renamed Matterhorn decoders

include/aare/PixelMap.hpp

@@ -21,8 +21,9 @@ NDArray<ssize_t, 3> GenerateMH02FourCounterPixelMap();
  * @param dynamic_range Dynamic range of the detector (16, 8, or 4)
  * @param n_counters Number of counters (1 to 4)
  */
-NDArray<ssize_t, 2> GenerateMatterhorn2PixelMap(const size_t dynamic_range = 16,
+NDArray<ssize_t, 2>
-                                                const size_t n_counters = 1);
+GenerateMatterhorn10PixelMap(const size_t dynamic_range = 16,
+                             const size_t n_counters = 1);
 
 // Eiger
 NDArray<ssize_t, 2> GenerateEigerFlipRowsPixelMap();

python/aare/transform.py

@@ -40,19 +40,31 @@ class Moench05TransformOld:
 
     def __call__(self, data):
         return np.take(data.view(np.uint16), self.pixel_map)
-
+    
-
+class Matterhorn02TransceiverTransform: 
-class Matterhorn02Transform:
+    #Could be moved to C++ without changing the interface
     def __init__(self):
-        self.pixel_map = _aare.GenerateMH02FourCounterPixelMap()
+        self.pixel_map = _aare.GenerateMH02SingleCounterPixelMap()
 
     def __call__(self, data):
-        counters = int(data.size / 48**2 / 2)
+        return np.take(data.view(np.uint16), self.pixel_map)
-        if counters == 1:
-            return np.take(data.view(np.uint16), self.pixel_map[0])
-        else:
-            return np.take(data.view(np.uint16), self.pixel_map[0:counters])
 
+# TODO: give a reasonable name 
+class Matterhorn02Transform:
+    def __init__(self, dynamic_range : int, num_counters : int):
+        self.pixel_map = _aare.GenerateMatterhorn2PixelMap(dynamic_range, num_counters)
+        self.dynamic_range = dynamic_range
+        self.num_counters = num_counters 
+
+    def __call__(self, data):
+        if self.dynamic_range == 16:
+            return np.take(data.view(np.uint16), self.pixel_map)
+        elif self.dynamic_range == 8: 
+            return np.take(data.view(np.uint8), self.pixel_map)
+        else: 
+            return 0 
+            #return np.take(data.view()) # TODO need to expand to 8 bits 
+            
 class Mythen302Transform:
     """
     Transform Mythen 302 test chip data from a buffer of bytes (uint8_t)

python/src/bind_PixelMap.hpp

@@ -33,15 +33,35 @@ void define_pixel_map_bindings(py::module &m) {
                      new NDArray<ssize_t, 2>(GenerateMoench05PixelMapOld());
                  return return_image_data(ptr);
              })
+
+        .def("GenerateMoench04AnalogPixelMap",
+             []() {
+                 auto ptr =
+                     new NDArray<ssize_t, 2>(GenerateMoench04AnalogPixelMap());
+                 return return_image_data(ptr);
+             })
+
         .def("GenerateMH02SingleCounterPixelMap",
              []() {
                  auto ptr = new NDArray<ssize_t, 2>(
                      GenerateMH02SingleCounterPixelMap());
                  return return_image_data(ptr);
              })
-        .def("GenerateMH02FourCounterPixelMap", []() {
+        .def("GenerateMH02FourCounterPixelMap",
-            auto ptr =
+             []() {
-                new NDArray<ssize_t, 3>(GenerateMH02FourCounterPixelMap());
+                 auto ptr =
-            return return_image_data(ptr);
+                     new NDArray<ssize_t, 3>(GenerateMH02FourCounterPixelMap());
-        });
+                 return return_image_data(ptr);
+             })
+
+        .def(
+            "GenerateMatterhorn10PixelMap",
+            [](const size_t dynamic_range, const size_t n_counters) {
+                auto ptr = new NDArray<ssize_t, 2>(
+                    GenerateMatterhorn10PixelMap(dynamic_range, n_counters));
+                return return_image_data(ptr);
+            },
+            py::arg("dynamic_range") = 16, py::arg("n_counters") = 1,
+            R"(
+        Generate pixel map for Matterhorn02 detector)");
 }

python/src/module.cpp

@@ -14,12 +14,12 @@
 #include "bind_calibration.hpp"
 
 // TODO! migrate the other names
+#include "bind_PixelMap.hpp"
 #include "ctb_raw_file.hpp"
 #include "file.hpp"
 #include "fit.hpp"
 #include "jungfrau_data_file.hpp"
 #include "pedestal.hpp"
-#include "pixel_map.hpp"
 #include "raw_file.hpp"
 #include "raw_master_file.hpp"
 #include "raw_sub_file.hpp"

src/PixelMap.cpp

@@ -165,8 +165,8 @@ NDArray<ssize_t, 3> GenerateMH02FourCounterPixelMap() {
     return order_map;
 }
 
-NDArray<ssize_t, 2> GenerateMatterhorn2PixelMap(const size_t dynamic_range,
+NDArray<ssize_t, 2> GenerateMatterhorn10PixelMap(const size_t dynamic_range,
-                                                const size_t n_counters) {
+                                                 const size_t n_counters) {
     constexpr size_t n_cols = 256;
     constexpr size_t n_rows = 256;
     NDArray<ssize_t, 2> pixel_map(