void WCP2dToy::Clustering_regular(WCP::PR3DClusterSelection &live_clusters,
                                  WCP::map_pr3dcluster_double &cluster_length_map,
                                  WCP::PR3DClusterSet &cluster_connected_dead, double length_cut,
                                  bool flag_enable_extend)
{
    // calculate the length ...
    TPCParams &mp = Singleton<TPCParams>::Instance();
    double pitch_u = mp.get_pitch_u();
    double pitch_v = mp.get_pitch_v();
    double pitch_w = mp.get_pitch_w();
    double angle_u = mp.get_angle_u();
    double angle_v = mp.get_angle_v();
    double angle_w = mp.get_angle_w();
    double time_slice_width = mp.get_ts_width();
    // std::vector<double> cluster_length_vec;
    // estimated length
    if (cluster_length_map.size() == 0)
        for (size_t i = 0; i != live_clusters.size(); i++) {
            PR3DCluster *cluster_1 = live_clusters.at(i);
            std::vector<int> range_v1 = cluster_1->get_uvwt_range();
            double length_1 = sqrt(2. / 3. *
                                       (pow(pitch_u * range_v1.at(0), 2) + pow(pitch_v * range_v1.at(1), 2) +
                                        pow(pitch_w * range_v1.at(2), 2)) +
                                   pow(time_slice_width * range_v1.at(3), 2));
            // cluster_length_vec.push_back(length_1);
            cluster_length_map[cluster_1] = length_1;
        }

    double internal_length_cut = 10 * units::cm;
    if (flag_enable_extend) internal_length_cut = 15 * units::cm;

    for (int kk = 0; kk != 1; kk++) {
        std::set<std::pair<PR3DCluster *, PR3DCluster *>> to_be_merged_pairs;
        for (size_t i = 0; i != live_clusters.size(); i++) {
            PR3DCluster *cluster_1 = live_clusters.at(i);
            if (cluster_length_map[cluster_1] < internal_length_cut) continue;
            for (size_t j = i + 1; j < live_clusters.size(); j++) {
                PR3DCluster *cluster_2 = live_clusters.at(j);
                if (cluster_length_map[cluster_2] < internal_length_cut) continue;
                // std::cout << cluster_1->get_cluster_id() << " " << cluster_2->get_cluster_id() << std::endl;
                if (WCP2dToy::Clustering_1st_round(cluster_1, cluster_2, cluster_length_map[cluster_1],
                                                   cluster_length_map[cluster_2], length_cut, flag_enable_extend))
                    to_be_merged_pairs.insert(std::make_pair(cluster_1, cluster_2));
            }
        }

        // to_be_merged_pairs.clear();
        // std::cout << to_be_merged_pairs.size() << std::endl;

        std::vector<std::set<PR3DCluster *>> merge_clusters;
        for (auto it = to_be_merged_pairs.begin(); it != to_be_merged_pairs.end(); it++) {
            PR3DCluster *cluster1 = (*it).first;
            PR3DCluster *cluster2 = (*it).second;
            // std::cout << cluster1 << " " << cluster2 << " " << cluster1->get_cluster_id() << " " <<
            // cluster2->get_cluster_id() << std::endl;

            bool flag_new = true;
            std::vector<std::set<PR3DCluster *>> temp_set;
            for (auto it1 = merge_clusters.begin(); it1 != merge_clusters.end(); it1++) {
                std::set<PR3DCluster *> &clusters = (*it1);
                if (clusters.find(cluster1) != clusters.end() || clusters.find(cluster2) != clusters.end()) {
                    clusters.insert(cluster1);
                    clusters.insert(cluster2);
                    flag_new = false;
                    temp_set.push_back(clusters);
                    // break;
                }
            }
            if (flag_new) {
                std::set<PR3DCluster *> clusters;
                clusters.insert(cluster1);
                clusters.insert(cluster2);
                merge_clusters.push_back(clusters);
            }
            if (temp_set.size() > 1) {
                // merge them further ...
                std::set<PR3DCluster *> clusters;
                for (size_t i = 0; i != temp_set.size(); i++) {
                    for (auto it1 = temp_set.at(i).begin(); it1 != temp_set.at(i).end(); it1++) {
                        // std::cout << i << " " << (*it1) << " " << (*it1)->get_cluster_id()  << std::endl;
                        clusters.insert(*it1);
                    }
                    merge_clusters.erase(find(merge_clusters.begin(), merge_clusters.end(), temp_set.at(i)));
                }
                merge_clusters.push_back(clusters);
            }
        }

        // merge clusters into new clusters, delete old clusters
        for (auto it = merge_clusters.begin(); it != merge_clusters.end(); it++) {
            std::set<PR3DCluster *> &clusters = (*it);
            PR3DCluster *ncluster = new PR3DCluster((*clusters.begin())->get_cluster_id());
            live_clusters.push_back(ncluster);

            bool flag_connected_to_dead = false;

            for (auto it1 = clusters.begin(); it1 != clusters.end(); it1++) {
                PR3DCluster *ocluster = *(it1);
                // std::cout << ocluster->get_cluster_id() << " ";
                SMGCSelection &mcells = ocluster->get_mcells();
                for (auto it2 = mcells.begin(); it2 != mcells.end(); it2++) {
                    SlimMergeGeomCell *mcell = (*it2);
                    // std::cout << ocluster->get_cluster_id() << " " << mcell << std::endl;
                    int time_slice = mcell->GetTimeSlice();
                    ncluster->AddCell(mcell, time_slice);
                }
                live_clusters.erase(find(live_clusters.begin(), live_clusters.end(), ocluster));
                cluster_length_map.erase(ocluster);

                if (cluster_connected_dead.find(ocluster) != cluster_connected_dead.end()) {
                    flag_connected_to_dead = true;
                    cluster_connected_dead.erase(ocluster);
                }
                delete ocluster;
            }

            if (flag_connected_to_dead) cluster_connected_dead.insert(ncluster);

            std::vector<int> range_v1 = ncluster->get_uvwt_range();
            double length_1 = sqrt(2. / 3. *
                                       (pow(pitch_u * range_v1.at(0), 2) + pow(pitch_v * range_v1.at(1), 2) +
                                        pow(pitch_w * range_v1.at(2), 2)) +
                                   pow(time_slice_width * range_v1.at(3), 2));
            cluster_length_map[ncluster] = length_1;

            // std::cout << std::endl;
        }
    }
    //  return cluster_length_map;
}

bool WCP2dToy::Clustering_1st_round(WCP::PR3DCluster *cluster1, WCP::PR3DCluster *cluster2, double length_1,
                                    double length_2, double length_cut, bool flag_enable_extend)
{
    cluster1->Create_point_cloud();
    cluster2->Create_point_cloud();

    // pick any point and merged cell in cluster1,
    SlimMergeGeomCell *prev_mcell1 = 0;
    SlimMergeGeomCell *prev_mcell2 = 0;
    SlimMergeGeomCell *mcell1 = 0;  // cluster1->get_mcells().at(0);
    Point p1;                       // = mcell1->center();
    SlimMergeGeomCell *mcell2 = 0;
    Point p2;
    double dis = Find_Closeset_Points(cluster1, cluster2, length_1, length_2, length_cut, mcell1, mcell2, p1, p2);

    if (dis < length_cut) {
        bool flag_para = false;
        bool flag_prolong_U = false;
        bool flag_prolong_V = false;
        bool flag_prolong_W = false;
        bool flag_para_U = false;
        bool flag_para_V = false;
        bool flag_regular = false;
        bool flag_extend = false;
        bool flag_force_extend = false;

        // pronlonged case for U 3 and V 4 ...
        TVector3 drift_dir(1, 0, 0);
        TVector3 U_dir(0, cos(60. / 180. * 3.1415926), sin(60. / 180. * 3.1415926));
        TVector3 V_dir(0, cos(60. / 180. * 3.1415926), -sin(60. / 180. * 3.1415926));
        TVector3 W_dir(0, 1, 0);

        // calculate average distance ...
        Point cluster1_ave_pos = cluster1->calc_ave_pos(p1, 5 * units::cm);
        Point cluster2_ave_pos = cluster2->calc_ave_pos(p2, 5 * units::cm);

        TVector3 dir2_1(p2.x - p1.x + 1e-9, p2.y - p1.y + 1e-9, p2.z - p1.z + 1e-9);  // 2-1
        TVector3 dir2(cluster2_ave_pos.x - cluster1_ave_pos.x + 1e-9, cluster2_ave_pos.y - cluster1_ave_pos.y + 1e-9,
                      cluster2_ave_pos.z - cluster1_ave_pos.z + 1e-9);  // 2-1
        dir2_1.SetMag(1);
        dir2.SetMag(1);

        // parallle case
        double angle1 = dir2_1.Angle(drift_dir);
        double angle2 = dir2.Angle(drift_dir);

        double angle3, angle4, angle5;
        double angle3_1, angle4_1, angle5_1;

        if ((fabs(angle1 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926 ||
             fabs(angle2 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926) &&
            dis < 45 * units::cm && length_1 > 12 * units::cm && length_2 > 12 * units::cm) {
            flag_para = true;

            if (dis >= 3 * length_1 && dis >= 3 * length_2 && flag_para) return false;

            angle3 = dir2_1.Angle(U_dir);
            angle4 = dir2_1.Angle(V_dir);

            angle3_1 = dir2.Angle(U_dir);
            angle4_1 = dir2.Angle(V_dir);

            if (fabs(angle3 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926 ||
                fabs(angle3_1 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926 ||
                ((fabs(angle3 - 3.1415926 / 2.) < 15 / 180. * 3.1415926 ||
                  fabs(angle3_1 - 3.1415926 / 2.) < 15 / 180. * 3.1415926) &&
                 dis < 6 * units::cm))
                flag_para_U = true;

            if (fabs(angle4 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926 ||
                fabs(angle4_1 - 3.1415926 / 2.) < 7.5 / 180. * 3.1415926 ||
                ((fabs(angle4 - 3.1415926 / 2.) < 15 / 180. * 3.1415926 ||
                  fabs(angle4_1 - 3.1415926 / 2.) < 15 / 180. * 3.1415926) &&
                 dis < 6 * units::cm))
                flag_para_V = true;
        }

        if (!flag_para) {
            // prolonged case
            TVector3 tempV3(0, p2.y - p1.y, p2.z - p1.z);
            TVector3 tempV4(0, cluster2_ave_pos.y - cluster1_ave_pos.y, cluster2_ave_pos.z - cluster1_ave_pos.z);
            TVector3 tempV5;

            double angle6 = tempV3.Angle(U_dir);
            tempV5.SetXYZ(fabs(p2.x - p1.x), sqrt(pow(p2.y - p1.y, 2) + pow(p2.z - p1.z, 2)) * sin(angle6), 0);
            angle6 = tempV5.Angle(drift_dir);

            double angle7 = tempV3.Angle(V_dir);
            tempV5.SetXYZ(fabs(p2.x - p1.x), sqrt(pow(p2.y - p1.y, 2) + pow(p2.z - p1.z, 2)) * sin(angle7), 0);
            angle7 = tempV5.Angle(drift_dir);

            double angle8 = tempV3.Angle(W_dir);
            tempV5.SetXYZ(fabs(p2.x - p1.x), sqrt(pow(p2.y - p1.y, 2) + pow(p2.z - p1.z, 2)) * sin(angle8), 0);
            angle8 = tempV5.Angle(drift_dir);

            double angle6_1 = tempV4.Angle(U_dir);
            tempV5.SetXYZ(fabs(cluster2_ave_pos.x - cluster1_ave_pos.x),
                          sqrt(pow(cluster2_ave_pos.y - cluster1_ave_pos.y, 2) +
                               pow(cluster2_ave_pos.z - cluster1_ave_pos.z, 2)) *
                              sin(angle6_1),
                          0);
            angle6_1 = tempV5.Angle(drift_dir);
            double angle7_1 = tempV4.Angle(V_dir);
            tempV5.SetXYZ(fabs(cluster2_ave_pos.x - cluster1_ave_pos.x),
                          sqrt(pow(cluster2_ave_pos.y - cluster1_ave_pos.y, 2) +
                               pow(cluster2_ave_pos.z - cluster1_ave_pos.z, 2)) *
                              sin(angle7_1),
                          0);
            angle7_1 = tempV5.Angle(drift_dir);

            double angle8_1 = tempV4.Angle(W_dir);
            tempV5.SetXYZ(fabs(cluster2_ave_pos.x - cluster1_ave_pos.x),
                          sqrt(pow(cluster2_ave_pos.y - cluster1_ave_pos.y, 2) +
                               pow(cluster2_ave_pos.z - cluster1_ave_pos.z, 2)) *
                              sin(angle8_1),
                          0);
            angle8_1 = tempV5.Angle(drift_dir);

            if (angle6 < 15 / 180. * 3.1415926 || angle6_1 < 15 / 180. * 3.1415926) flag_prolong_U = true;

            if (angle7 < 15 / 180. * 3.1415926 || angle7_1 < 15 / 180. * 3.1415926) flag_prolong_V = true;

            if (angle8 < 15 / 180. * 3.1415926 || angle8_1 < 15 / 180. * 3.1415926) flag_prolong_W = true;
        }

        /* if ( flag_prolong_V && dis < 25*units::cm) */
        /*   std::cout << cluster1->get_cluster_id() << " " << cluster2->get_cluster_id() << " " << dis/units::cm << " "
         * << length_1/units::cm << " " << length_2/units::cm << " " <<flag_prolong_U << " " << flag_prolong_V << " " <<
         * flag_prolong_W << " " << angle6/3.1415926*180. << " " << angle6_1/3.1415926*180. << " " <<
         * angle7/3.1415926*180. << " " << angle7_1/3.1415926*180.  << " " << angle8/3.1415926*180. << " " <<
         * angle8_1/3.1415926*180.  <<std::endl;  */

        // regular case
        if (dis <= 15 * units::cm) {
            flag_regular = true;
        }
        else if (length_1 > 30 * units::cm && length_2 > 30 * units::cm) {
            if (dis <= 25 * units::cm) flag_regular = true;
        }

        if ((flag_para_U || flag_para_V) || (flag_prolong_U || flag_prolong_V || flag_prolong_W) || flag_regular) {
            double angle_cut = 2.5;
            double para_angle_cut = 5.;
            double para_angle_cut_1 = 5;

            if (dis < 5 * units::cm) {
                angle_cut = 12;
            }
            else if (dis < 15 * units::cm) {
                angle_cut = 7.5;
            }
            else {
                angle_cut = 5;
            }

            if (dis > 45 * units::cm) {
                para_angle_cut = 5;
            }
            else if (dis > 15 * units::cm) {
                para_angle_cut = 15;
            }
            else if (dis > 5 * units::cm) {
                para_angle_cut = 30;
            }
            else {
                para_angle_cut = 60;
            }

            TVector3 dir1 =
                cluster1->VHoughTrans(cluster1_ave_pos, 30 * units::cm);  // cluster 1 direction based on hough
            TVector3 dir1_1 = cluster1->VHoughTrans(p1, 30 * units::cm);

            TVector3 dir3 = cluster2->VHoughTrans(cluster2_ave_pos, 30 * units::cm);
            TVector3 dir3_1 = cluster2->VHoughTrans(p2, 30 * units::cm);

            dir1_1.SetMag(1);
            dir1.SetMag(1);
            dir3.SetMag(1);
            dir3_1.SetMag(1);

            double angle_diff1 = (3.1415926 - dir1.Angle(dir2)) / 3.1415926 * 180.;
            double angle_diff1_1 = (3.1415926 - dir1_1.Angle(dir2_1)) / 3.1415926 * 180.;

            double angle_diff2 = dir3.Angle(dir2) / 3.1415926 * 180;
            double angle_diff2_1 = dir3_1.Angle(dir2_1) / 3.1415926 * 180.;

            double angle_diff3 = (3.1415926 - dir1.Angle(dir3)) / 3.1415926 * 180;
            double angle_diff3_1 = (3.1415926 - dir1_1.Angle(dir3_1)) / 3.1415926 * 180.;

            if (dis <= 3 * units::cm) {
                if ((angle_diff3 < angle_cut * 1.5 || angle_diff3_1 < angle_cut * 1.5) &&
                    ((angle_diff1 < angle_cut * 4.5 || angle_diff1_1 < angle_cut * 4.5 || length_1 < 12 * units::cm) &&
                     (angle_diff2 < angle_cut * 4.5 || angle_diff2_1 < angle_cut * 4.5 || length_2 < 12 * units::cm)))
                    return true;
                if ((angle_diff3 < angle_cut * 1.5 || angle_diff3_1 < angle_cut * 1.5) ||
                    (angle_diff1 < angle_cut * 1.5 || angle_diff1_1 < angle_cut * 1.5) ||
                    (angle_diff2 < angle_cut * 1.5 || angle_diff2_1 < angle_cut * 1.5))
                    flag_extend = true;
            }

            if (angle_diff1 < angle_cut || angle_diff1_1 < angle_cut) {  // possible match
                if (length_2 < 12 * units::cm && dis < 2 * units::cm)    // small and very close
                    return true;
                if (angle_diff3 < angle_cut || angle_diff3_1 < angle_cut) {
                    return true;
                }

                if (dis < 15 * units::cm && dis > 5 * units::cm &&
                    (angle_diff3 < 2 * angle_cut || angle_diff3_1 < 2 * angle_cut) &&
                    (length_1 < 15 * units::cm || length_2 < 15 * units::cm))
                    return true;

                flag_extend = true;
            }

            if (angle_diff2 < angle_cut || angle_diff2_1 < angle_cut) {
                if (length_1 < 12 * units::cm && dis < 2 * units::cm)  // small and very close
                    return true;

                if (angle_diff3 < angle_cut || angle_diff3_1 < angle_cut) return true;

                if (dis < 15 * units::cm && dis > 5 * units::cm &&
                    (angle_diff3 < 2 * angle_cut || angle_diff3_1 < 2 * angle_cut) &&
                    (length_1 < 15 * units::cm || length_2 < 15 * units::cm))
                    return true;

                flag_extend = true;
            }

            if (flag_para && (flag_para_U || flag_para_V || flag_regular)) {
                double dangle1 = (dir1.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;
                double dangle1_1 = (dir1_1.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;

                double dangle2 = (dir2.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;
                double dangle2_1 = (dir2_1.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;

                double dangle3 = (dir3.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;
                double dangle3_1 = (dir3_1.Angle(drift_dir) - 3.1415926 / 2.) / 3.1415926 * 180.;

                double dangle4 = dangle1 + dangle2;
                double dangle4_1 = dangle1_1 + dangle2_1;

                double dangle5 = dangle3 - dangle2;
                double dangle5_1 = dangle3_1 - dangle2_1;

                if ((flag_para_U || flag_para_V) &&
                    (fabs(angle3 - 3.1415926 / 2.) / 3.1415926 * 180 < 5 ||
                     fabs(angle4 - 3.1415926 / 2.) / 3.1415926 * 180 < 5) &&  // along U or V very much
                    (fabs(angle1 - 3.1415926 / 2.) / 3.1415926 * 180 < 5 &&
                     fabs(angle2 - 3.1415926 / 2.) / 3.1415926 * 180 < 5) &&
                    (dis < 35 * units::cm &&
                     (length_1 < 35 * units::cm || length_2 < 35 * units::cm)) &&  // parallel case
                    (angle_diff2 < 60 || angle_diff2_1 < 60 || length_1 < 12 * units::cm) &&
                    (angle_diff1 < 60 || angle_diff1_1 < 60 || length_2 < 12 * units::cm) &&
                    (angle_diff3 < 90 || angle_diff3_1 < 90 || length_1 < 12 * units::cm ||
                     length_2 < 12 * units::cm) &&  // angle is close
                    (fabs(dangle4) < 5 && fabs(dangle4_1) < 5 || fabs(dangle5) < 5 && fabs(dangle5_1) < 5) &&
                    (fabs(dangle1) < 10 || fabs(dangle1_1) < 10) &&
                    (fabs(dangle3) < 10 || fabs(dangle3_1) < 10)  // small angle close to parallel
                    && flag_enable_extend)
                    return true;

                if ((fabs(dangle1) < 2.5 || fabs(dangle1_1) < 2.5) && (fabs(dangle2) < 2.5 || fabs(dangle2_1) < 2.5) &&
                    (fabs(dangle3) < 2.5 || fabs(dangle3_1) < 2.5) &&
                    (length_1 > 25 * units::cm && length_2 > 25 * units::cm))
                    flag_force_extend = true;

                if (flag_para_U || flag_para_V) {
                    if ((fabs(dangle1) < para_angle_cut_1 || fabs(dangle1_1) < para_angle_cut_1) &&
                        (fabs(dangle2) < para_angle_cut_1 || fabs(dangle2_1) < para_angle_cut_1) &&
                        (fabs(dangle4) < para_angle_cut_1 / 2. || fabs(dangle4_1) < para_angle_cut_1 / 2.) &&
                        (angle_diff1 < para_angle_cut || angle_diff1_1 < para_angle_cut)) {
                        if (length_2 < 12 * units::cm && dis < 2 * units::cm)  // small and very close
                            return true;

                        if (angle_diff3 < para_angle_cut || angle_diff3_1 < para_angle_cut) return true;

                        flag_extend = true;
                    }

                    if ((fabs(dangle3) < para_angle_cut_1 || fabs(dangle3_1) < para_angle_cut_1) &&
                        (fabs(dangle2) < para_angle_cut_1 || fabs(dangle2_1) < para_angle_cut_1) &&
                        (fabs(dangle5) < para_angle_cut_1 / 2. || fabs(dangle5_1) < para_angle_cut_1 / 2.) &&
                        (angle_diff2 < para_angle_cut || angle_diff2_1 < para_angle_cut)) {
                        if (length_1 < 12 * units::cm && dis < 2 * units::cm)  // small and very close
                            return true;

                        if (angle_diff3 < para_angle_cut || angle_diff3_1 < para_angle_cut) return true;

                        flag_extend = true;
                    }

                    if (dis < 5 * units::cm && length_1 > 25 * units::cm && length_2 > 25 * units::cm)
                        flag_extend = true;
                }
            }

            if (flag_extend && flag_enable_extend || flag_force_extend) {
                // when to extend???

                if ((flag_para && (flag_para_U || flag_para_V || flag_regular)) ||
                    (!flag_para && (flag_prolong_U || flag_prolong_V || dis < 10 * units::cm))) {
                    // look use 1 to predict 2
                    // cluster1_ave_pos, dir1
                    // calculate the average distance
                    double ave_dis = sqrt(pow(cluster1_ave_pos.x - cluster2_ave_pos.x, 2) +
                                          pow(cluster1_ave_pos.y - cluster2_ave_pos.y, 2) +
                                          pow(cluster1_ave_pos.z - cluster2_ave_pos.z, 2));
                    Point test_point;
                    double min_dis = 1e9, max_dis = -1e9;
                    for (int i = -5; i != 6; i++) {
                        test_point.x = cluster1_ave_pos.x - dir1.X() * (ave_dis + i * 2 * units::cm);
                        test_point.y = cluster1_ave_pos.y - dir1.Y() * (ave_dis + i * 2 * units::cm);
                        test_point.z = cluster1_ave_pos.z - dir1.Z() * (ave_dis + i * 2 * units::cm);

                        std::pair<SlimMergeGeomCell *, Point> temp_results =
                            cluster2->get_closest_point_mcell(test_point);
                        // reuse this
                        Point test_point1 = temp_results.second;
                        if (sqrt(pow(test_point1.x - test_point.x, 2) + pow(test_point1.y - test_point.y, 2) +
                                 pow(test_point1.z - test_point.z, 2)) < 1.5 * units::cm) {
                            double temp_dis = (test_point1.x - cluster1_ave_pos.x) * dir1.X() +
                                              (test_point1.y - cluster1_ave_pos.y) * dir1.Y() +
                                              (test_point1.z - cluster1_ave_pos.z) * dir1.Z();
                            temp_dis *= -1;
                            if (temp_dis < min_dis) min_dis = temp_dis;
                            if (temp_dis > max_dis) max_dis = temp_dis;
                        }
                    }
                    // std::cout << cluster1->get_cluster_id() << " " << cluster2->get_cluster_id() << " " <<
                    // min_dis/units::cm << " " << max_dis/units::cm << " " << length_2/units::cm << std::endl;

                    if ((max_dis - min_dis) > 2.5 * units::cm) return true;

                    // look at the other side (repeat)
                    // cluster2_ave_pos, dir2
                    min_dis = 1e9;
                    max_dis = -1e9;
                    for (int i = -5; i != 6; i++) {
                        test_point.x = cluster2_ave_pos.x - dir3.X() * (ave_dis + i * 2 * units::cm);
                        test_point.y = cluster2_ave_pos.y - dir3.Y() * (ave_dis + i * 2 * units::cm);
                        test_point.z = cluster2_ave_pos.z - dir3.Z() * (ave_dis + i * 2 * units::cm);

                        std::pair<SlimMergeGeomCell *, Point> temp_results =
                            cluster1->get_closest_point_mcell(test_point);
                        // reuse this
                        Point test_point1 = temp_results.second;
                        if (sqrt(pow(test_point1.x - test_point.x, 2) + pow(test_point1.y - test_point.y, 2) +
                                 pow(test_point1.z - test_point.z, 2)) < 1.5 * units::cm) {
                            double temp_dis = (test_point1.x - cluster2_ave_pos.x) * dir3.X() +
                                              (test_point1.y - cluster2_ave_pos.y) * dir3.Y() +
                                              (test_point1.z - cluster2_ave_pos.z) * dir3.Z();
                            temp_dis *= -1;
                            if (temp_dis < min_dis) min_dis = temp_dis;
                            if (temp_dis > max_dis) max_dis = temp_dis;
                        }
                    }
                    // std::cout << cluster1->get_cluster_id() << " " << cluster2->get_cluster_id() << " " <<
                    // min_dis/units::cm << " " << max_dis/units::cm << " " << length_1/units::cm << std::endl;

                    if ((max_dis - min_dis) > 2.5 * units::cm) return true;

                    // both side simutaneously? leave it for futhre
                }
            }
        }
    }

    return false;
}
