#include <HadronicProcessHelper.h>

Public Types
typedef std::map< G4int, ReactionProductList >	ReactionMap

typedef std::vector< G4int >	ReactionProduct

typedef std::vector< ReactionProduct >	ReactionProductList

Public Member Functions
G4bool	applicabilityTester (const G4ParticleDefinition &particle)

ReactionProduct	finalState (const G4Track &track, G4ParticleDefinition *&target)

ReactionProduct	finalState (const G4DynamicParticle particle, const G4Material material, G4ParticleDefinition *&target)

	HadronicProcessHelper (const std::string &fileName)

	HadronicProcessHelper (const HadronicProcessHelper &)

G4double	inclusiveCrossSection (const G4DynamicParticle particle, const G4Element element)

HadronicProcessHelper *	instance ()

HadronicProcessHelper &	operator= (const HadronicProcessHelper &)

Private Member Functions
G4double	m_phaseSpace (const ReactionProduct &aReaction, const G4DynamicParticle aDynamicParticle, G4ParticleDefinition target)

G4bool	m_reactionIsPossible (const ReactionProduct &aReaction, const G4DynamicParticle aDynamicParticle, G4ParticleDefinition target)

G4double	m_reactionProductMass (const ReactionProduct &aReaction, const G4DynamicParticle aDynamicParticle, G4ParticleDefinition target)

void	m_readAndParse (const G4String &str, std::vector< G4String > &tokens, const G4String &delimiters=" ")

Private Attributes
G4double	m_checkFraction

std::map< const G4ParticleDefinition *, G4bool >	m_knownParticles

G4int	m_n22

G4int	m_n23

G4ParticleDefinition *	m_neutron

ReactionMap	m_neutronReactionMap

G4ParticleTable *	m_particleTable

G4ParticleDefinition *	m_proton

ReactionMap	m_protonReactionMap

Detailed Description

Definition at line 16 of file HadronicProcessHelper.h.

Member Typedef Documentation

typedef std::map<G4int, ReactionProductList> HadronicProcessHelper::ReactionMap

Definition at line 21 of file HadronicProcessHelper.h.

typedef std::vector<G4int> HadronicProcessHelper::ReactionProduct

Definition at line 19 of file HadronicProcessHelper.h.

typedef std::vector<ReactionProduct> HadronicProcessHelper::ReactionProductList

Definition at line 20 of file HadronicProcessHelper.h.

Constructor & Destructor Documentation

HadronicProcessHelper::HadronicProcessHelper ( const std::string & fileName )

Definition at line 16 of file HadronicProcessHelper.cc.

References mps_fire::i, mps_splice::line, parseEventContent::prod, and edmPickEvents::target.

                                                                       {
   m_particleTable = G4ParticleTable::GetParticleTable();
   m_proton = m_particleTable->FindParticle("proton");
   m_neutron = m_particleTable->FindParticle("neutron");
 
   G4String line;
 
   std::ifstream processListStream(fileName.c_str());
 
   while (getline(processListStream, line)) {
     std::vector<G4String> tokens;
 
     //Getting a line
     m_readAndParse(line, tokens, "#");
 
     //Important info
     G4String incident = tokens[0];
     G4ParticleDefinition* incidentDef = m_particleTable->FindParticle(incident);
     G4int incidentPDG = incidentDef->GetPDGEncoding();
     m_knownParticles[incidentDef] = true;
     //    G4cout<<"Incident: "<<incident<<G4endl;
     G4String target = tokens[1];
     //    G4cout<<"Target: "<<target<<G4endl;
 
     // Making a ReactionProduct
     ReactionProduct prod;
     for (size_t i = 2; i != tokens.size(); i++) {
       G4String part = tokens[i];
       if (m_particleTable->contains(part)) {
         prod.push_back(m_particleTable->FindParticle(part)->GetPDGEncoding());
       } else {
         G4Exception("HadronicProcessHelper",
                     "UnkownParticle",
                     FatalException,
                     "Initialization: The reaction product list contained an unknown particle");
       }
     }
     if (target == "proton") {
       m_protonReactionMap[incidentPDG].push_back(prod);
     } else if (target == "neutron") {
       m_neutronReactionMap[incidentPDG].push_back(prod);
     } else {
       G4Exception("HadronicProcessHelper",
                   "IllegalTarget",
                   FatalException,
                   "Initialization: The reaction product list contained an illegal target particle");
     }
   }
 
   processListStream.close();
 
   m_checkFraction = 0;
   m_n22 = 0;
   m_n23 = 0;
 }

HadronicProcessHelper::HadronicProcessHelper ( const HadronicProcessHelper & )

Member Function Documentation

G4bool HadronicProcessHelper::applicabilityTester ( const G4ParticleDefinition & particle )

Definition at line 72 of file HadronicProcessHelper.cc.

Referenced by instance().

                                                                                    {
   const G4ParticleDefinition* aP = &aPart;
   if (m_knownParticles[aP])
     return true;
   return false;
 }

ReactionProduct HadronicProcessHelper::finalState	(	const G4Track &	track,
		G4ParticleDefinition *&	target
	)

inline

Definition at line 36 of file HadronicProcessHelper.h.

References edmPickEvents::target.

                                                                                   {
     return finalState(track.GetDynamicParticle(), track.GetMaterial(), target);
   }

HadronicProcessHelper::ReactionProduct HadronicProcessHelper::finalState	(	const G4DynamicParticle *	particle,
		const G4Material *	material,
		G4ParticleDefinition *&	target
	)

Definition at line 107 of file HadronicProcessHelper.cc.

References ecalTB2006H4_GenSimDigiReco_cfg::G4cerr, mps_fire::i, and findQualityFiles::size.

                                                                                                                  {
   //  const G4DynamicParticle* incidentDynamicParticle = track.GetDynamicParticle();
 
   //-----------------------------------------------
   // Choose n / p as target
   // and get ReactionProductList pointer
   //-----------------------------------------------
   ReactionMap* m_reactionMap;
   //G4Material* material = track.GetMaterial();
   const G4ElementVector* elementVector = material->GetElementVector();
   const G4double* numberOfAtomsPerVolume = material->GetVecNbOfAtomsPerVolume();
 
   G4double numberOfProtons = 0;
   G4double numberOfNucleons = 0;
 
   //Loop on elements
   for (size_t elm = 0; elm < material->GetNumberOfElements(); elm++) {
     //Summing number of protons per unit volume
     numberOfProtons += numberOfAtomsPerVolume[elm] * (*elementVector)[elm]->GetZ();
     //Summing nucleons (not neutrons)
     numberOfNucleons += numberOfAtomsPerVolume[elm] * (*elementVector)[elm]->GetN();
   }
 
   //random decision of the target
   if (G4UniformRand() < numberOfProtons / numberOfNucleons) {  //target is a proton
     m_reactionMap = &m_protonReactionMap;
     target = m_proton;
   } else {  //target is a neutron
     m_reactionMap = &m_neutronReactionMap;
     target = m_neutron;
   }
 
   const G4int incidentPDG = incidentDynamicParticle->GetDefinition()->GetPDGEncoding();
 
   //Making a pointer directly to the ReactionProductList we are looking at. Makes life easier :-)
   ReactionProductList* reactionProductList = &((*m_reactionMap)[incidentPDG]);
 
   //-----------------------------------------------
   // Count processes
   // kinematic check
   // compute number of 2 -> 2 and 2 -> 3 processes
   //-----------------------------------------------
 
   G4int good22 = 0;  //Number of 2 -> 2 processes that are possible
   G4int good23 = 0;  //Number of 2 -> 3 processes that are possible
 
   //This is the list to be populated
   ReactionProductList goodReactionProductList;
 
   for (ReactionProductList::iterator prod_it = reactionProductList->begin(); prod_it != reactionProductList->end();
        prod_it++) {
     G4int secondaries = prod_it->size();
     // If the reaction is not possible we will not consider it
     if (m_reactionIsPossible(*prod_it, incidentDynamicParticle, target)) {
       // The reaction is possible. Let's store and count it
       goodReactionProductList.push_back(*prod_it);
       if (secondaries == 2) {
         good22++;
       } else if (secondaries == 3) {
         good23++;
       } else {
         G4cerr << "ReactionProduct has unsupported number of secondaries: " << secondaries << G4endl;
       }
     } /*else {
       G4cout<<"There was an impossible process"<<G4endl;
       }*/
   }
   //  G4cout<<"The size of the ReactionProductList is: "<<theReactionProductList.size()<<G4endl;
 
   if (goodReactionProductList.empty())
     G4Exception("HadronicProcessHelper",
                 "NoProcessPossible",
                 FatalException,
                 "GetFinalState: No process could be selected from the given list.");
   // Fill a probability map. Remember total probability
   // 2->2 is 0.15*1/n_22 2->3 uses phase space
   G4double prob22 = 0.15;
   G4double prob23 = 1 - prob22;  // :-)
 
   std::vector<G4double> probabilities;
   std::vector<G4bool> twoToThreeFlag;
 
   G4double cumulatedProbability = 0;
 
   // To each ReactionProduct we assign a cumulated probability and a flag
   // discerning between 2 -> 2 and 2 -> 3
   size_t numberOfReactions = goodReactionProductList.size();
   for (size_t i = 0; i != numberOfReactions; i++) {
     if (goodReactionProductList[i].size() == 2) {
       cumulatedProbability += prob22 / good22;
       twoToThreeFlag.push_back(false);
     } else {
       cumulatedProbability += prob23 / good23;
       twoToThreeFlag.push_back(true);
     }
     probabilities.push_back(cumulatedProbability);
   }
 
   //Normalising probabilities to 1
   for (std::vector<G4double>::iterator it = probabilities.begin(); it != probabilities.end(); it++) {
     *it /= cumulatedProbability;
   }
 
   // Choosing ReactionProduct
   G4bool selected = false;
   G4int tries = 0;
   //  ReactionProductList::iterator prod_it;
 
   //Keep looping over the list until we have a choice, or until we have tried 100 times
   size_t i;
   while (!selected && tries < 100) {
     i = 0;
     G4double dice = G4UniformRand();
     //select the process using the dice
     while (dice > probabilities[i] && i < numberOfReactions)
       i++;
 
     if (twoToThreeFlag[i]) {
       // 2 -> 3 processes require a phase space lookup
       if (m_phaseSpace(goodReactionProductList[i], incidentDynamicParticle, target) > G4UniformRand())
         selected = true;
     } else {
       // 2 -> 2 processes are chosen immediately
       selected = true;
     }
     tries++;
   }
   if (tries >= 100)
     G4cerr << "Could not select process!!!!" << G4endl;
 
   //Debugging stuff
   //Updating checkfraction:
   if (goodReactionProductList[i].size() == 2) {
     m_n22++;
   } else {
     m_n23++;
   }
   m_checkFraction = (1.0 * m_n22) / (m_n22 + m_n23);
 
   //return the selected productList
   return goodReactionProductList[i];
 }

G4double HadronicProcessHelper::inclusiveCrossSection	(	const G4DynamicParticle *	particle,
		const G4Element *	element
	)

Definition at line 79 of file HadronicProcessHelper.cc.

References funct::pow(), CustomPDGParser::s_containedQuarks(), and CustomPDGParser::s_isRGlueball().

Referenced by instance().

                                                                                                                  {
   //We really do need a dedicated class to handle the cross sections. They might not always be constant
 
   G4int pdgCode = particle->GetDefinition()->GetPDGEncoding();
 
   //24mb for gluino-balls
   if (CustomPDGParser::s_isRGlueball(pdgCode))
     return 24 * millibarn * element->GetN();
 
   //get quark vector
   std::vector<G4int> quarks = CustomPDGParser::s_containedQuarks(pdgCode);
 
   G4double totalNucleonCrossSection = 0;
 
   for (std::vector<G4int>::iterator it = quarks.begin(); it != quarks.end(); it++) {
     // 12mb for each 'up' or 'down'
     if (*it == 1 || *it == 2)
       totalNucleonCrossSection += 12 * millibarn;
     //  6mb for each 'strange'
     if (*it == 3)
       totalNucleonCrossSection += 6 * millibarn;
   }
 
   //Convert to xsec per nucleus
   //  return totalNucleonCrossSection * element->GetN();
   return totalNucleonCrossSection * pow(element->GetN(), 0.7) * 1.25;  // * 0.523598775598299;
 }

HadronicProcessHelper* HadronicProcessHelper::instance ( )

inline

Definition at line 29 of file HadronicProcessHelper.h.

References applicabilityTester(), and inclusiveCrossSection().

29 { return this; };

G4double HadronicProcessHelper::m_phaseSpace	(	const ReactionProduct &	aReaction,
		const G4DynamicParticle *	aDynamicParticle,
		G4ParticleDefinition *	target
	)

private

Definition at line 279 of file HadronicProcessHelper.cc.

References GeV, funct::pow(), and mathSSE::sqrt().

                                                                            {
   G4double qValue = m_reactionProductMass(aReaction, aDynamicParticle, target);
   G4double phi = sqrt(1 + qValue / (2 * 0.139 * GeV)) * pow(qValue / (1.1 * GeV), 3. / 2.);
   return (phi / (1 + phi));
 }

G4bool HadronicProcessHelper::m_reactionIsPossible	(	const ReactionProduct &	aReaction,
		const G4DynamicParticle *	aDynamicParticle,
		G4ParticleDefinition *	target
	)

private

Definition at line 271 of file HadronicProcessHelper.cc.

                                                                                  {
   if (m_reactionProductMass(aReaction, aDynamicParticle, target) > 0)
     return true;
   return false;
 }

G4double HadronicProcessHelper::m_reactionProductMass	(	const ReactionProduct &	aReaction,
		const G4DynamicParticle *	aDynamicParticle,
		G4ParticleDefinition *	target
	)

private

Definition at line 251 of file HadronicProcessHelper.cc.

References mathSSE::sqrt(), and TotemBeamConditions_cff::sqrtS.

                                                                                     {
   // Incident energy:
   G4double incidentEnergy = incidentDynamicParticle->GetTotalEnergy();
   G4double m_1 = incidentDynamicParticle->GetDefinition()->GetPDGMass();
   G4double m_2 = target->GetPDGMass();
   //square root of "s"
   G4double sqrtS = sqrt(m_1 * m_1 + m_2 * (m_2 + 2 * incidentEnergy));
   // Sum of rest masses after reaction:
   G4double productsMass = 0;
   //Loop on reaction producs
   for (ReactionProduct::const_iterator r_it = reactionProd.begin(); r_it != reactionProd.end(); r_it++) {
     //Sum the masses of the products
     productsMass += m_particleTable->FindParticle(*r_it)->GetPDGMass();
   }
   //the result is square root of "s" minus the masses of the products
   return sqrtS - productsMass;
 }

void HadronicProcessHelper::m_readAndParse	(	const G4String &	str,
		std::vector< G4String > &	tokens,
		const G4String &	delimiters = `" "`
	)

private

Definition at line 287 of file HadronicProcessHelper.cc.

References groupFilesInBlocks::temp.

                                                                        {
   // Skip delimiters at beginning.
   G4String::size_type lastPos = str.find_first_not_of(delimiters, 0);
   // Find first "non-delimiter".
   G4String::size_type pos = str.find_first_of(delimiters, lastPos);
 
   while (G4String::npos != pos || G4String::npos != lastPos) {
     //Skipping leading / trailing whitespaces
     G4String temp = str.substr(lastPos, pos - lastPos);
     while (temp.c_str()[0] == ' ')
       temp.erase(0, 1);
     while (temp[temp.size() - 1] == ' ')
       temp.erase(temp.size() - 1, 1);
     // Found a token, add it to the vector.
     tokens.push_back(temp);
     // Skip delimiters.  Note the "not_of"
     lastPos = str.find_first_not_of(delimiters, pos);
     // Find next "non-delimiter"
     pos = str.find_first_of(delimiters, lastPos);
   }
 }

HadronicProcessHelper& HadronicProcessHelper::operator= ( const HadronicProcessHelper & )

Member Data Documentation

G4double HadronicProcessHelper::m_checkFraction

private

Definition at line 75 of file HadronicProcessHelper.h.

std::map<const G4ParticleDefinition*, G4bool> HadronicProcessHelper::m_knownParticles

private

Definition at line 64 of file HadronicProcessHelper.h.

G4int HadronicProcessHelper::m_n22

private

Definition at line 76 of file HadronicProcessHelper.h.

G4int HadronicProcessHelper::m_n23

private

Definition at line 77 of file HadronicProcessHelper.h.

G4ParticleDefinition* HadronicProcessHelper::m_neutron

private

Definition at line 45 of file HadronicProcessHelper.h.

ReactionMap HadronicProcessHelper::m_neutronReactionMap

private

Definition at line 70 of file HadronicProcessHelper.h.

G4ParticleTable* HadronicProcessHelper::m_particleTable

private

Definition at line 72 of file HadronicProcessHelper.h.

G4ParticleDefinition* HadronicProcessHelper::m_proton

private

Definition at line 44 of file HadronicProcessHelper.h.

ReactionMap HadronicProcessHelper::m_protonReactionMap

private

Definition at line 67 of file HadronicProcessHelper.h.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation