Panzer_DOFManager.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//           Panzer: A partial differential equation assembly
//       engine for strongly coupled complex multiphysics systems
//                 Copyright (2011) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// 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 Roger P. Pawlowski (rppawlo@sandia.gov) and
// Eric C. Cyr (eccyr@sandia.gov)
// ***********************************************************************
// @HEADER

#ifndef __Panzer_DOFManager_hpp__
#define __Panzer_DOFManager_hpp__
#include <map>

#include <mpi.h>

#include "PanzerDofMgr_config.hpp"
#include "Panzer_FieldPattern.hpp"
#include "Panzer_FieldAggPattern.hpp"
#include "Panzer_GeometricAggFieldPattern.hpp"
#include "Panzer_ConnManager.hpp"
#include "Panzer_UniqueGlobalIndexer.hpp"
#include "Panzer_NodeType.hpp"
#include "Panzer_FieldType.hpp"
#include "Phalanx_KokkosDeviceTypes.hpp"

#include "Teuchos_RCP.hpp"

#include "Tpetra_Map.hpp"
#include "Tpetra_MultiVector.hpp"

namespace panzer {


template <typename LocalOrdinalT, typename GlobalOrdinalT>
class DOFManager : public UniqueGlobalIndexer<LocalOrdinalT, GlobalOrdinalT> {
public:
  typedef GlobalOrdinalT GO;
  typedef LocalOrdinalT LO;

  virtual ~DOFManager() {}

  DOFManager();

  DOFManager(const Teuchos::RCP<ConnManager<LocalOrdinalT,GlobalOrdinalT> > & connMngr,MPI_Comm mpiComm);

  void setConnManager(const Teuchos::RCP<ConnManager<LO,GO> > & connMngr, MPI_Comm mpiComm);

  Teuchos::RCP<ConnManager<LO,GO> > getConnManager() const
  { return connMngr_; }

  virtual Teuchos::RCP<const ConnManagerBase<LocalOrdinalT> > getConnManagerBase() const
  { return getConnManager(); }

  int addField(const std::string & str, const Teuchos::RCP<const FieldPattern> & pattern,
               const panzer::FieldType& type = panzer::FieldType::CG);

  int addField(const std::string & blockID, const std::string & str,
               const Teuchos::RCP<const FieldPattern> & pattern,
               const panzer::FieldType& type = panzer::FieldType::CG);

  Teuchos::RCP<const FieldPattern> getFieldPattern(const std::string & name) const;

  Teuchos::RCP<const FieldPattern> getFieldPattern(const std::string & blockId, const std::string & fieldName) const;

  void
  getOwnedIndices(
    std::vector<GlobalOrdinalT>& indices) const;

  void
  getGhostedIndices(
    std::vector<GlobalOrdinalT>& indices) const;

  void
  getOwnedAndGhostedIndices(
    std::vector<GlobalOrdinalT>& indices) const;

  int
  getNumOwned() const;

  int
  getNumGhosted() const;

  int
  getNumOwnedAndGhosted() const;

  int getNumFields() const;

  const std::vector<int> & getGIDFieldOffsets(const std::string & blockID, int fieldNum) const;

  const Kokkos::View<const int*,PHX::Device> getGIDFieldOffsetsKokkos(const std::string & blockID, int fieldNum) const;

  void getElementGIDs(LO localElementID, std::vector<GO> & gids, const std::string & blockIdHint="") const;

  void buildGlobalUnknowns();

  void buildGlobalUnknowns(const Teuchos::RCP<const FieldPattern> & geomPattern);
  
  int getFieldNum(const std::string & string) const;

  Teuchos::RCP<Teuchos::Comm<int> > getComm() const
  { return communicator_; }

  Teuchos::RCP<const FieldPattern> getGeometricFieldPattern() const
  { return ga_fp_; }

  void getElementBlockIds(std::vector<std::string> & elementBlockIds) const
  { connMngr_->getElementBlockIds(elementBlockIds); }
  
  bool fieldInBlock(const std::string & field, const std::string & block) const;

  const std::vector<int> & getBlockFieldNumbers(const std::string & blockId) const;

//************************************************************************

  const std::pair<std::vector<int>,std::vector<int> > & 
  getGIDFieldOffsets_closure(const std::string & blockId, int fieldNum, int subcellDim,int subcellId) const;

  const std::vector<LocalOrdinalT> & getElementBlock(const std::string & blockId) const
  { return connMngr_->getElementBlock(blockId); }

  void ownedIndices(const std::vector<GlobalOrdinalT> & indices,std::vector<bool> & isOwned) const;

  void setFieldOrder(const std::vector<std::string> & fieldOrder );

  void getFieldOrder(std::vector<std::string> & fieldOrder) const;

  bool validFieldOrder(const std::vector<std::string> & proposed_fieldOrder);

  //TODO:this
  void buildUnknownsOrientation();

  bool getOrientationsRequired() const
  { return requireOrientations_; }

  void setOrientationsRequired(bool ro)
  { requireOrientations_ = ro; }

  void getElementOrientation(LocalOrdinalT localElmtId,std::vector<double> & gidsOrientation) const;

  const std::string & getFieldString(int num) const;

  Teuchos::RCP<ConnManager<LocalOrdinalT,GlobalOrdinalT> > resetIndices();

  virtual int getElementBlockGIDCount(const std::string & blockId) const
  { return getElementBlockGIDCount(blockIdToIndex(blockId)); }

  virtual int getElementBlockGIDCount(const std::size_t & blockIndex) const
  { return elementBlockGIDCount_[blockIndex]; }

  void printFieldInformation(std::ostream & os) const;

  void enableTieBreak(bool enable)   
  { useTieBreak_ = enable; }

  void useNeighbors(bool flag)   
  { useNeighbors_ = flag; }

  // These functions are primarily for testing purposes
  // they are not intended to be useful otherwise (thus they are not 
  // documented in the Doxygen style

  // Return the number of elemnts as measured by the count of GID arrays.
  // note that this will include ghosted elements!
  std::size_t getNumberElementGIDArrays() const
  { return elementGIDs_.size(); }

protected:

  Teuchos::RCP<const Tpetra::Map<LO,GO,panzer::TpetraNodeType> >
  runLocalRCMReordering(const Teuchos::RCP<const Tpetra::Map<LocalOrdinalT,GlobalOrdinalT,panzer::TpetraNodeType> > &);

  std::size_t blockIdToIndex(const std::string & blockId) const;

  class ElementBlockAccess {
    bool useOwned_;
    Teuchos::RCP<const ConnManager<LO,GO> > connMngr_;
  public:
    ElementBlockAccess(bool owned,const Teuchos::RCP<const ConnManager<LO,GO> > & connMngr) 
      : useOwned_(owned), connMngr_(connMngr) {}
    
    const std::vector<LO> & getElementBlock(const std::string & eBlock) const 
    {
      if(useOwned_==true)
        return connMngr_->getElementBlock(eBlock);
      else
        return connMngr_->getNeighborElementBlock(eBlock);
    }
  };

  Teuchos::RCP<const Tpetra::Map<LO,GO,panzer::TpetraNodeType> >
  buildOverlapMapFromElements(const ElementBlockAccess & access) const; 

  Teuchos::RCP<Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> >
  buildTaggedMultiVector(const ElementBlockAccess & access);

  std::pair<Teuchos::RCP<Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> >,
            Teuchos::RCP<Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> > >
  buildGlobalUnknowns_GUN(const Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> & tagged_overlap_mv,
                          Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> & overlap_mv) const;

  void fillGIDsFromOverlappedMV(const ElementBlockAccess & access,
                                std::vector<std::vector< GO > > & elementGIDs,
                                const Tpetra::Map<LO,GO,panzer::TpetraNodeType> & overlapmap,
                                const Tpetra::MultiVector<GO,LO,GO,panzer::TpetraNodeType> & overlap_mv) const;
  void buildLocalIdsFromOwnedAndGhostedElements();
  
  Teuchos::RCP<ConnManager<LO,GO> > connMngr_;
  Teuchos::RCP<Teuchos::Comm<int> > communicator_;

  //Please note: AID=absolute ID. This is an attempt to remember that
  // fieldPatterns_ is unchanging storage for FPs.
  std::vector<Teuchos::RCP<const FieldPattern> > fieldPatterns_;
  std::vector<FieldType> fieldTypes_; // FieldType for a Field Pattern. Use AID to access just like fieldPatterns_.
  std::map<std::string,int> fieldNameToAID_;

  std::vector<std::string> blockOrder_; // To be got from the ConnManager.
  std::map<std::string,int> blockNameToID_; // I'm not sure the above vector is needed, this might suffice.
  std::vector<std::vector<int> > blockToAssociatedFP_; // each sub-vector is associated by
  // a block, with ordering given in blockOrder_. ints refer to the order in fieldPatterns_;
  std::vector<std::string> fieldStringOrder_;
  std::vector<int> fieldAIDOrder_; // Both of these must be updated and edited together.
  // The AID offers a simpler way to manage FPs internally.

  Teuchos::RCP<const panzer::FieldPattern> ga_fp_; // geometric aggregate field pattern
  std::vector<Teuchos::RCP<panzer::FieldAggPattern> > fa_fps_; //Ordered by blockOrder_;

  std::vector<GO> owned_;
  std::vector<GO> ghosted_;

  // Element GIDS ordered by LID.
  std::vector<std::vector< GO > > elementGIDs_;

  // Mimics the functionality of the getElemenentBlockGIDCount in
  // the original DOFManager. Indexed according to blockOrder_.
  std::vector<int> elementBlockGIDCount_;

  int numFields_;

  bool buildConnectivityRun_;

  bool requireOrientations_;
  std::vector<std::vector<signed char> > orientation_;

  bool useTieBreak_;
  bool useNeighbors_;
};

}

#endif