def run_component(self, core, progress_dialog): #need to have x monotonically increasing... xyvals = zip(*sorted([(sample['depth'].magnitude, sample['Calibrated 14C Age'].magnitude) for sample in core])) core.properties['Age/Depth Model'] = datastructures.PointlistInterpolation(*xyvals, run = core.run)
def run_component(self, core, progress_dialog): x = [sample['depth'] for sample in core] y = [sample['Calibrated 14C Age'] for sample in core] interp_func = scipy.interpolate.interp1d([float(i) for i in x], [float(i) for i in y], bounds_error=False, fill_value=0, kind='quadratic') new_x = np.arange(min(x), max(x), abs(max(x)-min(x))/100.0) xyvals = zip(*sorted([(i, interp_func(i)) for i in new_x])) core.properties['Age/Depth Model'] = datastructures.PointlistInterpolation(*xyvals)
def run_component(self, core, progress_dialog): x = [sample['depth'].item() for sample in core] y = [sample['Calibrated 14C Age'] for sample in core] slope, y_intcpt, r_value, p_value, std_err = scipy.stats.linregress(x, y) xyvals = zip(*sorted([(i, y_intcpt + slope * i) for i in x])) core.properties['Age/Depth Model'] = datastructures.PointlistInterpolation(*xyvals, run = core.run)
def transform_dict_out(self, value): if value.get('_datatype', None) == 'baconinfo': return datastructures.BaconInfo(value['csv_data']) if value.get('_datatype', None) == 'pointlist': return datastructures.PointlistInterpolation( value['xpoints'], value['ypoints']) return None
def run_component(self, core, progress_dialog): xyvals = zip(*sorted([(sample['depth'].magnitude, sample['Calibrated 14C Age'].magnitude) for sample in core])) tck, u = scipy.interpolate.splprep(xyvals, s=200000) x_i, y_i = scipy.interpolate.splev(np.linspace(0, 1, 100), tck) xyvals = zip(*sorted([(x_i, y_i)])) core.properties['Age/Depth Model'] = datastructures.PointlistInterpolation(*xyvals, run = core.run)
def run_component(self, core, progress_dialog): '''Run BACON on the given core. core: the core data progress_dialog: a dialog box. Used to update progress on BACON. This calls the SWIG wrapper to BACON. It then updates core['all']['eggs'] = total_info and core.properties['Age/Depth Model'] ''' #build a guess for thickness similar to how Bacon's R code does it #section thickness is the expected granularity of change within the #core. currently, we are using the default BACON parameter of 5 (cm); #note that we can use a v large thickness to do a ballpark fast, #and that BACON suggests limiting # of sections/core to between 10 #and 200. #manual suggests for "larger" (>~2-3 m) cores, a good approach is #to start thick very high (say, 50) and lower it until a "smooth #enough" model is found. def scaledepth(key): return float(core[key]['depth'].rescale('cm').magnitude) thickguess = 5 mindepth = scaledepth(min(core.keys())) maxdepth = scaledepth(max(core.keys())) sections = (maxdepth - mindepth) / thickguess if sections < 10: thickguess = min(self.prettynum( (sections / 10.0) * thickguess)) elif sections > 200: thickguess = max( self.prettynum((sections / 200.0) * thickguess)) parameters = self.user_inputs( core, [('Bacon Number of Iterations', ('integer', None, False), 200), ('Bacon Section Thickness', ('float', 'cm', False), thickguess), ('Bacon Memory: Mean', ('float', None, False), 0.7), ('Bacon Memory: Strength', ('float', None, False), 4), ('Bacon Difference', ('float', None, False), max(core.keys()) - min(core.keys())), ('Bacon Sections', ('float', None, False), sections), ('Bacon t_a', ('integer', None, False), 4, { 'helptip': 't_b = t_a + 1' })]) num_iterations = parameters['Bacon Number of Iterations'] sections = int( numpy.ceil((maxdepth - mindepth) / parameters['Bacon Section Thickness'].magnitude)) # progress_dialog.Update(1, "Initializing BACON") #TODO: make sure to actually use the right units... data = self.build_data_array(core) memorya, memoryb = self.find_mem_params(core) hiatusi = self.build_hiatus_array(core, data) guesses = numpy.round( numpy.random.normal(data[0][1], data[0][2], 2)) guesses.sort() self.set_value(core, 'Bacon guess 1', guesses[0]) self.set_value(core, 'Bacon guess 2', guesses[1]) #create a temporary file for BACON to write its output to, so as #to read it back in later. #for the curious, this is not in prepare() because we want a new #file for every run of BACON, not every instance of this component. #self.tempfile = tempfile.NamedTemporaryFile() self.tempfile = open('tempfile', 'w+') #the size given is the # of (I think) accepted iterations that we #want in our final output file. BACON defaults this to 2000, so that's #what I'm using for now. Note the ability to tweak this value to #do quick-and-dirty vs. "good" models #minage & maxage are meant to indicate limits of calibration curves; #just giving really big #s there is okay. # progress_dialog.Update(2, "Running BACON Simulation") # int run_simulation(int numdets, PreCalDet** dets, int hdim, int numhiatus, # double* hdata, # int sections, double memorya, double memoryb, double minyr, double maxyr, # double firstguess, double secondguess, double mindepth, double maxdepth, # char* outfile, int numsamples) time_change = 30 computation_progress = PBI.PyBusyInfo("Please Be Patient. \n" + "Time Remaining: " + str(time_change), title="Runnning Computation") cfiles.baconc.run_simulation( len(data), [cfiles.baconc.PreCalDet(*sample) for sample in data], hiatusi, sections, memorya, memoryb, -1000, 1000000, guesses[0], guesses[1], mindepth, maxdepth, self.tempfile.name, num_iterations) # progress_dialog.Update(8, "Writing Data") #I should do something here to clip the undesired burn-in off the #front of the file (default ~200) #for now, doing a lazy haxx where I'm just taking the trivial mean #of each depth=point age and calling that the "model age" at that #depth. Lots of interesting stuff here; plz consult a real statistician reader = csv.reader(self.tempfile, dialect='excel-tab', skipinitialspace=True) truethick = float(maxdepth - mindepth) / sections sums = [0] * (sections + 1) total_info = [] depth = [mindepth + (truethick * i) for i in range(sections + 1)] total_info.append(depth) total = 0 for it in reader: if not it: continue path_ls = [0] * (sections + 1) total += 1 #as read by csv, the bacon output file has an empty entry as its #first column, so we ignore that. 1st real column is a special case, #a set value instead of accumulation cumage = float(it[1]) sums[0] += cumage #last 2 cols are not acc rates; they are "w" and "U"; currently #ignored, but related to it probability for ind, acc in enumerate(it[2:-2]): cumage += truethick * float(acc) sums[ind + 1] += cumage path_ls[ind + 1] += cumage total_info.append(path_ls) sums = [sum / total for sum in sums] self.tempfile.close() core.properties[ 'Bacon Model Uncertainty'] = datastructures.BaconInfo( total_info, core.partial_run.display_name) #TODO: are these depths fiddled with at all in the alg? should I make #sure to pass "pretty" ones? core.properties['Age/Depth Model'] = \ datastructures.PointlistInterpolation( [mindepth + truethick*ind for ind in range(len(sums))], sums, core.partial_run.display_name) #output file as I understand it: #something with hiatuses I need to work out. #some number of rows of n columns. the last column is (?) #the 1st column appears to be the "correct" age of the youngest #point in the core #following columns up to the last 2 cols, which I am ignoring, are the #accepted *accumulation rate (years per cm)* for that segment of the core. # progress_dialog.Update(9) del computation_progress