BMIPhreeqcRM.h

Go to the documentation of this file.

 
#if !defined(BMIPHREEQCRM_H_INCLUDED)
#define BMIPHREEQCRM_H_INCLUDED
#include <map>
 
#if defined(WITH_PYBIND11)
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
#include <pybind11/stl.h>
#include <pybind11/stl_bind.h>
 
namespace py = pybind11;
 
class NotIntialized : public std::runtime_error {
public:
    NotIntialized() : std::runtime_error("must call initialize first") { };
};
#endif
 
#include "PhreeqcRM.h"
#include "BMIVariant.h"
#include "bmi.hxx"
#include "VarManager.h"
class NotImplemented : public std::logic_error {
public:
    NotImplemented() : std::logic_error("Not Implemented") { };
};
class IRM_DLL_EXPORT BMIPhreeqcRM : public bmi::Bmi, public PhreeqcRM
{
public:
    static void             CleanupBMIModuleInstances(void);
    static int              CreateBMIModule();
    static int              CreateBMIModule(int nxyz, MP_TYPE nthreads);
    static IRM_RESULT       DestroyBMIModule(int n);
    static BMIPhreeqcRM*    GetInstance(int n);
    BMIPhreeqcRM(int ngrid = PhreeqcRM::default_nxyz, MP_TYPE nthreads = PhreeqcRM::default_data_for_parallel_processing);
 
    ~BMIPhreeqcRM() override;
 
    // Model control functions.
    void Initialize(std::string config_file = "") override;
    void Update() override;
 
    void UpdateUntil(double end_time) override;
    void Finalize() override;
 
    // Model information functions.
 
#if defined(_MSC_VER)
#if defined(_WIN64)
    std::string GetComponentName() override {
        char buffer[400];
        sprintf(buffer, "BMI PhreeqcRM [MSC v.%d 64 bit (AMD64)]", _MSC_VER);
        return buffer;
    };
#elif defined(_WIN32)
    std::string GetComponentName() override {
        char buffer[400];
        sprintf(buffer, "BMI PhreeqcRM [MSC v.%d 32 bit (Intel)]", _MSC_VER);
        return buffer;
    };
#else
    std::string GetComponentName() override {
        char buffer[400];
        sprintf(buffer, "BMI PhreeqcRM [MSC v.%d Unknown]", _MSC_VER);
        return buffer;
    };
#endif
#else
    std::string GetComponentName() override { return "BMI PhreeqcRM"; };
#endif
 
    int GetInputItemCount() override;
 
    int GetOutputItemCount() override;
    int GetPointableItemCount();
 
    std::vector<std::string> GetInputVarNames() override;
 
    std::vector<std::string> GetOutputVarNames() override;
 
    std::vector<std::string> GetPointableVarNames();
 
    std::vector<std::string> GetReadOnlyVarNames();
 
    // Variable information functions
    int GetVarGrid(const std::string name) override { return 0; }
 
    std::string GetVarType(const std::string name) override;
    std::string GetVarUnits(const std::string name) override;
 
    int GetVarItemsize(const std::string name) override;
 
    int GetVarNbytes(const std::string name) override;
 
    std::string GetVarLocation(const std::string name) override { return "Unknown"; }
 
    // Time functions
 
    double GetCurrentTime() override;
 
    double GetStartTime() override;
 
    double GetEndTime() override;
 
    std::string GetTimeUnits() override { return "seconds"; };
    double GetTimeStep() override
    {
        return PhreeqcRM::GetTimeStep();
    };
 
    // Variable getters
    //Add NEW_VARIABLE to GetValue Documentation
    void GetValue(const std::string name, void* dest) override;
    void GetValue(const std::string name, bool& OUTPUT);
    void GetValue(const std::string name, bool* OUTPUT);
    void GetValue(const std::string name, double& OUTPUT);
    void GetValue(const std::string name, double* OUTPUT);
    void GetValue(const std::string name, int& OUTPUT);
    void GetValue(const std::string name, int* OUTPUT);
    void GetValue(const std::string name, std::string& OUTPUT);
    void GetValue(const std::string name, std::vector<double>& OUTPUT);
    void GetValue(const std::string name, std::vector<int>& OUTPUT);
    void GetValue(const std::string name, std::vector<std::string>& OUTPUT);
    //Add NEW_VARIABLE to GetValuePtr Documentation
    void* GetValuePtr(std::string name) override;  
    void GetValueAtIndices(std::string name, void* dest, int* inds, int count) override
    {
        throw NotImplemented();
    };
    
    // Variable setters
    void SetValue(const std::string name, void* src) override;
    void SetValue(const std::string name, bool src);
    void SetValue(const std::string name, const char* src);
    void SetValue(const std::string name, double src);
    void SetValue(const std::string name, int src);
    void SetValue(const std::string name, const std::string src);
    void SetValue(const std::string name, std::vector<double> src);
    void SetValue(const std::string name, std::vector<int>  src);
    void SetValue(const std::string name, std::vector<std::string>  src);
    void SetValueAtIndices(std::string name, int* inds, int count, void* src) override
    {
        throw NotImplemented();
    };
    // Grid information functions
    int GetGridRank(const int grid) override;
    int GetGridSize(const int grid) override;
    std::string GetGridType(const int grid) override;
    void GetGridShape(const int grid, int* shape) override
    {
        throw NotImplemented();
    }
    void GetGridSpacing(const int grid, double* spacing) override
    {
        throw NotImplemented();
    }
    void GetGridOrigin(const int grid, double* origin) override
    {
        throw NotImplemented();
    }
    void GetGridX(const int grid, double* x) override
    {
        throw NotImplemented();
    }
    void GetGridY(const int grid, double* y) override
    {
        throw NotImplemented();
    }
    void GetGridZ(const int grid, double* z) override
    {
        throw NotImplemented();
    }
    int GetGridNodeCount(const int grid) override
    {
        throw NotImplemented();
    }
    int GetGridEdgeCount(const int grid) override
    {
        throw NotImplemented();
    }
    int GetGridFaceCount(const int grid) override
    {
        throw NotImplemented();
    }
    void GetGridEdgeNodes(const int grid, int* edge_nodes) override
    {
        throw NotImplemented();
    }
    void GetGridFaceEdges(const int grid, int* face_edges) override
    {
        throw NotImplemented();
    }
    void GetGridFaceNodes(const int grid, int* face_nodes) override
    {
        throw NotImplemented();
    }
    void GetGridNodesPerFace(const int grid, int* nodes_per_face) override
    {
        throw NotImplemented();
    }
    void AddOutputVars(std::string option, std::string def) override;
 
    IRM_RESULT SetLanguage(const char* string) { this->language = string; return IRM_OK; };
    // data
    std::string language;
    // typedef void (*VarFunction)(BMIPhreeqcRM* brm_ptr); // function pointer type
    // typedef std::map<std::string, VarFunction> VarFunction_map;
    // VarFunction_map varfn_map;
    // VarFunction GetFn(const std::string name);
    //  std::set<std::string> UpdateMap;
    // std::set<std::string>& GetUpdateMap() { return UpdateMap; }
 
    IRM_RESULT                          LoadDatabase(const std::string& database) override;
 
#if defined(WITH_PYBIND11)
 
    py::array BMIPhreeqcRM::get_value(std::string name, py::array arr);
 
    //py::array get_value_test(std::string arg, py::array dest/* = py::none()*/);
    //py::array BMIPhreeqcRM::get_value_test(std::string name, py::array_t<double> dest = py::none());
    py::array get_value_ptr(std::string name);
 
    void set_value(std::string name, py::array src);
 
    py::array get_value_at_indices(std::string name, py::array dest, py::array indices);
 
    void set_value_at_indices(std::string name, py::array indices, py::array src);
 
    py::sequence process_sequence(py::sequence seq);
 
    bool _initialized;   // { var_man != nullptr }
#endif
 
#if defined(SWIG) || defined(swig_python_EXPORTS)
    void get_value_ptr_double(std::string var, double** ARGOUTVIEW_ARRAY1, int* DIM1);
    void get_value_ptr_int(std::string var, int** ARGOUTVIEW_ARRAY1, int* DIM1);
    std::vector<std::string>& get_value_ptr_vector_strings(std::string var);
#endif
 
protected:
    void Construct(void) override;
 
private:
    //friend class RM_interface;
    VarManager* var_man;
    bool constructed;
 
    void ClearBMISelectedOutput() override;
    void GenerateAutoOutputVars() override;
    void UpdateBMI(RMVARS v_enum) override;
    void UpdateVariables();
    RMVARS GetEnum(const std::string name);
};
#endif //BMIPHREEQCRM_H_INCLUDED