fei_NodeDatabase.hpp

#ifndef _NodeDatabase_hpp_
#define _NodeDatabase_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.                    */
/*--------------------------------------------------------------------*/
 
#include "fei_macros.hpp"
#include "fei_fwd.hpp"
#include "fei_defs.h"
#include "fei_NodeDescriptor.hpp"
#include "fei_Pool_alloc.hpp"
#include "fei_mpi.h"
 
#include <map>
 
class NodeDatabase {
 public:
  NodeDatabase(std::map<int,int>* fieldDatabase,
         NodeCommMgr* nodeCommMgr);
 
  virtual ~NodeDatabase();
 
  int getNumNodeDescriptors() const { return( nodePtrs_.size() ); };
 
  std::map<GlobalID,int>& getNodeIDs() { return( nodeIDs_ ); };
 
  int getNodeWithID(GlobalID nodeID, const NodeDescriptor*& node) const;
  int getNodeWithID(GlobalID nodeID, NodeDescriptor*& node);
 
  int getNodeWithNumber(int nodeNumber, const NodeDescriptor*& node) const;
 
  int getNodeWithEqn(int eqnNumber, const NodeDescriptor*& node) const;
 
  void getNodeAtIndex(int i, const NodeDescriptor*& node) const;
  void getNodeAtIndex(int i, NodeDescriptor*& node);
 
  int countLocalNodalEqns(int localRank);
 
  int countLocalNodeDescriptors(int localRank);
 
  int getIndexOfID(GlobalID nodeID) const;
 
  int initNodeID(GlobalID nodeID);
 
  int initNodeIDs(GlobalID* nodeIDs, int numNodes);
 
  int synchronize(int firstLocalNodeNumber,
      int firstLocalEqn,
      int localRank,
      MPI_Comm comm);
 
  int getAssociatedNodeNumber(int eqnNumber);
 
  int getAssociatedFieldID(int eqnNumber);
 
  bool isSynchronized() { return( synchronized_ ); };
 
 private:
  NodeDatabase(const NodeDatabase& src);
  NodeDatabase& operator=(const NodeDatabase& src);
 
  void deleteMemory();
 
  std::vector<NodeDescriptor*> nodePtrs_;
 
  std::vector<int> eqnNumbers_;  //eqnNumbers_ will be a sorted list of the
                                  //first global equation number at each node
                                  //in nodePtrs_.
                                  //the relationship between eqnNumbers_ and
  std::vector<int> eqnNodeIndices_;  //eqnNodeIndices_ is like this:
                                  //if eqn == eqnNumbers_[i], then
                                  //  nodePtrs_[eqnNodeIndices_[i]] points to
                                  //  the node with 'eqn'
 
  std::map<GlobalID,int> nodeIDs_; //nodeIDs_ maps node-ID to an index into
                                //the nodePtrs_ array of NodeDescriptors.
 
  std::map<int,int> nodeNumbers_;
 
  bool synchronized_;
  bool need_to_alloc_and_sync_;
 
  std::map<int,int>* fieldDB_;
  NodeCommMgr* nodeCommMgr_;
 
  int numLocalNodes_;
  int firstLocalNodeNumber_, lastLocalNodeNumber_;
 
  fei_Pool_alloc<NodeDescriptor> nodePool_;
};
 
#endif