#include <G4QGSMFragmentation.hh>

Inheritance diagram for G4QGSMFragmentation:

Public Member Functions
void	ActivateFor (const G4Element *anElement)

void	ActivateFor (const G4Material *aMaterial)

void	AddNewParticles ()

G4HadFinalState *	ApplyYourself (const G4HadProjectile &, G4Nucleus &) final

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

void	DeActivateFor (const G4Element *anElement)

void	DeActivateFor (const G4Material *aMaterial)

void	EraseNewParticles ()

virtual G4KineticTrackVector *	FragmentString (const G4ExcitedString &theString)

	G4QGSMFragmentation ()

virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const

virtual const std::pair< G4double, G4double >	GetFatalEnergyCheckLevels () const

G4double	GetMaxEnergy () const

G4double	GetMaxEnergy (const G4Material aMaterial, const G4Element anElement) const

G4double	GetMinEnergy () const

G4double	GetMinEnergy (const G4Material aMaterial, const G4Element anElement) const

const G4String &	GetModelName () const

G4double	GetRecoilEnergyThreshold () const

G4int	GetVerboseLevel () const

virtual void	InitialiseModel ()

virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)

G4bool	IsBlocked (const G4Element *anElement) const

G4bool	IsBlocked (const G4Material *aMaterial) const

virtual void	ModelDescription (std::ostream &outFile) const

G4bool	operator!= (const G4HadronicInteraction &right) const =delete

G4bool	operator== (const G4HadronicInteraction &right) const =delete

virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)

G4int	SampleQuarkFlavor (void)

G4ThreeVector	SampleQuarkPt (G4double ptMax=-1.)

void	SetDiquarkBreakProbability (G4double aValue)

void	SetDiquarkSuppression (G4double aValue)

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

void	SetMaxEnergy (const G4double anEnergy)

void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)

void	SetMinEnergy (G4double anEnergy)

void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)

void	SetMinimalStringMass (const G4FragmentingString *const string)

void	SetMinimalStringMass2 (const G4double aValue)

void	SetMinMasses ()

void	SetProbBBbar (G4double aValue)

void	SetProbCCbar (G4double aValue)

void	SetProbEta_b (G4double aValue)

void	SetProbEta_c (G4double aValue)

void	SetRecoilEnergyThreshold (G4double val)

void	SetScalarMesonMixings (std::vector< G4double > aVector)

void	SetSigmaTransverseMomentum (G4double aQT)

void	SetSpinThreeHalfBarionProbability (G4double aValue)

void	SetStrangenessSuppression (G4double aValue)

void	SetStringTensionParameter (G4double aValue)

void	SetVectorMesonMixings (std::vector< G4double > aVector)

void	SetVectorMesonProbability (G4double aValue)

void	SetVerboseLevel (G4int value)

	~G4QGSMFragmentation ()

Data Fields
G4int	Baryon [5][5][5][4]

G4double	BaryonWeight [5][5][5][4]

G4int	DecayQuark

G4ParticleDefinition *	FS_LeftHadron [350]

G4ParticleDefinition *	FS_RightHadron [350]

G4double	FS_Weight [350]

G4double	Mass_of_b_quark

G4double	Mass_of_c_quark

G4double	Mass_of_light_quark

G4double	Mass_of_s_quark

G4double	Mass_of_string_junction

G4int	Meson [5][5][7]

G4double	MesonWeight [5][5][7]

G4double	MinimalStringMass

G4double	MinimalStringMass2

G4double	minMassQDiQStr [5][5][5]

G4double	minMassQQbarStr [5][5]

G4int	NewQuark

G4int	NumberOf_FS

G4double	Prob_QQbar [5]

G4int	Qcharge [5]

Protected Types
typedef G4ParticleDefinition (G4HadronBuilder::	Pcreate) (G4ParticleDefinition , G4ParticleDefinition )

typedef std::pair< G4ParticleDefinition , G4ParticleDefinition >	pDefPair

Protected Member Functions
void	Block ()

void	CalculateHadronTimePosition (G4double theInitialStringMass, G4KineticTrackVector *)

void	ConstructParticle ()

G4ExcitedString *	CopyExcited (const G4ExcitedString &string)

G4ParticleDefinition *	CreateHadron (G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin)

pDefPair	CreatePartonPair (G4int NeedParticle, G4bool AllowDiquarks=true)

G4ParticleDefinition *	FindParticle (G4int Encoding)

G4int	GetClusterLoopInterrupt ()

G4double	GetDiquarkBreakProb ()

G4double	GetDiquarkSuppress ()

G4double	GetMassCut ()

G4double	GetProbBBbar ()

G4double	GetProbCCbar ()

G4double	GetProbEta_b ()

G4double	GetProbEta_c ()

G4double	GetStrangeSuppress ()

G4double	GetStringTensionParameter ()

G4bool	IsBlocked () const

G4double	PossibleHadronMass (const G4FragmentingString const string, Pcreate build=0, pDefPair pdefs=0)

G4KineticTrackVector *	ProduceOneHadron (const G4ExcitedString *const theString)

virtual G4ParticleDefinition *	QuarkSplitup (G4ParticleDefinition decay, G4ParticleDefinition &created)

virtual void	SetMassCut (G4double aValue)

void	SetModelName (const G4String &nam)

Protected Attributes
G4int	ClusterLoopInterrupt

G4double	DiquarkBreakProb

G4double	DiquarkSuppress

G4HadronBuilder *	hadronizer

G4bool	isBlocked

G4double	Kappa

G4double	MassCut

G4double	MaxMass

std::vector< G4ParticleDefinition * >	NewParticles

G4bool	PastInitPhase

G4double	ProbBBbar

G4double	ProbCB

G4double	ProbCCbar

G4double	ProbEta_b

G4double	ProbEta_c

G4double	pspin_barion

G4double	pspin_meson

std::vector< G4double >	scalarMesonMix

G4double	SigmaQT

G4double	StrangeSuppress

G4int	StringLoopInterrupt

G4double	theMaxEnergy

G4double	theMinEnergy

G4HadFinalState	theParticleChange

std::vector< G4double >	vectorMesonMix

G4int	verboseLevel

Private Member Functions
virtual G4ParticleDefinition *	DiQuarkSplitup (G4ParticleDefinition decay, G4ParticleDefinition &created)

	G4QGSMFragmentation (const G4QGSMFragmentation &right)

virtual G4double	GetLightConeZ (G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)

virtual G4bool	IsItFragmentable (const G4FragmentingString *string)

G4bool	operator!= (const G4QGSMFragmentation &right) const

const G4QGSMFragmentation &	operator= (const G4QGSMFragmentation &right)

G4bool	operator== (const G4QGSMFragmentation &right) const

virtual void	Sample4Momentum (G4LorentzVector Mom, G4double Mass, G4LorentzVector AntiMom, G4double AntiMass, G4double InitialMass)

void	SetFFq2q ()

void	SetFFq2qq ()

void	SetFFqq2q ()

void	SetFFqq2qq ()

virtual G4LorentzVector *	SplitEandP (G4ParticleDefinition pHadron, G4FragmentingString string, G4FragmentingString *newString)

virtual G4bool	SplitLast (G4FragmentingString string, G4KineticTrackVector LeftVector, G4KineticTrackVector *RightVector)

virtual G4KineticTrack *	Splitup (G4FragmentingString string, G4FragmentingString &newString)

virtual G4bool	StopFragmenting (const G4FragmentingString *string)

Private Attributes
G4double	aJPs

G4double	aksi

G4double	ala

G4double	alaB

G4double	alaC

G4double	alft

G4double	an

G4double	aphi

G4double	arho

G4double	aUps

G4double	aXi

G4double	aXiB

G4double	aXiBB

G4double	aXiC

G4double	aXiCB

G4double	aXiCC

std::pair< G4double, G4double >	epCheckLevels

G4double	FFq2q [5][5][2]

G4double	FFq2qq [5][15][2]

G4double	FFqq2q [15][5][2]

G4double	FFqq2qq [15][5][2]

G4int	IndexDiQ [5][5]

G4double	recoilEnergyThreshold

G4HadronicInteractionRegistry *	registry

std::vector< const G4Material * >	theBlockedList

std::vector< const G4Element * >	theBlockedListElements

std::vector< std::pair< G4double, const G4Material * > >	theMaxEnergyList

std::vector< std::pair< G4double, const G4Element * > >	theMaxEnergyListElements

std::vector< std::pair< G4double, const G4Material * > >	theMinEnergyList

std::vector< std::pair< G4double, const G4Element * > >	theMinEnergyListElements

G4String	theModelName

Detailed Description

Definition at line 39 of file G4QGSMFragmentation.hh.

Member Typedef Documentation

◆ Pcreate

typedef G4ParticleDefinition *(G4HadronBuilder::* G4VLongitudinalStringDecay::Pcreate) (G4ParticleDefinition *, G4ParticleDefinition *)

protectedinherited

Definition at line 86 of file G4VLongitudinalStringDecay.hh.

◆ pDefPair

typedef std::pair<G4ParticleDefinition*, G4ParticleDefinition*> G4VLongitudinalStringDecay::pDefPair

protectedinherited

Definition at line 83 of file G4VLongitudinalStringDecay.hh.

Constructor & Destructor Documentation

◆ G4QGSMFragmentation() [1/2]

G4QGSMFragmentation::G4QGSMFragmentation ( )

Definition at line 49 of file G4QGSMFragmentation.cc.

{
    SigmaQT = 0.45 * GeV;  // Uzhi June 2020
 
    MassCut = 0.35*GeV; 
 
    SetStrangenessSuppression((1.0 - 0.12)/2.);  // Uzhi June 2020 0.16 -> 0.12
 
    // Check if charmed and bottom hadrons are enabled: if this is the case, then
    // set the non-zero probabilities for c-cbar and b-bbar creation from the vacuum,
    // else set them to 0.0. If these probabilities are/aren't zero then charmed or bottom
    // hadrons can't/can be created during the string fragmentation of ordinary
    // (i.e. not heavy) projectile hadron nuclear reactions.
    if ( G4HadronicParameters::Instance()->EnableBCParticles() ) {
      SetProbCCbar(0.005);   // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
      SetProbBBbar(5.0e-5);  // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
    } else {
      SetProbCCbar(0.0);
      SetProbBBbar(0.0);
    }
    
    SetDiquarkSuppression(0.195);     // Uzhi June 2020 0.32 -> 0.195
    SetDiquarkBreakProbability(0.0);  // Uzhi June 2020 0.7  -> 0.0
 
    SetMinMasses();
 
    arho = 0.5;    // alpha_rho0
    aphi = 0.0;    // alpha_fi
    aJPs =-2.2;    // alpha_J/Psi
    aUps =-8.0;    // alpha_Y      ??? O. Piskunova Yad. Phys. 56 (1993) 1094.
 
    aksi =-1.0; 
    alft = 0.5;    // 2 * alpha'_R *<Pt^2>
 
    an    = -0.5 ; 
    ala   = -0.75; // an - arho/2 + aphi/2 
    alaC  =  an - arho/2.0 + aJPs/2.0;  
    alaB  =  an - arho/2.0 + aUps/2.0;  
    aXi   =  0.0;  // ??
    aXiC  =  0.0;  // ??
    aXiB  =  0.0;  // ??
    aXiCC =  0.0;  // ??
    aXiCB =  0.0;  // ??
    aXiBB =  0.0;  // ??
 
    SetFFq2q();
    SetFFq2qq();
    SetFFqq2q();
    SetFFqq2qq();
                         // d  u   s   c   b
    G4int Index[5][5] = { { 0, 1,  2,  3,  4 },    // d
                          { 1, 5,  6,  7,  8 },    // u
                          { 2, 6,  9, 10, 11 },    // s
                          { 3, 7, 10, 12, 13 },    // c
                          { 4, 8, 11, 13, 14 } };  // b
    for (G4int i = 0; i < 5; i++ ) {
      for ( G4int j = 0; j < 5; j++ ) { 
        IndexDiQ[i][j] = Index[i][j];
      } 
    };
}

◆ ~G4QGSMFragmentation()

G4QGSMFragmentation::~G4QGSMFragmentation ( )

Definition at line 111 of file G4QGSMFragmentation.cc.

112{}

◆ G4QGSMFragmentation() [2/2]

G4QGSMFragmentation::G4QGSMFragmentation ( const G4QGSMFragmentation & right )

private

Member Function Documentation

◆ ActivateFor() [1/2]

void G4HadronicInteraction::ActivateFor ( const G4Element * anElement )

inlineinherited

Definition at line 128 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), anElement);
    SetMinEnergy(GetMinEnergy(), anElement);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ ActivateFor() [2/2]

void G4HadronicInteraction::ActivateFor ( const G4Material * aMaterial )

inlineinherited

Definition at line 120 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), aMaterial);
    SetMinEnergy(GetMinEnergy(), aMaterial);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ AddNewParticles()

void G4VLongitudinalStringDecay::AddNewParticles ( )

inherited

◆ ApplyYourself()

G4HadFinalState * G4VLongitudinalStringDecay::ApplyYourself	(	const G4HadProjectile &	,
		G4Nucleus &
	)

finalvirtualinherited

Reimplemented from G4HadronicInteraction.

Definition at line 131 of file G4VLongitudinalStringDecay.cc.

{
  return nullptr;
}

◆ Block()

void G4HadronicInteraction::Block ( )

inlineprotectedinherited

Definition at line 170 of file G4HadronicInteraction.hh.

170{ isBlocked = true; }

G4HadronicInteraction::isBlocked

G4bool isBlocked

Definition: G4HadronicInteraction.hh:188

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::ActivateFor(), G4HadronicInteraction::DeActivateFor(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ BuildPhysicsTable()

void G4HadronicInteraction::BuildPhysicsTable ( const G4ParticleDefinition & )

virtualinherited

Reimplemented in G4LENDorBERTModel, G4LENDCombinedModel, G4LENDGammaModel, G4LENDModel, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, G4ParticleHPThermalScattering, G4AblaInterface, and G4PreCompoundModel.

Definition at line 56 of file G4HadronicInteraction.cc.

57{}

◆ CalculateHadronTimePosition()

void G4VLongitudinalStringDecay::CalculateHadronTimePosition	(	G4double	theInitialStringMass,
		G4KineticTrackVector *	Hadrons
	)

protectedinherited

Definition at line 435 of file G4VLongitudinalStringDecay.cc.

{
   //   `yo-yo` formation time
   //   const G4double kappa = 1.0 * GeV/fermi/4.;      
   G4double kappa = GetStringTensionParameter();
   for (size_t c1 = 0; c1 < Hadrons->size(); c1++)
   {
      G4double SumPz = 0; 
      G4double SumE  = 0;
      for (size_t c2 = 0; c2 < c1; c2++)
      {
         SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
         SumE  += Hadrons->operator[](c2)->Get4Momentum().e();   
      } 
      G4double HadronE  = Hadrons->operator[](c1)->Get4Momentum().e();
      G4double HadronPz = Hadrons->operator[](c1)->Get4Momentum().pz();
      Hadrons->operator[](c1)->SetFormationTime(
        (theInitialStringMass - 2.*SumPz + HadronE - HadronPz ) / (2.*kappa) / c_light ); 
      G4ThreeVector aPosition( 0, 0,
        (theInitialStringMass - 2.*SumE  - HadronE + HadronPz) / (2.*kappa) );
      Hadrons->operator[](c1)->SetPosition(aPosition);
   }
}

References source.hepunit::c_light, and G4VLongitudinalStringDecay::GetStringTensionParameter().

Referenced by FragmentString().

◆ ConstructParticle()

void G4VLongitudinalStringDecay::ConstructParticle ( )

protectedinherited

◆ CopyExcited()

G4ExcitedString * G4VLongitudinalStringDecay::CopyExcited ( const G4ExcitedString & string )

protectedinherited

Definition at line 326 of file G4VLongitudinalStringDecay.cc.

{
    G4Parton *Left=new G4Parton(*in.GetLeftParton());
    G4Parton *Right=new G4Parton(*in.GetRightParton());
    return new G4ExcitedString(Left,Right,in.GetDirection());
}

References G4ExcitedString::GetDirection(), G4ExcitedString::GetLeftParton(), and G4ExcitedString::GetRightParton().

Referenced by FragmentString().

◆ CreateHadron()

G4ParticleDefinition * G4VLongitudinalStringDecay::CreateHadron	(	G4int	id1,
		G4int	id2,
		G4bool	theGivenSpin,
		G4int	theSpin
	)

protectedinherited

◆ CreatePartonPair()

G4VLongitudinalStringDecay::pDefPair G4VLongitudinalStringDecay::CreatePartonPair	(	G4int	NeedParticle,
		G4bool	AllowDiquarks = `true`
	)

protectedinherited

Definition at line 360 of file G4VLongitudinalStringDecay.cc.

{
    //  NeedParticle = +1 for Particle, -1 for Antiparticle
    if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
    {
      // Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
      #ifdef debug_VStringDecay
      G4cout<<"VlongSD Create a Diquark - AntiDiquark pair"<<G4endl;
      #endif
      G4int q1(0), q2(0), spin(0), PDGcode(0);
 
      q1  = SampleQuarkFlavor();
      q2  = SampleQuarkFlavor();
 
      spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
                                     //   convention: quark with higher PDG number is first
      PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
 
      return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
 
    } else {
      // Create a Quark - AntiQuark pair, first in pair  IsParticle
      #ifdef debug_VStringDecay
      G4cout<<"VlongSD Create a Quark - AntiQuark pair"<<G4endl; 
      #endif
      G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
      return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
    }
}

References G4VLongitudinalStringDecay::DiquarkSuppress, G4VLongitudinalStringDecay::FindParticle(), G4cout, G4endl, G4UniformRand, G4INCL::Math::max(), G4INCL::Math::min(), and G4VLongitudinalStringDecay::SampleQuarkFlavor().

Referenced by G4LundStringFragmentation::DiQuarkSplitup(), DiQuarkSplitup(), G4VLongitudinalStringDecay::QuarkSplitup(), and SplitLast().

◆ DeActivateFor() [1/2]

void G4HadronicInteraction::DeActivateFor ( const G4Element * anElement )

inherited

Definition at line 186 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedListElements.push_back(anElement);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedListElements.

◆ DeActivateFor() [2/2]

void G4HadronicInteraction::DeActivateFor ( const G4Material * aMaterial )

inherited

Definition at line 180 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedList.push_back(aMaterial);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedList.

Referenced by G4HadronHElasticPhysics::ConstructProcess().

◆ DiQuarkSplitup()

G4ParticleDefinition * G4QGSMFragmentation::DiQuarkSplitup	(	G4ParticleDefinition *	decay,
		G4ParticleDefinition *&	created
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 397 of file G4QGSMFragmentation.cc.

{
   //... can Diquark break or not?
   if (G4UniformRand() < DiquarkBreakProb )  //... Diquark break
   {
      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
 
      if (G4UniformRand() < 0.5)
      {
         G4int Swap = stableQuarkEncoding;
         stableQuarkEncoding = decayQuarkEncoding;
         decayQuarkEncoding = Swap;
      }
 
      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1;  // if we have a quark, we need antiquark
 
      G4double StrSup=GetStrangeSuppress();
      SetStrangenessSuppression((1.0 - 0.07)/2.);  // Prob qq->K qq' 0.07
      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
      SetStrangenessSuppression(StrSup);
 
      //... Build new Diquark
      G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
      G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
      G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
      G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
      G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
      
      created = FindParticle(NewDecayEncoding);
      G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
 
      DecayQuark = decay->GetPDGEncoding();  //Uzhi June 2020  decayQuarkEncoding;
      NewQuark   = NewDecayEncoding;         //Uzhi June 2020  QuarkPair.first->GetPDGEncoding();
 
      return had;
 
   } else {  //... Diquark does not break
 
      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1;  // if we have a diquark, we need quark)
      G4double StrSup=GetStrangeSuppress();  // for changing s-sbar production
      SetStrangenessSuppression((1.0 - 0.07)/2.);
      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
      SetStrangenessSuppression(StrSup);
 
      created = QuarkPair.second;
 
      DecayQuark = decay->GetPDGEncoding();
      NewQuark   = created->GetPDGEncoding();
 
      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
      return had;
   }
}

Referenced by Splitup().

◆ EraseNewParticles()

void G4VLongitudinalStringDecay::EraseNewParticles ( )

inherited

◆ FindParticle()

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int Encoding )

protectedinherited

Definition at line 280 of file G4VLongitudinalStringDecay.cc.

{
  /*
  G4cout<<Encoding<<" G4VLongitudinalStringDecay::FindParticle Check di-quarks *******************"<<G4endl;
  for (G4int i=4; i<6;i++){
    for (G4int j=1;j<6;j++){
      G4cout<<i<<" "<<j<<" ";
      G4int Code = 1000 * i + 100 * j +1;
      G4ParticleDefinition* ptr1 = G4ParticleTable::GetParticleTable()->FindParticle(Code);
      Code +=2;
      G4ParticleDefinition* ptr2 = G4ParticleTable::GetParticleTable()->FindParticle(Code);
      G4cout<<"Code "<<Code - 2<<" ptr "<<ptr1<<" :: Code "<<Code<<" ptr "<<ptr2<<G4endl;
    }
    G4cout<<G4endl;
  }
  */
 
  G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
 
  if (ptr == nullptr)
  {
     for (size_t i=0; i < NewParticles.size(); i++)
     {
       if ( Encoding == NewParticles[i]->GetPDGEncoding() ) { ptr = NewParticles[i]; return ptr;}
     }
  }
 
  return ptr;    
}

References G4ParticleTable::FindParticle(), G4ParticleTable::GetParticleTable(), and G4VLongitudinalStringDecay::NewParticles.

Referenced by G4VLongitudinalStringDecay::CreatePartonPair(), G4LundStringFragmentation::Diquark_AntiDiquark_belowThreshold_lastSplitting(), G4LundStringFragmentation::DiQuarkSplitup(), DiQuarkSplitup(), G4VLongitudinalStringDecay::PossibleHadronMass(), G4VLongitudinalStringDecay::SetMinMasses(), and SplitLast().

◆ FragmentString()

G4KineticTrackVector * G4QGSMFragmentation::FragmentString ( const G4ExcitedString & theString )

virtual

Implements G4VLongitudinalStringDecay.

Definition at line 116 of file G4QGSMFragmentation.cc.

{
 
  G4FragmentingString  aString(theString);
  SetMinimalStringMass(&aString);
 
  #ifdef debug_QGSMfragmentation
  G4cout<<G4endl<<"QGSM StringFragm: String Mass "
                             <<theString.Get4Momentum().mag()<<" Pz "
                             <<theString.Get4Momentum().pz()
                             <<"------------------------------------"<<G4endl;
  G4cout<<"String ends Direct "<<theString.GetLeftParton()->GetPDGcode()<<" "
                               <<theString.GetRightParton()->GetPDGcode()<<" "
                               <<theString.GetDirection()<< G4endl;
  G4cout<<"Left  mom "<<theString.GetLeftParton()->Get4Momentum()<<G4endl;
  G4cout<<"Right mom "<<theString.GetRightParton()->Get4Momentum()<<G4endl;
  G4cout<<"Check for Fragmentation "<<G4endl;
  #endif
 
  // Can no longer modify Parameters for Fragmentation.
  PastInitPhase=true;
    
  // Check if string has enough mass to fragment...
  G4KineticTrackVector * LeftVector=NULL;
 
  if ( !IsItFragmentable(&aString) ) {
     LeftVector=ProduceOneHadron(&theString);
 
     #ifdef debug_QGSMfragmentation
     if ( LeftVector != 0 ) G4cout<<"Non fragmentable - the string is converted to one hadron "<<G4endl;
     #endif
 
     if ( LeftVector == nullptr ) LeftVector = new G4KineticTrackVector;
     return LeftVector;
  }
 
  #ifdef debug_QGSMfragmentation
  G4cout<<"The string will be fragmented. "<<G4endl;
  #endif
    
  LeftVector = new G4KineticTrackVector;
  G4KineticTrackVector * RightVector=new G4KineticTrackVector;
 
  G4ExcitedString *theStringInCMS=CopyExcited(theString);
  G4LorentzRotation toCms=theStringInCMS->TransformToAlignedCms();
 
  G4bool success=false, inner_sucess=true;
  G4int attempt=0;
  while ( !success && attempt++ < StringLoopInterrupt )  /* Loop checking, 07.08.2015, A.Ribon */
  {
                #ifdef debug_QGSMfragmentation
                G4cout<<"Loop_toFrag "<<theStringInCMS->GetLeftParton()->GetPDGcode()<<" "
                                      <<theStringInCMS->GetRightParton()->GetPDGcode()<<" "
                                      <<theStringInCMS->GetDirection()<< G4endl;
                #endif
 
        G4FragmentingString *currentString=new G4FragmentingString(*theStringInCMS);
 
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        RightVector->clear();
        
        inner_sucess=true;  // set false on failure..
                const G4int maxNumberOfLoops = 1000;
                G4int loopCounter = -1;
        while (! StopFragmenting(currentString) && ++loopCounter < maxNumberOfLoops )   /* Loop checking, 07.08.2015, A.Ribon */
        {  // Split current string into hadron + new string
 
                        #ifdef debug_QGSMfragmentation
                        G4cout<<"The string can fragment. "<<G4endl;;
                        #endif
            G4FragmentingString *newString=0;  // used as output from SplitUp...
            G4KineticTrack * Hadron=Splitup(currentString,newString);
 
            if ( Hadron != 0 ) 
            {
                           #ifdef debug_QGSMfragmentation
                           G4cout<<"Hadron prod at fragm. "<<Hadron->GetDefinition()->GetParticleName()<<G4endl;
                           #endif
                           // To close the production of hadrons at fragmentation stage
               if ( currentString->GetDecayDirection() > 0 )
                   LeftVector->push_back(Hadron);
                   else
                   RightVector->push_back(Hadron);
 
               delete currentString;
               currentString=newString;
 
            } else {
 
                           #ifdef debug_QGSMfragmentation
                           G4cout<<"abandon ... start from the beginning ---------------"<<G4endl;
                           #endif
 
               // Abandon ... start from the beginning
               if (newString) delete newString;
               inner_sucess=false;
               break;
            }
        }
                if ( loopCounter >= maxNumberOfLoops ) {
                  inner_sucess=false;
                }
 
        // Split current string into 2 final Hadrons
                #ifdef debug_QGSMfragmentation
                if( inner_sucess ) {  // Uzhi June 2020
                  G4cout<<"Split remaining string into 2 final hadrons."<<G4endl;
                } else {
          G4cout<<" New attempt to fragment string"<<G4endl;
        }  // Uzhi June 2020
                #endif
                // To the close production of hadrons at last string decay
        if ( inner_sucess && 
             SplitLast(currentString,LeftVector, RightVector) ) 
        {
            success=true;
        }
        delete currentString;
    }
    
    delete theStringInCMS;
    
    if ( ! success )
    {
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        delete RightVector;
        return LeftVector;
    }
        
    // Join Left- and RightVector into LeftVector in correct order.
    while(!RightVector->empty())  /* Loop checking, 07.08.2015, A.Ribon */
    {
        LeftVector->push_back(RightVector->back());
        RightVector->erase(RightVector->end()-1);
    }
    delete RightVector;
 
    CalculateHadronTimePosition(theString.Get4Momentum().mag(), LeftVector);
 
    G4LorentzRotation toObserverFrame(toCms.inverse());
 
    for (size_t C1 = 0; C1 < LeftVector->size(); C1++)
    {
       G4KineticTrack* Hadron = LeftVector->operator[](C1);
       G4LorentzVector Momentum = Hadron->Get4Momentum();
       Momentum = toObserverFrame*Momentum;
       Hadron->Set4Momentum(Momentum);
       G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
       Momentum = toObserverFrame*Coordinate;
       Hadron->SetFormationTime(Momentum.e());
       G4ThreeVector aPosition(Momentum.vect());
       Hadron->SetPosition(theString.GetPosition()+aPosition);
    }
    return LeftVector;
}

References C1, G4VLongitudinalStringDecay::CalculateHadronTimePosition(), G4VLongitudinalStringDecay::CopyExcited(), G4cout, G4endl, G4ExcitedString::Get4Momentum(), G4KineticTrack::Get4Momentum(), G4Parton::Get4Momentum(), G4FragmentingString::GetDecayDirection(), G4KineticTrack::GetDefinition(), G4ExcitedString::GetDirection(), G4KineticTrack::GetFormationTime(), G4ExcitedString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4Parton::GetPDGcode(), G4ExcitedString::GetPosition(), G4KineticTrack::GetPosition(), G4ExcitedString::GetRightParton(), CLHEP::HepLorentzRotation::inverse(), IsItFragmentable(), CLHEP::HepLorentzVector::mag(), G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProduceOneHadron(), CLHEP::HepLorentzVector::pz(), G4KineticTrack::Set4Momentum(), G4KineticTrack::SetFormationTime(), G4VLongitudinalStringDecay::SetMinimalStringMass(), G4KineticTrack::SetPosition(), SplitLast(), Splitup(), StopFragmenting(), G4VLongitudinalStringDecay::StringLoopInterrupt, and G4ExcitedString::TransformToAlignedCms().

◆ GetClusterLoopInterrupt()

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt ( )

inlineprotectedinherited

Definition at line 176 of file G4VLongitudinalStringDecay.hh.

176{return ClusterLoopInterrupt;};

G4VLongitudinalStringDecay::ClusterLoopInterrupt

G4int ClusterLoopInterrupt

Definition: G4VLongitudinalStringDecay.hh:192

References G4VLongitudinalStringDecay::ClusterLoopInterrupt.

◆ GetDiquarkBreakProb()

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb ( )

inlineprotectedinherited

Definition at line 174 of file G4VLongitudinalStringDecay.hh.

174{return DiquarkBreakProb;};

References G4VLongitudinalStringDecay::DiquarkBreakProb.

◆ GetDiquarkSuppress()

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress ( )

inlineprotectedinherited

Definition at line 173 of file G4VLongitudinalStringDecay.hh.

173{return DiquarkSuppress;};

References G4VLongitudinalStringDecay::DiquarkSuppress.

Referenced by G4LundStringFragmentation::Splitup(), and Splitup().

◆ GetEnergyMomentumCheckLevels()

std::pair< G4double, G4double > G4HadronicInteraction::GetEnergyMomentumCheckLevels ( ) const

virtualinherited

Reimplemented in G4TheoFSGenerator.

Definition at line 217 of file G4HadronicInteraction.cc.

{
  return epCheckLevels;
}

References G4HadronicInteraction::epCheckLevels.

Referenced by G4HadronicProcess::CheckEnergyMomentumConservation(), and G4TheoFSGenerator::GetEnergyMomentumCheckLevels().

◆ GetFatalEnergyCheckLevels()

const std::pair< G4double, G4double > G4HadronicInteraction::GetFatalEnergyCheckLevels ( ) const

virtualinherited

Reimplemented in G4FissLib, G4LFission, G4LENDFission, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, and G4ParticleHPThermalScattering.

Definition at line 210 of file G4HadronicInteraction.cc.

{
  // default level of Check
  return std::pair<G4double, G4double>(2.*perCent, 1. * GeV);
}

References GeV, and perCent.

Referenced by G4HadronicProcess::CheckResult().

◆ GetLightConeZ()

G4double G4QGSMFragmentation::GetLightConeZ	(	G4double	zmin,
		G4double	zmax,
		G4int	PartonEncoding,
		G4ParticleDefinition *	pHadron,
		G4double	Px,
		G4double	Py
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 558 of file G4QGSMFragmentation.cc.

{    
  G4double lambda = 2.0*(sqr(ptx)+sqr(pty))/sqr(GeV);  // Uzhi June 2020
 
  #ifdef debug_QGSMfragmentation
  G4cout<<"GetLightConeZ zmin zmax Parton pHadron "<<zmin<<" "<<zmax<<" "/*<< PartonEncoding */
        <<" "/*<< pHadron->GetParticleName() */ <<G4endl;
  #endif
 
  G4double z(0.);    
  G4int DiQold(0), DiQnew(0);
  G4double d1(-1.0), d2(0.);
  G4double invD1(0.),invD2(0.), r1(0.),r2(0.),r12(0.);
 
  G4int absDecayQuarkCode = std::abs( DecayQuark );
  G4int absNewQuarkCode   = std::abs( NewQuark   );
 
  G4int q1(0), q2(0);
  //  q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100;
 
  G4int qA(0), qB(0);
  //  qA = absNewQuarkCode/1000;   qB = (absNewQuarkCode % 1000)/100;
 
  if ( (absDecayQuarkCode < 6) && (absNewQuarkCode < 6) ) {
    d1 = FFq2q[absDecayQuarkCode-1][absNewQuarkCode-1][0]; d2 = FFq2q[absDecayQuarkCode-1][absNewQuarkCode-1][1];
  }
 
  if ( (absDecayQuarkCode < 6) && (absNewQuarkCode > 6) ) {
   qA = absNewQuarkCode/1000;   qB = (absNewQuarkCode % 1000)/100;   DiQnew = IndexDiQ[qA-1][qB-1];
   d1 = FFq2qq[absDecayQuarkCode-1][DiQnew][0]; d2 = FFq2q[absDecayQuarkCode-1][DiQnew][1];
  }
 
  if ( (absDecayQuarkCode > 6) && (absNewQuarkCode < 6) ) {
    q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100; DiQold = IndexDiQ[q1-1][q2-1];
    d1 = FFqq2q[DiQold][absNewQuarkCode-1][0]; d2 = FFqq2q[DiQold][absNewQuarkCode-1][1];
  }
 
  if ( d1 < 0. ) {
    q1 = absDecayQuarkCode/1000; q2 = (absDecayQuarkCode % 1000)/100; DiQold = IndexDiQ[q1-1][q2-1];
    d1 = FFqq2qq[DiQold][absNewQuarkCode-1][0]; d2 = FFqq2qq[DiQold][absNewQuarkCode-1][1];
  }
 
  d2 +=lambda;  // Uzhi June 2020
  d1+=1.0; d2+=1.0;
 
  invD1=1./d1; invD2=1./d2;
 
  const G4int maxNumberOfLoops = 10000;
  G4int loopCounter = 0;
  do  // Jong's algorithm
  {
    r1=G4Pow::GetInstance()->powA(G4UniformRand(),invD1);
    r2=G4Pow::GetInstance()->powA(G4UniformRand(),invD2);
    r12=r1+r2;
    z=r1/r12;
  } while ( ( (r12 > 1.0) || !((zmin <= z)&&(z <= zmax))) && 
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
 
  if ( loopCounter >= maxNumberOfLoops ) {
    z = 0.5*(zmin + zmax);  // Just a value between zmin and zmax, no physics considerations at all! 
  }
 
  return z;
}

References d1, d2, G4VLongitudinalStringDecay::DecayQuark, FFq2q, FFq2qq, FFqq2q, FFqq2qq, G4cout, G4endl, G4UniformRand, G4Pow::GetInstance(), GeV, IndexDiQ, G4InuclParticleNames::lambda, G4VLongitudinalStringDecay::NewQuark, G4Pow::powA(), and sqr().

Referenced by SplitEandP().

◆ GetMassCut()

G4double G4VLongitudinalStringDecay::GetMassCut ( )

protectedinherited

Definition at line 140 of file G4VLongitudinalStringDecay.cc.

140{ return MassCut; }

References G4VLongitudinalStringDecay::MassCut.

Referenced by G4LundStringFragmentation::FragmentString().

◆ GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const

inlineinherited

Definition at line 96 of file G4HadronicInteraction.hh.

97 { return theMaxEnergy; }

G4HadronicInteraction::theMaxEnergy

G4double theMaxEnergy

Definition: G4HadronicInteraction.hh:186

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4IonPhysics::ConstructProcess(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronElastic::G4HadronElastic(), G4hhElastic::G4hhElastic(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

◆ GetMaxEnergy() [2/2]

G4double G4HadronicInteraction::GetMaxEnergy	(	const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

inherited

Definition at line 131 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMaxEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return 0.0; }
  if(!theMaxEnergyListElements.empty()) {
    for(auto const& elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second )
    { return elmlist.first; }
    }
  }
  if(!theMaxEnergyList.empty()) {
    for(auto const& matlist : theMaxEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMaxEnergy;
}

References G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMaxEnergy, G4HadronicInteraction::theMaxEnergyList, and G4HadronicInteraction::theMaxEnergyListElements.

◆ GetMinEnergy() [1/2]

G4double G4HadronicInteraction::GetMinEnergy ( ) const

inlineinherited

Definition at line 83 of file G4HadronicInteraction.hh.

84 { return theMinEnergy; }

G4HadronicInteraction::theMinEnergy

G4double theMinEnergy

Definition: G4HadronicInteraction.hh:185

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

◆ GetMinEnergy() [2/2]

G4double G4HadronicInteraction::GetMinEnergy	(	const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

inherited

Definition at line 81 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMinEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return DBL_MAX; }
  if(!theMinEnergyListElements.empty()) {
    for(auto const& elmlist : theMinEnergyListElements) {
    if( anElement == elmlist.second )
      { return elmlist.first; }
    }
  }
  if(!theMinEnergyList.empty()) {
    for(auto const & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMinEnergy;
}

References DBL_MAX, G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMinEnergy, G4HadronicInteraction::theMinEnergyList, and G4HadronicInteraction::theMinEnergyListElements.

◆ GetModelName()

const G4String & G4HadronicInteraction::GetModelName ( ) const

inlineinherited

Definition at line 115 of file G4HadronicInteraction.hh.

116 { return theModelName; }

G4HadronicInteraction::theModelName

G4String theModelName

Definition: G4HadronicInteraction.hh:196

References G4HadronicInteraction::theModelName.

Referenced by G4MuMinusCapturePrecompound::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4VHadronPhysics::BuildModel(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4ChargeExchangePhysics::ConstructProcess(), G4MuonicAtomDecay::DecayIt(), G4LENDModel::DumpLENDTargetInfo(), G4AblaInterface::G4AblaInterface(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4ExcitedStringDecay::G4ExcitedStringDecay(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LENDorBERTModel::G4LENDorBERTModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4LowEIonFragmentation::G4LowEIonFragmentation(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4INCLXXInterface::GetDeExcitationModelName(), G4EnergyRangeManager::GetHadronicInteraction(), G4VHighEnergyGenerator::GetProjectileNucleus(), G4NeutronRadCapture::InitialiseModel(), G4BinaryCascade::ModelDescription(), G4LMsdGenerator::ModelDescription(), G4VPartonStringModel::ModelDescription(), G4TheoFSGenerator::ModelDescription(), G4VHadronPhysics::NewModel(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4HadronicProcessStore::PrintModelHtml(), G4BinaryCascade::PropagateModelDescription(), G4HadronicProcessStore::RegisterInteraction(), and G4LENDModel::returnUnchanged().

◆ GetProbBBbar()

G4double G4VLongitudinalStringDecay::GetProbBBbar ( )

inlineprotectedinherited

Definition at line 180 of file G4VLongitudinalStringDecay.hh.

180{return ProbBBbar;};

G4VLongitudinalStringDecay::ProbBBbar

G4double ProbBBbar

Definition: G4VLongitudinalStringDecay.hh:204

References G4VLongitudinalStringDecay::ProbBBbar.

◆ GetProbCCbar()

G4double G4VLongitudinalStringDecay::GetProbCCbar ( )

inlineprotectedinherited

Definition at line 178 of file G4VLongitudinalStringDecay.hh.

178{return ProbCCbar;};

G4VLongitudinalStringDecay::ProbCCbar

G4double ProbCCbar

Definition: G4VLongitudinalStringDecay.hh:201

References G4VLongitudinalStringDecay::ProbCCbar.

◆ GetProbEta_b()

G4double G4VLongitudinalStringDecay::GetProbEta_b ( )

inlineprotectedinherited

Definition at line 181 of file G4VLongitudinalStringDecay.hh.

181{return ProbEta_b;};

G4VLongitudinalStringDecay::ProbEta_b

G4double ProbEta_b

Definition: G4VLongitudinalStringDecay.hh:205

References G4VLongitudinalStringDecay::ProbEta_b.

◆ GetProbEta_c()

G4double G4VLongitudinalStringDecay::GetProbEta_c ( )

inlineprotectedinherited

Definition at line 179 of file G4VLongitudinalStringDecay.hh.

179{return ProbEta_c;};

G4VLongitudinalStringDecay::ProbEta_c

G4double ProbEta_c

Definition: G4VLongitudinalStringDecay.hh:202

References G4VLongitudinalStringDecay::ProbEta_c.

◆ GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const

inlineinherited

Definition at line 141 of file G4HadronicInteraction.hh.

142 { return recoilEnergyThreshold;}

G4HadronicInteraction::recoilEnergyThreshold

G4double recoilEnergyThreshold

Definition: G4HadronicInteraction.hh:194

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4ChargeExchange::ApplyYourself(), and G4HadronElastic::ApplyYourself().

◆ GetStrangeSuppress()

G4double G4VLongitudinalStringDecay::GetStrangeSuppress ( )

inlineprotectedinherited

Definition at line 175 of file G4VLongitudinalStringDecay.hh.

175{return StrangeSuppress;};

G4VLongitudinalStringDecay::StrangeSuppress

G4double StrangeSuppress

Definition: G4VLongitudinalStringDecay.hh:190

References G4VLongitudinalStringDecay::StrangeSuppress.

Referenced by G4LundStringFragmentation::DiQuarkSplitup(), DiQuarkSplitup(), and G4LundStringFragmentation::Splitup().

◆ GetStringTensionParameter()

G4double G4VLongitudinalStringDecay::GetStringTensionParameter ( )

inlineprotectedinherited

Definition at line 183 of file G4VLongitudinalStringDecay.hh.

183{return Kappa;};

G4VLongitudinalStringDecay::Kappa

G4double Kappa

Definition: G4VLongitudinalStringDecay.hh:213

References G4VLongitudinalStringDecay::Kappa.

Referenced by G4VLongitudinalStringDecay::CalculateHadronTimePosition().

◆ GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const

inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

110 { return verboseLevel; }

G4HadronicInteraction::verboseLevel

G4int verboseLevel

Definition: G4HadronicInteraction.hh:177

References G4HadronicInteraction::verboseLevel.

◆ InitialiseModel()

void G4HadronicInteraction::InitialiseModel ( )

virtualinherited

Reimplemented in G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4AblaInterface, G4NeutronRadCapture, G4LowEGammaNuclearModel, G4PreCompoundModel, and G4ElasticHadrNucleusHE.

Definition at line 59 of file G4HadronicInteraction.cc.

60{}

◆ IsApplicable()

G4bool G4HadronicInteraction::IsApplicable	(	const G4HadProjectile &	aTrack,
		G4Nucleus &	targetNucleus
	)

virtualinherited

Reimplemented in G4DiffuseElastic, G4DiffuseElasticV2, G4hhElastic, G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NeutrinoElectronCcModel, G4NeutrinoNucleusModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4CascadeInterface, and G4LMsdGenerator.

Definition at line 75 of file G4HadronicInteraction.cc.

{ 
  return true;
}

◆ IsBlocked() [1/3]

G4bool G4HadronicInteraction::IsBlocked ( ) const

inlineprotectedinherited

Definition at line 169 of file G4HadronicInteraction.hh.

169{ return isBlocked;}

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::GetMinEnergy().

◆ IsBlocked() [2/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Element * anElement ) const

inherited

Definition at line 202 of file G4HadronicInteraction.cc.

{
  for (auto const& elm : theBlockedListElements) {
    if (anElement == elm) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedListElements.

◆ IsBlocked() [3/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Material * aMaterial ) const

inherited

Definition at line 193 of file G4HadronicInteraction.cc.

{
  for (auto const& mat : theBlockedList) {
    if (aMaterial == mat) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedList.

◆ IsItFragmentable()

G4bool G4QGSMFragmentation::IsItFragmentable ( const G4FragmentingString * string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 278 of file G4QGSMFragmentation.cc.

{
        //Uzhi June 2020  return sqr( PossibleHadronMass(string) + MassCut ) < string->Mass2();
    return sqr( MinimalStringMass + MassCut ) < string->Mass2();  // Uzhi June 2020
}

References G4VLongitudinalStringDecay::MassCut, G4VLongitudinalStringDecay::MinimalStringMass, and sqr().

Referenced by FragmentString().

◆ ModelDescription()

void G4HadronicInteraction::ModelDescription ( std::ostream & outFile ) const

virtualinherited

Reimplemented in G4WilsonAbrasionModel, G4BinaryCascade, G4BinaryLightIonReaction, G4ChipsElasticModel, G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NeutrinoElectronCcModel, G4NeutrinoNucleusModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4VHighEnergyGenerator, G4ElasticHadrNucleusHE, G4HadronElastic, G4FTFModel, G4VIntraNuclearTransportModel, G4AblaInterface, G4CascadeInterface, G4LMsdGenerator, G4LFission, G4INCLXXInterface, G4ElectroVDNuclearModel, G4MuonVDNuclearModel, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, G4ParticleHPThermalScattering, G4QMDReaction, G4EmCaptureCascade, G4MuMinusCapturePrecompound, G4MuonMinusBoundDecay, G4PreCompoundModel, G4VPartonStringModel, G4QGSModel< ParticipantType >, G4QGSModel< G4GammaParticipants >, and G4TheoFSGenerator.

Definition at line 222 of file G4HadronicInteraction.cc.

{
  outFile << "The description for this model has not been written yet.\n";
}

Referenced by G4HadronicProcessStore::PrintModelHtml().

◆ operator!=() [1/2]

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

deleteinherited

◆ operator!=() [2/2]

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

private

◆ operator=()

const G4QGSMFragmentation & G4QGSMFragmentation::operator= ( const G4QGSMFragmentation & right )

private

◆ operator==() [1/2]

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

deleteinherited

◆ operator==() [2/2]

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

private

◆ PossibleHadronMass()

G4double G4VLongitudinalStringDecay::PossibleHadronMass	(	const G4FragmentingString *const	string,
		Pcreate	build = `0`,
		pDefPair *	pdefs = `0`
	)

protectedinherited

Definition at line 202 of file G4VLongitudinalStringDecay.cc.

{
        G4double mass = 0.0;
 
    if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
 
        G4ParticleDefinition* Hadron1 = nullptr;
    G4ParticleDefinition* Hadron2 = nullptr;
 
        if (!string->IsAFourQuarkString() )
        {
           // spin 0 meson or spin 1/2 barion will be built
 
           Hadron1 = (hadronizer->*build)(string->GetLeftParton(), string->GetRightParton());
           #ifdef debug_VStringDecay
       G4cout<<"VlongSD PossibleHadronMass"<<G4endl;
           G4cout<<"VlongSD Quarks at the string ends "<<string->GetLeftParton()->GetParticleName()
                 <<" "<<string->GetRightParton()->GetParticleName()<<G4endl;
           if ( Hadron1 != nullptr) {
             G4cout<<"(G4VLongitudinalStringDecay) Hadron "<<Hadron1->GetParticleName()
                   <<" "<<Hadron1->GetPDGMass()<<G4endl;
           }
           #endif
           if ( Hadron1 != nullptr) { mass = (Hadron1)->GetPDGMass();}
           else                  { mass = MaxMass;}
        } else
        {
           //... string is qq--qqbar: Build two stable hadrons,
 
           #ifdef debug_VStringDecay
           G4cout<<"VlongSD PossibleHadronMass"<<G4endl;
           G4cout<<"VlongSD string is qq--qqbar: Build two stable hadrons"<<G4endl; 
           #endif
 
           G4double StringMass   = string->Mass();
           G4int cClusterInterrupt = 0;
           do
           {
             if (cClusterInterrupt++ >= ClusterLoopInterrupt) return false;
 
             G4int LeftQuark1= string->GetLeftParton()->GetPDGEncoding()/1000;
             G4int LeftQuark2=(string->GetLeftParton()->GetPDGEncoding()/100)%10;
 
             G4int RightQuark1= string->GetRightParton()->GetPDGEncoding()/1000;
             G4int RightQuark2=(string->GetRightParton()->GetPDGEncoding()/100)%10;
 
             if (G4UniformRand()<0.5) {
               Hadron1 =hadronizer->Build(FindParticle(LeftQuark1), FindParticle(RightQuark1));
               Hadron2 =hadronizer->Build(FindParticle(LeftQuark2), FindParticle(RightQuark2));
             } else {
               Hadron1 =hadronizer->Build(FindParticle(LeftQuark1), FindParticle(RightQuark2));
               Hadron2 =hadronizer->Build(FindParticle(LeftQuark2), FindParticle(RightQuark1));
             }
             //... repeat procedure, if mass of cluster is too low to produce hadrons
             //... ClusterMassCut = 0.15*GeV model parameter
           }
           while ( Hadron1 == nullptr || Hadron2 == nullptr ||
                   ( StringMass <= Hadron1->GetPDGMass() + Hadron2->GetPDGMass() ) );
 
       mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
        }
 
        #ifdef debug_VStringDecay
        G4cout<<"VlongSD *Hadrons 1 and 2, proposed mass "<<Hadron1<<" "<<Hadron2<<" "<<mass<<G4endl; 
        #endif
    
    if ( pdefs != 0 ) 
    { // need to return hadrons as well....
       pdefs->first  = Hadron1;
       pdefs->second = Hadron2;
    }
       
        return mass;
}

References G4HadronBuilder::Build(), G4HadronBuilder::BuildLowSpin(), G4VLongitudinalStringDecay::ClusterLoopInterrupt, G4VLongitudinalStringDecay::FindParticle(), G4cout, G4endl, G4UniformRand, G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4VLongitudinalStringDecay::hadronizer, G4FragmentingString::IsAFourQuarkString(), and G4VLongitudinalStringDecay::MaxMass.

Referenced by G4VLongitudinalStringDecay::ProduceOneHadron().

◆ ProduceOneHadron()

G4KineticTrackVector * G4VLongitudinalStringDecay::ProduceOneHadron ( const G4ExcitedString *const theString )

protectedinherited

Definition at line 146 of file G4VLongitudinalStringDecay.cc.

{
        G4KineticTrackVector* result = nullptr; 
        pDefPair hadrons( nullptr, nullptr );
        G4FragmentingString aString( *string );
 
        #ifdef debug_VStringDecay
        G4cout<<"G4VLongitudinalStringDecay::ProduceOneHadron: PossibleHmass StrMass "
              <<aString.Mass()<<" MassCut "<<MassCut<<G4endl;
        #endif
        
        SetMinimalStringMass( &aString );
        PossibleHadronMass( &aString, 0, &hadrons );
        result = new G4KineticTrackVector;
        if ( hadrons.first != nullptr ) {       
           if ( hadrons.second == nullptr ) {
               // Substitute string by light hadron, Note that Energy is not conserved here!
 
               #ifdef debug_VStringDecay
               G4cout << "VlongSD Warning replacing string by single hadron (G4VLongitudinalStringDecay)" <<G4endl;
               G4cout << hadrons.first->GetParticleName()<<G4endl
                      << "string .. " << string->Get4Momentum() << " " 
                      << string->Get4Momentum().m() << G4endl;
               #endif           
 
               G4ThreeVector   Mom3 = string->Get4Momentum().vect();
               G4LorentzVector Mom( Mom3, std::sqrt( Mom3.mag2() + sqr( hadrons.first->GetPDGMass() ) ) );
               result->push_back( new G4KineticTrack( hadrons.first, 0, string->GetPosition(), Mom ) );
           } else {
               //... string was qq--qqbar type: Build two stable hadrons,
 
               #ifdef debug_VStringDecay
               G4cout << "VlongSD Warning replacing qq-qqbar string by TWO hadrons (G4VLongitudinalStringDecay)" 
                      << hadrons.first->GetParticleName() << " / " 
                      << hadrons.second->GetParticleName()
                      << "string .. " << string->Get4Momentum() << " " 
                      << string->Get4Momentum().m() << G4endl;
               #endif
 
               G4LorentzVector  Mom1, Mom2;
               Sample4Momentum( &Mom1, hadrons.first->GetPDGMass(), 
                                &Mom2, hadrons.second->GetPDGMass(),
                                string->Get4Momentum().mag() );
 
               result->push_back( new G4KineticTrack( hadrons.first,  0, string->GetPosition(), Mom1 ) );
               result->push_back( new G4KineticTrack( hadrons.second, 0, string->GetPosition(), Mom2 ) );
 
               G4ThreeVector Velocity = string->Get4Momentum().boostVector();
               result->Boost(Velocity);          
           }
        }
        return result;
}

References G4KineticTrackVector::Boost(), G4cout, G4endl, G4ExcitedString::Get4Momentum(), G4ExcitedString::GetPosition(), CLHEP::HepLorentzVector::mag(), CLHEP::Hep3Vector::mag2(), G4FragmentingString::Mass(), G4VLongitudinalStringDecay::MassCut, G4VLongitudinalStringDecay::PossibleHadronMass(), G4VLongitudinalStringDecay::Sample4Momentum(), G4VLongitudinalStringDecay::SetMinimalStringMass(), and sqr().

Referenced by G4LundStringFragmentation::FragmentString(), and FragmentString().

◆ QuarkSplitup()

G4ParticleDefinition * G4VLongitudinalStringDecay::QuarkSplitup	(	G4ParticleDefinition *	decay,
		G4ParticleDefinition *&	created
	)

protectedvirtualinherited

Definition at line 335 of file G4VLongitudinalStringDecay.cc.

{
   #ifdef debug_VStringDecay
   G4cout<<"VlongSD QuarkSplitup: quark ID "<<decay->GetPDGEncoding()<<G4endl; 
   #endif
   
   G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1;  // if we have a quark, we need antiquark (or diquark)
 
   pDefPair QuarkPair = CreatePartonPair(IsParticle);
   created = QuarkPair.second;
 
   DecayQuark = decay->GetPDGEncoding();
   NewQuark   = created->GetPDGEncoding();
 
   #ifdef debug_VStringDecay
   G4cout<<"VlongSD QuarkSplitup: "<<decay->GetPDGEncoding()<<" -> "<<QuarkPair.second->GetPDGEncoding()<<G4endl;
   G4cout<<"hadronizer->Build(QuarkPair.first, decay)"<<G4endl;
   #endif
   
   return hadronizer->Build(QuarkPair.first, decay);
}

References G4HadronBuilder::Build(), G4VLongitudinalStringDecay::CreatePartonPair(), G4INCL::ClusterDecay::decay(), G4VLongitudinalStringDecay::DecayQuark, G4cout, G4endl, G4ParticleDefinition::GetPDGEncoding(), G4VLongitudinalStringDecay::hadronizer, and G4VLongitudinalStringDecay::NewQuark.

Referenced by G4LundStringFragmentation::Splitup(), and Splitup().

◆ Sample4Momentum()

void G4QGSMFragmentation::Sample4Momentum	(	G4LorentzVector *	Mom,
		G4double	Mass,
		G4LorentzVector *	AntiMom,
		G4double	AntiMass,
		G4double	InitialMass
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 742 of file G4QGSMFragmentation.cc.

{
    #ifdef debug_QGSMfragmentation  // Uzhi June 2020
    G4cout<<"Sample4Momentum Last-----------------------------------------"<<G4endl;
    G4cout<<"  StrMass "<<InitialMass<<" Mass1 "<<Mass<<" Mass2 "<<AntiMass<<G4endl;
    G4cout<<"  SumMass "<<Mass+AntiMass<<G4endl;
    #endif
 
    G4double r_val = sqr(InitialMass*InitialMass - Mass*Mass - AntiMass*AntiMass) - sqr(2.*Mass*AntiMass);
    G4double Pabs = (r_val > 0.)? std::sqrt(r_val)/(2.*InitialMass) : 0;
 
    //... sample unit vector       
    G4double pz = 1. - 2.*G4UniformRand();  
    G4double st     = std::sqrt(1. - pz * pz)*Pabs;
    G4double phi    = 2.*pi*G4UniformRand();
    G4double px = st*std::cos(phi);
    G4double py = st*std::sin(phi);
    pz *= Pabs;
    
    Mom->setPx(px); Mom->setPy(py); Mom->setPz(pz);
    Mom->setE(std::sqrt(Pabs*Pabs + Mass*Mass));
 
    AntiMom->setPx(-px); AntiMom->setPy(-py); AntiMom->setPz(-pz);
    AntiMom->setE (std::sqrt(Pabs*Pabs + AntiMass*AntiMass));
}

References G4cout, G4endl, G4UniformRand, pi, CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPx(), CLHEP::HepLorentzVector::setPy(), CLHEP::HepLorentzVector::setPz(), and sqr().

Referenced by SplitLast().

◆ SampleInvariantT()

G4double G4HadronicInteraction::SampleInvariantT	(	const G4ParticleDefinition *	p,
		G4double	plab,
		G4int	Z,
		G4int	A
	)

virtualinherited

Reimplemented in G4ChipsElasticModel, G4DiffuseElastic, G4DiffuseElasticV2, G4NuclNuclDiffuseElastic, G4AntiNuclElastic, G4ElasticHadrNucleusHE, G4HadronElastic, G4LEHadronProtonElastic, G4LEnp, G4LEpp, G4LowEHadronElastic, and G4hhElastic.

Definition at line 69 of file G4HadronicInteraction.cc.

{
  return 0.0;
}

◆ SampleQuarkFlavor()

G4int G4VLongitudinalStringDecay::SampleQuarkFlavor ( void )

inherited

Definition at line 393 of file G4VLongitudinalStringDecay.cc.

{
   G4int  quark(1);
   G4double ksi = G4UniformRand();
   if ( ksi < ProbCB ) {
      if ( ksi < ProbCCbar ) {quark = 4;}   // c quark
      else                   {quark = 5;}   // b quark
      #ifdef debug_heavyHadrons
      G4cout << "G4VLongitudinalStringDecay::SampleQuarkFlavor : sampled from the vacuum HEAVY quark = "
         << quark << G4endl;
      #endif
   } else {
     quark = 1 + (int)(G4UniformRand()/StrangeSuppress);
   }
   #ifdef debug_VStringDecay
   G4cout<<"VlongSD SampleQuarkFlavor "<<quark<<" (ProbCB ProbCCbar ProbBBbar "<<ProbCB
         <<" "<<ProbCCbar<<" "<<ProbBBbar<<" )"<<G4endl; 
   #endif
   return quark;
}

References G4cout, G4endl, G4UniformRand, G4VLongitudinalStringDecay::ProbBBbar, G4VLongitudinalStringDecay::ProbCB, G4VLongitudinalStringDecay::ProbCCbar, and G4VLongitudinalStringDecay::StrangeSuppress.

Referenced by G4VLongitudinalStringDecay::CreatePartonPair().

◆ SampleQuarkPt()

G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt ( G4double ptMax = -1. )

inherited

Definition at line 416 of file G4VLongitudinalStringDecay.cc.

{
   G4double Pt;
   if ( ptMax < 0 ) {
      // sample full gaussian
      Pt = -G4Log(G4UniformRand());
   } else {
      // sample in limited range
      G4double q = ptMax/SigmaQT;
      G4double ymin = (q > 20.) ? 0.0 : G4Exp(-q*q); 
      Pt = -G4Log(G4RandFlat::shoot(ymin, 1.));
   }
   Pt = SigmaQT * std::sqrt(Pt);
   G4double phi = 2.*pi*G4UniformRand();
   return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
}

References G4Exp(), G4Log(), G4UniformRand, pi, G4INCL::DeJongSpin::shoot(), and G4VLongitudinalStringDecay::SigmaQT.

Referenced by G4LundStringFragmentation::Sample4Momentum().

◆ SetDiquarkBreakProbability()

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability ( G4double aValue )

inherited

Definition at line 488 of file G4VLongitudinalStringDecay.cc.

{
  if ( PastInitPhase ) {
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
  } else {
    DiquarkBreakProb = aValue;
  }
}

References G4VLongitudinalStringDecay::DiquarkBreakProb, and G4VLongitudinalStringDecay::PastInitPhase.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), and G4QGSMFragmentation().

◆ SetDiquarkSuppression()

void G4VLongitudinalStringDecay::SetDiquarkSuppression ( G4double aValue )

inherited

Definition at line 481 of file G4VLongitudinalStringDecay.cc.

{
   DiquarkSuppress = aValue;
}

References G4VLongitudinalStringDecay::DiquarkSuppress.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), G4LundStringFragmentation::Splitup(), and Splitup().

◆ SetEnergyMomentumCheckLevels()

void G4HadronicInteraction::SetEnergyMomentumCheckLevels	(	G4double	relativeLevel,
		G4double	absoluteLevel
	)

inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

150 { epCheckLevels.first = relativeLevel;

151 epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

Referenced by G4BinaryCascade::G4BinaryCascade(), G4CascadeInterface::G4CascadeInterface(), and G4FTFModel::G4FTFModel().

◆ SetFFq2q()

void G4QGSMFragmentation::SetFFq2q ( )

private

Definition at line 771 of file G4QGSMFragmentation.cc.

{
  for (G4int i=0; i < 5; i++) {
    FFq2q[i][0][0] = 2.0 ; FFq2q[i][0][1] = -arho + alft;  // q->d + (q dbar) Pi0, Eta, Eta', Rho0, omega
    FFq2q[i][1][0] = 2.0 ; FFq2q[i][1][1] = -arho + alft;  // q->u + (q ubar) Pi-, Rho-
    FFq2q[i][2][0] = 1.0 ; FFq2q[i][2][1] = -aphi + alft;  // q->s + (q sbar) K0, K*0
    FFq2q[i][3][0] = 1.0 ; FFq2q[i][3][1] = -aJPs + alft;  // q->c + (q+cbar) D-, D*-
    FFq2q[i][4][0] = 1.0 ; FFq2q[i][4][1] = -aUps + alft;  // q->b + (q bbar) EtaB, Upsilon
  }
}

References aJPs, alft, aphi, arho, aUps, and FFq2q.

Referenced by G4QGSMFragmentation().

◆ SetFFq2qq()

void G4QGSMFragmentation::SetFFq2qq ( )

private

Definition at line 784 of file G4QGSMFragmentation.cc.

{
  for (G4int i=0; i < 5; i++) {
    FFq2qq[i][ 0][0] = 0.0 ; FFq2qq[i][ 0][1] = arho - 2.0*an    + alft;  // q->dd bar + (q dd)
    FFq2qq[i][ 1][0] = 0.0 ; FFq2qq[i][ 1][1] = arho - 2.0*an    + alft;  // q->ud bar + (q ud)
    FFq2qq[i][ 2][0] = 0.0 ; FFq2qq[i][ 2][1] = arho - 2.0*ala   + alft;  // q->sd bar + (q sd) 
    FFq2qq[i][ 3][0] = 0.0 ; FFq2qq[i][ 3][1] = arho - 2.0*alaC  + alft;  // q->cd bar + (q cd)
    FFq2qq[i][ 4][0] = 0.0 ; FFq2qq[i][ 4][1] = arho - 2.0*alaB  + alft;  // q->bd bar + (q bd)
    FFq2qq[i][ 5][0] = 0.0 ; FFq2qq[i][ 5][1] = arho - 2.0*an    + alft;  // q->uu bar + (q uu)
    FFq2qq[i][ 6][0] = 0.0 ; FFq2qq[i][ 6][1] = arho - 2.0*ala   + alft;  // q->su bar + (q su)
    FFq2qq[i][ 7][0] = 0.0 ; FFq2qq[i][ 7][1] = arho - 2.0*alaC  + alft;  // q->cu bar + (q cu)
    FFq2qq[i][ 8][0] = 0.0 ; FFq2qq[i][ 8][1] = arho - 2.0*alaB  + alft;  // q->bu bar + (q bu)
    FFq2qq[i][ 9][0] = 0.0 ; FFq2qq[i][ 9][1] = arho - 2.0*aXi   + alft;  // q->ss bar + (q ss)    
    FFq2qq[i][10][0] = 0.0 ; FFq2qq[i][10][1] = arho - 2.0*aXiC  + alft;  // q->cs bar + (q cs)
    FFq2qq[i][11][0] = 0.0 ; FFq2qq[i][11][1] = arho - 2.0*aXiB  + alft;  // q->bs bar + (q bc)
    FFq2qq[i][12][0] = 0.0 ; FFq2qq[i][12][1] = arho - 2.0*aXiCC + alft;  // q->cc bar + (q cc) 
    FFq2qq[i][13][0] = 0.0 ; FFq2qq[i][13][1] = arho - 2.0*aXiCB + alft;  // q->bc bar + (q bc)
    FFq2qq[i][14][0] = 0.0 ; FFq2qq[i][14][1] = arho - 2.0*aXiBB + alft;  // q->bb bar + (q bb)
  }
}

References ala, alaB, alaC, alft, an, arho, aXi, aXiB, aXiBB, aXiC, aXiCB, aXiCC, and FFq2qq.

Referenced by G4QGSMFragmentation().

◆ SetFFqq2q()

void G4QGSMFragmentation::SetFFqq2q ( )

private

Definition at line 807 of file G4QGSMFragmentation.cc.

{
  for (G4int i=0; i < 15; i++) {   
    FFqq2q[i][0][0] = 2.0*(arho - an); FFqq2q[i][0][1] = -arho + alft;
    FFqq2q[i][1][0] = 2.0*(arho - an); FFqq2q[i][1][1] = -arho + alft;
    FFqq2q[i][2][0] = 2.0*(arho - an); FFqq2q[i][2][1] = -aphi + alft;
    FFqq2q[i][3][0] = 2.0*(arho - an); FFqq2q[i][3][1] = -aJPs + alft;
    FFqq2q[i][4][0] = 2.0*(arho - an); FFqq2q[i][4][1] = -aUps + alft;
  }
}

References aJPs, alft, an, aphi, arho, aUps, and FFqq2q.

Referenced by G4QGSMFragmentation().

◆ SetFFqq2qq()

void G4QGSMFragmentation::SetFFqq2qq ( )

private

Definition at line 820 of file G4QGSMFragmentation.cc.

{
  for (G4int i=0; i < 15; i++) {
    FFqq2qq[i][0][0] = 0.  ;  FFqq2qq[i][0][1] = 2.0*arho - 2.0*an -arho + alft;  // dd -> dd + Pi0 (d d bar)
    FFqq2qq[i][1][0] = 0.  ;  FFqq2qq[i][1][1] = 2.0*arho - 2.0*an -arho + alft;  // dd -> ud + Pi- (d u bar)
    FFqq2qq[i][2][0] = 0.  ;  FFqq2qq[i][2][1] = 2.0*arho - 2.0*an -aphi + alft;  // dd -> sd + K0  (d s bar)
    FFqq2qq[i][3][0] = 0.  ;  FFqq2qq[i][3][1] = 2.0*arho - 2.0*an -aJPs + alft;  // dd -> cd + D-  (d c bar)
    FFqq2qq[i][4][0] = 0.  ;  FFqq2qq[i][4][1] = 2.0*arho - 2.0*an -aUps + alft;  // dd -> bd + B0  (d b bar)
  }
}

References aJPs, alft, an, aphi, arho, aUps, and FFqq2qq.

Referenced by G4QGSMFragmentation().

◆ SetMassCut()

void G4VLongitudinalStringDecay::SetMassCut ( G4double aValue )

protectedvirtualinherited

Definition at line 139 of file G4VLongitudinalStringDecay.cc.

139{ MassCut=aValue; }

References G4VLongitudinalStringDecay::MassCut.

Referenced by G4LundStringFragmentation::FragmentString(), and G4LundStringFragmentation::G4LundStringFragmentation().

◆ SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double anEnergy )

inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

103 { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

◆ SetMaxEnergy() [2/3]

void G4HadronicInteraction::SetMaxEnergy	(	G4double	anEnergy,
		const G4Element *	anElement
	)

inherited

Definition at line 151 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyListElements.empty()) {
    for(auto & elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second ) {
        elmlist.first = anEnergy;
        return;
      }
    }
  }
  theMaxEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyListElements.

◆ SetMaxEnergy() [3/3]

void G4HadronicInteraction::SetMaxEnergy	(	G4double	anEnergy,
		const G4Material *	aMaterial
	)

inherited

Definition at line 166 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyList.empty()) {
    for(auto & matlist: theMaxEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMaxEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyList.

◆ SetMinEnergy() [1/3]

void G4HadronicInteraction::SetMinEnergy ( G4double anEnergy )

inlineinherited

Definition at line 89 of file G4HadronicInteraction.hh.

90 { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

◆ SetMinEnergy() [2/3]

void G4HadronicInteraction::SetMinEnergy	(	G4double	anEnergy,
		const G4Element *	anElement
	)

inherited

Definition at line 101 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyListElements.empty()) {
    for(auto & elmlist : theMinEnergyListElements) {
      if( anElement == elmlist.second ) {
    elmlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyListElements.

◆ SetMinEnergy() [3/3]

void G4HadronicInteraction::SetMinEnergy	(	G4double	anEnergy,
		const G4Material *	aMaterial
	)

inherited

Definition at line 116 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyList.empty()) {
    for(auto & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyList.

◆ SetMinimalStringMass()

void G4VLongitudinalStringDecay::SetMinimalStringMass ( const G4FragmentingString *const string )

inherited

Definition at line 952 of file G4VLongitudinalStringDecay.cc.

{
        //MaxMass = -350.0*GeV;
    G4double EstimatedMass=MaxMass;
 
        G4ParticleDefinition* LeftParton  = string->GetLeftParton();
        G4ParticleDefinition* RightParton = string->GetRightParton();
        if( LeftParton->GetParticleSubType() == RightParton->GetParticleSubType() ) { // q qbar, qq qqbar
          if( LeftParton->GetPDGEncoding() * RightParton->GetPDGEncoding() > 0 ) {
            // Not allowed combination of the partons
            throw G4HadronicException(__FILE__, __LINE__,
                      "G4VLongitudinalStringDecay::SetMinimalStringMass: Illegal quark content as input");
          }
        }
        if( LeftParton->GetParticleSubType() != RightParton->GetParticleSubType() ) { // q qq, qbar qqbar
          if( LeftParton->GetPDGEncoding() * RightParton->GetPDGEncoding() < 0 ) {
            // Not allowed combination of the partons
            throw G4HadronicException(__FILE__, __LINE__,
                      "G4VLongitudinalStringDecay::SetMinimalStringMass: Illegal quark content as input");
          }
        }
    
        G4int Qleft =std::abs(string->GetLeftParton()->GetPDGEncoding());
        G4int Qright=std::abs(string->GetRightParton()->GetPDGEncoding());
 
        if ((Qleft < 6) && (Qright < 6)) {   // Q-Qbar string
          EstimatedMass=minMassQQbarStr[Qleft-1][Qright-1];
          MinimalStringMass=EstimatedMass;
          SetMinimalStringMass2(EstimatedMass);
          return;
        }
 
        if ((Qleft < 6) && (Qright > 1000)) {   // Q - DiQ string
          G4int q1=Qright/1000;
          G4int q2=(Qright/100)%10;
          EstimatedMass=minMassQDiQStr[Qleft-1][q1-1][q2-1];
          MinimalStringMass=EstimatedMass;                    // It can be negative!
          SetMinimalStringMass2(EstimatedMass);
          return;
        }
 
        if ((Qleft > 1000) && (Qright < 6)) {   // DiQ - Q string   6 6 6
          G4int q1=Qleft/1000;
          G4int q2=(Qleft/100)%10;
          EstimatedMass=minMassQDiQStr[Qright-1][q1-1][q2-1];
          MinimalStringMass=EstimatedMass;                    // It can be negative!
          SetMinimalStringMass2(EstimatedMass);
          return;
        }
 
        // DiQuark - Anti DiQuark string -----------------
 
    G4double StringM=string->Get4Momentum().mag();
 
        #ifdef debug_LUNDfragmentation
        // G4cout<<"MinStringMass// Input String mass "<<string->Get4Momentum().mag()<<" Qleft "<<Qleft<<G4endl;
        #endif
 
        G4int q1= Qleft/1000    ;
        G4int q2=(Qleft/100)%10 ;
 
        G4int q3= Qright/1000   ;
        G4int q4=(Qright/100)%10;
 
        // -------------- 2 baryon production or 2 mesons production --------
 
        G4double EstimatedMass1 = minMassQDiQStr[q1-1][q2-1][0];
        G4double EstimatedMass2 = minMassQDiQStr[q3-1][q4-1][0];
        // Mass is negative if there is no corresponding particle.
 
        if ( (EstimatedMass1 > 0.) && (EstimatedMass2 > 0.)) {
           EstimatedMass = EstimatedMass1 + EstimatedMass2;
           if ( StringM > EstimatedMass ) {                     // 2 baryon production is possible.
              MinimalStringMass=EstimatedMass1 + EstimatedMass2;
              SetMinimalStringMass2(EstimatedMass);
              return;
          }
        }
 
        if ( (EstimatedMass1 < 0.) && (EstimatedMass2 > 0.)) {
           EstimatedMass = MaxMass;
           MinimalStringMass=EstimatedMass;
           SetMinimalStringMass2(EstimatedMass);
           return;
        }
 
        if ( (EstimatedMass1 > 0.) && (EstimatedMass2 < 0.)) {
           EstimatedMass = EstimatedMass1;
           MinimalStringMass=EstimatedMass;
           SetMinimalStringMass2(EstimatedMass);
           return;
        }
 
        //      if ( EstimatedMass >= StringM ) {
        // ------------- Re-orangement ---------------
        EstimatedMass=std::min(minMassQQbarStr[q1-1][q3-1] + minMassQQbarStr[q2-1][q4-1],
                               minMassQQbarStr[q1-1][q4-1] + minMassQQbarStr[q2-1][q3-1]);
 
        // In principle, re-arrangement and 2 baryon production can compete.
        // More physics consideration is needed.
 
        MinimalStringMass=EstimatedMass;
        SetMinimalStringMass2(EstimatedMass);
 
        return;
}

References G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetPDGEncoding(), G4FragmentingString::GetRightParton(), G4VLongitudinalStringDecay::MaxMass, G4INCL::Math::min(), G4VLongitudinalStringDecay::MinimalStringMass, G4VLongitudinalStringDecay::minMassQDiQStr, G4VLongitudinalStringDecay::minMassQQbarStr, and G4VLongitudinalStringDecay::SetMinimalStringMass2().

Referenced by G4LundStringFragmentation::FragmentString(), FragmentString(), G4LundStringFragmentation::IsItFragmentable(), G4VLongitudinalStringDecay::ProduceOneHadron(), G4LundStringFragmentation::SplitEandP(), SplitEandP(), G4LundStringFragmentation::SplitLast(), G4LundStringFragmentation::StopFragmenting(), and StopFragmenting().

◆ SetMinimalStringMass2()

void G4VLongitudinalStringDecay::SetMinimalStringMass2 ( const G4double aValue )

inherited

Definition at line 1061 of file G4VLongitudinalStringDecay.cc.

{
    MinimalStringMass2=aValue * aValue;
}

References G4VLongitudinalStringDecay::MinimalStringMass2.

Referenced by G4VLongitudinalStringDecay::SetMinimalStringMass().

◆ SetMinMasses()

void G4VLongitudinalStringDecay::SetMinMasses ( )

inherited

Definition at line 609 of file G4VLongitudinalStringDecay.cc.

{
    // ------ For estimation of a minimal string mass ---------------
    Mass_of_light_quark =140.*MeV;
    Mass_of_s_quark     =500.*MeV;
    Mass_of_c_quark     =1600.*MeV;
    Mass_of_b_quark     =4500.*MeV;
    Mass_of_string_junction=720.*MeV;
 
    // ---------------- Determination of minimal mass of q-qbar strings -------------------
    G4ParticleDefinition * hadron1;    G4int Code1;
    G4ParticleDefinition * hadron2;    G4int Code2;
    for (G4int i=1; i < 6; i++) {
        Code1 = 100*i + 10*1 + 1;
        hadron1 = FindParticle(Code1);
 
        if (hadron1 != nullptr) {
           for (G4int j=1; j < 6; j++) {
               Code2 = 100*j + 10*1 + 1;
               hadron2 = FindParticle(Code2);
               if (hadron2 != nullptr) {
                 minMassQQbarStr[i-1][j-1] = hadron1->GetPDGMass() + hadron2->GetPDGMass() + 70.0 * MeV;
               }
           } 
        }
    }
 
    minMassQQbarStr[1][1] = minMassQQbarStr[0][0];   // u-ubar = 0.5 Pi0 + 0.24 Eta + 0.25 Eta'
 
    // ---------------- Determination of minimal mass of qq-q strings -------------------
    G4ParticleDefinition * hadron3;
    G4int kfla, kflb;
    //  MaxMass = -350.0*GeV;   // If there will be a particle with mass larger than Higgs the value must be changed.
 
    for (G4int i=1; i < 6; i++) {   //i=1
        Code1 = 100*i + 10*1 + 1;
        hadron1 = FindParticle(Code1);
        for (G4int j=1; j < 6; j++) {
            for (G4int k=1; k < 6; k++) {
                kfla = std::max(j,k);
                kflb = std::min(j,k);
 
        // Add d-quark
                Code2 = 1000*kfla + 100*kflb + 10*1 + 2;
        if ( (j == 1) && (k==1)) Code2 = 1000*2 + 100*1 + 10*1 + 2; // In the case - add u-quark.
 
                hadron2 = G4ParticleTable::GetParticleTable()->FindParticle(Code2);
                hadron3 = G4ParticleTable::GetParticleTable()->FindParticle(Code2 + 2);
 
                if ((hadron2 == nullptr) && (hadron3 == nullptr)) {minMassQDiQStr[i-1][j-1][k-1] = MaxMass; continue;};
 
                if ((hadron2 != nullptr) && (hadron3 != nullptr)) {
                   if (hadron2->GetPDGMass() > hadron3->GetPDGMass() ) { hadron2 = hadron3; }
                };
 
                if ((hadron2 != nullptr) && (hadron3 == nullptr)) {};
 
                if ((hadron2 == nullptr) && (hadron3 != nullptr)) {hadron2 = hadron3;};
 
                minMassQDiQStr[i-1][j-1][k-1] = hadron1->GetPDGMass() + hadron2->GetPDGMass() + 70.0 * MeV;
            }
        }
    }
 
    // ------ An estimated minimal string mass ----------------------
    MinimalStringMass  = 0.;
    MinimalStringMass2 = 0.;
    // q charges  d               u                s               c                b
    Qcharge[0] = -1; Qcharge[1] = 2; Qcharge[2] = -1; Qcharge[3] = 2; Qcharge[4] = -1;
 
    // For treating of small string decays
    for (G4int i=0; i<5; i++)
    {  for (G4int j=0; j<5; j++)
       {  for (G4int k=0; k<7; k++)
          {
            Meson[i][j][k]=0; MesonWeight[i][j][k]=0.;
          }
       }
    }
    //--------------------------
    for (G4int i=0; i<5; i++)
    {  for (G4int j=0; j<5; j++)
       {
         Meson[i][j][0]       = 100 * (std::max(i,j)+1) + 10 * (std::min(i,j)+1) + 1; // Scalar meson
         MesonWeight[i][j][0] = (   pspin_meson);
         Meson[i][j][1]       = 100 * (std::max(i,j)+1) + 10 * (std::min(i,j)+1) + 3; // Vector meson
         MesonWeight[i][j][1] = (1.-pspin_meson);
       }
    }
 
    //qqs                                                                                                         indexes
    //dd1 -> scalarMesonMix[0] * 111 + (1-scalarMesonMix[0]-scalarMesonMix[1]) * 221 + scalarMesonMix[1] * 331     (000)
    //dd1 ->                     Pi0                                             Eta                       Eta'
 
    Meson[0][0][0] = 111; MesonWeight[0][0][0] = (   pspin_meson) * (  scalarMesonMix[0]                  );  // Pi0
    Meson[0][0][2] = 221; MesonWeight[0][0][3] = (   pspin_meson) * (1-scalarMesonMix[0]-scalarMesonMix[1]);  // Eta
    Meson[0][0][3] = 331; MesonWeight[0][0][4] = (   pspin_meson) * (                    scalarMesonMix[1]);  // Eta'
 
    //dd3 -> vectorMesonMix[0] * 113 + (1-vectorMesonMix[0]-vectorMesonMix[1]) * 223 + vectorMesonMix[1] * 333     (001)
    //dd3 ->                    rho_0                                           omega                      phi
 
    Meson[0][0][1] = 113; MesonWeight[0][0][1] = (1.-pspin_meson) * (  vectorMesonMix[0]                  );  // Rho
    Meson[0][0][4] = 223; MesonWeight[0][0][4] = (1.-pspin_meson) * (1-vectorMesonMix[0]-vectorMesonMix[1]);  // omega
    Meson[0][0][5] = 333; MesonWeight[0][0][5] = (1.-pspin_meson) * (                    vectorMesonMix[1]);  // phi
 
    //uu1 -> scalarMesonMix[0] * 111 + (1-scalarMesonMix[0]-scalarMesonMix[1]) * 221 + scalarMesonMix[1] * 331     (110)
    //uu1 ->                     Pi0                                             Eta                       Eta'
 
    Meson[1][1][0] = 111; MesonWeight[1][1][0] = (   pspin_meson) * (  scalarMesonMix[0]                  );  // Pi0
    Meson[1][1][2] = 221; MesonWeight[1][1][2] = (   pspin_meson) * (1-scalarMesonMix[0]-scalarMesonMix[1]);  // Eta
    Meson[1][1][3] = 331; MesonWeight[1][1][3] = (   pspin_meson) * (                    scalarMesonMix[1]);  // Eta'
 
    //uu3 -> vectorMesonMix[0] * 113 + (1-vectorMesonMix[0]-vectorMesonMix[1]) * 223 + vectorMesonMix[1] * 333     (111)
    //uu3 ->                    rho_0                                           omega                      phi
 
    Meson[1][1][1] = 113; MesonWeight[1][1][1] = (1.-pspin_meson) * (  vectorMesonMix[0]                  );  // Rho
    Meson[1][1][4] = 223; MesonWeight[1][1][4] = (1.-pspin_meson) * (1-vectorMesonMix[0]-vectorMesonMix[1]);  // omega
    Meson[1][1][5] = 333; MesonWeight[1][1][5] = (1.-pspin_meson) * (                    vectorMesonMix[1]);  // phi
 
    //ss1     ->                                             (1-scalarMesonMix[5]) * 221 + scalarMesonMix[5] * 331   (220)
    //ss1     ->                                                                     Eta                       Eta'
 
    Meson[2][2][0] = 221; MesonWeight[2][2][0] = (   pspin_meson) * (1-scalarMesonMix[5]                  );  // Eta
    Meson[2][2][2] = 331; MesonWeight[2][2][2] = (   pspin_meson) * (                    scalarMesonMix[5]);  // Eta'
 
    //ss3     ->                                             (1-vectorMesonMix[5]) * 223 + vectorMesonMix[5] * 333   (221)
    //ss3     ->                                                                    omega                      phi
 
    Meson[2][2][1] = 223; MesonWeight[2][2][1] = (1.-pspin_meson) * (1-vectorMesonMix[5]                  );  // omega
    Meson[2][2][3] = 333; MesonWeight[2][2][3] = (1.-pspin_meson) * (                    vectorMesonMix[5]);  // phi
 
    //cc1     ->    ProbEta_c /(1-pspin_meson) 441  (330) Probability of Eta_c
    //cc3     -> (1-ProbEta_c)/(  pspin_meson) 443  (331) Probability of J/Psi
 
    //bb1     ->    ProbEta_b /pspin_meson 551  (440) Probability of Eta_b
    //bb3     -> (1-ProbEta_b)/pspin_meson 553  (441) Probability of Upsilon
 
    if ( pspin_meson != 0. ) {
       Meson[3][3][0] *= (    ProbEta_c)/(   pspin_meson);   // Eta_c
       Meson[3][3][1] *= (1.0-ProbEta_c)/(1.-pspin_meson);   // J/Psi
 
       Meson[4][4][0] *= (    ProbEta_b)/(   pspin_meson);   // Eta_b
       Meson[4][4][1] *= (1.0-ProbEta_b)/(1.-pspin_meson);   // Upsilon
    }
 
    //--------------------------
 
    for (G4int i=0; i<5; i++)
    {  for (G4int j=0; j<5; j++)
       {  for (G4int k=0; k<5; k++)
          {  for (G4int l=0; l<4; l++)
             { Baryon[i][j][k][l]=0; BaryonWeight[i][j][k][l]=0.;}
          }
       }
    }
 
          kfla =0;  kflb =0;
    G4int                   kflc(0), kfld(0), kfle(0), kflf(0);
    for (G4int i=0; i<5; i++)
    {  for (G4int j=0; j<5; j++)
       {  for (G4int k=0; k<5; k++)
          {  
           kfla = i+1; kflb = j+1; kflc = k+1;
       kfld = std::max(kfla,kflb);
       kfld = std::max(kfld,kflc);
 
       kflf = std::min(kfla,kflb);
       kflf = std::min(kflf,kflc);
 
           kfle = kfla + kflb + kflc - kfld - kflf;
 
           Baryon[i][j][k][0]       = 1000 * kfld + 100 * kfle + 10 * kflf + 2; // spin=1/2
           BaryonWeight[i][j][k][0] = (   pspin_barion);
           Baryon[i][j][k][1]       = 1000 * kfld + 100 * kfle + 10 * kflf + 4; // spin=3/2
           BaryonWeight[i][j][k][1] = (1.-pspin_barion);
          }
       }
    }
 
    // Delta-  ddd - only 1114
    Baryon[0][0][0][0] = 1114;    BaryonWeight[0][0][0][0] = 1.0; 
    Baryon[0][0][0][1] =    0;    BaryonWeight[0][0][0][1] = 0.0; 
 
    // Delta++ uuu - only 2224
    Baryon[1][1][1][0] = 2224;    BaryonWeight[1][1][1][0] = 1.0; 
    Baryon[1][1][1][1] =    0;    BaryonWeight[1][1][1][1] = 0.0; 
 
    // Omega- sss - only 3334
    Baryon[2][2][2][0] = 3334;    BaryonWeight[2][2][2][0] = 1.0; 
    Baryon[2][2][2][1] =    0;    BaryonWeight[2][2][2][1] = 0.0; 
 
    // Omega_cc++ ccc - only 4444
    Baryon[3][3][3][0] = 4444;    BaryonWeight[3][3][3][0] = 1.0; 
    Baryon[3][3][3][1] =    0;    BaryonWeight[3][3][3][1] = 0.0; 
 
    // Omega_bb-  bbb - only 5554
    Baryon[4][4][4][0] = 5554;    BaryonWeight[4][4][4][0] = 1.0; 
    Baryon[4][4][4][1] =    0;    BaryonWeight[4][4][4][1] = 0.0; 
 
    // Lambda/Sigma0 sud - 3122/3212
    Baryon[0][1][2][0] = 3122;    BaryonWeight[0][1][2][0] *= 0.5;                  // Lambda
    Baryon[0][2][1][0] = 3122;    BaryonWeight[0][2][1][0] *= 0.5;
    Baryon[1][0][2][0] = 3122;    BaryonWeight[1][0][2][0] *= 0.5;
    Baryon[1][2][0][0] = 3122;    BaryonWeight[1][2][0][0] *= 0.5;
    Baryon[2][0][1][0] = 3122;    BaryonWeight[2][0][1][0] *= 0.5;
    Baryon[2][1][0][0] = 3122;    BaryonWeight[2][1][0][0] *= 0.5;
 
    Baryon[0][1][2][2] = 3212;    BaryonWeight[0][1][2][2]  = 0.5 * pspin_barion;   // Sigma0
    Baryon[0][2][1][2] = 3212;    BaryonWeight[0][2][1][2]  = 0.5 * pspin_barion;
    Baryon[1][0][2][2] = 3212;    BaryonWeight[1][0][2][2]  = 0.5 * pspin_barion;
    Baryon[1][2][0][2] = 3212;    BaryonWeight[1][2][0][2]  = 0.5 * pspin_barion;
    Baryon[2][0][1][2] = 3212;    BaryonWeight[2][0][1][2]  = 0.5 * pspin_barion;
    Baryon[2][1][0][2] = 3212;    BaryonWeight[2][1][0][2]  = 0.5 * pspin_barion;
 
    // Lambda_c+/Sigma_c+ cud - 4122/4212
    Baryon[0][1][3][0] = 4122;    BaryonWeight[0][1][3][0] *= 0.5;                  // Lambda_c+
    Baryon[0][3][1][0] = 4122;    BaryonWeight[0][3][1][0] *= 0.5;
    Baryon[1][0][3][0] = 4122;    BaryonWeight[1][0][3][0] *= 0.5;
    Baryon[1][3][0][0] = 4122;    BaryonWeight[1][3][0][0] *= 0.5;
    Baryon[3][0][1][0] = 4122;    BaryonWeight[3][0][1][0] *= 0.5;
    Baryon[3][1][0][0] = 4122;    BaryonWeight[3][1][0][0] *= 0.5;
 
    Baryon[0][1][3][2] = 4212;    BaryonWeight[0][1][3][2]  = 0.5 * pspin_barion;   // SigmaC+
    Baryon[0][3][1][2] = 4212;    BaryonWeight[0][3][1][2]  = 0.5 * pspin_barion;
    Baryon[1][0][3][2] = 4212;    BaryonWeight[1][0][3][2]  = 0.5 * pspin_barion;
    Baryon[1][3][0][2] = 4212;    BaryonWeight[1][3][0][2]  = 0.5 * pspin_barion;
    Baryon[3][0][1][2] = 4212;    BaryonWeight[3][0][1][2]  = 0.5 * pspin_barion;
    Baryon[3][1][0][2] = 4212;    BaryonWeight[3][1][0][2]  = 0.5 * pspin_barion;
 
    // Xi_c+/Xi_c+' cus - 4232/4322
    Baryon[1][2][3][0] = 4232;    BaryonWeight[1][2][3][0] *= 0.5;                  // Xi_c+
    Baryon[1][3][2][0] = 4232;    BaryonWeight[1][3][2][0] *= 0.5;
    Baryon[2][1][3][0] = 4232;    BaryonWeight[2][1][3][0] *= 0.5;
    Baryon[2][3][1][0] = 4232;    BaryonWeight[2][3][1][0] *= 0.5;
    Baryon[3][1][2][0] = 4232;    BaryonWeight[3][1][2][0] *= 0.5;
    Baryon[3][2][1][0] = 4232;    BaryonWeight[3][2][1][0] *= 0.5;
 
    Baryon[1][2][3][2] = 4322;    BaryonWeight[1][2][3][2]  = 0.5 * pspin_barion;   // Xi_c+'
    Baryon[1][3][2][2] = 4322;    BaryonWeight[1][3][2][2]  = 0.5 * pspin_barion;
    Baryon[2][1][3][2] = 4322;    BaryonWeight[2][1][3][2]  = 0.5 * pspin_barion;
    Baryon[2][3][1][2] = 4322;    BaryonWeight[2][3][1][2]  = 0.5 * pspin_barion;
    Baryon[3][1][2][2] = 4322;    BaryonWeight[3][1][2][2]  = 0.5 * pspin_barion;
    Baryon[3][2][1][2] = 4322;    BaryonWeight[3][2][1][2]  = 0.5 * pspin_barion;
 
    // Xi_c0/Xi_c0' cus - 4132/4312
    Baryon[0][2][3][0] = 4132;    BaryonWeight[0][2][3][0] *= 0.5;                  // Xi_c0
    Baryon[0][3][2][0] = 4132;    BaryonWeight[0][3][2][0] *= 0.5;
    Baryon[2][0][3][0] = 4132;    BaryonWeight[2][0][3][0] *= 0.5;
    Baryon[2][3][0][0] = 4132;    BaryonWeight[2][3][0][0] *= 0.5;
    Baryon[3][0][2][0] = 4132;    BaryonWeight[3][0][2][0] *= 0.5;
    Baryon[3][2][0][0] = 4132;    BaryonWeight[3][2][0][0] *= 0.5;
 
    Baryon[0][2][3][2] = 4312;    BaryonWeight[0][2][3][2]  = 0.5 * pspin_barion;   // Xi_c0'
    Baryon[0][3][2][2] = 4312;    BaryonWeight[0][3][2][2]  = 0.5 * pspin_barion;
    Baryon[2][0][3][2] = 4312;    BaryonWeight[2][0][3][2]  = 0.5 * pspin_barion;
    Baryon[2][3][0][2] = 4312;    BaryonWeight[2][3][0][2]  = 0.5 * pspin_barion;
    Baryon[3][0][2][2] = 4312;    BaryonWeight[3][0][2][2]  = 0.5 * pspin_barion;
    Baryon[3][2][0][2] = 4312;    BaryonWeight[3][2][0][2]  = 0.5 * pspin_barion;
 
    // Lambda_b0/Sigma_b0 bud - 5122/5212
    Baryon[0][1][4][0] = 5122;    BaryonWeight[0][1][4][0] *= 0.5;                  // Lambda_b0
    Baryon[0][4][1][0] = 5122;    BaryonWeight[0][4][1][0] *= 0.5;
    Baryon[1][0][4][0] = 5122;    BaryonWeight[1][0][4][0] *= 0.5;
    Baryon[1][4][0][0] = 5122;    BaryonWeight[1][4][0][0] *= 0.5;
    Baryon[4][0][1][0] = 5122;    BaryonWeight[4][0][1][0] *= 0.5;
    Baryon[4][1][0][0] = 5122;    BaryonWeight[4][1][0][0] *= 0.5;
 
    Baryon[0][1][4][2] = 5212;    BaryonWeight[0][1][4][2]  = 0.5 * pspin_barion;   // Sigma_b0
    Baryon[0][4][1][2] = 5212;    BaryonWeight[0][4][1][2]  = 0.5 * pspin_barion;
    Baryon[1][0][4][2] = 5212;    BaryonWeight[1][0][4][2]  = 0.5 * pspin_barion;
    Baryon[1][4][0][2] = 5212;    BaryonWeight[1][4][0][2]  = 0.5 * pspin_barion;
    Baryon[4][0][1][2] = 5212;    BaryonWeight[4][0][1][2]  = 0.5 * pspin_barion;
    Baryon[4][1][0][2] = 5212;    BaryonWeight[4][1][0][2]  = 0.5 * pspin_barion;
 
    // Xi_b0/Xi_b0' bus - 5232/5322
    Baryon[1][2][4][0] = 5232;    BaryonWeight[1][2][4][0] *= 0.5;                  // Xi_b0
    Baryon[1][4][2][0] = 5232;    BaryonWeight[1][4][2][0] *= 0.5;
    Baryon[2][1][4][0] = 5232;    BaryonWeight[2][1][4][0] *= 0.5;
    Baryon[2][4][1][0] = 5232;    BaryonWeight[2][4][1][0] *= 0.5;
    Baryon[4][1][2][0] = 5232;    BaryonWeight[4][1][2][0] *= 0.5;
    Baryon[4][2][1][0] = 5232;    BaryonWeight[4][2][1][0] *= 0.5;
 
    Baryon[1][2][4][2] = 5322;    BaryonWeight[1][2][4][2]  = 0.5 * pspin_barion;   // Xi_b0'
    Baryon[1][4][2][2] = 5322;    BaryonWeight[1][4][2][2]  = 0.5 * pspin_barion;
    Baryon[2][1][4][2] = 5322;    BaryonWeight[2][1][4][2]  = 0.5 * pspin_barion;
    Baryon[2][4][1][2] = 5322;    BaryonWeight[2][4][1][2]  = 0.5 * pspin_barion;
    Baryon[4][1][2][2] = 5322;    BaryonWeight[4][1][2][2]  = 0.5 * pspin_barion;
    Baryon[4][2][1][2] = 5322;    BaryonWeight[4][2][1][2]  = 0.5 * pspin_barion;
 
    // Xi_b-/Xi_b-' bus - 5132/5312
    Baryon[0][2][4][0] = 5132;    BaryonWeight[0][2][4][0] *= 0.5;                  // Xi_b-
    Baryon[0][4][2][0] = 5132;    BaryonWeight[0][4][2][0] *= 0.5;
    Baryon[2][0][4][0] = 5132;    BaryonWeight[2][0][4][0] *= 0.5;
    Baryon[2][4][0][0] = 5132;    BaryonWeight[2][4][0][0] *= 0.5;
    Baryon[4][0][2][0] = 5132;    BaryonWeight[4][0][2][0] *= 0.5;
    Baryon[4][2][0][0] = 5132;    BaryonWeight[4][2][0][0] *= 0.5;
 
    Baryon[0][2][4][2] = 5312;    BaryonWeight[0][2][4][2]  = 0.5 * pspin_barion;   // Xi_b-'
    Baryon[0][4][2][2] = 5312;    BaryonWeight[0][4][2][2]  = 0.5 * pspin_barion;
    Baryon[2][0][4][2] = 5312;    BaryonWeight[2][0][4][2]  = 0.5 * pspin_barion;
    Baryon[2][4][0][2] = 5312;    BaryonWeight[2][4][0][2]  = 0.5 * pspin_barion;
    Baryon[4][0][2][2] = 5312;    BaryonWeight[4][0][2][2]  = 0.5 * pspin_barion;
    Baryon[4][2][0][2] = 5312;    BaryonWeight[4][2][0][2]  = 0.5 * pspin_barion;
 
    for (G4int i=0; i<5; i++)
    {  for (G4int j=0; j<5; j++)
      {  for (G4int k=0; k<5; k++)
         {  for (G4int l=0; l<4; l++)
            { 
                     G4ParticleDefinition * TestHadron=
                       G4ParticleTable::GetParticleTable()->FindParticle(Baryon[i][j][k][l]);
                     /*
                     G4cout<<i<<" "<<j<<" "<<k<<" "<<l<<" "<<Baryon[i][j][k][l]<<" "<<TestHadron<<" "<<BaryonWeight[i][j][k][l];
                     if (TestHadron != nullptr) G4cout<<" "<<TestHadron->GetParticleName();
                     if ((TestHadron == nullptr)&&(Baryon[i][j][k][l] != 0)) G4cout<<" *****";
                     if ((TestHadron == nullptr)&&(Baryon[i][j][k][l] == 0)) G4cout<<" ---------------";
                     G4cout<<G4endl;
                     */
                     if ((TestHadron == nullptr)&&(Baryon[i][j][k][l] != 0)) Baryon[i][j][k][l] = 0;
                    }
         }
      }
    }
 
    // --------- Probabilities of q-qbar pair productions for kink or gluons.
    G4double ProbUUbar = 0.33;
    Prob_QQbar[0]=ProbUUbar;         // Probability of ddbar production
    Prob_QQbar[1]=ProbUUbar;         // Probability of uubar production
    Prob_QQbar[2]=1.0-2.*ProbUUbar;  // Probability of ssbar production 
    Prob_QQbar[3]=0.0;               // Probability of ccbar production
    Prob_QQbar[4]=0.0;               // Probability of bbbar production
 
    for ( G4int i=0 ; i<350 ; i++ ) { // Must be checked
      FS_LeftHadron[i] = 0;
      FS_RightHadron[i] = 0;
      FS_Weight[i] = 0.0; 
    }
 
    NumberOf_FS = 0;
}

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), and G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

◆ SetModelName()

void G4HadronicInteraction::SetModelName ( const G4String & nam )

inlineprotectedinherited

Definition at line 166 of file G4HadronicInteraction.hh.

167 { theModelName = nam; }

References G4HadronicInteraction::theModelName.

Referenced by G4ExcitedStringDecay::G4ExcitedStringDecay().

◆ SetProbBBbar()

void G4VLongitudinalStringDecay::SetProbBBbar ( G4double aValue )

inherited

Definition at line 587 of file G4VLongitudinalStringDecay.cc.

{
   ProbBBbar = aValue;
   ProbCB = ProbCCbar + ProbBBbar;
}

References G4VLongitudinalStringDecay::ProbBBbar, G4VLongitudinalStringDecay::ProbCB, and G4VLongitudinalStringDecay::ProbCCbar.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), and G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

◆ SetProbCCbar()

void G4VLongitudinalStringDecay::SetProbCCbar ( G4double aValue )

inherited

Definition at line 572 of file G4VLongitudinalStringDecay.cc.

{
   ProbCCbar = aValue;
   ProbCB = ProbCCbar + ProbBBbar;
}

References G4VLongitudinalStringDecay::ProbBBbar, G4VLongitudinalStringDecay::ProbCB, and G4VLongitudinalStringDecay::ProbCCbar.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), and G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

◆ SetProbEta_b()

void G4VLongitudinalStringDecay::SetProbEta_b ( G4double aValue )

inherited

Definition at line 595 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_b = aValue;
}

References G4VLongitudinalStringDecay::ProbEta_b.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

◆ SetProbEta_c()

void G4VLongitudinalStringDecay::SetProbEta_c ( G4double aValue )

inherited

Definition at line 580 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_c = aValue;
}

References G4VLongitudinalStringDecay::ProbEta_c.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

◆ SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double val )

inlineinherited

Definition at line 138 of file G4HadronicInteraction.hh.

139 { recoilEnergyThreshold = val; }

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

◆ SetScalarMesonMixings()

void G4VLongitudinalStringDecay::SetScalarMesonMixings ( std::vector< G4double > aVector )

inherited

Definition at line 528 of file G4VLongitudinalStringDecay.cc.

{
  if ( PastInitPhase ) {
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
  } else {
    if ( aVector.size() < 6 ) 
      throw G4HadronicException(__FILE__, __LINE__, 
        "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
    scalarMesonMix[0] = aVector[0];
    scalarMesonMix[1] = aVector[1];
    scalarMesonMix[2] = aVector[2];
    scalarMesonMix[3] = aVector[3];
    scalarMesonMix[4] = aVector[4];
    scalarMesonMix[5] = aVector[5];
    delete hadronizer;
    hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
  }
}

References G4VLongitudinalStringDecay::hadronizer, G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProbEta_b, G4VLongitudinalStringDecay::ProbEta_c, G4VLongitudinalStringDecay::pspin_barion, G4VLongitudinalStringDecay::pspin_meson, G4VLongitudinalStringDecay::scalarMesonMix, and G4VLongitudinalStringDecay::vectorMesonMix.

◆ SetSigmaTransverseMomentum()

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum ( G4double aQT )

inherited

Definition at line 462 of file G4VLongitudinalStringDecay.cc.

{
   if ( PastInitPhase ) {
     throw G4HadronicException(__FILE__, __LINE__, 
       "G4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
   } else {
     SigmaQT = aValue;
   }
}

References G4VLongitudinalStringDecay::PastInitPhase, and G4VLongitudinalStringDecay::SigmaQT.

◆ SetSpinThreeHalfBarionProbability()

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability ( G4double aValue )

inherited

Definition at line 514 of file G4VLongitudinalStringDecay.cc.

{
  if ( PastInitPhase ) {
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
  } else {
    pspin_barion = aValue;
    delete hadronizer;
    hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
  }
}

References G4VLongitudinalStringDecay::hadronizer, G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProbEta_b, G4VLongitudinalStringDecay::ProbEta_c, G4VLongitudinalStringDecay::pspin_barion, G4VLongitudinalStringDecay::pspin_meson, G4VLongitudinalStringDecay::scalarMesonMix, and G4VLongitudinalStringDecay::vectorMesonMix.

◆ SetStrangenessSuppression()

void G4VLongitudinalStringDecay::SetStrangenessSuppression ( G4double aValue )

inherited

Definition at line 474 of file G4VLongitudinalStringDecay.cc.

{
   StrangeSuppress = aValue;
}

References G4VLongitudinalStringDecay::StrangeSuppress.

Referenced by DiQuarkSplitup(), G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), and G4LundStringFragmentation::Splitup().

◆ SetStringTensionParameter()

void G4VLongitudinalStringDecay::SetStringTensionParameter ( G4double aValue )

inherited

Definition at line 602 of file G4VLongitudinalStringDecay.cc.

{
   Kappa = aValue * GeV/fermi;
}   

References fermi, GeV, and G4VLongitudinalStringDecay::Kappa.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

◆ SetVectorMesonMixings()

void G4VLongitudinalStringDecay::SetVectorMesonMixings ( std::vector< G4double > aVector )

inherited

Definition at line 550 of file G4VLongitudinalStringDecay.cc.

{
  if ( PastInitPhase ) {
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
  } else {
    if ( aVector.size() < 6 ) 
      throw G4HadronicException(__FILE__, __LINE__, 
        "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
    vectorMesonMix[0] = aVector[0];
    vectorMesonMix[1] = aVector[1];
    vectorMesonMix[2] = aVector[2];
    vectorMesonMix[3] = aVector[3];
    vectorMesonMix[4] = aVector[4];
    vectorMesonMix[5] = aVector[5];
    delete hadronizer;
    hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
  }
}

References G4VLongitudinalStringDecay::hadronizer, G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProbEta_b, G4VLongitudinalStringDecay::ProbEta_c, G4VLongitudinalStringDecay::pspin_barion, G4VLongitudinalStringDecay::pspin_meson, G4VLongitudinalStringDecay::scalarMesonMix, and G4VLongitudinalStringDecay::vectorMesonMix.

◆ SetVectorMesonProbability()

void G4VLongitudinalStringDecay::SetVectorMesonProbability ( G4double aValue )

inherited

Definition at line 500 of file G4VLongitudinalStringDecay.cc.

{
  if ( PastInitPhase ) {
    throw G4HadronicException(__FILE__, __LINE__, 
      "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
  } else {
    pspin_meson = aValue;
    delete hadronizer;
    hadronizer = new G4HadronBuilder( pspin_meson, pspin_barion, scalarMesonMix, vectorMesonMix, ProbEta_c, ProbEta_b );
  }
}

References G4VLongitudinalStringDecay::hadronizer, G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProbEta_b, G4VLongitudinalStringDecay::ProbEta_c, G4VLongitudinalStringDecay::pspin_barion, G4VLongitudinalStringDecay::pspin_meson, G4VLongitudinalStringDecay::scalarMesonMix, and G4VLongitudinalStringDecay::vectorMesonMix.

◆ SetVerboseLevel()

void G4HadronicInteraction::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 112 of file G4HadronicInteraction.hh.

113 { verboseLevel = value; }

References G4HadronicInteraction::verboseLevel.

Referenced by G4CascadeInterface::SetVerboseLevel(), and G4PreCompoundDeexcitation::setVerboseLevel().

◆ SplitEandP()

G4LorentzVector * G4QGSMFragmentation::SplitEandP	(	G4ParticleDefinition *	pHadron,
		G4FragmentingString *	string,
		G4FragmentingString *	newString
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 456 of file G4QGSMFragmentation.cc.

{
       G4double HadronMass = pHadron->GetPDGMass();
 
       SetMinimalStringMass(NewString);
 
       if ( MinimalStringMass < 0.0 ) return nullptr;
 
       #ifdef debug_QGSMfragmentation
       G4cout<<"G4QGSMFragmentation::SplitEandP "<<pHadron->GetParticleName()<<G4endl;
       G4cout<<"String 4 mom, String M "<<string->Get4Momentum()<<" "<<string->Mass()<<G4endl;
       G4cout<<"HadM MinimalStringMassLeft StringM hM+sM "<<HadronMass<<" "<<MinimalStringMass<<" "
             <<string->Mass()<<" "<<HadronMass+MinimalStringMass<<G4endl;
       #endif
 
       if (HadronMass + MinimalStringMass > string->Mass())
       {
         #ifdef debug_QGSMfragmentation
         G4cout<<"Mass of the string is not sufficient to produce the hadron!"<<G4endl;
         #endif
     return 0;
       }  // have to start all over!
 
       // calculate and assign hadron transverse momentum component HadronPx andHadronPy
       G4double StringMT2 = string->MassT2();
       G4double StringMT  = std::sqrt(StringMT2);
 
       G4LorentzVector String4Momentum = string->Get4Momentum();
       String4Momentum.setPz(0.);
       G4ThreeVector StringPt = String4Momentum.vect();
 
       G4ThreeVector HadronPt    , RemSysPt;
       G4double      HadronMassT2, ResidualMassT2;
 
       //Uzhi June 2020  Mt distribution is implemented
       G4double HadronMt, Pt, Pt2, phi;  // Uzhi June 2020
 
       //...  sample Pt of the hadron
       G4int attempt=0;
       do
       {
         attempt++; if (attempt > StringLoopInterrupt) return 0;
 
         HadronMt = HadronMass - 200.0*G4Log(G4UniformRand());    // Uzhi June 2020, 200.0 must be tuned
         Pt2 = sqr(HadronMt)-sqr(HadronMass); Pt=std::sqrt(Pt2);  // Uzhi June 2020
         phi = 2.*pi*G4UniformRand();
         G4ThreeVector SampleQuarkPtw= G4ThreeVector(Pt*std::cos(phi), Pt*std::sin(phi), 0);
         HadronPt =SampleQuarkPtw  + string->DecayPt();           // Uzhi June 2020
         //Uzhi June 2020  HadronPt =SampleQuarkPt()  + string->DecayPt();  // Save this for possible return
         HadronPt.setZ(0);
         RemSysPt = StringPt - HadronPt;
 
         HadronMassT2 = sqr(HadronMass) + HadronPt.mag2();
         ResidualMassT2=sqr(MinimalStringMass) + RemSysPt.mag2();
 
       } while (std::sqrt(HadronMassT2) + std::sqrt(ResidualMassT2) > StringMT);  /* Loop checking, 07.08.2015, A.Ribon */
 
       //...  sample z to define hadron longitudinal momentum and energy
       //... but first check the available phase space
 
       G4double Pz2 = (sqr(StringMT2 - HadronMassT2 - ResidualMassT2) -
              4*HadronMassT2 * ResidualMassT2)/4./StringMT2;
 
       if ( Pz2 < 0 ) {return 0;}          // have to start all over!
 
       //... then compute allowed z region  z_min <= z <= z_max
 
       G4double Pz = std::sqrt(Pz2);
       G4double zMin = (std::sqrt(HadronMassT2+Pz2) - Pz)/std::sqrt(StringMT2);
       G4double zMax = (std::sqrt(HadronMassT2+Pz2) + Pz)/std::sqrt(StringMT2);
 
       if (zMin >= zMax) return 0;      // have to start all over!
    
       G4double z = GetLightConeZ(zMin, zMax,
                          string->GetDecayParton()->GetPDGEncoding(), pHadron,
                          HadronPt.x(), HadronPt.y());      
 
       //... now compute hadron longitudinal momentum and energy
       // longitudinal hadron momentum component HadronPz
 
       HadronPt.setZ( 0.5* string->GetDecayDirection() *
              (z * string->LightConeDecay() - 
               HadronMassT2/(z * string->LightConeDecay())) );
       G4double HadronE  = 0.5* (z * string->LightConeDecay() + 
                 HadronMassT2/(z * string->LightConeDecay()) );
 
       G4LorentzVector * a4Momentum= new G4LorentzVector(HadronPt,HadronE);
 
       #ifdef debug_QGSMfragmentation
       G4cout<<"string->GetDecayDirection() string->LightConeDecay() "
             <<string->GetDecayDirection()<<" "<<string->LightConeDecay()<<G4endl;
       G4cout<<"HadronPt,HadronE "<<HadronPt<<" "<<HadronE<<G4endl;
       G4cout<<"Out of QGSM SplitEandP "<<G4endl;
       #endif
 
       return a4Momentum;
}

References G4cout, G4endl, G4Log(), G4UniformRand, G4FragmentingString::GetDecayDirection(), G4FragmentingString::GetDecayParton(), GetLightConeZ(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4FragmentingString::LightConeDecay(), CLHEP::Hep3Vector::mag2(), G4FragmentingString::Mass(), G4VLongitudinalStringDecay::MinimalStringMass, NewString, pi, G4VLongitudinalStringDecay::SetMinimalStringMass(), CLHEP::HepLorentzVector::setPz(), CLHEP::Hep3Vector::setZ(), sqr(), G4VLongitudinalStringDecay::StringLoopInterrupt, CLHEP::HepLorentzVector::vect(), CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by Splitup().

◆ SplitLast()

G4bool G4QGSMFragmentation::SplitLast	(	G4FragmentingString *	string,
		G4KineticTrackVector *	LeftVector,
		G4KineticTrackVector *	RightVector
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 626 of file G4QGSMFragmentation.cc.

{
    //... perform last cluster decay
 
    G4ThreeVector ClusterVel =string->Get4Momentum().boostVector();
    G4double ResidualMass    =string->Mass();
 
    #ifdef debug_QGSMfragmentation
    G4cout<<"Split last-----------------------------------------"<<G4endl;
    G4cout<<"StrMass "<<ResidualMass<<" q's "
          <<string->GetLeftParton()->GetParticleName()<<" "
          <<string->GetRightParton()->GetParticleName()<<G4endl;
    #endif
 
    G4int cClusterInterrupt = 0;
    G4ParticleDefinition *LeftHadron = nullptr;
    G4ParticleDefinition *RightHadron = nullptr;
    const G4int maxNumberOfLoops = 1000;
    G4int loopCounter = 0;
 
    G4double LeftHadronMass(0.); G4double RightHadronMass(0.);
    do
    {
        if (cClusterInterrupt++ >= ClusterLoopInterrupt) return false;  // Uzhi June 2020
        LeftHadronMass = -MaxMass; RightHadronMass = -MaxMass;
 
    G4ParticleDefinition * quark = nullptr;
    string->SetLeftPartonStable(); // to query quark contents..
 
    if (string->DecayIsQuark() && string->StableIsQuark() ) 
    {
      //... there are quarks on cluster ends
 
      G4int IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1; 
                // if we have a quark, we need antiquark or diquark
 
      pDefPair QuarkPair = CreatePartonPair(IsParticle);
      quark = QuarkPair.second;
 
      LeftHadron= hadronizer->BuildLowSpin(QuarkPair.first, string->GetLeftParton());
          if ( LeftHadron == NULL ) continue;                                      // Uzhi June 2020
          RightHadron = hadronizer->BuildLowSpin(string->GetRightParton(), quark); // Uzhi June 2020
          if ( RightHadron == NULL ) continue;                                     // Uzhi June 2020
    } else if( (!string->DecayIsQuark() &&  string->StableIsQuark() ) ||       // Uzhi June 2020
               ( string->DecayIsQuark() && !string->StableIsQuark() )   ) {    // Uzhi June 2020
      //... there is a Diquark on one of cluster ends
      G4int IsParticle;
      if ( string->StableIsQuark() ) {
        IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1; 
      } else {
        IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? +1 : -1;
      }
 
          //G4double ProbSaS   = 1.0 - 2.0 * GetStrangeSuppress();
          //G4double ActualProb = ProbSaS * 1.4;
          //SetStrangenessSuppression((1.0-ActualProb)/2.0);
 
          pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
          //SetStrangenessSuppression((1.0-ProbSaS)/2.0);
          quark = QuarkPair.second;
          LeftHadron=hadronizer->BuildLowSpin(QuarkPair.first, string->GetLeftParton());
          if ( LeftHadron == NULL ) continue;                                      // Uzhi June 2020
          RightHadron = hadronizer->BuildLowSpin(string->GetRightParton(), quark); // Uzhi June 2020
          if ( RightHadron == NULL ) continue;                                     // Uzhi June 2020
        } else {  // Diquark and anti-diquark are on the string ends               // Uzhi June 2020
          //+++++++++++++++++++++++++++++++ Inserted from FTF                      // Uzhi June 2020
          // Uzhi  G4double StringMass = string->Mass();
          if (cClusterInterrupt++ >= ClusterLoopInterrupt) return false;
          G4int LeftQuark1= string->GetLeftParton()->GetPDGEncoding()/1000;
          G4int LeftQuark2=(string->GetLeftParton()->GetPDGEncoding()/100)%10;
          G4int RightQuark1= string->GetRightParton()->GetPDGEncoding()/1000;
          G4int RightQuark2=(string->GetRightParton()->GetPDGEncoding()/100)%10;
          if (G4UniformRand()<0.5) {
            LeftHadron  =hadronizer->Build(FindParticle( LeftQuark1), FindParticle(RightQuark1));
            RightHadron =hadronizer->Build(FindParticle( LeftQuark2), FindParticle(RightQuark2));
          } else {
            LeftHadron  =hadronizer->Build(FindParticle( LeftQuark1), FindParticle(RightQuark2));
            RightHadron =hadronizer->Build(FindParticle( LeftQuark2), FindParticle(RightQuark1));
          }
      if ( (LeftHadron == NULL) || (RightHadron == NULL) ) continue;
          // End of inserting from FTF Uzhi June 2020
        }
        LeftHadronMass  = LeftHadron->GetPDGMass();
        RightHadronMass = RightHadron->GetPDGMass();
        //... repeat procedure, if mass of cluster is too low to produce hadrons
    } while ( ( ResidualMass <= LeftHadronMass + RightHadronMass )
              && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
 
    if ( loopCounter >= maxNumberOfLoops ) {
      return false;
    }
 
    //... compute hadron momenta and energies   
    G4LorentzVector  LeftMom, RightMom;
    G4ThreeVector    Pos;
    Sample4Momentum(&LeftMom , LeftHadron->GetPDGMass() , 
                    &RightMom, RightHadron->GetPDGMass(), ResidualMass);
    LeftMom.boost(ClusterVel);
    RightMom.boost(ClusterVel);
 
    #ifdef debug_QGSMfragmentation
    G4cout<<LeftHadron->GetParticleName()<<" "<<RightHadron->GetParticleName()<<G4endl;
    G4cout<<"Left  Hadrom P M "<<LeftMom<<" "<<LeftMom.mag()<<G4endl;
    G4cout<<"Right Hadrom P M "<<RightMom<<" "<<RightMom.mag()<<G4endl;
    #endif
 
    LeftVector->push_back(new G4KineticTrack(LeftHadron, 0, Pos, LeftMom));
    RightVector->push_back(new G4KineticTrack(RightHadron, 0, Pos, RightMom));
 
    return true;
}

References CLHEP::HepLorentzVector::boost(), G4HadronBuilder::Build(), G4HadronBuilder::BuildLowSpin(), G4VLongitudinalStringDecay::ClusterLoopInterrupt, G4VLongitudinalStringDecay::CreatePartonPair(), G4FragmentingString::DecayIsQuark(), G4VLongitudinalStringDecay::FindParticle(), G4cout, G4endl, G4UniformRand, G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4FragmentingString::GetRightParton(), G4VLongitudinalStringDecay::hadronizer, CLHEP::HepLorentzVector::mag(), G4VLongitudinalStringDecay::MaxMass, Sample4Momentum(), and G4FragmentingString::StableIsQuark().

Referenced by FragmentString().

◆ Splitup()

G4KineticTrack * G4QGSMFragmentation::Splitup	(	G4FragmentingString *	string,
		G4FragmentingString *&	newString
	)

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 304 of file G4QGSMFragmentation.cc.

{
       #ifdef debug_QGSMfragmentation
       G4cout<<G4endl;
       G4cout<<"Start SplitUP (G4VLongitudinalStringDecay) ========================="<<G4endl;
       G4cout<<"String partons: " <<string->GetLeftParton()->GetPDGEncoding()<<" "
                                  <<string->GetRightParton()->GetPDGEncoding()<<" "
             <<"Direction "       <<string->GetDecayDirection()<<G4endl;
       #endif
 
       //... random choice of string end to use for creating the hadron (decay)   
       G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
       if (SideOfDecay < 0)
       {
      string->SetLeftPartonStable();
       } else
       {
          string->SetRightPartonStable();
       }
 
       G4ParticleDefinition *newStringEnd;
       G4ParticleDefinition * HadronDefinition;
       if (string->DecayIsQuark())
       {
      G4double ProbDqADq = GetDiquarkSuppress();
 
      G4int NumberOfpossibleBaryons = 2;
 
      if (string->GetLeftParton()->GetParticleSubType()  != "quark") NumberOfpossibleBaryons++; 
      if (string->GetRightParton()->GetParticleSubType() != "quark") NumberOfpossibleBaryons++;
 
      G4double ActualProb  = ProbDqADq ;
          ActualProb *= (1.0-G4Exp(2.0*(1.0 - string->Mass()/(NumberOfpossibleBaryons*1400.0))));
 
      SetDiquarkSuppression(ActualProb); 
 
          HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
 
      SetDiquarkSuppression(ProbDqADq);
       } else {
          HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
       }      
 
       if ( HadronDefinition == NULL ) return NULL;
 
       #ifdef debug_QGSMfragmentation
       G4cout<<"The parton "<<string->GetDecayParton()->GetPDGEncoding()<<" "
             <<" produces hadron "<<HadronDefinition->GetParticleName()
             <<" and is transformed to "<<newStringEnd->GetPDGEncoding()<<G4endl;
       G4cout<<"The side of the string decay Left/Right (1/-1) "<<SideOfDecay<<G4endl;
       #endif
       // create new String from old, ie. keep Left and Right order, but replace decay
 
       newString=new G4FragmentingString(*string,newStringEnd); // To store possible
                                                                // quark containt of new string
 
       #ifdef debug_QGSMfragmentation
       G4cout<<"An attempt to determine its energy (SplitEandP)"<<G4endl;
       #endif
       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
 
       delete newString; newString=0;
    
       G4KineticTrack * Hadron =0;
       if ( HadronMomentum != 0 ) {
 
           #ifdef debug_QGSMfragmentation                     
           G4cout<<"The attempt was successful"<<G4endl;
           #endif
       G4ThreeVector   Pos;
       Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
 
           newString=new G4FragmentingString(*string,newStringEnd,HadronMomentum);
 
       delete HadronMomentum;
       }
       else
       {
         #ifdef debug_QGSMfragmentation
         G4cout<<"The attempt was not successful !!!"<<G4endl;
         #endif
       }
 
       #ifdef debug_VStringDecay
       G4cout<<"End SplitUP (G4VLongitudinalStringDecay) ====================="<<G4endl;
       #endif
 
       return Hadron;
}

References G4FragmentingString::DecayIsQuark(), DiQuarkSplitup(), G4cout, G4endl, G4Exp(), G4UniformRand, G4FragmentingString::GetDecayParton(), G4VLongitudinalStringDecay::GetDiquarkSuppress(), G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetPDGEncoding(), G4FragmentingString::GetRightParton(), G4FragmentingString::Mass(), G4VLongitudinalStringDecay::QuarkSplitup(), G4VLongitudinalStringDecay::SetDiquarkSuppression(), and SplitEandP().

Referenced by FragmentString().

◆ StopFragmenting()

G4bool G4QGSMFragmentation::StopFragmenting ( const G4FragmentingString * string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 286 of file G4QGSMFragmentation.cc.

{
    SetMinimalStringMass(string);
        if ( MinimalStringMass < 0.0 ) return true;
 
        G4double smass = string->Mass();
    G4double x = (string->IsAFourQuarkString()) ? 0.005*(smass - MinimalStringMass)
      : 0.66e-6*(smass - MinimalStringMass)*(smass + MinimalStringMass);
 
        G4bool res = true;
        if(x > 0.0) {
          res = (x < 200.) ? (G4UniformRand() < G4Exp(-x)) : false;
    }
    return res;
}

References G4Exp(), G4UniformRand, G4VLongitudinalStringDecay::MinimalStringMass, and G4VLongitudinalStringDecay::SetMinimalStringMass().

Referenced by FragmentString().

Field Documentation

◆ aJPs

G4double G4QGSMFragmentation::aJPs

private

Definition at line 85 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2q(), SetFFqq2q(), and SetFFqq2qq().

◆ aksi

G4double G4QGSMFragmentation::aksi

private

Definition at line 99 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation().

◆ ala

G4double G4QGSMFragmentation::ala

private

Definition at line 88 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ alaB

G4double G4QGSMFragmentation::alaB

private

Definition at line 91 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ alaC

G4double G4QGSMFragmentation::alaC

private

Definition at line 90 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ alft

G4double G4QGSMFragmentation::alft

private

Definition at line 100 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2q(), SetFFq2qq(), SetFFqq2q(), and SetFFqq2qq().

◆ an

G4double G4QGSMFragmentation::an

private

Definition at line 87 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2qq(), SetFFqq2q(), and SetFFqq2qq().

◆ aphi

G4double G4QGSMFragmentation::aphi

private

Definition at line 84 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2q(), SetFFqq2q(), and SetFFqq2qq().

◆ arho

G4double G4QGSMFragmentation::arho

private

Definition at line 83 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2q(), SetFFq2qq(), SetFFqq2q(), and SetFFqq2qq().

◆ aUps

G4double G4QGSMFragmentation::aUps

private

Definition at line 86 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), SetFFq2q(), SetFFqq2q(), and SetFFqq2qq().

◆ aXi

G4double G4QGSMFragmentation::aXi

private

Definition at line 92 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ aXiB

G4double G4QGSMFragmentation::aXiB

private

Definition at line 94 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ aXiBB

G4double G4QGSMFragmentation::aXiBB

private

Definition at line 97 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ aXiC

G4double G4QGSMFragmentation::aXiC

private

Definition at line 93 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ aXiCB

G4double G4QGSMFragmentation::aXiCB

private

Definition at line 96 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ aXiCC

G4double G4QGSMFragmentation::aXiCC

private

Definition at line 95 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and SetFFq2qq().

◆ Baryon

G4int G4VLongitudinalStringDecay::Baryon[5][5][5][4]

inherited

Definition at line 236 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ BaryonWeight

G4double G4VLongitudinalStringDecay::BaryonWeight[5][5][5][4]

inherited

Definition at line 237 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ ClusterLoopInterrupt

G4int G4VLongitudinalStringDecay::ClusterLoopInterrupt

protectedinherited

Definition at line 192 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_belowThreshold_lastSplitting(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetClusterLoopInterrupt(), G4VLongitudinalStringDecay::PossibleHadronMass(), and SplitLast().

◆ DecayQuark

G4int G4VLongitudinalStringDecay::DecayQuark

inherited

Definition at line 241 of file G4VLongitudinalStringDecay.hh.

Referenced by DiQuarkSplitup(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), GetLightConeZ(), and G4VLongitudinalStringDecay::QuarkSplitup().

◆ DiquarkBreakProb

G4double G4VLongitudinalStringDecay::DiquarkBreakProb

protectedinherited

Definition at line 189 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::DiQuarkSplitup(), DiQuarkSplitup(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetDiquarkBreakProb(), and G4VLongitudinalStringDecay::SetDiquarkBreakProbability().

◆ DiquarkSuppress

G4double G4VLongitudinalStringDecay::DiquarkSuppress

protectedinherited

Definition at line 188 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::CreatePartonPair(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetDiquarkSuppress(), and G4VLongitudinalStringDecay::SetDiquarkSuppression().

◆ epCheckLevels

std::pair<G4double, G4double> G4HadronicInteraction::epCheckLevels

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetEnergyMomentumCheckLevels(), and G4HadronicInteraction::SetEnergyMomentumCheckLevels().

◆ FFq2q

G4double G4QGSMFragmentation::FFq2q[5][5][2]

private

Definition at line 102 of file G4QGSMFragmentation.hh.

Referenced by GetLightConeZ(), and SetFFq2q().

◆ FFq2qq

G4double G4QGSMFragmentation::FFq2qq[5][15][2]

private

Definition at line 103 of file G4QGSMFragmentation.hh.

Referenced by GetLightConeZ(), and SetFFq2qq().

◆ FFqq2q

G4double G4QGSMFragmentation::FFqq2q[15][5][2]

private

Definition at line 104 of file G4QGSMFragmentation.hh.

Referenced by GetLightConeZ(), and SetFFqq2q().

◆ FFqq2qq

G4double G4QGSMFragmentation::FFqq2qq[15][5][2]

private

Definition at line 105 of file G4QGSMFragmentation.hh.

Referenced by GetLightConeZ(), and SetFFqq2qq().

◆ FS_LeftHadron

G4ParticleDefinition* G4VLongitudinalStringDecay::FS_LeftHadron[350]

inherited

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), G4VLongitudinalStringDecay::SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ FS_RightHadron

G4ParticleDefinition * G4VLongitudinalStringDecay::FS_RightHadron[350]

inherited

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), G4VLongitudinalStringDecay::SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ FS_Weight

G4double G4VLongitudinalStringDecay::FS_Weight[350]

inherited

Definition at line 252 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), G4LundStringFragmentation::SampleState(), G4VLongitudinalStringDecay::SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ hadronizer

G4HadronBuilder* G4VLongitudinalStringDecay::hadronizer

protectedinherited

Definition at line 194 of file G4VLongitudinalStringDecay.hh.

◆ IndexDiQ

G4int G4QGSMFragmentation::IndexDiQ[5][5]

private

Definition at line 113 of file G4QGSMFragmentation.hh.

Referenced by G4QGSMFragmentation(), and GetLightConeZ().

◆ isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::Block(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4HadronicInteraction::IsBlocked().

◆ Kappa

G4double G4VLongitudinalStringDecay::Kappa

protectedinherited

Definition at line 213 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetStringTensionParameter(), and G4VLongitudinalStringDecay::SetStringTensionParameter().

◆ Mass_of_b_quark

G4double G4VLongitudinalStringDecay::Mass_of_b_quark

inherited

Definition at line 222 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

◆ Mass_of_c_quark

G4double G4VLongitudinalStringDecay::Mass_of_c_quark

inherited

Definition at line 221 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

◆ Mass_of_light_quark

G4double G4VLongitudinalStringDecay::Mass_of_light_quark

inherited

Definition at line 219 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

◆ Mass_of_s_quark

G4double G4VLongitudinalStringDecay::Mass_of_s_quark

inherited

Definition at line 220 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

◆ Mass_of_string_junction

G4double G4VLongitudinalStringDecay::Mass_of_string_junction

inherited

Definition at line 223 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

◆ MassCut

G4double G4VLongitudinalStringDecay::MassCut

protectedinherited

Definition at line 186 of file G4VLongitudinalStringDecay.hh.

Referenced by G4QGSMFragmentation(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetMassCut(), IsItFragmentable(), G4VLongitudinalStringDecay::ProduceOneHadron(), and G4VLongitudinalStringDecay::SetMassCut().

◆ MaxMass

G4double G4VLongitudinalStringDecay::MaxMass

protectedinherited

Definition at line 209 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::PossibleHadronMass(), G4VLongitudinalStringDecay::SetMinimalStringMass(), G4VLongitudinalStringDecay::SetMinMasses(), and SplitLast().

◆ Meson

G4int G4VLongitudinalStringDecay::Meson[5][5][7]

inherited

Definition at line 233 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ MesonWeight

G4double G4VLongitudinalStringDecay::MesonWeight[5][5][7]

inherited

Definition at line 234 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ MinimalStringMass

G4double G4VLongitudinalStringDecay::MinimalStringMass

inherited

Definition at line 229 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::IsItFragmentable(), IsItFragmentable(), G4VLongitudinalStringDecay::SetMinimalStringMass(), G4VLongitudinalStringDecay::SetMinMasses(), G4LundStringFragmentation::SplitEandP(), SplitEandP(), G4LundStringFragmentation::SplitLast(), G4LundStringFragmentation::StopFragmenting(), and StopFragmenting().

◆ MinimalStringMass2

G4double G4VLongitudinalStringDecay::MinimalStringMass2

inherited

Definition at line 230 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinimalStringMass2(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ minMassQDiQStr

G4double G4VLongitudinalStringDecay::minMassQDiQStr[5][5][5]

inherited

Definition at line 226 of file G4VLongitudinalStringDecay.hh.

Referenced by G4FTFParameters::GetMinMass(), G4VLongitudinalStringDecay::SetMinimalStringMass(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ minMassQQbarStr

G4double G4VLongitudinalStringDecay::minMassQQbarStr[5][5]

inherited

Definition at line 225 of file G4VLongitudinalStringDecay.hh.

Referenced by G4FTFParameters::GetMinMass(), G4VLongitudinalStringDecay::SetMinimalStringMass(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ NewParticles

std::vector<G4ParticleDefinition *> G4VLongitudinalStringDecay::NewParticles

protectedinherited

Definition at line 215 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::FindParticle().

◆ NewQuark

G4int G4VLongitudinalStringDecay::NewQuark

inherited

Definition at line 242 of file G4VLongitudinalStringDecay.hh.

Referenced by DiQuarkSplitup(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), GetLightConeZ(), and G4VLongitudinalStringDecay::QuarkSplitup().

◆ NumberOf_FS

G4int G4VLongitudinalStringDecay::NumberOf_FS

inherited

Definition at line 253 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), G4LundStringFragmentation::SampleState(), G4VLongitudinalStringDecay::SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ PastInitPhase

G4bool G4VLongitudinalStringDecay::PastInitPhase

protectedinherited

Definition at line 211 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::FragmentString(), FragmentString(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::SetDiquarkBreakProbability(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSigmaTransverseMomentum(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ Prob_QQbar

G4double G4VLongitudinalStringDecay::Prob_QQbar[5]

inherited

Definition at line 239 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting(), G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), G4LundStringFragmentation::Quark_Diquark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ ProbBBbar

G4double G4VLongitudinalStringDecay::ProbBBbar

protectedinherited

Definition at line 204 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::GetProbBBbar(), G4VLongitudinalStringDecay::SampleQuarkFlavor(), G4VLongitudinalStringDecay::SetProbBBbar(), and G4VLongitudinalStringDecay::SetProbCCbar().

◆ ProbCB

G4double G4VLongitudinalStringDecay::ProbCB

protectedinherited

Definition at line 207 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SampleQuarkFlavor(), G4VLongitudinalStringDecay::SetProbBBbar(), and G4VLongitudinalStringDecay::SetProbCCbar().

◆ ProbCCbar

G4double G4VLongitudinalStringDecay::ProbCCbar

protectedinherited

Definition at line 201 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::GetProbCCbar(), G4VLongitudinalStringDecay::SampleQuarkFlavor(), G4VLongitudinalStringDecay::SetProbBBbar(), and G4VLongitudinalStringDecay::SetProbCCbar().

◆ ProbEta_b

G4double G4VLongitudinalStringDecay::ProbEta_b

protectedinherited

Definition at line 205 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetProbEta_b(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetProbEta_b(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ ProbEta_c

G4double G4VLongitudinalStringDecay::ProbEta_c

protectedinherited

Definition at line 202 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetProbEta_c(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetProbEta_c(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ pspin_barion

G4double G4VLongitudinalStringDecay::pspin_barion

protectedinherited

Definition at line 197 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ pspin_meson

G4double G4VLongitudinalStringDecay::pspin_meson

protectedinherited

Definition at line 196 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ Qcharge

G4int G4VLongitudinalStringDecay::Qcharge[5]

inherited

Definition at line 232 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), and G4VLongitudinalStringDecay::SetMinMasses().

◆ recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold

privateinherited

Definition at line 194 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetRecoilEnergyThreshold(), and G4HadronicInteraction::SetRecoilEnergyThreshold().

◆ registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry

privateinherited

Definition at line 192 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::G4HadronicInteraction(), and G4HadronicInteraction::~G4HadronicInteraction().

◆ scalarMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::scalarMesonMix

protectedinherited

Definition at line 199 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ SigmaQT

G4double G4VLongitudinalStringDecay::SigmaQT

protectedinherited

Definition at line 187 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4LundStringFragmentation::Sample4Momentum(), G4VLongitudinalStringDecay::SampleQuarkPt(), and G4VLongitudinalStringDecay::SetSigmaTransverseMomentum().

◆ StrangeSuppress

G4double G4VLongitudinalStringDecay::StrangeSuppress

protectedinherited

Definition at line 190 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::DiQuarkSplitup(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::GetStrangeSuppress(), G4VLongitudinalStringDecay::SampleQuarkFlavor(), and G4VLongitudinalStringDecay::SetStrangenessSuppression().

◆ StringLoopInterrupt

G4int G4VLongitudinalStringDecay::StringLoopInterrupt

protectedinherited

Definition at line 191 of file G4VLongitudinalStringDecay.hh.

Referenced by FragmentString(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4LundStringFragmentation::Loop_toFragmentString(), G4LundStringFragmentation::SplitEandP(), and SplitEandP().

◆ theBlockedList

std::vector<const G4Material *> G4HadronicInteraction::theBlockedList

privateinherited

Definition at line 204 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

◆ theBlockedListElements

std::vector<const G4Element *> G4HadronicInteraction::theBlockedListElements

privateinherited

Definition at line 205 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

◆ theMaxEnergy

G4double G4HadronicInteraction::theMaxEnergy

protectedinherited

Definition at line 186 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronicInteraction::G4HadronicInteraction(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMaxEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMaxEnergyList

privateinherited

Definition at line 201 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMaxEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMaxEnergyListElements

privateinherited

Definition at line 203 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMinEnergy

G4double G4HadronicInteraction::theMinEnergy

protectedinherited

Definition at line 185 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theMinEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMinEnergyList

privateinherited

Definition at line 200 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theMinEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMinEnergyListElements

privateinherited

Definition at line 202 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theModelName

G4String G4HadronicInteraction::theModelName

privateinherited

Definition at line 196 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetModelName(), and G4HadronicInteraction::SetModelName().

◆ theParticleChange

G4HadFinalState G4HadronicInteraction::theParticleChange

protectedinherited

Definition at line 172 of file G4HadronicInteraction.hh.

◆ vectorMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::vectorMesonMix

protectedinherited

Definition at line 198 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), and G4VLongitudinalStringDecay::SetVectorMesonProbability().

◆ verboseLevel

G4int G4HadronicInteraction::verboseLevel

protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

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

source/processes/hadronic/models/parton_string/hadronization/include/G4QGSMFragmentation.hh
source/processes/hadronic/models/parton_string/hadronization/src/G4QGSMFragmentation.cc

Public Member Functions

Data Fields

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Pcreate

◆ pDefPair

Constructor & Destructor Documentation

◆ G4QGSMFragmentation() [1/2]

◆ ~G4QGSMFragmentation()

◆ G4QGSMFragmentation() [2/2]

Member Function Documentation

◆ ActivateFor() [1/2]

◆ ActivateFor() [2/2]

◆ AddNewParticles()

◆ ApplyYourself()

◆ Block()

◆ BuildPhysicsTable()

◆ CalculateHadronTimePosition()

◆ ConstructParticle()

◆ CopyExcited()

◆ CreateHadron()

◆ CreatePartonPair()

◆ DeActivateFor() [1/2]

◆ DeActivateFor() [2/2]

◆ DiQuarkSplitup()

◆ EraseNewParticles()

◆ FindParticle()

◆ FragmentString()

◆ GetClusterLoopInterrupt()

◆ GetDiquarkBreakProb()

◆ GetDiquarkSuppress()

◆ GetEnergyMomentumCheckLevels()

◆ GetFatalEnergyCheckLevels()

◆ GetLightConeZ()

◆ GetMassCut()

◆ GetMaxEnergy() [1/2]

◆ GetMaxEnergy() [2/2]

◆ GetMinEnergy() [1/2]

◆ GetMinEnergy() [2/2]

◆ GetModelName()

◆ GetProbBBbar()

◆ GetProbCCbar()

◆ GetProbEta_b()

◆ GetProbEta_c()

◆ GetRecoilEnergyThreshold()

◆ GetStrangeSuppress()

◆ GetStringTensionParameter()

◆ GetVerboseLevel()

◆ InitialiseModel()

◆ IsApplicable()

◆ IsBlocked() [1/3]

◆ IsBlocked() [2/3]

◆ IsBlocked() [3/3]

◆ IsItFragmentable()

◆ ModelDescription()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator=()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ PossibleHadronMass()

◆ ProduceOneHadron()

◆ QuarkSplitup()

◆ Sample4Momentum()

◆ SampleInvariantT()

◆ SampleQuarkFlavor()

◆ SampleQuarkPt()

◆ SetDiquarkBreakProbability()

◆ SetDiquarkSuppression()

◆ SetEnergyMomentumCheckLevels()

◆ SetFFq2q()

◆ SetFFq2qq()

◆ SetFFqq2q()

◆ SetFFqq2qq()

◆ SetMassCut()