
bool WCPPID::NeutrinoID::examine_structure_final(WCPPID::PR3DCluster* temp_cluster){
  
  // results need to repeat the fit and the PID related work ...
  examine_structure_final_1(temp_cluster);
  examine_structure_final_1p(temp_cluster);
  
  examine_structure_final_2(temp_cluster);

  
  examine_structure_final_3(temp_cluster);
}

bool WCPPID::NeutrinoID::examine_structure_final_3(WCPPID::PR3DCluster* temp_cluster){
  bool flag_update;

  WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
  bool flag_updated = false;

  if (main_vertex !=0 && main_vertex->get_cluster_id() == temp_cluster->get_cluster_id()){
    bool flag_continue = true;
    while(flag_continue){
      flag_continue = false;
      flag_update = false;
      
      for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); 
it++){
        WCPPID::ProtoSegment *sg = *it;
        WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg, main_vertex);
	
        if (map_vertex_segments[vtx1].size()==1) continue;
        double dis = sqrt(pow(main_vertex->get_fit_pt().x - vtx1->get_fit_pt().x,2) + pow(main_vertex->get_fit_pt().y - vtx1->get_fit_pt().y, 2) + pow(main_vertex->get_fit_pt().z - vtx1->get_fit_pt().z,2));

	
	
        if (dis <2.5*units::cm){
          // check to see if the vtx1 can be merged into main_vertex ...
	  flag_update = true;
	  for (auto it1 = map_vertex_segments[main_vertex].begin(); it1 != map_vertex_segments[main_vertex].end(); it1++){
	    WCPPID::ProtoSegment *sg1 =  *it1;
	    if (sg == sg1) continue;
	    PointVector& pts = sg1->get_point_vec();
            bool flag_start;
	    if (sg->get_wcpt_vec().front().index == main_vertex->get_wcpt().index){
              flag_start = true;
            }else if (sg->get_wcpt_vec().back().index == main_vertex->get_wcpt().index){
              flag_start = false;
            }
	    
	    Point min_point = pts.front();
            double min_dis = 1e9;
            int min_index;
            for (size_t i=0;i!=pts.size();i++){
              double dis = fabs(sqrt(pow(pts.at(i).x - main_vertex->get_fit_pt().x,2) + pow(pts.at(i).y - main_vertex->get_fit_pt().y,2) + pow(pts.at(i).z - main_vertex->get_fit_pt().z,2))-3*units::cm);
              if (dis < min_dis){
                min_dis = dis;
                min_point = pts.at(i);
                min_index = i;
              }
            }

	    bool flag_connect = true;
            if (flag_start){
              for (int i = min_index; i>=0;i--){
                if (!ct_point_cloud->is_good_point(pts.at(i), 0.2*units::cm, 0, 0)) {
                  flag_connect = false;
                  break;
                }
              }
            }else{
              for (int i = min_index; i<pts.size(); i++){
                if (!ct_point_cloud->is_good_point(pts.at(i), 0.2*units::cm, 0, 0)) {
                  flag_connect = false;
                  break;
                }
              }     
            }
	    if (flag_connect){
              double step_size = 0.3*units::cm;
              Point start_p = min_point;
              Point end_p = vtx1->get_fit_pt();
              int ncount = std::round(sqrt(pow(start_p.x - end_p.x,2) + pow(start_p.y - end_p.y,2) + pow(start_p.z - end_p.z,2))/step_size);
              int n_bad = 0;
              for (int i=1;i<ncount;i++){
                Point test_p(start_p.x + (end_p.x - start_p.x)/ncount*i,
                             start_p.y + (end_p.y - start_p.y)/ncount*i,
                             start_p.z + (end_p.z - start_p.z)/ncount*i);
                if (!ct_point_cloud->is_good_point(test_p, 0.3*units::cm, 0, 0)) {
                  n_bad ++;
                }
		//	std::cout << i << " " << test_p << " " << ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0) << " " << ct_point_cloud->is_good_point(test_p, 0.3*units::cm, 0, 0) << std::endl;
              }
              if (n_bad >0) flag_update = false;
	      //  std::cout << sg1->get_id() << " " << n_bad << " " << ncount << std::endl;
            }
	  } // loop over segment around main_vertex

	  //	  std::cout << temp_cluster->get_cluster_id() << " " << flag_update << " " << map_vertex_segments[main_vertex].size() << " " << map_vertex_segments[vtx1].size() << " " << dis/units::cm << " " << vtx1->get_id() << " " << main_vertex->get_id() << std::endl;
	  
	  if (flag_update){
	    std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Final stage merge main_vertex " << main_vertex->get_id() << " " << main_vertex->get_fit_pt() << " " << vtx1->get_id() <<  " " << vtx1->get_fit_pt() << std::endl;
	    
	    for (auto it1 = map_vertex_segments[main_vertex].begin(); it1 != map_vertex_segments[main_vertex].end(); it1++) { 
              WCPPID::ProtoSegment *sg1 = *it1;
              if (sg1 == sg) continue;
              WCP::WCPointCloud<double>::WCPoint& vtx_new_wcp = vtx1->get_wcpt();
              std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps = sg1->get_wcpt_vec();
              bool flag_front = false;
              if (vec_wcps.front().index == main_vertex->get_wcpt().index) flag_front = true;
              
              WCP::WCPointCloud<double>::WCPoint min_wcp;
              double min_dis = 1e9;
              double max_dis = std::max(sqrt(pow(vec_wcps.front().x -main_vertex->get_fit_pt().x,2)+pow(vec_wcps.front().y - main_vertex->get_fit_pt().y,2)+pow(vec_wcps.front().z - main_vertex->get_fit_pt().z,2)), sqrt(pow(vec_wcps.back().x - main_vertex->get_fit_pt().x,2)+pow(vec_wcps.back().y - main_vertex->get_fit_pt().y,2)+pow(vec_wcps.back().z - main_vertex->get_fit_pt().z,2)));
	      for (size_t j=0;j!=vec_wcps.size();j++){
                double dis1 = sqrt(pow(vec_wcps.at(j).x -main_vertex->get_fit_pt().x,2)+pow(vec_wcps.at(j).y -main_vertex->get_fit_pt().y,2)+pow(vec_wcps.at(j).z - main_vertex->get_fit_pt().z,2));
                double dis = fabs(dis1 - 3.0*units::cm);
                if (dis < min_dis){
                  min_wcp = vec_wcps.at(j);
                  min_dis = dis;
                }
              }
              // establish the shortest path ...
	      std::list<WCP::WCPointCloud<double>::WCPoint> new_list;
              new_list.push_back(vtx_new_wcp);
              {
                double dis_step = 1.0*units::cm;
                int ncount = std::round(sqrt(pow(vtx_new_wcp.x - min_wcp.x,2) + pow(vtx_new_wcp.y - min_wcp.y,2) + pow(vtx_new_wcp.z - min_wcp.z,2))/dis_step);
                if (ncount <2) ncount = 2;
                for (int qx=1;qx<ncount;qx++){
                  Point tmp_p(vtx_new_wcp.x + (min_wcp.x-vtx_new_wcp.x)/ncount*qx, vtx_new_wcp.y + (min_wcp.y-vtx_new_wcp.y)/ncount*qx, vtx_new_wcp.z + (min_wcp.z-vtx_new_wcp.z)/ncount*qx);
                  WCP::WCPointCloud<double>::WCPoint& tmp_wcp = pcloud->get_closest_wcpoint(tmp_p);
                  //std::cout << qx << " " << sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) + pow(tmp_wcp.z - tmp_p.z,2))/units::cm << std::endl;
                  if (sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) + pow(tmp_wcp.z - tmp_p.z,2)) > 0.3*units::cm) continue; // too large ...
                  if (tmp_wcp.index != new_list.back().index && tmp_wcp.index != min_wcp.index)
                    new_list.push_back(tmp_wcp);
                }
	      }
              new_list.push_back(min_wcp);
	      std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
              std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));
              // append the list back ...
              //std::cout << min_wcp.index << " " << temp_cluster->get_path_wcps().size() << std::endl;
              if (flag_front){
                while(old_list.front().index != min_wcp.index && old_list.size()>0 ){
                  old_list.pop_front();
                }
                old_list.pop_front();
                //      std::cout << "f2 " << old_list.size() << std::endl;
                for (auto it = new_list.rbegin(); it!=new_list.rend(); it++){
                  old_list.push_front(*it);
		}
		 //      std::cout << "f3 " << old_list.size() << std::endl;
              }else{
                //      std::cout << "b1 " << old_list.size() << std::endl;
                while(old_list.back().index != min_wcp.index && old_list.size()>0 ){
                  old_list.pop_back();
                }
                old_list.pop_back();
                //      std::cout << "b2 " << old_list.size() << std::endl;
                for (auto it = new_list.rbegin(); it!=new_list.rend(); it++){
                  old_list.push_back(*it);
                }
                //      std::cout << "b3 " << old_list.size() << std::endl;
              }
              vec_wcps.clear();
              vec_wcps.reserve(old_list.size());
              std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));
              

            }
	    main_vertex->set_wcpt(vtx1->get_wcpt());

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

	      WCPPID::ProtoVertex *tt_vtx = find_other_vertex(sg1, vtx1);
	      if (tt_vtx != main_vertex){
		add_proto_connection(main_vertex, sg1, temp_cluster);
	      }else{
		del_proto_segment(sg1);
	      }
	    }
	    del_proto_vertex(vtx1);
	    del_proto_segment(sg);
	    break;
	  }
	} // distance is close
      } // loop over segment of main vertices ...
    } // while continue
    
    if (flag_update){
      flag_continue = true;
      flag_updated = true;
      temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
    }
  }
  
  
  return flag_updated;
}


bool WCPPID::NeutrinoID::examine_structure_final_2(WCPPID::PR3DCluster* temp_cluster){
  bool flag_update;
  WCP::ToyPointCloud *pcloud = temp_cluster->get_point_cloud_steiner();
  bool flag_updated = false;
  
  if (main_vertex !=0 && main_vertex->get_cluster_id() == temp_cluster->get_cluster_id()){
    bool flag_continue = true;
    while(flag_continue){
      flag_continue = false;
      flag_update = false;
      for (auto it = map_vertex_segments[main_vertex].begin(); it != map_vertex_segments[main_vertex].end(); it++){
	WCPPID::ProtoSegment *sg = *it;
	WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg, main_vertex);
	//	std::cout << vtx1 << " " << main_vertex << " " << sg->get_id() << " " << map_segment_vertices[sg].size() << std::endl;

	if (map_vertex_segments[vtx1].size()==1 || map_vertex_segments[main_vertex].size()==1) continue;
	double dis = sqrt(pow(main_vertex->get_fit_pt().x - vtx1->get_fit_pt().x,2) + pow(main_vertex->get_fit_pt().y - vtx1->get_fit_pt().y, 2) + pow(main_vertex->get_fit_pt().z - vtx1->get_fit_pt().z,2));

	if (dis <2.0*units::cm){
	  // check to see if the vtx1 can be merged into main_vertex ...
	  flag_update = true;
	  for (auto it1 = map_vertex_segments[vtx1].begin(); it1 != map_vertex_segments[vtx1].end(); it1++){
	    WCPPID::ProtoSegment *sg1 = *it1;
	    if (sg == sg1) continue;
	    PointVector& pts = sg1->get_point_vec();
	    bool flag_start;
	    if (sg->get_wcpt_vec().front().index == vtx1->get_wcpt().index){
	      flag_start = true;
	    }else if (sg->get_wcpt_vec().back().index == vtx1->get_wcpt().index){
	      flag_start = false;
	    }
	    
	    Point min_point = pts.front();
	    double min_dis = 1e9;
	    int min_index;
	    for (size_t i=0;i!=pts.size();i++){
	      double dis = fabs(sqrt(pow(pts.at(i).x - vtx1->get_fit_pt().x,2) + pow(pts.at(i).y - vtx1->get_fit_pt().y,2) + pow(pts.at(i).z - vtx1->get_fit_pt().z,2))-3*units::cm);
	      if (dis < min_dis){
		min_dis = dis;
		min_point = pts.at(i);
		min_index = i;
	      }
	    }
	    
	    bool flag_connect = true;
	    if (flag_start){
	      for (int i = min_index; i>=0;i--){
		if (!ct_point_cloud->is_good_point(pts.at(i), 0.2*units::cm, 0, 0)) {
		  flag_connect = false;
		  break;
		}
	      }
	    }else{
	      for (int i = min_index; i<pts.size(); i++){
		if (!ct_point_cloud->is_good_point(pts.at(i), 0.2*units::cm, 0, 0)) {
		  flag_connect = false;
		  break;
		}
	      }	    
	    }

	    // std::cout << min_index << " " << pts.size() << " " << min_point << " " << flag_connect << std::endl;
	    
	    if (flag_connect){
	      double step_size = 0.3  *units::cm;
	      Point start_p = min_point;
	      Point end_p = main_vertex->get_fit_pt();
	      int ncount = std::round(sqrt(pow(start_p.x - end_p.x,2) + pow(start_p.y - end_p.y,2) + pow(start_p.z - end_p.z,2))/step_size);
	      int n_bad = 0;
	      for (int i=1;i<ncount;i++){
		Point test_p(start_p.x + (end_p.x - start_p.x)/ncount*i,
			     start_p.y + (end_p.y - start_p.y)/ncount*i,
			     start_p.z + (end_p.z - start_p.z)/ncount*i);
		if (!ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0)) {
		  n_bad ++;
		}
	      }
	      if (n_bad >0) flag_update = false;
	      // std::cout << flag_connect << " " << n_bad << " " << start_p << " " << end_p << " " << ncount << std::endl;
	    }
	  } // loop segments connecting to vtx1

	  //	  std::cout << flag_update << " " << vtx1->get_id() << " " << vtx1->get_fit_pt() << " " << main_vertex->get_id()  << " " << main_vertex->get_fit_pt() << std::endl;

	  // sg needs to be solid in all three views ...
	  if ((!flag_update) && map_vertex_segments[vtx1].size()==2){
	    PointVector& tmp_pts = sg->get_point_vec();
	    for (size_t i=0;i!= tmp_pts.size(); i++){
	      Point test_p = tmp_pts.at(i);
	      if (!ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0)) flag_update = true;
	      if (i+1 != tmp_pts.size()){
		test_p.x += (tmp_pts.at(i+1).x - tmp_pts.at(i).x)/2.;
		test_p.y += (tmp_pts.at(i+1).y - tmp_pts.at(i).y)/2.;
		test_p.z += (tmp_pts.at(i+1).z - tmp_pts.at(i).z)/2.;
		if (!ct_point_cloud->is_good_point(test_p, 0.2*units::cm, 0, 0)) flag_update = true;
	      }
	    }
	  }

	  
	  if (flag_update){
	    std::cout << "Cluster: " << temp_cluster->get_cluster_id() << " Final stage merge vertex to main vertex " << vtx1->get_id() << " " << vtx1->get_fit_pt() << " " << main_vertex->get_id()  << " " << main_vertex->get_fit_pt() << std::endl;
	    for (auto it1 = map_vertex_segments[vtx1].begin(); it1 != map_vertex_segments[vtx1].end(); it1++){
	      WCPPID::ProtoSegment *sg1 = *it1;
	      if (sg1 == sg) continue;
	      WCP::WCPointCloud<double>::WCPoint& vtx_new_wcp = main_vertex->get_wcpt();
	      std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps = sg1->get_wcpt_vec();
	      bool flag_front = false;
	      if (vec_wcps.front().index == vtx1->get_wcpt().index) flag_front = true;
	      
	      WCP::WCPointCloud<double>::WCPoint min_wcp;
	      double min_dis = 1e9;
	      double max_dis = std::max(sqrt(pow(vec_wcps.front().x -vtx1->get_fit_pt().x,2)+pow(vec_wcps.front().y -vtx1->get_fit_pt().y,2)+pow(vec_wcps.front().z -vtx1->get_fit_pt().z,2)), sqrt(pow(vec_wcps.back().x -vtx1->get_fit_pt().x,2)+pow(vec_wcps.back().y -vtx1->get_fit_pt().y,2)+pow(vec_wcps.back().z -vtx1->get_fit_pt().z,2)));
	      for (size_t j=0;j!=vec_wcps.size();j++){
		double dis1 = sqrt(pow(vec_wcps.at(j).x -vtx1->get_fit_pt().x,2)+pow(vec_wcps.at(j).y -vtx1->get_fit_pt().y,2)+pow(vec_wcps.at(j).z -vtx1->get_fit_pt().z,2));
		double dis = fabs(dis1 - 3.0*units::cm);
		if (dis < min_dis){
		  min_wcp = vec_wcps.at(j);
		  min_dis = dis;
		}
	      }
	      // establish the shortest path ...
	      std::list<WCP::WCPointCloud<double>::WCPoint> new_list;
	      new_list.push_back(vtx_new_wcp);
	      {
		double dis_step = 1.0*units::cm;
		int ncount = std::round(sqrt(pow(vtx_new_wcp.x - min_wcp.x,2) + pow(vtx_new_wcp.y - min_wcp.y,2) + pow(vtx_new_wcp.z - min_wcp.z,2))/dis_step);
		if (ncount <2) ncount = 2;
		for (int qx=1;qx<ncount;qx++){
		  Point tmp_p(vtx_new_wcp.x + (min_wcp.x-vtx_new_wcp.x)/ncount*qx, vtx_new_wcp.y + (min_wcp.y-vtx_new_wcp.y)/ncount*qx, vtx_new_wcp.z + (min_wcp.z-vtx_new_wcp.z)/ncount*qx);
		  WCP::WCPointCloud<double>::WCPoint& tmp_wcp = pcloud->get_closest_wcpoint(tmp_p);
		  //std::cout << qx << " " << sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) + pow(tmp_wcp.z - tmp_p.z,2))/units::cm << std::endl;
		  if (sqrt(pow(tmp_wcp.x - tmp_p.x,2) + pow(tmp_wcp.y - tmp_p.y,2) + pow(tmp_wcp.z - tmp_p.z,2)) > 0.3*units::cm) continue; // too large ...
		  if (tmp_wcp.index != new_list.back().index && tmp_wcp.index != min_wcp.index)
		    new_list.push_back(tmp_wcp);
		}
	      }
	      new_list.push_back(min_wcp);
	      
	      
	      std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
	      std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));
	      // append the list back ...
	      //std::cout << min_wcp.index << " " << temp_cluster->get_path_wcps().size() << std::endl;
	      if (flag_front){
		while(old_list.front().index != min_wcp.index && old_list.size()>0 ){
		  old_list.pop_front();
		}
		old_list.pop_front();
		//      std::cout << "f2 " << old_list.size() << std::endl;
		for (auto it = new_list.rbegin(); it!=new_list.rend(); it++){
		  old_list.push_front(*it);
		}
		//      std::cout << "f3 " << old_list.size() << std::endl;
	      }else{
		//      std::cout << "b1 " << old_list.size() << std::endl;
		while(old_list.back().index != min_wcp.index && old_list.size()>0 ){
		  old_list.pop_back();
		}
		old_list.pop_back();
		//      std::cout << "b2 " << old_list.size() << std::endl;
		for (auto it = new_list.rbegin(); it!=new_list.rend(); it++){
		  old_list.push_back(*it);
		}
		//      std::cout << "b3 " << old_list.size() << std::endl;
	      }
	      vec_wcps.clear();
	      vec_wcps.reserve(old_list.size());
	      std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));

	      WCPPID::ProtoVertex *tt_vtx = find_other_vertex(sg1, vtx1);
	      if (tt_vtx != main_vertex){
		add_proto_connection(main_vertex, sg1, temp_cluster);
	      }else{
		del_proto_segment(sg1);
	      }
	    }
	    
	    del_proto_vertex(vtx1);
	    del_proto_segment(sg);
	    break;
	  }
	} // distacen is close
      } //loop over segment connecting to main vertex
      if (flag_update){
	flag_continue = true;
	flag_updated = true;
	temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
      }
    } // flag continue loop ...
  } // general check


  return flag_updated;
}


bool WCPPID::NeutrinoID::examine_structure_final_1p(WCPPID::PR3DCluster* temp_cluster){
  bool flag_update = false;
  std::set<WCPPID::ProtoSegment*> new_segments; // need to fit and then PID ...

  auto it = map_vertex_segments.find(main_vertex);
  if (it == map_vertex_segments.end() || it->second.size()!=2) return flag_update;
  
  WCPPID::ProtoSegment *sg1 = *(it->second.begin());
  WCPPID::ProtoSegment *sg2 = *(it->second.rbegin());

  TVector3 dir1 = sg1->cal_dir_3vector(main_vertex->get_fit_pt(), 15*units::cm);
  TVector3 dir2 = sg2->cal_dir_3vector(main_vertex->get_fit_pt(), 15*units::cm);
  double angle = dir1.Angle(dir2)/3.1415926*180.;
  double length1 = sg1->get_length();
  double length2 = sg2->get_length();

  //  std::cout << angle << " " << main_vertex->get_wcpt().index << std::endl;
  
  if (angle > 175){
    if (length1 < 6*units::cm && length1 < length2){
      WCPPID::ProtoVertex *vtx = find_other_vertex(sg1, main_vertex);
      std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps = sg2->get_wcpt_vec();
      bool flag_front;
      if (vec_wcps.front().index == main_vertex->get_wcpt().index){
	flag_front = true;
      }else{
	flag_front = false;
      }
      std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps1 = sg1->get_wcpt_vec();
      bool flag_front1;
      if (vec_wcps1.front().index == main_vertex->get_wcpt().index){
	flag_front1 = true;
      }else{
	flag_front1 = false;
      }
      
      
      std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
      std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));

      if (flag_front && flag_front1){
	for (auto it1 = vec_wcps1.begin(); it1 != vec_wcps1.end(); it1++){
	  if ((*it1).index != old_list.front().index) old_list.push_front(*it1);
	}
      }else if (flag_front && (!flag_front1)){
	for (auto it1 = vec_wcps1.rbegin(); it1 != vec_wcps1.rend(); it1++){
	  if ((*it1).index != old_list.front().index) old_list.push_front(*it1);
	}
      }else if ((!flag_front) && flag_front1){
	for (auto it1 = vec_wcps1.begin(); it1 != vec_wcps1.end(); it1++){
	  if ((*it1).index != old_list.back().index) old_list.push_back(*it1);
	}
      }else if ((!flag_front) && (!flag_front1)){
	for (auto it1 = vec_wcps1.rbegin(); it1 != vec_wcps1.rend(); it1++){
	  if ((*it1).index != old_list.back().index) old_list.push_back(*it1);
	}
      }
      
      vec_wcps.clear();
      vec_wcps.reserve(old_list.size());
      std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));
      main_vertex->set_wcpt(vtx->get_wcpt());

      //      std::cout << main_vertex->get_wcpt().index << " A " << vtx->get_wcpt().index << std::endl;
      
      for (auto it1 = map_vertex_segments[vtx].begin(); it1 != map_vertex_segments[vtx].end(); it1++){
	if ((*it1) == sg1) continue;
	add_proto_connection(main_vertex,*it1,temp_cluster);
      }
      del_proto_segment(sg1);
      del_proto_vertex(vtx);

      flag_update =true;
      
    }else if (length2 < 6*units::cm && length2 < length1){
      
      WCPPID::ProtoVertex *vtx = find_other_vertex(sg2, main_vertex);
      std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps = sg1->get_wcpt_vec();
      bool flag_front;
      if (vec_wcps.front().index == main_vertex->get_wcpt().index){
	flag_front = true;
      }else{
	flag_front = false;
      }
      std::vector<WCP::WCPointCloud<double>::WCPoint >& vec_wcps1 = sg2->get_wcpt_vec();
      bool flag_front1;
      if (vec_wcps1.front().index == main_vertex->get_wcpt().index){
	flag_front1 = true;
      }else{
	flag_front1 = false;
      }
      
      
      std::list<WCP::WCPointCloud<double>::WCPoint> old_list;
      std::copy(vec_wcps.begin(), vec_wcps.end(), std::back_inserter(old_list));

      if (flag_front && flag_front1){
	for (auto it1 = vec_wcps1.begin(); it1 != vec_wcps1.end(); it1++){
	  if ((*it1).index != old_list.front().index) old_list.push_front(*it1);
	}
      }else if (flag_front && (!flag_front1)){
	for (auto it1 = vec_wcps1.rbegin(); it1 != vec_wcps1.rend(); it1++){
	  if ((*it1).index != old_list.front().index) old_list.push_front(*it1);
	}
      }else if ((!flag_front) && flag_front1){
	for (auto it1 = vec_wcps1.begin(); it1 != vec_wcps1.end(); it1++){
	  if ((*it1).index != old_list.back().index) old_list.push_back(*it1);
	}
      }else if ((!flag_front) && (!flag_front1)){
	for (auto it1 = vec_wcps1.rbegin(); it1 != vec_wcps1.rend(); it1++){
	  if ((*it1).index != old_list.back().index) old_list.push_back(*it1);
	}
      }
      
      vec_wcps.clear();
      vec_wcps.reserve(old_list.size());
      std::copy(std::begin(old_list), std::end(old_list), std::back_inserter(vec_wcps));
      main_vertex->set_wcpt(vtx->get_wcpt());
      

      //      std::cout << main_vertex->get_wcpt().index << " B " << vtx->get_wcpt().index << std::endl;
      
      for (auto it1 = map_vertex_segments[vtx].begin(); it1 != map_vertex_segments[vtx].end(); it1++){
	if ((*it1) == sg2) continue;
	add_proto_connection(main_vertex,*it1,temp_cluster);
      }
      del_proto_segment(sg2);
      del_proto_vertex(vtx);

      flag_update =true;
    }
    
    //    std::cout << main_vertex->get_wcpt().index << std::endl;
    
    if (flag_update)
      temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
  }
  
  return flag_update;
}


bool WCPPID::NeutrinoID::examine_structure_final_1(WCPPID::PR3DCluster* temp_cluster){
  // merge two segments if a direct connection is better ...
  bool flag_update = false;
  bool flag_continue = true;

  std::set<WCPPID::ProtoSegment*> new_segments; // need to fit and then PID ...
  
  while(flag_continue){
    flag_continue = false;
    for (auto it = map_vertex_segments.begin(); it!=map_vertex_segments.end(); it++){
      WCPPID::ProtoVertex *vtx = it->first;
      if (vtx->get_cluster_id()!=temp_cluster->get_cluster_id()) continue;
      if (it->second.size()!=2) continue;
      if (vtx == main_vertex) continue;
      WCPPID::ProtoSegment *sg1 = *(it->second.begin());
      WCPPID::ProtoSegment *sg2 = *(it->second.rbegin());

      if (sg1->get_wcpt_vec().front().index == sg2->get_wcpt_vec().front().index && sg1->get_wcpt_vec().back().index == sg2->get_wcpt_vec().back().index
	  || sg1->get_wcpt_vec().front().index == sg2->get_wcpt_vec().back().index && sg1->get_wcpt_vec().back().index == sg2->get_wcpt_vec().front().index){
	del_proto_segment(sg2);
	flag_update = true;
	flag_continue = true;
	break;
      }else{
	double length1 = sg1->get_length();
	double length2 = sg2->get_length();
	
	
	WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg1, vtx);
	WCPPID::ProtoVertex *vtx2 = find_other_vertex(sg2, vtx);
	
	//      std::cout << map_segment_vertices[sg1].size() << " " << map_segment_vertices[sg2].size() << " " << sg1->get_id() << " " << sg1->get_wcpt_vec().front().index << " " << sg1->get_wcpt_vec().back().index << " " << sg2->get_id() << " " << sg2->get_wcpt_vec().front().index << " " << sg2->get_wcpt_vec().back().index << std::endl;
	
	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() << " Final stage 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);
	  
	  
	  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);
	  
	  del_proto_segment(sg1);
	  del_proto_segment(sg2);
	  del_proto_vertex(vtx);
	  
	  flag_update = true;
	  flag_continue = true;
	  break;
	}
      }
    }
  } // continue
  if (flag_update){

    /* 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_id() << " " << it->second.size() << " " << sg->get_wcpt_vec().front().index << " " << sg->get_wcpt_vec().back().index << " " << (*it->second.begin())->get_wcpt().index << " " << (*it->second.rbegin())->get_wcpt().index << std::endl; */
    /* } */
    
    temp_cluster->do_multi_tracking(map_vertex_segments, map_segment_vertices, *ct_point_cloud, global_wc_map, flash_time*units::microsecond, true, true, true);
  }
  return flag_update;
}




/* bool WCPPID::NeutrinoID::examine_vertices_5(WCPPID::PR3DCluster* temp_cluster){ */

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


  
/*   for (auto it = map_vertex_segments.begin(); it != map_vertex_segments.end(); it++){ */
/*     WCPPID::ProtoVertex *vtx = it->first; */
/*     if (vtx->get_cluster_id() != temp_cluster->get_cluster_id()) continue; */
/*     if (it->second.size()!=2) continue; // require two segments ... */
    
/*     for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++){ */
/*       WCPPID::ProtoSegment *sg1 = (*it1); */
/*       WCPPID::ProtoVertex *vtx1 = find_other_vertex(sg1, vtx); */
      
/*       auto it2 = map_vertex_segments.find(vtx1); */
/*       if ((it2->second).size()!=2) continue; // require two segments ... */
/*       WCPPID::ProtoSegment *sg2  = 0; */
/*       for (auto it3 = it2->second.begin(); it3 != it2->second.end(); it3++){ */
/* 	if (*it3 != sg1){ */
/* 	  sg2 = *it3; */
/* 	  break; */
/* 	} */
/*       } */

/*       WCPPID::ProtoVertex *vtx2 = find_other_vertex(sg2, vtx1); */
/*       double dis = sqrt(pow(vtx->get_fit_pt().x - vtx2->get_fit_pt().x,2) + pow(vtx->get_fit_pt().y - vtx2->get_fit_pt().y,2) + pow(vtx->get_fit_pt().z - vtx2->get_fit_pt().z,2)); */
/*       if (dis < 5*units::cm){ */
/* 	WCPPID::ProtoSegment *sg = 0; */
/* 	for (auto it3 = it->second.begin(); it3 != it->second.end(); it3++){ */
/* 	  if ( *it3 != sg1) { */
/* 	    sg = *it3; */
/* 	    break; */
/* 	  } */
/* 	} */
/* 	std::cout << sg1->get_id() << " " << sg2->get_id() << std::endl; */
/* 	examine_vertices_5(sg, vtx, vtx2, sg1, vtx1, sg2); */
/*       } */
/*     } */
/*   } */

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


/* bool WCPPID::NeutrinoID::examine_vertices_5(WCPPID::ProtoSegment *sg, WCPPID::ProtoVertex* vtx, WCPPID::ProtoVertex *vtx2, WCPPID::ProtoSegment *sg1, WCPPID::ProtoVertex *vtx1, WCPPID::ProtoSegment *sg2){ */
/*   TVector3 dir1(vtx2->get_fit_pt().x - vtx->get_fit_pt().x, vtx2->get_fit_pt().y - vtx->get_fit_pt().y, vtx2->get_fit_pt().z - vtx->get_fit_pt().z); */
/*   TVector3 dir2 = sg->cal_dir_3vector(vtx->get_fit_pt(), 6*units::cm); */

/*   std::cout << dir1.Angle(dir2)/3.1415926*180. << std::endl; */
/* } */
