MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
pzbeam.cc
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/struct/pzbeam.cc,v 1.35 2017/01/12 14:46:43 masarati Exp $ */
2 /*
3  * MBDyn (C) is a multibody analysis code.
4  * http://www.mbdyn.org
5  *
6  * Copyright (C) 1996-2017
7  *
8  * Pierangelo Masarati <masarati@aero.polimi.it>
9  * Paolo Mantegazza <mantegazza@aero.polimi.it>
10  *
11  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
12  * via La Masa, 34 - 20156 Milano, Italy
13  * http://www.aero.polimi.it
14  *
15  * Changing this copyright notice is forbidden.
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation (version 2 of the License).
20  *
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */
31 
32 #include "mbconfig.h" /* This goes first in every *.c,*.cc file */
33 
34 #include "dataman.h"
35 #include "pzbeam.h"
36 
37 /* PiezoActuatorBeam - begin */
38 
39 /* Funzioni di calcolo delle matrici */
40 void PiezoActuatorBeam::AssStiffnessMat(FullSubMatrixHandler& WMA,
41  FullSubMatrixHandler& WMB,
42  doublereal dCoef,
43  const VectorHandler& XCurr,
44  const VectorHandler& XPrimeCurr)
45 {
46  DEBUGCOUT("Entering PiezoActuatorBeam::AssStiffnessMat()" << std::endl);
47 
48  Beam::AssStiffnessMat(WMA, WMB, dCoef, XCurr, XPrimeCurr);
49 
50  Mat3xN tmp1(iNumElec);
51  Mat3xN tmp2(iNumElec);
52 
53  tmp1.LeftMult(R[S_I]*dCoef, PiezoMat[STRAIN][S_I]);
54  WMA.Sub(1, 19, tmp1);
55  WMA.Add(7, 19, tmp1);
56  tmp2.LeftMult(Mat3x3(MatCross, p[S_I] - pNode[NODE1]->GetXCurr()), tmp1);
57  WMA.Add(4, 19, tmp2);
58  tmp2.LeftMult(Mat3x3(MatCross, p[S_I] - pNode[NODE2]->GetXCurr()), tmp1);
59  WMA.Sub(10, 19, tmp2);
60 
61  tmp1.LeftMult(R[S_I]*dCoef, PiezoMat[CURVAT][S_I]);
62  WMA.Sub(4, 19, tmp1);
63  WMA.Add(10, 19, tmp1);
64 
65  tmp1.LeftMult(R[SII]*dCoef, PiezoMat[STRAIN][SII]);
66  WMA.Sub(7, 19, tmp1);
67  WMA.Add(13, 19, tmp1);
68  tmp2.LeftMult(Mat3x3(MatCross, p[SII] - pNode[NODE2]->GetXCurr()), tmp1);
69  WMA.Add(10, 19, tmp2);
70  tmp2.LeftMult(Mat3x3(MatCross, p[SII] - pNode[NODE3]->GetXCurr()), tmp1);
71  WMA.Sub(16, 19, tmp2);
72 
73  tmp1.LeftMult(R[SII]*dCoef, PiezoMat[CURVAT][SII]);
74  WMA.Sub(10, 19, tmp1);
75  WMA.Add(16, 19, tmp1);
76 }
77 
78 
79 void PiezoActuatorBeam::AssStiffnessVec(SubVectorHandler& WorkVec,
80  doublereal dCoef,
81  const VectorHandler& XCurr,
82  const VectorHandler& XPrimeCurr)
83 {
84  DEBUGCOUT("Entering PiezoActuatorBeam::AssStiffnessVec()" << std::endl);
85 
86  /* Riceve il vettore gia' dimensionato e con gli indici a posto
87  * per scrivere il residuo delle equazioni di equilibrio dei tre nodi */
88 
89  /* Per la trattazione teorica, il riferimento e' il file ul-travi.tex
90  * (ora e' superato) */
91 
92  if (bFirstRes) {
93  /* fFirstRes = flag(0); AfterPredict ha gia' calcolato tutto */
94  } else {
95  for (integer iCnt = 1; iCnt <= iNumElec; iCnt++) {
96  V.Put(iCnt, pvElecDofs[iCnt-1]->dGetX());
97  }
98  }
99 
100  Beam::AssStiffnessVec(WorkVec, dCoef, XCurr, XPrimeCurr);
101 }
102 
103 
104 void PiezoActuatorBeam::AddInternalForces(Vec6& AzLoc, unsigned int iSez)
105 {
106  AzLoc += Vec6(PiezoMat[STRAIN][iSez]*V, PiezoMat[CURVAT][iSez]*V);
107 }
108 
109 
110 /* Costruttore normale */
111 PiezoActuatorBeam::PiezoActuatorBeam(
112  unsigned int uL,
113  const StructNode* pN1,
114  const StructNode* pN2,
115  const StructNode* pN3,
116  const Vec3& F1,
117  const Vec3& F2,
118  const Vec3& F3,
119  const Mat3x3& R1,
120  const Mat3x3& R2,
121  const Mat3x3& R3,
122  const Mat3x3& r_I, const Mat3x3& rII,
123  const ConstitutiveLaw6D* pD_I,
124  const ConstitutiveLaw6D* pDII,
125  int iEl,
126  const ScalarDifferentialNode **pEDof,
127  const Mat3xN& T_Ie, const Mat3xN& T_Ik,
128  const Mat3xN& TIIe, const Mat3xN& TIIk,
129  OrientationDescription ood,
130  flag fOut
131 ) : Elem(uL, fOut),
132 Beam(uL, pN1, pN2, pN3, F1, F2, F3, R1, R2, R3, r_I, rII, pD_I, pDII, ood, fOut),
133 iNumElec(iEl), pvElecDofs(pEDof), V(iEl)
134 {
135 #ifdef DEBUG
136  ASSERT(iNumElec > 0);
137  ASSERT(pvElecDofs != NULL);
138  for (int i = iNumElec; i-- > 0; ) {
139  ASSERT(pvElecDofs[i] != NULL);
140  }
141 #endif // DEBUG
142 
143  PiezoMat[STRAIN][S_I].Copy(T_Ie);
144  PiezoMat[STRAIN][SII].Copy(TIIe);
145  PiezoMat[CURVAT][S_I].Copy(T_Ik);
146  PiezoMat[CURVAT][SII].Copy(TIIk);
147 }
148 
149 
150 /* Distruttore banale */
151 PiezoActuatorBeam::~PiezoActuatorBeam(void)
152 {
153  SAFEDELETEARR(pvElecDofs);
154 }
155 
156 
157 /* Contributo al file di restart */
158 std::ostream&
159 PiezoActuatorBeam::Restart(std::ostream& out) const
160 {
161  Restart_(out);
162  return out << "/* piezoelectric actuator NOT IMPLEMENTED YET */ ;" << std::endl;
163 }
164 
165 
166 /* Dimensioni del workspace; sono 36 righe perche' se genera anche le
167  * * forze d'inerzia consistenti deve avere accesso alle righe di definizione
168  * * della quantita' di moto */
169 void PiezoActuatorBeam::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
170  if (bConsistentInertia) {
171  *piNumRows = 36;
172  } else {
173  *piNumRows = 18;
174  }
175  *piNumCols = 18+iNumElec;
176 }
177 
178 
179 /* Settings iniziali, prima della prima soluzione */
180 void PiezoActuatorBeam::SetValue(DataManager *pDM,
181  VectorHandler& X, VectorHandler& XP,
182  SimulationEntity::Hints *ph)
183 {
184  /* se proprio non serve, si puo' eliminare */
185  Beam::SetValue(pDM, X, XP, ph);
186 }
187 
188 
189 /* Prepara i parametri di riferimento dopo la predizione */
190 void PiezoActuatorBeam::AfterPredict(VectorHandler& X,
191  VectorHandler& XP)
192 {
193  // Calcola le deformazioni, aggiorna il legame costitutivo e crea la FDE
194 
195  for (integer iCnt = 1; iCnt <= iNumElec; iCnt++) {
196  V.Put(iCnt, pvElecDofs[iCnt-1]->dGetX());
197  }
198 
199  Beam::AfterPredict(X, XP);
200 }
201 
202 
203 /* assemblaggio jacobiano */
204 VariableSubMatrixHandler&
205 PiezoActuatorBeam::AssJac(VariableSubMatrixHandler& WorkMat,
206  doublereal dCoef,
207  const VectorHandler& XCurr,
208  const VectorHandler& XPrimeCurr)
209 {
210  DEBUGCOUT("Entering PiezoActuatorBeam::AssJac(); will result in call to AssStiffnessMat()" << std::endl);
211 
212  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
213  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
214  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
215  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
216  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
217  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
218 
219  FullSubMatrixHandler& WM = WorkMat.SetFull();
220 
221  /* Dimensiona la matrice, la azzera e pone gli indici corretti */
222  if(bConsistentInertia) {
223  WM.ResizeReset(36, 18+iNumElec);
224  } else {
225  WM.ResizeReset(18, 18+iNumElec);
226  }
227 
228  for (int iCnt = 1; iCnt <= 6; iCnt++) {
229  WM.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
230  WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
231  WM.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
232  WM.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
233  WM.PutRowIndex(12+iCnt, iNode3FirstMomIndex+iCnt);
234  WM.PutColIndex(12+iCnt, iNode3FirstPosIndex+iCnt);
235  }
236 
237  for (int iCnt = 1; iCnt <= iNumElec; iCnt++) {
238  WM.PutColIndex(18+iCnt, pvElecDofs[iCnt-1]->iGetFirstColIndex()+1);
239  }
240 
241  AssStiffnessMat(WM, WM, dCoef, XCurr, XPrimeCurr);
242 
243  if (bConsistentInertia) {
244  for (int iCnt = 1; iCnt <= 6; iCnt++) {
245  WM.PutRowIndex(18+iCnt, iNode1FirstPosIndex+iCnt);
246  WM.PutRowIndex(24+iCnt, iNode2FirstPosIndex+iCnt);
247  WM.PutRowIndex(30+iCnt, iNode3FirstPosIndex+iCnt);
248  }
249  Beam::AssInertiaMat(WM, WM, dCoef, XCurr, XPrimeCurr);
250  }
251 
252  return WorkMat;
253 }
254 
255 
256 /* Contributo allo jacobiano durante l'assemblaggio iniziale */
257 VariableSubMatrixHandler&
258 PiezoActuatorBeam::InitialAssJac(VariableSubMatrixHandler& WorkMat,
259  const VectorHandler& XCurr)
260 {
261  return Beam::InitialAssJac(WorkMat, XCurr);
262 }
263 
264 
265 /* Contributo al residuo durante l'assemblaggio iniziale */
266 SubVectorHandler&
267 PiezoActuatorBeam::InitialAssRes(SubVectorHandler& WorkVec,
268  const VectorHandler& XCurr)
269 {
270  return Beam::InitialAssRes(WorkVec, XCurr);
271 }
272 
273 /* PiezoActuatorBeam - end */
274 
275 
276 /* PiezoActuatorVEBeam - begin */
277 
278 /* Funzioni di calcolo delle matrici */
279 void PiezoActuatorVEBeam::AssStiffnessMat(FullSubMatrixHandler& WMA,
280  FullSubMatrixHandler& WMB,
281  doublereal dCoef,
282  const VectorHandler& XCurr,
283  const VectorHandler& XPrimeCurr)
284 {
285  DEBUGCOUT("Entering PiezoActuatorVEBeam::AssStiffnessMat()" << std::endl);
286 
287  ViscoElasticBeam::AssStiffnessMat(WMA, WMB, dCoef, XCurr, XPrimeCurr);
288 
289  Mat3xN tmp1(iNumElec);
290  Mat3xN tmp2(iNumElec);
291 
292  tmp1.LeftMult(R[S_I]*dCoef, PiezoMat[STRAIN][S_I]);
293  WMA.Sub(1, 19, tmp1);
294  WMA.Add(7, 19, tmp1);
295  tmp2.LeftMult(Mat3x3(MatCross, p[S_I] - pNode[NODE1]->GetXCurr()), tmp1);
296  WMA.Add(4, 19, tmp2);
297  tmp2.LeftMult(Mat3x3(MatCross, p[S_I] - pNode[NODE2]->GetXCurr()), tmp1);
298  WMA.Sub(10, 19, tmp2);
299 
300  tmp1.LeftMult(R[S_I]*dCoef, PiezoMat[CURVAT][S_I]);
301  WMA.Sub(4, 19, tmp1);
302  WMA.Add(10, 19, tmp1);
303 
304  tmp1.LeftMult(R[SII]*dCoef, PiezoMat[STRAIN][SII]);
305  WMA.Sub(7, 19, tmp1);
306  WMA.Add(13, 19, tmp1);
307  tmp2.LeftMult(Mat3x3(MatCross, p[SII] - pNode[NODE2]->GetXCurr()), tmp1);
308  WMA.Add(10, 19, tmp2);
309  tmp2.LeftMult(Mat3x3(MatCross, p[SII] - pNode[NODE3]->GetXCurr()), tmp1);
310  WMA.Sub(16, 19, tmp2);
311 
312  tmp1.LeftMult(R[SII]*dCoef, PiezoMat[CURVAT][SII]);
313  WMA.Sub(10, 19, tmp1);
314  WMA.Add(16, 19, tmp1);
315 }
316 
317 
318 void PiezoActuatorVEBeam::AssStiffnessVec(SubVectorHandler& WorkVec,
319  doublereal dCoef,
320  const VectorHandler& XCurr,
321  const VectorHandler& XPrimeCurr)
322 {
323  DEBUGCOUT("Entering PiezoActuatorVEBeam::AssStiffnessVec()" << std::endl);
324 
325  /* Riceve il vettore gia' dimensionato e con gli indici a posto
326  * per scrivere il residuo delle equazioni di equilibrio dei tre nodi */
327 
328  /* Per la trattazione teorica, il riferimento e' il file ul-travi.tex
329  * (ora e' superato) */
330 
331  if (bFirstRes) {
332  /* fFirstRes = flag(0); AfterPredict ha gia' calcolato tutto */
333  } else {
334  for (integer iCnt = 1; iCnt <= iNumElec; iCnt++) {
335  V.Put(iCnt, pvElecDofs[iCnt-1]->dGetX());
336  }
337  }
338 
339  ViscoElasticBeam::AssStiffnessVec(WorkVec, dCoef, XCurr, XPrimeCurr);
340 }
341 
342 
343 void PiezoActuatorVEBeam::AddInternalForces(Vec6& AzLoc, unsigned int iSez)
344 {
345  AzLoc += Vec6(PiezoMat[STRAIN][iSez]*V, PiezoMat[CURVAT][iSez]*V);
346 }
347 
348 
349 /* Costruttore normale */
350 PiezoActuatorVEBeam::PiezoActuatorVEBeam(
351  unsigned int uL,
352  const StructNode* pN1,
353  const StructNode* pN2,
354  const StructNode* pN3,
355  const Vec3& F1,
356  const Vec3& F2,
357  const Vec3& F3,
358  const Mat3x3& R1,
359  const Mat3x3& R2,
360  const Mat3x3& R3,
361  const Mat3x3& r_I,
362  const Mat3x3& rII,
363  const ConstitutiveLaw6D* pD_I,
364  const ConstitutiveLaw6D* pDII,
365  int iEl,
366  const ScalarDifferentialNode **pEDof,
367  const Mat3xN& T_Ie,
368  const Mat3xN& T_Ik,
369  const Mat3xN& TIIe,
370  const Mat3xN& TIIk,
371  OrientationDescription ood,
372  flag fOut
373 ) : Elem(uL, fOut),
374 ViscoElasticBeam(uL, pN1, pN2, pN3, F1, F2, F3, R1, R2, R3,
375  r_I, rII, pD_I, pDII, ood, fOut),
376 iNumElec(iEl), pvElecDofs(pEDof), V(iEl)
377 {
378 #ifdef DEBUG
379  ASSERT(iNumElec > 0);
380  ASSERT(pvElecDofs != NULL);
381  for (int i = iNumElec; i-- > 0; ) {
382  ASSERT(pvElecDofs[i] != NULL);
383  }
384 #endif /* DEBUG */
385 
386  PiezoMat[STRAIN][S_I].Copy(T_Ie);
387  PiezoMat[STRAIN][SII].Copy(TIIe);
388  PiezoMat[CURVAT][S_I].Copy(T_Ik);
389  PiezoMat[CURVAT][SII].Copy(TIIk);
390 }
391 
392 
393 /* Distruttore banale */
394 PiezoActuatorVEBeam::~PiezoActuatorVEBeam(void)
395 {
396  SAFEDELETEARR(pvElecDofs);
397 }
398 
399 
400 /* Contributo al file di restart */
401 std::ostream&
402 PiezoActuatorVEBeam::Restart(std::ostream& out) const
403 {
404  Restart_(out);
405  return out << "/* piezoelectric actuator NOT IMPLEMENTED YET */ ;" << std::endl;
406 }
407 
408 
409 /* Dimensioni del workspace; sono 36 righe perche' se genera anche le
410  * forze d'inerzia consistenti deve avere accesso alle righe di definizione
411  * della quantita' di moto */
412 void
413 PiezoActuatorVEBeam::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
414  if (bConsistentInertia) {
415  *piNumRows = 36;
416  } else {
417  *piNumRows = 18;
418  }
419  *piNumCols = 18+iNumElec;
420 }
421 
422 
423 /* Settings iniziali, prima della prima soluzione */
424 void PiezoActuatorVEBeam::SetValue(DataManager *pDM,
425  VectorHandler& X, VectorHandler& XP,
426  SimulationEntity::Hints *ph)
427 {
428  /* se proprio non serve, si puo' eliminare */
429  ViscoElasticBeam::SetValue(pDM, X, XP, ph);
430 }
431 
432 
433 /* Prepara i parametri di riferimento dopo la predizione */
434 void PiezoActuatorVEBeam::AfterPredict(VectorHandler& X,
435  VectorHandler& XP)
436 {
437  // Calcola le deformazioni, aggiorna il legame costitutivo e crea la FDE
438 
439  for (integer iCnt = 1; iCnt <= iNumElec; iCnt++) {
440  V.Put(iCnt, pvElecDofs[iCnt-1]->dGetX());
441  }
442 
443  ViscoElasticBeam::AfterPredict(X, XP);
444 }
445 
446 
447 /* assemblaggio jacobiano */
448 VariableSubMatrixHandler&
449 PiezoActuatorVEBeam::AssJac(VariableSubMatrixHandler& WorkMat,
450  doublereal dCoef,
451  const VectorHandler& XCurr,
452  const VectorHandler& XPrimeCurr)
453 {
454  DEBUGCOUT("Entering PiezoActuatorVEBeam::AssJac(); will result in call to AssStiffnessMat()" << std::endl);
455 
456  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
457  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
458  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
459  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
460  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
461  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
462 
463  FullSubMatrixHandler& WM = WorkMat.SetFull();
464 
465  /* Dimensiona la matrice, la azzera e pone gli indici corretti */
466  if(bConsistentInertia) {
467  WM.ResizeReset(36, 18+iNumElec);
468  } else {
469  WM.ResizeReset(18, 18+iNumElec);
470  }
471 
472  for (int iCnt = 1; iCnt <= 6; iCnt++) {
473  WM.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
474  WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
475  WM.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
476  WM.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
477  WM.PutRowIndex(12+iCnt, iNode3FirstMomIndex+iCnt);
478  WM.PutColIndex(12+iCnt, iNode3FirstPosIndex+iCnt);
479  }
480 
481  for (int iCnt = 1; iCnt <= iNumElec; iCnt++) {
482  WM.PutColIndex(18+iCnt, pvElecDofs[iCnt-1]->iGetFirstColIndex()+1);
483  }
484 
485  AssStiffnessMat(WM, WM, dCoef, XCurr, XPrimeCurr);
486 
487  if (bConsistentInertia) {
488  for (int iCnt = 1; iCnt <= 6; iCnt++) {
489  WM.PutRowIndex(18+iCnt, iNode1FirstPosIndex+iCnt);
490  WM.PutRowIndex(24+iCnt, iNode2FirstPosIndex+iCnt);
491  WM.PutRowIndex(30+iCnt, iNode3FirstPosIndex+iCnt);
492  }
493  ViscoElasticBeam::AssInertiaMat(WM, WM, dCoef, XCurr, XPrimeCurr);
494  }
495 
496  return WorkMat;
497 }
498 
499 
500 /* Contributo allo jacobiano durante l'assemblaggio iniziale */
501 VariableSubMatrixHandler&
502 PiezoActuatorVEBeam::InitialAssJac(VariableSubMatrixHandler& WorkMat,
503  const VectorHandler& XCurr)
504 {
505  return ViscoElasticBeam::InitialAssJac(WorkMat, XCurr);
506 }
507 
508 
509 /* Contributo al residuo durante l'assemblaggio iniziale */
510 SubVectorHandler&
511 PiezoActuatorVEBeam::InitialAssRes(SubVectorHandler& WorkVec,
512  const VectorHandler& XCurr)
513 {
514  return ViscoElasticBeam::InitialAssRes(WorkVec, XCurr);
515 }
516 
517 /* PiezoActuatorVEBeam - end */
PiezoActuatorVEBeam::InitialAssRes
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: pzbeam.cc:511
ViscoElasticBeam::AssStiffnessVec
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:1522
FullSubMatrixHandler::PutColIndex
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
flag
long int flag
Definition: mbdyn.h:43
Mat3xN::LeftMult
const Mat3xN & LeftMult(const Mat3x3 &m)
Definition: matvec3n.cc:348
Beam::AssInertiaMat
virtual void AssInertiaMat(FullSubMatrixHandler &, FullSubMatrixHandler &, doublereal, const VectorHandler &, const VectorHandler &)
Definition: beam.h:232
Vec3
Definition: matvec3.h:98
PiezoActuatorVEBeam::InitialAssJac
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: pzbeam.cc:502
PiezoActuatorBeam::InitialAssRes
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: pzbeam.cc:267
MatCross
const MatCross_Manip MatCross
Definition: matvec3.cc:639
VariableSubMatrixHandler::SetFull
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
Beam::InitialAssRes
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: beam.cc:1265
FullSubMatrixHandler::Add
void Add(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:209
PiezoActuatorVEBeam::WorkSpaceDim
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: pzbeam.cc:413
PiezoActuatorVEBeam::AfterPredict
virtual void AfterPredict(VectorHandler &, VectorHandler &)
Definition: pzbeam.cc:434
PiezoActuatorBeam::PiezoActuatorBeam
PiezoActuatorBeam(const PiezoActuatorBeam &)
PiezoActuatorBeam::AfterPredict
virtual void AfterPredict(VectorHandler &, VectorHandler &)
Definition: pzbeam.cc:190
Beam::SetValue
void SetValue(DataManager *pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints *ph=0)
Definition: beam.cc:966
Beam::AssStiffnessVec
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:697
PiezoActuatorBeam::AssStiffnessVec
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:79
SAFEDELETEARR
#define SAFEDELETEARR(pnt)
Definition: mynewmem.h:713
PiezoActuatorVEBeam::PiezoActuatorVEBeam
PiezoActuatorVEBeam(const PiezoActuatorVEBeam &)
OrientationDescription
OrientationDescription
Definition: matvec3.h:1597
PiezoActuatorBeam::AssStiffnessMat
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:40
PiezoActuatorVEBeam::AddInternalForces
virtual void AddInternalForces(Vec6 &AzLoc, unsigned int iSez)
Definition: pzbeam.cc:343
SimulationEntity::Hints
std::vector< Hint * > Hints
Definition: simentity.h:89
Beam::AfterPredict
virtual void AfterPredict(VectorHandler &, VectorHandler &)
Definition: beam.cc:988
PiezoActuatorBeam::AddInternalForces
virtual void AddInternalForces(Vec6 &AzLoc, unsigned int iSez)
Definition: pzbeam.cc:104
PiezoActuatorVEBeam::pvElecDofs
const ScalarDifferentialNode ** pvElecDofs
Definition: pzbeam.h:158
ViscoElasticBeam::AssStiffnessMat
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:1404
PiezoActuatorBeam::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: pzbeam.cc:159
PiezoActuatorBeam::InitialAssJac
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: pzbeam.cc:258
PiezoActuatorVEBeam::AssStiffnessVec
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:318
PiezoActuatorBeam::WorkSpaceDim
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: pzbeam.cc:169
ViscoElasticBeam::SetValue
void SetValue(DataManager *pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints *ph=0)
Definition: beam.cc:1635
VecN::Put
void Put(integer i, const doublereal &d)
Definition: matvec3n.h:159
Vec6
Definition: matvec6.h:37
PiezoActuatorVEBeam::SetValue
void SetValue(DataManager *pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints *ph=0)
Definition: pzbeam.cc:424
Beam::R
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Beam
Definition: beam.h:56
PiezoActuatorVEBeam::AssJac
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:449
DEBUGCOUT
#define DEBUGCOUT(msg)
Definition: myassert.h:232
StructDispNode::iGetFirstMomentumIndex
virtual integer iGetFirstMomentumIndex(void) const =0
StructDispNode::iGetFirstPositionIndex
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
ViscoElasticBeam::AfterPredict
virtual void AfterPredict(VectorHandler &, VectorHandler &)
Definition: beam.cc:1657
ASSERT
#define ASSERT(expression)
Definition: colamd.c:977
Beam::pNode
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
FullSubMatrixHandler::ResizeReset
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
PiezoActuatorVEBeam::AssStiffnessMat
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:279
PiezoActuatorVEBeam::~PiezoActuatorVEBeam
virtual ~PiezoActuatorVEBeam(void)
Definition: pzbeam.cc:394
PiezoActuatorBeam::~PiezoActuatorBeam
virtual ~PiezoActuatorBeam(void)
Definition: pzbeam.cc:151
Beam::bFirstRes
bool bFirstRes
Definition: beam.h:197
Elem
Definition: elem.h:75
FullSubMatrixHandler::PutRowIndex
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
PiezoActuatorVEBeam::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: pzbeam.cc:402
Beam::InitialAssJac
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: beam.cc:1236
PiezoActuatorBeam::SetValue
void SetValue(DataManager *pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints *ph=0)
Definition: pzbeam.cc:180
FullSubMatrixHandler::Sub
void Sub(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:215
PiezoActuatorBeam::pvElecDofs
const ScalarDifferentialNode ** pvElecDofs
Definition: pzbeam.h:48
Mat3xN::Copy
const Mat3xN & Copy(const Mat3xN &m)
Definition: matvec3n.cc:407
doublereal
double doublereal
Definition: colamd.c:52
PiezoActuatorBeam::PiezoMat
Mat3xN PiezoMat[NUMDEFORM][NUMSEZ]
Definition: pzbeam.h:50
Beam::bConsistentInertia
const bool bConsistentInertia
Definition: beam.h:162
integer
long int integer
Definition: colamd.c:51
Beam::AssStiffnessMat
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:613
PiezoActuatorVEBeam::PiezoMat
Mat3xN PiezoMat[NUMDEFORM][NUMSEZ]
Definition: pzbeam.h:160
PiezoActuatorBeam::AssJac
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: pzbeam.cc:205
Beam::p
Vec3 p[NUMSEZ]
Definition: beam.h:187
Beam::Restart_
virtual std::ostream & Restart_(std::ostream &out) const
Definition: beam.cc:576