SliceLIDVar.h

Go to the documentation of this file.

#pragma once

#include "CAFAna/Core/Var.h"
#include "CAFAna/Core/MultiVar.h"

#include "SliceLID/shifts/TrackLengthCorrection.h"

#include "TensorFlowEvaluator/SliceLID/model/Model.h"
#include "TensorFlowEvaluator/SliceLID/cafana/ResultCacher.hxx"
#include "TensorFlowEvaluator/SliceLID/cafana/SliceLIDHelperVars.cxx"

namespace SliceLID
{

using namespace ana;
using CAFAnaModel = ResultCacher<Prediction>;

static VarDict fillVarDict(
    const caf::SRProxy *sr,
    const std::vector<std::pair<std::string, Var>>      &sliceVarDefs,
    const std::vector<std::pair<std::string, MultiVar>> &png3dVarDefs
)
{
    VarDict result;

    for (auto &namedVar : sliceVarDefs) {
        result.scalarVarMap[namedVar.first] = namedVar.second(sr);
    }

    for (auto &namedMultiVar : png3dVarDefs) {
        result.vectorVarMap[namedMultiVar.first] = namedMultiVar.second(sr);
    }

    return result;
}

static std::shared_ptr<CAFAnaModel> initCAFAnaModel(
    const std::string &modelSavedir
)
{
    auto model = std::make_shared<Model>(modelSavedir);

    return std::make_shared<CAFAnaModel>(
        [
          model      = std::move(model),
          trkLenCorr = TrackLengthCorrection()
        ] (const caf::SRProxy *sr) mutable -> Prediction
        {
            auto varDict = fillVarDict(
                sr, kSliceLIDSliceVarDefs, kSliceLIDPng3dVarDefs
            );

            /* TODO: remove air bubble correction once geometry is fixed */
            bool isMC = (sr->mc.nallnus > 0) || (sr->mc.nallcosmics > 0);
            trkLenCorr.setParams(isMC, (sr->hdr.det == caf::kFARDET));
            trkLenCorr.shift(varDict);

            return model->predict(varDict);
        }
    );
}

static Var numuid(const std::shared_ptr<CAFAnaModel> &model)
{
    return Var(
        [model] (const caf::SRProxy *sr) -> double
        {
            return (*model)(sr).numu;
        }
    );
}

static Var ncid(const std::shared_ptr<CAFAnaModel> &model)
{
    return Var(
        [model] (const caf::SRProxy *sr) -> double
        {
            return (*model)(sr).nc;
        }
    );
}

static Var nueid(const std::shared_ptr<CAFAnaModel> &model)
{
    return Var(
        [model] (const caf::SRProxy *sr) -> double
        {
            return (*model)(sr).nue;
        }
    );
}

static Var nutauid(const std::shared_ptr<CAFAnaModel> &model)
{
    return Var(
        [model] (const caf::SRProxy *sr) -> double
        {
            return (*model)(sr).nutau;
        }
    );
}

static Var cosmicid(const std::shared_ptr<CAFAnaModel> &model)
{
    return Var(
        [model] (const caf::SRProxy *sr) -> double
        {
            return (*model)(sr).cosmic;
        }
    );
}

}