#include <G4IntraNucleiCascader.hh>

Inheritance diagram for G4IntraNucleiCascader:

Public Member Functions
void	collide (G4InuclParticle bullet, G4InuclParticle target, G4CollisionOutput &globalOutput)

	G4IntraNucleiCascader ()

void	rescatter (G4InuclParticle bullet, G4KineticTrackVector theSecondaries, G4V3DNucleus *theNucleus, G4CollisionOutput &globalOutput)

void	setVerboseLevel (G4int verbose=0)

virtual	~G4IntraNucleiCascader ()

Protected Member Functions
void	copySecondaries (G4KineticTrackVector *theSecondaries)

void	copyWoundedNucleus (G4V3DNucleus *theNucleus)

G4InuclParticle *	createTarget (G4V3DNucleus *theNucleus)

void	decayTrappedParticle (const G4CascadParticle &trapped)

void	finalize (G4int itry, G4InuclParticle bullet, G4InuclParticle target, G4CollisionOutput &globalOutput)

G4bool	finishCascade ()

void	generateCascade ()

virtual G4bool	inelasticInteractionPossible (G4InuclParticle bullet, G4InuclParticle target, G4double ekin) const

G4bool	initialize (G4InuclParticle bullet, G4InuclParticle target)

void	newCascade (G4int itry)

G4bool	particleCanInteract (const G4CascadParticle &cpart) const

void	preloadCascade (G4V3DNucleus theNucleus, G4KineticTrackVector theSecondaries)

void	processSecondary (const G4KineticTrack *aSecondary)

void	processTrappedParticle (const G4CascadParticle &trapped)

void	releaseSecondary (const G4KineticTrack *aSecondary)

virtual void	setName (const G4String &name)

void	setupCascade ()

virtual G4bool	useEPCollider (G4InuclParticle bullet, G4InuclParticle target) const

virtual G4bool	validateOutput (const G4Fragment &fragment, G4CollisionOutput &output)

virtual G4bool	validateOutput (G4InuclParticle bullet, G4InuclParticle target, const std::vector< G4InuclElementaryParticle > &particles)

virtual G4bool	validateOutput (G4InuclParticle bullet, G4InuclParticle target, G4CollisionOutput &output)

Protected Attributes
G4CascadeCheckBalance *	balance

G4InteractionCase	interCase

G4String	theName

G4int	verboseLevel

Private Member Functions
	G4IntraNucleiCascader (const G4IntraNucleiCascader &)

G4IntraNucleiCascader &	operator= (const G4IntraNucleiCascader &)

Private Attributes
G4InuclNuclei *	bnuclei

G4InuclElementaryParticle *	bparticle

std::vector< G4CascadParticle >	cascad_particles

G4double	coulombBarrier

std::vector< G4ThreeVector >	hitNucleons

G4double	minimum_recoil_A

G4NucleiModel *	model

std::vector< G4CascadParticle >	new_cascad_particles

G4InuclNuclei *	nucleusTarget

G4CollisionOutput	output

G4InuclElementaryParticle *	protonTarget

G4CascadeHistory *	theCascadeHistory

G4CascadeCoalescence *	theClusterMaker

G4ElementaryParticleCollider *	theElementaryParticleCollider

G4ExitonConfiguration	theExitonConfiguration

G4CascadeRecoilMaker *	theRecoilMaker

G4InuclNuclei *	tnuclei

Static Private Attributes
static const G4int	itry_max = 100

static const G4double	quasielast_cut = 1*MeV

static const G4int	reflection_cut = 50

static const G4double	small_ekin = 0.001*MeV

Detailed Description

Definition at line 88 of file G4IntraNucleiCascader.hh.

Constructor & Destructor Documentation

◆ G4IntraNucleiCascader() [1/2]

G4IntraNucleiCascader::G4IntraNucleiCascader ( )

Definition at line 166 of file G4IntraNucleiCascader.cc.

  : G4CascadeColliderBase("G4IntraNucleiCascader"), model(new G4NucleiModel),
    theElementaryParticleCollider(new G4ElementaryParticleCollider),
    theRecoilMaker(new G4CascadeRecoilMaker), theClusterMaker(0),
    theCascadeHistory(0), tnuclei(0), bnuclei(0), bparticle(0),
    minimum_recoil_A(0.), coulombBarrier(0.),
    nucleusTarget(new G4InuclNuclei),
    protonTarget(new G4InuclElementaryParticle) {
  if (G4CascadeParameters::doCoalescence())
    theClusterMaker = new G4CascadeCoalescence;
 
  if (G4CascadeParameters::showHistory())
    theCascadeHistory = new G4CascadeHistory;
}

References G4CascadeParameters::doCoalescence(), G4CascadeParameters::showHistory(), theCascadeHistory, and theClusterMaker.

◆ ~G4IntraNucleiCascader()

G4IntraNucleiCascader::~G4IntraNucleiCascader ( )

virtual

Definition at line 181 of file G4IntraNucleiCascader.cc.

                                              {
  delete model;
  delete theElementaryParticleCollider;
  delete theRecoilMaker;
  delete theClusterMaker;
  delete theCascadeHistory;
  delete nucleusTarget;
  delete protonTarget;
}

References model, nucleusTarget, protonTarget, theCascadeHistory, theClusterMaker, theElementaryParticleCollider, and theRecoilMaker.

◆ G4IntraNucleiCascader() [2/2]

G4IntraNucleiCascader::G4IntraNucleiCascader ( const G4IntraNucleiCascader & )

private

Member Function Documentation

◆ collide()

void G4IntraNucleiCascader::collide	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target,
		G4CollisionOutput &	globalOutput
	)

virtual

Implements G4VCascadeCollider.

Definition at line 204 of file G4IntraNucleiCascader.cc.

                                                     {
  if (verboseLevel) G4cout << " >>> G4IntraNucleiCascader::collide " << G4endl;
 
  if (!initialize(bullet, target)) return;  // Load buffers and drivers
 
  G4int itry = 0;
  do {              /* Loop checking 08.06.2015 MHK */
    newCascade(++itry);
    setupCascade();
    generateCascade();
  } while (!finishCascade() && itry<itry_max);
 
  // Report full structure of final cascade if requested
  if (theCascadeHistory) theCascadeHistory->Print(G4cout);
 
  finalize(itry, bullet, target, globalOutput);
}

References finalize(), finishCascade(), G4cout, G4endl, generateCascade(), initialize(), itry_max, newCascade(), G4CascadeHistory::Print(), setupCascade(), theCascadeHistory, and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclCollider::collide().

◆ copySecondaries()

void G4IntraNucleiCascader::copySecondaries ( G4KineticTrackVector * theSecondaries )

protected

Definition at line 738 of file G4IntraNucleiCascader.cc.

                                                                        {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::copySecondaries" << G4endl;
 
  for (size_t i=0; i<secondaries->size(); i++) {
    if (verboseLevel > 3) G4cout << " processing secondary " << i << G4endl;
 
    processSecondary((*secondaries)[i]);        // Copy to cascade or to output
  }
 
  // Sort list of secondaries to put leading particle first
  std::sort(cascad_particles.begin(), cascad_particles.end(),
        G4ParticleLargerEkin());
 
  if (verboseLevel > 2) {
    G4cout << " Original list of " << secondaries->size() << " secondaries"
       << " produced " << cascad_particles.size() << " cascade, "
       << output.numberOfOutgoingParticles() << " released particles, "
       << output.numberOfOutgoingNuclei() << " fragments" << G4endl;
  }
}

References cascad_particles, G4cout, G4endl, G4CollisionOutput::numberOfOutgoingNuclei(), G4CollisionOutput::numberOfOutgoingParticles(), output, processSecondary(), and G4VCascadeCollider::verboseLevel.

Referenced by preloadCascade().

◆ copyWoundedNucleus()

void G4IntraNucleiCascader::copyWoundedNucleus ( G4V3DNucleus * theNucleus )

protected

Definition at line 707 of file G4IntraNucleiCascader.cc.

                                                                       {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::copyWoundedNucleus" << G4endl;
 
  // Loop over nucleons and count hits as exciton holes
  theExitonConfiguration.clear();
  hitNucleons.clear();
  if (theNucleus->StartLoop()) {
    G4Nucleon* nucl = 0;
    G4int nuclType = 0;
    /* Loop checking 08.06.2015 MHK */
    while ((nucl = theNucleus->GetNextNucleon())) {
      if (nucl->AreYouHit()) {  // Found previously interacted nucleon
    nuclType = G4InuclElementaryParticle::type(nucl->GetParticleType());
    theExitonConfiguration.incrementHoles(nuclType);
    hitNucleons.push_back(nucl->GetPosition());
      }
    }
  }
 
  if (verboseLevel > 3)
    G4cout << " nucleus has " << theExitonConfiguration.neutronHoles
       << " neutrons hit, " << theExitonConfiguration.protonHoles
       << " protons hit" << G4endl;
 
  // Preload nuclear model with confirmed hits, including locations
  model->reset(theExitonConfiguration.neutronHoles,
           theExitonConfiguration.protonHoles, &hitNucleons);
}

References G4Nucleon::AreYouHit(), G4ExitonConfiguration::clear(), G4cout, G4endl, G4V3DNucleus::GetNextNucleon(), G4Nucleon::GetParticleType(), G4Nucleon::GetPosition(), hitNucleons, G4ExitonConfiguration::incrementHoles(), model, G4ExitonConfiguration::neutronHoles, G4ExitonConfiguration::protonHoles, G4NucleiModel::reset(), G4V3DNucleus::StartLoop(), theExitonConfiguration, G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by preloadCascade().

◆ createTarget()

G4InuclParticle * G4IntraNucleiCascader::createTarget ( G4V3DNucleus * theNucleus )

protected

Definition at line 678 of file G4IntraNucleiCascader.cc.

                                                            {
  G4int theNucleusA = theNucleus->GetMassNumber();
  G4int theNucleusZ = theNucleus->GetCharge();
  
  if (theNucleusA > 1) {
    if (!nucleusTarget) nucleusTarget = new G4InuclNuclei;  // Just in case
    nucleusTarget->fill(0., theNucleusA, theNucleusZ, 0.);
    return nucleusTarget;
  } else {
    if (!protonTarget) protonTarget = new G4InuclElementaryParticle;
    protonTarget->fill(0., (theNucleusZ==1)?proton:neutron);
    return protonTarget;
  }
 
  return 0;     // Can never actually get here
}

References G4InuclNuclei::fill(), G4InuclElementaryParticle::fill(), G4V3DNucleus::GetCharge(), G4V3DNucleus::GetMassNumber(), G4InuclParticleNames::neutron, nucleusTarget, G4InuclParticleNames::proton, and protonTarget.

Referenced by rescatter().

◆ decayTrappedParticle()

void G4IntraNucleiCascader::decayTrappedParticle ( const G4CascadParticle & trapped )

protected

Definition at line 869 of file G4IntraNucleiCascader.cc.

                                                      {
  if (verboseLevel > 3) 
    G4cout << " unstable must be decayed in flight" << G4endl;
 
  const G4InuclElementaryParticle& trappedP = trapped.getParticle();
 
  G4DecayTable* unstable = trappedP.getDefinition()->GetDecayTable();
  if (!unstable) {          // No decay table; cannot decay!
    if (verboseLevel > 3)
      G4cerr << " no decay table!  Releasing trapped particle" << G4endl;
 
    output.addOutgoingParticle(trappedP);
    return;
  }
 
  // Get secondaries from decay in particle's rest frame
  G4DecayProducts* daughters = unstable->SelectADecayChannel()->DecayIt( trappedP.getDefinition()->GetPDGMass() );
  if (!daughters) {         // No final state; cannot decay!
    if (verboseLevel > 3)
      G4cerr << " no daughters!  Releasing trapped particle" << G4endl;
 
    output.addOutgoingParticle(trappedP);
    return;
  }
 
  if (verboseLevel > 3)
    G4cout << " " << daughters->entries() << " decay daughters" << G4endl;
 
  // Convert secondaries to lab frame
  G4double decayEnergy = trappedP.getEnergy();
  G4ThreeVector decayDir = trappedP.getMomentum().vect().unit();
  daughters->Boost(decayEnergy, decayDir);
 
  // Put all the secondaries onto the list for propagation
  const G4ThreeVector& decayPos = trapped.getPosition();
  G4int zone = trapped.getCurrentZone();
  G4int gen = trapped.getGeneration()+1;
 
  for (G4int i=0; i<daughters->entries(); i++) {
    G4DynamicParticle* idaug = (*daughters)[i];
 
    G4InuclElementaryParticle idaugEP(*idaug, G4InuclParticle::INCascader);
 
    // Propagate hadronic secondaries with known interactions (tables)
    if (G4CascadeChannelTables::GetTable(idaugEP.type())) {
      if (verboseLevel > 3) G4cout << " propagating " << idaugEP << G4endl;
      cascad_particles.push_back(G4CascadParticle(idaugEP,decayPos,zone,0.,gen));
    } else {
      if (verboseLevel > 3) G4cout << " releasing " << idaugEP << G4endl;
      output.addOutgoingParticle(idaugEP);
    }
  }
 
  delete daughters;     // Clean up memory created by DecayIt()
}

References G4CollisionOutput::addOutgoingParticle(), G4DecayProducts::Boost(), cascad_particles, G4VDecayChannel::DecayIt(), G4DecayProducts::entries(), G4cerr, G4cout, G4endl, G4CascadParticle::getCurrentZone(), G4ParticleDefinition::GetDecayTable(), G4InuclParticle::getDefinition(), G4InuclParticle::getEnergy(), G4CascadParticle::getGeneration(), G4InuclParticle::getMomentum(), G4CascadParticle::getParticle(), G4ParticleDefinition::GetPDGMass(), G4CascadParticle::getPosition(), G4CascadeChannelTables::GetTable(), G4InuclParticle::INCascader, output, G4DecayTable::SelectADecayChannel(), G4InuclElementaryParticle::type(), CLHEP::Hep3Vector::unit(), CLHEP::HepLorentzVector::vect(), and G4VCascadeCollider::verboseLevel.

Referenced by processTrappedParticle().

◆ finalize()

void G4IntraNucleiCascader::finalize	(	G4int	itry,
		G4InuclParticle *	bullet,
		G4InuclParticle *	target,
		G4CollisionOutput &	globalOutput
	)

protected

Definition at line 656 of file G4IntraNucleiCascader.cc.

                                                 {
  if (itry >= itry_max) {
    if (verboseLevel) {
      G4cout << " IntraNucleiCascader-> no inelastic interaction after "
         << itry << " attempts " << G4endl;
    }
 
    output.trivialise(bullet, target);
  } else if (verboseLevel) {
    G4cout << " IntraNucleiCascader output after trials " << itry << G4endl;
  }
  
  // Copy final generated cascade to output buffer for return
  globalOutput.add(output);
}

References G4CollisionOutput::add(), G4cout, G4endl, itry_max, output, G4CollisionOutput::trivialise(), and G4VCascadeCollider::verboseLevel.

Referenced by collide(), and rescatter().

◆ finishCascade()

G4bool G4IntraNucleiCascader::finishCascade ( )

protected

Definition at line 507 of file G4IntraNucleiCascader.cc.

                                            {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::finishCascade ?" << G4endl;
 
  // Add left-over cascade particles to output
  output.addOutgoingParticles(cascad_particles);
  cascad_particles.clear();
 
  // Cascade is finished. Check if it's OK.
  if (verboseLevel>3) {
    G4cout << " G4IntraNucleiCascader finished" << G4endl;
    output.printCollisionOutput();
  }
 
  // Apply cluster coalesence model to produce light ions
  if (theClusterMaker) {
    theClusterMaker->setVerboseLevel(verboseLevel);
    theClusterMaker->FindClusters(output);
 
    // Update recoil fragment after generating light ions
    if (verboseLevel>3) G4cout << " Recomputing recoil fragment" << G4endl;
    theRecoilMaker->collide(interCase.getBullet(), interCase.getTarget(),
                output);
    if (verboseLevel>3) {
      G4cout << " After cluster coalescence" << G4endl;
      output.printCollisionOutput();
    }
  }
 
  // Use last created recoil fragment instead of re-constructing
  G4int afin = theRecoilMaker->getRecoilA();
  G4int zfin = theRecoilMaker->getRecoilZ();
 
  // FIXME:  Should we deal with unbalanced (0,0) case before rejecting?
 
  // Sanity check before proceeding
  if (!theRecoilMaker->goodFragment() && !theRecoilMaker->wholeEvent()) {
    if (verboseLevel > 1)
      G4cerr << " Recoil nucleus is not physical: A=" << afin << " Z="
         << zfin << G4endl;
    return false;               // Discard event and try again
  }
  
  const G4LorentzVector& presid = theRecoilMaker->getRecoilMomentum();
  
  if (verboseLevel > 1) {
    G4cout << "  afin " << afin << " zfin " << zfin <<  G4endl;
  }
  
  if (afin == 0) return true;       // Whole event fragmented, exit
  
  if (afin == 1) {          // Add bare nucleon to particle list
    G4int last_type = (zfin==1) ? 1 : 2;    // proton=1, neutron=2
    
    G4double mass = G4InuclElementaryParticle::getParticleMass(last_type);
    G4double mres = presid.m();
    
    // Check for sensible kinematics
    if (mres-mass < -small_ekin) {      // Insufficient recoil energy
      if (verboseLevel > 2) G4cerr << " unphysical recoil nucleon" << G4endl;
      return false;
    }
    
    if (mres-mass > small_ekin) {       // Too much extra energy
      if (verboseLevel > 2)
    G4cerr << " extra energy with recoil nucleon" << G4endl;
      
      // FIXME:  For now, we add the nucleon as unbalanced, and let
      //       "SetOnShell" fudge things.  This should be abandoned.
    }
    
    G4InuclElementaryParticle last_particle(presid, last_type, 
                        G4InuclParticle::INCascader);
    
    if (verboseLevel > 3) {
      G4cout << " adding recoiling nucleon to output list\n"
         << last_particle  << G4endl;
    }
    
    output.addOutgoingParticle(last_particle);
 
    // Update recoil to include residual nucleon
    theRecoilMaker->collide(interCase.getBullet(), interCase.getTarget(),
                output);
  }
  
  // Process recoil fragment for consistency, exit or reject
  if (output.numberOfOutgoingParticles() == 1) {
    G4double Eex = theRecoilMaker->getRecoilExcitation();
    if (std::abs(Eex) < quasielast_cut) {
      if (verboseLevel > 3) {
    G4cout << " quasi-elastic scatter with " << Eex << " MeV recoil"
           << G4endl;
      }
      
      theRecoilMaker->setRecoilExcitation(Eex=0.);
      if (verboseLevel > 3) {
    G4cout << " Eex reset to " << theRecoilMaker->getRecoilExcitation()
           << G4endl;
      }
    }
  }
  
  if (theRecoilMaker->goodNucleus()) {
    theRecoilMaker->addExcitonConfiguration(theExitonConfiguration);
    
    G4Fragment* recoilFrag = theRecoilMaker->makeRecoilFragment();
    if (!recoilFrag) {
      G4cerr << "Got null pointer for recoil fragment!" << G4endl;
      return false;
    }
    
    if (verboseLevel > 2)
      G4cout << " adding recoil fragment to output list" << G4endl;
 
    output.addRecoilFragment(*recoilFrag);
  }
  
  // Put final-state particles in "leading order" for return
  std::vector<G4InuclElementaryParticle>& opart = output.getOutgoingParticles();
  std::sort(opart.begin(), opart.end(), G4ParticleLargerEkin());
  
  // Adjust final state to balance momentum and energy if necessary
  if (theRecoilMaker->wholeEvent() || theRecoilMaker->goodNucleus()) {
    output.setVerboseLevel(verboseLevel);
    output.setOnShell(interCase.getBullet(), interCase.getTarget());
    output.setVerboseLevel(0);
    
    if (output.acceptable()) return true;
    else if (verboseLevel>2) G4cerr << " Cascade setOnShell failed." << G4endl;
  }
 
  // Cascade not physically reasonable
  if (afin <= minimum_recoil_A && minimum_recoil_A < tnuclei->getA()) {
    ++minimum_recoil_A;
    if (verboseLevel > 3) {
      G4cout << " minimum recoil fragment increased to A " << minimum_recoil_A
         << G4endl;
    }
  }
 
  if (verboseLevel>2) G4cerr << " Cascade failed.  Retrying..." << G4endl;
  return false;
}

References G4CollisionOutput::acceptable(), G4CascadeRecoilMaker::addExcitonConfiguration(), G4CollisionOutput::addOutgoingParticle(), G4CollisionOutput::addOutgoingParticles(), G4CollisionOutput::addRecoilFragment(), cascad_particles, G4CascadeRecoilMaker::collide(), G4CascadeCoalescence::FindClusters(), G4cerr, G4cout, G4endl, G4InteractionCase::getBullet(), G4CollisionOutput::getOutgoingParticles(), G4InuclElementaryParticle::getParticleMass(), G4CascadeRecoilMaker::getRecoilA(), G4CascadeRecoilMaker::getRecoilExcitation(), G4CascadeRecoilMaker::getRecoilMomentum(), G4CascadeRecoilMaker::getRecoilZ(), G4InteractionCase::getTarget(), G4CascadeRecoilMaker::goodFragment(), G4CascadeRecoilMaker::goodNucleus(), G4InuclParticle::INCascader, G4CascadeColliderBase::interCase, CLHEP::HepLorentzVector::m(), G4CascadeRecoilMaker::makeRecoilFragment(), minimum_recoil_A, G4CollisionOutput::numberOfOutgoingParticles(), output, G4CollisionOutput::printCollisionOutput(), quasielast_cut, G4CollisionOutput::setOnShell(), G4CascadeRecoilMaker::setRecoilExcitation(), G4CascadeCoalescence::setVerboseLevel(), G4CollisionOutput::setVerboseLevel(), small_ekin, theClusterMaker, theExitonConfiguration, theRecoilMaker, G4VCascadeCollider::verboseLevel, and G4CascadeRecoilMaker::wholeEvent().

Referenced by collide(), and rescatter().

◆ generateCascade()

void G4IntraNucleiCascader::generateCascade ( )

protected

Definition at line 361 of file G4IntraNucleiCascader.cc.

                                            {
  if (verboseLevel>1) G4cout << " generateCascade " << G4endl;
 
  /* Loop checking 08.06.2015 MHK */
  G4int iloop = 0;
  while (!cascad_particles.empty() && !model->empty()) {
    iloop++;
    
    if (verboseLevel > 2) {
      G4cout << " Iteration " << iloop << ": Number of cparticles "
         << cascad_particles.size() << " last one: \n"
         << cascad_particles.back() << G4endl;
    }
 
    // Record incident particle first, to get history ID
    if (theCascadeHistory) {
      theCascadeHistory->AddEntry(cascad_particles.back());
      if (verboseLevel > 2) {
    G4cout << " active cparticle got history ID "
           << cascad_particles.back().getHistoryId() << G4endl;
      }
    }
 
    // If non-interacting particle, move directly to output
    if (!particleCanInteract(cascad_particles.back())) {
      if (verboseLevel > 2)
    G4cout << " particle is non-interacting; moving to output" << G4endl;
 
      output.addOutgoingParticle(cascad_particles.back().getParticle());
      cascad_particles.pop_back();
      continue;
    }
 
    // Generate interaction with nucleon
    model->generateParticleFate(cascad_particles.back(),
                theElementaryParticleCollider,
                new_cascad_particles);
 
    // Record interaction for later reporting (if desired)
    if (theCascadeHistory && new_cascad_particles.size()>1) 
      theCascadeHistory->AddVertex(cascad_particles.back(), new_cascad_particles);
 
    if (verboseLevel > 2) {
      G4cout << " After generate fate: New particles "
         << new_cascad_particles.size() << G4endl
         << " Discarding last cparticle from list " << G4endl;
    }
    
    cascad_particles.pop_back();
    
    // handle the result of a new step
    
    if (new_cascad_particles.size() == 1) { // last particle goes without interaction
      const G4CascadParticle& currentCParticle = new_cascad_particles[0];
      
      if (model->stillInside(currentCParticle)) {
    if (verboseLevel > 3)
      G4cout << " particle still inside nucleus " << G4endl;
    
    if (currentCParticle.getNumberOfReflections() < reflection_cut &&
        model->worthToPropagate(currentCParticle)) {
      if (verboseLevel > 3) G4cout << " continue reflections " << G4endl;
      cascad_particles.push_back(currentCParticle);
    } else {
      processTrappedParticle(currentCParticle);
    }   // reflection or exciton
    
      } else { // particle about to leave nucleus - check for Coulomb barrier
    if (verboseLevel > 3) G4cout << " possible escape " << G4endl;
    
    const G4InuclElementaryParticle& currentParticle =
      currentCParticle.getParticle();
    
    G4double KE = currentParticle.getKineticEnergy();
    G4double mass = currentParticle.getMass();
    G4double Q = currentParticle.getCharge();
    
    if (verboseLevel > 3)
      G4cout << " KE " << KE << " barrier " << Q*coulombBarrier << G4endl;
    
    if (KE < Q*coulombBarrier) {
      // Calculate barrier penetration
      G4double CBP = 0.0; 
      
      // if (KE > 0.0001) CBP = std::exp(-0.00126*tnuclei->getZ()*0.25*
      //   (1./KE - 1./coulombBarrier));
      if (KE > 0.0001) CBP = G4Exp(-0.0181*0.5*tnuclei->getZ()*
                       (1./KE - 1./coulombBarrier)*
                       std::sqrt(mass*(coulombBarrier-KE)) );
      
      if (G4UniformRand() < CBP) {
        if (verboseLevel > 3) 
          G4cout << " tunneled\n" << currentParticle << G4endl;
 
        // Tunnelling through barrier leaves KE unchanged
        output.addOutgoingParticle(currentParticle);
      } else {
        processTrappedParticle(currentCParticle);
      }
    } else {
      output.addOutgoingParticle(currentParticle);
      
      if (verboseLevel > 3)
        G4cout << " Goes out\n" << output.getOutgoingParticles().back()
           << G4endl;
    }
      } 
    } else { // interaction 
      if (verboseLevel > 3)
    G4cout << " interacted, adding new to list " << G4endl;
      
      cascad_particles.insert(cascad_particles.end(),
                  new_cascad_particles.begin(),
                  new_cascad_particles.end());
      
      std::pair<G4int, G4int> holes = model->getTypesOfNucleonsInvolved();
      if (verboseLevel > 3)
    G4cout << " adding new exciton holes " << holes.first << ","
           << holes.second << G4endl;
      
      theExitonConfiguration.incrementHoles(holes.first);
      
      if (holes.second > 0)
    theExitonConfiguration.incrementHoles(holes.second);
    }       // if (new_cascad_particles ...
    
    // Evaluate nuclear residue
    theRecoilMaker->collide(interCase.getBullet(), interCase.getTarget(),
                output, cascad_particles);
    
    G4double aresid = theRecoilMaker->getRecoilA();
    if (verboseLevel > 2) {
      G4cout << " cparticles remaining " << cascad_particles.size()
         << " nucleus (model) has "
         << model->getNumberOfNeutrons() << " n, "
         << model->getNumberOfProtons() << " p "
         << " residual fragment A " << aresid << G4endl;
    }
    
    if (aresid <= minimum_recoil_A) return; // Must have minimum fragment
  } // while cascade-list and model
}

References G4CascadeHistory::AddEntry(), G4CollisionOutput::addOutgoingParticle(), G4CascadeHistory::AddVertex(), cascad_particles, G4CascadeRecoilMaker::collide(), coulombBarrier, G4NucleiModel::empty(), G4cout, G4endl, G4Exp(), G4UniformRand, G4NucleiModel::generateParticleFate(), G4InteractionCase::getBullet(), G4InuclParticle::getCharge(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMass(), G4NucleiModel::getNumberOfNeutrons(), G4NucleiModel::getNumberOfProtons(), G4CascadParticle::getNumberOfReflections(), G4CollisionOutput::getOutgoingParticles(), G4CascadParticle::getParticle(), G4CascadeRecoilMaker::getRecoilA(), G4InteractionCase::getTarget(), G4NucleiModel::getTypesOfNucleonsInvolved(), G4InuclNuclei::getZ(), G4ExitonConfiguration::incrementHoles(), G4CascadeColliderBase::interCase, minimum_recoil_A, model, new_cascad_particles, output, particleCanInteract(), processTrappedParticle(), Q, reflection_cut, G4NucleiModel::stillInside(), theCascadeHistory, theElementaryParticleCollider, theExitonConfiguration, theRecoilMaker, tnuclei, G4VCascadeCollider::verboseLevel, and G4NucleiModel::worthToPropagate().

Referenced by collide(), and rescatter().

◆ inelasticInteractionPossible()

G4bool G4CascadeColliderBase::inelasticInteractionPossible	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target,
		G4double	ekin
	)		const

protectedvirtualinherited

Definition at line 85 of file G4CascadeColliderBase.cc.

                                                 {
  if (verboseLevel) {
    G4cout << " >>> " << theName << "::inelasticInteractionPossible" << G4endl;
  }
 
  // If hadron-hadron collision, defer to ElementaryParticleCollider
  if (useEPCollider(bullet, target)) return true;
 
  // See which one of the two (or both) is a nucleus, get properties
  // FIXME:  Should set a = baryon() for both, but that's not in base
  G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
  G4double ab = nuclei_bullet ? nuclei_bullet->getA() : 1;  // FIXME
  G4double zb = nuclei_bullet ? nuclei_bullet->getZ() : bullet->getCharge();
  
  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
  G4double at = nuclei_target ? nuclei_target->getA() : 1;  // FIXME
  G4double zt = nuclei_target ? nuclei_target->getZ() : target->getCharge();
  
  // VCOL (Coulomb barrier) used for testing if elastic collision necessary
  const G4double coeff = 0.001 * 1.2;
 
  G4double VCOL = coeff * zt * zb / (G4cbrt(at) + G4cbrt(ab)); 
  
  G4bool possible = true;   // Force inelastic; should be (ekin >= VCOL)
 
  if (verboseLevel > 3) {
    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: "
       << possible << G4endl;
  }
 
  return possible;
}

References ab, G4InuclSpecialFunctions::G4cbrt(), G4cout, G4endl, G4InuclNuclei::getA(), G4InuclParticle::getCharge(), G4InuclNuclei::getZ(), G4VCascadeCollider::theName, G4CascadeColliderBase::useEPCollider(), and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclCollider::collide().

◆ initialize()

G4bool G4IntraNucleiCascader::initialize	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target
	)

protected

Definition at line 251 of file G4IntraNucleiCascader.cc.

                                              {
  if (verboseLevel>1)
    G4cout << " >>> G4IntraNucleiCascader::initialize " << G4endl;
  
  // Configure processing modules
  theRecoilMaker->setTolerance(small_ekin);
 
  interCase.set(bullet,target);     // Classify collision type
 
  if (verboseLevel > 3) {
    G4cout << *interCase.getBullet() << G4endl
       << *interCase.getTarget() << G4endl;
  }
  
  // Bullet may be nucleus or simple particle
  bnuclei = dynamic_cast<G4InuclNuclei*>(interCase.getBullet());
  bparticle = dynamic_cast<G4InuclElementaryParticle*>(interCase.getBullet());
  
  if (!bnuclei && !bparticle) {
    G4cerr << " G4IntraNucleiCascader: projectile is not a valid particle."
       << G4endl;
    return false;
  }
  
  // Target _must_ be nucleus
  tnuclei = dynamic_cast<G4InuclNuclei*>(interCase.getTarget());
  if (!tnuclei) {
    if (verboseLevel)
      G4cerr << " Target is not a nucleus.  Abandoning." << G4endl;
    return false;
  }
  
  model->generateModel(tnuclei);
  coulombBarrier = 0.00126*tnuclei->getZ() / (1.+G4cbrt(tnuclei->getA()));
 
  // Energy/momentum conservation usually requires a recoiling nuclear fragment
  // This cut will be increased on each "itry" if momentum could not balance.
  minimum_recoil_A = 0.;
  
  if (verboseLevel > 3) {
    G4LorentzVector momentum_in = bullet->getMomentum() + target->getMomentum();
    G4cout << " intitial momentum  E " << momentum_in.e() << " Px "
       << momentum_in.x() << " Py " << momentum_in.y() << " Pz "
       << momentum_in.z() << G4endl;
  }
  
  return true;
}

References bnuclei, bparticle, coulombBarrier, CLHEP::HepLorentzVector::e(), G4InuclSpecialFunctions::G4cbrt(), G4cerr, G4cout, G4endl, G4NucleiModel::generateModel(), G4InuclNuclei::getA(), G4InteractionCase::getBullet(), G4InuclParticle::getMomentum(), G4InteractionCase::getTarget(), G4InuclNuclei::getZ(), G4CascadeColliderBase::interCase, minimum_recoil_A, model, G4InteractionCase::set(), G4CascadeRecoilMaker::setTolerance(), small_ekin, theRecoilMaker, tnuclei, G4VCascadeCollider::verboseLevel, CLHEP::HepLorentzVector::x(), CLHEP::HepLorentzVector::y(), and CLHEP::HepLorentzVector::z().

Referenced by collide(), and rescatter().

◆ newCascade()

void G4IntraNucleiCascader::newCascade ( G4int itry )

protected

Definition at line 303 of file G4IntraNucleiCascader.cc.

                                                 {
  if (verboseLevel > 1) {
    G4cout << " IntraNucleiCascader itry " << itry << " inter_case "
       << interCase.code() << G4endl;
  }
  
  model->reset();               // Start new cascade process
  output.reset();
  new_cascad_particles.clear();
  theExitonConfiguration.clear();
  cascad_particles.clear();     // List of initial secondaries
 
  if (theCascadeHistory) theCascadeHistory->Clear();
}

References cascad_particles, G4CascadeHistory::Clear(), G4ExitonConfiguration::clear(), G4InteractionCase::code(), G4cout, G4endl, G4CascadeColliderBase::interCase, model, new_cascad_particles, output, G4CollisionOutput::reset(), G4NucleiModel::reset(), theCascadeHistory, theExitonConfiguration, and G4VCascadeCollider::verboseLevel.

Referenced by collide(), and rescatter().

◆ operator=()

G4IntraNucleiCascader & G4IntraNucleiCascader::operator= ( const G4IntraNucleiCascader & )

private

◆ particleCanInteract()

G4bool G4IntraNucleiCascader::particleCanInteract ( const G4CascadParticle & cpart ) const

protected

Definition at line 929 of file G4IntraNucleiCascader.cc.

                                                         {
  // If we have a lookup table for particle type on proton, it interacts
  return (0 != G4CascadeChannelTables::GetTable(cpart.getParticle().type()));
}

References G4CascadParticle::getParticle(), G4CascadeChannelTables::GetTable(), and G4InuclElementaryParticle::type().

Referenced by generateCascade().

◆ preloadCascade()

void G4IntraNucleiCascader::preloadCascade	(	G4V3DNucleus *	theNucleus,
		G4KineticTrackVector *	theSecondaries
	)

protected

Definition at line 698 of file G4IntraNucleiCascader.cc.

                                                            {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::preloadCascade" << G4endl;
 
  copyWoundedNucleus(theNucleus);   // Update interacted nucleon counts
  copySecondaries(theSecondaries);  // Copy original to internal list
}

References copySecondaries(), copyWoundedNucleus(), G4cout, G4endl, and G4VCascadeCollider::verboseLevel.

Referenced by rescatter().

◆ processSecondary()

void G4IntraNucleiCascader::processSecondary ( const G4KineticTrack * aSecondary )

protected

Definition at line 763 of file G4IntraNucleiCascader.cc.

                                                                         {
  if (!ktrack) return;          // Sanity check
 
  // Get particle type to determine whether to keep or release
  const G4ParticleDefinition* kpd = ktrack->GetDefinition();
  if (!kpd) return;
 
  G4int ktype = G4InuclElementaryParticle::type(kpd);
  if (!ktype) {
    releaseSecondary(ktrack);
    return;
  }
 
  if (verboseLevel > 1) {
    G4cout << " >>> G4IntraNucleiCascader::processSecondary "
       << kpd->GetParticleName() << G4endl;
  }
 
  // Allocate next local particle in buffer and fill
  cascad_particles.resize(cascad_particles.size()+1);   // Like push_back();
  G4CascadParticle& cpart = cascad_particles.back();
 
  // Convert momentum to Bertini internal units
  cpart.getParticle().fill(ktrack->Get4Momentum()/GeV, ktype);
  cpart.setGeneration(1);
  cpart.setMovingInsideNuclei();
  cpart.initializePath(0);
 
  // Convert position units to Bertini's internal scale
  G4ThreeVector cpos = ktrack->GetPosition()/model->getRadiusUnits();
 
  cpart.updatePosition(cpos);
  cpart.updateZone(model->getZone(cpos.mag()));
 
  if (verboseLevel > 2)
    G4cout << " Created cascade particle \n" << cpart << G4endl;
}

References cascad_particles, G4InuclElementaryParticle::fill(), G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4KineticTrack::GetDefinition(), G4CascadParticle::getParticle(), G4ParticleDefinition::GetParticleName(), G4KineticTrack::GetPosition(), G4NucleiModel::getRadiusUnits(), G4NucleiModel::getZone(), GeV, G4CascadParticle::initializePath(), CLHEP::Hep3Vector::mag(), model, releaseSecondary(), G4CascadParticle::setGeneration(), G4CascadParticle::setMovingInsideNuclei(), G4InuclElementaryParticle::type(), G4CascadParticle::updatePosition(), G4CascadParticle::updateZone(), and G4VCascadeCollider::verboseLevel.

Referenced by copySecondaries().

◆ processTrappedParticle()

void G4IntraNucleiCascader::processTrappedParticle ( const G4CascadParticle & trapped )

protected

Definition at line 837 of file G4IntraNucleiCascader.cc.

                                                        {
  const G4InuclElementaryParticle& trappedP = trapped.getParticle();
 
  G4int xtype = trappedP.type();
  if (verboseLevel > 3) G4cout << " exciton of type " << xtype << G4endl;
  
  if (trappedP.nucleon()) { // normal exciton (proton or neutron)
    theExitonConfiguration.incrementQP(xtype);
    if (theCascadeHistory) theCascadeHistory->DropEntry(trapped);
    return;
  }
 
  if (trappedP.hyperon()) { // Not nucleon, so must be hyperon
    decayTrappedParticle(trapped);
    if (theCascadeHistory) theCascadeHistory->DropEntry(trapped);
    return;
  }
 
  // non-standard exciton; release it
  // FIXME: this is a meson, so need to absorb it
  if (verboseLevel > 3) {
    G4cout << " non-standard should be absorbed, now released\n"
       << trapped << G4endl;
  }
  
  output.addOutgoingParticle(trappedP);
}

References G4CollisionOutput::addOutgoingParticle(), decayTrappedParticle(), G4CascadeHistory::DropEntry(), G4cout, G4endl, G4CascadParticle::getParticle(), G4InuclElementaryParticle::hyperon(), G4ExitonConfiguration::incrementQP(), G4InuclElementaryParticle::nucleon(), output, theCascadeHistory, theExitonConfiguration, G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by generateCascade().

◆ releaseSecondary()

void G4IntraNucleiCascader::releaseSecondary ( const G4KineticTrack * aSecondary )

protected

Definition at line 804 of file G4IntraNucleiCascader.cc.

                                                                         {
  const G4ParticleDefinition* kpd = ktrack->GetDefinition();
 
  if (verboseLevel > 1) {
    G4cout << " >>> G4IntraNucleiCascader::releaseSecondary "
       << kpd->GetParticleName() << G4endl;
  }
 
  // Convert light ion into nucleus on fragment list
  if (dynamic_cast<const G4Ions*>(kpd)) {
    // Use resize() and fill() to avoid memory churn
    output.getOutgoingNuclei().resize(output.numberOfOutgoingNuclei()+1);
    G4InuclNuclei& inucl = output.getOutgoingNuclei().back();
 
    inucl.fill(ktrack->Get4Momentum()/GeV,
           kpd->GetAtomicMass(), kpd->GetAtomicNumber());
    if (verboseLevel > 2)
      G4cout << " Created pre-cascade fragment\n" << inucl << G4endl;
  } else {
    // Use resize() and fill() to avoid memory churn
    output.getOutgoingParticles().resize(output.numberOfOutgoingParticles()+1);
    G4InuclElementaryParticle& ipart = output.getOutgoingParticles().back();
 
    // SPECIAL:  Use G4PartDef directly, allowing unknown type code
    ipart.fill(ktrack->Get4Momentum()/GeV, ktrack->GetDefinition());
    if (verboseLevel > 2)
      G4cout << " Created invalid pre-cascade particle\n" << ipart << G4endl;
  }
}

References G4InuclNuclei::fill(), G4InuclElementaryParticle::fill(), G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4KineticTrack::GetDefinition(), G4CollisionOutput::getOutgoingNuclei(), G4CollisionOutput::getOutgoingParticles(), G4ParticleDefinition::GetParticleName(), GeV, G4CollisionOutput::numberOfOutgoingNuclei(), G4CollisionOutput::numberOfOutgoingParticles(), output, and G4VCascadeCollider::verboseLevel.

Referenced by processSecondary().

◆ rescatter()

void G4IntraNucleiCascader::rescatter	(	G4InuclParticle *	bullet,
		G4KineticTrackVector *	theSecondaries,
		G4V3DNucleus *	theNucleus,
		G4CollisionOutput &	globalOutput
	)

virtual

Reimplemented from G4CascadeColliderBase.

Definition at line 227 of file G4IntraNucleiCascader.cc.

                                                       {
  if (verboseLevel)
    G4cout << " >>> G4IntraNucleiCascader::rescatter " << G4endl;
 
  G4InuclParticle* target = createTarget(theNucleus);
  if (!initialize(bullet, target)) return;  // Load buffers and drivers
 
  G4int itry = 0;
  do {              /* Loop checking 08.06.2015 MHK */
    newCascade(++itry);
    preloadCascade(theNucleus, theSecondaries);
    generateCascade();
  } while (!finishCascade() && itry<itry_max);
 
  // Report full structure of final cascade if requested
  if (theCascadeHistory) theCascadeHistory->Print(G4cout);
 
  finalize(itry, bullet, target, globalOutput);
}

References createTarget(), finalize(), finishCascade(), G4cout, G4endl, generateCascade(), initialize(), itry_max, newCascade(), preloadCascade(), G4CascadeHistory::Print(), theCascadeHistory, and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclCollider::rescatter().

◆ setName()

virtual void G4VCascadeCollider::setName ( const G4String & name )

inlineprotectedvirtualinherited

Definition at line 55 of file G4VCascadeCollider.hh.

55{ theName = name; }

G4InuclParticleNames::name

const char * name(G4int ptype)

Definition: G4InuclParticleNames.hh:76

References G4InuclParticleNames::name(), and G4VCascadeCollider::theName.

Referenced by G4CascadeCheckBalance::setOwner().

◆ setupCascade()

void G4IntraNucleiCascader::setupCascade ( )

protected

Definition at line 321 of file G4IntraNucleiCascader.cc.

                                         {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::setupCascade" << G4endl;
 
  if (interCase.hadNucleus()) {         // particle with nuclei
    if (verboseLevel > 3)
      G4cout << " bparticle charge " << bparticle->getCharge()
         << " baryon number " << bparticle->baryon() << G4endl;
    
    cascad_particles.push_back(model->initializeCascad(bparticle));
  } else {              // nuclei with nuclei
    G4int ab = bnuclei->getA();
    G4int zb = bnuclei->getZ();
    
    G4NucleiModel::modelLists all_particles;    // Buffer to receive lists
    model->initializeCascad(bnuclei, tnuclei, all_particles);
    
    cascad_particles = all_particles.first;
    output.addOutgoingParticles(all_particles.second);
    
    if (cascad_particles.size() == 0) { // compound nuclei
      G4int i;
      
      for (i = 0; i < ab; i++) {
    G4int knd = i < zb ? 1 : 2;
    theExitonConfiguration.incrementQP(knd);
      };
      
      G4int ihn = G4int(2 * (ab-zb) * inuclRndm() + 0.5);
      G4int ihz = G4int(2 * zb * inuclRndm() + 0.5);
      
      for (i = 0; i < ihn; i++) theExitonConfiguration.incrementHoles(2);
      for (i = 0; i < ihz; i++) theExitonConfiguration.incrementHoles(1);
    }
  } // if (interCase ...
}

References ab, G4CollisionOutput::addOutgoingParticles(), G4InuclElementaryParticle::baryon(), bnuclei, bparticle, cascad_particles, G4cout, G4endl, G4InuclNuclei::getA(), G4InuclParticle::getCharge(), G4InuclNuclei::getZ(), G4InteractionCase::hadNucleus(), G4ExitonConfiguration::incrementHoles(), G4ExitonConfiguration::incrementQP(), G4NucleiModel::initializeCascad(), G4CascadeColliderBase::interCase, G4InuclSpecialFunctions::inuclRndm(), model, output, theExitonConfiguration, tnuclei, and G4VCascadeCollider::verboseLevel.

Referenced by collide().

◆ setVerboseLevel()

void G4IntraNucleiCascader::setVerboseLevel ( G4int verbose = 0 )

virtual

Reimplemented from G4CascadeColliderBase.

Definition at line 191 of file G4IntraNucleiCascader.cc.

                                                         {
  G4CascadeColliderBase::setVerboseLevel(verbose);
  model->setVerboseLevel(verbose);
  theElementaryParticleCollider->setVerboseLevel(verbose);
  theRecoilMaker->setVerboseLevel(verbose);
 
  // Optional functionality
  if (theClusterMaker) theClusterMaker->setVerboseLevel(verbose);
  if (theCascadeHistory) theCascadeHistory->setVerboseLevel(verbose);
}

References model, G4CascadeCoalescence::setVerboseLevel(), G4NucleiModel::setVerboseLevel(), G4CascadeColliderBase::setVerboseLevel(), G4CascadeHistory::setVerboseLevel(), G4VCascadeCollider::setVerboseLevel(), theCascadeHistory, theClusterMaker, theElementaryParticleCollider, and theRecoilMaker.

Referenced by G4InuclCollider::setVerboseLevel().

◆ useEPCollider()

G4bool G4CascadeColliderBase::useEPCollider	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target
	)		const

protectedvirtualinherited

Definition at line 75 of file G4CascadeColliderBase.cc.

                                                       {
  return (dynamic_cast<G4InuclElementaryParticle*>(bullet) &&
      dynamic_cast<G4InuclElementaryParticle*>(target));
}

Referenced by G4InuclCollider::collide(), G4ElementaryParticleCollider::collide(), and G4CascadeColliderBase::inelasticInteractionPossible().

◆ validateOutput() [1/3]

G4bool G4CascadeColliderBase::validateOutput	(	const G4Fragment &	fragment,
		G4CollisionOutput &	output
	)

protectedvirtualinherited

Definition at line 139 of file G4CascadeColliderBase.cc.

                                                    {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(fragment, output);
  return balance->okay();           // Returns false if violations
}

References G4CascadeColliderBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

◆ validateOutput() [2/3]

G4bool G4CascadeColliderBase::validateOutput	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target,
		const std::vector< G4InuclElementaryParticle > &	particles
	)

protectedvirtualinherited

Definition at line 151 of file G4CascadeColliderBase.cc.

                                                                    {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(bullet, target, particles);
  return balance->okay();           // Returns false if violations
}

References G4CascadeColliderBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

◆ validateOutput() [3/3]

G4bool G4CascadeColliderBase::validateOutput	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target,
		G4CollisionOutput &	output
	)

protectedvirtualinherited

Definition at line 123 of file G4CascadeColliderBase.cc.

                                                    {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  // Show final state particles
  if (verboseLevel > 2) output.printCollisionOutput();
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(bullet, target, output);
  return balance->okay();           // Returns false if violations
}

References G4CascadeColliderBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4CollisionOutput::printCollisionOutput(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

Referenced by G4ElementaryParticleCollider::collide(), and G4InuclCollider::deexcite().

Field Documentation

◆ balance

G4CascadeCheckBalance* G4CascadeColliderBase::balance

protectedinherited

Definition at line 88 of file G4CascadeColliderBase.hh.

Referenced by G4CascadeColliderBase::G4CascadeColliderBase(), G4CascadeColliderBase::setVerboseLevel(), G4CascadeColliderBase::validateOutput(), and G4CascadeColliderBase::~G4CascadeColliderBase().

◆ bnuclei

G4InuclNuclei* G4IntraNucleiCascader::bnuclei

private

Definition at line 146 of file G4IntraNucleiCascader.hh.

Referenced by initialize(), and setupCascade().

◆ bparticle

G4InuclElementaryParticle* G4IntraNucleiCascader::bparticle

private

Definition at line 147 of file G4IntraNucleiCascader.hh.

Referenced by initialize(), and setupCascade().

◆ cascad_particles

std::vector<G4CascadParticle> G4IntraNucleiCascader::cascad_particles

private

Definition at line 158 of file G4IntraNucleiCascader.hh.

Referenced by copySecondaries(), decayTrappedParticle(), finishCascade(), generateCascade(), newCascade(), processSecondary(), and setupCascade().

◆ coulombBarrier

G4double G4IntraNucleiCascader::coulombBarrier

private

Definition at line 150 of file G4IntraNucleiCascader.hh.

Referenced by generateCascade(), and initialize().

◆ hitNucleons

std::vector<G4ThreeVector> G4IntraNucleiCascader::hitNucleons

private

Definition at line 162 of file G4IntraNucleiCascader.hh.

Referenced by copyWoundedNucleus().

◆ interCase

G4InteractionCase G4CascadeColliderBase::interCase

protectedinherited

Definition at line 76 of file G4CascadeColliderBase.hh.

Referenced by G4InuclCollider::collide(), G4ElementaryParticleCollider::collide(), finishCascade(), generateCascade(), initialize(), newCascade(), G4InuclCollider::photonuclearOkay(), G4ElementaryParticleCollider::pionNucleonAbsorption(), and setupCascade().

◆ itry_max

const G4int G4IntraNucleiCascader::itry_max = 100

staticprivate

Definition at line 103 of file G4IntraNucleiCascader.hh.

Referenced by collide(), finalize(), and rescatter().

◆ minimum_recoil_A

G4double G4IntraNucleiCascader::minimum_recoil_A

private

Definition at line 149 of file G4IntraNucleiCascader.hh.

Referenced by finishCascade(), generateCascade(), and initialize().

◆ model

G4NucleiModel* G4IntraNucleiCascader::model

private

Definition at line 138 of file G4IntraNucleiCascader.hh.

Referenced by copyWoundedNucleus(), generateCascade(), initialize(), newCascade(), processSecondary(), setupCascade(), setVerboseLevel(), and ~G4IntraNucleiCascader().

◆ new_cascad_particles

std::vector<G4CascadParticle> G4IntraNucleiCascader::new_cascad_particles

private

Definition at line 159 of file G4IntraNucleiCascader.hh.

Referenced by generateCascade(), and newCascade().

◆ nucleusTarget

G4InuclNuclei* G4IntraNucleiCascader::nucleusTarget

private

Definition at line 153 of file G4IntraNucleiCascader.hh.

Referenced by createTarget(), and ~G4IntraNucleiCascader().

◆ output

G4CollisionOutput G4IntraNucleiCascader::output

private

Definition at line 157 of file G4IntraNucleiCascader.hh.

Referenced by copySecondaries(), decayTrappedParticle(), finalize(), finishCascade(), generateCascade(), newCascade(), processTrappedParticle(), releaseSecondary(), and setupCascade().

◆ protonTarget

G4InuclElementaryParticle* G4IntraNucleiCascader::protonTarget

private

Definition at line 154 of file G4IntraNucleiCascader.hh.

Referenced by createTarget(), and ~G4IntraNucleiCascader().

◆ quasielast_cut

const G4double G4IntraNucleiCascader::quasielast_cut = 1*MeV

staticprivate

Definition at line 106 of file G4IntraNucleiCascader.hh.

Referenced by finishCascade().

◆ reflection_cut

const G4int G4IntraNucleiCascader::reflection_cut = 50

staticprivate

Definition at line 104 of file G4IntraNucleiCascader.hh.

Referenced by generateCascade().

◆ small_ekin

const G4double G4IntraNucleiCascader::small_ekin = 0.001*MeV

staticprivate

Definition at line 105 of file G4IntraNucleiCascader.hh.

Referenced by finishCascade(), and initialize().

◆ theCascadeHistory

G4CascadeHistory* G4IntraNucleiCascader::theCascadeHistory

private

Definition at line 142 of file G4IntraNucleiCascader.hh.

Referenced by collide(), G4IntraNucleiCascader(), generateCascade(), newCascade(), processTrappedParticle(), rescatter(), setVerboseLevel(), and ~G4IntraNucleiCascader().

◆ theClusterMaker

G4CascadeCoalescence* G4IntraNucleiCascader::theClusterMaker

private

Definition at line 141 of file G4IntraNucleiCascader.hh.

Referenced by finishCascade(), G4IntraNucleiCascader(), setVerboseLevel(), and ~G4IntraNucleiCascader().

◆ theElementaryParticleCollider

G4ElementaryParticleCollider* G4IntraNucleiCascader::theElementaryParticleCollider

private

Definition at line 139 of file G4IntraNucleiCascader.hh.

Referenced by generateCascade(), setVerboseLevel(), and ~G4IntraNucleiCascader().

◆ theExitonConfiguration

G4ExitonConfiguration G4IntraNucleiCascader::theExitonConfiguration

private

Definition at line 160 of file G4IntraNucleiCascader.hh.

Referenced by copyWoundedNucleus(), finishCascade(), generateCascade(), newCascade(), processTrappedParticle(), and setupCascade().

◆ theName

G4String G4VCascadeCollider::theName

protectedinherited

◆ theRecoilMaker

G4CascadeRecoilMaker* G4IntraNucleiCascader::theRecoilMaker

private

Definition at line 140 of file G4IntraNucleiCascader.hh.

Referenced by finishCascade(), generateCascade(), initialize(), setVerboseLevel(), and ~G4IntraNucleiCascader().

◆ tnuclei

G4InuclNuclei* G4IntraNucleiCascader::tnuclei

private

Definition at line 145 of file G4IntraNucleiCascader.hh.

Referenced by generateCascade(), initialize(), and setupCascade().

◆ verboseLevel

G4int G4VCascadeCollider::verboseLevel

protectedinherited

Definition at line 53 of file G4VCascadeCollider.hh.

Referenced by G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), collide(), G4InuclCollider::collide(), G4LightTargetCollider::collide(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeRecoilMaker::collide(), G4ElementaryParticleCollider::collide(), copySecondaries(), copyWoundedNucleus(), decayTrappedParticle(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4PreCompoundDeexcitation::deExcite(), G4BigBanger::deExcite(), G4EquilibriumEvaporator::deExcite(), G4EvaporationInuclCollider::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeCheckBalance::ekinOkay(), G4CascadeCheckBalance::energyOkay(), G4EquilibriumEvaporator::explosion(), G4CascadeDeexciteBase::explosion(), G4CascadeRecoilMaker::fillRecoil(), finalize(), finishCascade(), G4VCascadeCollider::G4VCascadeCollider(), G4BigBanger::generateBangInSCM(), generateCascade(), G4BigBanger::generateMomentumModules(), G4ElementaryParticleCollider::generateMultiplicity(), G4ElementaryParticleCollider::generateSCMfinalState(), G4ElementaryParticleCollider::generateSCMmuonAbsorption(), G4ElementaryParticleCollider::generateSCMpionAbsorption(), G4ElementaryParticleCollider::generateSCMpionNAbsorption(), G4BigBanger::generateX(), G4EquilibriumEvaporator::getAF(), G4Fissioner::getC2(), G4EquilibriumEvaporator::getE0(), G4NonEquilibriumEvaporator::getE0(), G4NonEquilibriumEvaporator::getMatrixElement(), G4NonEquilibriumEvaporator::getParLev(), G4EquilibriumEvaporator::getPARLEVDEN(), G4EquilibriumEvaporator::getQF(), G4Fissioner::getZopt(), G4CascadeRecoilMaker::goodNucleus(), G4EquilibriumEvaporator::goodRemnant(), G4CascadeColliderBase::inelasticInteractionPossible(), initialize(), G4CascadeDeexciteBase::makeFragment(), G4CascadeRecoilMaker::makeRecoilFragment(), G4CascadeRecoilMaker::makeRecoilNuclei(), G4BigBanger::maxProbability(), G4CascadeCheckBalance::momentumOkay(), newCascade(), G4InuclCollider::photonuclearOkay(), G4ElementaryParticleCollider::pionNucleonAbsorption(), G4Fissioner::potentialMinimization(), preloadCascade(), processSecondary(), processTrappedParticle(), releaseSecondary(), rescatter(), G4InuclCollider::rescatter(), setupCascade(), G4InuclCollider::setVerboseLevel(), G4LightTargetCollider::setVerboseLevel(), G4VCascadeCollider::setVerboseLevel(), G4CascadeCheckBalance::strangeOkay(), G4InuclCollider::useCascadeDeexcitation(), G4InuclCollider::usePreCompoundDeexcitation(), G4CascadeDeexciteBase::validateOutput(), G4CascadeColliderBase::validateOutput(), G4CascadeRecoilMaker::wholeEvent(), and G4BigBanger::xProbability().

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

source/processes/hadronic/models/cascade/cascade/include/G4IntraNucleiCascader.hh
source/processes/hadronic/models/cascade/cascade/src/G4IntraNucleiCascader.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4IntraNucleiCascader() [1/2]

◆ ~G4IntraNucleiCascader()

◆ G4IntraNucleiCascader() [2/2]

Member Function Documentation

◆ collide()

◆ copySecondaries()

◆ copyWoundedNucleus()

◆ createTarget()

◆ decayTrappedParticle()

◆ finalize()

◆ finishCascade()

◆ generateCascade()

◆ inelasticInteractionPossible()

◆ initialize()

◆ newCascade()

◆ operator=()

◆ particleCanInteract()

◆ preloadCascade()

◆ processSecondary()

◆ processTrappedParticle()

◆ releaseSecondary()

◆ rescatter()

◆ setName()

◆ setupCascade()

◆ setVerboseLevel()

◆ useEPCollider()

◆ validateOutput() [1/3]

◆ validateOutput() [2/3]

◆ validateOutput() [3/3]

Field Documentation

◆ balance

◆ bnuclei

◆ bparticle

◆ cascad_particles

◆ coulombBarrier

◆ hitNucleons

◆ interCase

◆ itry_max

◆ minimum_recoil_A

◆ model

◆ new_cascad_particles

◆ nucleusTarget

◆ output

◆ protonTarget

◆ quasielast_cut

◆ reflection_cut

◆ small_ekin

◆ theCascadeHistory

◆ theClusterMaker

◆ theElementaryParticleCollider

◆ theExitonConfiguration

◆ theName

◆ theRecoilMaker

◆ tnuclei

◆ verboseLevel