Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

RootTofElecDataCnv Class Reference

#include <RootTofQElecDataCnv.h>

Inheritance diagram for RootTofElecDataCnv:

RootCalBaseCnv Converter< Ty1, Ty2 > 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
 RootTofElecDataCnv (ISvcLocator *svc)
virtual ~RootTofElecDataCnv ()

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<RootTofElecDataCnv>

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

RootTofElecDataCnv::RootTofElecDataCnv (  ISvcLocator *  svc  ) 
  

00030                                                         :
00031   RootCalBaseCnv(svc, CLID_TofQ_Elec) { 
00032 
00033 }

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

00029 {};

Member Function Documentation

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

00040                                         {
00041   return CLID_TofQ_Elec;
00042 }

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

Clean up when we've finished reading in 

00132                                      {
00133   m_inFile->Close();
00134 
00135   delete m_inFile;
00136   m_inFile = 0;
00137 
00138   if (m_saveDir) {
00139     m_saveDir->cd();
00140     m_saveDir = 0;
00141   }
00142   return StatusCode::SUCCESS;
00143 }

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) 

00179                                       {
00180 
00181   MsgStream log(msgSvc(), "RootCalBaseCnv");
00182 
00183   StatusCode ret = StatusCode::SUCCESS;
00184 
00185   m_outFile->cd();
00186   m_outFile->Close();
00187   delete m_outFile;
00188   m_outFile = 0;
00189   if (m_saveDir) m_saveDir->cd();
00190   m_saveDir = 0;
00191   return ret;
00192 }

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. 

00250                                                            {
00251   //  StatusCode ret;
00252 
00253   // first do the things we always need:
00254   //   First string parameter of opaque address is file ident
00255   MsgStream log(msgSvc(), "RootCalBaseCnv");
00256    log << MSG::DEBUG<<"RootCalBaseCnv::createObj( starting ...."<<endreq;
00257    const std::string* par = addr->par();
00258 
00259   std::string par0 = par[0];
00260    
00261   return internalCreateObj(par0, refpObject, addr);
00262 
00263 }

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

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 in RootDedxCalibDataCnv, RootDedxSimDataCnv, RootEmcCalibDataCnv, RootEsTimeCalibDataCnv, RootEstTofCalibDataCnv, RootMdcCalibDataCnv, RootMucCalibDataCnv, RootTofCalibDataCnv, and RootTofSimDataCnv.

00087                                                                        {
00088   MsgStream log(msgSvc(), "RootCalBaseCnv");
00089   log << MSG::ERROR 
00090       << "createRoot method not implemented for this calibration type" 
00091       << endreq;
00092   return StatusCode::FAILURE;
00093 }

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 
00239                                                           {
00240 
00241   // Get instrument name from InstrumentName service  Now handled by 
00242   // RootCalBaseCnv
00243   //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
00244   //  pRootObj->setInstrument(instr);
00245   return StatusCode::SUCCESS;
00246 }

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

00079                                     {
00080   return Converter::finalize();
00081 }

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

00058                                    {
00059     return m_rootSvc;
00060   }

StatusCode RootTofElecDataCnv::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.

00045                                                                 {
00046 
00047   MsgStream log(msgSvc(), "RootTofElecDataCnv");
00048   log<<MSG::DEBUG<<"SetProperty"<<endreq;
00049   StatusCode sc = openRead(fname);
00050   if(!sc)
00051     { log<<MSG::ERROR<<"unable to open files"<<endreq;
00052     }
00053 
00054   TTree *BarBoardNum=(TTree*)m_inFile -> Get("BarBoardNum");
00055   TTree *EndBoardNum= (TTree*)m_inFile -> Get("EndBoardNum");
00056   TTree *QElecBarParEast = (TTree*)m_inFile -> Get("QElecBarParEast");
00057   TTree *QElecBarParWest = (TTree*)m_inFile -> Get("QElecBarParWest");
00058   TTree *QElecEndPar = (TTree*)m_inFile -> Get("QElecEndPar");
00059   TTree *SimQElecBarParEast = (TTree*)m_inFile -> Get("SimQElecBarParEast");
00060   TTree *SimQElecBarParWest = (TTree*)m_inFile -> Get("SimQElecBarParWest");
00061   TTree *SimQElecEndPar = (TTree*)m_inFile -> Get("SimQElecEndPar");
00062 
00063   CalibData::BarrelElec bTof;
00064   CalibData::EndcapElec eTof;
00065 
00066   std::vector<CalibData::BarrelElec> tmpbTof;//; = new vector<CalibData::bTofCalibBase>;
00067   std::vector<CalibData::EndcapElec> tmpeTof;
00068 
00069     // Read in the object
00070   int cnt;
00071   // read btoftree ------------------------------------------------------------
00072   unsigned int num[4];
00073   double num1[4];
00074      BarBoardNum -> SetBranchAddress("Board", &num1[0]);
00075      BarBoardNum -> SetBranchAddress("Channel", &num1[1]);
00076      BarBoardNum -> SetBranchAddress("Crate", &num1[2]);
00077      BarBoardNum -> SetBranchAddress("Fee", &num1[3]);
00078   double p[11];
00079      QElecBarParEast->SetBranchAddress("P0",&p[0]);
00080      QElecBarParEast->SetBranchAddress("P1",&p[1]);
00081      QElecBarParEast->SetBranchAddress("P2",&p[2]);
00082      QElecBarParEast->SetBranchAddress("P3",&p[3]);
00083      QElecBarParEast->SetBranchAddress("P4",&p[4]);
00084      QElecBarParEast->SetBranchAddress("P5",&p[5]);
00085      QElecBarParEast->SetBranchAddress("P6",&p[6]);
00086      QElecBarParEast->SetBranchAddress("P7",&p[7]);
00087      QElecBarParEast->SetBranchAddress("P8",&p[8]);
00088      QElecBarParEast->SetBranchAddress("P9",&p[9]);
00089      QElecBarParEast->SetBranchAddress("P10",&p[10]);
00090    double p_w[11];
00091      QElecBarParWest->SetBranchAddress("P0",&p_w[0]);
00092      QElecBarParWest->SetBranchAddress("P1",&p_w[1]);
00093      QElecBarParWest->SetBranchAddress("P2",&p_w[2]);
00094      QElecBarParWest->SetBranchAddress("P3",&p_w[3]);
00095      QElecBarParWest->SetBranchAddress("P4",&p_w[4]);
00096      QElecBarParWest->SetBranchAddress("P5",&p_w[5]);
00097      QElecBarParWest->SetBranchAddress("P6",&p_w[6]);
00098      QElecBarParWest->SetBranchAddress("P7",&p_w[7]);
00099      QElecBarParWest->SetBranchAddress("P8",&p_w[8]);
00100      QElecBarParWest->SetBranchAddress("P9",&p_w[9]);
00101      QElecBarParWest->SetBranchAddress("P10",&p_w[10]);
00102       double p_se[11];
00103      SimQElecBarParEast->SetBranchAddress("P0",&p_se[0]);
00104      SimQElecBarParEast->SetBranchAddress("P1",&p_se[1]);
00105      SimQElecBarParEast->SetBranchAddress("P2",&p_se[2]);
00106      SimQElecBarParEast->SetBranchAddress("P3",&p_se[3]);
00107      SimQElecBarParEast->SetBranchAddress("P4",&p_se[4]);
00108      SimQElecBarParEast->SetBranchAddress("P5",&p_se[5]);
00109      SimQElecBarParEast->SetBranchAddress("P6",&p_se[6]);
00110      SimQElecBarParEast->SetBranchAddress("P7",&p_se[7]);
00111      SimQElecBarParEast->SetBranchAddress("P8",&p_se[8]);
00112      SimQElecBarParEast->SetBranchAddress("P9",&p_se[9]);
00113      SimQElecBarParEast->SetBranchAddress("P10",&p_se[10]);
00114        double p_sw[11];
00115      SimQElecBarParWest->SetBranchAddress("P0",&p_sw[0]);
00116      SimQElecBarParWest->SetBranchAddress("P1",&p_sw[1]);
00117      SimQElecBarParWest->SetBranchAddress("P2",&p_sw[2]);
00118      SimQElecBarParWest->SetBranchAddress("P3",&p_sw[3]);
00119      SimQElecBarParWest->SetBranchAddress("P4",&p_sw[4]);
00120      SimQElecBarParWest->SetBranchAddress("P5",&p_sw[5]);
00121      SimQElecBarParWest->SetBranchAddress("P6",&p_sw[6]);
00122      SimQElecBarParWest->SetBranchAddress("P7",&p_sw[7]);
00123      SimQElecBarParWest->SetBranchAddress("P8",&p_sw[8]);
00124      SimQElecBarParWest->SetBranchAddress("P9",&p_sw[9]);
00125      SimQElecBarParWest->SetBranchAddress("P10",&p_sw[10]);
00126 
00127      for(cnt=0; cnt<352; cnt++){
00128          BarBoardNum -> GetEntry(cnt);
00129           num[0]=num1[0];
00130            num[1]=num1[1];
00131           num[2]=num1[2];
00132            num[3]=num1[3];
00133          if(cnt%2!=0){
00134           bTof.setNumWest(num);
00135           }
00136          if(cnt%2==0){
00137           bTof.setNumEast(num);
00138          int kkk=cnt/2;
00139          QElecBarParEast->GetEntry(kkk);
00140          QElecBarParWest->GetEntry(kkk);
00141          SimQElecBarParEast->GetEntry(kkk);
00142          SimQElecBarParWest->GetEntry(kkk);
00143            bTof.setP1(p);
00144            bTof.setP2(p_w);
00145            bTof.setSimP1(p_se);
00146            bTof.setSimP2(p_sw);
00147           }           
00148          if(cnt%2!=0)
00149            tmpbTof.push_back(bTof);
00150           }
00151 
00152        //read etoftree
00153        EndBoardNum -> SetBranchAddress("Board", &num1[0]);
00154        EndBoardNum -> SetBranchAddress("Channel", &num1[1]);
00155        EndBoardNum -> SetBranchAddress("Crate", &num1[2]);
00156        EndBoardNum -> SetBranchAddress("Fee", &num1[3]);
00157        QElecEndPar-> SetBranchAddress("P0",&p[0]);
00158        QElecEndPar->SetBranchAddress("P1",&p[1]);
00159        QElecEndPar->SetBranchAddress("P2",&p[2]);
00160        QElecEndPar->SetBranchAddress("P3",&p[3]);
00161        QElecEndPar->SetBranchAddress("P4",&p[4]);
00162        QElecEndPar->SetBranchAddress("P5",&p[5]);
00163        QElecEndPar->SetBranchAddress("P6",&p[6]);
00164        QElecEndPar->SetBranchAddress("P7",&p[7]);
00165        QElecEndPar->SetBranchAddress("P8",&p[8]);
00166        QElecEndPar->SetBranchAddress("P9",&p[9]);
00167        QElecEndPar->SetBranchAddress("P10",&p[10]);
00168        SimQElecEndPar-> SetBranchAddress("P0",&p_w[0]);
00169        SimQElecEndPar->SetBranchAddress("P1",&p_w[1]);
00170        SimQElecEndPar->SetBranchAddress("P2",&p_w[2]);
00171        SimQElecEndPar->SetBranchAddress("P3",&p_w[3]);
00172        SimQElecEndPar->SetBranchAddress("P4",&p_w[4]);
00173        SimQElecEndPar->SetBranchAddress("P5",&p_w[5]);
00174        SimQElecEndPar->SetBranchAddress("P6",&p_w[6]);
00175        SimQElecEndPar->SetBranchAddress("P7",&p_w[7]);
00176        SimQElecEndPar->SetBranchAddress("P8",&p_w[8]);
00177        SimQElecEndPar->SetBranchAddress("P9",&p_w[9]);
00178        SimQElecEndPar->SetBranchAddress("P10",&p_w[10]);
00179         for(cnt=0; cnt<96; cnt++){
00180         EndBoardNum->GetEntry(cnt);
00181         QElecEndPar->GetEntry(cnt);
00182         SimQElecEndPar->GetEntry(cnt);
00183         num[0]=num1[0];
00184            num[1]=num1[1];
00185           num[2]=num1[2];
00186            num[3]=num1[3];
00187         eTof.setNum(num);
00188         eTof.setP(p);
00189         eTof.setSimP(p_w);
00190         tmpeTof.push_back(eTof);
00191    }
00192 
00193    CalibData::TofElecData *tmpObject = new CalibData::TofElecData(&tmpbTof,&tmpeTof);
00194 
00195   
00196       refpObject=tmpObject;
00197   delete BarBoardNum;
00198   delete EndBoardNum;
00199   delete QElecBarParEast;
00200   delete QElecBarParWest; 
00201   delete QElecEndPar; 
00202   delete SimQElecBarParEast;
00203   delete SimQElecBarParWest; 
00204   delete SimQElecEndPar; 
00205 
00206   return StatusCode::SUCCESS;
00207 
00208 
00209 }

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

In case there is additional work to do on the created object. 

00320                                                                       {
00321   return StatusCode::SUCCESS;
00322 }

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

00046                                       {
00047   StatusCode status = Converter::initialize();
00048 
00049   IDataProviderSvc* dp;
00050 
00051   // I guess the service names are assigned in jobOptions?
00052 
00053   serviceLocator()->getService ("CalibDataSvc",
00054                                 IID_IDataProviderSvc,
00055                                 (IInterface*&)dp);
00056   setDataProvider(dp);
00057   
00058   // Locate the Root Conversion Service
00059   serviceLocator()->getService ("CalibRootCnvSvc",
00060                                 IID_ICalibRootSvc,
00061                                 (IInterface*&) m_rootSvc);
00062 
00063   // Locate meta conversion service
00064   // Will anything need to be changed here to accommodate possibility
00065   // of two concrete implementations of ICalibMetaCnvSvc?  Would
00066   // have different storage types.  Could specify type desired
00067   // as job option.  Ditto for name of class?
00068   serviceLocator()->getService("CalibMySQLCnvSvc", 
00069                                IID_ICalibMetaCnvSvc,
00070                                 (IInterface*&)m_metaSvc);
00071 
00072   serviceLocator()->getService ("CalibDataSvc",
00073                                 IID_IInstrumentName,
00074                                 (IInterface*&)m_instrSvc);
00075 
00076   return status;
00077 }

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 
00267                                                                    {
00268   MsgStream log(msgSvc(), "RootCalBaseCnv");
00269    log << MSG::DEBUG<<"RootCalBaseCnv::internalCreateObj( starting ..... "<<endreq;
00270    RootCalBaseCnv* converter = this;
00271   CLID classId = address->clID();
00272 
00273   IConverter* conv = this->conversionSvc()->converter(classId);
00274   if (0 == conv) {
00275     log << MSG::WARNING
00276         << "No proper converter found for classID " << classId
00277             << ", the default converter"
00278             << " will be used. " << endreq;
00279   } else {
00280     converter = dynamic_cast <RootCalBaseCnv*> (conv);
00281     if (0 == converter) {
00282       log << MSG::ERROR
00283           << "The converter found for classID " << classId
00284               << " was not a descendent of RootCalBaseCnv as it should be "
00285               << "( was of type " << typeid (*converter).name() << "). "
00286               << "The default converter will be used" << endreq;
00287       converter = this;
00288     }
00289   }
00290 
00291     m_runfrm =*( address->ipar());
00292     m_runto =*( address->ipar()+1);
00293    // creates an object for the node found
00294    StatusCode sc = converter->i_createObj(fname, refpObject);
00295      if (sc.isFailure()) {
00296     return sc;
00297   } 
00298      CalibData::CalibBase1* tmpObject =  dynamic_cast <CalibData::CalibBase1*> (refpObject);
00299      setBaseInfo(tmpObject);
00300   // ends up the object construction
00301   sc = converter->i_processObj(refpObject, address);
00302   if (sc.isSuccess()) {
00303     log << MSG::DEBUG << "Successfully created calib. object " << endreq;
00304   }
00305   closeRead();
00306   return sc;
00307 }

const CLID & RootTofElecDataCnv::objType (   )  const
  

00036                                               {
00037   return CLID_TofQ_Elec;
00038 }

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 
00095                                                           { 
00096 
00097   MsgStream log(msgSvc(), "RootCalBaseCnv");
00098 
00099   // Check fname isn't empty
00100   if (fname == std::string("")) return StatusCode::FAILURE;
00101 
00102   if (doClean() ) {
00103     log << MSG::WARNING << "Previous operation didn't clean up! " << endreq;
00104   }
00105   m_saveDir = gDirectory;
00106 
00107   std::string ourName(fname);
00108   facilities::Util::expandEnvVar(&ourName);
00109 
00110   m_inFile = new TFile(ourName.c_str());
00111   
00112   if (!m_inFile->IsOpen() ) {
00113     log << MSG::ERROR << "ROOT file " << ourName 
00114         << "could not be opened for reading " << endreq;
00115     delete m_inFile;
00116     m_inFile = 0;
00117     return StatusCode::FAILURE;
00118   }
00119   else {
00120     log << MSG::INFO
00121         << "Successfully opened ROOT file " << fname << " aka " << ourName
00122         << " for reading " << endreq;
00123   }
00124 
00125 
00126   m_inFile->cd();             //    Maybe will need this
00127 
00128 
00129   return StatusCode::SUCCESS;
00130 }

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 
00145                                                            {
00146 
00147   MsgStream log(msgSvc(), "RootCalBaseCnv");
00148 
00149   // Check fname isn't empty
00150   if (fname == std::string("")) return StatusCode::FAILURE;
00151 
00152   std::string ourName(fname);
00153   facilities::Util::expandEnvVar(&ourName);
00154 
00155   if (doClean() ) {
00156     log << MSG::WARNING << "Previous operation didn't clean up! " << endreq;
00157   }
00158 
00159   m_saveDir = gDirectory;
00160 
00161  
00162   m_outFile = new TFile(ourName.c_str(), "RECREATE");
00163   if (!m_outFile->IsOpen()) {
00164     log << MSG::ERROR << "ROOT file " << fname << " aka " << ourName 
00165         << " could not be opened for writing" << endreq;
00166     delete m_outFile;
00167     m_outFile = 0;
00168     return StatusCode::FAILURE;
00169   }
00170   else {
00171     log << MSG::INFO
00172         << "Successfully opened ROOT file " << fname << " aka " << ourName
00173         << " for writing " << endreq;
00174   }
00175    m_outFile->cd();
00176   return StatusCode::SUCCESS;
00177 }

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]
  

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

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. 

00197                                                                 {
00198   TTree* pTree = (TTree*)m_inFile->Get(treename.c_str());
00199 
00200   return readRootObj(pTree, branch, pObj, ix);
00201  }

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

00034                                  { 
00035           return CALIBROOT_StorageType; 
00036       }

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. 

00325                                                           {
00326    MsgStream log(msgSvc(), "RootCalBaseCnv");
00327    log << MSG::DEBUG<<"set the runfrm and runto Numbers in the converter"<<endreq;
00328   pObj->setrunfrm(m_runfrm);
00329   pObj->setrunto(m_runto);
00330 }

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

00062 {return CALIBROOT_StorageType;}

Friends And Related Function Documentation

friend class CnvFactory<RootTofElecDataCnv> [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:
Generated on Wed Feb 2 18:49:12 2011 for BOSS6.5.5 by  doxygen 1.3.9.1