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];  
  };

}