G4ITModelProcessor Class Reference

#include <G4ITModelProcessor.hh>

Collaboration diagram for G4ITModelProcessor:

Public Member Functions
	G4ITModelProcessor ()
virtual	~G4ITModelProcessor ()
void	SetModelHandler (G4ITModelHandler *)
void	Initialize ()
void	RegisterModel (double time, G4VITStepModel *)
void	CleanProcessor ()
G4double	CalculateMinTimeStep (G4double currentGlobalTime, G4double definedMinTimeStep)
void	ComputeTrackReaction (G4ITStepStatus fITStepStatus, G4double fGlobalTime, G4double currentTimeStep, G4double previousTimeStep, G4bool reachedUserTimeLimit, G4double fTimeTolerance, G4UserTimeStepAction *fpUserTimeStepAction, G4int fVerbose)
void	InitializeStepper (G4double currentGlobalTime, G4double userMinTime)
bool	GetComputeTimeStep ()
void	CalculateTimeStep (const G4Track *, const G4double)
void	DoCalculateStep ()
void	FindReaction (G4ITReactionSet *reactionSet, const double currentStepTime, const double previousStepTime, const bool reachedUserStepTimeLimit)
const std::vector< std::vector < G4VITStepModel * > > *	GetCurrentModel ()
std::vector < G4ITReactionChange * > *	GetReactionInfo ()
const G4Track *	GetTrack () const
void	SetTrackingManager (G4ITTrackingManager *trackingManager)

Protected Member Functions
void	SetTrack (const G4Track *)
void	ExtractTimeStepperData ()
	G4ITModelProcessor (const G4ITModelProcessor &other)
G4ITModelProcessor &	operator= (const G4ITModelProcessor &other)

Protected Attributes
G4double	fTSTimeStep
G4ITReactionSet *	fReactionSet
G4ITTrackingManager *	fpTrackingManager
G4ITTrackHolder *	fpTrackContainer
G4bool	fInitialized
G4ITModelHandler *	fpModelHandler
const G4Track *	fpTrack
G4double	fUserMinTimeStep
std::vector< std::vector < G4VITStepModel * > >	fCurrentModel
G4VITStepModel *	fpModel
G4ITModelManager *	fpModelManager
G4ITType	fCurrentType1
G4ITType	fCurrentType2
std::vector< G4ITReactionChange * >	fReactionInfo
bool	fComputeTimeStep
bool	fComputeReaction

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 83 of file G4ITModelProcessor.hh.

Constructor & Destructor Documentation

G4ITModelProcessor::G4ITModelProcessor

(

)

Definition at line 56 of file G4ITModelProcessor.cc.

{
  fpTrack = 0;
  fpModel = 0;
  fInitialized = false;
  fpModelManager = 0;
  fCurrentModel.assign(G4ITType::size(), std::vector<G4VITStepModel*>());

  for(int i = 0; i < (int) G4ITType::size(); i++)
  {
    fCurrentModel[i].assign(G4ITType::size(), 0);
  }
  fUserMinTimeStep = -1.;
  fTSTimeStep = DBL_MAX;
  fpTrackingManager = 0;
  fReactionSet = 0;
  fpTrackContainer = 0;
  fpModelHandler = 0;
  fComputeTimeStep = false;
  fComputeReaction = false;
}

Here is the call graph for this function:

G4ITModelProcessor::~G4ITModelProcessor ( )

virtual

Definition at line 78 of file G4ITModelProcessor.cc.

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

G4ITModelProcessor::G4ITModelProcessor ( const G4ITModelProcessor &  other )

protected

Copy constructor

Parameters

other

Object to copy from

Definition at line 87 of file G4ITModelProcessor.cc.

{
  //copy ctorr
  fpTrack = 0;
  fpModelHandler = 0;
  fpModel = 0;
  fInitialized = false;
  fpModelManager = 0;
  fUserMinTimeStep = -1.;
  fTSTimeStep = DBL_MAX;
  fpTrackingManager = 0;
  fReactionSet = 0;
  fpTrackContainer = 0;
  fComputeTimeStep = false;
  fComputeReaction = false;
}

Member Function Documentation

G4double G4ITModelProcessor::CalculateMinTimeStep	(	G4double	currentGlobalTime,
		G4double	definedMinTimeStep
	)

Definition at line 131 of file G4ITModelProcessor.cc.

{

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DETAILED_STEPPING)
  MemStat mem_first, mem_second, mem_diff;
#endif

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif

  fTSTimeStep = DBL_MAX;

  InitializeStepper(currentGlobalTime, definedMinTimeStep);
  // TODO
  // fpMasterModelProcessor -> InitializeStepper(fGlobalTime, fDefinedMinTimeStep) ;

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second-mem_first;
  G4cout << "\t || MEM || G4Scheduler::CalculateMinTimeStep || After "
  "computing fpModelProcessor -> InitializeStepper, diff is : "
  << mem_diff
  << G4endl;
#endif

//  G4TrackList::iterator fpMainList_i = fpMainList->begin();

  G4TrackManyList* mainList = fpTrackContainer->GetMainList();
  G4TrackManyList::iterator it = mainList->begin();
  G4TrackManyList::iterator end = mainList->end();

  for (; it != end; ++it)
  {
    G4Track * track = *it;

    if (track == 0)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "No track found.";
      G4Exception("G4Scheduler::CalculateMinStep", "ITScheduler006",
          FatalErrorInArgument, exceptionDescription);
      return 0; // makes coverity happy
    }

#ifdef DEBUG
    G4cout << "*_* " << GetIT(track)->GetName()
    << " ID: " << track->GetTrackID()
    << " at time : " << track->GetGlobalTime()
    << G4endl;
#endif

    G4TrackStatus trackStatus = track->GetTrackStatus();
    if (trackStatus == fStopAndKill || trackStatus == fStopButAlive)
    {
      continue;
    }

    // This Extract... was thought for MT mode at the track level
    //ExtractTimeStepperData(fpModelProcessor) ;

    CalculateTimeStep(track, definedMinTimeStep);

    // if MT mode at track level, this command should be displaced
    ExtractTimeStepperData();
  }

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second-mem_first;
  G4cout << "\t || MEM || G4Scheduler::CalculateMinTimeStep || "
  "After looping on tracks, diff is : " << mem_diff << G4endl;
#endif
  return fTSTimeStep;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 397 of file G4ITModelProcessor.cc.

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

Here is the call graph for this function:

void G4ITModelProcessor::CleanProcessor ( )

inline

Restore original state of the modelProcessor. This method should be call only by the G4Scheduler

Definition at line 229 of file G4ITModelProcessor.hh.

{
  fpTrack = 0;
}

void G4ITModelProcessor::ComputeTrackReaction	(	G4ITStepStatus	fITStepStatus,
		G4double	fGlobalTime,
		G4double	currentTimeStep,
		G4double	previousTimeStep,
		G4bool	reachedUserTimeLimit,
		G4double	fTimeTolerance,
		G4UserTimeStepAction *	fpUserTimeStepAction,
		G4int	fVerbose
	)

Definition at line 439 of file G4ITModelProcessor.cc.

{
//  if (fReactingTracks.empty())
  if(fReactionSet->Empty())
  {
    return;
  }

  if(fITStepStatus == eCollisionBetweenTracks)
  //        if(fInteractionStep == false)
  {
    // TODO
    FindReaction(fReactionSet,
                                   currentTimeStep,
                                   previousTimeStep,
                                   reachedUserTimeLimit);
    // TODO
    // A ne faire uniquement si le temps choisis est celui calculé par le time stepper
    // Sinon utiliser quelque chose comme : fModelProcessor->FindReaction(&fMainList);

    std::vector<G4ITReactionChange*> * reactionInfo_v = GetReactionInfo();
    std::vector<G4ITReactionChange*>::iterator reactionInfo_i = reactionInfo_v
        ->begin();

    for(; reactionInfo_i != reactionInfo_v->end(); ++reactionInfo_i)
    {
      G4ITReactionChange* changes = (*reactionInfo_i);
      G4Track* trackA = const_cast<G4Track*>(changes->GetTrackA());
      G4Track* trackB = const_cast<G4Track*>(changes->GetTrackB());

      if(trackA == 0 || trackB == 0 || trackA->GetTrackStatus() == fStopAndKill
         || trackB->GetTrackStatus() == fStopAndKill) continue;

      G4int nbSecondaries = changes->GetNumberOfSecondaries();
      const vector<G4Track*>* productsVector = changes->GetfSecondary();

      if(fpUserTimeStepAction)
      {
        fpUserTimeStepAction->UserReactionAction(*trackA,
                                                 *trackB,
                                                 productsVector);
      }

#ifdef G4VERBOSE
      if(fVerbose)
      {
        G4cout << "At time : " << setw(7) << G4BestUnit(fGlobalTime, "Time")
        << " Reaction : " << GetIT(trackA)->GetName() << " ("
        << trackA->GetTrackID() << ") + " << GetIT(trackB)->GetName() << " ("
        << trackB->GetTrackID() << ") -> ";
      }
#endif

      if(nbSecondaries > 0)
      {
        for(int i = 0; i < nbSecondaries; ++i)
        {
#ifdef G4VERBOSE
          if(fVerbose && i != 0) G4cout << " + ";
#endif

          G4Track* secondary = (*productsVector)[i]; //changes->GetSecondary(i);
          fpTrackContainer->_PushTrack(secondary);
          GetIT(secondary)->SetParentID(trackA->GetTrackID(),
                                        trackB->GetTrackID());

          if(secondary->GetGlobalTime() - fGlobalTime > fTimeTolerance)
          {
            G4ExceptionDescription exceptionDescription;
            exceptionDescription << "The time of the secondary should not be bigger than the"
            " current global time."
            << " This may cause synchronization problem. If the process you"
            " are using required "
            << "such feature please contact the developpers." << G4endl<< "The global time in the step manager : "
            << G4BestUnit(fGlobalTime,"Time")
            << G4endl
            << "The global time of the track : "
            << G4BestUnit(secondary->GetGlobalTime(),"Time")
            << G4endl;

            G4Exception("G4Scheduler::ComputeInteractionBetweenTracks",
                        "ITScheduler010",
                        FatalErrorInArgument,
                        exceptionDescription);
          }

#ifdef G4VERBOSE
          if(fVerbose)
            G4cout << GetIT(secondary)->GetName() << " ("
                   << secondary->GetTrackID() << ")";
#endif
        }
      }
      else
      {
#ifdef G4VERBOSE
        if(fVerbose) G4cout << "No product";
#endif
      }
#ifdef G4VERBOSE
      if(fVerbose) G4cout << G4endl;
#endif
      if(trackA->GetTrackID() == 0 || trackB->GetTrackID() == 0)
      {
        G4Track* track = 0;
        if(trackA->GetTrackID() == 0) track = trackA;
        else track = trackB;

        G4ExceptionDescription exceptionDescription;
        exceptionDescription
            << "The problem was found for the reaction between tracks :"
            << trackA->GetParticleDefinition()->GetParticleName() << " ("
            << trackA->GetTrackID() << ") & "
            << trackB->GetParticleDefinition()->GetParticleName() << " ("
            << trackB->GetTrackID() << "). \n";

        if(track->GetStep() == 0)
        {
          exceptionDescription << "Also no step was found"
                               << " ie track->GetStep() == 0 \n";
        }

        exceptionDescription << "Parent ID of trackA : "
                             << trackA->GetParentID() << "\n";
        exceptionDescription << "Parent ID of trackB : "
                             << trackB->GetParentID() << "\n";

        exceptionDescription
            << "The ID of one of the reaction track was not setup.";
        G4Exception("G4Scheduler::ComputeInteractionBetweenTracks",
                    "ITScheduler011",
                    FatalErrorInArgument,
                    exceptionDescription);
      }

      if(changes->WereParentsKilled())
      {
        // DEBUG
        // G4cout << "Erasing tracks : "
        //  << "trackA at time : " << G4BestUnit(trackA->GetGlobalTime() , "Time")
        //  << "\t trackB at time : "<< G4BestUnit(trackB->GetGlobalTime(), "Time")
        //  << "\t GlobalTime : " << G4BestUnit(fGlobalTime, "Time")
        //  << G4endl;

        trackA->SetTrackStatus(fStopAndKill);
        trackB->SetTrackStatus(fStopAndKill);

//        G4TrackList::Pop(trackA);
//        G4TrackList::Pop(trackB);
        fpTrackingManager->EndTracking(trackA);
        fpTrackingManager->EndTracking(trackB);
      }

      delete changes;
    }

    reactionInfo_v->clear(); // never null because point to a non-pointer member of ModelProcessor
  }
  // DEBUG
  //else
  //{
  //    G4cout << "fInteractionStep == true" << G4endl ;
  //}

//  fReactingTracks.clear();
  fReactionSet->CleanAllReaction();

  fpTrackContainer->MergeSecondariesWithMainList();
  fpTrackContainer->KillTracks();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITModelProcessor::DoCalculateStep

(

)

Definition at line 418 of file G4ITModelProcessor.cc.

{
  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<G4VITStepModel*>& 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);
    }
  }
}

Here is the call graph for this function:

void G4ITModelProcessor::ExtractTimeStepperData ( )

protected

Definition at line 210 of file G4ITModelProcessor.cc.

{
  if(fpTrack == 0)
  {
    CleanProcessor();
    return;
  }

  const std::vector<std::vector<G4VITStepModel*> >* model = GetCurrentModel();

  for(unsigned i = 0; i < model->size(); ++i)
  {
    for(unsigned j = 0; j < (*model)[i].size(); ++j)
    {
      G4VITStepModel* mod = (*model)[i][j];

      if(mod == 0)
      {
        continue;
      }

      G4VITTimeStepComputer* stepper(mod->GetTimeStepper());

      G4double sampledMinTimeStep(stepper->GetSampledMinTimeStep());
      G4TrackVectorHandle reactants(stepper->GetReactants());

      if(sampledMinTimeStep < fTSTimeStep)
      {
        /*
         // DEBUG SPECIAL CASE
         if(!reactants)
         {
         G4ExceptionDescription exceptionDescription ;
         CalculateMinTimeStep(); // => at least N (N = nb of tracks) loops   exceptionDescription << "No reactants were found by the time stepper.";
         G4Exception("G4Scheduler::ExtractTimeStepperData","ITScheduler007",
         FatalErrorInArgument,exceptionDescription);
         continue ;
         }
         */

        fTSTimeStep = sampledMinTimeStep;
        //fReactingTracks.clear();

        fReactionSet->CleanAllReaction();
        if(bool(reactants))
        {
          // G4cout << "*** (1) G4Scheduler::ExtractTimeStepperData insert
          //          reactants for " << GetIT(track)->GetName() << G4endl;
          // G4cout << "bool(reactants) = " << bool(reactants) << G4endl;
          // G4cout << reactants->size() << G4endl;
          // G4cout << GetIT(reactants->operator[](0))->GetName() << G4endl;

          //  fReactingTracks.insert(make_pair(track, reactants));
          fReactionSet->AddReactions(fTSTimeStep,
                                     const_cast<G4Track*>(fpTrack),
                                     reactants);
          stepper->ResetReactants();
        }
      }
      else if(fTSTimeStep == sampledMinTimeStep)
      {
        /*
         // DEBUG SPECIAL CASE
         if(!reactants)
         {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No reactants were found by the time stepper.";
         G4Exception("G4Scheduler::ExtractTimeStepperData","ITScheduler008",
         FatalErrorInArgument,exceptionDescription);
         continue ;
         }
         */
        if(bool(reactants))
        {
          // G4cout << "*** (2) G4Scheduler::ExtractTimeStepperData insert
          //          reactants for " << GetIT(track)->GetName() << G4endl;
          // G4cout << "bool(reactants) = " << bool(reactants) << G4endl;
          // G4cout << "trackA : " << GetIT(track)->GetName()
          //        << " ("<< track->GetTrackID() << ")" << G4endl;
          // G4cout << reactants->size() << G4endl;
          // G4cout << GetIT(reactants->operator[](0))->GetName() << G4endl;

          // fReactingTracks.insert(make_pair(track, reactants));

          fReactionSet->AddReactions(fTSTimeStep,
                                     const_cast<G4Track*>(fpTrack),
                                     reactants);
          stepper->ResetReactants();
        }
      }
      else
      {
        if(bool(reactants))
        {
          stepper->ResetReactants();
        }
      }
    }
  }

  CleanProcessor();
}

Here is the call graph for this function:

void G4ITModelProcessor::FindReaction	(	G4ITReactionSet *	reactionSet,
		const double	currentStepTime,
		const double	previousStepTime,
		const bool	reachedUserStepTimeLimit
	)

Definition at line 622 of file G4ITModelProcessor.cc.

{
  // DEBUG
  //    G4cout << "G4ITReactionManager::FindReaction" << G4endl;
  //if (tracks == 0) return;
  if(reactionSet == 0) return;
  if(fpModelHandler->GetAllModelManager()->empty()) return;

  G4ITReactionPerTrackMap& reactionPerTrackMap = reactionSet->GetReactionMap();

  std::map<G4Track*, G4ITReactionPerTrackPtr, compTrackPerID>::iterator tracks_i =
      reactionPerTrackMap.begin();

  //std::map<G4Track*, G4TrackVectorHandle, compTrackPerID>::iterator tracks_i = tracks->begin();

  //    G4cout << "G4ITModelProcessor::FindReaction at step :" << G4ITTimeStepper::Instance()->GetNbSteps() << G4endl;

  //  for (tracks_i = tracks->begin(); tracks_i != tracks->end(); tracks_i++)
  for(tracks_i = reactionPerTrackMap.begin();
      tracks_i != reactionPerTrackMap.end();
      tracks_i = reactionPerTrackMap.begin())
  {
    //G4cout << "here" << G4endl;
    G4Track* trackA = tracks_i->first;
    if(trackA->GetTrackStatus() == fStopAndKill)
    {
      //G4cout << "continue 1" << G4endl;
      continue;
    }

    G4ITReactionPerTrackPtr reactionPerTrack = tracks_i->second;
    G4ITReactionList& reactionList = reactionPerTrack->GetReactionList();

    G4IT* ITA = GetIT(trackA);
    G4ITType ITypeA = ITA->GetITType();

    const std::vector<G4VITStepModel*> model = fCurrentModel[ITypeA];

    G4Track* trackB = 0;
    G4ITType ITypeB(-1);
    G4VITReactionProcess* process = 0;
    G4ITReactionChange* changes = 0;

    assert(reactionList.begin() != reactionList.end());

    for(G4ITReactionList::iterator it = reactionList.begin();
        it != reactionList.end(); it = reactionList.begin())
    {
      G4ITReactionPtr reaction(*it);
      trackB = reaction->GetReactant(trackA);
      if(trackB->GetTrackStatus() == fStopAndKill)
      {
        //G4cout << "continue 2" << G4endl;
        continue;
      }

      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();
      }

      reactionSet->SelectThisReaction(reaction);

      if(process && process->TestReactibility(*trackA,
                                              *trackB,
                                              currentStepTime,
                                              previousStepTime,
                                              reachedUserStepTimeLimit))
      {
        changes = process->MakeReaction(*trackA, *trackB);
      }

      if(changes)
      {
        fReactionInfo.push_back(changes);

        //        G4cout << "pushing reaction for trackA (" << trackA->GetTrackID() << ") and trackB ("
        //             << trackB->GetTrackID() << ")" << G4endl;
        //
        //        G4cout << "nb of secondaries : " << changes->GetNumberOfSecondaries() << G4endl;
        //        G4cout << "with track 0 = " << changes->GetSecondary(0) << G4endl;

        process->ResetChanges();
        changes = 0;

        break;
      }
    }
  }

  //assert(G4ITReaction::gAll->empty() == true);
}

Here is the call graph for this function:

bool G4ITModelProcessor::GetComputeTimeStep ( )

inline

Definition at line 118 of file G4ITModelProcessor.hh.

  {
    return fComputeTimeStep;
  }

Here is the caller graph for this function:

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

inline

Definition at line 211 of file G4ITModelProcessor.hh.

{
  return &fCurrentModel;
}

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

inline

Definition at line 142 of file G4ITModelProcessor.hh.

  {
    return &fReactionInfo;
  }

const G4Track* G4ITModelProcessor::GetTrack ( ) const

inline

Definition at line 147 of file G4ITModelProcessor.hh.

  {
    return fpTrack;
  }

void G4ITModelProcessor::Initialize

(

)

Definition at line 117 of file G4ITModelProcessor.cc.

{
  fpModelHandler->Initialize();
  fReactionSet = G4ITReactionSet::Instance();
  fpTrackContainer = G4ITTrackHolder::Instance();
  fInitialized = true;
  fComputeTimeStep = false;
  fComputeReaction = false;
  if(fpModelHandler->GetTimeStepComputerFlag()) fComputeTimeStep = true;
  if(fpModelHandler->GetReactionProcessFlag()) fComputeReaction = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 315 of file G4ITModelProcessor.cc.

{
  // 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();

  G4VITTimeStepComputer::SetTimes(currentGlobalTime, userMinTime);

  // TODO !!!
  //    if( nbModels1 != 1 || (nbModels1 == 1 && !fpModelManager) )
  {
    int nbModels2 = -1;
    G4VITStepModel* 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);
        G4VITTimeStepComputer* stepper = model->GetTimeStepper();

#if defined (DEBUG_MEM)
        MemStat mem_first, mem_second, mem_diff;
#endif

#if defined (DEBUG_MEM)
        mem_first = MemoryUsage();
#endif

        //      stepper->PrepareForAllProcessors() ;
        stepper->Prepare();

#if defined (DEBUG_MEM)
        mem_second = MemoryUsage();
        mem_diff = mem_second-mem_first;
        G4cout << "\t || MEM || G4ITModelProcessor::InitializeStepper || After computing stepper -> Prepare(), diff is : " << mem_diff << G4endl;
#endif
        fCurrentModel[i][j] = model;
      }
    }

    if(nbModels1 == 1 && nbModels2 == 1)
    {
      fpModelManager = modman;
      fpModel = model;
    }
    else fpModel = 0;
  }
}

Here is the call graph for this function:

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

protected

Assignment operator

Parameters

other

Object to assign from

Returns

A reference to this

Definition at line 110 of file G4ITModelProcessor.cc.

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

void G4ITModelProcessor::RegisterModel	(	double	time,
		G4VITStepModel *	model
	)

Definition at line 104 of file G4ITModelProcessor.cc.

{
  fpModelHandler->RegisterModel(model, time);
}

void G4ITModelProcessor::SetModelHandler ( G4ITModelHandler *  modelHandler )

inline

Definition at line 216 of file G4ITModelProcessor.hh.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITModelProcessor::SetTrack ( const G4Track *  track )

inlineprotected

Definition at line 206 of file G4ITModelProcessor.hh.

{
  fpTrack = track;
}

void G4ITModelProcessor::SetTrackingManager ( G4ITTrackingManager *  trackingManager )

inline

Definition at line 152 of file G4ITModelProcessor.hh.

  {
    fpTrackingManager = trackingManager;
  }

Here is the caller graph for this function:

Member Data Documentation

bool G4ITModelProcessor::fComputeReaction

protected

Definition at line 199 of file G4ITModelProcessor.hh.

bool G4ITModelProcessor::fComputeTimeStep

protected

Definition at line 198 of file G4ITModelProcessor.hh.

std::vector<std::vector<G4VITStepModel*> > G4ITModelProcessor::fCurrentModel

protected

Definition at line 186 of file G4ITModelProcessor.hh.

G4ITType G4ITModelProcessor::fCurrentType1

protected

Definition at line 193 of file G4ITModelProcessor.hh.

G4ITType G4ITModelProcessor::fCurrentType2

protected

Definition at line 194 of file G4ITModelProcessor.hh.

G4bool G4ITModelProcessor::fInitialized

protected

Definition at line 178 of file G4ITModelProcessor.hh.

G4VITStepModel* G4ITModelProcessor::fpModel

protected

Definition at line 190 of file G4ITModelProcessor.hh.

G4ITModelHandler* G4ITModelProcessor::fpModelHandler

protected

Definition at line 179 of file G4ITModelProcessor.hh.

G4ITModelManager* G4ITModelProcessor::fpModelManager

protected

Definition at line 191 of file G4ITModelProcessor.hh.

const G4Track* G4ITModelProcessor::fpTrack

protected

Definition at line 181 of file G4ITModelProcessor.hh.

G4ITTrackHolder* G4ITModelProcessor::fpTrackContainer

protected

Definition at line 176 of file G4ITModelProcessor.hh.

G4ITTrackingManager* G4ITModelProcessor::fpTrackingManager

protected

Definition at line 175 of file G4ITModelProcessor.hh.

std::vector<G4ITReactionChange*> G4ITModelProcessor::fReactionInfo

protected

Definition at line 196 of file G4ITModelProcessor.hh.

G4ITReactionSet* G4ITModelProcessor::fReactionSet

protected

Definition at line 174 of file G4ITModelProcessor.hh.

G4double G4ITModelProcessor::fTSTimeStep

protected

Definition at line 173 of file G4ITModelProcessor.hh.

G4double G4ITModelProcessor::fUserMinTimeStep

protected

Definition at line 182 of file G4ITModelProcessor.hh.

---

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

• source/geant4.10.03.p02/source/processes/electromagnetic/dna/management/include/G4ITModelProcessor.hh
• source/geant4.10.03.p02/source/processes/electromagnetic/dna/management/src/G4ITModelProcessor.cc