#include <G4QGSMFragmentation.hh>

Inheritance diagram for G4QGSMFragmentation:

Public Member Functions
	G4QGSMFragmentation ()

	~G4QGSMFragmentation ()

virtual G4KineticTrackVector *	FragmentString (const G4ExcitedString &theString)

Public Member Functions inherited from G4VLongitudinalStringDecay
	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)

Additional Inherited Members
Protected Types inherited from G4VLongitudinalStringDecay
typedef std::pair< G4ParticleDefinition , G4ParticleDefinition >	pDefPair

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

Protected Member Functions inherited from G4VLongitudinalStringDecay
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 inherited from G4VLongitudinalStringDecay
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 40 of file G4QGSMFragmentation.hh.

Constructor & Destructor Documentation

◆ G4QGSMFragmentation()

G4QGSMFragmentation::G4QGSMFragmentation ( )

Definition at line 45 of file G4QGSMFragmentation.cc.

                                         :
arho(0.5), aphi(0.), an(-0.5), ala(-0.75), aksi(-1.), alft(0.5)
   {
   }

◆ ~G4QGSMFragmentation()

G4QGSMFragmentation::~G4QGSMFragmentation ( )

Definition at line 50 of file G4QGSMFragmentation.cc.

51 {

52 }

Member Function Documentation

◆ FragmentString()

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

virtual

Implements G4VLongitudinalStringDecay.

Definition at line 56 of file G4QGSMFragmentation.cc.

{
//    Can no longer modify Parameters for Fragmentation.
    PastInitPhase=true;
    
//  check if string has enough mass to fragment...
    G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
    if ( LeftVector != 0 ) return LeftVector;
    
    LeftVector = new G4KineticTrackVector;
    G4KineticTrackVector * RightVector=new G4KineticTrackVector;
 
// this should work but its only a semi deep copy. %GF  G4ExcitedString theStringInCMS(theString);
        G4ExcitedString *theStringInCMS=CPExcited(theString);
    G4LorentzRotation toCms=theStringInCMS->TransformToAlignedCms();
 
    G4bool success=false, inner_sucess=true;
    G4int attempt=0;
    while ( !success && attempt++ < StringLoopInterrupt )
    {
        G4FragmentingString *currentString=new G4FragmentingString(*theStringInCMS);
 
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        RightVector->clear();
        
        inner_sucess=true;  // set false on failure..
        while (! StopFragmenting(currentString) )
        {  // Split current string into hadron + new string
            G4FragmentingString *newString=0;  // used as output from SplitUp...
            G4KineticTrack * Hadron=Splitup(currentString,newString);
            if ( Hadron != 0 && IsFragmentable(newString)) 
            {
               if ( currentString->GetDecayDirection() > 0 )
                   LeftVector->push_back(Hadron);
                   else
                   RightVector->push_back(Hadron);
               delete currentString;
               currentString=newString;
            } else {
             // abandon ... start from the beginning
               if (newString) delete newString;          // Uzhi restore 20.06.08
               if (Hadron)    delete Hadron;
               inner_sucess=false;
               break;
            }
        } 
        // Split current string into 2 final Hadrons
        if ( inner_sucess && 
             SplitLast(currentString,LeftVector, RightVector) ) 
        {
            success=true;
        }
        delete currentString;
    }
    
    delete theStringInCMS;
    
    if ( ! success )
    {
        std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
        LeftVector->clear();
        std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
        delete RightVector;
        return LeftVector;
    }
        
    // Join Left- and RightVector into LeftVector in correct order.
    while(!RightVector->empty())
    {
        LeftVector->push_back(RightVector->back());
        RightVector->erase(RightVector->end()-1);
    }
    delete RightVector;
 
    CalculateHadronTimePosition(theString.Get4Momentum().mag(), LeftVector);
 
    G4LorentzRotation toObserverFrame(toCms.inverse());
 
    for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
    {
       G4KineticTrack* Hadron = LeftVector->operator[](C1);
       G4LorentzVector Momentum = Hadron->Get4Momentum();
       Momentum = toObserverFrame*Momentum;
       Hadron->Set4Momentum(Momentum);
       G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
       Momentum = toObserverFrame*Coordinate;
       Hadron->SetFormationTime(Momentum.e());
       G4ThreeVector aPosition(Momentum.vect());
       Hadron->SetPosition(theString.GetPosition()+aPosition);
    }
    return LeftVector;
        
 
 
}

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