bool WCPPID::NeutrinoID::stem_direction(WCPPID::WCShower *max_shower, double max_energy, bool flag_print,
                                        bool flag_fill)
{
    bool flag_bad = false;
    TVector3 dir_drift(1, 0, 0);

    WCPPID::ProtoSegment *sg = max_shower->get_start_segment();
    PointVector tmp_pts;
    max_shower->fill_point_vec(tmp_pts, true);
    main_cluster->Calc_PCA(tmp_pts);
    TVector3 dir1(main_cluster->get_PCA_axis(0).x, main_cluster->get_PCA_axis(0).y, main_cluster->get_PCA_axis(0).z);

    Point vertex_point;
    if (max_shower->get_start_vertex().first->get_wcpt().index ==
        max_shower->get_start_segment()->get_wcpt_vec().front().index) {
        vertex_point = max_shower->get_start_segment()->get_point_vec().front();
    }
    else {
        vertex_point = max_shower->get_start_segment()->get_point_vec().back();
    }
    TVector3 dir_shower = max_shower->cal_dir_3vector(vertex_point, 100 * units::cm);

    double angle = 0;
    double angle1 = 0;
    double ratio = 0;
    double angle2 = fabs(dir1.Angle(dir_drift) / 3.1415926 * 180. - 90);
    double angle3 = 0;
    if (main_vertex->get_wcpt().index == sg->get_wcpt_vec().front().index) {
        TVector3 dir2 = sg->cal_dir_3vector(sg->get_point_vec().front(), 5 * units::cm);
        TVector3 dir3 = max_shower->cal_dir_3vector(sg->get_point_vec().front(), 30 * units::cm);
        angle = dir1.Angle(dir2) / 3.1415926 * 180.;
        angle3 = dir2.Angle(dir_shower) / 3.1415926 * 180.;
        if (angle > 90) angle = 180 - angle;
        angle1 = fabs(dir3.Angle(dir_drift) / 3.1415926 * 180. - 90);
        ratio = sg->get_direct_length(0, 10) / sg->get_length(0, 10);
        //	      std::cout << "Xin_A: " << max_energy/units::MeV << " " << sg->get_direct_length(0,10)/
        //sg->get_length(0,10) << " " << sg->get_length(0,10)/units::cm << " " << angle << " " <<
        //dir3.Angle(dir_drift)/3.1415926*180. << std::endl;
    }
    else {
        TVector3 dir2 = sg->cal_dir_3vector(sg->get_point_vec().back(), 5 * units::cm);
        TVector3 dir3 = max_shower->cal_dir_3vector(sg->get_point_vec().back(), 30 * units::cm);
        int num = int(sg->get_point_vec().size()) - 1;
        angle = dir1.Angle(dir2) / 3.1415926 * 180.;
        angle3 = dir2.Angle(dir_shower) / 3.1415926 * 180.;
        if (angle > 90) angle = 180 - angle;
        angle1 = fabs(dir3.Angle(dir_drift) / 3.1415926 * 180. - 90);
        ratio = sg->get_direct_length(num - 10, num) / sg->get_length(num - 10, num);
        //	      std::cout << "Xin_A: " << max_energy/units::MeV << " " << sg->get_direct_length(num-10,
        //num)/sg->get_length(num-10,num) << " " << sg->get_length(num-10,num)/units::cm << " " << angle << " " <<
        //dir3.Angle(dir_drift)/3.1415926*180. << std::endl;
    }

    // std::cout << "Xin_B: " << max_energy/units::MeV << " " << ratio  << " " << angle << " " << angle1 << " " <<
    // angle2 << std::endl;

    if (angle > 18) {
        if (max_energy > 1000 * units::MeV) {
        }
        else if (max_energy > 500 * units::MeV) {  // high energy
            if ((angle1 > 12.5 || angle2 > 12.5) && angle > 25 || (angle1 > 10 || angle2 > 10) && angle > 32) {
                if (angle3 > 3) flag_bad = true;  // 7006_293_14696
                if (flag_print)
                    std::cout << "Xin_B: " << max_energy << " " << angle1 << " " << angle2 << " " << angle << " "
                              << angle3 << " " << ratio << std::endl;
            }
        }
        else {
            if (angle > 25 && (angle1 > 7.5 || angle2 > 7.5)) {
                flag_bad = true;
                if (flag_print)
                    std::cout << "Xin_B1: " << max_energy << " " << angle1 << " " << angle2 << " " << angle << " "
                              << angle3 << " " << ratio << std::endl;
            }
            else if ((angle1 > 7.5 || angle2 > 7.5) && ratio < 0.97) {
                flag_bad = true;
                if (flag_print)
                    std::cout << "Xin_B2: " << max_energy << " " << angle1 << " " << angle2 << " " << angle << " "
                              << angle3 << " " << ratio << std::endl;
            }
        }
    }

    if (flag_fill) {
        tagger_info.stem_dir_angle = angle;
        tagger_info.stem_dir_energy = max_energy / units::MeV;
        tagger_info.stem_dir_angle1 = angle1;
        tagger_info.stem_dir_angle2 = angle2;
        tagger_info.stem_dir_angle3 = angle3;
        tagger_info.stem_dir_ratio = ratio;
    }

    // std::cout << "stem_dir: " << !flag_bad << " " << (map_vertex_segments[main_vertex].size()==1) << " " << 1 << " "
    // << angle << " " << max_energy/units::MeV << " " << angle1 << " " << angle2 << " " << angle3 << " " << ratio <<
    // std::endl;

    return flag_bad;
}

bool WCPPID::NeutrinoID::multiple_showers(WCPPID::WCShower *max_shower, double max_energy, bool flag_print,
                                          bool flag_fill)
{
    bool flag_bad = false;

    double E_total = 0;
    int nshowers = 0;
    double E_max_energy = 0;
    for (auto it1 = map_vertex_to_shower[main_vertex].begin(); it1 != map_vertex_to_shower[main_vertex].end(); it1++) {
        WCPPID::WCShower *shower = *it1;
        WCPPID::ProtoSegment *sg = shower->get_start_segment();
        if (sg->get_particle_type() != 11) continue;
        if (shower == max_shower) continue;
        auto pair_result = shower->get_start_vertex();
        if (pair_result.second > 1) continue;
        double E_shower = 0;
        if (shower->get_kine_best() != 0) {
            E_shower = shower->get_kine_best();
        }
        else {
            E_shower = shower->get_kine_charge();
        }
        bool flag_pi0 =
            pi0_identification(shower->get_start_vertex().first, shower->get_start_segment(), shower, 15 * units::MeV);
        if (flag_pi0) continue;
        if (shower->get_total_length(shower->get_start_segment()->get_cluster_id()) <
                shower->get_total_length() * 0.1 &&
            shower->get_total_length(shower->get_start_segment()->get_cluster_id()) < 10 * units::cm)
            continue;
        // 7010_532_26643
        if (shower->get_start_segment()->get_length() > 80 * units::cm) continue;
        //    if (mip_identification(shower->get_start_vertex().first, shower->get_start_segment(), shower, false,
        //    false)==-1 || track_overclustering(shower) || bad_reconstruction_3(shower->get_start_vertex().first,
        //    shower) || bad_reconstruction_2(shower->get_start_vertex().first, shower) ||
        //    gap_identification(shower->get_start_vertex().first, shower->get_start_segment(), false, 1,
        //    E_shower).first ) continue;
        if (E_shower > E_max_energy) E_max_energy = E_shower;

        if (E_shower > 50 * units::MeV) {
            E_total += E_shower;
            nshowers++;
        }

        //	    std::cout << "Xin_A: " << max_energy << " " << E_shower << " " << bad_reconstruction(shower) << " "
        //<< bad_reconstruction_1(shower) << std::endl;
    }

    if ((E_max_energy > 0.6 * max_energy ||
         E_max_energy > 0.45 * max_energy && max_energy - E_max_energy < 150 * units::MeV)) {
        flag_bad = true;
        if (flag_print) std::cout << "Xin_D_4: " << max_energy << " " << E_max_energy << std::endl;
    }

    if ((E_total > 0.6 * max_energy || max_energy < 400 * units::MeV && nshowers >= 2 && E_total > 0.3 * max_energy) &&
        (!flag_bad)) {
        flag_bad = true;
        if (flag_print) std::cout << "Xin_D_3: " << max_energy << " " << E_total << std::endl;
    }

    double total_other_energy = 0;
    double total_other_energy_1 = 0;
    int total_num_showers = 0;
    double E_max_energy_1 = 0;
    double E_max_energy_2 = 0;
    for (auto it1 = showers.begin(); it1 != showers.end(); it1++) {
        WCPPID::WCShower *shower = *it1;
        WCPPID::ProtoSegment *sg = shower->get_start_segment();
        if (sg->get_particle_type() != 11) continue;
        if (sg->get_cluster_id() == main_vertex->get_cluster_id()) continue;
        auto pair_result = shower->get_start_vertex();
        double E_shower = 0;
        if (shower->get_kine_best() != 0) {
            E_shower = shower->get_kine_best();
        }
        else {
            E_shower = shower->get_kine_charge();
        }
        //  std::cout << sg->get_cluster_id() << " " << pair_result.second << " " << E_shower << " " <<
        //  total_num_showers << std::endl;
        if (bad_reconstruction(shower)) continue;
        bool flag_pi0 =
            pi0_identification(shower->get_start_vertex().first, shower->get_start_segment(), shower, 15 * units::MeV);

        if (flag_pi0) {  // 7003_1682_84132
            if (map_shower_pio_id.find(shower) != map_shower_pio_id.end()) {
                std::vector<WCShower *> &tmp_showers = map_pio_id_showers[map_shower_pio_id[shower]];
                if (find(tmp_showers.begin(), tmp_showers.end(), max_shower) != tmp_showers.end()) {
                    //	  flag_pi0 = false;
                    if (E_shower > E_max_energy_1) E_max_energy_1 = E_shower;
                    // std::cout << "haha: " << std::endl;
                }
            }
        }

        if (flag_pi0) continue;
        //
        if (pair_result.second <= 3) {
            total_other_energy += E_shower;
            if (shower->get_start_vertex().first != main_vertex) total_other_energy_1 += E_shower;
            if (E_shower > 50 * units::MeV) total_num_showers++;
        }

        if (pair_result.second > 2) continue;
        if (E_shower > E_max_energy_2) E_max_energy_2 = E_shower;
    }

    if (E_max_energy_1 > max_energy * 0.75) flag_bad = true;
    //	  std::cout << "kaka: " << max_energy << " " << total_other_energy << " " << total_other_energy_1 << " "<<
    //total_num_showers << " " << max_shower->get_kine_dQdx() << std::endl;
    if (E_max_energy_2 > max_energy * 1.2 && max_energy < 250 * units::MeV) {  // not the highest energy ...
        flag_bad = true;
        if (flag_print) std::cout << "Xin_D_2: " << max_energy << " " << E_max_energy_2 << std::endl;
    }

    // 7014_241_12058
    if ((max_energy < 250 * units::MeV &&
             (total_other_energy - max_energy > 200 * units::MeV ||
              total_other_energy - max_energy > 60 * units::MeV && total_num_showers >= 2) ||
         max_energy > 800 * units::MeV && total_other_energy_1 > max_energy) &&
        (!flag_bad)) {
        flag_bad = true;
        if (flag_print) std::cout << "Xin_D_1: " << max_energy << " " << total_other_energy << std::endl;
    }

    if (flag_fill) {
        tagger_info.mgo_energy = max_energy / units::MeV;
        tagger_info.mgo_max_energy = E_max_energy / units::MeV;
        tagger_info.mgo_total_energy = E_total / units::MeV;
        tagger_info.mgo_n_showers = nshowers;
        tagger_info.mgo_max_energy_1 = E_max_energy_1 / units::MeV;
        tagger_info.mgo_max_energy_2 = E_max_energy_2 / units::MeV;
        tagger_info.mgo_total_other_energy = total_other_energy / units::MeV;
        tagger_info.mgo_n_total_showers = total_num_showers;
        tagger_info.mgo_total_other_energy_1 = total_other_energy_1 / units::MeV;
        tagger_info.mgo_flag = !flag_bad;

        // std::cout << "mgo: " << max_energy/units::MeV << " " << E_max_energy/units::MeV << " " << E_total/units::MeV
        // << " " << nshowers << " " << E_max_energy_1/units::MeV << " " << E_max_energy_2/units::MeV << " " <<
        // total_other_energy/units::MeV << " " << total_num_showers << " " << total_other_energy_1/units::MeV << " " <<
        // !flag_bad << std::endl;
    }

    return flag_bad;
}

bool WCPPID::NeutrinoID::other_showers(WCPPID::WCShower *shower, bool flag_single_shower, bool flag_print,
                                       bool flag_fill)
{
    bool flag_bad = false;
    double Eshower = 0;
    if (shower->get_kine_best() != 0) {
        Eshower = shower->get_kine_best();
    }
    else {
        Eshower = shower->get_kine_charge();
    }
    Point vertex_point;
    if (shower->get_start_vertex().first->get_wcpt().index ==
        shower->get_start_segment()->get_wcpt_vec().front().index) {
        vertex_point = shower->get_start_segment()->get_point_vec().front();
    }
    else {
        vertex_point = shower->get_start_segment()->get_point_vec().back();
    }

    double total_other_energy = 0;
    double max_energy = 0;

    for (auto it1 = showers.begin(); it1 != showers.end(); it1++) {
        WCPPID::WCShower *shower1 = *it1;
        WCPPID::ProtoSegment *sg1 = shower1->get_start_segment();
        if (sg1->get_particle_type() != 11) continue;
        if (sg1->get_cluster_id() == main_vertex->get_cluster_id()) continue;
        auto pair_result = shower1->get_start_vertex();
        double E_shower1 = 0;
        if (shower1->get_kine_best() != 0) {
            E_shower1 = shower1->get_kine_best();
        }
        else {
            E_shower1 = shower1->get_kine_charge();
        }

        // std::cout << sg->get_cluster_id() << " " << pair_result.second << " " << E_shower << std::endl;
        if (pair_result.second <= 3) total_other_energy += E_shower1;
        if (pair_result.second > 2) continue;

        if (E_shower1 > max_energy) {  // not the highest energy ...
            max_energy = E_shower1;
            //      if (flag_print) std::cout << "Xin_A: " << max_energy << " " << E_shower << std::endl;
        }
    }

    if (flag_single_shower && max_energy > Eshower) flag_bad = true;
    if (flag_single_shower && Eshower < 150 * units::MeV && total_other_energy > 0.27 * Eshower) {
        flag_bad = true;
        //	    if (flag_print) std::cout << "Xin_A1: " << max_energy << " " << total_other_energy << std::endl;
    }

    if (flag_print && flag_bad)
        std::cout << "Xin_N1: " << Eshower / units::MeV << " " << total_other_energy / units::MeV << " "
                  << max_energy / units::MeV << " " << flag_single_shower << std::endl;

    double E_direct_max_energy = 0, E_direct_total_energy = 0;
    double E_indirect_max_energy = 0, E_indirect_total_energy = 0;
    int n_direct_showers = 0;
    int n_indirect_showers = 0;
    bool flag_direct_max_pi0 = false;
    bool flag_indirect_max_pi0 = false;
    double max_energy_1 = 0;
    for (auto it1 = showers.begin(); it1 != showers.end(); it1++) {
        WCPPID::WCShower *shower1 = *it1;
        WCPPID::ProtoSegment *sg = shower1->get_start_segment();

        if (sg->get_particle_type() != 11) continue;
        if (shower1 == shower) continue;
        auto pair_result = shower1->get_start_vertex();
        double E_shower1 = 0;
        if (shower1->get_kine_best() != 0) {
            E_shower1 = shower1->get_kine_best();
        }
        else {
            E_shower1 = shower1->get_kine_charge();
        }

        bool flag_pi0 = pi0_identification(shower1->get_start_vertex().first, shower1->get_start_segment(), shower1,
                                           15 * units::MeV);
        if (flag_pi0) {  // 7003_1682_84132
            if (map_shower_pio_id.find(shower1) != map_shower_pio_id.end()) {
                std::vector<WCShower *> &tmp_showers = map_pio_id_showers[map_shower_pio_id[shower1]];
                if (find(tmp_showers.begin(), tmp_showers.end(), shower) != tmp_showers.end()) {
                    if (E_shower1 > max_energy_1) max_energy_1 = E_shower1;
                    // std::cout << "haha: " << std::endl;
                }
            }
        }

        //      std::cout << shower1->get_total_length(shower1->get_start_segment()->get_cluster_id())/units::cm << " "
        //      << shower1->get_total_length()/units::cm << std::endl;

        if (pair_result.second == 1) {
            // 7006_387_19382
            if (shower1->get_total_length(shower1->get_start_segment()->get_cluster_id()) <
                    shower1->get_total_length() * 0.1 &&
                shower1->get_total_length(shower1->get_start_segment()->get_cluster_id()) < 10 * units::cm)
                continue;
            // 7021_282_14130
            //	if (mip_identification(shower1->get_start_vertex().first, shower1->get_start_segment(), shower1, false,
            //false)==-1 || track_overclustering(shower1) || bad_reconstruction_3(shower1->get_start_vertex().first,
            //shower1) || bad_reconstruction_2(shower1->get_start_vertex().first, shower1) ) continue; 	if (flag_pi0)
            //continue;
            if (shower1->get_start_segment()->get_length() > 80 * units::cm) continue;
            // 6090_89_4498
            if (flag_pi0 && shower1->get_total_length(shower1->get_start_segment()->get_cluster_id()) <
                                0.12 * shower1->get_total_length())
                continue;

            //	std::cout << flag_pi0 << " " <<
            //shower1->get_total_length(shower1->get_start_segment()->get_cluster_id()) << " " <<
            //shower1->get_total_length() << std::endl;

            E_direct_total_energy += E_shower1;
            if (E_shower1 > E_direct_max_energy && shower1->get_start_vertex().first == main_vertex) {
                E_direct_max_energy = E_shower1;
                if (map_shower_pio_id.find(shower1) != map_shower_pio_id.end())
                    flag_direct_max_pi0 = true;
                else
                    flag_direct_max_pi0 = false;
            }
            if (E_shower1 > 80 * units::MeV) n_direct_showers++;
        }
        else if (pair_result.second == 2) {
            if (shower1->get_num_segments() <= 2) {
                if ((!shower1->get_start_segment()->get_flag_shower_trajectory()) &&
                    (!shower1->get_start_segment()->get_flag_shower_topology()) &&
                    shower1->get_start_segment()->get_length() > 45 * units::cm &&
                    shower1->get_start_segment()->get_length() > 0.95 * shower1->get_total_length())
                    continue;
                //	std::cout << shower1->get_start_segment()->get_length()/units::cm << " " <<
                //shower1->get_start_segment()->get_flag_shower_trajectory() << " " <<
                //shower1->get_start_segment()->get_flag_shower_topology() << std::endl;
            }
            double dis = sqrt(pow(vertex_point.x - shower1->get_start_point().x, 2) +
                              pow(vertex_point.y - shower1->get_start_point().y, 2) +
                              pow(vertex_point.z - shower1->get_start_point().z, 2));

            //	std::cout << dis/units::cm << std::endl;
            double factor = 1;
            // 6090_89_4498
            if (dis > 72 * units::cm)
                continue;
            else if (dis > 48 * units::cm)
                factor = 0.75;

            // std::cout <<  E_shower1 << " " << flag_pi0 << std::endl;
            if (!flag_pi0) {
                E_indirect_total_energy += E_shower1;
                if (E_shower1 * factor > E_indirect_max_energy) {
                    E_indirect_max_energy = E_shower1 * factor;
                    if (map_shower_pio_id.find(shower1) != map_shower_pio_id.end())
                        flag_indirect_max_pi0 = true;
                    else
                        flag_indirect_max_pi0 = false;
                }
            }

            if (E_shower1 > 80 * units::MeV) n_indirect_showers++;
        }
    }

    if (max_energy_1 > Eshower * 0.75) flag_bad = true;
    if (E_indirect_max_energy > Eshower + 350 * units::MeV || E_direct_max_energy > Eshower) flag_bad = true;
    if (Eshower < 1000 * units::MeV && n_direct_showers > 0 && E_direct_max_energy > 0.33 * Eshower) flag_bad = true;
    if (Eshower >= 1000 * units::MeV && n_direct_showers > 0 && E_direct_max_energy > 0.33 * Eshower &&
        E_direct_total_energy > 900 * units::MeV)
        flag_bad = true;

    // 6748_57_2867 + 7004_1604_80229
    if (flag_indirect_max_pi0) {
        if (Eshower < 800 * units::MeV && E_indirect_total_energy - E_indirect_max_energy > Eshower &&
            E_indirect_max_energy > 0.5 * Eshower)
            flag_bad = true;
    }
    else {
        if (Eshower < 800 * units::MeV && E_indirect_total_energy > Eshower * 0.6 &&
            E_indirect_max_energy > 0.5 * Eshower)
            flag_bad = true;
    }

    if (flag_fill) {
        tagger_info.mgt_flag_single_shower = flag_single_shower;
        tagger_info.mgt_max_energy = max_energy / units::MeV;
        tagger_info.mgt_energy = Eshower / units::MeV;
        tagger_info.mgt_total_other_energy = total_other_energy / units::MeV;
        tagger_info.mgt_max_energy_1 = max_energy_1 / units::MeV;
        tagger_info.mgt_e_indirect_max_energy = E_indirect_max_energy / units::MeV;
        tagger_info.mgt_e_direct_max_energy = E_direct_max_energy / units::MeV;
        tagger_info.mgt_n_direct_showers = n_direct_showers;
        tagger_info.mgt_e_direct_total_energy = E_direct_total_energy / units::MeV;
        tagger_info.mgt_e_indirect_total_energy = E_indirect_total_energy / units::MeV;
        tagger_info.mgt_flag_indirect_max_pio = flag_indirect_max_pi0;
        tagger_info.mgt_flag = !flag_bad;

        // std::cout << "mgt: " << flag_single_shower << " " << max_energy/units::MeV << " " << Eshower/units::MeV << "
        // " << total_other_energy/units::MeV << " " << max_energy_1/units::MeV << " " <<
        // E_indirect_max_energy/units::MeV << " " << E_direct_max_energy/units::MeV << " " << n_direct_showers << " "
        // << E_direct_total_energy/units::MeV << " " << flag_indirect_max_pi0 << " " <<
        // E_indirect_total_energy/units::MeV << " " << !flag_bad << std::endl;
    }

    if (flag_print && flag_bad)
        std::cout << "Xin_N0: " << Eshower << " " << n_direct_showers << " " << E_direct_max_energy << " "
                  << flag_direct_max_pi0 << " " << E_direct_total_energy << " " << n_indirect_showers << " "
                  << E_indirect_max_energy << " " << flag_indirect_max_pi0 << " " << E_indirect_total_energy
                  << std::endl;

    return flag_bad;
}

bool WCPPID::NeutrinoID::stem_length(WCPPID::WCShower *max_shower, double max_energy, bool flag_print, bool flag_fill)
{
    bool flag_bad = false;
    WCPPID::ProtoSegment *sg = max_shower->get_start_segment();
    auto pair_result = calculate_num_daughter_tracks(max_shower->get_start_vertex().first, sg, true);

    if (max_energy < 500 * units::MeV && sg->get_length() > 50 * units::cm && (!sg->get_flag_avoid_muon_check())) {
        flag_bad = true;

        if (pair_result.first > 6 && sg->get_length() < 55 * units::cm) flag_bad = false;

        if (flag_print)
            std::cout << "Xin_F_0: " << max_energy << " " << sg->get_length() / units::cm << " " << pair_result.first
                      << std::endl;
    }

    if (flag_fill) {
        tagger_info.stem_len_energy = max_energy / units::MeV;
        tagger_info.stem_len_length = sg->get_length() / units::cm;
        tagger_info.stem_len_flag_avoid_muon_check = sg->get_flag_avoid_muon_check();
        tagger_info.stem_len_num_daughters = pair_result.first;
        tagger_info.stem_len_daughter_length = pair_result.second / units::cm;
        tagger_info.stem_len_flag = !flag_bad;

        // std::cout << "stem_len: " << max_energy/units::MeV << " " << sg->get_length()/units::cm << " " <<
        // sg->get_flag_avoid_muon_check() << " " << pair_result.first << " " << pair_result.second/units::cm << " " <<
        // !flag_bad << std::endl;
    }

    return flag_bad;
}

bool WCPPID::NeutrinoID::vertex_inside_shower(WCPPID::WCShower *shower, bool flag_print, bool flag_fill)
{
    bool flag_bad = false;

    bool flag_bad1 = false;
    bool flag_bad2 = false;

    TVector3 drift_dir(1, 0, 0);
    TVector3 beam_dir(0, 0, 1);

    double Eshower = 0;
    if (shower->get_kine_best() != 0) {
        Eshower = shower->get_kine_best();
    }
    else {
        Eshower = shower->get_kine_charge();
    }

    WCPPID::ProtoVertex *vertex = shower->get_start_vertex().first;
    WCPPID::ProtoSegment *sg = shower->get_start_segment();
    Point vertex_point;
    if (vertex->get_wcpt().index == sg->get_wcpt_vec().front().index) {
        vertex_point = sg->get_point_vec().front();
    }
    else {
        vertex_point = sg->get_point_vec().back();
    }

    {
        // shower direction ...
        TVector3 dir1;
        if (vertex->get_wcpt().index == shower->get_start_segment()->get_wcpt_vec().front().index) {
            dir1 = shower->cal_dir_3vector(shower->get_start_segment()->get_point_vec().front(), 30 * units::cm);
        }
        else {
            dir1 = shower->cal_dir_3vector(shower->get_start_segment()->get_point_vec().back(), 30 * units::cm);
        }

        double max_angle = 0;
        WCPPID::ProtoSegment *max_sg = 0;
        int num_good_tracks = 0;
        for (auto it = map_vertex_segments[vertex].begin(); it != map_vertex_segments[vertex].end(); it++) {
            WCPPID::ProtoSegment *sg1 = *it;
            if (sg1 == shower->get_start_segment()) continue;
            TVector3 dir2 = sg1->cal_dir_3vector(vertex_point, 15 * units::cm);
            double angle = dir2.Angle(dir1) / 3.1415926 * 180.;
            if ((!sg1->get_flag_shower()) && (!sg1->is_dir_weak())) {
                num_good_tracks++;
            }
            //	    std::cout << sg->get_length()/units::cm << " " << angle << std::endl;
            if (angle > max_angle && sg1->get_length() > 1.0 * units::cm) {
                max_angle = angle;
                max_sg = sg;
            }
        }

        double max_shower_angle = 0;
        dir1 = shower->cal_dir_3vector(vertex_point, 100 * units::cm);
        for (auto it = showers.begin(); it != showers.end(); it++) {
            WCPPID::WCShower *shower1 = *it;
            if (shower1 == shower) continue;
            if (shower1->get_start_vertex().second > 2) continue;
            double energy = 0;
            if (shower1->get_kine_best() != 0) {
                energy = shower1->get_kine_best();
            }
            else {
                energy = shower1->get_kine_charge();
            }

            TVector3 dir2(shower1->get_start_point().x - vertex_point.x, shower1->get_start_point().y - vertex_point.y,
                          shower1->get_start_point().z - vertex_point.z);
            TVector3 dir3 = shower1->cal_dir_3vector(shower1->get_start_point(), 100 * units::cm);

            if (energy > 30 * units::MeV && energy > 0.2 * Eshower && dir2.Angle(dir3) / 3.1415926 * 180. < 20) {
                double angle1 = dir1.Angle(dir3) / 3.1415926 * 180.;
                if (max_shower_angle < angle1) max_shower_angle = angle1;
                // std::cout << Eshower/units::MeV << " " << energy/units::MeV << " " << dir1.Angle(dir3)/3.1415926*180.
                // << " " << dir2.Angle(dir3)/3.1415926*180. << std::endl;
            }
        }

        if (max_sg != 0) {
            double tmp_length1 = max_sg->get_length();
            double tmp_length2 = shower->get_start_segment()->get_length();
            if (map_vertex_segments[vertex].size() >= 3 && Eshower < 500 * units::MeV && num_good_tracks == 0 &&
                (max_angle > 150 && (tmp_length1 < 15 * units::cm || tmp_length2 < 15 * units::cm) &&
                     std::max(tmp_length1, tmp_length2) < 25 * units::cm ||
                 (max_angle > 170 || max_shower_angle > 170 && max_angle > 120) &&
                     (tmp_length1 < 25 * units::cm || tmp_length2 < 25 * units::cm) &&
                     std::max(tmp_length1, tmp_length2) < 35 * units::cm)) {
                flag_bad1 = true;
                if (flag_print)
                    std::cout << "Xin_O_3: " << Eshower << " " << map_vertex_segments[vertex].size() << " "
                              << num_good_tracks << " " << max_angle << " " << max_sg->get_length() / units::cm << " "
                              << shower->get_start_segment()->get_length() / units::cm << std::endl;
            }
            else if (map_vertex_segments[vertex].size() == 2 && Eshower < 500 * units::MeV && num_good_tracks == 0 &&
                     max_angle > 150 && max_sg->get_particle_type() == 13 &&
                     (tmp_length1 < 35 * units::cm || tmp_length2 < 35 * units::cm)) {
                flag_bad1 = true;
                if (flag_print)
                    std::cout << "Xin_O_2: " << Eshower << " " << map_vertex_segments[vertex].size() << " "
                              << num_good_tracks << " " << max_angle << " " << max_sg->get_length() / units::cm << " "
                              << shower->get_start_segment()->get_length() / units::cm << std::endl;
            }

            //      std::cout << "kaka: " << Eshower/units::MeV << " " << max_angle << " " << max_shower_angle << " " <<
            //      map_vertex_segments[main_vertex].size() << " " << max_sg->get_particle_type()  << " " <<
            //      max_sg->is_dir_weak() << " " << max_sg->get_medium_dQ_dx()/(43e3/units::cm) << " " <<
            //      num_good_tracks << " " << tmp_length1/units::cm << " " << tmp_length2/units::cm << " " << std::endl;

            if (flag_fill) {
                tagger_info.vis_1_filled = true;
                tagger_info.vis_1_n_vtx_segs = map_vertex_segments[vertex].size();
                tagger_info.vis_1_energy = Eshower / units::MeV;
                tagger_info.vis_1_num_good_tracks = num_good_tracks;
                tagger_info.vis_1_max_angle = max_angle;
                tagger_info.vis_1_max_shower_angle = max_shower_angle;
                tagger_info.vis_1_tmp_length1 = tmp_length1 / units::cm;
                tagger_info.vis_1_tmp_length2 = tmp_length2 / units::cm;
                tagger_info.vis_1_particle_type = max_sg->get_particle_type();
                tagger_info.vis_1_flag = !flag_bad1;

                //	std::cout << "vis_1: " << 1 << " " << map_vertex_segments[vertex].size() << " " <<
                //Eshower/units::MeV << " " << num_good_tracks << " " << max_angle << " " << tmp_length1/units::cm << "
                //" << tmp_length2/units::cm << " " << max_sg->get_particle_type() << " " << !flag_bad1 << std::endl;
            }
        }
    }

    {
        if (map_vertex_segments[vertex].size() > 1) {
            TVector3 dir_shower;
            if (shower->get_start_segment()->get_length() > 12 * units::cm) {
                dir_shower = shower->get_start_segment()->cal_dir_3vector(vertex_point, 15 * units::cm);
            }
            else {
                dir_shower = shower->cal_dir_3vector(vertex_point, 15 * units::cm);
            }
            if (fabs(dir_shower.Angle(drift_dir) / 3.1415926 * 180. - 90) < 10 || Eshower > 800 * units::MeV)
                dir_shower = shower->cal_dir_3vector(vertex_point, 25 * units::cm);
            dir_shower = dir_shower.Unit();

            double max_angle = 0;
            double max_angle1 = 0;
            int max_weak_track = 0;
            double max_length = 0;
            double max_medium_dQ_dx = 0;

            double min_angle = 180;
            double min_angle1 = 0;
            int min_weak_track = 0;
            double min_length = 0;
            double min_medium_dQ_dx = 0;

            TVector3 dir2 = sg->cal_dir_3vector(vertex_point, 6 * units::cm);

            for (auto it = map_vertex_segments[vertex].begin(); it != map_vertex_segments[vertex].end(); it++) {
                WCPPID::ProtoSegment *sg1 = *it;
                if (sg1 == shower->get_start_segment()) continue;
                TVector3 dir1 = sg1->cal_dir_3vector(vertex_point, 15 * units::cm);

                double angle = std::min(180 - dir1.Angle(dir_shower) / 3.1415926 * 180.,
                                        180 - dir1.Angle(dir2) / 3.1415926 * 180.);

                if (angle > max_angle) {
                    max_angle = angle;
                    max_angle1 = fabs(3.1415926 / 2. - dir1.Angle(drift_dir)) / 3.1415926 * 180.;
                    max_weak_track = sg1->is_dir_weak();
                    max_length = sg1->get_length();
                    max_medium_dQ_dx = sg1->get_medium_dQ_dx() / (43e3 / units::cm);
                }

                if (angle < min_angle) {
                    min_angle = angle;
                    min_angle1 = fabs(3.1415926 / 2. - dir1.Angle(drift_dir)) / 3.1415926 * 180.;
                    min_weak_track = sg1->is_dir_weak();
                    min_length = sg1->get_length();
                    min_medium_dQ_dx = sg1->get_medium_dQ_dx() / (43e3 / units::cm);
                }
            }

            // 6090_85_4300
            if (map_vertex_segments[vertex].size() == 2 && (min_angle < 25 && min_weak_track == 1 || min_angle < 20) &&
                beam_dir.Angle(dir_shower) / 3.1415926 * 180. > 50)
                flag_bad2 = true;
            if (map_vertex_segments[vertex].size() == 2 && min_angle < 70 && min_angle1 < 10 &&
                fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180. < 10 &&
                (fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180. + min_angle1) < 15 &&
                min_medium_dQ_dx > 1.5 && min_medium_dQ_dx < 2.2) {
                flag_bad2 = true;
                // 7001_100_5003 ... very short ...
                if (min_length < 4 * units::cm && min_angle > 45 && sg->get_length() > 30 * units::cm)
                    flag_bad2 = false;
            }
            // 7003_1740_87003
            if (map_vertex_segments[vertex].size() == 3 &&
                (min_angle < 15 && min_medium_dQ_dx < 2.1 ||
                 min_angle < 17.5 && min_length < 5.0 * units::cm && min_medium_dQ_dx < 2.5) &&
                (min_weak_track == 1 && max_angle > 120 ||
                 min_length < 6 * units::cm && max_angle > 135 && min_angle < 12.5 && max_weak_track == 1)) {
                // 7004_8_428
                if (max_length > 40 * units::cm && max_weak_track == 0) {
                }
                else {
                    flag_bad2 = true;
                }
            }

            if (map_vertex_segments[vertex].size() == 3 && (min_angle < 5 && min_medium_dQ_dx < 2.1) &&
                min_length < 10 * units::cm && max_angle > 90 && max_weak_track == 1)
                flag_bad2 = true;
            if (map_vertex_segments[vertex].size() == 3 && min_angle < 35 && min_angle1 < 10 &&
                fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180. < 10 &&
                (fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180. + min_angle1) < 15 &&
                (min_medium_dQ_dx < 2.1) && min_weak_track == 1 && max_angle > 120)
                flag_bad2 = true;

            if (flag_fill) {
                tagger_info.vis_2_filled = true;
                tagger_info.vis_2_n_vtx_segs = map_vertex_segments[vertex].size();
                tagger_info.vis_2_min_angle = min_angle;
                tagger_info.vis_2_min_weak_track = min_weak_track;
                tagger_info.vis_2_angle_beam = beam_dir.Angle(dir_shower) / 3.1415926 * 180.;
                tagger_info.vis_2_min_angle1 = min_angle1;
                tagger_info.vis_2_iso_angle1 = fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180.;
                tagger_info.vis_2_min_medium_dQ_dx = min_medium_dQ_dx;
                tagger_info.vis_2_min_length = min_length / units::cm;
                tagger_info.vis_2_sg_length = sg->get_length() / units::cm;
                tagger_info.vis_2_max_angle = max_angle;
                tagger_info.vis_2_max_weak_track = max_weak_track;
                tagger_info.vis_2_flag = !flag_bad2;

                //	std::cout << "vis_2: " << 1 << " " << map_vertex_segments[vertex].size() << " " << min_angle <<
                //" " << min_weak_track << " " << beam_dir.Angle(dir_shower)/3.1415926*180. << " " << min_angle1 << " "
                //<< fabs(3.1415926/2. - drift_dir.Angle(dir_shower))/3.1415926*180. << " " << min_medium_dQ_dx << " "
                //<< min_length/units::cm << " " << sg->get_length()/units::cm << " " << max_angle << " " <<
                //max_weak_track << " " << !flag_bad2 << std::endl;
            }

            if (flag_print && flag_bad2)
                std::cout << "Xin_O_1: " << Eshower << " " << map_vertex_segments[vertex].size() << " " << max_angle
                          << " " << max_angle1 << " " << max_weak_track << " " << max_length / units::cm << " "
                          << max_medium_dQ_dx << " " << min_angle << " " << min_angle1 << " " << min_weak_track << " "
                          << min_length / units::cm << " " << min_medium_dQ_dx << " "
                          << fabs(3.1415926 / 2. - drift_dir.Angle(dir_shower)) / 3.1415926 * 180. << " "
                          << beam_dir.Angle(dir_shower) / 3.1415926 * 180. << std::endl;
        }
    }

    flag_bad = flag_bad1 || flag_bad2;
    if (flag_fill) {
        tagger_info.vis_flag = !flag_bad;
    }

    return flag_bad;
}

bool WCPPID::NeutrinoID::compare_muon_energy(WCPPID::WCShower *max_shower, double max_energy, double muon_length,
                                             bool flag_print, bool flag_fill)
{
    bool flag_bad = false;

    TVector3 dir_drift(1, 0, 0);
    WCPPID::ProtoVertex *vertex = max_shower->get_start_vertex().first;
    WCPPID::ProtoSegment *sg = max_shower->get_start_segment();
    Point vertex_point;
    if (vertex->get_wcpt().index == sg->get_wcpt_vec().front().index) {
        vertex_point = sg->get_point_vec().front();
    }
    else {
        vertex_point = sg->get_point_vec().back();
    }
    TVector3 dir_shower;
    if (max_shower->get_start_segment()->get_length() > 12 * units::cm) {
        dir_shower = max_shower->get_start_segment()->cal_dir_3vector(vertex_point, 15 * units::cm);
    }
    else {
        dir_shower = max_shower->cal_dir_3vector(vertex_point, 15 * units::cm);
    }
    if (fabs(dir_shower.Angle(dir_drift) / 3.1415926 * 180. - 90) < 10 || max_energy > 800 * units::MeV)
        dir_shower = max_shower->cal_dir_3vector(vertex_point, 25 * units::cm);
    dir_shower = dir_shower.Unit();

    TVector3 dir_beam(0, 0, 1);

    TPCParams &mp = Singleton<TPCParams>::Instance();
    TGraph *g_range = mp.get_muon_r2ke();
    // check muon  ...
    double E_muon = g_range->Eval(muon_length / units::cm) * units::MeV;

    for (auto it1 = map_vertex_segments[main_vertex].begin(); it1 != map_vertex_segments[main_vertex].end(); it1++) {
        WCPPID::ProtoSegment *sg1 = *it1;
        if (sg1->get_particle_type() == 13 || sg1->get_particle_type() == 2212) {
            double length = sg1->get_length();
            double medium_dQ_dx = sg1->get_medium_dQ_dx();
            double dQ_dx_cut = 0.8866 + 0.9533 * pow(18 * units::cm / length, 0.4234);
            //	      std::cout << medium_dQ_dx/(43e3/units::cm) << " " << length/units::cm << " " << dQ_dx_cut <<
            //std::endl;
            if (medium_dQ_dx < dQ_dx_cut * 43e3 / units::cm) {
                double tmp_energy = g_range->Eval(sg1->get_length() / units::cm) * units::MeV;
                if (tmp_energy > E_muon) E_muon = tmp_energy;
            }
        }
    }

    //	  std::cout << "kaka: " << E_muon << " " << max_energy << " " << max_shower->get_kine_dQdx() << " " <<
    //muon_length/units::cm << " " << max_shower->get_total_length()/units::cm << std::endl;

    double tmp_shower_total_length = max_shower->get_total_length();

    bool flag_numuCC = (neutrino_type >> 2) & 1U;

    if (E_muon > max_energy && max_energy < 550 * units::MeV || muon_length > tmp_shower_total_length ||
        muon_length > 80 * units::cm ||
        muon_length > 0.6 * tmp_shower_total_length && max_energy < 500 * units::MeV  // round 2 debug
    ) {
        flag_bad = true;
        if (flag_print)
            std::cout << "Xin_E_1: " << max_energy << " " << E_muon << " " << muon_length / units::cm << " "
                      << tmp_shower_total_length / units::cm << " " << dir_beam.Angle(dir_shower) / 3.1415926 * 180.
                      << " " << flag_numuCC << std::endl;
    }

    if (flag_fill) {
        tagger_info.cme_mu_energy = E_muon / units::MeV;
        tagger_info.cme_energy = max_energy / units::MeV;
        tagger_info.cme_mu_length = muon_length / units::cm;
        tagger_info.cme_length = tmp_shower_total_length / units::cm;
        tagger_info.cme_angle_beam = dir_beam.Angle(dir_shower) / 3.1415926 * 180.;
        tagger_info.cme_flag = !flag_bad;

        //  std::cout << "cme: " << E_muon/units::MeV << " " << max_energy/units::MeV << " " << muon_length/units::cm <<
        //  " " << tmp_shower_total_length/units::cm << " " << dir_beam.Angle(dir_shower)/3.1415926*180. << " " <<
        //  !flag_bad << std::endl;
    }
    //	  std::cout << "Xin_A: " << max_energy << " " << E_muon << " " << muon_length/units::cm << std::endl;

    return flag_bad;
}
