probes.h

Go to the documentation of this file.

 
#pragma once
 
#include <petscis.h>
#include <petscsys.h>
 
#include <yaml-cpp/yaml.h>
 
#include <petibm/lininterp.h>
#include <petibm/mesh.h>
#include <petibm/type.h>
#include <petibm/solution.h>
 
namespace petibm
{
namespace misc
{
class ProbeBase
{
public:
    ProbeBase() = default;
 
    ProbeBase(const MPI_Comm &comm,
              const YAML::Node &node,
              const type::Mesh &mesh);
 
    virtual ~ProbeBase();
 
    virtual PetscErrorCode destroy();
 
    PetscErrorCode monitor(const type::Solution &solution,
                           const type::Mesh &mesh,
                           const PetscInt &n,
                           const PetscReal &t);
 
protected:
    std::string name;
 
    std::string path;
 
    type::Field field;
 
    PetscInt n_monitor;
 
    PetscReal t_start;
 
    PetscReal t_end;
 
    PetscViewer viewer;
 
    PetscViewerType viewerType;
 
    MPI_Comm comm;
 
    PetscMPIInt commSize;
 
    PetscMPIInt commRank;
 
    virtual PetscErrorCode init(const MPI_Comm &comm,
                                const YAML::Node &node,
                                const type::Mesh &mesh) = 0;
    
    virtual PetscErrorCode monitorVec(const DM &da,
                                      const Vec &fvec,
                                      const PetscInt &n,
                                      const PetscReal &t) = 0;
 
};  // ProbeBase
 
class ProbeVolume : public ProbeBase
{
public:
    ProbeVolume(const MPI_Comm &comm,
                const YAML::Node &node,
                const type::Mesh &mesh);
 
    virtual ~ProbeVolume() = default;
 
    PetscErrorCode destroy();
 
protected:
    type::RealVec2D box;
 
    IS isPetsc;
 
    IS isNatural;
 
    Vec dvec;
 
    type::RealVec2D coord;
 
    type::IntVec1D nPtsDir;
 
    PetscInt nPts;
 
    type::IntVec1D startIdxDir;
 
    PetscReal atol;
 
    PetscInt n_sum;
 
    PetscInt count = 0;
 
    PetscErrorCode init(const MPI_Comm &comm,
                        const YAML::Node &node,
                        const type::Mesh &mesh);
 
    PetscErrorCode getInfo(const type::Mesh &mesh,
                           const type::RealVec2D &box);
 
    PetscErrorCode createIS(const type::Mesh &mesh);
 
    PetscErrorCode createGrid(const type::Mesh &mesh);
 
    PetscErrorCode writeGrid(const std::string &filePath);
 
    PetscErrorCode writeGrid_ASCII(const std::string &filePath);
 
    PetscErrorCode writeGrid_HDF5(const std::string &filePath);
 
    PetscErrorCode writeIS(const std::string &filePath);
 
    PetscErrorCode writeIS_HDF5(const std::string &filePath);
 
    PetscErrorCode writeIS_ASCII(const std::string &filePath);
 
    PetscErrorCode monitorVec(const DM &da,
                              const Vec &fvec,
                              const PetscInt &n,
                              const PetscReal &t);
 
    PetscErrorCode writeVec(const Vec &vec, const PetscReal &t);
 
    PetscErrorCode writeVec_ASCII(const Vec &vec, const PetscReal &t);
 
    PetscErrorCode writeVec_HDF5(const Vec &vec, const PetscReal &t);
 
};  // ProbeVolume
 
class ProbePoint : public ProbeBase
{
public:
    ProbePoint(const MPI_Comm &comm,
               const YAML::Node &node,
               const type::Mesh &mesh);
 
    virtual ~ProbePoint() = default;
 
    PetscErrorCode destroy();
 
protected:
    type::RealVec1D loc;
 
    PetscBool pointOnLocalProc;
 
    Vec svec;
 
    PetscReal value;
 
    type::LinInterp interp;
 
    PetscErrorCode init(const MPI_Comm &comm,
                        const YAML::Node &node,
                        const type::Mesh &mesh);
 
    PetscErrorCode monitorVec(const DM &da,
                              const Vec &fvec,
                              const PetscInt &n,
                              const PetscReal &t);
 
};  // ProbePoint
 
}  // end of namespace misc
 
namespace type
{
typedef std::shared_ptr<misc::ProbeBase> Probe;
 
}  // end of namespace type
 
namespace misc
{
PetscErrorCode createProbe(const MPI_Comm &comm,
                           const YAML::Node &node,
                           const type::Mesh &mesh,
                           type::Probe &probe);
 
}  // end of namespace misc
 
}  // end of namespace petibm