MdcTSF.cxx

Go to the documentation of this file.

//---------------------------------------------------------------------------//
////      BOOST --- BESIII Object_Oriented Simulation Tool                     /
////
////---------------------------------------------------------------------------/
////
////Description:
////Author:   Caogf
////Created:  Feb, 2006
////Modified:
////Comment:
////
//
#include "Trigger/MdcTSF.h"
 
#include "Identifier/Identifier.h"
#include "Identifier/MdcID.h"
 
#include "RawEvent/DigiEvent.h"
#include "RawEvent/RawDataUtil.h"
 
#include <TString.h>
#include <fstream>
#include <vector>
 
using namespace std;
 
MdcTSF* MdcTSF::mdc_Pointer = 0;
MdcTSF* MdcTSF::get_Mdc( void ) {
  if ( !mdc_Pointer ) mdc_Pointer = new MdcTSF();
  return mdc_Pointer;
}
 
MdcTSF::MdcTSF() {
  ReadLut();
  // Dump();
}
MdcTSF::~MdcTSF() {}
void MdcTSF::setMdcDigi( std::vector<int>& vmdcHit ) {
  std::vector<int> vtmp;
  vtmp.clear();
  digiId.clear();
 
  for ( std::vector<int>::iterator iter = vmdcHit.begin(); iter != vmdcHit.end(); iter += 2 )
  {
    int layer = *iter;
    int wire  = *( iter + 1 );
    if ( layer <= 19 )
    {
      vtmp.push_back( layer );
      vtmp.push_back( wire );
    }
    if ( layer >= 36 && layer <= 39 )
    {
      wire = int( wire / 2 ); // combine neighbor two cells
      vtmp.push_back( layer );
      vtmp.push_back( wire );
    }
  }
 
  // remove the same layer, same cell, because of combine in 10 super layer;
  for ( std::vector<int>::iterator iter = vtmp.begin(); iter != vtmp.end(); iter += 2 )
  {
    bool ifsamelem = false;
    int  layerId   = *( iter );
    int  cellId    = *( iter + 1 );
    for ( std::vector<int>::iterator iter_tmp = iter; iter_tmp != vtmp.end(); iter_tmp += 2 )
    {
      if ( ( iter_tmp + 2 ) != vtmp.end() )
      {
        int layerId_tmp = *( iter_tmp + 2 );
        int cellId_tmp  = *( iter_tmp + 3 );
        if ( ( layerId == layerId_tmp ) && ( cellId == cellId_tmp ) ) ifsamelem = true;
      }
    }
    if ( ifsamelem == false )
    {
      digiId.push_back( layerId );
      digiId.push_back( cellId );
      //     std::cout<<"layer: "<<layerId<<" "<<"wire: "<<cellId<<std::endl;
    }
  }
}
void MdcTSF::CountTS() {
  //============================reset each array======================================
  // super layer one
  for ( int i = 0; i < 48; i++ )
  {
    SL1PivotCellHit[i] = 0;
    SL1TSF[i]          = 0;
    for ( int j = 0; j < 8; j++ ) { SL1HitCount[i][j] = 0; }
  }
  // super layer two
  for ( int i = 0; i < 80; i++ )
  {
    SL2PivotCellHit[i] = 0;
    SL2TSF[i]          = 0;
    for ( int j = 0; j < 12; j++ ) { SL2HitCount[i][j] = 0; }
  }
  // super layer three
  for ( int i = 0; i < 88; i++ )
  {
    SL3PivotCellHit[i] = 0;
    SL3TSF[i]          = 0;
    for ( int j = 0; j < 16; j++ ) { SL3HitCount[i][j] = 0; }
  }
  // super layer four
  for ( int i = 0; i < 112; i++ )
  {
    SL4PivotCellHit[i] = 0;
    SL4TSF[i]          = 0;
    for ( int j = 0; j < 22; j++ ) { SL4HitCount[i][j] = 0; }
  }
  // super layer five
  for ( int i = 0; i < 128; i++ )
  {
    SL5PivotCellHit[i] = 0;
    SL5TSF[i]          = 0;
    for ( int j = 0; j < 31; j++ ) { SL5HitCount[i][j] = 0; }
  }
  // super layer ten
  for ( int i = 0; i < 128; i++ )
  {
    SL10PivotCellHit[i] = 0;
    SL10TSF[i]          = 0;
    for ( int j = 0; j < 81; j++ ) { SL10HitCount[i][j] = 0; }
  }
  //=================================== end reset value ===================================
 
  //============ counting the hit number in each super layer for each combination ========
  int layer, cell, superlayer, ln;
 
  for ( std::vector<int>::iterator iter = digiId.begin(); iter != digiId.end(); iter += 2 )
  {
    layer = *iter;
    cell  = *( iter + 1 );
    if ( layer <= 19 )
    {
      superlayer = (int)layer / 4 + 1;
      ln         = layer % 4;
      if ( superlayer == 1 )
      {
        if ( ln == 2 ) SL1PivotCellHit[cell] = 1;
        for ( unsigned int i = 0; i < SL1.size(); i++ )
        {
          for ( unsigned int j = 0; j < SL1[i].size() / 4; j++ )
          {
            if ( SL1[i][3 - ln + j * 4] == cell + 1 ) SL1HitCount[i][j] += 1;
          }
        }
      } // end super layer1
 
      if ( superlayer == 2 )
      {
        if ( ln == 2 ) SL2PivotCellHit[cell] = 1;
        for ( unsigned int i = 0; i < SL2.size(); i++ )
        {
          for ( unsigned int j = 0; j < SL2[i].size() / 4; j++ )
          {
            if ( SL2[i][3 - ln + j * 4] == cell + 1 ) SL2HitCount[i][j] += 1;
          }
        }
      } // end super layer2
 
      if ( superlayer == 3 )
      {
        if ( ln == 2 ) SL3PivotCellHit[cell] = 1;
        for ( unsigned int i = 0; i < SL3.size(); i++ )
        {
          for ( unsigned int j = 0; j < SL3[i].size() / 4; j++ )
          {
            if ( SL3[i][3 - ln + j * 4] == cell + 1 ) SL3HitCount[i][j] += 1;
          }
        }
      } // end super layer3
 
      if ( superlayer == 4 )
      {
        if ( ln == 2 ) SL4PivotCellHit[cell] = 1;
        for ( unsigned int i = 0; i < SL4.size(); i++ )
        {
          for ( unsigned int j = 0; j < SL4[i].size() / 4; j++ )
          {
            if ( SL4[i][3 - ln + j * 4] == cell + 1 ) SL4HitCount[i][j] += 1;
          }
        }
      } // end super layer4
 
      if ( superlayer == 5 )
      {
        if ( ln == 1 ) SL5PivotCellHit[cell] = 1;
        for ( unsigned int i = 0; i < SL5.size(); i++ )
        {
          for ( unsigned int j = 0; j < SL5[i].size() / 4; j++ )
          {
            if ( SL5[i][3 - ln + j * 4] == cell + 1 ) SL5HitCount[i][j] += 1;
          }
        }
      } // end super layer5
    }
    else
    {
      superlayer = (int)layer / 4 + 1;
      ln         = layer % 4;
      if ( ln == 1 ) SL10PivotCellHit[cell] = 1;
      for ( unsigned int i = 0; i < SL10.size(); i++ )
      {
        for ( unsigned int j = 0; j < SL10[i].size() / 4; j++ )
        {
          if ( SL10[i][3 - ln + j * 4] == cell + 1 ) SL10HitCount[i][j] += 1;
        }
      }
    } // end super layer10
  }
}
void MdcTSF::GetTS() {
  CountTS();
  // find TSF in each super layer
  for ( int i = 0; i < 48; i++ )
    for ( int j = 0; j < 8; j++ )
    {
      if ( SL1HitCount[i][j] >= 3 )
      {
        SL1TSF[i] = 1;
        break;
      } // cout<<"SL1 cell id : "<<i<<endl; break; }
    }
 
  for ( int i = 0; i < 80; i++ )
    for ( int j = 0; j < 12; j++ )
    {
      if ( SL2HitCount[i][j] >= 3 )
      {
        SL2TSF[i] = 1;
        break;
      } // cout<<"SL2 cell id : "<<i<<endl; break; }
    }
 
  for ( int i = 0; i < 88; i++ )
    for ( int j = 0; j < 16; j++ )
    {
      if ( SL3HitCount[i][j] >= 3 )
      {
        SL3TSF[i] = 1;
        break;
      } // cout<<"SL3: "<<i<<endl; break; }
    }
 
  for ( int i = 0; i < 112; i++ )
    for ( int j = 0; j < 22; j++ )
    {
      if ( SL4HitCount[i][j] >= 3 )
      {
        SL4TSF[i] = 1;
        break;
      } // cout<<"SL4: "<<i<<endl; break; }
    }
 
  for ( int i = 0; i < 128; i++ )
    for ( int j = 0; j < 31; j++ )
    {
      if ( SL5HitCount[i][j] >= 3 )
      {
        SL5TSF[i] = 1;
        break;
      } // cout<<"SL5: "<<i<<endl; break; }
    }
 
  for ( int i = 0; i < 128; i++ )
    for ( int j = 0; j < 81; j++ )
    {
      if ( SL10HitCount[i][j] >= 3 )
      {
        SL10TSF[i] = 1;
        break;
      } // cout<<"SL10 : "<<i<<endl; break; }
    }
 
  // combine the continuous TSF
}
 
void MdcTSF::ReadLut() {
  fstream readin;
  int     ncell = 0, pl = 0;
  int     a, b, l4, l3, l2, l1;
  SL1.clear();
  SL2.clear();
  SL3.clear();
  SL4.clear();
  SL5.clear();
  SL10.clear();
  for ( int n = 1; n < 6; n++ )
  {
    if ( n == 1 )
    {
      ncell = 48;
      pl    = 3;
    }
    if ( n == 2 )
    {
      ncell = 80;
      pl    = 7;
    }
    if ( n == 3 )
    {
      ncell = 88;
      pl    = 11;
    }
    if ( n == 4 )
    {
      ncell = 112;
      pl    = 15;
    }
    if ( n == 5 )
    {
      ncell = 128;
      pl    = 18;
    }
 
    for ( int i = 1; i < ( ncell + 1 ); i++ )
    {
      std::vector<int> tmp;
      tmp.clear();
      int     num      = 0;
      TString filename = TString( getenv( "TRIGGERROOT" ) );
      filename += "/data/tsf";
      filename += n;
      filename += "/TSF-SL";
      filename += n;
      filename += "-L";
      filename += pl;
      filename += "-C";
      filename += i;
      filename += ".pat";
      readin.clear();
      readin.open( filename, ios_base::in );
      if ( !readin ) cerr << "can not open the file " << filename << endl;
      while ( readin.good() )
      {
        readin >> a >> b >> l4 >> l3 >> l2 >> l1;
        num++;
      }
      readin.close();
      readin.clear();
      readin.open( filename, ios_base::in );
      if ( !readin ) cerr << "can not open the file again " << filename << endl;
      for ( int j = 0; j < ( num - 1 ); j++ )
      {
        readin >> a >> b >> l4 >> l3 >> l2 >> l1;
        tmp.push_back( l4 );
        tmp.push_back( l3 );
        tmp.push_back( l2 );
        tmp.push_back( l1 );
      }
      readin.close();
      if ( n == 1 ) SL1.push_back( tmp );
      if ( n == 2 ) SL2.push_back( tmp );
      if ( n == 3 ) SL3.push_back( tmp );
      if ( n == 4 ) SL4.push_back( tmp );
      if ( n == 5 ) SL5.push_back( tmp );
    }
  }
  for ( int i = 1; i < 129; i++ )
  {
    std::vector<int> tmp1;
    tmp1.clear();
    int num = 0;
    // TString filename = "/ihepbatch/bes/caogf/data/tsf/tsf10C/TSF-SL10C-L38-C";
    TString filename = TString( getenv( "TRIGGERROOT" ) );
    filename += "/data/tsf10C/TSF-SL10C-L38-C";
    filename += i;
    filename += ".pat";
    readin.clear();
    readin.open( filename, ios_base::in );
    if ( !readin ) cerr << "can not open the file " << filename << endl;
    while ( readin.good() )
    {
      readin >> a >> b >> l4 >> l3 >> l2 >> l1;
      num++;
    }
    readin.close();
    readin.clear();
    readin.open( filename, ios_base::in );
    if ( !readin ) cerr << "can not open the file again " << filename << endl;
 
    for ( int j = 0; j < ( num - 1 ); j++ )
    {
      readin >> a >> b >> l4 >> l3 >> l2 >> l1;
      tmp1.push_back( l4 );
      tmp1.push_back( l3 );
      tmp1.push_back( l2 );
      tmp1.push_back( l1 );
    }
    readin.close();
    SL10.push_back( tmp1 );
  }
}
void MdcTSF::Dump() {
  std::vector<int> combine_size;
  cout << endl;
  cout << "     ***************check data file tsf: *****************      " << endl;
  cout << "*--------------------------BEGIN-------------------------------*" << endl;
  cout << endl;
 
  cout << "      -------------------SL1----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL1.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL1[i].size() );
    for ( unsigned int j = 0; j < SL1[i].size(); j++ )
    {
      cout << SL1[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "      -------------------SL2----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL2.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL2[i].size() );
    for ( unsigned int j = 0; j < SL2[i].size(); j++ )
    {
      cout << SL2[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "      -------------------SL3----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL3.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL3[i].size() );
    for ( unsigned int j = 0; j < SL3[i].size(); j++ )
    {
      cout << SL3[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "      -------------------SL4----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL4.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL4[i].size() );
    for ( unsigned int j = 0; j < SL4[i].size(); j++ )
    {
      cout << SL4[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "      -------------------SL5----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL5.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL5[i].size() );
    for ( unsigned int j = 0; j < SL5[i].size(); j++ )
    {
      cout << SL5[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "      -------------------SL10----------------------         " << endl;
  combine_size.clear();
  for ( unsigned int i = 0; i < SL10.size(); i++ )
  {
    cout << "Cell ID --> " << i << endl;
    combine_size.push_back( SL10[i].size() );
    for ( unsigned int j = 0; j < SL10[i].size(); j++ )
    {
      cout << SL10[i][j] << " ";
      if ( ( j + 1 ) % 4 == 0 ) cout << endl;
    }
    cout << endl;
  }
  sort( combine_size.begin(), combine_size.end() );
  cout << "The Max Number of Combination is " << combine_size[combine_size.size() - 1] / 4
       << endl;
  cout << endl;
 
  cout << "*---------------------------END------------------------------*" << endl;
}