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::istream &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 43 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;
    }

Referenced by operator=().

~G4InterpolationManager()

G4InterpolationManager::~G4InterpolationManager ( )

inline

Definition at line 55 of file G4InterpolationManager.hh.

    {
      delete[] start;
      delete[] range;
      delete[] scheme;
    }

Member Function Documentation

AppendScheme()

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

Definition at line 91 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;
    auto buffer = new G4int[nRanges];
    auto buffer1 = new G4int[nRanges];
    auto 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;
  }
}

CleanUp()

void G4InterpolationManager::CleanUp ( )

inline

Definition at line 138 of file G4InterpolationManager.hh.

    {
      nRanges = 0;
      nEntries = 0;
    }

GetInverseScheme()

G4InterpolationScheme G4InterpolationManager::GetInverseScheme ( G4int index )

inline

Definition at line 144 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;
    }

GetScheme()

G4InterpolationScheme G4InterpolationManager::GetScheme ( G4int index ) const

inline

Definition at line 128 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 GetInverseScheme().

Init() [1/3]

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

inline

Definition at line 82 of file G4InterpolationManager.hh.

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

Referenced by G4ParticleHPContAngularPar::Sample(), and G4ParticleHPDiscreteTwoBody::Sample().

Init() [2/3]

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

inline

Definition at line 90 of file G4InterpolationManager.hh.

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

Init() [3/3]

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

inline

Definition at line 99 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 34 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(), and Init().

operator=()

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

inline

Definition at line 62 of file G4InterpolationManager.hh.

    {
      if (this != &aManager) {
        nRanges = aManager.nRanges;
        nEntries = aManager.nEntries;
        delete[] scheme;
        delete[] start;
        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 Symbol Documentation

G4InterpolationIterator

friend class G4InterpolationIterator

friend

Definition at line 41 of file G4InterpolationManager.hh.

Referenced by G4InterpolationIterator.

---

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

• G4InterpolationManager.hh
• G4InterpolationManager.cc