BasicProngVars.cxx

Go to the documentation of this file.

#include "LSTME/art/var_dict_builder/BasicProngVars.h"

namespace LSTME
{

bool sortByLength(const art::Ptr<rb::Prong> &a, const art::Ptr<rb::Prong> &b) {
    return a->TotalLength() > b->TotalLength();
}

void BasicProngVars::reserveVectors(size_t nProngs)
{
    dir_x  .reserve(nProngs);
    dir_y  .reserve(nProngs);
    dir_z  .reserve(nProngs);

    start_x.reserve(nProngs);
    start_y.reserve(nProngs);
    start_z.reserve(nProngs);

    nhit   .reserve(nProngs);
    nhitx  .reserve(nProngs);
    nhity  .reserve(nProngs);
    nplane .reserve(nProngs);
    len    .reserve(nProngs);
    calE   .reserve(nProngs);

    weightedCalE.reserve(nProngs);
}

void BasicProngVars::initBasicVars()
{
    if (! hasProngs) {
        return;
    }

    reserveVectors(prongs.size());

    for (size_t pngIdx = 0; pngIdx < prongs.size(); ++pngIdx)
    {
        const rb::Prong &prong = *prongs[pngIdx];

        dir_x  .push_back(prong.Dir().X());
        dir_y  .push_back(prong.Dir().Y());
        dir_z  .push_back(prong.Dir().Z());

        start_x.push_back(prong.Start().X());
        start_y.push_back(prong.Start().Y());
        start_z.push_back(prong.Start().Z());

        nhit   .push_back(prong.NCell());
        nhitx  .push_back(prong.NXCell());
        nhity  .push_back(prong.NYCell());
        nplane .push_back(prong.ExtentPlane());
        len    .push_back(prong.TotalLength());
        calE   .push_back(prong.CalorimetricEnergy());

        if (hasWeightedProngs) {
            weightedCalE.push_back(
                weightedProngs[pngIdx]->CalorimetricEnergy()
            );
        }
        else {
            weightedCalE.push_back(0);
        }
    }
}

bool BasicProngVars::getProngs(
    const art::Event &evt,
    const std::vector<art::Ptr<rb::Vertex>> &elastics,
    const std::string &baseLabel,
    const std::string &assnLabel,
    std::vector<art::Ptr<rb::Prong>> &prongs
)
{
    auto png_fmp = art::FindManyP<rb::Prong>(
        elastics, evt, art::InputTag(baseLabel, assnLabel)
    );

    if (! png_fmp.isValid()) {
        return false;
    }

    prongs = png_fmp.at(0);
    std::sort(prongs.begin(), prongs.end(), sortByLength);

    return true;
}

bool BasicProngVars::getWeightedProngs(
    const art::Event &evt,
    const std::string &baseLabel,
    const std::string &assnLabel,
    std::vector<art::Ptr<rb::WeightedProng>> &weightedProngs
)
{
    auto weightedPng_fmp = art::FindManyP<rb::WeightedProng>(
        prongs, evt, art::InputTag(baseLabel, assnLabel)
    );

    if (! weightedPng_fmp.isValid()) {
        return false;
    }

    for (size_t i = 0; i < prongs.size(); i++) {
        /* OMG */
        weightedProngs.push_back(weightedPng_fmp.at(i)[0]);
    }

    return true;
}

void BasicProngVars::initProngs(
    const art::Event &evt,
    const std::vector<art::Ptr<rb::Vertex>> &elastics
)
{
    if (elastics.empty()) {
        return;
    }

    hasProngs = getProngs(
        evt, elastics, fuzzykLabel, fuzzykAssnLabel, prongs
    );

    if (! hasProngs) {
        return;
    }

    hasWeightedProngs = getWeightedProngs(
        evt, fuzzykLabel, fuzzykWeightAssnLabel, weightedProngs
    );
}

BasicProngVars::BasicProngVars(
    const art::Event &evt,
    const std::vector<art::Ptr<rb::Vertex>> &elastics,
    const std::string &fuzzykLabel,
    const std::string &fuzzykAssnLabel,
    const std::string &fuzzykWeightAssnLabel
)
    : hasProngs(false), hasWeightedProngs(false),
      fuzzykLabel(fuzzykLabel),
      fuzzykAssnLabel(fuzzykAssnLabel),
      fuzzykWeightAssnLabel(fuzzykWeightAssnLabel)
{
    initProngs(evt, elastics);
    initBasicVars();
}

void BasicProngVars::saveToDict(
    std::unordered_map<std::string, std::vector<double>> &dict,
    const std::string &prefix
) const
{
    dict.emplace(prefix + "dir.x",   dir_x);
    dict.emplace(prefix + "dir.y",   dir_y);
    dict.emplace(prefix + "dir.z",   dir_z);

    dict.emplace(prefix + "start.x", start_x);
    dict.emplace(prefix + "start.y", start_y);
    dict.emplace(prefix + "start.z", start_z);

    dict.emplace(prefix + "nhit",    nhit);
    dict.emplace(prefix + "nhitx",   nhitx);
    dict.emplace(prefix + "nhity",   nhity);

    dict.emplace(prefix + "nplane",  nplane);
    dict.emplace(prefix + "len",     len);
    dict.emplace(prefix + "calE",    calE);

    dict.emplace(prefix + "weightedCalE", weightedCalE);
}


}