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

TreeTofCalibDataCnv Class Reference

#include <TreeTofCalibDataCnv.h>

Inheritance diagram for TreeTofCalibDataCnv:

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 ()
ICalibTreeSvc * getCalibTreeSvc ()
virtual StatusCode initialize ()
const CLID & objType () const
destination * operator (const source &) const
destination * operator (const source &) const
virtual long repSvcType () const
 TreeTofCalibDataCnv (ISvcLocator *svc)
virtual ~TreeTofCalibDataCnv ()

Static Public Member Functions

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

Protected Member Functions

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 (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
IInstrumentName * m_instrSvc
ICalibMetaCnvSvc * m_metaSvc
TFile * m_outFile
int m_runfrm
int m_runto
TDirectory * m_saveDir
int m_serNo
ICalibTreeSvc * m_treeSvc
TTree * m_ttree

Friends

class CnvFactory<TreeTofCalibDataCnv>

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

TreeTofCalibDataCnv::TreeTofCalibDataCnv (  ISvcLocator *  svc  ) 
  

00044                                                           :
00045   TreeCalBaseCnv(svc, CLID_Calib_TofCal) { 
00046 
00047 }

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

00029 {};

Member Function Documentation

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

00054                                          {
00055   return CLID_Calib_TofCal;
00056 }

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

00059                                                                 {
00060 
00061   MsgStream log(msgSvc(), "TreeTofCalibDataCnv");
00062   log<<MSG::DEBUG<<"SetProperty"<<endreq;
00063   
00064   TreeAddress* add = dynamic_cast<TreeAddress*>(addr);
00065    
00066   DatabaseRecord *records=add->pp();
00067 
00068   TBuffer *buf1 = new TBuffer(TBuffer::kRead);
00069   TBuffer *buf2 = new TBuffer(TBuffer::kRead);
00070   TBuffer *buf3 = new TBuffer(TBuffer::kRead);
00071   TBuffer *buf4 = new TBuffer(TBuffer::kRead);
00072  
00073   buf1->SetBuffer((*records)["BarTofPar"],512000,kFALSE);
00074   buf2->SetBuffer((*records)["EndTofPar"],512000,kFALSE);
00075   buf3->SetBuffer((*records)["TofConPar"],512000,kFALSE);
00076   buf4->SetBuffer((*records)["BarTof"],512000,kFALSE);
00077 
00078   std::cout<<" CalVerSft is "<<(*records)["CalParVer"];
00079   std::cout<<"  File name  is "<<(*records)["FileName"]<<std::endl;
00080   
00081   TTree *btoftree= new TTree();
00082   TTree *etoftree= new TTree();
00083   TTree *btofcommontree = new TTree();
00084   TTree *CalibInfo = new TTree();
00085 
00086   btoftree->Streamer(*buf1);
00087   etoftree->Streamer(*buf2);
00088   btofcommontree->Streamer(*buf3);
00089   CalibInfo->Streamer(*buf4);
00090    
00091   int  nentri = btoftree -> GetEntries();
00092   int  nentri1 = etoftree -> GetEntries();
00093   int  nentri2 = btofcommontree->GetEntries();
00094   int  nentri3 = CalibInfo->GetEntries();
00095 
00096   CalibData::bTofCalibBase bTof;
00097   CalibData::eTofCalibBase eTof;
00098   CalibData::bTofCommonCalibBase bTofCommon;
00099   CalibData::tofCalibInfoBase tofinfo;
00100   
00101   std::vector<CalibData::bTofCalibBase> tmpbTof;
00102   std::vector<CalibData::eTofCalibBase> tmpeTof;
00103   std::vector<CalibData::bTofCommonCalibBase> tmpbTofCommon;
00104   std::vector<CalibData::tofCalibInfoBase> tofinfoCol;
00105   
00106   // Read in the object
00107   int cnt;
00108   // read btoftree ------------------------------------------------------------
00109   double cnvBarAtten[nBarAtten];
00110   double cnvBarSpeed[nBarSpeed];
00111   double cnvBarPar1[nBarPar];
00112   double cnvBarPar2[nBarPar];
00113   double cnvBarParOff1[nBarParOff];
00114   double cnvBarParOff2[nBarParOff];
00115   double cnvFLeft[nBarSigma];
00116   double cnvFRight[nBarSigma];
00117   double cnvFCount[nBarSigCnt];
00118   
00119   char brname[10];
00120   for( unsigned int i=0; i<nBarAtten; i++ ) {
00121     sprintf( brname, "Atten%i", i );
00122     btoftree -> SetBranchAddress( brname, &cnvBarAtten[i] );    
00123   }
00124   for( unsigned int i=0; i<nBarSpeed; i++ ) {
00125     sprintf( brname, "Speed%i", i );
00126     btoftree -> SetBranchAddress( brname, &cnvBarSpeed[i] );    
00127   }
00128   for( unsigned int i=0; i<nBarPar; i++ ) {
00129     sprintf( brname, "P%i", i );
00130     btoftree -> SetBranchAddress( brname, &cnvBarPar1[i] );    
00131   }
00132   for( unsigned int i=0; i<nBarPar; i++ ) {
00133     sprintf( brname, "P%i", i+nBarPar );
00134     btoftree -> SetBranchAddress( brname, &cnvBarPar2[i] );    
00135   }
00136   for( unsigned int i=0; i<nBarParOff; i++ ) {
00137     sprintf( brname, "Poff%i", i );
00138     btoftree -> SetBranchAddress( brname, &cnvBarParOff1[i] );    
00139   }
00140   for( unsigned int i=0; i<nBarParOff; i++ ) {
00141     sprintf( brname, "Poff%i", i+nBarParOff );
00142     btoftree -> SetBranchAddress( brname, &cnvBarParOff2[i] );    
00143   }
00144   for( unsigned int i=0; i<nBarSigma; i++ ) {
00145     sprintf( brname, "FLeft%i", i );
00146     btoftree -> SetBranchAddress( brname, &cnvFLeft[i] );    
00147   }
00148   for( unsigned int i=0; i<nBarSigma; i++ ) {
00149     sprintf( brname, "FRight%i", i );
00150     btoftree -> SetBranchAddress( brname, &cnvFRight[i] );    
00151   }
00152   for( unsigned int i=0; i<nBarSigCnt; i++ ) {
00153     sprintf( brname, "FCounter%i", i );
00154     btoftree -> SetBranchAddress( brname, &cnvFCount[i] );    
00155   }
00156 
00157   for(cnt=0; cnt<176; cnt++){
00158     btoftree -> GetEntry(cnt);
00159     bTof.setAtten( cnvBarAtten );
00160     bTof.setSpeed( cnvBarSpeed );
00161     bTof.setP1( cnvBarPar1 );
00162     bTof.setP2( cnvBarPar2 );
00163     bTof.setPoff1( cnvBarParOff1 );
00164     bTof.setPoff2( cnvBarParOff2 );
00165     bTof.setFPleft( cnvFLeft );
00166     bTof.setFPright( cnvFRight );
00167     bTof.setFPcounter( cnvFCount );
00168     tmpbTof.push_back(bTof);
00169   }
00170   
00171   //read etoftree
00172   double cnvEndAtten[nEndAtten];
00173   double cnvEndSpeed[nEndSpeed];
00174   double cnvEndPar[nEndPar];
00175   double cnvEndFPar[nEndSigma];
00176 
00177   char ecname[10];
00178   for( unsigned int i=0; i<nEndAtten; i++ ) {
00179     sprintf( ecname, "Atten%i", i );
00180     etoftree -> SetBranchAddress( ecname, &cnvEndAtten[i] );
00181   }
00182   for( unsigned int i=0; i<nEndSpeed; i++ ) {
00183     sprintf( ecname, "Speed%i", i );
00184     etoftree -> SetBranchAddress( ecname, &cnvEndSpeed[i] );
00185   }
00186   for( unsigned int i=0; i<nEndPar; i++ ) {
00187     sprintf( ecname, "P%i", i );
00188     etoftree -> SetBranchAddress( ecname, &cnvEndPar[i] );
00189   }
00190   for( unsigned int i=0; i<nEndSigma; i++ ) {
00191     sprintf( ecname, "FCounter%i", i );
00192     etoftree -> SetBranchAddress( ecname, &cnvEndFPar[i] );
00193   }
00194 
00195   for(cnt=0; cnt<96; cnt++){
00196     etoftree -> GetEntry(cnt);
00197     eTof.setAtten( cnvEndAtten );
00198     eTof.setSpeed( cnvEndSpeed );
00199     eTof.setP( cnvEndPar );
00200     eTof.setFP( cnvEndFPar );
00201     tmpeTof.push_back(eTof);
00202   }
00203 
00204   //read bTofCommonCalibBase
00205   double cnvBarSigCor[nBarSigCor];
00206   double cnvBarOffset[nBarOffset];
00207   for( unsigned int i=0; i<nBarSigCor; i++ ) {
00208     sprintf( brname, "sigmaCorr%i", i );
00209     btofcommontree-> SetBranchAddress( brname, &cnvBarSigCor[i] );
00210   }
00211   for( unsigned int i=0; i<nBarOffset; i++ ) {
00212     sprintf( brname, "t0offset%i", i );
00213     btofcommontree-> SetBranchAddress( brname, &cnvBarOffset[i]);
00214   }
00215 
00216   int entries = btofcommontree->GetEntries();
00217   for(cnt=0;cnt<entries;cnt++){
00218     btofcommontree->GetEntry(cnt);
00219     bTofCommon.setSigmaCorr( cnvBarSigCor );
00220     bTofCommon.setOffset( cnvBarOffset );
00221     tmpbTofCommon.push_back(bTofCommon);
00222   }
00223 
00224   int m_run1, m_run2, m_version;
00225   int m_qCorr, m_qElec, m_misLable;
00226   int m_tofidEast[5], m_tofidWest[5], m_tofidEndcap[5];
00227   
00228   // TTree *CalibInfo = (TTree*)m_inFile -> Get("CalibInfo");
00229   CalibInfo->SetBranchAddress("Run1",&m_run1);
00230   CalibInfo->SetBranchAddress("Run2",&m_run2);
00231   CalibInfo->SetBranchAddress("Version",&m_version);
00232   CalibInfo->SetBranchAddress("ebrId0",&m_tofidEast[0]);
00233   CalibInfo->SetBranchAddress("ebrId1",&m_tofidEast[1]);
00234   CalibInfo->SetBranchAddress("ebrId2",&m_tofidEast[2]);
00235   CalibInfo->SetBranchAddress("ebrId3",&m_tofidEast[3]);
00236   CalibInfo->SetBranchAddress("ebrId4",&m_tofidEast[4]);
00237   CalibInfo->SetBranchAddress("ecId0",&m_tofidEndcap[0]);
00238   CalibInfo->SetBranchAddress("ecId1",&m_tofidEndcap[1]);
00239   CalibInfo->SetBranchAddress("ecId2",&m_tofidEndcap[2]);
00240   CalibInfo->SetBranchAddress("ecId3",&m_tofidEndcap[3]);
00241   CalibInfo->SetBranchAddress("ecId4",&m_tofidEndcap[4]);
00242   CalibInfo->SetBranchAddress("wbrId0",&m_tofidWest[0]);
00243   CalibInfo->SetBranchAddress("wbrId1",&m_tofidWest[1]);
00244   CalibInfo->SetBranchAddress("wbrId2",&m_tofidWest[2]);
00245   CalibInfo->SetBranchAddress("wbrId3",&m_tofidWest[3]);
00246   CalibInfo->SetBranchAddress("wbrId4",&m_tofidWest[4]);
00247   CalibInfo->SetBranchAddress("misLable",&m_misLable);
00248   CalibInfo->SetBranchAddress("qCorr",&m_qCorr);
00249   CalibInfo->SetBranchAddress("qElec",&m_qElec);
00250   
00251   entries= CalibInfo->GetEntries();
00252   for(cnt=0;cnt<entries;cnt++){
00253     CalibInfo->GetEntry(cnt);
00254     tofinfo.setRunBegin(m_run1);
00255     tofinfo.setRunEnd(m_run2);
00256     tofinfo.setVersion(m_version);
00257     tofinfo.setQCorr(m_qCorr);
00258     tofinfo.setQElec(m_qElec);
00259     tofinfo.setMisLable(m_misLable);
00260     tofinfo.setBrEast(m_tofidEast);
00261     tofinfo.setBrWest(m_tofidWest);
00262     tofinfo.setEndcap(m_tofidEndcap);
00263     tofinfoCol.push_back(tofinfo);
00264   }
00265   
00266   CalibData::TofCalibData *tmpObject = new CalibData::TofCalibData(&tmpbTof,&tmpbTofCommon,&tmpeTof,&tofinfoCol);
00267  
00268   refpObject=tmpObject;
00269   delete btoftree;
00270   delete etoftree;
00271   delete btofcommontree;
00272   delete CalibInfo;
00273     
00274   return StatusCode::SUCCESS;
00275 }

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

00050                                                {
00051   return CLID_Calib_TofCal;
00052 }

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