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

Import Geant4 11.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-12-08 10:43:34 +01:00
parent dd1f179cda
commit 860a2b92bf
3962 changed files with 139318 additions and 164259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLBinaryCollisionAvatar.cc
+124 -1
View File
@@ -112,6 +112,13 @@
#include <string>
#include <sstream>
// #include <cassert>
#include "G4INCLNNbarElasticChannel.hh"
#include "G4INCLNNbarCEXChannel.hh"
#include "G4INCLNNbarToLLbarChannel.hh"
#include "G4INCLNNbarToNNbarpiChannel.hh"
#include "G4INCLNNbarToNNbar2piChannel.hh"
#include "G4INCLNNbarToNNbar3piChannel.hh"
#include "G4INCLNNbarToAnnihilationChannel.hh"
namespace G4INCL {
@@ -1233,8 +1240,124 @@ namespace G4INCL {
return new NYElasticChannel(particle1, particle2);
}
}
}
} else if ((particle1->isNucleon() && particle2->isAntiNucleon()) || (particle2->isNucleon() && particle1->isAntiNucleon())) {
//// NNbar
const G4double totCX = CrossSections::total(particle1, particle2);
const G4double NNbElasticCX = CrossSections::NNbarElastic(particle1,particle2);
const G4double NNbCEXCX = CrossSections::NNbarCEX(particle1,particle2);
const G4double NNbToLLbCX = CrossSections::NNbarToLLbar(particle1,particle2);
const G4double NNbToNNbpiCX = CrossSections::NNbarToNNbarpi(particle1,particle2);
const G4double NNbToNNb2piCX = CrossSections::NNbarToNNbar2pi(particle1,particle2);
const G4double NNbToNNb3piCX = CrossSections::NNbarToNNbar3pi(particle1,particle2);
const G4double AnnihilationCX = CrossSections::NNbarToAnnihilation(particle1, particle2);
// assert(std::fabs(totCX-NNbElasticCX-NNbCEXCX-NNbToLLbCX-NNbToNNbpiCX-NNbToNNb2piCX-NNbToNNb3piCX-AnnihilationCX)<0.1);
const G4double rChannel=Random::shoot() * totCX;
if (NNbElasticCX > rChannel) {
// NNbar (elastic) channel is chosen
isElastic = true;
//INCL_WARN("NNbar interaction: NNbarElastic channel chosen" << '\n');
return new NNbarElasticChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX > rChannel) {
// NNbar (CEX) channel is chosen
isElastic = false; // may be charge-exchange also
//INCL_WARN("NNbar interaction: NNbarCEX channel chosen" << '\n');
return new NNbarCEXChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX + NNbToLLbCX > rChannel) {
// NNbarToLLbar channel is chosen
isElastic = false; // may be charge-exchange also
//INCL_WARN("NNbar interaction: NNbarToLLbar channel chosen" << '\n');
return new NNbarToLLbarChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX + NNbToLLbCX + NNbToNNbpiCX > rChannel) {
// NNbar to NNbar pi channel is chosen
isElastic = false;
//INCL_WARN("NNbar interaction: NNbar pi channel chosen" << '\n');
return new NNbarToNNbarpiChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX + NNbToLLbCX + NNbToNNbpiCX + NNbToNNb2piCX > rChannel) {
// NNbar to NNbar 2pi channel is chosen
isElastic = false;
//INCL_WARN("NNbar interaction: NNbar 2pi channel chosen" << '\n');
return new NNbarToNNbar2piChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX + NNbToLLbCX + NNbToNNbpiCX + NNbToNNb2piCX + NNbToNNb3piCX > rChannel) {
// NNbar to NNbar 3pi channel is chosen
isElastic = false;
//INCL_WARN("NNbar interaction: NNbar 3pi channel chosen" << '\n');
return new NNbarToNNbar3piChannel(particle1, particle2);
} else if (NNbElasticCX + NNbCEXCX + NNbToLLbCX + NNbToNNbpiCX + NNbToNNb2piCX + NNbToNNb3piCX +AnnihilationCX > rChannel){
// NNbar annihilation channel is chosen
isElastic = false;
AnnihilationType atype;
if((particle1->getType()==antiProton && particle2->getType()==Proton) || (particle2->getType()==antiProton && particle1->getType()==Proton)){
atype = PTypeInFlight;
}
else if((particle1->getType()==antiProton && particle2->getType()==Neutron) || (particle2->getType()==antiProton && particle1->getType()==Neutron)){
atype = NTypeInFlight;
}
else if((particle1->getType()==antiNeutron && particle2->getType()==Proton) || (particle2->getType()==antiNeutron && particle1->getType()==Proton)){
atype = NbarPTypeInFlight;
}
else if((particle1->getType()==antiNeutron && particle2->getType()==Neutron) || (particle2->getType()==antiNeutron && particle1->getType()==Neutron)){
atype = NbarNTypeInFlight;
}
else{
atype = Def;
INCL_ERROR("Annihilation type problem " << '\n');
}
theNucleus->setAType(atype);
return new NNbarToAnnihilationChannel(theNucleus, particle1, particle2);
} else {
INCL_WARN("Inconsistency within the NNbar Cross Sections (sum != inelastic)" << '\n');
if (NNbToNNb3piCX > 0.0) {
INCL_WARN("Returning an NNbar 3pi channel" << '\n');
isElastic = false;
return new NNbarToNNbar3piChannel(particle1, particle2);
} else if (NNbToNNb2piCX > 0.0) {
INCL_WARN("Returning an NNbar 2pi channel" << '\n');
isElastic = false;
return new NNbarToNNbar2piChannel(particle1, particle2);
} else if (NNbToNNbpiCX > 0.0) {
INCL_WARN("Returning an NNbar pi channel" << '\n');
isElastic = false;
return new NNbarToNNbarpiChannel(particle1, particle2);
} else if (AnnihilationCX > 0.0) {
INCL_WARN("Returning an NNbar annihilation channel" << '\n');
isElastic = false;
AnnihilationType atype;
if((particle1->getType()==antiProton && particle2->getType()==Proton) || (particle2->getType()==antiProton && particle1->getType()==Proton)){
atype = PTypeInFlight;
}
else if((particle1->getType()==antiProton && particle2->getType()==Neutron) || (particle2->getType()==antiProton && particle1->getType()==Neutron)){
atype = NTypeInFlight;
}
else if((particle1->getType()==antiNeutron && particle2->getType()==Proton) || (particle2->getType()==antiNeutron && particle1->getType()==Proton)){
atype = NbarPTypeInFlight;
}
else if((particle1->getType()==antiNeutron && particle2->getType()==Neutron) || (particle2->getType()==antiNeutron && particle1->getType()==Neutron)){
atype = NbarNTypeInFlight;
}
else{
atype = Def;
INCL_ERROR("Annihilation type problem " << '\n');
}
theNucleus->setAType(atype);
return new NNbarToAnnihilationChannel(theNucleus, particle1, particle2);
} else if (NNbCEXCX > 0.0) {
INCL_WARN("Returning an NNbar CEX channel" << '\n');
isElastic = false;
return new NNbarCEXChannel(particle1, particle2);
} else if (NNbToLLbCX > 0.0) {
INCL_WARN("Returning an NNbar LLbar channel" << '\n');
isElastic = false;
return new NNbarToLLbarChannel(particle1, particle2);
} else {
INCL_WARN("Elastic NNbar channel chosen" << '\n');
isElastic = true;
return new NNbarElasticChannel(particle1, particle2);
}
}
}
else {
INCL_DEBUG("BinaryCollisionAvatar can only handle nucleons (for the moment)."
<< '\n'
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCascade.cc
+38 -12
View File
@@ -278,7 +278,7 @@ namespace G4INCL {
theGlobalInfo.geometricCrossSection = 9.7* //normalization factor from Corradini
Math::pi*std::pow((1.840 + 1.120*std::pow(currentA,(1./3.))),2)*
(1. + (Z*G4INCL::PhysicalConstants::eSquared*(currentA+1))/(currentA*kineticEnergy2*(1.840 + 1.120*std::pow(currentA,(1./3.)))));
//xsection formula was borrowed from Corradini et al. https://doi.org/10.1016/j.physletb.2011.09.069
//xsection formula was borrowed from Corradini et al. https://doi.org/10.1016/j.physletb.2011.09.069
}
else{
theGlobalInfo.geometricCrossSection =
@@ -306,7 +306,7 @@ namespace G4INCL {
nucleus = new Nucleus(A, Z, S, theConfig, maxUniverseRadius, theAType);
}
nucleus->getStore()->getBook().reset();
nucleus->initializeParticles();
nucleus->initializeParticles();
propagationModel->setNucleus(nucleus);
return true;
}
@@ -356,13 +356,13 @@ namespace G4INCL {
<< " by the INCL++ model" << G4endl;
G4Exception("G4INCLDataFile::readData()","rawppbarFS.dat, ...", FatalException, ed);
}
G4String dataPath0(std::getenv("G4INCLDATA"));
G4String dataPath0(G4FindDataDir("G4INCLDATA"));
G4String dataPathppbar(dataPath0 + "/rawppbarFS.dat");
G4String dataPathnpbar(dataPath0 + "/rawnpbarFS.dat");
G4String dataPathppbark(dataPath0 + "/rawppbarFSkaonic.dat");
G4String dataPathnpbark(dataPath0 + "/rawnpbarFSkaonic.dat");
#else
G4string path;
G4String path;
if (theConfig) path = theConfig->getINCLXXDataFilePath();
G4String dataPathppbar(path + "/rawppbarFS.dat");
INCL_DEBUG("Reading https://doi.org/10.1016/0375-9474(92)90362-N ppbar final states" << dataPathppbar << '\n');
@@ -390,7 +390,8 @@ namespace G4INCL {
sum = read_file(dataPathppbar, probabilities, particle_types);
rdm = (rdm/(1.-kaonicFSprob))*sum; //99.88 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return theEventInfo;
for (G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++) {
if (particle_types[n][j] == "pi0") {
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
@@ -424,10 +425,18 @@ namespace G4INCL {
starlist.push_back(pp);
} else {
INCL_ERROR("Some non-existing FS particle detected when reading pbar FS files");
for (int jj = 0; jj < static_cast<int>(particle_types[n].size()); jj++) {
for (G4int jj = 0; jj < static_cast<G4int>(particle_types[n].size()); jj++) {
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "gotcha! " << particle_types[n][jj] << G4endl;
#else
std::cout << "gotcha! " << particle_types[n][jj] << std::endl;
#endif
}
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "Some non-existing FS particle detected when reading pbar FS files" << G4endl;
#else
std::cout << "Some non-existing FS particle detected when reading pbar FS files" << std::endl;
#endif
}
}
} else {
@@ -435,7 +444,8 @@ namespace G4INCL {
sum = read_file(dataPathppbark, probabilities, particle_types);
rdm = ((1.-rdm)/kaonicFSprob)*sum; //2670 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return theEventInfo;
for (G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++) {
if (particle_types[n][j] == "pi0") {
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
@@ -466,10 +476,18 @@ namespace G4INCL {
starlist.push_back(p);
} else {
INCL_ERROR("Some non-existing FS particle detected when reading pbar FS files");
for (int jj = 0; jj < static_cast<int>(particle_types[n].size()); jj++) {
for (G4int jj = 0; jj < static_cast<G4int>(particle_types[n].size()); jj++) {
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "gotcha! " << particle_types[n][jj] << G4endl;
#else
std::cout << "gotcha! " << particle_types[n][jj] << std::endl;
#endif
}
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "Some non-existing FS particle detected when reading pbar FS files" << G4endl;
#else
std::cout << "Some non-existing FS particle detected when reading pbar FS files" << std::endl;
#endif
}
}
}
@@ -651,7 +669,7 @@ namespace G4INCL {
// The event bias
theEventInfo.eventBias = (Double_t) Particle::getTotalBias();
// Forced CN?
if(!(projectileSpecies.theType==antiProton && kineticEnergy<=theConfig->getAtrestThreshold())){
if(nucleus->getTryCompoundNucleus()) {
@@ -1193,7 +1211,6 @@ namespace G4INCL {
theGlobalInfo.nEnergyViolationInteraction += theEventInfo.nEnergyViolationInteraction;
}
G4double INCL::read_file(std::string filename, std::vector<G4double>& probabilities,
std::vector<std::vector<G4String>>& particle_types) {
std::ifstream file(filename);
@@ -1214,7 +1231,11 @@ namespace G4INCL {
particle_types.push_back(types);
}
} else {
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "ERROR no fread_file " << filename << G4endl;
#else
std::cout << "ERROR no fread_file " << filename << std::endl;
#endif
}
return sum_probs;
}
@@ -1225,17 +1246,22 @@ namespace G4INCL {
G4double smallestsum = 0.0;
G4double biggestsum = yields[0];
//G4cout << "initial input " << rdm << G4endl;
for (G4int i = 0; i < static_cast<G4int>(yields.size()); i++) {
for (G4int i = 0; i < static_cast<G4int>(yields.size()-1); i++) {
if (rdm >= smallestsum && rdm <= biggestsum) {
//G4cout << smallestsum << " and " << biggestsum << G4endl;
stringNumber = i;
stringNumber = i+1;
}
smallestsum += yields[i];
biggestsum += yields[i+1];
}
if(stringNumber==-1) stringNumber = static_cast<G4int>(yields.size());
if(stringNumber==-1){
INCL_ERROR("ERROR in findStringNumber (stringNumber=-1)");
#ifdef INCLXX_IN_GEANT4_MODE
G4cout << "ERROR in findStringNumber" << G4endl;
#else
std::cout << "ERROR in findStringNumber" << std::endl;
#endif
}
return stringNumber;
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCrossSections.cc
+28 -1
View File
@@ -44,6 +44,7 @@
#include "G4INCLCrossSectionsTruncatedMultiPions.hh"
#include "G4INCLCrossSectionsMultiPionsAndResonances.hh"
#include "G4INCLCrossSectionsStrangeness.hh"
#include "G4INCLCrossSectionsAntiparticles.hh"
// #include <cassert>
namespace G4INCL {
@@ -287,7 +288,31 @@ namespace G4INCL {
G4double NKbToLpi(Particle const * const p1, Particle const * const p2) {
return theCrossSections->NKbToLpi(p1,p2);
}
G4double NNbarElastic(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarElastic(p1,p2);
}
G4double NNbarCEX(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarCEX(p1,p2);
}
G4double NNbarToLLbar(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarToLLbar(p1,p2);
}
G4double NNbarToNNbarpi(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarToNNbarpi(p1,p2);
}
G4double NNbarToNNbar2pi(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarToNNbar2pi(p1,p2);
}
G4double NNbarToNNbar3pi(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarToNNbar3pi(p1,p2);
}
G4double NNbarToAnnihilation(Particle const* const p1, Particle const* const p2){
return theCrossSections->NNbarToAnnihilation(p1,p2);
}
G4double NKbToS2pi(Particle const * const p1, Particle const * const p2) {
return theCrossSections->NKbToS2pi(p1,p2);
}
@@ -483,6 +508,8 @@ namespace G4INCL {
setCrossSections(new CrossSectionsMultiPionsAndResonances);
else if(crossSections == StrangenessCrossSections)
setCrossSections(new CrossSectionsStrangeness);
else if(crossSections == AntiparticlesCrossSections)
setCrossSections(new CrossSectionsAntiparticles);
}
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCrossSectionsAntiparticles.cc
+597
View File
@@ -0,0 +1,597 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
/** \file G4INCLCrossSectionsAntiparticles.cc
* \brief Multipion, mesonic Resonances, strange cross sections and antinucleon as projectile
*
* \date 31st March 2023
* \author Demid Zharenov
*/
#include "G4INCLCrossSectionsAntiparticles.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLParticleTable.hh"
// #include <cassert>
namespace G4INCL {
template<G4int N>
struct BystrickyEvaluator {
static G4double eval(const G4double pLab, const G4double oneOverThreshold, HornerCoefficients<N> const &coeffs) {
const G4double pMeV = pLab*1E3;
const G4double ekin=std::sqrt(ParticleTable::effectiveNucleonMass2+pMeV*pMeV)-ParticleTable::effectiveNucleonMass;
const G4double xrat=ekin*oneOverThreshold;
const G4double x=std::log(xrat);
return HornerEvaluator<N>::eval(x, coeffs) * x * std::exp(-0.5*x);
}
};
const G4int CrossSectionsAntiparticles::nMaxPiNN = 4;
const G4int CrossSectionsAntiparticles::nMaxPiPiN = 4;
CrossSectionsAntiparticles::CrossSectionsAntiparticles() :
s11pzHC(-2.228000000000294018,8.7560000000005723725,-0.61000000000023239325,-5.4139999999999780324,3.3338333333333348023,-0.75835000000000022049,0.060623611111111114688),
s01ppHC(2.0570000000126518344,-6.029000000012135826,36.768500000002462784,-45.275666666666553533,25.112666666666611953,-7.2174166666666639187,1.0478875000000000275,-0.060804365079365080846),
s01pzHC(0.18030000000000441851,7.8700999999999953598,-4.0548999999999990425,0.555199999999999959),
s11pmHC(0.20590000000000031866,3.3450999999999993936,-1.4401999999999997825,0.17076666666666664973),
s12pmHC(-0.77235999999999901328,4.2626599999999991117,-1.9008899999999997323,0.30192266666666663379,-0.012270833333333331986),
s12ppHC(-0.75724999999999975664,2.0934399999999998565,-0.3803099999999999814),
s12zzHC(-0.89599999999996965072,7.882999999999978632,-7.1049999999999961928,1.884333333333333089),
s02pzHC(-1.0579999999999967036,11.113999999999994089,-8.5259999999999990196,2.0051666666666666525),
s02pmHC(2.4009000000012553286,-7.7680000000013376183,20.619000000000433505,-16.429666666666723928,5.2525708333333363472,-0.58969166666666670206),
s12mzHC(-0.21858699999999976269,1.9148999999999999722,-0.31727500000000001065,-0.027695000000000000486)
{
}
/// \brief redefining previous cross sections
G4double CrossSectionsAntiparticles::total(Particle const * const p1, Particle const * const p2) {
G4double inelastic;
if ((p1->isNucleon() && p2->isAntiNucleon()) || (p1->isAntiNucleon() && p2->isNucleon()))
inelastic = NNbarCEX(p1, p2) + NNbarToNNbarpi(p1, p2) + NNbarToNNbar2pi(p1, p2) + NNbarToNNbar3pi(p1, p2) + NNbarToAnnihilation(p1, p2) + NNbarToLLbar(p1, p2);
else if(p1->isNucleon() && p2->isNucleon()) {
return CrossSectionsMultiPions::NNTot(p1, p2);
} else if((p1->isNucleon() && p2->isDelta()) ||
(p1->isDelta() && p2->isNucleon())) {
inelastic = CrossSectionsMultiPions::NDeltaToNN(p1, p2) + NDeltaToNLK(p1, p2) + NDeltaToNSK(p1, p2) + NDeltaToDeltaLK(p1, p2) + NDeltaToDeltaSK(p1, p2) + NDeltaToNNKKb(p1, p2);
} else if((p1->isNucleon() && p2->isPion()) ||
(p1->isPion() && p2->isNucleon())) {
return CrossSectionsMultiPions::piNTot(p1,p2);
} else if((p1->isNucleon() && p2->isEta()) ||
(p1->isEta() && p2->isNucleon())) {
inelastic = CrossSectionsMultiPionsAndResonances::etaNToPiN(p1,p2) + CrossSectionsMultiPionsAndResonances::etaNToPiPiN(p1,p2);
} else if((p1->isNucleon() && p2->isOmega()) ||
(p1->isOmega() && p2->isNucleon())) {
inelastic = CrossSectionsMultiPionsAndResonances::omegaNInelastic(p1,p2);
} else if((p1->isNucleon() && p2->isEtaPrime()) ||
(p1->isEtaPrime() && p2->isNucleon())) {
inelastic = CrossSectionsMultiPionsAndResonances::etaPrimeNToPiN(p1,p2);
} else if((p1->isNucleon() && p2->isLambda()) ||
(p1->isLambda() && p2->isNucleon())) {
inelastic = CrossSectionsStrangeness::NLToNS(p1,p2);
} else if((p1->isNucleon() && p2->isSigma()) ||
(p1->isSigma() && p2->isNucleon())) {
inelastic = CrossSectionsStrangeness::NSToNL(p1,p2) + CrossSectionsStrangeness::NSToNS(p1,p2);
} else if((p1->isNucleon() && p2->isKaon()) ||
(p1->isKaon() && p2->isNucleon())) {
inelastic = CrossSectionsStrangeness::NKToNK(p1,p2) + CrossSectionsStrangeness::NKToNKpi(p1,p2) + CrossSectionsStrangeness::NKToNK2pi(p1,p2);
} else if((p1->isNucleon() && p2->isAntiKaon()) ||
(p1->isAntiKaon() && p2->isNucleon())) {
inelastic = CrossSectionsStrangeness::NKbToLpi(p1,p2)
+ CrossSectionsStrangeness::NKbToSpi(p1,p2) + CrossSectionsStrangeness::NKbToL2pi(p1,p2)
+ CrossSectionsStrangeness::NKbToS2pi(p1,p2) + CrossSectionsStrangeness::NKbToNKb(p1,p2)
+ CrossSectionsStrangeness::NKbToNKbpi(p1,p2) + CrossSectionsStrangeness::NKbToNKb2pi(p1,p2);
} else {
inelastic = 0.;
}
return inelastic + elastic(p1, p2);
}
// without NNbar!
G4double CrossSectionsAntiparticles::elastic(Particle const * const p1, Particle const * const p2) {
if ((p1->isNucleon() && p2->isAntiNucleon()) || (p1->isAntiNucleon() && p2->isNucleon()))
return NNbarElastic(p1, p2);
if((p1->isNucleon()||p1->isDelta()) && (p2->isNucleon()||p2->isDelta())){ // N-N, N-Delta, Delta-Delta
return CrossSectionsMultiPions::elastic(p1, p2);
}
else if ((p1->isNucleon() && p2->isPion()) || (p2->isNucleon() && p1->isPion())){
return CrossSectionsMultiPions::elastic(p1, p2);
}
else if ((p1->isNucleon() && p2->isEta()) || (p2->isNucleon() && p1->isEta())){
return CrossSectionsMultiPionsAndResonances::etaNElastic(p1, p2);
}
else if ((p1->isNucleon() && p2->isHyperon()) || (p2->isNucleon() && p1->isHyperon())){
return CrossSectionsStrangeness::NYelastic(p1, p2);
}
else if ((p1->isNucleon() && p2->isKaon()) || (p2->isNucleon() && p1->isKaon())){
return CrossSectionsStrangeness::NKelastic(p1, p2);
}
else if ((p1->isNucleon() && p2->isAntiKaon()) || (p2->isNucleon() && p1->isAntiKaon())){
return CrossSectionsStrangeness::NKbelastic(p1, p2);
}
else {
return 0.0;
}
}
G4double CrossSectionsAntiparticles::NNbarCEX(Particle const * const p1, Particle const * const p2) {
//brief ppbar
// p pbar -> n nbar (BFMM 204)
//
//brief nnbar
// n nbar -> p pbar (same as BFMM 204, but no threshold)
//
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM204 = {7.549, -0.041, -2.959, -6.835, 1.629, 0.114};
//{6.875, 0.590, -0.003, -6.629, 1.532, 0.114}
//const G4double Eth_PPbar_NNbar = 0.114;
const std::vector<G4double> BFMM204nn = {7.549, -0.041, -2.959, -6.835, 1.629};
//const G4double Eth_NNbar_PPbar = 0.0;
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ //npbar or pnbar
sigma = 0.0;
return sigma;
}
else{ // ppbar or nnbar
if(p1->getType()==antiProton || p1->getType()==Proton)
sigma = KinematicsUtils::compute_xs(BFMM204, pLab); // ppbar case
else
sigma = KinematicsUtils::compute_xs(BFMM204nn, pLab); // nnbar case
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarElastic(Particle const * const p1, Particle const * const p2) {
//brief ppbar
// p pbar -> p pbar (BFMM 2)
//
//brief npbar
// n pbar -> n pbar (BFMM 472)
//
//brief nnbar
// n nbar -> n nbar (same as BFMM 2)
//
//brief pnbar
// p nbar -> p nbar (same as BFMM 472)
//
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM2 = {110.496, -65.605, -0.198, -34.813, 4.317};
//elastic ppbar;
const std::vector<G4double> BFMM472 = {14.625, 23.413, -0.288, -9.002, 1.084};
//elastic pnbar;
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ //npbar or pnbar
sigma = KinematicsUtils::compute_xs(BFMM472, pLab);
return sigma;
}
else{ // ppbar or nnbar
if(p1->getType()==antiProton || p1->getType()==Proton)
sigma = KinematicsUtils::compute_xs(BFMM2, pLab); // ppbar case
else
sigma = KinematicsUtils::compute_xs(BFMM2, pLab); // nnbar case
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarToLLbar(Particle const * const p1, Particle const * const p2) {
// this channel includes all states with lambdas, sigmas and xis and their antiparticles
//brief ppbar
// p pbar -> l lbar (BFMM 121)
// ppbar -> l lbar pi0 (BFMM 113)
// ppbar -> splus pim lbar || sminusbar pim l (BFMM 136)
// ppbar -> sminus pip lbar || splusbar l pip (BFMM 146)
// ppbar -> sp spbar (BFMM 139)
// ppbar -> sm smbar (BFMM 149)
// ppbar -> szero szerobar (BFMM 144)
// ppbar -> ximinus ximinusbar (BFMM 101)
// ppbar -> szero lbar || szerobar l (BFMM 143)
//
//
//brief npbar
// n pbar -> l lbar pi- (BFMM 487)
// n pbar -> l sbarplus || lbar sminus (BFMM 488)
//
//
//brief nnbar
// all same as for ppbar
//
//
//brief pnbar
// p nbar -> l lbar pi+ (same as BFMM 487)
// p nbar -> l sbarminus || lbar splus (same as BFMM 488)
//
const std::vector<G4double> BFMM121 = {2.379, -2.738, -1.260, -1.915, 0.430, 1.437};
//const G4double Eth_PPbar_LLbar = 1.437;
const std::vector<G4double> BFMM113 = {-0.105, 0.000, -5.099, 0.188, -0.050, 1.820};
//const G4double Eth_PPbar_LLbar_pi0 = 1.820;
const std::vector<G4double> BFMM139 = {0.142, -0.291, -1.702, -0.058, 0.001, 1.851};
//const G4double Eth_PPbar_SpSpbar = 1.851;
const std::vector<G4double> BFMM149 = {1.855, -2.238, -1.002, -1.279, 0.252, 1.896};
//const G4double Eth_PPbar_SmSmbar = 1.896;
const std::vector<G4double> BFMM136 = {1.749, -2.506, -1.222, -1.262, 0.274, 2.042};
//const G4double Eth_PPbar_SpLbar_pim = 2.042;
const std::vector<G4double> BFMM146 = {1.037, -1.437, -1.155, -0.709, 0.138, 2.065};
//const G4double Eth_PPbar_SmLbar_pip = 2.065;
const std::vector<G4double> BFMM143 = {0.652, -1.006, -1.805, -0.537, 0.121, 1.653};
//const G4double Eth_PPbar_Szero_Lbar = 1.653;
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
//fixed due to limited data
G4double BFMM144;
if(pLab > 1.868) BFMM144 = 0.008; //sigmazero sigmazerobar
else BFMM144 = 0.0;
G4double BFMM101;
if(pLab > 1.868) BFMM101 = 0.002; //xizero xizerobar
else BFMM101 = 0.0;
// npbar cross sections (fixed due to limited data)
G4double BFMM487;
if(pLab > 2.1) BFMM487 = 0.048; //llbar piminus
else BFMM487 = 0.0;
G4double BFMM488;
if(pLab > 2.0) BFMM488 = 0.139; //lsigmaminus +cc
else BFMM488 = 0.0;
if(iso == 2 || iso == -2){ //npbar or pnbar
sigma = BFMM487 + BFMM488;
return sigma;
}
else{ // ppbar or nnbar
sigma = KinematicsUtils::compute_xs(BFMM113, pLab)
+KinematicsUtils::compute_xs(BFMM139, pLab) +KinematicsUtils::compute_xs(BFMM136, pLab)
+KinematicsUtils::compute_xs(BFMM146, pLab)+KinematicsUtils::compute_xs(BFMM143, pLab)
+KinematicsUtils::compute_xs(BFMM121, pLab)+KinematicsUtils::compute_xs(BFMM149, pLab)
+BFMM144 +BFMM101; // nnbar case totally same as ppbar
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarToNNbarpi(Particle const * const p1, Particle const * const p2) {
//brief ppbar
// p pbar -> p pbar pi0 (BFMM 185)
// p pbar -> p nbar pi- (BFMM 188)
// p pbar -> n pbar pi+ (BFMM 199)
// p pbar -> n nbar pi0 (no data)
//
//brief npbar
// n pbar -> p pbar pi- (BFMM 491)
// n pbar -> p nbar pion (impossible)
// n pbar -> n pbar pi0 (BFMM 495)
// n pbar -> n nbar pi- (same as BFMM 188)
//
//brief nnbar
// n nbar -> n nbar pi0 (same as BFMM 185)
// n nbar -> p nbar pi- (same as BFMM 188)
// n nbar -> n pbar pi+ (same as BFMM 199)
// n nbar -> p pbar pi0 (no data)
//
//brief pnbar
// p nbar -> p pbar pi+ (same as BFMM 491)
// p nbar -> n pbar pion (impossible)
// p nbar -> p nbar pi0 (BFMM 495)
// p nbar -> n nbar pi- (same as BFMM 188)
//
//
// BFMM 188,199 are very close in value, 491 is larger
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM185 = {-0.734, 0.841, 0.905, 3.415, -2.316, 0.775};
//{22.781, -22.602, -0.752, -11.036, 1.548, 0.775}
//const G4double Eth_PPbar_PPbar_pi0 = 0.775;
const std::vector<G4double> BFMM188 = { -0.442, 0.501, 0.002, 3.434, -1.201, 0.798};
//const G4double Eth_PPbar_PNbar_pim = 0.798;
const std::vector<G4double> BFMM199 = {-2.025, 2.055, -2.355, 6.064, -2.004, 0.798};
//const G4double Eth_PPbar_NPbar_pip = 0.798;
const std::vector<G4double> BFMM491 = {24.125, -20.669, -1.534, -19.573, 4.493, 0.787};
//const G4double Eth_NPbar_PPbar_pim = 0.787;
const std::vector<G4double> BFMM495 = {-0.650, -0.140, -0.058, 5.166, -1.705, 0.777};
//const G4double Eth_NPbar_NPbar_pi0 = 0.777;
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ //npbar or pnbar
sigma = KinematicsUtils::compute_xs(BFMM491, pLab) + KinematicsUtils::compute_xs(BFMM185, pLab) + KinematicsUtils::compute_xs(BFMM188, pLab);
return sigma;
}
else{ // ppbar or nnbar
sigma = KinematicsUtils::compute_xs(BFMM199, pLab) + KinematicsUtils::compute_xs(BFMM185, pLab) + KinematicsUtils::compute_xs(BFMM188, pLab);
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarToNNbar2pi(Particle const * const p1, Particle const * const p2) {
//brief ppbar
// p pbar -> p pbar pi+ pi- (BFMM 167)
// p pbar -> p nbar pi- pi0 (same as BFMM 490)
// p pbar -> n pbar pi+ pi0 (same as BFMM 490)
// p pbar -> n nbar pi+ pi- (BFMM 198)
//
//brief npbar
// n pbar -> p pbar pi- pi0 (BFMM 490)
// n pbar -> p nbar pi- pi- (BFMM 492)
// n pbar -> n pbar pi+ pi- (BFMM 494)
// n pbar -> n nbar pi- pi0 (same as BFMM 490)
//
//brief nnbar
// n nbar -> n nbar pi+ pi- (same as BFMM 167)
// n nbar -> p nbar pi- pi0 (same as BFMM 490)
// n nbar -> n pbar pi+ pi0 (same as BFMM 490)
// n nbar -> p pbar pi+ pi- (same as BFMM 198)
//
//brief pnbar
// p nbar -> p pbar pi+ pi0 (same as BFMM 490)
// p nbar -> n pbar pi+ pi+ (same as BFMM 492)
// p nbar -> p nbar pi+ pi- (same as BFMM 494)
// p nbar -> n nbar pi+ pi0 (same as BFMM 490)
//
//
// BFMM 188,199 are very close in value, 491 is larger
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM167 = {-6.885, 0.476, 1.206, 13.857, -5.728, 1.220};
//const G4double Eth_PPbar_PPbar_pip_pim = 1.220;
const std::vector<G4double> BFMM198 = {1.857, -21.213, -3.448, 0.827, -0.390, 1.231};
//const G4double Eth_PPbar_NNbar_pip_pim = 1.231;
const std::vector<G4double> BFMM490 = {-3.594, 0.811, 0.306, 5.108, -1.625, 1.201};
//const G4double Eth_PNbar_PPbar_pim_pi0 = 1.201;
const std::vector<G4double> BFMM492 = {-5.443, 7.254, -2.936, 8.441, -2.588, 1.221};
//const G4double Eth_PNbar_NPbar_pim_pim = 1.221;
const std::vector<G4double> BFMM494 = {21.688, -38.709, -2.062, -17.783, 3.895, 1.221};
//const G4double Eth_NPbar_NPbar_pip_pim = 1.221;
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ // pnbar or npbar
sigma = KinematicsUtils::compute_xs(BFMM490, pLab) + KinematicsUtils::compute_xs(BFMM490, pLab) + KinematicsUtils::compute_xs(BFMM167, pLab) + KinematicsUtils::compute_xs(BFMM198, pLab);
return sigma;
}
else{ // ppbar or nnbar
sigma = KinematicsUtils::compute_xs(BFMM490, pLab) + KinematicsUtils::compute_xs(BFMM490, pLab) + KinematicsUtils::compute_xs(BFMM492, pLab) + KinematicsUtils::compute_xs(BFMM494, pLab);
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarToNNbar3pi(Particle const * const p1, Particle const * const p2) {
//brief ppbar
// p pbar -> p pbar pi+ pi- pi0 (BFMM 161)
// p pbar -> p nbar 2pi- pi+ (BFMM 169)
// p pbar -> n pbar 2pi+ pi- (BFMM 201)
// p pbar -> n nbar pi+ pi- pi0 (BFMM 197)
//
//brief npbar
// n pbar -> p pbar 2pi- pi+ (same as BFMM 169)
// n pbar -> p nbar 2pi- pi0 (same as BFMM 197)
// n pbar -> n pbar pi+ pi- pi0 (same as BFMM 161)
// n pbar -> n nbar 2pi- pi+ (same as BFMM 169)
//
//brief nnbar
// n nbar -> n nbar pi+ pi- pi0 (same as BFMM 161)
// n nbar -> p nbar 2pi- pi+ (same as BFMM 169)
// n nbar -> n pbar 2pi+ pi- (same as BFMM 201)
// n nbar -> p pbar pi+ pi- pi0 (same as BFMM 197)
//
//brief pnbar
// p nbar -> p pbar 2pi+ pi- (same as BFMM 169)
// p nbar -> n pbar 2pi+ pi0 (same as BFMM 197)
// p nbar -> p nbar pi+ pi- pi0 (same as BFMM 161)
// p nbar -> n nbar 2pi+ pi- (same as BFMM 169)
//
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM161 = {-6.434, 1.351, -5.185, 7.754, -1.692, 1.604};
//const G4double Eth_PPbar_PPbar_pip_pim_pi0 = 1.604;
const std::vector<G4double> BFMM169 = {3.696, -5.356, -0.053, 1.941, -0.432, 1.624};
//const G4double Eth_PPbar_PNbar_2pim_pip = 1.624;
const std::vector<G4double> BFMM201 = {-1.070, -0.636, -0.009, 2.335, -0.499, 1.624};
//const G4double Eth_PPbar_NPbar_2pip_pim = 1.624;
const std::vector<G4double> BFMM197 = {1.857, -21.213, -3.448, 0.827, -0.390, 1.616};
//const G4double Eth_PPbar_NNbar_pip_pim_pi0 = 1.616;
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ // pnbar or npbar
sigma = KinematicsUtils::compute_xs(BFMM169, pLab) + KinematicsUtils::compute_xs(BFMM169, pLab) + KinematicsUtils::compute_xs(BFMM197, pLab) + KinematicsUtils::compute_xs(BFMM161, pLab);
return sigma;
}
else{ // ppbar or nnbar
sigma = KinematicsUtils::compute_xs(BFMM161, pLab) + KinematicsUtils::compute_xs(BFMM169, pLab) + KinematicsUtils::compute_xs(BFMM197, pLab) + KinematicsUtils::compute_xs(BFMM201, pLab);
return sigma;
}
}
G4double CrossSectionsAntiparticles::NNbarToAnnihilation(Particle const * const p1, Particle const * const p2) {
//brief ppbar
/*
This part only contains total annihilation xs, the choice of a particular final state
will be done in the channel file.
As long as we only have good data for ppbar, we assume that for npbar, pnbar and nnbar the xs
will be the same, but in order to compensate for the Coulombic effect the ppbar annihilation xs
is multiplied by the pnbar total xs and divided by the ppbar total xs.
*/
// assert((p1->isAntiNucleon() && p2->isNucleon()) || (p1->isNucleon() && p2->isAntiNucleon()));
G4double sigma=0.;
const G4int iso=ParticleTable::getIsospin(p1->getType()) + ParticleTable::getIsospin(p2->getType());
// iso == 2 || iso == -2 (n pbar or p nbar)
const std::vector<G4double> BFMM6 = {66.098, 0.153, -4.576, -38.319, 6.625}; //ppbar annihilation xs
const std::vector<G4double> BFMM1 = {119.066, 6.251, -0.006, -60.046, 11.958}; //ppbar total xs
const std::vector<G4double> BFMM471 = {108.104, 15.708, 0.832, -54.632, -6.958}; //npbar total xs
const Particle *antinucleon;
const Particle *nucleon;
if (p1->isAntiNucleon()) {
antinucleon = p1;
nucleon = p2;
}
else {
antinucleon = p2;
nucleon = p1;
}
const G4double pLab = 0.001*KinematicsUtils::momentumInLab(antinucleon, nucleon); // GeV
if(iso == 2 || iso == -2){ // pnbar or npbar
sigma = KinematicsUtils::compute_xs(BFMM6, pLab)*KinematicsUtils::compute_xs(BFMM471, pLab)/KinematicsUtils::compute_xs(BFMM1, pLab);
return sigma;
}
else if(p1->getType()==antiProton || p2->getType()==Proton){ // ppbar case
sigma = KinematicsUtils::compute_xs(BFMM6, pLab);
return sigma;
}
else{ // nnbar case
sigma = KinematicsUtils::compute_xs(BFMM6, pLab)*KinematicsUtils::compute_xs(BFMM471, pLab)/KinematicsUtils::compute_xs(BFMM1, pLab);
return sigma;
}
}
} // namespace G4INCL
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCrossSectionsINCL46.cc
+49 -1
View File
@@ -736,6 +736,54 @@ namespace G4INCL {
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarElastic(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarCEX(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon charge exchange cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarToLLbar(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Lambda-AntiLambda cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarToNNbarpi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 1 pion cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarToNNbar2pi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 2 pions cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarToNNbar3pi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 3 pions cross sections
//
return 0.;
}
G4double CrossSectionsINCL46::NNbarToAnnihilation(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon total annihilation cross sections
//
return 0.;
}
} // namespace G4INCL
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCrossSectionsMultiPions.cc
+47 -2
View File
@@ -1563,7 +1563,7 @@ namespace G4INCL {
//
return 0.;
}
G4double CrossSectionsMultiPions::NKbToS2pi(Particle const * const, Particle const * const) {
//
// Nucleon-antiKaon producing Sigma-2pion cross sections
@@ -1591,9 +1591,54 @@ namespace G4INCL {
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarElastic(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarCEX(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon charge exchange cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarToLLbar(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Lambda-AntiLambda cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarToNNbarpi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 1 pion cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarToNNbar2pi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 2 pions cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarToNNbar3pi(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon to Nucleon-AntiNucleon + 3 pions cross sections
//
return 0.;
}
G4double CrossSectionsMultiPions::NNbarToAnnihilation(Particle const* const, Particle const* const){
//
// Nucleon-AntiNucleon total annihilation cross sections
//
return 0.;
}
} // namespace G4INCL
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLEtaNElasticChannel.cc
+4 -4
View File
@@ -189,10 +189,10 @@ namespace G4INCL {
fi=(2.0*pi)*Random::shoot();
ThreeVector mom_nucleon1(
pn*std::sin(teta)*std::cos(fi),
pn*std::sin(teta)*std::sin(fi),
pn*std::cos(teta)
);
pn*std::sin(teta)*std::cos(fi),
pn*std::sin(teta)*std::sin(fi),
pn*std::cos(teta)
);
mom_nucleon = -mom_nucleon1 ;
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLInteractionAvatar.cc
+36 -21
View File
@@ -53,6 +53,7 @@
#include "G4INCLRootFinder.hh"
#include "G4INCLLogger.hh"
#include "G4INCLConfigEnums.hh"
#include "G4INCLConfig.hh"
// #include <cassert>
namespace G4INCL {
@@ -113,7 +114,7 @@ namespace G4INCL {
}
void InteractionAvatar::preInteractionLocalEnergy(Particle * const p) {
if(!theNucleus || p->isMeson()) return; // Local energy does not make any sense without a nucleus
if(!theNucleus || p->isMeson() || p->isPhoton() || p->isAntiNucleon()) return; // Local energy does not make any sense without a nucleus
if(shouldUseLocalEnergy())
KinematicsUtils::transformToLocalEnergyFrame(theNucleus, p);
@@ -346,6 +347,10 @@ namespace G4INCL {
G4bool InteractionAvatar::shouldUseLocalEnergy() const {
if(!theNucleus) return false;
LocalEnergyType theLocalEnergyType;
if(theNucleus->getStore()->getConfig()->getProjectileType()==antiProton ||
theNucleus->getStore()->getConfig()->getProjectileType()==antiNeutron){
return false;
}
if(getType()==DecayAvatarType || isPiN)
theLocalEnergyType = theNucleus->getStore()->getConfig()->getLocalEnergyPiType();
else
@@ -363,12 +368,22 @@ namespace G4INCL {
if(manyBodyFinalState)
violationEFunctor = new ViolationEMomentumFunctor(theNucleus, modifiedAndCreated, fs->getTotalEnergyBeforeInteraction(), boostVector, shouldUseLocalEnergy());
else {
Particle * const p = modified.front();
// The following condition is necessary for the functor to work
// correctly. A similar condition exists in INCL4.6.
if(p->getMass() < ParticleTable::minDeltaMass)
return false;
violationEFunctor = new ViolationEEnergyFunctor(theNucleus, p, fs->getTotalEnergyBeforeInteraction(), shouldUseLocalEnergy());
if (modified.empty()) {
Particle * const p1 = created.front(); //we destroy all nucleons during annihilation in NNbar case
// The following condition is necessary for the functor to work
// correctly. A similar condition exists in INCL4.6.
if(p1->getMass() < ParticleTable::minDeltaMass)
return false;
violationEFunctor = new ViolationEEnergyFunctor(theNucleus, p1, fs->getTotalEnergyBeforeInteraction(), shouldUseLocalEnergy());
}
else{
Particle * const p2 = modified.front(); // normal situation
// The following condition is necessary for the functor to work
// correctly. A similar condition exists in INCL4.6.
if(p2->getMass() < ParticleTable::minDeltaMass)
return false;
violationEFunctor = new ViolationEEnergyFunctor(theNucleus, p2, fs->getTotalEnergyBeforeInteraction(), shouldUseLocalEnergy());
}
}
// Apply the root-finding algorithm
@@ -433,14 +448,14 @@ namespace G4INCL {
}
//jcd if(shouldUseLocalEnergy && !(*i)->isPion()) { // This translates AECSVT's loops 1, 3 and 4
if(shouldUseLocalEnergy && !(*i)->isPion() && !(*i)->isEta() && !(*i)->isOmega() &&
!(*i)->isKaon() && !(*i)->isAntiKaon() && !(*i)->isSigma() && !(*i)->isPhoton() && !(*i)->isLambda()) { // This translates AECSVT's loops 1, 3 and 4
if(shouldUseLocalEnergy && !(*i)->isPion() && !(*i)->isEta() && !(*i)->isOmega() &&
!(*i)->isKaon() && !(*i)->isAntiKaon() && !(*i)->isSigma() && !(*i)->isPhoton() && !(*i)->isLambda() && !(*i)->isAntiNucleon()) { // This translates AECSVT's loops 1, 3 and 4
// assert(theNucleus); // Local energy without a nucleus doesn't make sense
const G4double energy = (*i)->getEnergy(); // Store the energy of the particle
G4double locE = KinematicsUtils::getLocalEnergy(theNucleus, *i); // Initial value of local energy
G4double locEOld;
G4double deltaLocE = InteractionAvatar::locEAccuracy + 1E3;
for(G4int iterLocE=0;
const G4double energy = (*i)->getEnergy(); // Store the energy of the particle
G4double locE = KinematicsUtils::getLocalEnergy(theNucleus, *i); // Initial value of local energy
G4double locEOld;
G4double deltaLocE = InteractionAvatar::locEAccuracy + 1E3;
for(G4int iterLocE=0;
deltaLocE>InteractionAvatar::locEAccuracy && iterLocE<InteractionAvatar::maxIterLocE;
++iterLocE) {
locEOld = locE;
@@ -453,13 +468,13 @@ namespace G4INCL {
}
//jlrs For lambdas and nuclei with masses higher than 19 also local energy
if(shouldUseLocalEnergy && (*i)->isLambda() && theNucleus->getA()>19) {
if(shouldUseLocalEnergy && (*i)->isLambda() && theNucleus->getA()>19) {
// assert(theNucleus); // Local energy without a nucleus doesn't make sense
const G4double energy = (*i)->getEnergy(); // Store the energy of the particle
G4double locE = KinematicsUtils::getLocalEnergy(theNucleus, *i); // Initial value of local energy
G4double locEOld;
G4double deltaLocE = InteractionAvatar::locEAccuracy + 1E3;
for(G4int iterLocE=0;
const G4double energy = (*i)->getEnergy(); // Store the energy of the particle
G4double locE = KinematicsUtils::getLocalEnergy(theNucleus, *i); // Initial value of local energy
G4double locEOld;
G4double deltaLocE = InteractionAvatar::locEAccuracy + 1E3;
for(G4int iterLocE=0;
deltaLocE>InteractionAvatar::locEAccuracy && iterLocE<InteractionAvatar::maxIterLocE;
++iterLocE) {
locEOld = locE;
@@ -468,8 +483,8 @@ namespace G4INCL {
theNucleus->updatePotentialEnergy(*i); // ...update its potential energy...
locE = KinematicsUtils::getLocalEnergy(theNucleus, *i); // ...and recompute locE.
deltaLocE = std::abs(locE-locEOld);
}
}
}
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLKinematicsUtils.cc
+31 -4
View File
@@ -42,8 +42,36 @@ namespace G4INCL {
namespace KinematicsUtils {
G4double fiveParFit (const G4double a, const G4double b, const G4double c, const G4double d, const G4double e, const G4double x){
return a+b*std::pow(x, c)+d*std::log(x)+e*std::log(x)*std::log(x);
}
G4double compute_xs(const std::vector<G4double> coefficients, const G4double pLab){
G4double sigma = 0.;
G4double Ethreshold = 0.0;
if(coefficients.size() == 6){
Ethreshold = coefficients[5];
if(Ethreshold >= 5){ //there are no Ethreshold even close to 5 GeV.
if(pLab > Ethreshold){ // E is E cutoff, not threshold, we use it when sigma should be zero.
return 0.;
}
}
else{
if(pLab < Ethreshold){
return 0.;
}
}
}
sigma = fiveParFit(coefficients[0],coefficients[1],coefficients[2],coefficients[3],coefficients[4], pLab);
if(sigma < 0.){
return 0.;
};
return sigma;
}
void transformToLocalEnergyFrame(Nucleus const * const n, Particle * const p) {
// assert(!p->isMeson() && !p->isPhoton()); // No local energy for mesons //D nor for photons!
// assert(!p->isMeson() && !p->isPhoton() && !p->isAntiNucleon()); // No local energy for mesons //D nor for photons!
const G4double localEnergy = getLocalEnergy(n, p);
const G4double localTotalEnergy = p->getEnergy() - localEnergy;
p->setEnergy(localTotalEnergy);
@@ -51,8 +79,7 @@ namespace G4INCL {
}
G4double getLocalEnergy(Nucleus const * const n, Particle * const p) {
// assert(!p->isMeson() && !p->isPhoton()); // No local energy for mesons //D photons are bad too!
// assert(!p->isMeson() && !p->isPhoton() && !p->isAntiNucleon()); // No local energy for mesons //D photons are bad too!
G4double vloc = 0.0;
const G4double r = p->getPosition().mag();
const G4double mass = p->getMass();
@@ -74,7 +101,7 @@ namespace G4INCL {
} else {
const G4double tf0 = p->getPotentialEnergy() - n->getPotential()->getSeparationEnergy(p);
if(tf0<0.0) return 0.0;
pfl0 = std::sqrt(tf0*(tf0 + 2.0*mass));
pfl0 = std::sqrt(tf0*(tf0 + 2.0*mass));
}
const G4double pReflection = p->getReflectionMomentum()/pfl0;
const G4double reflectionRadius = n->getDensity()->getMaxRFromP(p->getType(), pReflection);
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarCEXChannel.cc
+119
View File
@@ -0,0 +1,119 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarCEXChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarCEXChannel::NNbarCEXChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarCEXChannel::~NNbarCEXChannel(){}
void NNbarCEXChannel::fillFinalState(FinalState *fs) {
//brief ppbar
// p pbar -> n nbar (BFMM 204)
//
//brief nnbar
// n nbar -> p pbar (same as BFMM 204, but no threshold)
//
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
//setting types of new particles
if(nucleon->getType()==Proton){
if(antinucleon->getType()==antiProton){ //ppbar case
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{ //pnbar case
//no CEX for pnbar
INCL_ERROR("We should not be in this channel " << '\n');
}
}
else{ // neutron
if(antinucleon->getType()==antiNeutron){ //nnbar case
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{ //npbar case
//no CEX for npbar
INCL_ERROR("We should not be in this channel " << '\n');
}
}
G4double mn=nucleon->getMass();
G4double my=antinucleon->getMass();
G4double ey=(sqrtS*sqrtS+my*my-mn*mn)/(2*sqrtS);
G4double en=std::sqrt(ey*ey-my*my+mn*mn);
nucleon->setEnergy(en);
antinucleon->setEnergy(ey);
G4double py=std::sqrt(ey*ey-my*my);
ThreeVector mom_antinucleon = Random::normVector(py);
antinucleon->setMomentum(mom_antinucleon);
nucleon->setMomentum(-mom_antinucleon);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarElasticChannel.cc
+104
View File
@@ -0,0 +1,104 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarElasticChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarElasticChannel::NNbarElasticChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarElasticChannel::~NNbarElasticChannel(){}
void NNbarElasticChannel::fillFinalState(FinalState *fs) {
//brief ppbar
// p pbar -> p pbar (BFMM 2)
//
//brief npbar
// n pbar -> n pbar (BFMM 472)
//
//brief nnbar
// n nbar -> n nbar (same as BFMM 2)
//
//brief pnbar
// p nbar -> p nbar (same as BFMM 472)
//
//
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
G4double mn=nucleon->getMass();
G4double my=antinucleon->getMass();
G4double ey=(sqrtS*sqrtS+my*my-mn*mn)/(2*sqrtS);
G4double en=std::sqrt(ey*ey-my*my+mn*mn);
nucleon->setEnergy(en);
antinucleon->setEnergy(ey);
G4double py=std::sqrt(ey*ey-my*my);
ThreeVector mom_antinucleon = Random::normVector(py);
antinucleon->setMomentum(mom_antinucleon);
nucleon->setMomentum(-mom_antinucleon);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarToAnnihilationChannel.cc
+1103
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarToLLbarChannel.cc
+392
View File
@@ -0,0 +1,392 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarToLLbarChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarToLLbarChannel::NNbarToLLbarChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarToLLbarChannel::~NNbarToLLbarChannel(){}
void NNbarToLLbarChannel::fillFinalState(FinalState *fs) {
// this channel include all states with lambdas, sigmas and xis and their antiparticles
//brief ppbar
// p pbar -> l lbar (BFMM 121)
// ppbar -> l lbar pi0 (BFMM 113)
// ppbar -> splus pim lbar || sminusbar pim l (BFMM 136)
// ppbar -> sminus pip lbar || splusbar l pip (BFMM 146)
// ppbar -> sp spbar (BFMM 139)
// ppbar -> sm smbar (BFMM 149)
// ppbar -> szero szerobar (BFMM 144)
// ppbar -> ximinus ximinusbar (BFMM 101)
// ppbar -> szero lbar || szerobar l (BFMM 143)
//
//
//brief npbar
// n pbar -> l lbar pi- (BFMM 487)
// n pbar -> l sbarplus || lbar sminus (BFMM 488)
//
//
//brief nnbar
// all same as for ppbar
//
//
//brief pnbar
// p nbar -> l lbar pi+ (same as BFMM 487)
// p nbar -> l sbarminus || lbar splus (same as BFMM 488)
//
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double plab = 0.001*KinematicsUtils::momentumInLab(particle1, particle2); //GeV
// ppbar cross sections
const std::vector<G4double> BFMM121 = {2.379, -2.738, -1.260, -1.915, 0.430, 1.437};
//const G4double Eth_PPbar_LLbar = 1.437;
const std::vector<G4double> BFMM113 = {-0.105, 0.000, -5.099, 0.188, -0.050, 1.820};
//const G4double Eth_PPbar_LLbar_pi0 = 1.820;
const std::vector<G4double> BFMM139 = {0.142, -0.291, -1.702, -0.058, 0.001, 1.851};
//const G4double Eth_PPbar_SpSpbar = 1.851;
const std::vector<G4double> BFMM149 = {1.855, -2.238, -1.002, -1.279, 0.252, 1.896};
//const G4double Eth_PPbar_SmSmbar = 1.896;
const std::vector<G4double> BFMM136 = {1.749, -2.506, -1.222, -1.262, 0.274, 2.042};
//const G4double Eth_PPbar_SpLbar_pim = 2.042;
const std::vector<G4double> BFMM146 = {1.037, -1.437, -1.155, -0.709, 0.138, 2.065};
//const G4double Eth_PPbar_SmLbar_pip = 2.065;
const std::vector<G4double> BFMM143 = {0.652, -1.006, -1.805, -0.537, 0.121, 1.653};
//const G4double Eth_PPbar_Szero_Lbar = 1.653;
//fixed due to limited data
G4double BFMM144;
if(plab > 2.0) BFMM144 = 0.008; //sigmazero sigmazerobar
else BFMM144 = 0.0;
G4double BFMM101;
if(plab > 2.8) BFMM101 = 0.002; //ximinus ximinusbar
else BFMM101 = 0.0;
// npbar cross sections (fixed due to limited data)
G4double BFMM487;
if(plab > 2.1) BFMM487 = 0.048; //llbar piminus
else BFMM487 = 0.0;
G4double BFMM488;
if(plab > 2.0) BFMM488 = 0.139; //lsigmaminus +cc
else BFMM488 = 0.0;
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
const G4double totalppbar = KinematicsUtils::compute_xs(BFMM113, plab)
+KinematicsUtils::compute_xs(BFMM139, plab) +KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)
+KinematicsUtils::compute_xs(BFMM121, plab)+KinematicsUtils::compute_xs(BFMM149, plab)
+BFMM144 +BFMM101;
const G4double totalpnbar = BFMM487 + BFMM488;
const G4double rdm = Random::shoot();
G4bool thirdparticle = false; //set true if we have pion
ParticleType PionType;
//setting types of new particles
if(nucleon->getType()==Proton){
if(antinucleon->getType()==antiProton){ //ppbar case
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)){ //llbar
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144){ //sigmazero sigmazerobar
nucleon->setType(SigmaZero);
antinucleon->setType(antiSigmaZero);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101){ //ximinus ximinusbar
nucleon->setType(XiMinus);
antinucleon->setType(antiXiMinus);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab)){ //llbar pi0
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiZero;
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)){ //splus lbar pim || sminusbar l pim
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaPlus);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiMinus;
}
else{
nucleon->setType(antiSigmaMinus);
antinucleon->setType(Lambda);
thirdparticle = true;
PionType = PiMinus;
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)){ //sminus lbar pip || splussbar l pip
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaMinus);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiPlus;
}
else{
nucleon->setType(antiSigmaPlus);
antinucleon->setType(Lambda);
thirdparticle = true;
PionType = PiPlus;
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)){ //szero lbar || szerobar l
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaZero);
antinucleon->setType(antiLambda);
}
else{
nucleon->setType(antiSigmaZero);
antinucleon->setType(Lambda);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)
+KinematicsUtils::compute_xs(BFMM139, plab)){ //sp spbar
nucleon->setType(SigmaPlus);
antinucleon->setType(antiSigmaPlus);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)
+KinematicsUtils::compute_xs(BFMM139, plab)+KinematicsUtils::compute_xs(BFMM149, plab)){ //sm smbar
nucleon->setType(SigmaMinus);
antinucleon->setType(antiSigmaMinus);
}
else{
INCL_ERROR("out of total ppbar sum in LLbar channel");
}
}
else{ //pnbar case charge +1
if(rdm*totalpnbar < BFMM488){
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(Lambda);
antinucleon->setType(antiSigmaMinus); //charge +1
}
else{
nucleon->setType(antiLambda);
antinucleon->setType(SigmaPlus); //charge +1
}
}
else{
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiPlus;
}
}
}
else{ // neutron
if(antinucleon->getType()==antiNeutron){ //nnbar case same as ppbar
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)){ //llbar
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144){ //sigmazero sigmazerobar
nucleon->setType(SigmaZero);
antinucleon->setType(antiSigmaZero);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101){ //ximinus ximinusbar
nucleon->setType(XiMinus);
antinucleon->setType(antiXiMinus);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab)){ //llbar pi0
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiZero;
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)){ //splus lbar pim || sminusbar l pim
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaPlus);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiMinus;
}
else{
nucleon->setType(antiSigmaMinus);
antinucleon->setType(Lambda);
thirdparticle = true;
PionType = PiMinus;
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)){ //sminus lbar pip || splussbar l pip
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaMinus); //charge -1
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiPlus;
}
else{
nucleon->setType(antiSigmaPlus); //charge -1
antinucleon->setType(Lambda);
thirdparticle = true;
PionType = PiPlus;
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)){ //szero lbar || szerobar l
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(SigmaZero);
antinucleon->setType(antiLambda);
}
else{
nucleon->setType(antiSigmaZero);
antinucleon->setType(Lambda);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)
+KinematicsUtils::compute_xs(BFMM139, plab)){ //sp spbar
nucleon->setType(SigmaPlus);
antinucleon->setType(antiSigmaPlus);
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM121, plab)+BFMM144+BFMM101
+KinematicsUtils::compute_xs(BFMM113, plab) + KinematicsUtils::compute_xs(BFMM136, plab)
+KinematicsUtils::compute_xs(BFMM146, plab)+KinematicsUtils::compute_xs(BFMM143, plab)
+KinematicsUtils::compute_xs(BFMM139, plab)+KinematicsUtils::compute_xs(BFMM149, plab)){ //sm smbar
nucleon->setType(SigmaMinus);
antinucleon->setType(antiSigmaMinus);
}
else{
INCL_ERROR("out of total nnbar sum in LLbar channel");
}
}
else{ //npbar case charge -1
if(rdm*totalpnbar < BFMM488){
G4double rdm2 = Random::shoot();
if(rdm2 > 0.5){
nucleon->setType(Lambda);
antinucleon->setType(antiSigmaPlus); //charge -1
}
else{
nucleon->setType(antiLambda);
antinucleon->setType(SigmaMinus); //charge -1
}
}
else{
nucleon->setType(Lambda);
antinucleon->setType(antiLambda);
thirdparticle = true;
PionType = PiMinus;
}
}
}
//now assigning momentum to the final particles
if(thirdparticle){ //three particles
ParticleList list;
list.push_back(nucleon);
list.push_back(antinucleon);
const ThreeVector &rcol = nucleon->getPosition();
const ThreeVector zero;
Particle *pion = new Particle(PionType,zero,rcol);
list.push_back(pion);
PhaseSpaceGenerator::generate(sqrtS, list);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
fs->addCreatedParticle(pion);
}
else{//only two particles
G4double mn=nucleon->getMass();
G4double my=antinucleon->getMass();
G4double ey=(sqrtS*sqrtS+my*my-mn*mn)/(2*sqrtS);
G4double en=std::sqrt(ey*ey-my*my+mn*mn);
nucleon->setEnergy(en);
antinucleon->setEnergy(ey);
G4double py=std::sqrt(ey*ey-my*my);
ThreeVector mom_antinucleon = Random::normVector(py);
antinucleon->setMomentum(mom_antinucleon);
nucleon->setMomentum(-mom_antinucleon);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
}
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarToNNbar2piChannel.cc
+347
View File
@@ -0,0 +1,347 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarToNNbar2piChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarToNNbar2piChannel::NNbarToNNbar2piChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarToNNbar2piChannel::~NNbarToNNbar2piChannel(){}
void NNbarToNNbar2piChannel::fillFinalState(FinalState *fs) {
//brief ppbar
// p pbar -> p pbar pi+ pi- (BFMM 167)
// p pbar -> p nbar pi- pi0 (same as BFMM 490)
// p pbar -> n pbar pi+ pi0 (same as BFMM 490)
// p pbar -> n nbar pi+ pi- (BFMM 198)
//
//brief npbar
// n pbar -> p pbar pi- pi0 (BFMM 490)
// n pbar -> p nbar pi- pi- (BFMM 492)
// n pbar -> n nbar pi- pi0 (same as BFMM 490)
// n pbar -> n pbar pi+ pi- (BFMM 494)
//
//brief nnbar
// n nbar -> n nbar pi+ pi- (same as BFMM 167)
// n nbar -> p nbar pi- pi0 (same as BFMM 490)
// n nbar -> n pbar pi+ pi0 (same as BFMM 490)
// n nbar -> p pbar pi+ pi- (same as BFMM 198)
//
//brief pnbar
// p nbar -> p pbar pi+ pi0 (same as BFMM 490)
// p nbar -> n pbar pi+ pi+ (same as BFMM 492)
// p nbar -> n nbar pi+ pi0 (same as BFMM 490)
// p nbar -> p nbar pi+ pi- (same as BFMM 494)
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double plab = 0.001*KinematicsUtils::momentumInLab(particle1, particle2); //GeV
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
const G4double rdm = Random::shoot();
const std::vector<G4double> BFMM167 = {-6.885, 0.476, 1.206, 13.857, -5.728, 1.220};
//const G4double Eth_PPbar_PPbar_pip_pim = 1.220;
const std::vector<G4double> BFMM198 = {1.857, -21.213, -3.448, 0.827, -0.390, 1.231};
//const G4double Eth_PPbar_NNbar_pip_pim = 1.231;
const std::vector<G4double> BFMM490 = {-3.594, 0.811, 0.306, 5.108, -1.625, 1.201};
//const G4double Eth_PNbar_PPbar_pim_pi0 = 1.201;
const std::vector<G4double> BFMM492 = {-5.443, 7.254, -2.936, 8.441, -2.588, 1.221};
//const G4double Eth_PNbar_NPbar_pim_pim = 1.221;
const std::vector<G4double> BFMM494 = {21.688, -38.709, -2.062, -17.783, 3.895, 1.221};
//const G4double Eth_NPbar_NPbar_pip_pim = 1.221;
// pnbar total is same as for npbar
// ppbar total is same as for nnbar
const G4double totalppbar = KinematicsUtils::compute_xs(BFMM167, plab) +KinematicsUtils::compute_xs(BFMM198, plab) +2*KinematicsUtils::compute_xs(BFMM490, plab);
const G4double totalpnbar = KinematicsUtils::compute_xs(BFMM492, plab) +KinematicsUtils::compute_xs(BFMM494, plab) +2*KinematicsUtils::compute_xs(BFMM490, plab);
//totalnnbar == totalppbar;
//totalpnbar == totalnpbar;
ParticleType Pion1;
ParticleType Pion2;
//setting types of new particles
if(nucleon->getType()==Proton){
if(antinucleon->getType()==antiProton){ // ppbar case
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)){ // ppbarpi-pi+ case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)+KinematicsUtils::compute_xs(BFMM490, plab)){ //pnbarpi-pi0 case
Pion1 = PiMinus;
Pion2 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)+2*KinematicsUtils::compute_xs(BFMM490, plab)){ //npbarpi+pi0 case
Pion1 = PiPlus;
Pion2 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else{ // n nbar pi+ pi- case case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (pnbar case)
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM490, plab)){ // p pbar pi+ pi0 case
Pion1 = PiZero;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM490, plab)+KinematicsUtils::compute_xs(BFMM492, plab)){ // n pbar pi+ pi+ case
Pion1 = PiPlus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else if(rdm*totalppbar < 2*KinematicsUtils::compute_xs(BFMM490, plab)+KinematicsUtils::compute_xs(BFMM492, plab)){ // n nbar pi+ pi0 case
Pion1 = PiZero;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else{ // p nbar pi+ pi- case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
}
}
else{ // neutron
if(antinucleon->getType()==antiProton){ //npbar case
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM490, plab)){ // p pbar pi- pi0 case
Pion1 = PiZero;
Pion2 = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM490, plab)+KinematicsUtils::compute_xs(BFMM492, plab)){ // p nbar pi- pi- case
Pion1 = PiMinus;
Pion2 = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < 2*KinematicsUtils::compute_xs(BFMM490, plab)+KinematicsUtils::compute_xs(BFMM492, plab)){ // n nbar pi- pi0 case
Pion1 = PiZero;
Pion2 = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else{ // n pbar pi+ pi- case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (nnbar case)
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)){ // nnbarpi-pi+ case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)+KinematicsUtils::compute_xs(BFMM490, plab)){ //pnbarpi-pi0 case
Pion1 = PiMinus;
Pion2 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM167, plab)+2*KinematicsUtils::compute_xs(BFMM490, plab)){ //npbarpi+pi0 case
Pion1 = PiPlus;
Pion2 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else{ // p pbar pi+ pi- case
Pion1 = PiMinus;
Pion2 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
}
}
ParticleList list;
list.push_back(nucleon);
list.push_back(antinucleon);
const ThreeVector &rcol = nucleon->getPosition();
const ThreeVector zero;
Particle *pion2 = new Particle(Pion1,zero,rcol);
Particle *pion1 = new Particle(Pion2,zero,rcol);
if(rdm < 0.5){
pion1->setType(Pion1);
pion2->setType(Pion2);
}
list.push_back(pion1);
list.push_back(pion2);
PhaseSpaceGenerator::generate(sqrtS, list);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
fs->addCreatedParticle(pion1);
fs->addCreatedParticle(pion2);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarToNNbar3piChannel.cc
+393
View File
@@ -0,0 +1,393 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarToNNbar3piChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarToNNbar3piChannel::NNbarToNNbar3piChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarToNNbar3piChannel::~NNbarToNNbar3piChannel(){}
void NNbarToNNbar3piChannel::fillFinalState(FinalState *fs) {
//brief ppbar
// p pbar -> p pbar pi+ pi- pi0 (BFMM 161)
// p pbar -> p nbar 2pi- pi+ (BFMM 169)
// p pbar -> n pbar 2pi+ pi- (BFMM 201)
// p pbar -> n nbar pi+ pi- pi0 (BFMM 197)
//
//brief npbar
// n pbar -> p pbar 2pi- pi+ (same as BFMM 169)
// n pbar -> p nbar 2pi- pi0 (same as BFMM 197)
// n pbar -> n nbar 2pi- pi+ (same as BFMM 169)
// n pbar -> n pbar pi+ pi- pi0 (same as BFMM 161)
//
//brief nnbar
// n nbar -> n nbar pi+ pi- pi0 (same as BFMM 161)
// n nbar -> p nbar 2pi- pi+ (same as BFMM 169)
// n nbar -> n pbar 2pi+ pi- (same as BFMM 201)
// n nbar -> p pbar pi+ pi- pi0 (same as BFMM 197)
//
//brief pnbar
// p nbar -> p pbar 2pi+ pi- (same as BFMM 169)
// p nbar -> n pbar 2pi+ pi0 (same as BFMM 197)
// p nbar -> n nbar 2pi+ pi- (same as BFMM 169)
// p nbar -> p nbar pi+ pi- pi0 (same as BFMM 161)
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double plab = 0.001*KinematicsUtils::momentumInLab(particle1, particle2);
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
const G4double rdm = Random::shoot();
const std::vector<G4double> BFMM161 = {-6.434, 1.351, -5.185, 7.754, -1.692, 1.604};
//const G4double Eth_PPbar_PPbar_pip_pim_pi0 = 1.604;
const std::vector<G4double> BFMM169 = {3.696, -5.356, -0.053, 1.941, -0.432, 1.624};
//const G4double Eth_PPbar_PNbar_2pim_pip = 1.624;
const std::vector<G4double> BFMM201 = {-1.070, -0.636, -0.009, 2.335, -0.499, 1.624};
//const G4double Eth_PPbar_NPbar_2pip_pim = 1.624;
const std::vector<G4double> BFMM197 = {1.857, -21.213, -3.448, 0.827, -0.390, 1.616};
//const G4double Eth_PPbar_NNbar_pip_pim_pi0 = 1.616;
// pnbar total is same as for npbar
// ppbar total is same as for nnbar
const G4double totalppbar = KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM201, plab)
+KinematicsUtils::compute_xs(BFMM197, plab);
const G4double totalpnbar = KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM197, plab)
+2*KinematicsUtils::compute_xs(BFMM169, plab);
//totalnnbar == totalppbar;
//totalpnbar == totalnpbar;
ParticleType Pion1;
ParticleType Pion2;
ParticleType Pion3;
//setting types of new particles
if(nucleon->getType()==Proton){
if(antinucleon->getType()==antiProton){ // ppbar case
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)){ // p pbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM169, plab)){ //p nbar 2pi- pi+ case
Pion1 = PiMinus;
Pion2 = PiMinus;
Pion3 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM201, plab)){ //n pbar 2pi+ pi- case
Pion1 = PiPlus;
Pion2 = PiPlus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else{ // n nbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (pnbar case)
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM169, plab)){ // p pbar 2pi+ pi- case
Pion1 = PiPlus;
Pion2 = PiPlus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM197, plab)){ // n pbar 2pi+ pi0 case
Pion1 = PiPlus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else if(rdm*totalppbar < 2*KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM197, plab)){ // n nbar 2pi+ pi- case
Pion1 = PiPlus;
Pion2 = PiPlus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else{ // p nbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
}
}
else{ // neutron
if(antinucleon->getType()==antiProton){ //npbar case
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM169, plab)){ // p pbar 2pi- pi+ case
Pion1 = PiPlus;
Pion2 = PiMinus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM197, plab)){ // p nbar 2pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiMinus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < 2*KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM197, plab)){ // n nbar 2pi- pi+ case
Pion1 = PiPlus;
Pion2 = PiMinus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else{ // n pbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (nnbar case)
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)){ // n nbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM169, plab)){ //p nbar 2pi- pi+ case
Pion1 = PiMinus;
Pion2 = PiMinus;
Pion3 = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM161, plab)
+KinematicsUtils::compute_xs(BFMM169, plab)
+KinematicsUtils::compute_xs(BFMM201, plab)){ //n pbar 2pi+ pi- case
Pion1 = PiPlus;
Pion2 = PiPlus;
Pion3 = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else{ // p pbar pi+ pi- pi0 case
Pion1 = PiMinus;
Pion2 = PiPlus;
Pion3 = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
}
}
ParticleList list;
list.push_back(nucleon);
list.push_back(antinucleon);
const ThreeVector &rcol = nucleon->getPosition();
const ThreeVector zero;
// Create three particle pointers
Particle *pion1 = nullptr;
Particle *pion2 = nullptr;
Particle *pion3 = nullptr;
// Determine the types of particles based on the random number
if (rdm < 1.0 / 3.0) {
pion1 = new Particle(Pion1, zero, rcol);
pion2 = new Particle(Pion2, zero, rcol);
pion3 = new Particle(Pion3, zero, rcol);
} else if (rdm < 2.0 / 3.0) {
pion1 = new Particle(Pion1, zero, rcol);
pion2 = new Particle(Pion3, zero, rcol);
pion3 = new Particle(Pion2, zero, rcol);
} else {
pion1 = new Particle(Pion2, zero, rcol);
pion2 = new Particle(Pion1, zero, rcol);
pion3 = new Particle(Pion3, zero, rcol);
}
list.push_back(pion1);
list.push_back(pion2);
list.push_back(pion3);
PhaseSpaceGenerator::generate(sqrtS, list);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
fs->addCreatedParticle(pion1);
fs->addCreatedParticle(pion2);
fs->addCreatedParticle(pion3);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNNbarToNNbarpiChannel.cc
+278
View File
@@ -0,0 +1,278 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4INCLNNbarToNNbarpiChannel.hh"
#include "G4INCLKinematicsUtils.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
#include "G4INCLRandom.hh"
#include "G4INCLGlobals.hh"
#include "G4INCLLogger.hh"
#include <algorithm>
#include "G4INCLPhaseSpaceGenerator.hh"
namespace G4INCL {
NNbarToNNbarpiChannel::NNbarToNNbarpiChannel(Particle *p1, Particle *p2)
: particle1(p1), particle2(p2)
{}
NNbarToNNbarpiChannel::~NNbarToNNbarpiChannel(){}
void NNbarToNNbarpiChannel::fillFinalState(FinalState *fs) {
//brief ppbar
// p pbar -> p pbar pi0 (BFMM 185)
// p pbar -> p nbar pi- (BFMM 188)
// p pbar -> n pbar pi+ (BFMM 199)
// p pbar -> n nbar pi0 (no data)
//
//brief npbar
// n pbar -> p pbar pi- (BFMM 491)
// n pbar -> p nbar pion (impossible)
// n pbar -> n pbar pi0 (BFMM 495)
// n pbar -> n nbar pi- (same as BFMM 188)
//
//brief nnbar
// n nbar -> n nbar pi0 (same as BFMM 185)
// n nbar -> p nbar pi- (same as BFMM 188)
// n nbar -> n pbar pi+ (same as BFMM 199)
// n nbar -> p pbar pi0 (no data)
//
//brief pnbar
// p nbar -> p pbar pi+ (same as BFMM 491)
// p nbar -> n pbar pion (impossible)
// p nbar -> p nbar pi0 (same as BFMM 495)
// p nbar -> n nbar pi+ (same as BFMM 188)
Particle *nucleon;
Particle *antinucleon;
if(particle1->isNucleon()){
nucleon = particle1;
antinucleon = particle2;
}
else{
nucleon = particle2;
antinucleon = particle1;
}
const G4double plab = 0.001*KinematicsUtils::momentumInLab(particle1, particle2);
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, antinucleon);
const G4double rdm = Random::shoot();
const std::vector<G4double> BFMM185 = {-0.734, 0.841, 0.905, 3.415, -2.316, 0.775};
//{22.781, -22.602, -0.752, -11.036, 1.548, 0.775};
//const G4double Eth_PPbar_PPbar_pi0 = 0.775;
const std::vector<G4double> BFMM188 = { -0.442, 0.501, 0.002, 3.434, -1.201, 0.798};
//const G4double Eth_PPbar_PNbar_pim = 0.798;
const std::vector<G4double> BFMM199 = {-2.025, 2.055, -2.355, 6.064, -2.004, 0.798};
//const G4double Eth_PPbar_NPbar_pip = 0.798;
const std::vector<G4double> BFMM491 = {24.125, -20.669, -1.534, -19.573, 4.493, 0.787};
//const G4double Eth_NPbar_PPbar_pim = 0.787;
const std::vector<G4double> BFMM495 = {-0.650, -0.140, -0.058, 5.166, -1.705, 0.777};
//const G4double Eth_NPbar_NPbar_pi0 = 0.777;
// pnbar total is same as for npbar
// ppbar total is same as for nnbar
const G4double totalppbar = KinematicsUtils::compute_xs(BFMM199, plab) +KinematicsUtils::compute_xs(BFMM185, plab) +KinematicsUtils::compute_xs(BFMM188, plab);
const G4double totalpnbar = KinematicsUtils::compute_xs(BFMM491, plab) +KinematicsUtils::compute_xs(BFMM495, plab) +KinematicsUtils::compute_xs(BFMM188, plab);
//totalnnbar == totalppbar;
//totalpnbar == totalnpbar;
ParticleType PionType;
//setting types of new particles
if(nucleon->getType()==Proton){
if(antinucleon->getType()==antiProton){ // ppbar case
if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM185, plab)){ // ppbarpi0 case
PionType = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM185, plab)+KinematicsUtils::compute_xs(BFMM188, plab)){ //pnbarpi- case
PionType = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else{ // npbarpi+ case
PionType = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (pnbar case)
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM491, plab)){ // ppbarpi+ case
PionType = PiPlus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM491, plab)+KinematicsUtils::compute_xs(BFMM495, plab)){ //pnbarpi0 case
PionType = PiZero;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else{ // nnbarpi+ case
PionType = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
}
}
else{ // neutron
if(antinucleon->getType()==antiProton){ //npbar case
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM491, plab)){ // ppbarpi- case
PionType = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Proton);
}
}
else if(rdm*totalppbar < KinematicsUtils::compute_xs(BFMM491, plab)+KinematicsUtils::compute_xs(BFMM495, plab)){ //npbarpi0 case
PionType = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
else{ // nnbarpi- case
PionType = PiMinus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
}
else{ //antiNeutron (nnbar case)
if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM185, plab)){ // nnbarpi0 case
PionType = PiZero;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Neutron);
}
}
else if(rdm*totalpnbar < KinematicsUtils::compute_xs(BFMM185, plab)+KinematicsUtils::compute_xs(BFMM188, plab)){ //pnbarpi- case
PionType = PiMinus;
if(rdm<0.5){
nucleon->setType(Proton);
antinucleon->setType(antiNeutron);
}
else{
nucleon->setType(antiNeutron);
antinucleon->setType(Proton);
}
}
else{ // npbarpi+ case
PionType = PiPlus;
if(rdm<0.5){
nucleon->setType(Neutron);
antinucleon->setType(antiProton);
}
else{
nucleon->setType(antiProton);
antinucleon->setType(Neutron);
}
}
}
}
ParticleList list;
list.push_back(nucleon);
list.push_back(antinucleon);
const ThreeVector &rcol = nucleon->getPosition();
const ThreeVector zero;
Particle *pion = new Particle(PionType,zero,rcol);
list.push_back(pion);
PhaseSpaceGenerator::generate(sqrtS, list);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(antinucleon);
fs->addCreatedParticle(pion);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNuclearDensity.cc
+6 -1
View File
@@ -181,7 +181,12 @@ namespace G4INCL {
transmissionRadius[SigmaMinus] = theProtonTransmissionRadius;
transmissionRadius[KPlus] = theProtonNuclearRadius;
transmissionRadius[KMinus] = theProtonNuclearRadius;
transmissionRadius[antiProton] = theProtonTransmissionRadius;
transmissionRadius[antiSigmaPlus] = theProtonTransmissionRadius;
transmissionRadius[antiSigmaMinus] = theProtonTransmissionRadius;
transmissionRadius[XiMinus] = theProtonTransmissionRadius;
transmissionRadius[antiXiMinus] = theProtonTransmissionRadius;
// transmission radii for neutral particles intentionally left uninitialised
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNuclearPotentialIsospin.cc
+37 -8
View File
@@ -106,17 +106,15 @@ namespace G4INCL {
vSigmaPlus = -16.;
vLambda = 30.;
//D
//insert new particles here
//D
vantiProton = 100.;
const G4double asy = (theA - 2.*theZ)/theA;
// Jose Luis Rodriguez-Sanchez et al., Rapid Communication PRC 98, 021602 (2018)
if (asy > 0.236) vLambda = 40.91;
else if (asy > 0.133) vLambda = 56.549 - 678.73*asy + 4905.35*asy*asy - 9789.1*asy*asy*asy;
const G4double theLambdaSeparationEnergy = ParticleTable::getSeparationEnergy(Lambda,theA,theZ);
const G4double theantiProtonSeparationEnergy = ParticleTable::getSeparationEnergy(antiProton,theA,theZ);
separationEnergy[PiPlus] = theProtonSeparationEnergy - theNeutronSeparationEnergy;
separationEnergy[PiZero] = 0.;
@@ -140,6 +138,8 @@ namespace G4INCL {
separationEnergy[KShort] = (theNeutronSeparationEnergy - theLambdaSeparationEnergy);
separationEnergy[KLong] = (theNeutronSeparationEnergy - theLambdaSeparationEnergy);
separationEnergy[antiProton] = theantiProtonSeparationEnergy;
fermiEnergy[DeltaPlusPlus] = vDeltaPlusPlus - separationEnergy[DeltaPlusPlus];
fermiEnergy[DeltaPlus] = vDeltaPlus - separationEnergy[DeltaPlus];
fermiEnergy[DeltaZero] = vDeltaZero - separationEnergy[DeltaZero];
@@ -154,6 +154,8 @@ namespace G4INCL {
fermiEnergy[SigmaPlus] = vSigmaPlus - separationEnergy[SigmaPlus];
fermiEnergy[SigmaZero] = vSigmaZero - separationEnergy[SigmaZero];
fermiEnergy[SigmaMinus] = vSigmaMinus - separationEnergy[SigmaMinus];
fermiEnergy[antiProton] = vantiProton - separationEnergy[antiProton];
INCL_DEBUG("Table of separation energies [MeV] for A=" << theA << ", Z=" << theZ << ":" << '\n'
<< " proton: " << separationEnergy[Proton] << '\n'
@@ -232,7 +234,7 @@ namespace G4INCL {
case Eta:
case Omega:
case EtaPrime:
case EtaPrime:
return computePionResonancePotentialEnergy(particle);
break;
@@ -248,11 +250,38 @@ namespace G4INCL {
case Photon:
return 0.0;
break;
//D
case antiProton:
return vantiProton;
break;
case antiNeutron:
return vantiProton;
break;
case antiLambda:
return 0.0;
break;
//D
case antiSigmaMinus:
return 0.0;
break;
case antiSigmaPlus:
return 0.0;
break;
case antiSigmaZero:
return 0.0;
break;
case antiXiMinus:
return 0.0;
break;
case antiXiZero:
return 0.0;
break;
case XiMinus:
return 0.0;
break;
case XiZero:
return 0.0;
break;
case DeltaPlusPlus:
return vDeltaPlusPlus;
break;
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNucleus.cc
+58 -3
View File
@@ -63,16 +63,18 @@
#include <sstream>
// #include <cassert>
#include "G4INCLPbarAtrestEntryChannel.hh"
#include "G4INCLBinaryCollisionAvatar.hh"
namespace G4INCL {
Nucleus::Nucleus(G4int mass, G4int charge, G4int strangess, Config const * const conf, const G4double universeRadius,
AnnihilationType AType) //D
AnnihilationType AType) //D
: Cluster(charge,mass,strangess,true),
theInitialZ(charge), theInitialA(mass), theInitialS(strangess),
theNpInitial(0), theNnInitial(0),
theNpionplusInitial(0), theNpionminusInitial(0),
theNkaonplusInitial(0), theNkaonminusInitial(0),
theNantiprotonInitial(0),
initialInternalEnergy(0.),
incomingAngularMomentum(0.,0.,0.), incomingMomentum(0.,0.,0.),
initialCenterOfMass(0.,0.,0.),
@@ -124,6 +126,14 @@ namespace G4INCL {
delete theDensity;*/
}
AnnihilationType Nucleus::getAType() const {
return theAType;
}
void Nucleus::setAType(AnnihilationType type) {
theAType = type;
}
void Nucleus::initializeParticles() {
// Reset the variables connected with the projectile remnant
delete theProjectileRemnant;
@@ -229,8 +239,13 @@ namespace G4INCL {
totalEnergy += (*p)->getKineticEnergy() - (*p)->getPotentialEnergy();
else if((*p)->isResonance())
totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() - ParticleTable::effectiveNucleonMass;
else if((*p)->isHyperon() || (*p)->isAntiNucleon())
else if((*p)->isHyperon())
totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() - ParticleTable::getRealMass((*p)->getType());
else if((*p)->isAntiNucleon())
totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() + ParticleTable::getINCLMass(Proton) - ParticleTable::getProtonSeparationEnergy();
else if((*p)->isAntiLambda())
totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() + ParticleTable::getRealMass((*p)->getType()) - ParticleTable::getSeparationEnergyINCL(Lambda, theA, theZ);
//std::cout << ParticleTable::getRealMass((*p)->getType()) << std::endl;}
else
totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy();
}
@@ -288,8 +303,29 @@ namespace G4INCL {
const G4double totalEnergy = computeTotalEnergy();
const G4double separationEnergies = computeSeparationEnergyBalance();
return totalEnergy - initialInternalEnergy - separationEnergies;
G4double eSep = 0;
if (getAType() == AnnihilationType::Def) {
} else if (getAType() == AnnihilationType::PType) {
} else if (getAType() == AnnihilationType::NType) {
} else if (getAType() == AnnihilationType::PTypeInFlight) {
eSep = ParticleTable::getProtonSeparationEnergy();
} else if (getAType() == AnnihilationType::NTypeInFlight) {
eSep = ParticleTable::getNeutronSeparationEnergy();
} else if (getAType() == AnnihilationType::NbarPTypeInFlight) {
eSep = ParticleTable::getProtonSeparationEnergy();
} else if (getAType() == AnnihilationType::NbarNTypeInFlight) {
eSep = ParticleTable::getNeutronSeparationEnergy();
}
if (eSep > 0. && (totalEnergy - initialInternalEnergy - separationEnergies - eSep) < 0.) {
INCL_DEBUG("Negative Excitation Energy due to a Nbar Annihilation process (separation energy of the nucleon annihilated...); E* = " << (totalEnergy - initialInternalEnergy - separationEnergies - eSep) << '\n');
}
return totalEnergy - initialInternalEnergy - separationEnergies - eSep;
}
//thePotential->getSeparationEnergy(Proton)
std::string Nucleus::print()
{
@@ -1054,9 +1090,15 @@ namespace G4INCL {
eventInfo->ParticleBias[eventInfo->nParticles] = (*i)->getParticleBias();
#ifdef INCLXX_IN_GEANT4_MODE
eventInfo->A[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getA();
eventInfo->Z[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getZ();
eventInfo->S[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getS();
#else
eventInfo->A[eventInfo->nParticles] = (Short_t)(*i)->getA();
eventInfo->Z[eventInfo->nParticles] = (Short_t)(*i)->getZ();
eventInfo->S[eventInfo->nParticles] = (Short_t)(*i)->getS();
#endif
eventInfo->emissionTime[eventInfo->nParticles] = (*i)->getEmissionTime();
eventInfo->EKin[eventInfo->nParticles] = (*i)->getKineticEnergy();
ThreeVector mom = (*i)->getMomentum();
@@ -1087,9 +1129,15 @@ namespace G4INCL {
// Projectile-like remnant characteristics
if(theProjectileRemnant && theProjectileRemnant->getA()>0) {
#ifdef INCLXX_IN_GEANT4_MODE
eventInfo->ARem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getA();
eventInfo->ZRem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getZ();
eventInfo->SRem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getS();
#else
eventInfo->ARem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getA();
eventInfo->ZRem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getZ();
eventInfo->SRem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getS();
#endif
G4double eStar = theProjectileRemnant->getExcitationEnergy();
if(std::abs(eStar)<1E-10)
eStar = 0.0; // blame rounding and set the excitation energy to zero
@@ -1118,9 +1166,15 @@ namespace G4INCL {
// Target-like remnant characteristics
if(hasRemnant()) {
#ifdef INCLXX_IN_GEANT4_MODE
eventInfo->ARem[eventInfo->nRemnants] = (G4INCL::Short_t)getA();
eventInfo->ZRem[eventInfo->nRemnants] = (G4INCL::Short_t)getZ();
eventInfo->SRem[eventInfo->nRemnants] = (G4INCL::Short_t)getS();
#else
eventInfo->ARem[eventInfo->nRemnants] = (Short_t)getA();
eventInfo->ZRem[eventInfo->nRemnants] = (Short_t)getZ();
eventInfo->SRem[eventInfo->nRemnants] = (Short_t)getS();
#endif
eventInfo->EStarRem[eventInfo->nRemnants] = getExcitationEnergy();
if(eventInfo->EStarRem[eventInfo->nRemnants]<0.) {
INCL_WARN("Negative excitation energy in target-like remnant! EStarRem = " << eventInfo->EStarRem[eventInfo->nRemnants] << " eventNumber=" << eventInfo->eventNumber << '\n');
@@ -1185,6 +1239,7 @@ namespace G4INCL {
theBalance.energy -= (*i)->getEnergy(); // Note that outgoing particles should have the real mass
theBalance.momentum -= (*i)->getMomentum();
}
// Projectile-like remnant contribution, if present
if(theProjectileRemnant && theProjectileRemnant->getA()>0) {
theBalance.Z -= theProjectileRemnant->getZ();
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLParticleEntryAvatar.cc
+1 -1
View File
@@ -50,7 +50,7 @@ namespace G4INCL {
ParticleEntryAvatar::ParticleEntryAvatar(G4double time,
G4INCL::Nucleus *nucleus,
G4INCL::Particle *particle,
EntryType EType)
EntryType EType)
:IAvatar(time), theNucleus(nucleus), theParticle(particle), theEType(EType)
{
setType(ParticleEntryAvatarType);
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLPbarAtrestEntryChannel.cc
+14 -8
View File
@@ -34,6 +34,7 @@
#define INCLXX_IN_GEANT4_MODE 1
#include "globals.hh"
#include "G4EnvironmentUtils.hh"
#include "G4INCLPbarAtrestEntryChannel.hh"
#include "G4INCLRootFinder.hh"
@@ -95,7 +96,7 @@ namespace G4INCL {
}
}
else std::cout << "ERROR no fread_file " << filename << std::endl;
return sum_probs;
}
@@ -105,14 +106,15 @@ namespace G4INCL {
G4double smallestsum = 0.0;
G4double biggestsum = yields[0];
//std::cout << "initial input " << rdm << std::endl;
for (G4int i = 0; i < static_cast<G4int>(yields.size()); i++) {
for (G4int i = 0; i < static_cast<G4int>(yields.size()-1); i++) {
if (rdm >= smallestsum && rdm <= biggestsum) {
//std::cout << smallestsum << " and " << biggestsum << std::endl;
stringNumber = i;
stringNumber = i+1;
}
smallestsum += yields[i];
biggestsum += yields[i+1];
}
if(stringNumber==-1) stringNumber = static_cast<G4int>(yields.size());
if(stringNumber==-1){
INCL_ERROR("ERROR in findStringNumber (stringNumber=-1)");
std::cout << "ERROR in findStringNumber" << std::endl;
@@ -250,7 +252,7 @@ namespace G4INCL {
G4Exception("G4INCLDataFile::readData()","rawppbarFS.dat, ...",
FatalException, ed);
}
G4String dataPath0(std::getenv("G4INCLDATA"));
G4String dataPath0{G4FindDataDir("G4INCLDATA")};
G4String dataPathppbar(dataPath0 + "/rawppbarFS.dat");
G4String dataPathnpbar(dataPath0 + "/rawnpbarFS.dat");
G4String dataPathppbark(dataPath0 + "/rawppbarFSkaonic.dat");
@@ -303,7 +305,8 @@ namespace G4INCL {
sum = read_file(dataPathppbar, probabilities, particle_types);
rdm = (rdm/(1.-kaonicFSprob))*sum; //99.88 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return starlist;
for(G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++){
if(particle_types[n][j] == "pi0"){
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
@@ -357,7 +360,8 @@ namespace G4INCL {
sum = read_file(dataPathppbark, probabilities, particle_types);
rdm = ((1-rdm)/kaonicFSprob)*sum;//2670 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return starlist;
for(G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++){
if(particle_types[n][j] == "pi0"){
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
@@ -412,7 +416,8 @@ namespace G4INCL {
sum = read_file(dataPathnpbar, probabilities, particle_types);
rdm = (rdm/(1.-kaonicFSprob))*sum; //99.95 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return starlist;
for(G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++){
if(particle_types[n][j] == "pi0"){
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
@@ -466,7 +471,8 @@ namespace G4INCL {
sum = read_file(dataPathnpbark, probabilities, particle_types);
rdm = ((1-rdm)/kaonicFSprob)*sum;//3837 normalize by the sum of probabilities in the file
//now get the line number in the file where the FS particles are stored:
G4int n = findStringNumber(rdm, probabilities);
G4int n = findStringNumber(rdm, probabilities)-1;
if ( n < 0 ) return starlist;
for(G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++){
if(particle_types[n][j] == "pi0"){
Particle *p = new Particle(PiZero, mommy, annihilationPosition);
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLPiNElasticChannel.cc
+9 -9
View File
@@ -95,8 +95,8 @@ namespace G4INCL {
pion->setMomentum(-mom_nucleon);
#ifdef INCLXX_IN_GEANT4_MODE
ParticleType startingNucleonType = nucleon->getType();
ParticleType startingPionType = pion->getType();
ParticleType startingNucleonType = nucleon->getType();
ParticleType startingPionType = pion->getType();
#endif
G4int iso=ParticleTable::getIsospin(nucleon->getType())+ParticleTable::getIsospin(pion->getType());
@@ -122,13 +122,13 @@ namespace G4INCL {
}
#ifdef INCLXX_IN_GEANT4_MODE
// Erase the parent resonance information if the nucleon or pion changes type
if ( startingNucleonType != nucleon->getType() || startingPionType != pion->getType() ) {
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
}
// Erase the parent resonance information if the nucleon or pion changes type
if ( startingNucleonType != nucleon->getType() || startingPionType != pion->getType() ) {
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
}
#endif
fs->addModifiedParticle(nucleon);
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLPiNToEtaChannel.cc
+35 -35
View File
@@ -65,43 +65,43 @@ namespace G4INCL {
pion = particle1;
}
G4int iso=ParticleTable::getIsospin(nucleon->getType())+ParticleTable::getIsospin(pion->getType());
G4int iso=ParticleTable::getIsospin(nucleon->getType())+ParticleTable::getIsospin(pion->getType());
// assert(iso == 1 || iso == -1);
if (iso == 1) {
if (iso == 1) {
nucleon->setType(Proton);
}
else if (iso == -1) {
}
else if (iso == -1) {
nucleon->setType(Neutron);
}
pion->setType(Eta);
pion->setType(Eta);
#ifdef INCLXX_IN_GEANT4_MODE
// Erase the parent resonance information of the nucleon and pion
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
// Erase the parent resonance information of the nucleon and pion
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
#endif
G4double sh=nucleon->getEnergy()+pion->getEnergy();
G4double mn=nucleon->getMass();
G4double me=pion->getMass();
G4double en=(sh*sh+mn*mn-me*me)/(2*sh);
nucleon->setEnergy(en);
G4double ee=std::sqrt(en*en-mn*mn+me*me);
pion->setEnergy(ee);
G4double pn=std::sqrt(en*en-mn*mn);
G4double sh=nucleon->getEnergy()+pion->getEnergy();
G4double mn=nucleon->getMass();
G4double me=pion->getMass();
G4double en=(sh*sh+mn*mn-me*me)/(2*sh);
nucleon->setEnergy(en);
G4double ee=std::sqrt(en*en-mn*mn+me*me);
pion->setEnergy(ee);
G4double pn=std::sqrt(en*en-mn*mn);
// real distribution (from PRC 78, 025204 (2008))
G4double ECM=G4INCL::KinematicsUtils::totalEnergyInCM(particle1,particle2);
G4double ECM=G4INCL::KinematicsUtils::totalEnergyInCM(particle1,particle2);
const G4double pi=std::acos(-1.0);
G4double x1;
G4double u1;
G4double fteta;
G4double teta;
G4double fi;
const G4double pi=std::acos(-1.0);
G4double x1;
G4double u1;
G4double fteta;
G4double teta;
G4double fi;
if (ECM < 1650.) {
if (ECM < 1650.) {
// below 1650 MeV - angular distribution (x=cos(theta): ax^2+bx+c
G4double f1= -0.0000288627*ECM*ECM+0.09155289*ECM-72.25436; // f(1) that is the maximum (fit on experimental data)
@@ -154,22 +154,22 @@ namespace G4INCL {
passe2=1;
}
}
}
}
fi=(2.0*pi)*Random::shoot();
fi=(2.0*pi)*Random::shoot();
ThreeVector mom_nucleon(
ThreeVector mom_nucleon(
pn*std::sin(teta)*std::cos(fi),
pn*std::sin(teta)*std::sin(fi),
pn*std::cos(teta)
);
);
// end real distribution
nucleon->setMomentum(-mom_nucleon);
pion->setMomentum(mom_nucleon);
nucleon->setMomentum(-mom_nucleon);
pion->setMomentum(mom_nucleon);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
}
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLPiNToMultiPionsChannel.cc
+23 -23
View File
@@ -81,33 +81,33 @@ namespace G4INCL {
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
#endif
G4int ipi=ParticleTable::getIsospin(pion->getType());
ind2=ParticleTable::getIsospin(nucleon->getType());
G4int ipi=ParticleTable::getIsospin(pion->getType());
ind2=ParticleTable::getIsospin(nucleon->getType());
ParticleList list;
list.push_back(nucleon);
list.push_back(pion);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
ParticleList list;
list.push_back(nucleon);
list.push_back(pion);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
isospinRepartition(ipi);
isospinRepartition(ipi);
const ParticleType tn=ParticleTable::getNucleonType(ind2);
nucleon->setType(tn);
ParticleType pionType=ParticleTable::getPionType(isosp[0]);
pion->setType(pionType);
const ThreeVector &rcolpion = pion->getPosition();
const ThreeVector zero;
for(G4int i=1; i<npion; ++i) {
pionType=ParticleTable::getPionType(isosp[i]);
Particle *newPion = new Particle(pionType,zero,rcolpion);
newPion->setType(pionType);
list.push_back(newPion);
fs->addCreatedParticle(newPion);
}
const ParticleType tn=ParticleTable::getNucleonType(ind2);
nucleon->setType(tn);
ParticleType pionType=ParticleTable::getPionType(isosp[0]);
pion->setType(pionType);
const ThreeVector &rcolpion = pion->getPosition();
const ThreeVector zero;
for(G4int i=1; i<npion; ++i) {
pionType=ParticleTable::getPionType(isosp[i]);
Particle *newPion = new Particle(pionType,zero,rcolpion);
newPion->setType(pionType);
list.push_back(newPion);
fs->addCreatedParticle(newPion);
}
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, pion);
PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
const G4double sqrtS = KinematicsUtils::totalEnergyInCM(nucleon, pion);
PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLPiNToOmegaChannel.cc
+25 -25
View File
@@ -64,41 +64,41 @@ namespace G4INCL {
nucleon = particle2;
pion = particle1;
}
G4int iso=ParticleTable::getIsospin(nucleon->getType())+ParticleTable::getIsospin(pion->getType());
// assert(iso == 1 || iso == -1);
if (iso == 1) {
nucleon->setType(Proton);
}
else if (iso == -1) {
}
else if (iso == -1) {
nucleon->setType(Neutron);
}
pion->setType(Omega);
pion->setType(Omega);
#ifdef INCLXX_IN_GEANT4_MODE
// Erase the parent resonance information of the nucleon and pion
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
// Erase the parent resonance information of the nucleon and pion
nucleon->setParentResonancePDGCode(0);
nucleon->setParentResonanceID(0);
pion->setParentResonancePDGCode(0);
pion->setParentResonanceID(0);
#endif
// nucleon->setEnergy(std::sqrt((nucleon->getMass())*(nucleon->getMass())+(mom_nucleon.mag()*mom_nucleon.mag())));
// pion->setEnergy(std::sqrt((pion->getMass())*(pion->getMass())+(mom_nucleon.mag()*mom_nucleon.mag())));
G4double sh=nucleon->getEnergy()+pion->getEnergy();
G4double mn=nucleon->getMass();
G4double me=pion->getMass();
G4double en=(sh*sh+mn*mn-me*me)/(2*sh);
nucleon->setEnergy(en);
G4double ee=std::sqrt(en*en-mn*mn+me*me);
pion->setEnergy(ee);
G4double pn=std::sqrt(en*en-mn*mn);
// nucleon->setEnergy(std::sqrt((nucleon->getMass())*(nucleon->getMass())+(mom_nucleon.mag()*mom_nucleon.mag())));
// pion->setEnergy(std::sqrt((pion->getMass())*(pion->getMass())+(mom_nucleon.mag()*mom_nucleon.mag())));
G4double sh=nucleon->getEnergy()+pion->getEnergy();
G4double mn=nucleon->getMass();
G4double me=pion->getMass();
G4double en=(sh*sh+mn*mn-me*me)/(2*sh);
nucleon->setEnergy(en);
G4double ee=std::sqrt(en*en-mn*mn+me*me);
pion->setEnergy(ee);
G4double pn=std::sqrt(en*en-mn*mn);
ThreeVector mom_nucleon = Random::normVector(pn);
ThreeVector mom_nucleon = Random::normVector(pn);
nucleon->setMomentum(mom_nucleon);
pion->setMomentum(-mom_nucleon);
nucleon->setMomentum(mom_nucleon);
pion->setMomentum(-mom_nucleon);
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
}
fs->addModifiedParticle(nucleon);
fs->addModifiedParticle(pion);
}
}
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLStandardPropagationModel.cc
+3 -3
View File
@@ -380,8 +380,8 @@ namespace G4INCL {
hasLocalEnergy = ((theLocalEnergyType == FirstCollisionLocalEnergy &&
theNucleus->getStore()->getBook().getAcceptedCollisions()==0) ||
theLocalEnergyType == AlwaysLocalEnergy);
const G4bool p1HasLocalEnergy = (hasLocalEnergy && !p1->isMeson());
const G4bool p2HasLocalEnergy = (hasLocalEnergy && !p2->isMeson());
const G4bool p1HasLocalEnergy = (hasLocalEnergy && !p1->isMeson() && !p1->isAntiNucleon());
const G4bool p2HasLocalEnergy = (hasLocalEnergy && !p2->isMeson() && !p2->isAntiNucleon());
if(p1HasLocalEnergy) {
backupParticle1 = *p1;
@@ -391,7 +391,7 @@ namespace G4INCL {
return NULL;
}
KinematicsUtils::transformToLocalEnergyFrame(theNucleus, p1);
}
}
if(p2HasLocalEnergy) {
backupParticle2 = *p2;
p2->propagate(t - currentTime);
source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLTransmissionChannel.cc
+1
View File
@@ -120,6 +120,7 @@ namespace G4INCL {
initialEnergy += theParticle->getTableMass() - theParticle->getMass()
+ theParticle->getEmissionQValueCorrection(AParent,ZParent,SParent);
particleLeaves();
fs->setTotalEnergyBeforeInteraction(initialEnergy);
fs->addOutgoingParticle(theParticle); // We write the particle down as outgoing
}