Writer.h

Go to the documentation of this file.

#ifndef included_AMP_Writer
#define included_AMP_Writer
 
#include "AMP/mesh/MeshID.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Array.h"
#include "AMP/utils/Database.h"
 
#include <memory>
#include <string>
#include <vector>
 
 
// Declare some classes
namespace AMP::Mesh {
class Mesh;
class MeshIterator;
struct MeshElementID;
} // namespace AMP::Mesh
namespace AMP::LinearAlgebra {
class Vector;
class Matrix;
} // namespace AMP::LinearAlgebra
 
class dummy;
 
namespace AMP::IO {
 
 
class Writer
{
public:
    struct WriterProperties {
        std::string type;            // Writer type: Silo, HDF5, Ascii
        std::string extension;       // The primary file extension for the writer
        bool registerMesh;           // Does the writer support registering a mesh
        bool registerVector;         // Does the writer support registering a vector
        bool registerVectorWithMesh; // Does the writer support registering a vector with a mesh
        bool registerMatrix;         // Does the writer support registering a matrix
        bool enabled;                // Is the current writer enabled
        bool isNull;                 // Is the current writer a null writer
        WriterProperties();
    };
    enum class VectorType : uint8_t { DOUBLE, SINGLE, INT };
    enum class DecompositionType : uint8_t { SINGLE, MULTIPLE };
 
 
public:
    static std::shared_ptr<AMP::IO::Writer> buildWriter( std::string type,
                                                         AMP_MPI comm = AMP_COMM_WORLD );
 
    static std::shared_ptr<AMP::IO::Writer> buildWriter( std::shared_ptr<AMP::Database> db );
 
 
public:
    virtual ~Writer() = default;
 
    Writer( const Writer & ) = delete;
 
    virtual WriterProperties getProperties() const = 0;
 
    std::string getExtension() const;
 
    virtual void setDecomposition( int decomposition );
 
    virtual void readFile( const std::string &fname ) = 0;
 
    virtual void writeFile( const std::string &fname, size_t iteration, double time = 0 ) = 0;
 
    void registerMesh( std::shared_ptr<AMP::Mesh::Mesh> mesh,
                       int level               = 1,
                       const std::string &path = std::string() );
 
    virtual void registerVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vec,
                                 std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                 AMP::Mesh::GeomType type,
                                 const std::string &name = "",
                                 VectorType precision    = VectorType::DOUBLE,
                                 bool isStatic           = false );
 
    void registerVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vec,
                         const std::string &name = "" );
 
    void registerMatrix( std::shared_ptr<AMP::LinearAlgebra::Matrix> mat,
                         const std::string &name = "" );
 
protected: // Internal structures
    // Structure to hold id
    struct GlobalID {
        uint64_t objID;     // Object id
        uint32_t ownerRank; // Global rank of the processor that "owns" the data
        GlobalID() : objID( 0 ), ownerRank( 0 ) {}
        GlobalID( uint64_t obj, uint32_t rank ) : objID( obj ), ownerRank( rank ) {}
        bool operator==( const GlobalID &rhs ) const
        {
            return objID == rhs.objID && ownerRank == rhs.ownerRank;
        }
        bool operator!=( const GlobalID &rhs ) const
        {
            return objID != rhs.objID || ownerRank != rhs.ownerRank;
        }
        bool operator<( const GlobalID &rhs ) const
        {
            if ( objID == rhs.objID )
                return ownerRank < rhs.ownerRank;
            return objID < rhs.objID;
        }
        bool operator<=( const GlobalID &rhs ) const
        {
            if ( objID == rhs.objID )
                return ownerRank <= rhs.ownerRank;
            return objID < rhs.objID;
        }
        bool operator>( const GlobalID &rhs ) const
        {
            if ( objID == rhs.objID )
                return ownerRank > rhs.ownerRank;
            return objID > rhs.objID;
        }
        bool operator>=( const GlobalID &rhs ) const
        {
            if ( objID == rhs.objID )
                return ownerRank >= rhs.ownerRank;
            return objID > rhs.objID;
        }
    };
 
    // Structure to hold vector data
    using GeomType = AMP::Mesh::GeomType;
    struct VectorData {
        bool isStatic       = false;                     // Is the variable static vs time
        VectorType dataType = VectorType::DOUBLE;        // Desired precision (if supported)
        uint8_t numDOFs     = 0;                         // Number of unknowns per point
        GeomType type       = GeomType::Nullity;         // Types of variables
        std::string name;                                // Vector name to store
        std::shared_ptr<AMP::LinearAlgebra::Vector> vec; // AMP vector
        VectorData() = default;
        VectorData( std::shared_ptr<AMP::LinearAlgebra::Vector>, const std::string & );
    };
 
    // Structure to hold matrix data
    struct MatrixData {
        std::string name;                                // Matrix name to store
        std::shared_ptr<AMP::LinearAlgebra::Matrix> mat; // AMP matrix
        MatrixData() = default;
        MatrixData( std::shared_ptr<AMP::LinearAlgebra::Matrix>, const std::string & );
    };
 
    // Structure used to hold data for a base mesh
    struct baseMeshData {
        GlobalID id;                           // Unique ID to identify the mesh
        std::shared_ptr<AMP::Mesh::Mesh> mesh; // Pointer to the mesh
        int rank;                              // Rank of the current processor on the mesh
        int ownerRank;                         // Global rank of the processor that "owns" the mesh
        std::string meshName;                  // Name of the mesh
        std::string path;                      // Path to the mesh
        std::string file;                      // File that will contain the mesh
        std::vector<VectorData> vectors;       // Vectors for each mesh
        // Function to count the number of bytes needed to pack the data
        size_t size() const;
        // Function to pack the data to a byte array (note: some info may be lost)
        void pack( char * ) const;
        // Function to unpack the data from a byte array (note: some info may be lost)
        static baseMeshData unpack( const char * );
        // Constructor
        baseMeshData() : rank( -1 ), ownerRank( -1 ) {}
    };
 
    // Structure used to hold data for a multimesh
    struct multiMeshData {
        GlobalID id;                           // Unique ID to identify the mesh
        std::shared_ptr<AMP::Mesh::Mesh> mesh; // Pointer to the mesh
        int ownerRank;                         // Global rank of the processor that "owns" the mesh
                                               // (usually rank 0 on the mesh comm)
        std::string name;                      // Name of the multimesh
        std::vector<GlobalID> meshes;          // Base mesh ids needed to construct the mesh data
        std::vector<std::string> varName;      // Vectors for each mesh
        // Function to count the number of bytes needed to pack the data
        size_t size() const;
        // Function to pack the data to a byte array
        void pack( char * ) const;
        // Function to unpack the data from a byte array
        static multiMeshData unpack( const char * );
        // Constructor
        multiMeshData() : ownerRank( -1 ) {}
    };
 
protected: // Protected member functions
    // Default constructor
    Writer() = default;
 
    // Given a filename, strip the directory information and create the directories if needed
    void createDirectories( const std::string &filename );
 
    // Function to determine which base mesh ids to register a vector with
    static std::vector<AMP::Mesh::MeshID> getMeshIDs( std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
    // Get the node coordinates and elements for a mesh
    static void getNodeElemList( std::shared_ptr<const AMP::Mesh::Mesh> mesh,
                                 const AMP::Mesh::MeshIterator &elements,
                                 AMP::Array<double> *x,
                                 AMP::Array<int> &nodelist,
                                 std::vector<AMP::Mesh::MeshElementID> &nodelist_ids );
 
    // Register the mesh returning the ids of all registered base meshes
    void registerMesh2( std::shared_ptr<AMP::Mesh::Mesh> mesh,
                        int level,
                        const std::string &path,
                        std::set<GlobalID> &base_ids );
 
    // Function to syncronize multimesh data
    std::tuple<std::vector<multiMeshData>, std::map<GlobalID, baseMeshData>>
    syncMultiMeshData( int root = -1 ) const;
 
    // Get id from a communicator
    GlobalID getID( const AMP_MPI &comm ) const;
 
    // Synchronize the vectors (call makeConsistent)
    void syncVectors();
 
    // Synchronize mesh data
    template<class TYPE>
    void syncData( std::vector<TYPE> &data, int root ) const;
 
protected: // Internal data
    // The comm of the writer
    AMP_MPI d_comm = AMP_COMM_WORLD;
 
    // The decomposition to use
    DecompositionType d_decomposition = DecompositionType::MULTIPLE;
 
    // List of all meshes and their ids
    std::map<GlobalID, baseMeshData> d_baseMeshes;
    std::map<GlobalID, multiMeshData> d_multiMeshes;
 
    // List of all independent vectors that have been registered
    std::map<GlobalID, VectorData> d_vectors;
 
    // List of all independent matrices that have been registered
    std::map<GlobalID, MatrixData> d_matrices;
 
    // List of all vectors that have been registered (work on removing)
    std::vector<std::shared_ptr<AMP::LinearAlgebra::Vector>> d_vectorsMesh;
};
 
 
} // namespace AMP::IO
 
#endif