---

TMuiRoadEval.hh

Go to the documentation of this file.

#ifndef __TMUIROADEVAL_H__
#define __TMUIROADEVAL_H__

#include<TDataType.h>
#include<PHException.h>
#include<MUIOO.h>


class TMuiRoadEval : public TObject
{
public:



  TMuiRoadEval();

  virtual ~TMuiRoadEval(){;}



  // getter
  //
  virtual UShort_t get_n_true_hits() const { 
    // count number of bits set to get total number of true hits             
    //
    UShort_t nhits = 0;
    int limit = MUIOO::MAX_PLANE * MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_true_hits & (1<<i)) >> i; 
    }
    return nhits;
  }

  virtual bool get_is_plane_true_hit(UShort_t iplane) const {
    return (_n_true_hits & 1 << iplane) != 0; 
  }

  virtual bool get_is_plane_masked_hit(UShort_t iplane) const {
    return (_n_masked_hits & 1 << iplane) != 0; 
  }

  virtual bool get_is_plane_reco_true_hit(UShort_t iplane) const {
    return (_n_reco_true_hits & 1 << iplane) != 0; 
  }

  virtual bool get_is_plane_reco_ghost_hit(UShort_t iplane) const {
    return (_n_reco_ghost_hits & 1 << iplane) != 0; 
  }

  virtual UShort_t get_panel_true_hits(int ipanel) const { 
    // count number of bits set to get total number of true hits          
    //
    UShort_t nhits = 0;
    int limit = MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_true_hits & (1<<(i + ipanel*limit))) >> (i + ipanel*limit); 
    }
    return nhits;
  }

  virtual UShort_t get_n_masked_hits() const { 
    // count number of bits set to get total number of true hits             
    //
    UShort_t nhits = 0;
    int limit = MUIOO::MAX_PLANE * MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_masked_hits & (1<<i)) >> i; 
    }
    return nhits;
  }

  virtual Float_t get_ratio_masked() const { 
    return difference(get_n_true_hits(),get_n_masked_hits());
  }

  virtual UShort_t get_n_reco_true_hits() const { 
    // count number of bits set to get total number of true hits
    UShort_t nhits=0;
    int limit = MUIOO::MAX_PLANE * MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_reco_true_hits & (1<<i)) >> i;
    }   
    return nhits;       
  }

  virtual UShort_t get_panel_reco_true_hits(int ipanel) const {
    // count number of bits set to get total number of true hits
    //
    UShort_t nhits = 0;
    int limit = MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_reco_true_hits & (1<<(i + ipanel*limit))) >> (i + ipanel*limit);
    }
    return nhits;
  }
                  
  virtual UShort_t get_n_reco_ghost_hits() const {
    // count number of bits set to get total number of true hits
    UShort_t nhits=0;
    int limit = MUIOO::MAX_PLANE * MUIOO::MAX_ORIENTATION;
    for (int i = 0; i<limit; i++){
      nhits += (_n_reco_ghost_hits & (1<<i)) >> i;
    }   
    return nhits;       
  }

  virtual Float_t get_ratio_ghost() const { 
    return difference(get_n_reco_true_hits(), get_n_reco_ghost_hits());
  }

  //setter
  //
  virtual void set_n_true_hits(UShort_t n_true_hits) { _n_true_hits = n_true_hits;}
  virtual void set_n_masked_hits(UShort_t n_masked_hits) { _n_masked_hits = n_masked_hits;}
  virtual void set_n_reco_true_hits(UShort_t n_reco_true_hits) { _n_reco_true_hits = n_reco_true_hits;}
  virtual void set_n_reco_ghost_hits(UShort_t n_reco_ghost_hits) { _n_reco_ghost_hits = n_reco_ghost_hits;}



  //getter
  //
  virtual Float_t get_px_true_vx() const { return _px_true_vx;}
  virtual Float_t get_py_true_vx() const { return _py_true_vx;}
  virtual Float_t get_pz_true_vx() const { return _pz_true_vx;}
  virtual Float_t get_ptot_true_vx() const { return _ptot_true_vx;}

  //setter
  //
  virtual void set_px_true_vx(Float_t px_true) { _px_true_vx = px_true;}
  virtual void set_py_true_vx(Float_t py_true) { _py_true_vx = py_true;}
  virtual void set_pz_true_vx(Float_t pz_true) { _pz_true_vx = pz_true;}
  virtual void set_ptot_true_vx(Float_t ptot_true) { _ptot_true_vx = ptot_true;}


  virtual void TMuiRoadEval::print(std::ostream& os = std::cout) const;

private:

  virtual Float_t difference(Float_t a, Float_t b) const {
    if(a!=0) {
      return (b-a)/a;
    } else {
      return -999.0;
    }
  }

  virtual Float_t difference(UShort_t a, UShort_t b) const {
    if(a!=0) {
      return (1.0*b)/(1.0*a);
    } else {
      return -999.0;
    }
  }

  // Global evalution varibles.
  //
  UShort_t _n_true_hits;
  UShort_t _n_masked_hits;
  UShort_t _n_reco_true_hits;
  UShort_t _n_reco_ghost_hits;

  // Momentum evaluation varibles at vertex.
  //
  Float_t _px_true_vx;
  Float_t _py_true_vx;
  Float_t _pz_true_vx;
  Float_t _ptot_true_vx;

  ClassDef(TMuiRoadEval,1)
};

#endif /* __TMUIROADEVAL_H__ */

---