wmvariableparser.h

Go to the documentation of this file.

 
#ifndef __wmvariableparser__h__
#define __wmvariableparser__h__
 
// STL Libraries
#include <iostream>
#include <vector>
#include <map>
 
// WarpX/M Libraries
#include "lib/wxexcept.h"
#include "solver/wmsolverbase.h"
#include "lib/wxany.h"
#include "variables/wmunstructuredarray.h"
#include "wmudgfunctions.h"
 
int _factorial(int n);
 
// These are typecheck bit flags
 
enum
{
    // Unknown
    WMKERNELVARIABLE_NONE = 1 << 1, // Unknown
 
    // Never allocated
    WMKERNELVARIABLE_CONSTANT =
        1 << 2, // Constant in space and time - directly written into kernel
 
    // Allocated on its own or within structure/array
    //    WMKERNELVARIABLE_WMSCALAR         = 1 << 3,       // Constant in space - linked to
    //    WmScalar
    //    WMKERNELVARIABLE_WMARRAY        = 1 << 4,       // Constant in space - linked to
    //    WmArray
    //    WMKERNELVARIABLE_WMDARRAY         = 1 << 5,       // linked to distributed array
    WMKERNELVARIABLE_WMUARRAY = 1 << 6, // linked to unstructured array
    WMKERNELVARIABLE_OCLMEM = 1 << 7,   // linked to OpenCL Memory object: cl_mem
    WMKERNELVARIABLE_ANY = 1 << 8, // Constant in space - linked to WxAny (by pointer)
 
    // Structure of allocations
    WMKERNELVARIABLE_STRUCTURE = 1 << 9,
 
    // Tensor allocation - all of same type - don't try to interface with it outside of
    // the kernel - not initialized
    WMKERNELVARIABLE_TENSOR = 1 << 10,
    WMKERNELVARIABLE_VALUE =
        1 << 11, // used to link variable to function call or complex initialization
 
    // Array allocation - rank 1 tensor, can be filled with structures/allocations of the
    // same type
    WMKERNELVARIABLE_ARRAY = 1 << 12
 
};
 
struct variableType_t
{
    std::string _variableName;
    int _componentIndex;
    int _kernelVariableType;
    std::string _typeString;
 
    // just in case this is actually a constant
    WxAny _value;
};
 
class WmSolverBase;
 
typedef std::vector<variableType_t> variableTypeList_t;
 
class WmVariableParser
{
public:
    typedef std::map<std::string, std::string> constantsMap_t;
 
    class component_t
    {
    public:
        // Variable
        wxm::variable::variable_t* _variable;
 
        // Variable name
        std::string _variableName;
 
        // ComponentIndex;
        int _componentIndex;
    };
 
    typedef std::vector<component_t> componentList_t;
 
    WmVariableParser();
 
    virtual ~WmVariableParser();
 
    void setParentSolver(const WmSolverBase* solver)
    {
        _parentSolver = solver;
    }
 
    componentList_t parseVariablesFromCryptset(const WxCryptSet& wxe,
                                               const std::string& fieldName);
 
protected:
    // Protected Functions
 
    variableTypeList_t decomposeVariableName(const WxAny& varName) const;
 
    bool hasVariable(const WxCryptSet& wxc, const std::string& varName) const;
    bool hasVariableVector(const WxCryptSet& wxc, const std::string& varName) const;
 
    static std::string itos(int value);
    static std::string getAnyString(const WxAny& any);
    static std::string getTypeString(const std::type_info& type);
    static size_t getTypeSize(const std::type_info& typeinfo);
 
    // Parsing function
    componentList_t parseVariableNameIntoComponents(const std::string& fullVarName);
 
    // Protected Variables
 
    const WmSolverBase* _parentSolver;
    WxLogStream _debStrm;
 
private:
};
 
#endif