RootMdcCalibDataCnv.cxx

Go to the documentation of this file.

// $Header:
// /bes/bes/BossCvs/Calibration/CalibSvc/CalibROOTCnv/src/cnv/RootMdcCalibDataCnv.cxx,v 1.10
// 2023/10/06 22:57:09 maqm Exp $
#include "RootMdcCalibDataCnv.h"
#include "CalibData/Mdc/MdcCalStruct.h"
#include "CalibData/Mdc/MdcCalibData.h"
#include "CalibDataSvc/IInstrumentName.h"
#include "GaudiKernel/MsgStream.h"
 
#include "TBufferFile.h"
#include "TDirectory.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TObject.h"
#include "TTree.h"
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
 
#include "CalibDataSvc/ICalibMetaCnvSvc.h"
#include "CalibDataSvc/ICalibRootSvc.h" //maybe
 
// Temporary.  Hope to find a better way to do this
#include "CalibData/CalibModel.h"
using namespace CalibData;
// static CnvFactory<RootMdcCalibDataCnv> MdcCal_factory;
// const  ICnvFactory& RootMdcCalibDataCnvFactory = MdcCal_factory;
 
RootMdcCalibDataCnv::RootMdcCalibDataCnv( ISvcLocator* svc )
    : RootCalBaseCnv( svc, CLID_Calib_MdcCal ) {}
 
const CLID& RootMdcCalibDataCnv::objType() const { return CLID_Calib_MdcCal; }
 
const CLID& RootMdcCalibDataCnv::classID() { return CLID_Calib_MdcCal; }
 
StatusCode RootMdcCalibDataCnv::i_createObj( const std::string& fname,
                                             DataObject*&       refpObject ) {
 
  MsgStream log( msgSvc(), "RootMdcCalibDataCnv" );
  log << MSG::DEBUG << "SetProperty" << endmsg;
 
  StatusCode sc = openRead( fname );
  if ( !sc ) { log << MSG::ERROR << "unable to open files" << endmsg; }
 
  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 ) );
          newXtTree->SetCacheSize(10000000);
          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;
      // reduce Memerey use
      r2tTree->SetCacheSize( 2500 );
      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;
}
 
StatusCode RootMdcCalibDataCnv::createRoot( const std::string&     fname,
                                            CalibData::CalibBase1* pTDSObj ) {
 
  MsgStream log( msgSvc(), "RootMdcCalibDataCnv" );
  // Open the file, create the branch
  StatusCode sc = openWrite( fname );
  if ( !sc ) { log << MSG::ERROR << "unable to open files" << endmsg; }
  // 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" << endmsg;
  return sc;
}