using namespace std;
#include "hmdcefficiency.h"
#include <iostream>
#include <iomanip>
#include <stdlib.h>
#include <TMath.h>
#include <TLine.h>
#include <TText.h>
#include <TStyle.h>
#include <TMarker.h>
#include <TPaveLabel.h>
#include <TColor.h>
#include <TH2.h>
#include <TCanvas.h>
#include <TSlider.h>
#include <TSystem.h>
#include "hmdcgeomstruct.h"
#include "hmdcdef.h"
#include "hdebug.h"
#include "hades.h"
#include "heventheader.h"
#include "hiterator.h"
#include "hmdcgetcontainers.h"
#include "hmdccal1sim.h"
#include "hmdclookupgeom.h"
#include "hmdctimecut.h"
#include "hcategory.h"
#include "hmdclookuptb.h"
#include "hmdcrawstruct.h"
#include "hmdcdetector.h"
#include "hmdcsizescells.h"
#include "hmdcclussim.h"

//*-- Author : V.Pechenov
//*-- Modified : 15.06.2002 by V. Pechenov
//*-- Modified : 10.05.2001 by V. Pechenov
//*-- Modified : 10.05.2000 by V. Pechenov

//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////
//  HMdcEfficiency
//
// Estimation of MDC efficiency.
// Use macros mdcEfficiency.C
//
///////////////////////////////////////////////////////////////


ClassImp(HMdcEff)
ClassImp(HMdcEffMod)
ClassImp(HMdcEfficiency)
ClassImp(HMdcEfficiencySec)
ClassImp(HMdcEfficiencyMod)
ClassImp(HMdcEfficiencyLayer)

// !!! mishen', dlya magn.polya budet ...
//

void HMdcEff::calcEff(Double_t iN0,  Double_t eN0,
                      Double_t iN1,  Double_t eN1,
                      Double_t iN2m, Double_t eN2m,
		      Double_t iN2b, Double_t eN2b) {
  n0=iN0;
  n1=iN1;
  n2m=iN2m;
  n2b=iN2b;
  errN0=eN0;
  errN1=eN1;
  errN2m=eN2m;
  errN2b=eN2b;
  totNumTr=n0+n1+n2m+n2b;

  calculation();
}

Double_t HMdcEff::efficiency(Double_t n0T, Double_t n1T,
                             Double_t n2mT, Double_t n2bT) {
  Double_t eC=n2mT+0.5*n2bT;
  Double_t eB=n1T+2.*eC;
  Double_t eA=n0T+n1T+eC;
  if( eA == 0. ) return 0.;
  Double_t sq=eB*eB-4*eA*eC;
  if( sq < 0. ) sq=0.;
  return (eB+sqrt(sq))/(2.*eA);
}

Double_t HMdcEff::fractSingle(Double_t effT, Double_t n0T, Double_t n1T,
                             Double_t n2mT, Double_t n2bT) {
  Double_t b=n1T+2.*n2mT+n2bT;
  if( b == 0.0 ) return 0.;
  Double_t tmp=effT*b-n2mT;
  if( tmp < n2mT+n2bT ) return 0.;
  return 1.-(n2mT+n2bT)/tmp;
}

void HMdcEff::calculation(void) {

  // Determination of M coefficient
  eM=1.;
  errM=0.;
  if(n2m+n2b>0) {
    eM=1.-0.5*n2b/(n2m+n2b);
    Double_t dMdN2m=+0.5*n2b/((n2m+n2b)*(n2m+n2b));
    Double_t dMdN2b=-0.5*n2m/((n2m+n2b)*(n2m+n2b));
    errM=sqrt(dMdN2b*errN2b*dMdN2b*errN2b+dMdN2m*errN2m*dMdN2m*errN2m);
  }

  eff=efficiency(n0,n1,n2m,n2b);
  single=fractSingle(eff,n0,n1,n2m,n2b);
  p0=single*(1.-eff)+(1.-single)*(1.-eff)*(1.-eff)*eM;
  p1=single*eff+(1.-single)*eff*(1.-eff)*2.*eM;
  p2=(1.-single)*eff*eff;
  errEff=0.;
  errSingle=0.;
  errP0=errP1=errP2=0.;
  Double_t dEn[4],dSn[4],dP0[4],dP1[4],dP2[4];
  for(Int_t i=0; i<4; i++) dEn[i]=dSn[i]=dP0[i]=dP1[i]=dP2[i]=0.;
  if(n0+n1+n2m+n2b > 0) {
    for(Int_t i0=-1; i0<=1; i0++) {
      for(Int_t i1=-1; i1<=1; i1++) {
        for(Int_t i2m=-1; i2m<=1; i2m++) {
          for(Int_t i2b=-1; i2b<=1; i2b++) {
            Double_t shN0=n0+errN0*i0;
            if(shN0<0.) continue;
            Double_t shN1=n1+errN1*i1;
            if(shN1<0.) continue;
            Double_t shN2m=n2m+errN2m*i2m;
            if(shN2m<0.) continue;
            Double_t shN2b=n2b+errN2b*i2b;
            if(shN2b<0.) continue;
            //Maximal error:
            Double_t shEff=efficiency(shN0,shN1,shN2m,shN2b);
            errEff=TMath::Max(TMath::Abs(shEff-eff),errEff);
            Double_t shSingle=fractSingle(shEff,shN0,shN1,shN2m,shN2b);
            if(shN1+shN2m+shN2b > 0.) {
              errSingle=TMath::Max(TMath::Abs(shSingle-single),errSingle);
            }
            Double_t shM=(shN2m+shN2b>0) ? 1.-0.5*shN2b/(shN2m+shN2b) : 1.;
            Double_t shP0=shSingle*(1.-shEff)+
                          (1.-shSingle)*(1.-shEff)*(1.-shEff)*shM;
            errP0=TMath::Max(TMath::Abs(shP0-p0),errP0);
            Double_t shP1=shSingle*shEff+(1.-shSingle)*shEff*(1.-shEff)*2.*shM;
            errP1=TMath::Max(TMath::Abs(shP1-p1),errP1);
            Double_t shP2=(1.-shSingle)*shEff*shEff;
            errP2=TMath::Max(TMath::Abs(shP2-p2),errP2);

            Int_t n=abs(i0)+abs(i1)+abs(i2m)+abs(i2b);
            if(n==1) {
              Int_t i=abs(i0)*0+abs(i1)*1+abs(i2m)*2+abs(i2b)*3;
              dEn[i]=TMath::Max((shEff-eff)*(shEff-eff),dEn[i]);
              dSn[i]=TMath::Max((shSingle-single)*(shSingle-single),dSn[i]);
              dP0[i]=TMath::Max((shP0-p0)*(shP0-p0),dP0[i]);
              dP1[i]=TMath::Max((shP1-p1)*(shP1-p1),dP1[i]);
              dP2[i]=TMath::Max((shP2-p2)*(shP2-p2),dP2[i]);
            }
          }
        }
      }
    }
  }

  Double_t errEffN=sqrt(dEn[0]+dEn[1]+dEn[2]+dEn[3]);
  Double_t errSingleN=sqrt(dSn[0]+dSn[1]+dSn[2]+dSn[3]);
  Double_t errP0N=sqrt(dP0[0]+dP0[1]+dP0[2]+dP0[3]);
  Double_t errP1N=sqrt(dP1[0]+dP1[1]+dP1[2]+dP1[3]);
  Double_t errP2N=sqrt(dP2[0]+dP2[1]+dP2[2]+dP2[3]);
  if(errEffN<errEff) errEff=(errEff+errEffN)*0.5;
  if(errSingleN<errSingle) errSingle=(errSingle+errSingleN)*0.5;
  if(errP0N<errP0) errP0=(errP0+errP0N)*0.5;
  if(errP1N<errP1) errP1=(errP1+errP1N)*0.5;
  if(errP2N<errP2) errP2=(errP2+errP2N)*0.5;

/*  errEff=TMath::Min(errEff, sqrt(dEn[0]+dEn[1]+dEn[2]+dEn[3]));
  errSingle=TMath::Min(errSingle,sqrt(dSn[0]+dSn[1]+dSn[2]+dSn[3]));
  errP0=TMath::Min(errP0,sqrt(dP0[0]+dP0[1]+dP0[2]+dP0[3]));
  errP1=TMath::Min(errP1,sqrt(dP1[0]+dP1[1]+dP1[2]+dP1[3]));
  errP2=TMath::Min(errP2,sqrt(dP2[0]+dP2[1]+dP2[2]+dP2[3])); */
  if(n2b > 0.) totNumTr=totNumTr/(p0+p1+p2);
}

Double_t HMdcEffMod::efficiency(Double_t n0T, Double_t n1T,
                                Double_t n2T, Double_t n2bT) {
  Double_t eA=(n1T+n2T)*(n1T+n2T-4.*n0T);
  if( eA == 0. ) return 0.;
  Double_t eB=(2.*n2T+n1T)*(n1T+n2T-5.*n0T);
  Double_t eC=n2T*(n1T+n2T-5.*n0T);
  Double_t sq=eB*eB-4*eA*eC;
  if( sq < 0. ) sq=0.;
  return (eB+sqrt(sq))/(2.*eA);
}

void HMdcEffMod::calcEff(Double_t iN0,  Double_t eN0,
			 Double_t iN1,  Double_t eN1,
 			 Double_t iN2m, Double_t eN2m,
 			 Double_t iN2b, Double_t eN2b) {
  n0=iN0;
  n1=iN1;
  n2m=iN2m;
  n2b=iN2b;
  errN0=eN0;
  errN1=eN1;
  errN2m=eN2m;
  errN2b=eN2b;

  totNumTr=(n0+n1+n2m)/6.;

  calculation();

  Double_t p12=p1+p2;
  p6l=p12 *p12 *p12 *p12 *p12 *p12;
  p5l=p12 *p12 *p12 *p12 *p12 *p0   *6.;
  p4l=p12 *p12 *p12 *p12 *p0  *p0  *15.;
  p3l=p12 *p12 *p12 *p0  *p0  *p0  *20.;
  p2l=p0  *p0  *p0  *p0  *p12 *p12 *15.;
  p1l=p0  *p0  *p0  *p0  *p0  *p12  *6.;
  p0l=p0  *p0  *p0  *p0  *p0  *p0;
}


HMdcEfficiencyLayer::HMdcEfficiencyLayer(Short_t sec, Short_t mod,
 					 Short_t lay) {
  // constructor creates an array of pointers of type
  // HMdcEfficiencyLayer
  sector=sec;
  module=mod;
  layer=lay;
  is=0;
  // Geting of pointers to par. cont.
  HMdcGetContainers* fGetCont=HMdcGetContainers::getObject();
  if( !fGetCont ) return;
  HMdcGeomStruct* fGeomStr=fGetCont->getMdcGeomStruct();
  if ( fGeomStr ) {
    HMdcGetContainers::getFileName(fileName);
    nCells=((*fGeomStr)[sector][module])[layer];
    if( nCells > 0 ) {
      is=1;
      n0=new Int_t [nCells];
      n1=new Int_t [nCells];
      n2=new Int_t [nCells];
      nCellTot=new Int_t [nCells];
      nCellCutS=new Int_t [nCells];
      nCellStat=new Int_t [nCells];
      nCellsClus=new Int_t [nCells];
      nClustCell=new UChar_t [nCells];
      clear();
      createHists();
      for(Int_t nP=0; nP<6; nP++) listPads[nP]=1;
      nPads=6;
      Char_t buf[200];
      sprintf(buf,"%s_S%iM%iL%iEff",fileName.Data(),
          sector+1,module+1,layer+1);
      nameCanv=buf;
      sprintf(buf,"%s S%i M%i L%i Efficiency",fileName.Data(),
          sector+1,module+1,layer+1);
      titleCanv=buf;
      for(Int_t nPlXY=0; nPlXY<3; nPlXY++) {
        titlePadXY[nPlXY].SetX1(0.05);
        titlePadXY[nPlXY].SetX2(0.6);
        titlePadXY[nPlXY].SetY1(0.955);
        titlePadXY[nPlXY].SetY2(0.995);
        titlePadXY[nPlXY].SetTextAlign(22);
        titlePadXY[nPlXY].SetTextSize(0);
        titlePadXY[nPlXY].SetBorderSize(1);
        titlePadXY[nPlXY].SetFillColor(7);
      }
    }
  }
}

HMdcEfficiencyLayer::~HMdcEfficiencyLayer() {
  delete [] n0;
  delete [] n1;
  delete [] n2;
  delete [] nCellTot;
  delete [] nCellCutS;
  delete [] nCellStat;
  delete [] nClustCell;
  delete [] nCellsClus;
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  canvEff=(TCanvas*)fSegColl->FindObject(nameCanv);
  if( canvEff ) {
    delete canvEff;
    canvEff=0;
  }
  for(Int_t i=0; i<3; i++) {
    canvXY[i]=(TCanvas*)fSegColl->FindObject(nameCanvXY[i]);
    if( canvXY[i] ) {
      delete canvXY[i];
      canvXY[i]=0;
    }
  }
}

void HMdcEfficiencyLayer::clear(void) {
  for (Short_t i=0; i<nCells; i++) {
    n0[i]=n1[i]=n2[i]=0;
    nCellStat[i]=nCellCutS[i]=nCellTot[i]=nCellsClus[i]=0;
  }
  for (Short_t xy=0; xy<256; xy++) n0xy[xy]=n1xy[xy]=n2xy[xy]=0;
}

void HMdcEfficiencyLayer::createHists(void) {
  Char_t* titH[13];
  Char_t* nmH[13];
  titH[0]="Pattern";
  nmH[0] ="Pattern";
  titH[1]="Total num. of hits (no cut)";
  nmH[1] ="TNhitsNoCut";
  titH[2]="Num. of selected tracks crossing cell(s) vs. cell";
  nmH[2] ="TNtracks";
  titH[3]="Num. of \"zero\" hits";
  nmH[3] ="N0hits";
  titH[4]="Num. of \"single\" hits";
  nmH[4] ="N1hits";
  titH[5]="Num. of \"double\" hits";
  nmH[5] ="N2hits";
  titH[6]="Cells efficiency";
  nmH[6] ="Eff";
  titH[7]="Fraction of single hits";
  nmH[7] ="Sing";
  titH[8]="Probability to have \"zero\" hit";
  nmH[8] ="P0";
  titH[9]="Probability to have \"single\" hit";
  nmH[9] ="P1";
  titH[10]="Probability to have \"double\" hit";
  nmH[10] ="P2";
  titH[11]="Total num. of hits (cut time1&time2)";
  nmH[11] ="TNhitsCutT1T2";
  titH[12]="Hits from clusters";
  nmH[12] ="TNhitsClust";
  Float_t minimum[13] ={  0.,  0., 0., 0., 0., 0., .0,  .0, .0, .0, .0,  0.,  0.};
  Float_t maximim[13] ={ -1., -1.,-1.,-1.,-1.,-1.,1.1, 1.1,1.1,1.1,1.1, -1., -1.};
  Int_t markStyle[13] ={  -1,  -1, -1, -1, -1, -1, 21,  21, 21, 21, 21,  -1,  -1};
  Float_t markSize[13]={ 0.4, 0.4,0.4,0.4,0.4,0.4,0.4, 0.4,0.4,0.4,0.4, 0.4, 0.4};
  Int_t markColor[13] ={  -1,  -1, -1, -1, -1, -1,  4,   4,  2,  4,  3,  -1,  -1};
  Int_t fillStyle[13] ={1001,1001,  0,  0,  0,  0,  0,   0,  0,  0,  0,1001,   0};
  Text_t name[20];
  Text_t title[100];
  for(Int_t nHist=0; nHist<13; nHist++) {
    sprintf(name,"S%iM%iL%i%s",sector+1,module+1,layer+1,nmH[nHist]);
    sprintf(title,"S%i M%i L%i %s",sector+1,module+1,layer+1,titH[nHist]);
    hists[nHist]=new TH1F(name,title,nCells,0.,(Double_t)nCells);
    hists[nHist]->SetMinimum(minimum[nHist]);
    if(maximim[nHist]>0.) hists[nHist]->SetMaximum(maximim[nHist]);
    if(markStyle[nHist]>0) {
      hists[nHist]->SetMarkerStyle(markStyle[nHist]);
      hists[nHist]->SetMarkerSize(markSize[nHist]);
      hists[nHist]->SetMarkerColor(markColor[nHist]);
    }
    if(nHist>4&&nHist<11) hists[nHist]->SetOption("e1p");
    hists[nHist]->SetFillStyle(fillStyle[nHist]);
  }
  Char_t buf[200];
  sprintf(buf,"%s_S%iM%iL%inHitsXY",fileName.Data(),
      sector+1,module+1,layer+1);
  nameCanvXY[0]=buf;
  sprintf(buf,"%s_S%iM%iL%iEffXY",fileName.Data(),
      sector+1,module+1,layer+1);
  nameCanvXY[1]=buf;
  sprintf(buf,"%s_S%iM%iL%iSinXY",fileName.Data(),
      sector+1,module+1,layer+1);
  nameCanvXY[2]=buf;
  sprintf(buf,"%s S%i M%i L%i Num. of hits",
                               fileName.Data(),sector+1,module+1,layer+1);
  titleCanvXY[0]=buf;
  sprintf(buf,"%s S%i M%i L%i Efficiency",
                               fileName.Data(),sector+1,module+1,layer+1);
  titleCanvXY[1]=buf;
  sprintf(buf,"%s S%i M%i L%i Fraction of single hits vs XY",
                               fileName.Data(),sector+1,module+1,layer+1);
  titleCanvXY[2]=buf;
  setBiningXY(1);
}

void HMdcEfficiencyLayer::addCellInClust(Short_t cell) {
  if(cell>=0 && cell<nCells) nClustCell[cell]++;
}

void HMdcEfficiencyLayer::addCellTot(Short_t cell) {
  if(cell>=0 && cell<nCells) nCellTot[cell]++;
}

void HMdcEfficiencyLayer::addCellCutS(Short_t cell) {
  if(cell>=0 && cell<nCells) nCellCutS[cell]++;
}

void HMdcEfficiencyLayer::addCellClus(Short_t cell) {
  if(cell>=0 && cell<nCells) nCellsClus[cell]++;
}

void HMdcEfficiencyLayer::addCell(Short_t cell) {
  if(cell>=0 && cell<nCells) {
   nClustCell[cell]++;
   nCellStat[cell]++;
  }
}

Int_t HMdcEfficiencyLayer::getCellStat(Short_t cell) {
  if(cell>=0 && cell<nCells) return nCellStat[cell];
  return 0;
}

void HMdcEfficiencyLayer::add0Hit(Short_t cell, Int_t nB) {
  if(cell>=0 && cell<nCells) n0[cell]++;
  if(nB>=0) n0xy[nB]++;
}

void HMdcEfficiencyLayer::add1Hit(Short_t cell, Int_t nB) {
  if(cell>=0 && cell<nCells) n1[cell]++;
  if(nB>=0) n1xy[nB]++;
}

void HMdcEfficiencyLayer::add2Hit(Short_t cell1, Short_t cell2, Int_t nB) {
  if(cell1>=0 && cell1<nCells && cell2>=0 && cell2<nCells) {
   n2[(cell1>cell2) ? cell1 : cell2]++;
  }
  if(nB>=0) n2xy[nB]++;
}

void HMdcEfficiencyLayer::getEffCells(HMdcEff* efficiency,
                                      Short_t fCell, Short_t lCell) {
  // Calculating of avarage value of efficiency (eff +/- errEff)
  // and fraction of singles hits (singles +/- errSingles)
  // for cells  fCell, fCell+1, ... lCell (for lCell-fCell+1 cells).
  //
  // getEfficiency(fCell) -
  // - for cell number fCell
  //
  // getEfficiency() -
  // - for all cells in layers.


  // Finding of working wires region
  Short_t fCellN=0;
  Short_t lCellN=nCells-1;
  for(Short_t cell=0; cell<nCells; cell++) {
    if(nCellStat[cell]>0) {
      if(nCellStat[cell]>10) fCellN=cell;
      break;
    }
  }
  for(Short_t cell=lCellN; cell>=0; cell--) {
    if(nCellStat[cell]>0) {
      if(nCellStat[cell]>10) lCellN=cell;
      break;
    }
  }

  Short_t fC=(fCell<fCellN) ? fCellN : fCell;
  Short_t lC=(lCell>lCellN) ? lCellN : lCell;
  if(fCell!=-1000 && lCell == 1000) lC=fC=fCell;
  Int_t nHits,nHitsNoCut,nHitsCutS,nHitsClus,nC0,nC1,nC2b,nC2m;
  nHits=nHitsNoCut=nHitsCutS=nHitsClus=nC0=nC1=nC2b=nC2m=0;
  Double_t eN0,eN1,eN2m,eN2b;
  eN0=eN1=eN2m=eN2b=0.;
  if(fC>=fCellN && lC<=lCellN) {
    for (Int_t cell=fC; cell<=lC; cell++) {
      nHits+=nCellStat[cell];
      nHitsNoCut+=nCellTot[cell];
      nHitsCutS+=nCellCutS[cell];
      nHitsClus+=nCellsClus[cell];
      nC0+=n0[cell];
      nC1+=n1[cell];
      if(cell>fC) nC2m+=n2[cell];
    }
    if(fC>fCellN) nC2b+=n2[fC];
    if(lC<lCellN) nC2b+=n2[lC+1];
    eN0=(nC0>0) ? sqrt((Double_t)nC0) : 1.;
    eN1=(nC1>0) ? sqrt((Double_t)nC1) : 1.;
    if(fC != lC) eN2m=(nC2m>0) ? sqrt((Double_t)nC2m) : 1.;
    if(fC>fCellN || lC<lCellN) eN2b=(nC2b>0) ? sqrt((Double_t)nC2b) : 1.;
  }

  efficiency->setTotNhits((Float_t)nHits);
  efficiency->setTotNhitsCutS((Float_t)nHitsCutS);
  efficiency->setTotNhitsNoCut((Float_t)nHitsNoCut);
  efficiency->setTotNhitsClus((Float_t)nHitsClus);
  efficiency->calcEff((Double_t)nC0, eN0,  (Double_t)nC1,  eN1,
 		      (Double_t)nC2m,eN2m, (Double_t)nC2b,eN2b);
}

void HMdcEfficiencyLayer::getEffXY(HMdcEff* efficiency) {
  // Calculation of efficiency of MDC layer.
  getEffXY(efficiency,0,15,0,15);
}

void HMdcEfficiencyLayer::getEffXY(HMdcEff* efficiency,
                              Short_t xBin, Short_t yBin){
  // Calculation of efficiency of MDC for bin (xBin:yBin).
  getEffXY(efficiency,xBin,xBin,yBin,yBin);
}

void HMdcEfficiencyLayer::getEffXY(HMdcEff* efficiency,
                                   Short_t fXbin, Short_t lXbin,
                                   Short_t fYbin, Short_t lYbin){
  // Calculation of efficiency of MDC ragion
  // (MDC is divided on 16x16 bins).
  // Region: fXbin <= x <= lXbin, fYbin <= y <= lYbin
  Int_t nC0,nC1,nC2;
  nC0=nC1=nC2=0;
  Double_t eN0,eN1,eN2;
  eN0=eN1=eN2=0.;

  Int_t fXb=(fXbin < 0 ) ?  0 : fXbin;
  Int_t lXb=(lXbin > 15) ? 15 : lXbin;
  Int_t fYb=(fYbin < 0 ) ?  0 : fYbin;
  Int_t lYb=(lYbin > 15) ? 15 : lYbin;
  for(Int_t y=fYb; y<=lYb; y++) {
    Int_t nBin=y*16;
    for(Int_t x=fXb; x<=lXb; x++){
      nC0+=n0xy[nBin+x];
      nC1+=n1xy[nBin+x];
      nC2+=n2xy[nBin+x];
    }
  }
  if(nC0+nC1+nC2 > 0) {
    eN0=(nC0>0) ? sqrt((Double_t)nC0) : 1.;
    eN1=(nC1>0) ? sqrt((Double_t)nC1) : 1.;
    eN2=(nC2>0) ? sqrt((Double_t)nC2) : 1.;
  }
  efficiency->calcEff((Double_t)nC0,eN0, (Double_t)nC1,eN1, (Double_t)nC2,eN2);
}

void HMdcEfficiencyLayer::fillHists(void) {
  Float_t max0=1.;
  Float_t max1=0.;
  for (Int_t bin=0; bin<nCells; bin++) {
    getEffCells(&eff, bin, bin);
    hists[0]->SetBinContent(bin+1,eff.getTotNhits());
    hists[1]->SetBinContent(bin+1,eff.getTotNhitsNoCut());
    hists[11]->SetBinContent(bin+1,eff.getTotNhitsCutS());
    hists[12]->SetBinContent(bin+1,eff.getTotNhitsClus());
    hists[2]->SetBinContent(bin+1,eff.getTotNumTracks());
    hists[3]->SetBinContent(bin+1,eff.getN0());
    hists[4]->SetBinContent(bin+1,eff.getN1());
    hists[5]->SetBinContent(bin+1,eff.getN2());
    hists[6]->SetBinContent(bin+1,eff.getEfficiency());
    hists[6]->SetBinError(bin+1,eff.getErrEfficiency());
    hists[7]->SetBinContent(bin+1,eff.getFracSingle());
    hists[7]->SetBinError(bin+1,eff.getErrFracSingle());
    hists[8]->SetBinContent(bin+1,eff.getP0());
    hists[8]->SetBinError(bin+1,eff.getErrP0());
    hists[9]->SetBinContent(bin+1,eff.getP1());
    hists[9]->SetBinError(bin+1,eff.getErrP1());
    hists[10]->SetBinContent(bin+1,eff.getP2());
    hists[10]->SetBinError(bin+1,eff.getErrP2());
    if(eff.getTotNhits()>max0) {
      Float_t dn=(eff.getTotNhitsNoCut()-eff.getTotNhits())/eff.getTotNhits();
      if(dn<0.2) max0=eff.getTotNhitsCutS(); // max after cut "common stop"
    }
    if(eff.getTotNumTracks()>max1) max1=eff.getTotNumTracks();
  }
  hists[1]->SetMaximum(max0+0.1*max0);
  for(Int_t n=2; n<6; n++) hists[n]->SetMaximum(max1+0.1*max1);
  getEffCells(&eff);
}


void HMdcEfficiencyLayer::setTitle(TH1F* &hist, Char_t* nm){
  Char_t title[50];
  sprintf(title,"%s vs wire",nm);
  hist->SetYTitle(title);
  hist->GetYaxis()->CenterTitle(1);
  hist->SetTitleOffset(0.6,"Y");
  hist->GetXaxis()->SetLabelSize(0.07);
  hist->GetYaxis()->SetLabelSize(0.07);
  hist->GetYaxis()->SetTitleSize(0.06);
  gStyle->SetOptStat(0);
}


void HMdcEfficiencyLayer::drawTotNhits(void) {
  hists[0]->SetFillColor(3);
  if(TMath::Abs(hists[0]->GetSumOfWeights()-hists[1]->GetSumOfWeights())>0.5) {
    Text_t title[90];
    Float_t h0=hists[0]->GetSumOfWeights();
    Float_t h1=hists[1]->GetSumOfWeights();
    Float_t h11=hists[11]->GetSumOfWeights();
    Float_t prCut=(h1-h0)/h1*100.;
    Float_t prCutS=(h1-h11)/h1*100.;
    Float_t prCutTD=(h11-h0)/h1*100.;
    sprintf(title,"S%i M%i L%i: Nhits (Com.stop cut(%6.2f%c)+times diff. cut(%6.2f%c)=%6.2f%c)",
        sector+1,module+1,layer+1,prCutS,'%',prCutTD,'%',prCut,'%');
    setTitle(hists[1],"Nhits");
    hists[1]->SetTitle(title);
    hists[1]->SetFillColor(4);
    hists[1]->Draw();
    hists[11]->SetFillColor(5);
    hists[11]->Draw("same");
    hists[0]->Draw("same");
    hists[12]->SetLineColor(6);
    hists[12]->Draw("same");
 } else {
    setTitle(hists[0],"Nhits");
    hists[0]->Draw();
    hists[12]->SetLineColor(6);
    hists[12]->Draw("same");  
  }
}

void HMdcEfficiencyLayer::drawNHits(void) {
  setTitle(hists[2],"N0,N1,N2,Ntr");
  Char_t title[80];
  sprintf(title,
      "S%i M%i L%i:  N0[r]=%.0f  N1[b]=%.0f N2[g]=%.0f Ntr[black]=%.0f",
      sector+1,module+1,layer+1,
      eff.getN0(),eff.getN1(),eff.getN2(),eff.getTotNumTracks());
  hists[2]->SetTitle(title);
  hists[2]->Draw();
  hists[3]->SetLineColor(2);
  hists[3]->Draw("same");
  hists[4]->SetLineColor(4);
  hists[4]->Draw("same");
  hists[5]->SetLineColor(3);
  hists[5]->Draw("same");
}

void HMdcEfficiencyLayer::drawHistEff(void) {
  // Drawing of the efficiency.
  setTitle(hists[6],"E");
  Char_t title[60];
  sprintf(title,"S%i M%i L%i:  E=%.3f+/-%.4f",sector+1,module+1,layer+1,
                       eff.getEfficiency(), eff.getErrEfficiency());
  hists[6]->SetTitle(title);
  hists[6]->Draw();
  drawLineTot(hists[6],2, eff.getEfficiency(), eff.getErrEfficiency());
}

void HMdcEfficiencyLayer::drawHistSing(void) {
  // Drawing of the fraction of single hits.
  setTitle(hists[7],"S");
  Char_t title[60];
  sprintf(title,"S%i M%i L%i:  S=%.3f+/-%.4f",sector+1,module+1,layer+1,
                       eff.getFracSingle(), eff.getErrFracSingle());
  hists[7]->SetTitle(title);
  hists[7]->Draw();
  drawLineTot(hists[7], 2, (Float_t)eff.getFracSingle(),
                           (Float_t)eff.getErrFracSingle());
}

void HMdcEfficiencyLayer::drawProbabilitis(void) {
  // Drawing of the probabilities.
  setTitle(hists[8],"P0,P1,P2");
  Char_t title[80];
  sprintf(title,
      "S%i M%i L%i:  P0=%.3f+/-%.4f(r) P1=%.3f+/-%.4f(b) P2=%.3f+/-%.4f(g)",
      sector+1,module+1,layer+1,eff.getP0(),eff.getErrP0(),
      eff.getP1(),eff.getErrP1(),eff.getP2(),eff.getErrP2());
  hists[8]->SetTitle(title);
  hists[8]->Draw();
  drawLineTot(hists[8], 2, (Float_t)eff.getP0(), (Float_t)eff.getErrP0());
  hists[9]->Draw("same");
  drawLineTot(hists[9], 4, (Float_t)eff.getP1(), (Float_t)eff.getErrP1());
  hists[10]->Draw("same");
  drawLineTot(hists[10], 3, (Float_t)eff.getP2(), (Float_t)eff.getErrP2());
}

void HMdcEfficiencyLayer::drawLineTot(TH1F* hst, Int_t color, Float_t eff,
                                                              Float_t errEff){
  Float_t xf=hst->GetXaxis()->GetBinLowEdge(hst->GetXaxis()->GetFirst());
  Float_t xl=hst->GetXaxis()->GetBinUpEdge(hst->GetXaxis()->GetLast());
  TLine lnEffLay;
  lnEffLay.SetLineStyle(1);
  lnEffLay.SetLineColor(color);
  lnEffLay.DrawLine(xf,eff,xl,eff);
  lnEffLay.SetLineStyle(2);
  lnEffLay.DrawLine(xf, eff+errEff, xl, eff+errEff);
  lnEffLay.DrawLine(xf, eff-errEff, xl, eff-errEff);
}

void HMdcEfficiencyLayer::setListPads(Int_t* listPad) {
  nPads=0;
  for(Int_t pad=0; pad<5; pad++) {
    if(listPad[pad]) {
      nPads++;
      listPads[pad]=1;
    }
    else listPads[pad]=0;
  }

  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  TCanvas* canv=(TCanvas*)fSegColl->FindObject(nameCanv);
  if(canv) {
    if(nPads>0) {
      Int_t nPd=0;
      if(nPads != (nPd=canv->GetListOfPrimitives()->GetSize())) {
       canv->Clear();
       if(nPd<3||nPads<3) canv->SetWindowSize(700,(nPads>3) ? 900 : nPads*300);
       setPads();
      }
      drawCanvas();
    }
    else canv->Clear();
  }
  for(Int_t nPl=0; nPl<3; nPl++) {
    if( listPad[nPl+1] == 1 ) continue;
    TCanvas* canv=(TCanvas*)fSegColl->FindObject(nameCanvXY[nPl]);
    if( canv ) delete canv;
    for(Int_t i=0; i<256; i++) indDrawPv[nPl][i]=1;
    indDrawTitXY[nPl]=1;
  }
}

void HMdcEfficiencyLayer::creatCanvas(void) {
  if(gROOT->GetListOfCanvases()->FindObject(nameCanv)) return;
  if(nPads==0) return;
  canvEff=new TCanvas(nameCanv,titleCanv,1,1,700,(nPads>3) ? 900 : nPads*300);
  setPads();
}

void HMdcEfficiencyLayer::setPads(void) {
  canvEff->Divide(1,nPads,0.0001,0.0001);
  for(Int_t nPad=0; nPad<nPads; nPad++) {
    canvEff->cd(nPad+1);
    TPad* pad = (TPad*)gPad;
    pad->SetRightMargin(0.03);
    pad->SetLeftMargin(0.08);
    pad->SetTopMargin(0.1);
    pad->SetBottomMargin(0.1);
  }
}

void HMdcEfficiencyLayer::updateCanv(void) {
  canvEff=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanv);
  if(!canvEff) return;
  drawCanvas();
}

void HMdcEfficiencyLayer::drawCanvas(void) {
  creatCanvas();
  Int_t nPad=1;
  for(Short_t pad=0; pad<6; pad++) {
    if(!listPads[pad]) continue;
    canvEff->cd(nPad++);
    if(pad==0) drawTotNhits();
    else if(pad==1) drawNHits();
    else if(pad==2) drawHistEff();
    else if(pad==3) drawHistSing();
    else if(pad==4) drawProbabilitis();
  }
  canvEff->cd();
  canvEff->Modified();
  canvEff->Update();
}

void HMdcEfficiencyLayer::delCanvas(void){
  canvEff=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanv);
  if(canvEff) {
    delete canvEff;
    canvEff=0;
  }
}

void HMdcEfficiencyLayer::setPavesXY(void) {
  Int_t nPavesSh=16/nBinsSumXY;
  Float_t bordX=0.05;
  Float_t bordY=0.05;
  Float_t dX=(1.-bordX*2)/nPavesSh;
  Float_t dY=(1.-bordY*2)/nPavesSh;
  for(Int_t yp=0; yp<16; yp++) {
    Float_t y1=bordY+yp*dY;
    Float_t y2=bordY+(yp+1)*dY;
    for(Int_t xp=0; xp<16; xp++) {
      for(Int_t i=0; i<3; i++) {
        pvTxEffXY[i][xp+yp*16].SetX1(bordX+xp*dX);
        pvTxEffXY[i][xp+yp*16].SetX2(bordX+(xp+1)*dX);
        pvTxEffXY[i][xp+yp*16].SetY1(y1);
        pvTxEffXY[i][xp+yp*16].SetY2(y2);
        pvTxEffXY[i][xp+yp*16].SetX1NDC(bordX+xp*dX);
        pvTxEffXY[i][xp+yp*16].SetX2NDC(bordX+(xp+1)*dX);
        pvTxEffXY[i][xp+yp*16].SetY1NDC(y1);
        pvTxEffXY[i][xp+yp*16].SetY2NDC(y2);
        pvTxEffXY[i][xp+yp*16].SetTextAlign(22);
        pvTxEffXY[i][xp+yp*16].SetTextSize(0);
        pvTxEffXY[i][xp+yp*16].SetBorderSize(1);
      }
    }
  }
}

void HMdcEfficiencyLayer::setBiningXY(Int_t nBinsSum) {
  Int_t nbnSm=8;
  if( nBinsSum <= 1 ) nbnSm=1;
  else if( nBinsSum < 4 ) nbnSm=2;
  else if( nBinsSum < 8 ) nbnSm=4;
  if(nbnSm == nBinsSumXY) return;
  nBinsSumXY=nbnSm;
  for(Int_t nPl=0; nPl<3; nPl++) {
    canvXY[nPl]=(TCanvas*)gROOT->GetListOfCanvases()->
        FindObject(nameCanvXY[nPl]);
    if( canvXY[nPl] ) {
      canvXY[nPl]->Clear();
      for(Int_t i=0; i<256; i++) {
        pvTxEffXY[nPl][i].Clear();
        indDrawPv[nPl][i]=1;
      }
      indDrawTitXY[nPl]=1;
    }
  }
  setPavesXY();
  drawCanvXY(1);
}

void HMdcEfficiencyLayer::drawCanvXYlist(void) {
  drawCanvXY(0);
}

void HMdcEfficiencyLayer::updateCanvXYlist(void) {
  drawCanvXY(1);
}

void HMdcEfficiencyLayer::delCanvXYlist(void) {
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  for(Int_t i=0; i<3; i++) {
    if( !listPads[i+1] ) continue;
    canvXY[i]=(TCanvas*)fSegColl->FindObject(nameCanvXY[i]);
    if(canvXY[i]) {
      delete canvXY[i];
      canvXY[i]=0;
    }
  }
}

void HMdcEfficiencyLayer::fillPaveXYnHits(Int_t nPv) {
  Float_t edgeCol[10]={.2,.4,.5,.7,.79,.85,.89,.92,.94,.951};
  Text_t buf[20];
  Int_t color=0;
  sprintf(buf,"N0:%.0f",effXY.getN0());
  pvTxEffXY[0][nPv].InsertText(buf);
  sprintf(buf,"N1:%.0f",effXY.getN1());
  pvTxEffXY[0][nPv].InsertText(buf);
  sprintf(buf,"N2:%.0f",effXY.getN2());
  pvTxEffXY[0][nPv].InsertText(buf);
  Float_t eff=effXY.getEfficiency();
  if(eff >= 0.95) {
    color=Int_t((eff-0.95)/0.005)+10;
    if(color > 19) color=19;
  }
  else {
    color=0;
    while(eff > edgeCol[color]) color++;
  }
  pvTxEffXY[0][nPv].SetFillColor(color+31);
}

void HMdcEfficiencyLayer::fillPaveXYeff(Int_t nPv) {
  Float_t edgeCol[10]={.2,.4,.5,.7,.79,.85,.89,.92,.94,.951};
  Text_t buf[20];
  Int_t color=0;
  Float_t eff=effXY.getEfficiency();
  sprintf(buf,"%5.3f",eff);
  pvTxEffXY[1][nPv].InsertText(buf);
  sprintf(buf,"+-%5.3f",effXY.getErrEfficiency());
  pvTxEffXY[1][nPv].InsertText(buf);
  if(eff >= 0.95) {
    color=Int_t((eff-0.95)/0.005)+10;
    if(color > 19) color=19;
  }
  else {
    color=0;
    while(eff > edgeCol[color]) color++;
  }
  pvTxEffXY[1][nPv].SetFillColor(color+31);
}

void HMdcEfficiencyLayer::fillPaveXYsing(Int_t nPv) {
  Text_t buf[20];
  Float_t frS=effXY.getFracSingle();
  sprintf(buf,"%5.3f",frS);
  pvTxEffXY[2][nPv].InsertText(buf);
  sprintf(buf,"+-%5.3f",effXY.getErrFracSingle());
  pvTxEffXY[2][nPv].InsertText(buf);
  Int_t color=Int_t(frS*20.)+1;
  if(color > 20) color=20;
  pvTxEffXY[2][nPv].SetFillColor(color+30);
}


void HMdcEfficiencyLayer::drawCanvXY(Int_t indUpDr) {
  // indUpDr=0 - draw canv
  // indUpDr=1 - update
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  for(Int_t nPl=0; nPl<3; nPl++) {
    canvXY[nPl]=(TCanvas*)fSegColl->FindObject(nameCanvXY[nPl]);
    if( indUpDr == 0 && canvXY[nPl] == 0 && listPads[nPl+1] ) {
      canvXY[nPl]=new TCanvas(nameCanvXY[nPl],titleCanvXY[nPl],1,1,600,600);
      for(Int_t i=0; i<256; i++) indDrawPv[nPl][i]=1;
      indDrawTitXY[nPl]=1;
    }
  }
  setPavesXY();
  for(Short_t xp=0; xp<16; xp+=nBinsSumXY) {
    for(Short_t yp=0; yp<16; yp+=nBinsSumXY) {
      getEffXY(&effXY,xp,xp+nBinsSumXY-1,yp,yp+nBinsSumXY-1);
      if(effXY.getTotNumTracks() > 0.) {
        Int_t nPv=xp/nBinsSumXY+(yp/nBinsSumXY)*16;
        for(Int_t nPl=0; nPl<3; nPl++) {
          if( canvXY[nPl] == 0 ) continue;
          canvXY[nPl]->cd();
          pvTxEffXY[nPl][nPv].Clear();
          if( nPl == 0) fillPaveXYnHits(nPv);
          else if( nPl == 1) fillPaveXYeff(nPv);
          else fillPaveXYsing(nPv);
          if( indDrawPv[nPl][nPv] ) {
            pvTxEffXY[nPl][nPv].Draw();
            indDrawPv[nPl][nPv]=0;
          }
        }
      }
    }
  }
  getEffXY(&effXY);
  for(Int_t nPl=0; nPl<3; nPl++) {
    if( canvXY[nPl] == 0 ) continue;
    canvXY[nPl]->cd();
    Text_t buf[80];
    if( nPl == 0 ) sprintf(buf,"S%i M%i L%i:  N0=%.0f  N1=%.0f N2=%.0f",
      sector+1,module+1,layer+1,
      effXY.getN0(),effXY.getN1(),effXY.getN2());
    else if( nPl == 1 ) sprintf(buf,"S%i M%i L%i:  E=%.3f+/-%.4f",sector+1,
      module+1,layer+1,effXY.getEfficiency(), effXY.getErrEfficiency());
    else sprintf(buf,"S%i M%i L%i:  S=%.3f+/-%.4f",sector+1,module+1,layer+1,
                       effXY.getFracSingle(), effXY.getErrFracSingle());
    titlePadXY[nPl].Clear();
    titlePadXY[nPl].InsertText(buf);
    if( indDrawTitXY[nPl] ) {
      titlePadXY[nPl].Draw();
      indDrawTitXY[nPl]=0;
    }
    canvXY[nPl]->Modified();
    canvXY[nPl]->Update();
  }
}

//------------------------------

HMdcEfficiencyMod::HMdcEfficiencyMod(Short_t sec, Short_t mod) {
  // constructor creates an array of pointers of type HMdcEfficiencyLayer
  sector=sec;
  module=mod;

  // Geting of pointers to par. cont.
  HMdcGetContainers* fGetCont=HMdcGetContainers::getObject();
  if( !fGetCont ) return;
  HMdcLookUpTb* fLookUpTb= HMdcLookUpTb::getExObject();
  HMdcLookupGeom* flookupGeom=fGetCont->getMdcLookupGeom();
  HMdcRawStruct* frawStruct=fGetCont->getMdcRawStruct();
//!!!  if( !fLookUpTb ) return;

  // Geting of proj. plane sizes
  if( fLookUpTb && &((*fLookUpTb)[sector]) ) {
    HMdcLookUpTbSec& flookutsec = (*fLookUpTb)[sec];
    xLow=flookutsec.getXlow();
    xUp=flookutsec.getXup();
    yLow=flookutsec.getYlow();
    yUp=flookutsec.getYup();
    dX=(xUp-xLow)/16;
    dY=(yUp-yLow)/16;
    // creating of arrays
    clear();
  } else {
    xLow=xUp=yLow=yUp=0.;
    dX=dY=-1.;
  }

  // geting of pointers to HMdcLookupGeom[sec][mod] and HMdcLookupRaw[sec][mod]
  flookupGMod=(flookupGeom) ? &(*flookupGeom)[sector][module] :0;
  frawModStru=(frawStruct) ? &(*frawStruct)[sector][module] : 0;

  hsEffMb=0;
  nChannels=0;
  for(Int_t i=0; i<9; i++) hsTimes[i]=0;
  for(Int_t i=0; i<15; i++) drHsTimes[i]=0;
  minTimeBin[0]=minTimeBin[1]=minTimeBin[2]=1000000.;
  maxTimeBin[0]=maxTimeBin[1]=maxTimeBin[2]=-100000.0;
  HMdcGetContainers::getFileName(fileName);
  Char_t name[20];
  if(flookupGMod && frawStruct) {
    Int_t nMoth=frawModStru->getNMotherboards();
    for(Int_t nMb=0; nMb<nMoth; nMb++) {
      HMdcRawMothStru* fMb=&(*frawModStru)[nMb];
      if(fMb) nChannels+=fMb->getNTdcs();
    }
    sprintf(name,"S%iM%iEffMb",sector+1,module+1);
    hsEffMb=new TH1F(name,"",nChannels,0.,nChannels/8);
    hsEffMb->SetOption("e1p");
    hsEffMb->SetMarkerStyle(21);
    hsEffMb->SetMarkerSize(0.3);
    hsEffMb->SetMarkerColor(4);
    hsEffMb->SetMaximum(1.1);
    hsEffMb->SetMinimum(0.0);
    hsEffMb->SetYTitle("Eff. vs. 1 chan. TDC");
    hsEffMb->SetXTitle("TDC");
    hsEffMb->SetNdivisions(0);
    sprintf(name,"S%iM%iEffMbS4",sector+1,module+1);
    hsEffMb4=new TH1F(name,"",nChannels/4,0.,nChannels/8);
    hsEffMb4->SetOption("e1p");
    hsEffMb4->SetMarkerStyle(21);
    hsEffMb4->SetMarkerSize(0.3);
    hsEffMb4->SetMarkerColor(4);
    hsEffMb4->SetMaximum(1.1);
    hsEffMb4->SetMinimum(0.0);
    hsEffMb4->SetYTitle("Eff. vs. 4 chan. TDC");
    hsEffMb4->SetXTitle("TDC");
    hsEffMb4->SetNdivisions(0);
  }
  Char_t* titT[25];
  Char_t* nmT[9];
  titT[0]="Time1";
  titT[1]="Time2";
  titT[2]="Time2-Time1";
  titT[3]="Time1 (clust.)";
  titT[4]="Time2 (clust.)";
  titT[5]="Time2-Time1 (clust.)";
  titT[6]="Time1 (sel.clust.)";
  titT[7]="Time2 (sel.clust.)";
  titT[8]="Time2-Time1 (sel.clust.)";
  nmT[0]="Time1a";
  nmT[1]="Time2a";
  nmT[2]="Time2m1a";
  nmT[3]="Time1c";
  nmT[4]="Time2c";
  nmT[5]="Time2m1c";
  nmT[6]="Time1sc";
  nmT[7]="Time2sc";
  nmT[8]="Time2m1sc";
  biningTimes=1;
  Char_t title[50];
  Int_t colors[3]={4,5,3};
  for(Int_t i=0; i<9; i++) {
    Axis_t x1=-1000.;
    Axis_t x2=3200.;
    Int_t nBHs=840;
    if( (i+1)%3 == 0 ) {
      x1=-100.;
      x2=900.;
       nBHs=500;
    }
    sprintf(name,"S%iM%i%s",sector+1,module+1,nmT[i]);
    sprintf(title,"S%i M%i: %s",sector+1,module+1,titT[i]);
    hsTimes[i]=new TH1F(name,title,nBHs,x1,x2);
    hsTimes[i]->SetFillColor(colors[i/3]);
    hsTimes[i]->SetLineColor(colors[i/3]);
  }

  // creating of HMdcEfficiencyLayer array
  array = new TObjArray(6);
  for (Short_t layer = 0; layer < 6; layer++) {
    (*array)[layer] = new HMdcEfficiencyLayer(sector,module,layer);
  }
  setNameCanv();
}

void HMdcEfficiencyMod::setNameCanv(void){
  for(Int_t nCanv=0; nCanv<5; nCanv++) canvases[nCanv]=0;
  Char_t buf[200];
  sprintf(buf,"%s_S%iM%i_Pattern",fileName.Data(),sector+1,module+1);
  nameCanv[0]=buf;
  sprintf(buf,"%s_S%iM%i_NtrNhits",fileName.Data(),sector+1,module+1);
  nameCanv[1]=buf;
  sprintf(buf,"%s_S%iM%i_Eff",fileName.Data(),sector+1,module+1);
  nameCanv[2]=buf;
  sprintf(buf,"%s_S%iM%i_SingC",fileName.Data(),sector+1,module+1);
  nameCanv[3]=buf;
  sprintf(buf,"%s_S%iM%i_Prob",fileName.Data(),sector+1,module+1);
  nameCanv[4]=buf;
  sprintf(buf,"%s S%i M%i Pattern",fileName.Data(),
      sector+1,module+1);
  titleCanv[0]=buf;
  sprintf(buf,"%s S%i M%i Num. of tracks and zero, single and double hits",
      fileName.Data(),sector+1,module+1);
  titleCanv[1]=buf;
  sprintf(buf,"%s S%i M%i Efficiency",fileName.Data(),sector+1,module+1);
  titleCanv[2]=buf;
  sprintf(buf,"%s S%i M%i Single hits fraction",fileName.Data(),
      sector+1,module+1);
  titleCanv[3]=buf;
  sprintf(buf,
      "%s S%i M%i Probability to have zero, single and double hit",
      fileName.Data(),sector+1,module+1);
  titleCanv[4]=buf;
  nPads=0;
  for(Int_t nLay=0; nLay<6; nLay++) listLayers[nLay]=0;
  canvasMb=0;
  sprintf(buf,"%s_S%iM%i_EffMb",fileName.Data(),sector+1,module+1);
  nameCanvMb=buf;
  sprintf(buf,"%s S%i M%i Cells efficiency",
      fileName.Data(),sector+1,module+1);
  titleCanvMb=buf;
  sprintf(nameSliderMb,"Sl_S%iM%iEffMb",sector+1,module+1);
  sprintf(buf,"%s_S%iM%i_Times",fileName.Data(),sector+1,module+1);
  nameCanvTimes=buf;
  sprintf(buf,"%s S%i M%i time1, time2, time2-time1 ",
      fileName.Data(),sector+1,module+1);
  titleCanvTimes=buf;
}

HMdcEfficiencyMod::~HMdcEfficiencyMod() {
  // destructor
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  canvasMb=(TCanvas*)fSegColl->FindObject(nameCanvMb);
  if( canvasMb ) delete canvasMb;
  TCanvas* canv=(TCanvas*)fSegColl->FindObject(nameCanvTimes);
  if( canv ) delete canv;
  for(Int_t i=0; i<5; i++) {
    canvases[i]=(TCanvas*)fSegColl->FindObject(nameCanv[i]);
    if( canvases[i] ) delete canvases[i];
  }
  if( array ) {
    array->Delete();
    delete array;
  }
}

void HMdcEfficiencyMod::clear(void) {
  for (Short_t xy=0; xy<256; xy++) n0xy[xy]=n1xy[xy]=n2xy[xy]=0;
}

Int_t HMdcEfficiencyMod::getBinNum(Float_t x, Float_t y) {
  if(dX<=0. || dY<=0.) return -1000000;
  Int_t nX=(Int_t)((x-xLow+dX)/dX)-1;
  Int_t nY=(Int_t)((y-yLow+dY)/dY)-1;
  if(nX<0 || nX>=16 || nY<0 || nY>=16) return -1;
  return nY*16+nX;
}

void HMdcEfficiencyMod::getEffXY(HMdcEffMod* efficiency) {
  // Calculation of efficiency of MDC layer.
  getEffXY(efficiency,0,15,0,15);
}

void HMdcEfficiencyMod::getEffXY(HMdcEffMod* efficiency,
                              Short_t xBin, Short_t yBin){
  // Calculation of efficiency of MDC for bin (xBin:yBin).
  getEffXY(efficiency,xBin,xBin,yBin,yBin);
}
void HMdcEfficiencyMod::getEffXY(HMdcEffMod* efficiency,
                                   Short_t fXbin, Short_t lXbin,
                                   Short_t fYbin, Short_t lYbin){
  // Calculation of efficiency of MDC ragion
  // (MDC is divided on 16x16 bins).
  // Region: fXbin <= x <= lXbin, fYbin <= y <= lYbin
  Int_t nC0,nC1,nC2;
  nC0=nC1=nC2=0;
  Double_t eN0,eN1,eN2;
  eN0=eN1=eN2=0.;

  Int_t fXb=(fXbin < 0 ) ?  0 : fXbin;
  Int_t lXb=(lXbin > 15) ? 15 : lXbin;
  Int_t fYb=(fYbin < 0 ) ?  0 : fYbin;
  Int_t lYb=(lYbin > 15) ? 15 : lYbin;
  for(Int_t y=fYb; y<=lYb; y++) {
    Int_t nBin=y*16;
    for(Int_t x=fXb; x<=lXb; x++){
      nC0+=n0xy[nBin+x];
      nC1+=n1xy[nBin+x];
      nC2+=n2xy[nBin+x];
    }
  }
  if(nC0+nC1+nC2 > 0) {
    eN0=(nC0>0) ? sqrt((Double_t)nC0) : 1.;
    eN1=(nC1>0) ? sqrt((Double_t)nC1) : 1.;
    eN2=(nC2>0) ? sqrt((Double_t)nC2) : 1.;
  }
  efficiency->calcEff((Double_t)nC0,eN0, (Double_t)nC1,eN1, (Double_t)nC2,eN2);
}

void HMdcEfficiencyMod::setListLayers(Int_t* listLay) {
  nPads=0;
  for(Int_t lay=0; lay<6; lay++) {
    listLayers[lay]=(listLay[lay]) ? 1:0;
    if(listLayers[lay]) nPads++;
  }
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  for(Int_t nCanv=0; nCanv<5; nCanv++) {
    TCanvas* canv=(TCanvas*)fSegColl->FindObject(nameCanv[nCanv]);
    if(!canv) continue;
    if(nPads>0) {
      Int_t nPd=0;
      if(nPads != (nPd=canv->GetListOfPrimitives()->GetSize())) {
        canv->Clear();
        if(nPd<3 || nPads<3) canv->SetWindowSize(700,(nPads>3) ? 900:nPads*300);
        setPads(canv);
      }
      if(nCanv==0) drawCanvTotNhits();
      else if(nCanv==1) drawCanvNHits();
      else if(nCanv==2) drawCanvHistEff();
      else if(nCanv==3) drawCanvHistSing();
      else if(nCanv==4) drawCanvProbabilitis();
    } else delete canv;
  }
}

void HMdcEfficiencyMod::creatCanvas(Int_t nCanv) {
  if(gROOT->GetListOfCanvases()->FindObject(nameCanv[nCanv])) return;
  if(nPads==0) return;
  canvases[nCanv]=new TCanvas(nameCanv[nCanv],titleCanv[nCanv],
 			    1,1,700,(nPads>3) ? 900 : nPads*300);
  setPads(canvases[nCanv]);
}

void HMdcEfficiencyMod::setPads(TCanvas* canv) {
  canv->Divide(1,nPads,0.0001,0.0001);
  for(Int_t nPad=0; nPad<nPads; nPad++) {
    canv->cd(nPad+1);
    canv->SetLeftMargin(0.05);
    canv->SetRightMargin(0.02);
    canv->SetBottomMargin(0.1);
    canv->SetTopMargin(0.15);
  }
  gStyle->SetOptStat(0);
}

void HMdcEfficiencyMod::updateCanv(void) {
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  for(Int_t nCanv=0; nCanv<5; nCanv++){
    TCanvas* canv=(TCanvas*)fSegColl->FindObject(nameCanv[nCanv]);
    if(!canv) continue;
    drawHists(nCanv);
  }
  if(fSegColl->FindObject(nameCanvMb)) drawCanvEffMb();
  if(fSegColl->FindObject(nameCanvTimes)) drawCanvTimes();
}

void HMdcEfficiencyMod::drawHists(Int_t nCanv) {
  Int_t nPad=1;
  for(Short_t lay=0; lay<6; lay++) {
    if(!listLayers[lay]) continue;
    canvases[nCanv]->cd(nPad++);
    if(nCanv==0) (*this)[lay].drawTotNhits();
    else if(nCanv==1) (*this)[lay].drawNHits();
    else if(nCanv==2) (*this)[lay].drawHistEff();
    else if(nCanv==3) (*this)[lay].drawHistSing();
    else if(nCanv==4) (*this)[lay].drawProbabilitis();
  }
  canvases[nCanv]->Modified();
  canvases[nCanv]->Update();
}

void HMdcEfficiencyMod::drawCanvTotNhits(void) {
  creatCanvas(0);
  drawHists(0);
}

void HMdcEfficiencyMod::saveCanvases(UInt_t saveAs) {
  Int_t nPadsTmp=nPads;
  nPads=6;
  TString nmCanv;
  for(Int_t nCanv=0; nCanv<5; nCanv++) {
    nmCanv=nameCanv[nCanv];
    nmCanv.Remove(0,fileName.Length()+1);
    TCanvas* canv=new TCanvas(nmCanv,titleCanv[nCanv],1,1,700,900);
    setPads(canv);
    for(Int_t lay=0; lay<6; lay++) {
      canv->cd(lay+1);
      if(nCanv==0) (*this)[lay].drawTotNhits();
      else if(nCanv==1) (*this)[lay].drawNHits();
      else if(nCanv==2) (*this)[lay].drawHistEff();
      else if(nCanv==3) (*this)[lay].drawHistSing();
      else if(nCanv==4) (*this)[lay].drawProbabilitis();
    }
    if(saveAs) canv->Write();
    delete canv;
  }
  nPads=nPadsTmp;
}

void HMdcEfficiencyMod::drawCanvNHits(void) {
  creatCanvas(1);
  drawHists(1);
}

void HMdcEfficiencyMod::drawCanvHistEff(void) {
  creatCanvas(2);
  drawHists(2);
}

void HMdcEfficiencyMod::drawCanvHistSing(void) {
  creatCanvas(3);
  drawHists(3);
}

void HMdcEfficiencyMod::drawCanvProbabilitis(void) {
  creatCanvas(4);
  drawHists(4);
}

void HMdcEfficiencyMod::delCanv(Int_t nCanv){
  if(gROOT->GetListOfCanvases()->FindObject(nameCanv[nCanv]))
    delete canvases[nCanv];
  canvases[nCanv]=0;
}

void HMdcEfficiencyMod::fillHistMb(void) {
  if( !flookupGMod || !frawModStru) return;
  Int_t bin=0;
  Int_t bin4=0;
  Int_t nMoth=frawModStru->getNMotherboards();
  for(Int_t nMb=0; nMb<nMoth; nMb++) {
    HMdcRawMothStru* fRMb=&(*frawModStru)[nMb];
    if(!fRMb) continue;
    Int_t nChan=fRMb->getNTdcs();
    HMdcLookupMoth* fMb=&(*flookupGMod)[nMb];
    for(Int_t nCh4=0; nCh4<nChan/4; nCh4++) {
      Int_t nLay4,nCell1,nCell2;
      nLay4=nCell1=nCell2=-1;
      bin4++;
      for(Int_t i4=0; i4<4; i4++) {
        Int_t nCh=nCh4*4+i4;
        bin++;
        if( !fMb ) continue;
        HMdcLookupChan* fchan=&(*fMb)[nCh];
        if( !fchan ) continue;
        Int_t layer=fchan->getNLayer();
        Int_t cell=fchan->getNCell();
        if(cell<0 || layer<0) continue;
        HMdcEfficiencyLayer& flay=(*this)[layer];
        flay.getEffCells(&eff, cell);
        hsEffMb->SetBinContent(bin,eff.getEfficiency());
        hsEffMb->SetBinError(bin,eff.getErrEfficiency());
        if(nLay4==-1) {
          nCell1=nCell2=cell;
          nLay4=layer;
        } else {
          if(nLay4 != layer) Error("fillHistMb","nLay4 != layer");
          nCell2=cell;
        }
      }
      if(nCell1>nCell2) {
        Int_t tmp=nCell1;
        nCell1=nCell2;
        nCell2=tmp;
      }
      if(nLay4>=0 && nCell1>=0 && nCell2-nCell1<4) {
        HMdcEfficiencyLayer& flay=(*this)[nLay4];
        flay.getEffCells(&eff, nCell1, nCell2);
        hsEffMb4->SetBinContent(bin4,eff.getEfficiency());
        hsEffMb4->SetBinError(bin4,eff.getErrEfficiency());
      }
    }
  }
  getEffXY(&effMod);
  Char_t title[70];
  sprintf(title,"Sec.%i Mod.%i :     E=%.4f +/- %.5f",sector+1,module+1,
             effMod.getEfficiency(),effMod.getErrEfficiency());
  hsEffMb->SetTitle(title);
}

void HMdcEfficiencyMod::drawCanvEffMb(void) {
  if( !flookupGMod || !frawModStru) return;
  canvasMb=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanvMb);
  if( !canvasMb ) {
    canvasMb = new TCanvas(nameCanvMb,titleCanvMb,1,1,1000,600);
    creatCanvEffMb(canvasMb);
  }
  fillCanvEffMb(canvasMb);
  if(!(TSlider*)gROOT->FindObject(nameSliderMb)) {
    canvasMb->cd();
    Float_t x1=0.05;
    Float_t x2=0.98;
    mbSlider=new TSlider(nameSliderMb,"", x1,0.49,x2, 0.53);
    mbSlider->SetObject(this);

    Int_t nChan=0;
    Int_t nMoth=frawModStru->getNMotherboards();
    for(Int_t nMb=0; nMb<nMoth; nMb++) {
      HMdcRawMothStru* fMb=&(*frawModStru)[nMb];
      if( !fMb ) continue;
      Float_t x1p=Float_t(nChan)/Float_t(nChannels)*(x2-x1)+x1;
      nChan+=fMb->getNTdcs();
      Float_t x2p=Float_t(nChan)/Float_t(nChannels)*(x2-x1)+x1;
      Text_t nameMb[10];
      sprintf(nameMb,"%i : %s",nMb+1,fMb->GetName());
      TPaveLabel* pave = new TPaveLabel(x1p,0.45,x2p,0.48,nameMb);
      pave->SetBorderSize(1);
      pave->Draw();
    }
  }
  mbSlider->SetRange(
      Double_t(hsEffMb->GetXaxis()->GetFirst())/Double_t(nChannels),
      Double_t(hsEffMb->GetXaxis()->GetLast())/Double_t(nChannels));
  canvasMb->cd(0);
  canvasMb->Modified();
  canvasMb->Update();
}

void HMdcEfficiencyMod::saveCanvEffMb(UInt_t saveAs) {
  if( !flookupGMod || !frawModStru) return;
  TString nmCanv=nameCanvMb;
  nmCanv.Remove(0,fileName.Length()+1);
  TCanvas* canv = new TCanvas(nmCanv,titleCanvMb,1,1,1000,600); 
  canv->cd();
  Float_t x1=0.05;
  Float_t x2=0.98;
  Int_t nChan=0;
  Int_t nMoth=frawModStru->getNMotherboards();
  for(Int_t nMb=0; nMb<nMoth; nMb++) {
    HMdcRawMothStru* fMb=&(*frawModStru)[nMb];
    if( !fMb ) continue;
    Float_t x1p=Float_t(nChan)/Float_t(nChannels)*(x2-x1)+x1;
    nChan+=fMb->getNTdcs();
    Float_t x2p=Float_t(nChan)/Float_t(nChannels)*(x2-x1)+x1;
    Text_t nameMb[10];
    sprintf(nameMb,"%i : %s",nMb+1,fMb->GetName());
    TPaveLabel* pave = new TPaveLabel(x1p,0.45,x2p,0.48,nameMb);
    pave->SetBorderSize(1);
    pave->Draw();
  }
  canv->cd();
  creatCanvEffMb(canv);
  fillCanvEffMb(canv);
  canv->Modified();
  canv->Update();
  if(saveAs==1) canv->Write();
  delete canv;
}

void HMdcEfficiencyMod::creatCanvEffMb(TCanvas* canv) {
  canv->Divide(1,2);
  canv->cd(1);
  canv->SetBorderMode(0);
  canv->SetFillColor(10);

  TPad *upPad = (TPad*)gPad;
  upPad->SetPad(0.0,0.53,1.,1.);
  upPad->SetRightMargin(0.02);
  upPad->SetLeftMargin(0.05);
  upPad->SetTopMargin(0.1);
  upPad->SetFillColor(10);
  canv->cd(2);
  TPad *lowPad = (TPad*)gPad;
  lowPad->SetPad(0.0,0.0,1.,0.44);
  lowPad->SetRightMargin(0.02);
  lowPad->SetLeftMargin(0.05);
  lowPad->SetTopMargin(0.02);
  lowPad->SetFillColor(10);
}

void HMdcEfficiencyMod::fillCanvEffMb(TCanvas* canv) {
  canv->cd();
  gStyle->SetOptStat(0);
  canv->cd(1);
  gPad->SetFrameFillColor(10);
  hsEffMb->GetXaxis()->SetTitleSize(0.06);
  hsEffMb->SetTitleOffset(0.45,"Y");;
  hsEffMb->SetTitleOffset(0.8,"X");
  hsEffMb->GetYaxis()->SetTitleSize(0.05);
  hsEffMb->GetXaxis()->SetTitleSize(0.05);
  hsEffMb->GetYaxis()->CenterTitle(1);
  hsEffMb->GetXaxis()->SetLabelSize(0.05);
  hsEffMb->GetYaxis()->SetLabelSize(0.05);
  hsEffMb->Draw();
  drawLineEffMb(hsEffMb);
  drawLineGrMb(hsEffMb);
  canv->cd(2);
  gPad->SetFrameFillColor(10);
  hsEffMb4->SetTitleOffset(0.45,"Y");
  hsEffMb4->SetTitleOffset(0.8,"X");
  hsEffMb4->GetYaxis()->SetTitleSize(0.05);
  hsEffMb4->GetXaxis()->SetTitleSize(0.05);
  hsEffMb4->GetYaxis()->CenterTitle(1);
  hsEffMb4->GetXaxis()->SetLabelSize(0.05);
  hsEffMb4->GetYaxis()->SetLabelSize(0.05);
  hsEffMb4->Draw();
  drawLineEffMb(hsEffMb4);
  drawLineGrMb(hsEffMb4);
  gStyle->SetOptStat(0);
}

void HMdcEfficiencyMod::drawLineGrMb(TH1F* hst) {
  Float_t ymin=hst->GetMinimum();
  Float_t ymax=hst->GetMaximum();
  Float_t xf=hst->GetXaxis()->GetBinLowEdge(hst->GetXaxis()->GetFirst());
  Float_t xl=hst->GetXaxis()->GetBinUpEdge(hst->GetXaxis()->GetLast());
  TLine lineMb;
  lineMb.SetLineColor(3);
  Int_t nChan=0;
  Int_t nMoth=frawModStru->getNMotherboards();
  TText lbMb;
  for(Int_t nMb=0; nMb<nMoth; nMb++) {
    HMdcRawMothStru* fMb=&(*frawModStru)[nMb];
    if( !fMb ) continue;
    Int_t nChMoth=fMb->getNTdcs();
    lineMb.SetLineStyle(2);
    lineMb.SetLineColor(3);
    for(Int_t nTDC=0; nTDC<nChMoth/8; nTDC++) {
      lbMb.SetTextColor(3);
      Float_t x=Float_t(nChan/8+nTDC);
      if(x>xf && x<xl && nTDC>0) lineMb.DrawLine(x, ymin, x, ymax);
      if(x>=xf && x<xl) {
        Text_t labl[3];
        if( xl-xf <= 56.) {
          sprintf(labl,"%i",nTDC+1);
          lbMb.SetTextAlign(23);
          lbMb.DrawText(x+0.5,ymin-(ymax-ymin)*0.005,labl);
        }
        else if( nTDC==0 || nTDC==nChMoth/8-1 ) {
          sprintf(labl,"%i",nTDC+1);
          Int_t indFL=(nTDC+1)/(nChMoth/8);
          lbMb.SetTextAlign((indFL*2+1)*10+3);
          lbMb.DrawText(x+indFL+(1-indFL*2)*0.3,ymin-(ymax-ymin)*0.005,labl);
        }

      }
    }
    Float_t x=Float_t(nChan/8);
    if(x>=xf && x<=xl) {
      Text_t labl[3];
      sprintf(labl,"%i",nMb+1);
      lbMb.SetTextColor(1);
      lbMb.SetTextAlign(23);
      lbMb.DrawText(x,ymin-(ymax-ymin)*0.05,labl);
    }
    nChan+=nChMoth;
    lineMb.SetLineColor(6);
    lineMb.SetLineStyle(1);
    x=Float_t(nChan/8);
    if(x>xf && x<xl) lineMb.DrawLine(x, ymin-(ymax-ymin)*0.05, x, ymax);
  }
}

void HMdcEfficiencyMod::drawLineEffMb(TH1F* hst) {
  Float_t xf=hst->GetXaxis()->GetBinLowEdge(hst->GetXaxis()->GetFirst());
  Float_t xl=hst->GetXaxis()->GetBinUpEdge(hst->GetXaxis()->GetLast());
  TLine lnEffMod;
  lnEffMod.SetLineStyle(1);
  lnEffMod.SetLineColor(2);
  lnEffMod.DrawLine(xf,effMod.getEfficiency(),
                    xl,effMod.getEfficiency());
  lnEffMod.SetLineStyle(2);
  lnEffMod.DrawLine(xf,effMod.getEfficiency()+effMod.getErrEfficiency(),
                    xl,effMod.getEfficiency()+effMod.getErrEfficiency());
  lnEffMod.DrawLine(xf,effMod.getEfficiency()-effMod.getErrEfficiency(),
                    xl,effMod.getEfficiency()-effMod.getErrEfficiency());
}

void HMdcEfficiencyMod::delCanvMb(void){
  canvasMb=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanvMb);
  if( canvasMb ) {
    delete canvasMb;
    canvasMb=0;
  }
}

void HMdcEfficiencyMod::fillTimes(HMdcCal1* cal, Bool_t isGnt, Int_t nHist) {
  if( !hsTimes[nHist] ) return;
  if(cal==0) return;
  // nHits==0 tested befor call to this function.
  Int_t nHits=abs(cal->getNHits());
  Bool_t tm1=kTRUE;
  Bool_t tm2=(nHits==2) ? kTRUE:kFALSE;
  if(isGnt) {
    HMdcCal1Sim* calS=(HMdcCal1Sim*)cal;
    if(calS->getStatus1()<0) tm1=kFALSE;
    if(nHits==2 && calS->getStatus2()<0) tm2=kFALSE;
  }
  if(tm1) {
    Float_t time=cal->getTime1();
    if(hsTimes[nHist]) hsTimes[nHist]->Fill(time);
    if( nHist == 0 /* && time > -998.*/ ) {
      if( time < minTimeBin[0] ) minTimeBin[0]=time;
      if( time > maxTimeBin[0] ) maxTimeBin[0]=time;
    }
  }
  if( tm2 ) {
    Float_t time=cal->getTime2();
    if(hsTimes[nHist+1]) hsTimes[nHist+1]->Fill(time);
    if( nHist == 0 /* && time > -998.*/ ) {
      if( time < minTimeBin[1] ) minTimeBin[1]=time;
      if( time > maxTimeBin[1] ) maxTimeBin[1]=time;
    }
  }
  if(tm1 && tm2) {
    Float_t time=cal->getTime2()-cal->getTime1();
    if(hsTimes[nHist+2]) hsTimes[nHist+2]->Fill(time);
    if( nHist == 0 /* && time > -998.*/ ) {
      if( time < minTimeBin[2] ) minTimeBin[2]=time;
      if( time > maxTimeBin[2] ) maxTimeBin[2]=time;
    }
  }
}

void HMdcEfficiencyMod::delCanvTimes(void) {
  TCanvas* canv=(TCanvas*)gROOT->GetListOfCanvases()->
      FindObject(nameCanvTimes);
  if(canv) delete canv;
}

void HMdcEfficiencyMod::drawCanvTimes(Int_t bining, UInt_t saveAs) {
  if(bining>0 && bining <=100) biningTimes=bining;
  TCanvas* canv=0;
  if(saveAs==0) {
    canv=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanvTimes);
    if( !canv ) {
      canv = new TCanvas(nameCanvTimes,titleCanvTimes,300, 200,800, 700);
      canv->Divide(3,2);
      canv->SetBorderMode(0);
      canv->SetFillColor(10);
    }
  } else {
    TString nmCanv;
    nmCanv=nameCanvTimes;
    nmCanv.Remove(0,fileName.Length()+1);
    canv = new TCanvas(nmCanv,titleCanvTimes,300, 200,800, 700);
    canv->Divide(3,2);
    canv->SetBorderMode(0);
    canv->SetFillColor(10);
  }
  Text_t buf[80];
  for(Int_t i=0; i<15; i++) {
    if(drHsTimes[i]) delete (drHsTimes[i]);
    if( i < 9 ) {
      drHsTimes[i] = new TH1F(*hsTimes[i]);
      sprintf(buf,"%sR",hsTimes[i]->GetName());
      drHsTimes[i]->SetName(buf);
      if( biningTimes > 1 ) drHsTimes[i]->Rebin(biningTimes);
    } else if( i < 12 ) {
      drHsTimes[i] = new TH1F(*drHsTimes[i-3]);
      drHsTimes[i]->Sumw2();
      drHsTimes[i]->Divide(drHsTimes[i-9]);
      sprintf(buf,"%s (clust.fraction)",hsTimes[i-9]->GetTitle());
      drHsTimes[i]->SetTitle(buf);
      sprintf(buf,"%sdC",hsTimes[i-9]->GetName());
      drHsTimes[i]->SetName(buf);
    } else  {
      drHsTimes[i] = new TH1F(*drHsTimes[i-9]);
      drHsTimes[i]->Sumw2();
      drHsTimes[i]->Divide(drHsTimes[i-12]);
      sprintf(buf,"%s (clust.fraction)",hsTimes[i-12]->GetTitle());
      drHsTimes[i]->SetTitle(buf);
      sprintf(buf,"%sdSC",hsTimes[i-12]->GetName());
      drHsTimes[i]->SetName(buf);
    }
  }
  for(Int_t i=0; i<15; i++)  {
    drHsTimes[i]->SetAxisRange(minTimeBin[i%3]-10.0,maxTimeBin[i%3]+10.0);
  }
  for(Int_t i=0; i<3; i++) {
    canv->cd(i+1);
    drHsTimes[i]->SetFillColor(4);
    drHsTimes[i]->SetLineColor(4);
    drHsTimes[i]->Draw();
    drHsTimes[i+3]->SetLineColor(6);
    drHsTimes[i+3]->SetFillColor(6);
    drHsTimes[i+3]->Draw("same");
    drHsTimes[i+6]->Draw("same");
    canv->cd(i+4);
    drHsTimes[i+12]->SetLineColor(6);
    drHsTimes[i+12]->SetFillColor(6);
    drHsTimes[i+12]->SetMaximum(1.1);
    drHsTimes[i+12]->Draw("hist");
    drHsTimes[i+9]->SetFillColor(3);
    drHsTimes[i+9]->SetLineColor(3);
    drHsTimes[i+9]->Draw("samehist");
  }
  canv->Modified();
  canv->Update();
  if(saveAs) {
    canv->Write();
    delete canv;
  }
}

void HMdcEfficiencyMod::ExecuteEvent(Int_t event, Int_t px, Int_t py){
  if(event != 11) return;
  mbSlider=(TSlider*)gROOT->FindObject(nameSliderMb);
  if(!mbSlider) return;
  Int_t nTDC=hsEffMb->GetNbinsX()/32;
  Float_t min=mbSlider->GetMinimum();
  if(min<0.) min=0.;
  Float_t max=mbSlider->GetMaximum();
  Int_t nBmin=Int_t(nTDC*min+0.1);
  if(nBmin==nTDC) nBmin--;
  Int_t nBmax=Int_t(nTDC*max+0.1);
  if(nBmax==nBmin) nBmax++;
  canvasMb->cd(1);
  hsEffMb->SetAxisRange(nBmin*4,nBmax*4-0.0001);
  hsEffMb->Draw();
  drawLineEffMb(hsEffMb);
  drawLineGrMb(hsEffMb);
  mbSlider->SetRange(Float_t(nBmin)/nTDC,Float_t(nBmax)/nTDC);
  canvasMb->Update();
}

//--Sector--------------------------

HMdcEfficiencySec::HMdcEfficiencySec(Short_t sec) {
  // constructor creates an array of pointers of type
  // HMdcEfficiencyMod
  sector=sec;
  array = new TObjArray(4);
  HMdcGetContainers* fGetCont=HMdcGetContainers::getObject();
  HMdcGetContainers::getFileName(fileName);
  HMdcDetector* fMdcDetector=fGetCont->getMdcDetector();
  for (Short_t mod = 0; mod < 4; mod++) {
   if( fMdcDetector->getModule(sector,mod) ) {
      (*array)[mod] = new HMdcEfficiencyMod(sec,mod);
   }
  }
  Char_t buf[200];
  sprintf(buf,"%s_S%i_ProjPl",fileName.Data(),sector+1);
  nameCanvProj=buf;
  sprintf(buf,"%s S%i Cells projections",fileName.Data(),sector+1);
  titleCanvProj=buf;
  sprintf(buf,"%s_S%i_HitsPl",fileName.Data(),sector+1);
  nameCanvHits=buf;
  sprintf(buf,"%s S%i MDC hits",fileName.Data(),sector+1);
  titleCanvHits=buf;
  plotHits[0]=plotHits[1]=0;
}

HMdcEfficiencySec::~HMdcEfficiencySec() {
  // destructor
  TSeqCollection* fSegColl=gROOT->GetListOfCanvases();
  canvPlotProj=(TCanvas*)fSegColl->FindObject(nameCanvProj);
  if( canvPlotProj ) {
    delete canvPlotProj;
    canvPlotProj=0;
  }
  canvPlotsHits=(TCanvas*)fSegColl->FindObject(nameCanvHits);
  if( canvPlotsHits ) {
    delete canvPlotsHits;
    canvPlotsHits=0;
  }
  if( array ) {
    array->Delete();
    delete array;
  }
}

void HMdcEfficiencySec::creatPlots(HMdcLookUpTbSec* flookupTbSec) {
  if(flookupTbSec==0) return;
  Int_t nBinX=flookupTbSec->getNBinX();
  Int_t nBinY=flookupTbSec->getNBinY();
  Float_t xLow=flookupTbSec->getXlow();
  Float_t xUp=flookupTbSec->getXup();
  Float_t yLow=flookupTbSec->getYlow();
  Float_t yUp=flookupTbSec->getYup();
  Char_t buf[100];
  sprintf(buf,"S%iAllClust.",sector+1);
  plotHits[0]=new TH2F(buf,"",nBinX,xLow,xUp,nBinY,yLow,yUp);
  sprintf(buf,"S%iSelClust.",sector+1);
  plotHits[1]=new TH2F(buf,"",nBinX,xLow,xUp,nBinY,yLow,yUp);
  sprintf(buf,"S%i All clusters",sector+1);
  plotHits[0]->SetTitle(buf);
  sprintf(buf,"S%i Selected clusters",sector+1);
  plotHits[1]->SetTitle(buf);
  plotHits[0]->SetXTitle("x, (mm)");
  plotHits[0]->SetYTitle("y, (mm)      ");
  plotHits[1]->SetXTitle("x, (mm)");
  plotHits[1]->SetYTitle("y, (mm)      ");

}

void HMdcEfficiencySec::drawCanvProj(void) {
  if(gROOT->GetListOfCanvases()->FindObject(nameCanvProj)) return;
  canvPlotProj=new TCanvas(nameCanvProj,titleCanvProj,300,1,500,600);
  canvPlotProj->SetFillColor(10);
}

void HMdcEfficiencySec::delCanvProj(void){
  canvPlotProj=(TCanvas*)gROOT->GetListOfCanvases()->
      FindObject(nameCanvProj);
  if(canvPlotProj) {
    delete canvPlotProj;
    canvPlotProj=0;
  }
}

void HMdcEfficiencySec::drawCanvHits(void) {
  if(gROOT->GetListOfCanvases()->FindObject(nameCanvHits)) return;
  canvPlotsHits=new TCanvas(nameCanvHits,titleCanvHits,
      100,300,800,400);
  canvPlotsHits->Divide(2,1,0.0001,0.0001);
  canvPlotsHits->SetFillColor(10);
}

void HMdcEfficiencySec::saveCanvHits(UInt_t saveAs) {
  if(plotHits[0]==0 || plotHits[1]==0) return;
  TString nmCanv=nameCanvHits;
  nmCanv.Remove(0,fileName.Length()+1);
  TCanvas* canv=new TCanvas(nmCanv,titleCanvHits,100,300,800,400);
  canv->Divide(2,1,0.0001,0.0001);
  canv->SetFillColor(10);
  canv->cd(1);
  plotHits[0]->Draw();
  canv->cd(2);
  plotHits[1]->Draw();
  canv->Modified();
  canv->Update();
  if(saveAs==1) canv->Write();
  delete canv;
}
void HMdcEfficiencySec::delCanvHits(void){
  canvPlotsHits=(TCanvas*)gROOT->GetListOfCanvases()->
      FindObject(nameCanvHits);
  if(canvPlotsHits) {
    delete canvPlotsHits;
    canvPlotsHits=0;
  }
}

//------------------------------------------------

HMdcEfficiency::HMdcEfficiency() {
  initSecArray();
}

HMdcEfficiency::HMdcEfficiency(Text_t *name,Text_t *title) :
                                           HReconstructor(name,title) {
  initSecArray();
}

void HMdcEfficiency::initSecArray(void) {
  fCalCat=0;
  fLookUpTb=0;
  iter=0;
  eventId=0;
  fMdcDetector=0;
  isCreated=kFALSE;
  array = new TObjArray(6);
  firstEvent=kTRUE;
}

HMdcEfficiency::~HMdcEfficiency() {
  // destructor
  if( array ) {
    array->Delete();
    delete array;
  }
  canvEventProj=(TCanvas*)gROOT->GetListOfCanvases()->
      FindObject(nameCanvEvent);
  if( canvEventProj ) {
    delete canvEventProj;
    canvEventProj=0;
  }
  if(iter) {
    delete iter;
    iter = 0;
  }
  if(iterClus) {
    delete iterClus;
    iterClus = 0;
  }
}

Bool_t HMdcEfficiency::init(void) {

  fGetCont=HMdcGetContainers::getObject();
  if( !fGetCont ) return kFALSE;
  fLookUpTb=HMdcLookUpTb::getExObject();
  fSizesCells=HMdcSizesCells::getObject();
  fcut=HMdcTimeCut::getExObject();
  if(fcut && fcut->getIsUsed()) fcut=0;
  fMdcDetector      = fGetCont->getMdcDetector();
  if(!fSizesCells || !fMdcDetector) return kFALSE;

  fClusCat=HMdcGetContainers::getCatMdcClus();
  if( !fClusCat ) return kFALSE;

  fCalCat=gHades->getCurrentEvent()->getCategory(catMdcCal1);
//  if (!fCalCat) return kFALSE;
  isGeant=HMdcGetContainers::isGeant();
  iter=0;
  if(fCalCat) iter=(HIterator *)fCalCat->MakeIterator("native");
  for(Int_t i=31; i<51; i++) {
    TColor* cl=gROOT->GetColor(i);
    Float_t gr=(i-30)/20.;
    cl->SetRGB(1.-gr,gr,0.);
  }
  Int_t pal[12] = {17,16,15,14,13,12, 30,7,5,4,6,3};
  gStyle->SetPalette(12,pal);

  loc.set(4,0,0,0,0);
  iterClus=(HIterator *)fClusCat->MakeIterator();
  
  Char_t buf[200];
  sprintf(buf,"ProjPlEvent");
  nameCanvEvent=buf;
  sprintf(buf,"Cells projections");
  titleCanvEvent=buf;

  return kTRUE;
}

Bool_t HMdcEfficiency::reinit(void) {
  if( isCreated ) return kTRUE;
  if( fLookUpTb && !HMdcGetContainers::isInited(fLookUpTb) ) return kFALSE;
  if(!fSizesCells->initContainer()) return kFALSE;
  for (Short_t sec = 0; sec < 6; sec++) {
    if(!fMdcDetector->isSectorActive(sec) ) continue;
    HMdcEfficiencySec* fsec=(HMdcEfficiencySec*)(*array)[sec];
    if( !fsec ) {
      fsec=new HMdcEfficiencySec(sec);
      (*array)[sec] = fsec;
      if(fLookUpTb) fsec->creatPlots(&(*fLookUpTb)[sec]);
    }
    if(fLookUpTb) {
      HMdcLookUpTbSec& fLUTbSec=(*fLookUpTb)[sec];
      if(!&fLUTbSec) return kFALSE;
    }
  }
  evHeader=gHades->getCurrentEvent()->getHeader();
  if(!evHeader) {
    Error("reinit","Can't get pointer to event header.");
    return kFALSE;
  }
  isCreated=kTRUE;
  return kTRUE;
}

Int_t HMdcEfficiency::execute(void) {
  if(firstEvent) extractFileInfo();
  eventId=evHeader->getEventSeqNumber();
  
  //--------Num. clusters have cell ...------------------------
  for(Short_t sec=0; sec<6; sec++) {
    HMdcEfficiencySec& fsec=(*this)[sec];
    if(!&fsec) continue;
    for(Short_t mod=0; mod<4; mod++) {
      HMdcEfficiencyMod& fmod=fsec[mod];
      if(!&fmod) continue;
      for(Short_t lay=0; lay<6; lay++) {
        HMdcEfficiencyLayer& flay=fmod[lay];
        memset(flay.nClustCell,0,flay.nCells);
      }
    }
  }
  Int_t cellF[6];
  Int_t cellL[6];
  if(fCalCat) {
    iter->Reset();
    // Geant data ===========
    if(isGeant) {
      HMdcCal1Sim* cal=0;
      while ((cal=(HMdcCal1Sim *)iter->Next())!=0) {
        Int_t nHits=abs(cal->getNHits());
        if(nHits==0) continue;
        if(nHits==1 && cal->getStatus1()<0) continue;
        if(nHits==2 && cal->getStatus1()<0 && cal->getStatus2()<0) continue;
        Int_t s,m,l,c;
        cal->getAddress(s,m,l,c);
        if(&(*this)[s][m][l]) {
          (*this)[s][m][l].addCell(c);
          (*this)[s][m][l].addCellTot(c);
        }
        if( &(*this)[s][m] ) (*this)[s][m].fillTimesAll(cal,isGeant);
      }
    } else { // Real data ===========
      HMdcCal1* cal=0;
      while ((cal=(HMdcCal1 *)iter->Next())!=0) {
        Int_t s,m,l,c;
        if(cal->getNHits()==0) continue;
        cal->getAddress(s,m,l,c);
        HMdcEfficiencySec &fsec=(*this)[s];
        if( !&fsec ) continue;
        HMdcEfficiencyMod &fmod=fsec[m];
        if( !&fmod ) continue;
        fmod.fillTimesAll(cal,isGeant);
        HMdcEfficiencyLayer &flay=fmod[l];
        if(c<0 || c >flay.nCells) continue;
        flay.nCellTot[c]++;
        if(fcut) {
          if(fcut->cutComStop(cal)) continue;
          flay.nCellCutS[c]++;
          if(fcut->cut(cal)) continue;	 // Cut drift time
        }
        flay.nClustCell[c]++;
        flay.nCellStat[c]++;
      }
    }
  }
  //-----------------------------------------------------------
  iterClus->Reset();
  HMdcClus* fClus;
  while((fClus=(HMdcClus*)iterClus->Next())) {
    Int_t sec=fClus->getSec();
    HMdcEfficiencySec& fsec=(*this)[sec];
    if(!(&fsec)) continue;
    //===Selecting of clusters (tracks)===========================
    Int_t seg=fClus->getIOSeg();
    loc[0]=sec;
    for(Int_t m=0; m<2; m++) {
      Int_t nLayers=fClus->getNLayersMod(m);
      if(nLayers<=0) continue;
      loc[1]=m+seg*2;
      HMdcEfficiencyMod& fmod=fsec[loc[1]];
      if(!(&fmod)) continue;
      for(Int_t lay=0; lay<6; lay++) {
        Int_t clLay=lay+m*6;
        loc[2]=lay;
        loc[3]=-1;
        while((loc[3]=fClus->next(clLay,loc[3])) > -1) {
 	  Short_t cell=loc[3];
          if(fCalCat==0) {
            fmod[lay].addCell(cell);
            fmod[lay].addCellTot(cell);
          }
 	  fmod[lay].addCellInClust(cell);       // fired wires num.
          if(fmod[lay].nClustCell[cell] == 2) { //==1 after Cal1 loop filling!
            fmod[lay].addCellClus(cell);
            HMdcCal1* cal=0;
            if(fCalCat) cal=(HMdcCal1*)fCalCat->getObject(loc);
            fmod.fillTimesCls(cal,isGeant);     //tim1,time2,time2-time1 hist.
          }
 	}
      }
    }
  }
  iterClus->Reset();
  while((fClus=(HMdcClus*)iterClus->Next())) {
    if(fClus->getStatus()==0) continue;   // For clusters filtering
    Int_t sec=fClus->getSec();
    HMdcEfficiencySec& fsec=(*this)[sec];
    if(!(&fsec)) continue;
    Int_t seg=fClus->getIOSeg();
    loc[0]=sec;
    Bool_t hitPloted=kFALSE;
    Float_t xCl=fClus->getX();
    Float_t yCl=fClus->getY();
    if(fLookUpTb) fsec.getPlotAllHits()->Fill(xCl,yCl);
    for(Int_t m=0; m<2; m++) {
      Bool_t qual=kFALSE;
      if(fClus->getMinCl(m) != 5) continue;
      Int_t nLayers=fClus->getNLayersMod(m);
      if(nLayers<5) continue;
      Int_t mod=m+seg*2;
      loc[1]=mod;
      HMdcEfficiencyMod& fmod=fsec[mod];
      if(!(&fmod)) continue;
      for(Int_t lay=0; lay<6; lay++) {
        qual=kFALSE;
 	HMdcEfficiencyLayer& flay=fmod[lay];
        Int_t clLay=lay+m*6;
        Int_t nCells=fClus->getNCells(clLay);
 	//----- Num. fired cells in plane >2
 	if(nCells>2) break;
 	//----- Num. fired cells in plane >0 & <=2
 	if(nCells>0){
          cellF[lay]=fClus->getFirstCell(clLay);
          cellL[lay]=fClus->getLastCell(clLay);
 	  // For dubl.hits |n.cell1-n.cell2| must be = 1
          if(cellL[lay]-cellF[lay]>1) break;
          //selecting of fired wires in one cluster only
          if(flay.nClustCell[cellF[lay]]>2 || flay.nClustCell[cellL[lay]]>2) break;
 	  // Nearests cells can not be fired
 	  if(cellF[lay]>0 && flay.nClustCell[cellF[lay]-1]>0) break;
 	  if(cellL[lay]+1<flay.nCells&&flay.nClustCell[cellL[lay]+1] >0) break;
          qual=kTRUE;
 	} else {
 	//----- N. fired cells in plane = 0
          HMdcSizesCellsLayer& fSCLayer = (*fSizesCells)[sec][mod][lay];
          Double_t xcoor,ycoor,zcoor;
          fSCLayer.calcIntersection(
              fClus->getXTarg(),fClus->getYTarg(),fClus->getZTarg(),
              xCl,yCl,fClus->getZ(), xcoor,ycoor,zcoor);
          fSCLayer.transTo(xcoor,ycoor,zcoor);
          cellF[lay]=fSCLayer.calcCellNum(xcoor,ycoor);
 	  if( cellF[lay] < 0 ) break;
 	  if(cellF[lay]>0 && flay.nClustCell[cellF[lay]-1] >0) break;
 	  if(flay.nClustCell[cellF[lay]] >0) break;
 	  if(cellF[lay]+1<flay.nCells&&flay.nClustCell[cellF[lay]+1] >0) break;
          cellL[lay]=-1;
          qual=kTRUE;
 	}
      }
      // Filling ========================================
      if(!qual) continue;
      Int_t bNum=fmod.getBinNum(xCl,yCl);
      if( bNum<0 && bNum!=-1000000) continue;
      //==================================================
      for(Int_t lay=0; lay<6; lay++) {
 	HMdcEfficiencyLayer& flay=fmod[lay];
        for(Int_t cell=cellF[lay]; cell<=cellL[lay]; cell++) {
          loc[0]=sec; loc[1]=mod; loc[2]=lay;
          loc[3]=cell;
          HMdcCal1* cal=0;
          if(fCalCat) cal=(HMdcCal1*)fCalCat->getObject(loc);
          fmod.fillTimesSelCls(cal,isGeant);   //tim1,time2,time2-time1 hist.
        }
        if(cellL[lay]<0) {
 	  fmod.add0Hit(bNum);
          flay.add0Hit(cellF[lay],bNum);
 	} else if(cellL[lay]-cellF[lay] == 0) {
 	  fmod.add1Hit(bNum);
 	  if(nLayers==6) flay.add1Hit(cellF[lay],bNum);
 	} else {
 	  fmod.add2Hit(bNum);
 	  if(nLayers==6) flay.add2Hit(cellF[lay],cellL[lay],bNum);
 	}
      }
      //==================================================
      if(!hitPloted && fLookUpTb) {
        hitPloted=kTRUE;
        fsec.getPlotSelHits()->Fill(xCl,yCl);
      }
    }
  }
  return 0;
}

void HMdcEfficiency::drawProjPlotsSec(Int_t sec, Int_t type) {
  if(fLookUpTb==0 || ! &((*fLookUpTb)[sec]) ) return;
  if( ! &((*this)[sec]) ) return;
  TCanvas* canv=(*this)[sec].getCanvasProj();
  if( !canv ) return;
  canv->cd();
  canv->cd(1);
  drawProjPlots(sec, type);
  gStyle->SetOptStat(0);
  canv->Modified();
  canv->Update();
}

void HMdcEfficiency::drawPrPlEvent(Int_t type) {
  if(fLookUpTb==0) return;
  canvEventProj=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanvEvent);
  if(!canvEventProj) return;
  canvEventProj->cd();
  for(Int_t sec=0; sec<6; sec++) {
    if(type<0) type=typePrPlot[sec];
    else typePrPlot[sec]=type;
    if( ! &((*fLookUpTb)[sec]) ) continue;
    canvEventProj->cd(sec+1);
    drawProjPlots(sec, type);
  }
  canvEventProj->Modified();
  canvEventProj->Update();
}

void HMdcEfficiency::drawCanvEvent(void) {
  if(gROOT->GetListOfCanvases()->FindObject(nameCanvEvent)) return;
  canvEventProj=new TCanvas(nameCanvEvent,titleCanvEvent,20,1,800,600);
  canvEventProj->SetFillColor(10);
  canvEventProj->Divide(3,2,0.0001,0.0001);
}

void HMdcEfficiency::delCanvEvent(void){
  canvEventProj=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(nameCanvEvent);
  if(canvEventProj) {
    delete canvEventProj;
    canvEventProj=0;
  }

}

void HMdcEfficiency::drawProjPlots(Int_t sec, Int_t type) {
  if(fLookUpTb==0) return;
  HMdcLookUpTbSec& lookutsec = (*fLookUpTb)[sec];
  Char_t name[15],title[20];
  sprintf(name,"S%iPlProj",sec+1);
  sprintf(title,"Event %i Sector %i",eventId,sec+1);
  typePrPlot[sec]=type;
  TH2C* plt=lookutsec.fillTH2C(name,title,typePrPlot[sec]);
  plt->SetXTitle("x, (mm)");
  plt->SetYTitle("y, (mm)      ");
  plt->SetMinimum(0.0);
  Int_t modMax=3;
  for(; modMax>=0; modMax--) if(lookutsec.getMaxClus(modMax)) break;
  Float_t mxBn=0;
  if(typePrPlot[sec]==1) for(Int_t mod=0; mod<=modMax; mod++) mxBn+=6*(mod+1);
  else if(typePrPlot[sec]==2) mxBn=4.5;
  else for(Int_t mod=0; mod<4; mod++) if(lookutsec.getMaxClus(mod)) mxBn+=6.0;
  plt->SetMaximum(mxBn);
  plt->SetLabelSize(0.03,"X");
  plt->SetLabelOffset(0.001,"X");
  plt->GetXaxis()->SetTitleSize(0.04);
  plt->SetLabelSize(0.03,"Y");
  plt->SetLabelOffset(0.01,"Y");
  plt->SetTitleOffset(1.2,"Y");
  plt->GetYaxis()->SetTitleSize(0.04);
  plt->Draw("COLZ");
  TMarker marker;
  marker.SetMarkerSize(1.4);
  marker.SetMarkerColor(4);
  Int_t mark[4]={24,28,26,25};
  iterClus->Reset();
  HMdcClus* fClus;
  while((fClus=(HMdcClus*)iterClus->Next())) {
    if(fClus->getSec() != sec) continue;
    Int_t mod=fClus->getMod();
    if(mod<0) {
      if(fClus->getIOSeg()==0) marker.SetMarkerStyle(24);
      else marker.SetMarkerStyle(30);
    }
    else marker.SetMarkerStyle(mark[mod]);
    marker.DrawMarker(fClus->getX(),fClus->getY());
  }
  gStyle->SetOptStat(0);
}

void HMdcEfficiency::drawHitsPlots(Int_t sec) {
  if(fLookUpTb==0) return;
  if( ! &((*fLookUpTb)[sec]) ) return;
  if( ! &((*this)[sec]) ) return;
  TCanvas* canv=(*this)[sec].getCanvasHits();
  if(canv) {
    canv->cd(1);
    (*this)[sec].getPlotAllHits()->Draw();
    canv->cd(2);
    (*this)[sec].getPlotSelHits()->Draw();
    canv->Modified();
    canv->Update();
  }
}


void HMdcEfficiency::printClusters(Int_t sec) {
  iterClus->Reset();
  HMdcClus* fClus;
  while((fClus=(HMdcClus*)iterClus->Next()))
      if(fClus->getSec()==sec) fClus->print();
}

void HMdcEfficiency::calcEfficiency(Bool_t flag) {
  gStyle->SetTitleW(0.5);
  gStyle->SetTitleH(0.09);
  for(Int_t sec=0; sec<6; sec++){
    HMdcEfficiencySec& fsec=(*this)[sec];
    if(!&fsec) continue;
    if(flag) {
      for(Int_t mod=0; mod<4; mod++){
        HMdcEfficiencyMod& fmod=fsec[mod];
        if(!&fmod) continue;
        for(Int_t lay=0; lay<6; lay++) {
          fmod[lay].fillHists();
          fmod[lay].updateCanv();
          fmod[lay].updateCanvXYlist();
        }
        fmod.fillHistMb();
        fmod.updateCanv();
      }
    }
    drawProjPlotsSec(sec,typePrPlot[sec]);
    drawHitsPlots(sec);
  }
  drawPrPlEvent();
}

Bool_t HMdcEfficiency::finalize(void) {
  // writeHists();
  return kTRUE;
}

void HMdcEfficiency::extractFileInfo(void) {
  firstEvent=kFALSE;
  HMdcGetContainers::getFileName(fileName);
  TString runId;
  HMdcGetContainers::getRunId(runId);
  TString date;
  HMdcGetContainers::getEventDate(date);
  TString time;
  HMdcGetContainers::getEventTime(time);
  char buf[200];
  sprintf(buf,"%s   runId:%s  %s  %s",
      fileName.Data(),runId.Data(),date.Data(),time.Data());
  fileId=buf;
}

void HMdcEfficiency::saveHist(const TString& outputDir) {
  fileName=outputDir;
  fileName.Remove(TString::kTrailing, '/');
  fileName+="/MDC";
  saveHist();
}

void HMdcEfficiency::saveHist(void) {
  calcEfficiency();
  char buf[200];
  sprintf(buf,"%s_MdcEff.root",fileName.Data());
  TFile file(buf,"RECREATE");
  
  gROOT->SetBatch();
  for(Int_t sec=0; sec<6; sec++){
    HMdcEfficiencySec& fsec=(*this)[sec];
    if(!&fsec) continue;
    fsec.saveCanvHits(1);
    for(Int_t mod=0; mod<4; mod++){
      HMdcEfficiencyMod& fmod=fsec[mod];
      if(!&fmod) continue;
      fmod.saveCanvases(1);
      fmod.saveCanvEffMb(1);
      if(fCalCat) fmod.drawCanvTimes(-1,1);
      
//      fmod.fillHistMb();
//      fmod.updateCanv();
    }
  }
  saveAs((char*)fileName.Data(),"Pattern");
  saveAs((char*)fileName.Data(),"Eff");
  if(fCalCat) saveAs((char*)fileName.Data(),"Times");
  saveAs((char*)fileName.Data(),"EffMb");
  gROOT->SetBatch(kFALSE);
  file.Close();
}

void HMdcEfficiency::saveAs(char* fileName, char* type) {
  char psFileOp[500];
  sprintf(psFileOp,"%s_%s.ps(",fileName,type);
  char psFile[500];
  sprintf(psFile,"%s_%s.ps",fileName,type);
  char psFileCl[500];
  sprintf(psFileCl,"%s_%s.ps)",fileName,type);
  
  char buf[100];
  TCanvas* cn=0;
  Int_t nCn=0;
  for(Int_t m=0;m<4;m++) {
    for(Int_t s=0;s<6;s++) {
      sprintf(buf,"S%iM%i_%s",s+1,m+1,type);
      TCanvas* cnNext=(TCanvas*)gROOT->FindObject(buf);
      if(cnNext) {
        if(nCn==1) cn->Print(psFileOp);
        else if(nCn>1) cn->Print(psFile);
        nCn++;
        cn=cnNext;
      }
    }
  }
  if(nCn==1) cn->Print(psFile);
  else if(nCn>1) cn->Print(psFileCl);
  if(nCn>0) makePDF(psFile);
  return;
}

void HMdcEfficiency::savePDF(char* fileName, char* type) {
  // type = "Pattern","Eff","EffMb","NtrNhits","SingC","Prob","Times"
  gROOT->SetBatch();
  TString rootFile(fileName);
  rootFile += ".root";
  TFile* file=TFile::Open(rootFile.Data(),"READ");
  if(file) {
    saveAs(fileName,type);
    file->Close();
    delete file;
  } else printf("\nFile %s.root don't exist!\n\n",fileName);
  gROOT->SetBatch(kFALSE);
  return;
}

void HMdcEfficiency::makePDF(char* psFile) {
  // Execute ps2pdf GhostScript command on closed PS file, delete PS file 
  char command[500];
  sprintf(command,"ps2pdf %s",psFile);
  gSystem->Exec(command);
  sprintf(command,"rm %s",psFile);
  gSystem->Exec(command);
}