ThermalModelCanonical.h

Go to the documentation of this file.

/*
 * Thermal-FIST package
 * 
 * Copyright (c) 2015-2019 Volodymyr Vovchenko
 *
 * GNU General Public License (GPLv3 or later)
 */
#ifndef THERMALMODELCANONICAL_H
#define THERMALMODELCANONICAL_H
 
#include <map>
 
 
#include "HRGBase/ThermalModelIdeal.h"
 
namespace thermalfist {

  struct QuantumNumbers
  {
    int B; 
    int Q; 
    int S; 
    int C; 

    QuantumNumbers(int iB = 0, int iQ = 0, int iS = 0, int iC = 0) :
      B(iB), Q(iQ), S(iS), C(iC) { }
    const bool operator < (const QuantumNumbers &r) const {
      if (B != r.B)
        return (B < r.B);
      else if (Q != r.Q)
        return (Q < r.Q);
      else if (S != r.S)
        return (S < r.S);
      else
        return (C < r.C);
    }
  };

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

    virtual ~ThermalModelCanonical(void);

    virtual void CalculateQuantumNumbersRange(bool computeFluctuations = false);
    
    virtual void CalculatePartitionFunctions(double Vc = -1.);

    virtual bool IsParticleCanonical(const ThermalParticle &part);

    virtual void ConserveBaryonCharge(bool conserve = true) { m_BCE = static_cast<int>(conserve); }

    virtual void ConserveElectricCharge(bool conserve = true) { m_QCE = static_cast<int>(conserve); }

    virtual void ConserveStrangeness(bool conserve = true) { m_SCE = static_cast<int>(conserve); }

    virtual void ConserveCharm(bool conserve = true) { m_CCE = static_cast<int>(conserve); }
 
    virtual bool IsConservedChargeCanonical(ConservedCharge::Name charge) const;

    virtual double GetGCEDensity(int i) const;

    int IntegrationIterationsMultiplier() const { return m_IntegrationIterationsMultiplier; }

    void SetIntegrationIterationsMultiplier(int multiplier) { (multiplier > 0 ? m_IntegrationIterationsMultiplier = multiplier : m_IntegrationIterationsMultiplier = 1); }
    
 
    // Override functions begin
 
    void ChangeTPS(ThermalParticleSystem *TPS);
 
    virtual void SetStatistics(bool stats);
 
    virtual void FixParameters();
 
    virtual void FixParametersNoReset();
 
    virtual void CalculatePrimordialDensities();
 
    virtual void ValidateCalculation();
 
    virtual double ParticleScaledVariance(int part);
 
    virtual void CalculateTwoParticleCorrelations();

    virtual void CalculateFluctuations();
 
    virtual double CalculateEnergyDensity();
 
    virtual double CalculatePressure();
 
    virtual double CalculateEntropyDensity();
 
    virtual double CalculateEnergyDensityDerivativeT() { throw std::runtime_error("CalculateEnergyDensityDerivativeT not implemented"); return 0.; } // Not implemented

    virtual double ParticleScalarDensity(int /*part*/) { return 0.; }
 
    // Override functions end
 
  private:

    void PrepareModelGCE();  
 
    void CleanModelGCE();    
 
  protected:

    std::vector<QuantumNumbers> m_QNvec;

    std::map<QuantumNumbers, int> m_QNMap;
    
    std::vector<double> m_Corr;

    std::vector<double> m_PartialZ;

    int m_IntegrationIterationsMultiplier;
 
    int m_BMAX; 
    int m_QMAX; 
    int m_SMAX; 
    int m_CMAX; 
    int m_BMAX_list, m_QMAX_list, m_SMAX_list, m_CMAX_list;
 
    double m_MultExp; 
    double m_MultExpBanalyt; 

    ThermalModelIdeal *m_modelgce;
 
    int m_BCE; 
    int m_QCE; 
    int m_SCE; 
    int m_CCE; 

    bool m_Banalyt;
  };
 
} // namespace thermalfist
 
#endif