G4QGSParticipants.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * 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.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
#include <utility>
 
#include "G4QGSParticipants.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4LorentzVector.hh"
 
// Class G4QGSParticipants 
 
// HPW Feb 1999
// Promoting model parameters from local variables class properties
G4int G4QGSParticipants_NPart = 0;
 
G4QGSParticipants::G4QGSParticipants() : 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)
: G4VParticipants(),ModelMode(right.ModelMode), nCutMax(right.nCutMax),
  ThresholdParameter(right.ThresholdParameter), QGSMThreshold(right.QGSMThreshold),
  theNucleonRadius(right.theNucleonRadius)
{
}
 
 
G4QGSParticipants::~G4QGSParticipants()
{
}
 
void G4QGSParticipants::BuildInteractions(const G4ReactionProduct  &thePrimary) 
{
 
    // 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;
}
 
G4VSplitableHadron* G4QGSParticipants::SelectInteractions(const G4ReactionProduct  &thePrimary)
{
    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;
}
 
void G4QGSParticipants::PerformDiffractiveCollisions()
{
    // 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);
        }
    }
}
 
void G4QGSParticipants::PerformSoftCollisions()
{
    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
}