lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 8.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 14:55:03 +02:00
parent 216a75eeb1
commit fe73f43734
6714 changed files with 118229 additions and 68144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/transportation/src/G4CoupledTransportation.cc
+772
View File
@@ -0,0 +1,772 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4CoupledTransportation.cc,v 1.12 2006/11/22 18:41:44 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
// ------------------------------------------------------------
// GEANT 4 class implementation
// =======================================================================
// Modified:
//
// Created: 13 May 2006, J. Apostolakis, based on G4Transportation
// =======================================================================
#include "G4CoupledTransportation.hh"
#include "G4ProductionCutsTable.hh"
#include "G4ParticleTable.hh"
#include "G4ChordFinder.hh"
class G4VSensitiveDetector;
//////////////////////////////////////////////////////////////////////////
//
// Constructor
G4CoupledTransportation::G4CoupledTransportation( G4int verboseLevel )
: G4VProcess( G4String("CoupledTransportation"), fTransportation ),
fParticleIsLooping( false ),
fPreviousSftOrigin (0.,0.,0.),
fPreviousSafety ( 0.0 ),
#ifdef LOOPERS
fThreshold_Warning_Energy( 100 * MeV ),
fThreshold_Important_Energy( 250 * MeV ),
fThresholdTrials( 10 ),
fUnimportant_Energy( 1 * MeV ),
fNoLooperTrials(0),
fSumEnergyKilled( 0.0 ), fMaxEnergyKilled( 0.0 ),
#endif
fVerboseLevel(verboseLevel) // ( verboseLevel ? verboseLevel : 2 )
{
G4TransportationManager* transportMgr ;
transportMgr = G4TransportationManager::GetTransportationManager() ;
fMassNavigator = transportMgr->GetNavigatorForTracking() ;
fFieldPropagator = transportMgr->GetPropagatorInField() ;
// fGlobalFieldMgr = transportMgr->GetFieldManager() ;
fNavigatorId= transportMgr->ActivateNavigator( fMassNavigator );
if( fVerboseLevel > 0 ){
G4cout << " G4CoupledTransportation constructor: ----- " << G4endl;
G4cout << " Verbose level is " << fVerboseLevel << G4endl;
G4cout << " Navigator Id obtained in G4CoupledTransportation constructor "
<< fNavigatorId << G4endl;
}
fPathFinder= G4PathFinder::GetInstance();
fCurrentTouchableHandle = G4TouchableHandle( 0 ); // new G4TouchableHistory();
fStartedNewTrack= true;
// fEndGlobalTimeComputed = false;
// fCandidateEndGlobalTime = 0;
}
//////////////////////////////////////////////////////////////////////////
G4CoupledTransportation::~G4CoupledTransportation()
{
// fCurrentTouchableHandle is a data member - no deletion required
}
//////////////////////////////////////////////////////////////////////////
//
// Responsibilities:
// Find whether the geometry limits the Step, and to what length
// Calculate the new value of the safety and return it.
// Store the final time, position and momentum.
G4double G4CoupledTransportation::
AlongStepGetPhysicalInteractionLength( const G4Track& track,
G4double, // previousStepSize
G4double currentMinimumStep,
G4double& proposedSafetyForStart,
G4GPILSelection* selection )
{
G4double geometryStepLength;
G4double startMassSafety= 0.0; // estimated safety for start point (mass geometry)
G4double startFullSafety= 0.0; // estimated safety for start point (all geometries)
G4double safetyProposal= -1.0; // local copy of proposal
G4ThreeVector EndUnitMomentum ;
G4double lengthAlongCurve=0.0 ;
fParticleIsLooping = false ;
// Initial actions moved to StartTrack()
// --------------------------------------
// Note: in case another process changes touchable handle
// it will be necessary to add here (for all steps)
// fCurrentTouchableHandle = aTrack->GetTouchableHandle();
// GPILSelection is set to defaule value of CandidateForSelection
// It is a return value
//
*selection = CandidateForSelection ;
// Get initial Energy/Momentum of the track
//
const G4DynamicParticle* pParticle = track.GetDynamicParticle() ;
const G4ParticleDefinition* pParticleDef = pParticle->GetDefinition() ;
G4ThreeVector startMomentumDir = pParticle->GetMomentumDirection() ;
G4ThreeVector startPosition = track.GetPosition() ;
G4VPhysicalVolume* currentVolume= track.GetVolume();
if( fVerboseLevel > 1 ) {
G4cout << "G4CoupledTransportation::AlongStepGPIL> called in volume "
<< currentVolume->GetName() << G4endl;
}
// G4double theTime = track.GetGlobalTime() ;
if( fStartedNewTrack || track.GetCurrentStepNumber()==1 ) {
// fPathFinder->Locate( startPosition, startMomentumDir ); // -- out from G480
fCurrentTouchableHandle = track.GetTouchableHandle(); // out G480 ??
}
fStartedNewTrack= false;
// The Step Point safety can be limited by other geometries and/or the
// assumptions of any process - it's not always the geometrical safety.
// We calculate the starting point's isotropic safety here.
//
G4ThreeVector OriginShift = startPosition - fPreviousSftOrigin ;
G4double MagSqShift = OriginShift.mag2() ;
startMassSafety = 0.0;
startFullSafety= 0.0;
if( MagSqShift < sqr(fPreviousSafety) ) {
startMassSafety = fPreviousSafety - std::sqrt(MagSqShift) ;
// Only compute full safety if massSafety > 0. Else it remains 0
startFullSafety = fPathFinder->ComputeSafety( startPosition );
}
// Is the particle charged ?
//
G4double particleCharge = pParticle->GetCharge() ;
// fEndGlobalTimeComputed = false ;
// There is no need to locate the current volume. It is Done elsewhere:
// On track construction
// By the tracking, after all AlongStepDoIts, in "Relocation"
// Check whether the particle have an (EM) field force exerting upon it
//
G4FieldManager* fieldMgr=0;
if( (particleCharge != 0.0) ) // || (magneticMoment != 0.0 ) )
{
fieldMgr= fFieldPropagator->FindAndSetFieldManager( currentVolume );
if (fieldMgr != 0) {
// Message the field Manager, to configure it for this track
fieldMgr->ConfigureForTrack( &track );
}
// the PathFinder will recognise whether the field exerts force
}
G4double momentumMagnitude = pParticle->GetTotalMomentum() ;
G4double restMass = pParticleDef->GetPDGMass() ;
fFieldPropagator->SetChargeMomentumMass( particleCharge, // in e+ units
momentumMagnitude, // in Mev/c
restMass ) ;
G4ThreeVector spin = track.GetPolarization() ;
G4FieldTrack theFieldTrack = G4FieldTrack( startPosition,
track.GetMomentumDirection(),
0.0,
track.GetKineticEnergy(),
restMass,
0.0, // UNUSED: track.GetVelocity(),
track.GetGlobalTime(), // Lab.
track.GetProperTime(), // Part.
&spin ) ;
theFieldTrack.SetChargeAndMoments( particleCharge ); // EM moments -- future extension
G4int stepNo= track.GetCurrentStepNumber();
ELimited limitedStep;
G4FieldTrack endTrackState('a'); // Default values
fGeometryLimitedStep = false ; // default
if( currentMinimumStep > 0 ) {
G4double newMassSafety= 0.0; // temp. for recalculation
// Do the Transport in the field (non recti-linear)
//
lengthAlongCurve = fPathFinder->ComputeStep( theFieldTrack,
currentMinimumStep,
fNavigatorId,
stepNo,
newMassSafety,
limitedStep,
endTrackState,
currentVolume ) ;
// G4cout << " PathFinder ComputeStep returns " << lengthAlongCurve << G4endl;
if( limitedStep == kUnique || limitedStep == kSharedTransport ) {
fGeometryLimitedStep = true ;
}
if( lengthAlongCurve < currentMinimumStep){
geometryStepLength = lengthAlongCurve ;
// Old code: fGeometryLimitedStep = true ;
} else {
geometryStepLength = currentMinimumStep ;
}
// Momentum: Magnitude and direction can be changed too now ...
//
fMomentumChanged = true ;
fTransportEndMomentumDir = endTrackState.GetMomentumDir() ;
// Remember last safety origin & value.
fPreviousSftOrigin = startPosition ;
fPreviousSafety = newMassSafety ;
if( fVerboseLevel > 1 ){
G4cout << "G4CoupledTransport:CompStep> "
<< " called the pathfinder for a new step at " << startPosition
<< " and obtained step = " << lengthAlongCurve << G4endl;
G4cout << " New safety (preStep) = " << newMassSafety
<< " versus precalculated = " << startMassSafety << G4endl;
}
// Store as best estimate value
startMassSafety = newMassSafety ;
// Get the End-Position and End-Momentum (Dir-ection)
fTransportEndPosition = endTrackState.GetPosition() ;
fTransportEndKineticEnergy = endTrackState.GetKineticEnergy() ;
} else {
geometryStepLength = lengthAlongCurve= 0.0 ;
fMomentumChanged = false ;
// fGeometryLimitedStep = false ; // --- ???
fTransportEndMomentumDir = track.GetMomentumDirection();
fTransportEndKineticEnergy = track.GetKineticEnergy();
// If the step length requested is 0, and we are on a boundary
// then a boundary will also limit the step.
if( startMassSafety == 0.0 ) fGeometryLimitedStep = true ;
// TODO: Add explicit logical status for being at a boundary
}
// G4FieldTrack aTrackState(endTrackState);
if( fVerboseLevel > 1 ){
G4cout << " G4CT::CS End Position = " << fTransportEndPosition << G4endl;
G4cout << " G4CT::CS End Direction = " << fTransportEndMomentumDir << G4endl;
}
#if 0
if( fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy() )
{
// If the field can change energy, then the time must be integrated
// - so this should have been updated
//
fCandidateEndGlobalTime = endTrackState.GetLabTimeOfFlight();
fEndGlobalTimeComputed = true;
// was ( fCandidateEndGlobalTime != track.GetGlobalTime() );
// a cleaner way is to have FieldTrack knowing whether time is updated.
}
else
#endif
{
// The energy should be unchanged by field transport,
// - so the time changed will be calculated elsewhere
//
fEndGlobalTimeComputed = false;
// Check that the integration preserved the energy
// - and if not correct this!
G4double startEnergy= track.GetKineticEnergy();
G4double endEnergy= fTransportEndKineticEnergy;
static G4int no_inexact_steps=0; // , no_large_ediff;
G4double absEdiff = std::fabs(startEnergy- endEnergy);
if( absEdiff > perMillion * endEnergy ) {
no_inexact_steps++;
// Possible statistics keeping here ...
}
if( (fVerboseLevel > 1) && ( absEdiff > perThousand * endEnergy) )
{
ReportInexactEnergy(startEnergy, endEnergy);
} // end of if (fVerboseLevel)
// Correct the energy for fields that conserve it
// This - hides the integration error
// - but gives a better physical answer
fTransportEndKineticEnergy= track.GetKineticEnergy();
}
endpointDistance = (fTransportEndPosition - startPosition).mag() ;
// fParticleIsLooping = fFieldPropagator->IsParticleLooping() ;
fTransportEndSpin = endTrackState.GetSpin();
// Calculate the safety
safetyProposal= startFullSafety; // used to be startMassSafety
// Changed to accomodate processes that cannot update the safety -- JA 22 Nov 06
// Update safety for the end-point, if becomes negative at the end-point.
// To-Try: No safety update if at a boundary
if( startFullSafety < endpointDistance ) // && !fGeometryLimitedStep )
{
G4double endFullSafety =
fPathFinder->ComputeSafety( fTransportEndPosition);
// Expected mission -- only mass geometry's safety
// fMassNavigator->ComputeSafety( fTransportEndPosition) ;
// Yet discrete processes only have poststep -- and this cannot
// currently revise the safety
// ==> so we use the all-geometry safety as a precaution
G4double endMassSafety= fMassNavigator->ComputeSafety( fTransportEndPosition) ;
fPreviousSafety = endMassSafety ;
fPreviousSftOrigin = fTransportEndPosition ;
// The convention (Stepping Manager's) is safety from the start point
//
safetyProposal = endFullSafety + endpointDistance;
// --> was endMassSafety
// #undef G4DEBUG_TRANSPORT
// #define G4DEBUG_TRANSPORT 1
#ifdef G4DEBUG_TRANSPORT
int prec= G4cout.precision(12) ;
G4cout << "***CoupledTransportation::AlongStepGPIL ** " << G4endl ;
G4cout << " Revised Safety at endpoint " << fTransportEndPosition
<< " give safety values: Mass= " << endMassSafety
<< " All= " << endFullSafety << G4endl ;
G4cout << " Adding endpoint distance " << endpointDistance
<< " to obtain pseudo-safety= " << safetyProposal << G4endl ;
G4cout.precision(prec);
}
else{
int prec= G4cout.precision(12) ;
G4cout << "***CoupledTransportation::AlongStepGPIL ** " << G4endl ;
G4cout << " Quick Safety estimate at endpoint " << fTransportEndPosition
<< " gives safety endpoint value = " << startFullSafety - endpointDistance
<< " using start-point value " << startFullSafety
<< " and endpointDistance " << endpointDistance << G4endl;
G4cout.precision(prec);
#endif
}
proposedSafetyForStart= safetyProposal;
fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
return geometryStepLength ;
}
//////////////////////////////////////////////////////////////////////////
G4VParticleChange* G4CoupledTransportation::AlongStepDoIt( const G4Track& track,
const G4Step& stepData )
{
static G4int noCalls=0;
static const G4ParticleDefinition* fOpticalPhoton =
G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");
noCalls++;
fParticleChange.Initialize(track) ;
// sets all its members to the value of corresponding members in G4Track
// Code specific for Transport
//
fParticleChange.ProposePosition(fTransportEndPosition) ;
// G4cout << " G4CoupledTransportation::AlongStepDoIt"
// << " proposes position = " << fTransportEndPosition
// << " and end momentum direction = " << fTransportEndMomentumDir << G4endl;
fParticleChange.ProposeMomentumDirection(fTransportEndMomentumDir) ;
fParticleChange.ProposeEnergy(fTransportEndKineticEnergy) ;
fParticleChange.SetMomentumChanged(fMomentumChanged) ;
fParticleChange.ProposePolarization(fTransportEndSpin);
G4double deltaTime = 0.0 ;
// Calculate Lab Time of Flight (ONLY if field Equations used it!)
// G4double endTime = fCandidateEndGlobalTime;
// G4double delta_time = endTime - startTime;
G4double startTime = track.GetGlobalTime() ;
if (!fEndGlobalTimeComputed)
{
G4double finalInverseVel= DBL_MAX, initialInverseVel=DBL_MAX;
// The time was not integrated .. make the best estimate possible
//
G4double finalVelocity = track.GetVelocity() ;
if( finalVelocity > 0.0 ) { finalInverseVel= 1.0 / finalVelocity; }
G4double initialVelocity = stepData.GetPreStepPoint()->GetVelocity() ;
if( initialVelocity > 0.0 ) { initialInverseVel= 1.0 / initialVelocity; }
G4double stepLength = track.GetStepLength() ;
const G4DynamicParticle* fpDynamicParticle = track.GetDynamicParticle();
if (fpDynamicParticle->GetDefinition()== fOpticalPhoton)
{
// A photon is in the medium of the final point
// during the step, so Peter says it has the final velocity.
deltaTime = stepLength * finalInverseVel ;
// G4cout << " dt = s * initV " << " s = " << stepLength
// << " finalV= " << finalInverseVel << G4endl;
}
else if (finalVelocity > 0.0)
{
// deltaTime = stepLength/finalVelocity ;
G4double meanInverseVelocity = 0.5 * ( initialInverseVel + finalInverseVel );
deltaTime = stepLength * meanInverseVelocity ;
// G4cout << " dt = s * mean(1/v) , with " << " s = " << stepLength
// << " mean(1/v)= " << meanInverseVelocity << G4endl;
}
else
{
deltaTime = stepLength * initialInverseVel ;
// G4cout << " dt = s * initV " << " s = " << stepLength
// << " initV= " << initialInverseVel << G4endl;
} // Could do with better estimate for final step (finalVelocity = 0) ?
fCandidateEndGlobalTime = startTime + deltaTime ;
// G4cout << " Calculated global time from start = " << startTime << " and "
// << " delta time = " << deltaTime << G4endl;
}
else
{
deltaTime = fCandidateEndGlobalTime - startTime ;
// G4cout << " Calculated global time from candidate end time = "
// << fCandidateEndGlobalTime << " and start time = " << startTime << G4endl;
}
// G4cout << " G4CoupledTransportation::AlongStepDoIt "
// << " flag whether computed time = " << fEndGlobalTimeComputed << " and "
// << " is proposes end time " << fCandidateEndGlobalTime << G4endl;
fParticleChange.ProposeGlobalTime( fCandidateEndGlobalTime ) ;
// Now Correct by Lorentz factor to get "proper" deltaTime
G4double restMass = track.GetDynamicParticle()->GetMass() ;
G4double deltaProperTime = deltaTime*( restMass/track.GetTotalEnergy() ) ;
fParticleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
//fParticleChange. ProposeTrueStepLength( track.GetStepLength() ) ;
#if 0
// If the particle is caught looping or is stuck (in very difficult
// boundaries) in a magnetic field (doing many steps)
// THEN this kills it ...
//
if ( fParticleIsLooping )
{
G4double endEnergy= fTransportEndKineticEnergy;
if( (endEnergy < fThreshold_Important_Energy)
|| (fNoLooperTrials >= fThresholdTrials ) ){
// Kill the looping particle
//
fParticleChange.ProposeTrackStatus( fStopAndKill ) ;
// 'Bare' statistics
fSumEnergyKilled += endEnergy;
if( endEnergy > fMaxEnergyKilled) { fMaxEnergyKilled= endEnergy; }
#ifdef G4VERBOSE
if( (fVerboseLevel > 1) ||
( endEnergy > fThreshold_Warning_Energy ) ) {
G4cout << " G4CoupledTransportation is killing track that is looping or stuck "
<< G4endl
<< " This track has " << track.GetKineticEnergy() / MeV
<< " MeV energy." << G4endl;
}
#endif
fNoLooperTrials=0;
} else{
fNoLooperTrials ++;
}
}else{ fNoLooperTrials=0; }
#endif
// Another (sometimes better way) is to use a user-limit maximum Step size
// to alleviate this problem ..
// Add smooth curved trajectories to particle-change
//
// fParticleChange.SetPointerToVectorOfAuxiliaryPoints
// (fFieldPropagator->GimmeTrajectoryVectorAndForgetIt() );
return &fParticleChange ;
}
//////////////////////////////////////////////////////////////////////////
//
// This ensures that the PostStep action is always called,
// so that it can do the relocation if it is needed.
//
G4double G4CoupledTransportation::
PostStepGetPhysicalInteractionLength( const G4Track&,
G4double, // previousStepSize
G4ForceCondition* pForceCond )
{
// Must act as PostStep action -- to relocate particle
*pForceCond = Forced ;
return DBL_MAX ;
}
static
void ReportMove( G4ThreeVector OldVector, G4ThreeVector NewVector, G4String& Quantity )
{
G4ThreeVector moveVec = ( NewVector - OldVector );
G4cerr << G4endl
<< "**************************************************************" << G4endl;
G4cerr << "Endpoint has moved between value expected from TransportEndPosition "
<< " and value from Track in PostStepDoIt. " << G4endl
<< "Change of " << Quantity << " is " << moveVec.mag() / mm << " mm long, "
<< " and its vector is " << (1.0/mm) * moveVec << " mm " << G4endl
<< "Endpoint of ComputeStep was " << OldVector
<< " and current position to locate is " << NewVector << G4endl;
}
/////////////////////////////////////////////////////////////////////////////
G4VParticleChange* G4CoupledTransportation::PostStepDoIt( const G4Track& track,
const G4Step& )
{
G4TouchableHandle retCurrentTouchable ; // The one to return
// Initialize ParticleChange (by setting all its members equal
// to corresponding members in G4Track)
// fParticleChange.Initialize(track) ; // To initialise TouchableChange
fParticleChange.ProposeTrackStatus(track.GetTrackStatus()) ;
// Check that the end position and direction are preserved
// since call to AlongStepDoIt
if( (fTransportEndPosition - track.GetPosition()).mag2() >= 1.0e-16 ){
static G4String EndLabelString("End of Step Position");
ReportMove( track.GetPosition(), fTransportEndPosition, EndLabelString );
G4cerr << " Problem in G4CoupledTransportation::PostStepDoIt " << G4endl;
}
// If the Step was determined by the volume boundary, relocate the particle
// The pathFinder will know that the geometry limited the step (!?)
if( fVerboseLevel > 0 ){
G4cout << " Calling PathFinder::Locate() from "
<< " G4CoupledTransportation::PostStepDoIt " << G4endl;
}
fPathFinder->Locate( track.GetPosition(),
track.GetMomentumDirection(),
true);
if(fGeometryLimitedStep)
{
// fCurrentTouchable will now become the previous touchable,
// and what was the previous will be freed.
// (Needed because the preStepPoint can point to the previous touchable)
if( fVerboseLevel > 0 )
G4cout << "G4CoupledTransportation::PostStepDoIt --- fNavigatorId = "
<< fNavigatorId << G4endl;
fCurrentTouchableHandle=
fPathFinder->CreateTouchableHandle( fNavigatorId );
// Check whether the particle is out of the world volume
// If so it has exited and must be killed.
//
if( fVerboseLevel > 1 ){
G4VPhysicalVolume* vol= fCurrentTouchableHandle->GetVolume();
G4cout << "CHECK !!!!!!!!!!! fCurrentTouchableHandle->GetVolume() = " << vol;
if( vol ) { G4cout << "Name=" << vol->GetName(); }
G4cout << G4endl;
}
if( fCurrentTouchableHandle->GetVolume() == 0 )
{
fParticleChange.ProposeTrackStatus( fStopAndKill ) ;
}
retCurrentTouchable = fCurrentTouchableHandle ;
fParticleChange.SetTouchableHandle( fCurrentTouchableHandle ) ;
}
else // fGeometryLimitedStep is false
{
if( fVerboseLevel > 1 ){
G4cout << "G4CoupledTransportation::PostStepDoIt -- fGeometryLimitedStep = false !!"
<< G4endl;
}
// This serves only to move the Navigator's location
//
// fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
// Keep the value of the track's current Touchable is retained,
// and use it to overwrite the (unset) one in particle change.
// In general this is fCurrentTouchable,
// - yet could it be different at the start of a step ?
//
fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
retCurrentTouchable = track.GetTouchableHandle() ;
} // endif ( fGeometryLimitedStep )
const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
const G4Material* pNewMaterial = 0 ;
const G4VSensitiveDetector* pNewSensitiveDetector = 0 ;
if( pNewVol != 0 )
{
pNewMaterial= pNewVol->GetLogicalVolume()->GetMaterial();
pNewSensitiveDetector= pNewVol->GetLogicalVolume()->GetSensitiveDetector();
}
// ( const_cast<G4Material *> pNewMaterial ) ;
// ( const_cast<G4VSensitiveDetetor *> pNewSensitiveDetector) ;
fParticleChange.SetMaterialInTouchable( (G4Material *) pNewMaterial ) ;
fParticleChange.SetSensitiveDetectorInTouchable( (G4VSensitiveDetector *) pNewSensitiveDetector ) ;
// "temporarily" until Get/Set Material of ParticleChange,
// and StepPoint can be made const.
const G4MaterialCutsCouple* pNewMaterialCutsCouple = 0;
if( pNewVol != 0 )
{
pNewMaterialCutsCouple=pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
if( pNewMaterialCutsCouple!=0
&& pNewMaterialCutsCouple->GetMaterial()!=pNewMaterial )
{
// for parametrized volume
//
pNewMaterialCutsCouple =
G4ProductionCutsTable::GetProductionCutsTable()
->GetMaterialCutsCouple(pNewMaterial,
pNewMaterialCutsCouple->GetProductionCuts());
}
}
fParticleChange.SetMaterialCutsCoupleInTouchable( pNewMaterialCutsCouple );
// Must always set the touchable in ParticleChange, whether relocated or not
fParticleChange.SetTouchableHandle(retCurrentTouchable) ;
return &fParticleChange ;
}
// New method takes over the responsibility to reset the state of
// G4CoupledTransportation object:
// - at the start of a new track, and
// - on the resumption of a suspended track.
void
G4CoupledTransportation::StartTracking(G4Track* aTrack)
{
static G4TransportationManager* transportMgr=
G4TransportationManager::GetTransportationManager();
// G4VProcess::StartTracking(aTrack);
// The 'initialising' actions
// once taken in AlongStepGPIL -- if ( track.GetCurrentStepNumber()==1 )
fStartedNewTrack= true;
fMassNavigator = transportMgr->GetNavigatorForTracking() ;
fNavigatorId= transportMgr->ActivateNavigator( fMassNavigator ); // Confirm it!
if( fVerboseLevel > 1 ){
G4cout << " Navigator Id obtained in StartTracking " << fNavigatorId << G4endl;
}
G4ThreeVector position = aTrack->GetPosition();
G4ThreeVector direction = aTrack->GetMomentumDirection(); // G48
// if( fVerboseLevel > 1 ){
// G4cout << " Calling PathFinder::PrepareNewTrack from "
// << " G4CoupledTransportation::StartTracking -- which calls Locate()" << G4endl;
// }
fPathFinder->PrepareNewTrack( position, direction);
// This implies a call to fPathFinder->Locate( position, direction );
// reset safety value and center
//
fPreviousSafety = 0.0 ;
fPreviousSftOrigin = G4ThreeVector(0.,0.,0.) ;
#if LOOPERS // For now dont check loopers
// reset looping counter -- for motion in field // Needed in 8.x - G480
if( aTrack->GetCurrentStepNumber()==1 ) {
fNoLooperTrials= 0;
}
#endif
// ChordFinder reset internal state
//
if( DoesGlobalFieldExist() ) {
G4ChordFinder* chordF= fFieldPropagator->GetChordFinder();
if( chordF ) chordF->ResetStepEstimate();
}
if( fVerboseLevel > 1 ){
G4cout << " Returning touchable handle " << fCurrentTouchableHandle << G4endl;
}
// Update the current touchable handle (from the track's)
//
fCurrentTouchableHandle = aTrack->GetTouchableHandle(); // G480
}
void
G4CoupledTransportation::
ReportInexactEnergy(G4double startEnergy, G4double endEnergy)
{
static G4int no_warnings= 0, warnModulo=1, moduloFactor= 10, no_large_ediff= 0;
if( std::fabs(startEnergy- endEnergy) > perThousand * endEnergy )
{
no_large_ediff ++;
if( (no_large_ediff% warnModulo) == 0 )
{
no_warnings++;
G4cout << "WARNING - G4CoupledTransportation::AlongStepGetPIL() "
<< " Energy change in Step is above 1^-3 relative value. " << G4endl
<< " Relative change in 'tracking' step = "
<< std::setw(15) << (endEnergy-startEnergy)/startEnergy << G4endl
<< " Starting E= " << std::setw(12) << startEnergy / MeV << " MeV " << G4endl
<< " Ending E= " << std::setw(12) << endEnergy / MeV << " MeV " << G4endl;
G4cout << " Energy has been corrected -- however, review"
<< " field propagation parameters for accuracy." << G4endl;
if( (fVerboseLevel > 2 ) || (no_warnings<4) || (no_large_ediff == warnModulo * moduloFactor) ){
G4cout << " These include EpsilonStepMax(/Min) in G4FieldManager "
<< " which determine fractional error per step for integrated quantities. " << G4endl
<< " Note also the influence of the permitted number of integration steps."
<< G4endl;
}
G4cerr << "ERROR - G4CoupledTransportation::AlongStepGetPIL()" << G4endl
<< " Bad 'endpoint'. Energy change detected"
<< " and corrected. "
<< " Has occurred already "
<< no_large_ediff << " times." << G4endl;
if( no_large_ediff == warnModulo * moduloFactor )
{
warnModulo *= moduloFactor;
}
}
}
}
source/processes/transportation/src/G4MImportanceConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MImportanceConfigurator.cc,v 1.5.2.1 2006/06/29 21:10:50 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MImportanceConfigurator.cc,v 1.7 2006/11/13 16:13:50 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4MImportanceConfigurator
source/processes/transportation/src/G4MScoreConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MScoreConfigurator.cc,v 1.7.2.1 2006/06/29 21:10:52 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MScoreConfigurator.cc,v 1.9 2006/11/13 16:17:16 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4MScoreConfigurator
source/processes/transportation/src/G4MScoreProcess.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MScoreProcess.cc,v 1.12.2.1 2006/06/29 21:10:54 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MScoreProcess.cc,v 1.14 2006/11/13 16:19:14 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4MWeightWindowConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MWeightWindowConfigurator.cc,v 1.4.2.1 2006/06/29 21:10:56 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MWeightWindowConfigurator.cc,v 1.6 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4MWeightWindowConfigurator
source/processes/transportation/src/G4MassGCellFinder.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MassGCellFinder.cc,v 1.3.2.1 2006/06/29 21:10:58 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MassGCellFinder.cc,v 1.5 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4MassGeometrySampler.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MassGeometrySampler.cc,v 1.11.2.1 2006/06/29 21:11:00 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MassGeometrySampler.cc,v 1.13 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4MassImportanceProcess.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MassImportanceProcess.cc,v 1.17.2.1 2006/06/29 21:11:02 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MassImportanceProcess.cc,v 1.19 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4MassWeightWindowProcess.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MassWeightWindowProcess.cc,v 1.5.2.1 2006/06/29 21:11:04 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4MassWeightWindowProcess.cc,v 1.7 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4NeutronKiller.cc
+91
View File
@@ -0,0 +1,91 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NeutronKiller.cc,v 1.1 2006/11/17 15:53:04 vnivanch Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutronKiller
//
// Description: The process to kill particles to save CPU
//
// Author: V.Ivanchenko 26/09/00 for HARP software
//
//----------------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4NeutronKiller.hh"
#include "G4NeutronKillerMessenger.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4NeutronKiller::G4NeutronKiller(const G4String& processName, G4ProcessType aType)
: G4VDiscreteProcess(processName, aType)
{
kinEnergyThreshold = 0.0;
timeThreshold = DBL_MAX;
pMess = new G4NeutronKillerMessenger(this);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4NeutronKiller::~G4NeutronKiller()
{
delete pMess;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4bool G4NeutronKiller::IsApplicable(const G4ParticleDefinition& particle)
{
return (particle.GetParticleName() == "neutron");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4NeutronKiller::SetTimeLimit(G4double val)
{
timeThreshold = val;
if(verboseLevel > 0)
G4cout << "### G4NeutronKiller: timeLimit(ns) = "
<< timeThreshold/ns << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4NeutronKiller::SetKinEnergyLimit(G4double val)
{
kinEnergyThreshold = val;
if(verboseLevel > 0)
G4cout << "### G4NeutronKiller: Tracking cut E(MeV) = "
<< kinEnergyThreshold/MeV << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/processes/transportation/src/G4NeutronKillerMessenger.cc
+89
View File
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NeutronKillerMessenger.cc,v 1.1 2006/11/17 15:53:04 vnivanch Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutronKillerMessenger
//
// Description: Messenger class
//
// Author: V.Ivanchenko 26/09/00 for HARP software
//
//----------------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4NeutronKillerMessenger.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIdirectory.hh"
#include "G4NeutronKiller.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4NeutronKillerMessenger::G4NeutronKillerMessenger(G4NeutronKiller* p)
:killer(p)
{
dir = new G4UIdirectory("/physics_engine/neutron/");
dir->SetGuidance("control on neutrons");
eCmd = new G4UIcmdWithADoubleAndUnit("/physics_engine/neutron/energyLimit",this);
eCmd->SetGuidance("Set tracking cut - min energy of a particle.");
eCmd->SetParameterName("energyLimit",false);
eCmd->SetUnitCategory("Energy");
eCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
tCmd = new G4UIcmdWithADoubleAndUnit("/physics_engine/neutron/timeLimit",this);
tCmd->SetGuidance("Set time limit.");
tCmd->SetParameterName("timeLimit",false);
tCmd->SetUnitCategory("Time");
tCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4NeutronKillerMessenger::~G4NeutronKillerMessenger()
{
delete eCmd;
delete tCmd;
delete dir;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4NeutronKillerMessenger::SetNewValue(G4UIcommand* command, G4String val)
{
if (command == eCmd)
killer->SetKinEnergyLimit(eCmd->GetNewDoubleValue(val));
if (command == tCmd)
killer->SetTimeLimit(tCmd->GetNewDoubleValue(val));
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/processes/transportation/src/G4PImportanceConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4PImportanceConfigurator.cc,v 1.6.2.1 2006/06/29 21:11:22 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4PImportanceConfigurator.cc,v 1.8 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4PImportanceConfigurator
source/processes/transportation/src/G4PScoreConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4PScoreConfigurator.cc,v 1.7.2.1 2006/06/29 21:12:00 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4PScoreConfigurator.cc,v 1.9 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4PScoreConfigurator
source/processes/transportation/src/G4PScoreProcess.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4PScoreProcess.cc,v 1.9.2.1 2006/06/29 21:12:04 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4PScoreProcess.cc,v 1.11 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4PWeightWindowConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4PWeightWindowConfigurator.cc,v 1.4.2.1 2006/06/29 21:12:06 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4PWeightWindowConfigurator.cc,v 1.6 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4PWeightWindowConfigurator
source/processes/transportation/src/G4ParallelGCellFinder.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4ParallelGCellFinder.cc,v 1.3.2.1 2006/06/29 21:12:08 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4ParallelGCellFinder.cc,v 1.5 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ParallelGeometrySampler.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4ParallelGeometrySampler.cc,v 1.10.2.1 2006/06/29 21:12:10 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4ParallelGeometrySampler.cc,v 1.12 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ParallelImportanceProcess.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4ParallelImportanceProcess.cc,v 1.19 2006/06/29 21:12:12 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ParallelTransport.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4ParallelTransport.cc,v 1.15 2006/06/29 21:12:14 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ParallelTransportConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4ParallelTransportConfigurator.cc,v 1.5.2.1 2006/06/29 21:12:16 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4ParallelTransportConfigurator.cc,v 1.7 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4ParallelTransportConfigurator
source/processes/transportation/src/G4ParallelWWnTransportProcess.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4ParallelWWnTransportProcess.cc,v 1.6 2006/06/29 21:12:18 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ParallelWeightWindowProcess.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4ParallelWeightWindowProcess.cc,v 1.13 2006/06/29 21:12:20 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4ProcessPlacer.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4ProcessPlacer.cc,v 1.14.2.1 2006/06/29 21:12:22 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4ProcessPlacer.cc,v 1.16 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4SamplingPostStepAction.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4SamplingPostStepAction.cc,v 1.4 2006/06/29 21:12:24 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4StepLimiter.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4StepLimiter.cc,v 1.1.2.1 2006/06/29 21:12:26 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4StepLimiter.cc,v 1.3 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// --------------------------------------------------------------
// History
source/processes/transportation/src/G4Transportation.cc
+58 -101
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4Transportation.cc,v 1.55.2.1 2006/06/29 21:12:28 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4Transportation.cc,v 1.60 2006/11/22 18:47:02 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ------------------------------------------------------------
// GEANT 4 include file implementation
@@ -95,8 +95,17 @@ G4Transportation::G4Transportation( G4int verboseLevel )
// is constructed.
// Instead later the method DoesGlobalFieldExist() is called
fCurrentTouchableHandle = new G4TouchableHistory();
// Small memory leak from this new
// fCurrentTouchableHandle = new G4TouchableHistory();
// Fixes:
// 1) static G4TouchableHistory sfNullTouchableHistory = new G4TouchableHistory();
// fCurrentTouchableHandle = new G4TouchableHandle( sfNullTouchableHistory );
// 2) set it to (G4TouchableHistory*) 0
// fCurrentTouchableHandle = new G4TouchableHandle( (G4TouchableHistory*) 0 );
// 3) Below:
static G4TouchableHandle nullTouchableHandle; // Points to (G4VTouchable*) 0
fCurrentTouchableHandle = nullTouchableHandle;
fEndGlobalTimeComputed = false;
fCandidateEndGlobalTime = 0;
}
@@ -105,6 +114,15 @@ G4Transportation::G4Transportation( G4int verboseLevel )
G4Transportation::~G4Transportation()
{
// --- Alternative code to delete 'junk data' in touchable handle
// ** Corresponds to the case that the constructor has
// fCurrentTouchableHandle = new G4TouchableHistory();
// ** Likely incorrect - as at the end of the simulation
// the handle no longer holds the original 'null' history
// G4VTouchable* pTouchable= fCurrentTouchableHandle(); // Incorrect
// delete pTouchable; // Incorrect
if( (fVerboseLevel > 0) && (fSumEnergyKilled > 0.0 ) ){
G4cout << " G4Transportation: Statistics for looping particles " << G4endl;
G4cout << " Sum of energy of loopers killed: " << fSumEnergyKilled << G4endl;
@@ -188,6 +206,9 @@ AlongStepGetPhysicalInteractionLength( const G4Track& track,
}
}
// G4cout << " G4Transport: field exerts force= " << fieldExertsForce
// << " fieldMgr= " << fieldMgr << G4endl;
// Choose the calculation of the transportation: Field or not
//
if( !fieldExertsForce )
@@ -351,18 +372,24 @@ AlongStepGetPhysicalInteractionLength( const G4Track& track,
if( (no_large_ediff% warnModulo) == 0 )
{
no_warnings++;
G4cout << "WARNING - G4Transportation::AlongStepGetPIL()" << G4endl
<< " Energy changed in Step, more than 1/1000: " << G4endl
<< " Start= " << startEnergy << G4endl
<< " End= " << endEnergy << G4endl
<< " Relative change= "
<< (startEnergy-endEnergy)/startEnergy << G4endl;
G4cout << "WARNING - G4Transportation::AlongStepGetPIL() "
<< " Energy change in Step is above 1^-3 relative value. " << G4endl
<< " Relative change in 'tracking' step = "
<< std::setw(15) << (endEnergy-startEnergy)/startEnergy << G4endl
<< " Starting E= " << std::setw(12) << startEnergy / MeV << " MeV " << G4endl
<< " Ending E= " << std::setw(12) << endEnergy / MeV << " MeV " << G4endl;
G4cout << " Energy has been corrected -- however, review"
<< " field propagation parameters for accuracy." << G4endl;
<< " field propagation parameters for accuracy." << G4endl;
if( (fVerboseLevel > 2 ) || (no_warnings<4) || (no_large_ediff == warnModulo * moduloFactor) ){
G4cout << " These include EpsilonStepMax(/Min) in G4FieldManager "
<< " which determine fractional error per step for integrated quantities. " << G4endl
<< " Note also the influence of the permitted number of integration steps."
<< G4endl;
}
G4cerr << "ERROR - G4Transportation::AlongStepGetPIL()" << G4endl
<< " Bad 'endpoint'. Energy change detected"
<< " and corrected," << G4endl
<< " occurred already "
<< " and corrected. "
<< " Has occurred already "
<< no_large_ediff << " times." << G4endl;
if( no_large_ediff == warnModulo * moduloFactor )
{
@@ -431,6 +458,12 @@ AlongStepGetPhysicalInteractionLength( const G4Track& track,
G4VParticleChange* G4Transportation::AlongStepDoIt( const G4Track& track,
const G4Step& stepData )
{
static G4int noCalls=0;
static const G4ParticleDefinition* fOpticalPhoton =
G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");
noCalls++;
fParticleChange.Initialize(track) ;
// Code for specific process
@@ -458,8 +491,6 @@ G4VParticleChange* G4Transportation::AlongStepDoIt( const G4Track& track,
G4double initialVelocity = stepData.GetPreStepPoint()->GetVelocity() ;
G4double stepLength = track.GetStepLength() ;
static const G4ParticleDefinition* fOpticalPhoton =
G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");
const G4DynamicParticle* fpDynamicParticle = track.GetDynamicParticle();
if (fpDynamicParticle->GetDefinition()== fOpticalPhoton)
{
@@ -521,12 +552,23 @@ G4VParticleChange* G4Transportation::AlongStepDoIt( const G4Track& track,
<< G4endl
<< " This track has " << track.GetKineticEnergy() / MeV
<< " MeV energy." << G4endl;
G4cout << " Number of trials = " << fNoLooperTrials
<< " No of calls to AlongStepDoIt = " << noCalls
<< G4endl;
}
#endif
fNoLooperTrials=0;
}
else{
fNoLooperTrials ++;
#ifdef G4VERBOSE
if( (fVerboseLevel > 2) ){
G4cout << " Transportation::AlongStepDoIt(): Particle looping - "
<< " Number of trials = " << fNoLooperTrials
<< " No of calls to = " << noCalls
<< G4endl;
}
#endif
}
}else{
fNoLooperTrials=0;
@@ -599,88 +641,6 @@ G4VParticleChange* G4Transportation::PostStepDoIt( const G4Track& track,
}
else // fGeometryLimitedStep is false
{
#ifdef G4DEBUG_POSTSTEP_TRANSPORT
// Although the location is changed, we know that the physical
// volume remains constant.
// In order to help in checking the user geometry
// we perform a full-relocation and check its result
// *except* if we have made a very small step from a boundary
// (i.e. remaining inside the tolerance)
G4bool startAtSurface_And_MoveEpsilon ;
startAtSurface_And_MoveEpsilon =
(stepData.GetPreStepPoint()->GetSafety() == 0.0) &&
(stepData.GetStepLength() < kCarTolerance ) ;
if( startAtSurface_And_MoveEpsilon )
{
fLinearNavigator->
LocateGlobalPointAndUpdateTouchableHandle( track.GetPosition(),
track.GetMomentumDirection(),
fCurrentTouchableHandle,
true );
if( fCurrentTouchableHandle->GetVolume() != track.GetVolume() )
{
G4cerr << " ERROR: A relocation within safety has"
<< " caused a volume change! " << G4endl ;
G4cerr << " The old volume is called "
<< track.GetVolume()->GetName() << G4endl ;
G4cerr << " The new volume is called " ;
if ( fCurrentTouchableHandle->GetVolume() != 0 )
{
G4cerr << fCurrentTouchableHandle->GetVolume()->GetName()
<< G4endl ;
}
else
{
G4cerr << "Out of World" << G4endl ;
}
G4cerr.precision(7) ;
G4cerr << " The position is " << track.GetPosition() << G4endl ;
// Let us relocate again, for debuging
//
fLinearNavigator->
LocateGlobalPointAndUpdateTouchableHandle(track.GetPosition(),
track.GetMomentumDirection(),
fCurrentTouchableHandle,
true ) ;
G4cerr << " The newer volume is called " ;
if ( fCurrentTouchableHandle->GetVolume() != 0 )
{
G4cerr << fCurrentTouchableHandle->GetVolume()->GetName()
<< G4endl ;
}
else
{
G4cerr << "Out of World" << G4endl ;
}
}
assert( fCurrentTouchableHandle->GetVolume()->GetName() ==
track.GetVolume()->GetName() ) ;
retCurrentTouchable = fCurrentTouchableHandle ;
fParticleChange.SetTouchableHandle( fCurrentTouchableHandle ) ;
}
else
{
retCurrentTouchable = track.GetTouchableHandle() ;
fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
}
// This must be done in the above if ( AtSur ) fails
// We also do it for if (true) in order to get debug/opt to
// behave as exactly the same way as possible.
//
fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
#else // ie #ifndef G4DEBUG_POSTSTEP_TRANSPORT does a quick relocation
// This serves only to move the Navigator's location
//
fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
@@ -688,13 +648,10 @@ G4VParticleChange* G4Transportation::PostStepDoIt( const G4Track& track,
// The value of the track's current Touchable is retained.
// (and it must be correct because we must use it below to
// overwrite the (unset) one in particle change)
// Although in general this is fCurrentTouchable, at the start of
// a step it could be different ... ??
// It must be fCurrentTouchable too ??
//
fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
retCurrentTouchable = track.GetTouchableHandle() ;
#endif
} // endif ( fGeometryLimitedStep )
const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
source/processes/transportation/src/G4UserSpecialCuts.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4UserSpecialCuts.cc,v 1.14.2.1 2006/06/29 21:12:30 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4UserSpecialCuts.cc,v 1.16 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// --------------------------------------------------------------
// History
source/processes/transportation/src/G4VProcessPlacer.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VProcessPlacer.cc,v 1.2.2.1 2006/06/29 21:12:32 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4VProcessPlacer.cc,v 1.4 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4VSampler.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VSampler.cc,v 1.2.2.1 2006/06/29 21:12:42 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4VSampler.cc,v 1.4 2006/10/16 18:19:53 japost Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4VSamplerConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VSamplerConfigurator.cc,v 1.2.2.1 2006/06/29 21:12:44 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4VSamplerConfigurator.cc,v 1.4 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4VTrackTerminator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VTrackTerminator.cc,v 1.3.2.1 2006/06/29 21:12:46 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4VTrackTerminator.cc,v 1.5 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file
source/processes/transportation/src/G4WeightCutOffConfigurator.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4WeightCutOffConfigurator.cc,v 1.5.2.1 2006/06/29 21:12:48 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4WeightCutOffConfigurator.cc,v 1.7 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// Class G4WeightCutOffConfigurator
source/processes/transportation/src/G4WeightCutOffProcess.cc
+2 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4WeightCutOffProcess.cc,v 1.7.2.1 2006/06/29 21:12:50 gunter Exp $
// GEANT4 tag $Name: geant4-08-01 $
// $Id: G4WeightCutOffProcess.cc,v 1.9 2006/11/14 09:11:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-02 $
//
// ----------------------------------------------------------------------
// GEANT 4 class source file