G4InterpolationManager Class Reference

#include <G4InterpolationManager.hh>

Public Member Functions
	G4InterpolationManager ()
	~G4InterpolationManager ()
G4InterpolationManager &	operator= (const G4InterpolationManager &aManager)
void	Init (G4int aScheme, G4int aRange)
void	Init (G4InterpolationScheme aScheme, G4int aRange)
void	Init (std::ifstream &aDataFile)
G4InterpolationScheme	MakeScheme (G4int it)
G4InterpolationScheme	GetScheme (G4int index) const
void	CleanUp ()
G4InterpolationScheme	GetInverseScheme (G4int index)
void	AppendScheme (G4int aPoint, const G4InterpolationScheme &aScheme)

Friends
class	G4InterpolationIterator

Detailed Description

Definition at line 38 of file G4InterpolationManager.hh.

Constructor & Destructor Documentation

G4InterpolationManager()

G4InterpolationManager::G4InterpolationManager ( )

inline

Definition at line 44 of file G4InterpolationManager.hh.

   {
     nRanges = 1;
     start = new G4int[1];
     start[0] = 0;
     range = new G4int[1];
     range [0] = 100000;
     scheme = new G4InterpolationScheme[1];
     scheme[0] = LINLIN;
     nEntries = 0;
   }

~G4InterpolationManager()

G4InterpolationManager::~G4InterpolationManager ( )

inline

Definition at line 56 of file G4InterpolationManager.hh.

   {
     if(start!=0) delete [] start;
     if(range!=0) delete [] range;
     if(scheme!=0) delete [] scheme;
   }

Member Function Documentation

AppendScheme()

void G4InterpolationManager::AppendScheme	(	G4int	aPoint,
		const G4InterpolationScheme &	aScheme
	)

Definition at line 90 of file G4InterpolationManager.cc.

   {
     if(aPoint!=nEntries) 
     {
       G4cout <<"G4InterpolationManager::AppendScheme - "<<aPoint<<" "<<nEntries<<G4endl;
       throw G4HadronicException(__FILE__, __LINE__, "Wrong usage of G4InterpolationManager::AppendScheme");
     }
     if(nEntries==0)
     {
       nEntries = 1;
       nRanges = 1;
       start[0] = 0;
       range [0] = 1;
       scheme[0] = aScheme;
     }
     else if(aScheme==scheme[nRanges-1])
     {
       ++range[nRanges-1];
       nEntries++;
     }
     else
     {
       nEntries++;
       nRanges++;
       G4int i;
       G4int * buffer = new G4int[nRanges];
       G4int * buffer1 = new G4int[nRanges];
       G4InterpolationScheme* buff2 = new G4InterpolationScheme[nRanges];
       for(i=0; i<nRanges-1; i++) 
       {
         buffer[i]  = start[i];
         buffer1[i] = range[i];
         buff2[i]   = scheme[i];
       }
       delete [] start;
       delete [] range;
       delete [] scheme;
       start  = buffer;
       range  = buffer1;
       scheme = buff2;
       start[nRanges-1]  = start[nRanges-2]+range[nRanges-2];
       range[nRanges-1]  = 1;
       scheme[nRanges-1] = aScheme;
     }
   }

Referenced by G4NeutronHPVector::Merge(), and G4NeutronHPVector::SetScheme().

CleanUp()

void G4InterpolationManager::CleanUp ( )

inline

Definition at line 143 of file G4InterpolationManager.hh.

   {
     nRanges = 0;
     nEntries = 0;
   }

Referenced by G4NeutronHPVector::CleanUp().

GetInverseScheme()

G4InterpolationScheme G4InterpolationManager::GetInverseScheme ( G4int  index )

inline

Definition at line 149 of file G4InterpolationManager.hh.

   {
     G4InterpolationScheme result = GetScheme(index);
     if(result == HISTO) 
     {
       result = RANDOM;
     }
     else if(result == LINLOG)  
     {
       result = LOGLIN;
     }
     else if(result == LOGLIN)  
     {
       result = LINLOG;
     }
     else if(result == CHISTO) 
     {
       result = CRANDOM;
     }
     else if(result == CLINLOG) 
     {
       result = CLOGLIN;
     }
     else if(result == CLOGLIN) 
     {
       result = CLINLOG;
     }
     else if(result == UHISTO) 
     {
       result = URANDOM;
     }
     else if(result == ULINLOG) 
     {
       result = ULOGLIN;
     }
     else if(result == ULOGLIN) 
     {
       result = ULINLOG;
     }
     return result;
   }

Referenced by G4NeutronHPContAngularPar::Sample().

GetScheme()

G4InterpolationScheme G4InterpolationManager::GetScheme ( G4int  index ) const

inline

Definition at line 132 of file G4InterpolationManager.hh.

   {
     G4int it = 0;
     for(G4int i=1; i<nRanges; i++)
     {
       if(index<start[i]) break;
       it = i;
     }
     return scheme[it];
   }

Referenced by G4NeutronHPAngularP::GetCosTh(), GetInverseScheme(), G4NeutronHPVector::GetMeanX(), G4NeutronHPVector::GetScheme(), G4NeutronHPVector::GetXsec(), G4NeutronHPPartial::GetY(), G4NeutronHPVector::Integrate(), G4NeutronHPVector::IntegrateAndNormalise(), G4NeutronHPDiscreteTwoBody::Sample(), G4NeutronHPLabAngularEnergy::Sample(), G4NeutronHPContAngularPar::Sample(), G4NeutronHPLegendreStore::Sample(), G4NeutronHPPartial::Sample(), G4NeutronHPLegendreStore::SampleDiscreteTwoBody(), G4NeutronHPLegendreStore::SampleElastic(), and G4NeutronHPLegendreStore::SampleMax().

Init() [1/3]

void G4InterpolationManager::Init ( G4int  aScheme, G4int  aRange  )

inline

Definition at line 85 of file G4InterpolationManager.hh.

   {
     nRanges = 1;
     start[0] = 0;
     range [0] = aRange;
     scheme[0] = MakeScheme(aScheme);
     nEntries = aRange;
   }

Referenced by G4NeutronHPAngularP::Init(), G4NeutronHPContEnergyAngular::Init(), G4NeutronHPDiscreteTwoBody::Init(), G4NeutronHPLabAngularEnergy::Init(), G4NeutronHPVector::Init(), G4NeutronHPArbitaryTab::Init(), G4NeutronHPPhotonDist::InitAngular(), G4NeutronHPLegendreStore::InitInterpolation(), G4NeutronHPPartial::InitInterpolation(), G4NeutronHPVector::InitInterpolation(), G4NeutronHPDiscreteTwoBody::Sample(), G4NeutronHPContAngularPar::Sample(), and G4NeutronHPContAngularPar::SetInterpolation().

Init() [2/3]

void G4InterpolationManager::Init ( G4InterpolationScheme  aScheme, G4int  aRange  )

inline

Definition at line 93 of file G4InterpolationManager.hh.

   {
     nRanges = 1;
     start[0] = 0;
     range [0] = aRange;
     scheme[0] = aScheme;
     nEntries = aRange;
   }

Init() [3/3]

void G4InterpolationManager::Init ( std::ifstream &  aDataFile )

inline

Definition at line 102 of file G4InterpolationManager.hh.

   {
     delete [] start;
     delete [] range;
     delete [] scheme;
     aDataFile >> nRanges;
     start = new G4int[nRanges];
     range = new G4int[nRanges];
     scheme = new G4InterpolationScheme[nRanges];
     start[0] = 0;
     G4int it;
     for(G4int i=0; i<nRanges; i++)
     {
       aDataFile>>range[i];
       //***************************************************************
       //EMendoza -> there is a bug here.
       /*
       if(i!=0) start[i] = start[i-1]+range[i-1];
       */
       //***************************************************************
       if(i!=0) start[i] = range[i-1];
       //***************************************************************
       aDataFile>>it;
       scheme[i] = MakeScheme(it);
     }
     nEntries = start[nRanges-1]+range[nRanges-1];
   }

MakeScheme()

G4InterpolationScheme G4InterpolationManager::MakeScheme

(

G4int

it

)

Definition at line 33 of file G4InterpolationManager.cc.

   {
     G4InterpolationScheme result(LINLIN);
     switch(it)
     {
      case 1:
        result = HISTO;
        break;
      case 2:
        result = LINLIN;
        break;
      case 3:
        result = LINLOG;
        break;
      case 4:
        result = LOGLIN;
        break;
      case 5:
        result = LOGLOG;
        break;
      case 11:
        result = CHISTO;
        break;
      case 12:
        result = CLINLIN;
        break;
      case 13:
        result = CLINLOG;
        break;
      case 14:
        result = CLOGLIN;
        break;
      case 15:
        result = CLOGLOG;
        break;
      case 21:
        result = UHISTO;
        break;
      case 22:
        result = ULINLIN;
        break;
      case 23:
        result = ULINLOG;
        break;
      case 24:
        result = ULOGLIN;
        break;
      case 25:
        result = ULOGLOG;
        break;
      default:
        throw G4HadronicException(__FILE__, __LINE__, "G4InterpolationManager: unknown interpolation scheme");
        break;        
     }
     return result;
   }

Referenced by Init().

operator=()

G4InterpolationManager & G4InterpolationManager::operator= ( const G4InterpolationManager &  aManager )

inline

Definition at line 63 of file G4InterpolationManager.hh.

   {
     if(this != &aManager)
     {
       nRanges = aManager.nRanges;
       nEntries = aManager.nEntries;
       if(scheme!=0) delete [] scheme;
       if(start!=0) delete [] start;
       if(range!=0) delete [] range;
       scheme = new G4InterpolationScheme[nRanges];
       start = new G4int[nRanges];
       range = new G4int[nRanges];
       for(G4int i=0; i<nRanges; i++)
       {
     scheme[i]=aManager.scheme[i];
     start[i]=aManager.start[i];
     range[i]=aManager.range[i];
       }
     }
     return *this;
   }

Friends And Related Function Documentation

G4InterpolationIterator

friend class G4InterpolationIterator

friend

Definition at line 42 of file G4InterpolationManager.hh.

---

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

• G4InterpolationManager.hh
• G4InterpolationManager.cc