Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/shortlived/src/G4ExcitedNucleonConstructor.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /particles/shortlived/src/G4ExcitedNucleonConstructor.cc (Version 11.3.0) and /particles/shortlived/src/G4ExcitedNucleonConstructor.cc (Version 10.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 //
                                                   >>  27 // $Id: G4ExcitedNucleonConstructor.cc 72955 2013-08-14 14:23:14Z gcosmo $
                                                   >>  28 //
                                                   >>  29 // 
 26 // -------------------------------------------     30 // --------------------------------------------------------------
 27 //  GEANT 4 class implementation file          <<  31 //  GEANT 4 class implementation file 
 28 //      History: first implementation, based o     32 //      History: first implementation, based on object model of
 29 //      10 oct 1998  H.Kurashige                   33 //      10 oct 1998  H.Kurashige
 30 //                                             << 
 31 //      Update mass and width following PDG 20 << 
 32 //        4 nov 2023 S.Okada                   << 
 33 // -------------------------------------------     34 // ---------------------------------------------------------------
 34                                                    35 
                                                   >>  36 
 35 #include "G4ExcitedNucleonConstructor.hh"          37 #include "G4ExcitedNucleonConstructor.hh"
 36                                                    38 
 37 #include "G4DecayTable.hh"                     << 
 38 #include "G4PhaseSpaceDecayChannel.hh"         << 
 39 #include "G4SystemOfUnits.hh"                      39 #include "G4SystemOfUnits.hh"
                                                   >>  40 #include "G4ParticleDefinition.hh"
                                                   >>  41 #include "G4ParticleTable.hh"
                                                   >>  42 #include "G4PhaseSpaceDecayChannel.hh"
 40 #include "G4VDecayChannel.hh"                      43 #include "G4VDecayChannel.hh"
                                                   >>  44 #include "G4DecayTable.hh"
 41                                                    45 
 42 G4ExcitedNucleonConstructor::G4ExcitedNucleonC <<  46 
 43   : G4ExcitedBaryonConstructor(NStates, Nucleo <<  47 G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor():
 44 {}                                             <<  48     G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
                                                   >>  49 {
                                                   >>  50 
                                                   >>  51 }
                                                   >>  52 
                                                   >>  53 G4ExcitedNucleonConstructor::~G4ExcitedNucleonConstructor()
                                                   >>  54 {
                                                   >>  55 }
 45                                                    56 
 46 G4int G4ExcitedNucleonConstructor::GetEncoding     57 G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
 47 {                                                  58 {
 48   G4int encoding;                                  59   G4int encoding;
 49   // Delta has exceptinal encoding                 60   // Delta has exceptinal encoding
 50   if ((idxState == 1)      // N(1520)          <<  61   if ((idxState==1)||(idxState==6)||(idxState==8)||(idxState==9)||(idxState==12) )  {
 51       || (idxState == 6)   // N(1700)          << 
 52       || (idxState == 8)   // N(1720)          << 
 53       || (idxState == 9)   // N(1900)          << 
 54       || (idxState == 12)) // N(2190)          << 
 55   {                                            << 
 56     encoding = GetEncodingOffset(idxState);        62     encoding = GetEncodingOffset(idxState);
 57     if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) <<  63     if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
 58       // normal encoding                       <<  64       // normal encoding 
 59       encoding += 1000 * GetQuarkContents(0, i <<  65       encoding += 1000*GetQuarkContents(0, iIsoSpin3);
 60       encoding += 100 * GetQuarkContents(1, iI <<  66       encoding +=  100*GetQuarkContents(1, iIsoSpin3);
 61       encoding += 10 * GetQuarkContents(2, iIs <<  67       encoding +=   10*GetQuarkContents(2, iIsoSpin3);
 62     }                                          <<  68     } else if (iIsoSpin3== +1){
 63     else if (iIsoSpin3 == +1) {                <<  69       // 1st <--> 2nd quark 
 64       // 1st <--> 2nd quark                    <<  70       encoding += 1000*GetQuarkContents(0, iIsoSpin3);
 65       encoding += 1000 * GetQuarkContents(0, i <<  71       encoding +=   10*GetQuarkContents(1, iIsoSpin3);
 66       encoding += 10 * GetQuarkContents(1, iIs <<  72       encoding +=  100*GetQuarkContents(2, iIsoSpin3);
 67       encoding += 100 * GetQuarkContents(2, iI <<  73     } else if (iIsoSpin3== -1){
 68     }                                          <<  74       // 1st <--> 0th quark 
 69     else if (iIsoSpin3 == -1) {                <<  75       encoding +=  100*GetQuarkContents(0, iIsoSpin3);
 70       // 1st <--> 0th quark                    <<  76       encoding += 1000*GetQuarkContents(1, iIsoSpin3);
 71       encoding += 100 * GetQuarkContents(0, iI <<  77       encoding +=   10*GetQuarkContents(2, iIsoSpin3);
 72       encoding += 1000 * GetQuarkContents(1, i << 
 73       encoding += 10 * GetQuarkContents(2, iIs << 
 74     }                                              78     }
 75     encoding += GetiSpin(idxState) + 1;        <<  79     encoding += GetiSpin(idxState) +1;
 76   }                                            <<  80   } else {
 77   else                                         << 
 78   {                                            << 
 79     encoding = G4ExcitedBaryonConstructor::Get     81     encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
 80   }                                                82   }
 81   return encoding;                                 83   return encoding;
 82 }                                                  84 }
 83                                                    85 
 84 G4DecayTable* G4ExcitedNucleonConstructor::Cre <<  86 G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(
 85                                                <<  87              const G4String&  parentName,  
                                                   >>  88              G4int iIso3, 
                                                   >>  89              G4int iState,
                                                   >>  90              G4bool fAnti)
 86 {                                                  91 {
 87   // create decay table                            92   // create decay table
 88   auto decayTable = new G4DecayTable();        <<  93   G4DecayTable* decayTable =  new G4DecayTable();
 89                                                    94 
 90   G4double br;                                     95   G4double br;
 91   if ((br = bRatio[iState][NGamma]) > 0.0) {   <<  96   if ( (br=bRatio[iState][NGamma]) >0.0) {
 92     AddNGammaMode(decayTable, parentName, br,  <<  97     AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
 93   }                                                98   }
 94                                                    99 
 95   if ((br = bRatio[iState][NPi]) > 0.0) {      << 100   if ( (br=bRatio[iState][NPi]) >0.0) {
 96     AddNPiMode(decayTable, parentName, br, iIs << 101     AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
 97   }                                               102   }
 98                                                   103 
 99   if ((br = bRatio[iState][NEta]) > 0.0) {     << 104   if ( (br=bRatio[iState][NEta]) >0.0) {
100     AddNEtaMode(decayTable, parentName, br, iI << 105     AddNEtaMode( decayTable, parentName, br, iIso3, fAnti);
101   }                                               106   }
102                                                   107 
103   if ((br = bRatio[iState][NOmega]) > 0.0) {   << 108   if ( (br=bRatio[iState][NOmega]) >0.0) {
104     AddNOmegaMode(decayTable, parentName, br,  << 109     AddNOmegaMode( decayTable, parentName, br, iIso3, fAnti);
105   }                                               110   }
106                                                   111 
107   if ((br = bRatio[iState][NRho]) > 0.0) {     << 112   if ( (br=bRatio[iState][NRho]) >0.0) {
108     AddNRhoMode(decayTable, parentName, br, iI << 113     AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
109   }                                               114   }
110                                                   115 
111   if ((br = bRatio[iState][N2Pi]) > 0.0) {     << 116   if ( (br=bRatio[iState][N2Pi]) >0.0) {
112     AddN2PiMode(decayTable, parentName, br, iI << 117     AddN2PiMode( decayTable, parentName, br, iIso3, fAnti);
113   }                                               118   }
114                                                   119 
115   if ((br = bRatio[iState][DeltaPi]) > 0.0) {  << 120   if ( (br=bRatio[iState][DeltaPi]) >0.0) {
116     AddDeltaPiMode(decayTable, parentName, br, << 121     AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
117   }                                               122   }
118                                                   123 
119   if ((br = bRatio[iState][NStarPi]) > 0.0) {  << 124   if ( (br=bRatio[iState][NStarPi]) >0.0) {
120     AddNStarPiMode(decayTable, parentName, br, << 125     AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
121   }                                               126   }
122                                                   127 
123   if ((br = bRatio[iState][LambdaK]) > 0.0) {  << 128   if ( (br=bRatio[iState][LambdaK]) >0.0) {
124     AddLambdaKMode(decayTable, parentName, br, << 129     AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
125   }                                               130   }
126                                                   131 
127   return decayTable;                           << 132   return  decayTable;
128 }                                                 133 }
129                                                   134 
130 G4DecayTable* G4ExcitedNucleonConstructor::Add << 135 G4DecayTable*  G4ExcitedNucleonConstructor::AddNGammaMode( 
131                                                << 136            G4DecayTable* decayTable, const G4String& nameParent,
132                                                << 137             G4double br, G4int iIso3, G4bool fAnti)
133 {                                                 138 {
134   G4VDecayChannel* mode;                          139   G4VDecayChannel* mode;
135                                                   140 
136   //                                           << 141   // 
137   G4String daughterN;                             142   G4String daughterN;
138   if (iIso3 == +1) {                           << 143   if (iIso3 == +1) { 
139     daughterN = "proton";                      << 144     daughterN = "proton";  
140   }                                            << 145   } else {
141   else {                                       << 146     daughterN = "neutron"; 
142     daughterN = "neutron";                     << 147   } 
143   }                                            << 
144   if (fAnti) daughterN = "anti_" + daughterN;     148   if (fAnti) daughterN = "anti_" + daughterN;
145                                                   149 
146   // create decay channel  [parent    BR     #    150   // create decay channel  [parent    BR     #daughters]
147   mode = new G4PhaseSpaceDecayChannel(namePare << 151   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 152                                            daughterN,"gamma");
148   // add decay table                              153   // add decay table
149   decayTable->Insert(mode);                       154   decayTable->Insert(mode);
150                                                   155 
151   return decayTable;                              156   return decayTable;
152 }                                                 157 }
153                                                   158 
154 G4DecayTable* G4ExcitedNucleonConstructor::Add << 159 G4DecayTable*  G4ExcitedNucleonConstructor::AddNPiMode( 
155                                                << 160             G4DecayTable* decayTable, const G4String& nameParent,
156                                                << 161             G4double br, G4int iIso3, G4bool fAnti)
157 {                                                 162 {
158   G4VDecayChannel* mode;                          163   G4VDecayChannel* mode;
159                                                   164 
160   G4String daughterN;                             165   G4String daughterN;
161   G4String daughterPi;                            166   G4String daughterPi;
162                                                   167 
163   // ------------ N pi0 ------------           << 168   // ------------ N pi0 ------------ 
164   // determine daughters                          169   // determine daughters
165   if (iIso3 == +1) {                              170   if (iIso3 == +1) {
166     daughterN = "proton";                      << 171     daughterN  = "proton";
167     daughterPi = "pi0";                           172     daughterPi = "pi0";
168   }                                            << 173   } else {
169   else {                                       << 174     daughterN  = "neutron";
170     daughterN = "neutron";                     << 
171     daughterPi = "pi0";                           175     daughterPi = "pi0";
172   }                                               176   }
173   if (fAnti) daughterN = "anti_" + daughterN;     177   if (fAnti) daughterN = "anti_" + daughterN;
174   // create decay channel  [parent    BR     #    178   // create decay channel  [parent    BR     #daughters]
175   mode = new G4PhaseSpaceDecayChannel(namePare << 179   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 180                                            daughterN,daughterPi);
176   // add decay table                              181   // add decay table
177   decayTable->Insert(mode);                       182   decayTable->Insert(mode);
178                                                   183 
179   // -------------N pi +/- --------------      << 184   // -------------N pi +/- -------------- 
180   // determine daughters                          185   // determine daughters
181   if (iIso3 == +1) {                              186   if (iIso3 == +1) {
182     daughterN = "neutron";                     << 187     daughterN  = "neutron";
183     if (!fAnti) {                                 188     if (!fAnti) {
184       daughterPi = "pi+";                         189       daughterPi = "pi+";
185     }                                          << 190     } else {
186     else {                                     << 
187       daughterPi = "pi-";                         191       daughterPi = "pi-";
188     }                                             192     }
189   }                                            << 193   } else {
190   else {                                       << 194     daughterN  = "proton";
191     daughterN = "proton";                      << 
192     if (!fAnti) {                                 195     if (!fAnti) {
193       daughterPi = "pi-";                         196       daughterPi = "pi-";
194     }                                          << 197     } else {
195     else {                                     << 
196       daughterPi = "pi+";                         198       daughterPi = "pi+";
197     }                                             199     }
198   }                                               200   }
199   if (fAnti) daughterN = "anti_" + daughterN;     201   if (fAnti) daughterN = "anti_" + daughterN;
200                                                   202 
201   // create decay channel  [parent    BR     #    203   // create decay channel  [parent    BR     #daughters]
202   mode = new G4PhaseSpaceDecayChannel(namePare << 204   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 205                                            daughterN,daughterPi);
203   // add decay table                              206   // add decay table
204   decayTable->Insert(mode);                       207   decayTable->Insert(mode);
205                                                   208 
206   return decayTable;                              209   return decayTable;
207 }                                                 210 }
208                                                   211 
209 G4DecayTable* G4ExcitedNucleonConstructor::Add << 212 G4DecayTable*  G4ExcitedNucleonConstructor::AddNEtaMode( 
210                                                << 213             G4DecayTable* decayTable, const G4String& nameParent,
211                                                << 214             G4double br, G4int iIso3, G4bool fAnti)
212 {                                                 215 {
213   G4VDecayChannel* mode;                          216   G4VDecayChannel* mode;
214                                                   217 
215   G4String daughterN;                             218   G4String daughterN;
216                                                   219 
217   // ------------ N eta------------            << 220   // ------------ N eta------------ 
218   // determine daughters                          221   // determine daughters
219   if (iIso3 == +1) {                              222   if (iIso3 == +1) {
220     daughterN = "proton";                      << 223     daughterN  = "proton";
221   }                                            << 224   } else {
222   else {                                       << 225     daughterN  = "neutron";
223     daughterN = "neutron";                     << 
224   }                                               226   }
225   if (fAnti) daughterN = "anti_" + daughterN;     227   if (fAnti) daughterN = "anti_" + daughterN;
226   // create decay channel  [parent    BR     #    228   // create decay channel  [parent    BR     #daughters]
227   mode = new G4PhaseSpaceDecayChannel(namePare << 229   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 230                                            daughterN, "eta");
228   // add decay table                              231   // add decay table
229   decayTable->Insert(mode);                       232   decayTable->Insert(mode);
230                                                   233 
231   return decayTable;                              234   return decayTable;
232 }                                                 235 }
233                                                   236 
234 G4DecayTable* G4ExcitedNucleonConstructor::Add << 237 G4DecayTable*  G4ExcitedNucleonConstructor::AddNOmegaMode( 
235                                                << 238             G4DecayTable* decayTable, const G4String& nameParent,
236                                                << 239             G4double br, G4int iIso3, G4bool fAnti)
237 {                                                 240 {
238   G4VDecayChannel* mode;                          241   G4VDecayChannel* mode;
239                                                   242 
240   G4String daughterN;                             243   G4String daughterN;
241                                                   244 
242   // ------------ N omega------------          << 245   // ------------ N omega------------ 
243   // determine daughters                          246   // determine daughters
244   if (iIso3 == +1) {                              247   if (iIso3 == +1) {
245     daughterN = "proton";                      << 248     daughterN  = "proton";
246   }                                            << 249   } else {
247   else {                                       << 250     daughterN  = "neutron";
248     daughterN = "neutron";                     << 
249   }                                               251   }
250   if (fAnti) daughterN = "anti_" + daughterN;     252   if (fAnti) daughterN = "anti_" + daughterN;
251   // create decay channel  [parent    BR     #    253   // create decay channel  [parent    BR     #daughters]
252   mode = new G4PhaseSpaceDecayChannel(namePare << 254   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 255                                            daughterN, "omega");
253   // add decay table                              256   // add decay table
254   decayTable->Insert(mode);                       257   decayTable->Insert(mode);
255                                                   258 
256   return decayTable;                              259   return decayTable;
257 }                                                 260 }
258                                                   261 
259 G4DecayTable* G4ExcitedNucleonConstructor::Add << 262 G4DecayTable*  G4ExcitedNucleonConstructor::AddNRhoMode( 
260                                                << 263             G4DecayTable* decayTable, const G4String& nameParent,
261                                                << 264             G4double br, G4int iIso3, G4bool fAnti)
262 {                                                 265 {
263   G4VDecayChannel* mode;                          266   G4VDecayChannel* mode;
264                                                   267 
265   G4String daughterN;                             268   G4String daughterN;
266   G4String daughterRho;                           269   G4String daughterRho;
267                                                   270 
268   // ------------ N rho0 ------------          << 271   // ------------ N rho0 ------------ 
269   // determine daughters                          272   // determine daughters
270   if (iIso3 == +1) {                              273   if (iIso3 == +1) {
271     daughterN = "proton";                      << 274     daughterN  = "proton";
272     daughterRho = "rho0";                         275     daughterRho = "rho0";
273   }                                            << 276   } else {
274   else {                                       << 277     daughterN  = "neutron";
275     daughterN = "neutron";                     << 
276     daughterRho = "rho0";                         278     daughterRho = "rho0";
277   }                                               279   }
278   if (fAnti) daughterN = "anti_" + daughterN;     280   if (fAnti) daughterN = "anti_" + daughterN;
279   // create decay channel  [parent    BR     #    281   // create decay channel  [parent    BR     #daughters]
280   mode = new G4PhaseSpaceDecayChannel(namePare << 282   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 283                                            daughterN,daughterRho);
281   // add decay table                              284   // add decay table
282   decayTable->Insert(mode);                       285   decayTable->Insert(mode);
283                                                   286 
284   // -------------N rho+/- --------------      << 287   // -------------N rho+/- -------------- 
285   // determine daughters                          288   // determine daughters
286   if (iIso3 == +1) {                              289   if (iIso3 == +1) {
287     daughterN = "neutron";                     << 290     daughterN  = "neutron";
288     if (!fAnti) {                                 291     if (!fAnti) {
289       daughterRho = "rho+";                       292       daughterRho = "rho+";
290     }                                          << 293     } else {
291     else {                                     << 
292       daughterRho = "rho-";                       294       daughterRho = "rho-";
293     }                                             295     }
294   }                                            << 296   } else {
295   else {                                       << 297     daughterN  = "proton";
296     daughterN = "proton";                      << 
297     if (!fAnti) {                                 298     if (!fAnti) {
298       daughterRho = "rho-";                       299       daughterRho = "rho-";
299     }                                          << 300     } else {
300     else {                                     << 
301       daughterRho = "rho+";                       301       daughterRho = "rho+";
302     }                                             302     }
303   }                                               303   }
304   if (fAnti) daughterN = "anti_" + daughterN;     304   if (fAnti) daughterN = "anti_" + daughterN;
305                                                   305 
306   // create decay channel  [parent    BR     #    306   // create decay channel  [parent    BR     #daughters]
307   mode = new G4PhaseSpaceDecayChannel(namePare << 307   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 308                                            daughterN,daughterRho);
308   // add decay table                              309   // add decay table
309   decayTable->Insert(mode);                       310   decayTable->Insert(mode);
310                                                   311 
311   return decayTable;                              312   return decayTable;
312 }                                                 313 }
313                                                   314 
314 G4DecayTable* G4ExcitedNucleonConstructor::Add << 315 G4DecayTable*  G4ExcitedNucleonConstructor::AddN2PiMode( 
315                                                << 316             G4DecayTable* decayTable, const G4String& nameParent,
316                                                << 317             G4double br, G4int iIso3, G4bool fAnti)
317 {                                                 318 {
318   // Decay Modes                                  319   // Decay Modes
319   //   N* --> N + pi + pi                         320   //   N* --> N + pi + pi
320   //     Only I=0 states are included for 2-pi << 321   //     Only I=0 states are included for 2-pi system 
321                                                << 322   
322   G4VDecayChannel* mode;                          323   G4VDecayChannel* mode;
323                                                   324 
324   G4String daughterN;                             325   G4String daughterN;
325   G4String daughterPi1;                           326   G4String daughterPi1;
326   G4String daughterPi2;                           327   G4String daughterPi2;
327                                                   328 
328   // -------------N pi+ pi- --------------     << 329   // -------------N pi+ pi- -------------- 
329   // determine daughters                          330   // determine daughters
330   if (iIso3 == +1) {                              331   if (iIso3 == +1) {
331     daughterN = "proton";                      << 332     daughterN  = "proton";
332     daughterPi1 = "pi+";                          333     daughterPi1 = "pi+";
333     daughterPi2 = "pi-";                          334     daughterPi2 = "pi-";
334   }                                            << 335   } else {
335   else {                                       << 336     daughterN  = "neutron";
336     daughterN = "neutron";                     << 
337     daughterPi1 = "pi+";                          337     daughterPi1 = "pi+";
338     daughterPi2 = "pi-";                          338     daughterPi2 = "pi-";
339   }                                               339   }
340   if (fAnti) daughterN = "anti_" + daughterN;     340   if (fAnti) daughterN = "anti_" + daughterN;
341                                                   341 
342   // create decay channel  [parent    BR     #    342   // create decay channel  [parent    BR     #daughters]
343   mode = new G4PhaseSpaceDecayChannel(namePare << 343   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
                                                   >> 344                                            daughterN,daughterPi1,daughterPi2);
344   // add decay table                              345   // add decay table
345   decayTable->Insert(mode);                       346   decayTable->Insert(mode);
346                                                   347 
347   // -------------N pi0 pi0 --------------     << 348   // -------------N pi0 pi0 --------------  
348   // determine daughters                          349   // determine daughters
349   if (iIso3 == +1) {                              350   if (iIso3 == +1) {
350     daughterN = "proton";                      << 351     daughterN  = "proton";
351     daughterPi1 = "pi0";                          352     daughterPi1 = "pi0";
352     daughterPi2 = "pi0";                          353     daughterPi2 = "pi0";
353   }                                            << 354   } else {
354   else {                                       << 355     daughterN  = "neutron";
355     daughterN = "neutron";                     << 
356     daughterPi1 = "pi0";                          356     daughterPi1 = "pi0";
357     daughterPi2 = "pi0";                          357     daughterPi2 = "pi0";
358   }                                               358   }
359   if (fAnti) daughterN = "anti_" + daughterN;     359   if (fAnti) daughterN = "anti_" + daughterN;
360                                                   360 
361   // create decay channel  [parent    BR     #    361   // create decay channel  [parent    BR     #daughters]
362   mode = new G4PhaseSpaceDecayChannel(namePare << 362   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
                                                   >> 363                                            daughterN,daughterPi1,daughterPi2);
363   // add decay table                              364   // add decay table
364   decayTable->Insert(mode);                       365   decayTable->Insert(mode);
365                                                   366 
366   return decayTable;                              367   return decayTable;
367 }                                                 368 }
368                                                   369 
369 G4DecayTable* G4ExcitedNucleonConstructor::Add << 370 G4DecayTable*  G4ExcitedNucleonConstructor::AddNStarPiMode( 
370                                                << 371             G4DecayTable* decayTable, const G4String& nameParent,
371                                                << 372             G4double br, G4int iIso3, G4bool fAnti)
372 {                                                 373 {
373   G4VDecayChannel* mode;                          374   G4VDecayChannel* mode;
374                                                   375 
375   G4String daughterN;                             376   G4String daughterN;
376   G4String daughterPi;                            377   G4String daughterPi;
377                                                   378 
378   // ------------ N pi0 ------------           << 379   // ------------ N pi0 ------------ 
379   // determine daughters                          380   // determine daughters
380   if (iIso3 == +1) {                              381   if (iIso3 == +1) {
381     daughterN = "N(1440)+";                    << 382     daughterN  = "N(1440)+";
382     daughterPi = "pi0";                           383     daughterPi = "pi0";
383   }                                            << 384   } else {
384   else {                                       << 385     daughterN  = "N(1440)0";
385     daughterN = "N(1440)0";                    << 
386     daughterPi = "pi0";                           386     daughterPi = "pi0";
387   }                                               387   }
388   if (fAnti) daughterN = "anti_" + daughterN;     388   if (fAnti) daughterN = "anti_" + daughterN;
389   // create decay channel  [parent    BR     #    389   // create decay channel  [parent    BR     #daughters]
390   mode = new G4PhaseSpaceDecayChannel(namePare << 390   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 391                                            daughterN,daughterPi);
391   // add decay table                              392   // add decay table
392   decayTable->Insert(mode);                       393   decayTable->Insert(mode);
393                                                   394 
394   // -------------N pi +/- --------------      << 395   // -------------N pi +/- -------------- 
395   // determine daughters                          396   // determine daughters
396   if (iIso3 == +1) {                              397   if (iIso3 == +1) {
397     daughterN = "N(1440)0";                    << 398     daughterN  = "N(1440)0";
398     if (!fAnti) {                                 399     if (!fAnti) {
399       daughterPi = "pi+";                         400       daughterPi = "pi+";
400     }                                          << 401     } else {
401     else {                                     << 
402       daughterPi = "pi-";                         402       daughterPi = "pi-";
403     }                                             403     }
404   }                                            << 404   } else {
405   else {                                       << 405     daughterN  = "N(1440)+";
406     daughterN = "N(1440)+";                    << 
407     if (!fAnti) {                                 406     if (!fAnti) {
408       daughterPi = "pi-";                         407       daughterPi = "pi-";
409     }                                          << 408     } else {
410     else {                                     << 
411       daughterPi = "pi+";                         409       daughterPi = "pi+";
412     }                                             410     }
413   }                                               411   }
414   if (fAnti) daughterN = "anti_" + daughterN;     412   if (fAnti) daughterN = "anti_" + daughterN;
415                                                   413 
416   // create decay channel  [parent    BR     #    414   // create decay channel  [parent    BR     #daughters]
417   mode = new G4PhaseSpaceDecayChannel(namePare << 415   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 416                                            daughterN,daughterPi);
418   // add decay table                              417   // add decay table
419   decayTable->Insert(mode);                       418   decayTable->Insert(mode);
420                                                   419 
421   return decayTable;                              420   return decayTable;
422 }                                                 421 }
423                                                   422 
424 G4DecayTable* G4ExcitedNucleonConstructor::Add << 423 G4DecayTable*  G4ExcitedNucleonConstructor::AddDeltaPiMode( 
425                                                << 424             G4DecayTable* decayTable, const G4String& nameParent,
426                                                << 425             G4double br, G4int iIso3, G4bool fAnti)
427 {                                                 426 {
428   G4VDecayChannel* mode;                          427   G4VDecayChannel* mode;
429                                                   428 
430   G4String daughterDelta;                         429   G4String daughterDelta;
431   G4String daughterPi;                            430   G4String daughterPi;
432   G4double r;                                     431   G4double r;
433                                                   432 
434   // ------------ Delta pi+/- ------------     << 433   // ------------ Delta pi+/- ------------ 
435   // determine daughters                          434   // determine daughters
436   if (iIso3 == +1) {                              435   if (iIso3 == +1) {
437     daughterDelta = "delta0";                  << 436     daughterDelta  = "delta0";
438     if (!fAnti) {                                 437     if (!fAnti) {
439       daughterPi = "pi+";                         438       daughterPi = "pi+";
440     }                                          << 439     } else {
441     else {                                     << 
442       daughterPi = "pi-";                         440       daughterPi = "pi-";
443     }                                             441     }
444     r = br / 6.0;                              << 442     r = br/6.0;
445   }                                            << 443   } else {
446   else {                                       << 444     daughterDelta  = "delta+";
447     daughterDelta = "delta+";                  << 
448     if (!fAnti) {                                 445     if (!fAnti) {
449       daughterPi = "pi-";                         446       daughterPi = "pi-";
450     }                                          << 447     } else {
451     else {                                     << 
452       daughterPi = "pi+";                         448       daughterPi = "pi+";
453     }                                             449     }
454     r = br / 6.0;                              << 450     r = br/6.0;
455   }                                               451   }
456   if (fAnti) daughterDelta = "anti_" + daughte    452   if (fAnti) daughterDelta = "anti_" + daughterDelta;
457   // create decay channel  [parent    BR     #    453   // create decay channel  [parent    BR     #daughters]
458   mode = new G4PhaseSpaceDecayChannel(namePare << 454   mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
                                                   >> 455                                            daughterDelta,daughterPi);
459   // add decay table                              456   // add decay table
460   decayTable->Insert(mode);                       457   decayTable->Insert(mode);
461                                                   458 
462   // ------------ Delta pi+/- ------------     << 459   // ------------ Delta pi+/- ------------ 
463   // determine daughters                          460   // determine daughters
464   if (iIso3 == +1) {                              461   if (iIso3 == +1) {
465     daughterDelta = "delta++";                 << 462     daughterDelta  = "delta++";
466     if (!fAnti) {                                 463     if (!fAnti) {
467       daughterPi = "pi-";                         464       daughterPi = "pi-";
468     }                                          << 465     } else {
469     else {                                     << 
470       daughterPi = "pi+";                         466       daughterPi = "pi+";
471     }                                             467     }
472     r = br / 2.0;                              << 468     r = br/2.0;
473   }                                            << 469   } else {
474   else {                                       << 470     daughterDelta  = "delta-";
475     daughterDelta = "delta-";                  << 
476     if (!fAnti) {                                 471     if (!fAnti) {
477       daughterPi = "pi+";                         472       daughterPi = "pi+";
478     }                                          << 473     } else {
479     else {                                     << 
480       daughterPi = "pi-";                         474       daughterPi = "pi-";
481     }                                             475     }
482     r = br / 2.0;                              << 476     r = br/2.0;
483   }                                               477   }
484   if (fAnti) daughterDelta = "anti_" + daughte    478   if (fAnti) daughterDelta = "anti_" + daughterDelta;
485   // create decay channel  [parent    BR     #    479   // create decay channel  [parent    BR     #daughters]
486   mode = new G4PhaseSpaceDecayChannel(namePare << 480   mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
                                                   >> 481                                            daughterDelta,daughterPi);
487   // add decay table                              482   // add decay table
488   decayTable->Insert(mode);                       483   decayTable->Insert(mode);
489                                                   484 
490   // ------------ Delta pi0 ------------       << 485   // ------------ Delta pi0 ------------ 
491   // determine daughters                          486   // determine daughters
492   if (iIso3 == +1) {                              487   if (iIso3 == +1) {
493     daughterDelta = "delta+";                  << 488     daughterDelta  = "delta+";
494     daughterPi = "pi0";                           489     daughterPi = "pi0";
495     r = br / 3.0;                              << 490     r = br/3.0;
496   }                                            << 491   } else {
497   else {                                       << 492     daughterDelta  = "delta0";
498     daughterDelta = "delta0";                  << 
499     daughterPi = "pi0";                           493     daughterPi = "pi0";
500     r = br / 3.0;                              << 494     r = br/3.0;
501   }                                               495   }
502   if (fAnti) daughterDelta = "anti_" + daughte    496   if (fAnti) daughterDelta = "anti_" + daughterDelta;
503   // create decay channel  [parent    BR     #    497   // create decay channel  [parent    BR     #daughters]
504   mode = new G4PhaseSpaceDecayChannel(namePare << 498   mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
                                                   >> 499                                            daughterDelta,daughterPi);
505   // add decay table                              500   // add decay table
506   decayTable->Insert(mode);                       501   decayTable->Insert(mode);
507                                                   502 
                                                   >> 503 
508   return decayTable;                              504   return decayTable;
509 }                                                 505 }
510                                                   506 
511 G4DecayTable* G4ExcitedNucleonConstructor::Add << 507 G4DecayTable*  G4ExcitedNucleonConstructor::AddLambdaKMode( 
512                                                << 508             G4DecayTable* decayTable, const G4String& nameParent,
513                                                << 509             G4double br, G4int iIso3, G4bool fAnti)
514 {                                                 510 {
515   G4VDecayChannel* mode;                          511   G4VDecayChannel* mode;
516                                                   512 
517   G4String lambda = "lambda";                     513   G4String lambda = "lambda";
518   G4String daughterK;                             514   G4String daughterK;
519                                                   515 
520   // ------------ N pi0 ------------           << 516   // ------------ N pi0 ------------ 
521   // determine daughters                          517   // determine daughters
522   if (iIso3 == +1) {                              518   if (iIso3 == +1) {
523     if (!fAnti) {                                 519     if (!fAnti) {
524       daughterK = "kaon+";                        520       daughterK = "kaon+";
525     }                                          << 521     } else {
526     else {                                     << 
527       daughterK = "kaon-";                        522       daughterK = "kaon-";
528     }                                             523     }
529   }                                            << 524   } else {
530   else {                                       << 
531     if (!fAnti) {                                 525     if (!fAnti) {
532       daughterK = "kaon0";                        526       daughterK = "kaon0";
533     }                                          << 527     } else {
534     else {                                     << 
535       daughterK = "anti_kaon0";                   528       daughterK = "anti_kaon0";
536     }                                             529     }
537   }                                               530   }
538   if (fAnti) lambda = "anti_" + lambda;           531   if (fAnti) lambda = "anti_" + lambda;
539   // create decay channel  [parent    BR     #    532   // create decay channel  [parent    BR     #daughters]
540   mode = new G4PhaseSpaceDecayChannel(namePare << 533   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 534                                            lambda, daughterK);
541   // add decay table                              535   // add decay table
542   decayTable->Insert(mode);                       536   decayTable->Insert(mode);
543                                                   537 
544   return decayTable;                              538   return decayTable;
545 }                                                 539 }
546                                                   540 
547 // clang-format off                            << 
548                                                << 
549 // PDG2005                                        541 // PDG2005
550 //  N(2090) is renamed to N(2080)              << 542 //  N(2090) is renamed to N(2080) 
551 //   but keep unchanged temporalily Apr 06        543 //   but keep unchanged temporalily Apr 06
552 //                                             << 
553 // -> PDG2023: N(2090) is removed by S.Okada 4 << 
554                                                   544 
555 const char* G4ExcitedNucleonConstructor::name[    545 const char* G4ExcitedNucleonConstructor::name[] = {
556    "N(1440)", "N(1520)", "N(1535)", "N(1650)",    546    "N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)",
557    "N(1680)", "N(1700)", "N(1710)", "N(1720)", << 547    "N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)", 
558    "N(1990)", "N(2090)", "N(2190)", "N(2220)",    548    "N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)"
559 };                                                549 };
560                                                   550 
561 const G4double G4ExcitedNucleonConstructor::ma    551 const G4double G4ExcitedNucleonConstructor::mass[] = {
562   1.440*GeV, 1.515*GeV, 1.535*GeV, 1.650*GeV,  << 552   1.440*GeV, 1.520*GeV, 1.535*GeV, 1.655*GeV,  1.675*GeV, 
563   1.685*GeV, 1.720*GeV, 1.710*GeV, 1.720*GeV,  << 553   1.685*GeV, 1.700*GeV, 1.710*GeV, 1.720*GeV,  1.900*GeV, 
564   2.020*GeV, 2.080*GeV, 2.180*GeV, 2.250*GeV,  << 554   1.950*GeV, 2.080*GeV, 2.190*GeV, 2.250*GeV,  2.275*GeV
565 };                                                555 };
566                                                   556 
567 const G4double G4ExcitedNucleonConstructor::wi    557 const G4double G4ExcitedNucleonConstructor::width[] = {
568   350.0*MeV, 110.0*MeV, 150.0*MeV, 125.0*MeV,  << 558   300.0*MeV, 115.0*MeV, 150.0*MeV, 165.0*MeV, 150.0*MeV,
569   120.0*MeV, 200.0*MeV, 140.0*MeV, 250.0*MeV,  << 559   130.0*MeV, 100.0*MeV, 100.0*MeV, 200.0*MeV, 500.0*MeV,
570   300.0*MeV, 350.0*MeV, 400.0*MeV, 400.0*MeV,  << 560   555.0*MeV, 350.0*MeV, 500.0*MeV, 400.0*MeV, 500.0*MeV
571 };                                                561 };
572                                                   562 
573 const G4int G4ExcitedNucleonConstructor::iSpin    563 const G4int G4ExcitedNucleonConstructor::iSpin[] = {
574     1,   3,   1,   1,   5,                        564     1,   3,   1,   1,   5,
575     5,   3,   1,   3,   3,                        565     5,   3,   1,   3,   3,
576     7,   3,   7,   9,   9                         566     7,   3,   7,   9,   9
577 };                                                567 };
578                                                   568 
579 const G4int G4ExcitedNucleonConstructor::iPari    569 const G4int G4ExcitedNucleonConstructor::iParity[] = {
580   +1,  -1,   -1,  -1,  -1,                        570   +1,  -1,   -1,  -1,  -1,
581   +1,  -1,   +1,  +1,  +1,                        571   +1,  -1,   +1,  +1,  +1,
582   +1,  -1,   +1,  -1,  -1                      << 572   +1,  -1,   +1,  -1,  -1 
583 };                                                573 };
584                                                   574 
585 const G4int G4ExcitedNucleonConstructor::encod    575 const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
586    10000,       0,  20000,  30000,       0,       576    10000,       0,  20000,  30000,       0,
587    10000,   20000,  40000,  30000,   40000,    << 577    10000,   20000,  40000,  30000,   40000, 
588    10000,   50000,      0,     0,   10000      << 578    10000,   50000,       0,     0,   10000
589 };                                                579 };
590                                                   580 
591 const G4double G4ExcitedNucleonConstructor::bR << 581 const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] = 
592 {                                                 582 {
593    {  0.0, 0.70,  0.0,  0.0,  0.0,  0.05,  0.2 << 583    {  0.0, 0.70,  0.0,  0.0,  0.0,  0.05,  0.25,  0.0,  0.0}, 
594    {  0.0, 0.60,  0.0,  0.0,  0.0,  0.15,  0.2 << 584    {  0.0, 0.60,  0.0,  0.0,  0.0,  0.15,  0.25,  0.0,  0.0}, 
595    {0.001, 0.55, 0.35,  0.0,  0.0,  0.05,  0.0    585    {0.001, 0.55, 0.35,  0.0,  0.0,  0.05,  0.00, 0.05,  0.0},
596    {  0.0, 0.65, 0.05,  0.0,  0.0,  0.05,  0.1    586    {  0.0, 0.65, 0.05,  0.0,  0.0,  0.05,  0.10, 0.05, 0.10},
597    {  0.0, 0.45,  0.0,  0.0,  0.0,  0.00,  0.5    587    {  0.0, 0.45,  0.0,  0.0,  0.0,  0.00,  0.55,  0.0,  0.0},
598    {  0.0, 0.65,  0.0,  0.0,  0.0,  0.20,  0.1    588    {  0.0, 0.65,  0.0,  0.0,  0.0,  0.20,  0.15,  0.0,  0.0},
599    {  0.0, 0.10, 0.05,  0.0, 0.05,  0.45,  0.3    589    {  0.0, 0.10, 0.05,  0.0, 0.05,  0.45,  0.35,  0.0,  0.0},
600    {  0.0, 0.15, 0.20,  0.0, 0.05,  0.20,  0.2    590    {  0.0, 0.15, 0.20,  0.0, 0.05,  0.20,  0.20, 0.10, 0.10},
601    {  0.0, 0.15, 0.00,  0.0, 0.25,  0.45,  0.1    591    {  0.0, 0.15, 0.00,  0.0, 0.25,  0.45,  0.10, 0.00, 0.05},
602    {  0.0, 0.35,  0.0, 0.55, 0.05,  0.00,  0.0    592    {  0.0, 0.35,  0.0, 0.55, 0.05,  0.00,  0.05,  0.0,  0.0},
603    {  0.0, 0.05,  0.0,  0.0, 0.15,  0.25,  0.3    593    {  0.0, 0.05,  0.0,  0.0, 0.15,  0.25,  0.30, 0.15, 0.10},
604    {  0.0, 0.60, 0.05,  0.0, 0.25,  0.05,  0.0    594    {  0.0, 0.60, 0.05,  0.0, 0.25,  0.05,  0.05,  0.0,  0.0},
605    {  0.0, 0.35,  0.0, 0.00, 0.30,  0.15,  0.1    595    {  0.0, 0.35,  0.0, 0.00, 0.30,  0.15,  0.15, 0.05,  0.0},
606    {  0.0, 0.35,  0.0,  0.0, 0.25,  0.20,  0.2    596    {  0.0, 0.35,  0.0,  0.0, 0.25,  0.20,  0.20,  0.0,  0.0},
607    {  0.0, 0.30,  0.0, 0.00, 0.25,  0.20,  0.2    597    {  0.0, 0.30,  0.0, 0.00, 0.25,  0.20,  0.20, 0.05,  0.0}
608 };                                                598 };
                                                   >> 599 
                                                   >> 600 
                                                   >> 601 
                                                   >> 602 
                                                   >> 603 
                                                   >> 604 
                                                   >> 605 
                                                   >> 606 
                                                   >> 607 
                                                   >> 608 
                                                   >> 609 
                                                   >> 610 
                                                   >> 611 
                                                   >> 612 
                                                   >> 613 
                                                   >> 614 
609                                                   615