In This Package:

SoHistogramCnv.cpp

Go to the documentation of this file.

// this :
#include "SoHistogramCnv.h"

// AIDA :
#include <AIDA/IHistogram1D.h>
#include <AIDA/IHistogram2D.h>

// Gaudi :
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/IService.h>
#include <GaudiKernel/MsgStream.h>
#include <GaudiKernel/CnvFactory.h>
#include <GaudiKernel/DataObject.h>

// OnXSvc :
#include <OnXSvc/IUserInterfaceSvc.h>
#include <OnXSvc/ClassID.h>

// RootSvc :
//#601 #include <RootSvc/IRootSvc.h>

// HEPVis :
#include <HEPVis/nodekits/SoPlotterRegion.h>
#include <HEPVis/nodekits/SoPlotter.h>

// OnX :
#include <OnX/Interfaces/IWidget.h>
#include <OnX/Interfaces/IWidgetClass.h>

#include <TVirtualPad.h>
#include <TH1D.h>
#include <TH2D.h>
#include "GaudiKernel/HistogramBase.h"

DECLARE_CONVERTER_FACTORY(SoHistogramCnv);

SoHistogramCnv::SoHistogramCnv(
 ISvcLocator* aSvcLoc
) 
:Converter(So_TechnologyType,CLID_Histogram,aSvcLoc) 
,fUISvc(0)
//#601,fRootSvc(0)
{
}
StatusCode SoHistogramCnv::initialize(
) 


{
  StatusCode status = Converter::initialize();
  if( status.isFailure() ) return status;

  MsgStream log(messageService(), "SoHistogramCnv");

  {if(fUISvc) {
    fUISvc->release();
    fUISvc = 0;
  }
  StatusCode status = service("OnXSvc",fUISvc,true);
  if(status.isFailure() || !fUISvc) {
    log << MSG::INFO << " OnXSvc not found " << endreq;
    return StatusCode::FAILURE;
  }  
  fUISvc->addRef();}

  return StatusCode::SUCCESS;
}
StatusCode SoHistogramCnv::finalize() 


{
  if(fUISvc) {
    fUISvc->release();
    fUISvc = 0;
  }
//#601  if(fRootSvc) {
//#601    fRootSvc->release();
//#601    fRootSvc = 0;
//#601  }
  return StatusCode::SUCCESS;
}
long SoHistogramCnv::repSvcType() const
{
  return i_repSvcType();
}
const CLID& SoHistogramCnv::classID(
) 


{ 
  return CLID_Histogram;
}
const unsigned char SoHistogramCnv::storageType(
) 


{ 
  return So_TechnologyType; 
}
StatusCode SoHistogramCnv::createRep(
 DataObject* aObject
,IOpaqueAddress*&
) 


{
  MsgStream log(messageService(), "SoHistogramCnv");
  log << MSG::INFO << "Histogram createReps" << endreq;

  if(!aObject) {
    log << MSG::INFO << " NULL object." << endreq;
    return StatusCode::FAILURE; 
  }

  if(!fUISvc) {
    log << MSG::INFO << " OnXSvc not found " << endreq;
    return StatusCode::FAILURE;
  }  

  IWidget* widget = fUISvc->currentWidget();
  if(!widget) {
    log << MSG::INFO << " can't get current widget." << endreq;
    return StatusCode::FAILURE; 
  }

  if(widget->widgetClass().name()=="PageViewer") {

    SoRegion* soRegion = fUISvc->currentSoRegion();
    if(!soRegion) {
      log << MSG::INFO << " can't get SoRegion." << endreq;
      return StatusCode::FAILURE; 
    }
    if(!soRegion->isOfType(SoPlotterRegion::getClassTypeId())) {
      log << MSG::INFO << " region is not a SoPlotterRegion." << endreq;
      return StatusCode::FAILURE; 
    }

    if(AIDA::IHistogram1D* histogram = 
       dynamic_cast<AIDA::IHistogram1D*>(aObject)) {
      SbPlottableObject* sbPlottable =  
        new SoHistogramRep1D(aObject->name(),histogram);
      soRegion->doIt(SbPlotterDoIt(sbPlottable));
  
    } else if(AIDA::IHistogram2D* histogram = 
              dynamic_cast<AIDA::IHistogram2D*>(aObject)) {
      SbPlottableObject* sbPlottable =  
        new SoHistogramRep2D(aObject->name(),histogram);
      soRegion->doIt(SbPlotterDoIt(sbPlottable));
  
    } else {
      log << MSG::INFO 
          << " today only plotting of AIDA::IHistogram1D,2D supported." 
          << endreq;
      return StatusCode::FAILURE; 
    }

  } else if(widget->widgetClass().name()=="TCanvas") {

//#601    if(!fRootSvc) {
//#601      StatusCode status = service("RootSvc",fRootSvc,true);
//#601      if(status.isFailure()  || !fRootSvc) {
//#601        log << MSG::INFO << " OnXSvc not found " << endreq;
//#601        return StatusCode::SUCCESS; //Not fatal.
//#601      }
//#601      fRootSvc->addRef();
//#601    }

    if(AIDA::IHistogram* histogram = 
       dynamic_cast<AIDA::IHistogram*>(aObject)) {
  
//#601      fRootSvc->visualize(*histogram);

    } else {
      log << MSG::INFO 
          << " object not an AIDA::IHistogram." 
          << endreq;
      return StatusCode::FAILURE; 
    }

  } else {
    log << MSG::INFO 
        << " viewer not a PageViewer or a TCanvas." 
        << endreq;
    return StatusCode::FAILURE; 
  }

  return StatusCode::SUCCESS;
}
// AIDA :
#include <AIDA/IHistogram1D.h>
#include <AIDA/IHistogram2D.h>
#include <AIDA/IAxis.h>
#include <AIDA/IAnnotation.h>

// HEPVis :
#include <HEPVis/SbPlottableThings.h>

// Lib:
#include <Lib/smanip.h>

SoHistogramRep1D::SoHistogramRep1D(
 const std::string& aName
,const AIDA::IHistogram1D* aHistogram
)
:fName(aName)
,fHistogram(aHistogram)
,fDataClass("AIDA::IHistogram1D")
{
}
SoHistogramRep1D::~SoHistogramRep1D(
)
{
}
bool SoHistogramRep1D::isValid(
) const
{
  return true;
}
const char* SoHistogramRep1D::getName(
)
{
  return fName.c_str();
}
const char* SoHistogramRep1D::getLabel(
)
{
  fTitle = fHistogram->title(); 
  return fTitle.c_str(); 
}
int SoHistogramRep1D::getDimension(
) const
{
  return fHistogram->dimension();
}
void* SoHistogramRep1D::cast(
 const char* aClass
) const
{
  if(std::string(aClass)=="SbPlottableObject") {
    return (SbPlottableObject*)this;
  } else if(std::string(aClass)=="SbPlottableBins1D") {
    return (SbPlottableBins1D*)this;
  } else {
    return 0;
  }
}
void* SoHistogramRep1D::nativeObject(
) const
{
  return (void*)fHistogram; 
}
const char* SoHistogramRep1D::nativeObjectClass(
) const
{
  return fDataClass.c_str(); 
}
int SoHistogramRep1D::getAxisNumberOfBins(
) const
{
  return fHistogram->axis().bins();
}
float SoHistogramRep1D::getAxisMinimum(
) const
{
  return (float)fHistogram->axis().lowerEdge();
}
float SoHistogramRep1D::getAxisMaximum(
) const
{
  return (float)fHistogram->axis().upperEdge();
}
void SoHistogramRep1D::getBinsSumOfWeightsRange(
 float& aMin
,float& aMax
) const
{
  aMin = (float)fHistogram->minBinHeight();
  aMax = (float)fHistogram->maxBinHeight();
}
int SoHistogramRep1D::getBinNumberOfEntries(
 int aI
) const
{
  return fHistogram->binEntries(aI);
}
float SoHistogramRep1D::getBinLowerEdge(
 int aI
) const
{
  return (float)fHistogram->axis().binLowerEdge(aI);
}
float SoHistogramRep1D::getBinUpperEdge(
 int aI
) const
{
  return (float)fHistogram->axis().binUpperEdge(aI);
}
float SoHistogramRep1D::getBinSumOfWeights(
 int aI
) const
{
  return (float)fHistogram->binHeight(aI);
}
float SoHistogramRep1D::getBinBar(
 int aI
) const
{
  return (float)fHistogram->binError(aI);
}
const char* SoHistogramRep1D::getInfos(
 const char* /* aOptions */
)
{
  Lib::smanip::printf(fInfos,6 * 64,
"\
N %d\n\
I %d\n\
m %g\n\
r %g\n\
u %d\n\
o %d",fHistogram->allEntries()
     ,fHistogram->entries()
     ,fHistogram->mean()
     ,fHistogram->rms()
     ,fHistogram->binEntries(AIDA::IAxis::UNDERFLOW_BIN)
     ,fHistogram->binEntries(AIDA::IAxis::OVERFLOW_BIN));
  return fInfos.c_str();
}
const char* SoHistogramRep1D::getLegend(
)
{
  fLegend = fHistogram->annotation().value("Legend");
  return fLegend.c_str();
}
SoHistogramRep2D::SoHistogramRep2D(
 const std::string& aName
,const AIDA::IHistogram2D* aHistogram
)
:fName(aName)
,fHistogram(aHistogram)
,fDataClass("AIDA::IHistogram2D")
{
}
SoHistogramRep2D::~SoHistogramRep2D(
)
{
}
bool SoHistogramRep2D::isValid(
) const
{
  return true;
}
const char* SoHistogramRep2D::getName(
)
{
  return fName.c_str();
}
const char* SoHistogramRep2D::getLabel(
)
{
  fTitle = fHistogram->title(); 
  return fTitle.c_str(); 
}
int SoHistogramRep2D::getDimension(
) const
{
  return fHistogram->dimension();
}
void* SoHistogramRep2D::nativeObject(
) const
{
  return (void*)fHistogram; 
}
const char* SoHistogramRep2D::nativeObjectClass(
) const
{
  return fDataClass.c_str(); 
}
void* SoHistogramRep2D::cast(
 const char* aClass
) const
{
  if(std::string(aClass)=="SbPlottableObject") {
    return (SbPlottableObject*)this;
  } else if(std::string(aClass)=="SbPlottableBins2D") {
    return (SbPlottableBins2D*)this;
  } else {
    return 0;
  }
}
int SoHistogramRep2D::getAxisNumberOfBinsX(
) const
{
  return fHistogram->xAxis().bins();
}
float SoHistogramRep2D::getAxisMinimumX(
) const
{
  return (float)fHistogram->xAxis().lowerEdge();
}
float SoHistogramRep2D::getAxisMaximumX(
) const
{
  return (float)fHistogram->xAxis().upperEdge();
}
int SoHistogramRep2D::getAxisNumberOfBinsY(
) const
{
  return fHistogram->yAxis().bins();
}
float SoHistogramRep2D::getAxisMinimumY(
) const
{
  return (float)fHistogram->yAxis().lowerEdge();
}
float SoHistogramRep2D::getAxisMaximumY(
) const
{
  return (float)fHistogram->yAxis().upperEdge();
}
void SoHistogramRep2D::getBinsSumOfWeightsRange(
 float& aMin
,float& aMax
) const
{
  aMin = (float)fHistogram->minBinHeight();
  aMax = (float)fHistogram->maxBinHeight();
}
int SoHistogramRep2D::getBinNumberOfEntries(
 int aI
,int aJ
) const
{
  return fHistogram->binEntries(aI,aJ);
}
float SoHistogramRep2D::getBinLowerEdgeX(
 int aI
) const
{
  return (float)fHistogram->xAxis().binLowerEdge(aI);
}
float SoHistogramRep2D::getBinUpperEdgeX(
 int aI
) const
{
  return (float)fHistogram->xAxis().binUpperEdge(aI);
}
float SoHistogramRep2D::getBinLowerEdgeY(
 int aJ
) const
{
  return (float)fHistogram->yAxis().binLowerEdge(aJ);
}
float SoHistogramRep2D::getBinUpperEdgeY(
 int aJ
) const
{
  return (float)fHistogram->yAxis().binUpperEdge(aJ);
}
float SoHistogramRep2D::getBinSumOfWeights(
 int aI
,int aJ
) const
{
  return (float)fHistogram->binHeight(aI,aJ);
}
float SoHistogramRep2D::getBinBar(
 int aI
,int aJ
) const
{
  return (float)fHistogram->binError(aI,aJ);
}
const char* SoHistogramRep2D::getInfos(
 const char* /* aOptions */
)
{
  Lib::smanip::printf(fInfos,5 * 64,
"\
I %d\n\
mx %g\n\
rx %g\n\
my %g\n\
ry %g",fHistogram->entries()
       ,fHistogram->meanX()
       ,fHistogram->rmsX()
       ,fHistogram->meanY()
       ,fHistogram->rmsY());
  return fInfos.c_str();
}
const char* SoHistogramRep2D::getLegend(
)
{
  fLegend = fHistogram->annotation().value("Legend");
  return fLegend.c_str();
}

---