BDSDetectorConstruction.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 BDSDETECTORCONSTRUCTION_H
#define BDSDETECTORCONSTRUCTION_H 
 
#include "BDSExtent.hh"
#include "BDSExtentGlobal.hh"
 
#include "globals.hh" // geant4 types / globals
#include "G4Transform3D.hh"
#include "G4Version.hh"
#include "G4VUserDetectorConstruction.hh"
 
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
 
class G4LogicalVolume;
class G4Region;
class G4VPhysicalVolume;
 
namespace GMAD {
  class BLMPlacement;
  struct Element;
  template<typename T> class FastList;
  class Placement;
  class Query;
  class SamplerPlacement;
  class ScorerMesh;
}
 
class BDSAcceleratorModel;
class BDSBeamline;
class BDSBeamlineSet;
class BDSComponentFactoryUser;
class BDSFieldObjects;
class BDSFieldQueryInfo;
class BDSParticleDefinition;
class BDSSamplerInfo;
 
#if G4VERSION_NUMBER > 1009
class BDSBOptrMultiParticleChangeCrossSection;
#endif
 
class BDSDetectorConstruction: public G4VUserDetectorConstruction
{
public:
  explicit BDSDetectorConstruction(BDSComponentFactoryUser* userComponentFactoryIn = nullptr);
  virtual ~BDSDetectorConstruction();
 
  void UpdateSamplerDiameterAndCountSamplers();
 
  virtual G4VPhysicalVolume* Construct();
 
  virtual void ConstructSDandField();
 
  void BuildPhysicsBias();
 
  inline void SetDesignParticle(const BDSParticleDefinition* defIn) {designParticle = defIn;}
 
  BDSExtent WorldExtent() const {return worldExtent;}
  
  const std::vector<BDSFieldQueryInfo*>& FieldQueries() const {return fieldQueries;}
 
  static void PlaceBeamlineInWorld(BDSBeamline*          beamline,
                                   G4VPhysicalVolume*    containerPV,
                                   G4bool                checkOverlaps     = false,
                                   G4bool                setRegions        = false,
                                   G4bool                registerInfo      = false,
                                   G4bool                useCLPlacementTransform = false,
                                   G4bool                useIncrementalCopyNumbers = false);
 
  static G4Transform3D CreatePlacementTransform(const GMAD::Placement& placement,
                                                const BDSBeamline*     beamLine,
                                                G4double*              S               = nullptr,
                                                BDSExtent*             placementExtent = nullptr,
                                                const G4String&        objectTypeForErrorMsg = "placement");
 
  // Create a scorermesh placement transform. Turns the scorermesh into a
  static G4Transform3D CreatePlacementTransform(const GMAD::ScorerMesh& scorerMesh,
                                                const BDSBeamline*      beamLine,
                                                G4double*               S = nullptr);
  
  static G4Transform3D CreatePlacementTransform(const GMAD::SamplerPlacement& samplerPlacement,
                                                const BDSBeamline*            beamLine,
                                                G4double*                     S = nullptr);
 
  static G4Transform3D CreatePlacementTransform(const GMAD::BLMPlacement& blmPlacement,
                                                const BDSBeamline*        beamLine,
                                                G4double*                 S         = nullptr,
                                                BDSExtent*                blmExtent = nullptr);
  
  static G4Transform3D CreatePlacementTransform(const GMAD::Query& queryPlacement,
                                                const BDSBeamline* beamLine,
                                                G4double* S = nullptr);
 
  static G4ThreeVector SideToLocalOffset(const GMAD::Placement& placement,
                                         const BDSBeamline*     beamLine,
                                         const BDSExtent&       placementExtent);
  
  static BDSSamplerInfo* BuildSamplerInfo(const GMAD::Element* element);
 
  G4bool BuildSamplerWorld() const {return nSamplers > 0;}
  
  G4bool BuildPlacementFieldsWorld() const {return buildPlacementFieldsWorld;}
 
  static std::vector<BDSFieldQueryInfo*> PrepareFieldQueries(const BDSBeamline* mainBeamline);
  
private:
  BDSDetectorConstruction& operator=(const BDSDetectorConstruction&) = delete;
  BDSDetectorConstruction(BDSDetectorConstruction&) = delete;
  
  void PrepareExtraSamplerSDs();
  
  void CountPlacementFields();
  
  void InitialiseRegions();
 
  void InitialiseApertures();
  
  void BuildBeamlines();
 
  BDSBeamlineSet BuildBeamline(const GMAD::FastList<GMAD::Element>& beamLine,
                               const G4String&      name,
                               const G4Transform3D& initialTransform   = G4Transform3D(),
                               G4double             initialS           = 0.0,
                               G4bool               beamlineIsCircular = false,
                               G4bool               isPlacementBeamline= false);
 
  void BuildTunnel();
  
  G4VPhysicalVolume* BuildWorld();
  
  void ComponentPlacement(G4VPhysicalVolume* worldPV);
 
  G4bool UnsuitableFirstElement(std::list<GMAD::Element>::const_iterator element);
 
  BDSExtent CalculateExtentOfSamplerPlacement(const GMAD::SamplerPlacement& sp) const;
 
  BDSExtentGlobal CalculateExtentOfSamplerPlacements(const BDSBeamline* beamLine) const;
 
  BDSExtent CalculateExtentOfScorerMesh(const GMAD::ScorerMesh& sm) const;
 
  BDSExtentGlobal CalculateExtentOfScorerMeshes(const BDSBeamline* bl) const;
 
#if G4VERSION_NUMBER > 1009
  BDSBOptrMultiParticleChangeCrossSection* BuildCrossSectionBias(const std::list<std::string>& biasList,
                                                                 const std::list<std::string>& defaultBias,
                                                                 const G4String& elementName);
 
  void ConstructScoringMeshes();
  
 
  std::vector<BDSBOptrMultiParticleChangeCrossSection*> biasObjects;
  std::map<G4String, BDSBOptrMultiParticleChangeCrossSection*> biasSetObjects;
#endif
 
#ifdef BDSDEBUG
  bool debug = true;
#else
  bool debug = false;
#endif
 
  G4bool verbose;
  G4bool checkOverlaps;
 
  BDSAcceleratorModel* acceleratorModel;
 
  std::vector<BDSFieldObjects*> fields;
 
  G4bool       circular;    
  BDSExtent    worldExtent; 
  BDSBeamline* placementBL; 
  const BDSParticleDefinition* designParticle;
  G4bool canSampleAngledFaces; 
 
  BDSComponentFactoryUser* userComponentFactory;
 
  G4int nSamplers; 
  G4bool buildPlacementFieldsWorld;
  
  std::set<G4LogicalVolume*> worldContentsLogicalVolumes;
  std::set<G4LogicalVolume*> worldVacuumLogicalVolumes;
  G4LogicalVolume* worldLogicalVolume;
  
  std::vector<BDSFieldQueryInfo*> fieldQueries;
 
  // for developer checks only
#ifdef BDSCHECKUSERLIMITS
  void PrintUserLimitsSummary(const G4VPhysicalVolume* world) const;
  void PrintUserLimitsPV(const G4VPhysicalVolume* aPV, G4double globalMinEK) const;
#endif
};
 
#endif