WireCell::RayGrid Namespace Reference

Classes
class	Activity
class	Blob
struct	blobref_hash
struct	coordinate_t
class	Coordinates
class	Grouping
class	Solving
struct	Strip
class	Tiling

Typedefs
typedef blobs_t::const_iterator	blobref_t
typedef std::vector< blobref_t >	blobvec_t
typedef std::vector< blobvec_t >	blobproj_t
typedef std::unordered_set< blobref_t, blobref_hash >	blobset_t
typedef std::function< void(blobref_t &a, blobref_t &b)>	associator_t
typedef int	layer_index_t
typedef int	grid_index_t
typedef std::pair< layer_index_t, layer_index_t >	layer_pair_t
typedef std::tuple< layer_index_t, layer_index_t, layer_index_t >	layer_triple_t
typedef boost::multi_array< double, 3 >	tensor_t
typedef std::vector< Vector >	vector_array1d_t
typedef ObjectArray2d< Vector >	vector_array2d_t
typedef std::pair< grid_index_t, grid_index_t >	grid_range_t
typedef std::pair< coordinate_t, coordinate_t >	crossing_t
typedef std::vector< crossing_t >	crossings_t
typedef std::vector< Strip >	strips_t
typedef std::vector< Activity >	activities_t
typedef std::vector< Blob >	blobs_t

Functions
blobproj_t	projection (const blobvec_t &blobs, layer_index_t layer)
blobvec_t	select (const blobproj_t &proj, grid_range_t range)
blobvec_t	overlap (const blobref_t &blob, const blobproj_t &proj, layer_index_t layer)
bool	surrounding (const blobref_t &a, const blobref_t &b)
blobvec_t	references (const blobs_t &blobs)
void	associate (const blobs_t &one, const blobs_t &two, associator_t func)
std::ostream &	operator<< (std::ostream &os, const WireCell::RayGrid::coordinate_t &ra)
size_t	drop_invalid (blobs_t &blobs)
	free functions More...
void	prune (const Coordinates &coords, blobs_t &blobs)
blobs_t	make_blobs (const Coordinates &coords, const activities_t &activities)
std::ostream &	operator<< (std::ostream &os, const WireCell::RayGrid::Strip &s)
std::ostream &	operator<< (std::ostream &os, const WireCell::RayGrid::Activity &a)
std::ostream &	operator<< (std::ostream &os, const WireCell::RayGrid::Blob &b)
std::ostream &	operator<< (std::ostream &os, const WireCell::RayGrid::crossing_t &c)

Typedef Documentation

typedef std::vector<Activity> WireCell::RayGrid::activities_t

Definition at line 105 of file RayTiling.h.

typedef std::function<void(blobref_t& a, blobref_t& b)> WireCell::RayGrid::associator_t

Definition at line 44 of file RayClustering.h.

typedef std::vector<blobvec_t> WireCell::RayGrid::blobproj_t

Definition at line 15 of file RayClustering.h.

typedef blobs_t::const_iterator WireCell::RayGrid::blobref_t

Definition at line 13 of file RayClustering.h.

typedef std::vector<Blob> WireCell::RayGrid::blobs_t

Definition at line 134 of file RayTiling.h.

typedef std::unordered_set<blobref_t, blobref_hash> WireCell::RayGrid::blobset_t

Definition at line 22 of file RayClustering.h.

typedef std::vector<blobref_t> WireCell::RayGrid::blobvec_t

Definition at line 14 of file RayClustering.h.

typedef std::pair<coordinate_t,coordinate_t> WireCell::RayGrid::crossing_t

Definition at line 61 of file RayGrid.h.

typedef std::vector<crossing_t> WireCell::RayGrid::crossings_t

Definition at line 62 of file RayGrid.h.

typedef int WireCell::RayGrid::grid_index_t

Definition at line 33 of file RayGrid.h.

typedef std::pair<grid_index_t, grid_index_t> WireCell::RayGrid::grid_range_t

Definition at line 58 of file RayGrid.h.

typedef int WireCell::RayGrid::layer_index_t

Definition at line 28 of file RayGrid.h.

typedef std::pair<layer_index_t, layer_index_t> WireCell::RayGrid::layer_pair_t

Definition at line 43 of file RayGrid.h.

typedef std::tuple<layer_index_t, layer_index_t, layer_index_t> WireCell::RayGrid::layer_triple_t

Definition at line 46 of file RayGrid.h.

typedef std::vector<Strip> WireCell::RayGrid::strips_t

Definition at line 42 of file RayTiling.h.

typedef boost::multi_array<double, 3> WireCell::RayGrid::tensor_t

Definition at line 50 of file RayGrid.h.

typedef std::vector<Vector> WireCell::RayGrid::vector_array1d_t

Definition at line 53 of file RayGrid.h.

typedef ObjectArray2d<Vector> WireCell::RayGrid::vector_array2d_t

Definition at line 55 of file RayGrid.h.

Function Documentation

void WireCell::RayGrid::associate	(	const blobs_t &	one,
		const blobs_t &	two,
		associator_t	func
	)

Definition at line 91 of file RayClustering.cxx.

{
    if (one.empty() or two.empty()) {
        return;
    }
    const size_t nlayers = two[0].strips().size();
    const size_t ilayer = nlayers-1;
    const auto proj = projection(references(two), ilayer);
    for (blobref_t blob = one.begin(); blob != one.end(); ++blob) {
        auto assoc = overlap(blob, proj, ilayer); // recursive call
        for (blobref_t other : assoc) {
            func(blob, other);
        }
    }
}

size_t WireCell::RayGrid::drop_invalid

(

blobs_t &

blobs

)

free functions

Definition at line 325 of file RayTiling.cxx.

{
    const auto end = std::partition(blobs.begin(), blobs.end(),
                                    [](const Blob& b) { return b.valid(); });
    const size_t dropped = blobs.end() - end;
    blobs.resize(end - blobs.begin());
    return dropped;
}

blobs_t WireCell::RayGrid::make_blobs	(	const Coordinates &	coords,
		const activities_t &	activities
	)

Definition at line 371 of file RayTiling.cxx.

{
    Tiling rc(coords);
    blobs_t blobs;

    for (const auto& activity : activities) {
        if (blobs.empty()) {
            blobs = rc(activity);
        }
        else {
            blobs = rc(blobs, activity);
            if (blobs.empty()) {
                spdlog::trace("RayGrid::make_blobs: lost blobs with {}", activity);
                return blobs_t{};
            }
        }
        drop_invalid(blobs);
    }
    prune(coords, blobs);
    return blobs;
}

std::ostream& WireCell::RayGrid::operator<< ( std::ostream &  os, const WireCell::RayGrid::coordinate_t &  ra  )

inline

Definition at line 126 of file RayGrid.h.

        {
            os << "<rayaddr {L" << ra.layer << ",G" << ra.grid <<"}>";
            return os;
        }

std::ostream& WireCell::RayGrid::operator<< ( std::ostream &  os, const WireCell::RayGrid::Strip &  s  )

inline

Definition at line 172 of file RayTiling.h.

        {
            os << "<strip L" << s.layer << " pind:["  << s.bounds.first << "," << s.bounds.second << "]>";
            return os;
        }

std::ostream& WireCell::RayGrid::operator<< ( std::ostream &  os, const WireCell::RayGrid::Activity &  a  )

inline

Definition at line 179 of file RayTiling.h.

        {
            int b = a.pitch_index(a.begin()), e = a.pitch_index(a.end());
            auto strips = a.make_strips();
            os << "<activity L" << a.layer() << " " << strips.size() << " strips over pind:["  << b << "," << e << "]>";
            return os;
        }

std::ostream& WireCell::RayGrid::operator<< ( std::ostream &  os, const WireCell::RayGrid::Blob &  b  )

inline

Definition at line 188 of file RayTiling.h.

        {
            os << "<blob " << b.strips().size() << " strips, " << b.corners().size() << " corners>";
            return os;
        }

std::ostream& WireCell::RayGrid::operator<< ( std::ostream &  os, const WireCell::RayGrid::crossing_t &  c  )

inline

Definition at line 195 of file RayTiling.h.

        {
            os << "<corner [{L" << c.first.layer << ",G" << c.first.grid << "},"
               << "{L" << c.second.layer << ",G" << c.second.grid << "}]>";
            return os;
        }

WireCell::RayGrid::blobvec_t WireCell::RayGrid::overlap	(	const blobref_t &	blob,
		const blobproj_t &	proj,
		layer_index_t	layer
	)

Definition at line 38 of file RayClustering.cxx.

{
    const auto& strip = blob->strips()[layer];
    auto blobs = select(proj, strip.bounds);
    if (blobs.empty()) {
        return blobs;
    }
    if (layer == 0) {
        return blobs;
    }
    
    --layer;
    auto newproj = projection(blobs, layer);
    return overlap(blob, newproj, layer);
}

WireCell::RayGrid::blobproj_t WireCell::RayGrid::projection	(	const blobvec_t &	blobs,
		layer_index_t	layer
	)

Definition at line 6 of file RayClustering.cxx.

{
    blobproj_t ret;
    for (blobref_t blob : blobs) {
        const auto bounds = blob->strips()[layer].bounds;
        for (auto gi = bounds.first; gi != bounds.second; ++gi) {
            if ((int)ret.size() <= gi) {
                ret.resize(gi+1);
            }
            ret[gi].push_back(blob);
        }
    }
    return ret;
}

void WireCell::RayGrid::prune	(	const Coordinates &	coords,
		blobs_t &	blobs
	)

Definition at line 334 of file RayTiling.cxx.

{
    for (auto & blob: blobs) {

        auto& strips = blob.strips();
        const int nlayers = strips.size();
        std::vector< std::vector<grid_index_t> > mms(nlayers);
        for (const auto& corner : blob.corners()) {
            // fixme off by one bugs here?  Adding the two rays making
            // up a corner adds a pitch-bin-edge.  Adding the ray
            // crossing point measured in the 3rd layer pitch adds a
            // bin pitch-bin-content which should be either floor()'ed
            // or ceil()'ed (or both?)

            mms[corner.first.layer].push_back(corner.first.grid);
            mms[corner.second.layer].push_back(corner.second.grid);

            // Check every layer not forming the corner
            for (int layer=0; layer<nlayers; ++layer) {
                if (corner.first.layer == layer or corner.second.layer == layer) {
                    continue;
                }
                const double ploc = coords.pitch_location(corner.first, corner.second, layer);
                const int pind = coords.pitch_index(ploc, layer);
                mms[layer].push_back(pind);
                mms[layer].push_back(pind+1);
            }
        }

        for (int layer=0; layer<nlayers; ++layer) {
            auto mm = std::minmax_element(mms[layer].begin(), mms[layer].end());
            strips[layer].bounds.first = *mm.first;
            strips[layer].bounds.second = *mm.second;
        }
    }
}

WireCell::RayGrid::blobvec_t WireCell::RayGrid::references

(

const blobs_t &

blobs

)

Definition at line 55 of file RayClustering.cxx.

{
    const size_t siz = blobs.size();
    blobvec_t ret(siz);
    for (size_t ind=0; ind<siz; ++ind) {
        ret[ind] = blobs.begin()+ind;
    }
    return ret;
}

WireCell::RayGrid::blobvec_t WireCell::RayGrid::select	(	const blobproj_t &	proj,
		grid_range_t	range
	)

Definition at line 22 of file RayClustering.cxx.

{
    if (proj.empty()) {
        return WireCell::RayGrid::blobvec_t();
    }

    blobset_t uniq;
    int nproj = std::min((int)proj.size(), gr.second);
    for (grid_index_t gind = gr.first; gind < nproj; ++gind) {
        const auto& some = proj[gind];
        uniq.insert(some.begin(), some.end());
    }
    return blobvec_t(uniq.begin(), uniq.end());
}

bool WireCell::RayGrid::surrounding	(	const blobref_t &	a,
		const blobref_t &	b
	)

Definition at line 65 of file RayClustering.cxx.

{
    const auto& astrips = a->strips();
    const auto& bstrips = b->strips();
    const int nlayers = astrips.size();

    int ainb = 0, bina = 0;
    for (int ilayer=0; ilayer<nlayers; ++ilayer) {
        const auto& astrip = astrips[ilayer];
        const auto& bstrip = bstrips[ilayer];
        const auto& abounds = astrip.bounds;
        const auto& bbounds = bstrip.bounds;
        if (abounds.first <= bbounds.first and bbounds.second <= abounds.second) {
            ++bina;
        }
        if (bbounds.first <= abounds.first and abounds.second <= bbounds.second) {
            ++ainb;
        }
    }
    if (ainb == nlayers or bina == nlayers) {
        return true;
    }
    return false;
}