Gabriele Cosmo
645 lines
17 KiB
C++
645 lines
17 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// --------------------------------------------------------------
|
|
// 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 "G4DecayTable.hh"
|
|
#include "G4PhaseSpaceDecayChannel.hh"
|
|
#include "G4SystemOfUnits.hh"
|
|
#include "G4VDecayChannel.hh"
|
|
|
|
G4ExcitedSigmaConstructor::G4ExcitedSigmaConstructor()
|
|
: G4ExcitedBaryonConstructor(NStates, SigmaIsoSpin)
|
|
{}
|
|
|
|
G4DecayTable* G4ExcitedSigmaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
|
|
G4int iState, G4bool fAnti)
|
|
{
|
|
// create decay table
|
|
auto decayTable = new G4DecayTable();
|
|
|
|
G4double br;
|
|
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][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][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][LambdaStarPi]) > 0.0) {
|
|
AddLambdaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
|
|
}
|
|
|
|
if ((br = bRatio[iState][DeltaK]) > 0.0) {
|
|
AddDeltaKMode(decayTable, parentName, br, iIso3, fAnti);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
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-";
|
|
}
|
|
if (fAnti) daughterH = "anti_" + daughterH;
|
|
|
|
// create decay channel [parent BR #daughters]
|
|
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)
|
|
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterN;
|
|
G4String daughterK;
|
|
G4double r = 0.;
|
|
|
|
// ------------ N K- ------------
|
|
// determine daughters
|
|
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 {
|
|
daughterK = "kaon+";
|
|
}
|
|
if (fAnti) daughterN = "anti_" + daughterN;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
// ------------ N K0 ------------
|
|
// determine daughters
|
|
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 {
|
|
daughterK = "kaon0";
|
|
}
|
|
if (fAnti) daughterN = "anti_" + daughterN;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(G4DecayTable* decayTable,
|
|
const G4String& nameParent, G4double br,
|
|
G4int iIso3, G4bool fAnti)
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterN;
|
|
G4String daughterK;
|
|
G4double r = 0.;
|
|
|
|
// ------------ 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 (!fAnti) {
|
|
daughterK = "kaon-";
|
|
}
|
|
else {
|
|
daughterK = "kaon+";
|
|
}
|
|
if (fAnti) daughterN = "anti_" + daughterN;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
// ------------ 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 (!fAnti) {
|
|
daughterK = "anti_kaon0";
|
|
}
|
|
else {
|
|
daughterK = "kaon0";
|
|
}
|
|
if (fAnti) daughterN = "anti_" + daughterN;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(G4DecayTable* decayTable,
|
|
const G4String& nameParent, G4double br,
|
|
G4int iIso3, G4bool fAnti)
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterN;
|
|
G4String daughterK;
|
|
G4double r = 0.;
|
|
|
|
// ------------ N K- ------------
|
|
// determine daughters
|
|
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 {
|
|
daughterK = "k_star+";
|
|
}
|
|
if (fAnti) daughterN = "anti_" + daughterN;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
// ------------ N K0 ------------
|
|
|
|
// determine daughters
|
|
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 {
|
|
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);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(G4DecayTable* decayTable,
|
|
const G4String& nameParent, G4double br,
|
|
G4int iIso3, G4bool fAnti)
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterSigma;
|
|
G4String daughterPi;
|
|
G4double r = 0.;
|
|
|
|
// ------------ Sigma+ pi - ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
r = 0.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterSigma = "sigma+";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
daughterSigma = "sigma0";
|
|
r = br / 2.;
|
|
}
|
|
if (!fAnti) {
|
|
daughterPi = "pi-";
|
|
}
|
|
else {
|
|
daughterPi = "pi+";
|
|
}
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
// ------------ Sigma0 Pi0 ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
daughterSigma = "sigma+";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
r = 0.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
daughterSigma = "sigma-";
|
|
|
|
r = br / 2.;
|
|
}
|
|
daughterPi = "pi0";
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
// ------------ Sigma- pi + ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
daughterSigma = "sigma0";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterSigma = "sigma-";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
r = 0.;
|
|
}
|
|
if (!fAnti) {
|
|
daughterPi = "pi+";
|
|
}
|
|
else {
|
|
daughterPi = "pi-";
|
|
}
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
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 - ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
r = 0.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterSigma = "sigma(1385)+";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
daughterSigma = "sigma(1385)0";
|
|
r = br / 2.;
|
|
}
|
|
if (!fAnti) {
|
|
daughterPi = "pi-";
|
|
}
|
|
else {
|
|
daughterPi = "pi+";
|
|
}
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
// ------------ Sigma0 Pi0 ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
daughterSigma = "sigma(1385)+";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
r = 0.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
daughterSigma = "sigma(1385)-";
|
|
r = br / 2.;
|
|
}
|
|
daughterPi = "pi0";
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
// ------------ Sigma- pi + ------------
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
daughterSigma = "sigma(1385)0";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterSigma = "sigma(1385)-";
|
|
r = br / 2.;
|
|
}
|
|
else if (iIso3 == -2) {
|
|
r = 0.;
|
|
}
|
|
if (!fAnti) {
|
|
daughterPi = "pi+";
|
|
}
|
|
else {
|
|
daughterPi = "pi-";
|
|
}
|
|
if (fAnti) daughterSigma = "anti_" + daughterSigma;
|
|
if (r > 0.) {
|
|
// create decay channel [parent BR #daughters]
|
|
|
|
mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
|
|
// add decay table
|
|
decayTable->Insert(mode);
|
|
}
|
|
|
|
return decayTable;
|
|
}
|
|
|
|
G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(G4DecayTable* decayTable,
|
|
const G4String& nameParent, G4double br,
|
|
G4int iIso3, G4bool fAnti)
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterLambda = "lambda";
|
|
G4String daughterPi;
|
|
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
if (!fAnti) {
|
|
daughterPi = "pi+";
|
|
}
|
|
else {
|
|
daughterPi = "pi-";
|
|
}
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterPi = "pi0";
|
|
}
|
|
else if (iIso3 == -2) {
|
|
if (!fAnti) {
|
|
daughterPi = "pi-";
|
|
}
|
|
else {
|
|
daughterPi = "pi+";
|
|
}
|
|
}
|
|
if (fAnti) daughterLambda = "anti_" + daughterLambda;
|
|
// create decay channel [parent BR #daughters]
|
|
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)
|
|
{
|
|
G4VDecayChannel* mode;
|
|
|
|
G4String daughterLambda = "lambda(1405)";
|
|
G4String daughterPi;
|
|
|
|
// determine daughters
|
|
if (iIso3 == +2) {
|
|
if (!fAnti) {
|
|
daughterPi = "pi+";
|
|
}
|
|
else {
|
|
daughterPi = "pi-";
|
|
}
|
|
}
|
|
else if (iIso3 == 0) {
|
|
daughterPi = "pi0";
|
|
}
|
|
else if (iIso3 == -2) {
|
|
if (!fAnti) {
|
|
daughterPi = "pi-";
|
|
}
|
|
else {
|
|
daughterPi = "pi+";
|
|
}
|
|
}
|
|
|
|
if (fAnti) daughterLambda = "anti_" + daughterLambda;
|
|
// create decay channel [parent BR #daughters]
|
|
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-
|
|
}
|
|
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-
|
|
}
|
|
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.675*GeV, 1.750*GeV, 1.775*GeV,
|
|
1.915*GeV, 1.940*GeV, 2.030*GeV
|
|
};
|
|
|
|
const G4double G4ExcitedSigmaConstructor::width[] = {
|
|
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[] = {
|
|
3, 1, 3, 1, 5,
|
|
5, 3, 7
|
|
};
|
|
|
|
const G4int G4ExcitedSigmaConstructor::iParity[] = {
|
|
+1, +1, -1, -1, -1,
|
|
+1, -1, +1
|
|
};
|
|
|
|
|
|
const G4int G4ExcitedSigmaConstructor::encodingOffset[] = {
|
|
0, 10000, 10000, 20000, 0,
|
|
10000, 20000, 0
|
|
};
|
|
|
|
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}
|
|
|
|
};
|