Variable.h

Go to the documentation of this file.

/*
 *  This file is part of AQUAgpusph, a free CFD program based on SPH.
 *  Copyright (C) 2012  Jose Luis Cercos Pita <jl.cercos@upm.es>
 *
 *  AQUAgpusph is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AQUAgpusph is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AQUAgpusph.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef VARIABLE_H_INCLUDED
#define VARIABLE_H_INCLUDED
 
#include <Python.h>
#include <string>
#include <vector>
#include <sphPrerequisites.h>
#include <Tokenizer/Tokenizer.h>
 
#ifdef HAVE_3D
#define VecVariable Vec4Variable
#define IVecVariable IVec4Variable
#define UIVecVariable UIVec4Variable
#else
#define VecVariable Vec2Variable
#define IVecVariable IVec2Variable
#define UIVecVariable UIVec2Variable
#endif
 
namespace Aqua {
namespace InputOutput {
 
class Variable
{
  public:
        Variable(const std::string varname, const std::string vartype);
 
        virtual ~Variable(){};
 
        virtual bool isArray() = 0;
 
        virtual bool isScalar() { return !isArray(); }
 
        std::string name() const { return _name; }
 
        virtual std::string type() const { return _typename; }
 
        virtual size_t typesize() const { return 0; }
 
        virtual size_t size() const { return typesize(); }
 
        virtual void* get() { return NULL; }
 
        virtual void set(void* ptr) = 0;
 
        virtual PyObject* getPythonObject(int i0 = 0, int n = 0) { return NULL; }
 
        virtual bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0)
        {
                return true;
        }
 
        virtual const std::string asString() { return ""; }
 
        void setEvent(cl_event event);
 
        cl_event getEvent() { return _event; }
 
  protected:
        void sync();
 
  private:
        std::string _name;
 
        std::string _typename;
 
        cl_event _event;
 
        bool _synced;
};
 
template<class T>
class ScalarVariable : public Variable
{
  public:
        ScalarVariable(const std::string varname, const std::string vartype);
 
        ~ScalarVariable(){};
 
        bool isArray();
 
        size_t typesize() const { return sizeof(T); }
 
        inline void* get()
        {
                sync();
                return &_value;
        }
 
        inline void* get_async() { return &_value; }
 
        inline void set(void* ptr)
        {
                sync();
                memcpy(&_value, ptr, sizeof(T));
        }
 
        inline void set_async(void* ptr) { memcpy(&_value, ptr, sizeof(T)); }
 
        virtual const std::string asString() = 0;
 
  protected:
        T _value;
};
 
template<class T>
class ScalarNumberVariable : public ScalarVariable<T>
{
  public:
        ScalarNumberVariable(const std::string varname, const std::string vartype);
 
        ~ScalarNumberVariable(){};
 
        virtual const std::string asString();
};
 
class IntVariable : public ScalarNumberVariable<int>
{
  public:
        IntVariable(const std::string varname);
 
        ~IntVariable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class UIntVariable : public ScalarNumberVariable<unsigned int>
{
  public:
        UIntVariable(const std::string varname);
 
        ~UIntVariable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class FloatVariable : public ScalarNumberVariable<float>
{
  public:
        FloatVariable(const std::string varname);
 
        ~FloatVariable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
template<class T>
class ScalarVecVariable : public ScalarVariable<T>
{
  public:
        ScalarVecVariable(const std::string varname,
                          const std::string vartype,
                          const unsigned int dims);
 
        ~ScalarVecVariable(){};
 
        virtual const std::string asString();
 
  protected:
        bool checkPyhonObjectDims(PyObject* obj);
 
  private:
        unsigned int _dims;
};
 
class Vec2Variable : public ScalarVecVariable<vec2>
{
  public:
        Vec2Variable(const std::string varname);
 
        ~Vec2Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class Vec3Variable : public ScalarVecVariable<vec3>
{
  public:
        Vec3Variable(const std::string varname);
 
        ~Vec3Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class Vec4Variable : public ScalarVecVariable<vec4>
{
  public:
        Vec4Variable(const std::string varname);
 
        ~Vec4Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class IVec2Variable : public ScalarVecVariable<ivec2>
{
  public:
        IVec2Variable(const std::string varname);
 
        ~IVec2Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class IVec3Variable : public ScalarVecVariable<ivec3>
{
  public:
        IVec3Variable(const std::string varname);
 
        ~IVec3Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class IVec4Variable : public ScalarVecVariable<ivec4>
{
  public:
        IVec4Variable(const std::string varname);
 
        ~IVec4Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class UIVec2Variable : public ScalarVecVariable<uivec2>
{
  public:
        UIVec2Variable(const std::string varname);
 
        ~UIVec2Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class UIVec3Variable : public ScalarVecVariable<uivec3>
{
  public:
        UIVec3Variable(const std::string varname);
 
        ~UIVec3Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class UIVec4Variable : public ScalarVecVariable<uivec4>
{
  public:
        UIVec4Variable(const std::string varname);
 
        ~UIVec4Variable(){};
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};
 
class ArrayVariable : public Variable
{
  public:
        ArrayVariable(const std::string varname, const std::string vartype);
 
        ~ArrayVariable();
 
        bool isArray();
 
        size_t typesize() const { return sizeof(cl_mem); }
 
        size_t size() const;
 
        void* get() { return &_value; }
 
        void set(void* ptr) { _value = *(cl_mem*)ptr; }
 
        PyObject* getPythonObject(int i0 = 0, int n = 0);
 
        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
 
        const std::string asString();
 
        const std::string asString(size_t i);
 
  private:
        void cleanMem();
 
        cl_mem _value;
        std::vector<void*> _data;
        std::vector<PyObject*> _objects;
};
 
// ---------------------------------------------------------------------------
// Variables manager
// ---------------------------------------------------------------------------
 
class Variables
{
  public:
        Variables();
 
        ~Variables();
 
        void registerVariable(const std::string name,
                              const std::string type,
                              const std::string length,
                              const std::string value);
 
        Variable* get(unsigned int index);
 
        Variable* get(const std::string name);
 
        std::vector<Variable*> getAll() { return _vars; }
 
        unsigned int size() const { return _vars.size(); }
 
        size_t allocatedMemory();
 
        static size_t typeToBytes(const std::string type);
 
        static unsigned int typeToN(const std::string type);
 
        bool isSameType(const std::string type_a,
                        const std::string type_b,
                        bool ignore_asterisk = true);
 
        void solve(const std::string type_name,
                   const std::string value,
                   void* data,
                   const std::string name = "NULL");
 
        void populate(const std::string name = "");
 
        void populate(Variable* var);
 
  private:
        void registerScalar(const std::string name,
                            const std::string type,
                            const std::string value);
        void registerClMem(const std::string name,
                           const std::string type,
                           const std::string length);
 
        void readComponents(const std::string name,
                            const std::string value,
                            unsigned int n,
                            float* v);
 
        std::vector<Variable*> _vars;
        Tokenizer tok;
};
 
}
} // namespace
 
#endif // VARIABLE_H_INCLUDED