InfoStruct.h

#ifndef __INFOSTRUCT_INFOSTRUCT_H__
#define __INFOSTRUCT_INFOSTRUCT_H__

#include "../Constants/AtomicProperties.h"
#include "../Constants/Constants.h"
#include "rapidjson/document.h"
#include "rapidjson/filestream.h"
#include "rapidjson/prettywriter.h"
#include <qdir>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

namespace MDSimulation
{
    enum DriverMode
    {
        /* Sinusoidal driver. */
        Sinusoidal,
        /* Constant is a constant pressure function. */
        Constant
    };

    class InfoStruct
    {
    public:

        // Convenient synonym for the number of elements.
        static const int ET = Constants::ELEMENT_TYPES;

        std::vector<double> AtomicParts;

        // The cone angle is half the apex angle of the cone.
        double ConeAngle;
        double ConeTan2;
        double ConeSolidAngle;
        double Density;
        double Frequency;
        double DriverPressure;
        double AmbientPressure;
        double AmbientRadius;
        double AdiabaticRadius;
        double InitialRadius;
        double IsothermalRadius;
        double Temperature;
        double InitialTime;
        double InitialVelocity;
        double WallTemperature;
        double EquilibriumPressure;

        int LiquidType;
        double LiquidDensity;
        double LiquidSpeedOfSound;
        double LiquidViscosity;
        double LiquidSurfaceTension;

        double FusionBarrier;

        double AtomicDiameter[ET];
        double AtomicDiameterSquared[ET][ET];

        double AtomicMass[ET];
        double ReducedMass[ET][ET];

        double VWallThermal[ET];

        double BirdConstant[ET];

        DriverMode Driver;

        double CollisionThreshold;

        InfoStruct();

        InfoStruct ToSimulationUnits() const;

        static InfoStruct ParseInfoStruct(const std::string& fname);

        static InfoStruct DefaultInfoStruct();

        friend std::ostream& operator<<(std::ostream& stream, const InfoStruct& matrix);

        void Read(const rapidjson::Value& reader);

        bool operator==(const InfoStruct& rhs);

        template <typename Writer>
        void Serialize(Writer& writer) const;

    private:

        void InitTables();

        void CopyConstants();
    };

    template <typename Writer>
    void InfoStruct::Serialize(Writer& writer) const
    {
    
        const char* liquidName = Constants::LIQUID_NAMES[LiquidType].c_str();

        writer.StartObject();

        writer.String("Environment");
        writer.StartObject();

        // Write all of the other values.
        writer.String("ConeAngle")           , writer.Double(ConeAngle);
        writer.String("Temperature")         , writer.Double(Temperature);
        writer.String("WallTemp")            , writer.Double(WallTemperature);
        writer.String("AmbientRadius")       , writer.Double(AmbientRadius);
        writer.String("DriverPressure")      , writer.Double(DriverPressure);
        writer.String("Frequency")           , writer.Double(Frequency);
        writer.String("InitialTime")  , writer.Double(InitialTime);
        writer.String("InitialRadius")       , writer.Double(InitialRadius);
        writer.String("InitialVelocity")     , writer.Double(InitialVelocity);
        writer.String("EquilibriumPressure") , writer.Double(EquilibriumPressure);
        writer.String("AmbientPressure")     , writer.Double(AmbientPressure);  
        writer.String("AdiabaticRadius")     , writer.Double(AdiabaticRadius);
        writer.String("IsothermalRadius")    , writer.Double(IsothermalRadius);
        if( Driver == Constant ){
            writer.String("DriverMode")      , writer.String("constant");
        } else {
            writer.String("DriverMode")      , writer.String("sinusoidal");
        }
        writer.String("Liquid")              , writer.String(liquidName);
        writer.EndObject();
        // Write the atomic parts array.
        writer.String("Particles");
        writer.StartObject();
        writer.String("AtomicParts");
        writer.StartObject();
            int i = 0;
            double val = 0;
            const char *elemName;
            for(i = 0; i < AtomicParts.size(); i++){
                val = AtomicParts.at(i);
                elemName = Constants::ELEMENT_NAMES[i].c_str();
                if(val != 0){
                    writer.String(elemName), writer.Double(val);
                }
            }
        writer.EndObject();
        writer.EndObject();
        writer.EndObject();
    }
}

#endif /* __INFO_STRUCT_H__ */