G4NeutronHPPartial Class Reference

#include <G4NeutronHPPartial.hh>

Public Member Functions
	G4NeutronHPPartial (G4int n)
	G4NeutronHPPartial (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.)
	~G4NeutronHPPartial ()
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)
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)
G4NeutronHPVector *	GetY (G4double e1)
G4double	Sample (G4double x)

Detailed Description

Definition at line 40 of file G4NeutronHPPartial.hh.

Constructor & Destructor Documentation

G4NeutronHPPartial::G4NeutronHPPartial ( G4int  n )

inline

Definition at line 44 of file G4NeutronHPPartial.hh.

References n.

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

G4NeutronHPPartial::G4NeutronHPPartial ( G4int  n1, G4int  n2  )

inline

Definition at line 52 of file G4NeutronHPPartial.hh.

References G4INCL::Math::max().

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

G4NeutronHPPartial::~G4NeutronHPPartial ( )

inline

Definition at line 99 of file G4NeutronHPPartial.hh.

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

Member Function Documentation

G4int G4NeutronHPPartial::GetNEntries ( G4int  i )

inline

Definition at line 117 of file G4NeutronHPPartial.hh.

Referenced by Sample().

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

G4int G4NeutronHPPartial::GetNumberOfEnergies ( )

inline

Definition at line 105 of file G4NeutronHPPartial.hh.

{return nData;}

G4double G4NeutronHPPartial::GetT ( G4int  i )

inline

Definition at line 113 of file G4NeutronHPPartial.hh.

{return T[i];}

G4double G4NeutronHPPartial::GetX ( G4int  i )

inline

Definition at line 112 of file G4NeutronHPPartial.hh.

Referenced by GetY(), and Sample().

{return X[i];}

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

inline

Definition at line 114 of file G4NeutronHPPartial.hh.

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

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

inline

Definition at line 115 of file G4NeutronHPPartial.hh.

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

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

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

inline

Definition at line 116 of file G4NeutronHPPartial.hh.

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

G4NeutronHPVector * G4NeutronHPPartial::GetY

(

G4double

e1

)

Definition at line 36 of file G4NeutronHPPartial.cc.

References G4InterpolationManager::GetScheme(), GetX(), GetY(), G4NeutronHPInterpolator::Interpolate(), G4INCL::Math::min(), G4NeutronHPVector::SetData(), G4NeutronHPVector::SetInterpolationManager(), and G4NeutronHPVector::SetScheme().

  {
    G4NeutronHPVector * aBuffer = new G4NeutronHPVector();
    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;
  }

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

inline

Definition at line 70 of file G4NeutronHPPartial.hh.

References InitData(), and SetX().

Referenced by G4NeutronHPPhotonDist::InitEnergies().

  {
    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
    }  
  }

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

inline

Definition at line 83 of file G4NeutronHPPartial.hh.

References testem0::pg, SetX(), and SetY().

Referenced by G4NeutronHPAngular::Init(), and Init().

  {
    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);
    }          
  }

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

inline

Definition at line 60 of file G4NeutronHPPartial.hh.

Referenced by G4NeutronHPElasticFS::Init(), G4NeutronHPAngular::Init(), and G4NeutronHPPhotonDist::InitEnergies().

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

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

inline

Definition at line 65 of file G4NeutronHPPartial.hh.

References G4InterpolationManager::Init().

  {
    theManager.Init(aDataFile);
  }

G4double G4NeutronHPPartial::Sample

(

G4double

x

)

Definition at line 103 of file G4NeutronHPPartial.cc.

References GetNEntries(), G4InterpolationManager::GetScheme(), GetX(), GetY(), G4NeutronHPInterpolator::Interpolate(), G4NeutronHPVector::Sample(), G4NeutronHPVector::SetInterpolationManager(), G4NeutronHPVector::SetScheme(), G4NeutronHPVector::SetX(), G4NeutronHPVector::SetY(), and test::x.

Referenced by G4NeutronHPElasticFS::ApplyYourself(), and G4NeutronHPAngular::SampleAndUpdate().

  {
    G4int i;
    for (i=0; i<nData; i++)
    {
      if(x<X[i]) break;
    }
    G4NeutronHPVector 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))
      {
    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();
  }

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

inline

Definition at line 108 of file G4NeutronHPPartial.hh.

References test::x.

Referenced by G4NeutronHPElasticFS::Init(), and G4NeutronHPAngular::Init().

{T[i]=x;}

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

inline

Definition at line 107 of file G4NeutronHPPartial.hh.

References test::x.

Referenced by G4NeutronHPElasticFS::Init(), G4NeutronHPAngular::Init(), Init(), and InitData().

{X[i]=x;}

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

inline

Definition at line 109 of file G4NeutronHPPartial.hh.

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

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

inline

Definition at line 110 of file G4NeutronHPPartial.hh.

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

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

---

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

• G4NeutronHPPartial.hh
• G4NeutronHPPartial.cc