Adds calculation of Top Mass from generator objects as well as saving function implementations to output file

analysis/MiniTreeDataSet.hpp

@@ -73,6 +73,7 @@ class MiniTreeDataSet : public DataSet,
             Init((TTree*) input_file->Get("tree"));
             nentries = fChain->GetEntriesFast();
             output_file = TFile::Open(output_filename.c_str(), "RECREATE");
+            this->fChain->SetBranchStatus("*", false);
           }
 
         ~MiniTreeDataSet(){
@@ -123,6 +124,9 @@ class MiniTreeDataSet : public DataSet,
             // what values are plotted
             std::map<string,string> value_lookup = this->get_container_name_value_map();
             gDirectory->WriteObjectAny(&value_lookup, "std::map<std::string,std::string>", "_value_lookup");
+
+            std::map<string,string> fn_impl_lookup = this->get_function_name_impl_map();
+            gDirectory->WriteObjectAny(&fn_impl_lookup, "std::map<std::string,std::string>", "_function_impl_lookup");
         }
 };
 #endif // minitreedataset_h

analysis/TTTT_Analysis.cpp

@@ -76,6 +76,9 @@ void enable_branches(MiniTreeDataSet& mt){
     mt.track_branch_vec<float>("nJet", "Jet_phi");
     mt.track_branch_vec<float>("nJet", "Jet_mass");
     mt.track_branch_vec<float>("nJet", "Jet_btagCMVA");
+    mt.track_branch_vec< int >("nJet", "Jet_mcMatchFlav");
+    mt.track_branch_vec< int >("nJet", "Jet_mcMatchId");
+    mt.track_branch_vec< int >("nJet", "Jet_mcFlavour");
 
 
     mt.track_branch<int>("nGenPart");
@@ -103,48 +106,46 @@ void enable_branches(MiniTreeDataSet& mt){
 
 struct Jet{
     TLorentzVector v;
-    float          b_cmva;
     int            idx;
-    public:
-        Jet()
-          :v(),b_cmva(0),idx(0) { }
-        Jet(const TLorentzVector& v, float b_cmva, int idx)
-          :v(v),b_cmva(b_cmva),idx(idx) { }
+    int            pdgid;
+    float          b_cmva;
+    Jet() { }
+    Jet(const TLorentzVector& v, int idx, int pdgid, float b_cmva)
+      :v(v),idx(idx),pdgid(pdgid),b_cmva(b_cmva) { }
+
+    static Jet reco(const TLorentzVector& v, int idx, float b_cmva){
+        return Jet(v, idx, 0, b_cmva);
+    }
+
+    static Jet mc(const TLorentzVector& v, int idx, int pdgid){
+        return Jet(v, idx, pdgid, 0);
+    }
 };
 
 void declare_values(MiniTreeDataSet& mt){
 
-    energies(lorentz_vectors("LepGood_pt", "LepGood_eta", "LepGood_phi", "LepGood_mass", "LepGood_4v"), "LepGood_energy");
-    energies(lorentz_vectors("GenPart_pt", "GenPart_eta", "GenPart_phi", "GenPart_mass", "GenPart_4v"), "GenPart_energy");
-    energies(lorentz_vectors("Jet_pt",     "Jet_eta",     "Jet_phi",     "Jet_mass",     "Jet_4v"    ), "Jet_energy");
+    // Define Lorentz Vector(TLorentzVector) object from fields in ntuple
+    lorentz_vectors("LepGood_pt", "LepGood_eta", "LepGood_phi", "LepGood_mass", "LepGood_4v");
+    lorentz_vectors("GenPart_pt", "GenPart_eta", "GenPart_phi", "GenPart_mass", "GenPart_4v");
+    lorentz_vectors("Jet_pt",     "Jet_eta",     "Jet_phi",     "Jet_mass",     "Jet_4v"    );
+
+    energies("GenPart_4v", "GenPart_energy");
 
-    auto& build_jets = GenFunction::register_function<std::vector<Jet>(std::vector<TLorentzVector>,std::vector<float>)>("build_jets",
-        FUNC(([](const std::vector<TLorentzVector>& vs, const std::vector<float>& b_cmvas){
-            std::vector<Jet> jets;
-            for(int i=0; i<vs.size(); i++){
-                jets.push_back(Jet(vs[i],b_cmvas[i],i));
-           }
-            return jets;
-        })));
-    auto jet_parts = fv::tuple<std::vector<TLorentzVector>,std::vector<float>>(lookup<std::vector<TLorentzVector>>("Jet_4v"), lookup<std::vector<float>>("Jet_btagCMVA"));
-    auto jets = apply(build_jets, jet_parts, "jets");
 
-    auto b_jets = filter(GenFunction::register_function<bool(Jet)>("b_jet_filter",
+    // Define a couple selections to be used in the top-mass reconstruction.
+    auto& b_mva_filter = GenFunction::register_function<bool(Jet)>("b_mva_filter",
         FUNC(([cut=0.0](const Jet& j){
                 return j.b_cmva > cut;
-        }))), jets, "b_jets");
-
-    auto dijets = combinations<Jet,2>(jets, "dijets");
-
+        })));
+    auto& b_pdgid_filter = GenFunction::register_function<bool(Jet)>("b_pdgid_filter",
+        FUNC(([](const Jet& j){
+                return j.pdgid == 5 || j.pdgid==-5;
+        })));
     auto& w_mass_filter = GenFunction::register_function<bool(Jet, Jet)>("w_mass_filter",
         FUNC(([win_l=W_MASS-10, win_h=W_MASS+10](const Jet& j1, const Jet& j2){
             float inv_mass = (j1.v + j2.v).M();
             return inv_mass > win_l && inv_mass < win_h;
         })));
-    auto w_dijets = tup_filter(w_mass_filter, dijets, "w_dijets");
-
-    auto top_cands = cart_product<std::tuple<Jet,Jet>, Jet>(w_dijets, b_jets);
-
     auto& dup_filter = GenFunction::register_function<bool(std::tuple<Jet,Jet>,Jet)>("dup_filter",
         FUNC(([](const std::tuple<Jet,Jet>& w, const Jet& b){
             int j0 = b.idx;
@@ -152,45 +153,88 @@ void declare_values(MiniTreeDataSet& mt){
             int j2 = std::get<1>(w).idx;
             return (j0 != j1) && (j0 != j2) && (j1 != j2);
         })));
-    top_cands = tup_filter(dup_filter, top_cands, "top_cands_deduped");
+    auto& qg_id_filter = GenFunction::register_function<bool(Jet, Jet)>("qg_id_filter",
+        FUNC(([](const Jet& j1, const Jet& j2){
+            // require both particles be either quarks(not Top) or gluons
+            int id1 = abs(j1.pdgid);
+            int id2 = abs(j2.pdgid);
+            return ((id1 >=1 && id1 <= 5) || id1 == 21) &&
+                   ((id2 >=1 && id2 <= 5) || id2 == 21);
+        })));
+
+    // Here is the calculation of the Top Reconstructed Mass from Jets
+    auto jets = apply(GenFunction::register_function<std::vector<Jet>(std::vector<TLorentzVector>,std::vector<float>)>("build_reco_jets",
+        FUNC(([](const std::vector<TLorentzVector>& vs, const std::vector<float>& b_cmvas){
+            std::vector<Jet> jets;
+            for(int i=0; i<vs.size(); i++){
+                jets.push_back(Jet::reco(vs[i],i, b_cmvas[i]));
+            }
+            return jets;
+        }))), fv::tuple(lookup<std::vector<TLorentzVector>>("Jet_4v"), lookup<std::vector<float>>("Jet_btagCMVA")), "reco_jets");
+
 
+    auto b_jets = filter(b_mva_filter, jets, "reco_b_jets");
+    auto w_dijets = tup_filter<Jet,Jet>(w_mass_filter, combinations<Jet,2>(jets, "reco_dijets"));
 
-    fv::map(GenFunction::register_function<float(std::tuple<Jet,Jet>,Jet)>("t_mass",
+    auto top_cands = cart_product<std::tuple<Jet,Jet>, Jet>(w_dijets, b_jets);
+
+    top_cands = tup_filter(dup_filter, top_cands);
+
+    auto& t_mass = GenFunction::register_function<float(std::tuple<Jet,Jet>,Jet)>("t_mass",
         FUNC(([](const std::tuple<Jet,Jet>& w, const Jet& b){
             return (std::get<0>(w).v+std::get<1>(w).v+b.v).M();
-        }))),top_cands, "rec_top_mass");
+        })));
+
+    fv::map(t_mass, top_cands, "reco_top_mass");
+
+    // Here is the calculation of the Top Reconstructed Mass from Generator-Level objects
+    jets = apply(GenFunction::register_function<std::vector<Jet>(std::vector<TLorentzVector>,std::vector<int>)>("build_mcjets",
+        FUNC(([](const std::vector<TLorentzVector>& vs, const std::vector<int>& pdgid){
+            std::vector<Jet> jets;
+            for(int i=0; i<vs.size(); i++){
+                jets.push_back(Jet::mc(vs[i],i, pdgid[i]));
+            }
+            return jets;
+        }))), fv::tuple(lookup<std::vector<TLorentzVector>>("GenPart_4v"), lookup<std::vector<int>>("GenPart_pdgId")), "mcjets");
+
+    b_jets = filter(b_pdgid_filter, jets);
+
+    w_dijets = tup_filter(qg_id_filter, combinations<Jet,2>(jets));
+    w_dijets = tup_filter(w_mass_filter, w_dijets);
+
+    top_cands = cart_product<std::tuple<Jet,Jet>, Jet>(w_dijets, b_jets);
+
+    top_cands = tup_filter(dup_filter, top_cands);
 
 
+    fv::map(t_mass, top_cands, "mc_top_mass");
+
+
+    // calculation of di-jet inv-mass spectrum
     auto& inv_mass2 = GenFunction::register_function<float(Jet, Jet)>("inv_mass2",
         FUNC(([] (const Jet& j1, const Jet& j2){
             TLorentzVector sum = j1.v + j2.v;
             return (float)sum.M();
         })));
+    fv::map(inv_mass2, lookup<std::vector<std::tuple<Jet,Jet>>>("reco_dijets"), "dijet_inv_mass");
 
 
-    fv::map(inv_mass2, dijets, "di-jet_inv_mass");
-
-    fv::pair<vector<float>,vector<float>>("LepGood_energy", "LepGood_pt", "LepGood_energy_LepGood_pt");
-    fv::pair<vector<float>,vector<float>>("Jet_energy", "Jet_eta", "Jet_energy_vs_Jet_eta");
 
-    max<float>("LepGood_energy", "LepGood_energy_max");
-    min<float>("LepGood_energy", "LepGood_energy_min");
-    range<float>("LepGood_energy", "LepGood_energy_range");
-    mean<float>("LepGood_energy", "LepGood_energy_mean");
+    count<float>(GenFunction::register_function<bool(float)>("bJet_Selection",
+        FUNC(([](float x){
+            return x>0;
+        }))), "Jet_btagCMVA",  "b_jet_count");
 
-    count<float>(GenFunction::register_function<bool(float)>("bJet_Selection", FUNC(([](float x){return x>0;}))),
-                                                             "Jet_btagCMVA",  "b_jet_count");
-
-    auto &is_electron = GenFunction::register_function<bool(int)>("is_electron", FUNC(([](int pdgId)
-        {
+    auto &is_electron = GenFunction::register_function<bool(int)>("is_electron",
+        FUNC(([](int pdgId) {
             return abs(pdgId) == 11;
         })));
-    auto &is_muon = GenFunction::register_function<bool(int)>("is_muon", FUNC(([](int pdgId)
-        {
+    auto &is_muon = GenFunction::register_function<bool(int)>("is_muon",
+        FUNC(([](int pdgId) {
             return abs(pdgId) == 13;
         })));
-    auto &is_lepton = GenFunction::register_function<bool(int)>("is_lepton", FUNC(([ie=&is_electron, im=&is_muon](int pdgId)
-        {
+    auto &is_lepton = GenFunction::register_function<bool(int)>("is_lepton",
+        FUNC(([ie=&is_electron, im=&is_muon](int pdgId) {
             return (*ie)(pdgId) || (*im)(pdgId);
         })));
 
@@ -204,7 +248,7 @@ void declare_values(MiniTreeDataSet& mt){
 
 
     fv::pair<int, int>("genEle_count", "recEle_count", "genEle_count_v_recEle_count");
-    fv::pair<int, int>("genMu_count", "recMu_count", "genMu_count_v_recMu_count");
+    fv::pair<int, int>("genMu_count",  "recMu_count",  "genMu_count_v_recMu_count");
     fv::pair<int, int>("genLep_count", "recLep_count", "genLep_count_v_recLep_count");
 
     obs_filter("trilepton", FUNC(([nLepGood=lookup<int>("nLepGood")]()
@@ -230,65 +274,49 @@ void declare_containers(MiniTreeDataSet& mt){
 
     mt.register_container<ContainerTH1<int>>("lepton_count", "Lepton Multiplicity", lookup<int>("nLepGood"), 8, 0, 8);
 
-    mt.register_container<ContainerTH1Many<float>>("LepGood_energy_all", "Lepton Energy - All",
-                                                      lookup<vector<float>>("LepGood_energy"), 50, 0, 500);
-    mt.register_container<ContainerTH1<float>>("LepGood_energy_max", "Lepton Energy - Max",
-                                                  lookup<float>("LepGood_energy_max"), 50, 0, 500,
-                                                  "Lepton Energy Max(GeV)");
-    mt.register_container<ContainerTH1<float>>("LepGood_energy_min", "Lepton Energy - Min",
-                                                  lookup<float>("LepGood_energy_min"), 50, 0, 500,
-                                                  "Lepton Energy Min(GeV)");
-    mt.register_container<ContainerTH1<float>>("LepGood_energy_range", "Lepton Energy - Range",
-                                                  lookup<float>("LepGood_energy_range"), 50, 0, 500,
-                                                  "Lepton Energy Range(GeV)");
-
-    mt.register_container<ContainerTH1Many<float>>("Jet_pt", "Jet P_T",
+    mt.register_container<ContainerTH1Many<float>>("Jet_pt_dist", "Jet P_T",
                                                       lookup<vector<float>>("Jet_pt"), 50, 0, 500,
                                                       "Jet P_T");
-    mt.register_container<ContainerTH1Many<float>>("Jet_eta", "Jet Eta",
+    mt.register_container<ContainerTH1Many<float>>("Jet_eta_dist", "Jet Eta",
                                                       lookup<vector<float>>("Jet_eta"), 50, -3, 3,
                                                       "Jet Eta");
-    mt.register_container<ContainerTH1Many<float>>("Jet_phi", "Jet Phi",
+    mt.register_container<ContainerTH1Many<float>>("Jet_phi_dist", "Jet Phi",
                                                       lookup<vector<float>>("Jet_phi"), 20, -PI, PI,
                                                       "Jet Phi");
-    mt.register_container<ContainerTH1Many<float>>("Jet_mass", "Jet Mass",
+    mt.register_container<ContainerTH1Many<float>>("Jet_mass_dist", "Jet Mass",
                                                       lookup<vector<float>>("Jet_mass"), 50, 0, 200,
                                                       "Jet Mass");
 
     mt.register_container<ContainerTH1Many<float>>("dijet_inv_mass", "Di-Jet Inv. Mass - All",
-                                                      lookup<vector<float>>("di-jet_inv_mass"), 100, 0, 500,
+                                                      lookup<vector<float>>("dijet_inv_mass"), 100, 0, 500,
                                                       "Di-Jet Mass");
     mt.register_container<ContainerTH1Many<float>>("dijet_inv_mass_osdilepton", "Di-Jet Inv. Mass - OS Dilepton",
-                                                      lookup<vector<float>>("di-jet_inv_mass"), 100, 0, 500,
+                                                      lookup<vector<float>>("dijet_inv_mass"), 100, 0, 500,
                                                       "Di-Jet Mass")->add_filter(lookup_obs_filter("os-dilepton"));
     mt.register_container<ContainerTH1Many<float>>("dijet_inv_mass_ssdilepton", "Di-Jet Inv. Mass - SS Dilepton",
-                                                      lookup<vector<float>>("di-jet_inv_mass"), 100, 0, 500,
+                                                      lookup<vector<float>>("dijet_inv_mass"), 100, 0, 500,
                                                       "Di-Jet Mass")->add_filter(lookup_obs_filter("ss-dilepton"));
     mt.register_container<ContainerTH1Many<float>>("dijet_inv_mass_trilepton", "Di-Jet Inv. Mass - Trilepton",
-                                                      lookup<vector<float>>("di-jet_inv_mass"), 100, 0, 500,
+                                                      lookup<vector<float>>("dijet_inv_mass"), 100, 0, 500,
                                                       "Di-Jet Mass")->add_filter(lookup_obs_filter("trilepton"));
 
-    mt.register_container<ContainerTH1Many<float>>("rec_top_mass", "Reconstructed top mass",
-                                                      lookup<vector<float>>("rec_top_mass"), 100, 0, 500,
+    mt.register_container<ContainerTH1Many<float>>("reco_top_mass", "Reconstructed Top mass",
+                                                      lookup<vector<float>>("reco_top_mass"), 100, 0, 500,
+                                                      "Tri-jet invarient mass");
+    /* mt.register_container<ContainerTH1Many<float>>("reco_top_pt", "Reconstructed Top Pt", */
+    /*                                                   lookup<vector<float>>("reco_top_pt"), 100, 0, 500, */
+    /*                                                   "Tri-jet Pt"); */
+
+    mt.register_container<ContainerTH1Many<float>>("mc_top_mass", "Reconstructed MC Top mass",
+                                                      lookup<vector<float>>("mc_top_mass"), 100, 0, 500,
                                                       "Tri-jet invarient mass");
 
-    mt.register_container<ContainerTH1Many<float>>("Jet_energy", "Jet Energy",
-                                                      lookup<vector<float>>("Jet_energy"), 100, 0, 400,
-                                                      "Jet Energy");
-    mt.register_container<ContainerTH2Many<float>>("Jet_energy_vs_Jet_eta", "Jet Energy vs Jet Eta",
-                                                      lookup<std::pair<vector<float>, vector<float>>>("Jet_energy_vs_Jet_eta"),
-                                                      100, 0, 400, 50, -3, 3,
-                                                      "Jet Energy", "Jet Eta");
 
     mt.register_container<ContainerTH2<int>>("nLepvsnJet", "Number of Leptons vs Number of Jets",
                                               fv::pair<int, int>("nLepGood", "nJet"),
                                               7, 0, 7, 20, 0, 20,
                                               "Number of Leptons", "Number of Jets");
 
-    mt.register_container<ContainerTH2Many<float>>("LepGood_energy_vs_pt", "Lepton Energy vs Lepton Pt",
-                                                      lookup<std::pair<std::vector<float>,std::vector<float>>>("LepGood_energy_LepGood_pt"),
-                                                      50, 0, 500, 50, 0, 500,
-                                                      "lepton energy","lepton Pt");
 
     mt.register_container<ContainerTH2<int>>("genEle_count_v_recEle_count", "Number of Generated Electrons v. Number of Reconstructed Electrons",
                                                 lookup<std::pair<int,int>>("genEle_count_v_recEle_count"),
@@ -320,20 +348,33 @@ void declare_containers(MiniTreeDataSet& mt){
     mt.register_container<CounterMany<int>>("GenPart_pdgId_counter", lookup<vector<int>>("GenPart_pdgId"));
 
 
-    mt.register_container<Vector<vector< int >>>("GenPart_pdgId",          lookup<vector< int >>("GenPart_pdgId"));
-    mt.register_container<Vector<vector< int >>>("GenPart_motherIndex",    lookup<vector< int >>("GenPart_motherIndex"));
-    mt.register_container<Vector<vector< int >>>("GenPart_motherId",       lookup<vector< int >>("GenPart_motherId"));
-    mt.register_container<Vector<vector<float>>>("GenPart_pt",             lookup<vector<float>>("GenPart_pt"));
-    mt.register_container<Vector<vector<float>>>("GenPart_energy",         lookup<vector<float>>("GenPart_energy"));
-    mt.register_container<Vector<vector< int >>>("GenPart_status",         lookup<vector< int >>("GenPart_status"));
+    mt.register_container<Vector<std::vector< int >>>("GenPart_pdgId",       lookup<std::vector< int >>("GenPart_pdgId"));
+    mt.register_container<Vector<std::vector< int >>>("GenPart_motherIndex", lookup<std::vector< int >>("GenPart_motherIndex"));
+    mt.register_container<Vector<std::vector< int >>>("GenPart_motherId",    lookup<std::vector< int >>("GenPart_motherId"));
+    mt.register_container<Vector<std::vector<float>>>("GenPart_pt",          lookup<std::vector<float>>("GenPart_pt"));
+    mt.register_container<Vector<std::vector<float>>>("GenPart_eta",         lookup<std::vector<float>>("GenPart_eta"));
+    mt.register_container<Vector<std::vector<float>>>("GenPart_phi",         lookup<std::vector<float>>("GenPart_phi"));
+    mt.register_container<Vector<std::vector<float>>>("GenPart_mass",        lookup<std::vector<float>>("GenPart_mass"));
+    mt.register_container<Vector<std::vector<float>>>("GenPart_energy",      lookup<std::vector<float>>("GenPart_energy"));
+    mt.register_container<Vector<std::vector< int >>>("GenPart_status",      lookup<std::vector< int >>("GenPart_status"));
+
+    mt.register_container<Vector<vector< int >>>("LepGood_mcMatchId",        lookup<vector< int >>("LepGood_mcMatchId"));
+    mt.register_container<Vector<vector< int >>>("LepGood_mcMatchPdgId",     lookup<vector< int >>("LepGood_mcMatchPdgId"));
+
+    mt.register_container<Vector< int >>("run",                              lookup< int >("run") );
+    mt.register_container<Vector< int >>("lumi",                             lookup< int >("lumi"));
+    mt.register_container<Vector< int >>("evt",                              lookup< int >("evt") );
+    mt.register_container<Vector<float>>("xsec",                             lookup<float>("xsec"));
+
+    mt.register_container<Vector<std::vector< int >>>("Jet_mcMatchFlav",     lookup<std::vector< int >>("Jet_mcMatchFlav"));
+    mt.register_container<Vector<std::vector< int >>>("Jet_mcMatchId",       lookup<std::vector< int >>("Jet_mcMatchId"));
+    mt.register_container<Vector<std::vector< int >>>("Jet_mcFlavour",       lookup<std::vector< int >>("Jet_mcFlavour"));
 
-    mt.register_container<Vector<vector< int >>>("LepGood_mcMatchId",      lookup<vector< int >>("LepGood_mcMatchId"));
-    mt.register_container<Vector<vector< int >>>("LepGood_mcMatchPdgId",   lookup<vector< int >>("LepGood_mcMatchPdgId"));
+    mt.register_container<Vector<std::vector<float>>>("Jet_pt",              lookup<std::vector<float>>("Jet_pt"));
+    mt.register_container<Vector<std::vector<float>>>("Jet_eta",             lookup<std::vector<float>>("Jet_eta"));
+    mt.register_container<Vector<std::vector<float>>>("Jet_phi",             lookup<std::vector<float>>("Jet_phi"));
+    mt.register_container<Vector<std::vector<float>>>("Jet_mass",            lookup<std::vector<float>>("Jet_mass"));
 
-    mt.register_container<Vector< int >>("run",  lookup< int >("run") );
-    mt.register_container<Vector< int >>("lumi", lookup< int >("lumi"));
-    mt.register_container<Vector< int >>("evt",  lookup< int >("evt") );
-    mt.register_container<Vector<float>>("xsec", lookup<float>("xsec"));
 }
 
 

docs/api_8hpp.html

@@ -120,10 +120,10 @@ template&lt;typename... ArgTypes&gt; </td></tr>
 template&lt;typename Ret , typename... ArgTypes&gt; </td></tr>
 <tr class="memitem:a5f6cddf787ea43504071ae6241009c98"><td class="memTemplItemLeft" align="right" valign="top">Value&lt; std::vector&lt; Ret &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>fv::map</b> (Function&lt; Ret(ArgTypes...)&gt; &amp;fn, Value&lt; std::vector&lt; std::tuple&lt; ArgTypes... &gt;&gt;&gt; *arg, const std::string &amp;alias=&quot;&quot;)</td></tr>
 <tr class="separator:a5f6cddf787ea43504071ae6241009c98"><td class="memSeparator" colspan="2">&#160;</td></tr>
-<tr class="memitem:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memTemplParams" colspan="2"><a id="a3ba1ce087736f18af3360ea1e418d2c7"></a>
+<tr class="memitem:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memTemplParams" colspan="2"><a id="ad1aca7a0eb3a862c635286c5d65f0cfd"></a>
 template&lt;typename... ArgTypes&gt; </td></tr>
-<tr class="memitem:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memTemplItemLeft" align="right" valign="top">Value&lt; std::tuple&lt; ArgTypes... &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>fv::tuple</b> (Value&lt; ArgTypes &gt; *... args, const std::string &amp;alias=&quot;&quot;)</td></tr>
-<tr class="separator:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memTemplItemLeft" align="right" valign="top">Value&lt; std::tuple&lt; ArgTypes... &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>fv::tuple</b> (Value&lt; ArgTypes &gt; *... args)</td></tr>
+<tr class="separator:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a3951826aff6680e2d587fb6fb08e7526"><td class="memTemplParams" colspan="2"><a id="a3951826aff6680e2d587fb6fb08e7526"></a>
 template&lt;size_t N, typename... ArgTypes&gt; </td></tr>
 <tr class="memitem:a3951826aff6680e2d587fb6fb08e7526"><td class="memTemplItemLeft" align="right" valign="top">Value&lt; typename std::tuple_element&lt; N, std::tuple&lt; ArgTypes... &gt; &gt;::type &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>fv::detup</b> (Value&lt; std::tuple&lt; ArgTypes... &gt;&gt; *tup, const std::string &amp;alias=&quot;&quot;)</td></tr>

docs/classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4-members.html

@@ -76,14 +76,15 @@ $(function() {
   <tr bgcolor="#f0f0f0"><td class="entry"><b>Function</b>(const std::string &amp;name, std::function&lt; R(ArgTypes...)&gt; f) (defined in <a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a>)</td><td class="entry"><a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
   <tr class="even"><td class="entry"><a class="el" href="classfv_1_1GenFunction.html#a62f52779bd4aa60fefbd842f557b1f7d">function_registry</a></td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
   <tr bgcolor="#f0f0f0"><td class="entry"><b>GenFunction</b>(const std::string &amp;name, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>get_name</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>in_register_function</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">protected</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>lookup_function</b>(const std::string &amp;name) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>operator()</b>(ArgTypes ...args) (defined in <a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a>)</td><td class="entry"><a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>register_function</b>(const std::string &amp;name, std::function&lt; T &gt; f, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>summary</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>~Function</b>() (defined in <a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a>)</td><td class="entry"><a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>~GenFunction</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">virtual</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>get_impl</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>get_name</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>in_register_function</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">protected</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>lookup_function</b>(const std::string &amp;name) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>operator()</b>(ArgTypes ...args) (defined in <a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a>)</td><td class="entry"><a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>register_function</b>(const std::string &amp;name, std::function&lt; T &gt; f, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>summary</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>~Function</b>() (defined in <a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a>)</td><td class="entry"><a class="el" href="classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html">fv::Function&lt; R(ArgTypes...)&gt;</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>~GenFunction</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">virtual</span></td></tr>
 </table></div><!-- contents -->
 <!-- start footer part -->
 <hr class="footer"/><address class="footer"><small>

docs/classfv_1_1Function_3_01R_07ArgTypes_8_8_8_08_4.html

@@ -111,6 +111,9 @@ R&#160;</td><td class="memItemRight" valign="bottom"><b>operator()</b> (ArgTypes
 <tr class="memitem:ac821bad86421d773af1ba36f67174eb1 inherit pub_methods_classfv_1_1GenFunction"><td class="memItemLeft" align="right" valign="top"><a id="ac821bad86421d773af1ba36f67174eb1"></a>
 std::string &amp;&#160;</td><td class="memItemRight" valign="bottom"><b>get_name</b> ()</td></tr>
 <tr class="separator:ac821bad86421d773af1ba36f67174eb1 inherit pub_methods_classfv_1_1GenFunction"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a11d3571bfc71bb231082617334fd0301 inherit pub_methods_classfv_1_1GenFunction"><td class="memItemLeft" align="right" valign="top"><a id="a11d3571bfc71bb231082617334fd0301"></a>
+std::string &amp;&#160;</td><td class="memItemRight" valign="bottom"><b>get_impl</b> ()</td></tr>
+<tr class="separator:a11d3571bfc71bb231082617334fd0301 inherit pub_methods_classfv_1_1GenFunction"><td class="memSeparator" colspan="2">&#160;</td></tr>
 </table><table class="memberdecls">
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pri-attribs"></a>
 Private Attributes</h2></td></tr>

docs/classfv_1_1GenFunction-members.html

@@ -73,14 +73,15 @@ $(function() {
   <tr class="even"><td class="entry"><a class="el" href="classfv_1_1GenFunction.html#aecc1187b5bb9c551c104eb8478bdb567">format_code</a>(const std::string &amp;code)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
   <tr><td class="entry"><a class="el" href="classfv_1_1GenFunction.html#a62f52779bd4aa60fefbd842f557b1f7d">function_registry</a></td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
   <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>GenFunction</b>(const std::string &amp;name, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>get_name</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>impl</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">private</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>in_register_function</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">protected</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>lookup_function</b>(const std::string &amp;name) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>name</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">private</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>register_function</b>(const std::string &amp;name, std::function&lt; T &gt; f, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0"><td class="entry"><b>summary</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
-  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>~GenFunction</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">virtual</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>get_impl</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>get_name</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>impl</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">private</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>in_register_function</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">protected</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>lookup_function</b>(const std::string &amp;name) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>name</b> (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">private</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>register_function</b>(const std::string &amp;name, std::function&lt; T &gt; f, const std::string &amp;impl) (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>summary</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+  <tr bgcolor="#f0f0f0"><td class="entry"><b>~GenFunction</b>() (defined in <a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a>)</td><td class="entry"><a class="el" href="classfv_1_1GenFunction.html">fv::GenFunction</a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">virtual</span></td></tr>
 </table></div><!-- contents -->
 <!-- start footer part -->
 <hr class="footer"/><address class="footer"><small>

docs/classfv_1_1GenFunction.html

@@ -96,6 +96,9 @@ Public Member Functions</h2></td></tr>
 <tr class="memitem:ac821bad86421d773af1ba36f67174eb1"><td class="memItemLeft" align="right" valign="top"><a id="ac821bad86421d773af1ba36f67174eb1"></a>
 std::string &amp;&#160;</td><td class="memItemRight" valign="bottom"><b>get_name</b> ()</td></tr>
 <tr class="separator:ac821bad86421d773af1ba36f67174eb1"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a11d3571bfc71bb231082617334fd0301"><td class="memItemLeft" align="right" valign="top"><a id="a11d3571bfc71bb231082617334fd0301"></a>
+std::string &amp;&#160;</td><td class="memItemRight" valign="bottom"><b>get_impl</b> ()</td></tr>
+<tr class="separator:a11d3571bfc71bb231082617334fd0301"><td class="memSeparator" colspan="2">&#160;</td></tr>
 </table><table class="memberdecls">
 <tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-methods"></a>
 Static Public Member Functions</h2></td></tr>

docs/namespacefv.html

@@ -209,10 +209,10 @@ template&lt;typename... ArgTypes&gt; </td></tr>
 template&lt;typename Ret , typename... ArgTypes&gt; </td></tr>
 <tr class="memitem:a5f6cddf787ea43504071ae6241009c98"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classfv_1_1Value.html">Value</a>&lt; std::vector&lt; Ret &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>map</b> (Function&lt; Ret(ArgTypes...)&gt; &amp;fn, <a class="el" href="classfv_1_1Value.html">Value</a>&lt; std::vector&lt; std::tuple&lt; ArgTypes... &gt;&gt;&gt; *arg, const std::string &amp;alias=&quot;&quot;)</td></tr>
 <tr class="separator:a5f6cddf787ea43504071ae6241009c98"><td class="memSeparator" colspan="2">&#160;</td></tr>
-<tr class="memitem:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memTemplParams" colspan="2"><a id="a3ba1ce087736f18af3360ea1e418d2c7"></a>
+<tr class="memitem:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memTemplParams" colspan="2"><a id="ad1aca7a0eb3a862c635286c5d65f0cfd"></a>
 template&lt;typename... ArgTypes&gt; </td></tr>
-<tr class="memitem:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classfv_1_1Value.html">Value</a>&lt; std::tuple&lt; ArgTypes... &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>tuple</b> (<a class="el" href="classfv_1_1Value.html">Value</a>&lt; ArgTypes &gt; *... args, const std::string &amp;alias=&quot;&quot;)</td></tr>
-<tr class="separator:a3ba1ce087736f18af3360ea1e418d2c7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classfv_1_1Value.html">Value</a>&lt; std::tuple&lt; ArgTypes... &gt; &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>tuple</b> (<a class="el" href="classfv_1_1Value.html">Value</a>&lt; ArgTypes &gt; *... args)</td></tr>
+<tr class="separator:ad1aca7a0eb3a862c635286c5d65f0cfd"><td class="memSeparator" colspan="2">&#160;</td></tr>
 <tr class="memitem:a3951826aff6680e2d587fb6fb08e7526"><td class="memTemplParams" colspan="2"><a id="a3951826aff6680e2d587fb6fb08e7526"></a>
 template&lt;size_t N, typename... ArgTypes&gt; </td></tr>
 <tr class="memitem:a3951826aff6680e2d587fb6fb08e7526"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classfv_1_1Value.html">Value</a>&lt; typename std::tuple_element&lt; N, std::tuple&lt; ArgTypes... &gt; &gt;::type &gt; *&#160;</td><td class="memTemplItemRight" valign="bottom"><b>detup</b> (<a class="el" href="classfv_1_1Value.html">Value</a>&lt; std::tuple&lt; ArgTypes... &gt;&gt; *tup, const std::string &amp;alias=&quot;&quot;)</td></tr>

filval/api.hpp

@@ -70,8 +70,8 @@ namespace fv{
 
     template <typename... ArgTypes>
     Value<std::tuple<ArgTypes...>>*
-    tuple(Value<ArgTypes>*... args, const std::string& alias=""){
-        return new Tuple<ArgTypes...>(args..., alias);
+    tuple(Value<ArgTypes>*... args){
+        return new Tuple<ArgTypes...>(args..., "");
     }
 
     template <size_t N, typename... ArgTypes>

filval/dataset.hpp

@@ -67,6 +67,15 @@ class DataSet{
                 value_map[container.first] = container.second->get_value_name();
             return value_map;
         }
+
+        std::map<std::string,std::string> get_function_name_impl_map(){
+            std::map<std::string, std::string> impl_map;
+            for(auto fn : GenFunction::function_registry)
+                if (fn.second != nullptr){
+                    impl_map[fn.first] = GenFunction::format_code(fn.second->get_impl());
+                }
+            return impl_map;
+        }
     public:
         void process(bool silent=false){
             int events, current_event;

filval/value.hpp

@@ -164,6 +164,10 @@ class GenFunction {
             return name;
         }
 
+        std::string& get_impl(){
+            return impl;
+        }
+
         /**
          * Attempt to invoke clang-format for the purpose of printing out
          * nicely formatted functions to the log file. If clang-format is not

python/graph_vals.py

@@ -2,7 +2,6 @@ import pydotplus.graphviz as pdp
 import sys
 import re
 
-
 def parse(str_in, alias=None):
     str_in = "("+str_in+")"
 

python/utils.py

@@ -31,7 +31,7 @@ PDG = {1:   'd',   -1:  'd̄',
        15:  'τ-',  -15: 'τ+',
        16:  'ν_τ', -16: 'ῡ_τ',
 
-       21:  'gluon',
+       21:  'g',
        22:  'γ',
        23:  'Z0',
        24:  'W+',  -24: 'W-',
@@ -92,7 +92,11 @@ def show_value(container):
     if type(container) != str:
         container = container.GetName().split(':')[1]
     g = parse(VALUES[container], container)
-    return Image(g.create_gif())
+    try:
+        return Image(g.create_gif())
+    except Exception as e:
+        print(e)
+        print(g.to_string())
 
 
 class OutputCapture: