LMD/TFndLmdMon.cxx

// @(#)fROOT/LMD:$Name:  $:$Id: TFndLmdMon.cxx,v 1.37 2007/09/24 07:32:41 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>

//                TFndLmdMon                 //
//                                           //
//  - LMD-Histogram collection and filling   //
//  - LMD shared memories management         //
//                                           //
// (see GTS relative class for descriptions) //
//                                           //

#include <TF1.h>
#include <TSystem.h>

#include "TFndRun.h"
#include "TFndRunConfiguration.h"
#include "TFndGenInfo.h"
#include "TFndHLmd.h"
#include "TFndHdt.h"
#include "TFndLmdMon.h"

ClassImp(TFndLmdMon)

//______________________________________
TFndLmdMon::TFndLmdMon(const TString &fmode,Int_t lmd_adc_bins,Double_t lmd_adc_min,Double_t lmd_adc_max,Int_t lmd_tdc_bins,Double_t lmd_tdc_min,Double_t lmd_tdc_max):
  fout(),flmd(),
  mlmd(),mlmd_adc(),mlmd_tdc(),
  fMustRecoverHistos(kFALSE),
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  lmdmult(),lmdmult_good(),lmd_i_o_mult(),lmdmap(),lmdmap_good(),lmdmapadc0(),lmdmapadc(),lmdmapadce(),lmdmapadcp(),
  lmdmaptdc0(),lmdmaptdc(),lmdmaptdce(),lmdmaptdcp(),
  lmd_all_mapadctdc(),lmd_all_adc_tdc(),lmd_all_adce(),lmd_all_adcp(),lmd_all_mul(),
  lmd_all_aepat(),lmd_all_appat(),lmd_all_tepat(),lmd_all_tppat(),
  lmd_all_vp(),lmd_all_crg(),lmd_all_zet(),lmd_all_adc(),lmd_all_tdce(),lmd_all_tdcp(),lmd_all_tdf(),lmd_all_tmean(),lmd_all_tdc(),
  lmd_all_dhits(),lmd_all_dhits_tdc_dopp(),lmd_all_dhits_adc_dopp(),lmd_all_dhits_tdc_cell(),lmd_all_dhits_adc_cell(),
  lmdadce(),lmdadcp(),lmdcrg(),lmdzet(),lmdtdce(),lmdtdcp(),lmdtdf(),lmdtmean(),
  lmd1d(),lmd2d(),fLine()
{
  
  Init();
  OpenSharedFiles(fmode);
  InitHistos(lmd_adc_bins,lmd_adc_min,lmd_adc_max,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);  

}

//______________________________________
TFndLmdMon::TFndLmdMon():
  fout(),flmd(),
  mlmd(),mlmd_adc(),mlmd_tdc(),
  fMustRecoverHistos(kFALSE),
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  lmdmult(),lmdmult_good(),lmd_i_o_mult(),lmdmap(),lmdmap_good(),lmdmapadc0(),lmdmapadc(),lmdmapadce(),lmdmapadcp(),
  lmdmaptdc0(),lmdmaptdc(),lmdmaptdce(),lmdmaptdcp(),
  lmd_all_mapadctdc(),lmd_all_adc_tdc(),lmd_all_adce(),lmd_all_adcp(),lmd_all_mul(),
  lmd_all_aepat(),lmd_all_appat(),lmd_all_tepat(),lmd_all_tppat(),
  lmd_all_vp(),lmd_all_crg(),lmd_all_zet(),lmd_all_adc(),lmd_all_tdce(),lmd_all_tdcp(),lmd_all_tdf(),lmd_all_tmean(),lmd_all_tdc(),
  lmd_all_dhits(),lmd_all_dhits_tdc_dopp(),lmd_all_dhits_adc_dopp(),lmd_all_dhits_tdc_cell(),lmd_all_dhits_adc_cell(),
  lmdadce(),lmdadcp(),lmdcrg(),lmdzet(),lmdtdce(),lmdtdcp(),lmdtdf(),lmdtmean(),
  lmd1d(),lmd2d(),fLine()
{
  // This constructor was used by the consumer,
  // but now there is no need to open the shared memory
  // in read/update mode here... commented all (Diego - 03/03/2005)
  Init();

}

//______________________________________
TFndLmdMon::TFndLmdMon(const TFndLmdMon &lmdmon):
  fout(),flmd(),
  mlmd(),mlmd_adc(),mlmd_tdc(),
  fMustRecoverHistos(kFALSE),
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  lmdmult(),lmdmult_good(),lmd_i_o_mult(),lmdmap(),lmdmap_good(),lmdmapadc0(),lmdmapadc(),lmdmapadce(),lmdmapadcp(),
  lmdmaptdc0(),lmdmaptdc(),lmdmaptdce(),lmdmaptdcp(),
  lmd_all_mapadctdc(),lmd_all_adc_tdc(),lmd_all_adce(),lmd_all_adcp(),lmd_all_mul(),
  lmd_all_aepat(),lmd_all_appat(),lmd_all_tepat(),lmd_all_tppat(),
  lmd_all_vp(),lmd_all_crg(),lmd_all_zet(),lmd_all_adc(),lmd_all_tdce(),lmd_all_tdcp(),lmd_all_tdf(),lmd_all_tmean(),lmd_all_tdc(),
  lmd_all_dhits(),lmd_all_dhits_tdc_dopp(),lmd_all_dhits_adc_dopp(),lmd_all_dhits_tdc_cell(),lmd_all_dhits_adc_cell(),
  lmdadce(),lmdadcp(),lmdcrg(),lmdzet(),lmdtdce(),lmdtdcp(),lmdtdf(),lmdtmean(),
  lmd1d(),lmd2d(),fLine()
{
  //
  Init();
}

//______________________________________
TFndLmdMon::TFndLmdMon(TString *filename):
  fout(),flmd(),
  mlmd(),mlmd_adc(),mlmd_tdc(),
  fMustRecoverHistos(kFALSE),
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  lmdmult(),lmdmult_good(),lmd_i_o_mult(),lmdmap(),lmdmap_good(),lmdmapadc0(),lmdmapadc(),lmdmapadce(),lmdmapadcp(),
  lmdmaptdc0(),lmdmaptdc(),lmdmaptdce(),lmdmaptdcp(),
  lmd_all_mapadctdc(),lmd_all_adc_tdc(),lmd_all_adce(),lmd_all_adcp(),lmd_all_mul(),
  lmd_all_aepat(),lmd_all_appat(),lmd_all_tepat(),lmd_all_tppat(),
  lmd_all_vp(),lmd_all_crg(),lmd_all_zet(),lmd_all_adc(),lmd_all_tdce(),lmd_all_tdcp(),lmd_all_tdf(),lmd_all_tmean(),lmd_all_tdc(),
  lmd_all_dhits(),lmd_all_dhits_tdc_dopp(),lmd_all_dhits_adc_dopp(),lmd_all_dhits_tdc_cell(),lmd_all_dhits_adc_cell(),
  lmdadce(),lmdadcp(),lmdcrg(),lmdzet(),lmdtdce(),lmdtdcp(),lmdtdf(),lmdtmean(),
  lmd1d(),lmd2d(),fLine()
{

  Init();

  flmd = new TFile(filename->Data());
  TString hname = TString("lmdmult");
  lmdmult = (TH1F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmult_good");
  lmdmult_good = (TH1F *) flmd->Get(hname.Data()); 
  hname = TString("lmd_i_o_mult");
  lmd_i_o_mult = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmap");
  lmdmap = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmap_good");
  lmdmap_good = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmapadc0");
  lmdmapadc0 = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmapadc");
  lmdmapadc = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmapadce");
  lmdmapadce = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmapadcp");
  lmdmapadcp = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmaptdc0");
  lmdmaptdc0 = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmaptdc");
  lmdmaptdc = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmaptdce");
  lmdmaptdce = (TH2F *) flmd->Get(hname.Data()); 
  hname = TString("lmdmaptdcp");
  lmdmaptdcp = (TH2F *) flmd->Get(hname.Data()); 

  for (Int_t i=0;i<K_N_LMD_LAYERS;i++) {    
    //    cout << "Layer: " << i+1 << endl;
    for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {     
      //cout << "Chamber: " << j+1 << endl;
      Int_t nwire = K_N_LMD_INNER_WIRES;
      if(i == 1) nwire = K_N_LMD_OUTER_WIRES;
      
      Int_t idx1 = j+i*K_N_LMD_CHAMS_PER_LAYER;
      //cout << "idx1: " << idx1 << endl;
      Char_t chname[20];
      sprintf(chname,"_%d_%d",i+1,j+1);

      hname = TString("lmd_all_mapadctdc");
      hname.Append(chname);
      lmd_all_mapadctdc[idx1] = (TH2F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_zet");
      hname.Append(chname);
      lmd_all_zet[idx1] = (TH2F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_crg");
      hname.Append(chname);
      lmd_all_crg[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      // 
      // prove Elena
      hname = TString("lmd_all_vp");
      hname.Append(chname);
      lmd_all_vp[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      // 
      hname = TString("lmd_all_adce");
      hname.Append(chname);
      lmd_all_adce[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_adcp");
      hname.Append(chname);
      lmd_all_adcp[idx1] = (TH1F *) flmd->Get(hname.Data()); 

      hname = TString("lmd_all_mul");
      hname.Append(chname);
      lmd_all_mul[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      //
      hname = TString("lmd_all_aepat");
      hname+=chname;
      lmd_all_aepat[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      
      hname = TString("lmd_all_appat");
      hname+=chname;
      lmd_all_appat[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      
      hname = TString("lmd_all_tepat");
      hname+=chname;
      lmd_all_tepat[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      
      hname = TString("lmd_all_tppat");
      hname+=chname;
      lmd_all_tppat[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      
      //
      hname = TString("lmd_all_adc");
      hname.Append(chname);
      lmd_all_adc[idx1] = (TH2F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_adc_tdc");
      hname.Append(chname);
      lmd_all_adc_tdc[idx1] = (TH2F *) flmd->Get(hname.Data()); 

      hname = TString("lmd_all_tdce");
      hname.Append(chname);
      lmd_all_tdce[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_tdcp");
      hname.Append(chname);
      lmd_all_tdcp[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_tdf");
      hname.Append(chname);
      lmd_all_tdf[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_tmean");
      hname.Append(chname);
      lmd_all_tmean[idx1] = (TH1F *) flmd->Get(hname.Data()); 
      hname = TString("lmd_all_tdc");
      hname.Append(chname);
      lmd_all_tdc[idx1] = (TH2F *) flmd->Get(hname.Data()); 

      
      for (Int_t l=0;l<nwire;l++) {
        //cout << "Wire: " << l+1 << endl;
        Int_t idx = l+j*nwire+i*K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER;
        Char_t chname[20];
        sprintf(chname,"_%d_%d_%d",i+1,j+1,l+1);
        
        hname = TString("lmdtdce");
        hname.Append(chname);
        lmdtdce[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdtdcp");
        hname.Append(chname);
        lmdtdcp[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdtmean");
        hname.Append(chname);
        lmdtmean[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdtdf");
        hname.Append(chname);
        lmdtdf[idx] = (TH1F *) flmd->Get(hname.Data()); 
        
        hname = TString("lmdadce");
        hname.Append(chname);
        lmdadce[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdadcp");
        hname.Append(chname);
        lmdadcp[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdcrg");
        hname.Append(chname);
        lmdcrg[idx] = (TH1F *) flmd->Get(hname.Data()); 
        hname = TString("lmdzet");
        hname.Append(chname);
        lmdzet[idx] = (TH1F *) flmd->Get(hname.Data()); 
      }
    }
  }
  //  flmd->Close();

  lmd1d = 0;
  lmd2d = 0;
  fLine = 0;
}

//______________________________________
TFndLmdMon::~TFndLmdMon() {
  
  delete fLine;

  delete lmdmult;
  delete lmdmult_good; // LMD selected multiplicity
  delete lmd_i_o_mult;   // LMD multiplicity
  delete lmdmap;         // LMD map
  delete lmdmap_good;         // LMD map

  delete lmdmapadc0; // LMD ADC map (e || p |= 0)
  delete lmdmapadc;   // LMD ADC map (e && p != 0)
  delete lmdmapadce;  // LMD e-side ADC map
  delete lmdmapadcp;  // LMD p-side ADC map

  delete lmdmaptdc0;  // LMD TDC map (e || p |= 0) 
  delete lmdmaptdc;    // LMD TDC map (e && p != 0)  
  delete lmdmaptdce;  // LMD e-side TDC map   
  delete lmdmaptdcp;  // LMD p-side TDC map  

  for(Int_t i=0; i<K_N_LMD_TOT_CHAMS; i++) {
    delete lmd_all_mapadctdc[i];           // LMD ADC vs TDC existence 
    delete lmd_all_adc_tdc[i];        // LMD ADC vs TDC 
    delete lmd_all_adce[i];           // e-side ADC
    delete lmd_all_adcp[i];           // p-side  ADC
    delete lmd_all_mul[i];
    delete lmd_all_aepat[i];
    delete lmd_all_appat[i];
    delete lmd_all_tepat[i];
    delete lmd_all_tppat[i];
    delete lmd_all_crg[i];            // ADC (e+p)
    delete lmd_all_vp[i];            // propag. velocity
    delete lmd_all_zet[i];            // ADC (e-p)/(e+p)
    delete lmd_all_adc[i];            // ADC (e-side vs p-side)      
    delete lmd_all_tdce[i];           // e-side TDC
    delete lmd_all_tdcp[i];           // p-side  TDC
    delete lmd_all_tdf[i];            // Time difference
    delete lmd_all_tmean[i];          // (Te+Tp)/2
    delete lmd_all_tdc[i];            // TDC (e-side vs p-side)
    
    delete lmd_all_dhits[i];          // Double Lmd Hits
    delete lmd_all_dhits_tdc_dopp[i]; // Double Lmd Hits TDC
    delete lmd_all_dhits_adc_dopp[i]; // Double Lmd Hits ADC
    delete lmd_all_dhits_tdc_cell[i]; // Double Lmd Hits TDC
    delete lmd_all_dhits_adc_cell[i];  // Double Lmd Hits ADC
  }
  for(Int_t i=0; i<n_lmd_hist; i++) {
    delete lmdadce[i];           // e-side ADC
    delete lmdadcp[i];           // p-side  ADC
    delete lmdcrg[i];            // ADC (e+p)
    delete lmdzet[i];            // ADC (e-p)/(e+p)
    delete lmdtdce[i];           // e-side TDC
    delete lmdtdcp[i];           // p-side  TDC
    delete lmdtdf[i];            // Time difference
    delete lmdtmean[i];          // (Te+Tp)/2
  }

  if(! shmflg){
    if(flmd) flmd->Close();
    delete flmd;
  }
  
  if(fout) fout->Close();
  delete fout;

  if(mlmd){ mlmd->Close(); mlmd = 0; }
  else delete mlmd;
  
  for(Int_t kk=0;kk<2;kk++){
    if(mlmd_adc[kk]){ mlmd_adc[kk]->Close(); mlmd_adc[kk] = 0; }
    else delete mlmd_adc[kk];
  }
  
  //   if(mlmd_o_adc){ mlmd_o_adc->Close(); mlmd_o_adc = 0; }
  //   else delete mlmd_o_adc;
  
  for(Int_t kk=0;kk<2;kk++){
    if(mlmd_tdc[kk]){ mlmd_tdc[kk]->Close(); mlmd_tdc[kk] = 0; }
    else delete mlmd_tdc[kk];  
  }
  
}

//______________________________________
void TFndLmdMon::Init(){
  
  fZetaAdjust[0] = LmdZetaGeoAdjust(E_FIN_INNER_LAYER);
  fZetaAdjust[1] = LmdZetaGeoAdjust(E_FIN_OUTER_LAYER);
  
  fSharedMemName_Main   = FROOT::ExpandPathName("$FND_SHR/lmd.map");
  fSharedMemName_Adc[0] = FROOT::ExpandPathName("$FND_SHR/lmd_i_adc.map");
  fSharedMemName_Adc[1] = FROOT::ExpandPathName("$FND_SHR/lmd_o_adc.map");
  fSharedMemName_Tdc[0] = FROOT::ExpandPathName("$FND_SHR/lmd_i_tdc.map");
  fSharedMemName_Tdc[1] = FROOT::ExpandPathName("$FND_SHR/lmd_o_tdc.map");
  
  fSharedFileName_Main   = FROOT::ExpandPathName("lmd.file.map");
  fSharedFileName_Adc[0] = FROOT::ExpandPathName("lmd_i_adc.file.map");
  fSharedFileName_Adc[1] = FROOT::ExpandPathName("lmd_o_adc.file.map");
  fSharedFileName_Tdc[0] = FROOT::ExpandPathName("lmd_i_tdc.file.map");
  fSharedFileName_Tdc[1] = FROOT::ExpandPathName("lmd_o_tdc.file.map");

}

//______________________________________
void TFndLmdMon::InitHistos(const Int_t &lmd_adc_bins,const Double_t &lmd_adc_min,const Double_t &lmd_adc_max,const Int_t &lmd_tdc_bins,const Double_t &lmd_tdc_min,const Double_t &lmd_tdc_max){
  // try to recover histograms from shared file (if still available...)

  if(shmflg && ( !mlmd || !mlmd_adc[0] || !mlmd_adc[1] || !mlmd_tdc[0] || !mlmd_tdc[1]) ){
    Warning("InitHistos","Map-files not available: exiting method");
    return;
  }

  TString hname;
  TString htitle;

  if(shmflg) mlmd->cd();

  hname = "lmdmult";
  htitle = "Lmd multiplicity";
  lmdmult = (fMustRecoverHistos) ? 
    ((TH1F*) (mlmd->Get(hname))) :
    new TH1F(hname,htitle,200,-0.5,199.5);
  
  hname = "lmdmult_good";
  htitle = "Lmd selected mult.";
  lmdmult_good = (fMustRecoverHistos) ? 
    ((TH1F*) (mlmd->Get(hname))) :
    new TH1F(hname,htitle,20,-0.5,19.5);

  hname = "lmd_i_o_mult";
  htitle = "Lmd inner vs outer mult.";
  lmd_i_o_mult = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,10,-0.5,9.5,10,-0.5,9.5);

  hname = "lmdmap";
  htitle = "Lmd Hit Map (Wire vs Drift Number)";
  lmdmap = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmap_good";
  htitle = "Lmd Selected Hit Map (Wire vs Drift Number)";
  lmdmap_good = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmapadc0";
  htitle = "Lmd ADC map (e||p!=0)";
  lmdmapadc0 = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmapadc";
  htitle = "Lmd ADC map (e&&p!=0)";
  lmdmapadc = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmapadce";
  htitle = "Lmd ADC map (e-side)";
  lmdmapadce = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmapadcp";
  htitle = "Lmd ADC map (p-side)";
  lmdmapadcp = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   
  
  // ---

  hname = "lmdmaptdc0";
  htitle = "Lmd TDC map (e||p!=0)";
  lmdmaptdc0 = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmaptdc";
  htitle = "Lmd TDC map (e&&p!=0)";
  lmdmaptdc = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmaptdce";
  htitle = "Lmd TDC map (e-side)";
  lmdmaptdce = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  hname = "lmdmaptdcp";
  htitle = "Lmd TDC map (p-side)";
  lmdmaptdcp = (fMustRecoverHistos) ? 
    ((TH2F*) (mlmd->Get(hname))) :
    new TH2F(hname,htitle,20,10.5,30.5,24,0.5,24.5);   

  // ---  
  
  for (Int_t ji=0;ji<K_N_LMD_LAYERS;ji++) {     
    for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {
      Int_t id = K_N_LMD_CHAMS_PER_LAYER*ji + j;     
      hname.Form("lmd_all_mapadctdc_%d_%d",ji+1,j+1);
      htitle.Form("ADC E/P vs TDC E/P, dch %d, layer %d",j+1,ji+1);
      lmd_all_mapadctdc[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,4,-0.5,3.5,4,-0.5,3.5);
      
      hname.Form("lmd_all_adc_tdc_%d_%d",ji+1,j+1);
      htitle.Form("ADC vs TDC, dch %d, layer %d",j+1,ji+1);
      lmd_all_adc_tdc[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,50,lmd_tdc_min,lmd_tdc_max,50,lmd_adc_min,lmd_adc_max);
      
      hname.Form("lmd_all_dhits_%d_%d",ji+1,j+1);
      htitle.Form("Wire with Dij = -1, dch %d, layer %d",j+1,ji+1);
      lmd_all_dhits[id] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd->Get(hname))) :
        new TH1F(hname,htitle,22,0.5,22.5);
      
      hname.Form("lmd_all_dhits_tdc_dopp_%d_%d",ji+1,j+1);
      htitle.Form("T(i) vs T(i+1), dch %d, layer %d",j+1,ji+1);
      lmd_all_dhits_tdc_dopp[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,lmd_tdc_bins/4,lmd_tdc_min,lmd_tdc_max,lmd_tdc_bins/4,lmd_tdc_min,lmd_tdc_max);
      
      hname.Form("lmd_all_dhits_tdc_cell_%d_%d",ji+1,j+1);
      htitle.Form("T(i) vs T(i+1), dch %d, layer %d",j+1,ji+1);
      lmd_all_dhits_tdc_cell[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,lmd_tdc_bins/4,lmd_tdc_min,lmd_tdc_max,lmd_tdc_bins/4,lmd_tdc_min,lmd_tdc_max);
      
      hname.Form("lmd_all_dhits_adc_dopp_%d_%d",ji+1,j+1);
      htitle.Form("Q(i) vs Q(i+1) for dch: %d in layer: %d",j+1,ji+1);
      lmd_all_dhits_adc_dopp[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,lmd_adc_bins/4,lmd_adc_min,2.*lmd_adc_max,lmd_adc_bins/4,lmd_adc_min,2.*lmd_adc_max);
      
      hname.Form("lmd_all_dhits_adc_cell_%d_%d",ji+1,j+1);
      htitle.Form("Q(i) vs Q(i+1) (cell), dch %d, layer %d",j+1,ji+1);
      lmd_all_dhits_adc_cell[id] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd->Get(hname))) :
        new TH2F(hname,htitle,lmd_adc_bins/4,lmd_adc_min,2.*lmd_adc_max,lmd_adc_bins/4,lmd_adc_min,2.*lmd_adc_max);
      
      // ---
      Int_t nwir = K_N_LMD_INNER_WIRES;
      if(ji==1) nwir = K_N_LMD_OUTER_WIRES;
      hname.Form("lmd_all_mul_%d_%d",ji+1,j+1);
      htitle.Form("Multiplicity, dch %d, layer %d",j+1,ji+1);
      lmd_all_mul[id] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd->Get(hname))) :
        new TH1F(hname,htitle,nwir+1,-0.5,nwir+0.5);
      lmd_all_mul[id]->SetLineColor(4); // break here in recovery
      lmd_all_mul[id]->SetLineWidth(2);
    }
  }   
  
  //   LMD  ADC    

  for(Int_t kk=0;kk<K_N_LMD_LAYERS;kk++) {
    
    Int_t nwires = 12 + kk*10;
    if(shmflg) mlmd_adc[kk]->cd();

    for (Int_t jj=0;jj<K_N_LMD_CHAMS_PER_LAYER;jj++) {     
      Int_t j = K_N_LMD_CHAMS_PER_LAYER*kk+jj;
      hname.Form("lmd_all_adce_%d_%d",kk+1,jj+1);
      htitle.Form("ADC e-side, dch %d, layer %d",jj+1,kk+1);
      lmd_all_adce[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_adc_bins,lmd_adc_min,lmd_adc_max);
      lmd_all_adce[j]->SetLineColor(4);
      
      hname.Form("lmd_all_adcp_%d_%d",kk+1,jj+1);
      htitle.Form("ADC p-side, dch %d, layer %d",jj+1,kk+1);
      lmd_all_adcp[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_adc_bins,lmd_adc_min,lmd_adc_max);
      lmd_all_adcp[j]->SetLineColor(2); 

      Int_t nwir = K_N_LMD_INNER_WIRES;
      if(kk==1) nwir = K_N_LMD_OUTER_WIRES;

      //
      hname.Form("lmd_all_aepat_%d_%d",kk+1,jj+1);
      htitle.Form("Wire-Patt (ADC-e), dch %d, layer %d",jj+1,kk+1);
      lmd_all_aepat[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,nwir+1,-0.5,nwir+0.5);
      lmd_all_aepat[j]->SetLineColor(4);
      lmd_all_aepat[j]->SetLineWidth(2);

      hname.Form("lmd_all_appat_%d_%d",kk+1,jj+1);
      htitle.Form("Wire-Patt (ADC-p), dch %d, layer %d",jj+1,kk+1);
      lmd_all_appat[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,nwir+1,-0.5,nwir+0.5);
      lmd_all_appat[j]->SetLineColor(4);
      lmd_all_appat[j]->SetLineWidth(2);

      //     
      hname.Form("lmd_all_crg_%d_%d",kk+1,jj+1);
      htitle.Form("ADC (e+p)-side, dch %d, layer %d",jj+1,kk+1);
      lmd_all_crg[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_adc_bins,2*lmd_adc_min,2*lmd_adc_max);
      lmd_all_crg[j]->SetFillColor(9);

      // prove Elena      
      hname.Form("lmd_all_vp_%d_%d",kk+1,jj+1);
      htitle.Form("Drift velocity, dch %d, layer %d",jj+1,kk+1);
      lmd_all_vp[j] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
        new TH1F(hname,htitle,60,0.,30.);
      lmd_all_vp[j]->SetFillColor(4);
      // 
      hname.Form("lmd_all_zet_%d_%d",kk+1,jj+1);
      htitle.Form("Time vs Z, dch %d, layer %d",jj+1,kk+1);
      lmd_all_zet[j] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd_adc[kk]->Get(hname))) :
        new TH2F(hname,htitle,101,-fZetaAdjust[kk],fZetaAdjust[kk],lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max/2);
      
      hname.Form("lmd_all_adc_%d_%d",kk+1,jj+1);
      htitle.Form("ADC e vs p-side, dch %d, layer %d",jj+1,kk+1);
      lmd_all_adc[j] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd_adc[kk]->Get(hname))) :
        new TH2F(hname,htitle,lmd_adc_bins,lmd_adc_min,lmd_adc_max,lmd_adc_bins,lmd_adc_min,lmd_adc_max);
      
      for (Int_t l=0;l<nwires;l++) {
        
        Int_t k = K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*kk+l+jj*nwires;
        
        hname.Form("lmdadce_%d_%d_%d",kk+1,jj+1,l+1);
        htitle.Form("ADC e-side, wire %d, dch %d, layer %d",l+1,jj+1,kk+1);
        lmdadce[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_adc_bins,lmd_adc_min,lmd_adc_max);
        lmdadce[k]->SetLineColor(4); 
        
        hname.Form("lmdadcp_%d_%d_%d",kk+1,jj+1,l+1);
        htitle.Form("ADC p-side, wire %d, dch %d, layer %d",l+1,jj+1,kk+1);
        lmdadcp[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_adc_bins,lmd_adc_min,lmd_adc_max);
        lmdadcp[k]->SetLineColor(2); 
        
        hname.Form("lmdcrg_%d_%d_%d",kk+1,jj+1,l+1);
        htitle.Form("ADC (e+p)-side, wire %d, dch %d, layer %d",l+1,jj+1,kk+1);
        lmdcrg[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_adc_bins,2*lmd_adc_min,2*lmd_adc_max);
        lmdcrg[k]->SetFillColor(9);
        
        hname.Form("lmdzet_%d_%d_%d",kk+1,jj+1,l+1);
        htitle.Form("zeta (cm), wire %d, dch %d, layer %d",l+1,jj+1,kk+1);
        lmdzet[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_adc[kk]->Get(hname))) :
          new TH1F(hname,htitle,101,-fZetaAdjust[kk],fZetaAdjust[kk]);
      }
    }
    
    //   LMD    TDC
    if(shmflg) mlmd_tdc[kk]->cd();
    
    for (Int_t jk=0;jk<K_N_LMD_CHAMS_PER_LAYER;jk++) {     
      Int_t ij = K_N_LMD_CHAMS_PER_LAYER*kk+jk;
      hname.Form("lmd_all_tdce_%d_%d",kk+1,jk+1);
      htitle.Form("TDC e-side, dch %d, layer %d",jk+1,kk+1);
      lmd_all_tdce[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
      lmd_all_tdce[ij]->SetLineColor(4);
      
      hname.Form("lmd_all_tdcp_%d_%d",kk+1,jk+1);
      htitle.Form("TDC p-side, dch %d, layer %d",jk+1,kk+1);
      lmd_all_tdcp[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
      lmd_all_tdcp[ij]->SetLineColor(2); 
      
      hname.Form("lmd_all_tdf_%d_%d",kk+1,jk+1);
      htitle.Form("TDC (e-p)-side, dch %d, layer %d",jk+1,kk+1);
      lmd_all_tdf[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,25,-50.,50.);
      lmd_all_tdf[ij]->SetFillColor(9);
      
      hname.Form("lmd_all_tmean_%d_%d",kk+1,jk+1);
      htitle.Form("TDC (e+p-side)/2, dch %d, layer %d",jk+1,kk+1);
      lmd_all_tmean[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
      lmd_all_tmean[ij]->SetFillColor(7);
      
      hname.Form("lmd_all_tdc_%d_%d",kk+1,jk+1);
      htitle.Form("TDC e vs p side, dch %d, layer %d",jk+1,kk+1);
      lmd_all_tdc[ij] = (fMustRecoverHistos) ? 
        ((TH2F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH2F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);

      Int_t nwir = K_N_LMD_INNER_WIRES;
      if(kk==1) nwir = K_N_LMD_OUTER_WIRES;

      hname.Form("lmd_all_tepat_%d_%d",kk+1,jk+1);
      htitle.Form("Wire-Patt (TDC-e), dch %d, layer %d",jk+1,kk+1);
      lmd_all_tepat[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,nwir+1,-0.5,nwir+0.5);
      lmd_all_tepat[ij]->SetLineColor(4);
      lmd_all_tepat[ij]->SetLineWidth(2);
      
      hname.Form("lmd_all_tppat_%d_%d",kk+1,jk+1);
      htitle.Form("Wire-Patt (TDC-p), dch %d, layer %d",jk+1,kk+1);
      lmd_all_tppat[ij] = (fMustRecoverHistos) ? 
        ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
        new TH1F(hname,htitle,nwir+1,-0.5,nwir+0.5);
      lmd_all_tppat[ij]->SetLineColor(4);
      lmd_all_tppat[ij]->SetLineWidth(2);

      for (Int_t l=0;l<nwires;l++) {
        Int_t k = K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*kk+l+jk*nwires;
        
        hname.Form("lmdtdce_%d_%d_%d",kk+1,jk+1,l+1);
        htitle.Form("TDC e-side, wire %d, dch %d, layer %d",l+1,jk+1,kk+1);
        lmdtdce[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
        lmdtdce[k]->SetLineColor(4); 
        
        hname.Form("lmdtdcp_%d_%d_%d",kk+1,jk+1,l+1);
        htitle.Form("TDC p-side, wire %d, dch %d, layer %d",l+1,jk+1,kk+1);
        lmdtdcp[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
        lmdtdcp[k]->SetLineColor(2);      
        
        hname.Form("lmdtdf_%d_%d_%d",kk+1,jk+1,l+1);
        htitle.Form("TDC (e-p)-side, wire %d, dch %d, layer %d",l+1,jk+1,kk+1);
        //      lmdtdf[k] = new TH1F(hname,htitle,100,-50,50);
        lmdtdf[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
          new TH1F(hname,htitle,20,-40.,40.);
        lmdtdf[k]->SetFillColor(9);
        
        hname.Form("lmdtmean_%d_%d_%d",kk+1,jk+1,l+1);
        htitle.Form("TDC (e+p -side)/2, wire %d, dch %d, layer %d",l+1,jk+1,kk+1);
        lmdtmean[k] = (fMustRecoverHistos) ? 
          ((TH1F*) (mlmd_tdc[kk]->Get(hname))) :
          new TH1F(hname,htitle,lmd_tdc_bins,lmd_tdc_min,lmd_tdc_max);
        lmdtmean[k]->SetFillColor(9);
      }
    }
  }

}


//______________________________________
void TFndLmdMon::OpenSharedFiles(const TString &fmode){
  // will handle shared memories/files creation
   
  shmflg = fndrun->Onlflg();
  cout << "Lmd Shm flag is " << shmflg << endl;

  TString fhist = "_lmd.root";
  
  TString lmdnam_str = (fmode.IsNull())? "ONLM" : fmode;
  lmdnam_str+=fhist;

  flmd = 0;
  flmd = new TFile(lmdnam_str.Data(),"RECREATE","Lmd Histogram File");   
  
  mlmd = 0;
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    mlmd = TMapFile::Create(fSharedMemName_Main,"RECREATE",(Int_t)(1048576*FROOT::K_LmdMapSize),"Lmd memory mapped file with histograms");
    mlmd->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    if(gSystem->AccessPathName(fSharedFileName_Main)){
      cout << "Shared file missing: creating it now..." << endl;
      mlmd = new TFile(fSharedFileName_Main,"RECREATE");
    }
    else{
      cout << "Shared file found: histograms will be recovered..." << endl;
      mlmd = TFile::Open(fSharedFileName_Main,"UPDATE");
      fMustRecoverHistos = kTRUE;
      //mlmd->ls();
    }
#endif
  }

  for(Int_t kk=0;kk<K_N_LMD_LAYERS;kk++) {
    
    //   LMD  ADC    
    if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
      mlmd_adc[kk] = TMapFile::Create(fSharedMemName_Adc[kk],"RECREATE",(Int_t)(1048576*FROOT::K_LmdIadcMapSize),"Lmd memory mapped file with INNER ADC histograms");
      mlmd_adc[kk]->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
      if( gSystem->AccessPathName(fSharedFileName_Adc[kk]) && fMustRecoverHistos == kTRUE){
        cout << "Shared file missing: creating it now..." << endl;
        mlmd_adc[kk] = new TFile(fSharedFileName_Adc[kk],"RECREATE");
        fMustRecoverHistos = kFALSE;
      }
      else{
        cout << "Shared file found: histograms will be recovered..." << endl;
        mlmd_adc[kk] = TFile::Open(fSharedFileName_Adc[kk],"UPDATE");
        //mlmd_adc[kk]->ls();
      }
#endif
    }
    
    //   LMD    TDC
    if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
      mlmd_tdc[kk] = TMapFile::Create(fSharedMemName_Tdc[kk],"RECREATE",(Int_t)(1048576*FROOT::K_LmdItdcMapSize),"Lmd memory mapped file with INNER TDC histograms");
      mlmd_tdc[kk]->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
      if( gSystem->AccessPathName(fSharedFileName_Tdc[kk]) && fMustRecoverHistos == kTRUE){
        cout << "Shared file missing: creating it now..." << endl;
        mlmd_tdc[kk] = new TFile(fSharedFileName_Tdc[kk],"RECREATE");
        fMustRecoverHistos = kFALSE;
      }
      else{
        cout << "Shared file found: histograms will be recovered..." << endl;
        mlmd_tdc[kk] = TFile::Open(fSharedFileName_Tdc[kk],"UPDATE");
        //mlmd_tdc[kk]->ls();
      }
#endif
    }
    
  }
  
}

//______________________________________
void TFndLmdMon::Fill() {
  
  TClonesArray *cl = fndrun->GetCurrentHdt()->GetLmdHits();
  Fill(*cl);
  
}

//______________________________________
void TFndLmdMon::Fill(const TClonesArray &LmdHits) {
 
  Int_t nhlmd = LmdHits.GetEntries();
  lmdmult->Fill((Float_t) nhlmd);   // multiplicity before selection

  Int_t jgood = 0;
  Int_t n_inn = 0;
  Int_t n_out = 0;
  Int_t DchMul[K_N_LMD_TOT_CHAMS] = {0};

  for (Int_t j=0; j<nhlmd; j++) {
    TFndHLmd *hlmd = (TFndHLmd*) LmdHits[j];
    
    Int_t lay = hlmd->GetLayer();
    Int_t dch = hlmd->GetChamber();
    Int_t wire = hlmd->GetWire();
    
    Int_t dch_index = (10 *lay) + dch;
    
    Float_t ae = (Float_t ) hlmd->GetAdcE();
    Float_t ap = (Float_t ) hlmd->GetAdcP();
    Float_t te = (Float_t ) hlmd->GetTdcE();
    Float_t tp = (Float_t ) hlmd->GetTdcP();
    Float_t loc_z = hlmd->GetLocal_Z();    


    if(ap <=0 && ae <=0 && tp <=0 && te <=0) continue; // simply a (safe) check

    //if(te*tp != 0. && ae+ap == 0) hlmd->Print();
    Float_t tmean = (te+tp) /2;
    //

    //
    // Pedestal subtraction 
    //

    Float_t pede = 0.;
    Float_t pedp = 0.;
    Float_t t0e = 0.;
    Float_t t0p = 0.;

    Bool_t i_ae_ok = kFALSE;
    Bool_t i_ap_ok = kFALSE;
    Bool_t i_te_ok = kFALSE;
    Bool_t i_tp_ok = kFALSE;     
    if(ae > 0)i_ae_ok = kTRUE; // D. Faso (still not using database)
    if(ap > 0)i_ap_ok = kTRUE; // D. Faso (still not using database)
    if(te > 0)i_te_ok = kTRUE; // D. Faso (still not using database)
    if(tp > 0)i_tp_ok = kTRUE; // D. Faso (still not using database)

    // keeping "i_*_ok" for further selection-modes

    //     if(lmd_det && fndrun->RunConfiguration()->LmdPedestalSubtraction()) {
    //       pede = lmd_det->PedE(dch_index/10,dch_index%10,wire);
    //       pedp = lmd_det->PedP(dch_index/10,dch_index%10,wire);
    //       ae -= pede; ap -= pedp;
    //       //      cout << "ae: " << ae << ", ap: " << ap << endl;
    
    //       // Bad ADC
    //       //attenzione PG!      
    //       if(ae < 10. || ae > 4097.-pede) iaebad = 1;
    //       if(ap < 10. || ap > 4097.-pedp) iapbad = 1;
    //     }
    
    
    //     if(lmd_det) {
    //       t0e = lmd_det->TZeroE(dch_index/10,dch_index%10,wire);
    //       t0p = lmd_det->TZeroP(dch_index/10,dch_index%10,wire);
    
    // Bad TDC
    
    //   if(te < 900. || (te > t0e && t0e > 0.)) itebad = 1;
    //   if(tp < 900. || (tp > t0p && t0p > 0.)) itpbad = 1;     
    // attenzione PG!
    //     if((te > t0e && t0e > 0.) || te < (t0e-K_DRIFT_MAX_TIME)) itebad = 1;
    //     if((tp > t0p && t0p > 0.) || tp < (t0p-K_DRIFT_MAX_TIME)) itpbad = 1;
    //     }
    
    // Charge Scaling
    //     if(lmd_det && fndrun->RunConfiguration()->LmdChargeEqualisation()) {
    //       Float_t che = lmd_det->ChargeE(dch_index/10,dch_index%10,wire); 
    //       Float_t chp = lmd_det->ChargeP(dch_index/10,dch_index%10,wire);
    //       if(che) ae *= che;
    //       if(chp) ap *= chp;
    //       //      cout << "ae: " << ae << ", ap: " << ap << endl;
    //     }
    
    Int_t il = 0;
    Int_t sf = 0;
    Int_t idx = 0;
    Int_t nwire = 0;
    if(dch_index >= 11 && dch_index <= 18) { 
      sf = dch_index-11;
      il = 0;
      nwire = 12;
    }
    if(dch_index >=21 && dch_index <= 28) {
      sf = dch_index-21;
      il = 1;
      nwire = 22;
    }
    idx = sf+K_N_LMD_CHAMS_PER_LAYER*il;    
    
    Int_t itdc = TFndHit::E_HIT_NO_CH;
    if(i_te_ok  &&  i_tp_ok) itdc = TFndHit::E_HIT_BOTH_CH;
    if(i_te_ok  && !i_tp_ok) itdc = TFndHit::E_HIT_E_CH;
    if(!i_te_ok &&  i_tp_ok) itdc = TFndHit::E_HIT_P_CH;
    
    Int_t iadc = TFndHit::E_HIT_NO_CH;
    if(i_ae_ok  &&  i_ap_ok) iadc = TFndHit::E_HIT_BOTH_CH;
    if(i_ae_ok  && !i_ap_ok) iadc = TFndHit::E_HIT_E_CH;
    if(!i_ae_ok &&  i_ap_ok) iadc = TFndHit::E_HIT_P_CH;

    
    if( iadc != TFndHit::E_HIT_NO_CH || itdc != TFndHit::E_HIT_NO_CH ) DchMul[idx]++;
    if( iadc == TFndHit::E_HIT_BOTH_CH || iadc == TFndHit::E_HIT_E_CH ) lmd_all_aepat[idx]->Fill(wire);
    if( iadc == TFndHit::E_HIT_BOTH_CH || iadc == TFndHit::E_HIT_P_CH ) lmd_all_appat[idx]->Fill(wire);
    if( itdc == TFndHit::E_HIT_BOTH_CH || itdc == TFndHit::E_HIT_E_CH ) lmd_all_tepat[idx]->Fill(wire);
    if( itdc == TFndHit::E_HIT_BOTH_CH || itdc == TFndHit::E_HIT_P_CH ) lmd_all_tppat[idx]->Fill(wire);

    //
    // MOLTO IMPORTANTE !!!
    if( iadc != TFndHit::E_HIT_NO_CH || itdc != TFndHit::E_HIT_NO_CH ) lmd_all_mapadctdc[idx]->Fill(itdc,iadc);
    //
    if(ae>=0 && te >=0) lmd_all_adc_tdc[idx]->Fill(te,ae);

    jgood++; // no selection for now
    if(iadc == TFndHit::E_HIT_BOTH_CH && itdc == TFndHit::E_HIT_BOTH_CH ) lmdmap_good->Fill((Float_t) dch_index,(Float_t) wire);
    if(iadc!=TFndHit::E_HIT_NO_CH && itdc!=TFndHit::E_HIT_NO_CH && iadc==itdc){ // at least one side ADC && TDC
      lmdmap->Fill((Float_t) dch_index,(Float_t) wire);
    }
    
    if(iadc!=TFndHit::E_HIT_NO_CH || itdc!=TFndHit::E_HIT_NO_CH){ // at least one ADC or TDC
      if(dch_index >= 11 && dch_index <= 18) n_inn++;
      if(dch_index >= 21 && dch_index <= 28) n_out++;
    }

    // Fill histograms

    if(iadc != TFndHit::E_HIT_NO_CH)   lmdmapadc0->Fill((Float_t) dch_index,(Float_t) wire); // or
    if(iadc == TFndHit::E_HIT_BOTH_CH) lmdmapadc ->Fill((Float_t) dch_index,(Float_t) wire); // and
    if(i_ae_ok) lmdmapadce->Fill((Float_t) dch_index,(Float_t) wire); // e-side
    if(i_ap_ok) lmdmapadcp->Fill((Float_t) dch_index,(Float_t) wire); // p-side
    
    if(itdc != TFndHit::E_HIT_NO_CH) lmdmaptdc0->Fill((Float_t) dch_index,(Float_t) wire); // or
    if(itdc == TFndHit::E_HIT_BOTH_CH) lmdmaptdc ->Fill((Float_t) dch_index,(Float_t) wire); // and
    if(i_te_ok) lmdmaptdce->Fill((Float_t) dch_index,(Float_t) wire); // e-side
    if(i_tp_ok) lmdmaptdcp->Fill((Float_t) dch_index,(Float_t) wire); // p-side
    
    if(ae >=0) lmd_all_adce[idx]->Fill(ae);
    if(ap >=0) lmd_all_adcp[idx]->Fill(ap);
    if(ae >=0 && ap >=0){
      lmd_all_adc[idx]->Fill(ap,ae);
      lmd_all_crg[idx]->Fill(ae+ap);
    }
    //     Float_t zeta = 0.;
    if(ae >0 && ap >0) {
      //       zeta = fZetaAdjust[dch_index/10-1]*(ae-ap)/(ae+ap);
      lmd_all_zet[idx]->Fill(loc_z,tmean);
    }
    
    if(te >=0) lmd_all_tdce[idx]->Fill(te);
    if(tp >=0) lmd_all_tdcp[idx]->Fill(tp);
    if (te >0 && tp >0){
      lmd_all_tdc[idx]->Fill(tp,te);
      lmd_all_tdf[idx]->Fill(te-tp);
      lmd_all_tmean[idx]->Fill(tmean);
    }
    
    //     Float_t time_e = 0.;
    //     Float_t time_p = 0.;
    //     Float_t vp = 0.;
    //    if(fndrun->RunConfiguration()->LmdZeroTimeSubtraction()) {
    //      time_e = t0e - te;  // tempo di deriva lato e in tdc ch.
    //       time_p = t0p - tp;  // tempo di deriva lato p in tdc ch.
    //       vp = - 2. * zeta / (time_e - time_p);
    //       if(ae+ap != 0 && time_e > -15. && time_p > -15.) lmd_all_vp[idx]->Fill(vp);
    //     }

    // wire histograms

    sf = wire-1+nwire*sf+K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*il;
    
    if(ae >=0) lmdadce[sf]->Fill(ae);
    if(ap >=0) lmdadcp[sf]->Fill(ap);
    if(ae >=0 && ap >=0){
      lmdcrg[sf]->Fill(ae+ap);
      lmdzet[sf]->Fill(loc_z);
    }

    if(te >=0) lmdtdce[sf]->Fill(te); // November 29, 2006 ( if(te) )
    if(tp >=0) lmdtdcp[sf]->Fill(tp);
    if (te >0 && tp >0){
      lmdtdf[sf]->Fill(te-tp);
      lmdtmean[sf]->Fill(tmean);          
    }
  }
  lmdmult_good->Fill((Float_t) jgood);
  lmd_i_o_mult->Fill((Float_t) n_out,(Float_t) n_inn);

  for(Int_t id=0;id<K_N_LMD_TOT_CHAMS;id++) lmd_all_mul[id]->Fill(DchMul[id]);
}

//______________________________________
void TFndLmdMon::Update(Bool_t purge) {

#if defined _FND_ONL_USE_MAP_FILES_
  mlmd->Update();
  if(mlmd_adc[0] && mlmd_adc[0]->IsWritable() ) mlmd_adc[0]->Update();
  if(mlmd_tdc[0] && mlmd_tdc[0]->IsWritable() ) mlmd_tdc[0]->Update();
  if(mlmd_adc[1] && mlmd_adc[1]->IsWritable() ) mlmd_adc[1]->Update();
  if(mlmd_tdc[1] && mlmd_tdc[1]->IsWritable() ) mlmd_tdc[1]->Update();
#elif defined _FND_ONL_USE_SHARED_FILES_
  WriteToFile(0,kTRUE);

  mlmd->cd();
  if(purge) mlmd->Purge();
  mlmd->Flush();
  //
  mlmd_adc[0]->cd();
  if(purge) mlmd_adc[0]->Purge();
  mlmd_adc[0]->Flush();
  //
  mlmd_adc[1]->cd();
  if(purge) mlmd_adc[1]->Purge();
  mlmd_adc[1]->Flush();
  //
  mlmd_tdc[0]->cd();
  if(purge) mlmd_tdc[0]->Purge();
  mlmd_tdc[0]->Flush();
  //
  mlmd_tdc[1]->cd();
  if(purge) mlmd_tdc[1]->Purge();
  mlmd_tdc[1]->Flush();
  //

  // --- copy shared files from here to shared directory
  //     (NFS safe)
  TString comm_cp = "";
  comm_cp.Form("cp ./lmd.file.map %s",FROOT::ExpandPathName("$FND_SHR/lmd.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./lmd_i_adc.file.map %s",FROOT::ExpandPathName("$FND_SHR/lmd_i_adc.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./lmd_o_adc.file.map %s",FROOT::ExpandPathName("$FND_SHR/lmd_o_adc.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./lmd_i_tdc.file.map %s",FROOT::ExpandPathName("$FND_SHR/lmd_i_tdc.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./lmd_o_tdc.file.map %s",FROOT::ExpandPathName("$FND_SHR/lmd_o_tdc.file.map").Data());
  gSystem->Exec(comm_cp);



#endif  

  Info("Update","LMD histograms updated (producer)");

}

//______________________________________
void TFndLmdMon::ResetHistos(){

  if(lmdmult) lmdmult->Reset();
  if(lmdmult_good) lmdmult_good->Reset();
  if(lmd_i_o_mult) lmd_i_o_mult->Reset();
  if(lmdmap) lmdmap->Reset();
  if(lmdmap_good) lmdmap_good->Reset();
  if(lmdmapadc0) lmdmapadc0->Reset();
  if(lmdmapadc) lmdmapadc->Reset();
  if(lmdmapadce) lmdmapadce->Reset();
  if(lmdmapadcp) lmdmapadcp->Reset();
  if(lmdmaptdc0) lmdmaptdc0->Reset();
  if(lmdmaptdc) lmdmaptdc->Reset();
  if(lmdmaptdce) lmdmaptdce->Reset();
  if(lmdmaptdcp) lmdmaptdcp->Reset();

  for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {     
    for(Int_t ik=0;ik<2;ik++) {
      Int_t jk = ik*K_N_LMD_CHAMS_PER_LAYER + j;
      if(lmd_all_mapadctdc[jk]) lmd_all_mapadctdc[jk]->Reset();
      if(lmd_all_adc_tdc[jk]) lmd_all_adc_tdc[jk]->Reset();
      if(lmd_all_dhits[jk]) lmd_all_dhits[jk]->Reset();
      if(lmd_all_dhits_tdc_dopp[jk]) lmd_all_dhits_tdc_dopp[jk]->Reset();
      if(lmd_all_dhits_tdc_cell[jk]) lmd_all_dhits_tdc_cell[jk]->Reset();
      if(lmd_all_dhits_adc_dopp[jk]) lmd_all_dhits_adc_dopp[jk]->Reset();
      if(lmd_all_dhits_adc_cell[jk]) lmd_all_dhits_adc_cell[jk]->Reset();
      if(lmd_all_adce[jk]) lmd_all_adce[jk]->Reset();
      if(lmd_all_adcp[jk]) lmd_all_adcp[jk]->Reset();
      if(lmd_all_mul[jk]) lmd_all_mul[jk]->Reset();
      if(lmd_all_aepat[jk]) lmd_all_aepat[jk]->Reset();
      if(lmd_all_appat[jk]) lmd_all_appat[jk]->Reset();
      if(lmd_all_tepat[jk]) lmd_all_tepat[jk]->Reset();
      if(lmd_all_tppat[jk]) lmd_all_tppat[jk]->Reset();
      if(lmd_all_crg[jk]) lmd_all_crg[jk]->Reset();
      if(lmd_all_vp[jk]) lmd_all_vp[jk]->Reset();
      if(lmd_all_zet[jk]) lmd_all_zet[jk]->Reset();
      if(lmd_all_adc[jk]) lmd_all_adc[jk]->Reset();
      if(lmd_all_tdce[jk]) lmd_all_tdce[jk]->Reset();
      if(lmd_all_tdcp[jk]) lmd_all_tdcp[jk]->Reset();
      if(lmd_all_tdf[jk]) lmd_all_tdf[jk]->Reset();
      if(lmd_all_tmean[jk]) lmd_all_tmean[jk]->Reset();
      if(lmd_all_tdc[jk]) lmd_all_tdc[jk]->Reset();
    }

    for (Int_t l=0;l<(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);l++) {
      Int_t k = l+j*(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);
      if(lmdadce[k]) lmdadce[k]->Reset();
      if(lmdadcp[k]) lmdadcp[k]->Reset();
      if(lmdcrg[k]) lmdcrg[k]->Reset();
      if(lmdzet[k]) lmdzet[k]->Reset();
      // if(lmdadc[k]) lmdadc[k]->Reset();
      if(lmdtdce[k]) lmdtdce[k]->Reset();
      if(lmdtdcp[k]) lmdtdcp[k]->Reset();
      if(lmdtdf[k]) lmdtdf[k]->Reset();
      if(lmdtmean[k]) lmdtmean[k]->Reset();
      // if(lmdtdc[k]) lmdtdc[k]->Reset();
    }
  }       

}

//______________________________________
void TFndLmdMon::WriteToFile(TString file,Bool_t IsShared) {
  // COMPLETARE per files in online-mode

  if(IsShared){
    //    Info("TFndLmdMon::WriteToFile","Writing histograms in on-line mode");
    mlmd->cd();
  }
  else{
    if(file.IsNull()) 
      flmd->cd();
    else {
      fout = new TFile(file.Data(),"RECREATE","Lmd Histogram File");
      fout->cd();
    }
  }
  
  if(lmdmult) lmdmult->Write();
  if(lmdmult_good) lmdmult_good->Write();
  if(lmd_i_o_mult) lmd_i_o_mult->Write();
  if(lmdmap) lmdmap->Write();
  if(lmdmap_good) lmdmap_good->Write();
  if(lmdmapadc0) lmdmapadc0->Write();
  if(lmdmapadc) lmdmapadc->Write();
  if(lmdmapadce) lmdmapadce->Write();
  if(lmdmapadcp) lmdmapadcp->Write();
  if(lmdmaptdc0) lmdmaptdc0->Write();
  if(lmdmaptdc) lmdmaptdc->Write();
  if(lmdmaptdce) lmdmaptdce->Write();
  if(lmdmaptdcp) lmdmaptdcp->Write();
  
  for (Int_t ji=0;ji<K_N_LMD_LAYERS;ji++) {     
    for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {
      Int_t id = K_N_LMD_CHAMS_PER_LAYER*ji + j;     
      lmd_all_mapadctdc[id]->Write();
      lmd_all_adc_tdc[id]->Write();
      lmd_all_dhits[id]->Write();
      lmd_all_dhits_tdc_dopp[id]->Write();
      lmd_all_dhits_tdc_cell[id]->Write();
      lmd_all_dhits_adc_dopp[id]->Write();
      lmd_all_dhits_adc_cell[id]->Write();
      lmd_all_mul[id]->Write();
    }
  }   
  
  for(Int_t kk=0;kk<K_N_LMD_LAYERS;kk++) {
    Int_t nwires = 12 + kk*10;

    //ADC
    if(IsShared){
      //      Info("TFndLmdMon::WriteToFile","Writing histograms in on-line mode (ADCs: layer %d)",kk);
      mlmd_adc[kk]->cd();
      //       if(kk==0) mlmd_adc[0]->cd();
      //       else mlmd_o_adc->cd();
    }
    for (Int_t jj=0;jj<K_N_LMD_CHAMS_PER_LAYER;jj++) {     
      Int_t j = K_N_LMD_CHAMS_PER_LAYER*kk+jj;
      lmd_all_adce[j]->Write();
      lmd_all_adcp[j]->Write();

      Int_t nwir = K_N_LMD_INNER_WIRES;
      if(kk==1) nwir = K_N_LMD_OUTER_WIRES;
      lmd_all_crg[j]->Write();
      lmd_all_vp[j]->Write();
      lmd_all_zet[j]->Write();
      lmd_all_adc[j]->Write();
      lmd_all_aepat[j]->Write();
      lmd_all_appat[j]->Write();
      
      for (Int_t l=0;l<nwires;l++) {
        Int_t k = K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*kk+l+jj*nwires;   
        lmdadce[k]->Write();
        lmdadcp[k]->Write();
        lmdcrg[k]->Write();
        lmdzet[k]->Write();
      }
    }

    //TDC
    if(IsShared) mlmd_tdc[kk]->cd();

    for (Int_t jk=0;jk<K_N_LMD_CHAMS_PER_LAYER;jk++) {     
      Int_t ij = K_N_LMD_CHAMS_PER_LAYER*kk+jk;
      lmd_all_tdce[ij]->Write();
      lmd_all_tdcp[ij]->Write();
      lmd_all_tdf[ij]->Write();
      lmd_all_tmean[ij]->Write();
      lmd_all_tdc[ij]->Write();
      lmd_all_tepat[ij]->Write();
      lmd_all_tppat[ij]->Write();
      
      for (Int_t l=0;l<nwires;l++) {
        Int_t k = K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*kk+l+jk*nwires;
        
        lmdtdce[k]->Write();
        lmdtdcp[k]->Write();
        lmdtdf[k]->Write();
        lmdtmean[k]->Write();
      }
    }
  }
  
  //   for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {     
  //     for(Int_t ik=0;ik<2;ik++) {
  //       Int_t jk = ik*K_N_LMD_CHAMS_PER_LAYER + j;
  //       if(lmd_all_mapadctdc[jk]) lmd_all_mapadctdc[jk]->Write();
  //       if(lmd_all_adc_tdc[jk]) lmd_all_adc_tdc[jk]->Write();
  //       if(lmd_all_dhits[jk]) lmd_all_dhits[jk]->Write();
  //       if(lmd_all_dhits_tdc_dopp[jk]) lmd_all_dhits_tdc_dopp[jk]->Write();
  //       if(lmd_all_dhits_tdc_cell[jk]) lmd_all_dhits_tdc_cell[jk]->Write();
  //       if(lmd_all_dhits_adc_dopp[jk]) lmd_all_dhits_adc_dopp[jk]->Write();
  //       if(lmd_all_dhits_adc_cell[jk]) lmd_all_dhits_adc_cell[jk]->Write();
  //       if(lmd_all_adce[jk]) lmd_all_adce[jk]->Write();
  //       if(lmd_all_adcp[jk]) lmd_all_adcp[jk]->Write();
  //       if(lmd_all_adceped[jk]) lmd_all_adceped[jk]->Write();
  //       if(lmd_all_adcpped[jk]) lmd_all_adcpped[jk]->Write();
  //       if(lmd_all_crg[jk]) lmd_all_crg[jk]->Write();
  //       if(lmd_all_vp[jk]) lmd_all_vp[jk]->Write();
  //       if(lmd_all_zet[jk]) lmd_all_zet[jk]->Write();
  //       if(lmd_all_adc[jk]) lmd_all_adc[jk]->Write();
  //       if(lmd_all_tdce[jk]) lmd_all_tdce[jk]->Write();
  //       if(lmd_all_tdcp[jk]) lmd_all_tdcp[jk]->Write();
  //       if(lmd_all_tdf[jk]) lmd_all_tdf[jk]->Write();
  //       if(lmd_all_tmean[jk]) lmd_all_tmean[jk]->Write();
  //       if(lmd_all_tdc[jk]) lmd_all_tdc[jk]->Write();
  //     }
  //   }
  //
  //     for (Int_t l=0;l<(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);l++) {
  //       Int_t k = l+j*(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);
  //       if(lmdadce[k]) lmdadce[k]->Write();
  //       if(lmdadcp[k]) lmdadcp[k]->Write();
  //       if(lmdcrg[k]) lmdcrg[k]->Write();
  //       if(lmdzet[k]) lmdzet[k]->Write();
  //       // if(lmdadc[k]) lmdadc[k]->Write();
  //     }
  //     for (Int_t l=0;l<(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);l++) {
  //       Int_t k = l+j*(K_N_LMD_INNER_WIRES+K_N_LMD_OUTER_WIRES);
  //       if(lmdtdce[k]) lmdtdce[k]->Write();
  //       if(lmdtdcp[k]) lmdtdcp[k]->Write();
  //       if(lmdtdf[k]) lmdtdf[k]->Write();
  //       if(lmdtmean[k]) lmdtmean[k]->Write();
  //       // if(lmdtdc[k]) lmdtdc[k]->Write();
  //     }
  //   }       
  // if(file.IsNull()) flmd->Close();
  // else fout->Close();
  
}

//______________________________________
void TFndLmdMon::TimeCalibration(Int_t layer, Int_t dch, Int_t wire, Float_t scal_fac){

  /*
    if(layer < 1 || layer > K_N_LMD_LAYERS) {
    cout << "Wrong layer number" << endl;
    return;
    }
    if(dch < 1 || dch > K_N_LMD_CHAMS_PER_LAYER) {
    cout << "Wrong chamber number" << endl;
    return;
    }
    Int_t wmax = K_N_LMD_INNER_WIRES;
    if(layer == 2) wmax = K_N_LMD_OUTER_WIRES;
    if(wire < 1 || wire > wmax) {
    cout << "Wrong wire number" << endl;
    return;
    }

    cout << "Layer: " << layer << ", Chamber: " << dch << ", Wire: " << wire << endl;
    for(Int_t k=0; k<3; k++) ZeroTime[layer-1][dch-1][wire-1][k] = 0.;

    Int_t idx = wire-1+(dch-1)*wmax;
    if(layer == 2) idx += K_N_LMD_CHAMS_PER_LAYER*K_N_LMD_INNER_WIRES;

    Int_t lmd_tdc_bins = lmdtmean[idx]->GetNbinsX();
    Float_t lmd_tdc_min = lmdtmean[idx]->GetBinLowEdge(1);
    Float_t lmd_tdc_max = lmdtmean[idx]->GetBinLowEdge(lmd_tdc_bins);
    Float_t binsize = (lmd_tdc_max-lmd_tdc_min)/(lmd_tdc_bins-1);
    cout << "binsize: " << binsize << endl;
    const Int_t nwidth = 16;
    const Float_t cell_length = 24900.;

    Float_t high = 1600.;
    Float_t low  = 1100.;  // anche low = 1200. !
    TF1 *plateau = new TF1("plateau", "pol1", low, high);

    TH1F *h1[3];
    h1[0] = lmdtdce[idx];
    h1[1] = lmdtdcp[idx];
    h1[2] = lmdtmean[idx];

    Float_t t1 = 0;
    for(Int_t k = 0; k < 3; k++) {
    h1[k]->Fit("plateau","RQ");
    Float_t ChiSquared = (Float_t) plateau->GetChisquare();
    Int_t NDF = plateau->GetNumberFitPoints() - plateau->GetNpar();
    //    Float_t plat = (Float_t) plateau->GetParameter(0)/scal_fac;
    Float_t plat1 = (Float_t) plateau->GetParameter(0);
    Float_t plat2 = (Float_t) plateau->GetParameter(1);
    Float_t plat = plat1 + plat2*(high+low)/2.;
    plat /= scal_fac;
    //printf("end of cell\n");
    Int_t nbins = h1[k]->GetNbinsX();
    //lmdtmean[idx]->GetNbinsX();
    Int_t nb = 0;
    for(nb=0; nb<nbins/2; nb++) {
    if(h1[k]->GetBinContent(nb+1) > plat) break;
    }
    TF1 *endcell = new TF1("endcell", "pol1", lmd_tdc_min+binsize*(nb-nwidth), lmd_tdc_min+binsize*(nb+nwidth));
    endcell->SetLineColor(2);
    h1[k]->Fit("endcell","RQ");
    ChiSquared = (Float_t) endcell->GetChisquare();
    NDF = endcell->GetNumberFitPoints() - endcell->GetNpar();
    Float_t endc1 = (Float_t) endcell->GetParameter(0);
    Float_t endc2 = (Float_t) endcell->GetParameter(1);

    if(endc2 != 0 && k == 2) t1 = (plat-endc1)/endc2;
    for(Int_t nnb=nbins/2; nnb<nbins; nnb++) {
    Bool_t lfit = 0;
    lfit = h1[k]->GetBinContent(nnb+1) < plat && h1[k]->GetBinContent(nnb+2) < plat && h1[k]->GetBinContent(nnb+3) < plat;
    Float_t b1 = 0;
    Float_t b2 = 0;
    if(lfit) {
    b1 = h1[k]->GetBinContent(nnb);
    b2 = h1[k]->GetBinContent(nnb+1);
    if(b1 != b2) ZeroTime[layer-1][dch-1][wire-1][k] = h1[k]->GetBinLowEdge(nnb) + binsize*(0.5+(b1-plat)/(b1-b2));
    break;
    }
    }
    }
  
    if(t1 != ZeroTime[layer-1][dch-1][wire-1][2])
    DriftSpeed[layer-1][dch-1][wire-1] = 2.*cell_length/(ZeroTime[layer-1][dch-1][wire-1][2]-t1);  // micron/ns

    cout << "ZeroTime[" << layer-1 << "][" << dch-1 << "][" << wire-1 << "][0]: " <<  ZeroTime[layer-1][dch-1][wire-1][0] << endl;
    cout << "ZeroTime[" << layer-1 << "][" << dch-1 << "][" << wire-1 << "][1]: " <<  ZeroTime[layer-1][dch-1][wire-1][1] << endl;
    cout << "ZeroTime[" << layer-1 << "][" << dch-1 << "][" << wire-1 << "][2]: " <<  ZeroTime[layer-1][dch-1][wire-1][2] << endl;
  */
}

//______________________________________
void TFndLmdMon::TimeCalibration(Int_t layer, Int_t dch, Float_t scal_fac){

  /*
    if(layer < 1 || layer > K_N_LMD_LAYERS) {
    cout << "Wrong layer number" << endl;
    return;
    }
    if(dch < 1 || dch > K_N_LMD_CHAMS_PER_LAYER) {
    cout << "Wrong chamber number" << endl;
    return;
    }
    Int_t wires = K_N_LMD_INNER_WIRES;
    if(layer == 2) wires = K_N_LMD_OUTER_WIRES;
    for(Int_t i=1; i<=wires; i++) TimeCalibration(layer,dch,i,scal_fac);
  */
}

//______________________________________
void TFndLmdMon::TimeCalibration(Float_t scal_fac){

  for(Int_t i=1; i<=K_N_LMD_LAYERS; i++) 
    for(Int_t j=1; j<=K_N_LMD_CHAMS_PER_LAYER; j++)
      TimeCalibration(i,j,scal_fac);
}

//______________________________________
void TFndLmdMon::ChargeCalibration(Int_t layer, Int_t dch, Int_t wire){

  /*
    if(layer < 1 || layer > K_N_LMD_LAYERS) {
    cout << "Wrong layer number" << endl;
    return;
    }
    if(dch < 1 || dch > K_N_LMD_CHAMS_PER_LAYER) {
    cout << "Wrong chamber number" << endl;
    return;
    }
    Int_t wmax = K_N_LMD_INNER_WIRES;
    if(layer == 2) wmax = K_N_LMD_OUTER_WIRES;
    if(wire < 1 || wire > wmax) {
    cout << "Wrong wire number" << endl;
    return;
    }

    cout << "ADC Calibration Parameters for Layer: " << layer << ", Dch: " << dch << ", Wire: " << wire << endl;
    for(Int_t k=0; k<2; k++) ChargeCalib[layer-1][dch-1][wire-1][k] = 1.;

    Int_t idx = wire-1+(dch-1)*wmax;
    if(layer == 2) idx += K_N_LMD_CHAMS_PER_LAYER*K_N_LMD_INNER_WIRES;
  
    Float_t calpars[5];

    Float_t average = 400.;
    Float_t width = 100.;
    Float_t norm = average;
    Float_t adc_cut = 150.;
    //  Float_t e_p_scal = 1.0;  // E to P side scaling factor

    TH1F *h1[2];
    h1[0] = lmdadce[idx];
    h1[1] = lmdadcp[idx];
    for(Int_t j=0; j<2; j++) {
    Int_t lmd_bins = h1[j]->GetNbinsX();
    Float_t lmd_min = h1[j]->GetBinLowEdge(1);
    Float_t lmd_max = h1[j]->GetBinLowEdge(lmd_bins);
    Float_t binsize = (lmd_max-lmd_min)/(lmd_bins-1);
    Int_t maxcont = 0;
    for(Int_t k=0; k<lmd_bins; k++) {
    Int_t newcont = (Int_t) h1[j]->GetBinContent(k);
    if(lmd_min + k*binsize > adc_cut) {
    if(newcont > maxcont) {
    maxcont = newcont;
    average = lmd_min + k*binsize;
    }
    }
      
    }
    
    TF1 *ga = new TF1("ga","gaus",average-width,average+width);
  */
}

//______________________________________
void TFndLmdMon::ChargeCalibration(Int_t layer, Int_t dch){

  /*
    if(layer < 1 || layer > K_N_LMD_LAYERS) {
    cout << "Wrong layer number" << endl;
    return;
    }
    if(dch < 1 || dch > K_N_LMD_CHAMS_PER_LAYER) {
    cout << "Wrong chamber number" << endl;
    return;
    }
    Int_t wires = K_N_LMD_INNER_WIRES;
    if(layer == 2) wires = K_N_LMD_OUTER_WIRES;
    for(Int_t i=1; i<=wires; i++) ChargeCalibration(layer,dch,i);
  */
}

//______________________________________
void TFndLmdMon::ChargeCalibration(){
  for(Int_t i=1; i<=K_N_LMD_LAYERS; i++) 
    for(Int_t j=1; j<=K_N_LMD_CHAMS_PER_LAYER; j++)
      ChargeCalibration(i,j);
}

//______________________________________
void TFndLmdMon::PedestalsEvaluation(){

  /*
    for (Int_t kk=0;kk<K_N_LMD_LAYERS;kk++) {     
    Int_t wires = 12 + kk*10;
    for (Int_t jj=0;jj<K_N_LMD_CHAMS_PER_LAYER;jj++) {     
    for (Int_t l=0;l<wires;l++) {
    Int_t k = K_N_LMD_INNER_WIRES*K_N_LMD_CHAMS_PER_LAYER*kk+l+jj*wires;
    cout << "Layer: " << kk+1 << ", Dch: " << jj+1 << ", Wire: " << l+1 << endl;
    Float_t pede = (Float_t) lmdadce[k]->GetMean();
    Float_t sigf = (Float_t) lmdadce[k]->GetRMS();
    Float_t pedp = (Float_t) lmdadcp[k]->GetMean();
    Float_t sigr = (Float_t) lmdadcp[k]->GetRMS();
    cout << "Pede: " << pede << ", Pedp: " << pedp << endl;
    lmd_all_adceped[kk*K_N_LMD_CHAMS_PER_LAYER+jj]->Fill(Float_t (l+1),pede);
    lmd_all_adceped[kk*K_N_LMD_CHAMS_PER_LAYER+jj]->SetBinError(l+1,sigf);
    lmd_all_adcpped[kk*K_N_LMD_CHAMS_PER_LAYER+jj]->Fill(Float_t (l+1),pedp);
    lmd_all_adcpped[kk*K_N_LMD_CHAMS_PER_LAYER+jj]->SetBinError(l+1,sigr);
    }
    }
    }
  */
}

//______________________________________
void TFndLmdMon::WritePedestalsToMsql(){
  
  /*
    cout << "Write Lmd Msql Pedestal file" << endl;
    TString *lmd_ped_file = new TString("lmd_pedestals.msql");
    FILE *flmd_ped;
    flmd_ped = fopen(lmd_ped_file->Data(),"w+");
    fprintf(flmd_ped,"# Host: localhost    Database: LmdDB\n");
    fprintf(flmd_ped,"# Table structure for table 'pede'\n");
    fprintf(flmd_ped,"CREATE TABLE pede (\n");
    fprintf(flmd_ped,"  w   INT,\n");
    fprintf(flmd_ped,"  A   INT,\n");
    fprintf(flmd_ped,"  Z   INT,\n");
    fprintf(flmd_ped,"  p0e  REAL,\n");
    fprintf(flmd_ped,"  p0p  REAL\n");
    fprintf(flmd_ped,")g\n");

    TString *lmd_ped_asc = new TString("lmd_pedestals.cal");
    FILE *flmd_p_asc;
    flmd_p_asc = fopen(lmd_ped_asc->Data(),"w+");

    Int_t start_time = 11111;
    Int_t stop_time = 2000000000;

    for(Int_t i=0; i<K_N_LMD_LAYERS;i++){ 
    for(Int_t j=0; j<K_N_LMD_CHAMS_PER_LAYER;j++){ 
    Int_t nwires = K_N_LMD_INNER_WIRES;
    if(i==1) nwires = K_N_LMD_OUTER_WIRES;
    Int_t dch = 1000*(i+1)+100*(j+1);
    for(Int_t k=0; k<nwires;k++){ 
    Int_t wire = dch+k+1;
    Float_t pedef = 0;
    Float_t peder = 0;
        
    TString line_start = TString("INSERT INTO pede VALUES (");
    pedef = lmd_all_adceped[i*K_N_LMD_CHAMS_PER_LAYER+j]->GetBinContent(k+1);
    peder = lmd_all_adcpped[i*K_N_LMD_CHAMS_PER_LAYER+j]->GetBinContent(k+1);
          
    line_start+=wire;
    line_start+=",";
    line_start+=start_time;
    line_start+=",";
    line_start+=stop_time;
    line_start+=",";
    line_start+=pedef;
    line_start+=",";
    line_start+=peder;
    line_start+=")g";
    fprintf(flmd_ped,"%s\n",line_start.Data());
          
    TString line_start2 = TString("UpLmdDbP ");
    line_start2+=wire;
    line_start2+=" ";
    line_start2+=start_time;
    line_start2+=" ";
    line_start2+=pedef;
    line_start2+=" ";
    line_start2+=peder;
    fprintf(flmd_p_asc,"%s\n",line_start2.Data());
    }
    }
    }
    fclose(flmd_ped);
    fclose(flmd_p_asc);
  */
}

//______________________________________
void TFndLmdMon::WritePedestalsToMsql(Int_t runtime){

  /*  
      cout << "Write Lmd Msql Pedestal file" << endl;

      TString *lmd_ped_asc = new TString("lmd_pedestals.cal");
      FILE *flmd_p_asc;
      flmd_p_asc = fopen(lmd_ped_asc->Data(),"w+");

      Int_t start_time = runtime;
      //  Int_t start_time = 11111; 

      for(Int_t i=0; i<K_N_LMD_LAYERS;i++){ 
      for(Int_t j=0; j<K_N_LMD_CHAMS_PER_LAYER;j++){ 
      Int_t nwires = K_N_LMD_INNER_WIRES;
      if(i==1) nwires = K_N_LMD_OUTER_WIRES;
      Int_t dch = 1000*(i+1)+100*(j+1);
      for(Int_t k=0; k<nwires;k++){ 
      Int_t wire = dch+k+1;
      Float_t pedef = 0;
      Float_t peder = 0;        
      pedef = lmd_all_adceped[i*K_N_LMD_CHAMS_PER_LAYER+j]->GetBinContent(k+1);
      peder = lmd_all_adcpped[i*K_N_LMD_CHAMS_PER_LAYER+j]->GetBinContent(k+1);
      // stringa da scrivere: LmdDBUpdate P w a p0p p0e
      TString line_start = TString("./LmdDBUpdate P ");
      line_start+=wire;
      line_start+=" ";
      line_start+=start_time;
      line_start+=" ";
      line_start+=peder;   // controllare che cpdr corrisponda al lato p
      line_start+=" ";
      line_start+=pedef;   // controllare che cpdf corrisponda al lato e
      fprintf(flmd_p_asc,"%s\n",line_start.Data());
      }
      }    
      }
      fclose(flmd_p_asc);
  */
}

//______________________________________
void TFndLmdMon::WriteTimeToMsql(Int_t runtime,Char_t *ev_type){
  // ev_type: "C" (From vertex Center) ; "T" (Cosmic Event)

  /*
    cout << "Write Lmd Msql Time Calibration file" << endl;

    TString *lmd_time_asc = new TString("lmd_time.cal");
    FILE *flmd_time_asc;
    flmd_time_asc = fopen(lmd_time_asc->Data(),"w+");

    Int_t start_time = runtime;
    Int_t stop_time = 2000000000;  // ok per costanti nuove!

    for(Int_t i=0; i<K_N_LMD_LAYERS;i++){ 
    for(Int_t j=0; j<K_N_LMD_CHAMS_PER_LAYER;j++){ 
    Int_t nwires = K_N_LMD_INNER_WIRES;
    if(i==1) nwires = K_N_LMD_OUTER_WIRES;
    Int_t dch = 1000*(i+1)+100*(j+1);
    for(Int_t k=0; k<nwires;k++){ 
    Int_t wire = dch+k+1;
    // stringa da scrivere: LmdDBUpdate T w a z t0p t0e t0
    TString line_start = TString("./LmdDBUpdate ");
    line_start+=ev_type;
    line_start+=" ";
    line_start+=wire;
    line_start+=" ";
    line_start+=start_time;
    line_start+=" ";
    line_start+=stop_time;
    line_start+=" ";
    line_start+=ZeroTime[i][j][k][1];
    line_start+=" ";
    line_start+=ZeroTime[i][j][k][0];
    line_start+=" ";
    line_start+=ZeroTime[i][j][k][2];
    fprintf(flmd_time_asc,"%s\n",line_start.Data());
    }
    }
    }
    fclose(flmd_time_asc);
  */
}

//______________________________________
void TFndLmdMon::WriteChargeToMsql(){
  
  /*
    cout << "Write Lmd Msql Charge Calibration file" << endl;
    TString *lmd_charge_cal_file = new TString("lmd_charge_calibration.msql");
    FILE *flmd_charge_cal;
    flmd_charge_cal = fopen(lmd_charge_cal_file->Data(),"w+");
    fprintf(flmd_charge_cal,"# Host: localhost    Database: LmdDB\n");
    fprintf(flmd_charge_cal,"# Table structure for table 'cal'\n");
    fprintf(flmd_charge_cal,"CREATE TABLE charge_cal (\n");
    fprintf(flmd_charge_cal,"  w INT,\n");
    fprintf(flmd_charge_cal,"  A INT,\n");
    fprintf(flmd_charge_cal,"  Z INT,\n");
    fprintf(flmd_charge_cal,"  q0p REAL,\n");
    fprintf(flmd_charge_cal,"  q0e REAL,\n");
    fprintf(flmd_charge_cal,"  q1p REAL,\n");
    fprintf(flmd_charge_cal,"  q1e REAL\n");
    fprintf(flmd_charge_cal,")g\n");

    TString *lmd_crg_asc = new TString("lmd_charge.cal");
    FILE *flmd_charge_asc;
    flmd_charge_asc = fopen(lmd_crg_asc->Data(),"w+");


    Int_t start_time = 11111;
    Int_t stop_time = 2000000000;
    Float_t q1p = 33333;
    Float_t q1e = 44444;
    for(Int_t ii=0; ii<K_N_LMD_LAYERS;ii++){ 
    for(Int_t ij=0; ij<K_N_LMD_CHAMS_PER_LAYER;ij++){ 
    Int_t nwires = K_N_LMD_INNER_WIRES;
    if(ii==1) nwires = K_N_LMD_OUTER_WIRES;
    Int_t dch = 1000*(ii+1)+100*(ij+1);
    for(Int_t ik=0; ik<nwires;ik++){ 
    Int_t wire = dch+ik+1;
    TString line_start = TString("INSERT INTO charge_cal VALUES (");
    line_start+=wire;            line_start+=",";
    line_start+=start_time;      line_start+=",";
    line_start+=stop_time;       line_start+=",";
    line_start+=ChargeCalib[ii][ij][ik][1];  line_start+=","; // cq0p
    line_start+=ChargeCalib[ii][ij][ik][0];  line_start+=","; // cq0e
    line_start+=q1p;  line_start+=",";  // cq1p
    line_start+=q1e;  line_start+=")g"; // cq1e
    fprintf(flmd_charge_cal,"%s\n",line_start.Data());

    TString line_start2 = TString("UpLmdDbQ ");
    line_start2+=wire;         line_start2+=" ";
    line_start2+=start_time;   line_start2+=" ";
    line_start2+=ChargeCalib[ii][ij][ik][1];  line_start2+=" ";  // cq0p
    line_start2+=ChargeCalib[ii][ij][ik][0];  // cq0e
    fprintf(flmd_charge_asc,"%s\n",line_start2.Data());
    }
    }
    }
    fclose(flmd_charge_cal);
    fclose(flmd_charge_asc);
  */
} 
  
//______________________________________
void TFndLmdMon::WriteChargeToMsql(Int_t runtime){
  
  /*
    cout << "Write Lmd Msql Charge Calibration file" << endl;

    TString *lmd_crg_asc = new TString("lmd_charge.cal");
    FILE *flmd_charge_asc;
    flmd_charge_asc = fopen(lmd_crg_asc->Data(),"w+");

    Int_t start_time = runtime;

    for(Int_t ii=0; ii<K_N_LMD_LAYERS;ii++){ 
    for(Int_t ij=0; ij<K_N_LMD_CHAMS_PER_LAYER;ij++){ 
    Int_t nwires = K_N_LMD_INNER_WIRES;
    if(ii==1) nwires = K_N_LMD_OUTER_WIRES;
    Int_t dch = 1000*(ii+1)+100*(ij+1);
    for(Int_t ik=0; ik<nwires;ik++){ 
    //cout << "Layer: " << ii+1 << ", Chamber: " << ij+1 << ", Wire: " << ik+1 << endl;
    Int_t wire = dch+ik+1;
    // stringa da scrivere: LmdDBUpdate C w a q0p q0e
    TString line_start = TString("./LmdDBUpdate Q ");
    line_start+=wire;
    line_start+=" ";
    line_start+=start_time;
    line_start+=" ";
    line_start+=ChargeCalib[ii][ij][ik][1];
    line_start+=" ";
    line_start+=ChargeCalib[ii][ij][ik][0];
    fprintf(flmd_charge_asc,"%s\n",line_start.Data());
    }
    }
    }
    fclose(flmd_charge_asc);
  */
} 

//______________________________________
void TFndLmdMon::Add(TFndLmdMon *lmdmon) {

  for (Int_t i=0;i<K_N_LMD_LAYERS;i++) {    
    for (Int_t j=0;j<K_N_LMD_CHAMS_PER_LAYER;j++) {     
      Int_t nwire = K_N_LMD_INNER_WIRES;
      if(i == 1) nwire = K_N_LMD_OUTER_WIRES;
      Int_t idx1 = j+i*K_N_LMD_CHAMS_PER_LAYER;
      lmd_all_mapadctdc[idx1]->Add((const TH2 *) lmdmon->LmdAllMapAdcTdc(idx1));
      lmd_all_adc[idx1]->Add((const TH2 *) lmdmon->LmdAllAdc(idx1));
      lmd_all_adce[idx1]->Add((const TH1 *) lmdmon->LmdAllAdcE(idx1));
      lmd_all_adcp[idx1]->Add((const TH1 *) lmdmon->LmdAllAdcP(idx1));
      lmd_all_adc_tdc[idx1]->Add((const TH2 *) lmdmon->LmdAllAdcTdc(idx1));
      lmd_all_mul[idx1]->Add((const TH1 *) lmdmon->LmdAllMul(idx1));
      lmd_all_aepat[idx1]->Add((const TH1 *) lmdmon->LmdAllAdcEPat(idx1));
      lmd_all_appat[idx1]->Add((const TH1 *) lmdmon->LmdAllAdcPPat(idx1));
      lmd_all_tepat[idx1]->Add((const TH1 *) lmdmon->LmdAllTdcEPat(idx1));
      lmd_all_tppat[idx1]->Add((const TH1 *) lmdmon->LmdAllTdcPPat(idx1));
      lmd_all_crg[idx1]->Add((const TH1 *) lmdmon->LmdAllCrg(idx1));
      lmd_all_zet[idx1]->Add((const TH2 *) lmdmon->LmdAllZet(idx1));

      lmd_all_tdc[idx1]->Add((const TH2 *) lmdmon->LmdAllTdc(idx1));
      lmd_all_tdce[idx1]->Add((const TH1 *) lmdmon->LmdAllTdcE(idx1));
      lmd_all_tdcp[idx1]->Add((const TH1 *) lmdmon->LmdAllTdcP(idx1));
      lmd_all_tdf[idx1]->Add((const TH1 *) lmdmon->LmdAllTdf(idx1));
      lmd_all_tmean[idx1]->Add((const TH1 *) lmdmon->LmdAllTmean(idx1));

      for (Int_t l=0;l<nwire;l++) {
        Int_t idx = l + j * nwire + i *K_N_LMD_INNER_WIRES * K_N_LMD_CHAMS_PER_LAYER;
        lmdadce[idx]->Add((const TH1 *) lmdmon->LmdAdcE(idx));
        lmdadcp[idx]->Add((const TH1 *) lmdmon->LmdAdcP(idx));
        lmdcrg[idx]->Add((const TH1 *) lmdmon->LmdCrg(idx));
        lmdzet[idx]->Add((const TH1 *) lmdmon->LmdZet(idx));

        lmdtdce[idx]->Add((const TH1 *) lmdmon->LmdTdcE(idx));
        lmdtdcp[idx]->Add((const TH1 *) lmdmon->LmdTdcP(idx));
        lmdtmean[idx]->Add((const TH1 *) lmdmon->LmdTmean(idx));
        lmdtdf[idx]->Add((const TH1 *) lmdmon->LmdTdf(idx));
      }
    }
  }
}




// Following code were in TFndLmdMon::Fill
// still keeping it here:
//
// last line still present in "TFndLmdMon::Fill":
//     lmd_all_adc_tdc[idx]->Fill(tp,ap);
    
//
// Loop to search for double hits and clean-up
/*
  for (Int_t jj=j+1; jj<nhlmd; jj++) {
  TFndHLmd *hlmd1 = (TFndHLmd*) LmdHits.At(jj);
    
  Int_t dch1 = hlmd1->GetCham();
  Int_t wire1 = hlmd1->GetWire();
  Float_t ae1 =  (Float_t ) hlmd1->GetAdcE();
  Float_t ap1 =  (Float_t ) hlmd1->GetAdcP();
  Float_t te1 =  (Float_t ) hlmd1->GetTdcE();
  Float_t tp1 =  (Float_t ) hlmd1->GetTdcP();
  Float_t tmean1 = 0.5*(te1+tp1);
      
  // Pedestal subtraction
      
  //       Float_t pede = 0.;
  //       Float_t pedp = 0.;
  //       if(lmd_det && fndrun->RunConfiguration()->LmdPedestalSubtraction()) {
  //    pede = lmd_det->PedE(dch1/10,dch1%10,wire1);
  //    pedp = lmd_det->PedP(dch1/10,dch1%10,wire1);
  //    ae1 -= pede; ap1 -= pedp;
  //       }
      
  // Charge Scaling
      
  //       if(lmd_det && fndrun->RunConfiguration()->LmdChargeEqualisation()) {
  //    //cout << "Charge scaling" << endl;
  //    Float_t che = lmd_det->ChargeE(dch1/10,dch1%10,wire1); 
  //    Float_t chp = lmd_det->ChargeP(dch1/10,dch1%10,wire1);
  //    if(che) ae1 *= che;
  //    if(chp) ap1 *= chp;
  //       }
      
  Int_t il1 = 0;
  Int_t sf1 = 0;
  Int_t idx1 = 0;

  if(dch1 <= 18 && dch1 >= 11) { 
  sf1 = dch1-11;
  il1 = 0;
  }
  if(dch1 <= 28 && dch1 >=21) {
  sf1 = dch1-21;
  il1 = 1;
  }
  idx1 = sf1+K_N_LMD_CHAMS_PER_LAYER*il1;    

  if(dch == dch1) {
  if(wire-wire1 == 1) {
  lmd_all_dhits[idx1]->Fill((Float_t) wire1);
  if(wire%2) {
  lmd_all_dhits_tdc_cell[idx1]->Fill(tmean,tmean1);
  //        if(tmean < 2500. && tmean1 < 2500.) {
  lmd_all_dhits_adc_cell[idx1]->Fill(ae+ap,ae1+ap1);
  if(ae+ap < ae1+ap1)
  iskip[j] = 1;
  else
  iskip[jj] = 1;
  } 
  else {
  //        if(ae+ap < 1000. && ae1+ap1>1000. || ae1+ap1 < 1000. && ae+ap>1000.) 
  lmd_all_dhits_tdc_dopp[idx1]->Fill(tmean,tmean1);
  lmd_all_dhits_adc_dopp[idx1]->Fill(ae+ap,ae1+ap1);
  }
  } 
  else if (wire1-wire == 1) {
  lmd_all_dhits[idx1]->Fill((Float_t) wire);
  if(wire%2) {
  //        if(ae+ap < 1000 || ae1+ap1 < 1000.) 
  lmd_all_dhits_tdc_dopp[idx1]->Fill(tmean1,tmean);
  lmd_all_dhits_adc_dopp[idx1]->Fill(ae1+ap1,ae+ap);
  } 
  else {
  lmd_all_dhits_tdc_cell[idx1]->Fill(tmean1,tmean);
  //        if(tmean < 2500. && tmean1 < 2500.) {
  lmd_all_dhits_adc_cell[idx1]->Fill(ae1+ap1,ae+ap);
  if(ae+ap < ae1+ap1)
  iskip[j] = 1;
  else
  iskip[jj] = 1;
  }
  }
  }
  }
*/


// skip double hits
//if(iskip[j] == 1) continue;

---