Intrepid_FieldContainer.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_FIELDCONTAINER_HPP
#define INTREPID_FIELDCONTAINER_HPP

#include "Intrepid_ConfigDefs.hpp"
#include "Intrepid_Types.hpp"
#include "Intrepid_Utils.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_ArrayRCP.hpp"
#include "Teuchos_ArrayView.hpp"
#include "Shards_Array.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_BLAS.hpp"
#include "Teuchos_oblackholestream.hpp"
#include "Teuchos_Assert.hpp"

namespace Intrepid {
  
  template<class Scalar, int ArrayTypeId=0>
  class FieldContainer {
  public:
    typedef Scalar scalar_type;

  protected:
    
    Teuchos::ArrayRCP<Scalar> data_;

    typedef typename Teuchos::ArrayRCP<Scalar>::iterator data_ptr_t;
    data_ptr_t data_ptr_;    

    Teuchos::Array<int> dimensions_;
    
    int dim0_;
    
    int dim1_;
    
    int dim2_;
    
    int dim3_;
    
    int dim4_;
    
  public:
    

    ~FieldContainer() {};
    
    
    FieldContainer() : dim0_(0), dim1_(0), dim2_(0), dim3_(0), dim4_(0) 
    {
      data_.resize(0);
      data_ptr_ = Teuchos::NullIteratorTraits<data_ptr_t>::getNull();
      dimensions_.resize(0);
    } ;
    
    
    FieldContainer(const FieldContainer& right);
 
    
    FieldContainer(const int dim0);
    
    
    FieldContainer(const int dim0,
                   const int dim1);

    
    FieldContainer(const int dim0,
                   const int dim1,
                   const int dim2);

    
    FieldContainer(const int dim0,
                   const int dim1,
                   const int dim2,
                   const int dim3);
    
    
    FieldContainer(const int dim0,
                   const int dim1,
                   const int dim2,
                   const int dim3,
                   const int dim4);
    
    
    FieldContainer(const Teuchos::Array<int>& dimensions);
    
    
    FieldContainer(const Teuchos::Array<int>&        dimensions,
                   const Teuchos::ArrayView<Scalar>& data);


    FieldContainer(const Teuchos::Array<int>&       dimensions,
                   const Teuchos::ArrayRCP<Scalar>& data);


    FieldContainer(const Teuchos::Array<int>&    dimensions,
                   Scalar*                       data,
                   const bool                    deep_copy = false,
                   const bool                    owns_mem  = false);


    FieldContainer(const shards::Array<Scalar,shards::NaturalOrder>&  data,
                   const bool                                         deep_copy = false,
                   const bool                                         owns_mem  = false);



    
    //--------------------------------------------------------------------------------------------//
    //                                                                                            //
    //                            Access methods of FieldContainer class                          //
    //                                                                                            //
    //--------------------------------------------------------------------------------------------//
    
    int rank() const;
    
    
    int size() const;
    
    
    template<class Vector>
    void dimensions(Vector& dimensions) const;
    
    
    int dimension(const int whichDim) const;

    
    int getEnumeration(const int i0) const;
    
    
    int getEnumeration(const int i0,
                       const int i1) const;
    
    
    int getEnumeration(const int i0,
                       const int i1,
                       const int i2) const;
 
    
    int getEnumeration(const int i0,
                       const int i1,
                       const int i2,
                       const int i3) const;
    
    
    int getEnumeration(const int i0,
                       const int i1,
                       const int i2,
                       const int i3,
                       const int i4) const;
    
        
    int getEnumeration(const Teuchos::Array<int>& multiIndex) const;
    
    
    void getMultiIndex(int &     i0,
                       const int valueEnum) const;
    
    
    void getMultiIndex(int &     i0,
                       int &     i1,
                       const int valueEnum) const;
    
    
    void getMultiIndex(int &     i0,
                       int &     i1,
                       int &     i2,
                       const int valueEnum) const;
    
    
    void getMultiIndex(int &     i0,
                       int &     i1,
                       int &     i2,
                       int &     i3,
                       const int valueEnum) const;
    
    
    void getMultiIndex(int &     i0,
                       int &     i1,
                       int &     i2,
                       int &     i3,
                       int &     i4,
                       const int valueEnum) const;
    
    
    template<class Vector>
    void getMultiIndex(Vector&    multiIndex,
                       const int  valueEnum) const;
    
    //--------------------------------------------------------------------------------------------//
    //                                                                                            //
    //                          Methods to shape (resize) a field container                       //
    //                                                                                            //
    //--------------------------------------------------------------------------------------------//
    
    
    void clear();
    
    
    void resize(const int dim0);
    
    
    void resize(const int dim0,
                const int dim1);
    
    
    void resize(const int dim0,
                const int dim1,
                const int dim2);

    
    void resize(const int dim0,
                const int dim1,
                const int dim2,
                const int dim3);
    
    
    void resize(const int dim0,
                const int dim1,
                const int dim2,
                const int dim3,
                const int dim4);
    
    
    void resize(const Teuchos::Array<int>& newDimensions);
        
    
    void resize(const FieldContainer<Scalar, ArrayTypeId>& anotherContainer);
    
    
    void resize(const int             numPoints,
                const int             numFields,
                const EFunctionSpace  spaceType,
                const EOperator       operatorType,
                const int             spaceDim);
    
    //--------------------------------------------------------------------------------------------//
    //                                                                                            //
    //                     Methods to read and write values to FieldContainer                     //
    //                                                                                            //
    //--------------------------------------------------------------------------------------------//

    
    void initialize(const Scalar value = 0); 
        
    
    Scalar getValue(const Teuchos::Array<int>& multiIndex) const;
    
    
    void setValue(const Scalar               dataValue,
                  const Teuchos::Array<int>& multiIndex);
    
    
    void setValue(const Scalar  dataValue,
                  const int     order);
    
    
    void setValues(const Teuchos::ArrayView<Scalar>& dataArray);
    
    
    void setValues(const Scalar* dataPtr, 
                   const int     numData); 
    
    
    Teuchos::ArrayRCP<Scalar> getData() {
      return data_;
    }    


    Teuchos::ArrayRCP<const Scalar> getData() const {
      return data_;
    }    


    const Scalar& operator () (const int i0) const;
    
    Scalar&       operator () (const int i0);
    
    
    const Scalar& operator () (const int i0,
                               const int i1) const;
    
    Scalar&       operator () (const int i0,
                               const int i1);
    
    
    const Scalar& operator () (const int i0,
                               const int i1,
                               const int i2) const;
    
    Scalar&       operator () (const int i0,
                               const int i1,
                               const int i2);
    
    
    const Scalar& operator () (const int i0,
                               const int i1,
                               const int i2,
                               const int i3) const;
    
    Scalar&       operator () (const int i0,
                               const int i1,
                               const int i2,
                               const int i3);
    
    
    const Scalar& operator () (const int i0,
                               const int i1,
                               const int i2,
                               const int i3,
                               const int i4) const;
    
    Scalar&       operator () (const int i0,
                               const int i1,
                               const int i2,
                               const int i3,
                               const int i4);
    
        
    const Scalar & operator [] (const int address) const;

    
    Scalar &       operator [] (const int address);
    
    
    FieldContainer& operator  = (const FieldContainer& right);
    
  }; // end class FieldContainer
  
  
  //--------------------------------------------------------------------------------------------//
  //                                                                                            //
  //                        Function declarations related to FieldContainer                     //
  //                                                                                            //
  //--------------------------------------------------------------------------------------------//
  
  template<class Scalar, int ArrayTypeId>
    std::ostream& operator << (std::ostream& os, const FieldContainer<Scalar, ArrayTypeId>& container);
 
  
} // end namespace Intrepid

/*
template<class FadType, class Scalar>
struct Return_Type< Intrepid::FieldContainer<FadType>, Scalar>{
      typedef FadType& return_type;
      typedef FadType  const_return_type;
};

template<class FadType, class Scalar>
struct Return_Type<const Intrepid::FieldContainer<FadType>, Scalar>{
      typedef FadType& return_type;
      typedef FadType  const_return_type;
};
*/

// include templated definitions
#include <Intrepid_FieldContainerDef.hpp>

#endif