Gabriele Cosmo
336 lines
11 KiB
C++
336 lines
11 KiB
C++
//
|
|
// ********************************************************************
|
|
// * DISCLAIMER *
|
|
// * *
|
|
// * The following disclaimer summarizes all the specific disclaimers *
|
|
// * of contributors to this software. The specific disclaimers,which *
|
|
// * govern, are listed with their locations in: *
|
|
// * http://cern.ch/geant4/license *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. *
|
|
// * *
|
|
// * This code implementation is the intellectual property of the *
|
|
// * GEANT4 collaboration. *
|
|
// * By copying, distributing or modifying the Program (or any work *
|
|
// * based on the Program) you indicate your acceptance of this *
|
|
// * statement, and all its terms. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// $Id: G4DiffractiveExcitation.cc,v 1.2 2003/11/03 17:54:53 hpw Exp $
|
|
// ------------------------------------------------------------
|
|
// GEANT 4 class implemetation file
|
|
//
|
|
// ---------------- G4DiffractiveExcitation --------------
|
|
// by Gunter Folger, October 1998.
|
|
// diffractive Excitation used by strings models
|
|
// Take a projectile and a target
|
|
// excite the projectile and target
|
|
// ------------------------------------------------------------
|
|
|
|
|
|
#include "globals.hh"
|
|
#include "Randomize.hh"
|
|
|
|
#include "G4DiffractiveExcitation.hh"
|
|
#include "G4LorentzRotation.hh"
|
|
#include "G4ThreeVector.hh"
|
|
#include "G4ParticleDefinition.hh"
|
|
#include "G4VSplitableHadron.hh"
|
|
#include "G4ExcitedString.hh"
|
|
//#include "G4ios.hh"
|
|
|
|
G4DiffractiveExcitation::G4DiffractiveExcitation(G4double sigmaPt, G4double minextraMass,G4double x0mass)
|
|
:
|
|
widthOfPtSquare(-2*sqr(sigmaPt)) , minExtraMass(minextraMass),
|
|
minmass(x0mass)
|
|
{
|
|
}
|
|
|
|
G4bool G4DiffractiveExcitation::
|
|
ExciteParticipants(G4VSplitableHadron *projectile, G4VSplitableHadron *target) const
|
|
{
|
|
|
|
G4LorentzVector Pprojectile=projectile->Get4Momentum();
|
|
G4double Mprojectile2=sqr(projectile->GetDefinition()->GetPDGMass() + minExtraMass);
|
|
|
|
G4LorentzVector Ptarget=target->Get4Momentum();
|
|
G4double Mtarget2=sqr(target->GetDefinition()->GetPDGMass() + minExtraMass);
|
|
// G4cout << "E proj, target :" << Pprojectile.e() << ", " <<
|
|
// Ptarget.e() << G4endl;
|
|
|
|
// 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. )
|
|
{
|
|
// "String" moving backwards in CMS, abort collision !!
|
|
// G4cout << " abort Collision!! " << G4endl;
|
|
return false;
|
|
}
|
|
|
|
toCms.rotateZ(-1*Ptmp.phi());
|
|
toCms.rotateY(-1*Ptmp.theta());
|
|
|
|
// G4cout << "Pprojectile be4 boost " << Pprojectile << G4endl;
|
|
// G4cout << "Ptarget be4 boost : " << Ptarget << G4endl;
|
|
|
|
|
|
|
|
G4LorentzRotation toLab(toCms.inverse());
|
|
|
|
Pprojectile.transform(toCms);
|
|
Ptarget.transform(toCms);
|
|
|
|
// G4cout << "Pprojectile aft boost : " << Pprojectile << G4endl;
|
|
// G4cout << "Ptarget aft boost : " << Ptarget << G4endl;
|
|
// G4cout << "cms aft boost : " << (Pprojectile+ Ptarget) << G4endl;
|
|
|
|
// G4cout << " Projectile Xplus / Xminus : " <<
|
|
// Pprojectile.plus() << " / " << Pprojectile.minus() << G4endl;
|
|
// G4cout << " Target Xplus / Xminus : " <<
|
|
// Ptarget.plus() << " / " << Ptarget.minus() << G4endl;
|
|
|
|
G4LorentzVector Qmomentum;
|
|
G4int whilecount=0;
|
|
do {
|
|
// Generate pt
|
|
|
|
G4double maxPtSquare=sqr(Ptarget.pz());
|
|
if (whilecount++ >= 500 && (whilecount%100)==0)
|
|
// G4cout << "G4DiffractiveExcitation::ExciteParticipants possibly looping"
|
|
// << ", loop count/ maxPtSquare : "
|
|
// << whilecount << " / " << maxPtSquare << G4endl;
|
|
if (whilecount > 1000 )
|
|
{
|
|
Qmomentum=G4LorentzVector(0.,0.,0.,0.);
|
|
// G4cout << "G4DiffractiveExcitation::ExciteParticipants: Aborting loop!" << G4endl;
|
|
return false; // Ignore this interaction
|
|
}
|
|
Qmomentum=G4LorentzVector(GaussianPt(widthOfPtSquare,maxPtSquare),0);
|
|
|
|
// G4cout << "generated Pt " << Qmomentum << G4endl;
|
|
// G4cout << "Pprojectile with pt : " << Pprojectile+Qmomentum << G4endl;
|
|
// G4cout << "Ptarget with pt : " << Ptarget-Qmomentum << G4endl;
|
|
|
|
// Momentum transfer
|
|
G4double Xmin = minmass / ( Pprojectile.e() + Ptarget.e() );
|
|
G4double Xmax=1.;
|
|
G4double Xplus =ChooseX(Xmin,Xmax);
|
|
G4double Xminus=ChooseX(Xmin,Xmax);
|
|
|
|
// G4cout << " X-plus " << Xplus << G4endl;
|
|
// G4cout << " X-minus " << Xminus << G4endl;
|
|
|
|
G4double pt2=G4ThreeVector(Qmomentum.vect()).mag2();
|
|
G4double Qplus =-1 * pt2 / Xminus/Ptarget.minus();
|
|
G4double Qminus= pt2 / Xplus /Pprojectile.plus();
|
|
|
|
Qmomentum.setPz( (Qplus-Qminus)/2 );
|
|
Qmomentum.setE( (Qplus+Qminus)/2 );
|
|
|
|
// G4cout << "Qplus / Qminus " << Qplus << " / " << Qminus<<G4endl;
|
|
// G4cout << "pt2" << pt2 << G4endl;
|
|
// G4cout << "Qmomentum " << Qmomentum << G4endl;
|
|
// G4cout << " Masses (P/T) : " << (Pprojectile+Qmomentum).mag() <<
|
|
// " / " << (Ptarget-Qmomentum).mag() << G4endl;
|
|
|
|
} while ( (Pprojectile+Qmomentum).mag2() <= Mprojectile2 ||
|
|
(Ptarget-Qmomentum).mag2() <= Mtarget2 );
|
|
|
|
Pprojectile += Qmomentum;
|
|
Ptarget -= Qmomentum;
|
|
|
|
// G4cout << "Pprojectile with Q : " << Pprojectile << G4endl;
|
|
// G4cout << "Ptarget with Q : " << Ptarget << G4endl;
|
|
|
|
|
|
|
|
// G4cout << "Projectile back: " << toLab * Pprojectile << G4endl;
|
|
// G4cout << "Target back: " << toLab * Ptarget << G4endl;
|
|
|
|
// Transform back and update SplitableHadron Participant.
|
|
Pprojectile.transform(toLab);
|
|
Ptarget.transform(toLab);
|
|
|
|
// G4cout << "Target mass " << Ptarget.mag() << G4endl;
|
|
|
|
target->Set4Momentum(Ptarget);
|
|
//
|
|
|
|
|
|
// G4cout << "Projectile mass " << Pprojectile.mag() << G4endl;
|
|
|
|
projectile->Set4Momentum(Pprojectile);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
G4ExcitedString * G4DiffractiveExcitation::
|
|
String(G4VSplitableHadron * hadron, G4bool isProjectile) const
|
|
{
|
|
hadron->SplitUp();
|
|
G4Parton *start= hadron->GetNextParton();
|
|
if ( start==NULL)
|
|
{ G4cout << " G4FTFModel::String() Error:No start parton found"<< G4endl;
|
|
return NULL;
|
|
}
|
|
G4Parton *end = hadron->GetNextParton();
|
|
if ( end==NULL)
|
|
{ G4cout << " G4FTFModel::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 ptSquared= hadron->Get4Momentum().perp2();
|
|
G4double transverseMassSquared= hadron->Get4Momentum().plus()
|
|
* hadron->Get4Momentum().minus();
|
|
|
|
|
|
G4double maxAvailMomentumSquared=
|
|
sqr( sqrt(transverseMassSquared) - sqrt(ptSquared) );
|
|
|
|
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= 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 G4_FTFDEBUG
|
|
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;
|
|
}
|
|
|
|
|
|
// --------- private methods ----------------------
|
|
|
|
G4double G4DiffractiveExcitation::ChooseX(G4double Xmin, G4double Xmax) const
|
|
{
|
|
// choose an x between Xmin and Xmax with P(x) ~ 1/x
|
|
|
|
// to be improved...
|
|
|
|
G4double range=Xmax-Xmin;
|
|
|
|
if ( Xmin <= 0. || range <=0. )
|
|
{
|
|
G4cout << " Xmin, range : " << Xmin << " , " << range << G4endl;
|
|
throw G4HadronicException(__FILE__, __LINE__, "G4DiffractiveExcitation::ChooseX : Invalid arguments ");
|
|
}
|
|
|
|
G4double x;
|
|
do {
|
|
x=Xmin + G4UniformRand() * range;
|
|
} while ( Xmin/x < G4UniformRand() );
|
|
|
|
//debug-hpw cout << "DiffractiveX "<<x<<G4endl;
|
|
return x;
|
|
}
|
|
|
|
G4ThreeVector G4DiffractiveExcitation::GaussianPt(G4double widthSquare, G4double maxPtSquare) const
|
|
{ // @@ this method is used in FTFModel as well. Should go somewhere common!
|
|
|
|
G4double pt2;
|
|
|
|
do {
|
|
pt2=widthSquare * log( G4UniformRand() );
|
|
} while ( pt2 > maxPtSquare);
|
|
|
|
pt2=sqrt(pt2);
|
|
|
|
G4double phi=G4UniformRand() * twopi;
|
|
|
|
return G4ThreeVector (pt2*cos(phi), pt2*sin(phi), 0.);
|
|
}
|
|
|
|
G4DiffractiveExcitation::G4DiffractiveExcitation(const G4DiffractiveExcitation &)
|
|
:
|
|
widthOfPtSquare(0) , minExtraMass(0),
|
|
minmass(0)
|
|
{
|
|
throw G4HadronicException(__FILE__, __LINE__, "G4DiffractiveExcitation copy contructor not meant to be called");
|
|
}
|
|
|
|
|
|
G4DiffractiveExcitation::~G4DiffractiveExcitation()
|
|
{
|
|
}
|
|
|
|
|
|
const G4DiffractiveExcitation & G4DiffractiveExcitation::operator=(const G4DiffractiveExcitation &)
|
|
{
|
|
throw G4HadronicException(__FILE__, __LINE__, "G4DiffractiveExcitation = operator meant to be called");
|
|
return *this;
|
|
}
|
|
|
|
|
|
int G4DiffractiveExcitation::operator==(const G4DiffractiveExcitation &) const
|
|
{
|
|
throw G4HadronicException(__FILE__, __LINE__, "G4DiffractiveExcitation == operator meant to be called");
|
|
return false;
|
|
}
|
|
|
|
int G4DiffractiveExcitation::operator!=(const G4DiffractiveExcitation &) const
|
|
{
|
|
throw G4HadronicException(__FILE__, __LINE__, "G4DiffractiveExcitation != operator meant to be called");
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|