Intrepid_Basis.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_BASIS_HPP
#define INTREPID_BASIS_HPP
#include "Intrepid_ConfigDefs.hpp"
#include "Intrepid_Types.hpp"
#include "Intrepid_Utils.hpp"
#include "Shards_CellTopology.hpp"
 
namespace Intrepid {
    

            As a result, FVD bases require the vertex coordinates of the physical cell but the cell
            itself is not required to have a reference cell.
  
            Every DoF and its corresponding basis function from a given FEM or FVD basis set is 
            assigned an ordinal number which which specifies its numerical position in the DoF set, 
            and a 4-field DoF tag whose first 3 fields establish association between the DoF and a 
            subcell of particular dimension, and the last field gives the total number of basis
            functions associated with that subcell; see Section \ref basis_dof_tag_ord_sec for details.
  
  \remark   To limit memory use by factory-type objects (basis factories will be included in future
            releases of Intrepid), tag data is not initialized by basis ctors,
            instead, whenever a function that requires tag data is invoked for a first time, it calls
            initializeTags() to fill <var>ordinalToTag_</var> and <var>tagToOrdinal_</var>. Because  
            tag data is basis specific, every concrete basis class requires its own implementation
            of initializeTags(). 
  
  \todo     restore test for inclusion of reference points in their resective reference cells in 
            getValues_HGRAD_Args, getValues_CURL_Args, getValues_DIV_Args
  
 */
template<class Scalar, class ArrayScalar>
class Basis {
private:

  virtual void initializeTags() = 0;
  
protected: 
  
  int basisCardinality_;

  int basisDegree_;
  
              http://trilinos.sandia.gov/packages/shards for definition of base cell topology.
   */
  shards::CellTopology basisCellTopology_;
  
  EBasis basisType_;
  
  ECoordinates basisCoordinates_;
  
  /** \brief  "true" if <var>tagToOrdinal_</var> and <var>ordinalToTag_</var> have been initialized
   */
  bool basisTagsAreSet_;
  
              Rank-2 array with dimensions (basisCardinality_, 4) containing the DoF tags. This array 
              is left empty at instantiation and filled by initializeTags() only when tag data is
              requested. 
  
      \li     ordinalToTag_[DofOrd][0] = dim. of the subcell associated with the specified DoF 
      \li     ordinalToTag_[DofOrd][1] = ordinal of the subcell defined in the cell topology
      \li     ordinalToTag_[DodOrd][2] = ordinal of the specified DoF relative to the subcell
      \li     ordinalToTag_[DofOrd][3] = total number of DoFs associated with the subcell
   */
  std::vector<std::vector<int> > ordinalToTag_;
  
  
              Rank-3 array with dimensions (maxScDim + 1, maxScOrd + 1, maxDfOrd + 1), i.e., the 
              columnwise maximums of the 1st three columns in the DoF tag table for the basis plus 1. 
              For every triple (subscDim, subcOrd, subcDofOrd) that is valid DoF tag data this array 
              stores the corresponding DoF ordinal. If the triple does not correspond to tag data, 
              the array stores -1. This array is left empty at instantiation and filled by 
              initializeTags() only when tag data is requested. 
  
      \li     tagToOrdinal_[subcDim][subcOrd][subcDofOrd] = Degree-of-freedom ordinal
   */
  std::vector<std::vector<std::vector<int> > > tagToOrdinal_;  
  
public:
    
  virtual ~Basis() {}
  
        
  virtual void getValues(ArrayScalar &          outputValues,
                         const ArrayScalar &    inputPoints,
                         const EOperator        operatorType) const = 0;
  
        
  virtual void getValues(ArrayScalar &          outputValues,
                         const ArrayScalar &    inputPoints,
                         const ArrayScalar &    cellVertices,
                         const EOperator        operatorType = OPERATOR_VALUE) const = 0;
    
  virtual int getCardinality() const;
  
  
  virtual int getDegree() const;
  
  
  virtual const shards::CellTopology getBaseCellTopology() const;
 
    
  virtual EBasis getBasisType() const;
  
  
  virtual ECoordinates getCoordinateSystem() const;
  
  
  virtual int getDofOrdinal(const int subcDim,
                            const int subcOrd,
                            const int subcDofOrd);  

  virtual const std::vector<std::vector<std::vector<int> > > &getDofOrdinalData( );
 
  
      \param  dofOrd            [in]  - ordinal of the DoF whose tag is being retrieved
    
      \return reference to a vector with dimension (4) such that \n
      \li     element [0] = tag field 0  ->  dim. of the subcell associated with the specified DoF 
      \li     element [1] = tag field 1  ->  ordinal of the subcell defined by cell topology
      \li     element [2] = tag field 2  ->  ordinal of the specified DoF relative to the subcell
      \li     element [3] = tag field 3  ->  total number of DoFs associated with the subcell
   */
  virtual const std::vector<int>&  getDofTag(const int dofOrd);
  
  
  virtual const std::vector<std::vector<int> >& getAllDofTags();
  
  
 
 
}; // class Basis
 
 
//--------------------------------------------------------------------------------------------//
//                                                                                            //
//                            Helper functions of the Basis class                             //
//                                                                                            //
//--------------------------------------------------------------------------------------------//
 
//--------------------------------------------------------------------------------------------//
//                                                                                            //            
//                                        Argument checks                                     //
//                                                                                            //            
//--------------------------------------------------------------------------------------------//

template<class Scalar, class ArrayScalar>
void getValues_HGRAD_Args(ArrayScalar &                outputValues,
                          const ArrayScalar &          inputPoints,
                          const EOperator              operatorType,
                          const shards::CellTopology&  cellTopo,
                          const int                    basisCard);

template<class Scalar, class ArrayScalar>
void getValues_HCURL_Args(ArrayScalar &                outputValues,
                          const ArrayScalar &          inputPoints,
                          const EOperator              operatorType,
                          const shards::CellTopology&  cellTopo,
                          const int                    basisCard);

template<class Scalar, class ArrayScalar>
void getValues_HDIV_Args(ArrayScalar &                outputValues,
                          const ArrayScalar &          inputPoints,
                          const EOperator              operatorType,
                          const shards::CellTopology&  cellTopo,
                          const int                    basisCard);
 

template<class ArrayScalar>
class DofCoordsInterface {
public:
   virtual ~DofCoordsInterface() = 0;

   virtual void getDofCoords(ArrayScalar & DofCoords) const = 0;
};
 
 
// include templated definitions
#include <Intrepid_BasisDef.hpp>
  
 
}// namespace Intrepid
 
 
//--------------------------------------------------------------------------------------------//
//                                                                                            //
//                            D O C U M E N T A T I O N   P A G E S                           //   
//                                                                                            //
//--------------------------------------------------------------------------------------------//

#endif
 
#if defined(Intrepid_SHOW_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#warning "The Intrepid package is deprecated"
#endif
#endif