TofCaliSvc/TofCaliSvc-00-01-19/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 "TTree.h"
#include "TFile.h"
#include <assert.h>
#include <iostream>
#include <fstream>
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();
}