1 /** @file getMaterialMatrix.h
2
3 @brief Provides a simple class to obtain a material matrix pointer
4
5 This file is part of the G+Smo library.
6
7 This Source Code Form is subject to the terms of the Mozilla Public
8 License, v. 2.0. If a copy of the MPL was not distributed with this
9 file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11 Author(s):
12 H.M. Verhelst (2019-..., TU Delft)
13 A. Mantzaflaris (2019-..., Inria)
14 */
15
16 #pragma once
17
18 #include <gsKLShell/gsMaterialMatrixBase.h>
19 #include <gsKLShell/gsMaterialMatrixUtils.h>
20 #include <gsKLShell/gsMaterialMatrix.h>
21 #include <gsKLShell/gsMaterialMatrixLinear.h>
22 #include <gsKLShell/gsMaterialMatrixComposite.h>
23 #include <gsIO/gsOptionList.h>
24
25 namespace gismo
26 {
27
28
29 template<class T>
gsCompositeMatrix(const T Exx,const T Eyy,const T Gxy,const T nuxy,const T nuyx)30 gsMatrix<T> gsCompositeMatrix( const T Exx,
31 const T Eyy,
32 const T Gxy,
33 const T nuxy,
34 const T nuyx
35 )
36 {
37 GISMO_ASSERT(nuyx*Exx == nuxy*Eyy, "No symmetry in material properties for ply! (nu12*E2!=nu21*E1):\n"<<
38 "\tnu12 = "<<nuxy<<"\t E22 = "<<Eyy<<"\t nu12*E22 = "<<nuxy*Eyy<<"\n"
39 <<"\tnu21 = "<<nuyx<<"\t E11 = "<<Exx<<"\t nu21*E11 = "<<nuyx*Exx);
40
41 gsMatrix<T> G(3,3);
42 G.setZero();
43
44 G(0,0) = Exx / (1-nuxy*nuyx);
45 G(1,1) = Eyy / (1-nuxy*nuyx);
46 G(2,2) = Gxy;
47 G(0,1) = nuyx*Exx / (1-nuxy*nuyx);
48 G(1,0) = nuxy*Eyy / (1-nuxy*nuyx);
49 G(2,0) = G(0,2) = G(2,1) = G(1,2) = 0.0;
50 return G;
51 }
52
53 template<class T>
gsCompositeMatrixRaw(const T G11,const T G22,const T G33,const T G12,const T G13,const T G23,const T G21,const T G31,const T G32)54 gsMatrix<T> gsCompositeMatrixRaw( const T G11,
55 const T G22,
56 const T G33,
57 const T G12,
58 const T G13,
59 const T G23,
60 const T G21,
61 const T G31,
62 const T G32 )
63 {
64 gsMatrix<T> G(3,3);
65 G.setZero();
66
67 G(0,0) = G11;
68 G(1,1) = G22;
69 G(2,2) = G33;
70 G(1,0) = G12;
71 G(0,1) = G21;
72 G(0,2) = G13;
73 G(2,0) = G31;
74 G(1,2) = G23;
75 G(2,1) = G32;
76 return G;
77 }
78
79 template<class T>
gsCompositeMatrixRaw(const T G11,const T G22,const T G33,const T G12,const T G13,const T G23)80 gsMatrix<T> gsCompositeMatrixRaw( const T G11,
81 const T G22,
82 const T G33,
83 const T G12,
84 const T G13,
85 const T G23 )
86 {
87 gsMatrix<T> G(3,3);
88 G.setZero();
89
90 G(0,0) = G11;
91 G(1,1) = G22;
92 G(2,2) = G33;
93 G(1,0) = G(0,1) = G12;
94 G(0,2) = G(2,0) = G13;
95 G(1,2) = G(2,1) = G23;
96 return G;
97 }
98
99 /**
100 * @brief Gets a material matrix based on \a options
101 *
102 * @param[in] mp The undeformed geometry
103 * @param[in] thickness The thickness
104 * @param[in] parameters The parameters
105 * @param[in] rho The density
106 * @param[in] options The option list
107 *
108 * @tparam d The dimension of the problem (2 = planar, 3 = surface)
109 * @tparam T Real type
110 *
111 * @return The material matrix.
112 *
113 * @ingroup KLShell
114 *
115 */
116 template<short_t d, class T>
getMaterialMatrix(const gsMultiPatch<T> & mp,const gsFunction<T> & thickness,const std::vector<gsFunction<T> * > & parameters,const gsFunction<T> & rho,const gsOptionList & options)117 gsMaterialMatrixBase<T> * getMaterialMatrix(
118 const gsMultiPatch<T> & mp,
119 const gsFunction<T> & thickness,
120 const std::vector<gsFunction<T> *> & parameters,
121 const gsFunction<T> & rho,
122 const gsOptionList & options
123 )
124 {
125 index_t material = options.askInt("Material",0); // SvK by default
126 bool compressibility = options.askSwitch("Compressibility",false);
127 index_t implementation = options.askInt("Implementation",1);
128
129 enum Material mat = static_cast<enum Material>(material);
130 enum Implementation impl = static_cast<enum Implementation>(implementation);
131
132 if (mat==Material::SvK)
133 {
134 if (impl==Implementation::Composite)
135 GISMO_ERROR("Construct composite material models using the constructor of gsMaterialMatrixComposite directly.");
136 else
137 return new gsMaterialMatrixLinear<d,T>(mp,thickness,parameters,rho);
138 }
139 else
140 {
141 if (impl==Implementation::Composite)
142 GISMO_ERROR("Hyperelastic composites not available");
143 //--------------------------------------NH Incompressible--------------------------------------------------
144 else if ((mat==Material::NH) && (impl==Implementation::Analytical) && (!compressibility))
145 {
146 constexpr int id = encodeMat_id<Material::NH, Implementation::Analytical>::id;
147 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
148 }
149 else if ((mat==Material::NH) && (impl==Implementation::Generalized) && (!compressibility))
150 {
151 constexpr int id = encodeMat_id<Material::NH, Implementation::Generalized>::id;
152 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
153 }
154 else if ((mat==Material::NH) && (impl==Implementation::Spectral) && (!compressibility))
155 {
156 constexpr int id = encodeMat_id<Material::NH, Implementation::Spectral>::id;
157 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
158 }
159 //--------------------------------------NH Compressible--------------------------------------------------
160 else if ((mat==Material::NH) && (impl==Implementation::Analytical) && (compressibility))
161 {
162 constexpr int id = encodeMat_id<Material::NH, Implementation::Analytical>::id;
163 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
164 }
165 else if ((mat==Material::NH) && (impl==Implementation::Generalized) && (compressibility))
166 {
167 constexpr int id = encodeMat_id<Material::NH, Implementation::Generalized>::id;
168 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
169 }
170 else if ((mat==Material::NH) && (impl==Implementation::Spectral) && (compressibility))
171 {
172 constexpr int id = encodeMat_id<Material::NH, Implementation::Spectral>::id;
173 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
174 }
175 //
176 //--------------------------------------NH_ext Incompressible--------------------------------------------------
177 else if ((mat==Material::NH_ext) && (!compressibility))
178 {
179 GISMO_ERROR("Incompressible Extended NH with not available");
180 }
181 //---------------------------------------NH_ext Compressible-------------------------------------------------
182 else if ((mat==Material::NH_ext) && (impl==Implementation::Analytical) && (compressibility))
183 {
184 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Analytical>::id;
185 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
186 }
187 else if ((mat==Material::NH_ext) && (impl==Implementation::Generalized) && (compressibility))
188 {
189 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Generalized>::id;
190 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
191 }
192 else if ((mat==Material::NH_ext) && (impl==Implementation::Spectral) && (compressibility))
193 {
194 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Spectral>::id;
195 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
196 }
197 //
198 //--------------------------------------MR Incompressible--------------------------------------------------
199 else if ((mat==Material::MR) && (impl==Implementation::Analytical) && (!compressibility))
200 {
201 constexpr int id = encodeMat_id<Material::MR, Implementation::Analytical>::id;
202 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
203 }
204 else if ((mat==Material::MR) && (impl==Implementation::Generalized) && (!compressibility))
205 {
206 constexpr int id = encodeMat_id<Material::MR, Implementation::Generalized>::id;
207 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
208 }
209 else if ((mat==Material::MR) && (impl==Implementation::Spectral) && (!compressibility))
210 {
211 constexpr int id = encodeMat_id<Material::MR, Implementation::Spectral>::id;
212 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
213 }
214 //---------------------------------------MR Compressible-------------------------------------------------
215 else if ((mat==Material::MR) && (impl==Implementation::Analytical) && (compressibility))
216 {
217 constexpr int id = encodeMat_id<Material::MR, Implementation::Analytical>::id;
218 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
219 }
220 else if ((mat==Material::MR) && (impl==Implementation::Generalized) && (compressibility))
221 {
222 constexpr int id = encodeMat_id<Material::MR, Implementation::Generalized>::id;
223 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
224 }
225 else if ((mat==Material::MR) && (impl==Implementation::Spectral) && (compressibility))
226 {
227 constexpr int id = encodeMat_id<Material::MR, Implementation::Spectral>::id;
228 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
229 }
230 //
231 //--------------------------------------OG Incompressible--------------------------------------------------
232 else if ((mat==Material::OG) && (impl==Implementation::Analytical) && (!compressibility))
233 {
234 GISMO_ERROR("Incompressible Ogden with analytical implementation not available");
235 }
236 else if ((mat==Material::OG) && (impl==Implementation::Generalized) && (!compressibility))
237 {
238 GISMO_ERROR("Incompressible Ogden with generalized implementation not available");
239 }
240 else if ((mat==Material::OG) && (impl==Implementation::Spectral) && (!compressibility))
241 {
242 constexpr int id = encodeMat_id<Material::OG, Implementation::Spectral>::id;
243 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters,rho);
244 }
245 //---------------------------------------OG Compressible-------------------------------------------------
246 else if ((mat==Material::OG) && (impl==Implementation::Analytical) && (compressibility))
247 {
248 GISMO_ERROR("Compressible Ogden with analytical implementation not available");
249 }
250 else if ((mat==Material::OG) && (impl==Implementation::Generalized) && (compressibility))
251 {
252 GISMO_ERROR("Compressible Ogden with generalized implementation not available");
253 }
254 else if ((mat==Material::OG) && (impl==Implementation::Spectral) && (compressibility))
255 {
256 constexpr int id = encodeMat_id<Material::OG, Implementation::Spectral>::id;
257 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters,rho);
258 }
259 else
260 return NULL;
261 }
262 }
263
264 /**
265 * @brief Gets a material matrix based on \a options
266 *
267 * @param[in] mp The undeformed geometry
268 * @param[in] thickness The thickness
269 * @param[in] parameters The parameters
270 * @param[in] options The option list
271 *
272 * @tparam d The dimension of the problem (2 = planar, 3 = surface)
273 * @tparam T Real type
274 *
275 * @return The material matrix.
276 *
277 * @ingroup KLShell
278 *
279 */
280 template<short_t d, class T>
getMaterialMatrix(const gsMultiPatch<T> & mp,const gsFunction<T> & thickness,const std::vector<gsFunction<T> * > & parameters,const gsOptionList & options)281 gsMaterialMatrixBase<T> * getMaterialMatrix(
282 const gsMultiPatch<T> & mp,
283 const gsFunction<T> & thickness,
284 const std::vector<gsFunction<T> *> & parameters,
285 const gsOptionList & options
286 )
287 {
288 index_t material = options.askInt("Material",0); // SvK by default
289 bool compressibility = options.askSwitch("Compressibility",false);
290 index_t implementation = options.askInt("Implementation",1);
291
292 enum Material mat = static_cast<enum Material>(material);
293 enum Implementation impl = static_cast<enum Implementation>(implementation);
294
295 if (mat==Material::SvK)
296 {
297 if (impl==Implementation::Composite)
298 GISMO_ERROR("Construct composite material models using the constructor of gsMaterialMatrixComposite directly.");
299 else
300 return new gsMaterialMatrixLinear<d,T>(mp,thickness,parameters);
301 }
302 else
303 {
304 if (impl==Implementation::Composite)
305 GISMO_ERROR("Hyperelastic composites not available");
306 //--------------------------------------NH Incompressible--------------------------------------------------
307 else if ((mat==Material::NH) && (impl==Implementation::Analytical) && (!compressibility))
308 {
309 constexpr int id = encodeMat_id<Material::NH, Implementation::Analytical>::id;
310 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
311 }
312 else if ((mat==Material::NH) && (impl==Implementation::Generalized) && (!compressibility))
313 {
314 constexpr int id = encodeMat_id<Material::NH, Implementation::Generalized>::id;
315 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
316 }
317 else if ((mat==Material::NH) && (impl==Implementation::Spectral) && (!compressibility))
318 {
319 constexpr int id = encodeMat_id<Material::NH, Implementation::Spectral>::id;
320 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
321 }
322 //--------------------------------------NH Compressible--------------------------------------------------
323 else if ((mat==Material::NH) && (impl==Implementation::Analytical) && (compressibility))
324 {
325 constexpr int id = encodeMat_id<Material::NH, Implementation::Analytical>::id;
326 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
327 }
328 else if ((mat==Material::NH) && (impl==Implementation::Generalized) && (compressibility))
329 {
330 constexpr int id = encodeMat_id<Material::NH, Implementation::Generalized>::id;
331 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
332 }
333 else if ((mat==Material::NH) && (impl==Implementation::Spectral) && (compressibility))
334 {
335 constexpr int id = encodeMat_id<Material::NH, Implementation::Spectral>::id;
336 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
337 }
338 //
339 //--------------------------------------NH_ext Incompressible--------------------------------------------------
340 else if ((mat==Material::NH_ext) && (!compressibility))
341 {
342 GISMO_ERROR("Incompressible Extended NH with not available");
343 }
344 //---------------------------------------NH_ext Compressible-------------------------------------------------
345 else if ((mat==Material::NH_ext) && (impl==Implementation::Analytical) && (compressibility))
346 {
347 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Analytical>::id;
348 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
349 }
350 else if ((mat==Material::NH_ext) && (impl==Implementation::Generalized) && (compressibility))
351 {
352 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Generalized>::id;
353 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
354 }
355 else if ((mat==Material::NH_ext) && (impl==Implementation::Spectral) && (compressibility))
356 {
357 constexpr int id = encodeMat_id<Material::NH_ext, Implementation::Spectral>::id;
358 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
359 }
360 //
361 //--------------------------------------MR Incompressible--------------------------------------------------
362 else if ((mat==Material::MR) && (impl==Implementation::Analytical) && (!compressibility))
363 {
364 constexpr int id = encodeMat_id<Material::MR, Implementation::Analytical>::id;
365 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
366 }
367 else if ((mat==Material::MR) && (impl==Implementation::Generalized) && (!compressibility))
368 {
369 constexpr int id = encodeMat_id<Material::MR, Implementation::Generalized>::id;
370 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
371 }
372 else if ((mat==Material::MR) && (impl==Implementation::Spectral) && (!compressibility))
373 {
374 constexpr int id = encodeMat_id<Material::MR, Implementation::Spectral>::id;
375 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
376 }
377 //---------------------------------------MR Compressible-------------------------------------------------
378 else if ((mat==Material::MR) && (impl==Implementation::Analytical) && (compressibility))
379 {
380 constexpr int id = encodeMat_id<Material::MR, Implementation::Analytical>::id;
381 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
382 }
383 else if ((mat==Material::MR) && (impl==Implementation::Generalized) && (compressibility))
384 {
385 constexpr int id = encodeMat_id<Material::MR, Implementation::Generalized>::id;
386 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
387 }
388 else if ((mat==Material::MR) && (impl==Implementation::Spectral) && (compressibility))
389 {
390 constexpr int id = encodeMat_id<Material::MR, Implementation::Spectral>::id;
391 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
392 }
393 //
394 //--------------------------------------OG Incompressible--------------------------------------------------
395 else if ((mat==Material::OG) && (impl==Implementation::Analytical) && (!compressibility))
396 {
397 GISMO_ERROR("Incompressible Ogden with analytical implementation not available");
398 }
399 else if ((mat==Material::OG) && (impl==Implementation::Generalized) && (!compressibility))
400 {
401 GISMO_ERROR("Incompressible Ogden with generalized implementation not available");
402 }
403 else if ((mat==Material::OG) && (impl==Implementation::Spectral) && (!compressibility))
404 {
405 constexpr int id = encodeMat_id<Material::OG, Implementation::Spectral>::id;
406 return new gsMaterialMatrix<d,real_t,id,false>(mp,thickness,parameters);
407 }
408 //---------------------------------------OG Compressible-------------------------------------------------
409 else if ((mat==Material::OG) && (impl==Implementation::Analytical) && (compressibility))
410 {
411 GISMO_ERROR("Compressible Ogden with analytical implementation not available");
412 }
413 else if ((mat==Material::OG) && (impl==Implementation::Generalized) && (compressibility))
414 {
415 GISMO_ERROR("Compressible Ogden with generalized implementation not available");
416 }
417 else if ((mat==Material::OG) && (impl==Implementation::Spectral) && (compressibility))
418 {
419 constexpr int id = encodeMat_id<Material::OG, Implementation::Spectral>::id;
420 return new gsMaterialMatrix<d,real_t,id,true>(mp,thickness,parameters);
421 }
422 else
423 return NULL;
424 }
425 }
426
427
428
429 } // namespace
430
431