BDSBeamline.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 BDSBEAMLINE_H
#define BDSBEAMLINE_H
 
#include "globals.hh" // geant4 globals / types
#include "G4ThreeVector.hh"
#include "G4Transform3D.hh"
 
#include "BDSSamplerType.hh"
#include "BDSExtentGlobal.hh"
 
#include <iterator>
#include <ostream>
#include <set>
#include <vector>
 
class BDSAcceleratorComponent;
class BDSBeamlineElement;
class BDSBeamlineIntegral;
class BDSSamplerInfo;
class BDSSimpleComponent;
class BDSTiltOffset;
class BDSTransform3D;
namespace CLHEP {
  class HepRotation;
}
typedef CLHEP::HepRotation G4RotationMatrix;
 
class BDSBeamline
{
private:
  typedef std::vector<BDSBeamlineElement*> BeamlineVector;
 
  BeamlineVector beamline;
  
public:  
  BDSBeamline& operator=(const BDSBeamline&) = delete;
  BDSBeamline(BDSBeamline&) = delete;
  
  BDSBeamline(const G4ThreeVector& initialGlobalPosition = G4ThreeVector(0,0,0),
              G4RotationMatrix*    initialGlobalRotation = nullptr,
              G4double             initialSIn            = 0.0);
 
  explicit BDSBeamline(G4Transform3D initialTransform,
                       G4double      initialSIn       = 0.0);
  
  ~BDSBeamline();
 
  void AddComponent(BDSAcceleratorComponent*  component,
                    BDSTiltOffset*  tiltOffset  = nullptr,
                    BDSSamplerInfo* samplerInfo = nullptr,
                    const BDSBeamlineIntegral* beamlineIntegral = nullptr);
 
  void ApplyTransform3D(BDSTransform3D* component);
 
  void AddBeamlineElement(BDSBeamlineElement* element);
 
  void PrintAllComponents(std::ostream& out) const;
 
  void UpdateExtents(BDSBeamlineElement* element);
 
  inline const BDSBeamlineElement* at(int iElement) const { return beamline.at(iElement);}
 
  inline const BDSBeamlineElement* GetFirstItem() const {return front();} 
 
  inline const BDSBeamlineElement* GetLastItem() const {return back();}
 
  const BDSBeamlineElement* GetElement(G4String acceleratorComponentName, G4int i = 0) const;
 
  G4Transform3D GetTransformForElement(const G4String& acceleratorComponentName, G4int i = 0) const;
  
  inline G4double     GetTotalChordLength() const {return totalChordLength;}
 
  inline G4double     GetTotalArcLength() const {return totalArcLength;}
 
  inline G4double GetTotalAngle() const {return totalAngle;}
 
  G4bool ElementAnglesSumToCircle() const;
 
  BeamlineVector::size_type size() const {return beamline.size();}
 
  G4ThreeVector GetMaximumExtentPositive() const {return maximumExtentPositive;}
 
  G4ThreeVector GetMaximumExtentNegative() const {return maximumExtentNegative;}
 
  G4ThreeVector GetMaximumExtentAbsolute() const;
 
  BDSExtentGlobal GetExtentGlobal() const;
 
  typedef BeamlineVector::iterator       iterator;
  typedef BeamlineVector::const_iterator const_iterator;
  typedef BeamlineVector::reverse_iterator reverse_iterator;
  typedef BeamlineVector::const_reverse_iterator const_reverse_iterator;
  iterator               begin()        {return beamline.begin();}
  iterator               end()          {return beamline.end();}
  const_iterator         begin()  const {return beamline.begin();}
  const_iterator         end()    const {return beamline.end();}
  reverse_iterator       rbegin()       {return beamline.rbegin();}
  reverse_iterator       rend()         {return beamline.rend();}
  const_reverse_iterator rbegin() const {return beamline.rbegin();}
  const_reverse_iterator rend()   const {return beamline.rend();}
  G4bool                 empty()  const {return beamline.empty();}
 
  G4Transform3D GetGlobalEuclideanTransform(G4double s,
                                            G4double x = 0,
                                            G4double y = 0,
                                            G4int* indexOfFoundElement = nullptr) const;
 
  const BDSBeamlineElement* GetElementFromGlobalS(G4double S,
                                                  G4int* indexOfFoundElement = nullptr) const;
  
  const_iterator FindFromS(G4double S) const;
 
  std::vector<G4double> GetEdgeSPositions() const;
 
  G4double GetSMinimum() const {return sInitial;}
  G4double GetSMaximum() const {return sMaximum;}
 
  const BDSBeamlineElement* GetPrevious(const BDSBeamlineElement* element) const;
  const BDSBeamlineElement* GetNext(const BDSBeamlineElement* element) const;
 
  const BDSBeamlineElement* GetPrevious(G4int index) const;
  const BDSBeamlineElement* GetNext(G4int index) const;
  
  // Accessors in a similar style to std::vector
  inline BDSBeamlineElement* front() const {return beamline.front();}
  inline BDSBeamlineElement* back() const {return beamline.back();}
  
  friend std::ostream& operator<< (std::ostream &out, BDSBeamline const &bl);
 
  void PrintMemoryConsumption() const;
 
  BDSBeamlineElement* ProvideEndPieceElementBefore(BDSSimpleComponent* endPiece,
                                                   G4int    index) const;
  BDSBeamlineElement* ProvideEndPieceElementAfter(BDSSimpleComponent* endPiece,
                                                  G4int               index,
                                                  G4bool              flip = false) const;
 
  G4bool IndexOK(G4int index) const;
 
  static G4double PaddingLength() {return paddingLength;}
 
  std::vector<G4int> GetIndicesOfElementsOfType(const G4String& type) const;
 
  std::vector<G4int> GetIndicesOfElementsOfType(const std::set<G4String>& types) const;
 
  std::vector<G4int> GetIndicesOfCollimators() const;
  
private:
  void AddSingleComponent(BDSAcceleratorComponent* component,
                          BDSTiltOffset*           tiltOffset  = nullptr,
                          BDSSamplerInfo*          samplerInfo = nullptr,
                          const BDSBeamlineIntegral* beamlineIntegral = nullptr);
  
  void RegisterElement(BDSBeamlineElement* element);
 
  G4double sInitial; 
  G4double sMaximum;
 
  G4double totalChordLength;
  G4double totalArcLength;
  G4double totalAngle;
 
  G4ThreeVector maximumExtentPositive; 
  G4ThreeVector maximumExtentNegative; 
 
  G4RotationMatrix* previousReferenceRotationEnd;
 
  G4ThreeVector previousReferencePositionEnd;
 
  G4double previousSPositionEnd;
 
  G4bool transformHasJustBeenApplied;
 
  static G4double paddingLength;
 
  std::map<G4String, BDSBeamlineElement*> components;
 
  std::vector<G4double> sEnd;
};
 
#endif