fei_ConnectivityBlock.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_ConnectivityBlock_hpp_
#define _fei_ConnectivityBlock_hpp_

#include <fei_macros.hpp>

#include <map>
#include <vector>

namespace fei {
  class Pattern;

  class ConnectivityBlock {
  public:
    ConnectivityBlock(int blockID,
                      fei::Pattern* pattern,
                      int numConnectivities);
    ConnectivityBlock(int blockID,
                      fei::Pattern* rowpattern, fei::Pattern* colpattern,
                      int numConnectivities);
    ConnectivityBlock(int numRowIDs,
                      const int* rowIDs,
                      const int* rowOffsets,
                      bool offsets_are_lengths = false);

    ConnectivityBlock(int fieldID,
                      int numRowIDs,
                      const int* rowIDs,
                      const int* rowOffsets,
                      bool offsets_are_lengths = false);

    virtual ~ConnectivityBlock();

    int getBlockID() const { return(blockID_); }

    const fei::Pattern* getRowPattern() const { return(pattern_); }

    fei::Pattern* getRowPattern() { return(pattern_); }

    void setRowPattern(fei::Pattern* pattern) { pattern_ = pattern; }

    const fei::Pattern* getColPattern() const { return(colPattern_); }

    fei::Pattern* getColPattern() { return(colPattern_); }

    void setColPattern(fei::Pattern* pattern) { colPattern_ = pattern; }

    const std::map<int,int>& getConnectivityIDs() const { return( connIDsOffsetMap_ ); }

    std::map<int,int>& getConnectivityIDs() { return( connIDsOffsetMap_ ); }

    std::vector<int>& getConnectivityOffsets()
      { return(connectivityOffsets_); }

    std::vector<int>& getRowConnectivities()
      { return(connectivities_); }

    std::vector<int>& getColConnectivities()
      { return(colConnectivities_); }

    const int* getRowConnectivity(int ID) const;
    const int* getColConnectivity(int ID) const;
    int* getRowConnectivity(int ID);
    int* getColConnectivity(int ID);

    bool isSymmetric() const { return( isSymmetric_ ); }

    void setIsDiagonal(bool flag) { isDiagonal_ = flag; }
    bool isDiagonal() const { return( isDiagonal_ ); }

    bool haveFieldID()
      { return( haveFieldID_ ); }

    int fieldID()
      { return( fieldID_ ); }

  private:
    int blockID_;
    fei::Pattern* pattern_;
    fei::Pattern* colPattern_;
    bool isSymmetric_;
    bool isDiagonal_;

    std::map<int,int> connIDsOffsetMap_;

    std::vector<int> connectivityOffsets_;

    int numRecordsPerConnectivity_;
    std::vector<int> connectivities_;
    int numRecordsPerColConnectivity_;
    std::vector<int> colConnectivities_;

    int fieldID_;
    bool haveFieldID_;

  };//class ConnectivityBlock
} //namespace fei

#endif // _fei_ConnectivityBlock_hpp_