BOSS_7.0.2: RootDedxSimDataCnv Class Reference

template<class Ty1, class Ty2>

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

Definition at line 19 of file Converter.h.

template<class Ty1, class Ty2>

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

Definition at line 18 of file Converter.h.

RootDedxSimDataCnv::RootDedxSimDataCnv ( ISvcLocator * svc )

Definition at line 35 of file RootDedxSimDataCnv.cxx.

00035                                                         :
00036   RootCalBaseCnv(svc, CLID_Dedx_Sim) { 
00037  }

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

Definition at line 26 of file RootDedxSimDataCnv.h.

00026 {};

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

Definition at line 44 of file RootDedxSimDataCnv.cxx.

References CLID_Dedx_Sim.

00044                                         {
00045   return CLID_Dedx_Sim;
00046 }

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

Clean up when we've finished reading in

Definition at line 135 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::m_inFile, and RootCalBaseCnv::m_saveDir.

Referenced by RootCalBaseCnv::internalCreateObj().

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

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)

Definition at line 182 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::m_outFile, RootCalBaseCnv::m_saveDir, and msgSvc().

Referenced by RootTofCalibDataCnv::createRoot(), RootMdcCalibDataCnv::createRoot(), RootEstTofCalibDataCnv::createRoot(), RootEmcCalibDataCnv::createRoot(), and RootDedxCalibDataCnv::createRoot().

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

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.

Definition at line 252 of file RootCalBaseCnv.cxx.

References Bes_Common::DEBUG, RootCalBaseCnv::internalCreateObj(), msgSvc(), and deljobs::string.

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

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

Definition at line 110 of file RootDedxSimDataCnv.cxx.

References calibUtil::ERROR, msgSvc(), and RootCalBaseCnv::openWrite().

00111                                                                       {
00112    MsgStream log(msgSvc(), "RootDedxSimDataCnv");
00113 
00114  // Open the file, create the branch
00115    StatusCode sc = openWrite(fname);
00116   if(!sc)
00117     { log<<MSG::ERROR<<"unable to open files"<<endreq;
00118     }
00119   // write the Data in the TCDS to RootFile
00120  /*    int i;
00121      int j;
00122      CalibData::TofCalibData* btof = dynamic_cast<CalibData::TofCalibData*>(pTDSObj);
00123 
00124   // write  btoftree----------------------------------------------------------------
00125      double cnvP1[10];
00126      double cnvP2[10];
00127      double cnvW[4];
00128      double cnvAtten[8];
00129      double cnvQ;
00130      double cnvSpeed[2];
00131      TTree *btoftree = new TTree("BarTofPar", "BarTofPar");
00132       btoftree -> Branch("Atten0",&cnvAtten[0], "Atten0/D");
00133       btoftree -> Branch("Atten1",&cnvAtten[1], "Atten1/D");
00134       btoftree -> Branch("Atten2",&cnvAtten[2], "Atten2/D");
00135       btoftree -> Branch("Atten3",&cnvAtten[3], "Atten3/D");
00136       btoftree -> Branch("Atten4",&cnvAtten[4], "Atten4/D");
00137       btoftree -> Branch("Atten5",&cnvAtten[5], "Atten5/D");
00138       btoftree -> Branch("Atten6",&cnvAtten[6], "Atten6/D");
00139       btoftree -> Branch("Atten7",&cnvAtten[7], "Atten7/D");
00140       btoftree -> Branch("Q0",&cnvQ, "Q0/D");
00141       btoftree -> Branch("Speed0",&cnvSpeed[0], "Speed0/D");
00142       btoftree -> Branch("Speed1",&cnvSpeed[1], "Speed1/D");
00143       btoftree -> Branch("P0",&cnvP1[0], "P0/D");
00144       btoftree -> Branch("P1",&cnvP1[1], "P1/D");
00145       btoftree -> Branch("P2",&cnvP1[2], "P2/D");
00146       btoftree -> Branch("P3",&cnvP1[3], "P3/D");
00147       btoftree -> Branch("P4",&cnvP1[4], "P4/D");
00148       btoftree -> Branch("P5",&cnvP1[5], "P5/D");
00149       btoftree -> Branch("P6",&cnvP1[6], "P6/D");
00150       btoftree -> Branch("P7",&cnvP1[7], "P7/D");
00151       btoftree -> Branch("P8",&cnvP1[8], "P8/D");
00152       btoftree -> Branch("P9",&cnvP1[9], "P9/D");
00153       btoftree -> Branch("P10",&cnvP2[0], "P10/D");
00154       btoftree -> Branch("P11",&cnvP2[1], "P11/D");
00155       btoftree -> Branch("P12",&cnvP2[2], "P12/D");
00156       btoftree -> Branch("P13",&cnvP2[3], "P13/D");
00157       btoftree -> Branch("P14",&cnvP2[4], "P14/D");
00158       btoftree -> Branch("P15",&cnvP2[5], "P15/D");
00159       btoftree -> Branch("P16",&cnvP2[6], "P16/D");
00160       btoftree -> Branch("P17",&cnvP2[7], "P17/D");
00161       btoftree -> Branch("P18",&cnvP2[8], "P17/D");
00162       btoftree -> Branch("P19",&cnvP2[9], "P17/D");
00163       btoftree -> Branch("W0",&cnvW[0], "W0/D");
00164       btoftree -> Branch("W1",&cnvW[1], "W1/D");
00165       btoftree -> Branch("W2",&cnvW[2], "W2/D");
00166       btoftree -> Branch("W3",&cnvW[3], "W3/D");
00167 
00168        for(i=0; i<176; i++){
00169          cnvAtten[0] = btof->getBTofAtten(i,0);
00170          cnvAtten[1] = btof->getBTofAtten(i,1);
00171          cnvAtten[2] = btof->getBTofAtten(i,2);
00172          cnvQ = btof->getBTofQ(i);
00173          cnvSpeed[0] = btof->getBTofSpeed(i,0);
00174          cnvSpeed[1] = btof->getBTofSpeed(i,1);
00175          for(j=0;j<10;j++){
00176            cnvP1[j] = btof->getBTofPleft(i,j);
00177            cnvP2[j] = btof->getBTofPright(i,j);
00178          }
00179          for(j=0;j<4;j++){
00180            cnvW[j]=btof->getBTofW(i,j);
00181          }
00182          btoftree -> Fill();
00183        }
00184      
00185  //write  etoftree----------------------------------------------------------------
00186      double ecnvP[8];
00187      double ecnvAtten[5];
00188      double ecnvSpeed[3];
00189      TTree *etoftree = new TTree("EndTofPar", "EndTofPar");
00190       etoftree -> Branch("Atten0",&ecnvAtten[0], "Atten0/D");
00191       etoftree -> Branch("Atten1",&ecnvAtten[1], "Atten1/D");
00192       etoftree -> Branch("Atten2",&ecnvAtten[2], "Atten2/D");
00193       etoftree -> Branch("Atten3",&ecnvAtten[3], "Atten3/D");
00194       etoftree -> Branch("Atten4",&ecnvAtten[4], "Atten4/D");
00195       etoftree -> Branch("Speed0",&ecnvSpeed[0], "Speed0/D");
00196       etoftree -> Branch("Speed1",&ecnvSpeed[1], "Speed1/D");
00197       etoftree -> Branch("P0",&ecnvP[0], "P0/D");
00198       etoftree -> Branch("P1",&ecnvP[1], "P1/D");
00199       etoftree -> Branch("P2",&ecnvP[2], "P2/D");
00200       etoftree -> Branch("P3",&ecnvP[3], "P3/D");
00201       etoftree -> Branch("P4",&ecnvP[4], "P4/D");
00202       etoftree -> Branch("P5",&ecnvP[5], "P5/D");
00203       etoftree -> Branch("P6",&ecnvP[6], "P6/D");
00204       etoftree -> Branch("P7",&ecnvP[7], "P7/D");
00205     
00206        for(i=0; i<96; i++){
00207          ecnvAtten[0] = btof->getETofAtten(i,0);
00208          ecnvAtten[1] = btof->getETofAtten(i,1);
00209          ecnvAtten[2] = btof->getETofAtten(i,2);
00210          ecnvSpeed[0] = btof->getETofSpeed(i,0);
00211          ecnvSpeed[1] = btof->getETofSpeed(i,1);
00212          for(j=0;j<8;j++){
00213            ecnvP[j] = btof->getETofP(i,j);
00214          }
00215          etoftree -> Fill();
00216        }
00217 //  write all the trees
00218      btoftree -> Write();
00219      etoftree -> Write();
00220      delete btoftree;
00221      delete etoftree;
00222      closeWrite();
00223      log<<MSG::INFO<<"successfully create RootFile"<<endreq;
00224 */  
00225      return sc;
00226 
00227 }

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

Definition at line 241 of file RootCalBaseCnv.cxx.

00242                                                           {
00243 
00244   // Get instrument name from InstrumentName service  Now handled by 
00245   // RootCalBaseCnv
00246   //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
00247   //  pRootObj->setInstrument(instr);
00248   return StatusCode::SUCCESS;
00249 }

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

Definition at line 82 of file RootCalBaseCnv.cxx.

00082                                     {
00083   return Converter::finalize();
00084 }

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

Definition at line 58 of file RootCalBaseCnv.h.

References RootCalBaseCnv::m_rootSvc.

00058                                    {
00059     return m_rootSvc;
00060   }

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

Definition at line 48 of file RootDedxSimDataCnv.cxx.

References bin, Bes_Common::DEBUG, calibUtil::ERROR, RootCalBaseCnv::m_inFile, msgSvc(), RootCalBaseCnv::openRead(), CalibData::DedxSimData::setHist(), CalibData::DedxSimData::setHistNo(), CalibData::DedxSimData::setRange(), CalibData::DedxSimData::setRangeNo(), CalibData::DedxSimData::setThetaNo(), and CalibData::DedxSimData::setVersion().

00049                                                                     {
00050 
00051     MsgStream log(msgSvc(), "RootDedxSimDataCnv");
00052     log<<MSG::DEBUG<<"SetProperty"<<endreq;
00053  
00054     CalibData::DedxSimData *tmpObject = new CalibData::DedxSimData ;
00055 
00056     TH1F *h1=new TH1F();
00057     // open the file
00058     StatusCode sc = openRead(fname);
00059     if(!sc)
00060     {
00061         log<<MSG::ERROR<<"unable to open files"<<endreq;
00062     }
00063  
00064     std::vector<TH1F> hist;
00065     std::vector<double> hRange;
00066     // Read in the object
00067     int cnt;
00068     TTree *tree=(TTree*)m_inFile->Get("TH1F_Col");
00069     tree->SetBranchAddress("TH1F_Col", &h1);
00070     int entries=tree->GetEntries();
00071     for (cnt = 0; cnt < entries; cnt++) {
00072         tree -> GetEntry(cnt);
00073         gROOT->cd();
00074         TH1F *h2=new TH1F();
00075         h2=(TH1F*)h1->Clone();
00076             hist.push_back(*h2);
00077         }
00078 //      tmpObject->setHist(&hist);
00079     int ver;
00080     double betagamma[5000];
00081     int totalNum;
00082     int bgNum;
00083     int thetaNum;
00084     TTree* bin = (TTree*)m_inFile->Get("bin");
00085     if (bin->FindBranch("version")) bin->SetBranchAddress("version", &ver);
00086     else ver = 0;
00087     if (bin->FindBranch("thetaNum")) bin->SetBranchAddress("thetaNum", &thetaNum);
00088     else thetaNum = 16;
00089     bin->SetBranchAddress("totalNum", &totalNum);
00090     bin->SetBranchAddress("betagamma",  betagamma);
00091     bin->SetBranchAddress("betagammaBounds", &bgNum);
00092     bin->GetEntry(0);
00093     
00094     //int tot=totalNum*2;
00095     for (cnt = 0; cnt < bgNum; cnt++) {
00096         hRange.push_back(betagamma[cnt]);
00097     }
00098     
00099     tmpObject->setVersion(ver);
00100     tmpObject->setRangeNo(bgNum);
00101     tmpObject->setRange(&hRange);
00102     tmpObject->setThetaNo(thetaNum);
00103     tmpObject->setHistNo(totalNum);
00104     tmpObject->setHist(&hist);
00105     refpObject = tmpObject;
00106 
00107     return StatusCode::SUCCESS;
00108 }

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

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

Definition at line 322 of file RootCalBaseCnv.cxx.

Referenced by RootCalBaseCnv::internalCreateObj().

00323                                                                       {
00324   return StatusCode::SUCCESS;
00325 }

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

Definition at line 46 of file RootCalBaseCnv.cxx.

References IID_ICalibMetaCnvSvc(), IID_ICalibRootSvc(), IID_IInstrumentName(), RootCalBaseCnv::m_instrSvc, RootCalBaseCnv::m_metaSvc, and RootCalBaseCnv::m_rootSvc.

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   serviceLocator()->getService ("CalibDataSvc",
00057                                 IDataProviderSvc::interfaceID(),
00058                                 (IInterface*&)dp);
00059   setDataProvider(dp);
00060   
00061   // Locate the Root Conversion Service
00062   serviceLocator()->getService ("CalibRootCnvSvc",
00063                                 IID_ICalibRootSvc,
00064                                 (IInterface*&) m_rootSvc);
00065 
00066   // Locate meta conversion service
00067   // Will anything need to be changed here to accommodate possibility
00068   // of two concrete implementations of ICalibMetaCnvSvc?  Would
00069   // have different storage types.  Could specify type desired
00070   // as job option.  Ditto for name of class?
00071   serviceLocator()->getService("CalibMySQLCnvSvc", 
00072                                IID_ICalibMetaCnvSvc,
00073                                 (IInterface*&)m_metaSvc);
00074 
00075   serviceLocator()->getService ("CalibDataSvc",
00076                                 IID_IInstrumentName,
00077                                 (IInterface*&)m_instrSvc);
00078 
00079   return status;
00080 }

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

Definition at line 268 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::closeRead(), Bes_Common::DEBUG, calibUtil::ERROR, RootCalBaseCnv::i_createObj(), RootCalBaseCnv::i_processObj(), RootCalBaseCnv::m_runfrm, RootCalBaseCnv::m_runto, msgSvc(), RootCalBaseCnv::setBaseInfo(), and Bes_Common::WARNING.

Referenced by RootCalBaseCnv::createObj().

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

const CLID & RootDedxSimDataCnv::objType ( ) const

Definition at line 40 of file RootDedxSimDataCnv.cxx.

References CLID_Dedx_Sim.

00040                                               {
00041   return CLID_Dedx_Sim;
00042 }

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

Definition at line 98 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::doClean(), calibUtil::ERROR, Bes_Common::INFO, RootCalBaseCnv::m_inFile, RootCalBaseCnv::m_saveDir, msgSvc(), deljobs::string, and Bes_Common::WARNING.

Referenced by RootTofSimDataCnv::i_createObj(), RootTofElecDataCnv::i_createObj(), RootTofCalibDataCnv::i_createObj(), RootMucCalibDataCnv::i_createObj(), RootMdcCalibDataCnv::i_createObj(), RootEstTofCalibDataCnv::i_createObj(), RootEsTimeCalibDataCnv::i_createObj(), RootEmcCalibDataCnv::i_createObj(), i_createObj(), and RootDedxCalibDataCnv::i_createObj().

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

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

Definition at line 148 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::doClean(), calibUtil::ERROR, Bes_Common::INFO, RootCalBaseCnv::m_outFile, RootCalBaseCnv::m_saveDir, msgSvc(), deljobs::string, and Bes_Common::WARNING.

Referenced by RootTofSimDataCnv::createRoot(), RootTofCalibDataCnv::createRoot(), RootMdcCalibDataCnv::createRoot(), RootEstTofCalibDataCnv::createRoot(), RootEsTimeCalibDataCnv::createRoot(), RootEmcCalibDataCnv::createRoot(), createRoot(), and RootDedxCalibDataCnv::createRoot().

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

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]`

Definition at line 206 of file RootCalBaseCnv.cxx.

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

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.

Definition at line 198 of file RootCalBaseCnv.cxx.

References RootCalBaseCnv::m_inFile.

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

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

Definition at line 31 of file RootDedxSimDataCnv.h.

References CALIBROOT_StorageType.

00031                                  { 
00032           return CALIBROOT_StorageType; 
00033       }

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.

Definition at line 328 of file RootCalBaseCnv.cxx.

References Bes_Common::DEBUG, RootCalBaseCnv::m_runfrm, RootCalBaseCnv::m_runto, msgSvc(), CalibData::CalibBase1::setrunfrm(), and CalibData::CalibBase1::setrunto().

Referenced by RootCalBaseCnv::internalCreateObj().

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

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

Definition at line 62 of file RootCalBaseCnv.h.

References CALIBROOT_StorageType.

00062 {return CALIBROOT_StorageType;}

friend class CnvFactory< RootDedxSimDataCnv > [friend]

Definition at line 19 of file RootDedxSimDataCnv.h.

TFile* RootCalBaseCnv::m_inFile [protected, inherited]

Definition at line 207 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::closeRead(), RootCalBaseCnv::doClean(), RootTofSimDataCnv::i_createObj(), RootTofElecDataCnv::i_createObj(), RootTofCalibDataCnv::i_createObj(), RootMucCalibDataCnv::i_createObj(), RootMdcCalibDataCnv::i_createObj(), RootEstTofCalibDataCnv::i_createObj(), RootEsTimeCalibDataCnv::i_createObj(), RootEmcCalibDataCnv::i_createObj(), i_createObj(), RootDedxCalibDataCnv::i_createObj(), RootCalBaseCnv::openRead(), and RootCalBaseCnv::readRootObj().

IInstrumentName* RootCalBaseCnv::m_instrSvc [protected, inherited]

Definition at line 195 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::initialize().

ICalibMetaCnvSvc* RootCalBaseCnv::m_metaSvc [protected, inherited]

Definition at line 194 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::initialize().

TFile* RootCalBaseCnv::m_outFile [protected, inherited]

Definition at line 204 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::closeWrite(), RootCalBaseCnv::doClean(), and RootCalBaseCnv::openWrite().

ICalibRootSvc* RootCalBaseCnv::m_rootSvc [protected, inherited]

Definition at line 193 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::getCalibRootSvc(), and RootCalBaseCnv::initialize().

int RootCalBaseCnv::m_runfrm [protected, inherited]

Definition at line 200 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::internalCreateObj(), and RootCalBaseCnv::setBaseInfo().

int RootCalBaseCnv::m_runto [protected, inherited]

Definition at line 201 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::internalCreateObj(), and RootCalBaseCnv::setBaseInfo().

TDirectory* RootCalBaseCnv::m_saveDir [protected, inherited]

Definition at line 209 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::closeRead(), RootCalBaseCnv::closeWrite(), RootCalBaseCnv::doClean(), RootCalBaseCnv::openRead(), and RootCalBaseCnv::openWrite().

int RootCalBaseCnv::m_serNo [protected, inherited]

Definition at line 197 of file RootCalBaseCnv.h.

TTree* RootCalBaseCnv::m_ttree [protected, inherited]

Definition at line 205 of file RootCalBaseCnv.h.

Referenced by RootCalBaseCnv::doClean().

ITime* RootCalBaseCnv::m_vend [protected, inherited]

Definition at line 199 of file RootCalBaseCnv.h.

ITime* RootCalBaseCnv::m_vstart [protected, inherited]

Definition at line 198 of file RootCalBaseCnv.h.


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

RootDedxSimDataCnv Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation