TOF/TFndTofMon.cxx

// @(#)fROOT/TOF:$Name:  $:$Id: TFndTofMon.cxx,v 1.34 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>, 2000

//                                                    //
//                     TFndTofMon                     //
// The description of the Tof online monitor          //
// is analogous to the GTS one (take it as reference) //
//                                                    //

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

#include "FROOT.h"
#include "TFndRun.h"
#include "TFndTofMon.h"

ClassImp(TFndTofMon)

//_________________________________________________________________
TFndTofMon::TFndTofMon(const TString &fmode,Int_t tof_adc_bins,Double_t tof_adc_min,Double_t tof_adc_max,Int_t tof_tdc_bins,Double_t tof_tdc_min,Double_t tof_tdc_max):
    shmflg(),fout(),ftof(),
    mtof(),mtof_adc(),mtof_tdc(),
    fMustRecoverHistos(kFALSE),
    fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
    fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
    tof_mon_adc(),tof_mon_tdc(),tof_mon_adc_tdc(),
    tofmult(),tof_i_o_mult(),tofmap(),tofmapadc0(),tofmapadc(),tofmapadce(),tofmapadcp(),
    tofmaptdc0(),tofmaptdc(),tofmaptdce(),tofmaptdcp(),tofcorr(),tofmapmt(),
    tof_mapadctdc(),tof_adc_tdc(),tofadce(),tofadcp(),tofcrg(),tofadc(),tofzet(),toftdce(),toftdcp(),toftdf(),toftmn(),toftmn_hw(),toftdc(),tof1d(),tof2d()
{

  Init();
  OpenSharedFiles(fmode);
  InitHistos(tof_adc_bins,tof_adc_min,tof_adc_max,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
  
  

}

//_________________________________________________________________
TFndTofMon::TFndTofMon():
  shmflg(),fout(),ftof(),
  mtof(),mtof_adc(),mtof_tdc(),
  fMustRecoverHistos(kFALSE),  
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  tof_mon_adc(),tof_mon_tdc(),tof_mon_adc_tdc(),
  tofmult(),tof_i_o_mult(),tofmap(),tofmapadc0(),tofmapadc(),tofmapadce(),tofmapadcp(),
  tofmaptdc0(),tofmaptdc(),tofmaptdce(),tofmaptdcp(),tofcorr(),tofmapmt(),
  tof_mapadctdc(),tof_adc_tdc(),tofadce(),tofadcp(),tofcrg(),tofadc(),tofzet(),toftdce(),toftdcp(),toftdf(),toftmn(),toftmn_hw(),toftdc(),tof1d(),tof2d()
{
  // ---
  Init();

}

//_________________________________________________________________
TFndTofMon::TFndTofMon(TString *filename):
  shmflg(),fout(),ftof(),
  mtof(),mtof_adc(),mtof_tdc(),
  fMustRecoverHistos(kFALSE),
  fSharedMemName_Main(),fSharedMemName_Adc(),fSharedMemName_Tdc(),
  fSharedFileName_Main(),fSharedFileName_Adc(),fSharedFileName_Tdc(),
  tof_mon_adc(),tof_mon_tdc(),tof_mon_adc_tdc(),
  tofmult(),tof_i_o_mult(),tofmap(),tofmapadc0(),tofmapadc(),tofmapadce(),tofmapadcp(),
  tofmaptdc0(),tofmaptdc(),tofmaptdce(),tofmaptdcp(),tofcorr(),tofmapmt(),
  tof_mapadctdc(),tof_adc_tdc(),tofadce(),tofadcp(),tofcrg(),tofadc(),tofzet(),toftdce(),toftdcp(),toftdf(),toftmn(),toftmn_hw(),toftdc(),tof1d(),tof2d()
{

  Init();

  mtof = 0;
  mtof_adc = 0;
  mtof_tdc = 0;
  ftof = new TFile(filename->Data());

  TString hname;
  hname = TString("tofmult");
  tofmult = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_i_o_mult");
  tof_i_o_mult = (TH2F *) ftof->Get(hname.Data()); 
  hname = TString("tofcorr0");
  tofcorr[0] = (TH2F *) ftof->Get(hname.Data()); 
  hname = TString("tofcorr1");
  tofcorr[1] = (TH2F *) ftof->Get(hname.Data()); 
  hname = TString("tof_map");
  tofmap = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_mapadc0");
  tofmapadc0 = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_mapadc");
  tofmapadc = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_mapadcp");
  tofmapadcp = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_mapadce");
  tofmapadce = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_maptdc0");
  tofmaptdc0 = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_maptdc");
  tofmaptdc = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_maptdcp");
  tofmaptdcp = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_maptdce");
  tofmaptdce = (TH1F *) ftof->Get(hname.Data()); 
  hname = TString("tof_mapmt");
  tofmapmt = (TH1F *) ftof->Get(hname.Data()); 

  for (Int_t idx=0;idx<n_tof_hist;idx++) {    
    Int_t idx1 = idx;
    if(idx>11) idx1 = idx+88;
    hname = TString("tof_mapadctdc_");
    hname+=idx+1;
    tof_mapadctdc[idx] = (TH2F *) ftof->Get(hname.Data()); 
    hname = TString("tof_adc_tdc_");
    hname+=idx+1;
    tof_adc_tdc[idx] = (TH2F *) ftof->Get(hname.Data()); 
    hname = TString("tof_adcp_");
    hname+=idx+1;
    tofadcp[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_adce_");
    hname+=idx+1;
    tofadce[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_crg_");
    hname+=idx+1;
    tofcrg[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_zet_");
    hname+=idx+1;
    tofzet[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_adc_");
    hname+=idx+1;
    
    //cout << hname->Data() << endl;
    tofadc[idx] = (TH2F *) ftof->Get(hname.Data()); 
    
    hname = TString("tof_tdcp");
    hname+=idx+1;
    toftdcp[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_tdce");
    hname+=idx+1;
    toftdce[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_tdf");
    hname+=idx+1;
    toftdf[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_tmn");
    hname+=idx+1;
    toftmn[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_tmn_hw");
    hname+=idx+1;
    toftmn_hw[idx] = (TH1F *) ftof->Get(hname.Data()); 
    hname = TString("tof_tdc");
    hname+=idx+1;
    
    toftdc[idx] = (TH2F *) ftof->Get(hname.Data()); 
  }

  tof1d = 0;
  tof2d = 0;

}

//_________________________________________________________________
TFndTofMon::~TFndTofMon() {

  delete tof_mon_adc;
  delete tof_mon_tdc;
  delete tof_mon_adc_tdc;

  delete tofmap;
  delete tofmapadc;
  delete tofmapadc0;
  delete tofmapadcp;
  delete tofmapadce;
  delete tofmaptdc;
  delete tofmaptdc0;
  delete tofmaptdcp;
  delete tofmaptdce;
  delete tofmapmt;
  
  for (Int_t ji=0;ji<n_tof_hist;ji++) {     
    delete tof_mapadctdc[ji];
    delete tof_adc_tdc[ji];
    delete tofadcp[ji];
    delete tofadce[ji];
    delete tofcrg[ji];
    delete tofzet[ji];
    delete tofadc[ji];
    delete toftdcp[ji];
    delete toftdce[ji];
    delete toftdf[ji];
    delete toftmn[ji];
    delete toftmn_hw[ji];
    delete toftdc[ji];
  }   
  delete tof1d;
  delete tof2d;
  
  // BUG: Close operation breaks on ftof in online mode...why?
  if(! shmflg){
    if(ftof) ftof->Close();
    delete ftof;
  }

  if(fout) fout->Close();
  delete fout;
  
  // --- shared memories
  if(mtof){ mtof->Close(); mtof = 0; }
  else delete mtof;

  if(mtof_adc){ mtof_adc->Close(); mtof_adc = 0; }
  else delete mtof_adc;

  if(mtof_tdc){ mtof_tdc->Close(); mtof_tdc = 0; }
  else delete mtof_tdc;

}

//_________________________________________________________________
void TFndTofMon::Init() {

  fSharedMemName_Main = FROOT::ExpandPathName("$FND_SHR/tof_map.map");
  fSharedMemName_Adc = FROOT::ExpandPathName("$FND_SHR/tof_adc.map");
  fSharedMemName_Tdc = FROOT::ExpandPathName("$FND_SHR/tof_tdc.map");
 
  fSharedFileName_Main = FROOT::ExpandPathName("tof_map.file.map");
  fSharedFileName_Adc = FROOT::ExpandPathName("tof_adc.file.map");
  fSharedFileName_Tdc = FROOT::ExpandPathName("tof_tdc.file.map");

}

//_________________________________________________________________
void TFndTofMon::InitHistos(const Int_t &tof_adc_bins,const Double_t &tof_adc_min,const Double_t &tof_adc_max,const Int_t &tof_tdc_bins,const Double_t &tof_tdc_min,const Double_t &tof_tdc_max) {
  
  if(shmflg && ( !mtof || !mtof_adc || !mtof_tdc) ){
    Warning("InitHistos","Map-files not available: exiting method");
    return;
  }
     
  TString hname;
  TString htitle;
  
  
  if(shmflg) mtof->cd();
  
  Float_t low = 0.5;
  Float_t high = low+100+n_tof_hist;
  hname = "tofmult"; 
  htitle = "Tof multiplicity";
  tofmult = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,14,-0.5,13.5);
  
  hname = "tof_i_o_mult";
  htitle = "Inner vs Outer Multiplicity";
  tof_i_o_mult = (fMustRecoverHistos) ? 
    ((TH2F*) (mtof->Get(hname))) :
    new TH2F(hname,htitle,74,-0.5,73.5,13,-0.5,12.5);
   
  hname = "tofcorr0";
  htitle = "D Slab vs Slab Number";
  tofcorr[0] = (fMustRecoverHistos) ? 
    ((TH2F*) (mtof->Get(hname))) :
    new TH2F(hname,htitle,12,0.5,12.5,12,0.5,12.5);

  hname = "tofcorr1";
  htitle = "D1 Slab vs Slab Number";
  tofcorr[1] = (fMustRecoverHistos) ? 
    ((TH2F*) (mtof->Get(hname))) :
    new TH2F(hname,htitle,12,0.5,12.5,12,0.5,12.5);
   
  hname = "tof_map";
  htitle = "Tof Hit pattern";
  tofmap = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   

  hname = "tof_mapadc0";
  htitle = "Tof ADC pattern (p||e != 0)";
  tofmapadc0 = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   
  hname = "tof_mapadc";
  htitle = "Tof ADC pattern (p&&e != 0)";
  tofmapadc = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   
  hname = "tof_mapadcp";
  htitle = "Tof ADC pattern (p-side)";
  tofmapadcp = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);
   
  hname = "tof_mapadce";
  htitle = "Tof ADC pattern (e-side)";
  tofmapadce = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high); 
   
  hname = "tof_maptdc0";
  htitle = "Tof TDC pattern (p||e != 0)";
  tofmaptdc0 = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   
  hname = "tof_maptdc";
  htitle = "Tof TDC pattern (p&&e != 0)";
  tofmaptdc = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   
  hname = "tof_maptdcp";
  htitle = "Tof TDC pattern (p-side)";
  tofmaptdcp = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);
   
  hname = "tof_maptdce";
  htitle = "Tof TDC pattern (e-side)";
  tofmaptdce = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   

  hname = "tof_mapmt";
  htitle = "Tof MT pattern";
  tofmapmt = (fMustRecoverHistos) ? 
    ((TH1F*) (mtof->Get(hname))) :
    new TH1F(hname,htitle,100+n_tof_hist,low,high);   
   

  for (Int_t ji=0;ji<n_tof_hist;ji++) {     
    Int_t slb = ji+1;
    if(ji > 11) slb = ji+89;
    hname.Form("tof_mapadctdc_%d",slb);
    htitle.Form("ADC p/e vs TDC p/e for slab: %d",slb);
    tof_mapadctdc[ji] = (fMustRecoverHistos) ? 
      ((TH2F*) (mtof->Get(hname))) :
      new TH2F(hname,htitle,4,-0.5,3.5,4,-0.5,3.5);
     
    hname.Form("tof_adc_tdc_%d",slb);
    htitle.Form("ADC vs TDC for slab: %d",slb);
    tof_adc_tdc[ji] = (fMustRecoverHistos) ? 
      ((TH2F*) (mtof->Get(hname))) :
      new TH2F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max,tof_adc_bins,tof_adc_min,tof_adc_max);
  }   
   

  //   TOF   ADC
  if(shmflg) mtof_adc->cd();

  for (Int_t l=0;l<n_tof_hist;l++) {
    Int_t slb = l+1;
    if(l > 11) slb = l+89;
    hname.Form("tof_adcp_%d",slb);
    htitle.Form("p-side ADC for Slab: %d",slb);
    tofadcp[l] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_adc->Get(hname))) :
      new TH1F(hname,htitle,tof_adc_bins,tof_adc_min,tof_adc_max);
    tofadcp[l]->SetLineColor(6); 

    hname.Form("tof_adce_%d",slb);
    htitle.Form("e-side ADC for Slab: %d",slb);
    tofadce[l] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_adc->Get(hname))) :
      new TH1F(hname,htitle,tof_adc_bins,tof_adc_min,tof_adc_max);
    tofadce[l]->SetLineColor(9);      

    hname.Form("tof_crg_%d",slb);
    htitle.Form("sqrt(ADC p-side*e-side) for Slab: %d",slb);
    tofcrg[l] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_adc->Get(hname))) :
      new TH1F(hname,htitle,tof_adc_bins,tof_adc_min,tof_adc_max);
     
    tofcrg[l]->SetFillColor(9);

    hname.Form("tof_zet_%d",slb);
    htitle.Form("ADC log(p/e) for Slab: %d",slb);
    tofzet[l] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_adc->Get(hname))) :
      new TH1F(hname,htitle,101,-20.,20.);
    tofzet[l]->SetFillColor(9);

    hname.Form("tof_adc_%d",slb);
    htitle.Form("ADC p-side vs e-side for Slab: %d",slb);
    tofadc[l] = (fMustRecoverHistos) ? 
      ((TH2F*) (mtof_adc->Get(hname))) :
      new TH2F(hname,htitle,tof_adc_bins,tof_adc_min,tof_adc_max,tof_adc_bins,tof_adc_min,tof_adc_max);
    tofadc[l]->SetFillColor(8);
  }
   
  //   TOF   TDC
  if(shmflg) mtof_tdc->cd();
   
  for (Int_t k=0;k<n_tof_hist;k++) {
    Int_t slb = k+1;
    if(k > 11) slb = k+89;
    hname.Form("tof_tdcp_%d",slb);
    htitle.Form("p-side TDC for Slab: %d",slb);
    toftdcp[k] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_tdc->Get(hname))) :
      new TH1F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
    toftdcp[k]->SetLineColor(6); 

    hname.Form("tof_tdce_%d",slb);
    htitle.Form("e-side TDC for Slab: %d",slb);
    toftdce[k] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_tdc->Get(hname))) :
      new TH1F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
    //     toftdce[k]->SetLineColor(7);      
    toftdce[k]->SetLineColor(9);      

    hname.Form("tof_tdf_%d",slb);
    htitle.Form("TDC p-side - e-side for Slab: %d",slb);
    toftdf[k] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_tdc->Get(hname))) :
      new TH1F(hname,htitle,100,-1000.,1000.);
    toftdf[k]->SetFillColor(9);

    hname.Form("tof_tmn_%d",slb);
    htitle.Form("TDC SW Mean Time for Slab: %d",slb);
    toftmn[k] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_tdc->Get(hname))) :
      new TH1F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
    toftmn[k]->SetFillColor(9);
     
    hname.Form("tof_tmn_hw_%d",slb);
    htitle.Form("TDC HW Mean Time for Slab: %d",slb);
    toftmn_hw[k] = (fMustRecoverHistos) ? 
      ((TH1F*) (mtof_tdc->Get(hname))) :
      new TH1F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
    toftmn_hw[k]->SetFillColor(9);
     
    hname.Form("tof_tdc_%d",slb);
    htitle.Form("TDC p-side vs e-side for Slab: %d",slb);
    toftdc[k] = (fMustRecoverHistos) ? 
      ((TH2F*) (mtof_tdc->Get(hname))) :
      new TH2F(hname,htitle,tof_tdc_bins,tof_tdc_min,tof_tdc_max,tof_tdc_bins,tof_tdc_min,tof_tdc_max);
    toftdc[k]->SetFillColor(8);
  }

}

//_________________________________________________________________
void TFndTofMon::OpenSharedFiles(const TString &fmode) {
  TString fhist = "_tof.root";
   
  shmflg = fndrun->Onlflg();
  cout << "Tof Shm flag is " << shmflg << endl;

  TString tofname = (fmode.IsNull())? "ONLM" : fmode;
  tofname+=fhist;

  // TOF maps
  ftof = new TFile(tofname.Data(),"RECREATE","Tof Histogram File");
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    mtof = TMapFile::Create(fSharedMemName_Main,"RECREATE",(Int_t)(1048576*FROOT::K_TofMapSize),"Tof memory mapped file with histograms");
    mtof->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    if(gSystem->AccessPathName(fSharedFileName_Main)){
      cout << "Shared file missing: creating it now..." << endl;
      mtof = new TFile(fSharedFileName_Main,"RECREATE");
    }
    else{
      cout << "Shared file found: histograms will be recovered..." << endl;
      mtof = TFile::Open(fSharedFileName_Main,"UPDATE");
      fMustRecoverHistos = kTRUE;
      //mtof->ls();
    }
#endif
  }
  
  //   TOF   ADC
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    mtof_adc = TMapFile::Create(fSharedMemName_Adc,"RECREATE",(Int_t)(1048576*FROOT::K_TofAdcMapSize),"Tof memory mapped file with ADC histograms");
    mtof_adc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    if( gSystem->AccessPathName(fSharedFileName_Adc) && fMustRecoverHistos == kTRUE){
      cout << "Shared file missing: creating it now..." << endl;
      mtof_adc = new TFile(fSharedFileName_Adc,"RECREATE");
      fMustRecoverHistos = kFALSE;
    }
    else{
      cout << "Shared file found: histograms will be recovered..." << endl;
      mtof_adc = TFile::Open(fSharedFileName_Adc,"UPDATE");
      //mtof_adc->ls();
    }
#endif
  }
  
  
  //   TOF   TDC
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    mtof_tdc = TMapFile::Create(fSharedMemName_Tdc,"RECREATE",(Int_t)(1048576*FROOT::K_TofTdcMapSize),"Tof memory mapped file with TDC histograms");
    mtof_tdc->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    if(gSystem->AccessPathName(fSharedFileName_Tdc) && fMustRecoverHistos == kTRUE ){
      cout << "Shared file missing: creating it now..." << endl;
      mtof_tdc = new TFile(fSharedFileName_Tdc,"RECREATE");
      fMustRecoverHistos = kFALSE;
    }
    else{
      cout << "Shared file found: histograms will be recovered..." << endl;
      mtof_tdc = TFile::Open(fSharedFileName_Tdc,"UPDATE");
      //mtof_tdc->ls();
    }
#endif
  }
   
}

//_________________________________________________________________
void TFndTofMon::Fill() {

  TClonesArray *cl = fndrun->GetCurrentHdt()->GetTofHits();
  Fill(*cl);
}

//_________________________________________________________________
void TFndTofMon::Fill(const TClonesArray &TofHits) {

  Int_t sladiv = 12;
  Int_t nhtof = TofHits.GetEntries();
  tofmult->Fill((Float_t) nhtof);

  Int_t upp_mult = 0;
  Int_t low_mult = 0;
  for (Int_t j=0; j<nhtof; j++) {
    if(nhtof>84) cout << "TFndTofMon WARNING: TOF number of hits= " << nhtof << " (greater than 84)!!!" << endl;
    TFndHTof *htof = (TFndHTof*) TofHits[j];
    Float_t slb = htof->GetChannel();
    if(slb==0){
      Warning("TFndTofMon","slab out of range...skipping hit");
      continue;
    }
    Float_t ap = (Float_t) htof->GetAdcP();
    Float_t ae = (Float_t) htof->GetAdcE();
    Float_t tp = (Float_t) htof->GetTdcP();
    Float_t te = (Float_t) htof->GetTdcE();
    Float_t tm = (Float_t) htof->GetMeanTimer();
    Float_t crg = TMath::Sqrt(ap*ae);

    if(ap <=0 && ae <=0 && tp <=0 && te <=0 && tm <=0) continue; // simply a (safe) check
    
    tofmap->Fill(slb);
    
    if(slb<=sladiv) low_mult++;
    else if(slb>sladiv && slb<=172) upp_mult++;

    
    if(ap > 0 || ae > 0) tofmapadc0->Fill(slb);
    if(ap > 0 && ae > 0) tofmapadc->Fill(slb);
    if(ap > 0) tofmapadcp->Fill(slb);
    if(ae > 0) tofmapadce->Fill(slb);
         
    if(tp > 0 || te > 0) tofmaptdc0->Fill(slb);
    if(tp > 0 && te > 0) tofmaptdc->Fill(slb);

    if(tp > 0) tofmaptdcp->Fill(slb);
    if(te > 0) tofmaptdce->Fill(slb);
    if(tm > 0) tofmapmt->Fill(slb);

    Int_t itdc = TFndHit::E_HIT_NO_CH;
    if(tp >0  && te >0)  itdc =  TFndHit::E_HIT_BOTH_CH;
    if(tp <=0 && te >0)  itdc = TFndHit::E_HIT_E_CH;
    if(tp >0  && te <=0) itdc = TFndHit::E_HIT_P_CH;
    
    Int_t iadc = TFndHit::E_HIT_NO_CH;
    if(ap >0  && ae >0)  iadc = TFndHit::E_HIT_BOTH_CH;
    if(ap <=0 && ae >0)  iadc = TFndHit::E_HIT_E_CH;
    if(ap >0  && ae <=0) iadc = TFndHit::E_HIT_P_CH;
    
    Int_t sf = (Int_t) slb - 1;
    if(slb>100) sf -= 88;
    tof_mapadctdc[sf]->Fill(itdc,iadc);
    if(tp >=0 && ap >=0) tof_adc_tdc[sf]->Fill(tp,ap);
    if(te >=0 && ae >=0) tof_adc_tdc[sf]->Fill(te,ae);
    
    if(ap >=0) tofadcp[sf]->Fill(ap);
    if(ae >=0) tofadce[sf]->Fill(ae);

    Float_t zet = -100.;
    if(ae >=0 && ap >=0){
      tofadc[sf]->Fill(ae,ap);
      tofcrg[sf]->Fill(crg);
      zet = TMath::Log(ap/ae);
      tofzet[sf]->Fill(zet);
    }
    
    
    if(tp >=0) toftdcp[sf]->Fill(tp);
    if(te >=0) toftdce[sf]->Fill(te);
    if(tp >=0 && te >=0){
      toftdc[sf]->Fill(te,tp);
      toftmn_hw[sf]->Fill(tm);    
      tm = (tp+te)/2.;
      toftmn[sf]->Fill(tm);       
      toftdf[sf]->Fill(tp-te);    
    }

  } // hits loop

  tof_i_o_mult->Fill((Float_t) upp_mult,(Float_t) low_mult);

}

//_________________________________________________________________
void TFndTofMon::Update(Bool_t purge) {
  // Update shared memories content (used by the producer)

#if defined _FND_ONL_USE_MAP_FILES_
  if(mtof) mtof->Print();
  if( mtof && mtof->IsWritable() ) mtof->Update();
  if( mtof_adc) mtof_adc->Print();
  if( mtof_adc && mtof_adc->IsWritable() ) mtof_adc->Update();
  if( mtof_tdc) mtof_tdc->Print();
  if( mtof_tdc && mtof_tdc->IsWritable() ) mtof_tdc->Update();
#elif defined _FND_ONL_USE_SHARED_FILES_
  WriteToFile(0,kTRUE);
  
  mtof->cd();
  if(purge)  mtof->Purge();
  mtof->Flush();
  mtof_adc->cd();
  if(purge)  mtof_adc->Purge();
  mtof_adc->Flush();
  mtof_tdc->cd();
  if(purge)  mtof_tdc->Purge();
  mtof_tdc->Flush();

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

  comm_cp.Form("cp ./tof_adc.file.map %s",FROOT::ExpandPathName("$FND_SHR/tof_adc.file.map").Data());
  gSystem->Exec(comm_cp);

  comm_cp.Form("cp ./tof_tdc.file.map %s",FROOT::ExpandPathName("$FND_SHR/tof_tdc.file.map").Data());
  gSystem->Exec(comm_cp);
#endif 

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

}

//_________________________________________________________________
void TFndTofMon::ResetHistos(){

  if(tofmap) tofmap->Reset();
  if(tofmapadc0) tofmapadc0->Reset();
  if(tofmapadc) tofmapadc->Reset();
  if(tofmapadcp) tofmapadcp->Reset();
  if(tofmapadce) tofmapadce->Reset();
  
  if(tofmaptdc0) tofmaptdc0->Reset();
  if(tofmaptdc) tofmaptdc->Reset();
  if(tofmaptdcp) tofmaptdcp->Reset();
  if(tofmaptdce) tofmaptdce->Reset();
  if(tofmapmt) tofmapmt->Reset();
  
  if(tofmult) tofmult->Reset();
  if(tof_i_o_mult) tof_i_o_mult->Reset();
  if(tofcorr[0]) tofcorr[0]->Reset();
  if(tofcorr[1]) tofcorr[1]->Reset();

  for(Int_t sf=0; sf<n_tof_hist; sf++) {
    if(tof_mapadctdc[sf]) tof_mapadctdc[sf]->Reset();
    if(tof_adc_tdc[sf]) tof_adc_tdc[sf]->Reset();

    if(tofadcp[sf]) tofadcp[sf]->Reset();
    if(tofadce[sf]) tofadce[sf]->Reset();
    if(tofadc[sf]) tofadc[sf]->Reset();
    if(tofcrg[sf]) tofcrg[sf]->Reset();
    if(tofzet[sf]) tofzet[sf]->Reset();
    
    if(toftdcp[sf]) toftdcp[sf]->Reset();
    if(toftdce[sf]) toftdce[sf]->Reset();
    if(toftdc[sf]) toftdc[sf]->Reset();
    if(toftdf[sf]) toftdf[sf]->Reset();   
    if(toftmn[sf]) toftmn[sf]->Reset();   
    if(toftmn_hw[sf]) toftmn_hw[sf]->Reset();     
  }

}

//_________________________________________________________________
void TFndTofMon::WriteToFile(TString file,Bool_t IsShared) {
  
  if(IsShared){
    //    Info("TFndTofMon::WriteToFile","Writing histograms in on-line mode");
    mtof->cd();
  }
  else{
    if(file.IsNull()) 
      ftof->cd();
    else {
      if(fout) fout->Close();
      delete fout;
      fout = new TFile(file.Data(),"RECREATE","Tof Histogram File");
      fout->cd();
    }  
  }
  if(tofmap) tofmap->Write();
  if(tofmapadc0) tofmapadc0->Write();
  if(tofmapadc) tofmapadc->Write();
  if(tofmapadcp) tofmapadcp->Write();
  if(tofmapadce) tofmapadce->Write();
  
  if(tofmaptdc0) tofmaptdc0->Write();
  if(tofmaptdc) tofmaptdc->Write();
  if(tofmaptdcp) tofmaptdcp->Write();
  if(tofmaptdce) tofmaptdce->Write();
  if(tofmapmt) tofmapmt->Write();
  
  if(tofmult) tofmult->Write();
  if(tof_i_o_mult) tof_i_o_mult->Write();
  if(tofcorr[0]) tofcorr[0]->Write();
  if(tofcorr[1]) tofcorr[1]->Write();
  
  for(Int_t sf=0; sf<n_tof_hist; sf++) {
    //Info("WriteToFile","saving: sf = %d",sf);
    if(tof_mapadctdc[sf]) tof_mapadctdc[sf]->Write();
    if(tof_adc_tdc[sf]) tof_adc_tdc[sf]->Write();
  }
  
  if(IsShared){
    Info("TFndTofMon::WriteToFile","Writing histograms in on-line mode");
    mtof_adc->cd();
  }
  for(Int_t sf=0; sf<n_tof_hist; sf++) {
    if(tofadcp[sf]) tofadcp[sf]->Write();
    if(tofadce[sf]) tofadce[sf]->Write();
    if(tofadc[sf]) tofadc[sf]->Write();
    if(tofcrg[sf]) tofcrg[sf]->Write();
    if(tofzet[sf]) tofzet[sf]->Write();
  }    
  
  if(IsShared){
    Info("TFndTofMon::WriteToFile","Writing histograms in on-line mode");
    mtof_tdc->cd();
  }
  for(Int_t sf=0; sf<n_tof_hist; sf++) {
    if(toftdcp[sf]) toftdcp[sf]->Write();
    if(toftdce[sf]) toftdce[sf]->Write();
    if(toftdc[sf]) toftdc[sf]->Write();
    if(toftdf[sf]) toftdf[sf]->Write();   
    if(toftmn[sf]) toftmn[sf]->Write();   
    if(toftmn_hw[sf]) toftmn_hw[sf]->Write();     
  }


}

//_________________________________________________________________
void TFndTofMon::Add(TFndTofMon *tofmon) {

  if(tofmult) tofmult->Add((const TH1 *) tofmon->TofMult());
  if(tof_i_o_mult) tof_i_o_mult->Add((const TH2 *) tofmon->TofMultIO());
  if(tofcorr[0]) tofcorr[0]->Add((const TH2 *) tofmon->TofCorr(0));
  if(tofcorr[1]) tofcorr[1]->Add((const TH2 *) tofmon->TofCorr(1));
  if(tofmap) tofmap->Add((const TH1 *) tofmon->TofMap());
  if(tofmapadc0) tofmapadc0->Add((const TH1 *) tofmon->TofMapAdc0());
  if(tofmapadce) tofmapadce->Add((const TH1 *) tofmon->TofMapAdcP());
  if(tofmapadcp) tofmapadcp->Add((const TH1 *) tofmon->TofMapAdcE());
  if(tofmapadc) tofmapadc->Add((const TH1 *) tofmon->TofMapAdc());
  
  if(tofmaptdc0) tofmaptdc0->Add((const TH1 *) tofmon->TofMapTdc0());
  if(tofmaptdce) tofmaptdce->Add((const TH1 *) tofmon->TofMapTdcP());
  if(tofmaptdcp) tofmaptdcp->Add((const TH1 *) tofmon->TofMapTdcE());
  if(tofmaptdc) tofmaptdc->Add((const TH1 *) tofmon->TofMapTdc());
  if(tofmapmt) tofmapmt->Add((const TH1 *) tofmon->TofMapMT());

  for (Int_t idx=0;idx<n_tof_hist;idx++) {    
    if(tof_mapadctdc[idx]) tof_mapadctdc[idx]->Add((const TH2 *) tofmon->TofMapAdcTdc(idx));
    if(tof_adc_tdc[idx]) tof_adc_tdc[idx]->Add((const TH2 *) tofmon->TofAdcTdc(idx));
    if(tofadce[idx]) tofadce[idx]->Add((const TH1 *) tofmon->TofAdcE(idx));
    if(tofadcp[idx]) tofadcp[idx]->Add((const TH1 *) tofmon->TofAdcP(idx));
    if(tofcrg[idx]) tofcrg[idx]->Add((const TH1 *) tofmon->TofCrg(idx));
    if(tofzet[idx]) tofzet[idx]->Add((const TH1 *) tofmon->TofZet(idx));
    if(tofadc[idx]) tofadc[idx]->Add((const TH2 *) tofmon->TofAdc(idx));
    if(toftdce[idx]) toftdce[idx]->Add((const TH1 *) tofmon->TofTdcE(idx));
    if(toftdcp[idx]) toftdcp[idx]->Add((const TH1 *) tofmon->TofTdcP(idx));
    if(toftdf[idx]) toftdf[idx]->Add((const TH1 *) tofmon->TofTdf(idx));
    if(toftmn[idx]) toftmn[idx]->Add((const TH1 *) tofmon->TofTmn(idx));
    if(toftmn_hw[idx]) toftmn_hw[idx]->Add((const TH1 *) tofmon->TofTmnHW(idx));
    if(toftdc[idx]) toftdc[idx]->Add((const TH2 *) tofmon->TofTdc(idx));
  }
}

---