| 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 //
>> 28 //
26 // ------------------------------------------- 29 // --------------------------------------------------------------
27 // GEANT 4 class implementation file << 30 // GEANT 4 class implementation file
28 // 31 //
29 // History: first implementation, based o 32 // History: first implementation, based on object model of
30 // 10 oct 1998 H.Kurashige 33 // 10 oct 1998 H.Kurashige
31 // ------------------------------------------- 34 // ---------------------------------------------------------------
32 35
>> 36
33 #include "G4ExcitedBaryonConstructor.hh" 37 #include "G4ExcitedBaryonConstructor.hh"
34 38
35 #include "G4ExcitedBaryons.hh" << 39 #include "G4SystemOfUnits.hh"
36 #include "G4ParticleDefinition.hh" 40 #include "G4ParticleDefinition.hh"
37 #include "G4ParticleTable.hh" 41 #include "G4ParticleTable.hh"
38 #include "G4SystemOfUnits.hh" << 42 #include "G4PhaseSpaceDecayChannel.hh"
>> 43 #include "G4VDecayChannel.hh"
>> 44 #include "G4DecayTable.hh"
39 45
40 G4ExcitedBaryonConstructor::G4ExcitedBaryonCon << 46
41 : NumberOfStates(nStates), iIsoSpin(isoSpin) << 47 G4ExcitedBaryonConstructor::G4ExcitedBaryonConstructor(G4int nStates,
42 {} << 48 G4int isoSpin)
>> 49 : NumberOfStates(nStates), iIsoSpin(isoSpin), type("baryon"),
>> 50 iConjugation(0), iGParity(0), leptonNumber(0), baryonNumber(1)
>> 51 {
>> 52 }
>> 53
>> 54 G4ExcitedBaryonConstructor::~G4ExcitedBaryonConstructor()
>> 55 {
>> 56 }
43 57
44 void G4ExcitedBaryonConstructor::Construct(G4i 58 void G4ExcitedBaryonConstructor::Construct(G4int idx)
45 { 59 {
46 if (idx < 0) { << 60 if (idx < 0 ) {
47 for (G4int state = 0; state < NumberOfStat << 61 for (G4int state=0; state< NumberOfStates; state +=1) {
48 ConstructParticle(state); << 62 ConstructParticle(state);
49 ConstructAntiParticle(state); << 63 ConstructAntiParticle(state);
50 } << 64 }
51 } << 65 } else if (idx < NumberOfStates) {
52 else if (idx < NumberOfStates) { <<
53 ConstructParticle(idx); 66 ConstructParticle(idx);
54 ConstructAntiParticle(idx); 67 ConstructAntiParticle(idx);
55 } << 68 } else {
56 else { <<
57 #ifdef G4VERBOSE 69 #ifdef G4VERBOSE
58 if (G4ParticleTable::GetParticleTable()->G << 70 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
59 G4cerr << "G4ExcitedBaryonConstructor::C 71 G4cerr << "G4ExcitedBaryonConstructor::Construct()";
60 G4cerr << " illegal index os state = " 72 G4cerr << " illegal index os state = " << idx << G4endl;
61 } 73 }
62 #endif 74 #endif
63 } 75 }
64 } 76 }
65 77
>> 78
>> 79 #include "G4ExcitedBaryons.hh"
>> 80
66 void G4ExcitedBaryonConstructor::ConstructPart 81 void G4ExcitedBaryonConstructor::ConstructParticle(G4int idx)
67 { 82 {
68 if (!Exist(idx)) return; << 83 if (!Exist(idx) ) return;
69 84
70 // Construct Resonace particles as dynami 85 // Construct Resonace particles as dynamic object
71 // Arguments for constructor are as follo 86 // Arguments for constructor are as follows
72 // name mass 87 // name mass width charge
73 // 2*spin parity C-co 88 // 2*spin parity C-conjugation
74 // 2*Isospin 2*Isospin3 89 // 2*Isospin 2*Isospin3 G-parity
75 // type lepton number bary 90 // type lepton number baryon number PDG encoding
76 // stable lifetime de << 91 // stable lifetime decay table
77 << 92
>> 93
78 G4String name; 94 G4String name;
79 G4ParticleDefinition* particle; 95 G4ParticleDefinition* particle;
>> 96
>> 97 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
>> 98 name= GetName(iIso3, idx);
80 99
81 for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= i <<
82 name = GetName(iIso3, idx); <<
83 <<
84 // clang-format off <<
85 particle = new G4ExcitedBaryons( 100 particle = new G4ExcitedBaryons(
86 name, GetMass(idx,iIso3), GetWidth( 101 name, GetMass(idx,iIso3), GetWidth(idx,iIso3), GetCharge(iIso3),
87 GetiSpin(idx), GetiParity(idx), iConjugatio 102 GetiSpin(idx), GetiParity(idx), iConjugation,
88 iIsoSpin, iIso3, iGParit 103 iIsoSpin, iIso3, iGParity,
89 type, leptonNumber, baryo 104 type, leptonNumber, baryonNumber, GetEncoding( iIso3,idx),
90 false, 0.0, null << 105 false, 0.0, NULL
91 ); 106 );
92 // clang-format on <<
93 <<
94 ((G4ExcitedBaryons*)(particle))->SetMultip 107 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
95 particle->SetDecayTable(CreateDecayTable(n << 108 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, false));
96 } 109 }
97 } 110 }
98 111
99 void G4ExcitedBaryonConstructor::ConstructAnti 112 void G4ExcitedBaryonConstructor::ConstructAntiParticle(G4int idx)
100 { 113 {
101 if (!Exist(idx)) return; << 114 if (!Exist(idx) ) return;
102 115
103 // Construct Resonace particles as dynami 116 // Construct Resonace particles as dynamic object
104 // Arguments for constructor are as follo 117 // Arguments for constructor are as follows
105 // name mass 118 // name mass width charge
106 // 2*spin parity C-co 119 // 2*spin parity C-conjugation
107 // 2*Isospin 2*Isospin3 120 // 2*Isospin 2*Isospin3 G-parity
108 // type lepton number bary 121 // type lepton number baryon number PDG encoding
109 // stable lifetime de << 122 // stable lifetime decay table
110 << 123
>> 124
111 G4String name; 125 G4String name;
112 G4ParticleDefinition* particle; 126 G4ParticleDefinition* particle;
113 << 127
114 for (G4int iIso3 = -1 * iIsoSpin; iIso3 <= i << 128 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
115 name = GetName(iIso3, idx); 129 name = GetName(iIso3, idx);
116 name = "anti_" + name; 130 name = "anti_" + name;
117 131
118 // clang-format off <<
119 particle = new G4ExcitedBaryons( 132 particle = new G4ExcitedBaryons(
120 name, GetMass(idx,iIso3), GetWidth(idx,iIso3 133 name, GetMass(idx,iIso3), GetWidth(idx,iIso3), -1.0*GetCharge(iIso3),
121 GetiSpin(idx), GetiParity(idx), iConjugatio 134 GetiSpin(idx), GetiParity(idx), iConjugation,
122 iIsoSpin, -1*iIso3, iGParit 135 iIsoSpin, -1*iIso3, iGParity,
123 type, leptonNumber, 136 type, leptonNumber,
124 -1*baryonNumber, 137 -1*baryonNumber,
125 -1*GetEncoding( iIs 138 -1*GetEncoding( iIso3,idx),
126 false, 0.0, nullptr << 139 false, 0.0, NULL
127 ); 140 );
128 // clang-format on <<
129 141
130 ((G4ExcitedBaryons*)(particle))->SetMultip 142 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
131 particle->SetDecayTable(CreateDecayTable(n << 143 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, true));
132 } 144 }
>> 145
133 } 146 }
134 147
135 G4double G4ExcitedBaryonConstructor::GetCharge << 148 G4double G4ExcitedBaryonConstructor::GetCharge(G4int iIsoSpin3)
136 { 149 {
137 G4double charge = 0.0; 150 G4double charge = 0.0;
138 // clang-format off <<
139 static const G4double quark_charge[7] = 151 static const G4double quark_charge[7] =
140 { 152 {
141 0., -1./3., +2./3., -1./3., +2./3., -1./3. 153 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
142 }; 154 };
143 // clang-format on << 155
144 << 156 for (G4int idx=0; idx<3; idx+=1){
145 for (G4int idx = 0; idx < 3; idx += 1) { << 157 charge += quark_charge[GetQuarkContents(idx, iIsoSpin3)]*eplus;
146 charge += quark_charge[GetQuarkContents(id <<
147 } 158 }
148 return charge; 159 return charge;
149 } 160 }
150 161
151 G4int G4ExcitedBaryonConstructor::GetEncoding( << 162 G4int G4ExcitedBaryonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
152 { 163 {
153 G4int encoding = GetEncodingOffset(idxState) 164 G4int encoding = GetEncodingOffset(idxState);
154 encoding += 1000 * GetQuarkContents(0, iIsoS << 165 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
155 encoding += 100 * GetQuarkContents(1, iIsoSp << 166 encoding += 100*GetQuarkContents(1, iIsoSpin3);
156 encoding += 10 * GetQuarkContents(2, iIsoSpi << 167 encoding += 10*GetQuarkContents(2, iIsoSpin3);
157 if (GetiSpin(idxState) < 9) { << 168 if (GetiSpin(idxState) <9) {
158 encoding += GetiSpin(idxState) + 1; << 169 encoding += GetiSpin(idxState) +1;
159 } << 170 } else {
160 else { << 171 encoding += (GetiSpin(idxState) +1)*10000000;
161 encoding += (GetiSpin(idxState) + 1) * 100 <<
162 } 172 }
163 return encoding; 173 return encoding;
164 } 174 }
165 175