LayerFillLimits Class Reference

Helper class for the graded layer approximation. More...

Public Member Functions
	LayerFillLimits (std::vector< double > layers_bottomz)
std::vector< ZLimits >	layerZLimits () const
	Returns the filled region limits for each layer (in local layer coordinates) More...
void	update (ParticleLimits particle_limits, double offset=0.0)
	Particle limits are given in global coordinates. More...

Private Member Functions
size_t	layerIndexBottom (double bottom_z) const
size_t	layerIndexTop (double top_z) const
void	updateLayerLimits (size_t i_layer, ZLimits limits)

Private Attributes
std::vector< ZLimits >	m_layer_fill_limits
std::vector< double >	m_layers_bottomz

Detailed Description

Helper class for the graded layer approximation.

Generates limits for each layer, indicating the region of the layer (along z) that contains particle(s)

The constructor takes the bottom layer z-coordinates as parameter. This means that for N layers, only N-1 coordinates need to be passed (the last layer is assumed to be semi-infinite).

Definition at line 35 of file LayerFillLimits.h.

Constructor & Destructor Documentation

LayerFillLimits()

LayerFillLimits::LayerFillLimits

(

std::vector< double >

layers_bottomz

)

Definition at line 23 of file LayerFillLimits.cpp.

    : m_layers_bottomz(std::move(layers_bottomz)), m_layer_fill_limits(m_layers_bottomz.size() + 1)
// default ZLimits designate an absence of limits
{
}

Member Function Documentation

layerIndexBottom()

size_t LayerFillLimits::layerIndexBottom ( double  bottom_z ) const

private

Definition at line 62 of file LayerFillLimits.cpp.

{
    if (m_layers_bottomz.empty())
        return 0;
    if (bottom_z < m_layers_bottomz.back())
        return m_layers_bottomz.size();
    auto index_below =
        std::upper_bound(m_layers_bottomz.rbegin(), m_layers_bottomz.rend(), bottom_z);
    return static_cast<size_t>(m_layers_bottomz.rend() - index_below);
}

References m_layers_bottomz.

Referenced by update().

layerIndexTop()

size_t LayerFillLimits::layerIndexTop ( double  top_z ) const

private

Definition at line 52 of file LayerFillLimits.cpp.

{
    if (m_layers_bottomz.empty())
        return 0;
    if (top_z <= m_layers_bottomz.back())
        return m_layers_bottomz.size();
    auto index_above = std::lower_bound(m_layers_bottomz.rbegin(), m_layers_bottomz.rend(), top_z);
    return static_cast<size_t>(m_layers_bottomz.rend() - index_above);
}

References m_layers_bottomz.

Referenced by update().

layerZLimits()

std::vector< ZLimits > LayerFillLimits::layerZLimits

(

)

const

Returns the filled region limits for each layer (in local layer coordinates)

Definition at line 47 of file LayerFillLimits.cpp.

{
    return m_layer_fill_limits;
}

References m_layer_fill_limits.

update()

void LayerFillLimits::update	(	ParticleLimits	particle_limits,
		double	offset = 0.0
	)

Particle limits are given in global coordinates.

Definition at line 29 of file LayerFillLimits.cpp.

{
    if (m_layers_bottomz.empty())
        return; // do nothing for the single layer case
    double top = particle_limits.m_top + offset;
    double bottom = particle_limits.m_bottom + offset;
    if (bottom > top)
        throw std::runtime_error("LayerFillLimits::update: lower_limit > upper_limit.");
    if (bottom == top) // zero-size particle
        return;
    size_t top_index = layerIndexTop(top);
    size_t bottom_index = layerIndexBottom(bottom);
    for (size_t i_layer = top_index; i_layer < bottom_index + 1; ++i_layer) {
        ZLimits limits(bottom, top);
        updateLayerLimits(i_layer, limits);
    }
}

References layerIndexBottom(), layerIndexTop(), ParticleLimits::m_bottom, m_layers_bottomz, ParticleLimits::m_top, and updateLayerLimits().

Here is the call graph for this function:

updateLayerLimits()

void LayerFillLimits::updateLayerLimits ( size_t  i_layer, ZLimits  limits  )

private

Definition at line 73 of file LayerFillLimits.cpp.

{
    if (!limits.isFinite())
        throw std::runtime_error("LayerFillLimits::updateLayerLimits: given limits are not "
                                 "finite.");
    auto old_limits = m_layer_fill_limits[i_layer];
    double layer_ref = i_layer ? m_layers_bottomz[i_layer - 1] : m_layers_bottomz[i_layer];
    double upper =
        i_layer ? std::min(limits.upperLimit().m_value, layer_ref) : limits.upperLimit().m_value;
    double lower = (i_layer == m_layer_fill_limits.size() - 1)
                       ? limits.lowerLimit().m_value
                       : std::max(limits.lowerLimit().m_value, m_layers_bottomz[i_layer]);
    ZLimits bounded_limits(lower - layer_ref, upper - layer_ref);
    m_layer_fill_limits[i_layer] = CalculateNewLayerLimits(old_limits, bounded_limits);
}

References ZLimits::isFinite(), ZLimits::lowerLimit(), m_layer_fill_limits, m_layers_bottomz, OneSidedLimit::m_value, and ZLimits::upperLimit().

Referenced by update().

Here is the call graph for this function:

Member Data Documentation

m_layer_fill_limits

std::vector<ZLimits> LayerFillLimits::m_layer_fill_limits

private

Definition at line 50 of file LayerFillLimits.h.

Referenced by layerZLimits(), and updateLayerLimits().

m_layers_bottomz

std::vector<double> LayerFillLimits::m_layers_bottomz

private

Definition at line 49 of file LayerFillLimits.h.

Referenced by layerIndexBottom(), layerIndexTop(), update(), and updateLayerLimits().

---

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

• /home/www/ba/Sample/Scattering/LayerFillLimits.h
• /home/www/ba/Sample/Scattering/LayerFillLimits.cpp