SampleMesh.hpp

 
#ifndef SAMPLEMESH_H
#define SAMPLEMESH_H
 
#include <set>
#include <string>
 
#include "mfem.hpp"
#include "mpi.h"
 
#include "linalg/Matrix.h"
 
using namespace mfem;
using std::vector;
using std::set;
using std::map;
using std::string;
 
namespace CAROM {
 
void SampleVisualization(ParMesh *pmesh, set<int> const& elems,
                         set<int> const& intElems, set<int> const& faces,
                         set<int> const& edges, set<int> const& vertices,
                         string const& filename,
                         mfem::Vector *elemCount=nullptr,
                         double elementScaling=1.0);
 
class SampleMeshManager
{
public:
    SampleMeshManager(vector<ParFiniteElementSpace*> & fespace_,
                      string visFileName="", double visScale=1.0);
 
    void RegisterSampledVariable(const string variable, const int space,
                                 vector<int> const& sample_dofs_v, vector<int> const& num_sample_dofs_per_proc);
 
    void ConstructSampleMesh();
 
    void GatherDistributedMatrixRows(const string variable, CAROM::Matrix const& B,
                                     const int rdim, CAROM::Matrix& Bsp) const;
 
    ParFiniteElementSpace* GetSampleFESpace(const int space) const {
        return spfespace[space];
    }
 
    ParMesh* GetSampleMesh() const {
        MFEM_VERIFY(finalized, "Sample mesh is not constructed");
        return sample_pmesh;
    }
 
    int GetNumVarSamples(const string variable) const;
 
    void GetSampledValues(const string variable, mfem::Vector const& v,
                          CAROM::Vector & s) const;
 
 
    set<int>* GetSampleElements() {
        return &elems;
    }
 
    void WriteVariableSampleMap(const string variable, string file_name) const;
 
    ~SampleMeshManager()
    {
        for (int i=0; i<nspaces; ++i)
            delete spfespace[i];
 
        delete sample_pmesh;
    }
 
private:
    void CreateSampleMesh();
 
    int GetVariableIndex(const string variable) const;
 
    void SetSampleMaps();
    void FinishSampleMaps();
 
    bool finalized;
 
    const int nspaces;
    int nvar = 0;
 
    map<string, int> vmap;  // Variable name to index map
 
    int myid, nprocs;
    MPI_Comm root_comm;
 
    vector<ParFiniteElementSpace*> fespace;
    vector<ParFiniteElementSpace*> spfespace;
 
    ParMesh *pmesh = nullptr;
    ParMesh *sample_pmesh = nullptr;
 
    vector<vector<set<int>>> sample_dofs_proc;
 
    vector<int> sample_dofs;  // block true DOFs for all spaces, for all processes.
 
    vector<int> num_sample_dofs_per_proc_merged;
 
    vector<int> varSpace;
    vector<vector<int>> sample_dofs_var;
    vector<vector<int>> num_sample_dofs_per_proc_var;
    vector<vector<int>> s2sp_var;
    vector<int> s2sp, st2sp;
    vector<int>
    sprows;  // Local true DOFs on the original full mesh, restricted to the sample mesh stencil.
    vector<int> all_sprows;  // sprows gathered over all processes
 
    vector<int> spaceTOS, spaceOS, spaceOSSP;
    vector<vector<int>> spaceOSall;
 
    set<int> elems;
 
    string filename;  // For visualization output
 
    double elemVisScale;  // Scaling for sample element visualization
};
 
class SampleDOFSelector {
public:
    SampleDOFSelector() { }
 
    void ReadMapFromFile(const string variable, string file_name);
 
    void GetSampledValues(const string variable, mfem::Vector const& v,
                          CAROM::Vector & s) const;
 
    ~SampleDOFSelector()
    { }
 
private:
    int nvar = 0;
    map<string, int> vmap;  // Variable name to index map
    vector<vector<int>> s2sp_var;
 
    int GetVariableIndex(const string variable) const;
};
 
}  // namespace CAROM
 
#endif // SAMPLEMESH_H