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 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
lowrie_magic.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie_magic.py -h [command line options]
INPUT
takes magic_measurements formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is magic_measurements.txt
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav saves plots and quits
"""
fmt, plot = 'svg', 0
FIG = {} # plot dictionary
FIG['lowrie'] = 1 # demag is figure 1
pmagplotlib.plot_init(FIG['lowrie'], 6, 6)
norm = 1 # default is to normalize by maximum axis
in_file, dir_path = 'magic_measurements.txt', '.'
if len(sys.argv) > 1:
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-N' in sys.argv: norm = 0 # don't normalize
if '-sav' in sys.argv: plot = 1 # don't normalize
if '-fmt' in sys.argv: # sets input filename
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-f' in sys.argv: # sets input filename
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
else:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
in_file = dir_path + '/' + in_file
print(in_file)
PmagRecs, file_type = pmag.magic_read(in_file)
if file_type != "magic_measurements":
print('bad input file')
sys.exit()
PmagRecs = pmag.get_dictitem(PmagRecs, 'magic_method_codes', 'LP-IRM-3D',
'has') # get all 3D IRM records
if len(PmagRecs) == 0:
print('no records found')
sys.exit()
specs = pmag.get_dictkey(PmagRecs, 'er_specimen_name', '')
sids = []
for spec in specs:
if spec not in sids:
sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print(spc)
specdata = pmag.get_dictitem(PmagRecs, 'er_specimen_name', spc,
'T') # get all this one's data
DIMs, Temps = [], []
for dat in specdata: # step through the data
DIMs.append([
float(dat['measurement_dec']),
float(dat['measurement_inc']),
float(dat['measurement_magn_moment'])
])
Temps.append(float(dat['treatment_temp']) - 273.)
carts = pmag.dir2cart(DIMs).transpose()
if norm == 1: # want to normalize
nrm = (DIMs[0][2]) # normalize by NRM
ylab = "M/M_o"
else:
nrm = 1. # don't normalize
ylab = "Magnetic moment (Am^2)"
xlab = "Temperature (C)"
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[0]), nrm),
sym='r-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[0]), nrm),
sym='ro') # X direction
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[1]), nrm),
sym='c-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[1]), nrm),
sym='cs') # Y direction
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[2]), nrm),
sym='k-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[2]), nrm),
sym='k^',
title=spc,
xlab=xlab,
ylab=ylab) # Z direction
files = {'lowrie': 'lowrie:_' + spc + '_.' + fmt}
if plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = input('S[a]ve figure? [q]uit, <return> to continue ')
if ans == 'a':
pmagplotlib.saveP(FIG, files)
elif ans == 'q':
sys.exit()
else:
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG['lowrie'])
def main(command_line=True, **kwargs):
"""
NAME
iodp_jr6_magic.py
DESCRIPTION
converts shipboard .jr6 format files to magic_measurements format files
SYNTAX
iodp_jr6_magic.py [command line options]
OPTIONS
-h: prints the help message and quits.
-f FILE: specify input file, or
-F FILE: specify output file, default is magic_measurements.txt
-fsa FILE: specify er_samples.txt file for sample name lookup ,
default is 'er_samples.txt'
-loc HOLE : specify hole name (U1456A)
-A: don't average replicate measurements
INPUT
JR6 .jr6 format file
"""
def fix_separation(filename, new_filename):
old_file = open(filename, 'r')
data = old_file.readlines()
new_data = []
for line in data:
new_line = line.replace('-', ' -')
new_line = new_line.replace(' ', ' ')
new_data.append(new_line)
new_file = open(new_filename, 'w')
for s in new_data:
new_file.write(s)
old_file.close()
new_file.close()
return new_filename
def old_fix_separation(filename, new_filename):
old_file = open(filename, 'r')
data = old_file.readlines()
new_data = []
for line in data:
new_line = []
for i in line.split():
if '-' in i[1:]:
lead_char = '-' if i[0] == '-' else ''
if lead_char:
v = i[1:].split('-')
else:
v = i.split('-')
new_line.append(lead_char + v[0])
new_line.append('-' + v[1])
else:
new_line.append(i)
new_line = (' '.join(new_line)) + '\n'
new_data.append(new_line)
new_file = open(new_filename, 'w')
for s in new_data:
new_file.write(s)
new_file.close()
old_file.close()
return new_filename
# initialize some stuff
noave = 0
volume = 2.5**3 #default volume is a 2.5cm cube
inst = ""
samp_con, Z = '5', ""
missing = 1
demag = "N"
er_location_name = "unknown"
citation = 'This study'
args = sys.argv
meth_code = "LP-NO"
version_num = pmag.get_version()
dir_path = '.'
MagRecs = []
samp_file = 'er_samples.txt'
meas_file = 'magic_measurements.txt'
mag_file = ''
#
# get command line arguments
#
if command_line:
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
if '-ID' in sys.argv:
ind = sys.argv.index('-ID')
input_dir_path = sys.argv[ind + 1]
else:
input_dir_path = dir_path
output_dir_path = dir_path
if "-h" in args:
print(main.__doc__)
return False
if '-F' in args:
ind = args.index("-F")
meas_file = args[ind + 1]
if '-fsa' in args:
ind = args.index("-fsa")
samp_file = args[ind + 1]
if samp_file[0] != '/':
samp_file = os.path.join(input_dir_path, samp_file)
try:
open(samp_file, 'r')
ErSamps, file_type = pmag.magic_read(samp_file)
except:
print(samp_file, ' not found: ')
print(
' download csv file and import to MagIC with iodp_samples_magic.py'
)
if '-f' in args:
ind = args.index("-f")
mag_file = args[ind + 1]
if "-loc" in args:
ind = args.index("-loc")
er_location_name = args[ind + 1]
if "-A" in args:
noave = 1
if not command_line:
dir_path = kwargs.get('dir_path', '.')
input_dir_path = kwargs.get('input_dir_path', dir_path)
output_dir_path = dir_path
meas_file = kwargs.get('meas_file', 'magic_measurements.txt')
mag_file = kwargs.get('mag_file', '')
samp_file = kwargs.get('samp_file', 'er_samples.txt')
specnum = kwargs.get('specnum', 1)
samp_con = kwargs.get('samp_con', '1')
if len(str(samp_con)) > 1:
samp_con, Z = samp_con.split('-')
else:
Z = ''
er_location_name = kwargs.get('er_location_name', '')
noave = kwargs.get('noave', 0) # default (0) means DO average
meth_code = kwargs.get('meth_code', "LP-NO")
# format variables
meth_code = meth_code + ":FS-C-DRILL-IODP:SP-SS-C:SO-V"
meth_code = meth_code.strip(":")
if mag_file:
mag_file = os.path.join(input_dir_path, mag_file)
samp_file = os.path.join(input_dir_path, samp_file)
meas_file = os.path.join(output_dir_path, meas_file)
# validate variables
if not mag_file:
print("You must provide an IODP_jr6 format file")
return False, "You must provide an IODP_jr6 format file"
if not os.path.exists(mag_file):
print(
'The input file you provided: {} does not exist.\nMake sure you have specified the correct filename AND correct input directory name.'
.format(mag_file))
return False, 'The input file you provided: {} does not exist.\nMake sure you have specified the correct filename AND correct input directory name.'.format(
mag_file)
if not os.path.exists(samp_file):
print(
"Your input directory:\n{}\nmust contain an er_samples.txt file, or you must explicitly provide one"
.format(input_dir_path))
return False, "Your input directory:\n{}\nmust contain an er_samples.txt file, or you must explicitly provide one".format(
input_dir_path)
# parse data
temp = os.path.join(output_dir_path, 'temp.txt')
fix_separation(mag_file, temp)
samples, filetype = pmag.magic_read(samp_file)
with open(temp, 'r') as finput:
lines = finput.readlines()
os.remove(temp)
for line in lines:
MagRec = {}
line = line.split()
spec_text_id = line[0].split('_')[1]
SampRecs = pmag.get_dictitem(samples, 'er_sample_alternatives',
spec_text_id, 'has')
if len(SampRecs) > 0: # found one
MagRec['er_specimen_name'] = SampRecs[0]['er_sample_name']
MagRec['er_sample_name'] = MagRec['er_specimen_name']
MagRec['er_site_name'] = MagRec['er_specimen_name']
MagRec["er_citation_names"] = "This study"
MagRec['er_location_name'] = er_location_name
MagRec['magic_software_packages'] = version_num
MagRec["treatment_temp"] = '%8.3e' % (273) # room temp in kelvin
MagRec["measurement_temp"] = '%8.3e' % (273) # room temp in kelvin
MagRec["measurement_flag"] = 'g'
MagRec["measurement_standard"] = 'u'
MagRec["measurement_number"] = '1'
MagRec["treatment_ac_field"] = '0'
volume = float(SampRecs[0]['sample_volume'])
x = float(line[4])
y = float(line[3])
negz = float(line[2])
cart = np.array([x, y, -negz]).transpose()
direction = pmag.cart2dir(cart).transpose()
expon = float(line[5])
magn_volume = direction[2] * (10.0**expon)
moment = magn_volume * volume
MagRec["measurement_magn_moment"] = str(moment)
MagRec["measurement_magn_volume"] = str(
magn_volume) #str(direction[2] * (10.0 ** expon))
MagRec["measurement_dec"] = '%7.1f' % (direction[0])
MagRec["measurement_inc"] = '%7.1f' % (direction[1])
step = line[1]
if step == 'NRM':
meas_type = "LT-NO"
elif step[0:2] == 'AD':
meas_type = "LT-AF-Z"
treat = float(step[2:])
MagRec["treatment_ac_field"] = '%8.3e' % (
treat * 1e-3) # convert from mT to tesla
elif step[0:2] == 'TD':
meas_type = "LT-T-Z"
treat = float(step[2:])
MagRec["treatment_temp"] = '%8.3e' % (treat + 273.
) # temp in kelvin
elif step[0:3] == 'ARM': #
meas_type = "LT-AF-I"
treat = float(row['step'][3:])
MagRec["treatment_ac_field"] = '%8.3e' % (
treat * 1e-3) # convert from mT to tesla
MagRec["treatment_dc_field"] = '%8.3e' % (
50e-6) # assume 50uT DC field
MagRec[
"measurement_description"] = 'Assumed DC field - actual unknown'
elif step[0:3] == 'IRM': #
meas_type = "LT-IRM"
treat = float(step[3:])
MagRec["treatment_dc_field"] = '%8.3e' % (
treat * 1e-3) # convert from mT to tesla
else:
print('unknown treatment type for ', row)
return False, 'unknown treatment type for ', row
MagRec['magic_method_codes'] = meas_type
MagRecs.append(MagRec.copy())
else:
print('sample name not found: ', row['specname'])
MagOuts = pmag.measurements_methods(MagRecs, noave)
file_created, error_message = pmag.magic_write(meas_file, MagOuts,
'magic_measurements')
if file_created:
return True, meas_file
else:
return False, 'Results not written to file'
def main():
"""
NAME
lowrie.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie -h [command line options]
INPUT
takes SIO formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav save plots and quit
"""
fmt, plot = "svg", 0
FIG = {} # plot dictionary
FIG["lowrie"] = 1 # demag is figure 1
pmagplotlib.plot_init(FIG["lowrie"], 6, 6)
norm = 1 # default is to normalize by maximum axis
if len(sys.argv) > 1:
if "-h" in sys.argv:
print main.__doc__
sys.exit()
if "-N" in sys.argv:
norm = 0 # don't normalize
if "-sav" in sys.argv:
plot = 1 # don't normalize
if "-fmt" in sys.argv: # sets input filename
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if "-f" in sys.argv: # sets input filename
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
else:
print main.__doc__
print "you must supply a file name"
sys.exit()
else:
print main.__doc__
print "you must supply a file name"
sys.exit()
data = open(in_file).readlines() # open the SIO format file
PmagRecs = [] # set up a list for the results
keys = ["specimen", "treatment", "csd", "M", "dec", "inc"]
for line in data:
PmagRec = {}
rec = line.replace("\n", "").split()
for k in range(len(keys)):
PmagRec[keys[k]] = rec[k]
PmagRecs.append(PmagRec)
specs = pmag.get_dictkey(PmagRecs, "specimen", "")
sids = []
for spec in specs:
if spec not in sids:
sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print spc
specdata = pmag.get_dictitem(PmagRecs, "specimen", spc, "T") # get all this one's data
DIMs, Temps = [], []
for dat in specdata: # step through the data
DIMs.append([float(dat["dec"]), float(dat["inc"]), float(dat["M"]) * 1e-3])
Temps.append(float(dat["treatment"]))
carts = pmag.dir2cart(DIMs).transpose()
# if norm==1: # want to normalize
# nrm=max(max(abs(carts[0])),max(abs(carts[1])),max(abs(carts[2]))) # by maximum of x,y,z values
# ylab="M/M_max"
if norm == 1: # want to normalize
nrm = DIMs[0][2] # normalize by NRM
ylab = "M/M_o"
else:
nrm = 1.0 # don't normalize
ylab = "Magnetic moment (Am^2)"
xlab = "Temperature (C)"
pmagplotlib.plotXY(FIG["lowrie"], Temps, abs(carts[0]) / nrm, sym="r-")
pmagplotlib.plotXY(FIG["lowrie"], Temps, abs(carts[0]) / nrm, sym="ro") # X direction
pmagplotlib.plotXY(FIG["lowrie"], Temps, abs(carts[1]) / nrm, sym="c-")
pmagplotlib.plotXY(FIG["lowrie"], Temps, abs(carts[1]) / nrm, sym="cs") # Y direction
pmagplotlib.plotXY(FIG["lowrie"], Temps, abs(carts[2]) / nrm, sym="k-")
pmagplotlib.plotXY(
FIG["lowrie"], Temps, abs(carts[2]) / nrm, sym="k^", title=spc, xlab=xlab, ylab=ylab
) # Z direction
files = {"lowrie": "lowrie:_" + spc + "_." + fmt}
if plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = raw_input("S[a]ve figure? [q]uit, <return> to continue ")
if ans == "a":
pmagplotlib.saveP(FIG, files)
elif ans == "q":
sys.exit()
else:
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG["lowrie"])
def main():
"""
NAME
sites_locations.py
DESCRIPTION
reads in er_sites.txt file and finds all locations and bounds of locations
outputs er_locations.txt file
SYNTAX
sites_locations.py [command line options]
OPTIONS
-h prints help message and quits
-f: specimen input er_sites format file, default is "er_sites.txt"
-F: locations table: default is "er_locations.txt"
"""
# set defaults
site_file = "er_sites.txt"
loc_file = "er_locations.txt"
Names, user = [], "unknown"
Done = []
version_num = pmag.get_version()
args = sys.argv
dir_path = '.'
# get command line stuff
if '-WD' in args:
ind = args.index("-WD")
dir_path = args[ind + 1]
if "-h" in args:
print(main.__doc__)
sys.exit()
if '-f' in args:
ind = args.index("-f")
site_file = args[ind + 1]
if '-F' in args:
ind = args.index("-F")
loc_file = args[ind + 1]
#
site_file = dir_path + '/' + site_file
loc_file = dir_path + '/' + loc_file
Sites, file_type = pmag.magic_read(site_file)
if file_type != 'er_sites':
print(file_type)
print(file_type, "This is not a valid er_sites file ")
sys.exit()
# read in site data
#
LocNames, Locations = [], []
for site in Sites:
if site['er_location_name'] not in LocNames: # new location name
LocNames.append(site['er_location_name'])
sites_locs = pmag.get_dictitem(Sites, 'er_location_name',
site['er_location_name'],
'T') # get all sites for this loc
lats = pmag.get_dictkey(sites_locs, 'site_lat',
'f') # get all the latitudes as floats
lons = pmag.get_dictkey(sites_locs, 'site_lon',
'f') # get all the longitudes as floats
LocRec = {
'er_citation_names': 'This study',
'er_location_name': site['er_location_name'],
'location_type': ''
}
LocRec['location_begin_lat'] = str(min(lats))
LocRec['location_end_lat'] = str(max(lats))
LocRec['location_begin_lon'] = str(min(lons))
LocRec['location_end_lon'] = str(max(lons))
Locations.append(LocRec)
if len(Locations) > 0:
pmag.magic_write(loc_file, Locations, "er_locations")
print("Locations written to: ", loc_file)
def main(command_line=True, **kwargs):
"""
NAME
iodp_dscr_magic.py
DESCRIPTION
converts ODP LIMS discrete sample format files to magic_measurements format files
SYNTAX
iodp_descr_magic.py [command line options]
OPTIONS
-h: prints the help message and quits.
-f FILE: specify input .csv file, default is all in directory
-F FILE: specify output measurements file, default is magic_measurements.txt
-A : don't average replicate measurements
INPUTS
IODP discrete sample .csv file format exported from LIMS database
"""
#
# initialize defaults
version_num = pmag.get_version()
meas_file = 'magic_measurements.txt'
csv_file = ''
MagRecs, Specs = [], []
citation = "This study"
dir_path, demag = '.', 'NRM'
args = sys.argv
noave = 0
# get command line args
if command_line:
if '-WD' in args:
ind = args.index("-WD")
dir_path = args[ind + 1]
if '-ID' in args:
ind = args.index('-ID')
input_dir_path = args[ind + 1]
else:
input_dir_path = dir_path
output_dir_path = dir_path
if "-h" in args:
print(main.__doc__)
return False
if "-A" in args: noave = 1
if '-f' in args:
ind = args.index("-f")
csv_file = args[ind + 1]
if '-F' in args:
ind = args.index("-F")
meas_file = args[ind + 1]
if not command_line:
dir_path = kwargs.get('dir_path', '.')
input_dir_path = kwargs.get('input_dir_path', dir_path)
output_dir_path = dir_path # rename dir_path after input_dir_path is set
noave = kwargs.get('noave', 0) # default (0) is DO average
csv_file = kwargs.get('csv_file', '')
meas_file = kwargs.get('meas_file', 'magic_measurements.txt')
# format variables
meas_file = os.path.join(output_dir_path, meas_file)
if csv_file == "":
filelist = os.listdir(
input_dir_path) # read in list of files to import
else:
csv_file = os.path.join(input_dir_path, csv_file)
filelist = [csv_file]
# parsing the data
file_found = False
for fname in filelist: # parse each file
if fname[-3:].lower() == 'csv':
file_found = True
print('processing: ', fname)
with open(fname, 'r') as finput:
data = list(finput.readlines())
keys = data[0].replace('\n',
'').split(',') # splits on underscores
interval_key = "Offset (cm)"
demag_key = "Demag level (mT)"
offline_demag_key = "Treatment Value (mT or °C)"
offline_treatment_type = "Treatment type"
run_key = "Test No."
if "Inclination background + tray corrected (deg)" in keys:
inc_key = "Inclination background + tray corrected (deg)"
if "Inclination background & tray corrected (deg)" in keys:
inc_key = "Inclination background & tray corrected (deg)"
if "Declination background + tray corrected (deg)" in keys:
dec_key = "Declination background + tray corrected (deg)"
if "Declination background & tray corrected (deg)" in keys:
dec_key = "Declination background & tray corrected (deg)"
if "Intensity background + tray corrected (A/m)" in keys:
int_key = "Intensity background + tray corrected (A/m)"
if "Intensity background & tray corrected (A/m)" in keys:
int_key = "Intensity background & tray corrected (A/m)"
type = "Type"
sect_key = "Sect"
half_key = "A/W"
# need to add volume_key to LORE format!
if "Sample volume (cm^3)" in keys:
volume_key = "Sample volume (cm^3)"
if "Sample volume (cc)" in keys: volume_key = "Sample volume (cc)"
if "Sample volume (cm³)" in keys:
volume_key = "Sample volume (cm³)"
for line in data[1:]:
InRec = {}
for k in range(len(keys)):
InRec[keys[k]] = line.split(',')[k]
inst = "IODP-SRM"
MagRec = {}
expedition = InRec['Exp']
location = InRec['Site'] + InRec['Hole']
offsets = InRec[interval_key].split(
'.'
) # maintain consistency with er_samples convention of using top interval
if len(offsets) == 1:
offset = int(offsets[0])
else:
offset = int(offsets[0]) - 1
#interval=str(offset+1)# maintain consistency with er_samples convention of using top interval
interval = str(
offset
) # maintain consistency with er_samples convention of using top interval
specimen = expedition + '-' + location + '-' + InRec[
'Core'] + InRec[type] + "-" + InRec[
sect_key] + '_' + InRec[half_key] + '_' + interval
if specimen not in Specs: Specs.append(specimen)
MagRec['er_expedition_name'] = expedition
MagRec['er_location_name'] = location
MagRec['er_site_name'] = specimen
MagRec['er_citation_names'] = citation
MagRec['er_specimen_name'] = specimen
MagRec['er_sample_name'] = specimen
MagRec['er_site_name'] = specimen
# set up measurement record - default is NRM
MagRec['magic_software_packages'] = version_num
MagRec["treatment_temp"] = '%8.3e' % (273
) # room temp in kelvin
MagRec["measurement_temp"] = '%8.3e' % (
273) # room temp in kelvin
MagRec["treatment_ac_field"] = '0'
MagRec["treatment_dc_field"] = '0'
MagRec["treatment_dc_field_phi"] = '0'
MagRec["treatment_dc_field_theta"] = '0'
MagRec["measurement_flag"] = 'g' # assume all data are "good"
MagRec[
"measurement_standard"] = 'u' # assume all data are "good"
MagRec["measurement_csd"] = '0' # assume all data are "good"
volume = InRec[volume_key]
MagRec["magic_method_codes"] = 'LT-NO'
sort_by = 'treatment_ac_field' # set default to AF demag
if InRec[demag_key] != "0":
MagRec['magic_method_codes'] = 'LT-AF-Z'
inst = inst + ':IODP-SRM-AF' # measured on shipboard in-line 2G AF
treatment_value = float(
InRec[demag_key].strip('"')) * 1e-3 # convert mT => T
if sort_by == "treatment_ac_field":
MagRec[
"treatment_ac_field"] = treatment_value # AF demag in treat mT => T
else:
MagRec["treatment_ac_field"] = str(
treatment_value) # AF demag in treat mT => T
elif offline_treatment_type in list(
InRec.keys()) and InRec[offline_treatment_type] != "":
if "Lowrie" in InRec['Comments']:
MagRec['magic_method_codes'] = 'LP-IRM-3D'
treatment_value = float(InRec[offline_demag_key].strip(
'"')) + 273. # convert C => K
MagRec["treatment_temp"] = treatment_value
MagRec["treatment_ac_field"] = "0"
sort_by = 'treatment_temp'
elif 'Isothermal' in InRec[offline_treatment_type]:
MagRec['magic_method_codes'] = 'LT-IRM'
treatment_value = float(InRec[offline_demag_key].strip(
'"')) * 1e-3 # convert mT => T
MagRec["treatment_dc_field"] = treatment_value
MagRec["treatment_ac_field"] = "0"
sort_by = 'treatment_dc_field'
MagRec[
"measurement_standard"] = 'u' # assume all data are "good"
vol = float(volume) * 1e-6 # convert from cc to m^3
if run_key in list(InRec.keys()):
run_number = InRec[run_key]
MagRec['external_database_ids'] = run_number
MagRec['external_database_names'] = 'LIMS'
else:
MagRec['external_database_ids'] = ""
MagRec['external_database_names'] = ''
MagRec[
'measurement_description'] = 'sample orientation: ' + InRec[
'Sample orientation']
MagRec['measurement_inc'] = InRec[inc_key].strip('"')
MagRec['measurement_dec'] = InRec[dec_key].strip('"')
intens = InRec[int_key].strip('"')
MagRec['measurement_magn_moment'] = '%8.3e' % (
float(intens) * vol
) # convert intensity from A/m to Am^2 using vol
MagRec['magic_instrument_codes'] = inst
MagRec['measurement_number'] = '1'
MagRec['measurement_positions'] = ''
MagRecs.append(MagRec)
if not file_found:
print("No .csv files were found")
return False, "No .csv files were found"
MagOuts = []
for spec in Specs:
Speclist = pmag.get_dictitem(MagRecs, 'er_specimen_name', spec, 'T')
Meassorted = sorted(Speclist,
key=lambda x, y=None: int(
round(float(x[sort_by]) - float(y[sort_by])))
if y != None else 0)
for rec in Meassorted:
for key in list(rec.keys()):
rec[key] = str(rec[key])
MagOuts.append(rec)
Fixed = pmag.measurements_methods(MagOuts, noave)
Out, keys = pmag.fillkeys(Fixed)
if pmag.magic_write(meas_file, Out, 'magic_measurements'):
print('data stored in ', meas_file)
return True, meas_file
else:
print('no data found. bad magfile?')
return False, 'no data found. bad magfile?'
def main():
"""
NAME
atrm_magic.py
DESCRIPTION
Converts ATRM data to best-fit tensor (6 elements plus sigma)
Original program ARMcrunch written to accomodate ARM anisotropy data
collected from 6 axial directions (+X,+Y,+Z,-X,-Y,-Z) using the
off-axis remanence terms to construct the tensor. A better way to
do the anisotropy of ARMs is to use 9,12 or 15 measurements in
the Hext rotational scheme.
SYNTAX
atrm_magic.py [-h][command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f FILE: specify input file, default is atrm_measurements.txt
-Fa FILE: specify anisotropy output file, default is trm_anisotropy.txt
-Fr FILE: specify results output file, default is atrm_results.txt
INPUT
Input for the present program is a TRM acquisition data with an optional baseline.
The order of the measurements is:
Decs=[0,90,0,180,270,0,0,90,0]
Incs=[0,0,90,0,0,-90,0,0,90]
The last two measurements are optional
"""
# initialize some parameters
args=sys.argv
user=""
meas_file="atrm_measurements.txt"
rmag_anis="trm_anisotropy.txt"
rmag_res="atrm_results.txt"
dir_path='.'
#
# get name of file from command line
#
if '-WD' in args:
ind=args.index('-WD')
dir_path=args[ind+1]
if "-h" in args:
print main.__doc__
sys.exit()
if "-usr" in args:
ind=args.index("-usr")
user=sys.argv[ind+1]
if "-f" in args:
ind=args.index("-f")
meas_file=sys.argv[ind+1]
if "-Fa" in args:
ind=args.index("-Fa")
rmag_anis=args[ind+1]
if "-Fr" in args:
ind=args.index("-Fr")
rmag_res=args[ind+1]
meas_file=dir_path+'/'+meas_file
rmag_anis=dir_path+'/'+rmag_anis
rmag_res=dir_path+'/'+rmag_res
# read in data
meas_data,file_type=pmag.magic_read(meas_file)
meas_data=pmag.get_dictitem(meas_data,'magic_method_codes','LP-AN-TRM','has')
if file_type != 'magic_measurements':
print file_type
print file_type,"This is not a valid magic_measurements file "
sys.exit()
#
#
# get sorted list of unique specimen names
ssort=[]
for rec in meas_data:
spec=rec["er_specimen_name"]
if spec not in ssort:ssort.append(spec)
sids=sorted(ssort)
#
#
# work on each specimen
#
specimen,npos=0,6
RmagSpecRecs,RmagResRecs=[],[]
while specimen < len(sids):
nmeas=0
s=sids[specimen]
RmagSpecRec={}
RmagResRec={}
BX,X=[],[]
method_codes=[]
Spec0=""
#
# find the data from the meas_data file for this sample
# and get dec, inc, int and convert to x,y,z
#
data=pmag.get_dictitem(meas_data,'er_specimen_name',s,'T') # fish out data for this specimen name
if len(data)>5:
RmagSpecRec["rmag_anisotropy_name"]=data[0]["er_specimen_name"]
RmagSpecRec["er_location_name"]=data[0]["er_location_name"]
RmagSpecRec["er_specimen_name"]=data[0]["er_specimen_name"]
RmagSpecRec["er_sample_name"]=data[0]["er_sample_name"]
RmagSpecRec["er_site_name"]=data[0]["er_site_name"]
RmagSpecRec["magic_experiment_names"]=RmagSpecRec["rmag_anisotropy_name"]+":ATRM"
RmagSpecRec["er_citation_names"]="This study"
RmagResRec["rmag_result_name"]=data[0]["er_specimen_name"]+":ATRM"
RmagResRec["er_location_names"]=data[0]["er_location_name"]
RmagResRec["er_specimen_names"]=data[0]["er_specimen_name"]
RmagResRec["er_sample_names"]=data[0]["er_sample_name"]
RmagResRec["er_site_names"]=data[0]["er_site_name"]
RmagResRec["magic_experiment_names"]=RmagSpecRec["rmag_anisotropy_name"]+":ATRM"
RmagResRec["er_citation_names"]="This study"
RmagSpecRec["anisotropy_type"]="ATRM"
if "magic_instrument_codes" in data[0].keys():
RmagSpecRec["magic_instrument_codes"]=data[0]["magic_instrument_codes"]
else:
RmagSpecRec["magic_instrument_codes"]=""
RmagSpecRec["anisotropy_description"]="Hext statistics adapted to ATRM"
for rec in data:
meths=rec['magic_method_codes'].strip().split(':')
Dir=[]
Dir.append(float(rec["measurement_dec"]))
Dir.append(float(rec["measurement_inc"]))
Dir.append(float(rec["measurement_magn_moment"]))
if "LT-T-Z" in meths:
BX.append(pmag.dir2cart(Dir)) # append baseline steps
elif "LT-T-I" in meths:
X.append(pmag.dir2cart(Dir))
nmeas+=1
#
if len(BX)==1:
for i in range(len(X)-1):BX.append(BX[0]) # assume first 0 field step as baseline
elif len(BX)== 0: # assume baseline is zero
for i in range(len(X)):BX.append([0.,0.,0.]) # assume baseline of 0
elif len(BX)!= len(X): # if BX isn't just one measurement or one in between every infield step, just assume it is zero
print 'something odd about the baselines - just assuming zero'
for i in range(len(X)):BX.append([0.,0.,0.]) # assume baseline of 0
if nmeas<6: # must have at least 6 measurements right now -
print 'skipping specimen ',s,' too few measurements'
specimen+=1
else:
B,H,tmpH=pmag.designATRM(npos) # B matrix made from design matrix for positions
#
# subtract optional baseline and put in a work array
#
work=numpy.zeros((nmeas,3),'f')
for i in range(nmeas):
for j in range(3):
work[i][j]=X[i][j]-BX[i][j] # subtract baseline, if available
#
# calculate tensor elements
# first put ARM components in w vector
#
w=numpy.zeros((npos*3),'f')
index=0
for i in range(npos):
for j in range(3):
w[index]=work[i][j]
index+=1
s=numpy.zeros((6),'f') # initialize the s matrix
for i in range(6):
for j in range(len(w)):
s[i]+=B[i][j]*w[j]
trace=s[0]+s[1]+s[2] # normalize by the trace
for i in range(6):
s[i]=s[i]/trace
a=pmag.s2a(s)
#------------------------------------------------------------
# Calculating dels is different than in the Kappabridge
# routine. Use trace normalized tensor (a) and the applied
# unit field directions (tmpH) to generate model X,Y,Z
# components. Then compare these with the measured values.
#------------------------------------------------------------
S=0.
comp=numpy.zeros((npos*3),'f')
for i in range(npos):
for j in range(3):
index=i*3+j
compare=a[j][0]*tmpH[i][0]+a[j][1]*tmpH[i][1]+a[j][2]*tmpH[i][2]
comp[index]=compare
for i in range(npos*3):
d=w[i]/trace - comp[i] # del values
S+=d*d
nf=float(npos*3.-6.) # number of degrees of freedom
if S >0:
sigma=numpy.sqrt(S/nf)
else: sigma=0
hpars=pmag.dohext(nf,sigma,s)
#
# prepare for output
#
RmagSpecRec["anisotropy_s1"]='%8.6f'%(s[0])
RmagSpecRec["anisotropy_s2"]='%8.6f'%(s[1])
RmagSpecRec["anisotropy_s3"]='%8.6f'%(s[2])
RmagSpecRec["anisotropy_s4"]='%8.6f'%(s[3])
RmagSpecRec["anisotropy_s5"]='%8.6f'%(s[4])
RmagSpecRec["anisotropy_s6"]='%8.6f'%(s[5])
RmagSpecRec["anisotropy_mean"]='%8.3e'%(trace/3)
RmagSpecRec["anisotropy_sigma"]='%8.6f'%(sigma)
RmagSpecRec["anisotropy_unit"]="Am^2"
RmagSpecRec["anisotropy_n"]='%i'%(npos)
RmagSpecRec["anisotropy_tilt_correction"]='-1'
RmagSpecRec["anisotropy_F"]='%7.1f '%(hpars["F"]) # used by thellier_gui - must be taken out for uploading
RmagSpecRec["anisotropy_F_crit"]=hpars["F_crit"] # used by thellier_gui - must be taken out for uploading
RmagResRec["anisotropy_t1"]='%8.6f '%(hpars["t1"])
RmagResRec["anisotropy_t2"]='%8.6f '%(hpars["t2"])
RmagResRec["anisotropy_t3"]='%8.6f '%(hpars["t3"])
RmagResRec["anisotropy_v1_dec"]='%7.1f '%(hpars["v1_dec"])
RmagResRec["anisotropy_v2_dec"]='%7.1f '%(hpars["v2_dec"])
RmagResRec["anisotropy_v3_dec"]='%7.1f '%(hpars["v3_dec"])
RmagResRec["anisotropy_v1_inc"]='%7.1f '%(hpars["v1_inc"])
RmagResRec["anisotropy_v2_inc"]='%7.1f '%(hpars["v2_inc"])
RmagResRec["anisotropy_v3_inc"]='%7.1f '%(hpars["v3_inc"])
RmagResRec["anisotropy_ftest"]='%7.1f '%(hpars["F"])
RmagResRec["anisotropy_ftest12"]='%7.1f '%(hpars["F12"])
RmagResRec["anisotropy_ftest23"]='%7.1f '%(hpars["F23"])
RmagResRec["result_description"]='Critical F: '+hpars["F_crit"]+';Critical F12/F13: '+hpars["F12_crit"]
if hpars["e12"]>hpars["e13"]:
RmagResRec["anisotropy_v1_zeta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v1_zeta_dec"]='%7.1f '%(hpars['v2_dec'])
RmagResRec["anisotropy_v1_zeta_inc"]='%7.1f '%(hpars['v2_inc'])
RmagResRec["anisotropy_v2_zeta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"]='%7.1f '%(hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v1_eta_dec"]='%7.1f '%(hpars['v3_dec'])
RmagResRec["anisotropy_v1_eta_inc"]='%7.1f '%(hpars['v3_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"]='%7.1f '%(hpars['v1_inc'])
else:
RmagResRec["anisotropy_v1_zeta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v1_zeta_dec"]='%7.1f '%(hpars['v3_dec'])
RmagResRec["anisotropy_v1_zeta_inc"]='%7.1f '%(hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"]='%7.1f '%(hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v1_eta_dec"]='%7.1f '%(hpars['v2_dec'])
RmagResRec["anisotropy_v1_eta_inc"]='%7.1f '%(hpars['v2_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"]='%7.1f '%(hpars['v1_inc'])
if hpars["e23"]>hpars['e12']:
RmagResRec["anisotropy_v2_zeta_semi_angle"]='%7.1f '%(hpars['e23'])
RmagResRec["anisotropy_v2_zeta_dec"]='%7.1f '%(hpars['v3_dec'])
RmagResRec["anisotropy_v2_zeta_inc"]='%7.1f '%(hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"]='%7.1f '%(hpars['e23'])
RmagResRec["anisotropy_v3_zeta_dec"]='%7.1f '%(hpars['v2_dec'])
RmagResRec["anisotropy_v3_zeta_inc"]='%7.1f '%(hpars['v2_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"]='%7.1f '%(hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"]='%7.1f '%(hpars['v1_inc'])
else:
RmagResRec["anisotropy_v2_zeta_semi_angle"]='%7.1f '%(hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"]='%7.1f '%(hpars['v1_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"]='%7.1f '%(hpars['e23'])
RmagResRec["anisotropy_v3_eta_dec"]='%7.1f '%(hpars['v2_dec'])
RmagResRec["anisotropy_v3_eta_inc"]='%7.1f '%(hpars['v2_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"]='%7.1f '%(hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"]='%7.1f '%(hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"]='%7.1f '%(hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"]='%7.1f '%(hpars['e23'])
RmagResRec["anisotropy_v2_eta_dec"]='%7.1f '%(hpars['v3_dec'])
RmagResRec["anisotropy_v2_eta_inc"]='%7.1f '%(hpars['v3_inc'])
RmagResRec["tilt_correction"]='-1'
RmagResRec["anisotropy_type"]='ATRM'
RmagResRec["magic_method_codes"]='LP-AN-TRM:AE-H'
RmagSpecRec["magic_method_codes"]='LP-AN-TRM:AE-H'
RmagResRec["magic_software_packages"]=pmag.get_version()
RmagSpecRec["magic_software_packages"]=pmag.get_version()
RmagSpecRecs.append(RmagSpecRec)
RmagResRecs.append(RmagResRec)
specimen+=1
pmag.magic_write(rmag_anis,RmagSpecRecs,'rmag_anisotropy')
print "specimen tensor elements stored in ",rmag_anis
pmag.magic_write(rmag_res,RmagResRecs,'rmag_results')
print "specimen statistics and eigenparameters stored in ",rmag_res
def main():
"""
NAME
lowrie.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie -h [command line options]
INPUT
takes SIO formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav save plots and quit
"""
fmt, plot = 'svg', 0
FIG = {} # plot dictionary
FIG['lowrie'] = 1 # demag is figure 1
pmagplotlib.plot_init(FIG['lowrie'], 6, 6)
norm = 1 # default is to normalize by maximum axis
if len(sys.argv) > 1:
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-N' in sys.argv:
norm = 0 # don't normalize
if '-sav' in sys.argv:
plot = 1 # don't normalize
if '-fmt' in sys.argv: # sets input filename
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-f' in sys.argv: # sets input filename
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
else:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
else:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
data = pmag.open_file(in_file)
PmagRecs = [] # set up a list for the results
keys = ['specimen', 'treatment', 'csd', 'M', 'dec', 'inc']
for line in data:
PmagRec = {}
rec = line.replace('\n', '').split()
for k in range(len(keys)):
PmagRec[keys[k]] = rec[k]
PmagRecs.append(PmagRec)
specs = pmag.get_dictkey(PmagRecs, 'specimen', '')
sids = []
for spec in specs:
if spec not in sids:
sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print(spc)
specdata = pmag.get_dictitem(
PmagRecs, 'specimen', spc, 'T') # get all this one's data
DIMs, Temps = [], []
for dat in specdata: # step through the data
DIMs.append([float(dat['dec']), float(
dat['inc']), float(dat['M']) * 1e-3])
Temps.append(float(dat['treatment']))
carts = pmag.dir2cart(DIMs).transpose()
# if norm==1: # want to normalize
# nrm=max(max(abs(carts[0])),max(abs(carts[1])),max(abs(carts[2]))) # by maximum of x,y,z values
# ylab="M/M_max"
if norm == 1: # want to normalize
nrm = (DIMs[0][2]) # normalize by NRM
ylab = "M/M_o"
else:
nrm = 1. # don't normalize
ylab = "Magnetic moment (Am^2)"
xlab = "Temperature (C)"
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[0]), nrm), sym='r-')
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[0]), nrm), sym='ro') # X direction
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[1]), nrm), sym='c-')
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[1]), nrm), sym='cs') # Y direction
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[2]), nrm), sym='k-')
pmagplotlib.plotXY(FIG['lowrie'], Temps, old_div(
abs(carts[2]), nrm), sym='k^', title=spc, xlab=xlab, ylab=ylab) # Z direction
files = {'lowrie': 'lowrie:_' + spc + '_.' + fmt}
if plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = input('S[a]ve figure? [q]uit, <return> to continue ')
if ans == 'a':
pmagplotlib.saveP(FIG, files)
elif ans == 'q':
sys.exit()
else:
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG['lowrie'])
def main():
"""
NAME
scalc_magic.py
DESCRIPTION
calculates Sb from pmag_results files
SYNTAX
scalc_magic -h [command line options]
INPUT
takes magic formatted pmag_results table
pmag_result_name must start with "VGP: Site"
must have average_lat if spin axis is reference
OPTIONS
-h prints help message and quits
-f FILE: specify input results file, default is 'pmag_results.txt'
-c cutoff: specify VGP colatitude cutoff value
-k cutoff: specify kappa cutoff
-crd [s,g,t]: specify coordinate system, default is geographic
-v : use the VanDammme criterion
-a: use antipodes of reverse data: default is to use only normal
-C: use all data without regard to polarity
-r: use reverse data only
-p: do relative to principle axis
-b: do bootstrap confidence bounds
OUTPUT:
if option -b used: N, S_B, lower and upper bounds
otherwise: N, S_B, cutoff
"""
in_file='pmag_results.txt'
coord,kappa,cutoff="0",1.,90.
nb,anti,spin,v,boot=1000,0,1,0,0
coord_key='tilt_correction'
rev=0
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-f' in sys.argv:
ind=sys.argv.index("-f")
in_file=sys.argv[ind+1]
if '-c' in sys.argv:
ind=sys.argv.index('-c')
cutoff=float(sys.argv[ind+1])
if '-k' in sys.argv:
ind=sys.argv.index('-k')
kappa=float(sys.argv[ind+1])
if '-crd' in sys.argv:
ind=sys.argv.index("-crd")
coord=sys.argv[ind+1]
if coord=='s':coord="-1"
if coord=='g':coord="0"
if coord=='t':coord="100"
if '-a' in sys.argv: anti=1
if '-C' in sys.argv: cutoff=180. # no cutoff
if '-r' in sys.argv: rev=1
if '-p' in sys.argv: spin=0
if '-v' in sys.argv: v=1
if '-b' in sys.argv: boot=1
data,file_type=pmag.magic_read(in_file)
#
#
# find desired vgp lat,lon, kappa,N_site data:
#
#
#
A,Vgps,Pvgps=180.,[],[]
VgpRecs=pmag.get_dictitem(data,'vgp_lat','','F') # get all non-blank vgp latitudes
VgpRecs=pmag.get_dictitem(VgpRecs,'vgp_lon','','F') # get all non-blank vgp longitudes
SiteRecs=pmag.get_dictitem(VgpRecs,'data_type','i','T') # get VGPs (as opposed to averaged)
SiteRecs=pmag.get_dictitem(SiteRecs,coord_key,coord,'T') # get right coordinate system
for rec in SiteRecs:
if anti==1:
if 90.-abs(float(rec['vgp_lat']))<=cutoff and float(rec['average_k'])>=kappa:
if float(rec['vgp_lat'])<0:
rec['vgp_lat']='%7.1f'%(-1*float(rec['vgp_lat']))
rec['vgp_lon']='%7.1f'%(float(rec['vgp_lon'])-180.)
Vgps.append(rec)
Pvgps.append([float(rec['vgp_lon']),float(rec['vgp_lat'])])
elif rev==0: # exclude normals
if 90.-(float(rec['vgp_lat']))<=cutoff and float(rec['average_k'])>=kappa:
Vgps.append(rec)
Pvgps.append([float(rec['vgp_lon']),float(rec['vgp_lat'])])
else: # include normals
if 90.-abs(float(rec['vgp_lat']))<=cutoff and float(rec['average_k'])>=kappa:
if float(rec['vgp_lat'])<0:
rec['vgp_lat']='%7.1f'%(-1*float(rec['vgp_lat']))
rec['vgp_lon']='%7.1f'%(float(rec['vgp_lon'])-180.)
Vgps.append(rec)
Pvgps.append([float(rec['vgp_lon']),float(rec['vgp_lat'])])
if spin==0: # do transformation to pole
ppars=pmag.doprinc(Pvgps)
for vgp in Vgps:
vlon,vlat=pmag.dotilt(float(vgp['vgp_lon']),float(vgp['vgp_lat']),ppars['dec']-180.,90.-ppars['inc'])
vgp['vgp_lon']=vlon
vgp['vgp_lat']=vlat
vgp['average_k']="0"
S_B= pmag.get_Sb(Vgps)
A=cutoff
if v==1:
thetamax,A=181.,180.
vVgps,cnt=[],0
for vgp in Vgps:vVgps.append(vgp) # make a copy of Vgps
while thetamax>A:
thetas=[]
A=1.8*S_B+5
cnt+=1
for vgp in vVgps:thetas.append(90.-(float(vgp['vgp_lat'])))
thetas.sort()
thetamax=thetas[-1]
if thetamax<A:break
nVgps=[]
for vgp in vVgps:
if 90.-(float(vgp['vgp_lat']))<thetamax:nVgps.append(vgp)
vVgps=[]
for vgp in nVgps:vVgps.append(vgp)
S_B= pmag.get_Sb(vVgps)
Vgps=[]
for vgp in vVgps:Vgps.append(vgp) # make a new Vgp list
SBs=[]
if boot==1:
for i in range(nb): # now do bootstrap
BVgps=[]
if i%100==0: print(i,' out of ',nb)
for k in range(len(Vgps)):
random.seed()
ind=random.randint(0,len(Vgps)-1)
BVgps.append(Vgps[ind])
SBs.append(pmag.get_Sb(BVgps))
SBs.sort()
low=int(.025*nb)
high=int(.975*nb)
print(len(Vgps),'%7.1f _ %7.1f ^ %7.1f %7.1f'%(S_B,SBs[low],SBs[high],A))
else:
print(len(Vgps),'%7.1f %7.1f '%(S_B,A))
def main():
"""
NAME
specimens_results_magic.py
DESCRIPTION
combines pmag_specimens.txt file with age, location, acceptance criteria and
outputs pmag_results table along with other MagIC tables necessary for uploading to the database
SYNTAX
specimens_results_magic.py [command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f: specimen input magic_measurements format file, default is "magic_measurements.txt"
-fsp: specimen input pmag_specimens format file, default is "pmag_specimens.txt"
-fsm: sample input er_samples format file, default is "er_samples.txt"
-fsi: specimen input er_sites format file, default is "er_sites.txt"
-fla: specify a file with paleolatitudes for calculating VADMs, default is not to calculate VADMS
format is: site_name paleolatitude (space delimited file)
-fa AGES: specify er_ages format file with age information
-crd [s,g,t,b]: specify coordinate system
(s, specimen, g geographic, t, tilt corrected, b, geographic and tilt corrected)
Default is to assume geographic
NB: only the tilt corrected data will appear on the results table, if both g and t are selected.
-cor [AC:CR:NL]: colon delimited list of required data adjustments for all specimens
included in intensity calculations (anisotropy, cooling rate, non-linear TRM)
unless specified, corrections will not be applied
-pri [TRM:ARM] colon delimited list of priorities for anisotropy correction (-cor must also be set to include AC). default is TRM, then ARM
-age MIN MAX UNITS: specify age boundaries and units
-exc: use exiting selection criteria (in pmag_criteria.txt file), default is default criteria
-C: no acceptance criteria
-aD: average directions per sample, default is NOT
-aI: average multiple specimen intensities per sample, default is by site
-aC: average all components together, default is NOT
-pol: calculate polarity averages
-sam: save sample level vgps and v[a]dms, default is by site
-xSi: skip the site level intensity calculation
-p: plot directions and look at intensities by site, default is NOT
-fmt: specify output for saved images, default is svg (only if -p set)
-lat: use present latitude for calculating VADMs, default is not to calculate VADMs
-xD: skip directions
-xI: skip intensities
OUPUT
writes pmag_samples, pmag_sites, pmag_results tables
"""
# set defaults
Comps=[] # list of components
version_num=pmag.get_version()
args=sys.argv
DefaultAge=["none"]
skipdirs,coord,excrit,custom,vgps,average,Iaverage,plotsites,opt=1,0,0,0,0,0,0,0,0
get_model_lat=0 # this skips VADM calculation altogether, when get_model_lat=1, uses present day
fmt='svg'
dir_path="."
model_lat_file=""
Caverage=0
infile='pmag_specimens.txt'
measfile="magic_measurements.txt"
sampfile="er_samples.txt"
sitefile="er_sites.txt"
agefile="er_ages.txt"
specout="er_specimens.txt"
sampout="pmag_samples.txt"
siteout="pmag_sites.txt"
resout="pmag_results.txt"
critout="pmag_criteria.txt"
instout="magic_instruments.txt"
sigcutoff,OBJ="",""
noDir,noInt=0,0
polarity=0
coords=['0']
Dcrit,Icrit,nocrit=0,0,0
corrections=[]
nocorrection=['DA-NL','DA-AC','DA-CR']
priorities=['DA-AC-ARM','DA-AC-TRM'] # priorities for anisotropy correction
# get command line stuff
if "-h" in args:
print(main.__doc__)
sys.exit()
if '-WD' in args:
ind=args.index("-WD")
dir_path=args[ind+1]
if '-cor' in args:
ind=args.index('-cor')
cors=args[ind+1].split(':') # list of required data adjustments
for cor in cors:
nocorrection.remove('DA-'+cor)
corrections.append('DA-'+cor)
if '-pri' in args:
ind=args.index('-pri')
priorities=args[ind+1].split(':') # list of required data adjustments
for p in priorities:
p='DA-AC-'+p
if '-f' in args:
ind=args.index("-f")
measfile=args[ind+1]
if '-fsp' in args:
ind=args.index("-fsp")
infile=args[ind+1]
if '-fsi' in args:
ind=args.index("-fsi")
sitefile=args[ind+1]
if "-crd" in args:
ind=args.index("-crd")
coord=args[ind+1]
if coord=='s':coords=['-1']
if coord=='g':coords=['0']
if coord=='t':coords=['100']
if coord=='b':coords=['0','100']
if "-usr" in args:
ind=args.index("-usr")
user=sys.argv[ind+1]
else: user=""
if "-C" in args: Dcrit,Icrit,nocrit=1,1,1 # no selection criteria
if "-sam" in args: vgps=1 # save sample level VGPS/VADMs
if "-xSi" in args:
nositeints=1 # skip site level intensity
else:
nositeints=0
if "-age" in args:
ind=args.index("-age")
DefaultAge[0]=args[ind+1]
DefaultAge.append(args[ind+2])
DefaultAge.append(args[ind+3])
Daverage,Iaverage,Caverage=0,0,0
if "-aD" in args: Daverage=1 # average by sample directions
if "-aI" in args: Iaverage=1 # average by sample intensities
if "-aC" in args: Caverage=1 # average all components together ??? why???
if "-pol" in args: polarity=1 # calculate averages by polarity
if '-xD' in args:noDir=1
if '-xI' in args:
noInt=1
elif "-fla" in args:
if '-lat' in args:
print("you should set a paleolatitude file OR use present day lat - not both")
sys.exit()
ind=args.index("-fla")
model_lat_file=dir_path+'/'+args[ind+1]
get_model_lat=2
mlat=open(model_lat_file,'r')
ModelLats=[]
for line in mlat.readlines():
ModelLat={}
tmp=line.split()
ModelLat["er_site_name"]=tmp[0]
ModelLat["site_model_lat"]=tmp[1]
ModelLat["er_sample_name"]=tmp[0]
ModelLat["sample_lat"]=tmp[1]
ModelLats.append(ModelLat)
get_model_lat=2
elif '-lat' in args:
get_model_lat=1
if "-p" in args:
plotsites=1
if "-fmt" in args:
ind=args.index("-fmt")
fmt=args[ind+1]
if noDir==0: # plot by site - set up plot window
import pmagplotlib
EQ={}
EQ['eqarea']=1
pmagplotlib.plot_init(EQ['eqarea'],5,5) # define figure 1 as equal area projection
pmagplotlib.plotNET(EQ['eqarea']) # I don't know why this has to be here, but otherwise the first plot never plots...
pmagplotlib.drawFIGS(EQ)
if '-WD' in args:
infile=dir_path+'/'+infile
measfile=dir_path+'/'+measfile
instout=dir_path+'/'+instout
sampfile=dir_path+'/'+sampfile
sitefile=dir_path+'/'+sitefile
agefile=dir_path+'/'+agefile
specout=dir_path+'/'+specout
sampout=dir_path+'/'+sampout
siteout=dir_path+'/'+siteout
resout=dir_path+'/'+resout
critout=dir_path+'/'+critout
if "-exc" in args: # use existing pmag_criteria file
if "-C" in args:
print('you can not use both existing and no criteria - choose either -exc OR -C OR neither (for default)')
sys.exit()
crit_data,file_type=pmag.magic_read(critout)
print("Acceptance criteria read in from ", critout)
else : # use default criteria (if nocrit set, then get really loose criteria as default)
crit_data=pmag.default_criteria(nocrit)
if nocrit==0:
print("Acceptance criteria are defaults")
else:
print("No acceptance criteria used ")
accept={}
for critrec in crit_data:
for key in list(critrec.keys()):
# need to migrate specimen_dang to specimen_int_dang for intensity data using old format
if 'IE-SPEC' in list(critrec.keys()) and 'specimen_dang' in list(critrec.keys()) and 'specimen_int_dang' not in list(critrec.keys()):
critrec['specimen_int_dang']=critrec['specimen_dang']
del critrec['specimen_dang']
# need to get rid of ron shaars sample_int_sigma_uT
if 'sample_int_sigma_uT' in list(critrec.keys()):
critrec['sample_int_sigma']='%10.3e'%(eval(critrec['sample_int_sigma_uT'])*1e-6)
if key not in list(accept.keys()) and critrec[key]!='':
accept[key]=critrec[key]
#
#
if "-exc" not in args and "-C" not in args:
print("args",args)
pmag.magic_write(critout,[accept],'pmag_criteria')
print("\n Pmag Criteria stored in ",critout,'\n')
#
# now we're done slow dancing
#
SiteNFO,file_type=pmag.magic_read(sitefile) # read in site data - has the lats and lons
SampNFO,file_type=pmag.magic_read(sampfile) # read in site data - has the lats and lons
height_nfo=pmag.get_dictitem(SiteNFO,'site_height','','F') # find all the sites with height info.
if agefile !="":AgeNFO,file_type=pmag.magic_read(agefile) # read in the age information
Data,file_type=pmag.magic_read(infile) # read in specimen interpretations
IntData=pmag.get_dictitem(Data,'specimen_int','','F') # retrieve specimens with intensity data
comment,orient="",[]
samples,sites=[],[]
for rec in Data: # run through the data filling in missing keys and finding all components, coordinates available
# fill in missing fields, collect unique sample and site names
if 'er_sample_name' not in list(rec.keys()):
rec['er_sample_name']=""
elif rec['er_sample_name'] not in samples:
samples.append(rec['er_sample_name'])
if 'er_site_name' not in list(rec.keys()):
rec['er_site_name']=""
elif rec['er_site_name'] not in sites:
sites.append(rec['er_site_name'])
if 'specimen_int' not in list(rec.keys()):rec['specimen_int']=''
if 'specimen_comp_name' not in list(rec.keys()) or rec['specimen_comp_name']=="":rec['specimen_comp_name']='A'
if rec['specimen_comp_name'] not in Comps:Comps.append(rec['specimen_comp_name'])
rec['specimen_tilt_correction']=rec['specimen_tilt_correction'].strip('\n')
if "specimen_tilt_correction" not in list(rec.keys()): rec["specimen_tilt_correction"]="-1" # assume sample coordinates
if rec["specimen_tilt_correction"] not in orient: orient.append(rec["specimen_tilt_correction"]) # collect available coordinate systems
if "specimen_direction_type" not in list(rec.keys()): rec["specimen_direction_type"]='l' # assume direction is line - not plane
if "specimen_dec" not in list(rec.keys()): rec["specimen_direction_type"]='' # if no declination, set direction type to blank
if "specimen_n" not in list(rec.keys()): rec["specimen_n"]='' # put in n
if "specimen_alpha95" not in list(rec.keys()): rec["specimen_alpha95"]='' # put in alpha95
if "magic_method_codes" not in list(rec.keys()): rec["magic_method_codes"]=''
#
# start parsing data into SpecDirs, SpecPlanes, SpecInts
SpecInts,SpecDirs,SpecPlanes=[],[],[]
samples.sort() # get sorted list of samples and sites
sites.sort()
if noInt==0: # don't skip intensities
IntData=pmag.get_dictitem(Data,'specimen_int','','F') # retrieve specimens with intensity data
if nocrit==0: # use selection criteria
for rec in IntData: # do selection criteria
kill=pmag.grade(rec,accept,'specimen_int')
if len(kill)==0: SpecInts.append(rec) # intensity record to be included in sample, site calculations
else:
SpecInts=IntData[:] # take everything - no selection criteria
# check for required data adjustments
if len(corrections)>0 and len(SpecInts)>0:
for cor in corrections:
SpecInts=pmag.get_dictitem(SpecInts,'magic_method_codes',cor,'has') # only take specimens with the required corrections
if len(nocorrection)>0 and len(SpecInts)>0:
for cor in nocorrection:
SpecInts=pmag.get_dictitem(SpecInts,'magic_method_codes',cor,'not') # exclude the corrections not specified for inclusion
# take top priority specimen of its name in remaining specimens (only one per customer)
PrioritySpecInts=[]
specimens=pmag.get_specs(SpecInts) # get list of uniq specimen names
for spec in specimens:
ThisSpecRecs=pmag.get_dictitem(SpecInts,'er_specimen_name',spec,'T') # all the records for this specimen
if len(ThisSpecRecs)==1:
PrioritySpecInts.append(ThisSpecRecs[0])
elif len(ThisSpecRecs)>1: # more than one
prec=[]
for p in priorities:
ThisSpecRecs=pmag.get_dictitem(SpecInts,'magic_method_codes',p,'has') # all the records for this specimen
if len(ThisSpecRecs)>0:prec.append(ThisSpecRecs[0])
PrioritySpecInts.append(prec[0]) # take the best one
SpecInts=PrioritySpecInts # this has the first specimen record
if noDir==0: # don't skip directions
AllDirs=pmag.get_dictitem(Data,'specimen_direction_type','','F') # retrieve specimens with directed lines and planes
Ns=pmag.get_dictitem(AllDirs,'specimen_n','','F') # get all specimens with specimen_n information
if nocrit!=1: # use selection criteria
for rec in Ns: # look through everything with specimen_n for "good" data
kill=pmag.grade(rec,accept,'specimen_dir')
if len(kill)==0: # nothing killed it
SpecDirs.append(rec)
else: # no criteria
SpecDirs=AllDirs[:] # take them all
# SpecDirs is now the list of all specimen directions (lines and planes) that pass muster
#
PmagSamps,SampDirs=[],[] # list of all sample data and list of those that pass the DE-SAMP criteria
PmagSites,PmagResults=[],[] # list of all site data and selected results
SampInts=[]
for samp in samples: # run through the sample names
if Daverage==1: # average by sample if desired
SampDir=pmag.get_dictitem(SpecDirs,'er_sample_name',samp,'T') # get all the directional data for this sample
if len(SampDir)>0: # there are some directions
for coord in coords: # step through desired coordinate systems
CoordDir=pmag.get_dictitem(SampDir,'specimen_tilt_correction',coord,'T') # get all the directions for this sample
if len(CoordDir)>0: # there are some with this coordinate system
if Caverage==0: # look component by component
for comp in Comps:
CompDir=pmag.get_dictitem(CoordDir,'specimen_comp_name',comp,'T') # get all directions from this component
if len(CompDir)>0: # there are some
PmagSampRec=pmag.lnpbykey(CompDir,'sample','specimen') # get a sample average from all specimens
PmagSampRec["er_location_name"]=CompDir[0]['er_location_name'] # decorate the sample record
PmagSampRec["er_site_name"]=CompDir[0]['er_site_name']
PmagSampRec["er_sample_name"]=samp
PmagSampRec["er_citation_names"]="This study"
PmagSampRec["er_analyst_mail_names"]=user
PmagSampRec['magic_software_packages']=version_num
if nocrit!=1:PmagSampRec['pmag_criteria_codes']="ACCEPT"
if agefile != "": PmagSampRec= pmag.get_age(PmagSampRec,"er_site_name","sample_inferred_",AgeNFO,DefaultAge)
site_height=pmag.get_dictitem(height_nfo,'er_site_name',PmagSampRec['er_site_name'],'T')
if len(site_height)>0:PmagSampRec["sample_height"]=site_height[0]['site_height'] # add in height if available
PmagSampRec['sample_comp_name']=comp
PmagSampRec['sample_tilt_correction']=coord
PmagSampRec['er_specimen_names']= pmag.get_list(CompDir,'er_specimen_name') # get a list of the specimen names used
PmagSampRec['magic_method_codes']= pmag.get_list(CompDir,'magic_method_codes') # get a list of the methods used
if nocrit!=1: # apply selection criteria
kill=pmag.grade(PmagSampRec,accept,'sample_dir')
else:
kill=[]
if len(kill)==0:
SampDirs.append(PmagSampRec)
if vgps==1: # if sample level VGP info desired, do that now
PmagResRec=pmag.getsampVGP(PmagSampRec,SiteNFO)
if PmagResRec!="":PmagResults.append(PmagResRec)
PmagSamps.append(PmagSampRec)
if Caverage==1: # average all components together basically same as above
PmagSampRec=pmag.lnpbykey(CoordDir,'sample','specimen')
PmagSampRec["er_location_name"]=CoordDir[0]['er_location_name']
PmagSampRec["er_site_name"]=CoordDir[0]['er_site_name']
PmagSampRec["er_sample_name"]=samp
PmagSampRec["er_citation_names"]="This study"
PmagSampRec["er_analyst_mail_names"]=user
PmagSampRec['magic_software_packages']=version_num
if nocrit!=1:PmagSampRec['pmag_criteria_codes']=""
if agefile != "": PmagSampRec= pmag.get_age(PmagSampRec,"er_site_name","sample_inferred_",AgeNFO,DefaultAge)
site_height=pmag.get_dictitem(height_nfo,'er_site_name',site,'T')
if len(site_height)>0:PmagSampRec["sample_height"]=site_height[0]['site_height'] # add in height if available
PmagSampRec['sample_tilt_correction']=coord
PmagSampRec['sample_comp_name']= pmag.get_list(CoordDir,'specimen_comp_name') # get components used
PmagSampRec['er_specimen_names']= pmag.get_list(CoordDir,'er_specimen_name') # get specimne names averaged
PmagSampRec['magic_method_codes']= pmag.get_list(CoordDir,'magic_method_codes') # assemble method codes
if nocrit!=1: # apply selection criteria
kill=pmag.grade(PmagSampRec,accept,'sample_dir')
if len(kill)==0: # passes the mustard
SampDirs.append(PmagSampRec)
if vgps==1:
PmagResRec=pmag.getsampVGP(PmagSampRec,SiteNFO)
if PmagResRec!="":PmagResults.append(PmagResRec)
else: # take everything
SampDirs.append(PmagSampRec)
if vgps==1:
PmagResRec=pmag.getsampVGP(PmagSampRec,SiteNFO)
if PmagResRec!="":PmagResults.append(PmagResRec)
PmagSamps.append(PmagSampRec)
if Iaverage==1: # average by sample if desired
SampI=pmag.get_dictitem(SpecInts,'er_sample_name',samp,'T') # get all the intensity data for this sample
if len(SampI)>0: # there are some
PmagSampRec=pmag.average_int(SampI,'specimen','sample') # get average intensity stuff
PmagSampRec["sample_description"]="sample intensity" # decorate sample record
PmagSampRec["sample_direction_type"]=""
PmagSampRec['er_site_name']=SampI[0]["er_site_name"]
PmagSampRec['er_sample_name']=samp
PmagSampRec['er_location_name']=SampI[0]["er_location_name"]
PmagSampRec["er_citation_names"]="This study"
PmagSampRec["er_analyst_mail_names"]=user
if agefile != "": PmagSampRec=pmag.get_age(PmagSampRec,"er_site_name","sample_inferred_", AgeNFO,DefaultAge)
site_height=pmag.get_dictitem(height_nfo,'er_site_name',PmagSampRec['er_site_name'],'T')
if len(site_height)>0:PmagSampRec["sample_height"]=site_height[0]['site_height'] # add in height if available
PmagSampRec['er_specimen_names']= pmag.get_list(SampI,'er_specimen_name')
PmagSampRec['magic_method_codes']= pmag.get_list(SampI,'magic_method_codes')
if nocrit!=1: # apply criteria!
kill=pmag.grade(PmagSampRec,accept,'sample_int')
if len(kill)==0:
PmagSampRec['pmag_criteria_codes']="ACCEPT"
SampInts.append(PmagSampRec)
PmagSamps.append(PmagSampRec)
else:PmagSampRec={} # sample rejected
else: # no criteria
SampInts.append(PmagSampRec)
PmagSamps.append(PmagSampRec)
PmagSampRec['pmag_criteria_codes']=""
if vgps==1 and get_model_lat!=0 and PmagSampRec!={}: #
if get_model_lat==1: # use sample latitude
PmagResRec=pmag.getsampVDM(PmagSampRec,SampNFO)
del(PmagResRec['model_lat']) # get rid of the model lat key
elif get_model_lat==2: # use model latitude
PmagResRec=pmag.getsampVDM(PmagSampRec,ModelLats)
if PmagResRec!={}:PmagResRec['magic_method_codes']=PmagResRec['magic_method_codes']+":IE-MLAT"
if PmagResRec!={}:
PmagResRec['er_specimen_names']=PmagSampRec['er_specimen_names']
PmagResRec['er_sample_names']=PmagSampRec['er_sample_name']
PmagResRec['pmag_criteria_codes']='ACCEPT'
PmagResRec['average_int_sigma_perc']=PmagSampRec['sample_int_sigma_perc']
PmagResRec['average_int_sigma']=PmagSampRec['sample_int_sigma']
PmagResRec['average_int_n']=PmagSampRec['sample_int_n']
PmagResRec['vadm_n']=PmagSampRec['sample_int_n']
PmagResRec['data_type']='i'
PmagResults.append(PmagResRec)
if len(PmagSamps)>0:
TmpSamps,keylist=pmag.fillkeys(PmagSamps) # fill in missing keys from different types of records
pmag.magic_write(sampout,TmpSamps,'pmag_samples') # save in sample output file
print(' sample averages written to ',sampout)
#
#create site averages from specimens or samples as specified
#
for site in sites:
if Daverage==0: key,dirlist='specimen',SpecDirs # if specimen averages at site level desired
if Daverage==1: key,dirlist='sample',SampDirs # if sample averages at site level desired
tmp=pmag.get_dictitem(dirlist,'er_site_name',site,'T') # get all the sites with directions
tmp1=pmag.get_dictitem(tmp,key+'_tilt_correction',coords[-1],'T') # use only the last coordinate if Caverage==0
sd=pmag.get_dictitem(SiteNFO,'er_site_name',site,'T') # fish out site information (lat/lon, etc.)
if len(sd)>0:
sitedat=sd[0]
if Caverage==0: # do component wise averaging
for comp in Comps:
siteD=pmag.get_dictitem(tmp1,key+'_comp_name',comp,'T') # get all components comp
if len(siteD)>0: # there are some for this site and component name
PmagSiteRec=pmag.lnpbykey(siteD,'site',key) # get an average for this site
PmagSiteRec['site_comp_name']=comp # decorate the site record
PmagSiteRec["er_location_name"]=siteD[0]['er_location_name']
PmagSiteRec["er_site_name"]=siteD[0]['er_site_name']
PmagSiteRec['site_tilt_correction']=coords[-1]
PmagSiteRec['site_comp_name']= pmag.get_list(siteD,key+'_comp_name')
if Daverage==1:
PmagSiteRec['er_sample_names']= pmag.get_list(siteD,'er_sample_name')
else:
PmagSiteRec['er_specimen_names']= pmag.get_list(siteD,'er_specimen_name')
# determine the demagnetization code (DC3,4 or 5) for this site
AFnum=len(pmag.get_dictitem(siteD,'magic_method_codes','LP-DIR-AF','has'))
Tnum=len(pmag.get_dictitem(siteD,'magic_method_codes','LP-DIR-T','has'))
DC=3
if AFnum>0:DC+=1
if Tnum>0:DC+=1
PmagSiteRec['magic_method_codes']= pmag.get_list(siteD,'magic_method_codes')+':'+ 'LP-DC'+str(DC)
PmagSiteRec['magic_method_codes'].strip(":")
if plotsites==1:
print(PmagSiteRec['er_site_name'])
pmagplotlib.plotSITE(EQ['eqarea'],PmagSiteRec,siteD,key) # plot and list the data
pmagplotlib.drawFIGS(EQ)
PmagSites.append(PmagSiteRec)
else: # last component only
siteD=tmp1[:] # get the last orientation system specified
if len(siteD)>0: # there are some
PmagSiteRec=pmag.lnpbykey(siteD,'site',key) # get the average for this site
PmagSiteRec["er_location_name"]=siteD[0]['er_location_name'] # decorate the record
PmagSiteRec["er_site_name"]=siteD[0]['er_site_name']
PmagSiteRec['site_comp_name']=comp
PmagSiteRec['site_tilt_correction']=coords[-1]
PmagSiteRec['site_comp_name']= pmag.get_list(siteD,key+'_comp_name')
PmagSiteRec['er_specimen_names']= pmag.get_list(siteD,'er_specimen_name')
PmagSiteRec['er_sample_names']= pmag.get_list(siteD,'er_sample_name')
AFnum=len(pmag.get_dictitem(siteD,'magic_method_codes','LP-DIR-AF','has'))
Tnum=len(pmag.get_dictitem(siteD,'magic_method_codes','LP-DIR-T','has'))
DC=3
if AFnum>0:DC+=1
if Tnum>0:DC+=1
PmagSiteRec['magic_method_codes']= pmag.get_list(siteD,'magic_method_codes')+':'+ 'LP-DC'+str(DC)
PmagSiteRec['magic_method_codes'].strip(":")
if Daverage==0:PmagSiteRec['site_comp_name']= pmag.get_list(siteD,key+'_comp_name')
if plotsites==1:
pmagplotlib.plotSITE(EQ['eqarea'],PmagSiteRec,siteD,key)
pmagplotlib.drawFIGS(EQ)
PmagSites.append(PmagSiteRec)
else:
print('site information not found in er_sites for site, ',site,' site will be skipped')
for PmagSiteRec in PmagSites: # now decorate each dictionary some more, and calculate VGPs etc. for results table
PmagSiteRec["er_citation_names"]="This study"
PmagSiteRec["er_analyst_mail_names"]=user
PmagSiteRec['magic_software_packages']=version_num
if agefile != "": PmagSiteRec= pmag.get_age(PmagSiteRec,"er_site_name","site_inferred_",AgeNFO,DefaultAge)
PmagSiteRec['pmag_criteria_codes']='ACCEPT'
if 'site_n_lines' in list(PmagSiteRec.keys()) and 'site_n_planes' in list(PmagSiteRec.keys()) and PmagSiteRec['site_n_lines']!="" and PmagSiteRec['site_n_planes']!="":
if int(PmagSiteRec["site_n_planes"])>0:
PmagSiteRec["magic_method_codes"]=PmagSiteRec['magic_method_codes']+":DE-FM-LP"
elif int(PmagSiteRec["site_n_lines"])>2:
PmagSiteRec["magic_method_codes"]=PmagSiteRec['magic_method_codes']+":DE-FM"
kill=pmag.grade(PmagSiteRec,accept,'site_dir')
if len(kill)==0:
PmagResRec={} # set up dictionary for the pmag_results table entry
PmagResRec['data_type']='i' # decorate it a bit
PmagResRec['magic_software_packages']=version_num
PmagSiteRec['site_description']='Site direction included in results table'
PmagResRec['pmag_criteria_codes']='ACCEPT'
dec=float(PmagSiteRec["site_dec"])
inc=float(PmagSiteRec["site_inc"])
if 'site_alpha95' in list(PmagSiteRec.keys()) and PmagSiteRec['site_alpha95']!="":
a95=float(PmagSiteRec["site_alpha95"])
else:a95=180.
sitedat=pmag.get_dictitem(SiteNFO,'er_site_name',PmagSiteRec['er_site_name'],'T')[0] # fish out site information (lat/lon, etc.)
lat=float(sitedat['site_lat'])
lon=float(sitedat['site_lon'])
plong,plat,dp,dm=pmag.dia_vgp(dec,inc,a95,lat,lon) # get the VGP for this site
if PmagSiteRec['site_tilt_correction']=='-1':C=' (spec coord) '
if PmagSiteRec['site_tilt_correction']=='0':C=' (geog. coord) '
if PmagSiteRec['site_tilt_correction']=='100':C=' (strat. coord) '
PmagResRec["pmag_result_name"]="VGP Site: "+PmagSiteRec["er_site_name"] # decorate some more
PmagResRec["result_description"]="Site VGP, coord system = "+str(coord)+' component: '+comp
PmagResRec['er_site_names']=PmagSiteRec['er_site_name']
PmagResRec['pmag_criteria_codes']='ACCEPT'
PmagResRec['er_citation_names']='This study'
PmagResRec['er_analyst_mail_names']=user
PmagResRec["er_location_names"]=PmagSiteRec["er_location_name"]
if Daverage==1:
PmagResRec["er_sample_names"]=PmagSiteRec["er_sample_names"]
else:
PmagResRec["er_specimen_names"]=PmagSiteRec["er_specimen_names"]
PmagResRec["tilt_correction"]=PmagSiteRec['site_tilt_correction']
PmagResRec["pole_comp_name"]=PmagSiteRec['site_comp_name']
PmagResRec["average_dec"]=PmagSiteRec["site_dec"]
PmagResRec["average_inc"]=PmagSiteRec["site_inc"]
PmagResRec["average_alpha95"]=PmagSiteRec["site_alpha95"]
PmagResRec["average_n"]=PmagSiteRec["site_n"]
PmagResRec["average_n_lines"]=PmagSiteRec["site_n_lines"]
PmagResRec["average_n_planes"]=PmagSiteRec["site_n_planes"]
PmagResRec["vgp_n"]=PmagSiteRec["site_n"]
PmagResRec["average_k"]=PmagSiteRec["site_k"]
PmagResRec["average_r"]=PmagSiteRec["site_r"]
PmagResRec["average_lat"]='%10.4f ' %(lat)
PmagResRec["average_lon"]='%10.4f ' %(lon)
if agefile != "": PmagResRec= pmag.get_age(PmagResRec,"er_site_names","average_",AgeNFO,DefaultAge)
site_height=pmag.get_dictitem(height_nfo,'er_site_name',site,'T')
if len(site_height)>0:PmagResRec["average_height"]=site_height[0]['site_height']
PmagResRec["vgp_lat"]='%7.1f ' % (plat)
PmagResRec["vgp_lon"]='%7.1f ' % (plong)
PmagResRec["vgp_dp"]='%7.1f ' % (dp)
PmagResRec["vgp_dm"]='%7.1f ' % (dm)
PmagResRec["magic_method_codes"]= PmagSiteRec["magic_method_codes"]
if PmagSiteRec['site_tilt_correction']=='0':PmagSiteRec['magic_method_codes']=PmagSiteRec['magic_method_codes']+":DA-DIR-GEO"
if PmagSiteRec['site_tilt_correction']=='100':PmagSiteRec['magic_method_codes']=PmagSiteRec['magic_method_codes']+":DA-DIR-TILT"
PmagSiteRec['site_polarity']=""
if polarity==1: # assign polarity based on angle of pole lat to spin axis - may want to re-think this sometime
angle=pmag.angle([0,0],[0,(90-plat)])
if angle <= 55.: PmagSiteRec["site_polarity"]='n'
if angle > 55. and angle < 125.: PmagSiteRec["site_polarity"]='t'
if angle >= 125.: PmagSiteRec["site_polarity"]='r'
PmagResults.append(PmagResRec)
if polarity==1:
crecs=pmag.get_dictitem(PmagSites,'site_tilt_correction','100','T') # find the tilt corrected data
if len(crecs)<2:crecs=pmag.get_dictitem(PmagSites,'site_tilt_correction','0','T') # if there aren't any, find the geographic corrected data
if len(crecs)>2: # if there are some,
comp=pmag.get_list(crecs,'site_comp_name').split(':')[0] # find the first component
crecs=pmag.get_dictitem(crecs,'site_comp_name',comp,'T') # fish out all of the first component
precs=[]
for rec in crecs:
precs.append({'dec':rec['site_dec'],'inc':rec['site_inc'],'name':rec['er_site_name'],'loc':rec['er_location_name']})
polpars=pmag.fisher_by_pol(precs) # calculate average by polarity
for mode in list(polpars.keys()): # hunt through all the modes (normal=A, reverse=B, all=ALL)
PolRes={}
PolRes['er_citation_names']='This study'
PolRes["pmag_result_name"]="Polarity Average: Polarity "+mode #
PolRes["data_type"]="a"
PolRes["average_dec"]='%7.1f'%(polpars[mode]['dec'])
PolRes["average_inc"]='%7.1f'%(polpars[mode]['inc'])
PolRes["average_n"]='%i'%(polpars[mode]['n'])
PolRes["average_r"]='%5.4f'%(polpars[mode]['r'])
PolRes["average_k"]='%6.0f'%(polpars[mode]['k'])
PolRes["average_alpha95"]='%7.1f'%(polpars[mode]['alpha95'])
PolRes['er_site_names']= polpars[mode]['sites']
PolRes['er_location_names']= polpars[mode]['locs']
PolRes['magic_software_packages']=version_num
PmagResults.append(PolRes)
if noInt!=1 and nositeints!=1:
for site in sites: # now do intensities for each site
if plotsites==1:print(site)
if Iaverage==0: key,intlist='specimen',SpecInts # if using specimen level data
if Iaverage==1: key,intlist='sample',PmagSamps # if using sample level data
Ints=pmag.get_dictitem(intlist,'er_site_name',site,'T') # get all the intensities for this site
if len(Ints)>0: # there are some
PmagSiteRec=pmag.average_int(Ints,key,'site') # get average intensity stuff for site table
PmagResRec=pmag.average_int(Ints,key,'average') # get average intensity stuff for results table
if plotsites==1: # if site by site examination requested - print this site out to the screen
for rec in Ints:print(rec['er_'+key+'_name'],' %7.1f'%(1e6*float(rec[key+'_int'])))
if len(Ints)>1:
print('Average: ','%7.1f'%(1e6*float(PmagResRec['average_int'])),'N: ',len(Ints))
print('Sigma: ','%7.1f'%(1e6*float(PmagResRec['average_int_sigma'])),'Sigma %: ',PmagResRec['average_int_sigma_perc'])
input('Press any key to continue\n')
er_location_name=Ints[0]["er_location_name"]
PmagSiteRec["er_location_name"]=er_location_name # decorate the records
PmagSiteRec["er_citation_names"]="This study"
PmagResRec["er_location_names"]=er_location_name
PmagResRec["er_citation_names"]="This study"
PmagSiteRec["er_analyst_mail_names"]=user
PmagResRec["er_analyst_mail_names"]=user
PmagResRec["data_type"]='i'
if Iaverage==0:
PmagSiteRec['er_specimen_names']= pmag.get_list(Ints,'er_specimen_name') # list of all specimens used
PmagResRec['er_specimen_names']= pmag.get_list(Ints,'er_specimen_name')
PmagSiteRec['er_sample_names']= pmag.get_list(Ints,'er_sample_name') # list of all samples used
PmagResRec['er_sample_names']= pmag.get_list(Ints,'er_sample_name')
PmagSiteRec['er_site_name']= site
PmagResRec['er_site_names']= site
PmagSiteRec['magic_method_codes']= pmag.get_list(Ints,'magic_method_codes')
PmagResRec['magic_method_codes']= pmag.get_list(Ints,'magic_method_codes')
kill=pmag.grade(PmagSiteRec,accept,'site_int')
if nocrit==1 or len(kill)==0:
b,sig=float(PmagResRec['average_int']),""
if(PmagResRec['average_int_sigma'])!="":sig=float(PmagResRec['average_int_sigma'])
sdir=pmag.get_dictitem(PmagResults,'er_site_names',site,'T') # fish out site direction
if len(sdir)>0 and sdir[-1]['average_inc']!="": # get the VDM for this record using last average inclination (hope it is the right one!)
inc=float(sdir[0]['average_inc']) #
mlat=pmag.magnetic_lat(inc) # get magnetic latitude using dipole formula
PmagResRec["vdm"]='%8.3e '% (pmag.b_vdm(b,mlat)) # get VDM with magnetic latitude
PmagResRec["vdm_n"]=PmagResRec['average_int_n']
if 'average_int_sigma' in list(PmagResRec.keys()) and PmagResRec['average_int_sigma']!="":
vdm_sig=pmag.b_vdm(float(PmagResRec['average_int_sigma']),mlat)
PmagResRec["vdm_sigma"]='%8.3e '% (vdm_sig)
else:
PmagResRec["vdm_sigma"]=""
mlat="" # define a model latitude
if get_model_lat==1: # use present site latitude
mlats=pmag.get_dictitem(SiteNFO,'er_site_name',site,'T')
if len(mlats)>0: mlat=mlats[0]['site_lat']
elif get_model_lat==2: # use a model latitude from some plate reconstruction model (or something)
mlats=pmag.get_dictitem(ModelLats,'er_site_name',site,'T')
if len(mlats)>0: PmagResRec['model_lat']=mlats[0]['site_model_lat']
mlat=PmagResRec['model_lat']
if mlat!="":
PmagResRec["vadm"]='%8.3e '% (pmag.b_vdm(b,float(mlat))) # get the VADM using the desired latitude
if sig!="":
vdm_sig=pmag.b_vdm(float(PmagResRec['average_int_sigma']),float(mlat))
PmagResRec["vadm_sigma"]='%8.3e '% (vdm_sig)
PmagResRec["vadm_n"]=PmagResRec['average_int_n']
else:
PmagResRec["vadm_sigma"]=""
sitedat=pmag.get_dictitem(SiteNFO,'er_site_name',PmagSiteRec['er_site_name'],'T') # fish out site information (lat/lon, etc.)
if len(sitedat)>0:
sitedat=sitedat[0]
PmagResRec['average_lat']=sitedat['site_lat']
PmagResRec['average_lon']=sitedat['site_lon']
else:
PmagResRec['average_lon']='UNKNOWN'
PmagResRec['average_lon']='UNKNOWN'
PmagResRec['magic_software_packages']=version_num
PmagResRec["pmag_result_name"]="V[A]DM: Site "+site
PmagResRec["result_description"]="V[A]DM of site"
PmagResRec["pmag_criteria_codes"]="ACCEPT"
if agefile != "": PmagResRec= pmag.get_age(PmagResRec,"er_site_names","average_",AgeNFO,DefaultAge)
site_height=pmag.get_dictitem(height_nfo,'er_site_name',site,'T')
if len(site_height)>0:PmagResRec["average_height"]=site_height[0]['site_height']
PmagSites.append(PmagSiteRec)
PmagResults.append(PmagResRec)
if len(PmagSites)>0:
Tmp,keylist=pmag.fillkeys(PmagSites)
pmag.magic_write(siteout,Tmp,'pmag_sites')
print(' sites written to ',siteout)
else: print("No Site level table")
if len(PmagResults)>0:
TmpRes,keylist=pmag.fillkeys(PmagResults)
pmag.magic_write(resout,TmpRes,'pmag_results')
print(' results written to ',resout)
else: print("No Results level table")
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)
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'
azimuth_key = 'azimuth'
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
con = cb.Contribution()
con.propagate_location_to_measurements()
con.propagate_location_to_specimens()
con.propagate_location_to_samples()
if not 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 con.tables:
if 'id' in con.tables['contribution'].df.columns:
con_id = 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 con.ancestry:
if table in 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 con.tables[lowest_table].df.columns:
if 'locations' not in 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(con.tables[lowest_table].df['location'].isnull()):
locs = con.tables['locations'].df.index.unique()
lowest_locs = 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'] = con.tables.get('measurements', None)
all_data['specimens'] = con.tables.get('specimens', None)
all_data['samples'] = con.tables.get('samples', None)
all_data['sites'] = con.tables.get('sites', None)
all_data['locations'] = con.tables.get('locations', None)
if 'locations' in con.tables:
locations = 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
meas_data = get_data('measurements', loc)
spec_data = get_data('specimens', loc)
samp_data = get_data('samples', loc)
site_data = get_data('sites', loc)
loc_data = get_data('locations', loc)
if loc == "./": # if you can't sort by location, do everything together
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 samp_file in filelist and samp_data: # find coordinate systems
samps = samp_data
file_type = "samples"
# get all non blank sample orientations
Srecs = pmag.get_dictitem(samps, azimuth_key, '', 'F')
if len(Srecs) > 0:
crd = 'g'
print('using geographic coordinates')
else:
print('using specimen coordinates')
else:
if VERBOSE:
print('-I- No sample data found')
if meas_file in filelist and meas_data: # start with measurement data
print('working on 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"
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# 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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# 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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# equal area plots of directional data
# at measurment 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
print(CMD)
os.system(CMD)
info_log(CMD, loc, "eqarea_magic.py")
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'
elif len(SiteDIs_g) > 0:
CRD = ' -crd g'
elif len(SiteDIs_s) > 0:
CRD = ' -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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
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'
print(CMD)
info_log(CMD, loc, 'vgpmap_magic.py')
os.system(CMD)
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")
with open('intensities.txt', 'w') as out:
for rec in Selection:
if rec != 0:
out.write(str(rec * 1e6) + "\n")
loc = loc.replace(" ", "_")
if loc == "./":
loc_name = ""
else:
loc_name = loc
histfile = 'LO:_' + loc_name + \
'_TY:_intensities_histogram:_.' + fmt
# maybe run histplot.main here instead, so you can return an error message
CMD = "histplot.py -twin -b 1 -xlab 'Intensity (uT)' -sav -f intensities.txt -F " + histfile
os.system(CMD)
info_log(CMD, loc)
print(CMD)
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 = 'dayplot_magic.py -f tmp_specimens.txt -sav -fmt ' + fmt
info_log(CMD, loc)
print(CMD)
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)
CRD = ""
CMD = 'aniso_magic.py -x -B -sav -fmt ' + fmt + " -new"
if len(sdata) > 3:
CMD = CMD + ' -crd s'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
if len(gdata) > 3:
CMD = CMD + ' -crd g'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
if len(tdata) > 3:
CMD = CMD + ' -crd t'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# remove temporary files
for fname in glob.glob('tmp*.txt'):
os.remove(fname)
try:
os.remove('intensities.txt')
except FileNotFoundError:
pass
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'
print(CMD)
info_log(CMD, "all locations", "polemap_magic.py")
os.system(CMD)
else:
print('-I- No poles found')
thumbnails.make_thumbnails(dir_path)
def main():
"""
NAME
lowrie_magic.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie_magic.py -h [command line options]
INPUT
takes measurements formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is magic_measurements.txt
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav saves plots and quits
-DM [2, 3] MagIC data model number
"""
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if len(sys.argv) <= 1:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
FIG = {} # plot dictionary
FIG['lowrie'] = 1 # demag is figure 1
pmagplotlib.plot_init(FIG['lowrie'], 6, 6)
norm = 1 # default is to normalize by maximum axis
in_file = pmag.get_named_arg("-f", "measurements.txt")
dir_path = pmag.get_named_arg("-WD", ".")
in_file = pmag.resolve_file_name(in_file, dir_path)
data_model = pmag.get_named_arg("-DM", 3)
data_model = int(float(data_model))
fmt = pmag.get_named_arg("-fmt", "svg")
if '-N' in sys.argv:
norm = 0 # don't normalize
if '-sav' in sys.argv:
plot = 1 # silently save and quit
else:
plot = 0 # generate plots
print(in_file)
# read in data
PmagRecs, file_type = pmag.magic_read(in_file)
if data_model == 2 and file_type != "magic_measurements":
print('bad input file', file_type)
sys.exit()
if data_model == 3 and file_type != "measurements":
print('bad input file', file_type)
sys.exit()
if data_model == 2:
meth_code_col = 'magic_method_codes'
spec_col = 'er_specimen_name'
dec_col = "measurement_dec"
inc_col = 'measurement_inc'
moment_col = 'measurement_magn_moment'
temp_col = 'treatment_temp'
else:
meth_code_col = 'method_codes'
spec_col = 'specimen'
dec_col = 'dir_dec'
inc_col = 'dir_inc'
moment_col = 'magn_moment'
temp_col = "treat_temp"
PmagRecs = pmag.get_dictitem(
PmagRecs, meth_code_col, 'LP-IRM-3D', 'has') # get all 3D IRM records
if len(PmagRecs) == 0:
print('no records found with the method code LP-IRM-3D')
sys.exit()
specs = pmag.get_dictkey(PmagRecs, spec_col, '')
sids = []
for spec in specs:
if spec not in sids:
sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print(spc)
specdata = pmag.get_dictitem(
PmagRecs, spec_col, spc, 'T') # get all this one's data
DIMs, Temps = [], []
for dat in specdata: # step through the data
DIMs.append([float(dat[dec_col]), float(
dat[inc_col]), float(dat[moment_col])])
Temps.append(float(dat[temp_col])-273.)
carts = pmag.dir2cart(DIMs).transpose()
if norm == 1: # want to normalize
nrm = (DIMs[0][2]) # normalize by NRM
ylab = "M/M_o"
else:
nrm = 1. # don't normalize
ylab = "Magnetic moment (Am^2)"
xlab = "Temperature (C)"
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[0]) / nrm, sym='r-')
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[0]) / nrm, sym='ro') # X direction
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[1]) / nrm, sym='c-')
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[1]) / nrm, sym='cs') # Y direction
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[2]) / nrm, sym='k-')
pmagplotlib.plot_xy(FIG['lowrie'], Temps, abs(carts[2]) / nrm, sym='k^', title=spc, xlab=xlab, ylab=ylab) # Z direction
files = {'lowrie': 'lowrie:_'+spc+'_.'+fmt}
if plot == 0:
pmagplotlib.draw_figs(FIG)
ans = input('S[a]ve figure? [q]uit, <return> to continue ')
if ans == 'a':
pmagplotlib.save_plots(FIG, files)
elif ans == 'q':
sys.exit()
else:
pmagplotlib.save_plots(FIG, files)
pmagplotlib.clearFIG(FIG['lowrie'])
def main():
"""
NAME
sites_locations.py
DESCRIPTION
reads in er_sites.txt file and finds all locations and bounds of locations
outputs er_locations.txt file
SYNTAX
sites_locations.py [command line options]
OPTIONS
-h prints help message and quits
-f: specimen input er_sites format file, default is "er_sites.txt"
-F: locations table: default is "er_locations.txt"
"""
# set defaults
site_file="er_sites.txt"
loc_file="er_locations.txt"
Names,user=[],"unknown"
Done=[]
version_num=pmag.get_version()
args=sys.argv
dir_path='.'
# get command line stuff
if '-WD' in args:
ind=args.index("-WD")
dir_path=args[ind+1]
if "-h" in args:
print(main.__doc__)
sys.exit()
if '-f' in args:
ind=args.index("-f")
site_file=args[ind+1]
if '-F' in args:
ind=args.index("-F")
loc_file=args[ind+1]
#
site_file=dir_path+'/'+site_file
loc_file=dir_path+'/'+loc_file
Sites,file_type=pmag.magic_read(site_file)
if file_type != 'er_sites':
print(file_type)
print(file_type,"This is not a valid er_sites file ")
sys.exit()
# read in site data
#
LocNames,Locations=[],[]
for site in Sites:
if site['er_location_name'] not in LocNames: # new location name
LocNames.append(site['er_location_name'])
sites_locs=pmag.get_dictitem(Sites,'er_location_name',site['er_location_name'],'T') # get all sites for this loc
lats=pmag.get_dictkey(sites_locs,'site_lat','f') # get all the latitudes as floats
lons=pmag.get_dictkey(sites_locs,'site_lon','f') # get all the longitudes as floats
LocRec={'er_citation_names':'This study','er_location_name':site['er_location_name'],'location_type':''}
LocRec['location_begin_lat']=str(min(lats))
LocRec['location_end_lat']=str(max(lats))
LocRec['location_begin_lon']=str(min(lons))
LocRec['location_end_lon']=str(max(lons))
Locations.append(LocRec)
if len(Locations)>0:
pmag.magic_write(loc_file,Locations,"er_locations")
print("Locations written to: ",loc_file)
def main():
"""
NAME
aniso_magic.py
DESCRIPTION
plots anisotropy data with either bootstrap or hext ellipses
SYNTAX
aniso_magic.py [-h] [command line options]
OPTIONS
-h plots help message and quits
-usr USER: set the user name
-f AFILE, specify rmag_anisotropy formatted file for input
-F RFILE, specify rmag_results formatted file for output
-x Hext [1963] and bootstrap
-B DON'T do bootstrap, do Hext
-par Tauxe [1998] parametric bootstrap
-v plot bootstrap eigenvectors instead of ellipses
-sit plot by site instead of entire file
-crd [s,g,t] coordinate system, default is specimen (g=geographic, t=tilt corrected)
-P don't make any plots - just make rmag_results table
-sav don't make the rmag_results table - just save all the plots
-fmt [svg, jpg, eps] format for output images, pdf default
-gtc DEC INC dec,inc of pole to great circle [down(up) in green (cyan)
-d Vi DEC INC; Vi (1,2,3) to compare to direction DEC INC
-n N; specifies the number of bootstraps - default is 1000
DEFAULTS
AFILE: rmag_anisotropy.txt
RFILE: rmag_results.txt
plot bootstrap ellipses of Constable & Tauxe [1987]
NOTES
minor axis: circles
major axis: triangles
principal axis: squares
directions are plotted on the lower hemisphere
for bootstrapped eigenvector components: Xs: blue, Ys: red, Zs: black
"""
#
dir_path = "."
version_num = pmag.get_version()
verbose = pmagplotlib.verbose
args = sys.argv
ipar, ihext, ivec, iboot, imeas, isite, iplot, vec = 0, 0, 0, 1, 1, 0, 1, 0
hpars, bpars, PDir = [], [], []
CS, crd = '-1', 's'
nb = 1000
fmt = 'pdf'
ResRecs = []
orlist = []
outfile, comp, Dir, gtcirc, PDir = 'rmag_results.txt', 0, [], 0, []
infile = 'rmag_anisotropy.txt'
if "-h" in args:
print(main.__doc__)
sys.exit()
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind+1]
if '-n' in args:
ind = args.index('-n')
nb = int(args[ind+1])
if '-usr' in args:
ind = args.index('-usr')
user = args[ind+1]
else:
user = ""
if '-B' in args:
iboot, ihext = 0, 1
if '-par' in args:
ipar = 1
if '-x' in args:
ihext = 1
if '-v' in args:
ivec = 1
if '-sit' in args:
isite = 1
if '-P' in args:
iplot = 0
if '-f' in args:
ind = args.index('-f')
infile = args[ind+1]
if '-F' in args:
ind = args.index('-F')
outfile = args[ind+1]
if '-crd' in sys.argv:
ind = sys.argv.index('-crd')
crd = sys.argv[ind+1]
if crd == 'g':
CS = '0'
if crd == 't':
CS = '100'
if '-fmt' in args:
ind = args.index('-fmt')
fmt = args[ind+1]
if '-sav' in args:
plots = 1
verbose = 0
else:
plots = 0
if '-gtc' in args:
ind = args.index('-gtc')
d, i = float(args[ind+1]), float(args[ind+2])
PDir.append(d)
PDir.append(i)
if '-d' in args:
comp = 1
ind = args.index('-d')
vec = int(args[ind+1])-1
Dir = [float(args[ind+2]), float(args[ind+3])]
#
# set up plots
#
if infile[0] != '/':
infile = dir_path+'/'+infile
if outfile[0] != '/':
outfile = dir_path+'/'+outfile
ANIS = {}
initcdf, inittcdf = 0, 0
ANIS['data'], ANIS['conf'] = 1, 2
if iboot == 1:
ANIS['tcdf'] = 3
if iplot == 1:
inittcdf = 1
pmagplotlib.plot_init(ANIS['tcdf'], 5, 5)
if comp == 1 and iplot == 1:
initcdf = 1
ANIS['vxcdf'], ANIS['vycdf'], ANIS['vzcdf'] = 4, 5, 6
pmagplotlib.plot_init(ANIS['vxcdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vycdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vzcdf'], 5, 5)
if iplot == 1:
pmagplotlib.plot_init(ANIS['conf'], 5, 5)
pmagplotlib.plot_init(ANIS['data'], 5, 5)
# read in the data
data, ifiletype = pmag.magic_read(infile)
for rec in data: # find all the orientation systems
if 'anisotropy_tilt_correction' not in rec.keys():
rec['anisotropy_tilt_correction'] = '-1'
if rec['anisotropy_tilt_correction'] not in orlist:
orlist.append(rec['anisotropy_tilt_correction'])
if CS not in orlist:
if len(orlist) > 0:
CS = orlist[0]
else:
CS = '-1'
if CS == '-1':
crd = 's'
if CS == '0':
crd = 'g'
if CS == '100':
crd = 't'
if verbose:
print("desired coordinate system not available, using available: ", crd)
if isite == 1:
sitelist = []
for rec in data:
if rec['er_site_name'] not in sitelist:
sitelist.append(rec['er_site_name'])
sitelist.sort()
plt = len(sitelist)
else:
plt = 1
k = 0
while k < plt:
site = ""
sdata, Ss = [], [] # list of S format data
Locs, Sites, Samples, Specimens, Cits = [], [], [], [], []
if isite == 0:
sdata = data
else:
site = sitelist[k]
for rec in data:
if rec['er_site_name'] == site:
sdata.append(rec)
anitypes = []
csrecs = pmag.get_dictitem(
sdata, 'anisotropy_tilt_correction', CS, 'T')
for rec in csrecs:
if rec['anisotropy_type'] not in anitypes:
anitypes.append(rec['anisotropy_type'])
if rec['er_location_name'] not in Locs:
Locs.append(rec['er_location_name'])
if rec['er_site_name'] not in Sites:
Sites.append(rec['er_site_name'])
if rec['er_sample_name'] not in Samples:
Samples.append(rec['er_sample_name'])
if rec['er_specimen_name'] not in Specimens:
Specimens.append(rec['er_specimen_name'])
if rec['er_citation_names'] not in Cits:
Cits.append(rec['er_citation_names'])
s = []
s.append(float(rec["anisotropy_s1"]))
s.append(float(rec["anisotropy_s2"]))
s.append(float(rec["anisotropy_s3"]))
s.append(float(rec["anisotropy_s4"]))
s.append(float(rec["anisotropy_s5"]))
s.append(float(rec["anisotropy_s6"]))
if s[0] <= 1.0:
Ss.append(s) # protect against crap
# tau,Vdirs=pmag.doseigs(s)
ResRec = {}
ResRec['er_location_names'] = rec['er_location_name']
ResRec['er_citation_names'] = rec['er_citation_names']
ResRec['er_site_names'] = rec['er_site_name']
ResRec['er_sample_names'] = rec['er_sample_name']
ResRec['er_specimen_names'] = rec['er_specimen_name']
ResRec['rmag_result_name'] = rec['er_specimen_name'] + \
":"+rec['anisotropy_type']
ResRec["er_analyst_mail_names"] = user
ResRec["tilt_correction"] = CS
ResRec["anisotropy_type"] = rec['anisotropy_type']
if "anisotropy_n" not in rec.keys():
rec["anisotropy_n"] = "6"
if "anisotropy_sigma" not in rec.keys():
rec["anisotropy_sigma"] = "0"
fpars = pmag.dohext(
int(rec["anisotropy_n"])-6, float(rec["anisotropy_sigma"]), s)
ResRec["anisotropy_v1_dec"] = '%7.1f' % (fpars['v1_dec'])
ResRec["anisotropy_v2_dec"] = '%7.1f' % (fpars['v2_dec'])
ResRec["anisotropy_v3_dec"] = '%7.1f' % (fpars['v3_dec'])
ResRec["anisotropy_v1_inc"] = '%7.1f' % (fpars['v1_inc'])
ResRec["anisotropy_v2_inc"] = '%7.1f' % (fpars['v2_inc'])
ResRec["anisotropy_v3_inc"] = '%7.1f' % (fpars['v3_inc'])
ResRec["anisotropy_t1"] = '%10.8f' % (fpars['t1'])
ResRec["anisotropy_t2"] = '%10.8f' % (fpars['t2'])
ResRec["anisotropy_t3"] = '%10.8f' % (fpars['t3'])
ResRec["anisotropy_ftest"] = '%10.3f' % (fpars['F'])
ResRec["anisotropy_ftest12"] = '%10.3f' % (fpars['F12'])
ResRec["anisotropy_ftest23"] = '%10.3f' % (fpars['F23'])
ResRec["result_description"] = 'F_crit: ' + \
fpars['F_crit']+'; F12,F23_crit: '+fpars['F12_crit']
ResRec['anisotropy_type'] = pmag.makelist(anitypes)
ResRecs.append(ResRec)
if len(Ss) > 1:
if pmagplotlib.isServer:
title = "LO:_"+ResRec['er_location_names'] + \
'_SI:_'+site+'_SA:__SP:__CO:_'+crd
else:
title = ResRec['er_location_names']
if site:
title += "_{}".format(site)
title += '_{}'.format(crd)
ResRec['er_location_names'] = pmag.makelist(Locs)
bpars, hpars = pmagplotlib.plot_anis(
ANIS, Ss, iboot, ihext, ivec, ipar, title, iplot, comp, vec, Dir, nb)
if len(PDir) > 0:
pmagplotlib.plot_circ(ANIS['data'], PDir, 90., 'g')
pmagplotlib.plot_circ(ANIS['conf'], PDir, 90., 'g')
if verbose and plots == 0:
pmagplotlib.draw_figs(ANIS)
ResRec['er_location_names'] = pmag.makelist(Locs)
if plots == 1:
save(ANIS, fmt, title)
ResRec = {}
ResRec['er_citation_names'] = pmag.makelist(Cits)
ResRec['er_location_names'] = pmag.makelist(Locs)
ResRec['er_site_names'] = pmag.makelist(Sites)
ResRec['er_sample_names'] = pmag.makelist(Samples)
ResRec['er_specimen_names'] = pmag.makelist(Specimens)
ResRec['rmag_result_name'] = pmag.makelist(
Sites)+":"+pmag.makelist(anitypes)
ResRec['anisotropy_type'] = pmag.makelist(anitypes)
ResRec["er_analyst_mail_names"] = user
ResRec["tilt_correction"] = CS
if isite == "0":
ResRec['result_description'] = "Study average using coordinate system: " + CS
if isite == "1":
ResRec['result_description'] = "Site average using coordinate system: " + CS
if hpars != [] and ihext == 1:
HextRec = {}
for key in ResRec.keys():
HextRec[key] = ResRec[key] # copy over stuff
HextRec["anisotropy_v1_dec"] = '%7.1f' % (hpars["v1_dec"])
HextRec["anisotropy_v2_dec"] = '%7.1f' % (hpars["v2_dec"])
HextRec["anisotropy_v3_dec"] = '%7.1f' % (hpars["v3_dec"])
HextRec["anisotropy_v1_inc"] = '%7.1f' % (hpars["v1_inc"])
HextRec["anisotropy_v2_inc"] = '%7.1f' % (hpars["v2_inc"])
HextRec["anisotropy_v3_inc"] = '%7.1f' % (hpars["v3_inc"])
HextRec["anisotropy_t1"] = '%10.8f' % (hpars["t1"])
HextRec["anisotropy_t2"] = '%10.8f' % (hpars["t2"])
HextRec["anisotropy_t3"] = '%10.8f' % (hpars["t3"])
HextRec["anisotropy_hext_F"] = '%7.1f ' % (hpars["F"])
HextRec["anisotropy_hext_F12"] = '%7.1f ' % (hpars["F12"])
HextRec["anisotropy_hext_F23"] = '%7.1f ' % (hpars["F23"])
HextRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (hpars["v2_dec"])
HextRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (hpars["v2_inc"])
HextRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars["e13"])
HextRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars["v3_dec"])
HextRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars["v3_inc"])
HextRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (hpars["v1_dec"])
HextRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (hpars["v1_inc"])
HextRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars["e23"])
HextRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars["v3_dec"])
HextRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars["v3_inc"])
HextRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (hpars["v1_dec"])
HextRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (hpars["v1_inc"])
HextRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars["e23"])
HextRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars["v2_dec"])
HextRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars["v2_inc"])
HextRec["magic_method_codes"] = 'LP-AN:AE-H'
if verbose:
print("Hext Statistics: ")
print(
" tau_i, V_i_D, V_i_I, V_i_zeta, V_i_zeta_D, V_i_zeta_I, V_i_eta, V_i_eta_D, V_i_eta_I")
print(HextRec["anisotropy_t1"], HextRec["anisotropy_v1_dec"], HextRec["anisotropy_v1_inc"], HextRec["anisotropy_v1_eta_semi_angle"], HextRec["anisotropy_v1_eta_dec"],
HextRec["anisotropy_v1_eta_inc"], HextRec["anisotropy_v1_zeta_semi_angle"], HextRec["anisotropy_v1_zeta_dec"], HextRec["anisotropy_v1_zeta_inc"])
print(HextRec["anisotropy_t2"], HextRec["anisotropy_v2_dec"], HextRec["anisotropy_v2_inc"], HextRec["anisotropy_v2_eta_semi_angle"], HextRec["anisotropy_v2_eta_dec"],
HextRec["anisotropy_v2_eta_inc"], HextRec["anisotropy_v2_zeta_semi_angle"], HextRec["anisotropy_v2_zeta_dec"], HextRec["anisotropy_v2_zeta_inc"])
print(HextRec["anisotropy_t3"], HextRec["anisotropy_v3_dec"], HextRec["anisotropy_v3_inc"], HextRec["anisotropy_v3_eta_semi_angle"], HextRec["anisotropy_v3_eta_dec"],
HextRec["anisotropy_v3_eta_inc"], HextRec["anisotropy_v3_zeta_semi_angle"], HextRec["anisotropy_v3_zeta_dec"], HextRec["anisotropy_v3_zeta_inc"])
HextRec['magic_software_packages'] = version_num
ResRecs.append(HextRec)
if bpars != []:
BootRec = {}
for key in ResRec.keys():
BootRec[key] = ResRec[key] # copy over stuff
BootRec["anisotropy_v1_dec"] = '%7.1f' % (bpars["v1_dec"])
BootRec["anisotropy_v2_dec"] = '%7.1f' % (bpars["v2_dec"])
BootRec["anisotropy_v3_dec"] = '%7.1f' % (bpars["v3_dec"])
BootRec["anisotropy_v1_inc"] = '%7.1f' % (bpars["v1_inc"])
BootRec["anisotropy_v2_inc"] = '%7.1f' % (bpars["v2_inc"])
BootRec["anisotropy_v3_inc"] = '%7.1f' % (bpars["v3_inc"])
BootRec["anisotropy_t1"] = '%10.8f' % (bpars["t1"])
BootRec["anisotropy_t2"] = '%10.8f' % (bpars["t2"])
BootRec["anisotropy_t3"] = '%10.8f' % (bpars["t3"])
BootRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
bpars["v1_eta_inc"])
BootRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
bpars["v1_eta_dec"])
BootRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
bpars["v1_eta"])
BootRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
bpars["v1_zeta_inc"])
BootRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
bpars["v1_zeta_dec"])
BootRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
bpars["v1_zeta"])
BootRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
bpars["v2_eta_inc"])
BootRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
bpars["v2_eta_dec"])
BootRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
bpars["v2_eta"])
BootRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
bpars["v2_zeta_inc"])
BootRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
bpars["v2_zeta_dec"])
BootRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
bpars["v2_zeta"])
BootRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
bpars["v3_eta_inc"])
BootRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
bpars["v3_eta_dec"])
BootRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
bpars["v3_eta"])
BootRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
bpars["v3_zeta_inc"])
BootRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
bpars["v3_zeta_dec"])
BootRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
bpars["v3_zeta"])
BootRec["anisotropy_hext_F"] = ''
BootRec["anisotropy_hext_F12"] = ''
BootRec["anisotropy_hext_F23"] = ''
# regular bootstrap
BootRec["magic_method_codes"] = 'LP-AN:AE-H:AE-BS'
if ipar == 1:
# parametric bootstrap
BootRec["magic_method_codes"] = 'LP-AN:AE-H:AE-BS-P'
if verbose:
print("Boostrap Statistics: ")
print(
" tau_i, V_i_D, V_i_I, V_i_zeta, V_i_zeta_D, V_i_zeta_I, V_i_eta, V_i_eta_D, V_i_eta_I")
print(BootRec["anisotropy_t1"], BootRec["anisotropy_v1_dec"], BootRec["anisotropy_v1_inc"], BootRec["anisotropy_v1_eta_semi_angle"], BootRec["anisotropy_v1_eta_dec"],
BootRec["anisotropy_v1_eta_inc"], BootRec["anisotropy_v1_zeta_semi_angle"], BootRec["anisotropy_v1_zeta_dec"], BootRec["anisotropy_v1_zeta_inc"])
print(BootRec["anisotropy_t2"], BootRec["anisotropy_v2_dec"], BootRec["anisotropy_v2_inc"], BootRec["anisotropy_v2_eta_semi_angle"], BootRec["anisotropy_v2_eta_dec"],
BootRec["anisotropy_v2_eta_inc"], BootRec["anisotropy_v2_zeta_semi_angle"], BootRec["anisotropy_v2_zeta_dec"], BootRec["anisotropy_v2_zeta_inc"])
print(BootRec["anisotropy_t3"], BootRec["anisotropy_v3_dec"], BootRec["anisotropy_v3_inc"], BootRec["anisotropy_v3_eta_semi_angle"], BootRec["anisotropy_v3_eta_dec"],
BootRec["anisotropy_v3_eta_inc"], BootRec["anisotropy_v3_zeta_semi_angle"], BootRec["anisotropy_v3_zeta_dec"], BootRec["anisotropy_v3_zeta_inc"])
BootRec['magic_software_packages'] = version_num
ResRecs.append(BootRec)
k += 1
goon = 1
while goon == 1 and iplot == 1 and verbose:
if iboot == 1:
print("compare with [d]irection ")
print(
" plot [g]reat circle, change [c]oord. system, change [e]llipse calculation, s[a]ve plots, [q]uit ")
if isite == 1:
print(" [p]revious, [s]ite, [q]uit, <return> for next ")
ans = input("")
if ans == "q":
sys.exit()
if ans == "e":
iboot, ipar, ihext, ivec = 1, 0, 0, 0
e = input("Do Hext Statistics 1/[0]: ")
if e == "1":
ihext = 1
e = input("Suppress bootstrap 1/[0]: ")
if e == "1":
iboot = 0
if iboot == 1:
e = input("Parametric bootstrap 1/[0]: ")
if e == "1":
ipar = 1
e = input("Plot bootstrap eigenvectors: 1/[0]: ")
if e == "1":
ivec = 1
if iplot == 1:
if inittcdf == 0:
ANIS['tcdf'] = 3
pmagplotlib.plot_init(ANIS['tcdf'], 5, 5)
inittcdf = 1
bpars, hpars = pmagplotlib.plot_anis(
ANIS, Ss, iboot, ihext, ivec, ipar, title, iplot, comp, vec, Dir, nb)
if verbose and plots == 0:
pmagplotlib.draw_figs(ANIS)
if ans == "c":
print("Current Coordinate system is: ")
if CS == '-1':
print(" Specimen")
if CS == '0':
print(" Geographic")
if CS == '100':
print(" Tilt corrected")
key = input(
" Enter desired coordinate system: [s]pecimen, [g]eographic, [t]ilt corrected ")
if key == 's':
CS = '-1'
if key == 'g':
CS = '0'
if key == 't':
CS = '100'
if CS not in orlist:
if len(orlist) > 0:
CS = orlist[0]
else:
CS = '-1'
if CS == '-1':
crd = 's'
if CS == '0':
crd = 'g'
if CS == '100':
crd = 't'
print(
"desired coordinate system not available, using available: ", crd)
k -= 1
goon = 0
if ans == "":
if isite == 1:
goon = 0
else:
print("Good bye ")
sys.exit()
if ans == 'd':
if initcdf == 0:
initcdf = 1
ANIS['vxcdf'], ANIS['vycdf'], ANIS['vzcdf'] = 4, 5, 6
pmagplotlib.plot_init(ANIS['vxcdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vycdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vzcdf'], 5, 5)
Dir, comp = [], 1
print("""
Input: Vi D I to compare eigenvector Vi with direction D/I
where Vi=1: principal
Vi=2: major
Vi=3: minor
D= declination of comparison direction
I= inclination of comparison direction""")
con = 1
while con == 1:
try:
vdi = input("Vi D I: ").split()
vec = int(vdi[0])-1
Dir = [float(vdi[1]), float(vdi[2])]
con = 0
except IndexError:
print(" Incorrect entry, try again ")
bpars, hpars = pmagplotlib.plot_anis(
ANIS, Ss, iboot, ihext, ivec, ipar, title, iplot, comp, vec, Dir, nb)
Dir, comp = [], 0
if ans == 'g':
con, cnt = 1, 0
while con == 1:
try:
print(
" Input: input pole to great circle ( D I) to plot a great circle: ")
di = input(" D I: ").split()
PDir.append(float(di[0]))
PDir.append(float(di[1]))
con = 0
except:
cnt += 1
if cnt < 10:
print(
" enter the dec and inc of the pole on one line ")
else:
print(
"ummm - you are doing something wrong - i give up")
sys.exit()
pmagplotlib.plot_circ(ANIS['data'], PDir, 90., 'g')
pmagplotlib.plot_circ(ANIS['conf'], PDir, 90., 'g')
if verbose and plots == 0:
pmagplotlib.draw_figs(ANIS)
if ans == "p":
k -= 2
goon = 0
if ans == "q":
k = plt
goon = 0
if ans == "s":
keepon = 1
site = input(" print site or part of site desired: ")
while keepon == 1:
try:
k = sitelist.index(site)
keepon = 0
except:
tmplist = []
for qq in range(len(sitelist)):
if site in sitelist[qq]:
tmplist.append(sitelist[qq])
print(site, " not found, but this was: ")
print(tmplist)
site = input('Select one or try again\n ')
k = sitelist.index(site)
goon, ans = 0, ""
if ans == "a":
locs = pmag.makelist(Locs)
if pmagplotlib.isServer: # use server plot naming convention
title = "LO:_"+locs+'_SI:__'+'_SA:__SP:__CO:_'+crd
else: # use more readable plot naming convention
title = "{}_{}".format(locs, crd)
save(ANIS, fmt, title)
goon = 0
else:
if verbose:
print('skipping plot - not enough data points')
k += 1
# put rmag_results stuff here
if len(ResRecs) > 0:
ResOut, keylist = pmag.fillkeys(ResRecs)
pmag.magic_write(outfile, ResOut, 'rmag_results')
if verbose:
print(" Good bye ")
def main():
"""
NAME
vgpmap_magic.py
DESCRIPTION
makes a map of vgps and a95/dp,dm for site means in a pmag_results table
SYNTAX
vgpmap_magic.py [command line options]
OPTIONS
-h prints help and quits
-eye ELAT ELON [specify eyeball location], default is 90., 0.
-f FILE pmag_results format file, [default is pmag_results.txt]
-res [c,l,i,h] specify resolution (crude, low, intermediate, high]
-etp plot the etopo20 topographpy data (requires high resolution data set)
-prj PROJ, specify one of the following:
ortho = orthographic
lcc = lambert conformal
moll = molweide
merc = mercator
-sym SYM SIZE: choose a symbol and size, examples:
ro 5 : small red circles
bs 10 : intermediate blue squares
g^ 20 : large green triangles
-ell plot dp/dm or a95 ellipses
-rev RSYM RSIZE : flip reverse poles to normal antipode
-S: plot antipodes of all poles
-age : plot the ages next to the poles
-crd [g,t] : choose coordinate system, default is to plot all site VGPs
-fmt [pdf, png, eps...] specify output format, default is pdf
-sav save and quit
DEFAULTS
FILE: pmag_results.txt
res: c
prj: ortho
ELAT,ELON = 0,0
SYM SIZE: ro 8
RSYM RSIZE: g^ 8
"""
dir_path = '.'
res, ages = 'c', 0
plot = 0
proj = 'ortho'
results_file = 'pmag_results.txt'
ell, flip = 0, 0
lat_0, lon_0 = 90., 0.
fmt = 'pdf'
sym, size = 'ro', 8
rsym, rsize = 'g^', 8
anti = 0
fancy = 0
coord = ""
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-S' in sys.argv: anti = 1
if '-fmt' in sys.argv:
ind = sys.argv.index('-fmt')
fmt = sys.argv[ind + 1]
if '-sav' in sys.argv: plot = 1
if '-res' in sys.argv:
ind = sys.argv.index('-res')
res = sys.argv[ind + 1]
if '-etp' in sys.argv: fancy = 1
if '-prj' in sys.argv:
ind = sys.argv.index('-prj')
proj = sys.argv[ind + 1]
if '-rev' in sys.argv:
flip = 1
ind = sys.argv.index('-rev')
rsym = (sys.argv[ind + 1])
rsize = int(sys.argv[ind + 2])
if '-sym' in sys.argv:
ind = sys.argv.index('-sym')
sym = (sys.argv[ind + 1])
size = int(sys.argv[ind + 2])
if '-eye' in sys.argv:
ind = sys.argv.index('-eye')
lat_0 = float(sys.argv[ind + 1])
lon_0 = float(sys.argv[ind + 2])
if '-ell' in sys.argv: ell = 1
if '-age' in sys.argv: ages = 1
if '-f' in sys.argv:
ind = sys.argv.index('-f')
results_file = sys.argv[ind + 1]
if '-crd' in sys.argv:
ind = sys.argv.index('-crd')
crd = sys.argv[ind + 1]
if crd == 'g': coord = '0'
if crd == 't': coord = '100'
results_file = dir_path + '/' + results_file
data, file_type = pmag.magic_read(results_file)
if file_type != 'pmag_results':
print "bad results file"
sys.exit()
FIG = {'map': 1}
pmagplotlib.plot_init(FIG['map'], 6, 6)
# read in er_sites file
lats, lons, dp, dm, a95 = [], [], [], [], []
Pars = []
dates, rlats, rlons = [], [], []
if 'data_type' in data[0].keys():
Results = pmag.get_dictitem(data, 'data_type', 'i',
'T') # get all site level data
else:
Results = data
Results = pmag.get_dictitem(Results, 'vgp_lat', '',
'F') # get all non-blank latitudes
Results = pmag.get_dictitem(Results, 'vgp_lon', '',
'F') # get all non-blank longitudes
if coord != "":
Results = pmag.get_dictitem(Results, 'tilt_correction', coord,
'T') # get specified coordinate system
location = ""
for rec in Results:
if rec['er_location_names'] not in location:
location = location + ':' + rec['er_location_names']
if 'average_age' in rec.keys(
) and rec['average_age'] != "" and ages == 1:
dates.append(rec['average_age'])
lat = float(rec['vgp_lat'])
lon = float(rec['vgp_lon'])
if flip == 0:
lats.append(lat)
lons.append(lon)
elif flip == 1:
if lat < 0:
rlats.append(-lat)
lon = lon + 180.
if lon > 360: lon = lon - 360.
rlons.append(lon)
else:
lats.append(lat)
lons.append(lon)
elif anti == 1:
lats.append(-lat)
lon = lon + 180.
if lon > 360: lon = lon - 360.
lons.append(lon)
ppars = []
ppars.append(lon)
ppars.append(lat)
ell1, ell2 = "", ""
if 'vgp_dm' in rec.keys() and rec['vgp_dm'] != "":
ell1 = float(rec['vgp_dm'])
if 'vgp_dp' in rec.keys() and rec['vgp_dp'] != "":
ell2 = float(rec['vgp_dp'])
if 'vgp_alpha95' in rec.keys() and rec['vgp_alpha95'] != "":
ell1, ell2 = float(rec['vgp_alpha95']), float(rec['vgp_alpha95'])
if ell1 != "" and ell2 != "":
ppars = []
ppars.append(lons[-1])
ppars.append(lats[-1])
ppars.append(ell1)
ppars.append(lons[-1])
isign = abs(lats[-1]) / lats[-1]
ppars.append(lats[-1] - isign * 90.)
ppars.append(ell2)
ppars.append(lons[-1] + 90.)
ppars.append(0.)
Pars.append(ppars)
location = location.strip(':')
Opts = {
'latmin': -90,
'latmax': 90,
'lonmin': 0.,
'lonmax': 360.,
'lat_0': lat_0,
'lon_0': lon_0,
'proj': proj,
'sym': 'bs',
'symsize': 3,
'pltgrid': 0,
'res': res,
'boundinglat': 0.
}
Opts['details'] = {
'coasts': 1,
'rivers': 0,
'states': 0,
'countries': 0,
'ocean': 1,
'fancy': fancy
}
pmagplotlib.plotMAP(
FIG['map'], [90.], [0.],
Opts) # make the base map with a blue triangle at the pole`
Opts['pltgrid'] = -1
Opts['sym'] = sym
Opts['symsize'] = size
if len(dates) > 0: Opts['names'] = dates
if len(lats) > 0:
pmagplotlib.plotMAP(FIG['map'], lats, lons,
Opts) # add the lats and lons of the poles
Opts['names'] = []
if len(rlats) > 0:
Opts['sym'] = rsym
Opts['symsize'] = rsize
pmagplotlib.plotMAP(FIG['map'], rlats, rlons,
Opts) # add the lats and lons of the poles
if plot == 0:
pmagplotlib.drawFIGS(FIG)
if ell == 1: # add ellipses if desired.
Opts['details'] = {
'coasts': 0,
'rivers': 0,
'states': 0,
'countries': 0,
'ocean': 0
}
Opts['pltgrid'] = -1 # turn off meridian replotting
Opts['symsize'] = 2
Opts['sym'] = 'g-'
for ppars in Pars:
if ppars[2] != 0:
PTS = pmagplotlib.plotELL(FIG['map'], ppars, 'g.', 0, 0)
elats, elons = [], []
for pt in PTS:
elons.append(pt[0])
elats.append(pt[1])
pmagplotlib.plotMAP(
FIG['map'], elats, elons, Opts
) # make the base map with a blue triangle at the pole`
if plot == 0: pmagplotlib.drawFIGS(FIG)
files = {}
for key in FIG.keys():
files[key] = 'LO:_' + location + '_VGP_map.' + fmt
if pmagplotlib.isServer:
black = '#000000'
purple = '#800080'
titles = {}
titles['eq'] = 'LO:_' + location + '_VGP_map'
FIG = pmagplotlib.addBorders(FIG, titles, black, purple)
pmagplotlib.saveP(FIG, files)
elif plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = raw_input(" S[a]ve to save plot, Return to quit: ")
if ans == "a":
pmagplotlib.saveP(FIG, files)
else:
print "Good bye"
sys.exit()
else:
pmagplotlib.saveP(FIG, files)
def main():
"""
NAME
irmaq_magic.py
DESCRIPTION
plots IRM acquisition curves from magic_measurements file
SYNTAX
irmaq_magic [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-N ; do not normalize by last point - use original units
-fmt [png,jpg,eps,pdf] set plot file format [default is svg]
-sav save plot[s] and quit
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG={} # plot dictionary
FIG['exp']=1 # exp is figure 1
dir_path='./'
plot,fmt=0,'svg'
units,dmag_key='T','treatment_dc_field'
XLP=[]
norm=1
in_file,plot_key,LP='magic_measurements.txt','er_location_name',"LP-IRM"
if len(sys.argv)>1:
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-N' in sys.argv:norm=0
if '-sav' in sys.argv:plot=1
if '-fmt' in sys.argv:
ind=sys.argv.index("-fmt")
fmt=sys.argv[ind+1]
if '-f' in sys.argv:
ind=sys.argv.index("-f")
in_file=sys.argv[ind+1]
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
in_file=dir_path+'/'+in_file
if '-obj' in sys.argv:
ind=sys.argv.index('-obj')
plot_by=sys.argv[ind+1]
if plot_by=='sit':plot_key='er_site_name'
if plot_by=='sam':plot_key='er_sample_name'
if plot_by=='spc':plot_key='er_specimen_name'
data,file_type=pmag.magic_read(in_file)
sids=pmag.get_specs(data)
pmagplotlib.plot_init(FIG['exp'],6,6)
#
#
# find desired intensity data
#
# get plotlist
#
plotlist,intlist=[],['measurement_magnitude','measurement_magn_moment','measurement_magn_volume','measurement_magn_mass']
IntMeths=[]
data=pmag.get_dictitem(data,'magic_method_codes',LP,'has') # get all the records with this lab protocol
Ints={}
NoInts,int_key=1,""
for key in intlist:
Ints[key]=pmag.get_dictitem(data,key,'','F') # get all non-blank data for intensity type
if len(Ints[key])>0:
NoInts=0
if int_key=="":int_key=key
if NoInts==1:
print 'No intensity information found'
sys.exit()
for rec in Ints[int_key]:
if rec[plot_key] not in plotlist: plotlist.append(rec[plot_key])
plotlist.sort()
for plt in plotlist:
print plt
INTblock=[]
data=pmag.get_dictitem(Ints[int_key],plot_key,plt,'T') # get data with right intensity info whose plot_key matches plot
sids=pmag.get_specs(data) # get a list of specimens with appropriate data
if len(sids)>0:
title=data[0][plot_key]
for s in sids:
INTblock=[]
sdata=pmag.get_dictitem(data,'er_specimen_name',s,'T') # get data for each specimen
for rec in sdata:
INTblock.append([float(rec[dmag_key]),0,0,float(rec[int_key]),1,'g'])
pmagplotlib.plotMT(FIG['exp'],INTblock,title,0,units,norm)
files={}
for key in FIG.keys():
files[key]=title+'_'+LP+'.'+fmt
if plot==0:
pmagplotlib.drawFIGS(FIG)
ans=raw_input(" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans=='q':sys.exit()
if ans=="a":
pmagplotlib.saveP(FIG,files)
else:
pmagplotlib.saveP(FIG,files)
pmagplotlib.clearFIG(FIG['exp'])
def convert(**kwargs):
# initialize some stuff
methcode="LP-NO"
phi,theta,peakfield,labfield=0,0,0,0
pTRM,MD=0,0
dec=[315,225,180,135,45,90,270,270,270,90,180,180,0,0,0]
inc=[0,0,0,0,0,-45,-45,0,45,45,45,-45,-90,-45,45]
tdec=[0,90,0,180,270,0,0,90,0]
tinc=[0,0,90,0,0,-90,0,0,90]
missing=1
demag="N"
citations='This study'
fmt='old'
Samps=[]
trm=0
irm=0
#get args
user = kwargs.get('user', '')
dir_path = kwargs.get('dir_path', '.')
output_dir_path = dir_path
meas_file = kwargs.get('meas_file', 'measurements.txt')
spec_file = kwargs.get('spec_file', 'specimens.txt') # specimen outfile
samp_file = kwargs.get('samp_file', 'samples.txt') # sample outfile
site_file = kwargs.get('site_file', 'sites.txt') # site outfile
loc_file = kwargs.get('loc_file', 'locations.txt') # location outfile
mag_file = kwargs.get('mag_file', '')
labfield = kwargs.get('labfield', '')
if labfield:
labfield = float(labfield) *1e-6
else:
labfield = 0
phi = kwargs.get('phi', 0)
if phi:
phi = float(phi)
else:
phi = 0
theta = kwargs.get('theta', 0)
if theta:
theta=float(theta)
else:
theta = 0
peakfield = kwargs.get('peakfield', 0)
if peakfield:
peakfield=float(peakfield) *1e-3
else:
peakfield = 0
specnum = kwargs.get('specnum', 0)
samp_con = kwargs.get('samp_con', '1')
location = kwargs.get('location', 'unknown')
samp_infile = kwargs.get('samp_infile', '')
syn = kwargs.get('syn', 0)
institution = kwargs.get('institution', '')
syntype = kwargs.get('syntype', '')
inst = kwargs.get('inst', '')
noave = kwargs.get('noave', 0)
codelist = kwargs.get('codelist', '')
coil = kwargs.get('coil', '')
cooling_rates = kwargs.get('cooling_rates', '')
lat = kwargs.get('lat', '')
lon = kwargs.get('lon', '')
timezone = kwargs.get('timezone', 'UTC')
# make sure all initial values are correctly set up (whether they come from the command line or a GUI)
if samp_infile:
Samps, file_type = pmag.magic_read(samp_infile)
if coil:
coil = str(coil)
methcode="LP-IRM"
irmunits = "V"
if coil not in ["1","2","3"]:
print(__doc__)
print('not a valid coil specification')
return False, '{} is not a valid coil specification'.format(coil)
if mag_file:
lines = pmag.open_file(mag_file)
if not lines:
print("you must provide a valid mag_file")
return False, "you must provide a valid mag_file"
if not mag_file:
print(__doc__)
print("mag_file field is required option")
return False, "mag_file field is required option"
if specnum!=0:
specnum=-specnum
if "4" == samp_con[0]:
if "-" not in samp_con:
print("naming convention option [4] must be in form 4-Z where Z is an integer")
print('---------------')
return False, "naming convention option [4] must be in form 4-Z where Z is an integer"
else:
Z=samp_con.split("-")[1]
samp_con="4"
if "7" == samp_con[0]:
if "-" not in samp_con:
print("option [7] must be in form 7-Z where Z is an integer")
return False, "option [7] must be in form 7-Z where Z is an integer"
else:
Z=samp_con.split("-")[1]
samp_con="7"
else: Z = 0
if codelist:
codes=codelist.split(':')
if "AF" in codes:
demag='AF'
if'-dc' not in sys.argv: methcode="LT-AF-Z"
if'-dc' in sys.argv: methcode="LT-AF-I"
if "T" in codes:
demag="T"
if '-dc' not in sys.argv: methcode="LT-T-Z"
if '-dc' in sys.argv: methcode="LT-T-I"
if "I" in codes:
methcode="LP-IRM"
irmunits="mT"
if "I3d" in codes:
methcode="LT-T-Z:LP-IRM-3D"
if "S" in codes:
demag="S"
methcode="LP-PI-TRM:LP-PI-ALT-AFARM"
trm_labfield=labfield
ans=input("DC lab field for ARM step: [50uT] ")
if ans=="":
arm_labfield=50e-6
else:
arm_labfield=float(ans)*1e-6
ans=input("temperature for total trm step: [600 C] ")
if ans=="":
trm_peakT=600+273 # convert to kelvin
else:
trm_peakT=float(ans)+273 # convert to kelvin
if "G" in codes: methcode="LT-AF-G"
if "D" in codes: methcode="LT-AF-D"
if "TRM" in codes:
demag="T"
trm=1
if "CR" in codes:
demag="T"
cooling_rate_experiment=1
if command_line:
ind=sys.argv.index("CR")
cooling_rates=sys.argv[ind+1]
cooling_rates_list=cooling_rates.split(',')
else:
cooling_rates_list=str(cooling_rates).split(',')
if demag=="T" and "ANI" in codes:
methcode="LP-AN-TRM"
if demag=="T" and "CR" in codes:
methcode="LP-CR-TRM"
if demag=="AF" and "ANI" in codes:
methcode="LP-AN-ARM"
if labfield==0: labfield=50e-6
if peakfield==0: peakfield=.180
MeasRecs,SpecRecs,SampRecs,SiteRecs,LocRecs=[],[],[],[],[]
version_num=pmag.get_version()
##################################
for line in lines:
instcode=""
if len(line)>2:
MeasRec,SpecRec,SampRec,SiteRec,LocRec={},{},{},{},{}
MeasRec['software_packages']=version_num
MeasRec["description"]=""
MeasRec["treat_temp"]='%8.3e' % (273) # room temp in kelvin
MeasRec["meas_temp"]='%8.3e' % (273) # room temp in kelvin
MeasRec["treat_ac_field"]='0'
MeasRec["treat_dc_field"]='0'
MeasRec["treat_dc_field_phi"]='0'
MeasRec["treat_dc_field_theta"]='0'
meas_type="LT-NO"
rec=line.split()
try: float(rec[0]); print("No specimen name for line #%d in the measurement file"%lines.index(line)); continue
except ValueError: pass
if rec[1]==".00":rec[1]="0.00"
treat=rec[1].split('.')
if methcode=="LP-IRM":
if irmunits=='mT':
labfield=float(treat[0])*1e-3
else:
labfield=pmag.getfield(irmunits,coil,treat[0])
if rec[1][0]!="-":
phi,theta=0.,90.
else:
phi,theta=0.,-90.
meas_type="LT-IRM"
MeasRec["treat_dc_field"]='%8.3e'%(labfield)
MeasRec["treat_dc_field_phi"]='%7.1f'%(phi)
MeasRec["treat_dc_field_theta"]='%7.1f'%(theta)
if len(rec)>6:
code1=rec[6].split(';') # break e.g., 10/15/02;7:45 indo date and time
if len(code1)==2: # old format with AM/PM
missing=0
code2=code1[0].split('/') # break date into mon/day/year
code3=rec[7].split(';') # break e.g., AM;C34;200 into time;instr/axes/measuring pos;number of measurements
yy=int(code2[2])
if yy <90:
yyyy=str(2000+yy)
else: yyyy=str(1900+yy)
mm=int(code2[0])
if mm<10:
mm="0"+str(mm)
else: mm=str(mm)
dd=int(code2[1])
if dd<10:
dd="0"+str(dd)
else: dd=str(dd)
time=code1[1].split(':')
hh=int(time[0])
if code3[0]=="PM":hh=hh+12
if hh<10:
hh="0"+str(hh)
else: hh=str(hh)
min=int(time[1])
if min<10:
min= "0"+str(min)
else: min=str(min)
dt=yyyy+":"+mm+":"+dd+":"+hh+":"+min+":00"
local = pytz.timezone(timezone)
naive = datetime.datetime.strptime(dt, "%Y:%m:%d:%H:%M:%S")
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone(pytz.utc)
MeasRec["timestamp"]=utc_dt.strftime("%Y-%m-%dT%H:%M:%S")+"Z"
if inst=="":
if code3[1][0]=='C':instcode='SIO-bubba'
if code3[1][0]=='G':instcode='SIO-flo'
else:
instcode=''
MeasRec["meas_n_orient"]=code3[1][2]
elif len(code1)>2: # newest format (cryo7 or later)
if "LP-AN-ARM" not in methcode:labfield=0
fmt='new'
date=code1[0].split('/') # break date into mon/day/year
yy=int(date[2])
if yy <90:
yyyy=str(2000+yy)
else: yyyy=str(1900+yy)
mm=int(date[0])
if mm<10:
mm="0"+str(mm)
else: mm=str(mm)
dd=int(date[1])
if dd<10:
dd="0"+str(dd)
else: dd=str(dd)
time=code1[1].split(':')
hh=int(time[0])
if hh<10:
hh="0"+str(hh)
else: hh=str(hh)
min=int(time[1])
if min<10:
min= "0"+str(min)
else:
min=str(min)
dt=yyyy+":"+mm+":"+dd+":"+hh+":"+min+":00"
local = pytz.timezone(timezone)
naive = datetime.datetime.strptime(dt, "%Y:%m:%d:%H:%M:%S")
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone(pytz.utc)
MeasRec["timestamp"]=utc_dt.strftime("%Y-%m-%dT%H:%M:%S")+"Z"
if inst=="":
if code1[6][0]=='C':
instcode='SIO-bubba'
if code1[6][0]=='G':
instcode='SIO-flo'
else:
instcode=''
if len(code1)>1:
MeasRec["meas_n_orient"]=code1[6][2]
else:
MeasRec["meas_n_orient"]=code1[7] # takes care of awkward format with bubba and flo being different
if user=="":user=code1[5]
if code1[2][-1]=='C':
demag="T"
if code1[4]=='microT' and float(code1[3])!=0. and "LP-AN-ARM" not in methcode: labfield=float(code1[3])*1e-6
if code1[2]=='mT' and methcode!="LP-IRM":
demag="AF"
if code1[4]=='microT' and float(code1[3])!=0.: labfield=float(code1[3])*1e-6
if code1[4]=='microT' and labfield!=0. and meas_type!="LT-IRM":
phi,theta=0.,-90.
if demag=="T": meas_type="LT-T-I"
if demag=="AF": meas_type="LT-AF-I"
MeasRec["treat_dc_field"]='%8.3e'%(labfield)
MeasRec["treat_dc_field_phi"]='%7.1f'%(phi)
MeasRec["treat_dc_field_theta"]='%7.1f'%(theta)
if code1[4]=='' or labfield==0. and meas_type!="LT-IRM":
if demag=='T':meas_type="LT-T-Z"
if demag=="AF":meas_type="LT-AF-Z"
MeasRec["treat_dc_field"]='0'
if syn==0:
specimen=rec[0]
MeasRec["specimen"]=specimen
if specnum!=0:
sample=rec[0][:specnum]
else:
sample=rec[0]
if samp_infile and Samps: # if samp_infile was provided AND yielded sample data
samp=pmag.get_dictitem(Samps,'sample',sample,'T')
if len(samp)>0:
location=samp[0]["location"]
site=samp[0]["site"]
else:
location=''
site=''
else:
site=pmag.parse_site(sample,samp_con,Z)
if location!='' and location not in [x['location'] if 'location' in list(x.keys()) else '' for x in LocRecs]:
LocRec['location'] = location
LocRec['lat_n'] = lat
LocRec['lat_s'] = lat
LocRec['lon_e'] = lon
LocRec['lon_w'] = lon
LocRecs.append(LocRec)
if site!='' and site not in [x['site'] if 'site' in list(x.keys()) else '' for x in SiteRecs]:
SiteRec['location'] = location
SiteRec['site'] = site
SiteRec['lat'] = lat
SiteRec['lon'] = lon
SiteRecs.append(SiteRec)
if sample!='' and sample not in [x['sample'] if 'sample' in list(x.keys()) else '' for x in SampRecs]:
SampRec['site'] = site
SampRec['sample'] = sample
SampRecs.append(SampRec)
if specimen!='' and specimen not in [x['specimen'] if 'specimen' in list(x.keys()) else '' for x in SpecRecs]:
SpecRec["specimen"]=specimen
SpecRec['sample'] = sample
SpecRecs.append(SpecRec)
else:
specimen=rec[0]
MeasRec["specimen"]=specimen
if specnum!=0:
sample=rec[0][:specnum]
else:
sample=rec[0]
site=pmag.parse_site(sample,samp_con,Z)
if location!='' and location not in [x['location'] if 'location' in list(x.keys()) else '' for x in LocRecs]:
LocRec['location'] = location
LocRec['lat_n'] = lat
LocRec['lat_s'] = lat
LocRec['lon_e'] = lon
LocRec['lon_w'] = lon
LocRecs.append(LocRec)
if site!='' and site not in [x['site'] if 'site' in list(x.keys()) else '' for x in SiteRecs]:
SiteRec['location'] = location
SiteRec['site'] = site
SiteRec['lat'] = lat
SiteRec['lon'] = lon
SiteRecs.append(SiteRec)
if sample!='' and sample not in [x['sample'] if 'sample' in list(x.keys()) else '' for x in SampRecs]:
SampRec['site'] = site
SampRec['sample'] = sample
SampRecs.append(SampRec)
if specimen!='' and specimen not in [x['specimen'] if 'specimen' in list(x.keys()) else '' for x in SpecRecs]:
SpecRec["specimen"]=specimen
SpecRec['sample'] = sample
SpecRecs.append(SpecRec)
SampRec["institution"]=institution
SampRec["material_type"]=syntype
if float(rec[1])==0:
pass
elif demag=="AF":
if methcode != "LP-AN-ARM":
MeasRec["treat_ac_field"]='%8.3e' %(float(rec[1])*1e-3) # peak field in tesla
if meas_type=="LT-AF-Z": MeasRec["treat_dc_field"]='0'
else: # AARM experiment
if treat[1][0]=='0':
meas_type="LT-AF-Z:LP-AN-ARM:"
MeasRec["treat_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MeasRec["treat_dc_field"]='%8.3e'%(0)
if labfield!=0 and methcode!="LP-AN-ARM": print("Warning - inconsistency in mag file with lab field - overriding file with 0")
else:
meas_type="LT-AF-I:LP-AN-ARM"
ipos=int(treat[0])-1
MeasRec["treat_dc_field_phi"]='%7.1f' %(dec[ipos])
MeasRec["treat_dc_field_theta"]='%7.1f'% (inc[ipos])
MeasRec["treat_dc_field"]='%8.3e'%(labfield)
MeasRec["treat_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
elif demag=="T" and methcode == "LP-AN-TRM":
MeasRec["treat_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if treat[1][0]=='0':
meas_type="LT-T-Z:LP-AN-TRM"
MeasRec["treat_dc_field"]='%8.3e'%(0)
MeasRec["treat_dc_field_phi"]='0'
MeasRec["treat_dc_field_theta"]='0'
else:
MeasRec["treat_dc_field"]='%8.3e'%(labfield)
if treat[1][0]=='7': # alteration check as final measurement
meas_type="LT-PTRM-I:LP-AN-TRM"
else:
meas_type="LT-T-I:LP-AN-TRM"
# find the direction of the lab field in two ways:
# (1) using the treatment coding (XX.1=+x, XX.2=+y, XX.3=+z, XX.4=-x, XX.5=-y, XX.6=-z)
ipos_code=int(treat[1][0])-1
# (2) using the magnetization
DEC=float(rec[4])
INC=float(rec[5])
if INC < 45 and INC > -45:
if DEC>315 or DEC<45: ipos_guess=0
if DEC>45 and DEC<135: ipos_guess=1
if DEC>135 and DEC<225: ipos_guess=3
if DEC>225 and DEC<315: ipos_guess=4
else:
if INC >45: ipos_guess=2
if INC <-45: ipos_guess=5
# prefer the guess over the code
ipos=ipos_guess
MeasRec["treat_dc_field_phi"]='%7.1f' %(tdec[ipos])
MeasRec["treat_dc_field_theta"]='%7.1f'% (tinc[ipos])
# check it
if ipos_guess!=ipos_code and treat[1][0]!='7':
print("-E- ERROR: check specimen %s step %s, ATRM measurements, coding does not match the direction of the lab field!"%(rec[0],".".join(list(treat))))
elif demag=="S": # Shaw experiment
if treat[1][1]=='0':
if int(treat[0])!=0:
MeasRec["treat_ac_field"]='%8.3e' % (float(treat[0])*1e-3) # AF field in tesla
MeasRec["treat_dc_field"]='0'
meas_type="LT-AF-Z" # first AF
else:
meas_type="LT-NO"
MeasRec["treat_ac_field"]='0'
MeasRec["treat_dc_field"]='0'
elif treat[1][1]=='1':
if int(treat[0])==0:
MeasRec["treat_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MeasRec["treat_dc_field"]='%8.3e'%(arm_labfield)
MeasRec["treat_dc_field_phi"]='%7.1f'%(phi)
MeasRec["treat_dc_field_theta"]='%7.1f'%(theta)
meas_type="LT-AF-I"
else:
MeasRec["treat_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MeasRec["treat_dc_field"]='0'
meas_type="LT-AF-Z"
elif treat[1][1]=='2':
if int(treat[0])==0:
MeasRec["treat_ac_field"]='0'
MeasRec["treat_dc_field"]='%8.3e'%(trm_labfield)
MeasRec["treat_dc_field_phi"]='%7.1f'%(phi)
MeasRec["treat_dc_field_theta"]='%7.1f'%(theta)
MeasRec["treat_temp"]='%8.3e' % (trm_peakT)
meas_type="LT-T-I"
else:
MeasRec["treat_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MeasRec["treat_dc_field"]='0'
meas_type="LT-AF-Z"
elif treat[1][1]=='3':
if int(treat[0])==0:
MeasRec["treat_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MeasRec["treat_dc_field"]='%8.3e'%(arm_labfield)
MeasRec["treat_dc_field_phi"]='%7.1f'%(phi)
MeasRec["treat_dc_field_theta"]='%7.1f'%(theta)
meas_type="LT-AF-I"
else:
MeasRec["treat_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MeasRec["treat_dc_field"]='0'
meas_type="LT-AF-Z"
# Cooling rate experient # added by rshaar
elif demag=="T" and methcode == "LP-CR-TRM":
MeasRec["treat_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if treat[1][0]=='0':
meas_type="LT-T-Z:LP-CR-TRM"
MeasRec["treat_dc_field"]='%8.3e'%(0)
MeasRec["treat_dc_field_phi"]='0'
MeasRec["treat_dc_field_theta"]='0'
else:
MeasRec["treat_dc_field"]='%8.3e'%(labfield)
if treat[1][0]=='7': # alteration check as final measurement
meas_type="LT-PTRM-I:LP-CR-TRM"
else:
meas_type="LT-T-I:LP-CR-TRM"
MeasRec["treat_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MeasRec["treat_dc_field_theta"]='%7.1f' % (theta) # labfield theta
indx=int(treat[1][0])-1
# alteration check matjed as 0.7 in the measurement file
if indx==6:
cooling_time= cooling_rates_list[-1]
else:
cooling_time=cooling_rates_list[indx]
MeasRec["description"]="cooling_rate"+":"+cooling_time+":"+"K/min"
elif demag!='N':
if len(treat)==1:treat.append('0')
MeasRec["treat_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if trm==0: # demag=T and not trmaq
if treat[1][0]=='0':
meas_type="LT-T-Z"
else:
MeasRec["treat_dc_field"]='%8.3e' % (labfield) # labfield in tesla (convert from microT)
MeasRec["treat_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MeasRec["treat_dc_field_theta"]='%7.1f' % (theta) # labfield theta
if treat[1][0]=='1':meas_type="LT-T-I" # in-field thermal step
if treat[1][0]=='2':
meas_type="LT-PTRM-I" # pTRM check
pTRM=1
if treat[1][0]=='3':
MeasRec["treat_dc_field"]='0' # this is a zero field step
meas_type="LT-PTRM-MD" # pTRM tail check
else:
labfield=float(treat[1])*1e-6
MeasRec["treat_dc_field"]='%8.3e' % (labfield) # labfield in tesla (convert from microT)
MeasRec["treat_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MeasRec["treat_dc_field_theta"]='%7.1f' % (theta) # labfield theta
meas_type="LT-T-I:LP-TRM" # trm acquisition experiment
MeasRec["dir_csd"]=rec[2]
MeasRec["magn_moment"]='%10.3e'% (float(rec[3])*1e-3) # moment in Am^2 (from emu)
MeasRec["dir_dec"]=rec[4]
MeasRec["dir_inc"]=rec[5]
MeasRec["instrument_codes"]=instcode
MeasRec["analysts"]=user
MeasRec["citations"]=citations
if "LP-IRM-3D" in methcode : meas_type=methcode
#MeasRec["method_codes"]=methcode.strip(':')
MeasRec["method_codes"]=meas_type
MeasRec["quality"]='g'
if 'std' in rec[0]:
MeasRec["standard"]='s'
else:
MeasRec["standard"]='u'
MeasRec["treat_step_num"]='1'
#print MeasRec['treat_temp']
MeasRecs.append(MeasRec)
con = nb.Contribution(output_dir_path,read_tables=[])
# create MagIC tables
con.add_magic_table_from_data(dtype='specimens', data=SpecRecs)
con.add_magic_table_from_data(dtype='samples', data=SampRecs)
con.add_magic_table_from_data(dtype='sites', data=SiteRecs)
con.add_magic_table_from_data(dtype='locations', data=LocRecs)
MeasOuts=pmag.measurements_methods3(MeasRecs,noave)
con.add_magic_table_from_data(dtype='measurements', data=MeasOuts)
# write MagIC tables to file
con.tables['specimens'].write_magic_file(custom_name=spec_file)
con.tables['samples'].write_magic_file(custom_name=samp_file)
con.tables['sites'].write_magic_file(custom_name=site_file)
con.tables['locations'].write_magic_file(custom_name=loc_file)
con.tables['measurements'].write_magic_file(custom_name=meas_file)
return True, meas_file
def main():
"""
NAME
irmaq_magic.py
DESCRIPTION
plots IRM acquisition curves from measurements file
SYNTAX
irmaq_magic [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt/measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-N ; do not normalize by last point - use original units
-fmt [png,jpg,eps,pdf] set plot file format [default is svg]
-sav save plot[s] and quit
-DM MagIC data model number, default is 3
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG = {} # plot dictionary
FIG['exp'] = 1 # exp is figure 1
dir_path = './'
plot, fmt = 0, 'svg'
units = 'T',
XLP = []
norm = 1
LP = "LP-IRM"
if len(sys.argv) > 1:
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
data_model = int(pmag.get_named_arg("-DM", 3))
if '-N' in sys.argv:
norm = 0
if '-sav' in sys.argv:
plot = 1
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if data_model == 3:
in_file = pmag.get_named_arg("-f", 'measurements.txt')
else:
in_file = pmag.get_named_arg("-f", 'magic_measurements.txt')
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
dir_path = os.path.realpath(dir_path)
in_file = pmag.resolve_file_name(in_file, dir_path)
if '-WD' not in sys.argv:
dir_path = os.path.split(in_file)[0]
plot_by = pmag.get_named_arg("-obj", "loc")
if data_model == 3:
plot_key = 'location'
if plot_by == 'sit':
plot_key = 'site'
if plot_by == 'sam':
plot_key = 'sample'
if plot_by == 'spc':
plot_key = 'specimen'
else:
plot_key = 'er_location_name'
if plot_by == 'sit':
plot_key = 'er_site_name'
if plot_by == 'sam':
plot_key = 'er_sample_name'
if plot_by == 'spc':
plot_key = 'er_specimen_name'
# set defaults and get more information if needed
if data_model == 3:
dmag_key = 'treat_dc_field'
else:
dmag_key = 'treatment_dc_field'
#
if data_model == 3 and plot_key != 'specimen':
# gonna need to read in more files
print('-W- You are trying to plot measurements by {}'.format(plot_key))
print(
' By default, this information is not available in your measurement file.'
)
print(
' Trying to acquire this information from {}'.format(dir_path))
con = cb.Contribution(dir_path)
meas_df = con.propagate_location_to_measurements()
if meas_df is None:
print('-W- No data found in {}'.format(dir_path))
return
if plot_key not in meas_df.columns:
print('-W- Could not find required data.')
print(' Try a different plot key.')
return
else:
print('-I- Found {} information, continuing with plotting'.format(
plot_key))
# need to take the data directly from the contribution here, to keep
# location/site/sample columns in the measurements table
data = con.tables['measurements'].convert_to_pmag_data_list()
file_type = "measurements"
else:
data, file_type = pmag.magic_read(in_file)
# read in data
sids = pmag.get_specs(data)
pmagplotlib.plot_init(FIG['exp'], 6, 6)
#
#
# find desired intensity data
#
# get plotlist
#
plotlist = []
if data_model == 3:
intlist = ['magn_moment', 'magn_volume', 'magn_mass', 'magnitude']
else:
intlist = [
'measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass'
]
IntMeths = []
# get all the records with this lab protocol
#print('data', len(data))
#print('data[0]', data[0])
if data_model == 3:
data = pmag.get_dictitem(data, 'method_codes', LP, 'has')
else:
data = pmag.get_dictitem(data, 'magic_method_codes', LP, 'has')
Ints = {}
NoInts, int_key = 1, ""
for key in intlist:
# get all non-blank data for intensity type
Ints[key] = pmag.get_dictitem(data, key, '', 'F')
if len(Ints[key]) > 0:
NoInts = 0
if int_key == "":
int_key = key
if NoInts == 1:
print('No intensity information found')
sys.exit()
for rec in Ints[int_key]:
if rec[plot_key] not in plotlist:
plotlist.append(rec[plot_key])
plotlist.sort()
for plt in plotlist:
print(plt)
INTblock = []
# get data with right intensity info whose plot_key matches plot
data = pmag.get_dictitem(Ints[int_key], plot_key, plt, 'T')
# get a list of specimens with appropriate data
sids = pmag.get_specs(data)
if len(sids) > 0:
title = data[0][plot_key]
for s in sids:
INTblock = []
# get data for each specimen
if data_model == 3:
sdata = pmag.get_dictitem(data, 'specimen', s, 'T')
else:
sdata = pmag.get_dictitem(data, 'er_specimen_name', s, 'T')
for rec in sdata:
INTblock.append(
[float(rec[dmag_key]), 0, 0,
float(rec[int_key]), 1, 'g'])
pmagplotlib.plot_mag(FIG['exp'], INTblock, title, 0, units, norm)
files = {}
for key in list(FIG.keys()):
files[key] = title + '_' + LP + '.' + fmt
if plot == 0:
pmagplotlib.draw_figs(FIG)
ans = input(" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans == 'q':
sys.exit()
if ans == "a":
pmagplotlib.save_plots(FIG, files)
if plt != plotlist[
-1]: # if it isn't the last plot, init the next one
pmagplotlib.plot_init(FIG['exp'], 6, 6)
else:
pmagplotlib.save_plots(FIG, files)
pmagplotlib.clearFIG(FIG['exp'])
def main():
"""
NAME
lowrie.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie -h [command line options]
INPUT
takes SIO formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav save plots and quit
"""
fmt, plot = 'svg', 0
FIG = {} # plot dictionary
FIG['lowrie'] = 1 # demag is figure 1
pmagplotlib.plot_init(FIG['lowrie'], 6, 6)
norm = 1 # default is to normalize by maximum axis
if len(sys.argv) > 1:
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-N' in sys.argv:
norm = 0 # don't normalize
if '-sav' in sys.argv:
plot = 1 # don't normalize
if '-fmt' in sys.argv: # sets input filename
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-f' in sys.argv: # sets input filename
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
else:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
else:
print(main.__doc__)
print('you must supply a file name')
sys.exit()
data = pmag.open_file(in_file)
PmagRecs = [] # set up a list for the results
keys = ['specimen', 'treatment', 'csd', 'M', 'dec', 'inc']
for line in data:
PmagRec = {}
rec = line.replace('\n', '').split()
for k in range(len(keys)):
PmagRec[keys[k]] = rec[k]
PmagRecs.append(PmagRec)
specs = pmag.get_dictkey(PmagRecs, 'specimen', '')
sids = []
for spec in specs:
if spec not in sids:
sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print(spc)
specdata = pmag.get_dictitem(PmagRecs, 'specimen', spc,
'T') # get all this one's data
DIMs, Temps = [], []
for dat in specdata: # step through the data
DIMs.append(
[float(dat['dec']),
float(dat['inc']),
float(dat['M']) * 1e-3])
Temps.append(float(dat['treatment']))
carts = pmag.dir2cart(DIMs).transpose()
# if norm==1: # want to normalize
# nrm=max(max(abs(carts[0])),max(abs(carts[1])),max(abs(carts[2]))) # by maximum of x,y,z values
# ylab="M/M_max"
if norm == 1: # want to normalize
nrm = (DIMs[0][2]) # normalize by NRM
ylab = "M/M_o"
else:
nrm = 1. # don't normalize
ylab = "Magnetic moment (Am^2)"
xlab = "Temperature (C)"
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[0]), nrm),
sym='r-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[0]), nrm),
sym='ro') # X direction
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[1]), nrm),
sym='c-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[1]), nrm),
sym='cs') # Y direction
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[2]), nrm),
sym='k-')
pmagplotlib.plotXY(FIG['lowrie'],
Temps,
old_div(abs(carts[2]), nrm),
sym='k^',
title=spc,
xlab=xlab,
ylab=ylab) # Z direction
files = {'lowrie': 'lowrie:_' + spc + '_.' + fmt}
if plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = input('S[a]ve figure? [q]uit, <return> to continue ')
if ans == 'a':
pmagplotlib.saveP(FIG, files)
elif ans == 'q':
sys.exit()
else:
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG['lowrie'])
def main():
"""
NAME
irmaq_magic.py
DESCRIPTION
plots IRM acquisition curves from measurements file
SYNTAX
irmaq_magic [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt/measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-N ; do not normalize by last point - use original units
-fmt [png,jpg,eps,pdf] set plot file format [default is svg]
-sav save plot[s] and quit
-DM MagIC data model number, default is 3
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG = {} # plot dictionary
FIG['exp'] = 1 # exp is figure 1
dir_path = './'
plot, fmt = 0, 'svg'
units = 'T',
XLP = []
norm = 1
LP = "LP-IRM"
if len(sys.argv) > 1:
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
data_model = int(pmag.get_named_arg("-DM", 3))
if '-N' in sys.argv:
norm = 0
if '-sav' in sys.argv:
plot = 1
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if data_model == 3:
in_file = pmag.get_named_arg("-f", 'measurements.txt')
else:
in_file = pmag.get_named_arg("-f", 'magic_measurements.txt')
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
dir_path = os.path.realpath(dir_path)
in_file = pmag.resolve_file_name(in_file, dir_path)
if '-WD' not in sys.argv:
dir_path = os.path.split(in_file)[0]
plot_by = pmag.get_named_arg("-obj", "loc")
if data_model == 3:
plot_key = 'location'
if plot_by == 'sit':
plot_key = 'site'
if plot_by == 'sam':
plot_key = 'sample'
if plot_by == 'spc':
plot_key = 'specimen'
else:
plot_key = 'er_location_name'
if plot_by == 'sit':
plot_key = 'er_site_name'
if plot_by == 'sam':
plot_key = 'er_sample_name'
if plot_by == 'spc':
plot_key = 'er_specimen_name'
# set defaults and get more information if needed
if data_model == 3:
dmag_key = 'treat_dc_field'
else:
dmag_key = 'treatment_dc_field'
#
if data_model == 3 and plot_key != 'specimen':
# gonna need to read in more files
print('-W- You are trying to plot measurements by {}'.format(plot_key))
print(' By default, this information is not available in your measurement file.')
print(' Trying to acquire this information from {}'.format(dir_path))
con = cb.Contribution(dir_path)
meas_df = con.propagate_location_to_measurements()
if meas_df is None:
print('-W- No data found in {}'.format(dir_path))
return
if plot_key not in meas_df.columns:
print('-W- Could not find required data.')
print(' Try a different plot key.')
return
else:
print('-I- Found {} information, continuing with plotting'.format(plot_key))
# need to take the data directly from the contribution here, to keep
# location/site/sample columns in the measurements table
data = con.tables['measurements'].convert_to_pmag_data_list()
file_type = "measurements"
else:
data, file_type = pmag.magic_read(in_file)
# read in data
sids = pmag.get_specs(data)
pmagplotlib.plot_init(FIG['exp'], 6, 6)
#
#
# find desired intensity data
#
# get plotlist
#
plotlist = []
if data_model == 3:
intlist = ['magn_moment', 'magn_volume', 'magn_mass', 'magnitude']
else:
intlist = ['measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass']
IntMeths = []
# get all the records with this lab protocol
#print('data', len(data))
#print('data[0]', data[0])
if data_model == 3:
data = pmag.get_dictitem(data, 'method_codes', LP, 'has')
else:
data = pmag.get_dictitem(data, 'magic_method_codes', LP, 'has')
Ints = {}
NoInts, int_key = 1, ""
for key in intlist:
# get all non-blank data for intensity type
Ints[key] = pmag.get_dictitem(data, key, '', 'F')
if len(Ints[key]) > 0:
NoInts = 0
if int_key == "":
int_key = key
if NoInts == 1:
print('No intensity information found')
sys.exit()
for rec in Ints[int_key]:
if rec[plot_key] not in plotlist:
plotlist.append(rec[plot_key])
plotlist.sort()
for plt in plotlist:
print(plt)
INTblock = []
# get data with right intensity info whose plot_key matches plot
data = pmag.get_dictitem(Ints[int_key], plot_key, plt, 'T')
# get a list of specimens with appropriate data
sids = pmag.get_specs(data)
if len(sids) > 0:
title = data[0][plot_key]
for s in sids:
INTblock = []
# get data for each specimen
if data_model == 3:
sdata = pmag.get_dictitem(data, 'specimen', s, 'T')
else:
sdata = pmag.get_dictitem(data, 'er_specimen_name', s, 'T')
for rec in sdata:
INTblock.append([float(rec[dmag_key]), 0, 0,
float(rec[int_key]), 1, 'g'])
pmagplotlib.plot_mag(FIG['exp'], INTblock, title, 0, units, norm)
files = {}
for key in list(FIG.keys()):
files[key] = title + '_' + LP + '.' + fmt
if plot == 0:
pmagplotlib.draw_figs(FIG)
ans = input(" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans == 'q':
sys.exit()
if ans == "a":
pmagplotlib.save_plots(FIG, files)
if plt != plotlist[-1]: # if it isn't the last plot, init the next one
pmagplotlib.plot_init(FIG['exp'], 6, 6)
else:
pmagplotlib.save_plots(FIG, files)
pmagplotlib.clearFIG(FIG['exp'])
def main():
"""
NAME
thellier_magic_redo.py
DESCRIPTION
Calculates paleointensity parameters for thellier-thellier type data using bounds
stored in the "redo" file
SYNTAX
thellier_magic_redo [command line options]
OPTIONS
-h prints help message
-usr USER: identify user, default is ""
-fcr CRIT, set criteria for grading
-f IN: specify input file, default is magic_measurements.txt
-fre REDO: specify redo file, default is "thellier_redo"
-F OUT: specify output file, default is thellier_specimens.txt
-leg: attaches "Recalculated from original measurements; supercedes published results. " to comment field
-CR PERC TYPE: apply a blanket cooling rate correction if none supplied in the er_samples.txt file
PERC should be a percentage of original (say reduce to 90%)
TYPE should be one of the following:
EG (for educated guess); PS (based on pilots); TRM (based on comparison of two TRMs)
-ANI: perform anisotropy correction
-fsa SAMPFILE: er_samples.txt file with cooling rate correction information, default is NO CORRECTION
-Fcr CRout: specify pmag_specimen format file for cooling rate corrected data
-fan ANIFILE: specify rmag_anisotropy format file, default is rmag_anisotropy.txt
-Fac ACout: specify pmag_specimen format file for anisotropy corrected data
default is AC_specimens.txt
-fnl NLTFILE: specify magic_measurments format file, default is magic_measurements.txt
-Fnl NLTout: specify pmag_specimen format file for non-linear trm corrected data
default is NLT_specimens.txt
-z use z component differenences for pTRM calculation
INPUT
a thellier_redo file is Specimen_name Tmin Tmax (where Tmin and Tmax are in Centigrade)
"""
dir_path = '.'
critout = ""
version_num = pmag.get_version()
field, first_save = -1, 1
spec, recnum, start, end = 0, 0, 0, 0
crfrac = 0
NltRecs, PmagSpecs, AniSpecRecs, NltSpecRecs, CRSpecs = [], [], [], [], []
meas_file, pmag_file, mk_file = "magic_measurements.txt", "thellier_specimens.txt", "thellier_redo"
anis_file = "rmag_anisotropy.txt"
anisout, nltout = "AC_specimens.txt", "NLT_specimens.txt"
crout = "CR_specimens.txt"
nlt_file = ""
samp_file = ""
comment, user = "", "unknown"
anis, nltrm = 0, 0
jackknife = 0 # maybe in future can do jackknife
args = sys.argv
Zdiff = 0
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind + 1]
if "-h" in args:
print main.__doc__
sys.exit()
if "-usr" in args:
ind = args.index("-usr")
user = sys.argv[ind + 1]
if "-leg" in args:
comment = "Recalculated from original measurements; supercedes published results. "
cool = 0
if "-CR" in args:
cool = 1
ind = args.index("-CR")
crfrac = .01 * float(sys.argv[ind + 1])
crtype = 'DA-CR-' + sys.argv[ind + 2]
if "-Fcr" in args:
ind = args.index("-Fcr")
crout = sys.argv[ind + 1]
if "-f" in args:
ind = args.index("-f")
meas_file = sys.argv[ind + 1]
if "-F" in args:
ind = args.index("-F")
pmag_file = sys.argv[ind + 1]
if "-fre" in args:
ind = args.index("-fre")
mk_file = args[ind + 1]
if "-fsa" in args:
ind = args.index("-fsa")
samp_file = dir_path + '/' + args[ind + 1]
Samps, file_type = pmag.magic_read(samp_file)
SampCRs = pmag.get_dictitem(
Samps, 'cooling_rate_corr', '',
'F') # get samples cooling rate corrections
cool = 1
if file_type != 'er_samples':
print 'not a valid er_samples.txt file'
sys.exit()
#
#
if "-ANI" in args:
anis = 1
ind = args.index("-ANI")
if "-Fac" in args:
ind = args.index("-Fac")
anisout = args[ind + 1]
if "-fan" in args:
ind = args.index("-fan")
anis_file = args[ind + 1]
#
if "-NLT" in args:
if "-Fnl" in args:
ind = args.index("-Fnl")
nltout = args[ind + 1]
if "-fnl" in args:
ind = args.index("-fnl")
nlt_file = args[ind + 1]
if "-z" in args: Zdiff = 1
if '-fcr' in sys.argv:
ind = args.index("-fcr")
critout = sys.argv[ind + 1]
#
# start reading in data:
#
meas_file = dir_path + "/" + meas_file
mk_file = dir_path + "/" + mk_file
accept = pmag.default_criteria(1)[0] # set criteria to none
if critout != "":
critout = dir_path + "/" + critout
crit_data, file_type = pmag.magic_read(critout)
if file_type != 'pmag_criteria':
print 'bad pmag_criteria file, using no acceptance criteria'
print "Acceptance criteria read in from ", critout
for critrec in crit_data:
if 'sample_int_sigma_uT' in critrec.keys(
): # accommodate Shaar's new criterion
critrec['sample_int_sigma'] = '%10.3e' % (
eval(critrec['sample_int_sigma_uT']) * 1e-6)
for key in critrec.keys():
if key not in accept.keys() and critrec[key] != '':
accept[key] = critrec[key]
meas_data, file_type = pmag.magic_read(meas_file)
if file_type != 'magic_measurements':
print file_type
print file_type, "This is not a valid magic_measurements file "
sys.exit()
try:
mk_f = open(mk_file, 'rU')
except:
print "Bad redo file"
sys.exit()
mkspec = []
speclist = []
for line in mk_f.readlines():
tmp = line.split()
mkspec.append(tmp)
speclist.append(tmp[0])
if anis == 1:
anis_file = dir_path + "/" + anis_file
anis_data, file_type = pmag.magic_read(anis_file)
if file_type != 'rmag_anisotropy':
print file_type
print file_type, "This is not a valid rmag_anisotropy file "
sys.exit()
if nlt_file == "":
nlt_data = pmag.get_dictitem(
meas_data, 'magic_method_codes', 'LP-TRM',
'has') # look for trm acquisition data in the meas_data file
else:
nlt_file = dir_path + "/" + nlt_file
nlt_data, file_type = pmag.magic_read(nlt_file)
if len(nlt_data) > 0:
nltrm = 1
#
# sort the specimen names and step through one by one
#
sids = pmag.get_specs(meas_data)
#
print 'Processing ', len(speclist), ' specimens - please wait '
while spec < len(speclist):
s = speclist[spec]
recnum = 0
datablock = []
PmagSpecRec = {}
PmagSpecRec["er_analyst_mail_names"] = user
PmagSpecRec["er_citation_names"] = "This study"
PmagSpecRec["magic_software_packages"] = version_num
methcodes, inst_code = [], ""
#
# find the data from the meas_data file for this specimen
#
datablock = pmag.get_dictitem(meas_data, 'er_specimen_name', s, 'T')
datablock = pmag.get_dictitem(
datablock, 'magic_method_codes', 'LP-PI-TRM',
'has') #pick out the thellier experiment data
if len(datablock) > 0:
for rec in datablock:
if "magic_instrument_codes" not in rec.keys():
rec["magic_instrument_codes"] = "unknown"
#
# collect info for the PmagSpecRec dictionary
#
rec = datablock[0]
PmagSpecRec["er_specimen_name"] = s
PmagSpecRec["er_sample_name"] = rec["er_sample_name"]
PmagSpecRec["er_site_name"] = rec["er_site_name"]
PmagSpecRec["er_location_name"] = rec["er_location_name"]
PmagSpecRec["measurement_step_unit"] = "K"
PmagSpecRec["specimen_correction"] = 'u'
if "er_expedition_name" in rec.keys():
PmagSpecRec["er_expedition_name"] = rec["er_expedition_name"]
if "magic_instrument_codes" not in rec.keys():
PmagSpecRec["magic_instrument_codes"] = "unknown"
else:
PmagSpecRec["magic_instrument_codes"] = rec[
"magic_instrument_codes"]
if "magic_experiment_name" not in rec.keys():
rec["magic_experiment_name"] = ""
else:
PmagSpecRec["magic_experiment_names"] = rec[
"magic_experiment_name"]
meths = rec["magic_experiment_name"].split(":")
for meth in meths:
if meth.strip() not in methcodes and "LP-" in meth:
methcodes.append(meth.strip())
#
# sort out the data into first_Z, first_I, ptrm_check, ptrm_tail
#
araiblock, field = pmag.sortarai(datablock, s, Zdiff)
first_Z = araiblock[0]
first_I = araiblock[1]
ptrm_check = araiblock[2]
ptrm_tail = araiblock[3]
if len(first_I) < 3 or len(first_Z) < 4:
spec += 1
print 'skipping specimen ', s
else:
#
# get start, end
#
for redospec in mkspec:
if redospec[0] == s:
b, e = float(redospec[1]), float(redospec[2])
break
if e > float(first_Z[-1][0]): e = float(first_Z[-1][0])
for recnum in range(len(first_Z)):
if first_Z[recnum][0] == b: start = recnum
if first_Z[recnum][0] == e: end = recnum
nsteps = end - start
if nsteps > 2:
zijdblock, units = pmag.find_dmag_rec(s, meas_data)
pars, errcode = pmag.PintPars(datablock, araiblock,
zijdblock, start, end,
accept)
if 'specimen_scat' in pars.keys():
PmagSpecRec['specimen_scat'] = pars['specimen_scat']
if 'specimen_frac' in pars.keys():
PmagSpecRec['specimen_frac'] = '%5.3f' % (
pars['specimen_frac'])
if 'specimen_gmax' in pars.keys():
PmagSpecRec['specimen_gmax'] = '%5.3f' % (
pars['specimen_gmax'])
pars['measurement_step_unit'] = units
pars["specimen_lab_field_dc"] = field
pars["specimen_int"] = -1 * field * pars["specimen_b"]
PmagSpecRec["measurement_step_min"] = '%8.3e' % (
pars["measurement_step_min"])
PmagSpecRec["measurement_step_max"] = '%8.3e' % (
pars["measurement_step_max"])
PmagSpecRec["specimen_int_n"] = '%i' % (
pars["specimen_int_n"])
PmagSpecRec["specimen_lab_field_dc"] = '%8.3e' % (
pars["specimen_lab_field_dc"])
PmagSpecRec["specimen_int"] = '%9.4e ' % (
pars["specimen_int"])
PmagSpecRec["specimen_b"] = '%5.3f ' % (pars["specimen_b"])
PmagSpecRec["specimen_q"] = '%5.1f ' % (pars["specimen_q"])
PmagSpecRec["specimen_f"] = '%5.3f ' % (pars["specimen_f"])
PmagSpecRec["specimen_fvds"] = '%5.3f' % (
pars["specimen_fvds"])
PmagSpecRec["specimen_b_beta"] = '%5.3f' % (
pars["specimen_b_beta"])
PmagSpecRec["specimen_int_mad"] = '%7.1f' % (
pars["specimen_int_mad"])
PmagSpecRec["specimen_Z"] = '%7.1f' % (pars["specimen_Z"])
PmagSpecRec["specimen_gamma"] = '%7.1f' % (
pars["specimen_gamma"])
if pars["method_codes"] != "" and pars[
"method_codes"] not in methcodes:
methcodes.append(pars["method_codes"])
PmagSpecRec["specimen_dec"] = '%7.1f' % (
pars["specimen_dec"])
PmagSpecRec["specimen_inc"] = '%7.1f' % (
pars["specimen_inc"])
PmagSpecRec["specimen_tilt_correction"] = '-1'
PmagSpecRec["specimen_direction_type"] = 'l'
PmagSpecRec[
"direction_type"] = 'l' # this is redudant, but helpful - won't be imported
PmagSpecRec["specimen_dang"] = '%7.1f ' % (
pars["specimen_dang"])
PmagSpecRec["specimen_drats"] = '%7.1f ' % (
pars["specimen_drats"])
PmagSpecRec["specimen_drat"] = '%7.1f ' % (
pars["specimen_drat"])
PmagSpecRec["specimen_int_ptrm_n"] = '%i ' % (
pars["specimen_int_ptrm_n"])
PmagSpecRec["specimen_rsc"] = '%6.4f ' % (
pars["specimen_rsc"])
PmagSpecRec["specimen_md"] = '%i ' % (int(
pars["specimen_md"]))
if PmagSpecRec["specimen_md"] == '-1':
PmagSpecRec["specimen_md"] = ""
PmagSpecRec["specimen_b_sigma"] = '%5.3f ' % (
pars["specimen_b_sigma"])
if "IE-TT" not in methcodes: methcodes.append("IE-TT")
methods = ""
for meth in methcodes:
methods = methods + meth + ":"
PmagSpecRec["magic_method_codes"] = methods.strip(':')
PmagSpecRec["magic_software_packages"] = version_num
PmagSpecRec["specimen_description"] = comment
if critout != "":
kill = pmag.grade(PmagSpecRec, accept, 'specimen_int')
if len(kill) > 0:
Grade = 'F' # fails
else:
Grade = 'A' # passes
PmagSpecRec["specimen_grade"] = Grade
else:
PmagSpecRec["specimen_grade"] = "" # not graded
if nltrm == 0 and anis == 0 and cool != 0: # apply cooling rate correction
SCR = pmag.get_dictitem(
SampCRs, 'er_sample_name',
PmagSpecRec['er_sample_name'],
'T') # get this samples, cooling rate correction
CrSpecRec = pmag.cooling_rate(PmagSpecRec, SCR, crfrac,
crtype)
if CrSpecRec['er_specimen_name'] != 'none':
CrSpecs.append(CrSpecRec)
PmagSpecs.append(PmagSpecRec)
NltSpecRec = ""
#
# check on non-linear TRM correction
#
if nltrm == 1:
#
# find the data from the nlt_data list for this specimen
#
TRMs, Bs = [], []
NltSpecRec = ""
NltRecs = pmag.get_dictitem(
nlt_data, 'er_specimen_name',
PmagSpecRec['er_specimen_name'], 'has'
) # fish out all the NLT data for this specimen
if len(NltRecs) > 2:
for NltRec in NltRecs:
Bs.append(float(NltRec['treatment_dc_field']))
TRMs.append(
float(NltRec['measurement_magn_moment']))
NLTpars = nlt.NLtrm(
Bs, TRMs, float(PmagSpecRec['specimen_int']),
float(PmagSpecRec['specimen_lab_field_dc']), 0)
if NLTpars['banc'] > 0:
NltSpecRec = {}
for key in PmagSpecRec.keys():
NltSpecRec[key] = PmagSpecRec[key]
NltSpecRec['specimen_int'] = '%9.4e' % (
NLTpars['banc'])
NltSpecRec['magic_method_codes'] = PmagSpecRec[
"magic_method_codes"] + ":DA-NL"
NltSpecRec["specimen_correction"] = 'c'
NltSpecRec['specimen_grade'] = PmagSpecRec[
'specimen_grade']
NltSpecRec[
"magic_software_packages"] = version_num
print NltSpecRec[
'er_specimen_name'], ' Banc= ', float(
NLTpars['banc']) * 1e6
if anis == 0 and cool != 0:
SCR = pmag.get_dictitem(
SampCRs, 'er_sample_name',
NltSpecRec['er_sample_name'], 'T'
) # get this samples, cooling rate correction
CrSpecRec = pmag.cooling_rate(
NltSpecRec, SCR, crfrac, crtype)
if CrSpecRec['er_specimen_name'] != 'none':
CrSpecs.append(CrSpecRec)
NltSpecRecs.append(NltSpecRec)
#
# check on anisotropy correction
if anis == 1:
if NltSpecRec != "":
Spc = NltSpecRec
else: # find uncorrected data
Spc = PmagSpecRec
AniSpecs = pmag.get_dictitem(
anis_data, 'er_specimen_name',
PmagSpecRec['er_specimen_name'], 'T')
if len(AniSpecs) > 0:
AniSpec = AniSpecs[0]
AniSpecRec = pmag.doaniscorr(Spc, AniSpec)
AniSpecRec['specimen_grade'] = PmagSpecRec[
'specimen_grade']
AniSpecRec[
"magic_instrument_codes"] = PmagSpecRec[
'magic_instrument_codes']
AniSpecRec["specimen_correction"] = 'c'
AniSpecRec[
"magic_software_packages"] = version_num
if cool != 0:
SCR = pmag.get_dictitem(
SampCRs, 'er_sample_name',
AniSpecRec['er_sample_name'], 'T'
) # get this samples, cooling rate correction
CrSpecRec = pmag.cooling_rate(
AniSpecRec, SCR, crfrac, crtype)
if CrSpecRec['er_specimen_name'] != 'none':
CrSpecs.append(CrSpecRec)
AniSpecRecs.append(AniSpecRec)
elif anis == 1:
AniSpecs = pmag.get_dictitem(
anis_data, 'er_specimen_name',
PmagSpecRec['er_specimen_name'], 'T')
if len(AniSpecs) > 0:
AniSpec = AniSpecs[0]
AniSpecRec = pmag.doaniscorr(PmagSpecRec, AniSpec)
AniSpecRec['specimen_grade'] = PmagSpecRec[
'specimen_grade']
AniSpecRec["magic_instrument_codes"] = PmagSpecRec[
"magic_instrument_codes"]
AniSpecRec["specimen_correction"] = 'c'
AniSpecRec["magic_software_packages"] = version_num
if crfrac != 0:
CrSpecRec = {}
for key in AniSpecRec.keys():
CrSpecRec[key] = AniSpecRec[key]
inten = frac * float(CrSpecRec['specimen_int'])
CrSpecRec["specimen_int"] = '%9.4e ' % (
inten
) # adjust specimen intensity by cooling rate correction
CrSpecRec['magic_method_codes'] = CrSpecRec[
'magic_method_codes'] + ':DA-CR-' + crtype
CRSpecs.append(CrSpecRec)
AniSpecRecs.append(AniSpecRec)
spec += 1
else:
print "skipping ", s
spec += 1
pmag_file = dir_path + '/' + pmag_file
pmag.magic_write(pmag_file, PmagSpecs, 'pmag_specimens')
print 'uncorrected thellier data saved in: ', pmag_file
if anis == 1 and len(AniSpecRecs) > 0:
anisout = dir_path + '/' + anisout
pmag.magic_write(anisout, AniSpecRecs, 'pmag_specimens')
print 'anisotropy corrected data saved in: ', anisout
if nltrm == 1 and len(NltSpecRecs) > 0:
nltout = dir_path + '/' + nltout
pmag.magic_write(nltout, NltSpecRecs, 'pmag_specimens')
print 'non-linear TRM corrected data saved in: ', nltout
if crfrac != 0:
crout = dir_path + '/' + crout
pmag.magic_write(crout, CRSpecs, 'pmag_specimens')
print 'cooling rate corrected data saved in: ', crout
def main(command_line=True, **kwargs):
"""
NAME
iodp_dscr_magic.py
DESCRIPTION
converts ODP LIMS discrete sample format files to magic_measurements format files
SYNTAX
iodp_descr_magic.py [command line options]
OPTIONS
-h: prints the help message and quits.
-f FILE: specify input .csv file, default is all in directory
-F FILE: specify output measurements file, default is magic_measurements.txt
-A : don't average replicate measurements
INPUTS
IODP discrete sample .csv file format exported from LIMS database
"""
#
# initialize defaults
version_num=pmag.get_version()
meas_file='magic_measurements.txt'
csv_file=''
MagRecs,Specs=[],[]
citation="This study"
dir_path,demag='.','NRM'
args=sys.argv
noave=0
# get command line args
if command_line:
if '-WD' in args:
ind=args.index("-WD")
dir_path=args[ind+1]
if '-ID' in args:
ind = args.index('-ID')
input_dir_path = args[ind+1]
else:
input_dir_path = dir_path
output_dir_path = dir_path
if "-h" in args:
print(main.__doc__)
return False
if "-A" in args: noave=1
if '-f' in args:
ind=args.index("-f")
csv_file=args[ind+1]
if '-F' in args:
ind=args.index("-F")
meas_file=args[ind+1]
if not command_line:
dir_path = kwargs.get('dir_path', '.')
input_dir_path = kwargs.get('input_dir_path', dir_path)
output_dir_path = dir_path # rename dir_path after input_dir_path is set
noave = kwargs.get('noave', 0) # default (0) is DO average
csv_file = kwargs.get('csv_file', '')
meas_file = kwargs.get('meas_file', 'magic_measurements.txt')
# format variables
meas_file= os.path.join(output_dir_path, meas_file)
if csv_file=="":
filelist=os.listdir(input_dir_path) # read in list of files to import
else:
csv_file = os.path.join(input_dir_path, csv_file)
filelist=[csv_file]
# parsing the data
file_found = False
for fname in filelist: # parse each file
if fname[-3:].lower()=='csv':
file_found = True
print('processing: ',fname)
with open(fname, 'r') as finput:
data = list(finput.readlines())
keys = data[0].replace('\n','').split(',') # splits on underscores
interval_key="Offset (cm)"
demag_key="Demag level (mT)"
offline_demag_key="Treatment Value (mT or °C)"
offline_treatment_type="Treatment type"
run_key="Test No."
if "Inclination background + tray corrected (deg)" in keys: inc_key="Inclination background + tray corrected (deg)"
if "Inclination background & tray corrected (deg)" in keys: inc_key="Inclination background & tray corrected (deg)"
if "Declination background + tray corrected (deg)" in keys: dec_key="Declination background + tray corrected (deg)"
if "Declination background & tray corrected (deg)" in keys: dec_key="Declination background & tray corrected (deg)"
if "Intensity background + tray corrected (A/m)" in keys: int_key="Intensity background + tray corrected (A/m)"
if "Intensity background & tray corrected (A/m)" in keys: int_key="Intensity background & tray corrected (A/m)"
type="Type"
sect_key="Sect"
half_key="A/W"
# need to add volume_key to LORE format!
if "Sample volume (cm^3)" in keys:volume_key="Sample volume (cm^3)"
if "Sample volume (cc)" in keys:volume_key="Sample volume (cc)"
if "Sample volume (cm³)" in keys:volume_key="Sample volume (cm³)"
for line in data[1:]:
InRec={}
for k in range(len(keys)):InRec[keys[k]]=line.split(',')[k]
inst="IODP-SRM"
MagRec={}
expedition=InRec['Exp']
location=InRec['Site']+InRec['Hole']
offsets=InRec[interval_key].split('.') # maintain consistency with er_samples convention of using top interval
if len(offsets)==1:
offset=int(offsets[0])
else:
offset=int(offsets[0])-1
#interval=str(offset+1)# maintain consistency with er_samples convention of using top interval
interval=str(offset)# maintain consistency with er_samples convention of using top interval
specimen=expedition+'-'+location+'-'+InRec['Core']+InRec[type]+"-"+InRec[sect_key]+'_'+InRec[half_key]+'_'+interval
if specimen not in Specs:Specs.append(specimen)
MagRec['er_expedition_name']=expedition
MagRec['er_location_name']=location
MagRec['er_site_name']=specimen
MagRec['er_citation_names']=citation
MagRec['er_specimen_name']=specimen
MagRec['er_sample_name']=specimen
MagRec['er_site_name']=specimen
# set up measurement record - default is NRM
MagRec['magic_software_packages']=version_num
MagRec["treatment_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["measurement_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["treatment_ac_field"]='0'
MagRec["treatment_dc_field"]='0'
MagRec["treatment_dc_field_phi"]='0'
MagRec["treatment_dc_field_theta"]='0'
MagRec["measurement_flag"]='g' # assume all data are "good"
MagRec["measurement_standard"]='u' # assume all data are "good"
MagRec["measurement_csd"]='0' # assume all data are "good"
volume=InRec[volume_key]
MagRec["magic_method_codes"]='LT-NO'
sort_by='treatment_ac_field' # set default to AF demag
if InRec[demag_key]!="0":
MagRec['magic_method_codes'] = 'LT-AF-Z'
inst=inst+':IODP-SRM-AF' # measured on shipboard in-line 2G AF
treatment_value=float(InRec[demag_key].strip('"'))*1e-3 # convert mT => T
if sort_by =="treatment_ac_field":
MagRec["treatment_ac_field"]=treatment_value # AF demag in treat mT => T
else:
MagRec["treatment_ac_field"]=str(treatment_value)# AF demag in treat mT => T
elif offline_treatment_type in list(InRec.keys()) and InRec[offline_treatment_type]!="":
if "Lowrie" in InRec['Comments']:
MagRec['magic_method_codes'] = 'LP-IRM-3D'
treatment_value=float(InRec[offline_demag_key].strip('"'))+273. # convert C => K
MagRec["treatment_temp"]=treatment_value
MagRec["treatment_ac_field"]="0"
sort_by='treatment_temp'
elif 'Isothermal' in InRec[offline_treatment_type]:
MagRec['magic_method_codes'] = 'LT-IRM'
treatment_value=float(InRec[offline_demag_key].strip('"'))*1e-3 # convert mT => T
MagRec["treatment_dc_field"]=treatment_value
MagRec["treatment_ac_field"]="0"
sort_by='treatment_dc_field'
MagRec["measurement_standard"]='u' # assume all data are "good"
vol=float(volume)*1e-6 # convert from cc to m^3
if run_key in list(InRec.keys()):
run_number=InRec[run_key]
MagRec['external_database_ids']=run_number
MagRec['external_database_names']='LIMS'
else:
MagRec['external_database_ids']=""
MagRec['external_database_names']=''
MagRec['measurement_description']='sample orientation: '+InRec['Sample orientation']
MagRec['measurement_inc']=InRec[inc_key].strip('"')
MagRec['measurement_dec']=InRec[dec_key].strip('"')
intens= InRec[int_key].strip('"')
MagRec['measurement_magn_moment']='%8.3e'%(float(intens)*vol) # convert intensity from A/m to Am^2 using vol
MagRec['magic_instrument_codes']=inst
MagRec['measurement_number']='1'
MagRec['measurement_positions']=''
MagRecs.append(MagRec)
if not file_found:
print("No .csv files were found")
return False, "No .csv files were found"
MagOuts=[]
for spec in Specs:
Speclist=pmag.get_dictitem(MagRecs,'er_specimen_name',spec,'T')
Meassorted=sorted(Speclist, key=lambda x,y=None: int(round(float(x[sort_by])-float(y[sort_by]))) if y!=None else 0)
for rec in Meassorted:
for key in list(rec.keys()): rec[key]=str(rec[key])
MagOuts.append(rec)
Fixed=pmag.measurements_methods(MagOuts,noave)
Out,keys=pmag.fillkeys(Fixed)
if pmag.magic_write(meas_file,Out,'magic_measurements'):
print('data stored in ',meas_file)
return True, meas_file
else:
print('no data found. bad magfile?')
return False, 'no data found. bad magfile?'
def main():
"""
NAME
make_magic_plots.py
DESCRIPTION
inspects magic directory for available 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
"""
dirlist=['./']
dir_path=os.getcwd()
names=os.listdir(dir_path)
for n in names:
if 'Location' in n:
dirlist.append(n)
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)
if '-h' in sys.argv:
print main.__doc__
sys.exit()
for loc in dirlist:
print 'working on: ',loc
os.chdir(loc) # change working directories to each location
crd='s'
if 'er_samples.txt' in filelist: # find coordinate systems
samps,file_type=pmag.magic_read('er_samples.txt') # read in data
Srecs=pmag.get_dictitem(samps,'sample_azimuth','','F')# get all none blank sample orientations
if len(Srecs)>0:
crd='g'
if 'magic_measurements.txt' in filelist: # start with measurement data
print 'working on measurements data'
data,file_type=pmag.magic_read('magic_measurements.txt') # read in data
if loc == './': data=pmag.get_dictitem(data,'er_location_name','','T') # get all the blank location names from data file
# looking for zeq_magic possibilities
AFZrecs=pmag.get_dictitem(data,'magic_method_codes','LT-AF-Z','has')# get all none blank method codes
TZrecs=pmag.get_dictitem(data,'magic_method_codes','LT-T-Z','has')# get all none blank method codes
MZrecs=pmag.get_dictitem(data,'magic_method_codes','LT-M-Z','has')# get all none blank method codes
Drecs=pmag.get_dictitem(data,'measurement_dec','','F') # get all dec measurements
Irecs=pmag.get_dictitem(data,'measurement_inc','','F') # get all dec measurements
Mkeys=['measurement_magnitude','measurement_magn_moment','measurement_magn_volume','measurement_magn_mass']
for key in Mkeys:
Mrecs=pmag.get_dictitem(data,key,'','F') # get intensity data
if len(Mrecs)>0:break
if len(AFZrecs)>0 or len(TZrecs)>0 or len(MZrecs)>0 and len(Drecs)>0 and len(Irecs)>0 and len(Mrecs)>0: # potential for stepwise demag curves
print 'zeq_magic.py -fsp pmag_specimens.txt -sav -fmt '+fmt+' -crd '+crd
os.system('zeq_magic.py -sav -fmt '+fmt+' -crd '+crd )
# looking for thellier_magic possibilities
if len(pmag.get_dictitem(data,'magic_method_codes','LP-PI-TRM','has'))>0:
print 'thellier_magic.py -fsp pmag_specimens.txt -sav -fmt '+fmt
os.system('thellier_magic.py -sav -fmt '+fmt)
# looking for hysteresis possibilities
if len(pmag.get_dictitem(data,'magic_method_codes','LP-HYS','has'))>0: # find hyst experiments
print 'quick_hyst.py -sav -fmt '+fmt
os.system('quick_hyst.py -sav -fmt '+fmt)
if 'pmag_results.txt' in filelist: # start with measurement data
data,file_type=pmag.magic_read('pmag_results.txt') # read in data
print 'number of datapoints: ',len(data)
if loc == './': data=pmag.get_dictitem(data,'er_location_names',':','has') # get all the concatenated location names from data file
print 'number of datapoints: ',len(data) ,loc
print 'working on pmag_results directions'
SiteDIs=pmag.get_dictitem(data,'average_dec',"",'F') # find decs
print 'number of directions: ',len(SiteDIs)
SiteDIs=pmag.get_dictitem(SiteDIs,'average_inc',"",'F') # find decs and incs
print 'number of directions: ',len(SiteDIs)
SiteDIs=pmag.get_dictitem(SiteDIs,'data_type','i','has') # only individual results - not poles
print 'number of directions: ',len(SiteDIs)
SiteDIs_t=pmag.get_dictitem(SiteDIs,'tilt_correction','100','T')# tilt corrected coordinates
print 'number of directions: ',len(SiteDIs)
if len(SiteDIs_t)>0:
print 'eqarea_magic.py -sav -crd t -fmt '+fmt
os.system('eqarea_magic.py -sav -crd t -fmt '+fmt)
elif len(SiteDIs)>0 and 'tilt_correction' not in SiteDIs[0].keys():
print 'eqarea_magic.py -sav -fmt '+fmt
os.system('eqarea_magic.py -sav -fmt '+fmt)
else:
SiteDIs_g=pmag.get_dictitem(SiteDIs,'tilt_correction','0','T')# geographic coordinates
if len(SiteDIs_g)>0:
print 'eqarea_magic.py -sav -crd g -fmt '+fmt
os.system('eqarea_magic.py -sav -crd g -fmt '+fmt)
else:
SiteDIs_s=pmag.get_dictitem(SiteDIs,'tilt_correction','-1','T')# sample coordinates
if len(SiteDIs_s)>0:
print 'eqarea_magic.py -sav -crd s -fmt '+fmt
os.system('eqarea_magic.py -sav -crd s -fmt '+fmt)
else:
SiteDIs_x=pmag.get_dictitem(SiteDIs,'tilt_correction','','T')# no coordinates
if len(SiteDIs_x)>0:
print 'eqarea_magic.py -sav -fmt '+fmt
os.system('eqarea_magic.py -sav -fmt '+fmt)
print 'working on pmag_results VGP map'
VGPs=pmag.get_dictitem(SiteDIs,'vgp_lat',"",'F') # are there any VGPs?
if len(VGPs)>0: # YES!
os.system('vgpmap_magic.py -prj moll -res c -sym ro 5 -sav -fmt png')
print 'working on pmag_results intensities'
os.system('magic_select.py -f pmag_results.txt -key data_type i T -F tmp.txt')
os.system('magic_select.py -f tmp.txt -key average_int 0. has -F tmp1.txt')
os.system("grab_magic_key.py -f tmp1.txt -key average_int | awk '{print $1*1e6}' >tmp2.txt")
data,file_type=pmag.magic_read('tmp1.txt') # read in data
locations=pmag.get_dictkey(data,'er_location_names',"")
histfile='LO:_'+locations[0]+'_intensities_histogram:_.'+fmt
os.system("histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F " +histfile)
print "histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F " +histfile
os.system('rm tmp*.txt')
if 'rmag_hysteresis.txt' in filelist: # start with measurement data
print 'working on rmag_hysteresis'
data,file_type=pmag.magic_read('rmag_hysteresis.txt') # read in data
if loc == './': data=pmag.get_dictitem(data,'er_location_name','','T') # get all the blank location names from data file
hdata=pmag.get_dictitem(data,'hysteresis_bcr','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_mr_moment','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_ms_moment','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_bc','','F') # there are data for a dayplot
if len(hdata)>0:
print 'dayplot_magic.py -sav -fmt '+fmt
os.system('dayplot_magic.py -sav -fmt '+fmt)
#if 'er_sites.txt' in filelist: # start with measurement data
# print 'working on er_sites'
#os.system('basemap_magic.py -sav -fmt '+fmt)
if 'rmag_anisotropy.txt' in filelist: # do anisotropy plots if possible
print 'working on rmag_anisotropy'
data,file_type=pmag.magic_read('rmag_anisotropy.txt') # read in data
if loc == './': data=pmag.get_dictitem(data,'er_location_name','','T') # get all the blank location names from data file
sdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','-1','T') # get specimen coordinates
gdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','0','T') # get specimen coordinates
tdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','100','T') # get specimen coordinates
if len(sdata)>3:
print 'aniso_magic.py -x -B -crd s -sav -fmt '+fmt
os.system('aniso_magic.py -x -B -crd s -sav -fmt '+fmt)
if len(gdata)>3:
os.system('aniso_magic.py -x -B -crd g -sav -fmt '+fmt)
if len(tdata)>3:
os.system('aniso_magic.py -x -B -crd t -sav -fmt '+fmt)
if loc!='./':os.chdir('..') # change working directories to each location
def main():
"""
NAME
eqarea_magic.py
DESCRIPTION
makes equal area projections from declination/inclination data
SYNTAX
eqarea_magic.py [command line options]
INPUT
takes magic formatted pmag_results, pmag_sites, pmag_samples or pmag_specimens
OPTIONS
-h prints help message and quits
-f FILE: specify input magic format file from magic,default='pmag_results.txt'
supported types=[magic_measurements,pmag_specimens, pmag_samples, pmag_sites, pmag_results, magic_web]
-obj OBJ: specify level of plot [all, sit, sam, spc], default is all
-crd [s,g,t]: specify coordinate system, [s]pecimen, [g]eographic, [t]ilt adjusted
default is geographic, unspecified assumed geographic
-fmt [svg,png,jpg] format for output plots
-ell [F,K,B,Be,Bv] plot Fisher, Kent, Bingham, Bootstrap ellipses or Boostrap eigenvectors
-c plot as colour contour
-sav save plot and quit quietly
NOTE
all: entire file; sit: site; sam: sample; spc: specimen
"""
FIG={} # plot dictionary
FIG['eqarea']=1 # eqarea is figure 1
in_file,plot_key,coord,crd='pmag_results.txt','all',"0",'g'
plotE,contour=0,0
dir_path='.'
fmt='svg'
verbose=pmagplotlib.verbose
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
pmagplotlib.plot_init(FIG['eqarea'],5,5)
if '-f' in sys.argv:
ind=sys.argv.index("-f")
in_file=dir_path+"/"+sys.argv[ind+1]
if '-obj' in sys.argv:
ind=sys.argv.index('-obj')
plot_by=sys.argv[ind+1]
if plot_by=='all':plot_key='all'
if plot_by=='sit':plot_key='er_site_name'
if plot_by=='sam':plot_key='er_sample_name'
if plot_by=='spc':plot_key='er_specimen_name'
if '-c' in sys.argv: contour=1
plt=0
if '-sav' in sys.argv:
plt=1
verbose=0
if '-ell' in sys.argv:
plotE=1
ind=sys.argv.index('-ell')
ell_type=sys.argv[ind+1]
if ell_type=='F':dist='F'
if ell_type=='K':dist='K'
if ell_type=='B':dist='B'
if ell_type=='Be':dist='BE'
if ell_type=='Bv':
dist='BV'
FIG['bdirs']=2
pmagplotlib.plot_init(FIG['bdirs'],5,5)
if '-crd' in sys.argv:
ind=sys.argv.index("-crd")
crd=sys.argv[ind+1]
if crd=='s':coord="-1"
if crd=='g':coord="0"
if crd=='t':coord="100"
if '-fmt' in sys.argv:
ind=sys.argv.index("-fmt")
fmt=sys.argv[ind+1]
Dec_keys=['site_dec','sample_dec','specimen_dec','measurement_dec','average_dec','none']
Inc_keys=['site_inc','sample_inc','specimen_inc','measurement_inc','average_inc','none']
Tilt_keys=['tilt_correction','site_tilt_correction','sample_tilt_correction','specimen_tilt_correction','none']
Dir_type_keys=['','site_direction_type','sample_direction_type','specimen_direction_type']
Name_keys=['er_specimen_name','er_sample_name','er_site_name','pmag_result_name']
data,file_type=pmag.magic_read(in_file)
if file_type=='pmag_results' and plot_key!="all":plot_key=plot_key+'s' # need plural for results table
if verbose:
print len(data),' records read from ',in_file
#
#
# find desired dec,inc data:
#
dir_type_key=''
#
# get plotlist if not plotting all records
#
plotlist=[]
if plot_key!="all":
plots=pmag.get_dictitem(data,plot_key,'','F')
for rec in plots:
if rec[plot_key] not in plotlist:
plotlist.append(rec[plot_key])
plotlist.sort()
else:
plotlist.append('All')
for plot in plotlist:
#if verbose: print plot
DIblock=[]
GCblock=[]
SLblock,SPblock=[],[]
title=plot
mode=1
dec_key,inc_key,tilt_key,name_key,k="","","","",0
if plot!="All":
odata=pmag.get_dictitem(data,plot_key,plot,'T')
else: odata=data # data for this obj
for dec_key in Dec_keys:
Decs=pmag.get_dictitem(odata,dec_key,'','F') # get all records with this dec_key not blank
if len(Decs)>0: break
for inc_key in Inc_keys:
Incs=pmag.get_dictitem(Decs,inc_key,'','F') # get all records with this inc_key not blank
if len(Incs)>0: break
for tilt_key in Tilt_keys:
if tilt_key in Incs[0].keys(): break # find the tilt_key for these records
if tilt_key=='none': # no tilt key in data, need to fix this with fake data which will be unknown tilt
tilt_key='tilt_correction'
for rec in Incs:rec[tilt_key]=''
cdata=pmag.get_dictitem(Incs,tilt_key,coord,'T') # get all records matching specified coordinate system
if coord=='0': # geographic
udata=pmag.get_dictitem(Incs,tilt_key,'','T') # get all the blank records - assume geographic
if len(cdata)==0: crd=''
if len(udata)>0:
for d in udata:cdata.append(d)
crd=crd+'u'
for name_key in Name_keys:
Names=pmag.get_dictitem(cdata,name_key,'','F') # get all records with this name_key not blank
if len(Names)>0: break
for dir_type_key in Dir_type_keys:
Dirs=pmag.get_dictitem(cdata,dir_type_key,'','F') # get all records with this direction type
if len(Dirs)>0: break
if dir_type_key=="":dir_type_key='direction_type'
locations,site,sample,specimen="","","",""
for rec in cdata: # pick out the data
if 'er_location_name' in rec.keys() and rec['er_location_name']!="" and rec['er_location_name'] not in locations:locations=locations+rec['er_location_name'].replace("/","")+"_"
if 'er_location_names' in rec.keys() and rec['er_location_names']!="":
locs=rec['er_location_names'].split(':')
for loc in locs:
if loc not in locations:locations=locations+loc.replace("/","")+'_'
if plot_key=='er_site_name' or plot_key=='er_sample_name' or plot_key=='er_specimen_name':
site=rec['er_site_name']
if plot_key=='er_sample_name' or plot_key=='er_specimen_name':
sample=rec['er_sample_name']
if plot_key=='er_specimen_name':
specimen=rec['er_specimen_name']
if plot_key=='er_site_names' or plot_key=='er_sample_names' or plot_key=='er_specimen_names':
site=rec['er_site_names']
if plot_key=='er_sample_names' or plot_key=='er_specimen_names':
sample=rec['er_sample_names']
if plot_key=='er_specimen_names':
specimen=rec['er_specimen_names']
if dir_type_key not in rec.keys() or rec[dir_type_key]=="":rec[dir_type_key]='l'
if 'magic_method_codes' not in rec.keys():rec['magic_method_codes']=""
DIblock.append([float(rec[dec_key]),float(rec[inc_key])])
SLblock.append([rec[name_key],rec['magic_method_codes']])
if rec[tilt_key]==coord and rec[dir_type_key]!='l' and rec[dec_key]!="" and rec[inc_key]!="":
GCblock.append([float(rec[dec_key]),float(rec[inc_key])])
SPblock.append([rec[name_key],rec['magic_method_codes']])
if len(DIblock)==0 and len(GCblock)==0:
if verbose: print "no records for plotting"
sys.exit()
if verbose:
for k in range(len(SLblock)):
print '%s %s %7.1f %7.1f'%(SLblock[k][0],SLblock[k][1],DIblock[k][0],DIblock[k][1])
for k in range(len(SPblock)):
print '%s %s %7.1f %7.1f'%(SPblock[k][0],SPblock[k][1],GCblock[k][0],GCblock[k][1])
if len(DIblock)>0:
if contour==0:
pmagplotlib.plotEQ(FIG['eqarea'],DIblock,title)
else:
pmagplotlib.plotEQcont(FIG['eqarea'],DIblock)
else: pmagplotlib.plotNET(FIG['eqarea'])
if len(GCblock)>0:
for rec in GCblock: pmagplotlib.plotC(FIG['eqarea'],rec,90.,'g')
if plotE==1:
ppars=pmag.doprinc(DIblock) # get principal directions
nDIs,rDIs,npars,rpars=[],[],[],[]
for rec in DIblock:
angle=pmag.angle([rec[0],rec[1]],[ppars['dec'],ppars['inc']])
if angle>90.:
rDIs.append(rec)
else:
nDIs.append(rec)
if dist=='B': # do on whole dataset
etitle="Bingham confidence ellipse"
bpars=pmag.dobingham(DIblock)
for key in bpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(bpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(bpars[key])
npars.append(bpars['dec'])
npars.append(bpars['inc'])
npars.append(bpars['Zeta'])
npars.append(bpars['Zdec'])
npars.append(bpars['Zinc'])
npars.append(bpars['Eta'])
npars.append(bpars['Edec'])
npars.append(bpars['Einc'])
if dist=='F':
etitle="Fisher confidence cone"
if len(nDIs)>2:
fpars=pmag.fisher_mean(nDIs)
for key in fpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(fpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(fpars[key])
mode+=1
npars.append(fpars['dec'])
npars.append(fpars['inc'])
npars.append(fpars['alpha95']) # Beta
npars.append(fpars['dec'])
isign=abs(fpars['inc'])/fpars['inc']
npars.append(fpars['inc']-isign*90.) #Beta inc
npars.append(fpars['alpha95']) # gamma
npars.append(fpars['dec']+90.) # Beta dec
npars.append(0.) #Beta inc
if len(rDIs)>2:
fpars=pmag.fisher_mean(rDIs)
if verbose:print "mode ",mode
for key in fpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(fpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(fpars[key])
mode+=1
rpars.append(fpars['dec'])
rpars.append(fpars['inc'])
rpars.append(fpars['alpha95']) # Beta
rpars.append(fpars['dec'])
isign=abs(fpars['inc'])/fpars['inc']
rpars.append(fpars['inc']-isign*90.) #Beta inc
rpars.append(fpars['alpha95']) # gamma
rpars.append(fpars['dec']+90.) # Beta dec
rpars.append(0.) #Beta inc
if dist=='K':
etitle="Kent confidence ellipse"
if len(nDIs)>3:
kpars=pmag.dokent(nDIs,len(nDIs))
if verbose:print "mode ",mode
for key in kpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(kpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(kpars[key])
mode+=1
npars.append(kpars['dec'])
npars.append(kpars['inc'])
npars.append(kpars['Zeta'])
npars.append(kpars['Zdec'])
npars.append(kpars['Zinc'])
npars.append(kpars['Eta'])
npars.append(kpars['Edec'])
npars.append(kpars['Einc'])
if len(rDIs)>3:
kpars=pmag.dokent(rDIs,len(rDIs))
if verbose:print "mode ",mode
for key in kpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(kpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(kpars[key])
mode+=1
rpars.append(kpars['dec'])
rpars.append(kpars['inc'])
rpars.append(kpars['Zeta'])
rpars.append(kpars['Zdec'])
rpars.append(kpars['Zinc'])
rpars.append(kpars['Eta'])
rpars.append(kpars['Edec'])
rpars.append(kpars['Einc'])
else: # assume bootstrap
if dist=='BE':
if len(nDIs)>5:
BnDIs=pmag.di_boot(nDIs)
Bkpars=pmag.dokent(BnDIs,1.)
if verbose:print "mode ",mode
for key in Bkpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(Bkpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(Bkpars[key])
mode+=1
npars.append(Bkpars['dec'])
npars.append(Bkpars['inc'])
npars.append(Bkpars['Zeta'])
npars.append(Bkpars['Zdec'])
npars.append(Bkpars['Zinc'])
npars.append(Bkpars['Eta'])
npars.append(Bkpars['Edec'])
npars.append(Bkpars['Einc'])
if len(rDIs)>5:
BrDIs=pmag.di_boot(rDIs)
Bkpars=pmag.dokent(BrDIs,1.)
if verbose:print "mode ",mode
for key in Bkpars.keys():
if key!='n' and verbose:print " ",key, '%7.1f'%(Bkpars[key])
if key=='n' and verbose:print " ",key, ' %i'%(Bkpars[key])
mode+=1
rpars.append(Bkpars['dec'])
rpars.append(Bkpars['inc'])
rpars.append(Bkpars['Zeta'])
rpars.append(Bkpars['Zdec'])
rpars.append(Bkpars['Zinc'])
rpars.append(Bkpars['Eta'])
rpars.append(Bkpars['Edec'])
rpars.append(Bkpars['Einc'])
etitle="Bootstrapped confidence ellipse"
elif dist=='BV':
sym={'lower':['o','c'],'upper':['o','g'],'size':3,'edgecolor':'face'}
if len(nDIs)>5:
BnDIs=pmag.di_boot(nDIs)
pmagplotlib.plotEQsym(FIG['bdirs'],BnDIs,'Bootstrapped Eigenvectors', sym)
if len(rDIs)>5:
BrDIs=pmag.di_boot(rDIs)
if len(nDIs)>5: # plot on existing plots
pmagplotlib.plotDIsym(FIG['bdirs'],BrDIs,sym)
else:
pmagplotlib.plotEQ(FIG['bdirs'],BrDIs,'Bootstrapped Eigenvectors')
if dist=='B':
if len(nDIs)> 3 or len(rDIs)>3: pmagplotlib.plotCONF(FIG['eqarea'],etitle,[],npars,0)
elif len(nDIs)>3 and dist!='BV':
pmagplotlib.plotCONF(FIG['eqarea'],etitle,[],npars,0)
if len(rDIs)>3:
pmagplotlib.plotCONF(FIG['eqarea'],etitle,[],rpars,0)
elif len(rDIs)>3 and dist!='BV':
pmagplotlib.plotCONF(FIG['eqarea'],etitle,[],rpars,0)
if verbose:pmagplotlib.drawFIGS(FIG)
#
files={}
locations=locations[:-1]
for key in FIG.keys():
filename='LO:_'+locations+'_SI:_'+site+'_SA:_'+sample+'_SP:_'+specimen+'_CO:_'+crd+'_TY:_'+key+'_.'+fmt
files[key]=filename
if pmagplotlib.isServer:
black = '#000000'
purple = '#800080'
titles={}
titles['eq']='Equal Area Plot'
FIG = pmagplotlib.addBorders(FIG,titles,black,purple)
pmagplotlib.saveP(FIG,files)
elif verbose:
ans=raw_input(" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans=="q": sys.exit()
if ans=="a": pmagplotlib.saveP(FIG,files)
if plt:
pmagplotlib.saveP(FIG,files)
def main():
"""
NAME
make_magic_plots.py
DESCRIPTION
inspects magic directory for available 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
-DM [2,3] define data model
"""
dirlist=['./']
dir_path=os.getcwd()
names=os.listdir(dir_path)
for n in names:
if 'Location' in n:
dirlist.append(n)
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)
new_model=0
if '-DM' in sys.argv:
ind=sys.argv.index("-DM")
data_model=sys.argv[ind+1]
if data_model=='3': new_model=1
if new_model:
samp_file='samples.txt'
azimuth_key='azimuth'
meas_file='measurements.txt'
loc_key='location'
method_key='method_codes'
dec_key='dir_dec'
inc_key='dir_inc'
Mkeys=['magnitude','magn_moment','magn_volume','magn_mass']
results_file='sites.txt'
tilt_key='direction_tilt_correction'
hyst_file='specimens.txt'
aniso_file='specimens.txt'
else:
new_model=0
samp_file='er_samples.txt'
azimuth_key='sample_azimuth'
meas_file='magic_measurements.txt'
loc_key='er_location_name'
method_key='magic_method_codes'
dec_key='measurement_dec'
inc_key='measurement_inc'
Mkeys=['measurement_magnitude','measurement_magn_moment','measurement_magn_volume','measurement_magn_mass']
results_file='pmag_results.txt'
tilt_key='tilt_correction'
hyst_file='rmag_hysteresis'
aniso_file='rmag_anisotropy'
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
for loc in dirlist:
print('working on: ',loc)
os.chdir(loc) # change working directories to each location
crd='s'
print(samp_file)
if samp_file in filelist: # find coordinate systems
print('found sample file')
samps,file_type=pmag.magic_read(samp_file) # read in data
Srecs=pmag.get_dictitem(samps,azimuth_key,'','F')# get all none blank sample orientations
if len(Srecs)>0:
crd='g'
if meas_file in filelist: # start with measurement data
print('working on measurements data')
data,file_type=pmag.magic_read(meas_file) # read in data
if loc == './': data=pmag.get_dictitem(data,loc_key,'','T') # get all the blank location names from data file
# looking for zeq_magic possibilities
AFZrecs=pmag.get_dictitem(data,method_key,'LT-AF-Z','has')# get all none blank method codes
TZrecs=pmag.get_dictitem(data,method_key,'LT-T-Z','has')# get all none blank method codes
MZrecs=pmag.get_dictitem(data,method_key,'LT-M-Z','has')# get all none blank method codes
Drecs=pmag.get_dictitem(data,dec_key,'','F') # get all dec measurements
Irecs=pmag.get_dictitem(data,inc_key,'','F') # get all inc measurements
for key in Mkeys:
Mrecs=pmag.get_dictitem(data,key,'','F') # get intensity data
if len(Mrecs)>0:break
if len(AFZrecs)>0 or len(TZrecs)>0 or len(MZrecs)>0 and len(Drecs)>0 and len(Irecs)>0 and len(Mrecs)>0: # potential for stepwise demag curves
if new_model:
CMD = 'zeq_magic3.py -fsp specimens.txt -sav -fmt '+fmt+' -crd '+crd
else:
CMD='zeq_magic.py -fsp pmag_specimens.txt -sav -fmt '+fmt+' -crd '+crd
print(CMD)
os.system(CMD)
# looking for thellier_magic possibilities
if len(pmag.get_dictitem(data,method_key,'LP-PI-TRM','has'))>0:
if new_model:
CMD= 'thellier_magic3.py -fsp specimens.txt -sav -fmt '+fmt
else:
CMD= 'thellier_magic.py -fsp pmag_specimens.txt -sav -fmt '+fmt
print(CMD)
os.system(CMD)
# looking for hysteresis possibilities
if len(pmag.get_dictitem(data,method_key,'LP-HYS','has'))>0: # find hyst experiments
if new_model:
CMD= 'quick_hyst3.py -sav -fmt '+fmt
else:
CMD= 'quick_hyst.py -sav -fmt '+fmt
print(CMD)
os.system(CMD)
if results_file in filelist: # start with measurement data
data,file_type=pmag.magic_read(results_file) # read in data
print('number of datapoints: ',len(data))
if loc == './': data=pmag.get_dictitem(data,loc_key,':','has') # get all the concatenated location names from data file
print('number of datapoints: ',len(data) ,loc)
if new_model:
print('working on site directions')
dec_key='dir_dec'
inc_key='dir_inc'
int_key='int_abs'
else:
print('working on results directions')
dec_key='average_dec'
inc_key='average_inc'
int_key='average_int'
SiteDIs=pmag.get_dictitem(data,dec_key,"",'F') # find decs
SiteDIs=pmag.get_dictitem(SiteDIs,inc_key,"",'F') # find decs and incs
SiteDIs=pmag.get_dictitem(SiteDIs,'data_type','i','has') # only individual results - not poles
print('number of directions: ',len(SiteDIs))
SiteDIs_t=pmag.get_dictitem(SiteDIs,tilt_key,'100','T')# tilt corrected coordinates
print('number of tilt corrected directions: ',len(SiteDIs))
SiteDIs_g=pmag.get_dictitem(SiteDIs,tilt_key,'0','T')# geographic coordinates
SiteDIs_s=pmag.get_dictitem(SiteDIs,'tilt_correction','-1','T')# sample coordinates
SiteDIs_x=pmag.get_dictitem(SiteDIs,'tilt_correction','','T')# no coordinates
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'
elif len(SiteDIs_g )>0:
CRD=' -crd g'
elif len(SiteDIs_s )>0:
CRD=' -crd s'
if new_model:
CMD= 'eqarea_magic3.py -sav -crd t -fmt '+fmt +CRD
else:
CMD= 'eqarea_magic.py -sav -crd t -fmt '+fmt +CRD
print(CMD)
os.system(CMD)
print('working on VGP map')
VGPs=pmag.get_dictitem(SiteDIs,'vgp_lat',"",'F') # are there any VGPs?
if len(VGPs)>0: # YES!
os.system('vgpmap_magic.py -prj moll -res c -sym ro 5 -sav -fmt png')
print('working on intensities')
if not new_model:
CMD='magic_select.py -f '+results_file+' -key data_type i T -F tmp.txt'
os.system(CMD)
infile=' tmp.txt'
else: infile=results_file
print(int_key)
CMD='magic_select.py -key '+int_key +' 0. has -F tmp1.txt -f '+infile
os.system(CMD)
CMD="grab_magic_key.py -f tmp1.txt -key "+int_key+ " | awk '{print $1*1e6}' >tmp2.txt"
os.system(CMD)
data,file_type=pmag.magic_read('tmp1.txt') # read in data
if new_model:
locations=pmag.get_dictkey(data,loc_key,"")
else:
locations=pmag.get_dictkey(data,loc_key+'s',"")
histfile='LO:_'+locations[0]+'_intensities_histogram:_.'+fmt
os.system("histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F " +histfile)
print("histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F " +histfile)
os.system('rm tmp*.txt')
if hyst_file in filelist: # start with measurement data
print('working on hysteresis')
data,file_type=pmag.magic_read(hyst_file) # read in data
if loc == './': data=pmag.get_dictitem(data,loc_key,'','T') # get all the blank location names from data file
hdata=pmag.get_dictitem(data,'hysteresis_bcr','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_mr_moment','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_ms_moment','','F')
hdata=pmag.get_dictitem(hdata,'hysteresis_bc','','F') # there are data for a dayplot
if len(hdata)>0:
print('dayplot_magic.py -sav -fmt '+fmt)
os.system('dayplot_magic.py -sav -fmt '+fmt)
if aniso_file in filelist: # do anisotropy plots if possible
print('working on anisotropy')
data,file_type=pmag.magic_read(aniso_file) # read in data
if loc == './': data=pmag.get_dictitem(data,loc_key,'','T') # get all the blank location names from data file
sdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','-1','T') # get specimen coordinates
gdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','0','T') # get specimen coordinates
tdata=pmag.get_dictitem(data,'anisotropy_tilt_correction','100','T') # get specimen coordinates
CRD=""
if new_model:
CMD= 'aniso_magic3.py -x -B -sav -fmt '+fmt
else:
CMD= 'aniso_magic.py -x -B -sav -fmt '+fmt
if len(sdata)>3:
CMD=CMD+' -crd s'
print(CMD)
os.system(CMD)
if len(gdata)>3:
CMD=CMD+' -crd g'
print(CMD)
os.system(CMD)
if len(tdata)>3:
CMD=CMD+' -crd t'
print(CMD)
os.system(CMD)
if loc!='./':os.chdir('..') # change working directories to each location
def main():
"""
NAME
foldtest_magic.py
DESCRIPTION
does a fold test (Tauxe, 2010) on data
INPUT FORMAT
pmag_specimens format file, er_samples.txt format file (for bedding)
SYNTAX
foldtest_magic.py [command line options]
OPTIONS
-h prints help message and quits
-f pmag_sites formatted file [default is pmag_sites.txt]
-fsa er_samples formatted file [default is er_samples.txt]
-fsi er_sites formatted file
-exc use pmag_criteria.txt to set acceptance criteria
-n NB, set number of bootstraps, default is 1000
-b MIN, MAX, set bounds for untilting, default is -10, 150
-fmt FMT, specify format - default is svg
-sav saves plots and quits
OUTPUT
Geographic: is an equal area projection of the input data in
original coordinates
Stratigraphic: is an equal area projection of the input data in
tilt adjusted coordinates
% Untilting: The dashed (red) curves are representative plots of
maximum eigenvalue (tau_1) as a function of untilting
The solid line is the cumulative distribution of the
% Untilting required to maximize tau for all the
bootstrapped data sets. The dashed vertical lines
are 95% confidence bounds on the % untilting that yields
the most clustered result (maximum tau_1).
Command line: prints out the bootstrapped iterations and
finally the confidence bounds on optimum untilting.
If the 95% conf bounds include 0, then a pre-tilt magnetization is indicated
If the 95% conf bounds include 100, then a post-tilt magnetization is indicated
If the 95% conf bounds exclude both 0 and 100, syn-tilt magnetization is
possible as is vertical axis rotation or other pathologies
"""
kappa = 0
nb = 1000 # number of bootstraps
min, max = -10, 150
dir_path = '.'
infile, orfile = 'pmag_sites.txt', 'er_samples.txt'
critfile = 'pmag_criteria.txt'
dipkey, azkey = 'sample_bed_dip', 'sample_bed_dip_direction'
fmt = 'svg'
plot = 0
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
if '-h' in sys.argv: # check if help is needed
print(main.__doc__)
sys.exit() # graceful quit
if '-n' in sys.argv:
ind = sys.argv.index('-n')
nb = int(sys.argv[ind + 1])
if '-fmt' in sys.argv:
ind = sys.argv.index('-fmt')
fmt = sys.argv[ind + 1]
if '-sav' in sys.argv: plot = 1
if '-b' in sys.argv:
ind = sys.argv.index('-b')
min = int(sys.argv[ind + 1])
max = int(sys.argv[ind + 2])
if '-f' in sys.argv:
ind = sys.argv.index('-f')
infile = sys.argv[ind + 1]
if '-fsa' in sys.argv:
ind = sys.argv.index('-fsa')
orfile = sys.argv[ind + 1]
elif '-fsi' in sys.argv:
ind = sys.argv.index('-fsi')
orfile = sys.argv[ind + 1]
dipkey, azkey = 'site_bed_dip', 'site_bed_dip_direction'
orfile = dir_path + '/' + orfile
infile = dir_path + '/' + infile
critfile = dir_path + '/' + critfile
data, file_type = pmag.magic_read(infile)
ordata, file_type = pmag.magic_read(orfile)
if '-exc' in sys.argv:
crits, file_type = pmag.magic_read(critfile)
for crit in crits:
if crit['pmag_criteria_code'] == "DE-SITE":
SiteCrit = crit
break
# get to work
#
PLTS = {'geo': 1, 'strat': 2, 'taus': 3} # make plot dictionary
pmagplotlib.plot_init(PLTS['geo'], 5, 5)
pmagplotlib.plot_init(PLTS['strat'], 5, 5)
pmagplotlib.plot_init(PLTS['taus'], 5, 5)
GEOrecs = pmag.get_dictitem(data, 'site_tilt_correction', '0', 'T')
if len(GEOrecs) > 0: # have some geographic data
DIDDs = [] # set up list for dec inc dip_direction, dip
for rec in GEOrecs: # parse data
dip, dip_dir = 0, -1
Dec = float(rec['site_dec'])
Inc = float(rec['site_inc'])
orecs = pmag.get_dictitem(ordata, 'er_site_name',
rec['er_site_name'], 'T')
if len(orecs) > 0:
if orecs[0][azkey] != "": dip_dir = float(orecs[0][azkey])
if orecs[0][dipkey] != "": dip = float(orecs[0][dipkey])
if dip != 0 and dip_dir != -1:
if '-exc' in sys.argv:
keep = 1
for key in list(SiteCrit.keys()):
if 'site' in key and SiteCrit[key] != "" and rec[
key] != "" and key != 'site_alpha95':
if float(rec[key]) < float(SiteCrit[key]):
keep = 0
print(rec['er_site_name'], key, rec[key])
if key == 'site_alpha95' and SiteCrit[
key] != "" and rec[key] != "":
if float(rec[key]) > float(SiteCrit[key]):
keep = 0
if keep == 1: DIDDs.append([Dec, Inc, dip_dir, dip])
else:
DIDDs.append([Dec, Inc, dip_dir, dip])
else:
print('no geographic directional data found')
sys.exit()
pmagplotlib.plotEQ(PLTS['geo'], DIDDs, 'Geographic')
data = numpy.array(DIDDs)
D, I = pmag.dotilt_V(data)
TCs = numpy.array([D, I]).transpose()
pmagplotlib.plotEQ(PLTS['strat'], TCs, 'Stratigraphic')
if plot == 0: pmagplotlib.drawFIGS(PLTS)
Percs = list(range(min, max))
Cdf, Untilt = [], []
pylab.figure(num=PLTS['taus'])
print('doing ', nb, ' iterations...please be patient.....')
for n in range(
nb): # do bootstrap data sets - plot first 25 as dashed red line
if n % 50 == 0: print(n)
Taus = [] # set up lists for taus
PDs = pmag.pseudo(DIDDs)
if kappa != 0:
for k in range(len(PDs)):
d, i = pmag.fshdev(kappa)
dipdir, dip = pmag.dodirot(d, i, PDs[k][2], PDs[k][3])
PDs[k][2] = dipdir
PDs[k][3] = dip
for perc in Percs:
tilt = numpy.array([1., 1., 1., 0.01 * perc])
D, I = pmag.dotilt_V(PDs * tilt)
TCs = numpy.array([D, I]).transpose()
ppars = pmag.doprinc(TCs) # get principal directions
Taus.append(ppars['tau1'])
if n < 25: pylab.plot(Percs, Taus, 'r--')
Untilt.append(Percs[Taus.index(
numpy.max(Taus))]) # tilt that gives maximum tau
Cdf.append(old_div(float(n), float(nb)))
pylab.plot(Percs, Taus, 'k')
pylab.xlabel('% Untilting')
pylab.ylabel('tau_1 (red), CDF (green)')
Untilt.sort() # now for CDF of tilt of maximum tau
pylab.plot(Untilt, Cdf, 'g')
lower = int(.025 * nb)
upper = int(.975 * nb)
pylab.axvline(x=Untilt[lower], ymin=0, ymax=1, linewidth=1, linestyle='--')
pylab.axvline(x=Untilt[upper], ymin=0, ymax=1, linewidth=1, linestyle='--')
tit = '%i - %i %s' % (Untilt[lower], Untilt[upper], 'Percent Unfolding')
print(tit)
pylab.title(tit)
if plot == 0:
pmagplotlib.drawFIGS(PLTS)
ans = input('S[a]ve all figures, <Return> to quit \n ')
if ans != 'a':
print("Good bye")
sys.exit()
files = {}
for key in list(PLTS.keys()):
files[key] = ('foldtest_' + '%s' % (key.strip()[:2]) + '.' + fmt)
pmagplotlib.saveP(PLTS, files)
def main():
"""
NAME
thellier_magic_redo.py
DESCRIPTION
Calculates paleointensity parameters for thellier-thellier type data using bounds
stored in the "redo" file
SYNTAX
thellier_magic_redo [command line options]
OPTIONS
-h prints help message
-usr USER: identify user, default is ""
-fcr CRIT, set criteria for grading
-f IN: specify input file, default is magic_measurements.txt
-fre REDO: specify redo file, default is "thellier_redo"
-F OUT: specify output file, default is thellier_specimens.txt
-leg: attaches "Recalculated from original measurements; supercedes published results. " to comment field
-CR PERC TYPE: apply a blanket cooling rate correction if none supplied in the er_samples.txt file
PERC should be a percentage of original (say reduce to 90%)
TYPE should be one of the following:
EG (for educated guess); PS (based on pilots); TRM (based on comparison of two TRMs)
-ANI: perform anisotropy correction
-fsa SAMPFILE: er_samples.txt file with cooling rate correction information, default is NO CORRECTION
-Fcr CRout: specify pmag_specimen format file for cooling rate corrected data
-fan ANIFILE: specify rmag_anisotropy format file, default is rmag_anisotropy.txt
-Fac ACout: specify pmag_specimen format file for anisotropy corrected data
default is AC_specimens.txt
-fnl NLTFILE: specify magic_measurments format file, default is magic_measurements.txt
-Fnl NLTout: specify pmag_specimen format file for non-linear trm corrected data
default is NLT_specimens.txt
-z use z component differenences for pTRM calculation
INPUT
a thellier_redo file is Specimen_name Tmin Tmax (where Tmin and Tmax are in Centigrade)
"""
dir_path='.'
critout=""
version_num=pmag.get_version()
field,first_save=-1,1
spec,recnum,start,end=0,0,0,0
crfrac=0
NltRecs,PmagSpecs,AniSpecRecs,NltSpecRecs,CRSpecs=[],[],[],[],[]
meas_file,pmag_file,mk_file="magic_measurements.txt","thellier_specimens.txt","thellier_redo"
anis_file="rmag_anisotropy.txt"
anisout,nltout="AC_specimens.txt","NLT_specimens.txt"
crout="CR_specimens.txt"
nlt_file=""
samp_file=""
comment,user="","unknown"
anis,nltrm=0,0
jackknife=0 # maybe in future can do jackknife
args=sys.argv
Zdiff=0
if '-WD' in args:
ind=args.index('-WD')
dir_path=args[ind+1]
if "-h" in args:
print(main.__doc__)
sys.exit()
if "-usr" in args:
ind=args.index("-usr")
user=sys.argv[ind+1]
if "-leg" in args: comment="Recalculated from original measurements; supercedes published results. "
cool=0
if "-CR" in args:
cool=1
ind=args.index("-CR")
crfrac=.01*float(sys.argv[ind+1])
crtype='DA-CR-'+sys.argv[ind+2]
if "-Fcr" in args:
ind=args.index("-Fcr")
crout=sys.argv[ind+1]
if "-f" in args:
ind=args.index("-f")
meas_file=sys.argv[ind+1]
if "-F" in args:
ind=args.index("-F")
pmag_file=sys.argv[ind+1]
if "-fre" in args:
ind=args.index("-fre")
mk_file=args[ind+1]
if "-fsa" in args:
ind=args.index("-fsa")
samp_file=dir_path+'/'+args[ind+1]
Samps,file_type=pmag.magic_read(samp_file)
SampCRs=pmag.get_dictitem(Samps,'cooling_rate_corr','','F') # get samples cooling rate corrections
cool=1
if file_type!='er_samples':
print('not a valid er_samples.txt file')
sys.exit()
#
#
if "-ANI" in args:
anis=1
ind=args.index("-ANI")
if "-Fac" in args:
ind=args.index("-Fac")
anisout=args[ind+1]
if "-fan" in args:
ind=args.index("-fan")
anis_file=args[ind+1]
#
if "-NLT" in args:
if "-Fnl" in args:
ind=args.index("-Fnl")
nltout=args[ind+1]
if "-fnl" in args:
ind=args.index("-fnl")
nlt_file=args[ind+1]
if "-z" in args: Zdiff=1
if '-fcr' in sys.argv:
ind=args.index("-fcr")
critout=sys.argv[ind+1]
#
# start reading in data:
#
meas_file=dir_path+"/"+meas_file
mk_file=dir_path+"/"+mk_file
accept=pmag.default_criteria(1)[0] # set criteria to none
if critout!="":
critout=dir_path+"/"+critout
crit_data,file_type=pmag.magic_read(critout)
if file_type!='pmag_criteria':
print('bad pmag_criteria file, using no acceptance criteria')
print("Acceptance criteria read in from ", critout)
for critrec in crit_data:
if 'sample_int_sigma_uT' in list(critrec.keys()): # accommodate Shaar's new criterion
critrec['sample_int_sigma']='%10.3e'%(eval(critrec['sample_int_sigma_uT'])*1e-6)
for key in list(critrec.keys()):
if key not in list(accept.keys()) and critrec[key]!='':
accept[key]=critrec[key]
meas_data,file_type=pmag.magic_read(meas_file)
if file_type != 'magic_measurements':
print(file_type)
print(file_type,"This is not a valid magic_measurements file ")
sys.exit()
try:
mk_f=open(mk_file,'r')
except:
print("Bad redo file")
sys.exit()
mkspec=[]
speclist=[]
for line in mk_f.readlines():
tmp=line.split()
mkspec.append(tmp)
speclist.append(tmp[0])
if anis==1:
anis_file=dir_path+"/"+anis_file
anis_data,file_type=pmag.magic_read(anis_file)
if file_type != 'rmag_anisotropy':
print(file_type)
print(file_type,"This is not a valid rmag_anisotropy file ")
sys.exit()
if nlt_file=="":
nlt_data=pmag.get_dictitem(meas_data,'magic_method_codes','LP-TRM','has') # look for trm acquisition data in the meas_data file
else:
nlt_file=dir_path+"/"+nlt_file
nlt_data,file_type=pmag.magic_read(nlt_file)
if len(nlt_data)>0:
nltrm=1
#
# sort the specimen names and step through one by one
#
sids=pmag.get_specs(meas_data)
#
print('Processing ',len(speclist),' specimens - please wait ')
while spec < len(speclist):
s=speclist[spec]
recnum=0
datablock=[]
PmagSpecRec={}
PmagSpecRec["er_analyst_mail_names"]=user
PmagSpecRec["er_citation_names"]="This study"
PmagSpecRec["magic_software_packages"]=version_num
methcodes,inst_code=[],""
#
# find the data from the meas_data file for this specimen
#
datablock=pmag.get_dictitem(meas_data,'er_specimen_name',s,'T')
datablock=pmag.get_dictitem(datablock,'magic_method_codes','LP-PI-TRM','has') #pick out the thellier experiment data
if len(datablock)>0:
for rec in datablock:
if "magic_instrument_codes" not in list(rec.keys()): rec["magic_instrument_codes"]="unknown"
#
# collect info for the PmagSpecRec dictionary
#
rec=datablock[0]
PmagSpecRec["er_specimen_name"]=s
PmagSpecRec["er_sample_name"]=rec["er_sample_name"]
PmagSpecRec["er_site_name"]=rec["er_site_name"]
PmagSpecRec["er_location_name"]=rec["er_location_name"]
PmagSpecRec["measurement_step_unit"]="K"
PmagSpecRec["specimen_correction"]='u'
if "er_expedition_name" in list(rec.keys()):PmagSpecRec["er_expedition_name"]=rec["er_expedition_name"]
if "magic_instrument_codes" not in list(rec.keys()):
PmagSpecRec["magic_instrument_codes"]="unknown"
else:
PmagSpecRec["magic_instrument_codes"]=rec["magic_instrument_codes"]
if "magic_experiment_name" not in list(rec.keys()):
rec["magic_experiment_name"]=""
else:
PmagSpecRec["magic_experiment_names"]=rec["magic_experiment_name"]
meths=rec["magic_experiment_name"].split(":")
for meth in meths:
if meth.strip() not in methcodes and "LP-" in meth:methcodes.append(meth.strip())
#
# sort out the data into first_Z, first_I, ptrm_check, ptrm_tail
#
araiblock,field=pmag.sortarai(datablock,s,Zdiff)
first_Z=araiblock[0]
first_I=araiblock[1]
ptrm_check=araiblock[2]
ptrm_tail=araiblock[3]
if len(first_I)<3 or len(first_Z)<4:
spec+=1
print('skipping specimen ', s)
else:
#
# get start, end
#
for redospec in mkspec:
if redospec[0]==s:
b,e=float(redospec[1]),float(redospec[2])
break
if e > float(first_Z[-1][0]):e=float(first_Z[-1][0])
for recnum in range(len(first_Z)):
if first_Z[recnum][0]==b:start=recnum
if first_Z[recnum][0]==e:end=recnum
nsteps=end-start
if nsteps>2:
zijdblock,units=pmag.find_dmag_rec(s,meas_data)
pars,errcode=pmag.PintPars(datablock,araiblock,zijdblock,start,end,accept)
if 'specimen_scat' in list(pars.keys()): PmagSpecRec['specimen_scat']=pars['specimen_scat']
if 'specimen_frac' in list(pars.keys()): PmagSpecRec['specimen_frac']='%5.3f'%(pars['specimen_frac'])
if 'specimen_gmax' in list(pars.keys()): PmagSpecRec['specimen_gmax']='%5.3f'%(pars['specimen_gmax'])
pars['measurement_step_unit']=units
pars["specimen_lab_field_dc"]=field
pars["specimen_int"]=-1*field*pars["specimen_b"]
PmagSpecRec["measurement_step_min"]='%8.3e' % (pars["measurement_step_min"])
PmagSpecRec["measurement_step_max"]='%8.3e' % (pars["measurement_step_max"])
PmagSpecRec["specimen_int_n"]='%i'%(pars["specimen_int_n"])
PmagSpecRec["specimen_lab_field_dc"]='%8.3e'%(pars["specimen_lab_field_dc"])
PmagSpecRec["specimen_int"]='%9.4e '%(pars["specimen_int"])
PmagSpecRec["specimen_b"]='%5.3f '%(pars["specimen_b"])
PmagSpecRec["specimen_q"]='%5.1f '%(pars["specimen_q"])
PmagSpecRec["specimen_f"]='%5.3f '%(pars["specimen_f"])
PmagSpecRec["specimen_fvds"]='%5.3f'%(pars["specimen_fvds"])
PmagSpecRec["specimen_b_beta"]='%5.3f'%(pars["specimen_b_beta"])
PmagSpecRec["specimen_int_mad"]='%7.1f'%(pars["specimen_int_mad"])
PmagSpecRec["specimen_gamma"]='%7.1f'%(pars["specimen_gamma"])
if pars["magic_method_codes"]!="" and pars["magic_method_codes"] not in methcodes: methcodes.append(pars["magic_method_codes"])
PmagSpecRec["specimen_dec"]='%7.1f'%(pars["specimen_dec"])
PmagSpecRec["specimen_inc"]='%7.1f'%(pars["specimen_inc"])
PmagSpecRec["specimen_tilt_correction"]='-1'
PmagSpecRec["specimen_direction_type"]='l'
PmagSpecRec["direction_type"]='l' # this is redudant, but helpful - won't be imported
PmagSpecRec["specimen_dang"]='%7.1f '%(pars["specimen_dang"])
PmagSpecRec["specimen_drats"]='%7.1f '%(pars["specimen_drats"])
PmagSpecRec["specimen_drat"]='%7.1f '%(pars["specimen_drat"])
PmagSpecRec["specimen_int_ptrm_n"]='%i '%(pars["specimen_int_ptrm_n"])
PmagSpecRec["specimen_rsc"]='%6.4f '%(pars["specimen_rsc"])
PmagSpecRec["specimen_md"]='%i '%(int(pars["specimen_md"]))
if PmagSpecRec["specimen_md"]=='-1':PmagSpecRec["specimen_md"]=""
PmagSpecRec["specimen_b_sigma"]='%5.3f '%(pars["specimen_b_sigma"])
if "IE-TT" not in methcodes:methcodes.append("IE-TT")
methods=""
for meth in methcodes:
methods=methods+meth+":"
PmagSpecRec["magic_method_codes"]=methods.strip(':')
PmagSpecRec["magic_software_packages"]=version_num
PmagSpecRec["specimen_description"]=comment
if critout!="":
kill=pmag.grade(PmagSpecRec,accept,'specimen_int')
if len(kill)>0:
Grade='F' # fails
else:
Grade='A' # passes
PmagSpecRec["specimen_grade"]=Grade
else:
PmagSpecRec["specimen_grade"]="" # not graded
if nltrm==0 and anis==0 and cool!=0: # apply cooling rate correction
SCR=pmag.get_dictitem(SampCRs,'er_sample_name',PmagSpecRec['er_sample_name'],'T') # get this samples, cooling rate correction
CrSpecRec=pmag.cooling_rate(PmagSpecRec,SCR,crfrac,crtype)
if CrSpecRec['er_specimen_name']!='none':CrSpecs.append(CrSpecRec)
PmagSpecs.append(PmagSpecRec)
NltSpecRec=""
#
# check on non-linear TRM correction
#
if nltrm==1:
#
# find the data from the nlt_data list for this specimen
#
TRMs,Bs=[],[]
NltSpecRec=""
NltRecs=pmag.get_dictitem(nlt_data,'er_specimen_name',PmagSpecRec['er_specimen_name'],'has') # fish out all the NLT data for this specimen
if len(NltRecs) > 2:
for NltRec in NltRecs:
Bs.append(float(NltRec['treatment_dc_field']))
TRMs.append(float(NltRec['measurement_magn_moment']))
NLTpars=nlt.NLtrm(Bs,TRMs,float(PmagSpecRec['specimen_int']),float(PmagSpecRec['specimen_lab_field_dc']),0)
if NLTpars['banc']>0:
NltSpecRec={}
for key in list(PmagSpecRec.keys()):
NltSpecRec[key]=PmagSpecRec[key]
NltSpecRec['specimen_int']='%9.4e'%(NLTpars['banc'])
NltSpecRec['magic_method_codes']=PmagSpecRec["magic_method_codes"]+":DA-NL"
NltSpecRec["specimen_correction"]='c'
NltSpecRec['specimen_grade']=PmagSpecRec['specimen_grade']
NltSpecRec["magic_software_packages"]=version_num
print(NltSpecRec['er_specimen_name'], ' Banc= ',float(NLTpars['banc'])*1e6)
if anis==0 and cool!=0:
SCR=pmag.get_dictitem(SampCRs,'er_sample_name',NltSpecRec['er_sample_name'],'T') # get this samples, cooling rate correction
CrSpecRec=pmag.cooling_rate(NltSpecRec,SCR,crfrac,crtype)
if CrSpecRec['er_specimen_name']!='none':CrSpecs.append(CrSpecRec)
NltSpecRecs.append(NltSpecRec)
#
# check on anisotropy correction
if anis==1:
if NltSpecRec!="":
Spc=NltSpecRec
else: # find uncorrected data
Spc=PmagSpecRec
AniSpecs=pmag.get_dictitem(anis_data,'er_specimen_name',PmagSpecRec['er_specimen_name'],'T')
if len(AniSpecs)>0:
AniSpec=AniSpecs[0]
AniSpecRec=pmag.doaniscorr(Spc,AniSpec)
AniSpecRec['specimen_grade']=PmagSpecRec['specimen_grade']
AniSpecRec["magic_instrument_codes"]=PmagSpecRec['magic_instrument_codes']
AniSpecRec["specimen_correction"]='c'
AniSpecRec["magic_software_packages"]=version_num
if cool!=0:
SCR=pmag.get_dictitem(SampCRs,'er_sample_name',AniSpecRec['er_sample_name'],'T') # get this samples, cooling rate correction
CrSpecRec=pmag.cooling_rate(AniSpecRec,SCR,crfrac,crtype)
if CrSpecRec['er_specimen_name']!='none':CrSpecs.append(CrSpecRec)
AniSpecRecs.append(AniSpecRec)
elif anis==1:
AniSpecs=pmag.get_dictitem(anis_data,'er_specimen_name',PmagSpecRec['er_specimen_name'],'T')
if len(AniSpecs)>0:
AniSpec=AniSpecs[0]
AniSpecRec=pmag.doaniscorr(PmagSpecRec,AniSpec)
AniSpecRec['specimen_grade']=PmagSpecRec['specimen_grade']
AniSpecRec["magic_instrument_codes"]=PmagSpecRec["magic_instrument_codes"]
AniSpecRec["specimen_correction"]='c'
AniSpecRec["magic_software_packages"]=version_num
if crfrac!=0:
CrSpecRec={}
for key in list(AniSpecRec.keys()):CrSpecRec[key]=AniSpecRec[key]
inten=frac*float(CrSpecRec['specimen_int'])
CrSpecRec["specimen_int"]='%9.4e '%(inten) # adjust specimen intensity by cooling rate correction
CrSpecRec['magic_method_codes'] = CrSpecRec['magic_method_codes']+':DA-CR-'+crtype
CRSpecs.append(CrSpecRec)
AniSpecRecs.append(AniSpecRec)
spec +=1
else:
print("skipping ",s)
spec+=1
pmag_file=dir_path+'/'+pmag_file
pmag.magic_write(pmag_file,PmagSpecs,'pmag_specimens')
print('uncorrected thellier data saved in: ',pmag_file)
if anis==1 and len(AniSpecRecs)>0:
anisout=dir_path+'/'+anisout
pmag.magic_write(anisout,AniSpecRecs,'pmag_specimens')
print('anisotropy corrected data saved in: ',anisout)
if nltrm==1 and len(NltSpecRecs)>0:
nltout=dir_path+'/'+nltout
pmag.magic_write(nltout,NltSpecRecs,'pmag_specimens')
print('non-linear TRM corrected data saved in: ',nltout)
if crfrac!=0:
crout=dir_path+'/'+crout
pmag.magic_write(crout,CRSpecs,'pmag_specimens')
print('cooling rate corrected data saved in: ',crout)
def main():
"""
NAME
lowrie_magic.py
DESCRIPTION
plots intensity decay curves for Lowrie experiments
SYNTAX
lowrie_magic.py -h [command line options]
INPUT
takes magic_measurements formatted input files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is magic_measurements.txt
-N do not normalize by maximum magnetization
-fmt [svg, pdf, eps, png] specify fmt, default is svg
-sav saves plots and quits
"""
fmt,plot='svg',0
FIG={} # plot dictionary
FIG['lowrie']=1 # demag is figure 1
pmagplotlib.plot_init(FIG['lowrie'],6,6)
norm=1 # default is to normalize by maximum axis
in_file,dir_path='magic_measurements.txt','.'
if len(sys.argv)>1:
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-N' in sys.argv: norm=0 # don't normalize
if '-sav' in sys.argv: plot=1 # don't normalize
if '-fmt' in sys.argv: # sets input filename
ind=sys.argv.index("-fmt")
fmt=sys.argv[ind+1]
if '-f' in sys.argv: # sets input filename
ind=sys.argv.index("-f")
in_file=sys.argv[ind+1]
else:
print main.__doc__
print 'you must supply a file name'
sys.exit()
in_file=dir_path+'/'+in_file
print in_file
PmagRecs,file_type=pmag.magic_read(in_file)
if file_type!="magic_measurements":
print 'bad input file'
sys.exit()
PmagRecs=pmag.get_dictitem(PmagRecs,'magic_method_codes','LP-IRM-3D','has') # get all 3D IRM records
if len(PmagRecs)==0:
print 'no records found'
sys.exit()
specs=pmag.get_dictkey(PmagRecs,'er_specimen_name','')
sids=[]
for spec in specs:
if spec not in sids:sids.append(spec) # get list of unique specimen names
for spc in sids: # step through the specimen names
print spc
specdata=pmag.get_dictitem(PmagRecs,'er_specimen_name',spc,'T') # get all this one's data
DIMs,Temps=[],[]
for dat in specdata: # step through the data
DIMs.append([float(dat['measurement_dec']),float(dat['measurement_inc']),float(dat['measurement_magn_moment'])])
Temps.append(float(dat['treatment_temp'])-273.)
carts=pmag.dir2cart(DIMs).transpose()
if norm==1: # want to normalize
nrm=(DIMs[0][2]) # normalize by NRM
ylab="M/M_o"
else:
nrm=1. # don't normalize
ylab="Magnetic moment (Am^2)"
xlab="Temperature (C)"
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[0])/nrm,sym='r-')
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[0])/nrm,sym='ro') # X direction
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[1])/nrm,sym='c-')
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[1])/nrm,sym='cs') # Y direction
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[2])/nrm,sym='k-')
pmagplotlib.plotXY(FIG['lowrie'],Temps,abs(carts[2])/nrm,sym='k^',title=spc,xlab=xlab,ylab=ylab) # Z direction
files={'lowrie':'lowrie:_'+spc+'_.'+fmt}
if plot==0:
pmagplotlib.drawFIGS(FIG)
ans=raw_input('S[a]ve figure? [q]uit, <return> to continue ')
if ans=='a':
pmagplotlib.saveP(FIG,files)
elif ans=='q':
sys.exit()
else:
pmagplotlib.saveP(FIG,files)
pmagplotlib.clearFIG(FIG['lowrie'])
def main():
"""
NAME
atrm_magic.py
DESCRIPTION
Converts ATRM data to best-fit tensor (6 elements plus sigma)
Original program ARMcrunch written to accomodate ARM anisotropy data
collected from 6 axial directions (+X,+Y,+Z,-X,-Y,-Z) using the
off-axis remanence terms to construct the tensor. A better way to
do the anisotropy of ARMs is to use 9,12 or 15 measurements in
the Hext rotational scheme.
SYNTAX
atrm_magic.py [-h][command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f FILE: specify input file, default is atrm_measurements.txt
-Fa FILE: specify anisotropy output file, default is trm_anisotropy.txt
-Fr FILE: specify results output file, default is atrm_results.txt
INPUT
Input for the present program is a TRM acquisition data with an optional baseline.
The order of the measurements is:
Decs=[0,90,0,180,270,0,0,90,0]
Incs=[0,0,90,0,0,-90,0,0,90]
The last two measurements are optional
"""
# initialize some parameters
args = sys.argv
user = ""
meas_file = "atrm_measurements.txt"
rmag_anis = "trm_anisotropy.txt"
rmag_res = "atrm_results.txt"
dir_path = '.'
#
# get name of file from command line
#
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind + 1]
if "-h" in args:
print(main.__doc__)
sys.exit()
if "-usr" in args:
ind = args.index("-usr")
user = sys.argv[ind + 1]
if "-f" in args:
ind = args.index("-f")
meas_file = sys.argv[ind + 1]
if "-Fa" in args:
ind = args.index("-Fa")
rmag_anis = args[ind + 1]
if "-Fr" in args:
ind = args.index("-Fr")
rmag_res = args[ind + 1]
meas_file = dir_path + '/' + meas_file
rmag_anis = dir_path + '/' + rmag_anis
rmag_res = dir_path + '/' + rmag_res
# read in data
meas_data, file_type = pmag.magic_read(meas_file)
meas_data = pmag.get_dictitem(meas_data, 'magic_method_codes', 'LP-AN-TRM',
'has')
if file_type != 'magic_measurements':
print(file_type)
print(file_type, "This is not a valid magic_measurements file ")
sys.exit()
#
#
# get sorted list of unique specimen names
ssort = []
for rec in meas_data:
spec = rec["er_specimen_name"]
if spec not in ssort: ssort.append(spec)
sids = sorted(ssort)
#
#
# work on each specimen
#
specimen, npos = 0, 6
RmagSpecRecs, RmagResRecs = [], []
while specimen < len(sids):
nmeas = 0
s = sids[specimen]
RmagSpecRec = {}
RmagResRec = {}
BX, X = [], []
method_codes = []
Spec0 = ""
#
# find the data from the meas_data file for this sample
# and get dec, inc, int and convert to x,y,z
#
data = pmag.get_dictitem(meas_data, 'er_specimen_name', s,
'T') # fish out data for this specimen name
if len(data) > 5:
RmagSpecRec["rmag_anisotropy_name"] = data[0]["er_specimen_name"]
RmagSpecRec["er_location_name"] = data[0]["er_location_name"]
RmagSpecRec["er_specimen_name"] = data[0]["er_specimen_name"]
RmagSpecRec["er_sample_name"] = data[0]["er_sample_name"]
RmagSpecRec["er_site_name"] = data[0]["er_site_name"]
RmagSpecRec["magic_experiment_names"] = RmagSpecRec[
"rmag_anisotropy_name"] + ":ATRM"
RmagSpecRec["er_citation_names"] = "This study"
RmagResRec[
"rmag_result_name"] = data[0]["er_specimen_name"] + ":ATRM"
RmagResRec["er_location_names"] = data[0]["er_location_name"]
RmagResRec["er_specimen_names"] = data[0]["er_specimen_name"]
RmagResRec["er_sample_names"] = data[0]["er_sample_name"]
RmagResRec["er_site_names"] = data[0]["er_site_name"]
RmagResRec["magic_experiment_names"] = RmagSpecRec[
"rmag_anisotropy_name"] + ":ATRM"
RmagResRec["er_citation_names"] = "This study"
RmagSpecRec["anisotropy_type"] = "ATRM"
if "magic_instrument_codes" in list(data[0].keys()):
RmagSpecRec["magic_instrument_codes"] = data[0][
"magic_instrument_codes"]
else:
RmagSpecRec["magic_instrument_codes"] = ""
RmagSpecRec[
"anisotropy_description"] = "Hext statistics adapted to ATRM"
for rec in data:
meths = rec['magic_method_codes'].strip().split(':')
Dir = []
Dir.append(float(rec["measurement_dec"]))
Dir.append(float(rec["measurement_inc"]))
Dir.append(float(rec["measurement_magn_moment"]))
if "LT-T-Z" in meths:
BX.append(pmag.dir2cart(Dir)) # append baseline steps
elif "LT-T-I" in meths:
X.append(pmag.dir2cart(Dir))
nmeas += 1
#
if len(BX) == 1:
for i in range(len(X) - 1):
BX.append(BX[0]) # assume first 0 field step as baseline
elif len(BX) == 0: # assume baseline is zero
for i in range(len(X)):
BX.append([0., 0., 0.]) # assume baseline of 0
elif len(BX) != len(
X
): # if BX isn't just one measurement or one in between every infield step, just assume it is zero
print('something odd about the baselines - just assuming zero')
for i in range(len(X)):
BX.append([0., 0., 0.]) # assume baseline of 0
if nmeas < 6: # must have at least 6 measurements right now -
print('skipping specimen ', s, ' too few measurements')
specimen += 1
else:
B, H, tmpH = pmag.designATRM(
npos) # B matrix made from design matrix for positions
#
# subtract optional baseline and put in a work array
#
work = numpy.zeros((nmeas, 3), 'f')
for i in range(nmeas):
for j in range(3):
work[i][j] = X[i][j] - BX[i][
j] # subtract baseline, if available
#
# calculate tensor elements
# first put ARM components in w vector
#
w = numpy.zeros((npos * 3), 'f')
index = 0
for i in range(npos):
for j in range(3):
w[index] = work[i][j]
index += 1
s = numpy.zeros((6), 'f') # initialize the s matrix
for i in range(6):
for j in range(len(w)):
s[i] += B[i][j] * w[j]
trace = s[0] + s[1] + s[2] # normalize by the trace
for i in range(6):
s[i] = old_div(s[i], trace)
a = pmag.s2a(s)
#------------------------------------------------------------
# Calculating dels is different than in the Kappabridge
# routine. Use trace normalized tensor (a) and the applied
# unit field directions (tmpH) to generate model X,Y,Z
# components. Then compare these with the measured values.
#------------------------------------------------------------
S = 0.
comp = numpy.zeros((npos * 3), 'f')
for i in range(npos):
for j in range(3):
index = i * 3 + j
compare = a[j][0] * tmpH[i][0] + a[j][1] * tmpH[i][1] + a[
j][2] * tmpH[i][2]
comp[index] = compare
for i in range(npos * 3):
d = old_div(w[i], trace) - comp[i] # del values
S += d * d
nf = float(npos * 3. - 6.) # number of degrees of freedom
if S > 0:
sigma = numpy.sqrt(old_div(S, nf))
else:
sigma = 0
hpars = pmag.dohext(nf, sigma, s)
#
# prepare for output
#
RmagSpecRec["anisotropy_s1"] = '%8.6f' % (s[0])
RmagSpecRec["anisotropy_s2"] = '%8.6f' % (s[1])
RmagSpecRec["anisotropy_s3"] = '%8.6f' % (s[2])
RmagSpecRec["anisotropy_s4"] = '%8.6f' % (s[3])
RmagSpecRec["anisotropy_s5"] = '%8.6f' % (s[4])
RmagSpecRec["anisotropy_s6"] = '%8.6f' % (s[5])
RmagSpecRec["anisotropy_mean"] = '%8.3e' % (old_div(trace, 3))
RmagSpecRec["anisotropy_sigma"] = '%8.6f' % (sigma)
RmagSpecRec["anisotropy_unit"] = "Am^2"
RmagSpecRec["anisotropy_n"] = '%i' % (npos)
RmagSpecRec["anisotropy_tilt_correction"] = '-1'
RmagSpecRec["anisotropy_F"] = '%7.1f ' % (
hpars["F"]
) # used by thellier_gui - must be taken out for uploading
RmagSpecRec["anisotropy_F_crit"] = hpars[
"F_crit"] # used by thellier_gui - must be taken out for uploading
RmagResRec["anisotropy_t1"] = '%8.6f ' % (hpars["t1"])
RmagResRec["anisotropy_t2"] = '%8.6f ' % (hpars["t2"])
RmagResRec["anisotropy_t3"] = '%8.6f ' % (hpars["t3"])
RmagResRec["anisotropy_v1_dec"] = '%7.1f ' % (hpars["v1_dec"])
RmagResRec["anisotropy_v2_dec"] = '%7.1f ' % (hpars["v2_dec"])
RmagResRec["anisotropy_v3_dec"] = '%7.1f ' % (hpars["v3_dec"])
RmagResRec["anisotropy_v1_inc"] = '%7.1f ' % (hpars["v1_inc"])
RmagResRec["anisotropy_v2_inc"] = '%7.1f ' % (hpars["v2_inc"])
RmagResRec["anisotropy_v3_inc"] = '%7.1f ' % (hpars["v3_inc"])
RmagResRec["anisotropy_ftest"] = '%7.1f ' % (hpars["F"])
RmagResRec["anisotropy_ftest12"] = '%7.1f ' % (hpars["F12"])
RmagResRec["anisotropy_ftest23"] = '%7.1f ' % (hpars["F23"])
RmagResRec["result_description"] = 'Critical F: ' + hpars[
"F_crit"] + ';Critical F12/F13: ' + hpars["F12_crit"]
if hpars["e12"] > hpars["e13"]:
RmagResRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
else:
RmagResRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
if hpars["e23"] > hpars['e12']:
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
else:
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["tilt_correction"] = '-1'
RmagResRec["anisotropy_type"] = 'ATRM'
RmagResRec["magic_method_codes"] = 'LP-AN-TRM:AE-H'
RmagSpecRec["magic_method_codes"] = 'LP-AN-TRM:AE-H'
RmagResRec["magic_software_packages"] = pmag.get_version()
RmagSpecRec["magic_software_packages"] = pmag.get_version()
RmagSpecRecs.append(RmagSpecRec)
RmagResRecs.append(RmagResRec)
specimen += 1
pmag.magic_write(rmag_anis, RmagSpecRecs, 'rmag_anisotropy')
print("specimen tensor elements stored in ", rmag_anis)
pmag.magic_write(rmag_res, RmagResRecs, 'rmag_results')
print("specimen statistics and eigenparameters stored in ", rmag_res)
def main():
"""
NAME
zeq_magic_redo.py
DESCRIPTION
Calculate principal components through demagnetization data using bounds and calculation type stored in "redo" file
SYNTAX
zeq_magic_redo.py [command line options]
OPTIONS
-h prints help message
-usr USER: identify user, default is ""
-f: specify input file, default is magic_measurements.txt
-F: specify output file, default is zeq_specimens.txt
-fre REDO: specify redo file, default is "zeq_redo"
-fsa SAMPFILE: specify er_samples format file, default is "er_samples.txt"
-A : don't average replicate measurements, default is yes
-crd [s,g,t] :
specify coordinate system [s,g,t] [default is specimen coordinates]
are specimen, geographic, and tilt corrected respectively
NB: you must have a SAMPFILE in this directory to rotate from specimen coordinates
-leg: attaches "Recalculated from original measurements; supercedes published results. " to comment field
INPUTS
zeq_redo format file is:
specimen_name calculation_type[DE-BFL,DE-BFL-A,DE-BFL-O,DE-BFP,DE-FM] step_min step_max component_name[A,B,C]
"""
dir_path = '.'
INCL = ["LT-NO", "LT-AF-Z", "LT-T-Z", "LT-M-Z"] # looking for demag data
beg, end, pole, geo, tilt, askave, save = 0, 0, [], 0, 0, 0, 0
user, doave, comment = "", 1, ""
geo, tilt = 0, 0
version_num = pmag.get_version()
args = sys.argv
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind + 1]
meas_file, pmag_file, mk_file = dir_path + "/" + "magic_measurements.txt", dir_path + "/" + "zeq_specimens.txt", dir_path + "/" + "zeq_redo"
samp_file, coord = dir_path + "/" + "er_samples.txt", ""
if "-h" in args:
print(main.__doc__)
sys.exit()
if "-usr" in args:
ind = args.index("-usr")
user = sys.argv[ind + 1]
if "-A" in args: doave = 0
if "-leg" in args:
comment = "Recalculated from original measurements; supercedes published results. "
if "-f" in args:
ind = args.index("-f")
meas_file = dir_path + '/' + sys.argv[ind + 1]
if "-F" in args:
ind = args.index("-F")
pmag_file = dir_path + '/' + sys.argv[ind + 1]
if "-fre" in args:
ind = args.index("-fre")
mk_file = dir_path + "/" + args[ind + 1]
try:
mk_f = open(mk_file, 'r')
except:
print("Bad redo file")
sys.exit()
mkspec, skipped = [], []
speclist = []
for line in mk_f.readlines():
tmp = line.split()
mkspec.append(tmp)
speclist.append(tmp[0])
if "-fsa" in args:
ind = args.index("-fsa")
samp_file = dir_path + '/' + sys.argv[ind + 1]
if "-crd" in args:
ind = args.index("-crd")
coord = sys.argv[ind + 1]
if coord == "g": geo, tilt = 1, 0
if coord == "t": geo, tilt = 1, 1
#
# now get down to bidness
if geo == 1:
samp_data, file_type = pmag.magic_read(samp_file)
if file_type != 'er_samples':
print(file_type)
print("This is not a valid er_samples file ")
sys.exit()
#
#
#
meas_data, file_type = pmag.magic_read(meas_file)
if file_type != 'magic_measurements':
print(file_type)
print(file_type, "This is not a valid magic_measurements file ")
sys.exit()
#
# sort the specimen names
#
k = 0
print('Processing ', len(speclist), ' specimens - please wait')
PmagSpecs = []
while k < len(speclist):
s = speclist[k]
recnum = 0
PmagSpecRec = {}
method_codes, inst_codes = [], []
# find the data from the meas_data file for this sample
#
# collect info for the PmagSpecRec dictionary
#
meas_meth = []
spec = pmag.get_dictitem(meas_data, 'er_specimen_name', s, 'T')
if len(spec) == 0:
print('no data found for specimen: ', s)
print('delete from zeq_redo input file...., then try again')
else:
for rec in spec: # copy of vital stats to PmagSpecRec from first spec record in demag block
skip = 1
methods = rec["magic_method_codes"].split(":")
if len(set(methods) & set(INCL)) > 0:
PmagSpecRec["er_analyst_mail_names"] = user
PmagSpecRec["magic_software_packages"] = version_num
PmagSpecRec["er_specimen_name"] = s
PmagSpecRec["er_sample_name"] = rec["er_sample_name"]
PmagSpecRec["er_site_name"] = rec["er_site_name"]
PmagSpecRec["er_location_name"] = rec["er_location_name"]
if "er_expedition_name" in list(rec.keys()):
PmagSpecRec["er_expedition_name"] = rec[
"er_expedition_name"]
PmagSpecRec["er_citation_names"] = "This study"
if "magic_experiment_name" not in list(rec.keys()):
rec["magic_experiment_name"] = ""
PmagSpecRec["magic_experiment_names"] = rec[
"magic_experiment_name"]
if "magic_instrument_codes" not in list(rec.keys()):
rec["magic_instrument_codes"] = ""
inst = rec['magic_instrument_codes'].split(":")
for I in inst:
if I not in inst_codes: # copy over instruments
inst_codes.append(I)
meths = rec["magic_method_codes"].split(":")
for meth in meths:
if meth.strip() not in meas_meth:
meas_meth.append(meth)
if "LP-DIR-AF" in meas_meth or "LT-AF-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"] = "T"
if "LP-DIR-AF" not in method_codes:
method_codes.append("LP-DIR-AF")
if "LP-DIR-T" in meas_meth or "LT-T-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"] = "K"
if "LP-DIR-T" not in method_codes:
method_codes.append("LP-DIR-T")
if "LP-DIR-M" in meas_meth or "LT-M-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"] = "J"
if "LP-DIR-M" not in method_codes:
method_codes.append("LP-DIR-M")
#
#
datablock, units = pmag.find_dmag_rec(
s, spec) # fish out the demag data for this specimen
#
if len(datablock) < 2 or s not in speclist:
k += 1
# print 'skipping ', s,len(datablock)
else:
#
# find replicate measurements at given treatment step and average them
#
# step_meth,avedata=pmag.vspec(data)
#
# if len(avedata) != len(datablock):
# if doave==1:
# method_codes.append("DE-VM")
# datablock=avedata
#
# do geo or stratigraphic correction now
#
if geo == 1 or tilt == 1:
# find top priority orientation method
orient, az_type = pmag.get_orient(
samp_data, PmagSpecRec["er_sample_name"])
if az_type not in method_codes: method_codes.append(az_type)
#
# if tilt selected, get stratigraphic correction
#
tiltblock, geoblock = [], []
for rec in datablock:
if "sample_azimuth" in list(
orient.keys()) and orient["sample_azimuth"] != "":
d_geo, i_geo = pmag.dogeo(
rec[1], rec[2], float(orient["sample_azimuth"]),
float(orient["sample_dip"]))
geoblock.append(
[rec[0], d_geo, i_geo, rec[3], rec[4], rec[5]])
if tilt == 1 and "sample_bed_dip_direction" in list(
orient.keys()):
d_tilt, i_tilt = pmag.dotilt(
d_geo, i_geo,
float(orient["sample_bed_dip_direction"]),
float(orient["sample_bed_dip"]))
tiltblock.append([
rec[0], d_tilt, i_tilt, rec[3], rec[4], rec[5]
])
elif tilt == 1:
if PmagSpecRec["er_sample_name"] not in skipped:
print('no tilt correction for ',
PmagSpecRec["er_sample_name"],
' skipping....')
skipped.append(PmagSpecRec["er_sample_name"])
else:
if PmagSpecRec["er_sample_name"] not in skipped:
print('no geographic correction for ',
PmagSpecRec["er_sample_name"],
' skipping....')
skipped.append(PmagSpecRec["er_sample_name"])
#
# get beg_pca, end_pca, pca
if PmagSpecRec['er_sample_name'] not in skipped:
compnum = -1
for spec in mkspec:
if spec[0] == s:
CompRec = {}
for key in list(PmagSpecRec.keys()):
CompRec[key] = PmagSpecRec[key]
compnum += 1
calculation_type = spec[1]
beg = float(spec[2])
end = float(spec[3])
if len(spec) > 4:
comp_name = spec[4]
else:
comp_name = string.uppercase[compnum]
CompRec['specimen_comp_name'] = comp_name
if beg < float(datablock[0][0]):
beg = float(datablock[0][0])
if end > float(datablock[-1][0]):
end = float(datablock[-1][0])
for l in range(len(datablock)):
if datablock[l][0] == beg: beg_pca = l
if datablock[l][0] == end: end_pca = l
if geo == 1 and tilt == 0:
mpars = pmag.domean(geoblock, beg_pca, end_pca,
calculation_type)
if mpars["specimen_direction_type"] != "Error":
CompRec["specimen_dec"] = '%7.1f ' % (
mpars["specimen_dec"])
CompRec["specimen_inc"] = '%7.1f ' % (
mpars["specimen_inc"])
CompRec["specimen_tilt_correction"] = '0'
if geo == 1 and tilt == 1:
mpars = pmag.domean(tiltblock, beg_pca, end_pca,
calculation_type)
if mpars["specimen_direction_type"] != "Error":
CompRec["specimen_dec"] = '%7.1f ' % (
mpars["specimen_dec"])
CompRec["specimen_inc"] = '%7.1f ' % (
mpars["specimen_inc"])
CompRec["specimen_tilt_correction"] = '100'
if geo == 0 and tilt == 0:
mpars = pmag.domean(datablock, beg_pca, end_pca,
calculation_type)
if mpars["specimen_direction_type"] != "Error":
CompRec["specimen_dec"] = '%7.1f ' % (
mpars["specimen_dec"])
CompRec["specimen_inc"] = '%7.1f ' % (
mpars["specimen_inc"])
CompRec["specimen_tilt_correction"] = '-1'
if mpars["specimen_direction_type"] == "Error":
pass
else:
CompRec["measurement_step_min"] = '%8.3e ' % (
datablock[beg_pca][0])
try:
CompRec["measurement_step_max"] = '%8.3e ' % (
datablock[end_pca][0])
except:
print('error in end_pca ',
PmagSpecRec['er_specimen_name'])
CompRec["specimen_correction"] = 'u'
if calculation_type != 'DE-FM':
CompRec["specimen_mad"] = '%7.1f ' % (
mpars["specimen_mad"])
CompRec["specimen_alpha95"] = ""
else:
CompRec["specimen_mad"] = ""
CompRec["specimen_alpha95"] = '%7.1f ' % (
mpars["specimen_alpha95"])
CompRec["specimen_n"] = '%i ' % (
mpars["specimen_n"])
CompRec["specimen_dang"] = '%7.1f ' % (
mpars["specimen_dang"])
CompMeths = []
for meth in method_codes:
if meth not in CompMeths:
CompMeths.append(meth)
if calculation_type not in CompMeths:
CompMeths.append(calculation_type)
if geo == 1: CompMeths.append("DA-DIR-GEO")
if tilt == 1: CompMeths.append("DA-DIR-TILT")
if "DE-BFP" not in calculation_type:
CompRec["specimen_direction_type"] = 'l'
else:
CompRec["specimen_direction_type"] = 'p'
CompRec["magic_method_codes"] = ""
if len(CompMeths) != 0:
methstring = ""
for meth in CompMeths:
methstring = methstring + ":" + meth
CompRec[
"magic_method_codes"] = methstring.strip(
':')
CompRec["specimen_description"] = comment
if len(inst_codes) != 0:
inststring = ""
for inst in inst_codes:
inststring = inststring + ":" + inst
CompRec[
"magic_instrument_codes"] = inststring.strip(
':')
PmagSpecs.append(CompRec)
k += 1
pmag.magic_write(pmag_file, PmagSpecs, 'pmag_specimens')
print("Recalculated specimen data stored in ", pmag_file)
def main():
"""
NAME
foldtest_magic.py
DESCRIPTION
does a fold test (Tauxe, 2010) on data
INPUT FORMAT
pmag_specimens format file, er_samples.txt format file (for bedding)
SYNTAX
foldtest_magic.py [command line options]
OPTIONS
-h prints help message and quits
-f sites formatted file [default for 3.0 is sites.txt, for 2.5, pmag_sites.txt]
-fsa samples formatted file
-fsi sites formatted file
-exc use criteria to set acceptance criteria (supported only for data model 3)
-n NB, set number of bootstraps, default is 1000
-b MIN, MAX, set bounds for untilting, default is -10, 150
-fmt FMT, specify format - default is svg
-sav saves plots and quits
-DM NUM MagIC data model number (2 or 3, default 3)
OUTPUT
Geographic: is an equal area projection of the input data in
original coordinates
Stratigraphic: is an equal area projection of the input data in
tilt adjusted coordinates
% Untilting: The dashed (red) curves are representative plots of
maximum eigenvalue (tau_1) as a function of untilting
The solid line is the cumulative distribution of the
% Untilting required to maximize tau for all the
bootstrapped data sets. The dashed vertical lines
are 95% confidence bounds on the % untilting that yields
the most clustered result (maximum tau_1).
Command line: prints out the bootstrapped iterations and
finally the confidence bounds on optimum untilting.
If the 95% conf bounds include 0, then a pre-tilt magnetization is indicated
If the 95% conf bounds include 100, then a post-tilt magnetization is indicated
If the 95% conf bounds exclude both 0 and 100, syn-tilt magnetization is
possible as is vertical axis rotation or other pathologies
"""
if '-h' in sys.argv: # check if help is needed
print(main.__doc__)
sys.exit() # graceful quit
kappa = 0
dir_path = pmag.get_named_arg("-WD", ".")
nboot = int(float(pmag.get_named_arg("-n", 1000))) # number of bootstraps
fmt = pmag.get_named_arg("-fmt", "svg")
data_model_num = int(float(pmag.get_named_arg("-DM", 3)))
if data_model_num == 3:
infile = pmag.get_named_arg("-f", 'sites.txt')
orfile = 'samples.txt'
site_col = 'site'
dec_col = 'dir_dec'
inc_col = 'dir_inc'
tilt_col = 'dir_tilt_correction'
dipkey, azkey = 'bed_dip', 'bed_dip_direction'
crit_col = 'criterion'
critfile = 'criteria.txt'
else:
infile = pmag.get_named_arg("-f", 'pmag_sites.txt')
orfile = 'er_samples.txt'
site_col = 'er_site_name'
dec_col = 'site_dec'
inc_col = 'site_inc'
tilt_col = 'site_tilt_correction'
dipkey, azkey = 'sample_bed_dip', 'sample_bed_dip_direction'
crit_col = 'pmag_criteria_code'
critfile = 'pmag_criteria.txt'
if '-sav' in sys.argv:
plot = 1
else:
plot = 0
if '-b' in sys.argv:
ind = sys.argv.index('-b')
untilt_min = int(sys.argv[ind + 1])
untilt_max = int(sys.argv[ind + 2])
else:
untilt_min, untilt_max = -10, 150
if '-fsa' in sys.argv:
orfile = pmag.get_named_arg("-fsa", "")
elif '-fsi' in sys.argv:
orfile = pmag.get_named_arg("-fsi", "")
if data_model_num == 3:
dipkey, azkey = 'bed_dip', 'bed_dip_direction'
else:
dipkey, azkey = 'site_bed_dip', 'site_bed_dip_direction'
else:
if data_model_num == 3:
orfile = 'sites.txt'
else:
orfile = 'pmag_sites.txt'
orfile = pmag.resolve_file_name(orfile, dir_path)
infile = pmag.resolve_file_name(infile, dir_path)
critfile = pmag.resolve_file_name(critfile, dir_path)
df = pd.read_csv(infile, sep='\t', header=1)
# keep only records with tilt_col
data = df.copy()
data = data[data[tilt_col].notnull()]
data = data.where(data.notnull(), "")
# turn into pmag data list
data = list(data.T.apply(dict))
# get orientation data
if data_model_num == 3:
# often orientation will be in infile (sites table)
if os.path.split(orfile)[1] == os.path.split(infile)[1]:
ordata = df[df[azkey].notnull()]
ordata = ordata[ordata[dipkey].notnull()]
ordata = list(ordata.T.apply(dict))
# sometimes orientation might be in a sample file instead
else:
ordata = pd.read_csv(orfile, sep='\t', header=1)
ordata = list(ordata.T.apply(dict))
else:
ordata, file_type = pmag.magic_read(orfile)
if '-exc' in sys.argv:
crits, file_type = pmag.magic_read(critfile)
SiteCrits = []
for crit in crits:
if crit[crit_col] == "DE-SITE":
SiteCrits.append(crit)
#break
# get to work
#
PLTS = {'geo': 1, 'strat': 2, 'taus': 3} # make plot dictionary
if not set_env.IS_WIN:
pmagplotlib.plot_init(PLTS['geo'], 5, 5)
pmagplotlib.plot_init(PLTS['strat'], 5, 5)
pmagplotlib.plot_init(PLTS['taus'], 5, 5)
if data_model_num == 2:
GEOrecs = pmag.get_dictitem(data, tilt_col, '0', 'T')
else:
GEOrecs = data
if len(GEOrecs) > 0: # have some geographic data
num_dropped = 0
DIDDs = [] # set up list for dec inc dip_direction, dip
for rec in GEOrecs: # parse data
dip, dip_dir = 0, -1
Dec = float(rec[dec_col])
Inc = float(rec[inc_col])
orecs = pmag.get_dictitem(ordata, site_col, rec[site_col], 'T')
if len(orecs) > 0:
if orecs[0][azkey] != "":
dip_dir = float(orecs[0][azkey])
if orecs[0][dipkey] != "":
dip = float(orecs[0][dipkey])
if dip != 0 and dip_dir != -1:
if '-exc' in sys.argv:
keep = 1
for site_crit in SiteCrits:
crit_name = site_crit['table_column'].split('.')[1]
if crit_name and crit_name in rec.keys(
) and rec[crit_name]:
# get the correct operation (<, >=, =, etc.)
op = OPS[site_crit['criterion_operation']]
# then make sure the site record passes
if op(float(rec[crit_name]),
float(site_crit['criterion_value'])):
keep = 0
if keep == 1:
DIDDs.append([Dec, Inc, dip_dir, dip])
else:
num_dropped += 1
else:
DIDDs.append([Dec, Inc, dip_dir, dip])
if num_dropped:
print(
"-W- Dropped {} records because each failed one or more criteria"
.format(num_dropped))
else:
print('no geographic directional data found')
sys.exit()
pmagplotlib.plot_eq(PLTS['geo'], DIDDs, 'Geographic')
data = np.array(DIDDs)
D, I = pmag.dotilt_V(data)
TCs = np.array([D, I]).transpose()
pmagplotlib.plot_eq(PLTS['strat'], TCs, 'Stratigraphic')
if plot == 0:
pmagplotlib.draw_figs(PLTS)
Percs = list(range(untilt_min, untilt_max))
Cdf, Untilt = [], []
plt.figure(num=PLTS['taus'])
print('doing ', nboot, ' iterations...please be patient.....')
for n in range(
nboot
): # do bootstrap data sets - plot first 25 as dashed red line
if n % 50 == 0:
print(n)
Taus = [] # set up lists for taus
PDs = pmag.pseudo(DIDDs)
if kappa != 0:
for k in range(len(PDs)):
d, i = pmag.fshdev(kappa)
dipdir, dip = pmag.dodirot(d, i, PDs[k][2], PDs[k][3])
PDs[k][2] = dipdir
PDs[k][3] = dip
for perc in Percs:
tilt = np.array([1., 1., 1., 0.01 * perc])
D, I = pmag.dotilt_V(PDs * tilt)
TCs = np.array([D, I]).transpose()
ppars = pmag.doprinc(TCs) # get principal directions
Taus.append(ppars['tau1'])
if n < 25:
plt.plot(Percs, Taus, 'r--')
# tilt that gives maximum tau
Untilt.append(Percs[Taus.index(np.max(Taus))])
Cdf.append(float(n) / float(nboot))
plt.plot(Percs, Taus, 'k')
plt.xlabel('% Untilting')
plt.ylabel('tau_1 (red), CDF (green)')
Untilt.sort() # now for CDF of tilt of maximum tau
plt.plot(Untilt, Cdf, 'g')
lower = int(.025 * nboot)
upper = int(.975 * nboot)
plt.axvline(x=Untilt[lower], ymin=0, ymax=1, linewidth=1, linestyle='--')
plt.axvline(x=Untilt[upper], ymin=0, ymax=1, linewidth=1, linestyle='--')
tit = '%i - %i %s' % (Untilt[lower], Untilt[upper], 'Percent Unfolding')
print(tit)
plt.title(tit)
if plot == 0:
pmagplotlib.draw_figs(PLTS)
ans = input('S[a]ve all figures, <Return> to quit \n ')
if ans != 'a':
print("Good bye")
sys.exit()
files = {}
for key in list(PLTS.keys()):
files[key] = ('foldtest_' + '%s' % (key.strip()[:2]) + '.' + fmt)
pmagplotlib.save_plots(PLTS, files)
def main():
"""
NAME
irmaq_magic.py
DESCRIPTION
plots IRM acquisition curves from magic_measurements file
SYNTAX
irmaq_magic [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-N ; do not normalize by last point - use original units
-fmt [png,jpg,eps,pdf] set plot file format [default is svg]
-sav save plot[s] and quit
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG = {} # plot dictionary
FIG['exp'] = 1 # exp is figure 1
dir_path = './'
plot, fmt = 0, 'svg'
units, dmag_key = 'T', 'treatment_dc_field'
XLP = []
norm = 1
in_file, plot_key, LP = 'magic_measurements.txt', 'er_location_name', "LP-IRM"
if len(sys.argv) > 1:
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-N' in sys.argv: norm = 0
if '-sav' in sys.argv: plot = 1
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-f' in sys.argv:
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
in_file = dir_path + '/' + in_file
if '-obj' in sys.argv:
ind = sys.argv.index('-obj')
plot_by = sys.argv[ind + 1]
if plot_by == 'sit': plot_key = 'er_site_name'
if plot_by == 'sam': plot_key = 'er_sample_name'
if plot_by == 'spc': plot_key = 'er_specimen_name'
data, file_type = pmag.magic_read(in_file)
sids = pmag.get_specs(data)
pmagplotlib.plot_init(FIG['exp'], 6, 6)
#
#
# find desired intensity data
#
# get plotlist
#
plotlist, intlist = [], [
'measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass'
]
IntMeths = []
data = pmag.get_dictitem(
data, 'magic_method_codes', LP,
'has') # get all the records with this lab protocol
Ints = {}
NoInts, int_key = 1, ""
for key in intlist:
Ints[key] = pmag.get_dictitem(
data, key, '', 'F') # get all non-blank data for intensity type
if len(Ints[key]) > 0:
NoInts = 0
if int_key == "": int_key = key
if NoInts == 1:
print 'No intensity information found'
sys.exit()
for rec in Ints[int_key]:
if rec[plot_key] not in plotlist: plotlist.append(rec[plot_key])
plotlist.sort()
for plt in plotlist:
print plt
INTblock = []
data = pmag.get_dictitem(
Ints[int_key], plot_key, plt, 'T'
) # get data with right intensity info whose plot_key matches plot
sids = pmag.get_specs(
data) # get a list of specimens with appropriate data
if len(sids) > 0:
title = data[0][plot_key]
for s in sids:
INTblock = []
sdata = pmag.get_dictitem(data, 'er_specimen_name', s,
'T') # get data for each specimen
for rec in sdata:
INTblock.append(
[float(rec[dmag_key]), 0, 0,
float(rec[int_key]), 1, 'g'])
pmagplotlib.plotMT(FIG['exp'], INTblock, title, 0, units, norm)
files = {}
for key in FIG.keys():
files[key] = title + '_' + LP + '.' + fmt
if plot == 0:
pmagplotlib.drawFIGS(FIG)
ans = raw_input(
" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans == 'q': sys.exit()
if ans == "a":
pmagplotlib.saveP(FIG, files)
else:
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG['exp'])
def main(command_line=True, **kwargs):
"""
NAME
old_iodp_jr6_magic.py
DESCRIPTION
converts shipboard .jr6 format files to magic_measurements format files
SYNTAX
old_iodp_jr6_magic.py [command line options]
OPTIONS
-h: prints the help message and quits.
-f FILE: specify input file, or
-F FILE: specify output file, default is magic_measurements.txt
-fsa FILE: specify er_samples.txt file for sample name lookup ,
default is 'er_samples.txt'
-loc HOLE : specify hole name (U1456A)
-A: don't average replicate measurements
INPUT
JR6 .jr6 format file
"""
def fix_separation(filename, new_filename):
old_file = open(filename, 'rU')
data = old_file.readlines()
new_data = []
for line in data:
new_line = line.replace('-', ' -')
new_line = new_line.replace(' ', ' ')
new_data.append(new_line)
new_file = open(new_filename, 'w')
for s in new_data:
new_file.write(s)
old_file.close()
new_file.close()
return new_filename
def old_fix_separation(filename, new_filename):
old_file = open(filename, 'rU')
data = old_file.readlines()
new_data = []
for line in data:
new_line = []
for i in line.split():
if '-' in i[1:]:
lead_char = '-' if i[0] == '-' else ''
if lead_char:
v = i[1:].split('-')
else:
v = i.split('-')
new_line.append(lead_char + v[0])
new_line.append('-' + v[1])
else:
new_line.append(i)
new_line = (' '.join(new_line)) + '\n'
new_data.append(new_line)
new_file = open(new_filename, 'w')
for s in new_data:
new_file.write(s)
new_file.close()
old_file.close()
return new_filename
# initialize some stuff
noave=0
volume=2.5**3 #default volume is a 2.5cm cube
inst=""
samp_con,Z='5',""
missing=1
demag="N"
er_location_name="unknown"
citation='This study'
args=sys.argv
meth_code="LP-NO"
version_num=pmag.get_version()
dir_path='.'
MagRecs=[]
samp_file = 'er_samples.txt'
meas_file = 'magic_measurements.txt'
mag_file = ''
#
# get command line arguments
#
if command_line:
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
if '-ID' in sys.argv:
ind = sys.argv.index('-ID')
input_dir_path = sys.argv[ind+1]
else:
input_dir_path = dir_path
output_dir_path = dir_path
if "-h" in args:
print main.__doc__
return False
if '-F' in args:
ind=args.index("-F")
meas_file = args[ind+1]
if '-fsa' in args:
ind = args.index("-fsa")
samp_file = args[ind+1]
if samp_file[0]!='/':
samp_file = os.path.join(input_dir_path, samp_file)
try:
open(samp_file,'rU')
ErSamps,file_type=pmag.magic_read(samp_file)
except:
print samp_file,' not found: '
print ' download csv file and import to MagIC with iodp_samples_magic.py'
if '-f' in args:
ind = args.index("-f")
mag_file= args[ind+1]
if "-loc" in args:
ind=args.index("-loc")
er_location_name=args[ind+1]
if "-A" in args:
noave=1
if not command_line:
dir_path = kwargs.get('dir_path', '.')
input_dir_path = kwargs.get('input_dir_path', dir_path)
output_dir_path = dir_path
meas_file = kwargs.get('meas_file', 'magic_measurements.txt')
mag_file = kwargs.get('mag_file', '')
samp_file = kwargs.get('samp_file', 'er_samples.txt')
specnum = kwargs.get('specnum', 1)
samp_con = kwargs.get('samp_con', '1')
if len(str(samp_con)) > 1:
samp_con, Z = samp_con.split('-')
else:
Z = ''
er_location_name = kwargs.get('er_location_name', '')
noave = kwargs.get('noave', 0) # default (0) means DO average
meth_code = kwargs.get('meth_code', "LP-NO")
# format variables
meth_code=meth_code+":FS-C-DRILL-IODP:SP-SS-C:SO-V"
meth_code=meth_code.strip(":")
if mag_file:
mag_file = os.path.join(input_dir_path, mag_file)
samp_file = os.path.join(input_dir_path, samp_file)
meas_file = os.path.join(output_dir_path, meas_file)
# validate variables
if not mag_file:
print "You must provide an IODP_jr6 format file"
return False, "You must provide an IODP_jr6 format file"
if not os.path.exists(mag_file):
print 'The input file you provided: {} does not exist.\nMake sure you have specified the correct filename AND correct input directory name.'.format(os.path.join(input_dir_path, mag_file))
return False, 'The input file you provided: {} does not exist.\nMake sure you have specified the correct filename AND correct input directory name.'.format(magfile)
if not os.path.exists(samp_file):
print 'samp_file', samp_file
print "Your input directory:\n{}\nmust contain an er_samples.txt file, or you must explicitly provide one".format(input_dir_path)
return False, "Your input directory:\n{}\nmust contain an er_samples.txt file, or you must explicitly provide one".format(input_dir_path)
# parse data
temp = os.path.join(output_dir_path, 'temp.txt')
fix_separation(mag_file, temp)
#os.rename('temp.txt', mag_file)
#data = open(mag_file, 'rU').readlines()
data=pd.read_csv(temp, delim_whitespace=True,header=None)
os.remove(temp)
samples,filetype = pmag.magic_read(samp_file)
data.columns=['specname','step','negz','y','x','expon','sample_azimuth','sample_dip','sample_bed_dip_direction','sample_bed_dip','bed_dip_dir2','bed_dip2','param1','param2','param3','param4','measurement_csd']
cart=np.array([data['x'],data['y'],-data['negz']]).transpose()
dir= pmag.cart2dir(cart).transpose()
data['measurement_dec']=dir[0]
data['measurement_inc']=dir[1]
data['measurement_magn_volume']=dir[2]*(10.0**data['expon']) # A/m - data in A/m
data['measurement_flag']='g'
data['measurement_standard']='u'
data['measurement_number']='1'
data['measurement_temp']='273'
data['er_location_name']=er_location_name
for rowNum, row in data.iterrows():
MagRec={}
spec_text_id=row['specname'].split('_')[1]
SampRecs=pmag.get_dictitem(samples,'er_sample_alternatives',spec_text_id,'has') # retrieve sample record for this specimen
if len(SampRecs)>0: # found one
MagRec['er_specimen_name']=SampRecs[0]['er_sample_name']
MagRec['er_sample_name']=MagRec['er_specimen_name']
MagRec['er_site_name']=MagRec['er_specimen_name']
MagRec["er_citation_names"]="This study"
MagRec['er_location_name']=er_location_name
MagRec['magic_software_packages']=version_num
MagRec["treatment_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["measurement_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["measurement_flag"]='g'
MagRec["measurement_standard"]='u'
MagRec["measurement_number"]='1'
MagRec["treatment_ac_field"]='0'
volume=float(SampRecs[0]['sample_volume'])
moment=row['measurement_magn_volume'] * volume
MagRec["measurement_magn_moment"]=str(moment)
MagRec["measurement_magn_volume"]=str(row['measurement_magn_volume'])
MagRec["measurement_dec"]='%7.1f'%(row['measurement_dec'])
MagRec["measurement_inc"]='%7.1f'%(row['measurement_inc'])
if row['step'] == 'NRM':
meas_type="LT-NO"
elif row['step'][0:2] == 'AD':
meas_type="LT-AF-Z"
treat=float(row['step'][2:])
MagRec["treatment_ac_field"]='%8.3e' %(treat*1e-3) # convert from mT to tesla
elif row['step'][0] == 'TD':
meas_type="LT-T-Z"
treat=float(row['step'][2:])
MagRec["treatment_temp"]='%8.3e' % (treat+273.) # temp in kelvin
elif row['step'][0:3]=='ARM': #
meas_type="LT-AF-I"
treat=float(row['step'][3:])
MagRec["treatment_ac_field"]='%8.3e' %(treat*1e-3) # convert from mT to tesla
MagRec["treatment_dc_field"]='%8.3e' %(50e-6) # assume 50uT DC field
MagRec["measurement_description"]='Assumed DC field - actual unknown'
elif row['step'][0:3]=='IRM': #
meas_type="LT-IRM"
treat=float(row['step'][3:])
MagRec["treatment_dc_field"]='%8.3e' %(treat*1e-3) # convert from mT to tesla
else:
print 'unknown treatment type for ',row
return False, 'unknown treatment type for ',row
MagRec['magic_method_codes']=meas_type
MagRecs.append(MagRec.copy())
else:
print 'sample name not found: ',row['specname']
MagOuts=pmag.measurements_methods(MagRecs,noave)
file_created, error_message = pmag.magic_write(meas_file,MagOuts,'magic_measurements')
if file_created:
return True, meas_file
else:
return False, 'Results not written to file'
def main():
"""
NAME
magic_select.py
DESCRIPTION
picks out records and dictitem options saves to magic_special file
SYNTAX
magic_select.py [command line optins]
OPTIONS
-h prints help message and quits
-f FILE: specify input magic format file
-F FILE: specify output magic format file
-key KEY string [T,F,has, not, eval,min,max]
returns records where the value of the key either:
matches exactly the string (T)
does not match the string (F)
contains the string (has)
does not contain the string (not)
the value equals the numerical value of the string (eval)
the value is greater than the numerical value of the string (min)
the value is less than the numerical value of the string (max)
NOTES
for age range:
use KEY: age (converts to Ma, takes mid point of low, high if no value for age.
for paleolat:
use KEY: model_lat (uses lat, if age<5 Ma, else, model_lat, or attempts calculation from average_inc if no model_lat.) returns estimate in model_lat key
"""
dir_path="."
flag=''
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-f' in sys.argv:
ind=sys.argv.index('-f')
magic_file=dir_path+'/'+sys.argv[ind+1]
else:
print main.__doc__
sys.exit()
if '-F' in sys.argv:
ind=sys.argv.index('-F')
outfile=dir_path+'/'+sys.argv[ind+1]
else:
print main.__doc__
sys.exit()
if '-key' in sys.argv:
ind=sys.argv.index('-key')
grab_key=sys.argv[ind+1]
v=sys.argv[ind+2]
flag=sys.argv[ind+3]
else:
print main.__doc__
print '-key is required'
sys.exit()
#
# get data read in
Data,file_type=pmag.magic_read(magic_file)
if grab_key =='age':
grab_key='average_age'
Data=pmag.convert_ages(Data)
if grab_key =='model_lat':
Data=pmag.convert_lat(Data)
Data=pmag.convert_ages(Data)
Selection=pmag.get_dictitem(Data,grab_key,v,flag)
if len(Selection)>0:
pmag.magic_write(outfile,Selection,file_type)
else:
print 'no data matched your criteria'
def main():
"""
NAME
foldtest_magic.py
DESCRIPTION
does a fold test (Tauxe, 2010) on data
INPUT FORMAT
pmag_specimens format file, er_samples.txt format file (for bedding)
SYNTAX
foldtest_magic.py [command line options]
OPTIONS
-h prints help message and quits
-f sites formatted file [default for 3.0 is sites.txt, for 2.5, pmag_sites.txt]
-fsa samples formatted file
-fsi sites formatted file
-exc use criteria to set acceptance criteria (supported only for data model 3)
-n NB, set number of bootstraps, default is 1000
-b MIN, MAX, set bounds for untilting, default is -10, 150
-fmt FMT, specify format - default is svg
-sav saves plots and quits
-DM NUM MagIC data model number (2 or 3, default 3)
OUTPUT
Geographic: is an equal area projection of the input data in
original coordinates
Stratigraphic: is an equal area projection of the input data in
tilt adjusted coordinates
% Untilting: The dashed (red) curves are representative plots of
maximum eigenvalue (tau_1) as a function of untilting
The solid line is the cumulative distribution of the
% Untilting required to maximize tau for all the
bootstrapped data sets. The dashed vertical lines
are 95% confidence bounds on the % untilting that yields
the most clustered result (maximum tau_1).
Command line: prints out the bootstrapped iterations and
finally the confidence bounds on optimum untilting.
If the 95% conf bounds include 0, then a pre-tilt magnetization is indicated
If the 95% conf bounds include 100, then a post-tilt magnetization is indicated
If the 95% conf bounds exclude both 0 and 100, syn-tilt magnetization is
possible as is vertical axis rotation or other pathologies
"""
if '-h' in sys.argv: # check if help is needed
print(main.__doc__)
sys.exit() # graceful quit
kappa = 0
dir_path = pmag.get_named_arg("-WD", ".")
nboot = int(float(pmag.get_named_arg("-n", 1000))) # number of bootstraps
fmt = pmag.get_named_arg("-fmt", "svg")
data_model_num = int(float(pmag.get_named_arg("-DM", 3)))
if data_model_num == 3:
infile = pmag.get_named_arg("-f", 'sites.txt')
orfile = 'samples.txt'
site_col = 'site'
dec_col = 'dir_dec'
inc_col = 'dir_inc'
tilt_col = 'dir_tilt_correction'
dipkey, azkey = 'bed_dip', 'bed_dip_direction'
crit_col = 'criterion'
critfile = 'criteria.txt'
else:
infile = pmag.get_named_arg("-f", 'pmag_sites.txt')
orfile = 'er_samples.txt'
site_col = 'er_site_name'
dec_col = 'site_dec'
inc_col = 'site_inc'
tilt_col = 'site_tilt_correction'
dipkey, azkey = 'sample_bed_dip', 'sample_bed_dip_direction'
crit_col = 'pmag_criteria_code'
critfile = 'pmag_criteria.txt'
if '-sav' in sys.argv:
plot = 1
else:
plot = 0
if '-b' in sys.argv:
ind = sys.argv.index('-b')
untilt_min = int(sys.argv[ind+1])
untilt_max = int(sys.argv[ind+2])
else:
untilt_min, untilt_max = -10, 150
if '-fsa' in sys.argv:
orfile = pmag.get_named_arg("-fsa", "")
elif '-fsi' in sys.argv:
orfile = pmag.get_named_arg("-fsi", "")
if data_model_num == 3:
dipkey, azkey = 'bed_dip', 'bed_dip_direction'
else:
dipkey, azkey = 'site_bed_dip', 'site_bed_dip_direction'
else:
if data_model_num == 3:
orfile = 'sites.txt'
else:
orfile = 'pmag_sites.txt'
orfile = pmag.resolve_file_name(orfile, dir_path)
infile = pmag.resolve_file_name(infile, dir_path)
critfile = pmag.resolve_file_name(critfile, dir_path)
df = pd.read_csv(infile, sep='\t', header=1)
# keep only records with tilt_col
data = df.copy()
data = data[data[tilt_col].notnull()]
data = data.where(data.notnull(), "")
# turn into pmag data list
data = list(data.T.apply(dict))
# get orientation data
if data_model_num == 3:
# often orientation will be in infile (sites table)
if os.path.split(orfile)[1] == os.path.split(infile)[1]:
ordata = df[df[azkey].notnull()]
ordata = ordata[ordata[dipkey].notnull()]
ordata = list(ordata.T.apply(dict))
# sometimes orientation might be in a sample file instead
else:
ordata = pd.read_csv(orfile, sep='\t', header=1)
ordata = list(ordata.T.apply(dict))
else:
ordata, file_type = pmag.magic_read(orfile)
if '-exc' in sys.argv:
crits, file_type = pmag.magic_read(critfile)
SiteCrits = []
for crit in crits:
if crit[crit_col] == "DE-SITE":
SiteCrits.append(crit)
#break
# get to work
#
PLTS = {'geo': 1, 'strat': 2, 'taus': 3} # make plot dictionary
if not set_env.IS_WIN:
pmagplotlib.plot_init(PLTS['geo'], 5, 5)
pmagplotlib.plot_init(PLTS['strat'], 5, 5)
pmagplotlib.plot_init(PLTS['taus'], 5, 5)
if data_model_num == 2:
GEOrecs = pmag.get_dictitem(data, tilt_col, '0', 'T')
else:
GEOrecs = data
if len(GEOrecs) > 0: # have some geographic data
num_dropped = 0
DIDDs = [] # set up list for dec inc dip_direction, dip
for rec in GEOrecs: # parse data
dip, dip_dir = 0, -1
Dec = float(rec[dec_col])
Inc = float(rec[inc_col])
orecs = pmag.get_dictitem(
ordata, site_col, rec[site_col], 'T')
if len(orecs) > 0:
if orecs[0][azkey] != "":
dip_dir = float(orecs[0][azkey])
if orecs[0][dipkey] != "":
dip = float(orecs[0][dipkey])
if dip != 0 and dip_dir != -1:
if '-exc' in sys.argv:
keep = 1
for site_crit in SiteCrits:
crit_name = site_crit['table_column'].split('.')[1]
if crit_name and crit_name in rec.keys() and rec[crit_name]:
# get the correct operation (<, >=, =, etc.)
op = OPS[site_crit['criterion_operation']]
# then make sure the site record passes
if op(float(rec[crit_name]), float(site_crit['criterion_value'])):
keep = 0
if keep == 1:
DIDDs.append([Dec, Inc, dip_dir, dip])
else:
num_dropped += 1
else:
DIDDs.append([Dec, Inc, dip_dir, dip])
if num_dropped:
print("-W- Dropped {} records because each failed one or more criteria".format(num_dropped))
else:
print('no geographic directional data found')
sys.exit()
pmagplotlib.plot_eq(PLTS['geo'], DIDDs, 'Geographic')
data = np.array(DIDDs)
D, I = pmag.dotilt_V(data)
TCs = np.array([D, I]).transpose()
pmagplotlib.plot_eq(PLTS['strat'], TCs, 'Stratigraphic')
if plot == 0:
pmagplotlib.draw_figs(PLTS)
Percs = list(range(untilt_min, untilt_max))
Cdf, Untilt = [], []
plt.figure(num=PLTS['taus'])
print('doing ', nboot, ' iterations...please be patient.....')
for n in range(nboot): # do bootstrap data sets - plot first 25 as dashed red line
if n % 50 == 0:
print(n)
Taus = [] # set up lists for taus
PDs = pmag.pseudo(DIDDs)
if kappa != 0:
for k in range(len(PDs)):
d, i = pmag.fshdev(kappa)
dipdir, dip = pmag.dodirot(d, i, PDs[k][2], PDs[k][3])
PDs[k][2] = dipdir
PDs[k][3] = dip
for perc in Percs:
tilt = np.array([1., 1., 1., 0.01*perc])
D, I = pmag.dotilt_V(PDs*tilt)
TCs = np.array([D, I]).transpose()
ppars = pmag.doprinc(TCs) # get principal directions
Taus.append(ppars['tau1'])
if n < 25:
plt.plot(Percs, Taus, 'r--')
# tilt that gives maximum tau
Untilt.append(Percs[Taus.index(np.max(Taus))])
Cdf.append(float(n) / float(nboot))
plt.plot(Percs, Taus, 'k')
plt.xlabel('% Untilting')
plt.ylabel('tau_1 (red), CDF (green)')
Untilt.sort() # now for CDF of tilt of maximum tau
plt.plot(Untilt, Cdf, 'g')
lower = int(.025*nboot)
upper = int(.975*nboot)
plt.axvline(x=Untilt[lower], ymin=0, ymax=1, linewidth=1, linestyle='--')
plt.axvline(x=Untilt[upper], ymin=0, ymax=1, linewidth=1, linestyle='--')
tit = '%i - %i %s' % (Untilt[lower], Untilt[upper], 'Percent Unfolding')
print(tit)
plt.title(tit)
if plot == 0:
pmagplotlib.draw_figs(PLTS)
ans = input('S[a]ve all figures, <Return> to quit \n ')
if ans != 'a':
print("Good bye")
sys.exit()
files = {}
for key in list(PLTS.keys()):
files[key] = ('foldtest_'+'%s' % (key.strip()[:2])+'.'+fmt)
pmagplotlib.save_plots(PLTS, files)
def main():
"""
NAME
specimens_results_magic.py
DESCRIPTION
combines pmag_specimens.txt file with age, location, acceptance criteria and
outputs pmag_results table along with other MagIC tables necessary for uploading to the database
SYNTAX
specimens_results_magic.py [command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f: specimen input magic_measurements format file, default is "magic_measurements.txt"
-fsp: specimen input pmag_specimens format file, default is "pmag_specimens.txt"
-fsm: sample input er_samples format file, default is "er_samples.txt"
-fsi: specimen input er_sites format file, default is "er_sites.txt"
-fla: specify a file with paleolatitudes for calculating VADMs, default is not to calculate VADMS
format is: site_name paleolatitude (space delimited file)
-fa AGES: specify er_ages format file with age information
-crd [s,g,t,b]: specify coordinate system
(s, specimen, g geographic, t, tilt corrected, b, geographic and tilt corrected)
Default is to assume geographic
NB: only the tilt corrected data will appear on the results table, if both g and t are selected.
-cor [AC:CR:NL]: colon delimited list of required data adjustments for all specimens
included in intensity calculations (anisotropy, cooling rate, non-linear TRM)
unless specified, corrections will not be applied
-pri [TRM:ARM] colon delimited list of priorities for anisotropy correction (-cor must also be set to include AC). default is TRM, then ARM
-age MIN MAX UNITS: specify age boundaries and units
-exc: use exiting selection criteria (in pmag_criteria.txt file), default is default criteria
-C: no acceptance criteria
-aD: average directions per sample, default is NOT
-aI: average multiple specimen intensities per sample, default is by site
-aC: average all components together, default is NOT
-pol: calculate polarity averages
-sam: save sample level vgps and v[a]dms, default is by site
-xSi: skip the site level intensity calculation
-p: plot directions and look at intensities by site, default is NOT
-fmt: specify output for saved images, default is svg (only if -p set)
-lat: use present latitude for calculating VADMs, default is not to calculate VADMs
-xD: skip directions
-xI: skip intensities
OUPUT
writes pmag_samples, pmag_sites, pmag_results tables
"""
# set defaults
Comps = [] # list of components
version_num = pmag.get_version()
args = sys.argv
DefaultAge = ["none"]
skipdirs, coord, excrit, custom, vgps, average, Iaverage, plotsites, opt = 1, 0, 0, 0, 0, 0, 0, 0, 0
get_model_lat = 0 # this skips VADM calculation altogether, when get_model_lat=1, uses present day
fmt = 'svg'
dir_path = "."
model_lat_file = ""
Caverage = 0
infile = 'pmag_specimens.txt'
measfile = "magic_measurements.txt"
sampfile = "er_samples.txt"
sitefile = "er_sites.txt"
agefile = "er_ages.txt"
specout = "er_specimens.txt"
sampout = "pmag_samples.txt"
siteout = "pmag_sites.txt"
resout = "pmag_results.txt"
critout = "pmag_criteria.txt"
instout = "magic_instruments.txt"
sigcutoff, OBJ = "", ""
noDir, noInt = 0, 0
polarity = 0
coords = ['0']
Dcrit, Icrit, nocrit = 0, 0, 0
corrections = []
nocorrection = ['DA-NL', 'DA-AC', 'DA-CR']
priorities = ['DA-AC-ARM',
'DA-AC-TRM'] # priorities for anisotropy correction
# get command line stuff
if "-h" in args:
print main.__doc__
sys.exit()
if '-WD' in args:
ind = args.index("-WD")
dir_path = args[ind + 1]
if '-cor' in args:
ind = args.index('-cor')
cors = args[ind + 1].split(':') # list of required data adjustments
for cor in cors:
nocorrection.remove('DA-' + cor)
corrections.append('DA-' + cor)
if '-pri' in args:
ind = args.index('-pri')
priorities = args[ind + 1].split(
':') # list of required data adjustments
for p in priorities:
p = 'DA-AC-' + p
if '-f' in args:
ind = args.index("-f")
measfile = args[ind + 1]
if '-fsp' in args:
ind = args.index("-fsp")
infile = args[ind + 1]
if '-fsi' in args:
ind = args.index("-fsi")
sitefile = args[ind + 1]
if "-crd" in args:
ind = args.index("-crd")
coord = args[ind + 1]
if coord == 's': coords = ['-1']
if coord == 'g': coords = ['0']
if coord == 't': coords = ['100']
if coord == 'b': coords = ['0', '100']
if "-usr" in args:
ind = args.index("-usr")
user = sys.argv[ind + 1]
else:
user = ""
if "-C" in args: Dcrit, Icrit, nocrit = 1, 1, 1 # no selection criteria
if "-sam" in args: vgps = 1 # save sample level VGPS/VADMs
if "-xSi" in args:
nositeints = 1 # skip site level intensity
else:
nositeints = 0
if "-age" in args:
ind = args.index("-age")
DefaultAge[0] = args[ind + 1]
DefaultAge.append(args[ind + 2])
DefaultAge.append(args[ind + 3])
Daverage, Iaverage, Caverage = 0, 0, 0
if "-aD" in args: Daverage = 1 # average by sample directions
if "-aI" in args: Iaverage = 1 # average by sample intensities
if "-aC" in args:
Caverage = 1 # average all components together ??? why???
if "-pol" in args: polarity = 1 # calculate averages by polarity
if '-xD' in args: noDir = 1
if '-xI' in args:
noInt = 1
elif "-fla" in args:
if '-lat' in args:
print "you should set a paleolatitude file OR use present day lat - not both"
sys.exit()
ind = args.index("-fla")
model_lat_file = dir_path + '/' + args[ind + 1]
get_model_lat = 2
mlat = open(model_lat_file, 'rU')
ModelLats = []
for line in mlat.readlines():
ModelLat = {}
tmp = line.split()
ModelLat["er_site_name"] = tmp[0]
ModelLat["site_model_lat"] = tmp[1]
ModelLat["er_sample_name"] = tmp[0]
ModelLat["sample_lat"] = tmp[1]
ModelLats.append(ModelLat)
get_model_lat = 2
elif '-lat' in args:
get_model_lat = 1
if "-p" in args:
plotsites = 1
if "-fmt" in args:
ind = args.index("-fmt")
fmt = args[ind + 1]
if noDir == 0: # plot by site - set up plot window
import pmagplotlib
EQ = {}
EQ['eqarea'] = 1
pmagplotlib.plot_init(
EQ['eqarea'], 5, 5) # define figure 1 as equal area projection
pmagplotlib.plotNET(
EQ['eqarea']
) # I don't know why this has to be here, but otherwise the first plot never plots...
pmagplotlib.drawFIGS(EQ)
if '-WD' in args:
infile = dir_path + '/' + infile
measfile = dir_path + '/' + measfile
instout = dir_path + '/' + instout
sampfile = dir_path + '/' + sampfile
sitefile = dir_path + '/' + sitefile
agefile = dir_path + '/' + agefile
specout = dir_path + '/' + specout
sampout = dir_path + '/' + sampout
siteout = dir_path + '/' + siteout
resout = dir_path + '/' + resout
critout = dir_path + '/' + critout
if "-exc" in args: # use existing pmag_criteria file
if "-C" in args:
print 'you can not use both existing and no criteria - choose either -exc OR -C OR neither (for default)'
sys.exit()
crit_data, file_type = pmag.magic_read(critout)
print "Acceptance criteria read in from ", critout
else: # use default criteria (if nocrit set, then get really loose criteria as default)
crit_data = pmag.default_criteria(nocrit)
if nocrit == 0:
print "Acceptance criteria are defaults"
else:
print "No acceptance criteria used "
accept = {}
for critrec in crit_data:
for key in critrec.keys():
# need to migrate specimen_dang to specimen_int_dang for intensity data using old format
if 'IE-SPEC' in critrec.keys() and 'specimen_dang' in critrec.keys(
) and 'specimen_int_dang' not in critrec.keys():
critrec['specimen_int_dang'] = critrec['specimen_dang']
del critrec['specimen_dang']
# need to get rid of ron shaars sample_int_sigma_uT
if 'sample_int_sigma_uT' in critrec.keys():
critrec['sample_int_sigma'] = '%10.3e' % (
eval(critrec['sample_int_sigma_uT']) * 1e-6)
if key not in accept.keys() and critrec[key] != '':
accept[key] = critrec[key]
#
#
if "-exc" not in args and "-C" not in args:
print "args", args
pmag.magic_write(critout, [accept], 'pmag_criteria')
print "\n Pmag Criteria stored in ", critout, '\n'
#
# now we're done slow dancing
#
SiteNFO, file_type = pmag.magic_read(
sitefile) # read in site data - has the lats and lons
SampNFO, file_type = pmag.magic_read(
sampfile) # read in site data - has the lats and lons
height_nfo = pmag.get_dictitem(SiteNFO, 'site_height', '',
'F') # find all the sites with height info.
if agefile != "":
AgeNFO, file_type = pmag.magic_read(
agefile) # read in the age information
Data, file_type = pmag.magic_read(
infile) # read in specimen interpretations
IntData = pmag.get_dictitem(Data, 'specimen_int', '',
'F') # retrieve specimens with intensity data
comment, orient = "", []
samples, sites = [], []
for rec in Data: # run through the data filling in missing keys and finding all components, coordinates available
# fill in missing fields, collect unique sample and site names
if 'er_sample_name' not in rec.keys():
rec['er_sample_name'] = ""
elif rec['er_sample_name'] not in samples:
samples.append(rec['er_sample_name'])
if 'er_site_name' not in rec.keys():
rec['er_site_name'] = ""
elif rec['er_site_name'] not in sites:
sites.append(rec['er_site_name'])
if 'specimen_int' not in rec.keys(): rec['specimen_int'] = ''
if 'specimen_comp_name' not in rec.keys(
) or rec['specimen_comp_name'] == "":
rec['specimen_comp_name'] = 'A'
if rec['specimen_comp_name'] not in Comps:
Comps.append(rec['specimen_comp_name'])
rec['specimen_tilt_correction'] = rec[
'specimen_tilt_correction'].strip('\n')
if "specimen_tilt_correction" not in rec.keys():
rec["specimen_tilt_correction"] = "-1" # assume sample coordinates
if rec["specimen_tilt_correction"] not in orient:
orient.append(rec["specimen_tilt_correction"]
) # collect available coordinate systems
if "specimen_direction_type" not in rec.keys():
rec["specimen_direction_type"] = 'l' # assume direction is line - not plane
if "specimen_dec" not in rec.keys():
rec["specimen_direction_type"] = '' # if no declination, set direction type to blank
if "specimen_n" not in rec.keys(): rec["specimen_n"] = '' # put in n
if "specimen_alpha95" not in rec.keys():
rec["specimen_alpha95"] = '' # put in alpha95
if "magic_method_codes" not in rec.keys():
rec["magic_method_codes"] = ''
#
# start parsing data into SpecDirs, SpecPlanes, SpecInts
SpecInts, SpecDirs, SpecPlanes = [], [], []
samples.sort() # get sorted list of samples and sites
sites.sort()
if noInt == 0: # don't skip intensities
IntData = pmag.get_dictitem(
Data, 'specimen_int', '',
'F') # retrieve specimens with intensity data
if nocrit == 0: # use selection criteria
for rec in IntData: # do selection criteria
kill = pmag.grade(rec, accept, 'specimen_int')
if len(kill) == 0:
SpecInts.append(
rec
) # intensity record to be included in sample, site calculations
else:
SpecInts = IntData[:] # take everything - no selection criteria
# check for required data adjustments
if len(corrections) > 0 and len(SpecInts) > 0:
for cor in corrections:
SpecInts = pmag.get_dictitem(
SpecInts, 'magic_method_codes', cor,
'has') # only take specimens with the required corrections
if len(nocorrection) > 0 and len(SpecInts) > 0:
for cor in nocorrection:
SpecInts = pmag.get_dictitem(
SpecInts, 'magic_method_codes', cor, 'not'
) # exclude the corrections not specified for inclusion
# take top priority specimen of its name in remaining specimens (only one per customer)
PrioritySpecInts = []
specimens = pmag.get_specs(SpecInts) # get list of uniq specimen names
for spec in specimens:
ThisSpecRecs = pmag.get_dictitem(
SpecInts, 'er_specimen_name', spec,
'T') # all the records for this specimen
if len(ThisSpecRecs) == 1:
PrioritySpecInts.append(ThisSpecRecs[0])
elif len(ThisSpecRecs) > 1: # more than one
prec = []
for p in priorities:
ThisSpecRecs = pmag.get_dictitem(
SpecInts, 'magic_method_codes', p,
'has') # all the records for this specimen
if len(ThisSpecRecs) > 0: prec.append(ThisSpecRecs[0])
PrioritySpecInts.append(prec[0]) # take the best one
SpecInts = PrioritySpecInts # this has the first specimen record
if noDir == 0: # don't skip directions
AllDirs = pmag.get_dictitem(
Data, 'specimen_direction_type', '',
'F') # retrieve specimens with directed lines and planes
Ns = pmag.get_dictitem(
AllDirs, 'specimen_n', '',
'F') # get all specimens with specimen_n information
if nocrit != 1: # use selection criteria
for rec in Ns: # look through everything with specimen_n for "good" data
kill = pmag.grade(rec, accept, 'specimen_dir')
if len(kill) == 0: # nothing killed it
SpecDirs.append(rec)
else: # no criteria
SpecDirs = AllDirs[:] # take them all
# SpecDirs is now the list of all specimen directions (lines and planes) that pass muster
#
PmagSamps, SampDirs = [], [
] # list of all sample data and list of those that pass the DE-SAMP criteria
PmagSites, PmagResults = [], [
] # list of all site data and selected results
SampInts = []
for samp in samples: # run through the sample names
if Daverage == 1: # average by sample if desired
SampDir = pmag.get_dictitem(
SpecDirs, 'er_sample_name', samp,
'T') # get all the directional data for this sample
if len(SampDir) > 0: # there are some directions
for coord in coords: # step through desired coordinate systems
CoordDir = pmag.get_dictitem(
SampDir, 'specimen_tilt_correction', coord,
'T') # get all the directions for this sample
if len(CoordDir
) > 0: # there are some with this coordinate system
if Caverage == 0: # look component by component
for comp in Comps:
CompDir = pmag.get_dictitem(
CoordDir, 'specimen_comp_name', comp, 'T'
) # get all directions from this component
if len(CompDir) > 0: # there are some
PmagSampRec = pmag.lnpbykey(
CompDir, 'sample', 'specimen'
) # get a sample average from all specimens
PmagSampRec["er_location_name"] = CompDir[0][
'er_location_name'] # decorate the sample record
PmagSampRec["er_site_name"] = CompDir[0][
'er_site_name']
PmagSampRec["er_sample_name"] = samp
PmagSampRec[
"er_citation_names"] = "This study"
PmagSampRec["er_analyst_mail_names"] = user
PmagSampRec[
'magic_software_packages'] = version_num
if nocrit != 1:
PmagSampRec[
'pmag_criteria_codes'] = "ACCEPT"
if agefile != "":
PmagSampRec = pmag.get_age(
PmagSampRec, "er_site_name",
"sample_inferred_", AgeNFO,
DefaultAge)
site_height = pmag.get_dictitem(
height_nfo, 'er_site_name',
PmagSampRec['er_site_name'], 'T')
if len(site_height) > 0:
PmagSampRec[
"sample_height"] = site_height[0][
'site_height'] # add in height if available
PmagSampRec['sample_comp_name'] = comp
PmagSampRec[
'sample_tilt_correction'] = coord
PmagSampRec[
'er_specimen_names'] = pmag.get_list(
CompDir, 'er_specimen_name'
) # get a list of the specimen names used
PmagSampRec[
'magic_method_codes'] = pmag.get_list(
CompDir, 'magic_method_codes'
) # get a list of the methods used
if nocrit != 1: # apply selection criteria
kill = pmag.grade(
PmagSampRec, accept, 'sample_dir')
else:
kill = []
if len(kill) == 0:
SampDirs.append(PmagSampRec)
if vgps == 1: # if sample level VGP info desired, do that now
PmagResRec = pmag.getsampVGP(
PmagSampRec, SiteNFO)
if PmagResRec != "":
PmagResults.append(PmagResRec)
PmagSamps.append(PmagSampRec)
if Caverage == 1: # average all components together basically same as above
PmagSampRec = pmag.lnpbykey(
CoordDir, 'sample', 'specimen')
PmagSampRec["er_location_name"] = CoordDir[0][
'er_location_name']
PmagSampRec["er_site_name"] = CoordDir[0][
'er_site_name']
PmagSampRec["er_sample_name"] = samp
PmagSampRec["er_citation_names"] = "This study"
PmagSampRec["er_analyst_mail_names"] = user
PmagSampRec[
'magic_software_packages'] = version_num
if nocrit != 1:
PmagSampRec['pmag_criteria_codes'] = ""
if agefile != "":
PmagSampRec = pmag.get_age(
PmagSampRec, "er_site_name",
"sample_inferred_", AgeNFO, DefaultAge)
site_height = pmag.get_dictitem(
height_nfo, 'er_site_name', site, 'T')
if len(site_height) > 0:
PmagSampRec["sample_height"] = site_height[0][
'site_height'] # add in height if available
PmagSampRec['sample_tilt_correction'] = coord
PmagSampRec['sample_comp_name'] = pmag.get_list(
CoordDir,
'specimen_comp_name') # get components used
PmagSampRec['er_specimen_names'] = pmag.get_list(
CoordDir, 'er_specimen_name'
) # get specimne names averaged
PmagSampRec['magic_method_codes'] = pmag.get_list(
CoordDir,
'magic_method_codes') # assemble method codes
if nocrit != 1: # apply selection criteria
kill = pmag.grade(PmagSampRec, accept,
'sample_dir')
if len(kill) == 0: # passes the mustard
SampDirs.append(PmagSampRec)
if vgps == 1:
PmagResRec = pmag.getsampVGP(
PmagSampRec, SiteNFO)
if PmagResRec != "":
PmagResults.append(PmagResRec)
else: # take everything
SampDirs.append(PmagSampRec)
if vgps == 1:
PmagResRec = pmag.getsampVGP(
PmagSampRec, SiteNFO)
if PmagResRec != "":
PmagResults.append(PmagResRec)
PmagSamps.append(PmagSampRec)
if Iaverage == 1: # average by sample if desired
SampI = pmag.get_dictitem(
SpecInts, 'er_sample_name', samp,
'T') # get all the intensity data for this sample
if len(SampI) > 0: # there are some
PmagSampRec = pmag.average_int(
SampI, 'specimen', 'sample') # get average intensity stuff
PmagSampRec[
"sample_description"] = "sample intensity" # decorate sample record
PmagSampRec["sample_direction_type"] = ""
PmagSampRec['er_site_name'] = SampI[0]["er_site_name"]
PmagSampRec['er_sample_name'] = samp
PmagSampRec['er_location_name'] = SampI[0]["er_location_name"]
PmagSampRec["er_citation_names"] = "This study"
PmagSampRec["er_analyst_mail_names"] = user
if agefile != "":
PmagSampRec = pmag.get_age(PmagSampRec, "er_site_name",
"sample_inferred_", AgeNFO,
DefaultAge)
site_height = pmag.get_dictitem(height_nfo, 'er_site_name',
PmagSampRec['er_site_name'],
'T')
if len(site_height) > 0:
PmagSampRec["sample_height"] = site_height[0][
'site_height'] # add in height if available
PmagSampRec['er_specimen_names'] = pmag.get_list(
SampI, 'er_specimen_name')
PmagSampRec['magic_method_codes'] = pmag.get_list(
SampI, 'magic_method_codes')
if nocrit != 1: # apply criteria!
kill = pmag.grade(PmagSampRec, accept, 'sample_int')
if len(kill) == 0:
PmagSampRec['pmag_criteria_codes'] = "ACCEPT"
SampInts.append(PmagSampRec)
PmagSamps.append(PmagSampRec)
else:
PmagSampRec = {} # sample rejected
else: # no criteria
SampInts.append(PmagSampRec)
PmagSamps.append(PmagSampRec)
PmagSampRec['pmag_criteria_codes'] = ""
if vgps == 1 and get_model_lat != 0 and PmagSampRec != {}: #
if get_model_lat == 1: # use sample latitude
PmagResRec = pmag.getsampVDM(PmagSampRec, SampNFO)
del (PmagResRec['model_lat']
) # get rid of the model lat key
elif get_model_lat == 2: # use model latitude
PmagResRec = pmag.getsampVDM(PmagSampRec, ModelLats)
if PmagResRec != {}:
PmagResRec['magic_method_codes'] = PmagResRec[
'magic_method_codes'] + ":IE-MLAT"
if PmagResRec != {}:
PmagResRec['er_specimen_names'] = PmagSampRec[
'er_specimen_names']
PmagResRec['er_sample_names'] = PmagSampRec[
'er_sample_name']
PmagResRec['pmag_criteria_codes'] = 'ACCEPT'
PmagResRec['average_int_sigma_perc'] = PmagSampRec[
'sample_int_sigma_perc']
PmagResRec['average_int_sigma'] = PmagSampRec[
'sample_int_sigma']
PmagResRec['average_int_n'] = PmagSampRec[
'sample_int_n']
PmagResRec['vadm_n'] = PmagSampRec['sample_int_n']
PmagResRec['data_type'] = 'i'
PmagResults.append(PmagResRec)
if len(PmagSamps) > 0:
TmpSamps, keylist = pmag.fillkeys(
PmagSamps) # fill in missing keys from different types of records
pmag.magic_write(sampout, TmpSamps,
'pmag_samples') # save in sample output file
print ' sample averages written to ', sampout
#
#create site averages from specimens or samples as specified
#
for site in sites:
if Daverage == 0:
key, dirlist = 'specimen', SpecDirs # if specimen averages at site level desired
if Daverage == 1:
key, dirlist = 'sample', SampDirs # if sample averages at site level desired
tmp = pmag.get_dictitem(dirlist, 'er_site_name', site,
'T') # get all the sites with directions
tmp1 = pmag.get_dictitem(
tmp, key + '_tilt_correction', coords[-1],
'T') # use only the last coordinate if Caverage==0
sd = pmag.get_dictitem(
SiteNFO, 'er_site_name', site,
'T') # fish out site information (lat/lon, etc.)
if len(sd) > 0:
sitedat = sd[0]
if Caverage == 0: # do component wise averaging
for comp in Comps:
siteD = pmag.get_dictitem(tmp1, key + '_comp_name', comp,
'T') # get all components comp
if len(
siteD
) > 0: # there are some for this site and component name
PmagSiteRec = pmag.lnpbykey(
siteD, 'site', key) # get an average for this site
PmagSiteRec[
'site_comp_name'] = comp # decorate the site record
PmagSiteRec["er_location_name"] = siteD[0][
'er_location_name']
PmagSiteRec["er_site_name"] = siteD[0]['er_site_name']
PmagSiteRec['site_tilt_correction'] = coords[-1]
PmagSiteRec['site_comp_name'] = pmag.get_list(
siteD, key + '_comp_name')
if Daverage == 1:
PmagSiteRec['er_sample_names'] = pmag.get_list(
siteD, 'er_sample_name')
else:
PmagSiteRec['er_specimen_names'] = pmag.get_list(
siteD, 'er_specimen_name')
# determine the demagnetization code (DC3,4 or 5) for this site
AFnum = len(
pmag.get_dictitem(siteD, 'magic_method_codes',
'LP-DIR-AF', 'has'))
Tnum = len(
pmag.get_dictitem(siteD, 'magic_method_codes',
'LP-DIR-T', 'has'))
DC = 3
if AFnum > 0: DC += 1
if Tnum > 0: DC += 1
PmagSiteRec['magic_method_codes'] = pmag.get_list(
siteD,
'magic_method_codes') + ':' + 'LP-DC' + str(DC)
PmagSiteRec['magic_method_codes'].strip(":")
if plotsites == 1:
print PmagSiteRec['er_site_name']
pmagplotlib.plotSITE(EQ['eqarea'], PmagSiteRec,
siteD,
key) # plot and list the data
pmagplotlib.drawFIGS(EQ)
PmagSites.append(PmagSiteRec)
else: # last component only
siteD = tmp1[:] # get the last orientation system specified
if len(siteD) > 0: # there are some
PmagSiteRec = pmag.lnpbykey(
siteD, 'site', key) # get the average for this site
PmagSiteRec["er_location_name"] = siteD[0][
'er_location_name'] # decorate the record
PmagSiteRec["er_site_name"] = siteD[0]['er_site_name']
PmagSiteRec['site_comp_name'] = comp
PmagSiteRec['site_tilt_correction'] = coords[-1]
PmagSiteRec['site_comp_name'] = pmag.get_list(
siteD, key + '_comp_name')
PmagSiteRec['er_specimen_names'] = pmag.get_list(
siteD, 'er_specimen_name')
PmagSiteRec['er_sample_names'] = pmag.get_list(
siteD, 'er_sample_name')
AFnum = len(
pmag.get_dictitem(siteD, 'magic_method_codes',
'LP-DIR-AF', 'has'))
Tnum = len(
pmag.get_dictitem(siteD, 'magic_method_codes',
'LP-DIR-T', 'has'))
DC = 3
if AFnum > 0: DC += 1
if Tnum > 0: DC += 1
PmagSiteRec['magic_method_codes'] = pmag.get_list(
siteD, 'magic_method_codes') + ':' + 'LP-DC' + str(DC)
PmagSiteRec['magic_method_codes'].strip(":")
if Daverage == 0:
PmagSiteRec['site_comp_name'] = pmag.get_list(
siteD, key + '_comp_name')
if plotsites == 1:
pmagplotlib.plotSITE(EQ['eqarea'], PmagSiteRec, siteD,
key)
pmagplotlib.drawFIGS(EQ)
PmagSites.append(PmagSiteRec)
else:
print 'site information not found in er_sites for site, ', site, ' site will be skipped'
for PmagSiteRec in PmagSites: # now decorate each dictionary some more, and calculate VGPs etc. for results table
PmagSiteRec["er_citation_names"] = "This study"
PmagSiteRec["er_analyst_mail_names"] = user
PmagSiteRec['magic_software_packages'] = version_num
if agefile != "":
PmagSiteRec = pmag.get_age(PmagSiteRec, "er_site_name",
"site_inferred_", AgeNFO, DefaultAge)
PmagSiteRec['pmag_criteria_codes'] = 'ACCEPT'
if 'site_n_lines' in PmagSiteRec.keys(
) and 'site_n_planes' in PmagSiteRec.keys() and PmagSiteRec[
'site_n_lines'] != "" and PmagSiteRec['site_n_planes'] != "":
if int(PmagSiteRec["site_n_planes"]) > 0:
PmagSiteRec["magic_method_codes"] = PmagSiteRec[
'magic_method_codes'] + ":DE-FM-LP"
elif int(PmagSiteRec["site_n_lines"]) > 2:
PmagSiteRec["magic_method_codes"] = PmagSiteRec[
'magic_method_codes'] + ":DE-FM"
kill = pmag.grade(PmagSiteRec, accept, 'site_dir')
if len(kill) == 0:
PmagResRec = {
} # set up dictionary for the pmag_results table entry
PmagResRec['data_type'] = 'i' # decorate it a bit
PmagResRec['magic_software_packages'] = version_num
PmagSiteRec[
'site_description'] = 'Site direction included in results table'
PmagResRec['pmag_criteria_codes'] = 'ACCEPT'
dec = float(PmagSiteRec["site_dec"])
inc = float(PmagSiteRec["site_inc"])
if 'site_alpha95' in PmagSiteRec.keys(
) and PmagSiteRec['site_alpha95'] != "":
a95 = float(PmagSiteRec["site_alpha95"])
else:
a95 = 180.
sitedat = pmag.get_dictitem(
SiteNFO, 'er_site_name', PmagSiteRec['er_site_name'],
'T')[0] # fish out site information (lat/lon, etc.)
lat = float(sitedat['site_lat'])
lon = float(sitedat['site_lon'])
plong, plat, dp, dm = pmag.dia_vgp(
dec, inc, a95, lat, lon) # get the VGP for this site
if PmagSiteRec['site_tilt_correction'] == '-1':
C = ' (spec coord) '
if PmagSiteRec['site_tilt_correction'] == '0':
C = ' (geog. coord) '
if PmagSiteRec['site_tilt_correction'] == '100':
C = ' (strat. coord) '
PmagResRec["pmag_result_name"] = "VGP Site: " + PmagSiteRec[
"er_site_name"] # decorate some more
PmagResRec[
"result_description"] = "Site VGP, coord system = " + str(
coord) + ' component: ' + comp
PmagResRec['er_site_names'] = PmagSiteRec['er_site_name']
PmagResRec['pmag_criteria_codes'] = 'ACCEPT'
PmagResRec['er_citation_names'] = 'This study'
PmagResRec['er_analyst_mail_names'] = user
PmagResRec["er_location_names"] = PmagSiteRec[
"er_location_name"]
if Daverage == 1:
PmagResRec["er_sample_names"] = PmagSiteRec[
"er_sample_names"]
else:
PmagResRec["er_specimen_names"] = PmagSiteRec[
"er_specimen_names"]
PmagResRec["tilt_correction"] = PmagSiteRec[
'site_tilt_correction']
PmagResRec["pole_comp_name"] = PmagSiteRec['site_comp_name']
PmagResRec["average_dec"] = PmagSiteRec["site_dec"]
PmagResRec["average_inc"] = PmagSiteRec["site_inc"]
PmagResRec["average_alpha95"] = PmagSiteRec["site_alpha95"]
PmagResRec["average_n"] = PmagSiteRec["site_n"]
PmagResRec["average_n_lines"] = PmagSiteRec["site_n_lines"]
PmagResRec["average_n_planes"] = PmagSiteRec["site_n_planes"]
PmagResRec["vgp_n"] = PmagSiteRec["site_n"]
PmagResRec["average_k"] = PmagSiteRec["site_k"]
PmagResRec["average_r"] = PmagSiteRec["site_r"]
PmagResRec["average_lat"] = '%10.4f ' % (lat)
PmagResRec["average_lon"] = '%10.4f ' % (lon)
if agefile != "":
PmagResRec = pmag.get_age(PmagResRec, "er_site_names",
"average_", AgeNFO, DefaultAge)
site_height = pmag.get_dictitem(height_nfo, 'er_site_name',
site, 'T')
if len(site_height) > 0:
PmagResRec["average_height"] = site_height[0][
'site_height']
PmagResRec["vgp_lat"] = '%7.1f ' % (plat)
PmagResRec["vgp_lon"] = '%7.1f ' % (plong)
PmagResRec["vgp_dp"] = '%7.1f ' % (dp)
PmagResRec["vgp_dm"] = '%7.1f ' % (dm)
PmagResRec["magic_method_codes"] = PmagSiteRec[
"magic_method_codes"]
if PmagSiteRec['site_tilt_correction'] == '0':
PmagSiteRec['magic_method_codes'] = PmagSiteRec[
'magic_method_codes'] + ":DA-DIR-GEO"
if PmagSiteRec['site_tilt_correction'] == '100':
PmagSiteRec['magic_method_codes'] = PmagSiteRec[
'magic_method_codes'] + ":DA-DIR-TILT"
PmagSiteRec['site_polarity'] = ""
if polarity == 1: # assign polarity based on angle of pole lat to spin axis - may want to re-think this sometime
angle = pmag.angle([0, 0], [0, (90 - plat)])
if angle <= 55.: PmagSiteRec["site_polarity"] = 'n'
if angle > 55. and angle < 125.:
PmagSiteRec["site_polarity"] = 't'
if angle >= 125.: PmagSiteRec["site_polarity"] = 'r'
PmagResults.append(PmagResRec)
if polarity == 1:
crecs = pmag.get_dictitem(PmagSites, 'site_tilt_correction', '100',
'T') # find the tilt corrected data
if len(crecs) < 2:
crecs = pmag.get_dictitem(
PmagSites, 'site_tilt_correction', '0',
'T') # if there aren't any, find the geographic corrected data
if len(crecs) > 2: # if there are some,
comp = pmag.get_list(
crecs,
'site_comp_name').split(':')[0] # find the first component
crecs = pmag.get_dictitem(
crecs, 'site_comp_name', comp,
'T') # fish out all of the first component
precs = []
for rec in crecs:
precs.append({
'dec': rec['site_dec'],
'inc': rec['site_inc'],
'name': rec['er_site_name'],
'loc': rec['er_location_name']
})
polpars = pmag.fisher_by_pol(
precs) # calculate average by polarity
for mode in polpars.keys(
): # hunt through all the modes (normal=A, reverse=B, all=ALL)
PolRes = {}
PolRes['er_citation_names'] = 'This study'
PolRes[
"pmag_result_name"] = "Polarity Average: Polarity " + mode #
PolRes["data_type"] = "a"
PolRes["average_dec"] = '%7.1f' % (polpars[mode]['dec'])
PolRes["average_inc"] = '%7.1f' % (polpars[mode]['inc'])
PolRes["average_n"] = '%i' % (polpars[mode]['n'])
PolRes["average_r"] = '%5.4f' % (polpars[mode]['r'])
PolRes["average_k"] = '%6.0f' % (polpars[mode]['k'])
PolRes["average_alpha95"] = '%7.1f' % (
polpars[mode]['alpha95'])
PolRes['er_site_names'] = polpars[mode]['sites']
PolRes['er_location_names'] = polpars[mode]['locs']
PolRes['magic_software_packages'] = version_num
PmagResults.append(PolRes)
if noInt != 1 and nositeints != 1:
for site in sites: # now do intensities for each site
if plotsites == 1: print site
if Iaverage == 0:
key, intlist = 'specimen', SpecInts # if using specimen level data
if Iaverage == 1:
key, intlist = 'sample', PmagSamps # if using sample level data
Ints = pmag.get_dictitem(
intlist, 'er_site_name', site,
'T') # get all the intensities for this site
if len(Ints) > 0: # there are some
PmagSiteRec = pmag.average_int(
Ints, key,
'site') # get average intensity stuff for site table
PmagResRec = pmag.average_int(
Ints, key,
'average') # get average intensity stuff for results table
if plotsites == 1: # if site by site examination requested - print this site out to the screen
for rec in Ints:
print rec['er_' + key + '_name'], ' %7.1f' % (
1e6 * float(rec[key + '_int']))
if len(Ints) > 1:
print 'Average: ', '%7.1f' % (1e6 * float(
PmagResRec['average_int'])), 'N: ', len(Ints)
print 'Sigma: ', '%7.1f' % (
1e6 * float(PmagResRec['average_int_sigma'])
), 'Sigma %: ', PmagResRec['average_int_sigma_perc']
raw_input('Press any key to continue\n')
er_location_name = Ints[0]["er_location_name"]
PmagSiteRec[
"er_location_name"] = er_location_name # decorate the records
PmagSiteRec["er_citation_names"] = "This study"
PmagResRec["er_location_names"] = er_location_name
PmagResRec["er_citation_names"] = "This study"
PmagSiteRec["er_analyst_mail_names"] = user
PmagResRec["er_analyst_mail_names"] = user
PmagResRec["data_type"] = 'i'
if Iaverage == 0:
PmagSiteRec['er_specimen_names'] = pmag.get_list(
Ints, 'er_specimen_name') # list of all specimens used
PmagResRec['er_specimen_names'] = pmag.get_list(
Ints, 'er_specimen_name')
PmagSiteRec['er_sample_names'] = pmag.get_list(
Ints, 'er_sample_name') # list of all samples used
PmagResRec['er_sample_names'] = pmag.get_list(
Ints, 'er_sample_name')
PmagSiteRec['er_site_name'] = site
PmagResRec['er_site_names'] = site
PmagSiteRec['magic_method_codes'] = pmag.get_list(
Ints, 'magic_method_codes')
PmagResRec['magic_method_codes'] = pmag.get_list(
Ints, 'magic_method_codes')
kill = pmag.grade(PmagSiteRec, accept, 'site_int')
if nocrit == 1 or len(kill) == 0:
b, sig = float(PmagResRec['average_int']), ""
if (PmagResRec['average_int_sigma']) != "":
sig = float(PmagResRec['average_int_sigma'])
sdir = pmag.get_dictitem(PmagResults, 'er_site_names',
site,
'T') # fish out site direction
if len(sdir) > 0 and sdir[-1][
'average_inc'] != "": # get the VDM for this record using last average inclination (hope it is the right one!)
inc = float(sdir[0]['average_inc']) #
mlat = pmag.magnetic_lat(
inc) # get magnetic latitude using dipole formula
PmagResRec["vdm"] = '%8.3e ' % (pmag.b_vdm(
b, mlat)) # get VDM with magnetic latitude
PmagResRec["vdm_n"] = PmagResRec['average_int_n']
if 'average_int_sigma' in PmagResRec.keys(
) and PmagResRec['average_int_sigma'] != "":
vdm_sig = pmag.b_vdm(
float(PmagResRec['average_int_sigma']), mlat)
PmagResRec["vdm_sigma"] = '%8.3e ' % (vdm_sig)
else:
PmagResRec["vdm_sigma"] = ""
mlat = "" # define a model latitude
if get_model_lat == 1: # use present site latitude
mlats = pmag.get_dictitem(SiteNFO, 'er_site_name',
site, 'T')
if len(mlats) > 0: mlat = mlats[0]['site_lat']
elif get_model_lat == 2: # use a model latitude from some plate reconstruction model (or something)
mlats = pmag.get_dictitem(ModelLats, 'er_site_name',
site, 'T')
if len(mlats) > 0:
PmagResRec['model_lat'] = mlats[0][
'site_model_lat']
mlat = PmagResRec['model_lat']
if mlat != "":
PmagResRec["vadm"] = '%8.3e ' % (
pmag.b_vdm(b, float(mlat))
) # get the VADM using the desired latitude
if sig != "":
vdm_sig = pmag.b_vdm(
float(PmagResRec['average_int_sigma']),
float(mlat))
PmagResRec["vadm_sigma"] = '%8.3e ' % (vdm_sig)
PmagResRec["vadm_n"] = PmagResRec['average_int_n']
else:
PmagResRec["vadm_sigma"] = ""
sitedat = pmag.get_dictitem(
SiteNFO, 'er_site_name', PmagSiteRec['er_site_name'],
'T') # fish out site information (lat/lon, etc.)
if len(sitedat) > 0:
sitedat = sitedat[0]
PmagResRec['average_lat'] = sitedat['site_lat']
PmagResRec['average_lon'] = sitedat['site_lon']
else:
PmagResRec['average_lon'] = 'UNKNOWN'
PmagResRec['average_lon'] = 'UNKNOWN'
PmagResRec['magic_software_packages'] = version_num
PmagResRec["pmag_result_name"] = "V[A]DM: Site " + site
PmagResRec["result_description"] = "V[A]DM of site"
PmagResRec["pmag_criteria_codes"] = "ACCEPT"
if agefile != "":
PmagResRec = pmag.get_age(PmagResRec, "er_site_names",
"average_", AgeNFO,
DefaultAge)
site_height = pmag.get_dictitem(height_nfo, 'er_site_name',
site, 'T')
if len(site_height) > 0:
PmagResRec["average_height"] = site_height[0][
'site_height']
PmagSites.append(PmagSiteRec)
PmagResults.append(PmagResRec)
if len(PmagSites) > 0:
Tmp, keylist = pmag.fillkeys(PmagSites)
pmag.magic_write(siteout, Tmp, 'pmag_sites')
print ' sites written to ', siteout
else:
print "No Site level table"
if len(PmagResults) > 0:
TmpRes, keylist = pmag.fillkeys(PmagResults)
pmag.magic_write(resout, TmpRes, 'pmag_results')
print ' results written to ', resout
else:
print "No Results level table"
def main():
"""
NAME
vgpmap_magic.py
DESCRIPTION
makes a map of vgps and a95/dp,dm for site means in a pmag_results table
SYNTAX
vgpmap_magic.py [command line options]
OPTIONS
-h prints help and quits
-eye ELAT ELON [specify eyeball location], default is 90., 0.
-f FILE pmag_results format file, [default is pmag_results.txt]
-res [c,l,i,h] specify resolution (crude, low, intermediate, high]
-etp plot the etopo20 topographpy data (requires high resolution data set)
-prj PROJ, specify one of the following:
ortho = orthographic
lcc = lambert conformal
moll = molweide
merc = mercator
-sym SYM SIZE: choose a symbol and size, examples:
ro 5 : small red circles
bs 10 : intermediate blue squares
g^ 20 : large green triangles
-ell plot dp/dm or a95 ellipses
-rev RSYM RSIZE : flip reverse poles to normal antipode
-S: plot antipodes of all poles
-age : plot the ages next to the poles
-crd [g,t] : choose coordinate system, default is to plot all site VGPs
-fmt [pdf, png, eps...] specify output format, default is pdf
-sav save and quit
DEFAULTS
FILE: pmag_results.txt
res: c
prj: ortho
ELAT,ELON = 0,0
SYM SIZE: ro 8
RSYM RSIZE: g^ 8
"""
dir_path = '.'
res, ages = 'c', 0
plot = 0
proj = 'ortho'
results_file = 'pmag_results.txt'
ell, flip = 0, 0
lat_0, lon_0 = 90., 0.
fmt = 'pdf'
sym, size = 'ro', 8
rsym, rsize = 'g^', 8
anti = 0
fancy = 0
coord = ""
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind+1]
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-S' in sys.argv:
anti = 1
if '-fmt' in sys.argv:
ind = sys.argv.index('-fmt')
fmt = sys.argv[ind+1]
if '-sav' in sys.argv:
plot = 1
if '-res' in sys.argv:
ind = sys.argv.index('-res')
res = sys.argv[ind+1]
if '-etp' in sys.argv:
fancy = 1
if '-prj' in sys.argv:
ind = sys.argv.index('-prj')
proj = sys.argv[ind+1]
if '-rev' in sys.argv:
flip = 1
ind = sys.argv.index('-rev')
rsym = (sys.argv[ind+1])
rsize = int(sys.argv[ind+2])
if '-sym' in sys.argv:
ind = sys.argv.index('-sym')
sym = (sys.argv[ind+1])
size = int(sys.argv[ind+2])
if '-eye' in sys.argv:
ind = sys.argv.index('-eye')
lat_0 = float(sys.argv[ind+1])
lon_0 = float(sys.argv[ind+2])
if '-ell' in sys.argv:
ell = 1
if '-age' in sys.argv:
ages = 1
if '-f' in sys.argv:
ind = sys.argv.index('-f')
results_file = sys.argv[ind+1]
if '-crd' in sys.argv:
ind = sys.argv.index('-crd')
crd = sys.argv[ind+1]
if crd == 'g':
coord = '0'
if crd == 't':
coord = '100'
results_file = dir_path+'/'+results_file
data, file_type = pmag.magic_read(results_file)
if file_type != 'pmag_results':
print("bad results file")
sys.exit()
FIG = {'map': 1}
pmagplotlib.plot_init(FIG['map'], 6, 6)
# read in er_sites file
lats, lons, dp, dm, a95 = [], [], [], [], []
Pars = []
dates, rlats, rlons = [], [], []
if 'data_type' in data[0].keys():
# get all site level data
Results = pmag.get_dictitem(data, 'data_type', 'i', 'T')
else:
Results = data
# get all non-blank latitudes
Results = pmag.get_dictitem(Results, 'vgp_lat', '', 'F')
# get all non-blank longitudes
Results = pmag.get_dictitem(Results, 'vgp_lon', '', 'F')
if coord != "":
# get specified coordinate system
Results = pmag.get_dictitem(Results, 'tilt_correction', coord, 'T')
location = ""
for rec in Results:
if rec['er_location_names'] not in location:
location = location+':'+rec['er_location_names']
if 'average_age' in rec.keys() and rec['average_age'] != "" and ages == 1:
dates.append(rec['average_age'])
lat = float(rec['vgp_lat'])
lon = float(rec['vgp_lon'])
if flip == 0:
lats.append(lat)
lons.append(lon)
elif flip == 1:
if lat < 0:
rlats.append(-lat)
lon = lon+180.
if lon > 360:
lon = lon-360.
rlons.append(lon)
else:
lats.append(lat)
lons.append(lon)
elif anti == 1:
lats.append(-lat)
lon = lon+180.
if lon > 360:
lon = lon-360.
lons.append(lon)
ppars = []
ppars.append(lon)
ppars.append(lat)
ell1, ell2 = "", ""
if 'vgp_dm' in rec.keys() and rec['vgp_dm'] != "":
ell1 = float(rec['vgp_dm'])
if 'vgp_dp' in rec.keys() and rec['vgp_dp'] != "":
ell2 = float(rec['vgp_dp'])
if 'vgp_alpha95' in rec.keys() and rec['vgp_alpha95'] != "":
ell1, ell2 = float(rec['vgp_alpha95']), float(rec['vgp_alpha95'])
if ell1 != "" and ell2 != "":
ppars = []
ppars.append(lons[-1])
ppars.append(lats[-1])
ppars.append(ell1)
ppars.append(lons[-1])
isign = abs(lats[-1])/lats[-1]
ppars.append(lats[-1]-isign*90.)
ppars.append(ell2)
ppars.append(lons[-1]+90.)
ppars.append(0.)
Pars.append(ppars)
location = location.strip(':')
Opts = {'latmin': -90, 'latmax': 90, 'lonmin': 0., 'lonmax': 360., 'lat_0': lat_0, 'lon_0': lon_0,
'proj': proj, 'sym': 'bs', 'symsize': 3, 'pltgrid': 0, 'res': res, 'boundinglat': 0.}
Opts['details'] = {'coasts': 1, 'rivers': 0, 'states': 0,
'countries': 0, 'ocean': 1, 'fancy': fancy}
# make the base map with a blue triangle at the pole`
pmagplotlib.plot_map(FIG['map'], [90.], [0.], Opts)
Opts['pltgrid'] = -1
Opts['sym'] = sym
Opts['symsize'] = size
if len(dates) > 0:
Opts['names'] = dates
if len(lats) > 0:
# add the lats and lons of the poles
pmagplotlib.plot_map(FIG['map'], lats, lons, Opts)
Opts['names'] = []
if len(rlats) > 0:
Opts['sym'] = rsym
Opts['symsize'] = rsize
# add the lats and lons of the poles
pmagplotlib.plot_map(FIG['map'], rlats, rlons, Opts)
if plot == 0:
pmagplotlib.draw_figs(FIG)
if ell == 1: # add ellipses if desired.
Opts['details'] = {'coasts': 0, 'rivers': 0,
'states': 0, 'countries': 0, 'ocean': 0}
Opts['pltgrid'] = -1 # turn off meridian replotting
Opts['symsize'] = 2
Opts['sym'] = 'g-'
for ppars in Pars:
if ppars[2] != 0:
PTS = pmagplotlib.plot_ell(FIG['map'], ppars, 'g.', 0, 0)
elats, elons = [], []
for pt in PTS:
elons.append(pt[0])
elats.append(pt[1])
# make the base map with a blue triangle at the pole`
pmagplotlib.plot_map(FIG['map'], elats, elons, Opts)
if plot == 0:
pmagplotlib.draw_figs(FIG)
files = {}
for key in FIG.keys():
if pmagplotlib.isServer: # use server plot naming convention
files[key] = 'LO:_'+location+'_VGP_map.'+fmt
else: # use more readable plot naming convention
files[key] = '{}_VGP_map.{}'.format(
location.replace(' ', '_'), fmt)
if pmagplotlib.isServer:
black = '#000000'
purple = '#800080'
titles = {}
titles['eq'] = 'LO:_'+location+'_VGP_map'
FIG = pmagplotlib.add_borders(FIG, titles, black, purple)
pmagplotlib.save_plots(FIG, files)
elif plot == 0:
pmagplotlib.draw_figs(FIG)
ans = input(" S[a]ve to save plot, Return to quit: ")
if ans == "a":
pmagplotlib.save_plots(FIG, files)
else:
print("Good bye")
sys.exit()
else:
pmagplotlib.save_plots(FIG, files)
def main():
"""
NAME
eqarea_magic.py
DESCRIPTION
makes equal area projections from declination/inclination data
SYNTAX
eqarea_magic.py [command line options]
INPUT
takes magic formatted pmag_results, pmag_sites, pmag_samples or pmag_specimens
OPTIONS
-h prints help message and quits
-f FILE: specify input magic format file from magic,default='pmag_results.txt'
supported types=[magic_measurements,pmag_specimens, pmag_samples, pmag_sites, pmag_results, magic_web]
-obj OBJ: specify level of plot [all, sit, sam, spc], default is all
-crd [s,g,t]: specify coordinate system, [s]pecimen, [g]eographic, [t]ilt adjusted
default is geographic, unspecified assumed geographic
-fmt [svg,png,jpg] format for output plots
-ell [F,K,B,Be,Bv] plot Fisher, Kent, Bingham, Bootstrap ellipses or Boostrap eigenvectors
-c plot as colour contour
-sav save plot and quit quietly
NOTE
all: entire file; sit: site; sam: sample; spc: specimen
"""
FIG = {} # plot dictionary
FIG['eqarea'] = 1 # eqarea is figure 1
in_file, plot_key, coord, crd = 'pmag_results.txt', 'all', "0", 'g'
plotE, contour = 0, 0
dir_path = '.'
fmt = 'svg'
verbose = pmagplotlib.verbose
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind+1]
pmagplotlib.plot_init(FIG['eqarea'], 5, 5)
if '-f' in sys.argv:
ind = sys.argv.index("-f")
in_file = dir_path+"/"+sys.argv[ind+1]
if '-obj' in sys.argv:
ind = sys.argv.index('-obj')
plot_by = sys.argv[ind+1]
if plot_by == 'all':
plot_key = 'all'
if plot_by == 'sit':
plot_key = 'er_site_name'
if plot_by == 'sam':
plot_key = 'er_sample_name'
if plot_by == 'spc':
plot_key = 'er_specimen_name'
if '-c' in sys.argv:
contour = 1
plt = 0
if '-sav' in sys.argv:
plt = 1
verbose = 0
if '-ell' in sys.argv:
plotE = 1
ind = sys.argv.index('-ell')
ell_type = sys.argv[ind+1]
if ell_type == 'F':
dist = 'F'
if ell_type == 'K':
dist = 'K'
if ell_type == 'B':
dist = 'B'
if ell_type == 'Be':
dist = 'BE'
if ell_type == 'Bv':
dist = 'BV'
FIG['bdirs'] = 2
pmagplotlib.plot_init(FIG['bdirs'], 5, 5)
if '-crd' in sys.argv:
ind = sys.argv.index("-crd")
crd = sys.argv[ind+1]
if crd == 's':
coord = "-1"
if crd == 'g':
coord = "0"
if crd == 't':
coord = "100"
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind+1]
Dec_keys = ['site_dec', 'sample_dec', 'specimen_dec',
'measurement_dec', 'average_dec', 'none']
Inc_keys = ['site_inc', 'sample_inc', 'specimen_inc',
'measurement_inc', 'average_inc', 'none']
Tilt_keys = ['tilt_correction', 'site_tilt_correction',
'sample_tilt_correction', 'specimen_tilt_correction', 'none']
Dir_type_keys = ['', 'site_direction_type',
'sample_direction_type', 'specimen_direction_type']
Name_keys = ['er_specimen_name', 'er_sample_name',
'er_site_name', 'pmag_result_name']
data, file_type = pmag.magic_read(in_file)
if file_type == 'pmag_results' and plot_key != "all":
plot_key = plot_key+'s' # need plural for results table
if verbose:
print(len(data), ' records read from ', in_file)
#
#
# find desired dec,inc data:
#
dir_type_key = ''
#
# get plotlist if not plotting all records
#
plotlist = []
if plot_key != "all":
plots = pmag.get_dictitem(data, plot_key, '', 'F')
for rec in plots:
if rec[plot_key] not in plotlist:
plotlist.append(rec[plot_key])
plotlist.sort()
else:
plotlist.append('All')
for plot in plotlist:
# if verbose: print plot
DIblock = []
GCblock = []
SLblock, SPblock = [], []
title = plot
mode = 1
dec_key, inc_key, tilt_key, name_key, k = "", "", "", "", 0
if plot != "All":
odata = pmag.get_dictitem(data, plot_key, plot, 'T')
else:
odata = data # data for this obj
for dec_key in Dec_keys:
# get all records with this dec_key not blank
Decs = pmag.get_dictitem(odata, dec_key, '', 'F')
if len(Decs) > 0:
break
for inc_key in Inc_keys:
# get all records with this inc_key not blank
Incs = pmag.get_dictitem(Decs, inc_key, '', 'F')
if len(Incs) > 0:
break
for tilt_key in Tilt_keys:
if tilt_key in Incs[0].keys():
break # find the tilt_key for these records
if tilt_key == 'none': # no tilt key in data, need to fix this with fake data which will be unknown tilt
tilt_key = 'tilt_correction'
for rec in Incs:
rec[tilt_key] = ''
# get all records matching specified coordinate system
cdata = pmag.get_dictitem(Incs, tilt_key, coord, 'T')
if coord == '0': # geographic
# get all the blank records - assume geographic
udata = pmag.get_dictitem(Incs, tilt_key, '', 'T')
if len(cdata) == 0:
crd = ''
if len(udata) > 0:
for d in udata:
cdata.append(d)
crd = crd+'u'
for name_key in Name_keys:
# get all records with this name_key not blank
Names = pmag.get_dictitem(cdata, name_key, '', 'F')
if len(Names) > 0:
break
for dir_type_key in Dir_type_keys:
# get all records with this direction type
Dirs = pmag.get_dictitem(cdata, dir_type_key, '', 'F')
if len(Dirs) > 0:
break
if dir_type_key == "":
dir_type_key = 'direction_type'
locations, site, sample, specimen = "", "", "", ""
for rec in cdata: # pick out the data
if 'er_location_name' in rec.keys() and rec['er_location_name'] != "" and rec['er_location_name'] not in locations:
locations = locations + \
rec['er_location_name'].replace("/", "")+"_"
if 'er_location_names' in rec.keys() and rec['er_location_names'] != "":
locs = rec['er_location_names'].split(':')
for loc in locs:
if loc not in locations:
locations = locations+loc.replace("/", "")+'_'
if plot_key == 'er_site_name' or plot_key == 'er_sample_name' or plot_key == 'er_specimen_name':
site = rec['er_site_name']
if plot_key == 'er_sample_name' or plot_key == 'er_specimen_name':
sample = rec['er_sample_name']
if plot_key == 'er_specimen_name':
specimen = rec['er_specimen_name']
if plot_key == 'er_site_names' or plot_key == 'er_sample_names' or plot_key == 'er_specimen_names':
site = rec['er_site_names']
if plot_key == 'er_sample_names' or plot_key == 'er_specimen_names':
sample = rec['er_sample_names']
if plot_key == 'er_specimen_names':
specimen = rec['er_specimen_names']
if dir_type_key not in rec.keys() or rec[dir_type_key] == "":
rec[dir_type_key] = 'l'
if 'magic_method_codes' not in rec.keys():
rec['magic_method_codes'] = ""
DIblock.append([float(rec[dec_key]), float(rec[inc_key])])
SLblock.append([rec[name_key], rec['magic_method_codes']])
if rec[tilt_key] == coord and rec[dir_type_key] != 'l' and rec[dec_key] != "" and rec[inc_key] != "":
GCblock.append([float(rec[dec_key]), float(rec[inc_key])])
SPblock.append([rec[name_key], rec['magic_method_codes']])
if len(DIblock) == 0 and len(GCblock) == 0:
if verbose:
print("no records for plotting")
sys.exit()
if verbose:
for k in range(len(SLblock)):
print('%s %s %7.1f %7.1f' % (
SLblock[k][0], SLblock[k][1], DIblock[k][0], DIblock[k][1]))
for k in range(len(SPblock)):
print('%s %s %7.1f %7.1f' % (
SPblock[k][0], SPblock[k][1], GCblock[k][0], GCblock[k][1]))
if len(DIblock) > 0:
if contour == 0:
pmagplotlib.plot_eq(FIG['eqarea'], DIblock, title)
else:
pmagplotlib.plot_eq_cont(FIG['eqarea'], DIblock)
else:
pmagplotlib.plot_net(FIG['eqarea'])
if len(GCblock) > 0:
for rec in GCblock:
pmagplotlib.plot_circ(FIG['eqarea'], rec, 90., 'g')
if plotE == 1:
ppars = pmag.doprinc(DIblock) # get principal directions
nDIs, rDIs, npars, rpars = [], [], [], []
for rec in DIblock:
angle = pmag.angle([rec[0], rec[1]], [
ppars['dec'], ppars['inc']])
if angle > 90.:
rDIs.append(rec)
else:
nDIs.append(rec)
if dist == 'B': # do on whole dataset
etitle = "Bingham confidence ellipse"
bpars = pmag.dobingham(DIblock)
for key in bpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (bpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (bpars[key]))
npars.append(bpars['dec'])
npars.append(bpars['inc'])
npars.append(bpars['Zeta'])
npars.append(bpars['Zdec'])
npars.append(bpars['Zinc'])
npars.append(bpars['Eta'])
npars.append(bpars['Edec'])
npars.append(bpars['Einc'])
if dist == 'F':
etitle = "Fisher confidence cone"
if len(nDIs) > 2:
fpars = pmag.fisher_mean(nDIs)
for key in fpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (fpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (fpars[key]))
mode += 1
npars.append(fpars['dec'])
npars.append(fpars['inc'])
npars.append(fpars['alpha95']) # Beta
npars.append(fpars['dec'])
isign = abs(fpars['inc'])/fpars['inc']
npars.append(fpars['inc']-isign*90.) # Beta inc
npars.append(fpars['alpha95']) # gamma
npars.append(fpars['dec']+90.) # Beta dec
npars.append(0.) # Beta inc
if len(rDIs) > 2:
fpars = pmag.fisher_mean(rDIs)
if verbose:
print("mode ", mode)
for key in fpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (fpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (fpars[key]))
mode += 1
rpars.append(fpars['dec'])
rpars.append(fpars['inc'])
rpars.append(fpars['alpha95']) # Beta
rpars.append(fpars['dec'])
isign = abs(fpars['inc'])/fpars['inc']
rpars.append(fpars['inc']-isign*90.) # Beta inc
rpars.append(fpars['alpha95']) # gamma
rpars.append(fpars['dec']+90.) # Beta dec
rpars.append(0.) # Beta inc
if dist == 'K':
etitle = "Kent confidence ellipse"
if len(nDIs) > 3:
kpars = pmag.dokent(nDIs, len(nDIs))
if verbose:
print("mode ", mode)
for key in kpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (kpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (kpars[key]))
mode += 1
npars.append(kpars['dec'])
npars.append(kpars['inc'])
npars.append(kpars['Zeta'])
npars.append(kpars['Zdec'])
npars.append(kpars['Zinc'])
npars.append(kpars['Eta'])
npars.append(kpars['Edec'])
npars.append(kpars['Einc'])
if len(rDIs) > 3:
kpars = pmag.dokent(rDIs, len(rDIs))
if verbose:
print("mode ", mode)
for key in kpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (kpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (kpars[key]))
mode += 1
rpars.append(kpars['dec'])
rpars.append(kpars['inc'])
rpars.append(kpars['Zeta'])
rpars.append(kpars['Zdec'])
rpars.append(kpars['Zinc'])
rpars.append(kpars['Eta'])
rpars.append(kpars['Edec'])
rpars.append(kpars['Einc'])
else: # assume bootstrap
if dist == 'BE':
if len(nDIs) > 5:
BnDIs = pmag.di_boot(nDIs)
Bkpars = pmag.dokent(BnDIs, 1.)
if verbose:
print("mode ", mode)
for key in Bkpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (Bkpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (Bkpars[key]))
mode += 1
npars.append(Bkpars['dec'])
npars.append(Bkpars['inc'])
npars.append(Bkpars['Zeta'])
npars.append(Bkpars['Zdec'])
npars.append(Bkpars['Zinc'])
npars.append(Bkpars['Eta'])
npars.append(Bkpars['Edec'])
npars.append(Bkpars['Einc'])
if len(rDIs) > 5:
BrDIs = pmag.di_boot(rDIs)
Bkpars = pmag.dokent(BrDIs, 1.)
if verbose:
print("mode ", mode)
for key in Bkpars.keys():
if key != 'n' and verbose:
print(" ", key, '%7.1f' % (Bkpars[key]))
if key == 'n' and verbose:
print(" ", key, ' %i' % (Bkpars[key]))
mode += 1
rpars.append(Bkpars['dec'])
rpars.append(Bkpars['inc'])
rpars.append(Bkpars['Zeta'])
rpars.append(Bkpars['Zdec'])
rpars.append(Bkpars['Zinc'])
rpars.append(Bkpars['Eta'])
rpars.append(Bkpars['Edec'])
rpars.append(Bkpars['Einc'])
etitle = "Bootstrapped confidence ellipse"
elif dist == 'BV':
sym = {'lower': ['o', 'c'], 'upper': [
'o', 'g'], 'size': 3, 'edgecolor': 'face'}
if len(nDIs) > 5:
BnDIs = pmag.di_boot(nDIs)
pmagplotlib.plot_eq_sym(
FIG['bdirs'], BnDIs, 'Bootstrapped Eigenvectors', sym)
if len(rDIs) > 5:
BrDIs = pmag.di_boot(rDIs)
if len(nDIs) > 5: # plot on existing plots
pmagplotlib.plot_di_sym(FIG['bdirs'], BrDIs, sym)
else:
pmagplotlib.plot_eq(
FIG['bdirs'], BrDIs, 'Bootstrapped Eigenvectors')
if dist == 'B':
if len(nDIs) > 3 or len(rDIs) > 3:
pmagplotlib.plot_conf(FIG['eqarea'], etitle, [], npars, 0)
elif len(nDIs) > 3 and dist != 'BV':
pmagplotlib.plot_conf(FIG['eqarea'], etitle, [], npars, 0)
if len(rDIs) > 3:
pmagplotlib.plot_conf(FIG['eqarea'], etitle, [], rpars, 0)
elif len(rDIs) > 3 and dist != 'BV':
pmagplotlib.plot_conf(FIG['eqarea'], etitle, [], rpars, 0)
if verbose:
pmagplotlib.draw_figs(FIG)
#
files = {}
locations = locations[:-1]
for key in FIG.keys():
if pmagplotlib.isServer: # use server plot naming convention
filename = 'LO:_'+locations+'_SI:_'+site+'_SA:_'+sample + \
'_SP:_'+specimen+'_CO:_'+crd+'_TY:_'+key+'_.'+fmt
else: # use more readable plot naming convention
filename = ''
for item in [locations, site, sample, specimen, crd, key]:
if item:
item = item.replace(' ', '_')
filename += item + '_'
if filename.endswith('_'):
filename = filename[:-1]
filename += ".{}".format(fmt)
files[key] = filename
if pmagplotlib.isServer:
black = '#000000'
purple = '#800080'
titles = {}
titles['eq'] = 'Equal Area Plot'
FIG = pmagplotlib.add_borders(FIG, titles, black, purple)
pmagplotlib.save_plots(FIG, files)
elif verbose:
ans = raw_input(
" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans == "q":
sys.exit()
if ans == "a":
pmagplotlib.save_plots(FIG, files)
if plt:
pmagplotlib.save_plots(FIG, files)
def main():
"""
NAME
hysteresis_magic.py
DESCRIPTION
calculates hystereis parameters and saves them in 3.0 specimen format file
makes plots if option selected
SYNTAX
hysteresis_magic.py [command line options]
OPTIONS
-h prints help message and quits
-f: specify input file, default is agm_measurements.txt
-F: specify specimens.txt output file
-P: do not make the plots
-spc SPEC: specify specimen name to plot and quit
-sav save all plots and quit
-fmt [png,svg,eps,jpg]
"""
args=sys.argv
PLT=1
plots=0
fmt=pmag.get_named_arg_from_sys('-fmt','svg')
dir_path=pmag.get_named_arg_from_sys('-WD','.')
dir_path=os.path.realpath(dir_path)
verbose=pmagplotlib.verbose
version_num=pmag.get_version()
user=pmag.get_named_arg_from_sys('-usr','')
if "-h" in args:
print(main.__doc__)
sys.exit()
meas_file=pmag.get_named_arg_from_sys('-f','agm_measurements.txt')
spec_file=pmag.get_named_arg_from_sys('-F','specimens.txt')
if '-P' in args:
PLT=0
irm_init,imag_init=-1,-1
if '-sav' in args:
verbose=0
plots=1
pltspec=pmag.get_named_arg_from_sys('-spc',0)
if pltspec:
#pltspec= args[ind+1]
verbose=0
plots=1
spec_file=dir_path+'/'+spec_file
meas_file=dir_path+'/'+meas_file
SpecRecs=[]
#
#
meas_data,file_type=pmag.magic_read(meas_file)
if file_type!='measurements':
print(main.__doc__)
print('bad file')
sys.exit()
#
# initialize some variables
# define figure numbers for hyst,deltaM,DdeltaM curves
HystRecs,RemRecs=[],[]
HDD={}
if verbose:
if verbose and PLT:print("Plots may be on top of each other - use mouse to place ")
if PLT:
HDD['hyst'],HDD['deltaM'],HDD['DdeltaM']=1,2,3
pmagplotlib.plot_init(HDD['DdeltaM'],5,5)
pmagplotlib.plot_init(HDD['deltaM'],5,5)
pmagplotlib.plot_init(HDD['hyst'],5,5)
imag_init=0
irm_init=0
else:
HDD['hyst'],HDD['deltaM'],HDD['DdeltaM'],HDD['irm'],HDD['imag']=0,0,0,0,0
#
if spec_file: prior_data,file_type=pmag.magic_read(spec_file)
#
# get list of unique experiment names and specimen names
#
experiment_names,sids=[],[]
hys_data=pmag.get_dictitem(meas_data,'method_codes','LP-HYS','has')
dcd_data=pmag.get_dictitem(meas_data,'method_codes','LP-IRM-DCD','has')
imag_data=pmag.get_dictitem(meas_data,'method_codes','LP-IMAG','has')
for rec in hys_data:
if rec['experiment'] not in experiment_names:experiment_names.append(rec['experiment'])
if rec['specimen'] not in sids:sids.append(rec['specimen'])
#
k=0
if pltspec:
k=sids.index(pltspec)
print(sids[k])
while k < len(sids):
specimen=sids[k]
HystRec={'specimen':specimen,'experiment':""} # initialize a new specimen hysteresis record
if verbose and PLT:print(specimen, k+1 , 'out of ',len(sids))
#
#
B,M,Bdcd,Mdcd=[],[],[],[] #B,M for hysteresis, Bdcd,Mdcd for irm-dcd data
Bimag,Mimag=[],[] #Bimag,Mimag for initial magnetization curves
spec_data=pmag.get_dictitem(hys_data,'specimen',specimen,'T') # fish out all the LP-HYS data for this specimen
if len(spec_data)>0:
meths=spec_data[0]['method_codes'].split(':')
e=spec_data[0]['experiment']
HystRec['experiment']=spec_data[0]['experiment']
for rec in spec_data:
B.append(float(rec['meas_field_dc']))
M.append(float(rec['magn_moment']))
spec_data=pmag.get_dictitem(dcd_data,'specimen',specimen,'T') # fish out all the data for this specimen
if len(spec_data)>0:
HystRec['experiment']=HystRec['experiment']+':'+spec_data[0]['experiment']
irm_exp=spec_data[0]['experiment']
for rec in spec_data:
Bdcd.append(float(rec['treat_dc_field']))
Mdcd.append(float(rec['magn_moment']))
spec_data=pmag.get_dictitem(imag_data,'specimen',specimen,'T') # fish out all the data for this specimen
if len(spec_data)>0:
imag_exp=spec_data[0]['experiment']
for rec in spec_data:
Bimag.append(float(rec['meas_field_dc']))
Mimag.append(float(rec['magn_moment']))
#
# now plot the hysteresis curve
#
if len(B)>0:
hmeths=[]
for meth in meths: hmeths.append(meth)
hpars=pmagplotlib.plotHDD(HDD,B,M,e)
if verbose and PLT:pmagplotlib.drawFIGS(HDD)
#
if verbose:pmagplotlib.plotHPARS(HDD,hpars,'bs')
HystRec['hyst_mr_moment']=hpars['hysteresis_mr_moment']
HystRec['hyst_ms_moment']=hpars['hysteresis_ms_moment']
HystRec['hyst_bc']=hpars['hysteresis_bc']
HystRec['hyst_bcr']=hpars['hysteresis_bcr']
HystRec['susc_h']=hpars['hysteresis_xhf']
HystRec['experiments']=e
HystRec['software_packages']=version_num
if hpars["magic_method_codes"] not in hmeths:hmeths.append(hpars["magic_method_codes"])
methods=""
for meth in hmeths:
methods=methods+meth.strip()+":"
HystRec["method_codes"]=methods[:-1]
HystRec["citations"]="This study"
#
if len(Bdcd)>0:
rmeths=[]
for meth in meths: rmeths.append(meth)
if verbose and PLT:print('plotting IRM')
if irm_init==0:
HDD['irm']=5
pmagplotlib.plot_init(HDD['irm'],5,5)
irm_init=1
rpars=pmagplotlib.plotIRM(HDD['irm'],Bdcd,Mdcd,irm_exp)
HystRec['rem_mr_moment']=rpars['remanence_mr_moment']
HystRec['rem_bcr']=rpars['remanence_bcr']
HystRec['experiments']=specimen+':'+irm_exp
if rpars["magic_method_codes"] not in meths:meths.append(rpars["magic_method_codes"])
methods=""
for meth in rmeths:
methods=methods+meth.strip()+":"
HystRec["method_codes"]=HystRec['method_codes']+':'+methods[:-1]
HystRec["citations"]="This study"
else:
if irm_init:pmagplotlib.clearFIG(HDD['irm'])
if len(Bimag)>0:
if verbose and PLT:print('plotting initial magnetization curve')
# first normalize by Ms
Mnorm=[]
for m in Mimag: Mnorm.append(old_div(m,float(hpars['hysteresis_ms_moment'])))
if imag_init==0:
HDD['imag']=4
pmagplotlib.plot_init(HDD['imag'],5,5)
imag_init=1
pmagplotlib.plotIMAG(HDD['imag'],Bimag,Mnorm,imag_exp)
else:
if imag_init:pmagplotlib.clearFIG(HDD['imag'])
if len(list(HystRec.keys()))>0:HystRecs.append(HystRec)
#
files={}
if plots:
if pltspec:s=pltspec
files={}
for key in list(HDD.keys()):
files[key]=s+'_'+key+'.'+fmt
pmagplotlib.saveP(HDD,files)
if pltspec:sys.exit()
if verbose and PLT:
pmagplotlib.drawFIGS(HDD)
ans=input("S[a]ve plots, [s]pecimen name, [q]uit, <return> to continue\n ")
if ans=="a":
files={}
for key in list(HDD.keys()):
files[key]=specimen+'_'+key+'.'+fmt
pmagplotlib.saveP(HDD,files)
if ans=='':k+=1
if ans=="p":
del HystRecs[-1]
k-=1
if ans=='q':
print("Good bye")
sys.exit()
if ans=='s':
keepon=1
specimen=input('Enter desired specimen name (or first part there of): ')
while keepon==1:
try:
k =sids.index(specimen)
keepon=0
except:
tmplist=[]
for qq in range(len(sids)):
if specimen in sids[qq]:tmplist.append(sids[qq])
print(specimen," not found, but this was: ")
print(tmplist)
specimen=input('Select one or try again\n ')
k =sids.index(specimen)
else:
k+=1
if len(B)==0 and len(Bdcd)==0:
if verbose:print('skipping this one - no hysteresis data')
k+=1
if len(HystRecs)>0:
# go through prior_data, clean out prior results and save combined file as spec_file
SpecRecs,keys=[],list(HystRecs[0].keys())
if len(prior_data)>0:
prior_keys=list(prior_data[0].keys())
else: prior_keys=[]
for rec in prior_data:
for key in keys:
if key not in list(rec.keys()):rec[key]=""
if 'LP-HYS' not in rec['method_codes']:
SpecRecs.append(rec)
for rec in HystRecs:
for key in prior_keys:
if key not in list(rec.keys()):rec[key]=""
prior=pmag.get_dictitem(prior_data,'specimen',rec['specimen'],'T')
if len(prior)>0 and 'sample' in list(prior[0].keys()):
rec['sample']=prior[0]['sample'] # pull sample name from prior specimens table
SpecRecs.append(rec)
pmag.magic_write(spec_file,SpecRecs,"specimens")
if verbose:print("hysteresis parameters saved in ",spec_file)
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 main():
"""
NAME
make_magic_plots.py
DESCRIPTION
inspects magic directory for available 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
"""
dirlist = ['./']
dir_path = os.getcwd()
names = os.listdir(dir_path)
for n in names:
if 'Location' in n:
dirlist.append(n)
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)
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
for loc in dirlist:
print('working on: ', loc)
os.chdir(loc) # change working directories to each location
crd = 's'
if 'er_samples.txt' in filelist: # find coordinate systems
samps, file_type = pmag.magic_read(
'er_samples.txt') # read in data
Srecs = pmag.get_dictitem(
samps, 'sample_azimuth', '',
'F') # get all none blank sample orientations
if len(Srecs) > 0:
crd = 'g'
if 'magic_measurements.txt' in filelist: # start with measurement data
print('working on measurements data')
data, file_type = pmag.magic_read(
'magic_measurements.txt') # read in data
if loc == './':
data = pmag.get_dictitem(
data, 'er_location_name', '',
'T') # get all the blank location names from data file
# looking for zeq_magic possibilities
AFZrecs = pmag.get_dictitem(
data, 'magic_method_codes', 'LT-AF-Z',
'has') # get all none blank method codes
TZrecs = pmag.get_dictitem(
data, 'magic_method_codes', 'LT-T-Z',
'has') # get all none blank method codes
MZrecs = pmag.get_dictitem(
data, 'magic_method_codes', 'LT-M-Z',
'has') # get all none blank method codes
Drecs = pmag.get_dictitem(data, 'measurement_dec', '',
'F') # get all dec measurements
Irecs = pmag.get_dictitem(data, 'measurement_inc', '',
'F') # get all dec measurements
Mkeys = [
'measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass'
]
for key in Mkeys:
Mrecs = pmag.get_dictitem(data, key, '',
'F') # get intensity data
if len(Mrecs) > 0: break
if len(AFZrecs) > 0 or len(TZrecs) > 0 or len(MZrecs) > 0 and len(
Drecs) > 0 and len(Irecs) > 0 and len(
Mrecs) > 0: # potential for stepwise demag curves
print('zeq_magic.py -fsp pmag_specimens.txt -sav -fmt ' + fmt +
' -crd ' + crd)
os.system('zeq_magic.py -sav -fmt ' + fmt + ' -crd ' + crd)
# looking for thellier_magic possibilities
if len(
pmag.get_dictitem(data, 'magic_method_codes', 'LP-PI-TRM',
'has')) > 0:
print('thellier_magic.py -fsp pmag_specimens.txt -sav -fmt ' +
fmt)
os.system('thellier_magic.py -sav -fmt ' + fmt)
# looking for hysteresis possibilities
if len(
pmag.get_dictitem(data, 'magic_method_codes', 'LP-HYS',
'has')) > 0: # find hyst experiments
print('quick_hyst.py -sav -fmt ' + fmt)
os.system('quick_hyst.py -sav -fmt ' + fmt)
if 'pmag_results.txt' in filelist: # start with measurement data
data, file_type = pmag.magic_read(
'pmag_results.txt') # read in data
print('number of datapoints: ', len(data))
if loc == './':
data = pmag.get_dictitem(
data, 'er_location_names', ':', 'has'
) # get all the concatenated location names from data file
print('number of datapoints: ', len(data), loc)
print('working on pmag_results directions')
SiteDIs = pmag.get_dictitem(data, 'average_dec', "",
'F') # find decs
print('number of directions: ', len(SiteDIs))
SiteDIs = pmag.get_dictitem(SiteDIs, 'average_inc', "",
'F') # find decs and incs
print('number of directions: ', len(SiteDIs))
SiteDIs = pmag.get_dictitem(
SiteDIs, 'data_type', 'i',
'has') # only individual results - not poles
print('number of directions: ', len(SiteDIs))
SiteDIs_t = pmag.get_dictitem(SiteDIs, 'tilt_correction', '100',
'T') # tilt corrected coordinates
print('number of directions: ', len(SiteDIs))
if len(SiteDIs_t) > 0:
print('eqarea_magic.py -sav -crd t -fmt ' + fmt)
os.system('eqarea_magic.py -sav -crd t -fmt ' + fmt)
elif len(SiteDIs) > 0 and 'tilt_correction' not in SiteDIs[0].keys(
):
print('eqarea_magic.py -sav -fmt ' + fmt)
os.system('eqarea_magic.py -sav -fmt ' + fmt)
else:
SiteDIs_g = pmag.get_dictitem(SiteDIs, 'tilt_correction', '0',
'T') # geographic coordinates
if len(SiteDIs_g) > 0:
print('eqarea_magic.py -sav -crd g -fmt ' + fmt)
os.system('eqarea_magic.py -sav -crd g -fmt ' + fmt)
else:
SiteDIs_s = pmag.get_dictitem(SiteDIs, 'tilt_correction',
'-1',
'T') # sample coordinates
if len(SiteDIs_s) > 0:
print('eqarea_magic.py -sav -crd s -fmt ' + fmt)
os.system('eqarea_magic.py -sav -crd s -fmt ' + fmt)
else:
SiteDIs_x = pmag.get_dictitem(SiteDIs,
'tilt_correction', '',
'T') # no coordinates
if len(SiteDIs_x) > 0:
print('eqarea_magic.py -sav -fmt ' + fmt)
os.system('eqarea_magic.py -sav -fmt ' + fmt)
print('working on pmag_results VGP map')
VGPs = pmag.get_dictitem(SiteDIs, 'vgp_lat', "",
'F') # are there any VGPs?
if len(VGPs) > 0: # YES!
os.system(
'vgpmap_magic.py -prj moll -res c -sym ro 5 -sav -fmt png')
print('working on pmag_results intensities')
os.system(
'magic_select.py -f pmag_results.txt -key data_type i T -F tmp.txt'
)
os.system(
'magic_select.py -f tmp.txt -key average_int 0. has -F tmp1.txt'
)
os.system(
"grab_magic_key.py -f tmp1.txt -key average_int | awk '{print $1*1e6}' >tmp2.txt"
)
data, file_type = pmag.magic_read('tmp1.txt') # read in data
locations = pmag.get_dictkey(data, 'er_location_names', "")
histfile = 'LO:_' + locations[0] + '_intensities_histogram:_.' + fmt
os.system(
"histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F "
+ histfile)
print(
"histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F "
+ histfile)
os.system('rm tmp*.txt')
if 'rmag_hysteresis.txt' in filelist: # start with measurement data
print('working on rmag_hysteresis')
data, file_type = pmag.magic_read(
'rmag_hysteresis.txt') # read in data
if loc == './':
data = pmag.get_dictitem(
data, 'er_location_name', '',
'T') # get all the blank location names from data file
hdata = pmag.get_dictitem(data, 'hysteresis_bcr', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_mr_moment', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_ms_moment', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_bc', '',
'F') # there are data for a dayplot
if len(hdata) > 0:
print('dayplot_magic.py -sav -fmt ' + fmt)
os.system('dayplot_magic.py -sav -fmt ' + fmt)
#if 'er_sites.txt' in filelist: # start with measurement data
# print 'working on er_sites'
#os.system('basemap_magic.py -sav -fmt '+fmt)
if 'rmag_anisotropy.txt' in filelist: # do anisotropy plots if possible
print('working on rmag_anisotropy')
data, file_type = pmag.magic_read(
'rmag_anisotropy.txt') # read in data
if loc == './':
data = pmag.get_dictitem(
data, 'er_location_name', '',
'T') # get all the blank location names from data file
sdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction', '-1',
'T') # get specimen coordinates
gdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction', '0',
'T') # get specimen coordinates
tdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction',
'100', 'T') # get specimen coordinates
if len(sdata) > 3:
print('aniso_magic.py -x -B -crd s -sav -fmt ' + fmt)
os.system('aniso_magic.py -x -B -crd s -sav -fmt ' + fmt)
if len(gdata) > 3:
os.system('aniso_magic.py -x -B -crd g -sav -fmt ' + fmt)
if len(tdata) > 3:
os.system('aniso_magic.py -x -B -crd t -sav -fmt ' + fmt)
if loc != './':
os.chdir('..') # change working directories to each location
def main():
"""
NAME
scalc_magic.py
DESCRIPTION
calculates Sb from pmag_results files
SYNTAX
scalc_magic -h [command line options]
INPUT
takes magic formatted pmag_results table
pmag_result_name must start with "VGP: Site"
must have average_lat if spin axis is reference
OPTIONS
-h prints help message and quits
-f FILE: specify input results file, default is 'pmag_results.txt'
-c cutoff: specify VGP colatitude cutoff value
-k cutoff: specify kappa cutoff
-crd [s,g,t]: specify coordinate system, default is geographic
-v : use the VanDammme criterion
-a: use antipodes of reverse data: default is to use only normal
-C: use all data without regard to polarity
-r: use reverse data only
-p: do relative to principle axis
-b: do bootstrap confidence bounds
OUTPUT:
if option -b used: N, S_B, lower and upper bounds
otherwise: N, S_B, cutoff
"""
in_file = 'pmag_results.txt'
coord, kappa, cutoff = "0", 1., 90.
nb, anti, spin, v, boot = 1000, 0, 1, 0, 0
coord_key = 'tilt_correction'
rev = 0
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-f' in sys.argv:
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
if '-c' in sys.argv:
ind = sys.argv.index('-c')
cutoff = float(sys.argv[ind + 1])
if '-k' in sys.argv:
ind = sys.argv.index('-k')
kappa = float(sys.argv[ind + 1])
if '-crd' in sys.argv:
ind = sys.argv.index("-crd")
coord = sys.argv[ind + 1]
if coord == 's': coord = "-1"
if coord == 'g': coord = "0"
if coord == 't': coord = "100"
if '-a' in sys.argv: anti = 1
if '-C' in sys.argv: cutoff = 180. # no cutoff
if '-r' in sys.argv: rev = 1
if '-p' in sys.argv: spin = 0
if '-v' in sys.argv: v = 1
if '-b' in sys.argv: boot = 1
data, file_type = pmag.magic_read(in_file)
#
#
# find desired vgp lat,lon, kappa,N_site data:
#
#
#
A, Vgps, Pvgps = 180., [], []
VgpRecs = pmag.get_dictitem(data, 'vgp_lat', '',
'F') # get all non-blank vgp latitudes
VgpRecs = pmag.get_dictitem(VgpRecs, 'vgp_lon', '',
'F') # get all non-blank vgp longitudes
SiteRecs = pmag.get_dictitem(VgpRecs, 'data_type', 'i',
'T') # get VGPs (as opposed to averaged)
SiteRecs = pmag.get_dictitem(SiteRecs, coord_key, coord,
'T') # get right coordinate system
for rec in SiteRecs:
if anti == 1:
if 90. - abs(float(rec['vgp_lat'])) <= cutoff and float(
rec['average_k']) >= kappa:
if float(rec['vgp_lat']) < 0:
rec['vgp_lat'] = '%7.1f' % (-1 * float(rec['vgp_lat']))
rec['vgp_lon'] = '%7.1f' % (float(rec['vgp_lon']) - 180.)
Vgps.append(rec)
Pvgps.append([float(rec['vgp_lon']), float(rec['vgp_lat'])])
elif rev == 0: # exclude normals
if 90. - (float(rec['vgp_lat'])) <= cutoff and float(
rec['average_k']) >= kappa:
Vgps.append(rec)
Pvgps.append([float(rec['vgp_lon']), float(rec['vgp_lat'])])
else: # include normals
if 90. - abs(float(rec['vgp_lat'])) <= cutoff and float(
rec['average_k']) >= kappa:
if float(rec['vgp_lat']) < 0:
rec['vgp_lat'] = '%7.1f' % (-1 * float(rec['vgp_lat']))
rec['vgp_lon'] = '%7.1f' % (float(rec['vgp_lon']) - 180.)
Vgps.append(rec)
Pvgps.append(
[float(rec['vgp_lon']),
float(rec['vgp_lat'])])
if spin == 0: # do transformation to pole
ppars = pmag.doprinc(Pvgps)
for vgp in Vgps:
vlon, vlat = pmag.dotilt(float(vgp['vgp_lon']),
float(vgp['vgp_lat']),
ppars['dec'] - 180., 90. - ppars['inc'])
vgp['vgp_lon'] = vlon
vgp['vgp_lat'] = vlat
vgp['average_k'] = "0"
S_B = pmag.get_Sb(Vgps)
A = cutoff
if v == 1:
thetamax, A = 181., 180.
vVgps, cnt = [], 0
for vgp in Vgps:
vVgps.append(vgp) # make a copy of Vgps
while thetamax > A:
thetas = []
A = 1.8 * S_B + 5
cnt += 1
for vgp in vVgps:
thetas.append(90. - (float(vgp['vgp_lat'])))
thetas.sort()
thetamax = thetas[-1]
if thetamax < A: break
nVgps = []
for vgp in vVgps:
if 90. - (float(vgp['vgp_lat'])) < thetamax: nVgps.append(vgp)
vVgps = []
for vgp in nVgps:
vVgps.append(vgp)
S_B = pmag.get_Sb(vVgps)
Vgps = []
for vgp in vVgps:
Vgps.append(vgp) # make a new Vgp list
SBs = []
if boot == 1:
for i in range(nb): # now do bootstrap
BVgps = []
if i % 100 == 0: print(i, ' out of ', nb)
for k in range(len(Vgps)):
random.seed()
ind = random.randint(0, len(Vgps) - 1)
BVgps.append(Vgps[ind])
SBs.append(pmag.get_Sb(BVgps))
SBs.sort()
low = int(.025 * nb)
high = int(.975 * nb)
print(len(Vgps),
'%7.1f _ %7.1f ^ %7.1f %7.1f' % (S_B, SBs[low], SBs[high], A))
else:
print(len(Vgps), '%7.1f %7.1f ' % (S_B, A))
def main():
"""
NAME
aniso_magic.py
DESCRIPTION
plots anisotropy data with either bootstrap or hext ellipses
SYNTAX
aniso_magic.py [-h] [command line options]
OPTIONS
-h plots help message and quits
-usr USER: set the user name
-f AFILE, specify rmag_anisotropy formatted file for input
-F RFILE, specify rmag_results formatted file for output
-x Hext [1963] and bootstrap
-B DON'T do bootstrap, do Hext
-par Tauxe [1998] parametric bootstrap
-v plot bootstrap eigenvectors instead of ellipses
-sit plot by site instead of entire file
-crd [s,g,t] coordinate system, default is specimen (g=geographic, t=tilt corrected)
-P don't make any plots - just make rmag_results table
-sav don't make the rmag_results table - just save all the plots
-fmt [svg, jpg, eps] format for output images, pdf default
-gtc DEC INC dec,inc of pole to great circle [down(up) in green (cyan)
-d Vi DEC INC; Vi (1,2,3) to compare to direction DEC INC
-nb N; specifies the number of bootstraps - default is 1000
DEFAULTS
AFILE: rmag_anisotropy.txt
RFILE: rmag_results.txt
plot bootstrap ellipses of Constable & Tauxe [1987]
NOTES
minor axis: circles
major axis: triangles
principal axis: squares
directions are plotted on the lower hemisphere
for bootstrapped eigenvector components: Xs: blue, Ys: red, Zs: black
"""
#
dir_path = "."
version_num = pmag.get_version()
verbose = pmagplotlib.verbose
args = sys.argv
ipar, ihext, ivec, iboot, imeas, isite, iplot, vec = 0, 0, 0, 1, 1, 0, 1, 0
hpars, bpars, PDir = [], [], []
CS, crd = '-1', 's'
nb = 1000
fmt = 'pdf'
ResRecs = []
orlist = []
outfile, comp, Dir, gtcirc, PDir = 'rmag_results.txt', 0, [], 0, []
infile = 'rmag_anisotropy.txt'
if "-h" in args:
print(main.__doc__)
sys.exit()
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind + 1]
if '-nb' in args:
ind = args.index('-nb')
nb = int(args[ind + 1])
if '-usr' in args:
ind = args.index('-usr')
user = args[ind + 1]
else:
user = ""
if '-B' in args: iboot, ihext = 0, 1
if '-par' in args: ipar = 1
if '-x' in args: ihext = 1
if '-v' in args: ivec = 1
if '-sit' in args: isite = 1
if '-P' in args: iplot = 0
if '-f' in args:
ind = args.index('-f')
infile = args[ind + 1]
if '-F' in args:
ind = args.index('-F')
outfile = args[ind + 1]
if '-crd' in sys.argv:
ind = sys.argv.index('-crd')
crd = sys.argv[ind + 1]
if crd == 'g': CS = '0'
if crd == 't': CS = '100'
if '-fmt' in args:
ind = args.index('-fmt')
fmt = args[ind + 1]
if '-sav' in args:
plots = 1
verbose = 0
else:
plots = 0
if '-gtc' in args:
ind = args.index('-gtc')
d, i = float(args[ind + 1]), float(args[ind + 2])
PDir.append(d)
PDir.append(i)
if '-d' in args:
comp = 1
ind = args.index('-d')
vec = int(args[ind + 1]) - 1
Dir = [float(args[ind + 2]), float(args[ind + 3])]
#
# set up plots
#
if infile[0] != '/': infile = dir_path + '/' + infile
if outfile[0] != '/': outfile = dir_path + '/' + outfile
ANIS = {}
initcdf, inittcdf = 0, 0
ANIS['data'], ANIS['conf'] = 1, 2
if iboot == 1:
ANIS['tcdf'] = 3
if iplot == 1:
inittcdf = 1
pmagplotlib.plot_init(ANIS['tcdf'], 5, 5)
if comp == 1 and iplot == 1:
initcdf = 1
ANIS['vxcdf'], ANIS['vycdf'], ANIS['vzcdf'] = 4, 5, 6
pmagplotlib.plot_init(ANIS['vxcdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vycdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vzcdf'], 5, 5)
if iplot == 1:
pmagplotlib.plot_init(ANIS['conf'], 5, 5)
pmagplotlib.plot_init(ANIS['data'], 5, 5)
# read in the data
data, ifiletype = pmag.magic_read(infile)
for rec in data: # find all the orientation systems
if 'anisotropy_tilt_correction' not in rec.keys():
rec['anisotropy_tilt_correction'] = '-1'
if rec['anisotropy_tilt_correction'] not in orlist:
orlist.append(rec['anisotropy_tilt_correction'])
if CS not in orlist:
if len(orlist) > 0:
CS = orlist[0]
else:
CS = '-1'
if CS == '-1': crd = 's'
if CS == '0': crd = 'g'
if CS == '100': crd = 't'
if verbose:
print("desired coordinate system not available, using available: ",
crd)
if isite == 1:
sitelist = []
for rec in data:
if rec['er_site_name'] not in sitelist:
sitelist.append(rec['er_site_name'])
sitelist.sort()
plt = len(sitelist)
else:
plt = 1
k = 0
while k < plt:
site = ""
sdata, Ss = [], [] # list of S format data
Locs, Sites, Samples, Specimens, Cits = [], [], [], [], []
if isite == 0:
sdata = data
else:
site = sitelist[k]
for rec in data:
if rec['er_site_name'] == site: sdata.append(rec)
anitypes = []
csrecs = pmag.get_dictitem(sdata, 'anisotropy_tilt_correction', CS,
'T')
for rec in csrecs:
if rec['anisotropy_type'] not in anitypes:
anitypes.append(rec['anisotropy_type'])
if rec['er_location_name'] not in Locs:
Locs.append(rec['er_location_name'])
if rec['er_site_name'] not in Sites:
Sites.append(rec['er_site_name'])
if rec['er_sample_name'] not in Samples:
Samples.append(rec['er_sample_name'])
if rec['er_specimen_name'] not in Specimens:
Specimens.append(rec['er_specimen_name'])
if rec['er_citation_names'] not in Cits:
Cits.append(rec['er_citation_names'])
s = []
s.append(float(rec["anisotropy_s1"]))
s.append(float(rec["anisotropy_s2"]))
s.append(float(rec["anisotropy_s3"]))
s.append(float(rec["anisotropy_s4"]))
s.append(float(rec["anisotropy_s5"]))
s.append(float(rec["anisotropy_s6"]))
if s[0] <= 1.0: Ss.append(s) # protect against crap
#tau,Vdirs=pmag.doseigs(s)
ResRec = {}
ResRec['er_location_names'] = rec['er_location_name']
ResRec['er_citation_names'] = rec['er_citation_names']
ResRec['er_site_names'] = rec['er_site_name']
ResRec['er_sample_names'] = rec['er_sample_name']
ResRec['er_specimen_names'] = rec['er_specimen_name']
ResRec['rmag_result_name'] = rec['er_specimen_name'] + ":" + rec[
'anisotropy_type']
ResRec["er_analyst_mail_names"] = user
ResRec["tilt_correction"] = CS
ResRec["anisotropy_type"] = rec['anisotropy_type']
if "anisotropy_n" not in rec.keys(): rec["anisotropy_n"] = "6"
if "anisotropy_sigma" not in rec.keys():
rec["anisotropy_sigma"] = "0"
fpars = pmag.dohext(
int(rec["anisotropy_n"]) - 6, float(rec["anisotropy_sigma"]),
s)
ResRec["anisotropy_v1_dec"] = '%7.1f' % (fpars['v1_dec'])
ResRec["anisotropy_v2_dec"] = '%7.1f' % (fpars['v2_dec'])
ResRec["anisotropy_v3_dec"] = '%7.1f' % (fpars['v3_dec'])
ResRec["anisotropy_v1_inc"] = '%7.1f' % (fpars['v1_inc'])
ResRec["anisotropy_v2_inc"] = '%7.1f' % (fpars['v2_inc'])
ResRec["anisotropy_v3_inc"] = '%7.1f' % (fpars['v3_inc'])
ResRec["anisotropy_t1"] = '%10.8f' % (fpars['t1'])
ResRec["anisotropy_t2"] = '%10.8f' % (fpars['t2'])
ResRec["anisotropy_t3"] = '%10.8f' % (fpars['t3'])
ResRec["anisotropy_ftest"] = '%10.3f' % (fpars['F'])
ResRec["anisotropy_ftest12"] = '%10.3f' % (fpars['F12'])
ResRec["anisotropy_ftest23"] = '%10.3f' % (fpars['F23'])
ResRec["result_description"] = 'F_crit: ' + fpars[
'F_crit'] + '; F12,F23_crit: ' + fpars['F12_crit']
ResRec['anisotropy_type'] = pmag.makelist(anitypes)
ResRecs.append(ResRec)
if len(Ss) > 1:
if pmagplotlib.isServer:
title = "LO:_" + ResRec[
'er_location_names'] + '_SI:_' + site + '_SA:__SP:__CO:_' + crd
else:
title = ResRec['er_location_names']
if site:
title += "_{}".format(site)
title += '_{}'.format(crd)
ResRec['er_location_names'] = pmag.makelist(Locs)
bpars, hpars = pmagplotlib.plotANIS(ANIS, Ss, iboot, ihext, ivec,
ipar, title, iplot, comp, vec,
Dir, nb)
if len(PDir) > 0:
pmagplotlib.plotC(ANIS['data'], PDir, 90., 'g')
pmagplotlib.plotC(ANIS['conf'], PDir, 90., 'g')
if verbose and plots == 0: pmagplotlib.drawFIGS(ANIS)
ResRec['er_location_names'] = pmag.makelist(Locs)
if plots == 1:
save(ANIS, fmt, title)
ResRec = {}
ResRec['er_citation_names'] = pmag.makelist(Cits)
ResRec['er_location_names'] = pmag.makelist(Locs)
ResRec['er_site_names'] = pmag.makelist(Sites)
ResRec['er_sample_names'] = pmag.makelist(Samples)
ResRec['er_specimen_names'] = pmag.makelist(Specimens)
ResRec['rmag_result_name'] = pmag.makelist(
Sites) + ":" + pmag.makelist(anitypes)
ResRec['anisotropy_type'] = pmag.makelist(anitypes)
ResRec["er_analyst_mail_names"] = user
ResRec["tilt_correction"] = CS
if isite == "0":
ResRec[
'result_description'] = "Study average using coordinate system: " + CS
if isite == "1":
ResRec[
'result_description'] = "Site average using coordinate system: " + CS
if hpars != [] and ihext == 1:
HextRec = {}
for key in ResRec.keys():
HextRec[key] = ResRec[key] # copy over stuff
HextRec["anisotropy_v1_dec"] = '%7.1f' % (hpars["v1_dec"])
HextRec["anisotropy_v2_dec"] = '%7.1f' % (hpars["v2_dec"])
HextRec["anisotropy_v3_dec"] = '%7.1f' % (hpars["v3_dec"])
HextRec["anisotropy_v1_inc"] = '%7.1f' % (hpars["v1_inc"])
HextRec["anisotropy_v2_inc"] = '%7.1f' % (hpars["v2_inc"])
HextRec["anisotropy_v3_inc"] = '%7.1f' % (hpars["v3_inc"])
HextRec["anisotropy_t1"] = '%10.8f' % (hpars["t1"])
HextRec["anisotropy_t2"] = '%10.8f' % (hpars["t2"])
HextRec["anisotropy_t3"] = '%10.8f' % (hpars["t3"])
HextRec["anisotropy_hext_F"] = '%7.1f ' % (hpars["F"])
HextRec["anisotropy_hext_F12"] = '%7.1f ' % (hpars["F12"])
HextRec["anisotropy_hext_F23"] = '%7.1f ' % (hpars["F23"])
HextRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (hpars["v2_dec"])
HextRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (hpars["v2_inc"])
HextRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars["e13"])
HextRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars["v3_dec"])
HextRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars["v3_inc"])
HextRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (hpars["v1_dec"])
HextRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (hpars["v1_inc"])
HextRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars["e23"])
HextRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars["v3_dec"])
HextRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars["v3_inc"])
HextRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars["e12"])
HextRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (hpars["v1_dec"])
HextRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (hpars["v1_inc"])
HextRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars["e23"])
HextRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars["v2_dec"])
HextRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars["v2_inc"])
HextRec["magic_method_codes"] = 'LP-AN:AE-H'
if verbose:
print("Hext Statistics: ")
print(
" tau_i, V_i_D, V_i_I, V_i_zeta, V_i_zeta_D, V_i_zeta_I, V_i_eta, V_i_eta_D, V_i_eta_I"
)
print(HextRec["anisotropy_t1"],
HextRec["anisotropy_v1_dec"],
HextRec["anisotropy_v1_inc"],
HextRec["anisotropy_v1_eta_semi_angle"],
HextRec["anisotropy_v1_eta_dec"],
HextRec["anisotropy_v1_eta_inc"],
HextRec["anisotropy_v1_zeta_semi_angle"],
HextRec["anisotropy_v1_zeta_dec"],
HextRec["anisotropy_v1_zeta_inc"])
print(HextRec["anisotropy_t2"],
HextRec["anisotropy_v2_dec"],
HextRec["anisotropy_v2_inc"],
HextRec["anisotropy_v2_eta_semi_angle"],
HextRec["anisotropy_v2_eta_dec"],
HextRec["anisotropy_v2_eta_inc"],
HextRec["anisotropy_v2_zeta_semi_angle"],
HextRec["anisotropy_v2_zeta_dec"],
HextRec["anisotropy_v2_zeta_inc"])
print(HextRec["anisotropy_t3"],
HextRec["anisotropy_v3_dec"],
HextRec["anisotropy_v3_inc"],
HextRec["anisotropy_v3_eta_semi_angle"],
HextRec["anisotropy_v3_eta_dec"],
HextRec["anisotropy_v3_eta_inc"],
HextRec["anisotropy_v3_zeta_semi_angle"],
HextRec["anisotropy_v3_zeta_dec"],
HextRec["anisotropy_v3_zeta_inc"])
HextRec['magic_software_packages'] = version_num
ResRecs.append(HextRec)
if bpars != []:
BootRec = {}
for key in ResRec.keys():
BootRec[key] = ResRec[key] # copy over stuff
BootRec["anisotropy_v1_dec"] = '%7.1f' % (bpars["v1_dec"])
BootRec["anisotropy_v2_dec"] = '%7.1f' % (bpars["v2_dec"])
BootRec["anisotropy_v3_dec"] = '%7.1f' % (bpars["v3_dec"])
BootRec["anisotropy_v1_inc"] = '%7.1f' % (bpars["v1_inc"])
BootRec["anisotropy_v2_inc"] = '%7.1f' % (bpars["v2_inc"])
BootRec["anisotropy_v3_inc"] = '%7.1f' % (bpars["v3_inc"])
BootRec["anisotropy_t1"] = '%10.8f' % (bpars["t1"])
BootRec["anisotropy_t2"] = '%10.8f' % (bpars["t2"])
BootRec["anisotropy_t3"] = '%10.8f' % (bpars["t3"])
BootRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
bpars["v1_eta_inc"])
BootRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
bpars["v1_eta_dec"])
BootRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
bpars["v1_eta"])
BootRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
bpars["v1_zeta_inc"])
BootRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
bpars["v1_zeta_dec"])
BootRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
bpars["v1_zeta"])
BootRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
bpars["v2_eta_inc"])
BootRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
bpars["v2_eta_dec"])
BootRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
bpars["v2_eta"])
BootRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
bpars["v2_zeta_inc"])
BootRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
bpars["v2_zeta_dec"])
BootRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
bpars["v2_zeta"])
BootRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
bpars["v3_eta_inc"])
BootRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
bpars["v3_eta_dec"])
BootRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
bpars["v3_eta"])
BootRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
bpars["v3_zeta_inc"])
BootRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
bpars["v3_zeta_dec"])
BootRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
bpars["v3_zeta"])
BootRec["anisotropy_hext_F"] = ''
BootRec["anisotropy_hext_F12"] = ''
BootRec["anisotropy_hext_F23"] = ''
BootRec[
"magic_method_codes"] = 'LP-AN:AE-H:AE-BS' # regular bootstrap
if ipar == 1:
BootRec[
"magic_method_codes"] = 'LP-AN:AE-H:AE-BS-P' # parametric bootstrap
if verbose:
print("Boostrap Statistics: ")
print(
" tau_i, V_i_D, V_i_I, V_i_zeta, V_i_zeta_D, V_i_zeta_I, V_i_eta, V_i_eta_D, V_i_eta_I"
)
print(BootRec["anisotropy_t1"],
BootRec["anisotropy_v1_dec"],
BootRec["anisotropy_v1_inc"],
BootRec["anisotropy_v1_eta_semi_angle"],
BootRec["anisotropy_v1_eta_dec"],
BootRec["anisotropy_v1_eta_inc"],
BootRec["anisotropy_v1_zeta_semi_angle"],
BootRec["anisotropy_v1_zeta_dec"],
BootRec["anisotropy_v1_zeta_inc"])
print(BootRec["anisotropy_t2"],
BootRec["anisotropy_v2_dec"],
BootRec["anisotropy_v2_inc"],
BootRec["anisotropy_v2_eta_semi_angle"],
BootRec["anisotropy_v2_eta_dec"],
BootRec["anisotropy_v2_eta_inc"],
BootRec["anisotropy_v2_zeta_semi_angle"],
BootRec["anisotropy_v2_zeta_dec"],
BootRec["anisotropy_v2_zeta_inc"])
print(BootRec["anisotropy_t3"],
BootRec["anisotropy_v3_dec"],
BootRec["anisotropy_v3_inc"],
BootRec["anisotropy_v3_eta_semi_angle"],
BootRec["anisotropy_v3_eta_dec"],
BootRec["anisotropy_v3_eta_inc"],
BootRec["anisotropy_v3_zeta_semi_angle"],
BootRec["anisotropy_v3_zeta_dec"],
BootRec["anisotropy_v3_zeta_inc"])
BootRec['magic_software_packages'] = version_num
ResRecs.append(BootRec)
k += 1
goon = 1
while goon == 1 and iplot == 1 and verbose:
if iboot == 1: print("compare with [d]irection ")
print(
" plot [g]reat circle, change [c]oord. system, change [e]llipse calculation, s[a]ve plots, [q]uit "
)
if isite == 1:
print(" [p]revious, [s]ite, [q]uit, <return> for next ")
ans = input("")
if ans == "q":
sys.exit()
if ans == "e":
iboot, ipar, ihext, ivec = 1, 0, 0, 0
e = input("Do Hext Statistics 1/[0]: ")
if e == "1": ihext = 1
e = input("Suppress bootstrap 1/[0]: ")
if e == "1": iboot = 0
if iboot == 1:
e = input("Parametric bootstrap 1/[0]: ")
if e == "1": ipar = 1
e = input("Plot bootstrap eigenvectors: 1/[0]: ")
if e == "1": ivec = 1
if iplot == 1:
if inittcdf == 0:
ANIS['tcdf'] = 3
pmagplotlib.plot_init(ANIS['tcdf'], 5, 5)
inittcdf = 1
bpars, hpars = pmagplotlib.plotANIS(
ANIS, Ss, iboot, ihext, ivec, ipar, title, iplot, comp,
vec, Dir, nb)
if verbose and plots == 0: pmagplotlib.drawFIGS(ANIS)
if ans == "c":
print("Current Coordinate system is: ")
if CS == '-1': print(" Specimen")
if CS == '0': print(" Geographic")
if CS == '100': print(" Tilt corrected")
key = input(
" Enter desired coordinate system: [s]pecimen, [g]eographic, [t]ilt corrected "
)
if key == 's': CS = '-1'
if key == 'g': CS = '0'
if key == 't': CS = '100'
if CS not in orlist:
if len(orlist) > 0:
CS = orlist[0]
else:
CS = '-1'
if CS == '-1': crd = 's'
if CS == '0': crd = 'g'
if CS == '100': crd = 't'
print(
"desired coordinate system not available, using available: ",
crd)
k -= 1
goon = 0
if ans == "":
if isite == 1:
goon = 0
else:
print("Good bye ")
sys.exit()
if ans == 'd':
if initcdf == 0:
initcdf = 1
ANIS['vxcdf'], ANIS['vycdf'], ANIS['vzcdf'] = 4, 5, 6
pmagplotlib.plot_init(ANIS['vxcdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vycdf'], 5, 5)
pmagplotlib.plot_init(ANIS['vzcdf'], 5, 5)
Dir, comp = [], 1
print("""
Input: Vi D I to compare eigenvector Vi with direction D/I
where Vi=1: principal
Vi=2: major
Vi=3: minor
D= declination of comparison direction
I= inclination of comparison direction""")
con = 1
while con == 1:
try:
vdi = input("Vi D I: ").split()
vec = int(vdi[0]) - 1
Dir = [float(vdi[1]), float(vdi[2])]
con = 0
except IndexError:
print(" Incorrect entry, try again ")
bpars, hpars = pmagplotlib.plotANIS(
ANIS, Ss, iboot, ihext, ivec, ipar, title, iplot, comp,
vec, Dir, nb)
Dir, comp = [], 0
if ans == 'g':
con, cnt = 1, 0
while con == 1:
try:
print(
" Input: input pole to great circle ( D I) to plot a great circle: "
)
di = input(" D I: ").split()
PDir.append(float(di[0]))
PDir.append(float(di[1]))
con = 0
except:
cnt += 1
if cnt < 10:
print(
" enter the dec and inc of the pole on one line "
)
else:
print(
"ummm - you are doing something wrong - i give up"
)
sys.exit()
pmagplotlib.plotC(ANIS['data'], PDir, 90., 'g')
pmagplotlib.plotC(ANIS['conf'], PDir, 90., 'g')
if verbose and plots == 0: pmagplotlib.drawFIGS(ANIS)
if ans == "p":
k -= 2
goon = 0
if ans == "q":
k = plt
goon = 0
if ans == "s":
keepon = 1
site = input(" print site or part of site desired: ")
while keepon == 1:
try:
k = sitelist.index(site)
keepon = 0
except:
tmplist = []
for qq in range(len(sitelist)):
if site in sitelist[qq]:
tmplist.append(sitelist[qq])
print(site, " not found, but this was: ")
print(tmplist)
site = input('Select one or try again\n ')
k = sitelist.index(site)
goon, ans = 0, ""
if ans == "a":
locs = pmag.makelist(Locs)
if pmagplotlib.isServer: # use server plot naming convention
title = "LO:_" + locs + '_SI:__' + '_SA:__SP:__CO:_' + crd
else: # use more readable plot naming convention
title = "{}_{}".format(locs, crd)
save(ANIS, fmt, title)
goon = 0
else:
if verbose: print('skipping plot - not enough data points')
k += 1
# put rmag_results stuff here
if len(ResRecs) > 0:
ResOut, keylist = pmag.fillkeys(ResRecs)
pmag.magic_write(outfile, ResOut, 'rmag_results')
if verbose:
print(" Good bye ")
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.
SYNTAX
zeq_magic.py [command line options]
OPTIONS
-h prints help message and quits
-f MEASFILE: sets magic_measurements format input file, default: magic_measurements.txt
-fsp SPECFILE: sets pmag_specimens format file with prior interpreations, default: zeq_specimens.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
-fsa SAMPFILE: sets er_samples format file with orientation information, default: er_samples.txt
-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
plots,coord=0,'s'
noorient=0
version_num=pmag.get_version()
verbose=pmagplotlib.verbose
beg_pca,end_pca,direction_type="","",'l'
calculation_type,fmt="","svg"
user,spec_keys,locname="",[],''
plot_file=""
sfile=""
plot_file=""
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()
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
else:
dir_path='.'
inspec=dir_path+'/'+'zeq_specimens.txt'
meas_file,geo,tilt,ask,samp_file=dir_path+'/magic_measurements.txt',0,0,0,dir_path+'/er_samples.txt'
if '-f' in sys.argv:
ind=sys.argv.index('-f')
meas_file=dir_path+'/'+sys.argv[ind+1]
if '-fsp' in sys.argv:
ind=sys.argv.index('-fsp')
inspec=dir_path+'/'+sys.argv[ind+1]
if '-fsa' in sys.argv:
ind=sys.argv.index('-fsa')
samp_file=dir_path+'/'+sys.argv[ind+1]
sfile='ok'
if '-crd' in sys.argv:
ind=sys.argv.index('-crd')
coord=sys.argv[ind+1]
if coord=='g' or coord=='t':
samp_data,file_type=pmag.magic_read(samp_file)
if file_type=='er_samples':sfile='ok'
geo=1
if coord=='t':tilt=1
if '-spc' in sys.argv:
ind=sys.argv.index('-spc')
specimen=sys.argv[ind+1]
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 '-Fp' in sys.argv:
ind=sys.argv.index('-Fp')
plot_file=dir_path+'/'+sys.argv[ind+1]
if '-A' in sys.argv: doave=0
if '-sav' in sys.argv:
plots=1
verbose=0
if '-fmt' in sys.argv:
ind=sys.argv.index('-fmt')
fmt=sys.argv[ind+1]
#
first_save=1
meas_data,file_type=pmag.magic_read(meas_file)
changeM,changeS=0,0 # check if data or interpretations have changed
if file_type != 'magic_measurements':
print file_type
print file_type,"This is not a valid magic_measurements file "
sys.exit()
for rec in meas_data:
if "magic_method_codes" not in rec.keys(): rec["magic_method_codes"]=""
methods=""
tmp=rec["magic_method_codes"].replace(" ","").split(":")
for meth in tmp:
methods=methods+meth+":"
rec["magic_method_codes"]=methods[:-1] # get rid of annoying spaces in Anthony's export files
if "magic_instrument_codes" not in rec.keys() :rec["magic_instrument_codes"]=""
PriorSpecs=[]
PriorRecs,file_type=pmag.magic_read(inspec)
if len(PriorRecs)==0:
if verbose:print "starting new file ",inspec
for Rec in PriorRecs:
if 'magic_software_packages' not in Rec.keys():Rec['magic_software_packages']=""
if Rec['er_specimen_name'] not in PriorSpecs:
if 'specimen_comp_name' not in Rec.keys():Rec['specimen_comp_name']="A"
PriorSpecs.append(Rec['er_specimen_name'])
else:
if 'specimen_comp_name' not in Rec.keys():Rec['specimen_comp_name']="A"
if "magic_method_codes" in Rec.keys():
methods=[]
tmp=Rec["magic_method_codes"].replace(" ","").split(":")
for meth in tmp:
methods.append(meth)
if 'DE-FM' in methods:
Rec['calculation_type']='DE-FM' # this won't be imported but helps
if 'DE-BFL' in methods:
Rec['calculation_type']='DE-BFL'
if 'DE-BFL-A' in methods:
Rec['calculation_type']='DE-BFL-A'
if 'DE-BFL-O' in methods:
Rec['calculation_type']='DE-BFL-O'
if 'DE-BFP' in methods:
Rec['calculation_type']='DE-BFP'
else:
Rec['calculation_type']='DE-BFL' # default is to assume a best-fit line
#
# get list of unique specimen names
#
sids=pmag.get_specs(meas_data)
#
# set up plots, angle sets X axis to horizontal, direction_type 'l' is best-fit line
# direction_type='p' is great circle
#
#
# draw plots for sample s - default is just to step through zijderveld diagrams
#
#
# 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'],5,5)
pmagplotlib.plot_init(ZED['zijd'],6,5)
pmagplotlib.plot_init(ZED['demag'],5,5)
save_pca=0
if specimen=="":
k = 0
else:
k=sids.index(specimen)
angle,direction_type="",""
setangle=0
CurrRecs=[]
while k < len(sids):
CurrRecs=[]
if setangle==0:angle=""
method_codes,inst_code=[],""
s=sids[k]
PmagSpecRec={}
PmagSpecRec["er_analyst_mail_names"]=user
PmagSpecRec['magic_software_packages']=version_num
PmagSpecRec['specimen_description']=""
PmagSpecRec['magic_method_codes']=""
if verbose and s!="":print s, k , 'out of ',len(sids)
#
# collect info for the PmagSpecRec dictionary
#
s_meas=pmag.get_dictitem(meas_data,'er_specimen_name',s,'T') # fish out this specimen
s_meas=pmag.get_dictitem(s_meas,'magic_method_codes','Z','has') # fish out zero field steps
if len(s_meas)>0:
for rec in s_meas: # fix up a few things for the output record
PmagSpecRec["magic_instrument_codes"]=rec["magic_instrument_codes"] # copy over instruments
PmagSpecRec["er_citation_names"]="This study"
PmagSpecRec["er_specimen_name"]=s
PmagSpecRec["er_sample_name"]=rec["er_sample_name"]
PmagSpecRec["er_site_name"]=rec["er_site_name"]
PmagSpecRec["er_location_name"]=rec["er_location_name"]
locname=rec['er_location_name']
if 'er_expedition_name' in rec.keys(): PmagSpecRec["er_expedition_name"]=rec["er_expedition_name"]
PmagSpecRec["magic_method_codes"]=rec["magic_method_codes"]
if "magic_experiment_name" not in rec.keys():
PmagSpecRec["magic_experiment_names"]=""
else:
PmagSpecRec["magic_experiment_names"]=rec["magic_experiment_name"]
break
#
# find the data from the meas_data file for this specimen
#
data,units=pmag.find_dmag_rec(s,meas_data)
PmagSpecRec["measurement_step_unit"]= units
u=units.split(":")
if "T" in units:PmagSpecRec["magic_method_codes"]=PmagSpecRec["magic_method_codes"]+":LP-DIR-AF"
if "K" in units:PmagSpecRec["magic_method_codes"]=PmagSpecRec["magic_method_codes"]+":LP-DIR-T"
if "J" in units:PmagSpecRec["magic_method_codes"]=PmagSpecRec["magic_method_codes"]+":LP-DIR-M"
#
# find prior interpretation
#
if len(CurrRecs)==0: # check if already in
beg_pca,end_pca="",""
calculation_type=""
if inspec !="":
if verbose: print " looking up previous interpretations..."
precs=pmag.get_dictitem(PriorRecs,'er_specimen_name',s,'T') # get all the prior recs with this specimen name
precs=pmag.get_dictitem(precs,'magic_method_codes','LP-DIR','has') # get the directional data
PriorRecs=pmag.get_dictitem(PriorRecs,'er_specimen_name',s,'F') # take them all out of prior recs
# get the ones that meet the current coordinate system
for prec in precs:
if 'specimen_tilt_correction' not in prec.keys() or prec['specimen_tilt_correction']=='-1':
crd='s'
elif prec['specimen_tilt_correction']=='0':
crd='g'
elif prec['specimen_tilt_correction']=='100':
crd='t'
else:
crd='?'
CurrRec={}
for key in prec.keys():CurrRec[key]=prec[key]
CurrRecs.append(CurrRec) # put in CurrRecs
method_codes= CurrRec["magic_method_codes"].replace(" ","").split(':')
calculation_type='DE-BFL'
if 'DE-FM' in method_codes: calculation_type='DE-FM'
if 'DE-BFP' in method_codes: calculation_type='DE-BFP'
if 'DE-BFL-A' in method_codes: calculation_type='DE-BFL-A'
if 'specimen_dang' not in CurrRec.keys():
if verbose:print 'Run mk_redo.py and zeq_magic_redo.py to get the specimen_dang values'
CurrRec['specimen_dang']=-1
if calculation_type!='DE-FM' and crd==coord: # not a fisher mean
if verbose:print "Specimen N MAD DANG start end dec inc type component coordinates"
if units=='K':
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_mad"]),float(CurrRec["specimen_dang"]),float(CurrRec["measurement_step_min"])-273,float(CurrRec["measurement_step_max"])-273,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
elif units=='T':
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_mad"]),float(CurrRec["specimen_dang"]),float(CurrRec["measurement_step_min"])*1e3,float(CurrRec["measurement_step_max"])*1e3,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
elif 'T' in units and 'K' in units:
if float(CurrRec['measurement_step_min'])<1.0 :
min=float(CurrRec['measurement_step_min'])*1e3
else:
min=float(CurrRec['measurement_step_min'])-273
if float(CurrRec['measurement_step_max'])<1.0 :
max=float(CurrRec['measurement_step_max'])*1e3
else:
max=float(CurrRec['measurement_step_max'])-273
if verbose:print '%s %i %7.1f %i %i %7.1f %7.1f %7.1f, %s %s\n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_mad"]),float(CurrRec['specimen_dang']),min,max,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,crd)
elif 'J' in units:
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_mad"]),float(CurrRec['specimen_dang']),float(CurrRec["measurement_step_min"]),float(CurrRec["measurement_step_max"]),float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
elif calculation_type=='DE-FM' and crd==coord: # fisher mean
if verbose:print "Specimen a95 DANG start end dec inc type component coordinates"
if units=='K':
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_alpha95"]),float(CurrRec["measurement_step_min"])-273,float(CurrRec["measurement_step_max"])-273,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
elif units=='T':
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_alpha95"]),float(CurrRec["measurement_step_min"])*1e3,float(CurrRec["measurement_step_max"])*1e3,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
elif 'T' in units and 'K' in units:
if float(CurrRec['measurement_step_min'])<1.0 :
min=float(CurrRec['measurement_step_min'])*1e3
else:
min=float(CurrRec['measurement_step_min'])-273
if float(CurrRec['measurement_step_max'])<1.0 :
max=float(CurrRec['measurement_step_max'])*1e3
else:
max=float(CurrRec['measurement_step_max'])-273
if verbose:print '%s %i %7.1f %i %i %7.1f %7.1f %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_alpha95"]),min,max,float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,crd)
elif 'J' in units:
if verbose:print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %s %s %s \n' % (CurrRec["er_specimen_name"],int(CurrRec["specimen_n"]),float(CurrRec["specimen_mad"]),float(CurrRec["measurement_step_min"]),float(CurrRec["measurement_step_max"]),float(CurrRec["specimen_dec"]),float(CurrRec["specimen_inc"]),calculation_type,CurrRec['specimen_comp_name'],crd)
if len(CurrRecs)==0:beg_pca,end_pca="",""
datablock=data
noskip=1
if len(datablock) <3:
noskip=0
if backup==0:
k+=1
else:
k-=1
if len(CurrRecs)>0:
for rec in CurrRecs:
PriorRecs.append(rec)
CurrRecs=[]
else:
backup=0
if noskip:
#
# find replicate measurements at given treatment step and average them
#
# step_meth,avedata=pmag.vspec(data)
# if len(avedata) != len(datablock):
# if doave==1:
# method_codes.append("DE-VM")
# datablock=avedata
# #
# do geo or stratigraphic correction now
#
if geo==1:
#
# find top priority orientation method
orient,az_type=pmag.get_orient(samp_data,PmagSpecRec["er_sample_name"])
if az_type=='SO-NO':
if verbose: print "no orientation data for ",s
orient["sample_azimuth"]=0
orient["sample_dip"]=0
noorient=1
method_codes.append("SO-NO")
orient["sample_azimuth"]=0
orient["sample_dip"]=0
orient["sample_bed_dip_azimuth"]=0
orient["sample_bed_dip"]=0
noorient=1
method_codes.append("SO-NO")
else:
noorient=0
#
# if stratigraphic selected, get stratigraphic correction
#
tiltblock,geoblock=[],[]
for rec in datablock:
d_geo,i_geo=pmag.dogeo(rec[1],rec[2],float(orient["sample_azimuth"]),float(orient["sample_dip"]))
geoblock.append([rec[0],d_geo,i_geo,rec[3],rec[4],rec[5],rec[6]])
if tilt==1 and "sample_bed_dip" in orient.keys() and float(orient['sample_bed_dip'])!=0:
d_tilt,i_tilt=pmag.dotilt(d_geo,i_geo,float(orient["sample_bed_dip_direction"]),float(orient["sample_bed_dip"]))
tiltblock.append([rec[0],d_tilt,i_tilt,rec[3],rec[4],rec[5],rec[6]])
if tilt==1: plotblock=tiltblock
if geo==1 and tilt==0:plotblock=geoblock
if geo==0 and tilt==0: plotblock=datablock
#
# set the end pca point to last point if not set
if e==0 or e>len(plotblock)-1: e=len(plotblock)-1
if angle=="": angle=plotblock[0][1] # rotate to NRM declination
title=s+'_s'
if geo==1 and tilt==0 and noorient!=1:title=s+'_g'
if tilt==1 and noorient!=1:title=s+'_t'
pmagplotlib.plotZED(ZED,plotblock,angle,title,units)
if verbose:pmagplotlib.drawFIGS(ZED)
if len(CurrRecs)!=0:
for prec in CurrRecs:
if 'calculation_type' not in prec.keys():
calculation_type=''
else:
calculation_type=prec["calculation_type"]
direction_type=prec["specimen_direction_type"]
if calculation_type !="":
beg_pca,end_pca="",""
for j in range(len(datablock)):
if data[j][0]==float(prec["measurement_step_min"]):beg_pca=j
if data[j][0]==float(prec["measurement_step_max"]):end_pca=j
if beg_pca=="" or end_pca=="":
if verbose:
print "something wrong with prior interpretation "
break
if calculation_type!="":
if beg_pca=="":beg_pca=0
if end_pca=="":end_pca=len(plotblock)-1
if geo==1 and tilt==0:
mpars=pmag.domean(geoblock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
pmagplotlib.plotDir(ZED,mpars,geoblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
if geo==1 and tilt==1:
mpars=pmag.domean(tiltblock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
pmagplotlib.plotDir(ZED,mpars,tiltblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
if geo==0 and tilt==0:
mpars=pmag.domean(datablock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
pmagplotlib.plotDir(ZED,mpars,plotblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
#
# print out data for this sample to screen
#
recnum=0
for plotrec in plotblock:
if units=='T' and verbose: 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" and verbose: 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" and verbose: 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. and verbose: 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. and verbose: 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
if specimen!="":
if plot_file=="":
basename=locname+'_'+s
else:
basename=plot_file
files={}
for key in ZED.keys():
files[key]=basename+'_'+key+'.'+fmt
pmagplotlib.saveP(ZED,files)
sys.exit()
else: # interactive
if plots==0:
ans='b'
k+=1
changeS=0
while ans != "":
if len(CurrRecs)==0:
print """
g/b: indicates good/bad measurement. "bad" measurements excluded from calculation
set s[a]ve plot, [b]ounds for pca and calculate, [p]revious, [s]pecimen,
change [h]orizontal projection angle, change [c]oordinate systems,
[e]dit data, [q]uit:
"""
else:
print """
g/b: indicates good/bad measurement. "bad" measurements excluded from calculation
set s[a]ve plot, [b]ounds for pca and calculate, [p]revious, [s]pecimen,
change [h]orizontal projection angle, change [c]oordinate systems,
[d]elete current interpretation(s), [e]dit data, [q]uit:
"""
ans=raw_input('<Return> for next specimen \n')
setangle=0
if ans=='d': # delete this interpretation
CurrRecs=[]
k-=1 # replot same specimen
ans=""
changeS=1
if ans=='q':
if changeM==1:
ans=raw_input('Save changes to magic_measurements.txt? y/[n] ')
if ans=='y':
pmag.magic_write(meas_file,meas_data,'magic_measurements')
print "Good bye"
sys.exit()
if ans=='a':
if plot_file=="":
basename=locname+'_'+s+'_'
else:
basename=plot_file
files={}
for key in ZED.keys():
files[key]=basename+'_'+coord+'_'+key+'.'+fmt
pmagplotlib.saveP(ZED,files)
ans=""
if ans=='p':
k-=2
ans=""
backup=1
if ans=='c':
k-=1 # replot same block
if tilt==0 and geo ==1:print "You are currently viewing geographic coordinates "
if tilt==1 and geo ==1:print "You are currently viewing stratigraphic coordinates "
if tilt==0 and geo ==0: print "You are currently viewing sample coordinates "
print "\n Which coordinate system do you wish to view? "
coord=raw_input(" <Return> specimen, [g] geographic, [t] tilt corrected ")
if coord=="g":geo,tilt=1,0
if coord=="t":
geo=1
tilt=1
if coord=="":
coord='s'
geo=0
tilt=0
if geo==1 and sfile=="":
samp_file=raw_input(" Input er_samples file for sample orientations [er_samples.txt] " )
if samp_file=="":samp_file="er_samples.txt"
samp_data,file_type=pmag.magic_read(samp_file)
if file_type != 'er_samples':
print file_type
print "This is not a valid er_samples file - coordinate system not changed"
else:
sfile="ok"
ans=""
if ans=='s':
keepon=1
sample=raw_input('Enter desired specimen name (or first part there of): ')
while keepon==1:
try:
k =sids.index(sample)
keepon=0
except:
tmplist=[]
for qq in range(len(sids)):
if sample in sids[qq]:tmplist.append(sids[qq])
print sample," not found, but this was: "
print tmplist
sample=raw_input('Select one or try again\n ')
angle,direction_type="",""
setangle=0
ans=""
if ans=='h':
k-=1
angle=raw_input("Enter desired declination for X axis 0-360 ")
angle=float(angle)
if angle==0:angle=0.001
s=sids[k]
setangle=1
ans=""
if ans=='e':
k-=1
ans=""
recnum=0
for plotrec in plotblock:
if plotrec[0]<=200 and verbose: print '%s: %i %7.1f %s %8.3e %7.1f %7.1f ' % (plotrec[5], recnum,plotrec[0]*1e3," mT",plotrec[3],plotrec[1],plotrec[2])
if plotrec[0]>200 and verbose: print '%s: %i %7.1f %s %8.3e %7.1f %7.1f ' % (plotrec[5], recnum,plotrec[0]-273,' C',plotrec[3],plotrec[1],plotrec[2])
recnum += 1
answer=raw_input('Enter index of point to change from bad to good or vice versa: ')
try:
ind=int(answer)
meas_data=pmag.mark_dmag_rec(s,ind,meas_data)
changeM=1
except:
'bad entry, try again'
if ans=='b':
if end_pca=="":end_pca=len(plotblock)-1
if beg_pca=="":beg_pca=0
k-=1 # stay on same sample until through
GoOn=0
while GoOn==0:
print 'Enter index of first point for pca: ','[',beg_pca,']'
answer=raw_input('return to keep default ')
if answer != "":
beg_pca=int(answer)
print 'Enter index of last point for pca: ','[',end_pca,']'
answer=raw_input('return to keep default ')
try:
end_pca=int(answer)
if plotblock[beg_pca][5]=='b' or plotblock[end_pca][5]=='b':
print "Can't select 'bad' measurement for PCA bounds -try again"
end_pca=len(plotblock)-1
beg_pca=0
elif beg_pca >=0 and beg_pca<=len(plotblock)-2 and end_pca>0 and end_pca<len(plotblock):
GoOn=1
else:
print beg_pca,end_pca, " are bad entry of indices - try again"
end_pca=len(plotblock)-1
beg_pca=0
except:
print beg_pca,end_pca, " are bad entry of indices - try again"
end_pca=len(plotblock)-1
beg_pca=0
GoOn=0
while GoOn==0:
if calculation_type!="":
print "Prior calculation type = ",calculation_type
ct=raw_input('Enter new Calculation Type: best-fit line, plane or fisher mean [l]/p/f : ' )
if ct=="" or ct=="l":
direction_type="l"
calculation_type="DE-BFL"
GoOn=1
elif ct=='p':
direction_type="p"
calculation_type="DE-BFP"
GoOn=1
elif ct=='f':
direction_type="l"
calculation_type="DE-FM"
GoOn=1
else:
print "bad entry of calculation type: try again. "
pmagplotlib.plotZED(ZED,plotblock,angle,s,units)
if verbose:pmagplotlib.drawFIGS(ZED)
if geo==1 and tilt==0:
mpars=pmag.domean(geoblock,beg_pca,end_pca,calculation_type)
if mpars['specimen_direction_type']=='Error':break
PmagSpecRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
PmagSpecRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
if "SO-NO" not in method_codes:
PmagSpecRec["specimen_tilt_correction"]='0'
method_codes.append("DA-DIR-GEO")
else:
PmagSpecRec["specimen_tilt_correction"]='-1'
pmagplotlib.plotDir(ZED,mpars,geoblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
if geo==1 and tilt==1:
mpars=pmag.domean(tiltblock,beg_pca,end_pca,calculation_type)
if mpars['specimen_direction_type']=='Error':break
PmagSpecRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
PmagSpecRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
if "SO-NO" not in method_codes:
PmagSpecRec["specimen_tilt_correction"]='100'
method_codes.append("DA-DIR-TILT")
else:
PmagSpecRec["specimen_tilt_correction"]='-1'
pmagplotlib.plotDir(ZED,mpars,tiltblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
if geo==0 and tilt==0:
mpars=pmag.domean(datablock,beg_pca,end_pca,calculation_type)
if mpars['specimen_direction_type']=='Error':break
PmagSpecRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
PmagSpecRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
PmagSpecRec["specimen_tilt_correction"]='-1'
pmagplotlib.plotDir(ZED,mpars,plotblock,angle)
if verbose:pmagplotlib.drawFIGS(ZED)
PmagSpecRec["measurement_step_min"]='%8.3e ' %(mpars["measurement_step_min"])
PmagSpecRec["measurement_step_max"]='%8.3e ' %(mpars["measurement_step_max"])
PmagSpecRec["specimen_correction"]='u'
PmagSpecRec["specimen_dang"]='%7.1f ' %(mpars['specimen_dang'])
print 'DANG: ',PmagSpecRec["specimen_dang"]
if calculation_type!='DE-FM':
PmagSpecRec["specimen_mad"]='%7.1f ' %(mpars["specimen_mad"])
PmagSpecRec["specimen_alpha95"]=""
else:
PmagSpecRec["specimen_alpha95"]='%7.1f ' %(mpars["specimen_alpha95"])
PmagSpecRec["specimen_mad"]=""
PmagSpecRec["specimen_n"]='%i ' %(mpars["specimen_n"])
PmagSpecRec["specimen_direction_type"]=direction_type
PmagSpecRec["calculation_type"]=calculation_type # redundant and won't be imported - just for convenience
method_codes=PmagSpecRec["magic_method_codes"].split(':')
if len(method_codes) != 0:
methstring=""
for meth in method_codes:
ctype=meth.split('-')
if 'DE' not in ctype:methstring=methstring+ ":" +meth # don't include old direction estimation methods
methstring=methstring+':'+calculation_type
PmagSpecRec["magic_method_codes"]= methstring.strip(':')
print 'Method codes: ',PmagSpecRec['magic_method_codes']
if calculation_type!='DE-FM':
if units=='K':
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_mad"]),float(PmagSpecRec["specimen_dang"]),float(PmagSpecRec["measurement_step_min"])-273,float(PmagSpecRec["measurement_step_max"])-273,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
elif units== 'T':
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_mad"]),float(PmagSpecRec["specimen_dang"]),float(PmagSpecRec["measurement_step_min"])*1e3,float(PmagSpecRec["measurement_step_max"])*1e3,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
elif 'T' in units and 'K' in units:
if float(PmagSpecRec['measurement_step_min'])<1.0 :
min=float(PmagSpecRec['measurement_step_min'])*1e3
else:
min=float(PmagSpecRec['measurement_step_min'])-273
if float(PmagSpecRec['measurement_step_max'])<1.0 :
max=float(PmagSpecRec['measurement_step_max'])*1e3
else:
max=float(PmagSpecRec['measurement_step_max'])-273
print '%s %i %7.1f %i %i %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_mad"]),float(PmagSpecRec["specimen_dang"]),min,max,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
else:
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_mad"]),float(PmagSpecRec["specimen_dang"]),float(PmagSpecRec["measurement_step_min"]),float(PmagSpecRec["measurement_step_max"]),float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
else:
if 'K' in units:
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_alpha95"]),float(PmagSpecRec["specimen_dang"]),float(PmagSpecRec["measurement_step_min"])-273,float(PmagSpecRec["measurement_step_max"])-273,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
elif 'T' in units:
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_alpha95"]),float(PmagSpecRec["specimen_dang"]),float(PmagSpecRec["measurement_step_min"])*1e3,float(PmagSpecRec["measurement_step_max"])*1e3,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
elif 'T' in units and 'K' in units:
if float(PmagSpecRec['measurement_step_min'])<1.0 :
min=float(PmagSpecRec['measurement_step_min'])*1e3
else:
min=float(PmagSpecRec['measurement_step_min'])-273
if float(PmagSpecRec['measurement_step_max'])<1.0 :
max=float(PmagSpecRec['measurement_step_max'])*1e3
else:
max=float(PmagSpecRec['measurement_step_max'])-273
print '%s %i %7.1f %i %i %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_alpha95"]),min,max,float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
else:
print '%s %i %7.1f %7.1f %7.1f %7.1f %7.1f, %s \n' % (PmagSpecRec["er_specimen_name"],int(PmagSpecRec["specimen_n"]),float(PmagSpecRec["specimen_alpha95"]),float(PmagSpecRec["measurement_step_min"]),float(PmagSpecRec["measurement_step_max"]),float(PmagSpecRec["specimen_dec"]),float(PmagSpecRec["specimen_inc"]),calculation_type)
saveit=raw_input("Save this interpretation? [y]/n \n")
if saveit!="n":
changeS=1
#
# put in details
#
angle,direction_type,setangle="","",0
if len(CurrRecs)>0:
replace=raw_input(" [0] add new component, or [1] replace existing interpretation(s) [default is replace] ")
if replace=="1" or replace=="":
CurrRecs=[]
PmagSpecRec['specimen_comp_name']='A'
CurrRecs.append(PmagSpecRec)
else:
print 'These are the current component names for this specimen: '
for trec in CurrRecs:print trec['specimen_comp_name']
compnum=raw_input("Enter new component name: ")
PmagSpecRec['specimen_comp_name']=compnum
print "Adding new component: ",PmagSpecRec['specimen_comp_name']
CurrRecs.append(PmagSpecRec)
else:
PmagSpecRec['specimen_comp_name']='A'
CurrRecs.append(PmagSpecRec)
k+=1
ans=""
else:
ans=""
else: # plots=1
k+=1
files={}
locname.replace('/','-')
print PmagSpecRec
for key in ZED.keys():
files[key]="LO:_"+locname+'_SI:_'+PmagSpecRec['er_site_name']+'_SA:_'+PmagSpecRec['er_sample_name']+'_SP:_'+s+'_CO:_'+coord+'_TY:_'+key+'_.'+fmt
if pmagplotlib.isServer:
black = '#000000'
purple = '#800080'
titles={}
titles['demag']='DeMag Plot'
titles['zijd']='Zijderveld Plot'
titles['eqarea']='Equal Area Plot'
ZED = pmagplotlib.addBorders(ZED,titles,black,purple)
pmagplotlib.saveP(ZED,files)
if len(CurrRecs)>0:
for rec in CurrRecs: PriorRecs.append(rec)
if changeS==1:
if len(PriorRecs)>0:
save_redo(PriorRecs,inspec)
else:
os.system('rm '+inspec)
CurrRecs,beg_pca,end_pca=[],"","" # next up
changeS=0
else: k+=1 # skip record - not enough data
if changeM==1:
pmag.magic_write(meas_file,meas_data,'magic_measurements')
def main():
"""
NAME
make_magic_plots.py
DESCRIPTION
inspects magic directory for available 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)
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'
azimuth_key = 'azimuth'
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
con = cb.Contribution()
con.propagate_location_to_measurements()
con.propagate_location_to_specimens()
con.propagate_location_to_samples()
if not con.tables:
print('-E- No MagIC tables could be found in this directory')
error_log("No MagIC tables found")
return
# check to see if propagation worked, otherwise you can't plot by location
lowest_table = None
for table in con.ancestry:
if table in 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 con.tables[lowest_table].df.columns:
# are there any locations in the lowest table?
if not all(con.tables[lowest_table].df['location'].isnull()):
locs = con.tables['locations'].df.index.unique()
lowest_locs = 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'.
format(lowest_table))
else:
do_full_directory = True
error_log(
'could not propagate location names down to {} table'.format(
lowest_table))
else:
do_full_directory = True
error_log('could not propagate location names down to {} table'.format(
lowest_table))
all_data = {}
all_data['measurements'] = con.tables.get('measurements', None)
all_data['specimens'] = con.tables.get('specimens', None)
all_data['samples'] = con.tables.get('samples', None)
all_data['sites'] = con.tables.get('sites', None)
all_data['locations'] = con.tables.get('locations', None)
locations = con.tables['locations'].df.index.unique()
dirlist = [loc for loc in locations if cb.not_null(loc) 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')
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]):
data_container = all_data[dtype]
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
meas_data = get_data('measurements', loc)
spec_data = get_data('specimens', loc)
samp_data = get_data('samples', loc)
site_data = get_data('sites', loc)
location_data = get_data('locations', loc)
if loc == "./": # if you can't sort by location, do everything together
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 samp_file in filelist: # find coordinate systems
samps = samp_data
file_type = "samples"
# get all non blank sample orientations
Srecs = pmag.get_dictitem(samps, azimuth_key, '', 'F')
if len(Srecs) > 0:
crd = 'g'
print('using geographic coordinates')
else:
print('using specimen coordinates')
else:
if VERBOSE:
print('-I- No sample data found')
if meas_file in filelist: # start with measurement data
print('working on 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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# 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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# 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")
else:
CMD = 'quick_hyst.py -f tmp_measurements.txt -sav -fmt ' + fmt
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# equal area plots of directional data
# at measurment 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
print(CMD)
os.system(CMD)
info_log(CMD, loc, "eqarea_magic.py")
else:
if VERBOSE:
print('-I- No measurement data found')
# site data
if results_file in filelist:
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))
# only individual results - not poles
# get only individual results (if result_type col is available)
if SiteDIs:
if 'result_type' in SiteDIs[0]:
SiteDIs = pmag.get_dictitem(SiteDIs, 'result_type', 'i',
'has')
# then convert tilt_corr_key to correct format
old_SiteDIs = SiteDIs
SiteDIs = []
for rec in old_SiteDIs:
if tilt_corr_key not in rec:
error_log(
"Directional data found, but missing {}, can't plot directions"
.format(tilt_corr_key), loc, "eqarea_magic.py")
break
if cb.is_null(
rec[tilt_corr_key]) and rec[tilt_corr_key] != 0:
rec[tilt_corr_key] = ""
else:
try:
rec[tilt_corr_key] = str(
int(float(rec[tilt_corr_key])))
except ValueError:
rec[tilt_corr_key] = ""
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'
elif len(SiteDIs_g) > 0:
CRD = ' -crd g'
elif len(SiteDIs_s) > 0:
CRD = ' -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
print(CMD)
info_log(CMD, loc)
os.system(CMD)
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")
#
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'
print(CMD)
info_log(CMD, loc, 'vgpmap_magic.py')
os.system(CMD)
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")
with open('intensities.txt', 'w') as out:
for rec in Selection:
if rec != 0:
out.write(str(rec * 1e6) + "\n")
histfile = 'LO:_' + loc + \
'_TY:_intensities_histogram:_.' + fmt
# maybe run histplot.main here instead, so you can return an error message
CMD = "histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f intensities.txt -F " + histfile
os.system(CMD)
info_log(CMD, loc)
print(CMD)
else:
print('-I- No intensities found')
else:
print('-I- No intensities found')
##
if hyst_file in filelist:
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 = 'dayplot_magic.py -f tmp_specimens.txt -sav -fmt ' + fmt
info_log(CMD, loc)
print(CMD)
else:
print('no hysteresis data found')
if aniso_file in filelist: # 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)
CRD = ""
CMD = 'aniso_magic.py -x -B -sav -fmt ' + fmt
if len(sdata) > 3:
CMD = CMD + ' -crd s'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
if len(gdata) > 3:
CMD = CMD + ' -crd g'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
if len(tdata) > 3:
CMD = CMD + ' -crd t'
print(CMD)
info_log(CMD, loc)
os.system(CMD)
# remove temporary files
for fname in glob.glob('tmp*.txt'):
os.remove(fname)
try:
os.remove('intensities.txt')
except FileNotFoundError:
pass
if loc_file in filelist:
data, file_type = pmag.magic_read(loc_file) # read in location 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'
print(CMD)
info_log(CMD, "all locations", "polemap_magic.py")
os.system(CMD)
else:
print('-I- No poles found')
def main():
"""
NAME
make_magic_plots.py
DESCRIPTION
inspects magic directory for available 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
-DM [2,3] define data model
"""
dirlist = ['./']
dir_path = os.getcwd()
names = os.listdir(dir_path)
for n in names:
if 'Location' in n:
dirlist.append(n)
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)
new_model = 0
if '-DM' in sys.argv:
ind = sys.argv.index("-DM")
data_model = sys.argv[ind + 1]
if data_model == '3': new_model = 1
if new_model:
samp_file = 'samples.txt'
azimuth_key = 'azimuth'
meas_file = 'measurements.txt'
loc_key = 'location'
method_key = 'method_codes'
dec_key = 'dir_dec'
inc_key = 'dir_inc'
Mkeys = ['magnitude', 'magn_moment', 'magn_volume', 'magn_mass']
results_file = 'sites.txt'
tilt_key = 'direction_tilt_correction'
hyst_file = 'specimens.txt'
aniso_file = 'specimens.txt'
else:
new_model = 0
samp_file = 'er_samples.txt'
azimuth_key = 'sample_azimuth'
meas_file = 'magic_measurements.txt'
loc_key = 'er_location_name'
method_key = 'magic_method_codes'
dec_key = 'measurement_dec'
inc_key = 'measurement_inc'
Mkeys = [
'measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass'
]
results_file = 'pmag_results.txt'
tilt_key = 'tilt_correction'
hyst_file = 'rmag_hysteresis'
aniso_file = 'rmag_anisotropy'
if '-h' in sys.argv:
print main.__doc__
sys.exit()
for loc in dirlist:
print 'working on: ', loc
os.chdir(loc) # change working directories to each location
crd = 's'
print samp_file
if samp_file in filelist: # find coordinate systems
print 'found sample file'
samps, file_type = pmag.magic_read(samp_file) # read in data
Srecs = pmag.get_dictitem(
samps, azimuth_key, '',
'F') # get all none blank sample orientations
if len(Srecs) > 0:
crd = 'g'
if meas_file in filelist: # start with measurement data
print 'working on measurements data'
data, file_type = pmag.magic_read(meas_file) # read in data
if loc == './':
data = pmag.get_dictitem(
data, loc_key, '',
'T') # get all the blank location names from data file
# looking for zeq_magic possibilities
AFZrecs = pmag.get_dictitem(
data, method_key, 'LT-AF-Z',
'has') # get all none blank method codes
TZrecs = pmag.get_dictitem(
data, method_key, 'LT-T-Z',
'has') # get all none blank method codes
MZrecs = pmag.get_dictitem(
data, method_key, 'LT-M-Z',
'has') # get all none blank method codes
Drecs = pmag.get_dictitem(data, dec_key, '',
'F') # get all dec measurements
Irecs = pmag.get_dictitem(data, inc_key, '',
'F') # get all inc measurements
for key in Mkeys:
Mrecs = pmag.get_dictitem(data, key, '',
'F') # get intensity data
if len(Mrecs) > 0: break
if len(AFZrecs) > 0 or len(TZrecs) > 0 or len(MZrecs) > 0 and len(
Drecs) > 0 and len(Irecs) > 0 and len(
Mrecs) > 0: # potential for stepwise demag curves
if new_model:
CMD = 'zeq_magic3.0.py -fsp specimens.txt -sav -fmt ' + fmt + ' -crd ' + crd
else:
CMD = 'zeq_magic.py -fsp pmag_specimens.txt -sav -fmt ' + fmt + ' -crd ' + crd
print CMD
os.system(CMD)
# looking for thellier_magic possibilities
if len(pmag.get_dictitem(data, method_key, 'LP-PI-TRM',
'has')) > 0:
if new_model:
CMD = 'thellier_magic3.0.py -fsp specimens.txt -sav -fmt ' + fmt
else:
CMD = 'thellier_magic.py -fsp pmag_specimens.txt -sav -fmt ' + fmt
print CMD
os.system(CMD)
# looking for hysteresis possibilities
if len(pmag.get_dictitem(data, method_key, 'LP-HYS',
'has')) > 0: # find hyst experiments
if new_model:
CMD = 'quick_hyst3.0.py -sav -fmt ' + fmt
else:
CMD = 'quick_hyst.py -sav -fmt ' + fmt
print CMD
os.system(CMD)
if results_file in filelist: # start with measurement data
data, file_type = pmag.magic_read(results_file) # read in data
print 'number of datapoints: ', len(data)
if loc == './':
data = pmag.get_dictitem(
data, loc_key, ':', 'has'
) # get all the concatenated location names from data file
print 'number of datapoints: ', len(data), loc
if new_model:
print 'working on site directions'
dec_key = 'dir_dec'
inc_key = 'dir_inc'
int_key = 'int_abs'
else:
print 'working on results directions'
dec_key = 'average_dec'
inc_key = 'average_inc'
int_key = 'average_int'
SiteDIs = pmag.get_dictitem(data, dec_key, "", 'F') # find decs
SiteDIs = pmag.get_dictitem(SiteDIs, inc_key, "",
'F') # find decs and incs
SiteDIs = pmag.get_dictitem(
SiteDIs, 'data_type', 'i',
'has') # only individual results - not poles
print 'number of directions: ', len(SiteDIs)
SiteDIs_t = pmag.get_dictitem(SiteDIs, tilt_key, '100',
'T') # tilt corrected coordinates
print 'number of tilt corrected directions: ', len(SiteDIs)
SiteDIs_g = pmag.get_dictitem(SiteDIs, tilt_key, '0',
'T') # geographic coordinates
SiteDIs_s = pmag.get_dictitem(SiteDIs, 'tilt_correction', '-1',
'T') # sample coordinates
SiteDIs_x = pmag.get_dictitem(SiteDIs, 'tilt_correction', '',
'T') # no coordinates
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'
elif len(SiteDIs_g) > 0:
CRD = ' -crd g'
elif len(SiteDIs_s) > 0:
CRD = ' -crd s'
if new_model:
CMD = 'eqarea_magic3.0.py -sav -crd t -fmt ' + fmt + CRD
else:
CMD = 'eqarea_magic.py -sav -crd t -fmt ' + fmt + CRD
print CMD
os.system(CMD)
print 'working on VGP map'
VGPs = pmag.get_dictitem(SiteDIs, 'vgp_lat', "",
'F') # are there any VGPs?
if len(VGPs) > 0: # YES!
os.system(
'vgpmap_magic.py -prj moll -res c -sym ro 5 -sav -fmt png')
print 'working on intensities'
if not new_model:
CMD = 'magic_select.py -f ' + results_file + ' -key data_type i T -F tmp.txt'
os.system(CMD)
infile = ' tmp.txt'
else:
infile = results_file
print int_key
CMD = 'magic_select.py -key ' + int_key + ' 0. has -F tmp1.txt -f ' + infile
os.system(CMD)
CMD = "grab_magic_key.py -f tmp1.txt -key " + int_key + " | awk '{print $1*1e6}' >tmp2.txt"
os.system(CMD)
data, file_type = pmag.magic_read('tmp1.txt') # read in data
if new_model:
locations = pmag.get_dictkey(data, loc_key, "")
else:
locations = pmag.get_dictkey(data, loc_key + 's', "")
histfile = 'LO:_' + locations[0] + '_intensities_histogram:_.' + fmt
os.system(
"histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F "
+ histfile)
print "histplot.py -b 1 -xlab 'Intensity (uT)' -sav -f tmp2.txt -F " + histfile
os.system('rm tmp*.txt')
if hyst_file in filelist: # start with measurement data
print 'working on hysteresis'
data, file_type = pmag.magic_read(hyst_file) # read in data
if loc == './':
data = pmag.get_dictitem(
data, loc_key, '',
'T') # get all the blank location names from data file
hdata = pmag.get_dictitem(data, 'hysteresis_bcr', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_mr_moment', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_ms_moment', '', 'F')
hdata = pmag.get_dictitem(hdata, 'hysteresis_bc', '',
'F') # there are data for a dayplot
if len(hdata) > 0:
print 'dayplot_magic.py -sav -fmt ' + fmt
os.system('dayplot_magic.py -sav -fmt ' + fmt)
if aniso_file in filelist: # do anisotropy plots if possible
print 'working on anisotropy'
data, file_type = pmag.magic_read(aniso_file) # read in data
if loc == './':
data = pmag.get_dictitem(
data, loc_key, '',
'T') # get all the blank location names from data file
sdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction', '-1',
'T') # get specimen coordinates
gdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction', '0',
'T') # get specimen coordinates
tdata = pmag.get_dictitem(data, 'anisotropy_tilt_correction',
'100', 'T') # get specimen coordinates
CRD = ""
if new_model:
CMD = 'aniso_magic3.0.py -x -B -sav -fmt ' + fmt
else:
CMD = 'aniso_magic.py -x -B -sav -fmt ' + fmt
if len(sdata) > 3:
CMD = CMD + ' -crd s'
print CMD
os.system(CMD)
if len(gdata) > 3:
CMD = CMD + ' -crd g'
print CMD
os.system(CMD)
if len(tdata) > 3:
CMD = CMD + ' -crd t'
print CMD
os.system(CMD)
if loc != './':
os.chdir('..') # change working directories to each location
def main():
"""
NAME
quick_hyst.py
DESCRIPTION
makes plots of hysteresis data
SYNTAX
quick_hyst.py [command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f: specify input file, default is magic_measurements.txt
-spc SPEC: specify specimen name to plot and quit
-sav save all plots and quit
-fmt [png,svg,eps,jpg]
"""
args = sys.argv
PLT = 1
plots = 0
user, meas_file = "", "magic_measurements.txt"
pltspec = ""
dir_path = '.'
fmt = 'png'
verbose = pmagplotlib.verbose
version_num = pmag.get_version()
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind+1]
if "-h" in args:
print(main.__doc__)
sys.exit()
if "-usr" in args:
ind = args.index("-usr")
user = args[ind+1]
if '-f' in args:
ind = args.index("-f")
meas_file = args[ind+1]
if '-sav' in args:
verbose = 0
plots = 1
if '-spc' in args:
ind = args.index("-spc")
pltspec = args[ind+1]
verbose = 0
plots = 1
if '-fmt' in args:
ind = args.index("-fmt")
fmt = args[ind+1]
meas_file = dir_path+'/'+meas_file
#
#
meas_data, file_type = pmag.magic_read(meas_file)
if file_type != 'magic_measurements':
print(main.__doc__)
print('bad file')
sys.exit()
#
# initialize some variables
# define figure numbers for hyst,deltaM,DdeltaM curves
HystRecs, RemRecs = [], []
HDD = {}
HDD['hyst'] = 1
pmagplotlib.plot_init(HDD['hyst'], 5, 5)
#
# get list of unique experiment names and specimen names
#
experiment_names, sids = [], []
hyst_data = pmag.get_dictitem(
meas_data, 'magic_method_codes', 'LP-HYS', 'has') # get all hysteresis data
for rec in hyst_data:
if 'er_synthetic_name' in rec.keys() and rec['er_synthetic_name'] != "":
rec['er_specimen_name'] = rec['er_synthetic_name']
if rec['magic_experiment_name'] not in experiment_names:
experiment_names.append(rec['magic_experiment_name'])
if rec['er_specimen_name'] not in sids:
sids.append(rec['er_specimen_name'])
if 'measurement_temp' not in rec.keys():
# assume room T measurement unless otherwise specified
rec['measurement_temp'] = '300'
#
k = 0
if pltspec != "":
k = sids.index(pltspec)
intlist = ['measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass']
while k < len(sids):
locname, site, sample, synth = '', '', '', ''
s = sids[k]
hmeths = []
if verbose:
print(s, k+1, 'out of ', len(sids))
#
#
B, M = [], [] # B,M for hysteresis, Bdcd,Mdcd for irm-dcd data
# get all measurements for this specimen
spec = pmag.get_dictitem(hyst_data, 'er_specimen_name', s, 'T')
if 'er_location_name' in spec[0].keys():
locname = spec[0]['er_location_name']
if 'er_site_name' in spec[0].keys():
site = spec[0]['er_site_name']
if 'er_sample_name' in spec[0].keys():
sample = spec[0]['er_sample_name']
if 'er_synthetic_name' in spec[0].keys():
synth = spec[0]['er_synthetic_name']
for m in intlist:
# get all non-blank data for this specimen
meas_data = pmag.get_dictitem(spec, m, '', 'F')
if len(meas_data) > 0:
break
c = ['k-', 'b-', 'c-', 'g-', 'm-', 'r-', 'y-']
cnum = 0
if len(meas_data) > 0:
Temps = []
xlab, ylab, title = '', '', ''
for rec in meas_data:
if rec['measurement_temp'] not in Temps:
Temps.append(rec['measurement_temp'])
for t in Temps:
print('working on t: ', t)
t_data = pmag.get_dictitem(
meas_data, 'measurement_temp', t, 'T')
B, M = [], []
for rec in t_data:
B.append(float(rec['measurement_lab_field_dc']))
M.append(float(rec[m]))
# now plot the hysteresis curve(s)
#
if len(B) > 0:
B = numpy.array(B)
M = numpy.array(M)
if t == Temps[-1]:
xlab = 'Field (T)'
ylab = m
title = 'Hysteresis: '+s
if t == Temps[0]:
pmagplotlib.clearFIG(HDD['hyst'])
pmagplotlib.plot_xy(
HDD['hyst'], B, M, sym=c[cnum], xlab=xlab, ylab=ylab, title=title)
pmagplotlib.plot_xy(HDD['hyst'], [
1.1*B.min(), 1.1*B.max()], [0, 0], sym='k-', xlab=xlab, ylab=ylab, title=title)
pmagplotlib.plot_xy(HDD['hyst'], [0, 0], [
1.1*M.min(), 1.1*M.max()], sym='k-', xlab=xlab, ylab=ylab, title=title)
if verbose:
pmagplotlib.draw_figs(HDD)
cnum += 1
if cnum == len(c):
cnum = 0
#
files = {}
if plots:
if pltspec != "":
s = pltspec
files = {}
for key in HDD.keys():
if pmagplotlib.isServer: # use server plot naming convention
if synth == '':
filename = "LO:_"+locname+'_SI:_'+site + \
'_SA:_'+sample+'_SP:_'+s+'_TY:_'+key+'_.'+fmt
else:
filename = 'SY:_'+synth+'_TY:_'+key+'_.'+fmt
files[key] = filename
else: # use more readable plot naming convention
if synth == '':
filename = ''
for item in [locname, site, sample, s, key]:
if item:
item = item.replace(' ', '_')
filename += item + '_'
if filename.endswith('_'):
filename = filename[:-1]
filename += ".{}".format(fmt)
else:
filename = synth+'_'+key+'.fmt'
files[key] = filename
pmagplotlib.save_plots(HDD, files)
if pltspec != "":
sys.exit()
if verbose:
pmagplotlib.draw_figs(HDD)
ans = raw_input(
"S[a]ve plots, [s]pecimen name, [q]uit, <return> to continue\n ")
if ans == "a":
files = {}
for key in HDD.keys():
if pmagplotlib.isServer:
print('server')
files[key] = "LO:_"+locname+'_SI:_'+site + \
'_SA:_'+sample+'_SP:_'+s+'_TY:_'+key+'_.'+fmt
else:
print('not server')
filename = ''
for item in [locname, site, sample, s, key]:
if item:
item = item.replace(' ', '_')
filename += item + '_'
if filename.endswith('_'):
filename = filename[:-1]
filename += ".{}".format(fmt)
files[key] = filename
print('files', files)
pmagplotlib.save_plots(HDD, files)
if ans == '':
k += 1
if ans == "p":
del HystRecs[-1]
k -= 1
if ans == 'q':
print("Good bye")
sys.exit()
if ans == 's':
keepon = 1
specimen = raw_input(
'Enter desired specimen name (or first part there of): ')
while keepon == 1:
try:
k = sids.index(specimen)
keepon = 0
except:
tmplist = []
for qq in range(len(sids)):
if specimen in sids[qq]:
tmplist.append(sids[qq])
print(specimen, " not found, but this was: ")
print(tmplist)
specimen = raw_input('Select one or try again\n ')
k = sids.index(specimen)
else:
k += 1
if len(B) == 0:
if verbose:
print('skipping this one - no hysteresis data')
k += 1
def main():
"""
NAME
zeq_magic_redo.py
DESCRIPTION
Calculate principal components through demagnetization data using bounds and calculation type stored in "redo" file
SYNTAX
zeq_magic_redo.py [command line options]
OPTIONS
-h prints help message
-usr USER: identify user, default is ""
-f: specify input file, default is magic_measurements.txt
-F: specify output file, default is zeq_specimens.txt
-fre REDO: specify redo file, default is "zeq_redo"
-fsa SAMPFILE: specify er_samples format file, default is "er_samples.txt"
-A : don't average replicate measurements, default is yes
-crd [s,g,t] :
specify coordinate system [s,g,t] [default is specimen coordinates]
are specimen, geographic, and tilt corrected respectively
NB: you must have a SAMPFILE in this directory to rotate from specimen coordinates
-leg: attaches "Recalculated from original measurements; supercedes published results. " to comment field
INPUTS
zeq_redo format file is:
specimen_name calculation_type[DE-BFL,DE-BFL-A,DE-BFL-O,DE-BFP,DE-FM] step_min step_max component_name[A,B,C]
"""
dir_path='.'
INCL=["LT-NO","LT-AF-Z","LT-T-Z","LT-M-Z"] # looking for demag data
beg,end,pole,geo,tilt,askave,save=0,0,[],0,0,0,0
user,doave,comment= "",1,""
geo,tilt=0,0
version_num=pmag.get_version()
args=sys.argv
if '-WD' in args:
ind=args.index('-WD')
dir_path=args[ind+1]
meas_file,pmag_file,mk_file= dir_path+"/"+"magic_measurements.txt",dir_path+"/"+"zeq_specimens.txt",dir_path+"/"+"zeq_redo"
samp_file,coord=dir_path+"/"+"er_samples.txt",""
if "-h" in args:
print(main.__doc__)
sys.exit()
if "-usr" in args:
ind=args.index("-usr")
user=sys.argv[ind+1]
if "-A" in args:doave=0
if "-leg" in args: comment="Recalculated from original measurements; supercedes published results. "
if "-f" in args:
ind=args.index("-f")
meas_file=dir_path+'/'+sys.argv[ind+1]
if "-F" in args:
ind=args.index("-F")
pmag_file=dir_path+'/'+sys.argv[ind+1]
if "-fre" in args:
ind=args.index("-fre")
mk_file=dir_path+"/"+args[ind+1]
try:
mk_f=open(mk_file,'r')
except:
print("Bad redo file")
sys.exit()
mkspec,skipped=[],[]
speclist=[]
for line in mk_f.readlines():
tmp=line.split()
mkspec.append(tmp)
speclist.append(tmp[0])
if "-fsa" in args:
ind=args.index("-fsa")
samp_file=dir_path+'/'+sys.argv[ind+1]
if "-crd" in args:
ind=args.index("-crd")
coord=sys.argv[ind+1]
if coord=="g":geo,tilt=1,0
if coord=="t":geo,tilt=1,1
#
# now get down to bidness
if geo==1:
samp_data,file_type=pmag.magic_read(samp_file)
if file_type != 'er_samples':
print(file_type)
print("This is not a valid er_samples file ")
sys.exit()
#
#
#
meas_data,file_type=pmag.magic_read(meas_file)
if file_type != 'magic_measurements':
print(file_type)
print(file_type,"This is not a valid magic_measurements file ")
sys.exit()
#
# sort the specimen names
#
k = 0
print('Processing ',len(speclist), ' specimens - please wait')
PmagSpecs=[]
while k < len(speclist):
s=speclist[k]
recnum=0
PmagSpecRec={}
method_codes,inst_codes=[],[]
# find the data from the meas_data file for this sample
#
# collect info for the PmagSpecRec dictionary
#
meas_meth=[]
spec=pmag.get_dictitem(meas_data,'er_specimen_name',s,'T')
if len(spec)==0:
print('no data found for specimen: ',s)
print('delete from zeq_redo input file...., then try again')
else:
for rec in spec: # copy of vital stats to PmagSpecRec from first spec record in demag block
skip=1
methods=rec["magic_method_codes"].split(":")
if len(set(methods) & set(INCL))>0:
PmagSpecRec["er_analyst_mail_names"]=user
PmagSpecRec["magic_software_packages"]=version_num
PmagSpecRec["er_specimen_name"]=s
PmagSpecRec["er_sample_name"]=rec["er_sample_name"]
PmagSpecRec["er_site_name"]=rec["er_site_name"]
PmagSpecRec["er_location_name"]=rec["er_location_name"]
if "er_expedition_name" in list(rec.keys()):PmagSpecRec["er_expedition_name"]=rec["er_expedition_name"]
PmagSpecRec["er_citation_names"]="This study"
if "magic_experiment_name" not in list(rec.keys()): rec["magic_experiment_name"]=""
PmagSpecRec["magic_experiment_names"]=rec["magic_experiment_name"]
if "magic_instrument_codes" not in list(rec.keys()): rec["magic_instrument_codes"]=""
inst=rec['magic_instrument_codes'].split(":")
for I in inst:
if I not in inst_codes: # copy over instruments
inst_codes.append(I)
meths=rec["magic_method_codes"].split(":")
for meth in meths:
if meth.strip() not in meas_meth:meas_meth.append(meth)
if "LP-DIR-AF" in meas_meth or "LT-AF-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"]="T"
if "LP-DIR-AF" not in method_codes:method_codes.append("LP-DIR-AF")
if "LP-DIR-T" in meas_meth or "LT-T-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"]="K"
if "LP-DIR-T" not in method_codes:method_codes.append("LP-DIR-T")
if "LP-DIR-M" in meas_meth or "LT-M-Z" in meas_meth:
PmagSpecRec["measurement_step_unit"]="J"
if "LP-DIR-M" not in method_codes:method_codes.append("LP-DIR-M")
#
#
datablock,units=pmag.find_dmag_rec(s,spec) # fish out the demag data for this specimen
#
if len(datablock) <2 or s not in speclist :
k+=1
# print 'skipping ', s,len(datablock)
else:
#
# find replicate measurements at given treatment step and average them
#
# step_meth,avedata=pmag.vspec(data)
#
# if len(avedata) != len(datablock):
# if doave==1:
# method_codes.append("DE-VM")
# datablock=avedata
#
# do geo or stratigraphic correction now
#
if geo==1 or tilt==1:
# find top priority orientation method
orient,az_type=pmag.get_orient(samp_data,PmagSpecRec["er_sample_name"])
if az_type not in method_codes:method_codes.append(az_type)
#
# if tilt selected, get stratigraphic correction
#
tiltblock,geoblock=[],[]
for rec in datablock:
if "sample_azimuth" in list(orient.keys()) and orient["sample_azimuth"]!="":
d_geo,i_geo=pmag.dogeo(rec[1],rec[2],float(orient["sample_azimuth"]),float(orient["sample_dip"]))
geoblock.append([rec[0],d_geo,i_geo,rec[3],rec[4],rec[5]])
if tilt==1 and "sample_bed_dip_direction" in list(orient.keys()):
d_tilt,i_tilt=pmag.dotilt(d_geo,i_geo,float(orient["sample_bed_dip_direction"]),float(orient["sample_bed_dip"]))
tiltblock.append([rec[0],d_tilt,i_tilt,rec[3],rec[4],rec[5]])
elif tilt==1:
if PmagSpecRec["er_sample_name"] not in skipped:
print('no tilt correction for ', PmagSpecRec["er_sample_name"],' skipping....')
skipped.append(PmagSpecRec["er_sample_name"])
else:
if PmagSpecRec["er_sample_name"] not in skipped:
print('no geographic correction for ', PmagSpecRec["er_sample_name"],' skipping....')
skipped.append(PmagSpecRec["er_sample_name"])
#
# get beg_pca, end_pca, pca
if PmagSpecRec['er_sample_name'] not in skipped:
compnum=-1
for spec in mkspec:
if spec[0]==s:
CompRec={}
for key in list(PmagSpecRec.keys()):CompRec[key]=PmagSpecRec[key]
compnum+=1
calculation_type=spec[1]
beg=float(spec[2])
end=float(spec[3])
if len(spec)>4:
comp_name=spec[4]
else:
comp_name=string.uppercase[compnum]
CompRec['specimen_comp_name']=comp_name
if beg < float(datablock[0][0]):beg=float(datablock[0][0])
if end > float(datablock[-1][0]):end=float(datablock[-1][0])
for l in range(len(datablock)):
if datablock[l][0]==beg:beg_pca=l
if datablock[l][0]==end:end_pca=l
if geo==1 and tilt==0:
mpars=pmag.domean(geoblock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
CompRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
CompRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
CompRec["specimen_tilt_correction"]='0'
if geo==1 and tilt==1:
mpars=pmag.domean(tiltblock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
CompRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
CompRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
CompRec["specimen_tilt_correction"]='100'
if geo==0 and tilt==0:
mpars=pmag.domean(datablock,beg_pca,end_pca,calculation_type)
if mpars["specimen_direction_type"]!="Error":
CompRec["specimen_dec"]='%7.1f ' %(mpars["specimen_dec"])
CompRec["specimen_inc"]='%7.1f ' %(mpars["specimen_inc"])
CompRec["specimen_tilt_correction"]='-1'
if mpars["specimen_direction_type"]=="Error":
pass
else:
CompRec["measurement_step_min"]='%8.3e '%(datablock[beg_pca][0])
try:
CompRec["measurement_step_max"]='%8.3e '%(datablock[end_pca][0] )
except:
print('error in end_pca ',PmagSpecRec['er_specimen_name'])
CompRec["specimen_correction"]='u'
if calculation_type!='DE-FM':
CompRec["specimen_mad"]='%7.1f '%(mpars["specimen_mad"])
CompRec["specimen_alpha95"]=""
else:
CompRec["specimen_mad"]=""
CompRec["specimen_alpha95"]='%7.1f '%(mpars["specimen_alpha95"])
CompRec["specimen_n"]='%i '%(mpars["specimen_n"])
CompRec["specimen_dang"]='%7.1f '%(mpars["specimen_dang"])
CompMeths=[]
for meth in method_codes:
if meth not in CompMeths:CompMeths.append(meth)
if calculation_type not in CompMeths:CompMeths.append(calculation_type)
if geo==1: CompMeths.append("DA-DIR-GEO")
if tilt==1: CompMeths.append("DA-DIR-TILT")
if "DE-BFP" not in calculation_type:
CompRec["specimen_direction_type"]='l'
else:
CompRec["specimen_direction_type"]='p'
CompRec["magic_method_codes"]=""
if len(CompMeths) != 0:
methstring=""
for meth in CompMeths:
methstring=methstring+ ":" +meth
CompRec["magic_method_codes"]=methstring.strip(':')
CompRec["specimen_description"]=comment
if len(inst_codes) != 0:
inststring=""
for inst in inst_codes:
inststring=inststring+ ":" +inst
CompRec["magic_instrument_codes"]=inststring.strip(':')
PmagSpecs.append(CompRec)
k+=1
pmag.magic_write(pmag_file,PmagSpecs,'pmag_specimens')
print("Recalculated specimen data stored in ",pmag_file)
def main():
"""
NAME
aarm_magic.py
DESCRIPTION
Converts AARM data to best-fit tensor (6 elements plus sigma)
Original program ARMcrunch written to accomodate ARM anisotropy data
collected from 6 axial directions (+X,+Y,+Z,-X,-Y,-Z) using the
off-axis remanence terms to construct the tensor. A better way to
do the anisotropy of ARMs is to use 9,12 or 15 measurements in
the Hext rotational scheme.
SYNTAX
aarm_magic.py [-h][command line options]
OPTIONS
-h prints help message and quits
-usr USER: identify user, default is ""
-f FILE: specify input file, default is aarm_measurements.txt
-crd [s,g,t] specify coordinate system, requires er_samples.txt file
-fsa FILE: specify er_samples.txt file, default is er_samples.txt
-Fa FILE: specify anisotropy output file, default is arm_anisotropy.txt
-Fr FILE: specify results output file, default is aarm_results.txt
INPUT
Input for the present program is a series of baseline, ARM pairs.
The baseline should be the AF demagnetized state (3 axis demag is
preferable) for the following ARM acquisition. The order of the
measurements is:
positions 1,2,3, 6,7,8, 11,12,13 (for 9 positions)
positions 1,2,3,4, 6,7,8,9, 11,12,13,14 (for 12 positions)
positions 1-15 (for 15 positions)
"""
# initialize some parameters
args = sys.argv
user = ""
meas_file = "aarm_measurements.txt"
samp_file = "er_samples.txt"
rmag_anis = "arm_anisotropy.txt"
rmag_res = "aarm_results.txt"
dir_path = '.'
#
# get name of file from command line
#
if '-WD' in args:
ind = args.index('-WD')
dir_path = args[ind + 1]
if "-h" in args:
print main.__doc__
sys.exit()
if "-usr" in args:
ind = args.index("-usr")
user = sys.argv[ind + 1]
if "-f" in args:
ind = args.index("-f")
meas_file = sys.argv[ind + 1]
coord = '-1'
if "-crd" in sys.argv:
ind = sys.argv.index("-crd")
coord = sys.argv[ind + 1]
if coord == 's': coord = '-1'
if coord == 'g': coord = '0'
if coord == 't': coord = '100'
if "-fsa" in args:
ind = args.index("-fsa")
samp_file = sys.argv[ind + 1]
if "-Fa" in args:
ind = args.index("-Fa")
rmag_anis = args[ind + 1]
if "-Fr" in args:
ind = args.index("-Fr")
rmag_res = args[ind + 1]
meas_file = dir_path + '/' + meas_file
samp_file = dir_path + '/' + samp_file
rmag_anis = dir_path + '/' + rmag_anis
rmag_res = dir_path + '/' + rmag_res
# read in data
meas_data, file_type = pmag.magic_read(meas_file)
meas_data = pmag.get_dictitem(meas_data, 'magic_method_codes', 'LP-AN-ARM',
'has')
if file_type != 'magic_measurements':
print file_type
print file_type, "This is not a valid magic_measurements file "
sys.exit()
if coord != '-1': # need to read in sample data
samp_data, file_type = pmag.magic_read(samp_file)
if file_type != 'er_samples':
print file_type
print file_type, "This is not a valid er_samples file "
print "Only specimen coordinates will be calculated"
coord = '-1'
#
# sort the specimen names
#
ssort = []
for rec in meas_data:
spec = rec["er_specimen_name"]
if spec not in ssort: ssort.append(spec)
if len(ssort) > 1:
sids = sorted(ssort)
else:
sids = ssort
#
# work on each specimen
#
specimen = 0
RmagSpecRecs, RmagResRecs = [], []
while specimen < len(sids):
s = sids[specimen]
data = []
RmagSpecRec = {}
RmagResRec = {}
method_codes = []
#
# find the data from the meas_data file for this sample
#
data = pmag.get_dictitem(meas_data, 'er_specimen_name', s, 'T')
#
# find out the number of measurements (9, 12 or 15)
#
npos = len(data) / 2
if npos == 9:
#
# get dec, inc, int and convert to x,y,z
#
B, H, tmpH = pmag.designAARM(
npos) # B matrix made from design matrix for positions
X = []
for rec in data:
Dir = []
Dir.append(float(rec["measurement_dec"]))
Dir.append(float(rec["measurement_inc"]))
Dir.append(float(rec["measurement_magn_moment"]))
X.append(pmag.dir2cart(Dir))
#
# subtract baseline and put in a work array
#
work = numpy.zeros((npos, 3), 'f')
for i in range(npos):
for j in range(3):
work[i][j] = X[2 * i + 1][j] - X[2 * i][j]
#
# calculate tensor elements
# first put ARM components in w vector
#
w = numpy.zeros((npos * 3), 'f')
index = 0
for i in range(npos):
for j in range(3):
w[index] = work[i][j]
index += 1
s = numpy.zeros((6), 'f') # initialize the s matrix
for i in range(6):
for j in range(len(w)):
s[i] += B[i][j] * w[j]
trace = s[0] + s[1] + s[2] # normalize by the trace
for i in range(6):
s[i] = s[i] / trace
a = pmag.s2a(s)
#------------------------------------------------------------
# Calculating dels is different than in the Kappabridge
# routine. Use trace normalized tensor (a) and the applied
# unit field directions (tmpH) to generate model X,Y,Z
# components. Then compare these with the measured values.
#------------------------------------------------------------
S = 0.
comp = numpy.zeros((npos * 3), 'f')
for i in range(npos):
for j in range(3):
index = i * 3 + j
compare = a[j][0] * tmpH[i][0] + a[j][1] * tmpH[i][1] + a[
j][2] * tmpH[i][2]
comp[index] = compare
for i in range(npos * 3):
d = w[i] / trace - comp[i] # del values
S += d * d
nf = float(npos * 3 - 6) # number of degrees of freedom
if S > 0:
sigma = numpy.sqrt(S / nf)
else:
sigma = 0
RmagSpecRec["rmag_anisotropy_name"] = data[0]["er_specimen_name"]
RmagSpecRec["er_location_name"] = data[0]["er_location_name"]
RmagSpecRec["er_specimen_name"] = data[0]["er_specimen_name"]
RmagSpecRec["er_sample_name"] = data[0]["er_sample_name"]
RmagSpecRec["er_site_name"] = data[0]["er_site_name"]
RmagSpecRec["magic_experiment_names"] = RmagSpecRec[
"rmag_anisotropy_name"] + ":AARM"
RmagSpecRec["er_citation_names"] = "This study"
RmagResRec[
"rmag_result_name"] = data[0]["er_specimen_name"] + ":AARM"
RmagResRec["er_location_names"] = data[0]["er_location_name"]
RmagResRec["er_specimen_names"] = data[0]["er_specimen_name"]
RmagResRec["er_sample_names"] = data[0]["er_sample_name"]
RmagResRec["er_site_names"] = data[0]["er_site_name"]
RmagResRec["magic_experiment_names"] = RmagSpecRec[
"rmag_anisotropy_name"] + ":AARM"
RmagResRec["er_citation_names"] = "This study"
if "magic_instrument_codes" in data[0].keys():
RmagSpecRec["magic_instrument_codes"] = data[0][
"magic_instrument_codes"]
else:
RmagSpecRec["magic_instrument_codes"] = ""
RmagSpecRec["anisotropy_type"] = "AARM"
RmagSpecRec[
"anisotropy_description"] = "Hext statistics adapted to AARM"
if coord != '-1': # need to rotate s
# set orientation priorities
SO_methods = []
for rec in samp_data:
if "magic_method_codes" not in rec:
rec['magic_method_codes'] = 'SO-NO'
if "magic_method_codes" in rec:
methlist = rec["magic_method_codes"]
for meth in methlist.split(":"):
if "SO" in meth and "SO-POM" not in meth.strip():
if meth.strip() not in SO_methods:
SO_methods.append(meth.strip())
SO_priorities = pmag.set_priorities(SO_methods, 0)
# continue here
redo, p = 1, 0
if len(SO_methods) <= 1:
az_type = SO_methods[0]
orient = pmag.find_samp_rec(RmagSpecRec["er_sample_name"],
samp_data, az_type)
if orient["sample_azimuth"] != "":
method_codes.append(az_type)
redo = 0
while redo == 1:
if p >= len(SO_priorities):
print "no orientation data for ", s
orient["sample_azimuth"] = ""
orient["sample_dip"] = ""
method_codes.append("SO-NO")
redo = 0
else:
az_type = SO_methods[SO_methods.index(
SO_priorities[p])]
orient = pmag.find_samp_rec(
PmagSpecRec["er_sample_name"], samp_data, az_type)
if orient["sample_azimuth"] != "":
method_codes.append(az_type)
redo = 0
p += 1
az, pl = orient['sample_azimuth'], orient['sample_dip']
s = pmag.dosgeo(s, az, pl) # rotate to geographic coordinates
if coord == '100':
sampe_bed_dir, sample_bed_dip = orient[
'sample_bed_dip_direction'], orient['sample_bed_dip']
s = pmag.dostilt(
s, bed_dir,
bed_dip) # rotate to geographic coordinates
hpars = pmag.dohext(nf, sigma, s)
#
# prepare for output
#
RmagSpecRec["anisotropy_s1"] = '%8.6f' % (s[0])
RmagSpecRec["anisotropy_s2"] = '%8.6f' % (s[1])
RmagSpecRec["anisotropy_s3"] = '%8.6f' % (s[2])
RmagSpecRec["anisotropy_s4"] = '%8.6f' % (s[3])
RmagSpecRec["anisotropy_s5"] = '%8.6f' % (s[4])
RmagSpecRec["anisotropy_s6"] = '%8.6f' % (s[5])
RmagSpecRec["anisotropy_mean"] = '%8.3e' % (trace / 3)
RmagSpecRec["anisotropy_sigma"] = '%8.6f' % (sigma)
RmagSpecRec["anisotropy_unit"] = "Am^2"
RmagSpecRec["anisotropy_n"] = '%i' % (npos)
RmagSpecRec["anisotropy_tilt_correction"] = coord
RmagSpecRec["anisotropy_F"] = '%7.1f ' % (
hpars["F"]
) # used by thellier_gui - must be taken out for uploading
RmagSpecRec["anisotropy_F_crit"] = hpars[
"F_crit"] # used by thellier_gui - must be taken out for uploading
RmagResRec["anisotropy_t1"] = '%8.6f ' % (hpars["t1"])
RmagResRec["anisotropy_t2"] = '%8.6f ' % (hpars["t2"])
RmagResRec["anisotropy_t3"] = '%8.6f ' % (hpars["t3"])
RmagResRec["anisotropy_v1_dec"] = '%7.1f ' % (hpars["v1_dec"])
RmagResRec["anisotropy_v2_dec"] = '%7.1f ' % (hpars["v2_dec"])
RmagResRec["anisotropy_v3_dec"] = '%7.1f ' % (hpars["v3_dec"])
RmagResRec["anisotropy_v1_inc"] = '%7.1f ' % (hpars["v1_inc"])
RmagResRec["anisotropy_v2_inc"] = '%7.1f ' % (hpars["v2_inc"])
RmagResRec["anisotropy_v3_inc"] = '%7.1f ' % (hpars["v3_inc"])
RmagResRec["anisotropy_ftest"] = '%7.1f ' % (hpars["F"])
RmagResRec["anisotropy_ftest12"] = '%7.1f ' % (hpars["F12"])
RmagResRec["anisotropy_ftest23"] = '%7.1f ' % (hpars["F23"])
RmagResRec["result_description"] = 'Critical F: ' + hpars[
"F_crit"] + ';Critical F12/F13: ' + hpars["F12_crit"]
if hpars["e12"] > hpars["e13"]:
RmagResRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
else:
RmagResRec["anisotropy_v1_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v1_zeta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v1_zeta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v1_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v1_eta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v1_eta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
if hpars["e23"] > hpars['e12']:
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
else:
RmagResRec["anisotropy_v2_zeta_semi_angle"] = '%7.1f ' % (
hpars['e12'])
RmagResRec["anisotropy_v2_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v2_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v3_eta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v3_eta_dec"] = '%7.1f ' % (
hpars['v2_dec'])
RmagResRec["anisotropy_v3_eta_inc"] = '%7.1f ' % (
hpars['v2_inc'])
RmagResRec["anisotropy_v3_zeta_semi_angle"] = '%7.1f ' % (
hpars['e13'])
RmagResRec["anisotropy_v3_zeta_dec"] = '%7.1f ' % (
hpars['v1_dec'])
RmagResRec["anisotropy_v3_zeta_inc"] = '%7.1f ' % (
hpars['v1_inc'])
RmagResRec["anisotropy_v2_eta_semi_angle"] = '%7.1f ' % (
hpars['e23'])
RmagResRec["anisotropy_v2_eta_dec"] = '%7.1f ' % (
hpars['v3_dec'])
RmagResRec["anisotropy_v2_eta_inc"] = '%7.1f ' % (
hpars['v3_inc'])
RmagResRec["tilt_correction"] = '-1'
RmagResRec["anisotropy_type"] = 'AARM'
RmagResRec["magic_method_codes"] = 'LP-AN-ARM:AE-H'
RmagSpecRec["magic_method_codes"] = 'LP-AN-ARM:AE-H'
RmagResRec["magic_software_packages"] = pmag.get_version()
RmagSpecRec["magic_software_packages"] = pmag.get_version()
specimen += 1
RmagSpecRecs.append(RmagSpecRec)
RmagResRecs.append(RmagResRec)
else:
print 'skipping specimen ', s, ' only 9 positions supported', '; this has ', npos
specimen += 1
if rmag_anis == "": rmag_anis = "rmag_anisotropy.txt"
pmag.magic_write(rmag_anis, RmagSpecRecs, 'rmag_anisotropy')
print "specimen tensor elements stored in ", rmag_anis
if rmag_res == "": rmag_res = "rmag_results.txt"
pmag.magic_write(rmag_res, RmagResRecs, 'rmag_results')
print "specimen statistics and eigenparameters stored in ", rmag_res
def main(command_line=True, **kwargs):
"""
NAME
sio_magic.py
DESCRIPTION
converts SIO .mag format files to magic_measurements format files
SYNTAX
sio_magic.py [command line options]
OPTIONS
-h: prints the help message and quits.
-usr USER: identify user, default is ""
-f FILE: specify .mag format input file, required
-fsa SAMPFILE : specify er_samples.txt file relating samples, site and locations names,default is none -- values in SAMPFILE will override selections for -loc (location), -spc (designate specimen), and -ncn (sample-site naming convention)
-F FILE: specify output file, default is magic_measurements.txt
-Fsy: specify er_synthetics file, default is er_sythetics.txt
-LP [colon delimited list of protocols, include all that apply]
AF: af demag
T: thermal including thellier but not trm acquisition
S: Shaw method
I: IRM (acquisition)
I3d: 3D IRM experiment
N: NRM only
TRM: trm acquisition
ANI: anisotropy experiment
D: double AF demag
G: triple AF demag (GRM protocol)
CR: cooling rate experiment.
The treatment coding of the measurement file should be: XXX.00,XXX.10, XXX.20 ...XX.70 etc. (XXX.00 is optional)
where XXX in the temperature and .10,.20... are running numbers of the cooling rates steps.
XXX.00 is optional zerofield baseline. XXX.70 is alteration check.
syntax in sio_magic is: -LP CR xxx,yyy,zzz,..... xxx -A
where xxx, yyy, zzz...xxx are cooling time in [K/minutes], seperated by comma, ordered at the same order as XXX.10,XXX.20 ...XX.70
if you use a zerofield step then no need to specify the cooling rate for the zerofield
It is important to add to the command line the -A option so the measurements will not be averaged.
But users need to make sure that there are no duplicate measurements in the file
-V [1,2,3] units of IRM field in volts using ASC coil #1,2 or 3
-spc NUM : specify number of characters to designate a specimen, default = 0
-loc LOCNAME : specify location/study name, must have either LOCNAME or SAMPFILE or be a synthetic
-syn INST TYPE: sets these specimens as synthetics created at institution INST and of type TYPE
-ins INST : specify which demag instrument was used (e.g, SIO-Suzy or SIO-Odette),default is ""
-dc B PHI THETA: dc lab field (in micro tesla) and phi,theta, default is none
NB: use PHI, THETA = -1 -1 to signal that it changes, i.e. in anisotropy experiment
-ac B : peak AF field (in mT) for ARM acquisition, default is none
-ncn NCON: specify naming convention: default is #1 below
-A: don't average replicate measurements
Sample naming convention:
[1] XXXXY: where XXXX is an arbitrary length site designation and Y
is the single character sample designation. e.g., TG001a is the
first sample from site TG001. [default]
[2] XXXX-YY: YY sample from site XXXX (XXX, YY of arbitary length)
[3] XXXX.YY: YY sample from site XXXX (XXX, YY of arbitary length)
[4-Z] XXXX[YYY]: YYY is sample designation with Z characters from site XXX
[5] site name same as sample
[6] site is entered under a separate column NOT CURRENTLY SUPPORTED
[7-Z] [XXXX]YYY: XXXX is site designation with Z characters with sample name XXXXYYYY
NB: all others you will have to customize your self
or e-mail [email protected] for help.
[8] synthetic - has no site name
[9] ODP naming convention
INPUT
Best to put separate experiments (all AF, thermal, thellier, trm aquisition, Shaw, etc.) in
seperate .mag files (eg. af.mag, thermal.mag, etc.)
Format of SIO .mag files:
Spec Treat CSD Intensity Declination Inclination [optional metadata string]
Spec: specimen name
Treat: treatment step
XXX T in Centigrade
XXX AF in mT
for special experiments:
Thellier:
XXX.0 first zero field step
XXX.1 first in field step [XXX.0 and XXX.1 can be done in any order]
XXX.2 second in-field step at lower temperature (pTRM check)
XXX.3 second zero-field step after infield (pTRM check step)
XXX.3 MUST be done in this order [XXX.0, XXX.1 [optional XXX.2] XXX.3]
AARM:
X.00 baseline step (AF in zero bias field - high peak field)
X.1 ARM step (in field step) where
X is the step number in the 15 position scheme
(see Appendix to Lecture 13 - http://magician.ucsd.edu/Essentials_2)
ATRM:
X.00 optional baseline
X.1 ATRM step (+X)
X.2 ATRM step (+Y)
X.3 ATRM step (+Z)
X.4 ATRM step (-X)
X.5 ATRM step (-Y)
X.6 ATRM step (-Z)
X.7 optional alteration check (+X)
TRM:
XXX.YYY XXX is temperature step of total TRM
YYY is dc field in microtesla
Intensity assumed to be total moment in 10^3 Am^2 (emu)
Declination: Declination in specimen coordinate system
Inclination: Declination in specimen coordinate system
Optional metatdata string: mm/dd/yy;hh:mm;[dC,mT];xx.xx;UNITS;USER;INST;NMEAS
hh in 24 hours.
dC or mT units of treatment XXX (see Treat above) for thermal or AF respectively
xx.xxx DC field
UNITS of DC field (microT, mT)
INST: instrument code, number of axes, number of positions (e.g., G34 is 2G, three axes,
measured in four positions)
NMEAS: number of measurements in a single position (1,3,200...)
"""
# initialize some stuff
mag_file = None
codelist = None
infile_type="mag"
noave=0
methcode,inst="LP-NO",""
phi,theta,peakfield,labfield=0,0,0,0
pTRM,MD,samp_con,Z=0,0,'1',1
dec=[315,225,180,135,45,90,270,270,270,90,180,180,0,0,0]
inc=[0,0,0,0,0,-45,-45,0,45,45,45,-45,-90,-45,45]
tdec=[0,90,0,180,270,0,0,90,0]
tinc=[0,0,90,0,0,-90,0,0,90]
missing=1
demag="N"
er_location_name=""
citation='This study'
args=sys.argv
fmt='old'
syn=0
synfile='er_synthetics.txt'
samp_infile,Samps='',[]
trm=0
irm=0
specnum=0
coil=""
mag_file=""
#
# get command line arguments
#
meas_file="magic_measurements.txt"
user=""
if not command_line:
user = kwargs.get('user', '')
meas_file = kwargs.get('meas_file', '')
syn_file = kwargs.get('syn_file', '')
mag_file = kwargs.get('mag_file', '')
labfield = kwargs.get('labfield', '')
if labfield:
labfield = float(labfield) *1e-6
else:
labfield = 0
phi = kwargs.get('phi', 0)
if phi:
phi = float(phi)
else:
phi = 0
theta = kwargs.get('theta', 0)
if theta:
theta=float(theta)
else:
theta = 0
peakfield = kwargs.get('peakfield', 0)
if peakfield:
peakfield=float(peakfield) *1e-3
else:
peakfield = 0
specnum = kwargs.get('specnum', 0)
samp_con = kwargs.get('samp_con', '1')
er_location_name = kwargs.get('er_location_name', '')
samp_infile = kwargs.get('samp_infile', '')
syn = kwargs.get('syn', 0)
institution = kwargs.get('institution', '')
syntype = kwargs.get('syntype', '')
inst = kwargs.get('inst', '')
noave = kwargs.get('noave', 0)
codelist = kwargs.get('codelist', '')
coil = kwargs.get('coil', '')
cooling_rates = kwargs.get('cooling_rates', '')
if command_line:
if "-h" in args:
print(main.__doc__)
return False
if "-usr" in args:
ind=args.index("-usr")
user=args[ind+1]
if '-F' in args:
ind=args.index("-F")
meas_file=args[ind+1]
if '-Fsy' in args:
ind=args.index("-Fsy")
synfile=args[ind+1]
if '-f' in args:
ind=args.index("-f")
mag_file=args[ind+1]
if "-dc" in args:
ind=args.index("-dc")
labfield=float(args[ind+1])*1e-6
phi=float(args[ind+2])
theta=float(args[ind+3])
if "-ac" in args:
ind=args.index("-ac")
peakfield=float(args[ind+1])*1e-3
if "-spc" in args:
ind=args.index("-spc")
specnum=int(args[ind+1])
if "-loc" in args:
ind=args.index("-loc")
er_location_name=args[ind+1]
if "-fsa" in args:
ind=args.index("-fsa")
samp_infile = args[ind+1]
if '-syn' in args:
syn=1
ind=args.index("-syn")
institution=args[ind+1]
syntype=args[ind+2]
if '-fsy' in args:
ind=args.index("-fsy")
synfile=args[ind+1]
if "-ins" in args:
ind=args.index("-ins")
inst=args[ind+1]
if "-A" in args: noave=1
if "-ncn" in args:
ind=args.index("-ncn")
samp_con=sys.argv[ind+1]
if '-LP' in args:
ind=args.index("-LP")
codelist=args[ind+1]
if "-V" in args:
ind=args.index("-V")
coil=args[ind+1]
# make sure all initial values are correctly set up (whether they come from the command line or a GUI)
if samp_infile:
Samps, file_type = pmag.magic_read(samp_infile)
if coil:
coil = str(coil)
methcode="LP-IRM"
irmunits = "V"
if coil not in ["1","2","3"]:
print(main.__doc__)
print('not a valid coil specification')
return False, '{} is not a valid coil specification'.format(coil)
if mag_file:
try:
#with open(mag_file,'r') as finput:
# lines = finput.readlines()
lines=pmag.open_file(mag_file)
except:
print("bad mag file name")
return False, "bad mag file name"
if not mag_file:
print(main.__doc__)
print("mag_file field is required option")
return False, "mag_file field is required option"
if specnum!=0:
specnum=-specnum
#print 'samp_con:', samp_con
if samp_con:
if "4" == samp_con[0]:
if "-" not in samp_con:
print("naming convention option [4] must be in form 4-Z where Z is an integer")
print('---------------')
return False, "naming convention option [4] must be in form 4-Z where Z is an integer"
else:
Z=samp_con.split("-")[1]
samp_con="4"
if "7" == samp_con[0]:
if "-" not in samp_con:
print("option [7] must be in form 7-Z where Z is an integer")
return False, "option [7] must be in form 7-Z where Z is an integer"
else:
Z=samp_con.split("-")[1]
samp_con="7"
if codelist:
codes=codelist.split(':')
if "AF" in codes:
demag='AF'
if'-dc' not in args: methcode="LT-AF-Z"
if'-dc' in args: methcode="LT-AF-I"
if "T" in codes:
demag="T"
if '-dc' not in args: methcode="LT-T-Z"
if '-dc' in args: methcode="LT-T-I"
if "I" in codes:
methcode="LP-IRM"
irmunits="mT"
if "I3d" in codes:
methcode="LT-T-Z:LP-IRM-3D"
if "S" in codes:
demag="S"
methcode="LP-PI-TRM:LP-PI-ALT-AFARM"
trm_labfield=labfield
ans=input("DC lab field for ARM step: [50uT] ")
if ans=="":
arm_labfield=50e-6
else:
arm_labfield=float(ans)*1e-6
ans=input("temperature for total trm step: [600 C] ")
if ans=="":
trm_peakT=600+273 # convert to kelvin
else:
trm_peakT=float(ans)+273 # convert to kelvin
if "G" in codes: methcode="LT-AF-G"
if "D" in codes: methcode="LT-AF-D"
if "TRM" in codes:
demag="T"
trm=1
if "CR" in codes:
demag="T"
cooling_rate_experiment=1
if command_line:
ind=args.index("CR")
cooling_rates=args[ind+1]
cooling_rates_list=cooling_rates.split(',')
else:
cooling_rates_list=str(cooling_rates).split(',')
if demag=="T" and "ANI" in codes:
methcode="LP-AN-TRM"
if demag=="T" and "CR" in codes:
methcode="LP-CR-TRM"
if demag=="AF" and "ANI" in codes:
methcode="LP-AN-ARM"
if labfield==0: labfield=50e-6
if peakfield==0: peakfield=.180
SynRecs,MagRecs=[],[]
version_num=pmag.get_version()
##################################
if 1:
#if infile_type=="SIO format":
for line in lines:
instcode=""
if len(line)>2:
SynRec={}
MagRec={}
MagRec['er_location_name']=er_location_name
MagRec['magic_software_packages']=version_num
MagRec["treatment_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["measurement_temp"]='%8.3e' % (273) # room temp in kelvin
MagRec["treatment_ac_field"]='0'
MagRec["treatment_dc_field"]='0'
MagRec["treatment_dc_field_phi"]='0'
MagRec["treatment_dc_field_theta"]='0'
meas_type="LT-NO"
rec=line.split()
if rec[1]==".00":rec[1]="0.00"
treat=rec[1].split('.')
if methcode=="LP-IRM":
if irmunits=='mT':
labfield=float(treat[0])*1e-3
else:
labfield=pmag.getfield(irmunits,coil,treat[0])
if rec[1][0]!="-":
phi,theta=0.,90.
else:
phi,theta=0.,-90.
meas_type="LT-IRM"
MagRec["treatment_dc_field"]='%8.3e'%(labfield)
MagRec["treatment_dc_field_phi"]='%7.1f'%(phi)
MagRec["treatment_dc_field_theta"]='%7.1f'%(theta)
if len(rec)>6:
code1=rec[6].split(';') # break e.g., 10/15/02;7:45 indo date and time
if len(code1)==2: # old format with AM/PM
missing=0
code2=code1[0].split('/') # break date into mon/day/year
code3=rec[7].split(';') # break e.g., AM;C34;200 into time;instr/axes/measuring pos;number of measurements
yy=int(code2[2])
if yy <90:
yyyy=str(2000+yy)
else: yyyy=str(1900+yy)
mm=int(code2[0])
if mm<10:
mm="0"+str(mm)
else: mm=str(mm)
dd=int(code2[1])
if dd<10:
dd="0"+str(dd)
else: dd=str(dd)
time=code1[1].split(':')
hh=int(time[0])
if code3[0]=="PM":hh=hh+12
if hh<10:
hh="0"+str(hh)
else: hh=str(hh)
min=int(time[1])
if min<10:
min= "0"+str(min)
else: min=str(min)
MagRec["measurement_date"]=yyyy+":"+mm+":"+dd+":"+hh+":"+min+":00.00"
MagRec["measurement_time_zone"]='SAN'
if inst=="":
if code3[1][0]=='C':instcode='SIO-bubba'
if code3[1][0]=='G':instcode='SIO-flo'
else:
instcode=''
MagRec["measurement_positions"]=code3[1][2]
elif len(code1)>2: # newest format (cryo7 or later)
if "LP-AN-ARM" not in methcode:labfield=0
fmt='new'
date=code1[0].split('/') # break date into mon/day/year
yy=int(date[2])
if yy <90:
yyyy=str(2000+yy)
else: yyyy=str(1900+yy)
mm=int(date[0])
if mm<10:
mm="0"+str(mm)
else: mm=str(mm)
dd=int(date[1])
if dd<10:
dd="0"+str(dd)
else: dd=str(dd)
time=code1[1].split(':')
hh=int(time[0])
if hh<10:
hh="0"+str(hh)
else: hh=str(hh)
min=int(time[1])
if min<10:
min= "0"+str(min)
else:
min=str(min)
MagRec["measurement_date"]=yyyy+":"+mm+":"+dd+":"+hh+":"+min+":00.00"
MagRec["measurement_time_zone"]='SAN'
if inst=="":
if code1[6][0]=='C':
instcode='SIO-bubba'
if code1[6][0]=='G':
instcode='SIO-flo'
else:
instcode=''
if len(code1)>1:
MagRec["measurement_positions"]=code1[6][2]
else:
MagRec["measurement_positions"]=code1[7] # takes care of awkward format with bubba and flo being different
if user=="":user=code1[5]
if code1[2][-1]=='C':
demag="T"
if code1[4]=='microT' and float(code1[3])!=0. and "LP-AN-ARM" not in methcode: labfield=float(code1[3])*1e-6
if code1[2]=='mT' and methcode!="LP-IRM":
demag="AF"
if code1[4]=='microT' and float(code1[3])!=0.: labfield=float(code1[3])*1e-6
if code1[4]=='microT' and labfield!=0. and meas_type!="LT-IRM":
phi,theta=0.,-90.
if demag=="T": meas_type="LT-T-I"
if demag=="AF": meas_type="LT-AF-I"
MagRec["treatment_dc_field"]='%8.3e'%(labfield)
MagRec["treatment_dc_field_phi"]='%7.1f'%(phi)
MagRec["treatment_dc_field_theta"]='%7.1f'%(theta)
if code1[4]=='' or labfield==0. and meas_type!="LT-IRM":
if demag=='T':meas_type="LT-T-Z"
if demag=="AF":meas_type="LT-AF-Z"
MagRec["treatment_dc_field"]='0'
if syn==0:
MagRec["er_specimen_name"]=rec[0]
MagRec["er_synthetic_name"]=""
MagRec["er_site_name"]=""
if specnum!=0:
MagRec["er_sample_name"]=rec[0][:specnum]
else:
MagRec["er_sample_name"]=rec[0]
if samp_infile and Samps: # if samp_infile was provided AND yielded sample data
samp=pmag.get_dictitem(Samps,'er_sample_name',MagRec['er_sample_name'],'T')
if len(samp)>0:
MagRec["er_location_name"]=samp[0]["er_location_name"]
MagRec["er_site_name"]=samp[0]["er_site_name"]
else:
MagRec['er_location_name']=''
MagRec["er_site_name"]=''
elif int(samp_con)!=6:
site=pmag.parse_site(MagRec['er_sample_name'],samp_con,Z)
MagRec["er_site_name"]=site
if MagRec['er_site_name']=="":
print('No site name found for: ',MagRec['er_specimen_name'],MagRec['er_sample_name'])
if MagRec["er_location_name"]=="":
print('no location name for: ',MagRec["er_specimen_name"])
else:
MagRec["er_specimen_name"]=rec[0]
if specnum!=0:
MagRec["er_sample_name"]=rec[0][:specnum]
else:
MagRec["er_sample_name"]=rec[0]
MagRec["er_site_name"]=""
MagRec["er_synthetic_name"]=MagRec["er_specimen_name"]
SynRec["er_synthetic_name"]=MagRec["er_specimen_name"]
site=pmag.parse_site(MagRec['er_sample_name'],samp_con,Z)
SynRec["synthetic_parent_sample"]=site
SynRec["er_citation_names"]="This study"
SynRec["synthetic_institution"]=institution
SynRec["synthetic_type"]=syntype
SynRecs.append(SynRec)
if float(rec[1])==0:
pass
elif demag=="AF":
if methcode != "LP-AN-ARM":
MagRec["treatment_ac_field"]='%8.3e' %(float(rec[1])*1e-3) # peak field in tesla
if meas_type=="LT-AF-Z": MagRec["treatment_dc_field"]='0'
else: # AARM experiment
if treat[1][0]=='0':
meas_type="LT-AF-Z:LP-AN-ARM:"
MagRec["treatment_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MagRec["treatment_dc_field"]='%8.3e'%(0)
if labfield!=0 and methcode!="LP-AN-ARM": print("Warning - inconsistency in mag file with lab field - overriding file with 0")
else:
meas_type="LT-AF-I:LP-AN-ARM"
ipos=int(treat[0])-1
MagRec["treatment_dc_field_phi"]='%7.1f' %(dec[ipos])
MagRec["treatment_dc_field_theta"]='%7.1f'% (inc[ipos])
MagRec["treatment_dc_field"]='%8.3e'%(labfield)
MagRec["treatment_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
elif demag=="T" and methcode == "LP-AN-TRM":
MagRec["treatment_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if treat[1][0]=='0':
meas_type="LT-T-Z:LP-AN-TRM"
MagRec["treatment_dc_field"]='%8.3e'%(0)
MagRec["treatment_dc_field_phi"]='0'
MagRec["treatment_dc_field_theta"]='0'
else:
MagRec["treatment_dc_field"]='%8.3e'%(labfield)
if treat[1][0]=='7': # alteration check as final measurement
meas_type="LT-PTRM-I:LP-AN-TRM"
else:
meas_type="LT-T-I:LP-AN-TRM"
# find the direction of the lab field in two ways:
# (1) using the treatment coding (XX.1=+x, XX.2=+y, XX.3=+z, XX.4=-x, XX.5=-y, XX.6=-z)
ipos_code=int(treat[1][0])-1
# (2) using the magnetization
DEC=float(rec[4])
INC=float(rec[5])
if INC < 45 and INC > -45:
if DEC>315 or DEC<45: ipos_guess=0
if DEC>45 and DEC<135: ipos_guess=1
if DEC>135 and DEC<225: ipos_guess=3
if DEC>225 and DEC<315: ipos_guess=4
else:
if INC >45: ipos_guess=2
if INC <-45: ipos_guess=5
# prefer the guess over the code
ipos=ipos_guess
MagRec["treatment_dc_field_phi"]='%7.1f' %(tdec[ipos])
MagRec["treatment_dc_field_theta"]='%7.1f'% (tinc[ipos])
# check it
if ipos_guess!=ipos_code and treat[1][0]!='7':
print("-E- ERROR: check specimen %s step %s, ATRM measurements, coding does not match the direction of the lab field!"%(rec[0],".".join(list(treat))))
elif demag=="S": # Shaw experiment
if treat[1][1]=='0':
if int(treat[0])!=0:
MagRec["treatment_ac_field"]='%8.3e' % (float(treat[0])*1e-3) # AF field in tesla
MagRec["treatment_dc_field"]='0'
meas_type="LT-AF-Z" # first AF
else:
meas_type="LT-NO"
MagRec["treatment_ac_field"]='0'
MagRec["treatment_dc_field"]='0'
elif treat[1][1]=='1':
if int(treat[0])==0:
MagRec["treatment_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MagRec["treatment_dc_field"]='%8.3e'%(arm_labfield)
MagRec["treatment_dc_field_phi"]='%7.1f'%(phi)
MagRec["treatment_dc_field_theta"]='%7.1f'%(theta)
meas_type="LT-AF-I"
else:
MagRec["treatment_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MagRec["treatment_dc_field"]='0'
meas_type="LT-AF-Z"
elif treat[1][1]=='2':
if int(treat[0])==0:
MagRec["treatment_ac_field"]='0'
MagRec["treatment_dc_field"]='%8.3e'%(trm_labfield)
MagRec["treatment_dc_field_phi"]='%7.1f'%(phi)
MagRec["treatment_dc_field_theta"]='%7.1f'%(theta)
MagRec["treatment_temp"]='%8.3e' % (trm_peakT)
meas_type="LT-T-I"
else:
MagRec["treatment_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MagRec["treatment_dc_field"]='0'
meas_type="LT-AF-Z"
elif treat[1][1]=='3':
if int(treat[0])==0:
MagRec["treatment_ac_field"]='%8.3e' %(peakfield) # peak field in tesla
MagRec["treatment_dc_field"]='%8.3e'%(arm_labfield)
MagRec["treatment_dc_field_phi"]='%7.1f'%(phi)
MagRec["treatment_dc_field_theta"]='%7.1f'%(theta)
meas_type="LT-AF-I"
else:
MagRec["treatment_ac_field"]='%8.3e' % ( float(treat[0])*1e-3) # AF field in tesla
MagRec["treatment_dc_field"]='0'
meas_type="LT-AF-Z"
# Cooling rate experient # added by rshaar
elif demag=="T" and methcode == "LP-CR-TRM":
MagRec["treatment_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if treat[1][0]=='0':
meas_type="LT-T-Z:LP-CR-TRM"
MagRec["treatment_dc_field"]='%8.3e'%(0)
MagRec["treatment_dc_field_phi"]='0'
MagRec["treatment_dc_field_theta"]='0'
else:
MagRec["treatment_dc_field"]='%8.3e'%(labfield)
if treat[1][0]=='7': # alteration check as final measurement
meas_type="LT-PTRM-I:LP-CR-TRM"
else:
meas_type="LT-T-I:LP-CR-TRM"
MagRec["treatment_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MagRec["treatment_dc_field_theta"]='%7.1f' % (theta) # labfield theta
indx=int(treat[1][0])-1
# alteration check matjed as 0.7 in the measurement file
if indx==6:
cooling_time= cooling_rates_list[-1]
else:
cooling_time=cooling_rates_list[indx]
MagRec["measurement_description"]="cooling_rate"+":"+cooling_time+":"+"K/min"
elif demag!='N':
if len(treat)==1:treat.append('0')
MagRec["treatment_temp"]='%8.3e' % (float(treat[0])+273.) # temp in kelvin
if trm==0: # demag=T and not trmaq
if treat[1][0]=='0':
meas_type="LT-T-Z"
else:
MagRec["treatment_dc_field"]='%8.3e' % (labfield) # labfield in tesla (convert from microT)
MagRec["treatment_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MagRec["treatment_dc_field_theta"]='%7.1f' % (theta) # labfield theta
if treat[1][0]=='1':meas_type="LT-T-I" # in-field thermal step
if treat[1][0]=='2':
meas_type="LT-PTRM-I" # pTRM check
pTRM=1
if treat[1][0]=='3':
MagRec["treatment_dc_field"]='0' # this is a zero field step
meas_type="LT-PTRM-MD" # pTRM tail check
else:
labfield=float(treat[1])*1e-6
MagRec["treatment_dc_field"]='%8.3e' % (labfield) # labfield in tesla (convert from microT)
MagRec["treatment_dc_field_phi"]='%7.1f' % (phi) # labfield phi
MagRec["treatment_dc_field_theta"]='%7.1f' % (theta) # labfield theta
meas_type="LT-T-I:LP-TRM" # trm acquisition experiment
MagRec["measurement_csd"]=rec[2]
MagRec["measurement_magn_moment"]='%10.3e'% (float(rec[3])*1e-3) # moment in Am^2 (from emu)
MagRec["measurement_dec"]=rec[4]
MagRec["measurement_inc"]=rec[5]
MagRec["magic_instrument_codes"]=instcode
MagRec["er_analyst_mail_names"]=user
MagRec["er_citation_names"]=citation
if "LP-IRM-3D" in methcode : meas_type=methcode
#MagRec["magic_method_codes"]=methcode.strip(':')
MagRec["magic_method_codes"]=meas_type
MagRec["measurement_flag"]='g'
MagRec["er_specimen_name"]=rec[0]
if 'std' in rec[0]:
MagRec["measurement_standard"]='s'
else:
MagRec["measurement_standard"]='u'
MagRec["measurement_number"]='1'
#print MagRec['treatment_temp']
MagRecs.append(MagRec)
MagOuts=pmag.measurements_methods(MagRecs,noave)
pmag.magic_write(meas_file,MagOuts,'magic_measurements')
print("results put in ",meas_file)
if len(SynRecs)>0:
pmag.magic_write(synfile,SynRecs,'er_synthetics')
print("synthetics put in ",synfile)
return True, meas_file
def main():
"""
NAME
dmag_magic.py
DESCRIPTION
plots intensity decay curves for demagnetization experiments
SYNTAX
dmag_magic -h [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-LT [AF,T,M]: specify lab treatment type, default AF
-XLP [PI]: exclude specific lab protocols (for example, method codes like LP-PI)
-N do not normalize by NRM magnetization
-sav save plots silently and quit
-fmt [svg,jpg,png,pdf] set figure format [default is svg]
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG={} # plot dictionary
FIG['demag']=1 # demag is figure 1
in_file,plot_key,LT='magic_measurements.txt','er_location_name',"LT-AF-Z"
XLP=""
norm=1
LT='LT-AF-Z'
units,dmag_key='T','treatment_ac_field'
plot=0
fmt='svg'
if len(sys.argv)>1:
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-N' in sys.argv: norm=0
if '-sav' in sys.argv:
plot=1
if '-f' in sys.argv:
ind=sys.argv.index("-f")
in_file=sys.argv[ind+1]
if '-fmt' in sys.argv:
ind=sys.argv.index("-fmt")
fmt=sys.argv[ind+1]
if '-obj' in sys.argv:
ind=sys.argv.index('-obj')
plot_by=sys.argv[ind+1]
if plot_by=='sit':plot_key='er_site_name'
if plot_by=='sam':plot_key='er_sample_name'
if plot_by=='spc':plot_key='er_specimen_name'
if '-XLP' in sys.argv:
ind=sys.argv.index("-XLP")
XLP=sys.argv[ind+1] # get lab protocol for excluding
if '-LT' in sys.argv:
ind=sys.argv.index("-LT")
LT='LT-'+sys.argv[ind+1]+'-Z' # get lab treatment for plotting
if LT=='LT-T-Z':
units,dmag_key='K','treatment_temp'
elif LT=='LT-AF-Z':
units,dmag_key='T','treatment_ac_field'
elif LT=='LT-M-Z':
units,dmag_key='J','treatment_mw_energy'
else:
units='U'
data,file_type=pmag.magic_read(in_file)
sids=pmag.get_specs(data)
pmagplotlib.plot_init(FIG['demag'],5,5)
print len(data),' records read from ',in_file
#
#
# find desired intensity data
#
#
plotlist,intlist=[],['measurement_magnitude','measurement_magn_moment','measurement_magn_volume','measurement_magn_mass']
IntMeths=[]
FixData=[]
for rec in data:
meths=[]
methcodes=rec['magic_method_codes'].split(':')
for meth in methcodes:meths.append(meth.strip())
for key in rec.keys():
if key in intlist and rec[key]!="":
if key not in IntMeths:IntMeths.append(key)
if rec[plot_key] not in plotlist and LT in meths: plotlist.append(rec[plot_key])
if 'measurement_flag' not in rec.keys():rec['measurement_flag']='g'
FixData.append(rec)
plotlist.sort()
if len(IntMeths)==0:
print 'No intensity information found'
sys.exit()
data=FixData
int_key=IntMeths[0] # plot first intensity method found - normalized to initial value anyway - doesn't matter which used
for plt in plotlist:
if plot==0: print plt,'plotting by: ',plot_key
PLTblock=pmag.get_dictitem(data,plot_key,plt,'T') # fish out all the data for this type of plot
PLTblock=pmag.get_dictitem(PLTblock,'magic_method_codes',LT,'has') # fish out all the dmag for this experiment type
PLTblock=pmag.get_dictitem(PLTblock,int_key,'','F') # get all with this intensity key non-blank
if XLP!="":PLTblock=pmag.get_dictitem(PLTblock,'magic_method_codes',XLP,'not') # reject data with XLP in method_code
if len(PLTblock)>2:
title=PLTblock[0][plot_key]
spcs=[]
for rec in PLTblock:
if rec['er_specimen_name'] not in spcs:spcs.append(rec['er_specimen_name'])
for spc in spcs:
SPCblock=pmag.get_dictitem(PLTblock,'er_specimen_name',spc,'T') # plot specimen by specimen
INTblock=[]
for rec in SPCblock:
INTblock.append([float(rec[dmag_key]),0,0,float(rec[int_key]),1,rec['measurement_flag']])
if len(INTblock)>2:
pmagplotlib.plotMT(FIG['demag'],INTblock,title,0,units,norm)
if plot==1:
files={}
for key in FIG.keys():
files[key]=title+'_'+LT+'.'+fmt
pmagplotlib.saveP(FIG,files)
sys.exit()
else:
pmagplotlib.drawFIGS(FIG)
ans=raw_input(" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans=='q':sys.exit()
if ans=="a":
files={}
for key in FIG.keys():
files[key]=title+'_'+LT+'.svg'
pmagplotlib.saveP(FIG,files)
pmagplotlib.clearFIG(FIG['demag'])
def main():
"""
NAME
site_edit_magic.py
DESCRIPTION
makes equal area projections site by site
from pmag_specimens.txt file with
Fisher confidence ellipse using McFadden and McElhinny (1988)
technique for combining lines and planes
allows testing and reject specimens for bad orientations
SYNTAX
site_edit_magic.py [command line options]
OPTIONS
-h: prints help and quits
-f: specify pmag_specimen format file, default is pmag_specimens.txt
-fsa: specify er_samples.txt file
-exc: use existing pmag_criteria.txt file
-N: reset all sample flags to good
OUPUT
edited er_samples.txt file
"""
dir_path = '.'
FIG = {} # plot dictionary
FIG['eqarea'] = 1 # eqarea is figure 1
in_file = 'pmag_specimens.txt'
sampfile = 'er_samples.txt'
out_file = ""
fmt, plot = 'svg', 1
Crits = ""
M, N = 180., 1
repeat = ''
renew = 0
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path = sys.argv[ind + 1]
if '-f' in sys.argv:
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
if '-fsa' in sys.argv:
ind = sys.argv.index("-fsa")
sampfile = sys.argv[ind + 1]
if '-exc' in sys.argv:
Crits, file_type = pmag.magic_read(dir_path + '/pmag_criteria.txt')
for crit in Crits:
if crit['pmag_criteria_code'] == 'DE-SPEC':
M = float(crit['specimen_mad'])
N = float(crit['specimen_n'])
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-N' in sys.argv: renew = 1
#
if in_file[0] != "/": in_file = dir_path + '/' + in_file
if sampfile[0] != "/": sampfile = dir_path + '/' + sampfile
crd = 's'
Specs, file_type = pmag.magic_read(in_file)
if file_type != 'pmag_specimens':
print(' bad pmag_specimen input file')
sys.exit()
Samps, file_type = pmag.magic_read(sampfile)
if file_type != 'er_samples':
print(' bad er_samples input file')
sys.exit()
SO_methods = []
for rec in Samps:
if 'sample_orientation_flag' not in list(rec.keys()):
rec['sample_orientation_flag'] = 'g'
if 'sample_description' not in list(rec.keys()):
rec['sample_description'] = ''
if renew == 1:
rec['sample_orientation_flag'] = 'g'
description = rec['sample_description']
if '#' in description:
newdesc = ""
c = 0
while description[c] != '#' and c < len(
description) - 1: # look for first pound sign
newdesc = newdesc + description[c]
c += 1
while description[c] == '#':
c += 1 # skip first set of pound signs
while description[c] != '#':
c += 1 # find second set of pound signs
while description[c] == '#' and c < len(description) - 1:
c += 1 # skip second set of pound signs
while c < len(description) - 1: # look for first pound sign
newdesc = newdesc + description[c]
c += 1
rec['sample_description'] = newdesc # edit out old comment about orientations
if "magic_method_codes" in rec:
methlist = rec["magic_method_codes"]
for meth in methlist.split(":"):
if "SO" in meth.strip() and "SO-POM" not in meth.strip():
if meth.strip() not in SO_methods:
SO_methods.append(meth.strip())
pmag.magic_write(sampfile, Samps, 'er_samples')
SO_priorities = pmag.set_priorities(SO_methods, 0)
sitelist = []
for rec in Specs:
if rec['er_site_name'] not in sitelist:
sitelist.append(rec['er_site_name'])
sitelist.sort()
EQ = {}
EQ['eqarea'] = 1
pmagplotlib.plot_init(EQ['eqarea'], 5, 5)
k = 0
while k < len(sitelist):
site = sitelist[k]
print(site)
data = []
ThisSiteSpecs = pmag.get_dictitem(Specs, 'er_site_name', site, 'T')
ThisSiteSpecs = pmag.get_dictitem(ThisSiteSpecs,
'specimen_tilt_correction', '-1',
'T') # get all the unoriented data
for spec in ThisSiteSpecs:
if spec['specimen_mad'] != "" and spec[
'specimen_n'] != "" and float(
spec['specimen_mad']) <= M and float(
spec['specimen_n']) >= N:
# good spec, now get orientation....
redo, p = 1, 0
if len(SO_methods) <= 1:
az_type = SO_methods[0]
orient = pmag.find_samp_rec(spec["er_sample_name"], Samps,
az_type)
redo = 0
while redo == 1:
if p >= len(SO_priorities):
print("no orientation data for ",
spec['er_sample_name'])
orient["sample_azimuth"] = ""
orient["sample_dip"] = ""
redo = 0
else:
az_type = SO_methods[SO_methods.index(
SO_priorities[p])]
orient = pmag.find_samp_rec(spec["er_sample_name"],
Samps, az_type)
if orient["sample_azimuth"] != "":
redo = 0
p += 1
if orient['sample_azimuth'] != "":
rec = {}
for key in list(spec.keys()):
rec[key] = spec[key]
rec['dec'], rec['inc'] = pmag.dogeo(
float(spec['specimen_dec']),
float(spec['specimen_inc']),
float(orient['sample_azimuth']),
float(orient['sample_dip']))
rec["tilt_correction"] = '1'
crd = 'g'
rec['sample_azimuth'] = orient['sample_azimuth']
rec['sample_dip'] = orient['sample_dip']
data.append(rec)
if len(data) > 2:
print('specimen, dec, inc, n_meas/MAD,| method codes ')
for i in range(len(data)):
print('%s: %7.1f %7.1f %s / %s | %s' %
(data[i]['er_specimen_name'], data[i]['dec'],
data[i]['inc'], data[i]['specimen_n'],
data[i]['specimen_mad'], data[i]['magic_method_codes']))
fpars = pmag.dolnp(data, 'specimen_direction_type')
print("\n Site lines planes kappa a95 dec inc")
print(site, fpars["n_lines"], fpars["n_planes"], fpars["K"],
fpars["alpha95"], fpars["dec"], fpars["inc"], fpars["R"])
if out_file != "":
if float(fpars["alpha95"]) <= acutoff and float(
fpars["K"]) >= kcutoff:
out.write('%s %s %s\n' %
(fpars["dec"], fpars['inc'], fpars['alpha95']))
pmagplotlib.plot_lnp(EQ['eqarea'], site, data, fpars,
'specimen_direction_type')
pmagplotlib.draw_figs(EQ)
if k != 0 and repeat != 'y':
ans = input(
"s[a]ve plot, [q]uit, [e]dit specimens, [p]revious site, <return> to continue:\n "
)
elif k == 0 and repeat != 'y':
ans = input(
"s[a]ve plot, [q]uit, [e]dit specimens, <return> to continue:\n "
)
if ans == "p": k -= 2
if ans == "a":
files = {}
files['eqarea'] = site + '_' + crd + '_eqarea' + '.' + fmt
pmagplotlib.save_plots(EQ, files)
if ans == "q": sys.exit()
if ans == "e" and Samps == []:
print("can't edit samples without orientation file, sorry")
elif ans == "e":
# k-=1
testspec = input("Enter name of specimen to check: ")
for spec in data:
if spec['er_specimen_name'] == testspec:
# first test wrong direction of drill arrows (flip drill direction in opposite direction and re-calculate d,i
d, i = pmag.dogeo(float(spec['specimen_dec']),
float(spec['specimen_inc']),
float(spec['sample_azimuth']) - 180.,
-float(spec['sample_dip']))
XY = pmag.dimap(d, i)
pmagplotlib.plot_xy(EQ['eqarea'], [XY[0]], [XY[1]],
sym='g^')
# first test wrong end of compass (take az-180.)
d, i = pmag.dogeo(float(spec['specimen_dec']),
float(spec['specimen_inc']),
float(spec['sample_azimuth']) - 180.,
float(spec['sample_dip']))
XY = pmag.dimap(d, i)
pmagplotlib.plot_xy(EQ['eqarea'], [XY[0]], [XY[1]],
sym='kv')
# did the sample spin in the hole?
# now spin around specimen's z
X_up, Y_up, X_d, Y_d = [], [], [], []
for incr in range(0, 360, 5):
d, i = pmag.dogeo(
float(spec['specimen_dec']) + incr,
float(spec['specimen_inc']),
float(spec['sample_azimuth']),
float(spec['sample_dip']))
XY = pmag.dimap(d, i)
if i >= 0:
X_d.append(XY[0])
Y_d.append(XY[1])
else:
X_up.append(XY[0])
Y_up.append(XY[1])
pmagplotlib.plot_xy(EQ['eqarea'], X_d, Y_d, sym='b.')
pmagplotlib.plot_xy(EQ['eqarea'], X_up, Y_up, sym='c.')
pmagplotlib.draw_figs(EQ)
break
print("Triangle: wrong arrow for drill direction.")
print("Delta: wrong end of compass.")
print(
"Small circle: wrong mark on sample. [cyan upper hemisphere]"
)
deleteme = input("Mark this sample as bad? y/[n] ")
if deleteme == 'y':
reason = input(
"Reason: [1] broke, [2] wrong drill direction, [3] wrong compass direction, [4] bad mark, [5] displaced block [6] other "
)
if reason == '1':
description = ' sample broke while drilling'
if reason == '2':
description = ' wrong drill direction '
if reason == '3':
description = ' wrong compass direction '
if reason == '4':
description = ' bad mark in field'
if reason == '5':
description = ' displaced block'
if reason == '6':
description = input(
'Enter brief reason for deletion: ')
for samp in Samps:
if samp['er_sample_name'] == spec['er_sample_name']:
samp['sample_orientation_flag'] = 'b'
samp['sample_description'] = samp[
'sample_description'] + ' ## direction deleted because: ' + description + '##' # mark description
pmag.magic_write(sampfile, Samps, 'er_samples')
repeat = input("Mark another sample, this site? y/[n] ")
if repeat == 'y': k -= 1
else:
print(
'skipping site - not enough data with specified coordinate system'
)
k += 1
print("sample flags stored in ", sampfile)
def main():
"""
NAME
site_edit_magic.py
DESCRIPTION
makes equal area projections site by site
from pmag_specimens.txt file with
Fisher confidence ellipse using McFadden and McElhinny (1988)
technique for combining lines and planes
allows testing and reject specimens for bad orientations
SYNTAX
site_edit_magic.py [command line options]
OPTIONS
-h: prints help and quits
-f: specify pmag_specimen format file, default is pmag_specimens.txt
-fsa: specify er_samples.txt file
-exc: use existing pmag_criteria.txt file
-N: reset all sample flags to good
OUPUT
edited er_samples.txt file
"""
dir_path='.'
FIG={} # plot dictionary
FIG['eqarea']=1 # eqarea is figure 1
in_file='pmag_specimens.txt'
sampfile='er_samples.txt'
out_file=""
fmt,plot='svg',1
Crits=""
M,N=180.,1
repeat=''
renew=0
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-WD' in sys.argv:
ind=sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
if '-f' in sys.argv:
ind=sys.argv.index("-f")
in_file=sys.argv[ind+1]
if '-fsa' in sys.argv:
ind=sys.argv.index("-fsa")
sampfile=sys.argv[ind+1]
if '-exc' in sys.argv:
Crits,file_type=pmag.magic_read(dir_path+'/pmag_criteria.txt')
for crit in Crits:
if crit['pmag_criteria_code']=='DE-SPEC':
M=float(crit['specimen_mad'])
N=float(crit['specimen_n'])
if '-fmt' in sys.argv:
ind=sys.argv.index("-fmt")
fmt=sys.argv[ind+1]
if '-N' in sys.argv: renew=1
#
if in_file[0]!="/":in_file=dir_path+'/'+in_file
if sampfile[0]!="/":sampfile=dir_path+'/'+sampfile
crd='s'
Specs,file_type=pmag.magic_read(in_file)
if file_type!='pmag_specimens':
print ' bad pmag_specimen input file'
sys.exit()
Samps,file_type=pmag.magic_read(sampfile)
if file_type!='er_samples':
print ' bad er_samples input file'
sys.exit()
SO_methods=[]
for rec in Samps:
if 'sample_orientation_flag' not in rec.keys(): rec['sample_orientation_flag']='g'
if 'sample_description' not in rec.keys(): rec['sample_description']=''
if renew==1:
rec['sample_orientation_flag']='g'
description=rec['sample_description']
if '#' in description:
newdesc=""
c=0
while description[c]!='#' and c<len(description)-1: # look for first pound sign
newdesc=newdesc+description[c]
c+=1
while description[c]=='#':
c+=1# skip first set of pound signs
while description[c]!='#':c+=1 # find second set of pound signs
while description[c]=='#' and c<len(description)-1:c+=1 # skip second set of pound signs
while c<len(description)-1: # look for first pound sign
newdesc=newdesc+description[c]
c+=1
rec['sample_description']=newdesc # edit out old comment about orientations
if "magic_method_codes" in rec:
methlist=rec["magic_method_codes"]
for meth in methlist.split(":"):
if "SO" in meth.strip() and "SO-POM" not in meth.strip():
if meth.strip() not in SO_methods: SO_methods.append(meth.strip())
pmag.magic_write(sampfile,Samps,'er_samples')
SO_priorities=pmag.set_priorities(SO_methods,0)
sitelist=[]
for rec in Specs:
if rec['er_site_name'] not in sitelist: sitelist.append(rec['er_site_name'])
sitelist.sort()
EQ={}
EQ['eqarea']=1
pmagplotlib.plot_init(EQ['eqarea'],5,5)
k=0
while k<len(sitelist):
site=sitelist[k]
print site
data=[]
ThisSiteSpecs=pmag.get_dictitem(Specs,'er_site_name',site,'T')
ThisSiteSpecs=pmag.get_dictitem(ThisSiteSpecs,'specimen_tilt_correction','-1','T') # get all the unoriented data
for spec in ThisSiteSpecs:
if spec['specimen_mad']!="" and spec['specimen_n']!="" and float(spec['specimen_mad'])<=M and float(spec['specimen_n'])>=N:
# good spec, now get orientation....
redo,p=1,0
if len(SO_methods)<=1:
az_type=SO_methods[0]
orient=pmag.find_samp_rec(spec["er_sample_name"],Samps,az_type)
redo=0
while redo==1:
if p>=len(SO_priorities):
print "no orientation data for ",spec['er_sample_name']
orient["sample_azimuth"]=""
orient["sample_dip"]=""
redo=0
else:
az_type=SO_methods[SO_methods.index(SO_priorities[p])]
orient=pmag.find_samp_rec(spec["er_sample_name"],Samps,az_type)
if orient["sample_azimuth"] !="":
redo=0
p+=1
if orient['sample_azimuth']!="":
rec={}
for key in spec.keys():rec[key]=spec[key]
rec['dec'],rec['inc']=pmag.dogeo(float(spec['specimen_dec']),float(spec['specimen_inc']),float(orient['sample_azimuth']),float(orient['sample_dip']))
rec["tilt_correction"]='1'
crd='g'
rec['sample_azimuth']=orient['sample_azimuth']
rec['sample_dip']=orient['sample_dip']
data.append(rec)
if len(data)>2:
print 'specimen, dec, inc, n_meas/MAD,| method codes '
for i in range(len(data)):
print '%s: %7.1f %7.1f %s / %s | %s' % (data[i]['er_specimen_name'], data[i]['dec'], data[i]['inc'], data[i]['specimen_n'], data[i]['specimen_mad'], data[i]['magic_method_codes'])
fpars=pmag.dolnp(data,'specimen_direction_type')
print "\n Site lines planes kappa a95 dec inc"
print site, fpars["n_lines"], fpars["n_planes"], fpars["K"], fpars["alpha95"], fpars["dec"], fpars["inc"], fpars["R"]
if out_file!="":
if float(fpars["alpha95"])<=acutoff and float(fpars["K"])>=kcutoff:
out.write('%s %s %s\n'%(fpars["dec"],fpars['inc'],fpars['alpha95']))
pmagplotlib.plotLNP(EQ['eqarea'],site,data,fpars,'specimen_direction_type')
pmagplotlib.drawFIGS(EQ)
if k!=0 and repeat!='y':
ans=raw_input("s[a]ve plot, [q]uit, [e]dit specimens, [p]revious site, <return> to continue:\n ")
elif k==0 and repeat!='y':
ans=raw_input("s[a]ve plot, [q]uit, [e]dit specimens, <return> to continue:\n ")
if ans=="p": k-=2
if ans=="a":
files={}
files['eqarea']=site+'_'+crd+'_eqarea'+'.'+fmt
pmagplotlib.saveP(EQ,files)
if ans=="q": sys.exit()
if ans=="e" and Samps==[]:
print "can't edit samples without orientation file, sorry"
elif ans=="e":
# k-=1
testspec=raw_input("Enter name of specimen to check: ")
for spec in data:
if spec['er_specimen_name']==testspec:
# first test wrong direction of drill arrows (flip drill direction in opposite direction and re-calculate d,i
d,i=pmag.dogeo(float(spec['specimen_dec']),float(spec['specimen_inc']),float(spec['sample_azimuth'])-180.,-float(spec['sample_dip']))
XY=pmag.dimap(d,i)
pmagplotlib.plotXY(EQ['eqarea'],[XY[0]],[XY[1]],sym='g^')
# first test wrong end of compass (take az-180.)
d,i=pmag.dogeo(float(spec['specimen_dec']),float(spec['specimen_inc']),float(spec['sample_azimuth'])-180.,float(spec['sample_dip']))
XY=pmag.dimap(d,i)
pmagplotlib.plotXY(EQ['eqarea'],[XY[0]],[XY[1]],sym='kv')
# did the sample spin in the hole?
# now spin around specimen's z
X_up,Y_up,X_d,Y_d=[],[],[],[]
for incr in range(0,360,5):
d,i=pmag.dogeo(float(spec['specimen_dec'])+incr,float(spec['specimen_inc']),float(spec['sample_azimuth']),float(spec['sample_dip']))
XY=pmag.dimap(d,i)
if i>=0:
X_d.append(XY[0])
Y_d.append(XY[1])
else:
X_up.append(XY[0])
Y_up.append(XY[1])
pmagplotlib.plotXY(EQ['eqarea'],X_d,Y_d,sym='b.')
pmagplotlib.plotXY(EQ['eqarea'],X_up,Y_up,sym='c.')
pmagplotlib.drawFIGS(EQ)
break
print "Triangle: wrong arrow for drill direction."
print "Delta: wrong end of compass."
print "Small circle: wrong mark on sample. [cyan upper hemisphere]"
deleteme=raw_input("Mark this sample as bad? y/[n] ")
if deleteme=='y':
reason=raw_input("Reason: [1] broke, [2] wrong drill direction, [3] wrong compass direction, [4] bad mark, [5] displaced block [6] other ")
if reason=='1':
description=' sample broke while drilling'
if reason=='2':
description=' wrong drill direction '
if reason=='3':
description=' wrong compass direction '
if reason=='4':
description=' bad mark in field'
if reason=='5':
description=' displaced block'
if reason=='6':
description=raw_input('Enter brief reason for deletion: ')
for samp in Samps:
if samp['er_sample_name']==spec['er_sample_name']:
samp['sample_orientation_flag']='b'
samp['sample_description']=samp['sample_description']+' ## direction deleted because: '+description+'##' # mark description
pmag.magic_write(sampfile,Samps,'er_samples')
repeat=raw_input("Mark another sample, this site? y/[n] ")
if repeat=='y': k-=1
else:
print 'skipping site - not enough data with specified coordinate system'
k+=1
print "sample flags stored in ",sampfile
def main():
"""
NAME
dmag_magic.py
DESCRIPTION
plots intensity decay curves for demagnetization experiments
SYNTAX
dmag_magic -h [command line options]
INPUT
takes magic formatted magic_measurements.txt files
OPTIONS
-h prints help message and quits
-f FILE: specify input file, default is: magic_measurements.txt
-obj OBJ: specify object [loc, sit, sam, spc] for plot, default is by location
-LT [AF,T,M]: specify lab treatment type, default AF
-XLP [PI]: exclude specific lab protocols (for example, method codes like LP-PI)
-N do not normalize by NRM magnetization
-sav save plots silently and quit
-fmt [svg,jpg,png,pdf] set figure format [default is svg]
NOTE
loc: location (study); sit: site; sam: sample; spc: specimen
"""
FIG = {} # plot dictionary
FIG['demag'] = 1 # demag is figure 1
in_file, plot_key, LT = 'magic_measurements.txt', 'er_location_name', "LT-AF-Z"
XLP = ""
norm = 1
LT = 'LT-AF-Z'
units, dmag_key = 'T', 'treatment_ac_field'
plot = 0
fmt = 'svg'
if len(sys.argv) > 1:
if '-h' in sys.argv:
print(main.__doc__)
sys.exit()
if '-N' in sys.argv: norm = 0
if '-sav' in sys.argv:
plot = 1
if '-f' in sys.argv:
ind = sys.argv.index("-f")
in_file = sys.argv[ind + 1]
if '-fmt' in sys.argv:
ind = sys.argv.index("-fmt")
fmt = sys.argv[ind + 1]
if '-obj' in sys.argv:
ind = sys.argv.index('-obj')
plot_by = sys.argv[ind + 1]
if plot_by == 'sit': plot_key = 'er_site_name'
if plot_by == 'sam': plot_key = 'er_sample_name'
if plot_by == 'spc': plot_key = 'er_specimen_name'
if '-XLP' in sys.argv:
ind = sys.argv.index("-XLP")
XLP = sys.argv[ind + 1] # get lab protocol for excluding
if '-LT' in sys.argv:
ind = sys.argv.index("-LT")
LT = 'LT-' + sys.argv[ind +
1] + '-Z' # get lab treatment for plotting
if LT == 'LT-T-Z':
units, dmag_key = 'K', 'treatment_temp'
elif LT == 'LT-AF-Z':
units, dmag_key = 'T', 'treatment_ac_field'
elif LT == 'LT-M-Z':
units, dmag_key = 'J', 'treatment_mw_energy'
else:
units = 'U'
data, file_type = pmag.magic_read(in_file)
sids = pmag.get_specs(data)
pmagplotlib.plot_init(FIG['demag'], 5, 5)
print(len(data), ' records read from ', in_file)
#
#
# find desired intensity data
#
#
plotlist, intlist = [], [
'measurement_magnitude', 'measurement_magn_moment',
'measurement_magn_volume', 'measurement_magn_mass'
]
IntMeths = []
FixData = []
for rec in data:
meths = []
methcodes = rec['magic_method_codes'].split(':')
for meth in methcodes:
meths.append(meth.strip())
for key in rec.keys():
if key in intlist and rec[key] != "":
if key not in IntMeths: IntMeths.append(key)
if rec[plot_key] not in plotlist and LT in meths:
plotlist.append(rec[plot_key])
if 'measurement_flag' not in rec.keys():
rec['measurement_flag'] = 'g'
FixData.append(rec)
plotlist.sort()
if len(IntMeths) == 0:
print('No intensity information found')
sys.exit()
data = FixData
int_key = IntMeths[
0] # plot first intensity method found - normalized to initial value anyway - doesn't matter which used
for plt in plotlist:
if plot == 0: print(plt, 'plotting by: ', plot_key)
PLTblock = pmag.get_dictitem(
data, plot_key, plt,
'T') # fish out all the data for this type of plot
PLTblock = pmag.get_dictitem(
PLTblock, 'magic_method_codes', LT,
'has') # fish out all the dmag for this experiment type
PLTblock = pmag.get_dictitem(
PLTblock, int_key, '',
'F') # get all with this intensity key non-blank
if XLP != "":
PLTblock = pmag.get_dictitem(
PLTblock, 'magic_method_codes', XLP,
'not') # reject data with XLP in method_code
if len(PLTblock) > 2:
title = PLTblock[0][plot_key]
spcs = []
for rec in PLTblock:
if rec['er_specimen_name'] not in spcs:
spcs.append(rec['er_specimen_name'])
for spc in spcs:
SPCblock = pmag.get_dictitem(PLTblock, 'er_specimen_name', spc,
'T') # plot specimen by specimen
INTblock = []
for rec in SPCblock:
INTblock.append([
float(rec[dmag_key]), 0, 0,
float(rec[int_key]), 1, rec['measurement_flag']
])
if len(INTblock) > 2:
pmagplotlib.plotMT(FIG['demag'], INTblock, title, 0, units,
norm)
if plot == 1:
files = {}
for key in FIG.keys():
files[key] = title + '_' + LT + '.' + fmt
pmagplotlib.saveP(FIG, files)
sys.exit()
else:
pmagplotlib.drawFIGS(FIG)
ans = raw_input(
" S[a]ve to save plot, [q]uit, Return to continue: ")
if ans == 'q': sys.exit()
if ans == "a":
files = {}
for key in FIG.keys():
files[key] = title + '_' + LT + '.' + fmt
pmagplotlib.saveP(FIG, files)
pmagplotlib.clearFIG(FIG['demag'])