def add_mean_measurements(self, interpolate=True, substfunc='mean', mean_of_mean=False, reference=None, ref_dtype='mag', norm_dtypes='all', vval=None, norm_method='max', normalize_variable=False, dont_normalize=None, ignore_stypes=False): """ Creates mean measurements for all measurements and measurement types :param interpolate: :param substfunc: :param mean_of_mean: :param reference: :param ref_dtype: :param norm_dtypes: :param vval: :param norm_method: :param normalize_variable: :param dont_normalize: :param ignore_stypes: :return: """ ignore_stypes = RockPy3._to_tuple(ignore_stypes) mean_measurements = [] # separate the different mtypes for mtype in self.mtypes: # all measurements with that mtype measurements = self.get_measurement(mtype=mtype, mean=False) # use first measurement as template to check for series while measurements: m = measurements[0] if isinstance(m, RockPy3.Packages.Generic.Measurements.parameters.Parameter): break if ignore_stypes == 'all': mlist = measurements else: # get measurements with the same series mlist = [measurement for measurement in measurements if m.equal_series(measurement, ignore_stypes=ignore_stypes)] # remove the measurements from the measurements list so they don't get averaged twice measurements = [m for m in measurements if m not in mlist] if not mlist: self.log.debug('NO MORE measurements in mlist') break if self.mean_measurement_exists(mlist): self.log.warning('MEAN measurement already exists for these measurements:\n\t\t{}'.format(mlist)) mean_measurements.extend(self.mean_measurement_exists(mlist)) continue mean_measurements.append(self.create_mean_measurement(mlist=mlist, ignore_stypes=ignore_stypes, interpolate=interpolate, substfunc=substfunc, reference=reference, ref_dtype=ref_dtype, norm_dtypes=norm_dtypes, vval=vval, norm_method=norm_method, normalize_variable=normalize_variable, dont_normalize=dont_normalize)) return mean_measurements
def get_measurement_block(self): block = deepcopy(self.storage[0]) block[2] = [abbreviate_name(mtype).upper() for mtype in RockPy3._to_tuple(block[2]) if mtype] block[3] = abbreviate_name(block[3]).upper() if not all(block[1:]): raise ImportError('sname, mtype, ftype needed for minfo to be generated') return '_'.join((self.tuple2str(b) for b in block))
def measurement_infos(self): idict = {'fpath': self.fpath, 'ftype': self.ftype, 'idx': self.suffix, 'series': self.series} samples = RockPy3._to_tuple(self.samples) for i in samples: for j in self.mtypes: mtype = RockPy3.abbrev_to_classname(j) idict.update({'mtype': mtype, 'sample': i}) yield idict
def sample_infos(self): sdict = dict(mass=self.mass, diameter=self.diameter, height=self.height, mass_unit=self.massunit, height_unit=self.heightunit, diameter_unit=self.diameterunit, samplegroup=self.sgroups) samples = RockPy3._to_tuple(self.samples) for i in samples: sdict.update({'name': i}) yield sdict
def combine_measurements(self, others, remove_others=False, normalize_to_last=False): """ it combines several measurements into the specified one. e.g. a second cooling run at the end of the measurement Parameters ---------- others: list the measurements to appended to the self.data dictionary. The names are chosen according to the total number of heating and cooling runs remove_others: bool default: False if True the measurements are removed from the sample after it is combined with the measurement if False the measurements only combined normalize_to_last: default: False nomalizes the data to be combined to the last point of the last segment. So that different calibrations do not affect the measurement Returns ------- """ others = RockPy3._to_tuple(others) self.log.info('COMBINING << {} >> with {}'.format(self, others)) cool_idx = sum(1 for i in self.data if 'cool' in i) warm_idx = sum(1 for i in self.data if 'warm' in i) c, w = cool_idx - 1, warm_idx - 1 # old maximum indices nfactor = None last_segment = list(self.data.keys())[-1] if normalize_to_last: nfactor = self.data[last_segment]['mag'].v[-1] for m in others: m = deepcopy(m) if normalize_to_last: m.normalize('cooling00') m.normalize(norm_factor=1 / nfactor) for dtype in m.data: if 'cool' in dtype: self.data.update({'cooling%02i' % cool_idx: m.data[dtype]}) cool_idx += 1 if 'warming' in dtype: self.data.update({'warming%02i' % warm_idx: m.data[dtype]}) warm_idx += 1 if remove_others: self.log.info('REMOVING << {} >> from sample << {} >>'.format( self, self.sobj)) self.sobj.remove_measurement(mobj=m) return self
def measurement_block(self, block): sgroups, samples, mtypes, ftype = block.split('_') # names with , need to be replaced if not '(' in samples and ',' in samples: samples = samples.replace(',', '.') RockPy3.logger.warning('sample name %s contains \',\' will be replaced with \'.\'' % samples) self.sgroups, self.samples, self.mtypes, self.ftype = self.extract_tuple(sgroups), self.extract_tuple( samples), self.extract_tuple(mtypes), ftype self.mtypes = tuple(RockPy3.abbrev_to_classname(mtype) for mtype in RockPy3._to_tuple(self.mtypes)) self.ftype = RockPy3.abbrev_to_classname(ftype)
def get_measurement_block(self): block = deepcopy(self.storage[0]) block[2] = [ abbreviate_name(mtype).upper() for mtype in RockPy3._to_tuple(block[2]) if mtype ] block[3] = abbreviate_name(block[3]).upper() if not all(block[1:]): raise ImportError( 'sname, mtype, ftype needed for minfo to be generated') return '_'.join((self.tuple2str(b) for b in block))
def combine_measurements(self, others, remove_others = False, normalize_to_last=False): """ it combines several measurements into the specified one. e.g. a second cooling run at the end of the measurement Parameters ---------- others: list the measurements to appended to the self.data dictionary. The names are chosen according to the total number of heating and cooling runs remove_others: bool default: False if True the measurements are removed from the sample after it is combined with the measurement if False the measurements only combined normalize_to_last: default: False nomalizes the data to be combined to the last point of the last segment. So that different calibrations do not affect the measurement Returns ------- """ others = RockPy3._to_tuple(others) self.log.info('COMBINING << {} >> with {}'.format(self, others)) cool_idx = sum(1 for i in self.data if 'cool' in i) warm_idx = sum(1 for i in self.data if 'warm' in i) c,w = cool_idx-1, warm_idx-1 # old maximum indices nfactor = None last_segment = list(self.data.keys())[-1] if normalize_to_last: nfactor = self.data[last_segment]['mag'].v[-1] for m in others: m = deepcopy(m) if normalize_to_last: m.normalize('cooling00') m.normalize(norm_factor=1/nfactor) for dtype in m.data: if 'cool' in dtype: self.data.update({'cooling%02i'%cool_idx: m.data[dtype]}) cool_idx += 1 if 'warming' in dtype: self.data.update({'warming%02i'%warm_idx: m.data[dtype]}) warm_idx += 1 if remove_others: self.log.info('REMOVING << {} >> from sample << {} >>'.format(self, self.sobj)) self.sobj.remove_measurement(mobj=m) return self
def measurement_infos(self): idict = { 'fpath': self.fpath, 'ftype': self.ftype, 'idx': self.suffix, 'series': self.series } samples = RockPy3._to_tuple(self.samples) for i in samples: for j in self.mtypes: mtype = RockPy3.abbrev_to_classname(j) idict.update({'mtype': mtype, 'sample': i}) yield idict
def measurement_block(self, block): sgroups, samples, mtypes, ftype = block.split('_') # names with , need to be replaced if not '(' in samples and ',' in samples: samples = samples.replace(',', '.') RockPy3.logger.warning( 'sample name %s contains \',\' will be replaced with \'.\'' % samples) self.sgroups, self.samples, self.mtypes, self.ftype = self.extract_tuple( sgroups), self.extract_tuple(samples), self.extract_tuple( mtypes), ftype self.mtypes = tuple( RockPy3.abbrev_to_classname(mtype) for mtype in RockPy3._to_tuple(self.mtypes)) self.ftype = RockPy3.abbrev_to_classname(ftype)
def remove_measurement(self, mtype=None, series=None, stype=None, sval=None, sval_range=None, mean=False, invert=False, id=None, mobj=None): """ Removes measurements from the sample Parameters ---------- mtype series stype sval sval_range mean invert id mobj Returns ------- """ if mobj: mlist = RockPy3._to_tuple(mobj) else: mlist = self.get_measurement(mtype=mtype, series=series, stype=stype, sval=sval, sval_range=sval_range, mean=mean, invert=invert, id=id) for m in mlist: if not mean: self.measurements = np.delete(self.measurements, m._idx) else: self.mean_measurements = np.delete(self.mean_measurements, m._idx)
def tuple2str(tup): """ takes a tuple and converts it to text, if more than one element, brackets are put around it """ if tup is None: return '' tup = RockPy3._to_tuple(tup) # if type(tup) == list: # if len(tup) == 1: # tup = tup[0] # else: # tup = tuple(tup) if len(tup) == 1: return str(tup[0]) else: return str(tup).replace('\'', ' ').replace(' ', '')
def add_visual(self, visual, name=None, data=None, plot_groupmean=None, plot_samplemean=None, plot_samplebase=None, plot_groupbase=None, plot_other=None, base_alpha=None, result_from_means=None, xlabel=None, ylabel=None, **visual_opt): """ adds a visual to the plot. This creates a new subplot. Parameters ---------- visual: list, str name of visual to add. """ # calculation_parameters, kwargs = RockPy3.core.utils.separate_calculation_parameter_from_kwargs(rpobj=self, **visual_opt) # convert visual to list visuals = RockPy3._to_tuple(visual) # for easy checking convert the names to lower case visuals = map(str.lower, visuals) for visual in visuals: # check if visual exists otherwise don't create it if visual in RockPy3.implemented_visuals: self.log.debug('VISUAL << %s > found' % visual) self.__log_implemented() if not name: name = visual n = self._n_visuals # create instance of visual by dynamically calling from implemented_visuals dictionary visual_obj = RockPy3.implemented_visuals[visual]( data=data, plt_index=n, fig=self, name=name, plot_groupmean=plot_groupmean, plot_groupbase=plot_groupbase, plot_samplemean=plot_samplemean, plot_samplebase=plot_samplebase, plot_other=plot_other, base_alpha=base_alpha, result_from_means=result_from_means, xlabel=xlabel, ylabel=ylabel, **visual_opt) self._visuals.append([name, visual, visual_obj]) self._n_visuals += 1 else: self.log.warning('VISUAL << %s >> not implemented yet' % visual) self.__log_implemented(ignore_once=True) return return visual_obj
def get_significant_digits(values): values = RockPy3._to_tuple(values) values = map(str, values) digits = [len(s.split(".")[-1]) for s in values] return digits if len(digits) > 1 else digits[0]
def add_mean_measurements(self, interpolate=True, substfunc='mean', mean_of_mean=False, reference=None, ref_dtype='mag', norm_dtypes='all', vval=None, norm_method='max', normalize_variable=False, dont_normalize=None, ignore_stypes=False): """ Creates mean measurements for all measurements and measurement types :param interpolate: :param substfunc: :param mean_of_mean: :param reference: :param ref_dtype: :param norm_dtypes: :param vval: :param norm_method: :param normalize_variable: :param dont_normalize: :param ignore_stypes: :return: """ ignore_stypes = RockPy3._to_tuple(ignore_stypes) mean_measurements = [] # separate the different mtypes for mtype in self.mtypes: # all measurements with that mtype measurements = self.get_measurement(mtype=mtype, mean=False) # use first measurement as template to check for series while measurements: m = measurements[0] if isinstance( m, RockPy3.Packages.Generic.Measurements.parameters. Parameter): break if ignore_stypes == 'all': mlist = measurements else: # get measurements with the same series mlist = [ measurement for measurement in measurements if m.equal_series(measurement, ignore_stypes=ignore_stypes) ] # remove the measurements from the measurements list so they don't get averaged twice measurements = [m for m in measurements if m not in mlist] if not mlist: self.log.debug('NO MORE measurements in mlist') break if self.mean_measurement_exists(mlist): self.log.warning( 'MEAN measurement already exists for these measurements:\n\t\t{}' .format(mlist)) mean_measurements.extend( self.mean_measurement_exists(mlist)) continue mean_measurements.append( self.create_mean_measurement( mlist=mlist, ignore_stypes=ignore_stypes, interpolate=interpolate, substfunc=substfunc, reference=reference, ref_dtype=ref_dtype, norm_dtypes=norm_dtypes, vval=vval, norm_method=norm_method, normalize_variable=normalize_variable, dont_normalize=dont_normalize)) return mean_measurements
def get_significant_digits(values): values = RockPy3._to_tuple(values) values = map(str, values) digits = [len(s.split('.')[-1]) for s in values] return digits if len(digits)>1 else digits[0]
def QuickFig(data, visuals, **kwargs): f = RockPy3.Figure(data=data) visuals = RockPy3._to_tuple(visuals) for v in visuals: f.add_visual(visual=v) f.show(**kwargs)
def __init__(self, fpath, sgroups=None, samples=None, mtypes=None, ftype=None, mass=None, height=None, diameter=None, massunit=None, lengthunit=None, heightunit=None, diameterunit=None, series=None, comment=None, folder=None, suffix=None, read_fpath=True, **kwargs): """ Parameters ---------- fpath sgroups samples mtypes ftype mass height diameter massunit lengthunit heightunit diameterunit series comment folder suffix read_fpath: bool if true the path will be read for info kwargs """ if 'mtype' in kwargs and not mtypes: mtypes = kwargs.pop('mtype') if 'sgroup' in kwargs and not sgroups: mtypes = kwargs.pop('sgroup') if 'sample' in kwargs and not samples: mtypes = kwargs.pop('sample') blocks = (self.measurement_block, self.sample_block, self.series_block, self.add_block, self.comment_block) additional = tuple() sgroups = RockPy3._to_tuple(sgroups) sgroups = tuple([sg if sg != 'None' else None for sg in sgroups]) if mtypes: mtypes = tuple(RockPy3.abbrev_to_classname(mtype) for mtype in RockPy3._to_tuple(mtypes)) if ftype: ftype = RockPy3.abbrev_to_classname(ftype) self.__dict__.update({i: None for i in ('sgroups', 'samples', 'mtypes', 'ftype', 'mass', 'height', 'diameter', 'massunit', 'lengthunit', 'heightunit', 'diameterunit', 'series', 'additional', 'comment', 'folder', 'suffix') }) self.fpath = fpath if read_fpath and fpath: # todo add check for if path is readable self.folder = os.path.dirname(fpath) f, self.suffix = os.path.splitext(os.path.basename(fpath)) self.suffix = self.suffix.strip('.') splits = f.split('#') # check if RockPy compatible e.g. first part must be len(4) if not len(splits[0]) == 4: pass for i, block in enumerate(blocks[:len(splits)]): if splits[i]: try: block(splits[i]) except (ValueError,): pass for i in ('sgroups', 'samples', 'mtypes', 'ftype', 'mass', 'height', 'diameter', 'massunit', 'lengthunit', 'heightunit', 'diameterunit', 'series', 'additional', 'comment', 'folder'): if locals()[i]: if isinstance(locals()[i], (tuple, list, set)): if not all(locals()[i]): continue setattr(self, i, locals()[i]) if self.additional is None: self.additional = '' if kwargs: for k, v in kwargs.items(): if v: print(k, v, self.additional) self.additional += '{}:{}'.format(k, v) if suffix: self.suffix = suffix if type(self.suffix) == int: self.suffix = '%03i' % self.suffix if not self.suffix: self.suffix = '000' if not self.sgroups: self.sgroups = None self.storage = [[self.sgroups, self.samples, self.mtypes, self.ftype], [[self.mass, self.massunit], [self.height, self.heightunit], [self.diameter, self.diameterunit], ], self.series, (self.additional,), self.comment]
def import_folder(self, folder, sname=None, sgroup=None, mtype=None, automatic_results = True, ): # todo specify samples, mtypes and series for selective import of folder """ imports all files in the specified folder Parameters ---------- folder gname Returns ------- """ files = [os.path.join(folder, i) for i in os.listdir(folder) if not i.startswith('#') if not i.startswith(".") if not i.endswith("pynb") if not i.endswith("log") if not os.path.isdir(os.path.join(folder, i)) ] measurements = [] start = time.clock() minfos = (RockPy3.core.file_operations.minfo(f) for f in files) minfos = (minfo for minfo in minfos if minfo.is_readable()) if mtype: mtype = RockPy3._to_tuple(mtype) mtype = [RockPy3.abbrev_to_classname(mt) for mt in mtype] for mi in minfos: RockPy3.logger.info('importing {}'.format(mi.fpath)) # dont import samples that are not in the measurement info if sname: sname = RockPy3._to_tuple(sname) if not any(s in mi.samples for s in sname): continue # dont import samples that are not included in a certain samplegroup in the measurement info if sgroup: sgroup = RockPy3._to_tuple(sgroup) if not any(sg in mi.sgroups for sg in sgroup): continue # check if the filename has not been imported, yet if mi.fpath in self.imported_files: continue else: self.imported_files.append(mi.fpath) for sinfo in mi.sample_infos: s = self.add_sample(warnings=False, **sinfo) for minfo in mi.measurement_infos: if mtype and minfo['mtype'].lower() not in mtype: continue if minfo['sample'] == sinfo['name']: measurements.append(s.add_measurement(**minfo)) end = time.clock() print('IMPORT generated {} measurements: finished in {:.02e}s'.format(len(measurements), end - start)) return measurements
def __init__(self, fpath, sgroups=None, samples=None, mtypes=None, ftype=None, mass=None, height=None, diameter=None, massunit=None, lengthunit=None, heightunit=None, diameterunit=None, series=None, comment=None, folder=None, suffix=None, read_fpath=True, **kwargs): """ Parameters ---------- fpath sgroups samples mtypes ftype mass height diameter massunit lengthunit heightunit diameterunit series comment folder suffix read_fpath: bool if true the path will be read for info kwargs """ if 'mtype' in kwargs and not mtypes: mtypes = kwargs.pop('mtype') if 'sgroup' in kwargs and not sgroups: mtypes = kwargs.pop('sgroup') if 'sample' in kwargs and not samples: mtypes = kwargs.pop('sample') blocks = (self.measurement_block, self.sample_block, self.series_block, self.add_block, self.comment_block) additional = tuple() sgroups = RockPy3._to_tuple(sgroups) sgroups = tuple([sg if sg != 'None' else None for sg in sgroups]) if mtypes: mtypes = tuple( RockPy3.abbrev_to_classname(mtype) for mtype in RockPy3._to_tuple(mtypes)) if ftype: ftype = RockPy3.abbrev_to_classname(ftype) self.__dict__.update({ i: None for i in ('sgroups', 'samples', 'mtypes', 'ftype', 'mass', 'height', 'diameter', 'massunit', 'lengthunit', 'heightunit', 'diameterunit', 'series', 'additional', 'comment', 'folder', 'suffix') }) self.fpath = fpath if read_fpath and fpath: # todo add check for if path is readable self.folder = os.path.dirname(fpath) f, self.suffix = os.path.splitext(os.path.basename(fpath)) self.suffix = self.suffix.strip('.') splits = f.split('#') # check if RockPy compatible e.g. first part must be len(4) if not len(splits[0]) == 4: pass for i, block in enumerate(blocks[:len(splits)]): if splits[i]: try: block(splits[i]) except (ValueError, ): pass for i in ('sgroups', 'samples', 'mtypes', 'ftype', 'mass', 'height', 'diameter', 'massunit', 'lengthunit', 'heightunit', 'diameterunit', 'series', 'additional', 'comment', 'folder'): if locals()[i]: if isinstance(locals()[i], (tuple, list, set)): if not all(locals()[i]): continue setattr(self, i, locals()[i]) if self.additional is None: self.additional = '' if kwargs: for k, v in kwargs.items(): if v: print(k, v, self.additional) self.additional += '{}:{}'.format(k, v) if suffix: self.suffix = suffix if type(self.suffix) == int: self.suffix = '%03i' % self.suffix if not self.suffix: self.suffix = '000' if not self.sgroups: self.sgroups = None self.storage = [[self.sgroups, self.samples, self.mtypes, self.ftype], [ [self.mass, self.massunit], [self.height, self.heightunit], [self.diameter, self.diameterunit], ], self.series, (self.additional, ), self.comment]
def get_measurement(self, mtype=None, series=None, stype=None, sval=None, sval_range=None, mean=False, invert=False, id=None, result=None ): """ Returns a list of measurements of type = mtypes Parameters ---------- mtypes: list, str mtypes to be returned series: list(tuple) list of tuples, to search for several sepcific series. e.g. [('mtime',4),('gc',2)] will only return mesurements that fulfill both criteria. stypes: list, str series type sval_range: list, str series range e.g. sval_range = [0,2] will give all from 0 to 2 including 0,2 also '<2', '<=2', '>2', and '>=2' are allowed. svals: float series value to be searched for. caution: will be overwritten when sval_range is given invert: if invert true it returns only measurements that do not meet criteria sval_range: can be used to look up measurements within a certain range. if only one value is given, it is assumed to be an upper limit and the range is set to [0, sval_range] mean: bool id: list(int) search for given measurement id Returns ------- if no arguments are passed all sample.measurements list of RockPy.Measurements that meet search criteria or if invert is True, do not meet criteria. [] if none are found Note ---- there is no connection between stype and sval. This may cause problems. I you have measurements with M1: [pressure, 0.0, GPa], [temperature, 100.0, C] M2: [pressure, 1.0, GPa], [temperature, 100.0, C] and you search for stypes=['pressure','temperature'], svals=[0,100]. It will return both M1 and M2 because both M1 and M2 have [temperature, 100.0, C]. """ if mean: mlist = self.mean_measurements else: mlist = self.measurements if id is not None: id = RockPy3._to_tuple(id) mlist = filter(lambda x: x.id in id, mlist) return list(mlist) if mtype: mtype = RockPy3._to_tuple(mtype) mtype = tuple(RockPy3.abbrev_to_classname(mt) for mt in mtype) mlist = filter(lambda x: x.mtype in mtype, mlist) if stype: mlist = filter(lambda x: x.has_stype(stype=stype, method='any'), mlist) if sval_range is not None: sval_range = self._convert_sval_range(sval_range=sval_range, mean=mean) if not sval: sval = sval_range else: sval = RockPy3._to_tuple() sval += RockPy3._to_tuple(sval_range) if sval is not None: mlist = filter(lambda x: x.has_sval(sval=sval, method='any'), mlist) if series: series = RockPy3.core.utils.tuple2list_of_tuples(series) mlist = (x for x in mlist if x.has_series(series=series, method='all')) if result: mlist = filter(lambda x: x.has_result(result=result), mlist) if invert: if mean: mlist = filter(lambda x: x not in mlist, self.mean_measurements) else: mlist = filter(lambda x: x not in mlist, self.measurements) return list(mlist)
def import_folder( self, folder, sname=None, sgroup=None, mtype=None, automatic_results=True, ): # todo specify samples, mtypes and series for selective import of folder """ imports all files in the specified folder Parameters ---------- folder gname Returns ------- """ files = [ os.path.join(folder, i) for i in os.listdir(folder) if not i.startswith('#') if not i.startswith(".") if not i.endswith("pynb") if not i.endswith("log") if not os.path.isdir(os.path.join(folder, i)) ] measurements = [] start = time.clock() minfos = (RockPy3.core.file_operations.minfo(f) for f in files) minfos = (minfo for minfo in minfos if minfo.is_readable()) if mtype: mtype = RockPy3._to_tuple(mtype) mtype = [RockPy3.abbrev_to_classname(mt) for mt in mtype] for mi in minfos: RockPy3.logger.info('importing {}'.format(mi.fpath)) # dont import samples that are not in the measurement info if sname: sname = RockPy3._to_tuple(sname) if not any(s in mi.samples for s in sname): continue # dont import samples that are not included in a certain samplegroup in the measurement info if sgroup: sgroup = RockPy3._to_tuple(sgroup) if not any(sg in mi.sgroups for sg in sgroup): continue # check if the filename has not been imported, yet if mi.fpath in self.imported_files: continue else: self.imported_files.append(mi.fpath) for sinfo in mi.sample_infos: s = self.add_sample(warnings=False, **sinfo) for minfo in mi.measurement_infos: if mtype and minfo['mtype'].lower() not in mtype: continue if minfo['sample'] == sinfo['name']: measurements.append(s.add_measurement(**minfo)) end = time.clock() print('IMPORT generated {} measurements: finished in {:.02e}s'.format( len(measurements), end - start)) return measurements
def get_measurement(self, mtype=None, series=None, stype=None, sval=None, sval_range=None, mean=False, invert=False, id=None, result=None): """ Returns a list of measurements of type = mtypes Parameters ---------- mtypes: list, str mtypes to be returned series: list(tuple) list of tuples, to search for several sepcific series. e.g. [('mtime',4),('gc',2)] will only return mesurements that fulfill both criteria. stypes: list, str series type sval_range: list, str series range e.g. sval_range = [0,2] will give all from 0 to 2 including 0,2 also '<2', '<=2', '>2', and '>=2' are allowed. svals: float series value to be searched for. caution: will be overwritten when sval_range is given invert: if invert true it returns only measurements that do not meet criteria sval_range: can be used to look up measurements within a certain range. if only one value is given, it is assumed to be an upper limit and the range is set to [0, sval_range] mean: bool id: list(int) search for given measurement id Returns ------- if no arguments are passed all sample.measurements list of RockPy.Measurements that meet search criteria or if invert is True, do not meet criteria. [] if none are found Note ---- there is no connection between stype and sval. This may cause problems. I you have measurements with M1: [pressure, 0.0, GPa], [temperature, 100.0, C] M2: [pressure, 1.0, GPa], [temperature, 100.0, C] and you search for stypes=['pressure','temperature'], svals=[0,100]. It will return both M1 and M2 because both M1 and M2 have [temperature, 100.0, C]. """ if mean: mlist = self.mean_measurements else: mlist = self.measurements if id is not None: id = RockPy3._to_tuple(id) mlist = filter(lambda x: x.id in id, mlist) return list(mlist) if mtype: mtype = RockPy3._to_tuple(mtype) mtype = tuple(RockPy3.abbrev_to_classname(mt) for mt in mtype) mlist = filter(lambda x: x.mtype in mtype, mlist) if stype: mlist = filter(lambda x: x.has_stype(stype=stype, method='any'), mlist) if sval_range is not None: sval_range = self._convert_sval_range(sval_range=sval_range, mean=mean) if not sval: sval = sval_range else: sval = RockPy3._to_tuple() sval += RockPy3._to_tuple(sval_range) if sval is not None: mlist = filter(lambda x: x.has_sval(sval=sval, method='any'), mlist) if series: series = RockPy3.core.utils.tuple2list_of_tuples(series) mlist = (x for x in mlist if x.has_series(series=series, method='all')) if result: mlist = filter(lambda x: x.has_result(result=result), mlist) if invert: if mean: mlist = filter(lambda x: x not in mlist, self.mean_measurements) else: mlist = filter(lambda x: x not in mlist, self.measurements) return list(mlist)