| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
>> 26 //
>> 27 // $Id: G4ExcitedBaryonConstructor.cc,v 1.7 2006/06/29 19:26:56 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-09-03-patch-01 $
>> 29 //
>> 30 //
26 // ------------------------------------------- 31 // --------------------------------------------------------------
27 // GEANT 4 class implementation file << 32 // GEANT 4 class implementation file
28 // 33 //
29 // History: first implementation, based o 34 // History: first implementation, based on object model of
30 // 10 oct 1998 H.Kurashige 35 // 10 oct 1998 H.Kurashige
31 // ------------------------------------------- 36 // ---------------------------------------------------------------
32 37
>> 38
33 #include "G4ExcitedBaryonConstructor.hh" 39 #include "G4ExcitedBaryonConstructor.hh"
34 40
35 #include "G4ExcitedBaryons.hh" <<
36 #include "G4ParticleDefinition.hh" 41 #include "G4ParticleDefinition.hh"
37 #include "G4ParticleTable.hh" 42 #include "G4ParticleTable.hh"
38 #include "G4SystemOfUnits.hh" << 43 #include "G4ShortLivedTable.hh"
>> 44 #include "G4PhaseSpaceDecayChannel.hh"
>> 45 #include "G4VDecayChannel.hh"
>> 46 #include "G4DecayTable.hh"
>> 47
>> 48
>> 49 G4ExcitedBaryonConstructor::G4ExcitedBaryonConstructor(G4int nStates,
>> 50 G4int isoSpin)
>> 51 : NumberOfStates(nStates), iIsoSpin(isoSpin), type("baryon"),
>> 52 iConjugation(0), iGParity(0), leptonNumber(0), baryonNumber(1)
>> 53 {
>> 54 }
39 55
40 G4ExcitedBaryonConstructor::G4ExcitedBaryonCon << 56 G4ExcitedBaryonConstructor::~G4ExcitedBaryonConstructor()
41 : NumberOfStates(nStates), iIsoSpin(isoSpin) << 57 {
42 {} << 58 }
43 59
44 void G4ExcitedBaryonConstructor::Construct(G4i 60 void G4ExcitedBaryonConstructor::Construct(G4int idx)
45 { 61 {
46 if (idx < 0) { << 62 if (idx < 0 ) {
47 for (G4int state = 0; state < NumberOfStat << 63 for (G4int state=0; state< NumberOfStates; state +=1) {
48 ConstructParticle(state); << 64 ConstructParticle(state);
49 ConstructAntiParticle(state); << 65 ConstructAntiParticle(state);
50 } << 66 }
51 } << 67 } else if (idx < NumberOfStates) {
52 else if (idx < NumberOfStates) { <<
53 ConstructParticle(idx); 68 ConstructParticle(idx);
54 ConstructAntiParticle(idx); 69 ConstructAntiParticle(idx);
55 } << 70 } else {
56 else { <<
57 #ifdef G4VERBOSE 71 #ifdef G4VERBOSE
58 if (G4ParticleTable::GetParticleTable()->G << 72 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
59 G4cerr << "G4ExcitedBaryonConstructor::C 73 G4cerr << "G4ExcitedBaryonConstructor::Construct()";
60 G4cerr << " illegal index os state = " 74 G4cerr << " illegal index os state = " << idx << G4endl;
61 } 75 }
62 #endif 76 #endif
63 } 77 }
64 } 78 }
65 79
>> 80
>> 81 #include "G4ExcitedBaryons.hh"
>> 82
66 void G4ExcitedBaryonConstructor::ConstructPart 83 void G4ExcitedBaryonConstructor::ConstructParticle(G4int idx)
67 { 84 {
68 if (!Exist(idx)) return; << 85 if (!Exist(idx) ) return;
69 86
70 // Construct Resonace particles as dynami 87 // Construct Resonace particles as dynamic object
71 // Arguments for constructor are as follo 88 // Arguments for constructor are as follows
72 // name mass 89 // name mass width charge
73 // 2*spin parity C-co 90 // 2*spin parity C-conjugation
74 // 2*Isospin 2*Isospin3 91 // 2*Isospin 2*Isospin3 G-parity
75 // type lepton number bary 92 // type lepton number baryon number PDG encoding
76 // stable lifetime de << 93 // stable lifetime decay table
77 << 94
>> 95
78 G4String name; 96 G4String name;
79 G4ParticleDefinition* particle; 97 G4ParticleDefinition* particle;
>> 98
>> 99 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
>> 100 name= GetName(iIso3, idx);
80 101
81 for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= i <<
82 name = GetName(iIso3, idx); <<
83 <<
84 // clang-format off <<
85 particle = new G4ExcitedBaryons( 102 particle = new G4ExcitedBaryons(
86 name, GetMass(idx,iIso3), GetWidth( << 103 name, GetMass(idx), GetWidth(idx), GetCharge(iIso3),
87 GetiSpin(idx), GetiParity(idx), iConjugatio 104 GetiSpin(idx), GetiParity(idx), iConjugation,
88 iIsoSpin, iIso3, iGParit 105 iIsoSpin, iIso3, iGParity,
89 type, leptonNumber, baryo 106 type, leptonNumber, baryonNumber, GetEncoding( iIso3,idx),
90 false, 0.0, null << 107 false, 0.0, NULL
91 ); 108 );
92 // clang-format on <<
93 <<
94 ((G4ExcitedBaryons*)(particle))->SetMultip 109 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
95 particle->SetDecayTable(CreateDecayTable(n << 110 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, false));
96 } 111 }
97 } 112 }
98 113
99 void G4ExcitedBaryonConstructor::ConstructAnti 114 void G4ExcitedBaryonConstructor::ConstructAntiParticle(G4int idx)
100 { 115 {
101 if (!Exist(idx)) return; << 116 if (!Exist(idx) ) return;
102 117
103 // Construct Resonace particles as dynami 118 // Construct Resonace particles as dynamic object
104 // Arguments for constructor are as follo 119 // Arguments for constructor are as follows
105 // name mass 120 // name mass width charge
106 // 2*spin parity C-co 121 // 2*spin parity C-conjugation
107 // 2*Isospin 2*Isospin3 122 // 2*Isospin 2*Isospin3 G-parity
108 // type lepton number bary 123 // type lepton number baryon number PDG encoding
109 // stable lifetime de << 124 // stable lifetime decay table
110 << 125
>> 126
111 G4String name; 127 G4String name;
112 G4ParticleDefinition* particle; 128 G4ParticleDefinition* particle;
113 << 129
114 for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= i << 130 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
115 name = GetName(iIso3, idx); 131 name = GetName(iIso3, idx);
116 name = "anti_" + name; 132 name = "anti_" + name;
117 133
118 // clang-format off <<
119 particle = new G4ExcitedBaryons( 134 particle = new G4ExcitedBaryons(
120 name, GetMass(idx,iIso3), GetWidth(idx,iIso3 << 135 name, GetMass(idx), GetWidth(idx), -1.0*GetCharge(iIso3),
121 GetiSpin(idx), GetiParity(idx), iConjugatio 136 GetiSpin(idx), GetiParity(idx), iConjugation,
122 iIsoSpin, -1*iIso3, iGParit 137 iIsoSpin, -1*iIso3, iGParity,
123 type, leptonNumber, 138 type, leptonNumber,
124 -1*baryonNumber, 139 -1*baryonNumber,
125 -1*GetEncoding( iIs 140 -1*GetEncoding( iIso3,idx),
126 false, 0.0, nullptr << 141 false, 0.0, NULL
127 ); 142 );
128 // clang-format on <<
129 143
130 ((G4ExcitedBaryons*)(particle))->SetMultip 144 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
131 particle->SetDecayTable(CreateDecayTable(n << 145 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, true));
132 } 146 }
>> 147
133 } 148 }
134 149
135 G4double G4ExcitedBaryonConstructor::GetCharge << 150 G4double G4ExcitedBaryonConstructor::GetCharge(G4int iIsoSpin3)
136 { 151 {
137 G4double charge = 0.0; 152 G4double charge = 0.0;
138 // clang-format off << 153 static G4double quark_charge[7] =
139 static const G4double quark_charge[7] = <<
140 { 154 {
141 0., -1./3., +2./3., -1./3., +2./3., -1./3. 155 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
142 }; 156 };
143 // clang-format on << 157
144 << 158 for (G4int idx=0; idx<3; idx+=1){
145 for (G4int idx = 0; idx < 3; idx += 1) { << 159 charge += quark_charge[GetQuarkContents(idx, iIsoSpin3)]*eplus;
146 charge += quark_charge[GetQuarkContents(id <<
147 } 160 }
148 return charge; 161 return charge;
149 } 162 }
150 163
151 G4int G4ExcitedBaryonConstructor::GetEncoding( << 164 G4int G4ExcitedBaryonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
152 { 165 {
153 G4int encoding = GetEncodingOffset(idxState) 166 G4int encoding = GetEncodingOffset(idxState);
154 encoding += 1000 * GetQuarkContents(0, iIsoS << 167 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
155 encoding += 100 * GetQuarkContents(1, iIsoSp << 168 encoding += 100*GetQuarkContents(1, iIsoSpin3);
156 encoding += 10 * GetQuarkContents(2, iIsoSpi << 169 encoding += 10*GetQuarkContents(2, iIsoSpin3);
157 if (GetiSpin(idxState) < 9) { << 170 if (GetiSpin(idxState) <9) {
158 encoding += GetiSpin(idxState) + 1; << 171 encoding += GetiSpin(idxState) +1;
159 } << 172 } else {
160 else { << 173 encoding += (GetiSpin(idxState) +1)*10000000;
161 encoding += (GetiSpin(idxState) + 1) * 100 <<
162 } 174 }
163 return encoding; 175 return encoding;
164 } 176 }
165 177