G4EnergyRangeManager Class Reference

#include <G4EnergyRangeManager.hh>

Collaboration diagram for G4EnergyRangeManager:

Public Member Functions
	G4EnergyRangeManager ()
	~G4EnergyRangeManager ()
	G4EnergyRangeManager (const G4EnergyRangeManager &right)
G4EnergyRangeManager &	operator= (const G4EnergyRangeManager &right)
G4bool	operator== (const G4EnergyRangeManager &right) const
G4bool	operator!= (const G4EnergyRangeManager &right) const
void	RegisterMe (G4HadronicInteraction *a)
G4HadronicInteraction *	GetHadronicInteraction (const G4HadProjectile &aHadProjectile, G4Nucleus &aTargetNucleus, const G4Material *aMaterial, const G4Element *anElement) const
G4HadronicInteraction *	GetHadronicInteraction (const G4double kineticEnergy, const G4Material *aMaterial, const G4Element *anElement) const
std::vector< G4HadronicInteraction * > &	GetHadronicInteractionList ()
void	Dump (G4int verbose=0)
void	BuildPhysicsTable (const G4ParticleDefinition &)

Private Attributes
G4int	theHadronicInteractionCounter
std::vector< G4HadronicInteraction * >	theHadronicInteraction

Detailed Description

Definition at line 40 of file G4EnergyRangeManager.hh.

Constructor & Destructor Documentation

G4EnergyRangeManager() [1/2]

G4EnergyRangeManager::G4EnergyRangeManager

(

)

Definition at line 39 of file G4EnergyRangeManager.cc.

 : theHadronicInteractionCounter(0)
{}

~G4EnergyRangeManager()

G4EnergyRangeManager::~G4EnergyRangeManager

(

)

Definition at line 43 of file G4EnergyRangeManager.cc.

{}

G4EnergyRangeManager() [2/2]

G4EnergyRangeManager::G4EnergyRangeManager

(

const G4EnergyRangeManager &

right

)

Definition at line 46 of file G4EnergyRangeManager.cc.

{
  if (this != &right) {
    theHadronicInteractionCounter = right.theHadronicInteractionCounter;
    theHadronicInteraction = right.theHadronicInteraction;
  }
}

Member Function Documentation

BuildPhysicsTable()

void G4EnergyRangeManager::BuildPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 294 of file G4EnergyRangeManager.cc.

{
   for ( std::vector<G4HadronicInteraction*>::iterator 
         it = theHadronicInteraction.begin() ; it != theHadronicInteraction.end() ; it++ ) {
      (*it)->BuildPhysicsTable( aParticleType );
   }
}

Here is the caller graph for this function:

Dump()

void G4EnergyRangeManager::Dump

(

G4int

verbose = 0

)

Definition at line 277 of file G4EnergyRangeManager.cc.

{
  G4cout << "G4EnergyRangeManager " << this << G4endl;
  for (G4int i = 0 ; i < theHadronicInteractionCounter; i++) {
    G4cout << "   HadronicModel " << i <<":"
           << theHadronicInteraction[i]->GetModelName() << G4endl;
    if (verbose > 0) {
      G4cout << "      Minimum Energy " 
         << theHadronicInteraction[i]->GetMinEnergy()/GeV << " [GeV], "
             << "Maximum Energy " 
         << theHadronicInteraction[i]->GetMaxEnergy()/GeV << " [GeV]"
             << G4endl;
    }
  }
}

Here is the caller graph for this function:

GetHadronicInteraction() [1/2]

G4HadronicInteraction * G4EnergyRangeManager::GetHadronicInteraction	(	const G4HadProjectile &	aHadProjectile,
		G4Nucleus &	aTargetNucleus,
		const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

Definition at line 78 of file G4EnergyRangeManager.cc.

{
  if(0 == theHadronicInteractionCounter) {
    throw G4HadronicException(__FILE__, __LINE__,
                  "GetHadronicInteraction: NO MODELS STORED");
  }

  G4double kineticEnergy = aHadProjectile.GetKineticEnergy();
  // For ions, get kinetic energy per nucleon
  if ( aHadProjectile.GetDefinition()->GetBaryonNumber() > 1.5 ) {
    kineticEnergy /= aHadProjectile.GetDefinition()->GetBaryonNumber();
  }

  G4int cou = 0, memory = 0, memor2 = 0;
  G4double emi1 = 0.0, ema1 = 0.0, emi2 = 0.0, ema2 = 0.0;

  for (G4int i = 0; i<theHadronicInteractionCounter; ++i) {
    if ( theHadronicInteraction[i]->IsApplicable( aHadProjectile, aTargetNucleus ) ) {
      G4double low  = theHadronicInteraction[i]->GetMinEnergy( aMaterial, anElement );
      // Work-around for particles with 0 kinetic energy, which still
      // require a model to return a ParticleChange
      //if (low == 0.) low = -DBL_MIN;
      G4double high = theHadronicInteraction[i]->GetMaxEnergy( aMaterial, anElement );
      if (low <= kineticEnergy && high > kineticEnergy) {
        ++cou;
        emi2 = emi1;
        ema2 = ema1;
        emi1 = low;
        ema1 = high;
        memor2 = memory;
        memory = i;
      }
    }
  }

  G4int mem = -1;
  G4double rand;
  switch (cou) {
    case 0:
       G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="
         <<theHadronicInteractionCounter<<", Ek="
             <<kineticEnergy<<", Material = "<<aMaterial->GetName()
         <<", Element = "
             <<anElement->GetName()<<G4endl;
       for( G4int j=0; j<theHadronicInteractionCounter; ++j)
       {
         G4HadronicInteraction* HInt=theHadronicInteraction[j];
         G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
               <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
       }
       throw G4HadronicException(__FILE__, __LINE__,
          "GetHadronicInteraction: No Model found");
       return 0;
    case 1:
       mem = memory;
       break;
    case 2:
       if( (emi2<=emi1 && ema2>=ema1) || (emi2>=emi1 && ema2<=ema1) )
       {
         G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="
           <<theHadronicInteractionCounter<<", Ek="
               <<kineticEnergy<<", Material = "<<aMaterial->GetName()
           <<", Element = "
               <<anElement->GetName()<<G4endl;
         for( G4int j=0; j<theHadronicInteractionCounter; ++j)
         {
           G4HadronicInteraction* HInt=theHadronicInteraction[j];
           G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
               <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
         }
         throw G4HadronicException(__FILE__, __LINE__,
         "GetHadronicInteraction: Energy ranges of two models fully overlapping");
       }
       rand = G4UniformRand();
       if( emi1 < emi2 )
       {
         if( (ema1-kineticEnergy) < rand*(ema1-emi2) ) {
           mem = memor2;
         } else {
           mem = memory;
     }
       } else {
         if( (ema2-kineticEnergy) < rand*(ema2-emi1) ) {
           mem = memory;
     } else {
           mem = memor2;
     }
       }
       break;
    default:
      throw G4HadronicException(__FILE__, __LINE__,
      "GetHadronicInteraction: More than two competing models in this energy range");
  }

  return theHadronicInteraction[mem];
} 

Here is the call graph for this function:

Here is the caller graph for this function:

GetHadronicInteraction() [2/2]

G4HadronicInteraction * G4EnergyRangeManager::GetHadronicInteraction	(	const G4double	kineticEnergy,
		const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

Definition at line 180 of file G4EnergyRangeManager.cc.

{
  if(0 == theHadronicInteractionCounter) {
    throw G4HadronicException(__FILE__, __LINE__,
                  "GetHadronicInteraction: NO MODELS STORED");
  } 
  G4int cou = 0, memory = 0, memor2 = 0;
  G4double emi1 = 0.0, ema1 = 0.0, emi2 = 0.0, ema2 = 0.0;

  for (G4int i = 0; i<theHadronicInteractionCounter; ++i) {
      G4double low  = theHadronicInteraction[i]->GetMinEnergy( aMaterial, anElement );
    // Work-around for particles with 0 kinetic energy, which still
    // require a model to return a ParticleChange
    //if (low == 0.) low = -DBL_MIN;
    G4double high = theHadronicInteraction[i]->GetMaxEnergy( aMaterial, anElement );
    if (low <= kineticEnergy && high > kineticEnergy) {
      ++cou;
      emi2 = emi1;
      ema2 = ema1;
      emi1 = low;
      ema1 = high;
      memor2 = memory;
      memory = i;
    }
  }

  G4int mem = -1;
  G4double rand;
  switch (cou) {
    case 0:
       G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="
         <<theHadronicInteractionCounter<<", Ek="
             <<kineticEnergy<<", Material = "<<aMaterial->GetName()
         <<", Element = "
             <<anElement->GetName()<<G4endl;
       for( G4int j=0; j<theHadronicInteractionCounter; ++j)
       {
         G4HadronicInteraction* HInt=theHadronicInteraction[j];
         G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
               <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
       }
       throw G4HadronicException(__FILE__, __LINE__,
          "GetHadronicInteraction: No Model found");
       return 0;
    case 1:
       mem = memory;
       break;
    case 2:
       if( (emi2<=emi1 && ema2>=ema1) || (emi2>=emi1 && ema2<=ema1) )
       {
         G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="
           <<theHadronicInteractionCounter<<", Ek="
               <<kineticEnergy<<", Material = "<<aMaterial->GetName()
           <<", Element = "
               <<anElement->GetName()<<G4endl;
         for( G4int j=0; j<theHadronicInteractionCounter; ++j)
         {
           G4HadronicInteraction* HInt=theHadronicInteraction[j];
           G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
               <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
         }
         throw G4HadronicException(__FILE__, __LINE__,
         "GetHadronicInteraction: Energy ranges of two models fully overlapping");
       }
       rand = G4UniformRand();
       if( emi1 < emi2 )
       {
         if( (ema1-kineticEnergy) < rand*(ema1-emi2) ) {
           mem = memor2;
         } else {
           mem = memory;
     }
       } else {
         if( (ema2-kineticEnergy) < rand*(ema2-emi1) ) {
           mem = memory;
     } else {
           mem = memor2;
     }
       }
       break;
    default:
      throw G4HadronicException(__FILE__, __LINE__,
      "GetHadronicInteraction: More than two competing models in this energy range");
  }

  return theHadronicInteraction[mem];
} 

Here is the call graph for this function:

GetHadronicInteractionList()

std::vector< G4HadronicInteraction * > & G4EnergyRangeManager::GetHadronicInteractionList

(

)

Definition at line 271 of file G4EnergyRangeManager.cc.

{
  return theHadronicInteraction;
}

Here is the caller graph for this function:

operator!=()

G4bool G4EnergyRangeManager::operator!= ( const G4EnergyRangeManager &  right ) const

inline

Definition at line 55 of file G4EnergyRangeManager.hh.

    { return ( this != (G4EnergyRangeManager *) &right ); }

Here is the call graph for this function:

operator=()

G4EnergyRangeManager & G4EnergyRangeManager::operator=

(

const G4EnergyRangeManager &

right

)

Definition at line 54 of file G4EnergyRangeManager.cc.

{
  if (this != &right) {
    theHadronicInteractionCounter = right.theHadronicInteractionCounter;
    theHadronicInteraction = right.theHadronicInteraction;
  }
  return *this;
}

operator==()

G4bool G4EnergyRangeManager::operator== ( const G4EnergyRangeManager &  right ) const

inline

Definition at line 52 of file G4EnergyRangeManager.hh.

    { return ( this == (G4EnergyRangeManager *) &right ); }

RegisterMe()

void G4EnergyRangeManager::RegisterMe

(

G4HadronicInteraction *

a

)

Definition at line 64 of file G4EnergyRangeManager.cc.

{
  if(!a) { return; }
  if(0 < theHadronicInteractionCounter) {
    for(G4int i=0; i<theHadronicInteractionCounter; ++i) {
      if(a == theHadronicInteraction[i]) { return; }
    }
  }
  theHadronicInteraction.push_back(a);
  ++theHadronicInteractionCounter;
}

Here is the caller graph for this function:

Member Data Documentation

theHadronicInteraction

std::vector<G4HadronicInteraction*> G4EnergyRangeManager::theHadronicInteraction

private

Definition at line 80 of file G4EnergyRangeManager.hh.

theHadronicInteractionCounter

G4int G4EnergyRangeManager::theHadronicInteractionCounter

private

Definition at line 79 of file G4EnergyRangeManager.hh.

---

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

• G4EnergyRangeManager.hh
• G4EnergyRangeManager.cc