G4ParticleHPPartial Class Reference

#include <G4ParticleHPPartial.hh>

Public Member Functions
	G4ParticleHPPartial (G4int n)
	G4ParticleHPPartial (G4int n1, G4int n2)
void	InitInterpolation (G4int i, std::istream &aDataFile)
void	InitInterpolation (std::istream &aDataFile)
void	Init (std::istream &aDataFile)
void	InitData (G4int i, std::istream &aDataFile, G4double unit=1.)
	~G4ParticleHPPartial ()
G4int	GetNumberOfEnergies ()
void	SetX (G4int i, G4double x)
void	SetT (G4int i, G4double x)
void	SetX (G4int i, G4int j, G4double x)
void	SetY (G4int i, G4int j, G4double y)
void	DoneSetXY (G4int i)
G4double	GetX (G4int i)
G4double	GetT (G4int i)
G4double	GetX (G4int i, G4int j)
G4double	GetY (G4int i, G4int j)
G4double	GetY (G4int i, G4double e)
G4int	GetNEntries (G4int i)
G4ParticleHPVector *	GetY (G4double e1)
G4double	Sample (G4double x)

Detailed Description

Definition at line 41 of file G4ParticleHPPartial.hh.

Constructor & Destructor Documentation

G4ParticleHPPartial() [1/2]

G4ParticleHPPartial::G4ParticleHPPartial ( G4int n )

inline

Definition at line 44 of file G4ParticleHPPartial.hh.

    {
      X = new G4double[n];
      data = new G4ParticleHPVector[n];
      nData = n;
      T = nullptr;
    }

G4ParticleHPPartial() [2/2]

G4ParticleHPPartial::G4ParticleHPPartial ( G4int n1, G4int n2 )

inline

Definition at line 52 of file G4ParticleHPPartial.hh.

    {
      T = new G4double[n2];
      X = new G4double[n1];
      data = new G4ParticleHPVector[n1];
      nData = std::max(n1, n2);
    }

~G4ParticleHPPartial()

G4ParticleHPPartial::~G4ParticleHPPartial ( )

inline

Definition at line 95 of file G4ParticleHPPartial.hh.

    {
      delete[] X;
      delete[] T;
      delete[] data;
    }

Member Function Documentation

DoneSetXY()

void G4ParticleHPPartial::DoneSetXY ( G4int i )

inline

Definition at line 107 of file G4ParticleHPPartial.hh.

{ data[i].Hash(); }

GetNEntries()

G4int G4ParticleHPPartial::GetNEntries ( G4int i )

inline

Definition at line 114 of file G4ParticleHPPartial.hh.

{ return data[i].GetVectorLength(); }

Referenced by Sample().

GetNumberOfEnergies()

G4int G4ParticleHPPartial::GetNumberOfEnergies ( )

inline

Definition at line 101 of file G4ParticleHPPartial.hh.

{ return nData; }

GetT()

G4double G4ParticleHPPartial::GetT ( G4int i )

inline

Definition at line 110 of file G4ParticleHPPartial.hh.

{ return T[i]; }

GetX() [1/2]

G4double G4ParticleHPPartial::GetX ( G4int i )

inline

Definition at line 109 of file G4ParticleHPPartial.hh.

{ return X[i]; }

Referenced by GetY(), and Sample().

GetX() [2/2]

G4double G4ParticleHPPartial::GetX ( G4int i, G4int j )

inline

Definition at line 111 of file G4ParticleHPPartial.hh.

{ return data[i].GetX(j); }

GetY() [1/3]

G4ParticleHPVector * G4ParticleHPPartial::GetY

(

G4double

e1

)

Definition at line 39 of file G4ParticleHPPartial.cc.

{
  auto aBuffer = new G4ParticleHPVector();
  G4int i;
  if (nData == 1) {
    for (i = 0; i < data[0].GetVectorLength(); i++) {
      aBuffer->SetInterpolationManager(data[0].GetInterpolationManager());
      aBuffer->SetData(i, data[0].GetX(i), data[0].GetY(i));
    }
    return aBuffer;
  }
  for (i = 0; i < nData; i++) {
    if (X[i] > e1) break;
  }
  if (i == nData) i--;
  if (0 == i) i = 1;
  G4double x1, x2, y1, y2, y;
  G4int i1 = 0, ib = 0;
  G4double E1 = X[i - 1];
  G4double E2 = X[i];
  for (G4int ii = 0; ii < data[i].GetVectorLength(); ii++) {
    x1 = data[i - 1].GetX(std::min(i1, data[i - 1].GetVectorLength() - 1));
    x2 = data[i].GetX(ii);
    if (x1 < x2 && i1 < data[i - 1].GetVectorLength()) {
      y1 = data[i - 1].GetY(i1);
      y2 = data[i].GetY(x1);
      if (E2 - E1 != 0) {
        y = theInt.Interpolate(theManager.GetScheme(i), e1, E1, E2, y1, y2);
      }
      else {
        y = 0.5 * (y1 + y2);
      }
      aBuffer->SetData(ib, x1, y);
      aBuffer->SetScheme(ib++, data[i - 1].GetScheme(i1));
      i1++;
      if (x2 - x1 > 0.001 * x1) {
        ii--;
      }
    }
    else {
      y1 = data[i - 1].GetY(x2);
      y2 = data[i].GetY(ii);
      if (E2 - E1 != 0) {
        y = theInt.Interpolate(theManager.GetScheme(i), e1, E1, E2, y1, y2);
      }
      else {
        y = 0.5 * (y1 + y2);
      }
      aBuffer->SetData(ib, x2, y);
      aBuffer->SetScheme(ib++, data[i].GetScheme(ii));
      if (x1 - x2 < 0.001 * x2) i1++;
    }
  }
  return aBuffer;
}

GetY() [2/3]

G4double G4ParticleHPPartial::GetY ( G4int i, G4double e )

inline

Definition at line 113 of file G4ParticleHPPartial.hh.

{ return data[i].GetY(e); }

GetY() [3/3]

G4double G4ParticleHPPartial::GetY ( G4int i, G4int j )

inline

Definition at line 112 of file G4ParticleHPPartial.hh.

{ return data[i].GetY(j); }

Referenced by GetY(), and Sample().

Init()

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

inline

Definition at line 67 of file G4ParticleHPPartial.hh.

    {
      G4int i;
      G4double e;
      for (i = 0; i < nData; i++) {
        aDataFile >> e;
        e *= CLHEP::eV;
        SetX(i, e);
        InitData(i, aDataFile, CLHEP::eV);  // energy and probability for gammas
      }
    }

InitData()

void G4ParticleHPPartial::InitData ( G4int i, std::istream & aDataFile, G4double unit = 1. )

inline

Definition at line 79 of file G4ParticleHPPartial.hh.

    {
      G4int ii;
      G4double eg, pg;
      G4int neg;
      aDataFile >> neg;
      data[i].InitInterpolation(aDataFile);
      for (ii = 0; ii < neg; ii++) {
        aDataFile >> eg >> pg;
        eg *= unit;
        SetX(i, ii, eg);
        SetY(i, ii, pg);
      }
      data[i].Hash();
    }

Referenced by Init().

InitInterpolation() [1/2]

void G4ParticleHPPartial::InitInterpolation ( G4int i, std::istream & aDataFile )

inline

Definition at line 60 of file G4ParticleHPPartial.hh.

    {
      data[i].InitInterpolation(aDataFile);
    }

InitInterpolation() [2/2]

void G4ParticleHPPartial::InitInterpolation ( std::istream & aDataFile )

inline

Definition at line 65 of file G4ParticleHPPartial.hh.

{ theManager.Init(aDataFile); }

Sample()

G4double G4ParticleHPPartial::Sample

(

G4double

x

)

Definition at line 95 of file G4ParticleHPPartial.cc.

{
  G4int i;
  for (i = 0; i < nData; i++) {
    if (x < X[i]) break;
  }
  G4ParticleHPVector theBuff;
  if (i == 0) {
    theBuff.SetInterpolationManager(data[0].GetInterpolationManager());
    for (G4int ii = 0; ii < GetNEntries(0); ii++) {
      theBuff.SetX(ii, GetX(0, ii));
      theBuff.SetY(ii, GetY(0, ii));
    }
  }
  // else if(i==nData-1) this line will be delete
  else if (i == nData) {
    for (i = 0; i < GetNEntries(nData - 1); i++) {
      theBuff.SetX(i, GetX(nData - 1, i));
      theBuff.SetY(i, GetY(nData - 1, i));
      theBuff.SetInterpolationManager(data[nData - 1].GetInterpolationManager());
    }
  }
  else {
    G4int low = i - 1;
    G4int high = low + 1;
    G4double x1, x2, y1, y2;
    G4int i1 = 0, i2 = 0, ii = 0;
    x1 = X[low];
    x2 = X[high];
    while (i1 < GetNEntries(low) || i2 < GetNEntries(high))  // Loop checking, 11.05.2015, T. Koi
    {
      if ((GetX(low, i1) < GetX(high, i2) && i1 < GetNEntries(low)) || (i2 == GetNEntries(high))) {
        theBuff.SetX(ii, GetX(low, i1));
        y1 = GetY(low, i1);
        y2 = GetY(high, GetX(low, i1));  // prob at ident theta
        theBuff.SetY(ii, theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, y1,
                                            y2));  // energy interpol
        theBuff.SetScheme(ii, data[low].GetScheme(i1));
        if (std::abs(GetX(low, i1) - GetX(high, i2)) < 0.001) i2++;
        i1++;
        ii++;
      }
      else {
        theBuff.SetX(ii, GetX(high, i2));
        //*******************************************************************************
        // Change by E.Mendoza and D.Cano (CIEMAT):
        // y1 = GetY(high,i2);
        // y2 = GetY(low, GetX(high,i2));  //prob at ident theta
        y2 = GetY(high, i2);
        y1 = GetY(low, GetX(high, i2));  // prob at ident theta
        //*******************************************************************************
        theBuff.SetY(ii, theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, y1,
                                            y2));  // energy interpol
        theBuff.SetScheme(ii, data[high].GetScheme(i2));
        if (std::abs(GetX(low, i1) - GetX(high, i2)) < 0.001) i1++;
        i2++;
        ii++;
      }
    }
  }
  // buff is full, now sample.
  return theBuff.Sample();
}

SetT()

void G4ParticleHPPartial::SetT ( G4int i, G4double x )

inline

Definition at line 104 of file G4ParticleHPPartial.hh.

{ T[i] = x; }

SetX() [1/2]

void G4ParticleHPPartial::SetX ( G4int i, G4double x )

inline

Definition at line 103 of file G4ParticleHPPartial.hh.

{ X[i] = x; }

Referenced by Init(), and InitData().

SetX() [2/2]

void G4ParticleHPPartial::SetX ( G4int i, G4int j, G4double x )

inline

Definition at line 105 of file G4ParticleHPPartial.hh.

{ data[i].SetX(j, x); }

SetY()

void G4ParticleHPPartial::SetY ( G4int i, G4int j, G4double y )

inline

Definition at line 106 of file G4ParticleHPPartial.hh.

{ data[i].SetY(j, y); }

Referenced by InitData().

---

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

• G4ParticleHPPartial.hh
• G4ParticleHPPartial.cc