Phokhara.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <mdst/dataobjects/MCParticleGraph.h>
#include <Math/LorentzRotation.h>
#include <Math/Vector3D.h>
#include <utility>
 
namespace Belle2 {
  class Phokhara {
  public:
 
    Phokhara();
 
    ~Phokhara();
 
    void setDefaultSettings();
 
    void setLO(int LO) { m_LO = LO; }
 
    void setWeighted(int weighted) { m_weighted = weighted; }
 
    void setNLO(int NLO) { m_NLO = NLO; }
 
    void setFullNLO(int FullNLO) { m_fullNLO = FullNLO; }
 
    void setQED(int QED) { m_QED = QED; }
 
    void setIFSNLO(int IFSNLO) { m_IFSNLO = IFSNLO; }
 
    void setAlpha(int alpha) { m_alpha = alpha; }
 
    void setPionFF(int pionff) { m_pionff = pionff; }
 
    void setKaonFF(int kaonff) { m_kaonff = kaonff; }
 
    void setPionStructure(int pionstructure) { m_pionstructure = pionstructure; }
 
    void setNarrowRes(int narres) { m_narres = narres; }
 
    void setProtonFF(int protonff) { m_protonff = protonff; }
 
    void setChiSW(int chisw) { m_chi_sw = chisw; }
 
    void setSwitchBeamResolution(int be_r) { m_be_r = be_r; }
 
    void setBeamResolution(double beamres) { m_beamres = beamres; }
 
    void setScatteringAngleRangePhoton(std::pair<double, double> angleRange) { m_ScatteringAngleRangePhoton = angleRange; }
 
    void setScatteringAngleRangeFinalStates(std::pair<double, double> angleRange) { m_ScatteringAngleRangeFinalStates = angleRange; }
 
    void setMinInvMassHadronsGamma(double MinInvMassHadronsGamma) { m_MinInvMassHadronsGamma = MinInvMassHadronsGamma; }
 
    void setm_MinInvMassHadrons(double MinInvMassHadrons) { m_MinInvMassHadrons = MinInvMassHadrons; }
 
    void setForceMinInvMassHadronsCut(bool forceMinInvMassHadronsCut)
    { m_ForceMinInvMassHadronsCut = forceMinInvMassHadronsCut; }
 
    void setm_MaxInvMassHadrons(double MaxInvMassHadrons) { m_MaxInvMassHadrons = MaxInvMassHadrons; }
 
    void setMinEnergyGamma(double MinEnergyGamma) { m_MinEnergyGamma = MinEnergyGamma; }
 
    void setCMSEnergy(double cmsEnergy) { m_cmsEnergy = cmsEnergy; }
 
    void setNSearchMax(int nSearchMax) { m_nSearchMax = nSearchMax; }
 
    void setEpsilon(double epsilon) { m_epsilon = epsilon; }
 
    void setFinalState(int finalState) { m_finalState = finalState; }
 
    void setReplaceMuonsByVirtualPhoton(bool replaceMuonsByVirtualPhoton)
    { m_replaceMuonsByVirtualPhoton = replaceMuonsByVirtualPhoton; }
 
    void setNMaxTrials(int nMaxTrials) { m_nMaxTrials = nMaxTrials; }
 
    void init(const std::string& paramFile);
 
    double generateEvent(MCParticleGraph& mcGraph, ROOT::Math::XYZVector vertex, ROOT::Math::LorentzRotation boost);
 
    void term();
 
  protected:
    //constants (unused in PHOKHARA yet!!!!!!!!!!!!!!)
    double m_pi;                    
    double m_conversionFactor;      
    double m_alphaQED0;             
    double m_massElectron;          
    double m_massMuon;              
    double m_massW;                 
    double m_massZ;                 
    double m_widthZ;                
    //PHOKHARA
    int m_finalState;  
    bool m_replaceMuonsByVirtualPhoton; 
    int m_nMaxTrials;  
    int m_nSearchMax;  
    double m_cmsEnergy;         
    double m_epsilon;           
    int m_weighted;  
    int m_LO;  
    int m_NLO;  
    int m_fullNLO;  
    int m_QED;  
    int m_IFSNLO;  
    int m_alpha;  
    int m_pionff;  
    int m_pionstructure;  
    int m_kaonff;  
    int m_narres;  
    int m_protonff;  
    int m_chi_sw;  
    int m_be_r;  
    std::pair<double, double> m_ScatteringAngleRangePhoton; 
    std::pair<double, double> m_ScatteringAngleRangeFinalStates; 
    double m_MinInvMassHadronsGamma; 
    double m_MinInvMassHadrons; 
    bool m_ForceMinInvMassHadronsCut; 
    double m_MaxInvMassHadrons; 
    double m_MinEnergyGamma; 
    double m_beamres; 
    void applySettings();
 
    void storeParticle(MCParticleGraph& mcGraph, const double* mom, int pdg, ROOT::Math::XYZVector vertex,
                       ROOT::Math::LorentzRotation boost,
                       bool isVirtual = false, bool isInitial = false);
 
  private:
 
    int    m_npar[100];  
    double m_xpar[100];  
  };
}