G4QHadron Class Reference

#include <G4QHadron.hh>

Inheritance diagram for G4QHadron:

Public Member Functions
	G4QHadron ()
	G4QHadron (G4LorentzVector p)
	G4QHadron (G4int PDGcode, G4LorentzVector p=G4LorentzVector(0., 0., 0., 0.))
	G4QHadron (G4QPDGCode QPDG, G4LorentzVector p=G4LorentzVector(0., 0., 0., 0.))
	G4QHadron (G4QContent QC, G4LorentzVector p=G4LorentzVector(0., 0., 0., 0.))
	G4QHadron (G4int PDG, G4double m, G4QContent QC)
	G4QHadron (G4QPDGCode QPDG, G4double m, G4QContent QC)
	G4QHadron (G4int PDG, G4LorentzVector p, G4QContent QC)
	G4QHadron (G4QPDGCode QPDG, G4LorentzVector p, G4QContent QC)
	G4QHadron (G4QParticle *pPart, G4double maxM)
	G4QHadron (const G4QHadron &right)
	G4QHadron (const G4QHadron *right)
	G4QHadron (const G4QHadron *right, G4int ColC, G4ThreeVector Pos, G4LorentzVector Mom)
virtual	~G4QHadron ()
const G4QHadron &	operator= (const G4QHadron &right)
G4bool	operator== (const G4QHadron &right) const
G4bool	operator!= (const G4QHadron &right) const
G4int	GetPDGCode () const
G4int	GetQCode () const
G4QPDGCode	GetQPDG () const
G4double	GetSpin () const
G4LorentzVector	Get4Momentum () const
G4ThreeVector	Get3Momentum () const
G4double	GetEnergy () const
G4QContent	GetQC () const
G4double	GetMass () const
G4double	GetMass2 () const
G4double	GetWidth () const
G4int	GetNFragments () const
G4int	GetCharge () const
G4int	GetStrangeness () const
G4int	GetBaryonNumber () const
const G4ThreeVector &	GetPosition () const
G4double	GetBindingEnergy ()
G4double	GetFormationTime ()
std::list< G4QParton * >	GetColor ()
std::list< G4QParton * >	GetAntiColor ()
void	SetQPDG (const G4QPDGCode &QPDG)
void	SetPDGCode (const G4QPDGCode &PDG)
void	Set4Momentum (const G4LorentzVector &aMom)
void	SetQC (const G4QContent &newQC)
void	SetNFragments (const G4int &nf)
void	NegPDGCode ()
void	MakeAntiHadron ()
void	SetPosition (const G4ThreeVector &aPosition)
void	IncrementCollisionCount (G4int aCount)
void	SplitUp ()
G4QPartonPair *	SplitInTwoPartons ()
G4QParton *	GetNextParton ()
G4QParton *	GetNextAntiParton ()
void	SetBindingEnergy (G4double aBindE)
void	Boost (const G4LorentzVector &theBoost)
void	Boost (const G4ThreeVector &B)
void	LorentzRotate (const G4LorentzRotation &rotation)
void	SetFormationTime (G4double fT)
G4double	RandomizeMass (G4QParticle *pPart, G4double maxM)
G4bool	TestRealNeutral ()
G4bool	DecayIn2 (G4LorentzVector &f4Mom, G4LorentzVector &s4Mom)
G4bool	CorMDecayIn2 (G4double corM, G4LorentzVector &fr4Mom)
G4bool	CorEDecayIn2 (G4double corE, G4LorentzVector &fr4Mom)
G4bool	RelDecayIn2 (G4LorentzVector &f4Mom, G4LorentzVector &s4Mom, G4LorentzVector &dir, G4double maxCost=1., G4double minCost=-1.)
G4bool	CopDecayIn2 (G4LorentzVector &f4Mom, G4LorentzVector &s4Mom, G4LorentzVector &dir, G4double cop)
G4bool	DecayIn3 (G4LorentzVector &f4Mom, G4LorentzVector &s4Mom, G4LorentzVector &t4Mom)
G4bool	RelDecayIn3 (G4LorentzVector &fh4M, G4LorentzVector &sh4M, G4LorentzVector &th4Mom, G4LorentzVector &dir, G4double maxCost=1., G4double minCost=-1.)
G4bool	CopDecayIn3 (G4LorentzVector &fh4M, G4LorentzVector &sh4M, G4LorentzVector &th4Mom, G4LorentzVector &dir, G4double cosp)
void	Init3D ()

Protected Attributes
G4LorentzVector	theMomentum

Detailed Description

Definition at line 52 of file G4QHadron.hh.

Constructor & Destructor Documentation

G4QHadron() [1/13]

G4QHadron::G4QHadron

(

)

Definition at line 57 of file G4QHadron.cc.

                    : theMomentum(0.,0.,0.,0.), theQPDG(0), valQ(0,0,0,0,0,0), nFragm(0),
  thePosition(0.,0.,0.), theCollisionCount(0), isSplit(false), Direction(true),
  Color(), AntiColor(), bindE(0.), formTime(0.) {}

Referenced by G4QNucleus::ChooseNucleons(), CopDecayIn3(), G4QNucleus::DecayAlphaAlpha(), G4QNucleus::DecayAlphaBar(), G4QNucleus::DecayAlphaDiN(), G4QNucleus::DecayAntiDibaryon(), G4QNucleus::DecayAntiStrange(), G4QNucleus::DecayDibaryon(), DecayIn3(), G4QNucleus::DecayIsonucleus(), G4QNucleus::DecayMultyBaryon(), G4QNucleus::EvaporateNucleus(), G4QNucleus::G4QNucleus(), G4QNucleus::operator=(), and RelDecayIn3().

G4QHadron() [2/13]

G4QHadron::G4QHadron

(

G4LorentzVector

p

)

Definition at line 61 of file G4QHadron.cc.

                                     : theMomentum(p), theQPDG(0), valQ(0,0,0,0,0,0),
  nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0), isSplit(false), Direction(true),
  Color(), AntiColor(), bindE(0.), formTime(0.) {}

G4QHadron() [3/13]

G4QHadron::G4QHadron	(	G4int	PDGcode,
		G4LorentzVector	p = G4LorentzVector(0.,0.,0.,0.)
	)

Definition at line 66 of file G4QHadron.cc.

                                                    : theMomentum(p), theQPDG(PDGCode),
  nFragm(0),thePosition(0.,0.,0.),theCollisionCount(0),isSplit(false),Direction(true),
  Color(), AntiColor(), bindE(0.), formTime(0.)
{
#ifdef debug
  G4cout<<"G4QHadron must be created with PDG="<<PDGCode<<", 4M="<<p<<G4endl;
#endif
  if(GetQCode()>-1)
  {
    if(theMomentum.e()==0.) theMomentum.setE(theQPDG.GetMass());
    valQ=theQPDG.GetQuarkContent();
  }
  else if(PDGCode>80000000) DefineQC(PDGCode);
  else G4cerr<<"***G4QHadron:(P) PDG="<<PDGCode<<", use other constructor"<<G4endl;
#ifdef debug
  G4cout<<"G4QHadron is created with QCode="<<GetQCode()<<", QC="<<valQ<<G4endl;
#endif
}

G4QHadron() [4/13]

G4QHadron::G4QHadron	(	G4QPDGCode	QPDG,
		G4LorentzVector	p = G4LorentzVector(0.,0.,0.,0.)
	)

Definition at line 86 of file G4QHadron.cc.

                                                      : theMomentum(p), theQPDG(QPDG),
  nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0), isSplit(false), Direction(true),
  Color(), AntiColor(), bindE(0.), formTime(0.)
{
  if(theQPDG.GetQCode()>-1)
  {
    if(theMomentum.e()==0.) theMomentum.setE(theQPDG.GetMass());
    valQ=theQPDG.GetQuarkContent();
  }
  else
  {
    G4int cPDG=theQPDG.GetPDGCode();
    if(cPDG>80000000) DefineQC(cPDG);
    else G4cerr<<"***G4QHadr:(QP) PDG="<<cPDG<<" use other constructor"<<G4endl;
  }
}

G4QHadron() [5/13]

G4QHadron::G4QHadron	(	G4QContent	QC,
		G4LorentzVector	p = G4LorentzVector(0.,0.,0.,0.)
	)

Definition at line 104 of file G4QHadron.cc.

                                                    : theMomentum(p),theQPDG(0),valQ(QC),
  nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0), isSplit(false), Direction(true),
  Color(), AntiColor(), bindE(0.), formTime(0.)
{
  G4int curPDG=valQ.GetSPDGCode();
  if(curPDG==10&&valQ.GetBaryonNumber()>0) curPDG=valQ.GetZNSPDGCode();
  if(curPDG&&curPDG!=10) theQPDG.SetPDGCode(curPDG);
  else theQPDG.InitByQCont(QC);
}

G4QHadron() [6/13]

G4QHadron::G4QHadron	(	G4int	PDG,
		G4double	m,
		G4QContent	QC
	)

Definition at line 114 of file G4QHadron.cc.

                                                                 :
  theMomentum(0.,0.,0.,aMass), theQPDG(PDGCode), valQ(QC), nFragm(0),thePosition(0.,0.,0.),
  theCollisionCount(0), isSplit(false), Direction(true), Color(), AntiColor(), bindE(0.),
  formTime(0.)
{}

G4QHadron() [7/13]

G4QHadron::G4QHadron	(	G4QPDGCode	QPDG,
		G4double	m,
		G4QContent	QC
	)

Definition at line 120 of file G4QHadron.cc.

                                                                   :
  theMomentum(0.,0.,0.,aMass), theQPDG(QPDG), valQ(QC), nFragm(0), thePosition(0.,0.,0.),
  theCollisionCount(0), isSplit(false), Direction(true), Color(), AntiColor(), bindE(0.),
  formTime(0.)
{}

G4QHadron() [8/13]

G4QHadron::G4QHadron	(	G4int	PDG,
		G4LorentzVector	p,
		G4QContent	QC
	)

Definition at line 126 of file G4QHadron.cc.

                                                                    : theMomentum(p),
  theQPDG(PDGCode), valQ(QC), nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0),
  isSplit(false), Direction(true), Color(), AntiColor(), bindE(0.), formTime(0.)
{}

G4QHadron() [9/13]

G4QHadron::G4QHadron	(	G4QPDGCode	QPDG,
		G4LorentzVector	p,
		G4QContent	QC
	)

Definition at line 131 of file G4QHadron.cc.

                                                                      : theMomentum(p),
  theQPDG(QPDG), valQ(QC), nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0),
  isSplit(false), Direction(true), Color(), AntiColor(), bindE(0.), formTime(0.)
{}

G4QHadron() [10/13]

G4QHadron::G4QHadron	(	G4QParticle *	pPart,
		G4double	maxM
	)

Definition at line 136 of file G4QHadron.cc.

                                                      : theMomentum(0.,0.,0.,0.),
  theQPDG(pPart->GetQPDG()), nFragm(0), thePosition(0.,0.,0.), theCollisionCount(0),
  isSplit(false), Direction(true), Color(), AntiColor(), bindE(0.), formTime(0.)
{
#ifdef debug
  G4cout<<"G4QHadron is created & randomized with maxM="<<maxM<<G4endl;
#endif
  G4int PDGCode = theQPDG.GetPDGCode();
  if(PDGCode<2)G4cerr<<"***G4QHadron:(M) PDGC="<<PDGCode<<" use other constructor"<<G4endl;
  valQ=theQPDG.GetQuarkContent();
  theMomentum.setE(RandomizeMass(pPart, maxM));
}

G4QHadron() [11/13]

G4QHadron::G4QHadron

(

const G4QHadron &

right

)

Definition at line 149 of file G4QHadron.cc.

{
  theMomentum         = right.theMomentum;
  theQPDG             = right.theQPDG;
  valQ                = right.valQ;
  nFragm              = right.nFragm;
  thePosition         = right.thePosition;      
  theCollisionCount   = 0;
  isSplit             = false;
  Direction           = right.Direction;
  bindE               = right.bindE;
  formTime            = right.formTime;
}

G4QHadron() [12/13]

G4QHadron::G4QHadron

(

const G4QHadron *

right

)

Definition at line 163 of file G4QHadron.cc.

{
  theMomentum         = right->theMomentum;
  theQPDG             = right->theQPDG;
  valQ                = right->valQ;
  nFragm              = right->nFragm;
  thePosition         = right->thePosition;      
  theCollisionCount   = 0;
  isSplit             = false;
  Direction           = right->Direction;
  bindE               = right->bindE;
  formTime            = right->formTime;
}

G4QHadron() [13/13]

G4QHadron::G4QHadron	(	const G4QHadron *	right,
		G4int	ColC,
		G4ThreeVector	Pos,
		G4LorentzVector	Mom
	)

Definition at line 177 of file G4QHadron.cc.

{
  theMomentum         = M;
  theQPDG             = right->theQPDG;
  valQ                = right->valQ;
  nFragm              = right->nFragm;
  thePosition         = P;      
  theCollisionCount   = C;
  isSplit             = false;
  Direction           = right->Direction;
  bindE               = right->bindE;
  formTime            = right->formTime;
}

~G4QHadron()

G4QHadron::~G4QHadron ( )

virtual

Definition at line 208 of file G4QHadron.cc.

{
  std::list<G4QParton*>::iterator ipos = Color.begin();
  std::list<G4QParton*>::iterator epos = Color.end();
  for( ; ipos != epos; ipos++) {delete [] *ipos;}
  Color.clear();
 
  ipos = AntiColor.begin();
  epos = AntiColor.end();
  for( ; ipos != epos; ipos++) {delete [] *ipos;}
  AntiColor.clear();
}

Member Function Documentation

Boost() [1/2]

void G4QHadron::Boost

(

const G4LorentzVector &

theBoost

)

Definition at line 1293 of file G4QHadron.cc.

{  
  // see CERNLIB short writeup U101 for the algorithm
  G4double bm=boost4M.mag();
  G4double factor=(theMomentum.vect()*boost4M.vect()/(boost4M.e()+bm)-theMomentum.e())/bm;
  theMomentum.setE(theMomentum.dot(boost4M)/bm);
  theMomentum.setVect(factor*boost4M.vect() + theMomentum.vect());
} // End of Boost

Referenced by G4QNucleus::DoLorentzBoost(), G4QFragmentation::Fragment(), and G4QIonIonCollision::Fragment().

Boost() [2/2]

void G4QHadron::Boost ( const G4ThreeVector &  B )

inline

Definition at line 111 of file G4QHadron.hh.

{theMomentum.boost(B);} // Boosts 4-Momentum using v/c

CopDecayIn2()

G4bool G4QHadron::CopDecayIn2	(	G4LorentzVector &	f4Mom,
		G4LorentzVector &	s4Mom,
		G4LorentzVector &	dir,
		G4double	cop
	)

Definition at line 420 of file G4QHadron.cc.

{
  G4double fM2 = f4Mom.m2();
  G4double fM  = sqrt(fM2);              // Mass of the 1st Hadron
  G4double sM2 = s4Mom.m2();
  G4double sM  = sqrt(sM2);              // Mass of the 2nd Hadron
  G4double iM2 = theMomentum.m2();
  G4double iM  = sqrt(iM2);              // Mass of the decaying hadron
  G4double vP  = theMomentum.rho();      // Momentum of the decaying hadron
  G4double dE  = theMomentum.e();        // Energy of the decaying hadron
  G4bool neg=false;                // Negative (backward) distribution of t
  if(cosp<0)
  {
    cosp=-cosp;
    neg=true;
  }
  if(dE<vP)
  {
    G4cerr<<"***G4QHad::CopDecIn2: Tachionic 4-mom="<<theMomentum<<", E-p="<<dE-vP<<G4endl;
    G4double accuracy=.000001*vP;
    G4double emodif=std::fabs(dE-vP);
    //if(emodif<accuracy)
    //{
      G4cerr<<"G4QHadron::CopDecIn2: *Boost* E-p shift is corrected to "<<emodif<<G4endl;
      theMomentum.setE(vP+emodif+.01*accuracy);
    //}
  }
  G4ThreeVector ltb = theMomentum.boostVector();// Boost vector for backward Lorentz Trans.
  G4ThreeVector ltf = -ltb;              // Boost vector for forward Lorentz Trans.
  G4LorentzVector cdir = dir;            // A copy to make a transformation to CMS
#ifdef ppdebug
  if(cdir.e()+.001<cdir.rho()) G4cerr<<"*G4QH::RDIn2:*Boost* cd4M="<<cdir<<",e-p="
                                     <<cdir.e()-cdir.rho()<<G4endl;
#endif
  cdir.boost(ltf);                       // Direction transpormed to CMS of the Momentum
  G4ThreeVector vdir = cdir.vect();      // 3-Vector of the direction-particle
#ifdef ppdebug
  G4cout<<"G4QHad::CopDI2:dir="<<dir<<",ltf="<<ltf<<",cdir="<<cdir<<",vdir="<<vdir<<G4endl;
#endif
  G4ThreeVector vx(0.,0.,1.);            // Ort in the direction of the reference particle
  G4ThreeVector vy(0.,1.,0.);            // First ort orthogonal to the direction
  G4ThreeVector vz(1.,0.,0.);            // Second ort orthoganal to the direction
  if(vdir.mag2() > 0.)                   // the refference particle isn't at rest in CMS
  {
    vx = vdir.unit();                    // Ort in the direction of the reference particle
#ifdef ppdebug
    G4cout<<"G4QH::CopDecIn2:Vx="<<vx<<",M="<<theMomentum<<",d="<<dir<<",c="<<cdir<<G4endl;
#endif
    G4ThreeVector vv= vx.orthogonal();   // Not normed orthogonal vector (!)
    vy = vv.unit();                      // First ort orthogonal to the direction
    vz = vx.cross(vy);                   // Second ort orthoganal to the direction
  }
#ifdef ppdebug
  G4cout<<"G4QHad::CopDecIn2:iM="<<iM<<"=>fM="<<fM<<"+sM="<<sM<<",ob="<<vx<<vy<<vz<<G4endl;
#endif
  if(fabs(iM-fM-sM)<.00000001)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    return true;
  }
  else if (iM+.001<fM+sM || iM==0.)
  {//@@ Later on make a quark content check for the decay
    G4cerr<<"***G4QH::CopDecIn2: fM="<<fM<<"+sM="<<sM<<">iM="<<iM<<",d="<<iM-fM-sM<<G4endl;
    return false;
  }
  G4double d2 = iM2-fM2-sM2;
  G4double p2 = (d2*d2/4.-fM2*sM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
  if(p2<0.)
  {
#ifdef ppdebug
    G4cout<<"*G4QH:CopDI2:p2="<<p2<<"<0,d4/4="<<d2*d2/4.<<"<4*fM2*sM2="<<4*fM2*sM2<<G4endl;
#endif
    p2=0.;
  }
  G4double p  = sqrt(p2);
  G4double ct = 0;
  G4double rn = pow(G4UniformRand(),cosp+1.);
  if(neg)  ct = rn+rn-1.;                  // More backward than forward
  else     ct = 1.-rn-rn;                  // More forward than backward
  //
  G4double phi= twopi*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
  G4double ps=0.;
  if(fabs(ct)<1.) ps = p * sqrt(1.-ct*ct);
  else
  {
#ifdef ppdebug
    G4cout<<"**G4QH::CopDecayIn2:ct="<<ct<<",mac="<<maxCost<<",mic="<<minCost<<G4endl;
    //throw G4QException("***G4QHadron::RDIn2: bad cos(theta)");
#endif
    if(ct>1.) ct=1.;
    if(ct<-1.) ct=-1.;
  }
  G4ThreeVector pVect=(ps*sin(phi))*vz+(ps*cos(phi))*vy+p*ct*vx;
#ifdef ppdebug
  G4cout<<"G4QH::CopDIn2:ct="<<ct<<",p="<<p<<",ps="<<ps<<",ph="<<phi<<",v="<<pVect<<G4endl;
#endif
 
  f4Mom.setVect(pVect);
  f4Mom.setE(sqrt(fM2+p2));
  s4Mom.setVect((-1)*pVect);
  s4Mom.setE(sqrt(sM2+p2));
  
#ifdef ppdebug
  G4cout<<"G4QHadr::CopDecIn2:p2="<<p2<<",v="<<ltb<<",f4M="<<f4Mom<<" + s4M="<<s4Mom<<" = "
        <<f4Mom+s4Mom<<", M="<<iM<<G4endl;
#endif
  if(f4Mom.e()+.001<f4Mom.rho())G4cerr<<"*G4QH::RDIn2:*Boost* f4M="<<f4Mom<<",e-p="
                                      <<f4Mom.e()-f4Mom.rho()<<G4endl;
  f4Mom.boost(ltb);                        // Lor.Trans. of 1st hadron back to LS
  if(s4Mom.e()+.001<s4Mom.rho())G4cerr<<"*G4QH::RDIn2:*Boost* s4M="<<s4Mom<<",e-p="
                                      <<s4Mom.e()-s4Mom.rho()<<G4endl;
  s4Mom.boost(ltb);                        // Lor.Trans. of 2nd hadron back to LS
#ifdef ppdebug
  G4cout<<"G4QHadron::CopDecayIn2:Output, f4Mom="<<f4Mom<<" + s4Mom="<<s4Mom<<" = "
        <<f4Mom+s4Mom<<", d4M="<<theMomentum-f4Mom-s4Mom<<G4endl;
#endif
  return true;
} // End of "CopDecayIn2"

Referenced by CopDecayIn3().

CopDecayIn3()

G4bool G4QHadron::CopDecayIn3	(	G4LorentzVector &	fh4M,
		G4LorentzVector &	sh4M,
		G4LorentzVector &	th4Mom,
		G4LorentzVector &	dir,
		G4double	cosp
	)

Definition at line 951 of file G4QHadron.cc.

{
#ifdef debug
  G4cout<<"G4QH::CopDIn3:"<<theMomentum<<"=>f="<<f4Mom<<"+s="<<s4Mom<<"+t="<<t4Mom<<G4endl;
#endif
  G4double iM  = theMomentum.m();  // Mass of the decaying hadron
  G4double fM  = f4Mom.m();        // Mass of the 1st hadron
  G4double sM  = s4Mom.m();        // Mass of the 2nd hadron
  G4double tM  = t4Mom.m();        // Mass of the 3rd hadron
  G4double eps = 0.001;            // Accuracy of the split condition
  if (fabs(iM-fM-sM-tM)<=eps)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    G4double tR=tM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    t4Mom=tR*theMomentum;
    return true;
  }
  if (iM+eps<fM+sM+tM)
  {
    G4cout<<"***G4QHadron::CopDecayIn3:fM="<<fM<<" + sM="<<sM<<" + tM="<<tM<<" > iM="<<iM
          <<",d="<<iM-fM-sM-tM<<G4endl;
    return false;
  }
  G4double fM2 = fM*fM;
  G4double sM2 = sM*sM;
  G4double tM2 = tM*tM;
  G4double iM2 = iM*iM;
  G4double m13sBase=(iM-sM)*(iM-sM)-(fM+tM)*(fM+tM);
  G4double m12sMin =(fM+sM)*(fM+sM);
  G4double m12sBase=(iM-tM)*(iM-tM)-m12sMin;
  G4double rR = 0.;
  G4double rnd= 1.;
#ifdef debug
  G4int    tr = 0;                 //@@ Comment if "cout" below is skiped @@
#endif
  G4double m12s = 0.;              // Fake definition before the Loop
  while (rnd > rR)
  {
    m12s = m12sMin + m12sBase*G4UniformRand();
    G4double e1=m12s+fM2-sM2;
    G4double e2=iM2-m12s-tM2;
    G4double four12=4*m12s;
    G4double m13sRange=0.;
    G4double dif=(e1*e1-four12*fM2)*(e2*e2-four12*tM2);
    if(dif<0.)
    {
#ifdef debug
      if(dif<-.01) G4cerr<<"G4QHadron::CopDecayIn3:iM="<<iM<<",tM="<<tM<<",sM="<<sM<<",fM="
                         <<fM<<",m12(s+f)="<<sqrt(m12s)<<", d="<<iM-fM-sM-tM<<G4endl;
#endif
    }
    else m13sRange=sqrt(dif)/m12s;
    rR = m13sRange/m13sBase;
    rnd= G4UniformRand();
#ifdef debug
    G4cout<<"G4QHadron::CopDecayIn3: try decay #"<<++tr<<", rR="<<rR<<",rnd="<<rnd<<G4endl;
#endif
  }
  G4double m12 = sqrt(m12s);       // Mass of the H1+H2 system
  G4LorentzVector dh4Mom(0.,0.,0.,m12);
  
  if(!CopDecayIn2(t4Mom,dh4Mom,dir,cosp))
  {
    G4cerr<<"***G4QHadron::CopDecayIn3: Exception1"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
#ifdef debug
  G4cout<<"G4QHadron::DecayIn3: Now the last decay of m12="<<dh4Mom.m()<<G4endl;
#endif
  if(!G4QHadron(dh4Mom).DecayIn2(f4Mom,s4Mom))
  {
    G4cerr<<"***G4QHadron::CopDecayIn3: Error in DecayIn2 -> Exception2"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
  return true;
} // End of CopDecayIn3

CorEDecayIn2()

G4bool G4QHadron::CorEDecayIn2	(	G4double	corE,
		G4LorentzVector &	fr4Mom
	)

Definition at line 743 of file G4QHadron.cc.

{
  G4double fE  = fr4Mom.m();                // Energy of the Fragment
#ifdef debug
  G4cout<<"G4QH::CorEDecIn2:fE="<<fE<<fr4Mom<<">corE="<<corE<<",h4M="<<theMomentum<<G4endl;
#endif
  if (fE+.001<=corE)
  {
#ifdef debug
    G4cerr<<"***G4QHadron::CorEDecIn2*** fE="<<fE<<"<corE="<<corE<<", d="<<corE-fE<<G4endl;
#endif
    return false;
  }
  G4double fM2=fr4Mom.m2();                 // Squared Mass of the Fragment
  if(fM2<0.) fM2=0.;
  G4double iPx=fr4Mom.px();                 // Initial Px of the Fragment
  G4double iPy=fr4Mom.py();                 // Initial Py of the Fragment
  G4double iPz=fr4Mom.pz();                 // Initial Pz of the Fragment
  G4double fP2=iPx*iPx+iPy*iPy+iPz*iPz;     // Initial Squared 3-momentum of the Fragment
  G4double finE = fE - corE;                // Final energy of the fragment
  G4double rP = sqrt((finE*finE-fM2)/fP2);  // Reduction factor for the momentum
  G4double fPx=iPx*rP;
  G4double fPy=iPy*rP;
  G4double fPz=iPz*rP;
  fr4Mom= G4LorentzVector(fPx,fPy,fPz,finE);
  G4double Px=theMomentum.px()+iPx-fPx;
  G4double Py=theMomentum.py()+iPy-fPy;
  G4double Pz=theMomentum.pz()+iPz-fPz;
  G4double mE=theMomentum.e();
  ///////////G4double mM2=theMomentum.m2();
  theMomentum= G4LorentzVector(Px,Py,Pz,mE+corE);
#ifdef debug
  G4double difF=fr4Mom.m2()-fM2;
  G4cout<<"G4QH::CorEDecIn2: dF="<<difF<<",out:"<<theMomentum<<fr4Mom<<G4endl;
#endif
  return true;
} // End of "CorEDecayIn2"

CorMDecayIn2()

G4bool G4QHadron::CorMDecayIn2	(	G4double	corM,
		G4LorentzVector &	fr4Mom
	)

Definition at line 635 of file G4QHadron.cc.

{
  G4double fM  = fr4Mom.m();                // Mass of the Fragment
  G4LorentzVector comp=theMomentum+fr4Mom;  // 4Mom of the decaying compound system
  G4double iM  = comp.m();                  // mass of the decaying compound system
#ifdef debug
  G4cout<<"G4QH::CMDIn2: iM="<<iM<<comp<<"=>fM="<<fM<<"+corM="<<corM<<"="<<fM+corM<<G4endl;
#endif
  G4double dE=iM-fM-corM;
  //@@ Later on make a quark content check for the decay
  if (fabs(dE)<.001)
  {
    G4double fR=fM/iM;
    G4double cR=corM/iM;
    fr4Mom=fR*comp;
    theMomentum=cR*comp;
    return true;
  }
  else if (dE<-.001 || iM==0.)
  {
    G4cerr<<"***G4QH::CorMDIn2***fM="<<fM<<" + cM="<<corM<<" > iM="<<iM<<",d="<<dE<<G4endl;
    return false;
  }
  G4double corM2= corM*corM;
  G4double fM2 = fM*fM;
  G4double iM2 = iM*iM;
  G4double d2 = iM2-fM2-corM2;
  G4double p2 = (d2*d2/4.-fM2*corM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
  if (p2<0.)
  {
#ifdef debug
    G4cerr<<"**G4QH::CMDI2:p2="<<p2<<"<0,d="<<d2*d2/4.<<"<4*fM2*hM2="<<4*fM2*corM2<<G4endl;
#endif
    p2=0.;
  }
  G4double p  = sqrt(p2);
  if(comp.e()<comp.rho())G4cerr<<"*G4QH::CorMDecayIn2:*Boost* comp4M="<<comp<<",e-p="
                               <<comp.e()-comp.rho()<<G4endl;
  G4ThreeVector ltb = comp.boostVector();      // Boost vector for backward Lor.Trans.
  G4ThreeVector ltf = -ltb;                    // Boost vector for forward Lorentz Trans.
  G4LorentzVector cm4Mom=fr4Mom;               // Copy of fragment 4Mom to transform to CMS
  if(cm4Mom.e()<cm4Mom.rho())
  {
    G4cerr<<"*G4QH::CorMDecIn2:*Boost* c4M="<<cm4Mom<<G4endl;
    //cm4Mom.setE(1.0000001*cm4Mom.rho());
    return false;
  }
  cm4Mom.boost(ltf);                           // Now it is in CMS (Forward Lor.Trans.)
  G4double pfx= cm4Mom.px();
  G4double pfy= cm4Mom.py();
  G4double pfz= cm4Mom.pz();
  G4double pt2= pfx*pfx+pfy*pfy;
  G4double tx=0.;
  G4double ty=0.;
  if(pt2<=0.)
  {
    G4double phi= 360.*deg*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
    tx=sin(phi);
    ty=cos(phi);
  }
  else
  {
    G4double pt=sqrt(pt2);
    tx=pfx/pt;
    ty=pfy/pt;
  }
  G4double pc2=pt2+pfz*pfz;
  G4double ct=0.;
  if(pc2<=0.)
  {
    G4double rnd= G4UniformRand();
    ct=1.-rnd-rnd;
  }
  else
  {
    G4double pc_value=sqrt(pc2);
    ct=pfz/pc_value;
  }
#ifdef debug
  G4cout<<"G4QHadron::CorMDecayIn2: ct="<<ct<<", p="<<p<<G4endl;
#endif
  G4double ps = p * sqrt(1.-ct*ct);
  G4ThreeVector pVect(ps*tx,ps*ty,p*ct);
  fr4Mom.setVect(pVect);
  fr4Mom.setE(sqrt(fM2+p2));
  theMomentum.setVect((-1)*pVect);
  theMomentum.setE(sqrt(corM2+p2));
#ifdef debug
  G4LorentzVector dif2=comp-fr4Mom-theMomentum;
  G4cout<<"G4QH::CorMDIn2:c="<<comp<<"-f="<<fr4Mom<<"-4M="<<theMomentum<<"="<<dif2<<G4endl;
#endif
  if(fr4Mom.e()+.001<fr4Mom.rho())G4cerr<<"*G4QH::CorMDecIn2:*Boost*fr4M="<<fr4Mom<<G4endl;
  fr4Mom.boost(ltb);                        // Lor.Trans. of the Fragment back to LS
  if(theMomentum.e()<theMomentum.rho())
  {
    G4cerr<<"*G4QH::CMDI2:4="<<theMomentum<<G4endl;
    theMomentum.setE(1.0000001*theMomentum.rho());
  }
  theMomentum.boost(ltb);                  // Lor.Trans. of the Hadron back to LS
#ifdef debug
  G4LorentzVector dif3=comp-fr4Mom-theMomentum;
  G4cout<<"G4QH::CorMDecIn2:OUTPUT:f4M="<<fr4Mom<<",h4M="<<theMomentum<<"d="<<dif3<<G4endl;
#endif
  return true;
} // End of "CorMDecayIn2"

DecayIn2()

G4bool G4QHadron::DecayIn2	(	G4LorentzVector &	f4Mom,
		G4LorentzVector &	s4Mom
	)

Definition at line 544 of file G4QHadron.cc.

{
  G4double fM2 = f4Mom.m2();
  if(fM2<0.) fM2=0.;
  G4double fM  = sqrt(fM2);              // Mass of the 1st Hadron
  G4double sM2 = s4Mom.m2();
  if(sM2<0.) sM2=0.;
  G4double sM  = sqrt(sM2);              // Mass of the 2nd Hadron
  G4double iM2 = theMomentum.m2();
  if(iM2<0.) iM2=0.;
  G4double iM  = sqrt(iM2);              // Mass of the decaying hadron
#ifdef debug
  G4cout<<"G4QHadron::DecIn2: iM="<<iM<<" => fM="<<fM<<" + sM="<<sM<<" = "<<fM+sM<<G4endl;
#endif
  //@@ Later on make a quark content check for the decay
  if (fabs(iM-fM-sM)<.0000001)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    return true;
  }
  else if (iM+.001<fM+sM || iM==0.)
  {
#ifdef debug
    G4cerr<<"***G4QHadron::DecayIn2*** fM="<<fM<<" + sM="<<sM<<"="<<fM+sM<<" > iM="<<iM
          <<", d="<<iM-fM-sM<<G4endl;
#endif
    return false;
  }
 
  G4double d2 = iM2-fM2-sM2;
  G4double p2 = (d2*d2/4.-fM2*sM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
  if (p2<0.)
  {
#ifdef debug
    G4cerr<<"***G4QH::DI2:p2="<<p2<<"<0,d2^2="<<d2*d2/4.<<"<4*fM2*sM2="<<4*fM2*sM2<<G4endl;
#endif
    p2=0.;
  }
  G4double p  = sqrt(p2);
  G4double ct = 1.-2*G4UniformRand();
#ifdef debug
  G4cout<<"G4QHadron::DecayIn2: ct="<<ct<<", p="<<p<<G4endl;
#endif
  G4double phi= twopi*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
  G4double ps = p * sqrt(1.-ct*ct);
  G4ThreeVector pVect(ps*sin(phi),ps*cos(phi),p*ct);
 
  f4Mom.setVect(pVect);
  f4Mom.setE(sqrt(fM2+p2));
  s4Mom.setVect((-1)*pVect);
  s4Mom.setE(sqrt(sM2+p2));
 
  if(theMomentum.e()<theMomentum.rho())
  {
    G4cerr<<"*G4QH::DecIn2:*Boost* 4M="<<theMomentum<<",e-p="
          <<theMomentum.e()-theMomentum.rho()<<G4endl;
    //throw G4QException("G4QHadron::DecayIn2: Decay of particle with zero mass")
    //theMomentum.setE(1.0000001*theMomentum.rho()); // Lead to TeV error !
    return false;
  }
  G4double vP  = theMomentum.rho();      // Momentum of the decaying hadron
  G4double dE  = theMomentum.e();        // Energy of the decaying hadron
  if(dE<vP)
  {
    G4cerr<<"***G4QHad::RelDecIn2: Tachionic 4-mom="<<theMomentum<<", E-p="<<dE-vP<<G4endl;
    G4double accuracy=.000001*vP;
    G4double emodif=std::fabs(dE-vP);
    if(emodif<accuracy)
    {
      G4cerr<<"G4QHadron::DecayIn2: *Boost* E-p shift is corrected to "<<emodif<<G4endl;
      theMomentum.setE(vP+emodif+.01*accuracy);
    }
  }
  G4ThreeVector ltb = theMomentum.boostVector(); // Boost vector for backward Lor.Trans.
#ifdef debug
  G4cout<<"G4QHadron::DecIn2:LorTrans v="<<ltb<<",f4Mom="<<f4Mom<<",s4Mom="<<s4Mom<<G4endl;
#endif
  if(f4Mom.e()+.001<f4Mom.rho())G4cerr<<"*G4QH::DecIn2:*Boost* f4M="<<f4Mom<<G4endl;
  f4Mom.boost(ltb);                        // Lor.Trans. of 1st hadron back to LS
  if(s4Mom.e()+.001<s4Mom.rho())G4cerr<<"*G4QH::DecIn2:*Boost* s4M="<<s4Mom<<G4endl; 
  s4Mom.boost(ltb);                        // Lor.Trans. of 2nd hadron back to LS
#ifdef debug
  G4cout<<"G4QHadron::DecayIn2: ROOT OUTPUT f4Mom="<<f4Mom<<", s4Mom="<<s4Mom<<G4endl;
#endif
  return true;
} // End of "DecayIn2"

Referenced by G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), CopDecayIn3(), G4QEnvironment::DecayAntistrange(), G4QEnvironment::DecayBaryon(), DecayIn3(), G4QEnvironment::DecayMeson(), G4QNucleus::DecayMultyBaryon(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QDiffractionRatio::ProjFragment(), and RelDecayIn3().

DecayIn3()

G4bool G4QHadron::DecayIn3	(	G4LorentzVector &	f4Mom,
		G4LorentzVector &	s4Mom,
		G4LorentzVector &	t4Mom
	)

Definition at line 782 of file G4QHadron.cc.

{
#ifdef debug
  G4cout<<"G4QH::DIn3:"<<theMomentum<<"=>pf="<<f4Mom<<"+ps="<<s4Mom<<"+pt="<<t4Mom<<G4endl;
#endif
  G4double iM  = theMomentum.m();  // Mass of the decaying hadron
  G4double fM  = f4Mom.m();        // Mass of the 1st hadron
  G4double sM  = s4Mom.m();        // Mass of the 2nd hadron
  G4double tM  = t4Mom.m();        // Mass of the 3rd hadron
  G4double eps = 0.001;            // Accuracy of the split condition
  if (fabs(iM-fM-sM-tM)<=eps)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    G4double tR=tM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    t4Mom=tR*theMomentum;
    return true;
  }
  if (iM+eps<fM+sM+tM)
  {
    G4cout<<"***G4QHadron::DecayIn3:fM="<<fM<<" + sM="<<sM<<" + tM="<<tM<<" > iM="<<iM
          <<",d="<<iM-fM-sM-tM<<G4endl;
    return false;
  }
  G4double fM2 = fM*fM;
  G4double sM2 = sM*sM;
  G4double tM2 = tM*tM;
  G4double iM2 = iM*iM;
  G4double m13sBase=(iM-sM)*(iM-sM)-(fM+tM)*(fM+tM);
  G4double m12sMin =(fM+sM)*(fM+sM);
  G4double m12sBase=(iM-tM)*(iM-tM)-m12sMin;
  G4double rR = 0.;
  G4double rnd= 1.;
#ifdef debug
  G4int    tr = 0;                 //@@ Comment if "cout" below is skiped @@
#endif
  G4double m12s = 0.;              // Fake definition before the Loop
  while (rnd > rR)
  {
    m12s = m12sMin + m12sBase*G4UniformRand();
    G4double e1=m12s+fM2-sM2;
    G4double e2=iM2-m12s-tM2;
    G4double four12=4*m12s;
    G4double m13sRange=0.;
    G4double dif=(e1*e1-four12*fM2)*(e2*e2-four12*tM2);
    if(dif<0.)
    {
#ifdef debug
      if(dif<-.01) G4cerr<<"*G4QHadron::DecayIn3:iM="<<iM<<",tM="<<tM<<",sM="<<sM<<",fM="
                         <<fM<<",m12(s+f)="<<sqrt(m12s)<<", d="<<iM-fM-sM-tM<<G4endl;
#endif
    }
    else m13sRange=sqrt(dif)/m12s;
    rR = m13sRange/m13sBase;
    rnd= G4UniformRand();
#ifdef debug
    G4cout<<"G4QHadron::DecayIn3: try to decay #"<<++tr<<", rR="<<rR<<",rnd="<<rnd<<G4endl;
#endif
  }
  G4double m12 = sqrt(m12s);       // Mass of the H1+H2 system
  G4LorentzVector dh4Mom(0.,0.,0.,m12);
  
  if(!DecayIn2(t4Mom,dh4Mom))
  {
    G4cerr<<"***G4QHadron::DecayIn3: Exception1"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
#ifdef debug
  G4cout<<"G4QHadron::DecayIn3: Now the last decay of m12="<<dh4Mom.m()<<G4endl;
#endif
  if(!G4QHadron(dh4Mom).DecayIn2(f4Mom,s4Mom))
  {
    G4cerr<<"***G4QHadron::DecayIn3: Error in DecayIn2 -> Exception2"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
  return true;
} // End of DecayIn3

Referenced by G4QNucleus::DecayMultyBaryon(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateBaryon(), and G4QNucleus::EvaporateNucleus().

Get3Momentum()

G4ThreeVector G4QHadron::Get3Momentum ( ) const

inline

Definition at line 80 of file G4QHadron.hh.

{return theMomentum.vect();}// Get 3-mom ofH

Referenced by G4QNucleus::Init3D().

Get4Momentum()

G4LorentzVector G4QHadron::Get4Momentum ( ) const

inline

Definition at line 79 of file G4QHadron.hh.

{return theMomentum;} // Get 4-mom of Hadron

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QEnvironment::CheckMassShell(), G4QNucleus::DecayAlphaAlpha(), G4QNucleus::DecayAlphaBar(), G4QNucleus::DecayAlphaDiN(), G4QNucleus::DecayAntiDibaryon(), G4QEnvironment::DecayAntistrange(), G4QNucleus::DecayAntiStrange(), G4QEnvironment::DecayBaryon(), G4QNucleus::DecayDibaryon(), G4QNucleus::DecayIsonucleus(), G4QEnvironment::DecayMeson(), G4QNucleus::DecayMultyBaryon(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4QEnvironment::Fragment(), G4QFragmentation::Fragment(), G4QIonIonCollision::Fragment(), G4QString::FragmentString(), G4QCandidate::G4QCandidate(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4QNucleus::G4QNucleus(), G4QNucleus::GetNucleons4Momentum(), G4QNucleus::Increase(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), G4QCandidate::operator=(), G4QEnvironment::operator=(), G4QNucleus::operator=(), G4QAtomicElectronScattering::PostStepDoIt(), G4QDiffraction::PostStepDoIt(), G4QInelastic::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QDiffractionRatio::ProjFragment(), G4QNucleus::SplitBaryon(), G4QString::Splitup(), and G4QNucleus::SubtractNucleon().

GetAntiColor()

std::list< G4QParton * > G4QHadron::GetAntiColor ( )

inline

Definition at line 94 of file G4QHadron.hh.

{return AntiColor;}//pointer to anti-quarks/diquarks

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

GetBaryonNumber()

G4int G4QHadron::GetBaryonNumber ( ) const

inline

Definition at line 181 of file G4QHadron.hh.

{return valQ.GetBaryonNumber();}

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QNucleus::DecayAntiDibaryon(), G4QEnvironment::DecayAntistrange(), G4QNucleus::DecayAntiStrange(), G4QEnvironment::DecayBaryon(), G4QNucleus::DecayDibaryon(), G4QEnvironment::DecayMeson(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QFragmentation::Fragment(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4QAtomicElectronScattering::PostStepDoIt(), G4QDiffraction::PostStepDoIt(), G4QInelastic::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QNucleus::PrepareCandidates(), G4QDiffractionRatio::ProjFragment(), and SplitInTwoPartons().

GetBindingEnergy()

G4double G4QHadron::GetBindingEnergy ( )

inline

Definition at line 91 of file G4QHadron.hh.

{return bindE;}// Returns binding E in NucMatter

GetCharge()

G4int G4QHadron::GetCharge ( ) const

inline

Definition at line 179 of file G4QHadron.hh.

{return valQ.GetCharge();}

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QEnvironment::DecayAntistrange(), G4QNucleus::DecayAntiStrange(), G4QEnvironment::DecayBaryon(), G4QEnvironment::DecayMeson(), G4QNucleus::EvaporateNucleus(), G4QEnvironment::Fragment(), G4QFragmentation::Fragment(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QAtomicElectronScattering::PostStepDoIt(), G4QDiffraction::PostStepDoIt(), G4QInelastic::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QNucleus::PrepareCandidates(), and G4QDiffractionRatio::ProjFragment().

GetColor()

std::list< G4QParton * > G4QHadron::GetColor ( )

inline

Definition at line 93 of file G4QHadron.hh.

{return Color;}  // pointer to quarks/anti-diquarks

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

GetEnergy()

G4double G4QHadron::GetEnergy ( ) const

inline

Definition at line 81 of file G4QHadron.hh.

{return theMomentum.e();} // Get E of Hadron

Referenced by G4QNucleus::Init3D().

GetFormationTime()

G4double G4QHadron::GetFormationTime ( )

inline

Definition at line 92 of file G4QHadron.hh.

{return formTime;} // Returns formation time

Referenced by G4QString::FragmentString().

GetMass()

G4double G4QHadron::GetMass ( ) const

inline

Definition at line 176 of file G4QHadron.hh.

{return theMomentum.m();}

Referenced by G4QFragmentation::Breeder(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateBaryon(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4QString::FragmentationMass(), G4QString::FragmentString(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4QString::LightFragmentationTest(), and G4QString::SplitEandP().

GetMass2()

G4double G4QHadron::GetMass2 ( ) const

inline

Definition at line 177 of file G4QHadron.hh.

{return theMomentum.m2();}

Referenced by G4QFragmentation::Breeder(), G4QFragmentation::ExciteSingDiffParticipants(), and G4QIonIonCollision::ExciteSingDiffParticipants().

GetNextAntiParton()

G4QParton * G4QHadron::GetNextAntiParton

(

)

Definition at line 1622 of file G4QHadron.cc.

{
  if(AntiColor.size() == 0) return 0;
  G4QParton* result = AntiColor.front();
  AntiColor.pop_front();
  return result;
}

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

GetNextParton()

G4QParton * G4QHadron::GetNextParton

(

)

Definition at line 1614 of file G4QHadron.cc.

{
  if(Color.size()==0) return 0;
  G4QParton* result = Color.back();
  Color.pop_back();
  return result;
}

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

GetNFragments()

G4int G4QHadron::GetNFragments ( ) const

inline

Definition at line 174 of file G4QHadron.hh.

{return nFragm;}

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QEnvironment::CheckMassShell(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QEnvironment::G4QEnvironment(), G4QNucleus::G4QNucleus(), G4QCandidate::operator=(), G4QNucleus::operator=(), G4QAtomicElectronScattering::PostStepDoIt(), and G4QInelastic::PostStepDoIt().

GetPDGCode()

G4int G4QHadron::GetPDGCode ( ) const

inline

Definition at line 170 of file G4QHadron.hh.

{return theQPDG.GetPDGCode();}

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QEnvironment::CheckMassShell(), G4QNucleus::ChooseFermiMomenta(), G4QNucleus::DecayAlphaAlpha(), G4QNucleus::DecayAlphaBar(), G4QNucleus::DecayAlphaDiN(), G4QNucleus::DecayAntiDibaryon(), G4QEnvironment::DecayAntistrange(), G4QNucleus::DecayAntiStrange(), G4QNucleus::DecayDibaryon(), G4QNucleus::DecayIsonucleus(), G4QNucleus::DecayMultyBaryon(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QEnvironment::Fragment(), G4QFragmentation::Fragment(), G4QIonIonCollision::Fragment(), G4QString::FragmentationMass(), G4QString::FragmentString(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), GetSpin(), G4QNucleus::operator*=(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), G4QAtomicElectronScattering::PostStepDoIt(), G4QDiffraction::PostStepDoIt(), G4QInelastic::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QNucleus::PrepareCandidates(), G4QDiffractionRatio::ProjFragment(), SplitUp(), G4QString::Splitup(), and G4QNucleus::SubtractNucleon().

GetPosition()

const G4ThreeVector & G4QHadron::GetPosition ( ) const

inline

Definition at line 182 of file G4QHadron.hh.

{return thePosition;}

Referenced by G4QNucleus::ChooseFermiMomenta(), G4QNucleus::DoTranslation(), G4QString::FragmentString(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), and SplitUp().

GetQC()

G4QContent G4QHadron::GetQC ( ) const

inline

Definition at line 173 of file G4QHadron.hh.

{return valQ;}

Referenced by G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QNucleus::DecayAlphaBar(), G4QNucleus::DecayAntiStrange(), G4QEnvironment::DecayBaryon(), G4QNucleus::DecayIsonucleus(), G4QEnvironment::DecayMeson(), G4QNucleus::DecayMultyBaryon(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QEnvironment::Fragment(), G4QFragmentation::Fragment(), G4QIonIonCollision::Fragment(), G4QCandidate::G4QCandidate(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4QNucleus::G4QNucleus(), G4QNucleus::Increase(), G4QNucleus::operator*=(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), G4QCandidate::operator=(), G4QEnvironment::operator=(), and G4QNucleus::operator=().

GetQCode()

G4int G4QHadron::GetQCode ( ) const

inline

Definition at line 171 of file G4QHadron.hh.

{return theQPDG.GetQCode();}

Referenced by G4QEnvironment::G4QEnvironment(), and G4QHadron().

GetQPDG()

G4QPDGCode G4QHadron::GetQPDG ( ) const

inline

Definition at line 172 of file G4QHadron.hh.

{return theQPDG;}

Referenced by G4QFragmentation::Breeder(), G4QEnvironment::CheckMassShell(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QNucleus::G4QNucleus(), G4QNucleus::GetGSMass(), G4QNucleus::GetMZNS(), G4QCandidate::operator=(), G4QNucleus::operator=(), G4QInelastic::PostStepDoIt(), and G4QNucleus::PrepareCandidates().

GetSpin()

G4double G4QHadron::GetSpin ( ) const

inline

Definition at line 78 of file G4QHadron.hh.

{return .5*(GetPDGCode()%10-1);}

GetStrangeness()

G4int G4QHadron::GetStrangeness ( ) const

inline

Definition at line 180 of file G4QHadron.hh.

{return valQ.GetStrangeness();}

Referenced by G4QNucleus::DecayAntiDibaryon(), G4QEnvironment::DecayAntistrange(), G4QNucleus::DecayAntiStrange(), G4QEnvironment::DecayBaryon(), G4QNucleus::DecayDibaryon(), G4QEnvironment::DecayMeson(), G4QDiffraction::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QNucleus::PrepareCandidates(), and G4QDiffractionRatio::ProjFragment().

GetWidth()

G4double G4QHadron::GetWidth

(

)

const

IncrementCollisionCount()

void G4QHadron::IncrementCollisionCount ( G4int  aCount )

inline

Definition at line 104 of file G4QHadron.hh.

{theCollisionCount+=aCount;}// IncrTheCCounter

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

Init3D()

void G4QHadron::Init3D

(

)

LorentzRotate()

void G4QHadron::LorentzRotate ( const G4LorentzRotation &  rotation )

inline

Definition at line 112 of file G4QHadron.hh.

{theMomentum=rotation*theMomentum;}

Referenced by G4QNucleus::DoLorentzRotation().

MakeAntiHadron()

void G4QHadron::MakeAntiHadron ( )

inline

Definition at line 185 of file G4QHadron.hh.

{if(TestRealNeutral()) NegPDGCode();}

Referenced by G4Quasmon::DecayQHadron().

NegPDGCode()

void G4QHadron::NegPDGCode ( )

inline

Definition at line 191 of file G4QHadron.hh.

{theQPDG.NegPDGCode(); valQ.Anti();}

Referenced by MakeAntiHadron().

operator!=()

G4bool G4QHadron::operator!= ( const G4QHadron &  right ) const

inline

Definition at line 168 of file G4QHadron.hh.

{return this!=&rhs;}

operator=()

const G4QHadron & G4QHadron::operator=

(

const G4QHadron &

right

)

Definition at line 191 of file G4QHadron.cc.

{
  if(this != &right)                          // Beware of self assignment
  {
    theMomentum         = right.theMomentum;
    theQPDG             = right.theQPDG;
    valQ                = right.valQ;
    nFragm              = right.nFragm;
    thePosition         = right.thePosition;      
    theCollisionCount   = 0;
    isSplit             = false;
    Direction           = right.Direction;
    bindE               = right.bindE;
  }
  return *this;
}

operator==()

G4bool G4QHadron::operator== ( const G4QHadron &  right ) const

inline

Definition at line 167 of file G4QHadron.hh.

{return this==&rhs;}

RandomizeMass()

G4double G4QHadron::RandomizeMass	(	G4QParticle *	pPart,
		G4double	maxM
	)

Definition at line 1035 of file G4QHadron.cc.

{
  G4double meanM = theQPDG.GetMass();
  G4double width = theQPDG.GetWidth()/2.;
#ifdef debug
  G4cout<<"G4QHadron::RandomizeMass: meanM="<<meanM<<", halfWidth="<<width<<G4endl;
#endif
  if(maxM<meanM-3*width) 
  {
#ifdef debug
    G4cout<<"***G4QH::RandM:m=0 maxM="<<maxM<<"<meanM="<<meanM<<"-3*halfW="<<width<<G4endl;
#endif
    return 0.;
  }
  ///////////////G4double theMass  = 0.;
  if(width==0.)
  {
#ifdef debug
    if(meanM>maxM) G4cerr<<"***G4QHadron::RandM:Stable m="<<meanM<<">maxM="<<maxM<<G4endl;
#endif
    return meanM;
    //return 0.;
  }
  else if(width<0.)
  {
    // G4cerr<<"***G4QHadron::RandM: width="<<width<<"<0,PDGC="<<theQPDG.GetPDGCode()<<G4endl;
    // throw G4QException("G4QHadron::RandomizeMass: with the width of the Hadron < 0.");
    G4ExceptionDescription ed;
    ed << "width of the Hadron < 0. : width=" << width << "<0,PDGC="
       << theQPDG.GetPDGCode() << G4endl;
    G4Exception("G4QHadron::RandomizeMass()", "HAD_CHPS_0000", FatalException, ed);
  }
  G4double minM = pPart->MinMassOfFragm();
  if(minM>maxM)
  {
#ifdef debug
    G4cout<<"***G4QHadron::RandomizeMass:for PDG="<<theQPDG.GetPDGCode()<<" minM="<<minM
          <<" > maxM="<<maxM<<G4endl;
#endif
    return 0.;
  }
  //Now calculate the Breit-Wigner distribution with two cuts
  G4double v1=atan((minM-meanM)/width);
  G4double v2=atan((maxM-meanM)/width);
  G4double dv=v2-v1;
#ifdef debug
  G4cout<<"G4QHadr::RandM:Mi="<<minM<<",i="<<v1<<",Ma="<<maxM<<",a="<<v2<<","<<dv<<G4endl;
#endif
  return meanM+width*tan(v1+dv*G4UniformRand());
}

Referenced by G4QHadron().

RelDecayIn2()

G4bool G4QHadron::RelDecayIn2	(	G4LorentzVector &	f4Mom,
		G4LorentzVector &	s4Mom,
		G4LorentzVector &	dir,
		G4double	maxCost = 1.,
		G4double	minCost = -1.
	)

Definition at line 296 of file G4QHadron.cc.

{
  G4double fM2 = f4Mom.m2();
  G4double fM  = sqrt(fM2);              // Mass of the 1st Hadron
  G4double sM2 = s4Mom.m2();
  G4double sM  = sqrt(sM2);              // Mass of the 2nd Hadron
  G4double iM2 = theMomentum.m2();
  G4double iM  = sqrt(iM2);              // Mass of the decaying hadron
  G4double vP  = theMomentum.rho();      // Momentum of the decaying hadron
  G4double dE  = theMomentum.e();        // Energy of the decaying hadron
  if(dE<vP)
  {
    G4cerr<<"***G4QHad::RelDecIn2: Tachionic 4-mom="<<theMomentum<<", E-p="<<dE-vP<<G4endl;
    G4double accuracy=.000001*vP;
    G4double emodif=std::fabs(dE-vP);
    //if(emodif<accuracy)
    //{
      G4cerr<<"G4QHadron::RelDecIn2: *Boost* E-p shift is corrected to "<<emodif<<G4endl;
      theMomentum.setE(vP+emodif+.01*accuracy);
    //}
  }
  G4ThreeVector ltb = theMomentum.boostVector();// Boost vector for backward Lorentz Trans.
  G4ThreeVector ltf = -ltb;              // Boost vector for forward Lorentz Trans.
  G4LorentzVector cdir = dir;            // A copy to make a transformation to CMS
#ifdef ppdebug
  if(cdir.e()+.001<cdir.rho()) G4cerr<<"*G4QH::RDIn2:*Boost* cd4M="<<cdir<<",e-p="
                                     <<cdir.e()-cdir.rho()<<G4endl;
#endif
  cdir.boost(ltf);                       // Direction transpormed to CMS of the Momentum
  G4ThreeVector vdir = cdir.vect();      // 3-Vector of the direction-particle
#ifdef ppdebug
  G4cout<<"G4QHad::RelDI2:dir="<<dir<<",ltf="<<ltf<<",cdir="<<cdir<<",vdir="<<vdir<<G4endl;
#endif
  G4ThreeVector vx(0.,0.,1.);            // Ort in the direction of the reference particle
  G4ThreeVector vy(0.,1.,0.);            // First ort orthogonal to the direction
  G4ThreeVector vz(1.,0.,0.);            // Second ort orthoganal to the direction
  if(vdir.mag2() > 0.)                   // the refference particle isn't at rest in CMS
  {
    vx = vdir.unit();                    // Ort in the direction of the reference particle
#ifdef ppdebug
    G4cout<<"G4QH::RelDecIn2:Vx="<<vx<<",M="<<theMomentum<<",d="<<dir<<",c="<<cdir<<G4endl;
#endif
    G4ThreeVector vv= vx.orthogonal();   // Not normed orthogonal vector (!)
    vy = vv.unit();                      // First ort orthogonal to the direction
    vz = vx.cross(vy);                   // Second ort orthoganal to the direction
  }
#ifdef ppdebug
  G4cout<<"G4QHad::RelDecIn2:iM="<<iM<<"=>fM="<<fM<<"+sM="<<sM<<",ob="<<vx<<vy<<vz<<G4endl;
#endif
  if(maxCost> 1.) maxCost= 1.;
  if(minCost<-1.) minCost=-1.;
  if(maxCost<-1.) maxCost=-1.;
  if(minCost> 1.) minCost= 1.;
  if(minCost> maxCost) minCost=maxCost;
  if(fabs(iM-fM-sM)<.00000001)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    return true;
  }
  else if (iM+.001<fM+sM || iM==0.)
  {//@@ Later on make a quark content check for the decay
    G4cerr<<"***G4QH::RelDecIn2: fM="<<fM<<"+sM="<<sM<<">iM="<<iM<<",d="<<iM-fM-sM<<G4endl;
    return false;
  }
  G4double d2 = iM2-fM2-sM2;
  G4double p2 = (d2*d2/4.-fM2*sM2)/iM2;    // Decay momentum(^2) in CMS of Quasmon
  if(p2<0.)
  {
#ifdef ppdebug
    G4cout<<"**G4QH:RDIn2:p2="<<p2<<"<0,d2^2="<<d2*d2/4.<<"<4*fM2*sM2="<<4*fM2*sM2<<G4endl;
#endif
    p2=0.;
  }
  G4double p  = sqrt(p2);
  G4double ct = maxCost;
  if(maxCost>minCost)
  {
    G4double dcost=maxCost-minCost;
    ct = minCost+dcost*G4UniformRand();
  }
  G4double phi= twopi*G4UniformRand();  // @@ Change 360.*deg to M_TWOPI (?)
  G4double ps=0.;
  if(fabs(ct)<1.) ps = p * sqrt(1.-ct*ct);
  else
  {
#ifdef ppdebug
    G4cout<<"**G4QH::RDIn2:ct="<<ct<<",mac="<<maxCost<<",mic="<<minCost<<G4endl;
    //throw G4QException("***G4QHadron::RDIn2: bad cos(theta)");
#endif
    if(ct>1.) ct=1.;
    if(ct<-1.) ct=-1.;
  }
  G4ThreeVector pVect=(ps*sin(phi))*vz+(ps*cos(phi))*vy+p*ct*vx;
#ifdef ppdebug
  G4cout<<"G4QH::RelDIn2:ct="<<ct<<",p="<<p<<",ps="<<ps<<",ph="<<phi<<",v="<<pVect<<G4endl;
#endif
 
  f4Mom.setVect(pVect);
  f4Mom.setE(sqrt(fM2+p2));
  s4Mom.setVect((-1)*pVect);
  s4Mom.setE(sqrt(sM2+p2));
  
#ifdef ppdebug
  G4cout<<"G4QHadr::RelDecIn2:p2="<<p2<<",v="<<ltb<<",f4M="<<f4Mom<<" + s4M="<<s4Mom<<" = "
        <<f4Mom+s4Mom<<", M="<<iM<<G4endl;
#endif
  if(f4Mom.e()+.001<f4Mom.rho())G4cerr<<"*G4QH::RDIn2:*Boost* f4M="<<f4Mom<<",e-p="
                                      <<f4Mom.e()-f4Mom.rho()<<G4endl;
  f4Mom.boost(ltb);                        // Lor.Trans. of 1st hadron back to LS
  if(s4Mom.e()+.001<s4Mom.rho())G4cerr<<"*G4QH::RDIn2:*Boost* s4M="<<s4Mom<<",e-p="
                                      <<s4Mom.e()-s4Mom.rho()<<G4endl;
  s4Mom.boost(ltb);                        // Lor.Trans. of 2nd hadron back to LS
#ifdef ppdebug
  G4cout<<"G4QHadron::RelDecayIn2:Output, f4Mom="<<f4Mom<<" + s4Mom="<<s4Mom<<" = "
        <<f4Mom+s4Mom<<", d4M="<<theMomentum-f4Mom-s4Mom<<G4endl;
#endif
  return true;
} // End of "RelDecayIn2"

Referenced by RelDecayIn3().

RelDecayIn3()

G4bool G4QHadron::RelDecayIn3	(	G4LorentzVector &	fh4M,
		G4LorentzVector &	sh4M,
		G4LorentzVector &	th4Mom,
		G4LorentzVector &	dir,
		G4double	maxCost = 1.,
		G4double	minCost = -1.
	)

Definition at line 866 of file G4QHadron.cc.

{
#ifdef debug
  G4cout<<"G4QH::RelDIn3:"<<theMomentum<<"=>f="<<f4Mom<<"+s="<<s4Mom<<"+t="<<t4Mom<<G4endl;
#endif
  G4double iM  = theMomentum.m();  // Mass of the decaying hadron
  G4double fM  = f4Mom.m();        // Mass of the 1st hadron
  G4double sM  = s4Mom.m();        // Mass of the 2nd hadron
  G4double tM  = t4Mom.m();        // Mass of the 3rd hadron
  G4double eps = 0.001;            // Accuracy of the split condition
  if (fabs(iM-fM-sM-tM)<=eps)
  {
    G4double fR=fM/iM;
    G4double sR=sM/iM;
    G4double tR=tM/iM;
    f4Mom=fR*theMomentum;
    s4Mom=sR*theMomentum;
    t4Mom=tR*theMomentum;
    return true;
  }
  if (iM+eps<fM+sM+tM)
  {
    G4cout<<"***G4QHadron::RelDecayIn3:fM="<<fM<<" + sM="<<sM<<" + tM="<<tM<<" > iM="<<iM
          <<",d="<<iM-fM-sM-tM<<G4endl;
    return false;
  }
  G4double fM2 = fM*fM;
  G4double sM2 = sM*sM;
  G4double tM2 = tM*tM;
  G4double iM2 = iM*iM;
  G4double m13sBase=(iM-sM)*(iM-sM)-(fM+tM)*(fM+tM);
  G4double m12sMin =(fM+sM)*(fM+sM);
  G4double m12sBase=(iM-tM)*(iM-tM)-m12sMin;
  G4double rR = 0.;
  G4double rnd= 1.;
#ifdef debug
  G4int    tr = 0;                 //@@ Comment if "cout" below is skiped @@
#endif
  G4double m12s = 0.;              // Fake definition before the Loop
  while (rnd > rR)
  {
    m12s = m12sMin + m12sBase*G4UniformRand();
    G4double e1=m12s+fM2-sM2;
    G4double e2=iM2-m12s-tM2;
    G4double four12=4*m12s;
    G4double m13sRange=0.;
    G4double dif=(e1*e1-four12*fM2)*(e2*e2-four12*tM2);
    if(dif<0.)
    {
#ifdef debug
      if(dif<-.01) G4cerr<<"G4QHadron::RelDecayIn3:iM="<<iM<<",tM="<<tM<<",sM="<<sM<<",fM="
                         <<fM<<",m12(s+f)="<<sqrt(m12s)<<", d="<<iM-fM-sM-tM<<G4endl;
#endif
    }
    else m13sRange=sqrt(dif)/m12s;
    rR = m13sRange/m13sBase;
    rnd= G4UniformRand();
#ifdef debug
    G4cout<<"G4QHadron::RelDecayIn3: try decay #"<<++tr<<", rR="<<rR<<",rnd="<<rnd<<G4endl;
#endif
  }
  G4double m12 = sqrt(m12s);       // Mass of the H1+H2 system
  G4LorentzVector dh4Mom(0.,0.,0.,m12);
  
  if(!RelDecayIn2(t4Mom,dh4Mom,dir,maxCost,minCost))
  {
    G4cerr<<"***G4QHadron::RelDecayIn3: Exception1"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
#ifdef debug
  G4cout<<"G4QHadron::RelDecayIn3: Now the last decay of m12="<<dh4Mom.m()<<G4endl;
#endif
  if(!G4QHadron(dh4Mom).DecayIn2(f4Mom,s4Mom))
  {
    G4cerr<<"***G4QHadron::RelDecayIn3: Error in DecayIn2 -> Exception2"<<G4endl;
    //throw G4QException("G4QHadron::DecayIn3(): DecayIn2 did not succeed");
    return false;
  }
  return true;
} // End of RelDecayIn3

Set4Momentum()

void G4QHadron::Set4Momentum ( const G4LorentzVector &  aMom )

inline

Definition at line 187 of file G4QHadron.hh.

{theMomentum=aMom;}

Referenced by G4QFragmentation::Breeder(), G4QIonIonCollision::Breeder(), G4QNucleus::CalculateMass(), G4QEnvironment::CheckMassShell(), G4QNucleus::DecayAlphaAlpha(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::ExciteDiffParticipants(), G4QIonIonCollision::ExciteDiffParticipants(), G4QFragmentation::ExciteSingDiffParticipants(), G4QIonIonCollision::ExciteSingDiffParticipants(), G4QFragmentation::Fragment(), G4QString::FragmentString(), G4QCandidate::G4QCandidate(), G4QEnvironment::G4QEnvironment(), G4QFragmentation::G4QFragmentation(), G4QIonIonCollision::G4QIonIonCollision(), G4QNucleus::G4QNucleus(), G4QNucleus::Increase(), G4QNucleus::InitByPDG(), G4QCandidate::operator=(), G4QNucleus::operator=(), G4QInelastic::PostStepDoIt(), G4QDiffractionRatio::ProjFragment(), and G4QString::Splitup().

SetBindingEnergy()

void G4QHadron::SetBindingEnergy ( G4double  aBindE )

inline

Definition at line 109 of file G4QHadron.hh.

{bindE=aBindE;}// Set Binding E in Nuclear Matter

Referenced by G4QNucleus::Init3D().

SetFormationTime()

void G4QHadron::SetFormationTime ( G4double  fT )

inline

Definition at line 113 of file G4QHadron.hh.

{formTime=fT;}  // Defines formationTime for the Hadron

Referenced by G4QString::FragmentString().

SetNFragments()

void G4QHadron::SetNFragments ( const G4int &  nf )

inline

Definition at line 188 of file G4QHadron.hh.

{nFragm=nf;}

Referenced by G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QNucleus::G4QNucleus(), G4QNucleus::InitByPDG(), G4QCandidate::operator=(), and G4QNucleus::operator=().

SetPDGCode()

void G4QHadron::SetPDGCode ( const G4QPDGCode &  PDG )

inline

Definition at line 97 of file G4QHadron.hh.

{SetQPDG(G4QPDGCode(PDG));}// Set PDGCode of Hadron

Referenced by G4QFragmentation::Fragment().

SetPosition()

void G4QHadron::SetPosition ( const G4ThreeVector &  aPosition )

inline

Definition at line 189 of file G4QHadron.hh.

{thePosition=position;}

Referenced by G4QNucleus::ChoosePositions(), G4QNucleus::DoTranslation(), G4QString::FragmentString(), and G4QString::Splitup().

SetQC()

void G4QHadron::SetQC ( const G4QContent &  newQC )

inline

Definition at line 186 of file G4QHadron.hh.

{valQ=newQC;}

Referenced by G4QFragmentation::Breeder(), G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QNucleus::G4QNucleus(), G4QNucleus::operator*=(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), G4QCandidate::operator=(), and G4QNucleus::operator=().

SetQPDG()

void G4QHadron::SetQPDG

(

const G4QPDGCode &

QPDG

)

Definition at line 275 of file G4QHadron.cc.

{
  theQPDG  = newQPDG;
  G4int PDG= newQPDG.GetPDGCode();
  G4int Q  = newQPDG.GetQCode();
#ifdef debug
  G4cout<<"G4QHadron::SetQPDG is called with PDGCode="<<PDG<<", QCode="<<Q<<G4endl;
#endif
  if     (Q>-1) valQ=theQPDG.GetQuarkContent();
  else if(PDG>80000000) DefineQC(PDG);
  else
  {
    // G4cerr<<"***G4QHadron::SetQPDG: QPDG="<<newQPDG<<G4endl;
    // throw G4QException("***G4QHadron::SetQPDG: Impossible QPDG Probably a Chipolino");
    G4ExceptionDescription ed;
    ed << "Impossible QPDG Probably a Chipolino:  QPDG=" << newQPDG << G4endl;
    G4Exception("G4QHadron::SetQPDG()", "HAD_CHPS_0000", FatalException, ed);
  }
}

Referenced by G4QFragmentation::Breeder(), G4QEnvironment::DecayBaryon(), G4QEnvironment::DecayMeson(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QEnvironment::G4QEnvironment(), G4QNucleus::G4QNucleus(), G4QNucleus::InitByPDG(), G4QNucleus::operator*=(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), G4QCandidate::operator=(), G4QNucleus::operator=(), G4QInelastic::PostStepDoIt(), G4QDiffractionRatio::ProjFragment(), and SetPDGCode().

SplitInTwoPartons()

G4QPartonPair * G4QHadron::SplitInTwoPartons

(

)

Definition at line 1631 of file G4QHadron.cc.

{
  if(std::abs(GetBaryonNumber())>1) // Not Baryons or Mesons or Anti-Baryons
  {
    G4cerr<<"***G4QHadron::SplitInTwoPartons: Can not split QC="<<valQ<< G4endl;
    G4Exception("G4QFragmentation::ChooseX:","72",FatalException,"NeitherMesonNorBaryon");
  }
  std::pair<G4int,G4int> PP = valQ.MakePartonPair();
  return new G4QPartonPair(new G4QParton(PP.first), new G4QParton(PP.second));
}

SplitUp()

void G4QHadron::SplitUp

(

)

Definition at line 1087 of file G4QHadron.cc.

{  
  if (isSplit) return;
#ifdef pdebug
  G4cout<<"G4QHadron::SplitUp ***IsCalled***, before Splitting nC="<<Color.size()
        <<", SoftColCount="<<theCollisionCount<<G4endl;
#endif
  isSplit=true;                                     // PutUp isSplit flag to avoid remake
  if (!Color.empty()) return;                       // Do not split if it is already split
  if (!theCollisionCount)                           // Diffractive splitting from particDef
  {
    G4QParton* Left = 0;
    G4QParton* Right = 0;
    GetValenceQuarkFlavors(Left, Right);
    G4ThreeVector Pos=GetPosition();
    Left->SetPosition(Pos);
    Right->SetPosition(Pos);
  
    G4double theMomPlus  = theMomentum.plus();      // E+pz
    G4double theMomMinus = theMomentum.minus();     // E-pz
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* possition="<<Pos<<", 4M="<<theMomentum<<G4endl;
#endif
 
    // momenta of string ends 
    G4double pt2 = theMomentum.perp2();
    G4double transverseMass2 = theMomPlus*theMomMinus;
    if(transverseMass2<0.) transverseMass2=0.;
    G4double maxAvailMomentum2 = sqr(std::sqrt(transverseMass2) - std::sqrt(pt2));
    G4ThreeVector pt(0., 0., 0.); // Prototype
    if(maxAvailMomentum2/widthOfPtSquare > 0.01)
                                         pt=GaussianPt(widthOfPtSquare, maxAvailMomentum2);
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* maxMom2="<<maxAvailMomentum2<<", pt="<<pt<<G4endl;
#endif
    G4LorentzVector LeftMom(pt, 0.);
    G4LorentzVector RightMom;
    RightMom.setPx(theMomentum.px() - pt.x());
    RightMom.setPy(theMomentum.py() - pt.y());
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* right4m="<<RightMom<<", left4M="<<LeftMom<<G4endl;
#endif
    G4double Local1 = theMomMinus + (RightMom.perp2() - LeftMom.perp2()) / theMomPlus;
    G4double Local2 = std::sqrt(std::max(0., Local1*Local1 -
                                             4*RightMom.perp2()*theMomMinus / theMomPlus));
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp:Dif,L1="<<Local1<<",L2="<<Local2<<",D="<<Direction<<G4endl;
#endif
    if (Direction) Local2 = -Local2;
    G4double RightMinus   = 0.5*(Local1 + Local2);
    G4double LeftMinus = theMomentum.minus() - RightMinus;
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* Rminus="<<RightMinus<<",Lminus="<<LeftMinus<<",hmm="
          <<theMomentum.minus()<<G4endl;
#endif
    G4double LeftPlus  = 0.;
    if(LeftMinus) LeftPlus  = LeftMom.perp2()/LeftMinus;
    G4double RightPlus = theMomentum.plus() - LeftPlus;
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* Rplus="<<RightPlus<<", Lplus="<<LeftPlus<<G4endl;
#endif
    LeftMom.setPz(0.5*(LeftPlus - LeftMinus));
    LeftMom.setE (0.5*(LeftPlus + LeftMinus));
    RightMom.setPz(0.5*(RightPlus - RightMinus));
    RightMom.setE (0.5*(RightPlus + RightMinus));
    //G4cout<<"DSU 6: Left4M="<<LeftMom<<", Right4M="<<RightMom<<G4endl;
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Dif* -final- R4m="<<RightMom<<", L4M="<<LeftMom<<", L+R="
          <<RightMom+LeftMom<<", D4M="<<theMomentum-RightMom+LeftMom<<G4endl;
#endif
    Left->Set4Momentum(LeftMom);
    Right->Set4Momentum(RightMom);
    Color.push_back(Left);
    AntiColor.push_back(Right);
  }
  else
  {
    // Soft hadronization splitting: sample transversal momenta for sea and valence quarks
    //G4double phi, pts;
    G4ThreeVector SumP(0.,0.,0.);                         // Remember the hadron position
    G4ThreeVector Pos = GetPosition();                    // Remember the hadron position
    G4int nSeaPair = theCollisionCount-1;                 // a#of sea-pairs
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp:*Soft* Pos="<<Pos<<", nSeaPair="<<nSeaPair<<G4endl;
#endif   
    // here the condition,to ensure viability of splitting, also in cases
    // where difractive excitation occured together with soft scattering.
    for (G4int aSeaPair = 0; aSeaPair < nSeaPair; aSeaPair++) // If the sea pairs exist!
    {
      //  choose quark flavour, d:u:s = 1:1:(1/StrangeSuppress-2)
      G4int aPDGCode = 1 + (G4int)(G4UniformRand()/StrangeSuppress); 
 
      //  BuildSeaQuark() determines quark spin, isospin and colour 
      //  via parton-constructor G4QParton(aPDGCode) 
      G4QParton* aParton = BuildSeaQuark(false, aPDGCode); // quark/anti-diquark creation
 
      // save colour a spin-3 for anti-quark
      G4int firstPartonColour = aParton->GetColour();
      G4double firstPartonSpinZ = aParton->GetSpinZ();
#ifdef pdebug
      G4cout<<"G4QHadron::SplitUp:*Soft* Part1 PDG="<<aPDGCode<<", Col="<<firstPartonColour
            <<", SpinZ="<<firstPartonSpinZ<<", 4M="<<aParton->Get4Momentum()<<G4endl;
#endif
      SumP+=aParton->Get4Momentum();
      Color.push_back(aParton);                           // Quark/anti-diquark is filled
 
      // create anti-quark
      aParton = BuildSeaQuark(true, aPDGCode); // Redefine "aParton" (working pointer)
      aParton->SetSpinZ(-firstPartonSpinZ);
      aParton->SetColour(-firstPartonColour);
#ifdef pdebug
      G4cout<<"G4QHadron::SplUp:Sft,P2="<<aParton->Get4Momentum()<<",i="<<aSeaPair<<G4endl;
#endif
 
      SumP+=aParton->Get4Momentum();
      AntiColor.push_back(aParton);                       // Anti-quark/diquark is filled
#ifdef pdebug
      G4cout<<"G4QHadron::SplUp:*Sft* Antiquark is filled, i="<<aSeaPair<<G4endl;
#endif
    }
    // ---- Create valence quarks/diquarks
    G4QParton* pColorParton = 0;
    G4QParton* pAntiColorParton = 0;
    GetValenceQuarkFlavors(pColorParton, pAntiColorParton);
    G4int ColorEncoding = pColorParton->GetPDGCode();
#ifdef pdebug
    G4int AntiColorEncoding = pAntiColorParton->GetPDGCode();
    G4cout<<"G4QHadron::SplUp:*Sft*,C="<<ColorEncoding<<", AC="<<AntiColorEncoding<<G4endl;
#endif
    G4ThreeVector ptr = GaussianPt(sigmaPt, DBL_MAX);
    SumP += ptr;
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Sft*, ptr="<<ptr<<G4endl;
#endif
 
    if (ColorEncoding < 0) // use particle definition
    {
      G4LorentzVector ColorMom(-SumP, 0);
      pColorParton->Set4Momentum(ColorMom);
      G4LorentzVector AntiColorMom(ptr, 0.);
      pAntiColorParton->Set4Momentum(AntiColorMom);
    }
    else
    {
      G4LorentzVector ColorMom(ptr, 0);
      pColorParton->Set4Momentum(ColorMom);
      G4LorentzVector AntiColorMom(-SumP, 0);
      pAntiColorParton->Set4Momentum(AntiColorMom);
    }
    Color.push_back(pColorParton);
    AntiColor.push_back(pAntiColorParton);
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Soft* Col&Anticol are filled PDG="<<GetPDGCode()<<G4endl;
#endif
    // Sample X
    G4int nColor=Color.size();
    G4int nAntiColor=AntiColor.size();
    if(nColor!=nAntiColor || nColor != nSeaPair+1)
    {
      G4cerr<<"***G4QHadron::SplitUp: nA="<<nAntiColor<<",nAC="<<nColor<<",nSea="<<nSeaPair
             <<G4endl;
      G4Exception("G4QHadron::SplitUp:","72",FatalException,"Colours&AntiColours notSinc");
    }
#ifdef pdebug
    G4cout<<"G4QHad::SpUp:,nPartons="<<nColor+nColor<<G4endl;
#endif
    G4int dnCol=nColor+nColor;
    // From here two algorithm of splitting can be used (All(default): New, OBO: Olg, Bad)
    G4double* xs=RandomX(dnCol);        // All-Non-iterative CHIPS algorithm of splitting
    // Instead one can try one-by-one CHIPS algorithm (faster? but not exact). OBO comment.
    //G4double Xmax=1.;                   // OBO
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp:*Sft* Loop ColorX="<<ColorX<<G4endl;
#endif
    std::list<G4QParton*>::iterator icolor = Color.begin();
    std::list<G4QParton*>::iterator ecolor = Color.end();
    std::list<G4QParton*>::iterator ianticolor = AntiColor.begin();
    std::list<G4QParton*>::iterator eanticolor = AntiColor.end();
    G4int xi=-1;                        // XIndex for All-Non-interactive CHIPS algorithm
    //G4double X=0.;                      // OBO
    for ( ; icolor != ecolor && ianticolor != eanticolor; ++icolor, ++ianticolor)
    {
      (*icolor)->SetX(xs[++xi]);        // All-Non-iterative CHIPS algorithm of splitting
      //X=SampleCHIPSX(Xmax, dnCol);      // OBO
      //Xmax-=X;                          // OBO
      //--dnCol;                          // OBO
      //(*icolor)->SetX(X);               // OBO
      // ----
      (*icolor)->DefineEPz(theMomentum);
      (*ianticolor)->SetX(xs[++xi]);    // All-Non-iterative CHIPS algorithm of splitting
      //X=SampleCHIPSX(Xmax, dnCol);      // OBO
      //Xmax-=X;                          // OBO
      //--dnCol;                          // OBO
      //(*ianticolor)->SetX(X);           // OBO 
      // ----
      (*ianticolor)->DefineEPz(theMomentum);
    }
    delete[] xs;                           // The calculated array must be deleted (All)
#ifdef pdebug
    G4cout<<"G4QHadron::SplitUp: *Soft* ===> End, ColSize="<<Color.size()<<G4endl;
#endif
    return;
  }
} // End of SplitUp

Referenced by G4QInteraction::SplitHadrons().

TestRealNeutral()

G4bool G4QHadron::TestRealNeutral ( )

inline

Definition at line 192 of file G4QHadron.hh.

{ return theQPDG.TestRealNeutral();}

Referenced by MakeAntiHadron().

Member Data Documentation

theMomentum

G4LorentzVector G4QHadron::theMomentum

protected

Definition at line 143 of file G4QHadron.hh.

Referenced by Boost(), CopDecayIn2(), CopDecayIn3(), CorEDecayIn2(), CorMDecayIn2(), DecayIn2(), DecayIn3(), G4QNucleus::DeleteNucleons(), G4QNucleus::DoLorentzBoost(), G4QNucleus::DoLorentzRotation(), G4QHadron(), Get3Momentum(), Get4Momentum(), GetEnergy(), GetMass(), GetMass2(), LorentzRotate(), G4QNucleus::operator*=(), G4QNucleus::operator+=(), G4QNucleus::operator-=(), operator=(), RelDecayIn2(), RelDecayIn3(), Set4Momentum(), G4QNucleus::Split2Baryons(), SplitUp(), and G4QNucleus::SubtractNucleon().

---

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

• G4QHadron.hh
• G4QHadron.cc