added simple decoding of scan parameters

python/CMakeLists.txt

@@ -29,6 +29,7 @@ set( PYTHON_FILES
     aare/__init__.py
     aare/CtbRawFile.py
     aare/transform.py
+    aare/ScanParameters.py
 )
 
 # Copy the python files to the build directory

python/aare/CtbRawFile.py

@@ -1,7 +1,7 @@
 
 from . import _aare
 import numpy as np
-
+from .ScanParameters import ScanParameters
 class CtbRawFile(_aare.CtbRawFile):
     """File reader for the CTB raw file format.
     
@@ -108,7 +108,24 @@ class CtbRawFile(_aare.CtbRawFile):
             int: Frame position in file.
         """
         return super().tell()
+    
+    @property
+    def scan_parameters(self):
+        """Return the scan parameters.
 
+        Returns:
+            ScanParameters: Scan parameters.
+        """
+        return ScanParameters(self.master.scan_parameters)
+
+    @property
+    def master(self):
+        """Return the master file.
+
+        Returns:
+            RawMasterFile: Master file.
+        """
+        return super().master()
 
     @property
     def image_size_in_bytes(self) -> int:

python/aare/ScanParameters.py

@@ -0,0 +1,16 @@
+from . import _aare
+
+class ScanParameters(_aare.ScanParameters):
+    def __init__(self, s):
+        super().__init__(s)
+        
+    def __iter__(self):
+        return [getattr(self, a) for a in ['start', 'stop', 'step']].__iter__()
+    
+    def __str__(self):
+        return f'ScanParameters({self.dac}: {self.start}, {self.stop}, {self.step})'
+    
+    def __repr__(self):
+        return self.__str__()
+    
+    

python/aare/__init__.py

@@ -3,4 +3,5 @@ from . import _aare
 
 from ._aare import VarClusterFinder, File, RawMasterFile
 from ._aare import Pedestal, ClusterFinder
-from .CtbRawFile import CtbRawFile
+from .CtbRawFile import CtbRawFile
+from .ScanParameters import ScanParameters

python/aare/transform.py

@@ -5,7 +5,6 @@ from . import _aare
 class Moench05Transform:
     #Could be moved to C++ without changing the interface
     def __init__(self):
-        print('map created')
         self.pixel_map = _aare.GenerateMoench05PixelMap()
 
     def __call__(self, data):
@@ -23,6 +22,7 @@ class Matterhorn02Transform:
         else:
             return np.take(data.view(np.uint16), self.pixel_map[0:counters])
 
+
 #on import generate the pixel maps to avoid doing it every time
 moench05 = Moench05Transform()
 matterhorn02 = Matterhorn02Transform()

python/examples/play.py

@@ -95,11 +95,11 @@ f = aare.CtbRawFile(fpath, transform=transform.matterhorn02)
 f.seek(100)
 header1, image1 = f.read_frame()
 
-fpath = Path(base / 'scan_all15keV_vrf500_vrsh700_th0_master_0.json')
+# fpath = Path(base / 'scan_all15keV_vrf500_vrsh700_th0_master_0.json')
 
-f = aare.CtbRawFile(fpath, transform=transform.matterhorn02)
-f.seek(100)
-header4, image4 = f.read_frame()
+# f = aare.CtbRawFile(fpath, transform=transform.matterhorn02)
+# f.seek(100)
+# header4, image4 = f.read_frame()
 
 # n_counters = image.shape[1] / 48**2 / 2
 
@@ -112,7 +112,7 @@ header4, image4 = f.read_frame()
 
 
 #Data come in "blocks" of 4 pixels/receiver
-data = get_Mh02_frames(fpath.as_posix())
+# data = get_Mh02_frames(fpath.as_posix())
 
 # rawi = np.zeros(48*48*4+56, dtype = np.uint16)
 # for i,v in enumerate(rawi[56:]):
@@ -130,7 +130,7 @@ data = get_Mh02_frames(fpath.as_posix())
 #             pm[counter, row, col] = row*48 + col+counter*48*48
 
 
-f2 = aare.CtbRawFile(fpath, transform=transform.matterhorn02)
-header, data = f2.read()
-plt.plot(data[:,0,20,20])
+# f2 = aare.CtbRawFile(fpath, transform=transform.matterhorn02)
+# header, data = f2.read()
+# plt.plot(data[:,0,20,20])
 

python/src/file.hpp

@@ -166,11 +166,29 @@ void define_file_io_bindings(py::module &m) {
         .def_property_readonly("max_frames_per_file",
                                &RawMasterFile::max_frames_per_file)
         .def_property_readonly("bitdepth", &RawMasterFile::bitdepth)
+        .def_property_readonly("frame_padding", &RawMasterFile::frame_padding)
+        .def_property_readonly("frame_discard_policy",
+                               &RawMasterFile::frame_discard_policy)
+        .def_property_readonly("total_frames_expected", &RawMasterFile::total_frames_expected)
+        .def_property_readonly("geometry", &RawMasterFile::geometry)
         .def_property_readonly("analog_samples", &RawMasterFile::analog_samples)
         .def_property_readonly("digital_samples",
                                &RawMasterFile::digital_samples)
-        .def_property_readonly("transceiver_samples", &RawMasterFile::transceiver_samples);
+        .def_property_readonly("transceiver_samples", &RawMasterFile::transceiver_samples)
+        .def_property_readonly("number_of_rows", &RawMasterFile::number_of_rows)
+        .def_property_readonly("quad", &RawMasterFile::quad)
+        .def_property_readonly("scan_parameters", &RawMasterFile::scan_parameters);
 
+
+
+    py::class_<ScanParameters>(m, "ScanParameters")
+        .def(py::init<const std::string &>())
+        .def(py::init<const ScanParameters&>())
+        .def_property_readonly("enabled", &ScanParameters::enabled)
+        .def_property_readonly("dac", &ScanParameters::dac)
+        .def_property_readonly("start", &ScanParameters::start)
+        .def_property_readonly("stop", &ScanParameters::stop)
+        .def_property_readonly("step", &ScanParameters::step);
     // py::class_<ClusterHeader>(m, "ClusterHeader")
     //     .def(py::init<>())
     //     .def_readwrite("frame_number", &ClusterHeader::frame_number)