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

TreeDedxCalibDataCnv Class Reference

#include <TreeDedxCalibDataCnv.h>

Inheritance diagram for TreeDedxCalibDataCnv:

TreeCalBaseCnv 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 ()
ICalibTreeSvcgetCalibTreeSvc ()
virtual StatusCode initialize ()
const CLID & objType () const
destinationoperator (const source &) const
destinationoperator (const source &) const
virtual long repSvcType () const
 TreeDedxCalibDataCnv (ISvcLocator *svc)
virtual ~TreeDedxCalibDataCnv ()

Static Public Member Functions

const CLID & classID ()
const unsigned char storageType ()

Protected Member Functions

virtual destinationconvert (const source &) const =0
virtual destinationconvert (const source &) const =0
virtual StatusCode fillRoot (CalibData::CalibBase *pTDSObj, TObject *pRootObj)
virtual StatusCode i_createObj (IOpaqueAddress *address, 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 (DataObject *&refpObject, IOpaqueAddress *address)
void setBaseInfo (CalibData::CalibBase1 *pObj)
 Another utility for derived classes to use.

Protected Attributes

TFile * m_inFile
IInstrumentNamem_instrSvc
ICalibMetaCnvSvcm_metaSvc
TFile * m_outFile
int m_runfrm
int m_runto
TDirectory * m_saveDir
int m_serNo
ICalibTreeSvcm_treeSvc
TTree * m_ttree

Friends

class CnvFactory<TreeDedxCalibDataCnv>

Detailed Description

Base class for CAL calibration converters from Ttrees to TCDS. All such converters need to do certain things, which are handled here. Methods common to *all* calibrations are in the base class TreeCalBaseCnv

Author:
huang bin


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

TreeDedxCalibDataCnv::TreeDedxCalibDataCnv ISvcLocator *  svc  ) 
 

00031                                                             :
00032   TreeCalBaseCnv(svc, CLID_Calib_DedxCal) { 
00033 
00034 }

virtual TreeDedxCalibDataCnv::~TreeDedxCalibDataCnv  )  [inline, virtual]
 

00029 {};


Member Function Documentation

const CLID & TreeDedxCalibDataCnv::classID  )  [static]
 

00041                                           {
00042   return CLID_Calib_DedxCal;
00043 }

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

00108                                                            {
00109   //  StatusCode ret;
00110 
00111   // first do the things we always need:
00112   //   First string parameter of opaque address is file ident
00113   MsgStream log(msgSvc(), "TreeCalBaseCnv");
00114    log << MSG::DEBUG<<"TreeCalBaseCnv::createObj( starting ...."<<endreq;
00115  //  const std::string* par = addr->par();
00116 
00117  // std::string par0 = par[0];
00118    
00119 //  return internalCreateObj(par0, refpObject, addr);
00120   return internalCreateObj(refpObject, addr);
00121 
00122 }

StatusCode TreeCalBaseCnv::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
00086                                                                        {
00087   MsgStream log(msgSvc(), "TreeCalBaseCnv");
00088   log << MSG::ERROR 
00089       << "createRoot method not implemented for this calibration type" 
00090       << endreq;
00091   return StatusCode::FAILURE;
00092 }

StatusCode TreeCalBaseCnv::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
00097                                                           {
00098 
00099   // Get instrument name from InstrumentName service  Now handled by 
00100   // TreeCalBaseCnv
00101   //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
00102   //  pRootObj->setInstrument(instr);
00103   return StatusCode::SUCCESS;
00104 }

StatusCode TreeCalBaseCnv::finalize  )  [virtual, inherited]
 

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

ICalibTreeSvc* TreeCalBaseCnv::getCalibTreeSvc  )  [inline, inherited]
 

00057                                    {
00058     return m_treeSvc;
00059   }

StatusCode TreeDedxCalibDataCnv::i_createObj IOpaqueAddress *  address,
DataObject *&  refpObject
[protected, virtual]
 

This creates the transient representation of an object from the corresponding ROOT object. This actually does the "new" operation and deals with the attributes of the node. This base class implementation does nothing; it should not normally be called because it doesn't correspond to any TCDS class. Instead, i_createObj of some derived class will be called.

Parameters:
fname The ROOT file to be read in to be used to builds the object
refpObject the object to be built
Returns:
status depending on the completion of the call

Reimplemented from TreeCalBaseCnv.

00046                                                                 {
00047 
00048   MsgStream log(msgSvc(), "TreeDedxCalibDataCnv");
00049   log<<MSG::DEBUG<<"SetProperty"<<endreq;
00050 
00051   CalibData::DedxCalibData *tmpObject = new CalibData::DedxCalibData;
00052  TreeAddress* add = dynamic_cast<TreeAddress*>(addr);
00053   DatabaseRecord *records=add->pp();
00054 
00055  TBuffer *buf1 = new TBuffer(TBuffer::kRead);
00056  TBuffer *buf2 = new TBuffer(TBuffer::kRead);
00057  TBuffer *buf3 = new TBuffer(TBuffer::kRead);
00058  TBuffer *buf4 = new TBuffer(TBuffer::kRead);
00059  TBuffer *buf5 = new TBuffer(TBuffer::kRead);
00060  TBuffer *buf6 = new TBuffer(TBuffer::kRead);
00061  TBuffer *buf7 = new TBuffer(TBuffer::kRead);
00062  TBuffer *buf8 = new TBuffer(TBuffer::kRead);
00063  TBuffer *buf9 = new TBuffer(TBuffer::kRead);
00064 
00065  buf1->SetBuffer((*records)["DriftDist"],512000,kFALSE);
00066  buf2->SetBuffer((*records)["EntranceAng"],512000,kFALSE);
00067  buf3->SetBuffer((*records)["MeanGain"],512000,kFALSE);
00068  buf4->SetBuffer((*records)["GasGain"],512000,kFALSE);
00069  buf5->SetBuffer((*records)["LayerGain"],512000,kFALSE);
00070  buf6->SetBuffer((*records)["Resolution"],512000,kFALSE);
00071  buf7->SetBuffer((*records)["WireGain"],512000,kFALSE);
00072  buf8->SetBuffer((*records)["ZDep"],512000,kFALSE);
00073  buf9->SetBuffer((*records)["RunGain"],512000,kFALSE);
00074 
00075 
00076 
00077 
00078  std::cout<<" CalVerSft is "<<(*records)["CalParVer"];
00079  std::cout<<"  File name  is "<<(*records)["FileName"]<<std::endl;
00080 
00081 
00082 
00083   TTree* ddgtree = new TTree(); 
00084   ddgtree->Streamer(*buf1); 
00085  
00086   TTree* entratree = new TTree(); 
00087   entratree->Streamer(*buf2);
00088 
00089   TTree* gaintree= new TTree(); 
00090   gaintree->Streamer(*buf3); 
00091 
00092   TTree* ggstree = new TTree(); 
00093   ggstree->Streamer(*buf4); 
00094 
00095   TTree* layergtree = new TTree(); 
00096   layergtree->Streamer(*buf5); 
00097 
00098   TTree* resoltree = new TTree(); 
00099   resoltree->Streamer(*buf6); 
00100 
00101   TTree* wiregtree = new TTree(); 
00102   wiregtree->Streamer(*buf7); 
00103 
00104   TTree* zdeptree = new TTree(); 
00105   zdeptree->Streamer(*buf8); 
00106 
00107   TTree *rungtree = new TTree();
00108   rungtree->Streamer(*buf9);
00109 
00110   double rungain;
00111   double runmean;
00112   int runno;
00113   double runresol;
00114 
00115   rungtree -> SetBranchAddress("rungain", &rungain);
00116   rungtree -> SetBranchAddress("runmean", &runmean);
00117   rungtree -> SetBranchAddress("runno", &runno);
00118   rungtree -> SetBranchAddress("runresol", &runresol);
00119   int N = rungtree -> GetEntries();
00120   tmpObject -> setrunNO(N);
00121   for(int i=0; i<N; i++){
00122        rungtree -> GetEntry(i);
00123        tmpObject -> setrung(rungain,0,i);
00124        tmpObject -> setrung(runmean,1,i);
00125        tmpObject -> setrung(runno,2,i);
00126        tmpObject -> setrung(runresol,3,i);
00127           }
00128 
00129     
00130      double ddg0[43];
00131      double ddg1[43];
00132      double ddg2[43];
00133      double ddg3[43];
00134      double id_doca[1600];
00135      double iner_chi[1600];
00136      double iner_gain[1600]; 
00137      double iner_hits[1600]; 
00138      double ip_eangle[1600]; 
00139      double out_chi[1600];
00140      double out_gain[1600];
00141      double out_hits[1600];
00142 
00143      ddgtree -> SetBranchAddress("ddg0", ddg0);
00144      ddgtree -> SetBranchAddress("ddg1", ddg1);
00145      ddgtree -> SetBranchAddress("ddg2", ddg2);
00146      ddgtree -> SetBranchAddress("ddg3", ddg3);
00147      TBranch *bbb = ddgtree->FindBranch("Id_doca");
00148      if(bbb){
00149         ddgtree -> SetBranchAddress("Id_doca", id_doca);
00150         ddgtree -> SetBranchAddress("Iner_chi", iner_chi);
00151         ddgtree -> SetBranchAddress("Iner_gain", iner_gain);
00152         ddgtree -> SetBranchAddress("Iner_hits", iner_hits);
00153         ddgtree -> SetBranchAddress("Ip_eangle", ip_eangle);
00154         ddgtree -> SetBranchAddress("Out_chi", out_chi);
00155         ddgtree -> SetBranchAddress("Out_gain", out_gain);
00156         ddgtree -> SetBranchAddress("Out_hits", out_hits);
00157      }
00158 
00159       ddgtree -> GetEntry(0);
00160         for(int i=0; i<43; i++){
00161 
00162              tmpObject -> setddg(ddg0[i],0,i);
00163              tmpObject -> setddg(ddg1[i],1,i);
00164              tmpObject -> setddg(ddg2[i],2,i);
00165              tmpObject -> setddg(ddg3[i],3,i);
00166           }
00167   
00168       for(int i=0; i<1600; i++){
00169          if(!bbb){
00170             id_doca[i]=0;
00171             iner_chi[i]=0;
00172             iner_gain[i]=0;
00173             iner_hits[i]=0;
00174             ip_eangle[i]=0;
00175             out_chi[i]=0;
00176             out_gain[i]=0;
00177             out_hits[i]=0;
00178          }
00179                 tmpObject -> set_id_doca(id_doca[i],i);
00180                 tmpObject -> set_iner_chi(iner_chi[i],i);
00181                 tmpObject -> set_iner_gain(iner_gain[i],i);
00182                 tmpObject -> set_iner_hits(iner_hits[i],i);
00183                 tmpObject -> set_ip_eangle(ip_eangle[i],i);
00184                 tmpObject -> set_out_chi(out_chi[i],i);
00185                 tmpObject -> set_out_gain(out_gain[i],i);
00186                 tmpObject -> set_out_hits(out_hits[i],i);
00187         }
00188  
00189  
00190      double entra0[43];
00191      double entra1[43];
00192      double entra2[43];
00193      double entra3[43];
00194      double engle[100];
00195      int engle_no;
00196      entratree -> SetBranchAddress("entra0", entra0);
00197      entratree -> SetBranchAddress("entra1", entra1);
00198      entratree -> SetBranchAddress("entra2", entra2);
00199      entratree -> SetBranchAddress("entra3", entra3);
00200      entratree -> SetBranchAddress("1denangle", engle);
00201      entratree -> SetBranchAddress("1denangle_entry", &engle_no);
00202        entratree -> GetEntry(0);
00203         for(int i=0; i<43; i++){
00204              tmpObject -> setenta(entra0[i],0,i);
00205              tmpObject -> setenta(entra1[i],1,i);
00206              tmpObject -> setenta(entra2[i],2,i);
00207              tmpObject -> setenta(entra3[i],3,i);
00208           }
00209 
00210     tmpObject -> set_enanglesize(engle_no);
00211       for(int i=0; i<engle_no; i++){
00212              tmpObject -> set_enangle(engle[i],i);
00213           }
00214 
00215 
00216 
00217 
00218 // read ggscalib ------------------------------------------------------------
00219      double ggs0[43];
00220      double ggs1[43];
00221      double ggs2[43];
00222      double ggs3[43];
00223      double gcostheta[80];
00224      int hadron_entry;
00225      double hadron[20];
00226      ggstree -> SetBranchAddress("ggs0", ggs0);
00227      ggstree -> SetBranchAddress("ggs1", ggs1);
00228      ggstree -> SetBranchAddress("ggs2", ggs2);
00229      ggstree -> SetBranchAddress("ggs3", ggs3);
00230      ggstree -> SetBranchAddress("hadron", hadron);
00231      ggstree -> SetBranchAddress("hadronNo", &hadron_entry);
00232      if(bbb){
00233      ggstree -> SetBranchAddress("costheta", gcostheta);}
00234      ggstree -> GetEntry(0);
00235       for(int i=0; i<43;i++){
00236            tmpObject -> setggs(ggs0[i],0,i);
00237            tmpObject -> setggs(ggs1[i],1,i);
00238            tmpObject -> setggs(ggs2[i],2,i);
00239            tmpObject -> setggs(ggs3[i],3,i);
00240           }
00241       for(int i=0; i<80;i++){
00242            if(!bbb) gcostheta[i]=0;
00243            tmpObject ->set_costheta(gcostheta[i],i);
00244          }
00245      if(hadron_entry>20){
00246        log<<MSG::FATAL<<"hadron entry is larger than 20, larger than designed"<<endreq;
00247        return StatusCode::FAILURE;
00248       }
00249      tmpObject->set_hadronNo(hadron_entry);
00250      for(int i=0;i<hadron_entry;i++){
00251           tmpObject->set_hadron(hadron[i],i);
00252         }
00253 
00254  
00255 // read zdepcalib ------------------------------------------------------------
00256      double zdep0[43];
00257      double zdep1[43];
00258      double zdep2[43];
00259      double zdep3[43];
00260      zdeptree -> SetBranchAddress("zdep0", zdep0);
00261      zdeptree -> SetBranchAddress("zdep1", zdep1);
00262      zdeptree -> SetBranchAddress("zdep2", zdep2);
00263      zdeptree -> SetBranchAddress("zdep3", zdep3);
00264      zdeptree -> GetEntry(0);
00265 
00266      for(int i=0; i<43;i++){
00267            tmpObject -> setzdep(zdep0[i],0,i);
00268            tmpObject -> setzdep(zdep1[i],1,i);
00269            tmpObject -> setzdep(zdep2[i],2,i);
00270            tmpObject -> setzdep(zdep3[i],3,i);
00271           }
00272 // read gain ------------------------------------------------------------
00273      double gain;
00274      double gt0[35],gdedx[35];
00275      gaintree -> SetBranchAddress("gain", &gain);
00276      if(bbb){
00277      gaintree -> SetBranchAddress("t0",   gt0);
00278      gaintree -> SetBranchAddress("dedx", gdedx);}
00279            gaintree -> GetEntry(0);
00280            tmpObject -> setgain(gain);
00281      for(int i=0; i<35;i++){
00282       if(!bbb){
00283          gt0[i]=0;
00284          gdedx[i]=0;
00285       }
00286       tmpObject->set_t0(gt0[i],i);
00287       tmpObject->set_dedx(gdedx[i],i);
00288       }
00289 
00290 // read resol----------------------------------------------------------------
00291      double resol;
00292      resoltree -> SetBranchAddress("resol", &resol);
00293            resoltree -> GetEntry(0);
00294            tmpObject -> setresol(resol);
00295     
00296 // read wireg----------------------------------------------------------------
00297      double wireg[6796];
00298      wiregtree -> SetBranchAddress("wireg",wireg);
00299     wiregtree -> GetEntry(0);
00300      for(int i=0;i<6796;i++){
00301            if(wireg[i]>5||wireg[i]<0.2) wireg[i]=0;
00302            tmpObject -> setwireg(wireg[i],i);
00303      }
00304  
00305 // read layerg----------------------------------------------------------------
00306      double layerg[43];
00307      layergtree -> SetBranchAddress("layerg",layerg);
00308     layergtree -> GetEntry(0);
00309 
00310      for(int i=0;i<43;i++){
00311             tmpObject -> setlayerg(layerg[i],i);
00312      }
00313 
00314 
00315 
00316     // Read in the object
00317 
00318   
00319       refpObject=tmpObject;
00320 
00321    delete ddgtree;
00322   delete entratree;
00323   delete gaintree;
00324   delete ggstree;
00325   delete layergtree;
00326   delete resoltree;
00327   delete wiregtree;
00328   delete zdeptree;
00329   delete rungtree;
00330 
00331   return StatusCode::SUCCESS;
00332 
00333 
00334 }

StatusCode TreeCalBaseCnv::i_processObj DataObject *  pObject,
IOpaqueAddress *  address
[protected, virtual, inherited]
 

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

00184                                                                       {
00185   return StatusCode::SUCCESS;
00186 }

StatusCode TreeCalBaseCnv::initialize  )  [virtual, inherited]
 

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

StatusCode TreeCalBaseCnv::internalCreateObj 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
00128                                                                    {
00129 
00130   MsgStream log(msgSvc(), "TreeCalBaseCnv");
00131    log << MSG::DEBUG<<"TreeCalBaseCnv::internalCreateObj( starting ..... "<<endreq;
00132    TreeCalBaseCnv* converter = this;
00133   CLID classId = address->clID();
00134 
00135   IConverter* conv = this->conversionSvc()->converter(classId);
00136   if (0 == conv) {
00137     log << MSG::WARNING
00138         << "No proper converter found for classID " << classId
00139             << ", the default converter"
00140             << " will be used. " << endreq;
00141   } else {
00142     converter = dynamic_cast <TreeCalBaseCnv*> (conv);
00143     if (0 == converter) {
00144       log << MSG::ERROR
00145           << "The converter found for classID " << classId
00146               << " was not a descendent of TreeCalBaseCnv as it should be "
00147               << "( was of type " << typeid (*converter).name() << "). "
00148               << "The default converter will be used" << endreq;
00149       converter = this;
00150     }
00151   }
00152 
00153     m_runfrm =*( address->ipar());
00154     m_runto =*( address->ipar()+1);
00155  //   m_runfrm = 100;
00156  //   m_runto =1000;
00157    // creates an object for the node found
00158    StatusCode sc = converter->i_createObj(address, refpObject);
00159      if (sc.isFailure()) {
00160     return sc;
00161   } 
00162      CalibData::CalibBase1* tmpObject =  dynamic_cast <CalibData::CalibBase1*> (refpObject);
00163      setBaseInfo(tmpObject);
00164   // ends up the object construction
00165   sc = converter->i_processObj(refpObject, address);
00166   if (sc.isSuccess()) {
00167     log << MSG::DEBUG << "Successfully created calib. object " << endreq;
00168   }
00169  // closeRead();
00170   return sc;
00171 }

const CLID & TreeDedxCalibDataCnv::objType  )  const
 

00037                                                 {
00038   return CLID_Calib_DedxCal;
00039 }

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]
 

virtual long TreeDedxCalibDataCnv::repSvcType  )  const [inline, virtual]
 

00034                                   { 
00035           return CALIBTREE_StorageType; 
00036       } 

void TreeCalBaseCnv::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.

00189                                                           {
00190    MsgStream log(msgSvc(), "TreeCalBaseCnv");
00191    log << MSG::DEBUG<<"set the runfrm and runto Numbers in the converter"<<endreq;
00192   pObj->setrunfrm(m_runfrm);
00193   pObj->setrunto(m_runto);
00194 }

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

00061 {return CALIBTREE_StorageType;}


Friends And Related Function Documentation

friend class CnvFactory<TreeDedxCalibDataCnv> [friend]
 


Member Data Documentation

TFile* TreeCalBaseCnv::m_inFile [protected, inherited]
 

IInstrumentName* TreeCalBaseCnv::m_instrSvc [protected, inherited]
 

ICalibMetaCnvSvc* TreeCalBaseCnv::m_metaSvc [protected, inherited]
 

TFile* TreeCalBaseCnv::m_outFile [protected, inherited]
 

int TreeCalBaseCnv::m_runfrm [protected, inherited]
 

int TreeCalBaseCnv::m_runto [protected, inherited]
 

TDirectory* TreeCalBaseCnv::m_saveDir [protected, inherited]
 

int TreeCalBaseCnv::m_serNo [protected, inherited]
 

ICalibTreeSvc* TreeCalBaseCnv::m_treeSvc [protected, inherited]
 

TTree* TreeCalBaseCnv::m_ttree [protected, inherited]
 


The documentation for this class was generated from the following files:
Generated on Wed Feb 2 19:04:10 2011 for BOSS6.5.5 by  doxygen 1.3.9.1