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

RootTofSimDataCnv Class Reference

#include <RootTofSimDataCnv.h>

Inheritance diagram for RootTofSimDataCnv:

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

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

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

RootTofSimDataCnv::RootTofSimDataCnv (  ISvcLocator *  svc  ) 
  

00037                                                       :
00038   RootCalBaseCnv(svc, CLID_Calib_TofSim) { 
00039  }

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

00026 {};

Member Function Documentation

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

00046                                        {
00047   return CLID_Calib_TofSim;
00048 }

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 RootTofSimDataCnv::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.

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

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 RootTofSimDataCnv::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.

00051                                                                 {
00052 
00053   MsgStream log(msgSvc(), "RootTofSimDataCnv");
00054   log<<MSG::DEBUG<<"SetProperty"<<endreq;
00055  
00056  // open the file
00057   StatusCode sc = openRead(fname);
00058   if(!sc)
00059     { log<<MSG::ERROR<<"unable to open files"<<endreq;
00060     }
00061  
00062   CalibData::BTofSimBase bTof;
00063   CalibData::ETofSimBase eTof;
00064   CalibData::TofSimConstBase tofbase;
00065   std::vector<CalibData::BTofSimBase> tmpbTof;//; = new vector<CalibData::bTofCalibBase>;
00066   std::vector<CalibData::ETofSimBase> tmpeTof;
00067   std::vector<CalibData::TofSimConstBase> tofbaseCol;
00068    // Read in the object
00069   int cnt;
00070   // read btoftree ------------------------------------------------------------
00071      double AttenLength;
00072      double Gain;
00073      double Ratio;
00074      double NoiseSmear;
00075      TTree *btoftree = (TTree*)m_inFile -> Get("BTofSim");
00076      btoftree -> SetBranchAddress("AttenLength", &AttenLength);
00077      btoftree -> SetBranchAddress("Gain", &Gain);
00078      btoftree -> SetBranchAddress("Ratio", &Ratio);
00079      int entries=btoftree->GetEntries();
00080        for(cnt=0; cnt<entries; cnt++){
00081          btoftree -> GetEntry(cnt);
00082          bTof.setGain(Gain);
00083          bTof.setRatio(Ratio);
00084          bTof.setAttenLength(AttenLength);
00085          tmpbTof.push_back(bTof);
00086           }
00087        //read etoftree
00088      TTree *etoftree = (TTree*)m_inFile -> Get("ETofSim");
00089      etoftree -> SetBranchAddress("Gain", &Gain);
00090      etoftree -> SetBranchAddress("AttenLength", &AttenLength);
00091      etoftree -> SetBranchAddress("NoiseSmear",  &NoiseSmear );
00092        entries=etoftree->GetEntries();
00093        for(cnt=0; cnt<entries; cnt++){
00094          etoftree->GetEntry(cnt);
00095          eTof.setGain(Gain);
00096          eTof.setAttenLength(AttenLength);
00097          eTof.setNoiseSmear(NoiseSmear);
00098          tmpeTof.push_back(eTof);
00099           }
00100 
00101    //read SimConstants
00102     double BarConstant,BarPMTGain,BarHighThres,BarLowThres,EndConstant,EndPMTGain,EndHighThres,EndLowThres,EndNoiseSwitch;
00103     TTree *btofcommontree = (TTree*)m_inFile -> Get("SimConstants");
00104     btofcommontree-> SetBranchAddress("BarConstant", &BarConstant);
00105     btofcommontree-> SetBranchAddress("BarPMTGain",  &BarPMTGain);
00106     btofcommontree-> SetBranchAddress("BarHighThres", &BarHighThres);
00107     btofcommontree-> SetBranchAddress("BarLowThres", &BarLowThres);
00108     btofcommontree-> SetBranchAddress("EndConstant", &EndConstant);
00109     btofcommontree-> SetBranchAddress("EndPMTGain",  &EndPMTGain);
00110     btofcommontree-> SetBranchAddress("EndHighThres", &EndHighThres);
00111     btofcommontree-> SetBranchAddress("EndLowThres", &EndLowThres);
00112     btofcommontree-> SetBranchAddress("EndNoiseSwitch", &EndNoiseSwitch);
00113        entries = btofcommontree->GetEntries();
00114       for(cnt=0;cnt<entries;cnt++){
00115               btofcommontree->GetEntry(cnt);
00116               tofbase.setBarLowThres(BarLowThres);
00117               tofbase.setBarHighThres(BarHighThres);
00118               tofbase.setEndLowThres(EndLowThres);
00119               tofbase.setEndHighThres(EndHighThres);
00120               tofbase.setBarPMTGain(BarPMTGain);
00121               tofbase.setEndPMTGain(EndPMTGain); 
00122               tofbase.setBarConstant(BarConstant);
00123               tofbase.setEndConstant(EndConstant); 
00124               tofbase.setEndNoiseSwitch(EndNoiseSwitch); 
00125               tofbaseCol.push_back(tofbase);   
00126      }
00127 
00128      CalibData::TofSimData *tmpObject = new CalibData::TofSimData(&tofbaseCol,&tmpbTof,&tmpeTof);
00129 
00130   
00131       refpObject=tmpObject;
00132 
00133   return StatusCode::SUCCESS;
00134 }

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 & RootTofSimDataCnv::objType (   )  const
  

00042                                              {
00043   return CLID_Calib_TofSim;
00044 }

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 RootTofSimDataCnv::repSvcType (   )  const [inline, virtual]
  

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. 

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<RootTofSimDataCnv> [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:16 2011 for BOSS6.5.5 by  doxygen 1.3.9.1