Import Geant4 11.2.0 source tree
This commit is contained in:
Gabriele Cosmo
@@ -23,9 +23,6 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// ----------------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
@@ -33,15 +30,9 @@
|
||||
// 4th April 1996, G.Cosmo
|
||||
// **********************************************************************
|
||||
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "G4DiQuarks.hh"
|
||||
|
||||
// ######################################################################
|
||||
// ### DiQuarks ###
|
||||
// ######################################################################
|
||||
|
||||
// clang-format off
|
||||
G4DiQuarks::G4DiQuarks(
|
||||
const G4String& aName, G4double mass,
|
||||
G4double width, G4double charge,
|
||||
|
||||
@@ -23,46 +23,39 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedBaryonConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ExcitedBaryons.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
|
||||
|
||||
G4ExcitedBaryonConstructor::G4ExcitedBaryonConstructor(G4int nStates,
|
||||
G4int isoSpin)
|
||||
: NumberOfStates(nStates), iIsoSpin(isoSpin), type("baryon")
|
||||
{
|
||||
}
|
||||
G4ExcitedBaryonConstructor::G4ExcitedBaryonConstructor(G4int nStates, G4int isoSpin)
|
||||
: NumberOfStates(nStates), iIsoSpin(isoSpin), type("baryon")
|
||||
{}
|
||||
|
||||
void G4ExcitedBaryonConstructor::Construct(G4int idx)
|
||||
{
|
||||
if (idx < 0 ) {
|
||||
for (G4int state=0; state< NumberOfStates; state +=1) {
|
||||
ConstructParticle(state);
|
||||
ConstructAntiParticle(state);
|
||||
}
|
||||
} else if (idx < NumberOfStates) {
|
||||
if (idx < 0) {
|
||||
for (G4int state = 0; state < NumberOfStates; state += 1) {
|
||||
ConstructParticle(state);
|
||||
ConstructAntiParticle(state);
|
||||
}
|
||||
}
|
||||
else if (idx < NumberOfStates) {
|
||||
ConstructParticle(idx);
|
||||
ConstructAntiParticle(idx);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
#ifdef G4VERBOSE
|
||||
if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
|
||||
if (G4ParticleTable::GetParticleTable()->GetVerboseLevel() > 1) {
|
||||
G4cerr << "G4ExcitedBaryonConstructor::Construct()";
|
||||
G4cerr << " illegal index os state = " << idx << G4endl;
|
||||
}
|
||||
@@ -70,12 +63,9 @@ void G4ExcitedBaryonConstructor::Construct(G4int idx)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#include "G4ExcitedBaryons.hh"
|
||||
|
||||
void G4ExcitedBaryonConstructor::ConstructParticle(G4int idx)
|
||||
{
|
||||
if (!Exist(idx) ) return;
|
||||
if (!Exist(idx)) return;
|
||||
|
||||
// Construct Resonace particles as dynamic object
|
||||
// Arguments for constructor are as follows
|
||||
@@ -83,15 +73,15 @@ void G4ExcitedBaryonConstructor::ConstructParticle(G4int idx)
|
||||
// 2*spin parity C-conjugation
|
||||
// 2*Isospin 2*Isospin3 G-parity
|
||||
// type lepton number baryon number PDG encoding
|
||||
// stable lifetime decay table
|
||||
|
||||
|
||||
// stable lifetime decay table
|
||||
|
||||
G4String name;
|
||||
G4ParticleDefinition* particle;
|
||||
|
||||
for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
|
||||
name= GetName(iIso3, idx);
|
||||
|
||||
for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= iIsoSpin; iIso3 += 2) {
|
||||
name = GetName(iIso3, idx);
|
||||
|
||||
// clang-format off
|
||||
particle = new G4ExcitedBaryons(
|
||||
name, GetMass(idx,iIso3), GetWidth(idx,iIso3), GetCharge(iIso3),
|
||||
GetiSpin(idx), GetiParity(idx), iConjugation,
|
||||
@@ -99,14 +89,16 @@ void G4ExcitedBaryonConstructor::ConstructParticle(G4int idx)
|
||||
type, leptonNumber, baryonNumber, GetEncoding( iIso3,idx),
|
||||
false, 0.0, nullptr
|
||||
);
|
||||
// clang-format on
|
||||
|
||||
((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
|
||||
particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, false));
|
||||
particle->SetDecayTable(CreateDecayTable(name, iIso3, idx, false));
|
||||
}
|
||||
}
|
||||
|
||||
void G4ExcitedBaryonConstructor::ConstructAntiParticle(G4int idx)
|
||||
{
|
||||
if (!Exist(idx) ) return;
|
||||
if (!Exist(idx)) return;
|
||||
|
||||
// Construct Resonace particles as dynamic object
|
||||
// Arguments for constructor are as follows
|
||||
@@ -114,16 +106,16 @@ void G4ExcitedBaryonConstructor::ConstructAntiParticle(G4int idx)
|
||||
// 2*spin parity C-conjugation
|
||||
// 2*Isospin 2*Isospin3 G-parity
|
||||
// type lepton number baryon number PDG encoding
|
||||
// stable lifetime decay table
|
||||
|
||||
|
||||
// stable lifetime decay table
|
||||
|
||||
G4String name;
|
||||
G4ParticleDefinition* particle;
|
||||
|
||||
for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
|
||||
|
||||
for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= iIsoSpin; iIso3 += 2) {
|
||||
name = GetName(iIso3, idx);
|
||||
name = "anti_" + name;
|
||||
|
||||
// clang-format off
|
||||
particle = new G4ExcitedBaryons(
|
||||
name, GetMass(idx,iIso3), GetWidth(idx,iIso3), -1.0*GetCharge(iIso3),
|
||||
GetiSpin(idx), GetiParity(idx), iConjugation,
|
||||
@@ -133,37 +125,40 @@ void G4ExcitedBaryonConstructor::ConstructAntiParticle(G4int idx)
|
||||
-1*GetEncoding( iIso3,idx),
|
||||
false, 0.0, nullptr
|
||||
);
|
||||
// clang-format on
|
||||
|
||||
((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
|
||||
particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, true));
|
||||
particle->SetDecayTable(CreateDecayTable(name, iIso3, idx, true));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
G4double G4ExcitedBaryonConstructor::GetCharge(G4int iIsoSpin3)
|
||||
G4double G4ExcitedBaryonConstructor::GetCharge(G4int iIsoSpin3)
|
||||
{
|
||||
G4double charge = 0.0;
|
||||
// clang-format off
|
||||
static const G4double quark_charge[7] =
|
||||
{
|
||||
0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
|
||||
};
|
||||
|
||||
for (G4int idx=0; idx<3; idx+=1){
|
||||
charge += quark_charge[GetQuarkContents(idx, iIsoSpin3)]*eplus;
|
||||
// clang-format on
|
||||
|
||||
for (G4int idx = 0; idx < 3; idx += 1) {
|
||||
charge += quark_charge[GetQuarkContents(idx, iIsoSpin3)] * eplus;
|
||||
}
|
||||
return charge;
|
||||
}
|
||||
|
||||
G4int G4ExcitedBaryonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
|
||||
G4int G4ExcitedBaryonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
|
||||
{
|
||||
G4int encoding = GetEncodingOffset(idxState);
|
||||
encoding += 1000*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(2, iIsoSpin3);
|
||||
if (GetiSpin(idxState) <9) {
|
||||
encoding += GetiSpin(idxState) +1;
|
||||
} else {
|
||||
encoding += (GetiSpin(idxState) +1)*10000000;
|
||||
encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(2, iIsoSpin3);
|
||||
if (GetiSpin(idxState) < 9) {
|
||||
encoding += GetiSpin(idxState) + 1;
|
||||
}
|
||||
else {
|
||||
encoding += (GetiSpin(idxState) + 1) * 10000000;
|
||||
}
|
||||
return encoding;
|
||||
}
|
||||
|
||||
@@ -23,9 +23,6 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// ----------------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
@@ -33,15 +30,9 @@
|
||||
// 4th April 1996, G.Cosmo
|
||||
// **********************************************************************
|
||||
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "G4ExcitedBaryons.hh"
|
||||
|
||||
// ######################################################################
|
||||
// ### ExcitedBaryons ###
|
||||
// ######################################################################
|
||||
|
||||
// clang-format off
|
||||
G4ExcitedBaryons::G4ExcitedBaryons(
|
||||
const G4String& aName, G4double mass,
|
||||
G4double width, G4double charge,
|
||||
|
||||
@@ -23,107 +23,104 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
//
|
||||
// Update mass and width following PDG 2023
|
||||
// 4 nov 2023 S.Okada
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedDeltaConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
|
||||
|
||||
G4ExcitedDeltaConstructor::G4ExcitedDeltaConstructor():
|
||||
G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
|
||||
{
|
||||
|
||||
}
|
||||
G4ExcitedDeltaConstructor::G4ExcitedDeltaConstructor()
|
||||
: G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
|
||||
{}
|
||||
|
||||
G4int G4ExcitedDeltaConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
|
||||
{
|
||||
G4int encoding;
|
||||
// Delta has exceptinal encoding
|
||||
if ((idxState==1)||(idxState==3)||(idxState==4)||(idxState==5)||(idxState==7)) {
|
||||
if ((idxState == 1) || (idxState == 3) || (idxState == 4) || (idxState == 5) || (idxState == 7)) {
|
||||
encoding = GetEncodingOffset(idxState);
|
||||
if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
|
||||
// normal encoding
|
||||
encoding += 1000*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(2, iIsoSpin3);
|
||||
} else if (iIsoSpin3== +1){
|
||||
// 1st <--> 2nd quark
|
||||
encoding += 1000*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 100*GetQuarkContents(2, iIsoSpin3);
|
||||
} else if (iIsoSpin3== -1){
|
||||
// 1st <--> 0th quark
|
||||
encoding += 100*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 1000*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(2, iIsoSpin3);
|
||||
if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) {
|
||||
// normal encoding
|
||||
encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
encoding += GetiSpin(idxState) +1;
|
||||
} else {
|
||||
else if (iIsoSpin3 == +1) {
|
||||
// 1st <--> 2nd quark
|
||||
encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 100 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
else if (iIsoSpin3 == -1) {
|
||||
// 1st <--> 0th quark
|
||||
encoding += 100 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 1000 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
encoding += GetiSpin(idxState) + 1;
|
||||
}
|
||||
else {
|
||||
encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
|
||||
}
|
||||
return encoding;
|
||||
}
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::CreateDecayTable(
|
||||
const G4String& parentName,
|
||||
G4int iIso3,
|
||||
G4int iState,
|
||||
G4bool fAnti)
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
||||
G4int iState, G4bool fAnti)
|
||||
{
|
||||
// create decay table
|
||||
auto decayTable = new G4DecayTable();
|
||||
auto decayTable = new G4DecayTable();
|
||||
|
||||
G4double br;
|
||||
if ( (br=bRatio[iState][NGamma]) >0.0) {
|
||||
AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NGamma]) > 0.0) {
|
||||
AddNGammaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NPi]) >0.0) {
|
||||
AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NPi]) > 0.0) {
|
||||
AddNPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NRho]) >0.0) {
|
||||
AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NRho]) > 0.0) {
|
||||
AddNRhoMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][DeltaPi]) >0.0) {
|
||||
AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][DeltaPi]) > 0.0) {
|
||||
AddDeltaPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NStarPi]) >0.0) {
|
||||
AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NStarPi]) > 0.0) {
|
||||
AddNStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
return decayTable;
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNGammaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNGammaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
//
|
||||
//
|
||||
G4String daughterN;
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
} else {
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else {
|
||||
// can not decay into N+gamma
|
||||
return decayTable;
|
||||
}
|
||||
@@ -131,17 +128,16 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNGammaMode(
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterN,"gamma");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "gamma");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -149,57 +145,64 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N pi0 ------------
|
||||
// ------------ N pi0 ------------
|
||||
// determine daughters
|
||||
if ((iIso3 == +1)||(iIso3 == -1)) {
|
||||
if ((iIso3 == +1) || (iIso3 == -1)) {
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterPi = "pi0";
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
daughterPi = "pi0";
|
||||
r = br/3.;
|
||||
}
|
||||
r = br / 3.;
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// -------------N pi +/- --------------
|
||||
// -------------N pi +/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br/3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "proton";
|
||||
r = br / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -3) {
|
||||
daughterN = "neutron";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -3) {
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br;
|
||||
@@ -207,18 +210,16 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -226,57 +227,64 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(
|
||||
G4String daughterRho;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N Rho0 ------------
|
||||
// ------------ N Rho0 ------------
|
||||
// determine daughters
|
||||
if ((iIso3 == +1)||(iIso3 == -1)) {
|
||||
if ((iIso3 == +1) || (iIso3 == -1)) {
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterRho = "rho0";
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "neutron";
|
||||
daughterRho = "rho0";
|
||||
r = br/3.;
|
||||
}
|
||||
r = br / 3.;
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterRho);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterRho);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// -------------N Rho +/- --------------
|
||||
// -------------N Rho +/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho-";
|
||||
}
|
||||
r = br;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho-";
|
||||
}
|
||||
r = br/3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "proton";
|
||||
r = br / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho+";
|
||||
}
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -3) {
|
||||
daughterN = "neutron";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -3) {
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho+";
|
||||
}
|
||||
r = br;
|
||||
@@ -284,17 +292,16 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterRho);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterRho);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -302,57 +309,64 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N pi0 ------------
|
||||
// ------------ N pi0 ------------
|
||||
// determine daughters
|
||||
if ((iIso3 == +1)||(iIso3 == -1)) {
|
||||
if ((iIso3 == +1) || (iIso3 == -1)) {
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "N(1440)+";
|
||||
daughterN = "N(1440)+";
|
||||
daughterPi = "pi0";
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "N(1440)0";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "N(1440)0";
|
||||
daughterPi = "pi0";
|
||||
r = br/3.;
|
||||
}
|
||||
r = br / 3.;
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// -------------N pi +/- --------------
|
||||
// -------------N pi +/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
daughterN = "N(1440)+";
|
||||
daughterN = "N(1440)+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterN = "N(1440)0";
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterN = "N(1440)0";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br/3.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterN = "N(1440)+";
|
||||
r = br / 3.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterN = "N(1440)+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br*2./3.;
|
||||
} else if (iIso3 == -3) {
|
||||
daughterN = "N(1440)0";
|
||||
r = br * 2. / 3.;
|
||||
}
|
||||
else if (iIso3 == -3) {
|
||||
daughterN = "N(1440)0";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br;
|
||||
@@ -360,17 +374,16 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -378,82 +391,90 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r;
|
||||
|
||||
// ------------ Delta pi +------------
|
||||
// ------------ Delta pi +------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
daughterDelta = "delta+";
|
||||
r = br*0.4;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterDelta = "delta0";
|
||||
r = br*8./15.0;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterDelta = "delta-";
|
||||
r = br*6./15.;
|
||||
} else {
|
||||
r = 0.;
|
||||
daughterDelta = "delta+";
|
||||
r = br * 0.4;
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterDelta = "delta0";
|
||||
r = br * 8. / 15.0;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterDelta = "delta-";
|
||||
r = br * 6. / 15.;
|
||||
}
|
||||
else {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
if (r>0.0) {
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
if (r > 0.0) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ Delta pi0 ------------
|
||||
// ------------ Delta pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
daughterDelta = "delta++";
|
||||
r = br*0.6;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterDelta = "delta+";
|
||||
r = br*1./15.0;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterDelta = "delta0";
|
||||
r = br*1./15.;
|
||||
} else {
|
||||
daughterDelta = "delta-";
|
||||
r = br*0.6;
|
||||
daughterDelta = "delta++";
|
||||
r = br * 0.6;
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterDelta = "delta+";
|
||||
r = br * 1. / 15.0;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterDelta = "delta0";
|
||||
r = br * 1. / 15.;
|
||||
}
|
||||
else {
|
||||
daughterDelta = "delta-";
|
||||
r = br * 0.6;
|
||||
}
|
||||
daughterPi = "pi0";
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Delta pi - -------------
|
||||
// ------------ Delta pi - -------------
|
||||
// determine daughters
|
||||
if (iIso3 == +3) {
|
||||
r= 0.;
|
||||
} else if (iIso3 == +1) {
|
||||
daughterDelta = "delta++";
|
||||
r = br*6./15.0;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterDelta = "delta+";
|
||||
r = br*8./15.;
|
||||
} else {
|
||||
daughterDelta = "delta0";
|
||||
r = br*0.4;
|
||||
r = 0.;
|
||||
}
|
||||
else if (iIso3 == +1) {
|
||||
daughterDelta = "delta++";
|
||||
r = br * 6. / 15.0;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterDelta = "delta+";
|
||||
r = br * 8. / 15.;
|
||||
}
|
||||
else {
|
||||
daughterDelta = "delta0";
|
||||
r = br * 0.4;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
if (r>0.0) {
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
if (r > 0.0) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -461,24 +482,25 @@ G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
const char* G4ExcitedDeltaConstructor::name[] =
|
||||
// clang-format off
|
||||
const char* G4ExcitedDeltaConstructor::name[] =
|
||||
{
|
||||
"delta(1600)", "delta(1620)", "delta(1700)", "delta(1900)", "delta(1905)",
|
||||
"delta(1910)", "delta(1920)", "delta(1930)", "delta(1950)"
|
||||
};
|
||||
|
||||
const G4double G4ExcitedDeltaConstructor::mass[] =
|
||||
const G4double G4ExcitedDeltaConstructor::mass[] =
|
||||
{
|
||||
1.600*GeV, 1.630*GeV, 1.700*GeV, 1.900*GeV, 1.880*GeV,
|
||||
1.890*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV
|
||||
1.570*GeV, 1.610*GeV, 1.710*GeV, 1.860*GeV, 1.880*GeV,
|
||||
1.900*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV
|
||||
};
|
||||
|
||||
const G4double G4ExcitedDeltaConstructor::width[] = {
|
||||
320.0*MeV, 140.0*MeV, 300.0*MeV, 200.0*MeV, 330.0*MeV,
|
||||
280.0*MeV, 260.0*MeV, 360.0*MeV, 280.0*MeV
|
||||
250.0*MeV, 130.0*MeV, 300.0*MeV, 250.0*MeV, 330.0*MeV,
|
||||
300.0*MeV, 300.0*MeV, 300.0*MeV, 285.0*MeV
|
||||
};
|
||||
|
||||
const G4int G4ExcitedDeltaConstructor::iSpin[] =
|
||||
const G4int G4ExcitedDeltaConstructor::iSpin[] =
|
||||
{
|
||||
3, 1, 3, 1, 5,
|
||||
1, 3, 5, 7
|
||||
@@ -494,7 +516,7 @@ const G4int G4ExcitedDeltaConstructor::encodingOffset[] = {
|
||||
20000, 20000, 10000, 0
|
||||
};
|
||||
|
||||
const G4double G4ExcitedDeltaConstructor::bRatio[ G4ExcitedDeltaConstructor::NStates ][ G4ExcitedDeltaConstructor::NumberOfDecayModes] =
|
||||
const G4double G4ExcitedDeltaConstructor::bRatio[ G4ExcitedDeltaConstructor::NStates ][ G4ExcitedDeltaConstructor::NumberOfDecayModes] =
|
||||
{
|
||||
// NGamma Npi NRho DeltaPi N*Pi
|
||||
{ 0.0, 0.15, 0.0, 0.55, 0.30 },
|
||||
@@ -507,19 +529,3 @@ const G4double G4ExcitedDeltaConstructor::bRatio[ G4ExcitedDeltaConstructor::NSt
|
||||
{ 0.0, 0.20, 0.25, 0.25, 0.30 },
|
||||
{ 0.01, 0.44, 0.15, 0.20, 0.20 }
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -23,342 +23,327 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
//
|
||||
// Update mass and width following PDG 2023
|
||||
// 4 nov 2023 S.Okada
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedLambdaConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
|
||||
G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor()
|
||||
: G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
|
||||
{}
|
||||
|
||||
G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
|
||||
G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable(
|
||||
const G4String& parentName,
|
||||
G4int iIso3,
|
||||
G4int iState,
|
||||
G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
||||
G4int iState, G4bool fAnti)
|
||||
{
|
||||
// create decay table
|
||||
auto decayTable = new G4DecayTable();
|
||||
auto decayTable = new G4DecayTable();
|
||||
|
||||
G4double br;
|
||||
if ( (br=bRatio[iState][NK]) >0.0) {
|
||||
AddNKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NK]) > 0.0) {
|
||||
AddNKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NKStar]) >0.0) {
|
||||
AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NKStar]) > 0.0) {
|
||||
AddNKStarMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaPi]) >0.0) {
|
||||
AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaPi]) > 0.0) {
|
||||
AddSigmaPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
|
||||
AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaStarPi]) > 0.0) {
|
||||
AddSigmaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaGamma]) >0.0) {
|
||||
AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaGamma]) > 0.0) {
|
||||
AddLambdaGammaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaEta]) >0.0) {
|
||||
AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaEta]) > 0.0) {
|
||||
AddLambdaEtaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaOmega]) >0.0) {
|
||||
AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaOmega]) > 0.0) {
|
||||
AddLambdaOmegaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
return decayTable;
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaGammaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaGammaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent,
|
||||
G4double br, G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
if (fAnti) lambda = "anti_" + lambda;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
lambda,"gamma");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, lambda, "gamma");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaEtaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaEtaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
if (fAnti) lambda = "anti_" + lambda;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
lambda,"eta");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, lambda, "eta");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaOmegaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaOmegaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent,
|
||||
G4double br, G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
//
|
||||
G4String lambda = "lambda";
|
||||
if (fAnti) lambda = "anti_" + lambda;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
lambda,"omega");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, lambda, "omega");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddNKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddNKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br, G4int,
|
||||
G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterK;
|
||||
|
||||
// ------------ N K- ------------
|
||||
// ------------ N K- ------------
|
||||
// determine daughters
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon+";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ N K0 ------------
|
||||
// ------------ N K0 ------------
|
||||
// determine daughters
|
||||
daughterN = "neutron";
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_kaon0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddNKStarMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddNKStarMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterK;
|
||||
|
||||
// ------------ N K- ------------
|
||||
// ------------ N K- ------------
|
||||
// determine daughters
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterK = "k_star-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "k_star+";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ N K0 ------------
|
||||
// ------------ N K0 ------------
|
||||
// determine daughters
|
||||
daughterN = "neutron";
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_k_star0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "k_star0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterSigma;
|
||||
G4String daughterPi;
|
||||
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma0";
|
||||
daughterSigma = "sigma0";
|
||||
daughterPi = "pi0";
|
||||
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Sigma- pi + ------------
|
||||
// ------------ Sigma- pi + ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma-";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaStarPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int , G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaStarPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent,
|
||||
G4double br, G4int, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterSigma;
|
||||
G4String daughterPi;
|
||||
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma(1385)+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma(1385)0";
|
||||
daughterSigma = "sigma(1385)0";
|
||||
daughterPi = "pi0";
|
||||
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Sigma- pi + ------------
|
||||
// ------------ Sigma- pi + ------------
|
||||
// determine daughters
|
||||
daughterSigma = "sigma(1385)-";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3.0, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
|
||||
const char* G4ExcitedLambdaConstructor::name[] = {
|
||||
"lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)",
|
||||
"lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)",
|
||||
"lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)",
|
||||
"lambda(2100)","lambda(2110)"
|
||||
};
|
||||
|
||||
const G4double G4ExcitedLambdaConstructor::mass[] = {
|
||||
1.4051*GeV,1.5195*GeV, 1.600*GeV, 1.670*GeV, 1.690*GeV,
|
||||
1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV, 1.890*GeV,
|
||||
2.100*GeV, 2.110*GeV
|
||||
1.4051*GeV,1.5194*GeV, 1.600*GeV, 1.674*GeV, 1.690*GeV,
|
||||
1.800*GeV, 1.790*GeV, 1.820*GeV, 1.825*GeV, 1.890*GeV,
|
||||
2.100*GeV, 2.090*GeV
|
||||
};
|
||||
|
||||
const G4double G4ExcitedLambdaConstructor::width[] = {
|
||||
50.5*MeV, 15.6*MeV, 150.0*MeV, 35.0*MeV, 60.0*MeV,
|
||||
300.0*MeV, 150.0*MeV, 80.0*MeV, 95.0*MeV, 100.0*MeV,
|
||||
200.0*MeV, 200.0*MeV
|
||||
50.5*MeV, 15.7*MeV, 2000.0*MeV, 30.0*MeV, 70.0*MeV,
|
||||
200.0*MeV, 110.0*MeV, 80.0*MeV, 90.0*MeV, 120.0*MeV,
|
||||
200.0*MeV, 250.0*MeV
|
||||
};
|
||||
|
||||
const G4int G4ExcitedLambdaConstructor::iSpin[] = {
|
||||
@@ -370,43 +355,27 @@ const G4int G4ExcitedLambdaConstructor::iSpin[] = {
|
||||
const G4int G4ExcitedLambdaConstructor::iParity[] = {
|
||||
-1, -1, +1, -1, -1,
|
||||
-1, +1, +1, -1, +1,
|
||||
-1, +1
|
||||
-1, +1
|
||||
};
|
||||
|
||||
const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
|
||||
10000, 0, 20000, 30000, 10000,
|
||||
40000, 50000, 0, 10000, 20000,
|
||||
40000, 50000, 0, 10000, 20000,
|
||||
0, 20000
|
||||
};
|
||||
|
||||
const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] =
|
||||
const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] =
|
||||
{
|
||||
{ 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{ 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0.0},
|
||||
{ 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0.0},
|
||||
{ 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0.0},
|
||||
{ 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0.0},
|
||||
{ 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0},
|
||||
{ 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0.0},
|
||||
{ 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0.0},
|
||||
{ 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0.0},
|
||||
{ 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0.0},
|
||||
{ 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0.08},
|
||||
{ 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{ 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0.0},
|
||||
{ 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0.0},
|
||||
{ 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0.0},
|
||||
{ 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0.0},
|
||||
{ 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0},
|
||||
{ 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0.0},
|
||||
{ 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0.0},
|
||||
{ 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0.0},
|
||||
{ 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0.0},
|
||||
{ 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0.08},
|
||||
{ 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0.0}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -23,9 +23,6 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// ----------------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
@@ -33,15 +30,9 @@
|
||||
// 4th April 1996, G.Cosmo
|
||||
// **********************************************************************
|
||||
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "G4ExcitedMesons.hh"
|
||||
|
||||
// ######################################################################
|
||||
// ### ExcitedMesons ###
|
||||
// ######################################################################
|
||||
|
||||
// clang-format off
|
||||
G4ExcitedMesons::G4ExcitedMesons(
|
||||
const G4String& aName, G4double mass,
|
||||
G4double width, G4double charge,
|
||||
|
||||
@@ -23,401 +23,407 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
//
|
||||
// Update mass and width following PDG 2023
|
||||
// 4 nov 2023 S.Okada
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedNucleonConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
|
||||
|
||||
G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor():
|
||||
G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
|
||||
{
|
||||
|
||||
}
|
||||
G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor()
|
||||
: G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
|
||||
{}
|
||||
|
||||
G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
|
||||
{
|
||||
G4int encoding;
|
||||
// Delta has exceptinal encoding
|
||||
if ((idxState==1)||(idxState==6)||(idxState==8)||(idxState==9)||(idxState==12) ) {
|
||||
if ((idxState == 1) // N(1520)
|
||||
|| (idxState == 6) // N(1700)
|
||||
|| (idxState == 8) // N(1720)
|
||||
|| (idxState == 9) // N(1900)
|
||||
|| (idxState == 12)) // N(2190)
|
||||
{
|
||||
encoding = GetEncodingOffset(idxState);
|
||||
if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
|
||||
// normal encoding
|
||||
encoding += 1000*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(2, iIsoSpin3);
|
||||
} else if (iIsoSpin3== +1){
|
||||
// 1st <--> 2nd quark
|
||||
encoding += 1000*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 100*GetQuarkContents(2, iIsoSpin3);
|
||||
} else if (iIsoSpin3== -1){
|
||||
// 1st <--> 0th quark
|
||||
encoding += 100*GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 1000*GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10*GetQuarkContents(2, iIsoSpin3);
|
||||
if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) {
|
||||
// normal encoding
|
||||
encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 100 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
encoding += GetiSpin(idxState) +1;
|
||||
} else {
|
||||
else if (iIsoSpin3 == +1) {
|
||||
// 1st <--> 2nd quark
|
||||
encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 100 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
else if (iIsoSpin3 == -1) {
|
||||
// 1st <--> 0th quark
|
||||
encoding += 100 * GetQuarkContents(0, iIsoSpin3);
|
||||
encoding += 1000 * GetQuarkContents(1, iIsoSpin3);
|
||||
encoding += 10 * GetQuarkContents(2, iIsoSpin3);
|
||||
}
|
||||
encoding += GetiSpin(idxState) + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
|
||||
}
|
||||
return encoding;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(
|
||||
const G4String& parentName,
|
||||
G4int iIso3,
|
||||
G4int iState,
|
||||
G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
||||
G4int iState, G4bool fAnti)
|
||||
{
|
||||
// create decay table
|
||||
auto decayTable = new G4DecayTable();
|
||||
auto decayTable = new G4DecayTable();
|
||||
|
||||
G4double br;
|
||||
if ( (br=bRatio[iState][NGamma]) >0.0) {
|
||||
AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NGamma]) > 0.0) {
|
||||
AddNGammaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NPi]) >0.0) {
|
||||
AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NPi]) > 0.0) {
|
||||
AddNPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NEta]) >0.0) {
|
||||
AddNEtaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NEta]) > 0.0) {
|
||||
AddNEtaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NOmega]) >0.0) {
|
||||
AddNOmegaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NOmega]) > 0.0) {
|
||||
AddNOmegaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NRho]) >0.0) {
|
||||
AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NRho]) > 0.0) {
|
||||
AddNRhoMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][N2Pi]) >0.0) {
|
||||
AddN2PiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][N2Pi]) > 0.0) {
|
||||
AddN2PiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][DeltaPi]) >0.0) {
|
||||
AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][DeltaPi]) > 0.0) {
|
||||
AddDeltaPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NStarPi]) >0.0) {
|
||||
AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NStarPi]) > 0.0) {
|
||||
AddNStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaK]) >0.0) {
|
||||
AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaK]) > 0.0) {
|
||||
AddLambdaKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
return decayTable;
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
//
|
||||
//
|
||||
G4String daughterN;
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterN,"gamma");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "gamma");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterPi;
|
||||
|
||||
// ------------ N pi0 ------------
|
||||
// ------------ N pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterPi = "pi0";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
daughterPi = "pi0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// -------------N pi +/- --------------
|
||||
// -------------N pi +/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
} else {
|
||||
daughterN = "proton";
|
||||
}
|
||||
else {
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
|
||||
// ------------ N eta------------
|
||||
// ------------ N eta------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
daughterN = "proton";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterN, "eta");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "eta");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
|
||||
// ------------ N omega------------
|
||||
// ------------ N omega------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
daughterN = "proton";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterN, "omega");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "omega");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterRho;
|
||||
|
||||
// ------------ N rho0 ------------
|
||||
// ------------ N rho0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterRho = "rho0";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
daughterRho = "rho0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterRho);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterRho);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// -------------N rho+/- --------------
|
||||
// -------------N rho+/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "neutron";
|
||||
daughterN = "neutron";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho-";
|
||||
}
|
||||
} else {
|
||||
daughterN = "proton";
|
||||
}
|
||||
else {
|
||||
daughterN = "proton";
|
||||
if (!fAnti) {
|
||||
daughterRho = "rho-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterRho = "rho+";
|
||||
}
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterRho);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterRho);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
// Decay Modes
|
||||
// N* --> N + pi + pi
|
||||
// Only I=0 states are included for 2-pi system
|
||||
|
||||
// Only I=0 states are included for 2-pi system
|
||||
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterPi1;
|
||||
G4String daughterPi2;
|
||||
|
||||
// -------------N pi+ pi- --------------
|
||||
// -------------N pi+ pi- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterPi1 = "pi+";
|
||||
daughterPi2 = "pi-";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
daughterPi1 = "pi+";
|
||||
daughterPi2 = "pi-";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
|
||||
daughterN,daughterPi1,daughterPi2);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 3, daughterN, daughterPi1, daughterPi2);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// -------------N pi0 pi0 --------------
|
||||
// -------------N pi0 pi0 --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "proton";
|
||||
daughterN = "proton";
|
||||
daughterPi1 = "pi0";
|
||||
daughterPi2 = "pi0";
|
||||
} else {
|
||||
daughterN = "neutron";
|
||||
}
|
||||
else {
|
||||
daughterN = "neutron";
|
||||
daughterPi1 = "pi0";
|
||||
daughterPi2 = "pi0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
|
||||
daughterN,daughterPi1,daughterPi2);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 3, daughterN, daughterPi1, daughterPi2);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String daughterN;
|
||||
G4String daughterPi;
|
||||
|
||||
// ------------ N pi0 ------------
|
||||
// ------------ N pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "N(1440)+";
|
||||
daughterN = "N(1440)+";
|
||||
daughterPi = "pi0";
|
||||
} else {
|
||||
daughterN = "N(1440)0";
|
||||
}
|
||||
else {
|
||||
daughterN = "N(1440)0";
|
||||
daughterPi = "pi0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// -------------N pi +/- --------------
|
||||
// -------------N pi +/- --------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterN = "N(1440)0";
|
||||
daughterN = "N(1440)0";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
} else {
|
||||
daughterN = "N(1440)+";
|
||||
}
|
||||
else {
|
||||
daughterN = "N(1440)+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
|
||||
daughterN,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -425,134 +431,143 @@ G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r;
|
||||
|
||||
// ------------ Delta pi+/- ------------
|
||||
// ------------ Delta pi+/- ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterDelta = "delta0";
|
||||
daughterDelta = "delta0";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br/6.0;
|
||||
} else {
|
||||
daughterDelta = "delta+";
|
||||
r = br / 6.0;
|
||||
}
|
||||
else {
|
||||
daughterDelta = "delta+";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br/6.0;
|
||||
r = br / 6.0;
|
||||
}
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Delta pi+/- ------------
|
||||
// ------------ Delta pi+/- ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterDelta = "delta++";
|
||||
daughterDelta = "delta++";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
r = br/2.0;
|
||||
} else {
|
||||
daughterDelta = "delta-";
|
||||
r = br / 2.0;
|
||||
}
|
||||
else {
|
||||
daughterDelta = "delta-";
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
r = br/2.0;
|
||||
r = br / 2.0;
|
||||
}
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
// ------------ Delta pi0 ------------
|
||||
// ------------ Delta pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterDelta = "delta+";
|
||||
daughterDelta = "delta+";
|
||||
daughterPi = "pi0";
|
||||
r = br/3.0;
|
||||
} else {
|
||||
daughterDelta = "delta0";
|
||||
r = br / 3.0;
|
||||
}
|
||||
else {
|
||||
daughterDelta = "delta0";
|
||||
daughterPi = "pi0";
|
||||
r = br/3.0;
|
||||
r = br / 3.0;
|
||||
}
|
||||
if (fAnti) daughterDelta = "anti_" + daughterDelta;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterDelta,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
G4String lambda = "lambda";
|
||||
G4String daughterK;
|
||||
|
||||
// ------------ N pi0 ------------
|
||||
// ------------ N pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon-";
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "anti_kaon0";
|
||||
}
|
||||
}
|
||||
if (fAnti) lambda = "anti_" + lambda;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
lambda, daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, lambda, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
|
||||
// PDG2005
|
||||
// N(2090) is renamed to N(2080)
|
||||
// N(2090) is renamed to N(2080)
|
||||
// but keep unchanged temporalily Apr 06
|
||||
//
|
||||
// -> PDG2023: N(2090) is removed by S.Okada 4 Nov. 2023.
|
||||
|
||||
const char* G4ExcitedNucleonConstructor::name[] = {
|
||||
"N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)",
|
||||
"N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)",
|
||||
"N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)",
|
||||
"N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)"
|
||||
};
|
||||
|
||||
const G4double G4ExcitedNucleonConstructor::mass[] = {
|
||||
1.430*GeV, 1.515*GeV, 1.535*GeV, 1.655*GeV, 1.675*GeV,
|
||||
1.685*GeV, 1.700*GeV, 1.710*GeV, 1.720*GeV, 1.900*GeV,
|
||||
1.950*GeV, 2.080*GeV, 2.190*GeV, 2.250*GeV, 2.275*GeV
|
||||
1.440*GeV, 1.515*GeV, 1.535*GeV, 1.650*GeV, 1.675*GeV,
|
||||
1.685*GeV, 1.720*GeV, 1.710*GeV, 1.720*GeV, 1.920*GeV,
|
||||
2.020*GeV, 2.080*GeV, 2.180*GeV, 2.250*GeV, 2.280*GeV
|
||||
};
|
||||
|
||||
const G4double G4ExcitedNucleonConstructor::width[] = {
|
||||
350.0*MeV, 115.0*MeV, 150.0*MeV, 140.0*MeV, 150.0*MeV,
|
||||
130.0*MeV, 150.0*MeV, 100.0*MeV, 250.0*MeV, 500.0*MeV,
|
||||
555.0*MeV, 350.0*MeV, 500.0*MeV, 400.0*MeV, 500.0*MeV
|
||||
350.0*MeV, 110.0*MeV, 150.0*MeV, 125.0*MeV, 145.0*MeV,
|
||||
120.0*MeV, 200.0*MeV, 140.0*MeV, 250.0*MeV, 200.0*MeV,
|
||||
300.0*MeV, 350.0*MeV, 400.0*MeV, 400.0*MeV, 500.0*MeV
|
||||
};
|
||||
|
||||
const G4int G4ExcitedNucleonConstructor::iSpin[] = {
|
||||
@@ -564,19 +579,19 @@ const G4int G4ExcitedNucleonConstructor::iSpin[] = {
|
||||
const G4int G4ExcitedNucleonConstructor::iParity[] = {
|
||||
+1, -1, -1, -1, -1,
|
||||
+1, -1, +1, +1, +1,
|
||||
+1, -1, +1, -1, -1
|
||||
+1, -1, +1, -1, -1
|
||||
};
|
||||
|
||||
const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
|
||||
10000, 0, 20000, 30000, 0,
|
||||
10000, 20000, 40000, 30000, 40000,
|
||||
10000, 50000, 0, 0, 10000
|
||||
10000, 20000, 40000, 30000, 40000,
|
||||
10000, 50000, 0, 0, 10000
|
||||
};
|
||||
|
||||
const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] =
|
||||
const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] =
|
||||
{
|
||||
{ 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0},
|
||||
{ 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0},
|
||||
{ 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0},
|
||||
{ 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0},
|
||||
{0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.00, 0.05, 0.0},
|
||||
{ 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.10, 0.05, 0.10},
|
||||
{ 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.55, 0.0, 0.0},
|
||||
@@ -591,19 +606,3 @@ const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor:
|
||||
{ 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.20, 0.0, 0.0},
|
||||
{ 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.20, 0.05, 0.0}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -23,107 +23,98 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
//
|
||||
// Update mass and width following PDG 2023
|
||||
// 4 nov 2023 S.Okada
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedSigmaConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
|
||||
G4ExcitedSigmaConstructor::G4ExcitedSigmaConstructor():
|
||||
G4ExcitedBaryonConstructor(NStates, SigmaIsoSpin)
|
||||
G4ExcitedSigmaConstructor::G4ExcitedSigmaConstructor()
|
||||
: G4ExcitedBaryonConstructor(NStates, SigmaIsoSpin)
|
||||
{}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
||||
G4int iState, G4bool fAnti)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::CreateDecayTable(
|
||||
const G4String& parentName,
|
||||
G4int iIso3,
|
||||
G4int iState,
|
||||
G4bool fAnti)
|
||||
{
|
||||
|
||||
// create decay table
|
||||
auto decayTable = new G4DecayTable();
|
||||
auto decayTable = new G4DecayTable();
|
||||
|
||||
G4double br;
|
||||
if ( (br=bRatio[iState][NK]) >0.0) {
|
||||
AddNKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NK]) > 0.0) {
|
||||
AddNKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][NKStar]) >0.0) {
|
||||
AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][NKStar]) > 0.0) {
|
||||
AddNKStarMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaPi]) >0.0) {
|
||||
AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaPi]) > 0.0) {
|
||||
AddSigmaPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
|
||||
AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaStarPi]) > 0.0) {
|
||||
AddSigmaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaPi]) >0.0) {
|
||||
AddLambdaPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaPi]) > 0.0) {
|
||||
AddLambdaPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaEta]) >0.0) {
|
||||
AddSigmaEtaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaEta]) > 0.0) {
|
||||
AddSigmaEtaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaStarPi]) >0.0) {
|
||||
AddLambdaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaStarPi]) > 0.0) {
|
||||
AddLambdaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][DeltaK]) >0.0) {
|
||||
AddDeltaKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][DeltaK]) > 0.0) {
|
||||
AddDeltaKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
return decayTable;
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaEtaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaEtaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
//
|
||||
G4String daughterH;
|
||||
if (iIso3== +2) {
|
||||
daughterH = "sigma+";
|
||||
} else if (iIso3== 0) {
|
||||
daughterH = "sigma0";
|
||||
} else if (iIso3== -2) {
|
||||
daughterH = "sigma-";
|
||||
}
|
||||
//
|
||||
G4String daughterH;
|
||||
if (iIso3 == +2) {
|
||||
daughterH = "sigma+";
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterH = "sigma0";
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterH = "sigma-";
|
||||
}
|
||||
if (fAnti) daughterH = "anti_" + daughterH;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterH,"eta");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterH, "eta");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
@@ -132,53 +123,56 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(
|
||||
G4String daughterK;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N K- ------------
|
||||
// ------------ N K- ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
r=0.;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "proton";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
daughterN = "neutron";
|
||||
if (iIso3 == +2) {
|
||||
r = 0.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "proton";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterN = "neutron";
|
||||
r = br;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon+";
|
||||
}
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ N K0 ------------
|
||||
// ------------ N K0 ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
daughterN = "proton";
|
||||
r=br;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "neutron";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterN = "proton";
|
||||
r = br;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "neutron";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_kaon0";
|
||||
} else {
|
||||
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -186,9 +180,9 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -196,56 +190,58 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(
|
||||
G4String daughterK;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N K- ------------
|
||||
// ------------ N K- ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
daughterN = "delta++";
|
||||
r=0.75*br;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "delta+";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
daughterN = "delta0";
|
||||
r = 0.25*br;
|
||||
if (iIso3 == +2) {
|
||||
daughterN = "delta++";
|
||||
r = 0.75 * br;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "delta+";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterN = "delta0";
|
||||
r = 0.25 * br;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon+";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ N K0 ------------
|
||||
// ------------ N K0 ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
daughterN = "delta+";
|
||||
r=0.25*br;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "delta0";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
daughterN = "delta-";
|
||||
r=0.75*br;
|
||||
if (iIso3 == +2) {
|
||||
daughterN = "delta+";
|
||||
r = 0.25 * br;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "delta0";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterN = "delta-";
|
||||
r = 0.75 * br;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_kaon0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
if (r>0.) {
|
||||
|
||||
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -253,10 +249,9 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -264,54 +259,57 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(
|
||||
G4String daughterK;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ N K- ------------
|
||||
// ------------ N K- ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
|
||||
r=0.;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "proton";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
daughterN = "neutron";
|
||||
if (iIso3 == +2) {
|
||||
r = 0.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "proton";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterN = "neutron";
|
||||
r = br;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "k_star-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "k_star+";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ N K0 ------------
|
||||
// ------------ N K0 ------------
|
||||
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
daughterN = "proton";
|
||||
r=br;
|
||||
} else if (iIso3== 0) {
|
||||
daughterN = "neutron";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterN = "proton";
|
||||
r = br;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterN = "neutron";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_k_star0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "k_star0";
|
||||
}
|
||||
if (fAnti) daughterN = "anti_" + daughterN;
|
||||
// create decay channel [parent BR #daughters]
|
||||
if (r>0.) {
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterN,daughterK);
|
||||
if (r > 0.) {
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -319,9 +317,9 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -329,74 +327,78 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
r = 0.;
|
||||
} else if (iIso3== 0) {
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterSigma = "sigma+";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterSigma = "sigma0";
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterSigma = "sigma+";
|
||||
r = br/2.;
|
||||
} else if (iIso3== 0) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
r = 0.;
|
||||
} else if (iIso3== -2) {
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterSigma = "sigma-";
|
||||
|
||||
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
daughterPi = "pi0";
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ Sigma- pi + ------------
|
||||
// ------------ Sigma- pi + ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterSigma = "sigma0";
|
||||
r = br/2.;
|
||||
} else if (iIso3== 0) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterSigma = "sigma-";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -404,86 +406,89 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaStarPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaStarPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
|
||||
G4String daughterSigma;
|
||||
G4String daughterPi;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// ------------ Sigma+ pi - ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
r = 0.;
|
||||
} else if (iIso3== 0) {
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterSigma = "sigma(1385)+";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterSigma = "sigma(1385)0";
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// ------------ Sigma0 Pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterSigma = "sigma(1385)+";
|
||||
r = br/2.;
|
||||
} else if (iIso3== 0) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
r = 0.;
|
||||
} else if (iIso3== -2) {
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
daughterSigma = "sigma(1385)-";
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
daughterPi = "pi0";
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ Sigma- pi + ------------
|
||||
// ------------ Sigma- pi + ------------
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
daughterSigma = "sigma(1385)0";
|
||||
r = br/2.;
|
||||
} else if (iIso3== 0) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterSigma = "sigma(1385)-";
|
||||
r = br/2.;
|
||||
} else if (iIso3== -2) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterSigma,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -491,9 +496,9 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaStarPiMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -501,34 +506,37 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(
|
||||
G4String daughterPi;
|
||||
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
} else if (iIso3== 0) {
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterPi = "pi0";
|
||||
} else if (iIso3== -2) {
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
}
|
||||
if (fAnti) daughterLambda = "anti_" + daughterLambda;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterLambda, daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterLambda, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaStarPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaStarPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -536,66 +544,74 @@ G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaStarPiMode(
|
||||
G4String daughterPi;
|
||||
|
||||
// determine daughters
|
||||
if (iIso3== +2) {
|
||||
if (iIso3 == +2) {
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
} else if (iIso3== 0) {
|
||||
}
|
||||
else if (iIso3 == 0) {
|
||||
daughterPi = "pi0";
|
||||
} else if (iIso3== -2) {
|
||||
}
|
||||
else if (iIso3 == -2) {
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
}
|
||||
|
||||
if (fAnti) daughterLambda = "anti_" + daughterLambda;
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterLambda,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterLambda, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
|
||||
G4double G4ExcitedSigmaConstructor::GetMass(G4int iState, G4int iso3)
|
||||
{
|
||||
{
|
||||
G4double fmass = mass[iState];
|
||||
if (iState == 0 ) {
|
||||
if (iso3== +2) fmass -= 0.9*MeV; // sigma+
|
||||
else if (iso3== -2) fmass += 3.5*MeV; // sigma-
|
||||
if (iState == 0) {
|
||||
if (iso3 == +2)
|
||||
fmass -= 0.9 * MeV; // sigma+
|
||||
else if (iso3 == -2)
|
||||
fmass += 3.5 * MeV; // sigma-
|
||||
}
|
||||
return fmass;
|
||||
}
|
||||
|
||||
G4double G4ExcitedSigmaConstructor::GetWidth(G4int iState, G4int iso3)
|
||||
{
|
||||
G4double fw=width[iState];
|
||||
if (iState == 0 ) {
|
||||
if (iso3== +2) fw = 36.0*MeV; // sigma+
|
||||
else if (iso3== -2) fw = 39.4*MeV; // sigma-
|
||||
G4double fw = width[iState];
|
||||
if (iState == 0) {
|
||||
if (iso3 == +2)
|
||||
fw = 36.0 * MeV; // sigma+
|
||||
else if (iso3 == -2)
|
||||
fw = 39.4 * MeV; // sigma-
|
||||
}
|
||||
return fw;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
|
||||
const char* G4ExcitedSigmaConstructor::name[] = {
|
||||
"sigma(1385)","sigma(1660)","sigma(1670)","sigma(1750)","sigma(1775)",
|
||||
"sigma(1915)","sigma(1940)","sigma(2030)"
|
||||
};
|
||||
|
||||
const G4double G4ExcitedSigmaConstructor::mass[] = {
|
||||
1.3837*GeV, 1.660*GeV, 1.670*GeV, 1.750*GeV, 1.775*GeV,
|
||||
1.3837*GeV, 1.660*GeV, 1.675*GeV, 1.750*GeV, 1.775*GeV,
|
||||
1.915*GeV, 1.940*GeV, 2.030*GeV
|
||||
};
|
||||
|
||||
const G4double G4ExcitedSigmaConstructor::width[] = {
|
||||
36.0*MeV, 100.0*MeV, 60.0*MeV, 90.0*MeV, 120.0*MeV,
|
||||
120.0*MeV, 220.0*MeV, 180.0*MeV
|
||||
36.0*MeV, 200.0*MeV, 70.0*MeV, 150.0*MeV, 120.0*MeV,
|
||||
120.0*MeV, 250.0*MeV, 180.0*MeV
|
||||
};
|
||||
|
||||
const G4int G4ExcitedSigmaConstructor::iSpin[] = {
|
||||
@@ -614,26 +630,15 @@ const G4int G4ExcitedSigmaConstructor::encodingOffset[] = {
|
||||
10000, 20000, 0
|
||||
};
|
||||
|
||||
const G4double G4ExcitedSigmaConstructor::bRatio[ G4ExcitedSigmaConstructor::NStates ][ G4ExcitedSigmaConstructor::NumberOfDecayModes] =
|
||||
const G4double G4ExcitedSigmaConstructor::bRatio[ G4ExcitedSigmaConstructor::NStates ][ G4ExcitedSigmaConstructor::NumberOfDecayModes] =
|
||||
{
|
||||
{ 0.0, 0.0, 0.12, 0.0, 0.88, 0.0, 0.0, 0.0},
|
||||
{ 0.30, 0.0, 0.35, 0.0, 0.35, 0.0, 0.0, 0.0},
|
||||
{ 0.15, 0.0, 0.70, 0.0, 0.15, 0.0, 0.0, 0.0},
|
||||
{ 0.40, 0.0, 0.05, 0.0, 0.0, 0.55, 0.0, 0.0},
|
||||
{ 0.40, 0.0, 0.04, 0.10, 0.23, 0.0, 0.23, 0.0},
|
||||
{ 0.15, 0.0, 0.40, 0.05, 0.40, 0.0, 0.0, 0.0},
|
||||
{ 0.10, 0.15, 0.15, 0.15, 0.15, 0.0, 0.15, 0.15},
|
||||
{ 0.20, 0.04, 0.10, 0.10, 0.20, 0.0, 0.18, 0.18}
|
||||
{ 0.0, 0.0, 0.12, 0.0, 0.88, 0.0, 0.0, 0.0},
|
||||
{ 0.30, 0.0, 0.35, 0.0, 0.35, 0.0, 0.0, 0.0},
|
||||
{ 0.15, 0.0, 0.70, 0.0, 0.15, 0.0, 0.0, 0.0},
|
||||
{ 0.40, 0.0, 0.05, 0.0, 0.0, 0.55, 0.0, 0.0},
|
||||
{ 0.40, 0.0, 0.04, 0.10, 0.23, 0.0, 0.23, 0.0},
|
||||
{ 0.15, 0.0, 0.40, 0.05, 0.40, 0.0, 0.0, 0.0},
|
||||
{ 0.10, 0.15, 0.15, 0.15, 0.15, 0.0, 0.15, 0.15},
|
||||
{ 0.20, 0.04, 0.10, 0.10, 0.20, 0.0, 0.18, 0.18}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -23,89 +23,76 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
// History: first implementation, based on object model of
|
||||
// 10 oct 1998 H.Kurashige
|
||||
//
|
||||
// Update mass and width following PDG 2023
|
||||
// 4 nov 2023 S.Okada
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
|
||||
#include "G4ExcitedXiConstructor.hh"
|
||||
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
#include "G4DecayTable.hh"
|
||||
#include "G4PhaseSpaceDecayChannel.hh"
|
||||
#include "G4SystemOfUnits.hh"
|
||||
#include "G4VDecayChannel.hh"
|
||||
|
||||
G4ExcitedXiConstructor::G4ExcitedXiConstructor():
|
||||
G4ExcitedBaryonConstructor(NStates, XiIsoSpin)
|
||||
G4ExcitedXiConstructor::G4ExcitedXiConstructor() : G4ExcitedBaryonConstructor(NStates, XiIsoSpin) {}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
||||
G4int iState, G4bool fAnti)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::CreateDecayTable(
|
||||
const G4String& parentName,
|
||||
G4int iIso3,
|
||||
G4int iState,
|
||||
G4bool fAnti)
|
||||
{
|
||||
|
||||
// create decay table
|
||||
auto decayTable = new G4DecayTable();
|
||||
auto decayTable = new G4DecayTable();
|
||||
|
||||
G4double br;
|
||||
if ( (br=bRatio[iState][XiPi]) >0.0) {
|
||||
AddXiPiMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][XiPi]) > 0.0) {
|
||||
AddXiPiMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][XiGamma]) >0.0) {
|
||||
AddXiGammaMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][XiGamma]) > 0.0) {
|
||||
AddXiGammaMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][LambdaK]) >0.0) {
|
||||
AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][LambdaK]) > 0.0) {
|
||||
AddLambdaKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
if ( (br=bRatio[iState][SigmaK]) >0.0) {
|
||||
AddSigmaKMode( decayTable, parentName, br, iIso3, fAnti);
|
||||
if ((br = bRatio[iState][SigmaK]) > 0.0) {
|
||||
AddSigmaKMode(decayTable, parentName, br, iIso3, fAnti);
|
||||
}
|
||||
|
||||
return decayTable;
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddXiGammaMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddXiGammaMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
//
|
||||
G4String daughterH;
|
||||
if (iIso3== +1) {
|
||||
daughterH = "xi0";
|
||||
} else if (iIso3==-1) {
|
||||
daughterH = "xi-";
|
||||
}
|
||||
G4String daughterH;
|
||||
if (iIso3 == +1) {
|
||||
daughterH = "xi0";
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterH = "xi-";
|
||||
}
|
||||
if (fAnti) daughterH = "anti_" + daughterH;
|
||||
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
|
||||
daughterH,"gamma");
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterH, "gamma");
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddLambdaKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddLambdaKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
@@ -114,28 +101,30 @@ G4DecayTable* G4ExcitedXiConstructor::AddLambdaKMode(
|
||||
G4String daughterK;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ Lambda K- ------------
|
||||
// ------------ Lambda K- ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "anti_kaon0";
|
||||
}
|
||||
}
|
||||
r = br;
|
||||
} else if (iIso3 == -1) {
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon+";
|
||||
}
|
||||
}
|
||||
r = br;
|
||||
}
|
||||
if (fAnti) lambda = "anti_" + lambda;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
lambda,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, lambda, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -143,9 +132,9 @@ G4DecayTable* G4ExcitedXiConstructor::AddLambdaKMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddSigmaKMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddSigmaKMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -153,48 +142,50 @@ G4DecayTable* G4ExcitedXiConstructor::AddSigmaKMode(
|
||||
G4String daughterK;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ Sigma K- ------------
|
||||
// ------------ Sigma K- ------------
|
||||
// determine daughters
|
||||
if (iIso3== +1) {
|
||||
daughterH = "sigma+";
|
||||
r= br/2.;
|
||||
} else if (iIso3== -1) {
|
||||
daughterH = "sigma0";
|
||||
r = br/2.;
|
||||
if (iIso3 == +1) {
|
||||
daughterH = "sigma+";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterH = "sigma0";
|
||||
r = br / 2.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "kaon-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon+";
|
||||
}
|
||||
if (fAnti) daughterH = "anti_" + daughterH;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterH,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterH, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ Sigma K0 ------------
|
||||
// ------------ Sigma K0 ------------
|
||||
// determine daughters
|
||||
if (iIso3 == +1) {
|
||||
daughterH = "sigma0";
|
||||
r= br/2.;
|
||||
} else if (iIso3 == -1) {
|
||||
daughterH = "sigma-";
|
||||
r = br/2.;
|
||||
daughterH = "sigma0";
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterH = "sigma-";
|
||||
r = br / 2.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterK = "anti_kaon0";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterK = "kaon0";
|
||||
}
|
||||
if (fAnti) daughterH = "anti_" + daughterH;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterH,daughterK);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterH, daughterK);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -202,9 +193,9 @@ G4DecayTable* G4ExcitedXiConstructor::AddSigmaKMode(
|
||||
return decayTable;
|
||||
}
|
||||
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddXiPiMode(
|
||||
G4DecayTable* decayTable, const G4String& nameParent,
|
||||
G4double br, G4int iIso3, G4bool fAnti)
|
||||
G4DecayTable* G4ExcitedXiConstructor::AddXiPiMode(G4DecayTable* decayTable,
|
||||
const G4String& nameParent, G4double br,
|
||||
G4int iIso3, G4bool fAnti)
|
||||
{
|
||||
G4VDecayChannel* mode;
|
||||
|
||||
@@ -212,64 +203,66 @@ G4DecayTable* G4ExcitedXiConstructor::AddXiPiMode(
|
||||
G4String daughterPi;
|
||||
G4double r = 0.;
|
||||
|
||||
// ------------ Xi pi- ------------
|
||||
// ------------ Xi pi- ------------
|
||||
// determine daughters
|
||||
if (iIso3== +1) {
|
||||
if (iIso3 == +1) {
|
||||
r = 0.;
|
||||
} else if (iIso3 == -1) {
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterXi = "xi0";
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi-";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi+";
|
||||
}
|
||||
if (fAnti) daughterXi = "anti_" + daughterXi;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterXi,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterXi, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
// ------------ Xi Pi0 ------------
|
||||
// ------------ Xi Pi0 ------------
|
||||
// determine daughters
|
||||
if (iIso3== +1) {
|
||||
if (iIso3 == +1) {
|
||||
daughterXi = "xi0";
|
||||
r = br/2.;
|
||||
} else if (iIso3 == -1) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
daughterXi = "xi-";
|
||||
r = br/2.;
|
||||
r = br / 2.;
|
||||
}
|
||||
daughterPi = "pi0";
|
||||
if (fAnti) daughterXi = "anti_" + daughterXi;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterXi,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterXi, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
|
||||
// ------------ XI pi + ------------
|
||||
// ------------ XI pi + ------------
|
||||
// determine daughters
|
||||
if (iIso3== +1) {
|
||||
if (iIso3 == +1) {
|
||||
daughterXi = "xi-";
|
||||
r = br/2.;
|
||||
} else if (iIso3==-1) {
|
||||
r = br / 2.;
|
||||
}
|
||||
else if (iIso3 == -1) {
|
||||
r = 0.;
|
||||
}
|
||||
if (!fAnti) {
|
||||
daughterPi = "pi+";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
daughterPi = "pi-";
|
||||
}
|
||||
if (fAnti) daughterXi = "anti_" + daughterXi;
|
||||
if (r>0.) {
|
||||
if (r > 0.) {
|
||||
// create decay channel [parent BR #daughters]
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
|
||||
daughterXi,daughterPi);
|
||||
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterXi, daughterPi);
|
||||
// add decay table
|
||||
decayTable->Insert(mode);
|
||||
}
|
||||
@@ -278,10 +271,10 @@ G4DecayTable* G4ExcitedXiConstructor::AddXiPiMode(
|
||||
}
|
||||
|
||||
G4double G4ExcitedXiConstructor::GetMass(G4int iState, G4int iso3)
|
||||
{
|
||||
{
|
||||
G4double fm = mass[iState];
|
||||
if ( iState==0 ) {
|
||||
if (iso3== -1) fm = 1.5350*GeV; // xi-
|
||||
if (iState == 0) {
|
||||
if (iso3 == -1) fm = 1.5350 * GeV; // xi-
|
||||
}
|
||||
return fm;
|
||||
}
|
||||
@@ -289,22 +282,24 @@ G4double G4ExcitedXiConstructor::GetMass(G4int iState, G4int iso3)
|
||||
G4double G4ExcitedXiConstructor::GetWidth(G4int iState, G4int iso3)
|
||||
{
|
||||
G4double fw = width[iState];
|
||||
if ( iState==0 ) {
|
||||
if (iso3== -1) fw = 9.9*MeV; // xi-
|
||||
if (iState == 0) {
|
||||
if (iso3 == -1) fw = 9.9 * MeV; // xi-
|
||||
}
|
||||
return fw;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
|
||||
const char* G4ExcitedXiConstructor::name[] = {
|
||||
"xi(1530)", "xi(1690)", "xi(1820)", "xi(1950)", "xi(2030)"
|
||||
};
|
||||
|
||||
const G4double G4ExcitedXiConstructor::mass[] = {
|
||||
1.5318*GeV, 1.690*GeV, 1.823*GeV, 1.950*GeV, 2.025*GeV
|
||||
1.5318*GeV, 1.690*GeV, 1.823*GeV, 1.950*GeV, 2.025*GeV
|
||||
};
|
||||
|
||||
const G4double G4ExcitedXiConstructor::width[] = {
|
||||
9.1*MeV, 50.0*MeV, 24.0*MeV, 60.0*MeV, 20.0*MeV
|
||||
9.1*MeV, 20.0*MeV, 24.0*MeV, 60.0*MeV, 20.0*MeV
|
||||
};
|
||||
|
||||
const G4int G4ExcitedXiConstructor::iSpin[] = {
|
||||
@@ -320,22 +315,11 @@ const G4int G4ExcitedXiConstructor::encodingOffset[] = {
|
||||
0, 20000, 10000, 30000, 10000
|
||||
};
|
||||
|
||||
const G4double G4ExcitedXiConstructor::bRatio[ G4ExcitedXiConstructor::NStates ][ G4ExcitedXiConstructor::NumberOfDecayModes] =
|
||||
const G4double G4ExcitedXiConstructor::bRatio[ G4ExcitedXiConstructor::NStates ][ G4ExcitedXiConstructor::NumberOfDecayModes] =
|
||||
{
|
||||
{ 0.98, 0.02, 0.0, 0.0},
|
||||
{ 0.10, 0.0, 0.70, 0.20},
|
||||
{ 0.15, 0.0, 0.70, 0.15},
|
||||
{ 0.25, 0.0, 0.50, 0.25},
|
||||
{ 0.98, 0.02, 0.0, 0.0},
|
||||
{ 0.10, 0.0, 0.70, 0.20},
|
||||
{ 0.15, 0.0, 0.70, 0.15},
|
||||
{ 0.25, 0.0, 0.50, 0.25},
|
||||
{ 0.10, 0.0, 0.20, 0.70}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -23,9 +23,6 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// ----------------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
@@ -33,15 +30,9 @@
|
||||
// 4th April 1996, G.Cosmo
|
||||
// **********************************************************************
|
||||
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "G4Gluons.hh"
|
||||
|
||||
// ######################################################################
|
||||
// ### Gluons ###
|
||||
// ######################################################################
|
||||
|
||||
// clang-format off
|
||||
G4Gluons::G4Gluons(
|
||||
const G4String& aName, G4double mass,
|
||||
G4double width, G4double charge,
|
||||
|
||||
@@ -23,9 +23,6 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// ----------------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
@@ -33,15 +30,9 @@
|
||||
// 4th April 1996, G.Cosmo
|
||||
// **********************************************************************
|
||||
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "G4Quarks.hh"
|
||||
|
||||
// ######################################################################
|
||||
// ### Quarks ###
|
||||
// ######################################################################
|
||||
|
||||
// clang-format off
|
||||
G4Quarks::G4Quarks(
|
||||
const G4String& aName, G4double mass,
|
||||
G4double width, G4double charge,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -23,11 +23,8 @@
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class implementation file
|
||||
// GEANT 4 class implementation file
|
||||
//
|
||||
// History: first implementation, based on object model of
|
||||
// 28 June 1998 H.Kurashige
|
||||
@@ -35,6 +32,7 @@
|
||||
|
||||
#include "G4VShortLivedParticle.hh"
|
||||
|
||||
// clang-format off
|
||||
G4VShortLivedParticle::G4VShortLivedParticle(const G4String& aName,
|
||||
G4double mass,
|
||||
G4double width,
|
||||
@@ -55,16 +53,15 @@ G4VShortLivedParticle::G4VShortLivedParticle(const G4String& aName,
|
||||
:G4ParticleDefinition( aName,mass,width,charge,iSpin,iParity,
|
||||
iConjugation,iIsospin,iIsospinZ,gParity,pType,
|
||||
lepton,baryon,encoding,stable,lifetime,decaytable, true)
|
||||
{
|
||||
|
||||
}
|
||||
// clang-format on
|
||||
{}
|
||||
|
||||
G4bool G4VShortLivedParticle::operator==(const G4VShortLivedParticle &right) const
|
||||
G4bool G4VShortLivedParticle::operator==(const G4VShortLivedParticle& right) const
|
||||
{
|
||||
return (this->GetParticleName() == right.GetParticleName());
|
||||
}
|
||||
|
||||
G4bool G4VShortLivedParticle::operator!=(const G4VShortLivedParticle &right) const
|
||||
G4bool G4VShortLivedParticle::operator!=(const G4VShortLivedParticle& right) const
|
||||
{
|
||||
return (this->GetParticleName() != right.GetParticleName());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user