VectorBuilder.h

Go to the documentation of this file.

#ifndef included_AMP_VectorBuider
#define included_AMP_VectorBuider
 
#include "AMP/AMP_TPLs.h"
#include "AMP/discretization/DOF_Manager.h"
#include "AMP/utils/Backend.h"
#include "AMP/utils/Memory.h"
#include "AMP/utils/Utilities.h"
#include "AMP/vectors/Vector.h"
#include "AMP/vectors/data/VectorDataDefault.h"
#include "AMP/vectors/operations/default/VectorOperationsDefault.h"
 
#include <string>
 
 
// Forward declares
extern "C" {
typedef struct _p_Vec *Vec;
}
#if defined( AMP_USE_TRILINOS )
namespace Teuchos {
template<class TYPE>
class RCP;
}
 
    #if defined( AMP_USE_TRILINOS_THYRA )
namespace Thyra {
template<class TYPE>
class VectorBase;
}
    #endif
 
#endif
 
namespace AMP::LinearAlgebra {
 
 
// Forward declerations
class EpetraVectorEngineParameters;
 
 
template<typename TYPE = double,
         typename OPS  = VectorOperationsDefault<TYPE>,
         typename DATA = VectorDataDefault<TYPE>>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
              std::shared_ptr<AMP::LinearAlgebra::Variable> variable,
              bool split = true );
 
template<typename TYPE = double, typename DATA = VectorDataDefault<TYPE>>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
              std::shared_ptr<AMP::LinearAlgebra::Variable> variable,
              bool split,
              AMP::Utilities::Backend backend );
 
template<typename TYPE = double>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
              std::shared_ptr<AMP::LinearAlgebra::Variable> variable,
              bool split,
              AMP::Utilities::MemoryType memType );
 
template<typename TYPE = double>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
              std::shared_ptr<AMP::LinearAlgebra::Variable> variable,
              bool split,
              AMP::Utilities::MemoryType memType,
              AMP::Utilities::Backend backend );
 
template<typename TYPE = double>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vector,
              AMP::Utilities::MemoryType memType );
 
 
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> vector,
              AMP::Utilities::MemoryType memType );
 
template<typename TYPE = double>
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vector,
              AMP::Utilities::MemoryType memType,
              AMP::Utilities::Backend backend );
 
 
AMP::LinearAlgebra::Vector::shared_ptr
createVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> vector,
              AMP::Utilities::MemoryType memType,
              AMP::Utilities::Backend backend );
 
std::shared_ptr<Vector> createVector( Vec v,
                                      bool deleteable,
                                      AMP_MPI comm                  = AMP_MPI(),
                                      std::shared_ptr<Variable> var = nullptr );
 
 
std::shared_ptr<Vector> createEpetraVector( std::shared_ptr<CommunicationList> commList,
                                            std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
                                            std::shared_ptr<VectorData> p = nullptr );
 
 
std::shared_ptr<Vector> createTpetraVector( std::shared_ptr<CommunicationList> commList,
                                            std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
                                            std::shared_ptr<VectorData> p = nullptr );
 
#if defined( AMP_USE_TRILINOS ) && defined( AMP_USE_TRILINOS_THYRA )
 
std::shared_ptr<Vector> createVector( Teuchos::RCP<Thyra::VectorBase<double>> vec,
                                      size_t local,
                                      AMP_MPI comm,
                                      std::shared_ptr<Variable> var = nullptr );
#endif
 
template<typename TYPE,
         typename VecOps  = VectorOperationsDefault<TYPE>,
         typename VecData = VectorDataDefault<TYPE>>
Vector::shared_ptr createSimpleVector( size_t localSize, const std::string &var );
 
 
template<typename TYPE,
         typename VecOps  = VectorOperationsDefault<TYPE>,
         typename VecData = VectorDataDefault<TYPE>>
Vector::shared_ptr createSimpleVector( size_t localSize, std::shared_ptr<Variable> var );
 
 
template<typename TYPE,
         typename VecOps  = VectorOperationsDefault<TYPE>,
         typename VecData = VectorDataDefault<TYPE>>
Vector::shared_ptr
createSimpleVector( size_t localSize, std::shared_ptr<Variable> var, AMP_MPI comm );
 
 
template<typename TYPE,
         typename VecOps  = VectorOperationsDefault<TYPE>,
         typename VecData = VectorDataDefault<TYPE>>
Vector::shared_ptr createSimpleVector( std::shared_ptr<Variable> var,
                                       std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
                                       std::shared_ptr<CommunicationList> commlist );
 
 
template<typename T, typename FUN = FunctionTable<T>, typename Allocator = AMP::HostAllocator<void>>
Vector::shared_ptr createArrayVector( const ArraySize &localSize, const std::string &var );
 
template<typename T, typename FUN = FunctionTable<T>, typename Allocator = AMP::HostAllocator<void>>
Vector::shared_ptr createArrayVector( const ArraySize &localSize, std::shared_ptr<Variable> var );
 
 
template<typename T, typename FUN = FunctionTable<T>, typename Allocator = AMP::HostAllocator<void>>
Vector::shared_ptr createArrayVector( const ArraySize &localSize,
                                      const ArraySize &blockIndex,
                                      const AMP_MPI &comm,
                                      std::shared_ptr<Variable> var );
 
template<typename T>
Vector::shared_ptr createVectorAdaptor( const std::string &name,
                                        std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
                                        T *data );
 
} // namespace AMP::LinearAlgebra
 
#endif