SiStripFolderOrganizer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     SiStripCommon
// Class  :     SiStripFolderOrganizer
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  dkcira
//         Created:  Thu Jan 26 23:52:43 CET 2006
 
//
 
#include <iostream>
#include <sstream>
 
#include "FWCore/ServiceRegistry/interface/Service.h"
 
#include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "DQMServices/Core/interface/DQMStore.h"
 
#include "DQM/SiStripCommon/interface/SiStripFolderOrganizer.h"
#define CONTROL_FOLDER_NAME "ControlView"
#define MECHANICAL_FOLDER_NAME "MechanicalView"
#define SEP "/"
 
#include <cstring>
 
SiStripFolderOrganizer::SiStripFolderOrganizer() {
  TopFolderName = "SiStrip";
  // get a pointer to DQMStore
  dbe_ = edm::Service<DQMStore>().operator->();
}
 
SiStripFolderOrganizer::~SiStripFolderOrganizer() {}
 
void SiStripFolderOrganizer::setSiStripFolderName(std::string name) { TopFolderName = name; }
 
std::string SiStripFolderOrganizer::getSiStripFolder() { return TopFolderName; }
 
void SiStripFolderOrganizer::setSiStripFolder() {
  dbe_->setCurrentFolder(TopFolderName);
  return;
}
 
std::string SiStripFolderOrganizer::getSiStripTopControlFolder() {
  std::string lokal_folder = TopFolderName + CONTROL_FOLDER_NAME;
  return lokal_folder;
}
 
void SiStripFolderOrganizer::setSiStripTopControlFolder() {
  std::string lokal_folder = TopFolderName + CONTROL_FOLDER_NAME;
  dbe_->setCurrentFolder(lokal_folder);
  return;
}
 
std::string SiStripFolderOrganizer::getSiStripControlFolder(
    // unsigned short crate,
    unsigned short slot,
    unsigned short ring,
    unsigned short addr,
    unsigned short chan
    // unsigned short i2c
) {
  std::stringstream lokal_folder;
  lokal_folder << getSiStripTopControlFolder();
  //   if ( crate != all_ ) {// if ==all_ then remain in top control folder
  //     lokal_folder << SEP << "FecCrate" << crate;
  if (slot != all_) {
    lokal_folder << SEP << "FecSlot" << slot;
    if (ring != all_) {
      lokal_folder << SEP << "FecRing" << ring;
      if (addr != all_) {
        lokal_folder << SEP << "CcuAddr" << addr;
        if (chan != all_) {
          lokal_folder << SEP << "CcuChan" << chan;
          //        if ( i2c != all_ ) {
          //          lokal_folder << SEP << "I2cAddr" << i2c;
          //        }
        }
      }
    }
  }
  //   }
  std::string folder_name = lokal_folder.str();
  return folder_name;
}
 
void SiStripFolderOrganizer::setSiStripControlFolder(
    // unsigned short crate,
    unsigned short slot,
    unsigned short ring,
    unsigned short addr,
    unsigned short chan
    // unsigned short i2c
) {
  std::string lokal_folder = getSiStripControlFolder(slot, ring, addr, chan);
  dbe_->setCurrentFolder(lokal_folder);
  return;
}
 
std::pair<std::string, int32_t> SiStripFolderOrganizer::GetSubDetAndLayer(const uint32_t& detid,
                                                                          const TrackerTopology* tTopo,
                                                                          bool ring_flag) {
  std::string cSubDet;
  int32_t layer = 0;
  switch (StripSubdetector::SubDetector(StripSubdetector(detid).subdetId())) {
    case StripSubdetector::TIB:
      cSubDet = "TIB";
      layer = tTopo->tibLayer(detid);
      break;
    case StripSubdetector::TOB:
      cSubDet = "TOB";
      layer = tTopo->tobLayer(detid);
      break;
    case StripSubdetector::TID:
      cSubDet = "TID";
      if (ring_flag)
        layer = tTopo->tidRing(detid) * (tTopo->tidSide(detid) == 1 ? -1 : +1);
      else
        layer = tTopo->tidWheel(detid) * (tTopo->tidSide(detid) == 1 ? -1 : +1);
      break;
    case StripSubdetector::TEC:
      cSubDet = "TEC";
      if (ring_flag)
        layer = tTopo->tecRing(detid) * (tTopo->tecSide(detid) == 1 ? -1 : +1);
      else
        layer = tTopo->tecWheel(detid) * (tTopo->tecSide(detid) == 1 ? -1 : +1);
      break;
    default:
      edm::LogWarning("SiStripMonitorTrack") << "WARNING!!! this detid does not belong to tracker" << std::endl;
  }
  return std::make_pair(cSubDet, layer);
}
 
std::pair<std::string, int32_t> SiStripFolderOrganizer::GetSubDetAndLayerThickness(const uint32_t& detid,
                                                                                   const TrackerTopology* tTopo,
                                                                                   std::string& cThickness) {
  std::string cSubDet;
  int32_t layer = 0;
  int32_t ring = 0;
  switch (StripSubdetector::SubDetector(StripSubdetector(detid).subdetId())) {
    case StripSubdetector::TIB:
      cSubDet = "TIB";
      layer = tTopo->tibLayer(detid);
      cThickness = "THIN";
      break;
    case StripSubdetector::TOB:
      cSubDet = "TOB";
      layer = tTopo->tobLayer(detid);
      cThickness = "THICK";
      break;
    case StripSubdetector::TID:
      cSubDet = "TID";
      layer = tTopo->tidWheel(detid) * (tTopo->tidSide(detid) == 1 ? -1 : +1);
      cThickness = "THIN";
      break;
    case StripSubdetector::TEC:
      cSubDet = "TEC";
      layer = tTopo->tecWheel(detid) * (tTopo->tecSide(detid) == 1 ? -1 : +1);
      ring = tTopo->tecRing(detid) * (tTopo->tecSide(detid) == 1 ? -1 : +1);
      if (ring >= 1 && ring <= 4)
        cThickness = "THIN";
      else
        cThickness = "THICK";
      break;
    default:
      edm::LogWarning("SiStripMonitorTrack") << "WARNING!!! this detid does not belong to tracker" << std::endl;
  }
  return std::make_pair(cSubDet, layer);
}
 
std::pair<std::string, int32_t> SiStripFolderOrganizer::GetSubDetAndRing(const uint32_t& detid,
                                                                         const TrackerTopology* tTopo) {
  std::string cSubDet;
  int32_t ring = 0;
  switch (StripSubdetector::SubDetector(StripSubdetector(detid).subdetId())) {
    case StripSubdetector::TIB:
      cSubDet = "TIB";
      break;
    case StripSubdetector::TOB:
      cSubDet = "TOB";
      break;
    case StripSubdetector::TID:
      cSubDet = "TID";
      ring = tTopo->tidRing(detid) * (tTopo->tidSide(detid) == 1 ? -1 : +1);
      break;
    case StripSubdetector::TEC:
      cSubDet = "TEC";
      ring = tTopo->tecRing(detid) * (tTopo->tecSide(detid) == 1 ? -1 : +1);
      break;
    default:
      edm::LogWarning("SiStripMonitorTrack") << "WARNING!!! this detid does not belong to tracker" << std::endl;
  }
  return std::make_pair(cSubDet, ring);
}
 
void SiStripFolderOrganizer::setDetectorFolder(uint32_t rawdetid, const TrackerTopology* tTopo) {
  std::string folder_name;
  getFolderName(rawdetid, tTopo, folder_name);
  dbe_->setCurrentFolder(folder_name);
}
 
void SiStripFolderOrganizer::getSubDetLayerFolderName(std::stringstream& ss,
                                                      SiStripDetId::SubDetector subDet,
                                                      uint32_t layer,
                                                      uint32_t side) {
  //  std::cout << "[SiStripFolderOrganizer::getSubDetLayerFolderName] TopFolderName: " << TopFolderName << std::endl;
  ss << TopFolderName << SEP << MECHANICAL_FOLDER_NAME;
 
  std::stringstream sside;
  if (side == 1) {
    sside << "MINUS";
  } else if (side == 2) {
    sside << "PLUS";
  }
 
  if (subDet == SiStripDetId::TIB) {
    ss << SEP << "TIB" << SEP << "layer_" << layer << SEP;
  } else if (subDet == SiStripDetId::TID) {
    ss << SEP << "TID" << SEP << sside.str() << SEP << "wheel_" << layer << SEP;
  } else if (subDet == SiStripDetId::TOB) {
    ss << SEP << "TOB" << SEP << "layer_" << layer << SEP;
  } else if (subDet == SiStripDetId::TEC) {
    ss << SEP << "TEC" << SEP << sside.str() << SEP << "wheel_" << layer << SEP;
  } else {
    // ---------------------------  ???  --------------------------- //
    edm::LogWarning("SiStripTkDQM|WrongInput") << "no such SubDet :" << subDet << " no folder set!" << std::endl;
  }
}
 
void SiStripFolderOrganizer::getFolderName(int32_t rawdetid, const TrackerTopology* tTopo, std::string& lokal_folder) {
  lokal_folder = "";
  if (rawdetid == 0) {  // just top MechanicalFolder if rawdetid==0;
    return;
  }
  std::stringstream rest;
  SiStripDetId stripdet = SiStripDetId(rawdetid);
 
  if (stripdet.subDetector() == SiStripDetId::TIB) {
    // ---------------------------  TIB  --------------------------- //
 
    getSubDetLayerFolderName(rest, stripdet.subDetector(), tTopo->tibLayer(rawdetid));
 
    if (tTopo->tibIsZMinusSide(rawdetid))
      rest << "backward_strings" << SEP;
    else
      rest << "forward_strings" << SEP;
    if (tTopo->tibIsExternalString(rawdetid))
      rest << "external_strings" << SEP;
    else
      rest << "internal_strings" << SEP;
    rest << "string_" << tTopo->tibString(rawdetid) << SEP << "module_" << rawdetid;
  } else if (stripdet.subDetector() == SiStripDetId::TID) {
    // ---------------------------  TID  --------------------------- //
 
    getSubDetLayerFolderName(rest, stripdet.subDetector(), tTopo->tidWheel(rawdetid), tTopo->tidSide(rawdetid));
    rest << "ring_" << tTopo->tidRing(rawdetid) << SEP;
 
    if (tTopo->tidIsStereo(rawdetid))
      rest << "stereo_modules" << SEP;
    else
      rest << "mono_modules" << SEP;
    rest << "module_" << rawdetid;
  } else if (stripdet.subDetector() == SiStripDetId::TOB) {
    // ---------------------------  TOB  --------------------------- //
 
    getSubDetLayerFolderName(rest, stripdet.subDetector(), tTopo->tobLayer(rawdetid));
    if (tTopo->tobIsZMinusSide(rawdetid))
      rest << "backward_rods" << SEP;
    else
      rest << "forward_rods" << SEP;
    rest << "rod_" << tTopo->tobRod(rawdetid) << SEP << "module_" << rawdetid;
  } else if (stripdet.subDetector() == SiStripDetId::TEC) {
    // ---------------------------  TEC  --------------------------- //
 
    getSubDetLayerFolderName(rest, stripdet.subDetector(), tTopo->tecWheel(rawdetid), tTopo->tecSide(rawdetid));
    if (tTopo->tecIsBackPetal(rawdetid))
      rest << "backward_petals" << SEP;
    else
      rest << "forward_petals" << SEP;
 
    rest << "petal_" << tTopo->tecPetalNumber(rawdetid) << SEP << "ring_" << tTopo->tecRing(rawdetid) << SEP;
 
    if (tTopo->tecIsStereo(rawdetid))
      rest << "stereo_modules" << SEP;
    else
      rest << "mono_modules" << SEP;
 
    rest << "module_" << rawdetid;
  } else {
    // ---------------------------  ???  --------------------------- //
    edm::LogWarning("SiStripTkDQM|WrongInput")
        << "no such subdetector type :" << stripdet.subDetector() << " no folder set!" << std::endl;
    return;
  }
  lokal_folder += rest.str();
}
 
void SiStripFolderOrganizer::setLayerFolder(uint32_t rawdetid,
                                            const TrackerTopology* tTopo,
                                            int32_t layer,
                                            bool ring_flag) {
  std::string lokal_folder = TopFolderName + SEP + MECHANICAL_FOLDER_NAME;
  if (rawdetid == 0) {  // just top MechanicalFolder if rawdetid==0;
    dbe_->setCurrentFolder(lokal_folder);
    return;
  }
 
  std::ostringstream rest;
  SiStripDetId stripdet = SiStripDetId(rawdetid);
  if (stripdet.subDetector() == SiStripDetId::TIB) {
    // ---------------------------  TIB  --------------------------- //
 
    int tib_layer = tTopo->tibLayer(rawdetid);
    if (abs(layer) != tib_layer) {
      edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
          << " expect " << abs(layer) << " but getting " << tTopo->tibLayer(rawdetid) << std::endl;
      return;
    }
    rest << SEP << "TIB" << SEP << "layer_" << tTopo->tibLayer(rawdetid);
  } else if (stripdet.subDetector() == SiStripDetId::TID) {
    // ---------------------------  TID  --------------------------- //
 
    int tid_ring = tTopo->tidRing(rawdetid);
 
    // side
    uint32_t side = tTopo->tidSide(rawdetid);
    std::stringstream sside;
    if (side == 1) {
      sside << "MINUS";
    } else if (side == 2) {
      sside << "PLUS";
    }
 
    if (ring_flag) {
      if (abs(layer) != tid_ring) {
        edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
            << " expect " << abs(layer) << " but getting " << tTopo->tidRing(rawdetid) << std::endl;
        return;
      }
      rest << SEP << "TID" << SEP << sside.str() << SEP << "ring_" << tTopo->tidRing(rawdetid);
    } else {
      int tid_wheel = tTopo->tidWheel(rawdetid);
      if (abs(layer) != tid_wheel) {
        edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
            << " expect " << abs(layer) << " but getting " << tTopo->tidWheel(rawdetid) << std::endl;
        return;
      }
      rest << SEP << "TID" << SEP << sside.str() << SEP << "wheel_" << tTopo->tidWheel(rawdetid);
    }
  } else if (stripdet.subDetector() == SiStripDetId::TOB) {
    // ---------------------------  TOB  --------------------------- //
 
    int tob_layer = tTopo->tobLayer(rawdetid);
    if (abs(layer) != tob_layer) {
      edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
          << " expect " << abs(layer) << " but getting " << tTopo->tobLayer(rawdetid) << std::endl;
      return;
    }
    rest << SEP << "TOB" << SEP << "layer_" << tTopo->tobLayer(rawdetid);
  } else if (stripdet.subDetector() == SiStripDetId::TEC) {
    // ---------------------------  TEC  --------------------------- //
 
    // side
    uint32_t side = tTopo->tecSide(rawdetid);
    std::stringstream sside;
    if (side == 1) {
      sside << "MINUS";
    } else if (side == 2) {
      sside << "PLUS";
    }
 
    if (ring_flag) {
      int tec_ring = tTopo->tecRing(rawdetid);
      if (abs(layer) != tec_ring) {
        edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
            << " expect " << abs(layer) << " but getting " << tTopo->tecRing(rawdetid) << std::endl;
        return;
      }
      rest << SEP << "TEC" << SEP << sside.str() << SEP << "ring_" << tTopo->tecRing(rawdetid);
    } else {
      int tec_wheel = tTopo->tecWheel(rawdetid);
      if (abs(layer) != tec_wheel) {
        edm::LogWarning("SiStripTkDQM|Layer mismatch!!!")
            << " expect " << abs(layer) << " but getting " << tTopo->tecWheel(rawdetid) << std::endl;
        return;
      }
      rest << SEP << "TEC" << SEP << sside.str() << SEP << "wheel_" << tTopo->tecWheel(rawdetid);
    }
  } else {
    // ---------------------------  ???  --------------------------- //
    edm::LogWarning("SiStripTkDQM|WrongInput")
        << "no such subdetector type :" << stripdet.subDetector() << " no folder set!" << std::endl;
    return;
  }
 
  lokal_folder += rest.str();
  dbe_->setCurrentFolder(lokal_folder);
}
 
void SiStripFolderOrganizer::getSubDetFolder(const uint32_t& detid,
                                             const TrackerTopology* tTopo,
                                             std::string& folder_name) {
  std::pair<std::string, std::string> subdet_and_tag = getSubDetFolderAndTag(detid, tTopo);
  folder_name = subdet_and_tag.first;
}
//
// -- Get the name of Subdetector Layer folder
//
void SiStripFolderOrganizer::getLayerFolderName(std::stringstream& ss,
                                                uint32_t rawdetid,
                                                const TrackerTopology* tTopo,
                                                bool ring_flag) {
  ss << TopFolderName + SEP + MECHANICAL_FOLDER_NAME;
  if (rawdetid == 0) {  // just top MechanicalFolder if rawdetid==0;
    return;
  }
 
  SiStripDetId stripdet = SiStripDetId(rawdetid);
  if (stripdet.subDetector() == SiStripDetId::TIB) {
    // ---------------------------  TIB  --------------------------- //
 
    ss << SEP << "TIB" << SEP << "layer_" << tTopo->tibLayer(rawdetid);
  } else if (stripdet.subDetector() == SiStripDetId::TID) {
    // ---------------------------  TID  --------------------------- //
 
    uint32_t side = tTopo->tidSide(rawdetid);
    std::stringstream sside;
    if (side == 1) {
      sside << "MINUS";
    } else if (side == 2) {
      sside << "PLUS";
    }
 
    if (ring_flag) {
      ss << SEP << "TID" << SEP << sside.str() << SEP << "ring_" << tTopo->tidRing(rawdetid);
    } else {
      ss << SEP << "TID" << SEP << sside.str() << SEP << "wheel_" << tTopo->tidWheel(rawdetid);
    }
  } else if (stripdet.subDetector() == SiStripDetId::TOB) {
    // ---------------------------  TOB  --------------------------- //
 
    ss << SEP << "TOB" << SEP << "layer_" << tTopo->tobLayer(rawdetid);
  } else if (stripdet.subDetector() == SiStripDetId::TEC) {
    // ---------------------------  TEC  --------------------------- //
 
    uint32_t side = tTopo->tecSide(rawdetid);
    std::stringstream sside;
    if (side == 1) {
      sside << "MINUS";
    } else if (side == 2) {
      sside << "PLUS";
    }
 
    if (ring_flag) {
      ss << SEP << "TEC" << SEP << sside.str() << SEP << "ring_" << tTopo->tecRing(rawdetid);
    } else {
      ss << SEP << "TEC" << SEP << sside.str() << SEP << "wheel_" << tTopo->tecWheel(rawdetid);
    }
  } else {
    // ---------------------------  ???  --------------------------- //
    edm::LogWarning("SiStripTkDQM|WrongInput")
        << "no such subdetector type :" << stripdet.subDetector() << " no folder set!" << std::endl;
    return;
  }
}
//
// -- Get Subdetector Folder name and the Tag
//
std::pair<const std::string, const char*> SiStripFolderOrganizer::getSubDetFolderAndTag(const uint32_t& detid,
                                                                                        const TrackerTopology* tTopo) {
  const char* subdet_folder = "";
  const char* tag = "";
  switch (StripSubdetector::SubDetector(StripSubdetector(detid).subdetId())) {
    case StripSubdetector::TIB:
      subdet_folder = "TIB";
      tag = subdet_folder;
      break;
    case StripSubdetector::TOB:
      subdet_folder = "TOB";
      tag = subdet_folder;
      break;
    case StripSubdetector::TID:
      if (tTopo->tidSide(detid) == 2) {
        subdet_folder = "TID/PLUS";
        tag = "TID__PLUS";
      } else if (tTopo->tidSide(detid) == 1) {
        subdet_folder = "TID/MINUS";
        tag = "TID__MINUS";
      }
      break;
    case StripSubdetector::TEC:
      if (tTopo->tecSide(detid) == 2) {
        subdet_folder = "TEC/PLUS";
        tag = "TEC__PLUS";
      } else if (tTopo->tecSide(detid) == 1) {
        subdet_folder = "TEC/MINUS";
        tag = "TEC__MINUS";
      }
      break;
    default: {
      edm::LogWarning("SiStripCommon") << "WARNING!!! this detid does not belong to tracker" << std::endl;
      subdet_folder = "";
    }
  }
 
  std::string folder;
  folder.reserve(TopFolderName.size() + strlen(SEP MECHANICAL_FOLDER_NAME SEP) + strlen(subdet_folder) + 1);
  folder = TopFolderName + SEP MECHANICAL_FOLDER_NAME SEP + subdet_folder;
 
  return std::pair<const std::string, const char*>(folder, tag);
}