Continue updating FITS readers for ACADA

Author: sfegan

include/calin_global_config.hpp.in

@@ -38,11 +38,6 @@
 // Flags conditional compilation of GEANT4-specific code
 #cmakedefine CALIN_HAVE_GEANT4 1
 
-// CALIN_HAVE_CTA_CAMERASTOACTL
-// Flags conditional compilation of code depending on (proprietary)
-// CTA CamerasToACTL package
-#cmakedefine CALIN_HAVE_CTA_CAMERASTOACTL 1
-
 // Capture various CMake variables to pass to build system provenance class
 #define CALIN_BUILD_INSTALL_PREFIX     "${CMAKE_INSTALL_PREFIX}"
 #define CALIN_PROTO_INSTALL_DIR        "${CMAKE_INSTALL_PREFIX}/${CALIN_PROTO_INSTALL_DIR}"

include/iact_data/zfits_acada_data_source.hpp

@@ -31,6 +31,11 @@
 
 namespace calin { namespace iact_data { namespace zfits_acada_data_source {
 
+std::vector<std::string> get_zfits_table_names(std::string filename);
+std::vector<std::string> get_zfits_table_column_names(std::string filename, std::string tablename);
+std::vector<std::string> get_zfits_table_keys(std::string filename, std::string tablename);
+std::map<std::string,std::string> get_zfits_table_key_values(std::string filename, std::string tablename);
+
 template<typename EventMessage, typename HeaderMessage>
 class ZFITSSingleFileACADACameraEventDataSource:
   public calin::iact_data::acada_data_source::

src/iact_data/CMakeLists.txt

@@ -26,6 +26,7 @@ set(CALIN_SOURCES algorithms.cpp
 	nectarcam_ancillary_data.cpp
 	acada_data_source.cpp zfits_acada_data_source.cpp 
 	acada_event_decoder.cpp
+	nectarcam_acada_event_decoder_l0.cpp 
 	nectarcam_acada_event_decoder_r1v0.cpp
 	zfits_data_source.cpp)
 

src/iact_data/cta_acada_event_decoder_r1v0.cpp

@@ -61,28 +61,6 @@ bool CTA_ACADACameraEventDecoder_R1v0::decode(
   const event_type* cta_event)
 {
   ensure_deligate(cta_event, nullptr);    
-
-  if(this->delegate()==nullptr) {
-    if((config_.camera_type() == CTACameraEventDecoderConfig::NECTARCAM) or
-      ((config_.camera_type() == CTACameraEventDecoderConfig::AUTO_DETECT) and
-        (cta_event!=nullptr and cta_event->has_nectarcam())))
-      this->set_delegate(new NectarCam_ACADACameraEventDecoder_R1v0(filename_, run_number_, config_.nectarcam()),true);
-    else if((config_.camera_type() == CTACameraEventDecoderConfig::LSTCAM) or
-      ((config_.camera_type() == CTACameraEventDecoderConfig::AUTO_DETECT) and
-        (cta_event!=nullptr and cta_event->has_lstcam())))
-      this->set_delegate(new LSTCam_ACADACameraEventDecoder_R1v0(filename_, run_number_, config_.lstcam()),true);
-    else
-      throw std::runtime_error("CTA_ACADACameraEventDecoder_R1v0: event does not "
-        "have NectarCAM or LSTCam extensions");
-  } else if(config_.camera_type() == CTACameraEventDecoderConfig::AUTO_DETECT
-      and dynamic_cast<LSTCam_ACADACameraEventDecoder_R1v0*>(this->delegate())
-      and cta_event!=nullptr and cta_event->has_nectarcam()) {
-    this->set_delegate(new NectarCam_ACADACameraEventDecoder_R1v0(filename_, run_number_, config_.nectarcam()),true);
-  } else if(config_.camera_type() == CTACameraEventDecoderConfig::AUTO_DETECT
-      and dynamic_cast<NectarCam_ACADACameraEventDecoder_R1v0*>(this->delegate())
-      and cta_event!=nullptr and cta_event->has_lstcam()) {
-    this->set_delegate(new LSTCam_ACADACameraEventDecoder_R1v0(filename_, run_number_, config_.lstcam()),true);
-  }
   return this->delegate()->decode(event, cta_event);
 }
 

src/iact_data/nectarcam_actl_l0_event_decoder.cpp src/iact_data/nectarcam_acada_event_decoder_l0.cpp

@@ -25,38 +25,19 @@
 #include <memory>
 #include <numeric>
 
-#if !defined(__clang__) and defined(__GNUC__) && __GNUC__<5
-namespace std {
-
-inline void *align( std::size_t alignment, std::size_t size,
-                void *&ptr, std::size_t &space ) {
-  std::uintptr_t pn = reinterpret_cast< std::uintptr_t >( ptr );
-  std::uintptr_t aligned = ( pn + alignment - 1 ) & - alignment;
-  std::size_t padding = aligned - pn;
-  if ( space < size + padding ) return nullptr;
-  space -= padding;
-  return ptr = reinterpret_cast< void * >( aligned );
-}
-
-}
-#endif
-
 #include <util/log.hpp>
 #include <util/file.hpp>
-#include <iact_data/nectarcam_actl_event_decoder.hpp>
+#include <iact_data/nectarcam_acada_event_decoder.hpp>
 #include <iact_data/nectarcam_layout.hpp>
 #include <iact_data/nectarcam_configuration.hpp>
 #include <provenance/system_info.hpp>
 
-using namespace calin::iact_data::nectarcam_actl_event_decoder;
+using namespace calin::iact_data::nectarcam_acada_event_decoder;
 using namespace calin::ix::iact_data::telescope_event;
 using namespace calin::ix::iact_data::telescope_run_configuration;
 using namespace calin::ix::iact_data::nectarcam_data_source;
 using namespace calin::util::log;
 
-#include <ProtobufIFits.h>
-#include <L0.pb.h>
-
 #define TEST_ANYARRAY_TYPES 0
 
 /*
@@ -80,10 +61,10 @@ using namespace calin::util::log;
 
 */
 
-NectarCam_ACTL_L0_CameraEventDecoder::NectarCam_ACTL_L0_CameraEventDecoder(
+NectarCam_ACADACameraEventDecoder_L0::NectarCam_ACADACameraEventDecoder_L0(
   const std::string& filename,
   unsigned run_number, const config_type& config):
-  actl_event_decoder::ACTL_L0_CameraEventDecoder(), config_(config),
+  calin::iact_data::acada_event_decoder::ACADACameraEventDecoder_L0(), config_(config),
   filename_(filename), run_number_(run_number)
 {
   switch(config.exchange_gain_channels()) {
@@ -102,14 +83,14 @@ NectarCam_ACTL_L0_CameraEventDecoder::NectarCam_ACTL_L0_CameraEventDecoder(
   }
 }
 
-NectarCam_ACTL_L0_CameraEventDecoder::~NectarCam_ACTL_L0_CameraEventDecoder()
+NectarCam_ACADACameraEventDecoder_L0::~NectarCam_ACADACameraEventDecoder_L0()
 {
   // nothing to see here
 }
 
-bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
+bool NectarCam_ACADACameraEventDecoder_L0::decode(
   calin::ix::iact_data::telescope_event::TelescopeEvent* calin_event,
-  const DataModel::CameraEvent* cta_event)
+  const event_type* cta_event)
 {
   calin_event->set_telescope_id(cta_event->telescopeid());
   calin_event->set_local_event_number(cta_event->eventnumber());
@@ -321,7 +302,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
   if(cta_event->uctsdatapresence() and cta_event->has_uctsdata() and
     cta_event->uctsdata().has_data())
   {
-    calin::iact_data::actl_event_decoder::decode_cdts_data(
+    calin::iact_data::acada_event_decoder::decode_cdts_data(
       calin_event->mutable_cdts_data(), cta_event->uctsdata().data());
 
     const auto& cdts = calin_event->cdts_data();
@@ -365,7 +346,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
   if(cta_event->tibdatapresence() and cta_event->has_tibdata() and
     cta_event->tibdata().has_data())
   {
-    calin::iact_data::actl_event_decoder::decode_tib_data(
+    calin::iact_data::acada_event_decoder::decode_tib_data(
       calin_event->mutable_tib_data(), cta_event->tibdata().data());
 
     const auto& tib = calin_event->tib_data();
@@ -428,11 +409,11 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
 
   if(calin_event->has_tib_data()) {
     calin_event->set_trigger_type(
-      calin::iact_data::actl_event_decoder::determine_trigger_type(
+      calin::iact_data::acada_event_decoder::determine_trigger_type(
         &calin_event->tib_data(), nullptr));
   } else if(calin_event->has_cdts_data()) {
     calin_event->set_trigger_type(
-      calin::iact_data::actl_event_decoder::determine_trigger_type(
+      calin::iact_data::acada_event_decoder::determine_trigger_type(
         nullptr, &calin_event->cdts_data()));
   } else {
     // Now what cat? Now what?
@@ -447,7 +428,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
   if(config_.include_serialized_raw_data())
   {
     calin_event->set_serialized_raw_event_type(
-      SerializedRawEventType::SERIALIZED_RAW_EVENT_ACTL_PROTOBUF);
+      SerializedRawEventType::SERIALIZED_RAW_EVENT_ACADA_PROTOBUF);
     cta_event->SerializeToString(calin_event->mutable_serialized_raw_event());
   } else {
     calin_event->set_serialized_raw_event_type(
@@ -457,14 +438,14 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode(
   return true;
 }
 
-bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
+bool NectarCam_ACADACameraEventDecoder_L0::decode_run_config(
   calin::ix::iact_data::telescope_run_configuration::
     TelescopeRunConfiguration* calin_run_config,
-  const DataModel::CameraRunHeader* cta_run_header,
-  const DataModel::CameraEvent* cta_event)
+  const header_type* cta_run_header,
+  const event_type* cta_event)
 {
   calin_run_config->set_data_transcoder(
-    "calin::iact_data::nectarcam_actl_event_decoder::NectarCam_ACTL_L0_CameraEventDecoder");
+    "calin::iact_data::nectarcam_acada_event_decoder::NectarCam_ACADACameraEventDecoder_L0");
   calin_run_config->set_filename(filename_);
   calin_run_config->add_fragment_filename(filename_);
   calin_run_config->set_run_number(run_number_);
@@ -576,13 +557,13 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
   if(config_.demand_configured_module_id_size() != 0)
   {
     if(config_.demand_configured_module_id_size() != nmod)
-      throw std::runtime_error("NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config: "
+      throw std::runtime_error("NectarCam_ACADACameraEventDecoder_L0::decode_run_config: "
         "Demand module list size must equal number of modules in data.");
     config_mod_id.clear();
     for(int imod=0;imod<nmod;imod++) {
       unsigned mod_id = config_.demand_configured_module_id(imod);
       if(mod_id >= nmod_camera)
-        throw std::runtime_error("NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config: "
+        throw std::runtime_error("NectarCam_ACADACameraEventDecoder_L0::decode_run_config: "
           "Demand module id out of range: " + std::to_string(mod_id) + " >= " +
           std::to_string(nmod_camera));
       config_mod_id.insert(mod_id);
@@ -593,7 +574,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
     for(int imod=0; imod<nmod; imod++) {
       unsigned mod_id = calin_run_config->nectarcam().module(imod).module_id();
       if(mod_id >= nmod_camera)
-        throw std::runtime_error("NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config: "
+        throw std::runtime_error("NectarCam_ACADACameraEventDecoder_L0::decode_run_config: "
           "Demand module id out of range: " + std::to_string(mod_id) + " >= " +
           std::to_string(nmod_camera));
       config_mod_id.insert(mod_id);
@@ -679,7 +660,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
     cta_event->uctsdata().has_data())
   {
     calin::ix::iact_data::telescope_event::CDTSData calin_cdts_data;
-    calin::iact_data::actl_event_decoder::decode_cdts_data(
+    calin::iact_data::acada_event_decoder::decode_cdts_data(
       &calin_cdts_data, cta_event->uctsdata().data());
 
     if(calin_cdts_data.white_rabbit_status() == 1) {
@@ -697,7 +678,7 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
   if(cta_run_header and config_.include_serialized_raw_data())
   {
     calin_run_config->set_serialized_raw_header_type(
-      SerializedRawHeaderType::SERIALIZED_RAW_HEADER_ACTL_L0_PROTOBUF);
+      SerializedRawHeaderType::SERIALIZED_RAW_HEADER_ACADA_L0_PROTOBUF);
     cta_run_header->SerializeToString(calin_run_config->mutable_serialized_raw_header());
   } else {
     calin_run_config->set_serialized_raw_header_type(
@@ -707,10 +688,10 @@ bool NectarCam_ACTL_L0_CameraEventDecoder::decode_run_config(
   return true;
 }
 
-void NectarCam_ACTL_L0_CameraEventDecoder::
-copy_single_gain_integrals(const DataModel::CameraEvent* cta_event,
+void NectarCam_ACADACameraEventDecoder_L0::
+copy_single_gain_integrals(const event_type* cta_event,
   const calin::ix::iact_data::telescope_event::TelescopeEvent* calin_event,
-  const DataModel::PixelsChannel& cta_image,
+  const ProtoDataModel::PixelsChannel& cta_image,
   calin::ix::iact_data::telescope_event::DigitizedSkyImage* calin_image,
   const std::string& which_gain,
   calin::ix::iact_data::telescope_event::SignalType signal_type) const
@@ -752,10 +733,10 @@ copy_single_gain_integrals(const DataModel::CameraEvent* cta_event,
   }
 }
 
-void NectarCam_ACTL_L0_CameraEventDecoder::
-copy_single_gain_waveforms(const DataModel::CameraEvent* cta_event,
+void NectarCam_ACADACameraEventDecoder_L0::
+copy_single_gain_waveforms(const event_type* cta_event,
   const calin::ix::iact_data::telescope_event::TelescopeEvent* calin_event,
-  const DataModel::PixelsChannel& cta_image,
+  const ProtoDataModel::PixelsChannel& cta_image,
   calin::ix::iact_data::telescope_event::DigitizedSkyImage* calin_image,
   const std::string& which_gain,
   calin::ix::iact_data::telescope_event::SignalType signal_type) const
@@ -838,8 +819,8 @@ copy_single_gain_waveforms(const DataModel::CameraEvent* cta_event,
   }
 }
 
-unsigned NectarCam_ACTL_L0_CameraEventDecoder::
-get_nmod_from_event(const DataModel::CameraEvent* cta_event) const
+unsigned NectarCam_ACADACameraEventDecoder_L0::
+get_nmod_from_event(const event_type* cta_event) const
 {
   unsigned nmod = 0;
   if(cta_event->has_modulestatus() and
@@ -913,6 +894,6 @@ get_nmod_from_event(const DataModel::CameraEvent* cta_event) const
   return nmod;
 }
 
-NectarCam_ACTL_L0_CameraEventDecoder* NectarCam_ACTL_L0_CameraEventDecoder::clone() const {
-  return new NectarCam_ACTL_L0_CameraEventDecoder(*this);
+NectarCam_ACADACameraEventDecoder_L0* NectarCam_ACADACameraEventDecoder_L0::clone() const {
+  return new NectarCam_ACADACameraEventDecoder_L0(*this);
 }

src/iact_data/zfits_acada_data_source.cpp

@@ -61,6 +61,81 @@ namespace {
   template<> std::string default_message_table_name<ACADA_EventMessage_R1v1>() { return "Events"; }
 } // anonymous namespace
 
+std::vector<std::string> calin::iact_data::zfits_acada_data_source::
+get_zfits_table_names(std::string filename)
+{
+  calin::util::file::expand_filename_in_place(filename);
+  std::vector<std::string> tables;
+  try {
+    IFits ifits(filename, "", /* force= */ true);
+    if(ifits) {
+      tables.push_back(ifits.GetTable().name);
+    }
+    while(ifits.hasNextTable()) {
+      ifits.openNextTable(/* force= */ true);
+      tables.push_back(ifits.GetTable().name);
+    }
+  } catch(...) {
+    throw std::runtime_error(std::string("Could not open ZFits file: ")+filename);
+  }
+  return tables;
+}
+
+std::vector<std::string> calin::iact_data::zfits_acada_data_source::
+get_zfits_table_column_names(std::string filename, std::string tablename)
+{
+  calin::util::file::expand_filename_in_place(filename);
+  std::vector<std::string> columns;
+  try {
+    IFits ifits(filename, tablename, /* force= */ true);
+    if(ifits) {
+      for(const auto& col : ifits.GetColumns()) {
+        columns.push_back(col.first);
+      }
+    }
+  } catch(...) {
+    throw std::runtime_error(std::string("Could not open ZFits file table: ")+filename + " -> " + tablename);
+  }
+  return columns;
+}
+
+std::vector<std::string> calin::iact_data::zfits_acada_data_source::
+get_zfits_table_keys(std::string filename, std::string tablename)
+{
+  calin::util::file::expand_filename_in_place(filename);
+  std::vector<std::string> keys;
+  try {
+    IFits ifits(filename, tablename, /* force= */ true);
+    if(ifits) {
+      for(const auto& key : ifits.GetKeys()) {
+        keys.push_back(key.first);
+      }
+    }
+  } catch(...) {
+    throw std::runtime_error(std::string("Could not open ZFits file table: ")+filename + " -> " + tablename);
+  }
+  return keys;
+}
+
+std::map<std::string,std::string> calin::iact_data::zfits_acada_data_source::
+get_zfits_table_key_values(std::string filename, std::string tablename)
+{
+  calin::util::file::expand_filename_in_place(filename);
+  std::map<std::string,std::string> key_values;
+  try {
+    IFits ifits(filename, tablename, /* force= */ true);
+    if(ifits) {
+      for(const auto& key : ifits.GetKeys()) {
+        key_values[key.first] = key.second.value;
+      }
+    }
+  } catch(...) {
+    throw std::runtime_error(std::string("Could not open ZFits file table: ")+filename + " -> " + tablename);
+  }
+  return key_values;
+}
+
+
 // =============================================================================
 // =============================================================================
 // =============================================================================

swig/calin_global_definitions.i

@@ -27,6 +27,9 @@
 
 %{
 #include <iostream>
+#include <string>
+#include <vector>
+#include <map>
 #include "calin_global_definitions.hpp"
 #define SWIG_FILE_WITH_INIT
   %}
@@ -36,6 +39,7 @@
 %include <std_pair.i>
 %include <std_vector.i>
 %include <std_string.i>
+%include <std_map.i>
 %include "calin_stdint.i"
 
 %init %{
@@ -66,4 +70,6 @@
 %template (PairUnsignedUnsigned) std::pair<unsigned,unsigned>;
 %template (VectorPairUnsignedUnsigned) std::vector<std::pair<unsigned,unsigned> >;
 
+%template (MapStringString)      std::map<std::string,std::string>;
+
 %import "calin_global_definitions.hpp"