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 45 of file G4ParticleHPPartial.hh.

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

G4ParticleHPPartial() [2/2]

G4ParticleHPPartial::G4ParticleHPPartial ( G4int  n1, G4int  n2  )

inline

Definition at line 53 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 101 of file G4ParticleHPPartial.hh.

  {
    delete [] X;
    if(T!=0) delete [] T;
    delete [] data;
  }

Member Function Documentation

DoneSetXY()

void G4ParticleHPPartial::DoneSetXY ( G4int  i )

inline

Definition at line 113 of file G4ParticleHPPartial.hh.

{ data[i].Hash(); }

Referenced by G4ParticleHPElasticFS::Init().

GetNEntries()

G4int G4ParticleHPPartial::GetNEntries ( G4int  i )

inline

Definition at line 120 of file G4ParticleHPPartial.hh.

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

Referenced by Sample().

GetNumberOfEnergies()

G4int G4ParticleHPPartial::GetNumberOfEnergies ( )

inline

Definition at line 107 of file G4ParticleHPPartial.hh.

{return nData;}

GetT()

G4double G4ParticleHPPartial::GetT ( G4int  i )

inline

Definition at line 116 of file G4ParticleHPPartial.hh.

{return T[i];}

GetX() [1/2]

G4double G4ParticleHPPartial::GetX ( G4int  i )

inline

Definition at line 115 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 117 of file G4ParticleHPPartial.hh.

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

GetY() [1/3]

G4ParticleHPVector * G4ParticleHPPartial::GetY

(

G4double

e1

)

Definition at line 38 of file G4ParticleHPPartial.cc.

  {
    G4ParticleHPVector * 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 119 of file G4ParticleHPPartial.hh.

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

GetY() [3/3]

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

inline

Definition at line 118 of file G4ParticleHPPartial.hh.

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

Referenced by G4ParticleHPPhotonDist::GetPhotons(), GetY(), and Sample().

Init()

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

inline

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

Referenced by G4ParticleHPPhotonDist::InitEnergies().

InitData()

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

inline

Definition at line 84 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 G4ParticleHPAngular::Init(), and Init().

InitInterpolation() [1/2]

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

inline

Definition at line 61 of file G4ParticleHPPartial.hh.

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

Referenced by G4ParticleHPElasticFS::Init(), G4ParticleHPAngular::Init(), and G4ParticleHPPhotonDist::InitEnergies().

InitInterpolation() [2/2]

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

inline

Definition at line 66 of file G4ParticleHPPartial.hh.

  {
    theManager.Init(aDataFile);
  }

Sample()

G4double G4ParticleHPPartial::Sample

(

G4double

x

)

Definition at line 105 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();
  }

Referenced by G4ParticleHPElasticFS::ApplyYourself(), and G4ParticleHPAngular::SampleAndUpdate().

SetT()

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

inline

Definition at line 110 of file G4ParticleHPPartial.hh.

{T[i]=x;}

Referenced by G4ParticleHPElasticFS::Init(), and G4ParticleHPAngular::Init().

SetX() [1/2]

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

inline

Definition at line 109 of file G4ParticleHPPartial.hh.

{X[i]=x;}

Referenced by G4ParticleHPElasticFS::Init(), G4ParticleHPAngular::Init(), Init(), and InitData().

SetX() [2/2]

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

inline

Definition at line 111 of file G4ParticleHPPartial.hh.

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

SetY()

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

inline

Definition at line 112 of file G4ParticleHPPartial.hh.

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

Referenced by G4ParticleHPElasticFS::Init(), and InitData().

---

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

• G4ParticleHPPartial.hh
• G4ParticleHPPartial.cc