#include <G4ParticleHPArbitaryTab.hh>

Inheritance diagram for G4ParticleHPArbitaryTab:

Public Member Functions
	G4ParticleHPArbitaryTab ()

G4double	GetFractionalProbability (G4double anEnergy)

void	Init (std::istream &theData)

G4double	Sample (G4double anEnergy)

	~G4ParticleHPArbitaryTab ()

Private Attributes
G4int	nDistFunc

G4ParticleHPVector	theBuffer

G4ParticleHPVector *	theDistFunc

G4ParticleHPVector	theFractionalProb

G4double	theHighThreshold [1000]

G4double	theLowThreshold [1000]

G4InterpolationManager	theManager

Detailed Description

Definition at line 45 of file G4ParticleHPArbitaryTab.hh.

Constructor & Destructor Documentation

◆ G4ParticleHPArbitaryTab()

G4ParticleHPArbitaryTab::G4ParticleHPArbitaryTab ( )

inline

Definition at line 48 of file G4ParticleHPArbitaryTab.hh.

  {
   theDistFunc = 0;
   nDistFunc = 0;
  }

References nDistFunc, and theDistFunc.

◆ ~G4ParticleHPArbitaryTab()

G4ParticleHPArbitaryTab::~G4ParticleHPArbitaryTab ( )

inline

Definition at line 53 of file G4ParticleHPArbitaryTab.hh.

  {
   if(theDistFunc!=0) delete [] theDistFunc;
  }

References theDistFunc.

Member Function Documentation

◆ GetFractionalProbability()

G4double G4ParticleHPArbitaryTab::GetFractionalProbability ( G4double anEnergy )

inlinevirtual

Implements G4VParticleHPEDis.

Definition at line 101 of file G4ParticleHPArbitaryTab.hh.

  {
    return theFractionalProb.GetY(anEnergy);
  }

References G4ParticleHPVector::GetY(), and theFractionalProb.

◆ Init()

void G4ParticleHPArbitaryTab::Init ( std::istream & theData )

inlinevirtual

Implements G4VParticleHPEDis.

Definition at line 58 of file G4ParticleHPArbitaryTab.hh.

  {
    G4int i;
    theFractionalProb.Init(theData, CLHEP::eV);
    theData >> nDistFunc; // = number of incoming n energy points
    theDistFunc = new G4ParticleHPVector [nDistFunc];
    theManager.Init(theData);
    G4double currentEnergy;
    for(i=0; i<nDistFunc; i++)
    {
      theData >> currentEnergy;
      theDistFunc[i].SetLabel(currentEnergy*CLHEP::eV);
      theDistFunc[i].Init(theData, CLHEP::eV);
      theDistFunc[i].IntegrateAndNormalise();
      //************************************************************************
      //EMendoza:
      //ThinOut() assumes that the data is linear-linear, what is false:
      //theDistFunc[i].ThinOut(0.02); // @@@ optimization to be finished.
      //************************************************************************
    }
 
    //************************************************************************
    //EMendoza:
    //Here we calculate the thresholds for the 2D sampling:
    for(i=0; i<nDistFunc; i++){
      G4int np=theDistFunc[i].GetVectorLength();
      theLowThreshold[i]=theDistFunc[i].GetEnergy(0);
      theHighThreshold[i]=theDistFunc[i].GetEnergy(np-1);
      for(G4int j=0;j<np-1;j++){
    if(theDistFunc[i].GetXsec(j+1)>1.e-20){
      theLowThreshold[i]=theDistFunc[i].GetEnergy(j);
      break;
    }
      }
      for(G4int j=1;j<np;j++){
    if(theDistFunc[i].GetXsec(j-1)>1.e-20){
      theHighThreshold[i]=theDistFunc[i].GetEnergy(j);
    }
      }
    }
     //************************************************************************
  }

References CLHEP::eV, G4ParticleHPVector::GetEnergy(), G4ParticleHPVector::GetVectorLength(), G4InterpolationManager::Init(), G4ParticleHPVector::Init(), G4ParticleHPVector::IntegrateAndNormalise(), nDistFunc, G4ParticleHPVector::SetLabel(), theDistFunc, theFractionalProb, theHighThreshold, theLowThreshold, and theManager.

◆ Sample()

G4double G4ParticleHPArbitaryTab::Sample ( G4double anEnergy )

virtual

Implements G4VParticleHPEDis.

Definition at line 35 of file G4ParticleHPArbitaryTab.cc.

  {
    G4int i;
    for(i=0;i<nDistFunc;i++)
    {
      if(anEnergy<theDistFunc[i].GetLabel()) break; // that is the energy we need
    }
    G4int low(0), high(0);
    if(i==nDistFunc) 
    {
      low = i-2;
      high = i-1;
    }
    else if(i==0)
    {
      if(nDistFunc==0)
      {
        G4cerr << "No distribution functions to sample "
             << "from in G4ParticleHPArbitaryTab::Sample"<<G4endl;
        throw G4HadronicException(__FILE__, __LINE__, "nDistFunc==0");
      } 
      else 
      {
        return theDistFunc[0].Sample();
      }
    }
    else
    {
      low = i-1;
      high = i;
    }
    //************************************************************************
    //EMendoza
    /*
      theBuffer.Merge(theManager.GetScheme(low), anEnergy, 
      theDistFunc+low, theDistFunc+high);
      return theBuffer.Sample();
    */
    //************************************************************************
    //New way to perform the 2D sampling:
    G4double elow=theDistFunc[low].GetLabel();
    G4double ehigh=theDistFunc[high].GetLabel();
    G4double rval=(anEnergy-elow)/(ehigh-elow);//rval is 0 for elow and 1 for ehigh
    G4double eoutlow=theLowThreshold[low]+rval*(theLowThreshold[high]-theLowThreshold[low]);
    G4double eouthigh=theHighThreshold[low]+rval*(theHighThreshold[high]-theHighThreshold[low]);
    G4double rand=G4UniformRand();
    G4double Eout_1=0,Eout_2=0;
    if(rval<rand){
      Eout_1=theDistFunc[low].Sample();
      Eout_2=eoutlow+(Eout_1-theLowThreshold[low])*(eouthigh-eoutlow)/(theHighThreshold[low]-theLowThreshold[low]);
    }
    else{
      Eout_1=theDistFunc[high].Sample();
      Eout_2=eoutlow+(Eout_1-theLowThreshold[high])*(eouthigh-eoutlow)/(theHighThreshold[high]-theLowThreshold[high]);
    }
    return Eout_2;
 
    //************************************************************************
  }