G4ParticleHPThermalScattering Class Reference

#include <G4ParticleHPThermalScattering.hh>

Inheritance diagram for G4ParticleHPThermalScattering:

Public Member Functions
void	ActivateFor (const G4Element *anElement)
void	ActivateFor (const G4Material *aMaterial)
void	AddUserThermalScatteringFile (G4String, G4String)
G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &aTargetNucleus)
void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DeActivateFor (const G4Element *anElement)
void	DeActivateFor (const G4Material *aMaterial)
	G4ParticleHPThermalScattering ()
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 value)
	~G4ParticleHPThermalScattering ()

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

Protected Attributes
G4bool	isBlocked
G4double	theMaxEnergy
G4double	theMinEnergy
G4HadFinalState	theParticleChange
G4int	verboseLevel

Private Member Functions
void	buildPhysicsTable ()
G4bool	check_E_isoAng (E_isoAng *)
void	clearCurrentFSData ()
E_isoAng	create_E_isoAng_from_energy (G4double, std::vector< E_isoAng * > *)
std::pair< G4double, E_isoAng >	create_sE_and_EPM_from_pE_and_vE_P_E_isoAng (G4double, G4double, std::vector< E_P_E_isoAng * > *)
std::pair< G4double, G4double >	find_LH (G4double, std::vector< G4double > *)
G4double	get_linear_interpolated (G4double, std::pair< G4double, G4double >, std::pair< G4double, G4double >)
G4double	get_secondary_energy_from_E_P_E_isoAng (G4double random, E_P_E_isoAng *anE_P_E_isoAng)
G4double	getMu (E_isoAng *)
G4double	getMu (G4double rndm1, G4double rndm2, E_isoAng *anEPM)
G4int	getTS_ID (const G4Material *, const G4Element *)
std::map< G4double, std::vector< std::pair< G4double, G4double > * > * > *	readACoherentFSDATA (G4String)
E_isoAng *	readAnE_isoAng (std::istream *)
E_P_E_isoAng *	readAnE_P_E_isoAng (std::istream *)
std::map< G4double, std::vector< E_isoAng * > * > *	readAnIncoherentFSDATA (G4String)
std::map< G4double, std::vector< E_P_E_isoAng * > * > *	readAnInelasticFSDATA (G4String)
std::pair< G4double, G4int >	sample_inelastic_E (G4double rndm1, G4double rndm2, E_P_E_isoAng *anE_P_E_isoAng)
std::pair< G4double, G4double >	sample_inelastic_E_mu (G4double pE, std::vector< E_P_E_isoAng * > *vNEP_EPM)

Private Attributes
std::map< G4int, std::map< G4double, std::vector< std::pair< G4double, G4double > * > * > * > *	coherentFSs
std::map< std::pair< const G4Material *, const G4Element * >, G4int >	dic
std::pair< G4double, G4double >	epCheckLevels
std::map< G4int, std::map< G4double, std::vector< E_isoAng * > * > * > *	incoherentFSs
std::map< G4int, std::map< G4double, std::vector< E_P_E_isoAng * > * > * > *	inelasticFSs
G4ParticleHPThermalScatteringNames	names
size_t	nElement
size_t	nMaterial
G4double	recoilEnergyThreshold
G4HadronicInteractionRegistry *	registry
std::vector< const G4Material * >	theBlockedList
std::vector< const G4Element * >	theBlockedListElements
G4ParticleHPElastic *	theHPElastic
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
G4ParticleHPThermalScatteringData *	theXSection

Detailed Description

Definition at line 81 of file G4ParticleHPThermalScattering.hh.

Constructor & Destructor Documentation

G4ParticleHPThermalScattering()

G4ParticleHPThermalScattering::G4ParticleHPThermalScattering

(

)

Definition at line 56 of file G4ParticleHPThermalScattering.cc.

                             :G4HadronicInteraction("NeutronHPThermalScattering")
,coherentFSs(nullptr)
,incoherentFSs(nullptr)
,inelasticFSs(nullptr)
{
   theHPElastic = new G4ParticleHPElastic();
 
   SetMinEnergy( 0.*eV );
   SetMaxEnergy( 4*eV );
   theXSection = new G4ParticleHPThermalScatteringData();
 
   nMaterial = 0;
   nElement = 0;
}

References eV, nElement, nMaterial, G4HadronicInteraction::SetMaxEnergy(), G4HadronicInteraction::SetMinEnergy(), theHPElastic, and theXSection.

~G4ParticleHPThermalScattering()

G4ParticleHPThermalScattering::~G4ParticleHPThermalScattering

(

)

Definition at line 73 of file G4ParticleHPThermalScattering.cc.

{
   delete theHPElastic;
}

References theHPElastic.

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().

AddUserThermalScatteringFile()

void G4ParticleHPThermalScattering::AddUserThermalScatteringFile	(	G4String	nameG4Element,
		G4String	filename
	)

Definition at line 1253 of file G4ParticleHPThermalScattering.cc.

{
   names.AddThermalElement( nameG4Element , filename );
   theXSection->AddUserThermalScatteringFile( nameG4Element , filename );
   buildPhysicsTable();
}

References G4ParticleHPThermalScatteringNames::AddThermalElement(), G4ParticleHPThermalScatteringData::AddUserThermalScatteringFile(), buildPhysicsTable(), names, and theXSection.

ApplyYourself()

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

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 339 of file G4ParticleHPThermalScattering.cc.

{
 
// Select Element > Reaction >
 
   const G4Material * theMaterial = aTrack.GetMaterial();
   G4double aTemp = theMaterial->GetTemperature();
   G4int n = theMaterial->GetNumberOfElements();
 
   G4bool findThermalElement = false;
   G4int ielement;
   const G4Element* theElement = nullptr;
   for ( G4int i = 0; i < n ; i++ )
   {
      theElement = theMaterial->GetElement(i);
      //Select target element 
      if ( aNucleus.GetZ_asInt() == (G4int)(theElement->GetZ() + 0.5 ) )
      {
         //Check Applicability of Thermal Scattering 
         if (  getTS_ID( nullptr , theElement ) != -1 )
         {
            ielement = getTS_ID( nullptr , theElement );
            findThermalElement = true;
            break;
         }
         else if (  getTS_ID( theMaterial , theElement ) != -1 )
         {
            ielement = getTS_ID( theMaterial , theElement );
            findThermalElement = true;
            break;
         }
      }       
   } 
 
   if ( findThermalElement == true )
   {
 
//    Select Reaction  (Inelastic, coherent, incoherent)  
      const G4ParticleDefinition* pd = aTrack.GetDefinition();
      G4DynamicParticle* dp = new G4DynamicParticle ( pd , aTrack.Get4Momentum() );
      G4double total = theXSection->GetCrossSection( dp , theElement , theMaterial );
      G4double inelastic = theXSection->GetInelasticCrossSection( dp , theElement , theMaterial );
   
 
      G4double random = G4UniformRand();
      if ( random <= inelastic/total ) 
      {
         // Inelastic
 
         // T_L and T_H 
         std::map < G4double , std::vector< E_P_E_isoAng* >* >::iterator it; 
         std::vector<G4double> v_temp;
         v_temp.clear();
         for ( it = inelasticFSs->find( ielement )->second->begin() ; it != inelasticFSs->find( ielement )->second->end() ; it++ )
         {
            v_temp.push_back( it->first );
         }
 
//                   T_L         T_H 
         std::pair < G4double , G4double > tempLH = find_LH ( aTemp , &v_temp );
//
//       For T_L aNEP_EPM_TL  and T_H aNEP_EPM_TH
//
         std::vector< E_P_E_isoAng* >* vNEP_EPM_TL = 0;
         std::vector< E_P_E_isoAng* >* vNEP_EPM_TH = 0;
 
         if ( tempLH.first != 0.0 && tempLH.second != 0.0 ) 
         {
            vNEP_EPM_TL = inelasticFSs->find( ielement )->second->find ( tempLH.first/kelvin )->second;
            vNEP_EPM_TH = inelasticFSs->find( ielement )->second->find ( tempLH.second/kelvin )->second;
         }
         else if ( tempLH.first == 0.0 )
         {
            std::map < G4double , std::vector< E_P_E_isoAng* >* >::iterator itm;  
            itm = inelasticFSs->find( ielement )->second->begin();
            vNEP_EPM_TL = itm->second;
            itm++;
            vNEP_EPM_TH = itm->second;
            tempLH.first = tempLH.second;
            tempLH.second = itm->first;
         }
         else if (  tempLH.second == 0.0 )
         {
            std::map < G4double , std::vector< E_P_E_isoAng* >* >::iterator itm;  
            itm = inelasticFSs->find( ielement )->second->end();
            itm--;
            vNEP_EPM_TH = itm->second;
            itm--;
            vNEP_EPM_TL = itm->second;
            tempLH.second = tempLH.first;
            tempLH.first = itm->first;
         } 
 
     G4double sE=0., mu=1.0;
        
     // New Geant4 method - Stochastic temperature interpolation of the final state
         // (continuous temperature interpolation was used previously)
         std::pair< G4double , G4double > secondaryParam;
         G4double rand_temp = G4UniformRand();
         if ( rand_temp < (aTemp-tempLH.first)/(tempLH.second - tempLH.first) )
        secondaryParam = sample_inelastic_E_mu( aTrack.GetKineticEnergy() , vNEP_EPM_TH );  
         else
            secondaryParam = sample_inelastic_E_mu( aTrack.GetKineticEnergy() , vNEP_EPM_TL );
 
     sE = secondaryParam.first;
     mu = secondaryParam.second;
               
         //set 
         theParticleChange.SetEnergyChange( sE );
         G4double phi = CLHEP::twopi*G4UniformRand();
         G4double sint= std::sqrt ( 1 - mu*mu );
         theParticleChange.SetMomentumChange( sint*std::cos(phi), sint*std::sin(phi), mu );
 
      } 
      else if ( random <= ( inelastic + theXSection->GetCoherentCrossSection( dp , theElement , theMaterial ) ) / total )
      {
         // Coherent Elastic 
 
         G4double E = aTrack.GetKineticEnergy();
 
         // T_L and T_H 
         std::map < G4double , std::vector< std::pair< G4double , G4double >* >* >::iterator it; 
         std::vector<G4double> v_temp;
         v_temp.clear();
         for ( it = coherentFSs->find( ielement )->second->begin() ; it != coherentFSs->find( ielement )->second->end() ; it++ )
         {
            v_temp.push_back( it->first );
         }
 
//                   T_L         T_H 
         std::pair < G4double , G4double > tempLH = find_LH ( aTemp , &v_temp );
//
//
//       For T_L anEPM_TL  and T_H anEPM_TH
//
         std::vector< std::pair< G4double , G4double >* >* pvE_p_TL = nullptr; 
         std::vector< std::pair< G4double , G4double >* >* pvE_p_TH = nullptr; 
 
         if ( tempLH.first != 0.0 && tempLH.second != 0.0 ) 
         {
            pvE_p_TL = coherentFSs->find( ielement )->second->find ( tempLH.first/kelvin )->second;
            pvE_p_TH = coherentFSs->find( ielement )->second->find ( tempLH.first/kelvin )->second;
         }
         else if ( tempLH.first == 0.0 )
         {
            pvE_p_TL = coherentFSs->find( ielement )->second->find ( v_temp[ 0 ] )->second;
            pvE_p_TH = coherentFSs->find( ielement )->second->find ( v_temp[ 1 ] )->second;
            tempLH.first = tempLH.second;
            tempLH.second = v_temp[ 1 ];
         }
         else if ( tempLH.second == 0.0 )
         {
            pvE_p_TH = coherentFSs->find( ielement )->second->find ( v_temp.back() )->second;
            std::vector< G4double >::iterator itv;
            itv = v_temp.end();
            itv--;
            itv--;
            pvE_p_TL = coherentFSs->find( ielement )->second->find ( *itv )->second;
            tempLH.second = tempLH.first;
            tempLH.first = *itv;
         }
         else 
         {
            //tempLH.first == 0.0 && tempLH.second
            throw G4HadronicException(__FILE__, __LINE__, "A problem is found in Thermal Scattering Data! Unexpected temperature values in data");
         }
 
         std::vector< G4double > vE_T;
         std::vector< G4double > vp_T;
 
         G4int n1 = pvE_p_TL->size();  
       
         // New Geant4 method - Stochastic interpolation of the final state
         std::vector< std::pair< G4double , G4double >* >* pvE_p_T_sampled;
         G4double rand_temp = G4UniformRand();
         if ( rand_temp < (aTemp-tempLH.first)/(tempLH.second - tempLH.first) )
            pvE_p_T_sampled = pvE_p_TH;
         else
            pvE_p_T_sampled = pvE_p_TL;
 
         //171005 fix bug, contribution from H.N. TRAN@CEA
         for ( G4int i=0 ; i < n1 ; i++ ) 
         {
            vE_T.push_back ( (*pvE_p_T_sampled)[i]->first );
            vp_T.push_back ( (*pvE_p_T_sampled)[i]->second );            
         }
 
         G4int j = 0;  
         for ( G4int i = 1 ; i < n1 ; i++ ) 
         {
            if ( E/eV < vE_T[ i ] ) 
            {
               j = i-1;
               break;
            }
         }
 
         G4double rand_for_mu = G4UniformRand();
 
         G4int k = 0;
         for ( G4int i = 0 ; i <= j ; i++ )
         {
             G4double Pi = vp_T[ i ] / vp_T[ j ]; 
             if ( rand_for_mu < Pi )
             {
                k = i; 
                break;
             }
         }
 
         G4double Ei = vE_T[ k ];
 
         G4double mu = 1 - 2 * Ei / (E/eV) ;  
         //111102
         if ( mu < -1.0 ) mu = -1.0;
         //G4cout << "E= " << E/eV << ", Ei= " << Ei << ", mu= " << mu << G4endl;
 
         theParticleChange.SetEnergyChange( E );
         G4double phi = CLHEP::twopi*G4UniformRand();
         G4double sint= std::sqrt ( 1 - mu*mu );
         theParticleChange.SetMomentumChange( sint*std::cos(phi), sint*std::sin(phi), mu );
 
      }
      else
      {
         // InCoherent Elastic
 
         // T_L and T_H 
         std::map < G4double , std::vector < E_isoAng* >* >::iterator it; 
         std::vector<G4double> v_temp;
         v_temp.clear();
         for ( it = incoherentFSs->find( ielement )->second->begin() ; it != incoherentFSs->find( ielement )->second->end() ; it++ )
         {
            v_temp.push_back( it->first );
         }
              
//                   T_L         T_H 
         std::pair < G4double , G4double > tempLH = find_LH ( aTemp , &v_temp );
 
//
//       For T_L anEPM_TL  and T_H anEPM_TH
//
 
         E_isoAng anEPM_TL_E;
         E_isoAng anEPM_TH_E;
 
         if ( tempLH.first != 0.0 && tempLH.second != 0.0 ) {
            //Interpolate TL and TH 
            anEPM_TL_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( tempLH.first/kelvin )->second );
            anEPM_TH_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( tempLH.second/kelvin )->second );
         } else if ( tempLH.first == 0.0 ) {
            //Extrapolate T0 and T1
            anEPM_TL_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( v_temp[ 0 ] )->second );
            anEPM_TH_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( v_temp[ 1 ] )->second );
            tempLH.first = tempLH.second;
            tempLH.second = v_temp[ 1 ];
         } else if (  tempLH.second == 0.0 ) {
            //Extrapolate Tmax-1 and Tmax
            anEPM_TH_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( v_temp.back() )->second );
            std::vector< G4double >::iterator itv;
            itv = v_temp.end();
            itv--;
            itv--;
            anEPM_TL_E = create_E_isoAng_from_energy ( aTrack.GetKineticEnergy() , incoherentFSs->find( ielement )->second->find ( *itv )->second );
            tempLH.second = tempLH.first;
            tempLH.first = *itv;
         } 
        
         // E_isoAng for aTemp and aTrack.GetKineticEnergy() 
         G4double mu=1.0;
         
         // New Geant4 method - Stochastic interpolation of the final state
         E_isoAng anEPM_T_E_sampled;
         G4double rand_temp = G4UniformRand();
         if ( rand_temp < (aTemp-tempLH.first)/(tempLH.second - tempLH.first) )
            anEPM_T_E_sampled = anEPM_TH_E;
         else
            anEPM_T_E_sampled = anEPM_TL_E;
        
         mu = getMu ( &anEPM_T_E_sampled );
 
         // Set Final State
         theParticleChange.SetEnergyChange( aTrack.GetKineticEnergy() );  // No energy change in Elastic
         G4double phi = CLHEP::twopi*G4UniformRand();
         G4double sint= std::sqrt ( 1 - mu*mu );
         theParticleChange.SetMomentumChange( sint*std::cos(phi), sint*std::sin(phi), mu );
 
      } 
      delete dp;
 
      return &theParticleChange;
      
   }
   else 
   {
      // Not thermal element   
      // Neutron HP will handle
      return theHPElastic -> ApplyYourself( aTrack, aNucleus, 1); // L. Thulliez 2021/05/04 (CEA-Saclay)
   }
 
}

References ApplyYourself(), coherentFSs, create_E_isoAng_from_energy(), eV, find_LH(), G4UniformRand, G4HadProjectile::Get4Momentum(), G4ParticleHPThermalScatteringData::GetCoherentCrossSection(), G4ParticleHPThermalScatteringData::GetCrossSection(), G4HadProjectile::GetDefinition(), G4Material::GetElement(), G4ParticleHPThermalScatteringData::GetInelasticCrossSection(), G4HadProjectile::GetKineticEnergy(), G4HadProjectile::GetMaterial(), getMu(), G4Material::GetNumberOfElements(), G4Material::GetTemperature(), getTS_ID(), G4Element::GetZ(), G4Nucleus::GetZ_asInt(), incoherentFSs, inelasticFSs, kelvin, CLHEP::detail::n, sample_inelastic_E_mu(), second, G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetMomentumChange(), theHPElastic, G4HadronicInteraction::theParticleChange, theXSection, G4INCL::CrossSections::total(), and CLHEP::twopi.

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 G4ParticleHPThermalScattering::buildPhysicsTable ( )

private

Definition at line 1092 of file G4ParticleHPThermalScattering.cc.

{
   //Is rebuild of physics table a necessity 
   if ( nMaterial == G4Material::GetMaterialTable()->size() && nElement == G4Element::GetElementTable()->size() ) {
      return;
   } else {
      nMaterial = G4Material::GetMaterialTable()->size(); 
      nElement = G4Element::GetElementTable()->size(); 
   }
 
   dic.clear();   
   std::map < G4String , G4int > co_dic;   
 
   //Searching Nist Materials
   static G4ThreadLocal G4MaterialTable* theMaterialTable  = 0 ; if (!theMaterialTable) theMaterialTable= G4Material::GetMaterialTable();
   size_t numberOfMaterials = G4Material::GetNumberOfMaterials();
   for ( size_t i = 0 ; i < numberOfMaterials ; i++ )
   {
      G4Material* material = (*theMaterialTable)[i];
      size_t numberOfElements = material->GetNumberOfElements();
      for ( size_t j = 0 ; j < numberOfElements ; j++ )
      {
         const G4Element* element = material->GetElement(j);
         if ( names.IsThisThermalElement ( material->GetName() , element->GetName() ) )
         {                                    
            G4int ts_ID_of_this_geometry; 
            G4String ts_ndl_name = names.GetTS_NDL_Name( material->GetName() , element->GetName() ); 
            if ( co_dic.find ( ts_ndl_name ) != co_dic.end() )
            {
               ts_ID_of_this_geometry = co_dic.find ( ts_ndl_name ) -> second;
            }
            else
            {
               ts_ID_of_this_geometry = co_dic.size();
               co_dic.insert ( std::pair< G4String , G4int >( ts_ndl_name , ts_ID_of_this_geometry ) );
            }
 
            //G4cout << "Neutron HP Thermal Scattering: Registering a material-element pair of " 
            //       << material->GetName() << " " << element->GetName() 
            //       << " as internal thermal scattering id of  " <<  ts_ID_of_this_geometry << "." << G4endl;
 
            dic.insert( std::pair < std::pair < G4Material* , const G4Element* > , G4int > ( std::pair < G4Material* , const G4Element* > ( material , element ) , ts_ID_of_this_geometry ) );
         }
      }
   }
 
   //Searching TS Elements 
   static G4ThreadLocal G4ElementTable* theElementTable  = 0 ; if (!theElementTable) theElementTable= G4Element::GetElementTable();
   size_t numberOfElements = G4Element::GetNumberOfElements();
   //size_t numberOfThermalElements = 0; 
   for ( size_t i = 0 ; i < numberOfElements ; i++ )
   {
      const G4Element* element = (*theElementTable)[i];
      if ( names.IsThisThermalElement ( element->GetName() ) )
      {
         if ( names.IsThisThermalElement ( element->GetName() ) )
         {                                    
            G4int ts_ID_of_this_geometry; 
            G4String ts_ndl_name = names.GetTS_NDL_Name( element->GetName() ); 
            if ( co_dic.find ( ts_ndl_name ) != co_dic.end() )
            {
               ts_ID_of_this_geometry = co_dic.find ( ts_ndl_name ) -> second;
            }
            else
            {
               ts_ID_of_this_geometry = co_dic.size();
               co_dic.insert ( std::pair< G4String , G4int >( ts_ndl_name , ts_ID_of_this_geometry ) );
            }
 
            //G4cout << "Neutron HP Thermal Scattering: Registering an element of " 
            //       << material->GetName() << " " << element->GetName() 
            //       << " as internal thermal scattering id of  " <<  ts_ID_of_this_geometry << "." << G4endl;
 
            dic.insert( std::pair < std::pair < const G4Material* , const G4Element* > , G4int > ( std::pair < const G4Material* , const G4Element* > ( (G4Material*)nullptr , element ) ,  ts_ID_of_this_geometry ) );
         }
      }
   }
 
   G4cout << G4endl;
   G4cout << "Neutron HP Thermal Scattering: Following material-element pairs or elements are registered." << G4endl;
   for ( std::map < std::pair < const G4Material* , const G4Element* > , G4int >::iterator it = dic.begin() ; it != dic.end() ; it++ )   
   {
      if ( it->first.first != nullptr ) 
      {
         G4cout << "Material " << it->first.first->GetName() << " - Element " << it->first.second->GetName() << ",  internal thermal scattering id " << it->second << G4endl;
      }
      else
      {
         G4cout << "Element " << it->first.second->GetName() << ",  internal thermal scattering id " << it->second << G4endl;
      }
   }
   G4cout << G4endl;
 
   // Read Cross Section Data files
   
   G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
   coherentFSs = hpmanager->GetThermalScatteringCoherentFinalStates();
   incoherentFSs = hpmanager->GetThermalScatteringIncoherentFinalStates();
   inelasticFSs = hpmanager->GetThermalScatteringInelasticFinalStates();
 
   if ( G4Threading::IsMasterThread() ) {
 
      clearCurrentFSData();
 
      if ( coherentFSs == nullptr ) coherentFSs = new std::map < G4int , std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* >;
      if ( incoherentFSs == nullptr ) incoherentFSs = new std::map < G4int , std::map < G4double , std::vector < E_isoAng* >* >* >;
      if ( inelasticFSs == nullptr ) inelasticFSs = new std::map < G4int , std::map < G4double , std::vector < E_P_E_isoAng* >* >* >;
 
       G4String dirName;
       if ( !std::getenv( "G4NEUTRONHPDATA" ) ) 
          throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
       dirName = std::getenv( "G4NEUTRONHPDATA" );
 
   //G4String name;
 
   for ( std::map < G4String , G4int >::iterator it = co_dic.begin() ; it != co_dic.end() ; it++ )  
   {
      G4String tsndlName = it->first;
      G4int ts_ID = it->second;
 
      // Coherent
      G4String fsName = "/ThermalScattering/Coherent/FS/";
      G4String fileName = dirName + fsName + tsndlName;
      coherentFSs->insert ( std::pair < G4int , std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* > ( ts_ID , readACoherentFSDATA( fileName ) ) ); 
 
      // incoherent elastic 
      fsName = "/ThermalScattering/Incoherent/FS/";
      fileName = dirName + fsName + tsndlName;
      incoherentFSs->insert ( std::pair < G4int , std::map < G4double , std::vector < E_isoAng* >* >* > ( ts_ID , readAnIncoherentFSDATA( fileName ) ) ); 
 
      // inelastic 
      fsName = "/ThermalScattering/Inelastic/FS/";
      fileName = dirName + fsName + tsndlName;
      inelasticFSs->insert ( std::pair < G4int , std::map < G4double , std::vector < E_P_E_isoAng* >* >* > ( ts_ID , readAnInelasticFSDATA( fileName ) ) ); 
   } 
 
      hpmanager->RegisterThermalScatteringCoherentFinalStates( coherentFSs );
      hpmanager->RegisterThermalScatteringIncoherentFinalStates( incoherentFSs );
      hpmanager->RegisterThermalScatteringInelasticFinalStates( inelasticFSs );
   }
 
   theXSection->BuildPhysicsTable( *(G4Neutron::Neutron()) );
}

References G4ParticleHPThermalScatteringData::BuildPhysicsTable(), clearCurrentFSData(), coherentFSs, dic, G4cout, G4endl, G4ThreadLocal, G4Element::GetElementTable(), G4ParticleHPManager::GetInstance(), G4Material::GetMaterialTable(), G4Element::GetName(), G4Element::GetNumberOfElements(), G4Material::GetNumberOfMaterials(), G4ParticleHPManager::GetThermalScatteringCoherentFinalStates(), G4ParticleHPManager::GetThermalScatteringIncoherentFinalStates(), G4ParticleHPManager::GetThermalScatteringInelasticFinalStates(), G4ParticleHPThermalScatteringNames::GetTS_NDL_Name(), incoherentFSs, inelasticFSs, G4Threading::IsMasterThread(), G4ParticleHPThermalScatteringNames::IsThisThermalElement(), anonymous_namespace{G4QuasiElRatios.cc}::map, eplot::material, names, nElement, G4Neutron::Neutron(), nMaterial, readACoherentFSDATA(), readAnIncoherentFSDATA(), readAnInelasticFSDATA(), G4ParticleHPManager::RegisterThermalScatteringCoherentFinalStates(), G4ParticleHPManager::RegisterThermalScatteringIncoherentFinalStates(), G4ParticleHPManager::RegisterThermalScatteringInelasticFinalStates(), second, and theXSection.

Referenced by AddUserThermalScatteringFile(), and BuildPhysicsTable().

BuildPhysicsTable()

void G4ParticleHPThermalScattering::BuildPhysicsTable ( const G4ParticleDefinition &  particle )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 142 of file G4ParticleHPThermalScattering.cc.

                                                                                          {
   buildPhysicsTable();
   theHPElastic->BuildPhysicsTable( particle );
}

References buildPhysicsTable(), G4ParticleHPElastic::BuildPhysicsTable(), and theHPElastic.

check_E_isoAng()

G4bool G4ParticleHPThermalScattering::check_E_isoAng ( E_isoAng *  anE_IsoAng )

private

Definition at line 1261 of file G4ParticleHPThermalScattering.cc.

{
   G4bool result=false;
 
   G4int n = anE_IsoAng->n;
   G4double sum=0.0;
   for ( G4int i = 0 ; i < n ; i++ ) {
      sum += anE_IsoAng->isoAngle[ i ];
   }
   if ( sum != 0.0 ) result = true;
 
   return result;
}

References E_isoAng::isoAngle, CLHEP::detail::n, and E_isoAng::n.

Referenced by create_E_isoAng_from_energy().

clearCurrentFSData()

void G4ParticleHPThermalScattering::clearCurrentFSData ( )

private

Definition at line 79 of file G4ParticleHPThermalScattering.cc.

                                                       {
   if ( incoherentFSs != nullptr ) {
      for ( std::map < G4int , std::map < G4double , std::vector < E_isoAng* >* >* >::iterator it = incoherentFSs->begin() ; it != incoherentFSs->end() ; it++ )
      {
         std::map < G4double , std::vector < E_isoAng* >* >::iterator itt;
         for ( itt = it->second->begin() ; itt != it->second->end() ; itt++ )
         {
            std::vector< E_isoAng* >::iterator ittt;
            for ( ittt = itt->second->begin(); ittt != itt->second->end() ; ittt++ )
            {
               delete *ittt;
            }
            delete itt->second;
         }
         delete it->second;
      }
   }
   
   if ( coherentFSs != nullptr ) {
      for ( std::map < G4int , std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* >::iterator it = coherentFSs->begin() ; it != coherentFSs->end() ; it++ )
      {
         std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >::iterator itt;
         for ( itt = it->second->begin() ; itt != it->second->end() ; itt++ )
         {
            std::vector < std::pair< G4double , G4double >* >::iterator ittt;
            for ( ittt = itt->second->begin(); ittt != itt->second->end() ; ittt++ )
            {
               delete *ittt;
            }
            delete itt->second;
         }
         delete it->second;
      }
   }
   
   if ( inelasticFSs != nullptr ) {
      for ( std::map < G4int ,  std::map < G4double , std::vector < E_P_E_isoAng* >* >* >::iterator it = inelasticFSs->begin() ; it != inelasticFSs->end() ; it++ )
      {
         std::map < G4double , std::vector < E_P_E_isoAng* >* >::iterator itt;
         for ( itt = it->second->begin() ; itt != it->second->end() ; itt++ )
         {
            std::vector < E_P_E_isoAng* >::iterator ittt;
            for ( ittt = itt->second->begin(); ittt != itt->second->end() ; ittt++ )
            {
               std::vector < E_isoAng* >::iterator it4;
               for ( it4 = (*ittt)->vE_isoAngle.begin() ; it4 != (*ittt)->vE_isoAngle.end() ; it4++ )
               {
                  delete *it4;
               }
               delete *ittt;
            }
            delete itt->second;
         }
         delete it->second;
      }
   }
   
   incoherentFSs = nullptr;
   coherentFSs = nullptr;
   inelasticFSs = nullptr;
}

References coherentFSs, incoherentFSs, inelasticFSs, and anonymous_namespace{G4QuasiElRatios.cc}::map.

Referenced by buildPhysicsTable().

create_E_isoAng_from_energy()

E_isoAng G4ParticleHPThermalScattering::create_E_isoAng_from_energy ( G4double  energy, std::vector< E_isoAng * > *  vEPM  )

private

Definition at line 900 of file G4ParticleHPThermalScattering.cc.

{
   E_isoAng anEPM_T_E;
   std::vector<E_isoAng*>::iterator iv;
 
   std::vector<G4double> v_e;
   v_e.clear();
   for (iv = vEPM->begin(); iv != vEPM->end(); iv++) 
     v_e.push_back( (*iv)->energy );
 
   std::pair<G4double, G4double> energyLH = find_LH(energy, &v_e);
   //G4cout << " " << energy/eV << " " << energyLH.first/eV  << " " << energyLH.second/eV << G4endl;
 
   E_isoAng* panEPM_T_EL = 0;
   E_isoAng* panEPM_T_EH = 0;
 
   if (energyLH.first != 0.0 && energyLH.second != 0.0) {
     for (iv = vEPM->begin(); iv != vEPM->end(); iv++) {
       if (energyLH.first == (*iv)->energy) {
         panEPM_T_EL = *iv;
         iv++;
         panEPM_T_EH = *iv;
         break;
       }
     } 
 
   } else if (energyLH.first == 0.0) {
     panEPM_T_EL = (*vEPM)[0];
     panEPM_T_EH = (*vEPM)[1];
 
   } else if (energyLH.second == 0.0) {
     panEPM_T_EH = (*vEPM).back();
     iv = vEPM->end();
     iv--; 
     iv--; 
     panEPM_T_EL = *iv;
   } 
 
   if (panEPM_T_EL != 0 && panEPM_T_EH != 0) {
     //checking isoAng has proper values or not 
     // Inelastic/FS, the first and last entries of *vEPM has all zero values.
     if ( !(check_E_isoAng(panEPM_T_EL) ) ) panEPM_T_EL = panEPM_T_EH;
     if ( !(check_E_isoAng(panEPM_T_EH) ) ) panEPM_T_EH = panEPM_T_EL;
 
     if (panEPM_T_EL->n == panEPM_T_EH->n) {
       anEPM_T_E.energy = energy; 
       anEPM_T_E.n = panEPM_T_EL->n; 
 
       for (G4int i=0; i < panEPM_T_EL->n; i++) { 
         G4double angle;
         angle = get_linear_interpolated(energy, std::pair<G4double,G4double>(energyLH.first, panEPM_T_EL->isoAngle[i] ),
                                         std::pair<G4double,G4double>(energyLH.second, panEPM_T_EH->isoAngle[i] ) );  
         anEPM_T_E.isoAngle.push_back(angle); 
       }
 
     } else {
       G4Exception("G4ParticleHPThermalScattering::create_E_isoAng_from_energy",
                   "NotSupported", JustWarning,
                   "G4ParticleHPThermalScattering does not support yet EL->n != EH->n."); 
     }
 
   } else {
     G4Exception("G4ParticleHPThermalScattering::create_E_isoAng_from_energy",
                 "HAD_THERM_000", FatalException,
                 "Pointer panEPM_T_EL or panEPM_T_EH is zero");
   }
 
   return anEPM_T_E;
}

References angle, check_E_isoAng(), G4INCL::KinematicsUtils::energy(), E_isoAng::energy, FatalException, find_LH(), G4Exception(), get_linear_interpolated(), E_isoAng::isoAngle, JustWarning, and E_isoAng::n.

Referenced by ApplyYourself(), and create_sE_and_EPM_from_pE_and_vE_P_E_isoAng().

create_sE_and_EPM_from_pE_and_vE_P_E_isoAng()

std::pair< G4double, E_isoAng > G4ParticleHPThermalScattering::create_sE_and_EPM_from_pE_and_vE_P_E_isoAng ( G4double  rand_for_sE, G4double  pE, std::vector< E_P_E_isoAng * > *  vNEP_EPM  )

private

Definition at line 1016 of file G4ParticleHPThermalScattering.cc.

{
   std::map< G4double , G4int > map_energy;
   map_energy.clear();
   std::vector< G4double > v_energy;
   v_energy.clear();
   std::vector< E_P_E_isoAng* >::iterator itv;
   G4int i = 0;
   for ( itv = vNEP_EPM->begin(); itv != vNEP_EPM->end(); itv++ )
   {
      v_energy.push_back( (*itv)->energy );
      map_energy.insert( std::pair < G4double , G4int > ( (*itv)->energy , i ) );
      i++;
   } 
      
   std::pair < G4double , G4double > energyLH = find_LH ( pE , &v_energy );
 
   E_P_E_isoAng* pE_P_E_isoAng_EL = 0; 
   E_P_E_isoAng* pE_P_E_isoAng_EH = 0; 
 
   if ( energyLH.first != 0.0 && energyLH.second != 0.0 ) 
   {
      pE_P_E_isoAng_EL = (*vNEP_EPM)[ map_energy.find ( energyLH.first )->second ];    
      pE_P_E_isoAng_EH = (*vNEP_EPM)[ map_energy.find ( energyLH.second )->second ];    
   }
   else if ( energyLH.first == 0.0 ) 
   {
      pE_P_E_isoAng_EL = (*vNEP_EPM)[ 0 ];    
      pE_P_E_isoAng_EH = (*vNEP_EPM)[ 1 ];    
   }
   if ( energyLH.second == 0.0 ) 
   {
      pE_P_E_isoAng_EH = (*vNEP_EPM).back();    
      itv = vNEP_EPM->end();
      itv--; 
      itv--;
      pE_P_E_isoAng_EL = *itv;    
   }
 
   G4double sE; 
   G4double sE_L; 
   G4double sE_H; 
 
   sE_L = get_secondary_energy_from_E_P_E_isoAng ( rand_for_sE , pE_P_E_isoAng_EL );
   sE_H = get_secondary_energy_from_E_P_E_isoAng ( rand_for_sE , pE_P_E_isoAng_EH );
 
   sE = get_linear_interpolated ( pE , std::pair < G4double , G4double > ( energyLH.first , sE_L ) , std::pair < G4double , G4double > ( energyLH.second , sE_H ) );  
 
    
   E_isoAng E_isoAng_L = create_E_isoAng_from_energy ( sE , &(pE_P_E_isoAng_EL->vE_isoAngle) );
   E_isoAng E_isoAng_H = create_E_isoAng_from_energy ( sE , &(pE_P_E_isoAng_EH->vE_isoAngle) );
 
   E_isoAng anE_isoAng; 
   //For defeating warning message from compiler
   anE_isoAng.n = 1;
   anE_isoAng.energy = sE; //never used 
   if ( E_isoAng_L.n == E_isoAng_H.n ) 
   {
      anE_isoAng.n =  E_isoAng_L.n; 
      for ( G4int j=0 ; j < anE_isoAng.n ; j++ )
      { 
         G4double angle;
         angle = get_linear_interpolated ( sE  , std::pair< G4double , G4double > ( sE_L , E_isoAng_L.isoAngle[ j ] ) , std::pair< G4double , G4double > ( sE_H , E_isoAng_H.isoAngle[ j ] ) );  
         anE_isoAng.isoAngle.push_back( angle ); 
      }
   }
   else
   {
      //G4cout << "Do not Suuport yet." << G4endl; 
      throw G4HadronicException(__FILE__, __LINE__, "Unexpected values!");
   }
         
   return std::pair< G4double , E_isoAng >( sE , anE_isoAng); 
}

References angle, create_E_isoAng_from_energy(), E_isoAng::energy, find_LH(), get_linear_interpolated(), get_secondary_energy_from_E_P_E_isoAng(), E_isoAng::isoAngle, E_isoAng::n, and E_P_E_isoAng::vE_isoAngle.

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().

find_LH()

std::pair< G4double, G4double > G4ParticleHPThermalScattering::find_LH ( G4double  x, std::vector< G4double > *  aVector  )

private

Definition at line 846 of file G4ParticleHPThermalScattering.cc.

{
   G4double LL = 0.0; 
   G4double H = 0.0; 
 
   // v->size() == 1 --> LL=H=v(0)
   if ( aVector->size() == 1 ) {
      LL = aVector->front();
      H = aVector->front();
   } else {
   // 1) temp < v(0) -> LL=0.0 H=v(0)
   // 2) v(i-1) < temp <= v(i) -> LL=v(i-1) H=v(i)
   // 3) v(imax) < temp -> LL=v(imax) H=0.0
      for ( std::vector< G4double >::iterator 
            it = aVector->begin() ; it != aVector->end() ; it++ ) {
         if ( x <= *it ) {
            H = *it;  
            if ( it != aVector->begin() ) {
               // 2)
               it--;
               LL = *it;
            } else {
               // 1)
               LL = 0.0;
            }
            break; 
         } 
      } 
      // 3) 
      if ( H == 0.0 ) LL = aVector->back();
   }
 
   return std::pair < G4double , G4double > ( LL , H ); 
}

References LL.

Referenced by ApplyYourself(), create_E_isoAng_from_energy(), create_sE_and_EPM_from_pE_and_vE_P_E_isoAng(), and sample_inelastic_E_mu().

get_linear_interpolated()

G4double G4ParticleHPThermalScattering::get_linear_interpolated ( G4double  x, std::pair< G4double, G4double >  Low, std::pair< G4double, G4double >  High  )

private

Definition at line 882 of file G4ParticleHPThermalScattering.cc.

{ 
   G4double y=0.0;
   if ( High.first - Low.first != 0 ) {
      y = ( High.second - Low.second ) / ( High.first - Low.first ) * ( x - Low.first ) + Low.second;
   } else { 
      if ( High.second == Low.second ) {
         y = High.second;
      } else { 
         G4cout << "G4ParticleHPThermalScattering liner interpolation err!!" << G4endl; 
      }
   }
      
   return y; 
} 

References G4cout, and G4endl.

Referenced by create_E_isoAng_from_energy(), create_sE_and_EPM_from_pE_and_vE_P_E_isoAng(), and get_secondary_energy_from_E_P_E_isoAng().

get_secondary_energy_from_E_P_E_isoAng()

G4double G4ParticleHPThermalScattering::get_secondary_energy_from_E_P_E_isoAng ( G4double  random, E_P_E_isoAng *  anE_P_E_isoAng  )

private

Definition at line 972 of file G4ParticleHPThermalScattering.cc.

{
   G4double secondary_energy = 0.0;
 
   G4int n = anE_P_E_isoAng->n;
   G4double sum_p = 0.0; // sum_p_H
   G4double sum_p_L = 0.0;
 
   G4double total=0.0;
 
/*
   delete for speed up
   for ( G4int i = 0 ; i < n-1 ; i++ )
   {
      G4double E_L = anE_P_E_isoAng->vE_isoAngle[i]->energy/eV;
      G4double E_H = anE_P_E_isoAng->vE_isoAngle[i+1]->energy/eV;
      G4double dE = E_H - E_L;
      total += ( ( anE_P_E_isoAng->prob[i] ) * dE );
   }
 
   if ( std::abs( total - anE_P_E_isoAng->sum_of_probXdEs ) > 1.0e-14 ) G4cout << total - anE_P_E_isoAng->sum_of_probXdEs << G4endl;
*/
   total =  anE_P_E_isoAng->sum_of_probXdEs;
 
   for ( G4int i = 0 ; i < n-1 ; i++ )
   {
      G4double E_L = anE_P_E_isoAng->vE_isoAngle[i]->energy/eV;
      G4double E_H = anE_P_E_isoAng->vE_isoAngle[i+1]->energy/eV;
      G4double dE = E_H - E_L;
      sum_p += ( ( anE_P_E_isoAng->prob[i] ) * dE );
 
      if ( random <= sum_p/total )
      {
         secondary_energy = get_linear_interpolated ( random , std::pair < G4double , G4double > ( sum_p_L/total , E_L ) , std::pair < G4double , G4double > ( sum_p/total , E_H ) );
         secondary_energy = secondary_energy*eV;  //need eV
         break;
      }
      sum_p_L = sum_p; 
   }
 
   return secondary_energy; 
}

References dE, eV, get_linear_interpolated(), CLHEP::detail::n, E_P_E_isoAng::n, E_P_E_isoAng::prob, E_P_E_isoAng::sum_of_probXdEs, G4INCL::CrossSections::total(), and E_P_E_isoAng::vE_isoAngle.

Referenced by create_sE_and_EPM_from_pE_and_vE_P_E_isoAng().

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 > G4ParticleHPThermalScattering::GetFatalEnergyCheckLevels ( ) const

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 1246 of file G4ParticleHPThermalScattering.cc.

{
   //return std::pair<G4double, G4double>(10*perCent,10*GeV);
   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().

getMu() [1/2]

G4double G4ParticleHPThermalScattering::getMu ( E_isoAng *  anEPM )

private

Definition at line 809 of file G4ParticleHPThermalScattering.cc.

{
 
   G4double random = G4UniformRand();
   G4double result = 0.0;  
 
   G4int in = int ( random * ( (*anEPM).n ) );
 
   if ( in != 0 )
   {
       G4double mu_l = (*anEPM).isoAngle[ in-1 ]; 
       G4double mu_h = (*anEPM).isoAngle[ in ]; 
       result = ( mu_h - mu_l ) * ( random * ( (*anEPM).n ) - in ) + mu_l; 
   }
   else 
   {
       G4double x = random * (*anEPM).n;
       //Bugzilla 1971 
       G4double ratio = 0.5;
       G4double xx = G4UniformRand();
       if ( x <= ratio ) 
       {
          G4double mu_l = -1; 
          G4double mu_h = (*anEPM).isoAngle[ 0 ]; 
          result = ( mu_h - mu_l ) * xx + mu_l; 
       }
       else
       {
          G4double mu_l = (*anEPM).isoAngle[ (*anEPM).n - 1 ]; 
          G4double mu_h = 1;
          result = ( mu_h - mu_l ) * xx + mu_l; 
       }
   }
   return result;
}  

References G4UniformRand.

Referenced by ApplyYourself(), and sample_inelastic_E_mu().

getMu() [2/2]

G4double G4ParticleHPThermalScattering::getMu ( G4double  rndm1, G4double  rndm2, E_isoAng *  anEPM  )

private

Definition at line 771 of file G4ParticleHPThermalScattering.cc.

{
   G4double result = 0.0;
 
   G4int in = int ( rndm1 * ( (*anEPM).n ) );
 
   if ( in != 0 )
   {
      G4double mu_l = (*anEPM).isoAngle[ in-1 ];
      G4double mu_h = (*anEPM).isoAngle[ in ];
      result = ( mu_h - mu_l ) * ( rndm1*((*anEPM).n) - in ) + mu_l;
   }
   else
   {
      G4double x = rndm1 * (*anEPM).n;
      G4double ratio = 0.5;
      if ( x <= ratio )
      {
          G4double mu_l = -1;
          G4double mu_h = (*anEPM).isoAngle[ 0 ];
          result = ( mu_h - mu_l ) * rndm2 + mu_l;
      }
      else
      {
          G4double mu_l = (*anEPM).isoAngle[ (*anEPM).n - 1 ]; 
          G4double mu_h = 1;
          result = ( mu_h - mu_l ) * rndm2 + mu_l;
      }
   }
 
   return result;
}

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().

getTS_ID()

G4int G4ParticleHPThermalScattering::getTS_ID ( const G4Material *  material, const G4Element *  element  )

private

Definition at line 1237 of file G4ParticleHPThermalScattering.cc.

{
   G4int result = -1;
   if ( dic.find( std::pair < const G4Material* , const G4Element* > ( material , element ) ) != dic.end() ) 
      result = dic.find( std::pair < const G4Material* , const G4Element* > ( material , element ) )->second; 
   return result; 
}

References dic, and eplot::material.

Referenced by ApplyYourself().

GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const

inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

  { return verboseLevel; }

References G4HadronicInteraction::verboseLevel.

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 G4ParticleHPThermalScattering::ModelDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 1276 of file G4ParticleHPThermalScattering.cc.

{
   outFile << "High Precision model based on thermal scattering data in\n"
           << "evaluated nuclear data libraries for neutrons below 5eV\n"
           << "on specific materials\n";
}

operator!=()

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

deleteinherited

operator==()

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

deleteinherited

readACoherentFSDATA()

std::map< G4double, std::vector< std::pair< G4double, G4double > * > * > * G4ParticleHPThermalScattering::readACoherentFSDATA ( G4String  name )

private

Definition at line 148 of file G4ParticleHPThermalScattering.cc.

{
 
   std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* aCoherentFSDATA = new std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >;
 
   //std::ifstream theChannel( name.c_str() );
   std::istringstream theChannel(std::ios::in);
   G4ParticleHPManager::GetInstance()->GetDataStream(name,theChannel);
 
   std::vector< G4double > vBraggE;
 
   G4int dummy; 
   while ( theChannel >> dummy )   // MF // Loop checking, 11.05.2015, T. Koi
   {
      theChannel >> dummy;   // MT
      G4double temp; 
      theChannel >> temp;   
      std::vector < std::pair< G4double , G4double >* >* anBragE_P = new std::vector < std::pair< G4double , G4double >* >;
     
      G4int n; 
      theChannel >> n;   
      for ( G4int i = 0 ; i < n ; i++ )
      {
          G4double Ei; 
          G4double Pi;
          if ( aCoherentFSDATA->size() == 0 ) 
          {
             theChannel >> Ei;
             vBraggE.push_back( Ei );
          } 
          else 
          {
             Ei = vBraggE[ i ]; 
          } 
          theChannel >> Pi;   
          anBragE_P->push_back ( new std::pair < G4double , G4double > ( Ei , Pi ) );
          //G4cout << "Coherent Elastic " << Ei << " " << Pi << G4endl;   
      }
      aCoherentFSDATA->insert ( std::pair < G4double , std::vector < std::pair< G4double , G4double >* >*  > ( temp , anBragE_P ) );
   }
 
   return aCoherentFSDATA;
}

References G4ParticleHPManager::GetDataStream(), G4ParticleHPManager::GetInstance(), CLHEP::detail::n, and G4InuclParticleNames::name().

Referenced by buildPhysicsTable().

readAnE_isoAng()

E_isoAng * G4ParticleHPThermalScattering::readAnE_isoAng ( std::istream *  file )

private

Definition at line 313 of file G4ParticleHPThermalScattering.cc.

{
   E_isoAng* aData = new E_isoAng;
 
   G4double dummy;
   G4double energy;
   G4int n;
   *file >> dummy;
   *file >> energy;
   *file >> dummy;
   *file >> dummy;
   *file >> n;
   *file >> dummy;
   aData->energy = energy*eV;
   aData->n = n-2;
   aData->isoAngle.resize( n );
 
   *file >> dummy;
   *file >> dummy;
   for ( G4int i = 0 ; i < aData->n ; i++ )
      *file >> aData->isoAngle[i];
 
   return aData;
}

References G4INCL::KinematicsUtils::energy(), E_isoAng::energy, eV, geant4_check_module_cycles::file, E_isoAng::isoAngle, CLHEP::detail::n, and E_isoAng::n.

Referenced by readAnIncoherentFSDATA().

readAnE_P_E_isoAng()

E_P_E_isoAng * G4ParticleHPThermalScattering::readAnE_P_E_isoAng ( std::istream *  file )

private

Definition at line 222 of file G4ParticleHPThermalScattering.cc.

{
   E_P_E_isoAng* aData = new E_P_E_isoAng;
 
   G4double dummy;
   G4double energy;
   G4int nep , nl;
   *file >> dummy;
   *file >> energy;
   aData->energy = energy*eV;
   *file >> dummy;
   *file >> dummy;
   *file >> nep;
   *file >> nl;
   aData->n = nep/nl;
   for ( G4int i = 0 ; i < aData->n ; i++ )
   {
      G4double prob;
      E_isoAng* anE_isoAng = new E_isoAng;
      aData->vE_isoAngle.push_back( anE_isoAng );
      *file >> energy;
      anE_isoAng->energy = energy*eV; 
      anE_isoAng->n = nl - 2;  
      anE_isoAng->isoAngle.resize( anE_isoAng->n ); 
      *file >> prob;
      aData->prob.push_back( prob );
      //G4cout << "G4ParticleHPThermalScattering inelastic " << energy/eV << " " <<  i << " " << prob << " " << aData->prob[ i ] << G4endl; 
      for ( G4int j = 0 ; j < anE_isoAng->n ; j++ )
      {
         G4double x;
         *file >> x;
         anE_isoAng->isoAngle[j] = x ;
         //G4cout << "G4ParticleHPThermalScattering inelastic " << x << anE_isoAng->isoAngle[j] << G4endl; 
      }
   } 
 
   // Calcuate sum_of_provXdEs
   G4double total = 0;  
   aData->secondary_energy_cdf.push_back(0.);
   for ( G4int i = 0 ; i < aData->n - 1 ; i++ )
   {
      G4double E_L = aData->vE_isoAngle[i]->energy/eV;
      G4double E_H = aData->vE_isoAngle[i+1]->energy/eV;
      G4double dE = E_H - E_L;
      G4double pdf = (aData->prob[i] + aData->prob[i+1] )/2. * dE;
      total += ( pdf );
      aData->secondary_energy_cdf.push_back( total );
      aData->secondary_energy_pdf.push_back( pdf );
      aData->secondary_energy_value.push_back( E_L );
   }
 
   aData->sum_of_probXdEs = total;
 
   // Normalize CDF
   aData->secondary_energy_cdf_size = (G4int)aData->secondary_energy_cdf.size();
   for ( G4int i = 0; i < aData->secondary_energy_cdf_size; ++i )
   {
      aData->secondary_energy_cdf[i] /=  total;
   }
 
   return aData;
}

References dE, G4INCL::KinematicsUtils::energy(), E_isoAng::energy, E_P_E_isoAng::energy, eV, geant4_check_module_cycles::file, E_isoAng::isoAngle, E_isoAng::n, E_P_E_isoAng::n, E_P_E_isoAng::prob, E_P_E_isoAng::secondary_energy_cdf, E_P_E_isoAng::secondary_energy_cdf_size, E_P_E_isoAng::secondary_energy_pdf, E_P_E_isoAng::secondary_energy_value, E_P_E_isoAng::sum_of_probXdEs, G4INCL::CrossSections::total(), and E_P_E_isoAng::vE_isoAngle.

Referenced by readAnInelasticFSDATA().

readAnIncoherentFSDATA()

std::map< G4double, std::vector< E_isoAng * > * > * G4ParticleHPThermalScattering::readAnIncoherentFSDATA ( G4String  name )

private

Definition at line 286 of file G4ParticleHPThermalScattering.cc.

{
   std::map < G4double , std::vector < E_isoAng* >* >* T_E = new std::map < G4double , std::vector < E_isoAng* >* >;
 
   //std::ifstream theChannel( name.c_str() );
   std::istringstream theChannel(std::ios::in);
   G4ParticleHPManager::GetInstance()->GetDataStream(name,theChannel);
 
   G4int dummy; 
   while ( theChannel >> dummy )   // MF // Loop checking, 11.05.2015, T. Koi
   {
      theChannel >> dummy;   // MT
      G4double temp; 
      theChannel >> temp;   
      std::vector < E_isoAng* >* vE_isoAng = new std::vector < E_isoAng* >;
      G4int n;
      theChannel >> n;   
      for ( G4int i = 0 ; i < n ; i++ )
        vE_isoAng->push_back ( readAnE_isoAng( &theChannel ) );
      T_E->insert ( std::pair < G4double , std::vector < E_isoAng* >* > ( temp , vE_isoAng ) );
   }
   //theChannel.close();
 
   return T_E;
}

References G4ParticleHPManager::GetDataStream(), G4ParticleHPManager::GetInstance(), CLHEP::detail::n, G4InuclParticleNames::name(), and readAnE_isoAng().

Referenced by buildPhysicsTable().

readAnInelasticFSDATA()

std::map< G4double, std::vector< E_P_E_isoAng * > * > * G4ParticleHPThermalScattering::readAnInelasticFSDATA ( G4String  name )

private

Definition at line 193 of file G4ParticleHPThermalScattering.cc.

{
   std::map < G4double , std::vector < E_P_E_isoAng* >* >* anT_E_P_E_isoAng = new std::map < G4double , std::vector < E_P_E_isoAng* >* >;
 
   //std::ifstream theChannel( name.c_str() );
   std::istringstream theChannel(std::ios::in);
   G4ParticleHPManager::GetInstance()->GetDataStream(name,theChannel);
 
   G4int dummy; 
   while ( theChannel >> dummy )   // MF // Loop checking, 11.05.2015, T. Koi
   {
      theChannel >> dummy;   // MT
      G4double temp; 
      theChannel >> temp;   
      std::vector < E_P_E_isoAng* >* vE_P_E_isoAng = new std::vector < E_P_E_isoAng* >;
      G4int n;
      theChannel >> n;   
      for ( G4int i = 0 ; i < n ; i++ )
      {
          vE_P_E_isoAng->push_back ( readAnE_P_E_isoAng ( &theChannel ) );
      }
      anT_E_P_E_isoAng->insert ( std::pair < G4double , std::vector < E_P_E_isoAng* >* > ( temp , vE_P_E_isoAng ) );
   }    
   //theChannel.close();
 
   return anT_E_P_E_isoAng; 
}

References G4ParticleHPManager::GetDataStream(), G4ParticleHPManager::GetInstance(), CLHEP::detail::n, G4InuclParticleNames::name(), and readAnE_P_E_isoAng().

Referenced by buildPhysicsTable().

sample_inelastic_E()

std::pair< G4double, G4int > G4ParticleHPThermalScattering::sample_inelastic_E ( G4double  rndm1, G4double  rndm2, E_P_E_isoAng *  anE_P_E_isoAng  )

private

Definition at line 649 of file G4ParticleHPThermalScattering.cc.

{
   G4int i=0;
   G4double sE_value=0;
 
   for ( ; i < anE_P_E_isoAng->secondary_energy_cdf_size-1 ; ++i ) 
   {
      if ( rndm1 >= anE_P_E_isoAng->secondary_energy_cdf[i]  && 
           rndm1 < anE_P_E_isoAng->secondary_energy_cdf[i+1] )
      {
         G4double sE_value_i  = anE_P_E_isoAng->secondary_energy_value[i];
         G4double sE_pdf_i    = anE_P_E_isoAng->secondary_energy_pdf[i];
         G4double sE_value_i1 = anE_P_E_isoAng->secondary_energy_value[i+1];
         G4double sE_pdf_i1   = anE_P_E_isoAng->secondary_energy_pdf[i+1];
 
     G4double lambda = 0;
     G4double alpha = (sE_pdf_i1 - sE_pdf_i) / (sE_pdf_i1 + sE_pdf_i);
     G4double rndm = rndm1;
            
     if ( std::fabs(alpha) < 1E-8 )
         {
        lambda = rndm2;
     }
     else
         {
        G4double beta = 2 * sE_pdf_i / (sE_pdf_i1 + sE_pdf_i);
        rndm = rndm2;
            G4double gamma = -rndm;
            G4double delta = beta*beta - 4*alpha*gamma;
 
            if ( delta < 0 && std::fabs(delta) < 1.E-8 ) delta = 0;
    
            lambda = -beta + std::sqrt(delta);
            lambda = lambda/(2 * alpha);
 
            if      ( lambda > 1 ) lambda = 1;
            else if ( lambda < 0 ) lambda = 0;
     }
 
         sE_value = sE_value_i + lambda * (sE_value_i1 - sE_value_i);
 
     break;
      }
   }
 
   return std::pair< G4double , G4int >( sE_value , i );
}

References alpha, anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4InuclParticleNames::lambda, E_P_E_isoAng::secondary_energy_cdf, E_P_E_isoAng::secondary_energy_cdf_size, E_P_E_isoAng::secondary_energy_pdf, and E_P_E_isoAng::secondary_energy_value.

Referenced by sample_inelastic_E_mu().

sample_inelastic_E_mu()

std::pair< G4double, G4double > G4ParticleHPThermalScattering::sample_inelastic_E_mu ( G4double  pE, std::vector< E_P_E_isoAng * > *  vNEP_EPM  )

private

Definition at line 702 of file G4ParticleHPThermalScattering.cc.

{
   // Sample primary energy bin
   std::map< G4double , G4int > map_energy;
   map_energy.clear();
   std::vector< G4double > v_energy;
   v_energy.clear();
   std::vector< E_P_E_isoAng* >::iterator itv;
   G4int i = 0;
   for ( itv = vNEP_EPM->begin(); itv != vNEP_EPM->end(); ++itv )
   {
      v_energy.push_back( (*itv)->energy );
      map_energy.insert( std::pair< G4double , G4int >( (*itv)->energy , i ) );
      i++;
   }
 
   std::pair< G4double , G4double > energyLH = find_LH( pE , &v_energy );
 
   std::vector< E_P_E_isoAng* > pE_P_E_isoAng_limit(2, nullptr);
 
   if ( energyLH.first != 0.0 && energyLH.second != 0.0 )
   {
      pE_P_E_isoAng_limit[0] = (*vNEP_EPM)[ map_energy.find ( energyLH.first )->second ];
      pE_P_E_isoAng_limit[1] = (*vNEP_EPM)[ map_energy.find ( energyLH.second )->second ];
   }
   else if ( energyLH.first == 0.0 )
   {
      pE_P_E_isoAng_limit[0] = (*vNEP_EPM)[ 0 ];
      pE_P_E_isoAng_limit[1] = (*vNEP_EPM)[ 1 ];
   }
   if ( energyLH.second == 0.0 )
   {
      pE_P_E_isoAng_limit[1] = (*vNEP_EPM).back();
      itv = vNEP_EPM->end();
      itv--;
      itv--;
      pE_P_E_isoAng_limit[0] = *itv;
   }
 
   // Compute interpolation factor of the incident neutron energy   
   G4double factor = (energyLH.second - pE) / (energyLH.second - energyLH.first);
 
   if ( (energyLH.second - pE) <= 0. && std::fabs(pE/energyLH.second - 1) < 1E-11 ) factor = 0.;
   if ( (energyLH.first - pE) >= 0. && std::fabs(energyLH.first / pE - 1) < 1E-11 ) factor = 1.;
 
   G4double rndm1 = G4UniformRand();
   G4double rndm2 = G4UniformRand();
 
   // Sample secondary neutron energy
   std::pair< G4double , G4int > sE_lower = sample_inelastic_E( rndm1, rndm2, pE_P_E_isoAng_limit[0] );
   std::pair< G4double , G4int > sE_upper = sample_inelastic_E( rndm1, rndm2, pE_P_E_isoAng_limit[1] );
   G4double sE = factor * sE_lower.first + (1 - factor) * sE_upper.first;
   sE = sE * eV;
    
   // Sample cosine knowing the secondary neutron energy
   rndm1 = G4UniformRand();
   rndm2 = G4UniformRand();
   G4double mu_lower = getMu( rndm1, rndm2, pE_P_E_isoAng_limit[0]->vE_isoAngle[sE_lower.second] );
   G4double mu_upper = getMu( rndm1, rndm2, pE_P_E_isoAng_limit[1]->vE_isoAngle[sE_upper.second] );
   G4double mu = factor * mu_lower + (1 - factor) * mu_upper;
 
   return std::pair< G4double , G4double >( sE , mu );
}

References eV, find_LH(), G4UniformRand, getMu(), and sample_inelastic_E().

Referenced by ApplyYourself().

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::G4ParticleHPInelastic(), 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::G4ParticleHPInelastic(), 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 G4HadronicInteraction::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 112 of file G4HadronicInteraction.hh.

  { verboseLevel = value; }

References G4HadronicInteraction::verboseLevel.

Referenced by G4CascadeInterface::SetVerboseLevel(), and G4PreCompoundDeexcitation::setVerboseLevel().

Field Documentation

coherentFSs

std::map< G4int , std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* >* G4ParticleHPThermalScattering::coherentFSs

private

Definition at line 109 of file G4ParticleHPThermalScattering.hh.

Referenced by ApplyYourself(), buildPhysicsTable(), and clearCurrentFSData().

dic

std::map< std::pair < const G4Material* , const G4Element* > , G4int > G4ParticleHPThermalScattering::dic

private

Definition at line 143 of file G4ParticleHPThermalScattering.hh.

Referenced by buildPhysicsTable(), and getTS_ID().

epCheckLevels

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

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

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

incoherentFSs

std::map< G4int , std::map < G4double , std::vector < E_isoAng* >* >* >* G4ParticleHPThermalScattering::incoherentFSs

private

Definition at line 114 of file G4ParticleHPThermalScattering.hh.

Referenced by ApplyYourself(), buildPhysicsTable(), and clearCurrentFSData().

inelasticFSs

std::map< G4int , std::map < G4double , std::vector < E_P_E_isoAng* >* >* >* G4ParticleHPThermalScattering::inelasticFSs

private

Definition at line 120 of file G4ParticleHPThermalScattering.hh.

Referenced by ApplyYourself(), buildPhysicsTable(), and clearCurrentFSData().

isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

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

names

G4ParticleHPThermalScatteringNames G4ParticleHPThermalScattering::names

private

Definition at line 105 of file G4ParticleHPThermalScattering.hh.

Referenced by AddUserThermalScatteringFile(), and buildPhysicsTable().

nElement

size_t G4ParticleHPThermalScattering::nElement

private

Definition at line 153 of file G4ParticleHPThermalScattering.hh.

Referenced by buildPhysicsTable(), and G4ParticleHPThermalScattering().

nMaterial

size_t G4ParticleHPThermalScattering::nMaterial

private

Definition at line 152 of file G4ParticleHPThermalScattering.hh.

Referenced by buildPhysicsTable(), and G4ParticleHPThermalScattering().

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().

theHPElastic

G4ParticleHPElastic* G4ParticleHPThermalScattering::theHPElastic

private

Definition at line 126 of file G4ParticleHPThermalScattering.hh.

Referenced by ApplyYourself(), BuildPhysicsTable(), G4ParticleHPThermalScattering(), and ~G4ParticleHPThermalScattering().

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(), 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().

theXSection

G4ParticleHPThermalScatteringData* G4ParticleHPThermalScattering::theXSection

private

Definition at line 124 of file G4ParticleHPThermalScattering.hh.

Referenced by AddUserThermalScatteringFile(), ApplyYourself(), buildPhysicsTable(), and G4ParticleHPThermalScattering().

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/G4ParticleHPThermalScattering.hh
• source/processes/hadronic/models/particle_hp/src/G4ParticleHPThermalScattering.cc