PixelHdwAddress.cc

Go to the documentation of this file.

//
//
//
//
//

#include "CalibFormats/SiPixelObjects/interface/PixelHdwAddress.h"
#include <string>
#include <cassert>
#include <ostream>
#include <iostream>

using namespace pos;

//====================================================================================
PixelHdwAddress::PixelHdwAddress()
    : mfec_(0),
      mfecchannel_(0),
      portaddress_(0),
      hubaddress_(0),
      rocid_(0),
      fednumber_(0),
      fedchannel_(0),
      fedrocnumber_(0) {}

//====================================================================================
PixelHdwAddress::PixelHdwAddress(int fecnumber,
                                 int mfec,
                                 int mfecchannel,
                                 int hubaddress,
                                 int portaddress,
                                 int rocid,
                                 int fednumber,
                                 int fedchannel,
                                 int fedrocnumber)
    : fecnumber_(fecnumber),
      mfec_(mfec),
      mfecchannel_(mfecchannel),
      portaddress_(portaddress),
      hubaddress_(hubaddress),
      rocid_(rocid),
      fednumber_(fednumber),
      fedchannel_(fedchannel),
      fedrocnumber_(fedrocnumber) {
  //std::cout << "Created PixelHdwAddress:"<<std::endl;
  //std::cout << *this << std::endl;
}

//====================================================================================
std::ostream& pos::operator<<(std::ostream& s, const PixelHdwAddress& pixelroc) {
  s << "[PixelHdwAddress::operator<<]" << std::endl;
  s << "fecnumber   :" << pixelroc.fecnumber_ << std::endl;
  s << "mfec        :" << pixelroc.mfec_ << std::endl;
  s << "mfecchannel :" << pixelroc.mfecchannel_ << std::endl;
  s << "portaddress :" << pixelroc.portaddress_ << std::endl;
  s << "hubaddress  :" << pixelroc.hubaddress_ << std::endl;
  s << "rocid       :" << pixelroc.rocid_ << std::endl;
  s << "fednumber   :" << pixelroc.fednumber_ << std::endl;
  s << "fedchannel  :" << pixelroc.fedchannel_ << std::endl;
  s << "fedrocnumber:" << pixelroc.fedrocnumber_ << std::endl;

  return s;
}

//====================================================================================
const PixelHdwAddress& PixelHdwAddress::operator=(const PixelHdwAddress& aROC) {
  fecnumber_ = aROC.fecnumber_;
  mfec_ = aROC.mfec_;
  mfecchannel_ = aROC.mfecchannel_;
  portaddress_ = aROC.portaddress_;
  hubaddress_ = aROC.hubaddress_;
  rocid_ = aROC.rocid_;
  fednumber_ = aROC.fednumber_;
  fedchannel_ = aROC.fedchannel_;
  fedrocnumber_ = aROC.fedrocnumber_;

  return *this;
}

//====================================================================================
// Added by Dario
void PixelHdwAddress::setAddress(std::string what, int value) {
  std::string mthn = "[PixelHdwAddress::setAddress()]\t\t\t    ";
  if (what == "fecnumber") {
    fecnumber_ = value;
  } else if (what == "mfec") {
    mfec_ = value;
  } else if (what == "mfecchannel") {
    mfecchannel_ = value;
  } else if (what == "portaddress") {
    portaddress_ = value;
  } else if (what == "hubaddress") {
    hubaddress_ = value;
  } else if (what == "rocid") {
    rocid_ = value;
  } else if (what == "fednumber") {
    fednumber_ = value;
  } else if (what == "fedchannel") {
    fedchannel_ = value;
  } else if (what == "fedrocnumber") {
    fedrocnumber_ = value;
  } else {
    std::cout << __LINE__ << "]\t" << mthn << "Could not set a value for " << what << " (invalid keyword)" << std::endl;
    assert(0);
  }
}

//====================================================================================
void PixelHdwAddress::compare(std::string what, bool& changed, unsigned int newValue, unsigned int& oldValue) {
  std::string mthn = "[PixelHdwAddress::compare()]\t\t\t    ";
  changed = false;
  oldValue = 0;

  if (what == "fecnumber") {
    if (fecnumber_ != newValue) {
      changed = true;
      oldValue = fecnumber_;
      return;
    }
  } else if (what == "mfec") {
    if (mfec_ != newValue) {
      changed = true;
      oldValue = mfec_;
      return;
    }
  } else if (what == "mfecchannel") {
    if (mfecchannel_ != newValue) {
      changed = true;
      oldValue = mfecchannel_;
      return;
    }
  } else if (what == "portaddress") {
    if (portaddress_ != newValue) {
      changed = true;
      oldValue = portaddress_;
      return;
    }
  } else if (what == "hubaddress") {
    if (hubaddress_ != newValue) {
      changed = true;
      oldValue = hubaddress_;
      return;
    }
  } else if (what == "rocid") {
    if (rocid_ != newValue) {
      changed = true;
      oldValue = rocid_;
      return;
    }
  } else if (what == "fednumber") {
    if (fednumber_ != newValue) {
      changed = true;
      oldValue = fednumber_;
      return;
    }
  } else if (what == "fedchannel") {
    if (fedchannel_ != newValue) {
      changed = true;
      oldValue = fedchannel_;
      return;
    }
  } else if (what == "fedrocnumber") {
    if (fedrocnumber_ != newValue) {
      changed = true;
      oldValue = fedrocnumber_;
      return;
    }
  } else {
    std::cout << __LINE__ << "]\t" << mthn << "Could not compare value for " << what << " (invalid keyword)"
              << std::endl;
    assert(0);
  }
}

//====================================================================================
bool PixelHdwAddress::operator()(const PixelHdwAddress& roc1, const PixelHdwAddress& roc2) const {
  if (roc1.fednumber_ < roc2.fednumber_)
    return true;
  if (roc1.fednumber_ > roc2.fednumber_)
    return false;
  if (roc1.fedchannel_ < roc2.fedchannel_)
    return true;
  if (roc1.fedchannel_ > roc2.fedchannel_)
    return false;

  return (roc1.fedrocnumber_ < roc2.fedrocnumber_);
}