EffectiveMassModel.h

Go to the documentation of this file.

#ifndef EFFECTIVEMASSMODEL_H
#define EFFECTIVEMASSMODEL_H
#include <map>
 
#include "HRGBase/ThermalModelBase.h"
#include "HRGBase/Broyden.h"
 
namespace thermalfist {


    class EMMFieldPressure {
    protected:
      double m_mass;
      double m_c;
    public:
      EMMFieldPressure(double mass = 0.135, double c = 0)
        : m_mass(mass),
          m_c(c) {}

      virtual ~EMMFieldPressure() {}

      virtual EMMFieldPressure *clone() const { return new EMMFieldPressure(*this); }

      virtual double pf(double x) const { return (m_mass - x) * (m_mass - x) / 2. / m_c; }

      virtual double Dpf(double x) const { return -(m_mass - x) / m_c; }

      virtual double D2pf(double x) const { return 1. / m_c; }
    };

    class EMMFieldPressureChPT : public EMMFieldPressure {
    protected:
      double m_fpi;
    public:
      EMMFieldPressureChPT(double mass = 0.135, double fpi = 0.133) : EMMFieldPressure(mass), m_fpi(fpi) {}

      virtual ~EMMFieldPressureChPT() {}

      virtual EMMFieldPressure *clone() const { return new EMMFieldPressureChPT(*this); }

      virtual double pf(double x) const {
        return x * x * m_fpi * m_fpi / 4. * (1 - m_mass * m_mass / x / x) * (1 - m_mass * m_mass / x / x) *
               pow(xMath::GeVtoifm(), 3);
      }

      virtual double Dpf(double x) const {
        return x * m_fpi * m_fpi / 2. * (1 - pow(m_mass / x, 4)) * pow(xMath::GeVtoifm(), 3);
      }

      virtual double D2pf(double x) const {
        return m_fpi * m_fpi / 2. * (1. + 3. * pow(m_mass / x, 4)) * pow(xMath::GeVtoifm(), 3);
      }
    };

    class EffectiveMassModel : public GeneralizedDensity {
      ThermalParticle m_Particle;
      EMMFieldPressure *m_FieldPressure;
 
      double m_T, m_Mu;
      bool m_isSolved;
      bool m_isBEC;
 
      double m_TBEC;
 
      double m_Meff;
      double m_Pressure;
      double m_Density;
      double m_DensityScalar;
      double m_EntropyDensity;
      double m_Chi2;
    public:
      EffectiveMassModel(
          const ThermalParticle &particle = ThermalParticle(true, "pi", 211, 1.0, -1, 0.135, 0, 0, 1),
          EMMFieldPressure *FieldPressure = NULL);

      virtual ~EffectiveMassModel(void);

      EffectiveMassModel(const EffectiveMassModel &other);

      bool IsSolved() const { return m_isSolved; }

      virtual bool IsBECPhase() const { return m_isBEC; }

      double ComputeTBEC(double Mu, double TBECinit = -1.) const;

      void SetParameters(double T, double Mu);

      double Temperature() const { return m_T; }

      double ChemicalPotential() const { return m_Mu; }

      void SolveMeff(double meffinit = -1.);

      void SetMeff(double meff) { m_Meff = meff; }

      double Meff() const { return m_Meff; }

      double Pressure() const;

      double Density() const;

      double EntropyDensity() const;

      double EnergyDensity() const;

      virtual double Quantity(IdealGasFunctions::Quantity quantity, double T, double mu);

      virtual double EffectiveMass() const { return Meff(); }

      virtual double BECFraction() const;

      class BroydenEquationsEMMTBEC : public BroydenEquations {
      public:
        BroydenEquationsEMMTBEC(const EffectiveMassModel *model, double MuBEC)
                : BroydenEquations(), m_EMM(model), m_MuBEC(MuBEC) { m_N = 1; }

        std::vector<double> Equations(const std::vector<double> &x);
 
      private:
        const EffectiveMassModel *m_EMM;
        double m_MuBEC;
      };

      class BroydenEquationsEMMMeff : public BroydenEquations {
      public:
        BroydenEquationsEMMMeff(const EffectiveMassModel *model) : BroydenEquations(), m_EMM(model) { m_N = 1; }

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

      class BroydenEquationsEMMMeffConstrained : public BroydenEquations {
      public:
        BroydenEquationsEMMMeffConstrained(const EffectiveMassModel *model)
                : BroydenEquations(), m_EMM(model) { m_N = 1; }

        std::vector<double> Equations(const std::vector<double> &x);
 
      private:
        const EffectiveMassModel *m_EMM;
      };
 
    };
 
} // namespace thermalfist
 
#endif