Chirp Struct Reference

Public Types
typedef std::unordered_set< std::size_t >	indices_t

Public Member Functions
void	operator() (const int &x)
	Chirp (const blobs_t &one, const blobs_t &two, Coordinates &coords, JsonEvent &dumper)
bool	in (const blobref_t &a, const blobref_t &b)
void	operator() (const blobref_t &a, const blobref_t &b)
void	dump (JsonEvent &dumper)

Public Attributes
const blobs_t &	one
const blobs_t &	two
Coordinates &	coords
indices_t *	sel1
indices_t *	sel2

Detailed Description

Definition at line 38 of file test_tbb_join.cxx.

Member Typedef Documentation

typedef std::unordered_set<std::size_t> Chirp::indices_t

Definition at line 126 of file test_rayclustering.cxx.

Constructor & Destructor Documentation

Chirp::Chirp ( const blobs_t &  one, const blobs_t &  two, Coordinates &  coords, JsonEvent &  dumper  )

inline

Definition at line 130 of file test_rayclustering.cxx.

        : one(one)
        , two(two)
        , coords(coords)
        , sel1(new indices_t)
        , sel2(new indices_t)
        {}

Member Function Documentation

void Chirp::dump ( JsonEvent &  dumper )

inline

Definition at line 213 of file test_rayclustering.cxx.

                                 {
        int number = 0;
        for (const auto ind : *sel1) {
            const auto& br = one[ind];
            dumper(br, 10.0, 1.0, 1, ind);
            ++number;
        }
        number = 0;
        for (const auto ind : *sel2) {
            const auto& br = two[ind];
            dumper(br, 20.0, 1.0, 2, ind);
            ++number;
        }

        return;
    }

bool Chirp::in ( const blobref_t &  a, const blobref_t &  b  )

inline

Definition at line 139 of file test_rayclustering.cxx.

                                                    {
        if (surrounding(a, b)) {
            return true;
        }

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

        // if at least one corner of b is in side a, return true
        for (const auto& c : b->corners()) {
            int found = 0;
            // go through each layer of blob a
            for (layer_index_t layer = 0; layer < nlayers; ++layer) {
                const auto& astrip = astrips[layer];
                if (layer == c.first.layer) {
                    info("L{} A: {} {}", layer, astrip, c);
                    if (astrip.on(c.first.grid)) {
                        info("\ton with found={} nlayers={}", found, nlayers);
                        ++found;
                        continue;
                    }
                    info("\toff with found={} nlayers={}", found, nlayers);
                    break;
                }
                if (layer == c.second.layer) {
                    info("L{} A: {} {}", layer, astrip, c);
                    if (astrip.on(c.second.grid)) {
                        info("\ton with found={} nlayers={}", found, nlayers);
                        ++found;
                        continue;
                    }
                    info("\toff with found={} nlayers={}",found, nlayers);
                    break;
                }
                const double ploc = coords.pitch_location(c.first, c.second, layer);
                const int pind = coords.pitch_index(ploc, layer);

                info("L{} A: {} pind={} ploc={} {}", layer, astrip, pind, ploc, c);

                if (astrip.in(pind)) {
                    info("\tin with found={} nlayers={}", found, nlayers);
                    ++found;
                }
                else {
                    info("\tout with found={} nlayers={}", found, nlayers);
                    break;
                }
            }
            if (found == nlayers) {
                return true;
            }
        }
        return false;
    }

void Chirp::operator() ( const int &  x )

inline

Definition at line 39 of file test_tbb_join.cxx.

                                  {
        cerr << x << endl;
    }

void Chirp::operator() ( const blobref_t &  a, const blobref_t &  b  )

inline

Definition at line 194 of file test_rayclustering.cxx.

                                                            {


        const std::size_t d1 = a-one.begin();
        const std::size_t d2 = b-two.begin();

        info("overlap: a{} and b{}", d1, d2);
        info("\tblob a #{}: {}", d1, a->as_string());
        info("\tblob b #{}: {}", d2, b->as_string());

        if (!this->in(a,b)) {
            warn("NO CONTAINED CORNERS");
            //Assert(this->in(a,b));
        }

        sel1->insert(d1);
        sel2->insert(d2);
    }

Member Data Documentation

Coordinates& Chirp::coords

Definition at line 124 of file test_rayclustering.cxx.

const blobs_t& Chirp::one

Definition at line 122 of file test_rayclustering.cxx.

indices_t* Chirp::sel1

Definition at line 127 of file test_rayclustering.cxx.

indices_t* Chirp::sel2

Definition at line 128 of file test_rayclustering.cxx.

const blobs_t& Chirp::two

Definition at line 123 of file test_rayclustering.cxx.

---

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

• wire-cell-build/tbb/test/test_tbb_join.cxx
• wire-cell-build/util/test/test_rayclustering.cxx