G4VLongitudinalStringDecay Class Reference

#include <G4VLongitudinalStringDecay.hh>

Inheritance diagram for G4VLongitudinalStringDecay:

Public Member Functions
	G4VLongitudinalStringDecay ()
virtual	~G4VLongitudinalStringDecay ()
virtual G4KineticTrackVector *	FragmentString (const G4ExcitedString &theString)=0
G4int	SampleQuarkFlavor (void)
G4ThreeVector	SampleQuarkPt (G4double ptMax=-1.)
G4KineticTrackVector *	DecayResonans (G4KineticTrackVector *aHadrons)
void	SetSigmaTransverseMomentum (G4double aQT)
void	SetStrangenessSuppression (G4double aValue)
void	SetDiquarkSuppression (G4double aValue)
void	SetDiquarkBreakProbability (G4double aValue)
void	SetVectorMesonProbability (G4double aValue)
void	SetSpinThreeHalfBarionProbability (G4double aValue)
void	SetScalarMesonMixings (std::vector< G4double > aVector)
void	SetVectorMesonMixings (std::vector< G4double > aVector)
void	SetStringTensionParameter (G4double aValue)

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

Protected Member Functions
virtual void	SetMassCut (G4double aValue)
G4KineticTrackVector *	LightFragmentationTest (const G4ExcitedString *const theString)
G4double	FragmentationMass (const G4FragmentingString *const string, Pcreate build=0, pDefPair *pdefs=0)
G4ParticleDefinition *	FindParticle (G4int Encoding)
virtual void	Sample4Momentum (G4LorentzVector *Mom, G4double Mass, G4LorentzVector *AntiMom, G4double AntiMass, G4double InitialMass)=0
virtual G4bool	StopFragmenting (const G4FragmentingString *const string)=0
virtual G4bool	IsFragmentable (const G4FragmentingString *const string)=0
virtual G4bool	SplitLast (G4FragmentingString *string, G4KineticTrackVector *LeftVector, G4KineticTrackVector *RightVector)=0
G4ExcitedString *	CPExcited (const G4ExcitedString &string)
G4KineticTrack *	Splitup (G4FragmentingString *string, G4FragmentingString *&newString)
G4ParticleDefinition *	QuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
G4ParticleDefinition *	DiQuarkSplitup (G4ParticleDefinition *decay, G4ParticleDefinition *&created)
pDefPair	CreatePartonPair (G4int NeedParticle, G4bool AllowDiquarks=true)
virtual G4LorentzVector *	SplitEandP (G4ParticleDefinition *pHadron, G4FragmentingString *string, G4FragmentingString *newString)=0
virtual G4double	GetLightConeZ (G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition *pHadron, G4double Px, G4double Py)=0
void	CalculateHadronTimePosition (G4double theInitialStringMass, G4KineticTrackVector *)
void	ConstructParticle ()
G4ParticleDefinition *	CreateHadron (G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin)
G4double	GetDiquarkSuppress ()
G4double	GetDiquarkBreakProb ()
G4double	GetStrangeSuppress ()
G4double	GetClusterMass ()
G4int	GetClusterLoopInterrupt ()
G4double	GetStringTensionParameter ()

Protected Attributes
G4double	MassCut
G4double	ClusterMass
G4double	SigmaQT
G4double	DiquarkSuppress
G4double	DiquarkBreakProb
G4double	SmoothParam
G4double	StrangeSuppress
G4int	StringLoopInterrupt
G4int	ClusterLoopInterrupt
G4HadronBuilder *	hadronizer
G4double	pspin_meson
G4double	pspin_barion
std::vector< G4double >	vectorMesonMix
std::vector< G4double >	scalarMesonMix
G4bool	PastInitPhase
G4double	Kappa

Detailed Description

Definition at line 46 of file G4VLongitudinalStringDecay.hh.

Member Typedef Documentation

Pcreate

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

protected

Definition at line 74 of file G4VLongitudinalStringDecay.hh.

pDefPair

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

protected

Definition at line 71 of file G4VLongitudinalStringDecay.hh.

Constructor & Destructor Documentation

G4VLongitudinalStringDecay()

G4VLongitudinalStringDecay::G4VLongitudinalStringDecay

(

)

Definition at line 64 of file G4VLongitudinalStringDecay.cc.

{
   MassCut  = 0.35*GeV; 
   ClusterMass = 0.15*GeV;
 
   SmoothParam      = 0.9; 
   StringLoopInterrupt    = 1000;
   ClusterLoopInterrupt   =  500;
 
// Changable Parameters below.
   SigmaQT = 0.5 * GeV;  // 0.5 0.1
   
   StrangeSuppress  = 0.44;    //  27 % strange quarks produced, ie. u:d:s=1:1:0.27
   DiquarkSuppress  = 0.07;
   DiquarkBreakProb = 0.1;
   
   //... pspin_meson is probability to create vector meson 
   pspin_meson = 0.5;
 
   //... pspin_barion is probability to create 3/2 barion 
   pspin_barion = 0.5;
 
   //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
   vectorMesonMix.resize(6);
   vectorMesonMix[0] = 0.5;
   vectorMesonMix[1] = 0.0;
   vectorMesonMix[2] = 0.5;
   vectorMesonMix[3] = 0.0;
   vectorMesonMix[4] = 1.0;
   vectorMesonMix[5] = 1.0; 
 
   //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
   scalarMesonMix.resize(6);
   scalarMesonMix[0] = 0.5; 
   scalarMesonMix[1] = 0.25; 
   scalarMesonMix[2] = 0.5; 
   scalarMesonMix[3] = 0.25; 
   scalarMesonMix[4] = 1.0; 
   scalarMesonMix[5] = 0.5; 
 
// Parameters may be changed until the first fragmentation starts
   PastInitPhase=false;
   hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
                scalarMesonMix,vectorMesonMix);
   Kappa = 1.0 * GeV/fermi;
 
 
}

~G4VLongitudinalStringDecay()

G4VLongitudinalStringDecay::~G4VLongitudinalStringDecay ( )

virtual

Definition at line 114 of file G4VLongitudinalStringDecay.cc.

   {
   delete hadronizer;
   }

Member Function Documentation

CalculateHadronTimePosition()

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

protected

Definition at line 486 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);
 
      } 
   }

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

ConstructParticle()

void G4VLongitudinalStringDecay::ConstructParticle ( )

protected

CPExcited()

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

protected

Definition at line 315 of file G4VLongitudinalStringDecay.cc.

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

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

CreateHadron()

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

protected

CreatePartonPair()

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

protected

Definition at line 445 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
      G4int q1  = SampleQuarkFlavor();
      G4int q2  = SampleQuarkFlavor();
      G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
                                     //   convention: quark with higher PDG number is first
      G4int 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
      G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
      return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
    }
 
}

Referenced by DiQuarkSplitup(), and QuarkSplitup().

DecayResonans()

G4KineticTrackVector * G4VLongitudinalStringDecay::DecayResonans

(

G4KineticTrackVector *

aHadrons

)

DiQuarkSplitup()

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

protected

Definition at line 390 of file G4VLongitudinalStringDecay.cc.

{
   //... can Diquark break or not? 
   if (G4UniformRand() < DiquarkBreakProb ){
   //... Diquark break
 
      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
      if (G4UniformRand() < 0.5)
         {
         G4int Swap = stableQuarkEncoding;
         stableQuarkEncoding = decayQuarkEncoding;
         decayQuarkEncoding = Swap;
         }
 
      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1; 
            // if we have a quark, we need antiquark)
      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);
      return had;
//      return hadronizer->Build(QuarkPair.first, decayQuark);
   
   } else {
   //... Diquark does not break
 
      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1; 
            // if we have a diquark, we need quark)
      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
      created = QuarkPair.second;
 
      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
      return had;
//      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
   }
}

Referenced by Splitup().

FindParticle()

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int  Encoding )

protected

Definition at line 282 of file G4VLongitudinalStringDecay.cc.

   {
   G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
      if (ptr == NULL)
       {
       G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
       throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
       }
   return ptr;    
   }

Referenced by CreatePartonPair(), DiQuarkSplitup(), and FragmentationMass().

FragmentationMass()

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

protected

Definition at line 224 of file G4VLongitudinalStringDecay.cc.

{
    
        G4double mass;
        static G4bool NeedInit(true);
    static std::vector<double> nomix;
    static G4HadronBuilder * minMassHadronizer;
    if ( NeedInit ) 
    {
       NeedInit = false;
       nomix.resize(6);
       for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
 
//     minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
       minMassHadronizer=hadronizer;
    }
 
    if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
 
        G4ParticleDefinition *Hadron1, *Hadron2=0;
 
        if (!string->FourQuarkString() )
        {
           // spin 0 meson or spin 1/2 barion will be built
 
//G4cout<<"String Left Right "<<string->GetLeftParton()<<" "<<string->GetRightParton()<<G4endl;
           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
                                     string->GetRightParton());
//G4cout<<"Hadron1 "<<Hadron1->GetParticleName()<<G4endl;
           mass= (Hadron1)->GetPDGMass();
        } else
        {
           //... string is qq--qqbar: Build two stable hadrons,
           //...    with extra uubar or ddbar quark pair
       G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
       if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
 
       //... theSpin = 4; spin 3/2 baryons will be built
       Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
                                                 FindParticle(iflc)       );
       Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
                                                 FindParticle(-iflc)      );
           mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
        }
    
    if ( pdefs != 0 ) 
    { // need to return hadrons as well....
       pdefs->first  = Hadron1;
       pdefs->second = Hadron2;
    }
       
        return mass;
}

Referenced by LightFragmentationTest().

FragmentString()

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

pure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Referenced by G4VKinkyStringDecay::FragmentString().

GetClusterLoopInterrupt()

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt ( )

inlineprotected

Definition at line 170 of file G4VLongitudinalStringDecay.hh.

{return ClusterLoopInterrupt;};

GetClusterMass()

G4double G4VLongitudinalStringDecay::GetClusterMass ( )

inlineprotected

Definition at line 169 of file G4VLongitudinalStringDecay.hh.

{return ClusterMass;};

GetDiquarkBreakProb()

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb ( )

inlineprotected

Definition at line 167 of file G4VLongitudinalStringDecay.hh.

{return DiquarkBreakProb;};

GetDiquarkSuppress()

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress ( )

inlineprotected

Definition at line 166 of file G4VLongitudinalStringDecay.hh.

{return DiquarkSuppress;};

GetLightConeZ()

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

protectedpure virtual

GetStrangeSuppress()

G4double G4VLongitudinalStringDecay::GetStrangeSuppress ( )

inlineprotected

Definition at line 168 of file G4VLongitudinalStringDecay.hh.

{return StrangeSuppress;};

GetStringTensionParameter()

G4double G4VLongitudinalStringDecay::GetStringTensionParameter ( )

inlineprotected

Definition at line 172 of file G4VLongitudinalStringDecay.hh.

{return Kappa;};       // Uzhi 20 June 08

Referenced by CalculateHadronTimePosition().

IsFragmentable()

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

protectedpure virtual

LightFragmentationTest()

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

protected

Definition at line 152 of file G4VLongitudinalStringDecay.cc.

{
   // Check string decay threshold
        
    G4KineticTrackVector * result=0;  // return 0 when string exceeds the mass cut
    
    pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
 
    G4FragmentingString aString(*string);
 
    if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
        return 0;
    }
 
// The string mass is very low ---------------------------
    
    result=new G4KineticTrackVector;
        
    if ( hadrons.second ==0 )
    {
// Substitute string by light hadron, Note that Energy is not conserved here!
 
/*       
#ifdef DEBUG_LightFragmentationTest
           G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
           G4cout << hadrons.first->GetParticleName() 
              << "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_LightFragmentationTest
           G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons " 
              << 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;
    
}

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

QuarkSplitup()

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

protected

Definition at line 376 of file G4VLongitudinalStringDecay.cc.

{
    G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark, 
                                                            // we need antiquark 
                                                            // (or diquark)
    pDefPair QuarkPair = CreatePartonPair(IsParticle);
    created = QuarkPair.second;
    return hadronizer->Build(QuarkPair.first, decay);
    
}

Referenced by Splitup().

Sample4Momentum()

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

protectedpure virtual

Referenced by LightFragmentationTest().

SampleQuarkFlavor()

G4int G4VLongitudinalStringDecay::SampleQuarkFlavor

(

void

)

Definition at line 438 of file G4VLongitudinalStringDecay.cc.

   {
   return (1 + (int)(G4UniformRand()/StrangeSuppress));
   }

Referenced by CreatePartonPair(), and G4VKinkyStringDecay::FragmentString().

SampleQuarkPt()

G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt

(

G4double

ptMax = -1.

)

Definition at line 469 of file G4VLongitudinalStringDecay.cc.

   {
   G4double Pt;
   if ( ptMax < 0 ) {
      // sample full gaussian
      Pt = -std::log(G4UniformRand());
   } else {
      // sample in limited range
      Pt = -std::log(CLHEP::RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
   }
   Pt = SigmaQT * std::sqrt(Pt);
   G4double phi = 2.*pi*G4UniformRand();
   return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
   }

Referenced by G4VKinkyStringDecay::FragmentString().

SetDiquarkBreakProbability()

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability

(

G4double

aValue

)

Definition at line 548 of file G4VLongitudinalStringDecay.cc.

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

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

SetDiquarkSuppression()

void G4VLongitudinalStringDecay::SetDiquarkSuppression

(

G4double

aValue

)

Definition at line 537 of file G4VLongitudinalStringDecay.cc.

{
    if ( PastInitPhase ) {
        throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkSuppression after FragmentString() not allowed");
    } else {
        DiquarkSuppress = aValue;
    }
}

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

SetMassCut()

void G4VLongitudinalStringDecay::SetMassCut ( G4double  aValue )

protectedvirtual

Definition at line 146 of file G4VLongitudinalStringDecay.cc.

{MassCut=aValue;}

Referenced by G4LundStringFragmentation::FragmentString().

SetScalarMesonMixings()

void G4VLongitudinalStringDecay::SetScalarMesonMixings

(

std::vector< G4double >

aVector

)

Definition at line 587 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);
    }
}

SetSigmaTransverseMomentum()

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum

(

G4double

aQT

)

Definition at line 515 of file G4VLongitudinalStringDecay.cc.

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

SetSpinThreeHalfBarionProbability()

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability

(

G4double

aValue

)

Definition at line 573 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);
    }
}

SetStrangenessSuppression()

void G4VLongitudinalStringDecay::SetStrangenessSuppression

(

G4double

aValue

)

Definition at line 526 of file G4VLongitudinalStringDecay.cc.

{
    if ( PastInitPhase ) {
        throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
    } else {
        StrangeSuppress = aValue;
    }
}

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

SetStringTensionParameter()

void G4VLongitudinalStringDecay::SetStringTensionParameter

(

G4double

aValue

)

Definition at line 629 of file G4VLongitudinalStringDecay.cc.

{
          Kappa = aValue * GeV/fermi;
}   

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

SetVectorMesonMixings()

void G4VLongitudinalStringDecay::SetVectorMesonMixings

(

std::vector< G4double >

aVector

)

Definition at line 608 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);
  
    }
}

SetVectorMesonProbability()

void G4VLongitudinalStringDecay::SetVectorMesonProbability

(

G4double

aValue

)

Definition at line 559 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);
    }
}

SplitEandP()

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

protectedpure virtual

Referenced by Splitup().

SplitLast()

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

protectedpure virtual

Splitup()

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

protected

Definition at line 324 of file G4VLongitudinalStringDecay.cc.

{
//G4cout<<"Start SplitUP"<<G4endl;
       //... random choice of string end to use for creating the hadron (decay)   
       G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
       if (SideOfDecay < 0)
       {
      string->SetLeftPartonStable();
       } else
       {
          string->SetRightPartonStable();
       }
 
       G4ParticleDefinition *newStringEnd;
       G4ParticleDefinition * HadronDefinition;
       if (string->DecayIsQuark())
       {
           HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
       } else {
           HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
       }      
 
//G4cout<<"New had "<<HadronDefinition->GetParticleName()<<G4endl;
// create new String from old, ie. keep Left and Right order, but replace decay
 
       newString=new G4FragmentingString(*string,newStringEnd); // To store possible
                                                                // quark containt of new string
//G4cout<<"SplitEandP "<<G4endl;
       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
 
       delete newString; newString=0;                          
    
       G4KineticTrack * Hadron =0;
       if ( HadronMomentum != 0 ) {    
 
       G4ThreeVector   Pos;
       Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
 
       newString=new G4FragmentingString(*string,newStringEnd,
                    HadronMomentum);
 
       delete HadronMomentum;
       }      
//G4cout<<"End SplitUP"<<G4endl;
       return Hadron;
}

Referenced by G4QGSMFragmentation::FragmentString().

StopFragmenting()

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

protectedpure virtual

Member Data Documentation

ClusterLoopInterrupt

G4int G4VLongitudinalStringDecay::ClusterLoopInterrupt

protected

Definition at line 184 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), and GetClusterLoopInterrupt().

ClusterMass

G4double G4VLongitudinalStringDecay::ClusterMass

protected

Definition at line 177 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), and GetClusterMass().

DiquarkBreakProb

G4double G4VLongitudinalStringDecay::DiquarkBreakProb

protected

Definition at line 180 of file G4VLongitudinalStringDecay.hh.

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

DiquarkSuppress

G4double G4VLongitudinalStringDecay::DiquarkSuppress

protected

Definition at line 179 of file G4VLongitudinalStringDecay.hh.

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

hadronizer

G4HadronBuilder* G4VLongitudinalStringDecay::hadronizer

protected

Definition at line 185 of file G4VLongitudinalStringDecay.hh.

Referenced by DiQuarkSplitup(), FragmentationMass(), G4VLongitudinalStringDecay(), QuarkSplitup(), SetScalarMesonMixings(), SetSpinThreeHalfBarionProbability(), SetVectorMesonMixings(), SetVectorMesonProbability(), and ~G4VLongitudinalStringDecay().

Kappa

G4double G4VLongitudinalStringDecay::Kappa

protected

Definition at line 194 of file G4VLongitudinalStringDecay.hh.

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

MassCut

G4double G4VLongitudinalStringDecay::MassCut

protected

Definition at line 176 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), LightFragmentationTest(), and SetMassCut().

PastInitPhase

G4bool G4VLongitudinalStringDecay::PastInitPhase

protected

Definition at line 192 of file G4VLongitudinalStringDecay.hh.

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

pspin_barion

G4double G4VLongitudinalStringDecay::pspin_barion

protected

Definition at line 188 of file G4VLongitudinalStringDecay.hh.

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

pspin_meson

G4double G4VLongitudinalStringDecay::pspin_meson

protected

Definition at line 187 of file G4VLongitudinalStringDecay.hh.

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

scalarMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::scalarMesonMix

protected

Definition at line 190 of file G4VLongitudinalStringDecay.hh.

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

SigmaQT

G4double G4VLongitudinalStringDecay::SigmaQT

protected

Definition at line 178 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), SampleQuarkPt(), and SetSigmaTransverseMomentum().

SmoothParam

G4double G4VLongitudinalStringDecay::SmoothParam

protected

Definition at line 181 of file G4VLongitudinalStringDecay.hh.

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

StrangeSuppress

G4double G4VLongitudinalStringDecay::StrangeSuppress

protected

Definition at line 182 of file G4VLongitudinalStringDecay.hh.

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

StringLoopInterrupt

G4int G4VLongitudinalStringDecay::StringLoopInterrupt

protected

Definition at line 183 of file G4VLongitudinalStringDecay.hh.

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

vectorMesonMix

std::vector<G4double> G4VLongitudinalStringDecay::vectorMesonMix

protected

Definition at line 189 of file G4VLongitudinalStringDecay.hh.

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

---

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

• G4VLongitudinalStringDecay.hh
• G4VLongitudinalStringDecay.cc