WireCell::Gen Namespace Reference

Namespaces
	Noise
	Test

Classes
class	AddNoise
class	AnodeFace
class	AnodePlane
class	BinnedDiffusion
class	BinnedDiffusion_transform
class	BirksRecombination
class	BlipSource
class	BoxRecombination
class	DepoBagger
class	DepoChunker
class	DepoFanout
class	DepoFramer
class	DepoMerger
class	DepoPlaneX
class	DepoSetFanout
class	DepoSplat
class	DepoTransform
class	DepoZipper
class	Digitizer
class	Drifter
class	Ductor
class	DumpFrames
class	ElecResponse
class	EmpiricalNoiseModel
class	Fourdee
class	FrameFanin
class	FrameFanout
class	FrameSummer
struct	GausDesc
class	GaussianDiffusion
class	ImpactData
	Information that has been collected at one impact position. More...
class	ImpactResponse
class	ImpactTransform
class	ImpactZipper
class	MegaAnodePlane
class	MipRecombination
	Model for a MIP, dQ = (Rmip/Wi)*dE. More...
class	Misconfigure
class	MultiDuctor
class	NoiseSource
class	PerChannelVariation
class	PlaneImpactResponse
class	Random
class	RCResponse
class	Reframer
class	ResponseSys
class	Retagger
class	SilentNoise
class	StaticChannelStatus
class	TimeGatedDepos
class	TrackDepos
	A producer of depositions created from some number of simple, linear tracks. More...
class	TransportedDepo
class	TruthSmearer
class	TruthTraceID
class	WireBoundedDepos
class	WirePlane
class	WireSchemaFile

Functions
IFrame::pointer	sum (std::vector< IFrame::pointer > frames, int ident)

Function Documentation

IFrame::pointer WireCell::Gen::sum	(	std::vector< IFrame::pointer >	frames,
		int	ident
	)

Sum a vector of frames, returning a new one with the given ident. The start time of the new one will be the minimum time of all frames. The sample period (tick) of all frames must be identical. Traces on a common channel are summed producing a single trace which covers a time domain spanning the minimum and maximum tbin of all the traces in the channel. Zeros are padded for any intervening samples outside of any individual trace.

Definition at line 15 of file FrameUtil.cxx.

{
    // Extract starting times and ticks of all frames
    const int nframes = frames.size();
    std::vector<double> times(nframes), ticks(nframes);
    for (int ind=0; ind<nframes; ++ind) {
        times[ind] = frames[ind]->time();
        ticks[ind] = frames[ind]->tick();
    }
    auto tick_mm = std::minmax_element(ticks.begin(), ticks.end());
    if (*tick_mm.first != *tick_mm.second) {
        return nullptr;
    }
    const double tick = ticks[0];
    auto times_mm = std::minmax_element(times.begin(), times.end());
    const double start_time = *times_mm.first;
    
    // Make an temporary index mapping channel to all the trace data,
    // applying time offsets as we fill.
    channel_index_t index;
    for (int ind=0; ind<nframes; ++ind) {
        IFrame::pointer frame = frames[ind];
        const double dt = frame->time() - start_time;
        const int tbinoff = dt/tick;
        for (auto trace : *frame->traces()) {
            const int ch = trace->channel();
            const int new_tbin = tbinoff + trace->tbin();
            index[ch].push_back(make_pair(new_tbin, &(trace->charge())));
        }
    }

    // Process each channel to make flattened trace.
    ITrace::vector out_traces;
    for (auto ctc : index) {
        auto ch = ctc.first;
        auto tcv = ctc.second;  // vector of tbin_charge_t
        vector<int> tbins;
        for (auto tc : tcv) {   // go through once to find tbin bounds 
            const int tbin = tc.first;
            tbins.push_back(tbin);
            tbins.push_back(tbin+tc.second->size());
        }
        auto tbin_mm = std::minmax_element(tbins.begin(), tbins.end());
        const int trace_tbin = *tbin_mm.first;
        const int trace_nbins = *tbin_mm.second-trace_tbin;
        vector<float> charge(trace_nbins, 0.0);
        for (auto tc : tcv) {
            int ind = tc.first - trace_tbin;
            for (auto q : *tc.second) {
                charge[ind] += q;
                ++ind;
            }
        }
        ITrace::pointer trace = make_shared<SimpleTrace>(ch, trace_tbin, charge);
        out_traces.push_back(trace);
    }
    
    return make_shared<SimpleFrame>(ident, start_time, out_traces, tick);
}