BDSBeamlineElement.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 BDSBEAMLINEELEMENT_H
#define BDSBEAMLINEELEMENT_H
 
#include "BDSAcceleratorComponent.hh"
#include "BDSExtent.hh"
#include "BDSExtentGlobal.hh"
#include "BDSSamplerInfo.hh"
#include "BDSSamplerType.hh"
#include "BDSTiltOffset.hh"
 
#include "globals.hh" // geant4 globals / types
#include "G4ThreeVector.hh"
 
#include <ostream>
#include <set>
 
namespace HepGeom {
  class Transform3D;
}
typedef HepGeom::Transform3D G4Transform3D;
namespace CLHEP {
  class HepRotation;
}
typedef CLHEP::HepRotation G4RotationMatrix;
class G4VPhysicalVolume;
 
class BDSBeamlineElement
{
public:
  BDSBeamlineElement() = delete;
  BDSBeamlineElement(const BDSBeamlineElement&) = delete;
  BDSBeamlineElement& operator=(const BDSBeamlineElement&) = delete;
  BDSBeamlineElement(BDSAcceleratorComponent* componentIn,
                     const G4ThreeVector&     positionStartIn,
                     const G4ThreeVector&     positionMiddleIn,
                     const G4ThreeVector&     positionEndIn,
                     G4RotationMatrix*        rotationStartIn,
                     G4RotationMatrix*        rotationMiddleIn,
                     G4RotationMatrix*        rotationEndIn,
                     const G4ThreeVector&     referencePositionStartIn,
                     const G4ThreeVector&     referencePositionMiddleIn,
                     const G4ThreeVector&     referencePositionEndIn,
                     G4RotationMatrix*        referenceRotationStartIn,
                     G4RotationMatrix*        referenceRotationMiddleIn,
                     G4RotationMatrix*        referenceRotationEndIn,
                     G4double                 sPositionStartIn,
                     G4double                 sPositionMiddleIn,
                     G4double                 sPositionEndIn,
                     BDSTiltOffset*           tiltOffsetIn  = nullptr,
                     BDSSamplerInfo*          samplerInfoIn = nullptr,
                     G4int                    indexIn       = -1);
 
  ~BDSBeamlineElement();
 
  std::set<G4VPhysicalVolume*> PlaceElement(const G4String&    pvName,
                                            G4VPhysicalVolume* containerPV,
                                            G4bool             useCLPlacementTransform,
                                            G4int              copyNumber,
                                            G4bool             checkOverlaps) const;
 
  static std::set<G4VPhysicalVolume*> GetPVsFromAssembly(G4AssemblyVolume* av);
  
  inline BDSAcceleratorComponent* GetAcceleratorComponent() const {return component;}
  inline G4String          GetName()                      const {return component->GetName();}
  inline G4String          GetType()                      const {return component->GetType();}
  inline G4double          GetArcLength()                 const {return component->GetArcLength();}
  inline G4double          GetChordLength()               const {return component->GetChordLength();}
  inline G4double          GetAngle()                     const {return component->GetAngle();}
  inline BDSBeamPipeInfo*  GetBeamPipeInfo()              const {return component->GetBeamPipeInfo();}
  inline BDSExtent         GetExtent()                    const {return component->GetExtent();}
  inline G4String          GetPlacementName()             const {return placementName;}
  inline G4int             GetCopyNo()                    const {return copyNumber;}
  inline G4ThreeVector     GetPositionStart()             const {return positionStart;}
  inline G4ThreeVector     GetPositionMiddle()            const {return positionMiddle;}
  inline G4ThreeVector     GetPositionEnd()               const {return positionEnd;}
  inline G4RotationMatrix* GetRotationStart()             const {return rotationStart;}
  inline G4RotationMatrix* GetRotationMiddle()            const {return rotationMiddle;}
  inline G4RotationMatrix* GetRotationEnd()               const {return rotationEnd;}
  inline G4ThreeVector     GetReferencePositionStart()    const {return referencePositionStart;}
  inline G4ThreeVector     GetReferencePositionMiddle()   const {return referencePositionMiddle;}
  inline G4ThreeVector     GetReferencePositionEnd()      const {return referencePositionEnd;}
  inline G4RotationMatrix* GetReferenceRotationStart()    const {return referenceRotationStart;}
  inline G4RotationMatrix* GetReferenceRotationMiddle()   const {return referenceRotationMiddle;}
  inline G4RotationMatrix* GetReferenceRotationEnd()      const {return referenceRotationEnd;}
  inline G4double          GetSPositionStart()            const {return sPositionStart;}
  inline G4double          GetSPositionMiddle()           const {return sPositionMiddle;}
  inline G4double          GetSPositionEnd()              const {return sPositionEnd;}
  inline BDSTiltOffset*    GetTiltOffset()                const {return tiltOffset;}
  inline G4Transform3D*    GetPlacementTransform()        const {return placementTransform;}
  inline G4Transform3D*    GetPlacementTransformCL()      const {return placementTransformCL;}
  inline BDSSamplerInfo*   GetSamplerInfo()               const {return samplerInfo;}
  inline BDSSamplerType    GetSamplerType()               const {return samplerInfo ? samplerInfo->samplerType : BDSSamplerType::none;}
  inline G4Transform3D*    GetSamplerPlacementTransform() const {return samplerPlacementTransform;}
  inline G4int             GetIndex()                     const {return index;}
  inline G4String          GetMaterial()                  const {return component->Material();}
 
  BDSExtentGlobal GetExtentGlobal() const;
 
  G4ThreeVector InputFaceNormal()  const;
  G4ThreeVector OutputFaceNormal() const;
 
  G4bool AngledInputFace()  const {return component->AngledInputFace();}
  G4bool AngledOutputFace() const {return component->AngledOutputFace();}
  
  inline G4double GetTilt() const {return tiltOffset ? tiltOffset->GetTilt() : 0.0;}
  
  inline void SetReferencePositionEnd(G4ThreeVector     newReferencePositionEnd);
  inline void SetReferenceRotationEnd(G4RotationMatrix* newReferenceRotatonEnd);
  
  void UpdateSamplerPlacementTransform(const G4Transform3D& tranfsormIn);
 
  friend std::ostream& operator<< (std::ostream& out, BDSBeamlineElement const &element);
 
  G4bool Overlaps(const BDSBeamlineElement* otherElement) const;
  
private:
  BDSAcceleratorComponent* component;
 
  G4String          placementName;
  
  G4int             copyNumber;
  
  G4ThreeVector     positionStart;
  G4ThreeVector     positionMiddle;
  G4ThreeVector     positionEnd;
  
  G4RotationMatrix* rotationStart;
  G4RotationMatrix* rotationMiddle;
  G4RotationMatrix* rotationEnd;
 
  G4ThreeVector     referencePositionStart;
  G4ThreeVector     referencePositionMiddle;
  G4ThreeVector     referencePositionEnd;
  
  G4RotationMatrix* referenceRotationStart;
  G4RotationMatrix* referenceRotationMiddle;
  G4RotationMatrix* referenceRotationEnd;
 
  G4double          sPositionStart;
  G4double          sPositionMiddle;
  G4double          sPositionEnd;
 
  BDSTiltOffset* tiltOffset;
 
  G4Transform3D* placementTransform;
 
  G4Transform3D* placementTransformCL;
 
  BDSSamplerInfo* samplerInfo;
 
  G4Transform3D* samplerPlacementTransform;
 
  G4int index;
};
 
#endif