#include "TMatrixDEigen.h"

std::pair<WCP::Point, TVector3> WCPPID::NeutrinoID::calc_PCA_main_axis(WCP::PointVector &points)
{
    Point center(0, 0, 0);
    int nsum = 0;
    for (size_t i = 0; i != points.size(); i++) {
        center.x += points.at(i).x;
        center.y += points.at(i).y;
        center.z += points.at(i).z;
        nsum++;
    }

    TVector3 PCA_main_axis(0, 0, 0);

    if (nsum >= 3) {
        center.x /= nsum;
        center.y /= nsum;
        center.z /= nsum;
    }
    else {
        center.x = 0;
        center.y = 0;
        center.z = 0;
        return std::make_pair(center, PCA_main_axis);
    }

    TMatrixD cov_matrix(3, 3);
    for (int i = 0; i != 3; i++) {
        for (int j = i; j != 3; j++) {
            cov_matrix(i, j) = 0;
            PointVector &ps = points;
            for (int k = 0; k != ps.size(); k++) {
                if (i == 0 && j == 0) {
                    cov_matrix(i, j) += (ps.at(k).x - center.x) * (ps.at(k).x - center.x);
                }
                else if (i == 0 && j == 1) {
                    cov_matrix(i, j) += (ps.at(k).x - center.x) * (ps.at(k).y - center.y);
                }
                else if (i == 0 && j == 2) {
                    cov_matrix(i, j) += (ps.at(k).x - center.x) * (ps.at(k).z - center.z);
                }
                else if (i == 1 && j == 1) {
                    cov_matrix(i, j) += (ps.at(k).y - center.y) * (ps.at(k).y - center.y);
                }
                else if (i == 1 && j == 2) {
                    cov_matrix(i, j) += (ps.at(k).y - center.y) * (ps.at(k).z - center.z);
                }
                else if (i == 2 && j == 2) {
                    cov_matrix(i, j) += (ps.at(k).z - center.z) * (ps.at(k).z - center.z);
                }
            }
        }
    }
    cov_matrix(1, 0) = cov_matrix(0, 1);
    cov_matrix(2, 0) = cov_matrix(0, 2);
    cov_matrix(2, 1) = cov_matrix(1, 2);

    TMatrixDEigen eigen(cov_matrix);
    // TMatrixD eigen_values = eigen.GetEigenValues();
    TMatrixD eigen_vectors = eigen.GetEigenVectors();

    // PCA_values[0] = eigen_values(0,0) ;
    // PCA_values[1] = eigen_values(1,1) ;
    // PCA_values[2] = eigen_values(2,2) ;
    int i = 0;
    PCA_main_axis.SetXYZ(eigen_vectors(0, i) / sqrt(eigen_vectors(0, i) * eigen_vectors(0, i) +
                                                    eigen_vectors(1, i) * eigen_vectors(1, i) +
                                                    eigen_vectors(2, i) * eigen_vectors(2, i)),
                         eigen_vectors(1, i) / sqrt(eigen_vectors(0, i) * eigen_vectors(0, i) +
                                                    eigen_vectors(1, i) * eigen_vectors(1, i) +
                                                    eigen_vectors(2, i) * eigen_vectors(2, i)),
                         eigen_vectors(2, i) / sqrt(eigen_vectors(0, i) * eigen_vectors(0, i) +
                                                    eigen_vectors(1, i) * eigen_vectors(1, i) +
                                                    eigen_vectors(2, i) * eigen_vectors(2, i)));
    PCA_main_axis = PCA_main_axis.Unit();

    return std::make_pair(center, PCA_main_axis);
}

bool WCPPID::NeutrinoID::find_proto_vertex(WCPPID::PR3DCluster *temp_cluster, bool flag_break_track,
                                           int nrounds_find_other_tracks, bool flag_back_search)
{
    if (temp_cluster->get_point_cloud_steiner() == 0) return false;
    if (temp_cluster->get_point_cloud_steiner()->get_num_points() < 2) return false;

    WCPPID::ProtoSegment *sg1 = init_first_segment(temp_cluster, flag_back_search);

    if (sg1 == 0) return false;

    //  std::cout << "haha1 " << std::endl;

    if (temp_cluster == main_cluster) main_cluster_initial_pair_vertices = find_vertices(sg1);

    if (sg1->get_wcpt_vec().size() > 1) {
        // break tracks ...
        if (flag_break_track) {
            std::vector<WCPPID::ProtoSegment *> remaining_segments;
            remaining_segments.push_back(sg1);
            break_segments(remaining_segments, temp_cluster);

            //      if (flag_check_end_segments)	check_end_segments(temp_cluster);
            // if a straight length is better for a segment ...
            examine_structure(temp_cluster);
        }
        else {
            temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                            flash_time * units::microsecond, true, true, true);
        }

        /* for (auto it = map_vertex_segments.begin(); it!=map_vertex_segments.end(); it++){ */
        /*   WCPPID::ProtoVertex *vtx = it->first; */
        /*   if (vtx->get_cluster_id() == 50){ */
        /* 	std::cout << vtx->get_id() << " " << vtx->get_fit_pt() << " " << vtx->get_wcpt().x << " " <<
         * vtx->get_wcpt().y << " " << vtx->get_wcpt().z << std::endl; */
        /*   } */
        /* } */

        // std::cout << "haha2 " << std::endl;

        // find other segments ...
        for (size_t i = 0; i != nrounds_find_other_tracks; i++) {
            find_other_segments(temp_cluster, flag_break_track);
        }

        if (temp_cluster == main_cluster) {
            // merge two tracks if their angles are consistent
            if (examine_structure_3(temp_cluster))
                temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                global_wc_map, flash_time * units::microsecond, true, true, true);
        }

        // examine the vertices ...
        examine_vertices(temp_cluster);

        // examine partial identical segments
        examine_partial_identical_segments(temp_cluster);

        // examine the two initial points ...
        if (temp_cluster == main_cluster && main_cluster_initial_pair_vertices.first != 0) examine_vertices_3();

        temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                        flash_time * units::microsecond, true, true, true);

        return true;
    }

    return false;

    // for (auto it = map_segment_vertices.begin(); it!=map_segment_vertices.end(); it++){
    //   WCPPID::ProtoSegment *sg = it->first;
    //   std::cout << sg->get_id() << " " << sg->get_point_vec().size() << " " << sg->get_point_vec().front() << " " <<
    //   sg->get_point_vec().back() << std::endl; for (auto it1 = it->second.begin(); it1!=it->second.end(); it1++){
    //     std::cout << (*it1)->get_id() << " " << (*it1) << std::endl;
    //   }
    // }
    // for (auto it = map_vertex_segments.begin(); it!=map_vertex_segments.end(); it++){
    //   std::cout << (it->first)->get_id() << std::endl;
    //   for (auto it1 = it->second.begin(); it1!=it->second.end(); it1++){
    //     std::cout << (*it1)->get_id() << " " << (*it1) << std::endl;
    //   }
    // }

    //  temp_cluster->set_fit_parameters(map_vertex_segments, map_segment_vertices);
    // practice other components ...
}

void WCPPID::NeutrinoID::examine_partial_identical_segments(WCPPID::PR3DCluster *temp_cluster)
{
    bool flag_continue = true;
    while (flag_continue) {
        flag_continue = false;
        for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
            WCPPID::ProtoVertex *vtx = it->first;
            if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            if (it->second.size() <= 2) continue;

            WCPPID::ProtoSegment *max_sg1 = 0;
            WCPPID::ProtoSegment *max_sg2 = 0;
            double max_dis = 0;
            Point max_point;

            for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++) {
                WCPPID::ProtoSegment *sg1 = *it1;

                PointVector &pts_1 = sg1->get_point_vec();
                PointVector test_pts;
                if (sg1->get_wcpt_vec().front().index == vtx->get_wcpt().index) {
                    test_pts = pts_1;
                }
                else {
                    for (int i = int(pts_1.size()) - 1; i >= 0; i--) {
                        test_pts.push_back(pts_1.at(i));
                    }
                }

                for (auto it2 = it1; it2 != it->second.end(); it2++) {
                    WCPPID::ProtoSegment *sg2 = *it2;
                    if (sg1 == sg2) continue;
                    for (size_t i = 0; i != test_pts.size(); i++) {
                        if (sg2->get_closest_point(test_pts.at(i)).first < 0.3 * units::cm) {
                            double dis = sqrt(pow(test_pts.at(i).x - vtx->get_fit_pt().x, 2) +
                                              pow(test_pts.at(i).y - vtx->get_fit_pt().y, 2) +
                                              pow(test_pts.at(i).z - vtx->get_fit_pt().z, 2));
                            if (dis > max_dis) {
                                max_dis = dis;
                                max_point = test_pts.at(i);
                                max_sg1 = sg1;
                                max_sg2 = sg2;
                            }
                        }
                        else {
                            break;
                        }
                    }

                }  // loop over segment
            }      // loop over segment

            if (max_dis > 5 * units::cm) {  // start to adjust ...
                WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
                // check to see if a vertex is close to this one ...
                double min_dis = 1e9;
                WCPPID::ProtoVertex *min_vertex = 0;
                for (auto it1 = map_vertex_segments.begin(); it1 != map_vertex_segments.end(); it1++) {
                    WCPPID::ProtoVertex *vtx1 = it1->first;
                    if (vtx1->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
                    double dis =
                        sqrt(pow(max_point.x - vtx1->get_fit_pt().x, 2) + pow(max_point.y - vtx1->get_fit_pt().y, 2) +
                             pow(max_point.z - vtx1->get_fit_pt().z, 2));
                    if (dis < min_dis) {
                        min_dis = dis;
                        min_vertex = vtx1;
                    }
                }

                if (min_dis < 0.3 * units::cm) {  // merge to this vertex ...
                    WCPPID::ProtoSegment *good_segment = 0;
                    for (auto it1 = map_segment_vertices.begin(); it1 != map_segment_vertices.end(); it1++) {
                        WCPPID::ProtoSegment *tmp_segment = it1->first;
                        if (tmp_segment->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
                        if (tmp_segment->get_wcpt_vec().front().index == min_vertex->get_wcpt().index &&
                                tmp_segment->get_wcpt_vec().back().index == vtx->get_wcpt().index ||
                            tmp_segment->get_wcpt_vec().front().index == vtx->get_wcpt().index &&
                                tmp_segment->get_wcpt_vec().back().index == min_vertex->get_wcpt().index) {
                            good_segment = tmp_segment;
                            break;
                        }
                    }
                    //	  std::cout << max_sg1 << " " << max_sg2 << " " << good_segment << " " << max_sg1->get_id() << "
                    //" << max_sg2->get_id() << " " << good_segment->get_id() << std::endl;

                    temp_cluster->dijkstra_shortest_paths(min_vertex->get_wcpt(), 2);
                    if (good_segment == 0) {
                        temp_cluster->cal_shortest_path(vtx->get_wcpt(), 2);
                        WCPPID::ProtoSegment *sg3 = new WCPPID::ProtoSegment(
                            acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
                        acc_segment_id++;
                        add_proto_connection(min_vertex, sg3, temp_cluster);
                        add_proto_connection(vtx, sg3, temp_cluster);
                    }
                    if (max_sg1 != good_segment) {
                        WCPPID::ProtoVertex *tmp_vtx = find_other_vertex(max_sg1, vtx);
                        if (tmp_vtx != min_vertex) {
                            temp_cluster->cal_shortest_path(tmp_vtx->get_wcpt(), 2);
                            std::vector<WCP::WCPointCloud<double>::WCPoint> &wcps = max_sg1->get_wcpt_vec();
                            wcps.clear();
                            wcps.reserve(temp_cluster->get_path_wcps().size());
                            std::copy(std::begin(temp_cluster->get_path_wcps()),
                                      std::end(temp_cluster->get_path_wcps()), std::back_inserter(wcps));
                            del_proto_connection(vtx, max_sg1);
                            add_proto_connection(min_vertex, max_sg1, temp_cluster);
                        }
                        else {
                            del_proto_segment(max_sg1);
                        }
                    }
                    if (max_sg2 != good_segment) {
                        WCPPID::ProtoVertex *tmp_vtx = find_other_vertex(max_sg2, vtx);
                        if (tmp_vtx != min_vertex) {
                            temp_cluster->cal_shortest_path(tmp_vtx->get_wcpt(), 2);
                            std::vector<WCP::WCPointCloud<double>::WCPoint> &wcps = max_sg2->get_wcpt_vec();
                            wcps.clear();
                            wcps.reserve(temp_cluster->get_path_wcps().size());
                            std::copy(std::begin(temp_cluster->get_path_wcps()),
                                      std::end(temp_cluster->get_path_wcps()), std::back_inserter(wcps));
                            // std::cout << map_segment_vertices[max_sg2].size() << " " << vtx->get_id() << " " <<
                            // tmp_vtx->get_id() << " " << min_vertex->get_id() << std::endl;
                            del_proto_connection(vtx, max_sg2);
                            add_proto_connection(min_vertex, max_sg2, temp_cluster);
                            //	    std::cout << map_segment_vertices[max_sg2].size() << std::endl;
                        }
                        else {
                            del_proto_segment(max_sg2);
                        }
                    }
                    // fit everything ...
                    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                    global_wc_map, flash_time * units::microsecond, true, true, true);
                }
                else {
                    // create new stuff ...
                    WCP::WCPointCloud<double>::WCPoint &vtx_new_wcp = pcloud->get_closest_wcpoint(max_point);
                    // create a new vertices
                    WCPPID::ProtoVertex *vtx2 =
                        new WCPPID::ProtoVertex(acc_vertex_id, vtx_new_wcp, temp_cluster->get_cluster_id());
                    acc_vertex_id++;
                    // create a new segment
                    temp_cluster->dijkstra_shortest_paths(vtx_new_wcp, 2);
                    temp_cluster->cal_shortest_path(vtx->get_wcpt(), 2);
                    WCPPID::ProtoSegment *sg3 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(),
                                                                         temp_cluster->get_cluster_id());
                    acc_segment_id++;
                    // establish the connection between new segments and vertices
                    add_proto_connection(vtx2, sg3, temp_cluster);
                    add_proto_connection(vtx, sg3, temp_cluster);
                    // alter two segements's path ...
                    {
                        WCPPID::ProtoVertex *tmp_vtx = find_other_vertex(max_sg1, vtx);
                        temp_cluster->cal_shortest_path(tmp_vtx->get_wcpt(), 2);
                        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcps = max_sg1->get_wcpt_vec();
                        wcps.clear();
                        wcps.reserve(temp_cluster->get_path_wcps().size());
                        std::copy(std::begin(temp_cluster->get_path_wcps()), std::end(temp_cluster->get_path_wcps()),
                                  std::back_inserter(wcps));
                    }
                    {
                        WCPPID::ProtoVertex *tmp_vtx = find_other_vertex(max_sg2, vtx);
                        temp_cluster->cal_shortest_path(tmp_vtx->get_wcpt(), 2);
                        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcps = max_sg2->get_wcpt_vec();
                        wcps.clear();
                        wcps.reserve(temp_cluster->get_path_wcps().size());
                        std::copy(std::begin(temp_cluster->get_path_wcps()), std::end(temp_cluster->get_path_wcps()),
                                  std::back_inserter(wcps));
                    }
                    // disassociate the two segments to the original vertices
                    del_proto_connection(vtx, max_sg1);
                    del_proto_connection(vtx, max_sg2);
                    add_proto_connection(vtx2, max_sg1, temp_cluster);
                    add_proto_connection(vtx2, max_sg2, temp_cluster);
                    // fit everything ...
                    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                    global_wc_map, flash_time * units::microsecond, true, true, true);
                }
                flag_continue = true;
                // Now change the segment and vertex ...
            }
            if (flag_continue) break;
        }  // loop over vertices ... it
    }
}

void WCPPID::NeutrinoID::check_end_segments(WCPPID::PR3DCluster *temp_cluster)
{
    bool flag_check = true;
    while (flag_check) {
        flag_check = false;
        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            WCPPID::ProtoSegment *sg = it->first;
            std::pair<WCPPID::ProtoVertex *, WCPPID::ProtoVertex *> tmp_vtxs = find_vertices(sg);
            if (map_vertex_segments[tmp_vtxs.first].size() == 1 && map_vertex_segments[tmp_vtxs.second].size() > 1) {
                if (sg->get_length() < 5 * units::cm) {
                    del_proto_vertex(tmp_vtxs.first);
                    del_proto_segment(sg);
                    flag_check = true;
                    break;
                }
                //	std::cout << sg->get_length()/units::cm << " " << sg->get_medium_dQ_dx() << std::endl;
            }
            else if (map_vertex_segments[tmp_vtxs.first].size() > 1 &&
                     map_vertex_segments[tmp_vtxs.second].size() == 1) {
                //	std::cout << sg->get_length()/units::cm << " " << sg->get_medium_dQ_dx()<< std::endl;
                if (sg->get_length() < 5 * units::cm) {
                    del_proto_vertex(tmp_vtxs.second);
                    del_proto_segment(sg);
                    flag_check = true;
                    break;
                }
            }
        }
    }
}

void WCPPID::NeutrinoID::init_point_segment(WCPPID::PR3DCluster *temp_cluster)
{
    // do the first search of the trajectory ...
    std::pair<WCPointCloud<double>::WCPoint, WCPointCloud<double>::WCPoint> wcps =
        temp_cluster->get_two_boundary_wcps(1);
    // good for the first track
    temp_cluster->dijkstra_shortest_paths(wcps.first, 1);
    temp_cluster->cal_shortest_path(wcps.second, 1);
    WCPPID::ProtoVertex *v1 = 0;
    WCPPID::ProtoVertex *v2 = 0;
    WCPPID::ProtoSegment *sg1 = 0;

    if (temp_cluster->get_path_wcps().size() > 1) {
        v1 = new WCPPID::ProtoVertex(acc_vertex_id, wcps.first, temp_cluster->get_cluster_id());
        acc_vertex_id++;
        v2 = new WCPPID::ProtoVertex(acc_vertex_id, wcps.second, temp_cluster->get_cluster_id());
        acc_vertex_id++;
        sg1 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
        acc_segment_id++;
        add_proto_connection(v1, sg1, temp_cluster);
        add_proto_connection(v2, sg1, temp_cluster);

        temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                        flash_time * units::microsecond, true, true, true);
    }
}

WCPPID::ProtoSegment *WCPPID::NeutrinoID::init_first_segment(WCPPID::PR3DCluster *temp_cluster, bool flag_back_search)
{
    // do the first search of the trajectory ...
    std::pair<WCPointCloud<double>::WCPoint, WCPointCloud<double>::WCPoint> wcps =
        temp_cluster->get_two_boundary_wcps(2);

    if (temp_cluster == main_cluster) {
        // main cluster, start from the downstream point ...
        if (flag_back_search) {
            if (wcps.first.z < wcps.second.z) {
                auto wcp1 = wcps.first;
                auto wcp2 = wcps.second;
                wcps.first = wcp2;
                wcps.second = wcp1;
            }
        }
        else {
            if (wcps.first.z > wcps.second.z) {
                auto wcp1 = wcps.first;
                auto wcp2 = wcps.second;
                wcps.first = wcp2;
                wcps.second = wcp1;
            }
        }
    }
    else {
        Point tp1(wcps.first.x, wcps.first.y, wcps.first.z);
        Point tp2(wcps.second.x, wcps.second.y, wcps.second.z);
        double dis1 = main_cluster->get_point_cloud_steiner()->get_closest_dis(tp1);
        double dis2 = main_cluster->get_point_cloud_steiner()->get_closest_dis(tp2);
        if (dis2 < dis1) {
            auto wcp1 = wcps.first;
            auto wcp2 = wcps.second;
            wcps.first = wcp2;
            wcps.second = wcp1;
        }
    }

    // good for the first track
    temp_cluster->dijkstra_shortest_paths(wcps.first, 2);
    temp_cluster->cal_shortest_path(wcps.second, 2);

    //  std::cout << temp_cluster->get_cluster_id() << " " << wcps.first.index << " " << wcps.first.x << " " <<
    //  wcps.first.y << " " << wcps.first.z << " " << wcps.first.index_u << " " << wcps.first.index_v << " " <<
    //  wcps.first.index_w << " " << wcps.second.index << " " << wcps.second.x << " " << wcps.second.y << " " <<
    //  wcps.second.z << " " << wcps.second.index_u << " " << wcps.second.index_v << " " << wcps.second.index_w << " "
    //  << std::endl;
    /* { */
    /*   Point test_p(wcps.first.x, wcps.first.y, wcps.first.z); */
    /*   std::vector<int> results = ct_point_cloud->convert_3Dpoint_time_ch(test_p); */
    /*   std::cout << results.at(0) << " " << results.at(1) << " " << results.at(2) << " " << results.at(3) <<
     * std::endl; */
    /* } */
    // std::cout << temp_cluster->get_path_wcps().front().index << " " << temp_cluster->get_path_wcps().back().index <<
    // std::endl;

    WCPPID::ProtoVertex *v1 = 0;
    WCPPID::ProtoVertex *v2 = 0;
    WCPPID::ProtoSegment *sg1 = 0;

    if (temp_cluster->get_path_wcps().size() > 1) {
        v1 = new WCPPID::ProtoVertex(acc_vertex_id, wcps.first, temp_cluster->get_cluster_id());
        acc_vertex_id++;
        v2 = new WCPPID::ProtoVertex(acc_vertex_id, wcps.second, temp_cluster->get_cluster_id());
        acc_vertex_id++;
        sg1 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
        acc_segment_id++;

        temp_cluster->collect_charge_trajectory(*ct_point_cloud);
        // fit dQ/dx and everything ...

        // std::cout << "haha " << std::endl;

        temp_cluster->do_tracking(*ct_point_cloud, global_wc_map, flash_time * units::microsecond, true, true);

        //    std::cout << "haha1 " << std::endl;

        if (temp_cluster->get_fine_tracking_path().size() <= 1) {
            delete v1;
            delete v2;
            delete sg1;
            v1 = 0;
            v2 = 0;
            sg1 = 0;
        }
        else {
            v1->set_fit(temp_cluster->get_fine_tracking_path().front(), temp_cluster->get_dQ().front(),
                        temp_cluster->get_dx().front(), temp_cluster->get_pu().front(), temp_cluster->get_pv().front(),
                        temp_cluster->get_pw().front(), temp_cluster->get_pt().front(),
                        temp_cluster->get_reduced_chi2().front());
            v2->set_fit(temp_cluster->get_fine_tracking_path().back(), temp_cluster->get_dQ().back(),
                        temp_cluster->get_dx().back(), temp_cluster->get_pu().back(), temp_cluster->get_pv().back(),
                        temp_cluster->get_pw().back(), temp_cluster->get_pt().back(),
                        temp_cluster->get_reduced_chi2().back());
            sg1->set_fit_vec(temp_cluster->get_fine_tracking_path(), temp_cluster->get_dQ(), temp_cluster->get_dx(),
                             temp_cluster->get_pu(), temp_cluster->get_pv(), temp_cluster->get_pw(),
                             temp_cluster->get_pt(), temp_cluster->get_reduced_chi2());
            add_proto_connection(v1, sg1, temp_cluster);
            add_proto_connection(v2, sg1, temp_cluster);
        }
        //    std::cout << temp_cluster->get_fine_tracking_path().size() << " " << temp_cluster->get_dx().size() << " "
        //    << temp_cluster->get_fine_tracking_path().front() << " " << temp_cluster->get_fine_tracking_path().back()
        //    << " " << v1->get_pw() << " " << wcps.first.index_w << std::endl;
    }
    // else{
    //  v1 = new WCPPID::ProtoVertex(acc_vertex_id, wcps.first, temp_cluster->get_cluster_id()); acc_vertex_id++;
    //  sg1 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
    //  acc_segment_id++;
    //   add_proto_connection(v1,sg1,temp_cluster);
    //}

    // std::cout << proto_vertices.size() << " " << map_vertex_segments.size() << " " <<
    // map_segment_vertices[sg1].size() << " " << map_cluster_vertices[main_cluster].size() << " " <<
    // map_vertex_cluster.size()  << std::endl;
    //  del_proto_vertex(v1); // del_proto_vertex(v1);
    // std::cout << proto_vertices.size() << " " << map_vertex_segments.size() << " " <<
    // map_segment_vertices[sg1].size() << " " << map_cluster_vertices[main_cluster].size() << " " <<
    // map_vertex_cluster.size()  << std::endl; std::cout << proto_segments.size() << " " << map_segment_vertices.size()
    // << " " << map_vertex_segments[v1].size() << " " << map_cluster_segments[main_cluster].size() << " " <<
    // map_segment_cluster.size() << std::endl; del_proto_segment(sg1); // del_proto_segment(sg1); std::cout <<
    // proto_segments.size() << " " << map_segment_vertices.size() << " " << map_vertex_segments[v1].size() << " " <<
    // map_cluster_segments[main_cluster].size() << " " << map_segment_cluster.size() << std::endl;

    // temporary fit ...

    // finish the temporary fit ...

    //  std::cout << temp_cluster->get_fine_tracking_path().size() << " " <<
    //  temp_cluster->get_fine_tracking_path().at(40) << std::endl;

    // sg1->print_dis();
    // std::cout << v1->get_fit_init_dis()/units::cm << " " << v2->get_fit_init_dis()/units::cm << std::endl;
    return sg1;
}

void WCPPID::NeutrinoID::break_segments(std::vector<WCPPID::ProtoSegment *> &remaining_segments,
                                        WCPPID::PR3DCluster *temp_cluster, float dis_cut)
{
    bool flag_print = false;

    int count = 0;
    std::set<int> saved_break_wcp_indices;

    while (remaining_segments.size() != 0 && count < 2) {
        WCPPID::ProtoSegment *curr_sg = remaining_segments.back();
        remaining_segments.pop_back();
        if (map_segment_vertices.find(curr_sg) == map_segment_vertices.end()) continue;

        WCPPID::ProtoVertex *start_v = 0, *end_v = 0;
        if ((*map_segment_vertices[curr_sg].begin())->get_wcpt().index == curr_sg->get_wcpt_vec().front().index &&
            (*map_segment_vertices[curr_sg].rbegin())->get_wcpt().index == curr_sg->get_wcpt_vec().back().index) {
            start_v = (*map_segment_vertices[curr_sg].begin());
            end_v = (*map_segment_vertices[curr_sg].rbegin());
        }
        else if ((*map_segment_vertices[curr_sg].rbegin())->get_wcpt().index == curr_sg->get_wcpt_vec().front().index &&
                 (*map_segment_vertices[curr_sg].begin())->get_wcpt().index == curr_sg->get_wcpt_vec().back().index) {
            start_v = (*map_segment_vertices[curr_sg].rbegin());
            end_v = (*map_segment_vertices[curr_sg].begin());
        }
        /* for (auto it = map_segment_vertices[curr_sg].begin(); it!=map_segment_vertices[curr_sg].end(); it++){ */
        /*   if ((*it)->get_wcpt().index == curr_sg->get_wcpt_vec().front().index) start_v = *it; */
        /*   if ((*it)->get_wcpt().index == curr_sg->get_wcpt_vec().back().index) end_v = *it; */
        /* } */

        if (start_v == 0 || end_v == 0) {
            std::cout << "Error in finding vertices for a segment"
                      << " " << start_v << " " << end_v << " " << curr_sg->get_id() << " "
                      << map_segment_vertices[curr_sg].size() << std::endl;
            // std::cout << "Vertex: " << start_v->get_wcpt().index << " " << end_v->get_wcpt().index << std::endl;
        }

        // initialize the start points
        WCP::WCPointCloud<double>::WCPoint break_wcp = start_v->get_wcpt();
        Point test_start_p = curr_sg->get_point_vec().front();

        if (dis_cut > 0) {
            for (auto it = curr_sg->get_point_vec().begin(); it != curr_sg->get_point_vec().end(); it++) {
                double dis = sqrt(pow((*it).x - curr_sg->get_point_vec().front().x, 2) +
                                  pow((*it).y - curr_sg->get_point_vec().front().y, 2) +
                                  pow((*it).z - curr_sg->get_point_vec().front().z, 2));
                if (dis > dis_cut) {
                    test_start_p = *it;
                    break;
                }
            }
        }

        while (sqrt(pow(start_v->get_wcpt().x - break_wcp.x, 2) + pow(start_v->get_wcpt().y - break_wcp.y, 2) +
                    pow(start_v->get_wcpt().z - break_wcp.z, 2)) <= 1 * units::cm &&
               sqrt(pow(end_v->get_wcpt().x - break_wcp.x, 2) + pow(end_v->get_wcpt().y - break_wcp.y, 2) +
                    pow(end_v->get_wcpt().z - break_wcp.z, 2)) > 1 * units::cm) {
            std::tuple<Point, TVector3, TVector3, bool> kink_tuple = curr_sg->search_kink(test_start_p);
            if (std::get<1>(kink_tuple).Mag() != 0) {
                // find the extreme point ... PR3DCluster function
                break_wcp = temp_cluster->proto_extend_point(std::get<0>(kink_tuple), std::get<1>(kink_tuple),
                                                             std::get<2>(kink_tuple), std::get<3>(kink_tuple));
                //	std::cout << "Break point: " << remaining_segments.size() << " " << std::get<0>(kink_tuple) << "
                //" << std::get<1>(kink_tuple).Mag() << " " << std::get<3>(kink_tuple) << " " << break_wcp.x/units::cm
                //<< " " << break_wcp.y/units::cm << " " << break_wcp.z/units::cm << " " << break_wcp.index << " " <<
                //sqrt(pow(start_v->get_wcpt().x - break_wcp.x,2) + pow(start_v->get_wcpt().y - break_wcp.y,2) +
                //pow(start_v->get_wcpt().z - break_wcp.z,2))/units::cm << " " << sqrt(pow(end_v->get_wcpt().x -
                //break_wcp.x,2) +  pow(end_v->get_wcpt().y - break_wcp.y,2) +   pow(end_v->get_wcpt().z -
                //break_wcp.z,2))/units::cm << std::endl;
                if (saved_break_wcp_indices.find(break_wcp.index) != saved_break_wcp_indices.end()) {
                    test_start_p = std::get<0>(kink_tuple);
                    kink_tuple = curr_sg->search_kink(test_start_p);
                    break_wcp = temp_cluster->proto_extend_point(std::get<0>(kink_tuple), std::get<1>(kink_tuple),
                                                                 std::get<2>(kink_tuple), std::get<3>(kink_tuple));
                }
                else {
                    saved_break_wcp_indices.insert(break_wcp.index);
                }

                if (sqrt(pow(start_v->get_wcpt().x - break_wcp.x, 2) + pow(start_v->get_wcpt().y - break_wcp.y, 2) +
                         pow(start_v->get_wcpt().z - break_wcp.z, 2)) <= 1 * units::cm &&
                    sqrt(pow(end_v->get_wcpt().x - break_wcp.x, 2) + pow(end_v->get_wcpt().y - break_wcp.y, 2) +
                         pow(end_v->get_wcpt().z - break_wcp.z, 2)) > 1 * units::cm)
                    test_start_p = std::get<0>(kink_tuple);
            }
            else {
                break;
            }
        }

        if (sqrt(pow(start_v->get_wcpt().x - break_wcp.x, 2) + pow(start_v->get_wcpt().y - break_wcp.y, 2) +
                 pow(start_v->get_wcpt().z - break_wcp.z, 2)) > 1 * units::cm) {
            // find the new path ... PR3DCluster function
            // break into two tracks and adding a ProtoVertex in this function ...
            std::list<WCP::WCPointCloud<double>::WCPoint> wcps_list1;
            std::list<WCP::WCPointCloud<double>::WCPoint> wcps_list2;

            bool flag_break;
            if (sqrt(pow(end_v->get_wcpt().x - break_wcp.x, 2) + pow(end_v->get_wcpt().y - break_wcp.y, 2) +
                     pow(end_v->get_wcpt().z - break_wcp.z, 2)) < 1 * units::cm &&
                map_vertex_segments[end_v].size() == 1) {
                flag_break = temp_cluster->proto_break_tracks(start_v->get_wcpt(), break_wcp, end_v->get_wcpt(),
                                                              wcps_list1, wcps_list2, true);
            }
            else {
                flag_break = temp_cluster->proto_break_tracks(start_v->get_wcpt(), break_wcp, end_v->get_wcpt(),
                                                              wcps_list1, wcps_list2);
            }

            //  std::cout << break_wcp.index_u << " " << break_wcp.index_v << " " << break_wcp.index_w << " " <<
            //  break_wcp.mcell->GetTimeSlice() << std::endl;

            if (flag_break) {
                std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " breaking point: " << flag_break << " "
                          << wcps_list1.front().index << " " << wcps_list1.back().index << " "
                          << wcps_list2.front().index << " " << wcps_list2.back().index << std::endl;
                TVector3 tv1(end_v->get_wcpt().x - start_v->get_wcpt().x, end_v->get_wcpt().y - start_v->get_wcpt().y,
                             end_v->get_wcpt().z - start_v->get_wcpt().z);
                TVector3 tv2(end_v->get_wcpt().x - break_wcp.x, end_v->get_wcpt().y - break_wcp.y,
                             end_v->get_wcpt().z - break_wcp.z);

                double min_dis = 1e9;
                for (auto it5 = wcps_list1.begin(); it5 != wcps_list1.end(); it5++) {
                    double dis = sqrt(pow((*it5).x - end_v->get_wcpt().x, 2) + pow((*it5).y - end_v->get_wcpt().y, 2) +
                                      pow((*it5).z - end_v->get_wcpt().z, 2));
                    if (dis < min_dis) min_dis = dis;
                }
                //	std::cout << min_dis/units::cm << " " << tv1.Angle(tv2)/3.1415926*180. << std::endl;
                if (min_dis / units::cm < 1.5 && tv1.Angle(tv2) / 3.1415926 * 180. > 120) {
                    if (map_vertex_segments[end_v].size() == 1) {
                        WCPPID::ProtoVertex *v3 =
                            new WCPPID::ProtoVertex(acc_vertex_id, break_wcp, temp_cluster->get_cluster_id());
                        acc_vertex_id++;
                        WCPPID::ProtoSegment *sg2 =
                            new WCPPID::ProtoSegment(acc_segment_id, wcps_list1, temp_cluster->get_cluster_id());
                        acc_segment_id++;
                        add_proto_connection(start_v, sg2, temp_cluster);
                        add_proto_connection(v3, sg2, temp_cluster);
                        del_proto_vertex(end_v);
                        del_proto_segment(curr_sg);
                        flag_print = true;
                        // std::cout << sg2->get_id() << std::endl;
                        // clean_up_maps_vertices_segments(temp_cluster);
                        // fit dQ/dx here, do not exclude others
                        temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                        global_wc_map, flash_time * units::microsecond, true, true,
                                                        false);
                    }
                }
                else {
                    //	std::cout << tv1.Angle(tv2)/3.1415926*180. << " " << min_dis/units::cm << std::endl;

                    WCPPID::ProtoVertex *v3 =
                        new WCPPID::ProtoVertex(acc_vertex_id, break_wcp, temp_cluster->get_cluster_id());
                    acc_vertex_id++;
                    WCPPID::ProtoSegment *sg2 =
                        new WCPPID::ProtoSegment(acc_segment_id, wcps_list1, temp_cluster->get_cluster_id());
                    acc_segment_id++;
                    WCPPID::ProtoSegment *sg3 =
                        new WCPPID::ProtoSegment(acc_segment_id, wcps_list2, temp_cluster->get_cluster_id());
                    acc_segment_id++;

                    //	  std::cout <<"break " << curr_sg->get_id() << " " << sg2->get_id() << " " << sg3->get_id() <<
                    //std::endl;

                    add_proto_connection(start_v, sg2, temp_cluster);
                    add_proto_connection(v3, sg2, temp_cluster);
                    add_proto_connection(v3, sg3, temp_cluster);
                    add_proto_connection(end_v, sg3, temp_cluster);

                    del_proto_segment(curr_sg);
                    // delete curr_sg;

                    flag_print = true;
                    // fit dQ/dx here, do not exclude others
                    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                    global_wc_map, flash_time * units::microsecond, true, true, false);
                    remaining_segments.push_back(sg3);
                }
            } /* else if ((!flag_break) && sqrt(pow(end_v->get_wcpt().x - break_wcp.x,2) + pow(end_v->get_wcpt().y -
                 break_wcp.y,2) + pow(end_v->get_wcpt().z - break_wcp.z,2)) < 1*units::cm &&
                 map_vertex_segments[end_v].size()==1){ */
              /* 	//std::cout << "haah " << std::endl; */
              /* 	std::vector<WCP::WCPointCloud<double>::WCPoint >& wcps = curr_sg->get_wcpt_vec(); */
              /* 	end_v->set_wcpt(break_wcp); */

            /* 	WCP::WCPointCloud<double>::WCPoint  min_wcp = wcps.back(); */
            /* 	double min_dis = 1e9; */
            /* 	for (size_t i=0;i!=wcps.size(); i++){ */
            /* 	  double dis = sqrt(pow(break_wcp.x-wcps.at(i).x,2) + pow(break_wcp.y - wcps.at(i).y,2) +
             * pow(break_wcp.z - wcps.at(i).z,2)); */
            /* 	  if (dis < min_dis){ */
            /* 	    min_dis = dis; */
            /* 	    min_wcp = wcps.at(i); */
            /* 	  } */
            /* 	} */
            /* 	while(wcps.back().index != min_wcp.index){ */
            /* 	  wcps.pop_back(); */
            /* 	} */
            /* 	if (wcps.size()>1)  wcps.pop_back(); */
            /* 	wcps.push_back(break_wcp); */

            /* 	temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
             * global_wc_map, flash_time*units::microsecond, true, true, false);	 */
            /*   } */
        }
        //    std::cout << proto_vertices.size() << " " << map_vertex_segments.size() << " " <<
        //    map_segment_vertices[sg2].size() << " " << map_cluster_vertices[main_cluster].size() << " " <<
        //    map_vertex_cluster.size()  << std::endl;
        // std::cout << proto_segments.size() << " " << map_segment_vertices.size() << " " <<
        // map_vertex_segments[v3].size() << " " << map_cluster_segments[main_cluster].size() << " " <<
        // map_segment_cluster.size() << std::endl;
    }

    if (flag_print)
        std::cout << "Cluster: " << temp_cluster->get_cluster_id()
                  << " Break tracks  -- # of Vertices: " << map_vertex_segments.size()
                  << "; # of Segments: " << map_segment_vertices.size() << std::endl;
}

void WCPPID::NeutrinoID::find_other_segments(WCPPID::PR3DCluster *temp_cluster, bool flag_break_track,
                                             double search_range, double scaling_2d)
{
    const int N = temp_cluster->get_point_cloud_steiner()->get_num_points();
    std::vector<bool> &flag_tagged = temp_cluster->get_flag_tagged_steiner_graph();
    flag_tagged.resize(N, false);

    int num_tagged = 0;
    WCP::WCPointCloud<double> &cloud = temp_cluster->get_point_cloud_steiner()->get_cloud();
    for (size_t i = 0; i != N; i++) {
        Point p(cloud.pts[i].x, cloud.pts[i].y, cloud.pts[i].z);
        double min_dis_u = 1e9, min_dis_v = 1e9, min_dis_w = 1e9;
        double min_3d_dis = 1e9;
        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            WCPPID::ProtoSegment *sg1 = it->first;
            if (sg1->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            std::pair<double, WCP::Point> closest_dis_point = sg1->get_closest_point(p);
            std::tuple<double, double, double> closest_2d_dis = sg1->get_closest_2d_dis(p);
            if (closest_dis_point.first < min_3d_dis) min_3d_dis = closest_dis_point.first;
            if (closest_dis_point.first < search_range) {
                flag_tagged[i] = true;
                num_tagged++;
                break;
            }
            if (std::get<0>(closest_2d_dis) < min_dis_u) min_dis_u = std::get<0>(closest_2d_dis);
            if (std::get<1>(closest_2d_dis) < min_dis_v) min_dis_v = std::get<1>(closest_2d_dis);
            if (std::get<2>(closest_2d_dis) < min_dis_w) min_dis_w = std::get<2>(closest_2d_dis);
        }

        if (!flag_tagged[i]) {
            if ((min_dis_u < scaling_2d * search_range || ct_point_cloud->get_closest_dead_chs(p, 0)) &&
                (min_dis_v < scaling_2d * search_range || ct_point_cloud->get_closest_dead_chs(p, 1)) &&
                (min_dis_w < scaling_2d * search_range || ct_point_cloud->get_closest_dead_chs(p, 2)))
                flag_tagged[i] = true;
            // std::cout << min_dis_u/units::cm << " " << min_dis_v/units::cm << " " << min_dis_w/units::cm <<
            // std::endl;
        }

        //    if (cloud.pts[i].index_u< 820 && cloud.pts[i].index_u >800 && cloud.pts[i].index_w < 5525-4800 &&
        //    cloud.pts[i].index_w > 5505-4800 && p.x < 200*units::cm && p.x > 193*units::cm && min_dis_v <
        //    0.6*units::cm){
        // std::cout << p << " " << cloud.pts[i].index << " " << cloud.pts[i].index_u << " " <<
        // cloud.pts[i].index_v+2400 << " " << cloud.pts[i].index_w+4800 << " " << min_dis_u/units::cm << " " <<
        // min_dis_v/units::cm << " " << min_dis_w/units::cm << " " <<  min_3d_dis/units::cm << " " << flag_tagged[i] <<
        // std::endl;
        //}
    }

    // Now figure out the Terminal Graph ...
    std::vector<int> terminals;
    std::map<int, int> map_oindex_tindex;
    std::vector<bool> &flag_steiner_terminal = temp_cluster->get_flag_steiner_terminal();
    for (size_t i = 0; i != flag_steiner_terminal.size(); i++) {
        if (flag_steiner_terminal[i]) {
            map_oindex_tindex[i] = terminals.size();
            terminals.push_back(i);
        }
    }
    //  std::cout << N << " abc " << terminals.size() << std::endl;

    using Vertex = typename boost::graph_traits<WCPPID::MCUGraph>::vertex_descriptor;
    using Edge = typename boost::graph_traits<WCPPID::MCUGraph>::edge_descriptor;
    using Base = typename boost::property<edge_base_t, Edge>;
    using EdgeWeightMap = typename boost::property_map<WCPPID::MCUGraph, boost::edge_weight_t>::type;
    using Weight = typename boost::property_traits<EdgeWeightMap>::value_type;
    using WeightProperty = typename boost::property<boost::edge_weight_t, Weight, Base>;
    using TerminalGraph =
        boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, boost::no_property, WeightProperty>;
    using EdgeTerminal = typename boost::graph_traits<TerminalGraph>::edge_descriptor;

    WCPPID::MCUGraph *graph_steiner = temp_cluster->get_graph_steiner();
    EdgeWeightMap edge_weight = boost::choose_pmap(boost::get_param(boost::no_named_parameters(), boost::edge_weight),
                                                   *graph_steiner, boost::edge_weight);

    // distance array used in the dijkstra runs
    std::vector<Weight> distance(N);

    std::vector<Vertex> nearest_terminal(num_vertices(*graph_steiner));
    auto index = get(boost::vertex_index, *graph_steiner);
    auto nearest_terminal_map =
        boost::make_iterator_property_map(nearest_terminal.begin(), get(boost::vertex_index, *graph_steiner));
    for (auto terminal : terminals) {
        nearest_terminal_map[terminal] = terminal;
    }
    // compute voronoi diagram each vertex get nearest terminal and last edge on
    // path to nearest terminal
    auto distance_map = make_iterator_property_map(distance.begin(), index);
    std::vector<Edge> vpred(N);
    auto last_edge = boost::make_iterator_property_map(vpred.begin(), get(boost::vertex_index, *graph_steiner));
    boost::dijkstra_shortest_paths(*graph_steiner, terminals.begin(), terminals.end(), boost::dummy_property_map(),
                                   distance_map, edge_weight, index, paal::utils::less(), boost::closed_plus<Weight>(),
                                   std::numeric_limits<Weight>::max(), 0,
                                   boost::make_dijkstra_visitor(paal::detail::make_nearest_recorder(
                                       nearest_terminal_map, last_edge, boost::on_edge_relaxed{})));

    //  std::cout << "abc1 " << std::endl;
    // computing distances between terminals
    // creating terminal_graph
    TerminalGraph terminal_graph(N);
    std::map<std::pair<int, int>, std::pair<Weight, Edge> > map_saved_edge;

    for (auto w : boost::as_array(edges(*graph_steiner))) {
        auto const &nearest_to_source = nearest_terminal_map[source(w, *graph_steiner)];
        auto const &nearest_to_target = nearest_terminal_map[target(w, *graph_steiner)];
        if (nearest_to_source != nearest_to_target) {
            Weight temp_weight =
                distance[source(w, *graph_steiner)] + distance[target(w, *graph_steiner)] + edge_weight[w];
            if (map_saved_edge.find(std::make_pair(nearest_to_source, nearest_to_target)) != map_saved_edge.end()) {
                if (temp_weight < map_saved_edge[std::make_pair(nearest_to_source, nearest_to_target)].first)
                    map_saved_edge[std::make_pair(nearest_to_source, nearest_to_target)] =
                        std::make_pair(temp_weight, w);
            }
            else if (map_saved_edge.find(std::make_pair(nearest_to_target, nearest_to_source)) !=
                     map_saved_edge.end()) {
                if (temp_weight < map_saved_edge[std::make_pair(nearest_to_target, nearest_to_source)].first)
                    map_saved_edge[std::make_pair(nearest_to_target, nearest_to_source)] =
                        std::make_pair(temp_weight, w);
            }
            else {
                map_saved_edge[std::make_pair(nearest_to_source, nearest_to_target)] = std::make_pair(temp_weight, w);
            }
        }
    }

    std::vector<Edge> terminal_edge;
    for (auto it = map_saved_edge.begin(); it != map_saved_edge.end(); it++) {
        std::pair<Edge, bool> p = add_edge(it->first.first, it->first.second,
                                           WeightProperty(it->second.first, Base(it->second.second)), terminal_graph);
        //      terminal_edge.push_back(p.first);
    }
    // minimal spanning tree ...
    boost::kruskal_minimum_spanning_tree(terminal_graph, std::back_inserter(terminal_edge));

    // new Graph ...
    std::map<int, std::set<int> > map_connection;
    TerminalGraph terminal_graph_cluster(terminals.size());
    for (auto it = terminal_edge.begin(); it != terminal_edge.end(); it++) {
        if (flag_tagged[source(*it, terminal_graph)] == flag_tagged[target(*it, terminal_graph)]) {
            add_edge(map_oindex_tindex[source(*it, terminal_graph)], map_oindex_tindex[target(*it, terminal_graph)],
                     terminal_graph_cluster);
        }
        else {
            if (map_connection.find(source(*it, terminal_graph)) == map_connection.end()) {
                std::set<int> temp_results;
                temp_results.insert(target(*it, terminal_graph));
                map_connection[source(*it, terminal_graph)] = temp_results;
            }
            else {
                map_connection[source(*it, terminal_graph)].insert(target(*it, terminal_graph));
            }
            if (map_connection.find(target(*it, terminal_graph)) == map_connection.end()) {
                std::set<int> temp_results;
                temp_results.insert(source(*it, terminal_graph));
                map_connection[target(*it, terminal_graph)] = temp_results;
            }
            else {
                map_connection[target(*it, terminal_graph)].insert(source(*it, terminal_graph));
            }
        }
        //      std::cout << source(*it, terminal_graph) << " " << target(*it, terminal_graph) << std::endl;
    }
    // std::cout << map_connection.size() << std::endl;
    //    std::cout << map_saved_edge.size() << " " << terminal_edge.size() << std::endl;

    //  std::cout << "abc2 " << std::endl;

    std::vector<int> component(num_vertices(terminal_graph_cluster));
    const int num = connected_components(terminal_graph_cluster, &component[0]);
    //  std::cout << "jaja: " << num << std::endl;
    int ncounts[num];
    std::vector<std::vector<int> > sep_clusters(num);
    for (size_t i = 0; i != num; i++) {
        ncounts[i] = 0;
        std::vector<int> temp;
        sep_clusters[i] = temp;
    }
    {
        std::vector<int>::size_type i;
        for (i = 0; i != component.size(); ++i) {
            ncounts[component[i]]++;
            sep_clusters[component[i]].push_back(terminals.at(i));
        }
    }

    // test
    //  for (size_t j=0;j!=sep_clusters.size();j++){
    // for(size_t i=0;i!=sep_clusters[j].size();i++){
    //  if (sep_clusters[j].at(i) > 530 && sep_clusters[j].at(i) < 570)
    //	std::cout << j << " " << i << " " << sep_clusters[j].at(i) << " " << flag_tagged[sep_clusters[j].at(i)] <<
    //std::endl;
    //}
    //}

    std::vector<WCPPID::Res_proto_segment> temp_segments(num);
    std::set<int> remaining_segments;
    for (int i = 0; i != num; i++) {
        remaining_segments.insert(i);
    }

    for (size_t i = 0; i != num; i++) {
        // inside the original track
        if (flag_tagged[sep_clusters[i].front()]) {
            remaining_segments.erase(i);
            continue;
        }
        temp_segments.at(i).group_num = i;
        temp_segments.at(i).number_points = ncounts[i];

        int special_A = -1;
        std::vector<int> candidates_special_A;
        for (size_t j = 0; j != ncounts[i]; j++) {
            if (map_connection.find(sep_clusters[i].at(j)) != map_connection.end()) {
                //	special_A = sep_clusters[i].at(j);
                candidates_special_A.push_back(sep_clusters[i].at(j));
                //	if (ncounts[i]>=40)	  std::cout << special_A << " " << ncounts[i] << " " <<
                //cloud.pts[special_A].index_u << " " << cloud.pts[special_A].index_v << " " <<
                //cloud.pts[special_A].index_w << std::endl; 	break;
            }
        }

        if (candidates_special_A.size() > 0) {
            if (candidates_special_A.size() > 1 && ncounts[i] > 6) {
                //	special_A = candidates_special_A.back();
                PointVector tmp_points;
                for (size_t j = 0; j != ncounts[i]; j++) {
                    Point tmp_p(cloud.pts[sep_clusters[i].at(j)].x, cloud.pts[sep_clusters[i].at(j)].y,
                                cloud.pts[sep_clusters[i].at(j)].z);
                    tmp_points.push_back(tmp_p);
                }
                std::pair<Point, TVector3> results_pca = calc_PCA_main_axis(tmp_points);
                double max_val = 0;
                for (size_t j = 0; j != candidates_special_A.size(); j++) {
                    double val =
                        fabs((cloud.pts[candidates_special_A.at(j)].x - results_pca.first.x) * results_pca.second.X() +
                             (cloud.pts[candidates_special_A.at(j)].y - results_pca.first.y) * results_pca.second.Y() +
                             (cloud.pts[candidates_special_A.at(j)].z - results_pca.first.z) * results_pca.second.Z());
                    //  std::cout << candidates_special_A.at(j) << " " << val  << " " << ncounts[i] << " " <<
                    //  cloud.pts[candidates_special_A.at(j)].index_u << " " <<
                    //  cloud.pts[candidates_special_A.at(j)].index_v << " " <<
                    //  cloud.pts[candidates_special_A.at(j)].index_w << std::endl;
                    if (val > max_val) {
                        max_val = val;
                        special_A = candidates_special_A.at(j);
                    }
                }
            }
            else {
                special_A = candidates_special_A.front();
            }
        }

        //    if (special_A !=-1){
        //  std::cout << i << " " << special_A << " " << sep_clusters[i].size() << std::endl;
        //  for (auto it1 = map_connection[special_A].begin(); it1 != map_connection[special_A].end(); it1++){
        // 	std::cout << *it1 << std::endl;
        //  }
        // }

        int special_B = special_A;
        double min_dis = 0;

        int number_not_faked = 0;
        double max_dis_u = 0, max_dis_v = 0, max_dis_w = 0;
        for (size_t j = 0; j != ncounts[i]; j++) {
            double dis = sqrt(pow(cloud.pts[sep_clusters[i].at(j)].x - cloud.pts[special_A].x, 2) +
                              pow(cloud.pts[sep_clusters[i].at(j)].y - cloud.pts[special_A].y, 2) +
                              pow(cloud.pts[sep_clusters[i].at(j)].z - cloud.pts[special_A].z, 2));
            if (dis > min_dis) {
                min_dis = dis;
                special_B = sep_clusters[i].at(j);  // furthest away from special_A
            }

            // also judge whether this track is fake ...
            WCP::Point p(cloud.pts[sep_clusters[i].at(j)].x, cloud.pts[sep_clusters[i].at(j)].y,
                         cloud.pts[sep_clusters[i].at(j)].z);
            double min_dis_u = 1e9, min_dis_v = 1e9, min_dis_w = 1e9;
            for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
                WCPPID::ProtoSegment *sg1 = it->first;
                if (sg1->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
                std::tuple<double, double, double> closest_2d_dis = sg1->get_closest_2d_dis(p);
                if (std::get<0>(closest_2d_dis) < min_dis_u) min_dis_u = std::get<0>(closest_2d_dis);
                if (std::get<1>(closest_2d_dis) < min_dis_v) min_dis_v = std::get<1>(closest_2d_dis);
                if (std::get<2>(closest_2d_dis) < min_dis_w) min_dis_w = std::get<2>(closest_2d_dis);
            }
            int flag_num = 0;
            if (min_dis_u > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 0))) flag_num++;
            if (min_dis_v > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 1))) flag_num++;
            if (min_dis_w > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 2))) flag_num++;

            //      std::cout << cloud.pts[sep_clusters[i].at(j)].index << " " << min_dis_u/units::cm << " " <<
            //      min_dis_v/units::cm << " " << min_dis_w/units::cm << " " << ct_point_cloud->get_closest_dead_chs(p,
            //      0) << " " << ct_point_cloud->get_closest_dead_chs(p, 1) << " " <<
            //      ct_point_cloud->get_closest_dead_chs(p, 2) << std::endl;

            if (min_dis_u > max_dis_u && (!ct_point_cloud->get_closest_dead_chs(p, 0))) max_dis_u = min_dis_u;
            if (min_dis_v > max_dis_v && (!ct_point_cloud->get_closest_dead_chs(p, 1))) max_dis_v = min_dis_v;
            if (min_dis_w > max_dis_w && (!ct_point_cloud->get_closest_dead_chs(p, 2))) max_dis_w = min_dis_w;
            if (flag_num >= 2) number_not_faked++;
        }

        double length = sqrt(pow(cloud.pts[special_A].x - cloud.pts[special_B].x, 2) +
                             pow(cloud.pts[special_A].y - cloud.pts[special_B].y, 2) +
                             pow(cloud.pts[special_A].z - cloud.pts[special_B].z, 2));
        // check ...

        if (length < 3 * units::cm) {
            int save_index = special_A;
            double save_dis = 1e9;
            for (auto it1 = map_connection[special_A].begin(); it1 != map_connection[special_A].end(); it1++) {
                double temp_dis =
                    sqrt(pow(cloud.pts[special_A].x - cloud.pts[*it1].x, 2) +
                         pow(cloud.pts[*it1].y - cloud.pts[*it1].y, 2) + pow(cloud.pts[*it1].z - cloud.pts[*it1].z, 2));
                if (temp_dis < save_dis) {
                    save_index = *it1;
                    save_dis = temp_dis;
                }
            }
            special_A = save_index;
            length = sqrt(pow(cloud.pts[special_A].x - cloud.pts[special_B].x, 2) +
                          pow(cloud.pts[special_A].y - cloud.pts[special_B].y, 2) +
                          pow(cloud.pts[special_A].z - cloud.pts[special_B].z, 2));
        }
        //    std::cout << special_A << " " << special_B << " " << length/units::cm << std::endl;

        temp_segments.at(i).special_A = special_A;
        temp_segments.at(i).special_B = special_B;
        temp_segments.at(i).length = length;
        temp_segments.at(i).number_not_faked = number_not_faked;
        temp_segments.at(i).max_dis_u = max_dis_u;
        temp_segments.at(i).max_dis_v = max_dis_v;
        temp_segments.at(i).max_dis_w = max_dis_w;

        if (temp_segments.at(i).number_points == 1  //  only one point
            || number_not_faked == 0 &&
                   (length < 3.5 * units::cm  // very short & fake
                    || (number_not_faked < 0.25 * temp_segments.at(i).number_points ||
                        number_not_faked < 0.4 * temp_segments.at(i).number_points && length < 7 * units::cm) &&
                           max_dis_u / units::cm < 3 && max_dis_v / units::cm < 3 && max_dis_w / units::cm < 3 &&
                           max_dis_u + max_dis_v + max_dis_w <
                               6 * units::cm)  // many fake things and very close to each other ...
        ) {
            remaining_segments.erase(i);
        }
    }

    /* for (auto it = remaining_segments.begin(); it!=remaining_segments.end(); it++){ */
    /*   std::cout << "jaja1: " << *it << " " << temp_segments.at(*it).number_not_faked << " " <<
     * temp_segments.at(*it).number_points << " " <<  temp_segments.at(*it).max_dis_u/units::cm << " " <<
     * temp_segments.at(*it).max_dis_v/units::cm << " " << temp_segments.at(*it).max_dis_w/units::cm << " " <<
     * temp_segments.at(*it).length/units::cm << std::endl; */
    /* } */
    //  std::cout << remaining_segments.size() << std::endl;

    // plan to examine things ...
    std::vector<int> saved_clusters;
    std::vector<std::pair<int, int> > saved_cluster_points(num);

    /* saved_clusters.push_back(8); */
    /* saved_cluster_points.at(8) = std::make_pair(temp_segments.at(8).special_A, temp_segments.at(8).special_B); */

    ProtoSegmentSelection temp_segments_1, temp_segments_2;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        if (it->first->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        temp_segments_1.push_back(it->first);
    }

    while (remaining_segments.size() > 0) {
        // std::cout << num << " " << remaining_segments.size() << std::endl;

        // find the maximal length cluster
        double max_length = 0;
        int max_length_cluster = -1;
        double max_number_not_faked = 0;
        for (auto it = remaining_segments.begin(); it != remaining_segments.end(); it++) {
            if (temp_segments.at(*it).number_not_faked > max_number_not_faked) {
                max_length_cluster = *it;
                max_number_not_faked = temp_segments.at(*it).number_not_faked;
                max_length = temp_segments.at(*it).length;
            }
            else if (temp_segments.at(*it).number_not_faked == max_number_not_faked) {
                if (temp_segments.at(*it).length > max_length) {
                    max_length_cluster = *it;
                    max_number_not_faked = temp_segments.at(*it).number_not_faked;
                    max_length = temp_segments.at(*it).length;
                }
            }
            // std::cout << "b: " << *it << std::endl;
        }
        // save things ...
        saved_clusters.push_back(max_length_cluster);
        saved_cluster_points.at(max_length_cluster) = std::make_pair(temp_segments.at(max_length_cluster).special_A,
                                                                     temp_segments.at(max_length_cluster).special_B);
        remaining_segments.erase(max_length_cluster);

        /* for (auto it = remaining_segments.begin(); it!=remaining_segments.end(); it++){ */
        /*   std::cout << "c: " << *it << std::endl; */
        /* } */

        // form a new segment with this cluster ...
        // good for a new segement ...
        temp_cluster->dijkstra_shortest_paths(cloud.pts[temp_segments.at(max_length_cluster).special_A], 2);
        temp_cluster->cal_shortest_path(cloud.pts[temp_segments.at(max_length_cluster).special_B], 2);
        WCPPID::ProtoSegment *tmp_sg =
            new WCPPID::ProtoSegment(-1, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
        temp_segments_1.push_back(tmp_sg);
        temp_segments_2.push_back(tmp_sg);

        // std::cout <<"abc: "<< std::endl;

        std::set<int> tmp_del_set;
        // examine the rest of points ...
        for (auto it = remaining_segments.begin(); it != remaining_segments.end(); it++) {
            //  std::cout << *it << std::endl;
            // std::cout << " a " << ncounts[*it] << std::endl;

            // reset
            temp_segments.at(*it).number_not_faked = 0;
            temp_segments.at(*it).max_dis_u = 0;
            temp_segments.at(*it).max_dis_v = 0;
            temp_segments.at(*it).max_dis_w = 0;

            for (size_t j = 0; j != ncounts[*it]; j++) {
                // also judge whether this track is fake ...
                WCP::Point p(cloud.pts[sep_clusters[*it].at(j)].x, cloud.pts[sep_clusters[*it].at(j)].y,
                             cloud.pts[sep_clusters[*it].at(j)].z);
                double min_dis_u = 1e9, min_dis_v = 1e9, min_dis_w = 1e9;
                for (auto it1 = temp_segments_1.begin(); it1 != temp_segments_1.end(); it1++) {
                    WCPPID::ProtoSegment *sg1 = *it1;
                    std::tuple<double, double, double> closest_2d_dis = sg1->get_closest_2d_dis(p);
                    if (std::get<0>(closest_2d_dis) < min_dis_u) min_dis_u = std::get<0>(closest_2d_dis);
                    if (std::get<1>(closest_2d_dis) < min_dis_v) min_dis_v = std::get<1>(closest_2d_dis);
                    if (std::get<2>(closest_2d_dis) < min_dis_w) min_dis_w = std::get<2>(closest_2d_dis);
                }
                int flag_num = 0;
                if (min_dis_u > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 0))) flag_num++;
                if (min_dis_v > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 1))) flag_num++;
                if (min_dis_w > scaling_2d * search_range && (!ct_point_cloud->get_closest_dead_chs(p, 2))) flag_num++;
                if (flag_num >= 2) temp_segments.at(*it).number_not_faked++;
                if (min_dis_u > temp_segments.at(*it).max_dis_u && (!ct_point_cloud->get_closest_dead_chs(p, 0)))
                    temp_segments.at(*it).max_dis_u = min_dis_u;
                if (min_dis_v > temp_segments.at(*it).max_dis_v && (!ct_point_cloud->get_closest_dead_chs(p, 1)))
                    temp_segments.at(*it).max_dis_v = min_dis_v;
                if (min_dis_w > temp_segments.at(*it).max_dis_w && (!ct_point_cloud->get_closest_dead_chs(p, 2)))
                    temp_segments.at(*it).max_dis_w = min_dis_w;
            }

            if (temp_segments.at(*it).number_points == 1  //  only one point
                || temp_segments.at(*it).number_not_faked == 0 &&
                       (temp_segments.at(*it).length < 3.5 * units::cm  // very short & fake
                        || (temp_segments.at(*it).number_not_faked < 0.25 * temp_segments.at(*it).number_points ||
                            temp_segments.at(*it).number_not_faked < 0.4 * temp_segments.at(*it).number_points &&
                                temp_segments.at(*it).length < 7 * units::cm) &&
                               temp_segments.at(*it).max_dis_u / units::cm < 3 &&
                               temp_segments.at(*it).max_dis_v / units::cm < 3 &&
                               temp_segments.at(*it).max_dis_w / units::cm < 3 &&
                               temp_segments.at(*it).max_dis_u + temp_segments.at(*it).max_dis_v +
                                       temp_segments.at(*it).max_dis_w <
                                   6 * units::cm)  // many fake things and very close to each other ...
            )
                tmp_del_set.insert(*it);
            //       	 remaining_segments.erase(*it);
        }
        for (auto it = tmp_del_set.begin(); it != tmp_del_set.end(); it++) {
            remaining_segments.erase(*it);
        }
        /* for (auto it = remaining_segments.begin(); it!=remaining_segments.end(); it++){ */
        /*   std::cout << "jaja1: " << *it << " " << temp_segments.at(*it).number_not_faked << " " <<
         * temp_segments.at(*it).number_points << " " <<  temp_segments.at(*it).max_dis_u/units::cm << " " <<
         * temp_segments.at(*it).max_dis_v/units::cm << " " << temp_segments.at(*it).max_dis_w/units::cm << " " <<
         * temp_segments.at(*it).length/units::cm << std::endl; */
        /* } */
        /* std::cout << std::endl; */
        //    break;
    }

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

    //  std::cout << "abc3 " << std::endl;

    bool flag_final_fit = true;

    std::vector<WCPPID::ProtoSegment *> new_segments;
    std::vector<WCPPID::ProtoSegment *> new_segments_1;
    // save segments ...
    for (auto it = saved_clusters.begin(); it != saved_clusters.end(); it++) {
        //    std::cout << (saved_cluster_points.at(*it)).first << " " << (saved_cluster_points.at(*it)).second << " "
        //    << cloud.pts.size() << std::endl;
        // within the new segment, OK ...
        temp_cluster->dijkstra_shortest_paths(cloud.pts[(saved_cluster_points.at(*it)).first], 2);
        temp_cluster->cal_shortest_path(cloud.pts[(saved_cluster_points.at(*it)).second], 2);

        //    std::cout << cloud.pts[(saved_cluster_points.at(*it)).first].index << " A " <<
        //    cloud.pts[(saved_cluster_points.at(*it)).second].index << " " <<
        //    temp_cluster->get_path_wcps().front().index << " " << temp_cluster->get_path_wcps().back().index <<
        //    std::endl;

        std::list<WCP::WCPointCloud<double>::WCPoint> temp_path_list = temp_cluster->get_path_wcps();
        temp_cluster->collect_charge_trajectory(*ct_point_cloud);
        // do not fit dQ/dx at beginning ...
        temp_cluster->do_tracking(*ct_point_cloud, global_wc_map, flash_time * units::microsecond, false, false);

        //    std::cout << "abc3.2 " <<  " " << temp_cluster->get_fine_tracking_path().size() << std::endl;

        if (temp_cluster->get_fine_tracking_path().size() > 1) {
            WCPPID::ProtoVertex *v1 =
                find_vertex_other_segment(temp_cluster, true, cloud.pts[(saved_cluster_points.at(*it)).first]);
            //      std::cout << v1 << std::endl;
            WCPPID::ProtoVertex *v2 =
                find_vertex_other_segment(temp_cluster, false, cloud.pts[(saved_cluster_points.at(*it)).second]);
            //      std::cout << "abc3.3 " <<  v1 << " " << v2 << std::endl;
            // protection against a corner case crashing the code
            if (v1 == v2) {
                double tmp_dis1 = sqrt(pow(v1->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).first].x, 2) +
                                       pow(v1->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).first].y, 2) +
                                       pow(v1->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).first].z, 2));
                double tmp_dis2 = sqrt(pow(v1->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).second].x, 2) +
                                       pow(v1->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).second].y, 2) +
                                       pow(v1->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).second].z, 2));
                if (tmp_dis1 < tmp_dis2) {
                    // change v2
                    v2 = new WCPPID::ProtoVertex(acc_vertex_id, cloud.pts[(saved_cluster_points.at(*it)).second],
                                                 temp_cluster->get_cluster_id());
                    acc_vertex_id++;
                }
                else {
                    // change v1
                    v1 = new WCPPID::ProtoVertex(acc_vertex_id, cloud.pts[(saved_cluster_points.at(*it)).first],
                                                 temp_cluster->get_cluster_id());
                    acc_vertex_id++;
                }
            }

            //      std::cout << v1 << " " << v2 << " " << sqrt(pow(cloud.pts[(saved_cluster_points.at(*it)).first].x -
            //      cloud.pts[(saved_cluster_points.at(*it)).second].x,2) +
            //      pow(cloud.pts[(saved_cluster_points.at(*it)).first].y -
            //      cloud.pts[(saved_cluster_points.at(*it)).second].y,2) +
            //      pow(cloud.pts[(saved_cluster_points.at(*it)).first].z -
            //      cloud.pts[(saved_cluster_points.at(*it)).second].z,2)) << std::endl; std::cout <<
            //      cloud.pts[(saved_cluster_points.at(*it)).first].index << " A " <<
            //      cloud.pts[(saved_cluster_points.at(*it)).second].index << " " <<
            //      temp_cluster->get_path_wcps().front().index << " " << temp_cluster->get_path_wcps().back().index <<
            //      std::endl; std::cout << v1->get_wcpt().index << " " <<
            //      cloud.pts[(saved_cluster_points.at(*it)).first].index << " " << v2->get_wcpt().index << " " <<
            //      cloud.pts[(saved_cluster_points.at(*it)).second].index << std::endl;

            if (v1->get_wcpt().index == cloud.pts[(saved_cluster_points.at(*it)).first].index &&
                v2->get_wcpt().index == cloud.pts[(saved_cluster_points.at(*it)).second].index) {
                if (v1->get_wcpt().index != temp_cluster->get_path_wcps().front().index) {
                    temp_cluster->dijkstra_shortest_paths(cloud.pts[(saved_cluster_points.at(*it)).first], 2);
                    temp_cluster->cal_shortest_path(cloud.pts[(saved_cluster_points.at(*it)).second], 2);
                }
                else if (v2->get_wcpt().index != temp_cluster->get_path_wcps().back().index)
                    temp_cluster->cal_shortest_path(cloud.pts[(saved_cluster_points.at(*it)).second], 2);
                // this is between v1 and v2 ...
            }
            else {
                // std::cout << temp_path_list.size() << std::endl;
                if (v1->get_wcpt().index != cloud.pts[(saved_cluster_points.at(*it)).first].index) {
                    double tmp_length =
                        sqrt(pow(v1->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).first].x, 2) +
                             pow(v1->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).first].y, 2) +
                             pow(v1->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).first].z, 2));
                    int tmp_count = std::round(tmp_length / (0.6 * units::cm));
                    for (int k = 1; k < tmp_count; k++) {
                        Point tmp_p;
                        tmp_p.x =
                            cloud.pts[(saved_cluster_points.at(*it)).first].x +
                            (v1->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).first].x) * 1. / tmp_count * k;
                        tmp_p.y =
                            cloud.pts[(saved_cluster_points.at(*it)).first].y +
                            (v1->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).first].y) * 1. / tmp_count * k;
                        tmp_p.z =
                            cloud.pts[(saved_cluster_points.at(*it)).first].z +
                            (v1->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).first].z) * 1. / tmp_count * k;

                        WCP::WCPointCloud<double>::WCPoint &tmp_wcp =
                            temp_cluster->get_point_cloud_steiner()->get_closest_wcpoint(tmp_p);
                        if (tmp_wcp.index != temp_path_list.front().index) temp_path_list.push_front(tmp_wcp);
                    }
                    if (v1->get_wcpt().index != temp_path_list.front().index) temp_path_list.push_front(v1->get_wcpt());
                }

                if (v2->get_wcpt().index != cloud.pts[(saved_cluster_points.at(*it)).second].index) {
                    double tmp_length =
                        sqrt(pow(v2->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).second].x, 2) +
                             pow(v2->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).second].y, 2) +
                             pow(v2->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).second].z, 2));
                    int tmp_count = std::round(tmp_length / (0.6 * units::cm));
                    for (int k = 1; k < tmp_count; k++) {
                        Point tmp_p;
                        tmp_p.x = cloud.pts[(saved_cluster_points.at(*it)).second].x +
                                  (v2->get_wcpt().x - cloud.pts[(saved_cluster_points.at(*it)).second].x) * 1. /
                                      tmp_count * k;
                        tmp_p.y = cloud.pts[(saved_cluster_points.at(*it)).second].y +
                                  (v2->get_wcpt().y - cloud.pts[(saved_cluster_points.at(*it)).second].y) * 1. /
                                      tmp_count * k;
                        tmp_p.z = cloud.pts[(saved_cluster_points.at(*it)).second].z +
                                  (v2->get_wcpt().z - cloud.pts[(saved_cluster_points.at(*it)).second].z) * 1. /
                                      tmp_count * k;

                        WCP::WCPointCloud<double>::WCPoint &tmp_wcp =
                            temp_cluster->get_point_cloud_steiner()->get_closest_wcpoint(tmp_p);
                        if (tmp_wcp.index != temp_path_list.back().index) temp_path_list.push_back(tmp_wcp);
                    }
                    if (v2->get_wcpt().index != temp_path_list.back().index) temp_path_list.push_back(v2->get_wcpt());
                }

                //	std::cout << temp_path_list.size() << std::endl;
                temp_cluster->set_path_wcps(temp_path_list);
            }

            if (map_vertex_segments.find(v1) != map_vertex_segments.end() ||
                map_vertex_segments.find(v2) != map_vertex_segments.end()) {
                if (v1->get_wcpt().index != v2->get_wcpt().index) {
                    WCPPID::ProtoSegment *sg1 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(),
                                                                         temp_cluster->get_cluster_id());
                    acc_segment_id++;
                    // std::cout << map_vertex_segments.size() << " " << map_segment_vertices.size() << " " <<
                    // temp_cluster->get_path_wcps().size() << std::endl;
                    //	  std::cout << v1->get_wcpt().index  << " " << v2->get_wcpt().index << " " <<
                    //sg1->get_wcpt_vec().front().index << " " << sg1->get_wcpt_vec().back().index << std::endl;
                    add_proto_connection(v1, sg1, temp_cluster);
                    add_proto_connection(v2, sg1, temp_cluster);

                    // std::cout <<  sg1->get_cluster_id() << " " << sg1->get_direct_length()/units::cm << " " <<
                    // sg1->get_length()/units::cm << std::endl;
                    /* std::cout << map_vertex_segments.size() << " " << map_segment_vertices.size() << std::endl; */
                    /* for (auto it5 = map_segment_vertices.begin(); it5 != map_segment_vertices.end(); it5++){   */
                    /*   std::cout << it5->first->get_wcpt_vec().front().index << " " <<
                     * it5->first->get_wcpt_vec().back().index << " " << it5->second.size() << " " <<
                     * it5->first->get_point_vec().size() << std::endl;   */
                    /* }   */
                    /* std::cout << sg1->get_id() << " " << sg1->get_wcpt_vec().front().index << " " <<
                     * sg1->get_wcpt_vec().back().index << " " << v1->get_wcpt().index <<  " " << v2->get_wcpt().index
                     * << std::endl;   */

                    //	  clean_up_maps_vertices_segments(temp_cluster);
                    // do dQ/dx fitting and exclude others ...
                    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                    global_wc_map, flash_time * units::microsecond, true, true, true);

                    if (sg1->get_length() > 30 * units::cm || sg1->get_direct_length() < 0.78 * sg1->get_length() &&
                                                                  sg1->get_length() > 10 * units::cm &&
                                                                  sg1->get_medium_dQ_dx() / (43e3 / units::cm) > 1.6)
                        new_segments.push_back(sg1);

                    flag_final_fit = false;
                    // update output ...
                    std::cout << "Cluster: " << temp_cluster->get_cluster_id()
                              << " Other tracks -- # of Vertices: " << map_vertex_segments.size()
                              << "; # of Segments: " << map_segment_vertices.size() << std::endl;
                }
                else {
                    if (map_vertex_segments.find(v1) == map_vertex_segments.end()) delete v1;
                    if (map_vertex_segments.find(v2) == map_vertex_segments.end()) delete v2;
                }
            }
            else {
                TVector3 drift_dir(1, 0, 0);
                WCPPID::ProtoSegment *new_sg = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(),
                                                                        temp_cluster->get_cluster_id());
                acc_segment_id++;
                TVector3 dir(v1->get_wcpt().x - v2->get_wcpt().x, v1->get_wcpt().y - v2->get_wcpt().y,
                             v1->get_wcpt().z - v2->get_wcpt().z);

                /* for (auto it1 = temp_cluster->get_path_wcps().begin(); it1 != temp_cluster->get_path_wcps().end();
                 * it1++){ */
                /*   if ((*it1).mcell !=0){ */
                /*     std::cout << (*it1).index_u << " " << (*it1).index_v << " " << (*it1).index_w << " " <<
                 * (*it1).mcell->GetTimeSlice() << " " << (*it1).x/units::cm << std::endl; */
                /*   }else{ */
                /*     std::cout << (*it1).index_u << " " << (*it1).index_v << " " << (*it1).index_w << " " <<
                 * (*it1).x/units::cm << std::endl; */
                /*   } */
                /* } */
                //	std::cout << new_sg->get_length()/units::cm << std::endl;
                //	std::cout << new_sg->get_point_vec().front() << " " << new_sg->get_point_vec().back() <<
                //std::endl;

                // Now need a parallel search ...
                bool flag_parallel = false;
                if (dir.Mag() > 10 * units::cm || dir.Mag() > 8 * units::cm && new_sg->get_length() > 13 * units::cm) {
                    for (auto it1 = map_vertex_segments.begin(); it1 != map_vertex_segments.end(); it1++) {
                        WCPPID::ProtoVertex *vtx = it1->first;
                        if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
                        if (vtx == v1 || vtx == v2) continue;
                        TVector3 dir1(vtx->get_fit_pt().x - v1->get_wcpt().x, vtx->get_fit_pt().y - v1->get_wcpt().y,
                                      vtx->get_fit_pt().z - v1->get_wcpt().z);
                        TVector3 dir2(vtx->get_fit_pt().x - v2->get_wcpt().x, vtx->get_fit_pt().y - v2->get_wcpt().y,
                                      vtx->get_fit_pt().z - v2->get_wcpt().z);
                        // std::cout << dir1.Mag()/units::cm << " " << dir2.Mag()/units::cm << " "<<
                        // fabs(drift_dir.Angle(dir1)/3.1415926*180.-90.) << std::endl;
                        // check one vertex
                        if (dir1.Mag() < 6 * units::cm && fabs(drift_dir.Angle(dir1) / 3.1415926 * 180. - 90.) < 15.)
                            flag_parallel = modify_vertex_isochronous(vtx, v1, new_sg, v2, temp_cluster);
                        // check the other vertex
                        if ((!flag_parallel) && dir2.Mag() < 6 * units::cm &&
                            fabs(drift_dir.Angle(dir2) / 3.1415926 * 180. - 90.) < 15.)
                            flag_parallel = modify_vertex_isochronous(vtx, v2, new_sg, v1, temp_cluster);
                        if (flag_parallel) break;
                    }

                    if (!flag_parallel) {
                        double min_dis1 = 1e9;
                        WCPPID::ProtoSegment *min_sg1 = 0;
                        double min_dis2 = 1e9;
                        WCPPID::ProtoSegment *min_sg2 = 0;

                        for (auto it1 = map_segment_vertices.begin(); it1 != map_segment_vertices.end(); it1++) {
                            WCPPID::ProtoSegment *sg1 = it1->first;
                            if (sg1->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
                            // std::cout << sg1->get_closest_point(v1->get_fit_pt()).first/units::cm << "  "<<
                            // sg1->get_closest_point(v2->get_fit_pt()).first/units::cm << std::endl;
                            double dis1 = sg1->get_closest_point(v1->get_fit_pt()).first;
                            double dis2 = sg1->get_closest_point(v2->get_fit_pt()).first;
                            if (dis1 < 6 * units::cm) {
                                flag_parallel = modify_segment_isochronous(sg1, v1, new_sg, v2, temp_cluster);
                            }
                            if ((!flag_parallel) && dis2 < 6 * units::cm) {
                                flag_parallel = modify_segment_isochronous(sg1, v2, new_sg, v1, temp_cluster);
                            }
                            if (flag_parallel) break;
                            if (dis1 < min_dis1) {
                                min_dis1 = dis1;
                                min_sg1 = sg1;
                            }
                            if (dis2 < min_dis2) {
                                min_dis2 = dis2;
                                min_sg2 = sg1;
                            }
                        }
                        //	    std::cout << min_dis1/units::cm << " " << min_dis2/units::cm << " " << min_sg1 << "
                        //" << min_sg2 << " " << dir.Mag()/units::cm << std::endl;

                        //  long track ...
                        if (!flag_parallel && dir.Mag() > 18 * units::cm) {
                            if (min_dis1 < min_dis2 && min_dis1 < 10 * units::cm) {
                                flag_parallel = modify_segment_isochronous(min_sg1, v1, new_sg, v2, temp_cluster,
                                                                           10 * units::cm, 8, 15 * units::cm);
                                if (!flag_parallel)
                                    flag_parallel = modify_segment_isochronous(min_sg1, v1, new_sg, v2, temp_cluster,
                                                                               10 * units::cm, 8, 30 * units::cm);
                            }
                            else if (min_dis2 < min_dis1 && min_dis2 < 10 * units::cm) {
                                flag_parallel = modify_segment_isochronous(min_sg2, v2, new_sg, v1, temp_cluster,
                                                                           10 * units::cm, 8, 15 * units::cm);
                                if (!flag_parallel)
                                    flag_parallel = modify_segment_isochronous(min_sg2, v2, new_sg, v1, temp_cluster,
                                                                               10 * units::cm, 8, 30 * units::cm);
                            }
                        }

                        // very long track ...
                        if (!flag_parallel && dir.Mag() > 36 * units::cm) {
                            if (min_dis1 < min_dis2 && min_dis1 < 18 * units::cm) {
                                flag_parallel = modify_segment_isochronous(min_sg1, v1, new_sg, v2, temp_cluster,
                                                                           18 * units::cm, 5, 15 * units::cm);
                                if (!flag_parallel)
                                    flag_parallel = modify_segment_isochronous(min_sg1, v1, new_sg, v2, temp_cluster,
                                                                               18 * units::cm, 5, 30 * units::cm);
                            }
                            else if (min_dis2 < min_dis1 && min_dis2 < 18 * units::cm) {
                                flag_parallel = modify_segment_isochronous(min_sg2, v2, new_sg, v1, temp_cluster,
                                                                           18 * units::cm, 5, 15 * units::cm);
                                if (!flag_parallel)
                                    flag_parallel = modify_segment_isochronous(min_sg2, v2, new_sg, v1, temp_cluster,
                                                                               18 * units::cm, 5, 30 * units::cm);
                            }
                        }
                    }
                }

                //	std::cout << new_sg->get_point_vec().front() << " " << new_sg->get_point_vec().back() <<
                //std::endl;

                if (!flag_parallel) {
                    residual_segment_candidates.push_back(
                        std::make_tuple(temp_cluster, v1->get_wcpt().index, v2->get_wcpt().index));
                    std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Isolated residual segment found: "
                              << sqrt(pow(v1->get_fit_pt().x - v2->get_fit_pt().x, 2) +
                                      pow(v1->get_fit_pt().y - v2->get_fit_pt().y, 2) +
                                      pow(v1->get_fit_pt().z - v2->get_fit_pt().z, 2)) /
                                     units::cm
                              << " cm " << v1->get_fit_pt() << " " << v2->get_fit_pt() << std::endl;
                    delete v1;
                    delete v2;
                    delete new_sg;
                }
                else {
                    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                    global_wc_map, flash_time * units::microsecond, true, true, true);
                    //	  std::cout << new_sg->get_medium_dQ_dx()/(43e3/units::cm) << std::endl;
                    double direct_length = new_sg->get_direct_length();
                    double length = new_sg->get_length();
                    double medium_dQ_dx = new_sg->get_medium_dQ_dx() / (43e3 / units::cm);

                    // std::cout << direct_length/units::cm << " " << length/units::cm << " " << medium_dQ_dx <<
                    // std::endl;
                    if (direct_length < 0.78 * length && length > 10 * units::cm && medium_dQ_dx > 1.6 ||
                        direct_length < 0.6 * length && length > 10 * units::cm) {
                        if (medium_dQ_dx > 1.1) {
                            new_segments.push_back(new_sg);  // high dQdx ...
                        }
                        else {
                            new_segments_1.push_back(new_sg);
                        }
                    }
                }
            }

            // hack ...
            // break;
        }  // path > 1
    }      // loop over saved stuff

    //  std::cout << "abc4 " << std::endl;

    if (flag_break_track) {
        break_segments(new_segments_1, temp_cluster, 2.0 * units::cm);
        break_segments(new_segments, temp_cluster);
    }
    //  if (flag_final_fit)
    // temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
    // flash_time*units::microsecond, true, true, true);
}

WCPPID::ProtoVertex *WCPPID::NeutrinoID::find_vertex_other_segment(WCPPID::PR3DCluster *temp_cluster, bool flag_forward,
                                                                   WCP::WCPointCloud<double>::WCPoint &wcp)
{
    WCPPID::ProtoVertex *v1 = 0;

    std::tuple<WCPPID::ProtoVertex *, WCPPID::ProtoSegment *, Point> check_results =
        check_end_point(temp_cluster, temp_cluster->get_fine_tracking_path(), flag_forward);
    //  std::cout << "A: " << flag_forward << " " << std::get<0>(check_results) << " " << std::get<1>(check_results) <<
    //  " " << std::get<2>(check_results) << std::endl;
    if (std::get<0>(check_results) == 0 && std::get<1>(check_results) == 0) {
        check_results = check_end_point(temp_cluster, temp_cluster->get_fine_tracking_path(), flag_forward,
                                        1.2 * units::cm, 2.5 * units::cm);
        // std::cout << "B: " << flag_forward << " " <<  std::get<0>(check_results) << " " << std::get<1>(check_results)
        // << " " << std::get<2>(check_results) << std::endl;
    }
    if (std::get<0>(check_results) == 0 && std::get<1>(check_results) == 0) {
        check_results = check_end_point(temp_cluster, temp_cluster->get_fine_tracking_path(), flag_forward,
                                        1.5 * units::cm, 3.0 * units::cm);
    }

    // std::cout << std::get<0>(check_results) << " " << std::get<1>(check_results) << " " << std::get<2>(check_results)
    // << std::endl;
    // hack ...
    // std::get<0>(check_results) = 0;
    // std::get<1>(check_results) = 0;

    if (std::get<0>(check_results) != 0) {
        v1 = std::get<0>(check_results);
    }
    else if (std::get<1>(check_results) != 0) {
        WCPPID::ProtoSegment *sg1 = std::get<1>(check_results);
        Point test_p = std::get<2>(check_results);
        WCP::WCPointCloud<double>::WCPoint break_wcp = sg1->get_closest_wcpt(test_p);
        WCPPID::ProtoVertex *start_v = 0, *end_v = 0;

        if ((*map_segment_vertices[sg1].begin())->get_wcpt().index == sg1->get_wcpt_vec().front().index &&
            (*map_segment_vertices[sg1].rbegin())->get_wcpt().index == sg1->get_wcpt_vec().back().index) {
            start_v = (*map_segment_vertices[sg1].begin());
            end_v = (*map_segment_vertices[sg1].rbegin());
        }
        else if ((*map_segment_vertices[sg1].rbegin())->get_wcpt().index == sg1->get_wcpt_vec().front().index &&
                 (*map_segment_vertices[sg1].begin())->get_wcpt().index == sg1->get_wcpt_vec().back().index) {
            start_v = (*map_segment_vertices[sg1].rbegin());
            end_v = (*map_segment_vertices[sg1].begin());
        }
        //   for (auto it2 = map_segment_vertices[sg1].begin(); it2!=map_segment_vertices[sg1].end(); it2++){
        //  if ((*it2)->get_wcpt().index == sg1->get_wcpt_vec().front().index) start_v = *it2;
        // if ((*it2)->get_wcpt().index == sg1->get_wcpt_vec().back().index) end_v = *it2;
        //}
        if (start_v == 0 || end_v == 0) std::cout << "Error in finding vertices for a sgement" << std::endl;

        // std::cout << sqrt(pow(start_v->get_wcpt().x - break_wcp.x,2)+pow(start_v->get_wcpt().y - break_wcp.y,2) +
        // pow(start_v->get_wcpt().z - break_wcp.z,2))/units::cm << " " << sqrt(pow(end_v->get_wcpt().x -
        // break_wcp.x,2)+pow(end_v->get_wcpt().y - break_wcp.y,2) + pow(end_v->get_wcpt().z - break_wcp.z,2))/units::cm
        // << std::endl;
        if (sqrt(pow(start_v->get_wcpt().x - break_wcp.x, 2) + pow(start_v->get_wcpt().y - break_wcp.y, 2) +
                 pow(start_v->get_wcpt().z - break_wcp.z, 2)) < 0.9 * units::cm) {
            v1 = start_v;
        }
        else if (sqrt(pow(end_v->get_wcpt().x - break_wcp.x, 2) + pow(end_v->get_wcpt().y - break_wcp.y, 2) +
                      pow(end_v->get_wcpt().z - break_wcp.z, 2)) < 0.9 * units::cm) {
            v1 = end_v;
        }
        else {
            std::list<WCP::WCPointCloud<double>::WCPoint> wcps_list1;
            std::list<WCP::WCPointCloud<double>::WCPoint> wcps_list2;
            // std::cout << start_v->get_wcpt().index << " " << break_wcp.index << " " << end_v->get_wcpt().index <<
            // std::endl;
            temp_cluster->proto_break_tracks(start_v->get_wcpt(), break_wcp, end_v->get_wcpt(), wcps_list1, wcps_list2,
                                             true);
            //     std::cout << "xin " << wcps_list1.size() << " " << wcps_list2.size() << std::endl;

            v1 = new WCPPID::ProtoVertex(acc_vertex_id, break_wcp, temp_cluster->get_cluster_id());
            acc_vertex_id++;
            WCPPID::ProtoSegment *sg2 =
                new WCPPID::ProtoSegment(acc_segment_id, wcps_list1, temp_cluster->get_cluster_id());
            acc_segment_id++;
            WCPPID::ProtoSegment *sg3 =
                new WCPPID::ProtoSegment(acc_segment_id, wcps_list2, temp_cluster->get_cluster_id());
            acc_segment_id++;

            //     std::cout << "Other: " << sg1->get_id() << " " << sg2->get_id() << " " << sg3->get_id() << std::endl;
            //	  std::cout << start_v->get_wcpt().index << " " << break_wcp.index << " " << end_v->get_wcpt().index <<
            //" " << wcps_list1.size() << " " << wcps_list2.size() << std::endl; std::cout << map_vertex_segments.size()
            // << " " << map_segment_vertices.size() << std::endl;
            add_proto_connection(start_v, sg2, temp_cluster);
            add_proto_connection(v1, sg2, temp_cluster);
            add_proto_connection(v1, sg3, temp_cluster);
            add_proto_connection(end_v, sg3, temp_cluster);
            del_proto_segment(sg1);
        }
    }
    else {
        v1 = new WCPPID::ProtoVertex(acc_vertex_id, wcp, temp_cluster->get_cluster_id());
        acc_vertex_id++;
    }

    return v1;
}

bool WCPPID::NeutrinoID::modify_segment_isochronous(WCPPID::ProtoSegment *sg1, WCPPID::ProtoVertex *v1,
                                                    WCPPID::ProtoSegment *sg, WCPPID::ProtoVertex *v2,
                                                    WCPPID::PR3DCluster *temp_cluster, double dis_cut, double angle_cut,
                                                    double extend_cut)
{
    bool flag = false;

    TVector3 dir1 = sg->cal_dir_3vector(v1->get_fit_pt(), extend_cut) * (-1);
    TVector3 drift_dir(1, 0, 0);
    //  std::cout << fabs(drift_dir.Angle(dir1)/3.1415926*180.-90) << std::endl;
    //  if (fabs(drift_dir.Angle(dir1)/3.1415926*180.-90)<5)
    //  dir1 = sg->cal_dir_3vector(v1->get_fit_pt(), 30*units::cm) * (-1);
    if (dir1.X() == 0) return flag;

    PointVector &pts = sg1->get_point_vec();
    WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
    WCP::WCPointCloud<double>::WCPoint vtx_new_wcp;

    for (size_t i = 0; i != pts.size(); i++) {
        TVector3 dir(pts.at(i).x - v1->get_fit_pt().x, pts.at(i).y - v1->get_fit_pt().y,
                     pts.at(i).z - v1->get_fit_pt().z);

        if (dir.Mag() > dis_cut || fabs(drift_dir.Angle(dir) / 3.1415926 * 180. - 90.) >= angle_cut) continue;

        Point test_p = v1->get_fit_pt();
        test_p.x += pts.at(i).x - v1->get_fit_pt().x;
        test_p.y += dir1.Y() / dir1.X() * (pts.at(i).x - v1->get_fit_pt().x);
        test_p.z += dir1.Z() / dir1.X() * (pts.at(i).x - v1->get_fit_pt().x);
        vtx_new_wcp = pcloud->get_closest_wcpoint(test_p);

        double tmp_dis = sqrt(pow(vtx_new_wcp.x - v1->get_fit_pt().x, 2) + pow(vtx_new_wcp.y - v1->get_fit_pt().y, 2) +
                              pow(vtx_new_wcp.z - v1->get_fit_pt().z, 2));

        // std::cout << dir.Mag()/units::cm << " " << fabs(drift_dir.Angle(dir)/3.1415926*180.-90.) << " " <<
        // tmp_dis/units::cm << " " << test_p << " " << v1->get_fit_pt() << " " <<
        // fabs(drift_dir.Angle(dir1)/3.1415926*180.-90) << std::endl;

        if (tmp_dis > 5 * units::cm) continue;

        // check connectivity between vtx_new_wcp and the vtx one ...
        double step_size = 0.6 * units::cm;
        Point start_p = pts.at(i);
        Point end_p(vtx_new_wcp.x, vtx_new_wcp.y, vtx_new_wcp.z);
        int ncount = std::round(
            sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) / step_size);
        int n_bad = 0;
        for (int i = 1; i < ncount; i++) {
            Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i, start_p.y + (end_p.y - start_p.y) / ncount * i,
                         start_p.z + (end_p.z - start_p.z) / ncount * i);
            if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
        }
        //    std::cout << n_bad << std::endl;
        if (n_bad == 0) {
            flag = true;
            break;
        }
    }

    if (!flag) return flag;

    // modify the new segment ...
    v1->set_wcpt(vtx_new_wcp);
    temp_cluster->dijkstra_shortest_paths(vtx_new_wcp, 2);
    temp_cluster->cal_shortest_path(v2->get_wcpt(), 2);
    {
        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcpt_vec = sg->get_wcpt_vec();
        wcpt_vec.clear();
        wcpt_vec.reserve(temp_cluster->get_path_wcps().size());
        std::copy(std::begin(temp_cluster->get_path_wcps()), std::end(temp_cluster->get_path_wcps()),
                  std::back_inserter(wcpt_vec));
    }
    add_proto_connection(v1, sg, temp_cluster);
    add_proto_connection(v2, sg, temp_cluster);

    // create two new segments
    auto pair_vertices = find_vertices(sg1);
    {
        temp_cluster->cal_shortest_path(pair_vertices.first->get_wcpt(), 2);
        ProtoSegment *sg2 =
            new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
        acc_segment_id++;

        add_proto_connection(pair_vertices.first, sg2, temp_cluster);
        add_proto_connection(v1, sg2, temp_cluster);
    }
    {
        temp_cluster->cal_shortest_path(pair_vertices.second->get_wcpt(), 2);
        ProtoSegment *sg2 =
            new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
        acc_segment_id++;

        add_proto_connection(pair_vertices.second, sg2, temp_cluster);
        add_proto_connection(v1, sg2, temp_cluster);
    }
    del_proto_segment(sg1);

    std::cout << "Modify semgnet for adding a segment in isochronous case" << std::endl;

    return flag;
}

bool WCPPID::NeutrinoID::modify_vertex_isochronous(WCPPID::ProtoVertex *vtx, WCPPID::ProtoVertex *v1,
                                                   WCPPID::ProtoSegment *sg, WCPPID::ProtoVertex *v2,
                                                   WCPPID::PR3DCluster *temp_cluster)
{
    bool flag = false;

    TVector3 dir = sg->cal_dir_3vector(v1->get_fit_pt(), 15 * units::cm) * (-1);
    if (dir.X() == 0) return flag;

    Point test_p = v1->get_fit_pt();
    test_p.x += vtx->get_fit_pt().x - v1->get_fit_pt().x;
    test_p.y += dir.Y() / dir.X() * (vtx->get_fit_pt().x - v1->get_fit_pt().x);
    test_p.z += dir.Z() / dir.X() * (vtx->get_fit_pt().x - v1->get_fit_pt().x);

    WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
    WCP::WCPointCloud<double>::WCPoint &vtx_new_wcp = pcloud->get_closest_wcpoint(test_p);

    double tmp_dis = sqrt(pow(vtx_new_wcp.x - v1->get_fit_pt().x, 2) + pow(vtx_new_wcp.y - v1->get_fit_pt().y, 2) +
                          pow(vtx_new_wcp.z - v1->get_fit_pt().z, 2));

    if (tmp_dis > 5 * units::cm) return flag;

    // check connectivity between vtx_new_wcp and the vtx one ...
    double step_size = 0.6 * units::cm;
    Point start_p = vtx->get_fit_pt();
    Point end_p(vtx_new_wcp.x, vtx_new_wcp.y, vtx_new_wcp.z);
    int ncount = std::round(
        sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) / step_size);
    int n_bad = 0;
    for (int i = 1; i < ncount; i++) {
        Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i, start_p.y + (end_p.y - start_p.y) / ncount * i,
                     start_p.z + (end_p.z - start_p.z) / ncount * i);
        if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
    }
    if (n_bad > 0) return flag;
    //  std::cout << tmp_dis/units::cm << " " << n_bad << std::endl;

    // Now Update everything ...
    for (auto it = map_vertex_segments[vtx].begin(); it != map_vertex_segments[vtx].end(); it++) {
        WCPPID::ProtoSegment *sg1 = *it;
        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcpt_vec = sg1->get_wcpt_vec();

        WCP::WCPointCloud<double>::WCPoint vtx_other_wcp;
        if (wcpt_vec.front().index == vtx->get_wcpt().index) {
            vtx_other_wcp = wcpt_vec.back();
        }
        else {
            vtx_other_wcp = wcpt_vec.front();
        }
        temp_cluster->dijkstra_shortest_paths(vtx_new_wcp, 2);
        temp_cluster->cal_shortest_path(vtx_other_wcp, 2);
        //  std::cout << temp_cluster->get_path_wcps().front().index << " " <<
        //  temp_cluster->get_path_wcps().back().index << " " << vtx_new_wcp.index << " " << vtx_other_wcp.index <<
        //  std::endl;
        wcpt_vec.clear();
        wcpt_vec.reserve(temp_cluster->get_path_wcps().size());
        std::copy(std::begin(temp_cluster->get_path_wcps()), std::end(temp_cluster->get_path_wcps()),
                  std::back_inserter(wcpt_vec));
        //    std::cout << sg1->get_id() << " " << sg->get_id() << std::endl;
    }
    vtx->set_wcpt(vtx_new_wcp);

    temp_cluster->dijkstra_shortest_paths(vtx_new_wcp, 2);
    temp_cluster->cal_shortest_path(v2->get_wcpt(), 2);
    {
        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcpt_vec = sg->get_wcpt_vec();
        wcpt_vec.clear();
        wcpt_vec.reserve(temp_cluster->get_path_wcps().size());
        std::copy(std::begin(temp_cluster->get_path_wcps()), std::end(temp_cluster->get_path_wcps()),
                  std::back_inserter(wcpt_vec));
    }
    delete v1;
    add_proto_connection(vtx, sg, temp_cluster);
    add_proto_connection(v2, sg, temp_cluster);
    flag = true;
    std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " shift a isochronous vertex with adding a segment "
              << sg->get_id() << std::endl;

    return flag;
}

std::tuple<WCPPID::ProtoVertex *, WCPPID::ProtoSegment *, WCP::Point> WCPPID::NeutrinoID::check_end_point(
    WCPPID::PR3DCluster *temp_cluster, WCP::PointVector &tracking_path, bool flag_front, double vtx_cut1,
    double vtx_cut2, double sg_cut1, double sg_cut2)
{
    if (tracking_path.size() < 2) std::cout << "vector size wrong!" << std::endl;
    int ncount = 5;
    Point test_p;
    if (flag_front) {
        test_p = tracking_path.front();
    }
    else {
        test_p = tracking_path.back();
    }
    WCPPID::ProtoVertex *vtx = 0;
    WCPPID::ProtoSegment *seg = 0;

    Point dir_p(0, 0, 0);
    for (int i = 0; i != ncount; i++) {
        if (flag_front) {
            if (i + 1 < tracking_path.size()) {
                dir_p.x = test_p.x - tracking_path.at(i + 1).x;
                dir_p.y = test_p.y - tracking_path.at(i + 1).y;
                dir_p.z = test_p.z - tracking_path.at(i + 1).z;
            }
            else {
                dir_p.x = test_p.x - tracking_path.back().x;
                dir_p.y = test_p.y - tracking_path.back().y;
                dir_p.z = test_p.z - tracking_path.back().z;
            }
        }
        else {
            if (tracking_path.size() >= i + 2) {
                dir_p.x = test_p.x - tracking_path.at(tracking_path.size() - 2 - i).x;
                dir_p.y = test_p.y - tracking_path.at(tracking_path.size() - 2 - i).y;
                dir_p.z = test_p.z - tracking_path.at(tracking_path.size() - 2 - i).z;
            }
            else {
                dir_p.x = test_p.x - tracking_path.front().x;
                dir_p.x = test_p.y - tracking_path.front().y;
                dir_p.x = test_p.z - tracking_path.front().z;
            }
        }
        TVector3 temp_dir(dir_p.x, dir_p.y, dir_p.z);
        if (temp_dir.Mag() == 0) continue;

        temp_dir = temp_dir.Unit();
        Line temp_l(test_p, temp_dir);

        // check vertex
        for (auto it1 = map_vertex_segments.begin(); it1 != map_vertex_segments.end(); it1++) {
            WCPPID::ProtoVertex *test_v = it1->first;
            if (test_v->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            Point p1(test_v->get_wcpt().x, test_v->get_wcpt().y, test_v->get_wcpt().z);
            Point p2 = test_v->get_fit_pt();

            double dis1 = sqrt(pow(test_p.x - p1.x, 2) + pow(test_p.y - p1.y, 2) + pow(test_p.z - p1.z, 2));
            double dis2 = temp_l.closest_dis(p1);
            double dis3 = sqrt(pow(test_p.x - p2.x, 2) + pow(test_p.y - p2.y, 2) + pow(test_p.z - p2.z, 2));
            double dis4 = temp_l.closest_dis(p2);

            //      if (dis1 < 5*units::cm && dis2 < 5*units::cm)
            //	std::cout << i << " " << test_p << " " << temp_dir.X() << " " << temp_dir.Y() << " " << temp_dir.Z() <<
            //" " << dis1/units::cm << " " << dis2/units::cm << " " << dis3/units::cm << " " << dis4/units::cm << " " <<
            //it1->second.size() << " "  << std::endl;

            if (std::max(dis1, dis2) < 5 * units::cm &&
                (std::min(dis1, dis2) < vtx_cut1 && std::max(dis1, dis2) < vtx_cut2 ||
                 std::min(dis3, dis4) < vtx_cut1 * 1.3 && std::max(dis1, dis2) < vtx_cut2 * 2 &&
                     it1->second.size() == 1)) {
                TVector3 test_dir(p1.x - test_p.x, p1.y - test_p.y, p1.z - test_p.z);
                //	std::cout << test_dir.Angle(temp_dir)/3.1415926*180. << std::endl;
                if (test_dir.Angle(temp_dir) / 3.1415926 * 180. < 90) {
                    vtx = test_v;
                    break;
                }
            }
            if (std::max(dis3, dis4) < 5 * units::cm &&
                (std::min(dis3, dis4) < vtx_cut1 && std::max(dis3, dis4) < vtx_cut2 ||
                 std::min(dis3, dis4) < vtx_cut1 * 1.3 && std::max(dis3, dis4) < vtx_cut2 * 2 &&
                     it1->second.size() == 1)) {
                TVector3 test_dir(p2.x - test_p.x, p2.y - test_p.y, p2.z - test_p.z);
                //	std::cout << test_dir.Angle(temp_dir)/3.1415926*180. << std::endl;
                if (test_dir.Angle(temp_dir) / 3.1415926 * 180. < 90) {
                    vtx = test_v;
                    break;
                }
            }
        }

        if (vtx != 0) break;
    }

    // check segment
    if (vtx == 0) {
        WCPPID::ProtoSegment *min_sg = 0;
        Point min_point(0, 0, 0);
        double min_dis = 1e9;

        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            if (it->first->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            std::pair<double, WCP::Point> results = it->first->get_closest_point(test_p);
            if (results.first < sg_cut1) {
                PointVector &points = it->first->get_point_vec();

                Point dir_p(0, 0, 0);
                for (int i = 0; i != ncount; i++) {
                    if (flag_front) {
                        if (i + 1 < tracking_path.size()) {
                            dir_p.x = test_p.x - tracking_path.at(i + 1).x;
                            dir_p.y = test_p.y - tracking_path.at(i + 1).y;
                            dir_p.z = test_p.z - tracking_path.at(i + 1).z;
                        }
                        else {
                            dir_p.x = test_p.x - tracking_path.back().x;
                            dir_p.y = test_p.y - tracking_path.back().y;
                            dir_p.z = test_p.z - tracking_path.back().z;
                        }
                    }
                    else {
                        if (tracking_path.size() >= i + 2) {
                            dir_p.x = test_p.x - tracking_path.at(tracking_path.size() - 2 - i).x;
                            dir_p.y = test_p.y - tracking_path.at(tracking_path.size() - 2 - i).y;
                            dir_p.z = test_p.z - tracking_path.at(tracking_path.size() - 2 - i).z;
                        }
                        else {
                            dir_p.x = test_p.x - tracking_path.front().x;
                            dir_p.x = test_p.y - tracking_path.front().y;
                            dir_p.x = test_p.z - tracking_path.front().z;
                        }
                    }
                    TVector3 temp_dir(dir_p.x, dir_p.y, dir_p.z);
                    if (temp_dir.Mag() == 0) continue;
                    temp_dir = temp_dir.Unit();
                    Line temp_l(test_p, temp_dir);

                    for (size_t i = 0; i != points.size(); i++) {
                        double dis1 = temp_l.closest_dis(points.at(i));
                        if (dis1 < sg_cut2) {
                            TVector3 test_dir(points.at(i).x - test_p.x, points.at(i).y - test_p.y,
                                              points.at(i).z - test_p.z);
                            //	      std::cout << test_dir.Angle(temp_dir)/3.1415926*180. << " " <<
                            //test_dir.Mag()/units::cm << " " << dis1/units::cm << std::endl;
                            dis1 = sqrt(pow(dis1, 2) + pow(test_dir.Mag() / 4., 2));
                            if (test_dir.Angle(temp_dir) / 3.1415926 * 180. < 90 && dis1 < min_dis) {
                                min_dis = dis1;
                                min_point = points.at(i);
                                min_sg = it->first;
                            }
                        }
                    }
                }
            }
        }

        if (min_sg != 0) {
            seg = min_sg;
            test_p = min_point;
        }
    }

    // return ...
    return std::make_tuple(vtx, seg, test_p);
}

bool WCPPID::NeutrinoID::del_proto_connection(WCPPID::ProtoVertex *pv, WCPPID::ProtoSegment *ps)
{
    auto it1 = map_vertex_segments.find(pv);
    auto it2 = map_segment_vertices.find(ps);
    if (it1 == map_vertex_segments.end() || it2 == map_segment_vertices.end()) return false;

    if (it1 != map_vertex_segments.end()) {
        auto it3 = (it1->second).find(ps);
        if (it3 == (it1->second).end()) return false;
        (it1->second).erase(ps);
    }
    if (it2 != map_segment_vertices.end()) {
        auto it3 = (it2->second).find(pv);
        if (it3 == (it2->second).end()) return false;
        (it2->second).erase(pv);
    }
    return true;
}

bool WCPPID::NeutrinoID::add_proto_connection(WCPPID::ProtoVertex *pv, WCPPID::ProtoSegment *ps,
                                              WCPPID::PR3DCluster *cluster)
{
    if (pv->get_wcpt().index != ps->get_wcpt_vec().front().index &&
        pv->get_wcpt().index != ps->get_wcpt_vec().back().index) {
        std::cout << "Error! Vertex and Segment does not match " << pv->get_wcpt().index << " "
                  << ps->get_wcpt_vec().front().index << " " << ps->get_wcpt_vec().back().index << std::endl;
        return false;
    }

    if (map_vertex_cluster.find(pv) == map_vertex_cluster.end()) proto_vertices.push_back(pv);

    map_vertex_cluster[pv] = cluster;
    if (map_cluster_vertices.find(cluster) != map_cluster_vertices.end()) {
        map_cluster_vertices[cluster].insert(pv);
    }
    else {
        ProtoVertexSet temp_vertices;
        temp_vertices.insert(pv);
        map_cluster_vertices[cluster] = temp_vertices;
    }

    if (map_segment_cluster.find(ps) == map_segment_cluster.end()) proto_segments.push_back(ps);

    map_segment_cluster[ps] = cluster;
    if (map_cluster_segments.find(cluster) != map_cluster_segments.end()) {
        map_cluster_segments[cluster].insert(ps);
    }
    else {
        ProtoSegmentSet temp_segments;
        temp_segments.insert(ps);
        map_cluster_segments[cluster] = temp_segments;
    }

    if (map_vertex_segments.find(pv) != map_vertex_segments.end()) {
        map_vertex_segments[pv].insert(ps);
    }
    else {
        ProtoSegmentSet temp_segments;
        temp_segments.insert(ps);
        map_vertex_segments[pv] = temp_segments;
    }

    if (map_segment_vertices.find(ps) != map_segment_vertices.end()) {
        map_segment_vertices[ps].insert(pv);
    }
    else {
        ProtoVertexSet temp_vertices;
        map_segment_vertices[ps] = temp_vertices;
        map_segment_vertices[ps].insert(pv);
    }

    return true;
}

bool WCPPID::NeutrinoID::del_proto_vertex(WCPPID::ProtoVertex *pv)
{
    if (map_vertex_segments.find(pv) != map_vertex_segments.end()) {
        // overall
        for (auto it = map_vertex_segments[pv].begin(); it != map_vertex_segments[pv].end();
             it++) {  // loop very semeng *it
            map_segment_vertices[*it].erase(map_segment_vertices[*it].find(pv));
        }
        map_vertex_segments.erase(pv);
        // map between cluster and vertices
        if (map_vertex_cluster.find(pv) != map_vertex_cluster.end()) {
            if (map_cluster_vertices.find(map_vertex_cluster[pv]) != map_cluster_vertices.end())
                map_cluster_vertices[map_vertex_cluster[pv]].erase(
                    map_cluster_vertices[map_vertex_cluster[pv]].find(pv));
            map_vertex_cluster.erase(pv);
        }

        return true;
    }
    else {
        return false;
    }
}

bool WCPPID::NeutrinoID::del_proto_segment(WCPPID::ProtoSegment *ps)
{
    if (map_segment_vertices.find(ps) != map_segment_vertices.end()) {
        // overall
        //    proto_segments.erase(proto_segments.find(ps));
        // map between segment and vertex
        for (auto it = map_segment_vertices[ps].begin(); it != map_segment_vertices[ps].end(); it++) {
            map_vertex_segments[*it].erase(map_vertex_segments[*it].find(ps));
        }
        map_segment_vertices.erase(ps);
        // map between cluster and segment
        if (map_segment_cluster.find(ps) != map_segment_cluster.end()) {
            if (map_cluster_segments.find(map_segment_cluster[ps]) != map_cluster_segments.end())
                map_cluster_segments[map_segment_cluster[ps]].erase(
                    map_cluster_segments[map_segment_cluster[ps]].find(ps));
            map_segment_cluster.erase(ps);
        }
        return true;
    }
    else {
        return false;
    }
}

void WCPPID::NeutrinoID::examine_segment(WCPPID::PR3DCluster *temp_cluster)
{
    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;
        if (sg->get_length() > 4 * units::cm) continue;

        auto pair_vertices = find_vertices(sg);
        if (map_vertex_segments[pair_vertices.first].size() < 2 || map_vertex_segments[pair_vertices.second].size() < 2)
            continue;

        //    std::cout << sg->get_id () << " " << sg->get_length()/units::cm << std::endl;

        std::vector<WCPPID::ProtoVertex *> cand_vertices;
        cand_vertices.push_back(pair_vertices.first);
        cand_vertices.push_back(pair_vertices.second);

        for (size_t i = 0; i != 2; i++) {
            double max_angle = 0;
            double min_angle = 180;
            TVector3 dir1 = sg->cal_dir_3vector(cand_vertices.at(i)->get_fit_pt(), 2 * units::cm);
            for (auto it1 = map_vertex_segments[cand_vertices.at(i)].begin();
                 it1 != map_vertex_segments[cand_vertices.at(i)].end(); it1++) {
                WCPPID::ProtoSegment *sg1 = (*it1);
                if (sg1 == sg) continue;
                TVector3 dir3 = sg1->cal_dir_3vector(cand_vertices.at(i)->get_fit_pt(), 2 * units::cm);
                double angle = dir1.Angle(dir3) / 3.1415926 * 180.;
                if (max_angle < angle) max_angle = angle;
                if (min_angle > angle) min_angle = angle;
            }
            // std::cout << i << " " << max_angle << " " << min_angle << std::endl;

            if (max_angle > 150 && min_angle > 105) {
                // start examination ...
                crawl_segment(sg, cand_vertices.at(i), temp_cluster);
            }
        }
    }

    {
        std::set<WCPPID::ProtoVertex *> all_vertices;
        for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
            WCPPID::ProtoVertex *vtx = it->first;
            if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            all_vertices.insert(vtx);
        }

        bool flag_merge = true;
        while (flag_merge) {
            flag_merge = false;
            WCPPID::ProtoVertex *vtx1 = 0, *vtx2 = 0;
            for (auto it1 = all_vertices.begin(); it1 != all_vertices.end(); it1++) {
                vtx1 = *it1;
                for (auto it2 = it1; it2 != all_vertices.end(); it2++) {
                    vtx2 = *it2;
                    if (vtx1 != vtx2 && vtx1->get_wcpt().index == vtx2->get_wcpt().index) {
                        // merge vtx 2 to vtx1 ...
                        std::vector<WCPPID::ProtoSegment *> to_be_removed_segments;
                        for (auto it = map_vertex_segments[vtx2].begin(); it != map_vertex_segments[vtx2].end(); it++) {
                            WCPPID::ProtoSegment *sg = *it;
                            if (map_vertex_segments[vtx1].find(sg) != map_vertex_segments[vtx1].end())
                                to_be_removed_segments.push_back(sg);
                            else
                                add_proto_connection(vtx1, sg, temp_cluster);
                        }
                        del_proto_vertex(vtx2);
                        for (auto it = to_be_removed_segments.begin(); it != to_be_removed_segments.end(); it++) {
                            del_proto_segment(*it);
                        }
                        all_vertices.erase(vtx2);
                        flag_merge = true;
                        break;
                    }
                }
                if (flag_merge) break;
            }
        }
    }

    std::set<WCPPID::ProtoSegment *> segments_to_be_removed;
    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        WCPPID::ProtoVertex *vtx = it->first;
        if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        std::vector<WCPPID::ProtoSegment *> tmp_segments(it->second.begin(), it->second.end());
        for (size_t i = 0; i != tmp_segments.size(); i++) {
            auto it1 = find_vertices(tmp_segments.at(i));
            for (size_t j = i + 1; j < tmp_segments.size(); j++) {
                auto it2 = find_vertices(tmp_segments.at(j));
                if (it1.first->get_wcpt().index == it2.first->get_wcpt().index &&
                        it1.second->get_wcpt().index == it2.second->get_wcpt().index ||
                    it1.first->get_wcpt().index == it2.second->get_wcpt().index &&
                        it1.second->get_wcpt().index == it2.first->get_wcpt().index) {
                    //	  std::cout << i << " " << j << " " << tmp_segments.at(j)->get_id() << " " <<
                    //it1.first->get_id() << " " << it1.second->get_id() << " " << it2.first->get_id() << " " <<
                    //it1.first->get_wcpt().index << " " << it1.second->get_wcpt().index << " " <<
                    //it2.first->get_wcpt().index << " " << it2.second->get_wcpt().index << " " << it2.second->get_id()
                    //<< std::endl;
                    segments_to_be_removed.insert(tmp_segments.at(j));
                }
            }
        }
    }
    for (auto it = segments_to_be_removed.begin(); it != segments_to_be_removed.end(); it++) {
        del_proto_segment(*it);
    }
    std::set<WCPPID::ProtoVertex *> vertices_to_be_removed;
    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        if (it->second.size() == 0) vertices_to_be_removed.insert(it->first);
    }
    for (auto it = vertices_to_be_removed.begin(); it != vertices_to_be_removed.end(); it++) {
        del_proto_vertex(*it);
    }
}

bool WCPPID::NeutrinoID::crawl_segment(WCPPID::ProtoSegment *curr_sg, WCPPID::ProtoVertex *v1,
                                       WCPPID::PR3DCluster *temp_cluster)
{
    bool flag = false;

    if (curr_sg->get_cluster_id() != v1->get_cluster_id() ||
        curr_sg->get_cluster_id() != temp_cluster->get_cluster_id())
        return flag;

    std::map<WCPPID::ProtoSegment *, Point> map_segment_point;
    for (auto it = map_vertex_segments[v1].begin(); it != map_vertex_segments[v1].end(); it++) {
        WCPPID::ProtoSegment *sg = *it;
        if (sg == curr_sg) continue;
        PointVector &pts = sg->get_point_vec();
        Point min_point = pts.front();
        double min_dis = 1e9;
        for (size_t i = 0; i != pts.size(); i++) {
            double dis = fabs(sqrt(pow(pts.at(i).x - v1->get_fit_pt().x, 2) + pow(pts.at(i).y - v1->get_fit_pt().y, 2) +
                                   pow(pts.at(i).z - v1->get_fit_pt().z, 2)) -
                              3 * units::cm);
            if (dis < min_dis) {
                min_dis = dis;
                min_point = pts.at(i);
            }
        }
        map_segment_point[sg] = min_point;
    }

    PointVector &pts = curr_sg->get_point_vec();
    bool flag_start;
    if (v1->get_wcpt().index == curr_sg->get_wcpt_vec().front().index) {
        flag_start = true;
    }
    else if (v1->get_wcpt().index == curr_sg->get_wcpt_vec().back().index) {
        flag_start = false;
    }
    PointVector pts_to_be_tested;
    if (flag_start) {
        for (size_t i = 1; i + 1 < pts.size(); i++) {
            pts_to_be_tested.push_back(pts.at(i));
        }
    }
    else {
        for (int i = int(pts.size()) - 1; i > 0; i--) {
            pts_to_be_tested.push_back(pts.at(i));
        }
    }

    if (pts_to_be_tested.size() > 0) {
        //  std::cout << pts_to_be_tested.size() << std::endl;
        double step_size = 0.3 * units::cm;
        int max_bin = -1;
        for (size_t i = 0; i != pts_to_be_tested.size(); i++) {
            int n_bad = 0;
            Point end_p = pts_to_be_tested.at(i);
            for (auto it = map_segment_point.begin(); it != map_segment_point.end(); it++) {
                Point start_p = it->second;
                int ncount = std::round(
                    sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) /
                    step_size);
                for (int j = 1; j < ncount; j++) {
                    Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * j,
                                 start_p.y + (end_p.y - start_p.y) / ncount * j,
                                 start_p.z + (end_p.z - start_p.z) / ncount * j);
                    if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
                }
            }
            if (n_bad == 0) max_bin = i;
        }

        WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
        WCP::WCPointCloud<double> &cloud = pcloud->get_cloud();

        while (max_bin >= 0) {
            // Now change the segment and vertex ...
            WCP::WCPointCloud<double>::WCPoint &vtx_new_wcp = pcloud->get_closest_wcpoint(pts_to_be_tested.at(max_bin));
            if (flag_start && vtx_new_wcp.index == curr_sg->get_wcpt_vec().back().index ||
                (!flag_start) && vtx_new_wcp.index == curr_sg->get_wcpt_vec().front().index) {
                max_bin--;
                continue;
            }
            if (vtx_new_wcp.index == v1->get_wcpt().index) break;  // current wcpt ...

            //  std::cout << vtx_new_wcp.index << " " << v1->get_wcpt().index << " " << flag_start << " " <<
            //  curr_sg->get_wcpt_vec().back().index << " " << curr_sg->get_wcpt_vec().front().index << std::endl;

            // std::cout << vtx_new_wcp.index << std::endl;
            // update curr_sg ...
            {
                std::list<WCP::WCPointCloud<double>::WCPoint> new_list;
                std::vector<WCP::WCPointCloud<double>::WCPoint> &wcpt_vec = curr_sg->get_wcpt_vec();
                if (flag_start) {
                    double dis_limit = sqrt(pow(vtx_new_wcp.x - curr_sg->get_wcpt_vec().back().x, 2) +
                                            pow(vtx_new_wcp.y - curr_sg->get_wcpt_vec().back().y, 2) +
                                            pow(vtx_new_wcp.z - curr_sg->get_wcpt_vec().back().z, 2));
                    for (auto it = wcpt_vec.rbegin(); it != wcpt_vec.rend(); it++) {
                        double dis = sqrt(pow((*it).x - curr_sg->get_wcpt_vec().back().x, 2) +
                                          pow((*it).y - curr_sg->get_wcpt_vec().back().y, 2) +
                                          pow((*it).z - curr_sg->get_wcpt_vec().back().z, 2));
                        if (dis < dis_limit) new_list.push_back(*it);
                    }
                    if (new_list.size() > 1) new_list.pop_back();
                    new_list.push_back(vtx_new_wcp);
                }
                else {
                    double dis_limit = sqrt(pow(vtx_new_wcp.x - curr_sg->get_wcpt_vec().front().x, 2) +
                                            pow(vtx_new_wcp.y - curr_sg->get_wcpt_vec().front().y, 2) +
                                            pow(vtx_new_wcp.z - curr_sg->get_wcpt_vec().front().z, 2));

                    for (auto it = wcpt_vec.begin(); it != wcpt_vec.end(); it++) {
                        double dis = sqrt(pow((*it).x - curr_sg->get_wcpt_vec().front().x, 2) +
                                          pow((*it).y - curr_sg->get_wcpt_vec().front().y, 2) +
                                          pow((*it).z - curr_sg->get_wcpt_vec().front().z, 2));
                        if (dis < dis_limit) new_list.push_back(*it);
                    }
                    if (new_list.size() > 1) new_list.pop_back();
                    new_list.push_back(vtx_new_wcp);
                }
                std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
                if (flag_start) {
                    for (auto it1 = new_list.rbegin(); it1 != new_list.rend(); it1++) {
                        old_list.push_back(*it1);
                    }
                }
                else {
                    for (auto it1 = new_list.begin(); it1 != new_list.end(); it1++) {
                        old_list.push_back(*it1);
                    }
                }
                wcpt_vec.clear();
                wcpt_vec.reserve(old_list.size());
                std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(wcpt_vec));
                // std::cout << new_list.front().index << " " << new_list.back().index << std::endl;
                // for (auto it = new_list.begin(); it != new_list.end(); it++){
                // std::cout << (*it).index << std::endl;
                //}
            }

            // update the rest of segments ...
            for (auto it = map_segment_point.begin(); it != map_segment_point.end(); it++) {
                WCPPID::ProtoSegment *sg = it->first;
                std::vector<WCP::WCPointCloud<double>::WCPoint> &vec_wcps = sg->get_wcpt_vec();
                bool flag_front = false;
                if (vec_wcps.front().index == v1->get_wcpt().index) flag_front = true;
                Point min_p = it->second;

                // find min_wcp ...
                WCP::WCPointCloud<double>::WCPoint min_wcp;
                double min_dis = 1e9;
                for (size_t j = 0; j != vec_wcps.size(); j++) {
                    double dis = sqrt(pow(min_p.x - vec_wcps.at(j).x, 2) + pow(min_p.y - vec_wcps.at(j).y, 2) +
                                      pow(min_p.z - vec_wcps.at(j).z, 2));
                    if (dis < min_dis) {
                        min_wcp = vec_wcps.at(j);
                        min_dis = dis;
                    }
                }

                std::list<WCP::WCPointCloud<double>::WCPoint> new_list;
                new_list.push_back(vtx_new_wcp);
                {
                    double dis_step = 1.0 * units::cm;
                    int ncount = std::round(sqrt(pow(vtx_new_wcp.x - min_wcp.x, 2) + pow(vtx_new_wcp.y - min_wcp.y, 2) +
                                                 pow(vtx_new_wcp.z - min_wcp.z, 2)) /
                                            dis_step);
                    if (ncount < 2) ncount = 2;
                    for (int qx = 1; qx < ncount; qx++) {
                        Point tmp_p(vtx_new_wcp.x + (min_wcp.x - vtx_new_wcp.x) / ncount * qx,
                                    vtx_new_wcp.y + (min_wcp.y - vtx_new_wcp.y) / ncount * qx,
                                    vtx_new_wcp.z + (min_wcp.z - vtx_new_wcp.z) / ncount * qx);
                        WCP::WCPointCloud<double>::WCPoint &tmp_wcp = pcloud->get_closest_wcpoint(tmp_p);
                        // std::cout << qx << " " << sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) +
                        // pow(tmp_wcp.z - tmp_p.z,2))/units::cm << std::endl;
                        if (sqrt(pow(tmp_wcp.x - tmp_p.x, 2) + pow(tmp_wcp.y - tmp_p.y, 2) +
                                 pow(tmp_wcp.z - tmp_p.z, 2)) > 0.3 * units::cm)
                            continue;  // too large ...
                        if (tmp_wcp.index != new_list.back().index && tmp_wcp.index != min_wcp.index)
                            new_list.push_back(tmp_wcp);
                    }
                }
                new_list.push_back(min_wcp);

                std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
                std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));
                // append the list back ...
                // std::cout << min_wcp.index << " " << temp_cluster->get_path_wcps().size() << std::endl;
                if (flag_front) {
                    // std::cout << "f1 " << old_list.size() << std::endl;

                    while (old_list.front().index != min_wcp.index && old_list.size() > 0) {
                        old_list.pop_front();
                    }
                    old_list.pop_front();
                    //      std::cout << "f2 " << old_list.size() << std::endl;
                    for (auto it1 = new_list.rbegin(); it1 != new_list.rend(); it1++) {
                        old_list.push_front(*it1);
                    }
                    //      std::cout << "f3 " << old_list.size() << std::endl;
                }
                else {
                    //      std::cout << "b1 " << old_list.size() << std::endl;
                    while (old_list.back().index != min_wcp.index && old_list.size() > 0) {
                        old_list.pop_back();
                    }
                    old_list.pop_back();

                    //      std::cout << "b2 " << old_list.size() << std::endl;
                    for (auto it1 = new_list.rbegin(); it1 != new_list.rend(); it1++) {
                        old_list.push_back(*it1);
                    }
                    //      std::cout << "b3 " << old_list.size() << std::endl;
                }
                vec_wcps.clear();
                vec_wcps.reserve(old_list.size());
                std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));
                // std::cout << old_list.front().index << " " << old_list.back().index << " " << vec_wcps.front().index
                // << " " << vec_wcps.back().index << std::endl; for (auto it1 = old_list.begin(); it1 != old_list.end();
                // it1++){
                // std::cout << (*it1).index << std::endl;
                //}
            }
            // update vertex ...
            v1->set_wcpt(vtx_new_wcp);

            /* std::cout << v1->get_wcpt().index << std::endl; */
            /* for (auto it = map_vertex_segments[v1].begin(); it != map_vertex_segments[v1].end(); it++){ */
            /* 	std::cout << (*it)->get_wcpt_vec().front().index << " " << (*it)->get_wcpt_vec().back().index <<
             * std::endl; */
            /* } */

            temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                            flash_time * units::microsecond, true, true, true);

            //      std::cout << "haha " << std::endl;

            flag = true;
            break;
        }
    }

    return flag;
}

void WCPPID::NeutrinoID::examine_vertices(WCPPID::PR3DCluster *temp_cluster)
{
    bool flag_continue = true;
    while (flag_continue) {
        flag_continue = false;

        //    std::cout << "haha0 " << " " << flag_continue << std::endl;
        examine_segment(temp_cluster);

        //    std::cout << "haha1 " << " " << flag_continue << std::endl;
        // merge vertex if the kink is not at right location
        flag_continue = flag_continue || examine_vertices_1(temp_cluster);

        //    std::cout << "haha2 " << " " << flag_continue << std::endl;
        if (find_vertices(temp_cluster).size() > 2)
            // merge vertices if they are too close ...
            flag_continue = flag_continue || examine_vertices_2(temp_cluster);

        // merge vertices if they are reasonable close ...
        flag_continue = flag_continue || examine_vertices_4(temp_cluster);

        //    std::cout << "haha4 " << " " << flag_continue << std::endl;
    }
}

// examine if the initial vertices are not at the extreme location ...
void WCPPID::NeutrinoID::examine_vertices_3()
{
    // examine main_cluster_initial_pair_vertices ...
    std::vector<WCPPID::ProtoVertex *> temp_vertices;
    if (main_cluster_initial_pair_vertices.first != 0)
        temp_vertices.push_back(main_cluster_initial_pair_vertices.first);
    if (main_cluster_initial_pair_vertices.second != 0)
        temp_vertices.push_back(main_cluster_initial_pair_vertices.second);
    bool flag_refit = false;
    for (size_t i = 0; i != temp_vertices.size(); i++) {
        WCPPID::ProtoVertex *vtx = temp_vertices.at(i);
        auto it = map_vertex_segments.find(vtx);
        if (it == map_vertex_segments.end()) continue;
        if (it->second.size() > 1) continue;  // more than one track ...
        WCPPID::ProtoSegment *sg = *(it->second.begin());

        bool flag_start;
        if (sg->get_wcpt_vec().front().index == vtx->get_wcpt().index)
            flag_start = true;
        else if (sg->get_wcpt_vec().back().index == vtx->get_wcpt().index)
            flag_start = false;

        std::vector<WCP::WCPointCloud<double>::WCPoint> &wcps = sg->get_wcpt_vec();

        WCP::WCPointCloud<double>::WCPoint wcp2;
        if (flag_start)
            wcp2 = wcps.back();
        else
            wcp2 = wcps.front();

        auto wcp1 = main_cluster->get_local_extension(vtx->get_wcpt(), 2);

        if (wcp1.index == vtx->get_wcpt().index || wcp1.index == wcp2.index) continue;

        if (flag_start) {
            main_cluster->dijkstra_shortest_paths(wcp1, 2);
            main_cluster->cal_shortest_path(wcp2, 2);
        }
        else {
            main_cluster->dijkstra_shortest_paths(wcp2, 2);
            main_cluster->cal_shortest_path(wcp1, 2);
        }
        if (main_cluster->get_path_wcps().size() < wcps.size() * 2) {
            vtx->set_wcpt(wcp1);
            wcps.clear();
            for (auto it = main_cluster->get_path_wcps().begin(); it != main_cluster->get_path_wcps().end(); it++) {
                wcps.push_back(*it);
            }

            flag_refit = true;
        }

        //    std::cout << wcps.size() << " " << main_cluster->get_path_wcps().size() << std::endl;
    }
    if (flag_refit) {
        /* for (auto it5 = map_segment_vertices.begin(); it5 != map_segment_vertices.end(); it5++){ */
        /*   std::cout << it5->second.size() << " " << it5->first->get_wcpt_vec().front().index << " " <<
         * it5->first->get_wcpt_vec().back().index << std::endl; */
        /* } */
        /* for (auto it5 = map_vertex_segments.begin(); it5 != map_vertex_segments.end(); it5++){ */
        /*   std::cout << it5->first->get_wcpt().index << " " << it5->second.size() << std::endl; */
        /* } */
        main_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                        flash_time * units::microsecond, true, true, true);
    }

    std::set<WCPPID::ProtoSegment *> segments_to_be_removed;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        WCPPID::ProtoSegment *sg = it->first;
        if (sg->get_cluster_id() != main_cluster->get_cluster_id()) continue;
        auto pair_vertices = find_vertices(sg);
        //    std::cout << sg->get_id() << " " << it->second.size() << " " << pair_vertices.first << " " <<
        //    pair_vertices.second << std::endl; std::cout << sg->get_id() << " " << sg->get_direct_length()/units::cm
        //    << std::endl;
        if ((map_vertex_segments[pair_vertices.first].size() == 1 ||
             map_vertex_segments[pair_vertices.second].size() == 1) &&
            sg->get_direct_length() < 5 * units::cm) {
            PointVector &pts = sg->get_point_vec();
            int num_unique = 0;
            for (size_t i = 0; i != pts.size(); i++) {
                double min_u = 1e9;
                double min_v = 1e9;
                double min_w = 1e9;
                for (auto it1 = map_segment_vertices.begin(); it1 != map_segment_vertices.end(); it1++) {
                    WCPPID::ProtoSegment *sg1 = it1->first;
                    if (sg == sg1) continue;
                    std::tuple<double, double, double> results = sg1->get_closest_2d_dis(pts.at(i));
                    if (std::get<0>(results) < min_u) min_u = std::get<0>(results);
                    if (std::get<1>(results) < min_v) min_v = std::get<1>(results);
                    if (std::get<2>(results) < min_w) min_w = std::get<2>(results);
                }
                if (min_u > 0.6 * units::cm || min_v > 0.6 * units::cm || min_w > 0.6 * units::cm) num_unique++;
                //	if (min_u > 0.6*units::cm
                //	std::cout << sg->get_id() << " " << i << " " << min_u/units::cm << " " << min_v/units::cm << " "
                //<< min_w/units::cm << std::endl;
            }
            if (num_unique == 0) {
                segments_to_be_removed.insert(sg);
            }
        }
    }

    std::set<WCPPID::ProtoVertex *> can_vertices;

    for (auto it = segments_to_be_removed.begin(); it != segments_to_be_removed.end(); it++) {
        auto pair_vertices = find_vertices(*it);
        if (map_vertex_segments[pair_vertices.first].size() > 1) can_vertices.insert(pair_vertices.first);
        if (map_vertex_segments[pair_vertices.second].size() > 1) can_vertices.insert(pair_vertices.second);
        del_proto_segment(*it);
    }
    bool flag_cont = true;
    while (flag_cont) {
        flag_cont = false;
        for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
            if (it->second.size() == 0) {
                del_proto_vertex(it->first);
                flag_cont = true;
                break;
            }
        }
    }
    // std::cout << can_vertices.size() << std::endl;
    for (auto it = can_vertices.begin(); it != can_vertices.end(); it++) {
        examine_structure_4(*it, main_cluster);
    }

    if (segments_to_be_removed.size() > 0)
        main_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                        flash_time * units::microsecond, true, true, true);
}

bool WCPPID::NeutrinoID::examine_vertices_2(WCPPID::PR3DCluster *temp_cluster)
{
    // search for merge ...
    bool flag_continue = false;

    // std::map<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> map_vertex_replace;
    WCPPID::ProtoVertex *v1 = 0;
    WCPPID::ProtoVertex *v2 = 0;
    WCPPID::ProtoSegment *sg = 0;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        sg = it->first;
        if (sg->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        auto tmp_vertices = find_vertices(sg);
        v1 = tmp_vertices.first;
        v2 = tmp_vertices.second;
        if (v1 != 0 && v2 != 0) {
            double dis =
                sqrt(pow(v1->get_fit_pt().x - v2->get_fit_pt().x, 2) + pow(v1->get_fit_pt().y - v2->get_fit_pt().y, 2) +
                     pow(v1->get_fit_pt().z - v2->get_fit_pt().z, 2));

            // std::cout << sg->get_cluster_id() << " " << sg->get_id() << " " << dis/units::cm << " " <<
            // map_vertex_segments[v1].size() << " " << map_vertex_segments[v2].size() << std::endl;
            if (dis < 0.45 * units::cm) {
                flag_continue = true;
                break;
            }
            else if (dis < 1.5 * units::cm && map_vertex_segments[v1].size() == 2 &&
                     map_vertex_segments[v2].size() == 2) {
                flag_continue = true;
                break;
            }
            else {
                v1 = 0;
                v2 = 0;
                sg = 0;
            }
        }
    }

    // merge and clean up map ...
    if (v1 != 0 && v2 != 0) {
        if (v2 != main_vertex) {
            std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Merge Vertices Type II" << std::endl;
            // delete the segment in between
            del_proto_segment(sg);
            WCPPID::ProtoSegmentSelection tmp_segments;
            for (auto it1 = map_vertex_segments[v2].begin(); it1 != map_vertex_segments[v2].end(); it1++) {
                tmp_segments.push_back(*it1);
            }
            for (auto it1 = tmp_segments.begin(); it1 != tmp_segments.end(); it1++) {
                WCPPID::ProtoVertex *v3 = find_other_vertex(*it1, v2);
                temp_cluster->dijkstra_shortest_paths(v3->get_wcpt(), 2);
                temp_cluster->cal_shortest_path(v1->get_wcpt(), 2);
                ProtoSegment *sg2 = new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(),
                                                             temp_cluster->get_cluster_id());
                acc_segment_id++;
                del_proto_segment(*it1);
                add_proto_connection(v3, sg2, temp_cluster);
                add_proto_connection(v1, sg2, temp_cluster);
            }
            del_proto_vertex(v2);

            WCPPID::ProtoVertexSelection tmp_vertices;
            for (auto it1 = map_vertex_segments.begin(); it1 != map_vertex_segments.end(); it1++) {
                if (it1->second.size() == 0) tmp_vertices.push_back(it1->first);
            }
            for (auto it1 = tmp_vertices.begin(); it1 != tmp_vertices.end(); it1++) {
                del_proto_vertex(*it1);
            }

            temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                            flash_time * units::microsecond, true, true, true);
        }
        else {
            flag_continue = false;
        }
    }

    return flag_continue;
}

bool WCPPID::NeutrinoID::examine_vertices_4(WCPPID::PR3DCluster *temp_cluster)
{
    bool flag_continue = false;
    WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
    TVector3 drift_dir(1, 0, 0);

    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;
        auto pair_vertices = find_vertices(sg);
        WCPPID::ProtoVertex *v1 = pair_vertices.first;
        WCPPID::ProtoVertex *v2 = pair_vertices.second;

        TVector3 tmp_dir(sg->get_point_vec().front().x - sg->get_point_vec().back().x,
                         sg->get_point_vec().front().y - sg->get_point_vec().back().y,
                         sg->get_point_vec().front().z - sg->get_point_vec().back().z);
        //    std::cout << sg->get_id() << " " << sg->get_direct_length()/units::cm << " " <<
        //    drift_dir.Angle(tmp_dir)/3.1415926*180. << " " << map_vertex_segments[v1].size() << " " <<
        //    map_vertex_segments[v2].size() << std::endl;

        if (sg->get_direct_length() < 2.0 * units::cm ||
            tmp_dir.Mag() < 3.5 * units::cm && fabs(drift_dir.Angle(tmp_dir) / 3.1415926 * 180. - 90) < 10) {
            //      if (map_vertex_segments[v1].size() <= 1 || map_vertex_segments[v2].size() <=1) continue;
            //      if (v1 == main_vertex || v2 == main_vertex) continue;

            //      std::cout << sg->get_id() << " " << sg->get_direct_length()/units::cm << " " <<
            //      map_vertex_segments[v1].size() << " " << map_vertex_segments[v2].size() << std::endl;
            if (map_vertex_segments[v1].size() >= 2 && examine_vertices_4(v1, v2) && v1 != main_vertex) {
                for (auto it1 = map_vertex_segments[v1].begin(); it1 != map_vertex_segments[v1].end(); it1++) {
                    ProtoSegment *sg1 = *it1;
                    if (sg1 == sg) continue;

                    WCP::WCPointCloud<double>::WCPoint &vtx_new_wcp = v2->get_wcpt();

                    std::vector<WCP::WCPointCloud<double>::WCPoint> &vec_wcps = sg1->get_wcpt_vec();
                    bool flag_front = false;
                    if (vec_wcps.front().index == v1->get_wcpt().index) flag_front = true;

                    WCP::WCPointCloud<double>::WCPoint min_wcp;
                    double min_dis = 1e9;
                    double max_dis = std::max(sqrt(pow(vec_wcps.front().x - v1->get_fit_pt().x, 2) +
                                                   pow(vec_wcps.front().y - v1->get_fit_pt().y, 2) +
                                                   pow(vec_wcps.front().z - v1->get_fit_pt().z, 2)),
                                              sqrt(pow(vec_wcps.back().x - v1->get_fit_pt().x, 2) +
                                                   pow(vec_wcps.back().y - v1->get_fit_pt().y, 2) +
                                                   pow(vec_wcps.back().z - v1->get_fit_pt().z, 2)));
                    double dis_cut = 0;
                    double default_dis_cut = 2.5 * units::cm;
                    if (max_dis > 2 * default_dis_cut) dis_cut = default_dis_cut;
                    for (size_t j = 0; j != vec_wcps.size(); j++) {
                        double dis1 = sqrt(pow(vec_wcps.at(j).x - v1->get_fit_pt().x, 2) +
                                           pow(vec_wcps.at(j).y - v1->get_fit_pt().y, 2) +
                                           pow(vec_wcps.at(j).z - v1->get_fit_pt().z, 2));
                        double dis = fabs(dis1 - 3 * units::cm);
                        if (dis < min_dis && dis1 > dis_cut) {
                            min_wcp = vec_wcps.at(j);
                            min_dis = dis;
                        }
                    }
                    // establish the shortest path ...
                    std::list<WCP::WCPointCloud<double>::WCPoint> new_list;

                    new_list.push_back(vtx_new_wcp);
                    {
                        double dis_step = 2.0 * units::cm;
                        int ncount =
                            std::round(sqrt(pow(vtx_new_wcp.x - min_wcp.x, 2) + pow(vtx_new_wcp.y - min_wcp.y, 2) +
                                            pow(vtx_new_wcp.z - min_wcp.z, 2)) /
                                       dis_step);
                        if (ncount < 2) ncount = 2;

                        for (int qx = 1; qx < ncount; qx++) {
                            Point tmp_p(vtx_new_wcp.x + (min_wcp.x - vtx_new_wcp.x) / ncount * qx,
                                        vtx_new_wcp.y + (min_wcp.y - vtx_new_wcp.y) / ncount * qx,
                                        vtx_new_wcp.z + (min_wcp.z - vtx_new_wcp.z) / ncount * qx);
                            WCP::WCPointCloud<double>::WCPoint &tmp_wcp = pcloud->get_closest_wcpoint(tmp_p);
                            // std::cout << qx << " " << sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) +
                            // pow(tmp_wcp.z - tmp_p.z,2))/units::cm << std::endl;
                            if (sqrt(pow(tmp_wcp.x - tmp_p.x, 2) + pow(tmp_wcp.y - tmp_p.y, 2) +
                                     pow(tmp_wcp.z - tmp_p.z, 2)) > 0.3 * units::cm)
                                continue;  // too large ...
                            if (tmp_wcp.index != new_list.back().index && tmp_wcp.index != min_wcp.index)
                                new_list.push_back(tmp_wcp);
                        }
                    }
                    new_list.push_back(min_wcp);

                    std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
                    std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));
                    // append the list back ...
                    // std::cout << min_wcp.index << " " << temp_cluster->get_path_wcps().size() << std::endl;
                    if (flag_front) {
                        // std::cout << "f1 " << old_list.size() << std::endl;

                        while (old_list.front().index != min_wcp.index && old_list.size() > 0) {
                            old_list.pop_front();
                        }
                        old_list.pop_front();
                        //      std::cout << "f2 " << old_list.size() << std::endl;
                        for (auto it = new_list.rbegin(); it != new_list.rend(); it++) {
                            old_list.push_front(*it);
                        }
                        //      std::cout << "f3 " << old_list.size() << std::endl;
                    }
                    else {
                        //      std::cout << "b1 " << old_list.size() << std::endl;
                        while (old_list.back().index != min_wcp.index && old_list.size() > 0) {
                            old_list.pop_back();
                        }
                        old_list.pop_back();

                        //      std::cout << "b2 " << old_list.size() << std::endl;
                        for (auto it = new_list.rbegin(); it != new_list.rend(); it++) {
                            old_list.push_back(*it);
                        }
                        //      std::cout << "b3 " << old_list.size() << std::endl;
                    }
                    vec_wcps.clear();
                    vec_wcps.reserve(old_list.size());
                    std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));

                    add_proto_connection(v2, sg1, temp_cluster);
                }

                del_proto_vertex(v1);
                del_proto_segment(sg);

                flag_continue = true;
                temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                global_wc_map, flash_time * units::microsecond, true, true, true);
            }
            else if (map_vertex_segments[v2].size() >= 2 && examine_vertices_4(v2, v1) && v2 != main_vertex) {
                // merge v2's segments to v1 ...

                for (auto it1 = map_vertex_segments[v2].begin(); it1 != map_vertex_segments[v2].end(); it1++) {
                    WCPPID::ProtoSegment *sg1 = *it1;
                    if (sg1 == sg) continue;

                    WCP::WCPointCloud<double>::WCPoint &vtx_new_wcp = v1->get_wcpt();

                    std::vector<WCP::WCPointCloud<double>::WCPoint> &vec_wcps = sg1->get_wcpt_vec();
                    bool flag_front = false;
                    if (vec_wcps.front().index == v2->get_wcpt().index) flag_front = true;

                    WCP::WCPointCloud<double>::WCPoint min_wcp;
                    double min_dis = 1e9;
                    double max_dis = std::max(sqrt(pow(vec_wcps.front().x - v2->get_fit_pt().x, 2) +
                                                   pow(vec_wcps.front().y - v2->get_fit_pt().y, 2) +
                                                   pow(vec_wcps.front().z - v2->get_fit_pt().z, 2)),
                                              sqrt(pow(vec_wcps.back().x - v2->get_fit_pt().x, 2) +
                                                   pow(vec_wcps.back().y - v2->get_fit_pt().y, 2) +
                                                   pow(vec_wcps.back().z - v2->get_fit_pt().z, 2)));
                    double dis_cut = 0;
                    double default_dis_cut = 2.5 * units::cm;
                    if (max_dis > 2 * default_dis_cut) dis_cut = default_dis_cut;
                    for (size_t j = 0; j != vec_wcps.size(); j++) {
                        double dis1 = sqrt(pow(vec_wcps.at(j).x - v2->get_fit_pt().x, 2) +
                                           pow(vec_wcps.at(j).y - v2->get_fit_pt().y, 2) +
                                           pow(vec_wcps.at(j).z - v2->get_fit_pt().z, 2));
                        double dis = fabs(dis1 - 3.0 * units::cm);
                        if (dis < min_dis && dis1 > dis_cut) {
                            min_wcp = vec_wcps.at(j);
                            min_dis = dis;
                        }
                    }
                    // establish the shortest path ...
                    std::list<WCP::WCPointCloud<double>::WCPoint> new_list;

                    new_list.push_back(vtx_new_wcp);
                    {
                        double dis_step = 2.0 * units::cm;
                        int ncount =
                            std::round(sqrt(pow(vtx_new_wcp.x - min_wcp.x, 2) + pow(vtx_new_wcp.y - min_wcp.y, 2) +
                                            pow(vtx_new_wcp.z - min_wcp.z, 2)) /
                                       dis_step);
                        if (ncount < 2) ncount = 2;

                        for (int qx = 1; qx < ncount; qx++) {
                            Point tmp_p(vtx_new_wcp.x + (min_wcp.x - vtx_new_wcp.x) / ncount * qx,
                                        vtx_new_wcp.y + (min_wcp.y - vtx_new_wcp.y) / ncount * qx,
                                        vtx_new_wcp.z + (min_wcp.z - vtx_new_wcp.z) / ncount * qx);
                            WCP::WCPointCloud<double>::WCPoint &tmp_wcp = pcloud->get_closest_wcpoint(tmp_p);
                            // std::cout << qx << " " << sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) +
                            // pow(tmp_wcp.z - tmp_p.z,2))/units::cm << std::endl;
                            if (sqrt(pow(tmp_wcp.x - tmp_p.x, 2) + pow(tmp_wcp.y - tmp_p.y, 2) +
                                     pow(tmp_wcp.z - tmp_p.z, 2)) > 0.3 * units::cm)
                                continue;  // too large ...
                            if (tmp_wcp.index != new_list.back().index && tmp_wcp.index != min_wcp.index)
                                new_list.push_back(tmp_wcp);
                        }
                    }
                    new_list.push_back(min_wcp);

                    std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
                    std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));
                    // append the list back ...
                    // std::cout << min_wcp.index << " " << temp_cluster->get_path_wcps().size() << std::endl;
                    if (flag_front) {
                        // std::cout << "f1 " << old_list.size() << std::endl;

                        while (old_list.front().index != min_wcp.index && old_list.size() > 0) {
                            old_list.pop_front();
                        }
                        old_list.pop_front();
                        //      std::cout << "f2 " << old_list.size() << std::endl;
                        for (auto it = new_list.rbegin(); it != new_list.rend(); it++) {
                            old_list.push_front(*it);
                        }
                        //      std::cout << "f3 " << old_list.size() << std::endl;
                    }
                    else {
                        //      std::cout << "b1 " << old_list.size() << std::endl;
                        while (old_list.back().index != min_wcp.index && old_list.size() > 0) {
                            old_list.pop_back();
                        }
                        old_list.pop_back();

                        //      std::cout << "b2 " << old_list.size() << std::endl;
                        for (auto it = new_list.rbegin(); it != new_list.rend(); it++) {
                            old_list.push_back(*it);
                        }
                        //      std::cout << "b3 " << old_list.size() << std::endl;
                    }
                    vec_wcps.clear();
                    vec_wcps.reserve(old_list.size());
                    std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));

                    add_proto_connection(v1, sg1, temp_cluster);
                }

                del_proto_vertex(v2);
                del_proto_segment(sg);

                flag_continue = true;
                temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud,
                                                global_wc_map, flash_time * units::microsecond, true, true, true);
            }
            if (flag_continue) {
                std::cout << "Merge Vertices Type III: segment id: " << sg->get_id() << std::endl;
                break;
            }
        }
    }

    return flag_continue;
}

bool WCPPID::NeutrinoID::examine_vertices_4(WCPPID::ProtoVertex *v1, WCPPID::ProtoVertex *v2)
{
    WCPPID::ProtoSegment *sg1 = find_segment(v1, v2);

    bool flag = true;
    // check segments of v1 with respect v2 ...
    for (auto it = map_vertex_segments[v1].begin(); it != map_vertex_segments[v1].end(); it++) {
        WCPPID::ProtoSegment *sg = *it;
        if (sg == sg1) continue;

        PointVector &pts = sg->get_point_vec();
        Point min_point = pts.front();
        double min_dis = 1e9;
        for (size_t i = 0; i != pts.size(); i++) {
            double dis = fabs(sqrt(pow(pts.at(i).x - v1->get_fit_pt().x, 2) + pow(pts.at(i).y - v1->get_fit_pt().y, 2) +
                                   pow(pts.at(i).z - v1->get_fit_pt().z, 2)) -
                              3 * units::cm);
            if (dis < min_dis) {
                min_dis = dis;
                min_point = pts.at(i);
            }
        }

        //
        double step_size = 0.3 * units::cm;
        Point start_p = min_point;
        Point end_p = v2->get_fit_pt();
        int ncount = std::round(
            sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) / step_size);
        int n_bad = 0;
        for (int i = 1; i < ncount; i++) {
            Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i, start_p.y + (end_p.y - start_p.y) / ncount * i,
                         start_p.z + (end_p.z - start_p.z) / ncount * i);
            if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) {
                //	std::vector<int> tmp_results = ct_point_cloud->convert_3Dpoint_time_ch(test_p);
                // std::cout << tmp_results.at(0) << " " << tmp_results.at(1) << " " << tmp_results.at(2) << " " <<
                // tmp_results.at(3) << std::endl;
                n_bad++;
            }
        }

        //    std::cout << n_bad << " " << ncount << " " << sg->get_id() << " " << sg1->get_id() << " " <<
        //    sg1->get_length()/units::cm << " " << sqrt(pow(start_p.x - end_p.x,2) + pow(start_p.y - end_p.y,2) +
        //    pow(start_p.z - end_p.z,2))/units::cm << std::endl;
        if (n_bad != 0) {
            flag = false;
            break;
        }
    }
    //    std::cout << std::endl;

    return flag;
}

bool WCPPID::NeutrinoID::examine_vertices_1(WCPPID::PR3DCluster *temp_cluster)
{
    TPCParams &mp = Singleton<TPCParams>::Instance();
    double time_slice_width = mp.get_ts_width();
    int time_offset = mp.get_time_offset();
    int nrebin = mp.get_nrebin();
    double pitch_u = mp.get_pitch_u();
    double pitch_v = mp.get_pitch_v();
    double pitch_w = mp.get_pitch_w();
    double first_u_dis = mp.get_first_u_dis();
    double first_v_dis = mp.get_first_v_dis();
    double first_w_dis = mp.get_first_w_dis();
    double angle_u = mp.get_angle_u();
    double angle_v = mp.get_angle_v();
    double angle_w = mp.get_angle_w();
    //  convert Z to W ...
    double slope_zw = 1. / pitch_w * cos(angle_w);
    double slope_yw = 1. / pitch_w * sin(angle_w);

    double slope_yu = -1. / pitch_u * sin(angle_u);
    double slope_zu = 1. / pitch_u * cos(angle_u);
    double slope_yv = -1. / pitch_v * sin(angle_v);
    double slope_zv = 1. / pitch_v * cos(angle_v);
    // convert Y,Z to U,V
    double offset_w = -first_w_dis / pitch_w + 0.5;
    double offset_u = -first_u_dis / pitch_u + 0.5;
    double offset_v = -first_v_dis / pitch_v + 0.5;

    double first_t_dis = temp_cluster->get_point_cloud()->get_cloud().pts[0].mcell->GetTimeSlice() * time_slice_width -
                         temp_cluster->get_point_cloud()->get_cloud().pts[0].x;
    double slope_xt = 1. / time_slice_width;
    double offset_t = first_t_dis / time_slice_width + 0.5;

    /* 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; */
    /*   auto it1 = find_vertices(sg); */
    /*   std::cout << it1.first->get_wcpt().index << " " << it1.second->get_wcpt().index << std::endl; */
    /* } */

    bool flag_continue = false;

    // std::map<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> map_vertex_replace;
    WCPPID::ProtoVertex *v1 = 0;
    WCPPID::ProtoVertex *v2 = 0;
    WCPPID::ProtoVertex *v3 = 0;

    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        WCPPID::ProtoVertex *vtx = it->first;
        if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
        if (it->second.size() == 2) {  // potential check
            for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++) {
                WCPPID::ProtoSegment *sg = (*it1);

                if (sg->get_length() > 4 * units::cm) continue;
                for (auto it2 = map_segment_vertices[sg].begin(); it2 != map_segment_vertices[sg].end(); it2++) {
                    WCPPID::ProtoVertex *vtx1 = (*it2);
                    if (vtx1 == vtx) continue;
                    if (map_vertex_segments[vtx1].size() >= 2) {  // the other track needs to be larger than 2
                        //	    std::cout << sg->get_id() << " " << vtx->get_id() << " " << vtx1->get_id() << " " <<
                        //sg->get_length()/units::cm <<std::endl;

                        if (examine_vertices_1(vtx, vtx1, offset_t, slope_xt, offset_u, slope_yu, slope_zu, offset_v,
                                               slope_yv, slope_zv, offset_w, slope_yw, slope_zw)) {
                            v1 = vtx;
                            v2 = vtx1;
                            // std::cout << "haha " << std::endl;

                            for (auto it3 = it->second.begin(); it3 != it->second.end(); it3++) {
                                if (*it3 == sg) continue;
                                for (auto it4 = map_segment_vertices[*it3].begin();
                                     it4 != map_segment_vertices[*it3].end(); it4++) {
                                    if (*it4 == v1) continue;
                                    v3 = *it4;
                                }
                            }

                            flag_continue = true;
                            break;
                        }
                        //	    std::cout << "hehe " << std::endl;
                    }
                }  // loop over vertices ..
                if (flag_continue) break;
            }  // search for segments
            if (flag_continue) break;
        }  // require two segment
    }      // loop over vertices ...

    // replace ...
    if (v1 != 0 && v2 != 0) {
        if (v1 != main_vertex) {
            //      std::cout << v1 << " " << v2 << " " << v3 << std::endl;
            ProtoSegment *sg = find_segment(v1, v2);
            ProtoSegment *sg1 = find_segment(v1, v3);

            //      std::cout << v2->get_cluster_id() << " " << v3->get_cluster_id() << std::endl;

            //  std::cout << sg<< " " << sg1 << std::endl;
            temp_cluster->dijkstra_shortest_paths(v3->get_wcpt(), 2);
            temp_cluster->cal_shortest_path(v2->get_wcpt(), 2);
            ProtoSegment *sg2 =
                new WCPPID::ProtoSegment(acc_segment_id, temp_cluster->get_path_wcps(), temp_cluster->get_cluster_id());
            acc_segment_id++;

            std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Merge Vertices Type I " << sg->get_id()
                      << " + " << sg1->get_id() << " -> " << sg2->get_id() << std::endl;
            add_proto_connection(v2, sg2, temp_cluster);
            add_proto_connection(v3, sg2, temp_cluster);

            /* std::cout << v2->get_wcpt().index << " " << v3->get_wcpt().index << std::endl; */
            /* for (auto it5 = temp_cluster->get_path_wcps().begin(); it5 != temp_cluster->get_path_wcps().end();
             * it5++){ */
            /* 	std::cout << (*it5).index << std::endl; */
            /* } */

            del_proto_vertex(v1);
            del_proto_segment(sg);
            del_proto_segment(sg1);

            temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map,
                                            flash_time * units::microsecond, true, true, true);
        }
        else {
            flag_continue = false;
        }
    }

    // hack for now
    // flag_continue = false;

    return flag_continue;
}

bool WCPPID::NeutrinoID::examine_vertices_1(WCPPID::ProtoVertex *v1, WCPPID::ProtoVertex *v2, double offset_t,
                                            double slope_xt, double offset_u, double slope_yu, double slope_zu,
                                            double offset_v, double slope_yv, double slope_zv, double offset_w,
                                            double slope_yw, double slope_zw)
{
    // U, V, W ...
    Point &v1_p = v1->get_fit_pt();
    double v1_t = offset_t + slope_xt * v1_p.x;
    double v1_u = offset_u + slope_yu * v1_p.y + slope_zu * v1_p.z;
    double v1_v = offset_v + slope_yv * v1_p.y + slope_zv * v1_p.z;
    double v1_w = offset_w + slope_yw * v1_p.y + slope_zw * v1_p.z;

    Point &v2_p = v2->get_fit_pt();
    double v2_t = offset_t + slope_xt * v2_p.x;
    double v2_u = offset_u + slope_yu * v2_p.y + slope_zu * v2_p.z;
    double v2_v = offset_v + slope_yv * v2_p.y + slope_zv * v2_p.z;
    double v2_w = offset_w + slope_yw * v2_p.y + slope_zw * v2_p.z;

    // find the track segment in between
    WCPPID::ProtoSegment *sg = find_segment(v1, v2);
    if (sg == 0 || map_vertex_segments[v1].size() != 2) return false;

    int ncount_close = 0;
    int ncount_dead = 0;
    int ncount_line = 0;

    // one view must be close
    if (sqrt(pow(v1_u - v2_u, 2) + pow(v1_t - v2_t, 2)) < 2.5) {
        ncount_close++;
    }
    else {
        // one view must be dead? or shorter distance
        bool flag_dead = true;
        for (size_t i = 0; i != sg->get_point_vec().size(); i++) {
            if (!ct_point_cloud->get_closest_dead_chs(sg->get_point_vec().at(i), 0)) flag_dead = false;
        }
        if (flag_dead)
            ncount_dead++;
        else {
            // third view must be like a line
            PointVector &pts_1 = sg->get_point_vec();
            WCPPID::ProtoSegment *sg1 = 0;
            for (auto it1 = map_vertex_segments[v1].begin(); it1 != map_vertex_segments[v1].end(); it1++) {
                // sg is one track
                if (*it1 == sg) continue;
                sg1 = *it1;
            }

            PointVector &pts_2 = sg1->get_point_vec();
            TVector3 v1(v2_u - v1_u, v2_t - v1_t, 0);
            TVector3 v2(0, 0, 0);
            double min_dis = 1e9;
            Point start_p = v2_p;
            Point end_p;

            for (size_t i = 0; i != pts_2.size(); i++) {
                double p_t = offset_t + slope_xt * pts_2.at(i).x;
                double p_u = offset_u + slope_yu * pts_2.at(i).y + slope_zu * pts_2.at(i).z;
                TVector3 v3(p_u - v1_u, p_t - v1_t, 0);
                double dis = fabs(v3.Mag() - 9);
                if (dis < min_dis) {
                    min_dis = dis;
                    v2 = v3;
                    end_p = pts_2.at(i);
                }
            }

            if (180 - v1.Angle(v2) / 3.1415926 * 180. < 30 ||
                v1.Mag() < 8 && 180 - v1.Angle(v2) / 3.1415926 * 180. < 35)
                ncount_line++;
            else {
                double step_size = 0.6 * units::cm;
                int ncount = std::round(
                    sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) /
                    step_size);
                int n_bad = 0;
                for (int i = 1; i < ncount; i++) {
                    Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i,
                                 start_p.y + (end_p.y - start_p.y) / ncount * i,
                                 start_p.z + (end_p.z - start_p.z) / ncount * i);
                    if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
                }
                if (n_bad <= 1) ncount_line++;
            }
            // std::cout << v1.Mag() << " " << v2.Mag() << " " << v1.Angle(v2)/3.1415926*180. << std::endl;
        }
    }

    // std::cout << ncount_close << " " << ncount_dead << " " << ncount_line << std::endl;

    // one view must be close
    if (sqrt(pow(v1_v - v2_v, 2) + pow(v1_t - v2_t, 2)) < 2.5) {
        ncount_close++;
    }
    else {
        // one view must be dead? or shorter distance
        bool flag_dead = true;
        for (size_t i = 0; i != sg->get_point_vec().size(); i++) {
            if (!ct_point_cloud->get_closest_dead_chs(sg->get_point_vec().at(i), 1)) flag_dead = false;
        }
        if (flag_dead)
            ncount_dead++;
        else {
            // third view must be like a line
            PointVector &pts_1 = sg->get_point_vec();
            WCPPID::ProtoSegment *sg1 = 0;
            for (auto it1 = map_vertex_segments[v1].begin(); it1 != map_vertex_segments[v1].end(); it1++) {
                // sg is one track
                if (*it1 == sg) continue;
                sg1 = *it1;
            }

            PointVector &pts_2 = sg1->get_point_vec();
            TVector3 v1(v2_v - v1_v, v2_t - v1_t, 0);
            TVector3 v2(0, 0, 0);
            double min_dis = 1e9;

            Point start_p = v2_p;
            Point end_p;

            for (size_t i = 0; i != pts_2.size(); i++) {
                double p_t = offset_t + slope_xt * pts_2.at(i).x;
                double p_v = offset_v + slope_yv * pts_2.at(i).y + slope_zv * pts_2.at(i).z;
                TVector3 v3(p_v - v1_v, p_t - v1_t, 0);
                double dis = fabs(v3.Mag() - 9);
                if (dis < min_dis) {
                    min_dis = dis;
                    v2 = v3;
                    end_p = pts_2.at(i);
                }
            }

            if (180 - v1.Angle(v2) / 3.1415926 * 180. < 30 ||
                v1.Mag() < 8 && 180 - v1.Angle(v2) / 3.1415926 * 180. < 35)
                ncount_line++;
            else {
                double step_size = 0.6 * units::cm;
                int ncount = std::round(
                    sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) /
                    step_size);
                int n_bad = 0;
                for (int i = 1; i < ncount; i++) {
                    Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i,
                                 start_p.y + (end_p.y - start_p.y) / ncount * i,
                                 start_p.z + (end_p.z - start_p.z) / ncount * i);
                    if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
                }
                if (n_bad <= 1) ncount_line++;
            }
            //      std::cout << v1.Mag() << " " << v2.Mag() << " " << v1.Angle(v2)/3.1415926*180. << std::endl;
        }
    }

    // std::cout << ncount_close << " " << ncount_dead << " " << ncount_line << std::endl;

    // one view must be close
    if (sqrt(pow(v1_w - v2_w, 2) + pow(v1_t - v2_t, 2)) < 2.5) {
        //    std::cout << "haha " << sqrt(pow(v1_w - v2_w, 2) + pow(v1_t - v2_t,2)) << std::endl;
        ncount_close++;
    }
    else {
        // one view must be dead? or shorter distance
        bool flag_dead = true;
        for (size_t i = 0; i != sg->get_point_vec().size(); i++) {
            if (!ct_point_cloud->get_closest_dead_chs(sg->get_point_vec().at(i), 2)) flag_dead = false;
        }

        if (flag_dead)
            ncount_dead++;
        else {
            // third view must be like a line
            PointVector &pts_1 = sg->get_point_vec();
            WCPPID::ProtoSegment *sg1 = 0;
            for (auto it1 = map_vertex_segments[v1].begin(); it1 != map_vertex_segments[v1].end(); it1++) {
                // sg is one track
                if (*it1 == sg) continue;
                sg1 = *it1;
            }

            PointVector &pts_2 = sg1->get_point_vec();
            TVector3 v1(v2_w - v1_w, v2_t - v1_t, 0);
            TVector3 v2(0, 0, 0);
            double min_dis = 1e9;
            Point start_p = v2_p;
            Point end_p;
            for (size_t i = 0; i != pts_2.size(); i++) {
                double p_t = offset_t + slope_xt * pts_2.at(i).x;
                double p_w = offset_w + slope_yw * pts_2.at(i).y + slope_zw * pts_2.at(i).z;
                TVector3 v3(p_w - v1_w, p_t - v1_t, 0);
                double dis = fabs(v3.Mag() - 9);
                if (dis < min_dis) {
                    min_dis = dis;
                    v2 = v3;
                    end_p = pts_2.at(i);
                }
            }

            if (180 - v1.Angle(v2) / 3.1415926 * 180. < 30 ||
                v1.Mag() < 8 && 180 - v1.Angle(v2) / 3.1415926 * 180. < 35)
                ncount_line++;
            else {
                double step_size = 0.6 * units::cm;
                int ncount = std::round(
                    sqrt(pow(start_p.x - end_p.x, 2) + pow(start_p.y - end_p.y, 2) + pow(start_p.z - end_p.z, 2)) /
                    step_size);
                int n_bad = 0;
                for (int i = 1; i < ncount; i++) {
                    Point test_p(start_p.x + (end_p.x - start_p.x) / ncount * i,
                                 start_p.y + (end_p.y - start_p.y) / ncount * i,
                                 start_p.z + (end_p.z - start_p.z) / ncount * i);
                    if (!ct_point_cloud->is_good_point(test_p, 0.2 * units::cm, 0, 0)) n_bad++;
                }
                if (n_bad <= 1) ncount_line++;
            }
            //      std::cout << v1.Mag() << " " << v2.Mag() << " " << v1.Angle(v2)/3.1415926*180. << std::endl;
        }
    }

    //  std::cout << ncount_close << " " << ncount_dead << " " << ncount_line << std::endl;

    if (ncount_close >= 2 || ncount_close == 1 && ncount_dead == 1 & ncount_line >= 1 ||
        ncount_close == 1 && ncount_dead == 2 || ncount_close == 1 && ncount_line >= 2 || ncount_line >= 3)
        return true;

    //  std::cout <<  << " " << sqrt(pow(v1_u - v2_u, 2) + pow(v1_t - v2_t,2)) << " " << sqrt(pow(v1_v - v2_v, 2) +
    //  pow(v1_t - v2_t,2)) << std::endl;

    return false;
}

std::pair<WCPPID::ProtoVertex *, WCPPID::ProtoVertex *> WCPPID::NeutrinoID::find_vertices(WCPPID::ProtoSegment *sg)
{
    if (map_segment_vertices.find(sg) == map_segment_vertices.end())
        return std::make_pair((WCPPID::ProtoVertex *) 0, (WCPPID::ProtoVertex *) 0);

    WCPPID::ProtoVertex *v1 = 0;
    WCPPID::ProtoVertex *v2 = 0;

    for (auto it = map_segment_vertices[sg].begin(); it != map_segment_vertices[sg].end(); it++) {
        if (v1 == 0) {
            v1 = *it;
        }
        else {
            v2 = *it;
        }
    }

    return std::make_pair(v1, v2);
}

WCPPID::ProtoVertex *WCPPID::NeutrinoID::find_other_vertex(WCPPID::ProtoSegment *sg, WCPPID::ProtoVertex *v1)
{
    auto results = find_vertices(sg);
    if (v1 == results.first) {
        return results.second;
    }
    else if (v1 == results.second) {
        return results.first;
    }
    else {
        return (WCPPID::ProtoVertex *) 0;
    }
}

WCPPID::ProtoSegment *WCPPID::NeutrinoID::find_segment(WCPPID::ProtoVertex *v1, WCPPID::ProtoVertex *v2)
{
    WCPPID::ProtoSegment *sg = 0;
    for (auto it1 = map_vertex_segments[v1].begin(); it1 != map_vertex_segments[v1].end(); it1++) {
        sg = *it1;
        if (map_segment_vertices[sg].find(v2) == map_segment_vertices[sg].end()) {
            sg = 0;
        }
        else {
            break;
        }
    }
    return sg;
}

WCPPID::ProtoVertexSelection WCPPID::NeutrinoID::find_vertices(WCPPID::PR3DCluster *temp_cluster)
{
    WCPPID::ProtoVertexSelection tmp_vertices;
    for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++) {
        if (temp_cluster->get_cluster_id() == (it->first)->get_cluster_id()) tmp_vertices.push_back(it->first);
    }
    return tmp_vertices;
}

WCPPID::ProtoSegmentSelection WCPPID::NeutrinoID::find_segments(WCPPID::PR3DCluster *temp_cluster)
{
    WCPPID::ProtoSegmentSelection tmp_segments;
    for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
        if (temp_cluster->get_cluster_id() == (it->first)->get_cluster_id()) tmp_segments.push_back(it->first);
    }
    return tmp_segments;
}

void WCPPID::NeutrinoID::clean_up_maps_vertices_segments(WCPPID::PR3DCluster *temp_cluster)
{
    bool flag_continue = true;
    while (flag_continue) {
        flag_continue = false;
        WCPPID::ProtoVertex *v1 = 0;
        WCPPID::ProtoVertex *v2 = 0;
        WCPPID::ProtoSegment *sg = 0;
        for (auto it = map_segment_vertices.begin(); it != map_segment_vertices.end(); it++) {
            if (it->first->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
            auto pair_vertices = find_vertices(it->first);
            if (pair_vertices.first->get_wcpt().index == pair_vertices.second->get_wcpt().index) {
                v1 = pair_vertices.first;
                v2 = pair_vertices.second;
                sg = it->first;
                flag_continue = true;
                break;
            }
        }
        if (flag_continue) {
            //      std::cout << v1 << " " << sg << " " << v2 << std::endl;
            del_proto_segment(sg);
            for (auto it = map_vertex_segments[v2].begin(); it != map_vertex_segments[v2].end(); it++) {
                add_proto_connection(v1, *it, temp_cluster);
            }
            del_proto_vertex(v2);
        }
    }
}
