G4NeutronHPArbitaryTab Class Reference

#include <G4NeutronHPArbitaryTab.hh>

Inheritance diagram for G4NeutronHPArbitaryTab:

Public Member Functions
	G4NeutronHPArbitaryTab ()
	~G4NeutronHPArbitaryTab ()
void	Init (std::istream &theData)
G4double	GetFractionalProbability (G4double anEnergy)
G4double	Sample (G4double anEnergy)
Public Member Functions inherited from G4VNeutronHPEDis
	G4VNeutronHPEDis ()
virtual	~G4VNeutronHPEDis ()

Detailed Description

Definition at line 43 of file G4NeutronHPArbitaryTab.hh.

Constructor & Destructor Documentation

G4NeutronHPArbitaryTab::G4NeutronHPArbitaryTab ( )

inline

Definition at line 46 of file G4NeutronHPArbitaryTab.hh.

  {
   theDistFunc = 0;
  }

G4NeutronHPArbitaryTab::~G4NeutronHPArbitaryTab ( )

inline

Definition at line 50 of file G4NeutronHPArbitaryTab.hh.

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

Member Function Documentation

G4double G4NeutronHPArbitaryTab::GetFractionalProbability ( G4double  anEnergy )

inlinevirtual

Implements G4VNeutronHPEDis.

Definition at line 97 of file G4NeutronHPArbitaryTab.hh.

References G4NeutronHPVector::GetY().

  {
    return theFractionalProb.GetY(anEnergy);
  }

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

inlinevirtual

Implements G4VNeutronHPEDis.

Definition at line 55 of file G4NeutronHPArbitaryTab.hh.

References G4NeutronHPVector::GetEnergy(), G4NeutronHPVector::GetVectorLength(), G4InterpolationManager::Init(), G4NeutronHPVector::Init(), and G4NeutronHPVector::SetLabel().

  {
    G4int i;
    theFractionalProb.Init(theData, CLHEP::eV);
    theData >> nDistFunc; // = number of incoming n energy points
    theDistFunc = new G4NeutronHPVector [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);
      //************************************************************************
      //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);
    }
      }
    }
     //************************************************************************
  }

G4double G4NeutronHPArbitaryTab::Sample ( G4double  anEnergy )

virtual

Implements G4VNeutronHPEDis.

Definition at line 33 of file G4NeutronHPArbitaryTab.cc.

References G4cerr, G4endl, G4UniformRand, G4NeutronHPVector::GetLabel(), and G4NeutronHPVector::Sample().

  {
    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 G4NeutronHPArbitaryTab::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;

    //************************************************************************
  }

---

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

• G4NeutronHPArbitaryTab.hh
• G4NeutronHPArbitaryTab.cc