G4ParticleHPContEnergyAngular Class Reference

#include <G4ParticleHPContEnergyAngular.hh>

Inheritance diagram for G4ParticleHPContEnergyAngular:

Public Member Functions
	G4ParticleHPContEnergyAngular (G4ParticleDefinition *proj)
	~G4ParticleHPContEnergyAngular ()
void	Init (std::istream &aDataFile)
G4double	MeanEnergyOfThisInteraction ()
G4ReactionProduct *	Sample (G4double anEnergy, G4double massCode, G4double mass)
void	ClearHistories ()
Public Member Functions inherited from G4VParticleHPEnergyAngular
	G4VParticleHPEnergyAngular ()
virtual	~G4VParticleHPEnergyAngular ()
virtual void	Init (std::istream &aDataFile)=0
virtual G4ReactionProduct *	Sample (G4double anEnergy, G4double massCode, G4double mass)=0
virtual G4double	MeanEnergyOfThisInteraction ()=0
void	SetProjectileRP (G4ReactionProduct *aIncidentParticleRP)
void	SetTarget (G4ReactionProduct *aTarget)
G4ReactionProduct *	GetTarget ()
G4ReactionProduct *	GetProjectileRP ()
G4ReactionProduct *	GetCMS ()
void	SetQValue (G4double aValue)
virtual void	ClearHistories ()

Additional Inherited Members
Protected Member Functions inherited from G4VParticleHPEnergyAngular
G4double	GetQValue ()

Detailed Description

Definition at line 48 of file G4ParticleHPContEnergyAngular.hh.

Constructor & Destructor Documentation

G4ParticleHPContEnergyAngular()

G4ParticleHPContEnergyAngular::G4ParticleHPContEnergyAngular ( G4ParticleDefinition *  proj )

inline

Definition at line 52 of file G4ParticleHPContEnergyAngular.hh.

    : theProjectile(proj)
  {
    theAngular = 0;
    currentMeanEnergy.Put( -2 );
    theTargetCode = -1.0;
    theAngularRep = -1;
    nEnergy = -1;
    theInterpolation = -1;
    fCacheAngular.Put(0); //fix
  }

~G4ParticleHPContEnergyAngular()

G4ParticleHPContEnergyAngular::~G4ParticleHPContEnergyAngular ( )

inline

Definition at line 64 of file G4ParticleHPContEnergyAngular.hh.

  {
    if(theAngular!=0) delete [] theAngular;
    if (fCacheAngular.Get() != 0) delete fCacheAngular.Get(); //fix
  }

Member Function Documentation

ClearHistories()

void G4ParticleHPContEnergyAngular::ClearHistories ( )

virtual

Reimplemented from G4VParticleHPEnergyAngular.

Definition at line 115 of file G4ParticleHPContEnergyAngular.cc.

{ 
  if (theAngular!= NULL) { 
    for (G4int i = 0; i < nEnergy; i++) theAngular[i].ClearHistories(); 
  }
 
  // Added fCacheAngular ClearHistories() - this is the one actually used!
  // Maybe theAngular does not even need ClearHistories()?
  if (fCacheAngular.Get() != 0) fCacheAngular.Get()->ClearHistories();
}

Referenced by ClearHistories().

Init()

void G4ParticleHPContEnergyAngular::Init ( std::istream &  aDataFile )

inlinevirtual

Implements G4VParticleHPEnergyAngular.

Definition at line 70 of file G4ParticleHPContEnergyAngular.hh.

  {
    aDataFile >> theTargetCode >> theAngularRep >> theInterpolation >> nEnergy;
    theAngular = new G4ParticleHPContAngularPar[nEnergy];
    theManager.Init(aDataFile);
    for(G4int i=0; i<nEnergy; i++)
    {
      theAngular[i].Init(aDataFile, theProjectile);
      theAngular[i].SetInterpolation(theInterpolation);
#ifndef PHP_AS_HP
      theAngular[i].PrepareTableInterpolation();
#endif
    }
  }

MeanEnergyOfThisInteraction()

G4double G4ParticleHPContEnergyAngular::MeanEnergyOfThisInteraction ( )

virtual

Implements G4VParticleHPEnergyAngular.

Definition at line 101 of file G4ParticleHPContEnergyAngular.cc.

{
  G4double result(0);
  if (currentMeanEnergy.Get() < -1) {
     throw G4HadronicException(__FILE__, __LINE__,
                               "G4ParticleHPContEnergyAngular: Logical error in Product class");
  } else {
    result = currentMeanEnergy.Get();
  }
  currentMeanEnergy.Put(-2);
  return result;
}

Referenced by Sample().

Sample()

G4ReactionProduct * G4ParticleHPContEnergyAngular::Sample ( G4double  anEnergy, G4double  massCode, G4double  mass  )

virtual

Implements G4VParticleHPEnergyAngular.

Definition at line 37 of file G4ParticleHPContEnergyAngular.cc.

{
  G4ReactionProduct* result;
  G4int i(0);
  G4int it(0);
  for (i = 0; i < nEnergy; i++) {
    it = i;
#ifdef PHP_AS_HP 
    if(theAngular[i].GetEnergy() > anEnergy) break;
#else
    if(theAngular[i].GetEnergy() >= anEnergy) break;
#endif
  }
 
  G4double targetMass = GetTarget()->GetMass();
  if (it == 0) {
    theAngular[0].SetTarget(GetTarget());
    theAngular[0].SetTargetCode(theTargetCode);
    theAngular[0].SetPrimary(GetProjectileRP());
    result = theAngular[0].Sample(anEnergy, massCode, targetMass, 
                                  theAngularRep, theInterpolation);
    currentMeanEnergy.Put(theAngular[0].MeanEnergyOfThisInteraction() );
 
  } else {
     // interpolation through alternating sampling. This needs improvement @@@
     // This is the cause of the He3 problem !!!!!!!!
     // See to it, if you can improve this.
     //G4double random = G4UniformRand();
     //G4double deltaE = theAngular[it].GetEnergy()-theAngular[it-1].GetEnergy();
     //G4double offset = theAngular[it].GetEnergy()-anEnergy;
     //if(random<offset/deltaE) it--;
     //--- create new 
     //  if (theManager.GetScheme(0) != LINLIN) {
     //    // asserted in G4ParticleHPContEnergyAngular::init there is only one range
#ifdef PHP_AS_HP
    theAngular[it].SetTarget(GetTarget());
    theAngular[it].SetTargetCode(theTargetCode);
    theAngular[it].SetPrimary(GetProjectileRP());
    result = theAngular[it].Sample(anEnergy, massCode, targetMass, 
                    theAngularRep, theInterpolation);
    currentMeanEnergy.Put(theAngular[it].MeanEnergyOfThisInteraction() ); 
#else
    if (fCacheAngular.Get() == NULL) {
      G4ParticleHPContAngularPar* angpar = new G4ParticleHPContAngularPar(theProjectile);
      fCacheAngular.Put(angpar);
    }
    fCacheAngular.Get()->SetInterpolation(theInterpolation);
    fCacheAngular.Get()->BuildByInterpolation(anEnergy, theManager.GetScheme(0),
                                              (theAngular[it-1]), (theAngular[it]) );
    fCacheAngular.Get()->SetTarget(GetTarget());
    fCacheAngular.Get()->SetTargetCode(theTargetCode);
    fCacheAngular.Get()->SetPrimary(GetProjectileRP());
 
    result = fCacheAngular.Get()->Sample(anEnergy, massCode, targetMass, 
                                         theAngularRep, theInterpolation);
    currentMeanEnergy.Put(fCacheAngular.Get()->MeanEnergyOfThisInteraction() );
#endif
  } // end (it != 0) branch  
 
  return result;
}

---

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

• G4ParticleHPContEnergyAngular.hh
• G4ParticleHPContEnergyAngular.cc