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 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, m_QMAX, m_SMAX, 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, m_QCE, m_SCE, m_CCE;

    bool m_Banalyt;
  };

} // namespace thermalfist

#endif