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)
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)
G4bool	DoNotAdjustFinalState ()
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 43 of file G4NeutronHPFSFissionFS.hh.

Constructor & Destructor Documentation

G4NeutronHPFSFissionFS::G4NeutronHPFSFissionFS ( )

inline

Definition at line 47 of file G4NeutronHPFSFissionFS.hh.

References G4NeutronHPFinalState::hasXsec.

Referenced by New().

{ hasXsec = true; }

G4NeutronHPFSFissionFS::~G4NeutronHPFSFissionFS ( )

inline

Definition at line 48 of file G4NeutronHPFSFissionFS.hh.

{}

Member Function Documentation

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

Definition at line 101 of file G4NeutronHPFSFissionFS.cc.

References G4NeutronHPNeutronYield::GetDecayConstant(), G4ReactionProduct::GetKineticEnergy(), G4ReactionProduct::Lorentz(), G4Neutron::Neutron(), G4NeutronHPEnergyDistribution::Sample(), G4NeutronHPAngular::SampleAndUpdate(), G4ReactionProduct::SetDefinition(), G4DynamicParticle::SetDefinition(), G4ReactionProduct::SetKineticEnergy(), and G4DynamicParticle::SetMomentum().

Referenced by G4NeutronHPFissionFS::ApplyYourself().

  {  
    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;
  }

G4NeutronHPFissionERelease* G4NeutronHPFSFissionFS::GetEnergyRelease ( )

inline

Definition at line 82 of file G4NeutronHPFSFissionFS.hh.

Referenced by G4NeutronHPFissionFS::ApplyYourself().

  {
    return &theEnergyRelease;
  }

G4double G4NeutronHPFSFissionFS::GetMass ( )

inline

Definition at line 60 of file G4NeutronHPFSFissionFS.hh.

Referenced by G4NeutronHPFissionFS::ApplyYourself().

{ return targetMass; }

G4DynamicParticleVector * G4NeutronHPFSFissionFS::GetPhotons

(

)

Definition at line 175 of file G4NeutronHPFSFissionFS.cc.

References G4ReactionProduct::GetKineticEnergy(), G4NeutronHPPhotonDist::GetPhotons(), G4ReactionProduct::Lorentz(), G4DynamicParticle::SetDefinition(), and G4DynamicParticle::SetMomentum().

Referenced by G4NeutronHPFissionFS::ApplyYourself().

{
// 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;
}

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

virtual

Implements G4NeutronHPFinalState.

Definition at line 43 of file G4NeutronHPFSFissionFS.cc.

References G4cout, G4endl, G4NeutronHPManager::GetDataStream(), G4NeutronHPManager::GetInstance(), G4NeutronHPNames::GetName(), G4NeutronHPDataUsed::GetName(), G4NeutronHPNeutronYield::GetTargetMass(), G4NeutronHPFinalState::hasAnyData, G4NeutronHPFinalState::hasFSData, G4NeutronHPFinalState::hasXsec, G4NeutronHPFissionERelease::Init(), G4NeutronHPAngular::Init(), G4NeutronHPEnergyDistribution::Init(), G4NeutronHPPhotonDist::InitAngular(), G4NeutronHPNeutronYield::InitDelayed(), G4NeutronHPPhotonDist::InitEnergies(), G4NeutronHPNeutronYield::InitMean(), G4NeutronHPPhotonDist::InitMean(), G4NeutronHPNeutronYield::InitPrompt(), and G4NeutronHPFinalState::SetAZMs().

Referenced by G4NeutronHPFissionFS::Init().

  {
    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);
   std::istringstream theData(std::ios::in);
   G4NeutronHPManager::GetInstance()->GetDataStream(filename,theData);

    // 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();
  }

G4NeutronHPFinalState* G4NeutronHPFSFissionFS::New ( )

inlinevirtual

Implements G4NeutronHPFinalState.

Definition at line 54 of file G4NeutronHPFSFissionFS.hh.

References G4NeutronHPFSFissionFS().

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

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

Definition at line 151 of file G4NeutronHPFSFissionFS.cc.

References G4Poisson(), G4NeutronHPNeutronYield::GetDelayed(), G4NeutronHPNeutronYield::GetMean(), and G4NeutronHPNeutronYield::GetPrompt().

Referenced by G4NeutronHPFissionFS::ApplyYourself().

{
   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;
   }
}

void G4NeutronHPFSFissionFS::SetNeutron ( const G4ReactionProduct &  aNeutron )

inline

Definition at line 68 of file G4NeutronHPFSFissionFS.hh.

References G4NeutronHPAngular::SetNeutron().

Referenced by G4NeutronHPFissionFS::ApplyYourself().

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

void G4NeutronHPFSFissionFS::SetTarget ( const G4ReactionProduct &  aTarget )

inline

Definition at line 74 of file G4NeutronHPFSFissionFS.hh.

References G4NeutronHPAngular::SetTarget().

Referenced by G4NeutronHPFissionFS::ApplyYourself().

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

---

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

• G4NeutronHPFSFissionFS.hh
• G4NeutronHPFSFissionFS.cc