#include "WCPPID/NeutrinoID.h"

#include "WCPData/TPCParams.h"
#include "WCPData/Singleton.h"

#include <boost/graph/connected_components.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>

#include "WCPPaal/graph_metrics.h"
#include "WCPPaal/steiner_tree_greedy.h"

#include "WCPData/Line.h"

using namespace WCP;

#include "NeutrinoID_proto_vertex.h"
#include "NeutrinoID_final_structure.h"
#include "NeutrinoID_improve_vertex.h"
#include "NeutrinoID_examine_structure.h"
#include "NeutrinoID_deghost.h"
#include "NeutrinoID_track_shower.h"
#include "NeutrinoID_energy_reco.h"
#include "NeutrinoID_shower_clustering.h"
#include "NeutrinoID_em_shower.h"

#include "NeutrinoID_cosmic_tagger.h"
#include "NeutrinoID_numu_tagger.h"
#include "NeutrinoID_nue_tagger.h"
#include "NeutrinoID_nue_functions.h"
#include "NeutrinoID_pio_tagger.h"
#include "NeutrinoID_singlephoton_tagger.h"

#include "NeutrinoID_numu_bdts.h"
#include "NeutrinoID_nue_bdts.h"
#include "NeutrinoID_DL.h"

#include "NeutrinoID_kine.h"

WCPPID::NeutrinoID::NeutrinoID(WCPPID::PR3DCluster* main_cluster1, std::vector<WCPPID::PR3DCluster*>& other_clusters1,
                               std::vector<WCPPID::PR3DCluster*>& all_clusters1, WCPPID::ToyFiducial* fid,
                               WCPSst::GeomDataSource& gds, int nrebin, int frame_length, float unit_dis,
                               ToyCTPointCloud* ct_point_cloud,
                               std::map<int, std::map<const GeomWire*, SMGCSelection> >& global_wc_map,
                               double flash_time, double offset_x, int flag_neutrino_id_process, int flag_bdt,
                               bool flag_dl_vtx, double dl_vtx_cut, float match_isFC)
  : acc_vertex_id(0)
  , acc_segment_id(0)
  , main_cluster(main_cluster1)
  , other_clusters(other_clusters1)
  , all_clusters(all_clusters1)
  , fid(fid)
  , ct_point_cloud(ct_point_cloud)
  , global_wc_map(global_wc_map)
  , flash_time(flash_time)
  , offset_x(offset_x)
  , flag_neutrino_id_process(flag_neutrino_id_process)
  , type(0)
  , main_vertex(0)
  , main_cluster_initial_pair_vertices(std::make_pair((WCPPID::ProtoVertex*) 0, (WCPPID::ProtoVertex*) 0))
  , neutrino_type(0)
  , flag_bdt(flag_bdt)
  , flag_dl_vtx(flag_dl_vtx)
  , dl_vtx_cut(dl_vtx_cut)
  , match_isFC(match_isFC)
{
    bool flag_other_clusters = true;
    bool flag_main_cluster = true;
    bool flag_tagger = true;

    init_tagger_info();

    // hack the main cluster
    // for (auto it = other_clusters.begin(); it != other_clusters.end(); it++){
    //   WCPPID::PR3DCluster *cluster = *it;
    //   if (cluster->get_cluster_id()==67) {
    //     swap_main_cluster(cluster);
    //     break;
    //   }
    // }

    // form id vs. cluster ...

    map_id_cluster[main_cluster->get_cluster_id()] = main_cluster;
    main_cluster->create_steiner_graph(*ct_point_cloud, gds, nrebin, frame_length, unit_dis);
    {
        std::pair<WCP::WCPointCloud<double>::WCPoint, WCP::WCPointCloud<double>::WCPoint> two_wcps =
            main_cluster->get_two_boundary_wcps();
        map_cluster_length[main_cluster] =
            sqrt(pow(two_wcps.first.x - two_wcps.second.x, 2) + pow(two_wcps.first.y - two_wcps.second.y, 2) +
                 pow(two_wcps.first.z - two_wcps.second.z, 2));
    }

    if (flag_other_clusters) {
        for (auto it = other_clusters.begin(); it != other_clusters.end(); it++) {
            map_id_cluster[(*it)->get_cluster_id()] = *it;
            (*it)->create_steiner_graph(*ct_point_cloud, gds, nrebin, frame_length, unit_dis);
            std::pair<WCP::WCPointCloud<double>::WCPoint, WCP::WCPointCloud<double>::WCPoint> two_wcps =
                (*it)->get_two_boundary_wcps();
            double length =
                sqrt(pow(two_wcps.first.x - two_wcps.second.x, 2) + pow(two_wcps.first.y - two_wcps.second.y, 2) +
                     pow(two_wcps.first.z - two_wcps.second.z, 2));
            map_cluster_length[*it] = length;
        }
    }

    // std::cout << main_cluster->get_num_mcells() << " " << map_cluster_length[main_cluster]/units::cm << std::endl;
    // for  (auto it = other_clusters.begin(); it!=other_clusters.end(); it++){
    //  std::cout << (*it)->get_num_mcells() << " " << map_cluster_length[*it]/units::cm << std::endl;
    // }
    // hack switch
    // {
    //   auto it = find(other_clusters.begin(), other_clusters.end(), max_length_cluster);
    //   other_clusters.erase(it);
    //   other_clusters.push_back(main_cluster);
    //   main_cluster = max_length_cluster;
    // }

    if (map_cluster_length[main_cluster] < 3 * units::cm) return;

    if (flag_main_cluster) {
        // find the proto vertex ...
        find_proto_vertex(main_cluster, true, 2);

        // deal with shower ...
        clustering_points(main_cluster);
        separate_track_shower(main_cluster);
        determine_direction(main_cluster);

        shower_determing_in_main_cluster(main_cluster);
        determine_main_vertex(main_cluster);
        // improve_vertex(main_cluster, false); // do not search for vertex activities ...

        if (main_vertex != 0) {
            map_cluster_main_vertices[main_cluster] = main_vertex;
            main_vertex = 0;
        }
    }

    // loop over other clusters ...
    if (flag_other_clusters) {
        for (auto it = other_clusters.begin(); it != other_clusters.end(); it++) {
            // if (skip_clusters.find(*it) != skip_clusters.end()) continue;
            // if ((*it)->get_cluster_id()!=75) continue;
            // std::cout << (*it)->get_cluster_id() << " " << map_cluster_length[*it]/units::cm << std::endl;

            if (map_cluster_length[*it] > 6 * units::cm) {
                // find the proto vertex ...
                find_proto_vertex(*it, true, 2);
                // deal with shower ...
                clustering_points(*it);
                separate_track_shower(*it);
                determine_direction(*it);
                shower_determing_in_main_cluster(*it);
                determine_main_vertex(*it, false);
                // improve_vertex(main_cluster, false); // do not search for vertex activity

                if (main_vertex != 0) {
                    map_cluster_main_vertices[*it] = main_vertex;
                    main_vertex = 0;
                }
            }
            else {
                if (!find_proto_vertex(*it, false, 1)) init_point_segment(*it);

                clustering_points(*it);
                separate_track_shower(*it);
                determine_direction(*it);
                shower_determing_in_main_cluster(*it);
                determine_main_vertex(*it, false);
                if (main_vertex != 0) {
                    map_cluster_main_vertices[*it] = main_vertex;
                    main_vertex = 0;
                }
            }
        }

        //  deghost ...
        deghosting();
    }

    if (flag_main_cluster) {
        if (flag_dl_vtx) {
            bool flag_change = determine_overall_main_vertex_DL();
            if (!flag_change) determine_overall_main_vertex();
        }
        else {
            determine_overall_main_vertex();
        }
    }

    if (flag_main_cluster && main_vertex != 0) {
        // fit the vertex in 3D
        improve_vertex(main_cluster, true, true);

        clustering_points(main_cluster);
        examine_direction(main_vertex);

        std::cout << "Overall main Vertex " << main_vertex->get_fit_pt() << " connecting to: ";
        for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); it++) {
            std::cout << (*it)->get_id() << ", ";
        }
        std::cout << " in cluster " << main_vertex->get_cluster_id() << std::endl;
        print_segs_info(main_vertex->get_cluster_id(), main_vertex);

        // overall
        separate_track_shower();
        // for charge based on calculation ...
        collect_2D_charges();

        // cluster E&M ...
        shower_clustering_with_nv();
    }

    if (flag_tagger) {
        fill_kine_tree(kine_info);

        bool flag_cosmic = cosmic_tagger();

        // set the cosmic flag anyway ...
        // if (flag_cosmic) tagger_info.cosmic_flag = false;

        auto results = numu_tagger();
        bool flag_long_muon = results.first;

        nue_tagger(results.second);

        bool flag_sp = singlephoton_tagger(results.second);
        std::cout << "NeutrinoID.cxx line 241" << std::endl;
        if (flag_sp) {
            tagger_info.photon_flag = true;
        }
    }

    if (flag_bdt > 0) tagger_info.numu_score = cal_numu_bdts_xgboost();

    if (flag_bdt == 1) {
        // Xgboost training ...
        tagger_info.nue_score = cal_bdts_xgboost();
    }
    else if (flag_bdt == 2) {
        // TMVA training ...
        tagger_info.nue_score = cal_bdts();
        // numuCC TMVA training ...
    }

    // std::cout << "Final Information: " << std::endl;
    // print_segs_info(main_vertex);

    // for (auto it = map_segment_vertices.begin(); it!= map_segment_vertices.end(); it++){
    //   auto pair_vertices = find_vertices(it->first);
    //   if (pair_vertices.first->get_cluster_id() != pair_vertices.second->get_cluster_id())
    //     std::cout << pair_vertices.first->get_cluster_id() << " " << pair_vertices.second->get_cluster_id() <<
    //     std::endl;
    // }

    // prepare output ...
    fill_fit_parameters();
}

void WCPPID::NeutrinoID::determine_overall_main_vertex()
{
    PR3DCluster* max_length_cluster = 0;
    double max_length = 0;
    for (auto it = map_cluster_length.begin(); it != map_cluster_length.end(); it++) {
        double length = it->second;
        if (length > max_length) {
            max_length = length;
            max_length_cluster = it->first;
        }
    }

    // check main vertices ...
    examine_main_vertices();

    if (flag_neutrino_id_process == 1) {
        // development chain ...
        check_switch_main_cluster();
    }
    else {
        // frozen chain
        if (max_length > map_cluster_length[main_cluster] * 0.8)
            check_switch_main_cluster(map_cluster_main_vertices[main_cluster], max_length_cluster);
    }

    main_vertex = map_cluster_main_vertices[main_cluster];

    // examine the track connected to it ...
    for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); it++) {
        WCPPID::ProtoSegment* sg = *it;
        auto pair_results = calculate_num_daughter_showers(main_vertex, sg, false);
        if (pair_results.first == 1 && sg->get_length() < 1.5 * units::cm &&
            sg->get_medium_dQ_dx() / (43e3 / units::cm) > 1.6) {
            TPCParams& mp = Singleton<TPCParams>::Instance();
            sg->set_particle_type(2212);
            sg->set_particle_mass(mp.get_mass_proton());
            sg->cal_4mom();
            //    std::cout << pair_results.first << " " << sg->get_length()/units::cm << " " <<
            //    sg->get_medium_dQ_dx()/(43e3/units::cm) << std::endl; if (sg->get_length()<1*units::cm &&
            //    pair_results.
        }
    }

    // clean up long muons ...
    {
        std::set<WCPPID::ProtoSegment*> tmp_segments;
        std::set<WCPPID::ProtoVertex*> tmp_vertices;
        for (auto it = segments_in_long_muon.begin(); it != segments_in_long_muon.end(); it++) {
            if ((*it)->get_cluster_id() != main_vertex->get_cluster_id()) tmp_segments.insert(*it);
        }
        for (auto it = vertices_in_long_muon.begin(); it != vertices_in_long_muon.end(); it++) {
            if ((*it)->get_cluster_id() != main_vertex->get_cluster_id()) tmp_vertices.insert(*it);
        }
        for (auto it = tmp_segments.begin(); it != tmp_segments.end(); it++) {
            segments_in_long_muon.erase(*it);
        }
        for (auto it = tmp_vertices.begin(); it != tmp_vertices.end(); it++) {
            vertices_in_long_muon.erase(*it);
        }
    }
}

void WCPPID::NeutrinoID::examine_main_vertices()
{
    double cluster_length_cut = std::min(map_cluster_length[main_cluster] * 0.6, 6 * units::cm);
    WCP::ToyPointCloud* pcloud = main_cluster->get_point_cloud_steiner();

    WCPPID::PR3DClusterSelection clusters_to_be_removed;
    for (auto it = map_cluster_main_vertices.begin(); it != map_cluster_main_vertices.end(); it++) {
        WCPPID::PR3DCluster* cluster = it->first;
        WCPPID::ProtoVertex* vertex = it->second;
        double length = map_cluster_length[cluster];
        //    std::cout << cluster->get_cluster_id() << " " << length/units::cm << std::endl;
        if (length < cluster_length_cut) {
            bool flag_removed = true;
            for (auto it1 = map_vertex_segments[vertex].begin(); it1 != map_vertex_segments[vertex].end(); it1++) {
                WCPPID::ProtoSegment* seg = *it1;
                //	std::cout << seg->get_cluster_id() << " " << seg->get_id() << " " << seg->get_flag_shower() << "
                //" << seg->get_flag_dir() << " " << seg->is_dir_weak() << " " << seg->get_particle_type() << " " <<
                //length/units::cm << " " << seg->get_medium_dQ_dx()/(43e3/units::cm) << std::endl;
                if ((!seg->get_flag_shower()) && seg->get_flag_dir() != 0 &&
                    ((!seg->is_dir_weak()) || seg->get_medium_dQ_dx() / (43e3 / units::cm) > 2)) {
                    flag_removed = false;
                    break;
                }
            }
            if (!flag_removed) {
                if (length < 5 * units::cm && pcloud->get_closest_dis(vertex->get_fit_pt()) > 100 * units::cm)
                    flag_removed = true;

                // std::cout << cluster->get_cluster_id() << " " << length/units::cm << " " <<
                // pcloud->get_closest_dis(vertex->get_fit_pt()) << std::endl;
            }
            if (flag_removed) clusters_to_be_removed.push_back(cluster);
        }
        else {
            if (pcloud->get_closest_dis(vertex->get_fit_pt()) > 200 * units::cm)
                clusters_to_be_removed.push_back(cluster);

            //   std::cout << cluster->get_cluster_id() << " " <<
            //   pcloud->get_closest_dis(vertex->get_fit_pt())/units::cm << std::endl;
        }
    }
    for (auto it = clusters_to_be_removed.begin(); it != clusters_to_be_removed.end(); it++) {
        map_cluster_main_vertices.erase(*it);
    }
    clusters_to_be_removed.clear();

    // additional cut to remove global main vertex candidates ...
    if (map_cluster_main_vertices.find(main_cluster) != map_cluster_main_vertices.end()) {
        std::map<int, bool> map_cluster_id_shower;
        for (auto it = map_cluster_main_vertices.begin(); it != map_cluster_main_vertices.end(); it++) {
            map_cluster_id_shower[it->first->get_cluster_id()] = true;
        }

        bool flag_main_vertex_all_showers = true;
        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            //      if (it->first->get_cluster_id() != main_cluster->get_cluster_id()) continue;
            WCPPID::ProtoSegment* sg = it->first;
            if (map_cluster_id_shower.find(sg->get_cluster_id()) == map_cluster_id_shower.end()) continue;
            if (!sg->get_flag_shower()) {
                map_cluster_id_shower[sg->get_cluster_id()] = false;
                // flag_main_vertex_all_showers = false;
            }
        }
        flag_main_vertex_all_showers = map_cluster_id_shower[main_cluster->get_cluster_id()];

        //    std::cout << main_cluster->get_cluster_id() << " " << flag_main_vertex_all_showers << std::endl;
        if (flag_main_vertex_all_showers) {
            TVector3 dir_main = calc_dir_cluster(main_cluster->get_cluster_id(),
                                                 map_cluster_main_vertices[main_cluster]->get_fit_pt(), 15 * units::cm);
            ToyPointCloud* pcloud = main_cluster->get_point_cloud_steiner();
            for (auto it = map_cluster_main_vertices.begin(); it != map_cluster_main_vertices.end(); it++) {
                if (it->first == main_cluster) continue;
                double closest_dis = pcloud->get_closest_dis(it->second->get_fit_pt());
                TVector3 dir1(it->second->get_fit_pt().x - map_cluster_main_vertices[main_cluster]->get_fit_pt().x,
                              it->second->get_fit_pt().y - map_cluster_main_vertices[main_cluster]->get_fit_pt().y,
                              it->second->get_fit_pt().z - map_cluster_main_vertices[main_cluster]->get_fit_pt().z);
                double angle = dir_main.Angle(dir1) / 3.14115926 * 180.;

                // std::cout << it->first->get_cluster_id() << " " << closest_dis/units::cm << " " <<
                // dir_main.Angle(dir1)/3.14115926*180. << " " << map_cluster_length[it->first]/units::cm << std::endl;

                if (angle < 10) {
                    if (map_cluster_length[it->first] < 15 * units::cm && closest_dis < 40 * units::cm) {
                        clusters_to_be_removed.push_back(it->first);
                    }
                    else if (map_cluster_length[it->first] < 7 * units::cm && closest_dis < 60 * units::cm) {
                        clusters_to_be_removed.push_back(it->first);
                    }
                }
                else if (angle > 160) {
                    if (map_cluster_id_shower[it->first->get_cluster_id()] &&
                        map_cluster_length[it->first] > 10 * units::cm &&
                        map_cluster_length[it->first] > 0.5 * map_cluster_length[main_cluster]) {
                        TVector3 dir2 =
                            calc_dir_cluster(it->first->get_cluster_id(), it->second->get_fit_pt(), 15 * units::cm);
                        double closest_dis = std::get<2>(
                            it->first->get_point_cloud()->get_closest_points(main_cluster->get_point_cloud()));
                        double angle = dir2.Angle(dir_main) / 3.1415926 * 180.;
                        if (closest_dis < 10 * units::cm && angle < 25) {
                            //	      clusters_to_be_removed.push_back(main_cluster);
                            swap_main_cluster(it->first);
                        }
                        //	    std::cout << dir2.Angle(dir_main)/3.1415926*180. << " " << closest_dis/units::cm <<
                        //std::endl;
                    }
                }
            }
        }

        for (auto it = clusters_to_be_removed.begin(); it != clusters_to_be_removed.end(); it++) {
            map_cluster_main_vertices.erase(*it);
        }
        clusters_to_be_removed.clear();
    }

    // for (auto it = map_cluster_main_vertices.begin(); it!= map_cluster_main_vertices.end(); it++){
    //   WCPPID::PR3DCluster* cluster = it->first;
    //   WCPPID::ProtoVertex* vertex = it->second;
    //   double length = map_cluster_length[cluster];
    //    std::cout << cluster->get_cluster_id() << " " << length/units::cm << " " << vertex->get_fit_pt() << std::endl;
    // }
}

void WCPPID::NeutrinoID::examine_main_vertices(WCPPID::ProtoVertexSelection& vertices)
{
    if (vertices.size() == 1) return;

    double max_length = 0;
    TPCParams& mp = Singleton<TPCParams>::Instance();
    std::set<WCPPID::ProtoVertex*> tmp_vertices;

    for (auto it = vertices.begin(); it != vertices.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        if (map_vertex_segments[vtx].size() == 1) {
            tmp_vertices.insert(vtx);
        }
        else {
            std::set<WCPPID::ProtoSegment*> used_segments;
            for (auto it1 = map_vertex_segments[vtx].begin(); it1 != map_vertex_segments[vtx].end(); it1++) {
                WCPPID::ProtoSegment* sg1 = *it1;
                if (sg1->get_length() < 10 * units::cm) continue;
                TVector3 dir1 = sg1->cal_dir_3vector(vtx->get_fit_pt(), 15 * units::cm);
                TVector3 dir3 = sg1->cal_dir_3vector(vtx->get_fit_pt(), 30 * units::cm);
                if (sg1->get_length() > max_length) max_length = sg1->get_length();
                for (auto it2 = it1; it2 != map_vertex_segments[vtx].end(); it2++) {
                    WCPPID::ProtoSegment* sg2 = *it2;
                    if (sg1 == sg2) continue;
                    if (sg2->get_length() < 10 * units::cm) continue;
                    TVector3 dir2 = sg2->cal_dir_3vector(vtx->get_fit_pt(), 15 * units::cm);
                    TVector3 dir4 = sg2->cal_dir_3vector(vtx->get_fit_pt(), 30 * units::cm);

                    // std::cout << sg1->get_length()/units::cm << " " << sg2->get_length()/units::cm << " " <<
                    // dir1.Angle(dir2)/3.1415926*180. << " " << dir3.Angle(dir4)/3.1415926*180. << " " <<
                    // sg1->get_particle_type() << " " << sg2->get_particle_type() << std::endl;

                    if ((dir1.Angle(dir2) / 3.1415926 * 180. > 165 || dir3.Angle(dir4) / 3.1415926 * 180. > 165) &&
                        (sg1->get_particle_type() == 13 || sg2->get_particle_type() == 13) &&
                        (sg1->get_length() > 30 * units::cm || sg2->get_length() > 30 * units::cm)) {
                        // std::cout << "Xin: " << sg1->get_id() << " " << sg1->get_particle_type() << " " <<
                        // sg1->get_length()/units::cm << std::endl; std::cout << "Xin: " << sg2->get_id() << " " <<
                        // sg2->get_particle_type() << " " << sg2->get_length()/units::cm << std::endl;

                        used_segments.insert(sg1);
                        used_segments.insert(sg2);
                    }
                    else if ((dir1.Angle(dir2) / 3.1415926 * 180. > 170 || dir3.Angle(dir4) / 3.1415926 * 180. > 170) &&
                             (sg1->get_particle_type() == 2212 &&
                                  (sg2->get_particle_type() == 0 || sg2->get_particle_type() == 2212) ||
                              sg2->get_particle_type() == 2212 &&
                                  (sg1->get_particle_type() == 0 || sg1->get_particle_type() == 2212)) &&
                             (sg1->get_length() > 20 * units::cm && sg2->get_length() > 20 * units::cm)) {
                        // std::cout << "Xin: " << sg1->get_id() << " " << sg1->get_particle_type() << " " <<
                        // sg1->get_length()/units::cm << std::endl; std::cout << "Xin: " << sg2->get_id() << " " <<
                        // sg2->get_particle_type() << " " << sg2->get_length()/units::cm << std::endl;

                        used_segments.insert(sg1);
                        used_segments.insert(sg2);
                    }

                }  // loop second track
            }      // loop first track

            if (used_segments.size() > 0) {
                bool flag_skip = true;
                for (auto it1 = map_vertex_segments[vtx].begin(); it1 != map_vertex_segments[vtx].end(); it1++) {
                    WCPPID::ProtoSegment* sg1 = *it1;
                    if (used_segments.find(sg1) != used_segments.end()) continue;
                    double length = sg1->get_length();
                    if (sg1->get_flag_shower()) {                                            // shower
                        auto pair_result = calculate_num_daughter_showers(vtx, sg1, false);  // count all
                        if (pair_result.second > 35 * units::cm) {
                            flag_skip = false;
                            break;
                        }
                    }
                    else {  // not shower
                        if ((!sg1->is_dir_weak()) && length > 6 * units::cm) {
                            flag_skip = false;
                            break;
                        }
                    }
                    // std::cout << sg1->get_id() << " " << sg1->get_length()/units::cm << " " << sg1->is_dir_weak() <<
                    // " " << sg1->get_particle_type() << std::endl;
                }
                if (!flag_skip)
                    tmp_vertices.insert(vtx);
                else {
                    // change direction ...
                    for (auto it1 = used_segments.begin(); it1 != used_segments.end(); it1++) {
                        WCPPID::ProtoSegment* sg1 = *it1;
                        // std::cout << sg1->get_id() << " " << sg1->get_length()/units::cm << std::endl;
                        if (sg1->get_flag_shower_trajectory())
                            continue;
                        else if (sg1->get_flag_shower_topology()) {
                            if (sg1->get_length() > 40 * units::cm && sg1->get_flag_dir() == 0) {
                                sg1->set_particle_type(13);
                                sg1->set_particle_mass(mp.get_mass_muon());
                                change_daughter_type(vtx, sg1, 13, mp.get_mass_muon());
                                change_daughter_type(find_other_vertex(sg1, vtx), sg1, 13, mp.get_mass_muon());
                                sg1->set_flag_shower_topology(false);
                            }
                            else
                                continue;
                        }
                        else if (sg1->get_particle_type() != 13) {
                            sg1->set_particle_type(13);
                            sg1->set_particle_mass(mp.get_mass_muon());
                            change_daughter_type(vtx, sg1, 13, mp.get_mass_muon());
                            change_daughter_type(find_other_vertex(sg1, vtx), sg1, 13, mp.get_mass_muon());
                        }

                        std::vector<WCPPID::ProtoVertex*> acc_vertices;
                        auto results = find_cont_muon_segment(sg1, vtx);
                        while (results.first != 0) {
                            acc_vertices.push_back(results.second);
                            results = find_cont_muon_segment(results.first, results.second);
                        }
                        if (acc_vertices.size() > 0 && acc_vertices.back() != 0)
                            tmp_vertices.insert(acc_vertices.back());
                    }
                }
            }
            else {
                tmp_vertices.insert(vtx);
            }
        }  // else
    }      // loop vertices ...

    // print_segs_info(vertices.front()->get_cluster_id());

    if (tmp_vertices.size() == 0) return;
    vertices.clear();
    vertices.resize(tmp_vertices.size());
    std::copy(tmp_vertices.begin(), tmp_vertices.end(), vertices.begin());

    /*
    if (max_length > 40*units::cm){
      if (vertices.size()==1) return;

      tmp_vertices.clear();
      for (auto it = vertices.begin(); it!= vertices.end(); it++){
        WCPPID::ProtoVertex *vtx = *it;
        if (map_vertex_segments[vtx].size()>1){
          tmp_vertices.push_back(vtx);
        }else{
          WCPPID::ProtoSegment *sg = (*map_vertex_segments[vtx].begin());
          WCPPID::ProtoVertex *other_vtx = find_other_vertex(sg, vtx);
          //      std::cout << sg->get_length()/units::cm << std::endl;
          TVector3 dir1 = sg->cal_dir_3vector(other_vtx->get_fit_pt(), 15*units::cm);
          double max_angle = 0;
          double length = sg->get_length();
          if (length < 1*units::cm){
          }else if (length < 5*units::cm){
            for (auto it1 = map_vertex_segments[other_vtx].begin(); it1 != map_vertex_segments[other_vtx].end(); it1++){
              WCPPID::ProtoSegment *sg1 = *it1;
              if (sg1 == sg) continue;
              TVector3 dir2 = sg1->cal_dir_3vector(other_vtx->get_fit_pt(), 15*units::cm);
              double angle = dir1.Angle(dir2)/3.1415926*180.;
              if (angle > max_angle) max_angle = angle;
            }
            if (max_angle > 155) tmp_vertices.push_back(vtx);
            //	std::cout << max_angle << " " << sg->get_length()/units::cm << std::endl;
          }else{
            tmp_vertices.push_back(vtx);
          }
        }
      }

      if (tmp_vertices.size() == 0) return;
      vertices = tmp_vertices;
    }
    */
}

TVector3 WCPPID::NeutrinoID::calc_dir_cluster(int tmp_cluster_id, WCP::Point& orig_p, double dis_cut)
{
    Point ave_p(0, 0, 0);
    int num = 0;

    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (sg->get_cluster_id() != tmp_cluster_id) continue;
        WCP::PointVector& pts = sg->get_point_vec();
        for (size_t i = 1; i + 1 < pts.size(); i++) {
            double dis =
                sqrt(pow(pts.at(i).x - orig_p.x, 2) + pow(pts.at(i).y - orig_p.y, 2) + pow(pts.at(i).z - orig_p.z, 2));
            if (dis < dis_cut) {
                ave_p.x += pts.at(i).x;
                ave_p.y += pts.at(i).y;
                ave_p.z += pts.at(i).z;
                num++;
            }
        }
    }
    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        WCPPID::ProtoVertex* vtx = it->first;
        if (vtx->get_cluster_id() != tmp_cluster_id) continue;
        double dis = sqrt(pow(vtx->get_fit_pt().x - orig_p.x, 2) + pow(vtx->get_fit_pt().y - orig_p.y, 2) +
                          pow(vtx->get_fit_pt().z - orig_p.z, 2));
        if (dis < dis_cut) {
            ave_p.x += vtx->get_fit_pt().x;
            ave_p.y += vtx->get_fit_pt().y;
            ave_p.z += vtx->get_fit_pt().z;
            num++;
        }
    }

    TVector3 dir(0, 0, 0);

    if (num > 0) {
        ave_p.x /= num;
        ave_p.y /= num;
        ave_p.z /= num;

        dir.SetXYZ(ave_p.x - orig_p.x, ave_p.y - orig_p.y, ave_p.z - orig_p.z);
        dir = dir.Unit();
    }
    return dir;
}

void WCPPID::NeutrinoID::swap_main_cluster(WCPPID::PR3DCluster* new_main_cluster)
{
    other_clusters.push_back(main_cluster);
    main_cluster = new_main_cluster;
    auto it1 = find(other_clusters.begin(), other_clusters.end(), main_cluster);
    other_clusters.erase(it1);
}

void WCPPID::NeutrinoID::check_switch_main_cluster()
{
    bool flag_switch = false;
    bool flag_all_showers = false;

    bool flag_print = true;

    WCPPID::ProtoVertex* temp_main_vertex = 0;

    if (map_cluster_main_vertices.find(main_cluster) != map_cluster_main_vertices.end()) {
        temp_main_vertex = map_cluster_main_vertices[main_cluster];
        int n_showers = 0;

        //    std::cout << main_cluster->get_cluster_id() << " " << main_cluster << " " << temp_main_vertex <<
        //    std::endl;

        for (auto it = map_vertex_segments[temp_main_vertex].begin(); it != map_vertex_segments[temp_main_vertex].end();
             it++) {
            if ((*it)->get_flag_shower()) n_showers++;
        }
        if (n_showers == map_vertex_segments[temp_main_vertex].size()) flag_all_showers = true;
    }
    else {
        flag_all_showers = true;
    }

    if (flag_all_showers) {
        WCPPID::ProtoVertexSelection vertex_candidates;
        for (auto it = map_cluster_main_vertices.begin(); it != map_cluster_main_vertices.end(); it++) {
            vertex_candidates.push_back(it->second);
        }

        if (flag_print) {
            for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
                std::cout << "Candidate main vertex " << (*it)->get_cluster_id() << " " << (*it)->get_fit_pt()
                          << " connecting to: ";
                for (auto it1 = map_vertex_segments[*it].begin(); it1 != map_vertex_segments[*it].end(); it1++) {
                    std::cout << (*it1)->get_id() << ", ";
                }
                std::cout << std::endl;
            }
        }

        WCPPID::ProtoVertex* temp_main_vertex_1 = compare_main_vertices_global(vertex_candidates);
        if (temp_main_vertex_1 != temp_main_vertex) {
            if (temp_main_vertex != 0) {
                std::cout << "Switch Main Cluster " << temp_main_vertex->get_cluster_id() << " to "
                          << temp_main_vertex_1->get_cluster_id() << std::endl;
            }
            else {
                std::cout << "Switch Main Cluster  to " << temp_main_vertex_1->get_cluster_id() << std::endl;
            }
            for (auto it = map_cluster_main_vertices.begin(); it != map_cluster_main_vertices.end(); it++) {
                if (it->second == temp_main_vertex_1) {
                    swap_main_cluster(it->first);
                    break;
                }
            }
        }  // switch
    }      // all showers
}

WCPPID::ProtoVertex* WCPPID::NeutrinoID::compare_main_vertices_global(WCPPID::ProtoVertexSelection& vertex_candidates)
{
    bool flag_print = false;

    std::map<WCPPID::ProtoVertex*, double> map_vertex_num;
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        map_vertex_num[*it] = 0;
    }

    // whether the vertex is at beginning or not ...
    double min_z = 1e9;
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        if (vtx->get_fit_pt().z < min_z) min_z = vtx->get_fit_pt().z;
    }
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        // std::cout << vtx->get_fit_pt().z << std::endl;
        map_vertex_num[vtx] -= (vtx->get_fit_pt().z - min_z) / (200 * units::cm);  // position information
        //    std::cout << map_vertex_segments[vtx].size() << std::endl;
        // number of tracks, more is good
        for (auto it1 = map_vertex_segments[vtx].begin(); it1 != map_vertex_segments[vtx].end(); it1++) {
            WCPPID::ProtoSegment* sg = (*it1);
            // std::cout << sg->get_id() << " " << sg->get_flag_shower() << " " << sg->get_particle_type() << " " <<
            // sg->get_flag_dir() << " " << sg->is_dir_weak() << " " << sg->get_length()/units::cm << std::endl;
            if (sg->get_flag_shower()) {
                map_vertex_num[vtx] += 1 / 4. / 2.;  // number of showers
            }
            else {
                map_vertex_num[vtx] += 1 / 4.;  // number of tracks
            }
            if (sg->get_particle_type() == 2212 && sg->get_flag_dir() != 0 && (!sg->is_dir_weak()))
                map_vertex_num[vtx] += 1 / 4.;  // has a clear proton ...
            else if (sg->get_flag_dir() != 0 && (!sg->get_flag_shower()))
                map_vertex_num[vtx] += 1 / 4. / 2.;  // has a direction with track ..
        }
        // add to main vertex ...
        if (vtx->get_cluster_id() == main_cluster->get_cluster_id()) map_vertex_num[vtx] += 0.25;
        if (flag_print)
            std::cout << "A: " << map_vertex_num[vtx] << " " << (vtx->get_fit_pt().z - min_z) / (200 * units::cm) << " "
                      << map_vertex_segments[vtx].size() / 4. << " " << std::endl;
    }

    // whether the vetex is at boundary or not ...
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        if (fid->inside_fiducial_volume(vtx->get_fit_pt(), offset_x) ||
            vtx->get_cluster_id() == main_cluster->get_cluster_id())
            map_vertex_num[vtx] += 0.5;  // good      // fiducial volume ..
        if (flag_print)
            std::cout << "B: " << map_vertex_num[vtx] << " " << fid->inside_fiducial_volume(vtx->get_fit_pt(), offset_x)
                      << std::endl;
    }

    //  for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++){
    // WCPPID::ProtoVertex *vtx = *it;

    // double num_conflicts = calc_conflict_maps(vtx);
    //  map_vertex_num[vtx] -= num_conflicts/4.;
    // std::cout << "C: " << map_vertex_num[vtx] << " " << num_conflicts << " " << map_vertex_num[vtx] << std::endl;
    //}

    // Now compare with all other vertices ...
    std::map<WCPPID::ProtoVertex*, TVector3> map_vertex_dir;
    // for each vertices, calculate a direction first ...
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        map_vertex_dir[vtx] = get_dir(vtx);
    }

    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        double delta = 0;
        for (auto it1 = vertex_candidates.begin(); it1 != vertex_candidates.end(); it1++) {
            WCPPID::ProtoVertex* vtx1 = *it1;
            if (vtx1 == vtx) continue;
            TVector3 dir(vtx1->get_fit_pt().x - vtx->get_fit_pt().x, vtx1->get_fit_pt().y - vtx->get_fit_pt().y,
                         vtx1->get_fit_pt().z - vtx->get_fit_pt().z);
            TVector3 dir1 = map_vertex_dir[vtx1];
            if (dir.Angle(dir1) / 3.1415926 * 180. < 15) {
                map_vertex_num[vtx] += 0.25;
                delta++;
            }
            else if (dir.Angle(dir1) / 3.1415926 * 180. < 30) {
                map_vertex_num[vtx] += 0.25 / 2.;
                delta++;
            }
            // if (flag_print) std::cout << "D: " << vtx->get_cluster_id() << " " << map_vertex_num[vtx] << " " <<
            // dir.Angle(dir1)/3.1415926*180. << " " << main_cluster->get_cluster_id() << " " << dir.Mag()/units::cm <<
            // std::endl;
        }

        // nothing point to this one ...
        if (delta == 0) {
            double total_length = 0;
            int num_tracks = 0;
            for (auto it1 = map_segment_vertices.begin(); it1 != map_segment_vertices.end(); it1++) {
                if (it1->first->get_cluster_id() != vtx->get_cluster_id()) continue;
                total_length += it1->first->get_length();
                num_tracks++;
                // std::cout << delta << std::endl;
            }
            if (vtx->get_cluster_id() != main_cluster->get_cluster_id() && total_length < 6 * units::cm) {
                map_vertex_num[vtx] -= 0.25 * num_tracks;
            }
        }
        if (flag_print) std::cout << "E: " << map_vertex_num[vtx] << " " << std::endl;
    }

    double max_val = -1e9;
    WCPPID::ProtoVertex* max_vertex = 0;
    for (auto it = vertex_candidates.begin(); it != vertex_candidates.end(); it++) {
        WCPPID::ProtoVertex* vtx = *it;
        if (map_vertex_num[vtx] > max_val) {
            max_val = map_vertex_num[vtx];
            max_vertex = vtx;
        }
    }

    //  std::cout << (max_vertex->get_fit_pt().z-min_z)/(400*units::cm) << std::endl;

    return max_vertex;
}

TVector3 WCPPID::NeutrinoID::get_dir(WCPPID::ProtoVertex* vtx, double dis_cut)
{
    Point center(0, 0, 0);
    int ncount = 0;

    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (sg->get_cluster_id() != vtx->get_cluster_id()) continue;
        PointVector& pts = sg->get_point_vec();
        for (size_t i = 1; i + 1 < pts.size(); i++) {
            double dis = sqrt(pow(pts.at(i).x - vtx->get_fit_pt().x, 2) + pow(pts.at(i).y - vtx->get_fit_pt().y, 2) +
                              pow(pts.at(i).z - vtx->get_fit_pt().z, 2));
            if (dis < dis_cut) {
                center.x += pts.at(i).x;
                center.y += pts.at(i).y;
                center.z += pts.at(i).z;
                ncount++;
            }
        }
    }
    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        WCPPID::ProtoVertex* vertex = it->first;
        if (vertex->get_cluster_id() != vtx->get_cluster_id()) continue;
        double dis = sqrt(pow(vertex->get_fit_pt().x - vtx->get_fit_pt().x, 2) +
                          pow(vertex->get_fit_pt().y - vtx->get_fit_pt().y, 2) +
                          pow(vertex->get_fit_pt().z - vtx->get_fit_pt().z, 2));
        if (dis < dis_cut) {
            center.x += vertex->get_fit_pt().x;
            center.y += vertex->get_fit_pt().y;
            center.z += vertex->get_fit_pt().z;
            ncount++;
        }
    }

    center.x /= ncount;
    center.y /= ncount;
    center.z /= ncount;

    TVector3 dir(center.x - vtx->get_fit_pt().x, center.y - vtx->get_fit_pt().y, center.z - vtx->get_fit_pt().z);
    dir = dir.Unit();
    return dir;
}

void WCPPID::NeutrinoID::check_switch_main_cluster(WCPPID::ProtoVertex* temp_main_vertex,
                                                   WCPPID::PR3DCluster* max_length_cluster)
{
    bool flag_switch = false;

    int n_showers = 0;
    for (auto it = map_vertex_segments[temp_main_vertex].begin(); it != map_vertex_segments[temp_main_vertex].end();
         it++) {
        if ((*it)->get_flag_shower()) n_showers++;
    }
    if (n_showers == map_vertex_segments[temp_main_vertex].size()) flag_switch = true;

    if (flag_switch) {
        std::cout << "Switch Main Cluster " << main_cluster->get_cluster_id() << " to "
                  << max_length_cluster->get_cluster_id() << std::endl;
        swap_main_cluster(max_length_cluster);
    }
}

std::pair<int, int> WCPPID::NeutrinoID::count_num_tracks_showers(WCPPID::PR3DCluster* temp_cluster)
{
    int num[2] = {0, 0};
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (sg->get_flag_shower())
            num[1]++;
        else
            num[0]++;
    }
    return std::make_pair(num[0], num[1]);
}

void WCPPID::NeutrinoID::fill_fit_parameters()
{
    organize_vertices_segments();
    std::set<WCPPID::PR3DCluster*> clusters_set;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        WCPPID::PR3DCluster* cluster = map_id_cluster[sg->get_cluster_id()];
        clusters_set.insert(cluster);
    }
    for (auto it = clusters_set.begin(); it != clusters_set.end(); it++) {
        (*it)->set_fit_parameters(proto_vertices, proto_segments, map_vertex_segments, map_segment_vertices);
    }

    PR3DClusterSelection all_clusters = other_clusters;
    all_clusters.push_back(main_cluster);
    for (auto it = all_clusters.begin(); it != all_clusters.end(); it++) {
        WCPPID::PR3DCluster* temp_cluster = *it;
        std::vector<int>& point_sub_cluster_ids = temp_cluster->get_point_sub_cluster_ids();
        std::vector<bool>& point_flag_showers = temp_cluster->get_point_flag_showers();
        if (point_flag_showers.size() == 0) point_flag_showers.resize(point_sub_cluster_ids.size(), false);
    }
}

void WCPPID::NeutrinoID::clustering_points(WCPPID::PR3DCluster* temp_cluster)
{
    temp_cluster->clustering_points_master(map_vertex_segments, map_segment_vertices, *ct_point_cloud);

    std::map<int, WCPPID::ProtoSegment*> map_id_seg;
    std::map<WCPPID::ProtoSegment*, int> map_seg_id;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (sg->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        map_id_seg[sg->get_id()] = sg;
        map_seg_id[sg] = sg->get_id();
        // std::cout << "A: " << sg->get_id() << std::endl;
        sg->reset_associate_points();
    }

    {
        // find the relevant point clouds ...
        WCP::WCPointCloud<double>& cloud = temp_cluster->get_point_cloud()->get_cloud();
        WCP::WC2DPointCloud<double>& cloud_u = temp_cluster->get_point_cloud()->get_cloud_u();
        WCP::WC2DPointCloud<double>& cloud_v = temp_cluster->get_point_cloud()->get_cloud_v();
        WCP::WC2DPointCloud<double>& cloud_w = temp_cluster->get_point_cloud()->get_cloud_w();

        std::vector<int>& point_sub_cluster_ids = temp_cluster->get_point_sub_cluster_ids();

        for (size_t i = 0; i != point_sub_cluster_ids.size(); i++) {
            //      std::cout << point_sub_cluster_ids.at(i) << std::endl;
            if (point_sub_cluster_ids.at(i) == -1) continue;
            if (map_id_seg.find(point_sub_cluster_ids.at(i)) == map_id_seg.end()) continue;
            map_id_seg[point_sub_cluster_ids.at(i)]->add_associate_point(cloud.pts[i], cloud_u.pts[i], cloud_v.pts[i],
                                                                         cloud_w.pts[i]);
        }
    }

    {
        WCP::WCPointCloud<double>& cloud = temp_cluster->get_point_cloud_steiner()->get_cloud();
        std::vector<int>& point_steiner_sub_cluster_ids = temp_cluster->get_point_steiner_sub_cluster_ids();
        for (size_t i = 0; i != point_steiner_sub_cluster_ids.size(); i++) {
            if (point_steiner_sub_cluster_ids.at(i) == -1) continue;
            if (map_id_seg.find(point_steiner_sub_cluster_ids.at(i)) == map_id_seg.end()) continue;
            map_id_seg[point_steiner_sub_cluster_ids.at(i)]->add_associate_point_steiner(cloud.pts[i]);
        }
    }

    // build kdtree
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (sg->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        ToyPointCloud* pcloud_associate = sg->get_associated_pcloud();
        if (pcloud_associate != 0) pcloud_associate->build_kdtree_index();
        ToyPointCloud* pcloud_associate_steiner = sg->get_associated_pcloud_steiner();
        if (pcloud_associate_steiner != 0) pcloud_associate_steiner->build_kdtree_index();
    }
}

WCPPID::NeutrinoID::~NeutrinoID()
{
    for (auto it = proto_vertices.begin(); it != proto_vertices.end(); it++) {
        delete (*it);
    }
    for (auto it = proto_segments.begin(); it != proto_segments.end(); it++) {
        delete (*it);
    }
    for (auto it = showers.begin(); it != showers.end(); it++) {
        delete (*it);
    }
}

int WCPPID::NeutrinoID::get_num_segments(WCPPID::ProtoVertex* pv)
{
    if (map_vertex_segments.find(pv) != map_vertex_segments.end()) {
        return map_vertex_segments[pv].size();
    }
    else {
        return 0;
    }
}

void WCPPID::NeutrinoID::organize_vertices_segments()
{
    WCPPID::ProtoVertexSelection temp_vertices = proto_vertices;
    WCPPID::ProtoSegmentSelection temp_segments = proto_segments;
    proto_vertices.clear();
    proto_segments.clear();
    WCPPID::ProtoVertexSet temp_vset;
    WCPPID::ProtoSegmentSet temp_sset;
    WCPPID::ProtoSegmentSet temp_delset;
    for (auto it = temp_vertices.begin(); it != temp_vertices.end(); it++) {
        if (map_vertex_segments.find(*it) != map_vertex_segments.end() && temp_vset.find(*it) == temp_vset.end()) {
            proto_vertices.push_back(*it);
            temp_vset.insert(*it);
            // std::cout << "1: " << *it << std::endl;
            // std::cout <<"1: " << (*it)->get_wcpt().index << std::endl;
        }
    }
    for (auto it = temp_segments.begin(); it != temp_segments.end(); it++) {
        if (map_segment_vertices.find(*it) != map_segment_vertices.end()) {
            if (temp_sset.find(*it) == temp_sset.end()) {
                proto_segments.push_back(*it);
                temp_sset.insert(*it);
                // std::cout << (*it)->get_wcpt_vec().front().index << " " << (*it)->get_wcpt_vec().back().index << " "
                // << (*it)->get_point_vec().front() << " " << (*it)->get_wcpt_vec().front().x << " " <<
                // (*it)->get_wcpt_vec().front().y << " " << (*it)->get_wcpt_vec().front().z << " " <<
                // (*it)->get_point_vec().back() << " " << (*it)->get_wcpt_vec().back().x << " " <<
                // (*it)->get_wcpt_vec().back().y << " " << (*it)->get_wcpt_vec().back().z << std::endl; std::cout << "2:
                // " << *it << std::endl;
            }
        }
        else {
            temp_delset.insert(*it);
        }
    }

    for (auto it = temp_delset.begin(); it != temp_delset.end(); it++) {
        delete *it;
    }
}

void WCPPID::NeutrinoID::process_main_cluster()
{
    WCPPID::PR3DCluster* temp_cluster = main_cluster;
    if (temp_cluster->get_point_cloud_steiner() != 0) {
        if (temp_cluster->get_point_cloud_steiner()->get_num_points() >= 2) {
            std::pair<WCPointCloud<double>::WCPoint, WCPointCloud<double>::WCPoint> wcps =
                temp_cluster->get_two_boundary_wcps(2);
            temp_cluster->dijkstra_shortest_paths(wcps.first, 2);
            temp_cluster->cal_shortest_path(wcps.second, 2);
        }
        if (temp_cluster->get_path_wcps().size() >= 2) {
            temp_cluster->collect_charge_trajectory(*ct_point_cloud);
            temp_cluster->do_tracking(*ct_point_cloud, global_wc_map, flash_time * units::microsecond);
        }
    }
}

void WCPPID::NeutrinoID::process_other_clusters()
{
    for (auto it1 = other_clusters.begin(); it1 != other_clusters.end(); it1++) {
        WCPPID::PR3DCluster* temp_cluster = (*it1);
        if (temp_cluster->get_point_cloud_steiner() != 0) {
            if (temp_cluster->get_point_cloud_steiner()->get_num_points() >= 2) {
                std::pair<WCPointCloud<double>::WCPoint, WCPointCloud<double>::WCPoint> wcps =
                    temp_cluster->get_two_boundary_wcps(2);
                temp_cluster->dijkstra_shortest_paths(wcps.first, 2);
                temp_cluster->cal_shortest_path(wcps.second, 2);
            }
            if (temp_cluster->get_path_wcps().size() >= 2) {
                temp_cluster->collect_charge_trajectory(*ct_point_cloud);
                temp_cluster->do_tracking(*ct_point_cloud, global_wc_map, flash_time * units::microsecond);
            }
        }
    }
}

void WCPPID::NeutrinoID::fill_reco_tree(WCPPID::ProtoSegment* sg, WCRecoTree& rtree)
{
    rtree.mc_id[rtree.mc_Ntrack] = sg->get_cluster_id() * 1000 + sg->get_id();
    // particle code
    // e- 11  e+ -11
    // muon- 13  muon+ -13
    // gamma 22
    // pi+ 211, pi0 111, pi- -211
    // kaon+ 321, K- -321
    // p  2212
    // n 2112

    //    std::cout << sg->cal_kine_range()/units::MeV << " " << sg->cal_kine_dQdx()/units::MeV << std::endl;
    rtree.mc_included[rtree.mc_Ntrack] = 1;  // always included

    rtree.mc_pdg[rtree.mc_Ntrack] = sg->get_particle_type();  // all muons for now ...
    rtree.mc_process[rtree.mc_Ntrack] = 0;
    rtree.mc_mother[rtree.mc_Ntrack] = 0;
    rtree.mc_dir_weak[rtree.mc_Ntrack] = sg->is_dir_weak();
    rtree.mc_kine_range[rtree.mc_Ntrack] = sg->cal_kine_range() / units::MeV;
    rtree.mc_kine_dQdx[rtree.mc_Ntrack] = sg->cal_kine_dQdx() / units::MeV;
    rtree.mc_kine_charge[rtree.mc_Ntrack] = cal_kine_charge(sg) / units::MeV;
    rtree.mc_length[rtree.mc_Ntrack] = sg->get_length() / units::cm;
    // std::cout << rtree.mc_id[rtree.mc_Ntrack] << " " << rtree.mc_dir_weak[rtree.mc_Ntrack] << " " <<
    // rtree.mc_kine_range[rtree.mc_Ntrack] << " " << rtree.mc_kine_dQdx[rtree.mc_Ntrack] << " " <<
    // rtree.mc_kine_charge[rtree.mc_Ntrack] << std::endl;

    sg->set_kine_charge(rtree.mc_kine_charge[rtree.mc_Ntrack] * units::MeV);
    //    std::cout << rtree.mc_kine_range[rtree.mc_Ntrack] << " " << rtree.mc_kine_dQdx[rtree.mc_Ntrack] << " " <<
    //    rtree.mc_kine_charge[rtree.mc_Ntrack] << std::endl;

    if (sg->get_flag_dir() == 0)
        return;  // no direction not plot

    else if (sg->get_flag_dir() == 1) {
        rtree.mc_startXYZT[rtree.mc_Ntrack][0] = sg->get_point_vec().front().x / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][1] = sg->get_point_vec().front().y / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][2] = sg->get_point_vec().front().z / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][3] = 0;

        rtree.mc_endXYZT[rtree.mc_Ntrack][0] = sg->get_point_vec().back().x / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][1] = sg->get_point_vec().back().y / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][2] = sg->get_point_vec().back().z / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][3] = 0;
    }
    else if (sg->get_flag_dir() == -1) {
        rtree.mc_startXYZT[rtree.mc_Ntrack][0] = sg->get_point_vec().back().x / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][1] = sg->get_point_vec().back().y / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][2] = sg->get_point_vec().back().z / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][3] = 0;

        rtree.mc_endXYZT[rtree.mc_Ntrack][0] = sg->get_point_vec().front().x / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][1] = sg->get_point_vec().front().y / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][2] = sg->get_point_vec().front().z / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][3] = 0;
    }

    if (sg->get_particle_4mom(3) > 0) {
        //      std::cout << sg->get_particle_4mom(0)/units::MeV << " " << sg->get_particle_4mom(1)/units::MeV << " " <<
        //      sg->get_particle_4mom(2)/units::MeV << " " << sg->get_particle_4mom(3)/units::MeV << " " <<
        //      sg->get_particle_type() << " " << sg->get_particle_mass() << std::endl;
        rtree.mc_startMomentum[rtree.mc_Ntrack][0] = sg->get_particle_4mom(0) / units::GeV;
        rtree.mc_startMomentum[rtree.mc_Ntrack][1] = sg->get_particle_4mom(1) / units::GeV;
        rtree.mc_startMomentum[rtree.mc_Ntrack][2] = sg->get_particle_4mom(2) / units::GeV;
        rtree.mc_startMomentum[rtree.mc_Ntrack][3] = sg->get_particle_4mom(3) / units::GeV;

        rtree.mc_endMomentum[rtree.mc_Ntrack][0] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][1] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][2] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][3] = sg->get_particle_mass() / units::GeV;
    }
    else {
        rtree.mc_startMomentum[rtree.mc_Ntrack][0] = 0;
        rtree.mc_startMomentum[rtree.mc_Ntrack][1] = 0;
        rtree.mc_startMomentum[rtree.mc_Ntrack][2] = 0;
        rtree.mc_startMomentum[rtree.mc_Ntrack][3] = 0;

        rtree.mc_endMomentum[rtree.mc_Ntrack][0] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][1] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][2] = 0;
        rtree.mc_endMomentum[rtree.mc_Ntrack][3] = 0;
    }
    rtree.mc_Ntrack++;
    rtree.mc_daughters->resize(rtree.mc_Ntrack);
}

void WCPPID::NeutrinoID::fill_reco_tree(WCPPID::WCShower* shower, WCRecoTree& rtree)
{
    //  fill_reco_tree(shower->get_start_segment(), rtree);

    WCPPID::ProtoSegment* sg1 = shower->get_start_segment();

    rtree.mc_id[rtree.mc_Ntrack] = sg1->get_cluster_id() * 1000 + sg1->get_id();
    rtree.mc_pdg[rtree.mc_Ntrack] = shower->get_particle_type();
    rtree.mc_process[rtree.mc_Ntrack] = 0;

    if (shower->get_start_vertex().second <= 2) {
        rtree.mc_included[rtree.mc_Ntrack] = 1;
    }
    else {
        rtree.mc_included[rtree.mc_Ntrack] = shower->get_start_vertex().second;  // 3 or 4 ...
    }

    rtree.mc_kine_range[rtree.mc_Ntrack] = shower->get_kine_range() / units::MeV;
    rtree.mc_kine_dQdx[rtree.mc_Ntrack] = shower->get_kine_dQdx() / units::MeV;
    rtree.mc_kine_charge[rtree.mc_Ntrack] = shower->get_kine_charge() / units::MeV;
    rtree.mc_length[rtree.mc_Ntrack] = shower->get_total_length() / units::cm;

    rtree.mc_startXYZT[rtree.mc_Ntrack][0] = shower->get_start_point().x / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][1] = shower->get_start_point().y / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][2] = shower->get_start_point().z / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][3] = 0;

    rtree.mc_endXYZT[rtree.mc_Ntrack][0] = shower->get_end_point().x / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][1] = shower->get_end_point().y / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][2] = shower->get_end_point().z / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][3] = 0;

    std::pair<ProtoVertex*, int> pair_start_vertex = shower->get_start_vertex();
    if (pair_start_vertex.second == 4) {
        rtree.mc_dir_weak[rtree.mc_Ntrack] = 1;
        return;
    }
    else {
        rtree.mc_dir_weak[rtree.mc_Ntrack] = 0;
    }

    double kine_best = shower->get_kine_best();
    if (kine_best == 0) kine_best = shower->get_kine_charge();
    rtree.mc_startMomentum[rtree.mc_Ntrack][3] = (kine_best + sg1->get_particle_mass()) / units::GeV;
    double momentum = sqrt(pow(kine_best + sg1->get_particle_mass(), 2) - pow(sg1->get_particle_mass(), 2));
    TVector3 init_dir = shower->get_init_dir();
    init_dir = init_dir.Unit();
    rtree.mc_startMomentum[rtree.mc_Ntrack][0] = momentum * init_dir.X() / units::GeV;
    rtree.mc_startMomentum[rtree.mc_Ntrack][1] = momentum * init_dir.Y() / units::GeV;
    rtree.mc_startMomentum[rtree.mc_Ntrack][2] = momentum * init_dir.Z() / units::GeV;

    rtree.mc_mother[rtree.mc_Ntrack] = 0;
    rtree.mc_Ntrack++;
    rtree.mc_daughters->resize(rtree.mc_Ntrack);
}

std::pair<int, int> WCPPID::NeutrinoID::fill_pi0_reco_tree(WCPPID::WCShower* shower, WCRecoTree& rtree)
{
    // not calculation energy ....
    rtree.mc_included[rtree.mc_Ntrack] = 0;

    if (map_pio_id_saved_pair.find(map_shower_pio_id[shower]) == map_pio_id_saved_pair.end()) {
        WCPPID::ProtoSegment* sg1 = shower->get_start_segment();
        rtree.mc_id[rtree.mc_Ntrack] = sg1->get_cluster_id() * 1000 + map_shower_pio_id[shower];
        rtree.mc_pdg[rtree.mc_Ntrack] = 111;

        rtree.mc_process[rtree.mc_Ntrack] = 0;
        rtree.mc_kine_range[rtree.mc_Ntrack] = 0;
        rtree.mc_kine_dQdx[rtree.mc_Ntrack] = 0;
        rtree.mc_kine_charge[rtree.mc_Ntrack] = 0;
        rtree.mc_length[rtree.mc_Ntrack] = 0;
        rtree.mc_stopped[rtree.mc_Ntrack - 1] = 0;

        rtree.mc_startXYZT[rtree.mc_Ntrack][0] = shower->get_start_vertex().first->get_fit_pt().x / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][1] = shower->get_start_vertex().first->get_fit_pt().y / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][2] = shower->get_start_vertex().first->get_fit_pt().z / units::cm;
        rtree.mc_startXYZT[rtree.mc_Ntrack][3] = 0;

        rtree.mc_endXYZT[rtree.mc_Ntrack][0] = shower->get_start_vertex().first->get_fit_pt().x / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][1] = shower->get_start_vertex().first->get_fit_pt().y / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][2] = shower->get_start_vertex().first->get_fit_pt().z / units::cm;
        rtree.mc_endXYZT[rtree.mc_Ntrack][3] = 0;

        std::pair<ProtoVertex*, int> pair_start_vertex = shower->get_start_vertex();

        rtree.mc_dir_weak[rtree.mc_Ntrack] = 0;

        rtree.mc_startMomentum[rtree.mc_Ntrack][0] =
            sqrt(pow(map_pio_id_mass[map_shower_pio_id[shower]].first + 135 * units::MeV, 2) -
                 pow(135 * units::MeV, 2)) /
            units::GeV;
        rtree.mc_startMomentum[rtree.mc_Ntrack][1] = 0;
        rtree.mc_startMomentum[rtree.mc_Ntrack][2] = 0;
        rtree.mc_startMomentum[rtree.mc_Ntrack][3] =
            (map_pio_id_mass[map_shower_pio_id[shower]].first + 135 * units::MeV) / units::GeV;

        rtree.mc_mother[rtree.mc_Ntrack] = 0;
        rtree.mc_Ntrack++;
        rtree.mc_daughters->resize(rtree.mc_Ntrack);

        map_pio_id_saved_pair[map_shower_pio_id[shower]] =
            std::make_pair(rtree.mc_Ntrack - 1, rtree.mc_id[rtree.mc_Ntrack - 1]);
        return std::make_pair(rtree.mc_Ntrack - 1, rtree.mc_id[rtree.mc_Ntrack - 1]);
    }
    else {
        return map_pio_id_saved_pair[map_shower_pio_id[shower]];
    }
}

int WCPPID::NeutrinoID::fill_psuedo_reco_tree(WCPPID::WCShower* shower, WCRecoTree& rtree)
{
    WCPPID::ProtoSegment* sg1 = shower->get_start_segment();

    rtree.mc_id[rtree.mc_Ntrack] = sg1->get_cluster_id() * 1000 + acc_segment_id;
    acc_segment_id++;
    if (fabs(shower->get_particle_type()) == 11 || fabs(shower->get_particle_type()) == 22) {
        rtree.mc_pdg[rtree.mc_Ntrack] = 22;
    }
    else {
        rtree.mc_pdg[rtree.mc_Ntrack] = 2112;
    }
    rtree.mc_process[rtree.mc_Ntrack] = 0;

    rtree.mc_included[rtree.mc_Ntrack] = 0;

    rtree.mc_kine_range[rtree.mc_Ntrack] = 0;
    rtree.mc_kine_dQdx[rtree.mc_Ntrack] = 0;
    rtree.mc_kine_charge[rtree.mc_Ntrack] = 0;
    rtree.mc_length[rtree.mc_Ntrack] = 0;
    rtree.mc_stopped[rtree.mc_Ntrack - 1] = 0;

    rtree.mc_startXYZT[rtree.mc_Ntrack][0] = shower->get_start_vertex().first->get_fit_pt().x / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][1] = shower->get_start_vertex().first->get_fit_pt().y / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][2] = shower->get_start_vertex().first->get_fit_pt().z / units::cm;
    rtree.mc_startXYZT[rtree.mc_Ntrack][3] = 0;

    rtree.mc_endXYZT[rtree.mc_Ntrack][0] = shower->get_start_point().x / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][1] = shower->get_start_point().y / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][2] = shower->get_start_point().z / units::cm;
    rtree.mc_endXYZT[rtree.mc_Ntrack][3] = 0;

    std::pair<ProtoVertex*, int> pair_start_vertex = shower->get_start_vertex();

    rtree.mc_dir_weak[rtree.mc_Ntrack] = 0;

    double kine_best = shower->get_kine_best();
    if (kine_best == 0) kine_best = shower->get_kine_charge();
    double momentum;
    if (fabs(shower->get_particle_type()) == 11 || fabs(shower->get_particle_type()) == 22) {
        rtree.mc_startMomentum[rtree.mc_Ntrack][3] = (kine_best) / units::GeV;
        momentum = kine_best;
    }
    else {
        TPCParams& mp = Singleton<TPCParams>::Instance();
        double mass_neutron = mp.get_mass_neutron();
        rtree.mc_startMomentum[rtree.mc_Ntrack][3] = (kine_best + mass_neutron) / units::GeV;
        momentum = sqrt(pow(kine_best + mass_neutron, 2) - pow(mass_neutron, 2));
    }

    TVector3 init_dir(rtree.mc_endXYZT[rtree.mc_Ntrack][0] - rtree.mc_startXYZT[rtree.mc_Ntrack][0],
                      rtree.mc_endXYZT[rtree.mc_Ntrack][1] - rtree.mc_startXYZT[rtree.mc_Ntrack][1],
                      rtree.mc_endXYZT[rtree.mc_Ntrack][2] - rtree.mc_startXYZT[rtree.mc_Ntrack][2]);
    init_dir = init_dir.Unit();
    if (init_dir.Mag() == 0) init_dir = shower->get_start_segment()->cal_dir_3vector();
    rtree.mc_startMomentum[rtree.mc_Ntrack][0] = momentum * init_dir.X() / units::GeV;
    rtree.mc_startMomentum[rtree.mc_Ntrack][1] = momentum * init_dir.Y() / units::GeV;
    rtree.mc_startMomentum[rtree.mc_Ntrack][2] = momentum * init_dir.Z() / units::GeV;

    rtree.mc_mother[rtree.mc_Ntrack] = 0;
    rtree.mc_Ntrack++;
    rtree.mc_daughters->resize(rtree.mc_Ntrack);

    return rtree.mc_id[rtree.mc_Ntrack - 1];
}

void WCPPID::NeutrinoID::fill_reco_simple_tree(WCPPID::WCRecoTree& rtree)
{
    // start to fill
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        // only save the main cluster
        if (sg->get_cluster_id() != main_cluster->get_cluster_id()) continue;

        fill_reco_tree(sg, rtree);
        std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> pair_vertices = find_vertices(sg);
        if (map_vertex_segments[pair_vertices.first].size() == 1 ||
            map_vertex_segments[pair_vertices.second].size() == 1) {
            rtree.mc_stopped[rtree.mc_Ntrack - 1] = 1;
        }
        else {
            rtree.mc_stopped[rtree.mc_Ntrack - 1] = 0;
        }
    }
    // std::cout << rtree.mc_Ntrack << std::endl;
}

void WCPPID::NeutrinoID::fill_particle_tree(WCPPID::WCRecoTree& rtree)
{
    if (main_vertex == 0) return;

    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        if (map_segment_in_shower.find(sg) != map_segment_in_shower.end()) continue;
        if (sg->get_cluster_id() != main_vertex->get_cluster_id()) continue;
        //    std::cout << sg->get_cluster_id() << " " << main_vertex->get_cluster_id() << " " << sg->get_id() << " " <<
        //    sg->get_length()/units::cm << " " << sg->get_flag_dir() << std::endl;
        fill_reco_tree(sg, rtree);
        std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> pair_vertices = find_vertices(sg);
        if (map_vertex_segments[pair_vertices.first].size() == 1 ||
            map_vertex_segments[pair_vertices.second].size() == 1) {
            rtree.mc_stopped[rtree.mc_Ntrack - 1] = 1;
        }
        else {
            rtree.mc_stopped[rtree.mc_Ntrack - 1] = 0;
        }
        //    std::cout << "kak " << sg->get_cluster_id() << " " << sg->get_id() << std::endl;
    }
    for (auto it = showers.begin(); it != showers.end(); it++) {
        fill_reco_tree(*it, rtree);
        rtree.mc_stopped[rtree.mc_Ntrack - 1] = 0;
        // std::cout << "gag " << *it << " " << (*it)->get_start_segment()->get_id() << std::endl;
    }

    // id vs. rtree id
    std::map<int, int> map_sgid_rtid;
    std::map<int, int> map_rtid_sgid;
    for (int i = 0; i != rtree.mc_Ntrack; i++) {
        int sgid = rtree.mc_id[i];
        map_sgid_rtid[sgid] = i;
        map_rtid_sgid[i] = sgid;
    }

    // id vs. sg
    std::map<int, WCPPID::ProtoSegment*> map_sgid_sg;
    std::map<WCPPID::ProtoSegment*, int> map_sg_sgid;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        // only save the main cluster
        int sgid = sg->get_cluster_id() * 1000 + sg->get_id();
        map_sg_sgid[sg] = sgid;
        map_sgid_sg[sgid] = sg;
    }

    // main_vertex figure out the daughters and mother ...
    std::set<WCPPID::ProtoVertex*> used_vertices;
    std::set<WCPPID::ProtoSegment*> used_segments;

    for (auto it = showers.begin(); it != showers.end(); it++) {
        (*it)->fill_sets(used_vertices, used_segments, false);
    }

    std::vector<std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoSegment*> > segments_to_be_examined;
    for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); it++) {
        // parent are all zero now ...
        used_segments.insert(*it);
        WCPPID::ProtoVertex* other_vertex = find_other_vertex(*it, main_vertex);
        segments_to_be_examined.push_back(std::make_pair(other_vertex, *it));
    }
    used_vertices.insert(main_vertex);
    // std::cout << segments_to_be_examined.size() << " " << used_vertices.size() << " " << used_segments.size() <<
    // std::endl;

    while (segments_to_be_examined.size() > 0) {
        std::vector<std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoSegment*> > temp_segments;
        for (auto it = segments_to_be_examined.begin(); it != segments_to_be_examined.end(); it++) {
            WCPPID::ProtoVertex* curr_vtx = it->first;
            WCPPID::ProtoSegment* prev_sg = it->second;
            if (used_vertices.find(curr_vtx) != used_vertices.end()) continue;

            for (auto it1 = map_vertex_segments[curr_vtx].begin(); it1 != map_vertex_segments[curr_vtx].end(); it1++) {
                WCPPID::ProtoSegment* curr_sg = *it1;
                if (used_segments.find(curr_sg) != used_segments.end()) continue;
                used_segments.insert(curr_sg);
                // set mother ...
                rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = map_sg_sgid[prev_sg];
                // set daughters ...
                rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(map_sg_sgid[curr_sg]);
                WCPPID::ProtoVertex* other_vertex = find_other_vertex(curr_sg, curr_vtx);
                if (used_vertices.find(other_vertex) == used_vertices.end())
                    temp_segments.push_back(std::make_pair(other_vertex, curr_sg));
            }
            used_vertices.insert(curr_vtx);
        }
        segments_to_be_examined = temp_segments;
    }

    // Now the showers
    for (auto it = showers.begin(); it != showers.end(); it++) {
        WCPPID::WCShower* shower = *it;
        WCPPID::ProtoSegment* curr_sg = shower->get_start_segment();
        std::pair<ProtoVertex*, int> pair_vertex = shower->get_start_vertex();

        //    std::cout << pair_vertex.second << std::endl;

        if (pi0_showers.find(shower) == pi0_showers.end()) {  // not pi0
            if (pair_vertex.second == 1) {                    // direct connection
                if (pair_vertex.first == main_vertex) {
                    rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = 0;
                }
                else {
                    WCPPID::ProtoSegment* prev_sg = 0;
                    if (map_vertex_in_shower.find(pair_vertex.first) != map_vertex_in_shower.end()) {
                        prev_sg = map_vertex_in_shower[pair_vertex.first]->get_start_segment();
                    }
                    else {
                        prev_sg = find_incoming_segment(pair_vertex.first);
                    }
                    // set mother ...
                    rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = map_sg_sgid[prev_sg];
                    // set daughters ...
                    rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(map_sg_sgid[curr_sg]);
                }
            }
            else if (pair_vertex.second == 2 || pair_vertex.second == 3) {
                int psuedo_particle_id = fill_psuedo_reco_tree(shower, rtree);

                if (pair_vertex.first == main_vertex) {
                    rtree.mc_mother[rtree.mc_Ntrack - 1] = 0;
                    rtree.mc_daughters->at(rtree.mc_Ntrack - 1).push_back(map_sg_sgid[curr_sg]);
                    rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = psuedo_particle_id;
                }
                else {
                    WCPPID::ProtoSegment* prev_sg = 0;
                    if (map_vertex_in_shower.find(pair_vertex.first) != map_vertex_in_shower.end()) {
                        prev_sg = map_vertex_in_shower[pair_vertex.first]->get_start_segment();
                    }
                    else {
                        prev_sg = find_incoming_segment(pair_vertex.first);
                    }

                    rtree.mc_mother[rtree.mc_Ntrack - 1] = map_sg_sgid[prev_sg];
                    rtree.mc_daughters->at(rtree.mc_Ntrack - 1).push_back(map_sg_sgid[curr_sg]);
                    rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = psuedo_particle_id;
                    rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(psuedo_particle_id);
                }
            }
        }
        else {
            std::pair<ProtoVertex*, int> pair_vertex = shower->get_start_vertex();
            // pi0 ...
            // create a pi0 ...
            std::pair<int, int> pio_info_pair = fill_pi0_reco_tree(shower, rtree);

            int psuedo_particle_id = fill_psuedo_reco_tree(shower, rtree);

            //       std::cout << pio_info_pair.first << " " << pio_info_pair.second << " " << pair_vertex.first << " "
            //       << main_vertex << std::endl;

            if (pair_vertex.first == main_vertex) {
                // pio
                rtree.mc_mother[pio_info_pair.first] = 0;
                rtree.mc_daughters->at(pio_info_pair.first).push_back(psuedo_particle_id);
                // gamma
                rtree.mc_mother[rtree.mc_Ntrack - 1] = pio_info_pair.second;
                rtree.mc_daughters->at(rtree.mc_Ntrack - 1).push_back(map_sg_sgid[curr_sg]);
                // electron
                rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = psuedo_particle_id;
            }
            else {
                WCPPID::ProtoSegment* prev_sg = 0;
                if (map_vertex_in_shower.find(pair_vertex.first) != map_vertex_in_shower.end()) {
                    prev_sg = map_vertex_in_shower[pair_vertex.first]->get_start_segment();
                }
                else {
                    prev_sg = find_incoming_segment(pair_vertex.first);
                }
                //	 std::cout << map_sg_sgid[prev_sg] << " " <<  psuedo_particle_id << " " <<  pio_info_pair.first
                //<< " " << pio_info_pair.second << std::endl;

                // pio
                rtree.mc_mother[pio_info_pair.first] = map_sg_sgid[prev_sg];
                rtree.mc_daughters->at(pio_info_pair.first).push_back(psuedo_particle_id);
                // gamma
                rtree.mc_mother[rtree.mc_Ntrack - 1] = pio_info_pair.second;
                rtree.mc_daughters->at(rtree.mc_Ntrack - 1).push_back(map_sg_sgid[curr_sg]);
                // electron
                rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = psuedo_particle_id;
                if (find(rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).begin(),
                         rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).end(),
                         pio_info_pair.second) == rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).end())
                    rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(pio_info_pair.second);
                //	 rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(psuedo_particle_id);
            }

            // create the second psuedo particle

            // fill the final daughter ...
        }
    }
}

WCPPID::ProtoSegment* WCPPID::NeutrinoID::find_incoming_segment(WCPPID::ProtoVertex* vtx)
{
    WCPPID::ProtoSegment* sg = 0;
    // find the first segment ...
    for (auto it = map_vertex_segments[vtx].begin(); it != map_vertex_segments[vtx].end(); it++) {
        WCPPID::ProtoSegment* current_sg = (*it);
        bool flag_start;
        if (current_sg->get_wcpt_vec().front().index == vtx->get_wcpt().index)
            flag_start = true;
        else if (current_sg->get_wcpt_vec().back().index == vtx->get_wcpt().index)
            flag_start = false;

        if (flag_start && current_sg->get_flag_dir() == -1 || (!flag_start) && current_sg->get_flag_dir() == 1) {
            sg = current_sg;
            break;
        }
    }

    return sg;
}

void WCPPID::NeutrinoID::fill_proto_main_tree(WCPPID::WCRecoTree& rtree)
{
    fill_reco_simple_tree(rtree);

    // id vs. rtree id
    std::map<int, int> map_sgid_rtid;
    std::map<int, int> map_rtid_sgid;
    for (int i = 0; i != rtree.mc_Ntrack; i++) {
        int sgid = rtree.mc_id[i];
        map_sgid_rtid[sgid] = i;
        map_rtid_sgid[i] = sgid;
    }

    // id vs. sg
    std::map<int, WCPPID::ProtoSegment*> map_sgid_sg;
    std::map<WCPPID::ProtoSegment*, int> map_sg_sgid;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* sg = it->first;
        // only save the main cluster
        if (sg->get_cluster_id() != main_cluster->get_cluster_id()) continue;
        int sgid = sg->get_cluster_id() * 1000 + sg->get_id();

        map_sg_sgid[sg] = sgid;
        map_sgid_sg[sgid] = sg;
    }

    // main_vertex figure out the daughters and mother ...
    std::set<WCPPID::ProtoVertex*> used_vertices;
    std::set<WCPPID::ProtoSegment*> used_segments;

    std::vector<std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoSegment*> > segments_to_be_examined;
    for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); it++) {
        // parent are all zero now ...
        used_segments.insert(*it);
        WCPPID::ProtoVertex* other_vertex = find_other_vertex(*it, main_vertex);
        segments_to_be_examined.push_back(std::make_pair(other_vertex, *it));
    }
    used_vertices.insert(main_vertex);
    // std::cout << segments_to_be_examined.size() << " " << used_vertices.size() << " " << used_segments.size() <<
    // std::endl;

    while (segments_to_be_examined.size() > 0) {
        std::vector<std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoSegment*> > temp_segments;
        for (auto it = segments_to_be_examined.begin(); it != segments_to_be_examined.end(); it++) {
            WCPPID::ProtoVertex* curr_vtx = it->first;
            WCPPID::ProtoSegment* prev_sg = it->second;
            if (used_vertices.find(curr_vtx) != used_vertices.end()) continue;

            for (auto it1 = map_vertex_segments[curr_vtx].begin(); it1 != map_vertex_segments[curr_vtx].end(); it1++) {
                WCPPID::ProtoSegment* curr_sg = *it1;
                if (used_segments.find(curr_sg) != used_segments.end()) continue;
                used_segments.insert(curr_sg);
                // set mother ...
                rtree.mc_mother[map_sgid_rtid[map_sg_sgid[curr_sg]]] = map_sg_sgid[prev_sg];
                // set daughters ...
                rtree.mc_daughters->at(map_sgid_rtid[map_sg_sgid[prev_sg]]).push_back(map_sg_sgid[curr_sg]);
                WCPPID::ProtoVertex* other_vertex = find_other_vertex(curr_sg, curr_vtx);
                if (used_vertices.find(other_vertex) == used_vertices.end())
                    temp_segments.push_back(std::make_pair(other_vertex, curr_sg));
            }
            used_vertices.insert(curr_vtx);
        }
        segments_to_be_examined = temp_segments;
    }
}

void WCPPID::NeutrinoID::fill_skeleton_info_magnify(int mother_cluster_id, WCPPID::WCPointTree& ptree, TTree* T,
                                                    double dQdx_scale, double dQdx_offset, bool flag_skip_vertex)
{
    WCPPID::PR3DClusterSelection clusters_vec;
    clusters_vec.push_back(main_cluster);
    for (auto it = other_clusters.begin(); it != other_clusters.end(); it++) {
        clusters_vec.push_back(*it);
    }

    ptree.reco_chi2 = 1;
    ptree.reco_mother_cluster_id = mother_cluster_id;

    for (auto it0 = clusters_vec.begin(); it0 != clusters_vec.end(); it0++) {
        WCPPID::PR3DCluster* cluster = *it0;

        if (!flag_skip_vertex) {
            // fill vertex information
            ptree.reco_flag_track_shower = 0;
            for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
                WCPPID::ProtoVertex* vtx = it->first;
                if (vtx->get_cluster_id() != cluster->get_cluster_id()) continue;
                if (map_vertex_in_shower.find(vtx) != map_vertex_in_shower.end() && vtx != main_vertex) continue;
                ptree.reco_cluster_id = vtx->get_cluster_id();
                ptree.reco_proto_cluster_id = -1;
                ptree.reco_particle_id = -1;
                ptree.reco_ndf = vtx->get_cluster_id();
                ptree.reco_flag_vertex = 1;

                ptree.reco_x = vtx->get_fit_pt().x / units::cm;
                ptree.reco_y = vtx->get_fit_pt().y / units::cm;
                ptree.reco_z = vtx->get_fit_pt().z / units::cm;
                ptree.reco_dQ = vtx->get_dQ() * dQdx_scale + dQdx_offset;
                ptree.reco_dx = vtx->get_dx() / units::cm;
                ptree.reco_pu = vtx->get_pu();
                ptree.reco_pv = vtx->get_pv();
                ptree.reco_pw = vtx->get_pw();
                ptree.reco_pt = vtx->get_pt();
                ptree.reco_reduced_chi2 = vtx->get_reduced_chi2();
                ptree.reco_rr = -1;  // no residual range

                T->Fill();

                // std::cout<<" check vtx #### "<<"  "<<ptree.reco_dx<<", x/y/z
                // "<<ptree.reco_x<<"\t"<<ptree.reco_y<<std::endl;

                // std::cout<<" check vtx #### "<<"  "
                // 	 <<ptree.reco_x<<"\t"<<ptree.reco_y<<"\t dx and dQ: "
                // 	 <<vtx->get_dx()/units::cm<<"\t"
                // 	 <<vtx->get_dQ()
                // 	 <<std::endl;
            }
        }

        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            WCPPID::ProtoSegment* seg = it->first;
            if (seg->get_cluster_id() != cluster->get_cluster_id()) continue;
            std::vector<WCP::Point>& pts = seg->get_point_vec();
            std::vector<double>& dQ_vec = seg->get_dQ_vec();
            std::vector<double>& dx_vec = seg->get_dx_vec();
            std::vector<double>& pu_vec = seg->get_pu_vec();
            std::vector<double>& pv_vec = seg->get_pv_vec();
            std::vector<double>& pw_vec = seg->get_pw_vec();
            std::vector<double>& pt_vec = seg->get_pt_vec();
            std::vector<double>& reduced_chi2_vec = seg->get_reduced_chi2_vec();

            ptree.reco_cluster_id = seg->get_cluster_id();
            ptree.reco_ndf = seg->get_cluster_id();
            ptree.reco_proto_cluster_id = seg->get_cluster_id() * 1000 + seg->get_id();

            // calculate rr ...
            std::vector<double> rr_vec(pts.size(), 0);
            {
                WCPPID::ProtoVertex *start_v = 0, *end_v = 0;
                if ((*it->second.begin())->get_wcpt().index == it->first->get_wcpt_vec().front().index) {
                    start_v = (*it->second.begin());
                    end_v = (*it->second.rbegin());
                }
                else {
                    end_v = (*it->second.begin());
                    start_v = (*it->second.rbegin());
                }
                //	for (auto it1 = map_segment_vertices[it->first].begin();
                //it1!=map_segment_vertices[it->first].end(); it1++){
                //  if ((*it1)->get_wcpt().index == it->first->get_wcpt_vec().front().index) start_v = *it1;
                // if ((*it1)->get_wcpt().index == it->first->get_wcpt_vec().back().index) end_v = *it1;
                //}

                int start_n = map_vertex_segments[start_v].size();
                int end_n = map_vertex_segments[end_v].size();

                std::vector<double> L(pts.size(), 0);
                double acc_length = 0;
                for (size_t i = 0; i + 1 < pts.size(); i++) {
                    acc_length += sqrt(pow(pts.at(i + 1).x - pts.at(i).x, 2) + pow(pts.at(i + 1).y - pts.at(i).y, 2) +
                                       pow(pts.at(i + 1).z - pts.at(i).z, 2));
                    L.at(i + 1) = acc_length;
                }
                if ((seg)->get_flag_dir() == 1) {  // forward direction
                    for (size_t i = 0; i != pts.size(); i++) {
                        rr_vec.at(pts.size() - 1 - i) = L.back() - L.at(pts.size() - 1 - i);
                    }
                }
                else if ((seg)->get_flag_dir() == -1) {  // reverse direction
                    rr_vec = L;
                }
                else {
                    rr_vec = L;  // quick
                }
                if (start_n > 1) rr_vec.front() = -1;
                if (end_n > 1) rr_vec.back() = -1;
            }

            // hack for now ...
            //      ptree.reco_particle_id = seg->get_cluster_id()*1000 + seg->get_id();
            if (seg->get_flag_shower()) {
                ptree.reco_flag_track_shower = 1;
            }
            else {
                ptree.reco_flag_track_shower = 0;
            }

            if (ptree.reco_flag_track_shower == 1) {
                ptree.reco_particle_id = 1;
            }
            else {
                ptree.reco_particle_id = 4;
            }

            ptree.reco_flag_vertex = 0;
            for (size_t i = 0; i != pts.size(); i++) {
                ptree.reco_x = pts.at(i).x / units::cm;
                ptree.reco_y = pts.at(i).y / units::cm;
                ptree.reco_z = pts.at(i).z / units::cm;
                ptree.reco_dQ = dQ_vec.at(i) * dQdx_scale + dQdx_offset;
                ptree.reco_dx = dx_vec.at(i) / units::cm;
                ptree.reco_pu = pu_vec.at(i);
                ptree.reco_pv = pv_vec.at(i);
                ptree.reco_pw = pw_vec.at(i);
                ptree.reco_pt = pt_vec.at(i);
                ptree.reco_reduced_chi2 = reduced_chi2_vec.at(i);
                ptree.reco_rr = rr_vec.at(i) / units::cm;  // no residual range
                T->Fill();

                // std::cout<<" check pts ---> "<<i<<"  "<<ptree.reco_dx<<", x/y/z
                // "<<ptree.reco_x<<"\t"<<ptree.reco_y<<std::endl;

                // std::cout<<" check pts ---> "<<i<<"  "
                // 	 <<ptree.reco_x<<"\t"<<ptree.reco_y<<"\t dx and dQ: "
                // 	 <<dx_vec.at(i)/units::cm<<"\t"
                // 	 <<dQ_vec.at(i)
                // 	 <<std::endl;
            }
        }
    }
}

void WCPPID::NeutrinoID::fill_skeleton_info(int mother_cluster_id, WCPPID::WCPointTree& ptree, TTree* T,
                                            double dQdx_scale, double dQdx_offset, bool flag_skip_vertex)
{
    ptree.reco_chi2 = 1;
    ptree.reco_mother_cluster_id = mother_cluster_id;

    if (!flag_skip_vertex) {
        // fill vertex information
        ptree.reco_flag_track_shower = 0;
        for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
            WCPPID::ProtoVertex* vtx = it->first;
            ptree.reco_cluster_id = vtx->get_cluster_id();
            ptree.reco_proto_cluster_id = -1;
            ptree.reco_particle_id = -1;

            ptree.reco_ndf = vtx->get_cluster_id();
            ptree.reco_flag_vertex = 1;
            ptree.reco_x = vtx->get_fit_pt().x / units::cm;
            ptree.reco_y = vtx->get_fit_pt().y / units::cm;
            ptree.reco_z = vtx->get_fit_pt().z / units::cm;
            ptree.reco_dQ = vtx->get_dQ() * dQdx_scale + dQdx_offset;
            ptree.reco_dx = vtx->get_dx() / units::cm;
            ptree.reco_pu = vtx->get_pu();
            ptree.reco_pv = vtx->get_pv();
            ptree.reco_pw = vtx->get_pw();
            ptree.reco_pt = vtx->get_pt();
            ptree.reco_reduced_chi2 = vtx->get_reduced_chi2();

            if (vtx->get_dQ() != 0) T->Fill();
        }
    }

    for (auto it = map_vertex_to_shower.begin(); it != map_vertex_to_shower.end(); it++) {
        WCPPID::ProtoVertex* vtx = it->first;
        for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++) {
            WCPPID::WCShower* shower = (*it1);

            if (map_vertex_segments[vtx].find(shower->get_start_segment()) != map_vertex_segments[vtx].end()) {
                ptree.reco_cluster_id = vtx->get_cluster_id();

                ptree.reco_proto_cluster_id =
                    shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();
                ptree.reco_particle_id =
                    shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();

                ptree.reco_ndf = vtx->get_cluster_id();
                ptree.reco_flag_vertex = 1;

                ptree.reco_x = vtx->get_fit_pt().x / units::cm;
                ptree.reco_y = vtx->get_fit_pt().y / units::cm;
                ptree.reco_z = vtx->get_fit_pt().z / units::cm;
                ptree.reco_dQ = vtx->get_dQ() * dQdx_scale + dQdx_offset;
                ptree.reco_dx = vtx->get_dx() / units::cm;
                ptree.reco_pu = vtx->get_pu();
                ptree.reco_pv = vtx->get_pv();
                ptree.reco_pw = vtx->get_pw();
                ptree.reco_pt = vtx->get_pt();
                ptree.reco_reduced_chi2 = vtx->get_reduced_chi2();

                if (vtx->get_dQ() != 0) T->Fill();
            }
        }
    }

    for (auto it = map_vertex_in_shower.begin(); it != map_vertex_in_shower.end(); it++) {
        WCPPID::ProtoVertex* vtx = it->first;
        WCPPID::WCShower* shower = it->second;

        ptree.reco_proto_cluster_id =
            shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();
        if (shower->get_flag_shower()) {
            ptree.reco_flag_track_shower = 1;
        }
        else {
            ptree.reco_flag_track_shower = 0;
        }
        ptree.reco_particle_id =
            shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();
        ptree.reco_flag_vertex = 0;

        ptree.reco_x = vtx->get_fit_pt().x / units::cm;
        ptree.reco_y = vtx->get_fit_pt().y / units::cm;
        ptree.reco_z = vtx->get_fit_pt().z / units::cm;
        ptree.reco_dQ = vtx->get_dQ() * dQdx_scale + dQdx_offset;
        ptree.reco_dx = vtx->get_dx() / units::cm;
        ptree.reco_pu = vtx->get_pu();
        ptree.reco_pv = vtx->get_pv();
        ptree.reco_pw = vtx->get_pw();
        ptree.reco_pt = vtx->get_pt();
        ptree.reco_reduced_chi2 = vtx->get_reduced_chi2();

        // std::cout << vtx->get_cluster_id() << " " << vtx->get_id() << " " << vtx->get_fit_pt() << " " <<
        // shower->get_start_segment()->get_cluster_id() << " " << shower->get_start_segment()->get_id() << std::endl;

        // std::cout <<  ptree.reco_proto_cluster_id << std::endl;
        // std::cout << shower->get_start_segment()->get_length()/units::cm << " " << vtx << " " << shower << std::endl;
        if (vtx->get_dQ() != 0) T->Fill();
    }

    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* seg = it->first;

        std::vector<WCP::Point>& pts = seg->get_point_vec();
        std::vector<double>& dQ_vec = seg->get_dQ_vec();
        std::vector<double>& dx_vec = seg->get_dx_vec();
        std::vector<double>& pu_vec = seg->get_pu_vec();
        std::vector<double>& pv_vec = seg->get_pv_vec();
        std::vector<double>& pw_vec = seg->get_pw_vec();
        std::vector<double>& pt_vec = seg->get_pt_vec();
        std::vector<double>& reduced_chi2_vec = seg->get_reduced_chi2_vec();

        ptree.reco_cluster_id = seg->get_cluster_id();
        ptree.reco_ndf = seg->get_cluster_id();

        auto it1 = map_segment_in_shower.find(seg);
        if (it1 != map_segment_in_shower.end()) {
            WCPPID::WCShower* shower = it1->second;

            ptree.reco_proto_cluster_id =
                shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();
            if (shower->get_flag_shower()) {
                ptree.reco_flag_track_shower = 1;
            }
            else {
                ptree.reco_flag_track_shower = 0;
            }
            ptree.reco_particle_id =
                shower->get_start_segment()->get_cluster_id() * 1000 + shower->get_start_segment()->get_id();
            ptree.reco_flag_vertex = 0;

            for (size_t i = 1; i + 1 < pts.size(); i++) {
                ptree.reco_x = pts.at(i).x / units::cm;
                ptree.reco_y = pts.at(i).y / units::cm;
                ptree.reco_z = pts.at(i).z / units::cm;
                ptree.reco_dQ = dQ_vec.at(i) * dQdx_scale + dQdx_offset;
                ptree.reco_dx = dx_vec.at(i) / units::cm;
                ptree.reco_pu = pu_vec.at(i);
                ptree.reco_pv = pv_vec.at(i);
                ptree.reco_pw = pw_vec.at(i);
                ptree.reco_pt = pt_vec.at(i);
                ptree.reco_reduced_chi2 = reduced_chi2_vec.at(i);
                T->Fill();
            }
        }
        else {
            ptree.reco_proto_cluster_id = seg->get_cluster_id() * 1000 + seg->get_id();

            if (seg->get_flag_shower()) {
                ptree.reco_flag_track_shower = 1;
            }
            else {
                ptree.reco_flag_track_shower = 0;
            }

            ptree.reco_particle_id = ptree.reco_particle_id = seg->get_cluster_id() * 1000 + seg->get_id();

            ptree.reco_flag_vertex = 0;
            for (size_t i = 0; i != pts.size(); i++) {
                ptree.reco_x = pts.at(i).x / units::cm;
                ptree.reco_y = pts.at(i).y / units::cm;
                ptree.reco_z = pts.at(i).z / units::cm;
                ptree.reco_dQ = dQ_vec.at(i) * dQdx_scale + dQdx_offset;
                ptree.reco_dx = dx_vec.at(i) / units::cm;
                ptree.reco_pu = pu_vec.at(i);
                ptree.reco_pv = pv_vec.at(i);
                ptree.reco_pw = pw_vec.at(i);
                ptree.reco_pt = pt_vec.at(i);
                ptree.reco_reduced_chi2 = reduced_chi2_vec.at(i);
                T->Fill();
            }
        }
    }
}

void WCPPID::NeutrinoID::fill_point_info(int mother_cluster_id, WCPPID::WCPointTree& ptree, TTree* T)
{
    ptree.reco_mother_cluster_id = mother_cluster_id;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment* seg = it->first;

        auto it1 = map_segment_in_shower.find(seg);
        if (it1 != map_segment_in_shower.end()) {
            ptree.reco_proto_cluster_id = (it1->second)->get_start_segment()->get_cluster_id() * 1000 +
                                          (it1->second)->get_start_segment()->get_id();
            if (it1->second->get_flag_shower()) {
                ptree.reco_flag_track_shower = 1;
                ptree.reco_flag_track_shower_charge = 15000;
            }
            else {
                ptree.reco_flag_track_shower = 0;
                ptree.reco_flag_track_shower_charge = 0;
            }
        }
        else {
            ptree.reco_proto_cluster_id = seg->get_cluster_id() * 1000 + seg->get_id();
            if (seg->get_flag_shower()) {
                ptree.reco_flag_track_shower = 1;
                ptree.reco_flag_track_shower_charge = 15000;
            }
            else {
                ptree.reco_flag_track_shower = 0;
                ptree.reco_flag_track_shower_charge = 0;
            }
        }
        ptree.reco_cluster_id = seg->get_cluster_id();

        ToyPointCloud* pcloud = seg->get_associated_pcloud();
        if (pcloud != 0) {
            auto cloud = pcloud->get_cloud();
            //    std::cout << cloud.pts.size() << std::endl;
            for (size_t i = 0; i != cloud.pts.size(); i++) {
                ptree.reco_x = cloud.pts.at(i).x / units::cm;
                ptree.reco_y = cloud.pts.at(i).y / units::cm;
                ptree.reco_z = cloud.pts.at(i).z / units::cm;
                T->Fill();
            }
        }
    }
}

void WCPPID::NeutrinoID::init_tagger_info()
{
    // initialize cosmic one
    tagger_info.cosmic_flag = true;
    tagger_info.cosmic_n_solid_tracks = 0;
    tagger_info.cosmic_energy_main_showers = 0;
    tagger_info.cosmic_energy_direct_showers = 0;
    tagger_info.cosmic_energy_indirect_showers = 0;
    tagger_info.cosmic_n_direct_showers = 0;
    tagger_info.cosmic_n_indirect_showers = 0;
    tagger_info.cosmic_n_main_showers = 0;
    tagger_info.cosmic_filled = 0;

    // std::cout << "haha: " << tagger_info.cosmic_flag << std::endl;

    // shower gap identification
    tagger_info.gap_flag = true;
    tagger_info.gap_flag_prolong_u = false;
    tagger_info.gap_flag_prolong_v = false;
    tagger_info.gap_flag_prolong_w = false;
    tagger_info.gap_flag_parallel = false;
    tagger_info.gap_n_points = 0;
    tagger_info.gap_n_bad = 0;
    tagger_info.gap_energy = 0;
    tagger_info.gap_num_valid_tracks = 0;
    tagger_info.gap_flag_single_shower = false;
    tagger_info.gap_filled = 0;

    // shower MIP quality
    tagger_info.mip_quality_flag = true;
    tagger_info.mip_quality_energy = 0;
    tagger_info.mip_quality_overlap = false;
    tagger_info.mip_quality_n_showers = 0;
    tagger_info.mip_quality_n_tracks = 0;
    tagger_info.mip_quality_flag_inside_pi0 = false;
    tagger_info.mip_quality_n_pi0_showers = 0;
    tagger_info.mip_quality_shortest_length = 0;
    tagger_info.mip_quality_acc_length = 0;
    tagger_info.mip_quality_shortest_angle = 0;
    tagger_info.mip_quality_flag_proton = false;
    tagger_info.mip_quality_filled = 0;

    // mip identification
    tagger_info.mip_flag = true;
    tagger_info.mip_n_first_non_mip_2 = 19;
    tagger_info.mip_n_first_mip = 0;
    tagger_info.mip_n_end_reduction = 0;
    tagger_info.mip_n_first_non_mip_1 = 19;
    tagger_info.mip_n_first_non_mip = 19;
    tagger_info.mip_energy = 0;
    tagger_info.mip_max_dQ_dx_sample = 1;
    tagger_info.mip_vec_dQ_dx_0 = 1;
    tagger_info.mip_vec_dQ_dx_1 = 1;
    tagger_info.mip_n_below_threshold = 19;
    tagger_info.mip_n_good_tracks = 0;
    tagger_info.mip_n_vertex = 1;
    tagger_info.mip_angle_beam = 0;
    tagger_info.mip_flag_all_above = false;
    tagger_info.mip_length_main = 1;
    tagger_info.mip_length_total = 1;
    tagger_info.mip_min_dQ_dx_5 = 1;
    tagger_info.mip_lowest_dQ_dx = 1;
    tagger_info.mip_iso_angle = 0;
    tagger_info.mip_n_below_zero = 0;
    tagger_info.mip_highest_dQ_dx = 1;
    tagger_info.mip_n_lowest = 1;
    tagger_info.mip_n_highest = 1;
    tagger_info.mip_stem_length = 1;
    tagger_info.mip_E_indirect_max_energy = 0;
    tagger_info.mip_flag_stem_trajectory = 0;
    tagger_info.mip_min_dis = 0;
    tagger_info.mip_n_other_vertex = 2;
    tagger_info.mip_n_stem_size = 20;
    tagger_info.mip_medium_dQ_dx = 1;
    tagger_info.mip_filled = 0;

    tagger_info.mip_vec_dQ_dx_2 = 0;
    tagger_info.mip_vec_dQ_dx_3 = 0;
    tagger_info.mip_vec_dQ_dx_4 = 0;
    tagger_info.mip_vec_dQ_dx_5 = 0;
    tagger_info.mip_vec_dQ_dx_6 = 0;
    tagger_info.mip_vec_dQ_dx_7 = 0;
    tagger_info.mip_vec_dQ_dx_8 = 0;
    tagger_info.mip_vec_dQ_dx_9 = 0;
    tagger_info.mip_vec_dQ_dx_10 = 0;
    tagger_info.mip_vec_dQ_dx_11 = 0;
    tagger_info.mip_vec_dQ_dx_12 = 0;
    tagger_info.mip_vec_dQ_dx_13 = 0;
    tagger_info.mip_vec_dQ_dx_14 = 0;
    tagger_info.mip_vec_dQ_dx_15 = 0;
    tagger_info.mip_vec_dQ_dx_16 = 0;
    tagger_info.mip_vec_dQ_dx_17 = 0;
    tagger_info.mip_vec_dQ_dx_18 = 0;
    tagger_info.mip_vec_dQ_dx_19 = 0;

    // single photon shower identification
    tagger_info.shw_sp_flag = true;
    tagger_info.shw_sp_num_mip_tracks = 0;
    tagger_info.shw_sp_num_muons = 0;
    tagger_info.shw_sp_num_pions = 0;
    tagger_info.shw_sp_num_protons = 0;
    tagger_info.shw_sp_proton_length_1 = -1;
    tagger_info.shw_sp_proton_dqdx_1 = -1;
    tagger_info.shw_sp_proton_energy_1 = -1;
    tagger_info.shw_sp_proton_length_2 = -1;
    tagger_info.shw_sp_proton_dqdx_2 = -1;
    tagger_info.shw_sp_proton_energy_2 = -1;
    tagger_info.shw_sp_n_good_showers = 0;
    tagger_info.shw_sp_n_20mev_showers = 0;
    tagger_info.shw_sp_n_br1_showers = 0;
    tagger_info.shw_sp_n_br2_showers = 0;
    tagger_info.shw_sp_n_br3_showers = 0;
    tagger_info.shw_sp_n_br4_showers = 0;
    tagger_info.shw_sp_n_20mev_showers = 0;
    tagger_info.shw_sp_n_br1_showers = 0;
    tagger_info.shw_sp_n_br2_showers = 0;
    tagger_info.shw_sp_n_br3_showers = 0;
    tagger_info.shw_sp_n_br4_showers = 0;
    tagger_info.shw_sp_n_20br1_showers = 0;
    tagger_info.shw_sp_shw_vtx_dis = -1;
    tagger_info.shw_sp_max_shw_dis = -1;
    tagger_info.shw_sp_energy = 0;
    tagger_info.shw_sp_max_dQ_dx_sample = 1;
    tagger_info.shw_sp_vec_dQ_dx_0 = 1;
    tagger_info.shw_sp_vec_dQ_dx_1 = 1;
    tagger_info.shw_sp_n_below_threshold = 19;
    tagger_info.shw_sp_n_good_tracks = 0;
    tagger_info.shw_sp_n_vertex = 1;
    tagger_info.shw_sp_angle_beam = 0;
    tagger_info.shw_sp_flag_all_above = false;
    tagger_info.shw_sp_length_main = 1;
    tagger_info.shw_sp_length_total = 1;
    tagger_info.shw_sp_min_dQ_dx_5 = 1;
    tagger_info.shw_sp_lowest_dQ_dx = 1;
    tagger_info.shw_sp_iso_angle = 0;
    tagger_info.shw_sp_n_below_zero = 0;
    tagger_info.shw_sp_highest_dQ_dx = 1;
    tagger_info.shw_sp_n_lowest = 1;
    tagger_info.shw_sp_n_highest = 1;
    tagger_info.shw_sp_stem_length = 1;
    tagger_info.shw_sp_E_indirect_max_energy = 0;
    tagger_info.shw_sp_flag_stem_trajectory = 0;
    tagger_info.shw_sp_min_dis = 0;
    tagger_info.shw_sp_n_other_vertex = 2;
    tagger_info.shw_sp_n_stem_size = 20;
    tagger_info.shw_sp_medium_dQ_dx = 1;
    tagger_info.shw_sp_filled = 0;

    tagger_info.shw_sp_vec_dQ_dx_2 = 0;
    tagger_info.shw_sp_vec_dQ_dx_3 = 0;
    tagger_info.shw_sp_vec_dQ_dx_4 = 0;
    tagger_info.shw_sp_vec_dQ_dx_5 = 0;
    tagger_info.shw_sp_vec_dQ_dx_6 = 0;
    tagger_info.shw_sp_vec_dQ_dx_7 = 0;
    tagger_info.shw_sp_vec_dQ_dx_8 = 0;
    tagger_info.shw_sp_vec_dQ_dx_9 = 0;
    tagger_info.shw_sp_vec_dQ_dx_10 = 0;
    tagger_info.shw_sp_vec_dQ_dx_11 = 0;
    tagger_info.shw_sp_vec_dQ_dx_12 = 0;
    tagger_info.shw_sp_vec_dQ_dx_13 = 0;
    tagger_info.shw_sp_vec_dQ_dx_14 = 0;
    tagger_info.shw_sp_vec_dQ_dx_15 = 0;
    tagger_info.shw_sp_vec_dQ_dx_16 = 0;
    tagger_info.shw_sp_vec_dQ_dx_17 = 0;
    tagger_info.shw_sp_vec_dQ_dx_18 = 0;
    tagger_info.shw_sp_vec_dQ_dx_19 = 0;
    tagger_info.shw_sp_vec_median_dedx = 0;
    tagger_info.shw_sp_vec_mean_dedx = 0;

    // shower pi0 identification
    tagger_info.shw_sp_pio_flag = true;
    tagger_info.shw_sp_pio_mip_id = 0;
    tagger_info.shw_sp_pio_filled = 0;
    tagger_info.shw_sp_pio_flag_pio = 0;

    tagger_info.shw_sp_pio_1_flag = true;
    tagger_info.shw_sp_pio_1_mass = 0;
    tagger_info.shw_sp_pio_1_pio_type = 0;
    tagger_info.shw_sp_pio_1_energy_1 = 0;
    tagger_info.shw_sp_pio_1_energy_2 = 0;
    tagger_info.shw_sp_pio_1_dis_1 = 0;
    tagger_info.shw_sp_pio_1_dis_2 = 0;

    // bad reconstruction
    tagger_info.shw_sp_br_filled = 0;

    tagger_info.shw_sp_br1_flag = true;
    // br1_1
    tagger_info.shw_sp_br1_1_flag = true;
    tagger_info.shw_sp_br1_1_shower_type = 0;
    tagger_info.shw_sp_br1_1_vtx_n_segs = 0;
    tagger_info.shw_sp_br1_1_energy = 0;
    tagger_info.shw_sp_br1_1_n_segs = 0;
    tagger_info.shw_sp_br1_1_flag_sg_topology = 0;
    tagger_info.shw_sp_br1_1_flag_sg_trajectory = 0;
    tagger_info.shw_sp_br1_1_sg_length = 0;

    // br1_2
    tagger_info.shw_sp_br1_2_flag = true;
    tagger_info.shw_sp_br1_2_energy = 0;
    tagger_info.shw_sp_br1_2_n_connected = 0;
    tagger_info.shw_sp_br1_2_max_length = 0;
    tagger_info.shw_sp_br1_2_n_connected_1 = 0;
    tagger_info.shw_sp_br1_2_vtx_n_segs = 0;
    tagger_info.shw_sp_br1_2_n_shower_segs = 0;
    tagger_info.shw_sp_br1_2_max_length_ratio = 1;
    tagger_info.shw_sp_br1_2_shower_length = 0;

    // br1_3
    tagger_info.shw_sp_br1_3_flag = true;
    tagger_info.shw_sp_br1_3_energy = 0;
    tagger_info.shw_sp_br1_3_n_connected_p = 0;
    tagger_info.shw_sp_br1_3_max_length_p = 0;
    tagger_info.shw_sp_br1_3_n_shower_segs = 0;
    tagger_info.shw_sp_br1_3_flag_sg_topology = 0;
    tagger_info.shw_sp_br1_3_flag_sg_trajectory = 0;
    tagger_info.shw_sp_br1_3_n_shower_main_segs = 0;
    tagger_info.shw_sp_br1_3_sg_length = 0;

    // br2
    tagger_info.shw_sp_br2_flag = true;
    tagger_info.shw_sp_br2_flag_single_shower = 0;
    tagger_info.shw_sp_br2_num_valid_tracks = 0;
    tagger_info.shw_sp_br2_energy = 0;
    tagger_info.shw_sp_br2_angle1 = 0;
    tagger_info.shw_sp_br2_angle2 = 0;
    tagger_info.shw_sp_br2_angle = 0;
    tagger_info.shw_sp_br2_angle3 = 0;
    tagger_info.shw_sp_br2_n_shower_main_segs = 0;
    tagger_info.shw_sp_br2_max_angle = 0;
    tagger_info.shw_sp_br2_sg_length = 0;
    tagger_info.shw_sp_br2_flag_sg_trajectory = 0;

    // low-energy overlap
    tagger_info.shw_sp_lol_flag = true;
    tagger_info.shw_sp_lol_3_flag = true;
    tagger_info.shw_sp_lol_3_angle_beam = 0;
    tagger_info.shw_sp_lol_3_min_angle = 0;
    tagger_info.shw_sp_lol_3_n_valid_tracks = 0;
    tagger_info.shw_sp_lol_3_vtx_n_segs = 0;
    tagger_info.shw_sp_lol_3_energy = 0;
    tagger_info.shw_sp_lol_3_shower_main_length = 0;
    tagger_info.shw_sp_lol_3_n_sum = 0;
    tagger_info.shw_sp_lol_3_n_out = 0;

    // br3
    tagger_info.shw_sp_br3_1_energy = 0;
    tagger_info.shw_sp_br3_1_n_shower_segments = 0;
    tagger_info.shw_sp_br3_1_sg_flag_trajectory = 0;
    tagger_info.shw_sp_br3_1_sg_direct_length = 0;
    tagger_info.shw_sp_br3_1_sg_length = 0;
    tagger_info.shw_sp_br3_1_total_main_length = 0;
    tagger_info.shw_sp_br3_1_total_length = 0;
    tagger_info.shw_sp_br3_1_iso_angle = 0;
    tagger_info.shw_sp_br3_1_sg_flag_topology = 0;
    tagger_info.shw_sp_br3_1_flag = true;

    tagger_info.shw_sp_br3_2_n_ele = 0;
    tagger_info.shw_sp_br3_2_n_other = 0;
    tagger_info.shw_sp_br3_2_energy = 0;
    tagger_info.shw_sp_br3_2_total_main_length = 0;
    tagger_info.shw_sp_br3_2_total_length = 0;
    tagger_info.shw_sp_br3_2_other_fid = 0;
    tagger_info.shw_sp_br3_2_flag = true;

    tagger_info.shw_sp_br3_4_acc_length = 0;
    tagger_info.shw_sp_br3_4_total_length = 0;
    tagger_info.shw_sp_br3_4_energy = 0;
    tagger_info.shw_sp_br3_4_flag = true;

    tagger_info.shw_sp_br3_7_energy = 0;
    tagger_info.shw_sp_br3_7_min_angle = 0;
    tagger_info.shw_sp_br3_7_sg_length = 0;
    tagger_info.shw_sp_br3_7_shower_main_length = 0;
    tagger_info.shw_sp_br3_7_flag = true;

    tagger_info.shw_sp_br3_8_max_dQ_dx = 0;
    tagger_info.shw_sp_br3_8_energy = 0;
    tagger_info.shw_sp_br3_8_n_main_segs = 0;
    tagger_info.shw_sp_br3_8_shower_main_length = 0;
    tagger_info.shw_sp_br3_8_shower_length = 0;
    tagger_info.shw_sp_br3_8_flag = true;

    tagger_info.shw_sp_br3_flag = true;

    tagger_info.shw_sp_br4_1_shower_main_length = 0;
    tagger_info.shw_sp_br4_1_shower_total_length = 0;
    tagger_info.shw_sp_br4_1_min_dis = 0;
    tagger_info.shw_sp_br4_1_energy = 0;
    tagger_info.shw_sp_br4_1_flag_avoid_muon_check = 0;
    tagger_info.shw_sp_br4_1_n_vtx_segs = 0;
    tagger_info.shw_sp_br4_1_n_main_segs = 0;
    tagger_info.shw_sp_br4_1_flag = true;

    tagger_info.shw_sp_br4_2_ratio_45 = 1;
    tagger_info.shw_sp_br4_2_ratio_35 = 1;
    tagger_info.shw_sp_br4_2_ratio_25 = 1;
    tagger_info.shw_sp_br4_2_ratio_15 = 1;
    tagger_info.shw_sp_br4_2_energy = 0;
    tagger_info.shw_sp_br4_2_ratio1_45 = 1;
    tagger_info.shw_sp_br4_2_ratio1_35 = 1;
    tagger_info.shw_sp_br4_2_ratio1_25 = 1;
    tagger_info.shw_sp_br4_2_ratio1_15 = 1;
    tagger_info.shw_sp_br4_2_iso_angle = 0;
    tagger_info.shw_sp_br4_2_iso_angle1 = 0;
    tagger_info.shw_sp_br4_2_angle = 0;
    tagger_info.shw_sp_br4_2_flag = true;

    tagger_info.shw_sp_br4_flag = true;

    tagger_info.shw_sp_hol_1_n_valid_tracks = 0;
    tagger_info.shw_sp_hol_1_min_angle = 0;
    tagger_info.shw_sp_hol_1_energy = 0;
    tagger_info.shw_sp_hol_1_flag_all_shower = 0;
    tagger_info.shw_sp_hol_1_min_length = 0;
    tagger_info.shw_sp_hol_1_flag = true;

    tagger_info.shw_sp_hol_2_min_angle = 0;
    tagger_info.shw_sp_hol_2_medium_dQ_dx = 1;
    tagger_info.shw_sp_hol_2_ncount = 0;
    tagger_info.shw_sp_hol_2_energy = 0;
    tagger_info.shw_sp_hol_2_flag = true;

    tagger_info.shw_sp_hol_flag = true;

    tagger_info.shw_sp_lem_shower_total_length = 0;
    tagger_info.shw_sp_lem_shower_main_length = 0;
    tagger_info.shw_sp_lem_n_3seg = 0;
    tagger_info.shw_sp_lem_e_charge = 0;
    tagger_info.shw_sp_lem_e_dQdx = 0;
    tagger_info.shw_sp_lem_shower_num_segs = 0;
    tagger_info.shw_sp_lem_shower_num_main_segs = 0;
    tagger_info.shw_sp_lem_flag = true;

    // shower pi0 identification
    tagger_info.pio_flag = true;
    tagger_info.pio_mip_id = 0;
    tagger_info.pio_filled = 0;
    tagger_info.pio_flag_pio = 0;

    tagger_info.pio_1_flag = true;
    tagger_info.pio_1_mass = 0;
    tagger_info.pio_1_pio_type = 0;
    tagger_info.pio_1_energy_1 = 0;
    tagger_info.pio_1_energy_2 = 0;
    tagger_info.pio_1_dis_1 = 0;
    tagger_info.pio_1_dis_2 = 0;

    // stem direction
    tagger_info.stem_dir_flag = true;
    tagger_info.stem_dir_flag_single_shower = 0;
    tagger_info.stem_dir_filled = 0;
    tagger_info.stem_dir_angle = 0;
    tagger_info.stem_dir_energy = 0;
    tagger_info.stem_dir_angle1 = 0;
    tagger_info.stem_dir_angle2 = 0;
    tagger_info.stem_dir_angle3 = 0;
    tagger_info.stem_dir_ratio = 1;

    // bad reconstruction
    tagger_info.br_filled = 0;

    tagger_info.br1_flag = true;
    // br1_1
    tagger_info.br1_1_flag = true;
    tagger_info.br1_1_shower_type = 0;
    tagger_info.br1_1_vtx_n_segs = 0;
    tagger_info.br1_1_energy = 0;
    tagger_info.br1_1_n_segs = 0;
    tagger_info.br1_1_flag_sg_topology = 0;
    tagger_info.br1_1_flag_sg_trajectory = 0;
    tagger_info.br1_1_sg_length = 0;

    // br1_2
    tagger_info.br1_2_flag = true;
    tagger_info.br1_2_energy = 0;
    tagger_info.br1_2_n_connected = 0;
    tagger_info.br1_2_max_length = 0;
    tagger_info.br1_2_n_connected_1 = 0;
    tagger_info.br1_2_vtx_n_segs = 0;
    tagger_info.br1_2_n_shower_segs = 0;
    tagger_info.br1_2_max_length_ratio = 1;
    tagger_info.br1_2_shower_length = 0;

    // br1_3
    tagger_info.br1_3_flag = true;
    tagger_info.br1_3_energy = 0;
    tagger_info.br1_3_n_connected_p = 0;
    tagger_info.br1_3_max_length_p = 0;
    tagger_info.br1_3_n_shower_segs = 0;
    tagger_info.br1_3_flag_sg_topology = 0;
    tagger_info.br1_3_flag_sg_trajectory = 0;
    tagger_info.br1_3_n_shower_main_segs = 0;
    tagger_info.br1_3_sg_length = 0;

    // br2
    tagger_info.br2_flag = true;
    tagger_info.br2_flag_single_shower = 0;
    tagger_info.br2_num_valid_tracks = 0;
    tagger_info.br2_energy = 0;
    tagger_info.br2_angle1 = 0;
    tagger_info.br2_angle2 = 0;
    tagger_info.br2_angle = 0;
    tagger_info.br2_angle3 = 0;
    tagger_info.br2_n_shower_main_segs = 0;
    tagger_info.br2_max_angle = 0;
    tagger_info.br2_sg_length = 0;
    tagger_info.br2_flag_sg_trajectory = 0;

    // low-energy overlap
    tagger_info.lol_flag = true;
    tagger_info.lol_3_flag = true;
    tagger_info.lol_3_angle_beam = 0;
    tagger_info.lol_3_min_angle = 0;
    tagger_info.lol_3_n_valid_tracks = 0;
    tagger_info.lol_3_vtx_n_segs = 0;
    tagger_info.lol_3_energy = 0;
    tagger_info.lol_3_shower_main_length = 0;
    tagger_info.lol_3_n_sum = 0;
    tagger_info.lol_3_n_out = 0;

    // br3
    tagger_info.br3_1_energy = 0;
    tagger_info.br3_1_n_shower_segments = 0;
    tagger_info.br3_1_sg_flag_trajectory = 0;
    tagger_info.br3_1_sg_direct_length = 0;
    tagger_info.br3_1_sg_length = 0;
    tagger_info.br3_1_total_main_length = 0;
    tagger_info.br3_1_total_length = 0;
    tagger_info.br3_1_iso_angle = 0;
    tagger_info.br3_1_sg_flag_topology = 0;
    tagger_info.br3_1_flag = true;

    tagger_info.br3_2_n_ele = 0;
    tagger_info.br3_2_n_other = 0;
    tagger_info.br3_2_energy = 0;
    tagger_info.br3_2_total_main_length = 0;
    tagger_info.br3_2_total_length = 0;
    tagger_info.br3_2_other_fid = 0;
    tagger_info.br3_2_flag = true;

    tagger_info.br3_4_acc_length = 0;
    tagger_info.br3_4_total_length = 0;
    tagger_info.br3_4_energy = 0;
    tagger_info.br3_4_flag = true;

    tagger_info.br3_7_energy = 0;
    tagger_info.br3_7_min_angle = 0;
    tagger_info.br3_7_sg_length = 0;
    tagger_info.br3_7_shower_main_length = 0;
    tagger_info.br3_7_flag = true;

    tagger_info.br3_8_max_dQ_dx = 0;
    tagger_info.br3_8_energy = 0;
    tagger_info.br3_8_n_main_segs = 0;
    tagger_info.br3_8_shower_main_length = 0;
    tagger_info.br3_8_shower_length = 0;
    tagger_info.br3_8_flag = true;

    tagger_info.br3_flag = true;

    tagger_info.br4_1_shower_main_length = 0;
    tagger_info.br4_1_shower_total_length = 0;
    tagger_info.br4_1_min_dis = 0;
    tagger_info.br4_1_energy = 0;
    tagger_info.br4_1_flag_avoid_muon_check = 0;
    tagger_info.br4_1_n_vtx_segs = 0;
    tagger_info.br4_1_n_main_segs = 0;
    tagger_info.br4_1_flag = true;

    tagger_info.br4_2_ratio_45 = 1;
    tagger_info.br4_2_ratio_35 = 1;
    tagger_info.br4_2_ratio_25 = 1;
    tagger_info.br4_2_ratio_15 = 1;
    tagger_info.br4_2_energy = 0;
    tagger_info.br4_2_ratio1_45 = 1;
    tagger_info.br4_2_ratio1_35 = 1;
    tagger_info.br4_2_ratio1_25 = 1;
    tagger_info.br4_2_ratio1_15 = 1;
    tagger_info.br4_2_iso_angle = 0;
    tagger_info.br4_2_iso_angle1 = 0;
    tagger_info.br4_2_angle = 0;
    tagger_info.br4_2_flag = true;

    tagger_info.br4_flag = true;

    tagger_info.hol_1_n_valid_tracks = 0;
    tagger_info.hol_1_min_angle = 0;
    tagger_info.hol_1_energy = 0;
    tagger_info.hol_1_flag_all_shower = 0;
    tagger_info.hol_1_min_length = 0;
    tagger_info.hol_1_flag = true;

    tagger_info.hol_2_min_angle = 0;
    tagger_info.hol_2_medium_dQ_dx = 1;
    tagger_info.hol_2_ncount = 0;
    tagger_info.hol_2_energy = 0;
    tagger_info.hol_2_flag = true;

    tagger_info.hol_flag = true;

    // vertex inside shower
    tagger_info.vis_1_filled = false;
    tagger_info.vis_1_n_vtx_segs = 0;
    tagger_info.vis_1_energy = 0;
    tagger_info.vis_1_num_good_tracks = 0;
    tagger_info.vis_1_max_angle = 0;
    tagger_info.vis_1_max_shower_angle = 0;
    tagger_info.vis_1_tmp_length1 = 0;
    tagger_info.vis_1_tmp_length2 = 0;
    tagger_info.vis_1_particle_type = 0;
    tagger_info.vis_1_flag = true;

    tagger_info.vis_2_filled = false;
    tagger_info.vis_2_n_vtx_segs = 0;
    tagger_info.vis_2_min_angle = 0;
    tagger_info.vis_2_min_weak_track = 0;
    tagger_info.vis_2_angle_beam = 0;
    tagger_info.vis_2_min_angle1 = 0;
    tagger_info.vis_2_iso_angle1 = 0;
    tagger_info.vis_2_min_medium_dQ_dx = 0;
    tagger_info.vis_2_min_length = 0;
    tagger_info.vis_2_sg_length = 0;
    tagger_info.vis_2_max_angle = 0;
    tagger_info.vis_2_max_weak_track = 0;
    tagger_info.vis_2_flag = true;

    tagger_info.vis_flag = true;

    tagger_info.stem_len_energy = 0;
    tagger_info.stem_len_length = 0;
    tagger_info.stem_len_flag_avoid_muon_check = 0;
    tagger_info.stem_len_num_daughters = 0;
    tagger_info.stem_len_daughter_length = 0;
    tagger_info.stem_len_flag = true;

    tagger_info.brm_n_mu_segs = 0;
    tagger_info.brm_Ep = 0;
    tagger_info.brm_energy = 0;
    tagger_info.brm_acc_length = 0;
    tagger_info.brm_shower_total_length = 0;
    tagger_info.brm_connected_length = 0;
    tagger_info.brm_n_size = 0;
    tagger_info.brm_acc_direct_length = 0;
    tagger_info.brm_n_shower_main_segs = 0;
    tagger_info.brm_n_mu_main = 0;
    tagger_info.brm_flag = true;

    tagger_info.cme_mu_energy = 0;
    tagger_info.cme_energy = 0;
    tagger_info.cme_mu_length = 0;
    tagger_info.cme_length = 0;
    tagger_info.cme_angle_beam = 0;
    tagger_info.cme_flag = true;

    tagger_info.anc_energy = 0;
    tagger_info.anc_angle = 0;
    tagger_info.anc_max_angle = 0;
    tagger_info.anc_max_length = 0;
    tagger_info.anc_acc_forward_length = 0;
    tagger_info.anc_acc_backward_length = 0;
    tagger_info.anc_acc_forward_length1 = 0;
    tagger_info.anc_shower_main_length = 0;
    tagger_info.anc_shower_total_length = 0;
    tagger_info.anc_flag_main_outside = 0;
    tagger_info.anc_flag = true;

    tagger_info.lem_shower_total_length = 0;
    tagger_info.lem_shower_main_length = 0;
    tagger_info.lem_n_3seg = 0;
    tagger_info.lem_e_charge = 0;
    tagger_info.lem_e_dQdx = 0;
    tagger_info.lem_shower_num_segs = 0;
    tagger_info.lem_shower_num_main_segs = 0;
    tagger_info.lem_flag = true;

    tagger_info.stw_1_energy = 0;
    tagger_info.stw_1_dis = 0;
    tagger_info.stw_1_dQ_dx = 1;
    tagger_info.stw_1_flag_single_shower = 0;
    tagger_info.stw_1_n_pi0 = 0;
    tagger_info.stw_1_num_valid_tracks = 0;
    tagger_info.stw_1_flag = true;
    tagger_info.stw_flag = true;

    tagger_info.spt_flag_single_shower = 0;
    tagger_info.spt_energy = 0;
    tagger_info.spt_shower_main_length = 0;
    tagger_info.spt_shower_total_length = 0;
    tagger_info.spt_angle_beam = 0;
    tagger_info.spt_angle_vertical = 0;
    tagger_info.spt_max_dQ_dx = 1;
    tagger_info.spt_angle_beam_1 = 0;
    tagger_info.spt_angle_drift = 0;
    tagger_info.spt_angle_drift_1 = 0;
    tagger_info.spt_num_valid_tracks = 0;
    tagger_info.spt_n_vtx_segs = 0;
    tagger_info.spt_max_length = 0;
    tagger_info.spt_flag = true;

    tagger_info.mgo_energy = 0;
    tagger_info.mgo_max_energy = 0;
    tagger_info.mgo_total_energy = 0;
    tagger_info.mgo_n_showers = 0;
    tagger_info.mgo_max_energy_1 = 0;
    tagger_info.mgo_max_energy_2 = 0;
    tagger_info.mgo_total_other_energy = 0;
    tagger_info.mgo_n_total_showers = 0;
    tagger_info.mgo_total_other_energy_1 = 0;
    tagger_info.mgo_flag = true;

    tagger_info.mgt_flag_single_shower = 0;
    tagger_info.mgt_max_energy = 0;
    tagger_info.mgt_energy = 0;
    tagger_info.mgt_total_other_energy = 0;
    tagger_info.mgt_max_energy_1 = 0;
    tagger_info.mgt_e_indirect_max_energy = 0;
    tagger_info.mgt_e_direct_max_energy = 0;
    tagger_info.mgt_n_direct_showers = 0;
    tagger_info.mgt_e_direct_total_energy = 0;
    tagger_info.mgt_e_indirect_total_energy = 0;
    tagger_info.mgt_flag_indirect_max_pio = 0;
    tagger_info.mgt_flag = true;

    tagger_info.sig_flag = true;

    tagger_info.tro_3_stem_length = 0;
    tagger_info.tro_3_n_muon_segs = 0;
    tagger_info.tro_3_energy = 0;
    tagger_info.tro_3_flag = true;
    tagger_info.tro_flag = true;

    // cosmic tagger
    tagger_info.cosmict_flag_1 = false;
    tagger_info.cosmict_flag_2 = false;
    tagger_info.cosmict_flag_3 = false;
    tagger_info.cosmict_flag_4 = false;
    tagger_info.cosmict_flag_5 = false;
    tagger_info.cosmict_flag_6 = false;
    tagger_info.cosmict_flag_7 = false;
    tagger_info.cosmict_flag_8 = false;
    tagger_info.cosmict_flag_9 = false;
    tagger_info.cosmict_flag = false;

    // single muon
    tagger_info.cosmict_2_filled = 0;
    tagger_info.cosmict_2_particle_type = 0;
    tagger_info.cosmict_2_n_muon_tracks = 0;
    tagger_info.cosmict_2_total_shower_length = 0;
    tagger_info.cosmict_2_flag_inside = 1;
    tagger_info.cosmict_2_angle_beam = 0;
    tagger_info.cosmict_2_flag_dir_weak = 0;
    tagger_info.cosmict_2_dQ_dx_end = 0;
    tagger_info.cosmict_2_dQ_dx_front = 0;
    tagger_info.cosmict_2_theta = 0;
    tagger_info.cosmict_2_phi = 0;
    tagger_info.cosmict_2_valid_tracks = 0;

    // single muon (long)
    tagger_info.cosmict_3_filled = 0;
    tagger_info.cosmict_3_flag_inside = 0;
    tagger_info.cosmict_3_angle_beam = 0;
    tagger_info.cosmict_3_flag_dir_weak = 0;
    tagger_info.cosmict_3_dQ_dx_front = 0;
    tagger_info.cosmict_3_dQ_dx_end = 0;
    tagger_info.cosmict_3_theta = 0;
    tagger_info.cosmict_3_phi = 0;
    tagger_info.cosmict_3_valid_tracks = 0;

    // kinematics muon
    tagger_info.cosmict_4_filled = 0;
    tagger_info.cosmict_4_flag_inside = 0;
    tagger_info.cosmict_4_angle_beam = 0;
    tagger_info.cosmict_4_connected_showers = 0;

    // kinematics muon (long)
    tagger_info.cosmict_5_filled = 0;
    tagger_info.cosmict_5_flag_inside = 0;
    tagger_info.cosmict_5_angle_beam = 0;
    tagger_info.cosmict_5_connected_showers = 0;

    // special
    tagger_info.cosmict_6_filled = 0;
    tagger_info.cosmict_6_flag_dir_weak = 0;
    tagger_info.cosmict_6_flag_inside = 1;
    tagger_info.cosmict_6_angle = 0;

    // muon + michel
    tagger_info.cosmict_7_filled = 0;
    tagger_info.cosmict_7_flag_sec = 0;
    tagger_info.cosmict_7_n_muon_tracks = 0;
    tagger_info.cosmict_7_total_shower_length = 0;
    tagger_info.cosmict_7_flag_inside = 1;
    tagger_info.cosmict_7_angle_beam = 0;
    tagger_info.cosmict_7_flag_dir_weak = 0;
    tagger_info.cosmict_7_dQ_dx_end = 0;
    tagger_info.cosmict_7_dQ_dx_front = 0;
    tagger_info.cosmict_7_theta = 0;
    tagger_info.cosmict_7_phi = 0;

    // muon + michel + special
    tagger_info.cosmict_8_filled = 0;
    tagger_info.cosmict_8_flag_out = 0;
    tagger_info.cosmict_8_muon_length = 0;
    tagger_info.cosmict_8_acc_length = 0;

    // numu tagger
    tagger_info.numu_cc_flag_3 = 0;
    tagger_info.numu_cc_3_particle_type = 0;
    tagger_info.numu_cc_3_max_length = 0;
    tagger_info.numu_cc_3_acc_track_length = 0;
    tagger_info.numu_cc_3_max_length_all = 0;
    tagger_info.numu_cc_3_max_muon_length = 0;
    tagger_info.numu_cc_3_n_daughter_tracks = 0;
    tagger_info.numu_cc_3_n_daughter_all = 0;

    tagger_info.numu_cc_flag = 0;

    // numu BDTs
    tagger_info.cosmict_2_4_score = 0;
    tagger_info.cosmict_3_5_score = 0;
    tagger_info.cosmict_6_score = 0;
    tagger_info.cosmict_7_score = 0;
    tagger_info.cosmict_8_score = 0;
    tagger_info.cosmict_10_score = 0;

    tagger_info.numu_1_score = 0;
    tagger_info.numu_2_score = 0;
    tagger_info.numu_3_score = 0;

    // total score, place holder for cosmict ...
    tagger_info.cosmict_score = 0;
    tagger_info.numu_score = 0;

    // nue BDTs
    tagger_info.mipid_score = 0;
    tagger_info.gap_score = 0;
    tagger_info.hol_lol_score = 0;
    tagger_info.cme_anc_score = 0;
    tagger_info.mgo_mgt_score = 0;
    tagger_info.br1_score = 0;
    tagger_info.br3_score = 0;
    tagger_info.br3_3_score = 0;
    tagger_info.br3_5_score = 0;
    tagger_info.br3_6_score = 0;
    tagger_info.stemdir_br2_score = 0;
    tagger_info.trimuon_score = 0;
    tagger_info.br4_tro_score = 0;
    tagger_info.mipquality_score = 0;
    tagger_info.pio_1_score = 0;
    tagger_info.pio_2_score = 0;
    tagger_info.stw_spt_score = 0;
    tagger_info.vis_1_score = 0;
    tagger_info.vis_2_score = 0;
    tagger_info.stw_2_score = 0;
    tagger_info.stw_3_score = 0;
    tagger_info.stw_4_score = 0;
    tagger_info.sig_1_score = 0;
    tagger_info.sig_2_score = 0;
    tagger_info.lol_1_score = 0;
    tagger_info.lol_2_score = 0;
    tagger_info.tro_1_score = 0;
    tagger_info.tro_2_score = 0;
    tagger_info.tro_4_score = 0;
    tagger_info.tro_5_score = 0;
    tagger_info.nue_score = 0;
    tagger_info.photon_flag = false;

    kine_pio_flag = 0;
    kine_pio_mass = 0;
    kine_pio_vtx_dis = 1000 * units::cm;  // 10 m

    kine_pio_energy_1 = 0;
    kine_pio_theta_1 = 0;
    kine_pio_phi_1 = 0;
    kine_pio_dis_1 = 0;

    kine_pio_energy_2 = 0;
    kine_pio_theta_2 = 0;
    kine_pio_phi_2 = 0;
    kine_pio_dis_2 = 0;

    kine_pio_angle = 0;
}
