G4NeutronHPThermalScatteringData Class Reference

#include <G4NeutronHPThermalScatteringData.hh>

Inheritance diagram for G4NeutronHPThermalScatteringData:

Public Member Functions
	G4NeutronHPThermalScatteringData ()
	~G4NeutronHPThermalScatteringData ()
G4bool	IsIsoApplicable (const G4DynamicParticle *, G4int, G4int, const G4Element *, const G4Material *)
G4double	GetIsoCrossSection (const G4DynamicParticle *, G4int, G4int, const G4Isotope *, const G4Element *, const G4Material *)
G4bool	IsApplicable (const G4DynamicParticle *, const G4Element *)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetInelasticCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetCoherentCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetIncoherentCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DumpPhysicsTable (const G4ParticleDefinition &)
void	AddUserThermalScatteringFile (G4String, G4String)
Public Member Functions inherited from G4VCrossSectionDataSet
	G4VCrossSectionDataSet (const G4String &nam="")
virtual	~G4VCrossSectionDataSet ()
virtual G4bool	IsElementApplicable (const G4DynamicParticle *, G4int Z, const G4Material *mat=0)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=0)
G4double	ComputeCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=0)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat=0)
virtual G4Isotope *	SelectIsotope (const G4Element *, G4double kinEnergy)
virtual void	CrossSectionDescription (std::ostream &) const
virtual G4int	GetVerboseLevel () const
virtual void	SetVerboseLevel (G4int value)
G4double	GetMinKinEnergy () const
void	SetMinKinEnergy (G4double value)
G4double	GetMaxKinEnergy () const
void	SetMaxKinEnergy (G4double value)
const G4String &	GetName () const

Additional Inherited Members
Protected Member Functions inherited from G4VCrossSectionDataSet
void	SetName (const G4String &)
Protected Attributes inherited from G4VCrossSectionDataSet
G4int	verboseLevel

Detailed Description

Definition at line 58 of file G4NeutronHPThermalScatteringData.hh.

Constructor & Destructor Documentation

G4NeutronHPThermalScatteringData::G4NeutronHPThermalScatteringData

(

)

Definition at line 53 of file G4NeutronHPThermalScatteringData.cc.

References python.hepunit::eV, python.hepunit::MeV, G4VCrossSectionDataSet::SetMaxKinEnergy(), and G4VCrossSectionDataSet::SetMinKinEnergy().

:G4VCrossSectionDataSet("NeutronHPThermalScatteringData")
{
// Upper limit of neutron energy 
   emax = 4*eV;
   SetMinKinEnergy( 0*MeV );                                   
   SetMaxKinEnergy( emax );                                   

   ke_cache = 0.0;
   xs_cache = 0.0;
   element_cache = NULL;
   material_cache = NULL;

   indexOfThermalElement.clear(); 

   names = new G4NeutronHPThermalScatteringNames();

   //BuildPhysicsTable( *G4Neutron::Neutron() );
}

G4NeutronHPThermalScatteringData::~G4NeutronHPThermalScatteringData

(

)

Definition at line 73 of file G4NeutronHPThermalScatteringData.cc.

{

   clearCurrentXSData();

   delete names;
}

Member Function Documentation

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

Definition at line 536 of file G4NeutronHPThermalScatteringData.cc.

References G4NeutronHPThermalScatteringNames::AddThermalElement().

Referenced by G4NeutronHPThermalScattering::AddUserThermalScatteringFile().

{
   names->AddThermalElement( nameG4Element , filename );
}

void G4NeutronHPThermalScatteringData::BuildPhysicsTable ( const G4ParticleDefinition &  aP )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 206 of file G4NeutronHPThermalScatteringData.cc.

References G4String::first(), G4cout, G4endl, G4ThreadLocal, G4Material::GetElement(), G4Element::GetElementTable(), G4Material::GetMaterialTable(), G4Element::GetName(), G4Material::GetName(), G4Element::GetNumberOfElements(), G4Material::GetNumberOfElements(), G4Material::GetNumberOfMaterials(), G4NeutronHPThermalScatteringNames::GetTS_NDL_Name(), G4NeutronHPThermalScatteringNames::IsThisThermalElement(), eplot::material, G4Neutron::Neutron(), and python.hepunit::second.

Referenced by G4NeutronHPThermalScattering::ApplyYourself(), and G4NeutronHPThermalScattering::G4NeutronHPThermalScattering().

{

   if ( &aP != G4Neutron::Neutron() ) 
      throw G4HadronicException(__FILE__, __LINE__, "Attempt to use NeutronHP data for particles other than neutrons!!!");  

   //std::map < std::pair < G4Material* , const G4Element* > , G4int > dic;   
   dic.clear();   
   clearCurrentXSData();
   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 Data : 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*)NULL , element ) ,  ts_ID_of_this_geometry ) );
         }
      }
   }

   G4cout << G4endl;
   G4cout << "Neutron HP Thermal Scattering Data: Following material-element pairs and/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 != NULL ) 
      {
         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;


   //G4cout << "Neutron HP Thermal Scattering Data: Following NDL thermal scattering files are assigned to the internal thermal scattering id." << G4endl;
   //for ( std::map < G4String , G4int >::iterator it = co_dic.begin() ; it != co_dic.end() ; it++ )  
   //{
   //   G4cout << "NDL file name " << it->first << ", internal thermal scattering id " << it->second << G4endl;
   //}


   // Read Cross Section Data files

   G4String dirName;
   if ( !getenv( "G4NEUTRONHPDATA" ) ) 
      throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
   G4String baseName = getenv( "G4NEUTRONHPDATA" );

   dirName = baseName + "/ThermalScattering";

   G4String ndl_filename;
   G4String full_name;

   for ( std::map < G4String , G4int >::iterator it = co_dic.begin() ; it != co_dic.end() ; it++ )  
   {
      ndl_filename = it->first;
      G4int ts_ID = it->second;

      // Coherent
      full_name = dirName + "/Coherent/CrossSection/" + ndl_filename; 
      std::map< G4double , G4NeutronHPVector* >*  coh_amapTemp_EnergyCross = readData( full_name );
      coherent.insert ( std::pair < G4int , std::map< G4double , G4NeutronHPVector* >* > ( ts_ID , coh_amapTemp_EnergyCross ) );

      // Incoherent
      full_name = dirName + "/Incoherent/CrossSection/" + ndl_filename; 
      std::map< G4double , G4NeutronHPVector* >*  incoh_amapTemp_EnergyCross = readData( full_name );
      incoherent.insert ( std::pair < G4int , std::map< G4double , G4NeutronHPVector* >* > ( ts_ID , incoh_amapTemp_EnergyCross ) );

      // Inelastic
      full_name = dirName + "/Inelastic/CrossSection/" + ndl_filename; 
      std::map< G4double , G4NeutronHPVector* >*  inela_amapTemp_EnergyCross = readData( full_name );
      inelastic.insert ( std::pair < G4int , std::map< G4double , G4NeutronHPVector* >* > ( ts_ID , inela_amapTemp_EnergyCross ) );

   }

}

void G4NeutronHPThermalScatteringData::DumpPhysicsTable ( const G4ParticleDefinition &  aP )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 374 of file G4NeutronHPThermalScatteringData.cc.

References G4Neutron::Neutron().

{
   if( &aP != G4Neutron::Neutron() ) 
     throw G4HadronicException(__FILE__, __LINE__, "Attempt to use NeutronHP data for particles other than neutrons!!!");  
//  G4cout << "G4NeutronHPThermalScatteringData::DumpPhysicsTable still to be implemented"<<G4endl;
}

G4double G4NeutronHPThermalScatteringData::GetCoherentCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM
	)

Definition at line 454 of file G4NeutronHPThermalScatteringData.cc.

References G4Material::GetTemperature().

Referenced by G4NeutronHPThermalScattering::ApplyYourself().

{
   G4double result = 0;
   G4int ts_id = getTS_ID( aM , anE );
   G4double aT = aM->GetTemperature();
   result = GetX ( aP , aT , coherent.find( ts_id )->second );
   return result;
}

G4double G4NeutronHPThermalScatteringData::GetCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM
	)

Definition at line 423 of file G4NeutronHPThermalScatteringData.cc.

References G4Material::GetTemperature().

Referenced by G4NeutronHPThermalScattering::ApplyYourself(), and GetIsoCrossSection().

{
   G4double result = 0;
   
   G4int ts_id =getTS_ID( aM , anE );

   if ( ts_id == -1 ) return result;

   G4double aT = aM->GetTemperature();

   G4double Xcoh = GetX ( aP , aT , coherent.find(ts_id)->second );
   G4double Xincoh = GetX ( aP , aT , incoherent.find(ts_id)->second );
   G4double Xinela = GetX ( aP , aT , inelastic.find(ts_id)->second );

   result = Xcoh + Xincoh + Xinela;

   //G4cout << "G4NeutronHPThermalScatteringData::GetCrossSection  Tot= " << result/barn << " Coherent= " << Xcoh/barn << " Incoherent= " << Xincoh/barn << " Inelastic= " << Xinela/barn << G4endl;

   return result;
}

G4double G4NeutronHPThermalScatteringData::GetIncoherentCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM
	)

Definition at line 463 of file G4NeutronHPThermalScatteringData.cc.

References G4Material::GetTemperature().

{
   G4double result = 0;
   G4int ts_id = getTS_ID( aM , anE );
   G4double aT = aM->GetTemperature();
   result = GetX ( aP , aT , incoherent.find( ts_id )->second );
   return result;
}

G4double G4NeutronHPThermalScatteringData::GetInelasticCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM
	)

Definition at line 445 of file G4NeutronHPThermalScatteringData.cc.

References G4Material::GetTemperature().

Referenced by G4NeutronHPThermalScattering::ApplyYourself().

{
   G4double result = 0;
   G4int ts_id = getTS_ID( aM , anE );
   G4double aT = aM->GetTemperature();
   result = GetX ( aP , aT , inelastic.find( ts_id )->second );
   return result;
}

G4double G4NeutronHPThermalScatteringData::GetIsoCrossSection ( const G4DynamicParticle *  dp, G4int  , G4int  , const G4Isotope *  , const G4Element *  element, const G4Material *  material  )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 106 of file G4NeutronHPThermalScatteringData.cc.

References GetCrossSection(), G4DynamicParticle::GetKineticEnergy(), and eplot::material.

{
   if ( dp->GetKineticEnergy() == ke_cache && element == element_cache &&  material == material_cache ) return xs_cache;

   ke_cache = dp->GetKineticEnergy();
   element_cache = element;
   material_cache = material;
   //G4double xs = GetCrossSection( dp , element , material->GetTemperature() );
   G4double xs = GetCrossSection( dp , element , material );
   xs_cache = xs;
   return xs;
   //return GetCrossSection( dp , element , material->GetTemperature() );
}

G4bool G4NeutronHPThermalScatteringData::IsApplicable	(	const G4DynamicParticle *	aP,
		const G4Element *	anEle
	)

Definition at line 173 of file G4NeutronHPThermalScatteringData.cc.

References G4DynamicParticle::GetDefinition(), G4Element::GetIndex(), G4DynamicParticle::GetKineticEnergy(), and G4Neutron::Neutron().

{
   G4bool result = false;

   G4double eKin = aP->GetKineticEnergy();
   // Check energy 
   if ( eKin < emax )
   {
      // Check Particle Species
      if ( aP->GetDefinition() == G4Neutron::Neutron() ) 
      {
        // anEle is one of Thermal elements 
         G4int ie = (G4int) anEle->GetIndex();
         std::vector < G4int >::iterator it; 
         for ( it = indexOfThermalElement.begin() ; it != indexOfThermalElement.end() ; it++ )
         {
             if ( ie == *it ) return true;
         }
      }
   }

/*
   if ( names->IsThisThermalElement ( anEle->GetName() ) )
   {
      // Check energy and projectile species 
      G4double eKin = aP->GetKineticEnergy();
      if ( eKin < emax && aP->GetDefinition() == G4Neutron::Neutron() ) result = true; 
   }
*/
   return result;
}

G4bool G4NeutronHPThermalScatteringData::IsIsoApplicable ( const G4DynamicParticle *  dp, G4int  , G4int  , const G4Element *  element, const G4Material *  material  )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 81 of file G4NeutronHPThermalScatteringData.cc.

References python.hepunit::eV, G4DynamicParticle::GetDefinition(), G4DynamicParticle::GetKineticEnergy(), and G4Neutron::Neutron().

{
   G4double eKin = dp->GetKineticEnergy();
   if ( eKin > 4.0*eV //GetMaxKinEnergy() 
     || eKin < 0 //GetMinKinEnergy() 
     || dp->GetDefinition() != G4Neutron::Neutron() ) return false;                                   

   if ( dic.find( std::pair < const G4Material* , const G4Element* > ( (G4Material*)NULL , element ) ) != dic.end() 
     || dic.find( std::pair < const G4Material* , const G4Element* > ( material , element ) ) != dic.end() ) return true;

   return false;

//   return IsApplicable( dp , element );
/*
   G4double eKin = dp->GetKineticEnergy();
   if ( eKin > 4.0*eV //GetMaxKinEnergy() 
     || eKin < 0 //GetMinKinEnergy() 
     || dp->GetDefinition() != G4Neutron::Neutron() ) return false;                                   
   return true;
*/
}

---

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

• G4NeutronHPThermalScatteringData.hh
• G4NeutronHPThermalScatteringData.cc