/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Mdc/MdcCalibAlg/MdcCalibAlg-00-09-02/src/MdcCalConstMgr.cxx

Go to the documentation of this file.

#include "MdcCalibAlg/MdcCalConstMgr.h"

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/PropertyMgr.h"

#include "TROOT.h"
#include "TFile.h"
#include "TTree.h"
#include "TH1F.h"
#include "TObjArray.h"

#include <iostream>
#include <iomanip>

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"
         << endreq;

     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" 
         << endreq;

     TFile fconst("MdcCalibConst.root");
     log << MSG::INFO << "open file" << endreq;

// 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" << endreq;

// 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" << endreq;

// 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" << endreq;
}


// 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()" << endreq;

     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." << endreq;
}

---