RootEsTimeCalibDataCnv.cxx

Go to the documentation of this file.

#include "RootEsTimeCalibDataCnv.h"
#include "CalibData/EsTime/EsTimeCalibData.h"
#include "CalibDataSvc/IInstrumentName.h"
#include "GaudiKernel/MsgStream.h"
 
#include "TDirectory.h"
#include "TFile.h"
#include "TObject.h"
#include "TTree.h"
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
 
#include "CalibDataSvc/ICalibMetaCnvSvc.h"
#include "CalibDataSvc/ICalibRootSvc.h" //maybe
 
// Temporary.  Hope to find a better way to do this
#include "CalibData/CalibModel.h"
using namespace CalibData;
// static CnvFactory<RootEsTimeCalibDataCnv> EsTimeCal_factory;
// const  ICnvFactory& RootEsTimeCalibDataCnvFactory = EsTimeCal_factory;
 
RootEsTimeCalibDataCnv::RootEsTimeCalibDataCnv( ISvcLocator* svc )
    : RootCalBaseCnv( svc, CLID_Calib_EsTimeCal ) {}
 
const CLID& RootEsTimeCalibDataCnv::objType() const { return CLID_Calib_EsTimeCal; }
 
const CLID& RootEsTimeCalibDataCnv::classID() { return CLID_Calib_EsTimeCal; }
 
StatusCode RootEsTimeCalibDataCnv::i_createObj( const std::string& fname,
                                                DataObject*&       refpObject ) {
 
  MsgStream log( msgSvc(), "RootEsTimeCalibDataCnv" );
  log << MSG::DEBUG << "SetProperty" << endmsg;
 
  StatusCode sc = openRead( fname );
  if ( !sc ) { log << MSG::ERROR << "unable to open files" << endmsg; }
 
  CalibData::EsTimeCalibData* tmpObject = new CalibData::EsTimeCalibData;
  // Read in our object
  int i;
  int nentries;
 
  // read TestCalibConst ------------------------------------------------------------
 
  int            no;
  double         EsTimeCalibConst;
  vector<double> TestCalibConst;
  if ( m_inFile->Read( "h2" ) )
  {
    TTree* Testtree = (TTree*)m_inFile->Get( "h2" );
    Testtree->SetBranchAddress( "meant0", &EsTimeCalibConst );
 
    no = Testtree->GetEntries();
    for ( i = 0; i < no; i++ )
    {
      Testtree->GetEntry( i );
      TestCalibConst.push_back( EsTimeCalibConst );
    }
  }
 
  double t0offsete, t0offsetb;
  int    bunchtime, runFrom, runTo, eventFrom, eventTo;
  TTree* tree2 = (TTree*)m_inFile->Get( "calibconst" );
  tree2->SetBranchAddress( "t0offsete", &t0offsete );
  tree2->SetBranchAddress( "t0offsetb", &t0offsetb );
  tree2->SetBranchAddress( "bunchtime", &bunchtime );
  if ( tree2->GetBranchStatus( "runFrom" ) )
  {
    tree2->SetBranchAddress( "runFrom", &runFrom );
    tree2->SetBranchAddress( "runTo", &runTo );
    tree2->SetBranchAddress( "eventFrom", &eventFrom );
    tree2->SetBranchAddress( "eventTo", &eventTo );
  }
  else
  {
    runFrom   = -1;
    runTo     = -1;
    eventFrom = -1;
    eventTo   = -1;
  }
 
  no = tree2->GetEntries();
  for ( i = 0; i < no; i++ )
  {
    tree2->GetEntry( i );
    tmpObject->setToffsetb( t0offsetb );
    tmpObject->setToffsete( t0offsete );
    tmpObject->setBunchTime( bunchtime );
    tmpObject->setRunFrom( runFrom );
    tmpObject->setRunTo( runTo );
    tmpObject->setEventFrom( eventFrom );
    tmpObject->setEventTo( eventTo );
  }
 
  tmpObject->setTestCalibConst( &TestCalibConst );
  refpObject = tmpObject;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RootEsTimeCalibDataCnv::createRoot( const std::string&     fname,
                                               CalibData::CalibBase1* pTDSObj ) {
 
  MsgStream log( msgSvc(), "RootEsTimeCalibDataCnv" );
 
  // Open the file, create the branch
  StatusCode sc = openWrite( fname );
  if ( !sc ) { log << MSG::ERROR << "unable to open files" << endmsg; }
  // write the Data in the TCDS to RootFile
  /*    CalibData::EsTimeCalibData* tmpObject =
     dynamic_cast<CalibData::EsTimeCalibData*>(pTDSObj); int tmpNo; double EsTimeCalibConst;
      int i;
 
      //TestCalibConst------------------------------------------------------------------
      TTree *Testtree = new TTree("TestCalibConst", "TestCalibConst");
      Testtree -> Branch("TestCalibConst", &EsTimeCalibConst, "EsTimeCalibConst/D");
      tmpNo = tmpObject -> getTestCalibConstNo();
      for(i=0; i<tmpNo; i++){
           EsTimeCalibConst = tmpObject -> getTestCalibConst(i);
           Testtree -> Fill();
      }
 
 
      Testtree -> Write();
 
 
      delete Testtree;
 
      closeWrite();*/
  log << MSG::INFO << "successfully create RootFile" << endmsg;
  return sc;
}