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 11.1.1)


  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 //
                                                   >>  28 // 
 26 // -------------------------------------------     29 // --------------------------------------------------------------
 27 //  GEANT 4 class implementation file          <<  30 //  GEANT 4 class implementation file 
 28 //      History: first implementation, based o     31 //      History: first implementation, based on object model of
 29 //      10 oct 1998  H.Kurashige                   32 //      10 oct 1998  H.Kurashige
 30 //                                             << 
 31 //      Update mass and width following PDG 20 << 
 32 //        4 nov 2023 S.Okada                   << 
 33 // -------------------------------------------     33 // ---------------------------------------------------------------
 34                                                    34 
                                                   >>  35 
 35 #include "G4ExcitedLambdaConstructor.hh"           36 #include "G4ExcitedLambdaConstructor.hh"
 36                                                    37 
 37 #include "G4DecayTable.hh"                     << 
 38 #include "G4PhaseSpaceDecayChannel.hh"         << 
 39 #include "G4SystemOfUnits.hh"                      38 #include "G4SystemOfUnits.hh"
                                                   >>  39 #include "G4ParticleDefinition.hh"
                                                   >>  40 #include "G4ParticleTable.hh"
                                                   >>  41 #include "G4PhaseSpaceDecayChannel.hh"
 40 #include "G4VDecayChannel.hh"                      42 #include "G4VDecayChannel.hh"
                                                   >>  43 #include "G4DecayTable.hh"
                                                   >>  44 
                                                   >>  45 
                                                   >>  46 G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
                                                   >>  47     G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
                                                   >>  48 {
 41                                                    49 
 42 G4ExcitedLambdaConstructor::G4ExcitedLambdaCon <<  50 }
 43   : G4ExcitedBaryonConstructor(NStates, Lambda <<  51 
 44 {}                                             <<  52 G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor()
                                                   >>  53 {
                                                   >>  54 }
 45                                                    55 
 46 G4DecayTable* G4ExcitedLambdaConstructor::Crea <<  56 G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable(
 47                                                <<  57              const G4String&  parentName,  
                                                   >>  58              G4int iIso3, 
                                                   >>  59              G4int iState,
                                                   >>  60              G4bool fAnti)
 48 {                                                  61 {
 49   // create decay table                            62   // create decay table
 50   auto decayTable = new G4DecayTable();        <<  63   G4DecayTable* decayTable =  new G4DecayTable();
 51                                                    64 
 52   G4double br;                                     65   G4double br;
 53   if ((br = bRatio[iState][NK]) > 0.0) {       <<  66   if ( (br=bRatio[iState][NK]) >0.0) {
 54     AddNKMode(decayTable, parentName, br, iIso <<  67     AddNKMode( decayTable, parentName, br, iIso3, fAnti);
 55   }                                                68   }
 56                                                    69 
 57   if ((br = bRatio[iState][NKStar]) > 0.0) {   <<  70   if ( (br=bRatio[iState][NKStar]) >0.0) {
 58     AddNKStarMode(decayTable, parentName, br,  <<  71     AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
 59   }                                                72   }
 60                                                    73 
 61   if ((br = bRatio[iState][SigmaPi]) > 0.0) {  <<  74   if ( (br=bRatio[iState][SigmaPi]) >0.0) {
 62     AddSigmaPiMode(decayTable, parentName, br, <<  75     AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
 63   }                                                76   }
 64                                                    77 
 65   if ((br = bRatio[iState][SigmaStarPi]) > 0.0 <<  78   if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
 66     AddSigmaStarPiMode(decayTable, parentName, <<  79     AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
 67   }                                                80   }
 68                                                    81 
 69   if ((br = bRatio[iState][LambdaGamma]) > 0.0 <<  82   if ( (br=bRatio[iState][LambdaGamma]) >0.0) {
 70     AddLambdaGammaMode(decayTable, parentName, <<  83     AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti);
 71   }                                                84   }
 72                                                    85 
 73   if ((br = bRatio[iState][LambdaEta]) > 0.0)  <<  86   if ( (br=bRatio[iState][LambdaEta]) >0.0) {
 74     AddLambdaEtaMode(decayTable, parentName, b <<  87     AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti);
 75   }                                                88   }
 76                                                    89 
 77   if ((br = bRatio[iState][LambdaOmega]) > 0.0 <<  90   if ( (br=bRatio[iState][LambdaOmega]) >0.0) {
 78     AddLambdaOmegaMode(decayTable, parentName, <<  91     AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti);
 79   }                                                92   }
 80                                                    93 
 81   return decayTable;                           <<  94   return  decayTable;
 82 }                                                  95 }
 83                                                    96 
 84 G4DecayTable* G4ExcitedLambdaConstructor::AddL <<  97 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaGammaMode( 
 85                                                <<  98            G4DecayTable* decayTable, const G4String& nameParent,
 86                                                <<  99             G4double br, G4int , G4bool fAnti)
 87 {                                                 100 {
 88   G4VDecayChannel* mode;                          101   G4VDecayChannel* mode;
 89                                                   102 
 90   //                                           << 103   // 
 91   G4String lambda = "lambda";                  << 104   G4String lambda = "lambda";  
 92   if (fAnti) lambda = "anti_" + lambda;           105   if (fAnti) lambda = "anti_" + lambda;
 93                                                   106 
 94   // create decay channel  [parent    BR     #    107   // create decay channel  [parent    BR     #daughters]
 95   mode = new G4PhaseSpaceDecayChannel(namePare << 108   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 109                                            lambda,"gamma");
 96   // add decay table                              110   // add decay table
 97   decayTable->Insert(mode);                       111   decayTable->Insert(mode);
 98                                                   112 
 99   return decayTable;                              113   return decayTable;
100 }                                                 114 }
101 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 115 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaEtaMode( 
102                                                << 116            G4DecayTable* decayTable, const G4String& nameParent,
103                                                << 117             G4double br, G4int , G4bool fAnti)
104 {                                                 118 {
105   G4VDecayChannel* mode;                          119   G4VDecayChannel* mode;
106                                                   120 
107   //                                           << 121   // 
108   G4String lambda = "lambda";                  << 122   G4String lambda = "lambda";  
109   if (fAnti) lambda = "anti_" + lambda;           123   if (fAnti) lambda = "anti_" + lambda;
110                                                   124 
111   // create decay channel  [parent    BR     #    125   // create decay channel  [parent    BR     #daughters]
112   mode = new G4PhaseSpaceDecayChannel(namePare << 126   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 127                                            lambda,"eta");
113   // add decay table                              128   // add decay table
114   decayTable->Insert(mode);                       129   decayTable->Insert(mode);
115                                                   130 
116   return decayTable;                              131   return decayTable;
117 }                                                 132 }
118                                                   133 
119 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 134 G4DecayTable*  G4ExcitedLambdaConstructor::AddLambdaOmegaMode( 
120                                                << 135            G4DecayTable* decayTable, const G4String& nameParent,
121                                                << 136             G4double br, G4int , G4bool fAnti)
122 {                                                 137 {
123   G4VDecayChannel* mode;                          138   G4VDecayChannel* mode;
124                                                   139 
125   //                                           << 140   // 
126   G4String lambda = "lambda";                  << 141   G4String lambda = "lambda";  
127   if (fAnti) lambda = "anti_" + lambda;           142   if (fAnti) lambda = "anti_" + lambda;
128                                                   143 
129   // create decay channel  [parent    BR     #    144   // create decay channel  [parent    BR     #daughters]
130   mode = new G4PhaseSpaceDecayChannel(namePare << 145   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
                                                   >> 146                                            lambda,"omega");
131   // add decay table                              147   // add decay table
132   decayTable->Insert(mode);                       148   decayTable->Insert(mode);
133                                                   149 
134   return decayTable;                              150   return decayTable;
135 }                                                 151 }
136                                                   152 
137 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 153 G4DecayTable*  G4ExcitedLambdaConstructor::AddNKMode( 
138                                                << 154             G4DecayTable* decayTable, const G4String& nameParent,
139                                                << 155             G4double br, G4int , G4bool fAnti)
140 {                                                 156 {
141   G4VDecayChannel* mode;                          157   G4VDecayChannel* mode;
142                                                   158 
143   G4String daughterN;                             159   G4String daughterN;
144   G4String daughterK;                             160   G4String daughterK;
145                                                   161 
146   // ------------ N K- ------------            << 162   // ------------ N K- ------------ 
147   // determine daughters                          163   // determine daughters
148   daughterN = "proton";                        << 164   daughterN  = "proton";
149   if (!fAnti) {                                   165   if (!fAnti) {
150     daughterK = "kaon-";                          166     daughterK = "kaon-";
151   }                                            << 167   } else {
152   else {                                       << 
153     daughterK = "kaon+";                          168     daughterK = "kaon+";
154   }                                               169   }
155   if (fAnti) daughterN = "anti_" + daughterN;     170   if (fAnti) daughterN = "anti_" + daughterN;
156   // create decay channel  [parent    BR     #    171   // create decay channel  [parent    BR     #daughters]
157   mode = new G4PhaseSpaceDecayChannel(namePare << 172   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 173                                            daughterN,daughterK);
158   // add decay table                              174   // add decay table
159   decayTable->Insert(mode);                       175   decayTable->Insert(mode);
160                                                   176 
161   // ------------ N K0 ------------            << 177   // ------------ N K0 ------------ 
162   // determine daughters                          178   // determine daughters
163   daughterN = "neutron";                       << 179   daughterN  = "neutron";
164   if (!fAnti) {                                   180   if (!fAnti) {
165     daughterK = "anti_kaon0";                     181     daughterK = "anti_kaon0";
166   }                                            << 182   } else {
167   else {                                       << 
168     daughterK = "kaon0";                          183     daughterK = "kaon0";
169   }                                               184   }
170   if (fAnti) daughterN = "anti_" + daughterN;     185   if (fAnti) daughterN = "anti_" + daughterN;
171   // create decay channel  [parent    BR     #    186   // create decay channel  [parent    BR     #daughters]
172   mode = new G4PhaseSpaceDecayChannel(namePare << 187   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 188                                            daughterN,daughterK);
173   // add decay table                              189   // add decay table
174   decayTable->Insert(mode);                       190   decayTable->Insert(mode);
175                                                   191 
                                                   >> 192 
176   return decayTable;                              193   return decayTable;
177 }                                                 194 }
178                                                   195 
179 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 196 G4DecayTable*  G4ExcitedLambdaConstructor::AddNKStarMode( 
180                                                << 197             G4DecayTable* decayTable, const G4String& nameParent,
181                                                << 198             G4double br, G4int , G4bool fAnti)
182 {                                                 199 {
183   G4VDecayChannel* mode;                          200   G4VDecayChannel* mode;
184                                                   201 
185   G4String daughterN;                             202   G4String daughterN;
186   G4String daughterK;                             203   G4String daughterK;
187                                                   204 
188   // ------------ N K- ------------            << 205   // ------------ N K- ------------ 
189   // determine daughters                          206   // determine daughters
190   daughterN = "proton";                        << 207   daughterN  = "proton";
191   if (!fAnti) {                                   208   if (!fAnti) {
192     daughterK = "k_star-";                        209     daughterK = "k_star-";
193   }                                            << 210   } else {
194   else {                                       << 
195     daughterK = "k_star+";                        211     daughterK = "k_star+";
196   }                                               212   }
197   if (fAnti) daughterN = "anti_" + daughterN;     213   if (fAnti) daughterN = "anti_" + daughterN;
198   // create decay channel  [parent    BR     #    214   // create decay channel  [parent    BR     #daughters]
199   mode = new G4PhaseSpaceDecayChannel(namePare << 215   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 216                                            daughterN,daughterK);
200   // add decay table                              217   // add decay table
201   decayTable->Insert(mode);                       218   decayTable->Insert(mode);
202                                                   219 
203   // ------------ N K0 ------------            << 220   // ------------ N K0 ------------ 
204   // determine daughters                          221   // determine daughters
205   daughterN = "neutron";                       << 222   daughterN  = "neutron";
206   if (!fAnti) {                                   223   if (!fAnti) {
207     daughterK = "anti_k_star0";                   224     daughterK = "anti_k_star0";
208   }                                            << 225   } else {
209   else {                                       << 
210     daughterK = "k_star0";                        226     daughterK = "k_star0";
211   }                                               227   }
212   if (fAnti) daughterN = "anti_" + daughterN;     228   if (fAnti) daughterN = "anti_" + daughterN;
213   // create decay channel  [parent    BR     #    229   // create decay channel  [parent    BR     #daughters]
214   mode = new G4PhaseSpaceDecayChannel(namePare << 230   mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
                                                   >> 231                                            daughterN,daughterK);
215   // add decay table                              232   // add decay table
216   decayTable->Insert(mode);                       233   decayTable->Insert(mode);
217                                                   234 
                                                   >> 235 
218   return decayTable;                              236   return decayTable;
219 }                                                 237 }
220                                                   238 
221 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 239 G4DecayTable*  G4ExcitedLambdaConstructor::AddSigmaPiMode( 
222                                                << 240             G4DecayTable* decayTable, const G4String& nameParent,
223                                                << 241             G4double br, G4int , G4bool fAnti)
224 {                                                 242 {
225   G4VDecayChannel* mode;                          243   G4VDecayChannel* mode;
226                                                   244 
227   G4String daughterSigma;                         245   G4String daughterSigma;
228   G4String daughterPi;                            246   G4String daughterPi;
229                                                   247 
230   // ------------ Sigma+ pi - ------------     << 248   // ------------ Sigma+ pi - ------------ 
231   // determine daughters                          249   // determine daughters
232   daughterSigma = "sigma+";                       250   daughterSigma = "sigma+";
233   if (!fAnti) {                                   251   if (!fAnti) {
234     daughterPi = "pi-";                           252     daughterPi = "pi-";
235   }                                            << 253   } else {
236   else {                                       << 
237     daughterPi = "pi+";                           254     daughterPi = "pi+";
238   }                                               255   }
239   if (fAnti) daughterSigma = "anti_" + daughte    256   if (fAnti) daughterSigma = "anti_" + daughterSigma;
240   // create decay channel  [parent    BR     #    257   // create decay channel  [parent    BR     #daughters]
241   mode = new G4PhaseSpaceDecayChannel(namePare << 258   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 259                                            daughterSigma,daughterPi);
242   // add decay table                              260   // add decay table
243   decayTable->Insert(mode);                       261   decayTable->Insert(mode);
244                                                   262 
245   // ------------ Sigma0 Pi0 ------------      << 263    // ------------ Sigma0 Pi0 ------------ 
246   // determine daughters                          264   // determine daughters
247   daughterSigma = "sigma0";                    << 265   daughterSigma  = "sigma0";
248   daughterPi = "pi0";                             266   daughterPi = "pi0";
249                                                   267 
250   if (fAnti) daughterSigma = "anti_" + daughte    268   if (fAnti) daughterSigma = "anti_" + daughterSigma;
251   // create decay channel  [parent    BR     #    269   // create decay channel  [parent    BR     #daughters]
252   mode = new G4PhaseSpaceDecayChannel(namePare << 270   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 271                                            daughterSigma,daughterPi);
253                                                   272 
254   // add decay table                              273   // add decay table
255   decayTable->Insert(mode);                       274   decayTable->Insert(mode);
256                                                   275 
257   // ------------ Sigma- pi + ------------     << 276   // ------------ Sigma- pi + ------------ 
258   // determine daughters                          277   // determine daughters
259   daughterSigma = "sigma-";                       278   daughterSigma = "sigma-";
260   if (!fAnti) {                                   279   if (!fAnti) {
261     daughterPi = "pi+";                           280     daughterPi = "pi+";
262   }                                            << 281   } else {
263   else {                                       << 
264     daughterPi = "pi-";                           282     daughterPi = "pi-";
265   }                                               283   }
266   if (fAnti) daughterSigma = "anti_" + daughte    284   if (fAnti) daughterSigma = "anti_" + daughterSigma;
267   // create decay channel  [parent    BR     #    285   // create decay channel  [parent    BR     #daughters]
268   mode = new G4PhaseSpaceDecayChannel(namePare << 286   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 287                                            daughterSigma,daughterPi);
269   // add decay table                              288   // add decay table
270   decayTable->Insert(mode);                       289   decayTable->Insert(mode);
271                                                   290 
272   return decayTable;                              291   return decayTable;
273 }                                                 292 }
274                                                   293 
275 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 294 
276                                                << 295 G4DecayTable*  G4ExcitedLambdaConstructor::AddSigmaStarPiMode( 
277                                                << 296             G4DecayTable* decayTable, const G4String& nameParent,
                                                   >> 297             G4double br, G4int , G4bool fAnti)
278 {                                                 298 {
279   G4VDecayChannel* mode;                          299   G4VDecayChannel* mode;
280                                                   300 
281   G4String daughterSigma;                         301   G4String daughterSigma;
282   G4String daughterPi;                            302   G4String daughterPi;
283                                                   303 
284   // ------------ Sigma+ pi - ------------     << 304   // ------------ Sigma+ pi - ------------ 
285   // determine daughters                          305   // determine daughters
286   daughterSigma = "sigma(1385)+";                 306   daughterSigma = "sigma(1385)+";
287   if (!fAnti) {                                   307   if (!fAnti) {
288     daughterPi = "pi-";                           308     daughterPi = "pi-";
289   }                                            << 309   } else {
290   else {                                       << 
291     daughterPi = "pi+";                           310     daughterPi = "pi+";
292   }                                               311   }
293   if (fAnti) daughterSigma = "anti_" + daughte    312   if (fAnti) daughterSigma = "anti_" + daughterSigma;
294   // create decay channel  [parent    BR     #    313   // create decay channel  [parent    BR     #daughters]
295   mode = new G4PhaseSpaceDecayChannel(namePare << 314   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 315                                            daughterSigma,daughterPi);
296   // add decay table                              316   // add decay table
297   decayTable->Insert(mode);                       317   decayTable->Insert(mode);
298                                                   318 
299   // ------------ Sigma0 Pi0 ------------      << 319    // ------------ Sigma0 Pi0 ------------ 
300   // determine daughters                          320   // determine daughters
301   daughterSigma = "sigma(1385)0";              << 321   daughterSigma  = "sigma(1385)0";
302   daughterPi = "pi0";                             322   daughterPi = "pi0";
303                                                   323 
304   if (fAnti) daughterSigma = "anti_" + daughte    324   if (fAnti) daughterSigma = "anti_" + daughterSigma;
305   // create decay channel  [parent    BR     #    325   // create decay channel  [parent    BR     #daughters]
306   mode = new G4PhaseSpaceDecayChannel(namePare << 326   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 327                                            daughterSigma,daughterPi);
307                                                   328 
308   // add decay table                              329   // add decay table
309   decayTable->Insert(mode);                       330   decayTable->Insert(mode);
310                                                   331 
311   // ------------ Sigma- pi + ------------     << 332   // ------------ Sigma- pi + ------------ 
312   // determine daughters                          333   // determine daughters
313   daughterSigma = "sigma(1385)-";                 334   daughterSigma = "sigma(1385)-";
314   if (!fAnti) {                                   335   if (!fAnti) {
315     daughterPi = "pi+";                           336     daughterPi = "pi+";
316   }                                            << 337   } else {
317   else {                                       << 
318     daughterPi = "pi-";                           338     daughterPi = "pi-";
319   }                                               339   }
320   if (fAnti) daughterSigma = "anti_" + daughte    340   if (fAnti) daughterSigma = "anti_" + daughterSigma;
321   // create decay channel  [parent    BR     #    341   // create decay channel  [parent    BR     #daughters]
322   mode = new G4PhaseSpaceDecayChannel(namePare << 342   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
                                                   >> 343                                            daughterSigma,daughterPi);
323   // add decay table                              344   // add decay table
324   decayTable->Insert(mode);                       345   decayTable->Insert(mode);
325                                                   346 
326   return decayTable;                              347   return decayTable;
327 }                                                 348 }
328                                                   349 
329 // clang-format off                            << 
330                                                << 
331 const char* G4ExcitedLambdaConstructor::name[]    350 const char* G4ExcitedLambdaConstructor::name[] = {
332   "lambda(1405)","lambda(1520)","lambda(1600)" << 351   "lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)", 
333   "lambda(1800)","lambda(1810)","lambda(1820)"    352   "lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)",
334   "lambda(2100)","lambda(2110)"                   353   "lambda(2100)","lambda(2110)"
335 };                                                354 };
336                                                   355 
337 const G4double G4ExcitedLambdaConstructor::mas    356 const G4double G4ExcitedLambdaConstructor::mass[] = {
338   1.4051*GeV,1.5194*GeV, 1.600*GeV, 1.674*GeV, << 357   1.4051*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, << 358    1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV,  1.890*GeV, 
340    2.100*GeV, 2.090*GeV                        << 359    2.100*GeV, 2.110*GeV
341 };                                                360 };
342                                                   361 
343 const G4double G4ExcitedLambdaConstructor::wid    362 const G4double G4ExcitedLambdaConstructor::width[] = {
344    50.5*MeV,  15.7*MeV, 2000.0*MeV,  30.0*MeV, << 363    50.5*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,  << 364   300.0*MeV, 150.0*MeV,  80.0*MeV,  95.0*MeV, 100.0*MeV,
346   200.0*MeV, 250.0*MeV                         << 365   200.0*MeV, 200.0*MeV
347 };                                                366 };
348                                                   367 
349 const G4int G4ExcitedLambdaConstructor::iSpin[    368 const G4int G4ExcitedLambdaConstructor::iSpin[] = {
350     1,   3,   1,   1,   3,                        369     1,   3,   1,   1,   3,
351     1,   1,   5,   5,   3,                        370     1,   1,   5,   5,   3,
352     7,   5                                        371     7,   5
353 };                                                372 };
354                                                   373 
355 const G4int G4ExcitedLambdaConstructor::iParit    374 const G4int G4ExcitedLambdaConstructor::iParity[] = {
356   -1,  -1,   +1,  -1,  -1,                        375   -1,  -1,   +1,  -1,  -1,
357   -1,  +1,   +1,  -1,  +1,                        376   -1,  +1,   +1,  -1,  +1,
358   -1,  +1                                      << 377   -1,  +1 
359 };                                                378 };
360                                                   379 
361 const G4int G4ExcitedLambdaConstructor::encodi    380 const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
362   10000,     0, 20000, 30000, 10000,              381   10000,     0, 20000, 30000, 10000,
363   40000, 50000,     0, 10000, 20000,           << 382   40000, 50000,     0, 10000, 20000, 
364       0, 20000                                    383       0, 20000
365 };                                                384 };
366                                                   385 
367 const G4double G4ExcitedLambdaConstructor::bRa << 386 const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] = 
368 {                                                 387 {
369    {   0.0,  0.0,  1.0,  0.0,  0.0,   0.0,   0 << 388    {   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 << 389    {  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 << 390    {  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 << 391    {  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 << 392    {  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 << 393    {  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 << 394    {  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 << 395    {  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 << 396    {  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 << 397    {  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. << 398    {  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    399    {  0.25, 0.45, 0.30,  0.0,  0.0,   0.0,   0.0}
381 };                                                400 };
                                                   >> 401 
                                                   >> 402 
                                                   >> 403 
                                                   >> 404 
                                                   >> 405 
                                                   >> 406 
                                                   >> 407 
                                                   >> 408 
                                                   >> 409 
                                                   >> 410 
                                                   >> 411 
                                                   >> 412 
                                                   >> 413 
                                                   >> 414 
                                                   >> 415 
                                                   >> 416 
382                                                   417