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 ()
int	operator== (const G4QGSParticipants &right) const
int	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 ()
	G4VParticipants (const G4VParticipants &right)
virtual	~G4VParticipants ()
const G4VParticipants &	operator= (const G4VParticipants &right)
int	operator== (const G4VParticipants &right) const
int	operator!= (const G4VParticipants &right) const
virtual void	Init (G4int theZ, G4int theA)
virtual void	SetNucleus (G4V3DNucleus *aNucleus)
virtual G4V3DNucleus *	GetWoundedNucleus () const

Protected Types
enum	{ SOFT , DIFFRACTIVE }

Protected Member Functions
virtual G4VSplitableHadron *	SelectInteractions (const G4ReactionProduct &thePrimary)
void	SplitHadrons ()
void	PerformSoftCollisions ()
void	PerformDiffractiveCollisions ()
G4bool	IsSingleDiffractive ()

Protected Attributes
std::vector< G4InteractionContent * >	theInteractions
std::vector< G4VSplitableHadron * >	theTargets
std::vector< G4PartonPair * >	thePartonPairs
G4SingleDiffractiveExcitation	theSingleDiffExcitation
G4QGSDiffractiveExcitation	theDiffExcitaton
G4int	ModelMode
G4ThreeVector	theBoost
const G4int	nCutMax
const G4double	ThresholdParameter
const G4double	QGSMThreshold
const G4double	theNucleonRadius

Additional Inherited Members
Public Attributes inherited from G4VParticipants
G4V3DNucleus *	theNucleus

Detailed Description

Definition at line 41 of file G4QGSParticipants.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
SOFT
DIFFRACTIVE

Definition at line 85 of file G4QGSParticipants.hh.

{ SOFT, DIFFRACTIVE };

Constructor & Destructor Documentation

G4QGSParticipants() [1/2]

G4QGSParticipants::G4QGSParticipants

(

)

Definition at line 39 of file G4QGSParticipants.cc.

                                     : theDiffExcitaton(), //0.7*GeV, 250*MeV, 250*MeV),
        ModelMode(SOFT),
        //nCutMax(7),ThresholdParameter(0.45*GeV),
        nCutMax(7),ThresholdParameter(0.000*GeV),
        QGSMThreshold(3*GeV),theNucleonRadius(1.5*fermi)
 
{
}

G4QGSParticipants() [2/2]

G4QGSParticipants::G4QGSParticipants

(

const G4QGSParticipants &

right

)

Definition at line 48 of file G4QGSParticipants.cc.

: G4VParticipants(),ModelMode(right.ModelMode), nCutMax(right.nCutMax),
  ThresholdParameter(right.ThresholdParameter), QGSMThreshold(right.QGSMThreshold),
  theNucleonRadius(right.theNucleonRadius)
{
}

~G4QGSParticipants()

G4QGSParticipants::~G4QGSParticipants ( )

virtual

Definition at line 56 of file G4QGSParticipants.cc.

{
}

Member Function Documentation

BuildInteractions()

void G4QGSParticipants::BuildInteractions

(

const G4ReactionProduct &

thePrimary

)

Definition at line 60 of file G4QGSParticipants.cc.

{
 
    // Find the collisions and collition conditions
    G4VSplitableHadron* aProjectile = SelectInteractions(thePrimary);
 
    // now build the parton pairs. HPW
    SplitHadrons();
 
    // soft collisions first HPW, ordering is vital
    PerformSoftCollisions();
 
    // the rest is diffractive HPW
    PerformDiffractiveCollisions();
 
    // clean-up, if necessary
    std::for_each(theInteractions.begin(), theInteractions.end(), DeleteInteractionContent());
    theInteractions.clear();
    std::for_each(theTargets.begin(), theTargets.end(), DeleteSplitableHadron());
    theTargets.clear();
    delete aProjectile;
}

DoLorentzBoost()

virtual void G4QGSParticipants::DoLorentzBoost ( G4ThreeVector  aBoost )

inlinevirtual

Definition at line 52 of file G4QGSParticipants.hh.

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

GetNextPartonPair()

G4PartonPair * G4QGSParticipants::GetNextPartonPair ( )

inline

Definition at line 105 of file G4QGSParticipants.hh.

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

IsSingleDiffractive()

G4bool G4QGSParticipants::IsSingleDiffractive ( )

inlineprotected

Definition at line 94 of file G4QGSParticipants.hh.

{
    G4bool result=false;
    if(G4UniformRand()<1.) result = true;
    return result;
}

Referenced by SelectInteractions().

operator!=()

int G4QGSParticipants::operator!=

(

const G4QGSParticipants &

right

)

const

operator=()

const G4QGSParticipants & G4QGSParticipants::operator=

(

const G4QGSParticipants &

right

)

operator==()

int G4QGSParticipants::operator==

(

const G4QGSParticipants &

right

)

const

PerformDiffractiveCollisions()

void G4QGSParticipants::PerformDiffractiveCollisions ( )

protected

Definition at line 228 of file G4QGSParticipants.cc.

{
    // remove the "G4PartonPair::PROJECTILE", etc., which are not necessary. @@@
    unsigned int i;
    for(i = 0; i < theInteractions.size(); i++)
    {
        G4InteractionContent* anIniteraction = theInteractions[i];
        G4VSplitableHadron* aProjectile = anIniteraction->GetProjectile();
        G4Parton* aParton = aProjectile->GetNextParton();
        G4PartonPair * aPartonPair;
        // projectile first HPW
        if (aParton)
        {
            aPartonPair = new G4PartonPair(aParton, aProjectile->GetNextAntiParton(),
                    G4PartonPair::DIFFRACTIVE,
                    G4PartonPair::PROJECTILE);
            #ifdef debug_G4QGSPart_PDiffColl
            G4cout << "DiffPair Pro " << aPartonPair->GetParton1()->GetPDGcode() << " "
                    << aPartonPair->GetParton1()->Get4Momentum() << " "
                    << aPartonPair->GetParton1()->GetX() << " " << G4endl;
            G4cout << "         " << aPartonPair->GetParton2()->GetPDGcode() << " "
                    << aPartonPair->GetParton2()->Get4Momentum() << " "
                    << aPartonPair->GetParton2()->GetX() << " " << G4endl;
            #endif
            thePartonPairs.push_back(aPartonPair);
        }
        // then target HPW
        G4VSplitableHadron* aTarget = anIniteraction->GetTarget();
        aParton = aTarget->GetNextParton();
        if (aParton)
        {
            aPartonPair = new G4PartonPair(aParton, aTarget->GetNextAntiParton(),
                    G4PartonPair::DIFFRACTIVE,
                    G4PartonPair::TARGET);
                    #ifdef debug_G4QGSPart_PDiffColl
                    G4cout << "DiffPair Tgt " << aPartonPair->GetParton1()->GetPDGcode() << " "
                            << aPartonPair->GetParton1()->Get4Momentum() << " "
                            << aPartonPair->GetParton1()->GetX() << " " << G4endl;
                    G4cout << "         " << aPartonPair->GetParton2()->GetPDGcode() << " "
                            << aPartonPair->GetParton2()->Get4Momentum() << " "
                            << aPartonPair->GetParton2()->GetX() << " " << G4endl;
                    #endif
                    thePartonPairs.push_back(aPartonPair);
        }
    }
}

Referenced by BuildInteractions().

PerformSoftCollisions()

void G4QGSParticipants::PerformSoftCollisions ( )

protected

Definition at line 275 of file G4QGSParticipants.cc.

{
    std::vector<G4InteractionContent*>::iterator i;
    G4LorentzVector str4Mom;
    i = theInteractions.begin();
    while ( i != theInteractions.end() )
    {
        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 debug_G4QGSPart_PSoftColl
                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 debug_G4QGSParticipants
                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 debug_G4QGSPart_PSoftColl
                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 debug_G4QGSParticipants
                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 debug_G4QGSPart_PSoftColl
        G4cout << " string 4 mom " << str4Mom << G4endl;
    #endif
}

Referenced by BuildInteractions().

SelectInteractions()

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

protectedvirtual

Definition at line 83 of file G4QGSParticipants.cc.

{
    G4VSplitableHadron* aProjectile = new G4QGSMSplitableHadron(thePrimary, TRUE); // @@@ check the TRUE
    G4PomeronCrossSection theProbability(thePrimary.GetDefinition()); // @@@ should be data member
    G4double outerRadius = theNucleus->GetOuterRadius();
    // Check reaction threshold
 
    theNucleus->StartLoop();
    G4Nucleon * pNucleon = theNucleus->GetNextNucleon();
    G4LorentzVector aPrimaryMomentum(thePrimary.GetMomentum(), thePrimary.GetTotalEnergy());
    //--DEBUG--G4cout << " qgspart- " << aPrimaryMomentum << " # " << aPrimaryMomentum.mag()
    //--DEBUG--      << pNucleon->Get4Momentum() << " # " << (pNucleon->Get4Momentum()).mag()<< G4endl;
    G4double s_nucleus = (aPrimaryMomentum + pNucleon->Get4Momentum()).mag2();
    G4double ThresholdMass = thePrimary.GetMass() + pNucleon->GetDefinition()->GetPDGMass();
    ModelMode = SOFT;
    if (sqr(ThresholdMass + ThresholdParameter) > s_nucleus)
    {
        ModelMode = DIFFRACTIVE;
        //throw G4HadronicException(__FILE__, __LINE__, "Initial energy is too low. The 4-vectors of the input are inconsistant with the particle masses.");
    }
    if (sqr(ThresholdMass + QGSMThreshold) > s_nucleus) // thus only diffractive in cascade!
    {
        ModelMode = DIFFRACTIVE;
    }
 
    // first find the collisions HPW
    std::for_each(theInteractions.begin(), theInteractions.end(), DeleteInteractionContent());
    theInteractions.clear();
    G4int totalCuts = 0;
 
    #ifdef debug_QGS
        G4double eK = thePrimary.GetKineticEnergy()/GeV;
    #endif
    #ifdef debug_G4QGSParticipants
        G4double impactUsed = 0;
        G4LorentzVector intNuclMom;
    #endif
 
    while(theInteractions.size() == 0)
    {
        // choose random impact parameter HPW
        std::pair<G4double, G4double> theImpactParameter;
        theImpactParameter = theNucleus->ChooseImpactXandY(outerRadius+theNucleonRadius);
        G4double impactX = theImpactParameter.first;
        G4double impactY = theImpactParameter.second;
 
        // loop over nucleons to find collisions
        theNucleus->StartLoop();
        G4int nucleonCount = 0; // debug
        G4QGSParticipants_NPart = 0;
        #ifdef debug_G4QGSParticipants
            intNuclMom=aPrimaryMomentum;
        #endif
        while( (pNucleon = theNucleus->GetNextNucleon()) )
        {
            if(totalCuts>1.5*thePrimary.GetKineticEnergy()/GeV)
            {
                break;
            }
            nucleonCount++; // debug
            // Needs to be moved to Probability class @@@
            G4LorentzVector nucleonMomentum=pNucleon->Get4Momentum();
            nucleonMomentum.setE(nucleonMomentum.e()-pNucleon->GetBindingEnergy());
            G4double s_nucleon = (aPrimaryMomentum + nucleonMomentum).mag2();
            G4double Distance2 = sqr(impactX - pNucleon->GetPosition().x()) +
                    sqr(impactY - pNucleon->GetPosition().y());
            G4double Probability = theProbability.GetInelasticProbability(s_nucleon, Distance2);
            // test for inelastic collision
            G4double rndNumber = G4UniformRand();
            //      ModelMode = DIFFRACTIVE;
            if (Probability > rndNumber)
            {
            #ifdef debug_G4QGSParticipants
                G4cout << "DEBUG p="<< Probability<<" r="<<rndNumber<<" d="<<std::sqrt(Distance2)<<G4endl;
                G4cout << " qgspart+  " << aPrimaryMomentum << " # " << aPrimaryMomentum.mag()
                  << pNucleon->Get4Momentum() << " # " << (pNucleon->Get4Momentum()).mag()<< G4endl;
                intNuclMom += nucleonMomentum;
            #endif
                pNucleon->SetMomentum(nucleonMomentum);
                G4QGSMSplitableHadron* aTarget = new G4QGSMSplitableHadron(*pNucleon);
                G4QGSParticipants_NPart ++;
                theTargets.push_back(aTarget);
                pNucleon->Hit(aTarget);
                if ((theProbability.GetDiffractiveProbability(s_nucleon, Distance2)/Probability > G4UniformRand()
                        &&(ModelMode==SOFT)) || (ModelMode==DIFFRACTIVE ))
                {
                    // diffractive interaction occurs
                    if(IsSingleDiffractive())
                    {
                        theSingleDiffExcitation.ExciteParticipants(aProjectile, aTarget);
                    }
                    else
                    {
                        theDiffExcitaton.ExciteParticipants(aProjectile, aTarget);
                    }
                    G4InteractionContent * aInteraction = new G4InteractionContent(aProjectile);
                    aInteraction->SetTarget(aTarget);
                    theInteractions.push_back(aInteraction);
                    aInteraction->SetNumberOfDiffractiveCollisions(1);
                    totalCuts += 1;
                }
                else
                {
                    // nondiffractive soft interaction occurs
                    // sample nCut+1 (cut Pomerons) pairs of strings can be produced
                    G4int nCut;
                    G4double * running = new G4double[nCutMax];
                    running[0] = 0;
                    for(nCut = 0; nCut < nCutMax; nCut++)
                    {
                        running[nCut] = theProbability.GetCutPomeronProbability(s_nucleon, Distance2, nCut + 1);
                        if(nCut!=0) running[nCut] += running[nCut-1];
                    }
                    G4double random = running[nCutMax-1]*G4UniformRand();
                    for(nCut = 0; nCut < nCutMax; nCut++)
                    {
                        if(running[nCut] > random) break;
                    }
                    delete [] running;
                    nCut = 0;
                    aTarget->IncrementCollisionCount(nCut+1);
                    aProjectile->IncrementCollisionCount(nCut+1);
                    G4InteractionContent * aInteraction = new G4InteractionContent(aProjectile);
                    aInteraction->SetTarget(aTarget);
                    aInteraction->SetNumberOfSoftCollisions(nCut+1);
                    theInteractions.push_back(aInteraction);
                    totalCuts += nCut+1;
                    #ifdef debug_G4QGSParticipants
                        impactUsed=Distance2;
                    #endif
                }
            }
        }
    #ifdef debug_G4QGSParticipants
            G4cout << G4endl<<"NUCLEONCOUNT "<<nucleonCount<<G4endl;
            G4cout << " Interact 4-Vect " << intNuclMom << G4endl;
    #endif
    }
    #ifdef debug_G4QGSParticipants
        G4cout << G4endl<<"CUTDEBUG "<< totalCuts <<G4endl;
        G4cout << "Impact Parameter used = "<<impactUsed<<G4endl;
    #endif
    return aProjectile;
}

Referenced by BuildInteractions().

SplitHadrons()

void G4QGSParticipants::SplitHadrons ( )

inlineprotected

Definition at line 114 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 101 of file G4QGSParticipants.hh.

{
}

Member Data Documentation

ModelMode

G4int G4QGSParticipants::ModelMode

protected

Definition at line 78 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

nCutMax

const G4int G4QGSParticipants::nCutMax

protected

Definition at line 86 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

QGSMThreshold

const G4double G4QGSParticipants::QGSMThreshold

protected

Definition at line 88 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

theBoost

G4ThreeVector G4QGSParticipants::theBoost

protected

Definition at line 81 of file G4QGSParticipants.hh.

Referenced by DoLorentzBoost().

theDiffExcitaton

G4QGSDiffractiveExcitation G4QGSParticipants::theDiffExcitaton

protected

Definition at line 77 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

theInteractions

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

protected

Definition at line 70 of file G4QGSParticipants.hh.

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

theNucleonRadius

const G4double G4QGSParticipants::theNucleonRadius

protected

Definition at line 89 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

thePartonPairs

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

protected

Definition at line 74 of file G4QGSParticipants.hh.

Referenced by GetNextPartonPair(), PerformDiffractiveCollisions(), and PerformSoftCollisions().

theSingleDiffExcitation

G4SingleDiffractiveExcitation G4QGSParticipants::theSingleDiffExcitation

protected

Definition at line 76 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

theTargets

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

protected

Definition at line 72 of file G4QGSParticipants.hh.

Referenced by BuildInteractions(), and SelectInteractions().

ThresholdParameter

const G4double G4QGSParticipants::ThresholdParameter

protected

Definition at line 87 of file G4QGSParticipants.hh.

Referenced by SelectInteractions().

---

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

• G4QGSParticipants.hh
• G4QGSParticipants.cc