G4SingleDiffractiveExcitation Class Reference

#include <G4SingleDiffractiveExcitation.hh>

Inheritance diagram for G4SingleDiffractiveExcitation:

Public Member Functions
G4bool	ExciteParticipants (G4VSplitableHadron *aPartner, G4VSplitableHadron *bPartner, G4bool ProjectileDiffraction) const
	G4SingleDiffractiveExcitation ()
virtual G4ExcitedString *	String (G4VSplitableHadron *aHadron, G4bool isProjectile) const
	~G4SingleDiffractiveExcitation ()

Private Member Functions
G4double	ChooseP (G4double Pmin, G4double Pmax) const
G4double	ChooseX (G4double Xmin, G4double Xmax) const
	G4SingleDiffractiveExcitation (const G4SingleDiffractiveExcitation &right)
G4ThreeVector	GaussianPt (G4double widthSquare, G4double maxPtSquare) const
G4bool	operator!= (const G4SingleDiffractiveExcitation &right) const
const G4SingleDiffractiveExcitation &	operator= (const G4SingleDiffractiveExcitation &right)
G4bool	operator== (const G4SingleDiffractiveExcitation &right) const

Detailed Description

Definition at line 48 of file G4SingleDiffractiveExcitation.hh.

Constructor & Destructor Documentation

G4SingleDiffractiveExcitation() [1/2]

G4SingleDiffractiveExcitation::G4SingleDiffractiveExcitation

(

)

Definition at line 53 of file G4SingleDiffractiveExcitation.cc.

{}

~G4SingleDiffractiveExcitation()

G4SingleDiffractiveExcitation::~G4SingleDiffractiveExcitation

(

)

Definition at line 55 of file G4SingleDiffractiveExcitation.cc.

{}

G4SingleDiffractiveExcitation() [2/2]

G4SingleDiffractiveExcitation::G4SingleDiffractiveExcitation ( const G4SingleDiffractiveExcitation &  right )

private

Member Function Documentation

ChooseP()

G4double G4QGSDiffractiveExcitation::ChooseP ( G4double  Pmin, G4double  Pmax  ) const

privateinherited

Definition at line 375 of file G4QGSDiffractiveExcitation.cc.

{
  // choose an x between Xmin and Xmax with P(x) ~ 1/x
  //  to be improved...
 
  G4double range=Pmax-Pmin;
 
  if ( Pmin <= 0. || range <=0. ) 
  {
    G4cout << " Pmin, range : " << Pmin << " , " << range << G4endl;
    throw G4HadronicException(__FILE__, __LINE__, "G4QGSDiffractiveExcitation::ChooseP : Invalid arguments ");
  }
 
  G4double P;
  P=Pmin * G4Pow::GetInstance()->powA(Pmax/Pmin,G4UniformRand());
  //debug-hpw   cout << "DiffractiveX "<<x<<G4endl;
  return P;
}

References G4cout, G4endl, G4UniformRand, G4Pow::GetInstance(), P, anonymous_namespace{G4ChipsKaonMinusInelasticXS.cc}::Pmax, anonymous_namespace{G4ChipsKaonMinusInelasticXS.cc}::Pmin, and G4Pow::powA().

Referenced by G4QGSDiffractiveExcitation::ExciteParticipants().

ChooseX()

G4double G4SingleDiffractiveExcitation::ChooseX ( G4double  Xmin, G4double  Xmax  ) const

private

Definition at line 279 of file G4SingleDiffractiveExcitation.cc.

{
  // choose an x between Xmin and Xmax with P(x) ~ 1/x
  G4double range=Xmax-Xmin;
 
  if ( Xmin <= 0. || range <=0. ) 
  {
    G4cout << " Xmin, range : " << Xmin << " , " << range << G4endl;
    throw G4HadronicException(__FILE__, __LINE__, "G4SingleDiffractiveExcitation::ChooseX : Invalid arguments ");
  }
 
  G4double x = Xmin*G4Pow::GetInstance()->powA(Xmax/Xmin, G4UniformRand() );
  // G4double x = 1.0/sqr(1.0/std::sqrt(Xmin) - G4UniformRand() * (1.0/std::sqrt(Xmin) - 1.0/std::sqrt(Xmax)));
  return x;
}

References G4cout, G4endl, G4UniformRand, G4Pow::GetInstance(), and G4Pow::powA().

Referenced by ExciteParticipants().

ExciteParticipants()

G4bool G4SingleDiffractiveExcitation::ExciteParticipants ( G4VSplitableHadron *  aPartner, G4VSplitableHadron *  bPartner, G4bool  ProjectileDiffraction  ) const

virtual

Reimplemented from G4QGSDiffractiveExcitation.

Definition at line 57 of file G4SingleDiffractiveExcitation.cc.

{
  #ifdef debugSingleDiffraction
    G4cout<<G4endl<<"G4SingleDiffractiveExcitation::ExciteParticipants"<<G4endl;
  #endif
 
  G4LorentzVector Pprojectile=projectile->Get4Momentum();
  G4double Mprojectile =    projectile->GetDefinition()->GetPDGMass();
  G4double Mprojectile2=sqr(projectile->GetDefinition()->GetPDGMass());
 
  G4LorentzVector Ptarget=target->Get4Momentum();
  G4double Mtarget =    target->GetDefinition()->GetPDGMass();
  G4double Mtarget2=sqr(target->GetDefinition()->GetPDGMass());
 
  #ifdef debugSingleDiffraction
    G4cout<<"Proj Targ "<<projectile->GetDefinition()->GetPDGEncoding()<<" "<<target->GetDefinition()->GetPDGEncoding()<<G4endl;
    G4cout<<"Pr Tr 4-Mom "<<Pprojectile<<" "<<Pprojectile.mag()<<G4endl
          <<"            "<<Ptarget    <<" "<<Ptarget.mag()   <<G4endl;
  #endif
 
  G4LorentzVector Psum=Pprojectile+Ptarget;
  G4double SqrtS=Psum.mag();
  G4double S    =Psum.mag2();
 
  #ifdef debugSingleDiffraction
    G4cout<<"SqrtS-Mprojectile-Mtarget "<<SqrtS<<" "<<Mprojectile<<" "<<Mtarget
          <<" "<<SqrtS-Mprojectile-Mtarget<<G4endl;
  #endif
  if (SqrtS-Mprojectile-Mtarget <= 250.0*MeV) {
    #ifdef debugSingleDiffraction
    G4cerr<<"Projectile: "<<projectile->GetDefinition()->GetPDGEncoding()<<" "
          <<Pprojectile<<" "<<Pprojectile.mag()<<G4endl;
    G4cerr<<"Target:     "<<target->GetDefinition()->GetPDGEncoding()<<" "
          <<Ptarget<<" "<<Ptarget.mag()<<G4endl; 
    G4cerr<<"sqrt(S) = "<<SqrtS<<" Mp + Mt = "<<Pprojectile.mag()+Ptarget.mag()<<G4endl;
    #endif
    return true;
  }
 
  G4LorentzRotation toCms(-1*Psum.boostVector());
 
  G4LorentzVector Ptmp=toCms*Pprojectile;
 
  if ( Ptmp.pz() <= 0. )
  {
    // "String" moving backwards in  CMS, abort collision !!
    //         G4cout << " abort Collision!! " << G4endl;
    return false;
  }
 
  toCms.rotateZ(-1*Ptmp.phi());
  toCms.rotateY(-1*Ptmp.theta());
 
  G4LorentzRotation toLab(toCms.inverse());
 
  Pprojectile.transform(toCms);
  Ptarget.transform(toCms);
  #ifdef debugSingleDiffraction
    G4cout << "Pprojectile  in CMS " << Pprojectile << G4endl;
    G4cout << "Ptarget      in CMS " << Ptarget     << G4endl;
  #endif
  G4double maxPtSquare=sqr(Ptarget.pz());
 
  G4double ProjectileMinDiffrMass(0.), TargetMinDiffrMass(0.);
  G4double AveragePt2(0.);
  G4int absPDGcode=std::abs(projectile->GetDefinition()->GetPDGEncoding()); 
 
  if ( ProjectileDiffraction ) {
    if ( absPDGcode > 1000 )                            //------Projectile is baryon --------
    {
      if ( absPDGcode > 4000 && absPDGcode < 6000 )  // Projectile is a charm or bottom baryon
      {
        ProjectileMinDiffrMass = projectile->GetDefinition()->GetPDGMass()/CLHEP::GeV + 0.25;  // GeV
        AveragePt2 = 0.3;                                                                      // GeV^2
      }
      else
      {
        ProjectileMinDiffrMass = 1.16;              // GeV
        AveragePt2 = 0.3;                           // GeV^2
      }
    }
    else if( absPDGcode == 211 || absPDGcode ==  111) //------Projectile is Pion -----------
    {
      ProjectileMinDiffrMass = 1.0;               // GeV
      AveragePt2 = 0.3;                           // GeV^2
    }
    else if( absPDGcode == 321 || absPDGcode == 130 || absPDGcode == 310) //Projectile is Kaon
    {
      ProjectileMinDiffrMass = 1.1;               // GeV
      AveragePt2 = 0.3;                           // GeV^2
    }
    else if( absPDGcode == 22)                        //------Projectile is Gamma -----------
    {
      ProjectileMinDiffrMass = 0.25;             // GeV
      AveragePt2 = 0.36;                         // GeV^2
    }
    else if( absPDGcode > 400 && absPDGcode < 600)  // Projectile is a charm or bottom meson
    {
      ProjectileMinDiffrMass = projectile->GetDefinition()->GetPDGMass()/CLHEP::GeV + 0.25;  // GeV
      AveragePt2 = 0.3;                                                                      // GeV^2
    }
    else                                             //------Projectile is undefined, Nucleon assumed
    {
      ProjectileMinDiffrMass = 1.1;              // GeV
      AveragePt2 = 0.3;                          // GeV^2
    };
 
    ProjectileMinDiffrMass = ProjectileMinDiffrMass * GeV;
    Mprojectile2=sqr(ProjectileMinDiffrMass);
  }
  else
  {
    TargetMinDiffrMass = 1.16*GeV;                     // For target nucleon
    Mtarget2 = sqr( TargetMinDiffrMass) ;
    AveragePt2 = 0.3;                                  // GeV^2
  }   // end of if ( ProjectileDiffraction )
 
  AveragePt2 = AveragePt2 * GeV*GeV;
 
  G4double Pt2, PZcms, PZcms2;
  G4double ProjMassT2, ProjMassT;
  G4double TargMassT2, TargMassT;
  G4double PMinusMin, PMinusMax;
  G4double TPlusMin, TPlusMax;
  G4double PMinusNew, PPlusNew, TPlusNew, TMinusNew;
 
  G4LorentzVector Qmomentum;
  G4double Qminus, Qplus;
 
  G4int whilecount=0;
  do {
    whilecount++;
 
    if (whilecount > 1000 )
    {
      Qmomentum=G4LorentzVector(0.,0.,0.,0.);
      return false;       //  Ignore this interaction
    }
        
    //  Generate pt
    Qmomentum=G4LorentzVector(GaussianPt(AveragePt2,maxPtSquare),0);
 
    Pt2 = G4ThreeVector( Qmomentum.vect() ).mag2();
 
    ProjMassT2 = Mprojectile2 + Pt2;
    ProjMassT = std::sqrt( ProjMassT2 );
    TargMassT2 = Mtarget2 + Pt2;
    TargMassT = std::sqrt( TargMassT2 );
 
    #ifdef debugSingleDiffraction
      G4cout<<whilecount<<" "<<Pt2<<" "<<ProjMassT<<" "<<TargMassT<<" "<<SqrtS<<" "<<S<<" "<<ProjectileDiffraction<<G4endl;
    #endif
    if ( SqrtS < ProjMassT + TargMassT ) continue;
 
    PZcms2 = ( S*S + ProjMassT2*ProjMassT2 + TargMassT2*TargMassT2
              - 2.0*S*ProjMassT2 - 2.0*S*TargMassT2 - 2.0*ProjMassT2*TargMassT2 ) / 4.0 / S;
 
    if ( PZcms2 < 0 ) continue;
 
    PZcms = std::sqrt( PZcms2 );
 
    if ( ProjectileDiffraction )
    {       // The projectile will fragment, the target will saved.
      PMinusMin = std::sqrt( ProjMassT2 + PZcms2 ) - PZcms;
      PMinusMax = SqrtS - TargMassT;
 
      PMinusNew = ChooseX( PMinusMin, PMinusMax );
      TMinusNew = SqrtS - PMinusNew;
 
      Qminus = Ptarget.minus() - TMinusNew;
      TPlusNew = TargMassT2 / TMinusNew;
      Qplus = Ptarget.plus() - TPlusNew;
 
    } else {  // The target will fragment, the projectile will saved.
      TPlusMin = std::sqrt( TargMassT2 + PZcms2 ) - PZcms;
      TPlusMax = SqrtS - ProjMassT;
    
      TPlusNew = ChooseX( TPlusMin, TPlusMax );
      PPlusNew = SqrtS - TPlusNew;
 
      Qplus = PPlusNew - Pprojectile.plus();
      PMinusNew = ProjMassT2 / PPlusNew;
      Qminus = PMinusNew - Pprojectile.minus();
    }
  
    Qmomentum.setPz( (Qplus - Qminus)/2 );
    Qmomentum.setE(  (Qplus + Qminus)/2 );
 
    #ifdef debugSingleDiffraction
      G4cout<<ProjectileDiffraction<<" "<<( Pprojectile + Qmomentum ).mag2()<<" "<< Mprojectile2<<G4endl;
      G4cout<<!ProjectileDiffraction<<" "<<( Ptarget    - Qmomentum ).mag2()<<" "<< Mtarget2<<G4endl;
    #endif
 
  } while ( ( ProjectileDiffraction&&( Pprojectile + Qmomentum ).mag2() <  Mprojectile2 ) ||
            (!ProjectileDiffraction&&( Ptarget     - Qmomentum ).mag2() <  Mtarget2       )   ); 
    // Repeat the sampling because there was not any excitation
 
  Pprojectile += Qmomentum;
 
  Ptarget     -= Qmomentum;
 
  // Transform back and update SplitableHadron Participant.
  Pprojectile.transform(toLab);
  Ptarget.transform(toLab);
 
  #ifdef debugSingleDiffraction
    G4cout << "Pprojectile  in Lab. " << Pprojectile << G4endl;
    G4cout << "Ptarget      in Lab. " << Ptarget     << G4endl;
    G4cout << "G4SingleDiffractiveExcitation- Projectile mass  " <<  Pprojectile.mag() << G4endl;
    G4cout << "G4SingleDiffractiveExcitation- Target mass      " <<  Ptarget.mag() << G4endl;
  #endif
 
  target->Set4Momentum(Ptarget);
  projectile->Set4Momentum(Pprojectile);
 
  return true;
}

References CLHEP::HepLorentzVector::boostVector(), ChooseX(), G4cerr, G4cout, G4endl, GaussianPt(), G4VSplitableHadron::Get4Momentum(), G4VSplitableHadron::GetDefinition(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), CLHEP::GeV, GeV, CLHEP::HepLorentzRotation::inverse(), CLHEP::HepLorentzVector::mag(), CLHEP::HepLorentzVector::mag2(), CLHEP::Hep3Vector::mag2(), MeV, CLHEP::HepLorentzVector::minus(), CLHEP::HepLorentzVector::phi(), CLHEP::HepLorentzVector::plus(), CLHEP::HepLorentzVector::pz(), CLHEP::HepLorentzRotation::rotateY(), CLHEP::HepLorentzRotation::rotateZ(), S(), G4VSplitableHadron::Set4Momentum(), CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPz(), sqr(), CLHEP::HepLorentzVector::theta(), CLHEP::HepLorentzVector::transform(), and CLHEP::HepLorentzVector::vect().

Referenced by G4QGSParticipants::PerformDiffractiveCollisions().

GaussianPt()

G4ThreeVector G4SingleDiffractiveExcitation::GaussianPt ( G4double  widthSquare, G4double  maxPtSquare  ) const

private

Definition at line 296 of file G4SingleDiffractiveExcitation.cc.

{            //  @@ this method is used in FTFModel as well. Should go somewhere common!
 
  G4double pt2;
 
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do {
    pt2=-widthSquare * G4Log( G4UniformRand() );
  } while ( ( pt2 > maxPtSquare) && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 07.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    pt2 = 0.99*maxPtSquare;  // Just an acceptable value, without any physics consideration. 
  }
 
  pt2=std::sqrt(pt2);
 
  G4double phi=G4UniformRand() * twopi;
 
  return G4ThreeVector (pt2*std::cos(phi), pt2*std::sin(phi), 0.);    
}

References G4Log(), G4UniformRand, and twopi.

Referenced by ExciteParticipants().

operator!=()

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

private

operator=()

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

private

operator==()

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

private

String()

G4ExcitedString * G4QGSDiffractiveExcitation::String ( G4VSplitableHadron *  aHadron, G4bool  isProjectile  ) const

virtualinherited

Definition at line 300 of file G4QGSDiffractiveExcitation.cc.

{
  hadron->SplitUp();
  G4Parton *start= hadron->GetNextParton();
  if ( start==NULL) 
  { G4cout << " G4QGSDiffractiveExcitation::String() Error:No start parton found"<< G4endl;
    return NULL;
  }
  G4Parton *end  = hadron->GetNextParton();
  if ( end==NULL) 
  { G4cout << " G4QGSDiffractiveExcitation::String() Error:No end parton found"<< G4endl;
    return NULL;
  }
 
  G4ExcitedString * string;
  if ( isProjectile ) 
  {
    string= new G4ExcitedString(end,start, +1);
  } else {
    string= new G4ExcitedString(start,end, -1);
  }
 
  string->SetPosition(hadron->GetPosition());
 
  // momenta of string ends
 
  G4double maxAvailMomentumSquared=sqr(hadron->Get4Momentum().mag()/2.);
 
  G4double widthOfPtSquare = 0.5*sqr(GeV);
  G4ThreeVector pt=GaussianPt(widthOfPtSquare,maxAvailMomentumSquared);
 
  G4LorentzVector Pstart(G4LorentzVector(pt,0.));
  G4LorentzVector Pend;
  Pend.setPx(hadron->Get4Momentum().px() - pt.x());
  Pend.setPy(hadron->Get4Momentum().py() - pt.y());
 
  G4double tm1=hadron->Get4Momentum().minus() +
           ( Pend.perp2()-Pstart.perp2() ) / hadron->Get4Momentum().plus();
 
  G4double tm2= std::sqrt( std::max(0., sqr(tm1) -
               4. * Pend.perp2() * hadron->Get4Momentum().minus()
               /  hadron->Get4Momentum().plus() ));
 
  G4int Sign= isProjectile ? -1 : 1;
 
  G4double endMinus  = 0.5 * (tm1 + Sign*tm2);
  G4double startMinus= hadron->Get4Momentum().minus() - endMinus;
 
  G4double startPlus= Pstart.perp2() /  startMinus;
  G4double endPlus  = hadron->Get4Momentum().plus() - startPlus;
 
  Pstart.setPz(0.5*(startPlus - startMinus));
  Pstart.setE(0.5*(startPlus + startMinus));
 
  Pend.setPz(0.5*(endPlus - endMinus));
  Pend.setE(0.5*(endPlus + endMinus));
 
  start->Set4Momentum(Pstart);
  end->Set4Momentum(Pend);
 
  #ifdef debugQGSdiffExictation
    G4cout << " generated string flavors          " << start->GetPDGcode()   << " / " << end->GetPDGcode() << G4endl;
    G4cout << " generated string momenta:   quark " << start->Get4Momentum() << "mass : " <<start->Get4Momentum().mag()<< G4endl;
    G4cout << " generated string momenta: Diquark " << end ->Get4Momentum()  << "mass : " <<end->Get4Momentum().mag()<< G4endl;
    G4cout << " sum of ends                       " << Pstart+Pend << G4endl;
    G4cout << " Original                          " << hadron->Get4Momentum() << G4endl;
  #endif
 
  return string;    
}

References G4cout, G4endl, G4QGSDiffractiveExcitation::GaussianPt(), G4VSplitableHadron::Get4Momentum(), G4Parton::Get4Momentum(), G4VSplitableHadron::GetNextParton(), G4Parton::GetPDGcode(), G4VSplitableHadron::GetPosition(), GeV, CLHEP::HepLorentzVector::mag(), G4INCL::Math::max(), CLHEP::HepLorentzVector::minus(), CLHEP::HepLorentzVector::perp2(), CLHEP::HepLorentzVector::plus(), CLHEP::HepLorentzVector::px(), CLHEP::HepLorentzVector::py(), G4Parton::Set4Momentum(), CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPx(), CLHEP::HepLorentzVector::setPy(), CLHEP::HepLorentzVector::setPz(), G4VSplitableHadron::SplitUp(), sqr(), CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

---

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

• source/processes/hadronic/models/parton_string/qgsm/include/G4SingleDiffractiveExcitation.hh
• source/processes/hadronic/models/parton_string/qgsm/src/G4SingleDiffractiveExcitation.cc