LayerFillLimits Class Reference

Collaboration diagram for LayerFillLimits:

Public Member Functions
	LayerFillLimits (std::vector< double > layers_bottomz)
void	update (ParticleLimits particle_limits, double offset=0.0)
std::vector< ZLimits >	layerZLimits () const

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

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

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 30 of file LayerFillLimits.h.

Constructor & Destructor Documentation

LayerFillLimits()

LayerFillLimits::LayerFillLimits

(

std::vector< double >

layers_bottomz

)

Definition at line 24 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

update()

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

Particle limits are given in global coordinates.

Definition at line 30 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().

Referenced by MultiLayerUtils::ParticleRegions().

Here is the call graph for this function:

layerZLimits()

std::vector< ZLimits > LayerFillLimits::layerZLimits

(

)

const

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

Definition at line 48 of file LayerFillLimits.cpp.

{
    return m_layer_fill_limits;
}

References m_layer_fill_limits.

Referenced by MultiLayerUtils::ParticleRegions().

layerIndexTop()

size_t LayerFillLimits::layerIndexTop ( double  top_z ) const

private

Definition at line 53 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().

layerIndexBottom()

size_t LayerFillLimits::layerIndexBottom ( double  bottom_z ) const

private

Definition at line 63 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().

updateLayerLimits()

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

private

Definition at line 74 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 anonymous_namespace{LayerFillLimits.cpp}::CalculateNewLayerLimits(), 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_layers_bottomz

std::vector<double> LayerFillLimits::m_layers_bottomz

private

Definition at line 45 of file LayerFillLimits.h.

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

m_layer_fill_limits

std::vector<ZLimits> LayerFillLimits::m_layer_fill_limits

private

Definition at line 46 of file LayerFillLimits.h.

Referenced by layerZLimits(), 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