---

TMuiPseudoBLTO.h

Go to the documentation of this file.

// Interface Object Class : TMuiPseudoBLT
// Author: chun zhang
// Data: 12/03/03
// Description: Class for muon identifier road

#ifndef _TMUIPseudoBLTO_H_
#define _TMUIPseudoBLTO_H_

// CINT compatible headers//
//
#include<TDataType.h>
#include<PHKey.hh>
#include<PHException.h>
#include<MUIOO.h>




class TMuiPseudoBLTO : public PHKey {

public:


  
  TMuiPseudoBLTO(){;}  
  
  virtual ~TMuiPseudoBLTO(){;}
  
  TMuiPseudoBLTO(const Key& key) :
    PHKey(key){;}
  
  TMuiPseudoBLTO(const Key&,
                 UShort_t arm,
                 UShort_t index){;}
  
  

  
  virtual void fire_2D() {;}

  virtual void fire_1D1S() {;}

  virtual void fire_1D(const UShort_t iquad) {;}

  virtual void fire_1S(const UShort_t iquad) {;}



  
  virtual void fire_reco_2D() {;}

  virtual void fire_reco_1D1S() {;}

  virtual void fire_reco_1D(const UShort_t iquad) {;}

  virtual void fire_reco_1S(const UShort_t iquad) {;}




  virtual bool is_2D_fired() const { return false;}

  virtual bool is_1D1S_fired() const { return false;}

  virtual bool is_1D_fired(const UShort_t iquad) const { return false;}

  virtual bool is_1S_fired(const UShort_t iquad) const { return false;}




  virtual bool check_2D_trigger() const { return false;}

  virtual bool check_1D1S_trigger() const { return false;}


  virtual bool is_reco_2D_fired() const { return false;}

  virtual bool is_reco_1D1S_fired() const { return false;}

  virtual bool is_reco_1D_fired(const UShort_t iquad) const { return false;}

  virtual bool is_reco_1S_fired(const UShort_t iquad) const { return false;}




  virtual bool check_2D_with_reco() const { return false;}

  virtual bool check_1D1S_with_reco() const { return false;}




  virtual void set_arm( UShort_t arm) {}

  virtual void set_index( UShort_t index) {}

  virtual UShort_t get_arm() const {return 0;}

  virtual UShort_t get_index() const {return 0;}




  virtual void print(std::ostream& os = std::cout) const {}


  ClassDef(TMuiPseudoBLTO,1)

};


class TMuiPseudoBLTO_v1 : public TMuiPseudoBLTO {

public:

  TMuiPseudoBLTO_v1();  

  virtual ~TMuiPseudoBLTO_v1(){;}

  TMuiPseudoBLTO_v1(const Key&,
                    UShort_t arm,
                    UShort_t index);  


  TMuiPseudoBLTO_v1(const TMuiPseudoBLTO*);  

  TMuiPseudoBLTO_v1(const TMuiPseudoBLTO&);  

  void fire_2D() { _is_2D = true;}

  void fire_1D1S() { _is_1D1S = true;}

  void fire_1D( const UShort_t iquad) {
    switch(iquad) 
      {
      case 0:
        _is_1D_quad0 = true;
        break;
      case 1:
        _is_1D_quad1 = true;
        break;
      case 2:
        _is_1D_quad2 = true;
        break;
      case 3:
        _is_1D_quad3 = true;
      }
  }

  void fire_1S( const UShort_t iquad) {
    switch(iquad) 
      {
      case 0:
        _is_1S_quad0 = true;
        break;
      case 1:
        _is_1S_quad1 = true;
        break;
      case 2:
        _is_1S_quad2 = true;
        break;
      case 3:
        _is_1S_quad3 = true;
      }
  }
  
  bool check_2D_trigger() const;
  bool check_1D1S_trigger() const;

  bool is_2D_fired() const { return _is_2D;}
  
  bool is_1D1S_fired() const { return _is_1D1S;}

  bool is_1D_fired(const UShort_t iquad) const {
    switch(iquad)
      {
      case 0:
        return _is_1D_quad0;
      case 1:
        return _is_1D_quad0;
      case 2:
        return _is_1D_quad0;
      case 3:
        return _is_1D_quad0;
      default:
        return false;
      }
  }

  bool is_1S_fired(const UShort_t iquad) const {
    switch(iquad)
      {
      case 0:
        return _is_1S_quad0;
      case 1:
        return _is_1S_quad0;
      case 2:
        return _is_1S_quad0;
      case 3:
        return _is_1S_quad0;
      default:
        return false;
      }
  }

  void fire_reco_2D() { _is_reco_2D = true;}

  void fire_reco_1D1S() { _is_reco_1D1S = true;}

  void fire_reco_1D( const UShort_t iquad) {
    switch(iquad) 
      {
      case 0:
        _is_reco_1D_quad0 = true;
        break;
      case 1:
        _is_reco_1D_quad1 = true;
        break;
      case 2:
        _is_reco_1D_quad2 = true;
        break;
      case 3:
        _is_reco_1D_quad3 = true;
      }
  }

  void fire_reco_1S( const UShort_t iquad) {
    switch(iquad) 
      {
      case 0:
        _is_reco_1S_quad0 = true;
        break;
      case 1:
        _is_reco_1S_quad1 = true;
        break;
      case 2:
        _is_reco_1S_quad2 = true;
        break;
      case 3:
        _is_reco_1S_quad3 = true;
      }
  }

  bool is_reco_2D_fired() const { return _is_reco_2D;}

  bool is_reco_1D1S_fired() const { return _is_reco_1D1S;}

  bool is_reco_1D_fired(const UShort_t iquad) const {
    switch(iquad)
      {
      case 0:
        return _is_reco_1D_quad0;
      case 1:
        return _is_reco_1D_quad0;
      case 2:
        return _is_reco_1D_quad0;
      case 3:
        return _is_reco_1D_quad0;
      default:
        return false;
      }
  }

  bool is_reco_1S_fired(const UShort_t iquad) const {
    switch(iquad)
      {
      case 0:
        return _is_reco_1S_quad0;
      case 1:
        return _is_reco_1S_quad0;
      case 2:
        return _is_reco_1S_quad0;
      case 3:
        return _is_reco_1S_quad0;
      default:
        return false;
      }
  }
  
  bool check_2D_with_reco() const { 
    if(_is_reco_2D == _is_2D) return true;
    return false;
  }
  
  bool check_1D1S_with_reco() const {
    if(_is_reco_1D1S == _is_1D1S) return true;
    return false;
  }

  void set_arm( UShort_t arm) { _arm=arm;}

  void set_index( UShort_t index) { _index=index;}

  UShort_t get_arm() const {return _arm;}

  UShort_t get_index() const {return _index;}

  void print(std::ostream& os = std::cout) const {
    MUIOO::PRINT(os,GetName());
    os << " arm:         " << _arm << std::endl;
    os << " index:       " << _index << std::endl;
    os << " is_2D:       " << _is_2D << std::endl;
    os << " is_1D1S:     " << _is_1D1S << std::endl;
    os << " is_1D_quad0: " << _is_1D_quad0 << std::endl;
    os << " is_1D_quad1: " << _is_1D_quad1 << std::endl;
    os << " is_1D_quad2: " << _is_1D_quad2 << std::endl;
    os << " is_1D_quad3: " << _is_1D_quad3 << std::endl;
    os << " is_1S_quad0: " << _is_1S_quad0 << std::endl;
    os << " is_1S_quad1: " << _is_1S_quad1 << std::endl;
    os << " is_1S_quad2: " << _is_1S_quad2 << std::endl;
    os << " is_1S_quad3: " << _is_1S_quad3 << std::endl;
    os << " trigger decisions from reconstructed hits. " << std::endl;
    os << " is_reco_2D:       " << _is_reco_2D << std::endl;
    os << " is_reco_1D1S:     " << _is_reco_1D1S << std::endl;
    os << " is_reco_1D_quad0: " << _is_reco_1D_quad0 << std::endl;
    os << " is_reco_1D_quad1: " << _is_reco_1D_quad1 << std::endl;
    os << " is_reco_1D_quad2: " << _is_reco_1D_quad2 << std::endl;
    os << " is_reco_1D_quad3: " << _is_reco_1D_quad3 << std::endl;
    os << " is_reco_1S_quad0: " << _is_reco_1S_quad0 << std::endl;
    os << " is_reco_1S_quad1: " << _is_reco_1S_quad1 << std::endl;
    os << " is_reco_1S_quad2: " << _is_reco_1S_quad2 << std::endl;
    os << " is_reco_1S_quad3: " << _is_reco_1S_quad3 << std::endl;
    MUIOO::PRINT(os,"**");
  }
  
private:
  
  UShort_t _arm;
  UShort_t _index;
  
  bool _is_2D;
  bool _is_1D1S;
  bool _is_1D_quad0;
  bool _is_1D_quad1;
  bool _is_1D_quad2;
  bool _is_1D_quad3;
  bool _is_1S_quad0;
  bool _is_1S_quad1;
  bool _is_1S_quad2;
  bool _is_1S_quad3;

  bool _is_reco_2D;
  bool _is_reco_1D1S;
  bool _is_reco_1D_quad0;
  bool _is_reco_1D_quad1;
  bool _is_reco_1D_quad2;
  bool _is_reco_1D_quad3;
  bool _is_reco_1S_quad0;
  bool _is_reco_1S_quad1;
  bool _is_reco_1S_quad2;
  bool _is_reco_1S_quad3;
 
  ClassDef(TMuiPseudoBLTO_v1,1)
};

#endif /* _TMUIPSEUDOBLTO_H_ */
              

---