#include <G4VLongitudinalStringDecay.hh>

Inheritance diagram for G4VLongitudinalStringDecay:

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)=0

	G4VLongitudinalStringDecay (const G4String &name="StringDecay")

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)

virtual	~G4VLongitudinalStringDecay ()

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)

virtual G4ParticleDefinition *	DiQuarkSplitup (G4ParticleDefinition decay, G4ParticleDefinition &created)=0

G4ParticleDefinition *	FindParticle (G4int Encoding)

G4int	GetClusterLoopInterrupt ()

G4double	GetDiquarkBreakProb ()

G4double	GetDiquarkSuppress ()

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

G4double	GetMassCut ()

G4double	GetProbBBbar ()

G4double	GetProbCCbar ()

G4double	GetProbEta_b ()

G4double	GetProbEta_c ()

G4double	GetStrangeSuppress ()

G4double	GetStringTensionParameter ()

G4bool	IsBlocked () const

virtual G4bool	IsItFragmentable (const G4FragmentingString *const string)=0

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	Sample4Momentum (G4LorentzVector Mom, G4double Mass, G4LorentzVector AntiMom, G4double AntiMass, G4double InitialMass)=0

virtual void	SetMassCut (G4double aValue)

void	SetModelName (const G4String &nam)

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

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

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

virtual G4bool	StopFragmenting (const G4FragmentingString *const string)=0

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
	G4VLongitudinalStringDecay (const G4VLongitudinalStringDecay &right)

G4bool	operator!= (const G4VLongitudinalStringDecay &right) const

const G4VLongitudinalStringDecay &	operator= (const G4VLongitudinalStringDecay &right)

G4bool	operator== (const G4VLongitudinalStringDecay &right) const

Private Attributes
std::pair< G4double, G4double >	epCheckLevels

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 46 of file G4VLongitudinalStringDecay.hh.

Member Typedef Documentation

◆ Pcreate

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

protected

Definition at line 86 of file G4VLongitudinalStringDecay.hh.

◆ pDefPair

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

protected

Definition at line 83 of file G4VLongitudinalStringDecay.hh.

Constructor & Destructor Documentation

◆ G4VLongitudinalStringDecay() [1/2]

G4VLongitudinalStringDecay::G4VLongitudinalStringDecay ( const G4String & name = "StringDecay" )

Definition at line 67 of file G4VLongitudinalStringDecay.cc.

  : G4HadronicInteraction(name), ProbCCbar(0.0), ProbBBbar(0.0)
{
   MassCut = 210.0*MeV;   // Mpi + Delta
 
   StringLoopInterrupt  = 1000;
   ClusterLoopInterrupt =  500;
 
   // Changable Parameters below.
   SigmaQT = 0.5 * GeV;
   
   StrangeSuppress  = 0.44;    // =0.27/2.27 suppression of strange quark pair production, ie. u:d:s=1:1:0.27
   DiquarkSuppress  = 0.07;    // Probability of qq-qqbar pair production
   DiquarkBreakProb = 0.1;     // Probability of (qq)->h+(qq)'
   
   //... pspin_meson is probability to create pseudo-scalar meson 
   pspin_meson = 0.5;
 
   //... pspin_barion is probability to create 1/2 barion 
   pspin_barion = 0.5;
 
   //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
   vectorMesonMix.resize(6);
   vectorMesonMix[0] = 0.0;
   vectorMesonMix[1] = 0.375;
   vectorMesonMix[2] = 0.0;
   vectorMesonMix[3] = 0.375;
   vectorMesonMix[4] = 1.0;
   vectorMesonMix[5] = 1.0;
 
   //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
   scalarMesonMix.resize(6);
   scalarMesonMix[0] = 0.5;
   scalarMesonMix[1] = 0.25;
   scalarMesonMix[2] = 0.5;
   scalarMesonMix[3] = 0.25;
   scalarMesonMix[4] = 1.0;
   scalarMesonMix[5] = 0.5;
 
   SetProbCCbar(0.0);  // Probability of CCbar pair creation
   SetProbEta_c(0.1);  // Mixing of Eta_c and J/Psi
   SetProbBBbar(0.0);  // Probability of BBbar pair creation
   SetProbEta_b(0.0);  // Mixing of Eta_b and Upsilon_b
 
   // Parameters may be changed until the first fragmentation starts
   PastInitPhase=false;
   hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
                    scalarMesonMix,vectorMesonMix,
                                    ProbEta_c, ProbEta_b);
 
   MaxMass=-350.0*GeV;  // If there will be a particle with mass larger than Higgs the value must be changed.
 
   SetMinMasses();  // Re-calculation of minimal mass of strings and weights of particles in 2-part. decays
 
   Kappa = 1.0 * GeV/fermi;
   DecayQuark = NewQuark = 0;
}

References ClusterLoopInterrupt, DecayQuark, DiquarkBreakProb, DiquarkSuppress, fermi, GeV, hadronizer, Kappa, MassCut, MaxMass, MeV, NewQuark, PastInitPhase, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, scalarMesonMix, SetMinMasses(), SetProbBBbar(), SetProbCCbar(), SetProbEta_b(), SetProbEta_c(), SigmaQT, StrangeSuppress, StringLoopInterrupt, and vectorMesonMix.

◆ ~G4VLongitudinalStringDecay()

G4VLongitudinalStringDecay::~G4VLongitudinalStringDecay ( )

virtual

Definition at line 125 of file G4VLongitudinalStringDecay.cc.

{
   delete hadronizer;
}

References hadronizer.

◆ G4VLongitudinalStringDecay() [2/2]

G4VLongitudinalStringDecay::G4VLongitudinalStringDecay ( const G4VLongitudinalStringDecay & 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 ( )

◆ ApplyYourself()

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

finalvirtual

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
	)

protected

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 GetStringTensionParameter().

Referenced by G4QGSMFragmentation::FragmentString().

◆ ConstructParticle()

void G4VLongitudinalStringDecay::ConstructParticle ( )

protected

◆ CopyExcited()

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

protected

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 G4QGSMFragmentation::FragmentString().

◆ CreateHadron()

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

protected

◆ CreatePartonPair()

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

protected

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 DiquarkSuppress, FindParticle(), G4cout, G4endl, G4UniformRand, G4INCL::Math::max(), G4INCL::Math::min(), and SampleQuarkFlavor().

Referenced by G4LundStringFragmentation::DiQuarkSplitup(), G4QGSMFragmentation::DiQuarkSplitup(), QuarkSplitup(), and G4QGSMFragmentation::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()

virtual G4ParticleDefinition * G4VLongitudinalStringDecay::DiQuarkSplitup	(	G4ParticleDefinition *	decay,
		G4ParticleDefinition *&	created
	)

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ EraseNewParticles()

void G4VLongitudinalStringDecay::EraseNewParticles ( )

◆ FindParticle()

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int Encoding )

protected

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 NewParticles.

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

◆ FragmentString()

virtual G4KineticTrackVector * G4VLongitudinalStringDecay::FragmentString ( const G4ExcitedString & theString )

pure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Referenced by G4ExcitedStringDecay::FragmentString().

◆ GetClusterLoopInterrupt()

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt ( )

inlineprotected

Definition at line 176 of file G4VLongitudinalStringDecay.hh.

176{return ClusterLoopInterrupt;};

References ClusterLoopInterrupt.

◆ GetDiquarkBreakProb()

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb ( )

inlineprotected

Definition at line 174 of file G4VLongitudinalStringDecay.hh.

174{return DiquarkBreakProb;};

References DiquarkBreakProb.

◆ GetDiquarkSuppress()

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress ( )

inlineprotected

Definition at line 173 of file G4VLongitudinalStringDecay.hh.

173{return DiquarkSuppress;};

References DiquarkSuppress.

Referenced by G4LundStringFragmentation::Splitup(), and G4QGSMFragmentation::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()

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

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ GetMassCut()

G4double G4VLongitudinalStringDecay::GetMassCut ( )

protected

Definition at line 140 of file G4VLongitudinalStringDecay.cc.

140{ return MassCut; }

References 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 ( )

inlineprotected

Definition at line 180 of file G4VLongitudinalStringDecay.hh.

180{return ProbBBbar;};

References ProbBBbar.

◆ GetProbCCbar()

G4double G4VLongitudinalStringDecay::GetProbCCbar ( )

inlineprotected

Definition at line 178 of file G4VLongitudinalStringDecay.hh.

178{return ProbCCbar;};

References ProbCCbar.

◆ GetProbEta_b()

G4double G4VLongitudinalStringDecay::GetProbEta_b ( )

inlineprotected

Definition at line 181 of file G4VLongitudinalStringDecay.hh.

181{return ProbEta_b;};

References ProbEta_b.

◆ GetProbEta_c()

G4double G4VLongitudinalStringDecay::GetProbEta_c ( )

inlineprotected

Definition at line 179 of file G4VLongitudinalStringDecay.hh.

179{return ProbEta_c;};

References 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 ( )

inlineprotected

Definition at line 175 of file G4VLongitudinalStringDecay.hh.

175{return StrangeSuppress;};

References StrangeSuppress.

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

◆ GetStringTensionParameter()

G4double G4VLongitudinalStringDecay::GetStringTensionParameter ( )

inlineprotected

Definition at line 183 of file G4VLongitudinalStringDecay.hh.

183{return Kappa;};

References Kappa.

Referenced by 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()

virtual G4bool G4VLongitudinalStringDecay::IsItFragmentable ( const G4FragmentingString *const string )

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ 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 G4VLongitudinalStringDecay::operator!= ( const G4VLongitudinalStringDecay & right ) const

private

◆ operator=()

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

private

◆ operator==() [1/2]

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

deleteinherited

◆ operator==() [2/2]

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

private

◆ PossibleHadronMass()

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

protected

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(), ClusterLoopInterrupt, FindParticle(), G4cout, G4endl, G4UniformRand, G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), hadronizer, G4FragmentingString::IsAFourQuarkString(), and MaxMass.

Referenced by ProduceOneHadron().

◆ ProduceOneHadron()

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

protected

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(), MassCut, PossibleHadronMass(), Sample4Momentum(), SetMinimalStringMass(), and sqr().

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

◆ QuarkSplitup()

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

protectedvirtual

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(), CreatePartonPair(), G4INCL::ClusterDecay::decay(), DecayQuark, G4cout, G4endl, G4ParticleDefinition::GetPDGEncoding(), hadronizer, and NewQuark.

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

◆ Sample4Momentum()

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

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Referenced by ProduceOneHadron().

◆ 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 )

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, ProbBBbar, ProbCB, ProbCCbar, and StrangeSuppress.

Referenced by CreatePartonPair().

◆ SampleQuarkPt()

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

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 SigmaQT.

Referenced by G4LundStringFragmentation::Sample4Momentum().

◆ SetDiquarkBreakProbability()

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability ( G4double aValue )

Definition at line 488 of file G4VLongitudinalStringDecay.cc.

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

References DiquarkBreakProb, and PastInitPhase.

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

◆ SetDiquarkSuppression()

void G4VLongitudinalStringDecay::SetDiquarkSuppression ( G4double aValue )

Definition at line 481 of file G4VLongitudinalStringDecay.cc.

{
   DiquarkSuppress = aValue;
}

References DiquarkSuppress.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation::G4QGSMFragmentation(), G4LundStringFragmentation::Splitup(), and G4QGSMFragmentation::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().

◆ SetMassCut()

void G4VLongitudinalStringDecay::SetMassCut ( G4double aValue )

protectedvirtual

Definition at line 139 of file G4VLongitudinalStringDecay.cc.

139{ MassCut=aValue; }

References 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 )

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(), MaxMass, G4INCL::Math::min(), MinimalStringMass, minMassQDiQStr, minMassQQbarStr, and SetMinimalStringMass2().

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

◆ SetMinimalStringMass2()

void G4VLongitudinalStringDecay::SetMinimalStringMass2 ( const G4double aValue )

Definition at line 1061 of file G4VLongitudinalStringDecay.cc.

{
    MinimalStringMass2=aValue * aValue;
}

References MinimalStringMass2.

Referenced by SetMinimalStringMass().

◆ SetMinMasses()

void G4VLongitudinalStringDecay::SetMinMasses ( )

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;
}

References Baryon, BaryonWeight, FindParticle(), G4ParticleTable::FindParticle(), FS_LeftHadron, FS_RightHadron, FS_Weight, G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), Mass_of_b_quark, Mass_of_c_quark, Mass_of_light_quark, Mass_of_s_quark, Mass_of_string_junction, G4INCL::Math::max(), MaxMass, Meson, MesonWeight, MeV, G4INCL::Math::min(), MinimalStringMass, MinimalStringMass2, minMassQDiQStr, minMassQQbarStr, NumberOf_FS, Prob_QQbar, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, Qcharge, scalarMesonMix, and vectorMesonMix.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation(), G4QGSMFragmentation::G4QGSMFragmentation(), and 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 )

Definition at line 587 of file G4VLongitudinalStringDecay.cc.

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

References ProbBBbar, ProbCB, and ProbCCbar.

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

◆ SetProbCCbar()

void G4VLongitudinalStringDecay::SetProbCCbar ( G4double aValue )

Definition at line 572 of file G4VLongitudinalStringDecay.cc.

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

References ProbBBbar, ProbCB, and ProbCCbar.

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

◆ SetProbEta_b()

void G4VLongitudinalStringDecay::SetProbEta_b ( G4double aValue )

Definition at line 595 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_b = aValue;
}

References ProbEta_b.

Referenced by G4VLongitudinalStringDecay().

◆ SetProbEta_c()

void G4VLongitudinalStringDecay::SetProbEta_c ( G4double aValue )

Definition at line 580 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_c = aValue;
}

References ProbEta_c.

Referenced by 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 )

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 hadronizer, PastInitPhase, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

◆ SetSigmaTransverseMomentum()

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum ( G4double aQT )

Definition at line 462 of file G4VLongitudinalStringDecay.cc.

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

References PastInitPhase, and SigmaQT.

◆ SetSpinThreeHalfBarionProbability()

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability ( G4double aValue )

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 hadronizer, PastInitPhase, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

◆ SetStrangenessSuppression()

void G4VLongitudinalStringDecay::SetStrangenessSuppression ( G4double aValue )

Definition at line 474 of file G4VLongitudinalStringDecay.cc.

{
   StrangeSuppress = aValue;
}

References StrangeSuppress.

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

◆ SetStringTensionParameter()

void G4VLongitudinalStringDecay::SetStringTensionParameter ( G4double aValue )

Definition at line 602 of file G4VLongitudinalStringDecay.cc.

{
   Kappa = aValue * GeV/fermi;
}   

References fermi, GeV, and Kappa.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

◆ SetVectorMesonMixings()

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

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 hadronizer, PastInitPhase, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

◆ SetVectorMesonProbability()

void G4VLongitudinalStringDecay::SetVectorMesonProbability ( G4double aValue )

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 hadronizer, PastInitPhase, ProbEta_b, ProbEta_c, pspin_barion, pspin_meson, scalarMesonMix, and 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()

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

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ SplitLast()

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

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ Splitup()

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

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

◆ StopFragmenting()

virtual G4bool G4VLongitudinalStringDecay::StopFragmenting ( const G4FragmentingString *const string )

protectedpure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Field Documentation

◆ Baryon

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

Definition at line 236 of file G4VLongitudinalStringDecay.hh.

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

◆ BaryonWeight

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

Definition at line 237 of file G4VLongitudinalStringDecay.hh.

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

◆ ClusterLoopInterrupt

G4int G4VLongitudinalStringDecay::ClusterLoopInterrupt

protected

Definition at line 192 of file G4VLongitudinalStringDecay.hh.

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

◆ DecayQuark

G4int G4VLongitudinalStringDecay::DecayQuark

Definition at line 241 of file G4VLongitudinalStringDecay.hh.

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

◆ DiquarkBreakProb

G4double G4VLongitudinalStringDecay::DiquarkBreakProb

protected

Definition at line 189 of file G4VLongitudinalStringDecay.hh.

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

◆ DiquarkSuppress

G4double G4VLongitudinalStringDecay::DiquarkSuppress

protected

Definition at line 188 of file G4VLongitudinalStringDecay.hh.

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

◆ epCheckLevels

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

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

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

◆ FS_LeftHadron

G4ParticleDefinition* G4VLongitudinalStringDecay::FS_LeftHadron[350]

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

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

◆ FS_RightHadron

G4ParticleDefinition * G4VLongitudinalStringDecay::FS_RightHadron[350]

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

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

◆ FS_Weight

G4double G4VLongitudinalStringDecay::FS_Weight[350]

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(), SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ hadronizer

G4HadronBuilder* G4VLongitudinalStringDecay::hadronizer

protected

Definition at line 194 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Diquark_AntiDiquark_belowThreshold_lastSplitting(), G4LundStringFragmentation::DiQuarkSplitup(), G4QGSMFragmentation::DiQuarkSplitup(), G4VLongitudinalStringDecay(), PossibleHadronMass(), QuarkSplitup(), SetScalarMesonMixings(), SetSpinThreeHalfBarionProbability(), SetVectorMesonMixings(), SetVectorMesonProbability(), G4QGSMFragmentation::SplitLast(), and ~G4VLongitudinalStringDecay().

◆ 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

protected

Definition at line 213 of file G4VLongitudinalStringDecay.hh.

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

◆ Mass_of_b_quark

G4double G4VLongitudinalStringDecay::Mass_of_b_quark

Definition at line 222 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinMasses().

◆ Mass_of_c_quark

G4double G4VLongitudinalStringDecay::Mass_of_c_quark

Definition at line 221 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinMasses().

◆ Mass_of_light_quark

G4double G4VLongitudinalStringDecay::Mass_of_light_quark

Definition at line 219 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinMasses().

◆ Mass_of_s_quark

G4double G4VLongitudinalStringDecay::Mass_of_s_quark

Definition at line 220 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinMasses().

◆ Mass_of_string_junction

G4double G4VLongitudinalStringDecay::Mass_of_string_junction

Definition at line 223 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinMasses().

◆ MassCut

G4double G4VLongitudinalStringDecay::MassCut

protected

Definition at line 186 of file G4VLongitudinalStringDecay.hh.

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

◆ MaxMass

G4double G4VLongitudinalStringDecay::MaxMass

protected

Definition at line 209 of file G4VLongitudinalStringDecay.hh.

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

◆ Meson

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

Definition at line 233 of file G4VLongitudinalStringDecay.hh.

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

◆ MesonWeight

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

Definition at line 234 of file G4VLongitudinalStringDecay.hh.

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

◆ MinimalStringMass

G4double G4VLongitudinalStringDecay::MinimalStringMass

Definition at line 229 of file G4VLongitudinalStringDecay.hh.

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

◆ MinimalStringMass2

G4double G4VLongitudinalStringDecay::MinimalStringMass2

Definition at line 230 of file G4VLongitudinalStringDecay.hh.

Referenced by SetMinimalStringMass2(), and SetMinMasses().

◆ minMassQDiQStr

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

Definition at line 226 of file G4VLongitudinalStringDecay.hh.

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

◆ minMassQQbarStr

G4double G4VLongitudinalStringDecay::minMassQQbarStr[5][5]

Definition at line 225 of file G4VLongitudinalStringDecay.hh.

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

◆ NewParticles

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

protected

Definition at line 215 of file G4VLongitudinalStringDecay.hh.

Referenced by FindParticle().

◆ NewQuark

G4int G4VLongitudinalStringDecay::NewQuark

Definition at line 242 of file G4VLongitudinalStringDecay.hh.

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

◆ NumberOf_FS

G4int G4VLongitudinalStringDecay::NumberOf_FS

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(), SetMinMasses(), and G4LundStringFragmentation::SplitLast().

◆ PastInitPhase

G4bool G4VLongitudinalStringDecay::PastInitPhase

protected

Definition at line 211 of file G4VLongitudinalStringDecay.hh.

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

◆ Prob_QQbar

G4double G4VLongitudinalStringDecay::Prob_QQbar[5]

Definition at line 239 of file G4VLongitudinalStringDecay.hh.

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

◆ ProbBBbar

G4double G4VLongitudinalStringDecay::ProbBBbar

protected

Definition at line 204 of file G4VLongitudinalStringDecay.hh.

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

◆ ProbCB

G4double G4VLongitudinalStringDecay::ProbCB

protected

Definition at line 207 of file G4VLongitudinalStringDecay.hh.

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

◆ ProbCCbar

G4double G4VLongitudinalStringDecay::ProbCCbar

protected

Definition at line 201 of file G4VLongitudinalStringDecay.hh.

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

◆ ProbEta_b

G4double G4VLongitudinalStringDecay::ProbEta_b

protected

Definition at line 205 of file G4VLongitudinalStringDecay.hh.

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

◆ ProbEta_c

G4double G4VLongitudinalStringDecay::ProbEta_c

protected

Definition at line 202 of file G4VLongitudinalStringDecay.hh.

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

◆ pspin_barion

G4double G4VLongitudinalStringDecay::pspin_barion

protected

Definition at line 197 of file G4VLongitudinalStringDecay.hh.

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

◆ pspin_meson

G4double G4VLongitudinalStringDecay::pspin_meson

protected

Definition at line 196 of file G4VLongitudinalStringDecay.hh.

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

◆ Qcharge

G4int G4VLongitudinalStringDecay::Qcharge[5]

Definition at line 232 of file G4VLongitudinalStringDecay.hh.

Referenced by G4LundStringFragmentation::Quark_AntiQuark_lastSplitting(), and 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

protected

Definition at line 199 of file G4VLongitudinalStringDecay.hh.

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

◆ SigmaQT

G4double G4VLongitudinalStringDecay::SigmaQT

protected

Definition at line 187 of file G4VLongitudinalStringDecay.hh.

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

◆ StrangeSuppress

G4double G4VLongitudinalStringDecay::StrangeSuppress

protected

Definition at line 190 of file G4VLongitudinalStringDecay.hh.

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

◆ StringLoopInterrupt

G4int G4VLongitudinalStringDecay::StringLoopInterrupt

protected

Definition at line 191 of file G4VLongitudinalStringDecay.hh.

Referenced by G4QGSMFragmentation::FragmentString(), G4VLongitudinalStringDecay(), G4LundStringFragmentation::Loop_toFragmentString(), G4LundStringFragmentation::SplitEandP(), and G4QGSMFragmentation::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

protected

Definition at line 198 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), SetMinMasses(), SetScalarMesonMixings(), SetSpinThreeHalfBarionProbability(), SetVectorMesonMixings(), and 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/G4VLongitudinalStringDecay.hh
source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.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

◆ G4VLongitudinalStringDecay() [1/2]

◆ ~G4VLongitudinalStringDecay()

◆ G4VLongitudinalStringDecay() [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()

◆ SetMassCut()

◆ SetMaxEnergy() [1/3]

◆ SetMaxEnergy() [2/3]

◆ SetMaxEnergy() [3/3]

◆ SetMinEnergy() [1/3]