MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
inline.cc
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/struct/inline.cc,v 1.37 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 "inline.h"
35 
36 /* InLineJoint - begin */
37 
38 /* Costruttore non banale */
39 InLineJoint::InLineJoint(unsigned int uL, const DofOwner* pDO,
40  const StructNode* pN1, const StructNode* pN2,
41  const Mat3x3& RvTmp, const Vec3& pTmp, flag fOut)
42 : Elem(uL, fOut), Joint(uL, pDO, fOut),
43 pNode1(pN1), pNode2(pN2), Rv(RvTmp), p(pTmp), F(Zero3)
44 {
45  NO_OP;
46 };
47 
48 
49 InLineJoint::~InLineJoint(void)
50 {
51  NO_OP;
52 }
53 
54 
55 DofOrder::Order
56 InLineJoint::GetEqType(unsigned int i) const
57 {
58  ASSERTMSGBREAK(i < iGetNumDof(),
59  "INDEX ERROR in InLineJoint::GetEqType");
60  return DofOrder::ALGEBRAIC;
61 }
62 
63 
64 /* Contributo al file di restart */
65 std::ostream& InLineJoint::Restart(std::ostream& out) const
66 {
67  Joint::Restart(out) << ", in line, not implemented yet" << std::endl;
68  return out;
69 }
70 
71 
72 VariableSubMatrixHandler&
73 InLineJoint::AssJac(VariableSubMatrixHandler& WorkMat,
74  doublereal dCoef,
75  const VectorHandler& /* XCurr */ ,
76  const VectorHandler& /* XPrimeCurr */ )
77 {
78  DEBUGCOUTFNAME("InLineJoint::AssJac");
79  SparseSubMatrixHandler& WM = WorkMat.SetSparse();
80 
81  WM.ResizeReset(69, 0);
82 
83  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
84  integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
85  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
86  integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
87  integer iFirstReactionIndex = iGetFirstIndex();
88 
89  Vec3 x2mx1(pNode2->GetXCurr()-pNode1->GetXCurr());
90  Mat3x3 RvTmp(pNode1->GetRRef()*Rv);
91  Vec3 FTmp(RvTmp*(F*dCoef));
92 
93 
94  Vec3 Tmp1_1(RvTmp.GetVec(1).Cross(x2mx1));
95  Vec3 Tmp1_2(RvTmp.GetVec(2).Cross(x2mx1));
96  for(int iCnt = 1; iCnt <= 3; iCnt++) {
97  doublereal d = RvTmp.dGet(iCnt, 1);
98  WM.PutItem(iCnt, iNode1FirstMomIndex+iCnt,
99  iFirstReactionIndex+1, -d);
100  WM.PutItem(3+iCnt, iNode2FirstMomIndex+iCnt,
101  iFirstReactionIndex+1, d);
102 
103  WM.PutItem(6+iCnt, iFirstReactionIndex+1,
104  iNode1FirstPosIndex+iCnt, -d);
105  WM.PutItem(9+iCnt, iFirstReactionIndex+1,
106  iNode2FirstPosIndex+iCnt, d);
107 
108  d = RvTmp.dGet(iCnt, 2);
109  WM.PutItem(12+iCnt, iNode1FirstMomIndex+iCnt,
110  iFirstReactionIndex+2, -d);
111  WM.PutItem(15+iCnt, iNode2FirstMomIndex+iCnt,
112  iFirstReactionIndex+2, d);
113 
114  WM.PutItem(18+iCnt, iFirstReactionIndex+2,
115  iNode1FirstPosIndex+iCnt, -d);
116  WM.PutItem(21+iCnt, iFirstReactionIndex+2,
117  iNode2FirstPosIndex+iCnt, d);
118 
119  d = Tmp1_1.dGet(iCnt);
120  WM.PutItem(24+iCnt, iNode1FirstMomIndex+3+iCnt,
121  iFirstReactionIndex+1, d);
122 
123  WM.PutItem(27+iCnt, iFirstReactionIndex+1,
124  iNode1FirstPosIndex+3+iCnt, d);
125 
126  d = Tmp1_2.dGet(iCnt);
127  WM.PutItem(30+iCnt, iNode1FirstMomIndex+3+iCnt,
128  iFirstReactionIndex+2, d);
129 
130  WM.PutItem(33+iCnt, iFirstReactionIndex+2,
131  iNode1FirstPosIndex+3+iCnt, d);
132  }
133 
134  WM.PutCross(36+1, iNode1FirstMomIndex,
135  iNode1FirstPosIndex+3, FTmp);
136  WM.PutCross(42+1, iNode1FirstMomIndex+3,
137  iNode1FirstPosIndex, -FTmp);
138  WM.PutMat3x3(48+1, iNode1FirstMomIndex+3,
139  iNode1FirstPosIndex+3, Mat3x3(MatCrossCross, x2mx1, FTmp));
140  WM.PutCross(57+1, iNode1FirstMomIndex+3,
141  iNode2FirstPosIndex, FTmp);
142  WM.PutCross(63+1, iNode2FirstMomIndex,
143  iNode2FirstPosIndex+3, -FTmp);
144 
145  return WorkMat;
146 }
147 
148 
149 SubVectorHandler&
150 InLineJoint::AssRes(SubVectorHandler& WorkVec,
151  doublereal dCoef,
152  const VectorHandler& XCurr,
153  const VectorHandler& /* XPrimeCurr */ )
154 {
155  DEBUGCOUTFNAME("InLineJoint::AssRes");
156  WorkVec.ResizeReset(14);
157 
158  integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
159  integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
160  integer iFirstReactionIndex = iGetFirstIndex();
161 
162  /* Indici equazioni */
163  for (int iCnt = 1; iCnt <= 6; iCnt++) {
164  WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
165  WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
166  }
167 
168  /* Indice equazione vincolo */
169  WorkVec.PutRowIndex(13, iFirstReactionIndex+1);
170  WorkVec.PutRowIndex(14, iFirstReactionIndex+2);
171 
172  Vec3 x2mx1(pNode2->GetXCurr()-pNode1->GetXCurr());
173  Mat3x3 RvTmp = pNode1->GetRCurr()*Rv;
174 
175  /* Aggiorna i dati propri */
176  F.Put(1, XCurr(iFirstReactionIndex+1));
177  F.Put(2, XCurr(iFirstReactionIndex+2));
178  Vec3 FTmp(RvTmp*F);
179 
180  WorkVec.Add(1, FTmp);
181  WorkVec.Add(4, x2mx1.Cross(FTmp)); /* ( = -p/\F) */
182  WorkVec.Sub(7, FTmp);
183 
184  ASSERT(dCoef != 0.);
185  WorkVec.PutCoef(13, (Rv.GetVec(1).Dot(p)-RvTmp.GetVec(1).Dot(x2mx1))/dCoef);
186  WorkVec.PutCoef(14, (Rv.GetVec(2).Dot(p)-RvTmp.GetVec(2).Dot(x2mx1))/dCoef);
187 
188  return WorkVec;
189 }
190 
191 void
192 InLineJoint::OutputPrepare(OutputHandler& OH)
193 {
194  if (bToBeOutput()) {
195 #ifdef USE_NETCDF
196  if (OH.UseNetCDF(OutputHandler::JOINTS)) {
197  std::string name;
198  OutputPrepare_int("inline", OH, name);
199  }
200 #endif // USE_NETCDF
201  }
202 }
203 
204 void InLineJoint::Output(OutputHandler& OH) const
205 {
206  if (bToBeOutput()) {
207  Mat3x3 RvTmp(pNode1->GetRCurr()*Rv);
208 #ifdef USE_NETCDF
209  if (OH.UseNetCDF(OutputHandler::JOINTS)) {
210  Var_F_local->put_rec(F.pGetVec(), OH.GetCurrentStep());
211  Var_M_local->put_rec(Zero3.pGetVec(), OH.GetCurrentStep());
212  Var_F_global->put_rec((RvTmp*F).pGetVec(), OH.GetCurrentStep());
213  Var_M_global->put_rec(Zero3.pGetVec(), OH.GetCurrentStep());
214  }
215 #endif // USE_NETCDF
216 
217 
218  if (OH.UseText(OutputHandler::JOINTS)) {
219 
220  Joint::Output(OH.Joints(), "inline", GetLabel(),
221  F, Zero3, RvTmp*F, Zero3) << std::endl;
222  // TODO: output relative position and orientation
223  }
224  }
225 }
226 
227 
228 /* Contributo allo jacobiano durante l'assemblaggio iniziale */
229 VariableSubMatrixHandler&
230 InLineJoint::InitialAssJac(VariableSubMatrixHandler& WorkMat,
231  const VectorHandler& XCurr)
232 {
233  DEBUGCOUTFNAME("InLineJoint::InitialAssJac");
234  FullSubMatrixHandler& WM = WorkMat.SetFull();
235  WM.ResizeReset(28, 28);
236 
237  /* Indici gdl */
238  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
239  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
240  integer iFirstReactionIndex = iGetFirstIndex();
241  integer iReactionPrimeIndex = iFirstReactionIndex+2;
242 
243  /* Indici equazioni nodi */
244  for(int iCnt = 1; iCnt <= 12; iCnt++) {
245  WM.PutRowIndex(iCnt, iNode1FirstPosIndex+iCnt);
246  WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
247  WM.PutRowIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
248  WM.PutColIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
249  }
250 
251  /* Indici vincoli */
252  for(int iCnt = 1; iCnt <= 4; iCnt++) {
253  WM.PutRowIndex(24+iCnt, iFirstReactionIndex+iCnt);
254  WM.PutColIndex(24+iCnt, iFirstReactionIndex+iCnt);
255  }
256 
257  /* Dati */
258  Vec3 x2mx1(pNode2->GetXCurr()-pNode1->GetXCurr());
259  Vec3 xp2mxp1(pNode2->GetVCurr()-pNode1->GetVCurr());
260  Vec3 Omega(pNode1->GetWRef());
261 
262  /* Aggiorna i dati propri */
263  Vec3 FPrime(XCurr(iReactionPrimeIndex+1),
264  XCurr(iReactionPrimeIndex+2),
265  0.);
266  Mat3x3 RvTmp(pNode1->GetRRef()*Rv);
267  Vec3 FTmp(RvTmp*F);
268  Vec3 FPrimeTmp(RvTmp*FPrime);
269 
270  Vec3 v1(RvTmp.GetVec(1));
271  Vec3 Tmp1_1(v1.Cross(x2mx1));
272  Vec3 Tmp2_1(Omega.Cross(v1));
273  Vec3 Tmp3_1((Omega.Cross(x2mx1)-xp2mxp1).Cross(v1));
274  Vec3 Tmp4_1(-(xp2mxp1.Cross(v1)+x2mx1.Cross(Tmp2_1)));
275  Vec3 v2(RvTmp.GetVec(2));
276  Vec3 Tmp1_2(v2.Cross(x2mx1));
277  Vec3 Tmp2_2(Omega.Cross(v2));
278  Vec3 Tmp3_2((Omega.Cross(x2mx1)-xp2mxp1).Cross(v2));
279  Vec3 Tmp4_2(-(xp2mxp1.Cross(v2)+x2mx1.Cross(Tmp2_2)));
280  for(int iCnt = 1; iCnt <= 3; iCnt++) {
281  doublereal d = v1.dGet(iCnt);
282  WM.PutCoef(iCnt, 25, -d);
283  WM.PutCoef(12+iCnt, 25, d);
284 
285  WM.PutCoef(25, iCnt, -d);
286  WM.PutCoef(25, 12+iCnt, d);
287 
288  WM.PutCoef(6+iCnt, 27, -d);
289  WM.PutCoef(18+iCnt, 27, d);
290 
291  WM.PutCoef(27, 6+iCnt, -d);
292  WM.PutCoef(27, 18+iCnt, d);
293 
294  d = v2.dGet(iCnt);
295  WM.PutCoef(iCnt, 26, -d);
296  WM.PutCoef(12+iCnt, 26, d);
297 
298  WM.PutCoef(26, iCnt, -d);
299  WM.PutCoef(26, 12+iCnt, d);
300 
301  WM.PutCoef(6+iCnt, 28, -d);
302  WM.PutCoef(18+iCnt, 28, d);
303 
304  WM.PutCoef(28, 6+iCnt, -d);
305  WM.PutCoef(28, 18+iCnt, d);
306 
307  d = Tmp1_1.dGet(iCnt);
308  WM.PutCoef(3+iCnt, 25, d);
309  WM.PutCoef(25, 3+iCnt, d);
310 
311  WM.PutCoef(27, 9+iCnt, d);
312  WM.PutCoef(9+iCnt, 27, d);
313 
314  d = Tmp1_2.dGet(iCnt);
315  WM.PutCoef(3+iCnt, 26, d);
316  WM.PutCoef(26, 3+iCnt, d);
317 
318  WM.PutCoef(28, 9+iCnt, d);
319  WM.PutCoef(9+iCnt, 28, d);
320 
321  d = Tmp2_1.dGet(iCnt);
322  WM.PutCoef(27, iCnt, -d);
323  WM.PutCoef(27, 12+iCnt, d);
324 
325  WM.PutCoef(6+iCnt, 25, -d);
326  WM.PutCoef(18+iCnt, 25, d);
327 
328  d = Tmp2_2.dGet(iCnt);
329  WM.PutCoef(28, iCnt, -d);
330  WM.PutCoef(28, 12+iCnt, d);
331 
332  WM.PutCoef(6+iCnt, 26, -d);
333  WM.PutCoef(18+iCnt, 26, d);
334 
335  d = Tmp3_1.dGet(iCnt);
336  WM.PutCoef(27, 3+iCnt, d);
337 
338  d = Tmp3_2.dGet(iCnt);
339  WM.PutCoef(28, 3+iCnt, d);
340 
341  d = Tmp4_1.dGet(iCnt);
342  WM.PutCoef(9+iCnt, 25, d);
343 
344  d = Tmp4_2.dGet(iCnt);
345  WM.PutCoef(9+iCnt, 27, d);
346  }
347 
348  Mat3x3 MTmp(MatCross, FTmp);
349  WM.Add(1, 4, MTmp);
350  WM.Add(4, 13, MTmp);
351 
352  WM.Add(7, 10, MTmp);
353  WM.Add(10, 19, MTmp);
354 
355  WM.Sub(4, 1, MTmp);
356  WM.Sub(13, 4, MTmp);
357 
358  WM.Sub(19, 10, MTmp);
359  WM.Sub(10, 7, MTmp);
360 
361  MTmp = Mat3x3(MatCrossCross, x2mx1, FTmp);
362  WM.Add(4, 4, MTmp);
363 
364  WM.Add(10, 10, MTmp);
365 
366  MTmp = Mat3x3(MatCrossCross, Omega, FTmp) + Mat3x3(MatCross, FPrimeTmp);
367  WM.Add(7, 4, MTmp);
368  WM.Sub(19, 4, MTmp);
369 
370  MTmp = Mat3x3(MatCross, Omega.Cross(FTmp) + FPrimeTmp);
371  WM.Sub(10, 1, MTmp);
372  WM.Add(10, 13, MTmp);
373 
374  MTmp = Mat3x3((Mat3x3(MatCross, xp2mxp1) + Mat3x3(MatCrossCross, x2mx1, Omega))*Mat3x3(MatCross, FTmp)
375  + Mat3x3(MatCrossCross, x2mx1, FPrimeTmp));
376  WM.Add(10, 4, MTmp);
377 
378  return WorkMat;
379 }
380 
381 
382 /* Contributo al residuo durante l'assemblaggio iniziale */
383 SubVectorHandler&
384 InLineJoint::InitialAssRes(SubVectorHandler& WorkVec,
385  const VectorHandler& XCurr)
386 {
387  DEBUGCOUTFNAME("InLineJoint::InitialAssRes");
388  WorkVec.ResizeReset(28);
389 
390  /* Indici gdl */
391  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
392  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
393  integer iFirstReactionIndex = iGetFirstIndex();
394  integer iReactionPrimeIndex = iFirstReactionIndex+2;
395 
396  /* Indici equazioni nodi */
397  for(int iCnt = 1; iCnt <= 12; iCnt++) {
398  WorkVec.PutRowIndex(iCnt, iNode1FirstPosIndex+iCnt);
399  WorkVec.PutRowIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
400  }
401 
402  /* Indici equazioni vincoli */
403  WorkVec.PutRowIndex(25, iFirstReactionIndex+1);
404  WorkVec.PutRowIndex(26, iFirstReactionIndex+2);
405  WorkVec.PutRowIndex(27, iReactionPrimeIndex+1);
406  WorkVec.PutRowIndex(28, iReactionPrimeIndex+2);
407 
408  /* Dati */
409  Vec3 x2mx1(pNode2->GetXCurr()-pNode1->GetXCurr());
410  Vec3 xp2mxp1(pNode2->GetVCurr()-pNode1->GetVCurr());
411  Mat3x3 RvTmp(pNode1->GetRCurr()*Rv);
412  Vec3 Omega(pNode1->GetWCurr());
413 
414  /* Aggiorna i dati propri */
415  F.Put(1, XCurr(iFirstReactionIndex+1));
416  F.Put(2, XCurr(iFirstReactionIndex+2));
417  Vec3 FPrime(XCurr(iReactionPrimeIndex+1),
418  XCurr(iReactionPrimeIndex+2),
419  0.);
420  Vec3 FTmp(RvTmp*F);
421  Vec3 FPrimeTmp(RvTmp*FPrime);
422  Vec3 Tmp(Omega.Cross(FTmp)+FPrimeTmp);
423 
424  WorkVec.Add(1, FTmp);
425  WorkVec.Add(4, x2mx1.Cross(FTmp)); /* ( = -p/\F) */
426  WorkVec.Add(7, Tmp);
427  WorkVec.Add(10, xp2mxp1.Cross(FTmp)+x2mx1.Cross(Tmp));
428  WorkVec.Sub(13, FTmp);
429  WorkVec.Sub(19, Tmp);
430 
431  WorkVec.PutCoef(25, Rv.GetVec(1).Dot(p)-RvTmp.GetVec(1).Dot(x2mx1));
432  WorkVec.PutCoef(26, Rv.GetVec(2).Dot(p)-RvTmp.GetVec(2).Dot(x2mx1));
433  WorkVec.PutCoef(27, x2mx1.Dot(RvTmp.GetVec(1).Cross(Omega))-RvTmp.GetVec(1).Dot(xp2mxp1));
434  WorkVec.PutCoef(28, x2mx1.Dot(RvTmp.GetVec(2).Cross(Omega))-RvTmp.GetVec(2).Dot(xp2mxp1));
435 
436  return WorkVec;
437 }
438 
439 /* InLineJoint - end */
440 
441 
442 /* InLineWithOffsetJoint - begin */
443 
444 /* Costruttore non banale */
445 InLineWithOffsetJoint::InLineWithOffsetJoint(unsigned int uL,
446  const DofOwner* pDO,
447  const StructNode* pN1,
448  const StructNode* pN2,
449  const Mat3x3& RvTmp,
450  const Vec3& pTmp,
451  const Vec3& qTmp,
452  flag fOut)
453 : Elem(uL, fOut), Joint(uL, pDO, fOut),
454 pNode1(pN1), pNode2(pN2), Rv(RvTmp), p(pTmp), q(qTmp), F(Zero3)
455 {
456  NO_OP;
457 };
458 
459 
460 InLineWithOffsetJoint::~InLineWithOffsetJoint(void)
461 {
462  NO_OP;
463 }
464 
465 
466 /* Contributo al file di restart */
467 std::ostream& InLineWithOffsetJoint::Restart(std::ostream& out) const
468 {
469  Joint::Restart(out) << ", in line, not implemented yet" << std::endl;
470  return out;
471 }
472 
473 
474 VariableSubMatrixHandler&
475 InLineWithOffsetJoint::AssJac(VariableSubMatrixHandler& WorkMat,
476  doublereal dCoef,
477  const VectorHandler& /* XCurr */ ,
478  const VectorHandler& /* XPrimeCurr */ )
479 {
480  DEBUGCOUTFNAME("InLineWithOffsetJoint::AssJac");
481  SparseSubMatrixHandler& WM = WorkMat.SetSparse();
482 
483  WM.ResizeReset(108, 0);
484 
485  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
486  integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
487  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
488  integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
489  integer iFirstReactionIndex = iGetFirstIndex();
490 
491  Vec3 qTmp(pNode2->GetRCurr()*q);
492  Vec3 x2qmx1(pNode2->GetXCurr()+qTmp-pNode1->GetXCurr());
493  Mat3x3 RvTmp(pNode1->GetRRef()*Rv);
494  Vec3 FTmp(RvTmp*(F*dCoef));
495 
496 
497  Vec3 Tmp1_1(RvTmp.GetVec(1).Cross(x2qmx1));
498  Vec3 Tmp1_2(RvTmp.GetVec(2).Cross(x2qmx1));
499  Vec3 Tmp2_1(qTmp.Cross(RvTmp.GetVec(1)));
500  Vec3 Tmp2_2(qTmp.Cross(RvTmp.GetVec(2)));
501  for(int iCnt = 1; iCnt <= 3; iCnt++) {
502  doublereal d = RvTmp.dGet(iCnt, 1);
503  WM.PutItem(iCnt, iNode1FirstMomIndex+iCnt,
504  iFirstReactionIndex+1, -d);
505  WM.PutItem(3+iCnt, iNode2FirstMomIndex+iCnt,
506  iFirstReactionIndex+1, d);
507 
508  WM.PutItem(6+iCnt, iFirstReactionIndex+1,
509  iNode1FirstPosIndex+iCnt, -d);
510  WM.PutItem(9+iCnt, iFirstReactionIndex+1,
511  iNode2FirstPosIndex+iCnt, d);
512 
513  d = RvTmp.dGet(iCnt, 2);
514  WM.PutItem(12+iCnt, iNode1FirstMomIndex+iCnt,
515  iFirstReactionIndex+2, -d);
516  WM.PutItem(15+iCnt, iNode2FirstMomIndex+iCnt,
517  iFirstReactionIndex+2, d);
518 
519  WM.PutItem(18+iCnt, iFirstReactionIndex+2,
520  iNode1FirstPosIndex+iCnt, -d);
521  WM.PutItem(21+iCnt, iFirstReactionIndex+2,
522  iNode2FirstPosIndex+iCnt, d);
523 
524  d = Tmp1_1.dGet(iCnt);
525  WM.PutItem(24+iCnt, iNode1FirstMomIndex+3+iCnt,
526  iFirstReactionIndex+1, d);
527 
528  WM.PutItem(27+iCnt, iFirstReactionIndex+1,
529  iNode1FirstPosIndex+3+iCnt, d);
530 
531  d = Tmp1_2.dGet(iCnt);
532  WM.PutItem(30+iCnt, iNode1FirstMomIndex+3+iCnt,
533  iFirstReactionIndex+2, d);
534 
535  WM.PutItem(33+iCnt, iFirstReactionIndex+2,
536  iNode1FirstPosIndex+3+iCnt, d);
537 
538  d = Tmp2_1.dGet(iCnt);
539  WM.PutItem(36+iCnt, iNode2FirstMomIndex+3+iCnt,
540  iFirstReactionIndex+1, d);
541 
542  WM.PutItem(39+iCnt, iFirstReactionIndex+1,
543  iNode2FirstPosIndex+3+iCnt, d);
544 
545  d = Tmp2_2.dGet(iCnt);
546  WM.PutItem(42+iCnt, iNode2FirstMomIndex+3+iCnt,
547  iFirstReactionIndex+2, d);
548 
549  WM.PutItem(45+iCnt, iFirstReactionIndex+2,
550  iNode2FirstPosIndex+3+iCnt, d);
551  }
552 
553  WM.PutCross(48+1, iNode1FirstMomIndex,
554  iNode1FirstPosIndex+3, FTmp);
555  WM.PutCross(54+1, iNode1FirstMomIndex+3,
556  iNode1FirstPosIndex, -FTmp);
557  WM.PutMat3x3(60+1, iNode1FirstMomIndex+3,
558  iNode1FirstPosIndex+3, Mat3x3(MatCrossCross, x2qmx1, FTmp));
559  WM.PutCross(69+1, iNode1FirstMomIndex+3,
560  iNode2FirstPosIndex, FTmp);
561  WM.PutCross(75+1, iNode2FirstMomIndex,
562  iNode2FirstPosIndex+3, -FTmp);
563 
564  Mat3x3 MTmp(MatCrossCross, FTmp, qTmp);
565  WM.PutMat3x3(81+1, iNode1FirstMomIndex+3,
566  iNode2FirstPosIndex+3, -MTmp);
567  WM.PutMat3x3(90+1, iNode2FirstMomIndex+3,
568  iNode2FirstPosIndex+3, -MTmp);
569 
570  WM.PutMat3x3(99+1, iNode2FirstMomIndex+3,
571  iNode1FirstPosIndex+3, Mat3x3(MatCrossCross, -qTmp, FTmp));
572 
573  return WorkMat;
574 }
575 
576 
577 SubVectorHandler&
578 InLineWithOffsetJoint::AssRes(SubVectorHandler& WorkVec,
579  doublereal dCoef,
580  const VectorHandler& XCurr,
581  const VectorHandler& /* XPrimeCurr */ )
582 {
583  DEBUGCOUTFNAME("InLineWithOffsetJoint::AssRes");
584  WorkVec.ResizeReset(14);
585 
586  integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
587  integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
588  integer iFirstReactionIndex = iGetFirstIndex();
589 
590  /* Indici equazioni */
591  for (int iCnt = 1; iCnt <= 6; iCnt++) {
592  WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
593  WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
594  }
595 
596  /* Indice equazione vincolo */
597  WorkVec.PutRowIndex(13, iFirstReactionIndex+1);
598  WorkVec.PutRowIndex(14, iFirstReactionIndex+2);
599 
600  Vec3 qTmp(pNode2->GetRCurr()*q);
601  Vec3 x2qmx1(pNode2->GetXCurr()+qTmp-pNode1->GetXCurr());
602  Mat3x3 RvTmp = pNode1->GetRCurr()*Rv;
603 
604  /* Aggiorna i dati propri */
605  F.Put(1, XCurr(iFirstReactionIndex+1));
606  F.Put(2, XCurr(iFirstReactionIndex+2));
607  Vec3 FTmp(RvTmp*F);
608 
609  WorkVec.Add(1, FTmp);
610  WorkVec.Add(4, x2qmx1.Cross(FTmp));
611  WorkVec.Sub(7, FTmp);
612  WorkVec.Sub(10, qTmp.Cross(FTmp));
613 
614  ASSERT(dCoef != 0.);
615  WorkVec.PutCoef(13, (Rv.GetVec(1).Dot(p)-RvTmp.GetVec(1).Dot(x2qmx1))/dCoef);
616  WorkVec.PutCoef(14, (Rv.GetVec(2).Dot(p)-RvTmp.GetVec(2).Dot(x2qmx1))/dCoef);
617 
618  return WorkVec;
619 }
620 
621 DofOrder::Order
622 InLineWithOffsetJoint::GetEqType(unsigned int i) const
623 {
624  ASSERTMSGBREAK((i>=0) and (i<15),
625  "INDEX ERROR in InLineWithOffsetJoint::GetEqType");
626  if ((i==13) or (i==14)) {
627  return DofOrder::ALGEBRAIC;
628  }
629  return DofOrder::DIFFERENTIAL;
630 }
631 
632 void InLineWithOffsetJoint::Output(OutputHandler& OH) const
633 {
634  if (bToBeOutput()) {
635  Mat3x3 RvTmp(pNode1->GetRCurr()*Rv);
636  Joint::Output(OH.Joints(), "inline", GetLabel(),
637  F, Zero3, RvTmp*F, Zero3) << std::endl;
638  }
639 }
640 
641 
642 /* Contributo allo jacobiano durante l'assemblaggio iniziale */
643 VariableSubMatrixHandler&
644 InLineWithOffsetJoint::InitialAssJac(VariableSubMatrixHandler& WorkMat,
645  const VectorHandler& XCurr)
646 {
647  DEBUGCOUTFNAME("InLineWithOffsetJoint::InitialAssJac");
648  FullSubMatrixHandler& WM = WorkMat.SetFull();
649  WM.ResizeReset(28, 28);
650 
651  /* Indici gdl */
652  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
653  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
654  integer iFirstReactionIndex = iGetFirstIndex();
655  integer iReactionPrimeIndex = iFirstReactionIndex+2;
656 
657  /* Indici equazioni nodi */
658  for(int iCnt = 1; iCnt <= 12; iCnt++) {
659  WM.PutRowIndex(iCnt, iNode1FirstPosIndex+iCnt);
660  WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
661  WM.PutRowIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
662  WM.PutColIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
663  }
664 
665  /* Indici vincoli */
666  for(int iCnt = 1; iCnt <= 4; iCnt++) {
667  WM.PutRowIndex(24+iCnt, iFirstReactionIndex+iCnt);
668  WM.PutColIndex(24+iCnt, iFirstReactionIndex+iCnt);
669  }
670 
671  /* Dati */
672  Vec3 Omega1(pNode1->GetWRef());
673  Vec3 Omega2(pNode2->GetWRef());
674  Mat3x3 RvTmp(pNode1->GetRRef()*Rv);
675  Vec3 qTmp(pNode2->GetRRef()*q);
676  Vec3 x2qmx1(pNode2->GetXCurr()+qTmp-pNode1->GetXCurr());
677  Vec3 xp2qmxp1(pNode2->GetVCurr()+Omega2.Cross(qTmp)-pNode1->GetVCurr());
678 
679  /* Aggiorna i dati propri */
680  Vec3 FPrime(XCurr(iReactionPrimeIndex+1),
681  XCurr(iReactionPrimeIndex+2),
682  0.);
683  Vec3 FTmp(RvTmp*F);
684  Vec3 FPrimeTmp(RvTmp*FPrime);
685 
686  Vec3 v1(RvTmp.GetVec(1));
687  Vec3 Tmp1_1(v1.Cross(x2qmx1));
688  Vec3 Tmp2_1(Omega1.Cross(v1));
689  Vec3 Tmp3_1((Omega1.Cross(x2qmx1)-xp2qmxp1).Cross(v1));
690  Vec3 Tmp4_1(-(xp2qmxp1.Cross(v1)+x2qmx1.Cross(Tmp2_1)));
691 
692  Vec3 Tmp5_1(qTmp.Cross(v1));
693  Vec3 Tmp6_1(qTmp.Cross(v1.Cross(Omega2-Omega1)));
694  Vec3 Tmp7_1(qTmp.Cross(Omega1.Cross(v1))-v1.Cross(Omega2.Cross(qTmp)));
695 
696  Vec3 v2(RvTmp.GetVec(2));
697  Vec3 Tmp1_2(v2.Cross(x2qmx1));
698  Vec3 Tmp2_2(Omega1.Cross(v2));
699  Vec3 Tmp3_2((Omega1.Cross(x2qmx1)-xp2qmxp1).Cross(v2));
700  Vec3 Tmp4_2(-(xp2qmxp1.Cross(v2)+x2qmx1.Cross(Tmp2_2)));
701 
702  Vec3 Tmp5_2(qTmp.Cross(v2));
703  Vec3 Tmp6_2(qTmp.Cross(v2.Cross(Omega2-Omega1)));
704  Vec3 Tmp7_2(qTmp.Cross(Omega1.Cross(v2))-v2.Cross(Omega2.Cross(qTmp)));
705 
706  for(int iCnt = 1; iCnt <= 3; iCnt++) {
707  doublereal d = v1.dGet(iCnt);
708  WM.PutCoef(iCnt, 25, -d);
709  WM.PutCoef(12+iCnt, 25, d);
710 
711  WM.PutCoef(25, iCnt, -d);
712  WM.PutCoef(25, 12+iCnt, d);
713 
714  WM.PutCoef(6+iCnt, 27, -d);
715  WM.PutCoef(18+iCnt, 27, d);
716 
717  WM.PutCoef(27, 6+iCnt, -d);
718  WM.PutCoef(27, 18+iCnt, d);
719 
720  d = v2.dGet(iCnt);
721  WM.PutCoef(iCnt, 26, -d);
722  WM.PutCoef(12+iCnt, 26, d);
723 
724  WM.PutCoef(26, iCnt, -d);
725  WM.PutCoef(26, 12+iCnt, d);
726 
727  WM.PutCoef(6+iCnt, 28, -d);
728  WM.PutCoef(18+iCnt, 28, d);
729 
730  WM.PutCoef(28, 6+iCnt, -d);
731  WM.PutCoef(28, 18+iCnt, d);
732 
733  d = Tmp1_1.dGet(iCnt);
734  WM.PutCoef(3+iCnt, 25, d);
735  WM.PutCoef(25, 3+iCnt, d);
736 
737  WM.PutCoef(27, 9+iCnt, d);
738  WM.PutCoef(9+iCnt, 27, d);
739 
740  d = Tmp1_2.dGet(iCnt);
741  WM.PutCoef(3+iCnt, 26, d);
742  WM.PutCoef(26, 3+iCnt, d);
743 
744  WM.PutCoef(28, 9+iCnt, d);
745  WM.PutCoef(9+iCnt, 28, d);
746 
747  d = Tmp2_1.dGet(iCnt);
748  WM.PutCoef(27, iCnt, -d);
749  WM.PutCoef(27, 12+iCnt, d);
750 
751  WM.PutCoef(6+iCnt, 25, -d);
752  WM.PutCoef(18+iCnt, 25, d);
753 
754  d = Tmp2_2.dGet(iCnt);
755  WM.PutCoef(28, iCnt, -d);
756  WM.PutCoef(28, 12+iCnt, d);
757 
758  WM.PutCoef(6+iCnt, 26, -d);
759  WM.PutCoef(18+iCnt, 26, d);
760 
761  d = Tmp3_1.dGet(iCnt);
762  WM.PutCoef(27, 3+iCnt, d);
763 
764  d = Tmp3_2.dGet(iCnt);
765  WM.PutCoef(28, 3+iCnt, d);
766 
767  d = Tmp4_1.dGet(iCnt);
768  WM.PutCoef(9+iCnt, 25, d);
769 
770  d = Tmp4_2.dGet(iCnt);
771  WM.PutCoef(9+iCnt, 27, d);
772 
773  d = Tmp5_1.dGet(iCnt);
774  WM.PutCoef(15+iCnt, 25, d);
775  WM.PutCoef(21+iCnt, 27, d);
776 
777  WM.PutCoef(25, 15+iCnt, d);
778  WM.PutCoef(27, 21+iCnt, d);
779 
780  d = Tmp5_2.dGet(iCnt);
781  WM.PutCoef(15+iCnt, 26, d);
782  WM.PutCoef(21+iCnt, 28, d);
783 
784  WM.PutCoef(26, 15+iCnt, d);
785  WM.PutCoef(28, 21+iCnt, d);
786 
787  d = Tmp6_1.dGet(iCnt);
788  WM.PutCoef(27, 15+iCnt, d);
789 
790  d = Tmp6_2.dGet(iCnt);
791  WM.PutCoef(28, 15+iCnt, d);
792 
793  d = Tmp7_1.dGet(iCnt);
794  WM.PutCoef(21+iCnt, 25, d);
795 
796  d = Tmp7_2.dGet(iCnt);
797  WM.PutCoef(21+iCnt, 26, d);
798  }
799 
800  Mat3x3 MTmp(MatCross, FTmp);
801  WM.Add(1, 4, MTmp);
802  WM.Add(4, 13, MTmp);
803 
804  WM.Add(7, 10, MTmp);
805  WM.Add(10, 19, MTmp);
806 
807  WM.Sub(4, 1, MTmp);
808  WM.Sub(13, 4, MTmp);
809 
810  WM.Sub(19, 10, MTmp);
811  WM.Sub(10, 7, MTmp);
812 
813  MTmp = Mat3x3(MatCrossCross, x2qmx1, FTmp);
814  WM.Add(4, 4, MTmp);
815 
816  WM.Add(10, 10, MTmp);
817 
818  MTmp = Mat3x3(MatCrossCross, Omega1, FTmp) + Mat3x3(MatCross, FPrimeTmp);
819  WM.Add(7, 4, MTmp);
820  WM.Sub(19, 4, MTmp);
821 
822  MTmp = Mat3x3(MatCross, Omega1.Cross(FTmp) + FPrimeTmp);
823  WM.Sub(10, 1, MTmp);
824  WM.Add(10, 13, MTmp);
825 
826  MTmp = Mat3x3((Mat3x3(MatCross, xp2qmxp1) + Mat3x3(MatCrossCross, x2qmx1, Omega1))*Mat3x3(MatCross, FTmp)
827  + Mat3x3(MatCrossCross, x2qmx1, FPrimeTmp));
828  WM.Add(10, 4, MTmp);
829 
830  MTmp = Mat3x3(MatCrossCross, FTmp, qTmp);
831  WM.Add(16, 16, MTmp);
832  WM.Add(22, 22, MTmp);
833 
834  WM.Sub(4, 16, MTmp);
835  WM.Sub(10, 22, MTmp);
836 
837  MTmp = MTmp.Transpose();
838  WM.Add(16, 4, MTmp);
839  WM.Add(22, 10, MTmp);
840 
841  MTmp = (Mat3x3(MatCrossCross, FTmp, Omega2) + Mat3x3(MatCross, Omega1.Cross(FTmp) + FPrimeTmp))*Mat3x3(MatCross, qTmp);
842  WM.Add(22, 16, MTmp);
843  WM.Sub(10, 16, MTmp);
844 
845  MTmp = Mat3x3(MatCrossCross, qTmp.Cross(Omega2), FTmp)
846  - Mat3x3(MatCross, qTmp)*(Mat3x3(MatCrossCross, Omega1, FTmp) + Mat3x3(MatCross, FPrimeTmp));
847  WM.Add(22, 4, MTmp);
848 
849  return WorkMat;
850 }
851 
852 
853 /* Contributo al residuo durante l'assemblaggio iniziale */
854 SubVectorHandler&
855 InLineWithOffsetJoint::InitialAssRes(SubVectorHandler& WorkVec,
856  const VectorHandler& XCurr)
857 {
858  DEBUGCOUTFNAME("InLineWithOffsetJoint::InitialAssRes");
859  WorkVec.ResizeReset(28);
860 
861  /* Indici gdl */
862  integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
863  integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
864  integer iFirstReactionIndex = iGetFirstIndex();
865  integer iReactionPrimeIndex = iFirstReactionIndex+2;
866 
867  /* Indici equazioni nodi */
868  for(int iCnt = 1; iCnt <= 12; iCnt++) {
869  WorkVec.PutRowIndex(iCnt, iNode1FirstPosIndex+iCnt);
870  WorkVec.PutRowIndex(12+iCnt, iNode2FirstPosIndex+iCnt);
871  }
872 
873  /* Indici equazioni vincoli */
874  WorkVec.PutRowIndex(25, iFirstReactionIndex+1);
875  WorkVec.PutRowIndex(26, iFirstReactionIndex+2);
876  WorkVec.PutRowIndex(27, iReactionPrimeIndex+1);
877  WorkVec.PutRowIndex(28, iReactionPrimeIndex+2);
878 
879  /* Dati */
880  Mat3x3 RvTmp(pNode1->GetRCurr()*Rv);
881  Vec3 qTmp(pNode2->GetRCurr()*q);
882  Vec3 Omega1(pNode1->GetWCurr());
883  Vec3 Omega2(pNode2->GetWCurr());
884  Vec3 x2qmx1(pNode2->GetXCurr()+qTmp-pNode1->GetXCurr());
885  Vec3 xp2qmxp1(pNode2->GetVCurr()+Omega2.Cross(qTmp)-pNode1->GetVCurr());
886 
887  /* Aggiorna i dati propri */
888  F.Put(1, XCurr(iFirstReactionIndex+1));
889  F.Put(2, XCurr(iFirstReactionIndex+2));
890  Vec3 FPrime(XCurr(iReactionPrimeIndex+1),
891  XCurr(iReactionPrimeIndex+2),
892  0.);
893  Vec3 FTmp(RvTmp*F);
894  Vec3 FPrimeTmp(RvTmp*FPrime);
895  Vec3 Tmp(Omega1.Cross(FTmp)+FPrimeTmp);
896 
897  WorkVec.Add(1, FTmp);
898  WorkVec.Add(4, x2qmx1.Cross(FTmp)); /* ( = -p/\F) */
899  WorkVec.Add(7, Tmp);
900  WorkVec.Add(10, xp2qmxp1.Cross(FTmp)+x2qmx1.Cross(Tmp));
901  WorkVec.Sub(13, FTmp);
902  WorkVec.Sub(16, qTmp.Cross(FTmp));
903  WorkVec.Sub(19, Tmp);
904  WorkVec.Sub(22, qTmp.Cross(Tmp)+(Omega2.Cross(qTmp)).Cross(FTmp));
905 
906  WorkVec.PutCoef(25, Rv.GetVec(1).Dot(p)-RvTmp.GetVec(1).Dot(x2qmx1));
907  WorkVec.PutCoef(26, Rv.GetVec(2).Dot(p)-RvTmp.GetVec(2).Dot(x2qmx1));
908  WorkVec.PutCoef(27, x2qmx1.Dot(RvTmp.GetVec(1).Cross(Omega1))-RvTmp.GetVec(1).Dot(xp2qmxp1));
909  WorkVec.PutCoef(28, x2qmx1.Dot(RvTmp.GetVec(2).Cross(Omega1))-RvTmp.GetVec(2).Dot(xp2qmxp1));
910 
911  return WorkVec;
912 }
913 
914 /* InLineWithOffsetJoint - end */
915 
InLineWithOffsetJoint::p
const Vec3 p
Definition: inline.h:137
FullSubMatrixHandler::PutColIndex
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
SparseSubMatrixHandler::PutMat3x3
void PutMat3x3(integer iSubIt, integer iFirstRow, integer iFirstCol, const Mat3x3 &m)
Definition: submat.cc:1331
Zero3
const Vec3 Zero3(0., 0., 0.)
Vec3::Cross
Vec3 Cross(const Vec3 &v) const
Definition: matvec3.h:218
ASSERTMSGBREAK
#define ASSERTMSGBREAK(expr, msg)
Definition: myassert.h:222
flag
long int flag
Definition: mbdyn.h:43
StructNode::GetRRef
virtual const Mat3x3 & GetRRef(void) const
Definition: strnode.h:1006
ToBeOutput::bToBeOutput
virtual bool bToBeOutput(void) const
Definition: output.cc:890
Vec3
Definition: matvec3.h:98
DEBUGCOUTFNAME
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
VectorHandler::ResizeReset
virtual void ResizeReset(integer)
Definition: vh.cc:55
MatCross
const MatCross_Manip MatCross
Definition: matvec3.cc:639
OutputHandler::UseNetCDF
bool UseNetCDF(int out) const
Definition: output.cc:491
VariableSubMatrixHandler::SetFull
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
StructNode::GetRCurr
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
Vec3::Dot
doublereal Dot(const Vec3 &v) const
Definition: matvec3.h:243
FullSubMatrixHandler::Add
void Add(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:209
InLineWithOffsetJoint::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: inline.cc:467
InLineJoint::InitialAssRes
SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: inline.cc:384
VectorHandler::Sub
virtual void Sub(integer iRow, const Vec3 &v)
Definition: vh.cc:78
InLineJoint::GetEqType
DofOrder::Order GetEqType(unsigned int i) const
Definition: inline.cc:56
InLineJoint::p
const Vec3 p
Definition: inline.h:45
FullSubMatrixHandler::PutCoef
void PutCoef(integer iRow, integer iCol, const doublereal &dCoef)
Definition: submat.h:672
SparseSubMatrixHandler::ResizeReset
void ResizeReset(integer iNewRow, integer iNewCol)
Definition: submat.cc:1084
StructNode::GetWRef
virtual const Vec3 & GetWRef(void) const
Definition: strnode.h:1024
NO_OP
#define NO_OP
Definition: myassert.h:74
SparseSubMatrixHandler::PutCross
void PutCross(integer iSubIt, integer iFirstRow, integer iFirstCol, const Vec3 &v)
Definition: submat.cc:1236
Mat3x3::GetVec
Vec3 GetVec(unsigned short int i) const
Definition: matvec3.h:893
InLineWithOffsetJoint::q
const Vec3 q
Definition: inline.h:138
InLineJoint::pNode2
const StructNode * pNode2
Definition: inline.h:42
SubVectorHandler::PutRowIndex
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
InLineWithOffsetJoint::Rv
const Mat3x3 Rv
Definition: inline.h:136
InLineJoint::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: inline.cc:65
SparseSubMatrixHandler::PutItem
void PutItem(integer iSubIt, integer iRow, integer iCol, const doublereal &dCoef)
Definition: submat.h:997
InLineWithOffsetJoint::InitialAssJac
VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: inline.cc:644
InLineWithOffsetJoint::pNode1
const StructNode * pNode1
Definition: inline.h:133
InLineJoint::InitialAssJac
VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: inline.cc:230
OutputHandler::GetCurrentStep
long GetCurrentStep(void) const
Definition: output.h:116
Vec3::dGet
const doublereal & dGet(unsigned short int iRow) const
Definition: matvec3.h:285
InLineWithOffsetJoint::Output
virtual void Output(OutputHandler &OH) const
Definition: inline.cc:632
StructDispNode::iGetFirstMomentumIndex
virtual integer iGetFirstMomentumIndex(void) const =0
StructDispNode::iGetFirstPositionIndex
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
StructNode::GetWCurr
virtual const Vec3 & GetWCurr(void) const
Definition: strnode.h:1030
InLineJoint::~InLineJoint
~InLineJoint(void)
Definition: inline.cc:49
Joint::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: joint.h:195
InLineWithOffsetJoint::GetEqType
DofOrder::Order GetEqType(unsigned int i) const
Definition: inline.cc:622
OutputHandler::Joints
std::ostream & Joints(void) const
Definition: output.h:443
InLineJoint::pNode1
const StructNode * pNode1
Definition: inline.h:41
InLineWithOffsetJoint::AssRes
SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: inline.cc:578
ASSERT
#define ASSERT(expression)
Definition: colamd.c:977
InLineWithOffsetJoint::InLineWithOffsetJoint
InLineWithOffsetJoint(unsigned int uL, const DofOwner *pDO, const StructNode *pN1, const StructNode *pN2, const Mat3x3 &RvTmp, const Vec3 &pTmp, const Vec3 &qTmp, flag fOut)
Definition: inline.cc:445
InLineWithOffsetJoint::InitialAssRes
SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: inline.cc:855
InLineJoint::F
Vec3 F
Definition: inline.h:47
VectorHandler::PutCoef
virtual void PutCoef(integer iRow, const doublereal &dCoef)=0
grad::Cross
VectorExpression< VectorCrossExpr< VectorLhsExpr, VectorRhsExpr >, 3 > Cross(const VectorExpression< VectorLhsExpr, 3 > &u, const VectorExpression< VectorRhsExpr, 3 > &v)
Definition: matvec.h:3248
Joint::OutputPrepare_int
virtual void OutputPrepare_int(const std::string &type, OutputHandler &OH, std::string &name)
Definition: joint.cc:107
StructDispNode::GetXCurr
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
VectorHandler::Add
virtual void Add(integer iRow, const Vec3 &v)
Definition: vh.cc:63
FullSubMatrixHandler::ResizeReset
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
Mat3x3::Transpose
Mat3x3 Transpose(void) const
Definition: matvec3.h:816
MatCrossCross
const MatCrossCross_Manip MatCrossCross
Definition: matvec3.cc:640
Elem
Definition: elem.h:75
FullSubMatrixHandler::PutRowIndex
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
InLineWithOffsetJoint::AssJac
VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: inline.cc:475
Vec3::pGetVec
const doublereal * pGetVec(void) const
Definition: matvec3.h:192
InLineJoint::AssJac
VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: inline.cc:73
InLineJoint::AssRes
SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: inline.cc:150
StructDispNode::GetVCurr
virtual const Vec3 & GetVCurr(void) const
Definition: strnode.h:322
FullSubMatrixHandler::Sub
void Sub(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:215
Joint
Definition: joint.h:50
InLineWithOffsetJoint::~InLineWithOffsetJoint
~InLineWithOffsetJoint(void)
Definition: inline.cc:460
VariableSubMatrixHandler::SetSparse
SparseSubMatrixHandler & SetSparse(void)
Definition: submat.h:1178
DofOwnerOwner::iGetFirstIndex
virtual integer iGetFirstIndex(void) const
Definition: dofown.h:127
doublereal
double doublereal
Definition: colamd.c:52
InLineJoint::OutputPrepare
void OutputPrepare(OutputHandler &OH)
Definition: inline.cc:192
Joint::Output
std::ostream & Output(std::ostream &out, const char *sJointName, unsigned int uLabel, const Vec3 &FLocal, const Vec3 &MLocal, const Vec3 &FGlobal, const Vec3 &MGlobal) const
Definition: joint.cc:138
InLineJoint::InLineJoint
InLineJoint(unsigned int uL, const DofOwner *pDO, const StructNode *pN1, const StructNode *pN2, const Mat3x3 &RvTmp, const Vec3 &pTmp, flag fOut)
Definition: inline.cc:39
integer
long int integer
Definition: colamd.c:51
WithLabel::GetLabel
unsigned int GetLabel(void) const
Definition: withlab.cc:62
InLineJoint::Rv
const Mat3x3 Rv
Definition: inline.h:44
InLineJoint::Output
virtual void Output(OutputHandler &OH) const
Definition: inline.cc:204
Vec3::Put
void Put(unsigned short int iRow, const doublereal &dCoef)
Definition: matvec3.h:276
InLineWithOffsetJoint::pNode2
const StructNode * pNode2
Definition: inline.h:134
OutputHandler::UseText
bool UseText(int out) const
Definition: output.cc:446
InLineJoint::iGetNumDof
virtual unsigned int iGetNumDof(void) const
Definition: inline.h:65