---

mMuiBLTEmulator.cxx

Go to the documentation of this file.

//
// Utility class: mMuiBLTEmulator:
// Author: chun zhang
// Date: 12/03/03
// Description: BLT emulator 
//              

// MUIOO/MUTOO headers
//
#include <mMuiBLTEmulator.h>
#include <mMuiBLTEmulatorPar.h>
#include <TMutNode.h>
#include <PHException.h>
#include <MUTOO.h>
#include <PHTimer.h>
#include <TMuiHitMapO.h>
#include <TMuiMCHitMapO.h>
#include <TMuiPseudoBLTMapO.h>

// PHENIX db headers.
//
#include "RunToTimeObjy.hh"
#include "PdbBankManager.hh"
#include "PdbApplication.hh"
#include "PdbObjyBankManager.hh"
#include "PdbBankID.hh"
#include "PdbMuiTriggerMLU.hh"
#include "PdbCalBank.hh"
// MUID Geometry header.
//
#include <mMuiInitModule.h>
#include <PHCompositeNode.h>
#include <TMuiReadoutID.hh>
#include <TMuiAddressTable.hh>


// PHENIX RECO headers
//
#include "recoConsts.h" 

// STL/BOOST
//
#include <iostream>
#include <string>
#include <list>
#include <boost/array.hpp>

mMuiBLTEmulator::mMuiBLTEmulator() : _timer("mMuiBLTEmulator")
{
  name = "mMuiBLTEmulator";
  MUTOO::TRACE("initializing module " + std::string(name.getString()));    
  init_done = 0;
  _non_used_plane = 4;
}

// Destructor

mMuiBLTEmulator::~mMuiBLTEmulator() { }

// Event method.

PHBoolean mMuiBLTEmulator::event(PHCompositeNode* top_node)
{

  _timer.restart(); 
  
  try { 

    // Reset IOC pointers
    //
    set_interface_ptrs(top_node);
    // do the initialization for first event.
    //
    // if(!init_done) initialize();

    // collects all the raw hits/hits information.
    //
    if(_mod_par->get_mode()==mMuiBLTEmulatorPar::FROMPRDF) get_raw_data();
    if(_mod_par->get_mode()==mMuiBLTEmulatorPar::FROMDST) get_hits();
    // transfer the hit to trigger primary format.
    //
    raw_to_trigpattern();
    // Fill trigger decisions into pseudo-trigger map.
    //
    fill_map();
    // check blt emualtor according to the hit information.
    //
    if(_mod_par->get_debug_flag()==1) check_blt();
  } catch(std::exception& e) {
    MUTOO::TRACE(e.what());
    return False;
  }  

  // Timer
  //
  _timer.print(); 
  return True;
}

void 
mMuiBLTEmulator::get_raw_data() {
  // get raw data from event_node. then store it into 
  // arry word[arm][orientation][iword].
  // Tatally there are 120 words per orientation, and the low 16 bits
  // in each word represents 16 twopacks. 
  //
  Packet* p;  
  static const int id_base[max_arm] = {12001, 12003}; // for South and North

  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for(int iorient = 0; iorient < MUIOO::MAX_ORIENTATION; iorient++) {
      int pack_id = id_base[iarm] + iorient;
      if((p=_event->getPacket(pack_id))!=0) {
        for(int iword = 0; iword < MUIOO::kWordsPerFEM; iword++) {
          word[iarm][iorient][iword] = p->iValue(iword);
        }
        delete p;
      }
    }
  }
}

void mMuiBLTEmulator::get_hits(){
  // Loop through mui hit map, fill word array 
  // muioo hit is organized by (arm, plane, panel, orientation, twopack),
  // but word array is organized by FEM address and every word uses its
  // low 16 bits to store 16 twopacks, we need to map muioo hit into 
  // low 16 bits of each word in word array. This transform is taken care by
  // TMuiChannelId and TMuiAddressTable::Table()->HardwareAddress(TMuiChannelId).
  // Here I just call them.
  //

  // clear word array for each event.
  //
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++){
    for(int iorient = 0; iorient < MUIOO::MAX_ORIENTATION; iorient++) {
      for(int iword = 0; iword < MUIOO::kWordsPerFEM; iword++) {
        word[iarm][iorient][iword] = 0;
      }
    }
  }

  TMuiHitMapO::const_iterator hit_iter = _hit_map->range();
  while(TMuiHitMapO::const_pointer hit_ptr = hit_iter.next()){
    EOrient_t orientation = kVERT;
    if(hit_ptr->get()->get_orientation()==0) orientation = kHORIZ;
    
    TMuiChannelId muichannel(hit_ptr->get()->get_arm(),
                             hit_ptr->get()->get_plane(),
                             hit_ptr->get()->get_panel(),
                             orientation,
                             hit_ptr->get()->get_twopack());
    TMuiReadoutID hardware = TMuiAddressTable::Table()->HardwareAddress(muichannel);
    int iword = hardware.ROC()*MUIOO::kWordsPerROC+hardware.Word();
    int ibit  = hardware.Channel();

    word[hit_ptr->get()->get_arm()][hit_ptr->get()->get_orientation()][iword] |= (0x01<<ibit);  
  }
}

void mMuiBLTEmulator::raw_to_trigpattern() {

  // This whole piece is taken directly from Hiroki's code without any changes. Except for
  // using three/four dimension array to handle two arm at the same time. I was very careful about 
  // this little change.
  //

  // convert FEM word[iarm(0-1)][ifem(0-1)][word 0-119](0-0xffff) to trig_pattern[iarm(0-1)][quad(0-3)][plane(0-3)](0-15)

  const int max_sector = 8;
  int trig_bit[MUIOO::NumberOfArms][MUIOO::MAX_ORIENTATION][MUIOO::MAX_PLANE-1][max_sector];
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for ( int iorient = 0; iorient<MUIOO::MAX_ORIENTATION; iorient++ ) {
      for ( int iplane = 0; iplane<MUIOO::MAX_PLANE-1; iplane++ ){
        for ( int k = 0; k<max_sector; k++ ) {
          trig_bit[iarm][iorient][iplane][k] = 0;
        }
      }
    }
  }

  // use lower 16 bits of each word
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for( int iorient = 0; iorient<MUIOO::MAX_ORIENTATION; iorient++ ) {
      for ( int iword = 0; iword<MUIOO::kWordsPerFEM; iword++ ) {
        word[iarm][iorient][iword] = word[iarm][iorient][iword] & 0xffff;
      }
    }
  }
  // word -> trig_bit

  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    int plane_new = 0;
    for ( int plane = 0; plane<MUIOO::MAX_PLANE; plane++ ) {
      // There are 5 planes int word[][][], but only 4 planes in trig_bit[][][]
      if ( plane != get_non_used_plane()) { 
        for ( int sector = 0; sector<max_sector; sector++ ) {
          if ( sector % 2 == 0 ) {
            trig_bit[iarm][ 0 ][ plane_new ][ sector ] = 
            word[iarm][ 0 ][ plane*24 + sector*3  + 0 ]
            + word[iarm][ 0 ][ plane*24 + sector*3 + 1 ] 
            + word[iarm][ 0 ][ plane*24 + sector*3 + 2 ] 
            + word[iarm][ 0 ][ plane*24 + sector*3 + 3 ] ;
          }
          else {
            trig_bit[iarm][ 0 ][ plane_new ][ sector ] = 
              word[iarm][ 0 ][ plane*24 + (sector-1)*3 + 2 ]
              + word[iarm][ 0 ][ plane*24 + (sector-1)*3 + 3 ]
              + word[iarm][ 0 ][ plane*24 + (sector-1)*3 + 4 ]
              + word[iarm][ 0 ][ plane*24 + (sector-1)*3 + 5 ];
          }
          for ( int iword = 0; iword<3; iword++ ) {
            trig_bit[iarm][ 1 ][ plane_new ][ sector ]
              += word[iarm][ 1 ][ plane*24 + sector*3 + iword ]; 
          }
        }
        plane_new++;
      }
    }
  }
  // take "OR"
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for ( int iorient = 0; iorient < MUIOO::MAX_ORIENTATION; iorient++){ // orientation
      for ( int iplane = 0; iplane < MUIOO::MAX_PLANE-1; iplane++ ){ // plane
        for ( int k = 0; k<max_sector; k++ ) { //sector
          if ( trig_bit[iarm][iorient][iplane][k] != 0 ) { 
            trig_bit[iarm][iorient][iplane][k] = 1;
          }
        }
      }
    }
  }
  // trig_bit -> trig_pattern
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for ( int iquad = 0; iquad<max_quad; iquad++ ) {
      for ( int iplane = 0; iplane < MUIOO::MAX_PLANE-1; iplane++ ){ // plane
        trig_pattern[iarm][iquad][iplane] = 0;
      }
    }
  }
 
  // Chun :: horizental and vertial planes have different sector configuration.
  //         horizental :: sector    6 4 2 0   quadrant 3   1 
  //
  //
  //                                 7 5 3 1            4   2
  //
  //         vertical   :: sector    1     0   quadrant 3   1
  //                                 3     2
  //                                 5     4
  //                                 7     6            4   2
  //
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    for( int plane = 0; plane<MUIOO::MAX_PLANE-1; plane++ ){
      trig_pattern[iarm][0][plane] 
        += trig_bit[iarm][0][plane][0] * (int)pow( 2.0, 1 )
        + trig_bit[iarm][0][plane][2] * (int)pow( 2.0, 0 ) 
        + trig_bit[iarm][1][plane][0] * (int)pow( 2.0, 3 )
        + trig_bit[iarm][1][plane][2] * (int)pow( 2.0, 2 );
      trig_pattern[iarm][1][plane] 
        += trig_bit[iarm][0][plane][1] * (int)pow( 2.0, 1 )
        + trig_bit[iarm][0][plane][3] * (int)pow( 2.0, 0 ) 
        + trig_bit[iarm][1][plane][4] * (int)pow( 2.0, 2 )
        + trig_bit[iarm][1][plane][6] * (int)pow( 2.0, 3 );
      trig_pattern[iarm][2][plane] 
        += trig_bit[iarm][0][plane][4] * (int)pow( 2.0, 0 )
        + trig_bit[iarm][0][plane][6] * (int)pow( 2.0, 1 ) 
        + trig_bit[iarm][1][plane][1] * (int)pow( 2.0, 3 )
        + trig_bit[iarm][1][plane][3] * (int)pow( 2.0, 2 );
      trig_pattern[iarm][3][plane] 
        += trig_bit[iarm][0][plane][5] * (int)pow( 2.0, 0 )
        + trig_bit[iarm][0][plane][7] * (int)pow( 2.0, 1 ) 
        + trig_bit[iarm][1][plane][5] * (int)pow( 2.0, 2 )
        + trig_bit[iarm][1][plane][7] * (int)pow( 2.0, 3 );
    }
  }
}

int 
mMuiBLTEmulator::decision_event(int arm) {
  
  // Copy of Hiroki's code, modification I made is
  // having arm as an input to handle both arm 
  
  int trig_pattern_arm[max_quad][MUIOO::MAX_PLANE-1];
  
  for(int iquad = 0; iquad < max_quad; iquad++) {
    for(int iplane = 0; iplane < MUIOO::MAX_PLANE-1; iplane++) {
      trig_pattern_arm[iquad][iplane] = trig_pattern[arm][iquad][iplane];
    }
  }

  for( int quad = 0; quad<max_quad; quad++ ){
    trig_accept[arm][quad] = 0;
  }
  
  for ( int quad = 0; quad<max_quad; quad++ ) {
    if ( quad_fire( trig_pattern_arm[quad], mlu_data_d ) == 1 ) {
      trig_accept[arm][quad] = DEEP_ROAD;
    }
    else if ( quad_fire( trig_pattern_arm[quad], mlu_data_s ) == 1 ) {
      trig_accept[arm][quad] = SHALLOW_ROAD;
    }
  } 
  return decision_mlu(arm);
}

int mMuiBLTEmulator::quad_fire(int quad_trig_pattern[max_plane], int mlu_data[ mlu_address_max ]  )
{
  // copy from Hiroki's code, take out 'cout'
  //
  int fired = 0;
  int address = 0;
  int data_bit = 0;
  for ( int plane = 0; plane<max_plane - 1; plane++ ) {
    for ( int bit = 0; bit<4; bit++ ) {
      if ( ( ( quad_trig_pattern[plane] & (1<<bit) ) >> bit ) == 1 ) { 
        address += (int)pow( 2.0, bit + plane * 4 );  
      }
    }
  }
  data_bit = quad_trig_pattern[3];
  
  //  int scan_data;
  if ( ( ( mlu_data[address] & (1<<data_bit) ) >> data_bit ) == 1 ) {
    fired++;
  }
  if ( fired > 0 ) {
    return 1;
  }
  else{
    return 0;
  }
}


int mMuiBLTEmulator::decision_mlu( int arm) {

  // copy from hiroki's code, just take out 'cout'
  //

  short shallow = 0;
  short deep = 0;

  int exclusive_switch = 0;
  // if this is 1, all five bits are excusive.

  for( int quad = 0; quad<max_quad; quad++ ) {
    if ( trig_accept[arm][quad] > 0 ) {
      if ( trig_accept[arm][quad] == DEEP_ROAD ) {
        deep++;
      } else if ( trig_accept[arm][quad] == SHALLOW_ROAD ) {
        shallow++;
      }
    }
  }
     
  if ( deep >= 2 ) {
    if( exclusive_switch == 1 ) {
      return DEEP_DEEP;
    }
    else {
      return DEEP_DEEP + DEEP_SHALLOW + SHALLOW_SHALLOW +
        SINGLE_DEEP + SINGLE_SHALLOW;
    }
  } else if ( deep == 1 && shallow >= 1 ) {
    if( exclusive_switch == 1 ) {
      return DEEP_SHALLOW;
    } else {
      return DEEP_SHALLOW + SHALLOW_SHALLOW + SINGLE_DEEP + SINGLE_SHALLOW;
    }
  } else if ( deep == 1 ) {
    if( exclusive_switch == 1 ) {
      return SINGLE_DEEP;
    } else {
      return SINGLE_DEEP + SINGLE_SHALLOW;
    }
  }
  else if ( shallow >= 2 ) {
    if( exclusive_switch == 1 ) {
      return SHALLOW_SHALLOW;
    } else {
      return SHALLOW_SHALLOW + SINGLE_SHALLOW;
    }
  }
  else if ( shallow == 1 ) {
    return SINGLE_SHALLOW;
  } else {
    return 0;
  } 
}

void 
mMuiBLTEmulator::fill_map() {
  
  // Take the output from emulator, fill pseudo-BLT map.
  //
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    TMuiPseudoBLTMapO::iterator blt_iter = _blt_map->insert_new(iarm);
    int pseudoblt_bit = decision_event(iarm);
    if( (pseudoblt_bit & DEEP_DEEP) != 0 ) blt_iter->get()->fire_2D();
    if( (pseudoblt_bit & DEEP_SHALLOW) != 0 ) blt_iter->get()->fire_1D1S();
    for(int iquad = 0; iquad < max_quad; iquad++) {
      if(trig_accept[iarm][iquad]==DEEP_ROAD) {
        blt_iter->get()->fire_1D(iquad);
        blt_iter->get()->fire_1S(iquad);
      } else if(trig_accept[iarm][iquad]==SHALLOW_ROAD) {
        blt_iter->get()->fire_1S(iquad);
      }
    }
    if(is_reco_2D(iarm)) blt_iter->get()->fire_reco_2D();
    if(is_reco_1D1S(iarm)) blt_iter->get()->fire_reco_1D1S();
    for(int iquad = 0; iquad < max_quad; iquad++) {
      if(is_reco_1D(iarm,iquad)) blt_iter->get()->fire_reco_1D(iquad);
      if(is_reco_1S(iarm,iquad)) blt_iter->get()->fire_reco_1S(iquad);
    }
  }
}

void 
mMuiBLTEmulator::set_interface_ptrs(PHCompositeNode* top_node){  
  // module runtime parameters
  //
  _mod_par    = TMutNode<mMuiBLTEmulatorPar>::find_node(top_node,"mMuiBLTEmulatorPar");
  // interface map 
  //
  _blt_map    = TMutNode<TMuiPseudoBLTMapO>::find_node(top_node,"TMuiPseudoBLTMapO");

  if(_mod_par->get_mode()==mMuiBLTEmulatorPar::FROMPRDF){
    _event = TMutNode<Event>::find_node(top_node,"PRDF");
    _hit_map = 0;
  }
  if(_mod_par->get_mode()==mMuiBLTEmulatorPar::FROMDST){
    _event = 0;
    _hit_map    = TMutNode<TMuiHitMapO>::find_node(top_node,"TMuiHitMapO");
  }
} 

void mMuiBLTEmulator::initialize(int runNumber){

  // initialize of non_used_plane
  const int nup_max = 3; // non_used_plane
  int nup_begin[nup_max];
  int nup_end[nup_max];
  int nup[nup_max];
  
  int init_done = 0;

  nup_begin[0] = 35758;
  nup[0] = 1;
  nup_end[0] = 40655; // end of Run-2
  nup_begin[1] = 40656; // It is not certain when it changed?
  nup[1] = 2;
  nup_end[1] = 71869;  
  nup_begin[2] = 71870;  // Nobu
  nup[2] = 4;
  nup_end[2] = 9999999; // current configuration

  //  int runNumber= 0;
  //if(_event) {
  //  runNumber = _event->getRunNumber();
  //} else {
  //  recoConsts* rc = recoConsts::instance();
  //  runNumber = rc->get_IntFlag("RUNNUMBER",80312);
  //  cout << " mMuiBLTEmulator :: the runNumber we get from this analysis is " << runNumber << endl; 
  // }

  int nup_found = 0;
  for ( int nup_set = 0; nup_set < nup_max; nup_set++ ) {
    if ( runNumber >= nup_begin[nup_set] && 
         runNumber <= nup_end[nup_set] ) {
      set_non_used_plane(nup[nup_set]);
      nup_found = 1;
      cout << " mMuiPsedoTrigger Non_Used_Plane was set to "
           << get_non_used_plane() << endl;
    }
  }
  if( !nup_found ) {
    cout << " mMuiPsedoTrigger Non_Used_Plane was not found for Run "
         << runNumber  << endl;
    cout << "   Default value " << get_non_used_plane() << " will be used " << endl;
  }

  //Let's see if the database contains a time stamp for this run number,
  // if so we'll try to get the map from the database.
  init_done = -1;
  bool db_init_done = false;
  RunToTimeObjy runTime;
  PHTimeStamp *beginTime = runTime.getBeginTime(runNumber);
  if (beginTime)
  {
    PdbBankManager *bankManager = PdbObjyBankManager::instance();
    PdbApplication *application = bankManager->getApplication();  
    if (application->startRead()) {
      PdbMuiTriggerMLU *achan;
      PdbBankID shortbankID("*.calib.mui.muitriggermlu");
      shortbankID.setInternalValue(0);  //Shallow MLU will be 0
      PdbCalBank* shortBank =
        bankManager->fetchBank("PdbMuiTriggerMLUBank",shortbankID,"calib.mui.muitriggermlu",runNumber);
       //We are good to go!
          //First the shallow
      if(shortBank > 0)
      {
        shortBank->print();
          PdbMuiTriggerMLU *achan;
          if(shortBank->getLength()<=mlu_address_max){
            for(unsigned int wordid = 0; wordid < shortBank->getLength(); wordid++)
            {
              achan = (PdbMuiTriggerMLU*)&(shortBank->getEntry(wordid));
              mlu_data_s[wordid]=achan->MLUword();
            }
            db_init_done = true;
          }
          else
          {
            cout << PHWHERE << "More data in database than expected."<<endl;
            db_init_done = false;
          }
          delete shortBank;
      }
      else
      {
        cout << PHWHERE << "Map wasn't found in database."<<endl;
      }
      PdbBankID deepbankID("*.calib.mui.muitriggermlu");
      deepbankID.setInternalValue(1);  //Deep MLU will be 1
      PdbCalBank* deepBank =
        bankManager->fetchBank("PdbMuiTriggerMLUBank",deepbankID,"calib.mui.muitriggermlu",runNumber);
      if(deepBank > 0)
      {
        deepBank->print();
        //Now the deep
        if(deepBank->getLength()<=mlu_address_max){
          for(unsigned int wordid = 0; wordid < deepBank->getLength(); wordid++)
          {
            achan = (PdbMuiTriggerMLU*)&(deepBank->getEntry(wordid));
            mlu_data_d[wordid]=achan->MLUword();
          }
          db_init_done = true;
          delete deepBank;
        }
        else
        {
          cout << PHWHERE << "More data in database than expected."<<endl;
          db_init_done = false;
        }
      }
      else
      {
        cout << PHWHERE << "Map wasn't found in database."<< endl;
      }

      application->commit();
    }
    else
    {
      cout << PHWHERE << "Failed to start application for update" << endl;
    }
     delete beginTime;
  }
  if(db_init_done)
  {
    init_done = 1;
    return ;
  }
  else
  {
    cout<< PHWHERE << "Map not found in database will try local files."<< endl;
  }

  int map_select = _mod_par->get_mlu_map();
  char* mlu_file_d;
  char* mlu_file_d1 = "mui_pseudotrigmap_deep_mh1.dat";
  char* mlu_file_d2 = "mui_pseudotrigmap_deep_mh2.dat";
  // MLU data file for deep roads
  char* mlu_file_s = "mui_pseudotrigmap_shallow.dat";
  int run_pp_begin = 35758;
  int run_change_deep = 38189;
  int run_pp_end = 40655;
  
  if( map_select == 1 || map_select == 0 && ( (runNumber >= run_pp_begin) && (runNumber < run_change_deep) ) )  {
    mlu_file_d = mlu_file_d1;
  }
  else if( (map_select == 2 ) || map_select == 0 && ( (runNumber >= run_change_deep) && (runNumber <= run_pp_end) ) ) {
    mlu_file_d = mlu_file_d2;
  }
  else { 
    cout << " mMuiPseudoTrigger: This is not pp Run2 or simulation" << endl;
    cout << "   No MLU map was read" << endl;
    return;
  }

  if( read_mlu_data( mlu_data_d, mlu_file_d ) ) {
      cout << "mMuiPsedoTrigger; MLU data for deep roads " 
           << mlu_file_d << " was read" << endl;    
  }
  else {
    return;
  }

  if( read_mlu_data( mlu_data_s, mlu_file_s ) ) {
      cout << "mMuiPsedoTrigger; MLU data for shallow roads " 
           << mlu_file_s << " was read" << endl;    
  }
  else {
    return;
  } 

   init_done = 1;
}

bool mMuiBLTEmulator::read_mlu_data( int* mlu_word, char* mlu_data_file = "deep.dat"){

  for ( int i = 0; i<mlu_address_max; i++ ) {
    mlu_word[i] = 0;
  }

  FILE* fp;
  if ( !( fp = fopen( mlu_data_file, "r" ))) {
    printf(" mMuiPseudoTrigger: Input file '%s' can not be opened\n",mlu_data_file);
   return False;
  }
  int scan_data;
  for ( int i = 0; i<mlu_address_max; i++ ) {
    if ( fscanf( fp, "%x\n", &scan_data ) != EOF ) {
      mlu_word[i] = scan_data;
    }
    else {
      printf(" mMuiPseudoTrigger: unable to read %d th line of '%s'\n", i, mlu_data_file);
      return False;
    }
  }
  fclose( fp );

  return True;

}

bool mMuiBLTEmulator::is_reco_2D(int arm) {

  for(int iquad1 = 0; iquad1 < 4; iquad1++) {
    if(is_reco_1D(arm, iquad1)) {
      for(int iquad2=0; iquad2<4; iquad2++) {
        if(iquad2==iquad1) continue;
        if(is_reco_1D(arm,iquad2)) return true;
      }
    }
  }
  return false;
}

bool mMuiBLTEmulator::is_reco_1D1S(int arm) {
  for(int iquad1 = 0; iquad1 < 4; iquad1++) {
    if(is_reco_1D(arm, iquad1)) {
      for(int iquad2=0; iquad2<4; iquad2++) {
        if(iquad2==iquad1) continue;
        if(is_reco_1D(arm,iquad2) || is_reco_1S(arm,iquad2)) return true;
      }
    }
  }
  return false;
}

bool mMuiBLTEmulator::is_reco_1D(int arm, int quad) {

  int nhit_quad = 0;
  
  for(int iplane = 0; iplane < MUIOO::MAX_PLANE-1; iplane++) {
    for(int iorient = 0; iorient < MUIOO::MAX_ORIENTATION; iorient++){
      int find_flag = 0;
      for(int ipanel = 0; ipanel < MUIOO::MAX_PANEL; ipanel++) {
        TMuiHitMapO::const_iterator mui_hit_iter = _hit_map->get(arm,iplane,ipanel,iorient);
        while(TMuiHitMapO::const_pointer mui_hit_ptr = mui_hit_iter.next()){
          TMuiMCHitMapO::const_key_iterator mc_hit_iter = mui_hit_ptr->get()->get_associated<TMuiMCHitO>();
          while(TMuiMCHitMapO::const_pointer mc_hit_ptr = mc_hit_iter.next()) {
            // if the hit is in big panel( 0, 2, 3, 5) we can decide it's quadrant directly,
            // if the hit is in small panel(1, 4) and on horizental plane, it contributes to
            // both left and right quadrants, if the hit is in small panel and verticle plane,
            // we have to relay on mchit x/y position to decide the quadrant.
            //
            int iquad = -1;

            if(ipanel == 3 ||(ipanel == 4 && iorient == 0) ) {
              iquad = 0;
              if(quad==iquad) find_flag = 1;
            }
            if(ipanel == 5 ||(ipanel == 4 && iorient == 0)) {
              iquad = 1;
              if(quad==iquad) find_flag = 1;
            }
            if(ipanel == 2 ||(ipanel == 1 && iorient == 0)) {
              iquad = 2;
              if(quad==iquad) find_flag = 1;
            }
            if(ipanel == 0 ||(ipanel == 1 && iorient == 0)) {
              iquad = 3;
              if(quad==iquad) find_flag = 1;
            }
            if(iorient == 1 && (ipanel==4||ipanel==1)){
              iquad = get_quad(mc_hit_ptr->get()->get_x(),
                               mc_hit_ptr->get()->get_y(), 
                               mc_hit_ptr->get()->get_z());
              if(quad==iquad) find_flag = 1; 
            }
          }
        }
      }
      if(find_flag) nhit_quad++;
    }
  }
  if(nhit_quad >=7 ) return true;
  
  return false;
}

bool mMuiBLTEmulator::is_reco_1S(int arm, int quad) {

  int nhit_quad = 0;
  
  for(int iplane = 0; iplane < MUIOO::MAX_PLANE-3; iplane++) {
    for(int iorient = 0; iorient < MUIOO::MAX_ORIENTATION; iorient++){
      int find_flag = 0;
      for(int ipanel = 0; ipanel < MUIOO::MAX_PANEL; ipanel++) {
        TMuiHitMapO::const_iterator mui_hit_iter = _hit_map->get(arm,iplane,ipanel,iorient);
        while(TMuiHitMapO::const_pointer mui_hit_ptr = mui_hit_iter.next()){
          TMuiMCHitMapO::const_key_iterator mc_hit_iter = mui_hit_ptr->get()->get_associated<TMuiMCHitO>();
          while(TMuiMCHitMapO::const_pointer mc_hit_ptr = mc_hit_iter.next()) {
            // if the hit is in big panel( 0, 2, 3, 5) we can decide it's quadrant directly,
            // if the hit is in small panel(1, 4) and on horizental plane, it contributes to
            // both left and right quadrants, if the hit is in small panel and verticle plane,
            // we have to relay on mchit x/y position to decide the quadrant.
            //
            int iquad = -1;
            if(ipanel == 3 ||(ipanel == 4 && iorient == 0) ) {
              iquad = 0;
              if(quad==iquad) find_flag = 1;
            } 
            if(ipanel == 5 ||(ipanel == 4 && iorient == 0)) {
              iquad = 1;
              if(quad==iquad) find_flag = 1;
            }
            if(ipanel == 2 ||(ipanel == 1 && iorient == 0)) {
              iquad = 2;
              if(quad==iquad) find_flag = 1;
            }
            if(ipanel == 0 ||(ipanel == 1 && iorient == 0)) {
              iquad = 3;
              if(quad==iquad) find_flag = 1;
            }
            if(iorient == 1 && (ipanel==4||ipanel==1)) {
              iquad = get_quad(mc_hit_ptr->get()->get_x(),
                               mc_hit_ptr->get()->get_y(), 
                               mc_hit_ptr->get()->get_z());
              if(quad==iquad) find_flag = 1; 
            }
          }
        }
      }
      if(find_flag) nhit_quad++;
    }
  }

  if(nhit_quad >=3 ) return true;
  
  return false;
}

    
int mMuiBLTEmulator::get_quad(float x, float y, float z) {
  
  if( x>= 0 && y >= 0 ) return 3;
  if( x>= 0 && y <= 0 ) return 1;
  if( x<= 0 && y >= 0 ) return 2;
  if( x<= 0 && y <= 0 ) return 0;
  
  // not reached
  return -1;
}

void mMuiBLTEmulator::check_blt() {
  
  // define a flag for debug.
  //
  int check_flag = 0;
  for(int iarm = 0; iarm < MUIOO::NumberOfArms; iarm++) {
    TMuiPseudoBLTMapO::const_iterator blt_iter = _blt_map->get(iarm);
    while(TMuiPseudoBLTMapO::const_pointer blt_ptr = blt_iter.next()){
      if(blt_ptr->get()->is_2D_fired()!=is_reco_2D(iarm)) {
        check_flag = 1;
        std::cout << " 2D trigger shows inconsistent " << std::endl;
        dump_reco_blt(iarm);
        blt_ptr->get()->print();
        _hit_map->print();
      } else if(blt_ptr->get()->is_1D1S_fired()!=is_reco_1D1S(iarm)) {
        check_flag = 1;
        std::cout << " 1D1S trigger shows inconsistent " << std::endl;
        dump_reco_blt(iarm);
        blt_ptr->get()->print();
        _hit_map->print();
      } 
    }
  }
}

void mMuiBLTEmulator::dump_reco_blt(int arm) {

  std::cout << " check on arm : " << arm << " :: " <<std::endl;
  std::cout << " reco trigger check from mMuiBLTEmulator " << std::endl;
  std::cout << " is_reco_2D::                            " << is_reco_2D(arm) << std::endl;
  std::cout << " is_reco_1D1S::                          " << is_reco_1D1S(arm) << std::endl;
  std::cout << " is_reco_1D quad0::                      " << is_reco_1D(arm, 0) << std::endl;  
  std::cout << " is_reco_1D quad1::                      " << is_reco_1D(arm, 1) << std::endl;  
  std::cout << " is_reco_1D quad2::                      " << is_reco_1D(arm, 2) << std::endl;  
  std::cout << " is_reco_1D quad3::                      " << is_reco_1D(arm, 3) << std::endl;  
  std::cout << " is_reco_1S quad0::                      " << is_reco_1S(arm, 0) << std::endl;  
  std::cout << " is_reco_1S quad1::                      " << is_reco_1S(arm, 1) << std::endl;  
  std::cout << " is_reco_1S quad2::                      " << is_reco_1S(arm, 2) << std::endl;  
  std::cout << " is_reco_1S quad3::                      " << is_reco_1S(arm, 3) << std::endl;  
}

---