ThermalModelFit.h

Go to the documentation of this file.

/*
 * Thermal-FIST package
 * 
 * Copyright (c) 2014-2019 Volodymyr Vovchenko
 *
 * GNU General Public License (GPLv3 or later)
 */
#ifndef THERMALMODELFIT_H
#define THERMALMODELFIT_H

#include <string>

#include "HRGFit/ThermalModelFitParameters.h"
#include "HRGFit/ThermalModelFitQuantities.h"
#include "HRGBase/xMath.h"
#include "HRGPCE/ThermalModelPCE.h"

namespace thermalfist {

  class ThermalModelFit
  {
  public:
    ThermalModelFit(ThermalModelBase *model);

    ~ThermalModelFit(void);

    void SetFitFlag(const std::string& name, bool flag) {
      m_Parameters.SetParameterFitFlag(name, flag);
    }



    void SetData(const std::vector<FittedQuantity> & inData) {
      m_Quantities.resize(0);
      m_Ratios.resize(0);
      m_Multiplicities.resize(0);
      AddData(inData);
    }

    void SetQuantities(const std::vector<FittedQuantity> & inQuantities) { SetData(inQuantities); }

    void AddData(const std::vector<FittedQuantity> & inData) {
      for (size_t i = 0; i < inData.size(); ++i)
        AddDataPoint(inData[i]);
    }

    void AddQuantities(const std::vector<FittedQuantity> & inQuantities) { AddData(inQuantities); }

    void AddDataPoint(const FittedQuantity& inDataPoint) {
      m_Quantities.push_back(inDataPoint);
      if (inDataPoint.type == FittedQuantity::Ratio)
        m_Ratios.push_back(inDataPoint.ratio);
      else
        m_Multiplicities.push_back(inDataPoint.mult);
    }

    void AddQuantity(const FittedQuantity& inQuantity) { AddDataPoint(inQuantity); }

    void ClearData() { m_Quantities.resize(0); }

    void ClearQuantities() { ClearData(); }

    void SetRatios(const std::vector<ExperimentRatio> & inRatios) {
      m_Ratios = inRatios;
    }

    void AddRatios(const std::vector<ExperimentRatio> & inRatios) {
      m_Ratios.insert(m_Ratios.end(), inRatios.begin(), inRatios.end());
      for (size_t i = 0; i < inRatios.size(); i++) {
        m_Quantities.push_back(FittedQuantity(inRatios[i]));
      }
    }

    void AddRatio(const ExperimentRatio& inRatio) {
      m_Ratios.push_back(inRatio);
      m_Quantities.push_back(FittedQuantity(inRatio));
    }

    void ClearRatios() { m_Ratios.resize(0); }

    void PrintRatios();

    void SetMultiplicities(const std::vector<ExperimentMultiplicity> & inMultiplicities) {
      m_Multiplicities = inMultiplicities;
    }

    void AddMultiplicities(const std::vector<ExperimentMultiplicity> & inMultiplicities) {
      m_Multiplicities.insert(m_Multiplicities.end(), inMultiplicities.begin(), inMultiplicities.end());
      for (size_t i = 0; i < inMultiplicities.size(); i++) {
        m_Quantities.push_back(FittedQuantity(inMultiplicities[i]));
      }
    }

    void AddMultiplicity(const ExperimentMultiplicity& inMultiplicity) {
      m_Multiplicities.push_back(inMultiplicity);
      m_Quantities.push_back(FittedQuantity(inMultiplicity));
    }

    void ClearMultiplicities() { m_Multiplicities.resize(0); }

    void PrintParameters();

    void PrintMultiplicities();

    void PrintYields();

    void PrintYieldsTable(std::string filename = "Yield.dat");

    void PrintYieldsTable2(std::string filename = "Yield.dat");

    void PrintYieldsLatex(std::string filename = "Yield.dat", std::string name = "A+A");

    void PrintYieldsLatexAll(std::string filename = "Yield.dat", std::string name = "A+A", bool asymm = false);

    void PrintFitLog(std::string filename = "", std::string comment = "Thermal fit", bool asymm = false);

    //double chi2Ndf(double T, double muB);

    ThermalModelFitParameters PerformFit(bool verbose = true, bool AsymmErrors = false);

    int GetNdf() const;

    void Increment() { m_Iters++; }

    const ThermalModelFitParameters& Parameters() const { return m_Parameters; }

    void SetParameters(const ThermalModelFitParameters& params) { m_Parameters = params; }

    void SetParameter(const std::string & name, const FitParameter & param) { m_Parameters.SetParameter(name, param); }
    
    void SetParameter(const std::string & name, double val, double err, double xmin, double xmax) { m_Parameters.SetParameter(name, val, err, xmin, xmax); }
    
    void SetParameterValue(const std::string & name, double value) { m_Parameters.SetParameterValue(name, value); }
    
    void SetParameterFitFlag(const std::string & name, bool toFit) { m_Parameters.SetParameterFitFlag(name, toFit); }
    

    const ThermalModelFitParametersExtended& ExtendedParameters() const { return m_ExtendedParameters; }
    
    ThermalModelBase* model() { return m_model; }

    ThermalModelPCE* modelpce() { return m_modelpce; }

    void SetSBConstraint(double SB) {
      if (m_model != NULL)
        m_model->SetSoverB(SB);
      m_model->ConstrainMuB(true);
    }

    void SetQBConstraint(double QB) {
      if (m_model != NULL)
        m_model->SetQoverB(QB);
      m_model->ConstrainMuQ(true);
    }
    
    double SoverB() const { return m_model->SoverB(); }
    double QoverB() const { return m_model->QoverB(); }

    const std::vector<ExperimentMultiplicity>&    Multiplicities()   const { return m_Multiplicities; }
    
    const std::vector<ExperimentRatio>&           Ratios()           const { return m_Ratios; }

    const std::vector<FittedQuantity>&            FittedQuantities() const { return m_Quantities; }

    int& Iters() { return m_Iters; }

    double& Chi2() { return m_Chi2; }

    double& BT() { return m_BT; }

    double& QT() { return m_QT; }

    double& ST() { return m_ST; }

    double& CT() { return m_CT; }

    double& ModelData(int index) { return m_ModelData[index]; }

    int ModelDataSize() const { return m_ModelData.size(); }

    void ClearModelData() { m_ModelData.clear(); }

    int& Ndf() { return m_Ndf; }
    void FixVcOverV(bool fix) { m_FixVcToV = fix; }
    bool FixVcOverV() const { return m_FixVcToV; }

    void SetVcOverV(double VcOverV) { m_VcOverV = VcOverV; }
    double VcOverV() const { return m_VcOverV; }

    void UseTkin(bool YieldsAtTkin) { m_YieldsAtTkin = YieldsAtTkin; }
    bool UseTkin() const { return m_YieldsAtTkin; }

    void UseSahaForNuclei(bool UseSaha) { m_SahaForNuclei = UseSaha; }

    void PCEFreezeLongLived(bool FreezeLongLived) { m_PCEFreezeLongLived = FreezeLongLived; }

    void SetPCEWidthCut(double WidthCut) { m_PCEWidthCut = WidthCut; }

    std::pair< double, double > ModelDescriptionAccuracy() const;

    static std::vector<FittedQuantity> loadExpDataFromFile(const std::string & filename);

    static void saveExpDataToFile(const std::vector<FittedQuantity> & outQuantities, const std::string & filename);

  private:
    static std::string GetCurrentTime();
    
    static std::vector<FittedQuantity> loadExpDataFromFile_OldFormat(std::fstream & fin);

    static std::vector<FittedQuantity> loadExpDataFromFile_NewFormat(std::fstream & fin);

    ThermalModelFitParameters m_Parameters;
    ThermalModelFitParametersExtended m_ExtendedParameters;
    ThermalModelBase *m_model;
    ThermalModelPCE  *m_modelpce;
    std::vector<ExperimentMultiplicity> m_Multiplicities;
    std::vector<ExperimentRatio> m_Ratios;
    std::vector<FittedQuantity> m_Quantities;
    int       m_Iters;
    double    m_Chi2;
    double    m_BT;
    double    m_QT;
    double    m_ST;
    double    m_CT;
    std::vector<double> m_ModelData;
    int       m_Ndf;
    bool      m_FixVcToV;
    double    m_VcOverV;

    bool      m_YieldsAtTkin;
    bool      m_SahaForNuclei;
    bool      m_PCEFreezeLongLived;
    double    m_PCEWidthCut;
  };

} // namespace thermalfist

#endif