G4QGSParticipants Class Reference

#include <G4QGSParticipants.hh>

Inheritance diagram for G4QGSParticipants:

Collaboration 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
virtual void	InitProjectileNucleus (G4int theZ, G4int theA)
virtual void	SetProjectileNucleus (G4V3DNucleus *aNucleus)
virtual G4V3DNucleus *	GetProjectileNucleus () 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
G4V3DNucleus *	theProjectileNucleus

Detailed Description

Definition at line 41 of file G4QGSParticipants.hh.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
SOFT
DIFFRACTIVE

Definition at line 85 of file G4QGSParticipants.hh.

{ SOFT, DIFFRACTIVE };

Constructor & Destructor Documentation

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::G4QGSParticipants

(

const G4QGSParticipants &

right

)

Definition at line 47 of file G4QGSParticipants.cc.

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

G4QGSParticipants::~G4QGSParticipants ( )

virtual

Definition at line 55 of file G4QGSParticipants.cc.

{
}

Member Function Documentation

void G4QGSParticipants::BuildInteractions

(

const G4ReactionProduct &

thePrimary

)

Definition at line 59 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;
}

Here is the call graph for this function:

virtual void G4QGSParticipants::DoLorentzBoost ( G4ThreeVector  aBoost )

inlinevirtual

Definition at line 52 of file G4QGSParticipants.hh.

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

Here is the call graph for this function:

G4PartonPair * G4QGSParticipants::GetNextPartonPair ( )

inline

Definition at line 104 of file G4QGSParticipants.hh.

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

G4bool G4QGSParticipants::IsSingleDiffractive ( )

inlineprotected

Definition at line 93 of file G4QGSParticipants.hh.

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

Here is the caller graph for this function:

int G4QGSParticipants::operator!=

(

const G4QGSParticipants &

right

)

const

const G4QGSParticipants& G4QGSParticipants::operator=

(

const G4QGSParticipants &

right

)

int G4QGSParticipants::operator==

(

const G4QGSParticipants &

right

)

const

void G4QGSParticipants::PerformDiffractiveCollisions ( )

protected

Definition at line 235 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);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4QGSParticipants::PerformSoftCollisions ( )

protected

Definition at line 284 of file G4QGSParticipants.cc.

{
  std::vector<G4InteractionContent*>::iterator i;
  G4LorentzVector str4Mom;
  i = theInteractions.begin();
  while ( i != theInteractions.end() )  /* Loop checking, 10.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 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
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protectedvirtual

Definition at line 81 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

  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = -1;
  while ( (theInteractions.size() == 0) && ++loopCounter < maxNumberOfLoops )  /* Loop checking, 26.10.2015, A.Ribon */
  {
    // 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()) )  /* Loop checking, 26.10.2015, A.Ribon */
    {
      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

  }

  if ( loopCounter >= maxNumberOfLoops ) {
    G4ExceptionDescription ed;
    ed << " loopCounter exceeds maxNumberOfLoops : forced exit! " << G4endl;
    G4Exception( "G4QGSParticipants::SelectInteractions ", "HAD_QGS_001", JustWarning, ed );
  }

  #ifdef debug_G4QGSParticipants
  G4cout << G4endl<<"CUTDEBUG "<< totalCuts <<G4endl;
  G4cout << "Impact Parameter used = "<<impactUsed<<G4endl;
  #endif

  return aProjectile;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4QGSParticipants::SplitHadrons ( )

inlineprotected

Definition at line 112 of file G4QGSParticipants.hh.

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

Here is the caller graph for this function:

void G4QGSParticipants::StartPartonPairLoop ( )

inline

Definition at line 100 of file G4QGSParticipants.hh.

{
}

Member Data Documentation

G4int G4QGSParticipants::ModelMode

protected

Definition at line 78 of file G4QGSParticipants.hh.

const G4int G4QGSParticipants::nCutMax

protected

Definition at line 86 of file G4QGSParticipants.hh.

const G4double G4QGSParticipants::QGSMThreshold

protected

Definition at line 88 of file G4QGSParticipants.hh.

G4ThreeVector G4QGSParticipants::theBoost

protected

Definition at line 81 of file G4QGSParticipants.hh.

G4QGSDiffractiveExcitation G4QGSParticipants::theDiffExcitaton

protected

Definition at line 77 of file G4QGSParticipants.hh.

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

protected

Definition at line 70 of file G4QGSParticipants.hh.

const G4double G4QGSParticipants::theNucleonRadius

protected

Definition at line 89 of file G4QGSParticipants.hh.

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

protected

Definition at line 74 of file G4QGSParticipants.hh.

G4SingleDiffractiveExcitation G4QGSParticipants::theSingleDiffExcitation

protected

Definition at line 76 of file G4QGSParticipants.hh.

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

protected

Definition at line 72 of file G4QGSParticipants.hh.

const G4double G4QGSParticipants::ThresholdParameter

protected

Definition at line 87 of file G4QGSParticipants.hh.

---

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

• geant4.10.03.p01/source/processes/hadronic/models/parton_string/qgsm/include/G4QGSParticipants.hh
• geant4.10.03.p01/source/processes/hadronic/models/parton_string/qgsm/src/G4QGSParticipants.cc