Intrepid: http://trilinos.sandia.gov/packages/docs/r10.0/packages/intrepid/src/Shared/Intrepid

00001 // @HEADER
00002 // ************************************************************************
00003 //
00004 //                           Intrepid Package
00005 //                 Copyright (2007) Sandia Corporation
00006 //
00007 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
00008 // license for use of this work by or on behalf of the U.S. Government.
00009 //
00010 // This library is free software; you can redistribute it and/or modify
00011 // it under the terms of the GNU Lesser General Public License as
00012 // published by the Free Software Foundation; either version 2.1 of the
00013 // License, or (at your option) any later version.
00014 //
00015 // This library is distributed in the hope that it will be useful, but
00016 // WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018 // Lesser General Public License for more details.
00019 //
00020 // You should have received a copy of the GNU Lesser General Public
00021 // License along with this library; if not, write to the Free Software
00022 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00023 // USA
00024 // Questions? Contact Pavel Bochev (pbboche@sandia.gov) or
00025 //                    Denis Ridzal (dridzal@sandia.gov).
00026 //
00027 // ************************************************************************
00028 // @HEADER
00029 
00035 #ifndef INTREPID_INTREPID_TYPES_HPP
00036 #define INTREPID_INTREPID_TYPES_HPP
00037 
00038 #ifdef  HAVE_INTREPID_DEBUG
00039 #define INTREPID_VALIDATE( A )  A
00040 #else
00041 #define INTREPID_VALIDATE( A ) /* empty */
00042 #endif
00043 
00044 #include <Teuchos_ScalarTraits.hpp>
00045 
00049 #define INTREPID_MAX_ORDER 10
00050 
00054 #define INTREPID_MAX_INTEGRATION_POINTS 1001
00055 
00060 #define INTREPID_MAX_CUBATURE_DEGREE_EDGE 61
00061 
00066 #define INTREPID_MAX_CUBATURE_DEGREE_TRI 20
00067 
00072 #define INTREPID_MAX_CUBATURE_DEGREE_TET 20
00073 
00078 #define INTREPID_MAX_CUBATURE_DEGREE_PYRAMID 4
00079 
00083 #define INTREPID_MAX_DIMENSION 3
00084 
00089 #define INTREPID_MAX_NEWTON 15
00090 
00094 #define INTREPID_MAX_DERIVATIVE 10
00095 
00096 namespace Intrepid {
00097   
00100   static const double INTREPID_EPSILON   = std::abs(Teuchos::ScalarTraits<double>::eps());
00101     
00104   static const double INTREPID_THRESHOLD = 10.0 * INTREPID_EPSILON;
00105   
00108   static const double INTREPID_TOL       = 10.0* INTREPID_THRESHOLD;
00109   
00113   enum ECoordinates{
00114     COORDINATES_CARTESIAN=0,
00115     COORDINATES_POLAR,
00116     COORDINATES_CYLINDRICAL,
00117     COORDINATES_SPHERICAL,
00118     COORDINATES_MAX
00119   };
00120 
00121   inline std::string ECoordinatesToString(ECoordinates coords) {
00122     std::string retString;
00123     switch(coords) {
00124       case COORDINATES_CARTESIAN:   retString = "Cartesian";            break;
00125       case COORDINATES_POLAR:       retString = "Polar";                break;
00126       case COORDINATES_CYLINDRICAL: retString = "Cylindrical";          break;
00127       case COORDINATES_SPHERICAL:   retString = "Spherical";            break;
00128       case COORDINATES_MAX:         retString = "Max. Coordinates";     break;
00129       default:                      retString = "INVALID ECoordinates";
00130     }
00131     return retString;
00132   }
00133 
00139   inline int isValidCoordinate(ECoordinates coordinateType){
00140     return( ( coordinateType == COORDINATES_CARTESIAN)   ||
00141             ( coordinateType == COORDINATES_POLAR)       ||
00142             ( coordinateType == COORDINATES_CYLINDRICAL) ||
00143             ( coordinateType == COORDINATES_SPHERICAL) );
00144   }
00145   
00146   
00147   
00151   enum ENorm{
00152     NORM_ONE = 0,
00153     NORM_TWO,
00154     NORM_INF,
00155     NORM_FRO,    // Frobenius matrix norm
00156     NORM_MAX
00157   };
00158 
00159   inline std::string ENormToString(ENorm norm) {
00160     std::string retString;
00161     switch(norm) {
00162       case NORM_ONE:   retString = "1-Norm";         break;
00163       case NORM_TWO:   retString = "2-Norm";         break;
00164       case NORM_INF:   retString = "Infinity Norm";  break;
00165       case NORM_FRO:   retString = "Frobenius Norm"; break;
00166       case NORM_MAX:   retString = "Max. Norm";      break;
00167       default:         retString = "INVALID ENorm";
00168     }
00169     return retString;
00170   }
00171   
00177   inline int isValidNorm(ENorm normType){
00178     return( (normType == NORM_ONE) ||
00179             (normType == NORM_TWO) ||
00180             (normType == NORM_INF) ||
00181             (normType == NORM_FRO) ||
00182             (normType == NORM_MAX) );
00183   }
00184 
00185 
00186   
00192   enum EOperator{
00193     OPERATOR_VALUE = 0,
00194     OPERATOR_GRAD,      // 1
00195     OPERATOR_CURL,      // 2
00196     OPERATOR_DIV,       // 3
00197     OPERATOR_D1,        // 4
00198     OPERATOR_D2,        // 5
00199     OPERATOR_D3,        // 6
00200     OPERATOR_D4,        // 7
00201     OPERATOR_D5,        // 8
00202     OPERATOR_D6,        // 9
00203     OPERATOR_D7,        // 10
00204     OPERATOR_D8,        // 11
00205     OPERATOR_D9,        // 12
00206     OPERATOR_D10,       // 13
00207     OPERATOR_MAX        // 14
00208   };
00209   
00210   inline std::string EOperatorToString(EOperator op) {
00211     std::string retString;
00212     switch(op) {
00213       case OPERATOR_VALUE: retString = "Value";         break;
00214       case OPERATOR_GRAD:  retString = "Grad";          break;
00215       case OPERATOR_CURL:  retString = "Curl";          break;
00216       case OPERATOR_DIV:   retString = "Div";           break;
00217       case OPERATOR_D1:    retString = "D1";            break;
00218       case OPERATOR_D2:    retString = "D2";            break;
00219       case OPERATOR_D3:    retString = "D3";            break;
00220       case OPERATOR_D4:    retString = "D4";            break;
00221       case OPERATOR_D5:    retString = "D5";            break;
00222       case OPERATOR_D6:    retString = "D6";            break;
00223       case OPERATOR_D7:    retString = "D7";            break;
00224       case OPERATOR_D8:    retString = "D8";            break;
00225       case OPERATOR_D9:    retString = "D9";            break;
00226       case OPERATOR_D10:   retString = "D10";           break;
00227       case OPERATOR_MAX:   retString = "Max. Operator"; break;
00228       default:             retString = "INVALID EOperator";
00229     }
00230     return retString;
00231   }
00232   
00233   inline EOperator & operator++(EOperator &type) {
00234     return type = static_cast<EOperator>(type+1);
00235   }
00236     
00237   inline EOperator operator++(EOperator &type, int) {
00238     EOperator oldval = type;
00239     ++type;
00240     return oldval;
00241   }
00242    
00243   inline EOperator & operator--(EOperator &type) {
00244     return type = static_cast<EOperator>(type-1);
00245   }
00246     
00247   inline EOperator operator--(EOperator &type, int) {
00248     EOperator oldval = type;
00249     --type;
00250     return oldval;
00251   }
00252 
00258   inline int isValidOperator(const EOperator operatorType){
00259     return ( (operatorType == OPERATOR_VALUE) ||
00260              (operatorType == OPERATOR_GRAD)  || 
00261              (operatorType == OPERATOR_CURL)  || 
00262              (operatorType == OPERATOR_DIV)   ||
00263              (operatorType == OPERATOR_D1)    || 
00264              (operatorType == OPERATOR_D2)    || 
00265              (operatorType == OPERATOR_D3)    || 
00266              (operatorType == OPERATOR_D4)    || 
00267              (operatorType == OPERATOR_D5)    || 
00268              (operatorType == OPERATOR_D6)    || 
00269              (operatorType == OPERATOR_D7)    || 
00270              (operatorType == OPERATOR_D8)    || 
00271              (operatorType == OPERATOR_D9)    || 
00272              (operatorType == OPERATOR_D10) );
00273   }
00274   
00275   
00279   enum EFunctionSpace
00280     {
00281       FUNCTION_SPACE_HGRAD = 0,
00282       FUNCTION_SPACE_HCURL,
00283       FUNCTION_SPACE_HDIV,
00284       FUNCTION_SPACE_HVOL,
00285       FUNCTION_SPACE_VECTOR_HGRAD,
00286       FUNCTION_SPACE_TENSOR_HGRAD,
00287       FUNCTION_SPACE_MAX
00288     };
00289   
00290   inline std::string EFunctionSpaceToString(EFunctionSpace space) {
00291     std::string retString;
00292     switch(space) {
00293       case FUNCTION_SPACE_HGRAD:        retString = "H(grad)";     break;
00294       case FUNCTION_SPACE_HCURL:        retString = "H(curl)";     break;
00295       case FUNCTION_SPACE_HDIV:         retString = "H(div)";     break;
00296       case FUNCTION_SPACE_HVOL:         retString = "H(vol)";     break;
00297       case FUNCTION_SPACE_VECTOR_HGRAD: retString = "Vector H(grad)";     break;
00298       case FUNCTION_SPACE_TENSOR_HGRAD: retString = "Tensor H(grad)";     break;
00299       case FUNCTION_SPACE_MAX:          retString = "Max. Function space"; break;
00300       default:                          retString = "INVALID EFunctionSpace";
00301     }
00302     return retString;
00303   }
00304   
00310   inline int isValidFunctionSpace(const EFunctionSpace spaceType){
00311     return ( (spaceType == FUNCTION_SPACE_HGRAD) ||
00312              (spaceType == FUNCTION_SPACE_HCURL) || 
00313              (spaceType == FUNCTION_SPACE_HDIV)  ||
00314              (spaceType == FUNCTION_SPACE_HVOL)  ||
00315              (spaceType == FUNCTION_SPACE_VECTOR_HGRAD) || 
00316              (spaceType == FUNCTION_SPACE_TENSOR_HGRAD) );
00317   }
00318   
00319   
00320   
00329   enum EDiscreteSpace
00330     {
00331       DISCRETE_SPACE_COMPLETE = 0,        // value = 0
00332       DISCRETE_SPACE_INCOMPLETE,          // value = 1
00333       DISCRETE_SPACE_BROKEN,              // value = 2
00334       DISCRETE_SPACE_MAX                  // value = 3
00335     };
00336   
00337   inline std::string EDiscreteSpaceToString(EDiscreteSpace space) {
00338     std::string retString;
00339     switch(space) {
00340       case DISCRETE_SPACE_COMPLETE:   retString = "Complete";        break;
00341       case DISCRETE_SPACE_INCOMPLETE: retString = "Incomplete";      break;
00342       case DISCRETE_SPACE_BROKEN:     retString = "Broken";          break;
00343       case DISCRETE_SPACE_MAX:        retString = "Max. Rec. Space"; break;
00344       default:                              retString = "INVALID EDiscreteSpace";
00345     }
00346     return retString;
00347   }
00348   
00354   inline int isValidDiscreteSpace(const EDiscreteSpace spaceType){
00355     return ( (spaceType == DISCRETE_SPACE_COMPLETE) ||
00356              (spaceType == DISCRETE_SPACE_INCOMPLETE) || 
00357              (spaceType ==DISCRETE_SPACE_BROKEN) );
00358   }
00359 
00363   enum EPointType
00364     {
00365       POINTTYPE_EQUISPACED = 0,             // value = 0
00366       POINTTYPE_WARPBLEND 
00367     };
00368   
00369   inline std::string EPointTypeToString(EPointType pointType) {
00370     std::string retString;
00371     switch (pointType) {
00372     case POINTTYPE_EQUISPACED:
00373       retString = "Equispaced Points";
00374       break;
00375     case POINTTYPE_WARPBLEND:
00376       retString = "WarpBlend Points";
00377       break;
00378     }
00379     return retString;
00380   }
00381   
00387   inline int isValidPointType( const EPointType pointType ) {
00388     return ( (pointType == POINTTYPE_EQUISPACED ) ||
00389            (pointType == POINTTYPE_WARPBLEND ) );
00390   }
00391 
00395   enum EBasis
00396     {
00397       BASIS_FEM_DEFAULT = 0,                // value = 0
00398       BASIS_FEM_HIERARCHICAL,               // value = 1  
00399       BASIS_FEM_FIAT,                       // value = 2
00400       BASIS_FVD_DEFAULT,                    // value = 3
00401       BASIS_FVD_COVOLUME,                   // value = 4
00402       BASIS_FVD_MIMETIC,                    // value = 5
00403       BASIS_MAX                             // value = 6
00404     };
00405   
00406   inline std::string EBasisToString(EBasis basis) {
00407     std::string retString;
00408     switch(basis) {
00409       case BASIS_FEM_DEFAULT:      retString = "FEM Default";        break;
00410       case BASIS_FEM_HIERARCHICAL: retString = "FEM Hierarchical";   break;
00411       case BASIS_FEM_FIAT:         retString = "FEM FIAT";           break;
00412       case BASIS_FVD_DEFAULT:      retString = "FVD Default";        break;
00413       case BASIS_FVD_COVOLUME:     retString = "FVD Covolume";       break;
00414       case BASIS_FVD_MIMETIC:      retString = "FVD Mimetic";        break;
00415       case BASIS_MAX:              retString = "Max. Basis";         break;
00416       default:                     retString = "INVALID EBasis";
00417     }
00418     return retString;
00419   }
00420   
00426   inline int isValidBasis(const EBasis basisType){
00427     return ( (basisType == BASIS_FEM_DEFAULT) ||
00428              (basisType == BASIS_FEM_HIERARCHICAL) ||
00429              (basisType == BASIS_FEM_FIAT) ||
00430              (basisType == BASIS_FVD_DEFAULT) ||
00431              (basisType == BASIS_FVD_COVOLUME) ||
00432              (basisType == BASIS_FVD_MIMETIC) );
00433   }
00434 
00435   
00484   struct CubatureTemplate {
00485 
00488     int               numPoints_;
00489     
00492     double            points_[INTREPID_MAX_INTEGRATION_POINTS][INTREPID_MAX_DIMENSION];
00493     
00496     double            weights_[INTREPID_MAX_INTEGRATION_POINTS];
00497     
00498   };
00499 
00500 
00501 
00506   enum ECompEngine
00507   {
00508     COMP_CPP = 0,             
00509     COMP_BLAS,
00510     COMP_ENGINE_MAX
00511   };
00512 
00513   inline std::string ECompEngineToString(ECompEngine cEngine) {
00514     std::string retString;
00515     switch(cEngine) {
00516       case COMP_CPP:             retString = "Native C++";           break;
00517       case COMP_BLAS:            retString = "BLAS";                 break;
00518       case COMP_ENGINE_MAX:      retString = "Max. Comp. Engine";    break;
00519       default:                   retString = "INVALID ECompEngine";
00520     }
00521     return retString;
00522   }
00523   
00524   inline ECompEngine & operator++(ECompEngine &type) {
00525     return type = static_cast<ECompEngine>(type+1);
00526   }
00527 
00528   inline ECompEngine operator++(ECompEngine &type, int) {
00529     ECompEngine oldval = type;
00530     ++type;
00531     return oldval;
00532   }
00533 
00534   inline ECompEngine & operator--(ECompEngine &type) {
00535     return type = static_cast<ECompEngine>(type-1);
00536   }
00537 
00538   inline ECompEngine operator--(ECompEngine &type, int) {
00539     ECompEngine oldval = type;
00540     --type;
00541     return oldval;
00542   }
00543   
00544   
00550   inline int isValidCompEngine(const ECompEngine compEngType){
00551     return ( (compEngType == COMP_CPP) ||
00552              (compEngType == COMP_BLAS) );
00553   }
00554 
00555 } //namespace Intrepid
00556 
00712 #endif
http://trilinos.sandia.gov/packages/docs/r10.0/packages/intrepid/src/Shared/Intrepid_Types.hpp
