d2/d02/_g4_neutron_h_p_inelastic_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 // this code implementation is the intellectual property of

 // neutron_hp -- source file

 // J.P. Wellisch, Nov-1996

 // A prototype of the low energy neutron transport model.

 //

 // By copying, distributing or modifying the Program (or any work

 // based on the Program) you indicate your acceptance of this statement,

 // and all its terms.

 //

 //

 // 070523 bug fix for G4FPE_DEBUG on by A. Howard (and T. Koi)

 // 081203 limit maximum trial for creating final states add protection for 1H isotope case by T. Koi

 //

 #include "G4NeutronHPInelastic.hh"

 #include "G4SystemOfUnits.hh"


 #include "G4NeutronHPManager.hh"


   G4NeutronHPInelastic::G4NeutronHPInelastic()

     :G4HadronicInteraction("NeutronHPInelastic")

   ,theInelastic(NULL)

   ,numEle(0)

   {

     SetMinEnergy( 0.0 );

     SetMaxEnergy( 20.*MeV );

 /*


     G4int istatus;

 #if defined WIN32-VC

     istatus = system("echo %G4NEUTRONHPDATA%");

 #else

     istatus = system("echo $G4NEUTRONHPDATA");

 #endif

     if ( istatus < 0 )

     {

       G4cout << "Warning! system(\"echo $G4NEUTRONHPDATA\") returns error value at G4NeutronHPInelastic" << G4endl;

     }


 //    G4cout << " entering G4NeutronHPInelastic constructor"<<G4endl;

     if(!getenv("G4NEUTRONHPDATA"))

        throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");

     dirName = getenv("G4NEUTRONHPDATA");

     G4String tString = "/Inelastic";

     dirName = dirName + tString;

     numEle = G4Element::GetNumberOfElements();

 */

 /*

     theInelastic = new G4NeutronHPChannelList[numEle];

     for (G4int i=0; i<numEle; i++)

     {

       theInelastic[i].Init((*(G4Element::GetElementTable()))[i], dirName);

       G4int itry = 0;

       do

       {

         theInelastic[i].Register(&theNFS, "F01"); // has

         theInelastic[i].Register(&theNXFS, "F02");

         theInelastic[i].Register(&the2NDFS, "F03");

         theInelastic[i].Register(&the2NFS, "F04"); // has, E Done

         theInelastic[i].Register(&the3NFS, "F05"); // has, E Done

         theInelastic[i].Register(&theNAFS, "F06");

         theInelastic[i].Register(&theN3AFS, "F07");

         theInelastic[i].Register(&the2NAFS, "F08");

         theInelastic[i].Register(&the3NAFS, "F09");

         theInelastic[i].Register(&theNPFS, "F10");

         theInelastic[i].Register(&theN2AFS, "F11");

         theInelastic[i].Register(&the2N2AFS, "F12");

         theInelastic[i].Register(&theNDFS, "F13");

         theInelastic[i].Register(&theNTFS, "F14");

         theInelastic[i].Register(&theNHe3FS, "F15");

         theInelastic[i].Register(&theND2AFS, "F16");

         theInelastic[i].Register(&theNT2AFS, "F17");

         theInelastic[i].Register(&the4NFS, "F18"); // has, E Done

         theInelastic[i].Register(&the2NPFS, "F19");

         theInelastic[i].Register(&the3NPFS, "F20");

         theInelastic[i].Register(&theN2PFS, "F21");

         theInelastic[i].Register(&theNPAFS, "F22");

         theInelastic[i].Register(&thePFS, "F23");

         theInelastic[i].Register(&theDFS, "F24");

         theInelastic[i].Register(&theTFS, "F25");

         theInelastic[i].Register(&theHe3FS, "F26");

         theInelastic[i].Register(&theAFS, "F27");

         theInelastic[i].Register(&the2AFS, "F28");

         theInelastic[i].Register(&the3AFS, "F29");

         theInelastic[i].Register(&the2PFS, "F30");

         theInelastic[i].Register(&thePAFS, "F31");

         theInelastic[i].Register(&theD2AFS, "F32");

         theInelastic[i].Register(&theT2AFS, "F33");

         theInelastic[i].Register(&thePDFS, "F34");

         theInelastic[i].Register(&thePTFS, "F35");

         theInelastic[i].Register(&theDAFS, "F36");

         theInelastic[i].RestartRegistration();

         itry++;

       }

       //while(!theInelastic[i].HasDataInAnyFinalState());

       while( !theInelastic[i].HasDataInAnyFinalState() && itry < 6 );

                                                               // 6 is corresponding to the value(5) of G4NeutronHPChannel. TK


       if ( itry == 6 )

       {

          // No Final State at all.

          G4bool exceptional = false;

          if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )

          {

             if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H

          }

          if ( !exceptional ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");

       }

     }

 */

 /*


     for (G4int i=0; i<numEle; i++)

     {

       theInelastic.push_back( new G4NeutronHPChannelList );

       (*theInelastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName);

       G4int itry = 0;

       do

       {

         (*theInelastic[i]).Register(&theNFS, "F01"); // has

         (*theInelastic[i]).Register(&theNXFS, "F02");

         (*theInelastic[i]).Register(&the2NDFS, "F03");

         (*theInelastic[i]).Register(&the2NFS, "F04"); // has, E Done

         (*theInelastic[i]).Register(&the3NFS, "F05"); // has, E Done

         (*theInelastic[i]).Register(&theNAFS, "F06");

         (*theInelastic[i]).Register(&theN3AFS, "F07");

         (*theInelastic[i]).Register(&the2NAFS, "F08");

         (*theInelastic[i]).Register(&the3NAFS, "F09");

         (*theInelastic[i]).Register(&theNPFS, "F10");

         (*theInelastic[i]).Register(&theN2AFS, "F11");

         (*theInelastic[i]).Register(&the2N2AFS, "F12");

         (*theInelastic[i]).Register(&theNDFS, "F13");

         (*theInelastic[i]).Register(&theNTFS, "F14");

         (*theInelastic[i]).Register(&theNHe3FS, "F15");

         (*theInelastic[i]).Register(&theND2AFS, "F16");

         (*theInelastic[i]).Register(&theNT2AFS, "F17");

         (*theInelastic[i]).Register(&the4NFS, "F18"); // has, E Done

         (*theInelastic[i]).Register(&the2NPFS, "F19");

         (*theInelastic[i]).Register(&the3NPFS, "F20");

         (*theInelastic[i]).Register(&theN2PFS, "F21");

         (*theInelastic[i]).Register(&theNPAFS, "F22");

         (*theInelastic[i]).Register(&thePFS, "F23");

         (*theInelastic[i]).Register(&theDFS, "F24");

         (*theInelastic[i]).Register(&theTFS, "F25");

         (*theInelastic[i]).Register(&theHe3FS, "F26");

         (*theInelastic[i]).Register(&theAFS, "F27");

         (*theInelastic[i]).Register(&the2AFS, "F28");

         (*theInelastic[i]).Register(&the3AFS, "F29");

         (*theInelastic[i]).Register(&the2PFS, "F30");

         (*theInelastic[i]).Register(&thePAFS, "F31");

         (*theInelastic[i]).Register(&theD2AFS, "F32");

         (*theInelastic[i]).Register(&theT2AFS, "F33");

         (*theInelastic[i]).Register(&thePDFS, "F34");

         (*theInelastic[i]).Register(&thePTFS, "F35");

         (*theInelastic[i]).Register(&theDAFS, "F36");

         (*theInelastic[i]).RestartRegistration();

         itry++;

       }

       while( !(*theInelastic[i]).HasDataInAnyFinalState() && itry < 6 );

                                                               // 6 is corresponding to the value(5) of G4NeutronHPChannel. TK


       if ( itry == 6 )

       {

          // No Final State at all.

          G4bool exceptional = false;

          if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )

          {

             if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H

          }

          if ( !exceptional ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");

       }


     }

 */

   }


   G4NeutronHPInelastic::~G4NeutronHPInelastic()

   {

 //    delete [] theInelastic;

      for ( std::vector<G4NeutronHPChannelList*>::iterator

            it = (*theInelastic).begin() ; it != (*theInelastic).end() ; it++ )

      {

         delete *it;

      }

      (*theInelastic).clear();

   }


   #include "G4NeutronHPThermalBoost.hh"


   G4HadFinalState * G4NeutronHPInelastic::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& aNucleus )

   {

     //if ( numEle < (G4int)G4Element::GetNumberOfElements() ) addChannelForNewElement();

     G4NeutronHPManager::GetInstance()->OpenReactionWhiteBoard();

     const G4Material * theMaterial = aTrack.GetMaterial();

     G4int n = theMaterial->GetNumberOfElements();

     G4int index = theMaterial->GetElement(0)->GetIndex();

     G4int it=0;

     if(n!=1)

     {

       xSec = new G4double[n];

       G4double sum=0;

       G4int i;

       const G4double * NumAtomsPerVolume = theMaterial->GetVecNbOfAtomsPerVolume();

       G4double rWeight;

       G4NeutronHPThermalBoost aThermalE;

       for (i=0; i<n; i++)

       {

         index = theMaterial->GetElement(i)->GetIndex();

         rWeight = NumAtomsPerVolume[i];

         //xSec[i] = theInelastic[index].GetXsec(aThermalE.GetThermalEnergy(aTrack,

         xSec[i] = (*(*theInelastic)[index]).GetXsec(aThermalE.GetThermalEnergy(aTrack,

                                                                          theMaterial->GetElement(i),

                                                                          theMaterial->GetTemperature()));

         xSec[i] *= rWeight;

         sum+=xSec[i];

       }

       G4double random = G4UniformRand();

       G4double running = 0;

       for (i=0; i<n; i++)

       {

         running += xSec[i];

         index = theMaterial->GetElement(i)->GetIndex();

         it = i;

         //if(random<=running/sum) break;

         if( sum == 0 || random<=running/sum) break;

       }

       delete [] xSec;

     }


     //return theInelastic[index].ApplyYourself(theMaterial->GetElement(it), aTrack);

     G4HadFinalState* result = (*(*theInelastic)[index]).ApplyYourself(theMaterial->GetElement(it), aTrack);


     //Overwrite target parameters

     aNucleus.SetParameters(G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA(),G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargZ());

     const G4Element* target_element = (*G4Element::GetElementTable())[index];

     const G4Isotope* target_isotope=NULL;

     G4int iele = target_element->GetNumberOfIsotopes();

     for ( G4int j = 0 ; j != iele ; j++ ) {

        target_isotope=target_element->GetIsotope( j );

        if ( target_isotope->GetN() == G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA() ) break;

     }

     //G4cout << "Target Material of this reaction is " << theMaterial->GetName() << G4endl;

     //G4cout << "Target Element of this reaction is " << target_element->GetName() << G4endl;

     //G4cout << "Target Isotope of this reaction is " << target_isotope->GetName() << G4endl;

     aNucleus.SetIsotope( target_isotope );


     G4NeutronHPManager::GetInstance()->CloseReactionWhiteBoard();

     return result;

   }


 const std::pair<G4double, G4double> G4NeutronHPInelastic::GetFatalEnergyCheckLevels() const

 {

       // max energy non-conservation is mass of heavy nucleus

 //      if ( getenv("G4NEUTRONHP_DO_NOT_ADJUST_FINAL_STATE") ) return std::pair<G4double, G4double>(5*perCent,250*GeV);

       // This should be same to the hadron default value

 //      return std::pair<G4double, G4double>(10*perCent,10*GeV);

       return std::pair<G4double, G4double>(10*perCent,DBL_MAX);

 }


 /*

 void G4NeutronHPInelastic::addChannelForNewElement()

 {

    for ( G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++ )

    {

       G4cout << "G4NeutronHPInelastic Prepairing Data for the new element of " << (*(G4Element::GetElementTable()))[i]->GetName() << G4endl;


       theInelastic.push_back( new G4NeutronHPChannelList );

       (*theInelastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName);

       G4int itry = 0;

       do

       {

          (*theInelastic[i]).Register(&theNFS, "F01"); // has

          (*theInelastic[i]).Register(&theNXFS, "F02");

          (*theInelastic[i]).Register(&the2NDFS, "F03");

          (*theInelastic[i]).Register(&the2NFS, "F04"); // has, E Done

          (*theInelastic[i]).Register(&the3NFS, "F05"); // has, E Done

          (*theInelastic[i]).Register(&theNAFS, "F06");

          (*theInelastic[i]).Register(&theN3AFS, "F07");

          (*theInelastic[i]).Register(&the2NAFS, "F08");

          (*theInelastic[i]).Register(&the3NAFS, "F09");

          (*theInelastic[i]).Register(&theNPFS, "F10");

          (*theInelastic[i]).Register(&theN2AFS, "F11");

          (*theInelastic[i]).Register(&the2N2AFS, "F12");

          (*theInelastic[i]).Register(&theNDFS, "F13");

          (*theInelastic[i]).Register(&theNTFS, "F14");

          (*theInelastic[i]).Register(&theNHe3FS, "F15");

          (*theInelastic[i]).Register(&theND2AFS, "F16");

          (*theInelastic[i]).Register(&theNT2AFS, "F17");

          (*theInelastic[i]).Register(&the4NFS, "F18"); // has, E Done

          (*theInelastic[i]).Register(&the2NPFS, "F19");

          (*theInelastic[i]).Register(&the3NPFS, "F20");

          (*theInelastic[i]).Register(&theN2PFS, "F21");

          (*theInelastic[i]).Register(&theNPAFS, "F22");

          (*theInelastic[i]).Register(&thePFS, "F23");

          (*theInelastic[i]).Register(&theDFS, "F24");

          (*theInelastic[i]).Register(&theTFS, "F25");

          (*theInelastic[i]).Register(&theHe3FS, "F26");

          (*theInelastic[i]).Register(&theAFS, "F27");

          (*theInelastic[i]).Register(&the2AFS, "F28");

          (*theInelastic[i]).Register(&the3AFS, "F29");

          (*theInelastic[i]).Register(&the2PFS, "F30");

          (*theInelastic[i]).Register(&thePAFS, "F31");

          (*theInelastic[i]).Register(&theD2AFS, "F32");

          (*theInelastic[i]).Register(&theT2AFS, "F33");

          (*theInelastic[i]).Register(&thePDFS, "F34");

          (*theInelastic[i]).Register(&thePTFS, "F35");

          (*theInelastic[i]).Register(&theDAFS, "F36");

          (*theInelastic[i]).RestartRegistration();

          itry++;

       }

       while( !(*theInelastic[i]).HasDataInAnyFinalState() && itry < 6 );

                                                                   // 6 is corresponding to the value(5) of G4NeutronHPChannel. TK


       if ( itry == 6 )

       {

          // No Final State at all.

          G4bool exceptional = false;

          if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )

          {

             if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H

          }

          if ( !exceptional ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");

       }

    }


    numEle = (G4int)G4Element::GetNumberOfElements();

 }

 */


 G4int G4NeutronHPInelastic::GetVerboseLevel() const

 {

    return G4NeutronHPManager::GetInstance()->GetVerboseLevel();

 }

 void G4NeutronHPInelastic::SetVerboseLevel( G4int newValue )

 {

    G4NeutronHPManager::GetInstance()->SetVerboseLevel(newValue);

 }

 void G4NeutronHPInelastic::BuildPhysicsTable(const G4ParticleDefinition&)

 {

    G4NeutronHPManager* hpmanager = G4NeutronHPManager::GetInstance();


    theInelastic = hpmanager->GetInelasticFinalStates();


    if ( !G4Threading::IsWorkerThread() ) {


       if ( theInelastic == NULL ) theInelastic = new std::vector<G4NeutronHPChannelList*>;


       if ( numEle == (G4int)G4Element::GetNumberOfElements() ) return;


       if ( theInelastic->size() == G4Element::GetNumberOfElements() ) {

          numEle = G4Element::GetNumberOfElements();

          return;

       }


       if ( !getenv("G4NEUTRONHPDATA") )

          throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");

       dirName = getenv("G4NEUTRONHPDATA");

       G4String tString = "/Inelastic";

       dirName = dirName + tString;


       for (G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++)

       {

          (*theInelastic).push_back( new G4NeutronHPChannelList );

          (*(*theInelastic)[i]).Init((*(G4Element::GetElementTable()))[i], dirName);

          G4int itry = 0;

          do

          {

         (*(*theInelastic)[i]).Register(&theNFS,    "F01"); // has

         (*(*theInelastic)[i]).Register(&theNXFS,    "F02");

         (*(*theInelastic)[i]).Register(&the2NDFS,    "F03");

         (*(*theInelastic)[i]).Register(&the2NFS, "F04"); // has, E Done

         (*(*theInelastic)[i]).Register(&the3NFS, "F05"); // has, E Done

         (*(*theInelastic)[i]).Register(&theNAFS, "F06");

         (*(*theInelastic)[i]).Register(&theN3AFS,    "F07");

         (*(*theInelastic)[i]).Register(&the2NAFS,    "F08");

         (*(*theInelastic)[i]).Register(&the3NAFS,    "F09");

         (*(*theInelastic)[i]).Register(&theNPFS,    "F10");

         (*(*theInelastic)[i]).Register(&theN2AFS,    "F11");

         (*(*theInelastic)[i]).Register(&the2N2AFS,    "F12");

         (*(*theInelastic)[i]).Register(&theNDFS,    "F13");

         (*(*theInelastic)[i]).Register(&theNTFS,    "F14");

         (*(*theInelastic)[i]).Register(&theNHe3FS,    "F15");

         (*(*theInelastic)[i]).Register(&theND2AFS,    "F16");

         (*(*theInelastic)[i]).Register(&theNT2AFS,    "F17");

         (*(*theInelastic)[i]).Register(&the4NFS,    "F18"); // has, E Done

         (*(*theInelastic)[i]).Register(&the2NPFS,    "F19");

         (*(*theInelastic)[i]).Register(&the3NPFS,    "F20");

         (*(*theInelastic)[i]).Register(&theN2PFS,    "F21");

         (*(*theInelastic)[i]).Register(&theNPAFS,    "F22");

         (*(*theInelastic)[i]).Register(&thePFS, "F23");

         (*(*theInelastic)[i]).Register(&theDFS,    "F24");

         (*(*theInelastic)[i]).Register(&theTFS,    "F25");

         (*(*theInelastic)[i]).Register(&theHe3FS,    "F26");

         (*(*theInelastic)[i]).Register(&theAFS,    "F27");

         (*(*theInelastic)[i]).Register(&the2AFS,    "F28");

         (*(*theInelastic)[i]).Register(&the3AFS,    "F29");

         (*(*theInelastic)[i]).Register(&the2PFS,    "F30");

         (*(*theInelastic)[i]).Register(&thePAFS,    "F31");

         (*(*theInelastic)[i]).Register(&theD2AFS,    "F32");

         (*(*theInelastic)[i]).Register(&theT2AFS,    "F33");

         (*(*theInelastic)[i]).Register(&thePDFS,    "F34");

         (*(*theInelastic)[i]).Register(&thePTFS,    "F35");

         (*(*theInelastic)[i]).Register(&theDAFS,    "F36");

         (*(*theInelastic)[i]).RestartRegistration();

            itry++;

          }

          while( !(*(*theInelastic)[i]).HasDataInAnyFinalState() && itry < 6 );

                                                                  // 6 is corresponding to the value(5) of G4NeutronHPChannel. TK


          if ( itry == 6 )

          {

             // No Final State at all.

             G4bool exceptional = false;

             if ( (*(G4Element::GetElementTable()))[i]->GetNumberOfIsotopes() == 1 )

             {

                if ( (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetZ() == 1 && (*(G4Element::GetElementTable()))[i]->GetIsotope( 0 )->GetN() == 1 ) exceptional = true;  //1H

             }

             if ( !exceptional ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this element");

          }


       }

       hpmanager->RegisterInelasticFinalStates( theInelastic );


    }

    numEle = G4Element::GetNumberOfElements();

 }

G4NeutronHPInelastic::theNDFS
G4NeutronHPNDInelasticFS theNDFS
Definition: G4NeutronHPInelastic.hh:136

G4NeutronHPInelastic::theN2PFS
G4NeutronHPN2PInelasticFS theN2PFS
Definition: G4NeutronHPInelastic.hh:132

G4Element::GetNumberOfIsotopes
size_t GetNumberOfIsotopes() const
Definition: G4Element.hh:158

G4NeutronHPInelastic::the2PFS
G4NeutronHP2PInelasticFS the2PFS
Definition: G4NeutronHPInelastic.hh:120

G4NeutronHPManager::RegisterInelasticFinalStates
void RegisterInelasticFinalStates(std::vector< G4NeutronHPChannelList * > *val)
Definition: G4NeutronHPManager.hh:102

G4NeutronHPManager::OpenReactionWhiteBoard
void OpenReactionWhiteBoard()
Definition: G4NeutronHPManager.cc:75

G4HadFinalState
Definition: G4HadFinalState.hh:45

G4NeutronHPReactionWhiteBoard::GetTargA
G4int GetTargA()
Definition: G4NeutronHPReactionWhiteBoard.hh:51

G4Nucleus::SetIsotope
void SetIsotope(const G4Isotope *iso)
Definition: G4Nucleus.hh:122

lightions::Init
void Init()
Definition: G4IonTable.cc:87

MeV
static const double MeV
Definition: G4SIunits.hh:193

G4NeutronHPInelastic::theHe3FS
G4NeutronHPHe3InelasticFS theHe3FS
Definition: G4NeutronHPInelastic.hh:130

G4NeutronHPInelastic::thePTFS
G4NeutronHPPTInelasticFS thePTFS
Definition: G4NeutronHPInelastic.hh:147

G4NeutronHPInelastic.hh

G4Nucleus
Definition: G4Nucleus.hh:50

G4NeutronHPInelastic::theT2AFS
G4NeutronHPT2AInelasticFS theT2AFS
Definition: G4NeutronHPInelastic.hh:148

G4NeutronHPManager::GetInstance
static G4NeutronHPManager * GetInstance()
Definition: G4NeutronHPManager.hh:52

G4NeutronHPManager::GetReactionWhiteBoard
G4NeutronHPReactionWhiteBoard * GetReactionWhiteBoard()
Definition: G4NeutronHPManager.cc:86

G4NeutronHPInelastic::the2N2AFS
G4NeutronHP2N2AInelasticFS the2N2AFS
Definition: G4NeutronHPInelastic.hh:115

G4Material
Definition: G4Material.hh:120

G4NeutronHPInelastic::theDAFS
G4NeutronHPDAInelasticFS theDAFS
Definition: G4NeutronHPInelastic.hh:128

G4Element
Definition: G4Element.hh:97

G4HadProjectile
Definition: G4HadProjectile.hh:39

G4NeutronHPInelastic::theNPAFS
G4NeutronHPNPAInelasticFS theNPAFS
Definition: G4NeutronHPInelastic.hh:139

G4NeutronHPInelastic::theInelastic
std::vector< G4NeutronHPChannelList * > * theInelastic
Definition: G4NeutronHPInelastic.hh:107

G4NeutronHPInelastic::theNFS
G4NeutronHPNInelasticFS theNFS
Definition: G4NeutronHPInelastic.hh:138

G4NeutronHPInelastic::theTFS
G4NeutronHPTInelasticFS theTFS
Definition: G4NeutronHPInelastic.hh:149

G4NeutronHPInelastic::thePDFS
G4NeutronHPPDInelasticFS thePDFS
Definition: G4NeutronHPInelastic.hh:145

G4NeutronHPInelastic::GetFatalEnergyCheckLevels
virtual const std::pair< G4double, G4double > GetFatalEnergyCheckLevels() const
Definition: G4NeutronHPInelastic.cc:275

G4NeutronHPInelastic::SetVerboseLevel
void SetVerboseLevel(G4int)
Definition: G4NeutronHPInelastic.cc:358

G4NeutronHPInelastic::the2NAFS
G4NeutronHP2NAInelasticFS the2NAFS
Definition: G4NeutronHPInelastic.hh:116

G4NeutronHPChannelList
Definition: G4NeutronHPChannelList.hh:44

G4NeutronHPInelastic::theNXFS
G4NeutronHPNXInelasticFS theNXFS
Definition: G4NeutronHPInelastic.hh:143

G4NeutronHPInelastic::dirName
G4String dirName
Definition: G4NeutronHPInelastic.hh:108

G4NeutronHPInelastic::the2NPFS
G4NeutronHP2NPInelasticFS the2NPFS
Definition: G4NeutronHPInelastic.hh:119

G4NeutronHPInelastic::theD2AFS
G4NeutronHPD2AInelasticFS theD2AFS
Definition: G4NeutronHPInelastic.hh:127

G4ParticleDefinition
Definition: G4ParticleDefinition.hh:111

G4Material::GetElement
const G4Element * GetElement(G4int iel) const
Definition: G4Material.hh:202

G4int
int G4int
Definition: G4Types.hh:78

G4HadronicInteraction
Definition: G4HadronicInteraction.hh:62

G4NeutronHPInelastic::BuildPhysicsTable
void BuildPhysicsTable(const G4ParticleDefinition &)
Definition: G4NeutronHPInelastic.cc:362

G4NeutronHPManager
Definition: G4NeutronHPManager.hh:49

G4NeutronHPInelastic::the3NFS
G4NeutronHP3NInelasticFS the3NFS
Definition: G4NeutronHPInelastic.hh:123

G4HadronicInteraction::SetMinEnergy
void SetMinEnergy(G4double anEnergy)
Definition: G4HadronicInteraction.hh:89

G4Material::GetVecNbOfAtomsPerVolume
const G4double * GetVecNbOfAtomsPerVolume() const
Definition: G4Material.hh:206

G4NeutronHPInelastic::the4NFS
G4NeutronHP4NInelasticFS the4NFS
Definition: G4NeutronHPInelastic.hh:125

G4NeutronHPInelastic::the2NDFS
G4NeutronHP2NDInelasticFS the2NDFS
Definition: G4NeutronHPInelastic.hh:117

G4AutoDelete::Register
void Register(T *inst)
Definition: G4AutoDelete.hh:65

G4NeutronHPInelastic::the3NAFS
G4NeutronHP3NAInelasticFS the3NAFS
Definition: G4NeutronHPInelastic.hh:122

G4Isotope::GetN
G4int GetN() const
Definition: G4Isotope.hh:94

G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:93

G4Element::GetNumberOfElements
static size_t GetNumberOfElements()
Definition: G4Element.cc:410

G4NeutronHPInelastic::theNT2AFS
G4NeutronHPNT2AInelasticFS theNT2AFS
Definition: G4NeutronHPInelastic.hh:141

G4NeutronHPInelastic::thePFS
G4NeutronHPPInelasticFS thePFS
Definition: G4NeutronHPInelastic.hh:146

G4bool
bool G4bool
Definition: G4Types.hh:79

G4NeutronHPInelastic::theND2AFS
G4NeutronHPND2AInelasticFS theND2AFS
Definition: G4NeutronHPInelastic.hh:135

G4NeutronHPInelastic::the2AFS
G4NeutronHP2AInelasticFS the2AFS
Definition: G4NeutronHPInelastic.hh:114

G4NeutronHPInelastic::theNAFS
G4NeutronHPNAInelasticFS theNAFS
Definition: G4NeutronHPInelastic.hh:134

G4Isotope
Definition: G4Isotope.hh:72

G4Element::GetIndex
size_t GetIndex() const
Definition: G4Element.hh:181

perCent
static const double perCent
Definition: G4SIunits.hh:296

n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144

G4NeutronHPManager::GetVerboseLevel
G4int GetVerboseLevel()
Definition: G4NeutronHPManager.hh:73

G4NeutronHPInelastic::theDFS
G4NeutronHPDInelasticFS theDFS
Definition: G4NeutronHPInelastic.hh:129

G4Threading::IsWorkerThread
G4bool IsWorkerThread()
Definition: G4Threading.cc:128

G4NeutronHPThermalBoost.hh

G4NeutronHPManager::SetVerboseLevel
void SetVerboseLevel(G4int i)
Definition: G4NeutronHPManager.cc:192

G4NeutronHPInelastic::theNHe3FS
G4NeutronHPNHe3InelasticFS theNHe3FS
Definition: G4NeutronHPInelastic.hh:137

G4NeutronHPThermalBoost
Definition: G4NeutronHPThermalBoost.hh:39

G4NeutronHPThermalBoost::GetThermalEnergy
G4double GetThermalEnergy(const G4HadProjectile &aP, const G4Element *anE, G4double aT)
Definition: G4NeutronHPThermalBoost.hh:42

G4NeutronHPInelastic::thePAFS
G4NeutronHPPAInelasticFS thePAFS
Definition: G4NeutronHPInelastic.hh:144

G4NeutronHPManager::CloseReactionWhiteBoard
void CloseReactionWhiteBoard()
Definition: G4NeutronHPManager.cc:95

G4NeutronHPInelastic::G4NeutronHPInelastic
G4NeutronHPInelastic()
Definition: G4NeutronHPInelastic.cc:44

G4NeutronHPInelastic::ApplyYourself
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &aTargetNucleus)
Definition: G4NeutronHPInelastic.cc:214

G4NeutronHPInelastic::GetVerboseLevel
G4int GetVerboseLevel() const
Definition: G4NeutronHPInelastic.cc:354

G4HadronicInteraction::SetMaxEnergy
void SetMaxEnergy(const G4double anEnergy)
Definition: G4HadronicInteraction.hh:102

G4Element::GetIsotope
const G4Isotope * GetIsotope(G4int iso) const
Definition: G4Element.hh:169

G4NeutronHPInelastic::the3AFS
G4NeutronHP3AInelasticFS the3AFS
Definition: G4NeutronHPInelastic.hh:121

G4Material::GetTemperature
G4double GetTemperature() const
Definition: G4Material.hh:182

G4NeutronHPInelastic::theN2AFS
G4NeutronHPN2AInelasticFS theN2AFS
Definition: G4NeutronHPInelastic.hh:131

G4NeutronHPInelastic::~G4NeutronHPInelastic
~G4NeutronHPInelastic()
Definition: G4NeutronHPInelastic.cc:201

G4HadProjectile::GetMaterial
const G4Material * GetMaterial() const
Definition: G4HadProjectile.hh:76

G4Material::GetNumberOfElements
size_t GetNumberOfElements() const
Definition: G4Material.hh:186

G4HadronicException
Definition: G4HadronicException.hh:33

G4double
double G4double
Definition: G4Types.hh:76

G4NeutronHPInelastic::theNPFS
G4NeutronHPNPInelasticFS theNPFS
Definition: G4NeutronHPInelastic.hh:140

G4SystemOfUnits.hh

G4NeutronHPInelastic::the3NPFS
G4NeutronHP3NPInelasticFS the3NPFS
Definition: G4NeutronHPInelastic.hh:124

G4NeutronHPManager.hh

G4Element::GetElementTable
static G4ElementTable * GetElementTable()
Definition: G4Element.cc:403

G4NeutronHPInelastic::xSec
G4double * xSec
Definition: G4NeutronHPInelastic.hh:105

G4NeutronHPInelastic::theN3AFS
G4NeutronHPN3AInelasticFS theN3AFS
Definition: G4NeutronHPInelastic.hh:133

DBL_MAX
#define DBL_MAX
Definition: templates.hh:83

G4NeutronHPInelastic::theNTFS
G4NeutronHPNTInelasticFS theNTFS
Definition: G4NeutronHPInelastic.hh:142

G4Nucleus::SetParameters
void SetParameters(const G4double A, const G4double Z)
Definition: G4Nucleus.cc:198

G4NeutronHPInelastic::the2NFS
G4NeutronHP2NInelasticFS the2NFS
Definition: G4NeutronHPInelastic.hh:118

G4NeutronHPInelastic::theAFS
G4NeutronHPAInelasticFS theAFS
Definition: G4NeutronHPInelastic.hh:126

G4NeutronHPManager::GetInelasticFinalStates
std::vector< G4NeutronHPChannelList * > * GetInelasticFinalStates()
Definition: G4NeutronHPManager.hh:101

G4String
Definition: G4String.hh:45

G4NeutronHPInelastic::numEle
G4int numEle
Definition: G4NeutronHPInelastic.hh:109