G4ParticleHPLegendreStore Class Reference

#include <G4ParticleHPLegendreStore.hh>

Public Member Functions
	G4ParticleHPLegendreStore (G4int n)
G4double	GetCoeff (G4int i, G4int l)
G4double	GetEnergy (G4int i)
G4int	GetNumberOfPoly (G4int i)
G4double	GetTemperature (G4int i)
void	Init (G4int i, G4double e, G4int n)
void	InitInterpolation (std::istream &aDataFile)
G4double	Integrate (G4int k, G4double costh)
G4double	Sample (G4double energy)
G4double	SampleDiscreteTwoBody (G4double anEnergy)
G4double	SampleElastic (G4double anEnergy)
G4double	SampleMax (G4double energy)
void	SetCoeff (G4int i, G4int l, G4double coeff)
void	SetCoeff (G4int i, G4ParticleHPLegendreTable *theTable)
void	SetEnergy (G4int i, G4double energy)
void	SetManager (G4InterpolationManager &aManager)
void	SetNPoints (G4int n)
void	SetTemperature (G4int i, G4double temp)
	~G4ParticleHPLegendreStore ()

Private Attributes
G4int	nEnergy
G4ParticleHPLegendreTable *	theCoeff
G4InterpolationManager	theManager

Detailed Description

Definition at line 37 of file G4ParticleHPLegendreStore.hh.

Constructor & Destructor Documentation

G4ParticleHPLegendreStore()

G4ParticleHPLegendreStore::G4ParticleHPLegendreStore ( G4int  n )

inline

Definition at line 41 of file G4ParticleHPLegendreStore.hh.

  {
    theCoeff = new G4ParticleHPLegendreTable[n];
    nEnergy = n;
  }

References CLHEP::detail::n, nEnergy, and theCoeff.

~G4ParticleHPLegendreStore()

G4ParticleHPLegendreStore::~G4ParticleHPLegendreStore ( )

inline

Definition at line 47 of file G4ParticleHPLegendreStore.hh.

  {
    delete [] theCoeff;
  }

References theCoeff.

Member Function Documentation

GetCoeff()

G4double G4ParticleHPLegendreStore::GetCoeff ( G4int  i, G4int  l  )

inline

Definition at line 68 of file G4ParticleHPLegendreStore.hh.

{return theCoeff[i].GetCoeff(l);}

References G4ParticleHPLegendreTable::GetCoeff(), and theCoeff.

Referenced by SampleDiscreteTwoBody(), SampleElastic(), and SampleMax().

GetEnergy()

G4double G4ParticleHPLegendreStore::GetEnergy ( G4int  i )

inline

Definition at line 69 of file G4ParticleHPLegendreStore.hh.

{return theCoeff[i].GetEnergy();}

References G4ParticleHPLegendreTable::GetEnergy(), and theCoeff.

Referenced by Sample(), SampleDiscreteTwoBody(), SampleElastic(), and SampleMax().

GetNumberOfPoly()

G4int G4ParticleHPLegendreStore::GetNumberOfPoly ( G4int  i )

inline

Definition at line 71 of file G4ParticleHPLegendreStore.hh.

{return theCoeff[i].GetNumberOfPoly();}

References G4ParticleHPLegendreTable::GetNumberOfPoly(), and theCoeff.

GetTemperature()

G4double G4ParticleHPLegendreStore::GetTemperature ( G4int  i )

inline

Definition at line 70 of file G4ParticleHPLegendreStore.hh.

{return theCoeff[i].GetTemperature();}

References G4ParticleHPLegendreTable::GetTemperature(), and theCoeff.

Init()

void G4ParticleHPLegendreStore::Init ( G4int  i, G4double  e, G4int  n  )

inline

Definition at line 52 of file G4ParticleHPLegendreStore.hh.

  {
    theCoeff[i].Init(e, n);
  }

References G4ParticleHPLegendreTable::Init(), CLHEP::detail::n, and theCoeff.

Referenced by G4ParticleHPElasticFS::Init(), G4ParticleHPAngular::Init(), and G4ParticleHPContAngularPar::Sample().

InitInterpolation()

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

inline

Definition at line 79 of file G4ParticleHPLegendreStore.hh.

  {
    theManager.Init(aDataFile);
  }

References G4InterpolationManager::Init(), and theManager.

Referenced by G4ParticleHPElasticFS::Init(), and G4ParticleHPAngular::Init().

Integrate()

G4double G4ParticleHPLegendreStore::Integrate	(	G4int	k,
		G4double	costh
	)

Definition at line 323 of file G4ParticleHPLegendreStore.cc.

{
  G4double result=0.;
  G4ParticleHPFastLegendre theLeg;
//  G4cout <<"the COEFFS "<<k<<" ";
//  G4cout <<theCoeff[k].GetNumberOfPoly()<<" ";
  for(G4int l=0; l<theCoeff[k].GetNumberOfPoly() ; l++)
  {
    result += theCoeff[k].GetCoeff(l)*theLeg.Integrate(l, costh);
//    G4cout << theCoeff[k].GetCoeff(l)<<" ";
  } 
//  G4cout <<G4endl;
  return result;
}

References G4ParticleHPLegendreTable::GetCoeff(), G4ParticleHPLegendreTable::GetNumberOfPoly(), G4ParticleHPFastLegendre::Integrate(), and theCoeff.

Referenced by Sample().

Sample()

G4double G4ParticleHPLegendreStore::Sample

(

G4double

energy

)

Definition at line 270 of file G4ParticleHPLegendreStore.cc.

{
  G4int i0;
  G4int low(0), high(0);
//  G4cout << "G4ParticleHPLegendreStore::Sample "<<energy<<" "<<energy<<" "<<nEnergy<<G4endl;
  for (i0=0; i0<nEnergy; i0++)
  {
//     G4cout <<"theCoeff["<<i0<<"].GetEnergy() = "<<theCoeff[i0].GetEnergy()<<G4endl;
    high = i0;
    if(theCoeff[i0].GetEnergy()>energy) break;
  }
  low = std::max(0, high-1);
//  G4cout << "G4ParticleHPLegendreStore::Sample high, low: "<<high<<", "<<low<<G4endl;
  G4ParticleHPVector theBuffer;
  G4ParticleHPInterpolator theInt;
  G4double x1, x2, y1, y2, y;
  x1 = theCoeff[low].GetEnergy();
  x2 = theCoeff[high].GetEnergy();
//  G4cout << "the xes "<<x1<<" "<<x2<<G4endl;
  G4double costh=0;
  for(i0=0; i0<601; i0++)
  {
    costh = G4double(i0-300)/300.;
    y1 = Integrate(low, costh);
    y2 = Integrate(high, costh);
    y = theInt.Interpolate(theManager.GetScheme(high), energy, x1, x2, y1, y2);
    theBuffer.SetData(i0, costh, y);
//     G4cout << "Integration "<<low<<" "<<costh<<" "<<y1<<" "<<y2<<" "<<y<<G4endl;
  }
  G4double rand = G4UniformRand();
  G4int it;
  for (i0=1; i0<601; i0++)
  {
    it = i0;
    if(rand < theBuffer.GetY(i0)/theBuffer.GetY(600)) break;
//    G4cout <<"sampling now "<<i0<<" "
//         << theBuffer.GetY(i0)<<" "
//         << theBuffer.GetY(600)<<" "
//         << rand<<" "
//         << theBuffer.GetY(i0)/theBuffer.GetY(600)<<G4endl;;
  }
  if(it==601) it=600;
//  G4cout << "G4ParticleHPLegendreStore::Sample it "<<rand<<" "<<it<<G4endl;
  G4double norm = theBuffer.GetY(600);
  if(norm==0) return -DBL_MAX; 
  x1 = theBuffer.GetY(it)/norm;
  x2 = theBuffer.GetY(it-1)/norm;
  y1 = theBuffer.GetX(it);
  y2 = theBuffer.GetX(it-1);
//  G4cout << "G4ParticleHPLegendreStore::Sample x y "<<x1<<" "<<y1<<" "<<x2<<" "<<y2<<G4endl;
  return theInt.Interpolate(theManager.GetScheme(high), rand, x1, x2, y1, y2);
}

References DBL_MAX, G4INCL::KinematicsUtils::energy(), G4UniformRand, G4ParticleHPLegendreTable::GetEnergy(), GetEnergy(), G4InterpolationManager::GetScheme(), G4ParticleHPVector::GetX(), G4ParticleHPVector::GetY(), Integrate(), G4ParticleHPInterpolator::Interpolate(), G4INCL::Math::max(), nEnergy, G4ParticleHPVector::SetData(), theCoeff, and theManager.

SampleDiscreteTwoBody()

G4double G4ParticleHPLegendreStore::SampleDiscreteTwoBody

(

G4double

anEnergy

)

Definition at line 44 of file G4ParticleHPLegendreStore.cc.

{
  G4double result=0.;
  
  G4int i0;
  G4int low(0), high(0);
  G4ParticleHPFastLegendre theLeg;
  for (i0=0; i0<nEnergy; i0++)
  {
    high = i0;
    if(theCoeff[i0].GetEnergy()>anEnergy) break;
  }
  low = std::max(0, high-1);
  G4ParticleHPInterpolator theInt;
  G4double x, x1, x2;
  x = anEnergy;
  x1 = theCoeff[low].GetEnergy();
  x2 = theCoeff[high].GetEnergy();
  G4double theNorm = 0;
  G4double try01=0, try02=0;
  G4double max1, max2, costh;
  max1 = 0; max2 = 0;
  G4int l,m_tmp;
  for(i0=0; i0<601; i0++)
  {
      costh = G4double(i0-300)/300.;
      try01 = 0.5;
      for(m_tmp=0; m_tmp<theCoeff[low].GetNumberOfPoly() ; m_tmp++)
      {  
      l=m_tmp+1;
      try01 += (2.*l+1)/2.*theCoeff[low].GetCoeff(m_tmp)*theLeg.Evaluate(l, costh);
      } 
      if(try01>max1) max1=try01;
      try02 = 0.5;
      for(m_tmp=0; m_tmp<theCoeff[high].GetNumberOfPoly() ; m_tmp++)
      {
      l=m_tmp+1;
      try02 += (2.*l+1)/2.*theCoeff[high].GetCoeff(m_tmp)*theLeg.Evaluate(l, costh);
      }
      if(try02>max2) max2=try02;
  } 
  theNorm = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, max1, max2);
  
  G4double value, random;
  G4double v1, v2;
  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;
    }
    v1 = 0.5;
    v2 = 0.5;
    result = 2.*G4UniformRand()-1.;
    for(m_tmp=0; m_tmp<theCoeff[low].GetNumberOfPoly() ; m_tmp++)
    {
    l=m_tmp+1;  
    G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
    v1 += (2.*l+1)/2.*theCoeff[low].GetCoeff(m_tmp)*legend;
    } 
    for(m_tmp=0; m_tmp<theCoeff[high].GetNumberOfPoly() ; m_tmp++)
    {   
    l=m_tmp+1;
    G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
    v2 += (2.*l+1)/2.*theCoeff[high].GetCoeff(m_tmp)*legend;
    } 
    // v1 = std::max(0.,v1); // Workaround in case one of the distributions is fully non-physical.
    // v2 = std::max(0.,v2); 
    value = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, v1, v2);
    random = G4UniformRand();
    if(0>=theNorm) break; // Workaround for negative cross-section values. @@@@ 31 May 2000
  }
  while(random>value/theNorm); // Loop checking, 11.05.2015, T. Koi
 
  return result;
}

References G4ParticleHPFastLegendre::Evaluate(), G4cout, G4endl, G4UniformRand, GetCoeff(), G4ParticleHPLegendreTable::GetEnergy(), GetEnergy(), G4ParticleHPLegendreTable::GetNumberOfPoly(), G4InterpolationManager::GetScheme(), G4ParticleHPInterpolator::Interpolate(), G4INCL::Math::max(), nEnergy, theCoeff, and theManager.

Referenced by G4ParticleHPDiscreteTwoBody::Sample().

SampleElastic()

G4double G4ParticleHPLegendreStore::SampleElastic

(

G4double

anEnergy

)

Definition at line 202 of file G4ParticleHPLegendreStore.cc.

{
  G4double result=0.;
  
  G4int i0;
  G4int low(0), high(0);
  G4ParticleHPFastLegendre theLeg;
  for (i0=0; i0<nEnergy; i0++)
  {
    high = i0;
    if(theCoeff[i0].GetEnergy()>anEnergy) break;
  }
  low = std::max(0, high-1);
  G4ParticleHPInterpolator theInt;
  G4double x, x1, x2;
  x = anEnergy;
  x1 = theCoeff[low].GetEnergy();
  x2 = theCoeff[high].GetEnergy();
  G4double theNorm = 0;
  G4double try01=0, try02=0, try11=0, try12=0;
  G4double try1, try2;
  G4int l;
  for(l=0; l<theCoeff[low].GetNumberOfPoly(); l++)
  {
    try01 += (2.*l+1)/2.*theCoeff[low].GetCoeff(l)*theLeg.Evaluate(l, -1.);
    try11 += (2.*l+1)/2.*theCoeff[low].GetCoeff(l)*theLeg.Evaluate(l, +1.);
  } 
  for(l=0; l<theCoeff[high].GetNumberOfPoly(); l++)
  {
    try02 += (2.*l+1)/2.*theCoeff[high].GetCoeff(l)*theLeg.Evaluate(l, -1.);
    try12 += (2.*l+1)/2.*theCoeff[high].GetCoeff(l)*theLeg.Evaluate(l, +1.);
  } 
  try1 = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, try01, try02);
  try2 = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, try11, try12);
  theNorm = std::max(try1, try2);
  
  G4double value, random;
  G4double v1, v2;
  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;
    }
    v1 = 0;
    v2 = 0;
    result = 2.*G4UniformRand()-1.;
    for(l=0; l<theCoeff[low].GetNumberOfPoly() ; l++)
    {
      G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
      v1 += (2.*l+1)/2.*theCoeff[low].GetCoeff(l)*legend;
    } 
    for(l=0; l<theCoeff[high].GetNumberOfPoly() ; l++)
    {
      G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
      v2 += (2.*l+1)/2.*theCoeff[high].GetCoeff(l)*legend;
    } 
    value = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, v1, v2);
    random = G4UniformRand();
  }
  while(random>value/theNorm); // Loop checking, 11.05.2015, T. Koi
  
  return result;
}

References G4ParticleHPFastLegendre::Evaluate(), G4cout, G4endl, G4UniformRand, GetCoeff(), G4ParticleHPLegendreTable::GetEnergy(), GetEnergy(), G4ParticleHPLegendreTable::GetNumberOfPoly(), G4InterpolationManager::GetScheme(), G4ParticleHPInterpolator::Interpolate(), G4INCL::Math::max(), nEnergy, theCoeff, and theManager.

Referenced by G4ParticleHPElasticFS::ApplyYourself().

SampleMax()

G4double G4ParticleHPLegendreStore::SampleMax

(

G4double

energy

)

Definition at line 126 of file G4ParticleHPLegendreStore.cc.

{
  G4double result=0.;
  
  G4int i0;
  G4int low(0), high(0);
  G4ParticleHPFastLegendre theLeg;
  for (i0=0; i0<nEnergy; i0++)
  {
    high = i0;
    if(theCoeff[i0].GetEnergy()>anEnergy) break;
  }
  low = std::max(0, high-1);
  G4ParticleHPInterpolator theInt;
  G4double x, x1, x2;
  x = anEnergy;
  x1 = theCoeff[low].GetEnergy();
  x2 = theCoeff[high].GetEnergy();
  G4double theNorm = 0;
  G4double try01=0, try02=0;
  G4double max1, max2, costh;
  max1 = 0; max2 = 0;
  G4int l;
  for(i0=0; i0<601; i0++)
  {
    costh = G4double(i0-300)/300.;
    try01 = 0;
    for(l=0; l<theCoeff[low].GetNumberOfPoly() ; l++)
    {
      try01 += (2.*l+1)/2.*theCoeff[low].GetCoeff(l)*theLeg.Evaluate(l, costh);
    } 
    if(try01>max1) max1=try01;
    try02 = 0;
    for(l=0; l<theCoeff[high].GetNumberOfPoly() ; l++)
    {
      try02 += (2.*l+1)/2.*theCoeff[high].GetCoeff(l)*theLeg.Evaluate(l, costh);
    }
    if(try02>max2) max2=try02;
  } 
  theNorm = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, max1, max2);
  
  G4double value, random;
  G4double v1, v2;
  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;
    }
    v1 = 0;
    v2 = 0;
    result = 2.*G4UniformRand()-1.;
    for(l=0; l<theCoeff[low].GetNumberOfPoly() ; l++)
    {
      G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
      v1 += (2.*l+1)/2.*theCoeff[low].GetCoeff(l)*legend;
    } 
    for(l=0; l<theCoeff[high].GetNumberOfPoly() ; l++)
    {
      G4double legend = theLeg.Evaluate(l, result); // @@@ done to avoid optimization error on SUN
      v2 += (2.*l+1)/2.*theCoeff[high].GetCoeff(l)*legend;
    } 
    v1 = std::max(0.,v1); // Workaround in case one of the distributions is fully non-physical.
    v2 = std::max(0.,v2); 
    value = theInt.Interpolate(theManager.GetScheme(high), x, x1, x2, v1, v2);
    random = G4UniformRand();
    if(0>=theNorm) break; // Workaround for negative cross-section values. @@@@ 31 May 2000
  }
  while(random>value/theNorm); // Loop checking, 11.05.2015, T. Koi 
  return result;
}

References G4ParticleHPFastLegendre::Evaluate(), G4cout, G4endl, G4UniformRand, GetCoeff(), G4ParticleHPLegendreTable::GetEnergy(), GetEnergy(), G4ParticleHPLegendreTable::GetNumberOfPoly(), G4InterpolationManager::GetScheme(), G4ParticleHPInterpolator::Interpolate(), G4INCL::Math::max(), nEnergy, theCoeff, and theManager.

Referenced by G4ParticleHPPhotonDist::GetPhotons(), G4ParticleHPContAngularPar::Sample(), and G4ParticleHPAngular::SampleAndUpdate().

SetCoeff() [1/2]

void G4ParticleHPLegendreStore::SetCoeff ( G4int  i, G4int  l, G4double  coeff  )

inline

Definition at line 59 of file G4ParticleHPLegendreStore.hh.

{theCoeff[i].SetCoeff(l, coeff); }

References G4ParticleHPLegendreTable::SetCoeff(), and theCoeff.

Referenced by G4ParticleHPPhotonDist::GetPhotons(), G4ParticleHPElasticFS::Init(), G4ParticleHPAngular::Init(), G4ParticleHPDiscreteTwoBody::Sample(), and G4ParticleHPContAngularPar::Sample().

SetCoeff() [2/2]

void G4ParticleHPLegendreStore::SetCoeff ( G4int  i, G4ParticleHPLegendreTable *  theTable  )

inline

Definition at line 60 of file G4ParticleHPLegendreStore.hh.

  {
    if(i>nEnergy) throw G4HadronicException(__FILE__, __LINE__, "LegendreTableIndex out of range");
    theCoeff[i] = *theTable;
// not here -- see G4ParticleHPPhotonDist.cc line 275
//    delete theTable;
  }

References nEnergy, and theCoeff.

SetEnergy()

void G4ParticleHPLegendreStore::SetEnergy ( G4int  i, G4double  energy  )

inline

Definition at line 57 of file G4ParticleHPLegendreStore.hh.

{ theCoeff[i].SetEnergy(energy); }

References G4INCL::KinematicsUtils::energy(), G4ParticleHPLegendreTable::SetEnergy(), and theCoeff.

SetManager()

void G4ParticleHPLegendreStore::SetManager ( G4InterpolationManager &  aManager )

inline

Definition at line 84 of file G4ParticleHPLegendreStore.hh.

  {
    theManager = aManager;
  }

References theManager.

Referenced by G4ParticleHPDiscreteTwoBody::Sample(), and G4ParticleHPContAngularPar::Sample().

SetNPoints()

void G4ParticleHPLegendreStore::SetNPoints ( G4int  n )

inline

Definition at line 56 of file G4ParticleHPLegendreStore.hh.

{ nEnergy = n; }

References CLHEP::detail::n, and nEnergy.

SetTemperature()

void G4ParticleHPLegendreStore::SetTemperature ( G4int  i, G4double  temp  )

inline

Definition at line 58 of file G4ParticleHPLegendreStore.hh.

{ theCoeff[i].SetTemperature(temp); }

References G4ParticleHPLegendreTable::SetTemperature(), and theCoeff.

Referenced by G4ParticleHPElasticFS::Init(), and G4ParticleHPAngular::Init().

Field Documentation

nEnergy

G4int G4ParticleHPLegendreStore::nEnergy

private

Definition at line 91 of file G4ParticleHPLegendreStore.hh.

Referenced by G4ParticleHPLegendreStore(), Sample(), SampleDiscreteTwoBody(), SampleElastic(), SampleMax(), SetCoeff(), and SetNPoints().

theCoeff

G4ParticleHPLegendreTable* G4ParticleHPLegendreStore::theCoeff

private

Definition at line 92 of file G4ParticleHPLegendreStore.hh.

Referenced by G4ParticleHPLegendreStore(), GetCoeff(), GetEnergy(), GetNumberOfPoly(), GetTemperature(), Init(), Integrate(), Sample(), SampleDiscreteTwoBody(), SampleElastic(), SampleMax(), SetCoeff(), SetEnergy(), SetTemperature(), and ~G4ParticleHPLegendreStore().

theManager

G4InterpolationManager G4ParticleHPLegendreStore::theManager

private

Definition at line 93 of file G4ParticleHPLegendreStore.hh.

Referenced by InitInterpolation(), Sample(), SampleDiscreteTwoBody(), SampleElastic(), SampleMax(), and SetManager().

---

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

• source/processes/hadronic/models/particle_hp/include/G4ParticleHPLegendreStore.hh
• source/processes/hadronic/models/particle_hp/src/G4ParticleHPLegendreStore.cc