1 /*!
2  * \file   mfront/src/SupportedTypes.cxx
3  *
4  * \brief
5  * \author Thomas Helfer
6  * \date   12 Jan 2007
7  * \copyright Copyright (C) 2006-2018 CEA/DEN, EDF R&D. All rights
8  * re served.
9  * This project is publicly released under either the GNU GPL Licence
10  * or the CECILL-A licence. A copy of thoses licences are delivered
11  * with the sources of TFEL. CEA or EDF may also distribute this
12  * project under specific licensing conditions.
13  */
14 
15 #include <utility>
16 #include <sstream>
17 #include <stdexcept>
18 
19 #include "TFEL/Raise.hxx"
20 #include "MFront/MFrontDebugMode.hxx"
21 #include "MFront/VariableDescription.hxx"
22 #include "MFront/SupportedTypes.hxx"
23 
24 namespace mfront {
25 
26   /*!
27    * \return a map between type names and Supported::TypeFlags
28    */
29   static std::map<std::string, SupportedTypes::TypeFlag>&
SupportedTypes_getFlags()30   SupportedTypes_getFlags() {
31     using namespace std;
32     using TypeFlag = SupportedTypes::TypeFlag;
33     static map<string, TypeFlag> flags = {
34         {"real", SupportedTypes::SCALAR},
35         {"frequency", SupportedTypes::SCALAR},
36         {"stress", SupportedTypes::SCALAR},
37         {"length", SupportedTypes::SCALAR},
38         {"time", SupportedTypes::SCALAR},
39         //    {"stressrate",SupportedTypes::SCALAR},
40         {"strain", SupportedTypes::SCALAR},
41         {"strainrate", SupportedTypes::SCALAR},
42         {"temperature", SupportedTypes::SCALAR},
43         {"energydensity", SupportedTypes::SCALAR},
44         {"thermalexpansion", SupportedTypes::SCALAR},
45         {"thermalconductivity", SupportedTypes::SCALAR},
46         {"massdensity", SupportedTypes::SCALAR},
47         {"TVector", SupportedTypes::TVECTOR},
48         {"Vector", SupportedTypes::TVECTOR},
49         {"Stensor", SupportedTypes::STENSOR},
50         {"Tensor", SupportedTypes::TENSOR},
51         {"StressStensor", SupportedTypes::STENSOR},
52         {"StressRateStensor", SupportedTypes::STENSOR},
53         {"StrainStensor", SupportedTypes::STENSOR},
54         {"StrainRateStensor", SupportedTypes::STENSOR},
55         // CZM
56         {"DisplacementTVector", SupportedTypes::TVECTOR},
57         {"ForceTVector", SupportedTypes::TVECTOR},
58         // Finite Strain
59         {"DeformationGradientTensor", SupportedTypes::TENSOR},
60         {"StressTensor", SupportedTypes::TENSOR},
61         // GenericBehaviour
62         {"HeatFlux", SupportedTypes::TVECTOR},
63         {"TemperatureGradient", SupportedTypes::TVECTOR},
64     };
65     return flags;
66   }  // end of SupportedTypes_getFlags
67 
68   const std::map<std::string, SupportedTypes::TypeFlag>&
getTypeFlags()69   SupportedTypes::getTypeFlags() {
70     return SupportedTypes_getFlags();
71   }  // end of SupportedTypes::getTypeFlags
72 
73   SupportedTypes::TypeSize::TypeSize() = default;
74 
75   SupportedTypes::TypeSize::TypeSize(TypeSize&&) = default;
76 
77   SupportedTypes::TypeSize::TypeSize(const TypeSize&) = default;
78 
TypeSize(const int a,const int b,const int c,const int d)79   SupportedTypes::TypeSize::TypeSize(const int a,
80                                      const int b,
81                                      const int c,
82                                      const int d)
83       : scalarSize(a), tvectorSize(b), stensorSize(c), tensorSize(d) {}
84 
85   SupportedTypes::TypeSize& SupportedTypes::TypeSize::operator=(TypeSize&&) =
86       default;
87 
88   SupportedTypes::TypeSize& SupportedTypes::TypeSize::operator=(
89       const TypeSize&) = default;
90 
operator +=(const TypeSize & rhs)91   SupportedTypes::TypeSize& SupportedTypes::TypeSize::operator+=(
92       const TypeSize& rhs) {
93     this->scalarSize += rhs.scalarSize;
94     this->tvectorSize += rhs.tvectorSize;
95     this->stensorSize += rhs.stensorSize;
96     this->tensorSize += rhs.tensorSize;
97     return *this;
98   }
99 
operator -=(const TypeSize & rhs)100   SupportedTypes::TypeSize& SupportedTypes::TypeSize::operator-=(
101       const TypeSize& rhs) {
102     this->scalarSize -= rhs.scalarSize;
103     this->tvectorSize -= rhs.tvectorSize;
104     this->stensorSize -= rhs.stensorSize;
105     this->tensorSize -= rhs.tensorSize;
106     return *this;
107   }
108 
getValueForDimension(const unsigned short d) const109   int SupportedTypes::TypeSize::getValueForDimension(
110       const unsigned short d) const {
111     switch (d) {
112       case 1:
113         return scalarSize + tvectorSize + 3 * (stensorSize + tensorSize);
114       case 2:
115         return scalarSize + 2 * tvectorSize + 4 * stensorSize + 5 * tensorSize;
116       case 3:
117         return scalarSize + 3 * tvectorSize + 6 * stensorSize + 9 * tensorSize;
118     }
119     tfel::raise(
120         "SupportedTypes::TypeSize::getValueForDimension : "
121         "invalid type size");
122   }  // end of SupportedTypes::TypeSize::getValueForDimension
123 
getValueForModellingHypothesis(const Hypothesis h) const124   int SupportedTypes::TypeSize::getValueForModellingHypothesis(
125       const Hypothesis h) const {
126     return this->getValueForDimension(tfel::material::getSpaceDimension(h));
127   }
128 
operator <<(std::ostream & os,const SupportedTypes::TypeSize & size)129   std::ostream& operator<<(std::ostream& os,
130                            const SupportedTypes::TypeSize& size) {
131     bool first = true;
132     if (size.scalarSize != 0) {
133       os << size.scalarSize;
134       first = false;
135     }
136     if (size.tvectorSize != 0) {
137       if ((!first) && (size.tvectorSize >= 0)) {
138         os << "+";
139       }
140       if (size.tvectorSize == 1) {
141         os << "TVectorSize";
142       } else {
143         os << size.tvectorSize << "*TVectorSize";
144       }
145       first = false;
146     }
147     if (size.stensorSize != 0) {
148       if ((!first) && (size.stensorSize >= 0)) {
149         os << "+";
150       }
151       if (size.stensorSize == 1) {
152         os << "StensorSize";
153       } else {
154         os << size.stensorSize << "*StensorSize";
155       }
156       first = false;
157     }
158     if (size.tensorSize != 0) {
159       if ((!first) && (size.tensorSize >= 0)) {
160         os << "+";
161       }
162       if (size.tensorSize == 1) {
163         os << "TensorSize";
164       } else {
165         os << size.tensorSize << "*TensorSize";
166       }
167       first = false;
168     }
169     if (first) {
170       os << "0";
171     }
172     return os;
173   }
174 
175   SupportedTypes::SupportedTypes() = default;
176 
isSupportedType(const std::string & t) const177   bool SupportedTypes::isSupportedType(const std::string& t) const {
178     const auto& flags = SupportedTypes_getFlags();
179     return flags.find(t) != flags.end();
180   }  // end of SupportedTypes::isSupportedType
181 
getTypeFlag(const std::string & name)182   SupportedTypes::TypeFlag SupportedTypes::getTypeFlag(const std::string& name) {
183     const auto& flags = SupportedTypes_getFlags();
184     const auto p = flags.find(name);
185     tfel::raise_if(p == flags.end(),
186                    "SupportedTypes::getTypeTag: "
187                    "'" + name + "' is not a supported type.");
188     return p->second;
189   }
190 
getTypeSize(const std::string & type,const unsigned short a)191   SupportedTypes::TypeSize SupportedTypes::getTypeSize(const std::string& type,
192                                                        const unsigned short a) {
193     TypeSize res;
194     switch (SupportedTypes::getTypeFlag(type)) {
195       case SCALAR:
196         res = TypeSize(a, 0u, 0u, 0u);
197         break;
198       case TVECTOR:
199         res = TypeSize(0u, a, 0u, 0u);
200         break;
201       case STENSOR:
202         res = TypeSize(0u, 0u, a, 0u);
203         break;
204       case TENSOR:
205         res = TypeSize(0u, 0u, 0u, a);
206         break;
207       default:
208         tfel::raise("SupportedTypes::getTypeSize: internal error.");
209     }
210     return res;
211   }
212 
getTimeDerivativeType(const std::string & type) const213   std::string SupportedTypes::getTimeDerivativeType(
214       const std::string& type) const {
215     if (type == "real") {
216       return "frequency";
217     } else if (type == "strain") {
218       return "strainrate";
219     } else if (type == "stress") {
220       return "stressrate";
221     } else if (type == "Stensor") {
222       return "FrequencyStensor";
223     } else if (type == "StressStensor") {
224       return "StressRateStensor";
225     } else if (type == "StrainStensor") {
226       return "StrainRateStensor";
227     } else if (type == "DeformationGradientTensor") {
228       return "DeformationGradientRateTensor";
229     } else if (type == "Tensor") {
230       return "FrequencyTensor";
231     } else {
232       tfel::raise(
233           "SupportedTypes::getTimeDerivativeType: "
234           "internal error, unsupported type '" +
235           type + "'");
236     }
237   }
238 
getScalarSize() const239   int SupportedTypes::TypeSize::getScalarSize() const {
240     return this->scalarSize;
241   }
242 
getTVectorSize() const243   int SupportedTypes::TypeSize::getTVectorSize() const {
244     return this->tvectorSize;
245   }
246 
getStensorSize() const247   int SupportedTypes::TypeSize::getStensorSize() const {
248     return this->stensorSize;
249   }
250 
getTensorSize() const251   int SupportedTypes::TypeSize::getTensorSize() const {
252     return this->tensorSize;
253   }
254 
operator ==(const TypeSize & rhs) const255   bool SupportedTypes::TypeSize::operator==(const TypeSize& rhs) const {
256     return ((this->getScalarSize() == rhs.getScalarSize()) &&
257             (this->getStensorSize() == rhs.getStensorSize()) &&
258             (this->getTVectorSize() == rhs.getTVectorSize()) &&
259             (this->getTensorSize() == rhs.getTensorSize()));
260   }  // end of SupportedTypes::TypeSize::operator==
261 
operator !=(const TypeSize & rhs) const262   bool SupportedTypes::TypeSize::operator!=(const TypeSize& rhs) const {
263     return !this->operator==(rhs);
264   }  // end of SupportedTypes::TypeSize::operator!=
265 
isNull() const266   bool SupportedTypes::TypeSize::isNull() const {
267     return ((this->getScalarSize() == 0) && (this->getStensorSize() == 0) &&
268             (this->getTVectorSize() == 0) && (this->getTensorSize() == 0));
269   }  // end of SupportedTypes::TypeSize::isNull
270 
isOne() const271   bool SupportedTypes::TypeSize::isOne() const {
272     return ((this->getScalarSize() == 1) && (this->getStensorSize() == 0) &&
273             (this->getTVectorSize() == 0) && (this->getTensorSize() == 0));
274   }  // end of SupportedTypes::TypeSize::isOne
275 
276   SupportedTypes::~SupportedTypes() = default;
277 
to_string(const SupportedTypes::TypeSize & s)278   std::string to_string(const SupportedTypes::TypeSize& s) {
279     std::ostringstream os;
280     os << s;
281     return os.str();
282   }  // end of to_string
283 
284 }  // end of namespace mfront
285