def test_get_min_max_lat_lon(self): site_container = cb.MagicDataFrame(dtype='sites') site_container.add_row('site1', { 'lat': 10, 'lon': 4, 'location': 'location1' }) site_container.add_row('site2', { 'lat': 10.2, 'lon': 5, 'location': 'location1' }) site_container.add_row('site3', { 'lat': 20, 'lon': '15', 'location': 'location2' }) site_container.add_row('site4', {'lat': None, 'location': 'location1'}) loc_container = cb.MagicDataFrame( dtype='locations', columns=['lat_n', 'lat_s', 'lon_e', 'lon_w', 'location']) site_container.df loc_container.add_row('location1', {}) loc_container.add_row('location2', {}) con = cb.Contribution(".", read_tables=['images']) con.tables['sites'] = site_container con.tables['locations'] = loc_container con.get_min_max_lat_lon() self.assertEqual(10., con.tables['locations'].df.loc['location1', 'lat_s']) self.assertEqual(15., con.tables['locations'].df.loc['location2', 'lon_e']) os.remove(os.path.join(".", "locations.txt"))
def test_delete_row(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) old_len = len(magic_df.df) magic_df.delete_row(5) self.assertEqual(old_len - 1, len(magic_df.df)) self.assertEqual('3', magic_df.df.iloc[5].name)
def test_all_to_str(self): directory = os.path.join(WD, 'data_files', '3_0', 'McMurdo') fname = os.path.join(directory, "sites.txt") sites = cb.MagicDataFrame(fname) sites.df.loc['mc01', 'age'] = 1.18003000000000001 sites.all_to_str() self.assertEqual('1.18003', sites.df.loc['mc01', 'age'].values[0])
def test_add_row(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) old_len = len(magic_df.df) magic_df.add_row('new_site', {'new_col': 'new_val'}) self.assertEqual('new_val', magic_df.df.iloc[-1]['new_col']) self.assertEqual(old_len + 1, len(magic_df.df))
def test_add_blank_row(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) old_len = len(magic_df.df) magic_df.add_blank_row('blank_site') self.assertIn('blank_site', magic_df.df.index) self.assertEqual(old_len + 1, len(magic_df.df))
def test_get_thellier_gui_meas_mapping(self): # MagIC 3 --> 2 with 'treat_step_num' meas_data3_0 = cb.MagicDataFrame(self.magic_file).df meas_data3_0.iloc[0, meas_data3_0.columns.get_loc('measurement')] = 'custom' meas_data2_5 = map_magic.convert_meas_df_thellier_gui(meas_data3_0, output=2) self.assertEqual('custom', meas_data2_5.iloc[0, meas_data2_5.columns.get_loc('measurement')]) self.assertEqual(1, meas_data2_5.iloc[0, meas_data2_5.columns.get_loc('measurement_number')]) # and back meas_data3_again = map_magic.convert_meas_df_thellier_gui(meas_data2_5, output=3) self.assertEqual('custom', meas_data3_again.iloc[0, meas_data3_again.columns.get_loc('measurement')]) self.assertEqual(1, meas_data3_again.iloc[0, meas_data3_again.columns.get_loc('treat_step_num')]) # MagIC 3 --> 2 without 'treat_step_num' del meas_data3_0['treat_step_num'] self.assertEqual('custom', meas_data3_0.iloc[0, meas_data3_0.columns.get_loc('measurement')]) meas_data2_5 = map_magic.convert_meas_df_thellier_gui(meas_data3_0, output=2) self.assertIn('measurement_number', meas_data2_5.columns) self.assertEqual('custom', meas_data2_5.iloc[0, meas_data2_5.columns.get_loc('measurement')]) self.assertEqual('custom', meas_data2_5.iloc[0, meas_data2_5.columns.get_loc('measurement_number')]) # and back to 3 meas_data3_0_again = map_magic.convert_meas_df_thellier_gui(meas_data2_5, output=3) self.assertEqual('custom', meas_data3_0_again.iloc[0, meas_data2_5.columns.get_loc('measurement')]) self.assertNotIn('treat_step_num', meas_data3_0_again.columns)
def test_meas_dataframe(self): meas_file = os.path.join(WD, "data_files", "3_0", "McMurdo", "measurements.txt") df = pd.read_table(meas_file, skiprows=[0]) self.assertNotIn('sequence', df.columns) magic_df = cb.MagicDataFrame(meas_file) self.assertIn('sequence', magic_df.df.columns)
def test_get_first_non_null_value(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) res = magic_df.get_first_non_null_value('1', 'bed_dip_direction') self.assertEqual(135, res) magic_df.df.loc['1', 'bed_dip_direction'] = None res = magic_df.get_first_non_null_value('1', 'bed_dip_direction') self.assertTrue(pd.isnull(res))
def test_delete_rows(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) cond = magic_df.df['description'].str.contains('VGP').astype(bool) # delete all rows that aren't described as VGPs magic_df.delete_rows(-cond) for descr in magic_df.df['description'].values: self.assertTrue('VGP' in descr)
def test_update_record(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) cond = magic_df.df['lithologies'] == 'Basalt' magic_df.update_record('2', new_data={'description': 'updated'}, condition=cond) self.assertIn('updated', magic_df.df.loc['2', 'description'].values)
def test_sites_only_propagation(self): """ Make sure propagation works correclty with limited tables provided """ directory = os.path.join(WD, 'data_files', '3_0', 'McMurdo') con = cb.Contribution(directory, dmodel=DMODEL, read_tables=['sites'], custom_filenames={ 'locations': '_locations.txt', 'samples': '_samples.txt' }) self.assertEqual(['sites'], list(con.tables.keys())) con.propagate_all_tables_info() self.assertEqual(sorted(['samples', 'sites', 'locations']), sorted(con.tables.keys())) for fname in ['_locations.txt', '_samples.txt']: os.remove(os.path.join(directory, fname)) # con = cb.Contribution(directory, dmodel=DMODEL, read_tables=['sites'], custom_filenames={ 'locations': '_locations.txt', 'samples': '_samples.txt' }) samp_df = pd.DataFrame(index=['mc01b'], columns=['sample', 'site'], data=[['mc01b', 'fake site']]) samp_df = cb.MagicDataFrame(dtype='samples', df=samp_df) con.tables['samples'] = samp_df self.assertEqual('fake site', con.tables['samples'].df.loc['mc01b', 'site']) con.propagate_all_tables_info() self.assertEqual(sorted(['samples', 'sites', 'locations']), sorted(con.tables.keys())) # mc01b does not update b/c sample_df value trumps value from sites table self.assertEqual('fake site', con.tables['samples'].df.loc['mc01b', 'site']) # however, additional samples should be added self.assertIn('mc01d', con.tables['samples'].df.index) for fname in ['_locations.txt', '_samples.txt']: os.remove(os.path.join(directory, fname)) # con = cb.Contribution(self.directory, dmodel=DMODEL, read_tables=['sites'], custom_filenames={ 'locations': '_locations.txt', 'samples': '_samples.txt' }) self.assertEqual(['sites'], list(con.tables.keys())) con.propagate_all_tables_info() self.assertEqual(sorted(['sites', 'locations']), sorted(con.tables.keys())) for fname in ['_locations.txt']: # no samples available this time os.remove(os.path.join(self.directory, fname))
def test_get_name(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) val = magic_df.get_name('description') self.assertEqual('VGP:Site 1', val) df_slice = magic_df.df.iloc[10:20] val = magic_df.get_name('description', df_slice) self.assertEqual('VGP:Site 4', val) index_names = ['21', '22'] val = magic_df.get_name('description', index_names=index_names) self.assertEqual('VGP:Site 21', val)
def test_update_row(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) self.assertEqual('Lava Flow', magic_df.df.iloc[3]['geologic_types']) magic_df.update_row(3, { 'geologic_types': 'other type', 'new_col': 'new_val' }) self.assertEqual('other type', magic_df.df.iloc[3]['geologic_types']) self.assertIn('new_col', magic_df.df.columns) self.assertEqual('new_val', magic_df.df.iloc[3]['new_col'])
def test_atrm_success(self): res, outfile = ipmag.atrm_magic( 'atrm_measurements3.txt', self.atrm_WD, input_spec_file='orig_specimens.txt', output_spec_file='custom_specimens.txt') self.assertTrue(res) self.assertEqual(outfile, os.path.join(self.atrm_WD, 'custom_specimens.txt')) # check that samples are there from input specimen file df = cb.MagicDataFrame(outfile) self.assertTrue(any(df.df['sample']))
def test_convert_to_pmag_data_list(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) lst = magic_df.convert_to_pmag_data_list('lst') self.assertEqual(list, type(lst)) self.assertEqual(dict, type(lst[0])) self.assertEqual('1', str(lst[0]['site'])) # dct = magic_df.convert_to_pmag_data_list("dict") self.assertEqual(dict, type(dct)) self.assertEqual(dict, type(dct[list(dct.keys())[0]])) self.assertEqual('1', str(dct['1']['site']))
def test_init_with_data(self): data = [{ 'specimen': 'spec1', 'sample': 'samp1' }, { 'specimen': 'spec2', 'sample': 'samp2' }] magic_df = cb.MagicDataFrame(dtype='specimens', data=data) self.assertEqual(len(magic_df.df), 2) self.assertEqual(magic_df.dtype, 'specimens') self.assertEqual('specimen name', magic_df.df.index.name) self.assertEqual(['spec1', 'spec2'], sorted(magic_df.df.index))
def test_front_and_backfill(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) directions = magic_df.df.loc['1', 'bed_dip_direction'] self.assertEqual( sorted(directions, key=lambda x, y=0: int(x - y) if (isinstance(x, float) or isinstance(x, int)) and (isinstance(y, float) or isinstance(y, int)) else -1), [None, 135, 135]) magic_df.front_and_backfill(cols=['bed_dip_direction']) directions = magic_df.df.loc['1', 'bed_dip_direction'] self.assertEqual(sorted(directions), [135, 135, 135])
def test_drop_stub_rows(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) self.assertEqual(3, len(magic_df.df.loc['1'])) magic_df.add_row('1', {'site': '1', 'location': 'new_loc'}) magic_df.add_row('1', { 'site': '1', 'location': 'new_loc', 'citations': 'real citation' }) self.assertEqual(5, len(magic_df.df.loc['1'])) magic_df.drop_stub_rows(['site', 'location']) self.assertEqual(4, len(magic_df.df.loc['1']))
def test_get_di_block(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) di_block = magic_df.get_di_block(df_slice='all') self.assertEqual([289.8, 43.6], di_block[0]) di_block = magic_df.get_di_block(do_index=True, item_names=['1', '2']) self.assertEqual([289.8, 43.6], di_block[0]) self.assertEqual(4, len(di_block)) magic_df.df.loc['2', 'method_codes'] = 'fake_code' di_block = magic_df.get_di_block(do_index=True, item_names=['1', '2'], excl=['fake_code']) self.assertEqual(2, len(di_block))
def __init__(self, WD, parent, contribution=None): SIZE = wx.DisplaySize() SIZE = (SIZE[0] * .95, SIZE[1] * .95) wx.Frame.__init__(self, parent, wx.ID_ANY, size=SIZE, name='ErMagicBuilder') self.parent = parent self.main_frame = self.Parent self.panel = wx.ScrolledWindow(self) self.panel.SetScrollbars(1, 1, 1, 1) if sys.platform in ['win32', 'win64']: self.panel.SetScrollbars(20, 20, 50, 50) os.chdir(WD) self.WD = os.getcwd() self.site_lons = [] self.site_lats = [] # if ErMagic data object was not passed in, # create one based on the working directory if not contribution: self.contribution = cb.Contribution(self.WD) else: self.contribution = contribution # first propagate from measurements self.contribution.propagate_measurement_info() # then propagate from other tables # (i.e., if sites are in specimens or samples but not measurements) self.contribution.propagate_all_tables_info() # then add in blank tables if any are missing self.table_list = [ "specimens", "samples", "sites", "locations", "ages" ] for table in self.table_list: if table not in self.contribution.tables: new_table = cb.MagicDataFrame( dtype=table, dmodel=self.contribution.data_model) self.contribution.tables[table] = new_table self.SetTitle("Earth-Ref Magic Builder") self.InitUI() # hide mainframe, bind close event so that it closes the current window not the mainframe self.parent.Hide() self.parent.Bind( wx.EVT_MENU, lambda event: self.parent.menubar.on_quit(event, self), self.parent.menubar.file_quit)
def test_get_records_for_code(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) results = magic_df.get_records_for_code('LP-DC2') self.assertEqual(87, len(results)) # magic_df.df.loc['1', 'method_codes'] = 'LP-NEW' results = magic_df.get_records_for_code('LP', strict_match=False) self.assertEqual(89, len(results)) # df_slice = magic_df.df.head() results = magic_df.get_records_for_code('LP-DC2', use_slice=True, sli=df_slice) self.assertEqual(1, len(results))
def test_with_numeric_measurement_name(self): # set up meas df with numeric measurement names meas_data3 = cb.MagicDataFrame(self.magic_file).df del meas_data3['treat_step_num'] meas_names = range(1001, len(meas_data3) + 1001) meas_data3['measurement'] = meas_names # convert from MagIC 3 --> MagIC 2.5 meas_data2 = map_magic.convert_meas_df_thellier_gui(meas_data3, output=2) self.assertEqual(1001, meas_data2.iloc[0, meas_data2.columns.get_loc('measurement')]) self.assertEqual(1001, meas_data2.iloc[0, meas_data2.columns.get_loc('measurement_number')]) # and back meas_data3_again = map_magic.convert_meas_df_thellier_gui(meas_data2, output=3) self.assertNotIn('treat_step_num', meas_data3_again.columns) self.assertEqual(1001, meas_data3_again.iloc[0, meas_data3_again.columns.get_loc('measurement')])
def test_convert_to_pmag_list(self): # np.nan and None should both be converted to a string directory = os.path.join(WD, 'data_files', '3_0', 'Megiddo') fname = os.path.join(directory, "sites.txt") df = cb.MagicDataFrame(fname) df.df.loc['mgq04t1', 'age_high'] = np.nan df.df.loc['mgq04t1', 'age_low'] = None for val in df.df.loc['mgq04t1', 'age_high'].values: self.assertTrue(np.isnan(val)) for val in df.df.loc['mgq04t1', 'age_low'].values: self.assertTrue(val is None) lst = df.convert_to_pmag_data_list() relevant_lst = pmag.get_dictitem(lst, 'site', 'mgq04t1', 'T') # make sure np.nan/None values are converted to '' for i in relevant_lst: self.assertEqual(i['age_high'], '') self.assertEqual(i['age_low'], '') # make sure numeric values are string-i-fied self.assertEqual(str, type(relevant_lst[0]['age']))
def main(): """ NAME make_magic_plots.py DESCRIPTION inspects magic directory for available data and makes plots SYNTAX make_magic_plots.py [command line options] INPUT magic files OPTIONS -h prints help message and quits -f FILE specifies input file name -fmt [png,eps,svg,jpg,pdf] specify format, default is png """ if '-h' in sys.argv: print(main.__doc__) sys.exit() # reset log files for fname in ['log.txt', 'errors.txt']: f = os.path.join(os.getcwd(), fname) if os.path.exists(f): os.remove(f) image_recs = [] dirlist = ['./'] dir_path = os.getcwd() # if '-fmt' in sys.argv: ind = sys.argv.index("-fmt") fmt = sys.argv[ind + 1] else: fmt = 'png' if '-f' in sys.argv: ind = sys.argv.index("-f") filelist = [sys.argv[ind + 1]] else: filelist = os.listdir(dir_path) ## initialize some variables samp_file = 'samples.txt' meas_file = 'measurements.txt' #loc_key = 'location' loc_file = 'locations.txt' method_key = 'method_codes' dec_key = 'dir_dec' inc_key = 'dir_inc' tilt_corr_key = "dir_tilt_correction" aniso_tilt_corr_key = "aniso_tilt_correction" hyst_bcr_key = "hyst_bcr" hyst_mr_key = "hyst_mr_moment" hyst_ms_key = "hyst_ms_moment" hyst_bc_key = "hyst_bc" Mkeys = ['magnitude', 'magn_moment', 'magn_volume', 'magn_mass'] results_file = 'sites.txt' hyst_file = 'specimens.txt' aniso_file = 'specimens.txt' # create contribution and propagate data throughout full_con = cb.Contribution() full_con.propagate_location_to_measurements() full_con.propagate_location_to_specimens() full_con.propagate_location_to_samples() if not full_con.tables: print('-E- No MagIC tables could be found in this directory') error_log("No MagIC tables found") return # try to get the contribution id for error logging con_id = "" if 'contribution' in full_con.tables: if 'id' in full_con.tables['contribution'].df.columns: con_id = full_con.tables['contribution'].df.iloc[0]['id'] # check to see if propagation worked, otherwise you can't plot by location lowest_table = None for table in full_con.ancestry: if table in full_con.tables: lowest_table = table break do_full_directory = False # check that locations propagated down to the lowest table in the contribution if 'location' in full_con.tables[lowest_table].df.columns: if 'locations' not in full_con.tables: info_log( 'location names propagated to {}, but could not be validated'. format(lowest_table)) # are there any locations in the lowest table? elif not all(full_con.tables[lowest_table].df['location'].isnull()): locs = full_con.tables['locations'].df.index.unique() lowest_locs = full_con.tables[lowest_table].df['location'].unique() incorrect_locs = set(lowest_locs).difference(set(locs)) # are they actual locations? if not incorrect_locs: info_log( 'location names propagated to {}'.format(lowest_table)) else: do_full_directory = True error_log( 'location names did not propagate fully to {} table (looks like there are some naming inconsistencies between tables)' .format(lowest_table), con_id=con_id) else: do_full_directory = True error_log( 'could not propagate location names down to {} table'.format( lowest_table), con_id=con_id) else: do_full_directory = True error_log('could not propagate location names down to {} table'.format( lowest_table), con_id=con_id) all_data = {} all_data['measurements'] = full_con.tables.get('measurements', None) all_data['specimens'] = full_con.tables.get('specimens', None) all_data['samples'] = full_con.tables.get('samples', None) all_data['sites'] = full_con.tables.get('sites', None) all_data['locations'] = full_con.tables.get('locations', None) if 'locations' in full_con.tables: locations = full_con.tables['locations'].df.index.unique() else: locations = [''] dirlist = [ loc for loc in locations if cb.not_null(loc, False) and loc != 'nan' ] if not dirlist: dirlist = ["./"] if do_full_directory: dirlist = ["./"] # plot the whole contribution as one location if dirlist == ["./"]: error_log('plotting the entire contribution as one location', con_id=con_id) for fname in os.listdir("."): if fname.endswith(".txt"): shutil.copy(fname, "tmp_" + fname) # if possible, go through all data by location # use tmp_*.txt files to separate out by location for loc in dirlist: print('\nworking on: ', loc) def get_data(dtype, loc_name): """ Extract data of type dtype for location loc_name. Write tmp_dtype.txt files if possible. """ if cb.not_null(all_data[dtype], False): data_container = all_data[dtype] if loc_name == "./": data_df = data_container.df else: # awkward workaround for chars like "(" and "?" that break in regex try: data_df = data_container.df[data_container.df[ 'location'].astype(str).str.contains(loc_name, na=False)] except: #sre_constants.error: data_df = data_container.df[ data_container.df['location'] == loc_name] data = data_container.convert_to_pmag_data_list(df=data_df) res = data_container.write_magic_file( 'tmp_{}.txt'.format(dtype), df=data_df) if not res: return [], [] return data, data_df return [], [] meas_data, meas_df = get_data('measurements', loc) spec_data, spec_df = get_data('specimens', loc) samp_data, samp_df = get_data('samples', loc) site_data, site_df = get_data('sites', loc) loc_data, loc_df = get_data('locations', loc) con = cb.Contribution(read_tables=[]) con.tables['measurements'] = cb.MagicDataFrame(df=meas_df, dtype="measurements") con.tables['specimens'] = cb.MagicDataFrame(df=spec_df, dtype="specimens") con.tables['samples'] = cb.MagicDataFrame(df=samp_df, dtype="samples") con.tables['sites'] = cb.MagicDataFrame(df=site_df, dtype="sites") con.tables['locations'] = cb.MagicDataFrame(df=loc_df, dtype="locations") if loc == "./": # if you can't sort by location, do everything together con = full_con try: meas_data = con.tables[ 'measurements'].convert_to_pmag_data_list() except KeyError: meas_data = None try: spec_data = con.tables['specimens'].convert_to_pmag_data_list() except KeyError: spec_data = None try: samp_data = con.tables['samples'].convert_to_pmag_data_list() except KeyError: samp_data = None try: site_data = con.tables['sites'].convert_to_pmag_data_list() except KeyError: site_data = None crd = 's' if 'samples' in con.tables: if 'azimuth' in con.tables['samples'].df.columns: if any(con.tables['samples'].df['azimuth'].dropna()): crd = 'g' if crd == 's': print('using specimen coordinates') else: print('using geographic coordinates') if meas_file in filelist and meas_data: # start with measurement data print('working on plotting measurements data') data = meas_data file_type = 'measurements' # looking for zeq_magic possibilities # get all non blank method codes AFZrecs = pmag.get_dictitem(data, method_key, 'LT-AF-Z', 'has') # get all non blank method codes TZrecs = pmag.get_dictitem(data, method_key, 'LT-T-Z', 'has') # get all non blank method codes MZrecs = pmag.get_dictitem(data, method_key, 'LT-M-Z', 'has') # get all dec measurements Drecs = pmag.get_dictitem(data, dec_key, '', 'F') # get all inc measurements Irecs = pmag.get_dictitem(data, inc_key, '', 'F') for key in Mkeys: Mrecs = pmag.get_dictitem(data, key, '', 'F') # get intensity data if len(Mrecs) > 0: break # potential for stepwise demag curves if len(AFZrecs) > 0 or len(TZrecs) > 0 or len(MZrecs) > 0 and len( Drecs) > 0 and len(Irecs) > 0 and len(Mrecs) > 0: #CMD = 'zeq_magic.py -f tmp_measurements.txt -fsp tmp_specimens.txt -fsa tmp_samples.txt -fsi tmp_sites.txt -sav -fmt ' + fmt + ' -crd ' + crd + " -new" CMD = "ipmag.zeq_magic(crd={}, n_plots='all', contribution={}, image_records=True)".format( crd, con) print(CMD) info_log(CMD, loc) res, outfiles, zeq_images = ipmag.zeq_magic(crd=crd, n_plots='all', contribution=con, image_records=True) image_recs.extend(zeq_images) # looking for thellier_magic possibilities if len(pmag.get_dictitem(data, method_key, 'LP-PI-TRM', 'has')) > 0: #CMD = 'thellier_magic.py -f tmp_measurements.txt -fsp tmp_specimens.txt -sav -fmt ' + fmt CMD = "ipmag.thellier_magic(n_specs='all', fmt='png', contribution={}, image_records=True)".format( con) print(CMD) info_log(CMD, loc) res, outfiles, thellier_images = ipmag.thellier_magic( n_specs='all', fmt="png", contribution=con, image_records=True) image_recs.extend(thellier_images) # looking for hysteresis possibilities if len(pmag.get_dictitem(data, method_key, 'LP-HYS', 'has')) > 0: # find hyst experiments # check for reqd columns missing = check_for_reqd_cols(data, ['treat_temp']) if missing: error_log( 'LP-HYS method code present, but required column(s) [{}] missing' .format(", ".join(missing)), loc, "quick_hyst.py", con_id=con_id) else: #CMD = 'quick_hyst.py -f tmp_measurements.txt -sav -fmt ' + fmt CMD = "ipmag.quick_hyst(fmt='png', n_plots='all', contribution={}, image_records=True)".format( con) print(CMD) info_log(CMD, loc) res, outfiles, quick_hyst_recs = ipmag.quick_hyst( fmt="png", n_plots='all', contribution=con, image_records=True) image_recs.extend(quick_hyst_recs) # equal area plots of directional data # at measurement level (by specimen) if data: missing = check_for_reqd_cols(data, ['dir_dec', 'dir_inc']) if not missing: #CMD = "eqarea_magic.py -f tmp_measurements.txt -obj spc -sav -no-tilt -fmt " + fmt CMD = "ipmag.eqarea_magic(fmt='png', n_plots='all', ignore_tilt=True, plot_by='spc', contribution={}, source_table='measurements', image_records=True)".format( con) print(CMD) info_log(CMD, loc, "eqarea_magic.py") res, outfiles, eqarea_spc_images = ipmag.eqarea_magic( fmt="png", n_plots='all', ignore_tilt=True, plot_by="spc", contribution=con, source_table="measurements", image_records=True) image_recs.extend(eqarea_spc_images) else: if VERBOSE: print('-I- No measurement data found') # site data if results_file in filelist and site_data: print('-I- result file found', results_file) data = site_data file_type = 'sites' print('-I- working on site directions') print('number of datapoints: ', len(data), loc) dec_key = 'dir_dec' inc_key = 'dir_inc' int_key = 'int_abs' SiteDIs = pmag.get_dictitem(data, dec_key, "", 'F') # find decs SiteDIs = pmag.get_dictitem(SiteDIs, inc_key, "", 'F') # find decs and incs dir_data_found = len(SiteDIs) print('{} Dec/inc pairs found'.format(dir_data_found)) if SiteDIs: # then convert tilt_corr_key to correct format old_SiteDIs = SiteDIs SiteDIs = [] for rec in old_SiteDIs: if tilt_corr_key not in rec: rec[tilt_corr_key] = "0" # make sure tilt_corr_key is a correct format try: rec[tilt_corr_key] = str(int(float( rec[tilt_corr_key]))) except ValueError: rec[tilt_corr_key] = "0" SiteDIs.append(rec) print('number of individual directions: ', len(SiteDIs)) # tilt corrected coordinates SiteDIs_t = pmag.get_dictitem(SiteDIs, tilt_corr_key, '100', 'T', float_to_int=True) print('number of tilt corrected directions: ', len(SiteDIs_t)) SiteDIs_g = pmag.get_dictitem( SiteDIs, tilt_corr_key, '0', 'T', float_to_int=True) # geographic coordinates print('number of geographic directions: ', len(SiteDIs_g)) SiteDIs_s = pmag.get_dictitem( SiteDIs, tilt_corr_key, '-1', 'T', float_to_int=True) # sample coordinates print('number of sample directions: ', len(SiteDIs_s)) SiteDIs_x = pmag.get_dictitem(SiteDIs, tilt_corr_key, '', 'T') # no coordinates print('number of no coordinates directions: ', len(SiteDIs_x)) if len(SiteDIs_t) > 0 or len(SiteDIs_g) > 0 or len( SiteDIs_s) > 0 or len(SiteDIs_x) > 0: CRD = "" if len(SiteDIs_t) > 0: CRD = ' -crd t' crd = "t" elif len(SiteDIs_g) > 0: CRD = ' -crd g' crd = "g" elif len(SiteDIs_s) > 0: CRD = ' -crd s' crd = "s" #CMD = 'eqarea_magic.py -f tmp_sites.txt -fsp tmp_specimens.txt -fsa tmp_samples.txt -flo tmp_locations.txt -sav -fmt ' + fmt + CRD CMD = "ipmag.eqarea_magic(crd={}, fmt='png', n_plots='all', contribution={}, source_table='sites')".format( crd, con) print(CMD) info_log(CMD, loc) res, outfiles, eqarea_site_recs = ipmag.eqarea_magic( crd=crd, fmt="png", n_plots='all', contribution=con, source_table="sites", image_records=True) image_recs.extend(eqarea_site_recs) else: if dir_data_found: error_log( '{} dec/inc pairs found, but no equal area plots were made' .format(dir_data_found), loc, "equarea_magic.py", con_id=con_id) # print('-I- working on VGP map') VGPs = pmag.get_dictitem(SiteDIs, 'vgp_lat', "", 'F') # are there any VGPs? if len(VGPs) > 0: # YES! #CMD = 'vgpmap_magic.py -f tmp_sites.txt -prj moll -res c -sym ro 5 -sav -fmt png' CMD = "ipmag.vgpmap_magic(proj='moll', sym='ro', size=5, fmt='png', contribution={})".format( con) print(CMD) info_log(CMD, loc, 'vgpmap_magic.py') res, outfiles, vgpmap_recs = ipmag.vgpmap_magic( proj='moll', sym='ro', size=5, fmt="png", contribution=con, image_records=True) image_recs.extend(vgpmap_recs) else: print('-I- No vgps found') print('-I- Look for intensities') # is there any intensity data? if site_data: if int_key in site_data[0].keys(): # old way, wasn't working right: #CMD = 'magic_select.py -key ' + int_key + ' 0. has -F tmp1.txt -f tmp_sites.txt' Selection = pmag.get_dictkey(site_data, int_key, dtype="f") selection = [i * 1e6 for i in Selection if i != 0] loc = loc.replace(" ", "_") if loc == "./": loc_name = "" else: loc_name = loc histfile = 'LO:_' + loc_name + \ '_TY:_intensities_histogram:_.' + fmt CMD = "histplot.py -twin -b 1 -xlab 'Intensity (uT)' -sav -f intensities.txt -F " + histfile CMD = "ipmag.histplot(data=selection, outfile=histfile, xlab='Intensity (uT)', binsize=1, norm=-1, save_plots=True)".format( histfile) info_log(CMD, loc) print(CMD) ipmag.histplot(data=selection, outfile=histfile, xlab="Intensity (uT)", binsize=1, norm=-1, save_plots=True) histplot_rec = { 'file': histfile, 'type': 'Other', 'title': 'Intensity histogram', 'software_packages': version.version, 'keywords': "", 'timestamp': datetime.date.today().isoformat() } image_recs.append(histplot_rec) else: print('-I- No intensities found') else: print('-I- No intensities found') ## if hyst_file in filelist and spec_data: print('working on hysteresis', hyst_file) data = spec_data file_type = 'specimens' hdata = pmag.get_dictitem(data, hyst_bcr_key, '', 'F') hdata = pmag.get_dictitem(hdata, hyst_mr_key, '', 'F') hdata = pmag.get_dictitem(hdata, hyst_ms_key, '', 'F') # there are data for a dayplot hdata = pmag.get_dictitem(hdata, hyst_bc_key, '', 'F') if len(hdata) > 0: CMD = "ipmag.dayplot_magic(save=True, fmt='png', contribution={}, image_records=True)".format( con) info_log(CMD, loc) print(CMD) res, outfiles, dayplot_recs = ipmag.dayplot_magic( save=True, fmt='png', contribution=con, image_records=True) image_recs.extend(dayplot_recs) else: print('no hysteresis data found') if aniso_file in filelist and spec_data: # do anisotropy plots if possible print('working on anisotropy', aniso_file) data = spec_data file_type = 'specimens' # make sure there is some anisotropy data if not data: print('No anisotropy data found') elif 'aniso_s' not in data[0]: print('No anisotropy data found') else: # get specimen coordinates if aniso_tilt_corr_key not in data[0]: sdata = data else: sdata = pmag.get_dictitem(data, aniso_tilt_corr_key, '-1', 'T', float_to_int=True) # get specimen coordinates gdata = pmag.get_dictitem(data, aniso_tilt_corr_key, '0', 'T', float_to_int=True) # get specimen coordinates tdata = pmag.get_dictitem(data, aniso_tilt_corr_key, '100', 'T', float_to_int=True) if len(sdata) > 3: CMD = "ipmag.aniso_magic(iboot=0, ihext=1, crd='s', fmt='png', contribution={})".format( con) print(CMD) info_log(CMD, loc) res, files, aniso_recs = ipmag.aniso_magic( iboot=0, ihext=1, crd="s", fmt="png", contribution=con, image_records=True) image_recs.extend(aniso_recs) if len(gdata) > 3: CMD = "ipmag.aniso_magic(iboot=0, ihext=1, crd='g', fmt='png', contribution={})".format( con) print(CMD) info_log(CMD, loc) res, files, aniso_recs = ipmag.aniso_magic( iboot=0, ihext=1, crd="g", fmt="png", contribution=con, image_records=True) image_recs.extend(aniso_recs) if len(tdata) > 3: CMD = "ipmag.aniso_magic(iboot=0, ihext=1, crd='g', fmt='png', contribution={})".format( con) print(CMD) info_log(CMD, loc) res, files, aniso_recs = ipmag.aniso_magic( iboot=0, ihext=1, crd="t", fmt="png", contribution=con, image_records=True) image_recs.extend(aniso_recs) # remove temporary files for fname in glob.glob('tmp*.txt'): os.remove(fname) # now we need full contribution data if loc_file in filelist and loc_data: #data, file_type = pmag.magic_read(loc_file) # read in location data data = loc_data print('-I- working on pole map') poles = pmag.get_dictitem(data, 'pole_lat', "", 'F') # are there any poles? poles = pmag.get_dictitem(poles, 'pole_lon', "", 'F') # are there any poles? if len(poles) > 0: # YES! CMD = 'polemap_magic.py -sav -fmt png -rev gv 40' CMD = 'ipmag.polemap_magic(flip=True, rsym="gv", rsymsize=40, fmt="png", contribution={})'.format( full_con) print(CMD) info_log(CMD, "all locations", "polemap_magic.py") res, outfiles, polemap_recs = ipmag.polemap_magic( flip=True, rsym="gv", rsymsize=40, fmt="png", contribution=full_con, image_records=True) image_recs.extend(polemap_recs) else: print('-I- No poles found') if image_recs: new_image_file = os.path.join(dir_path, 'new_images.txt') old_image_file = os.path.join(dir_path, 'images.txt') pmag.magic_write(new_image_file, image_recs, 'images') if os.path.exists(old_image_file): ipmag.combine_magic([old_image_file, new_image_file], outfile=old_image_file, magic_table="images", dir_path=dir_path) else: os.rename(new_image_file, old_image_file) if set_env.isServer: thumbnails.make_thumbnails(dir_path)
def main(): """ NAME zeq_magic.py DESCRIPTION reads in magic_measurements formatted file, makes plots of remanence decay during demagnetization experiments. Reads in prior interpretations saved in a pmag_specimens formatted file [and allows re-interpretations of best-fit lines and planes and saves (revised or new) interpretations in a pmag_specimens file. interpretations are saved in the coordinate system used. Also allows judicious editting of measurements to eliminate "bad" measurements. These are marked as such in the magic_measurements input file. they are NOT deleted, just ignored. ] Bracketed part not yet implemented SYNTAX zeq_magic.py [command line options] OPTIONS -h prints help message and quits -f MEASFILE: sets measurements format input file, default: measurements.txt -fsp SPECFILE: sets specimens format file with prior interpreations, default: specimens.txt -fsa SAMPFILE: sets samples format file sample=>site information, default: samples.txt -fsi SITEFILE: sets sites format file with site=>location informationprior interpreations, default: samples.txt -Fp PLTFILE: sets filename for saved plot, default is name_type.fmt (where type is zijd, eqarea or decay curve) -crd [s,g,t]: sets coordinate system, g=geographic, t=tilt adjusted, default: specimen coordinate system -spc SPEC plots single specimen SPEC, saves plot with specified format with optional -dir settings and quits -dir [L,P,F][beg][end]: sets calculation type for principal component analysis, default is none beg: starting step for PCA calculation end: ending step for PCA calculation [L,P,F]: calculation type for line, plane or fisher mean must be used with -spc option -fmt FMT: set format of saved plot [png,svg,jpg] -A: suppresses averaging of replicate measurements, default is to average -sav: saves all plots without review SCREEN OUTPUT: Specimen, N, a95, StepMin, StepMax, Dec, Inc, calculation type """ # initialize some variables doave, e, b = 1, 0, 0 # average replicates, initial end and beginning step intlist = ['magn_moment', 'magn_volume', 'magn_mass', 'magnitude'] plots, coord = 0, 's' noorient = 0 version_num = pmag.get_version() verbose = pmagplotlib.verbose calculation_type, fmt = "", "svg" spec_keys = [] geo, tilt, ask = 0, 0, 0 PriorRecs = [] # empty list for prior interpretations backup = 0 specimen = "" # can skip everything and just plot one specimen with bounds e,b if '-h' in sys.argv: print(main.__doc__) sys.exit() dir_path = pmag.get_named_arg("-WD", default_val=os.getcwd()) meas_file = pmag.get_named_arg("-f", default_val="measurements.txt") spec_file = pmag.get_named_arg("-fsp", default_val="specimens.txt") samp_file = pmag.get_named_arg("-fsa", default_val="samples.txt") site_file = pmag.get_named_arg("-fsi", default_val="sites.txt") #meas_file = os.path.join(dir_path, meas_file) #spec_file = os.path.join(dir_path, spec_file) #samp_file = os.path.join(dir_path, samp_file) #site_file = os.path.join(dir_path, site_file) plot_file = pmag.get_named_arg("-Fp", default_val="") crd = pmag.get_named_arg("-crd", default_val="s") if crd == "s": coord = "-1" elif crd == "t": coord = "100" else: coord = "0" saved_coord = coord fmt = pmag.get_named_arg("-fmt", "svg") specimen = pmag.get_named_arg("-spc", default_val="") #if specimen: # just save plot and exit # plots, verbose = 1, 0 beg_pca, end_pca = "", "" if '-dir' in sys.argv: ind = sys.argv.index('-dir') direction_type = sys.argv[ind + 1] beg_pca = int(sys.argv[ind + 2]) end_pca = int(sys.argv[ind + 3]) if direction_type == 'L': calculation_type = 'DE-BFL' if direction_type == 'P': calculation_type = 'DE-BFP' if direction_type == 'F': calculation_type = 'DE-FM' if '-A' in sys.argv: doave = 0 if '-sav' in sys.argv: plots, verbose = 1, 0 # first_save = 1 fnames = { 'measurements': meas_file, 'specimens': spec_file, 'samples': samp_file, 'sites': site_file } contribution = cb.Contribution( dir_path, custom_filenames=fnames, read_tables=['measurements', 'specimens', 'samples', 'sites']) # # import specimens if 'measurements' not in contribution.tables: print('-W- No measurements table found in your working directory') return specimen_cols = [ 'analysts', 'aniso_ftest', 'aniso_ftest12', 'aniso_ftest23', 'aniso_s', 'aniso_s_mean', 'aniso_s_n_measurements', 'aniso_s_sigma', 'aniso_s_unit', 'aniso_tilt_correction', 'aniso_type', 'aniso_v1', 'aniso_v2', 'aniso_v3', 'citations', 'description', 'dir_alpha95', 'dir_comp', 'dir_dec', 'dir_inc', 'dir_mad_free', 'dir_n_measurements', 'dir_tilt_correction', 'experiments', 'geologic_classes', 'geologic_types', 'hyst_bc', 'hyst_bcr', 'hyst_mr_moment', 'hyst_ms_moment', 'int_abs', 'int_b', 'int_b_beta', 'int_b_sigma', 'int_corr', 'int_dang', 'int_drats', 'int_f', 'int_fvds', 'int_gamma', 'int_mad_free', 'int_md', 'int_n_measurements', 'int_n_ptrm', 'int_q', 'int_rsc', 'int_treat_dc_field', 'lithologies', 'meas_step_max', 'meas_step_min', 'meas_step_unit', 'method_codes', 'sample', 'software_packages', 'specimen' ] if 'specimens' in contribution.tables: contribution.propagate_name_down('sample', 'measurements') # add location/site info to measurements table for naming plots if pmagplotlib.isServer: contribution.propagate_name_down('site', 'measurements') contribution.propagate_name_down('location', 'measurements') spec_container = contribution.tables['specimens'] if 'method_codes' not in spec_container.df.columns: spec_container.df['method_codes'] = None prior_spec_data = spec_container.get_records_for_code( 'LP-DIR', strict_match=False ) # look up all prior directional interpretations # # tie sample names to measurement data # else: spec_container, prior_spec_data = None, [] # # import samples for orientation info # if 'samples' in contribution.tables: samp_container = contribution.tables['samples'] samps = samp_container.df samp_data = samps.to_dict( 'records' ) # convert to list of dictionaries for use with get_orient else: samp_data = [] #if ('samples' in contribution.tables) and ('specimens' in contribution.tables): # # contribution.propagate_name_down('site','measurements') # contribution.propagate_cols(col_names=[ # 'azimuth', 'dip', 'orientation_quality','bed_dip','bed_dip_direction'], target_df_name='measurements', source_df_name='samples') ## # define figure numbers for equal area, zijderveld, # and intensity vs. demagnetiztion step respectively # ZED = {} ZED['eqarea'], ZED['zijd'], ZED['demag'] = 1, 2, 3 pmagplotlib.plot_init(ZED['eqarea'], 6, 6) pmagplotlib.plot_init(ZED['zijd'], 6, 6) pmagplotlib.plot_init(ZED['demag'], 6, 6) # save_pca=0 angle, direction_type, setangle = "", "", 0 # create measurement dataframe # meas_container = contribution.tables['measurements'] meas_data = meas_container.df # meas_data = meas_data[meas_data['method_codes'].str.contains( 'LT-NO|LT-AF-Z|LT-T-Z|LT-M-Z') == True] # fish out steps for plotting meas_data = meas_data[meas_data['method_codes'].str.contains( 'AN|ARM|LP-TRM|LP-PI-ARM') == False] # strip out unwanted experiments intensity_types = [ col_name for col_name in meas_data.columns if col_name in intlist ] intensity_types = [ col_name for col_name in intensity_types if any(meas_data[col_name]) ] if not len(intensity_types): print('-W- No intensity columns found') return # plot first non-empty intensity method found - normalized to initial value anyway - # doesn't matter which used int_key = intensity_types[0] # get all the non-null intensity records of the same type meas_data = meas_data[meas_data[int_key].notnull()] if 'quality' not in meas_data.columns: meas_data['quality'] = 'g' # set the default flag to good # need to treat LP-NO specially for af data, treatment should be zero, # otherwise 273. #meas_data['treatment'] = meas_data['treat_ac_field'].where( # cond=meas_data['treat_ac_field'] != 0, other=meas_data['treat_temp']) meas_data['treatment'] = meas_data['treat_ac_field'].where( cond=meas_data['treat_ac_field'].astype(bool), other=meas_data['treat_temp']) meas_data['ZI'] = 1 # initialize these to one meas_data['instrument_codes'] = "" # initialize these to blank # for unusual case of microwave power.... if 'treat_mw_power' in meas_data.columns: meas_data.loc[ (meas_data.treat_mw_power != 0) & (meas_data.treat_mw_power) & (meas_data.treat_mw_time), 'treatment'] = meas_data.treat_mw_power * meas_data.treat_mw_time # # get list of unique specimen names from measurement data # # this is a list of all the specimen names specimen_names = meas_data.specimen.unique() specimen_names = specimen_names.tolist() specimen_names.sort() # # set up new DataFrame for this sessions specimen interpretations # data_container = cb.MagicDataFrame(dtype='specimens', columns=specimen_cols) # this is for interpretations from this session current_spec_data = data_container.df if specimen == "": k = 0 else: k = specimen_names.index(specimen) # let's look at the data now while k < len(specimen_names): mpars = {"specimen_direction_type": "Error"} # set the current specimen for plotting this_specimen = specimen_names[k] # reset beginning/end pca if plotting more than one specimen if not specimen: beg_pca, end_pca = "", "" if verbose and this_specimen != "": print(this_specimen, k + 1, 'out of ', len(specimen_names)) if setangle == 0: angle = "" this_specimen_measurements = meas_data[ meas_data['specimen'].str.contains(this_specimen).astype( bool)] # fish out this specimen this_specimen_measurements = this_specimen_measurements[ -this_specimen_measurements['quality'].str.contains('b').astype( bool)] # remove bad measurements if len(this_specimen_measurements) != 0: # if there are measurements meas_list = this_specimen_measurements.to_dict( 'records') # get a list of dictionaries this_sample = "" if coord != '-1' and 'sample' in meas_list[0].keys( ): # look up sample name this_sample = pmag.get_dictitem(meas_list, 'specimen', this_specimen, 'T') if len(this_sample) > 0: this_sample = this_sample[0]['sample'] # # set up datablock [[treatment,dec, inc, int, direction_type],[....]] # # # figure out the method codes # units, methods, title = "", "", this_specimen if pmagplotlib.isServer: try: loc = this_specimen_measurements.loc[:, 'location'].values[0] except: loc = "" try: site = this_specimen_measurements.loc[:, 'site'].values[0] except: site = "" try: samp = this_specimen_measurements.loc[:, 'sample'].values[0] except: samp = "" title = "LO:_{}_SI:_{}_SA:_{}_SP:_{}_".format( loc, site, samp, this_specimen) # this is a list of all the specimen method codes meas_meths = this_specimen_measurements.method_codes.unique() tr = pd.to_numeric(this_specimen_measurements.treatment).tolist() if any(cb.is_null(treat, False) for treat in tr): print( '-W- Missing required values in measurements.treatment for {}, skipping' .format(this_specimen)) if specimen: return k += 1 continue if set(tr) == set([0]): print( '-W- Missing required values in measurements.treatment for {}, skipping' .format(this_specimen)) if specimen: return k += 1 continue for m in meas_meths: if 'LT-AF-Z' in m and 'T' not in units: units = 'T' # units include tesla tr[0] = 0 if 'LT-T-Z' in m and 'K' not in units: units = units + ":K" # units include kelvin if 'LT-M-Z' in m and 'J' not in units: units = units + ':J' # units include joules tr[0] = 0 units = units.strip(':') # strip off extra colons if 'LP-' in m: methods = methods + ":" + m decs = pd.to_numeric(this_specimen_measurements.dir_dec).tolist() incs = pd.to_numeric(this_specimen_measurements.dir_inc).tolist() # # fix the coordinate system # # revert to original coordinate system coord = saved_coord if coord != '-1': # need to transform coordinates to geographic # get the azimuth or_info, az_type = pmag.get_orient(samp_data, this_sample, data_model=3) if 'azimuth' in or_info.keys() and cb.not_null( or_info['azimuth']): #azimuths = pd.to_numeric( # this_specimen_measurements.azimuth).tolist() #dips = pd.to_numeric(this_specimen_measurements.dip).tolist() azimuths = len(decs) * [or_info['azimuth']] dips = len(decs) * [or_info['dip']] # if azimuth/dip is missing, plot using specimen coordinates instead else: azimuths, dips = [], [] if any([cb.is_null(az) for az in azimuths if az != 0]): coord = '-1' print("-W- Couldn't find azimuth and dip for {}".format( this_specimen)) print(" Plotting with specimen coordinates instead") elif any([cb.is_null(dip) for dip in dips if dip != 0]): coord = '-1' print("-W- Couldn't find azimuth and dip for {}".format( this_specimen)) print(" Plotting with specimen coordinates instead") else: coord = saved_coord # if azimuth and dip were found, continue with geographic coordinates if coord != "-1" and len(azimuths) > 0: dirs = [decs, incs, azimuths, dips] # this transposes the columns and rows of the list of lists dirs_geo = np.array(list(map(list, list(zip(*dirs))))) decs, incs = pmag.dogeo_V(dirs_geo) if coord == '100' and 'bed_dip_direction' in or_info.keys( ) and or_info[ 'bed_dip_direction'] != "": # need to do tilt correction too bed_dip_dirs = len(decs) * [ or_info['bed_dip_direction'] ] bed_dips = len(decs) * [or_info['bed_dip']] #bed_dip_dirs = pd.to_numeric( # this_specimen_measurements.bed_dip_direction).tolist() # get the azimuths #bed_dips = pd.to_numeric( # this_specimen_measurements.bed_dip).tolist() # get the azimuths dirs = [decs, incs, bed_dip_dirs, bed_dips] ## this transposes the columns and rows of the list of lists dirs_tilt = np.array(list(map(list, list(zip(*dirs))))) decs, incs = pmag.dotilt_V(dirs_tilt) if pmagplotlib.isServer: title = title + "CO:_t_" else: title = title + '_t' else: if pmagplotlib.isServer: title = title + "CO:_g_" else: title = title + '_g' if angle == "": angle = decs[0] ints = pd.to_numeric(this_specimen_measurements[int_key]).tolist() ZI = this_specimen_measurements.ZI.tolist() flags = this_specimen_measurements.quality.tolist() codes = this_specimen_measurements.instrument_codes.tolist() datalist = [tr, decs, incs, ints, ZI, flags, codes] # this transposes the columns and rows of the list of lists datablock = list(map(list, list(zip(*datalist)))) pmagplotlib.plot_zed(ZED, datablock, angle, title, units) if verbose and not set_env.IS_WIN: pmagplotlib.draw_figs(ZED) # # collect info for current_specimen_interpretation dictionary # # # find prior interpretation # prior_specimen_interpretations = [] if len(prior_spec_data): prior_specimen_interpretations = prior_spec_data[ prior_spec_data['specimen'].str.contains( this_specimen) == True] if (beg_pca == "") and (len(prior_specimen_interpretations) != 0): if len(prior_specimen_interpretations) > 0: beg_pcas = pd.to_numeric(prior_specimen_interpretations. meas_step_min.values).tolist() end_pcas = pd.to_numeric(prior_specimen_interpretations. meas_step_max.values).tolist() spec_methods = prior_specimen_interpretations.method_codes.tolist( ) # step through all prior interpretations and plot them for ind in range(len(beg_pcas)): spec_meths = spec_methods[ind].split(':') for m in spec_meths: if 'DE-BFL' in m: calculation_type = 'DE-BFL' # best fit line if 'DE-BFP' in m: calculation_type = 'DE-BFP' # best fit plane if 'DE-FM' in m: calculation_type = 'DE-FM' # fisher mean if 'DE-BFL-A' in m: calculation_type = 'DE-BFL-A' # anchored best fit line if len(beg_pcas) != 0: try: # getting the starting and ending points start, end = tr.index(beg_pcas[ind]), tr.index( end_pcas[ind]) mpars = pmag.domean(datablock, start, end, calculation_type) except ValueError: print( '-W- Specimen record contains invalid start/stop bounds:' ) mpars['specimen_direction_type'] = "Error" # calculate direction/plane if mpars["specimen_direction_type"] != "Error": # put it on the plot pmagplotlib.plot_dir(ZED, mpars, datablock, angle) if verbose and not set_env.IS_WIN: pmagplotlib.draw_figs(ZED) ### SKIP if no prior interpretation - this section should not be used: # else: # try: # start, end = int(beg_pca), int(end_pca) # except ValueError: # beg_pca = 0 # end_pca = len(datablock) - 1 # start, end = int(beg_pca), int(end_pca) # # # calculate direction/plane # try: # mpars = pmag.domean(datablock, start, end, calculation_type) # except Exception as ex: # print('-I- Problem with {}'.format(this_specimen)) # print(' ', ex) # print(' Skipping') # continue # k += 1 # if mpars["specimen_direction_type"] != "Error": # # put it on the plot # pmagplotlib.plot_dir(ZED, mpars, datablock, angle) # if verbose: # pmagplotlib.draw_figs(ZED) if plots == 1 or specimen != "": if plot_file == "": basename = title else: basename = plot_file files = {} for key in list(ZED.keys()): files[key] = basename + '_' + key + '.' + fmt if pmagplotlib.isServer: files[key] = basename + "TY:_{}_.".format(key) + fmt pmagplotlib.save_plots(ZED, files) if specimen != "": sys.exit() if verbose: recnum = 0 for plotrec in datablock: if units == 'T': print('%s: %i %7.1f %s %8.3e %7.1f %7.1f %s' % (plotrec[5], recnum, plotrec[0] * 1e3, " mT", plotrec[3], plotrec[1], plotrec[2], plotrec[6])) if units == "K": print('%s: %i %7.1f %s %8.3e %7.1f %7.1f %s' % (plotrec[5], recnum, plotrec[0] - 273, ' C', plotrec[3], plotrec[1], plotrec[2], plotrec[6])) if units == "J": print('%s: %i %7.1f %s %8.3e %7.1f %7.1f %s' % (plotrec[5], recnum, plotrec[0], ' J', plotrec[3], plotrec[1], plotrec[2], plotrec[6])) if 'K' in units and 'T' in units: if plotrec[0] >= 1.: print('%s: %i %7.1f %s %8.3e %7.1f %7.1f %s' % (plotrec[5], recnum, plotrec[0] - 273, ' C', plotrec[3], plotrec[1], plotrec[2], plotrec[6])) if plotrec[0] < 1.: print('%s: %i %7.1f %s %8.3e %7.1f %7.1f %s' % (plotrec[5], recnum, plotrec[0] * 1e3, " mT", plotrec[3], plotrec[1], plotrec[2], plotrec[6])) recnum += 1 # we have a current interpretation elif mpars["specimen_direction_type"] != "Error": # # create a new specimen record for the interpreation for this # specimen this_specimen_interpretation = { col: "" for col in specimen_cols } # this_specimen_interpretation["analysts"]=user this_specimen_interpretation['software_packages'] = version_num this_specimen_interpretation['specimen'] = this_specimen this_specimen_interpretation["method_codes"] = calculation_type this_specimen_interpretation["meas_step_unit"] = units this_specimen_interpretation["meas_step_min"] = tr[start] this_specimen_interpretation["meas_step_max"] = tr[end] this_specimen_interpretation["dir_dec"] = '%7.1f' % ( mpars['specimen_dec']) this_specimen_interpretation["dir_inc"] = '%7.1f' % ( mpars['specimen_inc']) this_specimen_interpretation["dir_dang"] = '%7.1f' % ( mpars['specimen_dang']) this_specimen_interpretation["dir_n_measurements"] = '%i' % ( mpars['specimen_n']) this_specimen_interpretation["dir_tilt_correction"] = coord methods = methods.replace(" ", "") if "T" in units: methods = methods + ":LP-DIR-AF" if "K" in units: methods = methods + ":LP-DIR-T" if "J" in units: methods = methods + ":LP-DIR-M" this_specimen_interpretation["method_codes"] = methods.strip( ':') this_specimen_interpretation[ "experiments"] = this_specimen_measurements.experiment.unique( )[0] # # print some stuff # if calculation_type != 'DE-FM': this_specimen_interpretation["dir_mad_free"] = '%7.1f' % ( mpars['specimen_mad']) this_specimen_interpretation["dir_alpha95"] = '' if verbose: if units == 'K': print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_mad_free"]), float( this_specimen_interpretation["dir_dang"]), float(this_specimen_interpretation[ "meas_step_min"]) - 273, float(this_specimen_interpretation[ "meas_step_max"]) - 273, float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) elif units == 'T': print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_mad_free"]), float( this_specimen_interpretation["dir_dang"]), float(this_specimen_interpretation[ "meas_step_min"]) * 1e3, float(this_specimen_interpretation[ "meas_step_max"]) * 1e3, float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) elif 'T' in units and 'K' in units: if float(this_specimen_interpretation[ 'meas_step_min']) < 1.0: min = float(this_specimen_interpretation[ 'meas_step_min']) * 1e3 else: min = float(this_specimen_interpretation[ 'meas_step_min']) - 273 if float(this_specimen_interpretation[ 'meas_step_max']) < 1.0: max = float(this_specimen_interpretation[ 'meas_step_max']) * 1e3 else: max = float(this_specimen_interpretation[ 'meas_step_max']) - 273 print( '%s %i %7.1f %i %i %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_mad_free"]), float( this_specimen_interpretation["dir_dang"]), min, max, float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) else: print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_mad_free"]), float( this_specimen_interpretation["dir_dang"]), float(this_specimen_interpretation[ "meas_step_min"]), float(this_specimen_interpretation[ "meas_step_max"]), float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) else: this_specimen_interpretation["dir_alpha95"] = '%7.1f' % ( mpars['specimen_alpha95']) this_specimen_interpretation["dir_mad_free"] = '' if verbose: if 'K' in units: print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurments"]), float(this_specimen_interpretation[ "dir_mad_free"]), float( this_specimen_interpretation["dir_dang"]), float(this_specimen_interpretation[ "meas_step_min"]) - 273, float(this_specimen_interpretation[ "meas_step_max"]) - 273, float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) elif 'T' in units: print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_alpha95"]), float( this_specimen_interpretation["dir_dang"]), float(this_specimen_interpretation[ "meas_step_min"]) * 1e3, float(this_specimen_interpretation[ "meas_step_max"]) * 1e3, float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) elif 'T' in units and 'K' in units: if float(this_specimen_interpretation[ 'meas_step_min']) < 1.0: min = float(this_specimen_interpretation[ 'meas_step_min']) * 1e3 else: min = float(this_specimen_interpretation[ 'meas_step_min']) - 273 if float(this_specimen_interpretation[ 'meas_step_max']) < 1.0: max = float(this_specimen_interpretation[ 'meas_step_max']) * 1e3 else: max = float(this_specimen_interpretation[ 'meas_step_max']) - 273 print('%s %i %7.1f %i %i %7.1f %7.1f %s \n' % ( this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float( this_specimen_interpretation["dir_alpha95"] ), min, max, float(this_specimen_interpretation["dir_dec"]), float(this_specimen_interpretation["dir_inc"]), calculation_type)) else: print( '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %s \n' % (this_specimen_interpretation["specimen"], int(this_specimen_interpretation[ "dir_n_measurements"]), float(this_specimen_interpretation[ "dir_alpha95"]), float(this_specimen_interpretation[ "meas_step_min"]), float(this_specimen_interpretation[ "meas_step_max"]), float( this_specimen_interpretation["dir_dec"]), float( this_specimen_interpretation["dir_inc"]), calculation_type)) if verbose: saveit = input("Save this interpretation? [y]/n \n") else: print("no data", this_specimen) if verbose: pmagplotlib.draw_figs(ZED) #res = input(' <return> for next specimen, [q]uit ') res = input("S[a]ve plots, [q]uit, or <return> to continue ") if res == 'a': files = { plot_type: this_specimen + "_" + plot_type + "." + fmt for plot_type in ZED } pmagplotlib.save_plots(ZED, files) print("") if res == 'q': return k += 1
def test_sort_dataframe_cols(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) self.assertEqual('bed_dip', magic_df.df.columns[0]) magic_df.sort_dataframe_cols() self.assertEqual('site', magic_df.df.columns[0])
def main(): """ NAME thellier_magic.py DESCRIPTION plots Thellier-Thellier data in version 3.0 format Reads saved interpretations from a specimen formatted table, default: specimens.txt SYNTAX thellier_magic.py [command line options] OPTIONS -h prints help message and quits -f MEAS, set measurements input file, default is 'measurements.txt' -fsp PRIOR, set specimens.txt prior interpretations file, default is 'specimens.txt' -fcr CRIT, set criteria file for grading. # not yet implemented -fmt [svg,png,jpg], format for images - default is svg -sav, saves plots with out review (in format specified by -fmt key or default) -spc SPEC, plots single specimen SPEC, saves plot with specified format with optional -b bounds and quits -b BEG END: sets bounds for calculation BEG: starting step number for slope calculation END: ending step number for slope calculation -z use only z component difference for pTRM calculation OUTPUT figures: ALL: numbers refer to temperature steps in command line window 1) Arai plot: closed circles are zero-field first/infield open circles are infield first/zero-field triangles are pTRM checks squares are pTRM tail checks VDS is vector difference sum diamonds are bounds for interpretation 2) Zijderveld plot: closed (open) symbols are X-Y (X-Z) planes X rotated to NRM direction 3) (De/Re)Magnetization diagram: circles are NRM remaining squares are pTRM gained 4) equal area projections: green triangles are pTRM gained direction red (purple) circles are lower(upper) hemisphere of ZI step directions blue (cyan) squares are lower(upper) hemisphere IZ step directions 5) Optional: TRM acquisition 6) Optional: TDS normalization command line window: list is: temperature step numbers, temperatures (C), Dec, Inc, Int (units of measuements) list of possible commands: type letter followed by return to select option saving of plots creates image files with specimen, plot type as name """ # # initializations # version_num = pmag.get_version() verbose = pmagplotlib.verbose # # default acceptance criteria # accept = pmag.default_criteria(0)[0] # set the default criteria # # parse command line options # plots, fmt, Zdiff = 0, 'svg', 0 if '-h' in sys.argv: print(main.__doc__) sys.exit() dir_path = pmag.get_named_arg("-WD", default_val=os.getcwd()) meas_file = pmag.get_named_arg("-f", default_val="measurements.txt") spec_file = pmag.get_named_arg("-fsp", default_val="specimens.txt") crit_file = pmag.get_named_arg("-fcr", default_val="criteria.txt") spec_file = os.path.join(dir_path, spec_file) meas_file = os.path.join(dir_path, meas_file) crit_file = os.path.join(dir_path, crit_file) fmt = pmag.get_named_arg("-fmt", "svg") if '-sav' in sys.argv: plots, verbose = 1, 0 if '-z' in sys.argv: Zdiff = 1 specimen = pmag.get_named_arg("-spc", default_val="") if '-b' in sys.argv: ind = sys.argv.index('-b') start = int(sys.argv[ind + 1]) end = int(sys.argv[ind + 2]) else: start, end = "", "" fnames = { 'measurements': meas_file, 'specimens': spec_file, 'criteria': crit_file } contribution = cb.Contribution( dir_path, custom_filenames=fnames, read_tables=['measurements', 'specimens', 'criteria']) # # import prior interpretations from specimen file # specimen_cols = [ 'analysts', 'aniso_ftest', 'aniso_ftest12', 'aniso_ftest23', 'aniso_s', 'aniso_s_mean', 'aniso_s_n_measurements', 'aniso_s_sigma', 'aniso_s_unit', 'aniso_tilt_correction', 'aniso_type', 'aniso_v1', 'aniso_v2', 'aniso_v3', 'citations', 'description', 'dir_alpha95', 'dir_comp', 'dir_dec', 'dir_inc', 'dir_mad_free', 'dir_n_measurements', 'dir_tilt_correction', 'experiments', 'geologic_classes', 'geologic_types', 'hyst_bc', 'hyst_bcr', 'hyst_mr_moment', 'hyst_ms_moment', 'int_abs', 'int_b', 'int_b_beta', 'int_b_sigma', 'int_corr', 'int_dang', 'int_drats', 'int_f', 'int_fvds', 'int_gamma', 'int_mad_free', 'int_md', 'int_n_measurements', 'int_n_ptrm', 'int_q', 'int_rsc', 'int_treat_dc_field', 'lithologies', 'meas_step_max', 'meas_step_min', 'meas_step_unit', 'method_codes', 'sample', 'software_packages', 'specimen' ] spec_container, prior_spec_data = None, [] if 'specimens' in contribution.tables: spec_container = contribution.tables['specimens'] if 'method_codes' in spec_container.df.columns: # look up all prior intensity interpretations prior_spec_data = spec_container.get_records_for_code( 'LP-PI-TRM', strict_match=False) backup = 0 # Mkeys = ['magn_moment', 'magn_volume', 'magn_mass'] # # create measurement dataframe # if pmagplotlib.isServer: contribution.propagate_location_to_measurements() meas_container = contribution.tables['measurements'] meas_data = meas_container.df # meas_data['method_codes'] = meas_data['method_codes'].str.replace( " ", "") # get rid of nasty spaces meas_data = meas_data[meas_data['method_codes'].str.contains( 'LP-PI-TRM|LP-TRM|LP-TRM-TD') == True] # fish out zero field steps for plotting intensity_types = [ col_name for col_name in meas_data.columns if col_name in Mkeys ] # plot first intensity method found - normalized to initial value anyway - # doesn't matter which used int_key = meas_container.find_filled_col(intensity_types) if not int_key: print("-W- No intensity data found, thellier_magic cannot run") return # get all the non-null intensity records of the same type meas_data = meas_data[meas_data[int_key].notnull()] if not len(meas_data): print("-W- No intensity data found, thellier_magic cannot run") return if 'flag' not in meas_data.columns: meas_data['flag'] = 'g' # set the default flag to good meas_data = meas_data[meas_data['flag'].str.contains('g') == True] # only the 'good' measurements thel_data = meas_data[meas_data['method_codes'].str.contains('LP-PI-TRM') == True] # get all the Thellier data trm_data = meas_data[meas_data['method_codes'].str.contains('LP-TRM') == True] # get all the TRM acquisition data td_data = meas_data[meas_data['method_codes'].str.contains('LP-TRM-TD') == True] # get all the TD data anis_data = meas_data[meas_data['method_codes'].str.contains('LP-AN') == True] # get all the anisotropy data # # get list of unique specimen names from measurement data # # this is a Series of all the specimen names specimen_names = meas_data.specimen.unique() specimen_names = specimen_names.tolist() # turns it into a list specimen_names.sort() # sorts by specimen name # # set up new DataFrame for this sessions specimen interpretations # spec_container = cb.MagicDataFrame(dtype='specimens', columns=specimen_cols) # this is for interpretations from this session current_spec_data = spec_container.df if specimen == "": # do all specimens k = 0 else: k = specimen_names.index(specimen) # just do this one # define figure numbers for arai, zijderveld and # de-,re-magnetization diagrams AZD = {} AZD['deremag'], AZD['zijd'], AZD['arai'], AZD['eqarea'] = 1, 2, 3, 4 pmagplotlib.plot_init(AZD['arai'], 5, 5) pmagplotlib.plot_init(AZD['zijd'], 5, 5) pmagplotlib.plot_init(AZD['deremag'], 5, 5) pmagplotlib.plot_init(AZD['eqarea'], 5, 5) if len(trm_data) > 0: AZD['TRM'] = 5 pmagplotlib.plot_init(AZD['TRM'], 5, 5) if len(td_data) > 0: AZD['TDS'] = 6 pmagplotlib.plot_init(AZD['TDS'], 5, 5) # while k < len(specimen_names): # set the current specimen for plotting this_specimen = specimen_names[k] if verbose and this_specimen != "": print(this_specimen, k + 1, 'out of ', len(specimen_names)) if pmagplotlib.isServer: this_specimen_measurements = meas_data[meas_data['specimen'] == this_specimen] try: loc = this_specimen_measurements.loc[:, 'location'].values[0] except: loc = "" try: site = this_specimen_measurements.loc[:, 'site'].values[0] except: site = "" try: samp = this_specimen_measurements.loc[:, 'sample'].values[0] except: samp = "" # # set up datablocks # thelblock = thel_data[thel_data['specimen'].str.contains(this_specimen) == True] # fish out this specimen trmblock = trm_data[trm_data['specimen'].str.contains(this_specimen) == True] # fish out this specimen tdsrecs = td_data[td_data['specimen'].str.contains(this_specimen) == True] # fish out this specimen anisblock = anis_data[anis_data['specimen'].str.contains(this_specimen) == True] # fish out the anisotropy data if len(prior_spec_data): prior_specimen_interpretations = prior_spec_data[ prior_spec_data['specimen'].str.contains( this_specimen) == True] # fish out prior interpretation else: prior_specimen_interpretations = [] # # sort data into types # araiblock, field = pmag.sortarai(thelblock, this_specimen, Zdiff, version=3) first_Z = araiblock[0] GammaChecks = araiblock[5] if len(first_Z) < 3: if backup == 0: k += 1 if verbose: print('skipping specimen - moving forward ', this_specimen) else: k -= 1 if verbose: print('skipping specimen - moving backward ', this_specimen) else: backup = 0 zijdblock, units = pmag.find_dmag_rec(this_specimen, thelblock, version=3) if start == "" and len(prior_specimen_interpretations) > 0: if verbose: print('Looking up saved interpretation....') # # get prior interpretation steps # beg_int = pd.to_numeric(prior_specimen_interpretations. meas_step_min.values).tolist()[0] end_int = pd.to_numeric(prior_specimen_interpretations. meas_step_max.values).tolist()[0] else: beg_int, end_int = "", "" recnum = 0 if verbose: print("index step Dec Inc Int Gamma") for plotrec in zijdblock: if plotrec[0] == beg_int: start = recnum # while we are at it, collect these bounds if plotrec[0] == end_int: end = recnum if verbose: if GammaChecks != "": gamma = "" for g in GammaChecks: if g[0] == plotrec[0] - 273: gamma = g[1] break if gamma is not "": print('%i %i %7.1f %7.1f %8.3e %7.1f' % (recnum, plotrec[0] - 273, plotrec[1], plotrec[2], plotrec[3], gamma)) else: print('%i %i %7.1f %7.1f %8.3e ' % (recnum, plotrec[0] - 273, plotrec[1], plotrec[2], plotrec[3])) recnum += 1 for fig in list(AZD.keys()): pmagplotlib.clearFIG(AZD[fig]) # clear all figures if 'K' in units: u = 'K' elif 'J' in units: u = 'J' pmagplotlib.plot_arai_zij(AZD, araiblock, zijdblock, this_specimen, u) if verbose: pmagplotlib.draw_figs(AZD) if cb.is_null(start, False) or cb.is_null(end, False): if verbose: ans = input('Return for next specimen, q to quit: ') if ans == 'q': sys.exit() k += 1 # moving on start, end = "", "" continue pars, errcode = pmag.PintPars(thelblock, araiblock, zijdblock, start, end, accept, version=3) pars['measurement_step_unit'] = "K" pars['experiment_type'] = 'LP-PI-TRM' # # work on saving interpretations stuff later # if errcode != 1: # no problem in PintPars pars["specimen_lab_field_dc"] = field pars["specimen_int"] = -1 * field * pars["specimen_b"] pars["er_specimen_name"] = this_specimen # pars,kill=pmag.scoreit(pars,this_specimen_interpretation,accept,'',verbose) # # deal with this later pars["specimen_grade"] = 'None' pars['measurement_step_min'] = pars['meas_step_min'] pars['measurement_step_max'] = pars['meas_step_max'] if pars['measurement_step_unit'] == 'K': outstr = "specimen Tmin Tmax N lab_field B_anc b q f(coe) Fvds beta MAD Dang Drats Nptrm Grade R MD% sigma Gamma_max \n" pars_out = (this_specimen, (pars["meas_step_min"] - 273), (pars["meas_step_max"] - 273), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"], pars["specimen_b_beta"], pars["int_mad_free"], pars["int_dang"], pars["int_drats"], pars["int_n_ptrm"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["int_md"]), pars["specimen_b_sigma"], pars['specimen_gamma']) outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f' % pars_out + '\n' elif pars['measurement_step_unit'] == 'J': outstr = "specimen Wmin Wmax N lab_field B_anc b q f(coe) Fvds beta MAD Dang Drats Nptrm Grade R MD% sigma ThetaMax DeltaMax GammaMax\n" pars_out = ( this_specimen, (pars["meas_step_min"]), (pars["meas_step_max"]), (pars["specimen_int_n"]), 1e6 * (pars["specimen_lab_field_dc"]), 1e6 * (pars["specimen_int"]), pars["specimen_b"], pars["specimen_q"], pars["specimen_f"], pars["specimen_fvds"], pars["specimen_b_beta"], pars["specimen_int_mad"], pars["specimen_int_dang"], pars["specimen_drats"], pars["specimen_int_ptrm_n"], pars["specimen_grade"], np.sqrt(pars["specimen_rsc"]), int(pars["specimen_md"]), pars["specimen_b_sigma"], pars["specimen_theta"], pars["specimen_delta"], pars["specimen_gamma"]) outstring = '%s %4.0f %4.0f %i %4.1f %4.1f %5.3f %5.1f %5.3f %5.3f %5.3f %7.1f %7.1f %7.1f %s %s %6.3f %i %5.3f %7.1f %7.1f %7.1f' % pars_out + '\n' print(outstr) print(outstring) pmagplotlib.plot_b(AZD, araiblock, zijdblock, pars) mpars = pmag.domean(araiblock[1], start, end, 'DE-BFL') if verbose: pmagplotlib.draw_figs(AZD) print('pTRM direction= ', '%7.1f' % (mpars['specimen_dec']), ' %7.1f' % (mpars['specimen_inc']), ' MAD:', '%7.1f' % (mpars['specimen_mad'])) if len(anisblock) > 0: # this specimen has anisotropy data if verbose: print('Found anisotropy record... but ignoring for now ') if plots == 1: if fmt != "pmag": files = {} for key in list(AZD.keys()): if pmagplotlib.isServer: files[ key] = "LO:_{}_SI:_{}_SA:_{}_SP:_{}_TY:_{}_.{}".format( loc, site, samp, this_specimen, key, fmt) else: files[key] = 'SP:_' + this_specimen + \ '_TY:_' + key + '_' + '.' + fmt if pmagplotlib.isServer: black = '#000000' purple = '#800080' titles = {} titles['deremag'] = 'DeReMag Plot' titles['zijd'] = 'Zijderveld Plot' titles['arai'] = 'Arai Plot' titles['TRM'] = 'TRM Acquisition data' titles['eqarea'] = 'Equal Area Plot' AZD = pmagplotlib.add_borders(AZD, titles, black, purple) pmagplotlib.save_plots(AZD, files) else: # save in pmag format print('pmag format no longer supported') #script="grep "+this_specimen+" output.mag | thellier -mfsi" #script=script+' %8.4e'%(field) # min='%i'%((pars["measurement_step_min"]-273)) # Max='%i'%((pars["measurement_step_max"]-273)) #script=script+" "+min+" "+Max #script=script+" |plotxy;cat mypost >>thellier.ps\n" # pltf.write(script) # pmag.domagicmag(outf,MeasRecs) if specimen != "": sys.exit() # syonara if verbose: ans = input('Return for next specimen, q to quit: ') if ans == 'q': sys.exit() start, end = "", "" k += 1 # moving on
def test_init_blank(self): magic_df = cb.MagicDataFrame() self.assertFalse(magic_df.df)
def test_init_with_file(self): magic_df = cb.MagicDataFrame(os.path.join(PROJECT_WD, 'sites.txt'), dmodel=DMODEL) self.assertEqual('sites', magic_df.dtype) self.assertEqual('1', magic_df.df.index[1])
def test_init_with_dtype(self): magic_df = cb.MagicDataFrame(dtype='specimens', dmodel=DMODEL) self.assertEqual('specimens', magic_df.dtype)