G4InterpolationManager Class Reference

#include <G4InterpolationManager.hh>


Public Member Functions

 G4InterpolationManager ()
 ~G4InterpolationManager ()
G4InterpolationManageroperator= (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 (  )  [inline]

Definition at line 44 of file G4InterpolationManager.hh.

References LINLIN.

00045    {
00046      nRanges = 1;
00047      start = new G4int[1];
00048      start[0] = 0;
00049      range = new G4int[1];
00050      range [0] = 100000;
00051      scheme = new G4InterpolationScheme[1];
00052      scheme[0] = LINLIN;
00053      nEntries = 0;
00054    }

G4InterpolationManager::~G4InterpolationManager (  )  [inline]

Definition at line 56 of file G4InterpolationManager.hh.

00057    {
00058      if(start!=0) delete [] start;
00059      if(range!=0) delete [] range;
00060      if(scheme!=0) delete [] scheme;
00061    }


Member Function Documentation

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

Definition at line 90 of file G4InterpolationManager.cc.

References buffer, G4cout, and G4endl.

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

00091    {
00092      if(aPoint!=nEntries) 
00093      {
00094        G4cout <<"G4InterpolationManager::AppendScheme - "<<aPoint<<" "<<nEntries<<G4endl;
00095        throw G4HadronicException(__FILE__, __LINE__, "Wrong usage of G4InterpolationManager::AppendScheme");
00096      }
00097      if(nEntries==0)
00098      {
00099        nEntries = 1;
00100        nRanges = 1;
00101        start[0] = 0;
00102        range [0] = 1;
00103        scheme[0] = aScheme;
00104      }
00105      else if(aScheme==scheme[nRanges-1])
00106      {
00107        ++range[nRanges-1];
00108        nEntries++;
00109      }
00110      else
00111      {
00112        nEntries++;
00113        nRanges++;
00114        G4int i;
00115        G4int * buffer = new G4int[nRanges];
00116        G4int * buffer1 = new G4int[nRanges];
00117        G4InterpolationScheme* buff2 = new G4InterpolationScheme[nRanges];
00118        for(i=0; i<nRanges-1; i++) 
00119        {
00120          buffer[i]  = start[i];
00121          buffer1[i] = range[i];
00122          buff2[i]   = scheme[i];
00123        }
00124        delete [] start;
00125        delete [] range;
00126        delete [] scheme;
00127        start  = buffer;
00128        range  = buffer1;
00129        scheme = buff2;
00130        start[nRanges-1]  = start[nRanges-2]+range[nRanges-2];
00131        range[nRanges-1]  = 1;
00132        scheme[nRanges-1] = aScheme;
00133      }
00134    }

void G4InterpolationManager::CleanUp (  )  [inline]

Definition at line 143 of file G4InterpolationManager.hh.

Referenced by G4NeutronHPVector::CleanUp().

00144    {
00145      nRanges = 0;
00146      nEntries = 0;
00147    }

G4InterpolationScheme G4InterpolationManager::GetInverseScheme ( G4int  index  )  [inline]

Definition at line 149 of file G4InterpolationManager.hh.

References CHISTO, CLINLOG, CLOGLIN, CRANDOM, GetScheme(), HISTO, LINLOG, LOGLIN, RANDOM, UHISTO, ULINLOG, ULOGLIN, and URANDOM.

Referenced by G4NeutronHPContAngularPar::Sample().

00150    {
00151      G4InterpolationScheme result = GetScheme(index);
00152      if(result == HISTO) 
00153      {
00154        result = RANDOM;
00155      }
00156      else if(result == LINLOG)  
00157      {
00158        result = LOGLIN;
00159      }
00160      else if(result == LOGLIN)  
00161      {
00162        result = LINLOG;
00163      }
00164      else if(result == CHISTO) 
00165      {
00166        result = CRANDOM;
00167      }
00168      else if(result == CLINLOG) 
00169      {
00170        result = CLOGLIN;
00171      }
00172      else if(result == CLOGLIN) 
00173      {
00174        result = CLINLOG;
00175      }
00176      else if(result == UHISTO) 
00177      {
00178        result = URANDOM;
00179      }
00180      else if(result == ULINLOG) 
00181      {
00182        result = ULOGLIN;
00183      }
00184      else if(result == ULOGLIN) 
00185      {
00186        result = ULINLOG;
00187      }
00188      return result;
00189    }

G4InterpolationScheme G4InterpolationManager::GetScheme ( G4int  index  )  const [inline]

Definition at line 132 of file G4InterpolationManager.hh.

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

00133    {
00134      G4int it = 0;
00135      for(G4int i=1; i<nRanges; i++)
00136      {
00137        if(index<start[i]) break;
00138        it = i;
00139      }
00140      return scheme[it];
00141    }

void G4InterpolationManager::Init ( std::ifstream &  aDataFile  )  [inline]

Definition at line 102 of file G4InterpolationManager.hh.

References MakeScheme().

00103    {
00104      delete [] start;
00105      delete [] range;
00106      delete [] scheme;
00107      aDataFile >> nRanges;
00108      start = new G4int[nRanges];
00109      range = new G4int[nRanges];
00110      scheme = new G4InterpolationScheme[nRanges];
00111      start[0] = 0;
00112      G4int it;
00113      for(G4int i=0; i<nRanges; i++)
00114      {
00115        aDataFile>>range[i];
00116        //***************************************************************
00117        //EMendoza -> there is a bug here.
00118        /*
00119        if(i!=0) start[i] = start[i-1]+range[i-1];
00120        */
00121        //***************************************************************
00122        if(i!=0) start[i] = range[i-1];
00123        //***************************************************************
00124        aDataFile>>it;
00125        scheme[i] = MakeScheme(it);
00126      }
00127      nEntries = start[nRanges-1]+range[nRanges-1];
00128    }

void G4InterpolationManager::Init ( G4InterpolationScheme  aScheme,
G4int  aRange 
) [inline]

Definition at line 93 of file G4InterpolationManager.hh.

00094    {
00095      nRanges = 1;
00096      start[0] = 0;
00097      range [0] = aRange;
00098      scheme[0] = aScheme;
00099      nEntries = aRange;
00100    }

void G4InterpolationManager::Init ( G4int  aScheme,
G4int  aRange 
) [inline]

Definition at line 85 of file G4InterpolationManager.hh.

References MakeScheme().

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

00086    {
00087      nRanges = 1;
00088      start[0] = 0;
00089      range [0] = aRange;
00090      scheme[0] = MakeScheme(aScheme);
00091      nEntries = aRange;
00092    }

G4InterpolationScheme G4InterpolationManager::MakeScheme ( G4int  it  ) 

Definition at line 33 of file G4InterpolationManager.cc.

References CHISTO, CLINLIN, CLINLOG, CLOGLIN, CLOGLOG, HISTO, LINLIN, LINLOG, LOGLIN, LOGLOG, UHISTO, ULINLIN, ULINLOG, ULOGLIN, and ULOGLOG.

Referenced by Init().

00034    {
00035      G4InterpolationScheme result(LINLIN);
00036      switch(it)
00037      {
00038       case 1:
00039         result = HISTO;
00040         break;
00041       case 2:
00042         result = LINLIN;
00043         break;
00044       case 3:
00045         result = LINLOG;
00046         break;
00047       case 4:
00048         result = LOGLIN;
00049         break;
00050       case 5:
00051         result = LOGLOG;
00052         break;
00053       case 11:
00054         result = CHISTO;
00055         break;
00056       case 12:
00057         result = CLINLIN;
00058         break;
00059       case 13:
00060         result = CLINLOG;
00061         break;
00062       case 14:
00063         result = CLOGLIN;
00064         break;
00065       case 15:
00066         result = CLOGLOG;
00067         break;
00068       case 21:
00069         result = UHISTO;
00070         break;
00071       case 22:
00072         result = ULINLIN;
00073         break;
00074       case 23:
00075         result = ULINLOG;
00076         break;
00077       case 24:
00078         result = ULOGLIN;
00079         break;
00080       case 25:
00081         result = ULOGLOG;
00082         break;
00083       default:
00084         throw G4HadronicException(__FILE__, __LINE__, "G4InterpolationManager: unknown interpolation scheme");
00085         break;        
00086      }
00087      return result;
00088    }

G4InterpolationManager& G4InterpolationManager::operator= ( const G4InterpolationManager aManager  )  [inline]

Definition at line 63 of file G4InterpolationManager.hh.

References nEntries, nRanges, range, scheme, and start.

00064    {
00065      if(this != &aManager)
00066      {
00067        nRanges = aManager.nRanges;
00068        nEntries = aManager.nEntries;
00069        if(scheme!=0) delete [] scheme;
00070        if(start!=0) delete [] start;
00071        if(range!=0) delete [] range;
00072        scheme = new G4InterpolationScheme[nRanges];
00073        start = new G4int[nRanges];
00074        range = new G4int[nRanges];
00075        for(G4int i=0; i<nRanges; i++)
00076        {
00077          scheme[i]=aManager.scheme[i];
00078          start[i]=aManager.start[i];
00079          range[i]=aManager.range[i];
00080        }
00081      }
00082      return *this;
00083    }


Friends And Related Function Documentation

friend class G4InterpolationIterator [friend]

Definition at line 42 of file G4InterpolationManager.hh.


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:16 2013 for Geant4 by  doxygen 1.4.7