#include "WCP2dToy/uBooNE_Data_After_ROI.h"
#include "TSpectrum.h"


using namespace WCP;


WCP2dToy::uBooNEDataAfterROI::uBooNEDataAfterROI(WCP::FrameDataSource& fds, const WCP::GeomDataSource& gds, WCP2dToy::uBooNEDataROI& rois, int rebin)
  : fds(fds)
  , gds(gds)
  , rois(rois)
  , rebin(rebin)
{
  GeomWireSelection wires_u = gds.wires_in_plane(WirePlaneType_t(0));
  GeomWireSelection wires_v = gds.wires_in_plane(WirePlaneType_t(1));
  GeomWireSelection wires_w = gds.wires_in_plane(WirePlaneType_t(2));

  nwire_u = wires_u.size();
  nwire_v = wires_v.size();
  nwire_w = wires_w.size();

  // rois_u_tight.resize(nwire_u);
  // rois_v_tight.resize(nwire_v);
  // rois_w_tight.resize(nwire_w);

  // rois_u_loose.resize(nwire_u);
  // rois_v_loose.resize(nwire_v);
  // rois_w_loose.resize(nwire_w);
  
  for (Int_t i=0;i!=nwire_u;i++){
    SignalROIList temp_rois;
    rois_u_tight.push_back(temp_rois);
  }
  for (Int_t i=0;i!=nwire_v;i++){
    SignalROIList temp_rois;
    rois_v_tight.push_back(temp_rois);
  }
  for (Int_t i=0;i!=nwire_w;i++){
    SignalROIList temp_rois;
    rois_w_tight.push_back(temp_rois);
  }
  
  for (Int_t i=0;i!=nwire_u;i++){
    SignalROIList temp_rois;
    rois_u_loose.push_back(temp_rois);
  }
  for (Int_t i=0;i!=nwire_v;i++){
    SignalROIList temp_rois;
    rois_v_loose.push_back(temp_rois);
  }
  for (Int_t i=0;i!=nwire_w;i++){
    SignalROIList temp_rois;
    rois_w_loose.push_back(temp_rois);
  }
  

  bins_per_frame = int(fds.Get_Bins_Per_Frame()/rebin);
}


WCP2dToy::uBooNEDataAfterROI::~uBooNEDataAfterROI(){
  Clear();
}

int WCP2dToy::uBooNEDataAfterROI::size() const{
  return 1;
}

void WCP2dToy::uBooNEDataAfterROI::Clear(){
  for (int i=0;i!=nwire_u;i++){
    for (auto it = rois_u_tight.at(i).begin(); it!=rois_u_tight.at(i).end();it++){
      delete *it;
    }
    rois_u_tight.at(i).clear();
    for (auto it = rois_u_loose.at(i).begin(); it!=rois_u_loose.at(i).end();it++){
      delete *it;
    }
    rois_u_loose.at(i).clear();
  }

  for (int i=0;i!=nwire_v;i++){
    for (auto it = rois_v_tight.at(i).begin(); it!=rois_v_tight.at(i).end();it++){
      delete *it;
    }
    rois_v_tight.at(i).clear();
    for (auto it = rois_v_loose.at(i).begin(); it!=rois_v_loose.at(i).end();it++){
      delete *it;
    }
    rois_v_loose.at(i).clear();
  }

  for (int i=0;i!=nwire_w;i++){
    for (auto it = rois_w_tight.at(i).begin(); it!=rois_w_tight.at(i).end();it++){
      delete *it;
    }
    rois_w_tight.at(i).clear();
    for (auto it = rois_w_loose.at(i).begin(); it!=rois_w_loose.at(i).end();it++){
      delete *it;
    }
    rois_w_loose.at(i).clear();
  }
   
   front_rois.clear();
   back_rois.clear();
   contained_rois.clear();
   


}

void WCP2dToy::uBooNEDataAfterROI::CleanUpROIs(){
  // clean up ROIs
  std::map<SignalROI*, int> ROIsaved_map;
  //int counter = 0;
  for (int i=0;i!=rois_u_loose.size();i++){
    // counter += rois_u_loose.at(i).size();
    for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (ROIsaved_map.find(roi)==ROIsaved_map.end()){
     	if (contained_rois.find(roi) != contained_rois.end()){
	  // contain good stuff
	  SignalROISelection temp_rois;
	  temp_rois.push_back(roi);
	  ROIsaved_map[roi] = 1;
	  
	  while(temp_rois.size()){
	    SignalROI *temp_roi = temp_rois.back();
	    temp_rois.pop_back();
	    // save all its neighbour into a temporary holder
	    if (front_rois.find(temp_roi)!=front_rois.end()){
	      for (auto it1 = front_rois[temp_roi].begin();it1!=front_rois[temp_roi].end();it1++){
		if (ROIsaved_map.find(*it1)==ROIsaved_map.end()){
		  temp_rois.push_back(*it1);
		  ROIsaved_map[*it1] = 1;
		}
	      }
	    }
	    if (back_rois.find(temp_roi)!=back_rois.end()){
	      for (auto it1 = back_rois[temp_roi].begin();it1!=back_rois[temp_roi].end();it1++){
		if (ROIsaved_map.find(*it1)==ROIsaved_map.end()){
		  temp_rois.push_back(*it1);
		  ROIsaved_map[*it1] = 1;
		}
	      }
	    }
	  }
	}
      }
    }
  }

  //remove the bad ones ...
  //int counter2 = 0;
  for (int i=0;i!=rois_u_loose.size();i++){
    SignalROISelection to_be_removed;
    for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (ROIsaved_map.find(roi) == ROIsaved_map.end()){
	//	counter2 ++;
	to_be_removed.push_back(roi);
	//it = rois_u_loose.at(i).erase(it);
	// check contained map
	if (contained_rois.find(roi)!= contained_rois.end()){
	  std::cout << "Wrong! " << std::endl;
	}
	// check front map
	if (front_rois.find(roi)!=front_rois.end()){
	  for (auto it1 = front_rois[roi].begin(); it1 != front_rois[roi].end(); it1++){
	    auto it2 = find(back_rois[*it1].begin(),back_rois[*it1].end(),roi);
	    back_rois[*it1].erase(it2);
	  }
	  front_rois.erase(roi);
	}
	// check back map
	if (back_rois.find(roi)!=back_rois.end()){
	  for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	    auto it2 = find(front_rois[*it1].begin(),front_rois[*it1].end(),roi);
	    front_rois[*it1].erase(it2);
	  }
	  back_rois.erase(roi);
	}
      }
    }

    for (auto it = to_be_removed.begin(); it!= to_be_removed.end(); it++){
      auto it1 = find(rois_u_loose.at(i).begin(), rois_u_loose.at(i).end(),*it);
      rois_u_loose.at(i).erase(it1);
    }
  }


  // int counter = 0;
  for (int i=0;i!=rois_v_loose.size();i++){
    //  counter += rois_v_loose.at(i).size();
    for (auto it = rois_v_loose.at(i).begin(); it!= rois_v_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (ROIsaved_map.find(roi)==ROIsaved_map.end()){
     	if (contained_rois.find(roi) != contained_rois.end()){
	  // contain good stuff
	  SignalROISelection temp_rois;
	  temp_rois.push_back(roi);
	  ROIsaved_map[roi] = 1;
	  
	  while(temp_rois.size()){
	    SignalROI *temp_roi = temp_rois.back();
	    temp_rois.pop_back();
	    // save all its neighbour into a temporary holder
	    if (front_rois.find(temp_roi)!=front_rois.end()){
	      for (auto it1 = front_rois[temp_roi].begin();it1!=front_rois[temp_roi].end();it1++){
		if (ROIsaved_map.find(*it1)==ROIsaved_map.end()){
		  temp_rois.push_back(*it1);
		  ROIsaved_map[*it1] = 1;
		}
	      }
	    }
	    if (back_rois.find(temp_roi)!=back_rois.end()){
	      for (auto it1 = back_rois[temp_roi].begin();it1!=back_rois[temp_roi].end();it1++){
		if (ROIsaved_map.find(*it1)==ROIsaved_map.end()){
		  temp_rois.push_back(*it1);
		  ROIsaved_map[*it1] = 1;
		}
	      }
	    }
	  }
	}
      }
    }
  }

  //remove the bad ones ...
  //int counter2 = 0;
  for (int i=0;i!=rois_v_loose.size();i++){
    SignalROISelection to_be_removed;
    for (auto it = rois_v_loose.at(i).begin(); it!= rois_v_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (ROIsaved_map.find(roi) == ROIsaved_map.end()){
	//	counter2 ++;
	to_be_removed.push_back(roi);
	//it = rois_v_loose.at(i).erase(it);
	// check contained map
	if (contained_rois.find(roi)!= contained_rois.end()){
	  std::cout << "Wrong! " << std::endl;
	}
	// check front map
	if (front_rois.find(roi)!=front_rois.end()){
	  for (auto it1 = front_rois[roi].begin(); it1 != front_rois[roi].end(); it1++){
	    auto it2 = find(back_rois[*it1].begin(),back_rois[*it1].end(),roi);
	    back_rois[*it1].erase(it2);
	  }
	  front_rois.erase(roi);
	}
	// check back map
	if (back_rois.find(roi)!=back_rois.end()){
	  for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	    auto it2 = find(front_rois[*it1].begin(),front_rois[*it1].end(),roi);
	    front_rois[*it1].erase(it2);
	  }
	  back_rois.erase(roi);
	}
      }
    }

    for (auto it = to_be_removed.begin(); it!= to_be_removed.end(); it++){
      auto it1 = find(rois_v_loose.at(i).begin(), rois_v_loose.at(i).end(),*it);
      rois_v_loose.at(i).erase(it1);
    }
  }




  // int counter1 = 0;
  // for (int i=0;i!=rois_v_loose.size();i++){
  //   counter1+=rois_v_loose.at(i).size();
  // }
  
  // std::cout << counter << " " << ROIsaved_map.size() << " " << counter1 << " " << counter2 << std::endl;


}

void WCP2dToy::uBooNEDataAfterROI::CleanUpInductionROIs(){
  // deal with loose ROIs
  // focus on the isolated ones first
  float mean_threshold = 500;
  float threshold = 1000;
  
  
  std::list<SignalROI*> Bad_ROIs;
  for (int i=0;i!=nwire_u;i++){
    for (auto it = rois_u_loose.at(i).begin();it!=rois_u_loose.at(i).end();it++){
      SignalROI* roi = *it;
      if (front_rois.find(roi)==front_rois.end() && back_rois.find(roi)==back_rois.end()){
	if (roi->get_above_threshold(threshold).size()==0 && roi->get_average_heights() < mean_threshold)
	  Bad_ROIs.push_back(roi);
      }
    }
  }
  for (auto it = Bad_ROIs.begin(); it!=Bad_ROIs.end(); it ++){
    SignalROI* roi = *it;
    int chid = roi->get_chid();
    auto it1 = find(rois_u_loose.at(chid).begin(), rois_u_loose.at(chid).end(),roi);
    if (it1 != rois_u_loose.at(chid).end())
      rois_u_loose.at(chid).erase(it1);

    if (front_rois.find(roi)!=front_rois.end()){
      SignalROISelection next_rois = front_rois[roi];
      for (int i=0;i!=next_rois.size();i++){
   	//unlink the current roi
   	unlink(roi,next_rois.at(i));
      }
      front_rois.erase(roi);
    }
    
    if (back_rois.find(roi)!=back_rois.end()){
      SignalROISelection prev_rois = back_rois[roi];
      for (int i=0;i!=prev_rois.size();i++){
   	//unlink the current roi
   	unlink(prev_rois.at(i),roi);
      }
      back_rois.erase(roi);
    }
    
    
    delete roi;
  }
  Bad_ROIs.clear();
  for (int i=0;i!=nwire_v;i++){
    for (auto it = rois_v_loose.at(i).begin();it!=rois_v_loose.at(i).end();it++){
      SignalROI* roi = *it;
      if (front_rois.find(roi)==front_rois.end() && back_rois.find(roi)==back_rois.end()){
	if (roi->get_above_threshold(threshold).size()==0 && roi->get_average_heights() < mean_threshold)
	  Bad_ROIs.push_back(roi);
      }
    }
  }
  for (auto it = Bad_ROIs.begin(); it!=Bad_ROIs.end(); it ++){
    SignalROI* roi = *it;
    int chid = roi->get_chid()-nwire_u;
    auto it1 = find(rois_v_loose.at(chid).begin(), rois_v_loose.at(chid).end(),roi);
    if (it1 != rois_v_loose.at(chid).end())
      rois_v_loose.at(chid).erase(it1);

    if (front_rois.find(roi)!=front_rois.end()){
      SignalROISelection next_rois = front_rois[roi];
      for (int i=0;i!=next_rois.size();i++){
   	//unlink the current roi
   	unlink(roi,next_rois.at(i));
      }
      front_rois.erase(roi);
    }
    
    if (back_rois.find(roi)!=back_rois.end()){
      SignalROISelection prev_rois = back_rois[roi];
      for (int i=0;i!=prev_rois.size();i++){
   	//unlink the current roi
   	unlink(prev_rois.at(i),roi);
      }
      back_rois.erase(roi);
    }
    
    delete roi;
  }


  //  threshold = 1200;
  std::set<SignalROI*> Good_ROIs;
  for (int i=0;i!=nwire_u;i++){
    for (auto it = rois_u_loose.at(i).begin();it!=rois_u_loose.at(i).end();it++){
      SignalROI* roi = *it;
      if (roi->get_above_threshold(threshold).size()!=0 || roi->get_average_heights() > mean_threshold)
	Good_ROIs.insert(roi);
    }
  }
  Bad_ROIs.clear();
  for (int i=0;i!=nwire_u;i++){
    for (auto it = rois_u_loose.at(i).begin();it!=rois_u_loose.at(i).end();it++){
      SignalROI* roi = *it;
      
      if (Good_ROIs.find(roi)!=Good_ROIs.end()) continue;
      if (front_rois.find(roi)!=front_rois.end()){
	SignalROISelection next_rois = front_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      if (back_rois.find(roi)!=back_rois.end()){
	SignalROISelection next_rois = back_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      Bad_ROIs.push_back(roi);
    }
  }
  for (auto it = Bad_ROIs.begin(); it!=Bad_ROIs.end(); it ++){
    SignalROI* roi = *it;
    int chid = roi->get_chid();
    //std::cout << chid << std::endl;
    if (front_rois.find(roi)!=front_rois.end()){
      SignalROISelection next_rois = front_rois[roi];
      for (int i=0;i!=next_rois.size();i++){
   	//unlink the current roi
   	unlink(roi,next_rois.at(i));
      }
      front_rois.erase(roi);
    }
    
    if (back_rois.find(roi)!=back_rois.end()){
      SignalROISelection prev_rois = back_rois[roi];
      for (int i=0;i!=prev_rois.size();i++){
   	//unlink the current roi
   	unlink(prev_rois.at(i),roi);
      }
      back_rois.erase(roi);
    }
    auto it1 = find(rois_u_loose.at(chid).begin(), rois_u_loose.at(chid).end(),roi);
    if (it1 != rois_u_loose.at(chid).end())
      rois_u_loose.at(chid).erase(it1);
    
    delete roi;
  }


  Good_ROIs.clear();
  for (int i=0;i!=nwire_v;i++){
    for (auto it = rois_v_loose.at(i).begin();it!=rois_v_loose.at(i).end();it++){
      SignalROI* roi = *it;
      if (roi->get_above_threshold(threshold).size()!=0)
	Good_ROIs.insert(roi);
    }
  }
  Bad_ROIs.clear();
  for (int i=0;i!=nwire_v;i++){
    for (auto it = rois_v_loose.at(i).begin();it!=rois_v_loose.at(i).end();it++){
      SignalROI* roi = *it;
      
      if (Good_ROIs.find(roi)!=Good_ROIs.end()) continue;
      if (front_rois.find(roi)!=front_rois.end()){
	SignalROISelection next_rois = front_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      if (back_rois.find(roi)!=back_rois.end()){
	SignalROISelection next_rois = back_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      Bad_ROIs.push_back(roi);
    }
  }
  for (auto it = Bad_ROIs.begin(); it!=Bad_ROIs.end(); it ++){
    SignalROI* roi = *it;
    int chid = roi->get_chid()-nwire_u;
    //std::cout << chid << std::endl;
    if (front_rois.find(roi)!=front_rois.end()){
      SignalROISelection next_rois = front_rois[roi];
      for (int i=0;i!=next_rois.size();i++){
   	//unlink the current roi
   	unlink(roi,next_rois.at(i));
      }
      front_rois.erase(roi);
    }
    
    if (back_rois.find(roi)!=back_rois.end()){
      SignalROISelection prev_rois = back_rois[roi];
      for (int i=0;i!=prev_rois.size();i++){
   	//unlink the current roi
   	unlink(prev_rois.at(i),roi);
      }
      back_rois.erase(roi);
    }
    auto it1 = find(rois_v_loose.at(chid).begin(), rois_v_loose.at(chid).end(),roi);
    if (it1 != rois_v_loose.at(chid).end())
      rois_v_loose.at(chid).erase(it1);
    
    delete roi;
  }

}


void WCP2dToy::uBooNEDataAfterROI::CleanUpCollectionROIs(){
  // deal with tight ROIs, 
  // scan with all the tight ROIs to look for peaks above certain threshold, put in a temporary set
  float mean_threshold = 500; //electrons
  float threshold = 1000; //electrons, about 1/2 of MIP per tick ...
  
  std::set<SignalROI*> Good_ROIs;
  for (int i=0;i!=nwire_w;i++){
    for (auto it = rois_w_tight.at(i).begin();it!=rois_w_tight.at(i).end();it++){
      SignalROI* roi = *it;
      if (roi->get_above_threshold(threshold).size()!=0 || roi->get_average_heights() > mean_threshold)
	Good_ROIs.insert(roi);
    }
  }
  
  // for a particular ROI if it is not in, or it is not connected with one in the temporary map, then remove it
  std::list<SignalROI*> Bad_ROIs;
  for (int i=0;i!=nwire_w;i++){
    for (auto it = rois_w_tight.at(i).begin();it!=rois_w_tight.at(i).end();it++){
      SignalROI* roi = *it;
      
      if (Good_ROIs.find(roi)!=Good_ROIs.end()) continue;
      if (front_rois.find(roi)!=front_rois.end()){
	SignalROISelection next_rois = front_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      if (back_rois.find(roi)!=back_rois.end()){
	SignalROISelection next_rois = back_rois[roi];
	int flag_qx = 0;
	for (int i=0;i!=next_rois.size();i++){
	  SignalROI* roi1 = next_rois.at(i);
	  if (Good_ROIs.find(roi1)!=Good_ROIs.end()) {
	    flag_qx = 1;
	    continue;
	  }
	}
	if (flag_qx == 1) continue;
      }
      
      Bad_ROIs.push_back(roi);
    }
  }
  
  // remove the ROI and then update the map
  
  for (auto it = Bad_ROIs.begin(); it!=Bad_ROIs.end(); it ++){
    SignalROI* roi = *it;
    int chid = roi->get_chid()-nwire_u-nwire_v;
    //std::cout << chid << std::endl;
    if (front_rois.find(roi)!=front_rois.end()){
      SignalROISelection next_rois = front_rois[roi];
      for (int i=0;i!=next_rois.size();i++){
   	//unlink the current roi
   	unlink(roi,next_rois.at(i));
      }
      front_rois.erase(roi);
    }
  
    if (back_rois.find(roi)!=back_rois.end()){
      SignalROISelection prev_rois = back_rois[roi];
      for (int i=0;i!=prev_rois.size();i++){
   	//unlink the current roi
   	unlink(prev_rois.at(i),roi);
      }
      back_rois.erase(roi);
    }
    auto it1 = find(rois_w_tight.at(chid).begin(), rois_w_tight.at(chid).end(),roi);
    if (it1 != rois_w_tight.at(chid).end())
      rois_w_tight.at(chid).erase(it1);
    
    delete roi;
  }
  
}


void WCP2dToy::uBooNEDataAfterROI::BreakROI1(SignalROI* roi){
  int start_bin = roi->get_start_bin();
  int end_bin = roi->get_end_bin();
  
  if (start_bin <0 || end_bin < 0) return;

  TH1F *htemp = new TH1F("htemp","htemp",end_bin-start_bin+1,start_bin,end_bin+1);
  std::vector<float>& contents = roi->get_contents();
  for (Int_t i=0;i!=htemp->GetNbinsX();i++){
    htemp->SetBinContent(i+1,contents.at(i));
  }

   // now create many new ROIs
   std::vector<int> bins;
   for (int i=0;i!=htemp->GetNbinsX();i++){
     if (fabs(htemp->GetBinContent(i+1))<1e-3)
       bins.push_back(i+start_bin);
   }
   int chid = roi->get_chid();
   WirePlaneType_t plane = roi->get_plane();
   SignalROISelection new_rois;

   // if (chid == 1274)
   //   std::cout << "BreakROI1: " << chid << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << bins.size()  << " " << htemp->GetBinContent(1) << " " << htemp->GetBinContent(end_bin-start_bin+1) << std::endl;
   
   TH1F *h1 = new TH1F("h1","h1",end_bin+1,0,end_bin+1);
   for (int i=0;i!=int(bins.size()-1);i++){
     int start_bin1 = bins.at(i);
     int end_bin1 = bins.at(i+1);
     // if (chid == 1274)
     //   std::cout << start_bin1 << " " << end_bin1 << std::endl;
     h1->Reset();
     for (int j=start_bin1;j<=end_bin1;j++){
       h1->SetBinContent(j+1,htemp->GetBinContent(j-start_bin+1));
     }
     if (start_bin1 >=0 && end_bin1 >start_bin1){
       SignalROI *sub_roi = new SignalROI(plane,chid,start_bin1,end_bin1,h1);
       new_rois.push_back(sub_roi);
     }
   }

   // update the list 
   if (chid < nwire_u){
     auto it = find(rois_u_loose.at(chid).begin(),rois_u_loose.at(chid).end(),roi);
     rois_u_loose.at(chid).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_u_loose.at(chid).push_back(new_rois.at(i));
     }
   }else if (chid < nwire_u+nwire_v){
     auto it = find(rois_v_loose.at(chid-nwire_u).begin(),rois_v_loose.at(chid-nwire_u).end(),roi);
     rois_v_loose.at(chid-nwire_u).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_v_loose.at(chid-nwire_u).push_back(new_rois.at(i));
     }
   }else{
     auto it = find(rois_w_loose.at(chid-nwire_u-nwire_v).begin(),rois_w_loose.at(chid-nwire_u-nwire_v).end(),roi);
     rois_w_loose.at(chid-nwire_u-nwire_v).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_w_loose.at(chid-nwire_u-nwire_v).push_back(new_rois.at(i));
     } 
   }

   // update all the maps 
   // update front map
   if (front_rois.find(roi)!=front_rois.end()){
     SignalROISelection next_rois = front_rois[roi];
     for (int i=0;i!=next_rois.size();i++){
       //unlink the current roi
       unlink(roi,next_rois.at(i));
       //loop new rois and link them
       for (int j=0;j!=new_rois.size();j++){
   	 if (new_rois.at(j)->overlap(next_rois.at(i)))
   	   link(new_rois.at(j),next_rois.at(i));
       }
     }
     front_rois.erase(roi);
   }
   // update back map
   if (back_rois.find(roi)!=back_rois.end()){
     SignalROISelection prev_rois = back_rois[roi];
     for (int i=0;i!=prev_rois.size();i++){
       // unlink the current roi
       unlink(prev_rois.at(i),roi);
       // loop new rois and link them
       for (int j=0;j!=new_rois.size();j++){
   	 if (new_rois.at(j)->overlap(prev_rois.at(i)))
   	   link(prev_rois.at(i),new_rois.at(j));
       }
     }
     back_rois.erase(roi);
   }

   // update contained map 
   if (contained_rois.find(roi)!=contained_rois.end()){
     SignalROISelection tight_rois = contained_rois[roi];
     for (int i=0;i!=tight_rois.size();i++){
       for (int j=0;j!=new_rois.size();j++){
       	 if (new_rois.at(j)->overlap(tight_rois.at(i))){
   	   if (contained_rois.find(new_rois.at(j)) == contained_rois.end()){
   	     SignalROISelection temp_rois;
   	     temp_rois.push_back(tight_rois.at(i));
   	     contained_rois[new_rois.at(j)] = temp_rois;
   	   }else{
   	     contained_rois[new_rois.at(j)].push_back(tight_rois.at(i));
   	   }
   	 }
       }
     }
     contained_rois.erase(roi);
   }
   
   // delete the old ROI
   delete roi;
   delete h1;
   delete htemp;

}

void WCP2dToy::uBooNEDataAfterROI::BreakROI(SignalROI* roi, float rms){
  // main algorithm 
  int start_bin = roi->get_start_bin();
  int end_bin = roi->get_end_bin();
  
  if (start_bin <0 || end_bin <0 ) return;
  
  // if (roi->get_chid()==1240){
  //   std::cout << "xin: " << start_bin << " " << end_bin << std::endl;
  // }

  TH1F *htemp = new TH1F("htemp","htemp",end_bin-start_bin+1,start_bin,end_bin+1);
  std::vector<float>& contents = roi->get_contents();
  for (Int_t i=0;i!=htemp->GetNbinsX();i++){
    htemp->SetBinContent(i+1,contents.at(i));
  }
  TSpectrum *s = new TSpectrum(200);
  Int_t nfound = s->Search(htemp,2,"nobackground new",0.1);
  float th_peak = 3.0;
  float sep_peak = 6.0;

  float low_peak_sep_threshold = 1200; // electrons
  
  if (low_peak_sep_threshold < sep_peak * rms) 
    low_peak_sep_threshold = sep_peak * rms;

  std::set<int> saved_boundaries;

  if (nfound > 1){
    Int_t npeaks = s->GetNPeaks();
    Double_t *peak_pos = s->GetPositionX();
    Double_t *peak_height = s->GetPositionY();
    int order_peak_pos[205];
    int npeaks_threshold = 0;
    for (Int_t j=0;j!=npeaks;j++){
      order_peak_pos[j] = *(peak_pos+j);
      if (*(peak_height+j)>th_peak*rms){
	npeaks_threshold ++;
      }
    }
    if (npeaks_threshold >1){
      std::sort(order_peak_pos,order_peak_pos + npeaks);
      float valley_pos[205];
      valley_pos[0] = start_bin;

      // find the first real valley
      float min = 1e9;
      for (int k=0; k< order_peak_pos[0]-start_bin;k++){
       	if (htemp->GetBinContent(k+1) < min){
       	  min = htemp->GetBinContent(k+1);
	  valley_pos[0] = k+start_bin;
       	}
      }
      if (valley_pos[0] != start_bin){
	for (int j=npeaks-1;j>=0;j--){
	  order_peak_pos[j+1] = order_peak_pos[j];
	}
	npeaks ++;
	order_peak_pos[0] = start_bin;
	for (int j=start_bin; j!=valley_pos[0];j++){
	  if (htemp->GetBinContent(j-start_bin+1) > htemp->GetBinContent(order_peak_pos[0]-start_bin+1))
	    order_peak_pos[0] = j;
	}
	valley_pos[0] = start_bin;
      }

      for (Int_t j=0;j!=npeaks-1;j++){
	Float_t min = 1e9;
	valley_pos[j+1] = order_peak_pos[j];
	for (Int_t k = order_peak_pos[j]-start_bin; k< order_peak_pos[j+1]-start_bin;k++){
	  if (htemp->GetBinContent(k+1) < min){
	    min = htemp->GetBinContent(k+1);
	    valley_pos[j+1] = k+start_bin;
	  }
	}
      }

      //find the end ... 
      valley_pos[npeaks] = end_bin;
      min = 1e9;
      for (int k=order_peak_pos[npeaks-1]-start_bin; k<= end_bin-start_bin;k++){
      	if (htemp->GetBinContent(k+1) < min){
      	  min = htemp->GetBinContent(k+1);
      	  valley_pos[npeaks] = k+start_bin;
      	}
      }
      if (valley_pos[npeaks]!=end_bin){
	npeaks ++;
	valley_pos[npeaks] = end_bin;
	order_peak_pos[npeaks-1] = end_bin;
	for (int j=valley_pos[npeaks-1];j!=valley_pos[npeaks];j++){
	  if (htemp->GetBinContent(j-start_bin+1) > htemp->GetBinContent(order_peak_pos[npeaks-1] -start_bin+1))
	    order_peak_pos[npeaks-1] = j;
	}
      }
      
      
      // if (roi->get_chid() == 1195 && roi->get_plane() == WirePlaneType_t(0)){
      // 	for (int j=0;j!=npeaks;j++){
      // 	  std::cout << valley_pos[j] << " " << htemp->GetBinContent(valley_pos[j]-start_bin+1)<< " " << order_peak_pos[j] << " " << htemp->GetBinContent( order_peak_pos[j]-start_bin+1) << " " << valley_pos[j+1] << " " << htemp->GetBinContent(valley_pos[j+1] - start_bin+1)<< " " << rms * sep_peak << std::endl ;
      // 	}
      // }
	

      
      // need to organize the peaks and valleys ... 
      float valley_pos1[205];
      float peak_pos1[205];
      int npeaks1 = 0;
      // fill in the first valley;
      valley_pos1[0] = valley_pos[0];
      for (int j=0;j<npeaks;j++){
	if (npeaks1 >0){
	  // find the lowest valley except the first peak, except the first one
	  if (htemp->GetBinContent(valley_pos[j]-start_bin+1)< htemp->GetBinContent(valley_pos1[npeaks1]-start_bin+1)){
	    valley_pos1[npeaks1] = valley_pos[j];
	  }
	}

	// if (roi->get_chid() == 1195 && roi->get_plane() == WirePlaneType_t(0)){
	//   std::cout << "c: " << order_peak_pos[j] << " " << htemp->GetBinContent(order_peak_pos[j]-start_bin+1) << " " << valley_pos1[npeaks1] << " " << htemp->GetBinContent(valley_pos1[npeaks1]-start_bin+1) << std::endl;
	// }

	// find the next peak
	if ( htemp->GetBinContent(order_peak_pos[j]-start_bin+1) - htemp->GetBinContent(valley_pos1[npeaks1]-start_bin+1) > low_peak_sep_threshold){
	  peak_pos1[npeaks1] = order_peak_pos[j] ;
	  npeaks1 ++;
	  int flag1 = 0;

	  for (int k=j+1;k!=npeaks+1;k++){
	    // find the highest peak before ... 
	    if (k<=npeaks){
	      if (htemp->GetBinContent(order_peak_pos[k-1]-start_bin+1) > htemp->GetBinContent(peak_pos1[npeaks1-1]-start_bin+1))
		peak_pos1[npeaks1-1] = order_peak_pos[k-1];
	    }

	    if (htemp->GetBinContent(peak_pos1[npeaks1-1]-start_bin+1) - htemp->GetBinContent(valley_pos[k]-start_bin+1) > low_peak_sep_threshold){
	      valley_pos1[npeaks1] = valley_pos[k];
	      j = k-1;
	      flag1 = 1;
	      break;
	    }
	    // find the next valley
	  }
	  if (flag1 == 0){
	    valley_pos1[npeaks1] = valley_pos[npeaks];
	    j = npeaks;
	  }

	  // if (roi->get_chid() == 1240 && roi->get_plane() == WirePlaneType_t(0))
	  //   std::cout << "c: " << npeaks << " " << valley_pos1[npeaks1-1] << " " << peak_pos1[npeaks1-1] << " " << valley_pos1[npeaks1] << " " << rms * sep_peak << std::endl;
	}
      }
      // fill the last valley
      valley_pos1[npeaks1] = valley_pos[npeaks];
      //std::cout << roi->get_plane() << " " << roi->get_chid() << " " << npeaks << " " << npeaks1 << " " ;
      //std::cout << start_bin << " " << end_bin << std::endl;


      // if (roi->get_chid() == 1240 && roi->get_plane() == WirePlaneType_t(0)){
      //  	for (int j=0;j!=npeaks1;j++){
      //  	  std::cout << valley_pos1[j] << " " << peak_pos1[j] << " " <<  valley_pos1[j+1] << std::endl ;
      //  	}
      // }


     

      for (Int_t j=0;j!=npeaks1;j++){
	Int_t start_pos = valley_pos1[j];
	Int_t end_pos = valley_pos1[j+1];
	
	// if (roi->get_chid()==1195)
	//   std::cout << "b " << start_pos << " " << end_pos << std::endl;
	
	saved_boundaries.insert(start_pos);
	saved_boundaries.insert(end_pos);
      }
            
      TH1F *htemp1 = (TH1F*)htemp->Clone("htemp1");
      htemp->Reset();
      for (Int_t j=0;j!=npeaks1;j++){
	int flag = 0;
	Int_t start_pos = valley_pos1[j];
	Double_t start_content = htemp1->GetBinContent(valley_pos1[j]-start_bin+1);
	Int_t end_pos = valley_pos1[j+1];
	Double_t end_content = htemp1->GetBinContent(valley_pos1[j+1]-start_bin+1);
	
	//	std::cout << "a " << start_pos << " " << end_pos << std::endl;

	if (saved_boundaries.find(start_pos) != saved_boundaries.end() ||
	    saved_boundaries.find(end_pos) != saved_boundaries.end()){
	  // if (roi->get_chid() == 1240 && roi->get_plane() == WirePlaneType_t(0))
	  //   std::cout << "d: " << start_pos << " " << end_pos << std::endl;

	  for (Int_t k = start_pos; k!=end_pos+1;k++){
	    Double_t temp_content = htemp1->GetBinContent(k-start_bin+1) - (start_content + (end_content-start_content) * (k-start_pos) / (end_pos - start_pos));
	    htemp->SetBinContent(k-start_bin+1,temp_content);
	  }
	}
      }
      delete htemp1;

      // loop through the tight ROIs it contains ...
      // if nothing in the range, add things back ... 
      // if (roi->get_chid() == 1151){
      //  	std::cout << "Break:  "  << roi->get_chid() << " " << start_bin << " " << end_bin << " " << nfound << std::endl;
      //  	std::cout << npeaks1 << std::endl;
      // 	std::cout << contained_rois[roi].size() << std::endl;
      
      for (auto it = contained_rois[roi].begin(); it!= contained_rois[roi].end(); it++){
	SignalROI *temp_roi = *it;
	int temp_flag = 0;
	for (int i=temp_roi->get_start_bin(); i<= temp_roi->get_end_bin(); i++){
	  if (htemp->GetBinContent(i-roi->get_start_bin()+1)!=0){
	    temp_flag = 1;
	    break;
	  }
	}
	//	std::cout << temp_flag << std::endl;
	if (temp_flag==0){
	  for (int i=temp_roi->get_start_bin(); i<= temp_roi->get_end_bin(); i++){
	    htemp->SetBinContent(i-roi->get_start_bin()+1, temp_roi->get_contents().at(i-temp_roi->get_start_bin()));
	  }
	}
	
      }
      // } // if (1151)

    }
  }
  
  
  // if (roi->get_chid() == 1151){
  //   std::cout << "Break:  "  << roi->get_chid() << " " << start_bin << " " << end_bin << " " << nfound << std::endl;
  //   for (int i=0;i<htemp->GetNbinsX();i++){
  //     std::cout << htemp->GetBinContent(i+1) <<std::endl;
  //   }
  // }

  for (int qx = 0; qx!=2; qx++){
    // Now we should go through the system again and re-adjust the content
    std::vector<std::pair<int,int>> bins;
    for (int i=0;i<htemp->GetNbinsX();i++){
      if (htemp->GetBinContent(i+1) < 3*rms){
	int start = i;
	int end = i;
	for (int j=i+1;j<htemp->GetNbinsX();j++){
	  if (htemp->GetBinContent(j+1) < 3*rms){
	    end = j;
	  }else{
	    break;
	  }
	}
	bins.push_back(std::make_pair(start,end));
	 // if (roi->get_chid() == 1240)
	 //   std::cout << qx << " " <<  start+start_bin << " " << end + start_bin << " " << 3*rms << std::endl;
	i = end;
      }
    }


    std::vector<int> saved_b;
    for (int i=0;i!=bins.size();i++){
      int start = bins.at(i).first;
      int end = bins.at(i).second;
      // find minimum or zero
      float min = 1e9;
      int bin_min = start;
      for (int j=start;j<=end;j++){
	if (fabs(htemp->GetBinContent(j+1))< 1e-3){
	  bin_min = j;
	  break;
	}else{
	  if (htemp->GetBinContent(j+1) < min){
	    min = htemp->GetBinContent(j+1);
	    bin_min = j;
	  }
	}
      }
      
      // if (roi->get_chid() == 1308)
      // 	std::cout << bin_min+start_bin << std::endl;
      
      saved_b.push_back(bin_min);
    }

    // test
    
    if (saved_b.size() >=0){
      TH1F *htemp1 = (TH1F*)htemp->Clone("htemp1");
      htemp->Reset();
      // std::cout << saved_b.size() << " " << bins.size() << " " << htemp->GetNbinsX() << std::endl;
      for (Int_t j=0;j<int(saved_b.size()-1);j++){
	// if (j==0)
	//   std::cout << saved_b.size() << " " << j << std::endl;

	
	int flag = 0;
	int start_pos = saved_b.at(j);
	float start_content = htemp1->GetBinContent(start_pos+1);
	int end_pos = saved_b.at(j+1);
	float end_content = htemp1->GetBinContent(end_pos+1);
	
	for (Int_t k = start_pos; k!=end_pos+1;k++){
	  Double_t temp_content = htemp1->GetBinContent(k+1) - (start_content + (end_content-start_content) * (k-start_pos) / (end_pos - start_pos));
	  htemp->SetBinContent(k+1,temp_content);
	}
      }
      delete htemp1;
    }
  }

  // get back to the original content 
  for (Int_t i=0;i!=htemp->GetNbinsX();i++){
    contents.at(i) = htemp->GetBinContent(i+1);
  }
  
  



   delete s;
   delete htemp;
   

}

void WCP2dToy::uBooNEDataAfterROI::unlink(SignalROI* prev_roi, SignalROI* next_roi){
  if (front_rois.find(prev_roi)!=front_rois.end()){
    SignalROISelection& temp_rois = front_rois[prev_roi];
    auto it = find(temp_rois.begin(),temp_rois.end(),next_roi);
    if (it != temp_rois.end())
      temp_rois.erase(it);
  }
  if (back_rois.find(next_roi)!=back_rois.end()){
    SignalROISelection& temp_rois = back_rois[next_roi];
    auto it = find(temp_rois.begin(),temp_rois.end(),prev_roi);
    if (it != temp_rois.end())
      temp_rois.erase(it);
  }
}

void WCP2dToy::uBooNEDataAfterROI::link(SignalROI* prev_roi, SignalROI* next_roi){
  if (front_rois.find(prev_roi)!=front_rois.end()){
    SignalROISelection& temp_rois = front_rois[prev_roi];
    auto it = find(temp_rois.begin(),temp_rois.end(),next_roi);
    if (it == temp_rois.end())
      temp_rois.push_back(next_roi);
  }else{
    SignalROISelection temp_rois;
    temp_rois.push_back(next_roi);
    front_rois[prev_roi] = temp_rois;
  }

  if (back_rois.find(next_roi)!=back_rois.end()){
    SignalROISelection& temp_rois = back_rois[next_roi];
    auto it = find(temp_rois.begin(),temp_rois.end(),prev_roi);
    if (it == temp_rois.end())
      temp_rois.push_back(prev_roi);
  }else{
    SignalROISelection temp_rois;
    temp_rois.push_back(prev_roi);
    back_rois[next_roi] = temp_rois;
  }
}


void WCP2dToy::uBooNEDataAfterROI::BreakROIs(){
  // get RMS value, and put in 
  std::vector<float>& rms_u = rois.get_uplane_rms();
  std::vector<float>& rms_v = rois.get_vplane_rms();

  SignalROISelection all_rois;

  for (int i=0;i!=rois_u_loose.size();i++){
    for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end(); it++){
      BreakROI(*it,rms_u.at(i));
      all_rois.push_back(*it);
      
    }
  }
  
  for (int i=0;i!=rois_v_loose.size();i++){
    for (auto it = rois_v_loose.at(i).begin(); it!= rois_v_loose.at(i).end(); it++){
      BreakROI(*it,rms_v.at(i));
      all_rois.push_back(*it);
    }
  }



  for (int i=0;i!=all_rois.size();i++){
    // if (all_rois.at(i)->get_chid()==1151){
    //   std::cout << all_rois.at(i)->get_chid() << " " << all_rois.at(i)->get_start_bin() << " " << all_rois.at(i)->get_end_bin() << std::endl;
    //   for (int j=0;j!=all_rois.at(i)->get_contents().size();j++){
    // 	std::cout << j << " " << all_rois.at(i)->get_contents().at(j) << std::endl;  
    //   }
    // }

    BreakROI1(all_rois.at(i));
  }

  

  // int num_tight[3]={0,0,0};
  // int num_loose[3]={0,0,0};
  // for (int i=0;i!=nwire_u;i++){
  //   num_tight[0] += rois_u_tight.at(i).size();
  //   num_loose[0] += rois_u_loose.at(i).size();
  // }
  // for (int i=0;i!=nwire_v;i++){
  //   num_tight[1] += rois_v_tight.at(i).size();
  //   num_loose[1] += rois_v_loose.at(i).size();
  // }
  // for (int i=0;i!=nwire_w;i++){
  //   num_tight[2] += rois_w_tight.at(i).size();
  //   num_loose[2] += rois_w_loose.at(i).size();
  // }

  // std::cout << num_tight[0] << " " << num_tight[1] << " " << num_tight[2] << " " << num_loose[0] << " " << num_loose[1] << " " << num_loose[2] << " " << front_rois.size() << " " << back_rois.size() << " " << contained_rois.size() << std::endl;
}

void WCP2dToy::uBooNEDataAfterROI::ShrinkROI(SignalROI *roi){
  
  // get tight ROI as a inner boundary
  // get the nearby ROIs with threshold as some sort of boundary 
  int start_bin = roi->get_start_bin();
  int end_bin = roi->get_end_bin();

  if (start_bin <0 || end_bin <0) return;
  
  int chid = roi->get_chid();
  WirePlaneType_t plane = roi->get_plane();
  std::vector<float>& contents = roi->get_contents();
  
  float threshold1;
  if (chid < nwire_u){
    threshold1 = rois.get_uplane_rms().at(chid) * 3.0;
  }else if (chid<nwire_u+nwire_v){
    threshold1 = rois.get_vplane_rms().at(chid-nwire_u)*3.0;
  }
  
  int channel_save = 1240;
  int print_flag = 0;

  // std::cout << "check tight ROIs " << std::endl;
  // use to save contents 
  TH1F *htemp = new TH1F("htemp","htemp",end_bin-start_bin+1,start_bin,end_bin+1);
  // check tight ROIs
  if (contained_rois.find(roi)!=contained_rois.end()){
    for (auto it = contained_rois[roi].begin();it!=contained_rois[roi].end();it++){
      SignalROI *tight_roi = *it;
      int start_bin1 = tight_roi->get_start_bin();
      int end_bin1 = tight_roi->get_end_bin();
      
      if (chid == channel_save && print_flag)
	std::cout << "Tight "  " " << start_bin1 << " " << end_bin1 << std::endl;

      for (int i=start_bin1;i<=end_bin1;i++){
	if (i-start_bin >=0 && i-start_bin <=htemp->GetNbinsX()){
	  htemp->SetBinContent(i-start_bin+1,1);
	}
      }
    }
  }

  // std::cout << "check front ROIs " << std::endl;

  //check front ROIs
  if (front_rois.find(roi)!=front_rois.end()){
    for (auto it=front_rois[roi].begin();it!=front_rois[roi].end();it++){
      SignalROI *next_roi = *it;
      int start_bin1 = next_roi->get_start_bin();
      int chid1 = next_roi->get_chid();
      WirePlaneType_t plane1 = next_roi->get_plane();
      float threshold;
      if (chid1 < nwire_u){
	threshold = rois.get_uplane_rms().at(chid1) * 3.0;
      }else if (chid1<nwire_u+nwire_v){
	threshold = rois.get_vplane_rms().at(chid1-nwire_u)*3.0;
      }
      std::vector<std::pair<int,int>> contents_above_threshold = next_roi->get_above_threshold(threshold);
      for (int i=0;i!=contents_above_threshold.size();i++){
	if (chid == channel_save && print_flag)
	  std::cout << "Front " << chid1 << " " << start_bin1 + contents_above_threshold.at(i).first << " " << start_bin1 + contents_above_threshold.at(i).second << std::endl;

	for (int j=contents_above_threshold.at(i).first;j<=contents_above_threshold.at(i).second;j++){
	  if (j+start_bin1-start_bin >=0 && j+start_bin1-start_bin <htemp->GetNbinsX()){
	    if (contents.at(j+start_bin1-start_bin) > threshold1) htemp->SetBinContent(j+start_bin1-start_bin+1,1);
	  }
	}
      }
    }
  }
  
  //std::cout << "check back ROIs " << std::endl;

  //check back ROIs
  if (back_rois.find(roi)!=back_rois.end()){
    for (auto it=back_rois[roi].begin();it!=back_rois[roi].end();it++){
      SignalROI *prev_roi = *it;
      int start_bin1 = prev_roi->get_start_bin();
      int chid1 = prev_roi->get_chid();
      WirePlaneType_t plane1 = prev_roi->get_plane();
      float threshold;
      if (chid1 < nwire_u){
	threshold = rois.get_uplane_rms().at(chid1) * 3.0;
      }else if (chid1<nwire_u+nwire_v){
	threshold = rois.get_vplane_rms().at(chid1-nwire_u)*3.0;
      }
      std::vector<std::pair<int,int>> contents_above_threshold = prev_roi->get_above_threshold(threshold);
      for (int i=0;i!=contents_above_threshold.size();i++){
	 if (chid == channel_save && print_flag)
	   std::cout << "Back " << chid1 << " " << start_bin1 + contents_above_threshold.at(i).first << " " << start_bin1 + contents_above_threshold.at(i).second << std::endl;

	for (int j=contents_above_threshold.at(i).first;j<=contents_above_threshold.at(i).second;j++){
	  if (j+start_bin1-start_bin >=0 && j+start_bin1-start_bin <htemp->GetNbinsX()){
	    if (contents.at(j+start_bin1-start_bin) > threshold1)  htemp->SetBinContent(j+start_bin1-start_bin+1,1);
	  }
	}
      }
    }
  }

  //std::cout << "check contents " << std::endl;

  // // consider the 1/2 of the peak as threshold;
  // float max = 0;
  // for (int i=0;i!=contents.size();i++){
  //   if (contents.at(i) > max)
  //     max = contents.at(i);
  // }
  // for (int i=0;i!=contents.size();i++){
  //   // if (contents.at(i) > max/2. && contents.at(i) > threshold1*2 ) htemp->SetBinContent(i+1,1);
  // }
  
  // get the first bin, and last bin, add pad
  int pad = 5;
  int new_start_bin=start_bin;
  int new_end_bin=end_bin;
  for (int i=0;i!=htemp->GetNbinsX();i++){
    if (htemp->GetBinContent(i+1) >0){
      new_start_bin = i + start_bin;
      break;
    }
  }
  for (int i = htemp->GetNbinsX()-1; i>=0;i--){
    if (htemp->GetBinContent(i+1)>0){
      new_end_bin = i + start_bin;
      break;
    }
  }
  new_start_bin -= pad;
  new_end_bin += pad;
  if (new_start_bin < start_bin) new_start_bin = start_bin;
  if (new_end_bin > end_bin) new_end_bin = end_bin;
  
  if (chid == channel_save && print_flag)
    std::cout << "check contents " << " " << start_bin << " " << end_bin << " " << new_start_bin << " " << new_end_bin << std::endl;
  

  // create a new ROI
  TH1F *h1 = new TH1F("h1","h1",end_bin+1,0,end_bin+1);
  for (int i=new_start_bin; i<=new_end_bin;i++){
    h1->SetBinContent(i+1,contents.at(i-start_bin));
  }
  
  SignalROISelection new_rois;
  if (new_start_bin >=0 && new_end_bin > new_start_bin){
    SignalROI *new_roi = new SignalROI(plane,chid,new_start_bin,new_end_bin,h1);
    new_rois.push_back(new_roi);
  }

  // std::cout << "update maps " << std::endl;
  
   // update the list 
   if (chid < nwire_u){
     auto it = find(rois_u_loose.at(chid).begin(),rois_u_loose.at(chid).end(),roi);
     rois_u_loose.at(chid).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_u_loose.at(chid).push_back(new_rois.at(i));
     }
   }else if (chid < nwire_u+nwire_v){
     auto it = find(rois_v_loose.at(chid-nwire_u).begin(),rois_v_loose.at(chid-nwire_u).end(),roi);
     rois_v_loose.at(chid-nwire_u).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_v_loose.at(chid-nwire_u).push_back(new_rois.at(i));
     }
   }else{
     auto it = find(rois_w_loose.at(chid-nwire_u-nwire_v).begin(),rois_w_loose.at(chid-nwire_u-nwire_v).end(),roi);
     rois_w_loose.at(chid-nwire_u-nwire_v).erase(it);
     for (int i=0;i!=new_rois.size();i++){
       rois_w_loose.at(chid-nwire_u-nwire_v).push_back(new_rois.at(i));
     } 
   }

   // update all the maps 
   // update front map
   if (front_rois.find(roi)!=front_rois.end()){
     SignalROISelection next_rois = front_rois[roi];
     for (int i=0;i!=next_rois.size();i++){
       //unlink the current roi
       unlink(roi,next_rois.at(i));
       //loop new rois and link them
       for (int j=0;j!=new_rois.size();j++){
	 if (new_rois.at(j)->overlap(next_rois.at(i)))
	   link(new_rois.at(j),next_rois.at(i));
       }
     }
     front_rois.erase(roi);
   }
   // update back map
   if (back_rois.find(roi)!=back_rois.end()){
     SignalROISelection prev_rois = back_rois[roi];
     for (int i=0;i!=prev_rois.size();i++){
       // unlink the current roi
       unlink(prev_rois.at(i),roi);
       // loop new rois and link them
       for (int j=0;j!=new_rois.size();j++){
	 if (new_rois.at(j)->overlap(prev_rois.at(i)))
	   link(prev_rois.at(i),new_rois.at(j));
       }
     }
     back_rois.erase(roi);
   }

   // update contained map 
   if (contained_rois.find(roi)!=contained_rois.end()){
     SignalROISelection tight_rois = contained_rois[roi];
     for (int i=0;i!=tight_rois.size();i++){
       for (int j=0;j!=new_rois.size();j++){
	 if (new_rois.at(j)->overlap(tight_rois.at(i))){
	   if (contained_rois.find(new_rois.at(j)) == contained_rois.end()){
	     SignalROISelection temp_rois;
	     temp_rois.push_back(tight_rois.at(i));
	     contained_rois[new_rois.at(j)] = temp_rois;
	   }else{
	     contained_rois[new_rois.at(j)].push_back(tight_rois.at(i));
	   }
	 }
       }
     }
     contained_rois.erase(roi);
   }
   
   // delete the old ROI
   delete roi;

  delete htemp;
  delete h1;
  
}

void WCP2dToy::uBooNEDataAfterROI::ShrinkROIs(){
  // collect all ROIs
  SignalROISelection all_rois;
  for (int i=0;i!=rois_u_loose.size();i++){
    for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end(); it++){
      all_rois.push_back(*it);
    }
  }  
  for (int i=0;i!=rois_v_loose.size();i++){
    for (auto it = rois_v_loose.at(i).begin(); it!= rois_v_loose.at(i).end(); it++){
      all_rois.push_back(*it);
    }
  }
  for (int i=0;i!=all_rois.size();i++){
    ShrinkROI(all_rois.at(i));
  }
}

void WCP2dToy::uBooNEDataAfterROI::generate_merge_ROIs(){
  // find tight ROIs not contained by the loose ROIs
  for (int i = 0;i!=nwire_u;i++){
    std::map<SignalROI*,int> covered_tight_rois;
    for (auto it = rois_u_loose.at(i).begin();it!=rois_u_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (contained_rois.find(roi) != contained_rois.end()){
	for (auto it1 = contained_rois[roi].begin(); it1!= contained_rois[roi].end(); it1++){
	  if (covered_tight_rois.find(*it1)==covered_tight_rois.end()){
	    covered_tight_rois[*it1]  =1;
	  }
	}
      }
    }
    SignalROISelection saved_rois;
    for (auto it = rois_u_tight.at(i).begin();it!=rois_u_tight.at(i).end();it++){
      SignalROI *roi = *it;
      if (covered_tight_rois.find(roi) == covered_tight_rois.end()){
	saved_rois.push_back(roi);
      }
    }
    // if (i == 1212)
    //   std::cout << saved_rois.size() << " " << saved_rois.at(0)->get_start_bin() << " " << saved_rois.at(0)->get_end_bin() << std::endl;
    
    for (auto it = saved_rois.begin(); it!=saved_rois.end();it++){
      SignalROI *roi = *it;
      // Duplicate them 
      SignalROI *loose_roi = new SignalROI(roi);
      
      rois_u_loose.at(i).push_back(loose_roi);

      // update all the maps     
      // contained
      SignalROISelection temp_rois;
      temp_rois.push_back(roi);
      contained_rois[loose_roi] = temp_rois;
      // front map loose ROI
      if (i < nwire_u-1){
	for (auto it1 = rois_u_loose.at(i+1).begin(); it1!=rois_u_loose.at(i+1).end(); it1++){
	  SignalROI *next_roi = *it1;
	  
	  if (loose_roi->overlap(next_roi)){
	    if (back_rois.find(next_roi) == back_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(loose_roi);
	      back_rois[next_roi] = temp_rois;
	    }else{
	      back_rois[next_roi].push_back(loose_roi);
	    }
	      
	    if (front_rois.find(loose_roi) == front_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(next_roi);
	      front_rois[loose_roi] = temp_rois;
	    }else{
	      front_rois[loose_roi].push_back(next_roi);
	    }
	  }

	}
      }
      // back map loose ROI
      if (i > 0){
	for (auto it1 = rois_u_loose.at(i-1).begin(); it1!=rois_u_loose.at(i-1).end(); it1++){
	  SignalROI *prev_roi = *it1;
	  if (loose_roi->overlap(prev_roi)){
	    if (front_rois.find(prev_roi) == front_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(loose_roi);
	      front_rois[prev_roi] = temp_rois;
	    }else{
	      front_rois[prev_roi].push_back(loose_roi);
	    }
	    if (back_rois.find(loose_roi) == back_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(prev_roi);
	      back_rois[loose_roi] = temp_rois;
	    }else{
	      back_rois[loose_roi].push_back(prev_roi);
	    }
	  }
	}
      }
    }
  }
 




  for (int i = 0;i!=nwire_v;i++){
    std::map<SignalROI*,int> covered_tight_rois;
    for (auto it = rois_v_loose.at(i).begin();it!=rois_v_loose.at(i).end();it++){
      SignalROI *roi = *it;
      if (contained_rois.find(roi) != contained_rois.end()){
	for (auto it1 = contained_rois[roi].begin(); it1!= contained_rois[roi].end(); it1++){
	  if (covered_tight_rois.find(*it1)==covered_tight_rois.end()){
	    covered_tight_rois[*it1]  =1;
	  }
	}
      }
    }
    SignalROISelection saved_rois;
    for (auto it = rois_v_tight.at(i).begin();it!=rois_v_tight.at(i).end();it++){
      SignalROI *roi = *it;
      if (covered_tight_rois.find(roi) == covered_tight_rois.end()){
	saved_rois.push_back(roi);
      }
    }
    //if (i == 3885-2400)
    //  std::cout << saved_rois.size() << std::endl;
    //   std::cout << saved_rois.size() << " " << saved_rois.at(0)->get_start_bin() << " " << saved_rois.at(0)->get_end_bin() << std::endl;
    
    for (auto it = saved_rois.begin(); it!=saved_rois.end();it++){
      SignalROI *roi = *it;
      // Duplicate them 
      SignalROI *loose_roi = new SignalROI(roi);
      
      rois_v_loose.at(i).push_back(loose_roi);

      // update all the maps     
      // contained
      SignalROISelection temp_rois;
      temp_rois.push_back(roi);
      contained_rois[loose_roi] = temp_rois;
      // front map loose ROI
      if (i < nwire_v-1){
	for (auto it1 = rois_v_loose.at(i+1).begin(); it1!=rois_v_loose.at(i+1).end(); it1++){
	  SignalROI *next_roi = *it1;
	  
	  if (loose_roi->overlap(next_roi)){
	    if (back_rois.find(next_roi) == back_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(loose_roi);
	      back_rois[next_roi] = temp_rois;
	    }else{
	      back_rois[next_roi].push_back(loose_roi);
	    }
	      
	    if (front_rois.find(loose_roi) == front_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(next_roi);
	      front_rois[loose_roi] = temp_rois;
	    }else{
	      front_rois[loose_roi].push_back(next_roi);
	    }
	  }

	}
      }
      // back map loose ROI
      if (i > 0){
	for (auto it1 = rois_v_loose.at(i-1).begin(); it1!=rois_v_loose.at(i-1).end(); it1++){
	  SignalROI *prev_roi = *it1;
	  if (loose_roi->overlap(prev_roi)){
	    if (front_rois.find(prev_roi) == front_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(loose_roi);
	      front_rois[prev_roi] = temp_rois;
	    }else{
	      front_rois[prev_roi].push_back(loose_roi);
	    }
	    if (back_rois.find(loose_roi) == back_rois.end()){
	      SignalROISelection temp_rois;
	      temp_rois.push_back(prev_roi);
	      back_rois[loose_roi] = temp_rois;
	    }else{
	      back_rois[loose_roi].push_back(prev_roi);
	    }
	  }
	}
      }
    }
  }
  
}


int WCP2dToy::uBooNEDataAfterROI::jump(int frame_number){
  Clear();
  if (frame.index == frame_number) {
    return frame_number;
  }
  frame.clear();

  fds.jump(frame_number);
  const Frame& frame1 = fds.get();
  size_t ntraces = frame1.traces.size();
  int nticks = fds.Get_Bins_Per_Frame();

  TH1F *htemp_signal = new TH1F("htemp_signal","htemp_signal",nticks,0,nticks);
  
  for (size_t ind =0; ind<ntraces; ++ind) {
    htemp_signal->Reset();
    const Trace& trace = frame1.traces[ind];
    int tbin = trace.tbin;
    int chid = trace.chid;
    int nbins = trace.charge.size();

    //copy signal
    for (int i = tbin;i!=tbin+nbins;i++){
      int tt = i+1;
      htemp_signal->SetBinContent(tt,trace.charge.at(i));
    }
    
    std::vector<std::pair<int,int>>& uboone_rois = rois.get_self_rois(chid);
    for (int i=0;i!=uboone_rois.size();i++){
      //std::cout << nbins << " " << i << " " << uboone_rois.size() << " " << chid << " " << uboone_rois.at(i).first << " " << uboone_rois.at(i).second << std::endl;
      SignalROI *tight_roi;
      float threshold;
      if (chid < nwire_u){
	tight_roi = new SignalROI(WirePlaneType_t(0), chid,uboone_rois.at(i).first,uboone_rois.at(i).second, htemp_signal);
	threshold = rois.get_uplane_rms().at(chid) * 3.0;
      }else if (chid < nwire_u+nwire_v){
	tight_roi = new SignalROI(WirePlaneType_t(1), chid,uboone_rois.at(i).first,uboone_rois.at(i).second, htemp_signal);
	threshold = rois.get_vplane_rms().at(chid-nwire_u) * 3.0;
      }else{
	tight_roi = new SignalROI(WirePlaneType_t(2), chid,uboone_rois.at(i).first,uboone_rois.at(i).second, htemp_signal);
	threshold = rois.get_wplane_rms().at(chid-nwire_u-nwire_v) * 3.0;
      }
      // std::cout << i << std::endl;
      
      
      // if (chid == 1151)
      // 	std::cout << tight_roi->get_chid() << " " <<  tight_roi->get_start_bin() << " " << tight_roi->get_end_bin() << std::endl;

      // judge ...
      if (tight_roi->get_above_threshold(threshold).size()==0) {
	// if (chid ==1151)
	//   std::cout << tight_roi->get_chid() << " " <<  tight_roi->get_start_bin() << " " << tight_roi->get_end_bin() << std::endl;

	delete tight_roi;
	continue;
      }

      if (chid < nwire_u){
	rois_u_tight[chid].push_back(tight_roi);
       	if (chid>0){
       	  //form connectivity map
       	  for (auto it = rois_u_tight[chid-1].begin();it!=rois_u_tight[chid-1].end();it++){
       	    SignalROI *prev_roi = *it;
      	    if (tight_roi->overlap(prev_roi)){
      	      if (front_rois.find(prev_roi) == front_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(tight_roi);
      		front_rois[prev_roi] = temp_rois;
      	      }else{
      		front_rois[prev_roi].push_back(tight_roi);
      	      }
      	      if (back_rois.find(tight_roi) == back_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(prev_roi);
      		back_rois[tight_roi] = temp_rois;
      	      }else{
      		back_rois[tight_roi].push_back(prev_roi);
      	      }
      	    }
       	  }
     	}

	if (chid < nwire_u-1){
	  // add the code for the next one to be completed
	  for (auto it = rois_u_tight[chid+1].begin();it!=rois_u_tight[chid+1].end();it++){
	    SignalROI *next_roi = *it;
	    if (tight_roi->overlap(next_roi)){
	      if (back_rois.find(next_roi) == back_rois.end()){
		SignalROISelection temp_rois;
		temp_rois.push_back(tight_roi);
		back_rois[next_roi] = temp_rois;
	      }else{
		back_rois[next_roi].push_back(tight_roi);
	      }
	      
	      if (front_rois.find(tight_roi) == front_rois.end()){
		SignalROISelection temp_rois;
		temp_rois.push_back(next_roi);
		front_rois[tight_roi] = temp_rois;
	      }else{
		front_rois[tight_roi].push_back(next_roi);
	      }
	    }
	  }
	}
	
	
      }else if (chid < nwire_u + nwire_v){
       	rois_v_tight[chid-nwire_u].push_back(tight_roi);

      	if (chid>nwire_u){
      	  //form connectivity map
      	  for (auto it = rois_v_tight[chid - nwire_u-1].begin();it!=rois_v_tight[chid-nwire_u-1].end();it++){
      	    SignalROI *prev_roi = *it;
      	    if (tight_roi->overlap(prev_roi)){
      	      if (front_rois.find(prev_roi) == front_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(tight_roi);
      		front_rois[prev_roi] = temp_rois;
      	      }else{
      		front_rois[prev_roi].push_back(tight_roi);
      	      }
      	      if (back_rois.find(tight_roi) == back_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(prev_roi);
      		back_rois[tight_roi] = temp_rois;
      	      }else{
      		back_rois[tight_roi].push_back(prev_roi);
      	      }
      	    }
      	  }
      	}

	if (chid<nwire_u+nwire_v-1){
      	  //form connectivity map
      	  for (auto it = rois_v_tight[chid - nwire_u+1].begin();it!=rois_v_tight[chid-nwire_u+1].end();it++){
      	    SignalROI *next_roi = *it;
      	    if (tight_roi->overlap(next_roi)){
      	      if (back_rois.find(next_roi) == back_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(tight_roi);
      		back_rois[next_roi] = temp_rois;
      	      }else{
      		back_rois[next_roi].push_back(tight_roi);
      	      }
      	      if (front_rois.find(tight_roi) == front_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(next_roi);
      		front_rois[tight_roi] = temp_rois;
      	      }else{
      		front_rois[tight_roi].push_back(next_roi);
      	      }
      	    }
      	  }
      	}

	

      }else{
       	rois_w_tight[chid-nwire_u-nwire_v].push_back(tight_roi);

      	if (chid>nwire_u+nwire_v){
      	  //form connectivity map
      	  for (auto it = rois_w_tight[chid-nwire_u-nwire_v-1].begin();it!=rois_w_tight[chid-nwire_u-nwire_v-1].end();it++){
      	    SignalROI *prev_roi = *it;
      	    if (tight_roi->overlap(prev_roi)){
      	      if (front_rois.find(prev_roi) == front_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(tight_roi);
      		front_rois[prev_roi] = temp_rois;
      	      }else{
      		front_rois[prev_roi].push_back(tight_roi);
      	      }
      	      if (back_rois.find(tight_roi) == back_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(prev_roi);
      		back_rois[tight_roi] = temp_rois;
      	      }else{
      		back_rois[tight_roi].push_back(prev_roi);
      	      }
      	    }
      	  }
      	}


	if (chid<nwire_u+nwire_v+nwire_w-1){
      	  //form connectivity map
      	  for (auto it = rois_w_tight[chid-nwire_u-nwire_v+1].begin();it!=rois_w_tight[chid-nwire_u-nwire_v+1].end();it++){
      	    SignalROI *next_roi = *it;
      	    if (tight_roi->overlap(next_roi)){
      	      if (back_rois.find(next_roi) == back_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(tight_roi);
      		back_rois[next_roi] = temp_rois;
      	      }else{
      		back_rois[next_roi].push_back(tight_roi);
      	      }
      	      if (front_rois.find(tight_roi) == front_rois.end()){
      		SignalROISelection temp_rois;
      		temp_rois.push_back(next_roi);
      		front_rois[tight_roi] = temp_rois;
      	      }else{
      		front_rois[tight_roi].push_back(next_roi);
      	      }
      	    }
      	  }
      	}


      }
    }
    
    

    uboone_rois = rois.get_loose_rois(chid);
    for (int i = 0; i!=uboone_rois.size();i++){
      SignalROI *loose_roi;
      float threshold;
      if (chid < nwire_u){
	loose_roi = new SignalROI(WirePlaneType_t(0),chid,uboone_rois.at(i).first,uboone_rois.at(i).second,htemp_signal);
	threshold = rois.get_uplane_rms().at(chid) * 3.0;
      }else if (chid < nwire_u + nwire_v){
	loose_roi = new SignalROI(WirePlaneType_t(1),chid,uboone_rois.at(i).first,uboone_rois.at(i).second,htemp_signal);
	threshold = rois.get_vplane_rms().at(chid - nwire_u) * 3.0;
      }else{
	loose_roi = new SignalROI(WirePlaneType_t(2),chid,uboone_rois.at(i).first,uboone_rois.at(i).second,htemp_signal);
	threshold = rois.get_wplane_rms().at(chid-nwire_u-nwire_v) * 3.0;
      }

      if (loose_roi->get_above_threshold(threshold).size()==0) {
       	delete loose_roi;
       	continue;
      }
      
      if (chid < nwire_u){
    	rois_u_loose[chid].push_back(loose_roi);

    	if (chid>0){
    	  //form connectivity map
    	  for (auto it=rois_u_loose[chid-1].begin();it!=rois_u_loose[chid-1].end();it++){
    	    SignalROI *prev_roi = *it;
    	    if (loose_roi->overlap(prev_roi)){
    	      if (front_rois.find(prev_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		front_rois[prev_roi] = temp_rois;
    	      }else{
    		front_rois[prev_roi].push_back(loose_roi);
    	      }
    	      if (back_rois.find(loose_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(prev_roi);
    		back_rois[loose_roi] = temp_rois;
    	      }else{
    		back_rois[loose_roi].push_back(prev_roi);
    	      }
    	    }
    	  }
    	}

	if (chid<nwire_u-1){
    	  //form connectivity map
    	  for (auto it=rois_u_loose[chid+1].begin();it!=rois_u_loose[chid+1].end();it++){
    	    SignalROI *next_roi = *it;
    	    if (loose_roi->overlap(next_roi)){
    	      if (back_rois.find(next_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		back_rois[next_roi] = temp_rois;
    	      }else{
    		back_rois[next_roi].push_back(loose_roi);
    	      }
    	      if (front_rois.find(loose_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(next_roi);
    		front_rois[loose_roi] = temp_rois;
    	      }else{
    		front_rois[loose_roi].push_back(next_roi);
    	      }
    	    }
    	  }
    	}
	

    	//form contained map ... 
    	for (auto it=rois_u_tight[chid].begin();it!=rois_u_tight[chid].end();it++){
    	  SignalROI *tight_roi = *it;
    	  if (tight_roi->overlap(loose_roi)){
    	    if (contained_rois.find(loose_roi)==contained_rois.end()){
    	      SignalROISelection temp_rois;
    	      temp_rois.push_back(tight_roi);
    	      contained_rois[loose_roi] = temp_rois;
    	    }else{
    	      contained_rois[loose_roi].push_back(tight_roi);
    	    }
    	  }
    	}

      }else if (chid < nwire_u + nwire_v){
    	rois_v_loose[chid-nwire_u].push_back(loose_roi);

    	if (chid>nwire_u){
    	  //form connectivity map
    	  for (auto it = rois_v_loose[chid-nwire_u-1].begin();it!=rois_v_loose[chid-nwire_u-1].end();it++){
    	    SignalROI *prev_roi = *it;
    	    if (loose_roi->overlap(prev_roi)){
    	      if (front_rois.find(prev_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		front_rois[prev_roi] = temp_rois;
    	      }else{
    		front_rois[prev_roi].push_back(loose_roi);
    	      }
    	      if (back_rois.find(loose_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(prev_roi);
    		back_rois[loose_roi] = temp_rois;
    	      }else{
    		back_rois[loose_roi].push_back(prev_roi);
    	      }
    	    }
    	  }
    	}

	if (chid<nwire_u+nwire_v-1){
    	  //form connectivity map
    	  for (auto it = rois_v_loose[chid-nwire_u+1].begin();it!=rois_v_loose[chid-nwire_u+1].end();it++){
    	    SignalROI *next_roi = *it;
    	    if (loose_roi->overlap(next_roi)){
    	      if (back_rois.find(next_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		back_rois[next_roi] = temp_rois;
    	      }else{
    		back_rois[next_roi].push_back(loose_roi);
    	      }
    	      if (front_rois.find(loose_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(next_roi);
    		front_rois[loose_roi] = temp_rois;
    	      }else{
    		front_rois[loose_roi].push_back(next_roi);
    	      }
    	    }
    	  }
    	}

    	//form contained map ... 
    	for (auto it = rois_v_tight[chid-nwire_u].begin();it!=rois_v_tight[chid-nwire_u].end();it++){
    	  SignalROI *tight_roi = *it;
    	  if (tight_roi->overlap(loose_roi)){
    	    if (contained_rois.find(loose_roi)==contained_rois.end()){
    	      SignalROISelection temp_rois;
    	      temp_rois.push_back(tight_roi);
    	      contained_rois[loose_roi] = temp_rois;
    	    }else{
    	      contained_rois[loose_roi].push_back(tight_roi);
    	    }
    	  }
    	}

      }else{
    	rois_w_loose[chid-nwire_u-nwire_v].push_back(loose_roi);

    	if (chid>nwire_u+nwire_v){
    	  //form connectivity map
    	  for (auto it=rois_w_loose[chid-nwire_u-nwire_v-1].begin();it!=rois_w_loose[chid-nwire_u-nwire_v-1].end();it++){
    	    SignalROI *prev_roi = *it;
    	    if (loose_roi->overlap(prev_roi)){
    	      if (front_rois.find(prev_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		front_rois[prev_roi] = temp_rois;
    	      }else{
    		front_rois[prev_roi].push_back(loose_roi);
    	      }
    	      if (back_rois.find(loose_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(prev_roi);
    		back_rois[loose_roi] = temp_rois;
    	      }else{
    		back_rois[loose_roi].push_back(prev_roi);
    	      }
    	    }
    	  }
    	}

	if (chid<nwire_u+nwire_v+nwire_w-1){
    	  //form connectivity map
    	  for (auto it=rois_w_loose[chid-nwire_u-nwire_v+1].begin();it!=rois_w_loose[chid-nwire_u-nwire_v+1].end();it++){
    	    SignalROI *next_roi = *it;
    	    if (loose_roi->overlap(next_roi)){
    	      if (back_rois.find(next_roi) == back_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(loose_roi);
    		back_rois[next_roi] = temp_rois;
    	      }else{
    		back_rois[next_roi].push_back(loose_roi);
    	      }
    	      if (front_rois.find(loose_roi) == front_rois.end()){
    		SignalROISelection temp_rois;
    		temp_rois.push_back(next_roi);
    		front_rois[loose_roi] = temp_rois;
    	      }else{
    		front_rois[loose_roi].push_back(next_roi);
    	      }
    	    }
    	  }
    	}
	
    	//form contained map ... 
    	for (auto it=rois_w_tight[chid-nwire_u-nwire_v].begin();it!=rois_w_tight[chid-nwire_u-nwire_v].end();it++){
    	  SignalROI *tight_roi = *it;
    	  if (tight_roi->overlap(loose_roi)){
    	    if (contained_rois.find(loose_roi)==contained_rois.end()){
    	      SignalROISelection temp_rois;
    	      temp_rois.push_back(tight_roi);
    	      contained_rois[loose_roi] = temp_rois;
    	    }else{
    	      contained_rois[loose_roi].push_back(tight_roi);
    	    }
    	  }
	}
	
      }
    }
  }

  // std::cout << " 1st Check: " << std::endl;
  // TestROIs();
  
  //std::cout << rois_u_tight.size() << " " << rois_v_tight.size() << " " << rois_w_tight.size() << " " << rois_u_loose.size() << " " << rois_v_loose.size() << " " << rois_w_loose.size() << " " << front_rois.size() << " " << back_rois.size() << " " << contained_rois.size() << std::endl;
  std::cout << "Clean up loose ROIs" << std::endl;
  CleanUpROIs();
  std::cout << "Generate more loose ROIs from isolated good tight ROIs" << std::endl;
  generate_merge_ROIs();

  for (int qx = 0; qx!=2; qx++){
    std::cout << "Break loose ROIs" << std::endl;
    BreakROIs();
    std::cout << "Clean up ROIs 2nd time" << std::endl;
    CheckROIs();
    CleanUpROIs();
  }
  
  // std::cout << "2nd  Check: " << std::endl;
  // TestROIs();
  
  std::cout << "Shrink ROIs" << std::endl;
  ShrinkROIs();
  std::cout << "Clean up ROIs 3rd time" << std::endl;
  CheckROIs();
  CleanUpROIs();

  //  std::cout << "3rd  Check: " << std::endl;
  // TestROIs();
  
  // Further reduce fake hits
  std::cout << "Remove fake hits " << std::endl;
  CleanUpCollectionROIs();
  CleanUpInductionROIs();

  // std::cout << "Xin: " << rois_u_tight.at(2197).size() << " " << rois_u_loose.at(2197).size() << std::endl;
  //  for (auto it = rois_u_loose.at(2196).begin();it!= rois_u_loose.at(2196).end();it++){
  //   SignalROI *roi =  *it;
  //   std::cout << "2196 " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
  // }
  // for (auto it = rois_u_loose.at(2197).begin();it!= rois_u_loose.at(2197).end();it++){
  //   SignalROI *roi =  *it;
  //   std::cout << "2197 " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
  // }
  
  std::cout << "Extend ROIs" << std::endl;
  ExtendROIs();

  
  
  // std::cout << "Xin: " << rois_u_tight.at(1908).size() << " " << rois_u_loose.at(1908).size() << std::endl; 
  // for (auto it = rois_u_loose.at(1908).begin();it!= rois_u_loose.at(1908).end();it++){
  //   SignalROI *roi =  *it;
  //   std::cout << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
  // }

  // std::cout << "4th Check" << std::endl;
  // TestROIs();
  
  // load results back into the data ... 

  WCP2dToy::uBooNEData2DDeconvolutionFDS* temp_fds =(WCP2dToy::uBooNEData2DDeconvolutionFDS*)&fds;
    
  TH2I *hu_data = temp_fds->get_u_wiener();
  TH2I *hv_data = temp_fds->get_v_wiener();  
  TH2I *hw_data = temp_fds->get_w_wiener();
  
  for (size_t ind=0; ind<ntraces; ++ind) {
    htemp_signal->Reset();
    
    const Trace& trace = frame1.traces[ind];
    int tbin = trace.tbin;
    int chid = trace.chid;
    int nbins = trace.charge.size();

    // // load results back into the histogram
    // if (chid < nwire_u){
    //   for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
    // 	//for (auto it = rois_u_tight.at(chid).begin(); it!= rois_u_tight.at(chid).end();it++){
    // 	SignalROI *roi =  *it;
    // 	std::vector<float>& contents = roi->get_contents();
    // 	int start_bin = roi->get_start_bin();
    // 	for (int i=0;i!=contents.size();i++){
    // 	  htemp_signal->SetBinContent(start_bin+1+i,contents.at(i));
    // 	}
    //   }
    // }else if (chid < nwire_u + nwire_v){
    //   for (auto it = rois_v_loose.at(chid-nwire_u).begin(); it!= rois_v_loose.at(chid-nwire_u).end();it++){
    // 	//for (auto it = rois_v_tight.at(chid-nwire_u).begin(); it!= rois_v_tight.at(chid-nwire_u).end();it++){
    //   	SignalROI *roi =  *it;
    //   	std::vector<float>& contents = roi->get_contents();
    //   	int start_bin = roi->get_start_bin();
    //   	for (int i=0;i!=contents.size();i++){
    //   	  htemp_signal->SetBinContent(start_bin+1+i,contents.at(i));
    //   	}
    //   }
    // }else{
    //   for (auto it = rois_w_tight.at(chid-nwire_u-nwire_v).begin(); it!= rois_w_tight.at(chid-nwire_u-nwire_v).end();it++){
    //   	SignalROI *roi =  *it;
    //   	std::vector<float>& contents = roi->get_contents();
    //   	int start_bin = roi->get_start_bin();
    //   	for (int i=0;i!=contents.size();i++){
    //   	  htemp_signal->SetBinContent(start_bin+1+i,contents.at(i));
    //   	}
    //   }
    // }

      if (chid < nwire_u){
      for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
	SignalROI *roi =  *it;
	// int start_bin = roi->get_start_bin();
	// int end_bin = roi->get_end_bin();
	int start_bin = roi->get_ext_start_bin();
	int end_bin = roi->get_ext_end_bin();
	float start_content = hu_data->GetBinContent(chid+1,start_bin+1);
	float end_content = hu_data->GetBinContent(chid+1,end_bin+1);
	for (int i=start_bin; i<end_bin+1; i++){
	  int content = hu_data->GetBinContent(chid+1,i+1) - ((end_content - start_content)*(i-start_bin)/(end_bin-start_bin) + start_content);
	  htemp_signal->SetBinContent(i+1,content);
	}
      }
    }else if (chid < nwire_u + nwire_v){
      for (auto it = rois_v_loose.at(chid-nwire_u).begin(); it!= rois_v_loose.at(chid-nwire_u).end();it++){
	SignalROI *roi =  *it;
	// int start_bin = roi->get_start_bin();
	// int end_bin = roi->get_end_bin();
	int start_bin = roi->get_ext_start_bin();
	int end_bin = roi->get_ext_end_bin();
	float start_content = hv_data->GetBinContent(chid-nwire_u+1,start_bin+1);
	float end_content = hv_data->GetBinContent(chid-nwire_u+1,end_bin+1);
	for (int i=start_bin; i<end_bin+1; i++){
	  int content = hv_data->GetBinContent(chid-nwire_u+1,i+1) - ((end_content - start_content)*(i-start_bin)/(end_bin-start_bin) + start_content);
	  htemp_signal->SetBinContent(i+1,content);
	}
      }
    }else{
      for (auto it = rois_w_tight.at(chid-nwire_u-nwire_v).begin(); it!= rois_w_tight.at(chid-nwire_u-nwire_v).end();it++){
	SignalROI *roi =  *it;
	// int start_bin = roi->get_start_bin();
	// int end_bin = roi->get_end_bin();
	int start_bin = roi->get_ext_start_bin();
	int end_bin = roi->get_ext_end_bin();
	float start_content = hw_data->GetBinContent(chid-nwire_u-nwire_v+1,start_bin+1);
	float end_content = hw_data->GetBinContent(chid-nwire_u-nwire_v+1,end_bin+1);
	for (int i=start_bin; i<end_bin+1; i++){
	  int content = hw_data->GetBinContent(chid-nwire_u-nwire_v+1,i+1);// - ((end_content - start_content)*(i-start_bin)/(end_bin-start_bin) + start_content);
	  htemp_signal->SetBinContent(i+1,content);
	}
      }
    }
    
    
    // save into frames ... 
    WCP::Trace trace1;
    trace1.chid = chid;
    trace1.tbin = 0;
    trace1.charge.resize(bins_per_frame, 0.0);
    
    for (int i=0;i!=bins_per_frame;i++){
      float sum = 0;
      for (int j=0;j!=rebin;j++){
	sum += htemp_signal->GetBinContent(i*rebin+j+1);
      }
      trace1.charge.at(i) = sum;
    }
    frame.traces.push_back(trace1);
  }
  
  delete htemp_signal;

  frame.index = frame_number;
  return frame.index;

}

void WCP2dToy::uBooNEDataAfterROI::ExtendROIs(){

  bool flag = true;
  // initialize all ROIs
  for (int chid= 0 ; chid!=nwire_u; chid++){
    for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      // initialize the extended bins ... 
      roi->set_ext_start_bin(roi->get_start_bin());
      roi->set_ext_end_bin(roi->get_end_bin());

      // if (roi->get_start_bin() <0 || roi->get_start_bin() >=9594 || roi->get_end_bin() <0 || roi->get_end_bin() > 9594)
      // 	std::cout << roi->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << std::endl;
    }
  }
  for (int chid= 0 ; chid!=nwire_v; chid++){
    for (auto it = rois_v_loose.at(chid).begin(); it!= rois_v_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      // initialize the extended bins ... 
      roi->set_ext_start_bin(roi->get_start_bin());
      roi->set_ext_end_bin(roi->get_end_bin());
    }
  }
  for (int chid= 0 ; chid!=nwire_w; chid++){
    for (auto it = rois_w_tight.at(chid).begin(); it!= rois_w_tight.at(chid).end();it++){
      SignalROI *roi =  *it;
      // initialize the extended bins ... 
      roi->set_ext_start_bin(roi->get_start_bin());
      roi->set_ext_end_bin(roi->get_end_bin());
    }
  }
  

  
  // U plane ... 
  for (int chid = 0; chid != nwire_u; chid ++){
    rois_u_loose.at(chid).sort(CompareRois());
    for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      // // initialize the extended bins ... 
      // roi->set_ext_start_bin(roi->get_start_bin());
      // roi->set_ext_end_bin(roi->get_end_bin());

      if (flag){
	//loop through front
	for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  // if (roi->get_chid()==1908)
	  //   std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << " " << ext_start_bin << " " << ext_end_bin << std::endl;
	}
	
	// loop through back 
	for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  // if (roi->get_chid()==1908)
	  //   std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << " " << ext_start_bin << " " << ext_end_bin << std::endl;
	}
	//std::cout << chid << " " << roi->get_start_bin() << " " << roi->get_end_bin() << std::endl;
      }
    }

    if (flag){
      SignalROI *prev_roi = 0;
      for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
	SignalROI *roi =  *it;
	if (prev_roi!=0){
	  if (prev_roi->get_ext_end_bin() > roi->get_ext_start_bin()){
	    prev_roi->set_ext_end_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));
	    roi->set_ext_start_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));

	    // if (roi->get_chid()==1908)
	    //   std::cout << roi->get_chid() << " " << prev_roi->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << prev_roi->get_start_bin() << " " << prev_roi->get_end_bin() << " " << int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5) << " " << int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5) << std::endl;
	  }
	}
	prev_roi = roi;
      }
    }
    // for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
    //   SignalROI *roi =  *it;
    //   std::cout << chid << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
    // }
  }
  // V plane
  for (int chid = 0; chid != nwire_v; chid ++){
    rois_v_loose.at(chid).sort(CompareRois());
    for (auto it = rois_v_loose.at(chid).begin(); it!= rois_v_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      // // initialize the extended bins ... 
      // roi->set_ext_start_bin(roi->get_start_bin());
      // roi->set_ext_end_bin(roi->get_end_bin());

      if (flag){
	//loop through front
	for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  //	std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << std::endl;
	}
	
	// loop through back 
	for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  //	std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << std::endl;
	}
	//std::cout << chid << " " << roi->get_start_bin() << " " << roi->get_end_bin() << std::endl;
      }
    }

    if (flag){
      SignalROI *prev_roi = 0;
      for (auto it = rois_v_loose.at(chid).begin(); it!= rois_v_loose.at(chid).end();it++){
	SignalROI *roi =  *it;
	if (prev_roi!=0){
	  if (prev_roi->get_ext_end_bin() > roi->get_ext_start_bin()){
	    prev_roi->set_ext_end_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));
	    roi->set_ext_start_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));
	  }
	}
	prev_roi = roi;
      }
    }
    // for (auto it = rois_v_loose.at(chid).begin(); it!= rois_v_loose.at(chid).end();it++){
    //   SignalROI *roi =  *it;
    //   std::cout << chid << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
    // }
  }

  // W plane
  for (int chid = 0; chid != nwire_w; chid ++){
    rois_w_tight.at(chid).sort(CompareRois());
    for (auto it = rois_w_tight.at(chid).begin(); it!= rois_w_tight.at(chid).end();it++){
      SignalROI *roi =  *it;
      // // initialize the extended bins ... 
      // roi->set_ext_start_bin(roi->get_start_bin());
      // roi->set_ext_end_bin(roi->get_end_bin());

      if (flag){
	//loop through front
	for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  //	std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << std::endl;
	}
	
	// loop through back 
	for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	  SignalROI *roi1 = *it1;
	  int ext_start_bin = roi->get_ext_start_bin();
	  int ext_end_bin = roi->get_ext_end_bin();
	  if (ext_start_bin > roi1->get_start_bin()) ext_start_bin = roi1->get_start_bin();
	  if (ext_end_bin < roi1->get_end_bin()) ext_end_bin = roi1->get_end_bin();
	  roi->set_ext_start_bin(ext_start_bin);
	  roi->set_ext_end_bin(ext_end_bin);
	  //	std::cout << roi->get_chid() << " " << roi1->get_chid() << " " << roi->get_start_bin() << " " << roi->get_end_bin() << " " << roi1->get_start_bin() << " " << roi1->get_end_bin() << std::endl;
	}
	//std::cout << chid << " " << roi->get_start_bin() << " " << roi->get_end_bin() << std::endl;
      }

    }
    if (flag){
      SignalROI *prev_roi = 0;
      for (auto it = rois_w_tight.at(chid).begin(); it!= rois_w_tight.at(chid).end();it++){
	SignalROI *roi =  *it;
	if (prev_roi!=0){
	  if (prev_roi->get_ext_end_bin() > roi->get_ext_start_bin()){
	    prev_roi->set_ext_end_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));
	    roi->set_ext_start_bin(int(prev_roi->get_end_bin() * 0.5 + roi->get_start_bin()*0.5));
	  }
	}
	prev_roi = roi;
      }
    } 
      // for (auto it = rois_w_tight.at(chid).begin(); it!= rois_w_tight.at(chid).end();it++){
      //   SignalROI *roi =  *it;
      //   std::cout << chid << " " << roi->get_ext_start_bin() << " " << roi->get_ext_end_bin() << std::endl;
      // }
  }
}



void WCP2dToy::uBooNEDataAfterROI::CheckROIs(){
  std::vector<float>& rms_u = rois.get_uplane_rms();
  std::vector<float>& rms_v = rois.get_vplane_rms();
  
  // for (int i=0;i!=rois_u_loose.size();i++){
  //   for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end();it++){
  //     SignalROI *roi = *it;
  //     int chid = roi->get_chid();
  //     if (chid != i) 
  // 	std::cout << roi << std::endl;
      
  //     if (front_rois.find(roi)!=front_rois.end()){
  //  	for (auto it1 = front_rois[roi].begin();it1!=front_rois[roi].end();it1++){
  // 	  SignalROI *roi1 = *it1;
  // 	  int chid1 = roi1->get_chid();
  // 	  if (chid1!=i+1)
  // 	    std::cout << roi1 << " " << chid << " " << chid1 << std::endl;
  // 	}
  //     }
  //   }
  // }
  
  //loop over u loose
  for (int i=0;i!=rois_u_loose.size();i++){
    for (auto it = rois_u_loose.at(i).begin(); it!= rois_u_loose.at(i).end();it++){
      SignalROI *roi = *it;
      int chid = roi->get_chid();
      float th;
      th = 3*rms_u.at(chid);

      if (front_rois.find(roi)!=front_rois.end()){
	SignalROISelection temp_rois;
  	for (auto it1 = front_rois[roi].begin();it1!=front_rois[roi].end();it1++){
  	  SignalROI *roi1 = *it1;
  	  int chid1 = roi1->get_chid();
  	  //std::cout << "F " << i << " " << rois_u_loose.size() << " " << roi1 << " " << chid << " " << chid1 << std::endl;
  	  float th1;
  	  th1 = 3*rms_u.at(chid1);
  	  if (roi->overlap(roi1,th,th1)){
  	  }else{
	    temp_rois.push_back(roi1);
  	    //unlink(roi,roi1);
  	  }
  	}
	for (auto it2 = temp_rois.begin(); it2!= temp_rois.end();it2++){
	  unlink(roi,*it2);
	}
      }

      if (back_rois.find(roi)!=back_rois.end()){
	SignalROISelection temp_rois;
  	for (auto it1 = back_rois[roi].begin();it1!=back_rois[roi].end();it1++){
  	  SignalROI *roi1 = *it1;
  	  int chid1 = roi1->get_chid();
  	  //std::cout << "B " << roi1 << " " << chid << " " << chid1 << std::endl;
  	  float th1;
  	  th1 = 3*rms_u.at(chid1);
  	  if (roi->overlap(roi1,th,th1)){
  	  }else{
	    temp_rois.push_back(roi1);
  	    //unlink(roi,roi1);
  	  }
  	}
	for (auto it2 = temp_rois.begin(); it2!= temp_rois.end();it2++){
	  unlink(*it2,roi);
	}
      }

    }
  }


  //loop over v loose
  for (int i=0;i!=rois_v_loose.size();i++){
    for (auto it = rois_v_loose.at(i).begin(); it!= rois_v_loose.at(i).end();it++){
      SignalROI *roi = *it;
      int chid = roi->get_chid()-nwire_u;
      float th;
      th = 3*rms_v.at(chid);
      if (front_rois.find(roi)!=front_rois.end()){
	SignalROISelection temp_rois;
  	for (auto it1 = front_rois[roi].begin();it1!=front_rois[roi].end();it1++){
  	  SignalROI *roi1 = *it1;
  	  int chid1 = roi1->get_chid()-nwire_u;
  	  float th1;
  	  th1 = 3*rms_v.at(chid1);
  	  if (roi->overlap(roi1,th,th1)){
  	  }else{
	    temp_rois.push_back(roi1);
	    // unlink(roi,roi1);
  	  }
  	}
	for (auto it2 = temp_rois.begin(); it2!= temp_rois.end();it2++){
	  unlink(roi,*it2);
	}
      }
    
      if (back_rois.find(roi)!=back_rois.end()){
	SignalROISelection temp_rois;
  	for (auto it1 = back_rois[roi].begin();it1!=back_rois[roi].end();it1++){
  	  SignalROI *roi1 = *it1;
  	  int chid1 = roi1->get_chid()-nwire_u;
  	  float th1;
  	  th1 = 3*rms_v.at(chid1);
  	  if (roi->overlap(roi1,th,th1)){
  	  }else{
	    temp_rois.push_back(roi1);
	    // unlink(roi,roi1);
  	  }
  	}
	for (auto it2 = temp_rois.begin(); it2!= temp_rois.end();it2++){
	  unlink(*it2,roi);
	}
      }
    }
  }

}



void WCP2dToy::uBooNEDataAfterROI::TestROIs(){

  for (int chid = 0; chid != nwire_u; chid ++){
    for (auto it = rois_u_loose.at(chid).begin(); it!= rois_u_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      //loop through front
      for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	SignalROI *roi1 = *it1;
	if (find(rois_u_loose.at(chid+1).begin(), rois_u_loose.at(chid+1).end(), roi1) == rois_u_loose.at(chid+1).end())
	  std::cout << chid << " u " << +1 << " " << roi << " " << roi1 << std::endl;
      }
	
      // loop through back 
      for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	SignalROI *roi1 = *it1;
	if (find(rois_u_loose.at(chid-1).begin(), rois_u_loose.at(chid-1).end(), roi1) == rois_u_loose.at(chid-1).end())
	  std::cout << chid << " u " << -1 << " " << roi << " " << roi1 << std::endl;
      }
    }
  }


   for (int chid = 0; chid != nwire_v; chid ++){
    for (auto it = rois_v_loose.at(chid).begin(); it!= rois_v_loose.at(chid).end();it++){
      SignalROI *roi =  *it;
      //loop through front
      for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	SignalROI *roi1 = *it1;
	if (find(rois_v_loose.at(chid+1).begin(), rois_v_loose.at(chid+1).end(), roi1) == rois_v_loose.at(chid+1).end())
	  std::cout << chid << " v " << +1 << " " << roi << " " << roi1 << std::endl;
      }
	
      // loop through back 
      for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	SignalROI *roi1 = *it1;
	if (find(rois_v_loose.at(chid-1).begin(), rois_v_loose.at(chid-1).end(), roi1) == rois_v_loose.at(chid-1).end())
	  std::cout << chid << " v " << -1 << " " << roi << " " << roi1 << std::endl;
      }
    }
  }
   
   for (int chid = 0; chid != nwire_w; chid ++){
     for (auto it = rois_w_tight.at(chid).begin(); it!= rois_w_tight.at(chid).end();it++){
       SignalROI *roi =  *it;
       //loop through front
       for (auto it1 = front_rois[roi].begin(); it1!=front_rois[roi].end(); it1++){
	 SignalROI *roi1 = *it1;
	if (find(rois_w_tight.at(chid+1).begin(), rois_w_tight.at(chid+1).end(), roi1) == rois_w_tight.at(chid+1).end())
	  std::cout << chid << " w " << +1 << " " << roi << " " << roi1 << std::endl;
      }
	
      // loop through back 
      for (auto it1 = back_rois[roi].begin(); it1!=back_rois[roi].end(); it1++){
	SignalROI *roi1 = *it1;
	if (find(rois_w_tight.at(chid-1).begin(), rois_w_tight.at(chid-1).end(), roi1) == rois_w_tight.at(chid-1).end())
	  std::cout << chid << " w " << -1 << " " << roi << " " << roi1 << std::endl;
      }
    }
  }
  
}
