Geant4-11
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes
G4DecayWithSpin Class Reference

#include <G4DecayWithSpin.hh>

Inheritance diagram for G4DecayWithSpin:
G4Decay G4VRestDiscreteProcess G4VProcess

Public Member Functions

virtual G4VParticleChangeAlongStepDoIt (const G4Track &, const G4Step &)
 
virtual G4double AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
 
G4double AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition) override
 
G4double AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &) override
 
virtual void BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
 
virtual void DumpInfo () const
 
virtual void EndTracking () override
 
 G4DecayWithSpin (const G4String &processName="DecayWithSpin")
 
G4double GetCurrentInteractionLength () const
 
const G4VExtDecayerGetExtDecayer () const
 
const G4VProcessGetMasterProcess () const
 
G4double GetNumberOfInteractionLengthLeft () const
 
const G4StringGetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
 
G4double GetPILfactor () const
 
virtual const G4ProcessManagerGetProcessManager ()
 
const G4StringGetProcessName () const
 
G4int GetProcessSubType () const
 
G4ProcessType GetProcessType () const
 
G4double GetRemainderLifeTime () const
 
G4double GetTotalNumberOfInteractionLengthTraversed () const
 
G4int GetVerboseLevel () const
 
G4bool isAlongStepDoItIsEnabled () const
 
virtual G4bool IsApplicable (const G4ParticleDefinition &) override
 
G4bool isAtRestDoItIsEnabled () const
 
G4bool isPostStepDoItIsEnabled () const
 
G4bool operator!= (const G4VProcess &right) const
 
G4bool operator== (const G4VProcess &right) const
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
 
G4double PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
virtual void PreparePhysicsTable (const G4ParticleDefinition &)
 
virtual void PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
 
virtual void ProcessDescription (std::ostream &outFile) const override
 
virtual void ResetNumberOfInteractionLengthLeft ()
 
virtual G4bool RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
void SetExtDecayer (G4VExtDecayer *)
 
virtual void SetMasterProcess (G4VProcess *masterP)
 
void SetPILfactor (G4double value)
 
virtual void SetProcessManager (const G4ProcessManager *)
 
void SetProcessSubType (G4int)
 
void SetProcessType (G4ProcessType)
 
void SetVerboseLevel (G4int value)
 
virtual void StartTracking (G4Track *) override
 
virtual G4bool StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
virtual ~G4DecayWithSpin ()
 

Static Public Member Functions

static const G4StringGetProcessTypeName (G4ProcessType)
 

Protected Member Functions

virtual G4VParticleChangeAtRestDoIt (const G4Track &aTrack, const G4Step &aStep) override
 
void ClearNumberOfInteractionLengthLeft ()
 
virtual void DaughterPolarization (const G4Track &aTrack, G4DecayProducts *products)
 
virtual G4VParticleChangeDecayIt (const G4Track &aTrack, const G4Step &aStep)
 
virtual G4double GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition) override
 
virtual G4double GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *condition) override
 
virtual G4VParticleChangePostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override
 
void SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
 

Protected Attributes

G4ParticleChange aParticleChange
 
const G4ProcessManageraProcessManager = nullptr
 
G4double currentInteractionLength = -1.0
 
G4bool enableAlongStepDoIt = true
 
G4bool enableAtRestDoIt = true
 
G4bool enablePostStepDoIt = true
 
G4ParticleChangeForDecay fParticleChangeForDecay
 
G4double fRemainderLifeTime
 
const G4double HighestValue
 
G4VExtDecayerpExtDecayer
 
G4VParticleChangepParticleChange = nullptr
 
G4double theInitialNumberOfInteractionLength = -1.0
 
G4double theNumberOfInteractionLengthLeft = -1.0
 
G4String thePhysicsTableFileName
 
G4double thePILfactor = 1.0
 
G4String theProcessName
 
G4int theProcessSubType = -1
 
G4ProcessType theProcessType = fNotDefined
 
G4int verboseLevel
 

Private Member Functions

G4ThreeVector Spin_Precession (const G4Step &aStep, G4ThreeVector B, G4double deltatime)
 

Private Attributes

G4ProcessTablefProcessTable = nullptr
 
G4VProcessmasterProcessShadow = nullptr
 

Detailed Description

Definition at line 43 of file G4DecayWithSpin.hh.

Constructor & Destructor Documentation

◆ G4DecayWithSpin()

G4DecayWithSpin::G4DecayWithSpin ( const G4String processName = "DecayWithSpin")

Definition at line 52 of file G4DecayWithSpin.cc.

52 :G4Decay(processName)
53{
54 // set Process Sub Type
55 SetProcessSubType(static_cast<int>(DECAY_WithSpin));
56
57}
@ DECAY_WithSpin
G4Decay(const G4String &processName="Decay")
Definition: G4Decay.cc:62
void SetProcessSubType(G4int)
Definition: G4VProcess.hh:406

References DECAY_WithSpin, and G4VProcess::SetProcessSubType().

◆ ~G4DecayWithSpin()

G4DecayWithSpin::~G4DecayWithSpin ( )
virtual

Definition at line 59 of file G4DecayWithSpin.cc.

59{}

Member Function Documentation

◆ AlongStepDoIt()

virtual G4VParticleChange * G4VRestDiscreteProcess::AlongStepDoIt ( const G4Track ,
const G4Step  
)
inlinevirtualinherited

Implements G4VProcess.

Definition at line 87 of file G4VRestDiscreteProcess.hh.

90 { return 0; }

◆ AlongStepGetPhysicalInteractionLength()

virtual G4double G4VRestDiscreteProcess::AlongStepGetPhysicalInteractionLength ( const G4Track ,
G4double  ,
G4double  ,
G4double ,
G4GPILSelection  
)
inlinevirtualinherited

Implements G4VProcess.

Definition at line 78 of file G4VRestDiscreteProcess.hh.

84 { return -1.0; }

◆ AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL ( const G4Track track,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double proposedSafety,
G4GPILSelection selection 
)
inlineinherited

Definition at line 461 of file G4VProcess.hh.

466{
467 return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
468 currentMinimumStep, proposedSafety, selection);
469}
virtual G4double AlongStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

G4VParticleChange * G4DecayWithSpin::AtRestDoIt ( const G4Track aTrack,
const G4Step aStep 
)
overrideprotectedvirtual

Reimplemented from G4Decay.

Definition at line 109 of file G4DecayWithSpin.cc.

110{
111
112// get particle
113 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
114 const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
115
116// get parent_polarization
117 G4ThreeVector parent_polarization = aParticle->GetPolarization();
118
119 if(parent_polarization == G4ThreeVector(0,0,0)) {
120 // Generate random polarization direction
121 G4double cost = 1. - 2.*G4UniformRand();
122 G4double sint = std::sqrt((1.-cost)*(1.+cost));
123
125 G4double sinp = std::sin(phi);
126 G4double cosp = std::cos(phi);
127
128 G4double px = sint*cosp;
129 G4double py = sint*sinp;
130 G4double pz = cost;
131
132 parent_polarization.setX(px);
133 parent_polarization.setY(py);
134 parent_polarization.setZ(pz);
135
136 }else{
137
138 G4FieldManager* fieldMgr = aStep.GetTrack()->GetVolume()->
139 GetLogicalVolume()->GetFieldManager();
140 if (fieldMgr == nullptr) {
141 G4TransportationManager *transportMgr =
143 G4PropagatorInField* fFieldPropagator =
144 transportMgr->GetPropagatorInField();
145 if (fFieldPropagator) fieldMgr =
146 fFieldPropagator->GetCurrentFieldManager();
147 }
148
149 const G4Field* field = nullptr;
150 if (fieldMgr != nullptr) field = fieldMgr->GetDetectorField();
151
152 if ( field != nullptr ) {
153 G4double point[4];
154 point[0] = (aStep.GetPostStepPoint()->GetPosition())[0];
155 point[1] = (aStep.GetPostStepPoint()->GetPosition())[1];
156 point[2] = (aStep.GetPostStepPoint()->GetPosition())[2];
157 point[3] = aTrack.GetGlobalTime();
158
159 G4double fieldValue[6] ={ 0., 0., 0., 0., 0., 0.};
160 field -> GetFieldValue(point,fieldValue);
161 G4ThreeVector B(fieldValue[0],fieldValue[1],fieldValue[2]);
162
163 // Call the spin precession only for non-zero mag. field
164 if (B.mag2() > 0.) parent_polarization =
166
167 }
168 }
169
170// decay table
171 G4DecayTable *decaytable = aParticleDef->GetDecayTable();
172 if ( decaytable != nullptr) {
173 for (G4int ip=0; ip<decaytable->entries(); ip++){
174 decaytable->GetDecayChannel(ip)->SetPolarization(parent_polarization);
175 }
176 }
177
178 G4ParticleChangeForDecay* pParticleChangeForDecay;
179 pParticleChangeForDecay = (G4ParticleChangeForDecay*)G4Decay::DecayIt(aTrack,aStep);
180 pParticleChangeForDecay->ProposePolarization(parent_polarization);
181
182 return pParticleChangeForDecay;
183
184}
G4double B(G4double temperature)
static constexpr double twopi
Definition: G4SIunits.hh:56
CLHEP::Hep3Vector G4ThreeVector
double G4double
Definition: G4Types.hh:83
int G4int
Definition: G4Types.hh:85
#define G4UniformRand()
Definition: Randomize.hh:52
void setY(double)
void setZ(double)
void setX(double)
G4VDecayChannel * GetDecayChannel(G4int index) const
G4int entries() const
G4ThreeVector Spin_Precession(const G4Step &aStep, G4ThreeVector B, G4double deltatime)
virtual G4VParticleChange * DecayIt(const G4Track &aTrack, const G4Step &aStep)
Definition: G4Decay.cc:180
G4double fRemainderLifeTime
Definition: G4Decay.hh:173
G4ParticleDefinition * GetDefinition() const
const G4ThreeVector & GetPolarization() const
const G4Field * GetDetectorField() const
void ProposePolarization(G4double Px, G4double Py, G4double Pz)
G4DecayTable * GetDecayTable() const
G4FieldManager * GetCurrentFieldManager()
const G4ThreeVector & GetPosition() const
G4Track * GetTrack() const
G4StepPoint * GetPostStepPoint() const
G4VPhysicalVolume * GetVolume() const
G4double GetGlobalTime() const
const G4DynamicParticle * GetDynamicParticle() const
static G4TransportationManager * GetTransportationManager()
G4PropagatorInField * GetPropagatorInField() const
void SetPolarization(const G4ThreeVector &)

References B(), G4Decay::DecayIt(), G4DecayTable::entries(), G4Decay::fRemainderLifeTime, G4UniformRand, G4PropagatorInField::GetCurrentFieldManager(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4DynamicParticle::GetDefinition(), G4FieldManager::GetDetectorField(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetPolarization(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4TransportationManager::GetPropagatorInField(), G4Step::GetTrack(), G4TransportationManager::GetTransportationManager(), G4Track::GetVolume(), G4ParticleChangeForDecay::ProposePolarization(), G4VDecayChannel::SetPolarization(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), Spin_Precession(), and twopi.

◆ AtRestGetPhysicalInteractionLength()

G4double G4Decay::AtRestGetPhysicalInteractionLength ( const G4Track track,
G4ForceCondition condition 
)
overridevirtualinherited

Reimplemented from G4VRestDiscreteProcess.

Definition at line 477 of file G4Decay.cc.

481{
482 // condition is set to "Not Forced"
484
486 if (pTime >= 0.) {
487 fRemainderLifeTime = pTime - track.GetProperTime();
489 } else {
492 }
493 return fRemainderLifeTime;
494}
G4double condition(const G4ErrorSymMatrix &m)
@ NotForced
virtual G4double GetMeanLifeTime(const G4Track &aTrack, G4ForceCondition *condition) override
Definition: G4Decay.cc:100
G4double GetPreAssignedDecayProperTime() const
G4double GetProperTime() const
G4double theNumberOfInteractionLengthLeft
Definition: G4VProcess.hh:331
#define DBL_MIN
Definition: templates.hh:54

References condition(), DBL_MIN, G4Decay::fRemainderLifeTime, G4Track::GetDynamicParticle(), G4Decay::GetMeanLifeTime(), G4DynamicParticle::GetPreAssignedDecayProperTime(), G4Track::GetProperTime(), NotForced, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ AtRestGPIL()

G4double G4VProcess::AtRestGPIL ( const G4Track track,
G4ForceCondition condition 
)
inlineinherited

Definition at line 472 of file G4VProcess.hh.

474{
476}
G4double thePILfactor
Definition: G4VProcess.hh:352
virtual G4double AtRestGetPhysicalInteractionLength(const G4Track &track, G4ForceCondition *condition)=0

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BuildPhysicsTable()

void G4Decay::BuildPhysicsTable ( const G4ParticleDefinition )
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 175 of file G4Decay.cc.

176{
177 return;
178}

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition part)
virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

201{
202 BuildPhysicsTable(part);
203}
virtual void BuildPhysicsTable(const G4ParticleDefinition &)
Definition: G4VProcess.hh:187

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )
inlineprotectedinherited

◆ DaughterPolarization()

void G4Decay::DaughterPolarization ( const G4Track aTrack,
G4DecayProducts products 
)
protectedvirtualinherited

Reimplemented in G4PionDecayMakeSpin.

Definition at line 386 of file G4Decay.cc.

387{
388 // empty implementation
389}

Referenced by G4Decay::DecayIt().

◆ DecayIt()

G4VParticleChange * G4Decay::DecayIt ( const G4Track aTrack,
const G4Step aStep 
)
protectedvirtualinherited

Definition at line 180 of file G4Decay.cc.

181{
182 // The DecayIt() method returns by pointer a particle-change object.
183 // Units are expressed in GEANT4 internal units.
184
185 // Initialize ParticleChange
186 // all members of G4VParticleChange are set to equal to
187 // corresponding member in G4Track
189
190 // get particle
191 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
192 const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
193
194 // check if the particle is stable
195 if (aParticleDef->GetPDGStable()) return &fParticleChangeForDecay ;
196
197
198 //check if thePreAssignedDecayProducts exists
199 const G4DecayProducts* o_products = (aParticle->GetPreAssignedDecayProducts());
200 G4bool isPreAssigned = (o_products != nullptr);
201 G4DecayProducts* products = nullptr;
202
203 // decay table
204 G4DecayTable *decaytable = aParticleDef->GetDecayTable();
205
206 // check if external decayer exists
207 G4bool isExtDecayer = (decaytable == nullptr) && (pExtDecayer != nullptr);
208
209 // Error due to NO Decay Table
210 if ( (decaytable == nullptr) && !isExtDecayer && !isPreAssigned ){
211 if (GetVerboseLevel()>0) {
212 G4cout << "G4Decay::DoIt : decay table not defined for ";
213 G4cout << aParticle->GetDefinition()->GetParticleName()<< G4endl;
214 }
216 ed << "For " << aParticle->GetDefinition()->GetParticleName()
217 << " decay probability exist but decay table is not defined "
218 << "- the particle will be killed;\n"
219 << " isExtDecayer: " << isExtDecayer
220 << "; isPreAssigned: " << isPreAssigned;
221 G4Exception( "G4Decay::DecayIt ",
222 "DECAY101",JustWarning, ed);
223
225 // Kill the parent particle
228
231 }
232
233 if (isPreAssigned) {
234 // copy decay products
235 products = new G4DecayProducts(*o_products);
236 } else if ( isExtDecayer ) {
237 // decay according to external decayer
238 products = pExtDecayer->ImportDecayProducts(aTrack);
239 } else {
240 // Decay according to decay table.
241 // Keep trying to choose a candidate decay channel if the dynamic mass
242 // of the decaying particle is below the sum of the PDG masses of the
243 // candidate daughter particles.
244 // This is needed because the decay table used in Geant4 is based on
245 // the assumption of nominal PDG masses, but a wide resonance can have
246 // a dynamic masses well below its nominal PDG masses, and therefore
247 // some of its decay channels can be below the kinematical threshold.
248 // Note that, for simplicity, we ignore here the possibility that
249 // one or more of the candidate daughter particles can be, in turn,
250 // wide resonance. However, if this is the case, and the channel is
251 // accepted, then the masses of the resonance daughter particles will
252 // be sampled by taking into account their widths.
253 G4VDecayChannel* decaychannel = nullptr;
254 G4double massParent = aParticle->GetMass();
255 decaychannel = decaytable->SelectADecayChannel(massParent);
256 if ( decaychannel == nullptr) {
257 // decay channel not found
259 ed << "Can not determine decay channel for "
260 << aParticleDef->GetParticleName() << G4endl
261 << " mass of dynamic particle: "
262 << massParent/GeV << " (GEV)" << G4endl
263 << " dacay table has " << decaytable->entries()
264 << " entries" << G4endl;
265 G4double checkedmass=massParent;
266 if (massParent < 0.) {
267 checkedmass=aParticleDef->GetPDGMass();
268 ed << "Using PDG mass ("<<checkedmass/GeV
269 << "(GeV)) in IsOKWithParentMass" << G4endl;
270 }
271 for (G4int ic =0;ic <decaytable->entries();++ic) {
272 G4VDecayChannel * dc= decaytable->GetDecayChannel(ic);
273 ed << ic << ": BR " << dc->GetBR() << ", IsOK? "
274 << dc->IsOKWithParentMass(checkedmass)
275 << ", --> ";
276 G4int ndaughters=dc->GetNumberOfDaughters();
277 for (G4int id=0;id<ndaughters;++id) {
278 if (id>0) ed << " + "; // seperator, except for first
279 ed << dc->GetDaughterName(id);
280 }
281 ed << G4endl;
282 }
283 G4Exception("G4Decay::DoIt", "DECAY003", FatalException,ed);
284 } else {
285 // execute DecayIt()
286#ifdef G4VERBOSE
287 G4int temp = decaychannel->GetVerboseLevel();
288 if (GetVerboseLevel()>1) {
289 G4cout << "G4Decay::DoIt : selected decay channel addr:"
290 << decaychannel <<G4endl;
291 decaychannel->SetVerboseLevel(GetVerboseLevel());
292 }
293#endif
294 products = decaychannel->DecayIt(aParticle->GetMass());
295#ifdef G4VERBOSE
296 if (GetVerboseLevel()>1) {
297 decaychannel->SetVerboseLevel(temp);
298 }
299#endif
300#ifdef G4VERBOSE
301 if (GetVerboseLevel()>2) {
302 if (! products->IsChecked() ) products->DumpInfo();
303 }
304#endif
305 }
306 }
307
308 // get parent particle information ...................................
309 G4double ParentEnergy = aParticle->GetTotalEnergy();
310 G4double ParentMass = aParticle->GetMass();
311 if (ParentEnergy < ParentMass) {
313 ed << "Total Energy is less than its mass - increased the energy"
314 << "\n Particle: " << aParticle->GetDefinition()->GetParticleName()
315 << "\n Energy:" << ParentEnergy/MeV << "[MeV]"
316 << "\n Mass:" << ParentMass/MeV << "[MeV]";
317 G4Exception( "G4Decay::DecayIt ",
318 "DECAY102",JustWarning, ed);
319 ParentEnergy = ParentMass;
320 }
321
322 G4ThreeVector ParentDirection(aParticle->GetMomentumDirection());
323
324 //boost all decay products to laboratory frame
325 G4double energyDeposit = 0.0;
326 G4double finalGlobalTime = aTrack.GetGlobalTime();
327 G4double finalLocalTime = aTrack.GetLocalTime();
328 if (aTrack.GetTrackStatus() == fStopButAlive ){
329 // AtRest case
330 finalGlobalTime += fRemainderLifeTime;
331 finalLocalTime += fRemainderLifeTime;
332 energyDeposit += aParticle->GetKineticEnergy();
333 if (isPreAssigned) products->Boost( ParentEnergy, ParentDirection);
334 } else {
335 // PostStep case
336 if (!isExtDecayer) products->Boost( ParentEnergy, ParentDirection);
337 }
338 // set polarization for daughter particles
339 DaughterPolarization(aTrack, products);
340
341
342 //add products in fParticleChangeForDecay
343 G4int numberOfSecondaries = products->entries();
345#ifdef G4VERBOSE
346 if (GetVerboseLevel()>1) {
347 G4cout << "G4Decay::DoIt : Decay vertex :";
348 G4cout << " Time: " << finalGlobalTime/ns << "[ns]";
349 G4cout << " X:" << (aTrack.GetPosition()).x() /cm << "[cm]";
350 G4cout << " Y:" << (aTrack.GetPosition()).y() /cm << "[cm]";
351 G4cout << " Z:" << (aTrack.GetPosition()).z() /cm << "[cm]";
352 G4cout << G4endl;
353 G4cout << "G4Decay::DoIt : decay products in Lab. Frame" << G4endl;
354 products->DumpInfo();
355 }
356#endif
357 G4int index;
358 G4ThreeVector currentPosition;
359 const G4TouchableHandle thand = aTrack.GetTouchableHandle();
360 for (index=0; index < numberOfSecondaries; index++){
361 // get current position of the track
362 currentPosition = aTrack.GetPosition();
363 // create a new track object
364 G4Track* secondary = new G4Track( products->PopProducts(),
365 finalGlobalTime ,
366 currentPosition );
367 // switch on good for tracking flag
368 secondary->SetGoodForTrackingFlag();
369 secondary->SetTouchableHandle(thand);
370 // add the secondary track in the List
372 }
373 delete products;
374
375 // Kill the parent particle
379
380 // Clear NumberOfInteractionLengthLeft
382
384}
@ JustWarning
@ FatalException
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
static constexpr double GeV
Definition: G4SIunits.hh:203
static constexpr double MeV
Definition: G4SIunits.hh:200
static constexpr double cm
Definition: G4SIunits.hh:99
@ fStopAndKill
@ fStopButAlive
bool G4bool
Definition: G4Types.hh:86
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
void DumpInfo() const
G4int entries() const
G4DynamicParticle * PopProducts()
G4bool IsChecked() const
void Boost(G4double totalEnergy, const G4ThreeVector &momentumDirection)
G4VDecayChannel * SelectADecayChannel(G4double parentMass=-1.)
Definition: G4DecayTable.cc:82
G4VExtDecayer * pExtDecayer
Definition: G4Decay.hh:179
virtual void DaughterPolarization(const G4Track &aTrack, G4DecayProducts *products)
Definition: G4Decay.cc:386
G4ParticleChangeForDecay fParticleChangeForDecay
Definition: G4Decay.hh:176
G4double GetMass() const
const G4ThreeVector & GetMomentumDirection() const
const G4DecayProducts * GetPreAssignedDecayProducts() const
G4double GetKineticEnergy() const
G4double GetTotalEnergy() const
virtual void Initialize(const G4Track &)
G4bool GetPDGStable() const
const G4String & GetParticleName() const
G4TrackStatus GetTrackStatus() const
const G4ThreeVector & GetPosition() const
void SetTouchableHandle(const G4TouchableHandle &apValue)
G4double GetLocalTime() const
const G4TouchableHandle & GetTouchableHandle() const
void SetGoodForTrackingFlag(G4bool value=true)
G4double GetBR() const
void SetVerboseLevel(G4int value)
G4int GetVerboseLevel() const
G4int GetNumberOfDaughters() const
virtual G4DecayProducts * DecayIt(G4double parentMass=-1.0)=0
virtual G4bool IsOKWithParentMass(G4double parentMass)
const G4String & GetDaughterName(G4int anIndex) const
virtual G4DecayProducts * ImportDecayProducts(const G4Track &aTrack)=0
void ProposeTrackStatus(G4TrackStatus status)
void AddSecondary(G4Track *aSecondary)
void ProposeLocalEnergyDeposit(G4double anEnergyPart)
void SetNumberOfSecondaries(G4int totSecondaries)
G4int GetVerboseLevel() const
Definition: G4VProcess.hh:418
void ClearNumberOfInteractionLengthLeft()
Definition: G4VProcess.hh:424
#define ns
Definition: xmlparse.cc:614

References G4VParticleChange::AddSecondary(), G4DecayProducts::Boost(), G4VProcess::ClearNumberOfInteractionLengthLeft(), cm, G4Decay::DaughterPolarization(), G4VDecayChannel::DecayIt(), G4DecayProducts::DumpInfo(), G4DecayProducts::entries(), G4DecayTable::entries(), FatalException, G4Decay::fParticleChangeForDecay, G4Decay::fRemainderLifeTime, fStopAndKill, fStopButAlive, G4cout, G4endl, G4Exception(), G4VDecayChannel::GetBR(), G4VDecayChannel::GetDaughterName(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetLocalTime(), G4DynamicParticle::GetMass(), G4DynamicParticle::GetMomentumDirection(), G4VDecayChannel::GetNumberOfDaughters(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGStable(), G4Track::GetPosition(), G4DynamicParticle::GetPreAssignedDecayProducts(), G4DynamicParticle::GetTotalEnergy(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4VDecayChannel::GetVerboseLevel(), G4VProcess::GetVerboseLevel(), GeV, G4VExtDecayer::ImportDecayProducts(), G4ParticleChangeForDecay::Initialize(), G4DecayProducts::IsChecked(), G4VDecayChannel::IsOKWithParentMass(), JustWarning, MeV, ns, G4Decay::pExtDecayer, G4DecayProducts::PopProducts(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForDecay::ProposeLocalTime(), G4VParticleChange::ProposeTrackStatus(), G4DecayTable::SelectADecayChannel(), G4Track::SetGoodForTrackingFlag(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), and G4VDecayChannel::SetVerboseLevel().

Referenced by G4Decay::AtRestDoIt(), AtRestDoIt(), G4Decay::PostStepDoIt(), and PostStepDoIt().

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const
virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

168{
169 G4cout << "Process Name " << theProcessName ;
170 G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
171 G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
172}
static const G4String & GetProcessTypeName(G4ProcessType)
Definition: G4VProcess.cc:134
G4ProcessType theProcessType
Definition: G4VProcess.hh:346
G4int theProcessSubType
Definition: G4VProcess.hh:349
G4String theProcessName
Definition: G4VProcess.hh:341

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ EndTracking()

void G4Decay::EndTracking ( )
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 401 of file G4Decay.cc.

402{
403 // Clear NumberOfInteractionLengthLeft
405
407}
G4double currentInteractionLength
Definition: G4VProcess.hh:335

References G4VProcess::ClearNumberOfInteractionLengthLeft(), and G4VProcess::currentInteractionLength.

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const
inlineinherited

◆ GetExtDecayer()

const G4VExtDecayer * G4Decay::GetExtDecayer ( ) const
inlineinherited

Definition at line 193 of file G4Decay.hh.

194{
195 return pExtDecayer;
196}

References G4Decay::pExtDecayer.

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const
inlineinherited

◆ GetMeanFreePath()

G4double G4Decay::GetMeanFreePath ( const G4Track aTrack,
G4double  previousStepSize,
G4ForceCondition condition 
)
overrideprotectedvirtualinherited

Implements G4VRestDiscreteProcess.

Definition at line 129 of file G4Decay.cc.

130{
131 // get particle
132 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
133 const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
134 G4double aMass = aParticle->GetMass();
135 G4double aLife = aParticleDef->GetPDGLifeTime();
136
137
138 // returns the mean free path in GEANT4 internal units
139 G4double pathlength;
140 G4double aCtau = c_light * aLife;
141
142 // check if the particle is stable?
143 if (aParticleDef->GetPDGStable()) {
144 pathlength = DBL_MAX;
145
146 //check if the particle has very short life time ?
147 } else if (aCtau < DBL_MIN) {
148 pathlength = DBL_MIN;
149
150 } else {
151 //calculate the mean free path
152 // by using normalized kinetic energy (= Ekin/mass)
153 G4double rKineticEnergy = aParticle->GetKineticEnergy()/aMass;
154 if ( rKineticEnergy > HighestValue) {
155 // gamma >> 1
156 pathlength = ( rKineticEnergy + 1.0)* aCtau;
157 } else if ( rKineticEnergy < DBL_MIN ) {
158 // too slow particle
159#ifdef G4VERBOSE
160 if (GetVerboseLevel()>1) {
161 G4cout << "G4Decay::GetMeanFreePath() !!particle stops!!";
162 G4cout << aParticleDef->GetParticleName() << G4endl;
163 G4cout << "KineticEnergy:" << aParticle->GetKineticEnergy()/GeV <<"[GeV]";
164 }
165#endif
166 pathlength = DBL_MIN;
167 } else {
168 // beta <1
169 pathlength = (aParticle->GetTotalMomentum())/aMass*aCtau ;
170 }
171 }
172 return pathlength;
173}
const G4double HighestValue
Definition: G4Decay.hh:170
G4double GetTotalMomentum() const
G4double GetPDGLifeTime() const
float c_light
Definition: hepunit.py:256
#define DBL_MAX
Definition: templates.hh:62

References source.hepunit::c_light, DBL_MAX, DBL_MIN, G4cout, G4endl, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMass(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGLifeTime(), G4ParticleDefinition::GetPDGStable(), G4DynamicParticle::GetTotalMomentum(), G4VProcess::GetVerboseLevel(), GeV, and G4Decay::HighestValue.

Referenced by G4Decay::PostStepGetPhysicalInteractionLength().

◆ GetMeanLifeTime()

G4double G4Decay::GetMeanLifeTime ( const G4Track aTrack,
G4ForceCondition condition 
)
overrideprotectedvirtualinherited

Implements G4VRestDiscreteProcess.

Definition at line 100 of file G4Decay.cc.

102{
103 // returns the mean free path in GEANT4 internal units
104 G4double meanlife;
105
106 // get particle
107 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
108 const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
109 G4double aLife = aParticleDef->GetPDGLifeTime();
110
111 // check if the particle is stable?
112 if (aParticleDef->GetPDGStable()) {
113 //1000000 times the life time of the universe
114 meanlife = 1e24 * s;
115
116 } else {
117 meanlife = aLife;
118 }
119
120#ifdef G4VERBOSE
121 if (GetVerboseLevel()>1) {
122 G4cout << "mean life time: "<< meanlife/ns << "[ns]" << G4endl;
123 }
124#endif
125
126 return meanlife;
127}
static constexpr double s
Definition: G4SIunits.hh:154

References G4cout, G4endl, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4ParticleDefinition::GetPDGLifeTime(), G4ParticleDefinition::GetPDGStable(), G4VProcess::GetVerboseLevel(), ns, and s.

Referenced by G4Decay::AtRestGetPhysicalInteractionLength().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const
inlineinherited

Definition at line 431 of file G4VProcess.hh.

432{
434}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName ( const G4ParticleDefinition particle,
const G4String directory,
const G4String tableName,
G4bool  ascii = false 
)
inherited

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const
inlineinherited

Definition at line 455 of file G4VProcess.hh.

456{
457 return thePILfactor;
458}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )
inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

495{
496 return aProcessManager;
497}
const G4ProcessManager * aProcessManager
Definition: G4VProcess.hh:319

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const
inlineinherited

Definition at line 382 of file G4VProcess.hh.

383{
384 return theProcessName;
385}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const
inlineinherited

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const
inlineinherited

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType)
staticinherited

Definition at line 134 of file G4VProcess.cc.

135{
136 switch (aType)
137 {
138 case fNotDefined: return typeNotDefined; break;
139 case fTransportation: return typeTransportation; break;
140 case fElectromagnetic: return typeElectromagnetic; break;
141 case fOptical: return typeOptical; break;
142 case fHadronic: return typeHadronic; break;
144 case fDecay: return typeDecay; break;
145 case fGeneral: return typeGeneral; break;
146 case fParameterisation: return typeParameterisation; break;
147 case fUserDefined: return typeUserDefined; break;
148 case fPhonon: return typePhonon; break;
149 default: ;
150 }
151 return noType;
152}
@ fOptical
@ fPhonon
@ fParameterisation
@ fGeneral
@ fDecay
@ fElectromagnetic
@ fHadronic
@ fUserDefined
@ fTransportation
@ fPhotolepton_hadron
@ fNotDefined
static const G4String typeNotDefined
Definition: G4VProcess.cc:119
static const G4String typeParameterisation
Definition: G4VProcess.cc:127
static const G4String typePhotolepton_hadron
Definition: G4VProcess.cc:124
static const G4String typeElectromagnetic
Definition: G4VProcess.cc:121
static const G4String noType
Definition: G4VProcess.cc:130
static const G4String typeUserDefined
Definition: G4VProcess.cc:128
static const G4String typeDecay
Definition: G4VProcess.cc:125
static const G4String typeTransportation
Definition: G4VProcess.cc:120
static const G4String typeHadronic
Definition: G4VProcess.cc:123
static const G4String typeOptical
Definition: G4VProcess.cc:122
static const G4String typeGeneral
Definition: G4VProcess.cc:126
static const G4String typePhonon
Definition: G4VProcess.cc:129

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetRemainderLifeTime()

G4double G4Decay::GetRemainderLifeTime ( ) const
inlineinherited

Definition at line 199 of file G4Decay.hh.

200{
201 return fRemainderLifeTime;
202}

References G4Decay::fRemainderLifeTime.

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const
inlineinherited

◆ GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const
inlineinherited

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const
inlineinherited

Definition at line 506 of file G4VProcess.hh.

507{
508 return enableAlongStepDoIt;
509}
G4bool enableAlongStepDoIt
Definition: G4VProcess.hh:360

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

G4bool G4Decay::IsApplicable ( const G4ParticleDefinition aParticleType)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 88 of file G4Decay.cc.

89{
90 // check if the particle is stable?
91 if (aParticleType.GetPDGLifeTime() <0.0) {
92 return false;
93 } else if (aParticleType.GetPDGMass() <= 0.0*MeV) {
94 return false;
95 } else {
96 return true;
97 }
98}

References G4ParticleDefinition::GetPDGLifeTime(), G4ParticleDefinition::GetPDGMass(), and MeV.

Referenced by LBE::ConstructGeneral(), and G4DecayPhysics::ConstructProcess().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const
inlineinherited

Definition at line 500 of file G4VProcess.hh.

501{
502 return enableAtRestDoIt;
503}
G4bool enableAtRestDoIt
Definition: G4VProcess.hh:359

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const
inlineinherited

Definition at line 512 of file G4VProcess.hh.

513{
514 return enablePostStepDoIt;
515}
G4bool enablePostStepDoIt
Definition: G4VProcess.hh:361

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess right) const
inherited

Definition at line 161 of file G4VProcess.cc.

162{
163 return (this != &right);
164}

◆ operator==()

G4bool G4VProcess::operator== ( const G4VProcess right) const
inherited

Definition at line 155 of file G4VProcess.cc.

156{
157 return (this == &right);
158}

◆ PostStepDoIt()

G4VParticleChange * G4DecayWithSpin::PostStepDoIt ( const G4Track aTrack,
const G4Step aStep 
)
overrideprotectedvirtual

Reimplemented from G4Decay.

Definition at line 61 of file G4DecayWithSpin.cc.

62{
63 if ( (aTrack.GetTrackStatus() == fStopButAlive ) ||
64 (aTrack.GetTrackStatus() == fStopAndKill ) ){
67 }
68
69// get particle
70 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
71 const G4ParticleDefinition* aParticleDef = aParticle->GetDefinition();
72
73// get parent_polarization
74 G4ThreeVector parent_polarization = aParticle->GetPolarization();
75
76 if(parent_polarization == G4ThreeVector(0,0,0)){
77 // Generate random polarization direction
78 G4double cost = 1. - 2.*G4UniformRand();
79 G4double sint = std::sqrt((1.-cost)*(1.+cost));
80
82 G4double sinp = std::sin(phi);
83 G4double cosp = std::cos(phi);
84
85 G4double px = sint*cosp;
86 G4double py = sint*sinp;
87 G4double pz = cost;
88
89 parent_polarization.setX(px);
90 parent_polarization.setY(py);
91 parent_polarization.setZ(pz);
92 }
93
94// decay table
95 G4DecayTable *decaytable = aParticleDef->GetDecayTable();
96 if (decaytable != nullptr) {
97 for (G4int ip=0; ip<decaytable->entries(); ip++){
98 decaytable->GetDecayChannel(ip)->SetPolarization(parent_polarization);
99 }
100 }
101
102 G4ParticleChangeForDecay* pParticleChangeForDecay;
103 pParticleChangeForDecay = (G4ParticleChangeForDecay*)G4Decay::DecayIt(aTrack,aStep);
104 pParticleChangeForDecay->ProposePolarization(parent_polarization);
105
106 return pParticleChangeForDecay;
107}

References G4Decay::DecayIt(), G4DecayTable::entries(), G4Decay::fParticleChangeForDecay, fStopAndKill, fStopButAlive, G4UniformRand, G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetPolarization(), G4Track::GetTrackStatus(), G4ParticleChangeForDecay::Initialize(), G4ParticleChangeForDecay::ProposePolarization(), G4VDecayChannel::SetPolarization(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), and twopi.

◆ PostStepGetPhysicalInteractionLength()

G4double G4Decay::PostStepGetPhysicalInteractionLength ( const G4Track track,
G4double  previousStepSize,
G4ForceCondition condition 
)
overridevirtualinherited

Reimplemented from G4VRestDiscreteProcess.

Definition at line 410 of file G4Decay.cc.

415{
416 // condition is set to "Not Forced"
418
419 // pre-assigned Decay time
422
423 if (pTime < 0.) {
424 // normal case
425 if ( previousStepSize > 0.0){
426 // subtract NumberOfInteractionLengthLeft
430 }
432 }
433 // get mean free path
434 currentInteractionLength = GetMeanFreePath(track, previousStepSize, condition);
435
436#ifdef G4VERBOSE
437 if ((currentInteractionLength <=0.0) || (verboseLevel>2)){
438 G4cout << "G4Decay::PostStepGetPhysicalInteractionLength " << G4endl;
439 track.GetDynamicParticle()->DumpInfo();
440 G4cout << " in Material " << track.GetMaterial()->GetName() <<G4endl;
441 G4cout << "MeanFreePath = " << currentInteractionLength/cm << "[cm]" <<G4endl;
442 }
443#endif
444
445 G4double value;
448 //fRemainderLifeTime = theNumberOfInteractionLengthLeft*aLife;
449 } else {
450 value = DBL_MAX;
451 }
452
453 return value;
454
455 } else {
456 //pre-assigned Decay time case
457 // reminder proper time
458 fRemainderLifeTime = pTime - track.GetProperTime();
459 if (fRemainderLifeTime <= 0.0) fRemainderLifeTime = 0.0;
460
461 G4double rvalue=0.0;
462 // use pre-assigned Decay time to determine PIL
463 if (aLife>0.0) {
464 // ordinary particle
465 rvalue = (fRemainderLifeTime/aLife)*GetMeanFreePath(track, previousStepSize, condition);
466 } else {
467 // shortlived particle
468 rvalue = c_light * fRemainderLifeTime;
469 // by using normalized kinetic energy (= Ekin/mass)
470 G4double aMass = track.GetDynamicParticle()->GetMass();
471 rvalue *= track.GetDynamicParticle()->GetTotalMomentum()/aMass;
472 }
473 return rvalue;
474 }
475}
static constexpr double perMillion
Definition: G4SIunits.hh:327
virtual G4double GetMeanFreePath(const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition) override
Definition: G4Decay.cc:129
G4int verboseLevel
Definition: G4Decay.hh:162
void DumpInfo(G4int mode=0) const
const G4String & GetName() const
Definition: G4Material.hh:173
G4Material * GetMaterial() const
void SubtractNumberOfInteractionLengthLeft(G4double prevStepSize)
Definition: G4VProcess.hh:524

References source.hepunit::c_light, cm, condition(), G4VProcess::currentInteractionLength, DBL_MAX, G4DynamicParticle::DumpInfo(), G4Decay::fRemainderLifeTime, G4cout, G4endl, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetMass(), G4Track::GetMaterial(), G4Decay::GetMeanFreePath(), G4Material::GetName(), G4ParticleDefinition::GetPDGLifeTime(), G4DynamicParticle::GetPreAssignedDecayProperTime(), G4Track::GetProperTime(), G4DynamicParticle::GetTotalMomentum(), NotForced, perMillion, G4VProcess::SubtractNumberOfInteractionLengthLeft(), G4VProcess::theNumberOfInteractionLengthLeft, and G4Decay::verboseLevel.

◆ PostStepGPIL()

G4double G4VProcess::PostStepGPIL ( const G4Track track,
G4double  previousStepSize,
G4ForceCondition condition 
)
inlineinherited

Definition at line 479 of file G4VProcess.hh.

482{
483 return thePILfactor *
484 PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
485}
virtual G4double PostStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition )
inlinevirtualinherited

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition part)
virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

207{
209}
virtual void PreparePhysicsTable(const G4ParticleDefinition &)
Definition: G4VProcess.hh:194

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ ProcessDescription()

void G4DecayWithSpin::ProcessDescription ( std::ostream &  outFile) const
overridevirtual

Reimplemented from G4Decay.

Definition at line 225 of file G4DecayWithSpin.cc.

226{
227 outFile << GetProcessName()
228 << ": Decay of particles considering parent polarization \n"
229 << "kinematics of daughters are dertermined by DecayChannels \n";
230}
const G4String & GetProcessName() const
Definition: G4VProcess.hh:382

References G4VProcess::GetProcessName().

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )
virtualinherited

◆ RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable ( const G4ParticleDefinition ,
const G4String ,
G4bool   
)
inlinevirtualinherited

◆ SetExtDecayer()

void G4Decay::SetExtDecayer ( G4VExtDecayer val)
inherited

Definition at line 497 of file G4Decay.cc.

498{
499 pExtDecayer = val;
500
501 // set Process Sub Type
502 if ( pExtDecayer !=0 ) {
503 SetProcessSubType(static_cast<int>(DECAY_External));
504 }
505}
@ DECAY_External

References DECAY_External, G4Decay::pExtDecayer, and G4VProcess::SetProcessSubType().

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess masterP)
virtualinherited

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value)
inlineinherited

Definition at line 449 of file G4VProcess.hh.

450{
451 if (value>0.) { thePILfactor = value; }
452}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager procMan)
inlinevirtualinherited

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value)
inlineinherited

Definition at line 406 of file G4VProcess.hh.

407{
408 theProcessSubType = value;
409}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType)
inlineinherited

Definition at line 394 of file G4VProcess.hh.

395{
396 theProcessType = aType;
397}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value)
inlineinherited

◆ Spin_Precession()

G4ThreeVector G4DecayWithSpin::Spin_Precession ( const G4Step aStep,
G4ThreeVector  B,
G4double  deltatime 
)
private

Definition at line 186 of file G4DecayWithSpin.cc.

188{
189 G4double Bnorm = std::sqrt(sqr(B[0]) + sqr(B[1]) +sqr(B[2]) );
190
192 G4double a = 1.165922e-3;
193 G4double s_omega = 8.5062e+7*rad/(s*kilogauss);
194
195 G4double omega = -(q*s_omega)*(1.+a) * Bnorm;
196
197 G4double rotationangle = deltatime * omega;
198
199 G4Transform3D SpinRotation = G4Rotate3D(rotationangle,B.unit());
200
201 G4Vector3D Spin = aStep.GetTrack() -> GetPolarization();
202
203 G4Vector3D newSpin = SpinRotation * Spin;
204
205#ifdef G4VERBOSE
206 if (GetVerboseLevel()>2) {
207 G4double normspin = std::sqrt(Spin*Spin);
208 G4double normnewspin = std::sqrt(newSpin*newSpin);
209 //G4double cosalpha = Spin*newSpin/normspin/normnewspin;
210 //G4double alpha = std::acos(cosalpha);
211
212 G4cout << "AT REST::: PARAMETERS " << G4endl;
213 G4cout << "Initial spin : " << Spin << G4endl;
214 G4cout << "Delta time : " << deltatime << G4endl;
215 G4cout << "Rotation angle: " << rotationangle/rad << G4endl;
216 G4cout << "New spin : " << newSpin << G4endl;
217 G4cout << "Checked norms : " << normspin <<" " << normnewspin << G4endl;
218 }
219#endif
220
221 return newSpin;
222
223}
static constexpr double kilogauss
Definition: G4SIunits.hh:263
static constexpr double rad
Definition: G4SIunits.hh:129
HepGeom::Rotate3D G4Rotate3D
G4double GetPDGCharge() const
G4ParticleDefinition * GetDefinition() const
T sqr(const T &x)
Definition: templates.hh:128

References B(), G4cout, G4endl, G4Track::GetDefinition(), G4ParticleDefinition::GetPDGCharge(), G4Step::GetTrack(), G4VProcess::GetVerboseLevel(), kilogauss, rad, s, and sqr().

Referenced by AtRestDoIt().

◆ StartTracking()

void G4Decay::StartTracking ( G4Track )
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 393 of file G4Decay.cc.

394{
397
398 fRemainderLifeTime = -1.0;
399}
virtual void ResetNumberOfInteractionLengthLeft()
Definition: G4VProcess.cc:80

References G4VProcess::currentInteractionLength, G4Decay::fRemainderLifeTime, and G4VProcess::ResetNumberOfInteractionLengthLeft().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable ( const G4ParticleDefinition ,
const G4String ,
G4bool   
)
inlinevirtualinherited

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize)
inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

525{
527 {
530 {
532 }
533 }
534 else
535 {
536#ifdef G4VERBOSE
537 if (verboseLevel>0)
538 {
539 G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
540 G4cerr << " [" << theProcessName << "]" <<G4endl;
541 G4cerr << " currentInteractionLength = "
542 << currentInteractionLength << " [mm]";
543 G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
544 G4cerr << G4endl;
545 }
546#endif
547 G4String msg = "Negative currentInteractionLength for ";
548 msg += theProcessName;
549 G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
550 "ProcMan201", EventMustBeAborted, msg);
551 }
552}
@ EventMustBeAborted
G4GLOB_DLL std::ostream G4cerr
static constexpr double perMillion

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

Field Documentation

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange
protectedinherited

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr
protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0
protectedinherited

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true
protectedinherited

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true
protectedinherited

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true
protectedinherited

◆ fParticleChangeForDecay

G4ParticleChangeForDecay G4Decay::fParticleChangeForDecay
protectedinherited

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr
privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

◆ fRemainderLifeTime

G4double G4Decay::fRemainderLifeTime
protectedinherited

◆ HighestValue

const G4double G4Decay::HighestValue
protectedinherited

Definition at line 170 of file G4Decay.hh.

Referenced by G4Decay::GetMeanFreePath().

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr
privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

◆ pExtDecayer

G4VExtDecayer* G4Decay::pExtDecayer
protectedinherited

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr
protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0
protectedinherited

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0
protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName
protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0
protectedinherited

◆ theProcessName

G4String G4VProcess::theProcessName
protectedinherited

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1
protectedinherited

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined
protectedinherited

◆ verboseLevel

G4int G4Decay::verboseLevel
protectedinherited

Definition at line 162 of file G4Decay.hh.

Referenced by G4Decay::PostStepGetPhysicalInteractionLength().


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