void WCPPID::NeutrinoID::examine_structure(WCPPID::PR3DCluster *temp_cluster){
  // change 2 to 1
  
  

  
  if (examine_structure_2(temp_cluster) )
     temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
  // straighten 1
  if ( examine_structure_1(temp_cluster) )
     temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
}

bool WCPPID::NeutrinoID::examine_structure_1(WCPPID::PR3DCluster *temp_cluster){
  // look at the each segment, if the more straight one is better
  // change ...
  bool flag_update = false;
  for (auto it = map_segment_vertices.begin(); it!=map_segment_vertices.end(); it++){
     WCPPID::ProtoSegment *sg = it->first;
     if (sg->get_cluster_id()!=temp_cluster->get_cluster_id()) continue;
     //     std::cout << sg->get_length()/units::cm << std::endl;
     double length = sg->get_length();
     double medium_dQ_dx = sg->get_medium_dQ_dx() / (43e3/units::cm);
     //     std::cout << length/units::cm << " " << medium_dQ_dx << std::endl;
     if (length < 5*units::cm || length < 8*units::cm && medium_dQ_dx > 1.5){
       std::pair<WCPPID::ProtoVertex*, WCPPID::ProtoVertex*> pair_vertices = find_vertices(sg);
       PointVector& pts = sg->get_point_vec();
       std::vector<WCP::WCPointCloud<double>::WCPoint >& wcps = sg->get_wcpt_vec();
       // check the track
       double step_size = 0.6*units::cm;
       Point start_p = pts.front();
       Point end_p = pts.back();
       int ncount = std::round(sqrt(pow(start_p.x-end_p.x,2)+pow(start_p.y-end_p.y,2)+pow(start_p.z-end_p.z,2))/step_size);
       PointVector new_pts;
       bool flag_replace = true;
       int n_bad = 0;
       for (int i=1;i<ncount;i++){
	 Point test_p;
	 test_p.x = start_p.x + (end_p.x - start_p.x)/ncount*i;
	 test_p.y = start_p.y + (end_p.y - start_p.y)/ncount*i;
	 test_p.z = start_p.z + (end_p.z - start_p.z)/ncount*i;
	 new_pts.push_back(test_p);
	 if (!ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0)) n_bad ++;
	 if (n_bad>1) flag_replace = false;
	   //	 std::cout << i << " " << test_p << " " << ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0) << " " << sg->get_closest_point(test_p).first/units::cm << std::endl;
       }

       if (flag_replace){
	 WCP::ToyPointCloud* pcloud_steiner = temp_cluster->get_point_cloud_steiner();
	 WCP::WCPointCloud<double>::WCPoint start_wcp = wcps.front();
	 WCP::WCPointCloud<double>::WCPoint end_wcp = wcps.back();
	 wcps.clear();
	 //	 std::cout << start_wcp.index << std::endl;
	 wcps.push_back(start_wcp);
	 for (size_t i=0; i!=new_pts.size(); i++){
	   WCP::WCPointCloud<double>::WCPoint& wcp =  pcloud_steiner->get_closest_wcpoint(new_pts.at(i));
	   if (wcp.index != wcps.back().index ) {
	     //std::cout << new_pts.at(i) << " " << wcp.index << std::endl;
	     wcps.push_back(wcp);
	   }
	   if (wcps.back().index == end_wcp.index) break;
	 }
	 if (end_wcp.index != wcps.back().index) {
	   //std::cout << end_wcp.index << std::endl;
	   wcps.push_back(end_wcp);
	 }
	 flag_update = true;
	 std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " id " << sg->get_id() << " replace Track Content with Straight Line" << std::endl;
       } // replace
     } // if length cut and dQ/dx cut
  } // loop over all the segments ...
  return flag_update;
}


bool WCPPID::NeutrinoID::examine_structure_2(WCPPID::PR3DCluster *temp_cluster){
  bool flag_update = false;

  bool flag_continue = true;
  while(flag_continue){
    flag_continue = false;

    for (auto it = map_vertex_segments.begin(); it!=map_vertex_segments.end(); it++){
      WCPPID::ProtoVertex *vtx = it->first;
      //      std::cout <<"A: " << vtx->get_id() << " " << it->second.size() << std::endl;
      if (vtx->get_cluster_id()!=temp_cluster->get_cluster_id()) continue;
      if (it->second.size()!=2) continue;
      WCPPID::ProtoSegment *sg1 = *(it->second.begin());
      WCPPID::ProtoSegment *sg2 = *(it->second.rbegin());
      double length1 = sg1->get_length();
      double length2 = sg2->get_length();


      
      //if (length1 > 5*units::cm || length2 > 5*units::cm) continue;

      //      std::cout << "asd " << std::endl;
      WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg1, vtx);
      WCPPID::ProtoVertex *vtx2 = find_other_vertex(sg2, vtx);


      
      double step_size = 0.6*units::cm;
      Point start_p = vtx1->get_fit_pt();
      Point end_p = vtx2->get_fit_pt();
      int ncount = std::round(sqrt(pow(start_p.x-end_p.x,2)+pow(start_p.y-end_p.y,2)+pow(start_p.z-end_p.z,2))/step_size);
      
      PointVector new_pts;
      bool flag_replace = true;
      int n_bad = 0;
      for (int i=1;i<ncount;i++){
	Point test_p;
	test_p.x = start_p.x + (end_p.x - start_p.x)/ncount*i;
	test_p.y = start_p.y + (end_p.y - start_p.y)/ncount*i;
	test_p.z = start_p.z + (end_p.z - start_p.z)/ncount*i;
	new_pts.push_back(test_p);
	if (!ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0)) n_bad ++;
	if (n_bad>1) flag_replace = false;
	//	std::cout << i << " " << test_p << " " << ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0) << std::endl;
      }

      // std::cout << flag_replace << " " << sg1->get_id() << " " << sg2->get_id() << " " << length1/units::cm << " " << length2/units::cm << " " << n_bad << " " << ncount * step_size << std::endl;
      
      if (flag_replace){
	// form a new segment
	std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Merge two short segments: " << sg1->get_id() << " " << sg2->get_id() << " with a straight one, vtx id "  << vtx->get_id() << std::endl;
	
	WCP::ToyPointCloud* pcloud_steiner = temp_cluster->get_point_cloud_steiner();
	std::list<WCP::WCPointCloud<double>::WCPoint > wcps;
	WCP::WCPointCloud<double>::WCPoint start_wcp = vtx1->get_wcpt();
	WCP::WCPointCloud<double>::WCPoint end_wcp = vtx2->get_wcpt();
	wcps.push_back(start_wcp);
	for (size_t i=0; i!=new_pts.size(); i++){
	  WCP::WCPointCloud<double>::WCPoint& wcp =  pcloud_steiner->get_closest_wcpoint(new_pts.at(i));
	  if (wcp.index != wcps.back().index) wcps.push_back(wcp);
	}
	if (end_wcp.index != wcps.back().index) wcps.push_back(end_wcp);

	if (vtx1->get_wcpt().index != vtx2->get_wcpt().index){
	  WCPPID::ProtoSegment *sg3 = new WCPPID::ProtoSegment(acc_segment_id, wcps, temp_cluster->get_cluster_id()); acc_segment_id++;
	  add_proto_connection(vtx1,sg3,temp_cluster);
	  add_proto_connection(vtx2,sg3,temp_cluster);
	}else{
	  for (auto it5 = map_vertex_segments[vtx2].begin(); it5 != map_vertex_segments[vtx2].end(); it5++){
	    add_proto_connection(vtx1, *it5, temp_cluster);
	  }
	  del_proto_vertex(vtx2);
	}

	del_proto_segment(sg1);
	del_proto_segment(sg2);
	del_proto_vertex(vtx);

	
	flag_update = true;
	flag_continue = true;
	break;
      }
    }
  } // continue

  
  
  return flag_update;
}


bool WCPPID::NeutrinoID::examine_structure_3(WCPPID::PR3DCluster *temp_cluster){
  bool flag_update = false;
  bool flag_continue = true;
  while(flag_continue){
    flag_continue = false;
    
    for (auto it = map_vertex_segments.begin(); it!=map_vertex_segments.end(); it++){
      WCPPID::ProtoVertex *vtx = it->first;
      //      std::cout <<"A: " << vtx->get_id() << " " << it->second.size() << std::endl;
      if (vtx->get_cluster_id()!=temp_cluster->get_cluster_id()) continue;
      if (it->second.size()!=2) continue;
      WCPPID::ProtoSegment *sg1 = *(it->second.begin());
      WCPPID::ProtoSegment *sg2 = *(it->second.rbegin());
      WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg1, vtx);
      WCPPID::ProtoVertex *vtx2 = find_other_vertex(sg2, vtx);

      TVector3 dir1 = sg1->cal_dir_3vector(vtx->get_fit_pt(),10*units::cm);
      TVector3 dir2 = sg2->cal_dir_3vector(vtx->get_fit_pt(),10*units::cm);

      TVector3 dir3 = sg1->cal_dir_3vector(vtx->get_fit_pt(),3*units::cm);
      TVector3 dir4 = sg2->cal_dir_3vector(vtx->get_fit_pt(),3*units::cm);

      
      if ((3.1415926 - dir1.Angle(dir2))/3.1415926*180. < 18 && (3.1415926 - dir3.Angle(dir4))/3.1415926*180. <27 ){
	std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Merge two segments: " << sg1->get_id() << " " << sg2->get_id() << " into one according to angle "  << std::endl;
	
	WCP::ToyPointCloud* pcloud_steiner = temp_cluster->get_point_cloud_steiner();

	std::list<WCP::WCPointCloud<double>::WCPoint > wcps(sg1->get_wcpt_vec().begin(), sg1->get_wcpt_vec().end());
	std::vector<WCP::WCPointCloud<double>::WCPoint > wcps_2 = sg2->get_wcpt_vec();

	if (wcps.front().index == wcps_2.front().index){
	  wcps.pop_front();
	  for (auto it1 = wcps_2.begin(); it1 != wcps_2.end(); it1++){
	    wcps.push_front(*it1);
	  }
	}else if (wcps.front().index == wcps_2.back().index){
	  wcps.pop_front();
	  for (auto it1 = wcps_2.rbegin(); it1 != wcps_2.rend(); it1++){
	    wcps.push_front(*it1);
	  }
	}else if (wcps.back().index == wcps_2.front().index){
	  wcps.pop_back();
	  for (auto it1 = wcps_2.begin(); it1 != wcps_2.end(); it1++){
	    wcps.push_back(*it1);
	  }
	}else if (wcps.back().index == wcps_2.back().index){
	  wcps.pop_back();
	  for (auto it1 = wcps_2.rbegin(); it1 != wcps_2.rend(); it1++){
	    wcps.push_back(*it1);
	  }
	}
	
	
	WCPPID::ProtoSegment *sg3 = new WCPPID::ProtoSegment(acc_segment_id, wcps, temp_cluster->get_cluster_id()); acc_segment_id++; 

	//delete the old segments and old vertices
	add_proto_connection(vtx1,sg3,temp_cluster);
	add_proto_connection(vtx2,sg3,temp_cluster);

	del_proto_segment(sg1);
	del_proto_segment(sg2);
	del_proto_vertex(vtx);

	
	flag_update = true;
	flag_continue = true;
	break;
      }
    }
  }


  
  
  
  return flag_update;
}


bool WCPPID::NeutrinoID::examine_structure_4(WCPPID::ProtoVertex* vertex, WCPPID::PR3DCluster *temp_cluster, bool flag_final_vertex){
  bool flag_update = false;
  for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++){
    WCPPID::ProtoVertex *vtx = it->first;
    if (it->second.size()<2 && (!flag_final_vertex) ) continue;
    if (vtx != vertex) continue;

    ToyPointCloud* pcloud = temp_cluster->get_point_cloud_steiner();
    std::vector<bool>& flag_terminals = temp_cluster->get_flag_steiner_terminal();
    
    std::vector<TVector3> saved_dirs;
    int nshowers = 0;
    for (auto it1 =it->second.begin(); it1!=it->second.end(); it1++){
      TVector3 dir = get_dir(vtx, *it1);
      if (dir.Mag()!=0) saved_dirs.push_back(dir);
    }

    std::vector<WCP::WCPointCloud<double>::WCPoint > candidate_wcps = pcloud->get_closest_wcpoints(vtx->get_fit_pt(), 6*units::cm);

    double max_dis = 0;
    WCP::WCPointCloud<double>::WCPoint max_wcp;

    for (size_t i=0; i!=candidate_wcps.size(); i++){
      if (flag_terminals.at(candidate_wcps.at(i).index)){
	double dis = sqrt(pow(candidate_wcps.at(i).x - vtx->get_fit_pt().x ,2) + pow(candidate_wcps.at(i).y - vtx->get_fit_pt().y,2) + pow(candidate_wcps.at(i).z - vtx->get_fit_pt().z,2));
	double min_dis = 1e9;
	double min_dis_u = 1e9;
	double min_dis_v = 1e9;
	double min_dis_w = 1e9;
	Point test_p(candidate_wcps.at(i).x, candidate_wcps.at(i).y, candidate_wcps.at(i).z);
      

	for (auto it1 = map_segment_vertices.begin(); it1!=map_segment_vertices.end(); it1++){
	  WCPPID::ProtoSegment *sg = it1->first;
	  //if (sg->get_cluster_id() != temp_cluster->get_cluster_id()) continue;
	  WCP::WCPointCloud<double>::WCPoint closest_wcp = sg->get_closest_wcpt(test_p);
	  std::pair<double, WCP::Point> results = sg->get_closest_point(test_p);
	  if (results.first < min_dis) min_dis = results.first;
	  double tmp_dis = sqrt(pow(closest_wcp.x - test_p.x,2)+pow(closest_wcp.y-test_p.y,2)+pow(closest_wcp.z - test_p.z,2));
	  if (tmp_dis < min_dis) min_dis = tmp_dis;
	
	  std::tuple<double, double, double> results_2d = sg->get_closest_2d_dis(test_p);
	  if (std::get<0>(results_2d) < min_dis_u) min_dis_u = std::get<0>(results_2d);
	  if (std::get<1>(results_2d) < min_dis_v) min_dis_v = std::get<1>(results_2d);
	  if (std::get<2>(results_2d) < min_dis_w) min_dis_w = std::get<2>(results_2d);
	}


	
	if (min_dis > 0.9*units::cm   && min_dis_u + min_dis_v + min_dis_w > 1.8*units::cm &&
	    (min_dis_u > 0.8*units::cm && min_dis_v > 0.8*units::cm
	     || min_dis_u > 0.8*units::cm && min_dis_w > 0.8*units::cm
	     || min_dis_v > 0.8*units::cm && min_dis_w > 0.8*units::cm
	     )){
	  double step_size = 0.3*units::cm;
	  Point start_p = vtx->get_fit_pt();
	  Point end_p = test_p;
	  int ncount = std::round(sqrt(pow(start_p.x-end_p.x,2)+pow(start_p.y-end_p.y,2)+pow(start_p.z-end_p.z,2))/step_size);
	  bool flag_pass = true;
	  int n_bad = 0;
	  for (int j=1;j<ncount;j++){
	    Point test_p1;
	    test_p1.x = start_p.x + (end_p.x - start_p.x)/ncount*j;
	    test_p1.y = start_p.y + (end_p.y - start_p.y)/ncount*j;
	    test_p1.z = start_p.z + (end_p.z - start_p.z)/ncount*j;
	    if (!ct_point_cloud->is_good_point(test_p1, 0.3*units::cm, 0, 0)) n_bad ++;
	    if (n_bad>0) {
	      flag_pass = false;
	    }
	  }

	  //	  std::cout << " " << candidate_wcps.at(i).index_u << " " << candidate_wcps.at(i).index_v << " " << candidate_wcps.at(i).index_w << " " << dis/units::cm << " " << min_dis/units::cm << " " << min_dis_u/units::cm << " " <<  min_dis_v/units::cm << " " <<  min_dis_w/units::cm << " " << flag_pass << " " << n_bad << " " << ncount << std::endl;
	  //	  std::cout << dis/units::cm << " " << min_dis/units::cm << " " << min_dis_u/units::cm << " " <<  min_dis_v/units::cm << " " <<  min_dis_w/units::cm << std::endl;
	  
	  if (flag_pass){
	    
	    if (max_dis < dis){
	      max_dis = dis;
	      max_wcp = candidate_wcps.at(i);
	    }
	  }
	}
      } // must be steiner terminal
    } // loop over points ...

    //    std::cout << max_dis/units::cm << std::endl;
    
    if (max_dis > 1.6*units::cm){
      WCPPID::ProtoVertex *v1 = new WCPPID::ProtoVertex(acc_vertex_id, max_wcp, temp_cluster->get_cluster_id()); acc_vertex_id++;
      std::list<WCP::WCPointCloud<double>::WCPoint> wcp_list;
      wcp_list.push_back(vtx->get_wcpt());
      
      double step_size = 1*units::cm;
      Point start_p = vtx->get_fit_pt();
      Point end_p(max_wcp.x, max_wcp.y, max_wcp.z);
      int ncount = std::round(sqrt(pow(start_p.x-end_p.x,2)+pow(start_p.y-end_p.y,2)+pow(start_p.z-end_p.z,2))/step_size);
      
      for (size_t j=1; j<ncount;j++){
	Point tmp_p;
	tmp_p.x = start_p.x + (end_p.x - start_p.x)/ncount*j;
	tmp_p.y = start_p.y + (end_p.y - start_p.y)/ncount*j;
	tmp_p.z = start_p.z + (end_p.z - start_p.z)/ncount*j;
	WCP::WCPointCloud<double>::WCPoint& wcp =  pcloud->get_closest_wcpoint(tmp_p);
	if (wcp.index != wcp_list.back().index) wcp_list.push_back(wcp);
      }
      if (max_wcp.index != wcp_list.back().index)
	wcp_list.push_back(max_wcp);
      
      std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Add a track to the main vertex" << " " << acc_segment_id << " " << wcp_list.size() << " " << v1->get_wcpt().index << " " << vtx->get_wcpt().index << std::endl;
      WCPPID::ProtoSegment* sg1 = new WCPPID::ProtoSegment(acc_segment_id, wcp_list, temp_cluster->get_cluster_id()); acc_segment_id++;
      add_proto_connection(v1,sg1,temp_cluster);
      add_proto_connection(vtx,sg1,temp_cluster);
      flag_update = true;
    }
  } // loop over vertices ...
  return flag_update;
}
