Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/shortlived/src/G4ExcitedLambdaConstructor.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/G4ExcitedLambdaConstructor.cc (Version 11.3.0) and /particles/shortlived/src/G4ExcitedLambdaConstructor.cc (Version 7.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 //
                                                   >>  24 // $Id: G4ExcitedLambdaConstructor.cc,v 1.8 2004/02/13 05:54:07 kurasige Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-07-00-patch-01 $
                                                   >>  26 //
                                                   >>  27 // 
 26 // -------------------------------------------     28 // --------------------------------------------------------------
 27 //  GEANT 4 class implementation file          <<  29 //  GEANT 4 class implementation file 
 28 //      History: first implementation, based o     30 //      History: first implementation, based on object model of
 29 //      10 oct 1998  H.Kurashige                   31 //      10 oct 1998  H.Kurashige
 30 //                                             << 
 31 //      Update mass and width following PDG 20 << 
 32 //        4 nov 2023 S.Okada                   << 
 33 // -------------------------------------------     32 // ---------------------------------------------------------------
 34                                                    33 
                                                   >>  34 
 35 #include "G4ExcitedLambdaConstructor.hh"           35 #include "G4ExcitedLambdaConstructor.hh"
 36                                                    36 
 37 #include "G4DecayTable.hh"                     <<  37 #include "G4ParticleDefinition.hh"
                                                   >>  38 #include "G4ParticleTable.hh"
                                                   >>  39 #include "G4ShortLivedTable.hh"
 38 #include "G4PhaseSpaceDecayChannel.hh"             40 #include "G4PhaseSpaceDecayChannel.hh"
 39 #include "G4SystemOfUnits.hh"                  << 
 40 #include "G4VDecayChannel.hh"                      41 #include "G4VDecayChannel.hh"
                                                   >>  42 #include "G4DecayTable.hh"
 41                                                    43 
 42 G4ExcitedLambdaConstructor::G4ExcitedLambdaCon << 
 43   : G4ExcitedBaryonConstructor(NStates, Lambda << 
 44 {}                                             << 
 45                                                    44 
 46 G4DecayTable* G4ExcitedLambdaConstructor::Crea <<  45 G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
 47                                                <<  46     G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
                                                   >>  47 {
                                                   >>  48 
                                                   >>  49 }
                                                   >>  50 
                                                   >>  51 G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor()
                                                   >>  52 {
                                                   >>  53 }
                                                   >>  54 
                                                   >>  55 G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable(
                                                   >>  56              const G4String&  parentName,  
                                                   >>  57              G4int iIso3, 
                                                   >>  58              G4int iState,
                                                   >>  59              G4bool fAnti)
 48 {                                                  60 {
 49   // create decay table                            61   // create decay table
 50   auto decayTable = new G4DecayTable();        <<  62   G4DecayTable* decayTable =  new G4DecayTable();
 51                                                    63 
 52   G4double br;                                     64   G4double br;
 53   if ((br = bRatio[iState][NK]) > 0.0) {       <<  65   if ( (br=bRatio[iState][NK]) >0.0) {
 54     AddNKMode(decayTable, parentName, br, iIso <<  66     AddNKMode( decayTable, parentName, br, iIso3, fAnti);
 55   }                                                67   }
 56                                                    68 
 57   if ((br = bRatio[iState][NKStar]) > 0.0) {   <<  69   if ( (br=bRatio[iState][NKStar]) >0.0) {
 58     AddNKStarMode(decayTable, parentName, br,  <<  70     AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
 59   }                                                71   }
 60                                                    72 
 61   if ((br = bRatio[iState][SigmaPi]) > 0.0) {  <<  73   if ( (br=bRatio[iState][SigmaPi]) >0.0) {
 62     AddSigmaPiMode(decayTable, parentName, br, <<  74     AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
 63   }                                                75   }
 64                                                    76 
 65   if ((br = bRatio[iState][SigmaStarPi]) > 0.0 <<  77   if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
 66     AddSigmaStarPiMode(decayTable, parentName, <<  78     AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
 67   }                                                79   }
 68                                                    80 
 69   if ((br = bRatio[iState][LambdaGamma]) > 0.0 <<  81   if ( (br=bRatio[iState][LambdaGamma]) >0.0) {
 70     AddLambdaGammaMode(decayTable, parentName, <<  82     AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti);
 71   }                                                83   }
 72                                                    84 
 73   if ((br = bRatio[iState][LambdaEta]) > 0.0)  <<  85   if ( (br=bRatio[iState][LambdaEta]) >0.0) {
 74     AddLambdaEtaMode(decayTable, parentName, b <<  86     AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti);
 75   }                                                87   }
 76                                                    88 
 77   if ((br = bRatio[iState][LambdaOmega]) > 0.0 <<  89   if ( (br=bRatio[iState][LambdaOmega]) >0.0) {
 78     AddLambdaOmegaMode(decayTable, parentName, <<  90     AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti);
 79   }                                                91   }
 80                                                    92 
 81   return decayTable;                           <<  93   return  decayTable;
 82 }                                                  94 }
 83                                                    95 
 84 G4DecayTable* G4ExcitedLambdaConstructor::AddL <<  96 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaGammaMode( 
 85                                                <<  97            G4DecayTable* decayTable, const G4String& nameParent,
 86                                                <<  98             G4double br, G4int , G4bool fAnti)
 87 {                                                  99 {
 88   G4VDecayChannel* mode;                          100   G4VDecayChannel* mode;
 89                                                   101 
 90   //                                           << 102   // 
 91   G4String lambda = "lambda";                  << 103   G4String lambda = "lambda";  
 92   if (fAnti) lambda = "anti_" + lambda;           104   if (fAnti) lambda = "anti_" + lambda;
 93                                                   105 
 94   // create decay channel  [parent    BR     #    106   // create decay channel  [parent    BR     #daughters]
 95   mode = new G4PhaseSpaceDecayChannel(namePare << 107   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 108                                            lambda,"gamma");
 96   // add decay table                              109   // add decay table
 97   decayTable->Insert(mode);                       110   decayTable->Insert(mode);
 98                                                   111 
 99   return decayTable;                              112   return decayTable;
100 }                                                 113 }
101 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 114 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaEtaMode( 
102                                                << 115            G4DecayTable* decayTable, const G4String& nameParent,
103                                                << 116             G4double br, G4int , G4bool fAnti)
104 {                                                 117 {
105   G4VDecayChannel* mode;                          118   G4VDecayChannel* mode;
106                                                   119 
107   //                                           << 120   // 
108   G4String lambda = "lambda";                  << 121   G4String lambda = "lambda";  
109   if (fAnti) lambda = "anti_" + lambda;           122   if (fAnti) lambda = "anti_" + lambda;
110                                                   123 
111   // create decay channel  [parent    BR     #    124   // create decay channel  [parent    BR     #daughters]
112   mode = new G4PhaseSpaceDecayChannel(namePare << 125   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 126                                            lambda,"eta");
113   // add decay table                              127   // add decay table
114   decayTable->Insert(mode);                       128   decayTable->Insert(mode);
115                                                   129 
116   return decayTable;                              130   return decayTable;
117 }                                                 131 }
118                                                   132 
119 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 133 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaOmegaMode( 
120                                                << 134            G4DecayTable* decayTable, const G4String& nameParent,
121                                                << 135             G4double br, G4int , G4bool fAnti)
122 {                                                 136 {
123   G4VDecayChannel* mode;                          137   G4VDecayChannel* mode;
124                                                   138 
125   //                                           << 139   // 
126   G4String lambda = "lambda";                  << 140   G4String lambda = "lambda";  
127   if (fAnti) lambda = "anti_" + lambda;           141   if (fAnti) lambda = "anti_" + lambda;
128                                                   142 
129   // create decay channel  [parent    BR     #    143   // create decay channel  [parent    BR     #daughters]
130   mode = new G4PhaseSpaceDecayChannel(namePare << 144   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 145                                            lambda,"omega");
131   // add decay table                              146   // add decay table
132   decayTable->Insert(mode);                       147   decayTable->Insert(mode);
133                                                   148 
134   return decayTable;                              149   return decayTable;
135 }                                                 150 }
136                                                   151 
137 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 152 G4DecayTable*  G4ExcitedLambdaConstructor::AddNKMode( 
138                                                << 153             G4DecayTable* decayTable, const G4String& nameParent,
139                                                << 154             G4double br, G4int , G4bool fAnti)
140 {                                                 155 {
141   G4VDecayChannel* mode;                          156   G4VDecayChannel* mode;
142                                                   157 
143   G4String daughterN;                             158   G4String daughterN;
144   G4String daughterK;                             159   G4String daughterK;
145                                                   160 
146   // ------------ N K- ------------            << 161   // ------------ N K- ------------ 
147   // determine daughters                          162   // determine daughters
148   daughterN = "proton";                        << 163   daughterN  = "proton";
149   if (!fAnti) {                                   164   if (!fAnti) {
150     daughterK = "kaon-";                          165     daughterK = "kaon-";
151   }                                            << 166   } else {
152   else {                                       << 
153     daughterK = "kaon+";                          167     daughterK = "kaon+";
154   }                                               168   }
155   if (fAnti) daughterN = "anti_" + daughterN;     169   if (fAnti) daughterN = "anti_" + daughterN;
156   // create decay channel  [parent    BR     #    170   // create decay channel  [parent    BR     #daughters]
157   mode = new G4PhaseSpaceDecayChannel(namePare << 171   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 172                                            daughterN,daughterK);
158   // add decay table                              173   // add decay table
159   decayTable->Insert(mode);                       174   decayTable->Insert(mode);
160                                                   175 
161   // ------------ N K0 ------------            << 176   // ------------ N K0 ------------ 
162   // determine daughters                          177   // determine daughters
163   daughterN = "neutron";                       << 178   daughterN  = "neutron";
164   if (!fAnti) {                                   179   if (!fAnti) {
165     daughterK = "anti_kaon0";                     180     daughterK = "anti_kaon0";
166   }                                            << 181   } else {
167   else {                                       << 
168     daughterK = "kaon0";                          182     daughterK = "kaon0";
169   }                                               183   }
170   if (fAnti) daughterN = "anti_" + daughterN;     184   if (fAnti) daughterN = "anti_" + daughterN;
171   // create decay channel  [parent    BR     #    185   // create decay channel  [parent    BR     #daughters]
172   mode = new G4PhaseSpaceDecayChannel(namePare << 186   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 187                                            daughterN,daughterK);
173   // add decay table                              188   // add decay table
174   decayTable->Insert(mode);                       189   decayTable->Insert(mode);
175                                                   190 
                                                   >> 191 
176   return decayTable;                              192   return decayTable;
177 }                                                 193 }
178                                                   194 
179 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 195 G4DecayTable*  G4ExcitedLambdaConstructor::AddNKStarMode( 
180                                                << 196             G4DecayTable* decayTable, const G4String& nameParent,
181                                                << 197             G4double br, G4int , G4bool fAnti)
182 {                                                 198 {
183   G4VDecayChannel* mode;                          199   G4VDecayChannel* mode;
184                                                   200 
185   G4String daughterN;                             201   G4String daughterN;
186   G4String daughterK;                             202   G4String daughterK;
187                                                   203 
188   // ------------ N K- ------------            << 204   // ------------ N K- ------------ 
189   // determine daughters                          205   // determine daughters
190   daughterN = "proton";                        << 206   daughterN  = "proton";
191   if (!fAnti) {                                   207   if (!fAnti) {
192     daughterK = "k_star-";                        208     daughterK = "k_star-";
193   }                                            << 209   } else {
194   else {                                       << 
195     daughterK = "k_star+";                        210     daughterK = "k_star+";
196   }                                               211   }
197   if (fAnti) daughterN = "anti_" + daughterN;     212   if (fAnti) daughterN = "anti_" + daughterN;
198   // create decay channel  [parent    BR     #    213   // create decay channel  [parent    BR     #daughters]
199   mode = new G4PhaseSpaceDecayChannel(namePare << 214   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 215                                            daughterN,daughterK);
200   // add decay table                              216   // add decay table
201   decayTable->Insert(mode);                       217   decayTable->Insert(mode);
202                                                   218 
203   // ------------ N K0 ------------            << 219   // ------------ N K0 ------------ 
204   // determine daughters                          220   // determine daughters
205   daughterN = "neutron";                       << 221   daughterN  = "neutron";
206   if (!fAnti) {                                   222   if (!fAnti) {
207     daughterK = "anti_k_star0";                   223     daughterK = "anti_k_star0";
208   }                                            << 224   } else {
209   else {                                       << 
210     daughterK = "k_star0";                        225     daughterK = "k_star0";
211   }                                               226   }
212   if (fAnti) daughterN = "anti_" + daughterN;     227   if (fAnti) daughterN = "anti_" + daughterN;
213   // create decay channel  [parent    BR     #    228   // create decay channel  [parent    BR     #daughters]
214   mode = new G4PhaseSpaceDecayChannel(namePare << 229   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 230                                            daughterN,daughterK);
215   // add decay table                              231   // add decay table
216   decayTable->Insert(mode);                       232   decayTable->Insert(mode);
217                                                   233 
                                                   >> 234 
218   return decayTable;                              235   return decayTable;
219 }                                                 236 }
220                                                   237 
221 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 238 G4DecayTable*  G4ExcitedLambdaConstructor::AddSigmaPiMode( 
222                                                << 239             G4DecayTable* decayTable, const G4String& nameParent,
223                                                << 240             G4double br, G4int , G4bool fAnti)
224 {                                                 241 {
225   G4VDecayChannel* mode;                          242   G4VDecayChannel* mode;
226                                                   243 
227   G4String daughterSigma;                         244   G4String daughterSigma;
228   G4String daughterPi;                            245   G4String daughterPi;
229                                                   246 
230   // ------------ Sigma+ pi - ------------     << 247   // ------------ Sigma+ pi - ------------ 
231   // determine daughters                          248   // determine daughters
232   daughterSigma = "sigma+";                       249   daughterSigma = "sigma+";
233   if (!fAnti) {                                   250   if (!fAnti) {
234     daughterPi = "pi-";                           251     daughterPi = "pi-";
235   }                                            << 252   } else {
236   else {                                       << 
237     daughterPi = "pi+";                           253     daughterPi = "pi+";
238   }                                               254   }
239   if (fAnti) daughterSigma = "anti_" + daughte    255   if (fAnti) daughterSigma = "anti_" + daughterSigma;
240   // create decay channel  [parent    BR     #    256   // create decay channel  [parent    BR     #daughters]
241   mode = new G4PhaseSpaceDecayChannel(namePare << 257   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 258                                            daughterSigma,daughterPi);
242   // add decay table                              259   // add decay table
243   decayTable->Insert(mode);                       260   decayTable->Insert(mode);
244                                                   261 
245   // ------------ Sigma0 Pi0 ------------      << 262    // ------------ Sigma0 Pi0 ------------ 
246   // determine daughters                          263   // determine daughters
247   daughterSigma = "sigma0";                    << 264   daughterSigma  = "sigma0";
248   daughterPi = "pi0";                             265   daughterPi = "pi0";
249                                                   266 
250   if (fAnti) daughterSigma = "anti_" + daughte    267   if (fAnti) daughterSigma = "anti_" + daughterSigma;
251   // create decay channel  [parent    BR     #    268   // create decay channel  [parent    BR     #daughters]
252   mode = new G4PhaseSpaceDecayChannel(namePare << 269   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 270                                            daughterSigma,daughterPi);
253                                                   271 
254   // add decay table                              272   // add decay table
255   decayTable->Insert(mode);                       273   decayTable->Insert(mode);
256                                                   274 
257   // ------------ Sigma- pi + ------------     << 275   // ------------ Sigma- pi + ------------ 
258   // determine daughters                          276   // determine daughters
259   daughterSigma = "sigma-";                       277   daughterSigma = "sigma-";
260   if (!fAnti) {                                   278   if (!fAnti) {
261     daughterPi = "pi+";                           279     daughterPi = "pi+";
262   }                                            << 280   } else {
263   else {                                       << 
264     daughterPi = "pi-";                           281     daughterPi = "pi-";
265   }                                               282   }
266   if (fAnti) daughterSigma = "anti_" + daughte    283   if (fAnti) daughterSigma = "anti_" + daughterSigma;
267   // create decay channel  [parent    BR     #    284   // create decay channel  [parent    BR     #daughters]
268   mode = new G4PhaseSpaceDecayChannel(namePare << 285   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 286                                            daughterSigma,daughterPi);
269   // add decay table                              287   // add decay table
270   decayTable->Insert(mode);                       288   decayTable->Insert(mode);
271                                                   289 
272   return decayTable;                              290   return decayTable;
273 }                                                 291 }
274                                                   292 
275 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 293 
276                                                << 294 G4DecayTable*  G4ExcitedLambdaConstructor::AddSigmaStarPiMode( 
277                                                << 295             G4DecayTable* decayTable, const G4String& nameParent,
                                                   >> 296             G4double br, G4int , G4bool fAnti)
278 {                                                 297 {
279   G4VDecayChannel* mode;                          298   G4VDecayChannel* mode;
280                                                   299 
281   G4String daughterSigma;                         300   G4String daughterSigma;
282   G4String daughterPi;                            301   G4String daughterPi;
283                                                   302 
284   // ------------ Sigma+ pi - ------------     << 303   // ------------ Sigma+ pi - ------------ 
285   // determine daughters                          304   // determine daughters
286   daughterSigma = "sigma(1385)+";                 305   daughterSigma = "sigma(1385)+";
287   if (!fAnti) {                                   306   if (!fAnti) {
288     daughterPi = "pi-";                           307     daughterPi = "pi-";
289   }                                            << 308   } else {
290   else {                                       << 
291     daughterPi = "pi+";                           309     daughterPi = "pi+";
292   }                                               310   }
293   if (fAnti) daughterSigma = "anti_" + daughte    311   if (fAnti) daughterSigma = "anti_" + daughterSigma;
294   // create decay channel  [parent    BR     #    312   // create decay channel  [parent    BR     #daughters]
295   mode = new G4PhaseSpaceDecayChannel(namePare << 313   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 314                                            daughterSigma,daughterPi);
296   // add decay table                              315   // add decay table
297   decayTable->Insert(mode);                       316   decayTable->Insert(mode);
298                                                   317 
299   // ------------ Sigma0 Pi0 ------------      << 318    // ------------ Sigma0 Pi0 ------------ 
300   // determine daughters                          319   // determine daughters
301   daughterSigma = "sigma(1385)0";              << 320   daughterSigma  = "sigma(1385)0";
302   daughterPi = "pi0";                             321   daughterPi = "pi0";
303                                                   322 
304   if (fAnti) daughterSigma = "anti_" + daughte    323   if (fAnti) daughterSigma = "anti_" + daughterSigma;
305   // create decay channel  [parent    BR     #    324   // create decay channel  [parent    BR     #daughters]
306   mode = new G4PhaseSpaceDecayChannel(namePare << 325   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 326                                            daughterSigma,daughterPi);
307                                                   327 
308   // add decay table                              328   // add decay table
309   decayTable->Insert(mode);                       329   decayTable->Insert(mode);
310                                                   330 
311   // ------------ Sigma- pi + ------------     << 331   // ------------ Sigma- pi + ------------ 
312   // determine daughters                          332   // determine daughters
313   daughterSigma = "sigma(1385)-";                 333   daughterSigma = "sigma(1385)-";
314   if (!fAnti) {                                   334   if (!fAnti) {
315     daughterPi = "pi+";                           335     daughterPi = "pi+";
316   }                                            << 336   } else {
317   else {                                       << 
318     daughterPi = "pi-";                           337     daughterPi = "pi-";
319   }                                               338   }
320   if (fAnti) daughterSigma = "anti_" + daughte    339   if (fAnti) daughterSigma = "anti_" + daughterSigma;
321   // create decay channel  [parent    BR     #    340   // create decay channel  [parent    BR     #daughters]
322   mode = new G4PhaseSpaceDecayChannel(namePare << 341   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 342                                            daughterSigma,daughterPi);
323   // add decay table                              343   // add decay table
324   decayTable->Insert(mode);                       344   decayTable->Insert(mode);
325                                                   345 
326   return decayTable;                              346   return decayTable;
327 }                                                 347 }
328                                                   348 
329 // clang-format off                            << 
330                                                << 
331 const char* G4ExcitedLambdaConstructor::name[]    349 const char* G4ExcitedLambdaConstructor::name[] = {
332   "lambda(1405)","lambda(1520)","lambda(1600)" << 350   "lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)", 
333   "lambda(1800)","lambda(1810)","lambda(1820)"    351   "lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)",
334   "lambda(2100)","lambda(2110)"                   352   "lambda(2100)","lambda(2110)"
335 };                                                353 };
336                                                   354 
337 const G4double G4ExcitedLambdaConstructor::mas    355 const G4double G4ExcitedLambdaConstructor::mass[] = {
338   1.4051*GeV,1.5194*GeV, 1.600*GeV, 1.674*GeV, << 356   1.407*GeV,1.5195*GeV, 1.600*GeV, 1.670*GeV,  1.690*GeV, 
339    1.800*GeV, 1.790*GeV, 1.820*GeV, 1.825*GeV, << 357   1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV,  1.890*GeV, 
340    2.100*GeV, 2.090*GeV                        << 358   2.100*GeV, 2.110*GeV
341 };                                                359 };
342                                                   360 
343 const G4double G4ExcitedLambdaConstructor::wid    361 const G4double G4ExcitedLambdaConstructor::width[] = {
344    50.5*MeV,  15.7*MeV, 2000.0*MeV,  30.0*MeV, << 362    50.0*MeV,  15.6*MeV, 150.0*MeV,  35.0*MeV,  60.0*MeV,
345   200.0*MeV, 110.0*MeV,  80.0*MeV,  90.0*MeV,  << 363   300.0*MeV, 150.0*MeV,  80.0*MeV,  95.0*MeV, 100.0*MeV,
346   200.0*MeV, 250.0*MeV                         << 364   200.0*MeV, 200.0*MeV
347 };                                                365 };
348                                                   366 
349 const G4int G4ExcitedLambdaConstructor::iSpin[    367 const G4int G4ExcitedLambdaConstructor::iSpin[] = {
350     1,   3,   1,   1,   3,                        368     1,   3,   1,   1,   3,
351     1,   1,   5,   5,   3,                        369     1,   1,   5,   5,   3,
352     7,   5                                        370     7,   5
353 };                                                371 };
354                                                   372 
355 const G4int G4ExcitedLambdaConstructor::iParit    373 const G4int G4ExcitedLambdaConstructor::iParity[] = {
356   -1,  -1,   +1,  -1,  -1,                        374   -1,  -1,   +1,  -1,  -1,
357   -1,  +1,   +1,  -1,  +1,                        375   -1,  +1,   +1,  -1,  +1,
358   -1,  +1                                      << 376   -1,  +1 
359 };                                                377 };
360                                                   378 
361 const G4int G4ExcitedLambdaConstructor::encodi    379 const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
362   10000,     0, 20000, 30000, 10000,              380   10000,     0, 20000, 30000, 10000,
363   40000, 50000,     0, 10000, 20000,           << 381   40000, 50000,     0, 10000, 20000, 
364       0, 20000                                    382       0, 20000
365 };                                                383 };
366                                                   384 
367 const G4double G4ExcitedLambdaConstructor::bRa << 385 const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] = 
368 {                                                 386 {
369    {   0.0,  0.0,  1.0,  0.0,  0.0,   0.0,   0 << 387    {   0.0,  0.0,  1.0,  0.0,  0.0,   0.0,   0.0}, 
370    {  0.45,  0.0, 0.43, 0.11, 0.01,   0.0,   0 << 388    {  0.45,  0.0, 0.43, 0.11, 0.01,   0.0,   0.0}, 
371    {  0.35,  0.0, 0.65,  0.0,  0.0,   0.0,   0 << 389    {  0.35,  0.0, 0.65,  0.0,  0.0,   0.0,   0.0}, 
372    {  0.20,  0.0, 0.50,  0.0,  0.0,  0.30,   0 << 390    {  0.20,  0.0, 0.50,  0.0,  0.0,  0.30,   0.0}, 
373    {  0.25,  0.0, 0.45, 0.30,  0.0,   0.0,   0 << 391    {  0.25,  0.0, 0.45, 0.30,  0.0,   0.0,   0.0}, 
374    {  0.40, 0.20, 0.20, 0.20,  0.0,   0.0,   0 << 392    {  0.40, 0.20, 0.20, 0.20,  0.0,   0.0,   0.0}, 
375    {  0.35, 0.45, 0.15, 0.05,  0.0,   0.0,   0 << 393    {  0.35, 0.45, 0.15, 0.05,  0.0,   0.0,   0.0}, 
376    {  0.73,  0.0, 0.16, 0.11,  0.0,   0.0,   0 << 394    {  0.73,  0.0, 0.16, 0.11,  0.0,   0.0,   0.0}, 
377    {  0.10,  0.0, 0.70, 0.20,  0.0,   0.0,   0 << 395    {  0.10,  0.0, 0.70, 0.20,  0.0,   0.0,   0.0}, 
378    {  0.37, 0.21, 0.11, 0.31,  0.0,   0.0,   0 << 396    {  0.37, 0.21, 0.11, 0.31,  0.0,   0.0,   0.0}, 
379    {  0.35, 0.20, 0.05, 0.30,  0.0,  0.02,  0. << 397    {  0.35, 0.20, 0.05, 0.30,  0.0,  0.02,  0.08}, 
380    {  0.25, 0.45, 0.30,  0.0,  0.0,   0.0,   0    398    {  0.25, 0.45, 0.30,  0.0,  0.0,   0.0,   0.0}
381 };                                                399 };
                                                   >> 400 
                                                   >> 401 
                                                   >> 402 
                                                   >> 403 
                                                   >> 404 
                                                   >> 405 
                                                   >> 406 
                                                   >> 407 
                                                   >> 408 
                                                   >> 409 
                                                   >> 410 
                                                   >> 411 
                                                   >> 412 
                                                   >> 413 
                                                   >> 414 
                                                   >> 415 
382                                                   416