#include <G4IntraNucleiCascader.hh>

Inheritance diagram for G4IntraNucleiCascader:

Public Member Functions
	G4IntraNucleiCascader ()

virtual	~G4IntraNucleiCascader ()

void	collide (G4InuclParticle bullet, G4InuclParticle target, G4CollisionOutput &globalOutput)

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

void	setVerboseLevel (G4int verbose=0)

Public Member Functions inherited from G4CascadeColliderBase
	G4CascadeColliderBase (const char *name, G4int verbose=0)

virtual	~G4CascadeColliderBase ()

virtual void	rescatter (G4InuclParticle , G4KineticTrackVector , G4V3DNucleus *, G4CollisionOutput &)

virtual void	setVerboseLevel (G4int verbose=0)

virtual void	setConservationChecks (G4bool doBalance=true)

Public Member Functions inherited from G4VCascadeCollider
	G4VCascadeCollider (const char *name, G4int verbose=0)

virtual	~G4VCascadeCollider ()

virtual void	collide (G4InuclParticle bullet, G4InuclParticle target, G4CollisionOutput &output)=0

virtual void	setVerboseLevel (G4int verbose=0)

Protected Member Functions
G4bool	initialize (G4InuclParticle bullet, G4InuclParticle target)

void	newCascade (G4int itry)

void	setupCascade ()

void	generateCascade ()

G4bool	finishCascade ()

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

G4InuclParticle *	createTarget (G4V3DNucleus *theNucleus)

void	preloadCascade (G4V3DNucleus theNucleus, G4KineticTrackVector theSecondaries)

void	copyWoundedNucleus (G4V3DNucleus *theNucleus)

void	copySecondaries (G4KineticTrackVector *theSecondaries)

void	processSecondary (const G4KineticTrack *aSecondary)

void	releaseSecondary (const G4KineticTrack *aSecondary)

void	processTrappedParticle (const G4CascadParticle &trapped)

void	decayTrappedParticle (const G4CascadParticle &trapped)

Protected Member Functions inherited from G4CascadeColliderBase
virtual G4bool	useEPCollider (G4InuclParticle bullet, G4InuclParticle target) const

virtual G4bool	explosion (G4InuclNuclei *target) const

virtual G4bool	explosion (G4Fragment *target) const

virtual G4bool	explosion (G4int A, G4int Z, G4double excitation) const

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

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

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

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

Protected Member Functions inherited from G4VCascadeCollider
virtual void	setName (const char *name)

Additional Inherited Members
Protected Attributes inherited from G4CascadeColliderBase
G4InteractionCase	interCase

G4bool	doConservationChecks

G4CascadeCheckBalance *	balance

Protected Attributes inherited from G4VCascadeCollider
const char *	theName

G4int	verboseLevel

Detailed Description

Definition at line 85 of file G4IntraNucleiCascader.hh.

Constructor & Destructor Documentation

◆ G4IntraNucleiCascader()

G4IntraNucleiCascader::G4IntraNucleiCascader ( )

Definition at line 156 of file G4IntraNucleiCascader.cc.

  : G4CascadeColliderBase("G4IntraNucleiCascader"), model(new G4NucleiModel),
    theElementaryParticleCollider(new G4ElementaryParticleCollider),
    theRecoilMaker(new G4CascadeRecoilMaker), theClusterMaker(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;
}

◆ ~G4IntraNucleiCascader()

G4IntraNucleiCascader::~G4IntraNucleiCascader ( )

virtual

Definition at line 168 of file G4IntraNucleiCascader.cc.

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

Member Function Documentation

◆ collide()

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

virtual

Implements G4VCascadeCollider.

Definition at line 186 of file G4IntraNucleiCascader.cc.

                                                     {
  if (verboseLevel) G4cout << " >>> G4IntraNucleiCascader::collide " << G4endl;
 
  if (!initialize(bullet, target)) return;  // Load buffers and drivers
 
  G4int itry = 0;
  do {
    newCascade(++itry);
    setupCascade();
    generateCascade();
  } while (!finishCascade() && itry<itry_max);
 
  finalize(itry, bullet, target, globalOutput);
}

Referenced by G4InuclCollider::collide().

◆ copySecondaries()

void G4IntraNucleiCascader::copySecondaries ( G4KineticTrackVector * theSecondaries )

protected

Definition at line 687 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;
  }
}

Referenced by preloadCascade().

◆ copyWoundedNucleus()

void G4IntraNucleiCascader::copyWoundedNucleus ( G4V3DNucleus * theNucleus )

protected

Definition at line 657 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;
    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);
}

Referenced by preloadCascade().

◆ createTarget()

G4InuclParticle * G4IntraNucleiCascader::createTarget ( G4V3DNucleus * theNucleus )

protected

Definition at line 628 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
}

Referenced by rescatter().

◆ decayTrappedParticle()

void G4IntraNucleiCascader::decayTrappedParticle ( const G4CascadParticle & trapped )

protected

Definition at line 816 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);
    }
  }
}

Referenced by processTrappedParticle().

◆ finalize()

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

protected

Definition at line 606 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);
}

Referenced by collide(), and rescatter().

◆ finishCascade()

G4bool G4IntraNucleiCascader::finishCascade ( )

protected

Definition at line 457 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;
}

Referenced by collide(), and rescatter().

◆ generateCascade()

void G4IntraNucleiCascader::generateCascade ( )

protected

Definition at line 336 of file G4IntraNucleiCascader.cc.

                                            {
  if (verboseLevel>1) G4cout << " generateCascade " << G4endl;
 
  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;
    }
    
    model->generateParticleFate(cascad_particles.back(),
                theElementaryParticleCollider,
                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 = std::exp(-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
}

Referenced by collide(), and rescatter().

◆ initialize()

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

protected

Definition at line 227 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;
}

Referenced by collide(), and rescatter().

◆ newCascade()

void G4IntraNucleiCascader::newCascade ( G4int itry )

protected

Definition at line 279 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
}

Referenced by collide(), and rescatter().

◆ preloadCascade()

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

protected

Definition at line 648 of file G4IntraNucleiCascader.cc.

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

Referenced by rescatter().

◆ processSecondary()

void G4IntraNucleiCascader::processSecondary ( const G4KineticTrack * aSecondary )

protected

Definition at line 712 of file G4IntraNucleiCascader.cc.

                                                                         {
  if (!ktrack) return;          // Sanity check
 
  // Get particle type to determine whether to keep or release
  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(0);
  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;
}

Referenced by copySecondaries().

◆ processTrappedParticle()

void G4IntraNucleiCascader::processTrappedParticle ( const G4CascadParticle & trapped )

protected

Definition at line 786 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);
    return;
  }
 
  if (trappedP.hyperon()) { // Not nucleon, so must be hyperon
    decayTrappedParticle(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);
}

Referenced by generateCascade().

◆ releaseSecondary()

void G4IntraNucleiCascader::releaseSecondary ( const G4KineticTrack * aSecondary )

protected

Definition at line 753 of file G4IntraNucleiCascader.cc.

                                                                         {
  G4ParticleDefinition* kpd = ktrack->GetDefinition();
 
  if (verboseLevel > 1) {
    G4cout << " >>> G4IntraNucleiCascader::releaseSecondary "
       << kpd->GetParticleName() << G4endl;
  }
 
  // Convert light ion into nucleus on fragment list
  if (dynamic_cast<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;
  }
}

Referenced by processSecondary().

◆ rescatter()

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

virtual

Reimplemented from G4CascadeColliderBase.

Definition at line 206 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 {
    newCascade(++itry);
    preloadCascade(theNucleus, theSecondaries);
    generateCascade();
  } while (!finishCascade() && itry<itry_max);
 
  finalize(itry, bullet, target, globalOutput);
}

Referenced by G4InuclCollider::rescatter().

◆ setupCascade()

void G4IntraNucleiCascader::setupCascade ( )

protected

Definition at line 296 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 ...
}

Referenced by collide().

◆ setVerboseLevel()

void G4IntraNucleiCascader::setVerboseLevel ( G4int verbose = 0 )

virtual

Reimplemented from G4CascadeColliderBase.

Definition at line 177 of file G4IntraNucleiCascader.cc.

                                                         {
  G4CascadeColliderBase::setVerboseLevel(verbose);
  model->setVerboseLevel(verbose);
  theElementaryParticleCollider->setVerboseLevel(verbose);
  theRecoilMaker->setVerboseLevel(verbose);
}

Referenced by G4InuclCollider::setVerboseLevel().

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4IntraNucleiCascader()

◆ ~G4IntraNucleiCascader()

Member Function Documentation

◆ collide()

◆ copySecondaries()

◆ copyWoundedNucleus()

◆ createTarget()

◆ decayTrappedParticle()

◆ finalize()

◆ finishCascade()

◆ generateCascade()

◆ initialize()

◆ newCascade()

◆ preloadCascade()

◆ processSecondary()

◆ processTrappedParticle()

◆ releaseSecondary()

◆ rescatter()

◆ setupCascade()

◆ setVerboseLevel()