fei_MatrixGraph_Impl2.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*    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_MatrixGraph_Impl2_hpp_
#define _fei_MatrixGraph_Impl2_hpp_
 
#include <fei_macros.hpp>
#include <fei_SharedPtr.hpp>
#include <fei_VectorSpace.hpp>
#include <fei_Reducer.hpp>
#include <fei_Graph.hpp>
#include <snl_fei_Constraint.hpp>
#include <fei_Record.hpp>
#include <fei_Logger.hpp>
#include <fei_SparseRowGraph.hpp>
#include <fei_MatrixGraph.hpp>
 
#include <vector>
#include <map>
 
namespace fei {
  class ConnectivityBlock;
  class Pattern;
 
class MatrixGraph_Impl2 : public fei::MatrixGraph, private fei::Logger {
 public:
  class Factory {
  public:
    virtual ~Factory(){}
 
    virtual fei::SharedPtr<fei::MatrixGraph>
                 createMatrixGraph(fei::SharedPtr<fei::VectorSpace> rowSpace,
                                   fei::SharedPtr<fei::VectorSpace> columnSpace,
                                   const char* name);
  };
 
  MatrixGraph_Impl2(fei::SharedPtr<fei::VectorSpace> rowSpace,
              fei::SharedPtr<fei::VectorSpace> colSpace,
              const char* name = NULL);
 
  virtual ~MatrixGraph_Impl2();
 
  void setParameters(const fei::ParameterSet& params);
 
  void setRowSpace(fei::SharedPtr<fei::VectorSpace> rowSpace);
 
  fei::SharedPtr<fei::VectorSpace> getRowSpace();
 
  void setColumnSpace(fei::SharedPtr<fei::VectorSpace> columnSpace);
 
  fei::SharedPtr<fei::VectorSpace> getColSpace();
 
  int definePattern(int numIDs,
                    int idType);
 
  int definePattern(int numIDs,
                    int idType,
                    int fieldID);
 
   int definePattern(int numIDs,
                     int idType,
                     const int* numFieldsPerID,
                     const int* fieldIDs);
 
   int definePattern(int numIDs,
                     const int* idTypes,
                     const int* numFieldsPerID,
                     const int* fieldIDs);
 
   int initConnectivityBlock(int blockID,
                             int numConnectivityLists,
                             int patternID,
                             bool diagonal=false);
 
   int initConnectivityBlock(int numConnectivityLists,
                             int patternID,
                             bool diagonal=false);
 
   int initConnectivityBlock(int blockID,
                             int numConnectivityLists,
                             int rowPatternID,
                             int colPatternID);
 
   int initConnectivity(int blockID,
                        int connectivityID,
                        const int* connectedIdentifiers);
 
   int initConnectivity(int blockID,
                        int connectivityID,
                        const int* rowConnectedIdentifiers,
                        const int* colConnectedIdentifiers);
 
   int initConnectivity(int patternID,
                        const int* connectedIdentifiers);
 
   int initConnectivity(int rowPatternID,
                        const int* rowConnectedIdentifiers,
                        int colPatternID,
                        const int* colConnectedIdentifiers);
 
   int initConnectivity(int idType,
                        int numRows,
                        const int* rowIDs,
                        const int* rowOffsets,
                        const int* packedColumnIDs);
 
   int initConnectivity(int idType,
                        int fieldID,
                        int numRows,
                        const int* rowIDs,
                        const int* rowOffsets,
                        const int* packedColumnIDs);
 
   int initConnectivity(int idType,
                        int numRows,
                        const int* rowIDs,
                        const int* rowLengths,
                        const int*const* columnIDs);
 
   int initLagrangeConstraint(int constraintID,
                              int constraintIDType,
                              int numIDs,
                              const int* idTypes,
                              const int* IDs,
                              const int* fieldIDs);
 
   int initPenaltyConstraint(int constraintID,
                             int constraintIDType,
                             int numIDs,
                             const int* idTypes,
                             const int* IDs,
                             const int* fieldIDs);
 
   int initSlaveConstraint(int numIDs,
                           const int* idTypes,
                           const int* IDs,
                           const int* fieldIDs,
                           int offsetOfSlave,
                           int offsetIntoSlaveField,
                           const double* weights,
                           double rhsValue);
 
   bool newSlaveData();
 
   bool hasSlaveDof(int ID, int idType);
 
   int initComplete();
 
   fei::SharedPtr<fei::SparseRowGraph>
     createGraph(bool blockEntryGraph,
                 bool localRowGraph_includeSharedRows=false);
 
   int compareStructure(const fei::MatrixGraph& matrixGraph,
                        bool& equivalent) const;
 
   int getNumConnectivityBlocks() const;
 
   std::map<int,fei::ConnectivityBlock*>& getConnectivityBlocks();
 
   int getConnectivityBlockIDs(std::vector<int>& blockIDs) const;
 
   int getNumIDsPerConnectivityList(int blockID) const;
 
   int getConnectivityNumIndices(int blockID) const;
 
   int getConnectivityNumIndices(int blockID,
                                 int& numRowIndices,
                                 int& numColIndices);
 
   int getConnectivityIndices(int blockID,
                              int connectivityID,
                              int indicesAllocLen,
                              int* indices,
                              int& numIndices);
 
   int getConnectivityIndices(int blockID,
                              int connectivityID,
                              int rowIndicesAllocLen,
                              int* rowIndices,
                              int& numRowIndices,
                              int colIndicesAllocLen,
                              int* colIndices,
                              int& numColIndices);
 
   int getPatternNumIndices(int patternID,
                            int& numIndices);
 
   int getPatternIndices(int patternID,
                         const int* IDs,
                         std::vector<int>& indices);
 
   int getLocalNumLagrangeConstraints() const;
 
   int getGlobalNumSlaveConstraints() const;
 
   ConstraintType* getLagrangeConstraint(int constraintID);
 
   std::map<int, ConstraintType* >& getLagrangeConstraints();
 
   ConstraintType* getPenaltyConstraint(int constraintID);
 
   ConstraintType* getSlaveConstraint(int constraintID);
 
   int getConstraintConnectivityIndices(ConstraintType* cr,
                                        std::vector<int>& globalIndices);
 
   const fei::ConnectivityBlock* getConnectivityBlock(int blockID) const;
 
   fei::ConnectivityBlock* getConnectivityBlock(int blockID);
 
   void setIndicesMode(int mode);
 
   fei::SharedPtr<FillableMat> getSlaveDependencyMatrix();
 
   fei::Pattern* getPattern(int patternID);
 
   int createSlaveMatrices();
 
   fei::SharedPtr<fei::Reducer> getReducer();
 
   fei::SharedPtr<fei::SparseRowGraph> getRemotelyOwnedGraphRows();
 
   void getConstrainedIndices(std::vector<int>& crindices) const;
 
 private:
   int createAlgebraicGraph(bool blockEntryGraph,
                            fei::Graph* graph,
                            bool gatherFromOverlap);
 
   int addBlockToGraph_multiField_symmetric(fei::Graph* graph,
                                            fei::ConnectivityBlock* cblock);
   int addBlockToGraph_multiField_nonsymmetric(fei::Graph* graph,
                                            fei::ConnectivityBlock* cblock);
   int addBlockToGraph_singleField_symmetric(fei::Graph* graph,
                                             fei::ConnectivityBlock* cblock);
   int addBlockToGraph_singleField_nonsymmetric(fei::Graph* graph,
                                             fei::ConnectivityBlock* cblock);
   int addBlockToGraph_noField_symmetric(fei::Graph* graph,
                                         fei::ConnectivityBlock* cblock);
   int addBlockToGraph_sparse(fei::Graph* graph,
                              fei::ConnectivityBlock* cblock);
 
   int addPattern(fei::Pattern* pattern);
 
   int getConnectivityIndices_multiField(const snl_fei::RecordCollection*const* recordCollections,
                                         int* records, int numRecords,
                                         const int* numFieldsPerID,
                                         const int* fieldIDs,
                                         const int* fieldSizes,
                                         int indicesAllocLen,
                                         int* indices,
                                         int& numIndices);
 
   int getConnectivityIndices_singleField(const snl_fei::RecordCollection*const* recordCollections,
                                          int* records, int numRecords,
                                          int fieldID, int fieldSize,
                                          int indicesAllocLen,
                                          int* indices,
                                          int& numIndices);
 
   int getConnectivityIndices_noField(const snl_fei::RecordCollection*const* recordCollections,
                                      int* records,
                                      int numRecords,
                                      int indicesAllocLen,
                                      int* indices,
                                      int& numIndices);
 
   int getConnectivityRecords(fei::VectorSpace* vecSpace,
                              int idType,
                              int numIDs,
                              const int* IDs,
                              int* records);
 
   int getConnectivityRecords(fei::VectorSpace* vecSpace,
                              int idType,
                              int fieldID,
                              int numIDs,
                              const int* IDs,
                              int* records);
 
   int getConnectivityRecords(fei::Pattern* pattern,
                              fei::VectorSpace* solnSpace,
                              const int* connectedIdentifiers,
                              int* recordList);
 
   int exchangeBlkEqnSizes(fei::Graph* graph);
 
   int addLagrangeConstraintsToGraph(fei::Graph* graph);
 
   int addPenaltyConstraintsToGraph(fei::Graph* graph);
 
   void setName(const char* name);
 
 private:
   int localProc_, numProcs_;
 
   MPI_Comm comm_;
 
   fei::SharedPtr<fei::VectorSpace> rowSpace_;
   fei::SharedPtr<fei::VectorSpace> colSpace_;
   bool haveRowSpace_;
   bool haveColSpace_;
   bool symmetric_;
 
   fei::SharedPtr<fei::SparseRowGraph> remotelyOwnedGraphRows_;
 
   bool simpleProblem_;
   bool blockEntryGraph_;
 
   std::map<int,fei::Pattern*> patterns_;
 
   std::map<int,fei::ConnectivityBlock*> connectivityBlocks_;
   int arbitraryBlockCounter_;
 
   std::vector<fei::ConnectivityBlock*> sparseBlocks_;
 
   std::map<int, ConstraintType* >
     lagrangeConstraints_, penaltyConstraints_, slaveConstraints_;
 
   bool ptEqualBlk_;
 
   bool newSlaveData_;
 
   int localNumSlaves_;
   int globalNumSlaves_;
 
   fei::SharedPtr<FillableMat> D_;
   fei::SharedPtr<CSVec> g_;
   bool g_nonzero_;
 
   fei::SharedPtr<fei::Reducer> reducer_;
 
   std::string name_;
   std::string dbgprefix_;
 
   std::vector<int> tmpIntArray1_, tmpIntArray2_;
 
   int* vspcEqnPtr_;
 
   std::set<int> constrained_indices_;
 
   bool includeAllSlaveConstraints_;
};//class MatrixGraph_Impl2
 
 inline fei::SharedPtr<fei::VectorSpace> MatrixGraph_Impl2::getRowSpace()
   {
     return(rowSpace_);
   }
 
 inline fei::SharedPtr<fei::VectorSpace> MatrixGraph_Impl2::getColSpace()
   {
     return(colSpace_);
   }
 
 inline std::map<int,fei::ConnectivityBlock*>& MatrixGraph_Impl2::getConnectivityBlocks()
   {
     return(connectivityBlocks_);
   }
 
 inline int MatrixGraph_Impl2::getGlobalNumSlaveConstraints() const
   {
     return( globalNumSlaves_ );
   }
 
 inline std::map<int, ConstraintType* >& MatrixGraph_Impl2::getLagrangeConstraints()
   {
     return( lagrangeConstraints_ );
   }
}//namespace fei
 
#endif