CSCDQM_Summary.cc

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  Summary.cc
 *
 *    Description:  Class Summary implementation
 *
 *        Version:  1.0
 *        Created:  05/19/2008 10:59:34 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), Valdas.Rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */

#include "CSCDQM_Summary.h"

namespace cscdqm {

  Summary::Summary() : detector(NTICS, NTICS) { Reset(); }

  Summary::~Summary() {}

  void Summary::Reset() {
    Address adr;
    bzero(&adr, sizeof(Address));

    adr.mask.side = adr.mask.station = adr.mask.layer = false;
    adr.mask.ring = adr.mask.chamber = adr.mask.cfeb = adr.mask.hv = true;
    for (adr.ring = 1; adr.ring <= N_RINGS; adr.ring++) {
      for (adr.chamber = 1; adr.chamber <= N_CHAMBERS; adr.chamber++) {
        for (adr.cfeb = 1; adr.cfeb <= N_CFEBS; adr.cfeb++) {
          for (adr.hv = 1; adr.hv <= N_HVS; adr.hv++) {
            for (unsigned int bit = 0; bit < HWSTATUSBITSETSIZE; bit++) {
              ReSetValue(adr, (HWStatusBit)bit);
            }
          }
        }
      }
    }
  }

  void Summary::ReadReportingChambers(const TH2*& h2, const double threshold) {
    if (h2->GetXaxis()->GetXmin() <= 1 && h2->GetXaxis()->GetXmax() >= 36 && h2->GetYaxis()->GetXmin() <= 1 &&
        h2->GetYaxis()->GetXmax() >= 18) {
      Address adr;
      bzero(&adr, sizeof(Address));
      double z = 0.0;

      for (unsigned int x = 1; x <= 36; x++) {
        for (unsigned int y = 1; y <= 18; y++) {
          z = h2->GetBinContent(x, y);
          if (ChamberCoordsToAddress(x, y, adr)) {
            if (z >= threshold) {
              SetValue(adr, DATA);
            } else {
              ReSetValue(adr, DATA);
            }
          }
        }
      }
    } else {
      LOG_WARN << "cscdqm::Summary.ReadReportingChambers routine. Wrong histogram dimensions!";
    }
  }

  void Summary::ReadReportingChambersRef(const TH2*& h2,
                                         const TH2*& refh2,
                                         const double cold_coef,
                                         const double cold_Sfail,
                                         const double hot_coef,
                                         const double hot_Sfail) {
    if (h2->GetXaxis()->GetXmin() <= 1 && h2->GetXaxis()->GetXmax() >= 36 && h2->GetYaxis()->GetXmin() <= 1 &&
        h2->GetYaxis()->GetXmax() >= 18 && refh2->GetXaxis()->GetXmin() <= 1 && refh2->GetXaxis()->GetXmax() >= 36 &&
        refh2->GetYaxis()->GetXmin() <= 1 && refh2->GetYaxis()->GetXmax() >= 18) {
      double num = 1.0, denum = 1.0;
      for (unsigned int x = 1; x <= 36; x++) {
        for (unsigned int y = 1; y <= 18; y++) {
          double Nij = h2->GetBinContent(x, y);
          double Nrefij = refh2->GetBinContent(x, y);
          if (Nij > 0) {
            num += Nrefij;
            denum += pow(Nrefij, 2.0) / Nij;
          }
        }
      }
      double factor = num / denum;

      Address adr;
      bzero(&adr, sizeof(Address));
      unsigned int N = 0, n = 0;

      for (unsigned int x = 1; x <= 36; x++) {
        for (unsigned int y = 1; y <= 18; y++) {
          N = int(refh2->GetBinContent(x, y) * factor);
          n = int(h2->GetBinContent(x, y));

          if (ChamberCoordsToAddress(x, y, adr)) {
            ReSetValue(adr, HOT);
            ReSetValue(adr, COLD);

            if (n == 0) {
              ReSetValue(adr, DATA);
            } else {
              SetValue(adr, DATA);
            }

            switch (Utility::checkOccupancy(N, n, cold_coef, hot_coef, cold_Sfail, hot_Sfail)) {
              case -1:
                SetValue(adr, COLD);

                /*
            std::cout << "adr = " << detector.AddressName(adr);
            std::cout << ", x = " << x << ", y = " << y;
            std::cout << ", value = " << GetValue(adr);
            std::cout << ", refh2 = " << refh2->GetBinContent(x, y);
            std::cout << ", factor = " << factor;
            std::cout << ", N = " << N;
            std::cout << ", n = " << n;
            std::cout << ", num = " << num;
            std::cout << ", denum = " << denum;
            std::cout << ", rate = " << (N > 0 ? n / N : 0);
            std::cout << ", cold_coef = " << cold_coef;
            std::cout << ", = COLD";
            std::cout << "\n";
              */

                break;
              case 1:
                SetValue(adr, HOT);

                /*
            std::cout << "adr = " << detector.AddressName(adr);
            std::cout << ", x = " << x << ", y = " << y;
            std::cout << ", value = " << GetValue(adr);
            std::cout << ", refh2 = " << refh2->GetBinContent(x, y);
            std::cout << ", factor = " << factor;
            std::cout << ", N = " << N;
            std::cout << ", n = " << n;
            std::cout << ", num = " << num;
            std::cout << ", denum = " << denum;
            std::cout << ", rate = " << (N > 0 ? n / N : 0);
            std::cout << ", hot_coef = " << hot_coef;
            std::cout << ", = HOT";
            std::cout << "\n";
              */

                break;
            };
          }
        }
      }

    } else {
      LOG_WARN << "cscdqm::Summary.ReadReportingChambersRef routine. Wrong histogram dimensions!";
    }
  }

  void Summary::ReadErrorChambers(
      const TH2*& evs, const TH2*& err, const HWStatusBit bit, const double eps_max, const double Sfail) {
    if (evs->GetXaxis()->GetXmin() <= 1 && evs->GetXaxis()->GetXmax() >= 36 && evs->GetYaxis()->GetXmin() <= 1 &&
        evs->GetYaxis()->GetXmax() >= 18 && err->GetXaxis()->GetXmin() <= 1 && err->GetXaxis()->GetXmax() >= 36 &&
        err->GetYaxis()->GetXmin() <= 1 && err->GetYaxis()->GetXmax() >= 18) {
      Address adr;
      bzero(&adr, sizeof(Address));
      unsigned int N = 0, n = 0;

      for (unsigned int x = 1; x <= 36; x++) {
        for (unsigned int y = 1; y <= 18; y++) {
          N = int(evs->GetBinContent(x, y));
          n = int(err->GetBinContent(x, y));
          if (ChamberCoordsToAddress(x, y, adr)) {
            if (Utility::checkError(N, n, eps_max, Sfail)) {
              SetValue(adr, bit);
            } else {
              ReSetValue(adr, bit);
            }
          }
        }
      }
    } else {
      LOG_WARN << "cscdqm::Summary.ReadErrorChambers routine. Wrong histogram dimensions!";
    }
  }

  void Summary::Write(TH2*& h2, const unsigned int station) const {
    const AddressBox* box;
    Address adr, tadr;
    bzero(&adr, sizeof(Address));
    bzero(&tadr, sizeof(Address));
    float area_all = 0.0, area_rep = 0.0;

    if (station < 1 || station > N_STATIONS)
      return;

    adr.mask.side = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
    adr.mask.station = true;
    adr.station = station;

    unsigned int i = 0;

    while (detector.NextAddressBox(i, box, adr)) {
      unsigned int x = 1 + (box->adr.side - 1) * 9 + (box->adr.ring - 1) * 3 + (box->adr.hv - 1);
      unsigned int y = 1 + (box->adr.chamber - 1) * 5 + (box->adr.cfeb - 1);

      tadr = box->adr;
      HWStatusBitSet status = GetValue(tadr);

      float area_box = fabs((box->xmax - box->xmin) * (box->ymax - box->ymin));

      if (status.test(MASKED)) {
        h2->SetBinContent(x, y, 2.0);
      } else {
        area_all += area_box;
        if (HWSTATUSANYERROR(status)) {
          h2->SetBinContent(x, y, -1.0);
        } else {
          area_rep += area_box;
          if (status.test(DATA)) {
            h2->SetBinContent(x, y, 1.0);
          } else {
            h2->SetBinContent(x, y, 0.0);
          }
        }
      }
    }

    TString title = Form("ME%d Status: Physics Efficiency %.2f%%", station, (area_rep / area_all) * 100.0);
    h2->SetTitle(title);
  }

  void Summary::WriteMap(TH2*& h2) {
    unsigned int rep_el = 0, csc_el = 0;

    if (h2->GetXaxis()->GetXmin() <= 1 && h2->GetXaxis()->GetXmax() >= NTICS && h2->GetYaxis()->GetXmin() <= 1 &&
        h2->GetYaxis()->GetXmax() >= NTICS) {
      float xd = 5.0 / NTICS;

      float xmin, xmax;

      for (unsigned int x = 0; x < NTICS; x++) {
        xmin = -2.5 + xd * x;
        xmax = xmin + xd;

        for (unsigned int y = 0; y < NTICS; y++) {
          double value = 0.0;

          if (xmin == -2.5 || xmax == 2.5)
            continue;
          if (xmin >= -1 && xmax <= 1)
            continue;

          switch (IsPhysicsReady(x, y)) {
            case -1:
              value = -1.0;
              break;
            case 0:
              value = 0.0;
              rep_el++;
              break;
            case 1:
              value = 1.0;
              rep_el++;
              break;
            case 2:
              value = 2.0;
              rep_el++;
          }

          h2->SetBinContent(x + 1, y + 1, value);
          csc_el++;
        }
      }

    } else {
      LOG_WARN << "cscdqm::Summary.WriteMap routine. Wrong histogram dimensions!";
    }

    TString title =
        Form("EMU Status: Physics Efficiency %.2f%%", (csc_el == 0 ? 0.0 : (1.0 * rep_el) / csc_el) * 100.0);
    h2->SetTitle(title);
  }

  void Summary::WriteChamberState(TH2*& h2, const int mask, const int value, const bool reset, const bool op_any) const {
    if (h2->GetXaxis()->GetXmin() <= 1 && h2->GetXaxis()->GetXmax() >= 36 && h2->GetYaxis()->GetXmin() <= 1 &&
        h2->GetYaxis()->GetXmax() >= 18) {
      unsigned int x, y;
      Address adr;
      bzero(&adr, sizeof(Address));

      adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = true;
      adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;

      for (adr.side = 1; adr.side <= N_SIDES; adr.side++) {
        for (adr.station = 1; adr.station <= N_STATIONS; adr.station++) {
          for (adr.ring = 1; adr.ring <= detector.NumberOfRings(adr.station); adr.ring++) {
            for (adr.chamber = 1; adr.chamber <= detector.NumberOfChambers(adr.station, adr.ring); adr.chamber++) {
              if (ChamberAddressToCoords(adr, x, y)) {
                HWStatusBitSet hwValue = GetValue(adr);
                bool hit = (op_any ? HWSTATUSANY(hwValue, mask) : HWSTATUSEQUALS(hwValue, mask));

                // std::cout << "x = " << x << ", y = " << y << ", value = " << GetValue(adr) << std::endl;
                // std::cout << "adr = " << detector.AddressName(adr) << ", x = " << x << ", y = " << y << ", value = " << GetValue(adr) << std::endl;
                if (hit) {
                  h2->SetBinContent(x, y, 1.0 * value);
                } else if (reset) {
                  h2->SetBinContent(x, y, 0.0);
                }
              }
            }
          }
        }
      }

    } else {
      LOG_WARN << "cscdqm::Summary.WriteChamberState routine. Wrong histogram dimensions!";
    }
  }

  void Summary::ReSetValue(const HWStatusBit bit) { SetValue(bit, 0); }

  void Summary::ReSetValue(const Address& adr, const HWStatusBit bit) { SetValue(adr, bit, 0); }

  void Summary::SetValue(const HWStatusBit bit, const int value) {
    Address adr;
    bzero(&adr, sizeof(Address));
    adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv =
        false;
    SetValue(adr, bit, value);
  }

  void Summary::SetValue(Address adr, const HWStatusBit bit, const int value) {
    if (!adr.mask.side) {
      adr.mask.side = true;
      for (adr.side = 1; adr.side <= N_SIDES; adr.side++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.station) {
      adr.mask.station = true;
      for (adr.station = 1; adr.station <= N_STATIONS; adr.station++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.ring) {
      adr.mask.ring = true;
      for (adr.ring = 1; adr.ring <= detector.NumberOfRings(adr.station); adr.ring++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.chamber) {
      adr.mask.chamber = true;
      for (adr.chamber = 1; adr.chamber <= detector.NumberOfChambers(adr.station, adr.ring); adr.chamber++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.layer) {
      adr.mask.layer = true;
      for (adr.layer = 1; adr.layer <= N_LAYERS; adr.layer++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.cfeb) {
      adr.mask.cfeb = true;
      for (adr.cfeb = 1; adr.cfeb <= detector.NumberOfChamberCFEBs(adr.station, adr.ring); adr.cfeb++)
        SetValue(adr, bit, value);
      return;
    }

    if (!adr.mask.hv) {
      adr.mask.hv = true;
      for (adr.hv = 1; adr.hv <= detector.NumberOfChamberHVs(adr.station, adr.ring); adr.hv++)
        SetValue(adr, bit, value);
      return;
    }

    if (adr.side > 0 && adr.side <= N_SIDES && adr.station > 0 && adr.station <= N_STATIONS && adr.ring > 0 &&
        adr.ring <= N_RINGS && adr.chamber > 0 && adr.chamber <= N_CHAMBERS && adr.layer > 0 && adr.layer <= N_LAYERS &&
        adr.cfeb > 0 && adr.cfeb <= N_CFEBS && adr.hv > 0 && adr.hv <= N_HVS) {
      map[adr.side - 1][adr.station - 1][adr.ring - 1][adr.chamber - 1][adr.layer - 1][adr.cfeb - 1][adr.hv - 1].set(
          bit, value);
    }
  }

  const int Summary::IsPhysicsReady(const unsigned int px, const unsigned int py) {
    AddressBox* box;

    HWStatusBitSet status[N_STATIONS];

    unsigned int i = 0;
    while (detector.NextAddressBoxByPartition(i, px, py, box)) {
      status[box->adr.station - 1] |= GetValue(box->adr);
    }

    unsigned int cdata = 0, cerror = 0, cmask = 0;
    for (unsigned int i = 0; i < N_STATIONS; i++) {
      if (HWSTATUSANYERROR(status[i])) {
        cerror++;
      } else {
        if (status[i].test(MASKED))
          cmask++;
        if (status[i].test(DATA))
          cdata++;
      }
    }

    if (cdata > 1)
      return 1;
    if (cerror > 0)
      return -1;
    if (cmask > 0)
      return 2;
    return 0;
  }

  const double Summary::GetEfficiencyHW() const {
    Address adr;
    bzero(&adr, sizeof(Address));
    adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv =
        false;
    return GetEfficiencyHW(adr);
  }

  const double Summary::GetEfficiencyHW(const unsigned int station) const {
    Address adr;
    bzero(&adr, sizeof(Address));
    adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv =
        false;

    if (station > 0 && station <= N_STATIONS) {
      adr.mask.station = true;
      adr.station = station;
    } else {
      return 0.0;
    }

    return GetEfficiencyHW(adr);
  }

  const double Summary::GetEfficiencyHW(Address adr) const {
    double sum = 0.0;
    if (!adr.mask.side) {
      adr.mask.side = true;
      for (adr.side = 1; adr.side <= N_SIDES; adr.side++)
        sum += GetEfficiencyHW(adr);
      return sum / N_SIDES;
    }

    if (!adr.mask.station) {
      adr.mask.station = true;
      for (adr.station = 1; adr.station <= N_STATIONS; adr.station++)
        sum += GetEfficiencyHW(adr);
      return sum / N_STATIONS;
    }

    if (!adr.mask.ring) {
      adr.mask.ring = true;
      for (adr.ring = 1; adr.ring <= detector.NumberOfRings(adr.station); adr.ring++)
        sum += GetEfficiencyHW(adr);
      return sum / detector.NumberOfRings(adr.station);
    }

    if (!adr.mask.chamber) {
      adr.mask.chamber = true;
      for (adr.chamber = 1; adr.chamber <= detector.NumberOfChambers(adr.station, adr.ring); adr.chamber++)
        sum += GetEfficiencyHW(adr);
      return sum / detector.NumberOfChambers(adr.station, adr.ring);
    }

    if (!adr.mask.layer) {
      adr.mask.layer = true;
      for (adr.layer = 1; adr.layer <= N_LAYERS; adr.layer++)
        sum += GetEfficiencyHW(adr);
      return sum / N_LAYERS;
    }

    if (!adr.mask.cfeb) {
      adr.mask.cfeb = true;
      for (adr.cfeb = 1; adr.cfeb <= detector.NumberOfChamberCFEBs(adr.station, adr.ring); adr.cfeb++)
        sum += GetEfficiencyHW(adr);
      return sum / detector.NumberOfChamberCFEBs(adr.station, adr.ring);
    }

    if (!adr.mask.hv) {
      adr.mask.hv = true;
      for (adr.hv = 1; adr.hv <= detector.NumberOfChamberHVs(adr.station, adr.ring); adr.hv++)
        sum += GetEfficiencyHW(adr);
      return sum / detector.NumberOfChamberHVs(adr.station, adr.ring);
    }

    HWStatusBitSet status = GetValue(adr);
    if (HWSTATUSANYERROR(status))
      return 0.0;
    return 1.0;
  }

  const double Summary::GetEfficiencyArea(const unsigned int station) const {
    if (station <= 0 || station > N_STATIONS)
      return 0.0;

    Address adr;
    bzero(&adr, sizeof(Address));
    adr.mask.side = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
    adr.mask.station = true;
    adr.station = station;

    return GetEfficiencyArea(adr);
  }

  const double Summary::GetEfficiencyArea(const Address& adr) const {
    double all_area = 1;

    if ((adr.mask.side == false) && (adr.mask.ring == false) && (adr.mask.chamber == false) &&
        (adr.mask.layer == false) && (adr.mask.cfeb == false) && (adr.mask.hv == false) && (adr.mask.station == true))
      all_area = detector.Area(adr.station);
    else
      all_area = detector.Area(adr);

    double rep_area = GetReportingArea(adr);
    return rep_area / all_area;
  }

  const double Summary::GetReportingArea(Address adr) const {
    double sum = 0.0;
    if (!adr.mask.side) {
      adr.mask.side = true;
      for (adr.side = 1; adr.side <= N_SIDES; adr.side++)
        sum += GetReportingArea(adr);
      return sum;
    }

    if (!adr.mask.station) {
      adr.mask.station = true;
      for (adr.station = 1; adr.station <= N_STATIONS; adr.station++)
        sum += GetReportingArea(adr);
      return sum;
    }

    if (!adr.mask.ring) {
      adr.mask.ring = true;
      for (adr.ring = 1; adr.ring <= detector.NumberOfRings(adr.station); adr.ring++)
        sum += GetReportingArea(adr);
      return sum;
    }

    if (!adr.mask.chamber) {
      adr.mask.chamber = true;
      for (adr.chamber = 1; adr.chamber <= detector.NumberOfChambers(adr.station, adr.ring); adr.chamber++)
        sum += GetReportingArea(adr);
      return sum;
    }

    if (!adr.mask.cfeb) {
      adr.mask.cfeb = true;
      for (adr.cfeb = 1; adr.cfeb <= detector.NumberOfChamberCFEBs(adr.station, adr.ring); adr.cfeb++)
        sum += GetReportingArea(adr);
      return sum;
    }

    if (!adr.mask.hv) {
      adr.mask.hv = true;
      for (adr.hv = 1; adr.hv <= detector.NumberOfChamberHVs(adr.station, adr.ring); adr.hv++)
        sum += GetReportingArea(adr);
      return sum;
    }

    adr.mask.layer = false;

    HWStatusBitSet status = GetValue(adr);
    if (!HWSTATUSANYERROR(status)) {
      return detector.Area(adr);
    }
    return 0.0;
  }

  bool Summary::isChamberStandby(unsigned int side,
                                 unsigned int station,
                                 unsigned int ring,
                                 unsigned int chamber) const {
    Address adr;
    bzero(&adr, sizeof(Address));
    adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = true;
    adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
    adr.side = side;
    adr.station = station;
    adr.ring = ring;
    adr.chamber = chamber;

    //std::cout << adr << " = " << HWSTATUSANY(GetValue(adr), 0x1000) << "\n";

    return HWSTATUSANY(GetValue(adr), 0x1000);
  }

  bool Summary::isChamberStandby(CSCDetId cid) const {
    return isChamberStandby(cid.endcap(), cid.station(), cid.ring(), cid.chamber());
  }

  const HWStatusBitSet Summary::GetValue(Address adr) const {
    HWStatusBitSet state;
    state.reset();

    if (!adr.mask.side) {
      adr.mask.side = true;
      for (adr.side = 1; adr.side <= N_SIDES; adr.side++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.station) {
      adr.mask.station = true;
      for (adr.station = 1; adr.station <= N_STATIONS; adr.station++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.ring) {
      adr.mask.ring = true;
      for (adr.ring = 1; adr.ring <= detector.NumberOfRings(adr.station); adr.ring++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.chamber) {
      adr.mask.chamber = true;
      for (adr.chamber = 1; adr.chamber <= detector.NumberOfChambers(adr.station, adr.ring); adr.chamber++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.layer) {
      adr.mask.layer = true;
      for (adr.layer = 1; adr.layer <= N_LAYERS; adr.layer++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.cfeb) {
      adr.mask.cfeb = true;
      for (adr.cfeb = 1; adr.cfeb <= detector.NumberOfChamberCFEBs(adr.station, adr.ring); adr.cfeb++)
        state |= GetValue(adr);
      return state;
    }

    if (!adr.mask.hv) {
      adr.mask.hv = true;
      for (adr.hv = 1; adr.hv <= detector.NumberOfChamberHVs(adr.station, adr.ring); adr.hv++)
        state |= GetValue(adr);
      return state;
    }

    return map[adr.side - 1][adr.station - 1][adr.ring - 1][adr.chamber - 1][adr.layer - 1][adr.cfeb - 1][adr.hv - 1];
  }

  const unsigned int Summary::setMaskedHWElements(std::vector<std::string>& tokens) {
    unsigned int applied = 0;

    for (unsigned int r = 0; r < tokens.size(); r++) {
      std::string token = (std::string)tokens.at(r);
      Address adr;
      if (detector.AddressFromString(token, adr)) {
        SetValue(adr, MASKED);
        applied++;
      }
    }
    return applied;
  }

  const bool Summary::ChamberCoordsToAddress(const unsigned int x, const unsigned int y, Address& adr) const {
    if (x < 1 || x > 36 || y < 1 || y > 18)
      return false;

    adr.mask.side = adr.mask.station = adr.mask.ring = adr.mask.chamber = true;
    adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;

    if (y < 10)
      adr.side = 2;
    else
      adr.side = 1;

    adr.chamber = x;

    if (y == 1 || y == 18) {
      adr.station = 4;
      adr.ring = 2;
    } else if (y == 2 || y == 17) {
      adr.station = 4;
      adr.ring = 1;
    } else if (y == 3 || y == 16) {
      adr.station = 3;
      adr.ring = 2;
    } else if (y == 4 || y == 15) {
      adr.station = 3;
      adr.ring = 1;
    } else if (y == 5 || y == 14) {
      adr.station = 2;
      adr.ring = 2;
    } else if (y == 6 || y == 13) {
      adr.station = 2;
      adr.ring = 1;
    } else if (y == 7 || y == 12) {
      adr.station = 1;
      adr.ring = 3;
    } else if (y == 8 || y == 11) {
      adr.station = 1;
      adr.ring = 2;
    } else if (y == 9 || y == 10) {
      adr.station = 1;
      adr.ring = 1;
    }

    return true;
  }

  const bool Summary::ChamberAddressToCoords(const Address& adr, unsigned int& x, unsigned int& y) const {
    if (!adr.mask.side || !adr.mask.station || !adr.mask.ring || !adr.mask.chamber)
      return false;

    x = adr.chamber;
    y = 0;

    if (adr.side == 1) {
      switch (adr.station) {
        case 1:
          y = 10;
          if (adr.ring == 2)
            y = 11;
          if (adr.ring == 3)
            y = 12;
          break;
        case 2:
          y = 13;
          if (adr.ring == 2)
            y = 14;
          break;
        case 3:
          y = 15;
          if (adr.ring == 2)
            y = 16;
          break;
        case 4:
          y = 17;
          if (adr.ring == 2)
            y = 18;
          break;
      }
    } else if (adr.side == 2) {
      switch (adr.station) {
        case 1:
          y = 7;
          if (adr.ring == 2)
            y = 8;
          if (adr.ring == 1)
            y = 9;
          break;
        case 2:
          y = 5;
          if (adr.ring == 1)
            y = 6;
          break;
        case 3:
          y = 3;
          if (adr.ring == 1)
            y = 4;
          break;
        case 4:
          y = 1;
          if (adr.ring == 1)
            y = 2;
          break;
      }
    }

    return true;
  }

}  // namespace cscdqm