G4BlineTracer Class Reference

#include <Doxymodules_field.h>

Inheritance diagram for G4BlineTracer:

Public Member Functions
	G4BlineTracer ()
	~G4BlineTracer () override
void	BeginOfRunAction (const G4Run *aRun) override
void	EndOfRunAction (const G4Run *aRun) override
void	ComputeBlines (G4int nlines)
void	SetMaxTrackingStep (G4double max_step)
G4BlineEventAction *	GetEventAction ()

Private Member Functions
void	ResetChordFinders ()

Private Attributes
G4BlineTracerMessenger *	fMessenger = nullptr
G4BlineSteppingAction *	fSteppingAction = nullptr
G4BlineEventAction *	fEventAction = nullptr
G4BlinePrimaryGeneratorAction *	fPrimaryGeneratorAction = nullptr
G4double	fMaxTrackingStep = 1000. * CLHEP::m
G4bool	fWas_ResetChordFinders_already_called = false
std::vector< G4ChordFinder * >	fVecChordFinders
std::vector< G4FieldManager * >	fVecFieldManagers
std::vector< G4MagneticField * >	fVecMagneticFields
std::vector< G4BlineEquation * >	fVecEquationOfMotion

Detailed Description

Definition at line 22 of file Doxymodules_field.h.

Constructor & Destructor Documentation

G4BlineTracer()

G4BlineTracer::G4BlineTracer

(

)

Definition at line 60 of file G4BlineTracer.cc.

{
  fMessenger = new G4BlineTracerMessenger(this);
  fSteppingAction = new G4BlineSteppingAction(this) ;
  fEventAction = new G4BlineEventAction(this);
  fPrimaryGeneratorAction = new G4BlinePrimaryGeneratorAction();
}

~G4BlineTracer()

G4BlineTracer::~G4BlineTracer ( )

override

Definition at line 70 of file G4BlineTracer.cc.

{
  delete fMessenger;
  delete fSteppingAction;
  delete fEventAction;
  delete fPrimaryGeneratorAction;
  for (size_t i=0; i< fVecEquationOfMotion.size();i++)
  {
    if (fVecEquationOfMotion[i]) delete fVecEquationOfMotion[i];
    if (fVecChordFinders[i]) delete fVecChordFinders[i];
  }
}

Member Function Documentation

BeginOfRunAction()

void G4BlineTracer::BeginOfRunAction ( const G4Run *  aRun )

override

Definition at line 85 of file G4BlineTracer.cc.

{
}

EndOfRunAction()

void G4BlineTracer::EndOfRunAction ( const G4Run *  aRun )

override

Definition at line 91 of file G4BlineTracer.cc.

{
}

ComputeBlines()

void G4BlineTracer::ComputeBlines

(

G4int

nlines

)

Definition at line 97 of file G4BlineTracer.cc.

{
  //the first time ResetChordFinders should be called
  //
  if (!fWas_ResetChordFinders_already_called)
  {
    ResetChordFinders();
    fWas_ResetChordFinders_already_called=true;
  }
 
  // Replace the user action by the ad-hoc actions for Blines
 
  G4RunManager* theRunManager =  G4RunManager::GetRunManager();
  auto  user_run_action =
    (G4UserRunAction*)theRunManager->GetUserRunAction();
  theRunManager->SetUserAction(this);
 
  auto  user_stepping_action =
    (G4UserSteppingAction*)theRunManager->GetUserSteppingAction();
  theRunManager->SetUserAction(fSteppingAction);
 
  auto  userPrimaryAction =
    (G4VUserPrimaryGeneratorAction*)theRunManager->GetUserPrimaryGeneratorAction();
  if (userPrimaryAction)
    fPrimaryGeneratorAction->SetUserPrimaryAction(userPrimaryAction);
  theRunManager->SetUserAction(fPrimaryGeneratorAction);
 
  auto  user_event_action =
    (G4UserEventAction*)theRunManager->GetUserEventAction();
  theRunManager->SetUserAction(fEventAction);
 
  auto  user_tracking_action =
    (G4UserTrackingAction*)theRunManager->GetUserTrackingAction();
  G4UserTrackingAction* aNullTrackingAction = nullptr;
  theRunManager->SetUserAction(aNullTrackingAction);
 
  auto  user_stacking_action =
    (G4UserStackingAction*)theRunManager->GetUserStackingAction();
  G4UserStackingAction* aNullStackingAction = nullptr;
  theRunManager->SetUserAction(aNullStackingAction);
 
  // replace the user defined chordfinder by the element of fVecChordFinders
 
  std::vector<G4ChordFinder*> user_chord_finders;
  std::vector<G4double> user_largest_acceptable_step;
  for (size_t i=0;i<fVecChordFinders.size();i++)
  {
    user_largest_acceptable_step.push_back(-1.);
    if (fVecChordFinders[i])
    {
      user_chord_finders.push_back(fVecFieldManagers[i]->GetChordFinder());
      fVecChordFinders[i]->SetDeltaChord(user_chord_finders[i]->GetDeltaChord());
      fVecFieldManagers[i]->SetChordFinder(fVecChordFinders[i]);
    }
    else user_chord_finders.push_back(nullptr);
  }
 
  // I have tried to use the smooth line filter ability but I could not obtain
  // a smooth trajectory in the G4TrajectoryContainer after an event
  // Another solution for obtaining a smooth trajectory is to limit
  // the LargestAcceptableStep in the G4PropagatorInField object.
  // This is the solution I used.
 
  // Old solution:
  // G4TransportationManager::GetTransportationManager()
  //     ->GetPropagatorInField()->SetTrajectoryFilter(fTrajectoryFilter);
 
  // New solution:
  // set the largest_acceptable_step to max_step:length
 
  G4TransportationManager* tmanager =
    G4TransportationManager::GetTransportationManager();
  G4double previous_largest_acceptable_step =
    tmanager->GetPropagatorInField()->GetLargestAcceptableStep();
 
  tmanager->GetPropagatorInField()
          ->SetLargestAcceptableStep(fMaxTrackingStep);
 
  // Start the integration of n_of_lines different magnetic field lines
 
  for (G4int il=0; il<n_of_lines;il++)
  {
    // for each magnetic field line we integrate once backward and once
    // forward from the same starting point
 
    // backward integration
 
    for (size_t i=0; i< fVecEquationOfMotion.size();i++)
    {
      if (fVecEquationOfMotion[i])
        fVecEquationOfMotion[i]->SetBackwardDirectionOfIntegration(true);
    }
    theRunManager->BeamOn(1);
 
    // forward integration
 
    for (size_t i=0; i < fVecEquationOfMotion.size();i++)
    {
      if (fVecEquationOfMotion[i])
        fVecEquationOfMotion[i]->SetBackwardDirectionOfIntegration(false);
    }
    theRunManager->BeamOn(1);
  }
 
  // Remove trajectory filter to PropagatorInField
  // It was for old solution when using smooth trajectory filter
 
  // tmanager->GetPropagatorInField()->SetTrajectoryFilter(0);
 
  // back to User defined actions and other parameters
  // -------------------------------------------------
 
  tmanager->GetPropagatorInField()
          ->SetLargestAcceptableStep(previous_largest_acceptable_step);
 
  // return to User actions
 
  theRunManager->SetUserAction(user_run_action);
  theRunManager->SetUserAction(user_event_action);
  theRunManager->SetUserAction(userPrimaryAction);
  theRunManager->SetUserAction(user_stepping_action);
  theRunManager->SetUserAction(user_tracking_action);
  theRunManager->SetUserAction(user_stacking_action);
 
  // set user defined chord finders and largest acceptable step
 
  for (size_t i=0;i<fVecFieldManagers.size();i++)
  {
    if (user_chord_finders[i])
      fVecFieldManagers[i]->SetChordFinder(user_chord_finders[i]);
  }
}

SetMaxTrackingStep()

void G4BlineTracer::SetMaxTrackingStep ( G4double  max_step )

inline

Definition at line 80 of file G4BlineTracer.hh.

       { fMaxTrackingStep=max_step; }

GetEventAction()

G4BlineEventAction * G4BlineTracer::GetEventAction ( )

inline

Definition at line 82 of file G4BlineTracer.hh.

       { return fEventAction; }

ResetChordFinders()

void G4BlineTracer::ResetChordFinders ( )

private

Definition at line 270 of file G4BlineTracer.cc.

{
  for (size_t i=0; i<fVecEquationOfMotion.size();i++)
  {
    delete fVecEquationOfMotion[i];
    delete fVecChordFinders[i];
  }
 
  fVecChordFinders.clear();
  fVecFieldManagers.clear();
  fVecMagneticFields.clear();
  fVecEquationOfMotion.clear();
 
  // global field
 
  fVecChordFinders.push_back(nullptr);
  fVecMagneticFields.push_back(nullptr);
  fVecEquationOfMotion.push_back(nullptr);
  fVecFieldManagers.push_back(G4TransportationManager::GetTransportationManager()
                             ->GetFieldManager());
  if (fVecFieldManagers[0])
  {
    fVecMagneticFields[0] =
      (G4MagneticField*) fVecFieldManagers[0]->GetDetectorField();
    if (fVecMagneticFields[0])
    {
      fVecEquationOfMotion[0] = new G4BlineEquation(fVecMagneticFields[0]);
      auto  pStepper = new G4CashKarpRKF45(fVecEquationOfMotion[0]);
      auto  pIntgrDriver =
        new G4MagInt_Driver(0.01*mm,pStepper,pStepper->GetNumberOfVariables());
      fVecChordFinders[0] = new G4ChordFinder(pIntgrDriver);
    }
  }
 
  // local fields
 
  G4LogicalVolumeStore* theVolumeStore = G4LogicalVolumeStore::GetInstance();
 
  size_t j=0;
  for (size_t i=0; i<theVolumeStore->size();i++)
  {
    if ((*theVolumeStore)[i]->GetFieldManager())
    {
      j++;
      fVecFieldManagers.push_back(((*theVolumeStore)[i])->GetFieldManager());
      fVecMagneticFields.push_back((G4MagneticField*)
                                   fVecFieldManagers[j]->GetDetectorField());
      fVecEquationOfMotion.push_back(nullptr);
      fVecChordFinders.push_back(nullptr);
      if (fVecMagneticFields[j])
      {
        fVecEquationOfMotion[j]= new G4BlineEquation(fVecMagneticFields[j]);
        auto  pStepper = new G4CashKarpRKF45(fVecEquationOfMotion[j]);
        auto  pIntgrDriver =
          new G4MagInt_Driver(.01*mm,pStepper,pStepper->GetNumberOfVariables());
        fVecChordFinders[j] = new G4ChordFinder(pIntgrDriver);
      }
    }
  }
}

Member Data Documentation

fMessenger

G4BlineTracerMessenger* G4BlineTracer::fMessenger = nullptr

private

Definition at line 91 of file G4BlineTracer.hh.

fSteppingAction

G4BlineSteppingAction* G4BlineTracer::fSteppingAction = nullptr

private

Definition at line 92 of file G4BlineTracer.hh.

fEventAction

G4BlineEventAction* G4BlineTracer::fEventAction = nullptr

private

Definition at line 93 of file G4BlineTracer.hh.

fPrimaryGeneratorAction

G4BlinePrimaryGeneratorAction* G4BlineTracer::fPrimaryGeneratorAction = nullptr

private

Definition at line 94 of file G4BlineTracer.hh.

fMaxTrackingStep

G4double G4BlineTracer::fMaxTrackingStep = 1000. * CLHEP::m

private

Definition at line 95 of file G4BlineTracer.hh.

fWas_ResetChordFinders_already_called

G4bool G4BlineTracer::fWas_ResetChordFinders_already_called = false

private

Definition at line 96 of file G4BlineTracer.hh.

fVecChordFinders

std::vector<G4ChordFinder* > G4BlineTracer::fVecChordFinders

private

Definition at line 101 of file G4BlineTracer.hh.

fVecFieldManagers

std::vector<G4FieldManager* > G4BlineTracer::fVecFieldManagers

private

Definition at line 102 of file G4BlineTracer.hh.

fVecMagneticFields

std::vector<G4MagneticField* > G4BlineTracer::fVecMagneticFields

private

Definition at line 103 of file G4BlineTracer.hh.

fVecEquationOfMotion

std::vector<G4BlineEquation* > G4BlineTracer::fVecEquationOfMotion

private

Definition at line 104 of file G4BlineTracer.hh.

---

The documentation for this class was generated from the following files:

• .doxygen/Doxymodules_field.h
• extended/field/BlineTracer/include/G4BlineTracer.hh
• extended/field/BlineTracer/src/G4BlineTracer.cc