RootEstTofCalibDataCnv Class Reference

#include <RootEstTofCalibDataCnv.h>

Inheritance diagram for RootEstTofCalibDataCnv:

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
	RootEstTofCalibDataCnv (ISvcLocator *svc)
virtual	~RootEstTofCalibDataCnv ()
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<RootEstTofCalibDataCnv>

---

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

RootEstTofCalibDataCnv::RootEstTofCalibDataCnv (  ISvcLocator *  svc  )

: RootCalBaseCnv(svc, CLID_Calib_EstTofCal) { }

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

{};

---

Member Function Documentation

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

{ return CLID_Calib_EstTofCal; }

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 RootEstTofCalibDataCnv::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(), "RootEstTofCalibDataCnv"); // 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::TofCalibData* btof = dynamic_cast<CalibData::TofCalibData*>(pTDSObj); // write btoftree---------------------------------------------------------------- double cnvBarPar1[nBarPar]; double cnvBarPar2[nBarPar]; char brname[8], ibrname[8]; TTree *btoftree = new TTree("BarTofPar", "BarTofPar"); for( unsigned int i=0; i<nBarPar; i++ ) { sprintf( brname, "P%i", i ); sprintf( ibrname, "P%i/D", i ); btoftree -> Branch( brname, &cnvBarPar1[i], ibrname ); } for( int i=0; i<176; i++ ) { for( int j=0;j<static_cast<int>(nBarPar);j++){ cnvBarPar1[j] = btof->getBTofPleft(i,j); cnvBarPar2[j] = btof->getBTofPright(i,j); } btoftree -> Fill(); } //write etoftree---------------------------------------------------------------- double cnvEndPar[nEndPar]; char ecname[8], iecname[8]; TTree *etoftree = new TTree("EndTofPar", "EndTofPar"); for( unsigned int i=0; i<nEndPar; i++ ) { sprintf( ecname, "P%i", i ); sprintf( iecname, "P%i/D", i ); etoftree -> Branch( ecname, &cnvEndPar[i], iecname ); } for(int i=0; i<96; i++){ for(int j=0;j<static_cast<int>(nEndPar);j++){ cnvEndPar[j] = btof->getETofP(i,j); } etoftree->Fill(); } // write all the trees btoftree -> Write(); etoftree -> Write(); delete btoftree; delete etoftree; 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 RootEstTofCalibDataCnv::i_createObj (  const std::string &  fname, DataObject *&  refpObject )  [protected, virtual]

Read in object from specified branch. Don't need tree name; it's always Calib Reimplemented from RootCalBaseCnv. { MsgStream log(msgSvc(), "RootEstTofCalibDataCnv"); log<<MSG::DEBUG<<"SetProperty"<<endreq; // open the file StatusCode sc = openRead(fname); if(!sc) { log<<MSG::ERROR<<"unable to open files"<<endreq; } CalibData::bTofCalibBase bTof; CalibData::eTofCalibBase eTof; CalibData::bTofCommonCalibBase bTofCommon; CalibData::tofCalibInfoBase tofinfo; std::vector<CalibData::bTofCalibBase> tmpbTof; std::vector<CalibData::eTofCalibBase> tmpeTof; std::vector<CalibData::bTofCommonCalibBase> tmpbTofCommon; std::vector<CalibData::tofCalibInfoBase> tofinfoCol; // Read in the object int cnt; // read btoftree ------------------------------------------------------------ double cnvBarPar1[nBarPar]; double cnvBarPar2[nBarPar]; double cnvBarParOff1[nBarParOff]; double cnvBarParOff2[nBarParOff]; TTree *btoftree = (TTree*)m_inFile -> Get("BarTofPar"); char brname[10]; for( unsigned int i=0; i<nBarPar; i++ ) { sprintf( brname, "P%i", i ); btoftree -> SetBranchAddress( brname, &cnvBarPar1[i] ); } for( unsigned int i=0; i<nBarPar; i++ ) { sprintf( brname, "P%i", i+nBarPar ); btoftree -> SetBranchAddress( brname, &cnvBarPar2[i] ); } for( unsigned int i=0; i<nBarParOff; i++ ) { sprintf( brname, "Poff%i", i ); btoftree -> SetBranchAddress( brname, &cnvBarParOff1[i] ); } for( unsigned int i=0; i<nBarParOff; i++ ) { sprintf( brname, "Poff%i", i+nBarParOff ); btoftree -> SetBranchAddress( brname, &cnvBarParOff2[i] ); } for(cnt=0; cnt<176; cnt++){ btoftree -> GetEntry(cnt); bTof.setP1( cnvBarPar1 ); bTof.setP2( cnvBarPar2 ); bTof.setPoff1( cnvBarParOff1 ); bTof.setPoff2( cnvBarParOff2 ); tmpbTof.push_back( bTof ); } //read etoftree double cnvEndPar[nEndPar]; TTree *etoftree = (TTree*)m_inFile -> Get("EndTofPar"); char ecname[10]; for( unsigned int i=0; i<nEndPar; i++ ) { sprintf( ecname, "P%i", i ); etoftree -> SetBranchAddress( ecname, &cnvEndPar[i] ); } for(cnt=0; cnt<96; cnt++){ etoftree->GetEntry(cnt); eTof.setP( cnvEndPar ); tmpeTof.push_back(eTof); } //read bTofCommonCalibBase double cnvBarOffset[nBarOffset]; TTree *btofcommontree = (TTree*)m_inFile -> Get("BarTofParCommon"); for( unsigned int i=0; i<nBarOffset; i++ ) { sprintf( brname, "t0offset%i", i ); btofcommontree-> SetBranchAddress( brname, &cnvBarOffset[i]); } int entries = btofcommontree->GetEntries(); for(cnt=0;cnt<entries;cnt++){ btofcommontree->GetEntry(cnt); bTofCommon.setOffset( cnvBarOffset ); tmpbTofCommon.push_back(bTofCommon); } CalibData::TofCalibData *tmpObject = new CalibData::TofCalibData(&tmpbTof,&tmpbTofCommon,&tmpeTof,&tofinfoCol); 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 & RootEstTofCalibDataCnv::objType (   )  const

{ return CLID_Calib_EstTofCal; }

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 RootEstTofCalibDataCnv::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<RootEstTofCalibDataCnv> [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/RootEstTofCalibDataCnv.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Calibration/CalibSvc/CalibROOTCnv/CalibROOTCnv-00-00-45/src/cnv/RootEstTofCalibDataCnv.cxx

---