def test_create_asciixyc_frame(self):
self.assertEqual(1, 1)
## The dataset wrapper.
ds = Dataset("testdata/ASCIIxyC")
## The frames from the test dataset.
frames = ds.getFrames((51.509915, -0.142515, 34.02))
# The tests
#-----------
## The cluster finder from the first frame.
kf = KlusterFinder(frames[0].getPixelMap(), frames[0].getWidth(), frames[0].getHeight(), frames[0].isMC())
# The number of clusters in the first frame.
#
# This frame has 34 clusters.
self.assertEqual(kf.getNumberOfKlusters(), 34)
self.assertEqual(kf.getNumberOfGammas(), 12)
self.assertEqual(kf.getNumberOfMonopixels(), 4)
self.assertEqual(kf.getNumberOfBipixels(), 2)
self.assertEqual(kf.getNumberOfTripixelGammas(), 4)
self.assertEqual(kf.getNumberOfTetrapixelGammas(), 2)
## The list of clusters.
ks = kf.getListOfKlusters()
# Double check the number of clusters found.
self.assertEqual(len(ks), 34)
# The first - and largest - cluster.
# Cluster size (number of pixels).
self.assertEqual(ks[0].getNumberOfPixels(), 104)
# Cluster location (raw pixels).
self.assertEqual(ks[0].getXMin(), 141)
self.assertEqual(ks[0].getXMax(), 153)
self.assertEqual(ks[0].getYMin(), 230)
self.assertEqual(ks[0].getYMax(), 244)
# Cluster width and height.
self.assertEqual(ks[0].getWidth(), 13)
self.assertEqual(ks[0].getHeight(), 15)
# Cluster properties based on the unweighted (UW) mean.
# * Location.
self.assertAlmostEqual(ks[0].getXUW(), 146.673077, places=6)
self.assertAlmostEqual(ks[0].getYUW(), 237.375000, places=6)
# * Radius and density.
self.assertAlmostEqual(ks[0].getRadiusUW(), 8.550607, places=6)
self.assertAlmostEqual(ks[0].getDensityUW(), 0.452782, places=6)
# Counts.
self.assertEqual(ks[0].getTotalCounts(), 8854)
self.assertEqual(ks[0].getMaxCountValue(), 577)
# Energy.
self.assertAlmostEqual(ks[0].getTotalEnergy(), 0.0, places=6)
self.assertAlmostEqual(ks[0].getMaxEnergy(), 0.0, places=6)
# Linearity.
m, c, sumR = ks[0].getLineOfBestFitValues()
self.assertAlmostEqual(m, -0.827317, places=6)
self.assertAlmostEqual(c, 358.720154, places=6)
self.assertAlmostEqual(sumR, 211.088562, places=6)
# Edge pixels.
self.assertEqual(ks[0].getNumberOfEdgePixels(), 57)
self.assertAlmostEqual(ks[0].getInnerPixelFraction(), 0.451923, places=6)
self.assertAlmostEqual(ks[0].getOuterPixelFraction(), 0.548077, places=6)
# Is it a Monte Carlo cluster?
self.assertEqual(ks[0].isMC(), False)
# Is it an edge cluster?
self.assertEqual(ks[0].isEdgeCluster(), False)
# A mid-range cluster.
# Cluster size (number of pixels).
self.assertEqual(ks[10].getNumberOfPixels(), 19)
# Cluster location (raw pixels).
self.assertEqual(ks[10].getXMin(), 167.0)
self.assertEqual(ks[10].getXMax(), 173.0)
self.assertEqual(ks[10].getYMin(), 196.0)
self.assertEqual(ks[10].getYMax(), 201.0)
# Cluster width and height.
self.assertEqual(ks[10].getWidth(), 7.0)
self.assertEqual(ks[10].getHeight(), 6.0)
# Cluster properties based on the unweighted (UW) mean.
# * Location.
self.assertAlmostEqual(ks[10].getXUW(), 170.315789, places=6)
self.assertAlmostEqual(ks[10].getYUW(), 198.526316, places=6)
# * Radius and density.
self.assertAlmostEqual(ks[10].getRadiusUW(), 3.357301, places=6)
self.assertAlmostEqual(ks[10].getDensityUW(), 0.536566, places=6)
# Counts.
self.assertEqual(ks[10].getTotalCounts(), 612)
self.assertEqual(ks[10].getMaxCountValue(), 69)
# Energy.
self.assertAlmostEqual(ks[10].getTotalEnergy(), 0.0, places=6)
self.assertAlmostEqual(ks[10].getMaxEnergy(), 0.0, places=6)
# Linearity.
m, c, sumR = ks[10].getLineOfBestFitValues()
self.assertAlmostEqual(m, 0.180385, places=6)
self.assertAlmostEqual(c, 167.803853, places=6)
self.assertAlmostEqual(sumR, 20.854321, places=6)
# Edge pixels.
self.assertEqual(ks[10].getNumberOfEdgePixels(), 19)
self.assertAlmostEqual(ks[10].getInnerPixelFraction(), 0.000000, places=6)
self.assertAlmostEqual(ks[10].getOuterPixelFraction(), 1.000000, places=6)
# Is it a Monte Carlo cluster?
self.assertEqual(ks[10].isMC(), False)
# Is it an edge cluster?
self.assertEqual(ks[10].isEdgeCluster(), False)
#print "JSON entry:", ks[10].getKlusterPropertiesJson()
# The last - and small - cluster.
# Cluster size (number of pixels).
self.assertEqual(ks[33].getNumberOfPixels(), 1)
# Cluster location (raw pixels).
self.assertEqual(ks[33].getXMin(), 97.0)
self.assertEqual(ks[33].getXMax(), 97.0)
self.assertEqual(ks[33].getYMin(), 135.0)
self.assertEqual(ks[33].getYMax(), 135.0)
# Cluster width and height.
self.assertEqual(ks[33].getWidth(), 1)
self.assertEqual(ks[33].getHeight(), 1)
# Cluster properties based on the unweighted (UW) mean.
# * Location.
self.assertAlmostEqual(ks[33].getXUW(), 97.000000, places=6)
self.assertAlmostEqual(ks[33].getYUW(), 135.000000, places=6)
# * Radius and density.
self.assertAlmostEqual(ks[33].getRadiusUW(), 0.000000, places=6)
self.assertAlmostEqual(ks[33].getDensityUW(), 0.000000, places=6)
# Counts.
self.assertEqual(ks[33].getTotalCounts(), 18)
self.assertEqual(ks[33].getMaxCountValue(), 18)
# Energy.
self.assertAlmostEqual(ks[33].getTotalEnergy(), 0.0, places=6)
self.assertAlmostEqual(ks[33].getMaxEnergy(), 0.0, places=6)
# Linearity.
m, c, sumR = ks[33].getLineOfBestFitValues()
self.assertAlmostEqual(m, 0.000000, places=6)
self.assertAlmostEqual(c, 97.000000, places=6)
self.assertAlmostEqual(sumR, 0.000000, places=6)
# Edge pixels.
self.assertEqual(ks[33].getNumberOfEdgePixels(), 1)
self.assertAlmostEqual(ks[33].getInnerPixelFraction(), 0.000000, places=6)
self.assertAlmostEqual(ks[33].getOuterPixelFraction(), 1.000000, places=6)
# Is it a Monte Carlo cluster?
self.assertEqual(ks[33].isMC(), False)
# Is it an edge cluster?
self.assertEqual(ks[33].isEdgeCluster(), False)
def __init__(self, **kwargs):
"""
Constructor.
"""
lg.debug(" Instantiating a Frame object.")
# Geospatial information
#------------------------
if "lat" not in kwargs.keys():
raise IOError("FRAME_NO_LAT")
## The frame latitude [deg.].
self.__lat = kwargs["lat"]
if "lon" not in kwargs.keys():
raise IOError("FRAME_NO_LON")
## The frame longitude [deg.].
self.__lon = kwargs["lon"]
if "alt" not in kwargs.keys():
raise IOError("FRAME_NO_ALT")
## The frame altitude [m].
self.__alt = kwargs["alt"]
## The roll angle of the lab. frame [deg.].
self.__roll = 0.0
if "roll" in kwargs.keys():
# TODO: validate the value.
self.__roll = kwargs["roll"]
## The pitch angle of the lab. frame [deg.].
self.__pitch = 0.0
if "pitch" in kwargs.keys():
# TODO: validate the value.
self.__pitch = kwargs["pitch"]
## The yaw angle of the lab. frame [deg.].
self.__yaw = 0.0
if "yaw" in kwargs.keys():
# TODO: validate the value.
self.__yaw = kwargs["yaw"]
## The Omega_x of the lab frame [deg. s^{-1}].
self.__omegax = 0.0
if "omegax" in kwargs.keys():
self.__omegax = kwargs["omegax"]
## The Omega_y of the lab frame [deg. s^{-1}].
self.__omegay = 0.0
if "omegay" in kwargs.keys():
self.__omegay = kwargs["omegay"]
## The Omega_z of the lab frame [deg. s^{-1}].
self.__omegaz = 0.0
if "omegaz" in kwargs.keys():
self.__omegaz = kwargs["omegaz"]
# For the detector.
if "chipid" not in kwargs.keys():
raise IOError("FRAME_NO_CHIPID")
## The chip ID.
self.__chipid = kwargs["chipid"]
if "biasvoltage" not in kwargs.keys():
raise IOError("FRAME_NO_HV")
## The bias voltage (HV) [V].
self.__hv = kwargs["biasvoltage"]
if "ikrum" not in kwargs.keys():
raise IOError("FRAME_NO IKRUM")
## The detector I_Krum value.
self.__ikrum = kwargs["ikrum"]
## The detector x position [mm].
self.__det_x = 0.0
if "detx" in kwargs.keys():
self.__det_x = kwargs["detx"]
## The detector y position [mm].
self.__det_y = 0.0
if "dety" in kwargs.keys():
self.__det_y = kwargs["dety"]
## The detector z position [mm].
self.__det_z = 0.0
if "detz" in kwargs.keys():
self.__det_z = kwargs["detz"]
## The detector Euler angle a [deg.].
self.__det_euler_a = 0.0
if "deteulera" in kwargs.keys():
self.__det_euler_a = kwargs["deteulera"]
## The detector Euler angle b [deg.].
self.__det_euler_b = 0.0
if "deteulerb" in kwargs.keys():
self.__det_euler_b = kwargs["deteulerb"]
## The detector Euler angle c [deg.].
self.__det_euler_c = 0.0
if "deteulerc" in kwargs.keys():
self.__det_euler_c = kwargs["deteulerc"]
# Temporal information
#----------------------
if "starttime" not in kwargs.keys() or "acqtime" not in kwargs.keys():
raise IOError("BAD_FRAME_TIME_INFO")
## The start time [s].
self.__starttime = kwargs["starttime"]
## The acquisition time [s].
self.__acqtime = kwargs["acqtime"]
self.__starttimesec, self.__starttimesubsec, sts = \
getPixelmanTimeString(self.__starttime)
lg.debug(" Frame found with start time: '%s'." % (sts))
## The end time [s].
self.__endtime = self.__starttime + self.__acqtime
self.__endtimesec, self.__endtimesubsec, ets = \
getPixelmanTimeString(self.__endtime)
# Payload information
#--------------------
## The frame width.
self.__width = 256
if "width" in kwargs.keys():
self.__width = kwargs["width"]
## The frame height.
self.__height = 256
if "height" in kwargs.keys():
self.__height = kwargs["height"]
if "format" not in kwargs.keys():
raise IOError("FRAME_NO_FORMAT")
## The payload format.
self.__format = kwargs["format"]
## The map of the pixels.
self.__pixelmap = {}
if "pixelmap" in kwargs.keys():
self.__pixelmap = kwargs["pixelmap"]
## The pixel mask map.
self.__pixel_mask_map = {}
if "pixelmask" in kwargs.keys():
self.__pixel_mask_map = kwargs["pixelmask"]
## Is the data from a Monte Carlo simulation?
self.__isMC = False
if "ismc" in kwargs.keys():
self.__ismc = kwargs["ismc"]
if "skipclustering" in kwargs.keys():
if kwargs["skipclustering"]:
#print("SKIPPING THE CLUSTERING!")
self.__n_klusters = -1
return None
# Do the clustering.
## The frame's cluster finder.
self.__kf = KlusterFinder(self.getPixelMap(), self.getWidth(),
self.getHeight(), self.isMC(),
self.__pixel_mask_map)
self.__n_klusters = self.__kf.getNumberOfKlusters()
class Frame:
"""
A wrapper class for Timepix frames.
"""
def __init__(self, **kwargs):
"""
Constructor.
"""
lg.debug(" Instantiating a Frame object.")
# Geospatial information
#------------------------
if "lat" not in kwargs.keys():
raise IOError("FRAME_NO_LAT")
## The frame latitude [deg.].
self.__lat = kwargs["lat"]
if "lon" not in kwargs.keys():
raise IOError("FRAME_NO_LON")
## The frame longitude [deg.].
self.__lon = kwargs["lon"]
if "alt" not in kwargs.keys():
raise IOError("FRAME_NO_ALT")
## The frame altitude [m].
self.__alt = kwargs["alt"]
## The roll angle of the lab. frame [deg.].
self.__roll = 0.0
if "roll" in kwargs.keys():
# TODO: validate the value.
self.__roll = kwargs["roll"]
## The pitch angle of the lab. frame [deg.].
self.__pitch = 0.0
if "pitch" in kwargs.keys():
# TODO: validate the value.
self.__pitch = kwargs["pitch"]
## The yaw angle of the lab. frame [deg.].
self.__yaw = 0.0
if "yaw" in kwargs.keys():
# TODO: validate the value.
self.__yaw = kwargs["yaw"]
## The Omega_x of the lab frame [deg. s^{-1}].
self.__omegax = 0.0
if "omegax" in kwargs.keys():
self.__omegax = kwargs["omegax"]
## The Omega_y of the lab frame [deg. s^{-1}].
self.__omegay = 0.0
if "omegay" in kwargs.keys():
self.__omegay = kwargs["omegay"]
## The Omega_z of the lab frame [deg. s^{-1}].
self.__omegaz = 0.0
if "omegaz" in kwargs.keys():
self.__omegaz = kwargs["omegaz"]
# For the detector.
if "chipid" not in kwargs.keys():
raise IOError("FRAME_NO_CHIPID")
## The chip ID.
self.__chipid = kwargs["chipid"]
if "biasvoltage" not in kwargs.keys():
raise IOError("FRAME_NO_HV")
## The bias voltage (HV) [V].
self.__hv = kwargs["biasvoltage"]
if "ikrum" not in kwargs.keys():
raise IOError("FRAME_NO IKRUM")
## The detector I_Krum value.
self.__ikrum = kwargs["ikrum"]
## The detector x position [mm].
self.__det_x = 0.0
if "detx" in kwargs.keys():
self.__det_x = kwargs["detx"]
## The detector y position [mm].
self.__det_y = 0.0
if "dety" in kwargs.keys():
self.__det_y = kwargs["dety"]
## The detector z position [mm].
self.__det_z = 0.0
if "detz" in kwargs.keys():
self.__det_z = kwargs["detz"]
## The detector Euler angle a [deg.].
self.__det_euler_a = 0.0
if "deteulera" in kwargs.keys():
self.__det_euler_a = kwargs["deteulera"]
## The detector Euler angle b [deg.].
self.__det_euler_b = 0.0
if "deteulerb" in kwargs.keys():
self.__det_euler_b = kwargs["deteulerb"]
## The detector Euler angle c [deg.].
self.__det_euler_c = 0.0
if "deteulerc" in kwargs.keys():
self.__det_euler_c = kwargs["deteulerc"]
# Temporal information
#----------------------
if "starttime" not in kwargs.keys() or "acqtime" not in kwargs.keys():
raise IOError("BAD_FRAME_TIME_INFO")
## The start time [s].
self.__starttime = kwargs["starttime"]
## The acquisition time [s].
self.__acqtime = kwargs["acqtime"]
self.__starttimesec, self.__starttimesubsec, sts = \
getPixelmanTimeString(self.__starttime)
lg.debug(" Frame found with start time: '%s'." % (sts))
## The end time [s].
self.__endtime = self.__starttime + self.__acqtime
self.__endtimesec, self.__endtimesubsec, ets = \
getPixelmanTimeString(self.__endtime)
# Payload information
#--------------------
## The frame width.
self.__width = 256
if "width" in kwargs.keys():
self.__width = kwargs["width"]
## The frame height.
self.__height = 256
if "height" in kwargs.keys():
self.__height = kwargs["height"]
if "format" not in kwargs.keys():
raise IOError("FRAME_NO_FORMAT")
## The payload format.
self.__format = kwargs["format"]
## The map of the pixels.
self.__pixelmap = {}
if "pixelmap" in kwargs.keys():
self.__pixelmap = kwargs["pixelmap"]
## The pixel mask map.
self.__pixel_mask_map = {}
if "pixelmask" in kwargs.keys():
self.__pixel_mask_map = kwargs["pixelmask"]
## Is the data from a Monte Carlo simulation?
self.__isMC = False
if "ismc" in kwargs.keys():
self.__ismc = kwargs["ismc"]
if "skipclustering" in kwargs.keys():
if kwargs["skipclustering"]:
#print("SKIPPING THE CLUSTERING!")
self.__n_klusters = -1
return None
# Do the clustering.
## The frame's cluster finder.
self.__kf = KlusterFinder(self.getPixelMap(), self.getWidth(),
self.getHeight(), self.isMC(),
self.__pixel_mask_map)
self.__n_klusters = self.__kf.getNumberOfKlusters()
# Accessor methods
#==================
# Geospatial information
#------------------------
def getLatitude(self):
return self.__lat
def getLongitude(self):
return self.__lon
def getAltitude(self):
return self.__alt
def getRoll(self):
return self.__roll
def getPitch(self):
return self.__pitch
def getYaw(self):
return self.__yaw
def getOmegax(self):
return self.__omegax
def getOmegay(self):
return self.__omegay
def getOmegaz(self):
return self.__omegaz
def getDetx(self):
return self.__det_x
def getDety(self):
return self.__det_y
def getDetz(self):
return self.__det_z
def getDetEulera(self):
return self.__det_euler_a
def getDetEulerb(self):
return self.__det_euler_b
def getDetEulerc(self):
return self.__det_euler_c
def getChipId(self):
return self.__chipid
def getBiasVoltage(self):
return self.__hv
def getIKrum(self):
return self.__ikrum
# Temporal information
#----------------------
def getStartTime(self):
return self.__starttime
def getStartTimeSec(self):
return self.__starttimesec
def getStartTimeSubSec(self):
return self.__starttimesubsec
def getEndTime(self):
return self.__endtime
def getEndTimeSec(self):
return self.__endtimesec
def getEndTimeSubSec(self):
return self.__endtimesubsec
def getAcqTime(self):
return self.__acqtime
# Payload information
#---------------------
def getWidth(self):
return self.__width
def getHeight(self):
return self.__height
def getFormat(self):
return self.__format
def getPixelMap(self):
return self.__pixelmap
def getPixelMask(self):
return self.__pixel_mask_map
def getRawNumberOfPixels(self):
return len(self.__pixelmap)
def getNumberOfUnmaskedPixels(self):
unmasked = 0
#lg.debug(self.__pixelmap)
#lg.debug(self.__pixel_mask_map)
#for X in self.__pixel_mask_map.keys():
# lg.debug(" * %5d -> (%5d,%5d)." % (X, X%256, X/256))
for X in self.__pixelmap.keys():
#lg.debug(" * Is %5d -> (%5d,%5d) in the map?" % (X, X%256, X/256))
if X not in self.__pixel_mask_map.keys():
#lg.debug(" *---> NO!")
unmasked += 1
#else:
# lg.debug(" *---> YES!")
return unmasked
def getNumberOfMaskedPixels(self):
return len(self.__pixel_mask_map)
def getOccupancy(self):
return len(self.__pixelmap)
def getOccupancyPc(self):
return float(len(self.__pixelmap)) / float(
self.__width * self.__height)
def isMC(self):
return self.__ismc
def getPixelsString(self):
s = ""
def getNumberOfKlusters(self):
return self.__n_klusters
def getNumberOfGammas(self):
return self.__kf.getNumberOfGammas()
def getNumberOfMonopixels(self):
return self.__kf.getNumberOfMonopixels()
def getNumberOfBipixels(self):
return self.__kf.getNumberOfBipixels()
def getNumberOfTripixelGammas(self):
return self.__kf.getNumberOfTripixelGammas()
def getNumberOfTetrapixelGammas(self):
return self.__kf.getNumberOfTetrapixelGammas()
def getNumberOfNonGammas(self):
return self.getNumberOfKlusters() - self.getNumberOfGammas()
def getKlusterFinder(self):
return self.__kf
def __init__(self, **kwargs):
"""
Constructor.
"""
lg.debug(" Instantiating a Frame object.")
# Geospatial information
#------------------------
if "lat" not in kwargs.keys():
raise IOError("FRAME_NO_LAT")
## The frame latitude [deg.].
self.__lat = kwargs["lat"]
if "lon" not in kwargs.keys():
raise IOError("FRAME_NO_LON")
## The frame longitude [deg.].
self.__lon = kwargs["lon"]
if "alt" not in kwargs.keys():
raise IOError("FRAME_NO_ALT")
## The frame altitude [m].
self.__alt = kwargs["alt"]
## The roll angle of the lab. frame [deg.].
self.__roll = 0.0
if "roll" in kwargs.keys():
# TODO: validate the value.
self.__roll = kwargs["roll"]
## The pitch angle of the lab. frame [deg.].
self.__pitch = 0.0
if "pitch" in kwargs.keys():
# TODO: validate the value.
self.__pitch = kwargs["pitch"]
## The yaw angle of the lab. frame [deg.].
self.__yaw = 0.0
if "yaw" in kwargs.keys():
# TODO: validate the value.
self.__yaw = kwargs["yaw"]
## The Omega_x of the lab frame [deg. s^{-1}].
self.__omegax = 0.0
if "omegax" in kwargs.keys():
self.__omegax = kwargs["omegax"]
## The Omega_y of the lab frame [deg. s^{-1}].
self.__omegay = 0.0
if "omegay" in kwargs.keys():
self.__omegay = kwargs["omegay"]
## The Omega_z of the lab frame [deg. s^{-1}].
self.__omegaz = 0.0
if "omegaz" in kwargs.keys():
self.__omegaz = kwargs["omegaz"]
# For the detector.
if "chipid" not in kwargs.keys():
raise IOError("FRAME_NO_CHIPID")
## The chip ID.
self.__chipid = kwargs["chipid"]
if "biasvoltage" not in kwargs.keys():
raise IOError("FRAME_NO_HV")
## The bias voltage (HV) [V].
self.__hv = kwargs["biasvoltage"]
if "ikrum" not in kwargs.keys():
raise IOError("FRAME_NO IKRUM")
## The detector I_Krum value.
self.__ikrum = kwargs["ikrum"]
## The detector x position [mm].
self.__det_x = 0.0
if "detx" in kwargs.keys():
self.__det_x = kwargs["detx"]
## The detector y position [mm].
self.__det_y = 0.0
if "dety" in kwargs.keys():
self.__det_y = kwargs["dety"]
## The detector z position [mm].
self.__det_z = 0.0
if "detz" in kwargs.keys():
self.__det_z = kwargs["detz"]
## The detector Euler angle a [deg.].
self.__det_euler_a = 0.0
if "deteulera" in kwargs.keys():
self.__det_euler_a = kwargs["deteulera"]
## The detector Euler angle b [deg.].
self.__det_euler_b = 0.0
if "deteulerb" in kwargs.keys():
self.__det_euler_b = kwargs["deteulerb"]
## The detector Euler angle c [deg.].
self.__det_euler_c = 0.0
if "deteulerc" in kwargs.keys():
self.__det_euler_c = kwargs["deteulerc"]
# Temporal information
#----------------------
if "starttime" not in kwargs.keys() or "acqtime" not in kwargs.keys():
raise IOError("BAD_FRAME_TIME_INFO")
## The start time [s].
self.__starttime = kwargs["starttime"]
## The acquisition time [s].
self.__acqtime = kwargs["acqtime"]
self.__starttimesec, self.__starttimesubsec, sts = \
getPixelmanTimeString(self.__starttime)
lg.debug(" Frame found with start time: '%s'." % (sts))
## The end time [s].
self.__endtime = self.__starttime + self.__acqtime
self.__endtimesec, self.__endtimesubsec, ets = \
getPixelmanTimeString(self.__endtime)
# Payload information
#--------------------
## The frame width.
self.__width = 256
if "width" in kwargs.keys():
self.__width = kwargs["width"]
## The frame height.
self.__height = 256
if "height" in kwargs.keys():
self.__height = kwargs["height"]
if "format" not in kwargs.keys():
raise IOError("FRAME_NO_FORMAT")
## The payload format.
self.__format = kwargs["format"]
## The map of the pixels.
self.__pixelmap = {}
if "pixelmap" in kwargs.keys():
self.__pixelmap = kwargs["pixelmap"]
## The pixel mask map.
self.__pixel_mask_map = {}
if "pixelmask" in kwargs.keys():
self.__pixel_mask_map = kwargs["pixelmask"]
## Is the data from a Monte Carlo simulation?
self.__isMC = False
if "ismc" in kwargs.keys():
self.__ismc = kwargs["ismc"]
if "skipclustering" in kwargs.keys():
if kwargs["skipclustering"]:
#print("SKIPPING THE CLUSTERING!")
self.__n_klusters = -1
return None
# Do the clustering.
## The frame's cluster finder.
self.__kf = KlusterFinder(self.getPixelMap(), self.getWidth(), self.getHeight(), self.isMC(), self.__pixel_mask_map)
self.__n_klusters = self.__kf.getNumberOfKlusters()
class Frame:
"""
A wrapper class for Timepix frames.
"""
def __init__(self, **kwargs):
"""
Constructor.
"""
lg.debug(" Instantiating a Frame object.")
# Geospatial information
#------------------------
if "lat" not in kwargs.keys():
raise IOError("FRAME_NO_LAT")
## The frame latitude [deg.].
self.__lat = kwargs["lat"]
if "lon" not in kwargs.keys():
raise IOError("FRAME_NO_LON")
## The frame longitude [deg.].
self.__lon = kwargs["lon"]
if "alt" not in kwargs.keys():
raise IOError("FRAME_NO_ALT")
## The frame altitude [m].
self.__alt = kwargs["alt"]
## The roll angle of the lab. frame [deg.].
self.__roll = 0.0
if "roll" in kwargs.keys():
# TODO: validate the value.
self.__roll = kwargs["roll"]
## The pitch angle of the lab. frame [deg.].
self.__pitch = 0.0
if "pitch" in kwargs.keys():
# TODO: validate the value.
self.__pitch = kwargs["pitch"]
## The yaw angle of the lab. frame [deg.].
self.__yaw = 0.0
if "yaw" in kwargs.keys():
# TODO: validate the value.
self.__yaw = kwargs["yaw"]
## The Omega_x of the lab frame [deg. s^{-1}].
self.__omegax = 0.0
if "omegax" in kwargs.keys():
self.__omegax = kwargs["omegax"]
## The Omega_y of the lab frame [deg. s^{-1}].
self.__omegay = 0.0
if "omegay" in kwargs.keys():
self.__omegay = kwargs["omegay"]
## The Omega_z of the lab frame [deg. s^{-1}].
self.__omegaz = 0.0
if "omegaz" in kwargs.keys():
self.__omegaz = kwargs["omegaz"]
# For the detector.
if "chipid" not in kwargs.keys():
raise IOError("FRAME_NO_CHIPID")
## The chip ID.
self.__chipid = kwargs["chipid"]
if "biasvoltage" not in kwargs.keys():
raise IOError("FRAME_NO_HV")
## The bias voltage (HV) [V].
self.__hv = kwargs["biasvoltage"]
if "ikrum" not in kwargs.keys():
raise IOError("FRAME_NO IKRUM")
## The detector I_Krum value.
self.__ikrum = kwargs["ikrum"]
## The detector x position [mm].
self.__det_x = 0.0
if "detx" in kwargs.keys():
self.__det_x = kwargs["detx"]
## The detector y position [mm].
self.__det_y = 0.0
if "dety" in kwargs.keys():
self.__det_y = kwargs["dety"]
## The detector z position [mm].
self.__det_z = 0.0
if "detz" in kwargs.keys():
self.__det_z = kwargs["detz"]
## The detector Euler angle a [deg.].
self.__det_euler_a = 0.0
if "deteulera" in kwargs.keys():
self.__det_euler_a = kwargs["deteulera"]
## The detector Euler angle b [deg.].
self.__det_euler_b = 0.0
if "deteulerb" in kwargs.keys():
self.__det_euler_b = kwargs["deteulerb"]
## The detector Euler angle c [deg.].
self.__det_euler_c = 0.0
if "deteulerc" in kwargs.keys():
self.__det_euler_c = kwargs["deteulerc"]
# Temporal information
#----------------------
if "starttime" not in kwargs.keys() or "acqtime" not in kwargs.keys():
raise IOError("BAD_FRAME_TIME_INFO")
## The start time [s].
self.__starttime = kwargs["starttime"]
## The acquisition time [s].
self.__acqtime = kwargs["acqtime"]
self.__starttimesec, self.__starttimesubsec, sts = \
getPixelmanTimeString(self.__starttime)
lg.debug(" Frame found with start time: '%s'." % (sts))
## The end time [s].
self.__endtime = self.__starttime + self.__acqtime
self.__endtimesec, self.__endtimesubsec, ets = \
getPixelmanTimeString(self.__endtime)
# Payload information
#--------------------
## The frame width.
self.__width = 256
if "width" in kwargs.keys():
self.__width = kwargs["width"]
## The frame height.
self.__height = 256
if "height" in kwargs.keys():
self.__height = kwargs["height"]
if "format" not in kwargs.keys():
raise IOError("FRAME_NO_FORMAT")
## The payload format.
self.__format = kwargs["format"]
## The map of the pixels.
self.__pixelmap = {}
if "pixelmap" in kwargs.keys():
self.__pixelmap = kwargs["pixelmap"]
## The pixel mask map.
self.__pixel_mask_map = {}
if "pixelmask" in kwargs.keys():
self.__pixel_mask_map = kwargs["pixelmask"]
## Is the data from a Monte Carlo simulation?
self.__isMC = False
if "ismc" in kwargs.keys():
self.__ismc = kwargs["ismc"]
if "skipclustering" in kwargs.keys():
if kwargs["skipclustering"]:
#print("SKIPPING THE CLUSTERING!")
self.__n_klusters = -1
return None
# Do the clustering.
## The frame's cluster finder.
self.__kf = KlusterFinder(self.getPixelMap(), self.getWidth(), self.getHeight(), self.isMC(), self.__pixel_mask_map)
self.__n_klusters = self.__kf.getNumberOfKlusters()
# Accessor methods
#==================
# Geospatial information
#------------------------
def getLatitude(self):
return self.__lat
def getLongitude(self):
return self.__lon
def getAltitude(self):
return self.__alt
def getRoll(self):
return self.__roll
def getPitch(self):
return self.__pitch
def getYaw(self):
return self.__yaw
def getOmegax(self):
return self.__omegax
def getOmegay(self):
return self.__omegay
def getOmegaz(self):
return self.__omegaz
def getDetx(self):
return self.__det_x
def getDety(self):
return self.__det_y
def getDetz(self):
return self.__det_z
def getDetEulera(self):
return self.__det_euler_a
def getDetEulerb(self):
return self.__det_euler_b
def getDetEulerc(self):
return self.__det_euler_c
def getChipId(self):
return self.__chipid
def getBiasVoltage(self):
return self.__hv
def getIKrum(self):
return self.__ikrum
# Temporal information
#----------------------
def getStartTime(self):
return self.__starttime
def getStartTimeSec(self):
return self.__starttimesec
def getStartTimeSubSec(self):
return self.__starttimesubsec
def getEndTime(self):
return self.__endtime
def getEndTimeSec(self):
return self.__endtimesec
def getEndTimeSubSec(self):
return self.__endtimesubsec
def getAcqTime(self):
return self.__acqtime
# Payload information
#---------------------
def getWidth(self):
return self.__width
def getHeight(self):
return self.__height
def getFormat(self):
return self.__format
def getPixelMap(self):
return self.__pixelmap
def getPixelMask(self):
return self.__pixel_mask_map
def getRawNumberOfPixels(self):
return len(self.__pixelmap)
def getNumberOfUnmaskedPixels(self):
unmasked = 0
#lg.debug(self.__pixelmap)
#lg.debug(self.__pixel_mask_map)
#for X in self.__pixel_mask_map.keys():
# lg.debug(" * %5d -> (%5d,%5d)." % (X, X%256, X/256))
for X in self.__pixelmap.keys():
#lg.debug(" * Is %5d -> (%5d,%5d) in the map?" % (X, X%256, X/256))
if X not in self.__pixel_mask_map.keys():
#lg.debug(" *---> NO!")
unmasked += 1
#else:
# lg.debug(" *---> YES!")
return unmasked
def getNumberOfMaskedPixels(self):
return len(self.__pixel_mask_map)
def getOccupancy(self):
return len(self.__pixelmap)
def getOccupancyPc(self):
return float(len(self.__pixelmap))/float(self.__width * self.__height)
def isMC(self):
return self.__ismc
def getPixelsString(self):
s = ""
def getNumberOfKlusters(self):
return self.__n_klusters
def getNumberOfGammas(self):
return self.__kf.getNumberOfGammas()
def getNumberOfMonopixels(self):
return self.__kf.getNumberOfMonopixels()
def getNumberOfBipixels(self):
return self.__kf.getNumberOfBipixels()
def getNumberOfTripixelGammas(self):
return self.__kf.getNumberOfTripixelGammas()
def getNumberOfTetrapixelGammas(self):
return self.__kf.getNumberOfTetrapixelGammas()
def getNumberOfNonGammas(self):
return self.getNumberOfKlusters() - self.getNumberOfGammas()
def getKlusterFinder(self):
return self.__kf
def test_create_asciixyc_frame(self):
## The dataset wrapper.
ds = Dataset("testdata/B06-W0212/2014-04-02-150255/RAW/ASCIIxyC/")
## The frame metadata.
fmd = None
#
with open("testdata/B06-W0212/2014-04-02-150255/geo.json", "r") as fmdf:
fmd = json.load(fmdf, fmd)
#
lat, lon, alt = fmd['lat'], fmd['lon'], fmd['alt']
## The pixel mask.
pixel_mask = {}
with open("testdata/B06-W0212/2014-04-02-150255/masked_pixels.txt", "r") as mpf:
rows = mpf.readlines()
for row in rows:
vals = [int(val) for val in row.strip().split("\t")]
x = vals[0]; y = vals[1]; X = (256*y) + x; C = 1
pixel_mask[X] = C
## The frames from the dataset.
frames = ds.getFrames((lat, lon, alt), pixelmask=pixel_mask)
# The tests
#-----------
## The cluster finder from the first frame.
kf = KlusterFinder(frames[0].getPixelMap(), frames[0].getWidth(), frames[0].getHeight(), frames[0].isMC())
# The number of clusters in the first frame.
#
# This frame has 34 clusters.
self.assertEqual(kf.getNumberOfKlusters(), 9)
self.assertEqual(kf.getNumberOfGammas(), 2)
self.assertEqual(kf.getNumberOfMonopixels(), 1)
self.assertEqual(kf.getNumberOfBipixels(), 0)
self.assertEqual(kf.getNumberOfTripixelGammas(), 0)
self.assertEqual(kf.getNumberOfTetrapixelGammas(), 1)
## The list of clusters.
ks = kf.getListOfKlusters()
# Double check the number of clusters found.
self.assertEqual(len(ks), 9)
# The first - and largest - cluster.
# Cluster size (number of pixels).
self.assertEqual(ks[0].getNumberOfPixels(), 25)
# Cluster location (raw pixels).
self.assertEqual(ks[0].getXMin(), 99)
self.assertEqual(ks[0].getXMax(), 110)
self.assertEqual(ks[0].getYMin(), 179)
self.assertEqual(ks[0].getYMax(), 193)
# Cluster width and height.
self.assertEqual(ks[0].getWidth(), 12)
self.assertEqual(ks[0].getHeight(), 15)
# Cluster properties based on the unweighted (UW) mean.
# * Location.
self.assertAlmostEqual(ks[0].getXUW(), 104.16, places=6)
self.assertAlmostEqual(ks[0].getYUW(), 185.320, places=6)
# * Radius and density.
self.assertAlmostEqual(ks[0].getRadiusUW(), 8.73430, places=6)
self.assertAlmostEqual(ks[0].getDensityUW(), 0.104312, places=6)
# Counts.
self.assertEqual(ks[0].getTotalCounts(), 879)
self.assertEqual(ks[0].getMaxCountValue(), 88)
# Energy.
self.assertAlmostEqual(ks[0].getTotalEnergy(), 0.0, places=6)
self.assertAlmostEqual(ks[0].getMaxEnergy(), 0.0, places=6)
# Linearity.
m, c, sumR = ks[0].getLineOfBestFitValues()
self.assertAlmostEqual(m, -1.127456, places=6)
self.assertAlmostEqual(c, 302.755829, places=6)
self.assertAlmostEqual(sumR, 16.283415, places=6)
# Edge pixels.
self.assertEqual(ks[0].getNumberOfEdgePixels(), 25)
self.assertAlmostEqual(ks[0].getInnerPixelFraction(), 0.0, places=6)
self.assertAlmostEqual(ks[0].getOuterPixelFraction(), 1.0, places=6)
# Is it a Monte Carlo cluster?
self.assertEqual(ks[0].isMC(), False)
# Is it an edge cluster?
self.assertEqual(ks[0].isEdgeCluster(), False)
