fei_Lookup_Impl.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the 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.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _fei_Lookup_Impl_hpp_
#define _fei_Lookup_Impl_hpp_
 
#include <fei_macros.hpp>
#include <fei_MatrixGraph.hpp>
#include <fei_Pattern.hpp>
#include <fei_ConnectivityBlock.hpp>
#include <fei_SharedIDs.hpp>
#include <snl_fei_RecordCollection.hpp>
#include <snl_fei_PointBlockMap.hpp>
#include <fei_TemplateUtils.hpp>
#include <fei_Lookup.hpp>
 
#include <vector>
 
namespace fei {
  class Lookup_Impl : public virtual Lookup {
  public:
    Lookup_Impl(fei::SharedPtr<fei::MatrixGraph> matGraph,
    int nodeIDType);
 
    virtual ~Lookup_Impl();
 
    int getNumFields()
      {
  return( vspace_->getNumFields() );
      }
 
    int getFieldSize(int fieldID)
      {
  return(vspace_->getFieldSize(fieldID));
      }
 
    const int* getFieldIDsPtr()
      {
  int len = getNumFields();
  if (len < 1) return(NULL);
 
  vspace_->getFields(fieldIDs_);
  return(&fieldIDs_[0]);
      }
 
    const int* getFieldSizesPtr()
      {
  const int* fieldIDs = getFieldIDsPtr();
  if (fieldIDs == NULL) return(NULL);
 
  unsigned numFields = fieldIDs_.size();
  fieldSizes_.resize(numFields);
  int* fsPtr = &fieldSizes_[0];
  for(unsigned i=0; i<numFields; ++i) {
    fsPtr[i] = vspace_->getFieldSize(fieldIDs[i]);
  }
  return(fsPtr);
      }
 
    int getNumElemBlocks()
      { return(matGraph_->getConnectivityBlocks().size()); }
 
    const GlobalID* getElemBlockIDs()
      {
  int err = matGraph_->getConnectivityBlockIDs(elemBlockIDs_);
  return(err==0 ? &elemBlockIDs_[0] : NULL);
      }
 
    void getElemBlockInfo(GlobalID blockID,
                         int& interleaveStrategy, int& lumpingStrategy,
                         int& numElemDOF, int& numElements,
                         int& numNodesPerElem, int& numEqnsPerElem)
      {
  interleaveStrategy = 0; lumpingStrategy = 0;
  numElemDOF = 0;
  const fei::ConnectivityBlock* cblock =
    matGraph_->getConnectivityBlock(blockID);
  numElements = cblock->getConnectivityIDs().size();
  numNodesPerElem = cblock->getRowPattern()->getNumIDs();
  numEqnsPerElem = cblock->getRowPattern()->getNumIndices();
      }
 
    const int* getNumFieldsPerNode(GlobalID blockID)
      {
  const fei::ConnectivityBlock* cblock = matGraph_->getConnectivityBlock(blockID);
  if (cblock==NULL) return(NULL);
  return(cblock->getRowPattern()->getNumFieldsPerID());
      }
 
    const int* const* getFieldIDsTable(GlobalID blockID)
      {
  const fei::ConnectivityBlock* cblock = matGraph_->getConnectivityBlock(blockID);
  if (cblock==NULL) return(NULL);
  int numNodes = cblock->getRowPattern()->getNumIDs();
  const int* numFieldsPerNode = cblock->getRowPattern()->getNumFieldsPerID();
  const int* fieldIDs = cblock->getRowPattern()->getFieldIDs();
  fieldIDs_2D_.resize(numNodes);
  const int** f2dPtr = &fieldIDs_2D_[0];
  int offset = 0;
  for(int i=0; i<numNodes; ++i) {
    f2dPtr[i] = fieldIDs + offset;
    offset += numFieldsPerNode[i];
  }
  return(f2dPtr);
      }
 
    int getEqnNumber(int nodeNumber, int fieldID);
 
    int getAssociatedNodeNumber(int eqnNumber);
 
    int getAssociatedNodeID(int eqnNumber);
 
    int getAssociatedFieldID(int eqnNumber);
 
    bool isInLocalElement(int nodeNumber);
 
    int getNumSubdomains(int nodeNumber)
    {
      std::vector<int>* subdomains = NULL;
      std::map<int,std::vector<int>* >::iterator
        nns_iter = nodenumSubdomainDB_.find(nodeNumber);
      if (nns_iter != nodenumSubdomainDB_.end()) subdomains = (*nns_iter).second;
      return( subdomains==0 ? 0 : subdomains->size() );
    }
 
    int* getSubdomainList(int nodeNumber)
    {
      std::vector<int>* subdomains = NULL;
      std::map<int,std::vector<int>* >::iterator
        nns_iter = nodenumSubdomainDB_.find(nodeNumber);
      if (nns_iter != nodenumSubdomainDB_.end()) subdomains = (*nns_iter).second;
 
      return( subdomains==0 ? NULL : &(*subdomains)[0] );
    }
 
    int getNumSharedNodes()
    {
      int numShared;
      int err = vspace_->getNumSharedIDs(nodeIDType_, numShared);
      return(err==0 ? numShared : -1);
    }
 
    const int* getSharedNodeNumbers()
    {
      fei::SharedIDs<int>& sharedIDs = vspace_->getSharedIDs(nodeIDType_);
 
      int numShared = sharedIDs.getSharedIDs().size();
      workspace_.resize(numShared*2);
      int* wkPtr = &workspace_[0];
      fei::copyKeysToArray(sharedIDs.getSharedIDs(), numShared, wkPtr);
 
      snl_fei::RecordCollection* collection = NULL;
      vspace_->getRecordCollection(nodeIDType_, collection);
 
      for(int i=0; i<numShared; ++i) {
        fei::Record<int>* node = collection->getRecordWithID(wkPtr[i]);
        if (node == NULL) return NULL;
 
        wkPtr[numShared+i] = node->getNumber();
      }
      return(wkPtr+numShared);
    }
 
    const int* getSharedNodeProcs(int nodeNumber)
    {
      std::map<int,fei::Record<int>*>::iterator
        nnp_iter = nodenumPairs_.find(nodeNumber);
 
      if (nnp_iter == nodenumPairs_.end()) return(0);
 
      fei::Record<int>* node = (*nnp_iter).second;
 
      const fei::SharedIDs<int>& sharedIDs = vspace_->getSharedIDs(nodeIDType_);
 
      int shID = node->getID();
 
      fei::SharedIDs<int>::map_type::const_iterator
        iter = sharedIDs.getSharedIDs().find(shID);
      if (iter == sharedIDs.getSharedIDs().end()) return(NULL);
 
      const std::set<int>& shprocs = iter->second;
 
      fei::copySetToVector(shprocs, workspace_);
      return(&workspace_[0]);
    }
 
    int getNumSharingProcs(int nodeNumber)
    {
      std::map<int,fei::Record<int>*>::iterator
        nnp_iter = nodenumPairs_.find(nodeNumber);
 
      if (nnp_iter == nodenumPairs_.end()) return(0);
 
      fei::Record<int>* node = (*nnp_iter).second;
 
      const fei::SharedIDs<int>& sharedIDs = vspace_->getSharedIDs(nodeIDType_);
 
      int shID = node->getID();
 
      fei::SharedIDs<int>::map_type::const_iterator
        iter = sharedIDs.getSharedIDs().find(shID);
      if (iter == sharedIDs.getSharedIDs().end()) return(0);
 
      const std::set<int>& shprocs = iter->second;
      return(shprocs.size());
    }
 
    bool isExactlyBlkEqn(int ptEqn)
      { return( ptBlkMap_->isExactlyBlkEqn(ptEqn) ); }
 
    int ptEqnToBlkEqn(int ptEqn)
      { return( ptBlkMap_->eqnToBlkEqn(ptEqn) ); }
 
    int getOffsetIntoBlkEqn(int blkEqn, int ptEqn);
 
    int getBlkEqnSize(int blkEqn)
    {
      return( ptBlkMap_->getBlkEqnSize(blkEqn) );
    }
 
  private:
    int buildDatabases();
 
    fei::SharedPtr<fei::MatrixGraph> matGraph_;
    snl_fei::PointBlockMap* ptBlkMap_;
    fei::SharedPtr<fei::VectorSpace> vspace_;
    int nodeIDType_;
 
    std::map<int, fei::Record<int>*> nodenumPairs_;
    std::map<int,fei::Record<int>*> eqnnumPairs_;
 
    std::map<int,std::vector<int>*> nodenumSubdomainDB_;
 
    bool databasesBuilt_;
 
    std::vector<int> fieldIDs_;
    std::vector<int> fieldSizes_;
    std::vector<GlobalID> elemBlockIDs_;
    std::vector<const int*> fieldIDs_2D_;
    std::vector<int> workspace_;
  };//class Lookup_Impl
}//namespace fei
 
#endif // _fei_Lookup_Impl_hpp_