G4NeutronHPFinalState Class Reference

#include <G4NeutronHPFinalState.hh>

Inheritance diagram for G4NeutronHPFinalState:

G4FissionLibrary G4NeutronHPCaptureFS G4NeutronHPElasticFS G4NeutronHPFissionBaseFS G4NeutronHPFissionFS G4NeutronHPFSFissionFS G4NeutronHPInelasticBaseFS G4NeutronHPInelasticCompFS

Public Member Functions

 G4NeutronHPFinalState ()
virtual ~G4NeutronHPFinalState ()
void Init (G4double A, G4double Z, G4String &dirName, G4String &aFSType)
virtual void Init (G4double A, G4double Z, G4int M, G4String &dirName, G4String &aFSType)=0
virtual G4HadFinalStateApplyYourself (const G4HadProjectile &)
virtual G4NeutronHPFinalStateNew ()=0
G4bool HasXsec ()
G4bool HasFSData ()
G4bool HasAnyData ()
virtual G4double GetXsec (G4double)
virtual G4NeutronHPVectorGetXsec ()
void SetA_Z (G4double anA, G4double aZ, G4int aM=0)
G4double GetZ ()
G4double GetN ()
G4int GetM ()

Protected Member Functions

void SetAZMs (G4double anA, G4double aZ, G4int aM, G4NeutronHPDataUsed used)
void adjust_final_state (G4LorentzVector)

Protected Attributes

G4bool hasXsec
G4bool hasFSData
G4bool hasAnyData
G4NeutronHPNames theNames
G4HadFinalState theResult
G4double theBaseA
G4double theBaseZ
G4int theBaseM
G4int theNDLDataZ
G4int theNDLDataA
G4int theNDLDataM

Detailed Description

Definition at line 42 of file G4NeutronHPFinalState.hh.


Constructor & Destructor Documentation

G4NeutronHPFinalState::G4NeutronHPFinalState (  )  [inline]

Definition at line 46 of file G4NeutronHPFinalState.hh.

References hasAnyData, hasFSData, hasXsec, theBaseA, theBaseM, theBaseZ, theNDLDataA, and theNDLDataZ.

00047   { 
00048     hasFSData = true; 
00049     hasXsec = true;
00050     hasAnyData = true;
00051     theBaseZ = 0;
00052     theBaseA = 0;
00053     theBaseM = 0;
00054 
00055     theNDLDataZ = 0;
00056     theNDLDataA = 0;
00057 
00058      adjustResult = true;
00059      if ( getenv( "G4NEUTRONHP_DO_NOT_ADJUST_FINAL_STATE" ) ) adjustResult = false;
00060 
00061   };

virtual G4NeutronHPFinalState::~G4NeutronHPFinalState (  )  [inline, virtual]

Definition at line 63 of file G4NeutronHPFinalState.hh.

00063 {};


Member Function Documentation

void G4NeutronHPFinalState::adjust_final_state ( G4LorentzVector   )  [protected]

Definition at line 38 of file G4NeutronHPFinalState.cc.

References G4HadFinalState::AddSecondary(), G4cout, G4endl, G4UniformRand, G4Gamma::Gamma(), G4DynamicParticle::Get4Momentum(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4DynamicParticle::GetDefinition(), G4ParticleTable::GetIon(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentum(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGMass(), G4HadFinalState::GetSecondary(), G4Neutron::Neutron(), G4DynamicParticle::SetDefinition(), G4DynamicParticle::SetKineticEnergy(), G4DynamicParticle::SetMomentum(), theBaseA, theBaseZ, theNDLDataA, theNDLDataZ, and theResult.

Referenced by G4NeutronHPInelasticBaseFS::BaseApply(), and G4NeutronHPInelasticCompFS::CompositeApply().

00039 {
00040 
00041    G4double minimum_energy = 1*keV;
00042 
00043    if ( adjustResult != true ) return;
00044 
00045    G4int nSecondaries = theResult.GetNumberOfSecondaries();
00046 
00047    G4int sum_Z = 0;
00048    G4int sum_A = 0;
00049    G4int max_SecZ = 0;
00050    G4int max_SecA = 0;
00051    G4int imaxA = -1;
00052    for ( int i = 0 ; i < nSecondaries ; i++ )
00053    {
00054       sum_Z += theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber();
00055       max_SecZ = std::max ( max_SecZ , theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber() );
00056       sum_A += theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass();
00057       max_SecA = std::max ( max_SecA , theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() );
00058       if ( theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() == max_SecA ) imaxA = i;
00059    }
00060 
00061    G4ParticleDefinition* resi_pd = NULL;
00062    G4bool needOneMoreSec = false;
00063    G4ParticleDefinition* oneMoreSec_pd = NULL;
00064    if ( (int)(theBaseZ - sum_Z) == 0 && (int)(theBaseA + 1 - sum_A) == 0 )
00065    {
00066       //All secondaries are already created;
00067       resi_pd = theResult.GetSecondary( imaxA )->GetParticle()->GetDefinition(); 
00068    }
00069    else
00070    {
00071       if ( max_SecA > int(theBaseA + 1 - sum_A) ) 
00072       {
00073          //Most heavy secondary is interpreted as residual
00074          resi_pd = theResult.GetSecondary( imaxA )->GetParticle()->GetDefinition(); 
00075          needOneMoreSec = true;
00076       }
00077       else 
00078       {
00079          //creation of residual is requierd 
00080          resi_pd = G4ParticleTable::GetParticleTable()->GetIon ( int(theBaseZ - sum_Z) , (int)(theBaseA + 1 - sum_A) , 0.0 );
00081       }
00082 
00083       if ( needOneMoreSec )
00084       {
00085          if ( int(theBaseZ - sum_Z) == 0 && (int)(theBaseA + 1 - sum_A) > 0 )
00086          {
00087             if ( int(theBaseA + 1 - sum_A) > 1 ) G4cout << "More than one neutron is required for the balance of baryon number!" << G4endl;
00088             oneMoreSec_pd = G4Neutron::Neutron();
00089          }
00090          else 
00091          {
00092             oneMoreSec_pd = G4ParticleTable::GetParticleTable()->GetIon ( int(theBaseZ - sum_Z) , (int)(theBaseA + 1 - sum_A) , 0.0 );
00093          }
00094       }
00095   
00096       if ( resi_pd == NULL )
00097       {
00098          // theNDLDataZ,A has the Z and A of used NDL file
00099          if ( (int)(theNDLDataZ - sum_Z) == 0 && (int)(theNDLDataA + 1 - sum_A) == 0 )
00100          {
00101             G4int dif_Z = ( int ) ( theNDLDataZ - theBaseZ );
00102             G4int dif_A = ( int ) ( theNDLDataA - theBaseA );
00103             resi_pd = G4ParticleTable::GetParticleTable()->GetIon ( max_SecZ - dif_Z , max_SecA - dif_A , 0.0 );
00104             for ( int i = 0 ; i < nSecondaries ; i++ )
00105             {
00106                if ( theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicNumber() == max_SecZ  
00107                  && theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetAtomicMass() == max_SecA )
00108                {
00109                   G4ThreeVector p = theResult.GetSecondary( i )->GetParticle()->GetMomentum();
00110                   p = p * resi_pd->GetPDGMass()/ G4ParticleTable::GetParticleTable()->GetIon ( max_SecZ , max_SecA , 0.0 )->GetPDGMass(); 
00111                   theResult.GetSecondary( i )->GetParticle()->SetDefinition( resi_pd );
00112                   theResult.GetSecondary( i )->GetParticle()->SetMomentum( p );
00113                } 
00114             }
00115          }
00116       }
00117    }
00118 
00119 
00120    G4LorentzVector secs_4p_lab( 0.0 );
00121 
00122    G4int n_sec = theResult.GetNumberOfSecondaries();
00123    G4double fast = 0;
00124    G4double slow = 1;
00125    G4int ifast = 0;
00126    G4int islow = 0;
00127    G4int ires = -1;
00128 
00129    for ( G4int i = 0 ; i < n_sec ; i++ )
00130    {
00131 
00132       //G4cout << "HP_DB " << i 
00133       //       << " " << theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetParticleName() 
00134       //       << " 4p " << theResult.GetSecondary( i )->GetParticle()->Get4Momentum() 
00135       //       << " ke " << theResult.GetSecondary( i )->GetParticle()->Get4Momentum().e() - theResult.GetSecondary( i )->GetParticle()->GetDefinition()->GetPDGMass() 
00136       //       << G4endl;
00137 
00138       secs_4p_lab += theResult.GetSecondary( i )->GetParticle()->Get4Momentum();
00139 
00140       G4double beta = 0;
00141       if ( theResult.GetSecondary( i )->GetParticle()->GetDefinition() != G4Gamma::Gamma() )
00142       {
00143          beta = theResult.GetSecondary( i )->GetParticle()->Get4Momentum().beta(); 
00144       }
00145       else
00146       {
00147          beta = 1;
00148       }
00149 
00150       if ( theResult.GetSecondary( i )->GetParticle()->GetDefinition() == resi_pd ) ires = i; 
00151 
00152       if ( slow > beta && beta != 0 ) 
00153       {
00154          slow = beta; 
00155          islow = i;
00156       }
00157 
00158       if ( fast <= beta ) 
00159       {
00160          if ( fast != 1 )
00161          {
00162             fast = beta; 
00163             ifast = i;
00164          } 
00165          else
00166          {
00167 //          fast is already photon then check E
00168             G4double e = theResult.GetSecondary( i )->GetParticle()->Get4Momentum().e();
00169             if ( e > theResult.GetSecondary( ifast )->GetParticle()->Get4Momentum().e() )   
00170             {
00171 //             among photons, the highest E becomes the fastest 
00172                ifast = i; 
00173             }
00174          } 
00175       }
00176    }
00177 
00178 
00179    G4LorentzVector dif_4p = init_4p_lab - secs_4p_lab;
00180 
00181    //G4cout << "HP_DB dif_4p " << init_4p_lab - secs_4p_lab << G4endl;
00182    //G4cout << "HP_DB dif_3p mag " << ( dif_4p.v() ).mag() << G4endl;
00183    //G4cout << "HP_DB dif_e " << dif_4p.e() - ( dif_4p.v() ).mag()<< G4endl;
00184 
00185    G4LorentzVector p4(0);
00186    if ( ires == -1 ) 
00187    {
00188 //    Create and Add Residual Nucleus 
00189       ires = nSecondaries;
00190       nSecondaries += 1;
00191 
00192       G4DynamicParticle* res = new G4DynamicParticle ( resi_pd , dif_4p.v() );    
00193       theResult.AddSecondary ( res );    
00194 
00195       p4 = res->Get4Momentum(); 
00196       if ( slow > p4.beta() ) 
00197       {
00198          slow = p4.beta(); 
00199          islow = ires;
00200       }
00201       dif_4p = init_4p_lab - ( secs_4p_lab + p4 );  
00202    }
00203 
00204    if ( needOneMoreSec )
00205    {
00206       nSecondaries += 1;
00207       G4DynamicParticle* one = new G4DynamicParticle ( oneMoreSec_pd , dif_4p.v() );    
00208       theResult.AddSecondary ( one );    
00209       p4 = one->Get4Momentum(); 
00210       if ( slow > p4.beta() ) 
00211       {
00212          slow = p4.beta(); 
00213          islow = nSecondaries-1; //Because the first is 0th, so the last becomes "nSecondaries-1"
00214       }
00215       dif_4p = init_4p_lab - ( secs_4p_lab + p4 );  
00216    }
00217 
00218    //Which is bigger dif_p or dif_e
00219 
00220    if ( dif_4p.v().mag() < std::abs( dif_4p.e() ) )
00221    {
00222 
00223       // Adjust p
00224       //if ( dif_4p.v().mag() < 1*MeV )
00225       if ( minimum_energy < dif_4p.v().mag() && dif_4p.v().mag() < 1*MeV )
00226       {
00227 
00228          nSecondaries += 1;
00229          theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , dif_4p.v() ) );    
00230 
00231       }
00232       else
00233       {
00234          //G4cout << "HP_DB Difference in dif_p is too large (>1MeV) or too small(<1keV) to adjust, so that give up tuning" << G4endl;
00235       }
00236 
00237    }
00238    else
00239    {
00240 
00241       // dif_p > dif_e 
00242       // at first momentum 
00243       // Move residual momentum
00244 
00245       p4 = theResult.GetSecondary( ires )->GetParticle()->Get4Momentum();
00246       theResult.GetSecondary( ires )->GetParticle()->SetMomentum( p4.v() + dif_4p.v() ); 
00247       dif_4p = init_4p_lab - ( secs_4p_lab - p4 + theResult.GetSecondary( ires )->GetParticle()->Get4Momentum()  );  
00248 
00249       //G4cout << "HP_DB new residual kinetic energy " << theResult.GetSecondary( ires )->GetParticle()->GetKineticEnergy() << G4endl;
00250 
00251    }
00252 
00253    G4double dif_e = dif_4p.e() - ( dif_4p.v() ).mag();
00254    //G4cout << "HP_DB dif_e " << dif_e << G4endl;
00255 
00256    if ( dif_e > 0 )
00257    {
00258 
00259 //    create 2 gamma 
00260 
00261       nSecondaries += 2;
00262       G4double e1 = ( dif_4p.e() -dif_4p.v().mag() ) / 2;
00263       
00264       if ( minimum_energy < e1 )  
00265       {
00266          G4double costh = 2.*G4UniformRand()-1.;
00267          G4double phi = twopi*G4UniformRand();
00268          G4ThreeVector dir( std::sin(std::acos(costh))*std::cos(phi), 
00269                             std::sin(std::acos(costh))*std::sin(phi),
00270                             costh);
00271          theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , e1*dir ) );    
00272          theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , -e1*dir ) );    
00273       }
00274       else
00275       {
00276          //G4cout << "HP_DB Difference is too small(<1keV) to adjust, so that neglect it" << G4endl;
00277       }
00278 
00279    }
00280    else    //dif_e < 0
00281    {
00282 
00283 //    At first reduce KE of the fastest secondary;
00284       G4double ke0 = theResult.GetSecondary( ifast )->GetParticle()->GetKineticEnergy();
00285       G4ThreeVector p0 = theResult.GetSecondary( ifast )->GetParticle()->GetMomentum();
00286       G4ThreeVector dir = ( theResult.GetSecondary( ifast )->GetParticle()->GetMomentum() ).unit();
00287 
00288       //G4cout << "HP_DB ifast " << ifast << " ke0 " << ke0 << G4endl;
00289 
00290       if ( ke0 + dif_e > 0 )
00291       {
00292          theResult.GetSecondary( ifast )->GetParticle()->SetKineticEnergy( ke0 + dif_e ); 
00293          G4ThreeVector dp = p0 - theResult.GetSecondary( ifast )->GetParticle()->GetMomentum();  
00294 
00295          G4ThreeVector p = theResult.GetSecondary( islow )->GetParticle()->GetMomentum();
00296          //theResult.GetSecondary( islow )->GetParticle()->SetMomentum( p - dif_e*dir ); 
00297          theResult.GetSecondary( islow )->GetParticle()->SetMomentum( p + dp ); 
00298       }
00299       else
00300       {
00301          //G4cout << "HP_DB Difference in dif_e too large ( <0MeV ) to adjust, so that give up tuning" << G4endl;
00302       }
00303 
00304    }
00305 
00306 }

virtual G4HadFinalState* G4NeutronHPFinalState::ApplyYourself ( const G4HadProjectile  )  [inline, virtual]

Reimplemented in G4FissionLibrary, G4NeutronHP2AInelasticFS, G4NeutronHP2N2AInelasticFS, G4NeutronHP2NAInelasticFS, G4NeutronHP2NDInelasticFS, G4NeutronHP2NInelasticFS, G4NeutronHP2NPInelasticFS, G4NeutronHP2PInelasticFS, G4NeutronHP3AInelasticFS, G4NeutronHP3NAInelasticFS, G4NeutronHP3NInelasticFS, G4NeutronHP3NPInelasticFS, G4NeutronHP4NInelasticFS, G4NeutronHPAInelasticFS, G4NeutronHPCaptureFS, G4NeutronHPD2AInelasticFS, G4NeutronHPDAInelasticFS, G4NeutronHPDInelasticFS, G4NeutronHPElasticFS, G4NeutronHPFissionFS, G4NeutronHPHe3InelasticFS, G4NeutronHPInelasticBaseFS, G4NeutronHPInelasticCompFS, G4NeutronHPN2AInelasticFS, G4NeutronHPN2PInelasticFS, G4NeutronHPN3AInelasticFS, G4NeutronHPNAInelasticFS, G4NeutronHPND2AInelasticFS, G4NeutronHPNDInelasticFS, G4NeutronHPNHe3InelasticFS, G4NeutronHPNInelasticFS, G4NeutronHPNPAInelasticFS, G4NeutronHPNPInelasticFS, G4NeutronHPNT2AInelasticFS, G4NeutronHPNTInelasticFS, G4NeutronHPNXInelasticFS, G4NeutronHPPAInelasticFS, G4NeutronHPPDInelasticFS, G4NeutronHPPInelasticFS, G4NeutronHPPTInelasticFS, G4NeutronHPT2AInelasticFS, and G4NeutronHPTInelasticFS.

Definition at line 68 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPChannel::ApplyYourself().

00069   {
00070     throw G4HadronicException(__FILE__, __LINE__, "G4HadFinalState * ApplyYourself(const G4HadProjectile & theTrack) needs implementation");
00071     return 0;
00072   };

G4int G4NeutronHPFinalState::GetM (  )  [inline]

Definition at line 89 of file G4NeutronHPFinalState.hh.

References theBaseM.

00089 { return theBaseM; };

G4double G4NeutronHPFinalState::GetN (  )  [inline]

Definition at line 88 of file G4NeutronHPFinalState.hh.

References theBaseA.

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

00088 { return theBaseA; };

virtual G4NeutronHPVector* G4NeutronHPFinalState::GetXsec (  )  [inline, virtual]

Reimplemented in G4NeutronHPFissionBaseFS, G4NeutronHPInelasticBaseFS, and G4NeutronHPInelasticCompFS.

Definition at line 84 of file G4NeutronHPFinalState.hh.

00084 { return 0; };

virtual G4double G4NeutronHPFinalState::GetXsec ( G4double   )  [inline, virtual]

Reimplemented in G4NeutronHPFissionBaseFS, G4NeutronHPInelasticBaseFS, and G4NeutronHPInelasticCompFS.

Definition at line 83 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPChannel::GetFSCrossSection(), and G4NeutronHPChannel::UpdateData().

00083 { return 0; };

G4double G4NeutronHPFinalState::GetZ ( void   )  [inline]

Definition at line 87 of file G4NeutronHPFinalState.hh.

References theBaseZ.

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

00087 { return theBaseZ; };

G4bool G4NeutronHPFinalState::HasAnyData (  )  [inline]

Definition at line 81 of file G4NeutronHPFinalState.hh.

References hasAnyData.

Referenced by G4NeutronHPChannel::HasAnyData().

00081 {return hasAnyData;};

G4bool G4NeutronHPFinalState::HasFSData (  )  [inline]

Definition at line 80 of file G4NeutronHPFinalState.hh.

References hasFSData.

Referenced by G4NeutronHPFissionBaseFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), G4NeutronHPChannel::HasFSData(), and G4NeutronHPFissionFS::Init().

00080 {return hasFSData;};

G4bool G4NeutronHPFinalState::HasXsec (  )  [inline]

Definition at line 79 of file G4NeutronHPFinalState.hh.

References hasXsec.

00079 {return hasXsec;};

virtual void G4NeutronHPFinalState::Init ( G4double  A,
G4double  Z,
G4int  M,
G4String dirName,
G4String aFSType 
) [pure virtual]

Implemented in G4FissionLibrary, G4NeutronHP2AInelasticFS, G4NeutronHP2N2AInelasticFS, G4NeutronHP2NAInelasticFS, G4NeutronHP2NDInelasticFS, G4NeutronHP2NInelasticFS, G4NeutronHP2NPInelasticFS, G4NeutronHP2PInelasticFS, G4NeutronHP3AInelasticFS, G4NeutronHP3NAInelasticFS, G4NeutronHP3NInelasticFS, G4NeutronHP3NPInelasticFS, G4NeutronHP4NInelasticFS, G4NeutronHPAInelasticFS, G4NeutronHPCaptureFS, G4NeutronHPD2AInelasticFS, G4NeutronHPDAInelasticFS, G4NeutronHPDInelasticFS, G4NeutronHPElasticFS, G4NeutronHPFCFissionFS, G4NeutronHPFFFissionFS, G4NeutronHPFissionBaseFS, G4NeutronHPFissionFS, G4NeutronHPFSFissionFS, G4NeutronHPHe3InelasticFS, G4NeutronHPInelasticBaseFS, G4NeutronHPInelasticCompFS, G4NeutronHPLCFissionFS, G4NeutronHPN2AInelasticFS, G4NeutronHPN2PInelasticFS, G4NeutronHPN3AInelasticFS, G4NeutronHPNAInelasticFS, G4NeutronHPND2AInelasticFS, G4NeutronHPNDInelasticFS, G4NeutronHPNHe3InelasticFS, G4NeutronHPNInelasticFS, G4NeutronHPNPAInelasticFS, G4NeutronHPNPInelasticFS, G4NeutronHPNT2AInelasticFS, G4NeutronHPNTInelasticFS, G4NeutronHPNXInelasticFS, G4NeutronHPPAInelasticFS, G4NeutronHPPDInelasticFS, G4NeutronHPPInelasticFS, G4NeutronHPPTInelasticFS, G4NeutronHPSCFissionFS, G4NeutronHPT2AInelasticFS, G4NeutronHPTCFissionFS, and G4NeutronHPTInelasticFS.

void G4NeutronHPFinalState::Init ( G4double  A,
G4double  Z,
G4String dirName,
G4String aFSType 
) [inline]

Definition at line 66 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPChannel::UpdateData().

00066 { G4int M = 0; Init ( A, Z, M, dirName, aFSType); };

virtual G4NeutronHPFinalState* G4NeutronHPFinalState::New (  )  [pure virtual]

Implemented in G4FissionLibrary, G4NeutronHP2AInelasticFS, G4NeutronHP2N2AInelasticFS, G4NeutronHP2NAInelasticFS, G4NeutronHP2NDInelasticFS, G4NeutronHP2NInelasticFS, G4NeutronHP2NPInelasticFS, G4NeutronHP2PInelasticFS, G4NeutronHP3AInelasticFS, G4NeutronHP3NAInelasticFS, G4NeutronHP3NInelasticFS, G4NeutronHP3NPInelasticFS, G4NeutronHP4NInelasticFS, G4NeutronHPAInelasticFS, G4NeutronHPCaptureFS, G4NeutronHPD2AInelasticFS, G4NeutronHPDAInelasticFS, G4NeutronHPDInelasticFS, G4NeutronHPElasticFS, G4NeutronHPFCFissionFS, G4NeutronHPFFFissionFS, G4NeutronHPFissionFS, G4NeutronHPFSFissionFS, G4NeutronHPHe3InelasticFS, G4NeutronHPInelasticBaseFS, G4NeutronHPInelasticCompFS, G4NeutronHPLCFissionFS, G4NeutronHPN2AInelasticFS, G4NeutronHPN2PInelasticFS, G4NeutronHPN3AInelasticFS, G4NeutronHPNAInelasticFS, G4NeutronHPND2AInelasticFS, G4NeutronHPNDInelasticFS, G4NeutronHPNHe3InelasticFS, G4NeutronHPNInelasticFS, G4NeutronHPNPAInelasticFS, G4NeutronHPNPInelasticFS, G4NeutronHPNT2AInelasticFS, G4NeutronHPNTInelasticFS, G4NeutronHPNXInelasticFS, G4NeutronHPPAInelasticFS, G4NeutronHPPDInelasticFS, G4NeutronHPPInelasticFS, G4NeutronHPPTInelasticFS, G4NeutronHPSCFissionFS, G4NeutronHPT2AInelasticFS, G4NeutronHPTCFissionFS, and G4NeutronHPTInelasticFS.

Referenced by G4NeutronHPChannel::Register().

void G4NeutronHPFinalState::SetA_Z ( G4double  anA,
G4double  aZ,
G4int  aM = 0 
) [inline]

Definition at line 86 of file G4NeutronHPFinalState.hh.

References theBaseA, theBaseM, and theBaseZ.

Referenced by G4NeutronHPChannel::Register().

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

void G4NeutronHPFinalState::SetAZMs ( G4double  anA,
G4double  aZ,
G4int  aM,
G4NeutronHPDataUsed  used 
) [inline, protected]

Definition at line 92 of file G4NeutronHPFinalState.hh.

References theBaseA, theBaseM, and theBaseZ.

Referenced by G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), G4NeutronHPFSFissionFS::Init(), G4NeutronHPFissionBaseFS::Init(), G4NeutronHPElasticFS::Init(), and G4NeutronHPCaptureFS::Init().

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


Field Documentation

G4bool G4NeutronHPFinalState::hasAnyData [protected]

Definition at line 98 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPFinalState(), HasAnyData(), G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), G4NeutronHPFSFissionFS::Init(), G4NeutronHPFissionBaseFS::Init(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPElasticFS::Init(), G4NeutronHPCaptureFS::Init(), and G4FissionLibrary::Init().

G4bool G4NeutronHPFinalState::hasFSData [protected]

Definition at line 97 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPFinalState(), HasFSData(), G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), G4NeutronHPFSFissionFS::Init(), G4NeutronHPFissionBaseFS::Init(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPElasticFS::Init(), G4NeutronHPCaptureFS::Init(), and G4FissionLibrary::Init().

G4bool G4NeutronHPFinalState::hasXsec [protected]

Definition at line 94 of file G4NeutronHPFinalState.hh.

Referenced by G4FissionLibrary::G4FissionLibrary(), G4NeutronHPCaptureFS::G4NeutronHPCaptureFS(), G4NeutronHPElasticFS::G4NeutronHPElasticFS(), G4NeutronHPFCFissionFS::G4NeutronHPFCFissionFS(), G4NeutronHPFFFissionFS::G4NeutronHPFFFissionFS(), G4NeutronHPFinalState(), G4NeutronHPFissionBaseFS::G4NeutronHPFissionBaseFS(), G4NeutronHPFissionFS::G4NeutronHPFissionFS(), G4NeutronHPFSFissionFS::G4NeutronHPFSFissionFS(), G4NeutronHPInelasticBaseFS::G4NeutronHPInelasticBaseFS(), G4NeutronHPInelasticCompFS::G4NeutronHPInelasticCompFS(), G4NeutronHPLCFissionFS::G4NeutronHPLCFissionFS(), G4NeutronHPSCFissionFS::G4NeutronHPSCFissionFS(), G4NeutronHPTCFissionFS::G4NeutronHPTCFissionFS(), HasXsec(), G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), G4NeutronHPFSFissionFS::Init(), G4NeutronHPFissionBaseFS::Init(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPElasticFS::Init(), G4NeutronHPCaptureFS::Init(), and G4FissionLibrary::Init().

G4double G4NeutronHPFinalState::theBaseA [protected]

Definition at line 103 of file G4NeutronHPFinalState.hh.

Referenced by adjust_final_state(), G4NeutronHPFissionFS::ApplyYourself(), G4NeutronHPElasticFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), G4NeutronHPInelasticCompFS::CompositeApply(), G4NeutronHPFinalState(), GetN(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPCaptureFS::Init(), G4NeutronHPInelasticBaseFS::InitGammas(), SetA_Z(), and SetAZMs().

G4int G4NeutronHPFinalState::theBaseM [protected]

Definition at line 105 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPFinalState(), GetM(), SetA_Z(), and SetAZMs().

G4double G4NeutronHPFinalState::theBaseZ [protected]

Definition at line 104 of file G4NeutronHPFinalState.hh.

Referenced by adjust_final_state(), G4NeutronHPFissionFS::ApplyYourself(), G4NeutronHPElasticFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), G4NeutronHPInelasticCompFS::CompositeApply(), G4NeutronHPFinalState(), GetZ(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPCaptureFS::Init(), G4NeutronHPInelasticBaseFS::InitGammas(), SetA_Z(), and SetAZMs().

G4NeutronHPNames G4NeutronHPFinalState::theNames [protected]

Definition at line 99 of file G4NeutronHPFinalState.hh.

Referenced by G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), G4NeutronHPFissionBaseFS::Init(), G4NeutronHPFFFissionFS::Init(), G4NeutronHPElasticFS::Init(), and G4FissionLibrary::Init().

G4int G4NeutronHPFinalState::theNDLDataA [protected]

Definition at line 112 of file G4NeutronHPFinalState.hh.

Referenced by adjust_final_state(), G4NeutronHPFinalState(), G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), and G4NeutronHPFissionBaseFS::Init().

G4int G4NeutronHPFinalState::theNDLDataM [protected]

Definition at line 113 of file G4NeutronHPFinalState.hh.

G4int G4NeutronHPFinalState::theNDLDataZ [protected]

Definition at line 111 of file G4NeutronHPFinalState.hh.

Referenced by adjust_final_state(), G4NeutronHPFinalState(), G4NeutronHPInelasticCompFS::Init(), G4NeutronHPInelasticBaseFS::Init(), and G4NeutronHPFissionBaseFS::Init().

G4HadFinalState G4NeutronHPFinalState::theResult [protected]

Definition at line 101 of file G4NeutronHPFinalState.hh.

Referenced by adjust_final_state(), G4NeutronHPTInelasticFS::ApplyYourself(), G4NeutronHPT2AInelasticFS::ApplyYourself(), G4NeutronHPPTInelasticFS::ApplyYourself(), G4NeutronHPPInelasticFS::ApplyYourself(), G4NeutronHPPDInelasticFS::ApplyYourself(), G4NeutronHPPAInelasticFS::ApplyYourself(), G4NeutronHPNXInelasticFS::ApplyYourself(), G4NeutronHPNTInelasticFS::ApplyYourself(), G4NeutronHPNT2AInelasticFS::ApplyYourself(), G4NeutronHPNPInelasticFS::ApplyYourself(), G4NeutronHPNPAInelasticFS::ApplyYourself(), G4NeutronHPNInelasticFS::ApplyYourself(), G4NeutronHPNHe3InelasticFS::ApplyYourself(), G4NeutronHPNDInelasticFS::ApplyYourself(), G4NeutronHPND2AInelasticFS::ApplyYourself(), G4NeutronHPNAInelasticFS::ApplyYourself(), G4NeutronHPN3AInelasticFS::ApplyYourself(), G4NeutronHPN2PInelasticFS::ApplyYourself(), G4NeutronHPN2AInelasticFS::ApplyYourself(), G4NeutronHPHe3InelasticFS::ApplyYourself(), G4NeutronHPFissionFS::ApplyYourself(), G4NeutronHPElasticFS::ApplyYourself(), G4NeutronHPDInelasticFS::ApplyYourself(), G4NeutronHPDAInelasticFS::ApplyYourself(), G4NeutronHPD2AInelasticFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPAInelasticFS::ApplyYourself(), G4NeutronHP4NInelasticFS::ApplyYourself(), G4NeutronHP3NPInelasticFS::ApplyYourself(), G4NeutronHP3NInelasticFS::ApplyYourself(), G4NeutronHP3NAInelasticFS::ApplyYourself(), G4NeutronHP3AInelasticFS::ApplyYourself(), G4NeutronHP2PInelasticFS::ApplyYourself(), G4NeutronHP2NPInelasticFS::ApplyYourself(), G4NeutronHP2NInelasticFS::ApplyYourself(), G4NeutronHP2NDInelasticFS::ApplyYourself(), G4NeutronHP2NAInelasticFS::ApplyYourself(), G4NeutronHP2N2AInelasticFS::ApplyYourself(), G4NeutronHP2AInelasticFS::ApplyYourself(), G4FissionLibrary::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), and G4NeutronHPInelasticCompFS::CompositeApply().


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:38 2013 for Geant4 by  doxygen 1.4.7