Stokhos_AdaptivityManager.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Stokhos Package
//
// Copyright 2009 NTESS and the Stokhos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef STOKHOS_AdaptivityManager_HPP
#define STOKHOS_AdaptivityManager_HPP

#include "Stokhos_config.h"
#include "Stokhos_OrthogPolyBasis.hpp"
#include "Stokhos_ProductBasis.hpp"
#include "Stokhos_SGOperator.hpp"
#include "Stokhos_EpetraVectorOrthogPoly.hpp"
#include "Stokhos_EpetraOperatorOrthogPoly.hpp"

#include "Epetra_Map.h"
#include "Epetra_CrsGraph.h"
#include "Epetra_CrsMatrix.h"

#include "Teuchos_RCP.hpp"
#include "Teuchos_Array.hpp"

#include <vector>

#ifdef HAVE_STOKHOS_BOOST
#include <boost/unordered_map.hpp>
#endif

namespace Stokhos {

   class AdaptivityManager {
   public:
      AdaptivityManager(
         const Teuchos::RCP<const Stokhos::ProductBasis<int,double> >& sg_master_basis,
         const std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > & sg_basis_row_dof,
         const Epetra_CrsGraph & determ_graph, 
         bool onlyUseLinear,int kExpOrder,
         bool scaleOp=true);

      AdaptivityManager(
         const Teuchos::RCP<const Stokhos::ProductBasis<int,double> >& sg_master_basis,
         const std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > & sg_basis_row_dof,
         const Epetra_Comm & comm,
         bool scaleOp=true);

      inline int getGlobalColId(int determLid,int basisIndex) const
      { return myColGidOffsets_[determLid]+basisIndex; }

      inline int getGlobalRowId(int determLid,int basisIndex) const
      { return myRowGidOffsets_[determLid]+basisIndex; }

      Teuchos::RCP<Epetra_CrsMatrix> buildMatrixFromGraph() const;

      void setupWithGraph(const Epetra_CrsGraph & graph,bool onlyUseLinear,int kExpOrder);

      Teuchos::RCP<const Epetra_Map> getAdaptedMap() const
      { return rowMap_; }

      void setupOperator(Epetra_CrsMatrix & A,const Sparse3Tensor<int,double> & Cijk,Stokhos::EpetraOperatorOrthogPoly & poly,
                         bool onlyUseLinear=false,bool includeMean=true) const;

      void sumInOperator(Epetra_CrsMatrix & A,const Stokhos::Sparse3Tensor<int,double> & Cijk,int k,const Epetra_CrsMatrix & J_k) const;

      void copyToAdaptiveVector(const Stokhos::EpetraVectorOrthogPoly & x_sg,Epetra_Vector & x) const;

      void copyFromAdaptiveVector(const Epetra_Vector & x,Stokhos::EpetraVectorOrthogPoly & x_sg) const;

      int getRowStochasticBasisSize(int determLid) const
      { return sg_basis_row_dof_[determLid]->size(); }
  
      int getColStochasticBasisSize(int determLid) const
      { return sg_basis_col_dof_[determLid]->size(); }
  
      Teuchos::RCP<const Stokhos::ProductBasis<int,double> > getMasterStochasticBasis() const
      { return sg_master_basis_; } 
  
      Teuchos::RCP<const Stokhos::ProductBasis<int,double> > getRowStochasticBasis(int determLid) const
      { return sg_basis_row_dof_[determLid]; } 

      const std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > & getRowStochasticBasis() const
      { return sg_basis_row_dof_; } 
  
      Teuchos::RCP<const Stokhos::ProductBasis<int,double> > getColStochasticBasis(int determLid) const
      { return sg_basis_col_dof_[determLid]; } 

      bool isScaled() 
      { return scaleOp_; }

   private:

      class Sparse3TensorHash {
      public:
         Sparse3TensorHash(const Stokhos::Sparse3Tensor<int,double> & Cijk);
   
         double getValue(int i,int j,int k) const; 

      private:
         #ifdef HAVE_STOKHOS_BOOST
         struct IJK {
            int i_,j_,k_;
            IJK(int i,int j,int k) : i_(i), j_(j), k_(k) {}

            bool operator==(const IJK & ijk) const
            { return i_==ijk.i_ && j_==ijk.j_ && k_==ijk.k_; }
         };

         struct IJKHash {
            std::size_t operator()(const IJK & ijk) const;
         };

         boost::unordered_map<IJK,double,IJKHash> hashMap_;
         #else
         const Stokhos::Sparse3Tensor<int,double> & Cijk_;
         #endif
      };

      void sumInOperator(Epetra_CrsMatrix & A,const Sparse3TensorHash & Cijk,int k,const Epetra_CrsMatrix & J_k) const;

      Teuchos::RCP<const Stokhos::ProductBasis<int,double> > sg_master_basis_;
      std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > sg_basis_row_dof_;
      std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > sg_basis_col_dof_;

      std::vector<int> myRowGidOffsets_;
      std::vector<int> myColGidOffsets_;

      Teuchos::RCP<Epetra_CrsGraph> graph_;
      Teuchos::RCP<Epetra_Map> rowMap_;

      bool scaleOp_;
   };
    
} // namespace Stokhos

#endif // STOKHOS_AdaptivityUtils_HPP