ThermalModelRealGas.h

Go to the documentation of this file.

#ifndef THERMALMODELREALGAS_H
#define THERMALMODELREALGAS_H
 
#include "HRGBase/ThermalModelBase.h"
#include "ExcludedVolumeModelsMulti.h"
#include "MeanFieldModelsMulti.h"
 
namespace thermalfist {

    class ThermalModelRealGas : public ThermalModelBase
    {
    public:
        ThermalModelRealGas(ThermalParticleSystem* TPS_, const ThermalModelParameters& params = ThermalModelParameters());

        virtual ~ThermalModelRealGas(void);

        void SetExcludedVolumeModel(ExcludedVolumeModelMultiBase* exvolmod) { m_exvolmod = exvolmod; m_ComponentMapCalculated = false; }

        void SetMeanFieldModel(MeanFieldModelMultiBase* mfmod) { m_mfmod = mfmod; m_ComponentMapCalculated = false; }

        ExcludedVolumeModelMultiBase* ExcludedVolumeModel() const { return m_exvolmod; }

        MeanFieldModelMultiBase* MeanFieldModel() const { return m_mfmod; }
 
        //void SetExcludedVolumeModelCopy(const ExcludedVolumeModelMultiBase& exvolmod) { *m_exvolmod = exvolmod; }
        //void SetMeanFieldModelCopy(const MeanFieldModelMultiBase& mfmod) { *m_mfmod = mfmod; }

        virtual void SetMultipleSolutionsMode(bool search) { m_SearchMultipleSolutions = search; }

        bool UseMultipleSolutionsMode() const { return m_SearchMultipleSolutions; }

        double MuStar(int i) const { return m_MuStar[i]; }

        std::vector<double> GetMuStar() const { return m_MuStar; }

        void SetMuStar(const std::vector<double>& MuStar) { m_MuStar = MuStar; }
 
        // Override functions begin

        void FillChemicalPotentials();

        virtual void SetChemicalPotentials(const std::vector<double>& chem = std::vector<double>(0));

        virtual void CalculatePrimordialDensities();

        virtual std::vector<double> CalculateChargeFluctuations(const std::vector<double>& chgs, int order = 4);

        virtual std::vector<double> CalculateChargeFluctuationsOld(const std::vector<double>& chgs, int order = 4);

        virtual std::vector< std::vector<double> >  CalculateFluctuations(int order);

        void CalculateTwoParticleCorrelations();

        void CalculateFluctuations();

        virtual double CalculatePressure();

        virtual double CalculateEnergyDensity();

        virtual double CalculateEntropyDensity();

    virtual double CalculateEnergyDensityDerivativeT();

    virtual void CalculateTemperatureDerivatives();
 
        // Dummy
        virtual double CalculateBaryonMatterEntropyDensity() { return 0.; }

        virtual double CalculateMesonMatterEntropyDensity() { return 0.; }

        virtual double ParticleScalarDensity(int part);

        bool   IsLastSolutionOK() const { return m_LastBroydenSuccessFlag && m_LastCalculationSuccessFlag; }

        double DensityId(int index) { return m_DensitiesId[index]; }
 
        // Override functions end

        const std::vector< std::vector<int> >& ComponentIndices() const { return m_dMuStarIndices; }

        virtual double DeltaMu(int i) const { return MuShift(i); }

        std::vector< std::vector<double> > m_chi;

        std::vector<double> m_chiarb;
        double ChiArb(int charge);
 
    protected:

        void CalculateComponentsMap();

        virtual std::vector<double> SearchSingleSolution(const std::vector<double>& muStarInit);

        virtual std::vector<double> SearchSingleSolutionUsingComponents(const std::vector<double>& muStarInit);

        virtual std::vector<double> SearchSingleSolutionDirect(const std::vector<double>& muStarInit);

        std::vector<double> SearchMultipleSolutions(int iters = 300);

        void SolveEquations();

        virtual double MuShift(int id) const;

        std::vector<double> m_DensitiesId;

        std::vector<double> m_scaldens;

        bool   m_SearchMultipleSolutions;

        bool   m_LastBroydenSuccessFlag;

        bool   m_ComponentMapCalculated;

        std::vector<double> m_MuStar;

        std::vector<int> m_MapTodMuStar;

        std::vector<int> m_MapFromdMuStar;

        std::vector< std::vector<int> > m_dMuStarIndices;
 

        ExcludedVolumeModelMultiBase* m_exvolmod;

        MeanFieldModelMultiBase* m_mfmod;

        ExcludedVolumeModelMultiBase* m_exvolmodideal;

        MeanFieldModelMultiBase* m_mfmodideal;
    private:
        class BroydenEquationsRealGas : public BroydenEquations
        {
        public:
            BroydenEquationsRealGas(ThermalModelRealGas* model) : BroydenEquations(), m_THM(model) { m_N = model->ComponentsNumber(); }

            std::vector<double> Equations(const std::vector<double>& x);
        private:
            ThermalModelRealGas* m_THM;
        };

        class BroydenJacobianRealGas : public BroydenJacobian
        {
        public:
            BroydenJacobianRealGas(ThermalModelRealGas* model) : BroydenJacobian(), m_THM(model) { }

            std::vector<double> Jacobian(const std::vector<double>& x);
        private:
            ThermalModelRealGas* m_THM;
        };

        class BroydenSolutionCriteriumRealGas : public Broyden::BroydenSolutionCriterium
        {
        public:
            BroydenSolutionCriteriumRealGas(ThermalModelRealGas* model, double relative_error = Broyden::TOL) : Broyden::BroydenSolutionCriterium(relative_error), m_THM(model) { }

            virtual bool IsSolved(const std::vector<double>& x, const std::vector<double>& f, const std::vector<double>& xdelta = std::vector<double>()) const;
        protected:
            ThermalModelRealGas* m_THM;
        };

        class BroydenEquationsRealGasComponents : public BroydenEquations
        {
        public:
            BroydenEquationsRealGasComponents(ThermalModelRealGas* model) : BroydenEquations(), m_THM(model) { m_N = model->m_MapFromdMuStar.size(); }

            std::vector<double> Equations(const std::vector<double>& x);
        private:
            ThermalModelRealGas* m_THM;
        };

        class BroydenJacobianRealGasComponents : public BroydenJacobian
        {
        public:
            BroydenJacobianRealGasComponents(ThermalModelRealGas* model) : BroydenJacobian(), m_THM(model) { }

            std::vector<double> Jacobian(const std::vector<double>& x);
        private:
            ThermalModelRealGas* m_THM;
        };
 
    };
 
} // namespace thermalfist
 
#endif