optionsBase.h

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) BDSIM Collaboration, 2001 - 2026.
 
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 OPTIONSBASE_H
#define OPTIONSBASE_H
 
#include <string>
#include <vector>
 
namespace GMAD
{
  class OptionsBase
  {
  public:
    OptionsBase();
 
    std::string inputFileName;       
    std::string visMacroFileName;    
    std::string geant4MacroFileName; 
    std::string geant4PhysicsMacroFileName; 
    bool        geant4PhysicsMacroFileNameFromExecOptions;
    bool        visDebug;            
    int         visVerbosity;        
  
    std::string outputFileName;
    std::string outputFormat;
    bool        outputDoublePrecision;
    int         outputCompressionLevel;
  
    bool        survey;
    std::string surveyFileName;
  
    bool batch; 
 
    // verbosity here done in hierarchy of simulation - overall, run, event
    // track, step
    bool verbose;
 
    int  verboseRunLevel;
 
    bool verboseEventBDSIM;      // for bdsim print out
    int  verboseEventLevel;      // for geant4 print out
    int  verboseEventStart;
    int  verboseEventContinueFor;
    
    int  verboseTrackingLevel;  
 
    bool verboseSteppingBDSIM;  // for bdsim print out
    int  verboseSteppingLevel;  // for geant4 print out
    int  verboseSteppingEventStart;
    int  verboseSteppingEventContinueFor;
    bool verboseSteppingPrimaryOnly;
    
    int  verboseImportanceSampling; 
 
    bool verboseSensitivity;
  
    bool circular;                 
    int  seed;                     
    std::string randomEngine;      
    int  nGenerate;                
    bool recreate;                 
    std::string recreateFileName;  
    int  startFromEvent;           
    bool writeSeedState;           
    bool useASCIISeedState;        
    std::string seedStateFileName; 
 
    bool generatePrimariesOnly; 
    
    bool        exportGeometry;
    std::string exportType;
    std::string exportFileName;
 
    std::string bdsimPath;
    
    std::string physicsList;
    bool        physicsVerbose;
    int         physicsVerbosity;
    double      physicsEnergyLimitLow;
    double      physicsEnergyLimitHigh;
    bool        g4PhysicsUseBDSIMRangeCuts;
    bool        g4PhysicsUseBDSIMCutsAndLimits;
    
    int eventOffset;  
    bool recreateSeedState; 
    
    double elossHistoBinWidth;
    
    double ffact;
 
    double beamlineX;
    double beamlineY;
    double beamlineZ;
    double beamlinePhi;
    double beamlineTheta;
    double beamlinePsi;
    double beamlineAxisX;
    double beamlineAxisY;
    double beamlineAxisZ;
    double beamlineAngle;
    bool   beamlineAxisAngle;
    double beamlineS;
 
    int    eventNumberOffset;
    
    bool       checkOverlaps;
    double xsize, ysize;
 
    std::string magnetGeometryType;
    std::string outerMaterialName;
    double      horizontalWidth; // formerly outerDiameter
    double      thinElementLength;
    bool        hStyle; 
    double      vhRatio;
    double      coilWidthFraction;
    double      coilHeightFraction;
    bool        ignoreLocalMagnetGeometry;
    bool        buildPoleFaceGeometry;
 
    bool preprocessGDML;
    bool preprocessGDMLSchema;
 
    bool      dontSplitSBends;
 
    bool      yokeFields;
    bool      yokeFieldsMatchLHCGeometry;
    bool      useOldMultipoleOuterFields;
    double    scalingFieldOuter;
    bool      integrateKineticEnergyAlongBeamline;
    
    std::string cavityFieldType;
 
    bool        includeFringeFields;
    bool        includeFringeFieldsCavities;
 
    double      beampipeThickness;
    std::string apertureType;
    double      aper1;
    double      aper2;
    double      aper3;
    double      aper4;
    std::string beampipeMaterial;
    bool        ignoreLocalAperture;
    
    std::string vacMaterial;   
    std::string emptyMaterial; 
    std::string worldMaterial;
    std::string worldGeometryFile;
    bool        autoColourWorldGeometryFile;
    std::string importanceWorldGeometryFile;
    std::string importanceVolumeMap;
    // see verboseImportance
 
    double    worldVolumeMargin; 
 
    double    vacuumPressure;
    
    bool        buildTunnel;
    bool        buildTunnelStraight;
    std::string tunnelType;
    double      tunnelThickness;
    double      tunnelSoilThickness;
    std::string tunnelMaterial;
    std::string soilMaterial;
    bool        buildTunnelFloor;
    double      tunnelFloorOffset;
    double      tunnelAper1;
    double      tunnelAper2;
    bool        tunnelVisible;
    double      tunnelOffsetX;
    double      tunnelOffsetY;
    double      tunnelMaxSegmentLength;
    
    bool removeTemporaryFiles;
    std::string temporaryDirectory;
    
    // sampler options
    double   samplerDiameter;
 
    bool     turnOnOpticalAbsorption;
    bool     turnOnMieScattering;
    bool     turnOnRayleighScattering;
    bool     turnOnOpticalSurface;
 
    double   scintYieldFactor;
    int      maximumPhotonsPerStep;
    double   maximumBetaChangePerStep;
    long     maximumTracksPerEvent;
    double   minimumKineticEnergy;
    double   minimumKineticEnergyTunnel;
    double   minimumRange;
    std::string particlesToExcludeFromCuts;
    double   defaultRangeCut;
    double   prodCutPhotons;
    double   prodCutElectrons;
    double   prodCutPositrons;
    double   prodCutProtons;
    double   neutronTimeLimit;
    double   neutronKineticEnergyLimit;
    bool     useLENDGammaNuclear;
    bool     useElectroNuclear;
    bool     useMuonNuclear;
    bool     useGammaToMuMu;
    bool     usePositronToMuMu;
    bool     usePositronToHadrons;
    bool     restoreFTPFDiffractionForAGreater10;
 
    bool     beamPipeIsInfiniteAbsorber;
    bool     collimatorsAreInfiniteAbsorbers;
    bool     tunnelIsInfiniteAbsorber;
    int      muonSplittingFactor;
    double   muonSplittingThresholdParentEk;
    int      muonSplittingFactor2;
    double   muonSplittingThresholdParentEk2;
    bool     muonSplittingExcludeWeight1Particles;
    double   muonSplittingExclusionWeight;
    double   xrayAllSurfaceRoughness;
    bool     extendPionDecayChannels;
    bool     turnOffMuonDecay;
 
    // biasing options
    double    scaleFactorLaser;
    std::string defaultBiasVacuum;
    std::string defaultBiasMaterial;
    std::string biasForWorldVolume;
    std::string biasForWorldContents;
    std::string biasForWorldVacuum;
    std::string worldVacuumVolumeNames;
 
    // tracking related parameters
    std::string integratorSet;
    std::string fieldModulator;
    double   lengthSafety;
    double   lengthSafetyLarge;
    double   maximumTrackingTime; 
    double   maximumStepLength;   
    double   maximumTrackLength;  
    double   chordStepMinimum;
    double   chordStepMinimumYoke;
    double   deltaIntersection;
    double   minimumEpsilonStep;
    double   maximumEpsilonStep;
    double   minimumEpsilonStepThin;
    double   maximumEpsilonStepThin;
    double   deltaOneStep;
    bool     stopSecondaries;
    bool     killNeutrinos;
    bool     killedParticlesMassAddedToEloss;
    double   minimumRadiusOfCurvature; 
    bool     sampleElementsWithPoleface;
    double   nominalMatrixRelativeMomCut; 
    bool     teleporterFullTransform;     
    double   dEThresholdForScattering;
    double   backupStepperMomLimit;    
 
    // hit generation - only two parts that go in the same collection / branch
    bool      sensitiveOuter;
    bool      sensitiveBeamPipe;
    
    // output related options
    int         numberOfEventsPerNtuple;
 
    bool        storeMinimalData;
 
    bool        storeApertureImpacts;
    bool        storeApertureImpactsIons;
    bool        storeApertureImpactsAll;
    bool        storeApertureImpactsHistograms;
    double      apertureImpactsMinimumKE;
    bool        storeCavityInfo;
    bool        storeCollimatorInfo;
    bool        storeCollimatorHits;
    bool        storeCollimatorHitsLinks;
    bool        storeCollimatorHitsIons;
    bool        storeCollimatorHitsAll;
    double      collimatorHitsMinimumKE;
    bool        storeEloss;
    bool        storeElossHistograms;
    bool        storeElossVacuum;
    bool        storeElossVacuumHistograms;
    bool        storeElossTunnel;
    bool        storeElossTunnelHistograms;
    bool        storeElossWorld;
    bool        storeElossWorldIntegral;
    bool        storeElossWorldContents;
    bool        storeElossWorldContentsIntegral;
    bool        storeElossTurn;
    bool        storeElossLinks;
    bool        storeElossLocal;
    bool        storeElossGlobal;
    bool        storeElossTime;
    bool        storeElossStepLength;
    bool        storeElossPreStepKineticEnergy;
    bool        storeElossModelID;
    bool        storeElossPhysicsProcesses;
    bool        storeParticleData;
    bool        storePrimaries;
    bool        storePrimaryHistograms;
    
    bool        storeTrajectory;
    // filters
    int         storeTrajectoryDepth;
    int         storeTrajectoryStepPoints;
    bool        storeTrajectoryStepPointLast;
    std::string storeTrajectoryParticle;
    std::string storeTrajectoryParticleID;
    bool        storeTrajectorySecondaryParticles;
    double      storeTrajectoryEnergyThreshold;
    std::string storeTrajectorySamplerID;
    std::string storeTrajectoryELossSRange;
 
    // for trajectories stored, what data is stored
    bool        storeTrajectoryTransportationSteps;
    bool        trajNoTransportation;  
    bool        storeTrajectoryKineticEnergy;
    bool        storeTrajectoryMomentumVector;
    bool        storeTrajectoryProcesses;
    bool        storeTrajectoryTime;
    bool        storeTrajectoryLocal;
    bool        storeTrajectoryLinks;
    bool        storeTrajectoryIon;
    bool        storeTrajectoryMaterial;
    bool        storeTrajectoryAllVariables;
 
    // filter logic
    bool        trajectoryFilterLogicAND;
 
    bool        storeSamplerAll;
    bool        storeSamplerPolarCoords;
    bool        storeSamplerCharge;
    bool        storeSamplerKineticEnergy;
    bool        storeSamplerMass;
    bool        storeSamplerRigidity;
    bool        storeSamplerIon;
 
    double      trajCutGTZ;
    double      trajCutLTR;
    bool        trajConnect;
    
    bool        storeModel;
 
    bool        storePerEventHistos;
 
    int         samplersSplitLevel;
    int         modelSplitLevel;
    int         uprootCompatible;
 
    // circular options
    int         nturns;
    std::string ptcOneTurnMapFileName;
 
    double   printFractionEvents;
    double   printFractionTurns;
    bool     printPhysicsProcesses;
 
    // visualisation
    int nSegmentsPerCircle; 
 
    // scoring Map
    int    nbinsx;
    int    nbinsy;
    int    nbinsz;
    int    nbinse;
    double xmin;
    double xmax;
    double ymin;
    double ymax;
    double zmin;
    double zmax;
    double emin;
    double emax;
    bool   useScoringMap;
 
    // millicharge options
    bool enableMillicharge;
    std::string millichargeName;
    double millichargeMass;
    double millichargeCharge;
    int millichargeID;
 
    void print() const;
  
    std::vector<std::string> setKeys;
  };
}
 
#endif