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>
#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&              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,
              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,
                                           1,
                                           0,
                                           "GeV",
                                           "uniform",
                                           0,
                                           0,
                                           "uniform",
                                           0,
                                           0,
                                           "deg",
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           "cm",
                                           "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]] int getGeneratorType() const { return generator_type; }
 
    [[nodiscard]] const std::vector<GparticleRuntimeRecord>& getRuntimeRecords() const {
        return runtimeRecords;
    }
 
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>;