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