gparticle.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include <gemc/glogging/glogger.h>
#include <gemc/guts/gutilities.h>
 
// geant4
#include "G4ThreeVector.hh"
#include "G4ParticleGun.hh"
 
// c++
#include <string>
#include <vector>
 
struct GparticleRuntimeRecord
{
    std::string name;
    int         pid = 0;
    int         type = 1;
    double      p = 0;
    double      theta = 0;
    double      phi = 0;
    G4ThreeVector vertex;
};
 
 
class Gparticle
{
public:
    Gparticle(const std::string&              name,
              int                             multiplicity,
              double                          p,
              double                          delta_p,
              const std::string&              randomMomentumModel,
              double                          theta,
              double                          delta_theta,
              const std::string&              thetaModel,
              double                          phi,
              double                          delta_phi,
              double                          avx,
              double                          avy,
              double                          avz,
              double                          adelta_vx,
              double                          adelta_vy,
              double                          adelta_vz,
              const std::string&              randomVertexModel,
              const std::shared_ptr<GLogger>& logger,
              int                             generator_type = 1);
 
    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,
                                           gutilities::getG4Number("1*GeV"),
                                           0,
                                           "uniform",
                                           0,
                                           0,
                                           "uniform",
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           "uniform",
                                           log
                                          );
    }
 
    [[nodiscard]] const std::string& getName() const { return name; }
 
    [[nodiscard]] int getPid() const { return pid; }
 
    [[nodiscard]] int getMultiplicity() const { return multiplicity; }
 
    [[nodiscard]] double getMomentum() const { return p; }
 
    [[nodiscard]] double getTheta() const { return theta; }
 
    [[nodiscard]] double getPhi() const { return phi; }
 
    [[nodiscard]] const G4ThreeVector& getVertex() const { return v; }
 
    [[nodiscard]] double getDeltaMomentum() const { return delta_p; }
 
    [[nodiscard]] std::string getMomentumModel() const {
        return gutilities::to_string(randomMomentumModel);
    }
 
    [[nodiscard]] double getDeltaTheta() const { return delta_theta; }
 
    [[nodiscard]] std::string getThetaModel() const {
        return gutilities::to_string(randomThetaModel);
    }
 
    [[nodiscard]] double getDeltaPhi() const { return delta_phi; }
 
    [[nodiscard]] const G4ThreeVector& getDeltaVertex() const { return delta_v; }
 
    [[nodiscard]] std::string getVertexModel() const {
        return gutilities::to_string(randomVertexModel);
    }
 
    [[nodiscard]] int getGeneratorType() const { return generator_type; }
 
    [[nodiscard]] const std::vector<GparticleRuntimeRecord>& getRuntimeRecords() const {
        return runtimeRecords;
    }
 
    // ---- Setters (used by the GUI to reflect user edits in real time) ----
    void setName(const std::string& n)          { name = n; pid = get_pdg_id(); }
    void setMultiplicity(int m)                 { multiplicity = m; }
    void setMomentum(double p_mev)              { p = p_mev; }
    void setDeltaMomentum(double dp)            { delta_p = dp; }
    void setMomentumModel(const std::string& s) { randomMomentumModel = gutilities::stringToRandomModel(s); }
    void setTheta(double t_rad)                 { theta = t_rad; }
    void setDeltaTheta(double dt)               { delta_theta = dt; }
    void setThetaModel(const std::string& s)    { randomThetaModel = gutilities::stringToRandomModel(s); }
    void setPhi(double ph_rad)                  { phi = ph_rad; }
    void setDeltaPhi(double dp)                 { delta_phi = dp; }
    void setVertexX(double x)                   { v.setX(x); }
    void setVertexY(double y)                   { v.setY(y); }
    void setVertexZ(double z)                   { v.setZ(z); }
    void setDeltaVertexX(double x)              { delta_v.setX(x); }
    void setDeltaVertexY(double y)              { delta_v.setY(y); }
    void setDeltaVertexZ(double z)              { delta_v.setZ(z); }
    void setVertexModel(const std::string& s)   { randomVertexModel = gutilities::stringToRandomModel(s); }
 
private:
    std::string name;
 
    int generator_type;
 
    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;
 
    std::vector<GparticleRuntimeRecord> runtimeRecords;
 
    [[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(double thetaRad, double phiRad);
 
    G4ThreeVector calculateVertex();
 
    int get_pdg_id();
 
 
    // assigned at shootParticle for each multiplicity
    double        kinenergy;
    G4ThreeVector beamDirection;
    G4ThreeVector vertex;
 
    void setRunTimeQuantities(double ke, G4ThreeVector bd, G4ThreeVector v) {
        kinenergy     = ke;
        beamDirection = bd;
        vertex        = v;
    }
};
 
using GparticlePtr = std::shared_ptr<Gparticle>;