ITTrackingInteractivity Class Reference

#include <ITTrackingInteractivity.hh>

Inheritance diagram for ITTrackingInteractivity:

Collaboration diagram for ITTrackingInteractivity:

Public Member Functions
	ITTrackingInteractivity ()
virtual	~ITTrackingInteractivity ()
virtual void	Initialize ()
virtual void	StartTracking (G4Track *)
virtual void	AppendStep (G4Track *track, G4Step *step)
virtual void	EndTracking (G4Track *)
virtual void	Finalize ()
void	SetUserAction (G4UserTrackingAction *)
G4UserTrackingAction *	GetUserTrackingAction ()
void	SetUserAction (G4UserSteppingAction *)
G4UserSteppingAction *	GetUserSteppingAction ()
Public Member Functions inherited from G4ITTrackingInteractivity
	G4ITTrackingInteractivity (G4VITSteppingVerbose *verbose=0)
virtual	~G4ITTrackingInteractivity ()
virtual void	TrackBanner (G4Track *, const G4String &message="")
void	SetVerbose (int flag)
G4int	GetVerboseLevel () const
void	SetSteppingVerboseLevel (G4int level)
G4int	GetSteppingVerboseLevel () const
G4VITSteppingVerbose *	GetSteppingVerbose ()
void	SetSteppingVerbose (G4VITSteppingVerbose *verbose)

Private Attributes
G4UserTrackingAction *	fpUserTrackingAction
G4UserSteppingAction *	fpUserSteppingAction
int	fStoreTrajectory
std::vector< G4VTrajectory * >	fTrajectories

Additional Inherited Members
Protected Attributes inherited from G4ITTrackingInteractivity
int	fVerboseLevel

Detailed Description

Definition at line 49 of file ITTrackingInteractivity.hh.

Constructor & Destructor Documentation

ITTrackingInteractivity()

ITTrackingInteractivity::ITTrackingInteractivity

(

)

Definition at line 65 of file ITTrackingInteractivity.cc.

{
  fStoreTrajectory = 0;
  fVerboseLevel = 0;

  fpUserTrackingAction  = 0;
  fpUserSteppingAction = 0;

  // In case you want to use same tracking/stepping action
  // for normal and IT stepping
  /*
    fpUserTrackingAction =
      trackingManager->GetUserTrackingAction();
    fpUserSteppingAction =
      G4EventManager::GetEventManager()->GetUserSteppingAction();
   */
}

~ITTrackingInteractivity()

ITTrackingInteractivity::~ITTrackingInteractivity ( )

virtual

Definition at line 87 of file ITTrackingInteractivity.cc.

{
  G4EventManager* eventManager =
      G4EventManager::GetEventManager();

  if (eventManager)
  {
  G4UserTrackingAction* std_trackAct =
      eventManager->GetUserTrackingAction();
  if(fpUserTrackingAction != std_trackAct && fpUserTrackingAction)
    delete fpUserTrackingAction;

  G4UserSteppingAction* std_stepAct =
      eventManager->GetUserSteppingAction();
  if(fpUserSteppingAction != std_stepAct && fpUserSteppingAction)
    delete fpUserSteppingAction;
  }
  else
  {
    if(fpUserSteppingAction)
    {
      delete fpUserSteppingAction;
    }
    
    if(fpUserTrackingAction)
    {
      delete fpUserTrackingAction;
    }
  }
}

Here is the call graph for this function:

Member Function Documentation

AppendStep()

void ITTrackingInteractivity::AppendStep ( G4Track *  track, G4Step *  step  )

virtual

Reimplemented from G4ITTrackingInteractivity.

Definition at line 172 of file ITTrackingInteractivity.cc.

{
  // If you want to use sensitive detector
  /*
    G4VPhysicalVolume* currentVolume =
    step->GetPreStepPoint()->GetPhysicalVolume();
    G4SteppingControl stepControlFlag =  step->GetControlFlag();

    if( currentVolume  != 0 && stepControlFlag != AvoidHitInvocation)
    {
        G4VSensitiveDetector* sensitive = step->GetPreStepPoint()->
                GetSensitiveDetector();
        if( sensitive != 0 )
        {
            sensitive->Hit(fpStep);
        }
    }
   */

  if(fpUserSteppingAction)
    fpUserSteppingAction->UserSteppingAction(step);

  // If you want to use regional stepping action
  /*
    G4UserSteppingAction* regionalAction
            = fpStep->GetPreStepPoint()->GetPhysicalVolume()->
                  GetLogicalVolume()->GetRegion()->
                  GetRegionalSteppingAction();
    if( regionalAction ) regionalAction->UserSteppingAction(fpStep);
   */

  if(fStoreTrajectory)
  {
    G4TrackingInformation* trackingInfo =
        GetIT(track)->GetTrackingInfo();
    G4Trajectory_Lock* trajectory_lock =
        trackingInfo->GetTrajectory_Lock();
    trajectory_lock->fpTrajectory->AppendStep(step);
  }
}

Here is the call graph for this function:

EndTracking()

void ITTrackingInteractivity::EndTracking ( G4Track *  track )

virtual

Reimplemented from G4ITTrackingInteractivity.

Definition at line 219 of file ITTrackingInteractivity.cc.

{
#ifdef G4VERBOSE
  if(fVerboseLevel)
  {
    TrackBanner(track, "G4ITTrackingManager::EndTracking : ");
  }
#endif
  // Post tracking user intervention process.
  if( fpUserTrackingAction != 0 ) {
    fpUserTrackingAction->PostUserTrackingAction(track);
  }

//#ifdef G4_STORE_TRAJECTORY
  G4TrackingInformation* trackingInfo =
      GetIT(track)->GetTrackingInfo();
  G4Trajectory_Lock* trajectory_lock =
      trackingInfo->GetTrajectory_Lock();

  if(trajectory_lock)
  {
    G4VTrajectory*& trajectory = trajectory_lock->fpTrajectory;

    if(fStoreTrajectory && trajectory)
    {

#ifdef G4VERBOSE
      if(fVerboseLevel>10) trajectory->ShowTrajectory();
#endif
      G4TrackStatus istop = track->GetTrackStatus();

      if (trajectory && (istop != fStopButAlive) && (istop != fSuspend))
      {
        G4Event* currentEvent = G4EventManager::GetEventManager()
            ->GetNonconstCurrentEvent();

        if (currentEvent)
        {
          G4TrajectoryContainer* trajectoryContainer = currentEvent
              ->GetTrajectoryContainer();

          if (!trajectoryContainer)
          {
            trajectoryContainer = new G4TrajectoryContainer;
            currentEvent->SetTrajectoryContainer(trajectoryContainer);
          }
          trajectoryContainer->insert(trajectory);
        }
        else
        {
          fTrajectories.push_back(trajectory);
        }
      }
    }
    // Destruct the trajectory if it was created
    else if( (!fStoreTrajectory)&&trajectory ) {
      delete trajectory;
      trajectory = 0;
    }
    delete trajectory_lock;
    trackingInfo->SetTrajectory_Lock(0);
  }
//#endif
}

Here is the call graph for this function:

Finalize()

void ITTrackingInteractivity::Finalize ( )

virtual

Reimplemented from G4ITTrackingInteractivity.

Definition at line 284 of file ITTrackingInteractivity.cc.

{
  for (std::vector<G4VTrajectory*>::iterator it = fTrajectories.begin();
      it != fTrajectories.end(); it++)
  {
    G4VisManager::GetConcreteInstance()->Draw(**it);
  }
}

Here is the call graph for this function:

GetUserSteppingAction()

G4UserSteppingAction * ITTrackingInteractivity::GetUserSteppingAction ( )

inline

Definition at line 86 of file ITTrackingInteractivity.hh.

{
  return fpUserSteppingAction;
}

GetUserTrackingAction()

G4UserTrackingAction * ITTrackingInteractivity::GetUserTrackingAction ( )

inline

Definition at line 92 of file ITTrackingInteractivity.hh.

{
  return fpUserTrackingAction;
}

Initialize()

void ITTrackingInteractivity::Initialize ( )

virtual

Reimplemented from G4ITTrackingInteractivity.

Definition at line 120 of file ITTrackingInteractivity.cc.

{
  G4TrackingManager* trackingManager = 
    G4EventManager::GetEventManager()->GetTrackingManager();
  fStoreTrajectory = trackingManager->GetStoreTrajectory();
  fVerboseLevel = trackingManager->GetVerboseLevel();
}

Here is the call graph for this function:

SetUserAction() [1/2]

void ITTrackingInteractivity::SetUserAction ( G4UserTrackingAction *  trackAct )

inline

Definition at line 74 of file ITTrackingInteractivity.hh.

{
  fpUserTrackingAction = trackAct;
}

SetUserAction() [2/2]

void ITTrackingInteractivity::SetUserAction ( G4UserSteppingAction *  stepAct )

inline

Definition at line 80 of file ITTrackingInteractivity.hh.

{
  fpUserSteppingAction = stepAct;
}

StartTracking()

void ITTrackingInteractivity::StartTracking ( G4Track *  track )

virtual

Reimplemented from G4ITTrackingInteractivity.

Definition at line 130 of file ITTrackingInteractivity.cc.

{
#ifdef G4VERBOSE
  if(fVerboseLevel)
  {
    TrackBanner(track, "G4ITTrackingManager::StartTracking : ");
  }
#endif

  if(fVerboseLevel>0 && (G4VSteppingVerbose::GetSilent()!=1) )
    TrackBanner(track);

  // Pre tracking user intervention process.
  if( fpUserTrackingAction != 0 ) {
    fpUserTrackingAction->PreUserTrackingAction(track);
  }
//#ifdef G4_STORE_TRAJECTORY
  G4TrackingInformation* trackingInfo = GetIT(track)->GetTrackingInfo();
  G4Trajectory_Lock* trajectory_lock =
      trackingInfo->GetTrajectory_Lock();

  // Construct a trajectory if it is requested
  if(fStoreTrajectory&&(!trajectory_lock))
  {
    trajectory_lock = new G4Trajectory_Lock();
    trackingInfo->SetTrajectory_Lock(trajectory_lock);
    G4VTrajectory* trajectory = 0;
    // default trajectory concrete class object
    switch (fStoreTrajectory) {
      default:
      case 1: trajectory = new G4Trajectory(track); break;
      case 2: trajectory = new G4SmoothTrajectory(track); break;
      case 3: trajectory = new G4RichTrajectory(track); break;
    }
    trajectory_lock->fpTrajectory = trajectory;
  }
//#endif
}

Here is the call graph for this function:

Member Data Documentation

fpUserSteppingAction

G4UserSteppingAction* ITTrackingInteractivity::fpUserSteppingAction

private

Definition at line 52 of file ITTrackingInteractivity.hh.

fpUserTrackingAction

G4UserTrackingAction* ITTrackingInteractivity::fpUserTrackingAction

private

Definition at line 51 of file ITTrackingInteractivity.hh.

fStoreTrajectory

int ITTrackingInteractivity::fStoreTrajectory

private

Definition at line 53 of file ITTrackingInteractivity.hh.

fTrajectories

std::vector<G4VTrajectory*> ITTrackingInteractivity::fTrajectories

private

Definition at line 54 of file ITTrackingInteractivity.hh.

---

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

• ITTrackingInteractivity.hh
• ITTrackingInteractivity.cc