API changes

Author: taehyounpark

README.md

@@ -58,8 +58,8 @@ int main() {
 		column::expression([](std::vector<double> const& v){return v.size()}), x
 		);
 
-	auto h_x0_w = df.make( 
-		query::plan<h1d>( linax(100,0.0,1.0) ) 
+	auto h_x0_w = df.get( 
+		query::output<h1d>( linax(100,0.0,1.0) ) 
 		).fill(x0).book(sel).result();
 
 	std::ostringstream os;

docs/pages/example.md

@@ -51,7 +51,7 @@ int main() {
                   v)
           .filter(column::expression([](double x) { return x > 100.0; }), x);
 
-  auto h_x0_w = df.make(query::plan<h1d>(linax(20, 0.0, 200.0)))
+  auto h_x0_w = df.get(query::output<h1d>(linax(20, 0.0, 200.0)))
                     .fill(v0)
                     .book(sel)
                     .result();
@@ -275,7 +275,7 @@ int main() {
   // ---------------------------------------------------------------------------
 
   auto [pth_2los_sr, pth_2ldf_sr, pth_2lsf_sr] =
-      df.make(query::plan<HepQ::Hist<1, float>>("pth", 30, 0, 150))
+      df.get(query::output<HepQ::Hist<1, float>>("pth", 30, 0, 150))
           .fill(higgs_pt)
           .book(cut_2los_sr, cut_2ldf_sr, cut_2lsf_sr);
 
@@ -425,7 +425,7 @@ int main(int argc, char *argv[]) {
           .filter(column::expression(TwoElectrons), selectedElectrons);
 
   auto selectedElectronsPtHist =
-      df.make(query::plan<HepQ::Hist<1,float>>("diElectronMass", 100, 0, 500))
+      df.get(query::output<HepQ::Hist<1,float>>("diElectronMass", 100, 0, 500))
           .fill(diElectronsMassGeV)
           .book(atLeastTwoSelectedElectrons);
 
@@ -559,7 +559,7 @@ void task(int n) {
                       goodjet_mask);
 
   auto h_sumpt_goodjet =
-      df.make(query::plan<HepQ::Hist<1, float>>("goodjet_sumpt", 185, 15, 200))
+      df.get(query::output<HepQ::Hist<1, float>>("goodjet_sumpt", 185, 15, 200))
           .fill(goodjet_sumpt)
           .book(cut_goodjet);
 

docs/pages/guide.md

@@ -208,8 +208,8 @@ using h2d = qty::hist::hist<double,double>;
 using linax = qty::hist::axis::regular;
 
 // plan a 1d/2d histogram query filled with x/(x,y)
-auto q_1d = df.make(query::plan<h1d>(linax(100,0.0,1.0))).fill(x);
-auto q_2d = df.make(query::plan<h2d>(linax(100,0.0,1.0), linax(100,0.0,1.0))).fill(x,y);
+auto q_1d = df.get(query::output<h1d>(linax(100,0.0,1.0))).fill(x);
+auto q_2d = df.get(query::output<h2d>(linax(100,0.0,1.0), linax(100,0.0,1.0))).fill(x,y);
 
 // query at multiple selections
 auto [q_1d_a, q_1d_b] = q_1d.book(cut_a, cut_b);
@@ -226,7 +226,7 @@ auto hxy_c = q_2d_c.result(); // instantaneous
 @endcpp
 
 @see 
-- queryosity::query::plan (API)
+- queryosity::query::output (API)
 - queryosity::query::definition<T(Obs...)> (ABC)
 - queryosity::hist::hist (Extension)
 
@@ -281,17 +281,6 @@ auto z = systematic::vary(
 // (column::valued<double> is the common denominator base class)
 @endcpp
 
-
-@cpp
-// definitions are varied by alternate constructor arguments+input columns
-// since the constructor arguments of an arbitrary class is not known a-priori,
-// each must be provided on its own, rather than in a mapping.
-auto defn = df.vary(
-  column::definition<>(),
-  systematic::variation("vary_c", )
-  )();
-@endcpp
-
 The list of variations in a (set of) action(s) can be always be checked as they are propagated through the dataflow.
 After the dust settles, the nominal and each varied result of a query can be accessed individually.
 

docs/poxy.toml

@@ -84,7 +84,7 @@ paths           = [ 'images' ]
 'queryosity::todo?'               = 'classqueryosity_1_1todo.html'
 'queryosity::todo::varied?'       = 'classqueryosity_1_1todo_1_1varied.html'
 'queryosity::column::definition<Out(Ins...)>?'       = 'classqueryosity_1_1column_1_1definition_3_01_out_07_ins_8_8_8_08_4.html'
-'queryosity::query::plan?'       = 'classqueryosity_1_1query_1_1definition_3_01_t_07_obs_8_8_8_08_4.html'
+'queryosity::query::output?'       = 'classqueryosity_1_1query_1_1definition_3_01_t_07_obs_8_8_8_08_4.html'
 'queryosity::query::definition<T(Obs...)>?'       = 'classqueryosity_1_1query_1_1definition_3_01_t_07_obs_8_8_8_08_4.html'
 'queryosity::hist::hist<Vals...>?'       = 'classqueryosity_1_1hist_1_1hist.html'
 'Modules?'       = 'modules.html'

examples/example-hello_world.cxx

@@ -33,9 +33,9 @@ int main() {
               [](std::vector<double> const &v) { return v.size(); }))(v)
           .filter(column::expression([](double x) { return x > 100.0; }))(x);
 
-  auto h_x0_w = df.make(query::plan<h1d>(linax(20, 0.0, 200.0)))
+  auto h_x0_w = df.get(query::output<h1d>(linax(20, 0.0, 200.0)))
                     .fill(v0)
-                    .book(sel)
+                    .at(sel)
                     .result();
 
   std::ostringstream os;

examples/example-multiple_datasets.cxx

@@ -31,9 +31,9 @@ int main() {
 
   auto all = df.all();
 
-  auto h_z = df.make(query::plan<h1d>(linax(20,90.0,110.0)))
+  auto h_z = df.get(query::output<h1d>(linax(20,90.0,110.0)))
                     .fill(z)
-                    .book(all)
+                    .at(all)
                     .result();
 
   std::ostringstream os;

include/queryosity/column_series.h

@@ -44,16 +44,16 @@ queryosity::column::series<Col>::series(Col const &col) : m_column(col){};
 template <typename Col>
 auto queryosity::column::series<Col>::_get(lazy<selection::node> &sel) const {
   auto df = sel.m_df;
-  return df->make(query::plan<query::series<value_type>>())
+  return df->get(query::output<query::series<value_type>>())
       .fill(m_column)
-      .book(sel);
+      .at(sel);
 }
 
 template <typename Col>
 auto queryosity::column::series<Col>::_get(lazy<selection::node>::varied &sel)
     const -> typename lazy<query::series<value_type>>::varied {
   auto df = sel.nominal().m_df;
-  return df->make(query::plan<query::series<value_type>>())
+  return df->get(query::output<query::series<value_type>>())
       .fill(m_column)
-      .book(sel);
+      .at(sel);
 }

include/queryosity/dataflow.h

@@ -219,23 +219,35 @@ class dataflow {
   /**
    * @brief Plan a query.
    * @tparam Qry Concrete queryosity::query::definition implementation.
-   * @param[in] plan Query plan (constructor arguments).
+   * @param[in] output Query output (constructor arguments).
    * @return queryosity::todo query booker.
    */
   template <typename Qry>
-  auto make(query::plan<Qry> const &plan) -> todo<query::booker<Qry>>;
+  auto get(query::output<Qry> const &output) -> todo<query::booker<Qry>>;
+
+  /**
+   * @brief Get a column series.
+   * @tparam Col (Varied) lazy column.
+   * @param[in] col Column as series argument.
+   * @return queryosity::todo query booker.
+   */
+  template <typename Col> auto get(column::series<Col> const &srs);
 
   template <typename Val>
-  auto vary(column::constant<Val> const &cnst, std::map<std::string, Val> vars);
+  auto vary(column::constant<Val> const &cnst, std::map<std::string, Val> vars)
+      -> typename lazy<column::fixed<Val>>::varied;
 
   template <typename Fn>
   auto
   vary(column::expression<Fn> const &expr,
        std::map<std::string,
-                typename column::expression<Fn>::function_type> const &vars);
+                typename column::expression<Fn>::function_type> const &vars) ->
+      typename todo<column::evaluator<column::equation_t<Fn>>>::varied;
 
-  template <typename Defn, typename... Vars>
-  auto vary(column::definition<Defn> const &defn, Vars const &...vars);
+  template <typename Def>
+  auto vary(column::definition<Def> const &defn,
+            std::map<std::string, column::definition<Def>> const &vars) ->
+      typename todo<column::evaluator<Def>>::varied;
 
   /* "public" API for Python layer */
 
@@ -312,9 +324,9 @@ class dataflow {
   void _vary(Syst &syst, const std::string &name,
              column::expression<Fn> const &expr);
 
-  template <typename Syst, typename Defn>
+  template <typename Syst, typename Def>
   void _vary(Syst &syst, const std::string &name,
-             column::definition<Defn> const &defn);
+             column::definition<Def> const &defn);
 
 protected:
   dataset::processor m_processor;
@@ -367,7 +379,7 @@ class dataflow::node {
 
 #include "column_constant.h"
 #include "column_expression.h"
-#include "query_plan.h"
+#include "query_output.h"
 
 #include "systematic_nominal.h"
 #include "systematic_resolver.h"
@@ -534,9 +546,14 @@ auto queryosity::dataflow::_make(Args &&...args) -> todo<query::booker<Qry>> {
 }
 
 template <typename Qry>
-auto queryosity::dataflow::make(queryosity::query::plan<Qry> const &cntr)
+auto queryosity::dataflow::get(queryosity::query::output<Qry> const &qry)
     -> todo<query::booker<Qry>> {
-  return cntr._make(*this);
+  return qry.make(*this);
+}
+
+template <typename Col>
+auto queryosity::dataflow::get(queryosity::column::series<Col> const &srs) {
+  return this->all().get(srs);
 }
 
 template <typename Def, typename... Cols>
@@ -558,7 +575,7 @@ auto queryosity::dataflow::_apply(
     todo<selection::applicator<Sel, Def>> const &appl,
     lazy<Cols> const &...columns) -> lazy<selection::node> {
   auto act = ensemble::invoke(
-      [](dataset::player *plyr, selection::applicator<Sel,Def> const *appl,
+      [](dataset::player *plyr, selection::applicator<Sel, Def> const *appl,
          Cols const *...cols) { return plyr->template apply(*appl, *cols...); },
       m_processor.get_slots(), appl.get_slots(), columns.get_slots()...);
   auto lzy = lazy<selection::node>(*this, act);
@@ -598,7 +615,8 @@ inline void queryosity::dataflow::reset() { m_analyzed = false; }
 
 template <typename Val>
 auto queryosity::dataflow::vary(column::constant<Val> const &cnst,
-                                std::map<std::string, Val> vars) {
+                                std::map<std::string, Val> vars) ->
+    typename lazy<column::fixed<Val>>::varied {
   auto nom = this->define(cnst);
   using varied_type = typename decltype(nom)::varied;
   varied_type syst(std::move(nom));
@@ -612,7 +630,8 @@ template <typename Fn>
 auto queryosity::dataflow::vary(
     column::expression<Fn> const &expr,
     std::map<std::string, typename column::expression<Fn>::function_type> const
-        &vars) {
+        &vars) ->
+    typename todo<column::evaluator<column::equation_t<Fn>>>::varied {
   auto nom = this->_equate(expr);
   using varied_type = typename decltype(nom)::varied;
   using function_type = typename column::expression<Fn>::function_type;
@@ -623,15 +642,17 @@ auto queryosity::dataflow::vary(
   return syst;
 }
 
-template <typename Defn, typename... Vars>
-auto queryosity::dataflow::vary(column::definition<Defn> const &defn,
-                                Vars const &...vars) {
+template <typename Def>
+auto queryosity::dataflow::vary(
+    column::definition<Def> const &defn,
+    std::map<std::string, column::definition<Def>> const &vars) ->
+    typename todo<column::evaluator<Def>>::varied {
   auto nom = this->_define(defn);
   using varied_type = typename decltype(nom)::varied;
   varied_type syst(std::move(nom));
-  ((this->_vary(syst, vars.name(),
-                vars.template _vary_arg<column::definition<Defn>>())),
-   ...);
+  for (auto const &var : vars) {
+    this->_vary(syst, var.first, var.second);
+  }
   return syst;
 }
 
@@ -722,7 +743,8 @@ auto queryosity::dataflow::_select(column::expression<Fn> const &expr)
 }
 
 template <typename Sel, typename Fn>
-auto queryosity::dataflow::_select(lazy<selection::node> const& prev, column::expression<Fn> const &expr)
+auto queryosity::dataflow::_select(lazy<selection::node> const &prev,
+                                   column::expression<Fn> const &expr)
     -> todo<selection::applicator<Sel, column::equation_t<Fn>>> {
   return expr.template _select<Sel>(*this, prev);
 }
@@ -764,9 +786,9 @@ void queryosity::dataflow::_vary(Syst &syst, const std::string &name,
   syst.set_variation(name, this->_equate(expr));
 }
 
-template <typename Syst, typename Defn>
+template <typename Syst, typename Def>
 void queryosity::dataflow::_vary(Syst &syst, const std::string &name,
-                                 column::definition<Defn> const &defn) {
+                                 column::definition<Def> const &defn) {
   syst.set_variation(name, this->_define(defn));
 }
 

include/queryosity/lazy.h

@@ -309,15 +309,15 @@ template <typename Agg>
 auto queryosity::lazy<Action>::book(Agg &&agg) const {
   static_assert(std::is_base_of_v<selection::node, Action>,
                 "book must be called from a selection");
-  return agg.book(*this);
+  return agg.at(*this);
 }
 
 template <typename Action>
 template <typename... Aggs>
 auto queryosity::lazy<Action>::book(Aggs &&...aggs) const {
   static_assert(std::is_base_of_v<selection::node, Action>,
                 "book must be called from a selection");
-  return std::make_tuple((aggs.book(*this), ...));
+  return std::make_tuple((aggs.at(*this), ...));
 }
 
 template <typename Action>