BDSOutput.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) Royal Holloway, 
University of London 2001 - 2024.
 
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 BDSOUTPUT_H
#define BDSOUTPUT_H 
 
#include "BDSHistBinMapper.hh"
#include "BDSOutputStructures.hh"
#include "BDSTrajectoryOptions.hh"
 
#include "globals.hh"
 
#include <ctime>
#include <ostream>
#include <set>
#include <vector>
#include <map>
 
// forward declarations
template <class T> class G4THitsCollection;
class BDSHitApertureImpact;
typedef G4THitsCollection<BDSHitApertureImpact> BDSHitsCollectionApertureImpacts;
class BDSHitCollimator;
typedef G4THitsCollection<BDSHitCollimator> BDSHitsCollectionCollimator;
class BDSHitEnergyDeposition;
typedef G4THitsCollection<BDSHitEnergyDeposition> BDSHitsCollectionEnergyDeposition;
class BDSEventInfo;
class BDSParticleCoordsFullGlobal;
class BDSParticleDefinition;
class BDSHitSampler;
typedef G4THitsCollection<BDSHitSampler> BDSHitsCollectionSampler;
class BDSHitSamplerCylinder;
typedef G4THitsCollection<BDSHitSamplerCylinder> BDSHitsCollectionSamplerCylinder;
class BDSHitSamplerSphere;
typedef G4THitsCollection<BDSHitSamplerSphere> BDSHitsCollectionSamplerSphere;
class BDSHitSamplerLink;
typedef G4THitsCollection<BDSHitSamplerLink> BDSHitsCollectionSamplerLink;
class BDSTrajectory;
class BDSTrajectoryPointHit;
class BDSHitEnergyDepositionGlobal;
typedef G4THitsCollection<BDSHitEnergyDepositionGlobal> BDSHitsCollectionEnergyDepositionGlobal;
class BDSTrajectoriesToStore;
template <class T> class G4THitsMap;
 
class G4PrimaryVertex;
 
namespace GMAD
{
  class BeamBase;
  class OptionsBase;
}
 
class BDSOutput: protected BDSOutputStructures
{
public:
  BDSOutput() = delete;
  BDSOutput(const G4String& baseFileNameIn,
            const G4String& fileExtentionIn,
            G4int           fileNumberOffset);
  virtual ~BDSOutput(){;}
 
  virtual void NewFile() = 0;
 
  virtual void CloseFile() = 0;
 
  virtual void InitialiseGeometryDependent();
  
  virtual void UpdateSamplers() {UpdateSamplerStructures();}
  
  void FillHeader();
 
  void FillParticleData(G4bool writeIons);
 
  void FillBeam(const GMAD::BeamBase* beam);
  
  void FillOptions(const GMAD::OptionsBase* options);
 
  void FillModel();
 
  void FillEventPrimaryOnly(const BDSParticleCoordsFullGlobal& coords,
                            const BDSParticleDefinition*       particle);
  
  void FillEvent(const BDSEventInfo*                            info,
                 const G4PrimaryVertex*                         vertex,
                 const std::vector<BDSHitsCollectionSampler*>&  samplerHitsPlane,
                 const std::vector<BDSHitsCollectionSamplerCylinder*>&  samplerHitsCylinder,
                 const std::vector<BDSHitsCollectionSamplerSphere*>&  samplerHitsSphere,
                 const BDSHitsCollectionSamplerLink*            samplerHitsLink,
                 const BDSHitsCollectionEnergyDeposition*       energyLoss,
                 const BDSHitsCollectionEnergyDeposition*       energyLossFull,
                 const BDSHitsCollectionEnergyDeposition*       energyLossVacuum,
                 const BDSHitsCollectionEnergyDeposition*       energyLossTunnel,
                 const BDSHitsCollectionEnergyDepositionGlobal* energyLossWorld,
                 const BDSHitsCollectionEnergyDepositionGlobal* energyLossWorldContents,
                 const BDSHitsCollectionEnergyDepositionGlobal* worldExitHits,
                 const std::vector<const BDSTrajectoryPointHit*>& primaryHits,
                 const std::vector<const BDSTrajectoryPointHit*>& primaryLosses,
                 const BDSTrajectoriesToStore*                  trajectories,
                 const BDSHitsCollectionCollimator*             collimatorHits,
                 const BDSHitsCollectionApertureImpacts*        apertureImpactHits,
                 const std::map<G4String, G4THitsMap<G4double>*>& scorerHitsMap,
                 const G4int                                    turnsTaken);
 
  void CloseAndOpenNewFile();
 
  void FillRun(const BDSEventInfo* info,
               unsigned long long int nOriginalEventsIn,
               unsigned long long int nEventsRequestedIn,
               unsigned long long int nEventsInOriginalDistrFileIn,
               unsigned long long int nEventsDistrFileSkippedIn,
               unsigned int distrFileLoopNTimesIn);
  
  static G4bool InvalidSamplerName(const G4String& samplerName);
 
  static void PrintProtectedNames(std::ostream& out);
 
protected:
  G4String GetNextFileName();
 
  inline G4bool CreateCollimatorOutputStructures() const {return createCollimatorOutputStructures;}
 
  G4bool storeELoss;
  G4bool storeELossTunnel;
  G4bool storeELossVacuum;
  G4bool storeELossWorld; // for both world and world exit
  G4bool storeELossWorldContents;
  G4bool storeApertureImpacts;
  G4bool storeApertureImpactsHistograms;
  G4bool storePrimaries;
  G4bool storeTrajectory;
  G4bool storePerEventHistos;
 
  std::map<G4String, G4int> blmCollectionNameToHistogramID;
 
private:
  enum class LossType {energy, vacuum, tunnel, world, worldexit, worldcontents};
 
  virtual void WriteHeader() = 0;
  
  virtual void WriteHeaderEndOfFile() = 0;
 
  virtual void WriteParticleData() = 0;
 
  virtual void WriteBeam() = 0;
  
  virtual void WriteOptions() = 0;
 
  virtual void WriteModel() = 0;
 
  virtual void WriteFileEventLevel() = 0;
 
  virtual void WriteFileRunLevel() = 0;
 
  void CalculateHistogramParameters();
  
  void CreateHistograms();
  
  void FillPrimary(const G4PrimaryVertex* vertex,
                   const G4int            turnsTaken);
  
  void FillEventInfo(const BDSEventInfo* info);
  
  void FillSamplerHitsVector(const std::vector<BDSHitsCollectionSampler*>& hits);
  void FillSamplerCylinderHitsVector(const std::vector<BDSHitsCollectionSamplerCylinder*>& hits);
  void FillSamplerSphereHitsVector(const std::vector<BDSHitsCollectionSamplerSphere*>& hits);
  
  void FillSamplerHits(const BDSHitsCollectionSampler* hits);
  
  void FillSamplerHitsLink(const BDSHitsCollectionSamplerLink* hits);
 
  void FillPrimaryHit(const std::vector<const BDSTrajectoryPointHit*>& primaryHits);
 
  void FillEnergyLoss(const BDSHitsCollectionEnergyDeposition* loss,
                      const LossType type);
 
  void FillEnergyLoss(const BDSHitsCollectionEnergyDepositionGlobal* loss,
                      const LossType type);
 
  //void FillELossWorldExitHits(const BDSHitsCollectionVolumeExit* worldExitHits);
  
  void FillPrimaryLoss(const std::vector<const BDSTrajectoryPointHit*>& primaryLosses);
 
  void FillTrajectories(const BDSTrajectoriesToStore* trajectories);
 
  void FillCollimatorHits(const BDSHitsCollectionCollimator* hits,
                          const std::vector<const BDSTrajectoryPointHit*>& primaryLossPoints);
 
  void FillApertureImpacts(const BDSHitsCollectionApertureImpacts* hits);
 
  void FillScorerHits(const std::map<G4String, G4THitsMap<G4double>*>& scorerHitsMap);
 
  void FillScorerHitsIndividual(const G4String& hsitogramDefName,
                                const G4THitsMap<G4double>* hitMap);
 
  void FillScorerHitsIndividualBLM(const G4String& histogramDefName,
                                   const G4THitsMap<G4double>* hitMap);
 
  void FillRunInfoAndUpdateHeader(const BDSEventInfo* info,
                                  unsigned long long int nOriginalEventsIn,
                                  unsigned long long int nEventsRequestedIn,
                                  unsigned long long int nEventsInOriginalDistrFileIn,
                                  unsigned long long int nEventsDistrFileSkippedIn,
                                  unsigned int distrFileLoopNTimesIn);
 
  void CopyFromHistToHist1D(const G4String& sourceName,
                            const G4String& destinationName,
                            const std::vector<G4int>& indices);
  
  const G4String baseFileName;  
  const G4String fileExtension; 
  G4int numberEventPerFile; 
  G4int outputFileNumber;   
 
  const static std::set<G4String> protectedNames;
 
  G4bool useScoringMap;
 
  G4double sMinHistograms;
  G4double sMaxHistograms;
 
  G4int nbins;
 
  G4bool storeCavityInfo;
  G4bool storeCollimatorInfo;
  G4bool storeCollimatorHits;
  G4bool storeCollimatorHitsLinks;
  G4bool storeCollimatorHitsIons;
  G4bool storeELossHistograms;
  G4bool storeELossTunnelHistograms;
  G4bool storeELossVacuumHistograms;
  G4bool storeParticleData;
  G4bool storePrimaryHistograms;
  G4bool storeModel;
  G4bool storeSamplerPolarCoords;
  G4bool storeSamplerCharge;
  G4bool storeSamplerKineticEnergy;
  G4bool storeSamplerMass;
  G4bool storeSamplerRigidity;
  G4bool storeSamplerIon;
  G4int  storeTrajectoryStepPoints;
  G4bool storeTrajectoryStepPointLast;
  BDS::TrajectoryOptions storeTrajectoryOptions;
 
  G4bool createCollimatorOutputStructures;
 
  G4double energyDeposited;
  G4double energyDepositedVacuum;
  G4double energyDepositedWorld;
  G4double energyDepositedWorldContents;
  G4double energyDepositedTunnel;
  G4double energyImpactingAperture;
  G4double energyImpactingApertureKinetic;
  G4double energyWorldExit;
  G4double energyWorldExitKinetic;
  G4int    nCollimatorsInteracted;
 
  std::map<G4String, G4int> histIndices1D;
  std::map<G4String, G4int> histIndices3D;
  std::map<G4String, G4int> histIndices4D;
  std::map<G4String, BDSHistBinMapper> scorerCoordinateMaps;
 
  std::map<G4int, G4double> histIndexToUnits1D;
  std::map<G4int, G4double> histIndexToUnits3D;
  std::map<G4int, G4double> histIndexToUnits4D;
};
 
#endif