BDSAcceleratorComponent.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 BDSACCELERATORCOMPONENT_H
#define BDSACCELERATORCOMPONENT_H
 
#include "globals.hh"          // geant4 globals / types
 
#include "BDSGeometryComponent.hh"
 
#include <list>
#include <set>
#include <string>
#include <vector>
 
class BDSBeamPipeInfo;
class BDSFieldInfo;
class BDSSimpleComponent;
class G4LogicalVolume;
class G4UserLimits;
class G4VisAttributes;
 
class BDSAcceleratorComponent: public BDSGeometryComponent
{
public:
  BDSAcceleratorComponent(const G4String&      name,
                          G4double             arcLength,
                          G4double             angle,
                          const G4String&      type,
                          BDSBeamPipeInfo*     beamPipeInfo       = nullptr,
                          const G4ThreeVector& inputFaceNormalIn  = G4ThreeVector(0,0,-1),
                          const G4ThreeVector& outputFaceNormalIn = G4ThreeVector(0,0, 1),
                          BDSFieldInfo*        fieldInfoIn        = nullptr);
  
  virtual ~BDSAcceleratorComponent();
 
  virtual void Initialise();
 
  // Communal constructions tasks
  
  virtual void SetBiasVacuumList(const std::list<std::string>& biasVacuumListIn)
  {biasVacuumList = biasVacuumListIn;}
  virtual void SetBiasMaterialList(const std::list<std::string>& biasMaterialListIn)
  {biasMaterialList = biasMaterialListIn;}
  virtual void SetBiasMaterialLVList(const std::list<std::string>& biasMaterialLVListIn)
  {biasMaterialLVList = biasMaterialLVListIn;}
  
  virtual void SetRegion(const G4String& regionIn) {region = regionIn;}
 
  void SetField(BDSFieldInfo* fieldInfoIn);
 
  virtual void SetMinimumKineticEnergy(G4double /*minimumKineticEnergyIn*/){;}
 
  // Accessors
  
  virtual inline G4String GetName() const {return name;}
 
  virtual G4double GetArcLength()   const {return arcLength;} 
  virtual G4double GetChordLength() const {return chordLength;}
 
  inline G4double GetAngle() const {return angle;}
 
  G4double Sagitta() const;
 
  inline G4String GetType() const {return type;}
 
  G4String GetRegion() const {return region;}
 
  virtual G4bool HasAField() const {return fieldInfo;}
  
  virtual void SetFieldUsePlacementWorldTransform();
 
  inline BDSBeamPipeInfo* GetBeamPipeInfo() const {return beamPipeInfo;}
 
  inline G4ThreeVector InputFaceNormal()  const {return inputFaceNormal;}
  inline G4ThreeVector OutputFaceNormal() const {return outputFaceNormal;}
 
  G4bool AngledInputFace()  const;
  G4bool AngledOutputFace() const;
 
  virtual G4String Material() const {return "none";}
 
  virtual std::set<G4LogicalVolume*> GetAcceleratorVacuumLogicalVolumes() const {return acceleratorVacuumLV;}
 
  virtual std::set<G4LogicalVolume*> GetAcceleratorMaterialLogicalVolumes() const;
 
  inline void  IncrementCopyNumber() {copyNumber++;}
 
  inline G4int GetCopyNumber() const {return copyNumber;}
 
  std::list<std::string> GetBiasVacuumList()   const {return biasVacuumList;}
  std::list<std::string> GetBiasMaterialList() const {return biasMaterialList;}
  std::list<std::string> GetBiasMaterialLVList() const {return biasMaterialLVList;}
  
  BDSSimpleComponent* EndPieceBefore() const {return endPieceBefore;}
  BDSSimpleComponent* EndPieceAfter()  const {return endPieceAfter;}
 
  virtual void SetInputFaceNormal(const G4ThreeVector& input)   {inputFaceNormal  = input.unit();}
  virtual void SetOutputFaceNormal(const G4ThreeVector& output) {outputFaceNormal = output.unit();}
  
  static G4double lengthSafetyLarge;
 
protected:
  virtual void Build();
 
  virtual void BuildContainerLogicalVolume() = 0;
 
  inline void SetAcceleratorVacuumLogicalVolume(G4LogicalVolume* accVacLVIn)
  {acceleratorVacuumLV.insert(accVacLVIn);}
 
  inline void SetAcceleratorVacuumLogicalVolume(const std::set<G4LogicalVolume*>& accVacLVIn)
  {acceleratorVacuumLV.insert(accVacLVIn.begin(), accVacLVIn.end());}
 
  virtual void BuildUserLimits();
 
  virtual void AttachUserLimits() const;
  
  const G4String   name;
  const G4double   arcLength;
  const G4String   type;
  
  G4double         chordLength;
  G4double         angle;
  G4String         region;
 
  BDSBeamPipeInfo* beamPipeInfo;
 
  static G4double    lengthSafety;
  static G4Material* emptyMaterial;
  static G4Material* worldMaterial;
  static G4bool      checkOverlaps;
  static G4bool      sensitiveOuter;
  static G4bool      sensitiveVacuum;
  static G4VisAttributes* containerVisAttr;
 
  std::set<G4LogicalVolume*> acceleratorVacuumLV;
 
  BDSSimpleComponent* endPieceBefore;
  BDSSimpleComponent* endPieceAfter;
 
  G4UserLimits* userLimits; 
  
  BDSFieldInfo* fieldInfo; 
  
private:
  BDSAcceleratorComponent() = delete;
 
  BDSAcceleratorComponent& operator=(const BDSAcceleratorComponent&) = delete;
  BDSAcceleratorComponent(BDSAcceleratorComponent&) = delete;
 
  //A vector containing the physical volumes in the accelerator component- to be used for geometric importance sampling etc.
 
  G4bool initialised;
  
  G4int copyNumber;
 
  std::list<std::string> biasVacuumList;
  std::list<std::string> biasMaterialList;
  std::list<std::string> biasMaterialLVList;
  
  G4ThreeVector inputFaceNormal;  
  G4ThreeVector outputFaceNormal; 
};
 
#endif