def __init__(self, start_time_s, end_time_s):
""" Constructor. """
lg.info(" *")
lg.info(" * Initialising DataDay object...")
## The start time of the day [s].
self.__st_s = start_time_s
lg.info(" *--> Start time is % 15d [s] => '%s' UTC." % (self.__st_s, make_time_dir(self.__st_s)))
## The Python time object representing the day start time.
self.__st = time.gmtime(self.__st_s)
## The Pixelman time string of the start time.
self.__st_str = getPixelmanTimeString(self.__st_s)[2]
## The end time of the day [s].
self.__et_s = end_time_s
## The Python time object representing the month end time.
self.__et = time.gmtime(self.__et_s)
## The Pixelman time string of the end time.
self.__et_str = getPixelmanTimeString(self.__et_s)[2]
## The duration of the day [s].
self.__Delta_s = self.__et_s - self.__st_s + 1
## The number of non-full hour seconds in the day (error checking).
self.__remainder_seconds = int(self.__Delta_s % (60 * 60))
## The number of hours in the day [hours].
self.__n_hours = int((self.__Delta_s - self.__remainder_seconds) / (60 * 60))
#
if self.__remainder_seconds != 0:
raise IOError("* Error! Day has %d remainder seconds." % (self.__remainder_seconds))
## Dictionary of the number of frames recorded in each day.
self.__frames_in_an_hour = {}
#
## Dictionary of the hours in the day.
self.__hours = {}
#
for hour in range(self.__n_hours):
self.__frames_in_an_hour[hour] = 0
self.__hours[hour] = DataHour(self.__st_s + (hour*60*60), self.__st_s + ((hour+1)*60*60) - 1)
## The number of frames found in that day.
self.__num_frames = 0
# Update the user.
lg.info(" * Start time is %s (%d)" % (self.__st_str, self.__st_s))
lg.info(" * End time is %s (%d)" % (self.__et_str, self.__et_s))
lg.info(" * Number of hours in the day = %d" % (self.__n_hours))
lg.info(" *")
#
dataset_info_dict["Delta_T"] = Delta_T
#
dataset_info_dict["Delta_t"] = Delta_t
#
dataset_info_dict["delta_t"] = delta_t
#
dataset_info_dict["file_name"] = dataset_file_name
#
dataset_info_dict["n_frames"] = n_frames
#
dataset_info_dict["file_size"] = file_size
lg.info(" * Chip ID : '%s'" % (chip_id))
lg.info(" *")
lg.info(" * First start time: %s (%f)" % (first_start_time_str, st_s[ 0]))
lg.info(" * Last start time: %s (%f)" % (last_start_time_str, st_s[-1]))
lg.info(" *")
lg.info(" * Delta_{T} = %f [s]" % (Delta_T))
lg.info(" *")
lg.info(" * Delta_{t} = %f [s]" % (Delta_t))
lg.info(" *")
lg.info(" * File size = %d [B]" % (file_size))
## The JSON file name.
json_file_name = "%s_%s.json" % (chip_id, make_time_dir(st_s[0]))
#
# Write out the frame information to a JSON file.
with open(os.path.join(outputpath, json_file_name), "w") as jf:
json.dump(dataset_info_dict, jf)
def __init__(self, data_hour, **kwargs):
"""
Constructor.
"""
lg.info(" *")
lg.info(" * Initialising HourPlot object...")
#print(" * Initialising HourPlot object...")
# Reset the matplot lib plotting stuff.
plt.close()
# Here we create the figure on which we'll be plotting our results.
# We assign the figure a number, a size (5" x 3"), set the resolution
# of the image (150 DPI), and set the background and outline to white.
## The figure width [inches].
self.__fig_w = 42.0
#
if "fig_width" in kwargs.keys():
self.__fig_width = kwargs["fig_width"]
## The figure height [inches].
self.__fig_h = 4.2
#
if "fig_height" in kwargs.keys():
self.__fig_h = kwargs["fig_height"]
## The histogram.
self.__plot = plt.figure(101, figsize=(self.__fig_w, self.__fig_h), dpi=150, facecolor='w', edgecolor='w')
# Then we give a bit of clearance for the axes.
self.__plot.subplots_adjust(bottom=0.15, left=0.02, right=0.99)
# This is the subplot on which we'll actually be plotting.
self.__plot_ax = self.__plot.add_subplot(111)
# Label your axes:
## The x axis label.
self.__x_label = "$t$ / s"
#
if "x_label" in kwargs.keys():
self.__x_label = kwargs["x_label"]
#
plt.xlabel(self.__x_label)
## The y axis label.
self.__y_label = "$y$"
#
if "y_label" in kwargs.keys():
self.__y_label = kwargs["y_label"]
#
plt.ylabel(self.__y_label)
# Plot the number of frames.
# Should be we use a logarithmic scale for the y axis?
# Not yet, but we might do later.
uselogy = False
## The hour's start time.
h_st = data_hour.getStartTime()
lg.info(" * The hour's start time: %d [s] => '%s' UTC." % (h_st, make_time_dir(h_st)))
## The maximum y value.
y_max = 1.0
# Loop over the frames found.
for i, st in enumerate(data_hour.getStartTimes()):
## The frame's acquisition time [s].
acq_time = data_hour.getAcqTimes()[i]
## The number of pixels in the frame.
n_pixels = data_hour.getNumberOfPixels()[i]
lg.info(" * Found new frame: %s (%f [s], % 7d pixels)." % (time.asctime(time.gmtime(st)), acq_time, n_pixels))
## The "normal" frame colour.
frame_color = "#44aa44"
## The x position of the frame's bar (frame - hour's start time).
x = st - h_st
lg.info(" *--> Start time from frame: % 15d [s] => '%s' UTC." % (st, make_time_dir(st)))
lg.info(" *--> %d, %d, %d" % (st, h_st, x))
## The y position of the frame's bar.
y = 0
## The width of the bar - the acquition time.
w = acq_time
#
## The height of the bar - the pixels per second.
#
# This means the area of the bar is the total number of pixels
# in the frame.
if float(acq_time) > 0.:
h = float(n_pixels) / float(acq_time)
else:
h = 500
w = 1
frame_color = "#222288"
# Check if we have a noisy frame.
if n_pixels > 30000:
# Set the frame color to indicate an error (i.e. noise).
frame_color = "#882222"
else:
# If normal, check if we have a new maximum.
if h > y_max:
y_max = h
lg.info(" *---> (x, y) = (%f, %f)" % (x, y))
lg.info(" *---> (w, h) = (%f, %f)" % (w, h))
# Add a rectangle representing the frame to the plot.
self.__plot_ax.add_patch(Rectangle((x, y), w, h, facecolor=frame_color, edgecolor=frame_color))
# Round up to the nearest 10.
y_max = 10 * (np.floor(y_max/10.) + 1)
#
if y_max > 0:
plt.ylim([0.0, y_max])
# If supplied by the user, set the y axis limits.
if "y_max" in kwargs.keys():
y_max = kwargs["y_max"]
plt.ylim([0.0, y_max])
# Add gridlines.
plt.grid(1)
## The x axis maximum.
self.__x_max = 3600.0
#
if "x_max" in kwargs.keys():
self.__x_max = kwargs["x_max"]
# Set the x axis limits.
plt.xlim([0, self.__x_max])
# Set the x axis tickers.
self.__plot_ax.xaxis.set_ticks(np.arange(0.0, self.__x_max + 100, 100))
#self.__plot_ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1f'))
lg.info(" *")
#
dataset_info_dict["Delta_T"] = Delta_T
#
dataset_info_dict["Delta_t"] = Delta_t
#
dataset_info_dict["delta_t"] = delta_t
#
dataset_info_dict["file_name"] = dataset_file_name
#
dataset_info_dict["n_frames"] = n_frames
#
dataset_info_dict["file_size"] = file_size
lg.info(" * Chip ID : '%s'" % (chip_id))
lg.info(" *")
lg.info(" * First start time: %s (%f)" % (first_start_time_str, st_s[0]))
lg.info(" * Last start time: %s (%f)" % (last_start_time_str, st_s[-1]))
lg.info(" *")
lg.info(" * Delta_{T} = %f [s]" % (Delta_T))
lg.info(" *")
lg.info(" * Delta_{t} = %f [s]" % (Delta_t))
lg.info(" *")
lg.info(" * File size = %d [B]" % (file_size))
## The JSON file name.
json_file_name = "%s_%s.json" % (chip_id, make_time_dir(st_s[0]))
#
# Write out the frame information to a JSON file.
with open(os.path.join(outputpath, json_file_name), "w") as jf:
json.dump(dataset_info_dict, jf)
