#include <G4INCLProjectileRemnant.hh>

Inheritance diagram for G4INCL::ProjectileRemnant:

Public Member Functions
	ProjectileRemnant (ParticleSpecies const species, const G4double kineticEnergy)

	~ProjectileRemnant ()

void	reset ()
	Reset the projectile remnant to the state at the beginning of the cascade.

void	removeParticle (Particle *const p, const G4double theProjectileCorrection)
	Remove a nucleon from the projectile remnant.

ParticleList	addDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant.

ParticleList	addMostDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant.

void	deleteStoredComponents ()
	Clear the stored projectile components and delete the particles.

void	clearStoredComponents ()
	Clear the stored projectile components.

void	clearEnergyLevels ()
	Clear the stored energy levels.

G4double	computeExcitationEnergy (const long exceptID) const
	Compute the excitation energy.

EnergyLevels	getPresentEnergyLevels (const long exceptID) const

void	storeComponents ()
	Store the projectile components.

G4int	getNumberStoredComponents () const
	Get the number of the stored components.

void	storeEnergyLevels ()
	Store the energy levels.

Public Member Functions inherited from G4INCL::Cluster
	Cluster (const G4int Z, const G4int A, const G4bool createParticleSampler=true)
	Standard Cluster constructor.

template<class Iterator >
	Cluster (Iterator begin, Iterator end)

virtual	~Cluster ()

	Cluster (const Cluster &rhs)
	Copy constructor.

Cluster &	operator= (const Cluster &rhs)
	Assignment operator.

void	swap (Cluster &rhs)
	Helper method for the assignment operator.

ParticleSpecies	getSpecies () const
	Get the particle species.

void	deleteParticles ()

void	clearParticles ()

void	setZ (const G4int Z)
	Set the charge number of the cluster.

void	setA (const G4int A)
	Set the mass number of the cluster.

G4double	getExcitationEnergy () const
	Get the excitation energy of the cluster.

void	setExcitationEnergy (const G4double e)
	Set the excitation energy of the cluster.

virtual G4double	getTableMass () const
	Get the real particle mass.

ParticleList const &	getParticles () const

void	removeParticle (Particle *const p)
	Remove a particle from the cluster components.

void	addParticle (Particle *const p)

void	addParticles (ParticleList const &pL)
	Add a list of particles to the cluster.

ParticleList	getParticleList () const
	Returns the list of particles that make up the cluster.

std::string	print () const

virtual void	initializeParticles ()
	Initialise the NuclearDensity pointer and sample the particles.

void	internalBoostToCM ()
	Boost to the CM of the component particles.

void	putParticlesOffShell ()
	Put the cluster components off shell.

void	setPosition (const ThreeVector &position)
	Set the position of the cluster.

void	boost (const ThreeVector &aBoostVector)
	Boost the cluster with the indicated velocity.

void	freezeInternalMotion ()
	Freeze the internal motion of the particles.

virtual void	rotate (const G4double angle, const ThreeVector &axis)
	Rotate position and momentum of all the particles.

virtual void	makeProjectileSpectator ()
	Make all the components projectile spectators, too.

virtual void	makeTargetSpectator ()
	Make all the components target spectators, too.

virtual void	makeParticipant ()
	Make all the components participants, too.

ThreeVector const &	getSpin () const
	Get the spin of the nucleus.

void	setSpin (const ThreeVector &j)
	Set the spin of the nucleus.

G4INCL::ThreeVector	getAngularMomentum () const
	Get the total angular momentum (orbital + spin)

Public Member Functions inherited from G4INCL::Particle
	Particle ()

	Particle (ParticleType t, G4double energy, ThreeVector momentum, ThreeVector position)

	Particle (ParticleType t, ThreeVector momentum, ThreeVector position)

virtual	~Particle ()

	Particle (const Particle &rhs)
	Copy constructor.

Particle &	operator= (const Particle &rhs)
	Assignment operator.

G4INCL::ParticleType	getType () const

virtual G4INCL::ParticleSpecies	getSpecies () const
	Get the particle species.

void	setType (ParticleType t)

G4bool	isNucleon () const

ParticipantType	getParticipantType () const

void	setParticipantType (ParticipantType const p)

G4bool	isParticipant () const

G4bool	isTargetSpectator () const

G4bool	isProjectileSpectator () const

virtual void	makeParticipant ()

virtual void	makeTargetSpectator ()

virtual void	makeProjectileSpectator ()

G4bool	isPion () const
	Is this a pion?

G4bool	isResonance () const
	Is it a resonance?

G4bool	isDelta () const
	Is it a Delta?

G4int	getA () const
	Returns the baryon number.

G4int	getZ () const
	Returns the charge number.

G4double	getBeta () const

ThreeVector	boostVector () const

void	boost (const ThreeVector &aBoostVector)

void	lorentzContract (const ThreeVector &aBoostVector, const ThreeVector &refPos)
	Lorentz-contract the particle position around some center.

G4double	getMass () const
	Get the cached particle mass.

G4double	getINCLMass () const
	Get the INCL particle mass.

virtual G4double	getTableMass () const
	Get the tabulated particle mass.

G4double	getRealMass () const
	Get the real particle mass.

void	setRealMass ()
	Set the mass of the Particle to its real mass.

void	setTableMass ()
	Set the mass of the Particle to its table mass.

void	setINCLMass ()
	Set the mass of the Particle to its table mass.

G4double	getEmissionQValueCorrection (const G4int AParent, const G4int ZParent) const
	Computes correction on the emission Q-value.

G4double	getTransferQValueCorrection (const G4int AFrom, const G4int ZFrom, const G4int ATo, const G4int ZTo) const
	Computes correction on the transfer Q-value.

G4double	getInvariantMass () const
	Get the the particle invariant mass.

G4double	getKineticEnergy () const
	Get the particle kinetic energy.

G4double	getPotentialEnergy () const
	Get the particle potential energy.

void	setPotentialEnergy (G4double v)
	Set the particle potential energy.

G4double	getEnergy () const

void	setMass (G4double mass)

void	setEnergy (G4double energy)

const G4INCL::ThreeVector &	getMomentum () const

virtual G4INCL::ThreeVector	getAngularMomentum () const

virtual void	setMomentum (const G4INCL::ThreeVector &momentum)

const G4INCL::ThreeVector &	getPosition () const

virtual void	setPosition (const G4INCL::ThreeVector &position)

G4double	getHelicity ()

void	setHelicity (G4double h)

void	propagate (G4double step)

G4int	getNumberOfCollisions () const
	Return the number of collisions undergone by the particle.

void	setNumberOfCollisions (G4int n)
	Set the number of collisions undergone by the particle.

void	incrementNumberOfCollisions ()
	Increment the number of collisions undergone by the particle.

G4int	getNumberOfDecays () const
	Return the number of decays undergone by the particle.

void	setNumberOfDecays (G4int n)
	Set the number of decays undergone by the particle.

void	incrementNumberOfDecays ()
	Increment the number of decays undergone by the particle.

void	setOutOfWell ()
	Mark the particle as out of its potential well.

G4bool	isOutOfWell () const
	Check if the particle is out of its potential well.

void	setEmissionTime (G4double t)

G4double	getEmissionTime ()

ThreeVector	getTransversePosition () const
	Transverse component of the position w.r.t. the momentum.

ThreeVector	getLongitudinalPosition () const
	Longitudinal component of the position w.r.t. the momentum.

const ThreeVector &	adjustMomentumFromEnergy ()
	Rescale the momentum to match the total energy.

G4double	adjustEnergyFromMomentum ()
	Recompute the energy to match the momentum.

G4bool	isInList (ParticleList const &l) const
	Check if the particle belongs to a given list.

G4bool	isCluster () const

void	setFrozenMomentum (const ThreeVector &momentum)
	Set the frozen particle momentum.

void	setFrozenEnergy (const G4double energy)
	Set the frozen particle momentum.

ThreeVector	getFrozenMomentum () const
	Get the frozen particle momentum.

G4double	getFrozenEnergy () const
	Get the frozen particle momentum.

ThreeVector	getPropagationVelocity () const
	Get the propagation velocity of the particle.

void	freezePropagation ()
	Freeze particle propagation.

void	thawPropagation ()
	Unfreeze particle propagation.

virtual void	rotate (const G4double angle, const ThreeVector &axis)
	Rotate the particle position and momentum.

std::string	print () const

std::string	dump () const

long	getID () const

ParticleList const *	getParticles () const

Additional Inherited Members
Protected Member Functions inherited from G4INCL::Particle
void	swap (Particle &rhs)
	Helper method for the assignment operator.

Protected Attributes inherited from G4INCL::Cluster
ParticleList	particles

G4double	theExcitationEnergy

ThreeVector	theSpin

ParticleSampler *	theParticleSampler

Protected Attributes inherited from G4INCL::Particle
G4int	theZ

G4int	theA

ParticipantType	theParticipantType

G4INCL::ParticleType	theType

G4double	theEnergy

G4double *	thePropagationEnergy

G4double	theFrozenEnergy

G4INCL::ThreeVector	theMomentum

G4INCL::ThreeVector *	thePropagationMomentum

G4INCL::ThreeVector	theFrozenMomentum

G4INCL::ThreeVector	thePosition

G4int	nCollisions

G4int	nDecays

G4double	thePotentialEnergy

long	ID

Detailed Description

Definition at line 61 of file G4INCLProjectileRemnant.hh.

Constructor & Destructor Documentation

◆ ProjectileRemnant()

G4INCL::ProjectileRemnant::ProjectileRemnant	(	ParticleSpecies const	species,
		const G4double	kineticEnergy
	)

inline

Definition at line 67 of file G4INCLProjectileRemnant.hh.

      : Cluster(species.theZ, species.theA) {
 
      // Use the table mass
      setTableMass();
 
      // Set the kinematics
      const G4double projectileMass = getMass();
      const G4double energy = kineticEnergy + projectileMass;
      const G4double momentumZ = std::sqrt(energy*energy - projectileMass*projectileMass);
 
      // Initialise the particles
      initializeParticles();
      internalBoostToCM();
      putParticlesOffShell();
 
      // Store the energy levels of the ProjectileRemnant (used to compute its
      // excitation energy)
      storeEnergyLevels();
 
      // Boost the whole thing
      const ThreeVector aBoostVector = ThreeVector(0.0, 0.0, momentumZ / energy);
      boost(-aBoostVector);
 
      // Freeze the internal motion of the particles
      freezeInternalMotion();
 
      // Set as projectile spectator
      makeProjectileSpectator();
    }

◆ ~ProjectileRemnant()

G4INCL::ProjectileRemnant::~ProjectileRemnant ( )

inline

Definition at line 98 of file G4INCLProjectileRemnant.hh.

                         {
      deleteStoredComponents();
      clearEnergyLevels();
    }

Member Function Documentation

◆ addDynamicalSpectators()

ParticleList G4INCL::ProjectileRemnant::addDynamicalSpectators ( ParticleList pL )

Add back dynamical spectators to the projectile remnant.

Try to add the dynamical spectators back to the projectile remnant. Refuse to do so if this leads to a negative projectile excitation energy.

Return a list of rejected dynamical spectators.

Definition at line 125 of file G4INCLProjectileRemnant.cc.

                                                                        {
    // Try as hard as possible to add back all the dynamical spectators.
    // Don't add spectators that lead to negative excitation energies, but
    // iterate over the spectators as many times as possible, until
    // absolutely sure that all of them were rejected.
    unsigned int accepted;
    do {
      accepted = 0;
      ParticleList toBeAdded = pL;
      for(ParticleIter p=toBeAdded.begin(); p!=toBeAdded.end(); ++p) {
        G4bool isAccepted = addDynamicalSpectator(*p);
        if(isAccepted) {
          pL.remove(*p);
          accepted++;
        }
      }
    } while(accepted > 0);
    return pL;
  }

◆ addMostDynamicalSpectators()

ParticleList G4INCL::ProjectileRemnant::addMostDynamicalSpectators ( ParticleList pL )

Add back dynamical spectators to the projectile remnant.

Try as hard as possible to add back all the dynamical spectators. Don't add spectators that lead to negative excitation energies. Start by adding all of them, and repeatedly remove the most troublesome one until the excitation energy becomes non-negative.

Return a list of rejected dynamical spectators.

Definition at line 145 of file G4INCLProjectileRemnant.cc.

                                                                            {
    // Try as hard as possible to add back all the dynamical spectators.
    // Don't add spectators that lead to negative excitation energies. Start by
    // adding all of them, and repeatedly remove the most troublesome one until
    // the excitation energy becomes non-negative.
 
    // Put all the spectators in the projectile
    ThreeVector theNewMomentum = theMomentum;
    G4double theNewEnergy = theEnergy;
    G4int theNewA = theA;
    G4int theNewZ = theZ;
    for(ParticleIter p=pL.begin(); p!=pL.end(); ++p) {
// assert((*p)->isNucleon());
      // Add the initial (off-shell) momentum and energy to the projectile remnant
      theNewMomentum += getStoredMomentum(*p);
      theNewEnergy += (*p)->getEnergy();
      theNewA += (*p)->getA();
      theNewZ += (*p)->getZ();
    }
 
    // Check that the excitation energy of the new projectile remnant is non-negative
    const G4double theNewMass = ParticleTable::getTableMass(theNewA,theNewZ);
    const G4double theNewInvariantMassSquared = theNewEnergy*theNewEnergy-theNewMomentum.mag2();
 
    G4bool positiveExcitationEnergy = false;
    if(theNewInvariantMassSquared>=0.) {
      const G4double theNewInvariantMass = std::sqrt(theNewInvariantMassSquared);
      positiveExcitationEnergy = (theNewInvariantMass-theNewMass>-1.e-5);
    }
 
    // Keep removing nucleons from the projectile remnant until we achieve a
    // non-negative excitation energy.
    ParticleList rejected;
    while(!positiveExcitationEnergy && !pL.empty()) {
      G4double maxExcitationEnergy = -1.E30;
      ParticleList::iterator best = pL.end();
      ThreeVector bestMomentum;
      G4double bestEnergy = -1.;
      G4int bestA = -1, bestZ = -1;
      for(ParticleList::iterator p=pL.begin(); p!=pL.end(); ++p) {
        // Subtract the initial (off-shell) momentum and energy from the new
        // projectile remnant
        const ThreeVector theNewerMomentum = theNewMomentum - getStoredMomentum(*p);
        const G4double theNewerEnergy = theNewEnergy - (*p)->getEnergy();
        const G4int theNewerA = theNewA - (*p)->getA();
        const G4int theNewerZ = theNewZ - (*p)->getZ();
 
        const G4double theNewerMass = ParticleTable::getTableMass(theNewerA,theNewerZ);
        const G4double theNewerInvariantMassSquared = theNewerEnergy*theNewerEnergy-theNewerMomentum.mag2();
 
        if(theNewerInvariantMassSquared>=-1.e-5) {
          const G4double theNewerInvariantMass = std::sqrt(std::max(0.,theNewerInvariantMassSquared));
          const G4double theNewerExcitationEnergy = theNewerInvariantMass-theNewerMass;
          // Pick the nucleon that maximises the excitation energy of the
          // ProjectileRemnant
          if(theNewerExcitationEnergy>maxExcitationEnergy) {
            best = p;
            maxExcitationEnergy = theNewerExcitationEnergy;
            bestMomentum = theNewerMomentum;
            bestEnergy = theNewerEnergy;
            bestA = theNewerA;
            bestZ = theNewerZ;
          }
        }
      }
 
      // If we couldn't even calculate the excitation energy, fail miserably
      if(best==pL.end())
        return pL;
 
      rejected.push_back(*best);
      pL.erase(best);
      theNewMomentum = bestMomentum;
      theNewEnergy = bestEnergy;
      theNewA = bestA;
      theNewZ = bestZ;
 
      if(maxExcitationEnergy>0.) {
        // Stop here
        positiveExcitationEnergy = true;
      }
    }
 
    // Add the accepted participants to the projectile remnant
    for(ParticleIter p=pL.begin(); p!=pL.end(); ++p) {
      particles.push_back(*p);
    }
    theA = theNewA;
    theZ = theNewZ;
    theMomentum = theNewMomentum;
    theEnergy = theNewEnergy;
 
    return rejected;
  }

◆ clearEnergyLevels()

void G4INCL::ProjectileRemnant::clearEnergyLevels ( )

inline

Clear the stored energy levels.

Definition at line 147 of file G4INCLProjectileRemnant.hh.

                             {
      theInitialEnergyLevels.clear();
      theGroundStateEnergies.clear();
    }

Referenced by ~ProjectileRemnant().

◆ clearStoredComponents()

void G4INCL::ProjectileRemnant::clearStoredComponents ( )

inline

Clear the stored projectile components.

Definition at line 142 of file G4INCLProjectileRemnant.hh.

                                 {
      storedComponents.clear();
    }

Referenced by deleteStoredComponents().

◆ computeExcitationEnergy()

G4double G4INCL::ProjectileRemnant::computeExcitationEnergy ( const long exceptID ) const

Compute the excitation energy.

Compute the excitation energy of the projectile-like remnant as the difference between the initial and the present configuration. This follows the algorithm proposed by A. Boudard in INCL4.2-HI, as implemented in Geant4.

Returns: the excitation energy

Definition at line 270 of file G4INCLProjectileRemnant.cc.

                                                                               {
    // The ground-state energy is the sum of the A smallest initial projectile
    // energies.
    // For the last nucleon, return 0 so that the algorithm will just put it on
    // shell.
    if(theA==1)
      return 0.;
 
    const G4double groundState = theGroundStateEnergies.at(theA-2);
 
    // Compute the sum of the presently occupied energy levels
    const EnergyLevels theEnergyLevels = getPresentEnergyLevels(exceptID);
    const G4double excitedState = std::accumulate(
        theEnergyLevels.begin(),
        theEnergyLevels.end(),
        0.);
 
    return excitedState-groundState;
  }

Referenced by G4INCL::ParticleEntryChannel::getFinalState().

◆ deleteStoredComponents()

void G4INCL::ProjectileRemnant::deleteStoredComponents ( )

inline

Clear the stored projectile components and delete the particles.

Definition at line 135 of file G4INCLProjectileRemnant.hh.

                                  {
      for(std::map<long,Particle*>::const_iterator p=storedComponents.begin(); p!=storedComponents.end(); ++p)
        delete p->second;
      clearStoredComponents();
    }

Referenced by ~ProjectileRemnant().

◆ getNumberStoredComponents()

G4int G4INCL::ProjectileRemnant::getNumberStoredComponents ( ) const

inline

Get the number of the stored components.

Definition at line 185 of file G4INCLProjectileRemnant.hh.

                                            {
      return storedComponents.size();
    }

Referenced by G4INCL::Nucleus::finalizeProjectileRemnant().

◆ getPresentEnergyLevels()

EnergyLevels G4INCL::ProjectileRemnant::getPresentEnergyLevels ( const long exceptID ) const

inline

Definition at line 163 of file G4INCLProjectileRemnant.hh.

                                                                   {
      EnergyLevels theEnergyLevels;
      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        if((*p)->getID()!=exceptID) {
          EnergyLevelMap::const_iterator i = theInitialEnergyLevels.find((*p)->getID());
// assert(i!=theInitialEnergyLevels.end());
          theEnergyLevels.push_back(i->second);
        }
      }
// assert(theEnergyLevels.size()==particles.size()-1);
      return theEnergyLevels;
    }

Referenced by computeExcitationEnergy().

◆ removeParticle()

void G4INCL::ProjectileRemnant::removeParticle	(	Particle *const	p,
		const G4double	theProjectileCorrection
	)

Remove a nucleon from the projectile remnant.

Parameters

p	particle to be removed
theProjectileCorrection	correction to be given to the projectile total energy

Definition at line 80 of file G4INCLProjectileRemnant.cc.

                                                                                                   {
// assert(p->isNucleon());
 
    DEBUG("The following Particle is about to be removed from the ProjectileRemnant:"
        << std::endl << p->print()
        << "theProjectileCorrection=" << theProjectileCorrection << std::endl);
    // Update A, Z, momentum and energy of the projectile remnant
    theA -= p->getA();
    theZ -= p->getZ();
 
    ThreeVector const &oldMomentum = p->getMomentum();
    const G4double oldEnergy = p->getEnergy();
    Cluster::removeParticle(p);
 
#if !defined(NDEBUG) && !defined(INCLXX_IN_GEANT4_MODE)
    ThreeVector theTotalMomentum;
    G4double theTotalEnergy = 0.;
    const G4double theThreshold = 0.1;
#endif
 
    if(getA()>0) { // if there are any particles left
// assert((unsigned int)getA()==particles.size());
 
      const G4double theProjectileCorrectionPerNucleon = theProjectileCorrection / particles.size();
 
      // Update the kinematics of the components
      for(ParticleIter i=particles.begin(); i!=particles.end(); ++i) {
        (*i)->setEnergy((*i)->getEnergy() + theProjectileCorrectionPerNucleon);
        (*i)->setMass((*i)->getInvariantMass());
#if !defined(NDEBUG) && !defined(INCLXX_IN_GEANT4_MODE)
        theTotalMomentum += (*i)->getMomentum();
        theTotalEnergy += (*i)->getEnergy();
#endif
      }
    }
 
    theMomentum -= oldMomentum;
    theEnergy -= oldEnergy - theProjectileCorrection;
 
// assert(std::abs((theTotalMomentum-theMomentum).mag())<theThreshold);
// assert(std::abs(theTotalEnergy-theEnergy)<theThreshold);
    DEBUG("After Particle removal, the ProjectileRemnant looks like this:"
        << std::endl << print());
  }

Referenced by G4INCL::ParticleEntryChannel::getFinalState().

◆ reset()

void G4INCL::ProjectileRemnant::reset ( )

Reset the projectile remnant to the state at the beginning of the cascade.

Definition at line 56 of file G4INCLProjectileRemnant.cc.

                                {
    deleteParticles();
    thePosition = ThreeVector();
    theMomentum = ThreeVector();
    theEnergy = 0.0;
    thePotentialEnergy = 0.0;
    theA = 0;
    theZ = 0;
    nCollisions = 0;
 
    for(std::map<long, Particle*>::const_iterator i=storedComponents.begin(); i!=storedComponents.end(); ++i) {
      Particle *p = new Particle(*(i->second));
      EnergyLevelMap::iterator energyIter = theInitialEnergyLevels.find(i->first);
// assert(energyIter!=theInitialEnergyLevels.end());
      const G4double energyLevel = energyIter->second;
      theInitialEnergyLevels.erase(energyIter);
      theInitialEnergyLevels[p->getID()] = energyLevel;
      addParticle(p);
    }
    thePosition /= theA;
    setTableMass();
    DEBUG("ProjectileRemnant object was reset:" << std::endl << print());
  }

◆ storeComponents()

void G4INCL::ProjectileRemnant::storeComponents ( )

inline

Store the projectile components.

Definition at line 177 of file G4INCLProjectileRemnant.hh.

                           {
      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        // Store the particles (needed for forced CN)
        storedComponents[(*p)->getID()]=new Particle(**p);
      }
    }

Referenced by G4INCL::StandardPropagationModel::shootComposite().

◆ storeEnergyLevels()

void G4INCL::ProjectileRemnant::storeEnergyLevels ( )

inline

Store the energy levels.

Definition at line 190 of file G4INCLProjectileRemnant.hh.

                             {
      EnergyLevels energies;
 
      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        const G4double theCMEnergy = (*p)->getEnergy();
        // Store the CM energy in the EnergyLevels map
        theInitialEnergyLevels[(*p)->getID()] = theCMEnergy;
        energies.push_back(theCMEnergy);
      }
 
      std::sort(energies.begin(), energies.end());
// assert(energies.size()==(unsigned int)theA);
      theGroundStateEnergies.resize(energies.size());
      // Compute the partial sums of the CM energies -- they are our reference
      // ground-state energies for any number of nucleons
      std::partial_sum(energies.begin(), energies.end(), theGroundStateEnergies.begin());
    }

Referenced by ProjectileRemnant().

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ProjectileRemnant()

◆ ~ProjectileRemnant()

Member Function Documentation

◆ addDynamicalSpectators()

◆ addMostDynamicalSpectators()

◆ clearEnergyLevels()

◆ clearStoredComponents()

◆ computeExcitationEnergy()

◆ deleteStoredComponents()

◆ getNumberStoredComponents()

◆ getPresentEnergyLevels()

◆ removeParticle()

◆ reset()

◆ storeComponents()

◆ storeEnergyLevels()