fei_MatrixGraph.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_MatrixGraph_hpp_
#define _fei_MatrixGraph_hpp_

#include <fei_macros.hpp>
#include <fei_SharedPtr.hpp>
#include <fei_VectorSpace.hpp>
#include <fei_Reducer.hpp>
#include <snl_fei_Constraint.hpp>
#include <fei_Record.hpp>
#include <fei_SparseRowGraph.hpp>

#include <vector>

namespace fei {
  class ConnectivityBlock;
  class Pattern;
  class SparseRowGraph;
  typedef snl_fei::Constraint<fei::Record<int>*> ConstraintType;

class MatrixGraph {
 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) = 0;
  };

  enum { REDUCED_INDICES   = 0,
         UNREDUCED_INDICES = 1,
         BLOCK_ENTRY_GRAPH = 2,
         POINT_ENTRY_GRAPH = 3};

  virtual ~MatrixGraph(){}

  virtual void setParameters(const fei::ParameterSet& params) = 0;

  virtual void setRowSpace(fei::SharedPtr<fei::VectorSpace> rowSpace) = 0;

  virtual fei::SharedPtr<fei::VectorSpace> getRowSpace() = 0;

  virtual void setColumnSpace(fei::SharedPtr<fei::VectorSpace> columnSpace) = 0;

  virtual fei::SharedPtr<fei::VectorSpace> getColSpace() = 0;

  virtual int definePattern(int numIDs,
                     int idType) = 0;

  virtual int definePattern(int numIDs,
                    int idType,
                    int fieldID) = 0;

   virtual int definePattern(int numIDs,
                     int idType,
                     const int* numFieldsPerID,
                     const int* fieldIDs) = 0;

   virtual int definePattern(int numIDs,
                     const int* idTypes,
                     const int* numFieldsPerID,
                     const int* fieldIDs) = 0;

   virtual int initConnectivityBlock(int blockID,
                             int numConnectivityLists,
                             int patternID,
                             bool diagonal=false) = 0;

   virtual int initConnectivityBlock(int numConnectivityLists,
                                     int patternID,
                                     bool diagonal=false) = 0;

   virtual int initConnectivityBlock(int blockID,
                             int numConnectivityLists,
                             int rowPatternID,
                             int colPatternID) = 0;

   virtual int initConnectivity(int blockID,
                        int connectivityID,
                        const int* connectedIdentifiers) = 0;

   virtual int initConnectivity(int blockID,
                        int connectivityID,
                        const int* rowConnectedIdentifiers,
                        const int* colConnectedIdentifiers) = 0;

   virtual int initConnectivity(int patternID,
                        const int* connectedIdentifiers) = 0;

   virtual int initConnectivity(int rowPatternID,
                        const int* rowConnectedIdentifiers,
                        int colPatternID,
                        const int* colConnectedIdentifiers) = 0;

   virtual int initConnectivity(int idType,
                        int numRows,
                        const int* rowIDs,
                        const int* rowOffsets,
                        const int* packedColumnIDs) = 0;

   virtual int initConnectivity(int idType,
                        int fieldID,
                        int numRows,
                        const int* rowIDs,
                        const int* rowOffsets,
                        const int* packedColumnIDs) = 0;

   virtual int initConnectivity(int idType,
                        int numRows,
                        const int* rowIDs,
                        const int* rowLengths,
                        const int*const* columnIDs) = 0;

   virtual int initLagrangeConstraint(int constraintID,
                              int constraintIDType,
                              int numIDs,
                              const int* idTypes,
                              const int* IDs,
                              const int* fieldIDs) = 0;

   virtual int initPenaltyConstraint(int constraintID,
                             int constraintIDType,
                             int numIDs,
                             const int* idTypes,
                             const int* IDs,
                             const int* fieldIDs) = 0;

   virtual int initSlaveConstraint(int numIDs,
                           const int* idTypes,
                           const int* IDs,
                           const int* fieldIDs,
                           int offsetOfSlave,
                           int offsetIntoSlaveField,
                           const double* weights,
                           double rhsValue) = 0;

   virtual bool newSlaveData() = 0;

   virtual bool hasSlaveDof(int ID, int idType) = 0;

   virtual int initComplete() = 0;

   virtual fei::SharedPtr<fei::SparseRowGraph>
     createGraph(bool blockEntryGraph,
                 bool localRowGraph_includeSharedRows=false) = 0;

   virtual int compareStructure(const fei::MatrixGraph& matrixGraph,
                        bool& equivalent) const = 0;

   virtual int getNumConnectivityBlocks() const = 0;

   virtual std::map<int,fei::ConnectivityBlock*>& getConnectivityBlocks() = 0;
   virtual int getConnectivityBlockIDs(std::vector<int>& blockIDs) const = 0;

   virtual int getNumIDsPerConnectivityList(int blockID) const = 0;

   virtual int getConnectivityNumIndices(int blockID) const = 0;

   virtual int getConnectivityNumIndices(int blockID,
                                 int& numRowIndices,
                                 int& numColIndices) = 0;

   virtual int getConnectivityIndices(int blockID,
                              int connectivityID,
                              int indicesAllocLen,
                              int* indices,
                              int& numIndices) = 0;

   virtual int getConnectivityIndices(int blockID,
                              int connectivityID,
                              int rowIndicesAllocLen,
                              int* rowIndices,
                              int& numRowIndices,
                              int colIndicesAllocLen,
                              int* colIndices,
                              int& numColIndices) = 0;

   virtual int getPatternNumIndices(int patternID,
                            int& numIndices) = 0;

   virtual int getPatternIndices(int patternID,
                         const int* IDs,
                         std::vector<int>& indices) = 0;

   virtual int getLocalNumLagrangeConstraints() const = 0;

   virtual int getGlobalNumSlaveConstraints() const = 0;

   virtual ConstraintType* getLagrangeConstraint(int constraintID) = 0;

   virtual std::map<int, ConstraintType* >& getLagrangeConstraints() = 0;

   virtual ConstraintType* getPenaltyConstraint(int constraintID) = 0;

   virtual ConstraintType* getSlaveConstraint(int constraintID) = 0;

   virtual int getConstraintConnectivityIndices(ConstraintType* cr,
                                        std::vector<int>& globalIndices) = 0;

   virtual const fei::ConnectivityBlock* getConnectivityBlock(int blockID) const = 0;

   virtual fei::ConnectivityBlock* getConnectivityBlock(int blockID) = 0;

   virtual void setIndicesMode(int mode) = 0;

   virtual fei::SharedPtr<fei::FillableMat> getSlaveDependencyMatrix() = 0;

   virtual fei::Pattern* getPattern(int patternID) = 0;

   virtual int createSlaveMatrices() = 0;

   virtual fei::SharedPtr<fei::Reducer> getReducer() = 0;

   virtual fei::SharedPtr<fei::SparseRowGraph> getRemotelyOwnedGraphRows() = 0;

   virtual void getConstrainedIndices(std::vector<int>& crindices) const = 0;
};//class MatrixGraph
}//namespace fei

#endif