#include <G4ITModelProcessor.hh>

Public Member Functions
	G4ITModelProcessor ()

	G4ITModelProcessor (const G4ITModelProcessor &other)=delete

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

virtual	~G4ITModelProcessor ()

void	SetModelHandler (G4ITModelHandler *)

void	SetTrackingManager (G4ITTrackingManager *trackingManager)

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 () const

const G4Track *	GetTrack () const

Protected Member Functions
void	SetTrack (const G4Track *)

Protected Attributes
G4double	fTSTimeStep

G4ITReactionSet *	fReactionSet

G4ITTrackingManager *	fpTrackingManager

G4ITTrackHolder *	fpTrackContainer

G4bool	fInitialized

G4ITModelHandler *	fpModelHandler

const G4Track *	fpTrack

G4double	fUserMinTimeStep

std::vector< G4VITStepModel * >	fActiveModels

G4VITStepModel *	fpActiveModelWithMinTimeStep

std::vector< std::unique_ptr< 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.

Deprecated:: This class will be removed

Definition at line 71 of file G4ITModelProcessor.hh.

Constructor & Destructor Documentation

◆ G4ITModelProcessor() [1/2]

G4ITModelProcessor::G4ITModelProcessor ( )

Definition at line 53 of file G4ITModelProcessor.cc.

{
    fpTrack = nullptr;
    fInitialized = false;
    fUserMinTimeStep = -1.;
    fTSTimeStep = DBL_MAX;
    fpTrackingManager = nullptr;
    fReactionSet = nullptr;
    fpTrackContainer = nullptr;
    fpModelHandler = nullptr;
    fpActiveModelWithMinTimeStep = nullptr;
    fComputeTimeStep = false;
    fComputeReaction = false;
}

◆ G4ITModelProcessor() [2/2]

G4ITModelProcessor::G4ITModelProcessor ( const G4ITModelProcessor & other )

delete

◆ ~G4ITModelProcessor()

G4ITModelProcessor::~G4ITModelProcessor ( )

virtualdefault

Member Function Documentation

◆ CalculateMinTimeStep()

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

Definition at line 93 of file G4ITModelProcessor.cc.

{
 
#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DETAILED_STEPPING)
    MemStat mem_first, mem_second, mem_diff;
    mem_first = MemoryUsage();
#endif
 
    fpActiveModelWithMinTimeStep = nullptr;
    fTSTimeStep = DBL_MAX;
 
    InitializeStepper(currentGlobalTime, definedMinTimeStep);
 
#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
 
    for (auto& pStepModel : fActiveModels)
    {
        fTSTimeStep =
            pStepModel->GetTimeStepper()->CalculateMinTimeStep(
                currentGlobalTime,
                definedMinTimeStep);
 
        fpActiveModelWithMinTimeStep = pStepModel;
 
        if(fTSTimeStep == -1){
            fpActiveModelWithMinTimeStep->GetReactionProcess()->Initialize();
            if(fReactionSet->Empty()) return DBL_MAX;
            auto fReactionSetInTime = fReactionSet->GetReactionsPerTime();
            fTSTimeStep = fReactionSetInTime.begin()->get()->GetTime() - currentGlobalTime;
        }
    }
 
#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;
}

Referenced by G4Scheduler::Stepping().

◆ CleanProcessor()

void G4ITModelProcessor::CleanProcessor ( )

Restore the original state. This method should be called only by G4Scheduler

Definition at line 373 of file G4ITModelProcessor.cc.

{
    fpTrack = nullptr;
}

◆ ComputeTrackReaction()

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

Definition at line 171 of file G4ITModelProcessor.cc.

{
    if (fReactionSet->Empty())
    {
        return;
    }
 
    if (fITStepStatus == eCollisionBetweenTracks)
    {
        G4VITReactionProcess* pReactionProcess = fpActiveModelWithMinTimeStep->GetReactionProcess();
        fReactionInfo = pReactionProcess->FindReaction(fReactionSet,
                currentTimeStep,
                fGlobalTime,
                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);
 
        for (auto& pChanges : fReactionInfo)
        {
            auto pTrackA = const_cast<G4Track*>(pChanges->GetTrackA());
            auto pTrackB = const_cast<G4Track*>(pChanges->GetTrackB());
 
            if (pTrackA == nullptr
                || pTrackB == nullptr
                || pTrackA->GetTrackStatus() == fStopAndKill
                || pTrackB->GetTrackStatus() == fStopAndKill)
            {
                continue;
            }
 
            G4int nbSecondaries = pChanges->GetNumberOfSecondaries();
            const std::vector<G4Track*>* productsVector = pChanges->GetfSecondary();
 
            if (fpUserTimeStepAction)
            {
                fpUserTimeStepAction->UserReactionAction(*pTrackA,
                                                         *pTrackB,
                                                         productsVector);
            }
 
#ifdef G4VERBOSE
            if (fVerbose)
            {
                G4cout << "At time : " << std::setw(7) << G4BestUnit(fGlobalTime, "Time")
                       << " Reaction : " << GetIT(pTrackA)->GetName() << " ("
                       << pTrackA->GetTrackID() << ") + " << GetIT(pTrackB)->GetName() << " ("
                       << pTrackB->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(pTrackA->GetTrackID(),
                                                  pTrackB->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 developers." << 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 (pTrackA->GetTrackID() == 0 || pTrackB->GetTrackID() == 0)
            {
                G4Track* pTrack = nullptr;
                if (pTrackA->GetTrackID() == 0)
                {
                    pTrack = pTrackA;
                }
                else
                {
                    pTrack = pTrackB;
                }
 
                G4ExceptionDescription exceptionDescription;
                exceptionDescription
                    << "The problem was found for the reaction between tracks :"
                    << pTrackA->GetParticleDefinition()->GetParticleName() << " ("
                    << pTrackA->GetTrackID() << ") & "
                    << pTrackB->GetParticleDefinition()->GetParticleName() << " ("
                    << pTrackB->GetTrackID() << "). \n";
 
                if (pTrack->GetStep() == nullptr)
                {
                    exceptionDescription << "Also no step was found"
                                         << " ie track->GetStep() == 0 \n";
                }
 
                exceptionDescription << "Parent ID of trackA : "
                                     << pTrackA->GetParentID() << "\n";
                exceptionDescription << "Parent ID of trackB : "
                                     << pTrackB->GetParentID() << "\n";
 
                exceptionDescription
                    << "The ID of one of the reaction track was not setup.";
                G4Exception("G4Scheduler::ComputeInteractionBetweenTracks",
                            "ITScheduler011",
                            FatalErrorInArgument,
                            exceptionDescription);
            }
 
            if (pChanges->WereParentsKilled())
            {
                pTrackA->SetTrackStatus(fStopAndKill);
                pTrackB->SetTrackStatus(fStopAndKill);
 
                fpTrackingManager->EndTracking(pTrackA);
                fpTrackingManager->EndTracking(pTrackB);
            }
 
            pChanges.reset(nullptr);
        }
 
        fReactionInfo.clear();
    }
 
//    fReactionSet->CleanAllReaction();
 
    fpTrackContainer->MergeSecondariesWithMainList();
    fpTrackContainer->KillTracks();
}

Referenced by G4Scheduler::Stepping().

◆ GetComputeTimeStep()

bool G4ITModelProcessor::GetComputeTimeStep ( ) const

Definition at line 378 of file G4ITModelProcessor.cc.

{
    return fComputeTimeStep;
}

Referenced by G4Scheduler::Stepping().

◆ GetTrack()

const G4Track * G4ITModelProcessor::GetTrack ( ) const

Definition at line 383 of file G4ITModelProcessor.cc.

{
    return fpTrack;
}

◆ Initialize()

void G4ITModelProcessor::Initialize ( )

Definition at line 75 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;
    }
}

Referenced by G4Scheduler::Process().

◆ InitializeStepper()

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

Definition at line 144 of file G4ITModelProcessor.cc.

{
    G4VITTimeStepComputer::SetTimes(currentGlobalTime, userMinTime);
 
#if defined (DEBUG_MEM)
    MemStat mem_first, mem_second, mem_diff;
            mem_first = MemoryUsage();
#endif
 
    fActiveModels = fpModelHandler->GetActiveModels(currentGlobalTime);
 
    for (auto& pModel : fActiveModels)
    {
        pModel->PrepareNewTimeStep();
    }
 
#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
 
}

Referenced by CalculateMinTimeStep().

◆ operator=()

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

delete

◆ RegisterModel()

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

Definition at line 70 of file G4ITModelProcessor.cc.

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

◆ SetModelHandler()

void G4ITModelProcessor::SetModelHandler ( G4ITModelHandler * pModelHandler )

Definition at line 360 of file G4ITModelProcessor.cc.

{
    if (fInitialized)
    {
        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 = pModelHandler;
}

Referenced by G4Scheduler::Initialize().

◆ SetTrack()

void G4ITModelProcessor::SetTrack ( const G4Track * track )

protected

Definition at line 355 of file G4ITModelProcessor.cc.

{
    fpTrack = track;
}

◆ SetTrackingManager()

void G4ITModelProcessor::SetTrackingManager ( G4ITTrackingManager * trackingManager )

Definition at line 388 of file G4ITModelProcessor.cc.

{
    fpTrackingManager = pTrackingManager;
}

Referenced by G4Scheduler::Initialize().

Member Data Documentation

◆ fActiveModels

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

protected

Definition at line 123 of file G4ITModelProcessor.hh.

Referenced by CalculateMinTimeStep(), and InitializeStepper().

◆ fComputeReaction

bool G4ITModelProcessor::fComputeReaction

protected

Definition at line 129 of file G4ITModelProcessor.hh.

Referenced by G4ITModelProcessor(), and Initialize().

◆ fComputeTimeStep

bool G4ITModelProcessor::fComputeTimeStep

protected

Definition at line 128 of file G4ITModelProcessor.hh.

Referenced by G4ITModelProcessor(), GetComputeTimeStep(), and Initialize().

◆ fInitialized

G4bool G4ITModelProcessor::fInitialized

protected

Definition at line 117 of file G4ITModelProcessor.hh.

Referenced by G4ITModelProcessor(), Initialize(), and SetModelHandler().

◆ fpActiveModelWithMinTimeStep

G4VITStepModel* G4ITModelProcessor::fpActiveModelWithMinTimeStep

protected

Definition at line 124 of file G4ITModelProcessor.hh.

Referenced by CalculateMinTimeStep(), ComputeTrackReaction(), and G4ITModelProcessor().

◆ fpModelHandler

G4ITModelHandler* G4ITModelProcessor::fpModelHandler

protected

Definition at line 118 of file G4ITModelProcessor.hh.

Referenced by G4ITModelProcessor(), Initialize(), InitializeStepper(), RegisterModel(), and SetModelHandler().

◆ fpTrack

const G4Track* G4ITModelProcessor::fpTrack

protected

Definition at line 120 of file G4ITModelProcessor.hh.

Referenced by CleanProcessor(), G4ITModelProcessor(), GetTrack(), and SetTrack().

◆ fpTrackContainer

G4ITTrackHolder* G4ITModelProcessor::fpTrackContainer

protected

Definition at line 115 of file G4ITModelProcessor.hh.

Referenced by ComputeTrackReaction(), G4ITModelProcessor(), and Initialize().

◆ fpTrackingManager

G4ITTrackingManager* G4ITModelProcessor::fpTrackingManager

protected

Definition at line 114 of file G4ITModelProcessor.hh.

Referenced by ComputeTrackReaction(), G4ITModelProcessor(), and SetTrackingManager().

◆ fReactionInfo

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

protected

Definition at line 126 of file G4ITModelProcessor.hh.

Referenced by ComputeTrackReaction().

◆ fReactionSet

G4ITReactionSet* G4ITModelProcessor::fReactionSet

protected

Definition at line 113 of file G4ITModelProcessor.hh.

Referenced by CalculateMinTimeStep(), ComputeTrackReaction(), G4ITModelProcessor(), and Initialize().

◆ fTSTimeStep

G4double G4ITModelProcessor::fTSTimeStep

protected

Definition at line 112 of file G4ITModelProcessor.hh.

Referenced by CalculateMinTimeStep(), and G4ITModelProcessor().

◆ fUserMinTimeStep

G4double G4ITModelProcessor::fUserMinTimeStep

protected

Definition at line 121 of file G4ITModelProcessor.hh.

Referenced by G4ITModelProcessor().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4ITModelProcessor() [1/2]

◆ G4ITModelProcessor() [2/2]

◆ ~G4ITModelProcessor()

Member Function Documentation

◆ CalculateMinTimeStep()

◆ CleanProcessor()

◆ ComputeTrackReaction()

◆ GetComputeTimeStep()

◆ GetTrack()

◆ Initialize()

◆ InitializeStepper()

◆ operator=()

◆ RegisterModel()

◆ SetModelHandler()

◆ SetTrack()

◆ SetTrackingManager()

Member Data Documentation

◆ fActiveModels

◆ fComputeReaction

◆ fComputeTimeStep

◆ fInitialized

◆ fpActiveModelWithMinTimeStep

◆ fpModelHandler

◆ fpTrack

◆ fpTrackContainer

◆ fpTrackingManager

◆ fReactionInfo

◆ fReactionSet

◆ fTSTimeStep

◆ fUserMinTimeStep