smash::HyperSurfaceCrossActionsFinder Class Reference

#include <hypersurfacecrossingaction.h>

Finder for hypersurface crossing actions. Loops through all particles and checks if they cross the hypersurface during the next timestep.

Definition at line 61 of file hypersurfacecrossingaction.h.

Inheritance diagram for smash::HyperSurfaceCrossActionsFinder:

Collaboration diagram for smash::HyperSurfaceCrossActionsFinder:

Public Member Functions
	HyperSurfaceCrossActionsFinder (double tau)
	Construct hypersurfacecrossing action finder. More...
ActionList	find_actions_in_cell (const ParticleList &plist, double dt, const double, const std::vector< FourVector > &beam_momentum) const override
	Find the next hypersurface crossings for each particle that occur within the timestepless propagation. More...
ActionList	find_actions_with_neighbors (const ParticleList &, const ParticleList &, double, const std::vector< FourVector > &) const override
	Ignore the neighbor searches for hypersurface crossing. More...
ActionList	find_actions_with_surrounding_particles (const ParticleList &, const Particles &, double, const std::vector< FourVector > &) const override
	Ignore the surrounding searches for hypersurface crossing. More...
ActionList	find_final_actions (const Particles &, bool) const override
	No final actions for hypersurface crossing. More...
Public Member Functions inherited from smash::ActionFinderInterface
virtual	~ActionFinderInterface ()=default

Private Member Functions
bool	crosses_hypersurface (ParticleData &pdata_before_propagation, ParticleData &pdata_after_propagation, const double tau) const
	Determine whether particle crosses hypersurface within next timestep during propagation. More...
FourVector	coordinates_on_hypersurface (ParticleData &pdata_before_propagation, ParticleData &pdata_after_propagation, const double tau) const
	Find the coordinates where particle crosses hypersurface. More...

Private Attributes
const double	prop_time_
	Proper time of the hypersurface in fm. More...

Constructor & Destructor Documentation

HyperSurfaceCrossActionsFinder()

smash::HyperSurfaceCrossActionsFinder::HyperSurfaceCrossActionsFinder ( double  tau )

inlineexplicit

Construct hypersurfacecrossing action finder.

Parameters

[in]

tau

Proper time of the hypersurface. [fm]

Definition at line 67 of file hypersurfacecrossingaction.h.

: prop_time_{tau} {};

Member Function Documentation

find_actions_in_cell()

ActionList smash::HyperSurfaceCrossActionsFinder::find_actions_in_cell ( const ParticleList &  plist, double  dt, const double  , const std::vector< FourVector > &  beam_momentum  ) const

overridevirtual

Find the next hypersurface crossings for each particle that occur within the timestepless propagation.

Parameters

[in]	plist	List of all particles.
[in]	dt	Time until crossing can appear (until end of timestep). [fm]
[in]	beam_momentum	[GeV] List of beam momenta for each particle; only necessary for frozen Fermi motion necessary if frozen Fermi Motion is activated

Returns

List of all found wall crossings.

Implements smash::ActionFinderInterface.

Definition at line 50 of file hypersurfacecrossingaction.cc.

                                                      {
  std::vector<ActionPtr> actions;
 
  for (const ParticleData &p : plist) {
    ParticleData pdata_before_propagation = p;
    ParticleData pdata_after_propagation = p;  // Will receive updated position
    double t0 = p.position().x0();
    double t_end = t0 + dt;  // Time at the end of timestep
 
    // We don't want to remove particles before the nuclei have interacted
    // because those would not yet be part of the newly-created medium.
    if (t_end < 0.0) {
      continue;
    }
 
    // For frozen Fermi motion:
    // Fermi momenta are only applied if particles interact. The particle
    // properties p.velocity() and p.momentum() already contain the values
    // corrected by Fermi motion, but those particles that have not yet
    // interacted are propagated along the beam-axis with v = (0, 0, beam_v)
    // (and not with p.velocity()).
    // To identify the corresponding hypersurface crossings the finding for
    // those paricles without prior interactions has to be performed with
    // v = vbeam instead of p.velcocity().
    // Note: The beam_momentum vector is empty in case frozen Fermi motion is
    // not applied.
    const bool no_prior_interactions =
        (static_cast<uint64_t>(p.id()) <                  // particle from
         static_cast<uint64_t>(beam_momentum.size())) &&  // initial nucleus
        (p.get_history().collisions_per_particle == 0);
    ThreeVector v;
    if (no_prior_interactions) {
      const FourVector vbeam = beam_momentum[p.id()];
      v = vbeam.velocity();
    } else {
      v = p.velocity();
    }
 
    // propagate particles to position where they would be at the end of the
    // time step (after dt)
    const FourVector distance = FourVector(0.0, v * dt);
    FourVector position = p.position() + distance;
    position.set_x0(t_end);
    // update coordinates to the position corresponding to t_end
    pdata_after_propagation.set_4position(position);
 
    bool hypersurface_is_crossed = crosses_hypersurface(
        pdata_before_propagation, pdata_after_propagation, prop_time_);
 
    if (hypersurface_is_crossed) {
      // Get exact coordinates where hypersurface is crossed
      FourVector crossing_position = coordinates_on_hypersurface(
          pdata_before_propagation, pdata_after_propagation, prop_time_);
 
      double time_until_crossing = crossing_position[0] - t0;
 
      ParticleData outgoing_particle(p);
      outgoing_particle.set_4position(crossing_position);
      ActionPtr action = make_unique<HypersurfacecrossingAction>(
          p, outgoing_particle, time_until_crossing);
      actions.emplace_back(std::move(action));
    }
  }
  return actions;
}

Here is the call graph for this function:

find_actions_with_neighbors()

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

inlineoverridevirtual

Ignore the neighbor searches for hypersurface crossing.

Implements smash::ActionFinderInterface.

Definition at line 84 of file hypersurfacecrossingaction.h.

                                                    {
    return {};
  }

find_actions_with_surrounding_particles()

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

inlineoverridevirtual

Ignore the surrounding searches for hypersurface crossing.

Implements smash::ActionFinderInterface.

Definition at line 91 of file hypersurfacecrossingaction.h.

                                                    {
    return {};
  }

find_final_actions()

ActionList smash::HyperSurfaceCrossActionsFinder::find_final_actions ( const Particles &  , bool    ) const

inlineoverridevirtual

No final actions for hypersurface crossing.

Implements smash::ActionFinderInterface.

Definition at line 98 of file hypersurfacecrossingaction.h.

                                                                        {
    return {};
  }

crosses_hypersurface()

bool smash::HyperSurfaceCrossActionsFinder::crosses_hypersurface ( ParticleData &  pdata_before_propagation, ParticleData &  pdata_after_propagation, const double  tau  ) const

private

Determine whether particle crosses hypersurface within next timestep during propagation.

Parameters

[in]	pdata_before_propagation	Particle data at the beginning of time step in question
[in]	pdata_after_propagation	Particle data at the end of time step in question
[in]	tau	Proper time of the hypersurface that is tested

Returns

Does particle cross the hypersurface?

Definition at line 118 of file hypersurfacecrossingaction.cc.

                                                                   {
  bool hypersurface_is_crossed = false;
  const bool t_greater_z_before_prop =
      (std::fabs(pdata_before_propagation.position().x0()) >
               std::fabs(pdata_before_propagation.position().x3())
           ? 1
           : 0);
  const bool t_greater_z_after_prop =
      (std::fabs(pdata_after_propagation.position().x0()) >
               std::fabs(pdata_after_propagation.position().x3())
           ? 1
           : 0);
 
  if (t_greater_z_before_prop && t_greater_z_after_prop) {
    // proper time before and after propagation
    const double tau_before = pdata_before_propagation.position().tau();
    const double tau_after = pdata_after_propagation.position().tau();
 
    if (tau_before <= tau && tau <= tau_after) {
      hypersurface_is_crossed = true;
    }
  } else if (!t_greater_z_before_prop && t_greater_z_after_prop) {
    // proper time after propagation
    const double tau_after = pdata_after_propagation.position().tau();
    if (tau_after >= tau) {
      hypersurface_is_crossed = true;
    }
  }
 
  return hypersurface_is_crossed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

coordinates_on_hypersurface()

FourVector smash::HyperSurfaceCrossActionsFinder::coordinates_on_hypersurface ( ParticleData &  pdata_before_propagation, ParticleData &  pdata_after_propagation, const double  tau  ) const

private

Find the coordinates where particle crosses hypersurface.

Parameters

[in]	pdata_before_propagation	Particle data at the beginning of time in question
[in]	pdata_after_propagation	Particle data at the end of time step in question
[in]	tau	Proper time of the hypersurface that is crossed

Returns

Fourvector of the crossing position

Definition at line 152 of file hypersurfacecrossingaction.cc.

                                                                   {
  // find t and z at start of propagation
  const double t1 = pdata_before_propagation.position().x0();
  const double z1 = pdata_before_propagation.position().x3();
 
  // find t and z after propagation
  const double t2 = pdata_after_propagation.position().x0();
  const double z2 = pdata_after_propagation.position().x3();
 
  // find slope and intercept of linear function that describes propagation on
  // straight line
  const double m = (z2 - z1) / (t2 - t1);
  const double n = z1 - m * t1;
 
  // The equation to solve is a quadratic equation which provides two solutions,
  // the latter is usually out of the t-interval we are looking at.
  const double sol1 = n * m / (1 - m * m) +
                      std::sqrt((1 - m * m) * tau * tau + n * n) / (1 - m * m);
  const double sol2 = n * m / (1 - m * m) -
                      std::sqrt((1 - m * m) * tau * tau + n * n) / (1 - m * m);
 
  SMASH_UNUSED(sol2);  // only used in DEBUG output
  assert((sol1 >= t1 && sol1 <= t2));
  assert(!(sol2 >= t1 && sol2 <= t2));
 
  // Propagate to point where hypersurface is crossed
  const ThreeVector v = pdata_before_propagation.velocity();
  const FourVector distance = FourVector(0.0, v * (sol1 - t1));
  FourVector crossing_position = pdata_before_propagation.position() + distance;
  crossing_position.set_x0(sol1);
 
  return crossing_position;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

prop_time_

const double smash::HyperSurfaceCrossActionsFinder::prop_time_

private

Proper time of the hypersurface in fm.

Definition at line 104 of file hypersurfacecrossingaction.h.

---

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

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