G4DarkBreMModel.h

#ifndef G4DARKBREM_G4DARKBREMMODEL_H
#define G4DARKBREM_G4DARKBREMMODEL_H
 
#include <map>
#include <memory>
 
#include "G4DarkBreM/ParseLibrary.h"
#include "G4DarkBreM/PrototypeModel.h"
#include "G4DarkBreM/G4APrime.h"
#include "G4DarkBreM/G4FractionallyCharged.h"
#include "G4DarkBreM/ParseLibrary.h"
 
// Geant4
#include "G4Electron.hh"
#include "G4EventManager.hh"  //for EventID number
#include "G4MuonMinus.hh"
#include "G4PhaseSpaceDecayChannel.hh"
#include "G4PhysicalConstants.hh"
#include "G4RunManager.hh"  //for VerboseLevel
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
 
// Boost
#include <boost/math/quadrature/gauss_kronrod.hpp>
 
// STL
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
namespace g4db {
 
class G4DarkBreMModel : public PrototypeModel {
 public:
  enum class ScalingMethod {
    ForwardOnly = 1,
 
    CMScaling = 2,
    Undefined = 3
  };
 
  enum class XsecMethod {
    Full = 1,
 
    Improved = 2,
 
    HyperImproved = 3,
 
    Auto = 4
  };
 
  G4DarkBreMModel(const std::string& library_path, bool muons,
                  double threshold = 0.0, double epsilon = 1.0,
                  ScalingMethod sm = ScalingMethod::ForwardOnly,
                  XsecMethod xm = XsecMethod::Auto,
                  double max_R_for_full = 50.0, int aprime_lhe_id = 622,
                  bool load_library = true, bool scale_APrime = false,
                  double dist_decay_min = 0.0, double dist_decay_max = 1.0, 
                  int decay_particle_id = 11);
 
  virtual ~G4DarkBreMModel() = default;
 
  virtual void PrintInfo() const;
 
  virtual G4double ComputeCrossSectionPerAtom(G4double lepton_ke,
                                              G4double atomicA,
                                              G4double atomicZ);
 
  std::pair<G4ThreeVector, G4ThreeVector> scale(double target_Z,
                                                double incident_energy,
                                                double lepton_mass);
 
  virtual void GenerateChange(G4ParticleChange& particleChange,
                              const G4Track& track, const G4Step& step,
                              const G4Element& element);
 
 private:
  void SetMadGraphDataLibrary(const std::string& path);
 
  void MakePlaceholders();
 
  OutgoingKinematics sample(double target_Z, double incident_energy);
 
 private:
  unsigned int maxIterations_{10000};
 
  double threshold_;
 
  double epsilon_;
 
  int aprime_lhe_id_;
 
  ScalingMethod scaling_method_;
 
  XsecMethod xsec_method_;
 
  std::string method_name_;
 
  std::string library_path_;
 
  bool alwaysCreateNewLepton_{true};
 
  bool scale_APrime_{false};
 
  double dist_decay_min_{0.0};
 
  double dist_decay_max_{1.0};
 
  std::map<int, std::map<double, std::vector<OutgoingKinematics>>>
      madGraphData_;
 
  std::map<int, std::map<double, unsigned int>> currentDataPoints_;
 
  int decay_particle_id_{11};
};
 
}  // namespace g4db
 
#endif  // G4DARKBREM_G4DARKBREMMODEL_H