MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
constltp_impl.h
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/base/constltp_impl.h,v 1.41 2017/01/12 14:46:09 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 /* Legami costitutivi */
33 
34 
35 #ifndef CONSTLTP_IMPL_H
36 #define CONSTLTP_IMPL_H
37 
38 #include <limits>
39 #include <cfloat>
40 #include <cmath>
41 
42 #include "tpldrive_impl.h"
43 #include "constltp.h"
44 #include "hint_impl.h"
45 #include "elem.h"
46 
47 /* ConstitutiveLawArray - begin */
48 
49 template <class T, class Tder>
50 class ConstitutiveLawArray
51 : public ConstitutiveLaw<T, Tder> {
52 protected:
53  ConstLawType::Type m_type;
54  std::vector<ConstitutiveLaw<T, Tder> *> m_clv;
55 
56 public:
57  ConstitutiveLawArray(const std::vector<ConstitutiveLaw<T, Tder> *>& clv)
58  : m_clv(clv)
59  {
60  unsigned type = 0;
61  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::const_iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
62  type |= (*i)->GetConstLawType();
63  }
64  m_type = ConstLawType::Type(type);
65  };
66 
67  virtual ~ConstitutiveLawArray(void)
68  {
69  NO_OP;
70  };
71 
72  ConstLawType::Type GetConstLawType(void) const {
73  return m_type;
74  };
75 
76  void SetValue(DataManager *pDM,
77  VectorHandler& X, VectorHandler& XP,
78  SimulationEntity::Hints *ph = 0)
79  {
80  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
81  (*i)->SetValue(pDM, X, XP, ph);
82  }
83  };
84 
85  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
86  ConstitutiveLaw<T, Tder>* pCL = 0;
87 
88  std::vector<ConstitutiveLaw<T, Tder> *> clv(m_clv.size());
89  for (unsigned i = 0; i < m_clv.size(); i++) {
90  clv[i] = m_clv[i]->pCopy();
91  }
92 
93  typedef ConstitutiveLawArray<T, Tder> cl;
94  SAFENEWWITHCONSTRUCTOR(pCL, cl, cl(clv));
95  return pCL;
96  };
97 
98  virtual std::ostream& Restart(std::ostream& out) const {
99  out << "array, " << m_clv.size();
100  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::const_iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
101  out << ", ", (*i)->Restart(out);
102  }
103  return out;
104  };
105 
106  virtual void Update(const T& Eps, const T& EpsPrime = ::mb_zero<T>()) {
107  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
108  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
109  ConstitutiveLaw<T, Tder>::F = ::mb_zero<T>();
110  if (m_type & ConstLawType::ELASTIC) {
111  ConstitutiveLaw<T, Tder>::FDE = ::mb_zero<Tder>();
112  }
113  if (m_type & ConstLawType::VISCOUS) {
114  ConstitutiveLaw<T, Tder>::FDEPrime = ::mb_zero<Tder>();
115  }
116 
117  bool bChangeJac(false);
118  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
119  try {
120  (*i)->Update(Eps, EpsPrime);
121  }
122  catch (Elem::ChangedEquationStructure& e) {
123  bChangeJac = true;
124  }
125  ConstitutiveLaw<T, Tder>::F += (*i)->GetF();
126  if (m_type & ConstLawType::ELASTIC) {
127  ConstitutiveLaw<T, Tder>::FDE += (*i)->GetFDE();
128  }
129 
130  if (m_type & ConstLawType::VISCOUS) {
131  ConstitutiveLaw<T, Tder>::FDEPrime += (*i)->GetFDEPrime();
132  }
133  }
134  if (bChangeJac) {
135  /* if activating, ask for jacobian rigeneration */
136  throw Elem::ChangedEquationStructure(MBDYN_EXCEPT_ARGS);
137  }
138  };
139 
140  virtual void AfterConvergence(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
141  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
142  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
143 
144  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
145  (*i)->AfterConvergence(Eps, EpsPrime);
146  }
147  };
148 
149  virtual std::ostream& OutputAppend(std::ostream& out) const {
150  for (typename std::vector<ConstitutiveLaw<T, Tder> *>::const_iterator i = m_clv.begin(); i != m_clv.end(); ++i) {
151  (*i)->OutputAppend(out);
152  }
153  return out;
154  };
155 };
156 
157 /* ConstitutiveLawArray - end */
158 
159 
160 /* ElasticConstitutiveLaw - begin */
161 
162 template <class T, class Tder>
163 class ElasticConstitutiveLaw
164 : public ConstitutiveLaw<T, Tder>, public TplDriveOwner<T> {
165 protected:
166  T PreStress;
167 
168  virtual std::ostream&
169  Restart_int(std::ostream& out) const
170  {
171  out << ", prestress, ",
172  Write(out, PreStress /* + GetF() */ , ", ");
173  if (TplDriveOwner<T>::pGetDriveCaller()) {
174  out << ", prestrain, single, ",
175  Write(out, -ConstitutiveLaw<T, Tder>::Epsilon, ", ") << ", one /* ",
176  TplDriveOwner<T>::pGetDriveCaller()->Restart(out) << " */ ";
177  }
178 
179  return out;
180  };
181 
182 public:
183  ElasticConstitutiveLaw(const TplDriveCaller<T>* pDC, const T& PStress)
184  : TplDriveOwner<T>(pDC), PreStress(PStress)
185  {
186  NO_OP;
187  };
188 
189  virtual ~ElasticConstitutiveLaw(void)
190  {
191  NO_OP;
192  };
193 
194  ConstLawType::Type GetConstLawType(void) const {
195  return ConstLawType::ELASTIC;
196  };
197 
198  void SetValue(DataManager *pDM,
199  VectorHandler& X, VectorHandler& XP,
200  SimulationEntity::Hints *ph = 0)
201  {
202  if (ph) {
203  for (unsigned i = 0; i < ph->size(); ++i) {
204  TplVecHint<T> *pStressH = dynamic_cast<TplVecHint<T> *>((*ph)[i]);
205 
206  if (pStressH) {
207  PreStress = pStressH->pCreateVec(pDM);
208  continue;
209  }
210 
211  TplDriveHint<T> *pStrainH = dynamic_cast<TplDriveHint<T> *>((*ph)[i]);
212 
213  if (pStrainH) {
214  TplDriveCaller<T> *pDC = pStrainH->pCreateDrive(pDM);
215  if (pDC == 0) {
216  silent_cerr("ElasticConstitutiveLaw: "
217  "unable to create prestrain drive after hint "
218  "#" << i << std::endl);
219  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
220  }
221  TplDriveOwner<T>::Set(pDC);
222 
223  continue;
224  }
225  }
226  }
227  };
228 
229  virtual Hint *
230  ParseHint(DataManager *pDM, const char *s) const
231  {
232  if (strncasecmp(s, "prestress{" /*}*/ , STRLENOF("prestress{" /*}*/ )) == 0) {
233  s += STRLENOF("prestress{" /*}*/ );
234 
235  size_t len = strlen(s);
236 
237  if (s[len - 1] != '}') {
238  return 0;
239  }
240 
241  char *sStr = new char[len + 1];
242  memcpy(sStr, s, len + 1);
243  sStr[len - 1] = ';';
244 
245  return new TplVecHint<T>(sStr);
246 
247  } else if (strncasecmp(s, "prestrain{" /*}*/ , STRLENOF("prestrain{" /*}*/ )) == 0) {
248  s += STRLENOF("prestrain{" /*}*/ );
249 
250  size_t len = strlen(s);
251 
252  if (s[len - 1] != '}') {
253  return 0;
254  }
255 
256  char *sStr = new char[len + 1];
257  memcpy(sStr, s, len + 1);
258  sStr[len - 1] = ';';
259 
260  return new TplDriveHint<T>(sStr);
261  }
262 
263  return 0;
264  };
265 };
266 
267 typedef ElasticConstitutiveLaw<doublereal, doublereal> ElasticConstitutiveLaw1D;
268 typedef ElasticConstitutiveLaw<Vec3, Mat3x3> ElasticConstitutiveLaw3D;
269 typedef ElasticConstitutiveLaw<Vec6, Mat6x6> ElasticConstitutiveLaw6D;
270 
271 /* ElasticConstitutiveLaw - end */
272 
273 
274 /* LinearElasticIsotropicConstitutiveLaw - begin */
275 
276 template <class T, class Tder>
277 class LinearElasticIsotropicConstitutiveLaw
278 : public ElasticConstitutiveLaw<T, Tder> {
279 private:
280  doublereal dStiffness;
281 
282 public:
283  LinearElasticIsotropicConstitutiveLaw(const TplDriveCaller<T>* pDC,
284  const T& PStress, doublereal dStiff)
285  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress), dStiffness(dStiff) {
286  mb_deye<Tder>(ConstitutiveLaw<T, Tder>::FDE, dStiffness);
287  };
288 
289  virtual ~LinearElasticIsotropicConstitutiveLaw(void) {
290  NO_OP;
291  };
292 
293  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
294  ConstitutiveLaw<T, Tder>* pCL = 0;
295 
296  typedef LinearElasticIsotropicConstitutiveLaw<T, Tder> cl;
297  SAFENEWWITHCONSTRUCTOR(pCL,
298  cl,
299  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
300  ElasticConstitutiveLaw<T, Tder>::PreStress,
301  dStiffness));
302  return pCL;
303  };
304 
305  virtual std::ostream& Restart(std::ostream& out) const {
306  out << "linear elastic isotropic, " << dStiffness;
307  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
308  };
309 
310  virtual void Update(const T& Eps, const T& /* EpsPrime */ = mb_zero<T>()) {
311  ElasticConstitutiveLaw<T, Tder>::Epsilon = Eps;
312  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
313  + (ElasticConstitutiveLaw<T, Tder>::Epsilon - ElasticConstitutiveLaw<T, Tder>::Get())*dStiffness;
314  };
315 };
316 
317 typedef LinearElasticIsotropicConstitutiveLaw<doublereal, doublereal> LinearElasticIsotropicConstitutiveLaw1D;
318 typedef LinearElasticIsotropicConstitutiveLaw<Vec3, Mat3x3> LinearElasticIsotropicConstitutiveLaw3D;
319 typedef LinearElasticIsotropicConstitutiveLaw<Vec6, Mat6x6> LinearElasticIsotropicConstitutiveLaw6D;
320 
321 /* LinearElasticIsotropicConstitutiveLaw - end */
322 
323 
324 /* LinearElasticGenericConstitutiveLaw - begin */
325 
326 template <class T, class Tder>
327 class LinearElasticGenericConstitutiveLaw
328 : public ElasticConstitutiveLaw<T, Tder> {
329 public:
330  LinearElasticGenericConstitutiveLaw(const TplDriveCaller<T>* pDC,
331  const T& PStress, const Tder& Stiff)
332  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
333  ConstitutiveLaw<T, Tder>::FDE = Stiff;
334  };
335 
336  virtual ~LinearElasticGenericConstitutiveLaw(void) {
337  NO_OP;
338  };
339 
340  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
341  ConstitutiveLaw<T, Tder>* pCL = 0;
342 
343  typedef LinearElasticGenericConstitutiveLaw<T, Tder> cl;
344  SAFENEWWITHCONSTRUCTOR(pCL,
345  cl,
346  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
347  ElasticConstitutiveLaw<T, Tder>::PreStress,
348  ConstitutiveLaw<T, Tder>::FDE));
349  return pCL;
350  };
351 
352  virtual std::ostream& Restart(std::ostream& out) const {
353  out << "linear elastic generic, ",
354  Write(out, ConstitutiveLaw<T, Tder>::FDE, ", ");
355  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
356  };
357 
358  virtual void Update(const T& Eps, const T& /* EpsPrime */ = mb_zero<T>()) {
359  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
360  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
361  + ConstitutiveLaw<T, Tder>::FDE*(ConstitutiveLaw<T, Tder>::Epsilon - ElasticConstitutiveLaw<T, Tder>::Get());
362  };
363 };
364 
365 typedef LinearElasticGenericConstitutiveLaw<doublereal, doublereal> LinearElasticGenericConstitutiveLaw1D;
366 typedef LinearElasticGenericConstitutiveLaw<Vec3, Mat3x3> LinearElasticGenericConstitutiveLaw3D;
367 typedef LinearElasticGenericConstitutiveLaw<Vec6, Mat6x6> LinearElasticGenericConstitutiveLaw6D;
368 
369 /* LinearElasticGenericConstitutiveLaw - end */
370 
371 
372 /* LinearElasticGenericAxialTorsionCouplingConstitutiveLaw - begin */
373 
374 template <class T, class Tder>
375 class LinearElasticGenericAxialTorsionCouplingConstitutiveLaw
376 : public ElasticConstitutiveLaw<T, Tder> {
377 public:
378  LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller<T>* pDC,
379  const T& PStress,
380  const Tder& = mb_zero<Tder>(),
381  doublereal = 0.)
382  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
383  throw (typename ConstitutiveLaw<T, Tder>::Err(std::cerr, "axial-torsion coupling constitutive law "
384  "is allowed only for beams (6x6)"));
385  };
386 
387  virtual ~LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(void) {
388  NO_OP;
389  };
390 
391  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
392  return 0;
393  };
394 
395  virtual std::ostream& Restart(std::ostream& out) const {
396  return out;
397  };
398 
399  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
400  NO_OP;
401  };
402 };
403 
404 template<>
405 class LinearElasticGenericAxialTorsionCouplingConstitutiveLaw<Vec6, Mat6x6>
406 : public ElasticConstitutiveLaw6D {
407 protected:
408  Mat6x6 Stiffness;
409  doublereal dRefTorsion;
410  doublereal dAxialTorsionCoupling;
411 
412 public:
413  LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller<Vec6>* pDC,
414  const Vec6& PStress, const Mat6x6& Stiff,
415  doublereal dAxTors)
416  : ElasticConstitutiveLaw6D(pDC, PStress),
417  Stiffness(Stiff),
418  dRefTorsion(Stiffness.dGet(4, 4)),
419  dAxialTorsionCoupling(dAxTors) {
420  FDE = Stiffness;
421  };
422 
423  virtual ~LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(void) {
424  NO_OP;
425  };
426 
427  virtual ConstitutiveLaw<Vec6, Mat6x6>* pCopy(void) const {
428  ConstitutiveLaw<Vec6, Mat6x6>* pCL = 0;
429 
430  typedef LinearElasticGenericAxialTorsionCouplingConstitutiveLaw<Vec6, Mat6x6> cl;
431  SAFENEWWITHCONSTRUCTOR(pCL,
432  cl,
433  cl(pGetDriveCaller()->pCopy(),
434  PreStress,
435  Stiffness,
436  dAxialTorsionCoupling));
437 
438  return pCL;
439  };
440 
441  virtual std::ostream& Restart(std::ostream& out) const {
442  out << "linear elastic generic axial torsion coupling, ",
443  Write(out, FDE, ", ") << ", " << dAxialTorsionCoupling;
444  return Restart_int(out);
445  };
446 
447  virtual void Update(const Vec6& Eps, const Vec6& /* EpsPrime */ = mb_zero<Vec6>()) {
448  Epsilon = Eps;
449  doublereal d = Epsilon.dGet(1);
450  FDE.Put(4, 4, dRefTorsion + d*dAxialTorsionCoupling);
451  F = PreStress + FDE*(Epsilon-Get());
452  };
453 };
454 
455 /* LinearElasticGenericAxialTorsionCouplingConstitutiveLaw - end */
456 
457 
458 /* CubicElasticGenericConstitutiveLaw - begin */
459 
460 template <class T, class Tder>
461 class CubicElasticGenericConstitutiveLaw
462 : public ElasticConstitutiveLaw<T, Tder> {
463 public:
464  CubicElasticGenericConstitutiveLaw(const TplDriveCaller<T>* pDC,
465  const T& PStress, const T& Stiff1, const T& Stiff2, const T& Stiff3)
466  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
467  throw (typename ConstitutiveLaw<T, Tder>::Err(std::cerr, "cubic elastic generic constitutive law "
468  "is allowed only for scalar and 3x3"));
469  };
470 
471  virtual ~CubicElasticGenericConstitutiveLaw(void) {
472  NO_OP;
473  };
474 
475  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
476  return 0;
477  };
478 
479  virtual std::ostream& Restart(std::ostream& out) const {
480  return out;
481  };
482 
483  virtual void Update(const T& Eps, const T& /* EpsPrime */ = mb_zero<T>()) {
484  NO_OP;
485  };
486 };
487 
488 template <>
489 class CubicElasticGenericConstitutiveLaw<doublereal, doublereal>
490 : public ElasticConstitutiveLaw1D {
491 private:
492  doublereal Stiff1;
493  doublereal Stiff2;
494  doublereal Stiff3;
495 
496 public:
497  CubicElasticGenericConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
498  const doublereal& PStress, const doublereal& Stiff1,
499  const doublereal& Stiff2, const doublereal& Stiff3)
500  : ElasticConstitutiveLaw1D(pDC, PStress),
501  Stiff1(Stiff1), Stiff2(Stiff2), Stiff3(Stiff3)
502  {
503  NO_OP;
504  };
505 
506  virtual ~CubicElasticGenericConstitutiveLaw(void) {
507  NO_OP;
508  };
509 
510  virtual ConstitutiveLaw1D* pCopy(void) const {
511  ConstitutiveLaw1D* pCL = 0;
512 
513  typedef CubicElasticGenericConstitutiveLaw<doublereal, doublereal> cl;
514  SAFENEWWITHCONSTRUCTOR(pCL,
515  cl,
516  cl(ElasticConstitutiveLaw1D::pGetDriveCaller()->pCopy(),
517  ElasticConstitutiveLaw1D::PreStress,
518  Stiff1, Stiff2, Stiff3));
519  return pCL;
520  };
521 
522  virtual std::ostream& Restart(std::ostream& out) const {
523  out << "cubic elastic generic, ",
524  Write(out, Stiff1, ", ") << ", ",
525  Write(out, Stiff2, ", ") << ", ",
526  Write(out, Stiff3, ", ") << ", ";
527  return ElasticConstitutiveLaw1D::Restart_int(out);
528  };
529 
530  virtual void Update(const doublereal& Eps, const doublereal& /* EpsPrime */ = 0.) {
531  ConstitutiveLaw1D::Epsilon = Eps;
532  doublereal e1 = Eps - ElasticConstitutiveLaw1D::Get();
533  doublereal f1 = fabs(e1);
534  doublereal e2 = e1*e1;
535  doublereal f2 = f1*e1;
536  doublereal e3 = e2*e1;
537  ConstitutiveLaw1D::FDE = Stiff1 + 2.*Stiff2*f1 + 3.*Stiff3*e2;
538  ConstitutiveLaw1D::F = ElasticConstitutiveLaw1D::PreStress
539  + Stiff1*e1 + Stiff2*f2 + Stiff3*e3;
540  };
541 };
542 
543 template <>
544 class CubicElasticGenericConstitutiveLaw<Vec3, Mat3x3>
545 : public ElasticConstitutiveLaw3D {
546 private:
547  Vec3 Stiff1;
548  Vec3 Stiff2;
549  Vec3 Stiff3;
550 
551 public:
552  CubicElasticGenericConstitutiveLaw(const TplDriveCaller<Vec3>* pDC,
553  const Vec3& PStress, const Vec3& Stiff1,
554  const Vec3& Stiff2, const Vec3& Stiff3)
555  : ElasticConstitutiveLaw3D(pDC, PStress),
556  Stiff1(Stiff1), Stiff2(Stiff2), Stiff3(Stiff3)
557  {
558  NO_OP;
559  };
560 
561  virtual ~CubicElasticGenericConstitutiveLaw(void) {
562  NO_OP;
563  };
564 
565  virtual ConstitutiveLaw3D* pCopy(void) const {
566  ConstitutiveLaw3D* pCL = 0;
567 
568  typedef CubicElasticGenericConstitutiveLaw<Vec3, Mat3x3> cl;
569  SAFENEWWITHCONSTRUCTOR(pCL,
570  cl,
571  cl(ElasticConstitutiveLaw3D::pGetDriveCaller()->pCopy(),
572  ElasticConstitutiveLaw3D::PreStress,
573  Stiff1, Stiff2, Stiff3));
574  return pCL;
575  };
576 
577  virtual std::ostream& Restart(std::ostream& out) const {
578  out << "cubic elastic generic, ",
579  Write(out, Stiff1, ", ") << ", ",
580  Write(out, Stiff2, ", ") << ", ",
581  Write(out, Stiff3, ", ") << ", ";
582  return ElasticConstitutiveLaw3D::Restart_int(out);
583  };
584 
585  virtual void Update(const Vec3& Eps, const Vec3& /* EpsPrime */ = Zero3) {
586  ConstitutiveLaw3D::Epsilon = Eps;
587  Vec3 v1 = Eps - ElasticConstitutiveLaw3D::Get();
588  ConstitutiveLaw3D::F = ElasticConstitutiveLaw3D::PreStress;
589 
590 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
591  Vec3 FTmp;
592 #endif // MBDYN_X_WORKAROUND_GCC_3_2 || MBDYN_X_WORKAROUND_GCC_3_3
593 
594  for (int iCnt = 1; iCnt <= 3; iCnt++) {
595  doublereal e1 = v1(iCnt);
596  doublereal f1 = fabs(e1);
597  doublereal e2 = e1*e1;
598  doublereal f2 = f1*e1;
599  doublereal e3 = e2*e1;
600 
601 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
602  ConstitutiveLaw3D::FDE.Put(iCnt, iCnt,
603  Stiff1(iCnt)
604  + 2.*Stiff2(iCnt)*f1
605  + 3.*Stiff3(iCnt)*e2);
606  FTmp(iCnt) = Stiff1(iCnt)*e1
607  + Stiff2(iCnt)*f2
608  + Stiff3(iCnt)*e3;
609 #else // ! MBDYN_X_WORKAROUND_GCC_3_2 && ! MBDYN_X_WORKAROUND_GCC_3_3
610  ConstitutiveLaw3D::FDE(iCnt, iCnt) = Stiff1(iCnt) + 2.*Stiff2(iCnt)*f1 + 3.*Stiff3(iCnt)*e2;
611  ConstitutiveLaw3D::F(iCnt) += Stiff1(iCnt)*e1 + Stiff2(iCnt)*f2 + Stiff3(iCnt)*e3;
612 #endif // ! MBDYN_X_WORKAROUND_GCC_3_2 && ! MBDYN_X_WORKAROUND_GCC_3_3
613  }
614 
615 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
616  ConstitutiveLaw3D::F += FTmp;
617 #endif // MBDYN_X_WORKAROUND_GCC_3_3 || MBDYN_X_WORKAROUND_GCC_3_3
618  };
619 };
620 
621 /* CubicElasticGenericConstitutiveLaw - end */
622 
623 
624 /* InverseSquareConstitutiveLaw - begin */
625 
626 class InverseSquareConstitutiveLaw
627 : public ElasticConstitutiveLaw1D {
628 private:
629  doublereal m_A;
630  doublereal m_L0;
631 
632 public:
633  InverseSquareConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
634  const doublereal& PStress,
635  const doublereal& A, const doublereal& L0)
636  : ElasticConstitutiveLaw1D(pDC, PStress),
637  m_A(A), m_L0(L0)
638  {
639  NO_OP;
640  };
641 
642  virtual ~InverseSquareConstitutiveLaw(void) {
643  NO_OP;
644  };
645 
646  virtual ConstitutiveLaw1D* pCopy(void) const {
647  ConstitutiveLaw1D* pCL = 0;
648 
649  SAFENEWWITHCONSTRUCTOR(pCL,
650  InverseSquareConstitutiveLaw,
651  InverseSquareConstitutiveLaw(ElasticConstitutiveLaw1D::pGetDriveCaller()->pCopy(),
652  ElasticConstitutiveLaw1D::PreStress,
653  m_A, m_L0));
654  return pCL;
655  };
656 
657  virtual std::ostream& Restart(std::ostream& out) const {
658  out << "inverse square, " << m_A << ", " << m_L0;
659  return ElasticConstitutiveLaw1D::Restart_int(out);
660  };
661 
662  virtual void Update(const doublereal& Eps, const doublereal& /* EpsPrime */ = 0.) {
663  ConstitutiveLaw1D::Epsilon = Eps;
664  doublereal e1 = Eps - ElasticConstitutiveLaw1D::Get();
665  doublereal d = m_L0*(1 + e1);
666  doublereal d2 = d*d;
667  ConstitutiveLaw1D::F = ElasticConstitutiveLaw1D::PreStress + m_A/d2;
668  ConstitutiveLaw1D::FDE = -2.*m_A/(d2*d)*m_L0;
669  };
670 };
671 
672 /* InverseSquareConstitutiveLaw - end */
673 
674 
675 /* LogConstitutiveLaw - begin */
676 
677 template <class T, class Tder>
678 class LogConstitutiveLaw
679 : public ElasticConstitutiveLaw<T, Tder> {
680 public:
681  LogConstitutiveLaw(const TplDriveCaller<T>* pDC,
682  const T& PStress,
683  doublereal = 0.)
684  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
685  throw (typename ElasticConstitutiveLaw<T, Tder>::Err(std::cerr, "log constitutive law is allowed only for rods"));
686  };
687 
688  virtual ~LogConstitutiveLaw(void) {
689  NO_OP;
690  };
691 
692  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
693  return 0;
694  };
695 
696  virtual std::ostream& Restart(std::ostream& out) const {
697  return out;
698  };
699 
700  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
701  NO_OP;
702  };
703 };
704 
705 template<>
706 class LogConstitutiveLaw<doublereal, doublereal>
707 : public ElasticConstitutiveLaw1D {
708 private:
709  doublereal dStiffness;
710  doublereal dCurrEps;
711 
712 public:
713  LogConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
714  const doublereal& PStress, doublereal dStiff)
715  : ElasticConstitutiveLaw1D(pDC, PStress),
716  dStiffness(dStiff), dCurrEps(0.) {
717  ASSERT(Get() < 1.);
718  };
719 
720  virtual ~LogConstitutiveLaw(void) {
721  NO_OP;
722  };
723 
724  virtual ConstitutiveLaw<doublereal, doublereal>* pCopy(void) const {
725  ConstitutiveLaw<doublereal, doublereal>* pCL = 0;
726 
727  typedef LogConstitutiveLaw<doublereal, doublereal> cl;
728  SAFENEWWITHCONSTRUCTOR(pCL,
729  cl,
730  cl(pGetDriveCaller()->pCopy(),
731  PreStress,
732  dStiffness));
733 
734  return pCL;
735  };
736 
737  virtual std::ostream& Restart(std::ostream& out) const {
738  out << "log elastic, " << dStiffness;
739  return Restart_int(out);
740  };
741 
742  virtual void Update(const doublereal& Eps, const doublereal& /* EpsPrime */ = 0.) {
743  Epsilon = Eps;
744 
745  doublereal dPreStrain = Get();
746  dCurrEps = 1. + Epsilon - dPreStrain;
747  ASSERT(dCurrEps > std::numeric_limits<doublereal>::epsilon());
748 
749  if (dCurrEps < std::numeric_limits<doublereal>::epsilon()) {
750  // throw ErrGeneric();
751  dCurrEps = std::numeric_limits<doublereal>::epsilon();
752  }
753 
754  F = PreStress + dStiffness*log(dCurrEps);
755  FDE = dStiffness/dCurrEps;
756  };
757 };
758 
759 /* LogConstitutiveLaw - end */
760 
761 
762 /* DoubleLinearElasticConstitutiveLaw - begin */
763 
764 template <class T, class Tder>
765 class DoubleLinearElasticConstitutiveLaw
766 : public ElasticConstitutiveLaw<T, Tder> {
767 public:
768  DoubleLinearElasticConstitutiveLaw(const TplDriveCaller<T>* pDC,
769  const T& PStress,
770  doublereal = 0.,
771  doublereal = 0.,
772  doublereal = 0.,
773  doublereal = 0.)
774  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
775  throw (typename ElasticConstitutiveLaw<T, Tder>::Err(std::cerr, "double linear elastic constitutive law "
776  "is allowed only for rods and 3D hinges"));
777  };
778 
779  virtual ~DoubleLinearElasticConstitutiveLaw(void) {
780  NO_OP;
781  };
782 
783  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
784  return 0;
785  };
786 
787  virtual std::ostream& Restart(std::ostream& out) const {
788  return out;
789  };
790 
791  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
792  NO_OP;
793  };
794 };
795 
796 template<>
797 class DoubleLinearElasticConstitutiveLaw<doublereal, doublereal>
798 : public ElasticConstitutiveLaw1D {
799 private:
800  doublereal dStiffness; /* Isotropa: Eye*dStiffness */
801  doublereal dUpperLimitStrain;
802  doublereal dLowerLimitStrain;
803  doublereal dSecondStiffness;
804  flag fSecondStiff;
805 
806 public:
807  DoubleLinearElasticConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
808  const doublereal& PStress,
809  doublereal dStiff,
810  doublereal dUppLimStrain,
811  doublereal dLowLimStrain,
812  doublereal dSecondStiff)
813  : ElasticConstitutiveLaw1D(pDC, PStress),
814  dStiffness(dStiff),
815  dUpperLimitStrain(dUppLimStrain),
816  dLowerLimitStrain(dLowLimStrain),
817  dSecondStiffness(dSecondStiff) {
818  FDE = dStiffness;
819  };
820 
821  virtual ~DoubleLinearElasticConstitutiveLaw(void) {
822  NO_OP;
823  };
824 
825  virtual ConstitutiveLaw<doublereal, doublereal>* pCopy(void) const {
826  ConstitutiveLaw<doublereal, doublereal>* pCL = 0;
827 
828  typedef DoubleLinearElasticConstitutiveLaw<doublereal, doublereal> cl;
829  SAFENEWWITHCONSTRUCTOR(pCL,
830  cl,
831  cl(pGetDriveCaller()->pCopy(),
832  PreStress,
833  dStiffness,
834  dUpperLimitStrain,
835  dLowerLimitStrain,
836  dSecondStiffness));
837 
838  return pCL;
839  };
840 
841  virtual std::ostream& Restart(std::ostream& out) const {
842  out << "double linear elastic, "
843  << dStiffness << ", "
844  << dUpperLimitStrain << ", "
845  << dLowerLimitStrain << ", "
846  << dSecondStiffness;
847  return Restart_int(out);
848  };
849 
850  virtual void Update(const doublereal& Eps, const doublereal& /* EpsPrime */ = 0.) {
851  Epsilon = Eps;
852 
853  doublereal dPreStrain = Get();
854  doublereal dCurrStrain = Epsilon-dPreStrain;
855  if (dCurrStrain <= dUpperLimitStrain && dCurrStrain >= dLowerLimitStrain) {
856  FDE = dStiffness;
857  F = PreStress + dStiffness*dCurrStrain;
858  } else {
859  FDE = dSecondStiffness;
860 
861  if (dCurrStrain > dUpperLimitStrain) {
862  F = PreStress + dStiffness*dUpperLimitStrain
863  + dSecondStiffness*(dCurrStrain - dUpperLimitStrain);
864  } else /* if (dCurrStrain < dLowerLimitStrain) */ {
865  F = PreStress + dStiffness*dLowerLimitStrain
866  + dSecondStiffness*(dCurrStrain - dLowerLimitStrain);
867  }
868  }
869  };
870 };
871 
872 
873 template<>
874 class DoubleLinearElasticConstitutiveLaw<Vec3, Mat3x3>
875 : public ElasticConstitutiveLaw3D {
876 private:
877  doublereal dStiffness; /* Isotropa: Eye*dStiffness */
878  doublereal dUpperLimitStrain;
879  doublereal dLowerLimitStrain;
880  doublereal dSecondStiffness;
881 
882 public:
883  DoubleLinearElasticConstitutiveLaw(const TplDriveCaller<Vec3>* pDC,
884  const Vec3& PStress,
885  doublereal dStiff,
886  doublereal dUppLimStrain,
887  doublereal dLowLimStrain,
888  doublereal dSecondStiff)
889  : ElasticConstitutiveLaw3D(pDC, PStress),
890  dStiffness(dStiff),
891  dUpperLimitStrain(dUppLimStrain),
892  dLowerLimitStrain(dLowLimStrain),
893  dSecondStiffness(dSecondStiff) {
894  Mat3x3DEye.Manipulate(FDE, dStiffness);
895  };
896 
897  virtual ~DoubleLinearElasticConstitutiveLaw(void) {
898  NO_OP;
899  };
900 
901  virtual ConstitutiveLaw<Vec3, Mat3x3>* pCopy(void) const {
902  ConstitutiveLaw<Vec3, Mat3x3>* pCL = 0;
903 
904  typedef DoubleLinearElasticConstitutiveLaw<Vec3, Mat3x3> cl;
905  SAFENEWWITHCONSTRUCTOR(pCL,
906  cl,
907  cl(pGetDriveCaller()->pCopy(),
908  PreStress,
909  dStiffness,
910  dUpperLimitStrain,
911  dLowerLimitStrain,
912  dSecondStiffness));
913 
914  return pCL;
915  };
916 
917  virtual std::ostream& Restart(std::ostream& out) const {
918  out << "double linear elastic, "
919  << dStiffness << ", "
920  << dUpperLimitStrain << ", "
921  << dLowerLimitStrain << ", "
922  << dSecondStiffness;
923  return Restart_int(out);
924  };
925 
926  virtual void Update(const Vec3& Eps, const Vec3& /* EpsPrime */ = Zero3) {
927  Epsilon = Eps;
928 
929  Vec3 PreStrain = Get();
930  Vec3 CurrStrain = Epsilon-PreStrain;
931  doublereal dCurrStrain = CurrStrain.dGet(3);
932 
933  if (dCurrStrain <= dUpperLimitStrain && dCurrStrain >= dLowerLimitStrain) {
934  FDE.Put(3, 3, dStiffness);
935  F = PreStress+CurrStrain*dStiffness;
936  } else {
937  FDE.Put(3, 3, dSecondStiffness);
938 
939  if (dCurrStrain > dUpperLimitStrain) {
940  F = PreStress + Vec3(CurrStrain.dGet(1)*dStiffness,
941  CurrStrain.dGet(2)*dStiffness,
942  dUpperLimitStrain*dStiffness
943  + (dCurrStrain - dUpperLimitStrain)*dSecondStiffness);
944  } else /* if (dCurrStrain < dLowerLimitStrain) */ {
945  F = PreStress + Vec3(CurrStrain.dGet(1)*dStiffness,
946  CurrStrain.dGet(2)*dStiffness,
947  dLowerLimitStrain*dStiffness
948  + (dCurrStrain - dLowerLimitStrain)*dSecondStiffness);
949  }
950  }
951  };
952 };
953 
954 /* DoubleLinearElasticConstitutiveLaw - end */
955 
956 
957 /* IsotropicHardeningConstitutiveLaw - begin */
958 
959 template <class T, class Tder>
960 class IsotropicHardeningConstitutiveLaw
961 : public ElasticConstitutiveLaw<T, Tder> {
962 private:
963  doublereal dStiffness;
964  doublereal dAlpha;
965  doublereal dBeta;
966 
967  /* Legge costitutiva:
968  *
969  * Beta + Alpha*x^2
970  * f = k * ---------------- * x
971  * 1 + Alpha*x^2
972  */
973 
974 public:
975  IsotropicHardeningConstitutiveLaw(const TplDriveCaller<T>* pDC,
976  const T& PStress,
977  doublereal dStiff,
978  doublereal dStiff0,
979  doublereal dEpsHard)
980  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress),
981  dStiffness(dStiff), dAlpha(0.), dBeta(0.)
982  {
983  ASSERT(dEpsHard > std::numeric_limits<doublereal>::epsilon());
984  ASSERT(dStiff > std::numeric_limits<doublereal>::epsilon());
985 
986  dAlpha = 3./(dEpsHard*dEpsHard);
987  dBeta = dStiff0/dStiff;
988  };
989 
990  virtual ~IsotropicHardeningConstitutiveLaw(void) {
991  NO_OP;
992  };
993 
994  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
995  ConstitutiveLaw<T, Tder>* pCL = 0;
996 
997  typedef IsotropicHardeningConstitutiveLaw<T, Tder> cl;
998  SAFENEWWITHCONSTRUCTOR(pCL,
999  cl,
1000  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
1001  ElasticConstitutiveLaw<T, Tder>::PreStress,
1002  dStiffness,
1003  dBeta*dStiffness,
1004  sqrt(3./dAlpha)));
1005 
1006  return pCL;
1007  };
1008 
1009  virtual std::ostream& Restart(std::ostream& out) const {
1010  out << "isotropic hardening elastic, " << dStiffness << ", "
1011  << sqrt(3./dAlpha);
1012  if (dBeta != 0.) {
1013  out << ", linear stiffness, " << dBeta*dStiffness;
1014  }
1015  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1016  };
1017 
1018  virtual void Update(const T& Eps, const T& /* EpsPrime */ = Zero3) {
1019  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
1020  T x = ConstitutiveLaw<T, Tder>::Epsilon - ElasticConstitutiveLaw<T, Tder>::Get();
1021  doublereal dx2 = x*x;
1022  doublereal dDen = 1. + dAlpha*dx2;
1023  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
1024  + x*(dStiffness*(dBeta + dAlpha*dx2)/dDen);
1025  mb_deye<Tder>(ConstitutiveLaw<T, Tder>::FDE, dStiffness*(dBeta + (3. - dBeta + dAlpha*dx2)*dAlpha*dx2)/(dDen*dDen));
1026  };
1027 };
1028 
1029 typedef IsotropicHardeningConstitutiveLaw<doublereal, doublereal> IsotropicHardeningConstitutiveLaw1D;
1030 typedef IsotropicHardeningConstitutiveLaw<Vec3, Mat3x3> IsotropicHardeningConstitutiveLaw3D;
1031 typedef IsotropicHardeningConstitutiveLaw<Vec6, Mat6x6> IsotropicHardeningConstitutiveLaw6D;
1032 
1033 /* IsotropicHardeningConstitutiveLaw - end */
1034 
1035 
1036 /* ContactConstitutiveLaw - begin */
1037 
1038 template <class T, class Tder>
1039 class ContactConstitutiveLaw
1040 : public ElasticConstitutiveLaw<T, Tder> {
1041 
1042 public:
1043  ContactConstitutiveLaw(const TplDriveCaller<T>* pDC,
1044  const T& PStress,
1045  const doublereal = 0.,
1046  const doublereal = 0.)
1047  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
1048  throw (typename ElasticConstitutiveLaw<T, Tder>::Err(std::cerr, "contact constitutive law "
1049  "is allowed only for rods"));
1050  };
1051 
1052  virtual ~ContactConstitutiveLaw(void) {
1053  NO_OP;
1054  };
1055 
1056  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1057  return 0;
1058  };
1059 
1060  virtual std::ostream& Restart(std::ostream& out) const {
1061  return out;
1062  };
1063 
1064  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
1065  NO_OP;
1066  };
1067 };
1068 
1069 /*
1070  *
1071  * F = k * ( 1-l_0 / l ) ^ gamma
1072  * ==>
1073  * F = k * ( eps / ( 1 + eps ) ) ^ gamma
1074  *
1075  * d F = gamma * k * ( eps / ( 1 + eps ) ) ^ ( gamma - 1 ) * 1 / ( 1 + eps ) ^ 2 d eps
1076  *
1077  */
1078 
1079 template<>
1080 class ContactConstitutiveLaw<doublereal, doublereal>
1081 : public ElasticConstitutiveLaw1D {
1082 private:
1083  doublereal dKappa;
1084  doublereal dGamma;
1085 
1086 public:
1087  ContactConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
1088  const doublereal& PStress,
1089  const doublereal& dKappa,
1090  const doublereal& dGamma)
1091  : ElasticConstitutiveLaw1D(pDC, PStress), dKappa(dKappa), dGamma(dGamma) {
1092  NO_OP;
1093  };
1094 
1095  virtual ~ContactConstitutiveLaw(void) {
1096  NO_OP;
1097  };
1098 
1099  virtual ConstitutiveLaw<doublereal, doublereal>* pCopy(void) const {
1100  ConstitutiveLaw<doublereal, doublereal>* pCL = 0;
1101 
1102  typedef ContactConstitutiveLaw<doublereal, doublereal> cl;
1103  SAFENEWWITHCONSTRUCTOR(pCL,
1104  cl,
1105  cl(pGetDriveCaller()->pCopy(),
1106  PreStress,
1107  dKappa,
1108  dGamma));
1109 
1110  return pCL;
1111  };
1112 
1113  virtual std::ostream& Restart(std::ostream& out) const {
1114  out << "contact elastic, "
1115  << dKappa << ", "
1116  << dGamma;
1117  return Restart_int(out);
1118  };
1119 
1120  virtual void Update(const doublereal& Eps, const doublereal& /* EpsPrime */ = 0.) {
1121  doublereal dE;
1122 
1123  Epsilon = Eps;
1124  dE = Epsilon-Get();
1125  if ( dE >= 0. ) {
1126  F = PreStress;
1127  FDE = 0.;
1128  } else {
1129  F = PreStress+dKappa*(1. - 1./pow(1. + dE, dGamma));
1130  FDE = dGamma*dKappa/pow(1. + dE, dGamma + 1.);
1131  }
1132  };
1133 };
1134 
1135 
1136 template<>
1137 class ContactConstitutiveLaw<Vec3, Mat3x3>
1138 : public ElasticConstitutiveLaw3D {
1139 private:
1140  doublereal dKappa;
1141  doublereal dGamma;
1142 
1143 public:
1144  ContactConstitutiveLaw(const TplDriveCaller<Vec3>* pDC,
1145  const Vec3& PStress,
1146  const doublereal& dKappa,
1147  const doublereal& dGamma)
1148  : ElasticConstitutiveLaw3D(pDC, PStress), dKappa(dKappa), dGamma(dGamma) {
1149  F = Zero3;
1150  FDE = Zero3x3;
1151  };
1152 
1153  virtual ~ContactConstitutiveLaw(void) {
1154  NO_OP;
1155  };
1156 
1157  virtual ConstitutiveLaw<Vec3, Mat3x3>* pCopy(void) const {
1158  ConstitutiveLaw<Vec3, Mat3x3>* pCL = 0;
1159 
1160  typedef ContactConstitutiveLaw<Vec3, Mat3x3> cl;
1161  SAFENEWWITHCONSTRUCTOR(pCL,
1162  cl,
1163  cl(pGetDriveCaller()->pCopy(),
1164  PreStress,
1165  dKappa,
1166  dGamma));
1167 
1168  return pCL;
1169  };
1170 
1171  virtual std::ostream& Restart(std::ostream& out) const {
1172  out << "contact elastic, "
1173  << dKappa << ", "
1174  << dGamma;
1175  return Restart_int(out);
1176  };
1177 
1178  virtual void Update(const Vec3& Eps, const Vec3& /* EpsPrime */ = Zero3) {
1179  doublereal dE;
1180 
1181  Epsilon = Eps;
1182  dE = Epsilon.dGet(3)-Get().dGet(3);
1183  if ( dE >= 0. ) {
1184  F.Put(3, 0.);
1185  FDE.Put(3, 3, 0.);
1186  } else {
1187  F.Put(3, dKappa*(1. - 1./pow(1. + dE, dGamma)));
1188  FDE.Put(3, 3, dGamma*dKappa/pow(1. + dE, dGamma + 1.));
1189  }
1190  };
1191 };
1192 
1193 typedef ContactConstitutiveLaw<doublereal, doublereal> ContactConstitutiveLaw1D;
1194 typedef ContactConstitutiveLaw<Vec3, Mat3x3> ContactConstitutiveLaw3D;
1195 typedef ContactConstitutiveLaw<Vec6, Mat6x6> ContactConstitutiveLaw6D;
1196 
1197 /* ContactConstitutiveLaw - end */
1198 
1199 
1200 /* LinearViscousIsotropicConstitutiveLaw - begin */
1201 
1202 template <class T, class Tder>
1203 class LinearViscousIsotropicConstitutiveLaw
1204 : public ElasticConstitutiveLaw<T, Tder> {
1205  private:
1206  doublereal dStiffnessPrime; /* Isotropa: Eye*dStiffnessPrime */
1207 
1208  public:
1209  LinearViscousIsotropicConstitutiveLaw(const T& PStress,
1210  doublereal dStiffPrime)
1211  : ElasticConstitutiveLaw<T, Tder>(0, PStress),
1212  dStiffnessPrime(dStiffPrime) {
1213  mb_deye<Tder>(ConstitutiveLaw<T, Tder>::FDEPrime, dStiffnessPrime);
1214  };
1215 
1216  virtual ~LinearViscousIsotropicConstitutiveLaw(void) {
1217  NO_OP;
1218  };
1219 
1220  ConstLawType::Type GetConstLawType(void) const {
1221  return ConstLawType::VISCOUS;
1222  };
1223 
1224  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1225  ConstitutiveLaw<T, Tder>* pCL = 0;
1226 
1227  typedef LinearViscousIsotropicConstitutiveLaw<T, Tder> cl;
1228  SAFENEWWITHCONSTRUCTOR(pCL,
1229  cl,
1230  cl(ElasticConstitutiveLaw<T, Tder>::PreStress,
1231  dStiffnessPrime));
1232 
1233  return pCL;
1234  };
1235 
1236  virtual std::ostream& Restart(std::ostream& out) const {
1237  out << "linear viscous isotropic, "
1238  << dStiffnessPrime;
1239  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1240  };
1241 
1242  virtual void Update(const T& /* Eps */ , const T& EpsPrime = mb_zero<T>()) {
1243  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
1244  ConstitutiveLaw<T, Tder>::F = ConstitutiveLaw<T, Tder>::EpsilonPrime*dStiffnessPrime;
1245  };
1246 };
1247 
1248 /* LinearViscousIsotropicConstitutiveLaw - end */
1249 
1250 
1251 /* LinearViscousGenericConstitutiveLaw - begin */
1252 
1253 template <class T, class Tder>
1254 class LinearViscousGenericConstitutiveLaw
1255 : public ElasticConstitutiveLaw<T, Tder> {
1256  public:
1257  LinearViscousGenericConstitutiveLaw(const T& PStress,
1258  const Tder& StiffPrime)
1259  : ElasticConstitutiveLaw<T, Tder>(0, PStress) {
1260  ConstitutiveLaw<T, Tder>::FDEPrime = StiffPrime;
1261  };
1262 
1263  virtual ~LinearViscousGenericConstitutiveLaw(void) {
1264  NO_OP;
1265  };
1266 
1267  ConstLawType::Type GetConstLawType(void) const {
1268  return ConstLawType::VISCOUS;
1269  };
1270 
1271  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1272  ConstitutiveLaw<T, Tder>* pCL = 0;
1273 
1274  typedef LinearViscousGenericConstitutiveLaw<T, Tder> cl;
1275  SAFENEWWITHCONSTRUCTOR(pCL,
1276  cl,
1277  cl(ElasticConstitutiveLaw<T, Tder>::PreStress,
1278  ConstitutiveLaw<T, Tder>::FDEPrime));
1279 
1280  return pCL;
1281  };
1282 
1283  virtual std::ostream& Restart(std::ostream& out) const {
1284  out << "linear viscous generic, ",
1285  Write(out, ConstitutiveLaw<T, Tder>::FDEPrime, ", ");
1286  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1287  };
1288 
1289  virtual void Update(const T& /* Eps */ , const T& EpsPrime = mb_zero<T>()) {
1290  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
1291  ConstitutiveLaw<T, Tder>::F = ConstitutiveLaw<T, Tder>::FDEPrime*ConstitutiveLaw<T, Tder>::EpsilonPrime;
1292  };
1293 };
1294 
1295 /* LinearViscousGenericConstitutiveLaw - end */
1296 
1297 
1298 /* LinearViscoElasticIsotropicConstitutiveLaw - begin */
1299 
1300 template <class T, class Tder>
1301 class LinearViscoElasticIsotropicConstitutiveLaw
1302 : public ElasticConstitutiveLaw<T, Tder> {
1303  private:
1304  doublereal dStiffness;
1305  doublereal dStiffnessPrime;
1306 
1307  public:
1308  LinearViscoElasticIsotropicConstitutiveLaw(const TplDriveCaller<T>* pDC,
1309  const T& PStress,
1310  doublereal dStiff,
1311  doublereal dStiffPrime)
1312  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress),
1313  dStiffness(dStiff), dStiffnessPrime(dStiffPrime) {
1314  mb_deye<Tder>(ConstitutiveLaw<T, Tder>::FDE, dStiffness);
1315  mb_deye<Tder>(ConstitutiveLaw<T, Tder>::FDEPrime, dStiffnessPrime);
1316  };
1317 
1318  virtual ~LinearViscoElasticIsotropicConstitutiveLaw(void) {
1319  NO_OP;
1320  };
1321 
1322  ConstLawType::Type GetConstLawType(void) const {
1323  return ConstLawType::VISCOELASTIC;
1324  };
1325 
1326  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1327  ConstitutiveLaw<T, Tder>* pCL = 0;
1328 
1329  typedef LinearViscoElasticIsotropicConstitutiveLaw<T, Tder> cl;
1330  SAFENEWWITHCONSTRUCTOR(pCL,
1331  cl,
1332  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
1333  ElasticConstitutiveLaw<T, Tder>::PreStress,
1334  dStiffness,
1335  dStiffnessPrime));
1336 
1337  return pCL;
1338  };
1339 
1340  virtual std::ostream& Restart(std::ostream& out) const {
1341  out << "linear viscoelastic isotropic, "
1342  << dStiffness << ", "
1343  << dStiffnessPrime;
1344  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1345  };
1346 
1347  virtual void Update(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
1348  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
1349  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
1350 
1351  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
1352  +(ConstitutiveLaw<T, Tder>::Epsilon-ElasticConstitutiveLaw<T, Tder>::Get())*dStiffness+ConstitutiveLaw<T, Tder>::EpsilonPrime*dStiffnessPrime;
1353  };
1354 };
1355 
1356 typedef LinearViscoElasticIsotropicConstitutiveLaw<doublereal, doublereal> LinearViscoElasticIsotropicConstitutiveLaw1D;
1357 typedef LinearViscoElasticIsotropicConstitutiveLaw<Vec3, Mat3x3> LinearViscoElasticIsotropicConstitutiveLaw3D;
1358 typedef LinearViscoElasticIsotropicConstitutiveLaw<Vec6, Mat6x6> LinearViscoElasticIsotropicConstitutiveLaw6D;
1359 
1360 /* LinearViscoElasticIsotropicConstitutiveLaw - end */
1361 
1362 
1363 /* LinearViscoElasticGenericConstitutiveLaw - begin */
1364 
1365 template <class T, class Tder>
1366 class LinearViscoElasticGenericConstitutiveLaw
1367 : public ElasticConstitutiveLaw<T, Tder> {
1368  public:
1369  LinearViscoElasticGenericConstitutiveLaw(const TplDriveCaller<T>* pDC,
1370  const T& PStress,
1371  const Tder& Stiff,
1372  const Tder& StiffPrime)
1373  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
1374  ConstitutiveLaw<T, Tder>::FDE = Stiff;
1375  ConstitutiveLaw<T, Tder>::FDEPrime = StiffPrime;
1376  };
1377 
1378  virtual ~LinearViscoElasticGenericConstitutiveLaw(void) {
1379  NO_OP;
1380  };
1381 
1382  ConstLawType::Type GetConstLawType(void) const {
1383  return ConstLawType::VISCOELASTIC;
1384  };
1385 
1386  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1387  ConstitutiveLaw<T, Tder>* pCL = 0;
1388 
1389  typedef LinearViscoElasticGenericConstitutiveLaw<T, Tder> cl;
1390  SAFENEWWITHCONSTRUCTOR(pCL,
1391  cl,
1392  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
1393  ElasticConstitutiveLaw<T, Tder>::PreStress,
1394  ConstitutiveLaw<T, Tder>::FDE,
1395  ConstitutiveLaw<T, Tder>::FDEPrime));
1396 
1397  return pCL;
1398  };
1399 
1400  virtual std::ostream& Restart(std::ostream& out) const {
1401  out << "linear viscoelastic generic, ",
1402  Write(out, ConstitutiveLaw<T, Tder>::FDE, ", ") << ", ",
1403  Write(out, ConstitutiveLaw<T, Tder>::FDEPrime, ", ");
1404  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1405  };
1406 
1407  virtual void Update(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
1408  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
1409  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
1410  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
1411  +ConstitutiveLaw<T, Tder>::FDE*(ConstitutiveLaw<T, Tder>::Epsilon-ElasticConstitutiveLaw<T, Tder>::Get())
1412  +ConstitutiveLaw<T, Tder>::FDEPrime*ConstitutiveLaw<T, Tder>::EpsilonPrime;
1413  };
1414 };
1415 
1416 typedef LinearViscoElasticGenericConstitutiveLaw<doublereal, doublereal> LinearViscoElasticGenericConstitutiveLaw1D;
1417 typedef LinearViscoElasticGenericConstitutiveLaw<Vec3, Mat3x3> LinearViscoElasticGenericConstitutiveLaw3D;
1418 typedef LinearViscoElasticGenericConstitutiveLaw<Vec6, Mat6x6> LinearViscoElasticGenericConstitutiveLaw6D;
1419 
1420 /* LinearViscoElasticGenericConstitutiveLaw - end */
1421 
1422 /* LTVViscoElasticGenericConstitutiveLaw - begin */
1423 
1424 template <class T, class Tder>
1425 class LTVViscoElasticGenericConstitutiveLaw
1426 : public ElasticConstitutiveLaw<T, Tder> {
1427 protected:
1428  DriveOwner FDECoef;
1429  Tder FDERef;
1430  doublereal dPrevScaleFactor;
1431  DriveOwner FDEPrimeCoef;
1432  Tder FDEPrimeRef;
1433  doublereal dPrevScaleFactorPrime;
1434 
1435 public:
1436  LTVViscoElasticGenericConstitutiveLaw(const TplDriveCaller<T>* pDC,
1437  const T& PStress,
1438  const Tder& Stiff,
1439  const DriveCaller *pdc,
1440  const Tder& StiffPrime,
1441  const DriveCaller *pdcp)
1442  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress),
1443  FDECoef(pdc), FDEPrimeCoef(pdcp) {
1444  FDERef = Stiff;
1445  dPrevScaleFactor = 0.;
1446  FDEPrimeRef = StiffPrime;
1447  dPrevScaleFactorPrime = 0.;
1448  };
1449 
1450  virtual ~LTVViscoElasticGenericConstitutiveLaw(void) {
1451  NO_OP;
1452  };
1453 
1454  ConstLawType::Type GetConstLawType(void) const {
1455  return ConstLawType::VISCOELASTIC;
1456  };
1457 
1458  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1459  ConstitutiveLaw<T, Tder>* pCL = 0;
1460 
1461  typedef LTVViscoElasticGenericConstitutiveLaw<T, Tder> cl;
1462  SAFENEWWITHCONSTRUCTOR(pCL,
1463  cl,
1464  cl(ElasticConstitutiveLaw<T, Tder>::pGetDriveCaller()->pCopy(),
1465  ElasticConstitutiveLaw<T, Tder>::PreStress,
1466  FDERef,
1467  FDECoef.pGetDriveCaller()->pCopy(),
1468  FDEPrimeRef,
1469  FDEPrimeCoef.pGetDriveCaller()->pCopy()));
1470 
1471  return pCL;
1472  };
1473 
1474  virtual std::ostream& Restart(std::ostream& out) const {
1475  out << "linear time variant viscoelastic generic, ",
1476  Write(out, FDERef, ", ") << ", ",
1477  FDECoef.pGetDriveCaller()->Restart(out) << ", ",
1478  Write(out, FDEPrimeRef, ", ") << ", ",
1479  FDEPrimeCoef.pGetDriveCaller()->Restart(out);
1480  return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
1481  };
1482 
1483  virtual void Update(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
1484  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
1485  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
1486  doublereal dCurrScaleFactor = FDECoef.dGet();
1487  if (dCurrScaleFactor != dPrevScaleFactor) {
1488  dPrevScaleFactor = dCurrScaleFactor;
1489  ConstitutiveLaw<T, Tder>::FDE = FDERef*dCurrScaleFactor;
1490  }
1491  doublereal dCurrScaleFactorPrime = FDEPrimeCoef.dGet();
1492  if (dCurrScaleFactorPrime != dPrevScaleFactorPrime) {
1493  dPrevScaleFactorPrime = dCurrScaleFactorPrime;
1494  ConstitutiveLaw<T, Tder>::FDEPrime = FDEPrimeRef*dCurrScaleFactorPrime;
1495  }
1496  ConstitutiveLaw<T, Tder>::F = ElasticConstitutiveLaw<T, Tder>::PreStress
1497  + ConstitutiveLaw<T, Tder>::FDE*(ConstitutiveLaw<T, Tder>::Epsilon - ElasticConstitutiveLaw<T, Tder>::Get())
1498  + ConstitutiveLaw<T, Tder>::FDEPrime*ConstitutiveLaw<T, Tder>::EpsilonPrime;
1499  };
1500 };
1501 
1502 typedef LTVViscoElasticGenericConstitutiveLaw<doublereal, doublereal> LTVViscoElasticGenericConstitutiveLaw1D;
1503 typedef LTVViscoElasticGenericConstitutiveLaw<Vec3, Mat3x3> LTVViscoElasticGenericConstitutiveLaw3D;
1504 typedef LTVViscoElasticGenericConstitutiveLaw<Vec6, Mat6x6> LTVViscoElasticGenericConstitutiveLaw6D;
1505 
1506 /* LTVViscoElasticGenericConstitutiveLaw - end */
1507 
1508 /* LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw - begin */
1509 
1510 template <class T, class Tder>
1511 class LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw
1512 : public ElasticConstitutiveLaw<T, Tder> {
1513 public:
1514  LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller<T>* pDC,
1515  const T& PStress,
1516  const Tder& Stiff,
1517  const Tder& StiffPrime,
1518  doublereal dAxTors)
1519  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
1520  throw (typename ConstitutiveLaw<T, Tder>::Err(std::cerr, "axial-torsion coupling constitutive law "
1521  "is allowed only for beams (6x6)"));
1522  };
1523 
1524  virtual ~LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(void) {
1525  NO_OP;
1526  };
1527 
1528  ConstLawType::Type GetConstLawType(void) const {
1529  return ConstLawType::VISCOELASTIC;
1530  };
1531 
1532  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1533  return 0;
1534  };
1535 
1536  virtual std::ostream& Restart(std::ostream& out) const {
1537  return out;
1538  };
1539 
1540  virtual void Update(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
1541  NO_OP;
1542  };
1543 };
1544 
1545 template <>
1546 class LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw<Vec6, Mat6x6>
1547 : public ElasticConstitutiveLaw<Vec6, Mat6x6> {
1548 private:
1549  doublereal dRefTorsion;
1550  doublereal dAxialTorsionCoupling;
1551 
1552 public:
1553  LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller<Vec6>* pDC,
1554  const Vec6& PStress,
1555  const Mat6x6& Stiff,
1556  const Mat6x6& StiffPrime,
1557  doublereal dAxTors)
1558  : ElasticConstitutiveLaw<Vec6, Mat6x6>(pDC, PStress),
1559  dRefTorsion(Stiff(4, 4)),
1560  dAxialTorsionCoupling(dAxTors) {
1561  ConstitutiveLaw<Vec6, Mat6x6>::FDE = Stiff;
1562  ConstitutiveLaw<Vec6, Mat6x6>::FDEPrime = StiffPrime;
1563  };
1564 
1565  virtual ~LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(void) {
1566  NO_OP;
1567  };
1568 
1569  ConstLawType::Type GetConstLawType(void) const {
1570  return ConstLawType::VISCOELASTIC;
1571  };
1572 
1573  virtual ConstitutiveLaw<Vec6, Mat6x6>* pCopy(void) const {
1574  ConstitutiveLaw<Vec6, Mat6x6>* pCL = 0;
1575 
1576  typedef LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw<Vec6, Mat6x6> cl;
1577  SAFENEWWITHCONSTRUCTOR(pCL,
1578  cl,
1579  cl(ElasticConstitutiveLaw<Vec6, Mat6x6>::pGetDriveCaller()->pCopy(),
1580  ElasticConstitutiveLaw<Vec6, Mat6x6>::PreStress,
1581  ConstitutiveLaw<Vec6, Mat6x6>::FDE,
1582  ConstitutiveLaw<Vec6, Mat6x6>::FDEPrime,
1583  dAxialTorsionCoupling));
1584  return pCL;
1585  };
1586 
1587  virtual std::ostream& Restart(std::ostream& out) const {
1588  doublereal d = FDE(4, 4);
1589  out << "linear viscoelastic generic axial torsion coupling, ",
1590  Write(out, ConstitutiveLaw<Vec6, Mat6x6>::FDE, ", ") << ", ",
1591  Write(out, ConstitutiveLaw<Vec6, Mat6x6>::FDEPrime, ", ") << ", " << dAxialTorsionCoupling;
1592  ElasticConstitutiveLaw<Vec6, Mat6x6>::Restart_int(out);
1593  ((Mat6x6&)ConstitutiveLaw<Vec6, Mat6x6>::FDE)(4, 4) = d;
1594  return out;
1595  };
1596 
1597  virtual void Update(const Vec6& Eps, const Vec6& EpsPrime = mb_zero<Vec6>()) {
1598  ConstitutiveLaw<Vec6, Mat6x6>::Epsilon = Eps;
1599  ConstitutiveLaw<Vec6, Mat6x6>::EpsilonPrime = EpsPrime;
1600  doublereal d = Epsilon.dGet(1);
1601  ((Mat6x6&)ConstitutiveLaw<Vec6, Mat6x6>::FDE)(4, 4) = dRefTorsion + d*dAxialTorsionCoupling;
1602  ConstitutiveLaw<Vec6, Mat6x6>::F = ElasticConstitutiveLaw<Vec6, Mat6x6>::PreStress
1603  + ConstitutiveLaw<Vec6, Mat6x6>::FDE*(ConstitutiveLaw<Vec6, Mat6x6>::Epsilon - ElasticConstitutiveLaw<Vec6, Mat6x6>::Get())
1604  + ConstitutiveLaw<Vec6, Mat6x6>::FDEPrime*ConstitutiveLaw<Vec6, Mat6x6>::EpsilonPrime;
1605  };
1606 };
1607 
1608 typedef LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw<Vec6, Mat6x6> LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw6D;
1609 
1610 /* LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw - end */
1611 
1612 
1613 /* CubicViscoElasticGenericConstitutiveLaw - begin */
1614 
1615 template <class T, class Tder>
1616 class CubicViscoElasticGenericConstitutiveLaw
1617 : public ElasticConstitutiveLaw<T, Tder> {
1618 public:
1619  CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller<T>* pDC,
1620  const T& PStress, const T& Stiff1, const T& Stiff2, const T& Stiff3,
1621  const Tder& StiffPrime)
1622  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
1623  throw (typename ConstitutiveLaw<T, Tder>::Err(std::cerr, "cubic viscoelastic generic constitutive law "
1624  "is allowed only for scalar and 3x3"));
1625  };
1626 
1627  virtual ~CubicViscoElasticGenericConstitutiveLaw(void) {
1628  NO_OP;
1629  };
1630 
1631  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1632  return 0;
1633  };
1634 
1635  virtual std::ostream& Restart(std::ostream& out) const {
1636  return out;
1637  };
1638 
1639  virtual void Update(const T& Eps, const T& /* EpsPrime */ = mb_zero<T>()) {
1640  NO_OP;
1641  };
1642 };
1643 
1644 template <>
1645 class CubicViscoElasticGenericConstitutiveLaw<doublereal, doublereal>
1646 : public ElasticConstitutiveLaw1D {
1647 private:
1648  doublereal Stiff1;
1649  doublereal Stiff2;
1650  doublereal Stiff3;
1651 
1652 public:
1653  CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
1654  const doublereal& PStress, const doublereal& Stiff1,
1655  const doublereal& Stiff2, const doublereal& Stiff3,
1656  const doublereal& StiffPrime)
1657  : ElasticConstitutiveLaw1D(pDC, PStress),
1658  Stiff1(Stiff1), Stiff2(Stiff2), Stiff3(Stiff3)
1659  {
1660  ConstitutiveLaw1D::FDEPrime = StiffPrime;
1661  };
1662 
1663  virtual ~CubicViscoElasticGenericConstitutiveLaw(void) {
1664  NO_OP;
1665  };
1666 
1667  virtual ConstitutiveLaw1D* pCopy(void) const {
1668  ConstitutiveLaw1D* pCL = 0;
1669 
1670  typedef CubicViscoElasticGenericConstitutiveLaw<doublereal, doublereal> cl;
1671  SAFENEWWITHCONSTRUCTOR(pCL,
1672  cl,
1673  cl(ElasticConstitutiveLaw1D::pGetDriveCaller()->pCopy(),
1674  ElasticConstitutiveLaw1D::PreStress,
1675  Stiff1, Stiff2, Stiff3, ConstitutiveLaw1D::FDEPrime));
1676  return pCL;
1677  };
1678 
1679  virtual std::ostream& Restart(std::ostream& out) const {
1680  out << "cubic elastic generic, ",
1681  Write(out, Stiff1, ", ") << ", ",
1682  Write(out, Stiff2, ", ") << ", ",
1683  Write(out, Stiff3, ", ") << ", ",
1684  Write(out, ConstitutiveLaw1D::FDEPrime, ", ") << ", ";
1685  return ElasticConstitutiveLaw1D::Restart_int(out);
1686  };
1687 
1688  virtual void Update(const doublereal& Eps, const doublereal& EpsPrime = 0.) {
1689  ConstitutiveLaw1D::Epsilon = Eps;
1690  ConstitutiveLaw1D::EpsilonPrime = EpsPrime;
1691  doublereal e1 = Eps - ElasticConstitutiveLaw1D::Get();
1692  doublereal f1 = fabs(e1);
1693  doublereal e2 = e1*e1;
1694  doublereal f2 = f1*e1;
1695  doublereal e3 = e2*e1;
1696  ConstitutiveLaw1D::FDE = Stiff1 + 2.*Stiff2*f1 + 3.*Stiff3*e2;
1697  ConstitutiveLaw1D::F = ElasticConstitutiveLaw1D::PreStress
1698  + Stiff1*e1 + Stiff2*f2 + Stiff3*e3 + ConstitutiveLaw1D::FDEPrime*EpsPrime;
1699  };
1700 };
1701 
1702 template <>
1703 class CubicViscoElasticGenericConstitutiveLaw<Vec3, Mat3x3>
1704 : public ElasticConstitutiveLaw3D {
1705 private:
1706  Vec3 Stiff1;
1707  Vec3 Stiff2;
1708  Vec3 Stiff3;
1709 
1710 public:
1711  CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller<Vec3>* pDC,
1712  const Vec3& PStress, const Vec3& Stiff1,
1713  const Vec3& Stiff2, const Vec3& Stiff3,
1714  const Mat3x3& StiffPrime)
1715  : ElasticConstitutiveLaw3D(pDC, PStress),
1716  Stiff1(Stiff1), Stiff2(Stiff2), Stiff3(Stiff3)
1717  {
1718  ConstitutiveLaw3D::FDEPrime = StiffPrime;
1719  };
1720 
1721  virtual ~CubicViscoElasticGenericConstitutiveLaw(void) {
1722  NO_OP;
1723  };
1724 
1725  virtual ConstitutiveLaw3D* pCopy(void) const {
1726  ConstitutiveLaw3D* pCL = 0;
1727 
1728  typedef CubicViscoElasticGenericConstitutiveLaw<Vec3, Mat3x3> cl;
1729  SAFENEWWITHCONSTRUCTOR(pCL,
1730  cl,
1731  cl(ElasticConstitutiveLaw3D::pGetDriveCaller()->pCopy(),
1732  ElasticConstitutiveLaw3D::PreStress,
1733  Stiff1, Stiff2, Stiff3, ConstitutiveLaw3D::FDEPrime));
1734  return pCL;
1735  };
1736 
1737  virtual std::ostream& Restart(std::ostream& out) const {
1738  out << "cubic elastic generic, ",
1739  Write(out, Stiff1, ", ") << ", ",
1740  Write(out, Stiff2, ", ") << ", ",
1741  Write(out, Stiff3, ", ") << ", ",
1742  Write(out, ConstitutiveLaw3D::FDEPrime, ", ") << ", ";
1743  return ElasticConstitutiveLaw3D::Restart_int(out);
1744  };
1745 
1746  virtual void Update(const Vec3& Eps, const Vec3& EpsPrime = Zero3) {
1747  ConstitutiveLaw3D::Epsilon = Eps;
1748  ConstitutiveLaw3D::EpsilonPrime = EpsPrime;
1749  Vec3 v1 = Eps - ElasticConstitutiveLaw3D::Get();
1750  ConstitutiveLaw3D::F = ElasticConstitutiveLaw3D::PreStress + ConstitutiveLaw3D::FDEPrime*EpsPrime;
1751 
1752 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
1753  Vec3 FTmp;
1754 #endif // MBDYN_X_WORKAROUND_GCC_3_2 || MBDYN_X_WORKAROUND_GCC_3_3
1755 
1756  for (int iCnt = 1; iCnt <= 3; iCnt++) {
1757  doublereal e1 = v1(iCnt);
1758  doublereal f1 = fabs(e1);
1759  doublereal e2 = e1*e1;
1760  doublereal f2 = f1*e1;
1761  doublereal e3 = e2*e1;
1762 
1763 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
1764  ConstitutiveLaw3D::FDE.Put(iCnt, iCnt,
1765  Stiff1(iCnt)
1766  + 2.*Stiff2(iCnt)*f1
1767  + 3.*Stiff3(iCnt)*e2);
1768  FTmp(iCnt) = Stiff1(iCnt)*e1
1769  + Stiff2(iCnt)*f2
1770  + Stiff3(iCnt)*e3;
1771 #else // ! MBDYN_X_WORKAROUND_GCC_3_2 && ! MBDYN_X_WORKAROUND_GCC_3_3
1772  ConstitutiveLaw3D::FDE(iCnt, iCnt) = Stiff1(iCnt)
1773  + 2.*Stiff2(iCnt)*f1 + 3.*Stiff3(iCnt)*e2;
1774  ConstitutiveLaw3D::F(iCnt) += Stiff1(iCnt)*e1
1775  + Stiff2(iCnt)*f2 + Stiff3(iCnt)*e3;
1776 #endif // ! MBDYN_X_WORKAROUND_GCC_3_2 && ! MBDYN_X_WORKAROUND_GCC_3_3
1777  }
1778 
1779 #if defined(MBDYN_X_WORKAROUND_GCC_3_2) || defined(MBDYN_X_WORKAROUND_GCC_3_3)
1780  ConstitutiveLaw3D::F += FTmp;
1781 #endif // ! MBDYN_X_WORKAROUND_GCC_3_2 && ! MBDYN_X_WORKAROUND_GCC_3_3
1782  };
1783 };
1784 
1785 /* CubicViscoElasticGenericConstitutiveLaw - end */
1786 
1787 
1788 
1789 /* DoubleLinearViscoElasticConstitutiveLaw - begin */
1790 
1791 template <class T, class Tder>
1792 class DoubleLinearViscoElasticConstitutiveLaw
1793 : public ElasticConstitutiveLaw<T, Tder> {
1794  public:
1795  DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller<T>* pDC,
1796  const T& PStress,
1797  doublereal = 0.,
1798  doublereal = 0.,
1799  doublereal = 0.,
1800  doublereal = 0.,
1801  doublereal = 0.,
1802  doublereal = 0.)
1803  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
1804  throw (typename ElasticConstitutiveLaw<T, Tder>::Err(std::cerr, "doublelinear viscoelastic constitutive law "
1805  "is allowed only for rods ad 3D hinges"));
1806  };
1807 
1808  virtual ~DoubleLinearViscoElasticConstitutiveLaw(void) {
1809  NO_OP;
1810  };
1811 
1812  ConstLawType::Type GetConstLawType(void) const {
1813  return ConstLawType::VISCOELASTIC;
1814  };
1815 
1816  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
1817  return 0;
1818  };
1819 
1820  virtual std::ostream& Restart(std::ostream& out) const {
1821  return out;
1822  };
1823 
1824  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
1825  NO_OP;
1826  };
1827 };
1828 
1829 
1830 template<>
1831 class DoubleLinearViscoElasticConstitutiveLaw<doublereal, doublereal>
1832 : public ElasticConstitutiveLaw1D {
1833  private:
1834  doublereal dStiffness;
1835  doublereal dUpperLimitStrain;
1836  doublereal dLowerLimitStrain;
1837  doublereal dSecondStiffness;
1838  doublereal dStiffnessPrime;
1839  doublereal dSecondStiffnessPrime;
1840 
1841  public:
1842  DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
1843  const doublereal& PStress,
1844  doublereal dStiff,
1845  doublereal dUpp,
1846  doublereal dLow,
1847  doublereal dSecondS,
1848  doublereal dStiffPrime,
1849  doublereal dSecondSPrime)
1850  : ElasticConstitutiveLaw1D(pDC, PStress),
1851  dStiffness(dStiff),
1852  dUpperLimitStrain(dUpp), dLowerLimitStrain(dLow),
1853  dSecondStiffness(dSecondS),
1854  dStiffnessPrime(dStiffPrime),
1855  dSecondStiffnessPrime(dSecondSPrime)
1856  {
1857  FDEPrime = dStiffnessPrime;
1858  };
1859 
1860  virtual ~DoubleLinearViscoElasticConstitutiveLaw(void) {
1861  NO_OP;
1862  };
1863 
1864  ConstLawType::Type GetConstLawType(void) const {
1865  return ConstLawType::VISCOELASTIC;
1866  };
1867 
1868  virtual ConstitutiveLaw<doublereal, doublereal>* pCopy(void) const {
1869  ConstitutiveLaw<doublereal, doublereal>* pCL = 0;
1870 
1871  typedef DoubleLinearViscoElasticConstitutiveLaw<doublereal, doublereal> cl;
1872  SAFENEWWITHCONSTRUCTOR(pCL,
1873  cl,
1874  cl(pGetDriveCaller()->pCopy(),
1875  PreStress,
1876  dStiffness,
1877  dUpperLimitStrain,
1878  dLowerLimitStrain,
1879  dSecondStiffness,
1880  dStiffnessPrime,
1881  dSecondStiffnessPrime));
1882 
1883  return pCL;
1884  };
1885 
1886  virtual std::ostream& Restart(std::ostream& out) const {
1887  out << "double linear viscoelastic, "
1888  << dStiffness << ", "
1889  << dUpperLimitStrain << ", "
1890  << dLowerLimitStrain << ", "
1891  << dSecondStiffness << ", "
1892  << dStiffnessPrime << ", "
1893  "second damping, " << dSecondStiffnessPrime << ", ";
1894  return Restart_int(out);
1895  };
1896 
1897  virtual void Update(const doublereal& Eps, const doublereal& EpsPrime = 0.) {
1898  Epsilon = Eps;
1899  EpsilonPrime = EpsPrime;
1900 
1901  doublereal dPreStrain = Get();
1902  doublereal dCurrStrain = Epsilon-dPreStrain;
1903  if (dCurrStrain <= dUpperLimitStrain && dCurrStrain >= dLowerLimitStrain) {
1904  FDE = dStiffness;
1905  FDEPrime = dStiffnessPrime;
1906  F = PreStress+dStiffness*dCurrStrain
1907  +dStiffnessPrime*EpsilonPrime;
1908  } else {
1909  FDE = dSecondStiffness;
1910  FDEPrime = dSecondStiffnessPrime;
1911 
1912  if (dCurrStrain > dUpperLimitStrain) {
1913  F = PreStress+dStiffness*dUpperLimitStrain
1914  +dSecondStiffness*(dCurrStrain-dUpperLimitStrain)
1915  +dSecondStiffnessPrime*EpsilonPrime;
1916  } else /* if (dCurrStrain < dLowerLimitStrain) */ {
1917  F = PreStress+dStiffness*dLowerLimitStrain
1918  +dSecondStiffness*(dCurrStrain-dLowerLimitStrain)
1919  +dSecondStiffnessPrime*EpsilonPrime;
1920  }
1921  }
1922  };
1923 };
1924 
1925 
1926 template<>
1927 class DoubleLinearViscoElasticConstitutiveLaw<Vec3, Mat3x3>
1928 : public ElasticConstitutiveLaw3D {
1929  private:
1930  doublereal dStiffness; /* Isotropa: Eye*dStiffness */
1931  doublereal dUpperLimitStrain;
1932  doublereal dLowerLimitStrain;
1933  doublereal dSecondStiffness;
1934  doublereal dStiffnessPrime;
1935  doublereal dSecondStiffnessPrime;
1936 
1937  public:
1938  DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller<Vec3>* pDC,
1939  const Vec3& PStress,
1940  doublereal dStiff,
1941  doublereal dUppLimStrain,
1942  doublereal dLowLimStrain,
1943  doublereal dSecondStiff,
1944  doublereal dStiffPrime,
1945  doublereal dSecondStiffPrime)
1946  : ElasticConstitutiveLaw3D(pDC, PStress),
1947  dStiffness(dStiff),
1948  dUpperLimitStrain(dUppLimStrain),
1949  dLowerLimitStrain(dLowLimStrain),
1950  dSecondStiffness(dSecondStiff),
1951  dStiffnessPrime(dStiffPrime),
1952  dSecondStiffnessPrime(dSecondStiffPrime)
1953  {
1954  Mat3x3DEye.Manipulate(FDE, dStiffness);
1955  Mat3x3DEye.Manipulate(FDEPrime, dStiffnessPrime);
1956  };
1957 
1958  virtual ~DoubleLinearViscoElasticConstitutiveLaw(void) {
1959  NO_OP;
1960  };
1961 
1962  ConstLawType::Type GetConstLawType(void) const {
1963  return ConstLawType::VISCOELASTIC;
1964  };
1965 
1966  virtual ConstitutiveLaw<Vec3, Mat3x3>* pCopy(void) const {
1967  ConstitutiveLaw<Vec3, Mat3x3>* pCL = 0;
1968 
1969  typedef DoubleLinearViscoElasticConstitutiveLaw<Vec3, Mat3x3> cl;
1970  SAFENEWWITHCONSTRUCTOR(pCL,
1971  cl,
1972  cl(pGetDriveCaller()->pCopy(),
1973  PreStress,
1974  dStiffness,
1975  dUpperLimitStrain,
1976  dLowerLimitStrain,
1977  dSecondStiffness,
1978  dStiffnessPrime,
1979  dSecondStiffnessPrime));
1980 
1981  return pCL;
1982  };
1983 
1984  virtual std::ostream& Restart(std::ostream& out) const {
1985  out << "double linear viscoelastic, "
1986  << dStiffness << ", "
1987  << dUpperLimitStrain << ", "
1988  << dLowerLimitStrain << ", "
1989  << dSecondStiffness << ", "
1990  << dStiffnessPrime << ", "
1991  << dSecondStiffnessPrime << ", ";
1992  return Restart_int(out);
1993  };
1994 
1995  virtual void Update(const Vec3& Eps, const Vec3& EpsPrime = Zero3) {
1996  Epsilon = Eps;
1997  EpsilonPrime = EpsPrime;
1998 
1999  Vec3 PreStrain = Get();
2000  Vec3 CurrStrain = Epsilon-PreStrain;
2001  doublereal dCurrStrain = CurrStrain.dGet(3);
2002 
2003  if (dCurrStrain <= dUpperLimitStrain && dCurrStrain >= dLowerLimitStrain) {
2004  FDE.Put(3, 3, dStiffness);
2005  FDEPrime.Put(3, 3, dStiffnessPrime);
2006  F = PreStress+CurrStrain*dStiffness+EpsilonPrime*dStiffnessPrime;
2007  } else {
2008  FDE.Put(3, 3, dSecondStiffness);
2009  FDEPrime.Put(3, 3, dSecondStiffnessPrime);
2010 
2011  if (dCurrStrain > dUpperLimitStrain) {
2012  F = PreStress
2013  +Vec3(CurrStrain(1)*dStiffness + EpsilonPrime(1)*dStiffnessPrime,
2014  CurrStrain(2)*dStiffness + EpsilonPrime(2)*dStiffnessPrime,
2015  dUpperLimitStrain*dStiffness
2016  +(dCurrStrain-dUpperLimitStrain)*dSecondStiffness
2017  +EpsilonPrime(3)*dSecondStiffnessPrime);
2018  } else /* if (dCurrStrain < dLowerLimitStrain) */ {
2019  F = PreStress
2020  +Vec3(CurrStrain.dGet(1)*dStiffness + EpsilonPrime(1)*dStiffnessPrime,
2021  CurrStrain.dGet(2)*dStiffness + EpsilonPrime(2)*dStiffnessPrime,
2022  dLowerLimitStrain*dStiffness
2023  +(dCurrStrain-dLowerLimitStrain)*dSecondStiffness
2024  +EpsilonPrime(3)*dSecondStiffnessPrime);
2025  }
2026  }
2027  };
2028 };
2029 
2030 /* DoubleLinearViscoElasticConstitutiveLaw - end */
2031 
2032 
2033 /* TurbulentViscoElasticConstitutiveLaw - begin */
2034 
2035 template <class T, class Tder>
2036 class TurbulentViscoElasticConstitutiveLaw
2037 : public ElasticConstitutiveLaw<T, Tder> {
2038  public:
2039  TurbulentViscoElasticConstitutiveLaw(const TplDriveCaller<T>* pDC,
2040  const T& PStress,
2041  doublereal = 0.,
2042  doublereal = 0.,
2043  doublereal = 0.,
2044  doublereal = 0.)
2045  : ElasticConstitutiveLaw<T, Tder>(pDC, PStress) {
2046  throw (typename ElasticConstitutiveLaw<T, Tder>::Err(std::cerr, "Turbulent viscoelastic constitutive law "
2047  "is allowed only for rods"));
2048  };
2049 
2050  virtual ~TurbulentViscoElasticConstitutiveLaw(void) {
2051  NO_OP;
2052  };
2053 
2054  ConstLawType::Type GetConstLawType(void) const {
2055  return ConstLawType::VISCOELASTIC;
2056  };
2057 
2058  virtual ConstitutiveLaw<T, Tder>* pCopy(void) const {
2059  return 0;
2060  };
2061 
2062  virtual std::ostream& Restart(std::ostream& out) const {
2063  return out;
2064  };
2065 
2066  virtual void Update(const T& /* Eps */ , const T& /* EpsPrime */ = mb_zero<T>()) {
2067  NO_OP;
2068  };
2069 };
2070 
2071 
2072 template<>
2073 class TurbulentViscoElasticConstitutiveLaw<doublereal, doublereal>
2074 : public ElasticConstitutiveLaw1D {
2075  private:
2076  doublereal dStiffness;
2077  doublereal dStiffnessPrime;
2078  doublereal dTreshold;
2079  doublereal dParabolicStiffness;
2080 
2081  public:
2082  TurbulentViscoElasticConstitutiveLaw(const TplDriveCaller<doublereal>* pDC,
2083  const doublereal& PStress,
2084  doublereal dStiff,
2085  doublereal dStiffPrime,
2086  doublereal dTres,
2087  doublereal dParabStiff)
2088  : ElasticConstitutiveLaw1D(pDC, PStress),
2089  dStiffness(dStiff), dStiffnessPrime(dStiffPrime),
2090  dTreshold(dTres), dParabolicStiffness(dParabStiff) {
2091  FDE = dStiffness;
2092  };
2093 
2094  virtual ~TurbulentViscoElasticConstitutiveLaw(void) {
2095  NO_OP;
2096  };
2097 
2098  ConstLawType::Type GetConstLawType(void) const {
2099  return ConstLawType::VISCOELASTIC;
2100  };
2101 
2102  virtual ConstitutiveLaw<doublereal, doublereal>* pCopy(void) const {
2103  ConstitutiveLaw<doublereal, doublereal>* pCL = 0;
2104 
2105  typedef TurbulentViscoElasticConstitutiveLaw<doublereal, doublereal> cl;
2106  SAFENEWWITHCONSTRUCTOR(pCL,
2107  cl,
2108  cl(pGetDriveCaller()->pCopy(),
2109  PreStress,
2110  dStiffness,
2111  dStiffnessPrime,
2112  dTreshold,
2113  dParabolicStiffness));
2114 
2115  return pCL;
2116  };
2117 
2118  virtual std::ostream& Restart(std::ostream& out) const {
2119  out << "turbulent viscoelastic, "
2120  << dStiffness << ", "
2121  << dStiffnessPrime << ", "
2122  << dTreshold << ", "
2123  << dParabolicStiffness << ", ";
2124  return Restart_int(out);
2125  };
2126 
2127  virtual void Update(const doublereal& Eps, const doublereal& EpsPrime = 0.) {
2128  Epsilon = Eps;
2129  EpsilonPrime = EpsPrime;
2130 
2131  doublereal dPreStrain = Get();
2132 
2133  doublereal d = fabs(EpsilonPrime);
2134  if (d < dTreshold) {
2135  FDEPrime = dStiffnessPrime;
2136  F = PreStress+dStiffness*(Epsilon-dPreStrain)
2137  +dStiffnessPrime*EpsilonPrime;
2138  } else {
2139  FDEPrime = 2.*dParabolicStiffness*d;
2140  F = PreStress+dStiffness*(Epsilon-dPreStrain)
2141  +dParabolicStiffness*d*EpsilonPrime;
2142  }
2143  };
2144 };
2145 
2146 /* TurbulentViscoElasticConstitutiveLaw - end */
2147 
2148 /* BiStopCLWrapper - begin */
2149 
2150 template <class T, class Tder>
2151 class BiStopCLWrapper
2152 : public ConstitutiveLaw<T, Tder> {
2153 private:
2154  enum Status { INACTIVE, ACTIVE };
2155 
2156  ConstitutiveLaw<T, Tder> *m_pCL;
2157  enum Status m_status;
2158  const DriveCaller *m_pActivatingCondition;
2159  const DriveCaller *m_pDeactivatingCondition;
2160  T m_EpsRef;
2161 
2162 public:
2163  BiStopCLWrapper(
2164  ConstitutiveLaw<T, Tder> *pCL,
2165  bool bInitialStatus,
2166  const DriveCaller *pA,
2167  const DriveCaller *pD
2168  ) :
2169  m_pCL(pCL), m_status(bInitialStatus ? ACTIVE : INACTIVE),
2170  m_pActivatingCondition(pA), m_pDeactivatingCondition(pD),
2171  m_EpsRef(mb_zero<T>()) {
2172  ASSERT(m_pActivatingCondition != 0);
2173  ASSERT(m_pDeactivatingCondition != 0);
2174  };
2175 
2176  virtual
2177  ~BiStopCLWrapper(void) {
2178  NO_OP;
2179  };
2180 
2181  ConstLawType::Type GetConstLawType(void) const {
2182  return m_pCL->GetConstLawType();
2183  };
2184 
2185  virtual
2186  ConstitutiveLaw<T, Tder>* pCopy(void) const {
2187  ConstitutiveLaw<T, Tder>* pCL = 0;
2188 
2189  typedef BiStopCLWrapper<T, Tder> cl;
2190  SAFENEWWITHCONSTRUCTOR(pCL,
2191  cl,
2192  cl(m_pCL->pCopy(),
2193  m_status == ACTIVE,
2194  m_pActivatingCondition->pCopy(),
2195  m_pDeactivatingCondition->pCopy()));
2196 
2197  return pCL;
2198  };
2199 
2200  virtual std::ostream&
2201  Restart(std::ostream& out) const {
2202  out << "bistop, initial status, ";
2203  if (m_status == INACTIVE) {
2204  out << "inactive";
2205 
2206  } else {
2207  out << "active";
2208  }
2209  out << ", ",
2210  m_pActivatingCondition->Restart(out) << ", ",
2211  m_pDeactivatingCondition->Restart(out) << ", ";
2212  return m_pCL->Restart(out);
2213  };
2214 
2215  virtual void
2216  Update(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
2217  ConstitutiveLaw<T, Tder>::Epsilon = Eps;
2218  ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
2219  bool bChangeJac(false);
2220 
2221  switch (m_status) {
2222  case INACTIVE:
2223  if (m_pActivatingCondition->dGet() == 0.) {
2224  /* remains inactive: nothing to do */
2225  break;
2226  }
2227 
2228  /* activates: change data and ask for jacobian rigeneration */
2229  m_status = ACTIVE;
2230  m_EpsRef = ConstitutiveLaw<T, Tder>::Epsilon;
2231  bChangeJac = true;
2232 
2233  case ACTIVE:
2234  if (m_pDeactivatingCondition->dGet() != 0.) {
2235  /* disactivates: reset data and ask for jacobian rigeneration */
2236  m_status = INACTIVE;
2237  ConstitutiveLaw<T, Tder>::F = ::mb_zero<T>();
2238  ConstitutiveLaw<T, Tder>::FDE = ::mb_zero<Tder>();
2239  ConstitutiveLaw<T, Tder>::FDEPrime = ::mb_zero<Tder>();
2240  throw Elem::ChangedEquationStructure(MBDYN_EXCEPT_ARGS);
2241  }
2242 
2243  /* change force as well */
2244  try {
2245  m_pCL->Update(Eps - m_EpsRef, EpsPrime);
2246  }
2247  catch (Elem::ChangedEquationStructure& e) {
2248  bChangeJac = true;
2249  }
2250  ConstitutiveLaw<T, Tder>::F = m_pCL->GetF();
2251  ConstitutiveLaw<T, Tder>::FDE = m_pCL->GetFDE();
2252  ConstitutiveLaw<T, Tder>::FDEPrime = m_pCL->GetFDEPrime();
2253  if (bChangeJac) {
2254  /* if activating, ask for jacobian rigeneration */
2255  throw Elem::ChangedEquationStructure(MBDYN_EXCEPT_ARGS);
2256  }
2257  break;
2258  }
2259  };
2260 
2261  virtual void AfterConvergence(const T& Eps, const T& EpsPrime = mb_zero<T>()) {
2262  if (m_status == ACTIVE) {
2263  m_pCL->AfterConvergence(Eps - m_EpsRef, EpsPrime);
2264  }
2265  };
2266 
2267  // FIXME: OutputAppend() ?
2268 };
2269 
2270 /* BiStopCLWrapper - end */
2271 
2272 /* helpers */
2273 template <class T>
2274 void
2275 GetPreStress(MBDynParser& HP, T& PreStress)
2276 {
2277  if (HP.IsKeyWord("prestress")) {
2278  PreStress = HP.Get(PreStress);
2279  }
2280 }
2281 
2282 template <class T>
2283 TplDriveCaller<T>*
2284 GetPreStrain(const DataManager* pDM, MBDynParser& HP)
2285 {
2286  if (HP.IsKeyWord("prestrain")) {
2287  return HP.GetTplDriveCaller<T>();
2288  }
2289 
2290  TplDriveCaller<T> *pTplDC = 0;
2291 
2292  SAFENEW(pTplDC, ZeroTplDriveCaller<T>);
2293 
2294  return pTplDC;
2295 }
2296 
2297 #endif // CONSTLTP_IMPL_H
Hint
Definition: hint.h:38
ConstitutiveLaw::GetF
virtual const T & GetF(void) const
Definition: constltp.h:125
LinearViscoElasticIsotropicConstitutiveLaw1D
LinearViscoElasticIsotropicConstitutiveLaw< doublereal, doublereal > LinearViscoElasticIsotropicConstitutiveLaw1D
Definition: constltp_impl.h:1356
LinearViscoElasticIsotropicConstitutiveLaw::LinearViscoElasticIsotropicConstitutiveLaw
LinearViscoElasticIsotropicConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal dStiff, doublereal dStiffPrime)
Definition: constltp_impl.h:1308
LinearViscoElasticGenericConstitutiveLaw6D
LinearViscoElasticGenericConstitutiveLaw< Vec6, Mat6x6 > LinearViscoElasticGenericConstitutiveLaw6D
Definition: constltp_impl.h:1418
DoubleLinearViscoElasticConstitutiveLaw::DoubleLinearViscoElasticConstitutiveLaw
DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal=0., doublereal=0., doublereal=0., doublereal=0., doublereal=0., doublereal=0.)
Definition: constltp_impl.h:1795
CubicViscoElasticGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1631
LinearViscousIsotropicConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1224
BiStopCLWrapper::Update
virtual void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:2216
MBDynParser::GetTplDriveCaller
TplDriveCaller< T > * GetTplDriveCaller(void)
Definition: mbpar.cc:2112
CubicElasticGenericConstitutiveLaw< doublereal, doublereal >::CubicElasticGenericConstitutiveLaw
CubicElasticGenericConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, const doublereal &Stiff1, const doublereal &Stiff2, const doublereal &Stiff3)
Definition: constltp_impl.h:497
IsotropicHardeningConstitutiveLaw1D
IsotropicHardeningConstitutiveLaw< doublereal, doublereal > IsotropicHardeningConstitutiveLaw1D
Definition: constltp_impl.h:1029
Zero3
const Vec3 Zero3(0., 0., 0.)
mb_zero< Vec6 >
const Vec6 & mb_zero< Vec6 >(void)
Definition: matvec6.h:631
ElasticConstitutiveLaw::~ElasticConstitutiveLaw
virtual ~ElasticConstitutiveLaw(void)
Definition: constltp_impl.h:189
DoubleLinearElasticConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:787
BiStopCLWrapper::m_pActivatingCondition
const DriveCaller * m_pActivatingCondition
Definition: constltp_impl.h:2158
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::pCopy
virtual ConstitutiveLaw< Vec6, Mat6x6 > * pCopy(void) const
Definition: constltp_impl.h:1573
IsotropicHardeningConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &=Zero3)
Definition: constltp_impl.h:1018
LinearElasticGenericConstitutiveLaw::~LinearElasticGenericConstitutiveLaw
virtual ~LinearElasticGenericConstitutiveLaw(void)
Definition: constltp_impl.h:336
LinearViscoElasticGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1400
flag
long int flag
Definition: mbdyn.h:43
LTVViscoElasticGenericConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1454
grad::pow
GradientExpression< BinaryExpr< FuncPow, LhsExpr, RhsExpr > > pow(const GradientExpression< LhsExpr > &u, const GradientExpression< RhsExpr > &v)
Definition: gradient.h:2961
MBDYN_EXCEPT_ARGS
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
LinearElasticGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:340
Vec3
Definition: matvec3.h:98
IsotropicHardeningConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:994
ConstitutiveLawArray::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:98
tpldrive_impl.h
LinearViscoElasticGenericConstitutiveLaw::LinearViscoElasticGenericConstitutiveLaw
LinearViscoElasticGenericConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const Tder &Stiff, const Tder &StiffPrime)
Definition: constltp_impl.h:1369
BiStopCLWrapper::m_pCL
ConstitutiveLaw< T, Tder > * m_pCL
Definition: constltp_impl.h:2156
BiStopCLWrapper::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:2201
ConstitutiveLawArray::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:85
ContactConstitutiveLaw3D
ContactConstitutiveLaw< Vec3, Mat3x3 > ContactConstitutiveLaw3D
Definition: constltp_impl.h:1194
IsotropicHardeningConstitutiveLaw6D
IsotropicHardeningConstitutiveLaw< Vec6, Mat6x6 > IsotropicHardeningConstitutiveLaw6D
Definition: constltp_impl.h:1031
TurbulentViscoElasticConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:2054
LinearElasticIsotropicConstitutiveLaw1D
LinearElasticIsotropicConstitutiveLaw< doublereal, doublereal > LinearElasticIsotropicConstitutiveLaw1D
Definition: constltp_impl.h:317
CubicElasticGenericConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw1D * pCopy(void) const
Definition: constltp_impl.h:510
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:441
ConstitutiveLawArray::m_type
ConstLawType::Type m_type
Definition: constltp_impl.h:53
LinearViscoElasticIsotropicConstitutiveLaw3D
LinearViscoElasticIsotropicConstitutiveLaw< Vec3, Mat3x3 > LinearViscoElasticIsotropicConstitutiveLaw3D
Definition: constltp_impl.h:1357
Write
std::ostream & Write(std::ostream &out, const FullMatrixHandler &m, const char *s, const char *s2)
Definition: fullmh.cc:376
LogConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:696
LinearElasticGenericConstitutiveLaw3D
LinearElasticGenericConstitutiveLaw< Vec3, Mat3x3 > LinearElasticGenericConstitutiveLaw3D
Definition: constltp_impl.h:366
LTVViscoElasticGenericConstitutiveLaw6D
LTVViscoElasticGenericConstitutiveLaw< Vec6, Mat6x6 > LTVViscoElasticGenericConstitutiveLaw6D
Definition: constltp_impl.h:1504
CubicViscoElasticGenericConstitutiveLaw::CubicViscoElasticGenericConstitutiveLaw
CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const T &Stiff1, const T &Stiff2, const T &Stiff3, const Tder &StiffPrime)
Definition: constltp_impl.h:1619
ConstitutiveLaw::GetFDE
virtual const Tder & GetFDE(void) const
Definition: constltp.h:129
LinearViscoElasticIsotropicConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1340
DoubleLinearViscoElasticConstitutiveLaw< Vec3, Mat3x3 >::DoubleLinearViscoElasticConstitutiveLaw
DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller< Vec3 > *pDC, const Vec3 &PStress, doublereal dStiff, doublereal dUppLimStrain, doublereal dLowLimStrain, doublereal dSecondStiff, doublereal dStiffPrime, doublereal dSecondStiffPrime)
Definition: constltp_impl.h:1938
LTVViscoElasticGenericConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1483
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1536
BiStopCLWrapper::AfterConvergence
virtual void AfterConvergence(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:2261
LogConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:700
BiStopCLWrapper::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:2186
ConstitutiveLawArray::AfterConvergence
virtual void AfterConvergence(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:140
ElasticConstitutiveLaw1D
ElasticConstitutiveLaw< doublereal, doublereal > ElasticConstitutiveLaw1D
Definition: constltp_impl.h:267
NO_OP
#define NO_OP
Definition: myassert.h:74
LogConstitutiveLaw::~LogConstitutiveLaw
virtual ~LogConstitutiveLaw(void)
Definition: constltp_impl.h:688
DoubleLinearViscoElasticConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1816
CubicElasticGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:475
DoubleLinearViscoElasticConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1886
SimulationEntity::Hints
std::vector< Hint * > Hints
Definition: simentity.h:89
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:391
ContactConstitutiveLaw< Vec3, Mat3x3 >::ContactConstitutiveLaw
ContactConstitutiveLaw(const TplDriveCaller< Vec3 > *pDC, const Vec3 &PStress, const doublereal &dKappa, const doublereal &dGamma)
Definition: constltp_impl.h:1144
ContactConstitutiveLaw::ContactConstitutiveLaw
ContactConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const doublereal=0., const doublereal=0.)
Definition: constltp_impl.h:1043
TurbulentViscoElasticConstitutiveLaw< doublereal, doublereal >::TurbulentViscoElasticConstitutiveLaw
TurbulentViscoElasticConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, doublereal dStiff, doublereal dStiffPrime, doublereal dTres, doublereal dParabStiff)
Definition: constltp_impl.h:2082
DoubleLinearElasticConstitutiveLaw< Vec3, Mat3x3 >::DoubleLinearElasticConstitutiveLaw
DoubleLinearElasticConstitutiveLaw(const TplDriveCaller< Vec3 > *pDC, const Vec3 &PStress, doublereal dStiff, doublereal dUppLimStrain, doublereal dLowLimStrain, doublereal dSecondStiff)
Definition: constltp_impl.h:883
ContactConstitutiveLaw6D
ContactConstitutiveLaw< Vec6, Mat6x6 > ContactConstitutiveLaw6D
Definition: constltp_impl.h:1195
grad::fabs
GradientExpression< UnaryExpr< FuncFabs, Expr > > fabs(const GradientExpression< Expr > &u)
Definition: gradient.h:2973
LinearElasticGenericConstitutiveLaw6D
LinearElasticGenericConstitutiveLaw< Vec6, Mat6x6 > LinearElasticGenericConstitutiveLaw6D
Definition: constltp_impl.h:367
IsotropicHardeningConstitutiveLaw3D
IsotropicHardeningConstitutiveLaw< Vec3, Mat3x3 > IsotropicHardeningConstitutiveLaw3D
Definition: constltp_impl.h:1030
LogConstitutiveLaw< doublereal, doublereal >::LogConstitutiveLaw
LogConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, doublereal dStiff)
Definition: constltp_impl.h:713
CubicViscoElasticGenericConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1679
Mat3x3DEye
const Mat3x3DEye_Manip Mat3x3DEye
Definition: matvec3.cc:637
DoubleLinearViscoElasticConstitutiveLaw< Vec3, Mat3x3 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1984
LinearViscousIsotropicConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1220
DriveCaller::Restart
virtual std::ostream & Restart(std::ostream &out) const =0
TplDriveOwner::Set
void Set(const TplDriveCaller< T > *pDC)
Definition: tpldrive.h:97
ElasticConstitutiveLaw::Restart_int
virtual std::ostream & Restart_int(std::ostream &out) const
Definition: constltp_impl.h:169
LinearElasticIsotropicConstitutiveLaw::LinearElasticIsotropicConstitutiveLaw
LinearElasticIsotropicConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal dStiff)
Definition: constltp_impl.h:283
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::Update
virtual void Update(const Vec6 &Eps, const Vec6 &=mb_zero< Vec6 >())
Definition: constltp_impl.h:447
BiStopCLWrapper::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:2181
LinearElasticIsotropicConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:305
TurbulentViscoElasticConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:2118
LinearViscousIsotropicConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1236
BiStopCLWrapper::BiStopCLWrapper
BiStopCLWrapper(ConstitutiveLaw< T, Tder > *pCL, bool bInitialStatus, const DriveCaller *pA, const DriveCaller *pD)
Definition: constltp_impl.h:2163
CubicElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::CubicElasticGenericConstitutiveLaw
CubicElasticGenericConstitutiveLaw(const TplDriveCaller< Vec3 > *pDC, const Vec3 &PStress, const Vec3 &Stiff1, const Vec3 &Stiff2, const Vec3 &Stiff3)
Definition: constltp_impl.h:552
Zero3x3
const Mat3x3 Zero3x3(0., 0., 0., 0., 0., 0., 0., 0., 0.)
LTVViscoElasticGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1474
ContactConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1060
IsotropicHardeningConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1009
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::pCopy
virtual ConstitutiveLaw< Vec6, Mat6x6 > * pCopy(void) const
Definition: constltp_impl.h:427
DoubleLinearElasticConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &=0.)
Definition: constltp_impl.h:850
InverseSquareConstitutiveLaw::pCopy
virtual ConstitutiveLaw1D * pCopy(void) const
Definition: constltp_impl.h:646
LogConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &=0.)
Definition: constltp_impl.h:742
CubicElasticGenericConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &=mb_zero< T >())
Definition: constltp_impl.h:483
ConstitutiveLawArray::Update
virtual void Update(const T &Eps, const T &EpsPrime=::mb_zero< T >())
Definition: constltp_impl.h:106
CubicElasticGenericConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:522
Vec6
Definition: matvec6.h:37
TplDriveOwner::pGetDriveCaller
TplDriveCaller< T > * pGetDriveCaller(void) const
Definition: tpldrive.h:105
IsotropicHardeningConstitutiveLaw::~IsotropicHardeningConstitutiveLaw
virtual ~IsotropicHardeningConstitutiveLaw(void)
Definition: constltp_impl.h:990
ElasticConstitutiveLaw::ElasticConstitutiveLaw
ElasticConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress)
Definition: constltp_impl.h:183
LogConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:692
BiStopCLWrapper::m_status
enum Status m_status
Definition: constltp_impl.h:2157
mb_zero
const T & mb_zero(void)
LinearViscousGenericConstitutiveLaw::LinearViscousGenericConstitutiveLaw
LinearViscousGenericConstitutiveLaw(const T &PStress, const Tder &StiffPrime)
Definition: constltp_impl.h:1257
LinearViscoElasticGenericConstitutiveLaw1D
LinearViscoElasticGenericConstitutiveLaw< doublereal, doublereal > LinearViscoElasticGenericConstitutiveLaw1D
Definition: constltp_impl.h:1416
DoubleLinearViscoElasticConstitutiveLaw< doublereal, doublereal >::DoubleLinearViscoElasticConstitutiveLaw
DoubleLinearViscoElasticConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, doublereal dStiff, doublereal dUpp, doublereal dLow, doublereal dSecondS, doublereal dStiffPrime, doublereal dSecondSPrime)
Definition: constltp_impl.h:1842
vector
struct vector vector
SAFENEW
#define SAFENEW(pnt, item)
Definition: mynewmem.h:695
BiStopCLWrapper::~BiStopCLWrapper
virtual ~BiStopCLWrapper(void)
Definition: constltp_impl.h:2177
grad::log
GradientExpression< UnaryExpr< FuncLog, Expr > > log(const GradientExpression< Expr > &u)
Definition: gradient.h:2976
LTVViscoElasticGenericConstitutiveLaw::LTVViscoElasticGenericConstitutiveLaw
LTVViscoElasticGenericConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const Tder &Stiff, const DriveCaller *pdc, const Tder &StiffPrime, const DriveCaller *pdcp)
Definition: constltp_impl.h:1436
LogConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw< doublereal, doublereal > * pCopy(void) const
Definition: constltp_impl.h:724
LinearElasticIsotropicConstitutiveLaw6D
LinearElasticIsotropicConstitutiveLaw< Vec6, Mat6x6 > LinearElasticIsotropicConstitutiveLaw6D
Definition: constltp_impl.h:319
HighParser::IsKeyWord
virtual bool IsKeyWord(const char *sKeyWord)
Definition: parser.cc:910
LogConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:737
DoubleLinearElasticConstitutiveLaw::~DoubleLinearElasticConstitutiveLaw
virtual ~DoubleLinearElasticConstitutiveLaw(void)
Definition: constltp_impl.h:779
DoubleLinearViscoElasticConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1820
ConstitutiveLawArray::ConstitutiveLawArray
ConstitutiveLawArray(const std::vector< ConstitutiveLaw< T, Tder > * > &clv)
Definition: constltp_impl.h:57
Vec3::dGet
const doublereal & dGet(unsigned short int iRow) const
Definition: matvec3.h:285
LinearElasticIsotropicConstitutiveLaw3D
LinearElasticIsotropicConstitutiveLaw< Vec3, Mat3x3 > LinearElasticIsotropicConstitutiveLaw3D
Definition: constltp_impl.h:318
ConstitutiveLawArray::OutputAppend
virtual std::ostream & OutputAppend(std::ostream &out) const
Definition: constltp_impl.h:149
hint_impl.h
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:399
ElasticConstitutiveLaw6D
ElasticConstitutiveLaw< Vec6, Mat6x6 > ElasticConstitutiveLaw6D
Definition: constltp_impl.h:269
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller< Vec6 > *pDC, const Vec6 &PStress, const Mat6x6 &Stiff, const Mat6x6 &StiffPrime, doublereal dAxTors)
Definition: constltp_impl.h:1553
LogConstitutiveLaw::LogConstitutiveLaw
LogConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal=0.)
Definition: constltp_impl.h:681
TurbulentViscoElasticConstitutiveLaw::TurbulentViscoElasticConstitutiveLaw
TurbulentViscoElasticConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal=0., doublereal=0., doublereal=0., doublereal=0.)
Definition: constltp_impl.h:2039
CubicElasticGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:479
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1540
BiStopCLWrapper::m_pDeactivatingCondition
const DriveCaller * m_pDeactivatingCondition
Definition: constltp_impl.h:2159
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::Update
virtual void Update(const Vec6 &Eps, const Vec6 &EpsPrime=mb_zero< Vec6 >())
Definition: constltp_impl.h:1597
DoubleLinearViscoElasticConstitutiveLaw< Vec3, Mat3x3 >::Update
virtual void Update(const Vec3 &Eps, const Vec3 &EpsPrime=Zero3)
Definition: constltp_impl.h:1995
ContactConstitutiveLaw< Vec3, Mat3x3 >::Update
virtual void Update(const Vec3 &Eps, const Vec3 &=Zero3)
Definition: constltp_impl.h:1178
LinearElasticIsotropicConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &=mb_zero< T >())
Definition: constltp_impl.h:310
ASSERT
#define ASSERT(expression)
Definition: colamd.c:977
TplDriveHint::pCreateDrive
TplDriveCaller< T > * pCreateDrive(DataManager *pDM) const
Definition: hint_impl.h:124
DoubleLinearViscoElasticConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:1824
grad::sqrt
GradientExpression< UnaryExpr< FuncSqrt, Expr > > sqrt(const GradientExpression< Expr > &u)
Definition: gradient.h:2974
TurbulentViscoElasticConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:2058
CubicViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::CubicViscoElasticGenericConstitutiveLaw
CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller< Vec3 > *pDC, const Vec3 &PStress, const Vec3 &Stiff1, const Vec3 &Stiff2, const Vec3 &Stiff3, const Mat3x3 &StiffPrime)
Definition: constltp_impl.h:1711
ElasticConstitutiveLaw3D
ElasticConstitutiveLaw< Vec3, Mat3x3 > ElasticConstitutiveLaw3D
Definition: constltp_impl.h:268
CubicElasticGenericConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &=0.)
Definition: constltp_impl.h:530
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:395
SAFENEWWITHCONSTRUCTOR
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
DriveOwner::pGetDriveCaller
DriveCaller * pGetDriveCaller(void) const
Definition: drive.cc:658
DoubleLinearViscoElasticConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &EpsPrime=0.)
Definition: constltp_impl.h:1897
LTVViscoElasticGenericConstitutiveLaw3D
LTVViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 > LTVViscoElasticGenericConstitutiveLaw3D
Definition: constltp_impl.h:1503
LinearViscousIsotropicConstitutiveLaw::Update
virtual void Update(const T &, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1242
GetPreStress
void GetPreStress(MBDynParser &HP, T &PreStress)
Definition: constltp_impl.h:2275
LinearViscousGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1271
ContactConstitutiveLaw< Vec3, Mat3x3 >::pCopy
virtual ConstitutiveLaw< Vec3, Mat3x3 > * pCopy(void) const
Definition: constltp_impl.h:1157
ConstitutiveLaw::AfterConvergence
virtual void AfterConvergence(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp.h:113
CubicElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:577
DoubleLinearElasticConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:783
DoubleLinearElasticConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:791
DriveCaller::pCopy
virtual DriveCaller * pCopy(void) const =0
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw::LinearElasticGenericAxialTorsionCouplingConstitutiveLaw
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const Tder &=mb_zero< Tder >(), doublereal=0.)
Definition: constltp_impl.h:378
CubicElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Update
virtual void Update(const Vec3 &Eps, const Vec3 &=Zero3)
Definition: constltp_impl.h:585
DriveCaller::dGet
virtual doublereal dGet(const doublereal &dVar) const =0
ContactConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1056
TurbulentViscoElasticConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:2066
ContactConstitutiveLaw< Vec3, Mat3x3 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1171
DoubleLinearViscoElasticConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw< doublereal, doublereal > * pCopy(void) const
Definition: constltp_impl.h:1868
LinearViscousIsotropicConstitutiveLaw::LinearViscousIsotropicConstitutiveLaw
LinearViscousIsotropicConstitutiveLaw(const T &PStress, doublereal dStiffPrime)
Definition: constltp_impl.h:1209
IsotropicHardeningConstitutiveLaw::IsotropicHardeningConstitutiveLaw
IsotropicHardeningConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal dStiff, doublereal dStiff0, doublereal dEpsHard)
Definition: constltp_impl.h:975
LinearViscousGenericConstitutiveLaw::~LinearViscousGenericConstitutiveLaw
virtual ~LinearViscousGenericConstitutiveLaw(void)
Definition: constltp_impl.h:1263
ConstitutiveLawArray::SetValue
void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: constltp_impl.h:76
ConstitutiveLawArray::m_clv
std::vector< ConstitutiveLaw< T, Tder > * > m_clv
Definition: constltp_impl.h:54
STRLENOF
#define STRLENOF(s)
Definition: mbdyn.h:166
ElasticConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:194
DoubleLinearElasticConstitutiveLaw< Vec3, Mat3x3 >::Update
virtual void Update(const Vec3 &Eps, const Vec3 &=Zero3)
Definition: constltp_impl.h:926
InverseSquareConstitutiveLaw::~InverseSquareConstitutiveLaw
virtual ~InverseSquareConstitutiveLaw(void)
Definition: constltp_impl.h:642
Mat3x3DEye_Manip::Manipulate
void Manipulate(Mat3x3 &m, const doublereal d) const
Definition: matvec3.h:1463
LinearViscoElasticIsotropicConstitutiveLaw6D
LinearViscoElasticIsotropicConstitutiveLaw< Vec6, Mat6x6 > LinearViscoElasticIsotropicConstitutiveLaw6D
Definition: constltp_impl.h:1358
LinearViscoElasticGenericConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1382
DriveOwner::dGet
doublereal dGet(const doublereal &dVar) const
Definition: drive.cc:664
DoubleLinearElasticConstitutiveLaw< Vec3, Mat3x3 >::pCopy
virtual ConstitutiveLaw< Vec3, Mat3x3 > * pCopy(void) const
Definition: constltp_impl.h:901
ContactConstitutiveLaw::~ContactConstitutiveLaw
virtual ~ContactConstitutiveLaw(void)
Definition: constltp_impl.h:1052
TurbulentViscoElasticConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &EpsPrime=0.)
Definition: constltp_impl.h:2127
CubicElasticGenericConstitutiveLaw::~CubicElasticGenericConstitutiveLaw
virtual ~CubicElasticGenericConstitutiveLaw(void)
Definition: constltp_impl.h:471
LinearViscousGenericConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1267
CubicElasticGenericConstitutiveLaw::CubicElasticGenericConstitutiveLaw
CubicElasticGenericConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const T &Stiff1, const T &Stiff2, const T &Stiff3)
Definition: constltp_impl.h:464
ContactConstitutiveLaw::Update
virtual void Update(const T &, const T &=mb_zero< T >())
Definition: constltp_impl.h:1064
ConstitutiveLawArray::~ConstitutiveLawArray
virtual ~ConstitutiveLawArray(void)
Definition: constltp_impl.h:67
LinearViscoElasticGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1386
LTVViscoElasticGenericConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1458
DoubleLinearViscoElasticConstitutiveLaw< Vec3, Mat3x3 >::pCopy
virtual ConstitutiveLaw< Vec3, Mat3x3 > * pCopy(void) const
Definition: constltp_impl.h:1966
LinearElasticGenericConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &=mb_zero< T >())
Definition: constltp_impl.h:358
CubicViscoElasticGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1635
ConstitutiveLaw::GetFDEPrime
virtual const Tder & GetFDEPrime(void) const
Definition: constltp.h:133
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 >::LinearElasticGenericAxialTorsionCouplingConstitutiveLaw
LinearElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller< Vec6 > *pDC, const Vec6 &PStress, const Mat6x6 &Stiff, doublereal dAxTors)
Definition: constltp_impl.h:413
ElasticConstitutiveLaw::SetValue
void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: constltp_impl.h:198
LinearViscousGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1283
LinearViscoElasticGenericConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1407
DoubleLinearViscoElasticConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1812
LinearElasticIsotropicConstitutiveLaw::~LinearElasticIsotropicConstitutiveLaw
virtual ~LinearElasticIsotropicConstitutiveLaw(void)
Definition: constltp_impl.h:289
LinearViscoElasticIsotropicConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1347
Mat3x3::Put
void Put(unsigned short int iRow, unsigned short int iCol, const doublereal &dCoef)
Definition: matvec3.h:758
LinearViscoElasticIsotropicConstitutiveLaw::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:1322
TplVecHint::pCreateVec
T pCreateVec(DataManager *pDM) const
Definition: hint_impl.h:84
CubicViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Update
virtual void Update(const Vec3 &Eps, const Vec3 &EpsPrime=Zero3)
Definition: constltp_impl.h:1746
DoubleLinearElasticConstitutiveLaw< doublereal, doublereal >::DoubleLinearElasticConstitutiveLaw
DoubleLinearElasticConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, doublereal dStiff, doublereal dUppLimStrain, doublereal dLowLimStrain, doublereal dSecondStiff)
Definition: constltp_impl.h:807
MBDynParser::Get
virtual doublereal Get(const doublereal &d)
Definition: mbpar.cc:2213
InverseSquareConstitutiveLaw::Update
virtual void Update(const doublereal &Eps, const doublereal &=0.)
Definition: constltp_impl.h:662
doublereal
double doublereal
Definition: colamd.c:52
CubicViscoElasticGenericConstitutiveLaw::Update
virtual void Update(const T &Eps, const T &=mb_zero< T >())
Definition: constltp_impl.h:1639
LinearViscoElasticIsotropicConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1326
InverseSquareConstitutiveLaw::InverseSquareConstitutiveLaw
InverseSquareConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, const doublereal &A, const doublereal &L0)
Definition: constltp_impl.h:633
LinearElasticGenericConstitutiveLaw1D
LinearElasticGenericConstitutiveLaw< doublereal, doublereal > LinearElasticGenericConstitutiveLaw1D
Definition: constltp_impl.h:365
InverseSquareConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:657
LTVViscoElasticGenericConstitutiveLaw1D
LTVViscoElasticGenericConstitutiveLaw< doublereal, doublereal > LTVViscoElasticGenericConstitutiveLaw1D
Definition: constltp_impl.h:1502
DoubleLinearElasticConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw< doublereal, doublereal > * pCopy(void) const
Definition: constltp_impl.h:825
DoubleLinearElasticConstitutiveLaw::DoubleLinearElasticConstitutiveLaw
DoubleLinearElasticConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, doublereal=0., doublereal=0., doublereal=0., doublereal=0.)
Definition: constltp_impl.h:768
ContactConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &=0.)
Definition: constltp_impl.h:1120
CubicViscoElasticGenericConstitutiveLaw< doublereal, doublereal >::Update
virtual void Update(const doublereal &Eps, const doublereal &EpsPrime=0.)
Definition: constltp_impl.h:1688
ContactConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw< doublereal, doublereal > * pCopy(void) const
Definition: constltp_impl.h:1099
LinearElasticGenericConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:352
ContactConstitutiveLaw1D
ContactConstitutiveLaw< doublereal, doublereal > ContactConstitutiveLaw1D
Definition: constltp_impl.h:1193
TplDriveOwner::Get
T Get(void) const
Definition: tpldrive.h:113
ContactConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1113
DoubleLinearElasticConstitutiveLaw< doublereal, doublereal >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:841
CubicViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::pCopy
virtual ConstitutiveLaw3D * pCopy(void) const
Definition: constltp_impl.h:1725
ElasticConstitutiveLaw::ParseHint
virtual Hint * ParseHint(DataManager *pDM, const char *s) const
Definition: constltp_impl.h:230
CubicViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:1737
ContactConstitutiveLaw< doublereal, doublereal >::ContactConstitutiveLaw
ContactConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, const doublereal &dKappa, const doublereal &dGamma)
Definition: constltp_impl.h:1087
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw6D
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw< Vec6, Mat6x6 > LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw6D
Definition: constltp_impl.h:1608
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw::LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const Tder &Stiff, const Tder &StiffPrime, doublereal dAxTors)
Definition: constltp_impl.h:1514
CubicElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::pCopy
virtual ConstitutiveLaw3D * pCopy(void) const
Definition: constltp_impl.h:565
LinearViscoElasticGenericAxialTorsionCouplingConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:1532
TurbulentViscoElasticConstitutiveLaw::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:2062
LinearViscousGenericConstitutiveLaw::Update
virtual void Update(const T &, const T &EpsPrime=mb_zero< T >())
Definition: constltp_impl.h:1289
ConstitutiveLawArray::GetConstLawType
ConstLawType::Type GetConstLawType(void) const
Definition: constltp_impl.h:72
LinearElasticGenericConstitutiveLaw::LinearElasticGenericConstitutiveLaw
LinearElasticGenericConstitutiveLaw(const TplDriveCaller< T > *pDC, const T &PStress, const Tder &Stiff)
Definition: constltp_impl.h:330
TurbulentViscoElasticConstitutiveLaw< doublereal, doublereal >::pCopy
virtual ConstitutiveLaw< doublereal, doublereal > * pCopy(void) const
Definition: constltp_impl.h:2102
CubicViscoElasticGenericConstitutiveLaw< doublereal, doublereal >::CubicViscoElasticGenericConstitutiveLaw
CubicViscoElasticGenericConstitutiveLaw(const TplDriveCaller< doublereal > *pDC, const doublereal &PStress, const doublereal &Stiff1, const doublereal &Stiff2, const doublereal &Stiff3, const doublereal &StiffPrime)
Definition: constltp_impl.h:1653
LinearElasticIsotropicConstitutiveLaw::pCopy
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const
Definition: constltp_impl.h:293
DoubleLinearElasticConstitutiveLaw< Vec3, Mat3x3 >::Restart
virtual std::ostream & Restart(std::ostream &out) const
Definition: constltp_impl.h:917
LinearViscoElasticGenericConstitutiveLaw3D
LinearViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 > LinearViscoElasticGenericConstitutiveLaw3D
Definition: constltp_impl.h:1417
GetPreStrain
TplDriveCaller< T > * GetPreStrain(const DataManager *pDM, MBDynParser &HP)
Definition: constltp_impl.h:2284