RootDedxCalibDataCnv Class Reference

#include <RootDedxCalibDataCnv.h>

Inheritance diagram for RootDedxCalibDataCnv:

List of all members.

Public Types
typedef Ty1	source
typedef Ty2	destination
Public Member Functions
const CLID &	objType () const
	RootDedxCalibDataCnv (ISvcLocator *svc)
virtual	~RootDedxCalibDataCnv ()
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< RootDedxCalibDataCnv >

---

Detailed Description

Definition at line 20 of file RootDedxCalibDataCnv.h.

---

Member Typedef Documentation

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.

---

Constructor & Destructor Documentation

RootDedxCalibDataCnv::RootDedxCalibDataCnv

(

ISvcLocator *

svc

)

Definition at line 35 of file RootDedxCalibDataCnv.cxx.

                                                            :
  RootCalBaseCnv(svc, CLID_Calib_DedxCal) { 
}

virtual RootDedxCalibDataCnv::~RootDedxCalibDataCnv

(

)

[inline, virtual]

Definition at line 29 of file RootDedxCalibDataCnv.h.

{};

---

Member Function Documentation

const CLID & RootDedxCalibDataCnv::classID

(

)

[static]

Definition at line 44 of file RootDedxCalibDataCnv.cxx.

References CLID_Calib_DedxCal.

                                          {
  return CLID_Calib_DedxCal;
}

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().

                                     {
  m_inFile->Close();

  delete m_inFile;
  m_inFile = 0;

  if (m_saveDir) {
    m_saveDir->cd();
    m_saveDir = 0;
  }
  return StatusCode::SUCCESS;
}

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 createRoot().

                                      {

  MsgStream log(msgSvc(), "RootCalBaseCnv");

  StatusCode ret = StatusCode::SUCCESS;

  m_outFile->cd();
  m_outFile->Close();
  delete m_outFile;
  m_outFile = 0;
  if (m_saveDir) m_saveDir->cd();
  m_saveDir = 0;
  return ret;
}

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.

                                                           {
  //  StatusCode ret;

  // first do the things we always need:
  //   First string parameter of opaque address is file ident
  MsgStream log(msgSvc(), "RootCalBaseCnv");
   log << MSG::DEBUG<<"RootCalBaseCnv::createObj( starting ...."<<endreq;
   const std::string* par = addr->par();

  std::string par0 = par[0];
   
  return internalCreateObj(par0, refpObject, addr);

}

StatusCode RootDedxCalibDataCnv::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 290 of file RootDedxCalibDataCnv.cxx.

References RootCalBaseCnv::closeWrite(), calibUtil::ERROR, CalibData::DedxCalibData::getddg(), CalibData::DedxCalibData::getenta(), CalibData::DedxCalibData::getgain(), CalibData::DedxCalibData::getggs(), CalibData::DedxCalibData::getlayerg(), CalibData::DedxCalibData::getresol(), CalibData::DedxCalibData::getrung(), CalibData::DedxCalibData::getrunNO(), CalibData::DedxCalibData::getwireg(), CalibData::DedxCalibData::getzdep(), genRecEmupikp::i, Bes_Common::INFO, msgSvc(), TrigConf::N, RootCalBaseCnv::openWrite(), and check_raw_filter::runno.

                                                                      {
 
  MsgStream log(msgSvc(), "RootDedxCalibDataCnv");

 // Open the file, create the branch
   StatusCode sc = openWrite(fname);
  if(!sc)
    { log<<MSG::ERROR<<"unable to open files"<<endreq;
    }
  // write the Data in the TCDS to RootFile
     int i;
     CalibData::DedxCalibData* tmpObject = dynamic_cast<CalibData::DedxCalibData*>(pTDSObj);
  // write rungcalib ------------------------------------------------------------
     double rungain;
     double runmean;
     double runno;
     double runresol;
     TTree *rungcalibtree = new TTree("rungcalib", "rungCalib");
     rungcalibtree -> Branch("rungain", &rungain, "S/D");
     rungcalibtree -> Branch("runmean", &runmean, "S/D");
     rungcalibtree -> Branch("runno", &runno, "S/D");
     rungcalibtree -> Branch("runresol", &runresol, "S/D");
     int N = tmpObject->getrunNO();
     for(i=0; i<N; i++){
             rungain = tmpObject->getrung(0,i);
             runmean = tmpObject->getrung(1,i);
             runno = tmpObject->getrung(2,i);
             runresol = tmpObject->getrung(3,i);
             rungcalibtree -> Fill();
     } 

 

 // write  ddgcalib----------------------------------------------------------------
     double ddg0;
     double ddg1;
     double ddg2;
     double ddg3;
     TTree *ddgcalibtree = new TTree("ddgcalib", "ddgCalib");
     ddgcalibtree -> Branch("ddg0", &ddg0, "S/D");
     ddgcalibtree -> Branch("ddg1", &ddg1, "S/D");
     ddgcalibtree -> Branch("ddg2", &ddg2, "S/D");
     ddgcalibtree -> Branch("ddg3", &ddg3, "S/D");
     for(i=0; i<43; i++){
               ddg0 = tmpObject->getddg(0,i);
               ddg1 = tmpObject->getddg(1,i);
               ddg2 = tmpObject->getddg(2,i);
               ddg3 = tmpObject->getddg(3,i);
                    ddgcalibtree -> Fill();
     }
 
  // write  ggscalib----------------------------------------------------------------
     double ggs0;
     double ggs1;
     double ggs2;
     double ggs3;
     TTree *ggscalibtree = new TTree("ggscalib", "ggsCalib");
     ggscalibtree -> Branch("ggs0", &ggs0, "S/D");
     ggscalibtree -> Branch("ggs1", &ggs1, "S/D");
     ggscalibtree -> Branch("ggs2", &ggs2, "S/D");
     ggscalibtree -> Branch("ggs3", &ggs3, "S/D");
     for(i=0; i<43; i++){
               ggs0 = tmpObject->getggs(0,i);
               ggs1 = tmpObject->getggs(1,i);
               ggs2 = tmpObject->getggs(2,i);
               ggs3 = tmpObject->getggs(3,i);
                    ggscalibtree -> Fill();
     }

// write  zdepcalib----------------------------------------------------------------
     double zdep0;
     double zdep1;
     double zdep2;
     double zdep3;
     TTree *zdepcalibtree = new TTree("zdepcalib", "zdepCalib");
     zdepcalibtree -> Branch("zdep0", &zdep0, "S/D");
     zdepcalibtree -> Branch("zdep1", &zdep1, "S/D");
     zdepcalibtree -> Branch("zdep2", &zdep2, "S/D");
     zdepcalibtree -> Branch("zdep3", &zdep3, "S/D");
     for(i=0; i<43; i++){
               zdep0 = tmpObject->getzdep(0,i);
               zdep1 = tmpObject->getzdep(1,i);
               zdep2 = tmpObject->getzdep(2,i);
               zdep3 = tmpObject->getzdep(3,i);
                    zdepcalibtree -> Fill();
     }

// write  entacalib----------------------------------------------------------------
     double enta0;
     double enta1;
     double enta2;
     double enta3;
     TTree *entacalibtree = new TTree("entacalib", "entaCalib");
     entacalibtree -> Branch("enta0", &enta0, "S/D");
     entacalibtree -> Branch("enta1", &enta1, "S/D");
     entacalibtree -> Branch("enta2", &enta2, "S/D");
     entacalibtree -> Branch("enta3", &enta3, "S/D");
     for(i=0; i<43; i++){
               enta0 = tmpObject->getenta(0,i);
               enta1 = tmpObject->getenta(1,i);
               enta2 = tmpObject->getenta(2,i);
               enta3 = tmpObject->getenta(3,i);
                    entacalibtree -> Fill();
     }



// write  gain---------------------------------------------------------------------
     double gain;
     TTree *gaintree = new TTree("gaincalib", "gainCalib");
     gaintree -> Branch("gain", &gain, "S/D");
               gain = tmpObject->getgain();
               gaintree -> Fill();

// write  resol---------------------------------------------------------------------
     double resol;
     TTree *resoltree = new TTree("resolcalib", "resolCalib");
     resoltree -> Branch("resol", &resol, "S/D");
               resol = tmpObject->getresol();
               resoltree -> Fill();


// write  wiregcalib----------------------------------------------------------------
     double wireg;
     TTree *wiregcalibtree = new TTree("wiregcalib", "wiregCalib");
     wiregcalibtree -> Branch("wireg", &wireg, "S/D");
     for(i=0; i<6796; i++){
               wireg = tmpObject->getwireg(i);
               wiregcalibtree -> Fill();
     }

// write  layergcalib----------------------------------------------------------------
     double layerg;
     TTree *layergcalibtree = new TTree("layergcalib", "layergCalib");
     layergcalibtree -> Branch("layerg", &layerg, "S/D");
     for(i=0; i<43; i++){
               layerg = tmpObject->getlayerg(i);
               layergcalibtree -> Fill();
     }

//  write all the trees
     rungcalibtree -> Write();
     ddgcalibtree -> Write();
     ggscalibtree -> Write();
     zdepcalibtree -> Write();
     entacalibtree -> Write();
     gaintree -> Write();
     resoltree -> Write();
     wiregcalibtree -> Write();
     layergcalibtree -> Write();
     
     delete rungcalibtree;
     delete ddgcalibtree;
     delete ggscalibtree;
     delete zdepcalibtree;
     delete entacalibtree;
     delete gaintree;
     delete resoltree;
     delete wiregcalibtree;
     delete layergcalibtree;
     closeWrite();
     log<<MSG::INFO<<"successfully create RootFile"<<endreq;
     return sc;

}

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.

                                                          {

  // Get instrument name from InstrumentName service  Now handled by 
  // RootCalBaseCnv
  //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
  //  pRootObj->setInstrument(instr);
  return StatusCode::SUCCESS;
}

StatusCode RootCalBaseCnv::finalize

(

)

[virtual, inherited]

Definition at line 82 of file RootCalBaseCnv.cxx.

                                    {
  return Converter::finalize();
}

ICalibRootSvc* RootCalBaseCnv::getCalibRootSvc

(

)

[inline, inherited]

Definition at line 58 of file RootCalBaseCnv.h.

References RootCalBaseCnv::m_rootSvc.

                                   {
    return m_rootSvc;
  }

StatusCode RootDedxCalibDataCnv::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 RootDedxCalibDataCnv.cxx.

References Bes_Common::DEBUG, calibUtil::ERROR, Bes_Common::FATAL, genRecEmupikp::i, RootCalBaseCnv::m_inFile, msgSvc(), TrigConf::N, RootCalBaseCnv::openRead(), check_raw_filter::runno, CalibData::DedxCalibData::set_costheta(), CalibData::DedxCalibData::set_dedx(), CalibData::DedxCalibData::set_hadron(), CalibData::DedxCalibData::set_hadronNo(), and CalibData::DedxCalibData::set_t0().

                                                                {

  MsgStream log(msgSvc(), "RootDedxCalibDataCnv");
  log<<MSG::DEBUG<<"SetProperty"<<endreq;
   StatusCode sc = openRead(fname);
  if(!sc)
    { log<<MSG::ERROR<<"unable to open files"<<endreq;
    }

CalibData::DedxCalibData *tmpObject = new CalibData::DedxCalibData;
  // Read in our object
  int i;
  // read rungcalib ------------------------------------------------------------
  double rungain;
  double runmean;
  int runno;
  double runresol;
  TTree *rungtree = (TTree*)m_inFile -> Get("runcalib");
  rungtree -> SetBranchAddress("rungain", &rungain);
  rungtree -> SetBranchAddress("runmean", &runmean);
  rungtree -> SetBranchAddress("runno", &runno);
  rungtree -> SetBranchAddress("runresol", &runresol);
  int N = rungtree -> GetEntries();
  tmpObject -> setrunNO(N);
  //std::cout<<"N = "<<N<<std::endl;
  for(i=0; i<N; i++){
       rungtree -> GetEntry(i);
       //std::cout<<rungain<<"     "<<runmean<<"      "<<runno<<"       "<<runresol<<std::endl;
       tmpObject -> setrung(rungain,0,i);
       tmpObject -> setrung(runmean,1,i);
       tmpObject -> setrung(runno,2,i);
       tmpObject -> setrung(runresol,3,i);
          }



   // read ddgcalib ------------------------------------------------------------
     double ddg0[43];
     double ddg1[43];
     double ddg2[43];
     double ddg3[43];
     double id_doca[1600];
     double iner_chi[1600];
     double iner_gain[1600];
     double iner_hits[1600];
     double ip_eangle[1600];
     double out_chi[1600];
     double out_gain[1600];
     double out_hits[1600];

     TTree *ddgtree = (TTree*)m_inFile -> Get("ddgcalib");
     ddgtree -> SetBranchAddress("ddg0", ddg0);
     ddgtree -> SetBranchAddress("ddg1", ddg1);
     ddgtree -> SetBranchAddress("ddg2", ddg2);
     ddgtree -> SetBranchAddress("ddg3", ddg3);
     TBranch *bbb = ddgtree->FindBranch("Id_doca");
    if(bbb){
     ddgtree -> SetBranchAddress("Id_doca", id_doca);
     ddgtree -> SetBranchAddress("Iner_chi", iner_chi);
     ddgtree -> SetBranchAddress("Iner_gain", iner_gain);
     ddgtree -> SetBranchAddress("Iner_hits", iner_hits);
     ddgtree -> SetBranchAddress("Ip_eangle", ip_eangle);
     ddgtree -> SetBranchAddress("Out_chi", out_chi);
     ddgtree -> SetBranchAddress("Out_gain", out_gain);
     ddgtree -> SetBranchAddress("Out_hits", out_hits);
    }
       ddgtree -> GetEntry(0);
        for(i=0; i<43; i++){
             tmpObject -> setddg(ddg0[i],0,i);
             tmpObject -> setddg(ddg1[i],1,i);
             tmpObject -> setddg(ddg2[i],2,i);
             tmpObject -> setddg(ddg3[i],3,i);
          }

        for(i=0; i<1600; i++){
                if(!bbb){
                   id_doca[i]=0;
                   iner_chi[i]=0;
                   iner_gain[i]=0;
                   iner_hits[i]=0;
                   ip_eangle[i]=0;
                   out_chi[i]=0;
                   out_gain[i]=0;
                   out_hits[i]=0;
                  }
                tmpObject -> set_id_doca(id_doca[i],i);
                tmpObject -> set_iner_chi(iner_chi[i],i);
                tmpObject -> set_iner_gain(iner_gain[i],i);
                tmpObject -> set_iner_hits(iner_hits[i],i);
                tmpObject -> set_ip_eangle(ip_eangle[i],i);
                tmpObject -> set_out_chi(out_chi[i],i);
                tmpObject -> set_out_gain(out_gain[i],i);
                tmpObject -> set_out_hits(out_hits[i],i);
        }

// read entratree---------------------------------------------
     double entra0[43];
     double entra1[43];
     double entra2[43];
     double entra3[43];
     double engle[100];
     int engle_no;
     TTree *entratree = (TTree*)m_inFile -> Get("entracalib");
     entratree -> SetBranchAddress("entra0", entra0);
     entratree -> SetBranchAddress("entra1", entra1);
     entratree -> SetBranchAddress("entra2", entra2);
     entratree -> SetBranchAddress("entra3", entra3);
     entratree -> SetBranchAddress("1denangle", engle);
     entratree -> SetBranchAddress("1denangle_entry", &engle_no);
       entratree -> GetEntry(0);
        for(i=0; i<43; i++){
             tmpObject -> setenta(entra0[i],0,i);
             tmpObject -> setenta(entra1[i],1,i);
             tmpObject -> setenta(entra2[i],2,i);
             tmpObject -> setenta(entra3[i],3,i);
          }
    tmpObject -> set_enanglesize(engle_no);
      for(i=0; i<engle_no; i++){
             tmpObject -> set_enangle(engle[i],i);
          }



// read ggscalib ------------------------------------------------------------
     double ggs0[43];
     double ggs1[43];
     double ggs2[43];
     double ggs3[43];
     double gcostheta[80];
     int hadron_entry;
     double hadron[20];
     TTree *ggstree = (TTree*)m_inFile -> Get("ggscalib");
     ggstree -> SetBranchAddress("ggs0", ggs0);
     ggstree -> SetBranchAddress("ggs1", ggs1);
     ggstree -> SetBranchAddress("ggs2", ggs2);
     ggstree -> SetBranchAddress("ggs3", ggs3);
     ggstree -> SetBranchAddress("hadron", hadron);
     ggstree -> SetBranchAddress("hadronNo", &hadron_entry);
     if(bbb){
     ggstree -> SetBranchAddress("costheta", gcostheta);
     }
     ggstree -> GetEntry(0);
      for(i=0; i<43;i++){
           tmpObject -> setggs(ggs0[i],0,i);
           tmpObject -> setggs(ggs1[i],1,i);
           tmpObject -> setggs(ggs2[i],2,i);
           tmpObject -> setggs(ggs3[i],3,i);
          }
     
      for(i=0; i<80;i++){
            if(!bbb) gcostheta[i]=0;
           tmpObject ->set_costheta(gcostheta[i],i);
         }
    
     if(hadron_entry>20){ 
       log<<MSG::FATAL<<"hadron entry is larger than 20, larger than designed"<<endreq;
       return StatusCode::FAILURE;
      }

     tmpObject->set_hadronNo(hadron_entry);

     for(i=0;i<hadron_entry;i++){
          tmpObject->set_hadron(hadron[i],i);     
        }    
  

// read zdepcalib ------------------------------------------------------------
     double zdep0[43];
     double zdep1[43];
     double zdep2[43];
     double zdep3[43];
     TTree *zdeptree = (TTree*)m_inFile -> Get("zdepcalib");
     zdeptree -> SetBranchAddress("zdep0", zdep0);
     zdeptree -> SetBranchAddress("zdep1", zdep1);
     zdeptree -> SetBranchAddress("zdep2", zdep2);
     zdeptree -> SetBranchAddress("zdep3", zdep3);
     zdeptree -> GetEntry(0);

     for(i=0; i<43;i++){
           tmpObject -> setzdep(zdep0[i],0,i);
           tmpObject -> setzdep(zdep1[i],1,i);
           tmpObject -> setzdep(zdep2[i],2,i);
           tmpObject -> setzdep(zdep3[i],3,i);
          }
      
// read gain ------------------------------------------------------------
     double gain;
     double gt0[35],gdedx[35];
     TTree *gaintree = (TTree*)m_inFile -> Get("gaincalib");
     gaintree -> SetBranchAddress("gain", &gain);
     if(bbb){
     gaintree -> SetBranchAddress("t0",   gt0);
     gaintree -> SetBranchAddress("dedx", gdedx);
     }
           gaintree -> GetEntry(0);
           tmpObject -> setgain(gain);
     for(i=0; i<35;i++){
      if(!bbb){
          gt0[i]=0;
          gdedx[i]=0;
       }
      tmpObject->set_t0(gt0[i],i);
      tmpObject->set_dedx(gdedx[i],i);
      }
           
// read resol----------------------------------------------------------------
     double resol;
     TTree *resoltree = (TTree*)m_inFile -> Get("resolcalib");
     resoltree -> SetBranchAddress("resol", &resol);
           resoltree -> GetEntry(0);
           tmpObject -> setresol(resol);
    
// read wireg----------------------------------------------------------------
     double wireg[6796];
     TTree *wiregtree = (TTree*)m_inFile -> Get("wiregcalib");
     wiregtree -> SetBranchAddress("wireg",wireg);
    wiregtree -> GetEntry(0);
     for(i=0;i<6796;i++){
           tmpObject -> setwireg(wireg[i],i);
     }
  
// read layerg----------------------------------------------------------------
     double layerg[43];
     TTree *layergtree = (TTree*)m_inFile -> Get("layergcalib");
     layergtree -> SetBranchAddress("layerg",layerg);
    layergtree -> GetEntry(0);

     for(i=0;i<43;i++){
            tmpObject -> setlayerg(layerg[i],i);
     }
   
    refpObject=tmpObject;
  //  delete pObj;
  // std::cout<<"pObj.m_t0[Cell]="<<*(pObj->gett0()+Cell-1);
  // dynamic_cast<CalibData::Mdct0& >(refpObject);
  //refpObject = pObj;
  // std::cout<<"refObject.m_t0[Cell]="<<*(refpObject->gett0()+Cell-1);
  // refpObject = new  Mdct0(&t0_tmp[0]);
  return StatusCode::SUCCESS;
}

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().

                                                                      {
  return StatusCode::SUCCESS;
}

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.

                                      {
  StatusCode status = Converter::initialize();

  IDataProviderSvc* dp;

  // I guess the service names are assigned in jobOptions?

  /*serviceLocator()->getService ("CalibDataSvc",
                                IID_IDataProviderSvc,
                                (IInterface*&)dp);*/
  serviceLocator()->getService ("CalibDataSvc",
                                IDataProviderSvc::interfaceID(),
                                (IInterface*&)dp);
  setDataProvider(dp);
  
  // Locate the Root Conversion Service
  serviceLocator()->getService ("CalibRootCnvSvc",
                                IID_ICalibRootSvc,
                                (IInterface*&) m_rootSvc);

  // Locate meta conversion service
  // Will anything need to be changed here to accommodate possibility
  // of two concrete implementations of ICalibMetaCnvSvc?  Would
  // have different storage types.  Could specify type desired
  // as job option.  Ditto for name of class?
  serviceLocator()->getService("CalibMySQLCnvSvc", 
                               IID_ICalibMetaCnvSvc,
                                (IInterface*&)m_metaSvc);

  serviceLocator()->getService ("CalibDataSvc",
                                IID_IInstrumentName,
                                (IInterface*&)m_instrSvc);

  return status;
}

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().

                                                                   {
  MsgStream log(msgSvc(), "RootCalBaseCnv");
   log << MSG::DEBUG<<"RootCalBaseCnv::internalCreateObj( starting ..... "<<endreq;
   RootCalBaseCnv* converter = this;
  CLID classId = address->clID();

  IConverter* conv = this->conversionSvc()->converter(classId);
  if (0 == conv) {
    log << MSG::WARNING
        << "No proper converter found for classID " << classId
            << ", the default converter"
            << " will be used. " << endreq;
  } else {
    converter = dynamic_cast <RootCalBaseCnv*> (conv);
    if (0 == converter) {
      log << MSG::ERROR
          << "The converter found for classID " << classId
              << " was not a descendent of RootCalBaseCnv as it should be "
              << "( was of type " << typeid (*converter).name() << "). "
              << "The default converter will be used" << endreq;
      converter = this;
    }
  }

    m_runfrm =*( address->ipar());
    m_runto =*( address->ipar()+1);
   // creates an object for the node found
   StatusCode sc = converter->i_createObj(fname, refpObject);
     if (sc.isFailure()) {
    return sc;
  } 
     CalibData::CalibBase1* tmpObject =  dynamic_cast <CalibData::CalibBase1*> (refpObject);
     setBaseInfo(tmpObject);
  // ends up the object construction
  sc = converter->i_processObj(refpObject, address);
  if (sc.isSuccess()) {
    log << MSG::DEBUG << "Successfully created calib. object " << endreq;
  }
  closeRead();
  return sc;
}

const CLID & RootDedxCalibDataCnv::objType

(

)

const

Definition at line 40 of file RootDedxCalibDataCnv.cxx.

References CLID_Calib_DedxCal.

                                                {
  return CLID_Calib_DedxCal;
}

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(), RootDedxSimDataCnv::i_createObj(), and i_createObj().

                                                          { 

  MsgStream log(msgSvc(), "RootCalBaseCnv");

  // Check fname isn't empty
  if (fname == std::string("")) return StatusCode::FAILURE;

  if (doClean() ) {
    log << MSG::WARNING << "Previous operation didn't clean up! " << endreq;
  }
  m_saveDir = gDirectory;

  std::string ourName(fname);
  facilities::Util::expandEnvVar(&ourName);

  m_inFile = new TFile(ourName.c_str());
  
  if (!m_inFile->IsOpen() ) {
    log << MSG::ERROR << "ROOT file " << ourName 
        << "could not be opened for reading " << endreq;
    delete m_inFile;
    m_inFile = 0;
    return StatusCode::FAILURE;
  }
  else {
    log << MSG::INFO
        << "Successfully opened ROOT file " << fname << " aka " << ourName
        << " for reading " << endreq;
  }


  m_inFile->cd();             //    Maybe will need this


  return StatusCode::SUCCESS;
}

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(), RootDedxSimDataCnv::createRoot(), and createRoot().

                                                           {

  MsgStream log(msgSvc(), "RootCalBaseCnv");

  // Check fname isn't empty
  if (fname == std::string("")) return StatusCode::FAILURE;

  std::string ourName(fname);
  facilities::Util::expandEnvVar(&ourName);

  if (doClean() ) {
    log << MSG::WARNING << "Previous operation didn't clean up! " << endreq;
  }

  m_saveDir = gDirectory;

 
  m_outFile = new TFile(ourName.c_str(), "RECREATE");
  if (!m_outFile->IsOpen()) {
    log << MSG::ERROR << "ROOT file " << fname << " aka " << ourName 
        << " could not be opened for writing" << endreq;
    delete m_outFile;
    m_outFile = 0;
    return StatusCode::FAILURE;
  }
  else {
    log << MSG::INFO
        << "Successfully opened ROOT file " << fname << " aka " << ourName
        << " for writing " << endreq;
  }
   m_outFile->cd();
  return StatusCode::SUCCESS;
}

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.

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

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.

                                                                {
  TTree* pTree = (TTree*)m_inFile->Get(treename.c_str());

  return readRootObj(pTree, branch, pObj, ix);
 }

virtual long RootDedxCalibDataCnv::repSvcType

(

)

const [inline, virtual]

Definition at line 34 of file RootDedxCalibDataCnv.h.

References CALIBROOT_StorageType.

                                 { 
          return CALIBROOT_StorageType; 
      } 

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().

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

static const unsigned char RootCalBaseCnv::storageType

(

)

[inline, static, inherited]

Definition at line 62 of file RootCalBaseCnv.h.

References CALIBROOT_StorageType.

{return CALIBROOT_StorageType;}

---

Friends And Related Function Documentation

friend class CnvFactory< RootDedxCalibDataCnv > [friend]

Definition at line 22 of file RootDedxCalibDataCnv.h.

---

Member Data Documentation

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(), RootDedxSimDataCnv::i_createObj(), 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.

---