BDSTrajectoryPoint.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 BDSTRAJECTORYPOINT_H
#define BDSTRAJECTORYPOINT_H
#include "BDSTrajectoryPointIon.hh"
#include "BDSTrajectoryPointLocal.hh"
#include "BDSTrajectoryPointLink.hh"
 
#include "globals.hh" // geant4 types / globals
#include "G4Allocator.hh"
#include "G4TrajectoryPoint.hh"
 
#include <ostream>
 
class G4Material;
class G4Step;
class G4Track;
 
class BDSAuxiliaryNavigator;
class BDSBeamline;
 
class BDSTrajectoryPoint: public G4TrajectoryPoint
{
public:
  BDSTrajectoryPoint();
  
  BDSTrajectoryPoint(const G4Step* step,
                     G4bool storeExtrasLocalIn,
                     G4bool storeExtrasLinkIn,
                     G4bool storeExtrasIonIn);
  
  BDSTrajectoryPoint(const G4Track* track,
                     G4bool storeExtrasLocalIn,
                     G4bool storeExtrasLinkIn,
                     G4bool storeExtrasIonIn);
  
  BDSTrajectoryPoint(const BDSTrajectoryPoint& other);
 
  virtual ~BDSTrajectoryPoint();
 
  inline void *operator new(size_t);
  inline void operator delete(void *aTrajectoryPoint);
  inline int operator==(const BDSTrajectoryPoint& right) const {return (this==&right);};
 
  inline void DeleteExtraLocal() {delete extraLocal; extraLocal = nullptr;}
  inline void DeleteExtraLinks() {delete extraLink;  extraLink  = nullptr;}
  inline void DeleteExtraIon()   {delete extraIon;   extraIon   = nullptr;}
 
  G4bool IsScatteringPoint() const;
 
  G4bool NotTransportationLimitedStep() const;
  
  static G4bool IsScatteringPoint(const G4Step* step);
  static G4bool IsScatteringPoint(G4int    postProcessType,
                                  G4int    postProcessSubType,
                                  G4double totalEnergyDeposit);
  
  inline G4int    GetPreProcessType()          const {return preProcessType;}
  inline G4int    GetPreProcessSubType()       const {return preProcessSubType;}
  inline G4int    GetPostProcessType()         const {return postProcessType;}
  inline G4int    GetPostProcessSubType()      const {return postProcessSubType;}
  inline G4double GetPreWeight()               const {return preWeight;}
  inline G4double GetPostWeight()              const {return postWeight;}
  inline G4double GetPreEnergy()               const {return preEnergy;}
  inline G4double GetPostEnergy()              const {return postEnergy;}
  inline G4double GetEnergyDeposit()           const {return energyDeposit;}
  inline G4ThreeVector GetPreMomentum()        const {return preMomentum;}
  inline G4ThreeVector GetPostMomentum()       const {return postMomentum;}
  inline G4double GetPreS()                    const {return preS;}
  inline G4double GetPostS()                   const {return postS;}
  inline G4double GetPreGlobalTime()           const {return preGlobalTime;}
  inline G4double GetPostGlobalTime()          const {return postGlobalTime;}
  inline G4int    GetBeamLineIndex()           const {return beamlineIndex;}
  inline BDSBeamline* GetBeamLine()            const {return beamline;}
  inline G4ThreeVector GetPrePosLocal()        const {return prePosLocal;}
  inline G4ThreeVector GetPostPosLocal()       const {return postPosLocal;}
  inline G4Material* GetMaterial()             const {return material;}
  
  inline void SetMaterial(G4Material* materialIn) {material = materialIn;}
 
  inline G4ThreeVector GetPositionLocal() const {return extraLocal ? extraLocal->positionLocal : G4ThreeVector();}
  inline G4ThreeVector GetMomentumLocal() const {return extraLocal ? extraLocal->momentumLocal : G4ThreeVector();}
 
  inline G4int      GetCharge()         const {return extraLink ? extraLink->charge        : 0;}
  inline G4double   GetKineticEnergy()  const {return preEnergy;}
  inline G4int      GetTurnsTaken()     const {return extraLink ? extraLink->turnsTaken    : 0;}
  inline G4double   GetMass()           const {return extraLink ? extraLink->mass          : 0;}
  inline G4double   GetRigidity()       const {return extraLink ? extraLink->rigidity      : 0;}
 
  inline G4bool   GetIsIon()      const {return extraIon ? extraIon->isIon      : false;}
  inline G4int    GetIonA()       const {return extraIon ? extraIon->ionA       : 0;}
  inline G4int    GetIonZ()       const {return extraIon ? extraIon->ionZ       : 0;}
  inline G4int    GetNElectrons() const {return extraIon ? extraIon->nElectrons : 0;}
  
  G4double PrePosR()  const;
  G4double PostPosR() const;
 
  friend std::ostream& operator<< (std::ostream &out, BDSTrajectoryPoint const &p);
 
  // logic taken from BDSExtent - implement only one operator; rest come for free
  inline G4bool operator< (const BDSTrajectoryPoint& other) const;
  inline G4bool operator> (const BDSTrajectoryPoint& other) const {return other < (*this);}
  inline G4bool operator<=(const BDSTrajectoryPoint& other) const {return !((*this) > other);}
  inline G4bool operator>=(const BDSTrajectoryPoint& other) const {return !((*this) < other);}
 
  BDSTrajectoryPointLocal* extraLocal;
  BDSTrajectoryPointLink*  extraLink;
  BDSTrajectoryPointIon*   extraIon;
  
  static G4double dEThresholdForScattering;
 
private:
  void InitialiseVariables();
 
  void StoreExtrasLink(const G4Track* track);
 
  void StoreExtrasIon(const G4Track* track);
  
  G4int preProcessType;           
  G4int preProcessSubType;        
  G4int postProcessType;          
  G4int postProcessSubType;       
 
  G4double preWeight;             
  G4double postWeight;            
  G4double preEnergy;             
  G4double postEnergy;            
  G4ThreeVector preMomentum;      
  G4ThreeVector postMomentum;     
  G4double energyDeposit;         
  G4double preS;                  
  G4double postS;                 
  G4double preGlobalTime;         
  G4double postGlobalTime;        
  G4int    beamlineIndex;         
  BDSBeamline* beamline;          
  G4ThreeVector prePosLocal;      
  G4ThreeVector postPosLocal;     
  G4Material*   material;         
 
  static BDSAuxiliaryNavigator* auxNavigator;
};
 
extern G4Allocator<BDSTrajectoryPoint> bdsTrajectoryPointAllocator;
 
inline void* BDSTrajectoryPoint::operator new(size_t)
{
  void *aTrajectoryPoint;
  aTrajectoryPoint = (void *) bdsTrajectoryPointAllocator.MallocSingle();
  return aTrajectoryPoint;
}
 
inline void BDSTrajectoryPoint::operator delete(void *aTrajectoryPoint)
{
  bdsTrajectoryPointAllocator.FreeSingle((BDSTrajectoryPoint *) aTrajectoryPoint);
}
 
inline G4bool BDSTrajectoryPoint::operator< (const BDSTrajectoryPoint& other) const
{
  // can't test position without knowledge of beam line direction etc - too difficult / inaccurate
  // for now, this is simplistic
  // TODO deal with multiple beam lines and s coordinate change at join point
  return (preS < other.preS) && (preGlobalTime < other.preGlobalTime);
}
 
#endif