def format_vsm(self):
"""
formats the vsm output to be compatible with backfield measurements
:return:
"""
data = self.machine_data.out_backfield()
header = self.machine_data.header
# check for IRM acquisition -> index is changed
data_idx = 0
if self.machine_data.measurement_header['SCRIPT'][
'Include IRM?'] == 'Yes':
data_idx += 1
self.logger.info(
'IRM acquisition measured, adding new measurement')
irm = self.sample_obj.add_measurement(mtype='irm_acquisition',
mfile=self.mfile,
machine=self.machine)
irm._series = self._series
self._raw_data['remanence'] = RockPyData(column_names=['field', 'mag'],
data=data[data_idx][:,
[0, 1]])
if self.machine_data.measurement_header['SCRIPT'][
'Include direct moment?'] == 'Yes':
self._raw_data['induced'] = RockPyData(
column_names=['field', 'mag'],
data=data[data_idx + 1][:, [0, 2]])
else:
self._raw_data['induced'] = None
def format_vftb(self):
data = self.machine_data.out_thermocurve()
header = self.machine_data.header
if len(data) > 2:
print(
'LENGTH of machine.out_thermocurve =! 2. Assuming data[0] = heating data[1] = cooling'
)
# self.log.warning('LENGTH of machine.out_thermocurve =! 2. Assuming data[0] = heating data[1] = cooling')
if len(data) > 1:
self._raw_data['up_temp'] = RockPyData(column_names=header,
data=data[0])
self._raw_data['down_temp'] = RockPyData(column_names=header,
data=data[1])
else:
print('LENGTH of machine.out_thermocurve < 2.')
def format_sushibar(self):
data = RockPyData(column_names=['field', 'x', 'y', 'z'],
data=self.machine_data.out_afdemag()
) # , units=['mT', 'Am2', 'Am2', 'Am2'])
data.define_alias('m', ('x', 'y', 'z'))
self._raw_data['data'] = data.append_columns('mag',
data.magnitude('m'))
def calc_all(self, **parameter):
for sample in self.sample_list:
label = sample.name
sample.calc_all(**parameter)
results = sample.results
if self.results is None:
self.results = RockPyData(
column_names=results.column_names,
data=results.data,
row_names=[label for i in results.data])
else:
rpdata = RockPyData(column_names=results.column_names,
data=results.data,
row_names=[label for i in results.data])
self.results = self.results.append_rows(rpdata)
return self.results
def interpolate_smoothing_spline(self,
y_component='mag',
x_component='field',
out_spline=False):
"""
Interpolates using a smoothing spline between a x and y component
:param y_component:
:param x_component:
:param out_spline:
:return:
"""
from scipy.interpolate import UnivariateSpline
x_old = self._data['data'][x_component].v #
y_old = self._data['data'][y_component].v
smoothing_spline = UnivariateSpline(x_old, y_old, s=1)
if not out_spline:
x_new = np.linspace(min(x_old), max(x_old), 100)
y_new = smoothing_spline(x_new)
out = RockPyData(column_names=[x_component, y_component],
data=np.c_[x_new, y_new])
return out
else:
return smoothing_spline
def format_vsm(self):
data = self.machine_data.out
header = self.machine_data.header
segments = self.machine_data.segment_info
aux = np.array([j for i in data for j in i]) # combine all data arrays
a = np.array([(i, v)
for i, v in enumerate(np.diff(aux, axis=0)[:, 0])])
sign = np.sign(np.diff(aux, axis=0)[:, 1])
threshold = 3
zero_crossings = [
i + 1 for i in xrange(len(a[:, 1]) - 1)
if a[i, 1] > 0 > a[i + 1, 1] and a[i, 1] > 0 > a[i + 2, 1]
or a[i, 1] < 0 < a[i + 1, 1] and a[i, 1] < 0 < a[i + 2, 1]
]
zero_crossings = [0] + zero_crossings # start with zero index
zero_crossings += [len(aux)] # append last index
ut = 0 # running number warming
dt = 0 # running number cooling
for i, v in enumerate(zero_crossings):
if v < zero_crossings[-1]: # prevents index Error
if sum(a[v:zero_crossings[i + 1], 1]) < 0: # cooling
name = 'cool%02i' % (ut)
ut += 1
else:
name = 'warm%02i' % (dt)
dt += 1
data = aux[v:zero_crossings[i + 1] + 1]
rpd = RockPyData(column_names=header, data=data)
rpd.rename_column('temperature', 'temp')
rpd.rename_column('moment', 'mag')
self._data.update({name: rpd})
def segment_info(self):
segment_start_idx = [
i for i, v in enumerate(self.raw_out)
if v.strip().lower().startswith('segment')
or v.strip().lower().startswith('number')
]
if segment_start_idx:
segment_numbers_idx = [
i for i, v in enumerate(self.raw_out) if v.startswith('0')
]
segment_data = [
v.strip('\n').split(',') for i, v in enumerate(self.raw_out)
if i in segment_numbers_idx
]
sifw = [len(i) + 1 for i in segment_data[0]]
sifw += [len(segment_data[0])]
sifw = [sum(sifw[:i]) for i in range(len(sifw))]
segment_data = np.array(segment_data).astype(float)
segment_info = np.array(
[[v[sifw[i]:sifw[i + 1]] for i in range(len(sifw) - 1)]
for j, v in enumerate(self.raw_out)
if j in segment_start_idx]).T
segment_info = [' '.join(i) for i in segment_info]
segment_info = np.array(
[' '.join(j.split()).lower() for j in segment_info])
out = RockPyData(column_names=segment_info, data=segment_data)
else:
out = None
return out
def format_cryomag(self):
#self.log.debug('FORMATTING << %s >> raw_data for << cryomag >> data structure' % (self.mtype))
data = self.machine_data.out_trm()
header = self.machine_data.float_header
self._raw_data['remanence'] = RockPyData(column_names=header,
data=data)
self._raw_data['induced'] = None
def __init__(self, stype, value, unit, comment=None):
#self.log = logging.getLogger('RockPy.series.' + type(self).__name__)
#self.log.info('CREATING series << %s >>' % stype)
self.stype = stype.lower()
self.value = float(value)
self.data = RockPyData(column_names=stype, data=value)
self.unit = unit
self.comment = comment
def format_jr6(self):
data = self.machine_data.get_data()
data = RockPyData(column_names=['x', 'y', 'z'],
data=data,
units=['A m^2', 'A m^2', 'A m^2'])
data.define_alias('m', ('x', 'y', 'z'))
self._raw_data = {
'data': data.append_columns('mag', data.magnitude('m'))
}
def format_cryomag(self):
data = self.machine_data.float_data
header = self.machine_data.float_header
data = RockPyData(column_names=header, data=data)
data.define_alias('m', ('x', 'y', 'z'))
# data = data.append_columns('mag', data.magnitude('m'))
self._raw_data = {
'data': data.append_columns('mag', data.magnitude('m'))
}
def format_vftb(self):
'''
formats the output from vftb to measurement.data
:return:
'''
data = self.machine_data.out_backfield()
header = self.machine_data.header
self._raw_data['remanence'] = RockPyData(column_names=header,
data=data[0])
self._raw_data['induced'] = None
def test_add_errors(self):
d = RockPyData(column_names=['A', 'B'])
#d['A'].v = 1 # Attribute Error NoneType has no attribute, maybe initialize to np.nan?
#d['B'] = 2
#d['A'].e = 4
#d['B'].e = 5
d = d.append_rows([1, 2])
#print d
d.e = [[4, 5]]
self.assertEqual(5., d['B'].e)
def format_sushibar(self):
data = RockPyData(
column_names=['temp', 'x', 'y', 'z', 'sm'],
data=self.machine_data.out_trm(),
# units=['C', 'mT', 'A m^2', 'A m^2', 'A m^2']
)
data.define_alias('m', ('x', 'y', 'z'))
# data = data.append_columns('mag', data.magnitude('m'))
self._raw_data = {
'data': data.append_columns('mag', data.magnitude('m'))
}
def format_vsm(self):
"""
Formatting for viscosity Measurements from VSM machine
"""
data = self.machine_data.out
header = self.machine_data.header
self._raw_data['data'] = RockPyData(
column_names=['time', 'mag', 'field'], data=data[0][:])
self._raw_data['data'] = self._raw_data['data'].append_columns(
column_names=['ln_time'],
data=np.log(self._raw_data['data']['time'].v))
def __initialize(self):
"""
Initialize function is called inside the __init__ function, it is also called when the object is reconstructed
with pickle.
:return:
"""
# dynamical creation of entries in results data. One column for each results_* method.
# calculation_* methods are not creating columns -> if a result is calculated a result_* method
# has to be written
self.result_methods = [
i[7:] for i in dir(self) if i.startswith('result_')
if not i.endswith('generic') if not i.endswith('result')
] # search for implemented results methods
self.results = RockPyData(
column_names=self.result_methods,
data=[np.nan for i in self.result_methods
]) # dynamic entry creation for all available result methods
# ## warning with calculation of results:
# M.result_slope() -> 1.2
# M.calculate_vds(t_min=300) -> ***
# M.results['slope'] -> 1.2
# M.result_slope(t_min=300) -> 0.9
#
# the results are stored for the calculation parameters that were used to calculate it.
# This means calculating a different result with different parameters can lead to inconsistencies.
# One has to be aware that comparing the two may not be useful
# dynamically generating the calculation and standard parameters for each calculation method.
# This just sets the values to non, the values have to be specified in the class itself
self.calculation_methods = [
i for i in dir(self) if i.startswith('calculate_')
if not i.endswith('generic')
]
self.calculation_parameter = {i: dict() for i in self.result_methods}
self._standard_parameter = {
i[10:]: None
for i in dir(self) if i.startswith('calculate_')
if not i.endswith('generic')
}
if self._series:
for t in self._series:
self._add_sval_to_results(t)
# self._add_sval_to_data(t)
self.is_normalized = False # normalized flag for visuals, so its not normalized twize
self.norm = None # the actual parameters
self._info_dict = self.__create_info_dict()
def format_vsm(self):
"""
formats the vsm output to be compatible with backfield measurements
:return:
"""
data = self.machine_data.out_backfield()
header = self.machine_data.header
#check for IRM acquisition
if self.machine_data.measurement_header['SCRIPT'][
'Include IRM?'] == 'Yes':
self._raw_data['remanence'] = RockPyData(
column_names=['field', 'mag'], data=data[0][:, [0, 1]])
def format_cryomag(self):
data = RockPyData(column_names=self.machine_data.float_header,
data=self.machine_data.get_float_data())
if self.demag_type != 'af3':
idx = [
i for i, v in enumerate(self.machine_data.steps)
if v == self.demag_type
]
data = data.filter_idx(idx)
data.define_alias('m', ('x', 'y', 'z'))
self._raw_data['data'] = data.append_columns('mag',
data.magnitude('m'))
self._raw_data['data'].rename_column('step', 'field')
def format_ani(self):
self.header = self.machine_data.header
mdirs = self.machine_data.mdirs
measurements = self.machine_data.data
#do we have scalar or vectorial measurements?
if len(measurements.flatten()) == len(mdirs): #scalar
data = RockPyData(column_names=['d', 'i', 'm'])
elif len(measurements.flatten()) / len(mdirs) == 3: #vectorial
data = RockPyData(column_names=['d', 'i', 'x', 'y', 'z'])
else:
Anisotropy.logger.error(
"anisotropy measurements have %d components")
return
for idx in range(len(mdirs)):
data = data.append_rows(
np.hstack([np.array(mdirs[idx]), measurements[idx]]))
data.define_alias('variable', ('d', 'i'))
self._data['data'] = data
def setUp(self):
# run before each test
self.testdata = ((1, 2, 3, 4),
(1, 6, 7, 8),
(1, 2, 11, 12),
(1, 6, 55, 66))
self.col_names = ('F', 'Mx', 'My', 'Mz')
self.row_names = ('1.Zeile', '2.Zeile_A', '3.Zeile', '4.Zeile_A')
self.units = ('T', 'mT', 'fT', 'pT')
self.RPD = RockPyData(column_names=self.col_names, row_names=self.row_names, units=self.units,
data=self.testdata)
def format_sushibar(self):
data = self.machine_data.out_parm_spectra()
self.af3 = RockPyData(column_names=data[1],
data=data[0][0],
units=data[2])
self.af3.define_alias('m', ('x', 'y', 'z'))
self.af3 = self.af3.append_columns('mag', self.af3.magnitude('m'))
self.af3 = self.af3.append_columns(
column_names='mean_window',
data=np.array(
[self.af3['upper_window'].v + self.af3['lower_window'].v])[0] /
2)
self.data = RockPyData(column_names=data[1],
data=data[0][1:],
units=data[2])
self.data.define_alias('m', ('x', 'y', 'z'))
self.data = self.data.append_columns('mag', self.data.magnitude('m'))
self.data = self.data.append_columns(
column_names='mean_window',
data=np.array([
self.data['upper_window'].v + self.data['lower_window'].v
])[0] / 2)
self.data.define_alias('variable', 'mean_window')
def simulate(cls, sample_obj, color=None, **parameter):
"""
return simulated instance of measurement depending on parameters
"""
# get measurement directions in array of D,I pairs
mdirs = parameter.get('mdirs', [[0.0, 0.0], [90.0, 0.0], [0.0, 90.0]])
# get eigenvalues
evals = list(parameter.get('evals', [1.0, 1.0, 1.0]))
if len(evals) != 3:
raise RuntimeError('got %d eigenvalues instead of 3' % len(evals))
# get random measurement errors
measerr = parameter.get('measerr', 0)
# todo: normalize evals to 1?
R = Anisotropy.createDiagonalTensor(*evals)
#todo: also implement 1D measurement
data = RockPyData(column_names=['d', 'i', 'x', 'y', 'z'])
for mdir in mdirs:
# M = R * H
errs = [measerr * random() * 2 - measerr for i in (1, 2, 3)]
measurement = np.dot(R, DIL2XYZ((mdir[0], mdir[1], 1))) + errs
data = data.append_rows(np.hstack([np.array(mdir), measurement]))
data.define_alias('variable', ('d', 'i'))
mdata = {'data': data}
return cls(sample_obj,
'anisotropy',
mfile=None,
mdata=mdata,
machine='simulation',
color=color,
**parameter)
def format_vftb(self):
data = self.machine_data.get_data()
header = self.machine_data.header
# self.log.debug('FORMATTING << %s >> raw_data for << VFTB >> data structure' % (self.mtype))
self._raw_data['remanence'] = RockPyData(column_names=header,
data=data[0])
def test():
# define some data for tutorials.rst
testdata = ((1, 2, 3, 4),
(2, 6, 7, 8),
(9, 10, 11, 12))
testdata2 = ((1, 1),
(2, 2),
(19, 3))
# create a rockpydata object with named columns and filled with testdata
d = RockPyData(column_names=('F', 'Mx', 'My', 'Mz'), row_names=('1.Zeile', '2.Zeile', '3.Zeile'),
units=('T', 'mT', 'fT', 'pT'), data=testdata)
d_json = numpyson.dumps(d)
print d_json
dd = numpyson.loads(d_json)
print repr(dd)
print "dd:", dd
#d = d.eliminate_duplicate_variable_rows(substfunc='last')
#print d._find_unique_variable_rows()
print('d:\n%s' % d)
e = RockPyData(column_names=('F', 'Mx'), row_names=('1.Zeile', '2.Zeile', '3.Zeile'),
units=('T', 'mT', 'fT', 'pT'), data=testdata2)
print('e:\n%s' % e)
print('e+d:\n%s' % (e+d))
print('e-d:\n%s' % (e-d))
print('e/d:\n%s' % (e/d))
print('e*d:\n%s' % (e*d))
print('d/e:\n%s' % (d/e))
print('d*e:\n%s' % (d*e))
print('d+e:\n%s' % (d+e))
print('d-e:\n%s' % (d-e))
print d.units
# define as many aliases as you want
d.define_alias('M', ('Mx', 'My', 'Mz'))
d.define_alias('Mzx', ('Mz', 'Mx'))
# show some data
# aliases 'all', 'variable' and 'dep_var' are predefined
print('all:\n%s' % d['all'])
print('Mzx:\n%s' % d['Mzx'])
# lets alter some data
d['Mx'] = np.array((13, 24, 35))
# show M with modified Mx component
print('M:\n%s' % d['M'])
# show Mx
print('Mx:\n%s' % d['Mx'])
# we can also alter several columns at once
d['M'] = ((2, 3, 4),
(18, 88, 98),
(39, 89, 99))
print('M:\n%s' % d['M'])
# some math fun
# calculate magnitude of vector 'M' and save it as new column 'magM'
d = d.append_columns('magM', d.magnitude('M'))
# calculate values of 'magM' normalized to 100
#d.append_columns('normM', d.normalize('magM', 100))
# we can also add arbitrary data in a new column
d = d.append_columns(("T",), np.array((1, 2, 3)))
# we can also add an empty column
d = d.append_columns(("empty",))
# renaming a column
d.rename_column('T', 'temp')
# show all data again, now including magM and T as the last two columns
print d
# do a plot of F vs magM
# plt.plot(d['F'], d['magM'])
# plt.show()
# fancy filtering of data
tf_array = (d['Mx'].v > 10) & (d['Mx'].v < 20)
print 'filtering:'
filtered_d = d.filter(tf_array)
print filtered_d['Mx']
# arithmetic operations
e = deepcopy(d)
# mutlipy one column with value
e['Mx'].v *= 2
# calculate difference of two rockpydata objects
#c = e - d
#print c
#c = e + d
#print c
#c = e / d
#print c
#c = e * d
#print c
#print repr(c)
# test single line object
l = RockPyData(column_names=('A', 'B', 'C', 'D'), row_names=('1.Zeile',),
units=('T', 'mT', 'fT', 'pT'), data=((1, 2, 3, 4),))
l = l.append_columns('X', (5,))
print l
print l['X']
#print d.mean()
print d
print d + (1, 2, 3, 4, 5, 6)
print d.interpolate(np.arange(2, 10, .5), includesourcedata=True)
#d.define_alias('variable', 'Mx')
#print d.interpolate(np.arange(0, 10, .5))
print "condense:"
print condense([d, d*2, d*3], substfunc='median')
