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)
G4bool	HasXsec ()
G4bool	HasFSData ()
G4bool	HasAnyData ()
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 36 of file G4NeutronHPFFFissionFS.hh.

Constructor & Destructor Documentation

G4NeutronHPFFFissionFS::G4NeutronHPFFFissionFS ( )

inline

Definition at line 40 of file G4NeutronHPFFFissionFS.hh.

References G4NeutronHPFinalState::hasXsec.

Referenced by New().

{ hasXsec = false; }

G4NeutronHPFFFissionFS::~G4NeutronHPFFFissionFS ( )

inline

Definition at line 41 of file G4NeutronHPFFFissionFS.hh.

{}

Member Function Documentation

G4DynamicParticleVector * G4NeutronHPFFFissionFS::ApplyYourself

(

G4int

nNeutrons

)

Definition at line 121 of file G4NeutronHPFFFissionFS.cc.

References G4NeutronHPFissionBaseFS::ApplyYourself().

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

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

Definition at line 129 of file G4NeutronHPFFFissionFS.cc.

References DBL_MAX, G4UniformRand, and python.hepunit::second.

Referenced by G4NeutronHPFissionFS::ApplyYourself().

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

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

virtual

Implements G4NeutronHPFinalState.

Definition at line 34 of file G4NeutronHPFFFissionFS.cc.

References python.hepunit::eV, G4NeutronHPDataUsed::GetA(), G4NeutronHPManager::GetDataStream(), G4NeutronHPManager::GetInstance(), G4NeutronHPNames::GetName(), G4NeutronHPDataUsed::GetName(), G4NeutronHPDataUsed::GetZ(), G4NeutronHPFinalState::hasAnyData, G4NeutronHPFinalState::hasFSData, G4NeutronHPFinalState::hasXsec, jmax, G4NeutronHPFinalState::theBaseA, G4NeutronHPFinalState::theBaseZ, and G4NeutronHPFinalState::theNames.

Referenced by G4NeutronHPFissionFS::Init().

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

G4NeutronHPFinalState* G4NeutronHPFFFissionFS::New ( )

inlinevirtual

Implements G4NeutronHPFinalState.

Definition at line 47 of file G4NeutronHPFFFissionFS.hh.

References G4NeutronHPFFFissionFS().

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

---

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

• G4NeutronHPFFFissionFS.hh
• G4NeutronHPFFFissionFS.cc