gparticle.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include "glogger.h"
#include "gutilities.h"
 
// geant4
#include "G4ThreeVector.hh"
#include "G4ParticleGun.hh"
 
// c++
#include <string>
 
 
class Gparticle
{
public:
    Gparticle(const std::string&              name,
              int                             multiplicity,
              double                          p,
              double                          delta_p,
              const std::string&              punit,
              const std::string&              randomMomentumModel,
              double                          theta,
              double                          delta_theta,
              const std::string&              thetaModel,
              double                          phi,
              double                          delta_phi,
              const std::string&              aunit,
              double                          avx,
              double                          avy,
              double                          avz,
              double                          adelta_vx,
              double                          adelta_vy,
              double                          adelta_vz,
              const std::string&              vunit,
              const std::string&              randomVertexModel,
              const std::shared_ptr<GLogger>& logger);
 
    Gparticle(const Gparticle&) = delete;
 
    Gparticle& operator=(const Gparticle&) = delete;
 
    ~Gparticle() { log->debug(DESTRUCTOR, "Gparticle"); }
 
    void shootParticle(G4ParticleGun* particleGun, G4Event* anEvent);
 
    static std::shared_ptr<Gparticle> create_default_gparticle(const std::shared_ptr<GLogger>& log) {
        return std::make_shared<Gparticle>(
            "e-",
            1,
            1,
            0,
            "GeV",
            "uniform",
            0,
            0,
            "uniform",
            0,
            0,
            "deg",
            0,
            0,
            0,
            0,
            0,
            0,
            "cm",
            "uniform",
            log
        );
    }
 
private:
    std::string name;
 
    int pid;
 
    int multiplicity;
 
    double p;
 
    double delta_p;
 
    gutilities::randomModel randomMomentumModel;
 
    double theta;
 
    double delta_theta;
 
    gutilities::randomModel randomThetaModel;
 
    double phi;
 
    double delta_phi;
 
    G4ThreeVector v;
 
    G4ThreeVector delta_v;
 
    gutilities::randomModel randomVertexModel;
 
    std::shared_ptr<GLogger> log;
 
    [[nodiscard]] double get_mass() const;
 
    friend std::ostream& operator<<(std::ostream& os, const Gparticle& gp);
 
    friend std::ostream& operator<<(std::ostream& os, const std::shared_ptr<Gparticle>& ptr) {
        if (ptr) return os << *ptr;
        else return os << "<null Gparticle>";
    }
 
    [[nodiscard]] double randomizeNumberFromSigmaWithModel(double                  center,
                                                           double                  delta,
                                                           gutilities::randomModel model) const;
 
    double calculateMomentum();
 
    double calculateKinEnergy(double mass);
 
    G4ThreeVector calculateBeamDirection();
 
    G4ThreeVector calculateVertex();
 
    int get_pdg_id();
};
 
using GparticlePtr = std::shared_ptr<Gparticle>;