L1MuDTAddressArray.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuDTAddressArray
//
//   Description: Array of relative Addresses
//
//
//
//   Author :
//   N. Neumeister            CERN EP
//
//--------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------

#include "L1Trigger/DTTrackFinder/interface/L1MuDTAddressArray.h"

//---------------
// C++ Headers --
//---------------

#include <iostream>
#include <iomanip>
#include <vector>
#include <cassert>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

using namespace std;

// --------------------------------
//       class L1MuDTAddressArray
//---------------------------------

//----------------
// Constructors --
//----------------

L1MuDTAddressArray::L1MuDTAddressArray() { reset(); }

L1MuDTAddressArray::L1MuDTAddressArray(const L1MuDTAddressArray& addarray) {
  for (int stat = 1; stat <= 4; stat++) {
    m_station[stat - 1] = addarray.m_station[stat - 1];
  }
}

//--------------
// Destructor --
//--------------

L1MuDTAddressArray::~L1MuDTAddressArray() {}

//--------------
// Operations --
//--------------

//
// assignment operator
//
L1MuDTAddressArray& L1MuDTAddressArray::operator=(const L1MuDTAddressArray& addarray) {
  if (this != &addarray) {
    for (int stat = 1; stat <= 4; stat++) {
      m_station[stat - 1] = addarray.m_station[stat - 1];
    }
  }
  return *this;
}

//
//
//
bool L1MuDTAddressArray::operator==(const L1MuDTAddressArray& addarray) const {
  for (int stat = 1; stat <= 4; stat++) {
    if (m_station[stat - 1] != addarray.m_station[stat - 1])
      return false;
  }

  return true;
}

//
//
//
bool L1MuDTAddressArray::operator!=(const L1MuDTAddressArray& addarray) const {
  for (int stat = 1; stat <= 4; stat++) {
    if (m_station[stat - 1] != addarray.m_station[stat - 1])
      return true;
  }

  return false;
}

//
// reset AddressArray
//
void L1MuDTAddressArray::reset() {
  for (int stat = 1; stat <= 4; stat++) {
    m_station[stat - 1] = 15;
  }
}

//
// set Address of a given station
//
void L1MuDTAddressArray::setStation(int stat, int adr) {
  //  assert( stat >  0 && stat <= 4 );
  //  assert( adr  >= 0 && adr  <= 15       );
  m_station[stat - 1] = adr;
}

//
// set Addresses of all four stations
//
void L1MuDTAddressArray::setStations(int adr1, int adr2, int adr3, int adr4) {
  setStation(1, adr1);
  setStation(2, adr2);
  setStation(3, adr3);
  setStation(4, adr4);
}

//
// get track address code (for eta track finder)
//
int L1MuDTAddressArray::trackAddressCode() const {
  int code = -1;

  int s1 = m_station[0];
  s1 = (s1 == 15) ? 0 : ((s1 / 2) % 2) + 1;
  int s2 = m_station[1];
  s2 = (s2 == 15) ? 0 : ((s2 / 2) % 2) + 1;
  int s3 = m_station[2];
  s3 = (s3 == 15) ? 0 : ((s3 / 2) % 2) + 1;
  int s4 = m_station[3];
  s4 = (s4 == 15) ? 0 : ((s4 / 2) % 2) + 1;

  //  0 ... empty track segment
  //  1 ... same wheel
  //  2 ... next wheel

  if (s1 == 0 && s2 == 0 && s3 == 0 && s4 == 0)
    code = 0;
  if (s1 == 0 && s2 == 0 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 0 && s3 == 2 && s4 == 2)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 0 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 0 && s4 == 2)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 1 && s4 == 0)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 2 && s4 == 0)
    code = 0;
  if (s1 == 0 && s2 == 1 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 1 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 1 && s4 == 2)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 2 && s3 == 2 && s4 == 2)
    code = 0;
  if (s1 == 1 && s2 == 0 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 1 && s2 == 2 && s3 == 0 && s4 == 1)
    code = 0;
  if (s1 == 1 && s2 == 2 && s3 == 1 && s4 == 0)
    code = 0;
  if (s1 == 1 && s2 == 1 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 1 && s2 == 2 && s3 == 1 && s4 == 1)
    code = 0;
  if (s1 == 1 && s2 == 2 && s3 == 1 && s4 == 2)
    code = 0;
  if (s1 == 1 && s2 == 2 && s3 == 2 && s4 == 1)
    code = 0;
  if (s1 == 0 && s2 == 0 && s3 == 1 && s4 == 1)
    code = 1;
  if (s1 == 0 && s2 == 0 && s3 == 1 && s4 == 2)
    code = 2;
  if (s1 == 0 && s2 == 1 && s3 == 0 && s4 == 1)
    code = 3;
  if (s1 == 0 && s2 == 1 && s3 == 0 && s4 == 2)
    code = 4;
  if (s1 == 0 && s2 == 1 && s3 == 1 && s4 == 0)
    code = 5;
  if (s1 == 0 && s2 == 1 && s3 == 1 && s4 == 1)
    code = 6;
  if (s1 == 0 && s2 == 1 && s3 == 1 && s4 == 2)
    code = 7;
  if (s1 == 0 && s2 == 1 && s3 == 2 && s4 == 0)
    code = 8;
  if (s1 == 0 && s2 == 1 && s3 == 2 && s4 == 2)
    code = 8;
  if (s1 == 1 && s2 == 0 && s3 == 0 && s4 == 1)
    code = 9;
  if (s1 == 1 && s2 == 0 && s3 == 0 && s4 == 2)
    code = 10;
  if (s1 == 1 && s2 == 0 && s3 == 1 && s4 == 0)
    code = 11;
  if (s1 == 1 && s2 == 0 && s3 == 1 && s4 == 1)
    code = 12;
  if (s1 == 1 && s2 == 0 && s3 == 1 && s4 == 2)
    code = 13;
  if (s1 == 1 && s2 == 0 && s3 == 2 && s4 == 0)
    code = 14;
  if (s1 == 1 && s2 == 0 && s3 == 2 && s4 == 2)
    code = 14;
  if (s1 == 1 && s2 == 1 && s3 == 0 && s4 == 0)
    code = 15;
  if (s1 == 1 && s2 == 1 && s3 == 0 && s4 == 1)
    code = 16;
  if (s1 == 1 && s2 == 1 && s3 == 0 && s4 == 2)
    code = 17;
  if (s1 == 1 && s2 == 1 && s3 == 1 && s4 == 0)
    code = 18;
  if (s1 == 1 && s2 == 1 && s3 == 1 && s4 == 1)
    code = 19;
  if (s1 == 1 && s2 == 1 && s3 == 1 && s4 == 2)
    code = 20;
  if (s1 == 1 && s2 == 1 && s3 == 2 && s4 == 0)
    code = 21;
  if (s1 == 1 && s2 == 1 && s3 == 2 && s4 == 2)
    code = 21;
  if (s1 == 1 && s2 == 2 && s3 == 0 && s4 == 0)
    code = 22;
  if (s1 == 1 && s2 == 2 && s3 == 0 && s4 == 2)
    code = 22;
  if (s1 == 1 && s2 == 2 && s3 == 2 && s4 == 0)
    code = 22;
  if (s1 == 1 && s2 == 2 && s3 == 2 && s4 == 2)
    code = 22;

  return code;
}

//
// get converted Addresses
//
L1MuDTAddressArray L1MuDTAddressArray::converted() const {
  unsigned short int adr1 = L1MuDTAddressArray::convert(m_station[0]);
  unsigned short int adr2 = L1MuDTAddressArray::convert(m_station[1]);
  unsigned short int adr3 = L1MuDTAddressArray::convert(m_station[2]);
  unsigned short int adr4 = L1MuDTAddressArray::convert(m_station[3]);

  L1MuDTAddressArray newaddressarray;
  newaddressarray.setStations(adr1, adr2, adr3, adr4);

  return newaddressarray;
}

//
//
//
ostream& operator<<(ostream& s, const L1MuDTAddressArray& adrarr) {
  s.setf(ios::right, ios::adjustfield);
  for (int stat = 1; stat <= 4; stat++) {
    s << "stat " << stat << ": " << setw(2) << adrarr.station(stat) << "  ";
  }

  return s;
}

//
// convert address to corresponding VHDL address
//
unsigned short int L1MuDTAddressArray::convert(unsigned short int adr) {
  unsigned short int newaddress = 15;

  switch (adr) {
    case 0: {
      newaddress = 8;
      break;
    }
    case 1: {
      newaddress = 9;
      break;
    }
    case 2: {
      newaddress = 0;
      break;
    }
    case 3: {
      newaddress = 1;
      break;
    }
    case 4: {
      newaddress = 10;
      break;
    }
    case 5: {
      newaddress = 11;
      break;
    }
    case 6: {
      newaddress = 2;
      break;
    }
    case 7: {
      newaddress = 3;
      break;
    }
    case 8: {
      newaddress = 12;
      break;
    }
    case 9: {
      newaddress = 13;
      break;
    }
    case 10: {
      newaddress = 4;
      break;
    }
    case 11: {
      newaddress = 5;
      break;
    }
    case 15: {
      newaddress = 15;
      break;
    }
    default: {
      newaddress = 15;
      break;
    }
  }

  return newaddress;
}

//
// is it a same wheel address?
//
bool L1MuDTAddressArray::sameWheel(unsigned short int adr) {
  //  if ( adr > 15 ) cerr << "L1MuDTAddressArray : Error wrong address " << adr << endl;
  return ((adr / 2) % 2 == 0);
}

//
// is it a next wheel address?
//
bool L1MuDTAddressArray::nextWheel(unsigned short int adr) {
  //  if ( adr > 15 ) cerr << "L1MuDTAddressArray : Error wrong address " << adr << endl;
  return ((adr / 2) % 2 == 1);
}