Config.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 CONFIG_H
#define CONFIG_H
#include "BinSpecification.hh"
 
#include "Rtypes.h" // for classdef
 
#include "RebdsimTypes.hh"
#include "SpectraParticles.hh"
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
class HistogramDef;
class HistogramDefSet;
 
class Config
{
private:
  std::map<std::string, std::string> alternateKeys;
 
  std::map<std::string, bool>        optionsBool;
  std::map<std::string, std::string> optionsString;
  std::map<std::string, double>      optionsNumber;
 
  std::map<std::string, std::vector<HistogramDef*> > histoDefs;
 
  std::map<std::string, std::vector<HistogramDef*> > histoDefsSimple;
 
  std::map<std::string, std::vector<HistogramDef*> > histoDefsPerEntry;
 
  std::vector<HistogramDefSet*> eventHistoDefSetsSimple;
  std::vector<HistogramDefSet*> eventHistoDefSetsPerEntry;
  
  std::vector<std::string> eventParticleSetBranches;
  std::vector<std::string> eventParticleSetSimpleBranches;
  
public:
  virtual ~Config();
 
  static Config* Instance(const std::string& fileName = "",
                          const std::string& inputFilePath = "",
                          const std::string& outputFileName = "",
                          const std::string& defaultOutputFileSuffix = "_ana");
 
  void ParseInputFile();
 
  inline std::string GetOptionString(const std::string& key) const {return optionsString.at(key);}
  inline bool        GetOptionBool(const std::string& key)   const {return optionsBool.at(key);}
  inline double      GetOptionNumber(const std::string& key) const {return optionsNumber.at(key);}
 
  inline const std::vector<HistogramDef*>& HistogramDefinitions(const std::string& treeName) const
  {return histoDefs.at(treeName);}
 
  inline const std::vector<HistogramDef*>& HistogramDefinitionsSimple(const std::string& treeName) const
  {return histoDefsSimple.at(treeName);}
 
  inline const std::vector<HistogramDef*>& HistogramDefinitionsPerEntry(const std::string& treeName) const
  {return histoDefsPerEntry.at(treeName);}
 
  inline const std::vector<HistogramDefSet*>& EventHistogramSetDefinitionsSimple() const
  {return eventHistoDefSetsSimple;}
 
  inline const std::vector<HistogramDefSet*>& EventHistogramSetDefinitionsPerEntry() const
  {return eventHistoDefSetsPerEntry;}
  
  inline const std::vector<std::string>& EventParticleSetNamesSimple()   const {return eventParticleSetSimpleBranches;}
  inline const std::vector<std::string>& EventParticleSetNamesPerEntry() const {return eventParticleSetBranches;}
 
  const RBDS::VectorString& BranchesToBeActivated(const std::string& treeName) const
  {return branches.at(treeName);}
 
  inline const RBDS::BranchMap& BranchesToBeActivated() const {return branches;}
 
  void SetBranchToBeActivated(const std::string& treeName, const std::string& branchName);
 
  inline std::string InputFilePath() const             {return optionsString.at("inputfilepath");}
  inline std::string OutputFileName() const            {return optionsString.at("outputfilename");}
  inline std::string CalculateOpticalFunctionsFileName() const {return optionsString.at("opticslfilename");}
  inline bool   AllBranchesToBeActivated() const  {return optionsBool.at("allbranchesactivated");}
  inline bool   Debug() const                     {return optionsBool.at("debug");}
  inline bool   CalculateOpticalFunctions() const {return optionsBool.at("calculateoptics");}
  inline bool   EmittanceOnTheFly() const         {return optionsBool.at("emittanceonthefly");}
  inline bool   ProcessSamplers() const           {return optionsBool.at("processsamplers");}
  inline bool   PrintOut() const                  {return optionsBool.at("printout");}
  inline double PrintModuloFraction() const       {return optionsNumber.at("printmodulofraction");}
  inline bool   PerEntryBeam()   const {return optionsBool.at("perentrybeam");}
  inline bool   PerEntryEvent()  const {return optionsBool.at("perentryevent");}
  inline bool   PerEntryRun()    const {return optionsBool.at("perentryrun");}
  inline bool   PerEntryOption() const {return optionsBool.at("perentryoption");}
  inline bool   PerEntryModel()  const {return optionsBool.at("perentrymodel");}
 
  void PrintHistogramSetDefinitions() const;
 
  void FixCylindricalAndSphericalSamplerVariablesInSets(const std::set<std::string>& allCNames,
                                                        const std::set<std::string>& allSNames);
  
 protected:
  Config() = delete;
  Config(const std::string& inputFilePathIn,
         const std::string& outputFileNameIn,
         const std::string& defaultOutputFileSuffix = "_ana");
  Config(const std::string& fileNameIn,
         const std::string& inputFilePathIn,
         const std::string& outputFileNameIn,
         const std::string& defaultOutputFileSuffix);
 
  void InitialiseOptions(const std::string& analysisFile);
 
  void ParseHistogramLine(const std::string& line);
 
  void ParseSpectraLine(const std::string& line);
 
  void ParseParticleSetLine(const std::string& line);
 
  void ParseHistogram(const std::string& line, const int nDim);
 
  void ParsePerEntry(const std::string& name, bool& perEntry) const;
 
  bool ContainsWordCI(const std::string& input,
                      const std::string& word) const;
  
  void ParseLog(const std::string& definition,
                bool& xLog,
                bool& yLog,
                bool& zLog) const;
 
  void UpdateRequiredBranches(const HistogramDef* def);
 
  void UpdateRequiredBranches(const std::string& treeName,
                              const std::string& var);
 
  bool InvalidTreeName(const std::string& treeName) const;
 
  void CheckValidTreeName(std::string& treeName) const;
 
  void ParseBins(const std::string& bins,
                 int nDim,
                 BinSpecification& xBinning,
                 BinSpecification& yBinning,
                 BinSpecification& zBinning) const;
 
  void ParseBinning(const std::string& binning,
                    int nDim,
                    BinSpecification& xBinning,
                    BinSpecification& yBinning,
                    BinSpecification& zBinning,
                    bool xLog,
                    bool yLog,
                    bool zLog) const;
  std::vector<std::string> SplitOnWhiteSpace(const std::string& line) const;
    
  std::set<ParticleSpec> ParseParticles(const std::string& word) const;
    
  void ParseSetting(const std::string& line);
 
  std::string LowerCase(const std::string& st) const;
  
  bool RegisterHistogramName(const std::string& newHistName);
 
  static Config* instance;
 
  static std::vector<std::string> treeNames;
 
  int lineCounter = 0;
 
  RBDS::BranchMap branches;
 
  std::map<std::string, int> spectraNames;
  
  std::set<std::string> histogramNames;
 
  ClassDef(Config,1);
};
 
#endif