G4ParticleHPProduct Class Reference

#include <G4ParticleHPProduct.hh>

Collaboration diagram for G4ParticleHPProduct:

Classes
struct	toBeCached

Public Member Functions
	G4ParticleHPProduct ()
	~G4ParticleHPProduct ()
void	Init (std::istream &aDataFile, G4ParticleDefinition *projectile)
G4int	GetMultiplicity (G4double anEnergy)
G4ReactionProductVector *	Sample (G4double anEnergy, G4int nParticles)
G4double	GetMeanYield (G4double anEnergy)
void	SetProjectileRP (G4ReactionProduct *aIncidentPart)
void	SetTarget (G4ReactionProduct *aTarget)
G4ReactionProduct *	GetTarget ()
G4ReactionProduct *	GetProjectileRP ()
G4double	MeanEnergyOfThisInteraction ()
G4double	GetQValue ()
G4double	GetMassCode ()
G4double	GetMass ()

Private Attributes
G4double	theMassCode
G4double	theMass
G4int	theIsomerFlag
G4double	theGroundStateQValue
G4double	theActualStateQValue
G4int	theDistLaw
G4ParticleHPVector	theYield
G4VParticleHPEnergyAngular *	theDist
G4Cache< toBeCached >	fCache
G4HPMultiMethod	theMultiplicityMethod

Detailed Description

Definition at line 52 of file G4ParticleHPProduct.hh.

Constructor & Destructor Documentation

G4ParticleHPProduct()

G4ParticleHPProduct::G4ParticleHPProduct ( )

inline

Definition at line 63 of file G4ParticleHPProduct.hh.

  {
    theDist = 0;
    toBeCached val;
    fCache.Put( val );

    char * method = getenv( "G4PHP_MULTIPLICITY_METHOD" );
    if( method )  {
      if( G4String(method) == "Poisson" ) {
    theMultiplicityMethod = G4HPMultiPoisson;
      } else if( G4String(method) == "BetweenInts" ) {
    theMultiplicityMethod = G4HPMultiBetweenInts;
      } else {
    throw G4HadronicException(__FILE__, __LINE__, ("multiplicity method unknown to G4ParticleHPProduct" + G4String(method)).c_str());
      }
    } else {
      theMultiplicityMethod = G4HPMultiPoisson;
    }
  }

~G4ParticleHPProduct()

G4ParticleHPProduct::~G4ParticleHPProduct ( )

inline

Definition at line 82 of file G4ParticleHPProduct.hh.

  { 
    if(theDist != 0) delete theDist;
  }

Member Function Documentation

GetMass()

G4double G4ParticleHPProduct::GetMass ( )

inline

Definition at line 195 of file G4ParticleHPProduct.hh.

{return theMass;};

GetMassCode()

G4double G4ParticleHPProduct::GetMassCode ( )

inline

Definition at line 194 of file G4ParticleHPProduct.hh.

{return theMassCode;};

GetMeanYield()

G4double G4ParticleHPProduct::GetMeanYield ( G4double  anEnergy )

inline

Definition at line 156 of file G4ParticleHPProduct.hh.

  {
    return theYield.GetY(anEnergy);
  }

Here is the call graph for this function:

GetMultiplicity()

G4int G4ParticleHPProduct::GetMultiplicity

(

G4double

anEnergy

)

Definition at line 44 of file G4ParticleHPProduct.cc.

{
  //if(theDist == 0) { return 0; }
  //151120 TK Modified for solving reproducibility problem 
  if ( theDist == 0 ) { 
     fCache.Get().theCurrentMultiplicity = 0;
     return 0; 
  }

  G4double mean = theYield.GetY(anEnergy);
  //g  G4cout << "G4ParticleHPProduct MEAN NUMBER OF PARTICLES " << mean << " for " << theMass << G4endl;
  //if( mean <= 0. ) return 0;
  //151120 TK Modified for solving reproducibility problem 
  //This is also a real fix
  if ( mean <= 0. )  {
     fCache.Get().theCurrentMultiplicity = 0;
     return 0; 
  }

  G4int multi;
  multi = G4int(mean+0.0001);
  //if(theMassCode==0) multi = G4Poisson(mean); // @@@@gammas. please X-check this
  //080718
#ifdef PHP_AS_HP
  if ( theMassCode == 0 ) // DELETE THIS: IT MUST BE DONE FOR ALL PARTICLES
#endif
  { 
     if ( G4int ( mean ) == mean )
     {
        multi = (G4int) mean;
     }
     else
     {
#ifdef PHP_AS_HP
     multi = G4Poisson ( mean ); 
#else 
       if( theMultiplicityMethod == G4HPMultiPoisson ) {
     multi = G4Poisson ( mean );     
     if( getenv("G4PHPTEST") )  G4cout << " MULTIPLICITY MULTIPLIED " << multi << " " << theMassCode << G4endl;
       } else { // if( theMultiplicityMethod == G4HPMultiBetweenInts ) {
     G4double radnf = CLHEP::RandFlat::shoot();
     G4int imulti = G4int(mean);
     multi = imulti + G4int(radnf < mean-imulti);
     //  G4cout << theMass << " multi " << multi << " mean " << mean 
     //     << " radnf " << radnf << " mean-imulti " << mean-imulti << G4endl;
       }
#endif
    //       multi = int(mean);
    //       if( CLHEP::RandFlat::shoot() > mean-multi ) multi++;
     }
#ifdef G4PHPDEBUG
     if( getenv("G4ParticleHPDebug") ) G4cout << "G4ParticleHPProduct::GetMultiplicity " << theMassCode << " " << theMass << " multi " << multi << " mean " << mean << G4endl;
#endif
  }

  fCache.Get().theCurrentMultiplicity = static_cast<G4int>(mean);

  return multi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetProjectileRP()

G4ReactionProduct* G4ParticleHPProduct::GetProjectileRP ( )

inline

Definition at line 173 of file G4ParticleHPProduct.hh.

{ return fCache.Get().theProjectileRP; }

GetQValue()

G4double G4ParticleHPProduct::GetQValue ( )

inline

Definition at line 190 of file G4ParticleHPProduct.hh.

{ return theActualStateQValue; }

Here is the caller graph for this function:

GetTarget()

G4ReactionProduct* G4ParticleHPProduct::GetTarget ( void  )

inline

Definition at line 171 of file G4ParticleHPProduct.hh.

{ return fCache.Get().theTarget; }

Init()

void G4ParticleHPProduct::Init ( std::istream &  aDataFile, G4ParticleDefinition *  projectile  )

inline

Definition at line 87 of file G4ParticleHPProduct.hh.

  {
    aDataFile >> theMassCode>>theMass>>theIsomerFlag>>theDistLaw
              >> theGroundStateQValue>>theActualStateQValue;
    if( getenv("G4PHPTEST") )     G4cout << " G4ParticleHPProduct :: Init MassCode " << theMassCode << " " << theMass << " theActualStateQValue " << theActualStateQValue << G4endl;// GDEB
    if( getenv("G4PHPTEST") )     G4cout << " G4ParticleHPProduct :: Init theActualStateQValue " << theActualStateQValue << G4endl;// GDEB
    theGroundStateQValue*= CLHEP::eV;
    theActualStateQValue*= CLHEP::eV;
    theYield.Init(aDataFile, CLHEP::eV);
    theYield.Hash();
    if(theDistLaw==0)
    {
      // distribution not known, use E-independent, isotropic angular distribution
      theDist = new G4ParticleHPIsotropic;
    }
    else if(theDistLaw == 1)
    {
      // Continuum energy-angular distribution
      theDist = new G4ParticleHPContEnergyAngular(projectile);
    }
    else if(theDistLaw == 2)
    {
      // Discrete 2-body scattering
      theDist = new G4ParticleHPDiscreteTwoBody;
    }
    else if(theDistLaw == 3)
    {
      // Isotropic emission
      theDist = new G4ParticleHPIsotropic;
    }
    else if(theDistLaw == 4)
    {
      // Discrete 2-body recoil modification
      // not used for now. @@@@
      theDist = new G4ParticleHPDiscreteTwoBody; 
      // the above is only temporary;
      // recoils need to be addressed
      // properly
      delete theDist;
      theDist = 0;
    }
    //    else if(theDistLaw == 5)
    //    {
      // charged particles only, to be used in a later stage. @@@@
    //    }
    else if(theDistLaw == 6)
    {
      // N-Body phase space
      theDist = new G4ParticleHPNBodyPhaseSpace;
    }
    else if(theDistLaw == 7)
    {
      // Laboratory angular energy paraetrisation
      theDist = new G4ParticleHPLabAngularEnergy;
    }
    else
    {
      throw G4HadronicException(__FILE__, __LINE__, "distribution law unknown to G4ParticleHPProduct");
    }
    if(theDist!=0)
    {
      theDist->SetQValue(theActualStateQValue);      
      theDist->Init(aDataFile);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

MeanEnergyOfThisInteraction()

G4double G4ParticleHPProduct::MeanEnergyOfThisInteraction ( )

inline

Definition at line 175 of file G4ParticleHPProduct.hh.

  { 
    G4double result;
    if(theDist == 0)
    {
      result = 0;
    }
    else
    {
      result=theDist->MeanEnergyOfThisInteraction();
      result *= fCache.Get().theCurrentMultiplicity;
    }
    return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Sample()

G4ReactionProductVector * G4ParticleHPProduct::Sample	(	G4double	anEnergy,
		G4int	nParticles
	)

Definition at line 105 of file G4ParticleHPProduct.cc.

{
  if(theDist == 0) { return 0; }
  G4ReactionProductVector * result = new G4ReactionProductVector;

  theDist->SetTarget(fCache.Get().theTarget);
  theDist->SetProjectileRP(fCache.Get().theProjectileRP);
  G4int i;
//  G4double eMax = GetTarget()->GetMass()+GetNeutron()->GetMass()
//                  - theActualStateQValue;
  G4ReactionProduct * tmp;
  theDist->ClearHistories();

  for(i=0;i<multi;i++)
  {
#ifdef G4PHPDEBUG
 if( getenv("G4PHPTEST") )
    if( getenv("G4ParticleHPDebug") && tmp != 0 )    G4cout << multi << " " << i << " @@@ G4ParticleHPProduct::Sample " << anEnergy << " Mass " << theMassCode << " " << theMass << G4endl;
#endif
    tmp = theDist->Sample(anEnergy, theMassCode, theMass);
    if(tmp != 0) { result->push_back(tmp); }
#ifndef G4PHPDEBUG //GDEB
    if( getenv("G4ParticleHPDebug") && tmp != 0 )   G4cout << multi << " " << i << " @@@ G4ParticleHPProduct::Sample " << tmp->GetDefinition()->GetParticleName() << " E= " << tmp->GetKineticEnergy() << G4endl; 
#endif
  }
  if(multi == 0) 
    {
      tmp = theDist->Sample(anEnergy, theMassCode, theMass);
      delete  tmp;
    }
  /*
  //080901 TK Comment out, too many secondaries are produced in deuteron reactions
  if(theTarget->GetMass()<2*GeV) // @@@ take care of residuals in all cases
  {
  tmp = theDist->Sample(anEnergy, theMassCode, theMass);
  tmp->SetDefinition(G4Proton::Proton());
  if(tmp != 0) { result->push_back(tmp); }
  }
  */

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetProjectileRP()

void G4ParticleHPProduct::SetProjectileRP ( G4ReactionProduct *  aIncidentPart )

inline

Definition at line 161 of file G4ParticleHPProduct.hh.

  { 
    fCache.Get().theProjectileRP = aIncidentPart; 
  }

SetTarget()

void G4ParticleHPProduct::SetTarget ( G4ReactionProduct *  aTarget )

inline

Definition at line 166 of file G4ParticleHPProduct.hh.

  { 
    fCache.Get().theTarget = aTarget; 
  }

Member Data Documentation

fCache

G4Cache<toBeCached> G4ParticleHPProduct::fCache

private

Definition at line 218 of file G4ParticleHPProduct.hh.

theActualStateQValue

G4double G4ParticleHPProduct::theActualStateQValue

private

Definition at line 205 of file G4ParticleHPProduct.hh.

theDist

G4VParticleHPEnergyAngular* G4ParticleHPProduct::theDist

private

Definition at line 208 of file G4ParticleHPProduct.hh.

theDistLaw

G4int G4ParticleHPProduct::theDistLaw

private

Definition at line 206 of file G4ParticleHPProduct.hh.

theGroundStateQValue

G4double G4ParticleHPProduct::theGroundStateQValue

private

Definition at line 204 of file G4ParticleHPProduct.hh.

theIsomerFlag

G4int G4ParticleHPProduct::theIsomerFlag

private

Definition at line 203 of file G4ParticleHPProduct.hh.

theMass

G4double G4ParticleHPProduct::theMass

private

Definition at line 202 of file G4ParticleHPProduct.hh.

theMassCode

G4double G4ParticleHPProduct::theMassCode

private

Definition at line 195 of file G4ParticleHPProduct.hh.

theMultiplicityMethod

G4HPMultiMethod G4ParticleHPProduct::theMultiplicityMethod

private

Definition at line 220 of file G4ParticleHPProduct.hh.

theYield

G4ParticleHPVector G4ParticleHPProduct::theYield

private

Definition at line 207 of file G4ParticleHPProduct.hh.

---

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

• G4ParticleHPProduct.hh
• G4ParticleHPProduct.cc