BDSEventAction.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) Royal Holloway, 
University of London 2001 - 2022.
 
This file is part of BDSIM.
 
BDSIM is free software: you can redistribute it and/or modify 
it under the terms of the GNU General Public License as published 
by the Free Software Foundation version 3 of the License.
 
BDSIM is distributed in the hope that it will be useful, but 
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BDSEVENTACTION_H
#define BDSEVENTACTION_H
 
#include "BDSHitEnergyDeposition.hh"
#include "BDSHitSampler.hh"
#include "BDSTrajectoryFilter.hh"
 
#include "globals.hh" // geant4 types / globals
#include "G4UserEventAction.hh"
 
#include <bitset>
#include <ctime>
#include <map>
#include <string>
#include <vector>
 
class BDSEventInfo;
class BDSOutput;
class BDSTrajectoriesToStore;
class BDSTrajectory;
class BDSTrajectoryPrimary;
class G4Event;
class G4PrimaryVertex;
 
class BDSEventAction: public G4UserEventAction
{
public:
  explicit BDSEventAction(BDSOutput* outputIn);
  virtual ~BDSEventAction();
  
  virtual void BeginOfEventAction(const G4Event*);
  virtual void EndOfEventAction(const G4Event*);
 
  void StoreSeedState(G4String seedState) {seedStateAtStart = seedState;}
  G4int CurrentEventIndex() const {return currentEventIndex;}
 
  void SetPrimaryAbsorbedInCollimator(G4bool stoppedIn) {primaryAbsorbedInCollimator = stoppedIn;}
 
  void SetSamplerIDsForTrajectories(const std::vector<G4int>& samplerIDsIn) {trajectorySamplerID = samplerIDsIn;}
 
  void IncrementNTracks() {nTracks++;}
  
  void RegisterPrimaryTrajectory(const BDSTrajectoryPrimary* trajectoryIn);
 
protected:
  BDSTrajectoriesToStore* IdentifyTrajectoriesForStorage(const G4Event* evt,
                                                         G4bool verboseThisEvent,
                                                         BDSHitsCollectionEnergyDeposition* eCounterHits,
                                                         BDSHitsCollectionEnergyDeposition* eCounterFullHits,
                                                         const std::vector<BDSHitsCollectionSampler*>& allSamplerHits,
                                                         G4int nChar = 50) const;
 
  void ConnectTrajectory(std::map<BDSTrajectory*, bool>& interestingTraj,
                         BDSTrajectory* trajectoryToConnect,
                         std::map<BDSTrajectory*, std::bitset<BDS::NTrajectoryFilters> >& trajectoryFilters) const;
  
private:
  BDSOutput* output;         
  G4bool verboseEventBDSIM;
  G4int  verboseEventStart;
  G4int  verboseEventStop;
  G4bool storeTrajectory;    
  G4bool storeTrajectoryAll; 
  G4int  printModulo;
 
  G4int samplerCollID_plane;      
  G4int samplerCollID_cylin;      
  G4int samplerCollID_sphere;     
  G4int eCounterID;               
  G4int eCounterFullID;           
  G4int eCounterVacuumID;         
  G4int eCounterTunnelID;         
  G4int eCounterWorldID;          
  G4int eCounterWorldContentsID;  
  G4int worldExitCollID;          
  G4int collimatorCollID;         
  G4int apertureCollID;           
  G4int thinThingCollID;          
  std::map<G4String, G4int> scorerCollectionIDs; 
  std::map<G4String, G4int> extraSamplerCollectionIDs; 
  std::map<G4String, G4int> extraSamplerCylinderCollectionIDs; 
  std::map<G4String, G4int> extraSamplerSphereCollectionIDs; 
 
  time_t startTime; 
  time_t stopTime;  
 
  G4double starts; 
  G4double stops;  
 
  // Note that individual calls to std::clock have no meaning, only
  // the differences between them, and therefore this should not be
  // written to the output.
  std::clock_t cpuStartTime; 
 
  G4bool primaryAbsorbedInCollimator; 
 
  G4bool   trajectoryFilterLogicAND;
  G4double trajectoryEnergyThreshold;
  G4double trajectoryCutZ;
  G4double trajectoryCutR;
  G4bool   trajConnect;
  G4String trajParticleNameToStore;
  G4String trajParticleIDToStore;
  std::vector<int> trajParticleIDIntToStore;
  G4int            trajDepth;
  std::vector<int> trajectorySamplerID;
  std::vector<std::pair<double,double>> trajSRangeToStore;
  std::bitset<BDS::NTrajectoryFilters>  trajFiltersSet;
 
  std::string seedStateAtStart; 
  G4int currentEventIndex;
 
  BDSEventInfo* eventInfo;
 
  long long int nTracks; 
  
  std::map<G4int, const BDSTrajectoryPrimary*> primaryTrajectoriesCache;// Cache of primary trajectories as constructed
};
 
#endif