#include <G4ITModelProcessor.hh>

Public Member Functions
	G4ITModelProcessor ()

virtual	~G4ITModelProcessor ()

void	SetModelHandler (G4ITModelHandler *)

void	Initialize ()

void	CleanProcessor ()

void	InitializeStepper (const G4double &currentGlobalTime, const G4double &userMinTime)

void	CalculateTimeStep (const G4Track *, const G4double)

void	DoCalculateStep ()

void	FindReaction (std::map< G4Track , G4TrackVectorHandle > , const double currentStepTime, const double previousStepTime, const bool reachedUserStepTimeLimit)

const std::vector< std::vector < G4VITModel * > > *	GetCurrentModel ()

std::vector < G4ITReactionChange * > *	GetReactionInfo ()

const G4Track *	GetTrack () const

Protected Member Functions
void	SetTrack (const G4Track *)

	G4ITModelProcessor (const G4ITModelProcessor &other)

G4ITModelProcessor &	operator= (const G4ITModelProcessor &other)

Protected Attributes
G4bool	fInitialized

G4ITModelHandler *	fpModelHandler

const G4Track *	fpTrack

G4double	fUserMinTimeStep

std::vector< std::vector < G4VITModel * > >	fCurrentModel

G4VITModel *	fpModel

G4ITModelManager *	fpModelManager

G4ITType	fCurrentType1

G4ITType	fCurrentType2

std::vector< G4ITReactionChange * >	fReactionInfo

Static Protected Attributes
static G4ThreadLocal std::map < const G4Track , G4bool >	fHasReacted = 0

Detailed Description

The G4ITModelProcessor will call the two processes defined in G4VITModel. This processes act at the beginning and end of each step. The first one, the TimeStepper will calculate a time step to propagate all the track and eventually it can return some tracks that can likely react at the end of the step. The second one, the ReactionProcess will make the tracks reacting.

Definition at line 62 of file G4ITModelProcessor.hh.

Constructor & Destructor Documentation

G4ITModelProcessor::G4ITModelProcessor ( )

Definition at line 42 of file G4ITModelProcessor.cc.

References fCurrentModel, fHasReacted, fInitialized, fpModel, fpModelHandler, fpModelManager, fpTrack, fUserMinTimeStep, int(), and G4ITType::size().

 {
     //ctor
     if (!fHasReacted) fHasReacted = new std::map<const G4Track*, G4bool>;
     fpTrack = 0;
     fpModelHandler = 0;
     fpModel = 0;
     fInitialized = false;
     fpModelManager = 0;
     fCurrentModel.assign(G4ITType::size(), std::vector<G4VITModel*>());
 
     for(int i = 0 ; i < (int) G4ITType::size() ; i++)
     {
         fCurrentModel[i].assign(G4ITType::size(),0);
     }
     fUserMinTimeStep = -1.;
 }

G4ITModelProcessor::~G4ITModelProcessor ( )

virtual

Definition at line 60 of file G4ITModelProcessor.cc.

References fCurrentModel, and fReactionInfo.

 {
     //dtor
 //    if(fpModelHandler) delete fpModelHandler; deleted by G4ITStepManager
     fCurrentModel.clear();
     fReactionInfo.clear();
 }

G4ITModelProcessor::G4ITModelProcessor ( const G4ITModelProcessor & other )

protected

Copy constructor

Parameters

other Object to copy from

Definition at line 69 of file G4ITModelProcessor.cc.

References fInitialized, fpModel, fpModelHandler, fpModelManager, fpTrack, and fUserMinTimeStep.

 {
     //copy ctorr
     fpTrack = 0;
     fpModelHandler = 0;
     fpModel = 0;
     fInitialized = false;
     fpModelManager = 0;
     fUserMinTimeStep = -1.;
 }

Member Function Documentation

void G4ITModelProcessor::CalculateTimeStep	(	const G4Track *	track,
		const G4double	userMinTimeStep
	)

Definition at line 157 of file G4ITModelProcessor.cc.

References CleanProcessor(), DoCalculateStep(), FatalErrorInArgument, fUserMinTimeStep, G4Exception(), and SetTrack().

 {
     // G4cout  << "G4ITModelProcessor::CalculateStep" << G4endl;
     CleanProcessor();
     if(track == 0)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No track was passed to the method (track == 0).";
         G4Exception("G4ITModelProcessor::CalculateStep","ITModelProcessor004",
                     FatalErrorInArgument,exceptionDescription);
     }
     SetTrack(track);
     fUserMinTimeStep = userMinTimeStep ;
 
     DoCalculateStep();
 }

void G4ITModelProcessor::CleanProcessor ( )

inline

Restaure original state of the modelProcessor. This method should be call only by the ITStepManager

Definition at line 174 of file G4ITModelProcessor.hh.

References fpTrack.

Referenced by CalculateTimeStep().

 {
     fpTrack = 0;
 }

void G4ITModelProcessor::DoCalculateStep ( )

Definition at line 175 of file G4ITModelProcessor.cc.

References fCurrentModel, fpModel, fpTrack, fUserMinTimeStep, GetIT(), G4IT::GetITType(), and int().

Referenced by CalculateTimeStep().

 {
     if(fpModel) // ie only one model has been declared and will be used
     {
         fpModel -> GetTimeStepper()->CalculateStep(*fpTrack, fUserMinTimeStep);
     }
     else // ie many models have been declared and will be used
     {
         std::vector<G4VITModel*>& model = fCurrentModel[GetIT(fpTrack)->GetITType()];
 
         for(int i =0 ; i < (int) model.size() ; i++)
         {
             if(model[i] == 0) continue;
             model[i]->GetTimeStepper()->CalculateStep(*fpTrack, fUserMinTimeStep);
         }
     }
 }

void G4ITModelProcessor::FindReaction	(	std::map< G4Track , G4TrackVectorHandle >	tracks,
		const double	currentStepTime,
		const double	previousStepTime,
		const bool	reachedUserStepTimeLimit
	)

Get track A

Definition at line 194 of file G4ITModelProcessor.cc.

References FatalErrorInArgument, fCurrentModel, fHasReacted, fpModelHandler, fReactionInfo, fStopAndKill, G4Exception(), G4ITModelHandler::GetAllModelManager(), GetIT(), G4Track::GetTrackStatus(), G4VITReactionProcess::MakeReaction(), and G4VITReactionProcess::ResetChanges().

 {
     // DEBUG
     //    G4cout << "G4ITReactionManager::FindReaction" << G4endl;
     if(tracks == 0)       return ;
 
     if(fpModelHandler->GetAllModelManager()->empty()) return ;
 
     std::map<G4Track*, G4TrackVectorHandle>::iterator tracks_i = tracks->begin();;
 
     for(tracks_i = tracks->begin() ; tracks_i != tracks-> end() ; tracks_i ++)
     {
         /// Get track A
         G4Track* trackA = tracks_i->first;
 
         if(trackA == 0)         continue;
 
         std::map<const G4Track*, G4bool>::iterator it_hasReacted = fHasReacted->find(trackA);
         if(it_hasReacted != fHasReacted->end()) continue;
         if(trackA->GetTrackStatus() == fStopAndKill) continue;
 
         G4IT* ITA = GetIT(trackA);
         G4ITType ITypeA = ITA -> GetITType();
 
         const std::vector<G4VITModel*> model = fCurrentModel[ITypeA];
 
         G4TrackVectorHandle& trackB_vector = tracks_i->second ;
         std::vector<G4Track*>::iterator trackB_i = trackB_vector->begin();
 
         G4Track* trackB = 0 ;
         G4ITType ITypeB(-1);
         G4VITReactionProcess* process = 0;
         G4ITReactionChange* changes = 0;
 
         for(; trackB_i != trackB_vector->end() ; trackB_i++)
         {
             trackB = *trackB_i;
 
             if(trackB == 0)         continue;
             it_hasReacted = fHasReacted->find(trackB);
             if(it_hasReacted != fHasReacted->end()) continue;
             if(trackB->GetTrackStatus() == fStopAndKill) continue;
 
             // DEBUG
             //             G4cout << "Couple : " << trackA->GetParticleDefinition->GetParticleName() << " ("
             //                        << trackA->GetTrackID() << ")   "
             //                        << trackB->GetParticleDefinition->GetParticleName() << " ("
             //                        << trackB->GetTrackID() << ")"
             //                        << G4endl;
 
             if(trackB == trackA)
             {
                 G4ExceptionDescription exceptionDescription ;
                 exceptionDescription << "The IT reaction process sent back a reaction between trackA and trackB. ";
                 exceptionDescription << "The problem is trackA == trackB";
                 G4Exception("G4ITModelProcessor::FindReaction","ITModelProcessor005",
                             FatalErrorInArgument,exceptionDescription);
             }
 
             G4IT* ITB = GetIT(trackB);
             G4ITType ITypeBtmp = ITB -> GetITType();
 
             if(ITypeB != ITypeBtmp)
             {
                 ITypeB = ITypeBtmp ;
 
                 if(model[ITypeB])
                     process = model[ITypeB]->GetReactionProcess();
             }
 
             if(process && process -> TestReactibility(*trackA, *trackB,
                                                       currentStepTime, previousStepTime,
                                                       reachedUserStepTimeLimit))
             {
                 changes = process->MakeReaction(*trackA, *trackB);
             }
 
             if(changes)
             {
                 (*fHasReacted)[trackA] = true;
                 (*fHasReacted)[trackB] = true;
                 changes -> GetTrackA();
                 changes -> GetTrackB();
 
                 fReactionInfo.push_back(changes);
 
                 process->ResetChanges();
                 changes = 0;
 
                 break;
             }
         }
     }
 
     fHasReacted->clear();
 }

const std::vector< std::vector< G4VITModel * > > * G4ITModelProcessor::GetCurrentModel ( )

inline

Definition at line 157 of file G4ITModelProcessor.hh.

References fCurrentModel.

 {
     return &fCurrentModel ;
 }

std::vector<G4ITReactionChange*>* G4ITModelProcessor::GetReactionInfo ( )

inline

Definition at line 100 of file G4ITModelProcessor.hh.

References fReactionInfo.

     {
         return &fReactionInfo;
     }

const G4Track* G4ITModelProcessor::GetTrack ( ) const

inline

Definition at line 105 of file G4ITModelProcessor.hh.

References fpTrack.

     {
         return fpTrack;
     }

void G4ITModelProcessor::Initialize ( )

Definition at line 88 of file G4ITModelProcessor.cc.

References fInitialized, fpModelHandler, and G4ITModelHandler::Initialize().

 {
     fpModelHandler->Initialize();
     fInitialized = true;
 }

void G4ITModelProcessor::InitializeStepper	(	const G4double &	currentGlobalTime,
		const G4double &	userMinTime
	)

Definition at line 95 of file G4ITModelProcessor.cc.

References FatalErrorInArgument, fCurrentModel, fpModel, fpModelHandler, fpModelManager, G4Exception(), G4ITModelHandler::GetAllModelManager(), G4VITModel::GetTimeStepper(), and G4VITTimeStepper::SetTimes().

 {
     // G4cout << "G4ITModelProcessor::InitializeStepper" << G4endl;
     if(fpModelHandler==0)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No G4ITModelHandler was passed to the modelProcessor.";
         G4Exception("G4ITModelProcessor::InitializeStepper","ITModelProcessor002",
                     FatalErrorInArgument,exceptionDescription);
     }
     const std::vector<std::vector<G4ITModelManager*> >* modelManager = fpModelHandler
             ->GetAllModelManager();
 
     if(modelManager==0)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No G4ITModelManager was register to G4ITModelHandler.";
         G4Exception("G4ITModelProcessor::InitializeStepper","ITModelProcessor003",
                     FatalErrorInArgument,exceptionDescription);
     }
 
     int nbModels1 = modelManager->size() ;
 
     G4VITTimeStepper::SetTimes(currentGlobalTime, userMinTime) ;
 
     // TODO !!!
     //    if( nbModels1 != 1 || (nbModels1 == 1 && !fpModelManager) )
     {
         int nbModels2 = -1;
         G4VITModel* model = 0;
         G4ITModelManager* modman = 0;
 
         for(int i = 0 ; i < nbModels1 ; i++)
         {
             nbModels2 = (*modelManager)[i].size();
 
             for(int j = 0 ; j <= i ; j++)
             {
                 modman = (*modelManager)[i][j];
 
                 if(modman == 0) continue ;
 
                 model       =  modman -> GetModel(currentGlobalTime);
                 G4VITTimeStepper* stepper   = model->GetTimeStepper() ;
 
 //                stepper -> PrepareForAllProcessors() ;
                 stepper -> Prepare() ;
                 fCurrentModel[i][j] = model;
             }
         }
 
         if(nbModels1 == 1 && nbModels2 ==1)
         {
             fpModelManager = modman;
             fpModel = model;
         }
         else fpModel = 0;
     }
 }

G4ITModelProcessor & G4ITModelProcessor::operator= ( const G4ITModelProcessor & other )

protected

Assignment operator

Parameters

other Object to assign from

Returns: A reference to this

Definition at line 81 of file G4ITModelProcessor.cc.

 {
     if (this == &rhs) return *this; // handle self assignment
     //assignment operator
     return *this;
 }

void G4ITModelProcessor::SetModelHandler ( G4ITModelHandler * modelHandler )

inline

Definition at line 162 of file G4ITModelProcessor.hh.

References FatalErrorInArgument, fInitialized, fpModelHandler, and G4Exception().

 {
     if(fInitialized == 1)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "You are trying to set a new model while the model processor has alreaday be initialized";
         G4Exception("G4ITModelProcessor::SetModelHandler","ITModelProcessor001",
                     FatalErrorInArgument,exceptionDescription);
     }
     fpModelHandler = modelHandler;
 }