fei_VectorSpace.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_VectorSpace_hpp_
#define _fei_VectorSpace_hpp_

#include <fei_macros.hpp>
#include <fei_constants.hpp>
#include <fei_fwd.hpp>
#include <fei_SharedPtr.hpp>
#include <fei_Logger.hpp>
#include <fei_utils.hpp>
#include <fei_CommUtils.hpp>
#include <fei_FieldDofMap.hpp>
#include <fei_ctg_set.hpp>
#include <snl_fei_RaggedTable.hpp>

namespace fei {
  class FieldMask;
  class Lookup_Impl;
  class Pattern;
  template<typename GlobalIDType> class Record;
  template<typename GlobalIDType> class Record_Operator;
  template<typename GlobalIDType> class SharedIDs;

  class VectorSpace : private fei::Logger {
  public:
    class Factory {
    public:
      virtual ~Factory(){}

     virtual fei::SharedPtr<VectorSpace> createVectorSpace(MPI_Comm,
                                                           const char* name);
    };

    VectorSpace(MPI_Comm comm, const char* name = NULL);

    virtual ~VectorSpace();


    void setParameters(const fei::ParameterSet& paramset);

    void defineFields(int numFields,
                      const int* fieldIDs,
                      const int* fieldSizes,
                      const int* fieldTypes = NULL);

    void defineIDTypes(int numIDTypes,
                       const int* idTypes);

    void setIDMap(int idType,
                  const int* localIDs_begin, const int* localIDs_end,
                  const int* globalIDs_begin, const int* globalIDs_end);

    int addDOFs(int fieldID,
                int idType,
                int numIDs,
                const int* IDs);

    int addDOFs(int idType,
                int numIDs,
                const int* IDs);

    int initSharedIDs(int numShared,
                      int idType,
                      const int* sharedIDs,
                      const int* numSharingProcsPerID,
                      const int* sharingProcs);

    int initSharedIDs(int numShared,
                      int idType,
                      const int* sharedIDs,
                      const int* numSharingProcsPerID,
                      const int* const* sharingProcs);

    int setOwners(int numShared, int idType, const int* sharedIDs, const int* owners);

    int addVectorSpace(fei::VectorSpace* inputSpace);

    int initComplete();

    bool initCompleteAlreadyCalled() const { return initCompleteAlreadyCalled_; }



    MPI_Comm getCommunicator() const;

    int getGlobalIndex(int idType,
                       int ID,
                       int fieldID,
                       int fieldOffset,
                       int whichComponentOfField,
                       int& globalIndex);

    int getGlobalIndex(int idType,
                       int ID,
                       int fieldID,
                       int& globalIndex);

    int getGlobalBlkIndex(int idType,
                          int ID,
                          int& globalBlkIndex);

    int getGlobalIndices(int numIDs,
                         const int* IDs,
                         int idType,
                         int fieldID,
                         int* globalIndices);

    int getGlobalIndicesLocalIDs(int numIDs,
                         const int* localIDs,
                         int idType,
                         int fieldID,
                         int* globalIndices);

    int getGlobalBlkIndices(int numIDs,
                         const int* IDs,
                         int idType,
                         int* globalBlkIndices);

    int getGlobalIndices(int numIDs,
                         const int* IDs,
                         const int* idTypes,
                         const int* fieldIDs,                         
                         int* globalIndices);

    int getGlobalIndex(int idType,
                       int ID,
                       int& globalIndex);

    int getNumDegreesOfFreedom(int idType,
                               int ID);

    int getNumFields();

    void getFields(std::vector<int>& fieldIDs);

    int getNumFields(int idType, int ID);

    void getFields(int idType, int ID, std::vector<int>& fieldIDs);

    size_t getNumIDTypes();

    void getIDTypes(std::vector<int>& idTypes) const;

    void getGlobalIndexOffsets(std::vector<int>& globalOffsets) const;

    void getGlobalBlkIndexOffsets(std::vector<int>& globalBlkOffsets) const;

    int getOwnerProcPtIndex(int globalIndex);

    int getOwnerProcBlkIndex(int globalIndex);

    bool isLocal(int idType, int ID);

    bool isLocallyOwned(int idType, int ID);

    unsigned getFieldSize(int fieldID);

    int getNumOwnedAndSharedIDs(int idType);

    int getNumOwnedIDs(int idType);

    int getOwnedAndSharedIDs(int idtype,
                    int lenList,
                    int* IDs,
                    int& numOwnedAndSharedIDs);

    int getOwnedIDs(int idtype,
                           int lenList,
                           int* IDs,
                           int& numLocalIDs);

    int getNumIndices_SharedAndOwned() const;

    int getIndices_SharedAndOwned(std::vector<int>& globalIndices) const;

    int getNumBlkIndices_SharedAndOwned(int& numBlkIndices) const;

    int getBlkIndices_SharedAndOwned(int lenBlkIndices,
                                     int* globalBlkIndices,
                                     int* blkSizes,
                                     int& numBlkIndices);

    int getNumIndices_Owned() const;

    int getIndices_Owned(std::vector<int>& globalIndices) const;
    int getIndices_Owned(int lenIndices, int* globalIndices, int& numIndices) const;

    int getNumBlkIndices_Owned() const;

    int getBlkIndices_Owned(int lenBlkIndices,
                            int* globalBlkIndices,
                            int* blkSizes,
                            int& numBlkIndices);

    int getNumSharedIDs(int idType, int& numShared);

    int getGlobalNumIndices() const;

    int getGlobalNumBlkIndices() const;

    int getRecordCollection(int idType, snl_fei::RecordCollection*& records);

    int getRecordCollection(int idType, const snl_fei::RecordCollection*& records) const;

    std::vector<int>& getEqnNumbers();

    const std::vector<int>& getEqnNumbers() const;

    snl_fei::PointBlockMap* getPointBlockMap();
    const snl_fei::PointBlockMap* getPointBlockMap() const;

    fei::FieldDofMap<int>& getFieldDofMap();

    void getGlobalIndices(const fei::Pattern* pattern,
                          const fei::Record<int>*const* records,
                          std::vector<int>& indices);

    void getGlobalIndicesL(const fei::Pattern* pattern,
                          const int* records,
                          std::vector<int>& indices);

    void getGlobalBlkIndices(const fei::Pattern* pattern,
                             const fei::Record<int>*const* records,
                             std::vector<int>& indices);

    void getGlobalIndices(int numRecords,
                          const fei::Record<int>*const* records,
                          int fieldID,
                          int fieldSize,
                          int indicesAllocLen,
                          int* indices,
                          int& numIndices);

    void getGlobalIndicesL(int numRecords,
                          const snl_fei::RecordCollection*const* recordCollections,
                          const int* records,
                          int fieldID,
                          int fieldSize,
                          int indicesAllocLen,
                          int* indices,
                          int& numIndices);

    void getGlobalIndices(int numRecords,
                          const fei::Record<int>*const* records,
                          const int* numFieldsPerID,
                          const int* fieldIDs,
                          const int* fieldSizes,
                          int indicesAllocLen,
                          int* indices,
                          int& numIndices);

    void getGlobalIndicesL(int numRecords,
                          const snl_fei::RecordCollection*const* recordCollections,
                          const int* records,
                          const int* numFieldsPerID,
                          const int* fieldIDs,
                          const int* fieldSizes,
                          int indicesAllocLen,
                          int* indices,
                          int& numIndices);

    void getGlobalBlkIndices(int numRecords,
                             const fei::Record<int>*const* records,
                             int indicesAllocLen,
                             int* indices,
                             int& numIndices);

    void getGlobalBlkIndicesL(int numRecords,
                             const snl_fei::RecordCollection*const* recordCollections,
                             const int* records,
                             int indicesAllocLen,
                             int* indices,
                             int& numIndices);

    int addDOFs(int fieldID,
                            int idType,
                            int numIDs,
                            const int* IDs,
                            int* records);

    int addDOFs(int idType,
                            int numIDs,
                            const int* IDs,
                            int* records);

    std::vector<fei::FieldMask*> fieldMasks_;

    void getSendProcs(std::vector<int>& sendProcs) const;

    fei::SharedIDs<int>& getSharedIDs(int idType);

  private:
    friend class fei::Lookup_Impl;

  private:
    VectorSpace(const VectorSpace& src);
    VectorSpace& operator=(const VectorSpace& src);

    void compute_shared_ids(const std::vector<int>& global_min, const std::vector<int>& global_max);

    inline void check_version() { fei::utils::version(); }

    void setOwners_shared();

    int calculateGlobalIndices();

    void runRecords(fei::Record_Operator<int>& record_op);

    void runRecords(fei::Record_Operator<int>& record_op, int recordIndex);

    int synchronizeSharedRecords();

    int setLocalEqnNumbers();

    int exchangeGlobalIndices();

    int exchangeFieldInfo(fei::comm_map* ownerPattern,
                          fei::comm_map* sharerPattern,
                          snl_fei::RecordCollection* recordCollection,
                          std::vector<fei::FieldMask*>& fieldMasks);

    void setName(const char* name);

  private:
    MPI_Comm comm_;

    std::vector<int> idTypes_;
    std::map<int,unsigned> fieldDatabase_;
    fei::FieldDofMap<int> fieldDofMap_;
    int maxFieldSize_;
    std::vector<snl_fei::RecordCollection*> recordCollections_;

    std::map<int, fei::SharedIDs<int> > sharedIDTables_;
    std::map<int, fei::comm_map*> ownerPatterns_;
    std::map<int, fei::comm_map*> sharerPatterns_;

    bool sharedRecordsSynchronized_;

    snl_fei::PointBlockMap* ptBlkMap_;

    std::vector<int> globalOffsets_;
    std::vector<int> globalIDOffsets_;

    bool simpleProblem_;

    int firstLocalOffset_, lastLocalOffset_;

    std::vector<int> eqnNumbers_;

    bool newInitData_;
    bool initCompleteAlreadyCalled_;

    std::string name_;
    std::string dbgprefix_;
    bool checkSharedIDs_;
  }; // class fei::VectorSpace

  inline std::vector<int>& VectorSpace::getEqnNumbers()
    {
      return( eqnNumbers_ );
    }

  inline const std::vector<int>& VectorSpace::getEqnNumbers() const
    {
      return( eqnNumbers_ );
    }

  inline snl_fei::PointBlockMap* VectorSpace::getPointBlockMap()
    {
      return( ptBlkMap_ );
    }

  inline const snl_fei::PointBlockMap* VectorSpace::getPointBlockMap() const
    {
      return( ptBlkMap_ );
    }

} // namespace fei

#endif // _fei_VectorSpace_hpp_