G4LundStringFragmentation Class Reference

#include <G4LundStringFragmentation.hh>

Inheritance diagram for G4LundStringFragmentation:

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)
	G4LundStringFragmentation ()
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	~G4LundStringFragmentation ()

Data Fields
G4int	Baryon [5][5][5][4]
G4double	BaryonWeight [5][5][5][4]
G4int	DecayQuark
G4ParticleDefinition *	FS_LeftHadron [350]
G4ParticleDefinition *	FS_RightHadron [350]
G4double	FS_Weight [350]
G4double	Mass_of_b_quark
G4double	Mass_of_c_quark
G4double	Mass_of_light_quark
G4double	Mass_of_s_quark
G4double	Mass_of_string_junction
G4int	Meson [5][5][7]
G4double	MesonWeight [5][5][7]
G4double	MinimalStringMass
G4double	MinimalStringMass2
G4double	minMassQDiQStr [5][5][5]
G4double	minMassQQbarStr [5][5]
G4int	NewQuark
G4int	NumberOf_FS
G4double	Prob_QQbar [5]
G4int	Qcharge [5]

Protected Types
typedef G4ParticleDefinition *(G4HadronBuilder::*	Pcreate) (G4ParticleDefinition *, G4ParticleDefinition *)
typedef std::pair< G4ParticleDefinition *, G4ParticleDefinition * >	pDefPair

Protected Member Functions
void	Block ()
void	CalculateHadronTimePosition (G4double theInitialStringMass, G4KineticTrackVector *)
void	ConstructParticle ()
G4ExcitedString *	CopyExcited (const G4ExcitedString &string)
G4ParticleDefinition *	CreateHadron (G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin)
pDefPair	CreatePartonPair (G4int NeedParticle, G4bool AllowDiquarks=true)
G4ParticleDefinition *	FindParticle (G4int Encoding)
G4int	GetClusterLoopInterrupt ()
G4double	GetDiquarkBreakProb ()
G4double	GetDiquarkSuppress ()
G4double	GetMassCut ()
G4double	GetProbBBbar ()
G4double	GetProbCCbar ()
G4double	GetProbEta_b ()
G4double	GetProbEta_c ()
G4double	GetStrangeSuppress ()
G4double	GetStringTensionParameter ()
G4bool	IsBlocked () const
G4double	PossibleHadronMass (const G4FragmentingString *const string, Pcreate build=0, pDefPair *pdefs=0)
G4KineticTrackVector *	ProduceOneHadron (const G4ExcitedString *const theString)
virtual G4ParticleDefinition *	QuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
virtual void	SetMassCut (G4double aValue)
void	SetModelName (const G4String &nam)

Protected Attributes
G4int	ClusterLoopInterrupt
G4double	DiquarkBreakProb
G4double	DiquarkSuppress
G4HadronBuilder *	hadronizer
G4bool	isBlocked
G4double	Kappa
G4double	MassCut
G4double	MaxMass
std::vector< G4ParticleDefinition * >	NewParticles
G4bool	PastInitPhase
G4double	ProbBBbar
G4double	ProbCB
G4double	ProbCCbar
G4double	ProbEta_b
G4double	ProbEta_c
G4double	pspin_barion
G4double	pspin_meson
std::vector< G4double >	scalarMesonMix
G4double	SigmaQT
G4double	StrangeSuppress
G4int	StringLoopInterrupt
G4double	theMaxEnergy
G4double	theMinEnergy
G4HadFinalState	theParticleChange
std::vector< G4double >	vectorMesonMix
G4int	verboseLevel

Private Member Functions
G4bool	Diquark_AntiDiquark_aboveThreshold_lastSplitting (G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
G4bool	Diquark_AntiDiquark_belowThreshold_lastSplitting (G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
virtual G4ParticleDefinition *	DiQuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
	G4LundStringFragmentation (const G4LundStringFragmentation &right)
virtual G4double	GetLightConeZ (G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)
virtual G4bool	IsItFragmentable (const G4FragmentingString *const string)
G4double	lambda (G4double s, G4double m1_Sqr, G4double m2_Sqr)
G4bool	Loop_toFragmentString (const G4ExcitedString &theStringInCMS, G4KineticTrackVector *&LeftVector, G4KineticTrackVector *&RightVector)
G4bool	operator!= (const G4LundStringFragmentation &right) const
const G4LundStringFragmentation &	operator= (const G4LundStringFragmentation &right)
G4bool	operator== (const G4LundStringFragmentation &right) const
G4bool	Quark_AntiQuark_lastSplitting (G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
G4bool	Quark_Diquark_lastSplitting (G4FragmentingString *&string, G4ParticleDefinition *&LeftHadron, G4ParticleDefinition *&RightHadron)
virtual void	Sample4Momentum (G4LorentzVector *Mom, G4double Mass, G4LorentzVector *AntiMom, G4double AntiMass, G4double InitialMass)
G4int	SampleState (void)
virtual G4LorentzVector *	SplitEandP (G4ParticleDefinition *pHadron, G4FragmentingString *string, G4FragmentingString *newString)
virtual G4bool	SplitLast (G4FragmentingString *string, G4KineticTrackVector *LeftVector, G4KineticTrackVector *RightVector)
virtual G4KineticTrack *	Splitup (G4FragmentingString *string, G4FragmentingString *&newString)
virtual G4bool	StopFragmenting (const G4FragmentingString *const string)

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
G4double	Tmt

Detailed Description

Definition at line 41 of file G4LundStringFragmentation.hh.

Member Typedef Documentation

Pcreate

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

protectedinherited

Definition at line 86 of file G4VLongitudinalStringDecay.hh.

pDefPair

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

protectedinherited

Definition at line 83 of file G4VLongitudinalStringDecay.hh.

Constructor & Destructor Documentation

G4LundStringFragmentation() [1/2]

G4LundStringFragmentation::G4LundStringFragmentation

(

)

Definition at line 49 of file G4LundStringFragmentation.cc.

  : G4VLongitudinalStringDecay("LundStringFragmentation")
{
    SetMassCut(210.*MeV);   //  Mpi + Delta
                            // For ProduceOneHadron it is required
                            // that no one pi-meson can be produced.
    SigmaQT = 0.435 * GeV;
    Tmt = 190.0 * MeV;
    SetStringTensionParameter(1.*GeV/fermi);
    SetDiquarkBreakProbability(0.5);
    SetStrangenessSuppression((1.0 - 0.12)/2.0);
    SetDiquarkSuppression(0.15);
 
    // Check if charmed and bottom hadrons are enabled: if this is the case, then
    // set the non-zero probabilities for c-cbar and b-bbar creation from the vacuum,
    // else set them to 0.0. If these probabilities are/aren't zero then charmed or bottom
    // hadrons can't/can be created during the string fragmentation of ordinary
    // (i.e. not heavy) projectile hadron nuclear reactions.
    if ( G4HadronicParameters::Instance()->EnableBCParticles() ) {
      SetProbCCbar(0.005);   // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
      SetProbBBbar(5.0e-5);  // According to O.I. Piskunova Yad. Fiz. 56 (1993) 1094
    } else {
      SetProbCCbar(0.0);
      SetProbBBbar(0.0);
    }
    
    SetMinMasses();  // For treating of small string decays
}

References fermi, GeV, G4HadronicParameters::Instance(), MeV, G4VLongitudinalStringDecay::SetDiquarkBreakProbability(), G4VLongitudinalStringDecay::SetDiquarkSuppression(), G4VLongitudinalStringDecay::SetMassCut(), G4VLongitudinalStringDecay::SetMinMasses(), G4VLongitudinalStringDecay::SetProbBBbar(), G4VLongitudinalStringDecay::SetProbCCbar(), G4VLongitudinalStringDecay::SetStrangenessSuppression(), G4VLongitudinalStringDecay::SetStringTensionParameter(), G4VLongitudinalStringDecay::SigmaQT, and Tmt.

~G4LundStringFragmentation()

G4LundStringFragmentation::~G4LundStringFragmentation ( )

virtual

Definition at line 1347 of file G4LundStringFragmentation.cc.

{}

G4LundStringFragmentation() [2/2]

G4LundStringFragmentation::G4LundStringFragmentation ( const G4LundStringFragmentation &  right )

private

Member Function Documentation

ActivateFor() [1/2]

void G4HadronicInteraction::ActivateFor ( const G4Element *  anElement )

inlineinherited

Definition at line 128 of file G4HadronicInteraction.hh.

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

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

ActivateFor() [2/2]

void G4HadronicInteraction::ActivateFor ( const G4Material *  aMaterial )

inlineinherited

Definition at line 120 of file G4HadronicInteraction.hh.

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

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

AddNewParticles()

void G4VLongitudinalStringDecay::AddNewParticles ( )

inherited

ApplyYourself()

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

finalvirtualinherited

Reimplemented from G4HadronicInteraction.

Definition at line 131 of file G4VLongitudinalStringDecay.cc.

{
  return nullptr;
}

Block()

void G4HadronicInteraction::Block ( )

inlineprotectedinherited

Definition at line 170 of file G4HadronicInteraction.hh.

{ isBlocked = true; }

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.

{}

CalculateHadronTimePosition()

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

protectedinherited

Definition at line 435 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by G4QGSMFragmentation::FragmentString().

ConstructParticle()

void G4VLongitudinalStringDecay::ConstructParticle ( )

protectedinherited

CopyExcited()

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

protectedinherited

Definition at line 326 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by G4QGSMFragmentation::FragmentString().

CreateHadron()

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

protectedinherited

CreatePartonPair()

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

protectedinherited

Definition at line 360 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by DiQuarkSplitup(), G4QGSMFragmentation::DiQuarkSplitup(), G4VLongitudinalStringDecay::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().

Diquark_AntiDiquark_aboveThreshold_lastSplitting()

G4bool G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting ( G4FragmentingString *&  string, G4ParticleDefinition *&  LeftHadron, G4ParticleDefinition *&  RightHadron  )

private

Definition at line 882 of file G4LundStringFragmentation.cc.

{
    // StringMass-MinimalStringMass > 0. Creation of 2 baryons is possible ----
 
    G4double StringMass   = string->Mass();
    G4double StringMassSqr= sqr(StringMass); 
    G4ParticleDefinition * Di_Quark;
    G4ParticleDefinition * Anti_Di_Quark;
 
    if (string->GetLeftParton()->GetPDGEncoding() < 0)
    {
        Anti_Di_Quark   =string->GetLeftParton();
        Di_Quark=string->GetRightParton();
    } else
    {
        Anti_Di_Quark   =string->GetRightParton();
        Di_Quark=string->GetLeftParton();
    }
 
    G4int IDAnti_di_quark    =Anti_Di_Quark->GetPDGEncoding();
    G4int AbsIDAnti_di_quark =std::abs(IDAnti_di_quark);
    G4int IDdi_quark         =Di_Quark->GetPDGEncoding();
    G4int AbsIDdi_quark      =std::abs(IDdi_quark);
 
    G4int ADi_q1=AbsIDAnti_di_quark/1000;
    G4int ADi_q2=(AbsIDAnti_di_quark-ADi_q1*1000)/100;
 
    G4int Di_q1=AbsIDdi_quark/1000;
    G4int Di_q2=(AbsIDdi_quark-Di_q1*1000)/100;
 
    NumberOf_FS=0;
    for (G4int ProdQ=1; ProdQ < 6; ProdQ++)
    {
        G4int StateADiQ=0;
                const G4int maxNumberOfLoops = 1000;
                G4int loopCounter = 0;
        do  // while(Meson[AbsIDquark-1][ProdQ-1][StateQ]<>0);
        {
            LeftHadron=G4ParticleTable::GetParticleTable()->FindParticle(
                            -Baryon[ADi_q1-1][ADi_q2-1][ProdQ-1][StateADiQ]);
 
            if (LeftHadron == NULL) continue;
            G4double LeftHadronMass=LeftHadron->GetPDGMass();
 
            G4int StateDiQ=0;
                        const G4int maxNumberOfInternalLoops = 1000;
                        G4int internalLoopCounter = 0;
            do // while(Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]<>0);
            {
                RightHadron=G4ParticleTable::GetParticleTable()->FindParticle(
                                +Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]);
 
                if (RightHadron == NULL) continue;
                G4double RightHadronMass=RightHadron->GetPDGMass();
 
                if (StringMass > LeftHadronMass + RightHadronMass)
                {
                                        if ( NumberOf_FS > 349 ) {
                                          G4ExceptionDescription ed;
                                          ed << " NumberOf_FS exceeds its limit: NumberOf_FS=" << NumberOf_FS << G4endl;
                                          G4Exception( "G4LundStringFragmentation::Diquark_AntiDiquark_aboveThreshold_lastSplitting ",
                                                       "HAD_LUND_001", JustWarning, ed );
                                          NumberOf_FS = 349;
                                        }
 
                    G4double FS_Psqr=lambda(StringMassSqr,sqr(LeftHadronMass),
                                sqr(RightHadronMass));
                    //FS_Psqr=1.;
                    FS_Weight[NumberOf_FS]=std::sqrt(FS_Psqr)*FS_Psqr*
                                   BaryonWeight[ADi_q1-1][ADi_q2-1][ProdQ-1][StateADiQ]*
                                   BaryonWeight[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]*
                                   Prob_QQbar[ProdQ-1];
 
                    FS_LeftHadron[NumberOf_FS] = LeftHadron;
                    FS_RightHadron[NumberOf_FS]= RightHadron;
                    NumberOf_FS++;
                } // End of if (StringMass > LeftHadronMass + RightHadronMass)
 
                StateDiQ++;
 
            } while( (Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]!=0) && 
                                 ++internalLoopCounter < maxNumberOfInternalLoops );
                        if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
                          return false;
                        }
 
            StateADiQ++;
        } while( (Baryon[ADi_q1-1][ADi_q2-1][ProdQ-1][StateADiQ]!=0) &&
                         ++loopCounter < maxNumberOfLoops ); 
                if ( loopCounter >= maxNumberOfLoops ) {
                  return false;
                }
    } // End of for (G4int ProdQ=1; ProdQ < 4; ProdQ++)
 
    return true;
}

References G4VLongitudinalStringDecay::Baryon, G4VLongitudinalStringDecay::BaryonWeight, G4ParticleTable::FindParticle(), G4VLongitudinalStringDecay::FS_LeftHadron, G4VLongitudinalStringDecay::FS_RightHadron, G4VLongitudinalStringDecay::FS_Weight, G4endl, G4Exception(), G4FragmentingString::GetLeftParton(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), JustWarning, lambda(), G4VLongitudinalStringDecay::NumberOf_FS, G4VLongitudinalStringDecay::Prob_QQbar, and sqr().

Referenced by SplitLast().

Diquark_AntiDiquark_belowThreshold_lastSplitting()

G4bool G4LundStringFragmentation::Diquark_AntiDiquark_belowThreshold_lastSplitting ( G4FragmentingString *&  string, G4ParticleDefinition *&  LeftHadron, G4ParticleDefinition *&  RightHadron  )

private

Definition at line 836 of file G4LundStringFragmentation.cc.

{
    G4double StringMass   = string->Mass();
 
    G4int cClusterInterrupt = 0;
        G4bool isOK = false;
    do
    {
        G4int LeftQuark1= string->GetLeftParton()->GetPDGEncoding()/1000;
        G4int LeftQuark2=(string->GetLeftParton()->GetPDGEncoding()/100)%10;
 
        G4int RightQuark1= string->GetRightParton()->GetPDGEncoding()/1000;
        G4int RightQuark2=(string->GetRightParton()->GetPDGEncoding()/100)%10;
 
        if (G4UniformRand()<0.5)
        {
            LeftHadron =hadronizer->Build(FindParticle( LeftQuark1),
                              FindParticle(RightQuark1));
            RightHadron= (LeftHadron == nullptr) ? nullptr :
                                                      hadronizer->Build(FindParticle( LeftQuark2),
                              FindParticle(RightQuark2));
        } else
        {
            LeftHadron =hadronizer->Build(FindParticle( LeftQuark1),
                              FindParticle(RightQuark2));
            RightHadron=(LeftHadron == nullptr) ? nullptr :
                                          hadronizer->Build(FindParticle( LeftQuark2),
                              FindParticle(RightQuark1));
        }
 
        isOK = (LeftHadron != nullptr) && (RightHadron != nullptr);
        if(isOK) { isOK = (StringMass > LeftHadron->GetPDGMass() + RightHadron->GetPDGMass()); }
        ++cClusterInterrupt;
        //... repeat procedure, if mass of cluster is too low to produce hadrons
        //... ClusterMassCut = 0.15*GeV model parameter
    }
    while (isOK == false || cClusterInterrupt < ClusterLoopInterrupt);
    /* Loop checking, 07.08.2015, A.Ribon */
    return isOK;
}

References G4HadronBuilder::Build(), G4VLongitudinalStringDecay::ClusterLoopInterrupt, G4VLongitudinalStringDecay::FindParticle(), G4UniformRand, G4ParticleDefinition::GetPDGMass(), and G4VLongitudinalStringDecay::hadronizer.

Referenced by SplitLast().

DiQuarkSplitup()

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 458 of file G4LundStringFragmentation.cc.

{
   G4double StrSup=GetStrangeSuppress();
   G4double ProbQQbar = (1.0 - 2.0*StrSup);
 
   //... can Diquark break or not?
   if (G4UniformRand() < DiquarkBreakProb ){
 
      //... Diquark break
      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
      if (G4UniformRand() < 0.5)
      {
         G4int Swap = stableQuarkEncoding;
         stableQuarkEncoding = decayQuarkEncoding;
         decayQuarkEncoding = Swap;
      }
 
      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1;  // if we have a quark, we need antiquark
 
      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
 
      //... Build new Diquark
      G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
      G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
      G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
      G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
      G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
      created = FindParticle(NewDecayEncoding);
      G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
      StrangeSuppress=StrSup;
 
      return had;
 
   } else {
      //... Diquark does not break
 
      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1;  // if we have a diquark, we need quark
 
      StrangeSuppress=(1.0 - ProbQQbar * 0.9)/2.0;
      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
 
      created = QuarkPair.second;
 
      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
      StrangeSuppress=StrSup;
 
      return had;
   }
}

References G4HadronBuilder::Build(), G4VLongitudinalStringDecay::CreatePartonPair(), G4INCL::ClusterDecay::decay(), G4VLongitudinalStringDecay::DiquarkBreakProb, G4VLongitudinalStringDecay::FindParticle(), G4UniformRand, G4VLongitudinalStringDecay::GetStrangeSuppress(), G4VLongitudinalStringDecay::hadronizer, G4INCL::Math::max(), G4INCL::Math::min(), and G4VLongitudinalStringDecay::StrangeSuppress.

Referenced by Splitup().

EraseNewParticles()

void G4VLongitudinalStringDecay::EraseNewParticles ( )

inherited

FindParticle()

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int  Encoding )

protectedinherited

Definition at line 280 of file G4VLongitudinalStringDecay.cc.

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

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

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

FragmentString()

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

virtual

Implements G4VLongitudinalStringDecay.

Definition at line 80 of file G4LundStringFragmentation.cc.

{
    // Can no longer modify Parameters for Fragmentation.
 
    PastInitPhase=true;
 
    G4FragmentingString  aString(theString);
    SetMinimalStringMass(&aString);
 
        #ifdef debug_LUNDfragmentation
        G4cout<<G4endl<<"LUND StringFragmentation ------------------------------------"<<G4endl;
        G4cout<<G4endl<<"LUND StringFragm: String Mass "
                      <<theString.Get4Momentum().mag()<<G4endl
                      <<"4Mom "<<theString.Get4Momentum()<<G4endl
                      <<"------------------------------------"<<G4endl;
        G4cout<<"String ends Direct "<<theString.GetLeftParton()->GetPDGcode()<<" "
                                     <<theString.GetRightParton()->GetPDGcode()<<" "
                                     <<theString.GetDirection()<< G4endl;
        G4cout<<"Left  mom "<<theString.GetLeftParton()->Get4Momentum()<<G4endl;
        G4cout<<"Right mom "<<theString.GetRightParton()->Get4Momentum()<<G4endl<<G4endl;
        G4cout<<"Check for Fragmentation "<<G4endl;
        #endif
 
    G4KineticTrackVector * LeftVector(0);
 
    if (!aString.IsAFourQuarkString() && !IsItFragmentable(&aString))
    {
                #ifdef debug_LUNDfragmentation
                G4cout<<"Non fragmentable - the string is converted to one hadron "<<G4endl;
                #endif
                // SetMassCut(210.*MeV);  // For ProduceOneHadron it is required
                                          // that no one pi-meson can be produced.
 
        G4double Mcut = GetMassCut();
        SetMassCut(10000.*MeV);
        LeftVector=ProduceOneHadron(&theString);
        SetMassCut(Mcut);
 
        if ( LeftVector )
        {
          if ( LeftVector->size() > 0)
                  {
                LeftVector->operator[](0)->SetFormationTime(theString.GetTimeOfCreation());
                LeftVector->operator[](0)->SetPosition(theString.GetPosition());
                  }
          if (LeftVector->size() > 1)
                  {
                // 2 hadrons created from qq-qqbar are stored
            LeftVector->operator[](1)->SetFormationTime(theString.GetTimeOfCreation());
            LeftVector->operator[](1)->SetPosition(theString.GetPosition());
          }
        }       
        return LeftVector;
    }
 
        #ifdef debug_LUNDfragmentation
        G4cout<<"The string will be fragmented. "<<G4endl;
        #endif
 
    // The string can fragment. At least two particles can be produced.
                   LeftVector =new G4KineticTrackVector;
    G4KineticTrackVector * RightVector=new G4KineticTrackVector;
 
        G4bool success = Loop_toFragmentString(theString, LeftVector, RightVector);
 
    if ( ! success )
    {
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        delete RightVector;
        return LeftVector;
    }
 
    // Join Left- and RightVector into LeftVector in correct order.
    while (!RightVector->empty())
    {
        LeftVector->push_back(RightVector->back());
        RightVector->erase(RightVector->end()-1);
    }
    delete RightVector;
 
    return LeftVector;
}

References G4cout, G4endl, G4ExcitedString::Get4Momentum(), G4Parton::Get4Momentum(), G4ExcitedString::GetDirection(), G4ExcitedString::GetLeftParton(), G4VLongitudinalStringDecay::GetMassCut(), G4Parton::GetPDGcode(), G4ExcitedString::GetPosition(), G4ExcitedString::GetRightParton(), G4ExcitedString::GetTimeOfCreation(), G4FragmentingString::IsAFourQuarkString(), IsItFragmentable(), Loop_toFragmentString(), CLHEP::HepLorentzVector::mag(), MeV, G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::ProduceOneHadron(), G4VLongitudinalStringDecay::SetMassCut(), and G4VLongitudinalStringDecay::SetMinimalStringMass().

GetClusterLoopInterrupt()

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt ( )

inlineprotectedinherited

Definition at line 176 of file G4VLongitudinalStringDecay.hh.

{return ClusterLoopInterrupt;};

References G4VLongitudinalStringDecay::ClusterLoopInterrupt.

GetDiquarkBreakProb()

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb ( )

inlineprotectedinherited

Definition at line 174 of file G4VLongitudinalStringDecay.hh.

{return DiquarkBreakProb;};

References G4VLongitudinalStringDecay::DiquarkBreakProb.

GetDiquarkSuppress()

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress ( )

inlineprotectedinherited

Definition at line 173 of file G4VLongitudinalStringDecay.hh.

{return DiquarkSuppress;};

References G4VLongitudinalStringDecay::DiquarkSuppress.

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

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 628 of file G4LundStringFragmentation.cc.

{
    G4double Mass = pHadron->GetPDGMass();
        G4int HadronEncoding=std::abs(pHadron->GetPDGEncoding());
 
    G4double Mt2 = Px*Px + Py*Py + Mass*Mass;
 
    G4double  Alund, Blund;
    G4double zOfMaxyf(0.), maxYf(1.), z(0.), yf(1.);
 
    if (!((std::abs(PDGEncodingOfDecayParton) > 1000) && (HadronEncoding > 1000)) )
    {    // ---------------- Quark fragmentation  and qq-> meson ----------------------
           Alund=1.;
           Blund=0.7/GeV/GeV;
 
       G4double BMt2 = Blund*Mt2;
       if (Alund == 1.0) {
         zOfMaxyf=BMt2/(Blund*Mt2 + 1.);}
       else {  
         zOfMaxyf = ((1.0+BMt2) - std::sqrt(sqr(1.0-BMt2) + 4.0*BMt2*Alund))/2.0/(1.-Alund);
       }
 
       if (zOfMaxyf < zmin) {zOfMaxyf=zmin;}
       if (zOfMaxyf > zmax) {zOfMaxyf=zmax;}
       maxYf=(1-zOfMaxyf)/zOfMaxyf * G4Exp(-Blund*Mt2/zOfMaxyf);
 
           const G4int maxNumberOfLoops = 1000;
           G4int loopCounter = 0;
       do
       {
        z = zmin + G4UniformRand()*(zmax-zmin);
                //yf = (1-z)/z * G4Exp(-Blund*Mt2/z);
        yf = G4Pow::GetInstance()->powA(1.0-z,Alund)/z*G4Exp(-BMt2/z);
       }
       while ( (G4UniformRand()*maxYf > yf) && ++loopCounter < maxNumberOfLoops );
           if ( loopCounter >= maxNumberOfLoops ) {
             z = 0.5*(zmin + zmax);  // Just a value between zmin and zmax, no physics considerations at all! 
           }
       return z;
        }
 
    if (std::abs(PDGEncodingOfDecayParton) > 1000)     
    {
                G4double an = 2.5;
                an +=(sqr(Px)+sqr(Py))/sqr(GeV)-0.5;
                z=zmin + (zmax-zmin)*G4Pow::GetInstance()->powA(G4UniformRand(),1./an);
    }
 
    return z;
}

References G4InuclParticleNames::an, G4Exp(), G4UniformRand, G4Pow::GetInstance(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), GeV, G4Pow::powA(), and sqr().

Referenced by SplitEandP().

GetMassCut()

G4double G4VLongitudinalStringDecay::GetMassCut ( )

protectedinherited

Definition at line 140 of file G4VLongitudinalStringDecay.cc.

{ return MassCut; }

References G4VLongitudinalStringDecay::MassCut.

Referenced by FragmentString().

GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const

inlineinherited

Definition at line 96 of file G4HadronicInteraction.hh.

  { return theMaxEnergy; }

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.

  { return theMinEnergy; }

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.

  { return theModelName; }

References G4HadronicInteraction::theModelName.

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

GetProbBBbar()

G4double G4VLongitudinalStringDecay::GetProbBBbar ( )

inlineprotectedinherited

Definition at line 180 of file G4VLongitudinalStringDecay.hh.

{return ProbBBbar;};

References G4VLongitudinalStringDecay::ProbBBbar.

GetProbCCbar()

G4double G4VLongitudinalStringDecay::GetProbCCbar ( )

inlineprotectedinherited

Definition at line 178 of file G4VLongitudinalStringDecay.hh.

{return ProbCCbar;};

References G4VLongitudinalStringDecay::ProbCCbar.

GetProbEta_b()

G4double G4VLongitudinalStringDecay::GetProbEta_b ( )

inlineprotectedinherited

Definition at line 181 of file G4VLongitudinalStringDecay.hh.

{return ProbEta_b;};

References G4VLongitudinalStringDecay::ProbEta_b.

GetProbEta_c()

G4double G4VLongitudinalStringDecay::GetProbEta_c ( )

inlineprotectedinherited

Definition at line 179 of file G4VLongitudinalStringDecay.hh.

{return ProbEta_c;};

References G4VLongitudinalStringDecay::ProbEta_c.

GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const

inlineinherited

Definition at line 141 of file G4HadronicInteraction.hh.

  { return recoilEnergyThreshold;}

References G4HadronicInteraction::recoilEnergyThreshold.

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

GetStrangeSuppress()

G4double G4VLongitudinalStringDecay::GetStrangeSuppress ( )

inlineprotectedinherited

Definition at line 175 of file G4VLongitudinalStringDecay.hh.

{return StrangeSuppress;};

References G4VLongitudinalStringDecay::StrangeSuppress.

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

GetStringTensionParameter()

G4double G4VLongitudinalStringDecay::GetStringTensionParameter ( )

inlineprotectedinherited

Definition at line 183 of file G4VLongitudinalStringDecay.hh.

{return Kappa;};

References G4VLongitudinalStringDecay::Kappa.

Referenced by G4VLongitudinalStringDecay::CalculateHadronTimePosition().

GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const

inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

  { return verboseLevel; }

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.

{}

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.

{ return isBlocked;}

References G4HadronicInteraction::isBlocked.

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

IsBlocked() [2/3]

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

inherited

Definition at line 202 of file G4HadronicInteraction.cc.

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

References G4HadronicInteraction::theBlockedListElements.

IsBlocked() [3/3]

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

inherited

Definition at line 193 of file G4HadronicInteraction.cc.

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

References G4HadronicInteraction::theBlockedList.

IsItFragmentable()

G4bool G4LundStringFragmentation::IsItFragmentable ( const G4FragmentingString *const  string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 167 of file G4LundStringFragmentation.cc.

{
    SetMinimalStringMass(string);
        //G4cout<<"MinM StrM "<<MinimalStringMass<<" "<< string->Get4Momentum().mag()<<G4endl;
 
    return std::abs(MinimalStringMass) < string->Get4Momentum().mag();
 
        //MinimalStringMass is negative and large for a string with unknown particles in a final 2-particle decay.
}

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

Referenced by FragmentString().

lambda()

G4double G4LundStringFragmentation::lambda ( G4double  s, G4double  m1_Sqr, G4double  m2_Sqr  )

private

Definition at line 1340 of file G4LundStringFragmentation.cc.

{ 
    G4double lam = sqr(S - m1_Sqr - m2_Sqr) - 4.*m1_Sqr*m2_Sqr;
    return lam;
}

References G4InuclParticleNames::lam, S(), and sqr().

Referenced by Diquark_AntiDiquark_aboveThreshold_lastSplitting(), Quark_AntiQuark_lastSplitting(), and Quark_Diquark_lastSplitting().

Loop_toFragmentString()

G4bool G4LundStringFragmentation::Loop_toFragmentString ( const G4ExcitedString &  theStringInCMS, G4KineticTrackVector *&  LeftVector, G4KineticTrackVector *&  RightVector  )

private

Definition at line 179 of file G4LundStringFragmentation.cc.

{
        #ifdef debug_LUNDfragmentation
        G4cout<<"Loop_toFrag "<<theString.GetLeftParton()->GetPDGcode()<<" "
                              <<theString.GetLeftParton()->Get4Momentum()<<G4endl
              <<"            "<<theString.GetRightParton()->GetPDGcode()<<" "
                              <<theString.GetRightParton()->Get4Momentum()<<G4endl
              <<"Direction   "<<theString.GetDirection()<< G4endl;
        #endif
 
        G4LorentzRotation toCmsI, toObserverFrameI;
 
    G4bool final_success=false;
    G4bool inner_success=true;
 
    G4int attempt=0;
 
    while ( ! final_success && attempt++ < StringLoopInterrupt )
    {       // If the string fragmentation does not be happend, 
            // repeat the fragmentation.
 
                G4FragmentingString *currentString = new G4FragmentingString(theString);
                toCmsI = currentString->TransformToAlignedCms();
                toObserverFrameI = toCmsI.inverse();
 
        G4LorentzRotation toCms, toObserverFrame;
 
        //G4cout<<"Main loop start whilecounter "<<attempt<<G4endl;
 
        // Cleaning up the previously produced hadrons
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        RightVector->clear();
 
        // Main fragmentation loop until the string will not be able to fragment
        inner_success=true;  // set false on failure.
                const G4int maxNumberOfLoops = 1000;
                G4int loopCounter = -1;
        
        while ( (! StopFragmenting(currentString)) && ++loopCounter < maxNumberOfLoops )
        {       // Split current string into hadron + new string
                        #ifdef debug_LUNDfragmentation
                        G4cout<<"The string will fragment. "<<G4endl;;
                        //G4cout<<"1 "<<currentString->GetDecayDirection()<<G4endl;
                        #endif
            G4FragmentingString *newString=0;  // used as output from SplitUp.
 
            toCms=currentString->TransformToAlignedCms();
                        toObserverFrame= toCms.inverse();
            
                        #ifdef debug_LUNDfragmentation
                        //G4cout<<"CMS Left  mom "<<currentString->GetPleft()<<G4endl;
                        //G4cout<<"CMS Right mom "<<currentString->GetPright()<<G4endl;
                        //G4cout<<"CMS String M  "<<currentString->GetPstring()<<G4endl;
                        #endif
 
            G4KineticTrack * Hadron=Splitup(currentString,newString);
 
            if ( Hadron != 0 )  // Store the hadron                               
            {
                                #ifdef debug_LUNDfragmentation
                                G4cout<<"Hadron prod at fragm. "<<Hadron->GetDefinition()->GetParticleName()<<G4endl;
                                //G4cout<<"2 "<<currentString->GetDecayDirection()<<G4endl;
                                #endif
 
                Hadron->Set4Momentum(toObserverFrame*Hadron->Get4Momentum());
 
                G4double TimeOftheStringCreation=theString.GetTimeOfCreation();
                G4ThreeVector PositionOftheStringCreation(theString.GetPosition());
 
                G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
                G4LorentzVector Momentum = toObserverFrame*Coordinate;
                Hadron->SetFormationTime(TimeOftheStringCreation + Momentum.e() - fermi/c_light);
                G4ThreeVector aPosition(Momentum.vect());
                Hadron->SetPosition(PositionOftheStringCreation+aPosition);
 
                                // Open to protect hadron production at fragmentation 
                if ( currentString->GetDecayDirection() > 0 )
                                {
                    LeftVector->push_back(Hadron); 
                                } else
                                {
                    RightVector->push_back(Hadron);
                                }
                delete currentString;
                currentString=newString;
            } else {
                          if ( newString ) delete newString;
                        }
 
                        currentString->LorentzRotate(toObserverFrame);
        };
 
                if ( loopCounter >= maxNumberOfLoops ) {
                  inner_success=false;
                }
 
        // Split remaining string into 2 final hadrons.
                #ifdef debug_LUNDfragmentation
                if (inner_success) G4cout<<"Split remaining string into 2 final hadrons."<<G4endl;
                #endif
 
        if ( inner_success && SplitLast(currentString, LeftVector, RightVector) )  // Close to protect Last Str. Decay
        {
          final_success = true;
        }
 
        delete currentString;
    }  // End of the loop where we try to fragment the string.
 
        G4int sign = +1;
        if ( theString.GetDirection() < 0 ) sign = -1;
        for ( unsigned int hadronI = 0; hadronI < LeftVector->size(); ++hadronI ) {
           G4LorentzVector Tmp = LeftVector->operator[](hadronI)->Get4Momentum();
           Tmp.setZ(sign*Tmp.getZ());
           Tmp *= toObserverFrameI;
           LeftVector->operator[](hadronI)->Set4Momentum(Tmp);
        }
        for ( unsigned int hadronI = 0; hadronI < RightVector->size(); ++hadronI ) {
           G4LorentzVector Tmp = RightVector->operator[](hadronI)->Get4Momentum();
           Tmp.setZ(sign*Tmp.getZ());
           Tmp *= toObserverFrameI;
           RightVector->operator[](hadronI)->Set4Momentum(Tmp);
        }
 
    return final_success;
}

References source.hepunit::c_light, fermi, G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4Parton::Get4Momentum(), G4FragmentingString::GetDecayDirection(), G4KineticTrack::GetDefinition(), G4ExcitedString::GetDirection(), G4KineticTrack::GetFormationTime(), G4ExcitedString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4Parton::GetPDGcode(), G4ExcitedString::GetPosition(), G4KineticTrack::GetPosition(), G4ExcitedString::GetRightParton(), G4ExcitedString::GetTimeOfCreation(), CLHEP::HepLorentzVector::getZ(), CLHEP::HepLorentzRotation::inverse(), G4FragmentingString::LorentzRotate(), G4KineticTrack::Set4Momentum(), G4KineticTrack::SetFormationTime(), G4KineticTrack::SetPosition(), CLHEP::HepLorentzVector::setZ(), G4INCL::Math::sign(), SplitLast(), Splitup(), StopFragmenting(), G4VLongitudinalStringDecay::StringLoopInterrupt, and G4FragmentingString::TransformToAlignedCms().

Referenced by FragmentString().

ModelDescription()

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

virtualinherited

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

Definition at line 222 of file G4HadronicInteraction.cc.

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

Referenced by G4HadronicProcessStore::PrintModelHtml().

operator!=() [1/2]

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

deleteinherited

operator!=() [2/2]

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

private

operator=()

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

private

operator==() [1/2]

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

deleteinherited

operator==() [2/2]

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

private

PossibleHadronMass()

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

protectedinherited

Definition at line 202 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by G4VLongitudinalStringDecay::ProduceOneHadron().

ProduceOneHadron()

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

protectedinherited

Definition at line 146 of file G4VLongitudinalStringDecay.cc.

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

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

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

Quark_AntiQuark_lastSplitting()

G4bool G4LundStringFragmentation::Quark_AntiQuark_lastSplitting ( G4FragmentingString *&  string, G4ParticleDefinition *&  LeftHadron, G4ParticleDefinition *&  RightHadron  )

private

Definition at line 1102 of file G4LundStringFragmentation.cc.

{
    G4double StringMass   = string->Mass();
    G4double StringMassSqr= sqr(StringMass);
 
    G4ParticleDefinition * Quark;
    G4ParticleDefinition * Anti_Quark;
 
    if (string->GetLeftParton()->GetPDGEncoding()>0)
    {
        Quark     =string->GetLeftParton();
        Anti_Quark=string->GetRightParton();
    } else
    {
        Quark     =string->GetRightParton();
        Anti_Quark=string->GetLeftParton();
    }
 
    G4int IDquark         =Quark->GetPDGEncoding();
    G4int AbsIDquark      =std::abs(IDquark);
        G4int QuarkCharge     =Qcharge[IDquark-1];
 
    G4int IDanti_quark    =Anti_Quark->GetPDGEncoding();
    G4int AbsIDanti_quark =std::abs(IDanti_quark);
        G4int AntiQuarkCharge =-Qcharge[AbsIDanti_quark-1];
 
        G4int LeftHadronCharge(0), RightHadronCharge(0);
 
        //G4cout<<"Q Qbar "<<IDquark<<" "<<IDanti_quark<<G4endl;
 
    NumberOf_FS=0;
    for (G4int ProdQ=1; ProdQ < 4; ProdQ++)  // Loop over quark-antiquark cases: u-ubar, d-dbar, s-sbar 
    {                                        // (as last splitting, do not consider c-cbar and b-bbar cases)
        LeftHadronCharge = QuarkCharge - Qcharge[ProdQ-1];
        G4int SignQ = LeftHadronCharge/3; if (SignQ == 0) SignQ = 1;
 
        if ((IDquark == 1) && (ProdQ == 3)) SignQ= 1; // K0       (d,sbar)
        if ((IDquark == 3) && (ProdQ == 1)) SignQ=-1; // K0bar    (s,dbar)
                if ((IDquark == 4) && (ProdQ == 2)) SignQ= 1; // D0       (c,ubar)
                if ((IDquark == 5) && (ProdQ == 1)) SignQ=-1; // anti_B0  (b,dbar)
                if ((IDquark == 5) && (ProdQ == 3)) SignQ=-1; // anti_Bs0 (b,sbar)
        
                RightHadronCharge = AntiQuarkCharge + Qcharge[ProdQ-1];
        G4int SignAQ = RightHadronCharge/3; if (SignAQ == 0) SignAQ = 1;
 
        if ((IDanti_quark ==-1) && (ProdQ == 3)) SignAQ=-1; // K0bar   (dbar,s)
        if ((IDanti_quark ==-3) && (ProdQ == 1)) SignAQ= 1; // K0      (sbar,d)
        if ((IDanti_quark ==-4) && (ProdQ == 2)) SignAQ=-1; // anti_D0 (cbar,u)
        if ((IDanti_quark ==-5) && (ProdQ == 1)) SignAQ= 1; // B0      (bbar,d)
        if ((IDanti_quark ==-5) && (ProdQ == 3)) SignAQ= 1; // Bs0     (bbar,s)
 
                //G4cout<<"ProQ signs "<<ProdQ<<" "<<SignQ<<" "<<SignAQ<<G4endl;
 
        G4int StateQ=0;
                const G4int maxNumberOfLoops = 1000;
                G4int loopCounter = 0;
        do
        {
                        //G4cout<<"[AbsIDquark-1][ProdQ-1][StateQ "<<AbsIDquark-1<<" "
                        //<<ProdQ-1<<" "<<StateQ<<" "<<SignQ*Meson[AbsIDquark-1][ProdQ-1][StateQ]<<G4endl;
            LeftHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignQ*
                               Meson[AbsIDquark-1][ProdQ-1][StateQ]);
                        //G4cout<<"LeftHadron "<<LeftHadron<<G4endl;
            if (LeftHadron == NULL) { StateQ++; continue; }
                        //G4cout<<"LeftHadron "<<LeftHadron->GetParticleName()<<G4endl;
            G4double LeftHadronMass=LeftHadron->GetPDGMass();
 
            G4int StateAQ=0;
                        const G4int maxNumberOfInternalLoops = 1000;
                        G4int internalLoopCounter = 0;
            do
            {
                                //G4cout<<"           [AbsIDanti_quark-1][ProdQ-1][StateAQ] "<<AbsIDanti_quark-1<<" "
                                //      <<ProdQ-1<<" "<<StateAQ<<" "<<SignAQ*Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]<<G4endl;
                RightHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignAQ*
                                Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]);
                                //G4cout<<"RightHadron "<<RightHadron<<G4endl;
                if(RightHadron == NULL) { StateAQ++; continue; }
                                //G4cout<<"RightHadron "<<RightHadron->GetParticleName()<<G4endl;
                G4double RightHadronMass=RightHadron->GetPDGMass();
 
                if (StringMass > LeftHadronMass + RightHadronMass)
                {
                                        if ( NumberOf_FS > 349 ) {
                                          G4ExceptionDescription ed;
                                          ed << " NumberOf_FS exceeds its limit: NumberOf_FS=" << NumberOf_FS << G4endl;
                                          G4Exception( "G4LundStringFragmentation::Quark_AntiQuark_lastSplitting ",
                                                       "HAD_LUND_003", JustWarning, ed );
                                          NumberOf_FS = 349;
                                        }
 
                                        G4double FS_Psqr=lambda(StringMassSqr,sqr(LeftHadronMass),
                                sqr(RightHadronMass));
                    //FS_Psqr=1.;
                    FS_Weight[NumberOf_FS]=std::sqrt(FS_Psqr)*
                                   MesonWeight[AbsIDquark-1][ProdQ-1][StateQ]*
                                   MesonWeight[AbsIDanti_quark-1][ProdQ-1][StateAQ]*
                                   Prob_QQbar[ProdQ-1];
 
                    if (string->GetLeftParton()->GetPDGEncoding()>0)
                    {
                        FS_LeftHadron[NumberOf_FS] = RightHadron;
                        FS_RightHadron[NumberOf_FS]= LeftHadron;
                    } else
                    {
                        FS_LeftHadron[NumberOf_FS] = LeftHadron;
                        FS_RightHadron[NumberOf_FS]= RightHadron;
                    }
 
                    NumberOf_FS++;
 
                }
 
                StateAQ++;
                                //G4cout<<"               StateAQ Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ] "<<StateAQ<<" "
                                //      <<Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]<<" "<<internalLoopCounter<<G4endl;
            } while ( (Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]!=0) &&
                                  ++internalLoopCounter < maxNumberOfInternalLoops );
                          if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
                            return false;
                          }
 
            StateQ++;
                        //G4cout<<"StateQ Meson[AbsIDquark-1][ProdQ-1][StateQ] "<<StateQ<<" "
                        //      <<Meson[AbsIDquark-1][ProdQ-1][StateQ]<<" "<<loopCounter<<G4endl;
 
        } while ( (Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0) &&
                         ++loopCounter < maxNumberOfLoops );
                  if ( loopCounter >= maxNumberOfLoops ) {
                    return false;
                  }
    } // End of for (G4int ProdQ=1; ProdQ < 4; ProdQ++)
 
    return true;
}

References G4ParticleTable::FindParticle(), G4VLongitudinalStringDecay::FS_LeftHadron, G4VLongitudinalStringDecay::FS_RightHadron, G4VLongitudinalStringDecay::FS_Weight, G4endl, G4Exception(), G4FragmentingString::GetLeftParton(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), JustWarning, lambda(), G4VLongitudinalStringDecay::Meson, G4VLongitudinalStringDecay::MesonWeight, G4VLongitudinalStringDecay::NumberOf_FS, G4VLongitudinalStringDecay::Prob_QQbar, G4VLongitudinalStringDecay::Qcharge, and sqr().

Referenced by SplitLast().

Quark_Diquark_lastSplitting()

G4bool G4LundStringFragmentation::Quark_Diquark_lastSplitting ( G4FragmentingString *&  string, G4ParticleDefinition *&  LeftHadron, G4ParticleDefinition *&  RightHadron  )

private

Definition at line 984 of file G4LundStringFragmentation.cc.

{
    G4double StringMass   = string->Mass();
    G4double StringMassSqr= sqr(StringMass);
 
    G4ParticleDefinition * Di_Quark;
    G4ParticleDefinition * Quark;
 
    if (string->GetLeftParton()->GetParticleSubType()== "quark")
    {
        Quark   =string->GetLeftParton();
        Di_Quark=string->GetRightParton();
    } else
    {
        Quark   =string->GetRightParton();
        Di_Quark=string->GetLeftParton();
    }
 
    G4int IDquark        =Quark->GetPDGEncoding();
    G4int AbsIDquark     =std::abs(IDquark);
    G4int IDdi_quark   =Di_Quark->GetPDGEncoding();
    G4int AbsIDdi_quark=std::abs(IDdi_quark);
    G4int Di_q1=AbsIDdi_quark/1000;
    G4int Di_q2=(AbsIDdi_quark-Di_q1*1000)/100;
    G4int SignDiQ= 1;
    if (IDdi_quark < 0) SignDiQ=-1;
 
    NumberOf_FS=0;
    for (G4int ProdQ=1; ProdQ < 4; ProdQ++)  // Loop over quark-antiquark cases: u-ubar, d-dbar, s-sbar 
    {                                        // (as last splitting, do not consider c-cbar and b-bbar cases)
        G4int SignQ;
        if (IDquark > 0)
        {
                SignQ=-1;
                if (IDquark == 2)                   SignQ= 1;
            if ((IDquark == 1) && (ProdQ == 3)) SignQ= 1; // K0
            if ((IDquark == 3) && (ProdQ == 1)) SignQ=-1; // K0bar
                if (IDquark == 4)                   SignQ= 1; // D+, D0, Ds+
            if (IDquark == 5)                   SignQ=-1; // B-, anti_B0, anti_Bs0
        } else
        {
            SignQ= 1;
            if (IDquark == -2)                  SignQ=-1;
            if ((IDquark ==-1) && (ProdQ == 3)) SignQ=-1; // K0bar
            if ((IDquark ==-3) && (ProdQ == 1)) SignQ= 1; // K0
            if (IDquark == -4)                  SignQ=-1; // D-, anti_D0, anti_Ds+
            if (IDquark == -5)                  SignQ= 1; // B+, B0, Bs0
        }
 
        if (AbsIDquark == ProdQ)            SignQ= 1;
 
        G4int StateQ=0;
                const G4int maxNumberOfLoops = 1000;
                G4int loopCounter = 0;
        do  // while(Meson[AbsIDquark-1][ProdQ-1][StateQ]<>0);
        {
            LeftHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignQ*
                            Meson[AbsIDquark-1][ProdQ-1][StateQ]);
            if (LeftHadron == NULL) continue;
            G4double LeftHadronMass=LeftHadron->GetPDGMass();
 
            G4int StateDiQ=0;
                        const G4int maxNumberOfInternalLoops = 1000;
                        G4int internalLoopCounter = 0;
            do // while(Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]<>0);
            {
                RightHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignDiQ*
                                Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]);
                if (RightHadron == NULL) continue;
                G4double RightHadronMass=RightHadron->GetPDGMass();
 
                if (StringMass > LeftHadronMass + RightHadronMass)
                {
                                        if ( NumberOf_FS > 349 ) {
                                          G4ExceptionDescription ed;
                                          ed << " NumberOf_FS exceeds its limit: NumberOf_FS=" << NumberOf_FS << G4endl;
                                          G4Exception( "G4LundStringFragmentation::Quark_Diquark_lastSplitting ",
                                                       "HAD_LUND_002", JustWarning, ed );
                                          NumberOf_FS = 349;
                                        }
 
                    G4double FS_Psqr=lambda(StringMassSqr,sqr(LeftHadronMass),
                                sqr(RightHadronMass));
                    FS_Weight[NumberOf_FS]=std::sqrt(FS_Psqr)*
                                   MesonWeight[AbsIDquark-1][ProdQ-1][StateQ]*
                                   BaryonWeight[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]*
                                   Prob_QQbar[ProdQ-1];
 
                    FS_LeftHadron[NumberOf_FS] = LeftHadron;
                    FS_RightHadron[NumberOf_FS]= RightHadron;
 
                    NumberOf_FS++;
                } // End of if (StringMass > LeftHadronMass + RightHadronMass)
 
                StateDiQ++;
 
            } while( (Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]!=0) &&
                                 ++internalLoopCounter < maxNumberOfInternalLoops );
                        if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
                          return false;
                        }
 
            StateQ++;
        } while( (Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0) &&
                         ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
 
                  if ( loopCounter >= maxNumberOfLoops ) {
                    return false;
                  }
    }
 
    return true;
}

References G4VLongitudinalStringDecay::Baryon, G4VLongitudinalStringDecay::BaryonWeight, G4ParticleTable::FindParticle(), G4VLongitudinalStringDecay::FS_LeftHadron, G4VLongitudinalStringDecay::FS_RightHadron, G4VLongitudinalStringDecay::FS_Weight, G4endl, G4Exception(), G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleSubType(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), JustWarning, lambda(), G4VLongitudinalStringDecay::Meson, G4VLongitudinalStringDecay::MesonWeight, G4VLongitudinalStringDecay::NumberOf_FS, G4VLongitudinalStringDecay::Prob_QQbar, and sqr().

Referenced by SplitLast().

QuarkSplitup()

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

protectedvirtualinherited

Definition at line 335 of file G4VLongitudinalStringDecay.cc.

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

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

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

Sample4Momentum()

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 1270 of file G4LundStringFragmentation.cc.

{
    // ------ Sampling of momenta of 2 last produced hadrons --------------------
    G4ThreeVector Pt;
    G4double MassMt, AntiMassMt;
    G4double AvailablePz, AvailablePz2;
        #ifdef debug_LUNDfragmentation
        G4cout<<"Sampling of momenta of 2 last produced hadrons ----------------"<<G4endl;
        G4cout<<"Init Mass "<<InitialMass<<" FirstM "<<Mass<<" SecondM "<<AntiMass<<" ProbIsotropy "<<G4endl;  
        #endif
 
    G4double r_val = sqr(InitialMass*InitialMass - Mass*Mass - AntiMass*AntiMass) -   
            sqr(2.*Mass*AntiMass);
    G4double Pabs = (r_val > 0.)? std::sqrt(r_val)/(2.*InitialMass) : 0;
 
        const G4int maxNumberOfLoops = 1000;
    G4double SigmaQTw = SigmaQT;
    if ( Mass > 930. || AntiMass > 930. ) {
      SigmaQT *= ( 1.0 - 0.55*sqr( (Mass+AntiMass)/InitialMass ) );
        }
        if ( Mass < 930. && AntiMass < 930. ) {}     // q-qbar string
        if ( ( Mass < 930. && AntiMass > 930. ) ||
         ( Mass > 930. && AntiMass < 930. ) ) {  // q-di_q string
          //SigmaQT = -1.;  // isotropical decay
        }
        if ( Mass > 930. && AntiMass > 930. ) {      // qq-qqbar string
          SigmaQT *= ( 1.0 - 0.55*sqr( (Mass+AntiMass)/InitialMass ) );
        }
 
        G4int loopCounter = 0;
    do
    {
        Pt=SampleQuarkPt(Pabs); Pt.setZ(0); G4double Pt2=Pt.mag2();
        MassMt    = std::sqrt(    Mass *     Mass + Pt2);
        AntiMassMt= std::sqrt(AntiMass * AntiMass + Pt2);
    }
    while ( (InitialMass < MassMt + AntiMassMt) && ++loopCounter < maxNumberOfLoops ); 
 
        SigmaQT = SigmaQTw;
 
        if ( loopCounter >= maxNumberOfLoops ) {
            AvailablePz2 = 0.0;
        }
 
    AvailablePz2= sqr(InitialMass*InitialMass - sqr(MassMt) - sqr(AntiMassMt)) -
                4.*sqr(MassMt*AntiMassMt);
 
    AvailablePz2 /=(4.*InitialMass*InitialMass);
    AvailablePz = std::sqrt(AvailablePz2);
 
    G4double Px=Pt.getX();
    G4double Py=Pt.getY();
 
    Mom->setPx(Px); Mom->setPy(Py); Mom->setPz(AvailablePz);
    Mom->setE(std::sqrt(sqr(MassMt)+AvailablePz2));
 
    AntiMom->setPx(-Px); AntiMom->setPy(-Py); AntiMom->setPz(-AvailablePz);
    AntiMom->setE (std::sqrt(sqr(AntiMassMt)+AvailablePz2));
 
        #ifdef debug_LUNDfragmentation
        G4cout<<"Fmass Mom "<<Mom->getX()<<" "<<Mom->getY()<<" "<<Mom->getZ()<<" "<<Mom->getT()<<G4endl;
        G4cout<<"Smass Mom "<<AntiMom->getX()<<" "<<AntiMom->getY()<<" "<<AntiMom->getZ()
              <<" "<<AntiMom->getT()<<G4endl;
        #endif
}

References G4cout, G4endl, CLHEP::HepLorentzVector::getT(), CLHEP::HepLorentzVector::getX(), CLHEP::Hep3Vector::getX(), CLHEP::HepLorentzVector::getY(), CLHEP::Hep3Vector::getY(), CLHEP::HepLorentzVector::getZ(), CLHEP::Hep3Vector::mag2(), G4VLongitudinalStringDecay::SampleQuarkPt(), CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPx(), CLHEP::HepLorentzVector::setPy(), CLHEP::HepLorentzVector::setPz(), CLHEP::Hep3Vector::setZ(), G4VLongitudinalStringDecay::SigmaQT, and sqr().

Referenced by SplitLast().

SampleInvariantT()

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

virtualinherited

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

Definition at line 69 of file G4HadronicInteraction.cc.

{
  return 0.0;
}

SampleQuarkFlavor()

G4int G4VLongitudinalStringDecay::SampleQuarkFlavor ( void  )

inherited

Definition at line 393 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by G4VLongitudinalStringDecay::CreatePartonPair().

SampleQuarkPt()

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

inherited

Definition at line 416 of file G4VLongitudinalStringDecay.cc.

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

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

Referenced by Sample4Momentum().

SampleState()

G4int G4LundStringFragmentation::SampleState ( void  )

private

Definition at line 1242 of file G4LundStringFragmentation.cc.

{
        if ( NumberOf_FS > 349 ) {
          G4ExceptionDescription ed;
          ed << " NumberOf_FS exceeds its limit: NumberOf_FS=" << NumberOf_FS << G4endl;
          G4Exception( "G4LundStringFragmentation::SampleState ", "HAD_LUND_004", JustWarning, ed );
          NumberOf_FS = 349;
        }
 
    G4double SumWeights=0.;
 
    for (G4int i=0; i<NumberOf_FS; i++) {SumWeights+=FS_Weight[i];}
 
    G4double ksi=G4UniformRand();
    G4double Sum=0.;
    G4int indexPosition = 0;
 
    for (G4int i=0; i<NumberOf_FS; i++)
    {
        Sum+=(FS_Weight[i]/SumWeights);
        indexPosition=i;
        if (Sum >= ksi) break;
    }
    return indexPosition;
}

References G4VLongitudinalStringDecay::FS_Weight, G4endl, G4Exception(), G4UniformRand, JustWarning, and G4VLongitudinalStringDecay::NumberOf_FS.

Referenced by SplitLast().

SetDiquarkBreakProbability()

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability ( G4double  aValue )

inherited

Definition at line 488 of file G4VLongitudinalStringDecay.cc.

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

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

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

SetDiquarkSuppression()

void G4VLongitudinalStringDecay::SetDiquarkSuppression ( G4double  aValue )

inherited

Definition at line 481 of file G4VLongitudinalStringDecay.cc.

{
   DiquarkSuppress = aValue;
}

References G4VLongitudinalStringDecay::DiquarkSuppress.

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

SetEnergyMomentumCheckLevels()

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

inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

  { epCheckLevels.first = relativeLevel;
    epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

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

SetMassCut()

void G4VLongitudinalStringDecay::SetMassCut ( G4double  aValue )

protectedvirtualinherited

Definition at line 139 of file G4VLongitudinalStringDecay.cc.

{ MassCut=aValue; }

References G4VLongitudinalStringDecay::MassCut.

Referenced by FragmentString(), and G4LundStringFragmentation().

SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double  anEnergy )

inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

  { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonINCLXXPhysics::AddProcess(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

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.

  { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4NeutrinoElectronCcModel::IsApplicable(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

SetMinEnergy() [2/3]

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

inherited

Definition at line 101 of file G4HadronicInteraction.cc.

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

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

SetMinEnergy() [3/3]

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

inherited

Definition at line 116 of file G4HadronicInteraction.cc.

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

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

SetMinimalStringMass()

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

inherited

Definition at line 952 of file G4VLongitudinalStringDecay.cc.

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

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

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

SetMinimalStringMass2()

void G4VLongitudinalStringDecay::SetMinimalStringMass2 ( const G4double  aValue )

inherited

Definition at line 1061 of file G4VLongitudinalStringDecay.cc.

{
    MinimalStringMass2=aValue * aValue;
}

References G4VLongitudinalStringDecay::MinimalStringMass2.

Referenced by G4VLongitudinalStringDecay::SetMinimalStringMass().

SetMinMasses()

void G4VLongitudinalStringDecay::SetMinMasses ( )

inherited

Definition at line 609 of file G4VLongitudinalStringDecay.cc.

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

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

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

SetModelName()

void G4HadronicInteraction::SetModelName ( const G4String &  nam )

inlineprotectedinherited

Definition at line 166 of file G4HadronicInteraction.hh.

  { theModelName = nam; }

References G4HadronicInteraction::theModelName.

Referenced by G4ExcitedStringDecay::G4ExcitedStringDecay().

SetProbBBbar()

void G4VLongitudinalStringDecay::SetProbBBbar ( G4double  aValue )

inherited

Definition at line 587 of file G4VLongitudinalStringDecay.cc.

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

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

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

SetProbCCbar()

void G4VLongitudinalStringDecay::SetProbCCbar ( G4double  aValue )

inherited

Definition at line 572 of file G4VLongitudinalStringDecay.cc.

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

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

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

SetProbEta_b()

void G4VLongitudinalStringDecay::SetProbEta_b ( G4double  aValue )

inherited

Definition at line 595 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_b = aValue;
}

References G4VLongitudinalStringDecay::ProbEta_b.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

SetProbEta_c()

void G4VLongitudinalStringDecay::SetProbEta_c ( G4double  aValue )

inherited

Definition at line 580 of file G4VLongitudinalStringDecay.cc.

{
   ProbEta_c = aValue;
}

References G4VLongitudinalStringDecay::ProbEta_c.

Referenced by G4VLongitudinalStringDecay::G4VLongitudinalStringDecay().

SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double  val )

inlineinherited

Definition at line 138 of file G4HadronicInteraction.hh.

  { recoilEnergyThreshold = val; }

References G4HadronicInteraction::recoilEnergyThreshold.

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

SetScalarMesonMixings()

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

inherited

Definition at line 528 of file G4VLongitudinalStringDecay.cc.

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

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

SetSigmaTransverseMomentum()

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum ( G4double  aQT )

inherited

Definition at line 462 of file G4VLongitudinalStringDecay.cc.

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

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

SetSpinThreeHalfBarionProbability()

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability ( G4double  aValue )

inherited

Definition at line 514 of file G4VLongitudinalStringDecay.cc.

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

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

SetStrangenessSuppression()

void G4VLongitudinalStringDecay::SetStrangenessSuppression ( G4double  aValue )

inherited

Definition at line 474 of file G4VLongitudinalStringDecay.cc.

{
   StrangeSuppress = aValue;
}

References G4VLongitudinalStringDecay::StrangeSuppress.

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

SetStringTensionParameter()

void G4VLongitudinalStringDecay::SetStringTensionParameter ( G4double  aValue )

inherited

Definition at line 602 of file G4VLongitudinalStringDecay.cc.

{
   Kappa = aValue * GeV/fermi;
}   

References fermi, GeV, and G4VLongitudinalStringDecay::Kappa.

Referenced by G4LundStringFragmentation().

SetVectorMesonMixings()

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

inherited

Definition at line 550 of file G4VLongitudinalStringDecay.cc.

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

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

SetVectorMesonProbability()

void G4VLongitudinalStringDecay::SetVectorMesonProbability ( G4double  aValue )

inherited

Definition at line 500 of file G4VLongitudinalStringDecay.cc.

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

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

SetVerboseLevel()

void G4HadronicInteraction::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 112 of file G4HadronicInteraction.hh.

  { verboseLevel = value; }

References G4HadronicInteraction::verboseLevel.

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

SplitEandP()

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 513 of file G4LundStringFragmentation.cc.

{ 
    G4LorentzVector String4Momentum=string->Get4Momentum();
    G4double StringMT2=string->MassT2();
    G4double StringMT =std::sqrt(StringMT2);
 
    G4double HadronMass = pHadron->GetPDGMass();
    SetMinimalStringMass(newString);
 
       if ( MinimalStringMass < 0.0 ) return nullptr;
 
        #ifdef debug_LUNDfragmentation
        G4cout<<G4endl<<"Start LUND SplitEandP "<<G4endl;
        G4cout<<"String 4 mom, String M and Mt "<<String4Momentum<<" "<<String4Momentum.mag()
              <<" "<<std::sqrt(StringMT2)<<G4endl;
        G4cout<<"Hadron "<<pHadron->GetParticleName()<<G4endl;
        G4cout<<"HadM MinimalStringMassLeft StringM hM+sM "<<HadronMass<<" "<<MinimalStringMass<<" "
              <<String4Momentum.mag()<<" "<<HadronMass+MinimalStringMass<<G4endl;
        #endif
 
    if ((HadronMass + MinimalStringMass > string->Mass()) || MinimalStringMass < 0.) 
    {
          #ifdef debug_LUNDfragmentation
          G4cout<<"Mass of the string is not sufficient to produce the hadron!"<<G4endl;
          #endif
      return 0;
    }  // have to start all over!
 
    String4Momentum.setPz(0.);
    G4ThreeVector StringPt=String4Momentum.vect();
        StringPt.setZ(0.);
    
    // calculate and assign hadron transverse momentum component HadronPx and HadronPy
    G4ThreeVector HadronPt    , RemSysPt; 
    G4double      HadronMassT2, ResidualMassT2;
    G4double HadronMt, Pt, Pt2, phi;
 
        G4double TmtCur = Tmt;
        if ( (string->GetDecayParton()->GetParticleSubType()== "quark") &&
             (pHadron->GetBaryonNumber() != 0) ) {
          TmtCur = Tmt*0.37;                    // q->B     
        } else if ( (string->GetDecayParton()->GetParticleSubType()== "quark") &&
                    (pHadron->GetBaryonNumber() == 0) ) {
          //TmtCur = Tmt;                               // q->M
    } else if ( (string->GetDecayParton()->GetParticleSubType()== "di_quark") && 
                    (pHadron->GetBaryonNumber() == 0) ) {
          //TmtCur = Tmt*0.89;                          // qq -> M
        } else if ( (string->GetDecayParton()->GetParticleSubType()== "di_quark") &&
                    (pHadron->GetBaryonNumber() != 0) ) {
          TmtCur = Tmt*1.35;                            // qq -> B
        }
 
        //...  sample Pt of the hadron
        G4int attempt=0;
        do
        {
          attempt++; if (attempt > StringLoopInterrupt) {return 0;}
 
          HadronMt = HadronMass - TmtCur*G4Log(G4UniformRand());
      Pt2 = sqr(HadronMt)-sqr(HadronMass); Pt=std::sqrt(Pt2);
      phi = 2.*pi*G4UniformRand();
          HadronPt = G4ThreeVector( Pt*std::cos(phi), Pt*std::sin(phi), 0. );
          RemSysPt = StringPt - HadronPt;
          HadronMassT2 = sqr(HadronMass) + HadronPt.mag2();
          ResidualMassT2=sqr(MinimalStringMass) + RemSysPt.mag2();
 
        } while (std::sqrt(HadronMassT2) + std::sqrt(ResidualMassT2) > StringMT);
 
    //...  sample z to define hadron longitudinal momentum and energy
    //... but first check the available phase space
 
    G4double Pz2 = (sqr(StringMT2 - HadronMassT2 - ResidualMassT2) -
            4*HadronMassT2 * ResidualMassT2)/4./StringMT2;
 
    if (Pz2 < 0 ) {return 0;}          // have to start all over!
 
    //... then compute allowed z region  z_min <= z <= z_max
 
    G4double Pz = std::sqrt(Pz2);
    G4double zMin = (std::sqrt(HadronMassT2+Pz2) - Pz)/std::sqrt(StringMT2);
        // G4double zMin = (std::sqrt(HadronMassT2+Pz2) - 0.)/std::sqrt(StringMT2); // For testing purposes
    G4double zMax = (std::sqrt(HadronMassT2+Pz2) + Pz)/std::sqrt(StringMT2);
 
    if (zMin >= zMax) return 0;     // have to start all over!
 
    G4double z = GetLightConeZ(zMin, zMax, 
                       string->GetDecayParton()->GetPDGEncoding(), pHadron,
                       HadronPt.x(), HadronPt.y());
 
    //... now compute hadron longitudinal momentum and energy
    // longitudinal hadron momentum component HadronPz
 
    HadronPt.setZ(0.5* string->GetDecayDirection() *
               (z * string->LightConeDecay() - 
                    HadronMassT2/(z * string->LightConeDecay())));
    G4double HadronE  = 0.5* (z * string->LightConeDecay() +
                    HadronMassT2/(z * string->LightConeDecay()));
 
    G4LorentzVector * a4Momentum= new G4LorentzVector(HadronPt,HadronE);
 
        #ifdef debug_LUNDfragmentation
        G4cout<<G4endl<<" string->GetDecayDirection() "<<string->GetDecayDirection()<<G4endl<<G4endl;
        G4cout<<"string->LightConeDecay() "<<string->LightConeDecay()<<G4endl;
        G4cout<<"HadronPt,HadronE "<<HadronPt<<" "<<HadronE<<G4endl;
        G4cout<<"String4Momentum "<<String4Momentum<<G4endl;
        G4cout<<"Out of LUND SplitEandP "<<G4endl<<G4endl;
        #endif
 
    return a4Momentum;
}

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

Referenced by Splitup().

SplitLast()

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 684 of file G4LundStringFragmentation.cc.

{
    //... perform last cluster decay
        SetMinimalStringMass( string);
        if ( MinimalStringMass < 0.) return false;
        #ifdef debug_LUNDfragmentation
        G4cout<<G4endl<<"Split last-----------------------------------------"<<G4endl;
        G4cout<<"MinimalStringMass "<<MinimalStringMass<<G4endl;
        G4cout<<"Left  "<<string->GetLeftParton()->GetPDGEncoding()<<" "<<string->GetPleft()<<G4endl;
        G4cout<<"Right "<<string->GetRightParton()->GetPDGEncoding()<<" "<<string->GetPright()<<G4endl;
        G4cout<<"String4mom "<<string->GetPstring()<<" "<<string->GetPstring().mag()<<G4endl;
        #endif
 
        G4LorentzVector Str4Mom=string->Get4Momentum();
        G4LorentzRotation toCms(-1*Str4Mom.boostVector());
        G4LorentzVector Pleft = toCms * string->GetPleft();
        toCms.rotateZ(-1*Pleft.phi());
        toCms.rotateY(-1*Pleft.theta());
    
        G4LorentzRotation toObserverFrame= toCms.inverse();
 
    G4double StringMass=string->Mass();
 
    G4ParticleDefinition * LeftHadron(0), * RightHadron(0);
 
        NumberOf_FS=0;
    for (G4int i=0; i<350; i++) {FS_Weight[i]=0.;}
 
    G4int sampledState = 0;
 
        #ifdef debug_LUNDfragmentation
        G4cout<<"StrMass "<<StringMass<<" q's "
              <<string->GetLeftParton()->GetParticleName()<<" "
              <<string->GetRightParton()->GetParticleName()<<G4endl;
        #endif
 
    string->SetLeftPartonStable(); // to query quark contents..
 
    if (string->IsAFourQuarkString() )
    {
        // The string is qq-qqbar type. Diquarks are on the string ends
            if (StringMass-MinimalStringMass < 0.)
        {
            if (! Diquark_AntiDiquark_belowThreshold_lastSplitting(string, LeftHadron, RightHadron) )
                        {
                return false;
                        }
        } else
        {
            Diquark_AntiDiquark_aboveThreshold_lastSplitting(string, LeftHadron, RightHadron);
 
            if (NumberOf_FS == 0) return false;
 
                        sampledState = SampleState();
            if (string->GetLeftParton()->GetPDGEncoding() < 0)
            {
                LeftHadron =FS_LeftHadron[sampledState];
                RightHadron=FS_RightHadron[sampledState];
            } else
            {
                LeftHadron =FS_RightHadron[sampledState];
                RightHadron=FS_LeftHadron[sampledState];
            }
        }
        } else
    {
        if (string->DecayIsQuark() && string->StableIsQuark() )
        {       //... there are quarks on cluster ends
                        #ifdef debug_LUNDfragmentation
                        G4cout<<"Q Q string LastSplit"<<G4endl;
                        #endif
 
            Quark_AntiQuark_lastSplitting(string, LeftHadron, RightHadron);
        
            if (NumberOf_FS == 0) return false;
                    sampledState = SampleState();
            if (string->GetLeftParton()->GetPDGEncoding() < 0)
            {
                LeftHadron =FS_RightHadron[sampledState];
                RightHadron=FS_LeftHadron[sampledState];
            } else
            {
                LeftHadron =FS_LeftHadron[sampledState];
                RightHadron=FS_RightHadron[sampledState];
            }
        } else 
        {       //... there is a Diquark on one of the cluster ends
                        #ifdef debug_LUNDfragmentation
                        G4cout<<"DiQ Q string Last Split"<<G4endl;
                        #endif
 
            Quark_Diquark_lastSplitting(string, LeftHadron, RightHadron);
 
            if (NumberOf_FS == 0) return false;                           
                    sampledState = SampleState();
 
            if (string->GetLeftParton()->GetParticleSubType() == "quark")
            {
                LeftHadron =FS_LeftHadron[sampledState];
                RightHadron=FS_RightHadron[sampledState];
            } else 
            {
                LeftHadron =FS_RightHadron[sampledState];
                RightHadron=FS_LeftHadron[sampledState];
            }           
        }
 
    }
 
        #ifdef debug_LUNDfragmentation
        G4cout<<"Sampled hadrons: "<<LeftHadron->GetParticleName()<<" "<<RightHadron->GetParticleName()<<G4endl;
        #endif
 
    G4LorentzVector P_left  =string->GetPleft(), P_right = string->GetPright();
 
    G4LorentzVector  LeftMom, RightMom;
    G4ThreeVector    Pos;
 
    Sample4Momentum(&LeftMom,  LeftHadron->GetPDGMass(),
            &RightMom, RightHadron->GetPDGMass(),
            StringMass);
 
        // Sample4Momentum ascribes LeftMom.pz() along positive Z axis for baryons in many cases.
        // It must be negative in case when the system is moving against Z axis.
 
    if (!(string->DecayIsQuark() && string->StableIsQuark() ))
    { // Only for qq - q, q - qq, and qq - qqbar -------------------
 
          if ( G4UniformRand() <= 0.5 )
      {
        if (P_left.z() <= 0.) {G4LorentzVector tmp = LeftMom; LeftMom=RightMom; RightMom=tmp;}
      } 
      else  
      {
        if (P_right.z() >= 0.) {G4LorentzVector tmp = LeftMom; LeftMom=RightMom; RightMom=tmp;}
      }
    }
 
    LeftMom *=toObserverFrame;
    RightMom*=toObserverFrame;
 
    LeftVector->push_back(new G4KineticTrack(LeftHadron, 0, Pos, LeftMom));
    RightVector->push_back(new G4KineticTrack(RightHadron, 0, Pos, RightMom));
 
    string->LorentzRotate(toObserverFrame);
    return true;
}

References CLHEP::HepLorentzVector::boostVector(), G4FragmentingString::DecayIsQuark(), Diquark_AntiDiquark_aboveThreshold_lastSplitting(), Diquark_AntiDiquark_belowThreshold_lastSplitting(), G4VLongitudinalStringDecay::FS_LeftHadron, G4VLongitudinalStringDecay::FS_RightHadron, G4VLongitudinalStringDecay::FS_Weight, G4cout, G4endl, G4UniformRand, G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), CLHEP::HepLorentzRotation::inverse(), G4FragmentingString::IsAFourQuarkString(), G4VLongitudinalStringDecay::MinimalStringMass, G4VLongitudinalStringDecay::NumberOf_FS, CLHEP::HepLorentzVector::phi(), Quark_AntiQuark_lastSplitting(), Quark_Diquark_lastSplitting(), CLHEP::HepLorentzRotation::rotateY(), CLHEP::HepLorentzRotation::rotateZ(), Sample4Momentum(), SampleState(), G4VLongitudinalStringDecay::SetMinimalStringMass(), G4FragmentingString::StableIsQuark(), CLHEP::HepLorentzVector::theta(), and CLHEP::HepLorentzVector::z().

Referenced by Loop_toFragmentString().

Splitup()

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

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 340 of file G4LundStringFragmentation.cc.

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

References G4FragmentingString::DecayIsQuark(), DiQuarkSplitup(), G4cout, G4endl, G4UniformRand, G4FragmentingString::GetDecayParton(), G4VLongitudinalStringDecay::GetDiquarkSuppress(), G4Pow::GetInstance(), G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetPDGEncoding(), G4FragmentingString::GetRightParton(), G4VLongitudinalStringDecay::GetStrangeSuppress(), G4Pow::powA(), G4VLongitudinalStringDecay::QuarkSplitup(), G4VLongitudinalStringDecay::SetDiquarkSuppression(), G4VLongitudinalStringDecay::SetStrangenessSuppression(), SplitEandP(), and sqr().

Referenced by Loop_toFragmentString().

StopFragmenting()

G4bool G4LundStringFragmentation::StopFragmenting ( const G4FragmentingString *const  string )

privatevirtual

Implements G4VLongitudinalStringDecay.

Definition at line 312 of file G4LundStringFragmentation.cc.

{
    SetMinimalStringMass(string); 
 
    if ( MinimalStringMass < 0.) return true;
 
    if (string->IsAFourQuarkString())
    {
        return G4UniformRand() < G4Exp(-0.0005*(string->Mass() - MinimalStringMass));
    } else {
           
                if (MinimalStringMass < 0.0 ) return false;  // For a string with di-quark having c or b quarks and s, c, b quarks
 
        G4bool Result = G4UniformRand() < 
                G4Exp(-0.66e-6*(string->Mass()*string->Mass() - MinimalStringMass*MinimalStringMass));
                // G4bool Result = string->Mass() < MinimalStringMass + 150.*MeV*G4UniformRand();     // a'la LUND
 
                #ifdef debug_LUNDfragmentation 
                G4cout<<"StopFragmenting MinimalStringMass string->Mass() "<<MinimalStringMass
                      <<" "<<string->Mass()<<G4endl;
                G4cout<<"StopFragmenting - Yes/No "<<Result<<G4endl;
                #endif  
        return Result;
    }
}

References G4cout, G4endl, G4Exp(), G4UniformRand, G4FragmentingString::IsAFourQuarkString(), G4FragmentingString::Mass(), G4VLongitudinalStringDecay::MinimalStringMass, and G4VLongitudinalStringDecay::SetMinimalStringMass().

Referenced by Loop_toFragmentString().

Field Documentation

Baryon

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

inherited

Definition at line 236 of file G4VLongitudinalStringDecay.hh.

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

BaryonWeight

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

inherited

Definition at line 237 of file G4VLongitudinalStringDecay.hh.

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

ClusterLoopInterrupt

G4int G4VLongitudinalStringDecay::ClusterLoopInterrupt

protectedinherited

Definition at line 192 of file G4VLongitudinalStringDecay.hh.

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

DecayQuark

G4int G4VLongitudinalStringDecay::DecayQuark

inherited

Definition at line 241 of file G4VLongitudinalStringDecay.hh.

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

DiquarkBreakProb

G4double G4VLongitudinalStringDecay::DiquarkBreakProb

protectedinherited

Definition at line 189 of file G4VLongitudinalStringDecay.hh.

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

DiquarkSuppress

G4double G4VLongitudinalStringDecay::DiquarkSuppress

protectedinherited

Definition at line 188 of file G4VLongitudinalStringDecay.hh.

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

epCheckLevels

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

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

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

FS_LeftHadron

G4ParticleDefinition* G4VLongitudinalStringDecay::FS_LeftHadron[350]

inherited

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

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

FS_RightHadron

G4ParticleDefinition * G4VLongitudinalStringDecay::FS_RightHadron[350]

inherited

Definition at line 251 of file G4VLongitudinalStringDecay.hh.

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

FS_Weight

G4double G4VLongitudinalStringDecay::FS_Weight[350]

inherited

Definition at line 252 of file G4VLongitudinalStringDecay.hh.

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

hadronizer

G4HadronBuilder* G4VLongitudinalStringDecay::hadronizer

protectedinherited

Definition at line 194 of file G4VLongitudinalStringDecay.hh.

Referenced by Diquark_AntiDiquark_belowThreshold_lastSplitting(), DiQuarkSplitup(), G4QGSMFragmentation::DiQuarkSplitup(), G4VLongitudinalStringDecay::G4VLongitudinalStringDecay(), G4VLongitudinalStringDecay::PossibleHadronMass(), G4VLongitudinalStringDecay::QuarkSplitup(), G4VLongitudinalStringDecay::SetScalarMesonMixings(), G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(), G4VLongitudinalStringDecay::SetVectorMesonMixings(), G4VLongitudinalStringDecay::SetVectorMesonProbability(), G4QGSMFragmentation::SplitLast(), and G4VLongitudinalStringDecay::~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

protectedinherited

Definition at line 213 of file G4VLongitudinalStringDecay.hh.

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

Mass_of_b_quark

G4double G4VLongitudinalStringDecay::Mass_of_b_quark

inherited

Definition at line 222 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

Mass_of_c_quark

G4double G4VLongitudinalStringDecay::Mass_of_c_quark

inherited

Definition at line 221 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

Mass_of_light_quark

G4double G4VLongitudinalStringDecay::Mass_of_light_quark

inherited

Definition at line 219 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

Mass_of_s_quark

G4double G4VLongitudinalStringDecay::Mass_of_s_quark

inherited

Definition at line 220 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

Mass_of_string_junction

G4double G4VLongitudinalStringDecay::Mass_of_string_junction

inherited

Definition at line 223 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::SetMinMasses().

MassCut

G4double G4VLongitudinalStringDecay::MassCut

protectedinherited

Definition at line 186 of file G4VLongitudinalStringDecay.hh.

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

MaxMass

G4double G4VLongitudinalStringDecay::MaxMass

protectedinherited

Definition at line 209 of file G4VLongitudinalStringDecay.hh.

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

Meson

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

inherited

Definition at line 233 of file G4VLongitudinalStringDecay.hh.

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

MesonWeight

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

inherited

Definition at line 234 of file G4VLongitudinalStringDecay.hh.

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

MinimalStringMass

G4double G4VLongitudinalStringDecay::MinimalStringMass

inherited

Definition at line 229 of file G4VLongitudinalStringDecay.hh.

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

MinimalStringMass2

G4double G4VLongitudinalStringDecay::MinimalStringMass2

inherited

Definition at line 230 of file G4VLongitudinalStringDecay.hh.

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

minMassQDiQStr

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

inherited

Definition at line 226 of file G4VLongitudinalStringDecay.hh.

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

minMassQQbarStr

G4double G4VLongitudinalStringDecay::minMassQQbarStr[5][5]

inherited

Definition at line 225 of file G4VLongitudinalStringDecay.hh.

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

NewParticles

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

protectedinherited

Definition at line 215 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay::FindParticle().

NewQuark

G4int G4VLongitudinalStringDecay::NewQuark

inherited

Definition at line 242 of file G4VLongitudinalStringDecay.hh.

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

NumberOf_FS

G4int G4VLongitudinalStringDecay::NumberOf_FS

inherited

Definition at line 253 of file G4VLongitudinalStringDecay.hh.

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

PastInitPhase

G4bool G4VLongitudinalStringDecay::PastInitPhase

protectedinherited

Definition at line 211 of file G4VLongitudinalStringDecay.hh.

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

Prob_QQbar

G4double G4VLongitudinalStringDecay::Prob_QQbar[5]

inherited

Definition at line 239 of file G4VLongitudinalStringDecay.hh.

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

ProbBBbar

G4double G4VLongitudinalStringDecay::ProbBBbar

protectedinherited

Definition at line 204 of file G4VLongitudinalStringDecay.hh.

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

ProbCB

G4double G4VLongitudinalStringDecay::ProbCB

protectedinherited

Definition at line 207 of file G4VLongitudinalStringDecay.hh.

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

ProbCCbar

G4double G4VLongitudinalStringDecay::ProbCCbar

protectedinherited

Definition at line 201 of file G4VLongitudinalStringDecay.hh.

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

ProbEta_b

G4double G4VLongitudinalStringDecay::ProbEta_b

protectedinherited

Definition at line 205 of file G4VLongitudinalStringDecay.hh.

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

ProbEta_c

G4double G4VLongitudinalStringDecay::ProbEta_c

protectedinherited

Definition at line 202 of file G4VLongitudinalStringDecay.hh.

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

pspin_barion

G4double G4VLongitudinalStringDecay::pspin_barion

protectedinherited

Definition at line 197 of file G4VLongitudinalStringDecay.hh.

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

pspin_meson

G4double G4VLongitudinalStringDecay::pspin_meson

protectedinherited

Definition at line 196 of file G4VLongitudinalStringDecay.hh.

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

Qcharge

G4int G4VLongitudinalStringDecay::Qcharge[5]

inherited

Definition at line 232 of file G4VLongitudinalStringDecay.hh.

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

recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold

privateinherited

Definition at line 194 of file G4HadronicInteraction.hh.

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

registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry

privateinherited

Definition at line 192 of file G4HadronicInteraction.hh.

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

scalarMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::scalarMesonMix

protectedinherited

Definition at line 199 of file G4VLongitudinalStringDecay.hh.

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

SigmaQT

G4double G4VLongitudinalStringDecay::SigmaQT

protectedinherited

Definition at line 187 of file G4VLongitudinalStringDecay.hh.

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

StrangeSuppress

G4double G4VLongitudinalStringDecay::StrangeSuppress

protectedinherited

Definition at line 190 of file G4VLongitudinalStringDecay.hh.

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

StringLoopInterrupt

G4int G4VLongitudinalStringDecay::StringLoopInterrupt

protectedinherited

Definition at line 191 of file G4VLongitudinalStringDecay.hh.

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

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4ElectroVDNuclearModel::ApplyYourself(), G4ParticleHPThermalScattering::ApplyYourself(), G4NeutrinoElectronNcModel::ApplyYourself(), G4NeutronElectronElModel::ApplyYourself(), G4LFission::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4MuonVDNuclearModel::ApplyYourself(), G4NeutrinoElectronCcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4ElectroVDNuclearModel::CalculateEMVertex(), G4MuonVDNuclearModel::CalculateEMVertex(), G4ElectroVDNuclearModel::CalculateHadronicVertex(), G4MuonVDNuclearModel::CalculateHadronicVertex(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::copyOutputToHadronicResult(), G4BinaryCascade::DebugEpConservation(), G4BinaryCascade::DebugFinalEpConservation(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), G4WilsonAbrasionModel::GetAbradedNucleons(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4NeutrinoNucleusModel::RecoilDeexcitation(), G4LEHadronProtonElastic::~G4LEHadronProtonElastic(), G4LEnp::~G4LEnp(), and G4LFission::~G4LFission().

Tmt

G4double G4LundStringFragmentation::Tmt

private

Definition at line 111 of file G4LundStringFragmentation.hh.

Referenced by G4LundStringFragmentation(), and SplitEandP().

vectorMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::vectorMesonMix

protectedinherited

Definition at line 198 of file G4VLongitudinalStringDecay.hh.

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

verboseLevel

G4int G4HadronicInteraction::verboseLevel

protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LFission::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4CascadeInterface::checkFinalResult(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4LENDModel::create_used_target_map(), G4CascadeInterface::createBullet(), G4CascadeInterface::createTarget(), G4ElasticHadrNucleusHE::DefineHadronValues(), G4ElasticHadrNucleusHE::FillData(), G4ElasticHadrNucleusHE::FillFq2(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE(), G4EMDissociation::G4EMDissociation(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4ElasticHadrNucleusHE::GetFt(), G4ElasticHadrNucleusHE::GetLightFq2(), G4ElasticHadrNucleusHE::GetQ2_2(), G4HadronicInteraction::GetVerboseLevel(), G4ElasticHadrNucleusHE::HadronNucleusQ2_2(), G4ElasticHadrNucleusHE::HadronProtonQ2(), G4LFission::init(), G4DiffuseElastic::Initialise(), G4DiffuseElasticV2::Initialise(), G4NuclNuclDiffuseElastic::Initialise(), G4DiffuseElastic::InitialiseOnFly(), G4DiffuseElasticV2::InitialiseOnFly(), G4NuclNuclDiffuseElastic::InitialiseOnFly(), G4CascadeInterface::makeDynamicParticle(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4ElasticHadrNucleusHE::SampleInvariantT(), G4AntiNuclElastic::SampleThetaCMS(), G4DiffuseElastic::SampleThetaLab(), G4NuclNuclDiffuseElastic::SampleThetaLab(), G4AntiNuclElastic::SampleThetaLab(), G4WilsonAbrasionModel::SetUseAblation(), G4HadronicInteraction::SetVerboseLevel(), G4WilsonAbrasionModel::SetVerboseLevel(), G4DiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElasticV2::ThetaCMStoThetaLab(), G4NuclNuclDiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElastic::ThetaLabToThetaCMS(), G4DiffuseElasticV2::ThetaLabToThetaCMS(), and G4NuclNuclDiffuseElastic::ThetaLabToThetaCMS().

---

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

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