BHWide.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 BHWide {
  public:
 
    enum Channel {
      CH_BOTH = 0,    
      CH_S_ONLY = 1,  
      CH_T_ONLY = 2   
    };
 
    enum RandomGenerator {
      RG_RANMAR = 1, 
      RG_RANECU = 2  
    };
 
    enum EWCorrectionLib {
      EC_BABAMC = 1, 
      EC_ALIBABA = 2 
    };
 
    enum HardBremsModel {
      HM_HELICITY_AMP = 1, 
      HM_CALKUL = 2        
    };
 
    enum PhotonVacPolarization {
      PP_OFF = 0,       
      PP_BHLUMI = 1,    
      PP_EIDELMAN = 2,  
      PP_BURKHARDT = 3  
    };
 
    BHWide();
 
    ~BHWide();
 
    void setDefaultSettings();
 
    void enableZContribution(bool zContribution = true) { m_zContribution = zContribution; }
 
    void setChannel(Channel channel) { m_channel = channel; }
 
    void enableWeights(bool weighted = true) { m_weighted = weighted; }
 
    void setRandomGenerator(RandomGenerator randomGenerator) { m_randomGenerator = randomGenerator; }
 
    void enableWeakCorrections(bool weakCorrections = true) { m_weakCorrections = weakCorrections; }
 
    void setElectroWeakCorrectionsLib(EWCorrectionLib ewCorrectionLib) { m_ewCorrectionLib = ewCorrectionLib; }
 
    void setHardBremsModel(HardBremsModel hardBremsModel) { m_hardBremsModel = hardBremsModel; }
 
    void setPhotonVacPolarization(PhotonVacPolarization photonVacPol) { m_photonVacPol = photonVacPol; }  
    void setCMSEnergy(double cmsEnergy) { m_cmsEnergy = cmsEnergy; }
 
    void setScatAnglePositron(std::pair<double, double> angleRange) { m_ScatteringAngleRangePositron = angleRange; }
 
    void setScatAngleElectron(std::pair<double, double> angleRange) { m_ScatteringAngleRangeElectron = angleRange; }
 
    void setMinEnergyFinalStatePos(double minEnergyFinalStatePos) { m_minEnergyFinalStatePos = minEnergyFinalStatePos; }
 
    void setMinEnergyFinalStateElc(double minEnergyFinalStateElc) { m_minEnergyFinalStateElc = minEnergyFinalStateElc; }
 
    void setMaxAcollinearity(double maxAcollinearity) { m_maxAcollinearity = maxAcollinearity; }
 
    void setInfCutCMSEnergy(double infCutCMSEnergy) { m_infCutCMSEnergy = infCutCMSEnergy; }
 
    void setMaxRejectionWeight(double maxRejectionWeight) { m_maxRejectionWeight = maxRejectionWeight; }
 
    void setMassZ(double massZ) { m_massZ = massZ; }
 
    void setWidthZ(double widthZ) { m_widthZ = widthZ; }
 
    void setSinW2(double sinW2) { m_sinW2 = sinW2; }
 
    void setMassTop(double massTop) { m_massTop = massTop; }
 
    void setMassHiggs(double massHiggs) { m_massHiggs = massHiggs; }
 
    void init();
 
    void generateEvent(MCParticleGraph& mcGraph, ROOT::Math::XYZVector vertex, ROOT::Math::LorentzRotation boost);
 
    void term();
 
    double getCrossSection() { return m_crossSection; }
 
    double getCrossSectionError() { return m_crossSectionError; }
 
 
  protected:
 
    bool m_zContribution;                 
    Channel m_channel;                    
    bool m_weighted;                      
    RandomGenerator m_randomGenerator;    
    bool m_weakCorrections;               
    EWCorrectionLib m_ewCorrectionLib;    
    HardBremsModel m_hardBremsModel;      
    PhotonVacPolarization m_photonVacPol; 
    double m_cmsEnergy; 
    std::pair<double, double> m_ScatteringAngleRangePositron; 
    std::pair<double, double> m_ScatteringAngleRangeElectron; 
    double m_minEnergyFinalStatePos; 
    double m_minEnergyFinalStateElc; 
    double m_maxAcollinearity;       
    double m_infCutCMSEnergy;        
    double m_maxRejectionWeight;     
    double m_massZ;     
    double m_widthZ;    
    double m_sinW2;     
    double m_massTop;   
    double m_massHiggs; 
    double m_crossSection;      
    double m_crossSectionError; 
    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];  
  };
}