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"); }

    [[nodiscard]] std::vector<GparticleRuntimeRecord> shootParticle(G4ParticleGun* particleGun,
                                                                   G4Event* anEvent) const;

    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; }
 
    // ---- 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;

    [[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;

    [[nodiscard]] double calculateMomentum() const;

    [[nodiscard]] double calculateKinEnergy(double mass) const;

    [[nodiscard]] G4ThreeVector calculateBeamDirection(double thetaRad, double phiRad) const;

    [[nodiscard]] G4ThreeVector calculateVertex() const;

    int get_pdg_id();
 
};

using GparticlePtr = std::shared_ptr<Gparticle>;