def test_nsplice(self): # test splicing of two datasets scale, dscale, overlap = nsplice.get_scaling_in_overlap( self.qv0, self.rv0, self.drv0, self.qv1, self.rv1, self.drv1 ) assert_almost_equal(scale, self.scale) assert_almost_equal(dscale, self.dscale)
def test_nsplice_overlap_points(self): scale, dscale, overlap = nsplice.get_scaling_in_overlap( self.x0, self.y0, self.dy0, self.x1, self.y1, self.dy1 ) assert_almost_equal(scale, 0.5) assert_equal(np.count_nonzero(overlap), 4)
def test_nsplice_nooverlap(self): # test splicing of two datasets if there's no overlap # the scale factor should be np.nan qv0 = self.qv0[0:10] scale, dscale, overlap = nsplice.get_scaling_in_overlap( qv0, self.rv0, self.drv0, self.qv1, self.rv1, self.drv1) assert_(not np.isfinite(scale)) assert_(not np.isfinite(dscale)) assert_equal(np.size(overlap, 0), 0)
def test_nsplice_overlap_points(self): scale, dscale, overlap = nsplice.get_scaling_in_overlap(self.x0, self.y0, self.dy0, self.x1, self.y1, self.dy1) assert_almost_equal(scale, 0.5) assert_equal(np.count_nonzero(overlap), 4)
def test_nsplice(self): # test splicing of two datasets scale, dscale, overlap = nsplice.get_scaling_in_overlap(self.qv0, self.rv0, self.drv0, self.qv1, self.rv1, self.drv1) assert_almost_equal(scale, self.scale) assert_almost_equal(dscale, self.dscale)
def test_nsplice_nooverlap(self): # test splicing of two datasets if there's no overlap # the scale factor should be np.nan qv0 = self.qv0[0:10] scale, dscale, overlap = nsplice.get_scaling_in_overlap(qv0, self.rv0, self.drv0, self.qv1, self.rv1, self.drv1) assert_(not np.isfinite(scale)) assert_(not np.isfinite(dscale))
def test_nsplice_notsorted(self): # test splicing of two datasets if there's no sorting # of the data vec0 = np.arange(np.size(self.qv0)) np.random.shuffle(vec0) vec1 = np.arange(np.size(self.qv1)) np.random.shuffle(vec1) scale, dscale, overlap = (nsplice.get_scaling_in_overlap( self.qv0[vec0], self.rv0[vec0], self.drv0[vec0], self.qv1[vec1], self.rv1[vec1], self.drv1[vec1])) assert_almost_equal(scale, self.scale) assert_almost_equal(dscale, self.dscale)
def test_nsplice_notsorted(self): # test splicing of two datasets if there's no sorting # of the data vec0 = np.arange(np.size(self.qv0)) np.random.shuffle(vec0) vec1 = np.arange(np.size(self.qv1)) np.random.shuffle(vec1) scale, dscale, overlap = ( nsplice.get_scaling_in_overlap(self.qv0[vec0], self.rv0[vec0], self.drv0[vec0], self.qv1[vec1], self.rv1[vec1], self.drv1[vec1])) assert_almost_equal(scale, self.scale) assert_almost_equal(dscale, self.dscale)
def add_data(self, data_tuple, requires_splice=False, trim_trailing=True): """ Adds more data to the dataset Parameters ---------- data_tuple : tuple 2 to 4 member tuple containing the (x, y, y_sd, x_sd) data to add to the dataset. `y_sd` and `x_sd` are optional. requires_splice : bool, optional When the new data is added to the dataset do you want to scale it vertically so that it overlaps with the existing data? `y` and `y_sd` in `data_tuple` are both multiplied by the scaling factor. trim_trailing : bool, optional When the new data is concatenated do you want to remove points from the existing data that are in the overlap region? This might be done because the datapoints in the `data_tuple` you are adding have have lower `y_sd` than the preceding data. """ xdata, ydata, ydata_sd, xdata_sd = self.data axdata, aydata = data_tuple[0:2] if len(data_tuple) > 2: aydata_sd = np.asfarray(data_tuple[2]).flatten() else: aydata_sd = np.ones_like(axdata) if len(data_tuple) > 3: axdata_sd = np.asfarray(data_tuple[3]).flatten() else: axdata_sd = np.zeros(np.size(axdata)) qq = np.r_[xdata] rr = np.r_[ydata] dr = np.r_[ydata_sd] dq = np.r_[xdata_sd] # which values in the first dataset overlap with the second overlap_points = np.zeros_like(qq, 'bool') # go through and stitch them together. scale = 1. dscale = 0. if requires_splice and self.npoints > 1: scale, dscale, overlap_points = ( get_scaling_in_overlap(qq, rr, dr, axdata, aydata, aydata_sd)) if not trim_trailing: overlap_points[:] = False qq = np.r_[qq[~overlap_points], axdata] dq = np.r_[dq[~overlap_points], axdata_sd] rr = np.r_[rr[~overlap_points], aydata * scale] dr = np.r_[dr[~overlap_points], aydata_sd * scale] self.data = (qq, rr, dr, dq) self.sort()
def add_data(self, data_tuple, requires_splice=False, trim_trailing=True): """ Adds more data to the dataset. Parameters ---------- data_tuple : tuple 2 to 4 member tuple containing the (x, y, y_err, x_err) data to add to the dataset. `y_err` and `x_err` are optional. requires_splice : bool, optional When the new data is added to the dataset do you want to scale it vertically so that it overlaps with the existing data? `y` and `y_err` in `data_tuple` are both multiplied by the scaling factor. trim_trailing : bool, optional When the new data is concatenated do you want to remove points from the existing data that are in the overlap region? This might be done because the datapoints in the `data_tuple` you are adding have have lower `y_err` than the preceding data. Notes ----- Raises `ValueError` if there are no points in the overlap region and `requires_splice` was True. The added data is not masked. """ x, y, y_err, x_err = self.data # dataset has no points, can just initialise with the tuple if not len(self): self.data = data_tuple return ax, ay = data_tuple[0:2] # if ((len(data_tuple) > 2 and self.y_err is None) or # (len(data_tuple) == 2 and self.y_err is not None)): # raise ValueError("Both the existing Data1D and the data you're" # " trying to add need to have y_err") # # if ((len(data_tuple) > 3 and self.x_err is None) or # (len(data_tuple) == 3 and self.x_err is not None)): # raise ValueError("Both the existing Data1D and the data you're" # " trying to add need to have x_err") ay_err = None ax_err = None if len(data_tuple) > 2: ay_err = np.array(data_tuple[2], dtype=float) if len(data_tuple) > 3: ax_err = np.array(data_tuple[3], dtype=float) mask2 = np.full_like(data_tuple[0], True, bool) # which values in the first dataset overlap with the second overlap_points = np.zeros_like(x, 'bool') # go through and stitch them together. scale = 1. dscale = 0. if requires_splice and len(self) > 1: scale, dscale, overlap_points = ( get_scaling_in_overlap(x, y, y_err, ax, ay, ay_err)) if ((not np.isfinite(scale)) or (not np.isfinite(dscale)) or (not np.size(overlap_points, 0))): raise ValueError("No points in overlap region") if not trim_trailing: overlap_points[:] = False qq = np.r_[x[~overlap_points], ax] rr = np.r_[y[~overlap_points], ay * scale] overall_mask = np.r_[self.mask[~overlap_points], mask2] try: dr = np.r_[y_err[~overlap_points], ay_err * scale] except (TypeError, ValueError): if (ay_err is not None) or (y_err is not None): raise ValueError("Both the existing Data1D and the data you're" " trying to add need to have y_err") dr = None try: dq = np.r_[x_err[~overlap_points], ax_err] except (TypeError, ValueError): if (ax_err is not None) or (x_err is not None): raise ValueError("Both the existing Data1D and the data you're" " trying to add need to have x_err") dq = None self.data = (qq, rr, dr, dq) self.mask = overall_mask self.sort()