G4ElasticHNScattering Class Reference

#include <G4ElasticHNScattering.hh>

Public Member Functions
	G4ElasticHNScattering ()
virtual	~G4ElasticHNScattering ()
virtual G4bool	ElasticScattering (G4VSplitableHadron *aPartner, G4VSplitableHadron *bPartner, G4FTFParameters *theParameters) const

Detailed Description

Definition at line 50 of file G4ElasticHNScattering.hh.

Constructor & Destructor Documentation

G4ElasticHNScattering()

G4ElasticHNScattering::G4ElasticHNScattering

(

)

Definition at line 59 of file G4ElasticHNScattering.cc.

{}

~G4ElasticHNScattering()

G4ElasticHNScattering::~G4ElasticHNScattering ( )

virtual

Definition at line 189 of file G4ElasticHNScattering.cc.

{}

Member Function Documentation

ElasticScattering()

G4bool G4ElasticHNScattering::ElasticScattering ( G4VSplitableHadron * aPartner, G4VSplitableHadron * bPartner, G4FTFParameters * theParameters ) const

virtual

Definition at line 64 of file G4ElasticHNScattering.cc.

                                                                                        {
  projectile->IncrementCollisionCount( 1 );
  target->IncrementCollisionCount( 1 );
 
  if ( projectile->Get4Momentum().z() < 0.0 ) return false;  //Uzhi Aug.2019
 
  // Projectile parameters
  G4LorentzVector Pprojectile = projectile->Get4Momentum();
  G4double M0projectile = Pprojectile.mag();
  G4double M0projectile2 = M0projectile * M0projectile;
 
  // Target parameters
  G4LorentzVector Ptarget = target->Get4Momentum();
  G4double M0target = Ptarget.mag();
  G4double M0target2 = M0target * M0target;
 
  G4double AveragePt2 = theParameters->GetAvaragePt2ofElasticScattering();
 
  // Transform momenta to cms and then rotate parallel to z axis;
  G4LorentzVector Psum;
  Psum = Pprojectile + Ptarget;
  G4LorentzRotation toCms( -1*Psum.boostVector() );
  G4LorentzVector Ptmp = toCms*Pprojectile;
  if ( Ptmp.pz() <= 0.0 ) return false;                                 
  //"String" moving backwards in  CMS, abort collision !
  //G4cout << " abort Collision! " << G4endl;
  toCms.rotateZ( -1*Ptmp.phi() );
  toCms.rotateY( -1*Ptmp.theta() );
  G4LorentzRotation toLab( toCms.inverse() );
  Pprojectile.transform( toCms );
  Ptarget.transform( toCms );
 
  G4double PZcms2, PZcms;                                          
  G4double S = Psum.mag2();                                          
  G4double SqrtS = std::sqrt( S );
  if ( SqrtS < M0projectile + M0target ) return false;
 
  PZcms2 = ( S*S + sqr( M0projectile2 ) + sqr( M0target2 )
             - 2*S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2 ) / 4.0 / S;
 
  PZcms = ( PZcms2 > 0.0 ? std::sqrt( PZcms2 ) : 0.0 );
 
  G4double maxPtSquare = PZcms2;
 
  // Now we can calculate the transferred Pt
  G4double Pt2;                                                    
  G4double ProjMassT2, ProjMassT;                                  
  G4double TargMassT2, TargMassT;
  G4LorentzVector Qmomentum;
 
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do {
    Qmomentum = G4LorentzVector( GaussianPt( AveragePt2, maxPtSquare ), 0.0 );
    Pt2 = G4ThreeVector( Qmomentum.vect() ).mag2();                  
    ProjMassT2 = M0projectile2 + Pt2;                           
    ProjMassT = std::sqrt( ProjMassT2 );                            
    TargMassT2 = M0target2 + Pt2;                               
    TargMassT = std::sqrt( TargMassT2 );                            
  } while ( ( SqrtS < ProjMassT + TargMassT ) && 
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    return false;
  }
 
  PZcms2 = ( S*S + sqr( ProjMassT2 ) + sqr( TargMassT2 )                           
             - 2.0*S*ProjMassT2 - 2.0*S*TargMassT2 - 2.0*ProjMassT2*TargMassT2 ) / 4.0 / S;
 
  if ( PZcms2 < 0.0 ) { PZcms2 = 0.0; };  // to avoid the exactness problem
  PZcms = std::sqrt( PZcms2 );                                    
  Pprojectile.setPz( PZcms );  
  Ptarget.setPz( -PZcms ); 
  Pprojectile += Qmomentum;
  Ptarget     -= Qmomentum;
 
  // Transform back and update SplitableHadron Participant.
  Pprojectile.transform( toLab );
  Ptarget.transform( toLab );
 
  // Calculation of the creation time
  projectile->SetTimeOfCreation( target->GetTimeOfCreation() );
  projectile->SetPosition( target->GetPosition() );
 
  // Creation time and position of target nucleon were determined at
  // ReggeonCascade() of G4FTFModel
 
  projectile->Set4Momentum( Pprojectile );
  target->Set4Momentum( Ptarget );
 
  //projectile->IncrementCollisionCount( 1 );
  //target->IncrementCollisionCount( 1 );
 
  return true;
}

---

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

• G4ElasticHNScattering.hh
• G4ElasticHNScattering.cc