G4BlineTracer Class Reference

#include <G4BlineTracer.hh>

Inheritance diagram for G4BlineTracer:

Collaboration diagram for G4BlineTracer:

Public Member Functions
	G4BlineTracer ()
virtual	~G4BlineTracer ()
virtual void	BeginOfRunAction (const G4Run *aRun)
virtual void	EndOfRunAction (const G4Run *aRun)
void	ComputeBlines (G4int nlines)
void	SetMaxTrackingStep (G4double max_step)
G4BlineEventAction *	GetEventAction ()
Public Member Functions inherited from G4UserRunAction
	G4UserRunAction ()
virtual	~G4UserRunAction ()
virtual G4Run *	GenerateRun ()
virtual void	SetMaster (G4bool val=true)
G4bool	IsMaster () const

Additional Inherited Members
Protected Attributes inherited from G4UserRunAction
G4bool	isMaster

Detailed Description

Definition at line 67 of file G4BlineTracer.hh.

Constructor & Destructor Documentation

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();
  fMaxTrackingStep =1000.*m;
  fWas_ResetChordFinders_already_called=false;
}

G4BlineTracer::~G4BlineTracer ( )

virtual

Definition at line 72 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

void G4BlineTracer::BeginOfRunAction ( const G4Run *  aRun )

virtual

Reimplemented from G4UserRunAction.

Definition at line 87 of file G4BlineTracer.cc.

{
}  

void G4BlineTracer::ComputeBlines

(

G4int

nlines

)

Definition at line 99 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();
  G4UserRunAction* user_run_action =
    (G4UserRunAction*)theRunManager->GetUserRunAction();
  theRunManager->SetUserAction(this);

  G4UserSteppingAction* user_stepping_action =
    (G4UserSteppingAction*)theRunManager->GetUserSteppingAction();
  theRunManager->SetUserAction(fSteppingAction);
  
  G4VUserPrimaryGeneratorAction* userPrimaryAction =
    (G4VUserPrimaryGeneratorAction*)theRunManager->GetUserPrimaryGeneratorAction();
  if (userPrimaryAction) 
    fPrimaryGeneratorAction->SetUserPrimaryAction(userPrimaryAction);
  theRunManager->SetUserAction(fPrimaryGeneratorAction);

  G4UserEventAction* user_event_action =
    (G4UserEventAction*)theRunManager->GetUserEventAction();
  theRunManager->SetUserAction(fEventAction);
 
  G4UserTrackingAction* user_tracking_action =
    (G4UserTrackingAction*)theRunManager->GetUserTrackingAction();
  G4UserTrackingAction* aNullTrackingAction = 0;
  theRunManager->SetUserAction(aNullTrackingAction);

  G4UserStackingAction* user_stacking_action = 
    (G4UserStackingAction*)theRunManager->GetUserStackingAction();
  G4UserStackingAction* aNullStackingAction = 0;
  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(0); 
  }

  // 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]);
  } 
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4BlineTracer::EndOfRunAction ( const G4Run *  aRun )

virtual

Reimplemented from G4UserRunAction.

Definition at line 93 of file G4BlineTracer.cc.

{
}

G4BlineEventAction* G4BlineTracer::GetEventAction ( )

inline

Definition at line 81 of file G4BlineTracer.hh.

       { return fEventAction; }

Here is the caller graph for this function:

void G4BlineTracer::SetMaxTrackingStep ( G4double  max_step )

inline

Definition at line 79 of file G4BlineTracer.hh.

       { fMaxTrackingStep=max_step; }

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p03/examples/extended/field/BlineTracer/include/G4BlineTracer.hh
• source/geant4.10.03.p03/examples/extended/field/BlineTracer/src/G4BlineTracer.cc