BDSSamplerRegistry.hh

/* 
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 BDSSAMPLERREGISTRY_H
#define BDSSAMPLERREGISTRY_H
#include "BDSDebug.hh"
#include "BDSException.hh"
#include "BDSSamplerPlacementRecord.hh"
#include "BDSSamplerType.hh"
 
#include "globals.hh" // geant4 types / globals
#include "G4Transform3D.hh"
 
#include <map>
#include <set>
#include <utility>
#include <vector>
 
class BDSBeamlineElement;
class BDSSampler;
 
class BDSSamplerRegistry
{
private:
  typedef std::vector<BDSSamplerPlacementRecord> InfoVector;
 
  InfoVector infos;
  
public:
  static BDSSamplerRegistry* Instance();
 
  ~BDSSamplerRegistry();
 
  G4int RegisterSampler(const G4String&      name,
                        BDSSampler*          sampler,
                        const G4Transform3D& transform   = G4Transform3D(),
                        G4double             S            = -1000,
                        const BDSBeamlineElement* element = nullptr,
                        BDSSamplerType            type    = BDSSamplerType::plane,
                        G4double                  radius  = 0);
 
  G4int RegisterSampler(BDSSamplerPlacementRecord& info);
 
  typedef InfoVector::iterator       iterator;
  typedef InfoVector::const_iterator const_iterator;
  iterator       begin()       {return infos.begin();}
  iterator       end()         {return infos.end();}
  const_iterator begin() const {return infos.begin();}
  const_iterator end()   const {return infos.end();}
  G4bool         empty() const {return infos.empty();}
 
  inline G4String       GetName(G4int index) const;
  inline G4String       GetNameUnique(G4int index) const;
  inline BDSSampler*    GetSampler(G4int index) const;
  inline G4Transform3D  GetTransform(G4int index) const;
  inline G4Transform3D  GetTransformInverse(G4int index) const;
  inline G4double       GetSPosition(G4int index) const;
  inline const BDSSamplerPlacementRecord& GetInfo(G4int index) const {return infos.at(index);}
  inline G4int          GetBeamlineIndex(G4int index) const;
 
  std::vector<G4String> GetNames() const;
 
  std::vector<G4String> GetUniqueNames() const;
  std::vector<G4String> GetUniqueNamesPlane() const;
  std::vector<G4String> GetUniqueNamesCylinder() const;
  std::vector<G4String> GetUniqueNamesSphere() const;
  
  std::map<std::string, double> GetUniqueNameToRadiusCylinder() const;
  std::map<std::string, double> GetUniqueNameToRadiusSphere() const;
  
  inline std::vector<G4int> GetSamplerIDsPlane() const    {return samplerIDsPerType.at(BDSSamplerType::plane);}
  inline std::vector<G4int> GetSamplerIDsCylinder() const {return samplerIDsPerType.at(BDSSamplerType::cylinder);}
  inline std::vector<G4int> GetSamplerIDsSphere() const   {return samplerIDsPerType.at(BDSSamplerType::sphere);}
  
  std::vector<std::pair<G4String, G4double> > GetUniquePlaneNamesAndSPosition() const;
 
  inline G4int NumberOfExistingSamplers() const;
  inline size_t size() const;
 
  inline G4bool SafeIndex(G4int index) const {return index < (G4int)infos.size();}
  
private:
  BDSSamplerRegistry();
 
  static BDSSamplerRegistry* instance;
 
  G4int numberOfEntries;
 
  std::map<G4String, G4int> existingNames;
 
  std::set<BDSSampler*> samplerObjects;
  
  std::map<BDSSamplerType, BDSSamplerType> samplerTypeToCategory;
  std::map<BDSSamplerType, std::vector<G4int>> samplerIDsPerType;
};
 
inline G4String BDSSamplerRegistry::GetName(G4int index) const
{return SafeIndex(index) ? infos.at(index).Name() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline G4String BDSSamplerRegistry::GetNameUnique(G4int index) const
{return SafeIndex(index) ? infos.at(index).UniqueName() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline BDSSampler* BDSSamplerRegistry::GetSampler(G4int index) const
{return SafeIndex(index) ? infos.at(index).Sampler() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline G4Transform3D BDSSamplerRegistry::GetTransform(G4int index) const
{return SafeIndex(index) ? infos.at(index).Transform() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline G4Transform3D BDSSamplerRegistry::GetTransformInverse(G4int index) const
{return SafeIndex(index) ? infos.at(index).TransformInverse() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline G4double BDSSamplerRegistry::GetSPosition(G4int index) const
{return SafeIndex(index) ? infos.at(index).SPosition() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
inline G4int BDSSamplerRegistry::NumberOfExistingSamplers() const
{return numberOfEntries;}
 
inline size_t BDSSamplerRegistry::size() const
{return infos.size();}
 
inline G4int BDSSamplerRegistry::GetBeamlineIndex(G4int index) const
{return SafeIndex(index) ? infos.at(index).BeamlineIndex() : throw BDSException(__METHOD_NAME__, "invalid index");}
 
#endif