Sierra Toolkit  Version of the Day
CoordinateSystems.cpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2010 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
13 #include <stdlib.h>
14 
15 #include <sstream>
16 #include <stdexcept>
17 
18 #include <stk_util/util/string_case_compare.hpp>
19 #include <stk_util/environment/ReportHandler.hpp>
20 
21 #include <stk_mesh/fem/CoordinateSystems.hpp>
22 
23 namespace stk_classic {
24 namespace mesh {
25 
26 //----------------------------------------------------------------------
27 
28 namespace {
29 
30 unsigned get_index( const char * const func ,
31  const unsigned number_names ,
32  const char * const * names ,
33  const unsigned size ,
34  const char * const select )
35 {
36  unsigned index = size <= number_names ? 0 : size ;
37 
38  for ( ; index < size && not_equal_case(select,names[index]) ; ++index );
39 
40  ThrowErrorMsgIf( index == size,
41  func << ", size = " << size << " label = " << select );
42  return index ;
43 }
44 
45 const char * get_string( const char * const func ,
46  const unsigned number_names ,
47  const char * const * names ,
48  const unsigned size ,
49  const unsigned index )
50 {
51  ThrowErrorMsgIf( size < number_names || size <= index,
52  func << ", size = " << size << " index = " << index );
53 
54  return names[index];
55 }
56 
57 }
58 
59 //----------------------------------------------------------------------
60 
61 SHARDS_ARRAY_DIM_TAG_SIMPLE_IMPLEMENTATION( SimpleArrayTag )
62 
63 //----------------------------------------------------------------------
64 
65 const Cartesian2d & Cartesian2d::tag()
66 { static const Cartesian2d self ; return self ; }
67 
68 const char * Cartesian2d::name() const
69 { static const char n[] = "Cartesian2d" ; return n ; }
70 
71 namespace {
72 const char * const * Cartesian2d_label() {
73  static const char x[] = "x" ;
74  static const char y[] = "y" ;
75  static const char * label[] = { x , y };
76  return label;
77 }
78 }
79 std::string Cartesian2d::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
80 {
81  return std::string( get_string( Cartesian2d::tag().name() ,
82  2 , Cartesian2d_label() , size , index ) );
83 }
84 
85 shards::ArrayDimTag::size_type Cartesian2d::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
86 {
87  return get_index( Cartesian2d::tag().name() ,
88  2 , Cartesian2d_label() , size , arg.c_str() );
89 }
90 
91 //----------------------------------------------------------------------
92 
94 { static const Cartesian3d self ; return self ; }
95 
96 const char * Cartesian3d::name() const
97 { static const char n[] = "Cartesian3d" ; return n ; }
98 
99 namespace {
100 const char * const * Cartesian3d_label() {
101  static const char x[] = "x" ;
102  static const char y[] = "y" ;
103  static const char z[] = "z" ;
104  static const char * label[] = { x , y , z };
105  return label;
106 }
107 }
108 std::string Cartesian3d::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
109 {
110  return std::string( get_string( Cartesian3d::tag().name() ,
111  3 , Cartesian3d_label() , size , index ) );
112 }
113 
114 shards::ArrayDimTag::size_type Cartesian::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
115 {
116  return get_index( Cartesian3d::tag().name() ,
117  3 , Cartesian3d_label() , size , arg.c_str() );
118 }
119 
120 //----------------------------------------------------------------------
121 
123 { static const Cylindrical self ; return self ; }
124 
125 const char * Cylindrical::name() const
126 { static const char n[] = "Cylindrical" ; return n ; }
127 
128 namespace {
129 const char * const * Cylindrical_label() {
130  static const char r[] = "r" ;
131  static const char a[] = "a" ;
132  static const char z[] = "z" ;
133  static const char * label[] = { r , a , z };
134  return label;
135 }
136 }
137 std::string Cylindrical::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
138 {
139  return std::string( get_string( Cylindrical::tag().name() ,
140  3 , Cylindrical_label() , size , index ) );
141 }
142 
143 shards::ArrayDimTag::size_type Cylindrical::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
144 {
145  return get_index( Cylindrical::tag().name() ,
146  3 , Cylindrical_label() , size , arg.c_str() );
147 }
148 
149 //----------------------------------------------------------------------
150 
152 { static const FullTensor self ; return self ; }
153 
154 const char * FullTensor::name() const
155 { static const char n[] = "FullTensor" ; return n ; }
156 
157 namespace {
158 const char * const * FullTensor36_label() {
159  static const char xx[] = "xx" ;
160  static const char yx[] = "yx" ;
161  static const char zx[] = "zx" ;
162  static const char xy[] = "xy" ;
163  static const char yy[] = "yy" ;
164  static const char zy[] = "zy" ;
165  static const char xz[] = "xz" ;
166  static const char yz[] = "yz" ;
167  static const char zz[] = "zz" ;
168  static const char * label[] = { xx , yy , zz ,
169  xy , yz , zx ,
170  yx , zy , xz };
171  return label;
172 }
173 }
174 std::string FullTensor36::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
175 {
176  return std::string( get_string( FullTensor36::tag().name() ,
177  9 , FullTensor36_label() , size , index ) );
178 }
179 
180 shards::ArrayDimTag::size_type FullTensor::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
181 {
182  return get_index( FullTensor36::tag().name() ,
183  9 , FullTensor36_label() , size , arg.c_str() );
184 }
185 
186 //----------------------------------------------------------------------
187 
189 { static const FullTensor22 self ; return self ; }
190 
191 const char * FullTensor22::name() const
192 { static const char n[] = "FullTensor22" ; return n ; }
193 
194 namespace {
195 const char * const * FullTensor22_label() {
196  static const char xx[] = "xx" ;
197  static const char yy[] = "yy" ;
198  static const char xy[] = "xy" ;
199  static const char yx[] = "yx" ;
200  static const char * label[] = { xx, yy, xy, yx };
201  return label;
202 }
203 }
204 std::string FullTensor22::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
205 {
206  return std::string( get_string( FullTensor22::tag().name() ,
207  4 , FullTensor22_label() , size , index ) );
208 }
209 
210 shards::ArrayDimTag::size_type FullTensor22::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
211 {
212  return get_index( FullTensor22::tag().name() ,
213  4 , FullTensor22_label() , size , arg.c_str() );
214 }
215 
216 //----------------------------------------------------------------------
217 
219 { static const SymmetricTensor33 self ; return self ; }
220 
221 const char * SymmetricTensor::name() const
222 { static const char n[] = "SymmetricTensor" ; return n ; }
223 
224 namespace {
225 const char * const * SymmetricTensor33_label() {
226  static const char xx[] = "xx" ;
227  static const char yy[] = "yy" ;
228  static const char zz[] = "zz" ;
229  static const char xy[] = "xy" ;
230  static const char yz[] = "yz" ;
231  static const char xz[] = "xz" ;
232  static const char * label[] = { xx , yy , zz , xy , yz , xz };
233  return label;
234 }
235 }
236 std::string SymmetricTensor33::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
237 {
238  return std::string( get_string( SymmetricTensor33::tag().name() ,
239  6 , SymmetricTensor33_label() , size , index ) );
240 }
241 
242 shards::ArrayDimTag::size_type SymmetricTensor33::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
243 {
244  return get_index( SymmetricTensor33::tag().name() ,
245  6 , SymmetricTensor33_label() , size , arg.c_str() );
246 }
247 
248 //----------------------------------------------------------------------
249 
251 { static const SymmetricTensor31 self ; return self ; }
252 
253 const char * SymmetricTensor31::name() const
254 { static const char n[] = "SymmetricTensor31" ; return n ; }
255 
256 namespace {
257 const char * const * SymmetricTensor31_label() {
258  static const char rr[] = "rr" ;
259  static const char zz[] = "zz" ;
260  static const char rz[] = "rz" ;
261  static const char zr[] = "zr" ;
262  static const char * label[] = { rr, zz, rz, zr };
263  return label;
264 }
265 }
266 std::string SymmetricTensor31::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
267 {
268  return std::string( get_string( SymmetricTensor31::tag().name() ,
269  4 , SymmetricTensor31_label() , size , index ) );
270 }
271 
272 shards::ArrayDimTag::size_type SymmetricTensor31::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
273 {
274  return get_index( SymmetricTensor31::tag().name() ,
275  4 , SymmetricTensor31_label() , size , arg.c_str() );
276 }
277 
278 //----------------------------------------------------------------------
279 
281 { static const SymmetricTensor21 self ; return self ; }
282 
283 const char * SymmetricTensor21::name() const
284 { static const char n[] = "SymmetricTensor21" ; return n ; }
285 
286 namespace {
287 const char * const * SymmetricTensor21_label() {
288  static const char xx[] = "xx" ;
289  static const char yy[] = "yy" ;
290  static const char xy[] = "xy" ;
291  static const char * label[] = { xx, yy, xy };
292  return label;
293 }
294 }
295 std::string SymmetricTensor21::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
296 {
297  return std::string( get_string( SymmetricTensor21::tag().name() ,
298  3 , SymmetricTensor21_label() , size , index ) );
299 }
300 
301 shards::ArrayDimTag::size_type SymmetricTensor21::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
302 {
303  return get_index( SymmetricTensor21::tag().name() ,
304  3 , SymmetricTensor21_label() , size , arg.c_str() );
305 }
306 
307 //----------------------------------------------------------------------
308 
310 { static const AsymmetricTensor03 self ; return self ; }
311 
312 const char * AsymmetricTensor03::name() const
313 { static const char n[] = "AsymmetricTensor03" ; return n ; }
314 
315 namespace {
316 const char * const * AsymmetricTensor03_label() {
317  static const char yz[] = "yz" ;
318  static const char xz[] = "xz" ;
319  static const char xy[] = "xy" ;
320  static const char * label[] = { xy, yz, xz };
321  return label;
322 }
323 }
324 std::string AsymmetricTensor03::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
325 {
326  return std::string( get_string( AsymmetricTensor03::tag().name() ,
327  3 , AsymmetricTensor03_label() , size , index ) );
328 }
329 
330 shards::ArrayDimTag::size_type AsymmetricTensor03::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
331 {
332  return get_index( AsymmetricTensor03::tag().name() ,
333  3 , AsymmetricTensor03_label() , size , arg.c_str() );
334 }
335 
336 //----------------------------------------------------------------------
337 
339 { static const Matrix22 self ; return self ; }
340 
341 const char * Matrix22::name() const
342 { static const char n[] = "Matrix22" ; return n ; }
343 
344 namespace {
345 const char * const * Matrix22_label() {
346  static const char xx[] = "xx" ;
347  static const char yx[] = "yx" ;
348  static const char xy[] = "xy" ;
349  static const char yy[] = "yy" ;
350  static const char * label[] = { xx , yx, xy, yy };
351  return label;
352 }
353 }
354 std::string Matrix22::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
355 {
356  return std::string( get_string( Matrix22::tag().name() ,
357  4 , Matrix22_label() , size , index ) );
358 }
359 
360 shards::ArrayDimTag::size_type Matrix22::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
361 {
362  return get_index( Matrix22::tag().name() ,
363  4 , Matrix22_label() , size , arg.c_str() );
364 }
365 
366 //----------------------------------------------------------------------
367 
369 { static const Matrix33 self ; return self ; }
370 
371 const char * Matrix33::name() const
372 { static const char n[] = "Matrix33" ; return n ; }
373 
374 namespace {
375 const char * const * Matrix33_label() {
376  static const char xx[] = "xx" ;
377  static const char yx[] = "yx" ;
378  static const char zx[] = "zx" ;
379  static const char xy[] = "xy" ;
380  static const char yy[] = "yy" ;
381  static const char zy[] = "zy" ;
382  static const char xz[] = "xz" ;
383  static const char yz[] = "yz" ;
384  static const char zz[] = "zz" ;
385  static const char * label[] = { xx , yx , zx , xy , yy , zy , xz , yz , zz };
386  return label;
387 }
388 }
389 std::string Matrix33::to_string( shards::ArrayDimTag::size_type size , shards::ArrayDimTag::size_type index ) const
390 {
391  return std::string( get_string( Matrix33::tag().name() ,
392  9 , Matrix33_label() , size , index ) );
393 }
394 
395 shards::ArrayDimTag::size_type Matrix33::to_index( shards::ArrayDimTag::size_type size , const std::string & arg ) const
396 {
397  return get_index( Matrix33::tag().name() ,
398  9 , Matrix33_label() , size , arg.c_str() );
399 }
400 
401 //----------------------------------------------------------------------
402 
403 } // namespace mesh
404 } // namespace stk_classic
405 
static const Matrix22 & tag()
Singleton.
static const SymmetricTensor33 & tag()
Singleton.
static const SymmetricTensor31 & tag()
Singleton.
Implement an shards::ArrayDimTag for AsymmetricTensor.
static const Cartesian2d & tag()
Singleton.
Implement an shards::ArrayDimTag for FullTensor.
static const SymmetricTensor21 & tag()
Singleton.
Implement an shards::ArrayDimTag for SymmetricTensor.
static const FullTensor36 & tag()
Singleton.
Implement an shards::ArrayDimTag for SymmetricTensor.
bool not_equal_case(const char *lhs, const char *rhs)
Case-insensitive inequality compare.
static const Cartesian3d & tag()
Singleton.
Implement an shards::ArrayDimTag for Cylindrical coordinate dimensions.
Implement an shards::ArrayDimTag for Matrix.
static const AsymmetricTensor03 & tag()
Singleton.
Implement an shards::ArrayDimTag for Cartesian coordinate dimensions.
Implement an shards::ArrayDimTag for Matrix.
Sierra Toolkit.
Implement an shards::ArrayDimTag for SymmetricTensor.
static const FullTensor22 & tag()
Singleton.
Implement an shards::ArrayDimTag for FullTensor.
static const Cylindrical & tag()
Singleton.
static const Matrix33 & tag()
Singleton.
Implement an shards::ArrayDimTag for Cartesian 2d coordinate dimensions.