PyEngine.h

Go to the documentation of this file.

#include <vector>
#include <vapor/MyPython.h>
#include <vapor/DataMgr.h>
#include <vapor/DC.h>
 
#pragma once
 
namespace VAPoR {
 
//
class RENDER_API PyEngine : public Wasp::MyBase {
public:
    //
    PyEngine(DataMgr *dataMgr)
    {
        VAssert(dataMgr != NULL);
        _dataMgr = dataMgr;
    }
 
    ~PyEngine();
 
    //
    static int Initialize();
 
    //
    int AddFunction(string name, string script, const vector<string> &inputs, const vector<string> &outputs, const vector<string> &outMeshes, bool coordFlag = false);
 
    //
    void RemoveFunction(string name);
 
    std::vector<string> GetFunctionNames() const;
 
    //
    string GetFunctionScript(string name) const;
 
    bool GetFunctionScript(string name, string &script, std::vector<string> &inputVarNames, std::vector<string> &outputVarNames, std::vector<string> &outputMeshNames, bool &coordFlag) const;
 
    //
    string GetFunctionStdout(string name) const;
 
    static int Calculate(const string &script, vector<string> inputVarNames, vector<DimsType> inputVarDims, vector<float *> inputVarArrays, vector<string> outputVarNames,
                         vector<DimsType> outputVarDims, vector<float *> outputVarArrays);
 
private:
    class RENDER_API DerivedPythonVar : public DerivedDataVar {
    public:
        DerivedPythonVar(string varName, string units, DC::XType type, string mesh, string time_coord_var, bool hasMissing, std::vector<string> inNames, string script, DataMgr *dataMgr,
                         bool coordFlag);
 
        ~DerivedPythonVar() {}
 
        int Initialize();
 
        bool GetBaseVarInfo(DC::BaseVar &var) const;
 
        std::vector<string> GetInputs() const { return (_inNames); }
 
        int GetDimLensAtLevel(int level, std::vector<size_t> &dims_at_level, std::vector<size_t> &bs_at_level) const;
 
        virtual size_t GetNumRefLevels() const;
 
        virtual std::vector<size_t> GetCRatios() const { return (_varInfo.GetCRatios()); }
 
        int OpenVariableRead(size_t ts, int level = 0, int lod = 0);
 
        int CloseVariable(int fd);
 
        int ReadRegion(int fd, const std::vector<size_t> &min, const std::vector<size_t> &max, float *region);
 
        bool VariableExists(size_t ts, int reflevel, int lod) const;
 
        bool GetDataVarInfo(DC::DataVar &cvar) const;
 
        string GetScriptStdout() const { return (_stdoutString); }
 
    private:
        DC::DataVar         _varInfo;
        std::vector<string> _inNames;
        string              _script;
        DataMgr *           _dataMgr;
        bool                _coordFlag;
        DC::FileTable       _fileTable;
        DimsType            _dims;
        bool                _meshMatchFlag;
        string              _stdoutString;
 
        int _readRegionAll(int fd, const DimsType &min, const DimsType &max, float *region);
 
        int _readRegionSubset(int fd, const DimsType &min, const DimsType &max, float *region);
    };
 
    class func_c {
    public:
        func_c() {}
        func_c(const string &name, const string &script, const std::vector<string> &inputVarNames, const std::vector<string> &outputVarNames, const std::vector<string> &outputMeshNames,
               const std::vector<DerivedPythonVar *> &derivedVars, bool coordFlag)
        : _name(name), _script(script), _inputVarNames(inputVarNames), _outputVarNames(outputVarNames), _outputMeshNames(outputMeshNames), _derivedVars(derivedVars), _coordFlag(coordFlag)
        {
        }
 
        string                          _name;
        string                          _script;
        std::vector<string>             _inputVarNames;
        std::vector<string>             _outputVarNames;
        std::vector<string>             _outputMeshNames;
        std::vector<DerivedPythonVar *> _derivedVars;
        bool                            _coordFlag;
    };
 
    std::map<string, func_c> _functions;
    std::map<string, string> _functionsStdio;
    DataMgr *                _dataMgr;
    static bool              _isInitialized;
 
    PyEngine() : _dataMgr(NULL) {}
 
    static void _cleanupDict(PyObject *mainDict, vector<string> keynames);
 
    static int _c2python(PyObject *dict, vector<string> inputVarNames, vector<DimsType> inputVarDims, vector<float *> inputVarArrays);
 
    static int _python2c(PyObject *dict, vector<string> outputVarNames, vector<DimsType> outputVarDims, vector<float *> outputVarArrays);
 
    bool _validOutputVar(string name) const;
    int  _checkOutVars(const vector<string> &outputVarNames) const;
    bool _validOutputMesh(string name) const;
    int  _checkOutMeshes(const vector<string> &outputMeshNames) const;
 
    string _getTimeCoordVarName(const vector<string> &varNames) const;
};
};    // namespace VAPoR