datastruct.h

Go to the documentation of this file.

#ifndef PARFIS_DATASTRUCT_H
#define PARFIS_DATASTRUCT_H
 
#include <iostream>
#include <string>
#include <map>
#include <unordered_map>
#include <list>
#include <vector>
#include <math.h>
#include <functional>
#include <memory>
#include <random>
 
#if defined(PARFIS_LOG_LEVEL)
#define LOG_LEVEL PARFIS_LOG_LEVEL
#else
#define LOG_LEVEL 0
#endif
 
#if LOG_LEVEL > 0
#define LOG(logger, level, msg) {Logger::log(logger, level, msg);}
#else
#define LOG(logger, level, msg) {}
#endif // LOG_LEVEL
 
#if defined(STATE_TYPE_DOUBLE)
#define STATE_TYPE double
#else
#define STATE_TYPE float
#endif
 
namespace parfis {
 
    typedef STATE_TYPE state_t;
    typedef uint32_t cellId_t;
    typedef uint32_t stateId_t;
    typedef uint16_t cellPos_t;
    typedef uint8_t nodeFlag_t;
    typedef uint8_t stateFlag_t;
    typedef std::mt19937_64 randEngine_t;
 
    struct StateFlag {
        constexpr static stateFlag_t None = 0;
        constexpr static stateFlag_t PushedState = 1;
    };
 
    struct NodeFlag {
        constexpr static nodeFlag_t InsideGeo = 0b11111111;
        constexpr static nodeFlag_t NegZBound = 0b11110000;
        constexpr static nodeFlag_t PosZBound = 0b00001111;
    };
 
    enum struct LogMask: uint32_t {
        None = 0b0,
        Error = 0b1,
        Warning = 0b10,
        Memory = 0b100,
        Info = 0b1000
    };
 
    struct Logger
    {
        Logger(): m_fname(""), m_str(""){};
 
        std::string m_str;
        std::string m_fname;
 
        void initialize(const std::string& fname);
        void logToStr(LogMask mask, const std::string& msg);
        void printLogFile();
        static std::string getLogFileName(uint32_t id, uint32_t cnt);
        static void log(Logger& logger, LogMask mask, const std::string& msg) {
            if (LOG_LEVEL > 0) {
                if(uint32_t(mask) & LOG_LEVEL) logger.logToStr(mask, msg);
            }
        }
    };
    template <class T>
    struct Vec3D
    {
        T x;
        T y;
        T z;
 
        friend bool operator==(const Vec3D<T>& lhs, const Vec3D<T>& rhs) {
            return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
        }
 
        friend bool operator!=(const Vec3D<T>& lhs, const Vec3D<T>& rhs) {
            return (lhs.x != rhs.x || lhs.y != rhs.y || lhs.z != rhs.z);
        }
 
        friend std::ostream& operator<<(std::ostream& os, const Vec3D<T>& vec) {
            os << '[' << vec.x << ", " << vec.y << ", " << vec.z << ']';
            return os;
        }
 
        T len() const { return sqrt(x * x + y * y + z * z); }
 
        T lenSq() const { return x * x + y * y + z * z; }
    };
 
        struct PyVecContainer
    {
        static std::vector<const char *> pyStrVec;
    };
 
    template <class T>
    struct PyVec 
    {
        const T* ptr;
        size_t size;
 
        PyVec<T>& operator=(const std::vector<T>& tVec) {
            size = tVec.size();
            if (size > 0)
                ptr = &tVec[0];
            return *this;
        }
    };
 
    template<>
    struct PyVec<std::string>
    {   
        const char ** ptr;
        size_t size;
 
        PyVec<std::string>& operator=(const std::vector<std::string>& strVec) {
            bool init = true;
            for (auto & str: strVec) {
                PyVecContainer::pyStrVec.push_back(str.c_str());
                if (init) {
                    ptr = &PyVecContainer::pyStrVec.back();
                    size = strVec.size();
                    init = false;
                }
            }
            return *this;
        }
    };
 
    inline double xyDistSq(Vec3D<double>& a, Vec3D<double>& b) {
        return (a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y);
    };
 
    struct Cell
    {
        Vec3D<cellPos_t> pos;
    };
 
    struct State
    {   
        stateId_t next;
        stateId_t prev;
        Vec3D<state_t> pos;
        Vec3D<state_t> vel;
    };
 
    struct Specie
    {
        uint32_t id;
        const char * name;
        int velInitDist;
        int statesPerCell;
        int timestepRatio;
        double dt;
        double idt;
        double maxVel;
        double maxEv;
        Vec3D<double> velInitDistMin;
        Vec3D<double> velInitDistMax;
        double qm;
        double amuMass;
        double mass;
        int eCharge;
        double charge;
        uint32_t stateCount;
        size_t headIdOffset;
        Vec3D<double> dvUniformE;
        int randomSeed;
        std::vector<uint32_t> gasCollisionVecId;
        uint32_t gasCollisionProbId;
    };
 
    struct Gas
    {
        uint32_t id;
        const char* name;
        double amuMass;
        double volumeFraction;
        double temperature;
        double molDensity;
    };
 
    struct FuncTable
    {
        int type;
        int colCnt;
        int rowCnt;
        std::vector<double> ranges;
        std::vector<int> nbins;
        std::vector<double> idx;
        std::vector<double> xVec;
        std::vector<double> yVec;
        std::function<double(double)> eval;
        int loadData(const std::string& fileName);
    };
 
    struct PyFuncTable
    {
        int type;
        int colCnt;
        int rowCnt;
        PyVec<double> ranges;
        PyVec<int> nbins;
        PyVec<double> idx;
        PyVec<double> xVec;
        PyVec<double> yVec;
        PyFuncTable& operator=(const FuncTable& ftab) {
            type = ftab.type;
            rowCnt = ftab.rowCnt;
            colCnt = ftab.colCnt;
            ranges = ftab.ranges;
            nbins = ftab.nbins;
            idx = ftab.idx;
            xVec = ftab.xVec;
            yVec = ftab.yVec;
            return *this;
        }
    };
 
    struct GasCollision
    {
        uint32_t id;
        const char* name;
        const char* fileName;
        uint32_t specieId;
        uint32_t gasId;
        double threshold;
        int type;
        std::vector<double> scatterAngle;
        FuncTable xSecFtab;
        FuncTable freqFtab;
        int calculateColFreq(const Specie & specie, const Gas& gas);
    };
 
    struct PyGasCollision
    {
        uint32_t id;
        const char* name;
        const char* fileName;
        uint32_t specieId;
        uint32_t gasId;
        double threshold;
        int type;
        PyVec<double> scatterAngle;
        PyFuncTable xSecFtab;
        PyFuncTable freqFtab;
        PyGasCollision& operator=(const GasCollision& gasCol) {
            id = gasCol.id;
            name = gasCol.name;
            fileName = gasCol.fileName;
            specieId = gasCol.specieId;
            gasId = gasCol.gasId;
            threshold = gasCol.threshold;
            type = gasCol.type;
            scatterAngle = gasCol.scatterAngle;
            xSecFtab = gasCol.xSecFtab;
            freqFtab = gasCol.freqFtab;
            return *this;
        }
    };
 
 
    struct Field
    {
        Vec3D<int> typeE;
        Vec3D<int> typeB;
        Vec3D<double> strengthE;
        Vec3D<double> strengthB;
    };
 
    struct PyCfgData
    {
        int geometry;
        double timestep;
        Vec3D<double>* geometrySize;
        Vec3D<double>* cellSize;
        Vec3D<int>* periodicBoundary;
        Vec3D<int>* cellCount;
        PyVec<std::string> specieNameVec;
        PyVec<std::string> gasNameVec;
        PyVec<std::string> gasCollisionNameVec;
        PyVec<std::string> gasCollisionFileNameVec;
    };
 
    struct CfgData {
        int geometry;
        double timestep;
        Vec3D<double> geometrySize;
        Vec3D<double> cellSize;
        Vec3D<int> periodicBoundary;
        Vec3D<int> cellCount;
        std::vector<std::string> specieNameVec;
        std::vector<std::string> gasNameVec;
        std::vector<std::string> gasCollisionNameVec;
        std::vector<std::string> gasCollisionFileNameVec;
        PyCfgData pyCfgData;
        inline cellId_t getAbsoluteCellId(Vec3D<cellPos_t>& cellPos) {
            return cellCount.z * (cellCount.y * cellPos.x + cellPos.y ) + cellPos.z;
        };
        int setPyCfgData();
    };
 
    struct PySimData
    {
        PyVec<State> stateVec;
        PyVec<cellId_t> cellIdVec;
        PyVec<cellId_t> cellIdAVec;
        PyVec<cellId_t> cellIdBVec;
        PyVec<Specie> specieVec;
        PyVec<Cell> cellVec;
        PyVec<nodeFlag_t> nodeFlagVec;
        PyVec<stateId_t> headIdVec;
        PyVec<Gas> gasVec;
        PyVec<PyGasCollision> pyGasCollisionVec;
        PyVec<PyFuncTable> pyGasCollisionProbVec;
    };
 
    struct SimData {
        std::vector<Cell> cellVec;
        std::vector<nodeFlag_t> nodeFlagVec;
        std::vector<cellId_t> cellIdVec;
        std::vector<cellId_t> cellIdAVec;
        std::vector<cellId_t> cellIdBVec;
        std::vector<State> stateVec;
        std::vector<stateFlag_t> stateFlagVec;
        std::vector<stateId_t> headIdVec;
        std::vector<Specie> specieVec;
        std::vector<Gas> gasVec;
        std::vector<randEngine_t> randomEngineVec;
        std::vector<GasCollision> gasCollisionVec;
        std::vector<PyGasCollision> pyGasCollisionVec;
        std::vector<FuncTable> gasCollisionProbVec;
        std::vector<PyFuncTable> pyGasCollisionProbVec;
        Field field;
        PySimData pySimData;
        uint64_t evolveCnt;
        int setPySimData();
        int calculateColProb(const CfgData * pCfgData);
    };
    struct Command
    {
        Command(std::string name = "") :
            m_name(name), m_funcName(""), m_func(nullptr), m_pNext(nullptr) {}
 
        std::string m_name;
 
        std::string m_funcName;
 
        std::function<int()> m_func;
 
        Command* m_pNext;
 
        void setNext(Command& comRef) { m_pNext = &comRef; }
 
        Command* getNext() { return m_pNext; };
    };
 
    struct CommandChain : public Command
    {
        std::map<std::string, std::unique_ptr<Command>> m_cmdMap;
    };
 
    struct ParamBase
    {
        std::string m_name;
        std::string m_type;
        size_t m_size;
        ParamBase* m_parent;
        std::string getValueString(bool printType=false);
        std::map<std::string, std::unique_ptr<ParamBase>> m_childMap;
        template<class S>
        void addChild(const std::string& name);
        static void setValueVec(ParamBase* ppb, const std::string& valstr);
    };
 
    template<class T>
    struct Param : public ParamBase
    {
        Param();
        std::vector<T> m_valueVec;
        void setValueVec(const std::string& valstr);
    };
 
    template<>
    inline Param<double>::Param() { m_type = "double"; }
    
    template<>
    inline Param<int>::Param() { m_type = "int"; }
 
    template<>
    inline Param<std::string>::Param() { m_type = "std::string"; }
 
 
    struct Domain: public Param<std::string> {
        Domain() = default;
        Domain(const std::string& dname, Logger& logger, CfgData& cfgData, SimData& simData, 
                std::map<std::string, std::unique_ptr<CommandChain>>& cmdChainMap) 
            : m_pLogger(&logger), m_pCfgData(&cfgData), m_pSimData(&simData), 
            m_pCmdChainMap(&cmdChainMap) { m_name = dname; };
        Domain(const Domain&) = default;
        Domain& operator=(const Domain&) = default;
        virtual ~Domain() = default;
 
        parfis::Param<std::string>* getParent(const std::string& cstr);
        int initialize(const std::string& cstr);
        int configure(const std::string& cstr);
        virtual int loadCfgData() = 0;
        virtual int loadSimData() = 0;
 
        static std::unique_ptr<Domain> generateDomain(const std::string& dname, Logger& logger, 
            CfgData& cfgData, SimData& simData, 
            std::map<std::string, std::unique_ptr<CommandChain>>& cmdChainMap);
 
        template<class T>
        int getParamToValue(const std::string& key, T& valRef);
 
        template<class T>
        void getParamToVector(const std::string& key, std::vector<T>& vecRef);
 
        Logger* m_pLogger;
        CfgData* m_pCfgData;
        SimData* m_pSimData;
        std::map<std::string, std::unique_ptr<CommandChain>>* m_pCmdChainMap;
    };
}
 
#endif // PARFIS_DATASTRUCT_H