G4FTFParticipants Class Reference

#include <G4FTFParticipants.hh>

Inheritance diagram for G4FTFParticipants:

Public Member Functions
	G4FTFParticipants ()
	~G4FTFParticipants ()
const G4FTFParticipants &	operator= (const G4FTFParticipants &right)=delete
G4bool	operator== (const G4FTFParticipants &right) const =delete
G4bool	operator!= (const G4FTFParticipants &right) const =delete
	G4FTFParticipants (const G4FTFParticipants &right)=delete
void	SetImpactParameter (const G4double b_value)
G4double	GetImpactParameter () const
void	SetBminBmax (const G4double bmin_value, const G4double bmax_value)
G4bool	SampleBinInterval () const
G4double	GetBmin2 () const
G4double	GetBmax2 () const
void	GetList (const G4ReactionProduct &thePrimary, G4FTFParameters *theParameters)
void	StartLoop ()
G4bool	Next ()
void	SortInteractionsIncT ()
void	ShiftInteractionTime ()
G4InteractionContent &	GetInteraction ()
void	Clean ()
Public Member Functions inherited from G4VParticipants
	G4VParticipants ()
virtual	~G4VParticipants ()
	G4VParticipants (const G4VParticipants &right)=delete
const G4VParticipants &	operator= (const G4VParticipants &right)=delete
G4bool	operator== (const G4VParticipants &right) const =delete
G4bool	operator!= (const G4VParticipants &right) const =delete
virtual void	Init (G4int theZ, G4int theA)
virtual void	SetNucleus (G4V3DNucleus *aNucleus)
virtual G4V3DNucleus *	GetWoundedNucleus () const
virtual void	InitProjectileNucleus (G4int theZ, G4int theA, G4int numberOfLambdasOrAntiLambdas=0)
virtual void	SetProjectileNucleus (G4V3DNucleus *aNucleus)
virtual G4V3DNucleus *	GetProjectileNucleus () const

Additional Inherited Members
Protected Attributes inherited from G4VParticipants
G4V3DNucleus *	theNucleus
G4V3DNucleus *	theProjectileNucleus

Detailed Description

Definition at line 50 of file G4FTFParticipants.hh.

Constructor & Destructor Documentation

G4FTFParticipants() [1/2]

G4FTFParticipants::G4FTFParticipants

(

)

Definition at line 62 of file G4FTFParticipants.cc.

                                     : Bimpact( 0.0 ), BinInterval( false ),
                                         Bmin2( -1.0 ), Bmax2( -1.0 ),
                                         currentInteraction( -1 )
{}

~G4FTFParticipants()

G4FTFParticipants::~G4FTFParticipants

(

)

Definition at line 70 of file G4FTFParticipants.cc.

{}

G4FTFParticipants() [2/2]

G4FTFParticipants::G4FTFParticipants ( const G4FTFParticipants &  right )

delete

Member Function Documentation

Clean()

void G4FTFParticipants::Clean

(

)

Definition at line 384 of file G4FTFParticipants.cc.

                              {
  for ( size_t i = 0; i < theInteractions.size(); i++ ) {
    if ( theInteractions[ i ] ) {
      delete theInteractions[ i ];
      theInteractions[ i ] = 0;
    }
  }
  theInteractions.clear();
  currentInteraction = -1;
}

Referenced by G4FTFModel::GetStrings(), and G4FTFModel::Init().

GetBmax2()

G4double G4FTFParticipants::GetBmax2 ( ) const

inline

Definition at line 119 of file G4FTFParticipants.hh.

                                                  {
  return Bmax2;
}

Referenced by GetList().

GetBmin2()

G4double G4FTFParticipants::GetBmin2 ( ) const

inline

Definition at line 115 of file G4FTFParticipants.hh.

                                                  {
  return Bmin2;
}

Referenced by GetList().

GetImpactParameter()

G4double G4FTFParticipants::GetImpactParameter ( ) const

inline

Definition at line 99 of file G4FTFParticipants.hh.

                                                            {
  return Bimpact;
}

Referenced by G4FTFModel::GetStrings().

GetInteraction()

G4InteractionContent & G4FTFParticipants::GetInteraction ( )

inline

Definition at line 131 of file G4FTFParticipants.hh.

                                                               {
  return *theInteractions[ currentInteraction ];
}

Referenced by G4FTFModel::GetStrings().

GetList()

void G4FTFParticipants::GetList	(	const G4ReactionProduct &	thePrimary,
		G4FTFParameters *	theParameters
	)

Definition at line 74 of file G4FTFParticipants.cc.

                                                                  { 
 
  #ifdef debugFTFparticipant
  G4cout << "Participants::GetList" << G4endl 
         << "thePrimary " << thePrimary.GetMomentum() << G4endl << G4endl;
  #endif
 
  G4double betta_z = thePrimary.GetMomentum().z() / thePrimary.GetTotalEnergy();
  if ( betta_z < 1.0e-10 ) betta_z = 1.0e-10;
 
  StartLoop(); // reset Loop over Interactions
 
  for ( unsigned int i = 0; i < theInteractions.size(); i++ ) delete theInteractions[i];
  theInteractions.clear();
 
  G4double deltaxy = 2.0 * fermi;  // Extra nuclear radius
 
  if ( theProjectileNucleus == nullptr ) {  // Hadron-nucleus or anti-baryon-nucleus interactions
 
    G4double impactX( 0.0 ), impactY( 0.0 );
    G4double B( 0.0 ), B2( 0.0 );
 
    G4VSplitableHadron* primarySplitable = new G4DiffractiveSplitableHadron( thePrimary );
 
    #ifdef debugFTFparticipant
    G4cout << "Hadron-nucleus or anti-baryon-nucleus interactions" << G4endl;
    #endif
 
    G4double xyradius = theNucleus->GetOuterRadius() + deltaxy;  // Range of impact parameter sampling
 
    const G4int maxNumberOfLoops = 1000;
    G4int loopCounter = 0;                                          
    do {
 
      std::pair< G4double, G4double > theImpactParameter;
      if ( SampleBinInterval() ) {
        B2 = GetBmin2() + G4UniformRand() * ( GetBmax2() - GetBmin2() );
        B  = B2 > 0.0 ? std::sqrt( B2 ) : 0.0;
        G4double Phi = twopi * G4UniformRand();
        impactX = B * std::cos( Phi );
        impactY = B * std::sin( Phi );
        SetImpactParameter( B );
      } else {
        theImpactParameter = theNucleus->ChooseImpactXandY( xyradius );
        impactX = theImpactParameter.first; 
        impactY = theImpactParameter.second;
        SetImpactParameter( std::sqrt( sqr(impactX) + sqr(impactY) ) );
      }
 
      #ifdef debugFTFparticipant
      G4cout << "New interaction list," << " b[fm]= " 
             << std::sqrt( sqr(impactX ) + sqr( impactY ) )/fermi << G4endl;
      #endif
 
      G4ThreeVector thePosition( impactX, impactY, 0.0 );
      primarySplitable->SetPosition( thePosition );
 
      theNucleus->StartLoop();
      G4Nucleon* nucleon;
 
      #ifdef debugFTFparticipant
      G4int TrN( 0 );
      #endif
 
      while ( ( nucleon = theNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
 
        G4double impact2 = sqr( impactX - nucleon->GetPosition().x() ) +
                           sqr( impactY - nucleon->GetPosition().y() );
 
        if ( theParameters->GetProbabilityOfInteraction( impact2/fermi/fermi ) > 
             G4UniformRand() ) {
          primarySplitable->SetStatus( 1 );  // It takes part in the interaction
          G4VSplitableHadron* targetSplitable = 0;
          if ( ! nucleon->AreYouHit() ) {
            targetSplitable = new G4DiffractiveSplitableHadron( *nucleon );
            nucleon->Hit( targetSplitable );
            targetSplitable->SetStatus( 1 ); // It takes part in the interaction
 
            #ifdef debugFTFparticipant
            G4cout << "Participated nucleons #, " << TrN << " " << "Splitable Pr* Tr* "
                   << primarySplitable << " " << targetSplitable << G4endl;
            #endif
 
          }
          G4InteractionContent* aInteraction = new G4InteractionContent( primarySplitable );
          G4Nucleon* PrNucleon = 0;
          aInteraction->SetProjectileNucleon( PrNucleon );
          aInteraction->SetTarget( targetSplitable );
          aInteraction->SetTargetNucleon( nucleon );     
          aInteraction->SetStatus( 1 );                  
          aInteraction->SetInteractionTime( ( primarySplitable->GetPosition().z() + 
                                              nucleon->GetPosition().z() ) / betta_z );
          theInteractions.push_back( aInteraction );
        }
 
        #ifdef debugFTFparticipant
        TrN++;
        #endif
 
      } 
 
    } while ( ( theInteractions.size() == 0 ) && 
              ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
    if ( loopCounter >= maxNumberOfLoops ) {
      #ifdef debugFTFparticipant
      G4cout << "BAD situation: forced exit from the while loop!" << G4endl;
      #endif
      return;
    }
 
    #ifdef debugFTFparticipant
    G4cout << "Number of Hit nucleons " << theInteractions.size() << "\t Bx[fm] " << impactX/fermi
           << "\t By[fm] " << impactY/fermi << "\t B[fm] " 
           << std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl << G4endl;
    #endif
 
    //SortInteractionsIncT(); // Not need because nucleons are sorted in increasing z-coordinates.
    ShiftInteractionTime();  // To put correct times and z-coordinates
    return;
 
  }  // end of if ( theProjectileNucleus == 0 )
 
  // Projectile and target are nuclei
 
  #ifdef debugFTFparticipant
  G4cout << "Projectile and target are nuclei" << G4endl;
  #endif
 
  //G4cout<<theProjectileNucleus->GetOuterRadius()/fermi<<" "<<theNucleus->GetOuterRadius()/fermi<<" "<<deltaxy/fermi<<G4endl;
 
  // Range of impact parameter sampling
  G4double xyradius = theProjectileNucleus->GetOuterRadius() + theNucleus->GetOuterRadius() + deltaxy;
 
  G4double impactX( 0.0 ), impactY( 0.0 );
  G4double B( 0.0 ), B2( 0.0 );
 
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do {
 
    std::pair< G4double, G4double > theImpactParameter;
    if ( SampleBinInterval() ) {
      B2 = GetBmin2() + G4UniformRand() * ( GetBmax2() - GetBmin2() );
      B  = B2 > 0.0 ? std::sqrt( B2 ) : 0.0;  // In G4 internal units (mm)
      G4double Phi = twopi * G4UniformRand();
      impactX = B * std::cos( Phi ); 
      impactY = B * std::sin( Phi );
      SetImpactParameter( B );
    } else {
      theImpactParameter = theNucleus->ChooseImpactXandY( xyradius );
      impactX = theImpactParameter.first; 
      impactY = theImpactParameter.second;
      SetImpactParameter( std::sqrt( sqr(impactX) + sqr(impactY) ) );
    }
 
    #ifdef debugFTFparticipant
    G4cout << "New interaction list, " << "b[fm] "
           << std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl;
    #endif
 
    G4ThreeVector theBeamPosition( impactX, impactY, 0.0 );                    
 
    theProjectileNucleus->StartLoop();
    G4Nucleon* ProjectileNucleon;
 
    #ifdef debugFTFparticipant
    G4int PrNuclN( 0 );
    #endif
 
    while ( ( ProjectileNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
 
      G4VSplitableHadron* ProjectileSplitable = 0;
      theNucleus->StartLoop();
      G4Nucleon* TargetNucleon = 0;
 
      #ifdef debugFTFparticipant
      G4int TrNuclN( 0 );
      #endif
 
      while ( ( TargetNucleon = theNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
 
        G4double impact2 = sqr( impactX + ProjectileNucleon->GetPosition().x() - 
                                TargetNucleon->GetPosition().x() ) +
                           sqr( impactY + ProjectileNucleon->GetPosition().y() -
                                TargetNucleon->GetPosition().y() );
        G4VSplitableHadron* TargetSplitable = 0;
        if ( theParameters->GetProbabilityOfInteraction( impact2/fermi/fermi ) >
             G4UniformRand() ) {  // An interaction has happend!
 
          #ifdef debugFTFparticipant
          G4cout << G4endl << "An Interaction has happend" << G4endl << "Proj N mom " << PrNuclN
                 << " " << ProjectileNucleon->Get4Momentum() << "-------------" << G4endl
                 << "Targ N mom " << TrNuclN << " " << TargetNucleon->Get4Momentum() << G4endl
                 << "PrN TrN Z coords [fm]" << ProjectileNucleon->GetPosition().z()/fermi 
                 << " " << TargetNucleon->GetPosition().z()/fermi 
                 << " " << ProjectileNucleon->GetPosition().z()/fermi + 
                           TargetNucleon->GetPosition().z()/fermi << G4endl;
          #endif
 
          if ( ! ProjectileNucleon->AreYouHit() ) { 
            // Projectile nucleon was not involved until now.
            ProjectileSplitable = new G4DiffractiveSplitableHadron( *ProjectileNucleon );
            ProjectileNucleon->Hit( ProjectileSplitable );
            ProjectileSplitable->SetStatus( 1 );  // It takes part in the interaction
          } else {  // Projectile nucleon was involved before.
            ProjectileSplitable = ProjectileNucleon->GetSplitableHadron();
          }
 
          if ( ! TargetNucleon->AreYouHit() ) {  // Target nucleon was not involved until now
            TargetSplitable = new G4DiffractiveSplitableHadron( *TargetNucleon );
            TargetNucleon->Hit( TargetSplitable );
            TargetSplitable->SetStatus( 1 );   // It takes part in the interaction
          } else {  // Target nucleon was involved before.
            TargetSplitable = TargetNucleon->GetSplitableHadron();
          }
 
          G4InteractionContent* anInteraction = new G4InteractionContent( ProjectileSplitable );
          anInteraction->SetTarget( TargetSplitable );
          anInteraction->SetProjectileNucleon( ProjectileNucleon );
          anInteraction->SetTargetNucleon( TargetNucleon );
          anInteraction->SetInteractionTime( ( ProjectileNucleon->GetPosition().z() + 
                                               TargetNucleon->GetPosition().z() ) / betta_z );
          anInteraction->SetStatus( 1 );                     
 
          #ifdef debugFTFparticipant
          G4cout << "Part anInteraction->GetInteractionTime() [fm] " 
                 << anInteraction->GetInteractionTime()/fermi << G4endl
                 << "Splitable Pr* Tr* " << ProjectileSplitable << " " 
                 << TargetSplitable << G4endl;
          #endif
 
          theInteractions.push_back( anInteraction );
 
        } // End of an Interaction has happend!
 
        #ifdef debugFTFparticipant
        TrNuclN++;
        #endif
 
      }  // End of while ( ( TargetNucleon = theNucleus->GetNextNucleon() ) )
 
      #ifdef debugFTFparticipant
      PrNuclN++;
      #endif
 
    }  // End of while ( ( ProjectileNucleon = theProjectileNucleus->GetNextNucleon() ) )
 
    if ( theInteractions.size() != 0 ) theProjectileNucleus->DoTranslation( theBeamPosition );
 
  } while ( ( theInteractions.size() == 0 ) &&
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    #ifdef debugFTFparticipant
    G4cout << "BAD situation: forced exit from the while loop!" << G4endl;
    #endif
    return;
  }
 
  SortInteractionsIncT();
  ShiftInteractionTime();
 
  #ifdef debugFTFparticipant
  G4cout << G4endl << "Number of primary collisions " << theInteractions.size() 
         << "\t Bx[fm] " << impactX/fermi << "\t By[fm] " << impactY/fermi
         << "\t B[fm] " << std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl
         << "FTF participant End. #######################" << G4endl << G4endl;
  #endif
  return;
}

Referenced by G4FTFModel::GetStrings().

Next()

G4bool G4FTFParticipants::Next ( )

inline

Definition at line 127 of file G4FTFParticipants.hh.

                                      {
  return ++currentInteraction < static_cast< G4int >( theInteractions.size() );
}

Referenced by G4FTFModel::GetStrings().

operator!=()

G4bool G4FTFParticipants::operator!= ( const G4FTFParticipants &  right ) const

delete

operator=()

const G4FTFParticipants & G4FTFParticipants::operator= ( const G4FTFParticipants &  right )

delete

operator==()

G4bool G4FTFParticipants::operator== ( const G4FTFParticipants &  right ) const

delete

SampleBinInterval()

G4bool G4FTFParticipants::SampleBinInterval ( ) const

inline

Definition at line 111 of file G4FTFParticipants.hh.

                                                         {
  return BinInterval;
}

Referenced by GetList().

SetBminBmax()

void G4FTFParticipants::SetBminBmax ( const G4double  bmin_value, const G4double  bmax_value  )

inline

Definition at line 103 of file G4FTFParticipants.hh.

                                                                                                 {
  BinInterval = false;
  if ( bmin_value < 0.0 || bmax_value < 0.0 || bmax_value < bmin_value ) return;
  BinInterval = true;
  Bmin2 = bmin_value * bmin_value;
  Bmax2 = bmax_value * bmax_value;
}

Referenced by G4FTFModel::Init().

SetImpactParameter()

void G4FTFParticipants::SetImpactParameter ( const G4double  b_value )

inline

Definition at line 95 of file G4FTFParticipants.hh.

                                                                          {
  Bimpact = b_value;
}

Referenced by GetList().

ShiftInteractionTime()

void G4FTFParticipants::ShiftInteractionTime

(

)

Definition at line 364 of file G4FTFParticipants.cc.

                                             {
  G4double InitialTime = theInteractions[0]->GetInteractionTime();
  for ( unsigned int i = 1; i < theInteractions.size(); i++ ) {
    G4double InterTime = theInteractions[i]->GetInteractionTime() - InitialTime;
    theInteractions[i]->SetInteractionTime( InterTime );
    G4InteractionContent* aCollision = theInteractions[i];
    G4VSplitableHadron* projectile = aCollision->GetProjectile();
    G4VSplitableHadron* target = aCollision->GetTarget();
    G4ThreeVector prPosition = projectile->GetPosition();
    prPosition.setZ( target->GetPosition().z() );
    projectile->SetPosition( prPosition );
    projectile->SetTimeOfCreation( InterTime );
    target->SetTimeOfCreation( InterTime );
  }
  return;
}

Referenced by GetList().

SortInteractionsIncT()

void G4FTFParticipants::SortInteractionsIncT

(

)

Definition at line 356 of file G4FTFParticipants.cc.

                                             {  // on increased T 
  if ( theInteractions.size() < 2 ) return;  // Avoid unnecesary work
  std::sort( theInteractions.begin(), theInteractions.end(), G4FTFPartHelperForSortInT ); 
}

Referenced by GetList().

StartLoop()

void G4FTFParticipants::StartLoop ( )

inline

Definition at line 123 of file G4FTFParticipants.hh.

                                         {
  currentInteraction = -1;
}

Referenced by GetList(), and G4FTFModel::GetStrings().

---

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

• G4FTFParticipants.hh
• G4FTFParticipants.cc