G4ParticleHPVector Class Reference

#include <G4ParticleHPVector.hh>

Collaboration diagram for G4ParticleHPVector:

Public Member Functions
	G4ParticleHPVector ()
	G4ParticleHPVector (G4int n)
	~G4ParticleHPVector ()
G4ParticleHPVector &	operator= (const G4ParticleHPVector &right)
void	SetVerbose (G4int ff)
void	Times (G4double factor)
void	SetPoint (G4int i, const G4ParticleHPDataPoint &it)
void	SetData (G4int i, G4double x, G4double y)
void	SetX (G4int i, G4double e)
void	SetEnergy (G4int i, G4double e)
void	SetY (G4int i, G4double x)
void	SetXsec (G4int i, G4double x)
G4double	GetEnergy (G4int i) const
G4double	GetXsec (G4int i)
G4double	GetX (G4int i) const
const G4ParticleHPDataPoint &	GetPoint (G4int i) const
void	Hash ()
void	ReHash ()
G4double	GetXsec (G4double e)
G4double	GetXsec (G4double e, G4int min)
G4double	GetY (G4double x)
G4int	GetVectorLength () const
G4double	GetY (G4int i)
G4double	GetY (G4int i) const
void	Dump ()
void	InitInterpolation (std::istream &aDataFile)
void	Init (std::istream &aDataFile, G4int total, G4double ux=1., G4double uy=1.)
void	Init (std::istream &aDataFile, G4double ux=1., G4double uy=1.)
void	ThinOut (G4double precision)
void	SetLabel (G4double aLabel)
G4double	GetLabel ()
void	CleanUp ()
void	Merge (G4ParticleHPVector *active, G4ParticleHPVector *passive)
void	Merge (G4InterpolationScheme aScheme, G4double aValue, G4ParticleHPVector *active, G4ParticleHPVector *passive)
G4double	SampleLin ()
G4double	Sample ()
G4double *	Debug ()
void	IntegrateAndNormalise ()
void	Integrate ()
G4double	GetIntegral ()
void	SetInterpolationManager (const G4InterpolationManager &aManager)
const G4InterpolationManager &	GetInterpolationManager () const
void	SetInterpolationManager (G4InterpolationManager &aMan)
void	SetScheme (G4int aPoint, const G4InterpolationScheme &aScheme)
G4InterpolationScheme	GetScheme (G4int anIndex)
G4double	GetMeanX ()
std::vector< G4double >	GetBlocked ()
std::vector< G4double >	GetBuffered ()
G4double	Get15percentBorder ()
G4double	Get50percentBorder ()

Private Member Functions
void	Check (G4int i)
G4bool	IsBlocked (G4double aX)

Private Attributes
G4ParticleHPInterpolator	theLin
G4double	totalIntegral
G4ParticleHPDataPoint *	theData
G4InterpolationManager	theManager
G4double *	theIntegral
G4int	nEntries
G4int	nPoints
G4double	label
G4ParticleHPInterpolator	theInt
G4int	Verbose
G4int	isFreed
G4ParticleHPHash	theHash
G4double	maxValue
std::vector< G4double >	theBlocked
std::vector< G4double >	theBuffered
G4double	the15percentBorderCash
G4double	the50percentBorderCash

Friends
G4ParticleHPVector &	operator+ (G4ParticleHPVector &left, G4ParticleHPVector &right)

Detailed Description

Definition at line 56 of file G4ParticleHPVector.hh.

Constructor & Destructor Documentation

G4ParticleHPVector() [1/2]

G4ParticleHPVector::G4ParticleHPVector

(

)

Definition at line 83 of file G4ParticleHPVector.cc.

  {
    theData = new G4ParticleHPDataPoint[20]; 
    nPoints=20;
    nEntries=0;
    Verbose=0;
    theIntegral=0;
    totalIntegral=-1;
    isFreed = 0;
    maxValue = -DBL_MAX;
    the15percentBorderCash = -DBL_MAX;
    the50percentBorderCash = -DBL_MAX;
    label = -DBL_MAX;
  }

G4ParticleHPVector() [2/2]

G4ParticleHPVector::G4ParticleHPVector

(

G4int

n

)

Definition at line 98 of file G4ParticleHPVector.cc.

  {
    nPoints=std::max(n, 20);
    theData = new G4ParticleHPDataPoint[nPoints]; 
    nEntries=0;
    Verbose=0;
    theIntegral=0;
    totalIntegral=-1;
    isFreed = 0;
    maxValue = -DBL_MAX;
    the15percentBorderCash = -DBL_MAX;
    the50percentBorderCash = -DBL_MAX;
    label = -DBL_MAX;
  }

~G4ParticleHPVector()

G4ParticleHPVector::~G4ParticleHPVector

(

)

Definition at line 113 of file G4ParticleHPVector.cc.

  {
//    if(Verbose==1)G4cout <<"G4ParticleHPVector::~G4ParticleHPVector"<<G4endl;
      delete [] theData;
//    if(Verbose==1)G4cout <<"Vector: delete theData"<<G4endl;
      delete [] theIntegral;
//    if(Verbose==1)G4cout <<"Vector: delete theIntegral"<<G4endl;
    theHash.Clear();
    isFreed = 1;
  }

Here is the call graph for this function:

Member Function Documentation

Check()

void G4ParticleHPVector::Check ( G4int  i )

private

Definition at line 218 of file G4ParticleHPVector.cc.

  {
    if(i>nEntries) throw G4HadronicException(__FILE__, __LINE__, "Skipped some index numbers in G4ParticleHPVector");
    if(i==nPoints)
    {
      nPoints = static_cast<G4int>(1.2*nPoints);
      G4ParticleHPDataPoint * buff = new G4ParticleHPDataPoint[nPoints];
      for (G4int j=0; j<nEntries; j++) buff[j] = theData[j];
      delete [] theData;
      theData = buff;
    }
    if(i==nEntries) nEntries=i+1;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

CleanUp()

void G4ParticleHPVector::CleanUp ( )

inline

Definition at line 261 of file G4ParticleHPVector.hh.

  {
    nEntries=0;   
    theManager.CleanUp();
    maxValue = -DBL_MAX;
    theHash.Clear();
//080811 TK DB 
    delete[] theIntegral;
    theIntegral = NULL;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Debug()

G4double* G4ParticleHPVector::Debug ( )

inline

Definition at line 368 of file G4ParticleHPVector.hh.

  {
    return theIntegral;
  }

Dump()

void G4ParticleHPVector::Dump

(

)

Definition at line 205 of file G4ParticleHPVector.cc.

  {
    G4cout << nEntries<<G4endl;
    for(G4int i=0; i<nEntries; i++)
    {
      G4cout << theData[i].GetX()<<" ";
      G4cout << theData[i].GetY()<<" ";
//      if (i!=1&&i==5*(i/5)) G4cout << G4endl;
      G4cout << G4endl;
    }
    G4cout << G4endl;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Get15percentBorder()

G4double G4ParticleHPVector::Get15percentBorder

(

)

Definition at line 466 of file G4ParticleHPVector.cc.

  {    
    if(the15percentBorderCash>-DBL_MAX/2.) return the15percentBorderCash;
    G4double result;
    if(GetVectorLength()==1)
    {
      result = theData[0].GetX();
      the15percentBorderCash = result;
    }
    else
    {
      if(theIntegral==0) { IntegrateAndNormalise(); }
      G4int i;
      result = theData[GetVectorLength()-1].GetX();
      for(i=0;i<GetVectorLength();i++)
      {
    if(theIntegral[i]/theIntegral[GetVectorLength()-1]>0.15) 
    {
      result = theData[std::min(i+1, GetVectorLength()-1)].GetX();
          the15percentBorderCash = result;
      break;
    }
      }
      the15percentBorderCash = result;
    }
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Get50percentBorder()

G4double G4ParticleHPVector::Get50percentBorder

(

)

Definition at line 494 of file G4ParticleHPVector.cc.

  {    
    if(the50percentBorderCash>-DBL_MAX/2.) return the50percentBorderCash;
    G4double result;
    if(GetVectorLength()==1)
    {
      result = theData[0].GetX();
      the50percentBorderCash = result;
    }
    else
    {
      if(theIntegral==0) { IntegrateAndNormalise(); }
      G4int i;
      G4double x = 0.5;
      result = theData[GetVectorLength()-1].GetX();
      for(i=0;i<GetVectorLength();i++)
      {
    if(theIntegral[i]/theIntegral[GetVectorLength()-1]>x) 
    {
      G4int it;
      it = i;
      if(it == GetVectorLength()-1)
      {
        result = theData[GetVectorLength()-1].GetX();
      }
      else
      {
        G4double x1, x2, y1, y2;
        x1 = theIntegral[i-1]/theIntegral[GetVectorLength()-1];
        x2 = theIntegral[i]/theIntegral[GetVectorLength()-1];
        y1 = theData[i-1].GetX();
        y2 = theData[i].GetX();
        result = theLin.Lin(x, x1, x2, y1, y2);
      }
          the50percentBorderCash = result;
      break;
    }
      }
      the50percentBorderCash = result;
    }
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetBlocked()

std::vector<G4double> G4ParticleHPVector::GetBlocked ( )

inline

Definition at line 538 of file G4ParticleHPVector.hh.

{return theBlocked;}

GetBuffered()

std::vector<G4double> G4ParticleHPVector::GetBuffered ( )

inline

Definition at line 539 of file G4ParticleHPVector.hh.

{return theBuffered;}

Here is the call graph for this function:

GetEnergy()

G4double G4ParticleHPVector::GetEnergy ( G4int  i ) const

inline

Definition at line 125 of file G4ParticleHPVector.hh.

{ return theData[i].GetX(); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetIntegral()

G4double G4ParticleHPVector::GetIntegral ( )

inline

Definition at line 477 of file G4ParticleHPVector.hh.

  { 
    if(totalIntegral<-0.5) Integrate();
    return totalIntegral; 
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetInterpolationManager()

const G4InterpolationManager& G4ParticleHPVector::GetInterpolationManager ( ) const

inline

Definition at line 488 of file G4ParticleHPVector.hh.

  {
    return theManager;
  }

Here is the caller graph for this function:

GetLabel()

G4double G4ParticleHPVector::GetLabel ( )

inline

Definition at line 256 of file G4ParticleHPVector.hh.

  {
    return label;
  }

Here is the caller graph for this function:

GetMeanX()

G4double G4ParticleHPVector::GetMeanX ( )

inline

Definition at line 508 of file G4ParticleHPVector.hh.

  {
    G4double result;
    G4double running = 0;
    G4double weighted = 0;
    for(G4int i=1; i<nEntries; i++)
    {
      running += theInt.GetBinIntegral(theManager.GetScheme(i-1),
                           theData[i-1].GetX(), theData[i].GetX(),
                           theData[i-1].GetY(), theData[i].GetY());
      weighted += theInt.GetWeightedBinIntegral(theManager.GetScheme(i-1),
                           theData[i-1].GetX(), theData[i].GetX(),
                           theData[i-1].GetY(), theData[i].GetY());
    }  
    result = weighted / running;  
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetPoint()

const G4ParticleHPDataPoint& G4ParticleHPVector::GetPoint ( G4int  i ) const

inline

Definition at line 133 of file G4ParticleHPVector.hh.

{ return theData[i]; }

Here is the caller graph for this function:

GetScheme()

G4InterpolationScheme G4ParticleHPVector::GetScheme ( G4int  anIndex )

inline

Definition at line 503 of file G4ParticleHPVector.hh.

  {
    return theManager.GetScheme(anIndex);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetVectorLength()

G4int G4ParticleHPVector::GetVectorLength ( ) const

inline

Definition at line 199 of file G4ParticleHPVector.hh.

{return nEntries;}

Here is the caller graph for this function:

GetX()

G4double G4ParticleHPVector::GetX ( G4int  i ) const

inline

Definition at line 127 of file G4ParticleHPVector.hh.

  { 
    if (i<0) i=0;
    if(i>=GetVectorLength()) i=GetVectorLength()-1;
    return theData[i].GetX();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetXsec() [1/3]

G4double G4ParticleHPVector::GetXsec ( G4int  i )

inline

Definition at line 126 of file G4ParticleHPVector.hh.

{ return theData[i].GetY(); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetXsec() [2/3]

G4double G4ParticleHPVector::GetXsec

(

G4double

e

)

Definition at line 149 of file G4ParticleHPVector.cc.

  {
    if(nEntries == 0) return 0;
    //if(!theHash.Prepared()) Hash();
    if ( !theHash.Prepared() ) {
       if ( G4Threading::IsWorkerThread() ) {
          ;
       } else {
          Hash();
       }
    }
    G4int min = theHash.GetMinIndex(e);
    G4int i;
    for(i=min ; i<nEntries; i++)
    {
      //if(theData[i].GetX()>e) break;
      if(theData[i].GetX() >= e) break;
    }
    G4int low = i-1;
    G4int high = i;
    if(i==0)
    {
      low = 0;
      high = 1;
    }
    else if(i==nEntries)
    {
      low = nEntries-2;
      high = nEntries-1;
    }
    G4double y;
    if(e<theData[nEntries-1].GetX()) 
    {
      // Protect against doubled-up x values
      //if( (theData[high].GetX()-theData[low].GetX())/theData[high].GetX() < 0.000001)
      if ( theData[high].GetX() !=0 
       //080808 TKDB
       //&&( theData[high].GetX()-theData[low].GetX())/theData[high].GetX() < 0.000001)
       &&( std::abs( (theData[high].GetX()-theData[low].GetX())/theData[high].GetX() ) < 0.000001 ) )
      {
        y = theData[low].GetY();
      }
      else
      {
        y = theInt.Interpolate(theManager.GetScheme(high), e, 
                               theData[low].GetX(), theData[high].GetX(),
                   theData[low].GetY(), theData[high].GetY());
      }
    }
    else
    {
      y=theData[nEntries-1].GetY();
    }
    return y;
  }

Here is the call graph for this function:

GetXsec() [3/3]

G4double G4ParticleHPVector::GetXsec ( G4double  e, G4int  min  )

inline

Definition at line 157 of file G4ParticleHPVector.hh.

  {
    G4int i;
    for(i=min ; i<nEntries; i++)
    {
      if(theData[i].GetX()>e) break;
    }
    G4int low = i-1;
    G4int high = i;
    if(i==0)
    {
      low = 0;
      high = 1;
    }
    else if(i==nEntries)
    {
      low = nEntries-2;
      high = nEntries-1;
    }
    G4double y;
    if(e<theData[nEntries-1].GetX()) 
    {
      // Protect against doubled-up x values
      if( (theData[high].GetX()-theData[low].GetX())/theData[high].GetX() < 0.000001)
      {
        y = theData[low].GetY();
      }
      else
      {
        y = theInt.Interpolate(theManager.GetScheme(high), e, 
                               theData[low].GetX(), theData[high].GetX(),
                   theData[low].GetY(), theData[high].GetY());
      }
    }
    else
    {
      y=theData[nEntries-1].GetY();
    }
    return y;
  }

Here is the call graph for this function:

GetY() [1/3]

G4double G4ParticleHPVector::GetY ( G4double  x )

inline

Definition at line 198 of file G4ParticleHPVector.hh.

{return GetXsec(x);}

Here is the call graph for this function:

Here is the caller graph for this function:

GetY() [2/3]

G4double G4ParticleHPVector::GetY ( G4int  i )

inline

Definition at line 201 of file G4ParticleHPVector.hh.

  { 
    if (i<0) i=0;
    if(i>=GetVectorLength()) i=GetVectorLength()-1;
    return theData[i].GetY(); 
  }

Here is the call graph for this function:

GetY() [3/3]

G4double G4ParticleHPVector::GetY ( G4int  i ) const

inline

Definition at line 208 of file G4ParticleHPVector.hh.

  {
    if (i<0) i=0;
    if(i>=GetVectorLength()) i=GetVectorLength()-1;
    return theData[i].GetY(); 
  }

Here is the call graph for this function:

Hash()

void G4ParticleHPVector::Hash ( )

inline

Definition at line 135 of file G4ParticleHPVector.hh.

  {
    G4int i;
    G4double x, y;
    for(i=0 ; i<nEntries; i++)
    {
      if(0 == (i+1)%10)
      {
        x = GetX(i);
    y = GetY(i);
    theHash.SetData(i, x, y);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Init() [1/2]

void G4ParticleHPVector::Init ( std::istream &  aDataFile, G4int  total, G4double  ux = 1., G4double  uy = 1.  )

inline

Definition at line 221 of file G4ParticleHPVector.hh.

  {
    G4double x,y;
    for (G4int i=0;i<total;i++)
    {
      aDataFile >> x >> y;
      x*=ux;
      y*=uy;
      SetData(i,x,y);
      if(0 == nEntries%10)
      {
        theHash.SetData(nEntries-1, x, y);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Init() [2/2]

void G4ParticleHPVector::Init ( std::istream &  aDataFile, G4double  ux = 1., G4double  uy = 1.  )

inline

Definition at line 237 of file G4ParticleHPVector.hh.

  {
    G4int total;
    aDataFile >> total;
    if(theData!=0) delete [] theData;
    theData = new G4ParticleHPDataPoint[total]; 
    nPoints=total;
    nEntries=0;    
    theManager.Init(aDataFile);
    Init(aDataFile, total, ux, uy);
  }

Here is the call graph for this function:

InitInterpolation()

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

inline

Definition at line 216 of file G4ParticleHPVector.hh.

  {
    theManager.Init(aDataFile);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Integrate()

void G4ParticleHPVector::Integrate ( )

inline

Definition at line 423 of file G4ParticleHPVector.hh.

  {
    G4int i;
    if(nEntries == 1)
    {
      totalIntegral = 0;
      return;
    }
    G4double sum = 0;
    for(i=1;i<GetVectorLength();i++)
    {
      if(std::abs((theData[i].GetX()-theData[i-1].GetX())/theData[i].GetX())>0.0000001)
      {
        G4double x1 = theData[i-1].GetX();
        G4double x2 = theData[i].GetX();
        G4double y1 = theData[i-1].GetY();
        G4double y2 = theData[i].GetY();
        G4InterpolationScheme aScheme = theManager.GetScheme(i);
        if(aScheme==LINLIN||aScheme==CLINLIN||aScheme==ULINLIN)
        {
          sum+= 0.5*(y2+y1)*(x2-x1);
        }
        else if(aScheme==LINLOG||aScheme==CLINLOG||aScheme==ULINLOG)
        {
          G4double a = y1;
          G4double b = (y2-y1)/(G4Log(x2)-G4Log(x1));
          sum+= (a-b)*(x2-x1) + b*(x2*G4Log(x2)-x1*G4Log(x1));
        }
        else if(aScheme==LOGLIN||aScheme==CLOGLIN||aScheme==ULOGLIN)
        {
          G4double a = G4Log(y1);
          G4double b = (G4Log(y2)-G4Log(y1))/(x2-x1);
          sum += (G4Exp(a)/b)*(G4Exp(b*x2)-G4Exp(b*x1));
        }
        else if(aScheme==HISTO||aScheme==CHISTO||aScheme==UHISTO)
        {
          sum+= y1*(x2-x1);
        }
        else if(aScheme==LOGLOG||aScheme==CLOGLOG||aScheme==ULOGLOG)
        {
          G4double a = G4Log(y1);
          G4double b = (G4Log(y2)-G4Log(y1))/(G4Log(x2)-G4Log(x1));
          sum += (G4Exp(a)/(b+1))*(G4Pow::GetInstance()->powA(x2,b+1)-G4Pow::GetInstance()->powA(x1,b+1));
        }
        else
        {
          throw G4HadronicException(__FILE__, __LINE__, "Unknown interpolation scheme in G4ParticleHPVector::Integrate");
        }
          
      }
    }
    totalIntegral = sum;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

IntegrateAndNormalise()

void G4ParticleHPVector::IntegrateAndNormalise ( )

inline

Definition at line 373 of file G4ParticleHPVector.hh.

  {
    G4int i;
    if(theIntegral!=0) return;
    theIntegral = new G4double[nEntries];
    if(nEntries == 1)
    {
      theIntegral[0] = 1;
      return;
    }
    theIntegral[0] = 0;
    G4double sum = 0;
    G4double x1 = 0;
    G4double x0 = 0;
    for(i=1;i<GetVectorLength();i++)
    {
      x1 = theData[i].GetX();
      x0 = theData[i-1].GetX();
      if (std::abs(x1-x0) > std::abs(x1*0.0000001) )
      {
    //********************************************************************
    //EMendoza -> the interpolation scheme is not always lin-lin
    /*
        sum+= 0.5*(theData[i].GetY()+theData[i-1].GetY())*
                  (x1-x0);
    */
    //********************************************************************
        G4InterpolationScheme aScheme = theManager.GetScheme(i);
        G4double y0 = theData[i-1].GetY();
        G4double y1 = theData[i].GetY();
    G4double integ=theInt.GetBinIntegral(aScheme,x0,x1,y0,y1);
#if defined WIN32-VC
    if(!_finite(integ)){integ=0;}
#elif defined __IBMCPP__
    if(isinf(integ)||isnan(integ)){integ=0;}
#else
    if(std::isinf(integ)||std::isnan(integ)){integ=0;}
#endif
    sum+=integ;
    //********************************************************************
      }
      theIntegral[i] = sum;
    }
    G4double total = theIntegral[GetVectorLength()-1];
    for(i=1;i<GetVectorLength();i++)
    {
      theIntegral[i]/=total;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

IsBlocked()

G4bool G4ParticleHPVector::IsBlocked ( G4double  aX )

private

Definition at line 342 of file G4ParticleHPVector.cc.

  {
    G4bool result = false;
    std::vector<G4double>::iterator i;
    for(i=theBlocked.begin(); i!=theBlocked.end(); i++)
    {
      G4double aBlock = *i;
      if(std::abs(aX-aBlock) < 0.1*MeV)
      {
        result = true;
    theBlocked.erase(i);
    break;
      }
    }
    return result;
  }

Here is the caller graph for this function:

Merge() [1/2]

void G4ParticleHPVector::Merge ( G4ParticleHPVector *  active, G4ParticleHPVector *  passive  )

inline

Definition at line 273 of file G4ParticleHPVector.hh.

  {
    CleanUp();
    G4int s_tmp = 0, n=0, m_tmp=0;
    G4ParticleHPVector * tmp;
    G4int a = s_tmp, p = n, t;
    while (a<active->GetVectorLength()&&p<passive->GetVectorLength()) // Loop checking, 11.05.2015, T. Koi
    {
      if(active->GetEnergy(a) <= passive->GetEnergy(p))
      {
        G4double xa = active->GetEnergy(a);
        G4double yy = active->GetXsec(a);
        SetData(m_tmp, xa, yy);
        theManager.AppendScheme(m_tmp, active->GetScheme(a));
        m_tmp++;
        a++;
        G4double xp = passive->GetEnergy(p);

//080409 TKDB 
        //if( std::abs(std::abs(xp-xa)/xa)<0.001 ) p++;
        if ( !( xa == 0 ) && std::abs(std::abs(xp-xa)/xa)<0.001 ) p++;
      } else {
        tmp = active; 
        t=a;
        active = passive; 
        a=p;
        passive = tmp; 
        p=t;
      }
    }
    while (a!=active->GetVectorLength()) // Loop checking, 11.05.2015, T. Koi
    {
      SetData(m_tmp, active->GetEnergy(a), active->GetXsec(a));
      theManager.AppendScheme(m_tmp++, active->GetScheme(a));
      a++;
    }
    while (p!=passive->GetVectorLength()) // Loop checking, 11.05.2015, T. Koi
    {
      if(std::abs(GetEnergy(m_tmp-1)-passive->GetEnergy(p))/passive->GetEnergy(p)>0.001)
      //if(std::abs(GetEnergy(m)-passive->GetEnergy(p))/passive->GetEnergy(p)>0.001)
      {
        SetData(m_tmp, passive->GetEnergy(p), passive->GetXsec(p));
        theManager.AppendScheme(m_tmp++, active->GetScheme(p));
      }
      p++;
    }
  }    

Here is the call graph for this function:

Here is the caller graph for this function:

Merge() [2/2]

void G4ParticleHPVector::Merge	(	G4InterpolationScheme	aScheme,
		G4double	aValue,
		G4ParticleHPVector *	active,
		G4ParticleHPVector *	passive
	)

Definition at line 233 of file G4ParticleHPVector.cc.

  { 
    // interpolate between labels according to aScheme, cut at aValue, 
    // continue in unknown areas by substraction of the last difference.
    
    CleanUp();
    G4int s_tmp = 0, n=0, m_tmp=0;
    G4ParticleHPVector * tmp;
    G4int a = s_tmp, p = n, t;
    while ( a<active->GetVectorLength() ) // Loop checking, 11.05.2015, T. Koi
    {
      if(active->GetEnergy(a) <= passive->GetEnergy(p))
      {
        G4double xa  = active->GetEnergy(a);
        G4double yy = theInt.Interpolate(aScheme, aValue, active->GetLabel(), passive->GetLabel(),
                                                          active->GetXsec(a), passive->GetXsec(xa));
        SetData(m_tmp, xa, yy);
        theManager.AppendScheme(m_tmp, active->GetScheme(a));
        m_tmp++;
        a++;
        G4double xp = passive->GetEnergy(p);
        //if( std::abs(std::abs(xp-xa)/xa)<0.0000001&&a<active->GetVectorLength() ) 
        if ( xa != 0 
          && std::abs(std::abs(xp-xa)/xa) < 0.0000001 
          && a < active->GetVectorLength() )
        {
          p++;
          tmp = active; t=a;
          active = passive; a=p;
          passive = tmp; p=t;
        }
      } else {
        tmp = active; t=a;
        active = passive; a=p;
        passive = tmp; p=t;
      }
    }
    
    G4double deltaX = passive->GetXsec(GetEnergy(m_tmp-1)) - GetXsec(m_tmp-1);
    while (p!=passive->GetVectorLength()&&passive->GetEnergy(p)<=aValue) // Loop checking, 11.05.2015, T. Koi
    {
      G4double anX;
      anX = passive->GetXsec(p)-deltaX;
      if(anX>0)
      {
        //if(std::abs(GetEnergy(m-1)-passive->GetEnergy(p))/passive->GetEnergy(p)>0.0000001)
        if ( passive->GetEnergy(p) == 0 
          || std::abs(GetEnergy(m_tmp-1)-passive->GetEnergy(p))/passive->GetEnergy(p) > 0.0000001 )
        {
          SetData(m_tmp, passive->GetEnergy(p), anX);
          theManager.AppendScheme(m_tmp++, passive->GetScheme(p));
        }
      }
      p++;
    }
    // Rebuild the Hash;
    if(theHash.Prepared()) 
    {
      ReHash();
    }
  }

Here is the call graph for this function:

operator=()

G4ParticleHPVector & G4ParticleHPVector::operator=

(

const G4ParticleHPVector &

right

)

Definition at line 125 of file G4ParticleHPVector.cc.

  {
    if(&right == this) return *this;
    
    G4int i;
    
    totalIntegral = right.totalIntegral;
    if(right.theIntegral!=0) theIntegral = new G4double[right.nEntries];
    for(i=0; i<right.nEntries; i++)
    {
      SetPoint(i, right.GetPoint(i)); // copy theData
      if(right.theIntegral!=0) theIntegral[i] = right.theIntegral[i];
    }
    theManager = right.theManager; 
    label = right.label;
  
    Verbose = right.Verbose;
    the15percentBorderCash = right.the15percentBorderCash;
    the50percentBorderCash = right.the50percentBorderCash;
    theHash = right.theHash;
   return *this;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReHash()

void G4ParticleHPVector::ReHash ( )

inline

Definition at line 150 of file G4ParticleHPVector.hh.

  {
    theHash.Clear();
    Hash();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Sample()

G4double G4ParticleHPVector::Sample

(

)

Definition at line 359 of file G4ParticleHPVector.cc.

  {
    G4double result;
    G4int j;
    for(j=0; j<GetVectorLength(); j++)
    {
      if(GetY(j)<0) SetY(j, 0);
    }
    
    if(theBuffered.size() !=0 && G4UniformRand()<0.5) 
    {
      result = theBuffered[0];
      theBuffered.erase(theBuffered.begin());
      if(result < GetX(GetVectorLength()-1) ) return result;
    }
    if(GetVectorLength()==1)
    {
      result = theData[0].GetX();
    }
    else
    {
      if(theIntegral==0) { IntegrateAndNormalise(); }
      G4int icounter=0;
      G4int icounter_max=1024;
      do
      {
        icounter++;
        if ( icounter > icounter_max ) {
       G4cout << "Loop-counter exceeded the threshold value at " << __LINE__ << "th line of " << __FILE__ << "." << G4endl;
           break;
        }
//080808
/*
        G4double rand;
        G4double value, test, baseline;
        baseline = theData[GetVectorLength()-1].GetX()-theData[0].GetX();
        do
        {
          value = baseline*G4UniformRand();
          value += theData[0].GetX();
          test = GetY(value)/maxValue;
          rand = G4UniformRand();
        }
        //while(test<rand);
        while( test < rand && test > 0 );
        result = value;
*/
        G4double rand;
        G4double value, test;
        G4int jcounter=0;
        G4int jcounter_max=1024;
        do 
        {
           jcounter++;
           if ( jcounter > jcounter_max ) {
          G4cout << "Loop-counter exceeded the threshold value at " << __LINE__ << "th line of " << __FILE__ << "." << G4endl;
              break;
           }
           rand = G4UniformRand();
           G4int ibin = -1;
           for ( G4int i = 0 ; i < GetVectorLength() ; i++ )
           {
              if ( rand < theIntegral[i] ) 
              {
                 ibin = i; 
                 break;
              }
           }
           if ( ibin < 0 ) G4cout << "TKDB 080807 " << rand << G4endl; 
           // result 
           rand = G4UniformRand();
           G4double x1, x2; 
           if ( ibin == 0 ) 
           {
              x1 = theData[ ibin ].GetX(); 
              value = x1; 
              break;
           }
           else 
           {
              x1 = theData[ ibin-1 ].GetX();
           }
           
           x2 = theData[ ibin ].GetX();
           value = rand * ( x2 - x1 ) + x1;
       //***********************************************************************
       /*
           test = GetY ( value ) / std::max ( GetY( ibin-1 ) , GetY ( ibin ) ); 
       */
       //***********************************************************************
       //EMendoza - Always linear interpolation:
       G4double y1=theData[ ibin-1 ].GetY();
           G4double y2=theData[ ibin ].GetY();
       G4double mval=(y2-y1)/(x2-x1);
       G4double bval=y1-mval*x1;
       test =(mval*value+bval)/std::max ( GetY( ibin-1 ) , GetY ( ibin ) ); 
       //***********************************************************************
        }
        while ( G4UniformRand() > test ); // Loop checking, 11.05.2015, T. Koi
        result = value;
//080807
      }
      while(IsBlocked(result)); // Loop checking, 11.05.2015, T. Koi
    }
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SampleLin()

G4double G4ParticleHPVector::SampleLin ( )

inline

Definition at line 324 of file G4ParticleHPVector.hh.

  {
    G4double result;
    if(theIntegral==0) IntegrateAndNormalise();
    if(GetVectorLength()==1)
    {
      result = theData[0].GetX();
    }
    else
    {
      G4int i;
      G4double rand = G4UniformRand();
      
      // this was replaced 
//      for(i=1;i<GetVectorLength();i++)
//      {
//  if(rand<theIntegral[i]/theIntegral[GetVectorLength()-1]) break;
//      }

// by this (begin)
      for(i=GetVectorLength()-1; i>=0 ;i--)
      {
    if(rand>theIntegral[i]/theIntegral[GetVectorLength()-1]) break;
      }
      if(i!=GetVectorLength()-1) i++;
// until this (end)
      
      G4double x1, x2, y1, y2;
      y1 = theData[i-1].GetX();
      x1 = theIntegral[i-1];
      y2 = theData[i].GetX();
      x2 = theIntegral[i];
      if(std::abs((y2-y1)/y2)<0.0000001) // not really necessary, since the case is excluded by construction
      {
    y1 = theData[i-2].GetX();
    x1 = theIntegral[i-2];
      }
      result = theLin.Lin(rand, x1, x2, y1, y2);
    }
    return result;
  }

Here is the call graph for this function:

SetData()

void G4ParticleHPVector::SetData ( G4int  i, G4double  x, G4double  y  )

inline

Definition at line 96 of file G4ParticleHPVector.hh.

  { 
//    G4cout <<"G4ParticleHPVector::SetData called"<<nPoints<<" "<<nEntries<<G4endl;
    Check(i);
    if(y>maxValue) maxValue=y;
    theData[i].SetData(x, y);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SetEnergy()

void G4ParticleHPVector::SetEnergy ( G4int  i, G4double  e  )

inline

Definition at line 108 of file G4ParticleHPVector.hh.

  {
    Check(i);
    theData[i].SetX(e);
  }

Here is the call graph for this function:

SetInterpolationManager() [1/2]

void G4ParticleHPVector::SetInterpolationManager ( const G4InterpolationManager &  aManager )

inline

Definition at line 483 of file G4ParticleHPVector.hh.

  {
    theManager = aManager;
  }

Here is the caller graph for this function:

SetInterpolationManager() [2/2]

void G4ParticleHPVector::SetInterpolationManager ( G4InterpolationManager &  aMan )

inline

Definition at line 493 of file G4ParticleHPVector.hh.

  {
    theManager = aMan;
  }

SetLabel()

void G4ParticleHPVector::SetLabel ( G4double  aLabel )

inline

Definition at line 251 of file G4ParticleHPVector.hh.

  {
    label = aLabel;
  }

Here is the caller graph for this function:

SetPoint()

void G4ParticleHPVector::SetPoint ( G4int  i, const G4ParticleHPDataPoint &  it  )

inline

Definition at line 89 of file G4ParticleHPVector.hh.

  {
    G4double x = it.GetX();
    G4double y = it.GetY();
    SetData(i, x, y);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SetScheme()

void G4ParticleHPVector::SetScheme ( G4int  aPoint, const G4InterpolationScheme &  aScheme  )

inline

Definition at line 498 of file G4ParticleHPVector.hh.

  {
    theManager.AppendScheme(aPoint, aScheme);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerbose()

void G4ParticleHPVector::SetVerbose ( G4int  ff )

inline

Definition at line 71 of file G4ParticleHPVector.hh.

  {
    Verbose = ff;
  }

SetX()

void G4ParticleHPVector::SetX ( G4int  i, G4double  e  )

inline

Definition at line 103 of file G4ParticleHPVector.hh.

  {
    Check(i);
    theData[i].SetX(e);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SetXsec()

void G4ParticleHPVector::SetXsec ( G4int  i, G4double  x  )

inline

Definition at line 119 of file G4ParticleHPVector.hh.

  {
    Check(i);
    if(x>maxValue) maxValue=x;
    theData[i].SetY(x);
  }

Here is the call graph for this function:

SetY()

void G4ParticleHPVector::SetY ( G4int  i, G4double  x  )

inline

Definition at line 113 of file G4ParticleHPVector.hh.

  {
    Check(i);
    if(x>maxValue) maxValue=x;
    theData[i].SetY(x);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ThinOut()

void G4ParticleHPVector::ThinOut

(

G4double

precision

)

Definition at line 296 of file G4ParticleHPVector.cc.

  {
    // anything in there?
    if(GetVectorLength()==0) return;
    // make the new vector
    G4ParticleHPDataPoint * aBuff = new G4ParticleHPDataPoint[nPoints];
    G4double x, x1, x2, y, y1, y2;
    G4int count = 0, current = 2, start = 1;
    
    // First element always goes and is never tested.
    aBuff[0] = theData[0];
    
    // Find the rest
    while(current < GetVectorLength()) // Loop checking, 11.05.2015, T. Koi
    {
      x1=aBuff[count].GetX();
      y1=aBuff[count].GetY();
      x2=theData[current].GetX();
      y2=theData[current].GetY();
      for(G4int j=start; j<current; j++)
      {
    x = theData[j].GetX();
    if(x1-x2 == 0) y = (y2+y1)/2.;
    else y = theInt.Lin(x, x1, x2, y1, y2);
    if (std::abs(y-theData[j].GetY())>precision*y)
    {
      aBuff[++count] = theData[current-1]; // for this one, everything was fine
          start = current; // the next candidate
      break;
    }
      }
      current++ ;
    }
    // The last one also always goes, and is never tested.
    aBuff[++count] = theData[GetVectorLength()-1];
    delete [] theData;
    theData = aBuff;
    nEntries = count+1;
    
    // Rebuild the Hash;
    if(theHash.Prepared()) 
    {
      ReHash();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Times()

void G4ParticleHPVector::Times ( G4double  factor )

inline

Definition at line 76 of file G4ParticleHPVector.hh.

  {
    G4int i;
    for(i=0; i<nEntries; i++)
    {
      theData[i].SetY(theData[i].GetY()*factor);
    }
    if(theIntegral!=0)
    {
      theIntegral[i] *= factor;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

operator+

G4ParticleHPVector& operator+ ( G4ParticleHPVector &  left, G4ParticleHPVector &  right  )

friend

Definition at line 40 of file G4ParticleHPVector.cc.

  {
    G4ParticleHPVector * result = new G4ParticleHPVector;
    G4int j=0;
    G4double x;
    G4double y;
    G4int running = 0;
    for(G4int i=0; i<left.GetVectorLength(); i++)
    {
      while(j<right.GetVectorLength()) // Loop checking, 11.05.2015, T. Koi
      {
        if(right.GetX(j)<left.GetX(i)*1.001)
        {
          x = right.GetX(j);
          y = right.GetY(j)+left.GetY(x);
          result->SetData(running++, x, y);
          j++;
        }
        //else if(std::abs((right.GetX(j)-left.GetX(i))/(left.GetX(i)+right.GetX(j)))>0.001)
        else if( left.GetX(i)+right.GetX(j) == 0 
              || std::abs((right.GetX(j)-left.GetX(i))/(left.GetX(i)+right.GetX(j))) > 0.001 )
        {
          x = left.GetX(i);
          y = left.GetY(i)+right.GetY(x);
          result->SetData(running++, x, y);
          break;
        }
        else
        {
          break;
        }
      }
      if(j==right.GetVectorLength())
      {
        x = left.GetX(i);
        y = left.GetY(i)+right.GetY(x);
        result->SetData(running++, x, y);     
      }
    }
    result->ThinOut(0.02);
    return *result;
  }

Member Data Documentation

isFreed

G4int G4ParticleHPVector::isFreed

private

Definition at line 571 of file G4ParticleHPVector.hh.

label

G4double G4ParticleHPVector::label

private

Definition at line 566 of file G4ParticleHPVector.hh.

maxValue

G4double G4ParticleHPVector::maxValue

private

Definition at line 574 of file G4ParticleHPVector.hh.

nEntries

G4int G4ParticleHPVector::nEntries

private

Definition at line 564 of file G4ParticleHPVector.hh.

nPoints

G4int G4ParticleHPVector::nPoints

private

Definition at line 565 of file G4ParticleHPVector.hh.

the15percentBorderCash

G4double G4ParticleHPVector::the15percentBorderCash

private

Definition at line 578 of file G4ParticleHPVector.hh.

the50percentBorderCash

G4double G4ParticleHPVector::the50percentBorderCash

private

Definition at line 579 of file G4ParticleHPVector.hh.

theBlocked

std::vector<G4double> G4ParticleHPVector::theBlocked

private

Definition at line 576 of file G4ParticleHPVector.hh.

theBuffered

std::vector<G4double> G4ParticleHPVector::theBuffered

private

Definition at line 577 of file G4ParticleHPVector.hh.

theData

G4ParticleHPDataPoint* G4ParticleHPVector::theData

private

Definition at line 561 of file G4ParticleHPVector.hh.

theHash

G4ParticleHPHash G4ParticleHPVector::theHash

private

Definition at line 573 of file G4ParticleHPVector.hh.

theInt

G4ParticleHPInterpolator G4ParticleHPVector::theInt

private

Definition at line 568 of file G4ParticleHPVector.hh.

theIntegral

G4double* G4ParticleHPVector::theIntegral

private

Definition at line 563 of file G4ParticleHPVector.hh.

theLin

G4ParticleHPInterpolator G4ParticleHPVector::theLin

private

Definition at line 555 of file G4ParticleHPVector.hh.

theManager

G4InterpolationManager G4ParticleHPVector::theManager

private

Definition at line 562 of file G4ParticleHPVector.hh.

totalIntegral

G4double G4ParticleHPVector::totalIntegral

private

Definition at line 559 of file G4ParticleHPVector.hh.

Verbose

G4int G4ParticleHPVector::Verbose

private

Definition at line 569 of file G4ParticleHPVector.hh.

---

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

• G4ParticleHPVector.hh
• G4ParticleHPVector.cc