G4IntraNucleiCascader Class Reference

#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)
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)

---

Detailed Description

Definition at line 85 of file G4IntraNucleiCascader.hh.

---

Constructor & Destructor Documentation

G4IntraNucleiCascader::G4IntraNucleiCascader

(

)

Definition at line 156 of file G4IntraNucleiCascader.cc.

References G4CascadeParameters::doCoalescence().

  : 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

(

)

[virtual]

Definition at line 168 of file G4IntraNucleiCascader.cc.

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

---

Member Function Documentation

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

Implements G4VCascadeCollider.

Definition at line 186 of file G4IntraNucleiCascader.cc.

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

Referenced by G4InuclCollider::collide().

                                                                     {
  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);
}

void G4IntraNucleiCascader::copySecondaries

(

G4KineticTrackVector *

theSecondaries

)

[protected]

Definition at line 687 of file G4IntraNucleiCascader.cc.

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

Referenced by preloadCascade().

                                                                        {
  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;
  }
}

void G4IntraNucleiCascader::copyWoundedNucleus

(

G4V3DNucleus *

theNucleus

)

[protected]

Definition at line 657 of file G4IntraNucleiCascader.cc.

References G4ExitonConfiguration::clear(), G4cout, G4endl, G4V3DNucleus::GetNextNucleon(), G4ExitonConfiguration::incrementHoles(), G4ExitonConfiguration::neutronHoles, G4ExitonConfiguration::protonHoles, G4NucleiModel::reset(), G4V3DNucleus::StartLoop(), G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by preloadCascade().

                                                                       {
  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);
}

G4InuclParticle * G4IntraNucleiCascader::createTarget

(

G4V3DNucleus *

theNucleus

)

[protected]

Definition at line 628 of file G4IntraNucleiCascader.cc.

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

Referenced by rescatter().

                                                            {
  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
}

void G4IntraNucleiCascader::decayTrappedParticle

(

const G4CascadParticle &

trapped

)

[protected]

Definition at line 817 of file G4IntraNucleiCascader.cc.

References G4CollisionOutput::addOutgoingParticle(), G4DecayProducts::Boost(), 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, G4DecayTable::SelectADecayChannel(), G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by processTrappedParticle().

                                                      {
  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);
    }
  }
}

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

Definition at line 606 of file G4IntraNucleiCascader.cc.

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

Referenced by collide(), and rescatter().

                                                                 {
  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);
}

G4bool G4IntraNucleiCascader::finishCascade

(

)

[protected]

Definition at line 457 of file G4IntraNucleiCascader.cc.

References G4CollisionOutput::acceptable(), G4CascadeRecoilMaker::addExcitonConfiguration(), G4CollisionOutput::addOutgoingParticle(), G4CollisionOutput::addOutgoingParticles(), G4CollisionOutput::addRecoilFragment(), 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, G4CascadeRecoilMaker::makeRecoilFragment(), G4CollisionOutput::numberOfOutgoingParticles(), G4CollisionOutput::printCollisionOutput(), G4CollisionOutput::setOnShell(), G4CascadeRecoilMaker::setRecoilExcitation(), G4CollisionOutput::setVerboseLevel(), G4CascadeCoalescence::setVerboseLevel(), G4VCascadeCollider::verboseLevel, and G4CascadeRecoilMaker::wholeEvent().

Referenced by collide(), and rescatter().

                                            {
  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;
}

void G4IntraNucleiCascader::generateCascade

(

)

[protected]

Definition at line 336 of file G4IntraNucleiCascader.cc.

References G4CollisionOutput::addOutgoingParticle(), G4CascadeRecoilMaker::collide(), G4NucleiModel::empty(), G4cout, G4endl, G4UniformRand, G4NucleiModel::generateParticleFate(), G4InteractionCase::getBullet(), G4InuclParticle::getCharge(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMass(), G4NucleiModel::getNumberOfNeutrons(), G4NucleiModel::getNumberOfProtons(), G4CollisionOutput::getOutgoingParticles(), G4CascadeRecoilMaker::getRecoilA(), G4InteractionCase::getTarget(), G4NucleiModel::getTypesOfNucleonsInvolved(), G4InuclNuclei::getZ(), G4ExitonConfiguration::incrementHoles(), G4CascadeColliderBase::interCase, processTrappedParticle(), G4NucleiModel::stillInside(), G4VCascadeCollider::verboseLevel, and G4NucleiModel::worthToPropagate().

Referenced by collide(), and rescatter().

                                            {
  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
}

G4bool G4IntraNucleiCascader::initialize	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target
	)			[protected]

Definition at line 227 of file G4IntraNucleiCascader.cc.

References G4InuclSpecialFunctions::G4cbrt(), G4cerr, G4cout, G4endl, G4NucleiModel::generateModel(), G4InuclNuclei::getA(), G4InteractionCase::getBullet(), G4InuclParticle::getMomentum(), G4InteractionCase::getTarget(), G4InuclNuclei::getZ(), G4CascadeColliderBase::interCase, G4InteractionCase::set(), G4CascadeRecoilMaker::setTolerance(), and G4VCascadeCollider::verboseLevel.

Referenced by collide(), and rescatter().

                                                                  {
  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;
}

void G4IntraNucleiCascader::newCascade

(

G4int

itry

)

[protected]

Definition at line 279 of file G4IntraNucleiCascader.cc.

References G4ExitonConfiguration::clear(), G4InteractionCase::code(), G4cout, G4endl, G4CascadeColliderBase::interCase, G4CollisionOutput::reset(), G4NucleiModel::reset(), and G4VCascadeCollider::verboseLevel.

Referenced by collide(), and rescatter().

                                                 {
  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
}

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

Definition at line 648 of file G4IntraNucleiCascader.cc.

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

Referenced by rescatter().

                                                                            {
  if (verboseLevel > 1)
    G4cout << " >>> G4IntraNucleiCascader::preloadCascade" << G4endl;

  copyWoundedNucleus(theNucleus);       // Update interacted nucleon counts
  copySecondaries(theSecondaries);      // Copy original to internal list
}

void G4IntraNucleiCascader::processSecondary

(

const G4KineticTrack *

aSecondary

)

[protected]

Definition at line 712 of file G4IntraNucleiCascader.cc.

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

Referenced by copySecondaries().

                                                                         {
  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;
}

void G4IntraNucleiCascader::processTrappedParticle

(

const G4CascadParticle &

trapped

)

[protected]

Definition at line 787 of file G4IntraNucleiCascader.cc.

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

Referenced by generateCascade().

                                                        {
  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);
}

void G4IntraNucleiCascader::releaseSecondary

(

const G4KineticTrack *

aSecondary

)

[protected]

Definition at line 753 of file G4IntraNucleiCascader.cc.

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

Referenced by processSecondary().

                                                                         {
  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;
  }
}

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

Reimplemented from G4CascadeColliderBase.

Definition at line 206 of file G4IntraNucleiCascader.cc.

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

Referenced by G4InuclCollider::rescatter().

                                                                       {
  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);
}

void G4IntraNucleiCascader::setupCascade

(

)

[protected]

Definition at line 296 of file G4IntraNucleiCascader.cc.

References G4CollisionOutput::addOutgoingParticles(), G4InuclElementaryParticle::baryon(), G4cout, G4endl, G4InuclNuclei::getA(), G4InuclParticle::getCharge(), G4InuclNuclei::getZ(), G4InteractionCase::hadNucleus(), G4ExitonConfiguration::incrementHoles(), G4ExitonConfiguration::incrementQP(), G4NucleiModel::initializeCascad(), G4CascadeColliderBase::interCase, G4InuclSpecialFunctions::inuclRndm(), and G4VCascadeCollider::verboseLevel.

Referenced by collide().

                                         {
  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 ...
}

void G4IntraNucleiCascader::setVerboseLevel

(

G4int

verbose = 0

)

[virtual]

Reimplemented from G4CascadeColliderBase.

Definition at line 177 of file G4IntraNucleiCascader.cc.

References G4VCascadeCollider::setVerboseLevel(), G4NucleiModel::setVerboseLevel(), and G4CascadeColliderBase::setVerboseLevel().

Referenced by G4InuclCollider::setVerboseLevel().

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

---

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

• G4IntraNucleiCascader.hh
• G4IntraNucleiCascader.cc

---