Geant4  10.02.p03
Public Member Functions | Private Member Functions | Private Attributes | List of all members
G4DiffractiveSplitableHadron Class Reference

#include <G4DiffractiveSplitableHadron.hh>

Inheritance diagram for G4DiffractiveSplitableHadron:
Collaboration diagram for G4DiffractiveSplitableHadron:

Public Member Functions

 G4DiffractiveSplitableHadron ()
 
 G4DiffractiveSplitableHadron (const G4ReactionProduct &aPrimary)
 
 G4DiffractiveSplitableHadron (const G4Nucleon &aNucleon)
 
 G4DiffractiveSplitableHadron (const G4VKineticNucleon *aNucleon)
 
 ~G4DiffractiveSplitableHadron ()
 
void SplitUp ()
 
G4Parton * GetNextParton ()
 
G4Parton * GetNextAntiParton ()
 
void SetFirstParton (G4int PDGcode)
 
void SetSecondParton (G4int PDGcode)
 
- Public Member Functions inherited from G4VSplitableHadron
 G4VSplitableHadron ()
 
 G4VSplitableHadron (const G4ReactionProduct &aPrimary)
 
 G4VSplitableHadron (const G4Nucleon &aNucleon)
 
 G4VSplitableHadron (const G4VKineticNucleon *aNucleon)
 
virtual ~G4VSplitableHadron ()
 
int operator== (const G4VSplitableHadron &right) const
 
int operator!= (const G4VSplitableHadron &right) const
 
void Set4Momentum (const G4LorentzVector &a4Momentum)
 
const G4LorentzVector & Get4Momentum () const
 
void SetDefinition (const G4ParticleDefinition *aDefinition)
 
const G4ParticleDefinition * GetDefinition () const
 
void IncrementCollisionCount (G4int aCount)
 
void SetCollisionCount (G4int aCount)
 
void SetTimeOfCreation (G4double aTime)
 
G4double GetTimeOfCreation ()
 
void SetPosition (const G4ThreeVector &aPosition)
 
const G4ThreeVector & GetPosition () const
 
void SetStatus (const G4int aStatus)
 
G4int GetStatus ()
 
G4bool IsSplit ()
 
G4int GetSoftCollisionCount ()
 

Private Member Functions

 G4DiffractiveSplitableHadron (const G4DiffractiveSplitableHadron &)
 
G4DiffractiveSplitableHadron & operator= (const G4DiffractiveSplitableHadron &)
 
int operator== (const G4DiffractiveSplitableHadron &right) const
 
int operator!= (const G4DiffractiveSplitableHadron &right) const
 
G4int Diquark (G4int aquark, G4int bquark, G4int Spin) const
 
void ChooseStringEnds (G4int PDGcode, G4int *aEnd, G4int *bEnd) const
 

Private Attributes

G4Parton * Parton [2]
 
G4int PartonIndex
 

Additional Inherited Members

- Protected Member Functions inherited from G4VSplitableHadron
void Splitting ()
 

Detailed Description

Definition at line 47 of file G4DiffractiveSplitableHadron.hh.

Constructor & Destructor Documentation

◆ G4DiffractiveSplitableHadron() [1/5]

G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron ( )

Definition at line 47 of file G4DiffractiveSplitableHadron.cc.

47  {
48  PartonIndex = -1;
49  Parton[0] = new G4Parton( 1 );
50  Parton[1] = new G4Parton(-1 );
51 }

◆ G4DiffractiveSplitableHadron() [2/5]

G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron ( const G4ReactionProduct &  aPrimary)

Definition at line 56 of file G4DiffractiveSplitableHadron.cc.

56  :
57  G4VSplitableHadron( aPrimary )
58 {
59  PartonIndex = -2;
60  Parton[0] = NULL;
61 }

◆ G4DiffractiveSplitableHadron() [3/5]

G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron ( const G4Nucleon &  aNucleon)

Definition at line 66 of file G4DiffractiveSplitableHadron.cc.

66  :
67  G4VSplitableHadron( aNucleon )
68 {
69  PartonIndex = -2;
70  Parton[0] = NULL;
71 }

◆ G4DiffractiveSplitableHadron() [4/5]

G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron ( const G4VKineticNucleon *  aNucleon)

Definition at line 76 of file G4DiffractiveSplitableHadron.cc.

76  :
77  G4VSplitableHadron( aNucleon )
78 {
79  PartonIndex = -2;
80  Parton[0] = NULL;
81 }

◆ ~G4DiffractiveSplitableHadron()

G4DiffractiveSplitableHadron::~G4DiffractiveSplitableHadron ( )

Definition at line 86 of file G4DiffractiveSplitableHadron.cc.

86  {
87  //G4cout << "Destruct G4DiffractiveSplitableHadron" << Parton[0] << " " << Parton[1] << G4endl;
88  //if ( Parton[0] != NULL ) { delete Parton[0]; delete Parton[1]; }
89 }

◆ G4DiffractiveSplitableHadron() [5/5]

G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron ( const G4DiffractiveSplitableHadron &  )
private

Member Function Documentation

◆ ChooseStringEnds()

void G4DiffractiveSplitableHadron::ChooseStringEnds ( G4int  PDGcode,
G4int *  aEnd,
G4int *  bEnd 
) const
private

Definition at line 162 of file G4DiffractiveSplitableHadron.cc.

163  {
164  G4int absPDGcode = std::abs( PDGcode );
165 
166  if ( absPDGcode < 1000 ) { //-------------------- Meson -------------
167  G4int heavy(0), light(0);
168  if(!((absPDGcode == 111)||(absPDGcode == 221)||(absPDGcode == 331)))
169  { // Ordinary mesons =======================
170  heavy = absPDGcode/100;
171  light = (absPDGcode % 100)/10;
172  //G4int anti = std::pow( -1 , std::max( heavy, light ) );
173  G4int anti = 1 - 2*( std::max( heavy, light ) % 2 );
174  if (PDGcode < 0 ) anti *= -1;
175  heavy *= anti;
176  light *= -1 * anti;
177  }
178  else
179  { // Pi0, Eta, Eta' =======================
180  if( G4UniformRand() < 0.5 ) {heavy = 1; light = -1;}
181  else {heavy = 2; light = -2;}
182  }
183  if ( G4UniformRand() < 0.5 ) {
184  *aEnd = heavy;
185  *bEnd = light;
186  } else {
187  *aEnd = light;
188  *bEnd = heavy;
189  }
190  } else { //-------------------- Baryon --------------
191  G4int j1000 = PDGcode/1000;
192  G4int j100 = (PDGcode % 1000)/100;
193  G4int j10 = (PDGcode % 100)/10;
194 
195  G4double SuppresUUDDSS=1.0/2.0;
196  if((j1000 == j100) && (j1000 == j10)) SuppresUUDDSS=1.;
197 
198 //
199  const G4int maxNumberOfLoops = 1000;
200  G4int loopCounter = 0;
201  do
202  {
203  G4double random = G4UniformRand();
204 
205  if(random < 0.33333)
206  {
207  if(( j100 == j10 ) && ( G4UniformRand() > SuppresUUDDSS )) continue;
208  *aEnd = j1000;
209  if( j100 == j10 ) {*bEnd = Diquark( j100, j10, 1 );}
210  else
211  if( G4UniformRand() > 0.25) {*bEnd = Diquark( j100, j10, 0 );}
212  else {*bEnd = Diquark( j100, j10, 1 );}
213  break;
214  }
215  else if(random < 0.66667)
216  {
217  if(( j1000 == j10 ) && ( G4UniformRand() > SuppresUUDDSS )) continue;
218  *aEnd = j100;
219  if( j1000 == j10 ) {*bEnd = Diquark( j1000, j10, 1 );}
220  else
221  if( G4UniformRand() > 0.25) {*bEnd = Diquark( j1000, j10, 0 );}
222  else {*bEnd = Diquark( j1000, j10, 1 );}
223  break;
224  }
225  else
226  {
227  if(( j1000 == j100 ) && ( G4UniformRand() > SuppresUUDDSS )) continue;
228  *aEnd = j10;
229  if( j1000 == j100 ) {*bEnd = Diquark( j1000, j100, 1 );}
230  else
231  if( G4UniformRand() > 0.25) {*bEnd = Diquark( j1000, j100, 0 );}
232  else {*bEnd = Diquark( j1000, j100, 1 );}
233  break;
234  }
235  } while ( (true) &&
236  ++loopCounter < maxNumberOfLoops ); /* Loop checking, 10.08.2015, A.Ribon */
237  if ( loopCounter >= maxNumberOfLoops ) {
238  *aEnd = j10; *bEnd = Diquark( j1000, j100, 1 ); // Just something acceptable, without any physics consideration.
239  }
240 
241 //
242 /*
243  if ( std::abs( j100 ) >= std::abs( j10 ) ) {
244  if ( random < udspin1 ) {
245  *aEnd = j1000;
246  *bEnd = Diquark( j100, j10, 1 );
247  } else if ( random < udspin1 + uuspin1 ) {
248  *aEnd = j10;
249  *bEnd = Diquark( j1000, j100, 1 );
250  } else {
251  *aEnd = j100;
252  // Careful, there is no diquark q1=q2, (q1 q2)0, possible for Omega-
253  *bEnd = Diquark( j1000, j10, j1000 != j100 ? 0 : 1 );
254  }
255  } else {
256  // Lambda-like hadrons have two lightest quarks in spin 0
257  if ( random < udspin1 ) {
258  *aEnd = j1000;
259  // as above, but with charmed baryons
260  *bEnd = Diquark( j100, j10, j100 != j10 ? 0 : 10 );
261  } else if ( random < udspin1 + uuspin1 ) {
262  *aEnd = j10;
263  *bEnd = Diquark( j1000, j100, 1 );
264  } else {
265  *aEnd = j100;
266  *bEnd = Diquark( j1000, j10, 1 );
267  }
268  }
269 */
270  }
271 }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:97
G4DiffractiveSplitableHadron::Diquark
G4int Diquark(G4int aquark, G4int bquark, G4int Spin) const
Definition: G4DiffractiveSplitableHadron.cc:276
G4double
double G4double
Definition: G4Types.hh:76
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Diquark()

G4int G4DiffractiveSplitableHadron::Diquark ( G4int  aquark,
G4int  bquark,
G4int  Spin 
) const
private

Definition at line 276 of file G4DiffractiveSplitableHadron.cc.

276  {
277  G4int diquarkPDG = std::max( std::abs( aquark ), std::abs( bquark ) ) * 1000 +
278  std::min( std::abs( aquark ), std::abs( bquark ) ) * 100 +
279  2*Spin + 1;
280  return ( aquark > 0 && bquark > 0 ) ? diquarkPDG : -1*diquarkPDG;
281 }
G4int
int G4int
Definition: G4Types.hh:78
Here is the caller graph for this function:

◆ GetNextAntiParton()

G4Parton * G4DiffractiveSplitableHadron::GetNextAntiParton ( )
virtual

Implements G4VSplitableHadron.

Definition at line 135 of file G4DiffractiveSplitableHadron.cc.

135  {
136  ++PartonIndex;
137  if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
138  G4int PartonInd( PartonIndex );
139  if ( PartonIndex == 1 ) PartonIndex = -1;
140  return Parton[ PartonInd ];
141 }
G4int
int G4int
Definition: G4Types.hh:78

◆ GetNextParton()

G4Parton * G4DiffractiveSplitableHadron::GetNextParton ( )
virtual

Implements G4VSplitableHadron.

Definition at line 124 of file G4DiffractiveSplitableHadron.cc.

124  {
125  ++PartonIndex;
126  if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
127  G4int PartonInd( PartonIndex );
128  if ( PartonIndex == 1 ) PartonIndex = -1;
129  return Parton[ PartonInd ];
130 }
G4int
int G4int
Definition: G4Types.hh:78

◆ operator!=()

int G4DiffractiveSplitableHadron::operator!= ( const G4DiffractiveSplitableHadron &  right) const
private

◆ operator=()

G4DiffractiveSplitableHadron& G4DiffractiveSplitableHadron::operator= ( const G4DiffractiveSplitableHadron &  )
private

◆ operator==()

int G4DiffractiveSplitableHadron::operator== ( const G4DiffractiveSplitableHadron &  right) const
private

◆ SetFirstParton()

void G4DiffractiveSplitableHadron::SetFirstParton ( G4int  PDGcode)
virtual

Implements G4VSplitableHadron.

Definition at line 146 of file G4DiffractiveSplitableHadron.cc.

146  {
147  delete Parton[0];
148  Parton[0] = new G4Parton( PDGcode );
149 }

◆ SetSecondParton()

void G4DiffractiveSplitableHadron::SetSecondParton ( G4int  PDGcode)
virtual

Implements G4VSplitableHadron.

Definition at line 154 of file G4DiffractiveSplitableHadron.cc.

154  {
155  delete Parton[1];
156  Parton[1] = new G4Parton( PDGcode );
157 }

◆ SplitUp()

void G4DiffractiveSplitableHadron::SplitUp ( )
virtual

Implements G4VSplitableHadron.

Definition at line 94 of file G4DiffractiveSplitableHadron.cc.

94  {
95  //G4cout << "SplitUp() IsSplit() Parton[0] " << IsSplit() << " " << Parton[0] << G4endl;
96  if ( IsSplit() ) return;
97  Splitting();
98  // Split once only...
99  if ( Parton[0] != NULL ) return;
100 
101  // flavours of quark ends
102  G4int PDGcode = GetDefinition()->GetPDGEncoding();
103  G4int stringStart, stringEnd;
104  ChooseStringEnds( PDGcode, &stringStart, &stringEnd );
105 
106  Parton[0] = new G4Parton( stringStart );
107  Parton[1] = new G4Parton( stringEnd );
108 
109 /* // Inversion of a string
110  if ( G4UniformRand() < 1.75 ) { //0.75
111  Parton[0] = new G4Parton( stringStart );
112  Parton[1] = new G4Parton( stringEnd );
113  } else {
114  Parton[0] = new G4Parton( stringEnd );
115  Parton[1] = new G4Parton( stringStart );
116  }
117 */
118  PartonIndex = -1;
119 }
G4int
int G4int
Definition: G4Types.hh:78
G4DiffractiveSplitableHadron::ChooseStringEnds
void ChooseStringEnds(G4int PDGcode, G4int *aEnd, G4int *bEnd) const
Definition: G4DiffractiveSplitableHadron.cc:162
G4VSplitableHadron::GetDefinition
const G4ParticleDefinition * GetDefinition() const
Definition: G4VSplitableHadron.hh:142
Here is the call graph for this function:

Member Data Documentation

◆ Parton

G4Parton* G4DiffractiveSplitableHadron::Parton[2]
private

Definition at line 72 of file G4DiffractiveSplitableHadron.hh.

◆ PartonIndex

G4int G4DiffractiveSplitableHadron::PartonIndex
private

Definition at line 73 of file G4DiffractiveSplitableHadron.hh.

The documentation for this class was generated from the following files: