---

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 "DQM/CSCMonitorModule/interface/CSCDQM_Summary.h"

namespace cscdqm {

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

Summary::~Summary() {
  // Lets delete masked elements
  for (unsigned int r = 0; r < masked.size(); r++) { 
    delete (Address*) masked.at(r);
  }
}

void Summary::Reset() {
  Address adr;

  // Setting Zeros (no data) for each HW element (and beyond)
  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;
    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) {

    // Rate Factor calculation
    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, eps_meas = 0.0;

    Address adr;
    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)) {
          
          // Reset some bits
          ReSetValue(adr, HOT);
          ReSetValue(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 << "\n";
          */

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

          if (N > 0) {

            eps_meas = (1.0 * n) / (1.0 * N);
            double S = 0;

            // Chamber is cold? It means error!
            if (eps_meas < cold_coef) {

              S = SignificanceLevel(N, n, cold_coef);

              if (S > cold_Sfail) {

                /*
                std::cout << "!COLD!";
                std::cout << "adr = " << detector.AddressName(adr);
                std::cout << ", n = " << n << ", N = " << N;
                std::cout << ", eps_meas = " << eps_meas;
                std::cout << ", cold_coef = " << cold_coef;
                std::cout << ", cold_Sfail = " << cold_Sfail;
                std::cout << ", S = " << S;
                std::cout << "\n";
                */

                SetValue(adr, COLD);
              }
            } else {
            
              // Chamber is hot? It means error!
              if (eps_meas > hot_coef) {

                S = SignificanceLevelHot(N, n);

                if (S > hot_Sfail) {

                  /*
                  std::cout << "!HOT!";
                  std::cout << "adr = " << detector.AddressName(adr);
                  std::cout << ", n = " << n << ", N = " << N;
                  std::cout << ", eps_meas = " << eps_meas;
                  std::cout << ", hot_coef = " << hot_coef;
                  std::cout << ", hot_Sfail = " << hot_Sfail;
                  std::cout << ", S = " << S;
                  std::cout << "\n";
                  */

                  SetValue(adr, HOT);
                }
              }
            }


          }

        }

      }
    }

  } 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;
    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)) {
          double eps_meas = (1.0 * n) / (1.0 * N);
          if (eps_meas > eps_max) { 
            if(SignificanceLevel(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;
  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));
    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, yd = 1.0 * (2.0 * 3.14159) / NTICS;

    float xmin, xmax, ymin, ymax;

    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;

        ymin = yd * y;
        ymax = ymin + yd;

        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;

    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)) {
              bool hit = (op_any ? HWSTATUSANY(GetValue(adr), mask) : HWSTATUSEQUALS(GetValue(adr), mask));
              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(Address adr, const HWStatusBit bit) {
  SetValue(adr, bit, 0);
}

void Summary::SetValue(const HWStatusBit bit, const int value) {
  Address adr;
  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 at least 2 stations with data and without errors = OK
  if (cdata > 1)  return 1;
  // Else, if at least one station errorous = ERROR
  if (cerror > 0) return -1;
  // Else, if at least one station masked = MASKED
  if (cmask > 0)  return 2;
  // Else, not sufficient data = OK
  return 0;

}

const double Summary::GetEfficiencyHW() const {

  Address adr;
  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;
  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);
  }

  // if not error - then OK!
  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;
  adr.mask.side = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
  adr.station   = true;
  adr.station   = station;

  return GetEfficiencyArea(adr);
}

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

  if(adr.mask.side == adr.mask.ring == adr.mask.chamber == adr.mask.layer == adr.mask.cfeb == 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;
   
  // NOT errorous! 
  HWStatusBitSet status = GetValue(adr);
  if (!HWSTATUSANYERROR(status)) {
    return detector.Area(adr);
  }
  return 0.0;

}
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;

}

const double Summary::SignificanceLevel(const unsigned int N, const unsigned int n, const double eps) const {

  //std::cout << "N = " << N << ", n = " << n << ", eps = " << eps << "\n";

  double l_eps = eps;
  if (l_eps <= 0.0) l_eps = 0.000001;
  if (l_eps >= 1.0) l_eps = 0.999999;

  double eps_meas = (1.0 * n) / (1.0 * N);
  double a = 1.0, b = 1.0;

  if (n > 0) {
    for (unsigned int r = 0; r < n; r++) a = a * (eps_meas / l_eps);
  }

  if (n < N) {
    for (unsigned int r = 0; r < (N - n); r++) b = b * (1 - eps_meas) / (1 - l_eps);
  }

  return sqrt(2.0 * log(a * b));

}

const double Summary::SignificanceLevelHot(const unsigned int N, const unsigned int n) const {
  if (N > n) return 0.0;
  // no - n observed, ne - n expected
  double no = 1.0 * n, ne = 1.0 * N;
  return sqrt(2.0 * (no * (log(no / ne) - 1) + ne));
}

}

---