EventGeneratorBase.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 EVENTGENERATORBASE_H
#define EVENTGENERATORBASE_H
 
 
#include <sstream>
 
#include "HRGEventGenerator/SimpleEvent.h"
#include "HRGEventGenerator/Acceptance.h"
#include "HRGEventGenerator/RandomGenerators.h"
#include "HRGBase/xMath.h"
#include "HRGBase/ThermalModelBase.h"
 
namespace thermalfist {

  template <typename T>
  std::string to_string_fix(T value)
  {
    //create an output string stream
    std::ostringstream os;
 
    //throw the value into the string stream
    os << value;
 
    //convert the string stream into a string and return
    return os.str();
  }

  std::vector<double> LorentzBoost(const std::vector<double>& fourvector, double vx, double vy, double vz);

  struct EventGeneratorConfiguration {
    enum Ensemble { 
      GCE, 
      CE,  
      SCE, 
      CCE  
    };

    enum ModelType { 
      PointParticle, 
      DiagonalEV,    
      CrosstermsEV,  
      MeanFieldEV,   
      QvdW,          
      RealGas        
    };
    
    Ensemble fEnsemble;
    
    ModelType fModelType;
    
    ThermalModelParameters CFOParameters;
    
    int B, Q, S, C;

    bool CanonicalB;
    bool CanonicalQ;
    bool CanonicalS;
    bool CanonicalC;

    std::vector< std::vector<double> > bij;

    std::vector< std::vector<double> > aij;

    int RealGasExcludedVolumePrescription;

    bool fUsePCE;

    std::vector<double> fPCEChems;

    bool fUseEVRejectionMultiplicity;

    bool fUseEVRejectionCoordinates;

    bool fUseEVUseSPRApproximation;

    bool fUseGCEConservedCharges;

    EventGeneratorConfiguration();
  };

  class EventGeneratorBase
  {
  public:
    EventGeneratorBase();
    
    virtual ~EventGeneratorBase();

    virtual void SetMomentumGenerators() {}

    void ClearMomentumGenerators();

    virtual std::pair< std::vector<int>, double > SampleYields() const;

    virtual SimpleParticle SampleParticle(int id) const;

    virtual SimpleParticle SampleParticleByPdg(long long pdgid) const;

    virtual SimpleEvent SampleMomenta(const std::vector<int>& yields) const;

    virtual SimpleEvent SampleMomentaWithShuffle(const std::vector<int>& yields) const;

    virtual SimpleEvent GetEvent(bool PerformDecays = true) const;

    struct DecayerFlags {
      bool propagateParticles;
      DecayerFlags(bool in_propagateParticles = false) :
      propagateParticles(in_propagateParticles)
      {}
    };

    static SimpleEvent PerformDecays(const SimpleEvent& evtin, const ThermalParticleSystem* TPS, const DecayerFlags& decayerFlags = DecayerFlags());

    virtual std::vector<double> GCEMeanYields() const;

    static int fCEAccepted, fCETotal;

    void SetVolume(double V);

    void RescaleCEMeans(double Vmod);

    ThermalModelBase* ThermalModel() { return m_THM; }
 
 
    double ComputeWeight(const std::vector<int>& totals) const;
    double ComputeWeightNew(const std::vector<int>& totals) const;
 
    void SetEVUseSPR(bool EVfastmode)    { m_Config.fUseEVUseSPRApproximation = EVfastmode; }
    bool EVUseSPR() const                { return m_Config.fUseEVUseSPRApproximation; }
 
    const EventGeneratorConfiguration& GetConfiguration() const { return m_Config; }

    virtual void CheckSetParameters() { if (!m_ParametersSet) SetParameters(); }
 
  protected:
    void SetConfiguration(ThermalParticleSystem *TPS,
      const EventGeneratorConfiguration& config);
 

    void PrepareMultinomials();
    
    std::vector<int> GenerateTotals() const;

    std::vector<int> GenerateTotalsGCE() const;

    std::vector<int> GenerateTotalsCE() const;

    std::vector<int> GenerateTotalsSCE() const;

    std::vector<int> GenerateTotalsSCESubVolume(double VolumeSC) const;

    std::vector<int> GenerateTotalsCCE() const;

    std::vector<int> GenerateTotalsCCESubVolume(double VolumeSC) const;
 
    EventGeneratorConfiguration m_Config;
    ThermalModelBase *m_THM;

    std::vector<double> m_DensitiesIdeal;

    std::vector<RandomGenerators::ParticleMomentumGenerator*>    m_MomentumGens;

    std::vector<RandomGenerators::ThermalBreitWignerGenerator*>  m_BWGens;
 
    bool m_ParametersSet;
    virtual void SetParameters();
 
    std::vector<std::vector<double>> ComputeEVRadii() const;
 
    bool CheckEVOverlap(const std::vector<SimpleParticle>& evt, 
      const SimpleParticle& cand,
      const std::vector<int>& ids = std::vector<int>(),
      const std::vector<std::vector<double>>& radii = std::vector<std::vector<double>>()
      ) const;
 
  private:

    //static SimpleEvent PerformDecaysAlternativeWay(const SimpleEvent& evtin, ThermalParticleSystem* TPS);


    std::vector< std::pair<double, int> > m_Baryons;
    std::vector< std::pair<double, int> > m_AntiBaryons;
    std::vector< std::pair<double, int> > m_StrangeMesons;
    std::vector< std::pair<double, int> > m_AntiStrangeMesons;
    std::vector< std::pair<double, int> > m_ChargeMesons;
    std::vector< std::pair<double, int> > m_AntiChargeMesons;
    std::vector< std::pair<double, int> > m_CharmMesons;
    std::vector< std::pair<double, int> > m_AntiCharmMesons;
    std::vector< std::pair<double, int> > m_CharmAll;
    std::vector< std::pair<double, int> > m_AntiCharmAll;
 
    std::vector<double> m_BaryonsProbs;
    std::vector<double> m_AntiBaryonsProbs;
    std::vector<double> m_StrangeMesonsProbs;
    std::vector<double> m_AntiStrangeMesonsProbs;
    std::vector<double> m_ChargeMesonsProbs;
    std::vector<double> m_AntiChargeMesonsProbs;
    std::vector<double> m_CharmMesonsProbs;
    std::vector<double> m_AntiCharmMesonsProbs;
    std::vector<double> m_CharmAllProbs;
    std::vector<double> m_AntiCharmAllProbs;
 
    double m_MeanB, m_MeanAB;
    double m_MeanSM, m_MeanASM;
    double m_MeanCM, m_MeanACM; 
    double m_MeanCHRMM, m_MeanACHRMM;
    double m_MeanCHRM, m_MeanACHRM;
 
    std::vector<std::vector<double>> m_Radii;
 
    static double m_LastWeight;
    static double m_LastLogWeight;
    static double m_LastNormWeight;
  };
 
} // namespace thermalfist
 
#endif