BabayagaNLO.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 BabayagaNLO {
  public:
 
    BabayagaNLO();
 
    ~BabayagaNLO();
 
    void setDefaultSettings();
 
    void setScatAngle(std::pair<double, double> angleRange) { m_ScatteringAngleRange = angleRange; }
 
    void setNSearchMax(int nSearchMax) { m_nSearchMax = nSearchMax; }
 
    void setFMax(double fMax) { m_fMax = fMax; }
 
    void setMaxAcollinearity(double maxAcollinearity) { m_maxAcollinearity = maxAcollinearity; }
 
    void setCmsEnergyNominal(double cmsEnergyNominal) { m_cmsEnergyNominal = cmsEnergyNominal; }
 
    void setMinEnergy(double minEnergy) { m_eMin = minEnergy; }
 
    void setEpsilon(double epsilon) { m_epsilon = epsilon; }
 
    void setVacPol(const std::string& vacPol) { m_vacPol = vacPol; }
 
    void setModel(const std::string& model) { m_model = model; }
 
    void setMode(const std::string& mode) { m_mode = mode; }
 
    void setOrder(const std::string& order) { m_order = order; }
 
    void setFinalState(const std::string& finalState) { m_finalState = finalState; }
 
    void setEnergySpread(double spread) { m_EnergySpread = spread; }
 
    void setVPUncertainty(bool vpuncertainty) { m_VPUncertainty = vpuncertainty; }
 
    void setNPhotons(int nPhot) { m_nPhot = nPhot; }
 
    void setUserMode(const std::string& usermode) { m_userMode = usermode; }
 
    void setNSKDataFile(const std::string& NSKDataFile) { m_NSKDataFile = NSKDataFile; }
 
    void setEEMIN(double eemin) { m_eemin = eemin; }
 
    void setTEMIN(double temin) { m_temin = temin; }
 
    void setEGMIN(double egmin) { m_egmin = egmin; }
 
    void setTGMIN(double tgmin) { m_tgmin = tgmin; }
 
    void setEEVETO(double eeveto) { m_eeveto = eeveto; }
 
    void setTEVETO(double teveto) { m_teveto = teveto; }
 
    void setEGVETO(double egveto) { m_egveto = egveto; }
 
    void setTGVETO(double tgveto) { m_tgveto = tgveto; }
 
    void setMaxPrescale(double maxprescale) { m_maxprescale = maxprescale; }
 
    void init();
 
    void initExtraInfo();
 
    void generateEvent(MCParticleGraph& mcGraph, double ecm, ROOT::Math::XYZVector vertex, ROOT::Math::LorentzRotation boost);
 
    double getSDif() {return m_sDif;};
 
    void term();
 
  protected:
    bool m_applyBoost;              
    double m_pi;                    
    double m_conversionFactor;      
    double m_alphaQED0;             
    double m_massElectron;          
    double m_massMuon;              
    double m_massW;                 
    double m_massZ;                 
    double m_widthZ;                
    std::string m_vacPol;           
    std::string m_finalState;       
    std::string m_model;            
    std::string m_mode;             
    std::string m_order;            
    double m_EnergySpread;          
    double m_cmsEnergyNominal;      
    std::pair<double, double> m_ScatteringAngleRange; 
    std::pair<double, double> m_ScatteringAngleRangePhoton; 
    double m_epsilon; 
    double m_eMin; 
    double m_maxAcollinearity; 
    int m_nSearchMax;  
    int m_nPhot; 
    bool m_VPUncertainty;   
    std::string m_NSKDataFile;   
    std::string m_userMode; 
    double m_eemin; 
    double m_temin; 
    double m_egmin; 
    double m_tgmin; 
    double m_eeveto; 
    double m_teveto; 
    double m_egveto; 
    double m_tgveto; 
    double m_maxprescale; 
    double m_fMax;  
    double m_sDif;  
    ROOT::Math::LorentzRotation m_boostVector; 
    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, bool isISRFSR = false);
 
  private:
 
    int    m_npar[100];  
    double m_xpar[100];  
  };
}