RootDedxCalibDataCnv Class Reference

#include <RootDedxCalibDataCnv.h>

Inheritance diagram for RootDedxCalibDataCnv:

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
Public Member Functions inherited from RootCalBaseCnv
virtual	~RootCalBaseCnv ()
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
virtual StatusCode	createObj (IOpaqueAddress *addr, DataObject *&refpObject)
ICalibRootSvc *	getCalibRootSvc ()
	RootCalBaseCnv (ISvcLocator *svc, const CLID &clid)
virtual StatusCode	createRoot (const std::string &fname, CalibData::CalibBase1 *pTDSObj)
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)
Public Member Functions inherited from Converter< Ty1, Ty2 >
destination *	operator (const source &) const

Static Public Member Functions
static const CLID &	classID ()
Static Public Member Functions inherited from RootCalBaseCnv
static const unsigned char	storageType ()

Protected Member Functions
virtual StatusCode	i_createObj (const std::string &fname, DataObject *&refpObject)
Protected Member Functions inherited from RootCalBaseCnv
virtual StatusCode	internalCreateObj (const std::string &fname, DataObject *&refpObject, IOpaqueAddress *address)
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	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.
Protected Member Functions inherited from Converter< Ty1, Ty2 >
virtual destination *	convert (const source &) const =0

Friends
class	CnvFactory< RootDedxCalibDataCnv >

Additional Inherited Members
Public Types inherited from Converter< Ty1, Ty2 >
typedef Ty1	source
typedef Ty2	destination
Protected Attributes inherited from RootCalBaseCnv
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

Detailed Description

Definition at line 20 of file RootDedxCalibDataCnv.h.

Constructor & Destructor Documentation

RootDedxCalibDataCnv()

RootDedxCalibDataCnv::RootDedxCalibDataCnv

(

ISvcLocator *

svc

)

Definition at line 35 of file RootDedxCalibDataCnv.cxx.

                                                            :
  RootCalBaseCnv(svc, CLID_Calib_DedxCal) { 
}

~RootDedxCalibDataCnv()

virtual RootDedxCalibDataCnv::~RootDedxCalibDataCnv ( )

inlinevirtual

Definition at line 29 of file RootDedxCalibDataCnv.h.

{};

Member Function Documentation

classID()

const CLID & RootDedxCalibDataCnv::classID ( )

static

Definition at line 44 of file RootDedxCalibDataCnv.cxx.

                                          {
  return CLID_Calib_DedxCal;
}

createRoot()

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.

                                                                      {
 
  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;
 
}

i_createObj()

StatusCode RootDedxCalibDataCnv::i_createObj ( const std::string &  fname, DataObject *&  refpObject  )

protectedvirtual

Create the transient representation of an object, given an opaque address. This and the following update method comprise the core functionality of calibration converters. Convenience routine used by most CAL calibration types, which have a <dimension> element describing how the remainder of the data is laid out. Read from TDS; store information internally in protected members.
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 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.

                                                                {
 
  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;
}

objType()

const CLID & RootDedxCalibDataCnv::objType

(

)

const

Definition at line 40 of file RootDedxCalibDataCnv.cxx.

                                                {
  return CLID_Calib_DedxCal;
}

repSvcType()

virtual long RootDedxCalibDataCnv::repSvcType ( ) const

inlinevirtual

Definition at line 34 of file RootDedxCalibDataCnv.h.

                                 { 
          return CALIBROOT_StorageType; 
      } 

Friends And Related Function Documentation

CnvFactory< RootDedxCalibDataCnv >

friend class CnvFactory< RootDedxCalibDataCnv >

friend

Definition at line 1 of file RootDedxCalibDataCnv.h.

---

The documentation for this class was generated from the following files:

• RootDedxCalibDataCnv.h
• RootDedxCalibDataCnv.cxx