smash::DynamicFluidizationFinder Class Reference

#include <dynamicfluidfinder.h>

Finder for dynamic fluidizations.

Loops through all particles and checks if they reach the energy density threshold. This happens at the end of every time step for all hadrons that participated in a fluidizable process. For string fragmentation products, fluidization happens only after the fraction of formation time of the particle, controlled by Formation_Time_Fraction.

Definition at line 32 of file dynamicfluidfinder.h.

Inheritance diagram for smash::DynamicFluidizationFinder:

Public Member Functions
	DynamicFluidizationFinder (const RectangularLattice< EnergyMomentumTensor > &lattice, const std::map< int32_t, double > &background, const InitialConditionParameters &ic_params)
	Construct finder for fluidization action. More...
ActionList	find_actions_in_cell (const ParticleList &search_list, double dt, double gcell_vol, const std::vector< FourVector > &beam_momentum) const override
	Find particles to fluidize, depending on the energy density around them. More...
ActionList	find_actions_with_neighbors (const ParticleList &, const ParticleList &, const double, const std::vector< FourVector > &) const override
	Ignore the neighbor search for fluidization. More...
ActionList	find_actions_with_surrounding_particles (const ParticleList &, const Particles &, double, const std::vector< FourVector > &) const override
	Ignore the surrounding searches for fluidization. More...
ActionList	find_final_actions (const Particles &search_list) const override
	Prepare corona particles left in the IC for the afterburner. More...
bool	above_threshold (const ParticleData &pdata) const
	Determine if fluidization condition is satisfied. More...
bool	is_process_fluidizable (const HistoryData &history) const
	Checks if a given process type is in fluidizable_processes_. More...
Public Member Functions inherited from smash::ActionFinderInterface
virtual	~ActionFinderInterface ()=default

Private Attributes
const RectangularLattice< EnergyMomentumTensor > &	energy_density_lattice_
	Lattice where energy momentum tensor is computed. More...
const std::map< int32_t, double > &	background_
	Background energy density at positions of particles, using the id as key. More...
const double	energy_density_threshold_ = smash_NaN<double>
	Minimum energy density surrounding the particle to fluidize it. More...
const double	min_time_ = smash_NaN<double>
	Minimum time (in lab frame) in fm to allow fluidization. More...
const double	max_time_ = smash_NaN<double>
	Maximum time (in lab frame) in fm to allow fluidization. More...
const double	formation_time_fraction_ = smash_NaN<double>
	Fraction of formation time after which a particles can fluidize. More...
const double	smearing_kernel_at_0_ = smash_NaN<double>
	Smearing kernel at the position of the particle of interest. More...
const int	fluid_cells_ = smash_NaN<int>
	Number of cells to interpolate the energy density. More...
const FluidizableProcessesBitSet	fluidizable_processes_
	Processes that create a fluidizable particle. More...
const bool	delay_initial_elastic_ = true
	Whether the first elastic interaction of an initial nucleon is fluidizable. More...
int	particles_in_core_ = 0
	Accumulated number of core particles. More...
double	energy_in_core_ = 0.
	Accumulated energy of core particles. More...

Constructor & Destructor Documentation

DynamicFluidizationFinder()

smash::DynamicFluidizationFinder::DynamicFluidizationFinder ( const RectangularLattice< EnergyMomentumTensor > &  lattice, const std::map< int32_t, double > &  background, const InitialConditionParameters &  ic_params  )

inline

Construct finder for fluidization action.

Parameters

[in]	lattice	Lattice used for the energy density interpolation
[in]	background	Background map between particle indices and the corresponding background energy density
[in]	ic_params	Parameters for dynamic fluidization

Note

energy_density_lattice and energy_density_background are both "in" parameters because the class stores references, but the values are non constant.

Definition at line 45 of file dynamicfluidfinder.h.

      : energy_density_lattice_{lattice},
        background_{background},
        energy_density_threshold_{ic_params.energy_density_threshold.value()},
        min_time_{ic_params.min_time.value()},
        max_time_{ic_params.max_time.value()},
        formation_time_fraction_{ic_params.formation_time_fraction.value()},
        smearing_kernel_at_0_{ic_params.smearing_kernel_at_0.value()},
        fluid_cells_{ic_params.num_fluid_cells.value()},
        fluidizable_processes_{ic_params.fluidizable_processes.value()},
        delay_initial_elastic_{ic_params.delay_initial_elastic.value()} {};

Member Function Documentation

find_actions_in_cell()

ActionList smash::DynamicFluidizationFinder::find_actions_in_cell ( const ParticleList &  search_list, double  dt, double  gcell_vol, const std::vector< FourVector > &  beam_momentum  ) const

overridevirtual

Find particles to fluidize, depending on the energy density around them.

Parameters

[in]	search_list	List of candidate particles to fluidize.
[in]	dt	Time step duration in fm.
[in]	gcell_vol	Volume of the grid cell in fm³,
[in]	beam_momentum	Unused.

Returns

List of fluidization actions that will happen at the corresponding formation time.

Implements smash::ActionFinderInterface.

Definition at line 19 of file dynamicfluidfinder.cc.

                                                                       {
  ActionList actions;
 
  for (const ParticleData &p : search_list) {
    const double t0 = p.position().x0();
    const double t_creation = p.begin_formation_time();
    const double t_end = t0 + dt;
    if (t_end < min_time_ || t0 > max_time_) {
      break;
    }
    if (p.is_core()) {
      continue;
    }
    const double fluidization_time =
        t_creation +
        formation_time_fraction_ * (p.formation_time() - t_creation);
    if (fluidization_time >= t_end) {
      continue;
    }
    if (!is_process_fluidizable(p.get_history())) {
      continue;
    }
    if (above_threshold(p)) {
      double time_until = (1 - p.xsec_scaling_factor() <= really_small)
                              ? 0
                              : std::max(fluidization_time - t0, 0.);
      actions.emplace_back(
          std::make_unique<FluidizationAction>(p, p, time_until));
    }
  }  // search_list loop
  return actions;
}

find_actions_with_neighbors()

ActionList smash::DynamicFluidizationFinder::find_actions_with_neighbors ( const ParticleList &  , const ParticleList &  , const double  , const std::vector< FourVector > &    ) const

inlineoverridevirtual

Ignore the neighbor search for fluidization.

Implements smash::ActionFinderInterface.

Definition at line 74 of file dynamicfluidfinder.h.

                                                    {
    return {};
  }

find_actions_with_surrounding_particles()

ActionList smash::DynamicFluidizationFinder::find_actions_with_surrounding_particles ( const ParticleList &  , const Particles &  , double  , const std::vector< FourVector > &    ) const

inlineoverridevirtual

Ignore the surrounding searches for fluidization.

Implements smash::ActionFinderInterface.

Definition at line 81 of file dynamicfluidfinder.h.

                                                    {
    return {};
  }

find_final_actions()

ActionList smash::DynamicFluidizationFinder::find_final_actions ( const Particles &  search_list ) const

overridevirtual

Prepare corona particles left in the IC for the afterburner.

• Remove core particles.
• Move corona particles back to their last interaction point so they start at the correct spacetime position for afterburner rescattering with hadrons sampled from the fluid.
• Do not modify spectators.

Parameters

[in]

search_list

All particles at the end of the simulation.

Returns

ActionList with removals and backpropagation steps.

Note

The backpropagation is encoded as two FreeForAll actions: remove the corona particle, then add it at the target spacetime point. This will appear in the Collisions output.

Implements smash::ActionFinderInterface.

Definition at line 113 of file dynamicfluidfinder.cc.

                                        {
  ActionList actions;
  const bool are_there_core_particles =
      std::any_of(search_list.begin(), search_list.end(),
                  [](const ParticleData &p) { return p.is_core(); });
  if (are_there_core_particles) {
    for (auto &p : search_list) {
      if (p.is_core()) {
        actions.emplace_back(std::make_unique<FreeforallAction>(
            ParticleList{p}, ParticleList{}, p.position().x0()));
        particles_in_core_++;
        energy_in_core_ += p.momentum()[0];
      }
    }
  } else {
    for (auto &original : search_list) {
      if (original.get_history().collisions_per_particle == 0) {
        // Spectators are not propagated back.
        continue;
      }
      const double t = original.position().x0();
      double corona_time = original.get_history().time_last_collision;
      if (t == corona_time) {
        continue;
      }
      // This prevents particles from decays or strings from ending up at the
      // same position
      corona_time += 0.01;
      const ThreeVector r = original.position().threevec() -
                            (t - corona_time) * original.velocity();
      ParticleData backpropagated{original.type()};
      backpropagated.set_4position(FourVector(corona_time, r));
      backpropagated.set_4momentum(original.momentum());
      // This is done so no further actions can be found for this particle
      backpropagated.set_formation_time(t);
      backpropagated.set_cross_section_scaling_factor(0.0);
      actions.emplace_back(std::make_unique<FreeforallAction>(
          ParticleList{original}, ParticleList{}, t));
      actions.emplace_back(std::make_unique<FreeforallAction>(
          ParticleList{}, ParticleList{backpropagated}, corona_time));
    }
    logg[LFluidization].info()
        << particles_in_core_ << " particles were part of the core with energy "
        << energy_in_core_ << " GeV.";
  }
  return actions;
}

above_threshold()

bool smash::DynamicFluidizationFinder::above_threshold

(

const ParticleData &

pdata

)

const

Determine if fluidization condition is satisfied.

Parameters

[in]

pdata

Particle to be checked for fluidization.

Returns

Whether energy density around pdata is high enough.

Definition at line 55 of file dynamicfluidfinder.cc.

                                     {
  EnergyMomentumTensor Tmunu;
  // value_at returns false if pdata is out of bounds
  const bool inside =
      energy_density_lattice_.value_at(pdata.position().threevec(), Tmunu);
  if (inside) {
    // If the particle is not in the map, the background evaluates to 0
    const double background =
        background_.count(pdata.id()) ? background_.at(pdata.id()) : 0;
    const double e_den_particles =
        Tmunu.boosted(Tmunu.landau_frame_4velocity())[0];
    if (e_den_particles + background >=
        energy_density_threshold_ + pdata.pole_mass() * smearing_kernel_at_0_) {
      logg[LFluidization].debug()
          << "Fluidize " << pdata.id() << " with " << e_den_particles << "+"
          << background << " GeV/fm^3 at " << pdata.position().x0()
          << " fm, formed at " << pdata.formation_time() << " fm";
      return true;
    }
  }
  return false;
}

is_process_fluidizable()

bool smash::DynamicFluidizationFinder::is_process_fluidizable

(

const HistoryData &

history

)

const

Checks if a given process type is in fluidizable_processes_.

In particular, initially sampled hadrons are not fluidizable and have ProcessType::None, which falls in the default case for the switch.

Returns

whether the process is fluidizable

Definition at line 79 of file dynamicfluidfinder.cc.

                                      {
  const ProcessType &type = history.process_type;
  if (is_string_soft_process(type)) {
    return fluidizable_processes_
        [IncludedFluidizableProcesses::From_SoftString];
  }
  switch (type) {
    case ProcessType::Elastic:
      if (history.collisions_per_particle == 1 && delay_initial_elastic_) {
        return false;
      }
      return fluidizable_processes_[IncludedFluidizableProcesses::From_Elastic];
    case ProcessType::Decay:
      return fluidizable_processes_[IncludedFluidizableProcesses::From_Decay];
    case ProcessType::TwoToOne:
    case ProcessType::TwoToTwo:
    case ProcessType::TwoToThree:
    case ProcessType::TwoToFour:
    case ProcessType::TwoToFive:
    case ProcessType::MultiParticleThreeMesonsToOne:
    case ProcessType::MultiParticleThreeToTwo:
    case ProcessType::MultiParticleFourToTwo:
    case ProcessType::MultiParticleFiveToTwo:
      return fluidizable_processes_
          [IncludedFluidizableProcesses::From_Inelastic];
    case ProcessType::StringHard:
      return fluidizable_processes_
          [IncludedFluidizableProcesses::From_HardString];
    default:
      return false;
  }
}

Member Data Documentation

energy_density_lattice_

const RectangularLattice<EnergyMomentumTensor>& smash::DynamicFluidizationFinder::energy_density_lattice_

private

Lattice where energy momentum tensor is computed.

Note

It must be a reference so that it can be updated outside the class, without creating a new Finder object.

Definition at line 129 of file dynamicfluidfinder.h.

background_

const std::map<int32_t, double>& smash::DynamicFluidizationFinder::background_

private

Background energy density at positions of particles, using the id as key.

Note

It is a reference so that it can be updated outside the class, e.g. by an external manager using SMASH as a library.

Definition at line 136 of file dynamicfluidfinder.h.

energy_density_threshold_

const double smash::DynamicFluidizationFinder::energy_density_threshold_ = smash_NaN<double>

private

Minimum energy density surrounding the particle to fluidize it.

Definition at line 138 of file dynamicfluidfinder.h.

min_time_

const double smash::DynamicFluidizationFinder::min_time_ = smash_NaN<double>

private

Minimum time (in lab frame) in fm to allow fluidization.

Definition at line 140 of file dynamicfluidfinder.h.

max_time_

const double smash::DynamicFluidizationFinder::max_time_ = smash_NaN<double>

private

Maximum time (in lab frame) in fm to allow fluidization.

Definition at line 142 of file dynamicfluidfinder.h.

formation_time_fraction_

const double smash::DynamicFluidizationFinder::formation_time_fraction_ = smash_NaN<double>

private

Fraction of formation time after which a particles can fluidize.

Definition at line 144 of file dynamicfluidfinder.h.

smearing_kernel_at_0_

const double smash::DynamicFluidizationFinder::smearing_kernel_at_0_ = smash_NaN<double>

private

Smearing kernel at the position of the particle of interest.

Definition at line 146 of file dynamicfluidfinder.h.

fluid_cells_

const int smash::DynamicFluidizationFinder::fluid_cells_ = smash_NaN<int>

private

Number of cells to interpolate the energy density.

Definition at line 148 of file dynamicfluidfinder.h.

fluidizable_processes_

const FluidizableProcessesBitSet smash::DynamicFluidizationFinder::fluidizable_processes_

private

Processes that create a fluidizable particle.

Definition at line 150 of file dynamicfluidfinder.h.

delay_initial_elastic_

const bool smash::DynamicFluidizationFinder::delay_initial_elastic_ = true

private

Whether the first elastic interaction of an initial nucleon is fluidizable.

Definition at line 152 of file dynamicfluidfinder.h.

particles_in_core_

int smash::DynamicFluidizationFinder::particles_in_core_ = 0

mutableprivate

Accumulated number of core particles.

Definition at line 155 of file dynamicfluidfinder.h.

energy_in_core_

double smash::DynamicFluidizationFinder::energy_in_core_ = 0.

mutableprivate

Accumulated energy of core particles.

Definition at line 157 of file dynamicfluidfinder.h.

---

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

• src/include/smash/dynamicfluidfinder.h
• src/dynamicfluidfinder.cc