WireCell::FrameTools Namespace Reference

Typedefs
typedef std::vector< int >	channel_list

Functions
ITrace::vector	untagged_traces (IFrame::pointer frame)
ITrace::vector	tagged_traces (IFrame::pointer frame, IFrame::tag_t tag)
channel_list	channels (const ITrace::vector &traces)
std::pair< int, int >	tbin_range (const ITrace::vector &traces)
void	fill (Array::array_xxf &array, const ITrace::vector &traces, channel_list::iterator ch_begin, channel_list::iterator ch_end, int tbin=0)
int	frmtcmp (IFrame::pointer frame, double time)
std::pair< IFrame::pointer, IFrame::pointer >	split (IFrame::pointer frame, double time)

Typedef Documentation

typedef std::vector<int> WireCell::FrameTools::channel_list

Return a one-to-one vector of channels from a vector of traces.

Note, you probably want to get a sorted/unique version of this vector for later use. Do so something like:

auto ch = channels(traces); std::sort(ch.begin(), ch.end()); auto end = std::unique(ch.begin(), ch.end()); ch.resize(std::distance(ch.begin(), end));

Definition at line 41 of file FrameTools.h.

Function Documentation

FrameTools::channel_list WireCell::FrameTools::channels

(

const ITrace::vector &

traces

)

Definition at line 132 of file FrameTools.cxx.

{
    const auto nchans = traces.size();
    FrameTools::channel_list ret(nchans,0);
    for (size_t ind=0; ind != nchans; ++ind) {
        ret[ind] = traces[ind]->channel();
    }
    return ret;
}

void WireCell::FrameTools::fill	(	Array::array_xxf &	array,
		const ITrace::vector &	traces,
		channel_list::iterator	ch_begin,
		channel_list::iterator	ch_end,
		int	tbin = 0
	)

Fill a 2D [nchannels/nrows X nticks/ncolumns] array by adding the charge information in the given traces. The channel_list range is an ordered sequence of channels used to associate traces to rows in the array. Ie, any trace with the same channel number as pointed to ch_begin will be in row 0 of the array. The "tbin" gives the time bin of column 0 of the array and is compared to the tbin value of the individual traces. Note, traces which are not refered to in the channel list or which are outside the array are ignored and not all channels need to have associated traces.

Definition at line 158 of file FrameTools.cxx.

{
    std::unordered_map<int,int> index;
    // one col is one tick
    // one row is one channel
    // array is indexed in order: (irow, icol)
    const int ncols = array.cols(); 
    const int nrows = std::min((int)array.rows(), (int)std::distance(chit,chend));
    for (int ind = 0; ind != nrows and chit != chend; ++ind, ++chit) {
        index[*chit] = ind;
    }
    for (const auto trace : traces) {

        // resolve which row a the channel is at
        const int ch = trace->channel();
        auto it = index.find(ch);
        if (it == index.end()) {
            continue;
        }
        const int irow = it->second;
        
        const auto& charge = trace->charge();
        const int nticks = charge.size();
        const int dtbin = trace->tbin() - tbin;
        int icol0 = 0, itick0 = 0;
        if (dtbin < 0) {
            itick0 = -dtbin;
        }
        if (dtbin > 0) {
            icol0 = dtbin;
        }
                
        const int ncols_left = ncols - icol0;
        const int nticks_left = nticks - itick0;
        if (ncols_left <= 0 or nticks_left <= 0) {
            continue;
        }
        const int nleft = std::min(ncols_left, nticks_left);
        for (int ind=0; ind != nleft; ++ind) {
            array(irow, icol0+ind) += charge.at(itick0 + ind);
        }
    }
}

int WireCell::FrameTools::frmtcmp	(	IFrame::pointer	frame,
		double	time
	)

Compare the time span of a frame to a time.

Return 0 if the frame time span covers the target time. Return -1 if the frame is wholly before the target time. Return +1 if the frame is wholly after the target time.

Note, the frame pointer must be valid and the frame must have traces.

Note, if the low-edge of the minimum tick or the high-edge of the maximum tick is exactly at the target time then the frame span is not considered to cover the target time.

Definition at line 14 of file FrameTools.cxx.

{
    auto traces = frame->traces();
    auto tbin_mm = FrameTools::tbin_range(*traces.get());

    const double tref = frame->time();
    const double tick = frame->tick();
    const double tmin = tref + tbin_mm.first*tick;  // low edge
    const double tmax = tref + tbin_mm.second*tick; // high edge

    if (tmax <= time) {         // high edge may be exactly equal to target time and frame does not span.
        return -1;
    }
    if (tmin >= time) {         // low edge may be exactly equal to target time and frame does not span.
        return +1;
    }
    return 0;
}

std::pair< IFrame::pointer, IFrame::pointer > WireCell::FrameTools::split	(	IFrame::pointer	frame,
		double	time
	)

Split one frame into two. A new .first frame will contain traces with all samples taken before the given time and a new .second frame with traces containing samples all taken on or after the given time. If the original frame time span does not cover the target time then the original frame is returned in the associated half of the pair and the other half will hold the nullptr.

Note, the frame pointer must be valid and the frame must have traces.

Definition at line 32 of file FrameTools.cxx.

{
    int cmp = frmtcmp(frame, time);
    if (cmp < 0) {
        return std::pair<IFrame::pointer, IFrame::pointer>(frame, nullptr);
    }
    if (cmp > 0) {
        return std::pair<IFrame::pointer, IFrame::pointer>(nullptr, frame);
    }
    // now gotta do the hard work.

    const double tref = frame->time();
    const double tick = frame->tick();
    const int ident = frame->ident();
        
    // Every tick equal or larger than this is in the second frame.
    const double fnticks = (time - tref)/tick;
    const int tbin_split = 0.5 + fnticks;


    ITrace::vector mtraces, ptraces;
    for (auto trace : (*frame->traces())) {
        const int tbin = trace->tbin();

        if (tbin >= tbin_split) {
            ptraces.push_back(trace);
            continue;
        }

        const ITrace::ChargeSequence& wave = trace->charge();
        const int lbin = tbin + wave.size();

        if (lbin <= tbin_split) {
            mtraces.push_back(trace);
            continue;
        }
        const int ind_split = tbin_split - tbin;
        ITrace::ChargeSequence mcharge(wave.begin(), wave.begin() + ind_split);
        ITrace::ChargeSequence pcharge(wave.begin() + ind_split, wave.end());

        const int chid = trace->channel();

        auto mtrace = std::make_shared<SimpleTrace>(chid, tbin, mcharge);
        mtraces.push_back(mtrace);
        auto ptrace = std::make_shared<SimpleTrace>(chid, tbin_split, pcharge);
        ptraces.push_back(ptrace);
    }
    // fixme: what about ident, cmm, tags....
    IFrame::pointer mframe = std::make_shared<SimpleFrame>(ident, tref, mtraces, tick);
    IFrame::pointer pframe = std::make_shared<SimpleFrame>(ident, tref, ptraces, tick);
    return std::pair<IFrame::pointer, IFrame::pointer>(mframe, pframe);
}

ITrace::vector WireCell::FrameTools::tagged_traces	(	IFrame::pointer	frame,
		IFrame::tag_t	tag
	)

Return a vector of traces for the matching tag. First, if there is a matching trace tag, all its traces are returned. Else, if the frame as a whole is tagged, the entire frame of traces is returned. Else, the returned vector is empty. If the tag consisting of the empty string then untagged_traces() is called. Returned vector of traces has undefined order.

Definition at line 111 of file FrameTools.cxx.

{
    if (tag == "") {
        return untagged_traces(frame); 
    }
    ITrace::vector ret;
    auto const& all_traces = frame->traces();
    for (size_t index : frame->tagged_traces(tag)) {
        ret.push_back(all_traces->at(index));
    }
    if (!ret.empty()) {
        return ret;
    }
    auto ftags = frame->frame_tags();
    if (std::find(ftags.begin(), ftags.end(), tag) == ftags.end()) {
        return ret;
    }
    return *all_traces;         // must make copy of shared pointers
}

std::pair< int, int > WireCell::FrameTools::tbin_range

(

const ITrace::vector &

traces

)

Return the tbin range of the traces. The first value is minimum of all tbins and the second is maximum of all tbin+size where size is number of elements in the charge array.

Definition at line 143 of file FrameTools.cxx.

{
    const auto siz = traces.size();
    std::vector<int> tbins(siz), tlens(siz);
    for (size_t ind=0; ind != siz; ++ind) {
        const auto trace = traces[ind];
        const int tbin = trace->tbin();
        tbins[ind] = tbin;
        tlens[ind] = tbin+trace->charge().size();
    }
    return std::pair<int,int>(
        *std::min_element(tbins.begin(), tbins.end()),
        *std::max_element(tlens.begin(), tlens.end()));        
}

ITrace::vector WireCell::FrameTools::untagged_traces

(

IFrame::pointer

frame

)

Return a vector of traces which have no trace tags. Here, any frame tags are ignored. Returned vector of traces has undefined order.

Definition at line 90 of file FrameTools.cxx.

{
    auto traces = frame->traces();
    size_t ntraces = traces->size();

    std::unordered_set<size_t> tagged;
    for (auto tag : frame->trace_tags()) {
        const auto& taglist = frame->tagged_traces(tag);
        tagged.insert(taglist.begin(), taglist.end());
    }
    std::vector<size_t> all(ntraces), untagged;
    std::iota(all.begin(), all.end(), 0);
    std::set_difference(all.begin(), all.end(), tagged.begin(), tagged.end(),
                        std::inserter(untagged, untagged.begin()));
    ITrace::vector ret;
    for (size_t ind : untagged) {
        ret.push_back(traces->at(ind));
    }
    return ret;
}