G4ParticleHPDAInelasticFS Class Reference

#include <G4ParticleHPDAInelasticFS.hh>

Inheritance diagram for G4ParticleHPDAInelasticFS:

Public Member Functions
G4HadFinalState *	ApplyYourself (const G4HadProjectile &theTrack)
void	BaseApply (const G4HadProjectile &theTrack, G4ParticleDefinition **theDefs, G4int nDef)
	G4ParticleHPDAInelasticFS ()
G4double	GetA ()
G4int	GetM ()
G4double	GetN ()
virtual G4ParticleHPVector *	GetXsec ()
virtual G4double	GetXsec (G4double anEnergy)
G4double	GetZ ()
G4bool	HasAnyData ()
G4bool	HasFSData ()
G4bool	HasXsec ()
void	Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &aFSType, G4ParticleDefinition *)
void	Init (G4double A, G4double Z, G4String &dirName, G4String &aFSType, G4ParticleDefinition *projectile)
void	InitGammas (G4double AR, G4double ZR)
G4ParticleHPFinalState *	New ()
void	SetA_Z (G4double anA, G4double aZ, G4int aM=0)
void	SetAZMs (G4double anA, G4double aZ, G4int aM, G4ParticleHPDataUsed used)
void	SetProjectile (G4ParticleDefinition *projectile)
	~G4ParticleHPDAInelasticFS ()

Protected Member Functions
void	adjust_final_state (G4LorentzVector)

Protected Attributes
G4String	gammaPath
G4bool	hasAnyData
G4bool	hasFSData
G4bool	hasXsec
G4double	Qvalue
G4int	secID
G4ParticleHPAngular *	theAngularDistribution
G4double	theBaseA
G4int	theBaseM
G4double	theBaseZ
G4ParticleHPEnAngCorrelation *	theEnergyAngData
G4ParticleHPEnergyDistribution *	theEnergyDistribution
G4ParticleHPPhotonDist *	theFinalStatePhotons
G4ParticleHPDeExGammas	theGammas
G4ParticleHPNames	theNames
G4int	theNDLDataA
G4int	theNDLDataM
G4int	theNDLDataZ
G4double	theNuclearMassDifference
G4ParticleDefinition *	theProjectile
G4Cache< G4HadFinalState * >	theResult
G4ParticleHPVector *	theXsection

Detailed Description

Definition at line 41 of file G4ParticleHPDAInelasticFS.hh.

Constructor & Destructor Documentation

G4ParticleHPDAInelasticFS()

G4ParticleHPDAInelasticFS::G4ParticleHPDAInelasticFS

(

)

Definition at line 38 of file G4ParticleHPDAInelasticFS.cc.

{
  secID = G4PhysicsModelCatalog::GetModelID( "model_G4ParticleHPDAInelasticFS_F36" );
}

References G4PhysicsModelCatalog::GetModelID(), and G4ParticleHPFinalState::secID.

Referenced by New().

~G4ParticleHPDAInelasticFS()

G4ParticleHPDAInelasticFS::~G4ParticleHPDAInelasticFS ( )

inline

Definition at line 46 of file G4ParticleHPDAInelasticFS.hh.

{}

Member Function Documentation

adjust_final_state()

void G4ParticleHPFinalState::adjust_final_state ( G4LorentzVector  init_4p_lab )

protectedinherited

Definition at line 47 of file G4ParticleHPFinalState.cc.

{
 
   G4double minimum_energy = 1*keV;
 
   if ( G4ParticleHPManager::GetInstance()->GetDoNotAdjustFinalState() ) return;
 
   G4int nSecondaries = theResult.Get()->GetNumberOfSecondaries();
 
   G4int sum_Z = 0;
   G4int sum_A = 0;
   G4int max_SecZ = 0;
   G4int max_SecA = 0;
   G4int imaxA = -1;
   for ( int i = 0 ; i < nSecondaries ; i++ )
   {
      //G4cout << "G4ParticleHPFinalState::adjust_final_state theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetParticleName() = " << theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetParticleName() << G4endl;
      sum_Z += theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber();
      max_SecZ = std::max ( max_SecZ , theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber() );
      sum_A += theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass();
      max_SecA = std::max ( max_SecA , theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() );
      if ( theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() == max_SecA ) imaxA = i;
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))    G4cout << "G4ParticleHPFinalState::adjust_final_stat SECO " << i << " " <<theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetParticleName() << G4endl;
#endif
 
   }
 
   G4ParticleDefinition* resi_pd = 0;
 
   G4double baseZNew = theBaseZ;
   G4double baseANew = theBaseA;
   if( theProjectile == G4Neutron::Neutron() ) {
     baseANew ++;
   } else if( theProjectile == G4Proton::Proton() ) {
     baseZNew ++;
     baseANew ++;
   } else if( theProjectile == G4Deuteron::Deuteron() ) {
     baseZNew ++;
     baseANew += 2;
   } else if( theProjectile == G4Triton::Triton() ) {
     baseZNew ++;
     baseANew += 3;
   } else if( theProjectile == G4He3::He3() ) {
     baseZNew += 2;
     baseANew += 3;
   } else if( theProjectile == G4Alpha::Alpha() ) {
     baseZNew += 2;
     baseANew += 4;
   }
 
#ifdef G4PHPDEBUG
   if( std::getenv("G4ParticleHPDebug")) G4cout  << "G4ParticleHPFinalState::adjust_final_stat  BaseZ " << baseZNew << " BaseA " << baseANew << " sum_Z " << sum_Z << " sum_A " << sum_A << G4endl;
#endif
 
   G4bool needOneMoreSec = false;
   G4ParticleDefinition* oneMoreSec_pd = 0;
   if ( (int)(baseZNew - sum_Z) == 0 && (int)(baseANew - sum_A) == 0 )
   {
      //All secondaries are already created;
      resi_pd = theResult.Get()->GetSecondary( imaxA )->GetParticle()->GetDefinition(); 
   }
   else
   {
      if ( max_SecA >= int(baseANew - sum_A) ) 
      {
         //Most heavy secondary is interpreted as residual
         resi_pd = theResult.Get()->GetSecondary( imaxA )->GetParticle()->GetDefinition(); 
         needOneMoreSec = true;
      }
      else 
      {
         //creation of residual is requierd 
    resi_pd = G4IonTable::GetIonTable()->GetIon ( int(baseZNew - sum_Z) , (int)(baseANew - sum_A) , 0.0 );
      }
 
      if ( needOneMoreSec )
      {
         if ( int(baseZNew - sum_Z) == 0 && (int)(baseANew - sum_A) > 0 )
         {
            //In this case, one neutron is added to secondaries 
            if ( int(baseANew - sum_A) > 1 ) G4cout << "More than one neutron is required for the balance of baryon number!" << G4endl;
            oneMoreSec_pd = G4Neutron::Neutron();
         }
         else 
         {
#ifdef G4PHPDEBUG
       if( std::getenv("G4ParticleHPDebug")) G4cout << this << "G4ParticleHPFinalState oneMoreSec_pd Z " << baseZNew << " - " << sum_Z << " A " << baseANew << " - " << sum_A << " projectile " << theProjectile->GetParticleName() << G4endl;
#endif
       oneMoreSec_pd = G4IonTable::GetIonTable()->GetIon ( int(baseZNew - sum_Z) , (int)(baseANew - sum_A) , 0.0 );
       if( !oneMoreSec_pd ) {
         G4cerr << this << "G4ParticleHPFinalState oneMoreSec_pd Z " << baseZNew << " - " << sum_Z << " A " << baseANew << " - " << sum_A << " projectile " << theProjectile->GetParticleName() << G4endl;
         G4Exception("G4ParticleHPFinalState:adjust_final_state",
             "Warning",
             JustWarning,
             "No adjustment will be done!");
         return;
       }
         }
      }
  
      if ( resi_pd == 0 )
      {
         // theNDLDataZ,A has the Z and A of used NDL file
    G4double ndlZNew = theNDLDataZ;
    G4double ndlANew = theNDLDataA;
    if( theProjectile == G4Neutron::Neutron() ) {
      ndlANew ++;
    } else if( theProjectile == G4Proton::Proton() ) {
      ndlZNew ++;
      ndlANew ++;
    } else if( theProjectile == G4Deuteron::Deuteron() ) {
      ndlZNew ++;
      ndlANew += 2;
    } else if( theProjectile == G4Triton::Triton() ) {
      ndlZNew ++;
      ndlANew += 3;
    } else if( theProjectile == G4He3::He3() ) {
      ndlZNew += 2;
      ndlANew += 3;
    } else if( theProjectile == G4Alpha::Alpha() ) {
      ndlZNew += 2;
      ndlANew += 4;
    }
        // theNDLDataZ,A has the Z and A of used NDL file
        if ( (int)(ndlZNew - sum_Z) == 0 && (int)(ndlANew - sum_A) == 0 )
        {
           G4int dif_Z = ( int ) ( theNDLDataZ - theBaseZ );
           G4int dif_A = ( int ) ( theNDLDataA - theBaseA );
           resi_pd = G4IonTable::GetIonTable()->GetIon ( max_SecZ - dif_Z , max_SecA - dif_A , 0.0 );
       if( !resi_pd ) {
         G4cerr << "G4ParticleHPFinalState resi_pd Z " << max_SecZ << " - " << dif_Z << " A " << max_SecA << " - " << dif_A << " projectile " << theProjectile->GetParticleName() << G4endl;
         G4Exception("G4ParticleHPFinalState:adjust_final_state",
             "Warning",
             JustWarning,
             "No adjustment will be done!");
         return;
       }
 
           for ( int i = 0 ; i < nSecondaries ; i++ )
           {
              if ( theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber() == max_SecZ  
                && theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() == max_SecA )
              {
                 G4ThreeVector p = theResult.Get()->GetSecondary( i )->GetParticle()->GetMomentum();
                 p = p * resi_pd->GetPDGMass()/ G4IonTable::GetIonTable()->GetIon ( max_SecZ , max_SecA , 0.0 )->GetPDGMass(); 
                 theResult.Get()->GetSecondary( i )->GetParticle()->SetDefinition( resi_pd );
                 theResult.Get()->GetSecondary( i )->GetParticle()->SetMomentum( p );
              } 
           }
        }
      }
   }
 
 
   G4LorentzVector secs_4p_lab( 0.0 );
 
   G4int n_sec = theResult.Get()->GetNumberOfSecondaries();
   G4double fast = 0;
   G4double slow = 1;
   G4int ifast = 0;
   G4int islow = 0;
   G4int ires = -1;
 
   for ( G4int i = 0 ; i < n_sec ; i++ )
   {
 
      //G4cout << "HP_DB " << i 
      //       << " " << theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetParticleName() 
      //       << " 4p " << theResult.GetSecondary( i )->GetParticle()->Get4Momentum() 
      //       << " ke " << theResult.GetSecondary( i )->GetParticle()->Get4Momentum().e() - theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetPDGMass() 
      //       << G4endl;
 
      secs_4p_lab += theResult.Get()->GetSecondary( i )->GetParticle()->Get4Momentum();
 
      G4double beta = 0;
      if ( theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition() != G4Gamma::Gamma() )
      {
         beta = theResult.Get()->GetSecondary( i )->GetParticle()->Get4Momentum().beta(); 
      }
      else
      {
         beta = 1;
      }
 
      if ( theResult.Get()->GetSecondary( i )->GetParticle()->GetDefinition() == resi_pd ) ires = i; 
 
      if ( slow > beta && beta != 0 ) 
      {
         slow = beta; 
         islow = i;
      }
 
      if ( fast <= beta ) 
      {
         if ( fast != 1 )
         {
            fast = beta; 
            ifast = i;
         } 
         else
         {
//          fast is already photon then check E
            G4double e = theResult.Get()->GetSecondary( i )->GetParticle()->Get4Momentum().e();
            if ( e > theResult.Get()->GetSecondary( ifast )->GetParticle()->Get4Momentum().e() )   
            {
//             among photons, the highest E becomes the fastest 
               ifast = i; 
            }
         } 
      }
   }
 
 
   G4LorentzVector dif_4p = init_4p_lab - secs_4p_lab;
 
   //G4cout << "HP_DB dif_4p " << init_4p_lab - secs_4p_lab << G4endl;
   //G4cout << "HP_DB dif_3p mag " << ( dif_4p.v() ).mag() << G4endl;
   //G4cout << "HP_DB dif_e " << dif_4p.e() - ( dif_4p.v() ).mag()<< G4endl;
 
   G4LorentzVector p4(0);
   if ( ires == -1 ) 
   {
//    Create and Add Residual Nucleus 
      ires = nSecondaries;
      nSecondaries += 1;
 
      G4DynamicParticle* res = new G4DynamicParticle ( resi_pd , dif_4p.v() );    
      theResult.Get()->AddSecondary ( res, secID );    
 
      p4 = res->Get4Momentum(); 
      if ( slow > p4.beta() ) 
      {
         slow = p4.beta(); 
         islow = ires;
      }
      dif_4p = init_4p_lab - ( secs_4p_lab + p4 );  
   }
 
   if ( needOneMoreSec && oneMoreSec_pd)
     //
     // fca: this is not a fix, this is a crash avoidance...
     // fca: the baryon number is still wrong, most probably because it
     // fca: should have been decreased, but since we could not create a particle
     // fca: we just do not add it
     //
   {
      nSecondaries += 1;
      G4DynamicParticle* one = new G4DynamicParticle ( oneMoreSec_pd , dif_4p.v() );    
      theResult.Get()->AddSecondary ( one, secID );    
      p4 = one->Get4Momentum(); 
      if ( slow > p4.beta() ) 
      {
         slow = p4.beta(); 
         islow = nSecondaries-1; //Because the first is 0th, so the last becomes "nSecondaries-1"
      }
      dif_4p = init_4p_lab - ( secs_4p_lab + p4 );  
   }
 
   //Which is bigger dif_p or dif_e
 
   if ( dif_4p.v().mag() < std::abs( dif_4p.e() ) )
   {
 
      // Adjust p
      //if ( dif_4p.v().mag() < 1*MeV )
      if ( minimum_energy < dif_4p.v().mag() && dif_4p.v().mag() < 1*MeV )
      {
 
         nSecondaries += 1;
         theResult.Get()->AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , dif_4p.v() ), secID );    
 
      }
      else
      {
         //G4cout << "HP_DB Difference in dif_p is too large (>1MeV) or too small(<1keV) to adjust, so that give up tuning" << G4endl;
      }
 
   }
   else
   {
 
      // dif_p > dif_e 
      // at first momentum 
      // Move residual momentum
 
      p4 = theResult.Get()->GetSecondary( ires )->GetParticle()->Get4Momentum();
      theResult.Get()->GetSecondary( ires )->GetParticle()->SetMomentum( p4.v() + dif_4p.v() ); 
      dif_4p = init_4p_lab - ( secs_4p_lab - p4 + theResult.Get()->GetSecondary( ires )->GetParticle()->Get4Momentum()  );  
 
      //G4cout << "HP_DB new residual kinetic energy " << theResult.GetSecondary( ires )->GetParticle()->GetKineticEnergy() << G4endl;
 
   }
 
   G4double dif_e = dif_4p.e() - ( dif_4p.v() ).mag();
   //G4cout << "HP_DB dif_e " << dif_e << G4endl;
 
   if ( dif_e > 0 )
   {
 
//    create 2 gamma 
 
      nSecondaries += 2;
      G4double e1 = ( dif_4p.e() -dif_4p.v().mag() ) / 2;
      
      if ( minimum_energy < e1 )  
      {
         G4double costh = 2.*G4UniformRand()-1.;
         G4double phi = twopi*G4UniformRand();
         G4ThreeVector dir( std::sin(std::acos(costh))*std::cos(phi), 
                            std::sin(std::acos(costh))*std::sin(phi),
                            costh);
         theResult.Get()->AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , e1*dir ),  secID );    
         theResult.Get()->AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , -e1*dir ), secID );    
      }
      else
      {
         //G4cout << "HP_DB Difference is too small(<1keV) to adjust, so that neglect it" << G4endl;
      }
 
   }
   else    //dif_e < 0
   {
 
//    At first reduce KE of the fastest secondary;
      G4double ke0 = theResult.Get()->GetSecondary( ifast )->GetParticle()->GetKineticEnergy();
      G4ThreeVector p0 = theResult.Get()->GetSecondary( ifast )->GetParticle()->GetMomentum();
      G4ThreeVector dir = ( theResult.Get()->GetSecondary( ifast )->GetParticle()->GetMomentum() ).unit();
 
      //G4cout << "HP_DB ifast " << ifast << " ke0 " << ke0 << G4endl;
 
      if ( ke0 + dif_e > 0 )
      {
         theResult.Get()->GetSecondary( ifast )->GetParticle()->SetKineticEnergy( ke0 + dif_e ); 
         G4ThreeVector dp = p0 - theResult.Get()->GetSecondary( ifast )->GetParticle()->GetMomentum();  
 
         G4ThreeVector p = theResult.Get()->GetSecondary( islow )->GetParticle()->GetMomentum();
         //theResult.GetSecondary( islow )->GetParticle()->SetMomentum( p - dif_e*dir ); 
         theResult.Get()->GetSecondary( islow )->GetParticle()->SetMomentum( p + dp ); 
      }
      else
      {
         //G4cout << "HP_DB Difference in dif_e too large ( <0MeV ) to adjust, so that give up tuning" << G4endl;
      }
 
   }
 
}

References G4HadFinalState::AddSecondary(), G4Alpha::Alpha(), CLHEP::HepLorentzVector::beta(), anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4Deuteron::Deuteron(), CLHEP::HepLorentzVector::e(), e1, G4cerr, G4cout, G4endl, G4Exception(), G4UniformRand, G4Gamma::Gamma(), G4Cache< VALTYPE >::Get(), G4DynamicParticle::Get4Momentum(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4DynamicParticle::GetDefinition(), G4ParticleHPManager::GetInstance(), G4IonTable::GetIon(), G4IonTable::GetIonTable(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentum(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4HadFinalState::GetSecondary(), G4He3::He3(), JustWarning, keV, CLHEP::Hep3Vector::mag(), G4INCL::Math::max(), MeV, G4Neutron::Neutron(), G4Proton::Proton(), G4ParticleHPFinalState::secID, G4DynamicParticle::SetDefinition(), G4DynamicParticle::SetKineticEnergy(), G4DynamicParticle::SetMomentum(), G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseZ, G4ParticleHPFinalState::theNDLDataA, G4ParticleHPFinalState::theNDLDataZ, G4ParticleHPFinalState::theProjectile, G4ParticleHPFinalState::theResult, G4Triton::Triton(), twopi, and CLHEP::HepLorentzVector::v().

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), and G4ParticleHPInelasticCompFS::CompositeApply().

ApplyYourself()

G4HadFinalState * G4ParticleHPDAInelasticFS::ApplyYourself ( const G4HadProjectile &  theTrack )

virtual

Implements G4ParticleHPInelasticBaseFS.

Definition at line 43 of file G4ParticleHPDAInelasticFS.cc.

{
// these are the particle types in the final state
 
  G4ParticleDefinition * theDefs[2];
  theDefs[0] = G4Deuteron::Deuteron();
  theDefs[1] = G4Alpha::Alpha();
  
// fill the final state  
  G4ParticleHPInelasticBaseFS::BaseApply(theTrack, theDefs, 2);
  
// return the result
   return theResult.Get();
}

References G4Alpha::Alpha(), G4ParticleHPInelasticBaseFS::BaseApply(), G4Deuteron::Deuteron(), G4Cache< VALTYPE >::Get(), and G4ParticleHPFinalState::theResult.

BaseApply()

void G4ParticleHPInelasticBaseFS::BaseApply ( const G4HadProjectile &  theTrack, G4ParticleDefinition **  theDefs, G4int  nDef  )

inherited

Definition at line 187 of file G4ParticleHPInelasticBaseFS.cc.

{
 
// prepare neutron
  if ( theResult.Get() == NULL ) theResult.Put( new G4HadFinalState );
  theResult.Get()->Clear();
  G4double eKinetic = theTrack.GetKineticEnergy();
  const G4HadProjectile *hadProjectile = &theTrack;
  G4ReactionProduct incidReactionProduct( const_cast<G4ParticleDefinition *>(hadProjectile->GetDefinition()) );
  incidReactionProduct.SetMomentum( hadProjectile->Get4Momentum().vect() );
  incidReactionProduct.SetKineticEnergy( eKinetic );
 
// prepare target
  G4double targetMass;
  G4double eps = 0.0001;
  targetMass = ( G4NucleiProperties::GetNuclearMass(static_cast<G4int>(theBaseA+eps), static_cast<G4int>(theBaseZ+eps))) /
               //theProjectile->GetPDGMass();
               G4Neutron::Neutron()->GetPDGMass();
 
  //give priority to ENDF vales for target mass
  if(theEnergyAngData!=0)
     { targetMass = theEnergyAngData->GetTargetMass(); }
  if(theAngularDistribution!=0)
     { targetMass = theAngularDistribution->GetTargetMass(); }
 
//080731a
//110512 TKDB ENDF-VII.0 21Sc45 has trouble in MF4MT22 (n,np) targetMass is not properly recorded.
//if ( targetMass == 0 ) G4cout << "080731a It looks like something wrong value in G4NDL, please update the latest version. If you use the latest, then please report this problem to Geant4 Hyper news." << G4endl;
  if ( targetMass == 0 ) 
  {
     //G4cout << "TKDB targetMass = 0; ENDF-VII.0 21Sc45 has trouble in MF4MT22 (n,np) targetMass is not properly recorded. This could be a similar situation." << G4endl;
     //targetMass = ( G4NucleiProperties::GetNuclearMass(static_cast<G4int>(theBaseA+eps), static_cast<G4int>(theBaseZ+eps))) / theProjectile->GetPDGMass();
     targetMass = ( G4NucleiProperties::GetNuclearMass(static_cast<G4int>(theBaseA+eps), static_cast<G4int>(theBaseZ+eps))) / G4Neutron::Neutron()->GetPDGMass();
  }
 
  G4Nucleus aNucleus;
  G4ReactionProduct theTarget; 
  //G4ThreeVector neuVelo = (1./hadProjectile->GetDefinition()->GetPDGMass())*incidReactionProduct.GetMomentum();
  //theTarget = aNucleus.GetBiasedThermalNucleus( targetMass, neuVelo, theTrack.GetMaterial()->GetTemperature());
   //G4Nucleus::GetBiasedThermalNucleus requests normalization of mass and velocity in neutron mass
   G4ThreeVector neuVelo = (1./G4Neutron::Neutron()->GetPDGMass())*incidReactionProduct.GetMomentum();
   theTarget = aNucleus.GetBiasedThermalNucleus( targetMass, neuVelo, theTrack.GetMaterial()->GetTemperature());
 
  theTarget.SetDefinition( G4IonTable::GetIonTable()->GetIon( G4int(theBaseZ), G4int(theBaseA) , 0.0 ) );
 
// prepare energy in target rest frame
  G4ReactionProduct boosted;
  boosted.Lorentz(incidReactionProduct, theTarget);
  eKinetic = boosted.GetKineticEnergy();
  G4double orgMomentum = boosted.GetMomentum().mag();
  
// Take N-body phase-space distribution, if no other data present.
  if(!HasFSData()) // adding the residual is trivial here @@@
  {
    G4ParticleHPNBodyPhaseSpace thePhaseSpaceDistribution;
    G4double aPhaseMass=0;
    G4int ii;
    for(ii=0; ii<nDef; ii++) 
    {
      aPhaseMass+=theDefs[ii]->GetPDGMass();
    }
 
    //----------------------------------------------------------------------------
    if(Qvalue<1.*CLHEP::keV && Qvalue>-1.*CLHEP::keV){ //Not in the G4NDL lib or not calculated yet:
      //Calculate residual:
      G4int ResidualA=theBaseA;
      G4int ResidualZ=theBaseZ;
      for (ii = 0; ii < nDef; ii++) {
        ResidualZ -= theDefs[ii]->GetAtomicNumber();
        ResidualA -= theDefs[ii]->GetBaryonNumber();
      }
 
      if (ResidualA > 0 && ResidualZ > 0) {
        G4ParticleDefinition* resid = G4IonTable::GetIonTable()->GetIon(ResidualZ,ResidualA);
        Qvalue = incidReactionProduct.GetMass()+theTarget.GetMass()-aPhaseMass-resid->GetPDGMass();
      }
 
      if (Qvalue > 400*CLHEP::MeV || Qvalue < -400*CLHEP::MeV) { 
        //Then Q value is probably too large ...
        Qvalue = 1.1*CLHEP::keV;
      }
    }
    //----------------------------------------------------------------------------
 
    thePhaseSpaceDistribution.Init(aPhaseMass, nDef);
    thePhaseSpaceDistribution.SetProjectileRP(&incidReactionProduct);
    thePhaseSpaceDistribution.SetTarget(&theTarget);
    thePhaseSpaceDistribution.SetQValue(Qvalue);
 
    for(ii=0; ii<nDef; ii++) 
    {
      G4double massCode = 1000.*std::abs(theDefs[ii]->GetPDGCharge());
      massCode += theDefs[ii]->GetBaryonNumber(); 
      G4double dummy = 0;
      G4ReactionProduct * aSec = thePhaseSpaceDistribution.Sample(eKinetic, massCode, dummy);
      aSec->Lorentz(*aSec, -1.*theTarget);
      G4DynamicParticle * aPart = new G4DynamicParticle();
      aPart->SetDefinition(aSec->GetDefinition());
      aPart->SetMomentum(aSec->GetMomentum());
      delete aSec;
      theResult.Get()->AddSecondary(aPart, secID);     
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))  G4cout << this << " G4ParticleHPInelasticBaseFS::BaseApply NoFSData add secondary " << aPart->GetParticleDefinition()->GetParticleName() << " E= " << aPart->GetKineticEnergy() << " NSECO " << theResult.Get()->GetNumberOfSecondaries() << G4endl;
#endif
    }   
    theResult.Get()->SetStatusChange(stopAndKill);
    //TK120607
    //Final momentum check should be done before return
    G4ParticleDefinition* targ_pd = G4IonTable::GetIonTable()->GetIon ( (G4int)theBaseZ , (G4int)theBaseA , 0.0 );
    G4LorentzVector targ_4p_lab ( theTarget.GetMomentum() , std::sqrt( targ_pd->GetPDGMass()*targ_pd->GetPDGMass() + theTarget.GetMomentum().mag2() ) );
    G4LorentzVector proj_4p_lab = theTrack.Get4Momentum();
    G4LorentzVector init_4p_lab = proj_4p_lab + targ_4p_lab;
    adjust_final_state ( init_4p_lab );
 
    return;
  }
 
// set target and neutron in the relevant exit channel
  if(theAngularDistribution!=0) 
  {
    theAngularDistribution->SetTarget(theTarget);
    theAngularDistribution->SetProjectileRP(incidReactionProduct);
  }
  else if(theEnergyAngData!=0)
  {
    theEnergyAngData->SetTarget(theTarget);
    theEnergyAngData->SetProjectileRP(incidReactionProduct);
  }
  
  G4ReactionProductVector * tmpHadrons = 0;
#ifdef G4PHPDEBUG
  //To avoid compilation error around line 532.
  G4int ii(0);
#endif
  G4int dummy;
  unsigned int i;
 
  if(theEnergyAngData != 0)
  {
    tmpHadrons = theEnergyAngData->Sample(eKinetic);
 
    if ( ! G4ParticleHPManager::GetInstance()->GetDoNotAdjustFinalState() ) {
      //141017 Fix BEGIN 
      //Adjust A and Z in the case of miss much between selected data and target nucleus 
      if ( tmpHadrons != NULL ) {
         G4int sumA = 0;
         G4int sumZ = 0;
         G4int maxA = 0;
         G4int jAtMaxA = 0;
         for ( G4int j = 0 ; j != (G4int)tmpHadrons->size() ; j++ ) {
            //G4cout << __FILE__ << " " << __LINE__ << "th line: tmpHadrons->at(j)->GetDefinition()->GetParticleName() = " << tmpHadrons->at(j)->GetDefinition()->GetParticleName() << G4endl;
            if ( tmpHadrons->at(j)->GetDefinition()->GetBaryonNumber() > maxA ) {
               maxA = tmpHadrons->at(j)->GetDefinition()->GetBaryonNumber(); 
               jAtMaxA = j; 
            }
            sumA += tmpHadrons->at(j)->GetDefinition()->GetBaryonNumber();
            sumZ += G4int( tmpHadrons->at(j)->GetDefinition()->GetPDGCharge() + eps );
         }
         G4int dA = (G4int)theBaseA + hadProjectile->GetDefinition()->GetBaryonNumber() - sumA;
         G4int dZ = (G4int)theBaseZ + G4int( hadProjectile->GetDefinition()->GetPDGCharge() + eps ) - sumZ;
         if ( dA < 0 || dZ < 0 ) {
            G4int newA = tmpHadrons->at(jAtMaxA)->GetDefinition()->GetBaryonNumber() + dA ;
            G4int newZ = G4int( tmpHadrons->at(jAtMaxA)->GetDefinition()->GetPDGCharge() + eps ) + dZ;
        if(newA>newZ && newZ>0){
          G4ParticleDefinition* pd = G4IonTable::GetIonTable()->GetIon ( newZ , newA );
          tmpHadrons->at( jAtMaxA )->SetDefinition( pd );
        }
         }
      }
      //141017 Fix END
    }
  }
  else if(theAngularDistribution!= 0)
  {
    G4bool * Done = new G4bool[nDef];
    G4int i0;
    for(i0=0; i0<nDef; i0++) Done[i0] = false;
 
//Following lines are commented out to fix coverity defeat 58622 
//    if(tmpHadrons == 0) 
//    {
      tmpHadrons = new G4ReactionProductVector;
//    }
//    else
//    {
//      for(i=0; i<tmpHadrons->size(); i++)
//      {
//  for(ii=0; ii<nDef; ii++)
//          if(!Done[ii] && tmpHadrons->operator[](i)->GetDefinition() == theDefs[ii]) 
//              Done[ii] = true;
//      }
#ifdef G4PHPDEBUG
//      if( getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply secondary previously added " << tmpHadrons->operator[](i)->GetDefinition()->GetParticleName() << " E= " << tmpHadrons->operator[](i)->GetKineticEnergy() << G4endl;
#endif
//    }
    G4ReactionProduct * aHadron;
    G4double localMass = ( G4NucleiProperties::GetNuclearMass(static_cast<G4int>(theBaseA+eps), static_cast<G4int>(theBaseZ+eps)));
    G4ThreeVector bufferedDirection(0,0,0);
    for(i0=0; i0<nDef; i0++)
    {
      if(!Done[i0])
      {
        aHadron = new G4ReactionProduct;
    if(theEnergyDistribution!=0)
    {
      aHadron->SetDefinition(theDefs[i0]);
      aHadron->SetKineticEnergy(theEnergyDistribution->Sample(eKinetic, dummy));
    }
    else if(nDef == 1)
    {
      aHadron->SetDefinition(theDefs[i0]);
      aHadron->SetKineticEnergy(eKinetic);
    }
    else if(nDef == 2)
    {
      aHadron->SetDefinition(theDefs[i0]);
      aHadron->SetKineticEnergy(50*CLHEP::MeV);
    }
    else
    {
      throw G4HadronicException(__FILE__, __LINE__, "No energy distribution to sample from in InelasticBaseFS::BaseApply");
    }
    theAngularDistribution->SampleAndUpdate(*aHadron);
    if(theEnergyDistribution==0 && nDef == 2)
    {
      if(i0==0)
      {
        G4double mass1 = theDefs[0]->GetPDGMass();
        G4double mass2 = theDefs[1]->GetPDGMass();
        G4double massn = theProjectile->GetPDGMass();
        G4int z1 = static_cast<G4int>(theBaseZ+eps-theDefs[0]->GetPDGCharge()-theDefs[1]->GetPDGCharge());
        G4int a1 = static_cast<G4int>(theBaseA+eps)-theDefs[0]->GetBaryonNumber()-theDefs[1]->GetBaryonNumber();
        G4double concreteMass = G4NucleiProperties::GetNuclearMass(a1, z1);
        G4double availableEnergy = eKinetic+massn+localMass-mass1-mass2-concreteMass;
        // available kinetic energy in CMS (non relativistic)
        G4double emin = availableEnergy+mass1+mass2 - std::sqrt((mass1+mass2)*(mass1+mass2)+orgMomentum*orgMomentum);
        G4double p1=std::sqrt(2.*mass2*emin);
        bufferedDirection = p1*aHadron->GetMomentum().unit();
#ifdef G4PHPDEBUG
        if(std::getenv("G4ParticleHPDebug")) // @@@@@ verify the nucleon counting...
        { 
          G4cout << "G4ParticleHPInelasticBaseFS "<<z1<<" "<<theBaseZ<<" "<<a1<<" "<<theBaseA<<" "<<availableEnergy<<" "
                 << emin<<G4endl;
            }
#endif
      }
      else
      {
        bufferedDirection = -bufferedDirection;
      }
      // boost from cms to lab
#ifdef G4PHPDEBUG
        if(std::getenv("G4ParticleHPDebug")) 
      {
        G4cout << " G4ParticleHPInelasticBaseFS "<<bufferedDirection.mag2()<<G4endl;
      }
#endif
      aHadron->SetTotalEnergy( std::sqrt(aHadron->GetMass()*aHadron->GetMass()
                                  +bufferedDirection.mag2()) );
      aHadron->SetMomentum(bufferedDirection);
          aHadron->Lorentz(*aHadron, -1.*(theTarget+incidReactionProduct)); 
#ifdef G4PHPDEBUG                     
        if(std::getenv("G4ParticleHPDebug"))
      {
        G4cout << " G4ParticleHPInelasticBaseFS "<<aHadron->GetTotalEnergy()<<" "<<aHadron->GetMomentum()<<G4endl;
      }
#endif
    }
    tmpHadrons->push_back(aHadron);
#ifdef G4PHPDEBUG
    if( std::getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply FSData add secondary " << aHadron->GetDefinition()->GetParticleName() << " E= " << aHadron->GetKineticEnergy() << G4endl;
#endif
      }
    }
    delete [] Done;
  }
  else
  {
    throw G4HadronicException(__FILE__, __LINE__, "No data to create the neutrons in NInelasticFS");
  }
 
  G4ReactionProductVector * thePhotons = 0;
  if(theFinalStatePhotons!=0) 
  {
    // the photon distributions are in the Nucleus rest frame.
    G4ReactionProduct boosted_tmp;
    boosted_tmp.Lorentz(incidReactionProduct, theTarget);
    G4double anEnergy = boosted_tmp.GetKineticEnergy();
    thePhotons = theFinalStatePhotons->GetPhotons(anEnergy);
    if(thePhotons!=0)
    {
      for(i=0; i<thePhotons->size(); i++)
      {
        // back to lab
        thePhotons->operator[](i)->Lorentz(*(thePhotons->operator[](i)), -1.*theTarget);
      }
    }
  }
  else if(theEnergyAngData!=0)
  {
 
   // PA130927: do not create photons to adjust binding energy
    G4bool bAdjustPhotons = true;
#ifdef PHP_AS_HP 
    bAdjustPhotons = true; 
#else
    if ( G4ParticleHPManager::GetInstance()->GetDoNotAdjustFinalState() ) bAdjustPhotons = false;    
#endif
 
    if( bAdjustPhotons ) {
      G4double theGammaEnergy = theEnergyAngData->GetTotalMeanEnergy();
      G4double anEnergy = boosted.GetKineticEnergy();
      theGammaEnergy = anEnergy-theGammaEnergy;
      theGammaEnergy += theNuclearMassDifference;
      G4double eBindProducts = 0;
      G4double eBindN = 0;
      G4double eBindP = 0;
      G4double eBindD = G4NucleiProperties::GetBindingEnergy(2,1);
      G4double eBindT = G4NucleiProperties::GetBindingEnergy(3,1);
      G4double eBindHe3 = G4NucleiProperties::GetBindingEnergy(3,2);
      G4double eBindA = G4NucleiProperties::GetBindingEnergy(4,2);
      G4int ia=0;
      for(i=0; i<tmpHadrons->size(); i++)
    {
      if(tmpHadrons->operator[](i)->GetDefinition() == G4Neutron::Neutron())
        {
          eBindProducts+=eBindN;
        }
      else if(tmpHadrons->operator[](i)->GetDefinition() == G4Proton::Proton())
        {
          eBindProducts+=eBindP;
        }
      else if(tmpHadrons->operator[](i)->GetDefinition() == G4Deuteron::Deuteron())
        {
          eBindProducts+=eBindD;
        }
      else if(tmpHadrons->operator[](i)->GetDefinition() == G4Triton::Triton())
        {
          eBindProducts+=eBindT;
        }
      else if(tmpHadrons->operator[](i)->GetDefinition() == G4He3::He3())
        {
          eBindProducts+=eBindHe3;
        }
      else if(tmpHadrons->operator[](i)->GetDefinition() == G4Alpha::Alpha())
        {
          eBindProducts+=eBindA;
          ia++; 
        }
    }
      
      theGammaEnergy += eBindProducts;
      
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply gamma Energy " << theGammaEnergy << " eBindProducts " << eBindProducts << G4endl;
#endif
      
      //101111 
      //Special treatment for Be9 + n -> 2n + Be8 -> 2n + a + a
      if ( (G4int)(theBaseZ+eps) == 4 && (G4int)(theBaseA+eps) == 9 )
    {
      // This only valid for G4NDL3.13,,,
      if ( std::abs( theNuclearMassDifference -   
             ( G4NucleiProperties::GetBindingEnergy( 8 , 4 ) -
               G4NucleiProperties::GetBindingEnergy( 9 , 4 ) ) ) < 1*CLHEP::keV 
           && ia == 2 )
        {
          theGammaEnergy -= (2*eBindA);
        }
    }
      
      G4ReactionProductVector * theOtherPhotons = 0;
      G4int iLevel;
      while(theGammaEnergy>=theGammas.GetLevelEnergy(0)) // Loop checking, 11.05.2015, T. Koi
    {
      for(iLevel=theGammas.GetNumberOfLevels()-1; iLevel>=0; iLevel--)
        {
          if(theGammas.GetLevelEnergy(iLevel)<theGammaEnergy) break;
        }
      if(iLevel==0||iLevel==theGammas.GetNumberOfLevels()-1)
        {
          theOtherPhotons = theGammas.GetDecayGammas(iLevel);
#ifdef G4PHPDEBUG
          if( std::getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply adding gamma from level " << iLevel << theOtherPhotons->operator[](ii)->GetKineticEnergy() << G4endl;
#endif
        }
      else
        {
          G4double random = G4UniformRand();
          G4double eLow  = theGammas.GetLevelEnergy(iLevel);
          G4double eHigh = theGammas.GetLevelEnergy(iLevel+1);
          if(random > (eHigh-eLow)/(theGammaEnergy-eLow)) iLevel++;
          theOtherPhotons = theGammas.GetDecayGammas(iLevel);
        }
      if(thePhotons==0) thePhotons = new G4ReactionProductVector;
      if(theOtherPhotons != 0)
        {
          for(unsigned int iii=0; iii<theOtherPhotons->size(); iii++)
        {
          thePhotons->push_back(theOtherPhotons->operator[](iii));
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))
            G4cout << iii << " G4ParticleHPInelasticBaseFS::BaseApply adding gamma " << theOtherPhotons->operator[](iii)->GetKineticEnergy() << G4endl;
#endif
        }
          delete theOtherPhotons; 
        }
      theGammaEnergy -= theGammas.GetLevelEnergy(iLevel);
      if(iLevel == -1) break;
    }
    }
  }
  
  // fill the result
  unsigned int nSecondaries = tmpHadrons->size();
  unsigned int nPhotons = 0;
  if(thePhotons!=0) { nPhotons = thePhotons->size(); }
  nSecondaries += nPhotons;
  G4DynamicParticle * theSec;
#ifdef G4PHPDEBUG
  if( std::getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply N hadrons " << nSecondaries-nPhotons << G4endl;
#endif
  
  for(i=0; i<nSecondaries-nPhotons; i++)
    {
      theSec = new G4DynamicParticle;    
      theSec->SetDefinition(tmpHadrons->operator[](i)->GetDefinition());
      theSec->SetMomentum(tmpHadrons->operator[](i)->GetMomentum());
      theResult.Get()->AddSecondary(theSec, secID); 
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))  G4cout << this << " G4ParticleHPInelasticBaseFS::BaseApply add secondary2 " << theSec->GetParticleDefinition()->GetParticleName() << " E= " << theSec->GetKineticEnergy() << " NSECO " << theResult.Get()->GetNumberOfSecondaries() << G4endl;
#endif
     if( std::getenv("G4PHPTEST") ) G4cout << " InelasticBaseFS COS THETA " << std::cos(theSec->GetMomentum().theta()) << " " << (theSec->GetMomentum().theta()) << " " << theSec->GetMomentum() << " E "<< theSec->GetKineticEnergy() << " " << theSec->GetDefinition()->GetParticleName() << G4endl; //GDEB
      delete tmpHadrons->operator[](i);
    }
#ifdef G4PHPDEBUG
  if( std::getenv("G4ParticleHPDebug"))  G4cout << " G4ParticleHPInelasticBaseFS::BaseApply N photons " << nPhotons << G4endl;
#endif
  if(thePhotons != 0)
  {
    for(i=0; i<nPhotons; i++)
    {
      theSec = new G4DynamicParticle;    
      theSec->SetDefinition(thePhotons->operator[](i)->GetDefinition());
      theSec->SetMomentum(thePhotons->operator[](i)->GetMomentum());
      theResult.Get()->AddSecondary(theSec, secID); 
#ifdef G4PHPDEBUG
      if( std::getenv("G4ParticleHPDebug"))  G4cout << this << " G4ParticleHPInelasticBaseFS::BaseApply add secondary3 " << theSec->GetParticleDefinition()->GetParticleName() << " E= " << theSec->GetKineticEnergy() << " NSECO " << theResult.Get()->GetNumberOfSecondaries() << G4endl;
#endif
      delete thePhotons->operator[](i);
    }
  }
  
// some garbage collection
  delete thePhotons;
  delete tmpHadrons;
 
//080721 
   G4ParticleDefinition* targ_pd = G4IonTable::GetIonTable()->GetIon ( (G4int)theBaseZ , (G4int)theBaseA , 0.0 );
   G4LorentzVector targ_4p_lab ( theTarget.GetMomentum() , std::sqrt( targ_pd->GetPDGMass()*targ_pd->GetPDGMass() + theTarget.GetMomentum().mag2() ) );
   G4LorentzVector proj_4p_lab = theTrack.Get4Momentum();
   G4LorentzVector init_4p_lab = proj_4p_lab + targ_4p_lab;
 
   //if data in MF=6 format (no correlated particle emission), then  adjust_final_state can give severe errors:
   if(theEnergyAngData==0){adjust_final_state ( init_4p_lab );} 
 
// clean up the primary neutron
  theResult.Get()->SetStatusChange(stopAndKill);
}

References G4HadFinalState::AddSecondary(), G4ParticleHPFinalState::adjust_final_state(), G4Alpha::Alpha(), G4HadFinalState::Clear(), G4Deuteron::Deuteron(), eps, G4cout, G4endl, G4UniformRand, G4Cache< VALTYPE >::Get(), G4HadProjectile::Get4Momentum(), G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetBaryonNumber(), G4Nucleus::GetBiasedThermalNucleus(), G4NucleiProperties::GetBindingEnergy(), G4ParticleHPDeExGammas::GetDecayGammas(), G4DynamicParticle::GetDefinition(), G4HadProjectile::GetDefinition(), G4ReactionProduct::GetDefinition(), G4ParticleHPManager::GetDoNotAdjustFinalState(), G4ParticleHPManager::GetInstance(), G4IonTable::GetIon(), G4IonTable::GetIonTable(), G4DynamicParticle::GetKineticEnergy(), G4HadProjectile::GetKineticEnergy(), G4ReactionProduct::GetKineticEnergy(), G4ParticleHPDeExGammas::GetLevelEnergy(), G4ReactionProduct::GetMass(), G4HadProjectile::GetMaterial(), G4DynamicParticle::GetMomentum(), G4ReactionProduct::GetMomentum(), G4NucleiProperties::GetNuclearMass(), G4ParticleHPDeExGammas::GetNumberOfLevels(), G4HadFinalState::GetNumberOfSecondaries(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4ParticleHPPhotonDist::GetPhotons(), G4ParticleHPAngular::GetTargetMass(), G4ParticleHPEnAngCorrelation::GetTargetMass(), G4Material::GetTemperature(), G4ReactionProduct::GetTotalEnergy(), G4ParticleHPEnAngCorrelation::GetTotalMeanEnergy(), G4ParticleHPFinalState::HasFSData(), G4He3::He3(), G4ParticleHPNBodyPhaseSpace::Init(), CLHEP::keV, G4ReactionProduct::Lorentz(), CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), maxA, CLHEP::MeV, G4Neutron::Neutron(), G4Proton::Proton(), G4Cache< VALTYPE >::Put(), G4ParticleHPInelasticBaseFS::Qvalue, G4ParticleHPEnAngCorrelation::Sample(), G4ParticleHPNBodyPhaseSpace::Sample(), G4ParticleHPEnergyDistribution::Sample(), G4ParticleHPAngular::SampleAndUpdate(), G4ParticleHPFinalState::secID, G4DynamicParticle::SetDefinition(), G4ReactionProduct::SetDefinition(), G4ReactionProduct::SetKineticEnergy(), G4ReactionProduct::SetMomentum(), G4DynamicParticle::SetMomentum(), G4ParticleHPAngular::SetProjectileRP(), G4ParticleHPEnAngCorrelation::SetProjectileRP(), G4VParticleHPEnergyAngular::SetProjectileRP(), G4VParticleHPEnergyAngular::SetQValue(), G4HadFinalState::SetStatusChange(), G4ParticleHPAngular::SetTarget(), G4ParticleHPEnAngCorrelation::SetTarget(), G4VParticleHPEnergyAngular::SetTarget(), G4ReactionProduct::SetTotalEnergy(), stopAndKill, G4ParticleHPInelasticBaseFS::theAngularDistribution, G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseZ, G4ParticleHPInelasticBaseFS::theEnergyAngData, G4ParticleHPInelasticBaseFS::theEnergyDistribution, G4ParticleHPInelasticBaseFS::theFinalStatePhotons, G4ParticleHPInelasticBaseFS::theGammas, G4ParticleHPInelasticBaseFS::theNuclearMassDifference, G4ParticleHPFinalState::theProjectile, G4ParticleHPFinalState::theResult, CLHEP::Hep3Vector::theta(), G4Triton::Triton(), CLHEP::Hep3Vector::unit(), and CLHEP::HepLorentzVector::vect().

Referenced by G4ParticleHP2AInelasticFS::ApplyYourself(), G4ParticleHP2N2AInelasticFS::ApplyYourself(), G4ParticleHP2NAInelasticFS::ApplyYourself(), G4ParticleHP2NDInelasticFS::ApplyYourself(), G4ParticleHP2NInelasticFS::ApplyYourself(), G4ParticleHP2NPInelasticFS::ApplyYourself(), G4ParticleHP2PInelasticFS::ApplyYourself(), G4ParticleHP3AInelasticFS::ApplyYourself(), G4ParticleHP3NAInelasticFS::ApplyYourself(), G4ParticleHP3NInelasticFS::ApplyYourself(), G4ParticleHP3NPInelasticFS::ApplyYourself(), G4ParticleHP4NInelasticFS::ApplyYourself(), G4ParticleHPD2AInelasticFS::ApplyYourself(), ApplyYourself(), G4ParticleHPN2AInelasticFS::ApplyYourself(), G4ParticleHPN2PInelasticFS::ApplyYourself(), G4ParticleHPN3AInelasticFS::ApplyYourself(), G4ParticleHPNAInelasticFS::ApplyYourself(), G4ParticleHPND2AInelasticFS::ApplyYourself(), G4ParticleHPNDInelasticFS::ApplyYourself(), G4ParticleHPNHe3InelasticFS::ApplyYourself(), G4ParticleHPNPAInelasticFS::ApplyYourself(), G4ParticleHPNPInelasticFS::ApplyYourself(), G4ParticleHPNT2AInelasticFS::ApplyYourself(), G4ParticleHPNTInelasticFS::ApplyYourself(), G4ParticleHPNXInelasticFS::ApplyYourself(), G4ParticleHPPAInelasticFS::ApplyYourself(), G4ParticleHPPDInelasticFS::ApplyYourself(), G4ParticleHPPTInelasticFS::ApplyYourself(), and G4ParticleHPT2AInelasticFS::ApplyYourself().

GetA()

G4double G4ParticleHPFinalState::GetA ( void  )

inlineinherited

Definition at line 104 of file G4ParticleHPFinalState.hh.

{ return theBaseA; }

References G4ParticleHPFinalState::theBaseA.

GetM()

G4int G4ParticleHPFinalState::GetM ( )

inlineinherited

Definition at line 105 of file G4ParticleHPFinalState.hh.

{ return theBaseM; }

References G4ParticleHPFinalState::theBaseM.

Referenced by G4ParticleHPChannel::GetM().

GetN()

G4double G4ParticleHPFinalState::GetN ( )

inlineinherited

Definition at line 103 of file G4ParticleHPFinalState.hh.

{ return theBaseA; }

References G4ParticleHPFinalState::theBaseA.

Referenced by G4ParticleHPChannel::ApplyYourself(), and G4ParticleHPChannel::GetN().

GetXsec() [1/2]

virtual G4ParticleHPVector * G4ParticleHPInelasticBaseFS::GetXsec ( )

inlinevirtualinherited

Reimplemented from G4ParticleHPFinalState.

Definition at line 87 of file G4ParticleHPInelasticBaseFS.hh.

{return theXsection;}

References G4ParticleHPInelasticBaseFS::theXsection.

GetXsec() [2/2]

virtual G4double G4ParticleHPInelasticBaseFS::GetXsec ( G4double  anEnergy )

inlinevirtualinherited

Reimplemented from G4ParticleHPFinalState.

Definition at line 82 of file G4ParticleHPInelasticBaseFS.hh.

    {
      return std::max(0., theXsection->GetY(anEnergy));
    }

References G4ParticleHPVector::GetY(), G4INCL::Math::max(), and G4ParticleHPInelasticBaseFS::theXsection.

GetZ()

G4double G4ParticleHPFinalState::GetZ ( void  )

inlineinherited

Definition at line 102 of file G4ParticleHPFinalState.hh.

{ return theBaseZ; }

References G4ParticleHPFinalState::theBaseZ.

Referenced by G4ParticleHPChannel::ApplyYourself(), and G4ParticleHPChannel::GetZ().

HasAnyData()

G4bool G4ParticleHPFinalState::HasAnyData ( )

inlineinherited

Definition at line 96 of file G4ParticleHPFinalState.hh.

{ return hasAnyData; }

References G4ParticleHPFinalState::hasAnyData.

Referenced by G4ParticleHPChannel::HasAnyData().

HasFSData()

G4bool G4ParticleHPFinalState::HasFSData ( )

inlineinherited

Definition at line 95 of file G4ParticleHPFinalState.hh.

{ return hasFSData; }

References G4ParticleHPFinalState::hasFSData.

Referenced by G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPFissionBaseFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPChannel::HasFSData(), and G4ParticleHPFissionFS::Init().

HasXsec()

G4bool G4ParticleHPFinalState::HasXsec ( )

inlineinherited

Definition at line 94 of file G4ParticleHPFinalState.hh.

{ return hasXsec; }

References G4ParticleHPFinalState::hasXsec.

Referenced by G4ParticleHPChannel::DumpInfo().

Init() [1/2]

void G4ParticleHPDAInelasticFS::Init ( G4double  A, G4double  Z, G4int  M, G4String &  dirName, G4String &  aFSType, G4ParticleDefinition *  projectile  )

virtual

Implements G4ParticleHPFinalState.

Definition at line 58 of file G4ParticleHPDAInelasticFS.cc.

{
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;
   G4double ResidualZ = 0;
   if( projectile == G4Neutron::Neutron() ) {
     ResidualA = A-5;
     ResidualZ = Z-3;
   } else if( projectile == G4Proton::Proton() ) {
     ResidualA = A-5;
     ResidualZ = Z-2;
   } else if( projectile == G4Deuteron::Deuteron() ) {
     ResidualA = A-4;
     ResidualZ = Z-2;
   } else if( projectile == G4Triton::Triton() ) {
     ResidualA = A-3;
     ResidualZ = Z-2;
   } else if( projectile == G4He3::He3() ) {
     ResidualA = A-3;
     ResidualZ = Z-1;
   } else if( projectile == G4Alpha::Alpha() ) {
     ResidualA = A-2;
     ResidualZ = Z-1;
   }
 
   G4ParticleHPInelasticBaseFS::InitGammas(ResidualA, ResidualZ);
}

References A, G4Alpha::Alpha(), G4Deuteron::Deuteron(), G4He3::He3(), G4ParticleHPInelasticBaseFS::Init(), G4ParticleHPInelasticBaseFS::InitGammas(), M, G4Neutron::Neutron(), G4Proton::Proton(), G4Triton::Triton(), and Z.

Init() [2/2]

void G4ParticleHPFinalState::Init ( G4double  A, G4double  Z, G4String &  dirName, G4String &  aFSType, G4ParticleDefinition *  projectile  )

inlineinherited

Definition at line 76 of file G4ParticleHPFinalState.hh.

  {
    G4int M = 0;
    Init ( A, Z, M, dirName, aFSType,const_cast<G4ParticleDefinition*>(projectile));
  }

References A, G4ParticleHPFinalState::Init(), M, and Z.

Referenced by G4ParticleHPFinalState::Init(), and G4ParticleHPChannel::UpdateData().

InitGammas()

void G4ParticleHPInelasticBaseFS::InitGammas ( G4double  AR, G4double  ZR  )

inherited

Definition at line 51 of file G4ParticleHPInelasticBaseFS.cc.

{
  //   char the[100] = {""};
  //   std::ostrstream ost(the, 100, std::ios::out);
  //   ost <<gammaPath<<"z"<<ZR<<".a"<<AR;
  //   G4String * aName = new G4String(the);
  //   std::ifstream from(*aName, std::ios::in);
 
   std::ostringstream ost;
   ost <<gammaPath<<"z"<<ZR<<".a"<<AR;
   G4String aName = ost.str();
   std::ifstream from(aName, std::ios::in);
 
   if(!from) return; // no data found for this isotope
   //   std::ifstream theGammaData(*aName, std::ios::in);
   std::ifstream theGammaData(aName, std::ios::in);
    
   G4double eps = 0.001;
   theNuclearMassDifference = 
       G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(AR+eps),static_cast<G4int>(ZR+eps)) -
       G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(theBaseA+eps), static_cast<G4int>(theBaseZ+eps));
   theGammas.Init(theGammaData);
   //   delete aName;
 
}

References eps, G4ParticleHPInelasticBaseFS::gammaPath, G4NucleiProperties::GetBindingEnergy(), G4ParticleHPDeExGammas::Init(), G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseZ, G4ParticleHPInelasticBaseFS::theGammas, and G4ParticleHPInelasticBaseFS::theNuclearMassDifference.

Referenced by G4ParticleHP2AInelasticFS::Init(), G4ParticleHP2N2AInelasticFS::Init(), G4ParticleHP2NAInelasticFS::Init(), G4ParticleHP2NDInelasticFS::Init(), G4ParticleHP2NInelasticFS::Init(), G4ParticleHP2NPInelasticFS::Init(), G4ParticleHP2PInelasticFS::Init(), G4ParticleHP3AInelasticFS::Init(), G4ParticleHP3NAInelasticFS::Init(), G4ParticleHP3NInelasticFS::Init(), G4ParticleHP3NPInelasticFS::Init(), G4ParticleHP4NInelasticFS::Init(), G4ParticleHPD2AInelasticFS::Init(), Init(), G4ParticleHPN2AInelasticFS::Init(), G4ParticleHPN2PInelasticFS::Init(), G4ParticleHPN3AInelasticFS::Init(), G4ParticleHPNAInelasticFS::Init(), G4ParticleHPND2AInelasticFS::Init(), G4ParticleHPNDInelasticFS::Init(), G4ParticleHPNHe3InelasticFS::Init(), G4ParticleHPNPAInelasticFS::Init(), G4ParticleHPNPInelasticFS::Init(), G4ParticleHPNT2AInelasticFS::Init(), G4ParticleHPNTInelasticFS::Init(), G4ParticleHPNXInelasticFS::Init(), G4ParticleHPPAInelasticFS::Init(), G4ParticleHPPDInelasticFS::Init(), G4ParticleHPPTInelasticFS::Init(), and G4ParticleHPT2AInelasticFS::Init().

New()

G4ParticleHPFinalState * G4ParticleHPDAInelasticFS::New ( )

inlinevirtual

Implements G4ParticleHPInelasticBaseFS.

Definition at line 49 of file G4ParticleHPDAInelasticFS.hh.

  {
   G4ParticleHPDAInelasticFS * theNew = new G4ParticleHPDAInelasticFS;
   return theNew;
  }

References G4ParticleHPDAInelasticFS().

SetA_Z()

void G4ParticleHPFinalState::SetA_Z ( G4double  anA, G4double  aZ, G4int  aM = 0  )

inlineinherited

Definition at line 101 of file G4ParticleHPFinalState.hh.

{theBaseA = anA; theBaseZ = aZ; theBaseM=aM; }

References G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseM, and G4ParticleHPFinalState::theBaseZ.

Referenced by G4ParticleHPChannel::Register().

SetAZMs()

void G4ParticleHPFinalState::SetAZMs ( G4double  anA, G4double  aZ, G4int  aM, G4ParticleHPDataUsed  used  )

inlineinherited

Definition at line 107 of file G4ParticleHPFinalState.hh.

  {
    theBaseA = anA; theBaseZ = aZ; theBaseM=aM; 
    theNDLDataA=(G4int)used.GetA();
    theNDLDataZ=(G4int)used.GetZ();
    theNDLDataM=used.GetM();
  }

References G4ParticleHPDataUsed::GetA(), G4ParticleHPDataUsed::GetM(), G4ParticleHPDataUsed::GetZ(), G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseM, G4ParticleHPFinalState::theBaseZ, G4ParticleHPFinalState::theNDLDataA, G4ParticleHPFinalState::theNDLDataM, and G4ParticleHPFinalState::theNDLDataZ.

Referenced by G4ParticleHPCaptureFS::Init(), G4ParticleHPElasticFS::Init(), G4ParticleHPFSFissionFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), and G4ParticleHPInelasticBaseFS::Init().

SetProjectile()

void G4ParticleHPFinalState::SetProjectile ( G4ParticleDefinition *  projectile )

inlineinherited

Definition at line 115 of file G4ParticleHPFinalState.hh.

  {
    theProjectile = projectile;
  }

References G4ParticleHPFinalState::theProjectile.

Referenced by G4ParticleHPChannel::Register().

Field Documentation

gammaPath

G4String G4ParticleHPInelasticBaseFS::gammaPath

protectedinherited

Definition at line 99 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::InitGammas().

hasAnyData

G4bool G4ParticleHPFinalState::hasAnyData

protectedinherited

Definition at line 126 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::HasAnyData(), G4FissionLibrary::Init(), G4ParticleHPCaptureFS::Init(), G4ParticleHPElasticFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPFSFissionFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), and G4ParticleHPInelasticBaseFS::Init().

hasFSData

G4bool G4ParticleHPFinalState::hasFSData

protectedinherited

Definition at line 125 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::HasFSData(), G4FissionLibrary::Init(), G4ParticleHPCaptureFS::Init(), G4ParticleHPElasticFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPFSFissionFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), and G4ParticleHPInelasticBaseFS::Init().

hasXsec

G4bool G4ParticleHPFinalState::hasXsec

protectedinherited

Definition at line 124 of file G4ParticleHPFinalState.hh.

Referenced by G4FissionLibrary::G4FissionLibrary(), G4ParticleHPCaptureFS::G4ParticleHPCaptureFS(), G4ParticleHPElasticFS::G4ParticleHPElasticFS(), G4ParticleHPFCFissionFS::G4ParticleHPFCFissionFS(), G4ParticleHPFFFissionFS::G4ParticleHPFFFissionFS(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFissionBaseFS::G4ParticleHPFissionBaseFS(), G4ParticleHPFissionFS::G4ParticleHPFissionFS(), G4ParticleHPFSFissionFS::G4ParticleHPFSFissionFS(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticCompFS::G4ParticleHPInelasticCompFS(), G4ParticleHPLCFissionFS::G4ParticleHPLCFissionFS(), G4ParticleHPSCFissionFS::G4ParticleHPSCFissionFS(), G4ParticleHPTCFissionFS::G4ParticleHPTCFissionFS(), G4ParticleHPFinalState::HasXsec(), G4FissionLibrary::Init(), G4ParticleHPCaptureFS::Init(), G4ParticleHPElasticFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPFSFissionFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), and G4ParticleHPInelasticBaseFS::Init().

Qvalue

G4double G4ParticleHPInelasticBaseFS::Qvalue

protectedinherited

Definition at line 101 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), and G4ParticleHPInelasticBaseFS::Init().

secID

G4int G4ParticleHPFinalState::secID

protectedinherited

Definition at line 140 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPElasticFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHP2AInelasticFS::G4ParticleHP2AInelasticFS(), G4ParticleHP2N2AInelasticFS::G4ParticleHP2N2AInelasticFS(), G4ParticleHP2NAInelasticFS::G4ParticleHP2NAInelasticFS(), G4ParticleHP2NDInelasticFS::G4ParticleHP2NDInelasticFS(), G4ParticleHP2NInelasticFS::G4ParticleHP2NInelasticFS(), G4ParticleHP2NPInelasticFS::G4ParticleHP2NPInelasticFS(), G4ParticleHP2PInelasticFS::G4ParticleHP2PInelasticFS(), G4ParticleHP3AInelasticFS::G4ParticleHP3AInelasticFS(), G4ParticleHP3NAInelasticFS::G4ParticleHP3NAInelasticFS(), G4ParticleHP3NInelasticFS::G4ParticleHP3NInelasticFS(), G4ParticleHP3NPInelasticFS::G4ParticleHP3NPInelasticFS(), G4ParticleHP4NInelasticFS::G4ParticleHP4NInelasticFS(), G4ParticleHPAInelasticFS::G4ParticleHPAInelasticFS(), G4ParticleHPCaptureFS::G4ParticleHPCaptureFS(), G4ParticleHPD2AInelasticFS::G4ParticleHPD2AInelasticFS(), G4ParticleHPDAInelasticFS(), G4ParticleHPDInelasticFS::G4ParticleHPDInelasticFS(), G4ParticleHPElasticFS::G4ParticleHPElasticFS(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFissionFS::G4ParticleHPFissionFS(), G4ParticleHPHe3InelasticFS::G4ParticleHPHe3InelasticFS(), G4ParticleHPN2AInelasticFS::G4ParticleHPN2AInelasticFS(), G4ParticleHPN2PInelasticFS::G4ParticleHPN2PInelasticFS(), G4ParticleHPN3AInelasticFS::G4ParticleHPN3AInelasticFS(), G4ParticleHPNAInelasticFS::G4ParticleHPNAInelasticFS(), G4ParticleHPND2AInelasticFS::G4ParticleHPND2AInelasticFS(), G4ParticleHPNDInelasticFS::G4ParticleHPNDInelasticFS(), G4ParticleHPNHe3InelasticFS::G4ParticleHPNHe3InelasticFS(), G4ParticleHPNInelasticFS::G4ParticleHPNInelasticFS(), G4ParticleHPNPAInelasticFS::G4ParticleHPNPAInelasticFS(), G4ParticleHPNPInelasticFS::G4ParticleHPNPInelasticFS(), G4ParticleHPNT2AInelasticFS::G4ParticleHPNT2AInelasticFS(), G4ParticleHPNTInelasticFS::G4ParticleHPNTInelasticFS(), G4ParticleHPNXInelasticFS::G4ParticleHPNXInelasticFS(), G4ParticleHPPAInelasticFS::G4ParticleHPPAInelasticFS(), G4ParticleHPPDInelasticFS::G4ParticleHPPDInelasticFS(), G4ParticleHPPInelasticFS::G4ParticleHPPInelasticFS(), G4ParticleHPPTInelasticFS::G4ParticleHPPTInelasticFS(), G4ParticleHPT2AInelasticFS::G4ParticleHPT2AInelasticFS(), G4ParticleHPTInelasticFS::G4ParticleHPTInelasticFS(), and G4ParticleHPInelasticCompFS::use_nresp71_model().

theAngularDistribution

G4ParticleHPAngular* G4ParticleHPInelasticBaseFS::theAngularDistribution

protectedinherited

Definition at line 93 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS().

theBaseA

G4double G4ParticleHPFinalState::theBaseA

protectedinherited

Definition at line 132 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPElasticFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::GetA(), G4ParticleHPFinalState::GetN(), G4ParticleHPCaptureFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPInelasticBaseFS::InitGammas(), G4ParticleHPFinalState::SetA_Z(), and G4ParticleHPFinalState::SetAZMs().

theBaseM

G4int G4ParticleHPFinalState::theBaseM

protectedinherited

Definition at line 134 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::GetM(), G4ParticleHPFinalState::SetA_Z(), and G4ParticleHPFinalState::SetAZMs().

theBaseZ

G4double G4ParticleHPFinalState::theBaseZ

protectedinherited

Definition at line 133 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPElasticFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::GetZ(), G4ParticleHPCaptureFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPInelasticBaseFS::InitGammas(), G4ParticleHPFinalState::SetA_Z(), and G4ParticleHPFinalState::SetAZMs().

theEnergyAngData

G4ParticleHPEnAngCorrelation* G4ParticleHPInelasticBaseFS::theEnergyAngData

protectedinherited

Definition at line 94 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS().

theEnergyDistribution

G4ParticleHPEnergyDistribution* G4ParticleHPInelasticBaseFS::theEnergyDistribution

protectedinherited

Definition at line 92 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS().

theFinalStatePhotons

G4ParticleHPPhotonDist* G4ParticleHPInelasticBaseFS::theFinalStatePhotons

protectedinherited

Definition at line 96 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS().

theGammas

G4ParticleHPDeExGammas G4ParticleHPInelasticBaseFS::theGammas

protectedinherited

Definition at line 98 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), and G4ParticleHPInelasticBaseFS::InitGammas().

theNames

G4ParticleHPNames G4ParticleHPFinalState::theNames

protectedinherited

Definition at line 127 of file G4ParticleHPFinalState.hh.

Referenced by G4FissionLibrary::Init(), G4ParticleHPElasticFS::Init(), G4ParticleHPFFFissionFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), and G4ParticleHPInelasticBaseFS::Init().

theNDLDataA

G4int G4ParticleHPFinalState::theNDLDataA

protectedinherited

Definition at line 137 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPElasticFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPFinalState::SetAZMs().

theNDLDataM

G4int G4ParticleHPFinalState::theNDLDataM

protectedinherited

Definition at line 138 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPElasticFS::Init(), and G4ParticleHPFinalState::SetAZMs().

theNDLDataZ

G4int G4ParticleHPFinalState::theNDLDataZ

protectedinherited

Definition at line 136 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPElasticFS::Init(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPFissionBaseFS::Init(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPFinalState::SetAZMs().

theNuclearMassDifference

G4double G4ParticleHPInelasticBaseFS::theNuclearMassDifference

protectedinherited

Definition at line 97 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), and G4ParticleHPInelasticBaseFS::InitGammas().

theProjectile

G4ParticleDefinition* G4ParticleHPFinalState::theProjectile

protectedinherited

Definition at line 130 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPInelasticCompFS::Init(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPFinalState::SetProjectile().

theResult

G4Cache< G4HadFinalState* > G4ParticleHPFinalState::theResult

protectedinherited

Definition at line 129 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4FissionLibrary::ApplyYourself(), G4ParticleHP2AInelasticFS::ApplyYourself(), G4ParticleHP2N2AInelasticFS::ApplyYourself(), G4ParticleHP2NAInelasticFS::ApplyYourself(), G4ParticleHP2NDInelasticFS::ApplyYourself(), G4ParticleHP2NInelasticFS::ApplyYourself(), G4ParticleHP2NPInelasticFS::ApplyYourself(), G4ParticleHP2PInelasticFS::ApplyYourself(), G4ParticleHP3AInelasticFS::ApplyYourself(), G4ParticleHP3NAInelasticFS::ApplyYourself(), G4ParticleHP3NInelasticFS::ApplyYourself(), G4ParticleHP3NPInelasticFS::ApplyYourself(), G4ParticleHP4NInelasticFS::ApplyYourself(), G4ParticleHPAInelasticFS::ApplyYourself(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPD2AInelasticFS::ApplyYourself(), ApplyYourself(), G4ParticleHPDInelasticFS::ApplyYourself(), G4ParticleHPElasticFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPHe3InelasticFS::ApplyYourself(), G4ParticleHPN2AInelasticFS::ApplyYourself(), G4ParticleHPN2PInelasticFS::ApplyYourself(), G4ParticleHPN3AInelasticFS::ApplyYourself(), G4ParticleHPNAInelasticFS::ApplyYourself(), G4ParticleHPND2AInelasticFS::ApplyYourself(), G4ParticleHPNDInelasticFS::ApplyYourself(), G4ParticleHPNHe3InelasticFS::ApplyYourself(), G4ParticleHPNInelasticFS::ApplyYourself(), G4ParticleHPNPAInelasticFS::ApplyYourself(), G4ParticleHPNPInelasticFS::ApplyYourself(), G4ParticleHPNT2AInelasticFS::ApplyYourself(), G4ParticleHPNTInelasticFS::ApplyYourself(), G4ParticleHPNXInelasticFS::ApplyYourself(), G4ParticleHPPAInelasticFS::ApplyYourself(), G4ParticleHPPDInelasticFS::ApplyYourself(), G4ParticleHPPInelasticFS::ApplyYourself(), G4ParticleHPPTInelasticFS::ApplyYourself(), G4ParticleHPT2AInelasticFS::ApplyYourself(), G4ParticleHPTInelasticFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPInelasticCompFS::use_nresp71_model(), and G4ParticleHPFinalState::~G4ParticleHPFinalState().

theXsection

G4ParticleHPVector* G4ParticleHPInelasticBaseFS::theXsection

protectedinherited

Definition at line 91 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS(), G4ParticleHPInelasticBaseFS::GetXsec(), G4ParticleHPInelasticBaseFS::Init(), and G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS().

---

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

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