G4ParticleHPInelastic Class Reference

#include <G4ParticleHPInelastic.hh>

Inheritance diagram for G4ParticleHPInelastic:

Public Member Functions
void	ActivateFor (const G4Element *anElement)
void	ActivateFor (const G4Material *aMaterial)
G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &aTargetNucleus)
void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DeActivateFor (const G4Element *anElement)
void	DeActivateFor (const G4Material *aMaterial)
	G4ParticleHPInelastic (G4ParticleDefinition *projectile=G4Neutron::Neutron(), const char *name="NeutronHPInelastic")
virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
virtual const std::pair< G4double, G4double >	GetFatalEnergyCheckLevels () const
G4double	GetMaxEnergy () const
G4double	GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
G4double	GetMinEnergy () const
G4double	GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
const G4String &	GetModelName () const
G4double	GetRecoilEnergyThreshold () const
G4int	GetVerboseLevel () const
virtual void	InitialiseModel ()
virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
G4bool	IsBlocked (const G4Element *anElement) const
G4bool	IsBlocked (const G4Material *aMaterial) const
virtual void	ModelDescription (std::ostream &outFile) const
G4bool	operator!= (const G4HadronicInteraction &right) const =delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
void	SetMaxEnergy (const G4double anEnergy)
void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)
void	SetMinEnergy (G4double anEnergy)
void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)
void	SetRecoilEnergyThreshold (G4double val)
void	SetVerboseLevel (G4int)
	~G4ParticleHPInelastic ()

Protected Member Functions
void	Block ()
G4bool	IsBlocked () const
void	SetModelName (const G4String &nam)

Protected Attributes
G4String	dataDirVariable
G4String	dirName
G4bool	isBlocked
G4int	numEle
std::vector< G4ParticleHPChannelList * > *	theInelastic
G4double	theMaxEnergy
G4double	theMinEnergy
G4HadFinalState	theParticleChange
G4int	verboseLevel

Private Attributes
std::pair< G4double, G4double >	epCheckLevels
G4double	recoilEnergyThreshold
G4HadronicInteractionRegistry *	registry
std::vector< const G4Material * >	theBlockedList
std::vector< const G4Element * >	theBlockedListElements
std::vector< std::pair< G4double, const G4Material * > >	theMaxEnergyList
std::vector< std::pair< G4double, const G4Element * > >	theMaxEnergyListElements
std::vector< std::pair< G4double, const G4Material * > >	theMinEnergyList
std::vector< std::pair< G4double, const G4Element * > >	theMinEnergyListElements
G4String	theModelName
G4ParticleDefinition *	theProjectile

Detailed Description

Definition at line 89 of file G4ParticleHPInelastic.hh.

Constructor & Destructor Documentation

G4ParticleHPInelastic()

G4ParticleHPInelastic::G4ParticleHPInelastic	(	G4ParticleDefinition *	projectile = G4Neutron::Neutron(),
		const char *	name = "NeutronHPInelastic"
	)

Definition at line 47 of file G4ParticleHPInelastic.cc.

  :G4HadronicInteraction(name)
  ,theInelastic(NULL)
  ,numEle(0)
  ,theProjectile(projectile)
{
    G4String baseName; 
    if ( std::getenv("G4PARTICLEHPDATA") ) {
      baseName = std::getenv( "G4PARTICLEHPDATA" );
    }
    //const char* dataDirVariable;
    G4String particleName;
    if ( theProjectile == G4Neutron::Neutron() ) {
      dataDirVariable = "G4NEUTRONHPDATA";
    } else if( theProjectile == G4Proton::Proton() ) {
      dataDirVariable = "G4PROTONHPDATA";
      particleName = "Proton";
    } else if( theProjectile == G4Deuteron::Deuteron() ) {
      dataDirVariable = "G4DEUTERONHPDATA";
      particleName = "Deuteron";
    } else if( theProjectile == G4Triton::Triton() ) {
      dataDirVariable = "G4TRITONHPDATA";
      particleName = "Triton";
    } else if( theProjectile == G4He3::He3() ) {
      dataDirVariable = "G4HE3HPDATA";
      particleName = "He3";
    } else if( theProjectile == G4Alpha::Alpha() ) {
      dataDirVariable = "G4ALPHAHPDATA";
      particleName = "Alpha";
    } else {
      G4String message("G4ParticleHPInelastic may only be called for neutron, proton, deuteron, triton, He3 or alpha, while it is called for " + theProjectile->GetParticleName());
      throw G4HadronicException(__FILE__, __LINE__,message.c_str());
    }
 
    SetMinEnergy( 0.0 );
    SetMaxEnergy( 20.*MeV );
 
    //G4cout << " entering G4ParticleHPInelastic constructor"<<G4endl;
    if ( !std::getenv("G4PARTICLEHPDATA") && !std::getenv(dataDirVariable) ) {
      G4String message("Please setenv G4PARTICLEHPDATA (recommended) or, at least setenv " +
               G4String(dataDirVariable) + " to point to the " + theProjectile->GetParticleName() + " cross-section files." );      
      throw G4HadronicException(__FILE__, __LINE__,message.c_str());
    }
    if ( std::getenv(dataDirVariable) ) {
      dirName = std::getenv(dataDirVariable);
    } else {
      dirName = baseName + "/" + particleName;
    }
    
    #ifdef G4VERBOSE
    if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 0 ) G4cout << dirName << G4endl;
    #endif
    
    G4String tString = "/Inelastic";
    dirName = dirName + tString;
    //numEle = G4Element::GetNumberOfElements();
 
    #ifdef G4VERBOSE
    if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 0 )
      G4cout << "@@@ G4ParticleHPInelastic instantiated for particle " << theProjectile->GetParticleName() << " data directory variable is " << dataDirVariable << " pointing to " << dirName << G4endl;
    #endif
 
/*
    theInelastic = new G4ParticleHPChannelList[numEle];
    for (G4int i=0; i<numEle; i++)
    { 
      theInelastic[i].Init((*(G4Element::GetElementTable()))[i], dirName);
      G4int itry = 0;
      do
      {
    theInelastic[i].Register(&theNFS, "F01"); // has
    theInelastic[i].Register(&theNXFS, "F02");
    theInelastic[i].Register(&the2NDFS, "F03");
    theInelastic[i].Register(&the2NFS, "F04"); // has, E Done
    theInelastic[i].Register(&the3NFS, "F05"); // has, E Done
    theInelastic[i].Register(&theNAFS, "F06");
    theInelastic[i].Register(&theN3AFS, "F07");
    theInelastic[i].Register(&the2NAFS, "F08");
    theInelastic[i].Register(&the3NAFS, "F09");
    theInelastic[i].Register(&theNPFS, "F10");
    theInelastic[i].Register(&theN2AFS, "F11");
    theInelastic[i].Register(&the2N2AFS, "F12");
    theInelastic[i].Register(&theNDFS, "F13");
    theInelastic[i].Register(&theNTFS, "F14");
    theInelastic[i].Register(&theNHe3FS, "F15");
    theInelastic[i].Register(&theND2AFS, "F16");
    theInelastic[i].Register(&theNT2AFS, "F17");
    theInelastic[i].Register(&the4NFS, "F18"); // has, E Done
    theInelastic[i].Register(&the2NPFS, "F19");
    theInelastic[i].Register(&the3NPFS, "F20");
    theInelastic[i].Register(&theN2PFS, "F21");
    theInelastic[i].Register(&theNPAFS, "F22");
    theInelastic[i].Register(&thePFS, "F23");
    theInelastic[i].Register(&theDFS, "F24");
    theInelastic[i].Register(&theTFS, "F25");
    theInelastic[i].Register(&theHe3FS, "F26");
    theInelastic[i].Register(&theAFS, "F27");
    theInelastic[i].Register(&the2AFS, "F28");
    theInelastic[i].Register(&the3AFS, "F29");
    theInelastic[i].Register(&the2PFS, "F30");
    theInelastic[i].Register(&thePAFS, "F31");
    theInelastic[i].Register(&theD2AFS, "F32");
    theInelastic[i].Register(&theT2AFS, "F33");
    theInelastic[i].Register(&thePDFS, "F34");
    theInelastic[i].Register(&thePTFS, "F35");
    theInelastic[i].Register(&theDAFS, "F36");
    theInelastic[i].RestartRegistration();
        itry++;
      }
      //while(!theInelastic[i].HasDataInAnyFinalState());
      while( !theInelastic[i].HasDataInAnyFinalState() && itry < 6 );
                                                              // 6 is corresponding to the value(5) of G4ParticleHPChannel. TK  
 
      if ( itry == 6 ) 
      {
         // No Final State at all.
         G4bool exceptional = false;
         if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )
         {
            if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H
         } 
         if ( !exceptional ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");
      }
    }
*/
/*
    for (G4int i=0; i<numEle; i++)
    { 
      theInelastic.push_back( new G4ParticleHPChannelList );
      (*theInelastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName, theProjectile);
      G4int itry = 0;
      do
      {
    (*theInelastic[i]).Register(&theNFS, "F01"); // has
    (*theInelastic[i]).Register(&theNXFS, "F02");
    (*theInelastic[i]).Register(&the2NDFS, "F03");
    (*theInelastic[i]).Register(&the2NFS, "F04"); // has, E Done
    (*theInelastic[i]).Register(&the3NFS, "F05"); // has, E Done
    (*theInelastic[i]).Register(&theNAFS, "F06");
    (*theInelastic[i]).Register(&theN3AFS, "F07");
    (*theInelastic[i]).Register(&the2NAFS, "F08");
    (*theInelastic[i]).Register(&the3NAFS, "F09");
    (*theInelastic[i]).Register(&theNPFS, "F10");
    (*theInelastic[i]).Register(&theN2AFS, "F11");
    (*theInelastic[i]).Register(&the2N2AFS, "F12");
    (*theInelastic[i]).Register(&theNDFS, "F13");
    (*theInelastic[i]).Register(&theNTFS, "F14");
    (*theInelastic[i]).Register(&theNHe3FS, "F15");
    (*theInelastic[i]).Register(&theND2AFS, "F16");
    (*theInelastic[i]).Register(&theNT2AFS, "F17");
    (*theInelastic[i]).Register(&the4NFS, "F18"); // has, E Done
    (*theInelastic[i]).Register(&the2NPFS, "F19");
    (*theInelastic[i]).Register(&the3NPFS, "F20");
    (*theInelastic[i]).Register(&theN2PFS, "F21");
    (*theInelastic[i]).Register(&theNPAFS, "F22");
    (*theInelastic[i]).Register(&thePFS, "F23");
    (*theInelastic[i]).Register(&theDFS, "F24");
    (*theInelastic[i]).Register(&theTFS, "F25");
    (*theInelastic[i]).Register(&theHe3FS, "F26");
    (*theInelastic[i]).Register(&theAFS, "F27");
    (*theInelastic[i]).Register(&the2AFS, "F28");
    (*theInelastic[i]).Register(&the3AFS, "F29");
    (*theInelastic[i]).Register(&the2PFS, "F30");
    (*theInelastic[i]).Register(&thePAFS, "F31");
    (*theInelastic[i]).Register(&theD2AFS, "F32");
    (*theInelastic[i]).Register(&theT2AFS, "F33");
    (*theInelastic[i]).Register(&thePDFS, "F34");
    (*theInelastic[i]).Register(&thePTFS, "F35");
    (*theInelastic[i]).Register(&theDAFS, "F36");
    (*theInelastic[i]).RestartRegistration();
        itry++;
      }
      while( !(*theInelastic[i]).HasDataInAnyFinalState() && itry < 6 );
                                                              // 6 is corresponding to the value(5) of G4ParticleHPChannel. TK  
 
      if ( itry == 6 ) 
      {
         // No Final State at all.
         G4bool exceptional = false;
         if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )
         {
            if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H
         } 
     if ( !exceptional ) {
     G4cerr << " ELEMENT Z " << (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() << " N " << (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() << G4endl;  //1H
throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");
     }
      }
 
    }
*/
 
  }

References G4Alpha::Alpha(), dataDirVariable, G4Deuteron::Deuteron(), dirName, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), GetVerboseLevel(), G4He3::He3(), G4HadronicParameters::Instance(), MeV, G4Neutron::Neutron(), G4Proton::Proton(), G4HadronicInteraction::SetMaxEnergy(), G4HadronicInteraction::SetMinEnergy(), theProjectile, and G4Triton::Triton().

~G4ParticleHPInelastic()

G4ParticleHPInelastic::~G4ParticleHPInelastic

(

)

Definition at line 241 of file G4ParticleHPInelastic.cc.

  {
//    delete [] theInelastic;
    //Vector is shared, only master deletes
    if ( !G4Threading::IsWorkerThread() ) {
        if ( theInelastic != NULL ) {
            for ( std::vector<G4ParticleHPChannelList*>::iterator
                it = theInelastic->begin() ; it != theInelastic->end() ; it++ ) {
                delete *it;
            }
            theInelastic->clear();
        }
     }
  }

References G4Threading::IsWorkerThread(), and theInelastic.

Member Function Documentation

ActivateFor() [1/2]

void G4HadronicInteraction::ActivateFor ( const G4Element *  anElement )

inlineinherited

Definition at line 128 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), anElement);
    SetMinEnergy(GetMinEnergy(), anElement);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

ActivateFor() [2/2]

void G4HadronicInteraction::ActivateFor ( const G4Material *  aMaterial )

inlineinherited

Definition at line 120 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), aMaterial);
    SetMinEnergy(GetMinEnergy(), aMaterial);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

ApplyYourself()

G4HadFinalState * G4ParticleHPInelastic::ApplyYourself ( const G4HadProjectile &  aTrack, G4Nucleus &  aTargetNucleus  )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 258 of file G4ParticleHPInelastic.cc.

  {
    G4ParticleHPManager::GetInstance()->OpenReactionWhiteBoard();
    const G4Material * theMaterial = aTrack.GetMaterial();
    G4int n = theMaterial->GetNumberOfElements();
    G4int index = theMaterial->GetElement(0)->GetIndex();
    G4int it=0;
    if(n!=1)
    {
      G4double* xSec = new G4double[n];
      G4double sum=0;
      G4int i;
      const G4double * NumAtomsPerVolume = theMaterial->GetVecNbOfAtomsPerVolume();
      G4double rWeight;    
      G4ParticleHPThermalBoost aThermalE;
      for (i=0; i<n; i++)
      {
        index = theMaterial->GetElement(i)->GetIndex();
        rWeight = NumAtomsPerVolume[i];
    if ( aTrack.GetDefinition() == G4Neutron::Neutron() ) {
      xSec[i] = ((*theInelastic)[index])->GetXsec(aThermalE.GetThermalEnergy(aTrack,
                                          theMaterial->GetElement(i),
                                          theMaterial->GetTemperature()));
    } else {
      xSec[i] = ((*theInelastic)[index])->GetXsec(aTrack.GetKineticEnergy());
    }
        xSec[i] *= rWeight;
        sum+=xSec[i];
#ifdef G4PHPDEBUG
    #ifdef G4VERBOSE
    if( std::getenv("G4ParticleHPDebug") && G4HadronicParameters::Instance()->GetVerboseLevel() > 0 )
      G4cout << " G4ParticleHPInelastic XSEC ELEM " << i << " = " << xSec[i] << G4endl;
    #endif
#endif
 
      }
      G4double random = G4UniformRand();
      G4double running = 0;
      for (i=0; i<n; i++)
      {
        running += xSec[i];
        index = theMaterial->GetElement(i)->GetIndex();
        it = i;
        //if(random<=running/sum) break;
        if( sum == 0 || random<=running/sum) break;
      }
      delete [] xSec;
    }
 
#ifdef G4PHPDEBUG
    #ifdef G4VERBOSE
    if( std::getenv("G4ParticleHPDebug") && G4HadronicParameters::Instance()->GetVerboseLevel() > 0 )
      G4cout << " G4ParticleHPInelastic SELECTED ELEM " << it << " = " << theMaterial->GetElement(it)->GetName() << " FROM MATERIAL " << theMaterial->GetName() << G4endl;
    #endif
#endif
    //return theInelastic[index].ApplyYourself(theMaterial->GetElement(it), aTrack);
    G4HadFinalState* result = ((*theInelastic)[index])->ApplyYourself(theMaterial->GetElement(it), aTrack);
    //
    aNucleus.SetParameters(G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA(),G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargZ());
    const G4Element* target_element = (*G4Element::GetElementTable())[index];
    const G4Isotope* target_isotope=NULL;
    G4int iele = target_element->GetNumberOfIsotopes();
    for ( G4int j = 0 ; j != iele ; j++ ) { 
       target_isotope=target_element->GetIsotope( j );
       if ( target_isotope->GetN() == G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA() ) break; 
    }
    //G4cout << "Target Material of this reaction is " << theMaterial->GetName() << G4endl;
    //G4cout << "Target Element of this reaction is " << target_element->GetName() << G4endl;
    //G4cout << "Target Isotope of this reaction is " << target_isotope->GetName() << G4endl;
    aNucleus.SetIsotope( target_isotope );
 
    G4ParticleHPManager::GetInstance()->CloseReactionWhiteBoard();
 
    //GDEB
    if( std::getenv("G4PHPTEST") ) {
      G4HadSecondary* seco = result->GetSecondary(0);
      if(seco) {
    G4ThreeVector secoMom =  seco->GetParticle()->GetMomentum();
    #ifdef G4VERBOSE
    if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 0 )
      G4cout << " G4ParticleHPinelastic COS THETA " << std::cos(secoMom.theta()) <<" " << secoMom << G4endl;
    #endif
      }
    }
 
    return result;
  }

References ApplyYourself(), G4ParticleHPManager::CloseReactionWhiteBoard(), G4cout, G4endl, G4UniformRand, G4HadProjectile::GetDefinition(), G4Material::GetElement(), G4Element::GetElementTable(), G4Element::GetIndex(), G4ParticleHPManager::GetInstance(), G4Element::GetIsotope(), G4HadProjectile::GetKineticEnergy(), G4HadProjectile::GetMaterial(), G4DynamicParticle::GetMomentum(), G4Isotope::GetN(), G4Element::GetName(), G4Material::GetName(), G4Material::GetNumberOfElements(), G4Element::GetNumberOfIsotopes(), G4HadSecondary::GetParticle(), G4ParticleHPManager::GetReactionWhiteBoard(), G4HadFinalState::GetSecondary(), G4ParticleHPReactionWhiteBoard::GetTargA(), G4ParticleHPReactionWhiteBoard::GetTargZ(), G4Material::GetTemperature(), G4ParticleHPThermalBoost::GetThermalEnergy(), G4Material::GetVecNbOfAtomsPerVolume(), GetVerboseLevel(), G4HadronicParameters::GetVerboseLevel(), G4HadronicParameters::Instance(), CLHEP::detail::n, G4Neutron::Neutron(), G4ParticleHPManager::OpenReactionWhiteBoard(), G4Nucleus::SetIsotope(), G4Nucleus::SetParameters(), and CLHEP::Hep3Vector::theta().

Referenced by ApplyYourself().

Block()

void G4HadronicInteraction::Block ( )

inlineprotectedinherited

Definition at line 170 of file G4HadronicInteraction.hh.

{ isBlocked = true; }

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::ActivateFor(), G4HadronicInteraction::DeActivateFor(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

BuildPhysicsTable()

void G4ParticleHPInelastic::BuildPhysicsTable ( const G4ParticleDefinition &  projectile )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 468 of file G4ParticleHPInelastic.cc.

                                                                                    {
 
   G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
 
   theInelastic = hpmanager->GetInelasticFinalStates( &projectile );
 
   if ( G4Threading::IsMasterThread() ) {
 
      if ( theInelastic == NULL ) theInelastic = new std::vector<G4ParticleHPChannelList*>;
 
      if ( numEle == (G4int)G4Element::GetNumberOfElements() ) return;
 
      if ( theInelastic->size() == G4Element::GetNumberOfElements() ) {
         numEle = G4Element::GetNumberOfElements();
         return;
      }
/*
      const char* dataDirVariable;
      if( &projectile == G4Neutron::Neutron() ) {
        dataDirVariable = "G4NEUTRONHPDATA";
      }else if( &projectile == G4Proton::Proton() ) {
        dataDirVariable = "G4PROTONHPDATA";
      }else if( &projectile == G4Deuteron::Deuteron() ) {
        dataDirVariable = "G4DEUTERONHPDATA";
      }else if( &projectile == G4Triton::Triton() ) {
        dataDirVariable = "G4TRITONHPDATA";
      }else if( &projectile == G4He3::He3() ) {
        dataDirVariable = "G4HE3HPDATA";
      }else if( &projectile == G4Alpha::Alpha() ) {
        dataDirVariable = "G4ALPHAHPDATA";
      } else {
         G4String message("G4ParticleHPInelastic may only be called for neutron, proton, deuteron, triton, He3 or alpha, while it is called for " + projectile.GetParticleName());
         throw G4HadronicException(__FILE__, __LINE__,message.c_str());
      }
      if(!std::getenv(dataDirVariable)){
         G4String message("Please set the environment variable " + G4String(dataDirVariable) + " to point to the " + projectile.GetParticleName() + " cross-section files.");
         throw G4HadronicException(__FILE__, __LINE__,message.c_str());
      }
      dirName = std::getenv(dataDirVariable);
      G4cout << dirName << G4endl;
 
      G4String tString = "/Inelastic";
      dirName = dirName + tString;
 
*/
      #ifdef G4VERBOSE
      if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 0 ) {
    hpmanager->DumpSetting();
    G4cout << "@@@ G4ParticleHPInelastic instantiated for particle " << projectile.GetParticleName() << " data directory variable is " << dataDirVariable << " pointing to " << dirName << G4endl;
      }
      #endif
      for (G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements(); i++)
      {
        theInelastic->push_back( new G4ParticleHPChannelList );
        ((*theInelastic)[i])->Init((*(G4Element::GetElementTable()))[i], dirName, const_cast<G4ParticleDefinition*>(&projectile));
        G4int itry = 0;
        do
        {
          ((*theInelastic)[i])->Register( new G4ParticleHPNInelasticFS , "F01"); // has
          ((*theInelastic)[i])->Register( new G4ParticleHPNXInelasticFS , "F02");
          ((*theInelastic)[i])->Register( new G4ParticleHP2NDInelasticFS , "F03");
          ((*theInelastic)[i])->Register( new G4ParticleHP2NInelasticFS , "F04"); // has, E Done
          ((*theInelastic)[i])->Register( new G4ParticleHP3NInelasticFS , "F05"); // has, E Done
          ((*theInelastic)[i])->Register( new G4ParticleHPNAInelasticFS , "F06");
          ((*theInelastic)[i])->Register( new G4ParticleHPN3AInelasticFS , "F07");
          ((*theInelastic)[i])->Register( new G4ParticleHP2NAInelasticFS , "F08");
          ((*theInelastic)[i])->Register( new G4ParticleHP3NAInelasticFS , "F09");
          ((*theInelastic)[i])->Register( new G4ParticleHPNPInelasticFS , "F10");
          ((*theInelastic)[i])->Register( new G4ParticleHPN2AInelasticFS , "F11");
          ((*theInelastic)[i])->Register( new G4ParticleHP2N2AInelasticFS , "F12");
          ((*theInelastic)[i])->Register( new G4ParticleHPNDInelasticFS , "F13");
          ((*theInelastic)[i])->Register( new G4ParticleHPNTInelasticFS , "F14");
          ((*theInelastic)[i])->Register( new G4ParticleHPNHe3InelasticFS , "F15");
          ((*theInelastic)[i])->Register( new G4ParticleHPND2AInelasticFS , "F16");
          ((*theInelastic)[i])->Register( new G4ParticleHPNT2AInelasticFS , "F17");
          ((*theInelastic)[i])->Register( new G4ParticleHP4NInelasticFS , "F18"); // has, E Done
          ((*theInelastic)[i])->Register( new G4ParticleHP2NPInelasticFS , "F19");
          ((*theInelastic)[i])->Register( new G4ParticleHP3NPInelasticFS , "F20");
          ((*theInelastic)[i])->Register( new G4ParticleHPN2PInelasticFS , "F21");
          ((*theInelastic)[i])->Register( new G4ParticleHPNPAInelasticFS , "F22");
          ((*theInelastic)[i])->Register( new G4ParticleHPPInelasticFS , "F23");
          ((*theInelastic)[i])->Register( new G4ParticleHPDInelasticFS , "F24");
          ((*theInelastic)[i])->Register( new G4ParticleHPTInelasticFS , "F25");
          ((*theInelastic)[i])->Register( new G4ParticleHPHe3InelasticFS , "F26");
          ((*theInelastic)[i])->Register( new G4ParticleHPAInelasticFS , "F27");
          ((*theInelastic)[i])->Register( new G4ParticleHP2AInelasticFS , "F28");
          ((*theInelastic)[i])->Register( new G4ParticleHP3AInelasticFS , "F29");
          ((*theInelastic)[i])->Register( new G4ParticleHP2PInelasticFS , "F30");
          ((*theInelastic)[i])->Register( new G4ParticleHPPAInelasticFS , "F31");
          ((*theInelastic)[i])->Register( new G4ParticleHPD2AInelasticFS , "F32");
          ((*theInelastic)[i])->Register( new G4ParticleHPT2AInelasticFS , "F33");
          ((*theInelastic)[i])->Register( new G4ParticleHPPDInelasticFS , "F34");
          ((*theInelastic)[i])->Register( new G4ParticleHPPTInelasticFS , "F35");
          ((*theInelastic)[i])->Register( new G4ParticleHPDAInelasticFS , "F36");
          ((*theInelastic)[i])->RestartRegistration();
          itry++;
        }
        while( !((*theInelastic)[i])->HasDataInAnyFinalState() && itry < 6 ); // Loop checking, 11.05.2015, T. Koi
                                                              // 6 is corresponding to the value(5) of G4ParticleHPChannel. TK  
 
        if ( itry == 6 ) {
           // No Final State at all.
           /*
           G4bool exceptional = false;
           if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )
           {
              if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H
           } 
       if ( !exceptional ) {
          G4cerr << " ELEMENT Z " << (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() << " N " << (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() << G4endl;  //1H
              throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");
       }
           */
       #ifdef G4VERBOSE
           if ( G4ParticleHPManager::GetInstance()->GetVerboseLevel() > 1 &&
        G4HadronicParameters::Instance()->GetVerboseLevel() > 0 ) {
              G4cout << "ParticleHP::Inelastic for " << projectile.GetParticleName() << ". Do not know what to do with element of \"" << (*(G4Element::GetElementTable()))[i]->GetName() << "\"." << G4endl;
              G4cout << "The components of the element are" << G4endl;
          //G4cout << "TKDB dataDirVariable = " << dataDirVariable << G4endl;
              for ( G4int ii = 0 ; ii < (G4int)( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() ) ; ii++ ) { 
              G4cout << " Z: " << (*(G4Element::GetElementTable()))[i]->GetIsotope( ii )->GetZ() << ", A: " << (*(G4Element::GetElementTable()))[i]->GetIsotope( ii )->GetN() << G4endl;
              }
              G4cout << "No possible final state data of the element is found in " << dataDirVariable << "." << G4endl;
           }
       #endif
        }
      }
      hpmanager->RegisterInelasticFinalStates( &projectile , theInelastic );
   }
   numEle = G4Element::GetNumberOfElements();
}

References dataDirVariable, dirName, G4ParticleHPManager::DumpSetting(), G4cout, G4endl, G4Element::GetElementTable(), G4ParticleHPManager::GetInelasticFinalStates(), G4ParticleHPManager::GetInstance(), G4Element::GetNumberOfElements(), G4ParticleDefinition::GetParticleName(), G4ParticleHPManager::GetVerboseLevel(), GetVerboseLevel(), G4HadronicParameters::GetVerboseLevel(), lightions::Init(), G4HadronicParameters::Instance(), G4Threading::IsMasterThread(), numEle, G4AutoDelete::Register(), G4ParticleHPManager::RegisterInelasticFinalStates(), and theInelastic.

DeActivateFor() [1/2]

void G4HadronicInteraction::DeActivateFor ( const G4Element *  anElement )

inherited

Definition at line 186 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedListElements.push_back(anElement);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedListElements.

DeActivateFor() [2/2]

void G4HadronicInteraction::DeActivateFor ( const G4Material *  aMaterial )

inherited

Definition at line 180 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedList.push_back(aMaterial);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedList.

Referenced by G4HadronHElasticPhysics::ConstructProcess().

GetEnergyMomentumCheckLevels()

std::pair< G4double, G4double > G4HadronicInteraction::GetEnergyMomentumCheckLevels ( ) const

virtualinherited

Reimplemented in G4TheoFSGenerator.

Definition at line 217 of file G4HadronicInteraction.cc.

{
  return epCheckLevels;
}

References G4HadronicInteraction::epCheckLevels.

Referenced by G4HadronicProcess::CheckEnergyMomentumConservation(), and G4TheoFSGenerator::GetEnergyMomentumCheckLevels().

GetFatalEnergyCheckLevels()

const std::pair< G4double, G4double > G4ParticleHPInelastic::GetFatalEnergyCheckLevels ( ) const

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 346 of file G4ParticleHPInelastic.cc.

{
      // max energy non-conservation is mass of heavy nucleus
      // This should be same to the hadron default value
      return std::pair<G4double, G4double>(10*perCent,DBL_MAX);
}

References DBL_MAX, and perCent.

GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const

inlineinherited

Definition at line 96 of file G4HadronicInteraction.hh.

  { return theMaxEnergy; }

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4IonPhysics::ConstructProcess(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronElastic::G4HadronElastic(), G4hhElastic::G4hhElastic(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

GetMaxEnergy() [2/2]

G4double G4HadronicInteraction::GetMaxEnergy ( const G4Material *  aMaterial, const G4Element *  anElement  ) const

inherited

Definition at line 131 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMaxEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return 0.0; }
  if(!theMaxEnergyListElements.empty()) {
    for(auto const& elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second )
    { return elmlist.first; }
    }
  }
  if(!theMaxEnergyList.empty()) {
    for(auto const& matlist : theMaxEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMaxEnergy;
}

References G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMaxEnergy, G4HadronicInteraction::theMaxEnergyList, and G4HadronicInteraction::theMaxEnergyListElements.

GetMinEnergy() [1/2]

G4double G4HadronicInteraction::GetMinEnergy ( ) const

inlineinherited

Definition at line 83 of file G4HadronicInteraction.hh.

  { return theMinEnergy; }

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

GetMinEnergy() [2/2]

G4double G4HadronicInteraction::GetMinEnergy ( const G4Material *  aMaterial, const G4Element *  anElement  ) const

inherited

Definition at line 81 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMinEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return DBL_MAX; }
  if(!theMinEnergyListElements.empty()) {
    for(auto const& elmlist : theMinEnergyListElements) {
    if( anElement == elmlist.second )
      { return elmlist.first; }
    }
  }
  if(!theMinEnergyList.empty()) {
    for(auto const & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMinEnergy;
}

References DBL_MAX, G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMinEnergy, G4HadronicInteraction::theMinEnergyList, and G4HadronicInteraction::theMinEnergyListElements.

GetModelName()

const G4String & G4HadronicInteraction::GetModelName ( ) const

inlineinherited

Definition at line 115 of file G4HadronicInteraction.hh.

  { return theModelName; }

References G4HadronicInteraction::theModelName.

Referenced by G4MuMinusCapturePrecompound::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4VHadronPhysics::BuildModel(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4ChargeExchangePhysics::ConstructProcess(), G4MuonicAtomDecay::DecayIt(), G4LENDModel::DumpLENDTargetInfo(), G4AblaInterface::G4AblaInterface(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4ExcitedStringDecay::G4ExcitedStringDecay(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LENDorBERTModel::G4LENDorBERTModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4LowEIonFragmentation::G4LowEIonFragmentation(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4INCLXXInterface::GetDeExcitationModelName(), G4EnergyRangeManager::GetHadronicInteraction(), G4VHighEnergyGenerator::GetProjectileNucleus(), G4NeutronRadCapture::InitialiseModel(), G4BinaryCascade::ModelDescription(), G4LMsdGenerator::ModelDescription(), G4VPartonStringModel::ModelDescription(), G4TheoFSGenerator::ModelDescription(), G4VHadronPhysics::NewModel(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4HadronicProcessStore::PrintModelHtml(), G4BinaryCascade::PropagateModelDescription(), G4HadronicProcessStore::RegisterInteraction(), and G4LENDModel::returnUnchanged().

GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const

inlineinherited

Definition at line 141 of file G4HadronicInteraction.hh.

  { return recoilEnergyThreshold;}

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4ChargeExchange::ApplyYourself(), and G4HadronElastic::ApplyYourself().

GetVerboseLevel()

G4int G4ParticleHPInelastic::GetVerboseLevel

(

)

const

Definition at line 422 of file G4ParticleHPInelastic.cc.

{
   return G4ParticleHPManager::GetInstance()->GetVerboseLevel();
}

References G4ParticleHPManager::GetInstance(), and G4ParticleHPManager::GetVerboseLevel().

Referenced by ApplyYourself(), BuildPhysicsTable(), and G4ParticleHPInelastic().

InitialiseModel()

void G4HadronicInteraction::InitialiseModel ( )

virtualinherited

Reimplemented in G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4AblaInterface, G4NeutronRadCapture, G4LowEGammaNuclearModel, G4PreCompoundModel, and G4ElasticHadrNucleusHE.

Definition at line 59 of file G4HadronicInteraction.cc.

{}

IsApplicable()

G4bool G4HadronicInteraction::IsApplicable ( const G4HadProjectile &  aTrack, G4Nucleus &  targetNucleus  )

virtualinherited

Reimplemented in G4DiffuseElastic, G4DiffuseElasticV2, G4hhElastic, G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NeutrinoElectronCcModel, G4NeutrinoNucleusModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4CascadeInterface, and G4LMsdGenerator.

Definition at line 75 of file G4HadronicInteraction.cc.

{ 
  return true;
}

IsBlocked() [1/3]

G4bool G4HadronicInteraction::IsBlocked ( ) const

inlineprotectedinherited

Definition at line 169 of file G4HadronicInteraction.hh.

{ return isBlocked;}

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::GetMinEnergy().

IsBlocked() [2/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Element *  anElement ) const

inherited

Definition at line 202 of file G4HadronicInteraction.cc.

{
  for (auto const& elm : theBlockedListElements) {
    if (anElement == elm) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedListElements.

IsBlocked() [3/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Material *  aMaterial ) const

inherited

Definition at line 193 of file G4HadronicInteraction.cc.

{
  for (auto const& mat : theBlockedList) {
    if (aMaterial == mat) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedList.

ModelDescription()

void G4ParticleHPInelastic::ModelDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 600 of file G4ParticleHPInelastic.cc.

{
   outFile << "Extension of High Precision model for inelastic reaction of proton, deuteron, triton, He3 and alpha below 20MeV\n";
}

operator!=()

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

deleteinherited

operator==()

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

deleteinherited

SampleInvariantT()

G4double G4HadronicInteraction::SampleInvariantT ( const G4ParticleDefinition *  p, G4double  plab, G4int  Z, G4int  A  )

virtualinherited

Reimplemented in G4ChipsElasticModel, G4DiffuseElastic, G4DiffuseElasticV2, G4NuclNuclDiffuseElastic, G4AntiNuclElastic, G4ElasticHadrNucleusHE, G4HadronElastic, G4LEHadronProtonElastic, G4LEnp, G4LEpp, G4LowEHadronElastic, and G4hhElastic.

Definition at line 69 of file G4HadronicInteraction.cc.

{
  return 0.0;
}

SetEnergyMomentumCheckLevels()

void G4HadronicInteraction::SetEnergyMomentumCheckLevels ( G4double  relativeLevel, G4double  absoluteLevel  )

inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

  { epCheckLevels.first = relativeLevel;
    epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

Referenced by G4BinaryCascade::G4BinaryCascade(), G4CascadeInterface::G4CascadeInterface(), and G4FTFModel::G4FTFModel().

SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double  anEnergy )

inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

  { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonINCLXXPhysics::AddProcess(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

SetMaxEnergy() [2/3]

void G4HadronicInteraction::SetMaxEnergy ( G4double  anEnergy, const G4Element *  anElement  )

inherited

Definition at line 151 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyListElements.empty()) {
    for(auto & elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second ) {
        elmlist.first = anEnergy;
        return;
      }
    }
  }
  theMaxEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyListElements.

SetMaxEnergy() [3/3]

void G4HadronicInteraction::SetMaxEnergy ( G4double  anEnergy, const G4Material *  aMaterial  )

inherited

Definition at line 166 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyList.empty()) {
    for(auto & matlist: theMaxEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMaxEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyList.

SetMinEnergy() [1/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy )

inlineinherited

Definition at line 89 of file G4HadronicInteraction.hh.

  { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4NeutrinoElectronCcModel::IsApplicable(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

SetMinEnergy() [2/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy, const G4Element *  anElement  )

inherited

Definition at line 101 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyListElements.empty()) {
    for(auto & elmlist : theMinEnergyListElements) {
      if( anElement == elmlist.second ) {
    elmlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyListElements.

SetMinEnergy() [3/3]

void G4HadronicInteraction::SetMinEnergy ( G4double  anEnergy, const G4Material *  aMaterial  )

inherited

Definition at line 116 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyList.empty()) {
    for(auto & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyList.

SetModelName()

void G4HadronicInteraction::SetModelName ( const G4String &  nam )

inlineprotectedinherited

Definition at line 166 of file G4HadronicInteraction.hh.

  { theModelName = nam; }

References G4HadronicInteraction::theModelName.

Referenced by G4ExcitedStringDecay::G4ExcitedStringDecay().

SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double  val )

inlineinherited

Definition at line 138 of file G4HadronicInteraction.hh.

  { recoilEnergyThreshold = val; }

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

SetVerboseLevel()

void G4ParticleHPInelastic::SetVerboseLevel

(

G4int

newValue

)

Definition at line 426 of file G4ParticleHPInelastic.cc.

{
   G4ParticleHPManager::GetInstance()->SetVerboseLevel(newValue);
}

References G4ParticleHPManager::GetInstance(), and G4ParticleHPManager::SetVerboseLevel().

Field Documentation

dataDirVariable

G4String G4ParticleHPInelastic::dataDirVariable

protected

Definition at line 110 of file G4ParticleHPInelastic.hh.

Referenced by BuildPhysicsTable(), and G4ParticleHPInelastic().

dirName

G4String G4ParticleHPInelastic::dirName

protected

Definition at line 111 of file G4ParticleHPInelastic.hh.

Referenced by BuildPhysicsTable(), and G4ParticleHPInelastic().

epCheckLevels

std::pair<G4double, G4double> G4HadronicInteraction::epCheckLevels

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetEnergyMomentumCheckLevels(), and G4HadronicInteraction::SetEnergyMomentumCheckLevels().

isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::Block(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4HadronicInteraction::IsBlocked().

numEle

G4int G4ParticleHPInelastic::numEle

protected

Definition at line 112 of file G4ParticleHPInelastic.hh.

Referenced by BuildPhysicsTable().

recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold

privateinherited

Definition at line 194 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetRecoilEnergyThreshold(), and G4HadronicInteraction::SetRecoilEnergyThreshold().

registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry

privateinherited

Definition at line 192 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::G4HadronicInteraction(), and G4HadronicInteraction::~G4HadronicInteraction().

theBlockedList

std::vector<const G4Material *> G4HadronicInteraction::theBlockedList

privateinherited

Definition at line 204 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

theBlockedListElements

std::vector<const G4Element *> G4HadronicInteraction::theBlockedListElements

privateinherited

Definition at line 205 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

theInelastic

std::vector<G4ParticleHPChannelList*>* G4ParticleHPInelastic::theInelastic

protected

Definition at line 109 of file G4ParticleHPInelastic.hh.

Referenced by BuildPhysicsTable(), and ~G4ParticleHPInelastic().

theMaxEnergy

G4double G4HadronicInteraction::theMaxEnergy

protectedinherited

Definition at line 186 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronicInteraction::G4HadronicInteraction(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

theMaxEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMaxEnergyList

privateinherited

Definition at line 201 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

theMaxEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMaxEnergyListElements

privateinherited

Definition at line 203 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

theMinEnergy

G4double G4HadronicInteraction::theMinEnergy

protectedinherited

Definition at line 185 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

theMinEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMinEnergyList

privateinherited

Definition at line 200 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

theMinEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMinEnergyListElements

privateinherited

Definition at line 202 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

theModelName

G4String G4HadronicInteraction::theModelName

privateinherited

Definition at line 196 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetModelName(), and G4HadronicInteraction::SetModelName().

theParticleChange

G4HadFinalState G4HadronicInteraction::theParticleChange

protectedinherited

Definition at line 172 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4ElectroVDNuclearModel::ApplyYourself(), G4ParticleHPThermalScattering::ApplyYourself(), G4NeutrinoElectronNcModel::ApplyYourself(), G4NeutronElectronElModel::ApplyYourself(), G4LFission::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4MuonVDNuclearModel::ApplyYourself(), G4NeutrinoElectronCcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4ElectroVDNuclearModel::CalculateEMVertex(), G4MuonVDNuclearModel::CalculateEMVertex(), G4ElectroVDNuclearModel::CalculateHadronicVertex(), G4MuonVDNuclearModel::CalculateHadronicVertex(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::copyOutputToHadronicResult(), G4BinaryCascade::DebugEpConservation(), G4BinaryCascade::DebugFinalEpConservation(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), G4WilsonAbrasionModel::GetAbradedNucleons(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4NeutrinoNucleusModel::RecoilDeexcitation(), G4LEHadronProtonElastic::~G4LEHadronProtonElastic(), G4LEnp::~G4LEnp(), and G4LFission::~G4LFission().

theProjectile

G4ParticleDefinition* G4ParticleHPInelastic::theProjectile

private

Definition at line 154 of file G4ParticleHPInelastic.hh.

Referenced by G4ParticleHPInelastic().

verboseLevel

G4int G4HadronicInteraction::verboseLevel

protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LFission::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4CascadeInterface::checkFinalResult(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4LENDModel::create_used_target_map(), G4CascadeInterface::createBullet(), G4CascadeInterface::createTarget(), G4ElasticHadrNucleusHE::DefineHadronValues(), G4ElasticHadrNucleusHE::FillData(), G4ElasticHadrNucleusHE::FillFq2(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE(), G4EMDissociation::G4EMDissociation(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4ElasticHadrNucleusHE::GetFt(), G4ElasticHadrNucleusHE::GetLightFq2(), G4ElasticHadrNucleusHE::GetQ2_2(), G4HadronicInteraction::GetVerboseLevel(), G4ElasticHadrNucleusHE::HadronNucleusQ2_2(), G4ElasticHadrNucleusHE::HadronProtonQ2(), G4LFission::init(), G4DiffuseElastic::Initialise(), G4DiffuseElasticV2::Initialise(), G4NuclNuclDiffuseElastic::Initialise(), G4DiffuseElastic::InitialiseOnFly(), G4DiffuseElasticV2::InitialiseOnFly(), G4NuclNuclDiffuseElastic::InitialiseOnFly(), G4CascadeInterface::makeDynamicParticle(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4ElasticHadrNucleusHE::SampleInvariantT(), G4AntiNuclElastic::SampleThetaCMS(), G4DiffuseElastic::SampleThetaLab(), G4NuclNuclDiffuseElastic::SampleThetaLab(), G4AntiNuclElastic::SampleThetaLab(), G4WilsonAbrasionModel::SetUseAblation(), G4HadronicInteraction::SetVerboseLevel(), G4WilsonAbrasionModel::SetVerboseLevel(), G4DiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElasticV2::ThetaCMStoThetaLab(), G4NuclNuclDiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElastic::ThetaLabToThetaCMS(), G4DiffuseElasticV2::ThetaLabToThetaCMS(), and G4NuclNuclDiffuseElastic::ThetaLabToThetaCMS().

---

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

• source/processes/hadronic/models/particle_hp/include/G4ParticleHPInelastic.hh
• source/processes/hadronic/models/particle_hp/src/G4ParticleHPInelastic.cc