G4VLongitudinalStringDecay Class Reference

#include <G4VLongitudinalStringDecay.hh>

Inheritance diagram for G4VLongitudinalStringDecay:

G4LundStringFragmentation G4QGSMFragmentation

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 64 of file G4VLongitudinalStringDecay.cc.

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

00065 {
00066    MassCut  = 0.35*GeV; 
00067    ClusterMass = 0.15*GeV;
00068 
00069    SmoothParam      = 0.9; 
00070    StringLoopInterrupt    = 1000;
00071    ClusterLoopInterrupt   =  500;
00072 
00073 // Changable Parameters below.
00074    SigmaQT = 0.5 * GeV;  // 0.5 0.1
00075    
00076    StrangeSuppress  = 0.44;    //  27 % strange quarks produced, ie. u:d:s=1:1:0.27
00077    DiquarkSuppress  = 0.07;
00078    DiquarkBreakProb = 0.1;
00079    
00080    //... pspin_meson is probability to create vector meson 
00081    pspin_meson = 0.5;
00082 
00083    //... pspin_barion is probability to create 3/2 barion 
00084    pspin_barion = 0.5;
00085 
00086    //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
00087    vectorMesonMix.resize(6);
00088    vectorMesonMix[0] = 0.5;
00089    vectorMesonMix[1] = 0.0;
00090    vectorMesonMix[2] = 0.5;
00091    vectorMesonMix[3] = 0.0;
00092    vectorMesonMix[4] = 1.0;
00093    vectorMesonMix[5] = 1.0; 
00094 
00095    //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
00096    scalarMesonMix.resize(6);
00097    scalarMesonMix[0] = 0.5; 
00098    scalarMesonMix[1] = 0.25; 
00099    scalarMesonMix[2] = 0.5; 
00100    scalarMesonMix[3] = 0.25; 
00101    scalarMesonMix[4] = 1.0; 
00102    scalarMesonMix[5] = 0.5; 
00103 
00104 // Parameters may be changed until the first fragmentation starts
00105    PastInitPhase=false;
00106    hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
00107                                 scalarMesonMix,vectorMesonMix);
00108    Kappa = 1.0 * GeV/fermi;
00109 
00110 
00111 }

G4VLongitudinalStringDecay::~G4VLongitudinalStringDecay (  )  [virtual]

Definition at line 114 of file G4VLongitudinalStringDecay.cc.

References hadronizer.

00115    {
00116    delete hadronizer;
00117    }

Member Function Documentation

void G4VLongitudinalStringDecay::CalculateHadronTimePosition ( G4double  theInitialStringMass,
G4KineticTrackVector *   
) [protected]

Definition at line 486 of file G4VLongitudinalStringDecay.cc.

References GetStringTensionParameter().

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

00487    {
00488 
00489 //   `yo-yo` formation time
00490 //   const G4double kappa = 1.0 * GeV/fermi/4.;      
00491    G4double kappa = GetStringTensionParameter();
00492    for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
00493       {
00494       G4double SumPz = 0; 
00495       G4double SumE  = 0;
00496       for(size_t c2 = 0; c2 < c1; c2++)
00497          {
00498          SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
00499          SumE  += Hadrons->operator[](c2)->Get4Momentum().e();   
00500          } 
00501       G4double HadronE  = Hadrons->operator[](c1)->Get4Momentum().e();
00502       G4double HadronPz = Hadrons->operator[](c1)->Get4Momentum().pz();
00503       Hadrons->operator[](c1)->SetFormationTime(
00504 (theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)/c_light); 
00505 
00506       G4ThreeVector aPosition(0, 0,     
00507 (theInitialStringMass - 2.*SumE  - HadronE + HadronPz)/(2.*kappa));
00508       Hadrons->operator[](c1)->SetPosition(aPosition);
00509 
00510       } 
00511    }

void G4VLongitudinalStringDecay::ConstructParticle (  )  [protected]

G4ExcitedString * G4VLongitudinalStringDecay::CPExcited ( const G4ExcitedString &  string  )  [protected]

Definition at line 315 of file G4VLongitudinalStringDecay.cc.

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

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

00316 {
00317         G4Parton *Left=new G4Parton(*in.GetLeftParton());
00318         G4Parton *Right=new G4Parton(*in.GetRightParton());
00319         return new G4ExcitedString(Left,Right,in.GetDirection());
00320 }

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 445 of file G4VLongitudinalStringDecay.cc.

References DiquarkSuppress, FindParticle(), G4UniformRand, and SampleQuarkFlavor().

Referenced by DiQuarkSplitup(), and QuarkSplitup().

00446 {
00447 //  NeedParticle = +1 for Particle, -1 for Antiparticle
00448 
00449     if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
00450     {
00451       // Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
00452       G4int q1  = SampleQuarkFlavor();
00453       G4int q2  = SampleQuarkFlavor();
00454       G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
00455                                      //   convention: quark with higher PDG number is first
00456       G4int PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
00457       return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
00458       
00459 
00460     } else {
00461       // Create a Quark - AntiQuark pair, first in pair  IsParticle
00462       G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
00463       return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
00464     }
00465 
00466 }

G4KineticTrackVector* G4VLongitudinalStringDecay::DecayResonans ( G4KineticTrackVector *  aHadrons  ) 

G4ParticleDefinition * G4VLongitudinalStringDecay::DiQuarkSplitup ( G4ParticleDefinition *  decay,
G4ParticleDefinition *&  created 
) [protected]

Definition at line 390 of file G4VLongitudinalStringDecay.cc.

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

Referenced by Splitup().

00393 {
00394    //... can Diquark break or not? 
00395    if (G4UniformRand() < DiquarkBreakProb ){
00396    //... Diquark break
00397 
00398       G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
00399       G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
00400       if (G4UniformRand() < 0.5)
00401          {
00402          G4int Swap = stableQuarkEncoding;
00403          stableQuarkEncoding = decayQuarkEncoding;
00404          decayQuarkEncoding = Swap;
00405          }
00406 
00407       G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1; 
00408                         // if we have a quark, we need antiquark)
00409       pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
00410       //... Build new Diquark
00411       G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
00412       G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
00413       G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
00414       G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
00415       G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
00416       created = FindParticle(NewDecayEncoding);
00417       G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
00418       G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
00419       return had;
00420 //      return hadronizer->Build(QuarkPair.first, decayQuark);
00421    
00422    } else {
00423    //... Diquark does not break
00424  
00425       G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1; 
00426                         // if we have a diquark, we need quark)
00427       pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
00428       created = QuarkPair.second;
00429 
00430       G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
00431       return had;
00432 //      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
00433    }
00434 }

G4ParticleDefinition * G4VLongitudinalStringDecay::FindParticle ( G4int  Encoding  )  [protected]

Definition at line 282 of file G4VLongitudinalStringDecay.cc.

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

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

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

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

Definition at line 224 of file G4VLongitudinalStringDecay.cc.

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

Referenced by LightFragmentationTest().

00227 {
00228         
00229         G4double mass;
00230         static G4bool NeedInit(true);
00231         static std::vector<double> nomix;
00232         static G4HadronBuilder * minMassHadronizer;
00233         if ( NeedInit ) 
00234         {
00235            NeedInit = false;
00236            nomix.resize(6);
00237            for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
00238 
00239 //         minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
00240            minMassHadronizer=hadronizer;
00241         }
00242 
00243         if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
00244 
00245         G4ParticleDefinition *Hadron1, *Hadron2=0;
00246 
00247         if (!string->FourQuarkString() )
00248         {
00249            // spin 0 meson or spin 1/2 barion will be built
00250 
00251 //G4cout<<"String Left Right "<<string->GetLeftParton()<<" "<<string->GetRightParton()<<G4endl;
00252            Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
00253                                                  string->GetRightParton());
00254 //G4cout<<"Hadron1 "<<Hadron1->GetParticleName()<<G4endl;
00255            mass= (Hadron1)->GetPDGMass();
00256         } else
00257         {
00258            //... string is qq--qqbar: Build two stable hadrons,
00259            //...    with extra uubar or ddbar quark pair
00260            G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
00261            if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
00262 
00263            //... theSpin = 4; spin 3/2 baryons will be built
00264            Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
00265                                                  FindParticle(iflc)       );
00266            Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
00267                                                  FindParticle(-iflc)      );
00268            mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
00269         }
00270         
00271         if ( pdefs != 0 ) 
00272         { // need to return hadrons as well....
00273            pdefs->first  = Hadron1;
00274            pdefs->second = Hadron2;
00275         }
00276            
00277         return mass;
00278 }

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

Implemented in G4LundStringFragmentation, and G4QGSMFragmentation.

Referenced by G4VKinkyStringDecay::FragmentString().

G4int G4VLongitudinalStringDecay::GetClusterLoopInterrupt (  )  [inline, protected]

Definition at line 170 of file G4VLongitudinalStringDecay.hh.

References ClusterLoopInterrupt.

00170 {return ClusterLoopInterrupt;};

G4double G4VLongitudinalStringDecay::GetClusterMass (  )  [inline, protected]

Definition at line 169 of file G4VLongitudinalStringDecay.hh.

References ClusterMass.

00169 {return ClusterMass;};

G4double G4VLongitudinalStringDecay::GetDiquarkBreakProb (  )  [inline, protected]

Definition at line 167 of file G4VLongitudinalStringDecay.hh.

References DiquarkBreakProb.

00167 {return DiquarkBreakProb;};

G4double G4VLongitudinalStringDecay::GetDiquarkSuppress (  )  [inline, protected]

Definition at line 166 of file G4VLongitudinalStringDecay.hh.

References DiquarkSuppress.

00166 {return DiquarkSuppress;};

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

G4double G4VLongitudinalStringDecay::GetStrangeSuppress (  )  [inline, protected]

Definition at line 168 of file G4VLongitudinalStringDecay.hh.

References StrangeSuppress.

00168 {return StrangeSuppress;};

G4double G4VLongitudinalStringDecay::GetStringTensionParameter (  )  [inline, protected]

Definition at line 172 of file G4VLongitudinalStringDecay.hh.

Referenced by CalculateHadronTimePosition().

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

virtual G4bool G4VLongitudinalStringDecay::IsFragmentable ( const G4FragmentingString *const   string  )  [protected, pure virtual]

G4KineticTrackVector * G4VLongitudinalStringDecay::LightFragmentationTest ( const G4ExcitedString *const   theString  )  [protected]

Definition at line 152 of file G4VLongitudinalStringDecay.cc.

References G4KineticTrackVector::Boost(), FragmentationMass(), G4cout, G4endl, G4ExcitedString::Get4Momentum(), G4ExcitedString::GetPosition(), G4FragmentingString::Mass2(), MassCut, Sample4Momentum(), and sqr().

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

00154 {
00155    // Check string decay threshold
00156                 
00157         G4KineticTrackVector * result=0;  // return 0 when string exceeds the mass cut
00158         
00159         pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
00160 
00161         G4FragmentingString aString(*string);
00162 
00163         if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
00164                 return 0;
00165         }
00166 
00167 // The string mass is very low ---------------------------
00168         
00169         result=new G4KineticTrackVector;
00170         
00171         if ( hadrons.second ==0 )
00172         {
00173 // Substitute string by light hadron, Note that Energy is not conserved here!
00174 
00175 /*               
00176 #ifdef DEBUG_LightFragmentationTest
00177                G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
00178                G4cout << hadrons.first->GetParticleName() 
00179                       << "string .. " << string->Get4Momentum() << " " 
00180                       << string->Get4Momentum().m() << G4endl;
00181 #endif                
00182 */
00183                G4ThreeVector   Mom3 = string->Get4Momentum().vect();
00184                G4LorentzVector Mom(Mom3, 
00185                                    std::sqrt(Mom3.mag2() + 
00186                                              sqr(hadrons.first->GetPDGMass())));
00187                result->push_back(new G4KineticTrack(hadrons.first, 0, 
00188                                                   string->GetPosition(),
00189                                                           Mom));
00190         } else 
00191         {
00192 //... string was qq--qqbar type: Build two stable hadrons,
00193 
00194 #ifdef DEBUG_LightFragmentationTest
00195                G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons " 
00196                       << hadrons.first->GetParticleName() << " / " 
00197                       << hadrons.second->GetParticleName()
00198                       << "string .. " << string->Get4Momentum() << " " 
00199                       << string->Get4Momentum().m() << G4endl;
00200 #endif                
00201 
00202                G4LorentzVector  Mom1, Mom2;
00203                Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(), 
00204                                &Mom2,hadrons.second->GetPDGMass(),
00205                                string->Get4Momentum().mag());
00206 
00207                result->push_back(new G4KineticTrack(hadrons.first, 0, 
00208                                                     string->GetPosition(), 
00209                                                             Mom1));
00210                result->push_back(new G4KineticTrack(hadrons.second, 0, 
00211                                                     string->GetPosition(), 
00212                                                     Mom2));
00213 
00214                G4ThreeVector Velocity = string->Get4Momentum().boostVector();
00215                result->Boost(Velocity);          
00216         }
00217 
00218         return result;
00219         
00220 }

G4ParticleDefinition * G4VLongitudinalStringDecay::QuarkSplitup ( G4ParticleDefinition *  decay,
G4ParticleDefinition *&  created 
) [protected]

Definition at line 376 of file G4VLongitudinalStringDecay.cc.

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

Referenced by Splitup().

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

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

Referenced by LightFragmentationTest().

G4int G4VLongitudinalStringDecay::SampleQuarkFlavor ( void   ) 

Definition at line 438 of file G4VLongitudinalStringDecay.cc.

References G4UniformRand, and StrangeSuppress.

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

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

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

Definition at line 469 of file G4VLongitudinalStringDecay.cc.

References G4UniformRand, G4INCL::Math::pi, SigmaQT, and sqr().

Referenced by G4VKinkyStringDecay::FragmentString().

00470    {
00471    G4double Pt;
00472    if ( ptMax < 0 ) {
00473       // sample full gaussian
00474       Pt = -std::log(G4UniformRand());
00475    } else {
00476       // sample in limited range
00477       Pt = -std::log(CLHEP::RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
00478    }
00479    Pt = SigmaQT * std::sqrt(Pt);
00480    G4double phi = 2.*pi*G4UniformRand();
00481    return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
00482    }

void G4VLongitudinalStringDecay::SetDiquarkBreakProbability ( G4double  aValue  ) 

Definition at line 548 of file G4VLongitudinalStringDecay.cc.

References DiquarkBreakProb, and PastInitPhase.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

00549 {
00550         if ( PastInitPhase ) {
00551                 throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
00552         } else {
00553                 DiquarkBreakProb = aValue;
00554         }
00555 }

void G4VLongitudinalStringDecay::SetDiquarkSuppression ( G4double  aValue  ) 

Definition at line 537 of file G4VLongitudinalStringDecay.cc.

References DiquarkSuppress, and PastInitPhase.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

00538 {
00539         if ( PastInitPhase ) {
00540                 throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkSuppression after FragmentString() not allowed");
00541         } else {
00542                 DiquarkSuppress = aValue;
00543         }
00544 }

void G4VLongitudinalStringDecay::SetMassCut ( G4double  aValue  )  [protected, virtual]

Definition at line 146 of file G4VLongitudinalStringDecay.cc.

References MassCut.

Referenced by G4LundStringFragmentation::FragmentString().

00146 {MassCut=aValue;}

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

Definition at line 587 of file G4VLongitudinalStringDecay.cc.

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

00588 {
00589         if ( PastInitPhase ) {
00590                 throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
00591         } else {
00592           if ( aVector.size() < 6 ) 
00593               throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
00594           scalarMesonMix[0] = aVector[0];
00595           scalarMesonMix[1] = aVector[1];
00596           scalarMesonMix[2] = aVector[2];
00597           scalarMesonMix[3] = aVector[3];
00598           scalarMesonMix[4] = aVector[4];
00599           scalarMesonMix[5] = aVector[5];
00600           delete hadronizer;
00601           hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
00602                                 scalarMesonMix,vectorMesonMix);
00603         }
00604 }

void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum ( G4double  aQT  ) 

Definition at line 515 of file G4VLongitudinalStringDecay.cc.

References PastInitPhase, and SigmaQT.

00516 {
00517         if ( PastInitPhase ) {
00518                 throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
00519         } else {
00520                 SigmaQT = aValue;
00521         }
00522 }

void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability ( G4double  aValue  ) 

Definition at line 573 of file G4VLongitudinalStringDecay.cc.

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

00574 {
00575         if ( PastInitPhase ) {
00576                 throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
00577         } else {
00578                 pspin_barion = aValue;
00579                 delete hadronizer;
00580                 hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
00581                                 scalarMesonMix,vectorMesonMix);
00582         }
00583 }

void G4VLongitudinalStringDecay::SetStrangenessSuppression ( G4double  aValue  ) 

Definition at line 526 of file G4VLongitudinalStringDecay.cc.

References PastInitPhase, and StrangeSuppress.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

00527 {
00528         if ( PastInitPhase ) {
00529                 throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
00530         } else {
00531                 StrangeSuppress = aValue;
00532         }
00533 }

void G4VLongitudinalStringDecay::SetStringTensionParameter ( G4double  aValue  ) 

Definition at line 629 of file G4VLongitudinalStringDecay.cc.

References Kappa.

Referenced by G4LundStringFragmentation::G4LundStringFragmentation().

00630 {
00631           Kappa = aValue * GeV/fermi;
00632 }

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

Definition at line 608 of file G4VLongitudinalStringDecay.cc.

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

00609 {
00610         if ( PastInitPhase ) {
00611                 throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
00612         } else {
00613           if ( aVector.size() < 6 ) 
00614               throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
00615           vectorMesonMix[0] = aVector[0];
00616           vectorMesonMix[1] = aVector[1];
00617           vectorMesonMix[2] = aVector[2];
00618           vectorMesonMix[3] = aVector[3];
00619           vectorMesonMix[4] = aVector[4];
00620           vectorMesonMix[5] = aVector[5];
00621           delete hadronizer;
00622           hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
00623                                 scalarMesonMix,vectorMesonMix);
00624   
00625         }
00626 }

void G4VLongitudinalStringDecay::SetVectorMesonProbability ( G4double  aValue  ) 

Definition at line 559 of file G4VLongitudinalStringDecay.cc.

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

00560 {
00561         if ( PastInitPhase ) {
00562                 throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
00563         } else {
00564                 pspin_meson = aValue;
00565                 delete hadronizer;
00566                 hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
00567                                 scalarMesonMix,vectorMesonMix);
00568         }
00569 }

virtual G4LorentzVector* G4VLongitudinalStringDecay::SplitEandP ( G4ParticleDefinition *  pHadron,
G4FragmentingString *  string,
G4FragmentingString *  newString 
) [protected, pure virtual]

Referenced by Splitup().

virtual G4bool G4VLongitudinalStringDecay::SplitLast ( G4FragmentingString *  string,
G4KineticTrackVector *  LeftVector,
G4KineticTrackVector *  RightVector 
) [protected, pure virtual]

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

Definition at line 324 of file G4VLongitudinalStringDecay.cc.

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

Referenced by G4QGSMFragmentation::FragmentString().

00327 {
00328 //G4cout<<"Start SplitUP"<<G4endl;
00329        //... random choice of string end to use for creating the hadron (decay)   
00330        G4int SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
00331        if (SideOfDecay < 0)
00332        {
00333           string->SetLeftPartonStable();
00334        } else
00335        {
00336           string->SetRightPartonStable();
00337        }
00338 
00339        G4ParticleDefinition *newStringEnd;
00340        G4ParticleDefinition * HadronDefinition;
00341        if (string->DecayIsQuark())
00342        {
00343            HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
00344        } else {
00345            HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
00346        }      
00347 
00348 //G4cout<<"New had "<<HadronDefinition->GetParticleName()<<G4endl;
00349 // create new String from old, ie. keep Left and Right order, but replace decay
00350 
00351        newString=new G4FragmentingString(*string,newStringEnd); // To store possible
00352                                                                 // quark containt of new string
00353 //G4cout<<"SplitEandP "<<G4endl;
00354        G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
00355 
00356        delete newString; newString=0;                          
00357         
00358        G4KineticTrack * Hadron =0;
00359        if ( HadronMomentum != 0 ) {    
00360 
00361            G4ThreeVector   Pos;
00362            Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
00363  
00364            newString=new G4FragmentingString(*string,newStringEnd,
00365                                         HadronMomentum);
00366 
00367            delete HadronMomentum;
00368        }      
00369 //G4cout<<"End SplitUP"<<G4endl;
00370        return Hadron;
00371 }

virtual G4bool G4VLongitudinalStringDecay::StopFragmenting ( const G4FragmentingString *const   string  )  [protected, pure 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:
Generated on Mon May 27 17:53:50 2013 for Geant4 by  doxygen 1.4.7