Intrepid
http://trilinos.sandia.gov/packages/docs/r10.6/packages/intrepid/src/Discretization/Basis/Intrepid_HCURL_TRI_I1_FEMDef.hpp
Go to the documentation of this file.
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 //                    Kara Peterson (kjpeter@sandia.gov).
00027 //
00028 // ************************************************************************
00029 // @HEADER
00030 
00036 namespace Intrepid {
00037 
00038 template<class Scalar, class ArrayScalar>
00039 Basis_HCURL_TRI_I1_FEM<Scalar,ArrayScalar>::Basis_HCURL_TRI_I1_FEM()
00040   {
00041     this -> basisCardinality_  = 3;
00042     this -> basisDegree_       = 1;
00043     this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() );
00044     this -> basisType_         = BASIS_FEM_DEFAULT;
00045     this -> basisCoordinates_  = COORDINATES_CARTESIAN;
00046     this -> basisTagsAreSet_   = false;
00047   }
00048   
00049 template<class Scalar, class ArrayScalar>
00050 void Basis_HCURL_TRI_I1_FEM<Scalar, ArrayScalar>::initializeTags() {
00051   
00052   // Basis-dependent intializations
00053   int tagSize  = 4;        // size of DoF tag
00054   int posScDim = 0;        // position in the tag, counting from 0, of the subcell dim 
00055   int posScOrd = 1;        // position in the tag, counting from 0, of the subcell ordinal
00056   int posDfOrd = 2;        // position in the tag, counting from 0, of DoF ordinal relative to the subcell
00057 
00058   // An array with local DoF tags assigned to basis functions, in the order of their local enumeration 
00059   int tags[]  = {
00060                   1, 0, 0, 1,
00061                   1, 1, 0, 1,
00062                   1, 2, 0, 1 };
00063   
00064   // Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
00065   Intrepid::setOrdinalTagData(this -> tagToOrdinal_,
00066                               this -> ordinalToTag_,
00067                               tags,
00068                               this -> basisCardinality_,
00069                               tagSize,
00070                               posScDim,
00071                               posScOrd,
00072                               posDfOrd);
00073 }
00074 
00075 
00076 
00077 template<class Scalar, class ArrayScalar>
00078 void Basis_HCURL_TRI_I1_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar &        outputValues,
00079                                                             const ArrayScalar &  inputPoints,
00080                                                             const EOperator      operatorType) const {
00081 
00082 // Verify arguments
00083 #ifdef HAVE_INTREPID_DEBUG
00084   Intrepid::getValues_HCURL_Args<Scalar, ArrayScalar>(outputValues,
00085                                                       inputPoints,
00086                                                       operatorType,
00087                                                       this -> getBaseCellTopology(),
00088                                                       this -> getCardinality() );
00089 #endif
00090   
00091  // Number of evaluation points = dim 0 of inputPoints
00092   int dim0 = inputPoints.dimension(0);
00093 
00094   // Temporaries: (x,y) coordinates of the evaluation point
00095   Scalar x = 0.0;                                    
00096   Scalar y = 0.0;                                    
00097   
00098   switch (operatorType) {
00099     case OPERATOR_VALUE:
00100       for (int i0 = 0; i0 < dim0; i0++) {
00101         x = inputPoints(i0, 0);
00102         y = inputPoints(i0, 1);
00103         
00104         // outputValues is a rank-3 array with dimensions (basisCardinality_, dim0, spaceDim)
00105         outputValues(0, i0, 0) =  1.0 - y;
00106         outputValues(0, i0, 1) =  x;
00107 
00108         outputValues(1, i0, 0) = -y;
00109         outputValues(1, i0, 1) =  x;
00110 
00111         outputValues(2, i0, 0) = -y;
00112         outputValues(2, i0, 1) = -1.0 + x;
00113       }
00114       break;
00115       
00116     case OPERATOR_CURL:
00117       for (int i0 = 0; i0 < dim0; i0++) {
00118         x = inputPoints(i0, 0);
00119         y = inputPoints(i0, 1);
00120         
00121         // outputValues is a rank-2 array with dimensions (basisCardinality_, dim0)
00122         outputValues(0, i0) = 2.0;
00123         outputValues(1, i0) = 2.0;
00124         outputValues(2, i0) = 2.0;
00125       }
00126       break;
00127       
00128     case OPERATOR_DIV:
00129        TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument,
00130                           ">>> ERROR (Basis_HCURL_TRI_I1_FEM): DIV is invalid operator for HCURL Basis Functions");
00131       break;
00132       
00133     case OPERATOR_GRAD:
00134        TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
00135                           ">>> ERROR (Basis_HCURL_TRI_I1_FEM): GRAD is invalid operator for HCURL Basis Functions");
00136       break;
00137 
00138     case OPERATOR_D1:
00139     case OPERATOR_D2:
00140     case OPERATOR_D3:
00141     case OPERATOR_D4:
00142     case OPERATOR_D5:
00143     case OPERATOR_D6:
00144     case OPERATOR_D7:
00145     case OPERATOR_D8:
00146     case OPERATOR_D9:
00147     case OPERATOR_D10:
00148       TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1)    ||
00149                             (operatorType == OPERATOR_D2)    ||
00150                             (operatorType == OPERATOR_D3)    ||
00151                             (operatorType == OPERATOR_D4)    ||
00152                             (operatorType == OPERATOR_D5)    ||
00153                             (operatorType == OPERATOR_D6)    ||
00154                             (operatorType == OPERATOR_D7)    ||
00155                             (operatorType == OPERATOR_D8)    ||
00156                             (operatorType == OPERATOR_D9)    ||
00157                             (operatorType == OPERATOR_D10) ),
00158                           std::invalid_argument,
00159                           ">>> ERROR (Basis_HCURL_TRI_I1_FEM): Invalid operator type");
00160       break;
00161 
00162     default:
00163       TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
00164                             (operatorType != OPERATOR_GRAD)  &&
00165                             (operatorType != OPERATOR_CURL)  &&
00166                             (operatorType != OPERATOR_DIV)   &&
00167                             (operatorType != OPERATOR_D1)    &&
00168                             (operatorType != OPERATOR_D2)    &&
00169                             (operatorType != OPERATOR_D3)    &&
00170                             (operatorType != OPERATOR_D4)    &&
00171                             (operatorType != OPERATOR_D5)    &&
00172                             (operatorType != OPERATOR_D6)    &&
00173                             (operatorType != OPERATOR_D7)    &&
00174                             (operatorType != OPERATOR_D8)    &&
00175                             (operatorType != OPERATOR_D9)    &&
00176                             (operatorType != OPERATOR_D10) ),
00177                           std::invalid_argument,
00178                           ">>> ERROR (Basis_HCURL_TRI_I1_FEM): Invalid operator type");
00179   }
00180 }
00181 
00182 
00183   
00184 template<class Scalar, class ArrayScalar>
00185 void Basis_HCURL_TRI_I1_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar&           outputValues,
00186                                                             const ArrayScalar &    inputPoints,
00187                                                             const ArrayScalar &    cellVertices,
00188                                                             const EOperator        operatorType) const {
00189   TEST_FOR_EXCEPTION( (true), std::logic_error,
00190                       ">>> ERROR (Basis_HCURL_TRI_I1_FEM): FEM Basis calling an FVD member function");
00191                                                              }
00192 
00193 }// namespace Intrepid