G4ParticleHPInelasticBaseFS Class Reference

#include <G4ParticleHPInelasticBaseFS.hh>

Inheritance diagram for G4ParticleHPInelasticBaseFS:

Public Member Functions
virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &theTrack)=0
void	BaseApply (const G4HadProjectile &theTrack, G4ParticleDefinition **theDefs, G4int nDef)
	G4ParticleHPInelasticBaseFS ()
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 &bit, G4ParticleDefinition *)
void	Init (G4double A, G4double Z, G4String &dirName, G4String &aFSType, G4ParticleDefinition *projectile)
void	InitGammas (G4double AR, G4double ZR)
virtual G4ParticleHPFinalState *	New ()=0
void	SetA_Z (G4double anA, G4double aZ, G4int aM=0)
void	SetAZMs (G4double anA, G4double aZ, G4int aM, G4ParticleHPDataUsed used)
void	SetProjectile (G4ParticleDefinition *projectile)
virtual	~G4ParticleHPInelasticBaseFS ()

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 43 of file G4ParticleHPInelasticBaseFS.hh.

Constructor & Destructor Documentation

G4ParticleHPInelasticBaseFS()

G4ParticleHPInelasticBaseFS::G4ParticleHPInelasticBaseFS ( )

inline

Definition at line 47 of file G4ParticleHPInelasticBaseFS.hh.

    {
      hasXsec = true; 
      theXsection = new G4ParticleHPVector;
    
      theEnergyDistribution = 0;
      theFinalStatePhotons = 0;
      theEnergyAngData = 0;
      theAngularDistribution = 0;
 
      theNuclearMassDifference = 0.0;
      Qvalue = 0.0;
    }

References G4ParticleHPFinalState::hasXsec, Qvalue, theAngularDistribution, theEnergyAngData, theEnergyDistribution, theFinalStatePhotons, theNuclearMassDifference, and theXsection.

~G4ParticleHPInelasticBaseFS()

virtual G4ParticleHPInelasticBaseFS::~G4ParticleHPInelasticBaseFS ( )

inlinevirtual

Definition at line 61 of file G4ParticleHPInelasticBaseFS.hh.

    {
      delete theXsection;
      if (theEnergyDistribution != 0) delete theEnergyDistribution;
      if (theFinalStatePhotons != 0) delete theFinalStatePhotons;
      if (theEnergyAngData != 0) delete theEnergyAngData;
      if (theAngularDistribution != 0) delete theAngularDistribution;
    }

References theAngularDistribution, theEnergyAngData, theEnergyDistribution, theFinalStatePhotons, and theXsection.

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 BaseApply(), and G4ParticleHPInelasticCompFS::CompositeApply().

ApplyYourself()

virtual G4HadFinalState * G4ParticleHPInelasticBaseFS::ApplyYourself ( const G4HadProjectile &  theTrack )

pure virtual

Reimplemented from G4ParticleHPFinalState.

Implemented in G4ParticleHP2AInelasticFS, G4ParticleHP2N2AInelasticFS, G4ParticleHP2NAInelasticFS, G4ParticleHP2NDInelasticFS, G4ParticleHP2NInelasticFS, G4ParticleHP2NPInelasticFS, G4ParticleHP2PInelasticFS, G4ParticleHP3AInelasticFS, G4ParticleHP3NAInelasticFS, G4ParticleHP3NInelasticFS, G4ParticleHP3NPInelasticFS, G4ParticleHP4NInelasticFS, G4ParticleHPD2AInelasticFS, G4ParticleHPDAInelasticFS, G4ParticleHPN2AInelasticFS, G4ParticleHPN2PInelasticFS, G4ParticleHPN3AInelasticFS, G4ParticleHPNAInelasticFS, G4ParticleHPND2AInelasticFS, G4ParticleHPNDInelasticFS, G4ParticleHPNHe3InelasticFS, G4ParticleHPNPAInelasticFS, G4ParticleHPNPInelasticFS, G4ParticleHPNT2AInelasticFS, G4ParticleHPNTInelasticFS, G4ParticleHPNXInelasticFS, G4ParticleHPPAInelasticFS, G4ParticleHPPDInelasticFS, G4ParticleHPPTInelasticFS, and G4ParticleHPT2AInelasticFS.

BaseApply()

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

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(), 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, theAngularDistribution, G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseZ, theEnergyAngData, theEnergyDistribution, theFinalStatePhotons, theGammas, 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(), G4ParticleHPDAInelasticFS::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 ( )

inlinevirtual

Reimplemented from G4ParticleHPFinalState.

Definition at line 87 of file G4ParticleHPInelasticBaseFS.hh.

{return theXsection;}

References theXsection.

GetXsec() [2/2]

virtual G4double G4ParticleHPInelasticBaseFS::GetXsec ( G4double  anEnergy )

inlinevirtual

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 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(), 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 G4ParticleHPInelasticBaseFS::Init ( G4double  A, G4double  Z, G4int  M, G4String &  dirName, G4String &  bit, G4ParticleDefinition *    )

virtual

Implements G4ParticleHPFinalState.

Reimplemented in G4ParticleHPN2AInelasticFS, G4ParticleHPN2PInelasticFS, G4ParticleHPN3AInelasticFS, G4ParticleHPNAInelasticFS, G4ParticleHPND2AInelasticFS, G4ParticleHPNDInelasticFS, G4ParticleHPNHe3InelasticFS, G4ParticleHPNPAInelasticFS, G4ParticleHPNPInelasticFS, G4ParticleHPNT2AInelasticFS, G4ParticleHPNTInelasticFS, G4ParticleHPNXInelasticFS, G4ParticleHPPAInelasticFS, G4ParticleHPPDInelasticFS, G4ParticleHPPTInelasticFS, and G4ParticleHPT2AInelasticFS.

Definition at line 77 of file G4ParticleHPInelasticBaseFS.cc.

{
  gammaPath = "/Inelastic/Gammas/";
    if(!std::getenv("G4NEUTRONHPDATA")) 
       throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files where Inelastic/Gammas data is found.");
  G4String tBase = std::getenv("G4NEUTRONHPDATA");
  gammaPath = tBase+gammaPath;
  G4String tString = dirName;
  G4bool dbool;
  G4ParticleHPDataUsed aFile = theNames.GetName(static_cast<G4int>(A), static_cast<G4int>(Z), M,tString, bit, dbool);
  G4String filename = aFile.GetName();
#ifdef G4PHPDEBUG
  if( std::getenv("G4ParticleHPDebug") ) G4cout << " G4ParticleHPInelasticBaseFS::Init FILE " << filename << G4endl;
#endif
   SetAZMs( A, Z, M, aFile); 
  //theBaseA = aFile.GetA();
  //theBaseZ = aFile.GetZ();
  // theNDLDataA = (int)aFile.GetA();
  // theNDLDataZ = aFile.GetZ();
  //if(!dbool || ( Z<2.5 && ( std::abs(theBaseZ - Z)>0.0001 || std::abs(theBaseA - A)>0.0001)))
  if ( !dbool || ( Z<2.5 && ( std::abs(theNDLDataZ - Z)>0.0001 || std::abs(theNDLDataA - A)>0.0001)) )
  {
#ifdef G4PHPDEBUG
    if(std::getenv("G4ParticleHPDebug_NamesLogging")) G4cout << "Skipped = "<< filename <<" "<<A<<" "<<Z<<G4endl;
#endif
    hasAnyData = false;
    hasFSData = false; 
    hasXsec = false;
    return;
  }
  //  theBaseA = A;
  //  theBaseZ = G4int(Z+.5);
  //std::ifstream theData(filename, std::ios::in);
   //130205 For compressed data files 
   std::istringstream theData(std::ios::in);
   G4ParticleHPManager::GetInstance()->GetDataStream(filename,theData);
   //130205 END
  if(!theData) //"!" is a operator of ios
  {
    hasAnyData = false;
    hasFSData = false; 
    hasXsec = false;
    //   theData.close();
    return; // no data for exactly this isotope and FS
  }
  // here we go
  G4int infoType, dataType, dummy=INT_MAX;
  hasFSData = false; 
  while (theData >> infoType) // Loop checking, 11.05.2015, T. Koi
  {
    theData >> dataType;
 
    if(dummy==INT_MAX) theData >> Qvalue >> dummy;
    Qvalue*=CLHEP::eV; //In G4NDL4.5 this value is the MT number (<1000), in others is que Q-value in eV
 
    if(dataType==3) 
    {
      G4int total;
      theData >> total;
      theXsection->Init(theData, total, CLHEP::eV);
    }
    else if(dataType==4)
    {
      theAngularDistribution = new G4ParticleHPAngular;
      theAngularDistribution->Init(theData);
      hasFSData = true; 
    }
    else if(dataType==5)
    {
      theEnergyDistribution = new G4ParticleHPEnergyDistribution;
      theEnergyDistribution->Init(theData);
      hasFSData = true; 
    }
    else if(dataType==6)
    {
      theEnergyAngData = new G4ParticleHPEnAngCorrelation(theProjectile);
      //-      G4cout << this << " BaseFS theEnergyAngData " << theEnergyAngData << G4endl; //GDEB
      theEnergyAngData->Init(theData);
      hasFSData = true; 
    }
    else if(dataType==12)
    {
      theFinalStatePhotons = new G4ParticleHPPhotonDist;
      theFinalStatePhotons->InitMean(theData);
      hasFSData = true; 
    }
    else if(dataType==13)
    {
      theFinalStatePhotons = new G4ParticleHPPhotonDist;
      theFinalStatePhotons->InitPartials(theData, theXsection);
      hasFSData = true; 
    }
    else if(dataType==14)
    {
      theFinalStatePhotons->InitAngular(theData);
      hasFSData = true; 
    }
    else if(dataType==15)
    {
      theFinalStatePhotons->InitEnergies(theData);
      hasFSData = true; 
    }
    else
    {
      throw G4HadronicException(__FILE__, __LINE__, "Data-type unknown to G4ParticleHPInelasticBaseFS");
    }
  }
  //  theData.close();
}

References A, CLHEP::eV, G4cout, G4endl, gammaPath, G4ParticleHPManager::GetDataStream(), G4ParticleHPManager::GetInstance(), G4ParticleHPDataUsed::GetName(), G4ParticleHPNames::GetName(), G4ParticleHPFinalState::hasAnyData, G4ParticleHPFinalState::hasFSData, G4ParticleHPFinalState::hasXsec, G4ParticleHPAngular::Init(), G4ParticleHPEnAngCorrelation::Init(), G4ParticleHPVector::Init(), G4ParticleHPEnergyDistribution::Init(), G4ParticleHPPhotonDist::InitAngular(), G4ParticleHPPhotonDist::InitEnergies(), G4ParticleHPPhotonDist::InitMean(), G4ParticleHPPhotonDist::InitPartials(), INT_MAX, M, Qvalue, G4ParticleHPFinalState::SetAZMs(), theAngularDistribution, theEnergyAngData, theEnergyDistribution, theFinalStatePhotons, G4ParticleHPFinalState::theNames, G4ParticleHPFinalState::theNDLDataA, G4ParticleHPFinalState::theNDLDataZ, G4ParticleHPFinalState::theProjectile, theXsection, G4INCL::CrossSections::total(), and Z.

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(), G4ParticleHPDAInelasticFS::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().

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
	)

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, gammaPath, G4NucleiProperties::GetBindingEnergy(), G4ParticleHPDeExGammas::Init(), G4ParticleHPFinalState::theBaseA, G4ParticleHPFinalState::theBaseZ, theGammas, and 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(), G4ParticleHPDAInelasticFS::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()

virtual G4ParticleHPFinalState * G4ParticleHPInelasticBaseFS::New ( )

pure virtual

Implements G4ParticleHPFinalState.

Implemented in G4ParticleHP2AInelasticFS, G4ParticleHP2N2AInelasticFS, G4ParticleHP2NAInelasticFS, G4ParticleHP2NDInelasticFS, G4ParticleHP2NInelasticFS, G4ParticleHP2NPInelasticFS, G4ParticleHP2PInelasticFS, G4ParticleHP3AInelasticFS, G4ParticleHP3NAInelasticFS, G4ParticleHP3NInelasticFS, G4ParticleHP3NPInelasticFS, G4ParticleHP4NInelasticFS, G4ParticleHPD2AInelasticFS, G4ParticleHPDAInelasticFS, G4ParticleHPN2AInelasticFS, G4ParticleHPN2PInelasticFS, G4ParticleHPN3AInelasticFS, G4ParticleHPNAInelasticFS, G4ParticleHPND2AInelasticFS, G4ParticleHPNDInelasticFS, G4ParticleHPNHe3InelasticFS, G4ParticleHPNPAInelasticFS, G4ParticleHPNPInelasticFS, G4ParticleHPNT2AInelasticFS, G4ParticleHPNTInelasticFS, G4ParticleHPNXInelasticFS, G4ParticleHPPAInelasticFS, G4ParticleHPPDInelasticFS, G4ParticleHPPTInelasticFS, and G4ParticleHPT2AInelasticFS.

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 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

protected

Definition at line 99 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by Init(), and 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 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 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(), 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 Init().

Qvalue

G4double G4ParticleHPInelasticBaseFS::Qvalue

protected

Definition at line 101 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by BaseApply(), G4ParticleHPInelasticBaseFS(), and 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(), 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::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

protected

Definition at line 93 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by BaseApply(), G4ParticleHPInelasticBaseFS(), Init(), and ~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(), BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::GetA(), G4ParticleHPFinalState::GetN(), G4ParticleHPCaptureFS::Init(), G4ParticleHPFFFissionFS::Init(), 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(), BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPFinalState::GetZ(), G4ParticleHPCaptureFS::Init(), G4ParticleHPFFFissionFS::Init(), InitGammas(), G4ParticleHPFinalState::SetA_Z(), and G4ParticleHPFinalState::SetAZMs().

theEnergyAngData

G4ParticleHPEnAngCorrelation* G4ParticleHPInelasticBaseFS::theEnergyAngData

protected

Definition at line 94 of file G4ParticleHPInelasticBaseFS.hh.

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

theEnergyDistribution

G4ParticleHPEnergyDistribution* G4ParticleHPInelasticBaseFS::theEnergyDistribution

protected

Definition at line 92 of file G4ParticleHPInelasticBaseFS.hh.

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

theFinalStatePhotons

G4ParticleHPPhotonDist* G4ParticleHPInelasticBaseFS::theFinalStatePhotons

protected

Definition at line 96 of file G4ParticleHPInelasticBaseFS.hh.

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

theGammas

G4ParticleHPDeExGammas G4ParticleHPInelasticBaseFS::theGammas

protected

Definition at line 98 of file G4ParticleHPInelasticBaseFS.hh.

Referenced by BaseApply(), and 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 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(), 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(), Init(), and G4ParticleHPFinalState::SetAZMs().

theNuclearMassDifference

G4double G4ParticleHPInelasticBaseFS::theNuclearMassDifference

protected

Definition at line 97 of file G4ParticleHPInelasticBaseFS.hh.

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

theProjectile

G4ParticleDefinition* G4ParticleHPFinalState::theProjectile

protectedinherited

Definition at line 130 of file G4ParticleHPFinalState.hh.

Referenced by G4ParticleHPFinalState::adjust_final_state(), BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPInelasticCompFS::Init(), 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(), G4ParticleHPDAInelasticFS::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(), BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4ParticleHPFinalState::G4ParticleHPFinalState(), G4ParticleHPInelasticCompFS::use_nresp71_model(), and G4ParticleHPFinalState::~G4ParticleHPFinalState().

theXsection

G4ParticleHPVector* G4ParticleHPInelasticBaseFS::theXsection

protected

Definition at line 91 of file G4ParticleHPInelasticBaseFS.hh.

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

---

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

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