MonopoleTransportation.h

Go to the documentation of this file.

//
// =======================================================================
//
// Class MonopoleTransportation
//
// Created:  3 May 2010, J. Apostolakis, B. Bozsogi 
//                       G4MonopoleTransportation class for
//                       Geant4 extended example "monopole"
//
// Adopted for CMSSW by V.Ivanchenko 30 April 2018
// from Geant4 global tag geant4-10-04-ref-03                   
//
// =======================================================================
// 
// Class description:
//
// G4MonopoleTransportation is a process responsible for the transportation of 
// magnetic monopoles, i.e. the geometrical propagation encountering the 
// geometrical sub-volumes of the detectors.
// It is also tasked with part of updating the "safety".
// For monopoles, uses a different equation of motion and ignores energy
// conservation. 
//

#ifndef SimG4Core_PhysicsLists_MonopoleTransportation_h
#define SimG4Core_PhysicsLists_MonopoleTransportation_h 1

#include "G4VProcess.hh"
#include "G4FieldManager.hh"

#include "G4Navigator.hh"
#include "G4TransportationManager.hh"
#include "G4PropagatorInField.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ParticleChangeForTransport.hh"
#include "CLHEP/Units/SystemOfUnits.h"

class G4SafetyHelper; 
class Monopole;
class CMSFieldManager;

namespace sim {
  class ChordFinderSetter;
}

#include <memory>

class MonopoleTransportation : public G4VProcess 
{
public: 

  MonopoleTransportation(const Monopole* p, sim::ChordFinderSetter * cfs,
                         G4int verbosityLevel= 1);
  ~MonopoleTransportation() override; 

  G4double AlongStepGetPhysicalInteractionLength(
                             const G4Track& track,
                                   G4double  previousStepSize,
                                   G4double  currentMinimumStep, 
                                   G4double& currentSafety,
                                   G4GPILSelection* selection
                             ) override;

  G4VParticleChange* AlongStepDoIt(
                             const G4Track& track,
                             const G4Step& stepData
                       ) override;

  G4VParticleChange* PostStepDoIt(
                             const G4Track& track,
                             const G4Step&  stepData
                      ) override;
  // Responsible for the relocation.

  G4double PostStepGetPhysicalInteractionLength(
                             const G4Track& ,
                             G4double   previousStepSize,
                             G4ForceCondition* pForceCond
                            ) override;
  // Forces the PostStepDoIt action to be called, 
  // but does not limit the step.

  G4PropagatorInField* GetPropagatorInField();
  void SetPropagatorInField( G4PropagatorInField* pFieldPropagator);
  // Access/set the assistant class that Propagate in a Field.

  inline G4double GetThresholdWarningEnergy() const; 
  inline G4double GetThresholdImportantEnergy() const; 
  inline G4int GetThresholdTrials() const; 

  inline void SetThresholdWarningEnergy( G4double newEnWarn ); 
  inline void SetThresholdImportantEnergy( G4double newEnImp ); 
  inline void SetThresholdTrials(G4int newMaxTrials ); 

  // Get/Set parameters for killing loopers: 
  //   Above 'important' energy a 'looping' particle in field will 
  //   *NOT* be abandoned, except after fThresholdTrials attempts.
  // Below Warning energy, no verbosity for looping particles is issued

  inline G4double GetMaxEnergyKilled() const; 
  inline G4double GetSumEnergyKilled() const;
  inline void ResetKilledStatistics( G4int report = 1);      
  // Statistics for tracks killed (currently due to looping in field)

  inline void EnableShortStepOptimisation(G4bool optimise=true); 
  // Whether short steps < safety will avoid to call Navigator (if field=0)

  G4double AtRestGetPhysicalInteractionLength(
                             const G4Track& ,
                             G4ForceCondition* 
                            ) override { return -1.0; };
  // No operation in  AtRestDoIt.

  G4VParticleChange* AtRestDoIt(
                             const G4Track& ,
                             const G4Step&
                            ) override {return nullptr;};
  // No operation in  AtRestDoIt.

  void StartTracking(G4Track* aTrack) override;
  // Reset state for new (potentially resumed) track 

protected:

  G4bool               DoesGlobalFieldExist();
  // Checks whether a field exists for the "global" field manager.

private:

  const Monopole* fParticleDef;
  
  sim::ChordFinderSetter *fChordFinderSetter;;
  CMSFieldManager*     fieldMgrCMS;
    
  G4Navigator*         fLinearNavigator;
  G4PropagatorInField* fFieldPropagator;
  // The Propagators used to transport the particle

  G4ThreeVector        fTransportEndPosition;
  G4ThreeVector        fTransportEndMomentumDir;
  G4double             fTransportEndKineticEnergy;
  G4ThreeVector        fTransportEndSpin;
  G4bool               fMomentumChanged;

  G4bool               fEndGlobalTimeComputed; 
  G4double             fCandidateEndGlobalTime;
  // The particle's state after this Step, Store for DoIt

  G4bool               fParticleIsLooping;

  G4TouchableHandle    fCurrentTouchableHandle;

  G4bool fGeometryLimitedStep;
  // Flag to determine whether a boundary was reached.

  G4ThreeVector  fPreviousSftOrigin;
  G4double       fPreviousSafety; 
  // Remember last safety origin & value.

  G4ParticleChangeForTransport fParticleChange;
  // New ParticleChange

  G4double endpointDistance;

  // Thresholds for looping particles: 
  // 
  G4double fThreshold_Warning_Energy;     //  Warn above this energy
  G4double fThreshold_Important_Energy;   //  Hesitate above this
  G4int    fThresholdTrials;              //    for this no of trials
  // Above 'important' energy a 'looping' particle in field will 
  //   *NOT* be abandoned, except after fThresholdTrials attempts.

  // Counter for steps in which particle reports 'looping',
  //   if it is above 'Important' Energy 
  G4int    fNoLooperTrials; 
  // Statistics for tracks abandoned
  G4double fSumEnergyKilled;
  G4double fMaxEnergyKilled;

  // Whether to avoid calling G4Navigator for short step ( < safety)
  //   If using it, the safety estimate for endpoint will likely be smaller.
  G4bool   fShortStepOptimisation; 

  G4SafetyHelper* fpSafetyHelper;  // To pass it the safety value obtained

};

inline void
MonopoleTransportation::SetPropagatorInField( G4PropagatorInField* pFieldPropagator)
{
  fFieldPropagator= pFieldPropagator;
}

inline G4PropagatorInField* MonopoleTransportation::GetPropagatorInField()
{
  return fFieldPropagator;
}

inline G4bool MonopoleTransportation::DoesGlobalFieldExist()
{
  G4TransportationManager* transportMgr;
  transportMgr= G4TransportationManager::GetTransportationManager();

  // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
  // return fFieldExists;
  return transportMgr->GetFieldManager()->DoesFieldExist();
}

inline G4double MonopoleTransportation::GetThresholdWarningEnergy() const
{
  return fThreshold_Warning_Energy;
}
 
inline G4double MonopoleTransportation::GetThresholdImportantEnergy() const
{ 
  return fThreshold_Important_Energy;
} 

inline G4int MonopoleTransportation::GetThresholdTrials() const
{
  return fThresholdTrials;
}

inline void MonopoleTransportation::SetThresholdWarningEnergy( G4double newEnWarn )
{
  fThreshold_Warning_Energy= newEnWarn;
}

inline void MonopoleTransportation::SetThresholdImportantEnergy( G4double newEnImp )
{
  fThreshold_Important_Energy = newEnImp; 
}

inline void MonopoleTransportation::SetThresholdTrials(G4int newMaxTrials )
{
  fThresholdTrials = newMaxTrials; 
}

// Get/Set parameters for killing loopers: 
//   Above 'important' energy a 'looping' particle in field will 
//   *NOT* be abandoned, except after fThresholdTrials attempts.
// Below Warning energy, no verbosity for looping particles is issued

inline G4double MonopoleTransportation::GetMaxEnergyKilled() const
{
  return fMaxEnergyKilled; 
}

inline G4double MonopoleTransportation::GetSumEnergyKilled() const
{
  return fSumEnergyKilled;
}

inline void MonopoleTransportation::ResetKilledStatistics(G4int report)
{
  if( report ) { 
    G4cout << " MonopoleTransportation: Statistics for looping particles " << G4endl;
    G4cout << "   Sum of energy of loopers killed: " <<  fSumEnergyKilled << G4endl;
    G4cout << "   Max energy of loopers killed: " <<  fMaxEnergyKilled << G4endl;
  } 

  fSumEnergyKilled= 0;
  fMaxEnergyKilled= -1.0*CLHEP::GeV;
}
// Statistics for tracks killed (currently due to looping in field)

inline void 
MonopoleTransportation::EnableShortStepOptimisation(G4bool optimiseShortStep)
{ 
  fShortStepOptimisation=optimiseShortStep;
}

#endif