MdcCalConstMgr.cxx

Go to the documentation of this file.

#include "MdcCalibAlg/MdcCalConstMgr.h"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatusCode.h"
 
#include "TFile.h"
#include "TH1F.h"
#include "TObjArray.h"
#include "TROOT.h"
#include "TTree.h"
 
#include <iomanip>
#include <iostream>
 
MdcCalConstMgr::MdcCalConstMgr() {
  // constructor
}
 
MdcCalConstMgr::~MdcCalConstMgr() {
  // destructor
}
 
void MdcCalConstMgr::init( IMdcGeomSvc* mdcGeomSvc, IMdcCalibFunSvc* mdcFunSvc ) {
  m_mdcGeomSvc = mdcGeomSvc;
  m_mdcFunSvc  = mdcFunSvc;
}
 
// read calibration data from TCDS
void MdcCalConstMgr::rdConstTcds( MdcCalibConst* calconst ) {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "MdcCalConstMgr" );
  log << MSG::INFO << "Read calibration data from TCDS by MdcCalibFunSvc" << endmsg;
 
  int lay;
  int wid;
 
  int nlayer;
  int nwire;
 
  int    key;
  double val;
 
  nlayer = m_mdcGeomSvc->getLayerSize();
  nwire  = m_mdcGeomSvc->getWireSize();
 
  // read XT data -----------------------------------------------------------
  m_mdcFunSvc->setXtBegin();
  while ( m_mdcFunSvc->getNextXtpar( key, val ) ) { calconst->fillXtpar( key, val ); }
 
  // read T0 data -----------------------------------------------------------
  double t0;
  double delt0;
  for ( wid = 0; wid < nwire; wid++ )
  {
    t0    = m_mdcFunSvc->getT0( wid );
    delt0 = m_mdcFunSvc->getDelT0( wid );
    calconst->fillT0( t0 );
    calconst->fillDelT0( delt0 );
  }
 
  // read QT data -----------------------------------------------------------
  double qtpar0;
  double qtpar1;
  for ( lay = 0; lay < nlayer; lay++ )
  {
    qtpar0 = m_mdcFunSvc->getQtpar( lay, 0 );
    qtpar1 = m_mdcFunSvc->getQtpar( lay, 1 );
    calconst->fillQtpar0( qtpar0 );
    calconst->fillQtpar1( qtpar1 );
  }
 
  // read spatial resolution data -------------------------------------------
  m_mdcFunSvc->setSdBegin();
  while ( m_mdcFunSvc->getNextSdpar( key, val ) ) { calconst->fillSdpar( key, val ); }
}
 
// write calibration data from TCDS
void MdcCalConstMgr::wrtConstTcds( MdcCalibConst* calconst ) {}
 
// read calibration data directly in run directory
void MdcCalConstMgr::rdConst( MdcCalibConst* calconst ) {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "MdcCalConstMgr" );
  log << MSG::WARNING << "read calibration data directly from run directory" << endmsg;
 
  TFile fconst( "MdcCalibConst.root" );
  log << MSG::INFO << "open file" << endmsg;
 
  // read xttree ------------------------------------------------------------
  int    i;
  int    key;
  double xtpar;
  int    entry;
  TTree* xttree = (TTree*)fconst.Get( "XtTree" );
  xttree->SetBranchAddress( "xtkey", &key );
  xttree->SetBranchAddress( "xtpar", &xtpar );
  entry = (int)xttree->GetEntries();
  for ( i = 0; i < entry; i++ )
  {
    xttree->GetEntry( i );
    calconst->fillXtpar( key, xtpar );
  }
  log << MSG::INFO << "read XTtree" << endmsg;
 
  // read t0tree ------------------------------------------------------------
  double t0;
  double delt0;
  TTree* t0tree = (TTree*)fconst.Get( "T0Tree" );
  t0tree->SetBranchAddress( "t0", &t0 );
  t0tree->SetBranchAddress( "delt0", &delt0 );
  entry = (int)t0tree->GetEntries();
  for ( i = 0; i < entry; i++ )
  {
    t0tree->GetEntry( i );
    calconst->fillT0( t0 );
    calconst->fillDelT0( delt0 );
  }
  log << MSG::INFO << "read XTtree" << endmsg;
 
  // read qttree ------------------------------------------------------------
  double qtpar0;
  double qtpar1;
  TTree* qttree = (TTree*)fconst.Get( "QtTree" );
  qttree->SetBranchAddress( "qtpar0", &qtpar0 );
  qttree->SetBranchAddress( "qtpar1", &qtpar1 );
  entry = (int)qttree->GetEntries();
  for ( i = 0; i < entry; i++ )
  {
    qttree->GetEntry( i );
    calconst->fillQtpar0( qtpar0 );
    calconst->fillQtpar1( qtpar1 );
  }
 
  // read sdtree ---------------------------------------------------------
  double sdpar;
  TTree* sdtree = (TTree*)fconst.Get( "SdTree" );
  sdtree->SetBranchAddress( "sdkey", &key );
  sdtree->SetBranchAddress( "sdpar", &sdpar );
  entry = sdtree->GetEntries();
  for ( i = 0; i < entry; i++ )
  {
    sdtree->GetEntry( i );
    calconst->fillSdpar( key, sdpar );
  }
 
  fconst.Close();
 
  log << MSG::INFO << "read MdcCalibConst over" << endmsg;
}
 
// write calibration data directly in run directory
void MdcCalConstMgr::wrtConst( MdcCalibConst* calconst ) {
  IMessageSvc* msgSvc;
  Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
  MsgStream log( msgSvc, "MdcCalConstMgr" );
  log << MSG::INFO << "MdcCalConstMgr::wrtConst()" << endmsg;
 
  TFile fconst( "MdcCalibConst_new.root", "recreate" );
 
  // XT parameter tree -------------------------------------------------------
  int    i;
  int    key;
  int    entry;
  double xtpar;
  TTree* xttree = new TTree( "XtTree", "XtTree" );
  xttree->Branch( "xtkey", &key, "key/I" );
  xttree->Branch( "xtpar", &xtpar, "xtpar/D" );
  calconst->setXtBegin();
  while ( calconst->getNextXtpar( key, xtpar ) ) { xttree->Fill(); }
 
  // T0 parameter tree -------------------------------------------------------
  double t0;
  double delt0;
 
  TTree* t0tree = new TTree( "T0Tree", "T0Tree" );
  t0tree->Branch( "t0", &t0, "t0/D" );
  t0tree->Branch( "delt0", &delt0, "delt0/D" );
  entry = calconst->getT0Size();
  for ( i = 0; i < entry; i++ )
  {
    t0    = calconst->getT0( i );
    delt0 = calconst->getDelT0( i );
    t0tree->Fill();
  }
 
  // QT parameter tree -------------------------------------------------------
  double qtpar0;
  double qtpar1;
 
  TTree* qttree = new TTree( "QtTree", "QtTree" );
  qttree->Branch( "qtpar0", &qtpar0, "qtpar0/D" );
  qttree->Branch( "qtpar1", &qtpar1, "qtpar1/D" );
  entry = calconst->getQtSize();
  for ( i = 0; i < entry; i++ )
  {
    qtpar0 = calconst->getQtpar0( i );
    qtpar1 = calconst->getQtpar1( i );
    qttree->Fill();
  }
 
  // Spacial Resolution parameter tree ---------------------------------------
  double sdpar;
 
  TTree* sdtree = new TTree( "SdTree", "SdTree" );
  sdtree->Branch( "sdkey", &key, "key/I" );
  sdtree->Branch( "sdpar", &sdpar, "sdpar/D" );
  calconst->setSdBegin();
  while ( calconst->getNextSdpar( key, sdpar ) ) { sdtree->Fill(); }
 
  xttree->Write();
  t0tree->Write();
  qttree->Write();
  sdtree->Write();
 
  delete xttree;
  delete t0tree;
  delete qttree;
  delete sdtree;
 
  fconst.Close();
 
  log << MSG::INFO << "MdcCalibConst_new.root was written." << endmsg;
}