def generate_eye_data(domain, field, scale=None): """ :param object domain: A domain :param object field: Current field :param double scale: Scale factor by which to divide power :return: Temporal array and power matrix :rtype: Tuple Generates a temporal array and matrix containing eye traces. Each eye trace consists of the power array calculated for successive bits. """ # Use the first bit range for the temporal axis: t_eye = domain.t[0:domain.samples_per_bit] # Calculate power array and normalise if requested: P_t = temporal_power(field) if(scale is not None): P_t /= scale # Reshape into matrix with total_bits rows and samples_per_bit columns: P_eye = P_t.reshape(domain.total_bits, domain.samples_per_bit) # If passed a matrix, pyplot will plot each column as a separate data # series. Require each row to be plotted, so transpose the matrix: return t_eye, P_eye.T
def calculate(self): """ Actual calculation of metrics is performed in this function. """ maximum_absolute_difference = -1.0 sample_threshold = -1 maximum_Q = -1.0 sample_time = -1.0 TB = self.domain.total_bits SPB = self.domain.samples_per_bit for spb in range(SPB): data = [temporal_power(self.field[tb * SPB + spb]) for tb in range(TB)] threshold = np.sum(data) / TB zeros = [] ones = [] for datum in data: if(datum < threshold): zeros.append(datum) else: ones.append(datum) if((len(zeros) < 4) or (len(ones) < 4)): print "Not enough ones and zeros to calculate Q" #~raise Exception("Not enough ones and zeros to calculate Q") absolute_difference = np.abs(np.mean(ones) - np.mean(zeros)) if(absolute_difference > maximum_absolute_difference): maximum_absolute_difference = absolute_difference maximum_Q = \ absolute_difference / (np.std(ones) + np.std(zeros)) sample_time = spb * self.domain.dt sample_threshold = threshold # Store ones and zeros arrays: self.ones = ones self.zeros = zeros if(maximum_Q < 0.0): raise Exception("Unable to calculate maximum Q!") self.max_Q_dB = 10.0 * np.log10(maximum_Q) self.sample_time = sample_time self.sample_threshold = sample_threshold self.mean_peak_power_ones = np.mean(self.ones) self.mean_peak_power_zeros = np.mean(self.zeros) delta_ones = np.max(self.ones) - np.min(self.ones) AJ = 0.5 * delta_ones / np.mean(self.ones) self.amplitude_jitter = AJ ER = np.max(self.zeros) / (np.mean(self.ones) * (1.0 - AJ)) self.extinction_ratio = -10.0 * np.log10(ER)