#include <RootMdcCalibDataCnv.h>

Inheritance diagram for RootMdcCalibDataCnv:

Public Member Functions
const CLID &	objType () const

	RootMdcCalibDataCnv (ISvcLocator *svc)

virtual	~RootMdcCalibDataCnv ()

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

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

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

Author: J. Bogart

Definition at line 21 of file RootMdcCalibDataCnv.h.

Constructor & Destructor Documentation

◆ RootMdcCalibDataCnv()

RootMdcCalibDataCnv::RootMdcCalibDataCnv ( ISvcLocator * svc )

Definition at line 34 of file RootMdcCalibDataCnv.cxx.

                                                          :
  RootCalBaseCnv(svc, CLID_Calib_MdcCal) { 
 
}

◆ ~RootMdcCalibDataCnv()

virtual RootMdcCalibDataCnv::~RootMdcCalibDataCnv ( )

inlinevirtual

Definition at line 30 of file RootMdcCalibDataCnv.h.

30{};

Member Function Documentation

◆ classID()

const CLID & RootMdcCalibDataCnv::classID ( )

static

Definition at line 44 of file RootMdcCalibDataCnv.cxx.

                                         {
  return CLID_Calib_MdcCal;
}

◆ createRoot()

StatusCode RootMdcCalibDataCnv::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 149 of file RootMdcCalibDataCnv.cxx.

                                  {
 
  MsgStream log(msgSvc(), "RootMdcCalibDataCnv");
  // 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
  CalibData::MdcCalibData* tmpObject = dynamic_cast<CalibData::MdcCalibData*>(pTDSObj);
  int tmpNo;
  int key;
  double xtpar;
  double t0;
  double delt0;
  double qtpar[2];
  double sdpar;
  int i;
 
  //xttree------------------------------------------------------------------
  TTree *xttree = new TTree("XtTree", "XtTree");
  xttree -> Branch("xtkey", &key, "key/I");
  xttree -> Branch("xtpar", &xtpar, "xtpar/D");
  tmpObject -> setXtBegin();
  while( tmpObject -> getNextXtpar(key, xtpar) ){
    xttree -> Fill();
  }
  //newxttree------------------------------------------------------------------
  //FIXME
  /*
     TObjArray newxttrees_1;
  //TBufferFile newxttrees_buf(TBuffer::kWrite);
  int nTree=0;
  for(int t_layer=0; t_layer<43; t_layer++){
  for(int t_bin=0; t_bin<18; t_bin++){
  for(int t_lr=0; t_lr<2; t_lr++){
  char newXtTreeName[20];
  sprintf(newXtTreeName,"trNewXt%02d_%02d_%d",t_layer,t_bin,t_lr);
  TTree *newXttree =  ((TTree*)f->Get(newXtTreeName))->CloneTree();
  newxttrees_1.Add(newXttree);
  nTree++;
  }
  }
  }
  newxttrees_1.Streamer(newxttrees_buf);
  */
 
 
  //t0tree-------------------------------------------------------------------
  TTree *t0tree = new TTree("T0Tree", "T0Tree");
  t0tree -> Branch("t0", &t0, "t0/D");
  t0tree -> Branch("delt0", &delt0, "delt0/D");
  tmpNo = tmpObject -> gett0No();
  for(i=0; i<tmpNo; i++){
    t0 = tmpObject -> getT0(i);
    delt0 = tmpObject -> getDelT0(i);
    t0tree -> Fill();
  }
 
  //qttree--------------------------------------------------------------------
  TTree *qttree = new TTree("QtTree", "QtTree");
  qttree -> Branch("qtpar0", &(qtpar[0]), "qtpar0/D");
  qttree -> Branch("qtpar1", &(qtpar[1]), "qtpar1/D");
  tmpNo = tmpObject -> getqtparNo();
  for(i=0; i<tmpNo; i++){
    qtpar[0] =  tmpObject -> getQtpar0(i);
    qtpar[1] =  tmpObject -> getQtpar1(i);
    qttree -> Fill();
  }
 
  //sdtree--------------------------------------------------------------------
  TTree *sdtree = new TTree("SdTree", "SdTree");
  sdtree -> Branch("sdkey", &key, "key/I");
  sdtree -> Branch("sdpar", &sdpar, "sdpar/D");
  tmpObject -> setSdBegin();
  while( tmpObject -> getNextSdpar(key, sdpar) ){
    sdtree -> Fill();
  }
 
  xttree -> Write();
  t0tree -> Write();
  qttree -> Write();
  sdtree -> Write();
 
  delete xttree;
  delete t0tree;
  delete qttree;
  delete sdtree;
 
  closeWrite();
  log<<MSG::INFO<<"successfully create RootFile"<<endreq;
  return sc;
}

◆ i_createObj()

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

protectedvirtual

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 RootCalBaseCnv.

Definition at line 48 of file RootMdcCalibDataCnv.cxx.

                                                                {
 
  MsgStream log(msgSvc(), "RootMdcCalibDataCnv");
  log<<MSG::DEBUG<<"SetProperty"<<endreq;
 
  StatusCode sc = openRead(fname);
  if(!sc)
    { log<<MSG::ERROR<<"unable to open files"<<endreq;
    }
 
  CalibData::MdcCalibData *tmpObject = new CalibData::MdcCalibData ;
  // Read in our object
  int i;
  int nentries;
  // read xttree ------------------------------------------------------------
  double xtpar;
  int  xtkey;
  TTree *xttree = (TTree*)m_inFile -> Get("XtTree");
  xttree -> SetBranchAddress("xtpar", &xtpar);
  xttree -> SetBranchAddress("xtkey", &xtkey);
  nentries = xttree -> GetEntries();
  for(i=0; i<nentries; i++){
    xttree -> GetEntry(i);
    tmpObject -> setXtpar(xtkey,xtpar);
  }
 
  // read newxttree ------------------------------------------------------------
  TObjArray newXtTrees;
  if(NULL!=m_inFile->Get("trNewXt00_00_0")){
    for(int layid=0; layid<43; layid++){
      for(int entr=0; entr<18; entr++){
    for(int lr=0; lr<2; lr++){
      char newXtTreeName[20];
      sprintf(newXtTreeName,"trNewXt%02d_%02d_%d",layid,entr,lr);
      TTree* newXtTree = ((TTree*)m_inFile->Get(newXtTreeName));
      if(!newXtTree) break;
      newXtTrees.Add(newXtTree->CloneTree());
    }//end lr
      }//end entr
    }//end layid
    if((43*18*2)==newXtTrees.GetEntries())tmpObject->setNewXtpar(&newXtTrees);
  }
 
 
  // read r2ttree ------------------------------------------------------------
  TObjArray r2tTrees;
  if(NULL!=m_inFile->Get("r2t00")){
    for(int layid=0; layid<43; layid++){
      char r2tTreeName[20];
      sprintf(r2tTreeName,"r2t%02d",layid);
      TTree* r2tTree = ((TTree*)m_inFile->Get(r2tTreeName));
      if(!r2tTree) break;
      r2tTrees.Add(r2tTree->CloneTree());
    }
    if(43==r2tTrees.GetEntries()) tmpObject->setR2tpar(&r2tTrees);
  }
 
  // read t0tree ------------------------------------------------------------
  double t0;
  double delt0;
  TTree *t0tree = (TTree*)m_inFile -> Get("T0Tree");
  t0tree -> SetBranchAddress("t0", &t0);
  t0tree -> SetBranchAddress("delt0", &delt0);
  nentries = t0tree -> GetEntries();
  for(i=0; i<nentries; i++){
    t0tree -> GetEntry(i);
    tmpObject -> setT0(t0);
    tmpObject -> setDelT0(delt0);
  }
 
  // read qttree ------------------------------------------------------------
  double qtpar0;
  double qtpar1;
  TTree *qttree = (TTree*)m_inFile -> Get("QtTree");
  qttree -> SetBranchAddress("qtpar0", &qtpar0);
  qttree -> SetBranchAddress("qtpar1", &qtpar1);
  nentries = qttree -> GetEntries();
  for(i=0; i<nentries; i++){
    qttree -> GetEntry(i);
    tmpObject -> setQtpar0(qtpar0);
    tmpObject -> setQtpar1(qtpar1);
  }
 
  // read Sdtree ---------------------------------------------------------
  double sdpar;
  int  sdkey;
  TTree *sdtree = (TTree*)m_inFile -> Get("SdTree");
  sdtree -> SetBranchAddress("sdpar", &sdpar);
  sdtree -> SetBranchAddress("sdkey", &sdkey);
  nentries = sdtree -> GetEntries();
 
  for(i=0; i<nentries; i++){
    sdtree -> GetEntry(i);
    tmpObject -> setSdpar(sdkey,sdpar);
  }
 
  refpObject=tmpObject;
  return StatusCode::SUCCESS;
}

◆ objType()

const CLID & RootMdcCalibDataCnv::objType ( ) const

Definition at line 40 of file RootMdcCalibDataCnv.cxx.

                                               {
  return CLID_Calib_MdcCal;
}

◆ repSvcType()

virtual long RootMdcCalibDataCnv::repSvcType ( ) const

inlinevirtual

Definition at line 35 of file RootMdcCalibDataCnv.h.

                                  { 
          return CALIBROOT_StorageType; 
      } 

Friends And Related Function Documentation

◆ CnvFactory< RootMdcCalibDataCnv >

friend class CnvFactory< RootMdcCalibDataCnv >

friend

Definition at line 1 of file RootMdcCalibDataCnv.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members