G4ParticleHPArbitaryTab Class Reference

#include <G4ParticleHPArbitaryTab.hh>

Inheritance diagram for G4ParticleHPArbitaryTab:

Public Member Functions
	G4ParticleHPArbitaryTab ()
	~G4ParticleHPArbitaryTab () override
void	Init (std::istream &theData) override
G4double	GetFractionalProbability (G4double anEnergy) override
G4double	Sample (G4double anEnergy) override
Public Member Functions inherited from G4VParticleHPEDis
	G4VParticleHPEDis ()=default
virtual	~G4VParticleHPEDis ()=default

Detailed Description

Definition at line 46 of file G4ParticleHPArbitaryTab.hh.

Constructor & Destructor Documentation

G4ParticleHPArbitaryTab()

G4ParticleHPArbitaryTab::G4ParticleHPArbitaryTab ( )

inline

Definition at line 49 of file G4ParticleHPArbitaryTab.hh.

    {
      theDistFunc = nullptr;
      nDistFunc = 0;
    }

~G4ParticleHPArbitaryTab()

G4ParticleHPArbitaryTab::~G4ParticleHPArbitaryTab ( )

inlineoverride

Definition at line 54 of file G4ParticleHPArbitaryTab.hh.

{ delete[] theDistFunc; }

Member Function Documentation

GetFractionalProbability()

G4double G4ParticleHPArbitaryTab::GetFractionalProbability ( G4double anEnergy )

inlineoverridevirtual

Implements G4VParticleHPEDis.

Definition at line 99 of file G4ParticleHPArbitaryTab.hh.

    {
      return theFractionalProb.GetY(anEnergy);
    }

Init()

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

inlineoverridevirtual

Implements G4VParticleHPEDis.

Definition at line 56 of file G4ParticleHPArbitaryTab.hh.

    {
      std::size_t i;
      theFractionalProb.Init(theData, CLHEP::eV);
      theData >> nDistFunc;  // = number of incoming n energy points
      const std::size_t dsize = nDistFunc > 0 ? nDistFunc : 1;
      theDistFunc = new G4ParticleHPVector[dsize];
      theManager.Init(theData);
      G4double currentEnergy;
      for (i = 0; i < dsize; ++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 < dsize; ++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);
          }
        }
      }
      //************************************************************************
    }

Sample()

G4double G4ParticleHPArbitaryTab::Sample ( G4double anEnergy )

overridevirtual

Implements G4VParticleHPEDis.

Definition at line 36 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");
    }
    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;
 
  //************************************************************************
}

---

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

• G4ParticleHPArbitaryTab.hh
• G4ParticleHPArbitaryTab.cc