BDSComponentFactory.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 BDSCOMPONENTFACTORY_H
#define BDSCOMPONENTFACTORY_H
 
#include "BDSBeamlineIntegral.hh"
#include "BDSFieldType.hh"
#include "BDSMagnetGeometryType.hh"
#include "BDSMagnetStrength.hh"
#include "BDSMagnetType.hh"
#include "BDSIntegratorType.hh"
#include "BDSIntegratorSetType.hh"
#include "BDSParticleDefinition.hh"
 
#include "globals.hh"
#include "G4ThreeVector.hh"
#include "G4Transform3D.hh"
 
#include "CLHEP/Units/PhysicalConstants.h"
 
#include <map>
 
class G4Colour;
class G4Material;
 
namespace GMAD
{
  struct Element;
}
class BDSAcceleratorComponent;
class BDSBeamPipeInfo;
class BDSCavityInfo;
class BDSComponentFactoryUser;
class BDSCrystalInfo;
class BDSFieldInfo;
class BDSIntegratorSet;
class BDSLaser;
class BDSMagnet;
class BDSMagnetOuterInfo;
class BDSModulatorInfo;
class BDSTiltOffset;
 
class BDSComponentFactory
{
public:
  explicit BDSComponentFactory(BDSComponentFactoryUser* userComponentFactoryIn = nullptr,
                               G4bool usualPrintOut = true);
  ~BDSComponentFactory();
 
  BDSAcceleratorComponent* CreateComponent(GMAD::Element const* elementIn,
                                           GMAD::Element const* prevElementIn,
                                           GMAD::Element const* nextElementIn,
                                           BDSBeamlineIntegral& integral);
  
  BDSAcceleratorComponent* CreateTerminator(G4double witdth);
 
  BDSAcceleratorComponent* CreateTeleporter(const G4double       teleporterLength,
                                            const G4double       teleporterWidth,
                                            const G4Transform3D& transformIn);
 
  static BDSTiltOffset*    CreateTiltOffset(GMAD::Element const* el);
 
  static G4Transform3D CreateFieldTransform(const BDSTiltOffset* tiltOffset);
 
  static G4Transform3D CreateFieldTransform(GMAD::Element const* el);
 
  static BDSBeamPipeInfo* PrepareBeamPipeInfo(GMAD::Element const* el,
                                              const G4ThreeVector& inputFaceNormal  = G4ThreeVector(0,0,-1),
                                              const G4ThreeVector& outputFaceNormal = G4ThreeVector(0,0,1));
 
  static BDSBeamPipeInfo* PrepareBeamPipeInfo(GMAD::Element const* el,
                                              G4double angleIn,
                                              G4double angleOut);
 
  static G4bool YokeOnLeft(const GMAD::Element*     el,
                           const BDSMagnetStrength* st);
 
  static G4double PrepareHorizontalWidth(GMAD::Element const* el,
                                         G4double defaultHorizontalWidth = -1);
 
  static G4double ScalingFieldOuter(const GMAD::Element* ele);
 
  static BDSFieldInfo* PrepareMagnetOuterFieldInfo(const BDSMagnetStrength*  vacuumSt,
                                                   const BDSFieldType&       fieldType,
                                                   const BDSBeamPipeInfo*    bpInfo,
                                                   const BDSMagnetOuterInfo* outerInfo,
                                                   const G4Transform3D&      fieldTransform,
                                                   const BDSIntegratorSet*   integratorSetIn,
                                                   G4double                  brhoIn,
                                                   G4double                  outerFieldScaling = 1.0,
                                                   BDSModulatorInfo*         modulatorInfo = nullptr);
  
  static BDSMagnetOuterInfo* PrepareMagnetOuterInfo(const G4String&          elementNameIn,
                                                    const GMAD::Element*     el,
                                                    const BDSMagnetStrength* st,
                                                    const BDSBeamPipeInfo*   beamPipe,
                                                    G4double defaultHorizontalWidth    = -1,
                                                    G4double defaultVHRatio            = 1.0,
                                                    G4double defaultCoilWidthFraction  = -1,
                                                    G4double defaultCoilHeightFraction = -1);
 
  static BDSMagnetGeometryType MagnetGeometryType(const GMAD::Element* el);
 
  static BDSMagnetOuterInfo* PrepareMagnetOuterInfo(const G4String&        elementNameIn,
                                                    const GMAD::Element*   el,
                                                    const G4double         angleIn,
                                                    const G4double         angleOut,
                                                    const BDSBeamPipeInfo* beamPipe,
                                                    const G4bool   yokeOnLeft                = false,
                                                    G4double       defaultHorizontalWidth    = -1,
                                                    G4double       defaultVHRatio            = -1,
                                                    G4double       defaultCoilWidthFraction  = -1,
                                                    G4double       defaultCoilHeightFraction = -1);
 
  static G4Colour* PrepareColour(GMAD::Element const* element, const G4Material* material = nullptr);
 
  static G4Material* PrepareMaterial(GMAD::Element const* element,
                                     const G4String& defaultMaterialName);
 
  static G4Material* PrepareMaterial(GMAD::Element const* element);
 
  static G4Material* PrepareTipMaterial(GMAD::Element const* element,
                                     const G4String& defaultMaterialName);
 
  static G4Material* PrepareTipMaterial(GMAD::Element const* element);
 
  static void CheckBendLengthAngleWidthCombo(G4double arcLength,
                                             G4double angle,
                                             G4double horizontalWidth,
                                             const G4String& name = "not given");
 
  static void PoleFaceRotationsNotTooLarge(const GMAD::Element* el,
                                           G4double       maxAngle = 0.5*CLHEP::halfpi);
 
  static G4double EFieldFromElement(GMAD::Element const* el,
                                    BDSFieldType fieldType,
                                    G4double cavityLength,
                                    const BDSParticleDefinition& incomingParticle);
 
  static void CalculateAngleAndFieldRBend(const GMAD::Element* el,
                                          G4double brhoIn,
                                          G4double& arcLength,
                                          G4double& chordLength,
                                          G4double& field,
                                          G4double& angle);
 
  BDSCrystalInfo* PrepareCrystalInfo(const G4String& crystalName) const;
 
private:
  BDSComponentFactory() = delete;
 
  BDSComponentFactoryUser* userComponentFactory; 
  G4double lengthSafety;      
  G4double thinElementLength; 
  G4bool includeFringeFields; 
  G4bool yokeFields;          
  BDSModulatorInfo* defaultModulator; 
  BDSBeamlineIntegral* integralUpToThisComponent; 
  G4double synchronousTAtMiddleOfThisComponent;
 
  inline void SetBeta0(BDSMagnetStrength* stIn) const {(*stIn)["beta0"] = integralUpToThisComponent->designParticle.Beta();}
  inline G4double BRho() const {return integralUpToThisComponent->designParticle.BRho();}
 
  GMAD::Element const* element = nullptr;
  GMAD::Element const* prevElement = nullptr;
  GMAD::Element const* nextElement = nullptr;
  
  enum class KickerType {horizontal, vertical, general};
  
  enum class RFFieldDirection {x, y, z};
 
  BDSAcceleratorComponent* CreateDrift(G4double angleIn, G4double angleOut);
  BDSAcceleratorComponent* CreateRF(RFFieldDirection direction);
  BDSAcceleratorComponent* CreateSBend();
  BDSAcceleratorComponent* CreateRBend();
  BDSAcceleratorComponent* CreateKicker(KickerType type);
  BDSAcceleratorComponent* CreateQuad();
  BDSAcceleratorComponent* CreateSextupole();
  BDSAcceleratorComponent* CreateOctupole();
  BDSAcceleratorComponent* CreateDecapole();
  BDSAcceleratorComponent* CreateMultipole();
  BDSAcceleratorComponent* CreateThinMultipole(G4double angleIn);
  BDSAcceleratorComponent* CreateElement();
  BDSAcceleratorComponent* CreateSolenoid();
  BDSAcceleratorComponent* CreateParallelTransporter();
  BDSAcceleratorComponent* CreateRectangularCollimator();
  BDSAcceleratorComponent* CreateBeamMaskCollimator();
  BDSAcceleratorComponent* CreateGasCapillary();
  BDSAcceleratorComponent* CreateGasJet();
  BDSAcceleratorComponent* CreateTarget();
  BDSAcceleratorComponent* CreateEllipticalCollimator();
  BDSAcceleratorComponent* CreateJawCollimator();
  BDSAcceleratorComponent* CreateTipJawCollimator();
  BDSAcceleratorComponent* CreateMuonCooler();
  BDSAcceleratorComponent* CreateMuonSpoiler();
  BDSAcceleratorComponent* CreateShield();
  BDSAcceleratorComponent* CreateDegrader();
  BDSAcceleratorComponent* CreateGap();
  BDSAcceleratorComponent* CreateCrystalCollimator();
  BDSAcceleratorComponent* CreateLaser();
  BDSAcceleratorComponent* CreateScreen();
  BDSAcceleratorComponent* CreateTransform3D();
  BDSAcceleratorComponent* CreateWireScanner();
  BDSAcceleratorComponent* CreateRMatrix();
  BDSAcceleratorComponent* CreateThinRMatrix(G4double        angleIn,
                                             const G4String& name);
  BDSAcceleratorComponent* CreateThinRMatrix(G4double angleIn,
                                             BDSMagnetStrength*       stIn,
                                             const G4String&          name,
                                             BDSIntegratorType        intType = BDSIntegratorType::rmatrixthin,
                                             BDSFieldType             fieldType = BDSFieldType::rmatrix,
                                             G4double                 beamPipeRadius = 0,
                                             BDSModulatorInfo*        fieldModulator = nullptr);
  BDSAcceleratorComponent* CreateUndulator();
  BDSAcceleratorComponent* CreateDump();
  BDSAcceleratorComponent* CreateLaserwire(G4double currentArcLength);
 
#ifdef USE_DICOM
  BDSAcceleratorComponent* CreateCT();
#endif
  BDSAcceleratorComponent* CreateCavityFringe(G4double                 angleIn,
                                              BDSMagnetStrength*       stIn,
                                              const G4String&          name,
                                              G4double                 irisRadius,
                                              BDSModulatorInfo*        fieldModulator = nullptr);
  BDSAcceleratorComponent* CreateGaborLens();
#ifdef USE_AWAKE
  BDSAcceleratorComponent* CreateAwakeScreen();
  BDSAcceleratorComponent* CreateAwakeSpectrometer();
#endif
 
  BDSMagnet* CreateMagnet(const GMAD::Element* el,
                          BDSMagnetStrength*   st,
                          BDSFieldType         fieldType,
                          BDSMagnetType        magnetType,
                          G4double             angle = 0.0,
                          const G4String&      nameSuffix = "") const;
 
  G4bool HasSufficientMinimumLength(GMAD::Element const* el,
                                    G4bool               printWarning = true);
 
  G4Material* PrepareVacuumMaterial(GMAD::Element const* el) const;
  
  void PrepareCavityModels();
 
  void PrepareColours();
 
  void PrepareCrystals();
 
  void PrepareLasers();
 
  BDSLaser* PrepareLaser(GMAD::Element const* el) const;
 
  BDSCavityInfo* PrepareCavityModelInfo(GMAD::Element const* el,
                                        G4double             frequency) const;
 
  BDSCavityInfo* PrepareCavityModelInfoForElement(GMAD::Element const* el,
                                                  G4double             frequency) const;
 
  BDSMagnetStrength* PrepareCavityStrength(GMAD::Element const* el,
                                           BDSFieldType         fieldType,
                                           G4double             cavityLength,
                                           BDSMagnetStrength*&  fringeIn,
                                           BDSMagnetStrength*&  fringeOut) const;
 
  void SetFieldDefinitions(GMAD::Element const* el,
                           BDSAcceleratorComponent* component) const;
 
  void SetModulatorDefinition(GMAD::Element const* el,
                              BDSFieldInfo* info) const;
  
  BDSMagnetStrength* PrepareMagnetStrengthForMultipoles(GMAD::Element const* el) const;
 
  BDSMagnetStrength* PrepareMagnetStrengthForRMatrix(GMAD::Element const* el) const;
 
  std::map<G4String, BDSCavityInfo*> cavityInfos;
 
  std::map<G4String, BDSCrystalInfo*> crystalInfos;
 
  std::map<G4String, BDSLaser*> lasers;
 
  const BDSIntegratorSet* integratorSet;
 
  const BDSIntegratorSetType integratorSetType;
 
  G4double FieldFromAngle(const G4double angle,
                          const G4double arcLength) const;
 
  G4double AngleFromField(const G4double field,
                          const G4double arcLength) const;
 
  void CalculateAngleAndFieldSBend(GMAD::Element const* el,
                                   G4double&            angle,
                                   G4double&            field) const;
 
  G4double BendAngle(const GMAD::Element* el) const;
 
  G4double OutgoingFaceAngle(const GMAD::Element* el) const;
 
  G4double IncomingFaceAngle(const GMAD::Element* el) const;
 
  BDSModulatorInfo* ModulatorDefinition(const GMAD::Element* el, G4bool inDevelopment=false) const; // TBC
 
  void INDEVELOPMENTERROR() const;
 
  void GetKickValue(G4double& hkick,
                    G4double& vkick,
                    const KickerType type) const;
 
  void CalculateGaborLensStrength(BDSMagnetStrength* st) const;
 
  std::map<G4String, G4int> modifiedElements;
 
  G4String elementName;
 
  static G4bool coloursInitialised;
};
#endif