G4NeutronHPFFFissionFS Class Reference

#include <G4NeutronHPFFFissionFS.hh>

Inheritance diagram for G4NeutronHPFFFissionFS:

Public Member Functions
	G4NeutronHPFFFissionFS ()
	~G4NeutronHPFFFissionFS ()
void	Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &aFSType)
G4DynamicParticleVector *	ApplyYourself (G4int nNeutrons)
G4NeutronHPFinalState *	New ()
void	GetAFissionFragment (G4double, G4int &, G4int &, G4int &)
Public Member Functions inherited from G4NeutronHPFissionBaseFS
	G4NeutronHPFissionBaseFS ()
virtual	~G4NeutronHPFissionBaseFS ()
void	Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &bit)
G4DynamicParticleVector *	ApplyYourself (G4int Prompt)
virtual G4double	GetXsec (G4double anEnergy)
virtual G4NeutronHPVector *	GetXsec ()
void	SetNeutron (const G4ReactionProduct &aNeutron)
void	SetTarget (const G4ReactionProduct &aTarget)
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 37 of file G4NeutronHPFFFissionFS.hh.

Constructor & Destructor Documentation

G4NeutronHPFFFissionFS()

G4NeutronHPFFFissionFS::G4NeutronHPFFFissionFS ( )

inline

Definition at line 41 of file G4NeutronHPFFFissionFS.hh.

{ hasXsec = false; }

Referenced by New().

~G4NeutronHPFFFissionFS()

G4NeutronHPFFFissionFS::~G4NeutronHPFFFissionFS ( )

inline

Definition at line 42 of file G4NeutronHPFFFissionFS.hh.

{}

Member Function Documentation

ApplyYourself()

G4DynamicParticleVector * G4NeutronHPFFFissionFS::ApplyYourself

(

G4int

nNeutrons

)

Definition at line 118 of file G4NeutronHPFFFissionFS.cc.

{  
   G4DynamicParticleVector * aResult;
//    G4cout <<"G4NeutronHPFFFissionFS::ApplyYourself +"<<G4endl;
   aResult = G4NeutronHPFissionBaseFS::ApplyYourself(nNeutrons);    
   return aResult;
}

GetAFissionFragment()

void G4NeutronHPFFFissionFS::GetAFissionFragment	(	G4double	energy,
		G4int &	fragZ,
		G4int &	fragA,
		G4int &	fragM
	)

Definition at line 126 of file G4NeutronHPFFFissionFS.cc.

{
   //G4cout << "G4NeutronHPFFFissionFS::GetAFissionFragment " << G4endl;
 
   G4double rand =G4UniformRand();
   //G4cout << rand << G4endl;
 
   std::map< G4double , std::map< G4int , G4double >* >* mEnergyFSPData = FissionProductYieldData.find( 454 )->second;
    
   //It is not clear that the treatment of the scheme 2 on two-dimensional interpolation. 
   //So, here just use the closest energy point array of yield data. 
   //TK120531
   G4double key_energy = DBL_MAX;
   if ( mEnergyFSPData->size() == 1 )
   {
      key_energy = mEnergyFSPData->begin()->first;
   }
   else
   {
      //Find closest energy point
      G4double Dmin=DBL_MAX; 
      G4int i = 0;
      for ( std::map< G4double , std::map< G4int , G4double >* >::iterator it = mEnergyFSPData->begin() ; 
      it != mEnergyFSPData->end() ; it++ )
      {
         G4double e = (it->first);
         G4double d = std::fabs ( energy - e ); 
         if ( d < Dmin ) 
         {
            Dmin = d;
            key_energy = e;
         }
         i++;
      }
   }
 
   std::map<G4int,G4double>* mFSPYieldData = (*mEnergyFSPData)[key_energy];
 
   G4int ifrag=0;
   G4double ceilling = mFSPYieldData->rbegin()->second; // Becaseu of numerical accuracy, this is not always 2 
   for ( std::map<G4int,G4double>::iterator it = mFSPYieldData->begin() ; it != mFSPYieldData->end() ; it++ )
   {
      //if ( ( rand - it->second/ceilling ) < 1.0e-6 ) std::cout << rand - it->second/ceilling << std::endl;
      if ( rand <= it->second/ceilling ) 
      {  
         //G4cout << it->first << " " << it->second/ceilling << G4endl;
         ifrag = it->first;
         break;
      }
   }
 
   fragZ = ifrag/100000;
   fragA = (ifrag%100000)/100;
   fragM = (ifrag%100);
 
   //G4cout << fragZ << " " << fragA << " " << fragM << G4endl;
}

Referenced by G4NeutronHPFissionFS::ApplyYourself().

Init()

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

virtual

Implements G4NeutronHPFinalState.

Definition at line 33 of file G4NeutronHPFFFissionFS.cc.

{
   //G4cout << "G4NeutronHPFFFissionFS::Init" << G4endl;
   G4String aString = "FF";
 
   G4String tString = dirName;
   G4bool dbool;
   G4NeutronHPDataUsed aFile = theNames.GetName(static_cast<G4int>(A), static_cast<G4int>(Z), M, tString, aString , dbool);
   G4String filename = aFile.GetName();
   theBaseA = aFile.GetA();
   theBaseZ = aFile.GetZ();
 
//3456
   if ( !dbool || ( Z < 2.5 && ( std::abs(theBaseZ-Z)>0.0001 || std::abs(theBaseA-A)>0.0001) ) )
   {
      hasAnyData = false;
      hasFSData = false; 
      hasXsec = false;
      return; // no data for exactly this isotope.
   }
   std::ifstream theData(filename, std::ios::in);
   G4double dummy;
   if ( !theData )
   {
      theData.close();
      hasFSData = false;
      hasXsec = false;
      hasAnyData = false;
      return; // no data for this FS for this isotope
   }
 
 
   hasFSData = true; 
      //          MT              Energy            FPS    Yield
      //std::map< int , std::map< double , std::map< int , double >* >* > FisionProductYieldData; 
   while ( theData.good() )
   {
      G4int iMT, iMF;
      G4int imax;
      //Reading the data
      //         MT       MF       AWR
      theData >> iMT >> iMF >> dummy;
      //         nBlock 
      theData >> imax;
      //if ( !theData.good() ) continue;
      //        Ei                   FPS     Yield
      std::map< G4double , std::map< G4int , G4double >* >* mEnergyFSPData = new std::map< G4double , std::map< G4int , G4double >* >;
 
      std::map< G4double , G4int >* mInterporation = new std::map< G4double , G4int >;
      for ( G4int i = 0 ; i <= imax ; i++ ) 
      {
       
         G4double YY=0.0; 
         G4double Ei;
         G4int jmax;
         G4int ip;
         //        energy of incidnece neutron 
         theData >> Ei;
         //        Number of data set followings 
         theData >> jmax;
         //         interpolation scheme
         theData >> ip;
         mInterporation->insert( std::pair<G4double,G4int>(Ei*eV,ip) );
         //         nNumber  nIP
         std::map<G4int,G4double>* mFSPYieldData = new std::map<G4int,G4double>;
         for ( G4int j = 0 ; j < jmax ; j++ ) 
         {
            G4int FSP;
            G4int mFSP;
            G4double Y;
            theData >> FSP >> mFSP >> Y;
            G4int k = FSP*100+mFSP;
            YY = YY + Y;
            //if ( iMT == 454 )G4cout << iMT << " " << i << " " << j << " " <<  k << " " << Y << " " << YY << G4endl;
            mFSPYieldData->insert( std::pair<G4int,G4double>( k , YY ) );
         }
         mEnergyFSPData->insert( std::pair<G4double,std::map<G4int,G4double>*>(Ei*eV,mFSPYieldData) ); 
      }
 
      FissionProductYieldData.insert( std::pair< G4int , std::map< G4double , std::map< G4int , G4double >* >* > (iMT,mEnergyFSPData));
      mMTInterpolation.insert( std::pair<G4int,std::map<G4double,G4int>*> (iMT,mInterporation) ); 
   } 
   theData.close();
}

Referenced by G4NeutronHPFissionFS::Init().

New()

G4NeutronHPFinalState * G4NeutronHPFFFissionFS::New ( )

inlinevirtual

Implements G4NeutronHPFinalState.

Definition at line 48 of file G4NeutronHPFFFissionFS.hh.

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

---

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

• G4NeutronHPFFFissionFS.hh
• G4NeutronHPFFFissionFS.cc