/usr/src/RPM/BUILD/trilinos10-10.6.4/packages/intrepid/src/Shared/Intrepid_Types.hpp

Go to the documentation of this file.

// @HEADER
// ************************************************************************
//
//                           Intrepid Package
//                 Copyright (2007) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Pavel Bochev (pbboche@sandia.gov) or
//                    Denis Ridzal (dridzal@sandia.gov).
//
// ************************************************************************
// @HEADER

#ifndef INTREPID_INTREPID_TYPES_HPP
#define INTREPID_INTREPID_TYPES_HPP

#ifdef  HAVE_INTREPID_DEBUG
#define INTREPID_VALIDATE( A )  A
#else
#define INTREPID_VALIDATE( A ) /* empty */
#endif

#include <Teuchos_ScalarTraits.hpp>

#define INTREPID_MAX_ORDER 10

#define INTREPID_MAX_INTEGRATION_POINTS 1001

#define INTREPID_MAX_CUBATURE_DEGREE_EDGE 61

#define INTREPID_MAX_CUBATURE_DEGREE_TRI 20

#define INTREPID_MAX_CUBATURE_DEGREE_TET 20

#define INTREPID_MAX_CUBATURE_DEGREE_PYRAMID 4

#define INTREPID_MAX_DIMENSION 3

#define INTREPID_MAX_NEWTON 15

#define INTREPID_MAX_DERIVATIVE 10

namespace Intrepid {
  
  static const double INTREPID_EPSILON   = std::abs(Teuchos::ScalarTraits<double>::eps());
    
  static const double INTREPID_THRESHOLD = 10.0 * INTREPID_EPSILON;
  
  static const double INTREPID_TOL       = 10.0* INTREPID_THRESHOLD;
  
  enum ECoordinates{
    COORDINATES_CARTESIAN=0,
    COORDINATES_POLAR,
    COORDINATES_CYLINDRICAL,
    COORDINATES_SPHERICAL,
    COORDINATES_MAX
  };

  inline std::string ECoordinatesToString(ECoordinates coords) {
    std::string retString;
    switch(coords) {
      case COORDINATES_CARTESIAN:   retString = "Cartesian";            break;
      case COORDINATES_POLAR:       retString = "Polar";                break;
      case COORDINATES_CYLINDRICAL: retString = "Cylindrical";          break;
      case COORDINATES_SPHERICAL:   retString = "Spherical";            break;
      case COORDINATES_MAX:         retString = "Max. Coordinates";     break;
      default:                      retString = "INVALID ECoordinates";
    }
    return retString;
  }

  inline int isValidCoordinate(ECoordinates coordinateType){
    return( ( coordinateType == COORDINATES_CARTESIAN)   ||
            ( coordinateType == COORDINATES_POLAR)       ||
            ( coordinateType == COORDINATES_CYLINDRICAL) ||
            ( coordinateType == COORDINATES_SPHERICAL) );
  }
  
  
  
  enum ENorm{
    NORM_ONE = 0,
    NORM_TWO,
    NORM_INF,
    NORM_FRO,    // Frobenius matrix norm
    NORM_MAX
  };

  inline std::string ENormToString(ENorm norm) {
    std::string retString;
    switch(norm) {
      case NORM_ONE:   retString = "1-Norm";         break;
      case NORM_TWO:   retString = "2-Norm";         break;
      case NORM_INF:   retString = "Infinity Norm";  break;
      case NORM_FRO:   retString = "Frobenius Norm"; break;
      case NORM_MAX:   retString = "Max. Norm";      break;
      default:         retString = "INVALID ENorm";
    }
    return retString;
  }
  
  inline int isValidNorm(ENorm normType){
    return( (normType == NORM_ONE) ||
            (normType == NORM_TWO) ||
            (normType == NORM_INF) ||
            (normType == NORM_FRO) ||
            (normType == NORM_MAX) );
  }


  
  enum EOperator{
    OPERATOR_VALUE = 0,
    OPERATOR_GRAD,      // 1
    OPERATOR_CURL,      // 2
    OPERATOR_DIV,       // 3
    OPERATOR_D1,        // 4
    OPERATOR_D2,        // 5
    OPERATOR_D3,        // 6
    OPERATOR_D4,        // 7
    OPERATOR_D5,        // 8
    OPERATOR_D6,        // 9
    OPERATOR_D7,        // 10
    OPERATOR_D8,        // 11
    OPERATOR_D9,        // 12
    OPERATOR_D10,       // 13
    OPERATOR_MAX        // 14
  };
  
  inline std::string EOperatorToString(EOperator op) {
    std::string retString;
    switch(op) {
      case OPERATOR_VALUE: retString = "Value";         break;
      case OPERATOR_GRAD:  retString = "Grad";          break;
      case OPERATOR_CURL:  retString = "Curl";          break;
      case OPERATOR_DIV:   retString = "Div";           break;
      case OPERATOR_D1:    retString = "D1";            break;
      case OPERATOR_D2:    retString = "D2";            break;
      case OPERATOR_D3:    retString = "D3";            break;
      case OPERATOR_D4:    retString = "D4";            break;
      case OPERATOR_D5:    retString = "D5";            break;
      case OPERATOR_D6:    retString = "D6";            break;
      case OPERATOR_D7:    retString = "D7";            break;
      case OPERATOR_D8:    retString = "D8";            break;
      case OPERATOR_D9:    retString = "D9";            break;
      case OPERATOR_D10:   retString = "D10";           break;
      case OPERATOR_MAX:   retString = "Max. Operator"; break;
      default:             retString = "INVALID EOperator";
    }
    return retString;
  }
  
  inline EOperator & operator++(EOperator &type) {
    return type = static_cast<EOperator>(type+1);
  }
    
  inline EOperator operator++(EOperator &type, int) {
    EOperator oldval = type;
    ++type;
    return oldval;
  }
   
  inline EOperator & operator--(EOperator &type) {
    return type = static_cast<EOperator>(type-1);
  }
    
  inline EOperator operator--(EOperator &type, int) {
    EOperator oldval = type;
    --type;
    return oldval;
  }

  inline int isValidOperator(const EOperator operatorType){
    return ( (operatorType == OPERATOR_VALUE) ||
             (operatorType == OPERATOR_GRAD)  || 
             (operatorType == OPERATOR_CURL)  || 
             (operatorType == OPERATOR_DIV)   ||
             (operatorType == OPERATOR_D1)    || 
             (operatorType == OPERATOR_D2)    || 
             (operatorType == OPERATOR_D3)    || 
             (operatorType == OPERATOR_D4)    || 
             (operatorType == OPERATOR_D5)    || 
             (operatorType == OPERATOR_D6)    || 
             (operatorType == OPERATOR_D7)    || 
             (operatorType == OPERATOR_D8)    || 
             (operatorType == OPERATOR_D9)    || 
             (operatorType == OPERATOR_D10) );
  }
  
  
  enum EFunctionSpace
    {
      FUNCTION_SPACE_HGRAD = 0,
      FUNCTION_SPACE_HCURL,
      FUNCTION_SPACE_HDIV,
      FUNCTION_SPACE_HVOL,
      FUNCTION_SPACE_VECTOR_HGRAD,
      FUNCTION_SPACE_TENSOR_HGRAD,
      FUNCTION_SPACE_MAX
    };
  
  inline std::string EFunctionSpaceToString(EFunctionSpace space) {
    std::string retString;
    switch(space) {
      case FUNCTION_SPACE_HGRAD:        retString = "H(grad)";     break;
      case FUNCTION_SPACE_HCURL:        retString = "H(curl)";     break;
      case FUNCTION_SPACE_HDIV:         retString = "H(div)";     break;
      case FUNCTION_SPACE_HVOL:         retString = "H(vol)";     break;
      case FUNCTION_SPACE_VECTOR_HGRAD: retString = "Vector H(grad)";     break;
      case FUNCTION_SPACE_TENSOR_HGRAD: retString = "Tensor H(grad)";     break;
      case FUNCTION_SPACE_MAX:          retString = "Max. Function space"; break;
      default:                          retString = "INVALID EFunctionSpace";
    }
    return retString;
  }
  
  inline int isValidFunctionSpace(const EFunctionSpace spaceType){
    return ( (spaceType == FUNCTION_SPACE_HGRAD) ||
             (spaceType == FUNCTION_SPACE_HCURL) || 
             (spaceType == FUNCTION_SPACE_HDIV)  ||
             (spaceType == FUNCTION_SPACE_HVOL)  ||
             (spaceType == FUNCTION_SPACE_VECTOR_HGRAD) || 
             (spaceType == FUNCTION_SPACE_TENSOR_HGRAD) );
  }
  
  
  
  enum EDiscreteSpace
    {
      DISCRETE_SPACE_COMPLETE = 0,        // value = 0
      DISCRETE_SPACE_INCOMPLETE,          // value = 1
      DISCRETE_SPACE_BROKEN,              // value = 2
      DISCRETE_SPACE_MAX                  // value = 3
    };
  
  inline std::string EDiscreteSpaceToString(EDiscreteSpace space) {
    std::string retString;
    switch(space) {
      case DISCRETE_SPACE_COMPLETE:   retString = "Complete";        break;
      case DISCRETE_SPACE_INCOMPLETE: retString = "Incomplete";      break;
      case DISCRETE_SPACE_BROKEN:     retString = "Broken";          break;
      case DISCRETE_SPACE_MAX:        retString = "Max. Rec. Space"; break;
      default:                              retString = "INVALID EDiscreteSpace";
    }
    return retString;
  }
  
  inline int isValidDiscreteSpace(const EDiscreteSpace spaceType){
    return ( (spaceType == DISCRETE_SPACE_COMPLETE) ||
             (spaceType == DISCRETE_SPACE_INCOMPLETE) || 
             (spaceType ==DISCRETE_SPACE_BROKEN) );
  }

  enum EPointType
    {
      POINTTYPE_EQUISPACED = 0,             // value = 0
      POINTTYPE_SPECTRAL,
      POINTTYPE_SPECTRAL_OPEN,
      POINTTYPE_WARPBLEND 
    };
  
  inline std::string EPointTypeToString(EPointType pointType) {
    std::string retString;
    switch (pointType) {
    case POINTTYPE_EQUISPACED:
      retString = "Equispaced Points";
      break;
    case POINTTYPE_WARPBLEND:
      retString = "WarpBlend Points";
      break;
    case POINTTYPE_SPECTRAL:
      retString = "Spectral Points";
      break;
    case POINTTYPE_SPECTRAL_OPEN:
      retString = "Open Spectral Points";
      break;
    }
    return retString;
  }
  
  inline int isValidPointType( const EPointType pointType ) {
    return ( (pointType == POINTTYPE_EQUISPACED ) ||
           (pointType == POINTTYPE_WARPBLEND ) );
  }

  enum EBasis
    {
      BASIS_FEM_DEFAULT = 0,                // value = 0
      BASIS_FEM_HIERARCHICAL,               // value = 1  
      BASIS_FEM_FIAT,                       // value = 2
      BASIS_FVD_DEFAULT,                    // value = 3
      BASIS_FVD_COVOLUME,                   // value = 4
      BASIS_FVD_MIMETIC,                    // value = 5
      BASIS_MAX                             // value = 6
    };
  
  inline std::string EBasisToString(EBasis basis) {
    std::string retString;
    switch(basis) {
      case BASIS_FEM_DEFAULT:      retString = "FEM Default";        break;
      case BASIS_FEM_HIERARCHICAL: retString = "FEM Hierarchical";   break;
      case BASIS_FEM_FIAT:         retString = "FEM FIAT";           break;
      case BASIS_FVD_DEFAULT:      retString = "FVD Default";        break;
      case BASIS_FVD_COVOLUME:     retString = "FVD Covolume";       break;
      case BASIS_FVD_MIMETIC:      retString = "FVD Mimetic";        break;
      case BASIS_MAX:              retString = "Max. Basis";         break;
      default:                     retString = "INVALID EBasis";
    }
    return retString;
  }
  
  inline int isValidBasis(const EBasis basisType){
    return ( (basisType == BASIS_FEM_DEFAULT) ||
             (basisType == BASIS_FEM_HIERARCHICAL) ||
             (basisType == BASIS_FEM_FIAT) ||
             (basisType == BASIS_FVD_DEFAULT) ||
             (basisType == BASIS_FVD_COVOLUME) ||
             (basisType == BASIS_FVD_MIMETIC) );
  }

  
  struct CubatureTemplate {

    int               numPoints_;
    
    double            points_[INTREPID_MAX_INTEGRATION_POINTS][INTREPID_MAX_DIMENSION];
    
    double            weights_[INTREPID_MAX_INTEGRATION_POINTS];
    
  };



  enum ECompEngine
  {
    COMP_CPP = 0,             
    COMP_BLAS,
    COMP_ENGINE_MAX
  };

  inline std::string ECompEngineToString(ECompEngine cEngine) {
    std::string retString;
    switch(cEngine) {
      case COMP_CPP:             retString = "Native C++";           break;
      case COMP_BLAS:            retString = "BLAS";                 break;
      case COMP_ENGINE_MAX:      retString = "Max. Comp. Engine";    break;
      default:                   retString = "INVALID ECompEngine";
    }
    return retString;
  }
  
  inline ECompEngine & operator++(ECompEngine &type) {
    return type = static_cast<ECompEngine>(type+1);
  }

  inline ECompEngine operator++(ECompEngine &type, int) {
    ECompEngine oldval = type;
    ++type;
    return oldval;
  }

  inline ECompEngine & operator--(ECompEngine &type) {
    return type = static_cast<ECompEngine>(type-1);
  }

  inline ECompEngine operator--(ECompEngine &type, int) {
    ECompEngine oldval = type;
    --type;
    return oldval;
  }
  
  
  inline int isValidCompEngine(const ECompEngine compEngType){
    return ( (compEngType == COMP_CPP) ||
             (compEngType == COMP_BLAS) );
  }

} //namespace Intrepid

#endif