G4QGSParticipants Class Reference

#include <G4QGSParticipants.hh>

Inheritance diagram for G4QGSParticipants:

Classes
struct	DeleteInteractionContent
struct	DeletePartonPair
struct	DeleteSplitableHadron

Public Member Functions
	G4QGSParticipants ()
	G4QGSParticipants (const G4QGSParticipants &right)
const G4QGSParticipants &	operator= (const G4QGSParticipants &right)
virtual	~G4QGSParticipants ()
G4bool	operator== (const G4QGSParticipants &right) const
G4bool	operator!= (const G4QGSParticipants &right) const
virtual void	DoLorentzBoost (G4ThreeVector aBoost)
G4PartonPair *	GetNextPartonPair ()
void	BuildInteractions (const G4ReactionProduct &thePrimary)
void	StartPartonPairLoop ()
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)

Protected Types
enum	{ SOFT , DIFFRACTIVE }
enum	{ ALL , WITHOUT_R , NON_DIFF }
enum	{   PrD , TrD , DD , NonD ,   Qexc }

Protected Member Functions
virtual G4VSplitableHadron *	SelectInteractions (const G4ReactionProduct &thePrimary)
void	SplitHadrons ()
void	PerformSoftCollisions ()
void	PerformDiffractiveCollisions ()
G4bool	DeterminePartonMomenta ()
G4double	SampleX (G4double anXmin, G4int nSea, G4int theTotalSea, G4double aBeta)

Protected Attributes
std::vector< G4InteractionContent * >	theInteractions
std::vector< G4VSplitableHadron * >	theTargets
std::vector< G4PartonPair * >	thePartonPairs
G4QuarkExchange	theQuarkExchange
G4SingleDiffractiveExcitation	theSingleDiffExcitation
G4QGSDiffractiveExcitation	theDiffExcitaton
G4int	ModelMode
G4ThreeVector	theBoost
const G4int	nCutMax
const G4double	ThresholdParameter
const G4double	QGSMThreshold
const G4double	theNucleonRadius
G4ThreeVector	theCurrentVelocity
G4QGSMSplitableHadron *	theProjectileSplitable
Protected Attributes inherited from G4VParticipants
G4V3DNucleus *	theNucleus
G4V3DNucleus *	theProjectileNucleus

Detailed Description

Definition at line 44 of file G4QGSParticipants.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
SOFT
DIFFRACTIVE

Definition at line 157 of file G4QGSParticipants.hh.

{ SOFT, DIFFRACTIVE };

anonymous enum

anonymous enum

protected

Enumerator
ALL
WITHOUT_R
NON_DIFF

Definition at line 158 of file G4QGSParticipants.hh.

{ ALL, WITHOUT_R, NON_DIFF };   // Interaction modes

anonymous enum

anonymous enum

protected

Enumerator
PrD
TrD
DD
NonD
Qexc

Definition at line 159 of file G4QGSParticipants.hh.

{ PrD, TrD, DD, NonD, Qexc };   // Interaction types

Constructor & Destructor Documentation

G4QGSParticipants() [1/2]

G4QGSParticipants::G4QGSParticipants

(

)

Definition at line 49 of file G4QGSParticipants.cc.

  : theDiffExcitaton(), ModelMode(SOFT), nCutMax(7),
    ThresholdParameter(0.0*GeV), QGSMThreshold(3.0*GeV),
    theNucleonRadius(1.5*fermi), theCurrentVelocity(G4ThreeVector()),
    theProjectileSplitable(nullptr), Regge(nullptr),
    InteractionMode(ALL), alpha(-0.5), beta(2.5), sigmaPt(0.0),
    NumberOfInvolvedNucleonsOfTarget(0), NumberOfInvolvedNucleonsOfProjectile(0),
    ProjectileResidual4Momentum(G4LorentzVector()), ProjectileResidualMassNumber(0),
    ProjectileResidualCharge(0), ProjectileResidualExcitationEnergy(0.0),
    TargetResidual4Momentum(G4LorentzVector()), TargetResidualMassNumber(0),
    TargetResidualCharge(0), TargetResidualExcitationEnergy(0.0),
    CofNuclearDestruction(0.0), R2ofNuclearDestruction(0.0),
    ExcitationEnergyPerWoundedNucleon(0.0), DofNuclearDestruction(0.0),
    Pt2ofNuclearDestruction(0.0), MaxPt2ofNuclearDestruction(0.0)
{
  for (size_t i=0; i < 250; ++i) {
    TheInvolvedNucleonsOfTarget[i] = nullptr;
    TheInvolvedNucleonsOfProjectile[i] = nullptr;
  }
  // Parameters setting
  SetCofNuclearDestruction( 1.0 );
  SetR2ofNuclearDestruction( 1.5*fermi*fermi );
  SetDofNuclearDestruction( 0.3 );
  SetPt2ofNuclearDestruction( 0.075*GeV*GeV );
  SetMaxPt2ofNuclearDestruction( 1.0*GeV*GeV );
  SetExcitationEnergyPerWoundedNucleon( 40.0*MeV );
 
  sigmaPt=0.25*sqr(GeV);
}

G4QGSParticipants() [2/2]

G4QGSParticipants::G4QGSParticipants

(

const G4QGSParticipants &

right

)

Definition at line 79 of file G4QGSParticipants.cc.

  : G4VParticipants(), ModelMode(right.ModelMode), nCutMax(right.nCutMax),
    ThresholdParameter(right.ThresholdParameter),
    QGSMThreshold(right.QGSMThreshold),
    theNucleonRadius(right.theNucleonRadius),
    theCurrentVelocity(right.theCurrentVelocity),
    theProjectileSplitable(right.theProjectileSplitable),
    Regge(right.Regge), InteractionMode(right.InteractionMode),
    alpha(right.alpha), beta(right.beta), sigmaPt(right.sigmaPt),
    NumberOfInvolvedNucleonsOfTarget(right.NumberOfInvolvedNucleonsOfTarget),
    NumberOfInvolvedNucleonsOfProjectile(right.NumberOfInvolvedNucleonsOfProjectile),
    ProjectileResidual4Momentum(right.ProjectileResidual4Momentum),
    ProjectileResidualMassNumber(right.ProjectileResidualMassNumber),
    ProjectileResidualCharge(right.ProjectileResidualCharge),
    ProjectileResidualExcitationEnergy(right.ProjectileResidualExcitationEnergy),
    TargetResidual4Momentum(right.TargetResidual4Momentum),
    TargetResidualMassNumber(right.TargetResidualMassNumber),
    TargetResidualCharge(right.TargetResidualCharge),
    TargetResidualExcitationEnergy(right.TargetResidualExcitationEnergy),
    CofNuclearDestruction(right.CofNuclearDestruction),
    R2ofNuclearDestruction(right.R2ofNuclearDestruction),
    ExcitationEnergyPerWoundedNucleon(right.ExcitationEnergyPerWoundedNucleon),
    DofNuclearDestruction(right.DofNuclearDestruction),
    Pt2ofNuclearDestruction(right.Pt2ofNuclearDestruction),
    MaxPt2ofNuclearDestruction(right.MaxPt2ofNuclearDestruction)
{
  for (size_t i=0; i < 250; ++i) {
    TheInvolvedNucleonsOfTarget[i] = right.TheInvolvedNucleonsOfTarget[i];
    TheInvolvedNucleonsOfProjectile[i] = right.TheInvolvedNucleonsOfProjectile[i];
  }
}

~G4QGSParticipants()

G4QGSParticipants::~G4QGSParticipants ( )

virtual

Definition at line 111 of file G4QGSParticipants.cc.

{}

Member Function Documentation

BuildInteractions()

void G4QGSParticipants::BuildInteractions

(

const G4ReactionProduct &

thePrimary

)

Definition at line 113 of file G4QGSParticipants.cc.

{
  theProjectile = thePrimary;
 
  Regge = new G4Reggeons(theProjectile.GetDefinition());
 
  SetProjectileNucleus( 0 );
 
  NumberOfInvolvedNucleonsOfProjectile= 0;
  G4LorentzVector tmp( 0.0, 0.0, 0.0, 0.0 );
  ProjectileResidualMassNumber       = 0;
  ProjectileResidualCharge           = 0;
  ProjectileResidualExcitationEnergy = 0.0;
  ProjectileResidual4Momentum        = tmp;
 
  NumberOfInvolvedNucleonsOfTarget= 0;
  TargetResidualMassNumber       = theNucleus->GetMassNumber();
  TargetResidualCharge           = theNucleus->GetCharge();
  TargetResidualExcitationEnergy = 0.0;
 
  theNucleus->StartLoop();
  G4Nucleon* NuclearNucleon;
  while ( ( NuclearNucleon = theNucleus->GetNextNucleon() ) ) {  
    tmp+=NuclearNucleon->Get4Momentum();
  } 
  TargetResidual4Momentum        = tmp;
 
  if ( std::abs( theProjectile.GetDefinition()->GetBaryonNumber() ) <= 1 ) { 
    // Projectile is a hadron : meson or baryon
    ProjectileResidualMassNumber = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
    ProjectileResidualCharge = G4int( theProjectile.GetDefinition()->GetPDGCharge() );
    ProjectileResidualExcitationEnergy = 0.0;
    ProjectileResidual4Momentum.setVect( theProjectile.GetMomentum() );
    ProjectileResidual4Momentum.setE( theProjectile.GetTotalEnergy() );
  } 
 
  #ifdef debugQGSParticipants
    G4cout <<G4endl<< "G4QGSParticipants::BuildInteractions---------" << G4endl
           << "thePrimary " << thePrimary.GetDefinition()->GetParticleName()<<" "
           <<ProjectileResidual4Momentum<<G4endl;
    G4cout << "Target A and Z  " << theNucleus->GetMassNumber() <<" "<<theNucleus->GetCharge()<<" "
           << TargetResidual4Momentum<<G4endl;
  #endif
 
  G4bool Success( true );
 
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do
  {
    const G4int maxNumberOfInternalLoops = 1000;
    G4int internalLoopCounter = 0;
    do
    {
      if(std::abs(theProjectile.GetDefinition()->GetPDGEncoding()) < 100.0) 
      {
        SelectInteractions(theProjectile);  // for lepton projectile
      }
      else
      {
        GetList( theProjectile );  // Get list of participating nucleons for hadron projectile
      }
 
      if ( theInteractions.size() == 0 ) return;
 
      StoreInvolvedNucleon();       // Store participating nucleon
 
      ReggeonCascade();             // Make reggeon cascading. Involve nucleons in the cascading.
 
      Success = PutOnMassShell();   // Ascribe momenta to the involved and participating nucleons
 
      if(!Success) PrepareInitialState( thePrimary );
 
    } while( (!Success) && ++internalLoopCounter < maxNumberOfInternalLoops );
 
    if ( internalLoopCounter >= maxNumberOfInternalLoops ) {
      Success = false;
    }
   
    if ( Success ) {
      #ifdef debugQGSParticipants
        G4cout<<G4endl<<"PerformDiffractiveCollisions(); if they happend." <<G4endl;
      #endif
 
      PerformDiffractiveCollisions();
 
      #ifdef debugQGSParticipants
        G4cout<<G4endl<<"SplitHadrons();" <<G4endl;
      #endif
 
      SplitHadrons(); 
 
      if( theProjectileSplitable && theProjectileSplitable->GetStatus() == 0) {
        #ifdef debugQGSParticipants
          G4cout<<"Perform non-Diffractive Collisions if they happend. Determine Parton Momenta and so on." <<G4endl;
        #endif 
        Success = DeterminePartonMomenta(); 
      }
 
      if(!Success) PrepareInitialState( thePrimary );
    }
  } while( (!Success) && ++loopCounter < maxNumberOfLoops );
 
  if ( loopCounter >= maxNumberOfLoops ) {
    Success = false;
    #ifdef debugQGSParticipants
      G4cout<<"NOT Successful ======" <<G4endl;
    #endif
  }
 
  if ( Success ) {
    CreateStrings();  // To create strings
 
    GetResiduals();   // To calculate residual nucleus properties
 
    #ifdef debugQGSParticipants
      G4cout<<"All O.K. ======" <<G4endl;
    #endif
  }
 
  // clean-up, if necessary
  #ifdef debugQGSParticipants
    G4cout<<"Clearing "<<G4endl;
    G4cout<<"theInteractions.size() "<<theInteractions.size()<<G4endl;
  #endif
 
  if( Regge ) delete Regge;
 
  std::for_each( theInteractions.begin(), theInteractions.end(), DeleteInteractionContent() );
  theInteractions.clear();
 
  // Erasing of target involved nucleons.
  #ifdef debugQGSParticipants
    G4cout<<"Erasing of involved target nucleons "<<NumberOfInvolvedNucleonsOfTarget<<G4endl;
  #endif
 
  if ( NumberOfInvolvedNucleonsOfTarget != 0 ) {
     for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; i++ ) {
      G4VSplitableHadron* aNucleon = TheInvolvedNucleonsOfTarget[i]->GetSplitableHadron();
      if ( (aNucleon != 0 ) && (aNucleon->GetStatus() >= 1) ) delete aNucleon;
     }
  }
 
  // Erasing of projectile involved nucleons.
  if ( NumberOfInvolvedNucleonsOfProjectile != 0 ) {
     for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; i++ ) {
       G4VSplitableHadron* aNucleon = TheInvolvedNucleonsOfProjectile[i]->GetSplitableHadron();
       if ( aNucleon ) delete aNucleon;
     }
  }
 
  #ifdef debugQGSParticipants
    G4cout<<"Delition of target nucleons from soft interactions "<<theTargets.size()
          <<G4endl<<G4endl;
  #endif
  std::for_each(theTargets.begin(), theTargets.end(), DeleteSplitableHadron());
  theTargets.clear();
 
  if ( theProjectileSplitable ) {
    delete theProjectileSplitable;
    theProjectileSplitable = 0;
  }
}

DeterminePartonMomenta()

G4bool G4QGSParticipants::DeterminePartonMomenta ( )

protected

Definition at line 1537 of file G4QGSParticipants.cc.

{
  if ( ! theProjectileSplitable ) return false;
 
  const G4double aHugeValue = 1.0e+10;
 
  #ifdef debugQGSParticipants
    G4cout<<G4endl<<"DeterminePartonMomenta()......"<<G4endl;
    G4cout<<"theProjectile status (0 -nondiffr, #0 diffr./reggeon):  "<<theProjectileSplitable->GetStatus()<<G4endl;
  #endif
 
  if (theProjectileSplitable->GetStatus() != 0) {return false;} // There were only diffractive interactions.
 
  G4LorentzVector Projectile4Momentum  = theProjectileSplitable->Get4Momentum();
  G4LorentzVector Psum = Projectile4Momentum;
 
  G4double VqM_pr(0.), VaqM_pr(0.), VqM_tr(350.), VqqM_tr(700);
  if (std::abs(theProjectile.GetDefinition()->GetBaryonNumber()) != 0) {VqM_pr=350*MeV; VaqM_pr=700*MeV;}
 
  #ifdef debugQGSParticipants
    G4cout<<"Projectile 4 momentum "<<Psum<<G4endl
          <<"Target nucleon momenta at start"<<G4endl;
    G4int NuclNo=0;
  #endif
 
  std::vector<G4VSplitableHadron*>::iterator i;
 
  for (i = theTargets.begin(); i != theTargets.end(); i++ )
  {
    Psum += (*i)->Get4Momentum();
    #ifdef debugQGSParticipants
      G4cout<<"Nusleus nucleon # and its 4Mom. "<<NuclNo<<" "<<(*i)->Get4Momentum()<<G4endl;
      NuclNo++;
    #endif
  }
 
  G4LorentzRotation toCms( -1*Psum.boostVector() );
 
  G4LorentzVector Ptmp = toCms*Projectile4Momentum;
 
  toCms.rotateZ( -1*Ptmp.phi() );
  toCms.rotateY( -1*Ptmp.theta() );
  G4LorentzRotation toLab(toCms.inverse());
  Projectile4Momentum.transform( toCms );
  //  Ptarget.transform( toCms );
 
  #ifdef debugQGSParticipants
    G4cout<<G4endl<<"In CMS---------------"<<G4endl;
    G4cout<<"Projectile 4 Mom "<<Projectile4Momentum<<G4endl;
    NuclNo=0;
  #endif
 
  G4LorentzVector Target4Momentum(0.,0.,0.,0.);
  for(i = theTargets.begin(); i != theTargets.end(); i++ )
  {
    G4LorentzVector tmp= (*i)->Get4Momentum();  tmp.transform( toCms );
    (*i)->Set4Momentum( tmp );
    #ifdef debugQGSParticipants
      G4cout<<"Target nucleon # and 4Mom "<<" "<<NuclNo<<" "<<(*i)->Get4Momentum()<<G4endl;
      NuclNo++;
    #endif
    Target4Momentum += tmp;
  }
 
  G4double S     = Psum.mag2();
  G4double SqrtS = std::sqrt(S);
 
  #ifdef debugQGSParticipants
    G4cout<<"Sum of target nucleons 4 momentum "<<Target4Momentum<<G4endl<<G4endl;
    G4cout<<"Target nucleons mom: px, py, z_1, m_i"<<G4endl;
    NuclNo=0;
  #endif
 
  //G4double PplusProjectile = Projectile4Momentum.plus();
  G4double PminusTarget    = Target4Momentum.minus();
  
  for(i = theTargets.begin(); i != theTargets.end(); i++ )
  {
    G4LorentzVector tmp = (*i)->Get4Momentum(); // tmp.boost(bstToCM);
 
    //AR-19Jan2017 : the following line is causing a strange crash when Geant4
    //               is built in optimized mode.
    //               To fix it, I get the mass square instead of directly the
    //               mass from the Lorentz vector, and then I take care of the
    //               square root. If the mass square is negative, a JustWarning
    //               exception is thrown, and the mass is set to 0.
    //G4double Mass = tmp.mag();
    G4double Mass2 = tmp.mag2();
    G4double Mass = 0.0;
    if ( Mass2 < 0.0 ) {
      G4ExceptionDescription ed;
      ed << "Projectile " << theProjectile.GetDefinition()->GetParticleName()
         << "  4-momentum " << Psum << G4endl;
      ed << "LorentzVector tmp " << tmp << "  with Mass2 " << Mass2 << G4endl;
      G4Exception( "G4QGSParticipants::DeterminePartonMomenta(): 4-momentum with negative mass!",
                   "HAD_QGSPARTICIPANTS_001", JustWarning, ed );
    } else {
      Mass = std::sqrt( Mass2 );
    }
 
    tmp.setPz(tmp.minus()/PminusTarget);   tmp.setE(Mass);
    (*i)->Set4Momentum(tmp); 
    #ifdef debugQGSParticipants
      G4cout<<"Target nucleons # and mom: "<<NuclNo<<" "<<(*i)->Get4Momentum()<<G4endl;
      NuclNo++;
    #endif
  }
 
  //+++++++++++++++++++++++++++++++++++++++++++
 
  G4double SigPt = sigmaPt;
  G4Parton* aParton(0);
  G4ThreeVector aPtVector(0.,0.,0.);
  G4LorentzVector tmp(0.,0.,0.,0.);
 
  G4double Mt(0.);
  G4double ProjSumMt(0.), ProjSumMt2perX(0.);
  G4double TargSumMt(0.), TargSumMt2perX(0.);
 
 
  G4double aBeta = beta;   // Member of the class
 
  const G4ParticleDefinition* theProjectileDefinition = theProjectileSplitable->GetDefinition();
  if (theProjectileDefinition == G4PionMinus::PionMinusDefinition()) aBeta = 1.;
  if (theProjectileDefinition == G4Gamma::GammaDefinition())         aBeta = 1.;
  if (theProjectileDefinition == G4PionPlus::PionPlusDefinition())   aBeta = 1.;
  if (theProjectileDefinition == G4PionZero::PionZeroDefinition())   aBeta = 1.;
  if (theProjectileDefinition == G4KaonPlus::KaonPlusDefinition())   aBeta = 0.;
  if (theProjectileDefinition == G4KaonMinus::KaonMinusDefinition()) aBeta = 0.;
 
  G4double Xmin = 0.;
 
  G4bool Success = true;  G4int attempt = 0;
  const G4int maxNumberOfAttempts = 1000;
  do
  {
    attempt++;  if( attempt ==  100*(attempt/100) ) {SigPt/=2.;}
 
    ProjSumMt=0.; ProjSumMt2perX=0.;
    TargSumMt=0.; TargSumMt2perX=0.;
 
    Success = true;
    G4int nSeaPair = theProjectileSplitable->GetSoftCollisionCount()-1;
    #ifdef debugQGSParticipants
      G4cout<<"attempt ------------------------ "<<attempt<<G4endl;
      G4cout<<"nSeaPair of proj "<<nSeaPair<<G4endl;
    #endif
 
    G4double SumPx = 0.;
    G4double SumPy = 0.;
    G4double SumZ = 0.;
    G4int NumberOfUnsampledSeaQuarks = 2*nSeaPair;
 
    G4double Qmass=0.;
    for (G4int aSeaPair = 0; aSeaPair < nSeaPair; aSeaPair++)
    {
      aParton = theProjectileSplitable->GetNextParton();   // for quarks
      #ifdef debugQGSParticipants
        G4cout<<"Sea quarks: "<<aSeaPair<<" "<<aParton->GetDefinition()->GetParticleName();
      #endif
      aPtVector = GaussianPt(SigPt, aHugeValue);
      tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
      SumPx += aPtVector.x();   SumPy += aPtVector.y();
      Mt = std::sqrt(aPtVector.mag2()+sqr(Qmass));
      ProjSumMt += Mt; 
 
      // Sampling of Z fraction
      tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ)); 
      SumZ += tmp.z();
 
      NumberOfUnsampledSeaQuarks--;
      ProjSumMt2perX +=sqr(Mt)/tmp.pz();
      tmp.setE(sqr(Mt));
      aParton->Set4Momentum(tmp);
 
      aParton = theProjectileSplitable->GetNextAntiParton();   // for anti-quarks
      #ifdef debugQGSParticipants
        G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
        G4cout<<"              "<<tmp<<" "<<SumZ<<G4endl;
      #endif
      aPtVector = GaussianPt(SigPt, aHugeValue);
      tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
      SumPx += aPtVector.x();   SumPy += aPtVector.y();
      Mt = std::sqrt(aPtVector.mag2()+sqr(Qmass));
      ProjSumMt += Mt; 
 
      // Sampling of Z fraction
      tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ)); 
      SumZ += tmp.z();
 
      NumberOfUnsampledSeaQuarks--;
      ProjSumMt2perX +=sqr(Mt)/tmp.pz();
      tmp.setE(sqr(Mt));
      aParton->Set4Momentum(tmp);
      #ifdef debugQGSParticipants
        G4cout<<"              "<<tmp<<" "<<SumZ<<G4endl;
      #endif
    } 
 
    // For valence quark
    aParton = theProjectileSplitable->GetNextParton();   // for quarks
    #ifdef debugQGSParticipants
      G4cout<<"Val quark of Pr"<<" "<<aParton->GetDefinition()->GetParticleName();
    #endif
    aPtVector = GaussianPt(SigPt, aHugeValue);
    tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
    SumPx += aPtVector.x();   SumPy += aPtVector.y();
    Mt = std::sqrt(aPtVector.mag2()+sqr(VqM_pr));
    ProjSumMt += Mt;
 
    // Sampling of Z fraction
    tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ)); 
    SumZ += tmp.z();
 
    ProjSumMt2perX +=sqr(Mt)/tmp.pz();
    tmp.setE(sqr(Mt));
    aParton->Set4Momentum(tmp);
 
    // For valence di-quark
    aParton = theProjectileSplitable->GetNextAntiParton();
    #ifdef debugQGSParticipants
      G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
      G4cout<<"              "<<tmp<<" "<<SumZ<<" (z-fraction)"<<G4endl;
    #endif
    tmp.setPx(-SumPx); tmp.setPy(-SumPy);
    //Uzhi 2019  Mt = std::sqrt(aPtVector.mag2()+sqr(VaqM_pr));
    Mt = std::sqrt( sqr(SumPx) + sqr(SumPy) + sqr(VaqM_pr) );  //Uzhi 2019
    ProjSumMt += Mt;
    tmp.setPz(1.-SumZ);
 
    ProjSumMt2perX +=sqr(Mt)/tmp.pz();  // QQmass=750 MeV
    tmp.setE(sqr(Mt));
    aParton->Set4Momentum(tmp);
    #ifdef debugQGSParticipants
      G4cout<<"              "<<tmp<<" "<<SumZ+(1.-SumZ)<<" (z-fraction)"<<G4endl;
      NuclNo=0;
    #endif
 
    // End of work with the projectile
 
    // Work with target nucleons 
 
    for(i = theTargets.begin(); i != theTargets.end(); i++ )
    {
      nSeaPair = (*i)->GetSoftCollisionCount()-1;
      #ifdef debugQGSParticipants
        G4cout<<"nSeaPair of target N "<<nSeaPair<<G4endl
              <<"Target nucleon 4Mom "<<(*i)->Get4Momentum()<<G4endl;
      #endif
 
      SumPx = (*i)->Get4Momentum().px() * (-1.);
      SumPy = (*i)->Get4Momentum().py() * (-1.);
      SumZ  = 0.;
 
      NumberOfUnsampledSeaQuarks = 2*nSeaPair;
 
      Qmass=0;  
      for (G4int aSeaPair = 0; aSeaPair < nSeaPair; aSeaPair++)
      {
        aParton = (*i)->GetNextParton();   // for quarks
        #ifdef debugQGSParticipants
          G4cout<<"Sea quarks: "<<aSeaPair<<" "<<aParton->GetDefinition()->GetParticleName();
        #endif
        aPtVector = GaussianPt(SigPt, aHugeValue);
        tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
        SumPx += aPtVector.x();   SumPy += aPtVector.y();
        Mt=std::sqrt(aPtVector.mag2()+sqr(Qmass));
        TargSumMt += Mt; 
 
        // Sampling of Z fraction
        tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ));
        SumZ += tmp.z();
        tmp.setPz((*i)->Get4Momentum().pz()*tmp.pz());
        NumberOfUnsampledSeaQuarks--;
        TargSumMt2perX +=sqr(Mt)/tmp.pz();
        tmp.setE(sqr(Mt));
        aParton->Set4Momentum(tmp);
 
        aParton = (*i)->GetNextAntiParton();   // for anti-quarks
        #ifdef debugQGSParticipants
          G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
          G4cout<<"              "<<tmp<<" "<<SumZ<<G4endl;
        #endif
        aPtVector = GaussianPt(SigPt, aHugeValue);
        tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
        SumPx += aPtVector.x();   SumPy += aPtVector.y();
        Mt=std::sqrt(aPtVector.mag2()+sqr(Qmass));
        TargSumMt += Mt; 
 
        // Sampling of Z fraction
        tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ)); 
        SumZ += tmp.z();
        tmp.setPz((*i)->Get4Momentum().pz()*tmp.pz());
        NumberOfUnsampledSeaQuarks--;
        TargSumMt2perX +=sqr(Mt)/tmp.pz();
        tmp.setE(sqr(Mt));
        aParton->Set4Momentum(tmp);
        #ifdef debugQGSParticipants
          G4cout<<"              "<<tmp<<" "<<" "<<SumZ<<G4endl;
        #endif
      } 
 
      // Valence quark
      aParton = (*i)->GetNextParton();   // for quarks
      #ifdef debugQGSParticipants
        G4cout<<"Val quark of Tr"<<" "<<aParton->GetDefinition()->GetParticleName();
      #endif
      aPtVector = GaussianPt(SigPt, aHugeValue);
      tmp.setPx(aPtVector.x()); tmp.setPy(aPtVector.y());
      SumPx += aPtVector.x();   SumPy += aPtVector.y();
      Mt=std::sqrt(aPtVector.mag2()+sqr(VqM_tr));
      TargSumMt += Mt; 
 
      // Sampling of Z fraction
      tmp.setPz(SampleX(Xmin, NumberOfUnsampledSeaQuarks, 2*nSeaPair, aBeta)*(1.0-SumZ)); 
      SumZ += tmp.z();
      tmp.setPz((*i)->Get4Momentum().pz()*tmp.pz());
      TargSumMt2perX +=sqr(Mt)/tmp.pz();
      tmp.setE(sqr(Mt));
      aParton->Set4Momentum(tmp);
 
      // Valence di-quark
      aParton = (*i)->GetNextAntiParton();   // for quarks
      #ifdef debugQGSParticipants
        G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
        G4cout<<"              "<<tmp<<" "<<SumZ<<" (total z-sum) "<<G4endl;
      #endif
      tmp.setPx(-SumPx);                  tmp.setPy(-SumPy);
      //Uzhi 2019  Mt=std::sqrt(aPtVector.mag2()+sqr(VqqM_tr));
      Mt=std::sqrt( sqr(SumPx) + sqr(SumPy) + sqr(VqqM_tr) );  //Uzhi 2019   
      TargSumMt += Mt; 
 
      tmp.setPz((*i)->Get4Momentum().pz()*(1.0 - SumZ));
      TargSumMt2perX +=sqr(Mt)/tmp.pz();
      tmp.setE(sqr(Mt));
      aParton->Set4Momentum(tmp);
      #ifdef debugQGSParticipants
        G4cout<<"              "<<tmp<<" "<<1.0<<" "<<(*i)->Get4Momentum().pz()<<G4endl;
      #endif
 
    }   // End of for(i = theTargets.begin(); i != theTargets.end(); i++ )
 
    if( ProjSumMt      + TargSumMt      > SqrtS ) {
      Success = false; continue;}
    if( std::sqrt(ProjSumMt2perX) + std::sqrt(TargSumMt2perX) > SqrtS ) {
      Success = false; continue;}
 
  } while( (!Success) &&
           attempt < maxNumberOfAttempts );  /* Loop checking, 07.08.2015, A.Ribon */
 
  if ( attempt >= maxNumberOfAttempts ) {
    return false;
  }
 
  //+++++++++++++++++++++++++++++++++++++++++++
 
  G4double DecayMomentum2 = sqr(S) + sqr(ProjSumMt2perX) + sqr(TargSumMt2perX)
               - 2.0*S*ProjSumMt2perX - 2.0*S*TargSumMt2perX - 2.0*ProjSumMt2perX*TargSumMt2perX;
 
  G4double targetWminus=( S - ProjSumMt2perX + TargSumMt2perX + std::sqrt( DecayMomentum2 ))/2.0/SqrtS;
  G4double projectileWplus = SqrtS - TargSumMt2perX/targetWminus;
 
  G4LorentzVector Tmp(0.,0.,0.,0.);
  G4double z(0.);
 
  G4int nSeaPair = theProjectileSplitable->GetSoftCollisionCount()-1;
  #ifdef debugQGSParticipants
    G4cout<<"Backward transformation ===================="<<G4endl;
    G4cout<<"nSeaPair of proj "<<nSeaPair<<G4endl;
  #endif
 
  for (G4int aSeaPair = 0; aSeaPair < nSeaPair; aSeaPair++)
  {
    aParton = theProjectileSplitable->GetNextParton();   // for quarks
    #ifdef debugQGSParticipants
      G4cout<<"Sea quarks: "<<aSeaPair<<" "<<aParton->GetDefinition()->GetParticleName();
    #endif
    Tmp =aParton->Get4Momentum(); z=Tmp.z();
 
    Tmp.setPz(projectileWplus*z/2.0 - Tmp.e()/(2.0*z*projectileWplus));
    Tmp.setE( projectileWplus*z/2.0 + Tmp.e()/(2.0*z*projectileWplus)); 
    Tmp.transform( toLab );
 
    aParton->Set4Momentum(Tmp);
 
    aParton = theProjectileSplitable->GetNextAntiParton();          // for anti-quarks
    #ifdef debugQGSParticipants
      G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
      G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<G4endl;
    #endif
    Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
    Tmp.setPz(projectileWplus*z/2.0 - Tmp.e()/(2.0*z*projectileWplus));
    Tmp.setE( projectileWplus*z/2.0 + Tmp.e()/(2.0*z*projectileWplus)); 
    Tmp.transform( toLab );
 
    aParton->Set4Momentum(Tmp);
    #ifdef debugQGSParticipants
      G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<G4endl;
    #endif
  } 
 
  // For valence quark
  aParton = theProjectileSplitable->GetNextParton();   // for quarks
  #ifdef debugQGSParticipants
    G4cout<<"Val quark of Pr"<<" "<<aParton->GetDefinition()->GetParticleName();
  #endif
  Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
  Tmp.setPz(projectileWplus*z/2.0 - Tmp.e()/(2.0*z*projectileWplus));
  Tmp.setE( projectileWplus*z/2.0 + Tmp.e()/(2.0*z*projectileWplus)); 
  Tmp.transform( toLab );
 
  aParton->Set4Momentum(Tmp);
 
  // For valence di-quark
  aParton = theProjectileSplitable->GetNextAntiParton();
  #ifdef debugQGSParticipants
    G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
    G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<" (mass)"<<G4endl;
  #endif
  Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
  Tmp.setPz(projectileWplus*z/2.0 - Tmp.e()/(2.0*z*projectileWplus));
  Tmp.setE( projectileWplus*z/2.0 + Tmp.e()/(2.0*z*projectileWplus)); 
  Tmp.transform( toLab );
 
  aParton->Set4Momentum(Tmp);
 
  #ifdef debugQGSParticipants
    G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<" (mass)"<<G4endl;
    NuclNo=0;
  #endif
 
  // End of work with the projectile
 
  // Work with target nucleons 
  for(i = theTargets.begin(); i != theTargets.end(); i++ )
  {
    nSeaPair = (*i)->GetSoftCollisionCount()-1;
    #ifdef debugQGSParticipants
      G4cout<<"nSeaPair of target and N# "<<nSeaPair<<" "<<NuclNo<<G4endl;
      NuclNo++;
    #endif
    for (G4int aSeaPair = 0; aSeaPair < nSeaPair; aSeaPair++)
    {
      aParton = (*i)->GetNextParton();   // for quarks
      #ifdef debugQGSParticipants
        G4cout<<"Sea quarks: "<<aSeaPair<<" "<<aParton->GetDefinition()->GetParticleName();
      #endif
      Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
      Tmp.setPz(-targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus));
      Tmp.setE(  targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus)); 
      Tmp.transform( toLab );
 
      aParton->Set4Momentum(Tmp);
 
      aParton = (*i)->GetNextAntiParton();   // for quarks
      #ifdef debugQGSParticipants
        G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
        G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<G4endl;
      #endif
      Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
      Tmp.setPz(-targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus));
      Tmp.setE(  targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus)); 
      Tmp.transform( toLab );
 
      aParton->Set4Momentum(Tmp);
      #ifdef debugQGSParticipants
        G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<G4endl;
      #endif
    } 
 
    // Valence quark
 
    aParton = (*i)->GetNextParton();   // for quarks
    #ifdef debugQGSParticipants
      G4cout<<"Val quark of Tr"<<" "<<aParton->GetDefinition()->GetParticleName();
    #endif
    Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
    Tmp.setPz(-targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus));
    Tmp.setE(  targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus)); 
    Tmp.transform( toLab );
 
    aParton->Set4Momentum(Tmp);
 
    // Valence di-quark
    aParton = (*i)->GetNextAntiParton();   // for quarks
    #ifdef debugQGSParticipants
      G4cout<<" "<<aParton->GetDefinition()->GetParticleName()<<G4endl;
      G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<" (mass)"<<G4endl;
    #endif
    Tmp =aParton->Get4Momentum(); z=Tmp.z(); 
    Tmp.setPz(-targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus));
    Tmp.setE(  targetWminus*z/2.0 + Tmp.e()/(2.0*z*targetWminus)); 
    Tmp.transform( toLab );
 
    aParton->Set4Momentum(Tmp);
    #ifdef debugQGSParticipants
      G4cout<<"              "<<Tmp<<" "<<Tmp.mag()<<" (mass)"<<G4endl;
      NuclNo++;
    #endif
  }   // End of for(i = theTargets.begin(); i != theTargets.end(); i++ )
 
  return true;
}

Referenced by BuildInteractions().

DoLorentzBoost()

virtual void G4QGSParticipants::DoLorentzBoost ( G4ThreeVector aBoost )

inlinevirtual

Definition at line 55 of file G4QGSParticipants.hh.

    {
                theCurrentVelocity = -aBoost;
        if(theNucleus) theNucleus->DoLorentzBoost(aBoost);
        theBoost = aBoost;
    }

GetNextPartonPair()

G4PartonPair * G4QGSParticipants::GetNextPartonPair ( )

inline

Definition at line 212 of file G4QGSParticipants.hh.

{
    if (thePartonPairs.empty()) return 0;
    G4PartonPair * result = thePartonPairs.back();
    thePartonPairs.pop_back();
    return result;
}

operator!=()

G4bool G4QGSParticipants::operator!=

(

const G4QGSParticipants &

right

)

const

operator=()

const G4QGSParticipants & G4QGSParticipants::operator=

(

const G4QGSParticipants &

right

)

operator==()

G4bool G4QGSParticipants::operator==

(

const G4QGSParticipants &

right

)

const

PerformDiffractiveCollisions()

void G4QGSParticipants::PerformDiffractiveCollisions ( )

protected

Definition at line 1460 of file G4QGSParticipants.cc.

{
  #ifdef debugQGSParticipants
   G4cout<<G4endl<<"PerformDiffractiveCollisions()......"<<G4endl
         <<"theInteractions.size() "<<theInteractions.size()<<G4endl;
  #endif
 
  unsigned int i;
  for (i = 0; i < theInteractions.size(); i++)
  {
    G4InteractionContent* anIniteraction = theInteractions[i];
    #ifdef debugQGSParticipants
      G4cout<<"Interaction # and its status "
            <<i<<" "<<theInteractions[i]->GetStatus()<<G4endl;
    #endif
 
    G4int InterStatus = theInteractions[i]->GetStatus(); 
    if ( (InterStatus == PrD) || (InterStatus == TrD) || (InterStatus == DD))
    {  // Selection of diffractive interactions
      #ifdef debugQGSParticipants
        G4cout<<"Simulation of diffractive interaction. "<<InterStatus <<" PrD/TrD/DD/ND/Qech - 0,1,2,3,4"<<G4endl;
      #endif
 
      G4VSplitableHadron* aTarget = anIniteraction->GetTarget();
 
      #ifdef debugQGSParticipants
        G4cout<<"The proj. before inter "
              <<theProjectileSplitable->Get4Momentum()<<" "
              <<theProjectileSplitable->Get4Momentum().mag()<<G4endl;
        G4cout<<"The targ. before inter " <<aTarget->Get4Momentum()<<" "
              <<aTarget->Get4Momentum().mag()<<G4endl;
      #endif
 
      if ( InterStatus == PrD ) 
        theSingleDiffExcitation.ExciteParticipants(theProjectileSplitable, aTarget, TRUE); 
 
      if ( InterStatus == TrD ) 
        theSingleDiffExcitation.ExciteParticipants(theProjectileSplitable, aTarget, FALSE);
 
      if ( InterStatus == DD ) 
        theDiffExcitaton.ExciteParticipants(theProjectileSplitable, aTarget);
 
      #ifdef debugQGSParticipants
        G4cout<<"The proj. after  inter " <<theProjectileSplitable->Get4Momentum()<<" "
              <<theProjectileSplitable->Get4Momentum().mag()<<G4endl;
    G4cout<<"The targ. after  inter " <<aTarget->Get4Momentum()<<" "
              <<aTarget->Get4Momentum().mag()<<G4endl;
      #endif
    }
 
    if ( InterStatus == Qexc )
    {  // Quark exchange process
      #ifdef debugQGSParticipants
        G4cout<<"Simulation of interaction with quark exchange."<<G4endl;
      #endif
      G4VSplitableHadron* aTarget = anIniteraction->GetTarget();
 
      #ifdef debugQGSParticipants
        G4cout<<"The proj. before inter " <<theProjectileSplitable->Get4Momentum()<<" "
              <<theProjectileSplitable->Get4Momentum().mag()<<G4endl;
        G4cout<<"The targ. before inter "<<aTarget->Get4Momentum()<<" "
              <<aTarget->Get4Momentum().mag()<<G4endl;
      #endif
 
      theQuarkExchange.ExciteParticipants(theProjectileSplitable, aTarget);
 
      #ifdef debugQGSParticipants
        G4cout<<"The proj. after  inter " <<theProjectileSplitable->Get4Momentum()<<" "
              <<theProjectileSplitable->Get4Momentum().mag()<<G4endl;
    G4cout<<"The targ. after  inter " <<aTarget->Get4Momentum()<<" "
              <<aTarget->Get4Momentum().mag()<<G4endl;
      #endif
    }
  }
}

Referenced by BuildInteractions().

PerformSoftCollisions()

void G4QGSParticipants::PerformSoftCollisions ( )

protected

Definition at line 2331 of file G4QGSParticipants.cc.

{
  std::vector<G4InteractionContent*>::iterator i;
  G4LorentzVector str4Mom;
  i = theInteractions.begin();
  while ( i != theInteractions.end() )  /* Loop checking, 07.08.2015, A.Ribon */
  {
    G4InteractionContent* anIniteraction = *i;
    G4PartonPair * aPair = NULL;
    if (anIniteraction->GetNumberOfSoftCollisions())
    {
      G4VSplitableHadron* pProjectile = anIniteraction->GetProjectile();
      G4VSplitableHadron* pTarget     = anIniteraction->GetTarget();
      for (G4int j = 0; j < anIniteraction->GetNumberOfSoftCollisions(); j++)
      {
        aPair = new G4PartonPair(pTarget->GetNextParton(), pProjectile->GetNextAntiParton(),
                 G4PartonPair::SOFT, G4PartonPair::TARGET);
    #ifdef debugQGSParticipants
      G4cout << "SoftPair " << aPair->GetParton1()->GetPDGcode() << " "
         << aPair->GetParton1()->Get4Momentum() << " "
         << aPair->GetParton1()->GetX() << " " << G4endl;
      G4cout << "         " << aPair->GetParton2()->GetPDGcode() << " "
         << aPair->GetParton2()->Get4Momentum() << " "
         << aPair->GetParton2()->GetX() << " " << G4endl;
    #endif
    #ifdef debugQGSParticipants
      str4Mom += aPair->GetParton1()->Get4Momentum();
      str4Mom += aPair->GetParton2()->Get4Momentum();
    #endif
    thePartonPairs.push_back(aPair);
    aPair = new G4PartonPair(pProjectile->GetNextParton(), pTarget->GetNextAntiParton(),
                 G4PartonPair::SOFT, G4PartonPair::PROJECTILE);
    #ifdef debugQGSParticipants
      G4cout << "SoftPair " << aPair->GetParton1()->GetPDGcode() << " "
         << aPair->GetParton1()->Get4Momentum() << " "
         << aPair->GetParton1()->GetX() << " " << G4endl;
      G4cout << "         " << aPair->GetParton2()->GetPDGcode() << " "
         << aPair->GetParton2()->Get4Momentum() << " "
         << aPair->GetParton2()->GetX() << " " << G4endl;
    #endif
    #ifdef debugQGSParticipants
      str4Mom += aPair->GetParton1()->Get4Momentum();
      str4Mom += aPair->GetParton2()->Get4Momentum();
    #endif
    thePartonPairs.push_back(aPair);
      }
      delete *i;
      i=theInteractions.erase(i);    // i now points to the next interaction
    } else {
      i++;
    }
  }
  #ifdef debugQGSParticipants
    G4cout << " string 4 mom " << str4Mom << G4endl;
  #endif
}

SampleX()

G4double G4QGSParticipants::SampleX ( G4double anXmin, G4int nSea, G4int theTotalSea, G4double aBeta )

protected

Definition at line 2042 of file G4QGSParticipants.cc.

{
  G4double Oalfa = 1./(alpha + 1.);
  G4double Obeta = 1./(aBeta + (alpha + 1.)*nSea + 1.);  // ?
 
  G4double Ksi1, Ksi2, r1, r2, r12;
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do
  {
    Ksi1 = G4UniformRand(); r1 = G4Pow::GetInstance()->powA(Ksi1,Oalfa);
    Ksi2 = G4UniformRand(); r2 = G4Pow::GetInstance()->powA(Ksi2,Obeta); 
    r12=r1+r2;
  } while( ( r12 > 1.) &&
           ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    return 0.5;  // Just an acceptable value, without any physics consideration.
  }
 
  G4double result = r1/r12;
  return result;
} 

Referenced by DeterminePartonMomenta().

SelectInteractions()

G4VSplitableHadron * G4QGSParticipants::SelectInteractions ( const G4ReactionProduct & thePrimary )

protectedvirtual

Definition at line 2390 of file G4QGSParticipants.cc.

{
  // Check reaction threshold  - goes to CheckThreshold
 
  theProjectileSplitable = new G4QGSMSplitableHadron(thePrimary, TRUE);
  theProjectileSplitable->SetStatus(1);
 
  G4LorentzVector aPrimaryMomentum(thePrimary.GetMomentum(), thePrimary.GetTotalEnergy());
  G4LorentzVector aTargetNMomentum(0.,0.,0.,938.);
 
  if ((!(aPrimaryMomentum.e()>-1)) && (!(aPrimaryMomentum.e()<1)) )
  {
    throw G4HadronicException(__FILE__, __LINE__,
                  "G4GammaParticipants::SelectInteractions: primary nan energy.");
  }
  G4double S = (aPrimaryMomentum + aTargetNMomentum).mag2();
  G4double ThresholdMass = thePrimary.GetMass() + 938.;
  ModelMode = SOFT;
 
  #ifdef debugQGSParticipants
    G4cout << "Gamma projectile - SelectInteractions " << G4endl;
    G4cout<<"Energy and Nucleus "<<thePrimary.GetTotalEnergy()<<" "<<theNucleus->GetMassNumber()<<G4endl;
    G4cout << "SqrtS ThresholdMass ModelMode " <<std::sqrt(S)<<" "<<ThresholdMass<<" "<<ModelMode<< G4endl;
  #endif
 
  if (sqr(ThresholdMass + ThresholdParameter) > S)
  {
    ModelMode = DIFFRACTIVE;
  }
  if (sqr(ThresholdMass + QGSMThreshold) > S) // thus only diffractive in cascade!
  {
    ModelMode = DIFFRACTIVE;
  }
 
  // first find the collisions HPW
  std::for_each(theInteractions.begin(), theInteractions.end(), DeleteInteractionContent());
  theInteractions.clear();
 
  G4int theCurrent = G4int(theNucleus->GetMassNumber()*G4UniformRand());
  G4int NucleonNo=0;
 
  theNucleus->StartLoop();
  G4Nucleon * pNucleon = 0;
 
  while( (pNucleon = theNucleus->GetNextNucleon()) )  /* Loop checking, 07.08.2015, A.Ribon */
  { if(NucleonNo == theCurrent) break; NucleonNo++; }
 
  if ( pNucleon ) {
    G4QGSMSplitableHadron* aTarget = new G4QGSMSplitableHadron(*pNucleon);
 
    pNucleon->Hit(aTarget);
 
    if ( (0.06 > G4UniformRand() &&(ModelMode==SOFT)) || (ModelMode==DIFFRACTIVE ) )
    {
      G4InteractionContent * aInteraction = new G4InteractionContent(theProjectileSplitable);
      theProjectileSplitable->SetStatus(1*theProjectileSplitable->GetStatus());
 
      aInteraction->SetTarget(aTarget);
      aInteraction->SetTargetNucleon(pNucleon);
      aTarget->SetCollisionCount(0);
      aTarget->SetStatus(1);
 
      aInteraction->SetNumberOfDiffractiveCollisions(1);
      aInteraction->SetNumberOfSoftCollisions(0);
      aInteraction->SetStatus(1);
 
      theInteractions.push_back(aInteraction);
    }
    else
    {
      // nondiffractive soft interaction occurs
      aTarget->IncrementCollisionCount(1);
      aTarget->SetStatus(0);
      theTargets.push_back(aTarget);
 
      theProjectileSplitable->IncrementCollisionCount(1);
      theProjectileSplitable->SetStatus(0*theProjectileSplitable->GetStatus());
 
      G4InteractionContent * aInteraction = new G4InteractionContent(theProjectileSplitable);
      aInteraction->SetTarget(aTarget);
      aInteraction->SetTargetNucleon(pNucleon);
      aInteraction->SetNumberOfSoftCollisions(1);
      aInteraction->SetStatus(3);
      theInteractions.push_back(aInteraction);
    }
  }
  return theProjectileSplitable;
}

Referenced by BuildInteractions().

SplitHadrons()

void G4QGSParticipants::SplitHadrons ( )

inlineprotected

Definition at line 220 of file G4QGSParticipants.hh.

{
    unsigned int i;
    for(i = 0; i < theInteractions.size(); i++)
    {
        theInteractions[i]->SplitHadrons();
    }
}

Referenced by BuildInteractions().

StartPartonPairLoop()

void G4QGSParticipants::StartPartonPairLoop ( )

inline

Definition at line 208 of file G4QGSParticipants.hh.

{
}

Member Data Documentation

ModelMode

G4int G4QGSParticipants::ModelMode

protected

Definition at line 150 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

nCutMax

const G4int G4QGSParticipants::nCutMax

protected

Definition at line 161 of file G4QGSParticipants.hh.

QGSMThreshold

const G4double G4QGSParticipants::QGSMThreshold

protected

Definition at line 163 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

theBoost

G4ThreeVector G4QGSParticipants::theBoost

protected

Definition at line 152 of file G4QGSParticipants.hh.

Referenced by DoLorentzBoost().

theCurrentVelocity

G4ThreeVector G4QGSParticipants::theCurrentVelocity

protected

Definition at line 166 of file G4QGSParticipants.hh.

Referenced by DoLorentzBoost().

theDiffExcitaton

G4QGSDiffractiveExcitation G4QGSParticipants::theDiffExcitaton

protected

Definition at line 149 of file G4QGSParticipants.hh.

Referenced by PerformDiffractiveCollisions().

theInteractions

std::vector<G4InteractionContent*> G4QGSParticipants::theInteractions

protected

Definition at line 141 of file G4QGSParticipants.hh.

Referenced by BuildInteractions(), PerformDiffractiveCollisions(), PerformSoftCollisions(), SelectInteractions(), and SplitHadrons().

theNucleonRadius

const G4double G4QGSParticipants::theNucleonRadius

protected

Definition at line 164 of file G4QGSParticipants.hh.

thePartonPairs

std::vector<G4PartonPair*> G4QGSParticipants::thePartonPairs

protected

Definition at line 145 of file G4QGSParticipants.hh.

Referenced by GetNextPartonPair(), and PerformSoftCollisions().

theProjectileSplitable

G4QGSMSplitableHadron* G4QGSParticipants::theProjectileSplitable

protected

Definition at line 167 of file G4QGSParticipants.hh.

Referenced by BuildInteractions(), DeterminePartonMomenta(), PerformDiffractiveCollisions(), and SelectInteractions().

theQuarkExchange

G4QuarkExchange G4QGSParticipants::theQuarkExchange

protected

Definition at line 147 of file G4QGSParticipants.hh.

Referenced by PerformDiffractiveCollisions().

theSingleDiffExcitation

G4SingleDiffractiveExcitation G4QGSParticipants::theSingleDiffExcitation

protected

Definition at line 148 of file G4QGSParticipants.hh.

Referenced by PerformDiffractiveCollisions().

theTargets

std::vector<G4VSplitableHadron*> G4QGSParticipants::theTargets

protected

Definition at line 143 of file G4QGSParticipants.hh.

Referenced by BuildInteractions(), DeterminePartonMomenta(), and SelectInteractions().

ThresholdParameter

const G4double G4QGSParticipants::ThresholdParameter

protected

Definition at line 162 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

---

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

• G4QGSParticipants.hh
• G4QGSParticipants.cc