PlasmaMLPALLASEventAction.hh

Go to the documentation of this file.

#ifndef PlasmaMLPALLASEventAction_h
#define PlasmaMLPALLASEventAction_h 1
 
#include "G4UserEventAction.hh"
#include "PlasmaMLPALLASQuadrupoleUtils.hh"
 
class G4Event;
 
struct RunTallyInput
{
    float x = 0.0;
    float xp = 0.0;
    float y = 0.0;
    float yp = 0.0;
    float z = 0.0;
    float zp = 0.0;
    float energy = 0.0;
};
 
 
struct RunTallyCollimators
{
    float x = 0.0;
    float y = 0.0;
    float z = 0.0;
    float energy = 0.0;
    bool flag =false;
    
    // Methods to set data
    void SetXInteraction(float d) { x =d; }
    void SetYInteraction(float d) { y =d; }
    void SetZInteraction(float d) { z =d; }
    void SetEnergy(float d) { energy =d; }
    void ActiveFlag(){flag=true;}
    void ResetFlag(){flag=false;}
 
    // Methods to access data
    float GetXInteraction() const { return x; }
    float GetYInteraction() const { return y; }
    float GetZInteraction() const { return z; }
    float GetEnergy() const { return energy; }
    bool GetFlag() {return flag;}
 
  
};
 
struct RunTallyYAG
{
    std::vector<float> x_exit;
    std::vector<float> y_exit;
    std::vector<float> z_exit;
    std::vector<int> parentID;
    std::vector<int> particleID;
    std::vector<float> energy;
    float deposited_energy = 0.0;
    std::vector<float> total_deposited_energy;
    G4bool flag = false;
 
    // Methods to add data
    void AddXExit(float d) { x_exit.push_back(d); }
    void AddYExit(float d) { y_exit.push_back(d); }
    void AddZExit(float d) { z_exit.push_back(d); }
    void AddParentID(int d) { parentID.push_back(d); }
    void AddParticleID(int d) { particleID.push_back(d); }
    void AddEnergy(float d) { energy.push_back(d); }
    void AddDepositedEnergy(float d) { deposited_energy += d; }
    void AddTotalDepositedEnergy(float d) { total_deposited_energy.push_back(d); }
 
    // Size accessors
    size_t XExitSize() const { return x_exit.size(); }
    size_t YExitSize() const { return y_exit.size(); }
    size_t ZExitSize() const { return z_exit.size(); }
    size_t ParentIDSize() const { return parentID.size(); }
    size_t ParticleIDSize() const { return particleID.size(); }
    size_t EnergySize() const { return energy.size(); }
    size_t TotalDepositedEnergySize() const { return total_deposited_energy.size(); }
 
    // Index accessors
    float GetXExit(size_t i) const { return x_exit.at(i); }
    float GetYExit(size_t i) const { return y_exit.at(i); }
    float GetZExit(size_t i) const { return z_exit.at(i); }
    int GetParentID(size_t i) const { return parentID.at(i); }
    int GetParticleID(size_t i) const { return particleID.at(i); }
    float GetEnergy(size_t i) const { return energy.at(i); }
    float GetTotalDepositedEnergy(size_t i) const { return total_deposited_energy.at(i); }
 
    // Flags
    void ActivateFlag() { flag = true; }
    void ResetFlag() { flag = false; }
    G4bool ReturnFlag() const { return flag; }
 
    void ResetDepositedEnergy() { deposited_energy = 0; }
    float GetDepositedEnergy() const { return deposited_energy; }
};
 
class PlasmaMLPALLASEventAction : public G4UserEventAction
{
public:
    PlasmaMLPALLASEventAction(const char *);
    
    ~PlasmaMLPALLASEventAction();
 
    void BeginOfEventAction(const G4Event *);
    
    void EndOfEventAction(const G4Event *);
 
    void SetXStart(G4float d) { StatsInput.x = d; }
    void SetXpStart(G4float d) { StatsInput.xp = d; }
    void SetYStart(G4float d) { StatsInput.y = d; }
    void SetYpStart(G4float d) { StatsInput.yp = d; }
    void SetZStart(G4float d) { StatsInput.z = d; }
    void SetZpStart(G4float d) { StatsInput.zp = d; }
    void SetEnergyStart(G4float d) { StatsInput.energy = d; }
 
    void SetEnergy(G4float d) { StatsQuadrupoles.energy = d; }
 
    RunTallyQuadrupoles& GetStatsQuadrupoles() { return StatsQuadrupoles; }
 
    RunTallyCollimators& GetVerticalCollimators() { return StatsVerticalColl; }
    RunTallyCollimators& GetHorizontalCollimators() { return StatsHorizontalColl; }
 
    RunTallyYAG& GetBSYAG() { return StatsBSYAG; }
    RunTallyYAG& GetBSPECYAG() { return StatsBSPECYAG; }
 
private:
    TTree *EventTree;                        
    TBranch *EventBranch;                    
    RunTallyInput StatsInput;                
    RunTallyQuadrupoles StatsQuadrupoles;    
    RunTallyCollimators StatsHorizontalColl; 
    RunTallyCollimators StatsVerticalColl;   
    RunTallyYAG StatsBSYAG;                  
    RunTallyYAG StatsBSPECYAG;               
    G4String suffixe;                        
};
 
#endif