source: trunk/source/particles/shortlived/src/G4ExcitedLambdaConstructor.cc

Last change on this file was 1340, checked in by garnier, 14 years ago

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