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 51 of file G4ElasticHNScattering.hh.

Constructor & Destructor Documentation

G4ElasticHNScattering::G4ElasticHNScattering

(

)

Definition at line 59 of file G4ElasticHNScattering.cc.

{}

G4ElasticHNScattering::~G4ElasticHNScattering ( )

virtual

Definition at line 237 of file G4ElasticHNScattering.cc.

{}

Member Function Documentation

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 );

  G4SampleResonance BrW;

  // Projectile parameters
  G4LorentzVector Pprojectile = projectile->Get4Momentum();
  if ( Pprojectile.z() < 0.0 ) return false;
  G4bool PutOnMassShell( false );
  G4double M0projectile = Pprojectile.mag();       
  //if ( M0projectile < projectile->GetDefinition()->GetPDGMass() ) {

  G4double MminProjectile=BrW.GetMinimumMass(projectile->GetDefinition());

  if ( M0projectile < MminProjectile ) {
    PutOnMassShell = true;
    M0projectile = projectile->GetDefinition()->GetPDGMass();
  }
  G4double M0projectile2 = M0projectile * M0projectile;
  G4double AveragePt2 = theParameters->GetAvaragePt2ofElasticScattering();

  // Target parameters
  G4LorentzVector Ptarget = target->Get4Momentum();
  G4double M0target = Ptarget.mag();
  //if ( M0target < target->GetDefinition()->GetPDGMass() ) {

  G4double MminTarget=BrW.GetMinimumMass(target->GetDefinition());

  if ( M0target < MminTarget ) {
    PutOnMassShell = true;
    M0target = target->GetDefinition()->GetPDGMass();
  }   
  G4double M0target2 = M0target * M0target;                      

  // 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 );

  // Putting on mass-on-shell, if needed
  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;

  if ( PZcms2 < 0.0 ) {  // It can be in an interaction with off-shell nuclear nucleon
    if ( M0projectile > projectile->GetDefinition()->GetPDGMass() ) { 
      // An attempt to de-excite the projectile
      // It is assumed that the target is in the ground state
      M0projectile = projectile->GetDefinition()->GetPDGMass();
      M0projectile2 = M0projectile * M0projectile;
      PZcms2= ( S*S + sqr( M0projectile2 ) + sqr( M0target2 )
                - 2*S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2 ) / 4.0 / S;
      if ( PZcms2 < 0.0 ) { return false; }  // Nonsuccesful attempt to de-excitate the projectile
    } else {                                  
      return false; // The projectile was not excited, but the energy was too low to put
                    // the target nucleon on mass-shell
    }
  }

  PZcms = std::sqrt( PZcms2 );

  if ( PutOnMassShell ) {
    if ( Pprojectile.z() > 0.0 ) {
      Pprojectile.setPz( PZcms );
      Ptarget.setPz( -PZcms );
    } else {
      Pprojectile.setPz( -PZcms );
      Ptarget.setPz( PZcms );
    };
    Pprojectile.setE( std::sqrt( M0projectile2 + Pprojectile.x() * Pprojectile.x() +
                                                 Pprojectile.y() * Pprojectile.y() + PZcms2 ) );
    Ptarget.setE( std::sqrt( M0target2 + Ptarget.x() * Ptarget.x() + Ptarget.y() * Ptarget.y() +
                             PZcms2 ) );
  }

  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/processes/hadronic/models/parton_string/diffraction/include/G4ElasticHNScattering.hh
• geant4.10.03.p01/source/processes/hadronic/models/parton_string/diffraction/src/G4ElasticHNScattering.cc