RootMdcCalibDataCnv Class Reference

#include <RootMdcCalibDataCnv.h>

Inheritance diagram for RootMdcCalibDataCnv:

List of all members.

Public Types
typedef Ty2	destination
typedef Ty2	destination
typedef Ty1	source
typedef Ty1	source
Public Member Functions
virtual StatusCode	createObj (IOpaqueAddress *addr, DataObject *&refpObject)
virtual StatusCode	createRoot (const std::string &fname, CalibData::CalibBase1 *pTDSObj)
virtual StatusCode	finalize ()
ICalibRootSvc *	getCalibRootSvc ()
virtual StatusCode	initialize ()
const CLID &	objType () const
destination *	operator (const source &) const
destination *	operator (const source &) const
virtual StatusCode	readRootObj (TTree *tree, const std::string &branch, TObject *&pCalib, unsigned index=0)
virtual StatusCode	readRootObj (const std::string &treename, const std::string &branch, TObject *&pCalib, unsigned index=0)
virtual long	repSvcType () const
	RootMdcCalibDataCnv (ISvcLocator *svc)
virtual	~RootMdcCalibDataCnv ()
Static Public Member Functions
const CLID &	classID ()
const unsigned char	storageType ()
Protected Member Functions
StatusCode	closeRead ()
StatusCode	closeWrite ()
virtual destination *	convert (const source &) const =0
virtual destination *	convert (const source &) const =0
virtual StatusCode	fillRoot (CalibData::CalibBase *pTDSObj, TObject *pRootObj)
virtual StatusCode	i_createObj (const std::string &fname, DataObject *&refpObject)
virtual StatusCode	i_processObj (DataObject *pObject, IOpaqueAddress *address)
	In case there is additional work to do on the created object.
virtual StatusCode	internalCreateObj (const std::string &fname, DataObject *&refpObject, IOpaqueAddress *address)
StatusCode	openRead (const std::string &fname)
virtual StatusCode	openWrite (const std::string &fname)
void	setBaseInfo (CalibData::CalibBase1 *pObj)
	Another utility for derived classes to use.
Protected Attributes
TFile *	m_inFile
IInstrumentName *	m_instrSvc
ICalibMetaCnvSvc *	m_metaSvc
TFile *	m_outFile
ICalibRootSvc *	m_rootSvc
int	m_runfrm
int	m_runto
TDirectory *	m_saveDir
int	m_serNo
TTree *	m_ttree
ITime *	m_vend
ITime *	m_vstart
Friends
class	CnvFactory<RootMdcCalibDataCnv>

---

Detailed Description

Base class for CAL calibration converters from ROOT files to TCDS. All such converters need to do certain things, which are handled here. Methods common to *all* calibrations are in the base class RootCalBaseCnv

Author:

J. Bogart

---

Member Typedef Documentation

template<class Ty1, class Ty2> typedef Ty2 Converter< Ty1, Ty2 >::destination [inherited]

template<class Ty1, class Ty2> typedef Ty2 Converter< Ty1, Ty2 >::destination [inherited]

template<class Ty1, class Ty2> typedef Ty1 Converter< Ty1, Ty2 >::source [inherited]

template<class Ty1, class Ty2> typedef Ty1 Converter< Ty1, Ty2 >::source [inherited]

---

Constructor & Destructor Documentation

RootMdcCalibDataCnv::RootMdcCalibDataCnv (  ISvcLocator *  svc  )

: RootCalBaseCnv(svc, CLID_Calib_MdcCal) { }

virtual RootMdcCalibDataCnv::~RootMdcCalibDataCnv (   )  [inline, virtual]

{};

---

Member Function Documentation

const CLID & RootMdcCalibDataCnv::classID (   )  [static]

{ return CLID_Calib_MdcCal; }

StatusCode RootCalBaseCnv::closeRead (   )  [protected, inherited]

Clean up when we've finished reading in { m_inFile->Close(); delete m_inFile; m_inFile = 0; if (m_saveDir) { m_saveDir->cd(); m_saveDir = 0; } return StatusCode::SUCCESS; }

StatusCode RootCalBaseCnv::closeWrite (   )  [protected, inherited]

Finish up writing file opened with openWrite: fill the tree write the file close the file Delete TFile (causes associated Tree to be deleted) { MsgStream log(msgSvc(), "RootCalBaseCnv"); StatusCode ret = StatusCode::SUCCESS; m_outFile->cd(); m_outFile->Close(); delete m_outFile; m_outFile = 0; if (m_saveDir) m_saveDir->cd(); m_saveDir = 0; return ret; }

template<class Ty1, class Ty2> virtual destination* Converter< Ty1, Ty2 >::convert (  const source &   )  const [protected, pure virtual, inherited]

template<class Ty1, class Ty2> virtual destination* Converter< Ty1, Ty2 >::convert (  const source &   )  const [protected, pure virtual, inherited]

StatusCode RootCalBaseCnv::createObj (  IOpaqueAddress *  addr, DataObject *&  refpObject )  [virtual, inherited]

Create the transient representation of an object, given an opaque address. This and the following update method comprise the core functionality of calibration converters. { // StatusCode ret; // first do the things we always need: // First string parameter of opaque address is file ident MsgStream log(msgSvc(), "RootCalBaseCnv"); log << MSG::DEBUG<<"RootCalBaseCnv::createObj( starting ...."<<endreq; const std::string* par = addr->par(); std::string par0 = par[0]; return internalCreateObj(par0, refpObject, addr); }

StatusCode RootMdcCalibDataCnv::createRoot (  const std::string &  fname, CalibData::CalibBase1 *  pTDSObj )  [virtual]

Create ROOT file corresponding to TDS object input. Default implementation is to return an error. Must be separately implemented for each calibration type. Parameters: fname  Filename for output file pTDSObj  Pointer to tds object to be converted Reimplemented from RootCalBaseCnv. { MsgStream log(msgSvc(), "RootMdcCalibDataCnv"); // Open the file, create the branch StatusCode sc = openWrite(fname); if(!sc) { log<<MSG::ERROR<<"unable to open files"<<endreq; } // write the Data in the TCDS to RootFile CalibData::MdcCalibData* tmpObject = dynamic_cast<CalibData::MdcCalibData*>(pTDSObj); int tmpNo; int key; double xtpar; double t0; double delt0; double qtpar[2]; double sdpar; int i; //xttree------------------------------------------------------------------ TTree *xttree = new TTree("XtTree", "XtTree"); xttree -> Branch("xtkey", &key, "key/I"); xttree -> Branch("xtpar", &xtpar, "xtpar/D"); tmpObject -> setXtBegin(); while( tmpObject -> getNextXtpar(key, xtpar) ){ xttree -> Fill(); } //t0tree------------------------------------------------------------------- TTree *t0tree = new TTree("T0Tree", "T0Tree"); t0tree -> Branch("t0", &t0, "t0/D"); t0tree -> Branch("delt0", &delt0, "delt0/D"); tmpNo = tmpObject -> gett0No(); for(i=0; i<tmpNo; i++){ t0 = tmpObject -> getT0(i); delt0 = tmpObject -> getDelT0(i); t0tree -> Fill(); } //qttree-------------------------------------------------------------------- TTree *qttree = new TTree("QtTree", "QtTree"); qttree -> Branch("qtpar0", &(qtpar[0]), "qtpar0/D"); qttree -> Branch("qtpar1", &(qtpar[1]), "qtpar1/D"); tmpNo = tmpObject -> getqtparNo(); for(i=0; i<tmpNo; i++){ qtpar[0] = tmpObject -> getQtpar0(i); qtpar[1] = tmpObject -> getQtpar1(i); qttree -> Fill(); } //sdtree-------------------------------------------------------------------- TTree *sdtree = new TTree("SdTree", "SdTree"); sdtree -> Branch("sdkey", &key, "key/I"); sdtree -> Branch("sdpar", &sdpar, "sdpar/D"); tmpObject -> setSdBegin(); while( tmpObject -> getNextSdpar(key, sdpar) ){ sdtree -> Fill(); } xttree -> Write(); t0tree -> Write(); qttree -> Write(); sdtree -> Write(); delete xttree; delete t0tree; delete qttree; delete sdtree; closeWrite(); log<<MSG::INFO<<"successfully create RootFile"<<endreq; return sc; }

StatusCode RootCalBaseCnv::fillRoot (  CalibData::CalibBase *  pTDSObj, TObject *  pRootObj )  [protected, virtual, inherited]

Given a pointer to a TDS object which can be cast to "our" type, fill in corresponding information in the corresponding root class Parameters: pTDSObj  Pointer to tds object to be converted pRootObj  Pointer to destination root object ...maybe don't need pRootObj argument; keep this as the (protected) data member m_rootObj. Or else this routine could set the protected member to this passed-in value { // Get instrument name from InstrumentName service Now handled by // RootCalBaseCnv // TString instr = TString((m_instrSvc->getInstrumentName()).c_str()); // pRootObj->setInstrument(instr); return StatusCode::SUCCESS; }

StatusCode RootCalBaseCnv::finalize (   )  [virtual, inherited]

{ return Converter::finalize(); }

ICalibRootSvc* RootCalBaseCnv::getCalibRootSvc (   )  [inline, inherited]

{ return m_rootSvc; }

StatusCode RootMdcCalibDataCnv::i_createObj (  const std::string &  fname, DataObject *&  refpObject )  [protected, virtual]

This creates the transient representation of an object from the corresponding ROOT object. This actually does the "new" operation and deals with the attributes of the node. This base class implementation does nothing; it should not normally be called because it doesn't correspond to any TCDS class. Instead, i_createObj of some derived class will be called. Parameters: fname  The ROOT file to be read in to be used to builds the object refpObject  the object to be built Returns: status depending on the completion of the call Reimplemented from RootCalBaseCnv. { MsgStream log(msgSvc(), "RootMdcCalibDataCnv"); log<<MSG::DEBUG<<"SetProperty"<<endreq; StatusCode sc = openRead(fname); if(!sc) { log<<MSG::ERROR<<"unable to open files"<<endreq; } CalibData::MdcCalibData *tmpObject = new CalibData::MdcCalibData ; // Read in our object int i; int nentries; // read xttree ------------------------------------------------------------ double xtpar; int xtkey; TTree *xttree = (TTree*)m_inFile -> Get("XtTree"); xttree -> SetBranchAddress("xtpar", &xtpar); xttree -> SetBranchAddress("xtkey", &xtkey); nentries = xttree -> GetEntries(); for(i=0; i<nentries; i++){ xttree -> GetEntry(i); tmpObject -> setXtpar(xtkey,xtpar); } // read t0tree ------------------------------------------------------------ double t0; double delt0; TTree *t0tree = (TTree*)m_inFile -> Get("T0Tree"); t0tree -> SetBranchAddress("t0", &t0); t0tree -> SetBranchAddress("delt0", &delt0); nentries = t0tree -> GetEntries(); for(i=0; i<nentries; i++){ t0tree -> GetEntry(i); tmpObject -> setT0(t0); tmpObject -> setDelT0(delt0); } // read qttree ------------------------------------------------------------ double qtpar0; double qtpar1; TTree *qttree = (TTree*)m_inFile -> Get("QtTree"); qttree -> SetBranchAddress("qtpar0", &qtpar0); qttree -> SetBranchAddress("qtpar1", &qtpar1); nentries = qttree -> GetEntries(); for(i=0; i<nentries; i++){ qttree -> GetEntry(i); tmpObject -> setQtpar0(qtpar0); tmpObject -> setQtpar1(qtpar1); } // read Sdtree --------------------------------------------------------- double sdpar; int sdkey; TTree *sdtree = (TTree*)m_inFile -> Get("SdTree"); sdtree -> SetBranchAddress("sdpar", &sdpar); sdtree -> SetBranchAddress("sdkey", &sdkey); nentries = sdtree -> GetEntries(); for(i=0; i<nentries; i++){ sdtree -> GetEntry(i); tmpObject -> setSdpar(sdkey,sdpar); } refpObject=tmpObject; return StatusCode::SUCCESS; }

StatusCode RootCalBaseCnv::i_processObj (  DataObject *  pObject, IOpaqueAddress *  address )  [protected, virtual, inherited]

In case there is additional work to do on the created object. { return StatusCode::SUCCESS; }

StatusCode RootCalBaseCnv::initialize (   )  [virtual, inherited]

{ StatusCode status = Converter::initialize(); IDataProviderSvc* dp; // I guess the service names are assigned in jobOptions? serviceLocator()->getService ("CalibDataSvc", IID_IDataProviderSvc, (IInterface*&)dp); setDataProvider(dp); // Locate the Root Conversion Service serviceLocator()->getService ("CalibRootCnvSvc", IID_ICalibRootSvc, (IInterface*&) m_rootSvc); // Locate meta conversion service // Will anything need to be changed here to accommodate possibility // of two concrete implementations of ICalibMetaCnvSvc? Would // have different storage types. Could specify type desired // as job option. Ditto for name of class? serviceLocator()->getService("CalibMySQLCnvSvc", IID_ICalibMetaCnvSvc, (IInterface*&)m_metaSvc); serviceLocator()->getService ("CalibDataSvc", IID_IInstrumentName, (IInterface*&)m_instrSvc); return status; }

StatusCode RootCalBaseCnv::internalCreateObj (  const std::string &  fname, DataObject *&  refpObject, IOpaqueAddress *  address )  [protected, virtual, inherited]

This creates the transient representation of an object from the corresponding ROOT object it, then fills it and process it. This implementation actually only calls the i_* methods of the "right" converter to do the job; so the very first thing it does is get a pointer to the appropriate derived converter. Converters typically don't need to override this method but only to override/implement some of the i_* methods. Parameters: pRootObj  pointer to the ROOT object refpObject  the object to be built address  the opaque address for this object Returns: status depending on the completion of the call { MsgStream log(msgSvc(), "RootCalBaseCnv"); log << MSG::DEBUG<<"RootCalBaseCnv::internalCreateObj( starting ..... "<<endreq; RootCalBaseCnv* converter = this; CLID classId = address->clID(); IConverter* conv = this->conversionSvc()->converter(classId); if (0 == conv) { log << MSG::WARNING << "No proper converter found for classID " << classId << ", the default converter" << " will be used. " << endreq; } else { converter = dynamic_cast <RootCalBaseCnv*> (conv); if (0 == converter) { log << MSG::ERROR << "The converter found for classID " << classId << " was not a descendent of RootCalBaseCnv as it should be " << "( was of type " << typeid (*converter).name() << "). " << "The default converter will be used" << endreq; converter = this; } } m_runfrm =*( address->ipar()); m_runto =*( address->ipar()+1); // creates an object for the node found StatusCode sc = converter->i_createObj(fname, refpObject); if (sc.isFailure()) { return sc; } CalibData::CalibBase1* tmpObject = dynamic_cast <CalibData::CalibBase1*> (refpObject); setBaseInfo(tmpObject); // ends up the object construction sc = converter->i_processObj(refpObject, address); if (sc.isSuccess()) { log << MSG::DEBUG << "Successfully created calib. object " << endreq; } closeRead(); return sc; }

const CLID & RootMdcCalibDataCnv::objType (   )  const

{ return CLID_Calib_MdcCal; }

StatusCode RootCalBaseCnv::openRead (  const std::string &  fname  )  [protected, inherited]

Utility for "leaf" converters to call Parameters: Root  file to open for read Name  of branch to be read in ref.  to pCalib pointer which will be set to address of read-in object { MsgStream log(msgSvc(), "RootCalBaseCnv"); // Check fname isn't empty if (fname == std::string("")) return StatusCode::FAILURE; if (doClean() ) { log << MSG::WARNING << "Previous operation didn't clean up! " << endreq; } m_saveDir = gDirectory; std::string ourName(fname); facilities::Util::expandEnvVar(&ourName); m_inFile = new TFile(ourName.c_str()); if (!m_inFile->IsOpen() ) { log << MSG::ERROR << "ROOT file " << ourName << "could not be opened for reading " << endreq; delete m_inFile; m_inFile = 0; return StatusCode::FAILURE; } else { log << MSG::INFO << "Successfully opened ROOT file " << fname << " aka " << ourName << " for reading " << endreq; } m_inFile->cd(); // Maybe will need this return StatusCode::SUCCESS; }

StatusCode RootCalBaseCnv::openWrite (  const std::string &  fname  )  [protected, virtual, inherited]

Utility used by derived converters to start writing a ROOT file (open TFile, make a TTree, give it a branch) Parameters: fname  Name for new file className  Name of class for object specified in next parameter; used to name branch as well) pCalib  pointer to object used to create the branch { MsgStream log(msgSvc(), "RootCalBaseCnv"); // Check fname isn't empty if (fname == std::string("")) return StatusCode::FAILURE; std::string ourName(fname); facilities::Util::expandEnvVar(&ourName); if (doClean() ) { log << MSG::WARNING << "Previous operation didn't clean up! " << endreq; } m_saveDir = gDirectory; m_outFile = new TFile(ourName.c_str(), "RECREATE"); if (!m_outFile->IsOpen()) { log << MSG::ERROR << "ROOT file " << fname << " aka " << ourName << " could not be opened for writing" << endreq; delete m_outFile; m_outFile = 0; return StatusCode::FAILURE; } else { log << MSG::INFO << "Successfully opened ROOT file " << fname << " aka " << ourName << " for writing " << endreq; } m_outFile->cd(); return StatusCode::SUCCESS; }

template<class Ty1, class Ty2> destination* Converter< Ty1, Ty2 >::operator (  const source &   )  const [inline, inherited]

template<class Ty1, class Ty2> destination* Converter< Ty1, Ty2 >::operator (  const source &   )  const [inline, inherited]

StatusCode RootCalBaseCnv::readRootObj (  TTree *  tree, const std::string &  branch, TObject *&  pCalib, unsigned  index = 0 )  [virtual, inherited]

{ TBranch* pBranch=pTree->GetBranch(branch.c_str()); pBranch->SetAddress(&pObj); int nBytes = pBranch->GetEntry(ix); return (nBytes > 0) ? StatusCode::SUCCESS : StatusCode::FAILURE; }

StatusCode RootCalBaseCnv::readRootObj (  const std::string &  treename, const std::string &  branch, TObject *&  pCalib, unsigned  index = 0 )  [virtual, inherited]

Read in object (by default the first) from specified branch. { TTree* pTree = (TTree*)m_inFile->Get(treename.c_str()); return readRootObj(pTree, branch, pObj, ix); }

virtual long RootMdcCalibDataCnv::repSvcType (   )  const [inline, virtual]

{ return CALIBROOT_StorageType; }

void RootCalBaseCnv::setBaseInfo (  CalibData::CalibBase1 *  pObj  )  [protected, inherited]

Another utility for derived classes to use. Another convenience for derived classes: sets information belonging to the calibration base class, namely validity interval and serial number. { MsgStream log(msgSvc(), "RootCalBaseCnv"); log << MSG::DEBUG<<"set the runfrm and runto Numbers in the converter"<<endreq; pObj->setrunfrm(m_runfrm); pObj->setrunto(m_runto); }

const unsigned char RootCalBaseCnv::storageType (   )  [inline, static, inherited]

{return CALIBROOT_StorageType;}

---

Friends And Related Function Documentation

friend class CnvFactory<RootMdcCalibDataCnv> [friend]

---

Member Data Documentation

TFile* RootCalBaseCnv::m_inFile [protected, inherited]

IInstrumentName* RootCalBaseCnv::m_instrSvc [protected, inherited]

ICalibMetaCnvSvc* RootCalBaseCnv::m_metaSvc [protected, inherited]

TFile* RootCalBaseCnv::m_outFile [protected, inherited]

ICalibRootSvc* RootCalBaseCnv::m_rootSvc [protected, inherited]

int RootCalBaseCnv::m_runfrm [protected, inherited]

int RootCalBaseCnv::m_runto [protected, inherited]

TDirectory* RootCalBaseCnv::m_saveDir [protected, inherited]

int RootCalBaseCnv::m_serNo [protected, inherited]

TTree* RootCalBaseCnv::m_ttree [protected, inherited]

ITime* RootCalBaseCnv::m_vend [protected, inherited]

ITime* RootCalBaseCnv::m_vstart [protected, inherited]

---

The documentation for this class was generated from the following files:

• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Calibration/CalibSvc/CalibROOTCnv/CalibROOTCnv-00-00-45/src/cnv/RootMdcCalibDataCnv.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Calibration/CalibSvc/CalibROOTCnv/CalibROOTCnv-00-00-45/src/cnv/RootMdcCalibDataCnv.cxx

---