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

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/binary_cascade/src/G4BinaryCascade.cc
+9 -22
View File
@@ -209,18 +209,7 @@ G4HadFinalState * G4BinaryCascade::ApplyYourself(const G4HadProjectile & aTrack,
G4Nucleus & aNucleus)
//----------------------------------------------------------------------------
{
static G4int eventcounter=0;
// if ( eventcounter == 0 ) {
// SetEpReportLevel(3); // report non conservation with model etc.
// G4double relativeLevel = 1*perCent;
// G4double absoluteLevel = 2*MeV;
// SetEnergyMomentumCheckLevels(relativeLevel,absoluteLevel);
// }
//if(eventcounter == 100*(eventcounter/100) )
eventcounter++;
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction number starts ######### "<<eventcounter<<G4endl;
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction starts ######### "<< G4endl;
G4LorentzVector initial4Momentum = aTrack.Get4Momentum();
G4ParticleDefinition * definition = const_cast<G4ParticleDefinition *>(aTrack.GetDefinition());
@@ -319,7 +308,7 @@ G4HadFinalState * G4BinaryCascade::ApplyYourself(const G4HadProjectile & aTrack,
} else { // no interaction, return primary
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction number void ######### "<<eventcounter<<G4endl;
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction void, return intial state ######### "<< G4endl;
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
@@ -331,7 +320,7 @@ G4HadFinalState * G4BinaryCascade::ApplyYourself(const G4HadProjectile & aTrack,
delete the3DNucleus;
the3DNucleus = NULL;
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction number ends ######### "<<eventcounter<<G4endl;
if(getenv("BCDEBUG") ) G4cerr << " ######### Binary Cascade Reaction ends ######### "<< G4endl;
return &theParticleChange;
}
@@ -1736,7 +1725,7 @@ G4double G4BinaryCascade::CorrectShortlivedPrimaryForFermi(
G4int PDGcode=primary->GetDefinition()->GetPDGEncoding();
Efermi=((G4RKPropagation *)thePropagator)->GetField(PDGcode,primary->GetPosition());
if ( std::abs(PDGcode > 1000) && PDGcode != 2112 && PDGcode != 2212 )
if ( std::abs(PDGcode) > 1000 && PDGcode != 2112 && PDGcode != 2212 )
{
Efermi = ((G4RKPropagation *)thePropagator)->GetField(G4Neutron::Neutron()->GetPDGEncoding(),primary->GetPosition());
G4LorentzVector mom4Primary=primary->Get4Momentum();
@@ -2454,9 +2443,6 @@ G4Fragment * G4BinaryCascade::FindFragments()
//GF fragment->SetNumberOfParticles(excitons-holes);
fragment->SetNumberOfParticles(excitons);
fragment->SetNumberOfCharged(zCaptured);
G4ParticleDefinition * aIonDefinition =
G4ParticleTable::GetParticleTable()->FindIon(a,z,0,z);
fragment->SetParticleDefinition(aIonDefinition);
return fragment;
}
@@ -2553,9 +2539,8 @@ G4ReactionProductVector * G4BinaryCascade::Propagate1H1(
{
G4ReactionProductVector * products = new G4ReactionProductVector;
G4ParticleDefinition * aHTarg = G4Proton::ProtonDefinition();
G4double mass = aHTarg->GetPDGMass();
if (nucleus->GetCharge() == 0) aHTarg = G4Neutron::NeutronDefinition();
mass = aHTarg->GetPDGMass();
G4double mass = aHTarg->GetPDGMass();
G4KineticTrackVector * secs = 0;
G4ThreeVector pos(0,0,0);
G4LorentzVector mom(mass);
@@ -2584,9 +2569,11 @@ G4ReactionProductVector * G4BinaryCascade::Propagate1H1(
}
}
size_t current(0);
ClearAndDestroy(&theFinalState);
for(current=0; secs && current<secs->size(); current++)
ClearAndDestroy(secondaries);
delete secondaries;
for(size_t current=0; secs && current<secs->size(); current++)
{
if((*secs)[current]->GetDefinition()->IsShortLived())
{
source/processes/hadronic/models/binary_cascade/src/G4BinaryLightIonReaction.cc
+5 -11
View File
@@ -86,9 +86,7 @@ struct ReactionProduct4Mom
G4HadFinalState *G4BinaryLightIonReaction::
ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus & targetNucleus )
{
static G4int eventcounter=0;
eventcounter++;
if(getenv("BLICDEBUG") ) G4cerr << " ######### Binary Light Ion Reaction number starts ######### "<<eventcounter<<G4endl;
if(getenv("BLICDEBUG") ) G4cerr << " ######### Binary Light Ion Reaction starts ######### " << G4endl;
G4ping debug("debug_G4BinaryLightIonReaction");
pA=aTrack.GetDefinition()->GetBaryonNumber();
pZ=G4lrint(aTrack.GetDefinition()->GetPDGCharge()/eplus);
@@ -250,6 +248,8 @@ ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus & targetNucleus )
DeExciteSpectatorNucleus(spectators, cascaders, theStatisticalExEnergy, momentum);
} else {
delete spectators;
}
}
// Rotate to lab
@@ -299,7 +299,7 @@ ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus & targetNucleus )
<< aTrack.GetTotalEnergy() + m_nucl - Etot;
#endif
if(getenv("BLICDEBUG") ) G4cerr << " ######### Binary Light Ion Reaction number ends ######### "<<eventcounter<<G4endl;
if(getenv("BLICDEBUG") ) G4cerr << " ######### Binary Light Ion Reaction number ends ######### " << G4endl;
return &theResult;
}
@@ -428,10 +428,7 @@ G4ReactionProductVector * G4BinaryLightIonReaction::FuseNucleiAndPrompound(const
G4double m_nucl=G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(tZ,tA);
G4LorentzVector aL(mom.t()+m_nucl, plop);
aPreFrag.SetMomentum(aL);
G4ParticleDefinition * preFragDef;
preFragDef = G4ParticleTable::GetParticleTable()
->FindIon(pZ+tZ,pA+tA,0,pZ+tZ);
aPreFrag.SetParticleDefinition(preFragDef);
// G4cout << "Fragment INFO "<< pA+tA <<" "<<pZ+tZ<<" "
// << aL <<" "<<preFragDef->GetParticleName()<<G4endl;
@@ -603,9 +600,6 @@ void G4BinaryLightIonReaction::DeExciteSpectatorNucleus(G4ReactionProductVector
G4double mFragment=G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(spectatorZ,spectatorA);
pFragment=G4LorentzVector(0,0,0,mFragment+std::max(0.,theStatisticalExEnergy) );
aProRes.SetMomentum(pFragment);
G4ParticleDefinition * resDef;
resDef = G4ParticleTable::GetParticleTable()->FindIon(spectatorZ,spectatorA,0,spectatorZ);
aProRes.SetParticleDefinition(resDef);
proFrag = theHandler->BreakItUp(aProRes);
source/processes/hadronic/models/binary_cascade/src/G4GeneratorPrecompoundInterface.cc
+446 -59
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4GeneratorPrecompoundInterface.cc 66812 2013-01-12 16:06:46Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class file
@@ -46,8 +46,22 @@
#include "G4KineticTrackVector.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4V3DNucleus.hh"
#include "G4Nucleon.hh"
#include "G4AntiProton.hh"
#include "G4AntiNeutron.hh"
#include "G4AntiDeuteron.hh"
#include "G4AntiTriton.hh"
#include "G4AntiHe3.hh"
#include "G4AntiAlpha.hh"
#include "G4FragmentVector.hh"
#include "G4ReactionProduct.hh"
#include "G4ReactionProductVector.hh"
@@ -61,6 +75,20 @@ G4GeneratorPrecompoundInterface::G4GeneratorPrecompoundInterface(G4VPreCompoundM
{
proton = G4Proton::Proton();
neutron = G4Neutron::Neutron();
deuteron=G4Deuteron::Deuteron();
triton =G4Triton::Triton();
He3 =G4He3::He3();
He4 =G4Alpha::Alpha();
ANTIproton=G4AntiProton::AntiProton();
ANTIneutron=G4AntiNeutron::AntiNeutron();
ANTIdeuteron=G4AntiDeuteron::AntiDeuteron();
ANTItriton =G4AntiTriton::AntiTriton();
ANTIHe3 =G4AntiHe3::AntiHe3();
ANTIHe4 =G4AntiAlpha::AntiAlpha();
if(preModel) { SetDeExcitation(preModel); }
else {
G4HadronicInteraction* hadi =
@@ -78,7 +106,7 @@ G4GeneratorPrecompoundInterface::~G4GeneratorPrecompoundInterface()
//---------------------------------------------------------------------
// choose to calculate excitation energy from energy balance
#define exactExcitationEnergy
//#define debugPrecoInt
//#define G4GPI_debug_excitation
G4ReactionProductVector* G4GeneratorPrecompoundInterface::
@@ -154,78 +182,79 @@ Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus)
}
exciton3Momentum = captured3Momentum - wounded3Momentum;
if(anA>0 && aZ>0) {
if(anA == 0) return theTotalResult;
if(anA >= aZ)
{
G4double fMass = G4NucleiProperties::GetNuclearMass(anA, aZ);
#ifdef exactExcitationEnergy
// recalculate exEnergy from Energy balance....
// recalculate exEnergy from Energy balance....
const G4HadProjectile * primary = GetPrimaryProjectile();
G4double Einitial= primary->Get4Momentum().e()
+ G4NucleiProperties::GetNuclearMass(theNucleus->GetMassNumber(),theNucleus->GetCharge());
G4double Efinal = fMass + secondary4Momemtum.e();
+ G4NucleiProperties::GetNuclearMass(theNucleus->GetMassNumber(),
theNucleus->GetCharge());
// Uzhi G4double Efinal = fMass + secondary4Momemtum.e();
G4double Efinal = std::sqrt(exciton3Momentum.mag2() + fMass*fMass)
+ secondary4Momemtum.e();
if ( (Einitial - Efinal) > 0 ) {
// G4cout << "G4GPI::Propagate() : positive exact excitation Energy "
// << (Einitial - Efinal)/MeV << " MeV, exciton estimate " << exEnergy/MeV << " MeV" << G4endl;
exEnergy=Einitial - Efinal;
// << (Einitial - Efinal)/MeV << " MeV, exciton estimate "
// << exEnergy/MeV << " MeV" << G4endl;
// exEnergy=Einitial - Efinal;
G4LorentzVector PrimMom=primary->Get4Momentum(); PrimMom.setE(Einitial);
exEnergy=(PrimMom - secondary4Momemtum).mag() - fMass;
}
else {
// G4cout << "G4GeneratorPrecompoundInterface::Propagate() : negative exact excitation Energy "
// << (Einitial - Efinal)/MeV << " MeV, setting excitation to 0 MeV" << G4endl;
// G4cout << "G4GeneratorPrecompoundInterface::Propagate() : "
// << "negative exact excitation Energy "
// << (Einitial - Efinal)/MeV
// << " MeV, setting excitation to 0 MeV" << G4endl;
exEnergy=0.;
}
#endif
if(exEnergy < 0.) exEnergy=0.; // Uzhi 11 Dec. 2012
fMass += exEnergy;
G4ThreeVector balance=primary->Get4Momentum().vect() - secondary4Momemtum.vect() - exciton3Momentum;
#ifdef G4GPI_debug_excitation
G4cout << "momentum balance init/final " << balance << " value " << balance.mag() << G4endl
<< "primary / secondaries "<< primary->Get4Momentum() << " / "
<< secondary4Momemtum << " captured/wounded: " << captured3Momentum << " / " << wounded3Momentum
<< " exciton " << exciton3Momentum << G4endl
<< secondary4Momemtum.vect() + exciton3Momentum << G4endl;
#endif
#ifdef exactExcitationEnergy
G4LorentzVector exciton4Momentum(exciton3Momentum, fMass);
#else
G4ThreeVector balance=primary->Get4Momentum().vect() -
secondary4Momemtum.vect() - exciton3Momentum;
#ifdef G4GPI_debug_excitation
G4cout << "momentum balance" << balance
<< " value " << balance.mag() <<G4endl
<< "primary "<< primary->Get4Momentum() <<G4endl
<< "secondary "<< secondary4Momemtum <<G4endl
<< "captured "<< captured3Momentum <<G4endl
<< "wounded "<< wounded3Momentum <<G4endl
<< "exciton "<< exciton3Momentum <<G4endl
<< "second + exciton"
<< secondary4Momemtum.vect() + exciton3Momentum << G4endl;
#endif
//#ifdef exactExcitationEnergy
// G4LorentzVector exciton4Momentum(exciton3Momentum, fMass);
// G4LorentzVector exciton4Momentum(exciton3Momentum,
// std::sqrt(exciton3Momentum.mag2() + fMass*fMass));
//#else
G4LorentzVector exciton4Momentum(exciton3Momentum,
std::sqrt(exciton3Momentum.mag2() + fMass*fMass));
#endif
if ( exEnergy > 0.0 ) { // Need to de-excite the remnant nucleus only if excitation energy > 0.
G4Fragment anInitialState(anA, aZ, exciton4Momentum);
anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
anInitialState.SetNumberOfCharged(numberOfCh);
anInitialState.SetNumberOfHoles(numberOfHoles);
//#endif
//G4cout<<"exciton4Momentum "<<exciton4Momentum<<G4endl;
// Need to de-excite the remnant nucleus only if excitation energy > 0.
G4Fragment anInitialState(anA, aZ, exciton4Momentum);
anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
anInitialState.SetNumberOfCharged(numberOfCh);
anInitialState.SetNumberOfHoles(numberOfHoles);
G4ReactionProductVector * aPrecoResult = theDeExcitation->DeExcite(anInitialState);
// fill pre-compound part into the result, and return
theTotalResult->insert(theTotalResult->end(),aPrecoResult->begin(),aPrecoResult->end() );
delete aPrecoResult;
} else { // No/negative excitation energy, we only need to create the remnant nucleus
// energy is not conserved, ignore exciton momentum, i.e. remnant nucleus will be at rest
G4ParticleDefinition* theKindOfFragment = 0;
if (anA == 1 && aZ == 0) {
theKindOfFragment = G4Neutron::NeutronDefinition();
} else if (anA == 1 && aZ == 1) {
theKindOfFragment = G4Proton::ProtonDefinition();
} else if (anA == 2 && aZ == 1) {
theKindOfFragment = G4Deuteron::DeuteronDefinition();
} else if (anA == 3 && aZ == 1) {
theKindOfFragment = G4Triton::TritonDefinition();
} else if (anA == 3 && aZ == 2) {
theKindOfFragment = G4He3::He3Definition();
} else if (anA == 4 && aZ == 2) {
theKindOfFragment = G4Alpha::AlphaDefinition();;
} else {
theKindOfFragment =
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(aZ,anA,0.0);
}
if (theKindOfFragment != 0) {
G4ReactionProduct * theNew = new G4ReactionProduct(theKindOfFragment);
theNew->SetMomentum(G4ThreeVector(0.,0.,0.));
theNew->SetTotalEnergy(fMass);
//theNew->SetFormationTime(??0.??);
theTotalResult->push_back(theNew);
}
}
G4ReactionProductVector * aPrecoResult =
theDeExcitation->DeExcite(anInitialState);
// fill pre-compound part into the result, and return
theTotalResult->insert(theTotalResult->end(),aPrecoResult->begin(),
aPrecoResult->end() );
delete aPrecoResult;
}
return theTotalResult;
@@ -253,3 +282,361 @@ void G4GeneratorPrecompoundInterface::PropagateModelDescription(std::ostream& ou
// preco
}
// Uzhi Nov. 2012 ------------------------------------------------
G4ReactionProductVector* G4GeneratorPrecompoundInterface::
PropagateNuclNucl(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus,
G4V3DNucleus* theProjectileNucleus)
{
#ifdef debugPrecoInt
G4cout<<"G4GeneratorPrecompoundInterface::PropagateNuclNucl "<<G4endl;
#endif
G4ReactionProductVector * theTotalResult = new G4ReactionProductVector;
// prepare the target residual
G4int anA=theNucleus->GetMassNumber();
G4int aZ=theNucleus->GetCharge();
G4int numberOfEx = 0;
G4int numberOfCh = 0;
G4int numberOfHoles = 0;
G4double exEnergy = 0.0;
G4double R = theNucleus->GetNuclearRadius();
G4LorentzVector Target4Momentum(0,0,0,0);
#ifdef debugPrecoInt
G4cout<<"Target A Z "<<anA<<" "<<aZ<<G4endl;
#endif
// loop over wounded target nucleus
G4Nucleon * theCurrentNucleon =
theNucleus->StartLoop() ? theNucleus->GetNextNucleon() : 0;
while(theCurrentNucleon) {
if(theCurrentNucleon->AreYouHit()) {
++numberOfHoles;
++numberOfEx;
--anA;
aZ -= G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
eplus + 0.1);
exEnergy += theCurrentNucleon->GetBindingEnergy();
Target4Momentum -=theCurrentNucleon->Get4Momentum();
}
theCurrentNucleon = theNucleus->GetNextNucleon();
}
#ifdef debugPrecoInt
G4cout<<"Residual Target A Z E* 4mom "<<anA<<" "<<aZ<<" "<<exEnergy<<" "
<<Target4Momentum<<G4endl;
#endif
// prepare the projectile residual
#ifdef debugPrecoInt
G4cout<<"Primary BaryonNumber "
<<GetPrimaryProjectile()->GetDefinition()->GetBaryonNumber()<<G4endl;
#endif
G4bool ProjectileIsAntiNucleus=
GetPrimaryProjectile()->GetDefinition()->GetBaryonNumber() < -1;
G4ThreeVector bst = GetPrimaryProjectile()->Get4Momentum().boostVector();
G4int anAb=theProjectileNucleus->GetMassNumber();
G4int aZb=theProjectileNucleus->GetCharge();
G4int numberOfExB = 0;
G4int numberOfChB = 0;
G4int numberOfHolesB = 0;
G4double exEnergyB = 0.0;
G4double Rb = theProjectileNucleus->GetNuclearRadius();
G4LorentzVector Projectile4Momentum(0,0,0,0);
#ifdef debugPrecoInt
G4cout<<"Projectile A Z "<<anAb<<" "<<aZb<<G4endl;
#endif
// loop over wounded projectile nucleus
theCurrentNucleon =
theProjectileNucleus->StartLoop() ? theProjectileNucleus->GetNextNucleon() : 0;
while(theCurrentNucleon) {
if(theCurrentNucleon->AreYouHit()) {
++numberOfHolesB;
++numberOfExB;
--anAb;
if(!ProjectileIsAntiNucleus)
{
aZb -= G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
eplus + 0.1);
} else
{
aZb += G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
eplus - 0.1);
}
exEnergyB += theCurrentNucleon->GetBindingEnergy();
Projectile4Momentum -=theCurrentNucleon->Get4Momentum();
}
theCurrentNucleon = theProjectileNucleus->GetNextNucleon();
}
G4bool ExistTargetRemnant = G4double (numberOfHoles) <
0.3* G4double (numberOfHoles + anA);
G4bool ExistProjectileRemnant= G4double (numberOfHolesB) <
0.3*G4double (numberOfHolesB + anAb);
#ifdef debugPrecoInt
G4cout<<"Projectile residual A Z E* 4mom "<<anAb<<" "<<aZb<<" "<<exEnergyB<<" "
<<Projectile4Momentum<<G4endl;
G4cout<<" ExistTargetRemnant ExistProjectileRemnant "
<<ExistTargetRemnant<<" "<< ExistProjectileRemnant<<G4endl;
#endif
//-----------------------------------------------------------------------------
// decay the strong resonances
G4DecayKineticTracks decay(theSecondaries);
#ifdef debugPrecoInt
G4LorentzVector secondary4Momemtum(0,0,0,0);
G4int SecondrNum(0);
#endif
// loop over secondaries
G4KineticTrackVector::iterator iter;
for(iter=theSecondaries->begin(); iter !=theSecondaries->end(); ++iter)
{
G4ParticleDefinition* part = (*iter)->GetDefinition();
G4LorentzVector aTrack4Momentum=(*iter)->Get4Momentum();
if( part != proton && part != neutron &&
(part != ANTIproton && ProjectileIsAntiNucleus) &&
(part != ANTIneutron && ProjectileIsAntiNucleus) )
{
G4ReactionProduct * theNew = new G4ReactionProduct(part);
theNew->SetMomentum(aTrack4Momentum.vect());
theNew->SetTotalEnergy(aTrack4Momentum.e());
theTotalResult->push_back(theNew);
#ifdef debugPrecoInt
SecondrNum++;
secondary4Momemtum += (*iter)->Get4Momentum();
G4cout<<"Secondary "<<SecondrNum<<" "
<<theNew->GetDefinition()->GetParticleName()<<" "
<<secondary4Momemtum<<G4endl;
#endif
delete (*iter);
continue;
}
G4bool CanBeCapturedByTarget = false;
if( part == proton || part == neutron)
{
CanBeCapturedByTarget = ExistTargetRemnant &&
(CaptureThreshold >
(aTrack4Momentum + Target4Momentum).mag() -
aTrack4Momentum.mag() - Target4Momentum.mag()) &&
((*iter)->GetPosition().mag() < R);
}
// ---------------------------
G4LorentzVector Position((*iter)->GetPosition(),
(*iter)->GetFormationTime());
Position.boost(bst);
G4bool CanBeCapturedByProjectile = false;
if( !ProjectileIsAntiNucleus &&
( part == proton || part == neutron))
{
CanBeCapturedByProjectile = ExistProjectileRemnant &&
(CaptureThreshold >
(aTrack4Momentum + Projectile4Momentum).mag() -
aTrack4Momentum.mag() - Projectile4Momentum.mag()) &&
(Position.vect().mag() < Rb);
}
if( ProjectileIsAntiNucleus &&
( part == ANTIproton || part == ANTIneutron))
{
CanBeCapturedByProjectile = ExistProjectileRemnant &&
(CaptureThreshold >
(aTrack4Momentum + Projectile4Momentum).mag() -
aTrack4Momentum.mag() - Projectile4Momentum.mag()) &&
(Position.vect().mag() < Rb);
}
if(CanBeCapturedByTarget && CanBeCapturedByProjectile)
{
if(G4UniformRand() < 0.5)
{ CanBeCapturedByTarget = true; CanBeCapturedByProjectile = false;}
else
{ CanBeCapturedByTarget = false; CanBeCapturedByProjectile = true;}
}
if(CanBeCapturedByTarget)
{
// within the target nucleus, neutron or proton
// now calculate A, Z of the fragment, momentum,
// number of exciton states
#ifdef debugPrecoInt
G4cout<<"Track is CapturedByTarget "<<" "
<<aTrack4Momentum<<" "<<aTrack4Momentum.mag()<<G4endl;
#endif
++anA;
++numberOfEx;
G4int Z = G4int(part->GetPDGCharge()/eplus + 0.1);
aZ += Z;
numberOfCh += Z;
Target4Momentum +=aTrack4Momentum;
delete (*iter);
} else if(CanBeCapturedByProjectile)
{
// within the projectile nucleus, neutron or proton
// now calculate A, Z of the fragment, momentum,
// number of exciton states
#ifdef debugPrecoInt
G4cout<<"Track is CapturedByProjectile"<<" "
<<aTrack4Momentum<<" "<<aTrack4Momentum.mag()<<G4endl;
#endif
++anAb;
++numberOfExB;
G4int Z = G4int(part->GetPDGCharge()/eplus + 0.1);
if( ProjectileIsAntiNucleus ) Z=-Z;
aZb += Z;
numberOfChB += Z;
Projectile4Momentum +=aTrack4Momentum;
delete (*iter);
} else
{ // the track is not captured
G4ReactionProduct * theNew = new G4ReactionProduct(part);
theNew->SetMomentum(aTrack4Momentum.vect());
theNew->SetTotalEnergy(aTrack4Momentum.e());
theTotalResult->push_back(theNew);
#ifdef debugPrecoInt
SecondrNum++;
secondary4Momemtum += (*iter)->Get4Momentum();
G4cout<<"Secondary "<<SecondrNum<<" "
<<theNew->GetDefinition()->GetParticleName()<<" "
<<secondary4Momemtum<<G4endl;
#endif
delete (*iter);
continue;
}
}
delete theSecondaries;
//-----------------------------------------------------
#ifdef debugPrecoInt
G4cout<<"Final target residual A Z E* 4mom "<<anA<<" "<<aZ<<" "
<<exEnergy<<" "<<Target4Momentum<<G4endl;
#endif
if(0!=anA )
{
G4double fMass = G4NucleiProperties::GetNuclearMass(anA, aZ);
if((anA == theNucleus->GetMassNumber()) && (exEnergy <= 0.))
{Target4Momentum.setE(fMass);}
G4double RemnMass=Target4Momentum.mag();
if(RemnMass < fMass)
{
RemnMass=fMass + exEnergy;
Target4Momentum.setE(std::sqrt(Target4Momentum.vect().mag2() +
RemnMass*RemnMass));
} else
{ exEnergy=RemnMass-fMass;}
if( exEnergy < 0.) exEnergy=0.;
// Need to de-excite the remnant nucleus
G4Fragment anInitialState(anA, aZ, Target4Momentum);
anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
anInitialState.SetNumberOfCharged(numberOfCh);
anInitialState.SetNumberOfHoles(numberOfHoles);
G4ReactionProductVector * aPrecoResult =
theDeExcitation->DeExcite(anInitialState);
// fill pre-compound part into the result, and return
for(unsigned int ll=0; ll<aPrecoResult->size(); ++ll)
{
theTotalResult->push_back(aPrecoResult->operator[](ll));
#ifdef debugPrecoInt
G4cout<<"Tr frag "<<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()
<<" "<<aPrecoResult->operator[](ll)->GetMomentum()<<G4endl;
#endif
}
delete aPrecoResult;
}
//-----------------------------------------------------
if((anAb == theProjectileNucleus->GetMassNumber())&& (exEnergyB <= 0.))
{Projectile4Momentum = GetPrimaryProjectile()->Get4Momentum();}
#ifdef debugPrecoInt
G4cout<<"Final projectile residual A Z E* Pmom "<<anAb<<" "<<aZb<<" "
<<exEnergyB<<" "<<Projectile4Momentum<<G4endl;
#endif
if(0!=anAb)
{
G4double fMass = G4NucleiProperties::GetNuclearMass(anAb, aZb);
G4double RemnMass=Projectile4Momentum.mag();
if(RemnMass < fMass)
{
RemnMass=fMass + exEnergyB;
Projectile4Momentum.setE(std::sqrt(Projectile4Momentum.vect().mag2() +
RemnMass*RemnMass));
} else
{ exEnergyB=RemnMass-fMass;}
if( exEnergyB < 0.) exEnergyB=0.;
// Need to de-excite the remnant nucleus
G4Fragment anInitialState(anAb, aZb, Projectile4Momentum);
anInitialState.SetNumberOfParticles(numberOfExB-numberOfHolesB);
anInitialState.SetNumberOfCharged(numberOfChB);
anInitialState.SetNumberOfHoles(numberOfHolesB);
G4ReactionProductVector * aPrecoResult =
theDeExcitation->DeExcite(anInitialState);
// fill pre-compound part into the result, and return
for(unsigned int ll=0; ll<aPrecoResult->size(); ++ll)
{
if(ProjectileIsAntiNucleus)
{
#ifdef debugPrecoInt
G4cout<<"aPrecoRes "<<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()
<<" "<<aPrecoResult->operator[](ll)->GetMomentum()
<<" "<<aPrecoResult->operator[](ll)->GetTotalEnergy()
<<" "<<aPrecoResult->operator[](ll)->GetMass()<<G4endl;
#endif
G4ParticleDefinition * aFragment=aPrecoResult->operator[](ll)->GetDefinition();
G4ParticleDefinition * LastFragment=aFragment;
if (aFragment == proton) {LastFragment=G4AntiProton::AntiProtonDefinition();}
else if(aFragment == neutron) {LastFragment=G4AntiNeutron::AntiNeutronDefinition();}
else if(aFragment == deuteron){LastFragment=G4AntiDeuteron::AntiDeuteronDefinition();}
else if(aFragment == triton) {LastFragment=G4AntiTriton::AntiTritonDefinition();}
else if(aFragment == He3) {LastFragment=G4AntiHe3::AntiHe3Definition();}
else if(aFragment == He4) {LastFragment=G4AntiAlpha::AntiAlphaDefinition();}
else {}
aPrecoResult->operator[](ll)->SetDefinitionAndUpdateE(LastFragment);
}
#ifdef debugPrecoInt
G4cout<<"aPrecoResA "<<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()
<<" "<<aPrecoResult->operator[](ll)->GetMomentum()
<<" "<<aPrecoResult->operator[](ll)->GetTotalEnergy()
<<" "<<aPrecoResult->operator[](ll)->GetMass()<<G4endl;
#endif
theTotalResult->push_back(aPrecoResult->operator[](ll));
}
delete aPrecoResult;
}
return theTotalResult;
}
// Uzhi Nov. 2012 ------------------------------------------------
source/processes/hadronic/models/binary_cascade/src/G4KM_NucleonEqRhs.cc
+4 -3
View File
@@ -107,6 +107,7 @@ void G4KM_NucleonEqRhs::EvaluateRhsGivenB(const G4double y[],
*/
}
// Here by design, but it is unnecessary for nuclear fields
void G4KM_NucleonEqRhs::SetChargeMomentumMass(G4ChargeState,G4double ,G4double )
{
}
source/processes/hadronic/models/binary_cascade/src/G4KM_OpticalEqRhs.cc
+4 -3
View File
@@ -90,6 +90,7 @@ void G4KM_OpticalEqRhs::EvaluateRhsGivenB(const G4double y[], const G4double *,
dydx[5] = yMod == 0 ? 0 : -deriv*y[2]/yMod*c_light;
}
// Here by design, but it is unnecessary for nuclear fields
void G4KM_OpticalEqRhs::SetChargeMomentumMass(G4ChargeState,G4double ,G4double )
{
}
source/processes/hadronic/models/binary_cascade/src/G4RKFieldIntegrator.cc
+55 -53
View File
@@ -33,7 +33,7 @@
#include "G4NuclearShellModelDensity.hh"
#include "G4Nucleon.hh"
// Class G4RKFieldIntegrator
// Class G4RKFieldIntegrator
//*************************************************************************************************************************************
// only theActive are propagated, nothing else
@@ -69,14 +69,14 @@ G4double G4RKFieldIntegrator::CalculateTotalEnergy(const G4KineticTrackVector& B
G4double r12 = (p1->GetPosition() - p2->GetPosition()).mag()*fermi;
// Esk2
Etot += t1*std::pow(Alpha/pi, 3/2)*std::exp(-Alpha*r12*r12);
Etot += t1*std::pow(Alpha/pi, 3/2)*std::exp(-Alpha*r12*r12);
// Eyuk
Etot += Vo*0.5/r12*std::exp(1/(4*Alpha*GammaY*GammaY))*
(std::exp(-r12/GammaY)*(1 - Erf(0.5/GammaY/std::sqrt(Alpha) - std::sqrt(Alpha)*r12)) -
(std::exp(-r12/GammaY)*(1 - Erf(0.5/GammaY/std::sqrt(Alpha) - std::sqrt(Alpha)*r12)) -
std::exp( r12/GammaY)*(1 - Erf(0.5/GammaY/std::sqrt(Alpha) + std::sqrt(Alpha)*r12)));
// Ecoul
// Ecoul
Etot += 1.44*p1->GetDefinition()->GetPDGCharge()*p2->GetDefinition()->GetPDGCharge()/r12*Erf(std::sqrt(Alpha)*r12);
// Epaul
@@ -91,11 +91,11 @@ G4double G4RKFieldIntegrator::CalculateTotalEnergy(const G4KineticTrackVector& B
Etot = tGamma*std::pow(4*Alpha*Alpha/3/pi/pi, 1.5)*std::exp(-Alpha*(r12*r12 + r13*r13));
}
}
}
}
return Etot;
}
}
//************************************************************************************************
//************************************************************************************************
// originated from the Numerical recipes error function
G4double G4RKFieldIntegrator::Erf(G4double X)
{
@@ -107,18 +107,20 @@ G4double G4RKFieldIntegrator::Erf(G4double X)
const G4double Q10 = +3.2584593;
const G4double P11 = -9.7970465E-2;
static G4double P2[5] = { 7.3738883, 6.8650185, 3.0317993, 0.56316962, 4.3187787e-5 };
static G4double Q2[5] = { 7.3739609, 15.184908, 12.79553, 5.3542168, 1. };
// static G4ThreadLocal G4double P2[5] = { 7.3738883, 6.8650185, 3.0317993, 0.56316962, 4.3187787e-5 };
// static G4ThreadLocal G4double Q2[5] = { 7.3739609, 15.184908, 12.79553, 5.3542168, 1. };
const G4double P2[5] = { 7.3738883, 6.8650185, 3.0317993, 0.56316962, 4.3187787e-5 };
const G4double Q2[5] = { 7.3739609, 15.184908, 12.79553, 5.3542168, 1. };
const G4double P30 = -1.2436854E-1;
const G4double Q30 = +4.4091706E-1;
const G4double P31 = -9.6821036E-2;
G4double V = std::abs(X);
G4double H;
G4double H;
G4double Y;
G4int c1;
if(V < HF)
{
Y = V*V;
@@ -126,7 +128,7 @@ G4double G4RKFieldIntegrator::Erf(G4double X)
}
else
{
if(V < 4)
if(V < 4)
{
G4double AP = P2[4];
G4double AQ = Q2[4];
@@ -142,21 +144,21 @@ G4double G4RKFieldIntegrator::Erf(G4double X)
Y = 1./V*V;
H = 1 - std::exp(-V*V)*(C1+Y*(P30 + P31*Y)/(Q30 + Y))/V;
}
if (X < 0)
if (X < 0)
H = -H;
}
return H;
}
//************************************************************************************************
//************************************************************************************************
//This is a QMD version to calculate excitation energy of a fragment,
//which consists from G4KTV &the Particles
/*
G4double G4RKFieldIntegrator::GetExcitationEnergy(const G4KineticTrackVector &theParticles)
{
// Excitation energy of a fragment consisting from A nucleons and Z protons
// is Etot - Z*Mp - (A - Z)*Mn - B(A, Z), where B(A,Z) is the binding energy of fragment
// and Mp, Mn are proton and neutron mass, respectively.
// is Etot - Z*Mp - (A - Z)*Mn - B(A, Z), where B(A,Z) is the binding energy of fragment
// and Mp, Mn are proton and neutron mass, respectively.
G4int NZ = 0;
G4int NA = 0;
G4double Etot = CalculateTotalEnergy(theParticles);
@@ -175,7 +177,7 @@ G4double G4RKFieldIntegrator::GetExcitationEnergy(const G4KineticTrackVector &th
*/
//*************************************************************************************************************************************
//This is a simplified method to get excitation energy of a residual
//This is a simplified method to get excitation energy of a residual
// nucleus with nHitNucleons.
G4double G4RKFieldIntegrator::GetExcitationEnergy(G4int nHitNucleons, const G4KineticTrackVector &)
{
@@ -199,7 +201,7 @@ void G4RKFieldIntegrator::Integrate(G4KineticTrackVector& theParticles)
pKineticTrack->SetPosition(pKineticTrack->GetPosition() + theTimeStep*pKineticTrack->Get4Momentum().boostVector());
}
}
*/
*/
//*************************************************************************************************************************************
void G4RKFieldIntegrator::Integrate(const G4KineticTrackVector& theBarions, G4double theTimeStep)
@@ -208,9 +210,9 @@ void G4RKFieldIntegrator::Integrate(const G4KineticTrackVector& theBarions, G4do
{
G4KineticTrack* pKineticTrack = theBarions[cParticle];
pKineticTrack->SetPosition(pKineticTrack->GetPosition() + theTimeStep*pKineticTrack->Get4Momentum().boostVector());
}
}
}
//*************************************************************************************************************************************
// constant to calculate theCoulomb barrier
@@ -239,22 +241,22 @@ G4double G4RKFieldIntegrator::GetNeutronPotential(G4double )
G4VNuclearDensity *theDencity;
if(theA < 17) theDencity = new G4NuclearShellModelDensity(theA, theZ);
else theDencity = new G4NuclearFermiDensity(theA, theZ);
// GetDencity() accepts only G4ThreeVector so build it:
// GetDencity() accepts only G4ThreeVector so build it:
G4ThreeVector aPosition(0.0, 0.0, radius);
G4double density = theDencity->GetDensity(aPosition);
delete theDencity;
G4FermiMomentum *fm = new G4FermiMomentum();
fm->Init(theA, theZ);
G4double fermiMomentum = fm->GetFermiMomentum(density);
delete fm;
return sqr(fermiMomentum)/(2 * Mn)
return sqr(fermiMomentum)/(2 * Mn)
+ G4CreateNucleus::GetBindingEnergy(theZ, theA)/theA;
//+ G4NucleiProperties::GetBindingEnergy(theZ, theA)/theA;
*/
return 0.0;
}
@@ -268,20 +270,20 @@ G4double G4RKFieldIntegrator::GetProtonPotential(G4double )
G4VNuclearDensity *theDencity;
if(theA < 17) theDencity = new G4NuclearShellModelDensity(theA, theZ);
else theDencity = new G4NuclearFermiDensity(theA, theZ);
// GetDencity() accepts only G4ThreeVector so build it:
// GetDencity() accepts only G4ThreeVector so build it:
G4ThreeVector aPosition(0.0, 0.0, radius);
G4double density = theDencity->GetDensity(aPosition);
delete theDencity;
G4FermiMomentum *fm = new G4FermiMomentum();
fm->Init(theA, theZ);
G4double fermiMomentum = fm->GetFermiMomentum(density);
delete fm;
return sqr(fermiMomentum)/ (2 * Mp)
return sqr(fermiMomentum)/ (2 * Mp)
+ G4CreateNucleus::GetBindingEnergy(theZ, theA)/theA;
//+ G4NucleiProperties::GetBindingEnergy(theZ, theA)/theA
//+ G4NucleiProperties::GetBindingEnergy(theZ, theA)/theA
+ theCoulombBarrier;
*/
@@ -292,26 +294,26 @@ G4double G4RKFieldIntegrator::GetAntiprotonPotential(G4double )
{
/*
//G4double theM = G4NucleiProperties::GetAtomicMass(theA, theZ);
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
+ (theA - theZ) * G4Neutron::Neutron()->GetPDGMass()
+ G4CreateNucleus::GetBindingEnergy(theZ, theA);
const G4double Mp = 938.27231 * MeV; // mass of proton
G4double mu = (theM * Mp)/(theM + Mp);
// antiproton's potential coefficient
// V = coeff_antiproton * nucleus_density
G4double coeff_antiproton = -2.*pi/mu * (1. + Mp) * a_antiproton;
G4VNuclearDensity *theDencity;
if(theA < 17) theDencity = new G4NuclearShellModelDensity(theA, theZ);
else theDencity = new G4NuclearFermiDensity(theA, theZ);
// GetDencity() accepts only G4ThreeVector so build it:
// GetDencity() accepts only G4ThreeVector so build it:
G4ThreeVector aPosition(0.0, 0.0, radius);
G4double density = theDencity->GetDensity(aPosition);
delete theDencity;
return coeff_antiproton * density;
*/
@@ -322,26 +324,26 @@ G4double G4RKFieldIntegrator::GetKaonPotential(G4double )
{
/*
//G4double theM = G4NucleiProperties::GetAtomicMass(theA, theZ);
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
+ (theA - theZ) * G4Neutron::Neutron()->GetPDGMass()
+ G4CreateNucleus::GetBindingEnergy(theZ, theA);
const G4double Mk = 496. * MeV; // mass of "kaon"
G4double mu = (theM * Mk)/(theM + Mk);
// kaon's potential coefficient
// V = coeff_kaon * nucleus_density
G4double coeff_kaon = -2.*pi/mu * (1. + Mk/theM) * a_kaon;
G4VNuclearDensity *theDencity;
if(theA < 17) theDencity = new G4NuclearShellModelDensity(theA, theZ);
else theDencity = new G4NuclearFermiDensity(theA, theZ);
// GetDencity() accepts only G4ThreeVector so build it:
// GetDencity() accepts only G4ThreeVector so build it:
G4ThreeVector aPosition(0.0, 0.0, radius);
G4double density = theDencity->GetDensity(aPosition);
delete theDencity;
return coeff_kaon * density;
*/
@@ -352,26 +354,26 @@ G4double G4RKFieldIntegrator::GetPionPotential(G4double )
{
/*
//G4double theM = G4NucleiProperties::GetAtomicMass(theA, theZ);
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
G4double theM = theZ * G4Proton::Proton()->GetPDGMass()
+ (theA - theZ) * G4Neutron::Neutron()->GetPDGMass()
+ G4CreateNucleus::GetBindingEnergy(theZ, theA);
const G4double Mpi = 139. * MeV; // mass of "pion"
G4double mu = (theM * Mpi)/(theM + Mpi);
// pion's potential coefficient
// V = coeff_pion * nucleus_density
G4double coeff_pion = -2.*pi/mu * (1. + Mpi) * a_pion;
G4VNuclearDensity *theDencity;
if(theA < 17) theDencity = new G4NuclearShellModelDensity(theA, theZ);
else theDencity = new G4NuclearFermiDensity(theA, theZ);
// GetDencity() accepts only G4ThreeVector so build it:
// GetDencity() accepts only G4ThreeVector so build it:
G4ThreeVector aPosition(0.0, 0.0, radius);
G4double density = theDencity->GetDensity(aPosition);
delete theDencity;
return coeff_pion * density;
*/