---

EBBeamCaloClient.cc

Go to the documentation of this file.

/*
 * \file EBBeamCaloClient.cc
 *
 * $Date: 2008/08/11 07:24:13 $
 * $Revision: 1.89 $
 * \author G. Della Ricca
 * \author A. Ghezzi
 *
 */

#include <memory>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <math.h>

#include "TCanvas.h"
#include "TStyle.h"

#include "DQMServices/Core/interface/DQMStore.h"

#include "OnlineDB/EcalCondDB/interface/MonOccupancyDat.h"

#include "OnlineDB/EcalCondDB/interface/EcalCondDBInterface.h"

#include "DQM/EcalCommon/interface/UtilsClient.h"
#include "DQM/EcalCommon/interface/LogicID.h"
#include "DQM/EcalCommon/interface/Numbers.h"

#include <DQM/EcalBarrelMonitorClient/interface/EBBeamCaloClient.h>

using namespace cms;
using namespace edm;
using namespace std;

EBBeamCaloClient::EBBeamCaloClient(const ParameterSet& ps) {

  // cloneME switch
  cloneME_ = ps.getUntrackedParameter<bool>("cloneME", true);

  // verbose switch
  verbose_ = ps.getUntrackedParameter<bool>("verbose", true);

  // debug switch
  debug_ = ps.getUntrackedParameter<bool>("debug", false);

  // prefixME path
  prefixME_ = ps.getUntrackedParameter<string>("prefixME", "");

  // enableCleanup_ switch
  enableCleanup_ = ps.getUntrackedParameter<bool>("enableCleanup", false);

  // vector of selected Super Modules (Defaults to all 36).
  superModules_.reserve(36);
  for ( unsigned int i = 1; i <= 36; i++ ) superModules_.push_back(i);
  superModules_ = ps.getUntrackedParameter<vector<int> >("superModules", superModules_);

  checkedSteps_.reserve(86);
  // there should be not more than a eta row in an autoscan
  minEvtNum_ = 1800;//
  //FIX ME, this should be configurable and change with the beam energy
  aveEne1_    = 1850;  E1Th_   = 900;
  aveEne3x3_  = 2600;  E3x3Th_ = 2600;
  RMSEne3x3_  = 800;

  ReadCryErrThr_ = 0.01;// 1%
  //FIX ME, this should follow the prescaling in the monitoring
  prescaling_ = 20;

  for(int u=0;u<cryInArray_;u++) {
    hBGains_[u] = 0;
    hBpulse_[u] = 0;
    //hBGainsMoving_[u] = 0;
  }
  hBEne1_ = 0;
  //hBEne1Moving_ = 0;
  hBAllNeededCry_ = 0;
  hBNumReadCry_ = 0;
  hBE3x3_ = 0;
  hBE3x3Moving_ = 0;
  hBCryOnBeam_ = 0;
  hBMaxEneCry_ = 0;
  hBReadCryErrors_ = 0;
  hBE1vsCry_ = 0;
  hBE3x3vsCry_ = 0;
  hBEntriesvsCry_ = 0;
  hBcryDone_ = 0;
  hBBeamCentered_ = 0;
  hbTBmoving_ = 0;
  hbE1MaxCry_ = 0;
  hbDesync_ = 0;
  pBCriInBeamEvents_ = 0;

  meEBBCaloRedGreen_ = 0;
  meEBBCaloRedGreenReadCry_ = 0;
  meEBBCaloRedGreenSteps_ = 0;
}

EBBeamCaloClient::~EBBeamCaloClient() {

}

void EBBeamCaloClient::beginJob(DQMStore* dqmStore) {

  dqmStore_ = dqmStore;

  if ( debug_ ) cout << "EBBeamCaloClient: beginJob" << endl;

  ievt_ = 0;
  jevt_ = 0;

}

void EBBeamCaloClient::beginRun(void) {

  if ( debug_ ) cout << "EBBeamCaloClient: beginRun" << endl;

  jevt_ = 0;

  this->setup();

}

void EBBeamCaloClient::endJob(void) {

  if ( debug_ ) cout << "EBBeamCaloClient: endJob, ievt = " << ievt_ << endl;

  this->cleanup();

}

void EBBeamCaloClient::endRun(void) {

  if ( debug_ ) cout << "EBBeamCaloClient: endRun, jevt = " << jevt_ << endl;

  this->cleanup();

}

void EBBeamCaloClient::setup(void) {

  char histo[200];

  dqmStore_->setCurrentFolder( prefixME_ + "/EBBeamCaloClient" );

  if ( meEBBCaloRedGreen_ ) dqmStore_->removeElement( meEBBCaloRedGreen_->getName() );
  sprintf(histo, "EBBCT quality");
  meEBBCaloRedGreen_ = dqmStore_->book2D(histo, histo, 85, 0., 85., 20, 0., 20.);

  meEBBCaloRedGreen_->Reset();

  for ( int ie = 1; ie <= 85; ie++ ) {
    for ( int ip = 1; ip <= 20; ip++ ) {

      meEBBCaloRedGreen_ ->setBinContent( ie, ip, 2. );

    }
  }

  if ( meEBBCaloRedGreenReadCry_ ) dqmStore_->removeElement( meEBBCaloRedGreenReadCry_->getName() );
  sprintf(histo, "EBBCT quality read crystal errors");
  meEBBCaloRedGreenReadCry_ = dqmStore_->book2D(histo, histo, 1, 0., 1., 1, 0., 1.);
  meEBBCaloRedGreenReadCry_->Reset();
  meEBBCaloRedGreenReadCry_ ->setBinContent( 1, 1, 2. );

  if( meEBBCaloRedGreenSteps_ ) dqmStore_->removeElement( meEBBCaloRedGreenSteps_->getName() );
  sprintf(histo, "EBBCT quality entries or read crystals errors");
  meEBBCaloRedGreenSteps_ = dqmStore_->book2D(histo, histo, 86, 1., 87., 1, 0., 1.);
  meEBBCaloRedGreenSteps_->setAxisTitle("step in the scan");
  meEBBCaloRedGreenSteps_->Reset();
  for( int bin=1; bin <87; bin++) { meEBBCaloRedGreenSteps_->setBinContent( bin, 1, 2. );}

}

void EBBeamCaloClient::cleanup(void) {
  if ( ! enableCleanup_ ) return;
  if ( cloneME_ ) {
    for(int u=0;u<cryInArray_;u++) {
      if(hBGains_[u]) delete hBGains_[u];
      if(hBpulse_[u]) delete hBpulse_[u];
      //if(hBGainsMoving_[u])delete hBGainsMoving_[u];
    }
    if(hBEne1_) delete hBEne1_;
    //    if(hBEne1Moving_) delete hBEne1Moving_;
    if(hBAllNeededCry_) delete hBAllNeededCry_;
    if(hBNumReadCry_) delete hBNumReadCry_;
    if(hBE3x3_) delete hBE3x3_;
    if(hBE3x3Moving_) delete hBE3x3Moving_;
    if(hBCryOnBeam_) delete hBCryOnBeam_;
    if(hBMaxEneCry_) delete hBMaxEneCry_;
    if(hBReadCryErrors_) delete hBReadCryErrors_;
    if(hBE1vsCry_) delete hBE1vsCry_;
    if(hBE3x3vsCry_) delete hBE3x3vsCry_;
    if(hBEntriesvsCry_) delete hBEntriesvsCry_;
    if(hBcryDone_) delete hBcryDone_;
    if(hBBeamCentered_) delete hBBeamCentered_;
    if(hbTBmoving_) delete hbTBmoving_;
    if(hbE1MaxCry_) delete hbE1MaxCry_;
    if(hbDesync_) delete hbDesync_;
    if(pBCriInBeamEvents_) delete pBCriInBeamEvents_;
  }

  for(int u=0;u<cryInArray_;u++) {
    hBGains_[u] = 0;
    hBpulse_[u] = 0;
    //hBGainsMoving_[u] = 0;
  }
  hBEne1_ = 0;
  //hBEne1Moving_ = 0;
  hBAllNeededCry_ = 0;
  hBNumReadCry_ = 0;
  hBE3x3_ = 0;
  hBE3x3Moving_ = 0;
  hBCryOnBeam_ = 0;
  hBMaxEneCry_ = 0;
  hBReadCryErrors_ = 0;
  hBE1vsCry_ = 0;
  hBE3x3vsCry_ = 0;
  hBEntriesvsCry_ = 0;
  hBcryDone_ = 0;
  hBBeamCentered_ = 0;
  hbTBmoving_ = 0;
  hbE1MaxCry_ = 0;
  hbDesync_ = 0;
  pBCriInBeamEvents_ =0;

  dqmStore_->setCurrentFolder( prefixME_ + "/EBBeamCaloClient" );

  if ( meEBBCaloRedGreen_) dqmStore_->removeElement( meEBBCaloRedGreen_->getName() );
  meEBBCaloRedGreen_ = 0;
  if ( meEBBCaloRedGreenReadCry_) dqmStore_->removeElement( meEBBCaloRedGreenReadCry_->getName() );
  meEBBCaloRedGreenReadCry_ = 0;
  if( meEBBCaloRedGreenSteps_ ) dqmStore_->removeElement (  meEBBCaloRedGreenSteps_->getName() );
  meEBBCaloRedGreenSteps_ = 0;
}

bool EBBeamCaloClient::writeDb(EcalCondDBInterface* econn, RunIOV* runiov, MonRunIOV* moniov, bool& status, bool flag) {

  status = true;

  if ( ! flag ) return false;

  EcalLogicID ecid;

  MonOccupancyDat o;
  map<EcalLogicID, MonOccupancyDat> dataset;

  for ( unsigned int i=0; i<superModules_.size(); i++ ) {

    int ism = superModules_[i];

    if ( verbose_ ) {
      cout << " " << Numbers::sEB(ism) << " (ism=" << ism << ")" << endl;
      cout << endl;
    }

    const float n_min_tot = 1000.;

    float num01, num02;
    float mean01;

    for ( int ie = 1; ie <= 85; ie++ ) {
      for ( int ip = 1; ip <= 20; ip++ ) {

        num01 = num02 = -1.;
        mean01 = -1.;

        bool update_channel = false;

        if ( hBCryOnBeam_ && hBCryOnBeam_->GetEntries() >= n_min_tot ) {
          num01 = hBCryOnBeam_->GetBinContent(ie, ip);
          update_channel = true;
        }

        if ( hBMaxEneCry_ && hBMaxEneCry_->GetEntries() >= n_min_tot ) {
          num02 = hBMaxEneCry_->GetBinContent(ie, ip);
          update_channel = true;
        }

        mean01 = 0.;
        //int cry = ip+20*(ie-1);
        int ic = (ip-1) + 20*(ie-1) + 1;
        int step = 0;
        if (hBcryDone_) { step = (int) hBcryDone_->GetBinContent(ic);}
        if( step > 0 && step < 86) {
        //if(hBE3x3vsCry_) {mean01 = hBE3x3vsCry_->GetBinContent(step);}// E in the 3x3
        if( hBE1vsCry_ ) {mean01 = hBE1vsCry_->GetBinContent(ic);} // E1
        }

        if ( update_channel ) {

          if ( Numbers::icEB(ism, ie, ip) == 1 ) {

            if ( verbose_ ) {
              cout << "Preparing dataset for " << Numbers::sEB(ism) << " (ism=" << ism << ")" << endl;
              cout << "CryOnBeam (" << ie << "," << ip << ") " << num01  << endl;
              cout << "MaxEneCry (" << ie << "," << ip << ") " << num02  << endl;
              cout << "E1 ("        << ie << "," << ip << ") " << mean01 << endl;
              cout << endl;
            }

          }

          o.setEventsOverHighThreshold(int(num01));
          o.setEventsOverLowThreshold(int(num02));

          o.setAvgEnergy(mean01);

          if ( econn ) {
            ecid = LogicID::getEcalLogicID("EB_crystal_number", Numbers::iSM(ism, EcalBarrel), ic);
            dataset[ecid] = o;
          }

        }

      }
    }

  }

  if ( econn ) {
    try {
      if ( verbose_ ) cout << "Inserting MonOccupancyDat ..." << endl;
      if ( dataset.size() != 0 ) econn->insertDataArraySet(&dataset, moniov);
      if ( verbose_ ) cout << "done." << endl;
    } catch (runtime_error &e) {
      cerr << e.what() << endl;
    }
  }

  return true;

}

void EBBeamCaloClient::analyze(void) {

  ievt_++;
  jevt_++;
  if ( ievt_ % 10 == 0 ) {
    if ( debug_ ) cout << "EBBeamCaloClient: ievt/jevt = " << ievt_ << "/" << jevt_ << endl;
  }

  char histo[200];

  MonitorElement* me = 0;

  // MonitorElement* meCD;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT crystals done").c_str());
  //meCD = dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBcryDone_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBcryDone_ );

  //MonitorElement* meCryInBeam;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT crystal on beam").c_str());
  //meCryInBeam = dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBCryOnBeam_ = UtilsClient::getHisto<TH2F*>( me, cloneME_, hBCryOnBeam_);

  //MonitorElement* allNeededCry;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT all needed crystals readout").c_str());
  //allNeededCry= dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBAllNeededCry_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBAllNeededCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT readout crystals number").c_str());
  //allNeededCry= dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBNumReadCry_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBNumReadCry_);

  //MonitorElement* RecEne3x3;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT rec Ene sum 3x3").c_str());
  //RecEne3x3= dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBE3x3_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBE3x3_);

  //MonitorElement* ErrRedCry;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT readout crystals errors").c_str());
  //ErrRedCry = dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBReadCryErrors_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBReadCryErrors_);

  //  MonitorElement* RecEne1;
  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT rec energy cry 5").c_str());
  //RecEne1= dqmStore_->get(histo);
  me = dqmStore_->get(histo);
  hBEne1_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBEne1_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT crystal with maximum rec energy").c_str());
  me = dqmStore_->get(histo);
  hBMaxEneCry_ = UtilsClient::getHisto<TH2F*>( me, cloneME_, hBMaxEneCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT average rec energy in the 3x3 array").c_str());
  me = dqmStore_->get(histo);
  hBE3x3vsCry_ = UtilsClient::getHisto<TProfile*>( me, cloneME_, hBE3x3vsCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT average rec energy in the single crystal").c_str());
  me = dqmStore_->get(histo);
  hBE1vsCry_ = UtilsClient::getHisto<TProfile*>( me, cloneME_, hBE1vsCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT number of entries").c_str());
  me = dqmStore_->get(histo);
  hBEntriesvsCry_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBEntriesvsCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT energy deposition in the 3x3").c_str());
  me = dqmStore_->get(histo);
  hBBeamCentered_ = UtilsClient::getHisto<TH2F*>( me, cloneME_, hBBeamCentered_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT table is moving").c_str());
  me = dqmStore_->get(histo);
  hbTBmoving_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, hbTBmoving_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT crystal in beam vs event").c_str());
  me = dqmStore_->get(histo);
  pBCriInBeamEvents_ =  UtilsClient::getHisto<TProfile*>( me, cloneME_, pBCriInBeamEvents_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT E1 in the max cry").c_str());
  me = dqmStore_->get(histo);
  hbE1MaxCry_ =  UtilsClient::getHisto<TH1F*>( me, cloneME_, hbE1MaxCry_);

  sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT Desynchronization vs step").c_str());
  me = dqmStore_->get(histo);
  hbDesync_ =  UtilsClient::getHisto<TH1F*>( me, cloneME_, hbDesync_);

  for(int ind = 0; ind < cryInArray_; ind ++) {
    sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT pulse profile in G12 cry %01d").c_str(), ind+1);
    me = dqmStore_->get(histo);
    hBpulse_[ind] = UtilsClient::getHisto<TProfile*>( me, cloneME_, hBpulse_[ind]);

    sprintf(histo, (prefixME_ + "/EBBeamCaloTask/EBBCT found gains cry %01d").c_str(), ind+1);
    me = dqmStore_->get(histo);
    hBGains_[ind] = UtilsClient::getHisto<TH1F*>( me, cloneME_, hBGains_[ind]);
  }

  int DoneCry = 0;//if it stays 1 the run is not an autoscan
  if (hBcryDone_) {
    for(int cry=1 ; cry<1701 ; cry ++) {
      int step = (int) hBcryDone_->GetBinContent(cry);
      if( step>0 ) {//this crystal has been scanned or is being scanned
        DoneCry++;
        float E3x3RMS = -1, E3x3 =-1, E1=-1;
        if(hBE3x3vsCry_) {
          //E3x3RMS = hBE3x3vsCry_->GetBinError(step);
          //E3x3 = hBE3x3vsCry_->GetBinContent(step);
          E3x3RMS = hBE3x3vsCry_->GetBinError(cry);
          E3x3 = hBE3x3vsCry_->GetBinContent(cry);
        }
        //if( hBE1vsCry_) {E1=hBE1vsCry_->GetBinContent(step);}
        if( hBE1vsCry_) {E1=hBE1vsCry_->GetBinContent(cry);}
        bool RMS3x3  =  (  E3x3RMS < RMSEne3x3_ && E3x3RMS >= 0 );
        bool Mean3x3 =  ( fabs( E3x3 - aveEne3x3_ ) < E3x3Th_);
        bool Mean1   =  ( fabs( E1 - aveEne1_ ) < E1Th_ );
        int ieta = ( cry - 1)/20 + 1 ;//+1 for the bin
        int iphi = ( cry - 1)%20 + 1 ;//+1 for the bin
        //fill the RedGreen histo
        if(ieta >0 && iphi >0 ) {
          if(RMS3x3 && Mean3x3 && Mean1) {meEBBCaloRedGreen_->setBinContent(ieta,iphi,1.);}
          else {meEBBCaloRedGreen_->setBinContent(ieta,iphi,0.);}
        }

        float Entries = -1;
        //if ( hBEntriesvsCry_ ) {Entries = hBEntriesvsCry_->GetBinContent(step);}
        if ( hBEntriesvsCry_ ) {Entries = hBEntriesvsCry_->GetBinContent(cry);}
        bool Nent = ( Entries * prescaling_  > minEvtNum_ );
        bool readCryOk = true;
        if( hBReadCryErrors_ ) {
          int step_bin = hBReadCryErrors_->GetXaxis()->FindFixBin(step);
          if ( step_bin > 0 && step_bin < hBReadCryErrors_->GetNbinsX() ) {
            if ( hBReadCryErrors_->GetBinContent(step_bin) <= Entries*ReadCryErrThr_ ) {readCryOk = true;}
            else {readCryOk = false;}
          }
        }

        if(Nent && readCryOk ) { meEBBCaloRedGreenSteps_->setBinContent(step,1,1.);}
        else{ meEBBCaloRedGreenSteps_->setBinContent(step,1,0.);}

        if (readCryOk &&  meEBBCaloRedGreenReadCry_->getBinContent(1,1) != 0.) { meEBBCaloRedGreenReadCry_->setBinContent(1,1, 1.);}
        else if ( !readCryOk ) { meEBBCaloRedGreenReadCry_->setBinContent(1,1, 0.);}
      }// end of if (step>0)
    }//end of loop over cry
  }//end of if(hBcryDone_)

  if(DoneCry == 1) {//this is probably not an auotscan or it is the first crystal
    float nEvt = 0;
    if(hBE3x3_) {nEvt = hBE3x3_->GetEntries();}
    if(nEvt > 1*prescaling_ && hBE3x3_ && hBEne1_ && hBCryOnBeam_ && meEBBCaloRedGreen_) {//check for mean and RMS
      bool RMS3x3  =  ( hBE3x3_->GetRMS() < RMSEne3x3_ );
      bool Mean3x3 =  ( fabs( hBE3x3_->GetMean() - aveEne3x3_ ) < E3x3Th_ );
      bool Mean1   =  ( fabs( hBEne1_->GetMean() - aveEne1_ ) < E1Th_ );
      //fill the RedGreen histo
      int ieta=0,iphi=0;
      float found =0; //there should be just one bin filled but...
      for (int b_eta =1; b_eta<86; b_eta++) {
        for (int b_phi =1; b_phi<21; b_phi++) {
          float bc = hBCryOnBeam_->GetBinContent(b_eta,b_phi);//FIX ME check if this is the correct binning
          if(bc > found) { found =bc; ieta = b_eta; iphi= b_phi;}
        }
      }
      if(ieta >0 && iphi >0 ) {
        if(RMS3x3 && Mean3x3 && Mean1) {meEBBCaloRedGreen_->setBinContent(ieta,iphi,1.);}
        else {meEBBCaloRedGreen_->setBinContent(ieta,iphi,0.);}
      }
    }
    if(hBReadCryErrors_) {
      float nErr = hBReadCryErrors_->GetBinContent(1);// for a non autoscan just the first bin should be filled
      if( nErr > nEvt*ReadCryErrThr_ ) { meEBBCaloRedGreenReadCry_->setBinContent(1,1,0.);}
      else { meEBBCaloRedGreenReadCry_->setBinContent(1,1,1.);}
    }
  }

  //   // was done using me instead of histos
  //   if(DoneCry == 0) {//this is probably not an auotscan
  //     float nEvt = RecEne3x3->getEntries();
  //     if(nEvt > 1000*prescaling_) {//check for mean and RMS
  //       bool RMS3x3  =  ( RecEne3x3->getRMS() < RMSEne3x3_ );
  //       bool Mean3x3 =  ( (RecEne3x3->getMean() - aveEne3x3_) < E3x3Th_);
  //       bool Mean1   =  ( (RecEne1->getMean() < aveEne1_) < E1Th_ );
  //       //fill the RedGreen histo
  //       int ieta=0,iphi=0;
  //       float found =0; //there should be just one bin filled but...
  //       for (int b_eta =1; b_eta<86; b_eta++) {
  //         for (int b_phi =1; b_phi<21; b_phi++) {
  //           float bc = meCryInBeam->getBinContent(b_eta,b_phi);//FIX ME check if this is the correct binning
  //           if(bc > found) { found =bc; ieta = b_eta; iphi= b_phi;}
  //         }
  //       }
  //       if(ieta >0 && iphi >0 ) {
  //         if(RMS3x3 && Mean3x3 && Mean1) {meEBBCaloRedGreen_->setBinContent(ieta,iphi,1.);}
  //         else {meEBBCaloRedGreen_->setBinContent(ieta,iphi,0.);}
  //       }
  //     }
  //     float nErr = ErrRedCry->getBinContent(1);// for a non autoscan just the first bin should be filled
  //     if( nErr > nEvt*ReadCryErrThr_ ) { meEBBCaloRedGreenReadCry_->setBinContent(1,1,0.);}
  //     else { meEBBCaloRedGreenReadCry_->setBinContent(1,1,1.);}
  //   }


}

void EBBeamCaloClient::softReset(bool flag) {

}

void EBBeamCaloClient::htmlOutput(int run, string& htmlDir, string& htmlName) {

  if ( verbose_ ) cout << "Preparing EBBeamCaloClient html output ..." << endl;

  ofstream htmlFile;

  htmlFile.open((htmlDir + htmlName).c_str());

  // html page header
  htmlFile << "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">  " << endl;
  htmlFile << "<html>  " << endl;
  htmlFile << "<head>  " << endl;
  htmlFile << "  <meta content=\"text/html; charset=ISO-8859-1\"  " << endl;
  htmlFile << " https-equiv=\"content-type\">  " << endl;
  htmlFile << "  <title>Monitor:BeamTask output</title> " << endl;
  htmlFile << "</head>  " << endl;
  htmlFile << "<style type=\"text/css\"> td { font-weight: bold } </style>" << endl;
  htmlFile << "<body>  " << endl;
  htmlFile << "<br>  " << endl;
  htmlFile << "<h2>Run:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" << endl;
  htmlFile << "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <span " << endl;
  htmlFile << " style=\"color: rgb(0, 0, 153);\">" << run << "</span></h2>" << endl;
  htmlFile << "<h2>Monitoring task:&nbsp;&nbsp;&nbsp;&nbsp; <span " << endl;
  htmlFile << " style=\"color: rgb(0, 0, 153);\">BeamCalo</span></h2> " << endl;
  htmlFile << "<hr>" << endl;
  //  htmlFile << "<table border=1><tr><td bgcolor=red>channel has problems in this task</td>" << endl;
  //  htmlFile << "<td bgcolor=lime>channel has NO problems</td>" << endl;
  //  htmlFile << "<td bgcolor=yellow>channel is missing</td></table>" << endl;
  //  htmlFile << "<hr>" << endl;


  htmlFile <<  "<a href=\"#qua_plots\"> Quality plots </a>" << endl;
  htmlFile << "<p>" << endl;
  htmlFile <<  "<a href=\"#gen_plots\"> General plots </a>" << endl;
  htmlFile << "<p>" << endl;
  htmlFile <<  "<a href=\"#fix_plots\"> Plots for the fixed crystal runs </a>" << endl;
  htmlFile << "<p>" << endl;
  htmlFile <<  "<a href=\"#aut_plots\"> Plots for the autoscan runs </a>" << endl;
  htmlFile << "<p>" << endl;

  htmlFile << "<hr>" << endl;
  htmlFile << "<p>" << endl;



  // Produce the plots to be shown as .png files from existing histograms


  const int csize = 250;
  //  const double histMax = 1.e15;

  int pCol3[7] = { 301, 302, 303, 304, 305, 306, 307 };

  TH2C dummy( "dummy", "dummy for sm", 85, 0., 85., 20, 0., 20. );
  for ( int i = 0; i < 68; i++ ) {
    int a = 2 + ( i/4 ) * 5;
    int b = 2 + ( i%4 ) * 5;
    dummy.Fill( a, b, i+1 );
  }
  dummy.SetMarkerSize(2);
  dummy.SetMinimum(0.1);

  TH2I dummyStep( "dummyStep", "dummy2 for sm", 86, 1., 87., 1, 0., 1. );
  if(hBcryDone_) {
    for(int cry=1 ; cry<1701 ; cry ++) {
      int step = (int) hBcryDone_->GetBinContent(cry);
      if (step >0 ) {dummyStep.SetBinContent( step+1, 1, cry );}
    }
  }
  //dummyStep.SetBinContent( 6, 1, 1699 );
  //dummyStep.SetBinContent( 85, 1, 1698 );
  dummyStep.SetMarkerSize(2);
  dummyStep.SetMinimum(0.1);

  //useful for both autoscan and non autoscan
  string RedGreenSMImg,RedGreenImg,RedGreenAutoImg, numCryReadImg, cryReadErrImg, E1MaxCryImg, DesyncImg;
  string cryOnBeamImg, cryMaxEneImg, ratioImg;
  // useful for non autoscan
  string ene1Img, ene3x3Img, EBBeamCentered;
  string pulseshapeImg, gainImg;
  //useful for autoscan
  string cryDoneImg, EntriesVScryImg, E1vsCryImg, E3x3vsCryImg;
  string cryVSeventImg, TBmoving;

  string meName,imgName1,imgName2,imgName3;
  TH2F* obj2f = 0;
  TH1F* obj1f = 0;
  TProfile* objp1 = 0;

  htmlFile << "<br>" << endl;
  htmlFile <<  "<a name=\"qua_plots\"> <B> Quality plots </B> </a> " << endl;
  htmlFile << "</br>" << endl;

  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  // quality red-green histo
  obj2f = UtilsClient::getHisto<TH2F*>( meEBBCaloRedGreen_ );
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", 2*csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    RedGreenSMImg = meName + ".png";
    imgName1 = htmlDir + RedGreenSMImg;

    can->cd();
    gStyle->SetOptStat(" ");
    gStyle->SetPalette(7, pCol3);
    obj2f->GetXaxis()->SetNdivisions(17);
    obj2f->GetYaxis()->SetNdivisions(4);
    can->SetGridx();
    can->SetGridy();
    obj2f->SetMinimum(-0.00000001);
    obj2f->SetMaximum(7.0);
    obj2f->Draw("col");
    dummy.Draw("text,same");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << RedGreenSMImg  << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //red-green pad
  obj2f = UtilsClient::getHisto<TH2F*>( meEBBCaloRedGreenReadCry_ );
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    RedGreenImg = meName + ".png";
    imgName1 = htmlDir + RedGreenImg;

    can->cd();
    gStyle->SetOptStat(" ");
    gStyle->SetPalette(7, pCol3);
    obj2f->GetXaxis()->SetNdivisions(0);
    obj2f->GetYaxis()->SetNdivisions(0);
    obj2f->SetMinimum(-0.00000001);
    obj2f->SetMaximum(7.0);
    obj2f->Draw("col");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << RedGreenImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  // quality entries and read cry red-green histo for autoscan
  obj2f = UtilsClient::getHisto<TH2F*>( meEBBCaloRedGreenSteps_ );
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", 5*csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    RedGreenAutoImg = meName + ".png";
    imgName1 = htmlDir + RedGreenAutoImg;

    can->cd();
    gStyle->SetOptStat(" ");
    gStyle->SetPalette(7, pCol3);
    obj2f->GetXaxis()->SetNdivisions(86);
    obj2f->GetYaxis()->SetNdivisions(0);
    can->SetGridx();
    //can->SetGridy();
    obj2f->SetMinimum(-0.00000001);
    obj2f->SetMaximum(7.0);
    obj2f->Draw("col");
    dummyStep.Draw("text90,same");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << RedGreenAutoImg  << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;


  htmlFile << "<br>" << endl;
  htmlFile <<  "<a name=\"gen_plots\"> <B> General plots </B> </a>" << endl;
  htmlFile << "</br>" << endl;

  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  // number of readout crystals : numCryReadImg
  obj1f = hBNumReadCry_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    numCryReadImg = meName + ".png";
    imgName1 = htmlDir + numCryReadImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat(1110);
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << numCryReadImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  // error: reading less than the 7x7: cryReadErrImg;
  obj1f = hBReadCryErrors_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    cryReadErrImg = meName + ".png";
    imgName1 = htmlDir + cryReadErrImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << cryReadErrImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;


 // E1 of the max cry: cryReadErrImg;
  obj1f = hbE1MaxCry_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    E1MaxCryImg = meName + ".png";
    imgName1 = htmlDir +  E1MaxCryImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" <<  E1MaxCryImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

 // Desynchronization
  obj1f = hbDesync_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    DesyncImg = meName + ".png";
    imgName1 = htmlDir +  DesyncImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << DesyncImg  << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  //  crystal on beam: cryOnBeamImg
  obj2f =  hBCryOnBeam_;
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", 2*csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    cryOnBeamImg = meName + ".png";
    imgName1 = htmlDir + cryOnBeamImg;

    can->cd();
    gStyle->SetOptStat(" ");
    gStyle->SetPalette(1);
    obj2f->GetXaxis()->SetNdivisions(17);
    obj2f->GetYaxis()->SetNdivisions(4);
    can->SetGridx();
    can->SetGridy();
    obj2f->SetMinimum(0.00000001);
    //obj2f->SetMaximum(2.0);
    obj2f->Draw("colz");
    dummy.Draw("text,same");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << cryOnBeamImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //cryMaxEneImg

  obj2f = hBMaxEneCry_;
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", 2*csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    cryMaxEneImg = meName + ".png";
    imgName1 = htmlDir + cryMaxEneImg;

    can->cd();
    gStyle->SetOptStat(" ");
    gStyle->SetPalette(1);
    obj2f->GetXaxis()->SetNdivisions(17);
    obj2f->GetYaxis()->SetNdivisions(4);
    can->SetGridx();
    can->SetGridy();
    obj2f->SetMinimum(0.00000001);
    obj2f->Draw("colz");
    dummy.Draw("text,same");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << cryMaxEneImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  // ratioImg still to be done
  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;

  htmlFile << "<br>" << endl;
  htmlFile <<  "<a name=\"fix_plots\"> <B> Plots for the fixed crystal runs </B> </a>" << endl;
  htmlFile << "</br>" << endl;

  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  //ene1Img, ene3x3Img, EBBeamCentered;
  obj1f = hBEne1_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    ene1Img = meName + ".png";
    imgName1 = htmlDir + ene1Img;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat(1110);
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << ene1Img << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //ene3x3Img
  obj1f = hBE3x3_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    ene3x3Img = meName + ".png";
    imgName1 = htmlDir + ene3x3Img;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat(1110);
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << ene3x3Img << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //EBBeamCentered
  obj2f = hBBeamCentered_;
  if ( obj2f ) {

    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj2f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    EBBeamCentered = meName + ".png";
    imgName1 = htmlDir + EBBeamCentered;

    can->cd();
    gStyle->SetOptStat(" ");
    obj2f->SetLineColor(kRed);
    obj2f->SetFillColor(kRed);

    obj2f->Draw("box");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << EBBeamCentered << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  string pulseImg[cryInArray_], gainsImg[cryInArray_], pulseImgF[cryInArray_], gainsImgF[cryInArray_];
  for(int ind = 0; ind < cryInArray_; ind ++) {
    objp1 = hBpulse_[ind];
    if ( objp1 ) {
      TCanvas* can = new TCanvas("can", "Temp", csize, csize);
      meName = objp1->GetName();

      replace(meName.begin(), meName.end(), ' ', '_');
      pulseImg[ind] = meName + ".png";
      pulseImgF[ind] = htmlDir + pulseImg[ind] ;

      can->cd();
      objp1->SetStats(kTRUE);
      gStyle->SetOptStat("e");
      objp1->Draw();
      can->Update();
      can->SaveAs( pulseImgF[ind].c_str());
      delete can;
    }

    obj1f = hBGains_[ind];
    if ( obj1f ) {
      TCanvas* can = new TCanvas("can", "Temp", csize, csize);
      meName = obj1f->GetName();

      replace(meName.begin(), meName.end(), ' ', '_');
      gainsImg[ind] = meName + ".png";
      gainsImgF[ind] = htmlDir + gainsImg[ind];

      can->cd();
      obj1f->SetStats(kTRUE);
      gStyle->SetOptStat(1110);
      if(obj1f->GetEntries() != 0 ) {gStyle->SetOptLogy(1);}
      obj1f->Draw();
      can->Update();
      can->SaveAs(gainsImgF[ind].c_str());
      gStyle->SetOptLogy(0);
      delete can;
    }

  }

  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  htmlFile << "<td>" << endl;
  int row = (int) sqrt(float(cryInArray_));
  htmlFile << "<table border=\"4\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;

  for(int ind=0; ind < cryInArray_; ind++) {
    if ( pulseImgF[ind].size() != 0 )
      htmlFile << "<td><img src=\"" << pulseImg[ind] << "\"></td>" << endl;
    else
      htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;
    if ( (ind+1) % row == 0) {htmlFile << "</tr>" << endl;}
  }
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  htmlFile << "</td>" << endl;
  htmlFile << "<td>" << endl;
  htmlFile << "<table border=\"4\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;

  for(int ind=0; ind < cryInArray_; ind++) {
    if ( gainsImgF[ind].size() != 0 )
      htmlFile << "<td><img src=\"" << gainsImg[ind] << "\"></td>" << endl;
    else
      htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;
    if ( (ind+1) % row == 0) {htmlFile << "</tr>" << endl;}
  }
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  htmlFile << "</td>" << endl;
  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;

  htmlFile << "<br>" << endl;
  htmlFile <<  "<a name=\"aut_plots\"> <B> Plots for the autoscan runs </B> </a>" << endl;
  htmlFile << "</br>" << endl;

  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  // cryDoneImg,EntriesVScryImg E1vsCryImg, E3x3vsCryImg
  //cryDoneImg
  obj1f = hBcryDone_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", int(1.618*csize), csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    cryDoneImg = meName + ".png";
    imgName1 = htmlDir + cryDoneImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << cryDoneImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //EntriesVScryImg
  obj1f = hBEntriesvsCry_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", int(1.618*csize), csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    EntriesVScryImg = meName + ".png";
    imgName1 = htmlDir + EntriesVScryImg;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");

    if(obj1f->GetEntries() != 0 ) {gStyle->SetOptLogy(1);}
    AdjustRange(obj1f);
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
    gStyle->SetOptLogy(0);
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" << EntriesVScryImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;


  htmlFile << "</tr>" << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  //E1vsCryImg
  objp1 = hBE1vsCry_;
  if ( objp1 ) {
    TCanvas* can = new TCanvas("can", "Temp", int(1.618*csize), csize);
    meName = objp1->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    E1vsCryImg = meName + ".png";
    imgName1 = htmlDir +  E1vsCryImg;

    can->cd();
    objp1->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(objp1);
    objp1->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" <<  E1vsCryImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  //E3x3vsCryImg
  objp1 = hBE3x3vsCry_;
  if ( objp1 ) {
    TCanvas* can = new TCanvas("can", "Temp", int(1.618*csize), csize);
    meName = objp1->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    E3x3vsCryImg = meName + ".png";
    imgName1 = htmlDir +  E3x3vsCryImg;

    can->cd();
    objp1->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    AdjustRange(objp1);
    objp1->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" <<  E3x3vsCryImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;


  htmlFile << "</tr>" << endl;
  htmlFile << "</table>" << endl;
  htmlFile << "<br>" << endl;
  htmlFile << "<table border=\"0\" cellspacing=\"0\" " << endl;
  htmlFile << "cellpadding=\"10\" align=\"center\"> " << endl;
  htmlFile << "<tr align=\"center\">" << endl;
  // cryVSeventImg, TBmoving;
  objp1 = pBCriInBeamEvents_;
  if ( objp1 ) {
    TCanvas* can = new TCanvas("can", "Temp", 3*csize, csize);
    meName = objp1->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    cryVSeventImg = meName + ".png";
    imgName1 = htmlDir +  cryVSeventImg;

    can->cd();
    //objp1->SetStats(kTRUE);
    //gStyle->SetOptStat("e");

    float dd=0;
    int mbin =0;
    for( int bin=1; bin < objp1->GetNbinsX()+1; bin++ ) {
      float temp = objp1->GetBinContent(bin);
      if(temp>0) { dd= temp+0.01; mbin=bin; break;}
    }
    if(mbin >0) { objp1->Fill(20*mbin-1,dd);}

    AdjustRange(objp1);
    float Ymin = 1701, Ymax =0;
    for( int bin=1; bin < objp1->GetNbinsX()+1; bin++ ) {
      float temp = objp1->GetBinContent(bin);
      if(temp >0) {
        if(temp < Ymin) {Ymin=temp;}
        if(temp > Ymax) {Ymax=temp;}
      }
    }
    if( Ymin < Ymax+1 ) {
       for( int bin=1; bin < objp1->GetNbinsX()+1; bin++ ) {
         if( objp1->GetBinError(bin) >0 ) {
           objp1->SetBinContent(bin, (Ymin+Ymax)/2.*objp1->GetBinEntries(bin) );
         }
       }
       objp1->GetYaxis()->SetRangeUser(Ymin-1. , Ymax+1.);
    }

    objp1->Draw("e");
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" <<  cryVSeventImg << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;

  // TBmoving;
  obj1f = hbTBmoving_;
  if ( obj1f ) {
    TCanvas* can = new TCanvas("can", "Temp", csize, csize);
    meName = obj1f->GetName();

    replace(meName.begin(), meName.end(), ' ', '_');
    TBmoving = meName + ".png";
    imgName1 = htmlDir +  TBmoving;

    can->cd();
    obj1f->SetStats(kTRUE);
    gStyle->SetOptStat("e");
    obj1f->Draw();
    can->Update();
    can->SaveAs(imgName1.c_str());
    delete can;
  }
  if ( imgName1.size() != 0 )
    htmlFile << "<td><img src=\"" <<  TBmoving << "\"></td>" << endl;
  else
    htmlFile << "<td><img src=\"" << " " << "\"></td>" << endl;



  // html page footer
  htmlFile << "</body> " << endl;
  htmlFile << "</html> " << endl;

  htmlFile.close();

}

template<class T> void EBBeamCaloClient::AdjustRange( T obj) {
  if (obj->GetEntries() == 0) {return;}
  int first_bin = -1, last_bin=-1;
  for( int bin=1; bin < obj->GetNbinsX()+1; bin++ ) {
    if( obj->GetBinContent(bin) > 0) {
      if(first_bin == -1) {first_bin = bin;}
      last_bin = bin;
    }
  }

  if(first_bin < 1 || last_bin < 1) {return;}
  if(first_bin > 3) {first_bin -= 3;}
  if(last_bin < obj->GetNbinsX() ) {last_bin += 3;}

  obj->GetXaxis()->SetRange(first_bin, last_bin);
}

---