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

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

protected

Definition at line 75 of file G4VLongitudinalStringDecay.hh.

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

protected

Definition at line 71 of file G4VLongitudinalStringDecay.hh.

Constructor & Destructor Documentation

G4VLongitudinalStringDecay::G4VLongitudinalStringDecay

(

)

Definition at line 63 of file G4VLongitudinalStringDecay.cc.

References ClusterLoopInterrupt, ClusterMass, DiquarkBreakProb, DiquarkSuppress, python.hepunit::fermi, python.hepunit::GeV, hadronizer, Kappa, MassCut, PastInitPhase, pspin_barion, pspin_meson, scalarMesonMix, SigmaQT, SmoothParam, StrangeSuppress, StringLoopInterrupt, and vectorMesonMix.

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

virtual

Definition at line 113 of file G4VLongitudinalStringDecay.cc.

References hadronizer.

   {
   delete hadronizer;
   }

Member Function Documentation

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

protected

Definition at line 485 of file G4VLongitudinalStringDecay.cc.

References plottest35::c1, python.hepunit::c_light, and GetStringTensionParameter().

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

   {

//   `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);

      } 
   }

void G4VLongitudinalStringDecay::ConstructParticle ( )

protected

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

protected

Definition at line 314 of file G4VLongitudinalStringDecay.cc.

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

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

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

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

protected

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

protected

Definition at line 444 of file G4VLongitudinalStringDecay.cc.

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

Referenced by DiQuarkSplitup(), and QuarkSplitup().

{
//  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));
    }

}

G4KineticTrackVector* G4VLongitudinalStringDecay::DecayResonans

(

G4KineticTrackVector *

aHadrons

)

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

protected

Definition at line 389 of file G4VLongitudinalStringDecay.cc.

References G4HadronBuilder::Build(), CreatePartonPair(), DiquarkBreakProb, FindParticle(), G4UniformRand, G4ParticleDefinition::GetPDGEncoding(), hadronizer, G4INCL::Math::max(), and G4INCL::Math::min().

Referenced by Splitup().

{
   //... 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);
   }
}

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int  Encoding )

protected

Definition at line 281 of file G4VLongitudinalStringDecay.cc.

References G4ParticleTable::FindParticle(), G4cout, G4endl, and G4ParticleTable::GetParticleTable().

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

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

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

protected

Definition at line 223 of file G4VLongitudinalStringDecay.cc.

References G4HadronBuilder::BuildLowSpin(), FindParticle(), G4FragmentingString::FourQuarkString(), G4ThreadLocal, G4UniformRand, G4FragmentingString::GetLeftParton(), G4ParticleDefinition::GetPDGEncoding(), G4FragmentingString::GetRightParton(), and hadronizer.

Referenced by LightFragmentationTest().

{
    
        G4double mass;
        static G4ThreadLocal G4bool NeedInit(true);
    static G4ThreadLocal std::vector<double> *nomix_G4MT_TLS_ = 0 ; if (!nomix_G4MT_TLS_) nomix_G4MT_TLS_ = new  std::vector<double>  ;  std::vector<double> &nomix = *nomix_G4MT_TLS_;
    static G4ThreadLocal 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;
}

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

pure virtual

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Referenced by G4VKinkyStringDecay::FragmentString().

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt ( )

inlineprotected

Definition at line 170 of file G4VLongitudinalStringDecay.hh.

References ClusterLoopInterrupt.

{return ClusterLoopInterrupt;};

G4double G4VLongitudinalStringDecay::GetClusterMass ( )

inlineprotected

Definition at line 169 of file G4VLongitudinalStringDecay.hh.

References ClusterMass.

{return ClusterMass;};

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb ( )

inlineprotected

Definition at line 167 of file G4VLongitudinalStringDecay.hh.

References DiquarkBreakProb.

{return DiquarkBreakProb;};

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress ( )

inlineprotected

Definition at line 166 of file G4VLongitudinalStringDecay.hh.

References DiquarkSuppress.

{return DiquarkSuppress;};

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

protectedpure virtual

G4double G4VLongitudinalStringDecay::GetStrangeSuppress ( )

inlineprotected

Definition at line 168 of file G4VLongitudinalStringDecay.hh.

References StrangeSuppress.

{return StrangeSuppress;};

G4double G4VLongitudinalStringDecay::GetStringTensionParameter ( )

inlineprotected

Definition at line 172 of file G4VLongitudinalStringDecay.hh.

Referenced by CalculateHadronTimePosition().

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

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

protectedpure virtual

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

protected

Definition at line 151 of file G4VLongitudinalStringDecay.cc.

References G4KineticTrackVector::Boost(), FragmentationMass(), G4cout, G4endl, G4ExcitedString::GetPosition(), CLHEP::HepLorentzVector::mag(), CLHEP::Hep3Vector::mag2(), G4FragmentingString::Mass2(), MassCut, Sample4Momentum(), and sqr().

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

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

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

protected

Definition at line 375 of file G4VLongitudinalStringDecay.cc.

References G4HadronBuilder::Build(), CreatePartonPair(), G4ParticleDefinition::GetPDGEncoding(), and hadronizer.

Referenced by Splitup().

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

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

protectedpure virtual

Referenced by LightFragmentationTest().

G4int G4VLongitudinalStringDecay::SampleQuarkFlavor

(

void

)

Definition at line 437 of file G4VLongitudinalStringDecay.cc.

References G4UniformRand, and StrangeSuppress.

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

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

G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt

(

G4double

ptMax = -1.

)

Definition at line 468 of file G4VLongitudinalStringDecay.cc.

References G4UniformRand, python.hepunit::pi, G4INCL::DeJongSpin::shoot(), SigmaQT, and sqr().

Referenced by G4VKinkyStringDecay::FragmentString().

   {
   G4double Pt;
   if ( ptMax < 0 ) {
      // sample full gaussian
      Pt = -std::log(G4UniformRand());
   } else {
      // sample in limited range
      Pt = -std::log(G4RandFlat::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);
   }

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability

(

G4double

aValue

)

Definition at line 547 of file G4VLongitudinalStringDecay.cc.

References DiquarkBreakProb, and PastInitPhase.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

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

void G4VLongitudinalStringDecay::SetDiquarkSuppression

(

G4double

aValue

)

Definition at line 536 of file G4VLongitudinalStringDecay.cc.

References DiquarkSuppress, and PastInitPhase.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

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

void G4VLongitudinalStringDecay::SetMassCut ( G4double  aValue )

protectedvirtual

Definition at line 145 of file G4VLongitudinalStringDecay.cc.

References MassCut.

Referenced by G4LundStringFragmentation::FragmentString().

{MassCut=aValue;}

void G4VLongitudinalStringDecay::SetScalarMesonMixings

(

std::vector< G4double >

aVector

)

Definition at line 586 of file G4VLongitudinalStringDecay.cc.

References hadronizer, PastInitPhase, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

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

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum

(

G4double

aQT

)

Definition at line 514 of file G4VLongitudinalStringDecay.cc.

References PastInitPhase, and SigmaQT.

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

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability

(

G4double

aValue

)

Definition at line 572 of file G4VLongitudinalStringDecay.cc.

References hadronizer, PastInitPhase, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

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

void G4VLongitudinalStringDecay::SetStrangenessSuppression

(

G4double

aValue

)

Definition at line 525 of file G4VLongitudinalStringDecay.cc.

References PastInitPhase, and StrangeSuppress.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

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

void G4VLongitudinalStringDecay::SetStringTensionParameter

(

G4double

aValue

)

Definition at line 628 of file G4VLongitudinalStringDecay.cc.

References python.hepunit::fermi, python.hepunit::GeV, and Kappa.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

{
          Kappa = aValue * GeV/fermi;
}   

void G4VLongitudinalStringDecay::SetVectorMesonMixings

(

std::vector< G4double >

aVector

)

Definition at line 607 of file G4VLongitudinalStringDecay.cc.

References hadronizer, PastInitPhase, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

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

void G4VLongitudinalStringDecay::SetVectorMesonProbability

(

G4double

aValue

)

Definition at line 558 of file G4VLongitudinalStringDecay.cc.

References hadronizer, PastInitPhase, pspin_barion, pspin_meson, scalarMesonMix, and vectorMesonMix.

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

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

protectedpure virtual

Referenced by Splitup().

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

protectedpure virtual

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

protected

Definition at line 323 of file G4VLongitudinalStringDecay.cc.

References G4FragmentingString::DecayIsQuark(), DiQuarkSplitup(), G4UniformRand, G4FragmentingString::GetDecayParton(), QuarkSplitup(), and SplitEandP().

Referenced by G4QGSMFragmentation::FragmentString().

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

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

protectedpure virtual

Field Documentation

G4int G4VLongitudinalStringDecay::ClusterLoopInterrupt

protected

Definition at line 184 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), and GetClusterLoopInterrupt().

G4double G4VLongitudinalStringDecay::ClusterMass

protected

Definition at line 177 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), and GetClusterMass().

G4double G4VLongitudinalStringDecay::DiquarkBreakProb

protected

Definition at line 180 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::DiquarkSuppress

protected

Definition at line 179 of file G4VLongitudinalStringDecay.hh.

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

G4HadronBuilder* G4VLongitudinalStringDecay::hadronizer

protected

Definition at line 185 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::Kappa

protected

Definition at line 194 of file G4VLongitudinalStringDecay.hh.

Referenced by G4VLongitudinalStringDecay(), and SetStringTensionParameter().

G4double G4VLongitudinalStringDecay::MassCut

protected

Definition at line 172 of file G4VLongitudinalStringDecay.hh.

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

G4bool G4VLongitudinalStringDecay::PastInitPhase

protected

Definition at line 192 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::pspin_barion

protected

Definition at line 188 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::pspin_meson

protected

Definition at line 187 of file G4VLongitudinalStringDecay.hh.

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

std::vector<G4double> G4VLongitudinalStringDecay::scalarMesonMix

protected

Definition at line 190 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::SigmaQT

protected

Definition at line 178 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::SmoothParam

protected

Definition at line 181 of file G4VLongitudinalStringDecay.hh.

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

G4double G4VLongitudinalStringDecay::StrangeSuppress

protected

Definition at line 182 of file G4VLongitudinalStringDecay.hh.

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

G4int G4VLongitudinalStringDecay::StringLoopInterrupt

protected

Definition at line 183 of file G4VLongitudinalStringDecay.hh.

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

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