/usr/src/RPM/BUILD/trilinos-11.12.1/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.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Pavel Bochev  (pbboche@sandia.gov)
//                    Denis Ridzal  (dridzal@sandia.gov), or
//                    Kara Peterson (kjpeter@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_PYR 11

#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