TofCaliSvc/test/convert2root.cxx

Go to the documentation of this file.

//=====================================================
// this script is used to convert result in text file
// to root files. it is based on files named that start
// by "calib_barrel" .it means thest result from barrel.
//=====================================================
 
#include "TFile.h"
#include "TTree.h"
#include <assert.h>
#include <fstream>
#include <iostream>
using namespace std;
 
bool calib_conv2root() {
  TTree* t0   = new TTree( "CalibInfo", "run number and version number" );
  int    run1 = 0, run2 = 0, version = 0;
  int    qCorr = 1, qElec = 1, misLable = 1;
  int    itofid[15] = { 0 };
  char   ebrname[5], wbrname[5], ecname[5];
  char   iebrname[5], iwbrname[5], iecname[5];
  t0->Branch( "Run1", &run1, "Run1/I" );
  t0->Branch( "Run2", &run2, "Run2/I" );
  t0->Branch( "Version", &version, "Version/I" );
  t0->Branch( "qCorr", &qCorr, "qCorr/I" );
  t0->Branch( "qElec", &qElec, "qElec/I" );
  t0->Branch( "misLable", &misLable, "misLable/I" );
 
  for ( unsigned int i = 0; i < 5; i++ )
  {
    sprintf( ebrname, "ebrId%d", i );
    sprintf( iebrname, "ebrId%d/I", i );
    t0->Branch( ebrname, &itofid[i], iebrname );
    sprintf( wbrname, "wbrId%d", i );
    sprintf( iwbrname, "wbrId%d/I", i );
    t0->Branch( wbrname, &itofid[i + 5], iwbrname );
    sprintf( ecname, "ecId%d", i );
    sprintf( iecname, "ecId%d/I", i );
    t0->Branch( ecname, &itofid[i + 10], iecname );
  }
 
  int          itmp;
  unsigned int barrel, layer, tofid, end;
  ifstream     inf;
  bool         is_open = false;
  const char*  file    = "calib_info.txt";
  inf.open( file, ios::in );
  if ( inf.good() ) { is_open = true; }
  else { std::cerr << "file: " << file << " can't be found!" << std::endl; }
  try
  {
    if ( is_open )
    {
      inf >> run1 >> run2 >> version;
      inf >> qCorr >> qElec >> misLable;
      for ( unsigned int i = 0; i < 15; i++ )
      {
        inf >> itmp;
        if ( itmp != -1 )
        {
          tofid = unsigned int( itmp );
          if ( i >= 0 && i <= 9 )
          {
            if ( i >= 0 && i <= 4 ) { end = 0; }
            else if ( i >= 5 && i <= 9 ) { end = 1; }
            barrel = 1;
            if ( itmp >= 0 && itmp <= 87 ) { layer = 0; }
            else if ( itmp >= 88 && itmp <= 175 )
            {
              tofid = tofid - 88;
              layer = 1;
            }
            else { std::cout << "1 impossible tofid!" << std::endl; }
            itofid[i] =
                ( 0x20000000 | ( barrel << 14 ) | ( layer << 8 ) | ( tofid << 1 ) | end );
          }
          else if ( i >= 10 && i <= 14 )
          {
            if ( version == 0 )
            {
              barrel = 0;
              layer  = 0;
              end    = 0;
              if ( itmp >= 48 && itmp <= 95 )
              {
                barrel = 2;
                tofid  = tofid - 48;
              }
              itofid[i] =
                  ( 0x20000000 | ( barrel << 14 ) | ( layer << 8 ) | ( tofid << 1 ) | end );
            }
            else if ( version == 1 )
            {
              barrel              = 3;
              end                 = unsigned int( itmp / 10000 );
              tofid               = unsigned int( ( itmp - end * 10000 ) / 100 );
              unsigned int strip  = unsigned int( itmp % 100 );
              unsigned int endcap = 0;
              if ( tofid >= 36 && tofid <= 71 )
              {
                endcap = 1;
                tofid  = tofid - 35;
              }
              itofid[i] = ( 0x20000000 | ( barrel << 14 ) | ( endcap << 11 ) | ( tofid << 5 ) |
                            ( strip << 1 ) | end );
            }
            else if ( version == 2 ) { itofid[i] = itmp; }
          }
          else { std::cout << "impossible tofid!" << std::endl; }
        }
        else { itofid[i] = 0x2fffffff; }
      }
      t0->Fill();
    }
  } catch ( ... )
  { return false; }
 
  TFile f( "CalibInfo.root", "RECREATE" );
  t0->Write();
  f.Close();
  delete t0;
  t0 = NULL;
 
  return true;
}
 
bool barrel_conv2root() {
 
  TTree* t1 = new TTree( "BarTofPar", "barrel parameters" );
 
  double p[20] = { 1. };
  char   brname[20];
  char   ptname[20];
  for ( int i = 0; i < 20; i++ )
  {
    sprintf( brname, "P%d", i );
    sprintf( ptname, "p%d/D", i );
    t1->Branch( brname, &p[i], ptname );
  }
 
  double bunch0_poff[40] = { 1. }, bunch1_poff[40] = { 1. }, bunch2_poff[40] = { 1. },
         bunch3_poff[40] = { 1. };
  char broffname[40];
  char ptoffname[40];
  for ( int i = 0; i < 40; i++ )
  {
    sprintf( broffname, "Bunch0_Poff%d", i );
    sprintf( ptoffname, "bunch0_poff%d/D", i );
    t1->Branch( broffname, &bunch0_poff[i], ptoffname );
  }
  for ( int i = 0; i < 40; i++ )
  {
    sprintf( broffname, "Bunch1_Poff%d", i );
    sprintf( ptoffname, "bunch1_poff%d/D", i );
    t1->Branch( broffname, &bunch1_poff[i], ptoffname );
  }
  for ( int i = 0; i < 40; i++ )
  {
    sprintf( broffname, "Bunch2_Poff%d", i );
    sprintf( ptoffname, "bunch2_poff%d/D", i );
    t1->Branch( broffname, &bunch2_poff[i], ptoffname );
  }
  for ( int i = 0; i < 40; i++ )
  {
    sprintf( broffname, "Bunch3_Poff%d", i );
    sprintf( ptoffname, "bunch3_poff%d/D", i );
    t1->Branch( broffname, &bunch3_poff[i], ptoffname );
  }
 
  double fitfun[20] = { 0. };
  ;
  char fbrname1[5], fptname1[5], fbrname2[5], fptname2[5];
  char fbrname3[10], fptname3[10];
  for ( int i = 0; i < 5; i++ )
  {
    sprintf( fbrname1, "FLeft%d", i );
    sprintf( fptname1, "fleft%d/D", i );
    t1->Branch( fbrname1, &fitfun[i], fptname1 );
    sprintf( fbrname2, "FRight%d", i );
    sprintf( fptname2, "fright%d/D", i );
    t1->Branch( fbrname2, &fitfun[5 + i], fptname2 );
  }
  for ( int i = 0; i < 10; i++ )
  {
    sprintf( fbrname3, "FCounter%d", i );
    sprintf( fptname3, "fcounter%d/D", i );
    t1->Branch( fbrname3, &fitfun[10 + i], fptname3 );
  }
 
  double Atten[8] = { 1. };
  for ( int i = 0; i < 8; i++ )
  {
    sprintf( brname, "Atten%d", i );
    sprintf( ptname, "Atten%d/D", i );
    t1->Branch( brname, &Atten[i], ptname );
  }
 
  double Speed[2] = { 1. };
  t1->Branch( "Speed0", &Speed[0], "Speed0/D" );
  t1->Branch( "Speed1", &Speed[1], "Speed1/D" );
 
  const int   N = 23;
  ifstream    inf[N];
  bool        is_open[N]  = { false };
  const char* filelist[N] = {
      "calib_barrel_left.txt",                 // 0
      "calib_barrel_right.txt",                // 1
      "calib_barrel_left_offset1_bunch0.txt",  // 2
      "calib_barrel_left_offset2_bunch0.txt",  // 3
      "calib_barrel_right_offset1_bunch0.txt", // 4
      "calib_barrel_right_offset2_bunch0.txt", // 5
      "calib_barrel_left_offset1_bunch1.txt",  // 6
      "calib_barrel_left_offset2_bunch1.txt",  // 7
      "calib_barrel_right_offset1_bunch1.txt", // 8
      "calib_barrel_right_offset2_bunch1.txt", // 9
      "calib_barrel_left_offset1_bunch2.txt",  // 10
      "calib_barrel_left_offset2_bunch2.txt",  // 11
      "calib_barrel_right_offset1_bunch2.txt", // 12
      "calib_barrel_right_offset2_bunch2.txt", // 13
      "calib_barrel_left_offset1_bunch3.txt",  // 14
      "calib_barrel_left_offset2_bunch3.txt",  // 15
      "calib_barrel_right_offset1_bunch3.txt", // 16
      "calib_barrel_right_offset2_bunch3.txt", // 17
      "calib_barrel_sigma.txt",                // 18
      "calib_barrel_atten.txt",                // 19
      "calib_barrel_q0.txt",                   // 20
      "calib_barrel_veff.txt",                 // 21
      "calib_barrel_common.txt"                // 22
  };
  for ( int m = 0; m < N; m++ )
  {
    inf[m].open( filelist[m], ios::in );
    if ( inf[m].good() ) is_open[m] = true;
    else std::cerr << "file: " << filelist[m] << " can't be found!" << std::endl;
  }
 
  try
  {
    for ( int k = 0; k < 176; k++ )
    {
      //------------set p-------------------------
      if ( is_open[0] && is_open[1] )
      {
        for ( int j = 0; j < 7; j++ )
        {
          inf[0] >> p[j];
          inf[1] >> p[j + 10];
        }
      }
      //-------set offset of bunch0 correction  pars -------
      if ( is_open[2] && is_open[3] && is_open[4] && is_open[5] )
      {
        for ( int j = 0; j < 7; j++ )
        {
          inf[2] >> bunch0_poff[j];
          inf[3] >> bunch0_poff[j + 10];
          inf[4] >> bunch0_poff[j + 20];
          inf[5] >> bunch0_poff[j + 30];
        }
      }
      //-------set offset of bunch1 correction  pars -------
      if ( is_open[6] && is_open[7] && is_open[8] && is_open[9] )
      {
        for ( int j = 0; j < 7; j++ )
        {
          inf[6] >> bunch1_poff[j];
          inf[7] >> bunch1_poff[j + 10];
          inf[8] >> bunch1_poff[j + 20];
          inf[9] >> bunch1_poff[j + 30];
        }
      }
 
      //-------set offset of bunch2 correction  pars -------
      if ( is_open[10] && is_open[11] && is_open[12] && is_open[13] )
      {
        for ( int j = 0; j < 7; j++ )
        {
          inf[10] >> bunch2_poff[j];
          inf[11] >> bunch2_poff[j + 10];
          inf[12] >> bunch2_poff[j + 20];
          inf[13] >> bunch2_poff[j + 30];
        }
      }
      if ( is_open[14] && is_open[15] && is_open[16] && is_open[17] )
      {
        for ( int j = 0; j < 7; j++ )
        {
          inf[14] >> bunch3_poff[j];
          inf[15] >> bunch3_poff[j + 10];
          inf[16] >> bunch3_poff[j + 20];
          inf[17] >> bunch3_poff[j + 30];
        }
      }
      //--------fit sigma vs z parameters---------
      if ( is_open[18] )
      {
        for ( int j = 0; j < 15; j++ ) { inf[18] >> fitfun[j]; }
      }
      //-----------atten lenght-------------------
      if ( is_open[19] )
      {
        for ( int j = 0; j < 2; j++ ) { inf[19] >> Atten[j]; }
        Atten[0] = 1. / Atten[0];
      }
      //--------------Q0--------------------------
      if ( is_open[20] )
      {
        for ( int j = 2; j < 5; j++ ) { inf[20] >> Atten[j]; }
      }
      //-------------speed------------------------
      if ( is_open[21] )
      {
        for ( int j = 0; j < 2; j++ ) { inf[21] >> Speed[j]; }
        Speed[0] = 1. / Speed[0];
      }
      t1->Fill();
    }
  } catch ( ... )
  { return false; }
 
  TTree* t2          = new TTree( "BarTofParCommon", "common part of barrel" );
  double t0Offset[2] = { 0. }, sigmaCorr[8] = { 0. };
  for ( int i = 0; i < 2; i++ )
  {
    sprintf( brname, "t0offset%d", i );
    sprintf( ptname, "t0offset%d/D", i );
    t2->Branch( brname, &t0Offset[i], ptname );
  }
  for ( int i = 0; i < 8; i++ )
  {
    sprintf( brname, "sigmaCorr%d", i );
    sprintf( ptname, "sigmaCorr%d/D", i );
    t2->Branch( brname, &sigmaCorr[i], ptname );
  }
  try
  {
    if ( is_open[22] )
    { inf[22] >> sigmaCorr[0] >> sigmaCorr[1] >> t0Offset[0] >> t0Offset[1]; }
    t2->Fill();
  } catch ( ... )
  { return false; }
 
  for ( int m = 0; m < N; m++ ) { inf[m].close(); }
 
  TFile f( "BarTofPar.root", "RECREATE" );
  t1->Write();
  t2->Write();
  f.Close();
  delete t1;
  delete t2;
  t1 = NULL;
  t2 = NULL;
 
  return true;
}
 
//=====================================================
// this script is used to convert result in text file
// to root files. it is based on files named that start
// by "calib_endcap_" .it means thest result from endcap.
//=====================================================
bool endcap_conv2root() {
 
  TTree* t = new TTree( "EndTofPar", "endcap parameters" );
  char   brname[8];
  char   ptname[8];
  double p[8] = { 0. };
  for ( int i = 0; i < 8; i++ )
  {
    sprintf( brname, "P%d", i );
    sprintf( ptname, "p%d/D", i );
    t->Branch( brname, &p[i], ptname );
  }
  double fcounter[5] = { 0. }, Atten[5] = { 0. }, Speed[4] = { 0. };
  for ( int i = 0; i < 5; i++ )
  {
    sprintf( brname, "FCounter%d", i );
    sprintf( ptname, "fcounter%d/D", i );
    t->Branch( brname, &fcounter[i], ptname );
    sprintf( brname, "Atten%d", i );
    sprintf( ptname, "Atten%d/D", i );
    t->Branch( brname, &Atten[i], ptname );
  }
  double Speed[4] = { 0. };
  for ( int i = 0; i < 4; i++ )
  {
    sprintf( brname, "Speed%d", i );
    sprintf( ptname, "Speed%d/D", i );
    t->Branch( brname, &Speed[i], ptname );
  }
 
  try
  {
    for ( int k = 0; k < 96; k++ ) { t->Fill(); }
  } catch ( ... )
  { return false; }
  //-------------------------------------------
  TFile f( "EndTofPar.root", "RECREATE" );
  t->Write();
  f.Close();
  delete t;
  t = NULL;
 
  return true;
}
 
bool etf_conv2root() {
 
  TTree* t  = new TTree( "EtfTofPar", "etf parameters" );
  TTree* t1 = new TTree( "EtfTofBunch", "etf parameters" );
 
  char   brname[60];
  char   ptname[60];
  double p[60] = { 1. };
  for ( int i = 0; i < 60; i++ )
  {
    sprintf( brname, "P%d", i );
    sprintf( ptname, "p%d/D", i );
    t->Branch( brname, &p[i], ptname );
  }
  double Speed[4] = { 1. };
  for ( int i = 0; i < 4; i++ )
  {
    sprintf( brname, "Speed%d", i );
    sprintf( ptname, "Speed%d/D", i );
    t->Branch( brname, &Speed[i], ptname );
  }
  double tmp;
  double pBunch[4] = { 1. };
  for ( int i = 0; i < 4; i++ )
  {
    sprintf( brname, "pbunch%d", i );
    sprintf( ptname, "pbunch%d/D", i );
    t1->Branch( brname, &pBunch[i], ptname );
  }
 
  const int   K = 5;
  ifstream    inf[K];
  bool        is_open[K]  = { false };
  const char* filelist[K] = { "calib_etf_combine.txt", "calib_etf_left.txt",
                              "calib_etf_right.txt", "calib_etf_veff.txt",
                              "calib_etf_bunch.txt" };
  for ( int i = 0; i < K; i++ )
  {
    inf[i].open( filelist[i], ios::in );
    if ( inf[i].good() ) is_open[i] = true;
    else { std::cerr << "File: " << filelist[i] << " can't be opened" << std::endl; }
  }
  try
  {
    for ( int i = 0; i < 72; i++ )
    {
      for ( int j = 0; j < 12; j++ )
      {
        //------------set p-------------------------
        if ( is_open[0] && is_open[1] && is_open[2] )
        {
          for ( int k = 0; k < 7; k++ ) { inf[0] >> p[k]; }
          for ( int k = 0; k < 13; k++ )
          {
            inf[1] >> p[k + 20];
            inf[2] >> p[k + 40];
          }
        }
        //-------------speed------------------------
        if ( is_open[3] )
        {
          for ( int k = 0; k < 4; k++ ) { inf[3] >> Speed[k]; }
        }
        t->Fill();
      }
    }
    //-------------bunch------------------------
    if ( is_open[4] )
    {
      for ( int k = 0; k < 4; k++ ) { inf[4] >> pBunch[k] >> tmp; }
    }
    t1->Fill();
  } catch ( ... )
  { return false; }
 
  for ( int i = 0; i < K; i++ ) { inf[i].close(); }
 
  TFile f( "EtfTofPar.root", "RECREATE" );
  t->Write();
  t1->Write();
  f.Close();
  delete t;
  delete t1;
  t  = NULL;
  t1 = NULL;
 
  return true;
}
 
bool join() {
 
  TFile  f0( "CalibInfo.root" );
  TTree* t0    = (TTree*)f0.Get( "CalibInfo" );
  TTree* tnew0 = t0->CloneTree();
  if ( 0 == tnew0 )
  {
    std::cerr << " can't get tree :CalibInfo in file CalibInfo.root" << std::endl;
    return false;
  }
 
  TFile  f( "EndTofPar.root" );
  TTree* t    = (TTree*)f.Get( "EndTofPar" );
  TTree* tnew = t->CloneTree();
  if ( 0 == tnew )
  {
    std::cerr << " can't get tree :EndTofPar in file EndTofPar.root" << std::endl;
    return false;
  }
 
  TFile  f1( "BarTofPar.root" );
  TTree* t1    = (TTree*)f1.Get( "BarTofPar" );
  TTree* tnew1 = t1->CloneTree();
  if ( 0 == tnew1 )
  {
    std::cerr << " can't get tree :BarTofPar in file BarTofPar.root" << std::endl;
    return false;
  }
  TTree* t2    = (TTree*)f1.Get( "BarTofParCommon" );
  TTree* tnew2 = t2->CloneTree();
  if ( 0 == tnew2 )
  {
    std::cerr << " can't get tree :BarTofPar Common in file BarTofPar.root" << std::endl;
    return false;
  }
 
  TFile  f2( "EtfTofPar.root" );
  TTree* t3    = (TTree*)f2.Get( "EtfTofPar" );
  TTree* tnew3 = t3->CloneTree();
  TTree* t4    = (TTree*)f2.Get( "EtfTofBunch" );
  TTree* tnew4 = t4->CloneTree();
  if ( 0 == tnew4 )
  {
    std::cerr << " can't get tree :EtfTofBunch in file EtfTofPar.root" << std::endl;
    return false;
  }
 
  TFile fnew( "TofCalConst.root", "RECREATE" );
  tnew0->Write();
  tnew->Write();
  tnew1->Write();
  tnew2->Write();
  tnew3->Write();
  tnew4->Write();
  f0.Close();
  f.Close();
  f1.Close();
  f2.Close();
  fnew.Close();
 
  t0    = NULL;
  t     = NULL;
  t1    = NULL;
  t2    = NULL;
  t3    = NULL;
  t4    = NULL;
  tnew0 = NULL;
  tnew  = NULL;
  tnew1 = NULL;
  tnew2 = NULL;
  tnew3 = NULL;
  tnew4 = NULL;
 
  return true;
}
 
int main() {
  calib_conv2root();
  barrel_conv2root();
  endcap_conv2root();
  etf_conv2root();
  join();
}