#include <G4LENDModel.hh>

Inheritance diagram for G4LENDModel:

Public Member Functions
	G4LENDModel (G4String name="LENDModel")

	~G4LENDModel ()

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

void	ChangeDefaultEvaluation (G4String name)

void	AllowNaturalAbundanceTarget ()

void	AllowAnyCandidateTarget ()

void	BuildPhysicsTable (const G4ParticleDefinition &)

void	DumpLENDTargetInfo (G4bool force=false)

Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")

virtual	~G4HadronicInteraction ()

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

virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)

G4double	GetMinEnergy () const

G4double	GetMinEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMinEnergy (G4double anEnergy)

void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)

G4double	GetMaxEnergy () const

G4double	GetMaxEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMaxEnergy (const G4double anEnergy)

void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)

G4int	GetVerboseLevel () const

void	SetVerboseLevel (G4int value)

const G4String &	GetModelName () const

void	DeActivateFor (const G4Material *aMaterial)

void	ActivateFor (const G4Material *aMaterial)

void	DeActivateFor (const G4Element *anElement)

void	ActivateFor (const G4Element *anElement)

G4bool	IsBlocked (const G4Material *aMaterial) const

G4bool	IsBlocked (const G4Element *anElement) const

void	SetRecoilEnergyThreshold (G4double val)

G4double	GetRecoilEnergyThreshold () const

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

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

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

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

virtual void	InitialiseModel ()

	G4HadronicInteraction (const G4HadronicInteraction &right)=delete

const G4HadronicInteraction &	operator= (const G4HadronicInteraction &right)=delete

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

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

Protected Member Functions
void	create_used_target_map ()

void	recreate_used_target_map ()

G4GIDI_target *	get_target_from_map (G4int nuclear_code)

G4HadFinalState *	returnUnchanged (const G4HadProjectile &aTrack, G4HadFinalState *theResult)

Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)

G4bool	IsBlocked () const

void	Block ()

Protected Attributes
G4ParticleDefinition *	proj

G4LENDManager *	lend_manager

std::map< G4int, G4LENDUsedTarget * >	usedTarget_map

G4int	secID

Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange

G4int	verboseLevel

G4double	theMinEnergy

G4double	theMaxEnergy

G4bool	isBlocked

Detailed Description

Definition at line 51 of file G4LENDModel.hh.

Constructor & Destructor Documentation

◆ G4LENDModel()

G4LENDModel::G4LENDModel ( G4String name = "LENDModel" )

Definition at line 48 of file G4LENDModel.cc.

  :G4HadronicInteraction( name ), secID(-1)
{
 
   proj = NULL; //will be set in an inherited class
 
   SetMinEnergy( 0.*eV );
   SetMaxEnergy( 20.*MeV );
 
   //default_evaluation = "endl99"; 
   //default_evaluation = "ENDF.B-VII.0";
   default_evaluation = "ENDF/BVII.1";
 
   allow_nat = false;
   allow_any = false;
 
   lend_manager = G4LENDManager::GetInstance();  
 
   secID = G4PhysicsModelCatalog::GetModelID( "model_" + GetModelName() );
}

◆ ~G4LENDModel()

G4LENDModel::~G4LENDModel ( )

Definition at line 69 of file G4LENDModel.cc.

{
   for ( std::map< G4int , G4LENDUsedTarget* >::iterator 
         it = usedTarget_map.begin() ; it != usedTarget_map.end() ; it ++ )
   { 
      delete it->second;  
   }
}

Member Function Documentation

◆ AllowAnyCandidateTarget()

void G4LENDModel::AllowAnyCandidateTarget ( )

inline

Definition at line 64 of file G4LENDModel.hh.

64{ allow_any = true; recreate_used_target_map(); };

G4LENDModel::recreate_used_target_map

void recreate_used_target_map()

Definition G4LENDModel.cc:79

◆ AllowNaturalAbundanceTarget()

void G4LENDModel::AllowNaturalAbundanceTarget ( )

inline

Definition at line 63 of file G4LENDModel.hh.

63{ allow_nat = true; recreate_used_target_map(); };

Referenced by G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), and G4HadronElasticPhysicsLEND::ConstructProcess().

◆ ApplyYourself()

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

virtual

Reimplemented from G4HadronicInteraction.

Reimplemented in G4LENDCapture, G4LENDCombinedModel, G4LENDElastic, G4LENDFission, G4LENDGammaModel, G4LENDInelastic, and G4LENDorBERTModel.

Definition at line 160 of file G4LENDModel.cc.

{
 
   G4double temp = aTrack.GetMaterial()->GetTemperature();
 
   //G4int iZ = int ( aTarg.GetZ() );
   //G4int iA = int ( aTarg.GetN() );
   //migrate to integer A and Z (GetN_asInt returns number of neutrons in the nucleus since this) 
   G4int iZ = aTarg.GetZ_asInt();
   G4int iA = aTarg.GetA_asInt();
   G4int iM = 0;
   if ( aTarg.GetIsotope() != NULL ) {
      iM = aTarg.GetIsotope()->Getm();
   }
 
   G4double ke = aTrack.GetKineticEnergy();
 
   G4HadFinalState* theResult = new G4HadFinalState();
 
   G4GIDI_target* aTarget = usedTarget_map.find( lend_manager->GetNucleusEncoding( iZ , iA , iM ) )->second->GetTarget();
 
   G4double aMu = aTarget->getElasticFinalState( ke*MeV, temp, NULL, NULL );
 
   G4double phi = twopi*G4UniformRand();
   G4double theta = std::acos( aMu );
   //G4double sinth = std::sin( theta );
 
   G4ReactionProduct theNeutron( aTrack.GetDefinition() );
   theNeutron.SetMomentum( aTrack.Get4Momentum().vect() );
   theNeutron.SetKineticEnergy( ke );
 
   G4ParticleDefinition* pd = G4IonTable::GetIonTable()->GetIon( iZ , iA , iM );
   G4ReactionProduct theTarget( pd );
 
   G4double mass = pd->GetPDGMass();
 
// add Thermal motion 
   G4double kT = k_Boltzmann*temp;
   G4ThreeVector v ( G4RandGauss::shoot() * std::sqrt( kT*mass ) 
                   , G4RandGauss::shoot() * std::sqrt( kT*mass ) 
                   , G4RandGauss::shoot() * std::sqrt( kT*mass ) );
 
   theTarget.SetMomentum( v );
 
 
     G4ThreeVector the3Neutron = theNeutron.GetMomentum();
     G4double nEnergy = theNeutron.GetTotalEnergy();
     G4ThreeVector the3Target = theTarget.GetMomentum();
     G4double tEnergy = theTarget.GetTotalEnergy();
     G4ReactionProduct theCMS;
     G4double totE = nEnergy+tEnergy;
     G4ThreeVector the3CMS = the3Target+the3Neutron;
     theCMS.SetMomentum(the3CMS);
     G4double cmsMom = std::sqrt(the3CMS*the3CMS);
     G4double sqrts = std::sqrt((totE-cmsMom)*(totE+cmsMom));
     theCMS.SetMass(sqrts);
     theCMS.SetTotalEnergy(totE);
 
       theNeutron.Lorentz(theNeutron, theCMS);
       theTarget.Lorentz(theTarget, theCMS);
       G4double en = theNeutron.GetTotalMomentum(); // already in CMS.
       G4ThreeVector cms3Mom=theNeutron.GetMomentum(); // for neutron direction in CMS
       G4double cms_theta=cms3Mom.theta();
       G4double cms_phi=cms3Mom.phi();
       G4ThreeVector tempVector;
       tempVector.setX(std::cos(theta)*std::sin(cms_theta)*std::cos(cms_phi)
                       +std::sin(theta)*std::cos(phi)*std::cos(cms_theta)*std::cos(cms_phi)
                       -std::sin(theta)*std::sin(phi)*std::sin(cms_phi)  );
       tempVector.setY(std::cos(theta)*std::sin(cms_theta)*std::sin(cms_phi)
                       +std::sin(theta)*std::cos(phi)*std::cos(cms_theta)*std::sin(cms_phi)
                       +std::sin(theta)*std::sin(phi)*std::cos(cms_phi)  );
       tempVector.setZ(std::cos(theta)*std::cos(cms_theta)
                       -std::sin(theta)*std::cos(phi)*std::sin(cms_theta)  );
       tempVector *= en;
       theNeutron.SetMomentum(tempVector);
       theTarget.SetMomentum(-tempVector);
       G4double tP = theTarget.GetTotalMomentum();
       G4double tM = theTarget.GetMass();
       theTarget.SetTotalEnergy(std::sqrt((tP+tM)*(tP+tM)-2.*tP*tM));
       theNeutron.Lorentz(theNeutron, -1.*theCMS);
       theTarget.Lorentz(theTarget, -1.*theCMS);
 
     theResult->SetEnergyChange(theNeutron.GetKineticEnergy());
     theResult->SetMomentumChange(theNeutron.GetMomentum().unit());
     G4DynamicParticle* theRecoil = new G4DynamicParticle;
 
     theRecoil->SetDefinition( G4IonTable::GetIonTable()->GetIon( iZ , iA , iM , iZ ) );
     theRecoil->SetMomentum( theTarget.GetMomentum() );
 
     theResult->AddSecondary( theRecoil );
 
   return theResult; 
 
}

Referenced by G4LENDCombinedModel::ApplyYourself(), and G4LENDGammaModel::ApplyYourself().

◆ BuildPhysicsTable()

void G4LENDModel::BuildPhysicsTable ( const G4ParticleDefinition & )

inlinevirtual

Reimplemented from G4HadronicInteraction.

Reimplemented in G4LENDorBERTModel.

Definition at line 66 of file G4LENDModel.hh.

66{ recreate_used_target_map(); };

◆ ChangeDefaultEvaluation()

void G4LENDModel::ChangeDefaultEvaluation ( G4String name )

inline

Definition at line 62 of file G4LENDModel.hh.

62{ default_evaluation = name; recreate_used_target_map(); };

G4InuclParticleNames::name

const char * name(G4int ptype)

Definition G4InuclParticleNames.hh:76

Referenced by G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronLENDBuilder::Build(), and G4HadronElasticPhysicsLEND::ConstructProcess().

◆ create_used_target_map()

void G4LENDModel::create_used_target_map ( )

protected

Definition at line 95 of file G4LENDModel.cc.

{
 
   lend_manager->RequestChangeOfVerboseLevel( verboseLevel );
 
   std::size_t numberOfElements = G4Element::GetNumberOfElements();
   static const G4ElementTable* theElementTable = G4Element::GetElementTable();
 
   for ( std::size_t i = 0 ; i < numberOfElements ; ++i )
   {
 
      const G4Element* anElement = (*theElementTable)[i];
      G4int numberOfIsotope = (G4int)anElement->GetNumberOfIsotopes(); 
 
      if ( numberOfIsotope > 0 )
      {
      // User Defined Abundances   
         for ( G4int i_iso = 0 ; i_iso < numberOfIsotope ; ++i_iso )
         {
            G4int iZ = anElement->GetIsotope( i_iso )->GetZ();
            G4int iA = anElement->GetIsotope( i_iso )->GetN();
            G4int iIsomer = anElement->GetIsotope( i_iso )->Getm();
 
            G4LENDUsedTarget* aTarget = new G4LENDUsedTarget ( proj , default_evaluation , iZ , iA , iIsomer );  
            if ( allow_nat == true ) aTarget->AllowNat();
            if ( allow_any == true ) aTarget->AllowAny();
            usedTarget_map.insert( std::pair< G4int , G4LENDUsedTarget* > ( lend_manager->GetNucleusEncoding( iZ , iA , iIsomer ) , aTarget ) );
         }
      }
      else
      {
      // Natural Abundances   
         G4NistElementBuilder* nistElementBuild = lend_manager->GetNistElementBuilder();
         G4int iZ = int ( anElement->GetZ() );
         //G4cout << nistElementBuild->GetNumberOfNistIsotopes( int ( anElement->GetZ() ) ) << G4endl;
         G4int numberOfNistIso = nistElementBuild->GetNumberOfNistIsotopes( int ( anElement->GetZ() ) ); 
 
         for ( G4int ii = 0 ; ii < numberOfNistIso ; ii++ )
         {
            //G4cout << nistElementBuild->GetIsotopeAbundance( iZ , nistElementBuild->GetNistFirstIsotopeN( iZ ) + i ) << G4endl;
            if ( nistElementBuild->GetIsotopeAbundance( iZ , nistElementBuild->GetNistFirstIsotopeN( iZ ) + ii ) > 0 )
            {
               G4int iMass = nistElementBuild->GetNistFirstIsotopeN( iZ ) + ii;  
               //G4cout << iZ << " " << nistElementBuild->GetNistFirstIsotopeN( iZ ) + i << " " << nistElementBuild->GetIsotopeAbundance ( iZ , iMass ) << G4endl;  
               G4int iIsomer = 0;
 
               G4LENDUsedTarget* aTarget = new G4LENDUsedTarget ( proj , default_evaluation , iZ , iMass );  
               if ( allow_nat == true ) aTarget->AllowNat();
               if ( allow_any == true ) aTarget->AllowAny();
               usedTarget_map.insert( std::pair< G4int , G4LENDUsedTarget* > ( lend_manager->GetNucleusEncoding( iZ , iMass , iIsomer ) , aTarget ) );
 
            }
 
         }
 
      }
   }
 
   DumpLENDTargetInfo();
}

Referenced by G4LENDCombinedModel::BuildPhysicsTable(), G4LENDGammaModel::BuildPhysicsTable(), G4LENDorBERTModel::BuildPhysicsTable(), DumpLENDTargetInfo(), G4LENDCapture::G4LENDCapture(), G4LENDElastic::G4LENDElastic(), G4LENDFission::G4LENDFission(), G4LENDInelastic::G4LENDInelastic(), and recreate_used_target_map().

◆ DumpLENDTargetInfo()

void G4LENDModel::DumpLENDTargetInfo ( G4bool force = false )

Definition at line 277 of file G4LENDModel.cc.

                                                   {
 
   if ( lend_manager->GetVerboseLevel() >= 1 || force ) {
      if ( usedTarget_map.size() == 0 ) create_used_target_map(); 
      G4cout << "Dumping UsedTarget of " << GetModelName() << " for " << proj->GetParticleName() << G4endl;
      G4cout << "Requested Evaluation, Z , A -> Actual Evaluation, Z , A(0=Nat) " << G4endl;
      for ( std::map< G4int , G4LENDUsedTarget* >::iterator 
         it = usedTarget_map.begin() ; it != usedTarget_map.end() ; it ++ ) {
         G4cout 
         << " " << it->second->GetWantedEvaluation() 
         << ", " << it->second->GetWantedZ() 
         << ", " << it->second->GetWantedA() 
         << " -> " << it->second->GetActualEvaluation() 
         << ", " << it->second->GetActualZ() 
         << ", " << it->second->GetActualA() 
         << G4endl; 
      } 
   }
}

Referenced by G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4HadronElasticPhysicsLEND::ConstructProcess(), and create_used_target_map().

◆ get_target_from_map()

G4GIDI_target * G4LENDModel::get_target_from_map ( G4int nuclear_code )

protected

Definition at line 269 of file G4LENDModel.cc.

                                                                    {
   G4GIDI_target* target = NULL;
   if ( usedTarget_map.find( nuclear_code ) != usedTarget_map.end() ) {
      target = usedTarget_map.find( nuclear_code )->second->GetTarget();
   }
   return target;
}

Referenced by G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4LENDCombinedModel::HasData(), and G4LENDGammaModel::HasData().

◆ recreate_used_target_map()

void G4LENDModel::recreate_used_target_map ( )

protected

Definition at line 79 of file G4LENDModel.cc.

{
 
   for ( std::map< G4int , G4LENDUsedTarget* >::iterator 
         it = usedTarget_map.begin() ; it != usedTarget_map.end() ; it ++ )
   { 
      delete it->second;  
   }
   usedTarget_map.clear();
 
   create_used_target_map();
 
}

Referenced by AllowAnyCandidateTarget(), AllowNaturalAbundanceTarget(), BuildPhysicsTable(), and ChangeDefaultEvaluation().

◆ returnUnchanged()

G4HadFinalState * G4LENDModel::returnUnchanged	(	const G4HadProjectile &	aTrack,
		G4HadFinalState *	theResult )

protected

Definition at line 255 of file G4LENDModel.cc.

                                                                                                        {
   if ( lend_manager->GetVerboseLevel() >= 1 ) {
      G4String message;
      message = "Produce unchanged final state is requested in ";
      message += this->GetModelName();
      message += ". Cross section and model likely have an inconsistency.";
      G4Exception( "G4LENDModel::returnUnchanged(,)" , "LENDModel-01" , JustWarning ,
                  message );
   }
   theResult->SetEnergyChange( aTrack.GetKineticEnergy() );
   theResult->SetMomentumChange( aTrack.Get4Momentum().getV().unit() );
   return theResult;
}

Referenced by G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), and G4LENDFission::ApplyYourself().

Member Data Documentation

◆ lend_manager

G4LENDManager* G4LENDModel::lend_manager

protected

Definition at line 84 of file G4LENDModel.hh.

Referenced by G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), ApplyYourself(), create_used_target_map(), DumpLENDTargetInfo(), G4LENDModel(), G4LENDCombinedModel::HasData(), G4LENDGammaModel::HasData(), and returnUnchanged().

◆ proj

G4ParticleDefinition* G4LENDModel::proj

protected

Definition at line 83 of file G4LENDModel.hh.

Referenced by G4LENDCombinedModel::ApplyYourself(), G4LENDGammaModel::ApplyYourself(), create_used_target_map(), DumpLENDTargetInfo(), G4LENDCapture::G4LENDCapture(), G4LENDCombinedModel::G4LENDCombinedModel(), G4LENDElastic::G4LENDElastic(), G4LENDFission::G4LENDFission(), G4LENDGammaModel::G4LENDGammaModel(), G4LENDInelastic::G4LENDInelastic(), G4LENDModel(), and G4LENDorBERTModel::G4LENDorBERTModel().

◆ secID

G4int G4LENDModel::secID

protected

Definition at line 87 of file G4LENDModel.hh.

Referenced by G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), and G4LENDModel().

◆ usedTarget_map

std::map< G4int , G4LENDUsedTarget* > G4LENDModel::usedTarget_map

protected

Definition at line 85 of file G4LENDModel.hh.

Referenced by ApplyYourself(), create_used_target_map(), DumpLENDTargetInfo(), get_target_from_map(), recreate_used_target_map(), and ~G4LENDModel().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4LENDModel()

◆ ~G4LENDModel()

Member Function Documentation

◆ AllowAnyCandidateTarget()

◆ AllowNaturalAbundanceTarget()

◆ ApplyYourself()

◆ BuildPhysicsTable()

◆ ChangeDefaultEvaluation()

◆ create_used_target_map()

◆ DumpLENDTargetInfo()

◆ get_target_from_map()

◆ recreate_used_target_map()

◆ returnUnchanged()

Member Data Documentation

◆ lend_manager

◆ proj

◆ secID

◆ usedTarget_map