MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
actuator.cc
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/hydr/actuator.cc,v 1.41 2017/01/12 14:46:32 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 /*
33  * Copyright 1999-2000 Lamberto Puggelli <puggelli@tiscalinet.it>
34  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
35  */
36 
37 /*
38  * Attuatore idraulico.
39  *
40  * L'attuatore e' un elemento che applica le pressioni di due nodi idraulici
41  * a due nodi strutturali; allo stesso tempo usa la cinematica dei due nodi
42  * strutturali per determinare il bilancio di portata dei due nodi idraulici
43  * che rappresentano le due camere.
44  *
45  * L'elemento attuatore assume che il movimento avvenga lungo la direzione
46  * identificata da "axis" nel sistema di riferimento del nodo strutturale 1;
47  * quindi sono richiesti due vincoli strutturali di spostamento "inline" e
48  * "prismatic" per assicurare che l'unico movimento relativo tra i due nodi
49  * strutturali sia di scorrimento lungo un asse, avente la giacitura di "axis"
50  *
51  * Non sono previsti trafilamenti tra le due camere, in quanto possono essere
52  * riprodotti mettendo in parallelo un elemento di perdita di carico
53  * concentrata tra i due nodi idraulici.
54  *
55  * L'eventuale presenza di attrito ecc. e' delegata ai vincoli strutturali di
56  * contorno.
57  *
58  * La topologia dell'attuatore e' definita dagli offset "f1" e "f2",
59  * che rappresentano le posizioni, nei sistemi di riferimento
60  * dei rispettivi nodi, dei baricentri delle due superfici che si affacciano
61  * sulla camera 1; quindi i due punti coincidono quando la camera 1 e' a pacco.
62  * Tra i dati in ingresso figura anche una dimensione "dl", che rappresenta
63  * la massima estensione della camera 1, ovvero la lunghezza del cilindro
64  * a meno dello spessore del pistone.
65  * la dimensione della camera 2 e' data dall'area 2 per la differenza tra
66  * la dimensione massima dell'area 1 e la sua dimensione corrente.
67  *
68  * La forza scambiata e' calcolata come (p2*A2-p1*A1) e viene proiettata
69  * nella direzione "axis".
70  * Se gli offset non sono allineati con "axis", il loro prodotto vettore per
71  * la forza determina la coppia che e' applicata ai nodi strutturali.
72  * La portata e' calcolata come la derivata della massa presente in ogni
73  * camera, ed e' considerata positiva quando entra nella camera (nodo), quindi
74  *
75  * q = d/dt( rho * V )
76  *
77  * = d( rho )/dp * p' * V + rho * V'
78  *
79  * dove i volumi V1 e V2 sono, rispettivamente,
80  *
81  * V1 = A1 * d
82  *
83  * V2 = A2 * ( l - d )
84  *
85  * Per disporre delle derivate delle pressioni si sono usati due stati
86  * interni.
87  */
88 
89 #include "mbconfig.h" /* This goes first in every *.c,*.cc file */
90 
91 #include <cfloat>
92 #include <limits>
93 
94 #include "actuator.h"
95 
96 #define HF1 HF /* Hack to use the base member HF as HF1 in actuator */
97 
98 /* Actuator - begin */
99 
100 Actuator::Actuator(unsigned int uL, const DofOwner* pDO,
101  const PressureNode* p1, const PressureNode* p2,
102  const StructNode* pN1,
103  const StructNode* pN2,
104  const Vec3& f1Tmp,
105  const Vec3& f2Tmp,
106  const Vec3& axisTmp,
107  HydraulicFluid* hf1,
108  HydraulicFluid* hf2,
109  doublereal A_1, doublereal A_2,
110  doublereal l,
111  flag fOut)
112 : Elem(uL, fOut),
113 HydraulicElem(uL, pDO, hf1, fOut),
114 pNodeHyd1(p1), pNodeHyd2(p2),
115 HF2(hf2),
116 area1(A_1), area2(A_2),
117 dl(l), axis(axisTmp),
118 dp1(0.),
119 dp2(0.),
120 dpP1(0.),
121 dpP2(0.),
122 flow1(0.),
123 flow2(0.),
124 Vol1(0.),
125 Vol2(0.),
126 density1(0.),
127 density2(0.),
128 pNodeStr1(pN1), pNodeStr2(pN2), f1(f1Tmp), f2(f2Tmp)
129 {
130  ASSERT(pNodeHyd1 != NULL);
132  ASSERT(pNodeHyd2 != NULL);
134  ASSERT(area1 > std::numeric_limits<doublereal>::epsilon());
135  ASSERT(area2 > std::numeric_limits<doublereal>::epsilon());
136  ASSERT(dl > std::numeric_limits<doublereal>::epsilon());
137  ASSERT(pNodeStr1 != NULL);
139  ASSERT(pNodeStr2 != NULL);
141  ASSERT(HF2 != NULL);
142 }
143 
145 {
146  if (HF2 != NULL) {
147  SAFEDELETE(HF2);
148  }
149 }
150 
151 /* Tipo di elemento idraulico (usato solo per debug ecc.) */
153 {
155 }
156 
157 
158 /* Contributo al file di restart */
159 std::ostream& Actuator::Restart(std::ostream& out) const
160 {
161  return out << "Actuator not implemented yet!" << std::endl;
162 }
163 
164 
165 unsigned int Actuator::iGetNumDof(void) const
166 {
167  return 2;
168 }
169 
170 
171 DofOrder::Order Actuator::GetDofType(unsigned int i) const
172 {
173  return DofOrder::DIFFERENTIAL;
174 }
175 
176 
177 DofOrder::Order Actuator::GetEqType(unsigned int i) const
178 {
179  return DofOrder::DIFFERENTIAL;
180 }
181 
182 
183 void
184 Actuator::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
185 {
186  *piNumRows = 16;
187  *piNumCols = 16;
188 
189 }
190 
191 
194  doublereal dCoef,
195  const VectorHandler& XCurr,
196  const VectorHandler& XPrimeCurr)
197 {
198  DEBUGCOUT("Entering Actuator::AssJac()" << std::endl);
199 
200  FullSubMatrixHandler& WM = WorkMat.SetFull();
201  WM.ResizeReset(16, 16);
202 
203  /* Recupera gli indici */
204  integer iNode1FirstPosIndex = pNodeStr1->iGetFirstPositionIndex();
205  integer iNode1FirstMomIndex = pNodeStr1->iGetFirstMomentumIndex();
206  integer iNode2FirstPosIndex = pNodeStr2->iGetFirstPositionIndex();
207  integer iNode2FirstMomIndex = pNodeStr2->iGetFirstMomentumIndex();
208  integer iIndex = iGetFirstIndex();
209 
210  /* Setta gli indici della matrice */
211  for (int iCnt = 1; iCnt <= 6; iCnt++) {
212  WM.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
213  WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
214  WM.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
215  WM.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
216  }
217 
218  integer iNode1RowIndex = pNodeHyd1->iGetFirstRowIndex()+1;
219  integer iNode1ColIndex = pNodeHyd1->iGetFirstColIndex()+1;
220  integer iNode2RowIndex = pNodeHyd2->iGetFirstRowIndex()+1;
221  integer iNode2ColIndex = pNodeHyd2->iGetFirstColIndex()+1;
222 
223  WM.PutRowIndex(13, iNode1RowIndex);
224  WM.PutColIndex(13, iNode1ColIndex);
225  WM.PutRowIndex(14, iNode2RowIndex);
226  WM.PutColIndex(14, iNode2ColIndex);
227 
228  WM.PutRowIndex(15, iIndex+1);
229  WM.PutColIndex(15, iIndex+1);
230  WM.PutRowIndex(16, iIndex+2);
231  WM.PutColIndex(16, iIndex+2);
232 
233  doublereal p1 = pNodeHyd1->dGetX();
234  doublereal p2 = pNodeHyd2->dGetX();
235 
236  doublereal density1 = HF1->dGetDensity(p1);
238  doublereal densityDP1 = HF1->dGetDensityDPres(p1);
239  doublereal densityDP2 = HF2->dGetDensityDPres(p2);
240 
241  Vec3 x1(pNodeStr1->GetXCurr());
242  Vec3 x2(pNodeStr2->GetXCurr());
243  Mat3x3 R1(pNodeStr1->GetRRef());
244  Mat3x3 R2(pNodeStr2->GetRRef());
245 
246  Vec3 f1Tmp(R1*f1);
247  Vec3 f2Tmp(R2*f2);
248 
249  Vec3 v1(pNodeStr1->GetVCurr());
250  Vec3 v2(pNodeStr2->GetVCurr());
251  Vec3 Omega1(pNodeStr1->GetWRef());
252  Vec3 Omega2(pNodeStr2->GetWRef());
253 
254  Vec3 TmpAxis(R1*axis);
255 
256  Vec3 FHyd = TmpAxis*(area1*p1-area2*p2); /* forza idraulica (scalare) */
257 
258  doublereal dDist = TmpAxis.Dot(x2+f2Tmp-x1-f1Tmp);
259  doublereal dVel = TmpAxis.Dot(v2+Omega2.Cross(f2Tmp)-v1-Omega1.Cross(f1Tmp));
260 
261  /* prima equazione & terza equazione
262  * moltiplica deltagpuntonodo1 */
263  Mat3x3 JacMatWedge1(MatCross, FHyd*dCoef);
264  WM.Sub(1, 4, JacMatWedge1);
265  WM.Add(7, 4, JacMatWedge1);
266 
267  /* moltiplica deltaP1 e deltaP2 */
268  for (int iCnt = 1; iCnt <= 3; iCnt++) {
269  doublereal d = TmpAxis.dGet(iCnt);
270  doublereal d1 = d*area1;
271  doublereal d2 = d*area2;
272 
273  WM.PutCoef(iCnt, 13, d1);
274  WM.PutCoef(6+iCnt, 13, -d1);
275 
276 
277  WM.PutCoef(iCnt, 14, -d2);
278  WM.PutCoef(6+iCnt, 14, d2);
279  }
280 
281  /* seconda equazione moltiplica deltagpuntonodo1 */
282  WM.Sub(4, 4, Mat3x3(MatCross, f1Tmp.Cross(FHyd*dCoef)));
283 
284  /* moltiplica deltaP1 e deltaP2 */
285  Vec3 JacVec = f1Tmp.Cross(TmpAxis);
286  for (int iCnt = 1; iCnt <= 3; iCnt++) {
287  doublereal d = JacVec.dGet(iCnt);
288 
289  WM.PutCoef(3+iCnt, 13, d*area1);
290  WM.PutCoef(3+iCnt, 14, -d*area2);
291  }
292 
293  /* quarta equazione moltiplica deltagpuntonodo1 */
294  Mat3x3 TmpMat(MatCross, f2Tmp.Cross(FHyd*dCoef));
295  WM.Add(4, 4, TmpMat);
296  WM.Sub(4, 10, TmpMat);
297 
298  /* moltiplica deltaP1 e deltaP2 */
299  JacVec = f2Tmp.Cross(TmpAxis);
300  for (int iCnt = 1; iCnt <=3; iCnt++) {
301  doublereal d = JacVec.dGet(iCnt);
302 
303  WM.PutCoef(9+iCnt, 13, -d*area1);
304  WM.PutCoef(9+iCnt, 14, d*area2);
305  }
306 
307  /* inerzia del fluido */
308  WM.PutCoef(13, 15, -densityDP1*dDist*area1);
309  WM.PutCoef(13, 13, -densityDP1*dVel*area1);
310  WM.PutCoef(14, 16, -densityDP2*(dl-dDist)*area2);
311  WM.PutCoef(14, 14, densityDP2*dVel*area2);
312 
313  /* termini in spostamento e velocita' */
314  doublereal rho1A1 = (density1+dCoef*densityDP1*dpP1)*area1;
315  doublereal rho2A2 = (density2+dCoef*densityDP2*dpP2)*area2;
316 
317  for (int iCnt = 1; iCnt <= 3; iCnt++) {
318  doublereal d = TmpAxis.dGet(iCnt);
319  WM.PutCoef(13, iCnt, d*rho1A1);
320  WM.PutCoef(13, 6+iCnt, -d*rho1A1);
321 
322  WM.PutCoef(14, iCnt, -d*rho2A2);
323  WM.PutCoef(14, 6+iCnt, d*rho2A2);
324  }
325 
326  /* prima eq., nodo 1 */
327  JacVec = (TmpAxis.Cross(x2+f2Tmp-x1))*(densityDP1*dpP1*dCoef)
328  +(TmpAxis.Cross(f1Tmp+(x2+Omega2.Cross(f2Tmp)-x1)*dCoef))*density1;
329  for (int iCnt = 1; iCnt <= 3; iCnt++) {
330  WM.PutCoef(13, 3+iCnt, -JacVec.dGet(iCnt)*area1);
331  }
332 
333  /* prima eq., nodo 2 */
334  JacVec = (TmpAxis.Cross(f2Tmp))*(densityDP1*dpP1*dCoef)
335  +(TmpAxis.Cross(f2Tmp+(Omega2.Cross(f2Tmp))*dCoef))*density1;
336  for (int iCnt = 1; iCnt <= 3; iCnt++) {
337  WM.PutCoef(13, 9+iCnt, JacVec.dGet(iCnt)*area1);
338  }
339 
340  /* seconda eq., nodo 1 */
341  JacVec = (TmpAxis.Cross(x2+f2Tmp-x1))*(densityDP2*dpP2*dCoef)
342  +(TmpAxis.Cross(f1Tmp+(x2+Omega2.Cross(f2Tmp)-x1)*dCoef))*density2;
343  for (int iCnt = 1; iCnt <= 3; iCnt++) {
344  WM.PutCoef(14, 3+iCnt, JacVec.dGet(iCnt)*area2);
345  }
346 
347  /* seconda eq., nodo 2 */
348  JacVec = (TmpAxis.Cross(f2Tmp))*(densityDP2*dpP2*dCoef)
349  +(TmpAxis.Cross(f2Tmp+(Omega2.Cross(f2Tmp))*dCoef))*density2;
350  for (int iCnt = 1; iCnt <= 3; iCnt++) {
351  WM.PutCoef(14, 9+iCnt, JacVec.dGet(iCnt)*area2);
352  }
353 
354  /* definizione della pressione interna */
355 
356  WM.PutCoef(15, 15, dCoef);
357  WM.PutCoef(15, 13, -1.);
358 
359  WM.PutCoef(16, 16, dCoef);
360  WM.PutCoef(16, 14, -1.);
361 
362  return WorkMat;
363 }
364 
365 
368  doublereal dCoef,
369  const VectorHandler& XCurr,
370  const VectorHandler& XPrimeCurr)
371 
372 {
373  WorkVec.ResizeReset(16);
374 
375  integer iNode1RowIndex = pNodeHyd1->iGetFirstRowIndex()+1;
376  integer iNode2RowIndex = pNodeHyd2->iGetFirstRowIndex()+1;
377  integer iNode1FirstMomIndex = pNodeStr1->iGetFirstMomentumIndex();
378  integer iNode2FirstMomIndex = pNodeStr2->iGetFirstMomentumIndex();
379  integer iIndex = iGetFirstIndex();
380 
381  /* Setta gli indici */
382  for (int iCnt = 1; iCnt <= 6; iCnt++) {
383  WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
384  WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
385  }
386 
387  WorkVec.PutRowIndex(13, iNode1RowIndex);
388  WorkVec.PutRowIndex(14, iNode2RowIndex);
389 
390  WorkVec.PutRowIndex(15, iIndex+1);
391  WorkVec.PutRowIndex(16, iIndex+2);
392 
393  /* Dati */
394  doublereal p1 = pNodeHyd1->dGetX();
395  doublereal p2 = pNodeHyd2->dGetX();
396 
397  dp1 = XCurr(iIndex+1);
398  dp2 = XCurr(iIndex+2);
399 
400  dpP1 = XPrimeCurr(iIndex+1);
401  dpP2 = XPrimeCurr(iIndex+2);
402 
403  Vec3 x1(pNodeStr1->GetXCurr());
404  Vec3 x2(pNodeStr2->GetXCurr());
405  Mat3x3 R1(pNodeStr1->GetRCurr());
406  Mat3x3 R2(pNodeStr2->GetRCurr());
407 
408  Vec3 v1(pNodeStr1->GetVCurr());
409  Vec3 v2(pNodeStr2->GetVCurr());
410  Vec3 Omega1(pNodeStr1->GetWCurr());
411  Vec3 Omega2(pNodeStr2->GetWCurr());
412 
413  Vec3 f1Tmp(R1*f1);
414  Vec3 f2Tmp(R2*f2);
415 
416  density1 = HF1->dGetDensity(p1);
417  density2 = HF2->dGetDensity(p2);
418 
419  doublereal densityDP1 = HF1->dGetDensityDPres(p1);
420  doublereal densityDP2 = HF2->dGetDensityDPres(p2);
421 
422  /* asse nel sistema globale */
423  Vec3 TmpAxis(R1*axis);
424 
425  /* Calcolo della forza */
426  Vec3 FHyd = TmpAxis*(area1*p1-area2*p2);
427 
428  /* Calcolo delle portate */
429  /*
430  * FIXME: manca nello Jacobiano un pezzo della velocita'
431  * dell'attuatore dipendente dalla velocita' angolare dell'asse
432  */
433  Vec3 Dist = x2+f2Tmp-x1-f1Tmp;
434  doublereal dDist = TmpAxis*Dist;
435  doublereal dVel = TmpAxis.Dot(v2+Omega2.Cross(f2Tmp)-v1-Omega1.Cross(f1Tmp))
436  +Dist*(Omega1.Cross(TmpAxis));
437  flow1 = area1*(densityDP1*dpP1*dDist+density1*dVel);
438  flow2 = area2*(densityDP2*dpP2*(dl-dDist)-density2*dVel);
439  Vol1 = area1*dDist;
440  Vol2 = area2*(dl-dDist);
441 
442  /* Forze e coppia sul nodo strutturale 1 */
443  WorkVec.Sub(1, FHyd);
444  WorkVec.Sub(4, f1Tmp.Cross(FHyd));
445 
446  /* Forze e coppia sul nodo strutturale 2 */
447  WorkVec.Add(7, FHyd);
448  WorkVec.Add(10, f2Tmp.Cross(FHyd));
449 
450  /* Portata sul nodo idraulico 1 */
451  WorkVec.PutCoef(13, flow1);
452 
453  /* Portata sul nodo idraulico 2 */
454  WorkVec.PutCoef(14, flow2);
455 
456  /* pressioni */
457  WorkVec.PutCoef(15, p1-dp1);
458  WorkVec.PutCoef(16, p2-dp2);
459 
460  return WorkVec;
461 }
462 
463 
465 {
466  if (bToBeOutput()) {
467  std::ostream& out = OH.Hydraulic();
468  out << std::setw(8) << GetLabel()
469  << " " << flow1 << " " << flow2
470  << " " << dp1 << " " << dp2
471  << " " << dpP1 << " " << dpP2
472  << " " << Vol1 << " " << Vol2
473  << " " << density1 << " " << density2
474  << std::endl;
475  }
476 }
477 
478 
482 {
483  integer iIndex = iGetFirstIndex();
484  (doublereal&)dp1 = pNodeHyd1->dGetX();
485  (doublereal&)dp2 = pNodeHyd2->dGetX();
486  (doublereal&)dpP1 = 0.;
487  (doublereal&)dpP2 = 0.;
488 
489  X.PutCoef(iIndex+1, dp1);
490  X.PutCoef(iIndex+2, dp2);
491  XP.PutCoef(iIndex+1, dpP1);
492  XP.PutCoef(iIndex+2, dpP2);
493 }
494 
495 /* Actuator - end */
496 
SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: actuator.cc:367
doublereal dp2
Definition: actuator.h:58
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
Vec3 Cross(const Vec3 &v) const
Definition: matvec3.h:218
Actuator(unsigned int uL, const DofOwner *pD, const PressureNode *p1, const PressureNode *p2, const StructNode *pN1, const StructNode *pN2, const Vec3 &f1Tmp, const Vec3 &f2Tmp, const Vec3 &axisTmp, HydraulicFluid *hf1, HydraulicFluid *hf2, doublereal A_1, doublereal A_2, doublereal l, flag fOut)
Definition: actuator.cc:100
long int flag
Definition: mbdyn.h:43
virtual const Mat3x3 & GetRRef(void) const
Definition: strnode.h:1006
virtual bool bToBeOutput(void) const
Definition: output.cc:890
virtual HydraulicElem::Type GetHydraulicType(void) const
Definition: actuator.cc:152
const Vec3 f2
Definition: actuator.h:72
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: actuator.cc:479
Definition: matvec3.h:98
doublereal area2
Definition: actuator.h:50
virtual void ResizeReset(integer)
Definition: vh.cc:55
const MatCross_Manip MatCross
Definition: matvec3.cc:639
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
virtual Node::Type GetNodeType(void) const
Definition: strnode.cc:145
virtual doublereal dGetDensityDPres(void) const =0
doublereal Dot(const Vec3 &v) const
Definition: matvec3.h:243
void Add(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:209
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: actuator.cc:184
virtual std::ostream & Restart(std::ostream &out) const
Definition: actuator.cc:159
const PressureNode * pNodeHyd1
Definition: actuator.h:46
virtual void Sub(integer iRow, const Vec3 &v)
Definition: vh.cc:78
VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: actuator.cc:193
doublereal dp1
Definition: actuator.h:57
virtual DofOrder::Order GetDofType(unsigned int i) const
Definition: actuator.cc:171
void PutCoef(integer iRow, integer iCol, const doublereal &dCoef)
Definition: submat.h:672
virtual const Vec3 & GetWRef(void) const
Definition: strnode.h:1024
virtual void Output(OutputHandler &OH) const
Definition: actuator.cc:464
std::vector< Hint * > Hints
Definition: simentity.h:89
doublereal dl
Definition: actuator.h:52
doublereal Vol2
Definition: actuator.h:65
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
virtual doublereal dGetDensity(void) const =0
virtual const doublereal & dGetX(void) const
Definition: node.h:492
~Actuator(void)
Definition: actuator.cc:144
#define HF1
Definition: actuator.cc:96
doublereal flow2
Definition: actuator.h:63
const doublereal & dGet(unsigned short int iRow) const
Definition: matvec3.h:285
#define DEBUGCOUT(msg)
Definition: myassert.h:232
doublereal density2
Definition: actuator.h:67
virtual unsigned int iGetNumDof(void) const
Definition: actuator.cc:165
virtual integer iGetFirstRowIndex(void) const
Definition: node.cc:82
virtual integer iGetFirstMomentumIndex(void) const =0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
virtual const Vec3 & GetWCurr(void) const
Definition: strnode.h:1030
#define ASSERT(expression)
Definition: colamd.c:977
const Vec3 axis
Definition: actuator.h:55
virtual void PutCoef(integer iRow, const doublereal &dCoef)=0
const Vec3 f1
Definition: actuator.h:71
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
virtual void Add(integer iRow, const Vec3 &v)
Definition: vh.cc:63
doublereal density1
Definition: actuator.h:66
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
HydraulicFluid * HF2
Definition: actuator.h:48
Definition: elem.h:75
doublereal dpP1
Definition: actuator.h:59
virtual DofOrder::Order GetEqType(unsigned int i) const
Definition: actuator.cc:177
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
doublereal flow1
Definition: actuator.h:62
doublereal dpP2
Definition: actuator.h:60
virtual Node::Type GetNodeType(void) const
Definition: presnode.h:54
virtual const Vec3 & GetVCurr(void) const
Definition: strnode.h:322
void Sub(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:215
const StructNode * pNodeStr1
Definition: actuator.h:69
std::ostream & Hydraulic(void) const
Definition: output.h:492
virtual integer iGetFirstIndex(void) const
Definition: dofown.h:127
double doublereal
Definition: colamd.c:52
long int integer
Definition: colamd.c:51
unsigned int GetLabel(void) const
Definition: withlab.cc:62
doublereal Vol1
Definition: actuator.h:64
doublereal area1
Definition: actuator.h:49
const PressureNode * pNodeHyd2
Definition: actuator.h:47
#define SAFEDELETE(pnt)
Definition: mynewmem.h:710
const StructNode * pNodeStr2
Definition: actuator.h:70
virtual integer iGetFirstColIndex(void) const
Definition: node.cc:88