1 // Copyright(C) 1999-2020 National Technology & Engineering Solutions
2 // of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with
3 // NTESS, the U.S. Government retains certain rights in this software.
4 //
5 // See packages/seacas/LICENSE for details
6
7 #include <Ioss_ConcreteVariableType.h>
8 #include <Ioss_VariableType.h>
9
10 #include <cassert>
11 #include <string>
12
13 namespace {
X()14 const std::string X() { return std::string("x"); }
Y()15 const std::string Y() { return std::string("y"); }
Z()16 const std::string Z() { return std::string("z"); }
Q()17 const std::string Q() { return std::string("q"); }
S()18 const std::string S() { return std::string("s"); }
19
XX()20 const std::string XX() { return std::string("xx"); }
YY()21 const std::string YY() { return std::string("yy"); }
ZZ()22 const std::string ZZ() { return std::string("zz"); }
XY()23 const std::string XY() { return std::string("xy"); }
YZ()24 const std::string YZ() { return std::string("yz"); }
ZX()25 const std::string ZX() { return std::string("zx"); }
YX()26 const std::string YX() { return std::string("yx"); }
ZY()27 const std::string ZY() { return std::string("zy"); }
XZ()28 const std::string XZ() { return std::string("xz"); }
29
invalid()30 const std::string invalid() { return std::string("invalid"); }
scalar()31 const std::string scalar() { return std::string("scalar"); }
vector_2d()32 const std::string vector_2d() { return std::string("vector_2d"); }
vector_3d()33 const std::string vector_3d() { return std::string("vector_3d"); }
quaternion_2d()34 const std::string quaternion_2d() { return std::string("quaternion_2d"); }
quaternion_3d()35 const std::string quaternion_3d() { return std::string("quaternion_3d"); }
full_tensor_36()36 const std::string full_tensor_36() { return std::string("full_tensor_36"); }
full_tensor_32()37 const std::string full_tensor_32() { return std::string("full_tensor_32"); }
full_tensor_22()38 const std::string full_tensor_22() { return std::string("full_tensor_22"); }
full_tensor_16()39 const std::string full_tensor_16() { return std::string("full_tensor_16"); }
full_tensor_12()40 const std::string full_tensor_12() { return std::string("full_tensor_12"); }
sym_tensor_33()41 const std::string sym_tensor_33() { return std::string("sym_tensor_33"); }
sym_tensor_31()42 const std::string sym_tensor_31() { return std::string("sym_tensor_31"); }
sym_tensor_21()43 const std::string sym_tensor_21() { return std::string("sym_tensor_21"); }
sym_tensor_13()44 const std::string sym_tensor_13() { return std::string("sym_tensor_13"); }
sym_tensor_11()45 const std::string sym_tensor_11() { return std::string("sym_tensor_11"); }
sym_tensor_10()46 const std::string sym_tensor_10() { return std::string("sym_tensor_10"); }
asym_tensor_03()47 const std::string asym_tensor_03() { return std::string("asym_tensor_03"); }
asym_tensor_02()48 const std::string asym_tensor_02() { return std::string("asym_tensor_02"); }
asym_tensor_01()49 const std::string asym_tensor_01() { return std::string("asym_tensor_01"); }
matrix_22()50 const std::string matrix_22() { return std::string("matrix_22"); }
matrix_33()51 const std::string matrix_33() { return std::string("matrix_33"); }
52 } // namespace
53
StorageInitializer()54 Ioss::StorageInitializer::StorageInitializer()
55 {
56 // List all storage types here with a call to their factory method.
57 // This is Used to get the linker to pull in all needed libraries.
58 Ioss::Invalid_Storage::factory();
59 Ioss::Scalar::factory();
60 Ioss::Vector_2D::factory();
61 Ioss::Vector_3D::factory();
62 Ioss::Quaternion_2D::factory();
63 Ioss::Quaternion_3D::factory();
64 Ioss::Full_Tensor_36::factory();
65 Ioss::Full_Tensor_32::factory();
66 Ioss::Full_Tensor_22::factory();
67 Ioss::Full_Tensor_16::factory();
68 Ioss::Full_Tensor_12::factory();
69 Ioss::Sym_Tensor_33::factory();
70 Ioss::Sym_Tensor_31::factory();
71 Ioss::Sym_Tensor_21::factory();
72 Ioss::Sym_Tensor_13::factory();
73 Ioss::Sym_Tensor_11::factory();
74 Ioss::Sym_Tensor_10::factory();
75 Ioss::Asym_Tensor_03::factory();
76 Ioss::Asym_Tensor_02::factory();
77 Ioss::Asym_Tensor_01::factory();
78 Ioss::Matrix_22::factory();
79 Ioss::Matrix_33::factory();
80 }
81
82 // ------------------------------------------------------------------------
Invalid_Storage()83 Ioss::Invalid_Storage::Invalid_Storage() : Ioss::VariableType(invalid(), 0) {}
84
label(int,const char)85 std::string Ioss::Invalid_Storage::label(int /*which*/, const char /*suffix_sep*/) const
86 {
87 return "";
88 }
89
label_name(const std::string & base,int,const char)90 std::string Ioss::Invalid_Storage::label_name(const std::string &base, int /*which*/,
91 const char /*suffix_sep*/) const
92 {
93 return base;
94 }
95
96 // ------------------------------------------------------------------------
97
Scalar()98 Ioss::Scalar::Scalar() : Ioss::VariableType(scalar(), 1)
99 {
100 // Sierra uses 'REAL' as a variable storage type
101 Ioss::VariableType::alias("scalar", "real");
102 // Sierra also uses 'INTEGER' as a variable storage type
103 Ioss::VariableType::alias("scalar", "integer");
104 Ioss::VariableType::alias("scalar", "unsigned integer");
105 }
106
label(int which,const char)107 std::string Ioss::Scalar::label(int which, const char /*suffix_sep*/) const
108 {
109 assert(which > 0 && which <= component_count());
110 switch (which) {
111 case 1: return "";
112 default: return "";
113 }
114 }
115
label_name(const std::string & base,int,const char)116 std::string Ioss::Scalar::label_name(const std::string &base, int /*which*/,
117 const char /*suffix_sep*/) const
118 {
119 return base;
120 }
121
122 // ------------------------------------------------------------------------
123
Vector_2D()124 Ioss::Vector_2D::Vector_2D() : Ioss::VariableType(vector_2d(), 2)
125 {
126 Ioss::VariableType::alias("vector_2d", "pair");
127 }
128
label(int which,const char)129 std::string Ioss::Vector_2D::label(int which, const char /*suffix_sep*/) const
130 {
131 assert(which > 0 && which <= component_count());
132 switch (which) {
133 case 1: return X();
134 case 2: return Y();
135 default: return "";
136 }
137 }
138
139 // ------------------------------------------------------------------------
140
Vector_3D()141 Ioss::Vector_3D::Vector_3D() : Ioss::VariableType(vector_3d(), 3) {}
142
label(int which,const char)143 std::string Ioss::Vector_3D::label(int which, const char /*suffix_sep*/) const
144 {
145 assert(which > 0 && which <= component_count());
146 switch (which) {
147 case 1: return X();
148 case 2: return Y();
149 case 3: return Z();
150 default: return "";
151 }
152 }
153
154 // ------------------------------------------------------------------------
155
Quaternion_2D()156 Ioss::Quaternion_2D::Quaternion_2D() : Ioss::VariableType(quaternion_2d(), 2) {}
157
label(int which,const char)158 std::string Ioss::Quaternion_2D::label(int which, const char /*suffix_sep*/) const
159 {
160 assert(which > 0 && which <= component_count());
161 switch (which) {
162 case 1: return S();
163 case 2: return Q();
164 default: return "";
165 }
166 }
167
168 // ------------------------------------------------------------------------
169
Quaternion_3D()170 Ioss::Quaternion_3D::Quaternion_3D() : Ioss::VariableType(quaternion_3d(), 4) {}
171
label(int which,const char)172 std::string Ioss::Quaternion_3D::label(int which, const char /*suffix_sep*/) const
173 {
174 assert(which > 0 && which <= component_count());
175 switch (which) {
176 case 1: return X();
177 case 2: return Y();
178 case 3: return Z();
179 case 4: return Q();
180 default: return "";
181 }
182 }
183
184 // ------------------------------------------------------------------------
185
Full_Tensor_36()186 Ioss::Full_Tensor_36::Full_Tensor_36() : Ioss::VariableType(full_tensor_36(), 9) {}
187
label(int which,const char)188 std::string Ioss::Full_Tensor_36::label(int which, const char /*suffix_sep*/) const
189 {
190 assert(which > 0 && which <= component_count());
191 switch (which) {
192 case 1: return XX();
193 case 2: return YY();
194 case 3: return ZZ();
195 case 4: return XY();
196 case 5: return YZ();
197 case 6: return ZX();
198 case 7: return YX();
199 case 8: return ZY();
200 case 9: return XZ();
201 default: return "";
202 }
203 }
204
205 // ------------------------------------------------------------------------
206
Full_Tensor_32()207 Ioss::Full_Tensor_32::Full_Tensor_32() : Ioss::VariableType(full_tensor_32(), 5) {}
208
label(int which,const char)209 std::string Ioss::Full_Tensor_32::label(int which, const char /*suffix_sep*/) const
210 {
211 assert(which > 0 && which <= component_count());
212 switch (which) {
213 case 1: return XX();
214 case 2: return YY();
215 case 3: return ZZ();
216 case 4: return XY();
217 case 5: return YX();
218 default: return "";
219 }
220 }
221
222 // ------------------------------------------------------------------------
223
Full_Tensor_22()224 Ioss::Full_Tensor_22::Full_Tensor_22() : Ioss::VariableType(full_tensor_22(), 4) {}
225
label(int which,const char)226 std::string Ioss::Full_Tensor_22::label(int which, const char /*suffix_sep*/) const
227 {
228 assert(which > 0 && which <= component_count());
229 switch (which) {
230 case 1: return XX();
231 case 2: return YY();
232 case 3: return XY();
233 case 4: return YX();
234 default: return "";
235 }
236 }
237
238 // ------------------------------------------------------------------------
239
Full_Tensor_16()240 Ioss::Full_Tensor_16::Full_Tensor_16() : Ioss::VariableType(full_tensor_16(), 7) {}
241
label(int which,const char)242 std::string Ioss::Full_Tensor_16::label(int which, const char /*suffix_sep*/) const
243 {
244 assert(which > 0 && which <= component_count());
245 switch (which) {
246 case 1: return XX();
247 case 2: return XY();
248 case 3: return YZ();
249 case 4: return ZX();
250 case 5: return YX();
251 case 6: return ZY();
252 case 7: return XZ();
253 default: return "";
254 }
255 }
256
257 // ------------------------------------------------------------------------
258
Full_Tensor_12()259 Ioss::Full_Tensor_12::Full_Tensor_12() : Ioss::VariableType(full_tensor_12(), 3) {}
260
label(int which,const char)261 std::string Ioss::Full_Tensor_12::label(int which, const char /*suffix_sep*/) const
262 {
263 assert(which > 0 && which <= component_count());
264 switch (which) {
265 case 1: return XX();
266 case 2: return XY();
267 case 3: return YX();
268 default: return "";
269 }
270 }
271
272 // ------------------------------------------------------------------------
273
Sym_Tensor_33()274 Ioss::Sym_Tensor_33::Sym_Tensor_33() : Ioss::VariableType(sym_tensor_33(), 6) {}
275
label(int which,const char)276 std::string Ioss::Sym_Tensor_33::label(int which, const char /*suffix_sep*/) const
277 {
278 assert(which > 0 && which <= component_count());
279 switch (which) {
280 case 1: return XX();
281 case 2: return YY();
282 case 3: return ZZ();
283 case 4: return XY();
284 case 5: return YZ();
285 case 6: return ZX();
286 default: return "";
287 }
288 }
289
290 // ------------------------------------------------------------------------
291
Sym_Tensor_31()292 Ioss::Sym_Tensor_31::Sym_Tensor_31() : Ioss::VariableType(sym_tensor_31(), 4) {}
293
label(int which,const char)294 std::string Ioss::Sym_Tensor_31::label(int which, const char /*suffix_sep*/) const
295 {
296 assert(which > 0 && which <= component_count());
297 switch (which) {
298 case 1: return XX();
299 case 2: return YY();
300 case 3: return ZZ();
301 case 4: return XY();
302 default: return "";
303 }
304 }
305
306 // ------------------------------------------------------------------------
307
Sym_Tensor_21()308 Ioss::Sym_Tensor_21::Sym_Tensor_21() : Ioss::VariableType(sym_tensor_21(), 3) {}
309
label(int which,const char)310 std::string Ioss::Sym_Tensor_21::label(int which, const char /*suffix_sep*/) const
311 {
312 assert(which > 0 && which <= component_count());
313 switch (which) {
314 case 1: return XX();
315 case 2: return YY();
316 case 3: return XY();
317 default: return "";
318 }
319 }
320
321 // ------------------------------------------------------------------------
322
Sym_Tensor_13()323 Ioss::Sym_Tensor_13::Sym_Tensor_13() : Ioss::VariableType(sym_tensor_13(), 4) {}
324
label(int which,const char)325 std::string Ioss::Sym_Tensor_13::label(int which, const char /*suffix_sep*/) const
326 {
327 assert(which > 0 && which <= component_count());
328 switch (which) {
329 case 1: return XX();
330 case 2: return XY();
331 case 3: return YZ();
332 case 4: return ZX();
333 default: return "";
334 }
335 }
336
337 // ------------------------------------------------------------------------
338
Sym_Tensor_11()339 Ioss::Sym_Tensor_11::Sym_Tensor_11() : Ioss::VariableType(sym_tensor_11(), 2) {}
340
label(int which,const char)341 std::string Ioss::Sym_Tensor_11::label(int which, const char /*suffix_sep*/) const
342 {
343 assert(which > 0 && which <= component_count());
344 switch (which) {
345 case 1: return XX();
346 case 2: return XY();
347 default: return "";
348 }
349 }
350
351 // ------------------------------------------------------------------------
352
Sym_Tensor_10()353 Ioss::Sym_Tensor_10::Sym_Tensor_10() : Ioss::VariableType(sym_tensor_10(), 1) {}
354
label(int which,const char)355 std::string Ioss::Sym_Tensor_10::label(int which, const char /*suffix_sep*/) const
356 {
357 assert(which > 0 && which <= component_count());
358 switch (which) {
359 case 1: return XX();
360 default: return "";
361 }
362 }
363
364 // ------------------------------------------------------------------------
365
Asym_Tensor_03()366 Ioss::Asym_Tensor_03::Asym_Tensor_03() : Ioss::VariableType(asym_tensor_03(), 3) {}
367
label(int which,const char)368 std::string Ioss::Asym_Tensor_03::label(int which, const char /*suffix_sep*/) const
369 {
370 assert(which > 0 && which <= component_count());
371 switch (which) {
372 case 1: return XY();
373 case 2: return YZ();
374 case 3: return ZX();
375 default: return "";
376 }
377 }
378
379 // ------------------------------------------------------------------------
380
Asym_Tensor_02()381 Ioss::Asym_Tensor_02::Asym_Tensor_02() : Ioss::VariableType(asym_tensor_02(), 2) {}
382
label(int which,const char)383 std::string Ioss::Asym_Tensor_02::label(int which, const char /*suffix_sep*/) const
384 {
385 assert(which > 0 && which <= component_count());
386 switch (which) {
387 case 1: return XY();
388 case 2: return YZ();
389 default: return "";
390 }
391 }
392
393 // ------------------------------------------------------------------------
394
Asym_Tensor_01()395 Ioss::Asym_Tensor_01::Asym_Tensor_01() : Ioss::VariableType(asym_tensor_01(), 1) {}
396
label(int which,const char)397 std::string Ioss::Asym_Tensor_01::label(int which, const char /*suffix_sep*/) const
398 {
399 assert(which > 0 && which <= component_count());
400 switch (which) {
401 case 1: return XY();
402 default: return "";
403 }
404 }
405
406 // ------------------------------------------------------------------------
407
Matrix_22()408 Ioss::Matrix_22::Matrix_22() : Ioss::VariableType(matrix_22(), 4) {}
409
label(int which,const char)410 std::string Ioss::Matrix_22::label(int which, const char /*suffix_sep*/) const
411 {
412 assert(which > 0 && which <= component_count());
413 switch (which) {
414 case 1: return XX();
415 case 2: return XY();
416 case 3: return YX();
417 case 4: return YY();
418 default: return "";
419 }
420 }
421
422 // ------------------------------------------------------------------------
423
Matrix_33()424 Ioss::Matrix_33::Matrix_33() : Ioss::VariableType(matrix_33(), 9) {}
425
label(int which,const char)426 std::string Ioss::Matrix_33::label(int which, const char /*suffix_sep*/) const
427 {
428 assert(which > 0 && which <= component_count());
429 switch (which) {
430 case 1: return XX();
431 case 2: return XY();
432 case 3: return XZ();
433 case 4: return YX();
434 case 5: return YY();
435 case 6: return YZ();
436 case 7: return ZX();
437 case 8: return ZY();
438 case 9: return ZZ();
439 default: return "";
440 }
441 }
442
443 // Define all factories here:
factory()444 void Ioss::Invalid_Storage::factory() { static Ioss::Invalid_Storage registerThis; }
445
factory()446 void Ioss::Scalar::factory() { static Ioss::Scalar registerThis; }
447
factory()448 void Ioss::Vector_2D::factory() { static Ioss::Vector_2D registerThis; }
449
factory()450 void Ioss::Vector_3D::factory() { static Ioss::Vector_3D registerThis; }
451
factory()452 void Ioss::Quaternion_2D::factory() { static Ioss::Quaternion_2D registerThis; }
453
factory()454 void Ioss::Quaternion_3D::factory() { static Ioss::Quaternion_3D registerThis; }
455
factory()456 void Ioss::Full_Tensor_36::factory() { static Ioss::Full_Tensor_36 registerThis; }
457
factory()458 void Ioss::Full_Tensor_32::factory() { static Ioss::Full_Tensor_32 registerThis; }
459
factory()460 void Ioss::Full_Tensor_22::factory() { static Ioss::Full_Tensor_22 registerThis; }
461
factory()462 void Ioss::Full_Tensor_16::factory() { static Ioss::Full_Tensor_16 registerThis; }
463
factory()464 void Ioss::Full_Tensor_12::factory() { static Ioss::Full_Tensor_12 registerThis; }
465
factory()466 void Ioss::Sym_Tensor_33::factory() { static Ioss::Sym_Tensor_33 registerThis; }
467
factory()468 void Ioss::Sym_Tensor_31::factory() { static Ioss::Sym_Tensor_31 registerThis; }
469
factory()470 void Ioss::Sym_Tensor_21::factory() { static Ioss::Sym_Tensor_21 registerThis; }
471
factory()472 void Ioss::Sym_Tensor_13::factory() { static Ioss::Sym_Tensor_13 registerThis; }
473
factory()474 void Ioss::Sym_Tensor_11::factory() { static Ioss::Sym_Tensor_11 registerThis; }
475
factory()476 void Ioss::Sym_Tensor_10::factory() { static Ioss::Sym_Tensor_10 registerThis; }
477
factory()478 void Ioss::Asym_Tensor_03::factory() { static Ioss::Asym_Tensor_03 registerThis; }
479
factory()480 void Ioss::Asym_Tensor_02::factory() { static Ioss::Asym_Tensor_02 registerThis; }
481
factory()482 void Ioss::Asym_Tensor_01::factory() { static Ioss::Asym_Tensor_01 registerThis; }
483
factory()484 void Ioss::Matrix_22::factory() { static Ioss::Matrix_22 registerThis; }
485
factory()486 void Ioss::Matrix_33::factory() { static Ioss::Matrix_33 registerThis; }
487