G4FermiBreakUpAN Class Reference

#include <G4FermiBreakUpAN.hh>

Inheritance diagram for G4FermiBreakUpAN:

Public Member Functions
	G4FermiBreakUpAN (G4int verbosity=0)
	~G4FermiBreakUpAN () override=default
void	Initialise () override
G4bool	IsApplicable (G4int Z, G4int A, G4double eexc) const override
void	BreakFragment (G4FragmentVector *results, G4Fragment *theNucleus) override
std::vector< G4FermiParticle >	BreakItUp (const G4FermiParticle &nucleus) const
Public Member Functions inherited from G4VFermiBreakUp
	G4VFermiBreakUp ()
virtual	~G4VFermiBreakUp ()=default
	G4VFermiBreakUp (const G4VFermiBreakUp &right)=delete
const G4VFermiBreakUp &	operator= (const G4VFermiBreakUp &right)=delete
G4bool	operator== (const G4VFermiBreakUp &right) const =delete
G4bool	operator!= (const G4VFermiBreakUp &right) const =delete
void	SetVerbose (G4int val)

Additional Inherited Members
Protected Attributes inherited from G4VFermiBreakUp
G4int	verbose {0}

Detailed Description

Definition at line 48 of file G4FermiBreakUpAN.hh.

Constructor & Destructor Documentation

G4FermiBreakUpAN()

G4FermiBreakUpAN::G4FermiBreakUpAN ( G4int verbosity = 0 )

explicit

Definition at line 162 of file G4FermiBreakUpAN.cc.

  : splits_(G4FermiAtomicMass(MAX_A)),
    secID_(G4PhysicsModelCatalog::GetModelID("model_G4FermiBreakUpVI")),
    verbosity_(verbosity)
{}

~G4FermiBreakUpAN()

G4FermiBreakUpAN::~G4FermiBreakUpAN ( )

overridedefault

Member Function Documentation

BreakFragment()

void G4FermiBreakUpAN::BreakFragment ( G4FragmentVector * results, G4Fragment * theNucleus )

overridevirtual

Reimplemented from G4VFermiBreakUp.

Definition at line 239 of file G4FermiBreakUpAN.cc.

{
  if (theNucleus == nullptr || results == nullptr) {
    G4ExceptionDescription ed;
    ed << "G4Fragment or result G4FragmentVector is not set in FermiBreakUp";
    G4Exception("G4FermiBreakUpAN::BreakFragment()", "Fermi003", FatalErrorInArgument, ed);
    return;
  }
 
  const auto particle =
    G4FermiParticle(G4FermiAtomicMass(theNucleus->GetA_asInt()),
                    G4FermiChargeNumber(theNucleus->GetZ_asInt()), theNucleus->GetMomentum());
  const auto fragments = BreakItUp(particle);
 
  // decay impossible
  if (fragments.size() <= 1) { return; }
 
  const auto creationTime = theNucleus->GetCreationTime();
  // primary should be deleted
  delete theNucleus;
  
  for (const auto& fragment : fragments) {
    auto fr = new G4Fragment(static_cast<G4int>(fragment.GetAtomicMass()),
                             static_cast<G4int>(fragment.GetChargeNumber()),
                             fragment.GetMomentum());
    results->push_back(fr);
    fr->SetCreationTime(creationTime);
    fr->SetCreatorModelID(secID_);
  }
}

BreakItUp()

std::vector< G4FermiParticle > G4FermiBreakUpAN::BreakItUp

(

const G4FermiParticle &

nucleus

)

const

Definition at line 168 of file G4FermiBreakUpAN.cc.

{
  FERMI_LOG_DEBUG(verbosity_, "Breaking up particle: " << particle);
 
  if (particle.GetExcitationEnergy() < 0.) {
    FERMI_LOG_DEBUG(verbosity_, "G4FermiParticle is stable with excitation energy = "
            << particle.GetExcitationEnergy());
    return {particle};
  }
 
  const auto& splits = splits_.GetSplits(particle.GetAtomicMass(), particle.GetChargeNumber());
  FERMI_LOG_DEBUG(verbosity_,
          "Selecting Split for " << particle << " from " << splits.size() << " splits");
  if (splits.empty()) {
    FERMI_LOG_DEBUG(verbosity_, "No splits found");
    return {particle};
  }
 
  // get phase space weights for every split
  // we can't cache them, because calculations is probabilistic
  weights_.resize(splits.size());
  std::transform(splits.begin(), splits.end(), weights_.begin(),
                 [atomicMass = particle.GetAtomicMass(),
                  totalEnergy = particle.GetMomentum().m()](const auto& split) {
                   return G4FermiSplitter::DecayWeight(split, atomicMass, totalEnergy);
                 });
 
  if (std::all_of(weights_.begin(), weights_.end(), [](auto weight) { return weight == 0.; })) {
    FERMI_LOG_DEBUG(verbosity_, "Every split has zero weight");
    return {particle};
  }
 
  const auto& chosenSplit = splits[SampleWeightDistribution(weights_)];
  FERMI_LOG_DEBUG(verbosity_,
                  "From " << splits.size() << " splits chosen split: " << LogSplit(chosenSplit));
 
  return SplitToParticles(particle, chosenSplit);
}

Referenced by BreakFragment().

Initialise()

void G4FermiBreakUpAN::Initialise ( )

overridevirtual

Reimplemented from G4VFermiBreakUp.

Definition at line 207 of file G4FermiBreakUpAN.cc.

{
  if (G4NucleiProperties::GetNuclearMass(2, 0) <= 0.) {
    G4BaryonConstructor pCBar;
    pCBar.ConstructParticle();
  }
  G4FermiNucleiProperties::Instance().Initialize();
 
  {
    auto pool = G4FermiFragmentPoolAN::DefaultPoolANSource();
    pool.Initialize();
    G4FermiFragmentPoolAN::Instance().Initialize(pool);
  }
 
  // order is important here, we use G4FermiFragmentPool to create splits!
  splits_ = PossibleSplits();
  for (auto a = 1; a < MAX_A; ++a) {
    for (auto z = 0; z <= a; ++z) {
      const auto atomicMass = G4FermiAtomicMass(a);
      const auto chargeNumber = G4FermiChargeNumber(z);
 
      splits_.InsertSplits(atomicMass, chargeNumber,
                           G4FermiSplitter::GenerateSplits({atomicMass, chargeNumber}));
    }
  }
}

IsApplicable()

G4bool G4FermiBreakUpAN::IsApplicable ( G4int Z, G4int A, G4double eexc ) const

overridevirtual

Reimplemented from G4VFermiBreakUp.

Definition at line 234 of file G4FermiBreakUpAN.cc.

{
  return Z < MAX_Z && A < MAX_A;
}

---

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

• G4FermiBreakUpAN.hh
• G4FermiBreakUpAN.cc