---

mMuiFastRoadFinderPar.h

Go to the documentation of this file.

#ifndef __MMUIFASTROADFINDERPAR_HH__
#define __MMUIFASTROADFINDERPAR_HH__

#include<PHObject.h>
#include<MUIOO.h>
#include<MuiCommon.hh>
#include<TMuiParBase.h>


class mMuiFastRoadFinderPar : public TMuiParBase
{
  
 public: 
  
  enum Mode { ORIGINAL, SIMPLIFIED };

  mMuiFastRoadFinderPar() : 
    _min_valid_hits(3), // 4 => sheep and deep, 2 => really shallow also
    _depth_match(1),
    _min_depth(2),
    _min_slope(0.21255656), // tan(12.0*M_PI/180.0) 
    _mode(SIMPLIFIED)
    {
      _symset_middle[0] = 2;
      _symset_middle[1] = 10;
      _symset_middle[2] = 24;
      _symset_middle[3] = 44;
      _symset_middle[4] = 70;

      _symset_upper[0] = 4;
      _symset_upper[1] = 15;
      _symset_upper[2] = 32;
      _symset_upper[3] = 55;
      _symset_upper[4] = 84;

      int iplane;
      for (iplane = 0; iplane < MUIOO::MAX_PLANE; iplane++)
        {
          _symset_per_plane[iplane] = _symset_upper[iplane] - _symset_middle[iplane] + 1;
        }
      iplane = 0;
      for (int isymset = 0; isymset < MAX_SYMSET; isymset++)
        {
          if (isymset > _symset_upper[iplane]) iplane++;
          _symset_plane[isymset] = iplane;
          _symset_logical_offset[isymset] = isymset - _symset_middle[iplane];
        }
      // minimum momentum, arm 0 
      _min_momentum[0][0] = 1.49;
      _min_momentum[0][1] = 1.63; 
      _min_momentum[0][2] = 1.76; 
      _min_momentum[0][3] = 2.04; 
      _min_momentum[0][4] = 2.31;
      // arm 1, same as for arm 0, to start with
      _min_momentum[1][0] = 1.49;
      _min_momentum[1][1] = 1.63; 
      _min_momentum[1][2] = 1.76; 
      _min_momentum[1][3] = 2.04; 
      _min_momentum[1][4] = 2.31;

      // variables specific to original version
      for (iplane = 0; iplane < MUIOO::MAX_PLANE; iplane++)
        {
          _maxmisshits[iplane] = 1;
          for (int jplane = 0; jplane < MUIOO::MAX_PLANE; jplane++)
            {
              // showercut
              if (iplane>=jplane) {
                _showercut[iplane][jplane] = 6;
              }
              else {
                _showercut[iplane][jplane] = 0;
              }
              // swi
              if (iplane>=jplane && jplane!=0) {
                _swi[iplane][jplane] = 1;
              }
              else {
                _swi[iplane][jplane] = 0;
              }
              // maxskip
              if (iplane>=jplane) {
                _maxskip[iplane][jplane] = 1 + iplane/3;
              }
              else {
                _maxskip[iplane][jplane] = 0;
              }

            }//jplane
        }//iplane
    }
  
  ~mMuiFastRoadFinderPar(){;}  

  enum{MAX_SYMSET = 85};

  UShort_t get_min_valid_hits() const {return _min_valid_hits;} 

  UShort_t get_symset_middle(int plane) const { return _symset_middle[plane];}

  UShort_t get_symset_upper(int plane) const { return _symset_upper[plane];}

  UShort_t get_symset_per_plane(int plane) const { return _symset_per_plane[plane];}

  UShort_t get_symset_plane(int symset) const { return _symset_plane[symset] ;}

  UShort_t get_symset_logical_offset(int symset) const 
    { return _symset_logical_offset[symset] ;}

  UShort_t get_depth_match() const { return _depth_match;}

  UShort_t get_min_depth() const { return _min_depth;}

  Float_t get_min_slope() const { return _min_slope;}

  Float_t get_min_momentum(int arm, int plane) const { return _min_momentum[arm][plane];}

  void set_min_valid_hits(UShort_t val) { _min_valid_hits = val;}

  void set_symset_middle(int plane, UShort_t val) { _symset_middle[plane] = val;}

  void set_symset_upper(int plane, UShort_t val) { _symset_upper[plane] = val;}

  void set_symset_per_plane(int plane, UShort_t val) { _symset_per_plane[plane] = val;}

  void set_symset_plane(int symset, UShort_t val) { _symset_plane[symset]  = val;}

  void set_symset_logical_offset(int symset, UShort_t val) 
    { _symset_logical_offset[symset]  = val;}

  void set_depth_match(UShort_t val) { _depth_match = val;}

  void set_min_depth(UShort_t val) { _min_depth = val;}

  void set_min_slope(Float_t val) { _min_slope = val;}

  void set_min_momentum(int arm, int plane, Float_t val) { _min_momentum[arm][plane] = val;}

  void set_mode(Mode mode) { _mode = mode; }
  
  Mode get_mode() const {return _mode;}

  // variables specific to original version

  UShort_t get_maxmisshits(UShort_t ipla) const 
    {return _maxmisshits[ipla];} 
  void set_maxmisshits(UShort_t ipla, UShort_t val) 
    { _maxmisshits[ipla] = val;}

  UShort_t get_showercut(UShort_t ipla, UShort_t jpla) const 
    {return _showercut[ipla][jpla];} 
  void set_showercut(UShort_t ipla, UShort_t jpla, UShort_t val) 
    { _showercut[ipla][jpla] = val;}

  UShort_t get_swi(UShort_t ipla, UShort_t jpla) const 
    {return _swi[ipla][jpla];} 
  void set_swi(UShort_t ipla, UShort_t jpla, UShort_t val) 
    { _swi[ipla][jpla] = val;}

  UShort_t get_maxskip(UShort_t ipla, UShort_t jpla) const 
    {return _maxskip[ipla][jpla];} 
  void set_maxskip(UShort_t ipla, UShort_t jpla, UShort_t val) 
    { _maxskip[ipla][jpla] = val;}

 void print(std::ostream& os = std::cout) const {
    os << "** mMuiFastRoadFinderPar - value (excl. arrays) dump **" << endl;
    os << " min_valid_hits " << _min_valid_hits << endl         
       << " depth_match " << _depth_match << endl
       << " min_depth " << _min_depth << endl
       << " min_slope " << _min_slope << endl
       << " mode " << _mode << endl;
    if (_mode == SIMPLIFIED) os << " simplified algorithm" << endl;
    else if (_mode == ORIGINAL) os << " original algorithm " << endl;
    else os << " unknown algorithm " << endl;
    os << " ** " << endl;
  }
 private:  
  
  UShort_t _min_valid_hits;
  UShort_t _symset_middle[MUIOO::MAX_PLANE];
  UShort_t _symset_upper[MUIOO::MAX_PLANE];
  UShort_t _symset_per_plane[MUIOO::MAX_PLANE];
  UShort_t _symset_plane[MAX_SYMSET];
  UShort_t _symset_logical_offset[MAX_SYMSET];

  UShort_t _depth_match;
  UShort_t _min_depth;
  Float_t _min_slope;
  Float_t _min_momentum[MUIOO::MAX_ARM][MUIOO::MAX_PLANE];
  Mode _mode;
  // variables specific to original algorithm, not in simplified version
  UShort_t _maxmisshits[MUIOO::MAX_PLANE];
  UShort_t _showercut[MUIOO::MAX_PLANE][MUIOO::MAX_PLANE];
  UShort_t _swi[MUIOO::MAX_PLANE][MUIOO::MAX_PLANE];
  UShort_t _maxskip[MUIOO::MAX_PLANE][MUIOO::MAX_PLANE];
};

#endif /* __MMUIFASTROADFINDERPAR_HH__ */

---