G4ITModelProcessor Class Reference

#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 55 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;
}

Referenced by G4ITModelProcessor(), and operator=().

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 95 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;
            const 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;
}

CleanProcessor()

void G4ITModelProcessor::CleanProcessor

(

)

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

Definition at line 375 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 173 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 != nullptr)
            {
                fpUserTimeStepAction->UserReactionAction(*pTrackA,
                                                         *pTrackB,
                                                         productsVector);
            }
 
#ifdef G4VERBOSE
            if (fVerbose != 0)
            {
                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 != 0) && 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 != 0)
                    {
                        G4cout << GetIT(secondary)->GetName() << " ("
                               << secondary->GetTrackID() << ")";
                    }
#endif
                }
            }
            else
            {
#ifdef G4VERBOSE
                if (fVerbose != 0)
                {
                    G4cout << "No product";
                }
#endif
            }
#ifdef G4VERBOSE
            if (fVerbose != 0)
            {
                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();
}

GetComputeTimeStep()

bool G4ITModelProcessor::GetComputeTimeStep

(

)

const

Definition at line 380 of file G4ITModelProcessor.cc.

{
    return fComputeTimeStep;
}

GetTrack()

const G4Track * G4ITModelProcessor::GetTrack

(

)

const

Definition at line 385 of file G4ITModelProcessor.cc.

{
    return fpTrack;
}

Initialize()

void G4ITModelProcessor::Initialize

(

)

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

InitializeStepper()

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

Definition at line 146 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 72 of file G4ITModelProcessor.cc.

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

SetModelHandler()

void G4ITModelProcessor::SetModelHandler

(

G4ITModelHandler *

pModelHandler

)

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

SetTrack()

void G4ITModelProcessor::SetTrack ( const G4Track * track )

protected

Definition at line 357 of file G4ITModelProcessor.cc.

{
    fpTrack = track;
}

SetTrackingManager()

void G4ITModelProcessor::SetTrackingManager

(

G4ITTrackingManager *

trackingManager

)

Definition at line 390 of file G4ITModelProcessor.cc.

{
    fpTrackingManager = pTrackingManager;
}

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:

• G4ITModelProcessor.hh
• G4ITModelProcessor.cc