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_