HcalTriggerGeometry.cxx

#include "Hcal/HcalTriggerGeometry.h"
 
#include <iostream>
#include <sstream>
 
#include "DetDescr/HcalGeometry.h"
#include "Framework/ConditionsObjectProvider.h"
#include "Framework/EventHeader.h"
 
namespace hcal {
 
HcalTriggerGeometry::HcalTriggerGeometry(const ldmx::HcalGeometry* hcalGeom)
    : ConditionsObject(CONDITIONS_OBJECT_NAME), hcal_geometry_{hcalGeom} {}
 
std::vector<ldmx::HcalDigiID> HcalTriggerGeometry::contentsOfQuad(
    ldmx::HcalTriggerID triggerCell) const {
  std::vector<ldmx::HcalDigiID> retval;
  for (int i_strip = 0; i_strip < 4; i_strip++) {
    int strip = i_strip + 4 * triggerCell.superstrip();
    if (strip >= hcal_geometry_->getNumStrips(triggerCell.section())) break;
    retval.push_back(ldmx::HcalDigiID(
        triggerCell.section(), triggerCell.layer(), strip, triggerCell.end()));
  }
  return retval;
}
 
std::vector<ldmx::HcalDigiID> HcalTriggerGeometry::contentsOfSTQ(
    ldmx::HcalTriggerID triggerCell) const {
  std::vector<ldmx::HcalDigiID> retval;
  for (int i_strip = 0; i_strip < 8; i_strip++) {
    for (int i_layer = 0; i_layer < 2; i_layer++) {
      int strip = i_strip + 8 * triggerCell.superstrip();
      if (strip >= hcal_geometry_->getNumStrips(triggerCell.section()))
        continue;
      int tlayer = triggerCell.layer();
      int player = 2 * (tlayer + i_strip) - tlayer % 2;
      if (player >= hcal_geometry_->getNumLayers(triggerCell.section()))
        continue;
      retval.push_back(ldmx::HcalDigiID(triggerCell.section(), player, strip,
                                        triggerCell.end()));
    }
  }
  return retval;
}
 
ldmx::HcalTriggerID HcalTriggerGeometry::belongsToQuad(
    ldmx::HcalDigiID precisionCell) const {
  return ldmx::HcalTriggerID(precisionCell.section(), precisionCell.layer(),
                             precisionCell.strip() / 4, precisionCell.end());
}
 
ldmx::HcalTriggerID HcalTriggerGeometry::belongsToSTQ(
    ldmx::HcalDigiID precisionCell) const {
  // 2x2 groups of quads, with "superlayers" like:
  // 0 1 0 1 2 3 2 3 ...
  // V H V H V H V H ...
  int layer = precisionCell.layer();
  int superlayer = 2 * (layer / 4) + (layer % 4) % 2;
  return ldmx::HcalTriggerID(precisionCell.section(), superlayer,
                             precisionCell.strip() / 8, precisionCell.end());
}
 
class HcalTriggerGeometryProvider : public framework::ConditionsObjectProvider {
 public:
  HcalTriggerGeometryProvider(const std::string& name,
                              const std::string& tagname,
                              const framework::config::Parameters& parameters,
                              framework::Process& process)
      : ConditionsObjectProvider(HcalTriggerGeometry::CONDITIONS_OBJECT_NAME,
                                 tagname, parameters, process),
        hcal_trigger_geometry_{nullptr} {}
 
  virtual ~HcalTriggerGeometryProvider() {
    if (hcal_trigger_geometry_ != nullptr) delete hcal_trigger_geometry_;
    hcal_trigger_geometry_ = nullptr;
  }
 
  virtual std::pair<const framework::ConditionsObject*,
                    framework::ConditionsIOV>
  getCondition(const ldmx::EventHeader& context) {
    if (hcal_trigger_geometry_ == nullptr) {
      std::pair<const framework::ConditionsObject*, framework::ConditionsIOV>
          cond_hcal_geom = requestParentCondition(
              ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME, context);
      const ldmx::HcalGeometry* hcalgeom =
          dynamic_cast<const ldmx::HcalGeometry*>(cond_hcal_geom.first);
      hcal_trigger_geometry_ = new HcalTriggerGeometry(hcalgeom);
    }
    return std::make_pair(hcal_trigger_geometry_,
                          framework::ConditionsIOV(
                              context.getRun(), context.getRun(), true, true));
  }
 
  virtual void releaseConditionsObject(const framework::ConditionsObject* co) {}
 
 private:
  HcalTriggerGeometry* hcal_trigger_geometry_;
};
 
}  // namespace hcal
DECLARE_CONDITIONS_PROVIDER(hcal::HcalTriggerGeometryProvider);