#include <GflashHadronWrapperProcess.h>

Inheritance diagram for GflashHadronWrapperProcess:

Public Member Functions
G4String	GetName ()

	GflashHadronWrapperProcess (G4String processName)

G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &step) override

void	Print (const G4Step &astep)

	~GflashHadronWrapperProcess () override

Private Attributes
G4VProcess *	fProcess

G4ProcessVector *	fProcessVector

G4VParticleChange *	particleChange

G4ProcessManager *	pmanager

G4String	theProcessName

Detailed Description

Definition at line 14 of file GflashHadronWrapperProcess.h.

Constructor & Destructor Documentation

◆ GflashHadronWrapperProcess()

GflashHadronWrapperProcess::GflashHadronWrapperProcess ( G4String processName )

Definition at line 15 of file GflashHadronWrapperProcess.cc.

     : particleChange(nullptr), pmanager(nullptr), fProcessVector(nullptr), fProcess(nullptr) {
   theProcessName = processName;
 }

References SimL1EmulatorRepack_CalouGT_cff::processName, and theProcessName.

◆ ~GflashHadronWrapperProcess()

GflashHadronWrapperProcess::~GflashHadronWrapperProcess ( )

override

Definition at line 20 of file GflashHadronWrapperProcess.cc.

20 {}

Member Function Documentation

◆ GetName()

G4String GflashHadronWrapperProcess::GetName ( )

inline

Definition at line 24 of file GflashHadronWrapperProcess.h.

24 { return theProcessName; };

References theProcessName.

◆ PostStepDoIt()

G4VParticleChange * GflashHadronWrapperProcess::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

override

Definition at line 22 of file GflashHadronWrapperProcess.cc.

                                                                                                     {
   // process PostStepDoIt for the original process
  
   particleChange = pRegProcess->PostStepDoIt(track, step);
  
   // specific actions of the wrapper process
  
   // update step/track information after PostStep of the original process is
   // done these steps will be repeated again without additional conflicts even
   // if the parameterized physics process doesn't take over the original process
  
   particleChange->UpdateStepForPostStep(const_cast<G4Step *>(&step));
  
   // we may not want to update G4Track during this wrapper process if
   // G4Track accessors are not used in the G4VFastSimulationModel model
   //  (const_cast<G4Step *> (&step))->UpdateTrack();
  
   // update safety after each invocation of PostStepDoIts
   // G4double safety = std::max(endpointSafety - (endpointSafOrigin -
   // fPostStepPoint->GetPosition()).mag(),0.);
   // step.GetPostStepPoint()->SetSafety(safety);
  
   // the secondaries from the original process are also created at the wrapper
   // process, but they must be deleted whether the parameterized physics is
   // an 'ExclusivelyForced' process or not.  Normally the secondaries will be
   // created after this wrapper process in G4SteppingManager::InvokePSDIP
  
   // store the secondaries from ParticleChange to SecondaryList
  
   G4TrackVector *fSecondary = (const_cast<G4Step *>(&step))->GetfSecondary();
   G4int nSecondarySave = fSecondary->size();
  
   G4int num2ndaries = particleChange->GetNumberOfSecondaries();
   G4Track *tempSecondaryTrack;
  
   for (G4int DSecLoop = 0; DSecLoop < num2ndaries; DSecLoop++) {
     tempSecondaryTrack = particleChange->GetSecondary(DSecLoop);
  
     // Set the process pointer which created this track
     tempSecondaryTrack->SetCreatorProcess(pRegProcess);
  
     // add secondaries from this wrapper process to the existing list
     fSecondary->push_back(tempSecondaryTrack);
  
   }  // end of loop on secondary
  
   // Now we can still impose conditions on the secondaries from ModelTrigger,
   // such as the number of secondaries produced by the original process as well
   // as those by other continuous processes - for the hadronic inelastic
   // interaction, it is always true that
   // particleChange->GetNumberOfSecondaries() > 0
  
   // at this stage, updated step information after all processes involved
   // should be available
  
   //  Print(step);
  
   // call ModelTrigger for the second time - the primary loop of PostStepGPIL
   // is inside G4SteppingManager::DefinePhysicalStepLength().
  
   pmanager = track.GetDefinition()->GetProcessManager();
  
   G4double testGPIL = DBL_MAX;
   G4double fStepLength = 0.0;
   G4ForceCondition fForceCondition = InActivated;
  
   fStepLength = step.GetStepLength();
  
   fProcessVector = pmanager->GetPostStepProcessVector(typeDoIt);
  
   // keep the current status of track, use fPostponeToNextEvent word for
   // this particular PostStep GPIL and then restore G4TrackStatus if the
   // paramterized physics doesn't meet trigger conditions in ModelTrigger
  
   const G4TrackStatus keepStatus = track.GetTrackStatus();
  
   (const_cast<G4Track *>(&track))->SetTrackStatus(fPostponeToNextEvent);
   int fpv_entries = fProcessVector->entries();
   for (G4int ipm = 0; ipm < fpv_entries; ipm++) {
     fProcess = (*fProcessVector)(ipm);
  
     if (fProcess->GetProcessType() == fParameterisation) {
       // test ModelTrigger via PostStepGPIL
  
       testGPIL = fProcess->PostStepGPIL(track, fStepLength, &fForceCondition);
  
       // if G4FastSimulationModel:: ModelTrigger is true, then the parameterized
       // physics process takes over the current process
  
       if (fForceCondition == ExclusivelyForced) {
         // clean up memory for changing the process - counter clean up for
         // the secondaries created by new G4Track in
         // G4HadronicProcess::FillTotalResult
         G4int nsec = particleChange->GetNumberOfSecondaries();
         for (G4int DSecLoop = 0; DSecLoop < nsec; DSecLoop++) {
           G4Track *tempSecondaryTrack = particleChange->GetSecondary(DSecLoop);
           delete tempSecondaryTrack;
         }
         particleChange->Clear();
  
         // updating G4Step between PostStepGPIL and PostStepDoIt for the
         // parameterized process may not be necessary, but do it anyway
  
         (const_cast<G4Step *>(&step))->SetStepLength(testGPIL);
         (const_cast<G4Track *>(&track))->SetStepLength(testGPIL);
  
         step.GetPostStepPoint()->SetStepStatus(fExclusivelyForcedProc);
         ;
         step.GetPostStepPoint()->SetProcessDefinedStep(fProcess);
         step.GetPostStepPoint()->SetSafety(0.0);
  
         // invoke PostStepDoIt: equivalent steps for
         // G4SteppingManager::InvokePSDIP
         particleChange = fProcess->PostStepDoIt(track, step);
  
         // update PostStepPoint of Step according to ParticleChange
         particleChange->UpdateStepForPostStep(const_cast<G4Step *>(&step));
  
         // update G4Track according to ParticleChange after each PostStepDoIt
         (const_cast<G4Step *>(&step))->UpdateTrack();
  
         // update safety after each invocation of PostStepDoIts - acutally this
         // is not necessary for the parameterized physics process, but do it
         // anyway
         step.GetPostStepPoint()->SetSafety(0.0);
  
         // additional nullification
         (const_cast<G4Track *>(&track))->SetTrackStatus(particleChange->GetTrackStatus());
       } else {
         // restore TrackStatus if fForceCondition !=  ExclusivelyForced
         (const_cast<G4Track *>(&track))->SetTrackStatus(keepStatus);
       }
       // assume that there is one and only one parameterized physics
       break;
     }
   }
  
   // remove secondaries of this wrapper process that were added to the secondary
   // list since they will be added in the normal stepping procedure after
   // this->PostStepDoIt in G4SteppingManager::InvokePSDIP
  
   // move the iterator to the (nSecondarySave+1)th element in the secondary list
   G4TrackVector::iterator itv = fSecondary->begin();
   itv += nSecondarySave;
  
   // delete next num2ndaries tracks from the secondary list
   fSecondary->erase(itv, itv + num2ndaries);
  
   // end of specific actions of this wrapper process
  
   return particleChange;
 }

References fProcess, fProcessVector, particleChange, pmanager, and HLT_FULL_cff::track.

◆ Print()

void GflashHadronWrapperProcess::Print ( const G4Step & astep )

Definition at line 175 of file GflashHadronWrapperProcess.cc.

                                                          {
   std::cout << " GflashHadronWrapperProcess ProcessName, PreStepPosition, "
                "preStepPoint KE, PostStepPoint KE, DeltaEnergy Nsec \n "
             << step.GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName() << " "
             << step.GetPostStepPoint()->GetPosition() << " " << step.GetPreStepPoint()->GetKineticEnergy() / GeV << " "
             << step.GetPostStepPoint()->GetKineticEnergy() / GeV << " " << step.GetDeltaEnergy() / GeV << " "
             << particleChange->GetNumberOfSecondaries() << std::endl;
 }