BDSAcceleratorModel.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 BDSACCELERATORMODEL_H
#define BDSACCELERATORMODEL_H
#include "BDSBeamlineSet.hh"
#include "BDSPlacementToMake.hh"
#include "BDSScorerHistogramDef.hh"
 
#include "globals.hh"         // geant4 globals / types
#include "G4Transform3D.hh"
 
#include <map>
#include <set>
#include <vector>
 
class BDSApertureInfo;
class BDSBeamline;
class BDSFieldObjects;
class BDSLinkComponent;
class BDSRegion;
class G4LogicalVolume;
class G4Region;
class G4VPhysicalVolume;
class G4VSolid;
class G4VUserParallelWorld;
 
class BDSAcceleratorModel
{
public:
  static BDSAcceleratorModel* Instance();
  ~BDSAcceleratorModel();
 
  inline void RegisterWorldPV(G4VPhysicalVolume* worldIn) {worldPV = worldIn;}
  inline void RegisterWorldLV(G4LogicalVolume*   worldIn) {worldLV = worldIn;}
  inline void RegisterWorldSolid(G4VSolid*       worldIn) {worldSolid = worldIn;}
 
  inline G4VPhysicalVolume* WorldPV() const {return worldPV;} 
  inline G4LogicalVolume*   WorldLV() const {return worldLV;} 
 
  void RegisterBeamlineSetMain(const BDSBeamlineSet& setIn);
 
  void RegisterBeamlineSetExtra(const G4String&       name,
                                                const BDSBeamlineSet& setIn);
  
  inline const BDSBeamlineSet& BeamlineSetMain() const {return mainBeamlineSet;}
  const BDSBeamlineSet& BeamlineSet(const G4String& name) const;
  inline const std::map<G4String, BDSBeamlineSet>& ExtraBeamlines() const {return extraBeamlines;}
  const BDSBeamline* BeamlineMain() const {return mainBeamlineSet.massWorld;}
 
  inline void RegisterParallelWorld(G4VUserParallelWorld* world) {parallelWorlds.insert(world);}
 
  inline void RegisterPlacementBeamline(BDSBeamline* placementBLIn) {placementBeamline = placementBLIn;}
 
  inline BDSBeamline* PlacementBeamline() const {return placementBeamline;}
  
  inline void RegisterPlacementFieldPlacements(const std::vector<BDSPlacementToMake>& pIn) {placementFieldPlacements = pIn;}
  
  const std::vector<BDSPlacementToMake>& PlacementFieldPWPlacements() const {return placementFieldPlacements;}
 
  inline void RegisterBLMs(BDSBeamline* blmsIn) {blmsBeamline = blmsIn;}
 
  inline BDSBeamline* BLMsBeamline() const {return blmsBeamline;}
  
  inline void RegisterTunnelBeamline(BDSBeamline* beamlineIn) {tunnelBeamline = beamlineIn;}
 
  inline BDSBeamline* TunnelBeamline() const {return tunnelBeamline;}
  
  inline void RegisterFields(std::vector<BDSFieldObjects*>& fieldsIn){fields = fieldsIn;}
 
  void RegisterRegion(BDSRegion* region);
 
  inline void RegisterAperture(const G4String& name, BDSApertureInfo* apertureIn) {apertures[name] = apertureIn;}
  
  void RegisterApertures(const std::map<G4String, BDSApertureInfo*>& aperturesIn);
 
  BDSApertureInfo*  Aperture(G4String name) const;
 
  G4Region*         Region(const G4String& name) const;
 
  std::set<G4LogicalVolume*>* VolumeSet(const G4String& name);
 
  G4bool VolumeInSet(G4LogicalVolume* volume,
                     const G4String& registryName);
 
  BDSBeamline* CorrespondingMassWorldBeamline(BDSBeamline* bl) const;
 
  G4bool BeamlineIsMassWorld(BDSBeamline* bl) const;
 
  void MassWorldBeamlineAndIndex(BDSBeamline*& bl,
                                 G4int&        index) const;
 
  void RegisterScorerHistogramDefinition(const BDSScorerHistogramDef& def);
  
  void RegisterScorerPlacement(const G4String& meshName,
                          const G4Transform3D& placement);
 
  const std::vector<BDSScorerHistogramDef>& ScorerHistogramDefinitions() const {return scorerHistogramDefs;}
  const std::map<G4String, BDSScorerHistogramDef>& ScorerHistogramDefinitionsMap() const {return scorerHistogramDefsMap;}
  const BDSScorerHistogramDef* ScorerHistogramDef(const G4String& name);
  const std::map<G4String, G4Transform3D>& ScorerMeshPlacementsMap() const {return scorerMeshPlacements;}
  
  void RegisterLinkComponent(BDSLinkComponent* linkComponentIn) {linkComponents.insert(linkComponentIn);}
  inline const std::set<BDSLinkComponent*>& LinkComponents() const {return linkComponents;}
  
private:
  BDSAcceleratorModel(); 
 
  static BDSAcceleratorModel* instance;
 
  G4VPhysicalVolume* worldPV;              
  G4LogicalVolume*   worldLV;
  G4VSolid*          worldSolid;
 
  BDSBeamlineSet mainBeamlineSet;
  std::map<G4String, BDSBeamlineSet> extraBeamlines; 
 
  std::set<G4VUserParallelWorld*> parallelWorlds; 
 
  std::map<BDSBeamline*, BDSBeamline*> clToMassWorldMap;
 
  std::map<BDSBeamline*, G4bool> massWorldMapTF;
 
  void MapBeamlineSet(const BDSBeamlineSet& setIn);
 
  BDSBeamline* tunnelBeamline;            
  BDSBeamline* placementBeamline;         
  BDSBeamline* blmsBeamline;              
  
  std::vector<BDSFieldObjects*>         fields;    
  std::map<G4String, BDSRegion*>        regions;
  std::set<BDSRegion*>                  regionStorage; 
  std::map<G4String, BDSApertureInfo*>  apertures; 
  
  std::vector<BDSPlacementToMake>       placementFieldPlacements;
 
  std::map<G4String, std::set<G4LogicalVolume*>* > volumeRegistries; 
 
  std::vector<BDSScorerHistogramDef> scorerHistogramDefs;
  std::map<G4String, BDSScorerHistogramDef> scorerHistogramDefsMap;
  std::map<G4String, G4Transform3D> scorerMeshPlacements;
  
  std::set<BDSLinkComponent*> linkComponents;
};
 
#endif