#include "hmdctargetmon.h"
#include "TROOT.h"
#include "TH1.h"
#include "TH2.h"
#include "TNtuple.h"
#include "TCanvas.h"
#include "TStyle.h"
#include "TPaveLabel.h"
#include "TSystem.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hdatasource.h"
#include "hspectrometer.h"
#include "hmdcgeompar.h"
#include "hspecgeompar.h"
#include "heventheader.h"
#include "hmdcdetector.h"
#include "hmdcdef.h"
#include "hevent.h"
#include "hcategory.h"
#include "hgeomvolume.h"
#include "hmdchit.h"
#include "hiterator.h"
#include "hmdcseg.h"
#include "hrun.h"
#include "TLine.h"
#include "hmdcsizescells.h"
#include "hmdcgetcontainers.h"
#include "hmdctrackdset.h"
#include "TSystem.h"

ClassImp(HMdcTargetMon)

HMdcTargetMon::HMdcTargetMon(Bool_t isClOff, UInt_t pt) {
  isCoilOff=isClOff;
  setDefParam(pt);
}

HMdcTargetMon::HMdcTargetMon(const Text_t *name,const Text_t *title,
    Bool_t isClOff,UInt_t pt) : HReconstructor(name,title) {
  isCoilOff=isClOff;
  setDefParam(pt);
}

void HMdcTargetMon::setDefParam(UInt_t pt) {
  plotType        = pt;
  timeStep        = 10.;
  mode            = kFALSE;
  label           = NULL;
  labelNR         = NULL;
  combToMdc[0][0] = 0;
  combToMdc[0][1] = 1;
  combToMdc[1][0] = 0;
  combToMdc[1][1] = 2;
  combToMdc[2][0] = 0;
  combToMdc[2][1] = 3;
  combToMdc[3][0] = 1;
  combToMdc[3][1] = 2;
  combToMdc[4][0] = 1;
  combToMdc[4][1] = 3;
  combToMdc[5][0] = 2;
  combToMdc[5][1] = 3;

  iterMdcHit      = 0;
  firstEvent      = kTRUE;
  dateFEvent      = 0;
  timeFEvent      = 0;
  dateLEvent      = 0;
  timeLEvent      = 0;
  dPhiCut         = 5.5; //15.; //1.5;
  r0Cut           = 20.; //100.; //25.;

  nZmBins         = 1000; //900;
  zmin            = -500.;//-90; //-5000.;  //-1000.;
  zmax            = 600.;//100; //5000.;   //800.;
  histsMode       = 0;
  numEventsSave   = -1;
  eventCounter    = 0;
  
  fillSeg         = kFALSE;
  stat            = 0;
  sumOfFiles      = kTRUE;
  collectNRuns    = 0;
  runsCounter     = 0;
  for(Int_t s=0;s<6;s++) {
    canvs[s]      = NULL;
    canvsForNR[s] = NULL;
  }
  for(Int_t i=0;i<7;i++) {
    dPhiH[i]      = NULL;
    r0H[i]        = NULL;
    dPhiForNR[i]  = NULL;
    r0ForNR[i]    = NULL;
    for(Int_t s=0;s<6;s++) {
      zVerH[s][i]            = NULL;
      zVerVsEventH[s][i]     = NULL;    
      zVerForNR[s][i]        = NULL;
      zVerVsEventForNR[s][1] = NULL;
      for(Int_t k=0;k<10;k++) {
        zVerDscH[s][i][k]     = NULL;
        zVerDscForNR[s][i][k] = NULL;
      }
   }
  }
  for(Int_t s=0;s<6;s++) {
    useRtdbTarget[s] = kTRUE;
    firstTarPnt[s]   = 0.; 
    lastTarPnt[s]    = 0.;
  }
  drawInOutTracks  = kFALSE;
  inTargetArr      = 0;
  allTargetArr     = 0;
  nRunsDraw        = 0;
  inOutTargCurrRun = 0;
  hTargTrFraction  = 0;
  canvasWidth      = 950;
  canvasHeight     = 700;
  pathHistOneRun   = ".";
  pathHistSumRun   = ".";
  selectEvByTBits  = -1;
  normalizeHists   = kTRUE;
}

HMdcTargetMon::~HMdcTargetMon() {
  // destructor
  if(iterMdcHit) delete iterMdcHit;
  iterMdcHit   = 0;
  if(inTargetArr)  delete inTargetArr;
  inTargetArr  = 0;
  if(allTargetArr) delete allTargetArr;
  allTargetArr = 0;
}

void HMdcTargetMon::setGraphicFormat(const Char_t* fileType) {
  if(fileType==0) typePrintFile = "-";
  else {
    typePrintFile = fileType;
    typePrintFile.ToLower();
  }
}


TH1F* HMdcTargetMon::setTargetZRegion(Double_t fpoint,Double_t lpoint,Int_t nRuns,Int_t sec) {
  // set target Z region for calulating 
  // n.tracks_in_target/n.tracks_out_target
  // nRuns - maximal number of runs in hist
  if(drawInOutTracks || nRuns<2) return 0;
  for(Int_t s=0;s<6;s++) if(sec<0 || sec>5 || s==sec){
    firstTarPnt[s] = fpoint;
    lastTarPnt[s]  = lpoint;
  }
  drawInOutTracks  = kTRUE;
  nRunsDraw        = nRuns;
  inTargetArr      = new Double_t [nRunsDraw];
  allTargetArr     = new Double_t [nRunsDraw];
  for(Int_t i=0;i<nRuns;i++) inTargetArr[i]=allTargetArr[i]=0.;
  inOutTargCurrRun = 0;
  hTargTrFraction  = new TH1F("hTargTrFraction","N.TargetTracks/N.Tracks;Run",nRunsDraw,0.,nRunsDraw);
  hTargTrFraction->SetLabelSize(0.05,"X");
  hTargTrFraction->SetLabelSize(0.05,"Y");
  return hTargTrFraction;
}

void HMdcTargetMon::shiftArrays(void) {
  for(Int_t i=0;i<nRunsDraw-1;i++) {
    inTargetArr[i]  = inTargetArr[i+1];
    allTargetArr[i] = allTargetArr[i+1];
  }
  inTargetArr[nRunsDraw-1]  = 0.;
  allTargetArr[nRunsDraw-1] = 0.;
}

void HMdcTargetMon::fillTargTrFraction(void) {
  if(!drawInOutTracks) return;
  if(inOutTargCurrRun < nRunsDraw-1) inOutTargCurrRun++;
  for(Int_t i=0;i<=inOutTargCurrRun;i++) fillInOutTarHistBin(i);
  if(inOutTargCurrRun == nRunsDraw-1) shiftArrays();
  setEntriesInOutTHist();
}

void HMdcTargetMon::setEntriesInOutTHist(void) {
  Int_t nRuns = inOutTargCurrRun;
  if(allTargetArr[inOutTargCurrRun]>0) nRuns++;
  hTargTrFraction->SetEntries(nRuns);
}

void HMdcTargetMon::fillInOutTarHistBin(Int_t bin) {
  if(allTargetArr[bin]>0) {
    Double_t cont = inTargetArr[bin]/allTargetArr[bin];
    Double_t err  = TMath::Sqrt(inTargetArr[bin])/allTargetArr[bin];
    hTargTrFraction->SetBinContent(bin+1,cont);
    hTargTrFraction->SetBinError(bin+1,err);
  } else {
    hTargTrFraction->SetBinContent(bin+1,0.);
    hTargTrFraction->SetBinError(bin+1,0.);
  }
}

Bool_t HMdcTargetMon::init(void) {
  fMdcHitCat = gHades->getCurrentEvent()->getCategory(catMdcHit);
  if (fMdcHitCat) iterMdcHit = (HIterator *)fMdcHitCat->MakeIterator();
  else {
    Error("init","The category HMdcHit is absent");
    return kFALSE;
  }

  HMdcGeomPar* fMdcGeomPar = (HMdcGeomPar*)gHades->getRuntimeDb()->getContainer("MdcGeomPar");
  if(!fMdcGeomPar) return kFALSE;

  HSpecGeomPar* fSpecGeomPar = (HSpecGeomPar*)gHades->getRuntimeDb()->getContainer("SpecGeomPar");
  if(!fSpecGeomPar) return kFALSE;

  if(fillSeg) {
    fSegCat = gHades->getCurrentEvent()->getCategory(catMdcSeg);
    if (!fSegCat) {
      HMdcDetector* fMdcDet=(HMdcDetector*)gHades->getSetup()->getDetector("Mdc");
      fSegCat = fMdcDet->buildCategory(catMdcSeg);
      if (!fSegCat) return kFALSE;
      gHades->getCurrentEvent()->addCategory(catMdcSeg,fSegCat,"Mdc");
    }
  } else fSegCat=0;
  locSeg.set(2,0,0);
  runId = 0;
  
  return kTRUE;
}

Bool_t HMdcTargetMon::initHists(void) {
  HMdcGetContainers* fGetCont = HMdcGetContainers::getObject();
  Int_t nModsMax=(isCoilOff) ? 4:2;
  Int_t nSectors=0;
  for (Int_t n=0; n<24; n++) listMdc[n]=kFALSE;
  for (Int_t sec = 0; sec < 6; sec++) {
    mdcInSec[sec]=0;
    for(Int_t mod=0; mod<nModsMax; mod++) if(fGetCont->isModActive(sec,mod)) mdcInSec[sec]++;
    if(mdcInSec[sec]>=2) {
      for(Int_t mod=0; mod<nModsMax; mod++) listMdc[sec*4+mod] = fGetCont->isModActive(sec,mod);
      nSectors++;
    } else mdcInSec[sec]=0;
  }
  if(nSectors == 0) {
    Error("init","Numb. of MDC's is not enough for target finding!");
    return kFALSE;
  }

  Char_t name[100];
  Char_t title[100];
  for(Int_t comb=0; comb<6; comb++) nPads[comb]=0;
  gStyle->SetOptStat(10);
  for(Int_t sec=0; sec<6; sec++) {
    for(Int_t mod1=0; mod1<nModsMax-1; mod1++) {
      if(!listMdc[sec*4+mod1]) continue;
      for(Int_t mod2=mod1+1; mod2<nModsMax; mod2++) {
        if(!listMdc[sec*4+mod2]) continue;
        Int_t comb = mod1+mod2;
        if(mod1==0) comb--;
        nPads[comb]++;
        if(dPhiH[comb] == NULL) {
          sprintf(name,"s%im%iv%i_dPhi",sec+1,mod1+1,mod2+1);
          sprintf(title,"S.%i M.%i-%i  #Delta#phi (deg.)",sec+1,mod1+1,mod2+1);
          dPhiH[comb]=new TH1F(name,title,200,-10.,10.);
          sprintf(name,"s%im%iv%i_Rm",sec+1,mod1+1,mod2+1);
          sprintf(title,"S.%i M.%i-%i  R_{min} (mm)",sec+1,mod1+1,mod2+1);
          r0H[comb]=new TH1F(name,title,500,-100.,100.);
        }
        if(zVerH[sec][comb] == NULL) {
          sprintf(name,"s%im%iv%i_Zm",sec+1,mod1+1,mod2+1);
          sprintf(title,"S.%i M.%i-%i",sec+1,mod1+1,mod2+1);
          zVerH[sec][comb]=new TH1F(name,title,nZmBins,zmin,zmax);
          zVerH[sec][comb]->SetFillColor(3);
          if(histsMode==1) {
            zVerH[sec][comb]->GetXaxis()->SetTitle(
                "Downsc.Flag:  #color[4]{0}, #color[2]{1}             Zmin, (mm)");
          } else zVerH[sec][comb]->GetXaxis()->SetTitle("Zmin, (mm)");
          zVerH[sec][comb]->GetXaxis()->SetTitleOffset(0.9);
          if(histsMode==1) {
            sprintf(name,"s%im%iv%i_ZmDS0",sec+1,mod1+1,mod2+1);
            sprintf(title,"DownscalingFlag=0;Zmin, (mm)");
            zVerDscH[sec][comb][0]=new TH1F(name,title,nZmBins,zmin,zmax);
            zVerDscH[sec][comb][0]->SetFillColor(4);
            zVerDscH[sec][comb][0]->SetLineColor(4);
            sprintf(name,"s%im%iv%i_ZmDS1",sec+1,mod1+1,mod2+1);
            sprintf(title,"DownscalingFlag=1;Zmin, (mm)");
            zVerDscH[sec][comb][1]=new TH1F(name,title,nZmBins,zmin,zmax);
            zVerDscH[sec][comb][1]->SetLineColor(2);
          } else if(histsMode==2) {
            Int_t col[10]={2,4,5,6,7,8,9,10,34,36};
            for(Int_t n=0;n<8;n++) {
              sprintf(name,"s%im%iv%i_ZmTR%i",sec+1,mod1+1,mod2+1,n);
              sprintf(title,"Trigger. %i;Zmin, (mm)",n);
              zVerDscH[sec][comb][n]=new TH1F(name,title,nZmBins,zmin,zmax);
              zVerDscH[sec][comb][n]->SetLineColor(col[n]);
              zVerDscH[sec][comb][n]->SetFillColor(0);
            }
          }

          if(plotType==1) {
            sprintf(name,"s%im%iv%i_ZmVev",sec+1,mod1+1,mod2+1);
            sprintf(title,"S.%i M.%i-%i  Z_{min} vs Nev.;Event;Zmin",sec+1,mod1+1,mod2+1);
            zVerVsEventH[sec][comb] = new TH2F(name,title,1000,0,1000,500,zmin,zmax);
//new TH2F(name,title,1000,0,1000,256,0.,256.);


#if ROOT_VERSION_CODE  > ROOT_VERSION(6,0,0)
	    zVerVsEventH[sec][comb]->SetCanExtend(TH1::kAllAxes);
#else
	    zVerVsEventH[sec][comb]->SetBit(TH1::kCanRebin);
#endif

          } else if(plotType==2) {
            sprintf(name,"s%im%iv%i_YvX",sec+1,mod1+1,mod2+1);
            sprintf(title,"S.%i M.%i-%i  Y vs X;X (mm);Y (mm)",sec+1,mod1+1,mod2+1);
            zVerVsEventH[sec][comb] = new TH2F(name,title,30,-30.,30.,30,-30.,30.);
//zVerVsEventH[sec][comb] = new TH2F(name,title,50,-100.,100.,50,-100.,100.);
          } else if(plotType==3) {
            sprintf(name,"s%im%iv%i_ZmVtm",sec+1,mod1+1,mod2+1);
            sprintf(title,"S.%i M.%i-%i  Z_{min} vs ev.time;Time;Zmin",sec+1,mod1+1,mod2+1);
            zVerVsEventH[sec][comb] = new TH2F(name,title,600,0,600,500,zmin,zmax);
//new TH2F(name,title,1000,0,1000,256,0.,256.);

#if ROOT_VERSION_CODE  > ROOT_VERSION(6,0,0)
	    zVerVsEventH[sec][comb]->SetCanExtend(TH1::kAllAxes);
#else
	    zVerVsEventH[sec][comb]->SetBit(TH1::kCanRebin);
#endif
          } else if(plotType==4) {
            sprintf(name,"s%im%iv%i_XvZ",sec+1,mod1+1,mod2+1);
            sprintf(title,"S.%i M.%i-%i  X vs Z;Z (mm);X (mm)",sec+1,mod1+1,mod2+1);
            zVerVsEventH[sec][comb] = new TH2F(name,title,500,zmin,zmax,50,-100.,100.);
          } else if(plotType==5) {
            sprintf(name,"s%im%iv%i_YvZ",sec+1,mod1+1,mod2+1);
            sprintf(title,"S.%i M.%i-%i  Y vs Z;Z (mm);Y (mm)",sec+1,mod1+1,mod2+1);
            zVerVsEventH[sec][comb] = new TH2F(name,title,500,zmin,zmax,50,-100.,100.);
          } else {
            sprintf(name,"s%im%iv%i_ThVZm",sec+1,mod1+1,mod2+1);
            sprintf(title,"Theta vs Zmin;Zmin;Theta");
            zVerVsEventH[sec][comb]=new TH2F(name,title,100,-250.,150.,80,10,90);
          }
        }
      }
    }
  }
  initRunsSumHists();
  return kTRUE;
} 
 
void HMdcTargetMon::initRunsSumHists(void) {
  if(collectNRuns<2) return;  
  Char_t name[100]; 
  for(Int_t sec=0; sec<6; sec++) {
    for(Int_t mod1=0; mod1<3; mod1++) {
      for(Int_t mod2=mod1+1; mod2<4; mod2++) {
        Int_t comb=mod1+mod2;        
        if(mod1==0) comb--;

        if(dPhiH[comb]!=NULL && dPhiForNR[comb]==NULL) {
          sprintf(name,"s%im%iv%i_dPhi_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
          dPhiForNR[comb]=new TH1F(*(dPhiH[comb]));
          dPhiForNR[comb]->SetName(name);
          sprintf(name,"s%im%iv%i_Rm_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
          r0ForNR[comb]=new TH1F(*(r0H[comb]));
          r0ForNR[comb]->SetName(name);          
        }
        if(zVerH[sec][comb]!=NULL && zVerForNR[sec][comb]==NULL) {
          sprintf(name,"s%im%iv%i_Zm_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
          zVerForNR[sec][comb] = new TH1F(*(zVerH[sec][comb]));
          zVerForNR[sec][comb]->SetName(name);
          if(histsMode==1) {
            sprintf(name,"s%im%iv%i_ZmDS0_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerDscForNR[sec][comb][0] = new TH1F(*(zVerDscH[sec][comb][0]));
            zVerDscForNR[sec][comb][0]->SetName(name);
            sprintf(name,"s%im%iv%i_ZmDS1_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerDscForNR[sec][comb][1] = new TH1F(*(zVerDscH[sec][comb][1]));
            zVerDscForNR[sec][comb][1]->SetName(name);
          } else if(histsMode==2) {
            for(Int_t n=0;n<8;n++) {
              sprintf(name,"s%im%iv%i_ZmTR%i_%iruns",sec+1,mod1+1,mod2+1,n,collectNRuns);
              zVerDscForNR[sec][comb][n]=new TH1F(*(zVerDscH[sec][comb][n]));
              zVerDscForNR[sec][comb][n]->SetName(name);
            }
          }

          if(plotType==1) {
            sprintf(name,"s%im%iv%i_ZmVev_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);

#if ROOT_VERSION_CODE  > ROOT_VERSION(6,0,0)
	    zVerVsEventForNR[sec][comb]->SetCanExtend(TH1::kAllAxes);
#else
	    zVerVsEventForNR[sec][comb]->SetBit(TH1::kCanRebin);
#endif




          } else if(plotType==2) {
            sprintf(name,"s%im%iv%i_YvX_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);
          } else if(plotType==3) {
            sprintf(name,"s%im%iv%i_ZmVtm_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);
          } else if(plotType==4) {
            sprintf(name,"s%im%iv%i_XvZ_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);
          } else if(plotType==5) {
            sprintf(name,"s%im%iv%i_YvZ_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);
          } else {
            sprintf(name,"s%im%iv%i_ThVZm_%iruns",sec+1,mod1+1,mod2+1,collectNRuns);
            zVerVsEventForNR[sec][comb]=new TH2F(*(zVerVsEventH[sec][comb]));
            zVerVsEventForNR[sec][comb]->SetName(name);
          }
        }
      }
    }
  }
} 
 
Bool_t HMdcTargetMon::reinit(void) {
  
  UInt_t newRunId = gHades->getDataSource()->getCurrentRunId();
  if(newRunId > 0 && newRunId == runId) return kTRUE;
  
//   if(runId > 0) addHistsToRunsSum();
   if(!initHists()) return kFALSE;
  evHeader = gHades->getCurrentEvent()->getHeader();
  if(!evHeader) {
    Error("reinit","Can't get pointer to event header.");
    return kFALSE;
  }

  HMdcGeomPar* fMdcGeomPar = (HMdcGeomPar*)gHades->getRuntimeDb()->getContainer("MdcGeomPar");
  if(!fMdcGeomPar) return kFALSE;
  for(Int_t s=0;s<6;s++) {
    for(Int_t m=0;m<4;m++) {
      HModGeomPar* mGeomPar = fMdcGeomPar->getModule(s,m);
      if(mGeomPar) transf[s*4+m] = &(mGeomPar->getLabTransform());
      else         transf[s*4+m] = NULL;
    }
  }

  HSpecGeomPar* fSpecGeomPar = (HSpecGeomPar*)gHades->getRuntimeDb()->getContainer("SpecGeomPar");
  if(!fSpecGeomPar) return kFALSE;
  for(Int_t sec=0;sec<6;sec++) if(useRtdbTarget[sec]) {
    Int_t nTarg=fSpecGeomPar->getNumTargets()-1;
    target[sec] = fSpecGeomPar->getTarget(    0)->getTransform().getTransVector() +
                  fSpecGeomPar->getTarget(nTarg)->getTransform().getTransVector();
    target[sec] /= 2.;
  }
  HMdcSizesCells* pMdcSizesCells = HMdcSizesCells::getExObject();
  const HGeomVector& firsPnt     = pMdcSizesCells->getTargetFirstPoint();
  const HGeomVector& lastPnt     = pMdcSizesCells->getTargetLastPoint();
  Double_t targHalfLength = (lastPnt.getZ()-firsPnt.getZ())*0.5;
  for(Int_t sec=0;sec<6;sec++) {
    Double_t tarHLngth = (lastTarPnt[sec]-firstTarPnt[sec])*0.5;
    if(tarHLngth <= 0.001) tarHLngth = targHalfLength;
    firstTarPnt[sec] = target[sec].getZ()-tarHLngth;
    lastTarPnt[sec]  = target[sec].getZ()+tarHLngth;
  }
  for(Int_t sec=0;sec<6;sec++) {
    printf("*** Sector %i Target: X=%7.2f Y=%7.2f Z=%7.2f (%7.2f <-> %7.2f)\n",sec+1,
        target[sec].getX(),target[sec].getY(),target[sec].getZ(),firstTarPnt[sec],lastTarPnt[sec]);
  }
  if(sumOfFiles) {
    collectNRuns=0;       // collect n.runs for sumOfFiles=kFALSE only !!!
    extractFileInfo();
    if(firstEvent) {
      setCanvName();
      if(!mode) {
        timer.Reset();
        timer.Start();
      }
      firstEvent=kFALSE;
    }
  } else {
    if(firstEvent) {
      extractFileInfo();
      setCanvName();
      drawCanvases();
      if(collectNRuns>1) {
        firstRunName = fileNameR;
        lastRunName  = fileNameR;
        drawCanvasesRunsSum();
      }
    }
    stat = 0;
    if(!mode) {
      timer.Reset();
      timer.Start();
    }
    firstEvent = kFALSE;
  }

  return kTRUE;
}

Bool_t HMdcTargetMon::finalize(void) {
  runsCounter++;
  if(collectNRuns > 1) {
    addHistsToRunsSum();     // add and draw hists
    saveCanvasesForNR();
  }
  drawCanvases();
  saveCanvases();
  return kTRUE;
}

void HMdcTargetMon::saveCanvases(void) {
  if(stat<1) return;
  for(Int_t comb=0; comb<6; comb++) {
    if(nPads[comb] == 0) continue;
    TCanvas *canv = canvs[comb]; //(TCanvas*)gROOT->FindObject(cnComb[comb]);
    if(canv == NULL) continue;
    saveCanvas(canv,pathHistOneRun);
  }
}

void HMdcTargetMon::saveCanvasesForNR(void) {
  for(Int_t comb=0; comb<6; comb++) {
    if(nPads[comb] == 0) continue;
    TCanvas *canv = canvsForNR[comb];
    if(canv == NULL) continue;
    saveCanvas(canv,pathHistSumRun);
  }
}

void HMdcTargetMon::saveCanvas(TCanvas* canv,TString& path) {
  if(canv == 0) return;
  TString fileName(path);
  fileName += "/";
  fileName += canv->GetName();
  if(typePrintFile.Length() == 0)     canv->SaveAs("");  // ps file will be cr.
  if(typePrintFile.Contains(".pdf"))  canv->SaveAs((fileName+".pdf").Data());
  if(typePrintFile.Contains(".ps"))   canv->SaveAs((fileName+".ps").Data());
  if(typePrintFile.Contains(".eps"))  canv->SaveAs((fileName+".eps").Data());
  if(typePrintFile.Contains(".gif"))  canv->SaveAs((fileName+".gif").Data());
  if(typePrintFile.Contains(".svg"))  canv->SaveAs((fileName+".svg").Data());
  if(typePrintFile.Contains(".jpg"))  canv->SaveAs((fileName+".jpg").Data());
  if(typePrintFile.Contains(".root")) canv->SaveAs((fileName+".root").Data());
}
    
Int_t HMdcTargetMon::execute(void) {

  gSystem->ProcessEvents();
  
  UInt_t newRunId = 0;
  if(dateFEvent == 0) {
    dateFEvent  = evHeader->getDate();
    timeFEvent  = evHeader->getTime();
  }
  newRunId = gHades->getDataSource()->getCurrentRunId();
  if(newRunId == 0) return 0;
  if(runId != newRunId) {
      // New run but not first run! ------------------------------------------
    fillTargTrFraction();
    if( !sumOfFiles ) {
      runsCounter++;
      drawCanvases();
      saveCanvases();  // save hists for each run
      if(numEventsSave > 0) eventCounter = 0;
      if(collectNRuns > 1) {
        lastRunName = fileNameR;
        addHistsToRunsSum();     // add and draw hists
        if(runsCounter==collectNRuns) saveCanvasesForNR();
      }
      extractFileInfo();
      lastRunName  = fileNameR;
      
      if(collectNRuns>1 && runsCounter==collectNRuns) {
        runsCounter  = 0;
        firstRunName = fileNameR;
        lastRunName  = fileNameR;
        resetHistsRunsSum();
        drawCanvasesRunsSum();
      }

       stat = 0;
       setCanvName();
       resetHists();

       if(!mode) {
         timer.Reset();
         timer.Start();
       }
       firstEvent=kFALSE;
    }
  }
  
  UInt_t downscalingFlag=evHeader->getDownscalingFlag() & 1;
  
  Int_t tBit = evHeader->getTBit();
  if(selectEvByTBits>0 && (selectEvByTBits&tBit)==0) return 1;

//if(selectEvByTBits != tBit) return 1;

// June10:
// PT1 (TOF mult.):        12            2048
// PT2 (RPC mult.):        13            4096
// PT3 (FW  mult.):        14            8192
  
  tBit = tBit&255;
  Int_t hNum = -1;
  if(histsMode==2) {
    if(tBit&1)       hNum = (tBit&32) ? 1:0;  // 0 - mult.4; 1 - mult.4+opp.sec.
    else if(tBit& 2) hNum = 2;                // minimum bias
    else if(tBit& 4) hNum = (tBit&32) ? 4:3;  // 3 - mult.2; 4 - mult.2+opp.sec.
    else if(tBit& 8) hNum = 5;                // M1 //small angle
    else if(tBit&16) hNum = 7;                // M3 //pulser;
    else if(tBit&32) hNum = 6;                // opp.sec.
  }
  
  
//Trigger Box setting for alignment run:
//   1         2        4       8       16           32
// 1         2        3       4        5           6             7       8
//M4    Start      Veto       M1      M3    opp. Sec.          1kHz   r.puls
// 2         C        D       C       0           2              0 0
//on        on      on     on      on         on           OFF   on
  
  
  if(evHeader->getId() != 1) return 0;
  timeLEvent    = evHeader->getTime();
  UInt_t nevent = evHeader->getEventSeqNumber();
  
// static UInt_t oldEvn=0;
// static UInt_t mmm=0;
// if(oldEvn==0) {
//   oldEvn=nevent;
//   mmm=nevent;
// }
// if((tBit&128)) {
//   if(nevent-oldEvn > 200) {
//     printf("nevent=%i  nevent-oldEvn=%i\n",nevent,nevent-oldEvn);
//     mmm=nevent;
//   }
//   oldEvn=nevent;
// }
// nevent-=mmm;
// if((tBit&1)==0) return 0;
  for(Int_t n=0; n<24; n++) nhits[n]=0;
  HGeomVector vHit;
  HMdcHit* hit;
  iterMdcHit->Reset();
  while ( (hit=(HMdcHit*)iterMdcHit->Next()) != 0 ){
    //if(hit->getChi2()<0. || hit->getChi2()>30.) continue;
    //if(hit->getOffset()<-10.||hit->getOffset()>50.) continue;
    Int_t sec  = hit->getSector();
    if(mdcInSec[sec]<2) continue;
    Int_t mod  = hit->getModule();
    Int_t indx = sec*4+mod;
    if(!listMdc[indx]) continue;
    if(nhits[indx]>=1000) {
      printf("Too many clusters! Skip event!\n");
      return kSkipEvent;
    }
    //   if(mod != modF && mod != modS) continue;

    vHit.setXYZ(hit->getX(),hit->getY(),0.);
    vHit=transf[indx]->transFrom(vHit);
    Int_t indx2=nhits[indx];
    x[indx][indx2] = vHit.getX() - target[sec].getX();  // shift Z to target position
    y[indx][indx2] = vHit.getY() - target[sec].getY();  //
    z[indx][indx2] = vHit.getZ();
    vHit -= target[sec];
    Double_t phiN=TMath::ATan2(vHit.getY(),vHit.getX())*180./TMath::Pi();
    if(phiN<0.) phiN+=360.;
//    Double_t thetaN=acos(vHit.getZ()/vHit.length())*180./TMath::Pi();
    phi[indx][indx2]=phiN;
    nhits[indx]++;
  }

//zVerVsEventH[0][5]->Fill(nevent+0.5,tBit);
  if(fSegCat) fSegCat->Clear(); 
    
  for(Int_t sec=0; sec<6; sec++) {
    if(mdcInSec[sec]<2) continue;
    
    Int_t iS  = sec*4;
    locSeg[0] = sec;
    HGeomVector& targ = target[sec];
    for(Int_t mod1=0; mod1<3; mod1++) {
      Int_t iM1= iS+mod1;
      if(nhits[iM1]==0) continue;
      locSeg[1]=mod1>>1;   // po pervomu modulyu !!!
      for(Int_t mod2=mod1+1; mod2<4; mod2++) {
        Int_t iM2= iS+mod2;
        if(nhits[iM2]==0) continue;
        Int_t comb = mod1+mod2;
        if(mod1==0) comb--;
        Int_t nTracks = 0;
        for(Int_t hitM1=0; hitM1<nhits[iM1]; hitM1++) {
          for(Int_t hitM2=0; hitM2<nhits[iM2]; hitM2++) {
            TrackPar &track  =  trArr[nTracks];
            //-------------------------------------------
            Double_t dX      = x[iM2][hitM2]-x[iM1][hitM1];
            Double_t dY      = y[iM2][hitM2]-y[iM1][hitM1];
            Double_t phiTr   = TMath::ATan2(dY,dX);
            Double_t r0      = y[iM1][hitM1]*TMath::Cos(phiTr)-x[iM1][hitM1]*TMath::Sin(phiTr);
            Double_t dZ      = z[iM2][hitM2]-z[iM1][hitM1];
            track.theta      = TMath::ATan2(TMath::Sqrt(dX*dX+dY*dY),dZ);
//if(TMath::Abs(track.theta)<45.*TMath::DegToRad()) continue;
            if( TMath::Abs(track.theta) < 0.01 ) continue;
            track.z = z[iM1][hitM1] - TMath::Cos(track.theta)/TMath::Sin(track.theta) *
                      (x[iM1][hitM1]*TMath::Cos(phiTr)+y[iM1][hitM1]*TMath::Sin(phiTr));
//printf("%f %f   %f %f\n",track.z,track.theta,z[iM1][hitM1],z[iM2][hitM2]);
            //-------------------------------------------
            Double_t           dPhi  = phi[iM1][hitM1]-phi[iM2][hitM2];
            if(dPhi<-180.)     dPhi += 360.;
            else if(dPhi>180.) dPhi -= 360.;
            dPhiH[comb]->Fill(dPhi);

            //Double_t dTheta=theta[iM1][hitM1]-theta[iM2][hitM2];
//if(theta[iM1][hitM1]<40.||theta[iM2][hitM2]<40.) continue;
            if(TMath::Abs(dPhi)>=dPhiCut) continue;
            //-------------------------------------------
            r0H[comb]->Fill(r0);
            //-------------------------------------------
            
            stat++;
            
            track.x0 = -100000.;
            track.y0 = -100000.;
            
            if(plotType==2 && TMath::Abs(dZ)>1.e-20 && TMath::Abs(track.z-targ.getZ())<10.) {
              track.y0 = dY/dZ*(targ.getZ()-z[iM1][hitM1]) + y[iM1][hitM1]+targ.getY();
              track.x0 = dX/dZ*(targ.getZ()-z[iM1][hitM1]) + x[iM1][hitM1]+targ.getX();
              zVerVsEventH[sec][comb]->Fill(track.x0,track.y0);
            }
            if(plotType==4) {
              track.y0 = dY/dZ*(targ.getZ()-z[iM1][hitM1]) + y[iM1][hitM1]+targ.getY();
              track.x0 = dX/dZ*(targ.getZ()-z[iM1][hitM1]) + x[iM1][hitM1]+targ.getX();
              zVerVsEventH[sec][comb]->Fill(track.z,track.x0);
            } else if(plotType==5) {
              track.y0 = dY/dZ*(targ.getZ()-z[iM1][hitM1]) + y[iM1][hitM1]+targ.getY();
              track.x0 = dX/dZ*(targ.getZ()-z[iM1][hitM1]) + x[iM1][hitM1]+targ.getX();
              zVerVsEventH[sec][comb]->Fill(track.z,track.y0);
            }
            
            //-------------------------------------------
            if(TMath::Abs(r0)>=r0Cut) continue;
            if(fillSeg) {
              HMdcSeg* fSeg = (HMdcSeg*)fSegCat->getNewSlot(locSeg);
              if(!fSeg) Warning("execute","S.%i No HMdcSeg slot available",sec+1);
              else {
                fSeg=new(fSeg) HMdcSeg;
                fSeg->setPar(track.z,r0,track.theta,phiTr);
                fSeg->setSec(locSeg[0]);
                fSeg->setIOSeg(locSeg[1]);
                fSeg->setFlag((mod1<<2)+mod2);
                fSeg->setChi2(100.); //!!!!!!!!!!!!!!!!!
              }
            }
            
            nTracks++;
            if(nTracks>=10000) {
              Warning("execut","To many tracks. Return kSkipEvent!");
              return kSkipEvent;
            }
          }
        }
        // Fill histogramms:
        if(nTracks==0) continue;
        Double_t wt = normalizeHists ? 1./Double_t(nTracks) : 1.;
        for(Int_t n=0;n<nTracks;n++) {
          TrackPar &track  =  trArr[n];
          zVerH[sec][comb]->Fill(track.z,wt);
          if(drawInOutTracks) {
            allTargetArr[inOutTargCurrRun] += wt;
            if(track.z>firstTarPnt[sec] && track.z<lastTarPnt[sec]) inTargetArr[inOutTargCurrRun] += wt;
          }
          if(histsMode==1) zVerDscH[sec][comb][downscalingFlag]->Fill(track.z,wt);
          else if(histsMode==2 && hNum>=0 && hNum<8) zVerDscH[sec][comb][hNum]->Fill(track.z,wt);
          if(plotType == 1) {
            if(track.z>zmin && track.z<zmax) zVerVsEventH[sec][comb]->Fill(nevent+0.5,track.z,wt);
          }
          else if(plotType == 3) {
            if(track.z>zmin && track.z<zmax) zVerVsEventH[sec][comb]->Fill(eventTime()+0.5,track.z,wt);
          }
        }
      }
    }
  }
  if(!mode) {
    if(timer.CpuTime()>=timeStep) {
      if(drawInOutTracks) {
        fillInOutTarHistBin(inOutTargCurrRun);
        setEntriesInOutTHist();
      }
      drawCanvases();
      timer.Reset();
    }
    timer.Start(kFALSE);
  }
  
  // Saving canvases for each "numEventsSave" events:
  if(numEventsSave > 0) {
    eventCounter++;
    if(eventCounter%numEventsSave == 0) {
      if(drawInOutTracks) {
        fillInOutTarHistBin(inOutTargCurrRun);
        setEntriesInOutTHist();
      }
      drawCanvases();
      saveCanvases();
    }
  }
 
  return 0;
}

void HMdcTargetMon::extractFileInfo(void) {
  dateFEvent  = evHeader->getDate();
  if(timeFEvent==0) timeFEvent  = evHeader->getTime();
  TString fileNameOld(fileNameR);
  
  fileNameR = gHades->getDataSource()->getCurrentFileName();
  runId     = gHades->getDataSource()->getCurrentRunId();
  fileNameR.Replace(0, fileNameR.Last('/') + 1, ""); // remove path
  Int_t indpnt = fileNameR.Index(".");
  if(indpnt == 13 || indpnt==15) {                   // file name (be...,)
    fileNameR = fileNameR.Remove(13);
  } else {
    fileNameR.Clear();
    fileNameR += runId;
  }

  if(firstEvent || !sumOfFiles) fileName = fileNameR;
  else {
    fileName += ".";
//    fileName += fileNameR;
  }
}

void HMdcTargetMon::fillDateTime(void) {
  UChar_t* dt  = (UChar_t*)&dateFEvent;
  UChar_t* tm1 = (UChar_t*)&timeFEvent;
  UChar_t* tm2 = (UChar_t*)&timeLEvent;
  Char_t buf[100];
  UChar_t d = dt[0];
  UChar_t h1 = tm1[2];
  UChar_t h2 = tm2[2];
  h1 += 2;
  if(h1 > 23) {
    h1 -= 24;
    d += 1;
  }
  h2 += 2;
  if(h2 > 23) h2 -= 24;
  sprintf(buf,"%02i-%02i-%4i:  %02i:%02i:%02i - %02i:%02i:%02i\n",
      d,dt[1]+1,1900+dt[2],h1,tm1[1],tm1[0],h2,tm2[1],tm2[0]);
  dateTime=buf;
}

Int_t HMdcTargetMon::eventTime(void) {
  UChar_t* tm1=(UChar_t*)&timeFEvent;
  UChar_t* tm2=(UChar_t*)&timeLEvent;
  UInt_t t1=(((UInt_t)tm1[2])*60+((UInt_t)tm1[1]))*60+(UInt_t)tm1[0];
  UInt_t t2=(((UInt_t)tm2[2])*60+((UInt_t)tm2[1]))*60+(UInt_t)tm2[0];
  if(t1<=t2) return t2-t1;
  return (t2+86400)-t1;
}

void HMdcTargetMon::setCanvName(void) {
//   sprintf(cnCut,"cR%icuts",runId);
//   sprintf(ctCut,"Run %s    Cuts",fileNameR.Data());
  for(Int_t comb=0; comb<6; comb++)
    if(nPads[comb]>0) {
      sprintf(cnComb[comb],"target%s_%s_M%i%i",addCnName.Data(),
          fileNameR.Data(),combToMdc[comb][0]+1,combToMdc[comb][1]+1);
      sprintf(ctComb[comb],"Run %s  %s  MDC %i-%i",fileNameR.Data(),
          addCnName.Data(),combToMdc[comb][0]+1,combToMdc[comb][1]+1);
      if(canvs[comb]) {
        canvs[comb]->SetName(cnComb[comb]);
        canvs[comb]->SetTitle(ctComb[comb]);
        canvs[comb]->Update();
      }
   }
}

void HMdcTargetMon::setCanvNameForNR(void) {
  if(collectNRuns<2) return;
  for(Int_t comb=0; comb<6; comb++)
    if(nPads[comb]>0) {
      sprintf(cnCombForNR[comb],"targetSum%iruns%s_%s-%s_M%i%i",
          collectNRuns,addCnName.Data(),
          firstRunName.Data(),lastRunName.Data(),
          combToMdc[comb][0]+1,combToMdc[comb][1]+1);
      sprintf(ctCombForNR[comb],"Runs %s-%s  %s  MDC %i-%i",
          firstRunName.Data(),lastRunName.Data(),
          addCnName.Data(),combToMdc[comb][0]+1,combToMdc[comb][1]+1);
      if(canvsForNR[comb]) {
        canvsForNR[comb]->SetName(cnCombForNR[comb]);
        canvsForNR[comb]->SetTitle(ctCombForNR[comb]);
        canvsForNR[comb]->Update();
      }
   }
}

void HMdcTargetMon::setCanvasSize(Int_t ww, Int_t wh) {
  if(ww>50) canvasWidth  = ww;
  if(wh>50) canvasHeight = wh;
}

void HMdcTargetMon::drawCanvases(void) {
  fillDateTime();
  Char_t title[200];
  if(label==0) label=new TPaveLabel(0.1,0.955,0.9,0.995," ");
//  sprintf(title,"Run:   #color[4]{%s}       Date:   #color[4]{%s}",
//      fileName.Data(),dateTime.Data());
  if(dateFEvent==0) sprintf(title,"%s Run:   #color[4]{%s}",addCnName.Data(),fileName.Data());
  else              sprintf(title,"%s Run:   #color[4]{%s}       Date:   #color[4]{%s}",
  	                    addCnName.Data(),fileName.Data(),dateTime.Data());
  label->SetLabel(title);
  Int_t nPadsPerSector = drawInOutTracks ? 3 : 2;
  for(comb=0; comb<6; comb++) {
    if(nPads[comb]==0) continue;
    if(canvs[comb] == 0) {
      Int_t yln = canvasHeight;
      if(nPads[comb]>1) yln += (nPads[comb]-1)*100;
      if(yln>900) yln = 900;
      canvs[comb] = new TCanvas(cnComb[comb],ctComb[comb],canvasWidth,yln);
      currCanvas = canvs[comb];
      currCanvas->cd();
      currCanvas->SetFillColor(10);
      label->Draw();
      Double_t dY=0.95/nPads[comb];
      Int_t padsRow=0;
      for(Int_t sec=0; sec<6; sec++) {
        if(!zVerH[sec][comb]) continue;
        pad         = padsRow*nPadsPerSector;
        Double_t y1 = dY*(nPads[comb]-padsRow-1)+0.0001;
        Double_t y2 = dY*(nPads[comb]-padsRow)-0.0001;
        
        drawPad(0.0001,y1,0.6999,y2);
        sprintf(title,"sec.%i mod. %i-%i",sec+1,combToMdc[comb][0]+1,combToMdc[comb][1]+1);
        zVerH[sec][comb]->SetTitle(title);
        zVerH[sec][comb]->SetMinimum(0.);
        zVerH[sec][comb]->Draw();
        
        if(drawInOutTracks) {
          TLine* ln = new TLine();
          ln->SetLineColor(2);
          ln->SetLineWidth(4);
          ln->DrawLine(firstTarPnt[sec],0.,lastTarPnt[sec],0.);
        }
        
        fPads[comb][pad]->SetGridx();
        fPads[comb][pad]->SetGridy();
        
        if(histsMode==1) {
          zVerDscH[sec][comb][0]->Draw("same");
          zVerDscH[sec][comb][1]->Draw("same");
        } else if(histsMode==2)
            for(Int_t n=0;n<8;n++) zVerDscH[sec][comb][n]->Draw("same");
        
        Double_t y1b = drawInOutTracks ? (y1+y2)*0.4+0.0001 : y1;
        Double_t y2b = drawInOutTracks ? (y1+y2)*0.4-0.0001 : y2;
        pad++;
        drawPad(0.7001,y1b,0.9999,y2);
        if(plotType==2) {
          sprintf(title,"%s Z=%.2f",zVerVsEventH[sec][comb]->GetTitle(),target[sec].getZ());
          zVerVsEventH[sec][comb]->SetTitle(title);
        }
	gPad->SetGridx();
	gPad->SetGridy();
        zVerVsEventH[sec][comb]->Draw("colz");
        
        if(drawInOutTracks) {
          pad++;
          drawPad(0.7001,y1,0.9999,y2b);
	  gPad->SetGridx();
	  gPad->SetGridy();
          hTargTrFraction->SetLineColor(2);
          hTargTrFraction->Draw();
        }
        padsRow++;
        
      }
    } else {
      canvs[comb]->cd();
      for(Int_t pad=0;pad<(nPadsPerSector*nPads[comb]); pad++) fPads[comb][pad]->Modified();
    }
    canvs[comb]->Modified();
    canvs[comb]->Update();
  }
}

void HMdcTargetMon::drawPad(Double_t x1,Double_t y1,Double_t x2,Double_t y2) {
  Char_t title[20];
  sprintf(title,"pad%i_%02i",comb,pad);
  currCanvas->cd();
  fPads[comb][pad] = new TPad(title,title,x1,y1,x2,y2);
  fPads[comb][pad]->Draw();
  fPads[comb][pad]->cd();
}

void HMdcTargetMon::drawCanvasesRunsSum(void) {
  if(collectNRuns<2) return;
  fillDateTime();
  setCanvNameForNR();
  Char_t title[200];
  if(labelNR==0) labelNR=new TPaveLabel(0.1,0.955,0.9,0.995," ");
//  sprintf(title,"Run:   #color[4]{%s}       Date:   #color[4]{%s}",
//      fileName.Data(),dateTime.Data());
  sprintf(title,"%s %i runs: #color[4]{%s-%s}",addCnName.Data(),runsCounter,firstRunName.Data(),lastRunName.Data());
  labelNR->SetLabel(title);
  Int_t nPadsPerSector = drawInOutTracks ? 3 : 2;
  for(comb=0; comb<6; comb++) {
    if(nPads[comb]==0) continue;
    if(canvsForNR[comb] == 0) {
      Int_t yln = canvasHeight;
      if(nPads[comb]>1) yln += (nPads[comb]-1)*100;
      if(yln>900) yln = 900;
      canvsForNR[comb] = new TCanvas(cnCombForNR[comb],ctCombForNR[comb],canvasWidth,yln);
      currCanvas = canvsForNR[comb];
      currCanvas->cd();
      currCanvas->SetFillColor(10);
      labelNR->Draw();
      Double_t dY      = 0.95/nPads[comb];
      Int_t    padsRow = 0;
      for(Int_t sec=0; sec<6; sec++) {
        if(!zVerForNR[sec][comb]) continue;
        pad         = padsRow*nPadsPerSector;
        Double_t y1 = dY*(nPads[comb]-padsRow-1)+0.0001;
        Double_t y2 = dY*(nPads[comb]-padsRow)-0.0001;
        
        drawPadS(0.0001,y1,0.6999,y2);
        sprintf(title,"sec.%i mod. %i-%i",sec+1,
            combToMdc[comb][0]+1,combToMdc[comb][1]+1);
        zVerForNR[sec][comb]->SetTitle(title);
        zVerForNR[sec][comb]->SetMinimum(0.);
        zVerForNR[sec][comb]->Draw();
        
        if(drawInOutTracks) {
          TLine* ln = new TLine();
          ln->SetLineColor(2);
          ln->SetLineWidth(4);
          ln->DrawLine(firstTarPnt[sec],0.,lastTarPnt[sec],0.);
        }
        
        fPadsForNR[comb][pad]->SetGridx();
        fPadsForNR[comb][pad]->SetGridy();
        
        if(histsMode==1) {
          zVerDscForNR[sec][comb][0]->Draw("same");
          zVerDscForNR[sec][comb][1]->Draw("same");
        } else if(histsMode==2)
            for(Int_t n=0;n<8;n++) zVerDscForNR[sec][comb][n]->Draw("same");
        
        Double_t y1b = drawInOutTracks ? (y1+y2)*0.4+0.0001 : y1;
        Double_t y2b = drawInOutTracks ? (y1+y2)*0.4-0.0001 : y2;
        pad++;
        drawPadS(0.7001,y1b,0.9999,y2);
        if(plotType==2) {
          sprintf(title,"%s Z=%.2f",zVerVsEventForNR[sec][comb]->GetTitle(),target[sec].getZ());
          zVerVsEventForNR[sec][comb]->SetTitle(title);
        }
	gPad->SetGridx();
	gPad->SetGridy();
        zVerVsEventForNR[sec][comb]->Draw("colz");
        
        if(drawInOutTracks) {
          pad++;
          drawPadS(0.7001,y1,0.9999,y2b);
	  gPad->SetGridx();
	  gPad->SetGridy();
          hTargTrFraction->SetLineColor(2);
          hTargTrFraction->Draw();
        }
        padsRow++;
      }
    } else {
      canvsForNR[comb]->cd();
      for(Int_t pad=0;pad<(nPadsPerSector*nPads[comb]); pad++) 
          fPadsForNR[comb][pad]->Modified();
    }
    canvsForNR[comb]->Modified();
    canvsForNR[comb]->Update();
  }
}

void HMdcTargetMon::drawPadS(Double_t x1,Double_t y1,Double_t x2,Double_t y2) {
  Char_t title[20];
  sprintf(title,"pad%i_%02iS",comb,pad);
  currCanvas->cd();
  fPadsForNR[comb][pad] = new TPad(title,title,x1,y1,x2,y2);
  fPadsForNR[comb][pad]->Draw();
  fPadsForNR[comb][pad]->cd();
}

void HMdcTargetMon::setTargPos(Double_t xt, Double_t yt, Double_t zt,Int_t sec) {
  // if sec <0 use it for all sectors
  if(sec>=0 && sec<6) {
    useRtdbTarget[sec] = kFALSE;
    target[sec].setXYZ(xt,yt,zt);
  } else  for(Int_t s=0;s<6;s++) {
    useRtdbTarget[s] = kFALSE;
    target[s].setXYZ(xt,yt,zt);
  }
}

void HMdcTargetMon::setHistPar(Int_t nb, Double_t z1, Double_t z2) {
  nZmBins=nb;
  zmin=z1;
  zmax=z2;
}

void HMdcTargetMon::resetHists(void) {
  for(Int_t i=0;i<6;i++) {
    if(dPhiH[i]) dPhiH[i]->Reset();
    if(r0H[i]) r0H[i]->Reset();
    for(Int_t s=0;s<6;s++) {        
      if(zVerH[s][i]) zVerH[s][i]->Reset();
      if(zVerVsEventH[s][i]) zVerVsEventH[s][i]->Reset();
      for(Int_t k=0;k<10;k++) if(zVerDscH[s][i][k]) zVerDscH[s][i][k]->Reset();
    }
  }
  drawCanvases();
}

void HMdcTargetMon::resetHistsRunsSum(void) {
  if(collectNRuns<2) return;
  for(Int_t i=0;i<6;i++) {
    if(dPhiForNR[i] != NULL) dPhiForNR[i]->Reset();
    if(r0ForNR[i]   != NULL) r0ForNR[i]->Reset();
    for(Int_t s=0;s<6;s++) {        
      if(zVerForNR[s][i]        != NULL) zVerForNR[s][i]->Reset();
      if(zVerVsEventForNR[s][i] != NULL) zVerVsEventForNR[s][i]->Reset();
      for(Int_t k=0;k<10;k++) if(zVerDscForNR[s][i][k] != NULL) zVerDscForNR[s][i][k]->Reset();
    }
  }
  drawCanvasesRunsSum();
}

void HMdcTargetMon::addHistsToRunsSum(void) {
  if(collectNRuns<2) return;
  for(Int_t i=0;i<6;i++) {
    if(dPhiH[i] != NULL) dPhiForNR[i]->Add(dPhiH[i]);
    if(r0H[i]   != NULL  ) r0ForNR[i]->Add(r0H[i]);
    for(Int_t s=0;s<6;s++) {        
      if(zVerH[s][i]        != NULL) zVerForNR[s][i]->Add(zVerH[s][i]);
      if(zVerVsEventH[s][i] != NULL) zVerVsEventForNR[s][i]->Add(zVerVsEventH[s][i]);
      for(Int_t k=0;k<10;k++) if(zVerDscH[s][i][k] != NULL) zVerDscForNR[s][i][k]->Add(zVerDscH[s][i][k]);
    }
  }
  drawCanvasesRunsSum();
}

Bool_t HMdcTargetMon::readMonParam(TString fileMonParam) {
  FILE* file = fopen(fileMonParam.Data(),"r");
  if(file == NULL) {
    Error("readMonParan","File of monitor parameters has been not found !!!");
    return kFALSE;
  }
  TString buffer;
  TString p[6];
  while(buffer.Gets(file)) {
    Int_t ind = buffer.First('#');
    if(ind == 0)  continue;              // Skip line comment
    else if(ind>0) buffer.Resize(ind);   // Remove comment at the line end
    buffer.ToLower();
    TObjArray* a = buffer.Tokenize(" ");
    Int_t np = a->GetEntries()-1;
    TString name = ((TObjString*)(a->At(0)))->GetString();
    if(np > 0 && np<7) {
      for(Int_t n=0;n<np;n++) p[n] = ((TObjString*)(a->At(n+1)))->GetString();
      TString &p1 = p[0];
      if(np == 1) {
        if     (name.EqualTo("selecttrigerbit"))    selectEvByTBits = p1.Atoi();
        else if(name.EqualTo("hist1rmincut"))       r0Cut           = p1.Atof();
        else if(name.EqualTo("donormalization"))    normalizeHists  = p1.Atoi();
        else if(name.EqualTo("hist1type"))          histsMode       = p1.Atoi();
        else if(name.EqualTo("hist2type"))          plotType        = p1.Atoi();
        else if(name.EqualTo("numeventssave"))      numEventsSave   = p1.Atoi();
        else if(name.EqualTo("numrunscollect"))     collectNRuns    = p1.Atoi();
        else if(name.EqualTo("selecttrigerbit"))    selectEvByTBits = p1.Atoi();
        else if(name.EqualTo("saveas"))             typePrintFile   = p1;
        else if(name.EqualTo("pathforonerunhist"))  pathHistOneRun  = p1;
        else if(name.EqualTo("pathforsumrunshist")) pathHistSumRun  = p1;
        else if(name.EqualTo("draweachrun"))        sumOfFiles      = p1.Atoi()==0;
      } else {
        TString &p2 = p[1];
        if(np == 2) {
          if(name.EqualTo("canvassize"))            setCanvasSize(p1.Atoi(),p2.Atoi());
          if(name.EqualTo("clfinderlevelseg1"))     HMdcTrackDSet::setTrFnSegLevel(0,p1.Atoi(),p2.Atoi());
          if(name.EqualTo("clfinderlevelseg2"))     HMdcTrackDSet::setTrFnSegLevel(1,p1.Atoi(),p2.Atoi());
        } else {
          TString &p3 = p[2];
          if(np == 3) {
            if(name.EqualTo("hist1param"))          setHistPar(p1.Atoi(),p2.Atof(),p3.Atof());
            if(name.EqualTo("hist3targetregion"))   setTargetZRegion(p1.Atof(),p2.Atof(),p3.Atoi());
          } else {
            TString &p4 = p[3];
            if(np == 4) {
              if(name.EqualTo("xyztargsec"))        target[p1.Atoi()].setXYZ(p2.Atof(),p3.Atof(),p4.Atof());
            } else {
              if(np == 5) {
                if(name.EqualTo("nlayerssec")) {
                  for(Int_t m=0;m<4;m++)            HMdcTrackDSet::setTrFnNLayers(p1.Atoi(),m,p[m+1].Atoi());
                }
              } else {
                if(np == 6 &&  name.EqualTo("setflag")) {
                  for(Int_t i=0;i<6;i++) useRtdbTarget[i] = (p[i].Atoi()==0);
                }
              }
            }
          }
        }
      }
      a->Delete();
      delete a;
    }
  }
  fclose(file);
  return kTRUE;
}