G4NeutronHPFSFissionFS Class Reference

#include <G4NeutronHPFSFissionFS.hh>

Inheritance diagram for G4NeutronHPFSFissionFS:

Public Member Functions
	G4NeutronHPFSFissionFS ()
	~G4NeutronHPFSFissionFS ()
void	Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &aFSType)
G4DynamicParticleVector *	ApplyYourself (G4int Prompt, G4int delayed, G4double *decayconst)
G4NeutronHPFinalState *	New ()
G4double	GetMass ()
void	SampleNeutronMult (G4int &all, G4int &Prompt, G4int &delayed, G4double energy, G4int off)
void	SetNeutron (const G4ReactionProduct &aNeutron)
void	SetTarget (const G4ReactionProduct &aTarget)
G4DynamicParticleVector *	GetPhotons ()
G4NeutronHPFissionERelease *	GetEnergyRelease ()
Public Member Functions inherited from G4NeutronHPFinalState
	G4NeutronHPFinalState ()
virtual	~G4NeutronHPFinalState ()
void	Init (G4double A, G4double Z, G4String &dirName, G4String &aFSType)
virtual void	Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &aFSType)=0
virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &)
virtual G4NeutronHPFinalState *	New ()=0
G4bool	HasXsec ()
G4bool	HasFSData ()
G4bool	HasAnyData ()
virtual G4double	GetXsec (G4double)
virtual G4NeutronHPVector *	GetXsec ()
void	SetA_Z (G4double anA, G4double aZ, G4int aM=0)
G4double	GetZ ()
G4double	GetN ()
G4int	GetM ()

Additional Inherited Members
Protected Member Functions inherited from G4NeutronHPFinalState
void	SetAZMs (G4double anA, G4double aZ, G4int aM, G4NeutronHPDataUsed used)
void	adjust_final_state (G4LorentzVector)
Protected Attributes inherited from G4NeutronHPFinalState
G4bool	hasXsec
G4bool	hasFSData
G4bool	hasAnyData
G4NeutronHPNames	theNames
G4HadFinalState	theResult
G4double	theBaseA
G4double	theBaseZ
G4int	theBaseM
G4int	theNDLDataZ
G4int	theNDLDataA
G4int	theNDLDataM

Detailed Description

Definition at line 44 of file G4NeutronHPFSFissionFS.hh.

Constructor & Destructor Documentation

G4NeutronHPFSFissionFS()

G4NeutronHPFSFissionFS::G4NeutronHPFSFissionFS ( )

inline

Definition at line 48 of file G4NeutronHPFSFissionFS.hh.

{ hasXsec = true; }

Referenced by New().

~G4NeutronHPFSFissionFS()

G4NeutronHPFSFissionFS::~G4NeutronHPFSFissionFS ( )

inline

Definition at line 49 of file G4NeutronHPFSFissionFS.hh.

{}

Member Function Documentation

ApplyYourself()

G4DynamicParticleVector * G4NeutronHPFSFissionFS::ApplyYourself	(	G4int	Prompt,
		G4int	delayed,
		G4double *	decayconst
	)

Definition at line 98 of file G4NeutronHPFSFissionFS.cc.

  {  
    G4int i;
    G4DynamicParticleVector * aResult = new G4DynamicParticleVector;
    G4ReactionProduct boosted;
    boosted.Lorentz(theNeutron, theTarget);
    G4double eKinetic = boosted.GetKineticEnergy();
    
// Build neutrons
    G4ReactionProduct * theNeutrons = new G4ReactionProduct[nPrompt+nDelayed];
    for(i=0; i<nPrompt+nDelayed; i++)
    {
      theNeutrons[i].SetDefinition(G4Neutron::Neutron());
    }
    
// sample energies
   G4int it, dummy;
   G4double tempE;
   for(i=0; i<nPrompt; i++)
   {
     tempE = thePromptNeutronEnDis.Sample(eKinetic, dummy); // energy distribution (file5) always in lab
     theNeutrons[i].SetKineticEnergy(tempE);
   }
   for(i=nPrompt; i<nPrompt+nDelayed; i++)
   {
     theNeutrons[i].SetKineticEnergy(theDelayedNeutronEnDis.Sample(eKinetic, it));  // dito
     if(it==0) theNeutrons[i].SetKineticEnergy(thePromptNeutronEnDis.Sample(eKinetic, dummy));
     theDecayConst[i-nPrompt] = theFinalStateNeutrons.GetDecayConstant(it); // this is returned
   }
 
// sample neutron angular distribution
   for(i=0; i<nPrompt+nDelayed; i++)
   {
     theNeutronAngularDis.SampleAndUpdate(theNeutrons[i]); // angular comes back in lab automatically
   }
   
// already in lab. Add neutrons to dynamic particle vector
   for(i=0; i<nPrompt+nDelayed; i++)
   {
      G4DynamicParticle * dp = new G4DynamicParticle;
      dp->SetDefinition(theNeutrons[i].GetDefinition());
      dp->SetMomentum(theNeutrons[i].GetMomentum());
      aResult->push_back(dp);
   }
   delete [] theNeutrons;
// return the result
   return aResult;
  }

Referenced by G4NeutronHPFissionFS::ApplyYourself().

GetEnergyRelease()

G4NeutronHPFissionERelease * G4NeutronHPFSFissionFS::GetEnergyRelease ( )

inline

Definition at line 83 of file G4NeutronHPFSFissionFS.hh.

  {
    return &theEnergyRelease;
  }

Referenced by G4NeutronHPFissionFS::ApplyYourself().

GetMass()

G4double G4NeutronHPFSFissionFS::GetMass ( )

inline

Definition at line 61 of file G4NeutronHPFSFissionFS.hh.

{ return targetMass; }

Referenced by G4NeutronHPFissionFS::ApplyYourself().

GetPhotons()

G4DynamicParticleVector * G4NeutronHPFSFissionFS::GetPhotons

(

)

Definition at line 172 of file G4NeutronHPFSFissionFS.cc.

{
// sample photons
   G4ReactionProductVector * temp;
   G4ReactionProduct boosted;
// the photon distributions are in the Nucleus rest frame.
   boosted.Lorentz(theNeutron, theTarget);
   G4double anEnergy = boosted.GetKineticEnergy();
   temp = theFinalStatePhotons.GetPhotons(anEnergy);
   if(temp == 0) { return 0; }
 
// lorentz transform, and add photons to final state
   unsigned int i;
   G4DynamicParticleVector * result = new G4DynamicParticleVector;
   for(i=0; i<temp->size(); i++)
   {
     // back to lab
     temp->operator[](i)->Lorentz(*(temp->operator[](i)), -1.*theTarget);
     G4DynamicParticle * theOne = new G4DynamicParticle;
     theOne->SetDefinition(temp->operator[](i)->GetDefinition());
     theOne->SetMomentum(temp->operator[](i)->GetMomentum());
     result->push_back(theOne);
     delete temp->operator[](i);
   }
   delete temp;
   return result;
}

Referenced by G4NeutronHPFissionFS::ApplyYourself().

Init()

void G4NeutronHPFSFissionFS::Init ( G4double  A, G4double  Z, G4int  M, G4String &  dirName, G4String &  aFSType  )

virtual

Implements G4NeutronHPFinalState.

Definition at line 42 of file G4NeutronHPFSFissionFS.cc.

  {
    G4String tString = "/FS/";
    G4bool dbool;
    G4NeutronHPDataUsed aFile = theNames.GetName(static_cast<G4int>(A), static_cast<G4int>(Z), M, dirName, tString, dbool);
    G4String filename = aFile.GetName();
    SetAZMs( A, Z, M, aFile ); 
    if(!dbool)
    {
      hasAnyData = false;
      hasFSData = false; 
      hasXsec = false;
      return;
    }
    std::ifstream theData(filename, std::ios::in);
 
    // here it comes
    G4int infoType, dataType;
    hasFSData = false; 
    while (theData >> infoType)
    {
      hasFSData = true; 
      theData >> dataType;
      switch(infoType)
      {
        case 1: 
          if(dataType==4) theNeutronAngularDis.Init(theData); 
          if(dataType==5) thePromptNeutronEnDis.Init(theData); 
          if(dataType==12) theFinalStatePhotons.InitMean(theData); 
          if(dataType==14) theFinalStatePhotons.InitAngular(theData); 
          if(dataType==15) theFinalStatePhotons.InitEnergies(theData); 
          break;
        case 2:
          if(dataType==1) theFinalStateNeutrons.InitMean(theData); 
          break;
        case 3:
          if(dataType==1) theFinalStateNeutrons.InitDelayed(theData); 
          if(dataType==5) theDelayedNeutronEnDis.Init(theData);
          break;
        case 4:
          if(dataType==1) theFinalStateNeutrons.InitPrompt(theData); 
          break;
        case 5:
          if(dataType==1) theEnergyRelease.Init(theData); 
          break;
        default:
          G4cout << "G4NeutronHPFSFissionFS::Init: unknown data type"<<dataType<<G4endl;
          throw G4HadronicException(__FILE__, __LINE__, "G4NeutronHPFSFissionFS::Init: unknown data type");
          break;
      }
    }
    targetMass = theFinalStateNeutrons.GetTargetMass();
    theData.close();
  }

Referenced by G4NeutronHPFissionFS::Init().

New()

G4NeutronHPFinalState * G4NeutronHPFSFissionFS::New ( )

inlinevirtual

Implements G4NeutronHPFinalState.

Definition at line 55 of file G4NeutronHPFSFissionFS.hh.

  {
   G4NeutronHPFSFissionFS * theNew = new G4NeutronHPFSFissionFS;
   return theNew;
  }

SampleNeutronMult()

void G4NeutronHPFSFissionFS::SampleNeutronMult	(	G4int &	all,
		G4int &	Prompt,
		G4int &	delayed,
		G4double	energy,
		G4int	off
	)

Definition at line 148 of file G4NeutronHPFSFissionFS.cc.

{
   G4double promptNeutronMulti = 0;
   promptNeutronMulti = theFinalStateNeutrons.GetPrompt(eKinetic);
   G4double delayedNeutronMulti = 0;
   delayedNeutronMulti = theFinalStateNeutrons.GetDelayed(eKinetic);
   
   if(delayedNeutronMulti==0&&promptNeutronMulti==0)
   {
     Prompt = 0;
     delayed = 0;
     G4double totalNeutronMulti = theFinalStateNeutrons.GetMean(eKinetic);
     all = G4Poisson(totalNeutronMulti-off);
     all += off;
   }
   else
   {   
     Prompt  = G4Poisson(promptNeutronMulti-off);
     Prompt += off;
     delayed = G4Poisson(delayedNeutronMulti);
     all = Prompt+delayed;
   }
}

Referenced by G4NeutronHPFissionFS::ApplyYourself().

SetNeutron()

void G4NeutronHPFSFissionFS::SetNeutron ( const G4ReactionProduct &  aNeutron )

inline

Definition at line 69 of file G4NeutronHPFSFissionFS.hh.

                        { 
                          theNeutron = aNeutron;
                          theNeutronAngularDis.SetNeutron(aNeutron);
                        }

Referenced by G4NeutronHPFissionFS::ApplyYourself().

SetTarget()

void G4NeutronHPFSFissionFS::SetTarget ( const G4ReactionProduct &  aTarget )

inline

Definition at line 75 of file G4NeutronHPFSFissionFS.hh.

                        { 
                          theTarget = aTarget; 
                          theNeutronAngularDis.SetTarget(aTarget);
                        }

Referenced by G4NeutronHPFissionFS::ApplyYourself().

---

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

• G4NeutronHPFSFissionFS.hh
• G4NeutronHPFSFissionFS.cc