

void WCP2dToy::Clustering_live_dead(WCP::PR3DClusterSelection& live_clusters, WCP::PR3DClusterSelection& dead_clusters, WCP::map_pr3dcluster_double& cluster_length_map, WCP::PR3DClusterSet& cluster_connected_dead){

  TPCParams& mp = Singleton<TPCParams>::Instance();
  double pitch_u = mp.get_pitch_u();
  double pitch_v = mp.get_pitch_v();
  double pitch_w = mp.get_pitch_w();
  double angle_u = mp.get_angle_u();
  double angle_v = mp.get_angle_v();
  double angle_w = mp.get_angle_w();
  double time_slice_width = mp.get_ts_width();
  
   // dead to live clusters mapping ... 
   std::map<PR3DCluster*,std::vector<PR3DCluster*>> dead_live_cluster_mapping;
   std::map<PR3DCluster*,std::vector<SMGCSelection>> dead_live_mcells_mapping;
   
   // form map between live and dead clusters ... 
   for (size_t i = 0; i!=live_clusters.size(); i++){
     for (size_t j = 0; j!= dead_clusters.size(); j++){
       SMGCSelection mcells = (live_clusters.at(i))->Is_Connected(dead_clusters.at(j),2);
       int live_cluster_id = live_clusters.at(i)->get_cluster_id();
       int dead_cluster_id = dead_clusters.at(j)->get_cluster_id();

       if ( mcells.size()>0 ){
	 if (dead_live_cluster_mapping.find(dead_clusters.at(j))==dead_live_cluster_mapping.end() ){
	   std::vector<PR3DCluster*> temp_clusters;
	   temp_clusters.push_back(live_clusters.at(i));
	   dead_live_cluster_mapping[dead_clusters.at(j)] = temp_clusters;
	   std::vector<SMGCSelection> temp_mcells;
	   temp_mcells.push_back(mcells);
	   dead_live_mcells_mapping[dead_clusters.at(j)] = temp_mcells;
	 }else{
	   dead_live_cluster_mapping[dead_clusters.at(j)].push_back(live_clusters.at(i));
	   dead_live_mcells_mapping[dead_clusters.at(j)].push_back(mcells);
	 }
       }
     }
   }
  
  std::set<std::pair<PR3DCluster*, PR3DCluster*>> tested_pairs;
  std::set<std::pair<PR3DCluster*, PR3DCluster*>> to_be_merged_pairs;

  
  for (auto it = dead_live_cluster_mapping.begin(); it!= dead_live_cluster_mapping.end(); it++){
    PR3DCluster* the_dead_cluster = (*it).first;
    std::vector<PR3DCluster*> connected_live_clusters = (*it).second;
    std::vector<SMGCSelection> connected_live_mcells = dead_live_mcells_mapping[the_dead_cluster];

    if (connected_live_clusters.size()>1){

      // try to record the length of each blob ...
      //std::vector<double> cluster_length_vec;
      /* for (size_t i=0; i!= connected_live_clusters.size(); i++){ */
      /* 	PR3DCluster* cluster_1 = connected_live_clusters.at(i); */
      /* 	std::vector<int> range_v1 = cluster_1->get_uvwt_range(); */
      /* 	// example ... */
      /* 	double length_1 = sqrt(2./3. * (pow(pitch_u*range_v1.at(0),2) + pow(pitch_v*range_v1.at(1),2) + pow(pitch_w*range_v1.at(2),2)) + pow(time_slice_width*range_v1.at(3),2)); */
      /* 	cluster_length_map[cluster_1] = length_1; */
      /* 	//cluster_length_vec.push_back(length_1); */
      /* } */
      
      for (size_t i=0; i!= connected_live_clusters.size(); i++){
	
	
        PR3DCluster* cluster_1 = connected_live_clusters.at(i);
      	SMGCSelection mcells_1 = connected_live_mcells.at(i);
	cluster_1->Create_point_cloud();
      	ToyPointCloud* cloud_1 = cluster_1->get_point_cloud();

	cluster_connected_dead.insert(cluster_1);
	
      	for (size_t j=i+1;j<connected_live_clusters.size(); j++){
      	  PR3DCluster* cluster_2 = connected_live_clusters.at(j);
      	  SMGCSelection mcells_2 = connected_live_mcells.at(j);
      	  cluster_2->Create_point_cloud();
      	  ToyPointCloud* cloud_2 = cluster_2->get_point_cloud();
	
      	  if (tested_pairs.find(std::make_pair(cluster_1,cluster_2))==tested_pairs.end()){
	    tested_pairs.insert(std::make_pair(cluster_1,cluster_2));
      	    tested_pairs.insert(std::make_pair(cluster_2,cluster_1));
      	    // starting the test ... 

      	    bool flag_merge = false;
	    
      	    // pick any point and merged cell in cluster1,
      	    SlimMergeGeomCell *prev_mcell1 = 0;
      	    SlimMergeGeomCell *prev_mcell2 = 0;
      	    SlimMergeGeomCell *mcell1 = mcells_1.at(0);
      	    Point p1 = mcell1->center();
      	    WCPointCloud<double>::WCPoint wcp1 = cloud_1->get_closest_wcpoint(p1);
		   
      	    SlimMergeGeomCell *mcell2=0;
      	    Point p2;
      	    WCPointCloud<double>::WCPoint wcp2;
	    
      	    while(mcell1!=prev_mcell1 || mcell2!=prev_mcell2){
      	      prev_mcell1 = mcell1;
      	      prev_mcell2 = mcell2;

      	      wcp2 = cloud_2->get_closest_wcpoint(wcp1);
      	      mcell2 = wcp2.mcell;

      	      wcp1 = cloud_1->get_closest_wcpoint(wcp2);
      	      mcell1 = wcp1.mcell;
	    }
      	    p1.x = wcp1.x; p1.y = wcp1.y; p1.z = wcp1.z;
      	    p2.x = wcp2.x; p2.y = wcp2.y; p2.z = wcp2.z;
	    double dis = sqrt(pow(p1.x-p2.x,2)+pow(p1.y-p2.y,2)+pow(p1.z-p2.z,2));


	    if (dis < 60*units::cm){
	      double length_1 = cluster_length_map[cluster_1];//cluster_length_vec.at(i);
	      double length_2 = cluster_length_map[cluster_2];//cluster_length_vec.at(j);
	      
	      Point mcell1_center, mcell2_center;
	      TVector3 dir1, dir3;

	       
	     
	      mcell1_center = cluster_1->calc_ave_pos(p1,5*units::cm);
	      dir1 = cluster_1->VHoughTrans(mcell1_center,30*units::cm);
	      
	      mcell2_center = cluster_2->calc_ave_pos(p2,5*units::cm);
	      dir3 = cluster_2->VHoughTrans(mcell2_center,30*units::cm);
	      
	      
	      TVector3 dir2 (mcell2_center.x - mcell1_center.x, mcell2_center.y - mcell1_center.y, mcell2_center.z - mcell1_center.z);
	      TVector3 dir4 (mcell1_center.x - mcell2_center.x, mcell1_center.y - mcell2_center.y, mcell1_center.z - mcell2_center.z);
		
		
	      double angle_diff1 = (3.1415926-dir1.Angle(dir2))/3.1415926*180.; // 1 to 2
	      double angle_diff2 = (3.1415926-dir3.Angle(dir4))/3.1415926*180.; // 2 to 1
	      double angle_diff3 = (3.1415926-dir1.Angle(dir3))/3.1415926*180.; // 1 to 2
	      
	      
	      bool flag_para =false;

	      

	      
	      double angle1, angle2, angle3;
	      if (!flag_merge){
		// deal with parallel live dead merge ... 
		TVector3 drift_dir(1,0,0);
		angle1 = dir1.Angle(drift_dir); // cluster 1
		angle2 = dir2.Angle(drift_dir); // cluster 1 to cluster 2 
		angle3 = dir3.Angle(drift_dir); // cluster 2 
		if (fabs(angle1-3.1415926/2.)<5/180.*3.1415926 &&
		    fabs(angle2-3.1415926/2.)<5/180.*3.1415926 &&
		    fabs(angle3-3.1415926/2.)<5/180.*3.1415926 ){
		  if (dis < 10*units::cm)  // if very parallel and close, merge any way
		    flag_merge = true;
		}
		
		// if parallel
		if (fabs(angle2-3.1415926/2.)<7.5/180.*3.1415926 &&
		    (fabs(angle1-3.1415926/2.)<7.5/180.*3.1415926 ||
		     fabs(angle3-3.1415926/2.)<7.5/180.*3.1415926) &&
		    fabs(angle1-3.1415926/2.)+fabs(angle2-3.1415926/2.)+fabs(angle3-3.1415926/2.) < 25/180.*3.1415926){
		  flag_para = true;
		  if (WCP2dToy::is_angle_consistent(dir1,dir2,false,15,angle_u,angle_v,angle_w,3) && WCP2dToy::is_angle_consistent(dir3,dir2,true,15,angle_u,angle_v,angle_w,3))
		    flag_merge = true;
		}else{
		  bool flag_const1 = WCP2dToy::is_angle_consistent(dir1,dir2,false,10,angle_u,angle_v,angle_w);
		  bool flag_const2 = WCP2dToy::is_angle_consistent(dir3,dir2,true,10,angle_u,angle_v,angle_w);

		  if (flag_const1 && flag_const2){
		    flag_merge = true;
		  }else if (flag_const1 && length_2 < 6*units::cm && length_1 > 15*units::cm){
		    if (WCP2dToy::is_angle_consistent(dir1,dir2,false,5,angle_u,angle_v,angle_w,3))
		      flag_merge = true;
		  }else if (flag_const2 && length_1 < 6*units::cm && length_2 > 15*units::cm){
		    if (WCP2dToy::is_angle_consistent(dir3,dir2,true,5,angle_u,angle_v,angle_w,3))
		       flag_merge = true;
		  }
		  
		}
	      }
	      
	      
	      // divide into four cases, according to length ... 
	      if (!flag_merge){
		
	
		
		if (length_1 <= 12*units::cm && length_2 <=12*units::cm){
		  // both are short
		  if ((dis <= 3*units::cm) && ((angle_diff1 <= 45 || angle_diff2 <=45) && (angle_diff3 < 60) ||
					       (flag_para && (angle_diff1 <= 90 || angle_diff2 <=90) && angle_diff3 < 120)) ||
		      (dis <= 5*units::cm) && (angle_diff1 <= 30 || angle_diff2 <=30) && angle_diff3 < 45 ||
		      (dis <=15*units::cm) && (angle_diff1<=15 || angle_diff2 <=15) && angle_diff3 < 20||
		      (dis <=60*units::cm) && (angle_diff1<5 || angle_diff2 < 5) && angle_diff3 < 10
		      ){
		    flag_merge = true;
		  }
		} else if (length_1 > 12*units::cm && length_2 <=12*units::cm){
		  //one is short
		  if ((dis <= 3*units::cm)  && ((angle_diff1 <= 45 || angle_diff2<=45) && (angle_diff3 < 60) ||
		  				(flag_para && (angle_diff1 <= 90 || angle_diff2 <=90 )&& angle_diff3 < 120))
		      || dis <= 5*units::cm && angle_diff1 <=30 && angle_diff3 < 60
		      || dis <= 15*units::cm && (angle_diff1 <=20) && angle_diff3 < 40
		      || (angle_diff1<10 && dis <= 60*units::cm && angle_diff3 < 15))
		    flag_merge = true;
		}else if (length_2 > 12*units::cm && length_1 <=12*units::cm){
		  // one is short
		  if ((dis <= 3*units::cm)  && ((angle_diff2 <= 45 || angle_diff2<=45) && (angle_diff3 < 60)||
		  				(flag_para && (angle_diff1 <= 90 || angle_diff2 <=90 )&& angle_diff3 < 120))
		      || dis <=5*units::cm && angle_diff2 <=30  && angle_diff3 < 60
		      || dis <= 15*units::cm && (angle_diff2 <=20) && angle_diff3 < 40
		      || (angle_diff2<10 && dis <= 60*units::cm&& angle_diff3 < 15))
		    flag_merge = true;
		}else{
		  // both are long
		  if ((dis <= 3*units::cm) && ((angle_diff1 <= 45 || angle_diff2 <=45) && (angle_diff3 < 60) ||
		  			       (flag_para && (angle_diff1 <= 90 || angle_diff2 <=90 )&& angle_diff3 < 120)) 
		      || dis <=5*units::cm && (angle_diff1 <=30 || angle_diff2 <=30) && angle_diff3 < 45 
		      || (dis <=15*units::cm) && (angle_diff1<=20 || angle_diff2 <=20) && angle_diff3<30  
		      || (angle_diff1<10 || angle_diff2 < 10) && (dis <=60*units::cm) && angle_diff3 < 15
		      )
		    flag_merge = true;
		  
		}
	      }
	      	    
	      if (flag_merge){
		to_be_merged_pairs.insert(std::make_pair(cluster_1,cluster_2));
	      }
	    }
	      
	    
	    
	    

	    
      	    //std::cout << cluster_1->get_cluster_id() << " " << cluster_2->get_cluster_id() << " " << flag_1 << " " << length_1/units::cm << " " << flag_2 << " " << length_2/units::cm << " " << dis/units::cm << std::endl;
      	    // if (flag_1){
      	    //   cluster_1->dijkstra_shortest_paths(wcp1);
      	    //   TVector3 dir1 = cluster_1->VHoughTrans(p1,30*units::cm);
      	    //   Point p_test;
      	    //   p_test.x = p1.x + dir1.X()*30*units::cm;
      	    //   p_test.y = p1.y + dir1.Y()*30*units::cm;
      	    //   p_test.z = p1.z + dir1.Z()*30*units::cm;
      	    //   WCPointCloud<double>::WCPoint& wcp1_target = cloud_1->get_closest_wcpoint(p_test);
      	    //   cluster_1->cal_shortest_path(wcp1_target);
      	    //   cluster_1->fine_tracking(4);
      	    //   if (!cluster_1->get_fine_tracking_flag()) flag_1 = false;
      	    // }

      	    // if (flag_2){
      	    //   cluster_2->dijkstra_shortest_paths(wcp2);
      	    //   TVector3 dir2 = cluster_2->VHoughTrans(p2,30*units::cm);
      	    //   Point p_test;
      	    //   p_test.x = p2.x + dir2.X()*30*units::cm;
      	    //   p_test.y = p2.y + dir2.Y()*30*units::cm;
      	    //   p_test.z = p2.z + dir2.Z()*30*units::cm;
      	    //   WCPointCloud<double>::WCPoint& wcp2_target = cloud_2->get_closest_wcpoint(p_test);
      	    //   cluster_2->cal_shortest_path(wcp2_target);
      	    //   cluster_2->fine_tracking(4);
      	    //   if (!cluster_2->get_fine_tracking_flag()) flag_2 = false;
      	    // }
      	    // if (flag_1 && flag_2){ // both long tracks
      	    //   TVector3 dir_1 = cluster_1->get_ft_dir_end(3*units::cm,10*units::cm);
      	    //   Line l1(cluster_1->get_fine_tracking_path().at(0),dir_1);
      	    //   TVector3 dir_2 = cluster_2->get_ft_dir_end(3*units::cm,10*units::cm);
      	    //   Line l2(cluster_2->get_fine_tracking_path().at(0),dir_2);
      	    //   double dis1 = l1.closest_dis(l2);
      	    //   double angle_diff = (3.1415926-dir_1.Angle(dir_2))/3.1415926*180.;
      	    //   std::cout <<  angle_diff << " " << dis1/units::cm << " " << dis/units::cm << std::endl;
      	    // }else if (flag_1 && !flag_2){// 1 is long, 2 is short
      	    // }else if (flag_2 && !flag_1){// 2 is long 1 is short
      	    // }else{ // both are short ...
      	    // }
	    
      	    
      	  }
      	}
      }
      //  std::cout << std::endl;
    }
  }
  
  //to_be_merged_pairs.clear();
  
  std::vector<std::set<PR3DCluster*>> merge_clusters;
  for (auto it = to_be_merged_pairs.begin(); it!=to_be_merged_pairs.end(); it++){
    PR3DCluster *cluster1 = (*it).first;
    PR3DCluster *cluster2 = (*it).second;
    //  std::cout << cluster1 << " " << cluster2 << " " << cluster1->get_cluster_id() << " " << cluster2->get_cluster_id() << std::endl;
    
    bool flag_new = true;
    std::vector<std::set<PR3DCluster*>> temp_set;
    for (auto it1 = merge_clusters.begin(); it1!=merge_clusters.end(); it1++){
      std::set<PR3DCluster*>& clusters = (*it1);
      if (clusters.find(cluster1)!=clusters.end() ||
	  clusters.find(cluster2)!=clusters.end()){
	clusters.insert(cluster1);
	clusters.insert(cluster2);
	flag_new = false;
	temp_set.push_back(clusters);
	//break;
      }
    }
    if (flag_new){
      std::set<PR3DCluster*> clusters;
      clusters.insert(cluster1);
      clusters.insert(cluster2);
      merge_clusters.push_back(clusters);
    }
    if (temp_set.size()>1){
      // merge them further ...
      std::set<PR3DCluster*> clusters;
      for (size_t i=0;i!=temp_set.size();i++){
	for (auto it1 = temp_set.at(i).begin(); it1!= temp_set.at(i).end(); it1++){
	  clusters.insert(*it1);
	}
	merge_clusters.erase(find(merge_clusters.begin(),merge_clusters.end(),temp_set.at(i)));
      }
      merge_clusters.push_back(clusters);
    }
  }

  // merge clusters into new clusters, delete old clusters 
  for (auto it = merge_clusters.begin(); it!=merge_clusters.end();it++){
    std::set<PR3DCluster*>& clusters = (*it);
    PR3DCluster *ncluster = new PR3DCluster((*clusters.begin())->get_cluster_id());
    live_clusters.push_back(ncluster);
    for (auto it1 = clusters.begin(); it1!=clusters.end(); it1++){
      PR3DCluster *ocluster = *(it1);
      // std::cout << ocluster->get_cluster_id() << " ";
      SMGCSelection& mcells = ocluster->get_mcells();
      for (auto it2 = mcells.begin(); it2!=mcells.end(); it2++){
  	SlimMergeGeomCell *mcell = (*it2);
  	//std::cout << ocluster->get_cluster_id() << " " << mcell << std::endl;
  	int time_slice = mcell->GetTimeSlice();
  	ncluster->AddCell(mcell,time_slice);
      }
      live_clusters.erase(find(live_clusters.begin(), live_clusters.end(), ocluster));
      cluster_length_map.erase(ocluster);
      cluster_connected_dead.erase(ocluster);
      delete ocluster;
    }
    std::vector<int> range_v1 = ncluster->get_uvwt_range();
    double length_1 = sqrt(2./3. * (pow(pitch_u*range_v1.at(0),2) + pow(pitch_v*range_v1.at(1),2) + pow(pitch_w*range_v1.at(2),2)) + pow(time_slice_width*range_v1.at(3),2));
    cluster_length_map[ncluster] = length_1;
    cluster_connected_dead.insert(ncluster);
    //std::cout << std::endl;
  }
  
  //std::cout << merge_clusters.size() << std::endl;
  
  //std::cout << to_be_merged_pairs.size() << std::endl;
  // 
  //   std::cout << "Pair: " << (*it).first->get_cluster_id() << " " << (*it).second->get_cluster_id() << std::endl;
  // }


  
}


// bool WCP2dToy::IsCrossing(WCP::Point& p, double theta, double phi, WCP::SlimMergeGeomCell *mcell, WCPSst::GeomDataSource& gds){
//   // dx = sintheta*cosphi*dl
//   // dy = sintheta*sinphi*dl
//   // dz = costheta*dl
//   Point pc = mcell->center();
//   Point p_test;
//   if (sin(theta)*cos(phi)!=0){
//     double dl = (pc.x - p.x)/(sin(theta)*cos(phi));
//     if (dl<0) return false;
    
//     p_test.x = pc.x;
//     p_test.y = p.y + sin(theta)*sin(phi)*dl;
//     p_test.z = p.z + cos(theta)*dl;

//     // std::cout << pc.x/units::cm << " " << p.x/units::cm << " " << dl/units::cm << " " << sqrt(pow(p_test.x - pc.x,2)+pow(p_test.y - pc.y,2)+pow(p_test.z - pc.z,2))/units::cm << std::endl;
    
//   }else{
//     p_test.x = pc.x;
//     double dl = (pc.y-p.y)*sin(theta)*sin(phi) + (pc.z-p.z)*cos(theta);
//     if (dl<0) return false;
//     p_test.y = p.y + sin(theta)*sin(phi)*dl;
//     p_test.z = p.z + cos(theta)*dl;
//   }
//   const GeomWire *uwire = gds.closest(p_test,WirePlaneType_t(0));
//   const GeomWire *vwire = gds.closest(p_test,WirePlaneType_t(1));
//   const GeomWire *wwire = gds.closest(p_test,WirePlaneType_t(2));

//   GeomWireSelection uwires = mcell->get_uwires();
//   GeomWireSelection vwires = mcell->get_vwires();
//   GeomWireSelection wwires = mcell->get_wwires();
  
//   // std::cout << uwires.front()->index() << " " << uwire->index() << " " << uwires.back()->index() << " "
//   // 	    << vwires.front()->index() << " " << vwire->index() << " " << vwires.back()->index() << " "
//   // 	    << wwires.front()->index() << " " << wwire->index() << " " << wwires.back()->index() << " " << std::endl;
    
//   if (uwire->index() >= uwires.front()->index() && uwire->index() <= uwires.back()->index() &&
//       vwire->index() >= vwires.front()->index() && vwire->index() <= vwires.back()->index() &&
//       wwire->index() >= wwires.front()->index() && wwire->index() <= wwires.back()->index()){
//     return true;
//   }else{
//     return false;
//   }
  
// }
