---

TemporaryMapper.h

Go to the documentation of this file.

#ifndef TEMPORARYMAPPER_H
#define TEMPORARYMAPPER_H

#include "SundanceDefs.h"

#include "TSFArray.h"
#include "Mesh.h"
#include "TSFSmartPtr.h"



namespace Sundance
{

  using namespace TSF;
  using std::string;

  using std::ostream;



  /** \ingroup LowLevelFE

  This is a temporary data structure used in building the
  local-global DOF maps. It distributes the DOFs among all cells,
  not just the cells that will be integrated. This data structure
  is huge, but it gets deleted before the matrix is built.

  Initially, all cells are tagged with -1, which indicates that
  they have not yet had a DOF number assigned. DOF indices are
  assigned during calls to the appendDOFs() method; if a cell is
  not locally owned, that cell's global index is appended to a
  table of requests to be resolved by other processors.  Remotely
  owned cells are tagged with -2. That tag is never used in
  calculations, but can trap errors if some cell never gets
  resolved.

  Once all the local DOFs have been assigned and the remote cells
  have been identified, call synchronizeRemoteDOFs() to share DOF
  counts across processors and resolve DOF numbers for remotely
  owned cells.

  Finally, after the remote DOFs have been resolved, we can make
  calls to the getDOFs() methods to get DOF indices for (cell,
  funcID) sets.  */

  class TemporaryMapper
    {
    public:
      /** */
      TemporaryMapper(const Mesh& mesh, int nFunc);

      /** */
      void appendDOFs(const Cell& cell, const TSFArray<int>& funcID);

      /** */
      void getDOFs(const Cell& cell,
                   const TSFArray<int>& funcID,
                   TSFArray<int>& indices) ;

      /** */
      int numberOfLocalDOFs() const {return localDOFs_;}
      /** */
      int numberOfRemoteDOFs() const {return remoteDOFList_->length();}
      /** */
      int lowestLocalDOF() const {return globalOffsets_[MPIComm::world().getRank()];}
      /** */
      void synchronizeRemoteDOFs();
      /** */
      void synchronizeRemoteDOFs(int dimension);
      /** */
      const TSFSmartPtr<TSFArray<int> >& remoteDOFList() const {return remoteDOFList_;}
      /** */
      void print() const ;

      /** */
      static bool& verboseDOFAssignment() {static bool rtn=false; return rtn;}

      /** */
      static bool& verboseComm() {static bool rtn=false; return rtn;}


    private:
      int myProcID_;
      Mesh mesh_;
      int localDOFs_;
      int remoteDOFs_;
      int nFunc_;
      // map_[cellDim][cellIndex][funcID] --> DOF index
      TSFArray<TSFArray<TSFArray<int> > > cellAndFuncToIndexMap_;
      TSFArray<TSFArray<TSFArray<bool> > > cellAndFuncTag_;
      // dofRequests_[cellDim][procID] {cellIndex1, fid1, cellIndex2, fid2...}
      TSFArray<TSFArray<TSFArray<int> > > remoteDOFRequests_;
      TSFArray<int> globalOffsets_;
      TSFSmartPtr<TSFArray<int> > remoteDOFList_;

    };




}
#endif

---

Contact:

Kevin Long (krlong@ca.sandia.gov)


Documentation generated by