G4TheoFSGenerator.cc

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
//
// G4TheoFSGenerator
//
// 20110307  M. Kelsey -- Add call to new theTransport->SetPrimaryProjectile()
//      to provide access to full initial state (for Bertini)
// 20110805  M. Kelsey -- Follow change to G4V3DNucleus::GetNucleons()
 
#include "G4DynamicParticle.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ReactionProductVector.hh"
#include "G4ReactionProduct.hh"
#include "G4IonTable.hh"
#include "G4HadronicParameters.hh"
#include "G4CRCoalescence.hh"
#include "G4HadronicInteractionRegistry.hh"
 
 
G4TheoFSGenerator::G4TheoFSGenerator( const G4String& name )
    : G4HadronicInteraction( name )
    , theTransport( nullptr ), theHighEnergyGenerator( nullptr )
    , theQuasielastic( nullptr ), theCosmicCoalescence( nullptr )
    , theStringModelID( -1 ), theFTFQuasiElasticID( -1 ), theFTFDiffractiveID( -1 )
{
  theParticleChange = new G4HadFinalState;
  theStringModelID     = G4PhysicsModelCatalog::GetModelID( "model_" + name );
  theFTFQuasiElasticID = G4PhysicsModelCatalog::GetModelID( "model_QuasiElastic_FTF" );
  theFTFDiffractiveID  = G4PhysicsModelCatalog::GetModelID( "model_Diffractive_FTF" );
}
 
 
G4TheoFSGenerator::~G4TheoFSGenerator()
{
  delete theParticleChange;
}
 
 
void G4TheoFSGenerator::ModelDescription( std::ostream& outFile ) const
{
  outFile << GetModelName() <<" consists of a " << theHighEnergyGenerator->GetModelName()
      << " string model and a stage to de-excite the excited nuclear fragment.\n<p>"
      << "The string model simulates the interaction of\n"
          << "an incident hadron with a nucleus, forming \n"
          << "excited strings, decays these strings into hadrons,\n"
          << "and leaves an excited nucleus. \n"
          << "<p>The string model:\n";
  theHighEnergyGenerator->ModelDescription( outFile );
  outFile << "\n<p>";
  theTransport->PropagateModelDescription( outFile );
}
 
 
G4HadFinalState* G4TheoFSGenerator::ApplyYourself( const G4HadProjectile & thePrimary, G4Nucleus &theNucleus )
{
  // init particle change
  theParticleChange->Clear();
  theParticleChange->SetStatusChange( stopAndKill );
  G4double timePrimary = thePrimary.GetGlobalTime();
 
  // Temporarily dummy treatment of heavy (charm and bottom) hadron projectiles at low energies.
  // Cascade models are currently not applicable for heavy hadrons and string models cannot
  // handle them properly at low energies - let's say safely below ~100 MeV.
  // In these cases, we return as final state the initial state unchanged.
  // For most applications, this is a safe simplification, giving that the nearly all
  // slowly moving charm and bottom hadrons decay before any hadronic interaction can occur.
  // Note that we prefer not to use G4HadronicParameters::GetMinEnergyTransitionFTF_Cascade()
  // (typically ~3 GeV) because FTFP works reasonably well below such a value.
  const G4double energyThresholdForCharmAndBottomHadrons = 100.0*CLHEP::MeV;
  if ( thePrimary.GetKineticEnergy() < energyThresholdForCharmAndBottomHadrons  &&
       ( thePrimary.GetDefinition()->GetQuarkContent( 4 )     != 0  ||    // Has charm       constituent quark
     thePrimary.GetDefinition()->GetAntiQuarkContent( 4 ) != 0  ||    // Has anti-charm  constituent anti-quark
     thePrimary.GetDefinition()->GetQuarkContent( 5 )     != 0  ||    // Has bottom      constituent quark
     thePrimary.GetDefinition()->GetAntiQuarkContent( 5 ) != 0 ) ) {  // Has anti-bottom constituent anti-quark
    theParticleChange->SetStatusChange( isAlive );
    theParticleChange->SetEnergyChange( thePrimary.GetKineticEnergy() );
    theParticleChange->SetMomentumChange( thePrimary.Get4Momentum().vect().unit() );
    return theParticleChange;
  }
 
  // Temporarily dummy treatment of light hypernuclei projectiles at low energies.
  // Bertini and Binary intra-nuclear cascade models are currently not applicable
  // for hypernuclei and string models cannot handle them properly at low energies -
  // let's say safely below ~100 MeV.
  // In these cases, we return as final state the initial state unchanged.
  // For most applications, this is a safe simplification, giving that the nearly all
  // slowly moving hypernuclei decay before any hadronic interaction can occur.
  // Note that we prefer not to use G4HadronicParameters::GetMinEnergyTransitionFTF_Cascade()
  // (typically ~3 GeV) because FTFP works reasonably well below such a value.
  // Note that for anti-hypernuclei, FTF model works fine down to zero kinetic energy,
  // so there is no need of any extra, dummy treatment.
  const G4double energyThresholdForHyperNuclei = 100.0*CLHEP::MeV;
  if ( thePrimary.GetKineticEnergy() < energyThresholdForHyperNuclei  &&
       thePrimary.GetDefinition()->IsHypernucleus() ) {
    theParticleChange->SetStatusChange( isAlive );
    theParticleChange->SetEnergyChange( thePrimary.GetKineticEnergy() );
    theParticleChange->SetMomentumChange( thePrimary.Get4Momentum().vect().unit() );
    return theParticleChange;
  }
 
  // check if models have been registered, and use default, in case this is not true @@
  
  const G4DynamicParticle aPart( thePrimary.GetDefinition(), thePrimary.Get4Momentum().vect() );
 
  if ( theQuasielastic ) 
  {
    if ( theQuasielastic->GetFraction( theNucleus, aPart ) > G4UniformRand() )
    {
      //G4cout<<"___G4TheoFSGenerator: before Scatter (1) QE=" << theQuasielastic<<G4endl;
      G4KineticTrackVector* result= theQuasielastic->Scatter( theNucleus, aPart );
      //G4cout << "^^G4TheoFSGenerator: after Scatter (1) " << G4endl;
      if ( result )
      {
        for ( auto & ptr : *result )
    {
      G4DynamicParticle* aNew = new G4DynamicParticle( ptr->GetDefinition(),
                                                       ptr->Get4Momentum().e(),
                                                       ptr->Get4Momentum().vect() );
      theParticleChange->AddSecondary( aNew, ptr->GetCreatorModelID() );
      delete ptr;
    }
    delete result;     
      } 
      else 
      {
        theParticleChange->SetStatusChange( isAlive );
    theParticleChange->SetEnergyChange( thePrimary.GetKineticEnergy() );
    theParticleChange->SetMomentumChange( thePrimary.Get4Momentum().vect().unit() );
      }
      return theParticleChange;
    }
  }
 
  // get result from high energy model
  G4KineticTrackVector* theInitialResult = theHighEnergyGenerator->Scatter( theNucleus, aPart );
 
  // Assign the creator model ID.
  // Only for the FTF string model, an inelastic interaction can be classified as quasi-elastic
  // or diffractive. For the QGS model, the two boolean methods below return always "false".
  G4int theModelID = theStringModelID;
  if ( theHighEnergyGenerator->IsQuasiElasticInteraction() ) {
    theModelID = theFTFQuasiElasticID;
  } else if ( theHighEnergyGenerator->IsDiffractiveInteraction() ) {
    theModelID = theFTFDiffractiveID;
  }
  for ( auto & ptr : *theInitialResult ) {
    ptr->SetCreatorModelID( theModelID );
  }
 
  //#define DEBUG_initial_result
  #ifdef DEBUG_initial_result
      G4double E_out( 0 );
      G4IonTable* ionTable = G4ParticleTable::GetParticleTable()->GetIonTable();
      for ( auto & ptr : *theInitialResult )
      {
         //G4cout << "TheoFS secondary, mom " << ptr->GetDefinition()->GetParticleName() 
             //         << " " << ptr->Get4Momentum() << G4endl;
         E_out += ptr->Get4Momentum().e();
      }
      G4double init_mass = ionTable->GetIonMass( theNucleus.GetZ_asInt(), theNucleus.GetA_asInt() );
          G4double init_E = aPart.Get4Momentum().e();
      // residual nucleus
 
      const std::vector< G4Nucleon >& thy = theHighEnergyGenerator->GetWoundedNucleus()->GetNucleons();
 
      G4int resZ( 0 ), resA( 0 );
      G4double delta_m( 0.0 );
      for ( auto & nuc : thy )
      {
        if ( nuc.AreYouHit() ) {
          ++resA;
          if ( nuc.GetDefinition() == G4Proton::Proton() ) {
            ++resZ;
        delta_m += CLHEP::proton_mass_c2;
          } else {
        delta_m += CLHEP::neutron_mass_c2;
          }  
        }
      }
 
      G4double final_mass( 0.0 );
      if ( theNucleus.GetA_asInt() ) {
        final_mass = ionTable->GetIonMass( theNucleus.GetZ_asInt() - resZ,theNucleus.GetA_asInt() - resA );
      }
      G4double E_excit = init_mass + init_E - final_mass - E_out;
      G4cout << " Corrected delta mass " << init_mass - final_mass - delta_m << G4endl;
      G4cout << "initial E, mass = " << init_E << ", " << init_mass << G4endl;
      G4cout << "  final E, mass = " << E_out <<", " << final_mass << "  excitation_E " << E_excit << G4endl;
  #endif
 
  G4ReactionProductVector* theTransportResult = nullptr;
 
  G4V3DNucleus* theProjectileNucleus = theHighEnergyGenerator->GetProjectileNucleus(); 
  if ( theProjectileNucleus == nullptr )
  {
    G4int hitCount = 0;
    const std::vector< G4Nucleon >& they = theHighEnergyGenerator->GetWoundedNucleus()->GetNucleons();
    for ( auto & nuc : they )
    {
      if ( nuc.AreYouHit() ) ++hitCount;
    }
    if ( hitCount != theHighEnergyGenerator->GetWoundedNucleus()->GetMassNumber() )
    {
      theTransport->SetPrimaryProjectile( thePrimary );
      theTransportResult = theTransport->Propagate( theInitialResult,
                                theHighEnergyGenerator->GetWoundedNucleus() );
      if ( theTransportResult == nullptr ) {
        G4cout << "G4TheoFSGenerator: null ptr from transport propagate " << G4endl;
        throw G4HadronicException( __FILE__, __LINE__, "Null ptr from transport propagate" );
      }
    }
    else
    {
      theTransportResult = theDecay.Propagate( theInitialResult, 
                                 theHighEnergyGenerator->GetWoundedNucleus() );
      if ( theTransportResult == nullptr ) {
         G4cout << "G4TheoFSGenerator: null ptr from decay propagate " << G4endl;
         throw G4HadronicException( __FILE__, __LINE__, "Null ptr from decay propagate" );
      }
    }
  }
  else 
  {
    theTransport->SetPrimaryProjectile( thePrimary );
    theTransportResult = theTransport->PropagateNuclNucl( theInitialResult, 
                            theHighEnergyGenerator->GetWoundedNucleus(),
                            theProjectileNucleus );
    if ( theTransportResult == nullptr ) {
       G4cout << "G4TheoFSGenerator: null ptr from transport propagate " << G4endl;
       throw G4HadronicException( __FILE__, __LINE__, "Null ptr from transport propagate" );
    }
  }
 
  // If enabled, apply the Cosmic Rays (CR) coalescence to the list of secondaries produced so far.
  // This algorithm can form deuterons and antideuterons by coalescence of, respectively,
  // proton-neutron and antiproton-antineutron pairs close in momentum space.
  // This can be useful in particular for Cosmic Ray applications.
  if ( G4HadronicParameters::Instance()->EnableCRCoalescence() ) {
    if ( theCosmicCoalescence == nullptr ) {
      theCosmicCoalescence = (G4CRCoalescence*)
        G4HadronicInteractionRegistry::Instance()->FindModel( "G4CRCoalescence" );
      if ( theCosmicCoalescence == nullptr ) {
        theCosmicCoalescence = new G4CRCoalescence;
      }
    }
    theCosmicCoalescence->SetP0Coalescence( thePrimary, theHighEnergyGenerator->GetModelName() );
    theCosmicCoalescence->GenerateDeuterons( theTransportResult );
  }
    
  // Fill particle change
  for ( auto & ptr : *theTransportResult )
  {
    G4DynamicParticle* aNewDP = new G4DynamicParticle( ptr->GetDefinition(),
                                                       ptr->GetTotalEnergy(),
                                                       ptr->GetMomentum() );
    G4HadSecondary aNew = G4HadSecondary( aNewDP );
    G4double time = std::max( ptr->GetFormationTime(), 0.0 );
    aNew.SetTime( timePrimary + time );
    aNew.SetCreatorModelID( ptr->GetCreatorModelID() );
    aNew.SetParentResonanceDef( ptr->GetParentResonanceDef() );
    aNew.SetParentResonanceID( ptr->GetParentResonanceID() );
    theParticleChange->AddSecondary( aNew );
    delete ptr;
  }
  
  // some garbage collection
  delete theTransportResult;
  
  // Done
  return theParticleChange;
}
 
 
std::pair<G4double, G4double> G4TheoFSGenerator::GetEnergyMomentumCheckLevels() const
{
  if ( theHighEnergyGenerator ) {
    return theHighEnergyGenerator->GetEnergyMomentumCheckLevels();
  } else {
    return std::pair<G4double, G4double>( DBL_MAX, DBL_MAX );
  }
}