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

#include "Minuit2/FunctionMinimum.h"
#include "Minuit2/MnUserParameterState.h"
#include "Minuit2/MnMigrad.h"
//#include "Minuit2/MnMinos.h"
//#include "Minuit2/MnContours.h"
//#include "Minuit2/MnPlot.h"
#include "TVector3.h"

using namespace WCP;

WCVertex::WCVertex(MergeSpaceCell &msc)
  : msc(&msc)
{
    center = msc.Get_Center();
}

float WCVertex::center_dist()
{
    float dis = sqrt(pow(center.x - msc->Get_Center().x, 2) + pow(center.y - msc->Get_Center().y, 2) +
                     pow(center.z - msc->Get_Center().z, 2));
    return dis;
}

WCVertex::~WCVertex() {}

void WCVertex::reset_center() { center = msc->Get_Center(); }

void WCVertex::set_ky(WCTrack *track, double ky)
{
    if (tracks_ky.size() == 0) {
        tracks_ky.resize(tracks.size());
    }
    while (tracks_ky.size() < tracks.size()) {
        tracks_ky.push_back(0);
    }
    auto it = find(tracks.begin(), tracks.end(), track);
    tracks_ky.at(it - tracks.begin()) = ky;
}

void WCVertex::set_kz(WCTrack *track, double kz)
{
    if (tracks_kz.size() == 0) {
        tracks_kz.resize(tracks.size());
    }
    while (tracks_kz.size() < tracks.size()) {
        tracks_kz.push_back(0);
    }
    auto it = find(tracks.begin(), tracks.end(), track);
    tracks_kz.at(it - tracks.begin()) = kz;
}

double WCVertex::get_ky(WCTrack *track)
{
    auto it = find(tracks.begin(), tracks.end(), track);
    return tracks_ky.at(it - tracks.begin());
}

double WCVertex::get_kz(WCTrack *track)
{
    auto it = find(tracks.begin(), tracks.end(), track);
    return tracks_kz.at(it - tracks.begin());
}

//   return 0;
// }

double MyFCN::get_chi2(const std::vector<double> &xx) const
{
    double chi2 = 0;
    double charge = 0;

    int ntracks = vertex->get_tracks().size();
    double x, y, z;
    double ky[100], kz[100];

    if (ntracks == 1) {
        x = vertex->get_msc()->Get_Center().x;
        y = xx[0];
        z = xx[1];
        ky[0] = xx[2];
        kz[0] = xx[3];
    }
    else {
        x = xx[0];
        y = xx[1];
        z = xx[2];
        for (int i = 0; i != ntracks; i++) {
            ky[i] = xx[3 + 2 * i];
            kz[i] = xx[3 + 2 * i + 1];
        }
    }

    double x0 = vertex->get_msc()->Get_Center().x;

    for (int i = 0; i != ntracks; i++) {
        WCTrack *track = vertex->get_tracks().at(i);
        MergeSpaceCellSelection cells = track->get_all_cells();

        double x01 = 0;
        int flag_check_range = 1;
        // auto it = find(track->get_end_scells().begin(),track->get_end_scells().end(),mscell);
        if (vertex->get_msc() == track->get_end_scells().at(0)) {
            x01 = track->get_end_scells().at(1)->Get_Center().x;
        }
        else if (vertex->get_msc() == track->get_end_scells().at(1)) {
            x01 = track->get_end_scells().at(0)->Get_Center().x;
        }
        else {
            flag_check_range = 0;
        }

        // calculate medium
        std::vector<double> dy_all, dz_all;

        for (int j = 0; j != cells.size(); j++) {
            MergeSpaceCell *mscell = cells.at(j);
            MergeSpaceCell *prev_mscell = mscell;
            MergeSpaceCell *next_mscell = mscell;

            if (cells.size() >= 3) {
                if (j == 0) {
                    prev_mscell = cells.at(2);
                    next_mscell = cells.at(1);
                }
                else if (j == cells.size() - 1) {
                    prev_mscell = cells.at(cells.size() - 2);
                    next_mscell = cells.at(cells.size() - 3);
                }
                else {
                    prev_mscell = cells.at(j - 1);
                    next_mscell = cells.at(j + 1);
                }
            }

            double xc = mscell->Get_Center().x;

            int flag = 0;
            if (vertex->get_fit_type() == 1) {
                if (fabs(xc - x0) / units::cm < 5) flag = 1;
            }
            else if (vertex->get_fit_type() == 2) {
                if ((fabs(xc - x0) / units::cm < 5 &&
                     fabs(xc - x0) > 1.6 * Singleton<TPCParams>::Instance().get_ts_width() && fit_flag == 0) ||
                    (fabs(xc - x0) / units::cm < 6 &&
                     fabs(xc - x0) > 3.1 * Singleton<TPCParams>::Instance().get_ts_width() && fit_flag != 0))
                    flag = 1;
            }

            if (flag == 1) {
                double dy = sqrt(
                    (pow(mscell->get_dy(), 2) + pow(prev_mscell->get_dy(), 2) + pow(next_mscell->get_dy(), 2)) / 3.);
                double dz = sqrt(
                    (pow(mscell->get_dz(), 2) + pow(prev_mscell->get_dz(), 2) + pow(next_mscell->get_dz(), 2)) / 3.);

                // double dy = mscell->get_dy();
                // double dz = mscell->get_dz();

                if (dy == 0) dy = Singleton<TPCParams>::Instance().get_pitch() / 2.;
                if (dz == 0) dz = Singleton<TPCParams>::Instance().get_pitch() / 2.;
                dy_all.push_back(dy);
                dz_all.push_back(dz);
            }
        }

        double dy_ave, dz_ave;
        size_t n_ave = dy_all.size() / 2.;
        //   std::cout << n_ave << " " << dy_all.size() << std::endl;
        if (dy_all.size() > 0) {
            nth_element(dy_all.begin(), dy_all.begin() + n_ave, dy_all.end());
            dy_ave = dy_all[n_ave];
            nth_element(dz_all.begin(), dz_all.begin() + n_ave, dz_all.end());
            dz_ave = dz_all[n_ave];
        }
        else {
            dy_ave = Singleton<TPCParams>::Instance().get_pitch() / 2.;
            dz_ave = Singleton<TPCParams>::Instance().get_pitch() / 2.;
        }

        for (int j = 0; j != cells.size(); j++) {
            MergeSpaceCell *mscell = cells.at(j);
            MergeSpaceCell *prev_mscell = mscell;
            MergeSpaceCell *next_mscell = mscell;

            if (cells.size() >= 3) {
                if (j == 0) {
                    prev_mscell = cells.at(2);
                    next_mscell = cells.at(1);
                }
                else if (j == cells.size() - 1) {
                    prev_mscell = cells.at(cells.size() - 2);
                    next_mscell = cells.at(cells.size() - 3);
                }
                else {
                    prev_mscell = cells.at(j - 1);
                    next_mscell = cells.at(j + 1);
                }
            }

            double xc = mscell->Get_Center().x;

            // if (vertex->get_fit_type() == 1){
            // 	if (fabs(xc-x0)/units::cm < 5)
            // 	  flag = 1;
            // }else if (vertex->get_fit_type()==2){
            // 	if ((fabs(xc-x0)/units::cm < 5 && fabs(xc-x0)/units::cm > 0.5 && fit_flag == 0) ||
            // (fabs(xc-x0)/units::cm < 6 && fabs(xc-x0)/units::cm > 1.0 && fit_flag != 0)) 	  flag = 1;
            // }

            // if ( (fabs(xc-x0)/units::cm < 5 && ntracks < 2)
            // 	   || (fabs(xc-x0)/units::cm < 5 && fabs(xc-x0)/units::cm > 0.5 && ntracks >=2)){
            // 	flag = 1;
            // }
            // if (ntracks==1){
            // 	if (fabs(xc-x0)/units::cm > 0.1 && )
            // 	  flag = 1;
            // }else if (ntracks>1){
            // 	if (fabs(xc-x0)/units::cm > 0.7 && fabs(xc-x0)/units::cm < 5)
            // 	  flag = 1;
            // }
            // if (it != track->get_end_scells().end()){
            // 	flag = 0;
            // }

            double x1 = mscell->Get_Center().x;
            double y1 = mscell->Get_Center().y;
            double z1 = mscell->Get_Center().z;
            // double q = mscell->Get_Charge();
            double q = 1;

            double dy =
                sqrt((pow(mscell->get_dy(), 2) + pow(prev_mscell->get_dy(), 2) + pow(next_mscell->get_dy(), 2)) / 3.);
            double dz =
                sqrt((pow(mscell->get_dz(), 2) + pow(prev_mscell->get_dz(), 2) + pow(next_mscell->get_dz(), 2)) / 3.);

            // double dy = mscell->get_dy();
            // double dz = mscell->get_dz();

            if (dy == 0) dy = Singleton<TPCParams>::Instance().get_pitch() / 2.;
            if (dz == 0) dz = Singleton<TPCParams>::Instance().get_pitch() / 2.;

            int flag = 0;
            if (vertex->get_fit_type() == 1) {
                if (fabs(xc - x0) / units::cm < 5) flag = 1;
            }
            else if (vertex->get_fit_type() == 2) {
                if (((fabs(xc - x0) / units::cm < 5 && fit_flag == 0) ||
                     (fabs(xc - x0) / units::cm < 6 && fit_flag != 0)) &&
                    (dy < dy_ave * 2 && dz < dz_ave * 2))
                    flag = 1;
            }

            double a, b, c, d;

            a = y - ky[i] * x;
            b = ky[i];
            c = z - kz[i] * x;
            d = kz[i];

            double x2 = (-a * b - c * d + b * y1 + d * z1 + x1) / (1 + b * b + d * d);
            double y2 = a + b * x2;
            double z2 = c + d * x2;

            //	chi2 += (pow(x2-x1,2)+pow(y2-y1,2)+pow(z2-z1,2))*q/0.15/0.15*3./units::cm/units::cm;
            if (flag == 1) {
                chi2 += (pow(x2 - x1, 2) / pow(Singleton<TPCParams>::Instance().get_ts_width() / 2., 2) * 3 +
                         pow(y2 - y1, 2) / pow(dy, 2) * 3 + pow(z2 - z1, 2) / pow(dz, 2) * 3) *
                        q;

                //  	std::cout << i << " " << j << " " << x << " " << y << " " << z << " " << ky[i] << " " << kz[i]
                //  << std::endl;

                charge += q;

                // std::cout << flag_check_range << " " << i << " " << x1 << " " << y1 << " " << z1 << " "
                // 	  << x << " " << x0 << " " << x01 << std::endl;

                if (flag_check_range == 1) {
                    if ((x01 - x0) * (x1 - x) < 0) {
                        chi2 += (pow(x2 - x1, 2) / pow(Singleton<TPCParams>::Instance().get_ts_width() / 2., 2) * 3. +
                                 pow(y2 - y1, 2) / pow(dy, 2) * 3 + pow(z2 - z1, 2) / pow(dz, 2) * 3) *
                                10;
                    }
                }
            }
            else {
                // if (fabs(x2-x1) <= 0.16*units::cm &&
                //     fabs(y2-y1) <= fabs(dy) &&
                //     fabs(z2-z1) <= fabs(dz) ){
                // }else{
                //   chi2 += q;
                // }
            }

            // if (flag == 1 ){
            // 	// 1.0-5 cm

            // 	//std::cout << xc/units::cm << " " << x0/units::cm << std::endl;

            // 	SpaceCellSelection scells = mscell->Get_all_spacecell();
            // 	for (int k=0;k!=scells.size();k++){
            // 	  double x1 = scells.at(k)->x();
            // 	  double y1 = scells.at(k)->y();
            // 	  double z1 = scells.at(k)->z();
            // 	  double q = scells.at(k)->q();

            // 	  double a,b,c,d;

            // 	  a = y - ky[i]*x;
            // 	  b = ky[i];
            // 	  c = z - kz[i]*x;
            // 	  d = kz[i];

            // 	  double x2 = (-a*b-c*d+b*y1+d*z1+x1)/(1+b*b+d*d);
            // 	  double y2 = a + b*x2;
            // 	  double z2 = c + d*x2;

            // 	  // std::cout << x1/units::cm << " " << x2/units::cm << " " <<
            // 	  //   y1/units::cm << " " << y2/units::cm << " " <<
            // 	  //   z1/units::cm << " " << z2/units::cm << " " <<  q <<
            // 	  //   std::endl;
            // 	  // TVector3 n(1,ky[i],kz[i]);
            // 	  // TVector3 p(x-x1,y-x1,z-x1);
            // 	  // TVector3 v = p.Cross(n);
            // 	  // double dis = v.Mag()/n.Mag();

            // 	  chi2 += (pow(x2-x1,2)+pow(y2-y1,2)+pow(z2-z1,2))*q/0.15/0.15*3./units::cm/units::cm;
            // 	  charge += q;
            // 	}
            //}
        }
    }

    // std::cout << chi2 << " " << charge << std::endl;

    return chi2 / charge;
}

double MyFCN::operator()(const std::vector<double> &xx) const { return get_chi2(xx); }

bool WCVertex::FindVertex(int flag)
{
    // hack ...
    // if (tracks.size()>3){
    //   //    tracks.erase(tracks.begin()+4);
    //   tracks.erase(tracks.begin()+3);
    //   tracks.erase(tracks.begin()+2);
    //   tracks.erase(tracks.begin()+1);
    //   tracks.erase(tracks.begin()+0);
    // }

    WCTrackSelection bad_tracks;
    for (int i = 0; i != tracks.size(); i++) {
        if (tracks.at(i)->get_all_cells().size() == 1) bad_tracks.push_back(tracks.at(i));
    }
    for (int i = 0; i != bad_tracks.size(); i++) {
        auto it = find(tracks.begin(), tracks.end(), bad_tracks.at(i));
        tracks.erase(it);
    }

    MyFCN fcn(this, flag);
    int ntracks = tracks.size();

    std::vector<double> variable;
    int npar;

    if (ntracks == 1) {
        // 4 parameters, (2 for vertex y,z) and two directions
        npar = 4;
        variable.push_back(center.y);
        variable.push_back(center.z);

        WCTrack *track = tracks.at(0);
        MergeSpaceCell *a1 = track->get_end_scells().at(0);
        MergeSpaceCell *a2 = track->get_end_scells().at(1);

        // float dis1 = fabs(a1->Get_Center().x-center.x);
        // float dis2 = fabs(a2->Get_Center().x-center.x);
        float ky, kz;

        ky = (a2->Get_Center().y - a1->Get_Center().y) / (a2->Get_Center().x - a1->Get_Center().x);
        kz = (a2->Get_Center().z - a1->Get_Center().z) / (a2->Get_Center().x - a1->Get_Center().x);

        // std::cout << "abc: " << center.y/units::cm << " " << center.z/units::cm << " " << ky << " " << kz <<
        // std::endl;

        variable.push_back(ky);
        variable.push_back(kz);
    }
    else {
        // 3 parameters for vertex and 2*n for track direction, each for a track
        npar = 3 + 2 * ntracks;

        variable.push_back(center.x);
        variable.push_back(center.y);
        variable.push_back(center.z);

        for (int i = 0; i != ntracks; i++) {
            WCTrack *track = tracks.at(i);
            MergeSpaceCell *a1 = track->get_end_scells().at(0);
            MergeSpaceCell *a2 = track->get_end_scells().at(1);

            float ky, kz;

            ky = (a2->Get_Center().y - a1->Get_Center().y) / (a2->Get_Center().x - a1->Get_Center().x);
            kz = (a2->Get_Center().z - a1->Get_Center().z) / (a2->Get_Center().x - a1->Get_Center().x);

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

            variable.push_back(ky);
            variable.push_back(kz);
        }
    }

    // figure out fit_type;
    // fit 1, fit everything
    // fit 2 exclude vertex and fit

    fit_type = 2;
    int num_tracks = 0;
    for (int i = 0; i != tracks.size(); i++) {
        int num_cells = 0;
        for (int j = 0; j != tracks.at(i)->get_all_cells().size(); j++) {
            if (flag == 0) {
                if (fabs(msc->Get_Center().x - tracks.at(i)->get_all_cells().at(j)->Get_Center().x) >
                    Singleton<TPCParams>::Instance().get_ts_width() * 1.56)
                    num_cells++;
            }
            else {
                if (fabs(msc->Get_Center().x - tracks.at(i)->get_all_cells().at(j)->Get_Center().x) >
                    Singleton<TPCParams>::Instance().get_ts_width() * 3.1)
                    num_cells++;
            }
        }
        if (num_cells >= 4) num_tracks++;
    }
    if (num_tracks < 2) fit_type = 1;

    // std::cout << fit_type << " " << num_tracks << " " << ntracks << std::endl;

    // fit_type = 1;

    ROOT::Minuit2::MnUserParameters upar;
    for (int i = 0; i != npar; i++) {
        upar.Add(Form("x_%d", i), variable.at(i), 0.001);
    }
    // create MIGRAD minimizer
    ROOT::Minuit2::MnMigrad migrad(fcn, upar);

    // minimize
    ROOT::Minuit2::FunctionMinimum min = migrad();
    const ROOT::Minuit2::MnUserParameterState &state = min.UserState();

    tracks_ky.clear();
    tracks_kz.clear();
    if (ntracks == 1) {
        center.y = state.Value(0);
        center.z = state.Value(1);
        tracks_ky.push_back(state.Value(2));
        tracks_kz.push_back(state.Value(3));
    }
    else {
        center.x = state.Value(0);
        center.y = state.Value(1);
        center.z = state.Value(2);

        for (int i = 0; i != ntracks; i++) {
            tracks_ky.push_back(state.Value(3 + 2 * i));
            tracks_kz.push_back(state.Value(3 + 2 * i + 1));

            // std::cout << state.Value(3+2*i) << " " << state.Value(3+2*i+1) << std::endl;
        }
    }

    // std::cout << min.IsValid() << std::endl;

    // output
    //  std::cout << fcn.get_chi2(variable) << " Minimum: " << min.Fval() << " " << state.Value(0)/units::cm << " "
    //  <<state.Value(1)/units::cm << " " << state.Value(2)/units::cm << std::endl;
    // std::cout << "abc1: " << min.Fval() << " " << fcn.get_chi2(variable) << " " << fcn.get_chi2(variable1) << " " <<
    // state.Value(0)/units::cm << " " <<state.Value(1)/units::cm  << " " << state.Value(2) << " " << state.Value(3) <<
    // std::endl;
    // std::cout << fcn.get_chi2(variable) << std::endl;

    fit_success = min.IsValid();
    fit_chi2 = min.Fval();

    // return 0;
    return min.IsValid();
}

Point WCVertex::Center() { return center; }

void WCVertex::Add(WCTrack *track) { tracks.push_back(track); }

WCVertex *WCVertex::OrganizeTracks()
{
    WCVertex *result = 0;

    if (tracks.size() > 1) {
        // find a track where the vertex is one of the end track
        WCTrack *end_track = 0;
        WCTrackSelection end_tracks;
        for (int i = 0; i != tracks.size(); i++) {
            auto it = find(tracks.at(i)->get_end_scells().begin(), tracks.at(i)->get_end_scells().end(), msc);
            if (it != tracks.at(i)->get_end_scells().end()) {
                end_track = tracks.at(i);
                end_tracks.push_back(end_track);
            }
        }

        if (end_track == 0) return result;

        //    MergeClusterTrack& mct = end_track->get_mct();
        // find out where is the mct

        int flag;
        Point p0 = msc->Get_Center();
        Point p1 = end_track->get_all_cells().front()->Get_Center();
        Point p2 = end_track->get_all_cells().back()->Get_Center();
        float dis1 = sqrt(pow(p0.x - p1.x, 2) + pow(p0.y - p1.y, 2) + pow(p0.z - p1.z, 2));
        float dis2 = sqrt(pow(p0.x - p2.x, 2) + pow(p0.y - p2.y, 2) + pow(p0.z - p2.z, 2));

        if (dis1 < dis2) {
            flag = 1;
        }
        else {
            flag = -1;
        }

        int time_length = end_track->get_all_cells().size();
        MergeSpaceCell *nvertex = msc;

        if (flag == 1) {
            int flag_common = 0;
            for (int i = 0; i != time_length; i++) {
                MergeSpaceCell *tcell = end_track->get_all_cells().at(i);
                if (this->CheckContain(tcell)) {
                    flag_common = 1;
                    if (tcell->Get_Center().x != nvertex->Get_Center().x) {
                        nvertex = tcell;
                    }
                    else {
                        if (tcell->Get_all_spacecell().size() > nvertex->Get_all_spacecell().size()) {
                            nvertex = tcell;
                        }
                    }
                }
                if (flag_common == 0) break;
            }
        }
        else {
            int flag_common = 0;
            for (int i = 0; i != time_length; i++) {
                MergeSpaceCell *tcell = end_track->get_all_cells().at(time_length - 1 - i);
                if (this->CheckContain(tcell)) {
                    flag_common = 1;
                    if (tcell->Get_Center().x != nvertex->Get_Center().x) {
                        nvertex = tcell;
                    }
                    else {
                        if (tcell->Get_all_spacecell().size() > nvertex->Get_all_spacecell().size()) {
                            nvertex = tcell;
                        }
                    }
                }
                if (flag_common == 0) break;
            }
        }

        if (end_tracks.size() != tracks.size()) {
            for (int i = 0; i != end_tracks.size(); i++) {
                end_tracks.at(i)->ReplaceEndCell(msc, nvertex);
                end_tracks.at(i)->ModifyCells();
            }
            msc = nvertex;
            center = msc->Get_Center();
        }
        else {
            result = new WCVertex(*nvertex);
            for (int i = 1; i < end_tracks.size(); i++) {
                end_tracks.at(i)->ReplaceEndCell(msc, nvertex);
                end_tracks.at(i)->ModifyCells();
                result->Add(end_tracks.at(i));

                auto it = find(tracks.begin(), tracks.end(), end_tracks.at(i));
                tracks.erase(it);
            }
        }

        // for (int i=0;i!=tracks.size();i++){
        //   tracks.at(i)->ModifyCells();
        // }
    }

    return result;
}

WCTrackSelection WCVertex::BreakTracksAngle(WCTrackSelection &finished_tracks)
{
    WCTrackSelection result_tracks;

    for (int i = 0; i != tracks.size(); i++) {
        WCTrack *track = tracks.at(i);

        auto it = find(finished_tracks.begin(), finished_tracks.end(), track);
        if (it == finished_tracks.end()) {
            finished_tracks.push_back(track);

            MergeSpaceCellSelection all_cells = track->get_all_cells();

            // std::cout << all_cells.size() << std::endl;

            float dis1 = fabs(msc->Get_Center().x - all_cells.at(0)->Get_Center().x);
            float dis2 = fabs(msc->Get_Center().x - all_cells.at(all_cells.size() - 1)->Get_Center().x);

            // try to find all the break points
            MergeSpaceCellSelection break_cells;
            // int prev_break_point = 0;

            MergeSpaceCell *start_cell = all_cells.front();
            MergeSpaceCell *end_cell = all_cells.back();
            MergeSpaceCell *prev_break_cell = all_cells.front();

            for (int j = 0; j != all_cells.size(); j++) {
                //	std::cout << j << " " << all_cells.size() << std::endl;
                MergeSpaceCell *curr_cell;
                MergeSpaceCell *next_cell;
                MergeSpaceCell *prev_cell;

                MergeSpaceCellSelection curr_cells;
                MergeSpaceCellSelection prev_cells;
                MergeSpaceCellSelection next_cells;

                if (dis1 < dis2) {
                    curr_cell = all_cells.at(j);
                }
                else {
                    curr_cell = all_cells.at(all_cells.size() - 1 - j);
                }

                //	curr_cells.push_back(curr_cell);
                for (int k = -5; k != 5; k++) {
                    int num;
                    if (dis1 < dis2) {
                        num = j + k;
                    }
                    else {
                        num = all_cells.size() - 1 - j + k;
                    }
                    if (num >= 0 && num <= all_cells.size() - 1) {
                        if (fabs(all_cells.at(num)->Get_Center().x - curr_cell->Get_Center().x) <
                            Singleton<TPCParams>::Instance().get_ts_width() * 0.3) {
                            curr_cells.push_back(all_cells.at(num));
                        }
                    }
                }

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

                // if (fabs(curr_cell->Get_Center().x/units::cm - 54.08)<2.0 )
                //   std::cout << j << " " << curr_cell->Get_Center().x/units::cm << std::endl;

                if (fabs(curr_cell->Get_Center().x - start_cell->Get_Center().x) >=
                        5 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95 &&
                    fabs(curr_cell->Get_Center().x - end_cell->Get_Center().x) >=
                        5 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95 &&
                    fabs(curr_cell->Get_Center().x - prev_break_cell->Get_Center().x) >=
                        5 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95) {
                    // MergeSpaceCellSelection temp_msc;

                    if (dis1 < dis2) {
                        // std::cout << "abc: " << j-4 << std::endl;
                        // temp_msc.push_back(all_cells.at(j-1));
                        // temp_msc.push_back(all_cells.at(j-2));
                        // temp_msc.push_back(all_cells.at(j-3));
                        prev_cell = all_cells.at(j);
                        int k = 0;
                        while (fabs(prev_cell->Get_Center().x - curr_cell->Get_Center().x) <
                               4 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95) {
                            k++;
                            if (j - k >= 0 && j - k < all_cells.size()) {
                                prev_cell = all_cells.at(j - k);
                            }
                            else {
                                break;
                            }
                            // temp_msc.push_back(prev_cell);
                        }

                        for (int kk = -5; kk != 5; kk++) {
                            int num = j - k + kk;
                            if (num >= 0 && num <= all_cells.size() - 1) {
                                if (fabs(all_cells.at(num)->Get_Center().x - prev_cell->Get_Center().x) <
                                    Singleton<TPCParams>::Instance().get_ts_width() * 0.3) {
                                    prev_cells.push_back(all_cells.at(num));
                                }
                            }
                        }
                        //	    std::cout << "abc2" << std::endl;

                        // temp_msc.push_back(all_cells.at(j+1));
                        // temp_msc.push_back(all_cells.at(j+2));
                        // temp_msc.push_back(all_cells.at(j+3));
                        next_cell = all_cells.at(j);

                        k = 0;
                        while (fabs(next_cell->Get_Center().x - curr_cell->Get_Center().x) <
                               4 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95) {
                            k++;
                            if (j + k >= 0 && j + k < all_cells.size()) {
                                next_cell = all_cells.at(j + k);
                            }
                            else {
                                break;
                            }
                            // temp_msc.push_back(next_cell);
                        }

                        for (int kk = -5; kk != 5; kk++) {
                            int num = j + k + kk;
                            if (num >= 0 && num <= all_cells.size() - 1) {
                                if (fabs(all_cells.at(num)->Get_Center().x - next_cell->Get_Center().x) <
                                    Singleton<TPCParams>::Instance().get_ts_width() * 0.3) {
                                    next_cells.push_back(all_cells.at(num));
                                }
                            }
                        }
                        //	    std::cout << "abc3" << std::endl;
                    }
                    else {
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j+1));
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j+2));
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j+3));
                        // std::cout << "abc: " << all_cells.size()-1-j+4 << " " << all_cells.size() << std::endl;
                        prev_cell = all_cells.at(all_cells.size() - 1 - j);
                        int k = 0;
                        while (fabs(prev_cell->Get_Center().x - curr_cell->Get_Center().x) <
                               4 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95) {
                            k++;
                            if (all_cells.size() - 1 - j + k >= 0 && all_cells.size() - 1 - j + k < all_cells.size()) {
                                prev_cell = all_cells.at(all_cells.size() - 1 - j + k);
                            }
                            else {
                                break;
                            }
                            // temp_msc.push_back(prev_cell);
                        }

                        for (int kk = -5; kk != 5; kk++) {
                            int num = all_cells.size() - 1 - j + k + kk;
                            if (num >= 0 && num <= all_cells.size() - 1) {
                                if (fabs(all_cells.at(num)->Get_Center().x - prev_cell->Get_Center().x) <
                                    Singleton<TPCParams>::Instance().get_ts_width() * 0.3) {
                                    prev_cells.push_back(all_cells.at(num));
                                }
                            }
                        }

                        //  std::cout << "abc5" << std::endl;
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j-1));
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j-2));
                        // temp_msc.push_back(all_cells.at(all_cells.size()-1-j-3));
                        next_cell = all_cells.at(all_cells.size() - 1 - j);
                        k = 0;
                        while (fabs(next_cell->Get_Center().x - curr_cell->Get_Center().x) <
                               4 * Singleton<TPCParams>::Instance().get_ts_width() * 0.95) {
                            k++;
                            if (all_cells.size() - 1 - j - k >= 0 && all_cells.size() - 1 - j - k < all_cells.size()) {
                                next_cell = all_cells.at(all_cells.size() - 1 - j - k);
                            }
                            else {
                                break;
                            }
                            // temp_msc.push_back(next_cell);
                        }

                        for (int kk = -5; kk != 5; kk++) {
                            int num = all_cells.size() - 1 - j - k + kk;
                            if (num >= 0 && num <= all_cells.size() - 1) {
                                if (fabs(all_cells.at(num)->Get_Center().x - next_cell->Get_Center().x) <
                                    Singleton<TPCParams>::Instance().get_ts_width() * 0.3) {
                                    next_cells.push_back(all_cells.at(num));
                                }
                            }
                        }
                        // std::cout << "abc6" << std::endl;
                    }

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

                    Point p1;
                    p1.x = 0;
                    p1.y = 0;
                    p1.z = 0;
                    int np1 = 0;

                    for (int kk = 0; kk != prev_cells.size(); kk++) {
                        p1.x += prev_cells.at(kk)->Get_Center().x * prev_cells.at(kk)->Get_all_spacecell().size();
                        p1.y += prev_cells.at(kk)->Get_Center().y * prev_cells.at(kk)->Get_all_spacecell().size();
                        p1.z += prev_cells.at(kk)->Get_Center().z * prev_cells.at(kk)->Get_all_spacecell().size();
                        np1 += prev_cells.at(kk)->Get_all_spacecell().size();
                    }
                    p1.x /= np1;
                    p1.y /= np1;
                    p1.z /= np1;

                    Point p2;
                    p2.x = 0;
                    p2.y = 0;
                    p2.z = 0;
                    int np2 = 0;

                    for (int kk = 0; kk != curr_cells.size(); kk++) {
                        p2.x += curr_cells.at(kk)->Get_Center().x * curr_cells.at(kk)->Get_all_spacecell().size();
                        p2.y += curr_cells.at(kk)->Get_Center().y * curr_cells.at(kk)->Get_all_spacecell().size();
                        p2.z += curr_cells.at(kk)->Get_Center().z * curr_cells.at(kk)->Get_all_spacecell().size();
                        np2 += curr_cells.at(kk)->Get_all_spacecell().size();
                    }
                    p2.x /= np2;
                    p2.y /= np2;
                    p2.z /= np2;

                    Point p3;
                    p3.x = 0;
                    p3.y = 0;
                    p3.z = 0;
                    int np3 = 0;

                    for (int kk = 0; kk != next_cells.size(); kk++) {
                        p3.x += next_cells.at(kk)->Get_Center().x * next_cells.at(kk)->Get_all_spacecell().size();
                        p3.y += next_cells.at(kk)->Get_Center().y * next_cells.at(kk)->Get_all_spacecell().size();
                        p3.z += next_cells.at(kk)->Get_Center().z * next_cells.at(kk)->Get_all_spacecell().size();
                        np3 += next_cells.at(kk)->Get_all_spacecell().size();
                    }
                    p3.x /= np3;
                    p3.y /= np3;
                    p3.z /= np3;

                    // Point p2 = curr_cell->Get_Center();
                    // Point p3 = next_cell->Get_Center();

                    double ky = (p3.y - p1.y) / (p3.x - p1.x);
                    double kz = (p3.z - p1.z) / (p3.x - p1.x);

                    double yp = ky * (p2.x - p1.x) + p1.y;
                    double zp = kz * (p2.x - p1.x) + p1.z;

                    double dy = sqrt(
                        (pow(curr_cell->get_dy(), 2) + pow(prev_cell->get_dy(), 2) + pow(next_cell->get_dy(), 2)) / 3.);
                    double dz = sqrt(
                        (pow(curr_cell->get_dz(), 2) + pow(prev_cell->get_dz(), 2) + pow(next_cell->get_dz(), 2)) / 3.);

                    if (dy < curr_cell->get_dy()) dy = curr_cell->get_dy();
                    if (dz < curr_cell->get_dz()) dz = curr_cell->get_dz();
                    if (dy == 0) dy = Singleton<TPCParams>::Instance().get_pitch();
                    if (dz == 0) dz = Singleton<TPCParams>::Instance().get_pitch();
                    dy = sqrt(dy * dy + pow(Singleton<TPCParams>::Instance().get_pitch(), 2));
                    dz = sqrt(dz * dz + pow(Singleton<TPCParams>::Instance().get_pitch(), 2));

                    if (curr_cells.size() > 1) {
                        double ymax = -1e9;
                        double ymin = 1e9;
                        double zmax = -1e9;
                        double zmin = 1e9;
                        for (int qx = 0; qx != curr_cells.size(); qx++) {
                            if (curr_cells.at(qx)->get_maxy() > ymax) ymax = curr_cells.at(qx)->get_maxy();
                            if (curr_cells.at(qx)->get_maxz() > zmax) zmax = curr_cells.at(qx)->get_maxz();
                            if (curr_cells.at(qx)->get_miny() < ymin) ymin = curr_cells.at(qx)->get_miny();
                            if (curr_cells.at(qx)->get_minz() < zmin) zmin = curr_cells.at(qx)->get_minz();
                        }

                        if (dy < fabs(ymax - ymin) / 2.) dy = fabs(ymax - ymin) / 2.;
                        if (dz < fabs(zmax - zmin) / 2.) dz = fabs(zmax - zmin) / 2.;
                    }

                    double dis_sigma2 = pow(yp - p2.y, 2) / pow(dy, 2) + pow(zp - p2.z, 2) / pow(dz, 2);

                    float theta1_old = atan((p2.y - p1.y) / (p2.x - p1.x)) / 3.1415926 * 180.;
                    float theta2_old = atan((p2.z - p1.z) / (p2.x - p1.x)) / 3.1415926 * 180.;

                    float theta1_new = atan((p3.y - p2.y) / (p3.x - p2.x)) / 3.1415926 * 180.;
                    float theta2_new = atan((p3.z - p2.z) / (p3.x - p2.x)) / 3.1415926 * 180.;

                    // if (fabs(p2.x/units::cm-150)<20 && fabs(p2.y/units::cm-70)<10){
                    // std::cout << "Xin: "  << p2.x/units::cm << " " <<p2.y/units::cm << " " << p2.z/units::cm
                    // 	      << " " <<
                    //   sqrt(pow(theta1_new-theta1_old,2)+pow(theta2_new-theta2_old,2)) <<
                    //   " " << dis_sigma2 << " " <<
                    //   curr_cell->get_dy() << " " << prev_cell->get_dy()  << " " << next_cell->get_dy()
                    // 	      << " " << curr_cell->get_dz() << " " << prev_cell->get_dz()  << " " << next_cell->get_dz()
                    // 	      << std::endl;
                    //}

                    // if (sqrt(pow(theta1_new-theta1_old,2)+pow(theta2_new-theta2_old,2))>30. && dis_sigma2 > 1.4
                    if (sqrt(pow(theta1_new - theta1_old, 2) + pow(theta2_new - theta2_old, 2)) > 18. &&
                        dis_sigma2 > 0.5 && 3 * curr_cell->get_dy() > prev_cell->get_dy() &&
                        3 * curr_cell->get_dy() > next_cell->get_dy() &&
                        3 * curr_cell->get_dz() > prev_cell->get_dz() &&
                        3 * curr_cell->get_dz() > next_cell->get_dz()) {
                        // std::cout << curr_cell->get_dy() << " " << prev_cell->get_dy()  << " " << next_cell->get_dy()
                        // 	      << " " << curr_cell->get_dz() << " " << prev_cell->get_dz()  << " " <<
                        // next_cell->get_dz()
                        // 	      << std::endl;

                        prev_break_cell = curr_cell;
                        break_cells.push_back(curr_cell);

                        std::cout << "Break Angle: "
                                  << sqrt(pow(theta1_new - theta1_old, 2) + pow(theta2_new - theta2_old, 2)) << " "
                                  << dis_sigma2 << " " << curr_cell->Get_Center().x / units::cm << " "
                                  << curr_cell->Get_Center().y / units::cm << " "
                                  << curr_cell->Get_Center().z / units::cm << " " << curr_cell->get_dy() << " "
                                  << curr_cell->get_dz() << " " << prev_cells.size() << " " << curr_cells.size() << " "
                                  << next_cells.size() << " " <<
                            // all_cells.at(0)->Get_Center().x/units::cm << " " <<
                            // all_cells.back()->Get_Center().x/units::cm << " " << prev_cell->Get_Center().x/units::cm
                            // << " " << prev_cell->Get_Center().y/units::cm << " " <<
                            // prev_cell->Get_Center().z/units::cm << " " <<  prev_cell->get_dy() << " "
                            // 	      << prev_cell->get_dz() << " "  <<
                            // next_cell->Get_Center().x/units::cm << " " << next_cell->Get_Center().y/units::cm <<
                            // " " << next_cell->Get_Center().z/units::cm << " " <<  next_cell->get_dy() << " "
                            // 	      << next_cell->get_dz() << " "  <<
                            // (yp - p2.y)/units::cm << " " << (zp-p2.z)/units::cm << " " << dy/units::cm << " " <<
                            // dz/units::cm << " " << pow(yp-p2.y,2)/pow(dy,2)+pow(zp-p2.z,2)/pow(dz,2) << " " <<
                            std::endl;
                    }

                    // for (int k=0;k!= temp_msc.size();k++){
                    //   Point p = temp_msc.at(k)->Get_Center();
                    //   double yp1 = ky * (p.x-p1.x) + p1.y;
                    //   double zp1 = kz * (p.x-p1.x) + p1.z;

                    //   double_t dis_sigma1 = sqrt(pow(yp-p.y,2)/pow(dy,2)+pow(zp-p.z,2)/pow(dz,2));
                    // }
                }
            }

            if (break_cells.size() > 0) {
                track->get_end_scells().clear();
                track->get_all_cells().clear();

                //      std::cout << all_cells.size() << std::endl;
                WCTrack *track1 = track;
                result_tracks.push_back(track1);

                // use break points to form tracks
                for (int j = 0; j != all_cells.size(); j++) {
                    MergeSpaceCell *curr_cell;
                    if (dis1 < dis2) {
                        curr_cell = all_cells.at(j);
                    }
                    else {
                        curr_cell = all_cells.at(all_cells.size() - 1 - j);
                    }

                    // push any way
                    if (j == 0 || j == all_cells.size() - 1) {
                        track1->get_end_scells().push_back(curr_cell);
                    }

                    track1->get_all_cells().push_back(curr_cell);
                    auto it = find(break_cells.begin(), break_cells.end(), curr_cell);
                    if (it != break_cells.end()) {
                        track1->get_end_scells().push_back(curr_cell);
                        track1 = new WCTrack(track->get_mct());
                        track1->get_end_scells().clear();
                        track1->get_all_cells().clear();

                        finished_tracks.push_back(track1);
                        result_tracks.push_back(track1);
                        track1->get_end_scells().push_back(curr_cell);
                        track1->get_all_cells().push_back(curr_cell);
                    }
                }

                // test
                // for (int j = 0; j!= result_tracks.size();j++){
                //   std::cout << result_tracks.at(j)->get_end_scells().at(0)->Get_Center().x/units::cm << " "
                // 	    << result_tracks.at(j)->get_end_scells().at(1)->Get_Center().x/units::cm << " "
                // 	    << std::endl;
                // }
            }
        }
    }

    return result_tracks;
}

WCTrackSelection WCVertex::BreakTracks()
{
    WCTrackSelection result_tracks;
    if (tracks.size() > 1) {
        float length = 0;

        for (int i = 0; i != tracks.size(); i++) {
            auto it = find(tracks.at(i)->get_end_scells().begin(), tracks.at(i)->get_end_scells().end(), msc);
            if (it != tracks.at(i)->get_end_scells().end()) {
                float length1 = fabs(tracks.at(i)->get_end_scells().at(0)->Get_Center().x -
                                     tracks.at(i)->get_end_scells().at(1)->Get_Center().x) /
                                units::cm;
                if (length1 > length) length = length1;
            }
        }

        for (int i = 0; i != tracks.size(); i++) {
            MergeSpaceCell *cell1 = tracks.at(i)->get_end_scells().at(0);
            MergeSpaceCell *cell2 = tracks.at(i)->get_end_scells().at(1);
            float dis1 = cell1->Get_Center().x - msc->Get_Center().x;
            float dis2 = cell2->Get_Center().x - msc->Get_Center().x;
            auto it = find(tracks.at(i)->get_end_scells().begin(), tracks.at(i)->get_end_scells().end(), msc);

            // std::cout << dis1 << " " << dis2 << " " << length << std::endl;

            if (it == tracks.at(i)->get_end_scells().end()) {
                if (fabs(dis1) > 2.1 * Singleton<TPCParams>::Instance().get_ts_width() &&
                    fabs(dis2) > 2.1 * Singleton<TPCParams>::Instance().get_ts_width() &&
                    length > Singleton<TPCParams>::Instance().get_ts_width() * 6.7 / units::cm) {
                    WCTrack *primary_track = tracks.at(i);
                    WCTrack *secondary_track = new WCTrack(primary_track->get_mct());
                    if (cell1 == primary_track->replace_end_scells(msc)) {
                        secondary_track->get_end_scells().clear();
                        secondary_track->get_end_scells().push_back(msc);
                        secondary_track->get_end_scells().push_back(cell1);
                    }
                    else {
                        secondary_track->get_end_scells().clear();
                        secondary_track->get_end_scells().push_back(msc);
                        secondary_track->get_end_scells().push_back(cell2);
                    }

                    tracks.push_back(secondary_track);

                    primary_track->ModifyCells();
                    secondary_track->ModifyCells();

                    result_tracks.push_back(primary_track);
                    result_tracks.push_back(secondary_track);

                    std::cout << "Break!"
                              << " " << msc->Get_Center().x / units::cm << " " << msc->Get_Center().y / units::cm << " "
                              << msc->Get_Center().z / units::cm << " "
                              << fabs(cell1->Get_Center().x - msc->Get_Center().x) / units::cm << " "
                              << fabs(cell2->Get_Center().x - msc->Get_Center().x) / units::cm << std::endl;
                    break;
                }
            }
        }
    }

    return result_tracks;
}

void WCVertex::ProcessTracks(WCTrackSelection &break_tracks)
{
    WCTrack *primary_track = break_tracks.at(0);
    WCTrack *secondary_track = break_tracks.at(1);

    // primary_track->ModifyCells();
    // secondary_track->ModifyCells();

    auto it = find(tracks.begin(), tracks.end(), primary_track);
    if (it != tracks.end()) {
        float dis1 = msc->Get_Center().x - primary_track->get_end_scells().at(0)->Get_Center().x;
        float dis2 = msc->Get_Center().x - primary_track->get_end_scells().at(1)->Get_Center().x;

        if (dis1 * dis2 > 0) {
            tracks.erase(it);
            tracks.push_back(secondary_track);
        }
    }
}

void WCVertex::OrganizeEnds(MergeSpaceCellSelection &cells1, int flag)
{
    WCTrackSelection removed;
    for (int i = 0; i != tracks.size(); i++) {
        auto it = find(tracks.at(i)->get_end_scells().begin(), tracks.at(i)->get_end_scells().end(), msc);
        if (it == tracks.at(i)->get_end_scells().end()) {
            MergeSpaceCell *cell1 = tracks.at(i)->get_end_scells().at(0);
            MergeSpaceCell *cell2 = tracks.at(i)->get_end_scells().at(1);
            if (fabs(cell1->Get_Center().x - msc->Get_Center().x) >
                    Singleton<TPCParams>::Instance().get_ts_width() * 2.1 &&
                fabs(cell2->Get_Center().x - msc->Get_Center().x) >
                    Singleton<TPCParams>::Instance().get_ts_width() * 2.1 &&
                flag == 1) {
                removed.push_back(tracks.at(i));
            }
            else {
                if (flag == 1) {
                    auto it1 = find(tracks.at(i)->get_all_cells().begin(), tracks.at(i)->get_all_cells().end(), msc);
                    float dis1 = tracks.at(i)->get_end_scells().at(0)->Get_Center().x - msc->Get_Center().x;
                    float dis2 = tracks.at(i)->get_end_scells().at(1)->Get_Center().x - msc->Get_Center().x;
                    if (it1 == tracks.at(i)->get_all_cells().end() && dis1 * dis2 < 0) {
                        removed.push_back(tracks.at(i));
                    }
                }
            }
        }
    }

    for (int i = 0; i != removed.size(); i++) {
        auto it = find(tracks.begin(), tracks.end(), removed.at(i));
        tracks.erase(it);
    }

    for (int i = 0; i != tracks.size(); i++) {
        auto it = find(tracks.at(i)->get_end_scells().begin(), tracks.at(i)->get_end_scells().end(), msc);
        if (it == tracks.at(i)->get_end_scells().end()) {
            tracks.at(i)->replace_end_scells(msc, &cells1);
            tracks.at(i)->ModifyCells();
        }
    }
}

bool WCVertex::CheckContain(MergeSpaceCell *cell)
{
    bool result = true;
    for (int i = 0; i != tracks.size(); i++) {
        WCTrack *track = tracks.at(i);
        // MergeClusterTrack& mct = track->get_mct();
        MergeSpaceCellSelection &cells = track->get_all_cells();
        auto it = find(cells.begin(), cells.end(), cell);
        if (it == cells.end()) {
            result = false;
            break;
        }
    }
    return result;
}

int WCVertex::IsInside(WCVertex *vertex)
{
    int result = -1;

    // if (tracks.size()==1 && vertex->get_ntracks()==1){
    //   return -1;
    // }else if (tracks.size()>1 && vertex->get_ntracks()==1){
    //   return -1;
    // }else if (tracks.size()==1 && vertex->get_ntracks()>1){
    //   return -1;
    // }else if (tracks.size()>1 && vertex->get_ntracks()>1){
    result = 1;
    WCTrackSelection &temp_tracks = vertex->get_tracks();
    for (int i = 0; i != tracks.size(); i++) {
        WCTrack *track = tracks.at(i);
        auto it = find(temp_tracks.begin(), temp_tracks.end(), track);
        if (it == temp_tracks.end()) {
            result = -1;
            break;
        }
    }

    if (result == 1) {
        for (int i = 0; i != tracks.size(); i++) {
            WCTrack *track = tracks.at(i);
            auto it = find(track->get_all_cells().begin(), track->get_all_cells().end(), vertex->get_msc());
            if (it == track->get_all_cells().end()) {
                result = -1;
                break;
            }
        }
    }

    if (result == 1 && tracks.size() == temp_tracks.size()) {
        result = 0;
    }
    // }

    return result;
}

bool WCVertex::MergeVertex(WCVertex *vertex)
{
    if (msc != vertex->get_msc()) {
        return false;
    }
    else {
        for (int i = 0; i != vertex->get_tracks().size(); i++) {
            WCTrack *track = vertex->get_tracks().at(i);
            auto it = find(tracks.begin(), tracks.end(), track);
            if (it == tracks.end()) {
                tracks.push_back(track);
                tracks_ky.push_back(vertex->get_ky(track));
                tracks_kz.push_back(vertex->get_kz(track));
            }
        }
        return true;
    }
}

bool WCVertex::AddVertex(WCVertex *vertex, int flag)
{
    bool result = false;

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

    MergeSpaceCell *msc1 = msc;
    MergeSpaceCell *msc2 = vertex->get_msc();

    float dis = (Singleton<TPCParams>::Instance().get_ts_width() * 2.3) / units::mm;

    if (fabs(msc1->Get_Center().x / units::mm - msc2->Get_Center().x / units::mm) < dis) {
        // std::cout <<  fabs(msc1->Get_Center().x/units::mm-msc2->Get_Center().x/units::mm) << " " <<
        // msc1->Overlap(*msc2) << std::endl;
        if (msc1->Overlap(*msc2)) {
            for (int i = 0; i != tracks.size(); i++) {
                WCTrack *track1 = tracks.at(i);
                auto it = find(vertex->get_tracks().begin(), vertex->get_tracks().end(), track1);
                if (it != vertex->get_tracks().end()) {
                    result = true;

                    // these two vertex share track1 ...
                    if (flag == 1) {
                        for (int j = 0; j != vertex->get_tracks().size(); j++) {
                            WCTrack *track = vertex->get_tracks().at(j);
                            auto it = find(track->get_all_cells().begin(), track->get_all_cells().end(), msc);
                            if (it == track->get_all_cells().end()) {
                                result = false;  // track->Grow(msc);
                                if (!result) break;
                            }
                        }
                    }
                    else if (flag == 0) {
                        // center must be at the end of common track
                        auto it1 = find(track1->get_end_scells().begin(), track1->get_end_scells().end(), msc);
                        if (it1 == track1->get_end_scells().end()) result = false;
                    }
                    else if (flag == 2) {
                        // No cut
                    }

                    if (result) {
                        // std::cout << tracks.size() << " " << tracks.at(0) << std::endl;
                        for (int j = 0; j != vertex->get_tracks().size(); j++) {
                            WCTrack *track2 = vertex->get_tracks().at(j);
                            // std::cout << track2 << std::endl;
                            auto it1 = find(tracks.begin(), tracks.end(), track2);
                            if (it1 == tracks.end()) {
                                tracks.push_back(track2);
                            }
                        }
                        // std::cout << tracks.size() << std::endl;
                        break;
                    }
                }
            }
        }
    }

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

    return result;
}
