1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/elec/genel_.cc,v 1.15 2017/01/12 14:46:22 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 "genel_.h"
36
37 /* GenelClamp - begin */
38
GenelClamp(unsigned int uLabel,const DofOwner * pDO,const DriveCaller * pDC,const ScalarDof & sd,flag fOutput)39 GenelClamp::GenelClamp(unsigned int uLabel,
40 const DofOwner* pDO,
41 const DriveCaller* pDC,
42 const ScalarDof& sd,
43 flag fOutput)
44 : Elem(uLabel, fOutput),
45 Genel(uLabel, pDO, fOutput),
46 DriveOwner(pDC), SD(sd), dRct(0.)
47 {
48 NO_OP;
49 }
50
~GenelClamp(void)51 GenelClamp::~GenelClamp(void)
52 {
53 const Node2Scalar *pn2s;
54
55 pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
56 if (pn2s) {
57 SAFEDELETE(pn2s);
58 }
59 }
60
61 unsigned int
iGetNumDof(void) const62 GenelClamp::iGetNumDof(void) const
63 {
64 return 1;
65 }
66
67 /* esegue operazioni sui dof di proprieta' dell'elemento */
68 DofOrder::Order
GetDofType(unsigned int i) const69 GenelClamp::GetDofType(unsigned int i) const
70 {
71 ASSERT(i == 0);
72 return DofOrder::ALGEBRAIC;
73 }
74
75 /* esegue operazioni sui dof di proprieta' dell'elemento */
76 DofOrder::Order
GetEqType(unsigned int i) const77 GenelClamp::GetEqType(unsigned int i) const
78 {
79 ASSERT(i == 0);
80 return DofOrder::ALGEBRAIC;
81 }
82
83 /* Scrive il contributo dell'elemento al file di restart */
84 std::ostream&
Restart(std::ostream & out) const85 GenelClamp::Restart(std::ostream& out) const
86 {
87 return out;
88 }
89
90 /* Tipo di Genel */
91 Genel::Type
GetGenelType(void) const92 GenelClamp::GetGenelType(void) const
93 {
94 return Genel::CLAMP;
95 }
96
97 /* Dimensioni del workspace */
98 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const99 GenelClamp::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
100 {
101 *piNumRows = 2;
102 *piNumCols = 2;
103 }
104
105 void
Output(OutputHandler & OH) const106 GenelClamp::Output(OutputHandler& OH ) const
107 {
108 if (bToBeOutput()) {
109 std::ostream& out = OH.Genels();
110 out << std::setw(8) << GetLabel() << " " << dRct << std::endl;
111 }
112 }
113
114 /* assemblaggio jacobiano */
115 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)116 GenelClamp::AssJac(VariableSubMatrixHandler& WorkMat,
117 doublereal dCoef,
118 const VectorHandler& XCurr,
119 const VectorHandler& XPrimeCurr)
120 {
121 DEBUGCOUT("Entering GenelClamp::AssJac()" << std::endl);
122
123 SparseSubMatrixHandler& WM = WorkMat.SetSparse();
124 WM.Resize(2, 0);
125
126 integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
127 integer iColIndex = SD.pNode->iGetFirstColIndex() + 1;
128 integer iFirstReactionIndex = iGetFirstIndex() + 1;
129
130 WM.PutItem(1, iRowIndex, iFirstReactionIndex, 1.);
131 WM.PutItem(2, iFirstReactionIndex, iColIndex, 1.);
132
133 return WorkMat;
134 }
135
136 /* assemblaggio residuo */
137 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)138 GenelClamp::AssRes(SubVectorHandler& WorkVec,
139 doublereal dCoef,
140 const VectorHandler& XCurr,
141 const VectorHandler& XPrimeCurr)
142 {
143 DEBUGCOUT("Entering GenelClamp::AssRes()" << std::endl);
144
145 WorkVec.Resize(2);
146
147 integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
148 integer iFirstReactionIndex = iGetFirstIndex() + 1;
149
150 doublereal dVal = SD.pNode->dGetDofValue(1, SD.iOrder);
151 dRct = XCurr(iFirstReactionIndex);
152
153 WorkVec.PutItem(1, iRowIndex, -dRct);
154
155 doublereal dConstr = dGet() - dVal;
156 if (SD.iOrder == 0
157 && SD.pNode->GetDofType(0) == DofOrder::DIFFERENTIAL
158 && dCoef != 0.)
159 {
160 dConstr /= dCoef;
161 }
162 WorkVec.PutItem(2, iFirstReactionIndex, dConstr);
163
164 return WorkVec;
165 }
166
167 void
SetValue(DataManager * pDM,VectorHandler & X,VectorHandler & XP,SimulationEntity::Hints * ph)168 GenelClamp::SetValue(DataManager *pDM,
169 VectorHandler& X, VectorHandler& XP,
170 SimulationEntity::Hints *ph)
171 {
172 if (SD.iOrder == 0) {
173 X.PutCoef(SD.pNode->iGetFirstRowIndex() + 1, dGet());
174 } else if (SD.iOrder == 1) {
175 XP.PutCoef(SD.pNode->iGetFirstRowIndex() + 1, dGet());
176 }
177 }
178
179 /* *******PER IL SOLUTORE PARALLELO******** */
180 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
181 * utile per l'assemblaggio della matrice di connessione fra i dofs */
182 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const183 GenelClamp::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
184 connectedNodes.resize(1);
185 connectedNodes[0] = SD.pNode;
186 }
187 /* ************************************************ */
188
189 /* GenelClamp - end */
190
191
192 /* GenelDistance - begin */
193
GenelDistance(unsigned int uLabel,const DofOwner * pDO,const DriveCaller * pDC,const ScalarDof & sd1,const ScalarDof & sd2,flag fOutput)194 GenelDistance::GenelDistance(unsigned int uLabel,
195 const DofOwner* pDO,
196 const DriveCaller* pDC,
197 const ScalarDof& sd1,
198 const ScalarDof& sd2,
199 flag fOutput)
200 : Elem(uLabel, fOutput),
201 Genel(uLabel, pDO, fOutput),
202 DriveOwner(pDC), SD1(sd1), SD2(sd2), dRct(0.)
203 {
204 NO_OP;
205 }
206
~GenelDistance(void)207 GenelDistance::~GenelDistance(void)
208 {
209 const Node2Scalar *pn2s;
210
211 pn2s = dynamic_cast<const Node2Scalar *>(SD1.pNode);
212 if (pn2s) {
213 SAFEDELETE(pn2s);
214 }
215
216 pn2s = dynamic_cast<const Node2Scalar *>(SD2.pNode);
217 if (pn2s) {
218 SAFEDELETE(pn2s);
219 }
220 }
221
222 unsigned int
iGetNumDof(void) const223 GenelDistance::iGetNumDof(void) const
224 {
225 return 1;
226 }
227
228 DofOrder::Order
GetDofType(unsigned int i) const229 GenelDistance::GetDofType(unsigned int i ) const
230 {
231 ASSERT(i == 0);
232 return DofOrder::ALGEBRAIC;
233 }
234
235 /* Scrive il contributo dell'elemento al file di restart */
236 std::ostream&
Restart(std::ostream & out) const237 GenelDistance::Restart(std::ostream& out) const
238 {
239 return out;
240 }
241
242 /* Tipo di Genel */
243 Genel::Type
GetGenelType(void) const244 GenelDistance::GetGenelType(void) const
245 {
246 return Genel::DISTANCE;
247 }
248
249 /* Dimensioni del workspace */
250 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const251 GenelDistance::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
252 {
253 *piNumRows = 3;
254 *piNumCols = 3;
255 }
256
257 void
Output(OutputHandler & OH) const258 GenelDistance::Output(OutputHandler& OH) const
259 {
260 if (bToBeOutput()) {
261 std::ostream& out = OH.Genels();
262 out << std::setw(8) << GetLabel() << " " << dRct << std::endl;
263 }
264 }
265
266 /* assemblaggio jacobiano */
267 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)268 GenelDistance::AssJac(VariableSubMatrixHandler& WorkMat,
269 doublereal dCoef,
270 const VectorHandler& XCurr,
271 const VectorHandler& XPrimeCurr)
272 {
273 DEBUGCOUT("Entering GenelDistance::AssJac()" << std::endl);
274
275 SparseSubMatrixHandler& WM = WorkMat.SetSparse();
276 WM.ResizeReset(4, 0);
277
278 integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
279 integer iNode1ColIndex = SD1.pNode->iGetFirstColIndex() + 1;
280 integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
281 integer iNode2ColIndex = SD2.pNode->iGetFirstColIndex() + 1;
282 integer iFirstReactionIndex = iGetFirstIndex() + 1;
283
284 WM.PutItem(1, iNode1RowIndex, iFirstReactionIndex, -1.);
285 WM.PutItem(2, iNode2RowIndex, iFirstReactionIndex, 1.);
286
287 doublereal d = dCoef;
288 if ((SD1.iOrder == 0) && (SD2.iOrder == 0)) {
289 d = 1.;
290 }
291
292 if (SD1.iOrder == 1) {
293 WM.PutItem(3, iFirstReactionIndex, iNode1ColIndex, -1.);
294 } else {
295 WM.PutItem(3, iFirstReactionIndex, iNode1ColIndex, -d);
296 }
297
298 if (SD2.iOrder == 1) {
299 WM.PutItem(4, iFirstReactionIndex, iNode2ColIndex, 1.);
300 } else {
301 WM.PutItem(4, iFirstReactionIndex, iNode2ColIndex, d);
302 }
303
304 return WorkMat;
305 }
306
307 /* assemblaggio residuo */
308 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)309 GenelDistance::AssRes(SubVectorHandler& WorkVec,
310 doublereal dCoef,
311 const VectorHandler& XCurr,
312 const VectorHandler& XPrimeCurr)
313 {
314 DEBUGCOUT("Entering GenelDistance::AssRes()" << std::endl);
315
316 WorkVec.ResizeReset(3);
317
318 integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
319 integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
320 integer iFirstReactionIndex = iGetFirstIndex() + 1;
321
322 doublereal dVal1 = SD1.pNode->dGetDofValue(1, SD1.iOrder);
323 doublereal dVal2 = SD2.pNode->dGetDofValue(1, SD2.iOrder);
324 dRct = XCurr(iFirstReactionIndex);
325
326 WorkVec.PutItem(1, iNode1RowIndex, dRct);
327 WorkVec.PutItem(2, iNode2RowIndex, -dRct);
328
329 if ((SD1.iOrder == 0) && (SD2.iOrder == 0)) {
330 ASSERT(dCoef != 0.);
331 WorkVec.PutItem(3, iFirstReactionIndex,
332 (dGet() - dVal2 + dVal1)/dCoef);
333
334 } else {
335 WorkVec.PutItem(3, iFirstReactionIndex, dGet() - dVal2 + dVal1);
336 }
337
338 return WorkVec;
339 }
340
341 void
SetValue(DataManager * pDM,VectorHandler & X,VectorHandler & XP,SimulationEntity::Hints * ph)342 GenelDistance::SetValue(DataManager *pDM,
343 VectorHandler& X, VectorHandler& XP,
344 SimulationEntity::Hints *ph)
345 {
346 if (SD2.iOrder == 0) {
347 X.PutCoef(SD2.pNode->iGetFirstRowIndex() + 1,
348 dGet() - SD2.pNode->dGetX()
349 + SD1.pNode->dGetDofValue(1, SD1.iOrder));
350 } else if (SD2.iOrder == 1) {
351 XP.PutCoef(SD2.pNode->iGetFirstRowIndex() + 1,
352 dGet() - SD2.pNode->dGetXPrime()
353 + SD1.pNode->dGetDofValue(1, SD1.iOrder));
354 }
355 }
356
357 /* *******PER IL SOLUTORE PARALLELO******** */
358 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
359 * utile per l'assemblaggio della matrice di connessione fra i dofs */
360 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const361 GenelDistance::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
362 connectedNodes.resize(2);
363 connectedNodes[0] = SD1.pNode;
364 connectedNodes[1] = SD2.pNode;
365 }
366 /* ************************************************ */
367
368 /* GenelDistance - end */
369
370
371 /* GenelSpring - begin */
372
GenelSpring(unsigned int uLabel,const DofOwner * pDO,const ConstitutiveLaw1D * pCL,const ScalarDof & sd1,const ScalarDof & sd2,flag fOutput)373 GenelSpring::GenelSpring(unsigned int uLabel,
374 const DofOwner* pDO,
375 const ConstitutiveLaw1D* pCL,
376 const ScalarDof& sd1,
377 const ScalarDof& sd2,
378 flag fOutput)
379 : Elem(uLabel, fOutput),
380 Genel(uLabel, pDO, fOutput),
381 ConstitutiveLaw1DOwner(pCL), SD1(sd1), SD2(sd2), dVal(0.)
382 {
383 NO_OP;
384 }
385
~GenelSpring(void)386 GenelSpring::~GenelSpring(void)
387 {
388 const Node2Scalar *pn2s;
389
390 pn2s = dynamic_cast<const Node2Scalar *>(SD1.pNode);
391 if (pn2s) {
392 SAFEDELETE(pn2s);
393 }
394
395 pn2s = dynamic_cast<const Node2Scalar *>(SD2.pNode);
396 if (pn2s) {
397 SAFEDELETE(pn2s);
398 }
399 }
400
401 /* Scrive il contributo dell'elemento al file di restart */
402 std::ostream&
Restart(std::ostream & out) const403 GenelSpring::Restart(std::ostream& out) const
404 {
405 return out;
406 }
407
408 void
AfterConvergence(const VectorHandler & X,const VectorHandler & XP)409 GenelSpring::AfterConvergence(const VectorHandler& X,
410 const VectorHandler& XP)
411 {
412 ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
413 }
414
415 /* Tipo di Genel */
416 Genel::Type
GetGenelType(void) const417 GenelSpring::GetGenelType(void) const
418 {
419 return Genel::SPRING;
420 }
421
422 /* Dimensioni del workspace */
423 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const424 GenelSpring::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
425 {
426 *piNumRows = 2;
427 *piNumCols = 2;
428 }
429
430 /* assemblaggio jacobiano */
431 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)432 GenelSpring::AssJac(VariableSubMatrixHandler& WorkMat,
433 doublereal dCoef,
434 const VectorHandler& XCurr,
435 const VectorHandler& XPrimeCurr)
436 {
437 DEBUGCOUT("Entering GenelSpring::AssJac()" << std::endl);
438
439 FullSubMatrixHandler& WM = WorkMat.SetFull();
440 WM.ResizeReset(2, 2);
441
442 integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
443 integer iNode1ColIndex = SD1.pNode->iGetFirstColIndex() + 1;
444 integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
445 integer iNode2ColIndex = SD2.pNode->iGetFirstColIndex() + 1;
446
447 WM.PutRowIndex(1, iNode1RowIndex);
448 WM.PutColIndex(1, iNode1ColIndex);
449 WM.PutRowIndex(2, iNode2RowIndex);
450 WM.PutColIndex(2, iNode2ColIndex);
451
452 doublereal dFDE = GetFDE();
453
454 if (SD1.iOrder == 1) {
455 WM.PutCoef(1, 1, dFDE);
456 WM.PutCoef(2, 1, -dFDE);
457 } else {
458 WM.PutCoef(1, 1, dFDE*dCoef);
459 WM.PutCoef(2, 1, -dFDE*dCoef);
460 }
461
462 if (SD2.iOrder == 1) {
463 WM.PutCoef(1, 2, -dFDE);
464 WM.PutCoef(2, 2, dFDE);
465 } else {
466 WM.PutCoef(1, 2, -dFDE*dCoef);
467 WM.PutCoef(2, 2, dFDE*dCoef);
468 }
469
470 return WorkMat;
471 }
472
473 /* assemblaggio residuo */
474 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)475 GenelSpring::AssRes(SubVectorHandler& WorkVec,
476 doublereal dCoef,
477 const VectorHandler& XCurr,
478 const VectorHandler& XPrimeCurr)
479 {
480 DEBUGCOUT("Entering GenelSpring::AssRes()" << std::endl);
481
482 WorkVec.ResizeReset(2);
483
484 integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex()+1;
485 integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex()+1;
486
487 doublereal dVal1 = SD1.pNode->dGetDofValue(1, SD1.iOrder);
488 doublereal dVal2 = SD2.pNode->dGetDofValue(1, SD2.iOrder);
489
490 dVal = dVal2 - dVal1;
491 ConstitutiveLaw1DOwner::Update(dVal, 0.);
492
493 doublereal d = GetF();
494
495 WorkVec.PutItem(1, iNode1RowIndex, d);
496 WorkVec.PutItem(2, iNode2RowIndex, -d);
497
498 return WorkVec;
499 }
500
501 /* *******PER IL SOLUTORE PARALLELO******** */
502 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
503 * utile per l'assemblaggio della matrice di connessione fra i dofs */
504 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const505 GenelSpring::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
506 connectedNodes.resize(2);
507 connectedNodes[0] = SD1.pNode;
508 connectedNodes[1] = SD2.pNode;
509 }
510 /* ************************************************ */
511
512 /* GenelSpring - end */
513
514
515 /* GenelSpringSupport - begin */
516
GenelSpringSupport(unsigned int uLabel,const DofOwner * pDO,const ConstitutiveLaw1D * pCL,const ScalarDof & sd,doublereal X0,flag fOutput)517 GenelSpringSupport::GenelSpringSupport(unsigned int uLabel,
518 const DofOwner* pDO,
519 const ConstitutiveLaw1D* pCL,
520 const ScalarDof& sd, doublereal X0, flag fOutput)
521 : Elem(uLabel, fOutput),
522 Genel(uLabel, pDO, fOutput),
523 ConstitutiveLaw1DOwner(pCL), SD(sd), dVal(0.), dInitVal(X0)
524 {
525 ASSERT(SD.iOrder == 0);
526 }
527
~GenelSpringSupport(void)528 GenelSpringSupport::~GenelSpringSupport(void)
529 {
530 const Node2Scalar *pn2s;
531
532 pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
533 if (pn2s) {
534 SAFEDELETE(pn2s);
535 }
536 }
537
538 /* Scrive il contributo dell'elemento al file di restart */
539 std::ostream&
Restart(std::ostream & out) const540 GenelSpringSupport::Restart(std::ostream& out) const
541 {
542 return out;
543 }
544
545 void
AfterConvergence(const VectorHandler & X,const VectorHandler & XP)546 GenelSpringSupport::AfterConvergence(const VectorHandler& X,
547 const VectorHandler& XP)
548 {
549 ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
550 }
551
552 /* Tipo di Genel */
553 Genel::Type
GetGenelType(void) const554 GenelSpringSupport::GetGenelType(void) const
555 {
556 return Genel::SPRINGSUPPORT;
557 }
558
559 /* Dimensioni del workspace */
560 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const561 GenelSpringSupport::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
562 {
563 *piNumRows = 1;
564 *piNumCols = 1;
565 }
566
567 /* assemblaggio jacobiano */
568 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)569 GenelSpringSupport::AssJac(VariableSubMatrixHandler& WorkMat,
570 doublereal dCoef,
571 const VectorHandler& XCurr,
572 const VectorHandler& XPrimeCurr)
573 {
574 DEBUGCOUT("Entering GenelSpringSupport::AssJac()" << std::endl);
575
576 FullSubMatrixHandler& WM = WorkMat.SetFull();
577 WM.ResizeReset(1, 1);
578
579 integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
580 integer iNodeColIndex = SD.pNode->iGetFirstColIndex() + 1;
581
582 WM.PutRowIndex(1, iNodeRowIndex);
583 WM.PutColIndex(1, iNodeColIndex);
584
585 WM.PutCoef(1, 1, GetFDE()*dCoef);
586
587 return WorkMat;
588 }
589
590 /* assemblaggio residuo */
591 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)592 GenelSpringSupport::AssRes(SubVectorHandler& WorkVec,
593 doublereal dCoef,
594 const VectorHandler& XCurr,
595 const VectorHandler& XPrimeCurr)
596 {
597 DEBUGCOUT("Entering GenelSpringSupport::AssRes()" << std::endl);
598
599 WorkVec.ResizeReset(1);
600
601 integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
602
603 dVal = SD.pNode->dGetX() - dInitVal;
604 ConstitutiveLaw1DOwner::Update(dVal, 0.);
605
606 WorkVec.PutItem(1, iNodeRowIndex, -GetF());
607
608 return WorkVec;
609 }
610
611 /* *******PER IL SOLUTORE PARALLELO******** */
612 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
613 * utile per l'assemblaggio della matrice di connessione fra i dofs */
614 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const615 GenelSpringSupport::GetConnectedNodes(
616 std::vector<const Node *>& connectedNodes) const {
617 connectedNodes.resize(1);
618 connectedNodes[0] = SD.pNode;
619 }
620
iGetNumPrivData(void) const621 unsigned int GenelSpringSupport::iGetNumPrivData(void) const
622 {
623 return 2u;
624 }
625
iGetPrivDataIdx(const char * s) const626 unsigned int GenelSpringSupport::iGetPrivDataIdx(const char *s) const
627 {
628 if (0 == strcmp(s, "F")) {
629 return 1u;
630 }
631
632 if (0 == strcmp(s, "X")) {
633 return 2u;
634 }
635
636 silent_cerr("genel(" << GetLabel() << "): private data \"" << s << "\" not available" << std::endl);
637 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
638 }
639
dGetPrivData(unsigned int i) const640 doublereal GenelSpringSupport::dGetPrivData(unsigned int i) const
641 {
642 switch (i) {
643 case 1u:
644 return GetF();
645 case 2u:
646 return dVal;
647 default:
648 silent_cerr("genel(" << GetLabel() << "): private data index " << i << " out of range" << std::endl);
649 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
650 }
651 }
652 /* ************************************************ */
653
654 /* GenelSpringSupport - end */
655
656
657 /* GenelCrossSpringSupport - begin */
658
GenelCrossSpringSupport(unsigned int uLabel,const DofOwner * pDO,const ConstitutiveLaw1D * pCL,const ScalarDof & sdrow,const ScalarDof & sdcol,flag fOutput)659 GenelCrossSpringSupport::GenelCrossSpringSupport(unsigned int uLabel,
660 const DofOwner* pDO,
661 const ConstitutiveLaw1D* pCL,
662 const ScalarDof& sdrow,
663 const ScalarDof& sdcol,
664 flag fOutput)
665 : Elem(uLabel, fOutput),
666 Genel(uLabel, pDO, fOutput),
667 ConstitutiveLaw1DOwner(pCL),
668 SDRow(sdrow), SDCol(sdcol), dVal(0.)
669 {
670 ASSERT(SDCol.iOrder == 0);
671 }
672
~GenelCrossSpringSupport(void)673 GenelCrossSpringSupport::~GenelCrossSpringSupport(void)
674 {
675 const Node2Scalar *pn2s;
676
677 pn2s = dynamic_cast<const Node2Scalar *>(SDRow.pNode);
678 if (pn2s) {
679 SAFEDELETE(pn2s);
680 }
681
682 pn2s = dynamic_cast<const Node2Scalar *>(SDCol.pNode);
683 if (pn2s) {
684 SAFEDELETE(pn2s);
685 }
686 }
687
688 /* Scrive il contributo dell'elemento al file di restart */
689 std::ostream&
Restart(std::ostream & out) const690 GenelCrossSpringSupport::Restart(std::ostream& out) const
691 {
692 return out;
693 }
694
695 void
AfterConvergence(const VectorHandler & X,const VectorHandler & XP)696 GenelCrossSpringSupport::AfterConvergence(const VectorHandler& X,
697 const VectorHandler& XP)
698 {
699 ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
700 }
701
702 /* Tipo di Genel */
703 Genel::Type
GetGenelType(void) const704 GenelCrossSpringSupport::GetGenelType(void) const
705 {
706 return Genel::CROSSSPRINGSUPPORT;
707 }
708
709 /* Dimensioni del workspace */
710 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const711 GenelCrossSpringSupport::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
712 {
713 *piNumRows = 1;
714 *piNumCols = 1;
715 }
716
717 /* assemblaggio jacobiano */
718 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)719 GenelCrossSpringSupport::AssJac(VariableSubMatrixHandler& WorkMat,
720 doublereal dCoef,
721 const VectorHandler& XCurr,
722 const VectorHandler& XPrimeCurr)
723 {
724 DEBUGCOUT("Entering GenelCrossSpringSupport::AssJac()" << std::endl);
725
726 FullSubMatrixHandler& WM = WorkMat.SetFull();
727 WM.ResizeReset(1, 1);
728
729 integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;
730 integer iNodeColIndex = SDCol.pNode->iGetFirstColIndex() + 1;
731
732 WM.PutRowIndex(1, iNodeRowIndex);
733 WM.PutColIndex(1, iNodeColIndex);
734
735 WM.PutCoef(1, 1, GetFDE()*dCoef);
736
737 return WorkMat;
738 }
739
740 /* assemblaggio residuo */
741 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)742 GenelCrossSpringSupport::AssRes(SubVectorHandler& WorkVec,
743 doublereal dCoef,
744 const VectorHandler& XCurr,
745 const VectorHandler& XPrimeCurr)
746 {
747 DEBUGCOUT("Entering GenelCrossSpringSupport::AssRes()" << std::endl);
748
749 WorkVec.ResizeReset(1);
750
751 integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex()+1;
752
753 dVal = SDCol.pNode->dGetX();
754 ConstitutiveLaw1DOwner::Update(dVal, 0.);
755
756 WorkVec.PutItem(1, iNodeRowIndex, -GetF());
757
758 return WorkVec;
759 }
760
761 /* *******PER IL SOLUTORE PARALLELO******** */
762 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
763 * utile per l'assemblaggio della matrice di connessione fra i dofs */
764 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const765 GenelCrossSpringSupport::GetConnectedNodes(
766 std::vector<const Node *>& connectedNodes) const {
767 connectedNodes.resize(2);
768 connectedNodes[0] = SDRow.pNode;
769 connectedNodes[1] = SDCol.pNode;
770 }
771 /* ************************************************ */
772
773 /* GenelCrossSpringSupport - end */
774
775
776 /* GenelCrossSpringDamperSupport - begin */
777
GenelCrossSpringDamperSupport(unsigned int uLabel,const DofOwner * pDO,const ConstitutiveLaw1D * pCL,const ScalarDof & sdrow,const ScalarDof & sdcol,flag fOutput)778 GenelCrossSpringDamperSupport::GenelCrossSpringDamperSupport(
779 unsigned int uLabel, const DofOwner* pDO,
780 const ConstitutiveLaw1D* pCL,
781 const ScalarDof& sdrow,
782 const ScalarDof& sdcol,
783 flag fOutput)
784 : Elem(uLabel, fOutput),
785 Genel(uLabel, pDO, fOutput),
786 ConstitutiveLaw1DOwner(pCL), SDRow(sdrow), SDCol(sdcol),
787 dVal(0.), dValPrime(0.)
788 {
789 ASSERT(SDCol.iOrder == 0);
790 }
791
~GenelCrossSpringDamperSupport(void)792 GenelCrossSpringDamperSupport::~GenelCrossSpringDamperSupport(void)
793 {
794 const Node2Scalar *pn2s;
795
796 pn2s = dynamic_cast<const Node2Scalar *>(SDRow.pNode);
797 if (pn2s) {
798 SAFEDELETE(pn2s);
799 }
800
801 pn2s = dynamic_cast<const Node2Scalar *>(SDCol.pNode);
802 if (pn2s) {
803 SAFEDELETE(pn2s);
804 }
805 }
806
807 /* Scrive il contributo dell'elemento al file di restart */
808 std::ostream&
Restart(std::ostream & out) const809 GenelCrossSpringDamperSupport::Restart(std::ostream& out) const
810 {
811 return out;
812 }
813
814 void
AfterConvergence(const VectorHandler & X,const VectorHandler & XP)815 GenelCrossSpringDamperSupport::AfterConvergence(const VectorHandler& X,
816 const VectorHandler& XP)
817 {
818 ConstitutiveLaw1DOwner::AfterConvergence(dVal, dValPrime);
819 }
820
821 /* Tipo di Genel */
822 Genel::Type
GetGenelType(void) const823 GenelCrossSpringDamperSupport::GetGenelType(void) const
824 {
825 return Genel::CROSSSPRINGDAMPERSUPPORT;
826 }
827
828 /* Dimensioni del workspace */
829 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const830 GenelCrossSpringDamperSupport::WorkSpaceDim(integer* piNumRows,
831 integer* piNumCols) const
832 {
833 *piNumRows = 1;
834 *piNumCols = 1;
835 }
836
837 /* assemblaggio jacobiano */
838 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)839 GenelCrossSpringDamperSupport::AssJac(VariableSubMatrixHandler& WorkMat,
840 doublereal dCoef,
841 const VectorHandler& XCurr,
842 const VectorHandler& XPrimeCurr)
843 {
844 DEBUGCOUT("Entering GenelCrossSpringDamperSupport::AssJac()" << std::endl);
845
846 FullSubMatrixHandler& WM = WorkMat.SetFull();
847 WM.ResizeReset(1, 1);
848
849 integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;
850 integer iNodeColIndex = SDCol.pNode->iGetFirstColIndex() + 1;
851
852 WM.PutRowIndex(1, iNodeRowIndex);
853 WM.PutColIndex(1, iNodeColIndex);
854
855 WM.PutCoef(1, 1, GetFDE()*dCoef+GetFDEPrime());
856
857 return WorkMat;
858 }
859
860 /* assemblaggio residuo */
861 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)862 GenelCrossSpringDamperSupport::AssRes(SubVectorHandler& WorkVec,
863 doublereal dCoef,
864 const VectorHandler& XCurr,
865 const VectorHandler& XPrimeCurr)
866 {
867 DEBUGCOUT("Entering GenelCrossSpringDamperSupport::AssRes()" << std::endl);
868
869 WorkVec.ResizeReset(1);
870
871 integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;
872
873 dVal = SDCol.pNode->dGetX();
874 dValPrime = SDCol.pNode->dGetXPrime();
875 ConstitutiveLaw1DOwner::Update(dVal, dValPrime);
876
877 WorkVec.PutItem(1, iNodeRowIndex, -GetF());
878
879 return WorkVec;
880 }
881
882 /* *******PER IL SOLUTORE PARALLELO******** */
883 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
884 * utile per l'assemblaggio della matrice di connessione fra i dofs */
885 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const886 GenelCrossSpringDamperSupport::GetConnectedNodes(
887 std::vector<const Node *>& connectedNodes) const {
888 connectedNodes.resize(2);
889 connectedNodes[0] = SDRow.pNode;
890 connectedNodes[1] = SDCol.pNode;
891 }
892 /* ************************************************ */
893
894 /* GenelCrossSpringDamperSupport - end */
895
896
897 /* GenelSpringDamperSupport - begin */
898
GenelSpringDamperSupport(unsigned int uLabel,const DofOwner * pDO,const ConstitutiveLaw1D * pCL,const ScalarDof & sd,doublereal X0,flag fOutput)899 GenelSpringDamperSupport::GenelSpringDamperSupport(unsigned int uLabel,
900 const DofOwner* pDO,
901 const ConstitutiveLaw1D* pCL,
902 const ScalarDof& sd, doublereal X0, flag fOutput)
903 : Elem(uLabel, fOutput),
904 Genel(uLabel, pDO, fOutput),
905 ConstitutiveLaw1DOwner(pCL),
906 SD(sd), dVal(0.), dInitVal(X0), dValPrime(0.)
907 {
908 ASSERT(sd.pNode->GetDofType(0) == DofOrder::DIFFERENTIAL);
909 ASSERT(sd.iOrder == 0);
910 }
911
~GenelSpringDamperSupport(void)912 GenelSpringDamperSupport::~GenelSpringDamperSupport(void)
913 {
914 const Node2Scalar *pn2s;
915
916 pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
917 if (pn2s) {
918 SAFEDELETE(pn2s);
919 }
920 }
921
922 /* Scrive il contributo dell'elemento al file di restart */
923 std::ostream&
Restart(std::ostream & out) const924 GenelSpringDamperSupport::Restart(std::ostream& out) const
925 {
926 return out;
927 }
928
929 void
AfterConvergence(const VectorHandler & X,const VectorHandler & XP)930 GenelSpringDamperSupport::AfterConvergence(const VectorHandler& X,
931 const VectorHandler& XP)
932 {
933 ConstitutiveLaw1DOwner::AfterConvergence(dVal, dValPrime);
934 }
935
936 /* Tipo di Genel */
937 Genel::Type
GetGenelType(void) const938 GenelSpringDamperSupport::GetGenelType(void) const
939 {
940 return Genel::SPRINGDAMPERSUPPORT;
941 }
942
943 /* Dimensioni del workspace */
944 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const945 GenelSpringDamperSupport::WorkSpaceDim(integer* piNumRows,
946 integer* piNumCols) const
947 {
948 *piNumRows = 1;
949 *piNumCols = 1;
950 }
951
952 /* assemblaggio jacobiano */
953 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)954 GenelSpringDamperSupport::AssJac(VariableSubMatrixHandler& WorkMat,
955 doublereal dCoef,
956 const VectorHandler& XCurr,
957 const VectorHandler& XPrimeCurr)
958 {
959 DEBUGCOUT("Entering GenelSpringDamperSupport::AssJac()" << std::endl);
960
961 FullSubMatrixHandler& WM = WorkMat.SetFull();
962 WM.ResizeReset(1, 1);
963
964 integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
965 integer iNodeColIndex = SD.pNode->iGetFirstColIndex() + 1;
966
967 WM.PutRowIndex(1, iNodeRowIndex);
968 WM.PutColIndex(1, iNodeColIndex);
969
970 WM.PutCoef(1, 1, GetFDE()*dCoef + GetFDEPrime());
971
972 return WorkMat;
973 }
974
975 /* assemblaggio residuo */
976 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)977 GenelSpringDamperSupport::AssRes(SubVectorHandler& WorkVec,
978 doublereal dCoef,
979 const VectorHandler& XCurr,
980 const VectorHandler& XPrimeCurr)
981 {
982 DEBUGCOUT("Entering GenelSpringDamperSupport::AssRes()" << std::endl);
983
984 WorkVec.ResizeReset(1);
985
986 integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex()+1;
987
988 dVal = SD.pNode->dGetX() - dInitVal;
989 dValPrime = SD.pNode->dGetXPrime();
990
991 ConstitutiveLaw1DOwner::Update(dVal, dValPrime);
992
993 WorkVec.PutItem(1, iNodeRowIndex, -GetF());
994
995 return WorkVec;
996 }
997
998 /* *******PER IL SOLUTORE PARALLELO******** */
999 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
1000 * utile per l'assemblaggio della matrice di connessione fra i dofs */
1001 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const1002 GenelSpringDamperSupport::GetConnectedNodes(
1003 std::vector<const Node *>& connectedNodes) const {
1004 connectedNodes.resize(1);
1005 connectedNodes[0] = SD.pNode;
1006 }
1007 /* ************************************************ */
1008
1009 /* GenelSpringDamperSupport - end */
1010
1011
1012 /* GenelMass - begin */
1013
GenelMass(unsigned int uLabel,const DofOwner * pDO,const DriveCaller * pDC,const ScalarDof & sd,flag fOutput)1014 GenelMass::GenelMass(unsigned int uLabel,
1015 const DofOwner* pDO, const DriveCaller* pDC,
1016 const ScalarDof& sd, flag fOutput)
1017 : Elem(uLabel, fOutput),
1018 Genel(uLabel, pDO, fOutput),
1019 DriveOwner(pDC), SD(sd)
1020 {
1021 NO_OP;
1022 }
1023
~GenelMass(void)1024 GenelMass::~GenelMass(void)
1025 {
1026 const Node2Scalar *pn2s;
1027
1028 pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
1029 if (pn2s) {
1030 SAFEDELETE(pn2s);
1031 }
1032 }
1033
1034 unsigned int
iGetNumDof(void) const1035 GenelMass::iGetNumDof(void) const
1036 {
1037 return 1;
1038 }
1039
1040 /* esegue operazioni sui dof di proprieta' dell'elemento */
1041 DofOrder::Order
GetDofType(unsigned int i) const1042 GenelMass::GetDofType(unsigned int i ) const
1043 {
1044 ASSERT(i == 0);
1045 return DofOrder::DIFFERENTIAL;
1046 }
1047
1048 /* Scrive il contributo dell'elemento al file di restart */
1049 std::ostream&
Restart(std::ostream & out) const1050 GenelMass::Restart(std::ostream& out) const
1051 {
1052 return out;
1053 }
1054
1055 /* Tipo di Genel */
1056 Genel::Type
GetGenelType(void) const1057 GenelMass::GetGenelType(void) const
1058 {
1059 return Genel::MASS;
1060 }
1061
1062 /* Dimensioni del workspace */
1063 void
WorkSpaceDim(integer * piNumRows,integer * piNumCols) const1064 GenelMass::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
1065 {
1066 *piNumRows = 2;
1067 *piNumCols = 2;
1068 }
1069
1070 /* assemblaggio jacobiano */
1071 VariableSubMatrixHandler&
AssJac(VariableSubMatrixHandler & WorkMat,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)1072 GenelMass::AssJac(VariableSubMatrixHandler& WorkMat,
1073 doublereal dCoef,
1074 const VectorHandler& XCurr,
1075 const VectorHandler& XPrimeCurr)
1076 {
1077 DEBUGCOUT("Entering GenelMass::AssJac()" << std::endl);
1078
1079 SparseSubMatrixHandler& WM = WorkMat.SetSparse();
1080 WM.ResizeReset(3, 0);
1081
1082 integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
1083 integer iColIndex = SD.pNode->iGetFirstColIndex() + 1;
1084 integer iDerivativeIndex = iGetFirstIndex() + 1;
1085
1086 WM.PutItem(1, iRowIndex, iDerivativeIndex, dGet());
1087 WM.PutItem(2, iDerivativeIndex, iColIndex, -1.);
1088 WM.PutItem(3, iDerivativeIndex, iDerivativeIndex, dCoef);
1089
1090 return WorkMat;
1091 }
1092
1093 /* assemblaggio residuo */
1094 SubVectorHandler&
AssRes(SubVectorHandler & WorkVec,doublereal dCoef,const VectorHandler & XCurr,const VectorHandler & XPrimeCurr)1095 GenelMass::AssRes(SubVectorHandler& WorkVec,
1096 doublereal dCoef,
1097 const VectorHandler& XCurr,
1098 const VectorHandler& XPrimeCurr)
1099 {
1100 DEBUGCOUT("Entering GenelMass::AssRes()" << std::endl);
1101
1102 WorkVec.ResizeReset(2);
1103
1104 integer iRowIndex = SD.pNode->iGetFirstRowIndex()+1;
1105 integer iDerivativeIndex = iGetFirstIndex()+1;
1106
1107 doublereal dVal = SD.pNode->dGetXPrime();
1108 doublereal dDer = XCurr(iDerivativeIndex);
1109 doublereal dDerPrime = XPrimeCurr(iDerivativeIndex);
1110
1111 WorkVec.PutItem(1, iRowIndex, -dGet()*dDerPrime);
1112 WorkVec.PutItem(2, iDerivativeIndex, dVal - dDer);
1113
1114 return WorkVec;
1115 }
1116
1117 void
SetValue(DataManager * pDM,VectorHandler & X,VectorHandler & XP,SimulationEntity::Hints * ph)1118 GenelMass::SetValue(DataManager *pDM,
1119 VectorHandler& X, VectorHandler& XP,
1120 SimulationEntity::Hints *ph)
1121 {
1122 X.PutCoef(iGetFirstIndex() + 1, SD.pNode->dGetXPrime());
1123 }
1124
1125 /* *******PER IL SOLUTORE PARALLELO******** */
1126 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
1127 * utile per l'assemblaggio della matrice di connessione fra i dofs */
1128 void
GetConnectedNodes(std::vector<const Node * > & connectedNodes) const1129 GenelMass::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
1130 connectedNodes.resize(1);
1131 connectedNodes[0] = SD.pNode;
1132 }
1133 /* ************************************************ */
1134
1135 /* GenelMass - end */
1136
1137