RootDedxCalibDataCnv Class Reference

#include <RootDedxCalibDataCnv.h>

Inheritance diagram for RootDedxCalibDataCnv:

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

---

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

RootDedxCalibDataCnv::RootDedxCalibDataCnv (  ISvcLocator *  svc  )

: RootCalBaseCnv(svc, CLID_Calib_DedxCal) { }

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

{};

---

Member Function Documentation

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

{ return CLID_Calib_DedxCal; }

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 RootDedxCalibDataCnv::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(), "RootDedxCalibDataCnv"); // 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 int i; CalibData::DedxCalibData* tmpObject = dynamic_cast<CalibData::DedxCalibData*>(pTDSObj); // write rungcalib ------------------------------------------------------------ double rungain; double runmean; double runno; double runresol; TTree *rungcalibtree = new TTree("rungcalib", "rungCalib"); rungcalibtree -> Branch("rungain", &rungain, "S/D"); rungcalibtree -> Branch("runmean", &runmean, "S/D"); rungcalibtree -> Branch("runno", &runno, "S/D"); rungcalibtree -> Branch("runresol", &runresol, "S/D"); int N = tmpObject->getrunNO(); for(i=0; i<N; i++){ rungain = tmpObject->getrung(0,i); runmean = tmpObject->getrung(1,i); runno = tmpObject->getrung(2,i); runresol = tmpObject->getrung(3,i); rungcalibtree -> Fill(); } // write ddgcalib---------------------------------------------------------------- double ddg0; double ddg1; double ddg2; double ddg3; TTree *ddgcalibtree = new TTree("ddgcalib", "ddgCalib"); ddgcalibtree -> Branch("ddg0", &ddg0, "S/D"); ddgcalibtree -> Branch("ddg1", &ddg1, "S/D"); ddgcalibtree -> Branch("ddg2", &ddg2, "S/D"); ddgcalibtree -> Branch("ddg3", &ddg3, "S/D"); for(i=0; i<43; i++){ ddg0 = tmpObject->getddg(0,i); ddg1 = tmpObject->getddg(1,i); ddg2 = tmpObject->getddg(2,i); ddg3 = tmpObject->getddg(3,i); ddgcalibtree -> Fill(); } // write ggscalib---------------------------------------------------------------- double ggs0; double ggs1; double ggs2; double ggs3; TTree *ggscalibtree = new TTree("ggscalib", "ggsCalib"); ggscalibtree -> Branch("ggs0", &ggs0, "S/D"); ggscalibtree -> Branch("ggs1", &ggs1, "S/D"); ggscalibtree -> Branch("ggs2", &ggs2, "S/D"); ggscalibtree -> Branch("ggs3", &ggs3, "S/D"); for(i=0; i<43; i++){ ggs0 = tmpObject->getggs(0,i); ggs1 = tmpObject->getggs(1,i); ggs2 = tmpObject->getggs(2,i); ggs3 = tmpObject->getggs(3,i); ggscalibtree -> Fill(); } // write zdepcalib---------------------------------------------------------------- double zdep0; double zdep1; double zdep2; double zdep3; TTree *zdepcalibtree = new TTree("zdepcalib", "zdepCalib"); zdepcalibtree -> Branch("zdep0", &zdep0, "S/D"); zdepcalibtree -> Branch("zdep1", &zdep1, "S/D"); zdepcalibtree -> Branch("zdep2", &zdep2, "S/D"); zdepcalibtree -> Branch("zdep3", &zdep3, "S/D"); for(i=0; i<43; i++){ zdep0 = tmpObject->getzdep(0,i); zdep1 = tmpObject->getzdep(1,i); zdep2 = tmpObject->getzdep(2,i); zdep3 = tmpObject->getzdep(3,i); zdepcalibtree -> Fill(); } // write entacalib---------------------------------------------------------------- double enta0; double enta1; double enta2; double enta3; TTree *entacalibtree = new TTree("entacalib", "entaCalib"); entacalibtree -> Branch("enta0", &enta0, "S/D"); entacalibtree -> Branch("enta1", &enta1, "S/D"); entacalibtree -> Branch("enta2", &enta2, "S/D"); entacalibtree -> Branch("enta3", &enta3, "S/D"); for(i=0; i<43; i++){ enta0 = tmpObject->getenta(0,i); enta1 = tmpObject->getenta(1,i); enta2 = tmpObject->getenta(2,i); enta3 = tmpObject->getenta(3,i); entacalibtree -> Fill(); } // write gain--------------------------------------------------------------------- double gain; TTree *gaintree = new TTree("gaincalib", "gainCalib"); gaintree -> Branch("gain", &gain, "S/D"); gain = tmpObject->getgain(); gaintree -> Fill(); // write resol--------------------------------------------------------------------- double resol; TTree *resoltree = new TTree("resolcalib", "resolCalib"); resoltree -> Branch("resol", &resol, "S/D"); resol = tmpObject->getresol(); resoltree -> Fill(); // write wiregcalib---------------------------------------------------------------- double wireg; TTree *wiregcalibtree = new TTree("wiregcalib", "wiregCalib"); wiregcalibtree -> Branch("wireg", &wireg, "S/D"); for(i=0; i<6796; i++){ wireg = tmpObject->getwireg(i); wiregcalibtree -> Fill(); } // write layergcalib---------------------------------------------------------------- double layerg; TTree *layergcalibtree = new TTree("layergcalib", "layergCalib"); layergcalibtree -> Branch("layerg", &layerg, "S/D"); for(i=0; i<43; i++){ layerg = tmpObject->getlayerg(i); layergcalibtree -> Fill(); } // write all the trees rungcalibtree -> Write(); ddgcalibtree -> Write(); ggscalibtree -> Write(); zdepcalibtree -> Write(); entacalibtree -> Write(); gaintree -> Write(); resoltree -> Write(); wiregcalibtree -> Write(); layergcalibtree -> Write(); delete rungcalibtree; delete ddgcalibtree; delete ggscalibtree; delete zdepcalibtree; delete entacalibtree; delete gaintree; delete resoltree; delete wiregcalibtree; delete layergcalibtree; 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 RootDedxCalibDataCnv::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(), "RootDedxCalibDataCnv"); log<<MSG::DEBUG<<"SetProperty"<<endreq; StatusCode sc = openRead(fname); if(!sc) { log<<MSG::ERROR<<"unable to open files"<<endreq; } CalibData::DedxCalibData *tmpObject = new CalibData::DedxCalibData; // Read in our object int i; // read rungcalib ------------------------------------------------------------ double rungain; double runmean; int runno; double runresol; TTree *rungtree = (TTree*)m_inFile -> Get("runcalib"); rungtree -> SetBranchAddress("rungain", &rungain); rungtree -> SetBranchAddress("runmean", &runmean); rungtree -> SetBranchAddress("runno", &runno); rungtree -> SetBranchAddress("runresol", &runresol); int N = rungtree -> GetEntries(); tmpObject -> setrunNO(N); //std::cout<<"N = "<<N<<std::endl; for(i=0; i<N; i++){ rungtree -> GetEntry(i); //std::cout<<rungain<<" "<<runmean<<" "<<runno<<" "<<runresol<<std::endl; tmpObject -> setrung(rungain,0,i); tmpObject -> setrung(runmean,1,i); tmpObject -> setrung(runno,2,i); tmpObject -> setrung(runresol,3,i); } // read ddgcalib ------------------------------------------------------------ double ddg0[43]; double ddg1[43]; double ddg2[43]; double ddg3[43]; double id_doca[1600]; double iner_chi[1600]; double iner_gain[1600]; double iner_hits[1600]; double ip_eangle[1600]; double out_chi[1600]; double out_gain[1600]; double out_hits[1600]; TTree *ddgtree = (TTree*)m_inFile -> Get("ddgcalib"); ddgtree -> SetBranchAddress("ddg0", ddg0); ddgtree -> SetBranchAddress("ddg1", ddg1); ddgtree -> SetBranchAddress("ddg2", ddg2); ddgtree -> SetBranchAddress("ddg3", ddg3); TBranch *bbb = ddgtree->FindBranch("Id_doca"); if(bbb){ ddgtree -> SetBranchAddress("Id_doca", id_doca); ddgtree -> SetBranchAddress("Iner_chi", iner_chi); ddgtree -> SetBranchAddress("Iner_gain", iner_gain); ddgtree -> SetBranchAddress("Iner_hits", iner_hits); ddgtree -> SetBranchAddress("Ip_eangle", ip_eangle); ddgtree -> SetBranchAddress("Out_chi", out_chi); ddgtree -> SetBranchAddress("Out_gain", out_gain); ddgtree -> SetBranchAddress("Out_hits", out_hits); } ddgtree -> GetEntry(0); for(i=0; i<43; i++){ tmpObject -> setddg(ddg0[i],0,i); tmpObject -> setddg(ddg1[i],1,i); tmpObject -> setddg(ddg2[i],2,i); tmpObject -> setddg(ddg3[i],3,i); } for(i=0; i<1600; i++){ if(!bbb){ id_doca[i]=0; iner_chi[i]=0; iner_gain[i]=0; iner_hits[i]=0; ip_eangle[i]=0; out_chi[i]=0; out_gain[i]=0; out_hits[i]=0; } tmpObject -> set_id_doca(id_doca[i],i); tmpObject -> set_iner_chi(iner_chi[i],i); tmpObject -> set_iner_gain(iner_gain[i],i); tmpObject -> set_iner_hits(iner_hits[i],i); tmpObject -> set_ip_eangle(ip_eangle[i],i); tmpObject -> set_out_chi(out_chi[i],i); tmpObject -> set_out_gain(out_gain[i],i); tmpObject -> set_out_hits(out_hits[i],i); } // read entratree--------------------------------------------- double entra0[43]; double entra1[43]; double entra2[43]; double entra3[43]; double engle[100]; int engle_no; TTree *entratree = (TTree*)m_inFile -> Get("entracalib"); entratree -> SetBranchAddress("entra0", entra0); entratree -> SetBranchAddress("entra1", entra1); entratree -> SetBranchAddress("entra2", entra2); entratree -> SetBranchAddress("entra3", entra3); entratree -> SetBranchAddress("1denangle", engle); entratree -> SetBranchAddress("1denangle_entry", &engle_no); entratree -> GetEntry(0); for(i=0; i<43; i++){ tmpObject -> setenta(entra0[i],0,i); tmpObject -> setenta(entra1[i],1,i); tmpObject -> setenta(entra2[i],2,i); tmpObject -> setenta(entra3[i],3,i); } tmpObject -> set_enanglesize(engle_no); for(i=0; i<engle_no; i++){ tmpObject -> set_enangle(engle[i],i); } // read ggscalib ------------------------------------------------------------ double ggs0[43]; double ggs1[43]; double ggs2[43]; double ggs3[43]; double gcostheta[80]; int hadron_entry; double hadron[20]; TTree *ggstree = (TTree*)m_inFile -> Get("ggscalib"); ggstree -> SetBranchAddress("ggs0", ggs0); ggstree -> SetBranchAddress("ggs1", ggs1); ggstree -> SetBranchAddress("ggs2", ggs2); ggstree -> SetBranchAddress("ggs3", ggs3); ggstree -> SetBranchAddress("hadron", hadron); ggstree -> SetBranchAddress("hadronNo", &hadron_entry); if(bbb){ ggstree -> SetBranchAddress("costheta", gcostheta); } ggstree -> GetEntry(0); for(i=0; i<43;i++){ tmpObject -> setggs(ggs0[i],0,i); tmpObject -> setggs(ggs1[i],1,i); tmpObject -> setggs(ggs2[i],2,i); tmpObject -> setggs(ggs3[i],3,i); } for(i=0; i<80;i++){ if(!bbb) gcostheta[i]=0; tmpObject ->set_costheta(gcostheta[i],i); } if(hadron_entry>20){ log<<MSG::FATAL<<"hadron entry is larger than 20, larger than designed"<<endreq; return StatusCode::FAILURE; } tmpObject->set_hadronNo(hadron_entry); for(i=0;i<hadron_entry;i++){ tmpObject->set_hadron(hadron[i],i); } // read zdepcalib ------------------------------------------------------------ double zdep0[43]; double zdep1[43]; double zdep2[43]; double zdep3[43]; TTree *zdeptree = (TTree*)m_inFile -> Get("zdepcalib"); zdeptree -> SetBranchAddress("zdep0", zdep0); zdeptree -> SetBranchAddress("zdep1", zdep1); zdeptree -> SetBranchAddress("zdep2", zdep2); zdeptree -> SetBranchAddress("zdep3", zdep3); zdeptree -> GetEntry(0); for(i=0; i<43;i++){ tmpObject -> setzdep(zdep0[i],0,i); tmpObject -> setzdep(zdep1[i],1,i); tmpObject -> setzdep(zdep2[i],2,i); tmpObject -> setzdep(zdep3[i],3,i); } // read gain ------------------------------------------------------------ double gain; double gt0[35],gdedx[35]; TTree *gaintree = (TTree*)m_inFile -> Get("gaincalib"); gaintree -> SetBranchAddress("gain", &gain); if(bbb){ gaintree -> SetBranchAddress("t0", gt0); gaintree -> SetBranchAddress("dedx", gdedx); } gaintree -> GetEntry(0); tmpObject -> setgain(gain); for(i=0; i<35;i++){ if(!bbb){ gt0[i]=0; gdedx[i]=0; } tmpObject->set_t0(gt0[i],i); tmpObject->set_dedx(gdedx[i],i); } // read resol---------------------------------------------------------------- double resol; TTree *resoltree = (TTree*)m_inFile -> Get("resolcalib"); resoltree -> SetBranchAddress("resol", &resol); resoltree -> GetEntry(0); tmpObject -> setresol(resol); // read wireg---------------------------------------------------------------- double wireg[6796]; TTree *wiregtree = (TTree*)m_inFile -> Get("wiregcalib"); wiregtree -> SetBranchAddress("wireg",wireg); wiregtree -> GetEntry(0); for(i=0;i<6796;i++){ tmpObject -> setwireg(wireg[i],i); } // read layerg---------------------------------------------------------------- double layerg[43]; TTree *layergtree = (TTree*)m_inFile -> Get("layergcalib"); layergtree -> SetBranchAddress("layerg",layerg); layergtree -> GetEntry(0); for(i=0;i<43;i++){ tmpObject -> setlayerg(layerg[i],i); } refpObject=tmpObject; // delete pObj; // std::cout<<"pObj.m_t0[Cell]="<<*(pObj->gett0()+Cell-1); // dynamic_cast<CalibData::Mdct0& >(refpObject); //refpObject = pObj; // std::cout<<"refObject.m_t0[Cell]="<<*(refpObject->gett0()+Cell-1); // refpObject = new Mdct0(&t0_tmp[0]); 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 & RootDedxCalibDataCnv::objType (   )  const

{ return CLID_Calib_DedxCal; }

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

---