Geant4-11
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Attributes
G4ExcitedDeltaConstructor Class Reference

#include <G4ExcitedDeltaConstructor.hh>

Inheritance diagram for G4ExcitedDeltaConstructor:
G4ExcitedBaryonConstructor

Public Types

enum  { NStates = 9 }
 
enum  { NumberOfDecayModes = 5 }
 

Public Member Functions

virtual void Construct (G4int indexOfState=-1)
 
 G4ExcitedDeltaConstructor ()
 
virtual ~G4ExcitedDeltaConstructor ()
 

Protected Member Functions

virtual void ConstructAntiParticle (G4int indexOfState)
 
virtual void ConstructParticle (G4int indexOfState)
 
virtual G4DecayTable * CreateDecayTable (const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false)
 
virtual G4bool Exist (G4int)
 
virtual G4double GetCharge (G4int iIsoSpin3)
 
virtual G4int GetEncoding (G4int iIsoSpin3, G4int idxState)
 
virtual G4int GetEncodingOffset (G4int iState)
 
virtual G4int GetiParity (G4int iState)
 
virtual G4int GetiSpin (G4int iState)
 
virtual G4double GetMass (G4int state, G4int iso)
 
virtual G4String GetMultipletName (G4int iState)
 
virtual G4String GetName (G4int iIso3, G4int iState)
 
virtual G4int GetQuarkContents (G4int, G4int)
 
virtual G4double GetWidth (G4int state, G4int iso)
 

Protected Attributes

const G4int baryonNumber
 
const G4int iConjugation
 
const G4int iGParity
 
G4int iIsoSpin
 
const G4int leptonNumber
 
G4int NumberOfStates
 
const G4String type
 

Private Types

enum  { DeltaIsoSpin = 3 }
 
enum  {
  NGamma =0 , NPi =1 , NRho =2 , DeltaPi =3 ,
  NStarPi =4
}
 

Private Member Functions

G4DecayTable * AddDeltaPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
 
G4DecayTable * AddNGammaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
 
G4DecayTable * AddNPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
 
G4DecayTable * AddNRhoMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
 
G4DecayTable * AddNStarPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
 

Static Private Attributes

static const G4double bRatio [NStates][NumberOfDecayModes]
 
static const G4int encodingOffset [NStates]
 
static const G4int iParity [NStates]
 
static const G4int iSpin [NStates]
 
static const G4double mass [NStates]
 
static const char * name [NStates]
 
static const G4double width [NStates]
 

Detailed Description

Definition at line 42 of file G4ExcitedDeltaConstructor.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
NStates 

Definition at line 83 of file G4ExcitedDeltaConstructor.hh.

83{ NStates = 9 };

◆ anonymous enum

anonymous enum
private
Enumerator
DeltaIsoSpin 

Definition at line 85 of file G4ExcitedDeltaConstructor.hh.

85{ DeltaIsoSpin = 3 };

◆ anonymous enum

anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 96 of file G4ExcitedDeltaConstructor.hh.

96{ NumberOfDecayModes = 5};

◆ anonymous enum

anonymous enum
private
Enumerator
NGamma 
NPi 
NRho 
DeltaPi 
NStarPi 

Definition at line 98 of file G4ExcitedDeltaConstructor.hh.

98{ NGamma=0, NPi=1, NRho=2, DeltaPi=3, NStarPi=4 };

Constructor & Destructor Documentation

◆ G4ExcitedDeltaConstructor()

G4ExcitedDeltaConstructor::G4ExcitedDeltaConstructor ( )

Definition at line 47 of file G4ExcitedDeltaConstructor.cc.

47 :
48 G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
49{
50
51}
G4ExcitedBaryonConstructor::G4ExcitedBaryonConstructor
G4ExcitedBaryonConstructor(G4int nStates=0, G4int isoSpin=0)
Definition: G4ExcitedBaryonConstructor.cc:47

◆ ~G4ExcitedDeltaConstructor()

G4ExcitedDeltaConstructor::~G4ExcitedDeltaConstructor ( )
virtual

Definition at line 53 of file G4ExcitedDeltaConstructor.cc.

54{
55}

Member Function Documentation

◆ AddDeltaPiMode()

G4DecayTable * G4ExcitedDeltaConstructor::AddDeltaPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4bool  fAnti 
)
private

Definition at line 375 of file G4ExcitedDeltaConstructor.cc.

378{
379 G4VDecayChannel* mode;
380
381 G4String daughterDelta;
382 G4String daughterPi;
383 G4double r;
384
385 // ------------ Delta pi +------------
386 // determine daughters
387 if (iIso3 == +3) {
388 daughterDelta = "delta+";
389 r = br*0.4;
390 } else if (iIso3 == +1) {
391 daughterDelta = "delta0";
392 r = br*8./15.0;
393 } else if (iIso3 == -1) {
394 daughterDelta = "delta-";
395 r = br*6./15.;
396 } else {
397 r = 0.;
398 }
399 if (!fAnti) {
400 daughterPi = "pi+";
401 } else {
402 daughterPi = "pi-";
403 }
404 if (fAnti) daughterDelta = "anti_" + daughterDelta;
405 if (r>0.0) {
406 // create decay channel [parent BR #daughters]
407 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
408 daughterDelta,daughterPi);
409 // add decay table
410 decayTable->Insert(mode);
411 }
412
413 // ------------ Delta pi0 ------------
414 // determine daughters
415 if (iIso3 == +3) {
416 daughterDelta = "delta++";
417 r = br*0.6;
418 } else if (iIso3 == +1) {
419 daughterDelta = "delta+";
420 r = br*1./15.0;
421 } else if (iIso3 == -1) {
422 daughterDelta = "delta0";
423 r = br*1./15.;
424 } else {
425 daughterDelta = "delta-";
426 r = br*0.6;
427 }
428 daughterPi = "pi0";
429 if (fAnti) daughterDelta = "anti_" + daughterDelta;
430
431 // create decay channel [parent BR #daughters]
432 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
433 daughterDelta,daughterPi);
434 // add decay table
435 decayTable->Insert(mode);
436
437 // ------------ Delta pi - -------------
438 // determine daughters
439 if (iIso3 == +3) {
440 r= 0.;
441 } else if (iIso3 == +1) {
442 daughterDelta = "delta++";
443 r = br*6./15.0;
444 } else if (iIso3 == -1) {
445 daughterDelta = "delta+";
446 r = br*8./15.;
447 } else {
448 daughterDelta = "delta0";
449 r = br*0.4;
450 }
451 if (!fAnti) {
452 daughterPi = "pi-";
453 } else {
454 daughterPi = "pi+";
455 }
456 if (fAnti) daughterDelta = "anti_" + daughterDelta;
457 if (r>0.0) {
458 // create decay channel [parent BR #daughters]
459 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
460 daughterDelta,daughterPi);
461 // add decay table
462 decayTable->Insert(mode);
463 }
464
465 return decayTable;
466}
G4double
double G4double
Definition: G4Types.hh:83

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

◆ AddNGammaMode()

G4DecayTable * G4ExcitedDeltaConstructor::AddNGammaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4bool  fAnti 
)
private

Definition at line 118 of file G4ExcitedDeltaConstructor.cc.

121{
122 G4VDecayChannel* mode;
123
124 //
125 G4String daughterN;
126 if (iIso3 == +1) {
127 daughterN = "proton";
128 } else if (iIso3 == -1) {
129 daughterN = "neutron";
130 } else {
131 // can not decay into N+gamma
132 return decayTable;
133 }
134
135 if (fAnti) daughterN = "anti_" + daughterN;
136
137 // create decay channel [parent BR #daughters]
138 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
139 daughterN,"gamma");
140 // add decay table
141 decayTable->Insert(mode);
142
143 return decayTable;
144}

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

◆ AddNPiMode()

G4DecayTable * G4ExcitedDeltaConstructor::AddNPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4bool  fAnti 
)
private

Definition at line 146 of file G4ExcitedDeltaConstructor.cc.

149{
150 G4VDecayChannel* mode;
151
152 G4String daughterN;
153 G4String daughterPi;
154 G4double r = 0.;
155
156 // ------------ N pi0 ------------
157 // determine daughters
158 if ((iIso3 == +1)||(iIso3 == -1)) {
159 if (iIso3 == +1) {
160 daughterN = "proton";
161 daughterPi = "pi0";
162 r = br*2./3.;
163 } else if (iIso3 == -1) {
164 daughterN = "neutron";
165 daughterPi = "pi0";
166 r = br/3.;
167 }
168 if (fAnti) daughterN = "anti_" + daughterN;
169 // create decay channel [parent BR #daughters]
170 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
171 daughterN,daughterPi);
172 // add decay table
173 decayTable->Insert(mode);
174 }
175
176 // -------------N pi +/- --------------
177 // determine daughters
178 if (iIso3 == +3) {
179 daughterN = "proton";
180 if (!fAnti) {
181 daughterPi = "pi+";
182 } else {
183 daughterPi = "pi-";
184 }
185 r = br;
186 } else if (iIso3 == +1) {
187 daughterN = "neutron";
188 if (!fAnti) {
189 daughterPi = "pi+";
190 } else {
191 daughterPi = "pi-";
192 }
193 r = br/3.;
194 } else if (iIso3 == -1) {
195 daughterN = "proton";
196 if (!fAnti) {
197 daughterPi = "pi-";
198 } else {
199 daughterPi = "pi+";
200 }
201 r = br*2./3.;
202 } else if (iIso3 == -3) {
203 daughterN = "neutron";
204 if (!fAnti) {
205 daughterPi = "pi-";
206 } else {
207 daughterPi = "pi+";
208 }
209 r = br;
210 }
211 if (fAnti) daughterN = "anti_" + daughterN;
212
213 // create decay channel [parent BR #daughters]
214 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
215 daughterN,daughterPi);
216 // add decay table
217 decayTable->Insert(mode);
218
219 return decayTable;
220}

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

◆ AddNRhoMode()

G4DecayTable * G4ExcitedDeltaConstructor::AddNRhoMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4bool  fAnti 
)
private

Definition at line 223 of file G4ExcitedDeltaConstructor.cc.

226{
227 G4VDecayChannel* mode;
228
229 G4String daughterN;
230 G4String daughterRho;
231 G4double r = 0.;
232
233 // ------------ N Rho0 ------------
234 // determine daughters
235 if ((iIso3 == +1)||(iIso3 == -1)) {
236 if (iIso3 == +1) {
237 daughterN = "proton";
238 daughterRho = "rho0";
239 r = br*2./3.;
240 } else if (iIso3 == -1) {
241 daughterN = "neutron";
242 daughterRho = "rho0";
243 r = br/3.;
244 }
245 if (fAnti) daughterN = "anti_" + daughterN;
246 // create decay channel [parent BR #daughters]
247 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
248 daughterN,daughterRho);
249 // add decay table
250 decayTable->Insert(mode);
251 }
252
253 // -------------N Rho +/- --------------
254 // determine daughters
255 if (iIso3 == +3) {
256 daughterN = "proton";
257 if (!fAnti) {
258 daughterRho = "rho+";
259 } else {
260 daughterRho = "rho-";
261 }
262 r = br;
263 } else if (iIso3 == +1) {
264 daughterN = "neutron";
265 if (!fAnti) {
266 daughterRho = "rho+";
267 } else {
268 daughterRho = "rho-";
269 }
270 r = br/3.;
271 } else if (iIso3 == -1) {
272 daughterN = "proton";
273 if (!fAnti) {
274 daughterRho = "rho-";
275 } else {
276 daughterRho = "rho+";
277 }
278 r = br*2./3.;
279 } else if (iIso3 == -3) {
280 daughterN = "neutron";
281 if (!fAnti) {
282 daughterRho = "rho-";
283 } else {
284 daughterRho = "rho+";
285 }
286 r = br;
287 }
288 if (fAnti) daughterN = "anti_" + daughterN;
289
290 // create decay channel [parent BR #daughters]
291 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
292 daughterN,daughterRho);
293 // add decay table
294 decayTable->Insert(mode);
295
296 return decayTable;
297}

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

◆ AddNStarPiMode()

G4DecayTable * G4ExcitedDeltaConstructor::AddNStarPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4bool  fAnti 
)
private

Definition at line 299 of file G4ExcitedDeltaConstructor.cc.

302{
303 G4VDecayChannel* mode;
304
305 G4String daughterN;
306 G4String daughterPi;
307 G4double r = 0.;
308
309 // ------------ N pi0 ------------
310 // determine daughters
311 if ((iIso3 == +1)||(iIso3 == -1)) {
312 if (iIso3 == +1) {
313 daughterN = "N(1440)+";
314 daughterPi = "pi0";
315 r = br*2./3.;
316 } else if (iIso3 == -1) {
317 daughterN = "N(1440)0";
318 daughterPi = "pi0";
319 r = br/3.;
320 }
321 if (fAnti) daughterN = "anti_" + daughterN;
322 // create decay channel [parent BR #daughters]
323 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
324 daughterN,daughterPi);
325 // add decay table
326 decayTable->Insert(mode);
327 }
328
329 // -------------N pi +/- --------------
330 // determine daughters
331 if (iIso3 == +3) {
332 daughterN = "N(1440)+";
333 if (!fAnti) {
334 daughterPi = "pi+";
335 } else {
336 daughterPi = "pi-";
337 }
338 r = br;
339 } else if (iIso3 == +1) {
340 daughterN = "N(1440)0";
341 if (!fAnti) {
342 daughterPi = "pi+";
343 } else {
344 daughterPi = "pi-";
345 }
346 r = br/3.;
347 } else if (iIso3 == -1) {
348 daughterN = "N(1440)+";
349 if (!fAnti) {
350 daughterPi = "pi-";
351 } else {
352 daughterPi = "pi+";
353 }
354 r = br*2./3.;
355 } else if (iIso3 == -3) {
356 daughterN = "N(1440)0";
357 if (!fAnti) {
358 daughterPi = "pi-";
359 } else {
360 daughterPi = "pi+";
361 }
362 r = br;
363 }
364 if (fAnti) daughterN = "anti_" + daughterN;
365
366 // create decay channel [parent BR #daughters]
367 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
368 daughterN,daughterPi);
369 // add decay table
370 decayTable->Insert(mode);
371
372 return decayTable;
373}

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

◆ Construct()

void G4ExcitedBaryonConstructor::Construct ( G4int  indexOfState = -1)
virtualinherited

Definition at line 58 of file G4ExcitedBaryonConstructor.cc.

59{
60 if (idx < 0 ) {
61 for (G4int state=0; state< NumberOfStates; state +=1) {
62 ConstructParticle(state);
63 ConstructAntiParticle(state);
64 }
65 } else if (idx < NumberOfStates) {
66 ConstructParticle(idx);
67 ConstructAntiParticle(idx);
68 } else {
69#ifdef G4VERBOSE
70 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
71 G4cerr << "G4ExcitedBaryonConstructor::Construct()";
72 G4cerr << " illegal index os state = " << idx << G4endl;
73 }
74#endif
75 }
76}
G4int
int G4int
Definition: G4Types.hh:85
G4cerr
G4GLOB_DLL std::ostream G4cerr
G4endl
#define G4endl
Definition: G4ios.hh:57
G4ExcitedBaryonConstructor::ConstructAntiParticle
virtual void ConstructAntiParticle(G4int indexOfState)
Definition: G4ExcitedBaryonConstructor.cc:112
G4ExcitedBaryonConstructor::ConstructParticle
virtual void ConstructParticle(G4int indexOfState)
Definition: G4ExcitedBaryonConstructor.cc:81
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:87

References G4ExcitedBaryonConstructor::ConstructAntiParticle(), G4ExcitedBaryonConstructor::ConstructParticle(), G4cerr, G4endl, G4ParticleTable::GetParticleTable(), and G4ExcitedBaryonConstructor::NumberOfStates.

Referenced by G4ShortLivedConstructor::ConstructResonances().

◆ ConstructAntiParticle()

void G4ExcitedBaryonConstructor::ConstructAntiParticle ( G4int  indexOfState)
protectedvirtualinherited

Definition at line 112 of file G4ExcitedBaryonConstructor.cc.

113{
114 if (!Exist(idx) ) return;
115
116 // Construct Resonace particles as dynamic object
117 // Arguments for constructor are as follows
118 // name mass width charge
119 // 2*spin parity C-conjugation
120 // 2*Isospin 2*Isospin3 G-parity
121 // type lepton number baryon number PDG encoding
122 // stable lifetime decay table
123
124
125 G4String name;
126 G4ParticleDefinition* particle;
127
128 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
129 name = GetName(iIso3, idx);
130 name = "anti_" + name;
131
132 particle = new G4ExcitedBaryons(
133 name, GetMass(idx,iIso3), GetWidth(idx,iIso3), -1.0*GetCharge(iIso3),
134 GetiSpin(idx), GetiParity(idx), iConjugation,
135 iIsoSpin, -1*iIso3, iGParity,
136 type, leptonNumber,
137 -1*baryonNumber,
138 -1*GetEncoding( iIso3,idx),
139 false, 0.0, NULL
140 );
141
142 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
143 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, true));
144 }
145
146}
G4ExcitedBaryonConstructor::GetCharge
virtual G4double GetCharge(G4int iIsoSpin3)
Definition: G4ExcitedBaryonConstructor.cc:148
G4ExcitedBaryonConstructor::GetiParity
virtual G4int GetiParity(G4int)=0
G4ExcitedBaryonConstructor::GetiSpin
virtual G4int GetiSpin(G4int)=0
G4ExcitedBaryonConstructor::CreateDecayTable
virtual G4DecayTable * CreateDecayTable(const G4String &, G4int, G4int, G4bool)=0
G4ExcitedBaryonConstructor::GetMass
virtual G4double GetMass(G4int state, G4int iso)=0
G4ExcitedBaryonConstructor::Exist
virtual G4bool Exist(G4int)=0
G4ExcitedBaryonConstructor::GetName
virtual G4String GetName(G4int, G4int)=0
G4ExcitedBaryonConstructor::GetWidth
virtual G4double GetWidth(G4int state, G4int iso)=0
G4ExcitedBaryonConstructor::GetMultipletName
virtual G4String GetMultipletName(G4int)=0
G4ExcitedBaryonConstructor::GetEncoding
virtual G4int GetEncoding(G4int iIsoSpin3, G4int idxState)
Definition: G4ExcitedBaryonConstructor.cc:162
G4ParticleDefinition::SetDecayTable
void SetDecayTable(G4DecayTable *aDecayTable)
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition: G4InuclParticleNames.hh:76

References G4ExcitedBaryonConstructor::baryonNumber, G4ExcitedBaryonConstructor::CreateDecayTable(), G4ExcitedBaryonConstructor::Exist(), G4ExcitedBaryonConstructor::GetCharge(), G4ExcitedBaryonConstructor::GetEncoding(), G4ExcitedBaryonConstructor::GetiParity(), G4ExcitedBaryonConstructor::GetiSpin(), G4ExcitedBaryonConstructor::GetMass(), G4ExcitedBaryonConstructor::GetMultipletName(), G4ExcitedBaryonConstructor::GetName(), G4ExcitedBaryonConstructor::GetWidth(), G4ExcitedBaryonConstructor::iConjugation, G4ExcitedBaryonConstructor::iGParity, G4ExcitedBaryonConstructor::iIsoSpin, G4ExcitedBaryonConstructor::leptonNumber, G4InuclParticleNames::name(), G4ParticleDefinition::SetDecayTable(), and G4ExcitedBaryonConstructor::type.

Referenced by G4ExcitedBaryonConstructor::Construct().

◆ ConstructParticle()

void G4ExcitedBaryonConstructor::ConstructParticle ( G4int  indexOfState)
protectedvirtualinherited

Definition at line 81 of file G4ExcitedBaryonConstructor.cc.

82{
83 if (!Exist(idx) ) return;
84
85 // Construct Resonace particles as dynamic object
86 // Arguments for constructor are as follows
87 // name mass width charge
88 // 2*spin parity C-conjugation
89 // 2*Isospin 2*Isospin3 G-parity
90 // type lepton number baryon number PDG encoding
91 // stable lifetime decay table
92
93
94 G4String name;
95 G4ParticleDefinition* particle;
96
97 for (G4int iIso3 = -1*iIsoSpin; iIso3 <= iIsoSpin; iIso3 +=2) {
98 name= GetName(iIso3, idx);
99
100 particle = new G4ExcitedBaryons(
101 name, GetMass(idx,iIso3), GetWidth(idx,iIso3), GetCharge(iIso3),
102 GetiSpin(idx), GetiParity(idx), iConjugation,
103 iIsoSpin, iIso3, iGParity,
104 type, leptonNumber, baryonNumber, GetEncoding( iIso3,idx),
105 false, 0.0, NULL
106 );
107 ((G4ExcitedBaryons*)(particle))->SetMultipletName(GetMultipletName(idx));
108 particle->SetDecayTable(CreateDecayTable( name, iIso3, idx, false));
109 }
110}

References G4ExcitedBaryonConstructor::baryonNumber, G4ExcitedBaryonConstructor::CreateDecayTable(), G4ExcitedBaryonConstructor::Exist(), G4ExcitedBaryonConstructor::GetCharge(), G4ExcitedBaryonConstructor::GetEncoding(), G4ExcitedBaryonConstructor::GetiParity(), G4ExcitedBaryonConstructor::GetiSpin(), G4ExcitedBaryonConstructor::GetMass(), G4ExcitedBaryonConstructor::GetMultipletName(), G4ExcitedBaryonConstructor::GetName(), G4ExcitedBaryonConstructor::GetWidth(), G4ExcitedBaryonConstructor::iConjugation, G4ExcitedBaryonConstructor::iGParity, G4ExcitedBaryonConstructor::iIsoSpin, G4ExcitedBaryonConstructor::leptonNumber, G4InuclParticleNames::name(), G4ParticleDefinition::SetDecayTable(), and G4ExcitedBaryonConstructor::type.

Referenced by G4ExcitedBaryonConstructor::Construct().

◆ CreateDecayTable()

G4DecayTable * G4ExcitedDeltaConstructor::CreateDecayTable ( const G4String &  name,
G4int  iIso3,
G4int  iState,
G4bool  fAnti = false 
)
protectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 85 of file G4ExcitedDeltaConstructor.cc.

90{
91 // create decay table
92 G4DecayTable* decayTable = new G4DecayTable();
93
94 G4double br;
95 if ( (br=bRatio[iState][NGamma]) >0.0) {
96 AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
97 }
98
99 if ( (br=bRatio[iState][NPi]) >0.0) {
100 AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
101 }
102
103 if ( (br=bRatio[iState][NRho]) >0.0) {
104 AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
105 }
106
107 if ( (br=bRatio[iState][DeltaPi]) >0.0) {
108 AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
109 }
110
111 if ( (br=bRatio[iState][NStarPi]) >0.0) {
112 AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
113 }
114
115 return decayTable;
116}
G4ExcitedDeltaConstructor::AddNGammaMode
G4DecayTable * AddNGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
Definition: G4ExcitedDeltaConstructor.cc:118
G4ExcitedDeltaConstructor::AddDeltaPiMode
G4DecayTable * AddDeltaPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
Definition: G4ExcitedDeltaConstructor.cc:375
G4ExcitedDeltaConstructor::AddNPiMode
G4DecayTable * AddNPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
Definition: G4ExcitedDeltaConstructor.cc:146
G4ExcitedDeltaConstructor::AddNRhoMode
G4DecayTable * AddNRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
Definition: G4ExcitedDeltaConstructor.cc:223
G4ExcitedDeltaConstructor::AddNStarPiMode
G4DecayTable * AddNStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
Definition: G4ExcitedDeltaConstructor.cc:299
G4ExcitedDeltaConstructor::bRatio
static const G4double bRatio[NStates][NumberOfDecayModes]
Definition: G4ExcitedDeltaConstructor.hh:100

References AddDeltaPiMode(), AddNGammaMode(), AddNPiMode(), AddNRhoMode(), AddNStarPiMode(), bRatio, DeltaPi, NGamma, NPi, NRho, and NStarPi.

◆ Exist()

virtual G4bool G4ExcitedDeltaConstructor::Exist ( G4int  )
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 55 of file G4ExcitedDeltaConstructor.hh.

55{return true;}

◆ GetCharge()

G4double G4ExcitedBaryonConstructor::GetCharge ( G4int  iIsoSpin3)
protectedvirtualinherited

Definition at line 148 of file G4ExcitedBaryonConstructor.cc.

149{
150 G4double charge = 0.0;
151 static const G4double quark_charge[7] =
152 {
153 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
154 };
155
156 for (G4int idx=0; idx<3; idx+=1){
157 charge += quark_charge[GetQuarkContents(idx, iIsoSpin3)]*eplus;
158 }
159 return charge;
160}
eplus
static constexpr double eplus
Definition: G4SIunits.hh:184
G4ExcitedBaryonConstructor::GetQuarkContents
virtual G4int GetQuarkContents(G4int, G4int)=0

References eplus, and G4ExcitedBaryonConstructor::GetQuarkContents().

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ GetEncoding()

G4int G4ExcitedDeltaConstructor::GetEncoding ( G4int  iIsoSpin3,
G4int  idxState 
)
protectedvirtual

Reimplemented from G4ExcitedBaryonConstructor.

Definition at line 57 of file G4ExcitedDeltaConstructor.cc.

58{
59 G4int encoding;
60 // Delta has exceptinal encoding
61 if ((idxState==1)||(idxState==3)||(idxState==4)||(idxState==5)||(idxState==7)) {
62 encoding = GetEncodingOffset(idxState);
63 if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
64 // normal encoding
65 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
66 encoding += 100*GetQuarkContents(1, iIsoSpin3);
67 encoding += 10*GetQuarkContents(2, iIsoSpin3);
68 } else if (iIsoSpin3== +1){
69 // 1st <--> 2nd quark
70 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
71 encoding += 10*GetQuarkContents(1, iIsoSpin3);
72 encoding += 100*GetQuarkContents(2, iIsoSpin3);
73 } else if (iIsoSpin3== -1){
74 // 1st <--> 0th quark
75 encoding += 100*GetQuarkContents(0, iIsoSpin3);
76 encoding += 1000*GetQuarkContents(1, iIsoSpin3);
77 encoding += 10*GetQuarkContents(2, iIsoSpin3);
78 }
79 encoding += GetiSpin(idxState) +1;
80 } else {
81 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
82 }
83 return encoding;
84}
G4ExcitedDeltaConstructor::GetQuarkContents
virtual G4int GetQuarkContents(G4int, G4int)
Definition: G4ExcitedDeltaConstructor.hh:134
G4ExcitedDeltaConstructor::GetEncodingOffset
virtual G4int GetEncodingOffset(G4int iState)
Definition: G4ExcitedDeltaConstructor.hh:128
G4ExcitedDeltaConstructor::GetiSpin
virtual G4int GetiSpin(G4int iState)
Definition: G4ExcitedDeltaConstructor.hh:116
encoding
#define encoding
Definition: xmlparse.cc:605

References encoding, G4ExcitedBaryonConstructor::GetEncoding(), GetEncodingOffset(), GetiSpin(), and GetQuarkContents().

◆ GetEncodingOffset()

G4int G4ExcitedDeltaConstructor::GetEncodingOffset ( G4int  iState)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 128 of file G4ExcitedDeltaConstructor.hh.

129{
130 return encodingOffset[iState];
131}
G4ExcitedDeltaConstructor::encodingOffset
static const G4int encodingOffset[NStates]
Definition: G4ExcitedDeltaConstructor.hh:93

References encodingOffset.

Referenced by GetEncoding().

◆ GetiParity()

G4int G4ExcitedDeltaConstructor::GetiParity ( G4int  iState)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 122 of file G4ExcitedDeltaConstructor.hh.

123{
124 return iParity[iState];
125}
G4ExcitedDeltaConstructor::iParity
static const G4int iParity[NStates]
Definition: G4ExcitedDeltaConstructor.hh:92

References iParity.

◆ GetiSpin()

G4int G4ExcitedDeltaConstructor::GetiSpin ( G4int  iState)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 116 of file G4ExcitedDeltaConstructor.hh.

117{
118 return iSpin[iState];
119}
G4ExcitedDeltaConstructor::iSpin
static const G4int iSpin[NStates]
Definition: G4ExcitedDeltaConstructor.hh:91

References iSpin.

Referenced by GetEncoding().

◆ GetMass()

G4double G4ExcitedDeltaConstructor::GetMass ( G4int  state,
G4int  iso 
)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 104 of file G4ExcitedDeltaConstructor.hh.

105{
106 return mass[iState];
107}
G4ExcitedDeltaConstructor::mass
static const G4double mass[NStates]
Definition: G4ExcitedDeltaConstructor.hh:89

References mass.

◆ GetMultipletName()

G4String G4ExcitedDeltaConstructor::GetMultipletName ( G4int  iState)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 171 of file G4ExcitedDeltaConstructor.hh.

172{
173 return name[iState];
174}
G4ExcitedDeltaConstructor::name
static const char * name[NStates]
Definition: G4ExcitedDeltaConstructor.hh:88

References name.

◆ GetName()

G4String G4ExcitedDeltaConstructor::GetName ( G4int  iIso3,
G4int  iState 
)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 177 of file G4ExcitedDeltaConstructor.hh.

178{
179 G4String particle = name[iState];
180 if ( iIso3 == -3 ){
181 particle += "-";
182 } else if ( iIso3 == -1 ){
183 particle += "0";
184 } else if ( iIso3 == +1 ){
185 particle += "+";
186 } else {
187 particle += "++";
188 }
189 return particle;
190}

References name.

◆ GetQuarkContents()

G4int G4ExcitedDeltaConstructor::GetQuarkContents ( G4int  iQ,
G4int  iIso3 
)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 134 of file G4ExcitedDeltaConstructor.hh.

135{
136 // Quark contents
137 // iIso3 = +3 : uuu
138 // iIso3 = +1 : uud
139 // iIso3 = -1 : udd
140 // iIso3 = -3 : ddd
141 G4int quark=0;
142 if ( iQ == 0 ){
143 if ( iIso3 == -3 ){
144 // d-quark
145 quark = 1;
146 } else {
147 // u-quark
148 quark = 2;
149 }
150 } else if ( iQ == 2 ){
151 if ( iIso3 == +3 ){
152 // u-quark
153 quark = 2;
154 } else {
155 // d-quark
156 quark = 1;
157 }
158 } else {
159 if (( iIso3 == -1 )||( iIso3 == -3 )) {
160 // d-quark
161 quark = 1;
162 } else {
163 // u-quark
164 quark = 2;
165 }
166 }
167 return quark;
168}

Referenced by GetEncoding().

◆ GetWidth()

G4double G4ExcitedDeltaConstructor::GetWidth ( G4int  state,
G4int  iso 
)
inlineprotectedvirtual

Implements G4ExcitedBaryonConstructor.

Definition at line 110 of file G4ExcitedDeltaConstructor.hh.

111{
112 return width[iState];
113}
G4ExcitedDeltaConstructor::width
static const G4double width[NStates]
Definition: G4ExcitedDeltaConstructor.hh:90

References width.

Field Documentation

◆ baryonNumber

const G4int G4ExcitedBaryonConstructor::baryonNumber
protectedinherited

Definition at line 70 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ bRatio

const G4double G4ExcitedDeltaConstructor::bRatio
staticprivate
Initial value:
=
{
{ 0.0, 0.15, 0.0, 0.55, 0.30 },
{ 0.0, 0.25, 0.0, 0.60, 0.15 },
{ 0.0, 0.20, 0.10, 0.55, 0.15 },
{ 0.0, 0.30, 0.15, 0.30, 0.25 },
{ 0.0, 0.20, 0.60, 0.10, 0.10 },
{ 0.0, 0.35, 0.40, 0.15, 0.10 },
{ 0.0, 0.15, 0.30, 0.30, 0.25 },
{ 0.0, 0.20, 0.25, 0.25, 0.30 },
{ 0.01, 0.44, 0.15, 0.20, 0.20 }
}

Definition at line 100 of file G4ExcitedDeltaConstructor.hh.

Referenced by CreateDecayTable().

◆ encodingOffset

const G4int G4ExcitedDeltaConstructor::encodingOffset
staticprivate
Initial value:
= {
30000, 0, 10000, 10000, 0,
20000, 20000, 10000, 0
}

Definition at line 93 of file G4ExcitedDeltaConstructor.hh.

Referenced by GetEncodingOffset().

◆ iConjugation

const G4int G4ExcitedBaryonConstructor::iConjugation
protectedinherited

Definition at line 67 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ iGParity

const G4int G4ExcitedBaryonConstructor::iGParity
protectedinherited

Definition at line 68 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ iIsoSpin

G4int G4ExcitedBaryonConstructor::iIsoSpin
protectedinherited

Definition at line 64 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ iParity

const G4int G4ExcitedDeltaConstructor::iParity
staticprivate
Initial value:
= {
+1, -1, -1, -1, +1,
+1, +1, -1, +1
}

Definition at line 92 of file G4ExcitedDeltaConstructor.hh.

Referenced by GetiParity().

◆ iSpin

const G4int G4ExcitedDeltaConstructor::iSpin
staticprivate
Initial value:
=
{
3, 1, 3, 1, 5,
1, 3, 5, 7
}

Definition at line 91 of file G4ExcitedDeltaConstructor.hh.

Referenced by GetiSpin().

◆ leptonNumber

const G4int G4ExcitedBaryonConstructor::leptonNumber
protectedinherited

Definition at line 69 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ mass

const G4double G4ExcitedDeltaConstructor::mass
staticprivate
Initial value:
=
{
1.600*GeV, 1.630*GeV, 1.700*GeV, 1.900*GeV, 1.880*GeV,
1.890*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV
}
GeV
static constexpr double GeV
Definition: G4SIunits.hh:203

Definition at line 89 of file G4ExcitedDeltaConstructor.hh.

Referenced by GetMass().

◆ name

const char * G4ExcitedDeltaConstructor::name
staticprivate
Initial value:
=
{
"delta(1600)", "delta(1620)", "delta(1700)", "delta(1900)", "delta(1905)",
"delta(1910)", "delta(1920)", "delta(1930)", "delta(1950)"
}

Definition at line 88 of file G4ExcitedDeltaConstructor.hh.

Referenced by source.g4viscp.G4Scene::create_scene(), GetMultipletName(), GetName(), mcscore.MCParticle::printout(), and source.g4viscp.G4Scene::update_scene().

◆ NumberOfStates

G4int G4ExcitedBaryonConstructor::NumberOfStates
protectedinherited

Definition at line 63 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::Construct().

◆ type

const G4String G4ExcitedBaryonConstructor::type
protectedinherited

Definition at line 66 of file G4ExcitedBaryonConstructor.hh.

Referenced by G4ExcitedBaryonConstructor::ConstructAntiParticle(), and G4ExcitedBaryonConstructor::ConstructParticle().

◆ width

const G4double G4ExcitedDeltaConstructor::width
staticprivate
Initial value:
= {
320.0*MeV, 140.0*MeV, 300.0*MeV, 200.0*MeV, 330.0*MeV,
280.0*MeV, 260.0*MeV, 360.0*MeV, 280.0*MeV
}
MeV
static constexpr double MeV
Definition: G4SIunits.hh:200

Definition at line 90 of file G4ExcitedDeltaConstructor.hh.

Referenced by GetWidth().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.3