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