G4ExcitedStringDecay Class Reference

#include <G4ExcitedStringDecay.hh>

Inheritance diagram for G4ExcitedStringDecay:

Public Member Functions
	G4ExcitedStringDecay (G4VLongitudinalStringDecay *aStringDecay=nullptr)
virtual	~G4ExcitedStringDecay ()
virtual G4KineticTrackVector *	FragmentStrings (const G4ExcitedStringVector *theStrings)
Public Member Functions inherited from G4VStringFragmentation
	G4VStringFragmentation (const G4String &name="StringFragmentation")
	~G4VStringFragmentation () override
	G4VStringFragmentation (const G4VStringFragmentation &right)=delete
const G4VStringFragmentation &	operator= (const G4VStringFragmentation &right)=delete
G4bool	operator== (const G4VStringFragmentation &right) const =delete
G4bool	operator!= (const G4VStringFragmentation &right) const =delete
Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")
virtual	~G4HadronicInteraction ()
virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
G4double	GetMinEnergy () const
G4double	GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
void	SetMinEnergy (G4double anEnergy)
void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)
G4double	GetMaxEnergy () const
G4double	GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
void	SetMaxEnergy (const G4double anEnergy)
void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int value)
const G4String &	GetModelName () const
void	DeActivateFor (const G4Material *aMaterial)
void	ActivateFor (const G4Material *aMaterial)
void	DeActivateFor (const G4Element *anElement)
void	ActivateFor (const G4Element *anElement)
G4bool	IsBlocked (const G4Material *aMaterial) const
G4bool	IsBlocked (const G4Element *anElement) const
void	SetRecoilEnergyThreshold (G4double val)
G4double	GetRecoilEnergyThreshold () const
virtual const std::pair< G4double, G4double >	GetFatalEnergyCheckLevels () const
virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
virtual void	ModelDescription (std::ostream &outFile) const
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	InitialiseModel ()
	G4HadronicInteraction (const G4HadronicInteraction &right)=delete
const G4HadronicInteraction &	operator= (const G4HadronicInteraction &right)=delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4HadronicInteraction &right) const =delete

Additional Inherited Members
Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)
G4bool	IsBlocked () const
void	Block ()
Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange
G4int	verboseLevel
G4double	theMinEnergy
G4double	theMaxEnergy
G4bool	isBlocked

Detailed Description

Definition at line 38 of file G4ExcitedStringDecay.hh.

Constructor & Destructor Documentation

G4ExcitedStringDecay()

G4ExcitedStringDecay::G4ExcitedStringDecay

(

G4VLongitudinalStringDecay *

aStringDecay = nullptr

)

Definition at line 39 of file G4ExcitedStringDecay.cc.

  : G4VStringFragmentation(), theStringDecay(ptr)
{
  if(!ptr) { 
    G4HadronicInteraction* p =
      G4HadronicInteractionRegistry::Instance()->FindModel("LundStringFragmentation");
    theStringDecay = static_cast<G4VLongitudinalStringDecay*>(p);
    if(!theStringDecay) { theStringDecay = new G4LundStringFragmentation(); }
  } 
  SetModelName(theStringDecay->GetModelName());
}

~G4ExcitedStringDecay()

G4ExcitedStringDecay::~G4ExcitedStringDecay ( )

virtual

Definition at line 51 of file G4ExcitedStringDecay.cc.

{}

Member Function Documentation

FragmentStrings()

G4KineticTrackVector * G4ExcitedStringDecay::FragmentStrings ( const G4ExcitedStringVector * theStrings )

virtual

Implements G4VStringFragmentation.

Definition at line 59 of file G4ExcitedStringDecay.cc.

{
  G4LorentzVector KTsum(0.,0.,0.,0.);
 
  #ifdef debug_G4ExcitedStringDecay
  G4cout<<G4endl;
  G4cout<<"--------------------------- G4ExcitedStringDecay ----------------------"<<G4endl;
  G4cout<<"Hadronization of Excited Strings: theStrings->size() "<<theStrings->size()<<G4endl;
  #endif
 
  for ( unsigned int astring=0; astring < theStrings->size(); astring++)
  // for ( unsigned int astring=0; astring < 1; astring++)
  {
    // G4cout<<"theStrings->operator[](astring)->IsExcited() "<<" "<<astring<<" "<<theStrings->operator[](astring)->IsExcited()<<G4endl;
    if ( theStrings->operator[](astring)->IsExcited() )
         {KTsum+= theStrings->operator[](astring)->Get4Momentum();}
    else {KTsum+=theStrings->operator[](astring)->GetKineticTrack()->Get4Momentum();}
  }
 
  G4LorentzRotation toCms( -1 * KTsum.boostVector() );
  G4LorentzRotation toLab(toCms.inverse());
  G4LorentzVector Ptmp;
  KTsum=G4LorentzVector(0.,0.,0.,0.);
 
  for ( unsigned int astring=0; astring < theStrings->size(); astring++)
  // for ( unsigned int astring=0; astring < 1; astring++)
  {
    if ( theStrings->operator[](astring)->IsExcited() )
    {
      Ptmp=toCms * theStrings->operator[](astring)->GetLeftParton()->Get4Momentum();
      theStrings->operator[](astring)->GetLeftParton()->Set4Momentum(Ptmp);
 
      Ptmp=toCms * theStrings->operator[](astring)->GetRightParton()->Get4Momentum();
      theStrings->operator[](astring)->GetRightParton()->Set4Momentum(Ptmp);
 
      KTsum+= theStrings->operator[](astring)->Get4Momentum();
    }
    else
    {
      Ptmp=toCms * theStrings->operator[](astring)->GetKineticTrack()->Get4Momentum();
      theStrings->operator[](astring)->GetKineticTrack()->Set4Momentum(Ptmp);
      KTsum+= theStrings->operator[](astring)->GetKineticTrack()->Get4Momentum();
    }
  }
 
  G4SampleResonance BrW;
  const G4ParticleDefinition* TrackDefinition=0;
 
  G4KineticTrackVector * theResult = new G4KineticTrackVector;
  G4int attempts(0);
  G4bool success=false;
  G4bool NeedEnergyCorrector=false;
  do {
        #ifdef debug_G4ExcitedStringDecay  
        G4cout<<"New try No "<<attempts<<" to hadronize strings"<<G4endl;
        #endif
 
    std::for_each(theResult->begin() , theResult->end() , DeleteKineticTrack());
    theResult->clear();
 
    attempts++;
 
    G4LorentzVector KTsecondaries(0.,0.,0.,0.);
    NeedEnergyCorrector=false;
 
    for ( unsigned int astring=0; astring < theStrings->size(); astring++)
        // for ( unsigned int astring=0; astring < 1; astring++)  // Proj. Last Str. Decay for FTF
        // for ( unsigned int astring=1; astring < 2; astring++)  // Proj. Last Str. Decay for QGS
        // for ( unsigned int astring=0; astring < 1; astring++)  // For testing purposes
    {
          #ifdef debug_G4ExcitedStringDecay  
          G4cout<<"String No "<<astring+1<<" Excited?  "<<theStrings->operator[](astring)->IsExcited()<<G4endl;
 
          G4cout<<"String No "<<astring+1<<" 4Momentum "<<theStrings->operator[](astring)->Get4Momentum()
          <<" "<<theStrings->operator[](astring)->Get4Momentum().mag()<<G4endl;
          #endif
 
          G4KineticTrackVector * generatedKineticTracks = NULL;
      if ( theStrings->operator[](astring)->IsExcited() )
      {
             #ifdef debug_G4ExcitedStringDecay  
             G4cout<<"Fragment String with partons: "
                   <<theStrings->operator[](astring)->GetLeftParton()->GetPDGcode() <<" "
                   <<theStrings->operator[](astring)->GetRightParton()->GetPDGcode()<<" "
                   <<"Direction "<<theStrings->operator[](astring)->GetDirection()<<G4endl;
             #endif
         generatedKineticTracks=FragmentString(*theStrings->operator[](astring));
             #ifdef debug_G4ExcitedStringDecay  
             G4cout<<"(G4ExcitedStringDecay) Number of produced hadrons = "
                   <<generatedKineticTracks->size()<<G4endl;
             #endif
      } else {
             #ifdef debug_G4ExcitedStringDecay  
             G4cout<<"   GetTrack from the String"<<G4endl;
             #endif
             G4LorentzVector Mom=theStrings->operator[](astring)->GetKineticTrack()->Get4Momentum();
             G4KineticTrack * aTrack= new G4KineticTrack(
                            theStrings->operator[](astring)->GetKineticTrack()->GetDefinition(),
                            theStrings->operator[](astring)->GetKineticTrack()->GetFormationTime(),
                            G4ThreeVector(0), Mom);
 
             aTrack->SetPosition(theStrings->operator[](astring)->GetKineticTrack()->GetPosition());
 
             #ifdef debug_G4ExcitedStringDecay  
             G4cout<<"   A particle stored in the track is "<<aTrack->GetDefinition()->GetParticleName()<<G4endl;
             #endif
 
         generatedKineticTracks = new G4KineticTrackVector;
         generatedKineticTracks->push_back(aTrack);
      }    
 
      if (generatedKineticTracks == nullptr || generatedKineticTracks->size() == 0)
      {
             // G4cerr << "G4VPartonStringModel:No KineticTracks produced" << G4endl; 
         delete generatedKineticTracks;
         generatedKineticTracks = nullptr;
             continue;
      }
 
          G4LorentzVector KTsum1(0.,0.,0.,0.);
          for ( unsigned int aTrack=0; aTrack<generatedKineticTracks->size();aTrack++)
      {
             #ifdef debug_G4ExcitedStringDecay  
             G4cout<<"Prod part No. "<<aTrack+1<<" "
                   <<(*generatedKineticTracks)[aTrack]->GetDefinition()->GetParticleName()<<" "
                   <<(*generatedKineticTracks)[aTrack]->Get4Momentum()
                   <<(*generatedKineticTracks)[aTrack]->Get4Momentum().mag()<<G4endl;
             #endif
             // --------------- Sampling mass of unstable hadronic resonances ----------------
             TrackDefinition = (*generatedKineticTracks)[aTrack]->GetDefinition();
 
         if (TrackDefinition->IsShortLived())
             {
               G4double NewTrackMass = 
                 BrW.SampleMass( TrackDefinition->GetPDGMass(), TrackDefinition->GetPDGWidth(),
                                 BrW.GetMinimumMass( TrackDefinition ) + 10.0*MeV, 
                                 TrackDefinition->GetPDGMass() + 5.0*TrackDefinition->GetPDGWidth() );
               G4LorentzVector Tmp=G4LorentzVector((*generatedKineticTracks)[aTrack]->Get4Momentum());
               Tmp.setE(std::sqrt(sqr(NewTrackMass) + Tmp.vect().mag2()));
 
               (*generatedKineticTracks)[aTrack]->Set4Momentum(Tmp);
 
               #ifdef debug_G4ExcitedStringDecay  
               G4cout<<"Resonance *** "<<aTrack+1<<" "
                     <<(*generatedKineticTracks)[aTrack]->GetDefinition()->GetParticleName()<<" "
                     <<(*generatedKineticTracks)[aTrack]->Get4Momentum()
                     <<(*generatedKineticTracks)[aTrack]->Get4Momentum().mag()<<G4endl;
               #endif
             }
             //-------------------------------------------------------------------------------
 
             theResult->push_back(generatedKineticTracks->operator[](aTrack));
             KTsum1+= (*generatedKineticTracks)[aTrack]->Get4Momentum();
      }
      KTsecondaries+=KTsum1;
    
          #ifdef debug_G4ExcitedStringDecay  
          G4cout << "String secondaries(" <<generatedKineticTracks->size()<< ")"<<G4endl
                 <<"Init  string  momentum: "<< theStrings->operator[](astring)->Get4Momentum()<<G4endl
                 <<"Final hadrons momentum: "<< KTsum1 << G4endl;
          #endif
 
      if  ( KTsum1.e() > 0 && 
                std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
      {
        NeedEnergyCorrector=true;
      }
 
          #ifdef debug_G4ExcitedStringDecay  
          G4cout<<"NeedEnergyCorrection yes/no "<<NeedEnergyCorrector<<G4endl;
          #endif
 
          // clean up
      delete generatedKineticTracks;
      success=true;                          
    }
 
    if ( NeedEnergyCorrector ) success=EnergyAndMomentumCorrector(theResult, KTsum);
  } while (!success && (attempts < 100));  /* Loop checking, 07.08.2015, A.Ribon */
 
  for ( unsigned int aTrack=0; aTrack<theResult->size();aTrack++)
  {
    Ptmp=(*theResult)[aTrack]->Get4Momentum();
    Ptmp.transform( toLab);
    (*theResult)[aTrack]->Set4Momentum(Ptmp);
  }
 
  #ifdef debug_G4ExcitedStringDecay  
  G4cout<<"End of the strings fragmentation (G4ExcitedStringDecay)"<<G4endl;
 
  G4LorentzVector  KTsum1(0.,0.,0.,0.); 
 
  for ( unsigned int aTrack=0; aTrack<theResult->size();aTrack++)
  {
      G4cout << " corrected tracks .. " << (*theResult)[aTrack]->GetDefinition()->GetParticleName()
      <<"  " << (*theResult)[aTrack]->Get4Momentum() 
      <<"  " << (*theResult)[aTrack]->Get4Momentum().mag()<< G4endl;
      KTsum1+= (*theResult)[aTrack]->Get4Momentum();
  }
 
  G4cout << "Needcorrector/success " << NeedEnergyCorrector << "/" << success 
         << ", Corrected total  4 momentum " << KTsum1  << G4endl;
  if ( ! success ) G4cout << "failed to correct E/p" << G4endl;  
 
  G4cout<<"End of the Hadronization (G4ExcitedStringDecay)"<<G4endl;
  #endif
 
  if (!success)
  {
    if (theResult->size() != 0)
    {
      std::for_each(theResult->begin() , theResult->end() , DeleteKineticTrack());
      theResult->clear();
      delete theResult; theResult=0;
    }
    for ( unsigned int astring=0; astring < theStrings->size(); astring++)
    // for ( unsigned int astring=0; astring < 1; astring++) // Need more correct. For testing purposes.
    {
      if ( theStrings->operator[](astring)->IsExcited() )
      {
        Ptmp=theStrings->operator[](astring)->GetLeftParton()->Get4Momentum();
        Ptmp.transform( toLab);
        theStrings->operator[](astring)->GetLeftParton()->Set4Momentum(Ptmp);
 
        Ptmp=theStrings->operator[](astring)->GetRightParton()->Get4Momentum();
        Ptmp.transform( toLab);
        theStrings->operator[](astring)->GetRightParton()->Set4Momentum(Ptmp);
      }
      else
      {
        Ptmp=theStrings->operator[](astring)->GetKineticTrack()->Get4Momentum();
        Ptmp.transform( toLab);
        theStrings->operator[](astring)->GetKineticTrack()->Set4Momentum(Ptmp);
      }
    }
  }
  return theResult;
}

---

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

• G4ExcitedStringDecay.hh
• G4ExcitedStringDecay.cc