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

smash::HyperSurfaceCrossActionsFinder::HyperSurfaceCrossActionsFinder ( double tau )

inlineexplicit

Construct hypersurfacecrossing action finder.

Parameters

[in] tau Proper time of the hypersurface. [fm]

Definition at line 65 of file hypersurfacecrossingaction.h.

65 : prop_time_{tau} {};

smash::HyperSurfaceCrossActionsFinder::prop_time_

const double prop_time_

Proper time of the hypersurface in fm.

Definition: hypersurfacecrossingaction.h:102

Member Function Documentation

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 52 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:

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 82 of file hypersurfacecrossingaction.h.

                                                     {
     return {};
   }

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 89 of file hypersurfacecrossingaction.h.

                                                     {
     return {};
   }

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

inlineoverridevirtual

No final actions for hypersurface crossing.

Implements smash::ActionFinderInterface.

Definition at line 96 of file hypersurfacecrossingaction.h.

                                                                         {
     return {};
   }

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 120 of file hypersurfacecrossingaction.cc.

                                                                    {
   bool hypersurface_is_crossed = false;
   const bool t_greater_z_before_prop =
       (fabs(pdata_before_propagation.position().x0()) >
                fabs(pdata_before_propagation.position().x3())
            ? 1
            : 0);
   const bool t_greater_z_after_prop =
       (fabs(pdata_after_propagation.position().x0()) >
                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:

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 154 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:

Member Data Documentation

const double smash::HyperSurfaceCrossActionsFinder::prop_time_

private

Proper time of the hypersurface in fm.

Definition at line 102 of file hypersurfacecrossingaction.h.

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

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

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation