fei_MatrixGraph_Impl2.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_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