---

H2DCnv.cpp

Go to the documentation of this file.

#define ROOTHISTCNV_H2DCNV_CPP


// Include files
#include <iostream>
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IHistogram2D.h"
#include "GaudiKernel/IAxis.h"

#include "H2DCnv.h"
#include "RootDirFcn.h"

#include "TH2.h"
#include "TFile.h"
#include <list>

//------------------------------------------------------------------------------
//
// Implementation of class :  RootHistCnv::H2DCnv
//
// Author :                   Charles Leggett
//
//------------------------------------------------------------------------------
  

// Instantiation of a static factory class used by clients to create
// instances of this service
static CnvFactory<RootHistCnv::H2DCnv> s_factory;
const ICnvFactory& RootHistH2DCnvFactory = s_factory;


namespace RootHistCnv {

  StatusCode H2DCnv::createRep(DataObject* pObject, IOpaqueAddress*& refpAddress)  {

    IHistogram2D* h = dynamic_cast<IHistogram2D*>(pObject);
    refpAddress = 0;

    MsgStream log(msgSvc(), "RootHistCnv::H2DCnv");

    if ( 0 != h ) {

      std::string temp = h->title();

      int sep = temp.find('|');
      if ( 0 >= sep ) {
        // No histogram ID, no histogram name
        log << MSG::ERROR << "Cannot separate histogram title and identifier" << endreq;
        log << MSG::ERROR << "while converting the histogram: " << temp << endreq;
        return StatusCode::FAILURE;
      }

      std::string histoID( temp, 0, sep );
      std::string title( temp, sep+1, temp.length() );

      int    nBinX    = h->xAxis()->bins();     // Number of bins in the axis X
      float  xLow     = h->xAxis()->lowerEdge();  // X-lower edge
      float  xHigh    = h->xAxis()->upperEdge();  // X-upper edge
      float  x_uflow  = xLow  - 1.0;      // Underflow coordinate X
      float  x_oflow  = xHigh + 1.0;      // Overflow coordinate X

      int    nBinY    = h->yAxis()->bins();     // Number of bins in the axis Y
      float  yLow     = h->yAxis()->lowerEdge();  // Y-lower edge
      float  yHigh    = h->yAxis()->upperEdge();  // Y-upper edge
      float  y_uflow  = yLow  - 1.0;      // Underflow coordinate Y
      float  y_oflow  = yHigh + 1.0;      // Overflow coordinate Y

      int    entries  = 0;                // Number of entries in a bin
      float  height   = 0.;               // Height if a bin
      float  centreX  = 0.;               // Centre of a bin on the axis X
      float  centreY  = 0.;               // Centre of a bin on the axis Y
      float  weight   = 0.;               // height / entries
      int    ix       = 0;                // Bin index on the axis X
      int    iy       = 0;                // Bin index on the axis Y
      int    j        = 0;                // Fill index

      Stat_t* errs    = new Stat_t[nBinX*nBinY];  // Array of bin errors
      int    ind      = 0;                        // Index of bin errors
      
      float x_mean  = xLow + (xHigh-xLow)/2.0;
      float y_mean  = yLow + (yHigh-yLow)/2.0;

      // Book the ROOT 2D histogram with fixed binning
      std::string full = pObject->fullpath();
      //      cdToPath(full);
      std::string dir = pObject->location();
      RootTrimLeadingDir(dir,"/stat");
      RootMkdir(dir);
      RootCd(dir);

      log << MSG::INFO << "creating hist id: " << histoID 
          << "  title: " << title << " in " << dir << endreq;

      TH2F *rhist = new TH2F(histoID.c_str(), title.c_str(),
                             nBinX, xLow, xHigh, nBinY, yLow, yHigh);


      // Fill it
      for ( ix = 0; ix < nBinX; ix++ )  {
        for ( iy = 0; iy < nBinY; iy++, ind++ )  {
          errs[ind] = h->binError(ix,iy);
          height = h->binHeight(ix,iy);
          if( 0 != height ) {
            centreX  = h->xAxis()->binCentre(ix);
            centreY  = h->yAxis()->binCentre(iy);
            entries = h->binEntries(ix,iy);
            weight  = height / entries;
            for( j = 0; j < entries; j++ ) {
              rhist->Fill(centreX, centreY, weight);
            }
          }
        }
      }

      rhist->SetError( errs );

      // Underflow and overflow bins
      // W
      entries          = h->binEntriesX( IHistogram::UNDERFLOW_BIN                            );
      height           = h->binHeightX ( IHistogram::UNDERFLOW_BIN                            );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_uflow,y_mean,weight);
      }
      // NW
      entries          = h->binEntries ( IHistogram::UNDERFLOW_BIN, IHistogram::OVERFLOW_BIN  );
      height           = h->binHeight  ( IHistogram::UNDERFLOW_BIN, IHistogram::OVERFLOW_BIN  );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_uflow, y_oflow, weight);
      }
      // N
      entries          = h->binEntriesY(                            IHistogram::OVERFLOW_BIN  );
      height           = h->binHeightY (                            IHistogram::OVERFLOW_BIN  );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_mean, y_oflow, weight);
      }
      // NE
      entries          = h->binEntries ( IHistogram::OVERFLOW_BIN,  IHistogram::OVERFLOW_BIN  );
      height           = h->binHeight  ( IHistogram::OVERFLOW_BIN,  IHistogram::OVERFLOW_BIN  );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_oflow, y_oflow, weight);
      }
      // E
      entries          = h->binEntriesX( IHistogram::OVERFLOW_BIN                             );
      height           = h->binHeightX ( IHistogram::OVERFLOW_BIN                             );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_oflow, y_mean, weight);
      }
      // SE
      entries          = h->binEntries ( IHistogram::OVERFLOW_BIN,  IHistogram::UNDERFLOW_BIN );
      height           = h->binHeight  ( IHistogram::OVERFLOW_BIN,  IHistogram::UNDERFLOW_BIN );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_oflow, y_uflow, weight);
      }
      // S
      entries          = h->binEntriesY(                            IHistogram::UNDERFLOW_BIN );
      height           = h->binHeightY (                            IHistogram::UNDERFLOW_BIN );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_mean, y_uflow, weight);
      }
      // SW
      entries          = h->binEntries ( IHistogram::UNDERFLOW_BIN, IHistogram::UNDERFLOW_BIN );
      height           = h->binHeight  ( IHistogram::UNDERFLOW_BIN, IHistogram::UNDERFLOW_BIN );
      weight  = height / entries;
      for( j = 0; j < entries; j++ ) {
        rhist->Fill(x_uflow, y_uflow, weight);
      }

      // HBOOK 2D histograms do not support mean and rms

      write(histoID, h, refpAddress);
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

  StatusCode H2DCnv::write(std::string /*histoID*/, IHistogram2D* h, IOpaqueAddress*& refpAddress)   {
    DataObject* pObject = dynamic_cast<DataObject*>(h);
    //    IDataDirectory* par = pObject->directory()->parent();
    std::string full(pObject->location());
    //    int icycle = 0;
    full.insert(0,"/");

    MsgStream log(msgSvc(), "RootHistCnv::H2DCnv");
//      log << MSG::DEBUG;
//      if( log.isActive() ) {
//        HPRINT(histoID);
//      }

    GenericAddress* addr = new GenericAddress(repSvcType() , objType());
    addr->setContainerName(full);
    addr->setObjectName(h->title());
    refpAddress = addr;
    return StatusCode::SUCCESS;
  }

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

}    // namespace RootHistCnv

---