#include "WCPSst/GeomDataSource.h"
#include "WCPSst/ToyuBooNEFrameDataSource.h"
#include "WCPSst/ToyuBooNESliceDataSource.h"
#include "WCP2dToy/ToyEventDisplay.h"
#include "WCP2dToy/ClusterDisplay.h"
#include "WCP2dToy/ToyTiling.h"
#include "WCP2dToy/MergeToyTiling.h"
#include "WCP2dToy/TruthToyTiling.h"
#include "WCP2dToy/SimpleBlobToyTiling.h"

#include "WCP2dToy/ToyMatrix.h"
#include "WCP2dToy/ToyMatrixExclusive.h"
#include "WCP2dToy/ToyMatrixKalman.h"
#include "WCP2dToy/ToyMatrixIterate.h"
#include "WCP2dToy/ToyMatrixMarkov.h"
#include "WCP2dToy/ToyMetric.h"
#include "WCP2dToy/BlobMetric.h"
#include "WCPData/TPCParams.h"
#include "WCPData/Singleton.h"

#include "WCPData/MergeGeomCell.h"
#include "WCPData/MergeGeomWire.h"

#include "WCPData/GeomCluster.h"

#include "WCPNav/FrameDataSource.h"
#include "WCPNav/SimDataSource.h"
#include "WCPNav/SliceDataSource.h"
#include "WCPSst/Util.h"
#include "WCPData/SimTruth.h"
#include "WCP2dToy/ToyDepositor.h"
#include "WCPNav/GenerativeFDS.h"
#include "WCP2dToy/ToySignalSimu.h"
#include "WCP2dToy/ToySignalSimuTrue.h"
#include "WCP2dToy/ToySignalGaus.h"
#include "WCP2dToy/ToySignalWien.h"


#include "WCPData/SpaceCell.h"
#include "WCPData/MergeSpaceCell.h"
#include "WCP2dToy/ToyCrawler.h"


#include "TApplication.h"
#include "TCanvas.h"
#include "TStyle.h"
#include "TH1F.h"
#include "TFile.h"
#include "TGraph2D.h"
#include "TColor.h"
#include "TVectorD.h"
#include "TMatrixD.h"
#include <iostream>

using namespace WCP;
using namespace std;




int main(int argc, char* argv[])
{
  if (argc < 4) {
    cerr << "usage: wire-cell-uboone /path/to/ChannelWireGeometry.txt /path/to/celltree.root eve_num -x[x_center] -y[y_center] -z[z_center] -a[rotate_angle]" << endl;
    return 1;
  }
  
  float x_center = 0;
  float y_center = 0;
  float z_center = 0;
  float rotate_angle = 0;
  
  for(Int_t i = 1; i != argc; i++){
     switch(argv[i][1]){
     case 'x':
       x_center = atof(&argv[i][2]); //m
       break;
     case 'y':
       y_center = atof(&argv[i][2]); //m
       break;
     case 'z':
       z_center = atof(&argv[i][2]); // m
       break;
     case 'a':
       rotate_angle = atof(&argv[i][2]); //degrees 
       break;
     }
  }



  x_center *= units::m;
  y_center *= units::m;
  z_center *= units::m;
  rotate_angle = rotate_angle/180.*3.1415926;

  
  WCPSst::GeomDataSource gds(argv[1]);
  std::vector<double> ex = gds.extent();
  cerr << "Extent: "
       << " x:" << ex[0]/units::mm << " mm"
       << " y:" << ex[1]/units::m << " m"
       << " z:" << ex[2]/units::m << " m"
       << endl;
  cout << "Pitch: " << gds.pitch(WirePlaneType_t(0)) 
       << " " << gds.pitch(WirePlaneType_t(1)) 
       << " " << gds.pitch(WirePlaneType_t(2))
       << endl;
  cout << "Angle: " << gds.angle(WirePlaneType_t(0)) 
       << " " << gds.angle(WirePlaneType_t(1)) 
       << " " << gds.angle(WirePlaneType_t(2))
       << endl;
  
  
  const char* root_file = argv[2];
  const char* tpath = "/Event/Sim";
  
  int recon_threshold = 2000;
  int max_events = 100;
  int eve_num = atoi(argv[3]);

  float unit_dis = 1.6;

  float toffset_1=1.647;
  float toffset_2=1.539+1.647;
  float toffset_3=0;
  
  int save_image_outline_flag = 1; // prescale flag 

  int total_time_bin=9600;
  int frame_length = 3200;
  int nrebin = 4;
  
  TPCParams& mp = Singleton<TPCParams>::Instance();
  
  double pitch_u = gds.pitch(WirePlaneType_t(0));
  double pitch_v = gds.pitch(WirePlaneType_t(1));
  double pitch_w = gds.pitch(WirePlaneType_t(2));
  double time_slice_width = nrebin * unit_dis * 0.5 * units::mm;

  mp.set_pitch_u(pitch_u);
  mp.set_pitch_v(pitch_v);
  mp.set_pitch_w(pitch_w);
  mp.set_ts_width(time_slice_width);
  
  std::cout << "Singleton: " << mp.get_pitch_u() << " " << mp.get_pitch_v() << " " << mp.get_pitch_w() << " " << mp.get_ts_width() << std::endl;
  
  float threshold_u = 5.87819e+02 * 4.0;
  float threshold_v = 8.36644e+02 * 4.0;
  float threshold_w = 5.67974e+02 * 4.0;

  float threshold_ug = 755.96;
  float threshold_vg = 822.81;
  float threshold_wg = 510.84;

  int time_offset = 0;

  TFile *tfile = TFile::Open(root_file);

  TTree* sst = dynamic_cast<TTree*>(tfile->Get(tpath));

  int run_no, subrun_no, event_no;
  sst->SetBranchAddress("eventNo",&event_no);
  sst->SetBranchAddress("runNo",&run_no);
  sst->SetBranchAddress("subRunNo",&subrun_no);
  sst->GetEntry(eve_num);

  cout << "Run No: " << run_no << " " << subrun_no << " " << eve_num << endl;

  WCP::FrameDataSource* fds = 0;
  fds = WCPSst::make_fds(*tfile);
  if (!fds) {
    cerr << "ERROR: failed to get FDS from " << root_file << endl;
    return 1;
  }
  
  TH1::AddDirectory(kFALSE);
  
  
 
  
  WCP::ToyDepositor *toydep = new WCP::ToyDepositor(fds,0,unit_dis,frame_length,x_center,y_center,z_center,rotate_angle);
  const PointValueVector& pvv = toydep->depositions(eve_num);
  
  WCP::GenerativeFDS *gfds = new WCP::GenerativeFDS(*toydep,gds,total_time_bin,max_events,0.5*unit_dis*units::millimeter); // 87 K at 0.5 kV/cm
  gfds->jump(eve_num);

  
  int abc;
  
  tfile->Close("R");
  delete tfile;

  
  cout << "Put in Truth " << endl; 
  WCP2dToy::ToySignalSimuTrueFDS *st_fds = new WCP2dToy::ToySignalSimuTrueFDS(*gfds,gds,total_time_bin/nrebin,max_events,0); //truth
  st_fds->jump(eve_num);
  
  cout << "Simulate Raw WaveForm " << endl; 
  WCP2dToy::ToySignalSimuFDS *simu_fds = new WCP2dToy::ToySignalSimuFDS(*gfds,gds,total_time_bin,max_events,toffset_1,toffset_2,1); // time offset among different planes for the time electrons travel among different planes
  simu_fds->jump(eve_num);
  
  cout << "Deconvolution with Gaussian filter" << endl;
  WCP2dToy::ToySignalGausFDS *gaus_fds = new WCP2dToy::ToySignalGausFDS(*simu_fds,gds,total_time_bin/nrebin,max_events,toffset_1,toffset_2); // gaussian smearing for charge estimation
  gaus_fds->jump(eve_num);
  
  cout << "Deconvolution with Wiener filter" << endl;
   WCP2dToy::ToySignalWienFDS *wien_fds = new WCP2dToy::ToySignalWienFDS(*simu_fds,gds,total_time_bin/nrebin,max_events,toffset_1,toffset_2); // weiner smearing for hit identification
  wien_fds->jump(eve_num);
  
  
  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));

  int nwire_u = wires_u.size();
  int nwire_v = wires_v.size();
  int nwire_w = wires_w.size();
  
 
  
  // cin >> abc;

  WCPSst::ToyuBooNESliceDataSource *sds = new WCPSst::ToyuBooNESliceDataSource(*wien_fds,*gaus_fds,threshold_u, 
  					    threshold_v, threshold_w, 
  					    threshold_ug, 
  					    threshold_vg, threshold_wg, 
  					    nwire_u, 
  					    nwire_v, nwire_w); 

  WCPSst::ToyuBooNESliceDataSource *sds_th = new WCPSst::ToyuBooNESliceDataSource(*st_fds,*st_fds,500, 
  					    500, 500, 
  					    threshold_ug, 
  					    threshold_vg, threshold_wg, 
  					    nwire_u, 
  					    nwire_v, nwire_w); 

 
  int ncount = 0;
  int ncount1 = 0;  
  int ncount2 = 0;

  int ncount_t = 0;
  
  
  

  WCP2dToy::ToyTiling **toytiling = new WCP2dToy::ToyTiling*[2400];
  WCP2dToy::MergeToyTiling **mergetiling = new WCP2dToy::MergeToyTiling*[2400];
  WCP2dToy::TruthToyTiling **truthtiling = new WCP2dToy::TruthToyTiling*[2400];
  WCP2dToy::SimpleBlobToyTiling **blobtiling = new WCP2dToy::SimpleBlobToyTiling*[2400];
  WCP2dToy::ToyMatrix **toymatrix = new WCP2dToy::ToyMatrix*[2400];
  //save truth ...
  WCP2dToy::ToyTiling **toytiling_th = new WCP2dToy::ToyTiling*[2400];
  WCP2dToy::TruthToyTiling **truthtiling_th = new WCP2dToy::TruthToyTiling*[2400];
  WCP2dToy::ToyMetric toymetric;
  WCP2dToy::BlobMetric blobmetric;



  
  int start_num = 0 ;
  int end_num = sds->size()-1;
  // int start_num = 800 ;
  // int end_num = 810;
  // GeomCellSelection total_cells;
  // GeomCellSelection total_edge_cells;

  cout << "Start the Tiling " << endl; 
  WCP::Slice slice;
  for (int i=start_num;i!=end_num+1;i++){
    
    sds->jump(i);
    sds_th->jump(i);
    slice = sds->get();
    WCP::Slice slice_th = sds_th->get();
    // cout << i << " " << slice.group().size() << " " << slice_th.group().size() << endl;
    
    toytiling[i] = new WCP2dToy::ToyTiling(slice,gds,0,0,0,threshold_ug,threshold_vg, threshold_wg);
    GeomCellSelection allcell = toytiling[i]->get_allcell();
    
    GeomWireSelection allwire = toytiling[i]->get_allwire();
    cout << "Single Cell: " << i << " "  << allcell.size() << " " << allwire.size() << endl;
    //    mergetiling[i] = new WCP2dToy::MergeToyTiling(*toytiling[i],i,3,1);
    mergetiling[i] = new WCP2dToy::MergeToyTiling(*toytiling[i],i,3);
    GeomCellSelection allmcell = mergetiling[i]->get_allcell();
    
    GeomWireSelection allmwire = mergetiling[i]->get_allwire();
    cout <<"Blob: " << i << " " << allmcell.size() << " " << allmwire.size() << endl;
    truthtiling[i] = new WCP2dToy::TruthToyTiling(*toytiling[i],pvv,i,gds,frame_length/nrebin,unit_dis);
    
    
    toytiling_th[i] = new WCP2dToy::ToyTiling(slice_th,gds,0,0,0,threshold_ug,threshold_vg, threshold_wg);
    truthtiling_th[i] = new WCP2dToy::TruthToyTiling(*toytiling_th[i],pvv,i,gds,frame_length/nrebin,unit_dis);
    CellChargeMap ccmap = truthtiling[i]->ccmap();
        
    // for (int j=0;j!=allcell.size();j++){
    //   total_cells.push_back(allcell.at(j));
    // }
    // for (int j=0;j!=allmcell.size();j++){
    //   const MergeGeomCell *mcell = (const MergeGeomCell*)allmcell.at(j);
    //   GeomCellSelection edgecells = mcell->get_edgecells();
    //   for (int k=0;k!=edgecells.size();k++){
    // 	total_edge_cells.push_back(edgecells.at(k));
    //   }
    // }

  }

  delete sds;
  delete sds_th;
  
  delete simu_fds;
  delete gaus_fds;
  delete wien_fds;

  delete st_fds;
  delete gfds;
  delete toydep;
  delete fds;


  
    //do display
  
  // TApplication theApp("theApp",&argc,argv);
  // theApp.SetReturnFromRun(true);
  
  // TCanvas c1("ToyMC","ToyMC",800,600);
  // WCP2dToy::ToyEventDisplay display(c1, gds);
  
  // display.charge_min = 0.;
  // display.charge_max = 1.;
  
  
  
  // gStyle->SetOptStat(0);
  
  // const Int_t NRGBs = 5;
  // const Int_t NCont = 255;
  // Int_t MyPalette[NCont];
  // Double_t stops[NRGBs] = {0.0, 0.34, 0.61, 0.84, 1.0};
  // Double_t red[NRGBs] = {0.0, 0.0, 0.87 ,1.0, 0.51};
  // Double_t green[NRGBs] = {0.0, 0.81, 1.0, 0.2 ,0.0};
  // Double_t blue[NRGBs] = {0.51, 1.0, 0.12, 0.0, 0.0};
  // Int_t FI = TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
  // gStyle->SetNumberContours(NCont);
  // for (int kk=0;kk!=NCont;kk++) MyPalette[kk] = FI+kk;
  // gStyle->SetPalette(NCont,MyPalette);
  
  // display.init(0,10.3698,-2.33/2.,2.33/2.);
    
  // display.draw_mc(1,WCP::PointValueVector(),"colz");
  // display.draw_slice(slice,"");
  // display.draw_cells(total_cells,"*same");
  // display.draw_cells(total_edge_cells,"*same",2);
  // theApp.Run();



  


   for (int i=start_num;i!=end_num+1;i++){
     toymatrix[i] = new WCP2dToy::ToyMatrix(*toytiling[i],*mergetiling[i]);
    // cout << "start the iterate " << endl; 
    if (toymatrix[i]->Get_Solve_Flag()==0){
      WCP2dToy::ToyMatrixIterate toymatrix_it(*toymatrix[i],2000,1e5);
    }
    
    cout << i << " chi2: " << toymatrix[i]->Get_Chi2() <<
      " NDF: " << toymatrix[i]->Get_ndf() << endl;
    GeomCellSelection allmcell = mergetiling[i]->get_allcell();
    CellChargeMap ccmap = truthtiling[i]->ccmap();
    if (toymatrix[i]->Get_Solve_Flag()!=0)
      toymetric.Add(allmcell,*toymatrix[i],ccmap);
    
    toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
   }

   toymetric.Print();




  //add in cluster
  std::cout << "Start Clustering " << std::endl;
  GeomClusterList cluster_list, cluster_dellist;
  int ncount_mcell = 0;
  //Now do cluster
  for (int i=start_num;i!=end_num+1;i++){
    //for (int i=800;i!=810;i++){
    GeomCellSelection pallmcell = mergetiling[i]->get_allcell();
    GeomCellSelection allmcell;
    for (int j=0;j!=pallmcell.size();j++){
      const GeomCell* mcell = pallmcell[j];
      
      //hack for now
      if (toymatrix[i]->Get_Solve_Flag()!=0){
      	if (toymatrix[i]->Get_Cell_Charge(mcell)> recon_threshold){
      	  allmcell.push_back(mcell);
      	}
      }else{
      	allmcell.push_back(mcell);
      }
      
      //allmcell.push_back(mcell);
    }
    
    
    if (cluster_list.empty()){
      // if cluster is empty, just insert all the mcell, each as a cluster
      for (int j=0;j!=allmcell.size();j++){
	MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
	if (mcell->get_allcell().size()>0){
	  GeomCluster *cluster = new GeomCluster(*mcell);
	  cluster_list.push_back(cluster);
	}
      }
    }else{
      for (int j=0;j!=allmcell.size();j++){
	MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
	if (mcell->get_allcell().size()>0){
	  int flag = 0;
	  int flag_save = 0;
	  GeomCluster *cluster_save = 0;
	  cluster_dellist.clear();
	  
	  // loop through merged cell
	  int tmp_num = 0;
	  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
	    //loop through clusters
	    
	    flag += (*it)->AddCell(*mcell);
	    // std::cout << i << " " << j << " " << tmp_num << " " << flag << std::endl;
	    tmp_num ++;
	    
	    if (flag==1 && flag != flag_save){
	      cluster_save = *it;
	    }else if (flag>1 && flag != flag_save){
	      cluster_save->MergeCluster(*(*it));
	      cluster_dellist.push_back(*it);
	    }
	    flag_save = flag;
	    
	  }
	  
	  for (auto it = cluster_dellist.begin();it!=cluster_dellist.end();it++){
	    auto it1 = find(cluster_list.begin(),cluster_list.end(),*it);
	    cluster_list.erase(it1);
	    delete (*it);
	  }
	  
	  if (flag==0){
	    GeomCluster *cluster = new GeomCluster(*mcell);
	    cluster_list.push_back(cluster);
	  }
	}
	
      }
    }
    
    // int ncount_mcell_cluster = 0;
    // for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    //   ncount_mcell_cluster += (*it)->get_allcell().size();
    // }
    ncount_mcell += allmcell.size();
    //cout << i << " " << allmcell.size()  << " " << cluster_set.size()  << endl;
  }
  
  int ncount_mcell_cluster = 0;
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    ncount_mcell_cluster += (*it)->get_allcell().size();
  }
  cout << "Summary: " << ncount << " " << ncount_mcell << " " << ncount_mcell_cluster << endl;
  
  int ncluster;

   

  // start crawler
  cout << "Start Crawling " << endl;
  std::vector<WCP2dToy::ToyCrawler*> crawlers;
  MergeSpaceCellSelection all_msc_cells;
  SpaceCellSelection all_sc_cells;
  
  ncluster = 0;
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    
    MergeSpaceCellSelection mscells;
    for (int i=0; i!=(*it)->get_allcell().size();i++){
      const MergeGeomCell *mcell = (const MergeGeomCell*)((*it)->get_allcell().at(i));
      MergeSpaceCell *mscell = new MergeSpaceCell();
      all_msc_cells.push_back(mscell);
      mscell->set_mcell(mcell);
      for (int j=0;j!=mcell->get_allcell().size();j++){
  	const GeomCell *cell = mcell->get_allcell().at(j);
  	SpaceCell *space_cell = new SpaceCell(ncluster,*cell,(mcell->GetTimeSlice()*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.)*units::cm,1,unit_dis/10.*nrebin/2.*units::cm);
  	all_sc_cells.push_back(space_cell);
	mscell->AddSpaceCell(space_cell);
      }
      mscells.push_back(mscell);
    }
    WCP2dToy::ToyCrawler* toycrawler = new WCP2dToy::ToyCrawler(mscells);
    crawlers.push_back(toycrawler);
    
    // std::cout << ncluster << " " << toycrawler->Get_mcells_map().size() << " " << toycrawler->Get_allCT().size() << " " << toycrawler->Get_allMCT().size()  << std::endl;

    // if (toycrawler->Get_mcells_map().size()>200){
    //   TApplication theApp("theApp",&argc,argv);
    //   theApp.SetReturnFromRun(true);
      
    //   TCanvas c1("ToyMC","ToyMC",800,600);
    //   c1.Draw();
      
    //   WCP2dToy::ClusterDisplay display(c1);
    //   //display.DrawCluster(cells);
    //   display.DrawCluster(mscells);
      
      
    //   display.DrawCrawler(*toycrawler,"psame",1);
      
    //   theApp.Run();
    // }


    ncluster ++;
  }
  
  
  //check # of clusters 
  int sum = 0 ;
  for (int i=0;i!=crawlers.size();i++){
    for (auto it = crawlers.at(i)->Get_mcells_map().begin(); it!= crawlers.at(i)->Get_mcells_map().end();it++){
      MergeSpaceCell *mcell1 = it->first;
      sum += mcell1->Get_all_spacecell().size();
    }
  }
  
  std::cout << "Check: " << crawlers.size() << " "  << sum << std::endl;

  

  //start to prepare the important merge cell vectors
  std::vector<GeomCellSelection> Good_MCells;
  for (int i=start_num;i!=end_num+1;i++){
    GeomCellSelection cells;
    Good_MCells.push_back(cells);
  }
 
  for (int i=0;i!=crawlers.size();i++){
    WCP2dToy::ToyCrawler *toycrawler = crawlers.at(i);
    for (int j=0;j!=toycrawler->Get_allMCT().size();j++){
      MergeClusterTrack *mct = toycrawler->Get_allMCT().at(j);
      int ntime = mct->Get_TimeLength();
      int ntime_flag = 0;

      if (ntime < 6 && ntime >= 2){
	ntime_flag = 1;
	for (int k=0;k!=ntime;k++){
	  MergeSpaceCellSelection cells = mct->Get_MSCS(k);
	  ntime_flag = 0;
	  for (int i1 = 0; i1!=cells.size(); i1++){
	    if (cells.at(i1)->Get_all_spacecell().size() > 300/ntime){
	      ntime_flag = 1;
	      break;
	    }
	  }
	  if (ntime_flag == 0)
	    break;
	}
      }else{
	ntime_flag = 1;
      }
      

      if (ntime_flag){
	// do something	
	for (int k=0;k!=ntime;k++){
	  MergeSpaceCellSelection cells = mct->Get_MSCS(k);
	  int time = mct->Get_Time(k);
	  if (cells.size()==1){
	    Good_MCells.at(time).push_back(cells.at(0)->get_mcell());  
	  }else if (cells.size()>1){
	    
	    MergeSpaceCell *cell = cells.at(0);
	    MergeSpaceCell *next_cell = cells.at(1);
	    for (int i1 = 1; i1!=cells.size();i1++){
	      if (cell->Get_all_spacecell().size() < cells.at(i1)->Get_all_spacecell().size()){
	   	cell = cells.at(i1);
		next_cell = cell;
	      }
	    }
	    if (cell->Get_all_spacecell().size() > 3* next_cell->Get_all_spacecell().size())
	      Good_MCells.at(time).push_back(cell->get_mcell());
	  }
	}
      }
    }
  }
  

  //start to solve matrix ...
  for (int i=start_num;i!=end_num+1;i++){
    //   //toymatrix[i] = new WCP2dToy::ToyMatrix(*toytiling[i],*mergetiling[i]);
    //  // cout << "start the iterate " << endl; 
    if (toymatrix[i]->Get_Solve_Flag()==0){
      WCP2dToy::ToyMatrixIterate toymatrix_it(*toymatrix[i], *mergetiling[i], Good_MCells.at(i-start_num));
      cout << i << " chi2: " << toymatrix[i]->Get_Chi2() <<
      " NDF: " << toymatrix[i]->Get_ndf() << endl;
    }
    //  GeomCellSelection allmcell = mergetiling[i]->get_allcell();
    //  CellChargeMap ccmap = truthtiling[i]->ccmap();
    //  if (toymatrix[i]->Get_Solve_Flag()!=0)
    //    toymetric.Add(allmcell,*toymatrix[i],ccmap);
    
    //  toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
  }

  toymetric.Print();
  // std::cout << "Starting MCMC" << std::endl;
  
//     //without  time information
//   // for (int i=start_num;i!=end_num+1;i++){
//   //   if (toymatrix[i]->Get_Solve_Flag()==0){
//   //     GeomCellSelection allmcell = mergetiling[i]->get_allcell();
//   //     WCP2dToy::ToyMatrixMarkov toymatrix_markov(*toymatrix[i],*mergetiling[i],&allmcell,Good_MCells.at(i-start_num));
//   //     //WCP2dToy::ToyMatrixMarkov toymatrix_markov(toymatrix[i],&allmcell);
//   //     CellChargeMap ccmap = truthtiling[i]->ccmap();
//   //     if (toymatrix[i]->Get_Solve_Flag()!=0)
//   // 	toymetric.Add(allmcell,*toymatrix[i],ccmap);
//   //     toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
//   //     cout << " chi2: " << i << " " << toymatrix[i]->Get_Chi2() 
//   // 	   << " NDF: " << toymatrix[i]->Get_ndf() << endl;
//   //   }
//   // }


// //with time information
//   if (start_num != end_num){
//     int first_solve=-1;
//     for (int i=start_num; i!=end_num+1;i++){
//       if (toymatrix[i]->Get_Solve_Flag()!=0){
//   	first_solve = i;
//   	break;
//       }
//     }
//     if (first_solve <0){
//       for (int i=start_num;i!=end_num+1;i++){
//   	if (toymatrix[i]->Get_Solve_Flag()==0){
//   	  GeomCellSelection allmcell = mergetiling[i]->get_allcell();
//   	  WCP2dToy::ToyMatrixMarkov toymatrix_markov(toymatrix[i],&allmcell);
//   	  CellChargeMap ccmap = truthtiling[i]->ccmap();
//   	  if (toymatrix[i]->Get_Solve_Flag()!=0)
//   	    toymetric.Add(allmcell,*toymatrix[i],ccmap);
//   	  toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
//   	  cout << "chi2: " << i << " " << toymatrix[i]->Get_Chi2() << endl;
//   	  cout << "NDF: " << toymatrix[i]->Get_ndf() << endl;
//   	}
//       }
//     }else{
//       for (int i=first_solve+1;i<=end_num-1;i++){
//   	if (toymatrix[i]->Get_Solve_Flag()==0){
//   	  GeomCellSelection allmcell = mergetiling[i]->get_allcell();
//   	  WCP2dToy::ToyMatrixMarkov toymatrix_markov(toymatrix[i-1],toymatrix[i],toymatrix[i+1],mergetiling[i-1],mergetiling[i],mergetiling[i+1],&allmcell);
//   	  CellChargeMap ccmap = truthtiling[i]->ccmap();
//   	  if (toymatrix[i]->Get_Solve_Flag()!=0)
//   	    toymetric.Add(allmcell,*toymatrix[i],ccmap);
//   	  toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
	  
//   	  cout << "chi2: " << i << " " << toymatrix[i]->Get_Chi2() << endl;
//   	  cout << "NDF: " << toymatrix[i]->Get_ndf() << endl;
	  
//   	  //toymetric.Print();
//   	}
//       }
      
//       if (toymatrix[end_num]->Get_Solve_Flag()==0){
//   	GeomCellSelection allmcell = mergetiling[end_num]->get_allcell();
//   	WCP2dToy::ToyMatrixMarkov toymatrix_markov(toymatrix[end_num-1],toymatrix[end_num],0,mergetiling[end_num-1],mergetiling[end_num],0,&allmcell);
	
	
//   	CellChargeMap ccmap = truthtiling[end_num]->ccmap();
//   	if (toymatrix[end_num]->Get_Solve_Flag()!=0)
//   	  toymetric.Add(allmcell,*toymatrix[end_num],ccmap);
//   	toymetric.AddSolve(toymatrix[end_num]->Get_Solve_Flag());
	
//   	cout << "chi2: " << end_num << " " << toymatrix[end_num]->Get_Chi2() << endl;
//   	cout << "NDF: " << toymatrix[end_num]->Get_ndf() << endl;
//       }
      
//       // go to early ones 
//       for (int i=first_solve-1;i>=start_num+1;i--){
//   	if (toymatrix[i]->Get_Solve_Flag()==0){
//   	  GeomCellSelection allmcell = mergetiling[i]->get_allcell();
//   	  WCP2dToy::ToyMatrixMarkov toymatrix_markov(toymatrix[i-1],toymatrix[i],toymatrix[i+1],mergetiling[i-1],mergetiling[i],mergetiling[i+1],&allmcell);
	  
//   	  CellChargeMap ccmap = truthtiling[i]->ccmap();
//   	  if (toymatrix[i]->Get_Solve_Flag()!=0)
//   	    toymetric.Add(allmcell,*toymatrix[i],ccmap);
//   	  toymetric.AddSolve(toymatrix[i]->Get_Solve_Flag());
	  
//   	  cout << "chi2: " << i << " " << toymatrix[i]->Get_Chi2() << endl;
//   	  cout << "NDF: " << toymatrix[i]->Get_ndf() << endl;
//   	}
//       }
      
//       if (toymatrix[start_num]->Get_Solve_Flag()==0){
//   	GeomCellSelection allmcell = mergetiling[start_num]->get_allcell();
//   	WCP2dToy::ToyMatrixMarkov toymatrix_markov(0,toymatrix[start_num],toymatrix[start_num+1],0,mergetiling[start_num],mergetiling[start_num+1],&allmcell);
	
	
//   	CellChargeMap ccmap = truthtiling[start_num]->ccmap();
//   	if (toymatrix[start_num]->Get_Solve_Flag()!=0)
//   	  toymetric.Add(allmcell,*toymatrix[start_num],ccmap);
//   	toymetric.AddSolve(toymatrix[start_num]->Get_Solve_Flag());
	
//   	cout << "chi2: " << start_num << " " << toymatrix[start_num]->Get_Chi2() << endl;
//   	cout << "NDF: " << toymatrix[start_num]->Get_ndf() << endl;
//       }
//     }
//   }


  // reset existing cluster and redo it ...
  std::cout << "Start Clustering after solving equations " << std::endl;
  cluster_dellist.clear();
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    delete (*it);
  }
  cluster_list.clear();
  
  ncount_mcell = 0;

  //Now do cluster
  for (int i=start_num;i!=end_num+1;i++){
    GeomCellSelection pallmcell = mergetiling[i]->get_allcell();
    GeomCellSelection allmcell;
    for (int j=0;j!=pallmcell.size();j++){
      const GeomCell* mcell = pallmcell[j];
      if (toymatrix[i]->Get_Cell_Charge(mcell)> recon_threshold || toymatrix[i]->Get_Solve_Flag()==0){
	allmcell.push_back(mcell);
      }
    }
    
    
    if (cluster_list.empty()){
      // if cluster is empty, just insert all the mcell, each as a cluster
      for (int j=0;j!=allmcell.size();j++){
	MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
	if (mcell->get_allcell().size()>0){
	  GeomCluster *cluster = new GeomCluster(*mcell);
	  cluster_list.push_back(cluster);
	}
      }
    }else{
      for (int j=0;j!=allmcell.size();j++){
	MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
	if (mcell->get_allcell().size()>0){
	  int flag = 0;
	  int flag_save = 0;
	  GeomCluster *cluster_save = 0;
	  cluster_dellist.clear();
	  
	  // loop through merged cell
	  int tmp_num = 0;
	  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
	    //loop through clusters
	    
	    flag += (*it)->AddCell(*mcell);
	    // std::cout << i << " " << j << " " << tmp_num << " " << flag << std::endl;
	    tmp_num ++;
	    
	    if (flag==1 && flag != flag_save){
	      cluster_save = *it;
	    }else if (flag>1 && flag != flag_save){
	      cluster_save->MergeCluster(*(*it));
	      cluster_dellist.push_back(*it);
	    }
	    flag_save = flag;
	    
	  }
	  
	  for (auto it = cluster_dellist.begin();it!=cluster_dellist.end();it++){
	    auto it1 = find(cluster_list.begin(),cluster_list.end(),*it);
	    cluster_list.erase(it1);
	    delete (*it);
	  }
	  
	  if (flag==0){
	    GeomCluster *cluster = new GeomCluster(*mcell);
	    cluster_list.push_back(cluster);
	  }
	}
	
      }
    }
    
    // int ncount_mcell_cluster = 0;
    // for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    //   ncount_mcell_cluster += (*it)->get_allcell().size();
    // }
    ncount_mcell += allmcell.size();
    //cout << i << " " << allmcell.size()  << " " << cluster_set.size()  << endl;
  }
  
  ncount_mcell_cluster = 0;
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    ncount_mcell_cluster += (*it)->get_allcell().size();
  }
  cout << "Summary: " << ncount << " " << ncount_mcell << " " << ncount_mcell_cluster << endl;
  
  // reset crawler ... 
  for (int i =0; i!=crawlers.size();i++){
    delete crawlers.at(i);
  }
  crawlers.clear();
  for (int i=0;i!=all_msc_cells.size();i++){
    delete all_msc_cells.at(i);
  }
  all_msc_cells.clear();
  for (int i=0;i!=all_sc_cells.size();i++){
    delete all_sc_cells.at(i);
  }
  all_sc_cells.clear();

  // start crawler ... 

  
  // start crawler
  cout << "Start Crawling after solving equations " << endl;
  
  ncluster = 0;
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    
    MergeSpaceCellSelection mscells;
    for (int i=0; i!=(*it)->get_allcell().size();i++){
      const MergeGeomCell *mcell = (const MergeGeomCell*)((*it)->get_allcell().at(i));
      MergeSpaceCell *mscell = new MergeSpaceCell();
      all_msc_cells.push_back(mscell);
      mscell->set_mcell(mcell);
      for (int j=0;j!=mcell->get_allcell().size();j++){
  	const GeomCell *cell = mcell->get_allcell().at(j);
  	SpaceCell *space_cell = new SpaceCell(ncluster,*cell,(mcell->GetTimeSlice()*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.)*units::cm,1,unit_dis/10.*nrebin/2.*units::cm);
	all_sc_cells.push_back(space_cell);
  	mscell->AddSpaceCell(space_cell);
      }
      mscells.push_back(mscell);
    }
    WCP2dToy::ToyCrawler* toycrawler = new WCP2dToy::ToyCrawler(mscells,2);
    crawlers.push_back(toycrawler);
    
    // std::cout << ncluster << " " << toycrawler->Get_mcells_map().size() << " " << toycrawler->Get_allCT().size() << " " << toycrawler->Get_allMCT().size()  << std::endl;

    // if (toycrawler->Get_mcells_map().size()>200){
    //   TApplication theApp("theApp",&argc,argv);
    //   theApp.SetReturnFromRun(true);
      
    //   TCanvas c1("ToyMC","ToyMC",800,600);
    //   c1.Draw();
      
    //   WCP2dToy::ClusterDisplay display(c1);
    //   //display.DrawCluster(cells);
    //   display.DrawCluster(mscells);
      
      
    //   display.DrawCrawler(*toycrawler,"psame",1);
      
    //   theApp.Run();
    // }


    ncluster ++;
  }
  
  
  //check # of clusters 
  sum = 0 ;
  for (int i=0;i!=crawlers.size();i++){
    for (auto it = crawlers.at(i)->Get_mcells_map().begin(); it!= crawlers.at(i)->Get_mcells_map().end();it++){
      MergeSpaceCell *mcell1 = it->first;
      sum += mcell1->Get_all_spacecell().size();
    }
  }
  
  std::cout << "Check: " << crawlers.size() << " "  << sum << std::endl;


  //save files
  TFile *file = new TFile(Form("shower3D_cluster_%d_%d.root",eve_num, int(round(rotate_angle/3.1415926*180.))),"RECREATE");
  TTree *t_true = new TTree("T_true","T_true");
  TTree *t_rec = new TTree("T_rec","T_rec");
  TTree *t_rec_charge = new TTree("T_rec_charge","T_rec_charge");
  TTree *t_rec_charge_blob = new TTree("T_rec_charge_blob","T_rec_charge_blob");

  Double_t x_save, y_save, z_save;
  Double_t charge_save;
  Double_t ncharge_save;
  Double_t chi2_save;
  Double_t ndf_save;
  Double_t type_save;
  
  t_true->SetDirectory(file);
  t_true->Branch("x",&x_save,"x/D");
  t_true->Branch("y",&y_save,"y/D");
  t_true->Branch("z",&z_save,"z/D");
  t_true->Branch("q",&charge_save,"q/D");
  
  t_rec->SetDirectory(file);
  t_rec->Branch("x",&x_save,"x/D");
  t_rec->Branch("y",&y_save,"y/D");
  t_rec->Branch("z",&z_save,"z/D");
  
  t_rec_charge->SetDirectory(file);
  t_rec_charge->Branch("x",&x_save,"x/D");
  t_rec_charge->Branch("y",&y_save,"y/D");
  t_rec_charge->Branch("z",&z_save,"z/D");
  t_rec_charge->Branch("q",&charge_save,"q/D");
  t_rec_charge->Branch("nq",&ncharge_save,"nq/D");
  t_rec_charge->Branch("chi2",&chi2_save,"chi2/D");
  t_rec_charge->Branch("ndf",&ndf_save,"ndf/D");

  //blob stuff
  t_rec_charge_blob->SetDirectory(file);
  t_rec_charge_blob->Branch("x",&x_save,"x/D");
  t_rec_charge_blob->Branch("y",&y_save,"y/D");
  t_rec_charge_blob->Branch("z",&z_save,"z/D");
  t_rec_charge_blob->Branch("q",&charge_save,"q/D");
  t_rec_charge_blob->Branch("nq",&ncharge_save,"nq/D");

  if (save_image_outline_flag==1){
    t_rec->Branch("type",&type_save,"type/D");
    t_rec_charge->Branch("type",&type_save,"type/D");
    t_rec_charge_blob->Branch("type",&type_save,"type/D");
  }
  
  TGraph2D *g = new TGraph2D();
  TGraph2D *gt = new TGraph2D();
  TGraph2D *g_rec = new TGraph2D();
  TGraph2D *g_rec_blob = new TGraph2D();

  //save results 
  for (int i=start_num;i!=end_num+1;i++){
    //truth
    CellChargeMap ccmap = truthtiling_th[i]->ccmap();
    for (auto it = ccmap.begin();it!=ccmap.end(); it++){
      Point p = it->first->center();
      x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
      y_save = p.y/units::cm;
      z_save = p.z/units::cm;
      charge_save = it->second;
      
      gt->SetPoint(ncount_t,x_save,y_save,z_save);
      t_true->Fill();
      
      ncount_t ++;
    }
    
    //recon 1
    GeomCellSelection allmcell = mergetiling[i]->get_allcell();
    for (int j=0;j!=allmcell.size();j++){
      MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];

      if (save_image_outline_flag==1){
	Point p = mcell->get_allcell().at(0)->center();
	x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	y_save = p.y/units::cm;
	z_save = p.z/units::cm;
	g->SetPoint(ncount,x_save,y_save,z_save);
	ncount ++;
	type_save = 1; //center
	t_rec->Fill();
	
	for (int k=0;k!=mcell->get_edgecells().size();k++){
	  Point p = mcell->get_edgecells().at(k)->center();
	  y_save = p.y/units::cm;
    	  z_save = p.z/units::cm;
	  g->SetPoint(ncount,x_save,y_save,z_save);
	  ncount ++;
	  type_save = 2; //boundary ...
	  t_rec->Fill();
	}
	for (int k=0;k!=mcell->get_allcell().size();k++){
    	  Point p = mcell->get_allcell().at(k)->center();
	  x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	  y_save = p.y/units::cm;
    	  z_save = p.z/units::cm;
	  type_save = 0;
	  t_rec->Fill();
	 
	}

      }else{
	for (int k=0;k!=mcell->get_allcell().size();k++){
    	  Point p = mcell->get_allcell().at(k)->center();
	  x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	  y_save = p.y/units::cm;
    	  z_save = p.z/units::cm;
	  g->SetPoint(ncount,x_save,y_save,z_save);
	  ncount ++;
	  t_rec->Fill();
	 
	}
      }
    }
    // GeomCellSelection allcell = toytiling[i]->get_allcell();
    // for (int j=0;j!=allcell.size();j++){
    //   Point p = allcell[j]->center();
    //   x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
    //   y_save = p.y/units::cm;
    //   z_save = p.z/units::cm;
      

    //   g->SetPoint(ncount,x_save,y_save,z_save);
    //   t_rec->Fill();

    //   ncount ++;
    // }
    
    //recon 2 with charge
    //GeomCellSelection allmcell = mergetiling[i]->get_allcell();
    for (int j=0;j!=allmcell.size();j++){
      MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
      double charge = toymatrix[i]->Get_Cell_Charge(mcell,1);
      if (charge> recon_threshold || toymatrix[i]->Get_Solve_Flag()==0){

    	if (toymatrix[i]->Get_Solve_Flag()==0)
	  charge = toytiling[i]->get_ave_charge();

	if (save_image_outline_flag==1){
	  Point p = mcell->get_allcell().at(0)->center();
	  x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	  y_save = p.y/units::cm;
	  z_save = p.z/units::cm;
	  charge_save = charge;
	  ncharge_save = mcell->get_allcell().size();
	  chi2_save = toymatrix[i]->Get_Chi2();
	  ndf_save = toymatrix[i]->Get_ndf();
	  g_rec->SetPoint(ncount1,x_save,y_save,z_save);
	  ncount1 ++;
	  type_save = 1; //center
	  t_rec_charge->Fill();

	  charge_save = 0;
	  ncharge_save = 0;
	  chi2_save= 0;
	  ndf_save = 0;

	  for (int k=0;k!=mcell->get_edgecells().size();k++){
	    Point p = mcell->get_edgecells().at(k)->center();
	    y_save = p.y/units::cm;
	    z_save = p.z/units::cm;
	    g_rec->SetPoint(ncount1,x_save,y_save,z_save);
	    ncount1 ++;
	    type_save = 2; //boundary ...
	    t_rec_charge->Fill();
	  }

	  for (int k=0;k!=mcell->get_allcell().size();k++){
	    Point p = mcell->get_allcell().at(k)->center();
	    x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	    y_save = p.y/units::cm;
	    z_save = p.z/units::cm;
	    charge_save = charge/mcell->get_allcell().size();
	    ncharge_save = mcell->get_allcell().size();
	    chi2_save = toymatrix[i]->Get_Chi2();
	    ndf_save = toymatrix[i]->Get_ndf();
	    type_save = 0;
	    t_rec_charge->Fill();
	  }

	}else{
	  for (int k=0;k!=mcell->get_allcell().size();k++){
	    Point p = mcell->get_allcell().at(k)->center();
	    x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	    y_save = p.y/units::cm;
	    z_save = p.z/units::cm;
	    charge_save = charge/mcell->get_allcell().size();
	    ncharge_save = mcell->get_allcell().size();
	    chi2_save = toymatrix[i]->Get_Chi2();
	    ndf_save = toymatrix[i]->Get_ndf();
	    
	    g_rec->SetPoint(ncount1,x_save,y_save,z_save);
	    t_rec_charge->Fill();
	    
	    ncount1 ++;
	  }
	}
      }
    }
    
    // for (int j=0;j!=allmcell.size();j++){
    //   MergeGeomCell *mcell = (MergeGeomCell*)allmcell[j];
    //   double charge = toymatrix[i]->Get_Cell_Charge(mcell,1);
    //   if (charge> recon_threshold || toymatrix[i]->Get_Solve_Flag()==0){
    // 	if (toymatrix[i]->Get_Solve_Flag()==0)
    // 	  charge = toytiling[i]->get_ave_charge();

    // 	for (int k=0;k!=mcell->get_allcell().size();k++){
    // 	  Point p = mcell->get_allcell().at(k)->center();
    // 	  x_save = i*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
    // 	  y_save = p.y/units::cm;
    // 	  z_save = p.z/units::cm;
    // 	  charge_save = charge/mcell->get_allcell().size();
    // 	  ncharge_save = mcell->get_allcell().size();
	  
    // 	  g_rec_blob->SetPoint(ncount2,x_save,y_save,z_save);
    // 	  t_rec_charge_blob->Fill();
	  
    // 	  ncount2 ++;
    // 	}
    //   }
    // }


  }
 
  

  
  
  // // const int N = 100000;
  // // Double_t x[N],y[N],z[N];
  // Double_t x,y,z;
  // //save cluster
  // ncluster = 0;
  // for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
  //   ncount = 0;
  //   TGraph2D *g1 = new TGraph2D();
  //   for (int i=0; i!=(*it)->get_allcell().size();i++){
  //     const MergeGeomCell *mcell = (const MergeGeomCell*)((*it)->get_allcell().at(i));
  //     for (int j=0; j!=mcell->get_allcell().size();j++){
  // 	Point p = mcell->get_allcell().at(j)->center();
  // 	x = mcell->GetTimeSlice()*nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
  // 	y = p.y/units::cm;
  // 	z = p.z/units::cm;
  // 	g1->SetPoint(ncount,x,y,z);
  // 	ncount ++;
  //     }
  //   }
  //   // cout << ncount << endl;
  //   g1->Write(Form("cluster_%d",ncluster));
  //   ncluster ++;
  // }


  // save all the toy tiling stuff
  WCP2dToy::ToyTiling* tt1 = 0;
  int time_slice;
  
  TTree* ttree = new TTree("T","T");
  ttree->Branch("time_slice",&time_slice,"time_slice/I");
  ttree->Branch("toytiling",&tt1);
  ttree->SetDirectory(file);
  for (int i=start_num;i!=end_num+1;i++){
    tt1 = toytiling[i];
    time_slice = i;
    ttree->Fill();
  }
  ttree->Write();

  TTree *ttree1 = new TTree("TC","TC");
  // To save cluster, we need to save
  // 1. time slice
  // 2. single cell
  // 3. charge
  // 4. cluster number
  const GeomCell* cell_save = 0;
  int cluster_num = -1;
  int mcell_id = -1;
  
  ttree1->Branch("time_slice",&time_slice,"time_slice/I"); // done
  ttree1->Branch("cell",&cell_save);
  ttree1->Branch("ncluster",&cluster_num,"cluster_num/I"); //done
  ttree1->Branch("mcell_id",&mcell_id,"mcell_id/I");
  ttree1->Branch("charge",&charge_save,"charge/D"); 
  double xx,yy,zz;
  ttree1->Branch("xx",&xx,"xx/D");    //don
  ttree1->Branch("yy",&yy,"yy/D");    //don
  ttree1->Branch("zz",&zz,"zz/D");    //don

  // ttree1->Branch("x",&x_save,"x/D");    //done
  //ttree1->Branch("y",&y_save,"y/D");
  //ttree1->Branch("z",&z_save,"z/D");
  

   // save information to reconstruct the toytiling
  int u_index, v_index, w_index;
  double u_charge, v_charge, w_charge;
  double u_charge_err, v_charge_err, w_charge_err;
  
  int apa_no=0, cryostat_no=0;
  ttree1->Branch("apa_no",&apa_no,"apa_no/I");
  int face = 0;
  ttree1->Branch("face",&face,"face/I");
  ttree1->Branch("cryostat_no",&cryostat_no,"cryostat_no/I");

  ttree1->Branch("u_index",&u_index,"u_index/I");
  ttree1->Branch("v_index",&v_index,"v_index/I");
  ttree1->Branch("w_index",&w_index,"w_index/I");
  
  ttree1->Branch("u_charge",&u_charge,"u_charge/D");
  ttree1->Branch("v_charge",&v_charge,"v_charge/D");
  ttree1->Branch("w_charge",&w_charge,"w_charge/D");

  ttree1->Branch("u_charge_err",&u_charge_err,"u_charge_err/D");
  ttree1->Branch("v_charge_err",&v_charge_err,"v_charge_err/D");
  ttree1->Branch("w_charge_err",&w_charge_err,"w_charge_err/D");

  //end save 


  ttree1->SetDirectory(file);
  
  for (auto it = cluster_list.begin();it!=cluster_list.end();it++){
    cluster_num ++;
    //loop merged cell
    for (int i=0; i!=(*it)->get_allcell().size();i++){
      const MergeGeomCell *mcell = (const MergeGeomCell*)((*it)->get_allcell().at(i));
      mcell_id ++;
      time_slice = mcell->GetTimeSlice();
      x_save = time_slice *nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
      xx = x_save;
      //loop single cell
      for (int j=0; j!=mcell->get_allcell().size();j++){
	cell_save = mcell->get_allcell().at(j);

	//fill the information needed for toytiling
	GeomWireSelection wires = toytiling[time_slice]->wires(*cell_save);
	
	//	if (i==0 && j==0) cout << "abc: " << time_slice << " " << toytiling[time_slice]->get_allcell().size() << " " << wires.size() << endl;

	for (int k=0;k!=wires.size();k++){
	  const GeomWire *wire = wires.at(k);
	  WirePlaneType_t plane = wire->plane();
	  if (plane==0){
	    u_index = wire->index();
	    u_charge = toytiling[time_slice]->wcmap()[wire];
	    u_charge_err = toytiling[time_slice]->wcemap()[wire];
	  }else if (plane==1){
	    v_index = wires.at(k)->index();
	    v_charge = toytiling[time_slice]->wcmap()[wire];
	    v_charge_err = toytiling[time_slice]->wcemap()[wire];
	  }else if (plane==2){
	    w_index = wire->index();
	    w_charge = toytiling[time_slice]->wcmap()[wire];
	    w_charge_err = toytiling[time_slice]->wcemap()[wire];
	  }
	}
	//end fill


	Point p = mcell->get_allcell().at(j)->center();
	//hack for now
	charge_save = toymatrix[time_slice]->Get_Cell_Charge(mcell,1)/mcell->cross_section() * cell_save->cross_section();
	//charge_save = 1;
	
	//std::cout << time_slice << " " << x_save << std::endl;
	yy = p.y/units::cm;
  	zz = p.z/units::cm;
	ttree1->Fill();

	if (save_image_outline_flag==0){
	  //save the g_rec_blob tree ... 
	  x_save = xx;
	  y_save = yy;
	  z_save = zz;
	  ncharge_save = mcell->get_allcell().size();
	  g_rec_blob->SetPoint(ncount2,x_save,y_save,z_save);
	  ncount2++;
	  t_rec_charge_blob->Fill();
	}else if (save_image_outline_flag==1){
	   //save the g_rec_blob tree ... 
	  x_save = xx;
	  y_save = yy;
	  z_save = zz;
	  ncharge_save = mcell->get_allcell().size();
	  type_save = 0;
	  t_rec_charge_blob->Fill();
	}
      }
       if (save_image_outline_flag==1){
	Point p = mcell->get_allcell().at(0)->center();
	x_save = time_slice *nrebin/2.*unit_dis/10. - frame_length/2.*unit_dis/10.;
	y_save = mcell->center().y/units::cm;
	z_save = mcell->center().z/units::cm;
	charge_save = toymatrix[time_slice]->Get_Cell_Charge(mcell,1);
	ncharge_save = mcell->get_allcell().size();
	g_rec_blob->SetPoint(ncount2,x_save,y_save,z_save);
	ncount2++;
	type_save = 1;
	t_rec_charge_blob->Fill();
	
	charge_save = 0;
	ncharge_save = 0;
	
	for (int k=0;k!=mcell->get_edgecells().size();k++){
	  Point p = mcell->get_edgecells().at(k)->center();
	  y_save = p.y/units::cm;
	  z_save = p.z/units::cm;
	  g_rec_blob->SetPoint(ncount2,x_save,y_save,z_save);
	  ncount2 ++;
	  type_save = 2; //boundary ...
	  t_rec_charge_blob->Fill();
	}
      }

    }
  }
  ttree1->Write();
  g->Write("shower3D");
  gt->Write("shower3D_truth");
  g_rec->Write("shower3D_charge");
  g_rec_blob->Write("shower3D_charge_blob");
 
  TTree *Trun = new TTree("Trun","Trun");
  Trun->SetDirectory(file);
  
  int detector = 0; // MicroBooNE
  Trun->Branch("detector",&detector,"detector/I");

  Trun->Branch("eventNo",&event_no,"eventNo/I");
  Trun->Branch("runNo",&run_no,"runNo/I");
  Trun->Branch("subRunNo",&subrun_no,"runRunNo/I");


  Trun->Branch("unit_dis",&unit_dis,"unit_dis/F");
  Trun->Branch("toffset_uv",&toffset_1,"toffset_uv/F");
  Trun->Branch("toffset_uw",&toffset_2,"toffset_uw/F");
  Trun->Branch("toffset_u",&toffset_3,"toffset_u/F");
  Trun->Branch("total_time_bin",&total_time_bin,"total_time_bin/I");
  Trun->Branch("recon_threshold",&recon_threshold,"recon_threshold/I");
  Trun->Branch("frame_length",&frame_length,"frame_length/I");
  Trun->Branch("max_events",&max_events,"max_events/I");
  Trun->Branch("eve_num",&eve_num,"eve_num/I");
  Trun->Branch("nrebin",&nrebin,"nrebin/I");
  Trun->Branch("threshold_u",&threshold_u,"threshold_u/F");
  Trun->Branch("threshold_v",&threshold_v,"threshold_v/F");
  Trun->Branch("threshold_w",&threshold_w,"threshold_w/F");
  Trun->Branch("time_offset",&time_offset,"time_offset/I");

   pitch_u = pitch_u/units::cm;
  pitch_v = pitch_v/units::cm;
  pitch_w = pitch_w/units::cm;
  Trun->Branch("pitch_u",&pitch_u,"pitch_u/D");
  Trun->Branch("pitch_v",&pitch_v,"pitch_v/D");
  Trun->Branch("pitch_w",&pitch_w,"pitch_w/D");

  Trun->Fill();

  file->Write();
  file->Close();

  toymetric.Print();
  blobmetric.Print();

  // cin >> abc;
  
  return 0;
  
} // main()
