test_omnicndb.cxx File Reference

#include "WireCellSigProc/OmniChannelNoiseDB.h"
#include "WireCellUtil/Persist.h"
#include "WireCellUtil/PluginManager.h"
#include "WireCellUtil/Testing.h"
#include "WireCellUtil/NamedFactory.h"
#include "WireCellIface/IAnodePlane.h"
#include "WireCellIface/IConfigurable.h"
#include "TCanvas.h"
#include "TGraph.h"
#include "TStyle.h"
#include "TH1F.h"
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <unordered_set>
#include "anode_loader.h"

Go to the source code of this file.

Typedefs
typedef std::vector< WireCell::IChannelNoiseDatabase::filter_t >	filter_bag_t

Functions
void	plot_spec (const filter_bag_t &specs, const std::string &name)
int	main (int argc, char *argv[])

Variables
const std::string	config_text

Typedef Documentation

typedef std::vector<WireCell::IChannelNoiseDatabase::filter_t> filter_bag_t

Definition at line 119 of file test_omnicndb.cxx.

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

User code should never do this.

Definition at line 170 of file test_omnicndb.cxx.

{
    /// User code should never do this.
    auto anode_tns = anode_loader("uboone");
    const std::string pcr_filename = "microboone-channel-responses-v1.json.bz2";

    {
        Configuration cfg;

        if (argc > 1) {
            cerr << "testing with " << argv[1] << endl;
            WireCell::Persist::externalvars_t extvar;
            extvar["detector"] = "uboone";
            cfg = Persist::load(argv[1], extvar);
            if (cfg.isArray()) {        // probably a full configuration
                for (auto jone : cfg) {
                    string the_type = jone["type"].asString();
                    if (the_type == "wclsChannelNoiseDB" || the_type == "OmniChannelNoiseDB") {
                        //cerr << "Found my config\n" << jone << "\n";
                        cfg = jone["data"];
                        break;
                    }
                }
            }
        }
        else {
            cerr << "testing with build in config text\n";
            cfg = Persist::loads(config_text);
        }
        cfg["anode"] = anode_tns[0];

        auto icfg = Factory::lookup_tn<IConfigurable>("OmniChannelNoiseDB");
        auto def = icfg->default_configuration();
        cfg = update(def, cfg);
        icfg->configure(cfg);
    }
    
    auto anode = Factory::find_tn<IAnodePlane>(anode_tns[0]);
    const int nchannels = anode->channels().size();

    auto idb = Factory::find_tn<IChannelNoiseDatabase>("OmniChannelNoiseDB");

    gStyle->SetOptStat(0);
    TCanvas canvas("canvas","canvas",500,500);

    string pdfname = Form("%s.pdf",argv[0]);

    canvas.Print((pdfname+"[").c_str(),"pdf");
    canvas.SetGridx(1);
    canvas.SetGridy(1);
    double tick = idb->sample_time();
    cerr << "tick = " << tick/units::us << " us.\n";

    std::vector<std::string> scalar_names{
        "nominal baseline", "gain correction", "response offset", "pad window front", "pad window back",
            "min rms cut", "max rms cut", "rcrc sum", "config sum", "noise sum", "response sum"};

    const int nscalars = 11;
    std::vector<TGraph*> scalars;
    for (int ind=0; ind<11; ++ind) { scalars.push_back(new TGraph); }
    for (int ch=0; ch<nchannels; ++ch) {
        scalars[0]->SetPoint(ch, ch, idb->nominal_baseline(ch));
        scalars[1]->SetPoint(ch, ch, idb->gain_correction(ch));
        scalars[2]->SetPoint(ch, ch, idb->response_offset(ch));
        scalars[3]->SetPoint(ch, ch, idb->pad_window_front(ch));
        scalars[4]->SetPoint(ch, ch, idb->pad_window_back(ch));
        scalars[5]->SetPoint(ch, ch, idb->min_rms_cut(ch));
        scalars[6]->SetPoint(ch, ch, idb->max_rms_cut(ch));

        scalars[7]->SetPoint(ch, ch,  std::abs(Waveform::sum(idb->rcrc(ch))));
        scalars[8]->SetPoint(ch, ch,  std::abs(Waveform::sum(idb->config(ch))));
        scalars[9]->SetPoint(ch, ch,  std::abs(Waveform::sum(idb->noise(ch))));
        scalars[10]->SetPoint(ch, ch, std::abs(Waveform::sum(idb->response(ch))));

    }

    for (size_t ind=0; ind<nscalars; ++ind) {
        TGraph* graph = scalars[ind];
        graph->SetName(scalar_names[ind].c_str());
        graph->SetLineColor(2);
        graph->SetLineWidth(3);
        graph->Draw("AL");

        auto frame = graph->GetHistogram();
        frame->SetTitle(scalar_names[ind].c_str());
        frame->GetXaxis()->SetTitle("channels");
        canvas.Print(pdfname.c_str(), "pdf");
    }

    canvas.Print((pdfname+"]").c_str(), "pdf");

    
    return 0;
}

void plot_spec	(	const filter_bag_t &	specs,
		const std::string &	name
	)

Definition at line 122 of file test_omnicndb.cxx.

{
    if (specs.empty()) {
        cerr << "No specs for \"" << name << "\"\n";
        return;
    }
    cerr << "plot spec \"" << name << "\" size=" << specs.size() << endl;


    std::vector<TGraph*> graphs;
    std::vector<float> tmp;
    for (const auto& spec : specs) {
        TGraph* graph = new TGraph();
        graphs.push_back(graph);
        for (size_t ind=0; ind< spec.size(); ++ind) {
            double amp = std::abs(spec.at(ind));
            graph->SetPoint(ind, ind, amp);
            tmp.push_back(amp);
        }
    }
    auto mme = std::minmax_element(tmp.begin(), tmp.end());
    float ymin = *mme.first;
    float ymax = *mme.second;

    const int ncolors=5;
    int colors[ncolors] = {1,2,4,6,8};
    for (size_t igraph = 0; igraph<graphs.size(); ++igraph) {
        TGraph* graph = graphs[igraph];
        graph->SetLineColor(colors[igraph%ncolors]);
        graph->SetLineWidth(2);

        if (!igraph) {
            auto frame = graph->GetHistogram();
            frame->SetTitle(name.c_str());
            frame->GetXaxis()->SetTitle("frequency bins");
            frame->GetYaxis()->SetTitle("amplitude");
            graph->Draw("AL");
            frame->SetMinimum(ymin);
            frame->SetMaximum(ymax);
            cerr << name << " ymin=" << ymin << ", ymax=" << ymax << endl;
        }
        else {
            graph->Draw("L");
        }
    }
}

Variable Documentation

const std::string config_text

Definition at line 21 of file test_omnicndb.cxx.