wmunstructuredapp.h

Go to the documentation of this file.

#ifndef __wmunstructuredapp__h__
#define __wmunstructuredapp__h__
 
// STD libraries
#include <iostream>
#include <vector>
 
// WarpX includes
#include "lib/wxcryptset.h"
 
// WarpM includes
#include "lib/wmvariableparser.h"
#include "lib/wmunstructuredequationset.h"
 
// Used for generating strings from cl code snippits
#define STRINGIFY_CL_CODE(src) ("\n" + std::string(#src) + "\n")
 
// These are placement identifiers
enum
{
    WMCALLTYPE_INVALID = 1 << 0,
    WMCALLTYPE_PRIVATE = 1 << 1,
    WMCALLTYPE_FLUX = 1 << 2,
    WMCALLTYPE_SOURCE = 1 << 3,
    WMCALLTYPE_EXTERNAL = 1 << 4
};
 
class WmVariableParser;
 
class WmUnstructuredApp : public WmVariableParser
{
public:
    WmUnstructuredApp();
 
    virtual ~WmUnstructuredApp();
 
    virtual void setup(const WxCryptSet& wxc);
 
    // This generates the string for the function call
    virtual std::string generateSourceCall(const WmUnstructuredEquationSet& eqSet,
                                           unsigned int callType) const = 0;
 
    // This generates the source code for the entire app
    virtual std::string generateSource(const WmUnstructuredEquationSet& eqSet) const = 0;
 
    // Used to grab variables required by app
    virtual void consolidateVariables(variableList_t& varList, unsigned int callType);
 
    typedef std::map<std::string, std::string> replaceMap_t;
    static void replaceKeys(std::string& string, const replaceMap_t& map);
 
protected:
    std::string
    fillAllocationAtIndex(const std::string& indentation,
                          const WmKernelVariable* kVars[],
                          int numKVars,
                          int startIndex = 0,
                          const std::string& allocationName = "pPVS->rA") const;
 
    template<typename T> T readVal(const WxCryptSet& wxc, const std::string& name) const
    {
        return wxc.get<T>(name);
    }
 
    template<typename T>
    std::vector<T> readVec(const WxCryptSet& wxc, const std::string& name) const
    {
        return wxc.getVec<T>(name);
    }
 
    template<typename T>
    T readVal(const WxCryptSet& wxc, const std::string& name, const T& defaultValue) const
    {
        if (wxc.has(name))
        {
            return wxc.get<T>(name);
        }
        else
        {
            return defaultValue;
        }
    }
 
    static void indent(std::string& indentation)
    {
        indentation += "\t";
    }
 
    static void outdent(std::string& indentation)
    {
        unsigned found = indentation.find_last_of("\t");
        indentation = indentation.substr(0, found);
    }
 
    template<typename T> static std::string toStr(const T& val)
    {
        std::stringstream ss;
        ss << val;
        return ss.str();
    }
 
    // variables required by flux apps
    variableList_t _fluxVariables;
 
    // variables required by source apps
    variableList_t _sourceVariables;
 
    // variables required by external apps
    variableList_t _externalVariables;
 
    // Allocations required by all apps (private variable set)
    variableList_t _privateVariables;
 
private:
    WmUnstructuredApp& operator=(const WmUnstructuredApp& var);
    WmUnstructuredApp(const WmUnstructuredApp& var);
};
 
#endif // __wmunstructuredapp__h__