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