def get_holder_from_file_name(file):
holder_search = 'holder\-<>'
return std.metadata_from_file_name(holder_search,
file,
is_numeric=True,
delimeter='',
abs_path=True)
def period_from_file_name( file, base_unit = 'ns' ):
"""
Retrieve pulse period from file name.
:param file: File name to extract data from.
:param base_unit: Base unit of time. [Default: 'ns']
:returns: period in units of base_unit.
"""
period_search = 'period(\d+[nu]s)'
match = std.metadata_from_file_name( period_search, file )
# convert to correct base
val = float( match[ :-2 ] )
unit = match[ -2: ]
if unit == base_unit:
# base unit and extracted unit match, no change needed.
return val
if unit == 'ns':
if base_unit == 'us':
return val* 1e3
elif unit == 'us':
if base_unit == 'ns':
return val* 1e-3
raise ValueError( 'Could not convert time unit to base unit.' )
def get_program_from_file_name( file ):
program_search = '(\d+)'
return std.metadata_from_file_name(
program_search,
file,
is_numeric = True,
delimeter = '_'
)
def get_metadata_values(file, metadata):
"""
Gets metadata values from a file path
:param file: The file path to search
:param metadata: Metadata from the file name is turned into MultiIndex columns
+ If list, use standard keywords to include in index [ 'sample', 'power', 'wavelength', 'time' ]
+ If Dictionary, keys indicate level name, value is pattern to match
or another dictionary with 'search' key being the pattern to match, and additional
entries matching arguments passed to standard_functions#metadata_from_filename.
+ Reseserved key 'standard' can be provided with a list value to get standard metadata
:returns: A list of metadata values
"""
if isinstance(metadata, list):
# use standard metadata
return get_standard_metadata_values(file, metadata)
if isinstance(metadata, dict):
# use custom metadata
# key is name, value is regexp pattern or dictionary with pattern and arguments
header_names = list(metadata.keys())
# get number of values
val_len = len(header_names)
if 'standard' in header_names:
val_len += len(metadata['standard']) - 1
vals = header_names.copy()
for name, search in metadata.items():
index = header_names.index(name)
if name == 'standard':
# insert standard keys
vals[index] = get_standard_metadata_values(file, search)
else:
# custom key
if isinstance(search, dict):
pattern = search['search']
kwargs = search.copy()
del kwargs['search']
else:
pattern = search
kwargs = {}
vals[index] = std.metadata_from_file_name(
pattern, file, **kwargs)
# fllatten standard keys
if 'standard' in header_names:
index = header_names.index('standard')
vals = vals[:index] + vals[index] + vals[index + 1:]
return vals
def center_wavelength_from_file_name( file ):
"""
Extract center wavelength from file name.
:param file: File name.
:returns: Center wavelength.
"""
center_search = 'em<>nm'
center = std.metadata_from_file_name( center_search, file, is_numeric = True )
return center
def get_channel_from_file_name(file, prefix='C'):
"""
:param prefix: The prefix of the channel. [Default: 'C']
"""
channel_search = '{}<>'.format(prefix)
return std.metadata_from_file_name(channel_search,
file,
is_numeric=True,
delimeter='',
abs_path=True)
def bandwidth_from_file_name( file ):
"""
Extract bandwidth from file name.
:parma file: File name.
:returns: Bandwidth.
"""
bandwidth_search = 'bandwidth<>nm'
bandwidth = std.metadata_from_file_name( bandwidth_search, file, is_numeric = True )
return bandwidth
def import_mpp_cycle_datum_channel(folder,
cycle_pattern='cycle-<>',
channel_pattern='ch-<>'):
"""
Imports MPP tracking data from an MPP with JV program, broken in to cycles.
:param folder: Folder path containing cycles.
:param cycle_pattern: Pattern for cycle folders. [Default: 'cycle-<>']
:param channel_pattern: Pattern for channel folders. [Default: 'ch-<>']
:returns: Tuple of ( voc, jv, mpp ) Pandas DataFrames by cycle.
"""
# get scan folders
cycles = os.listdir(folder)
# get data for each scan
vocs = []
jvs = []
mpps = []
for cycle in cycles:
cycle_path = os.path.join(folder, cycle)
dfs = (voc, jv,
mpp) = import_mpp_datum_channel(cycle_path) # import scan data
# add scan index
cycle_id = int(
std.metadata_from_file_name(cycle_pattern,
cycle_path,
full_path=True,
is_numeric=True))
for df in dfs:
# channel already in headers
std.insert_index_levels(df, cycle_id, 'cycle', key_level=1)
vocs.append(voc)
jvs.append(jv)
mpps.append(mpp)
vocs = std.common_reindex(vocs)
jvs = std.common_reindex(jvs)
mpps = std.common_reindex(mpps)
vocs = pd.concat(vocs, axis=1).sort_index(axis=1)
jvs = pd.concat(jvs, axis=1).sort_index(axis=1)
mpps = pd.concat(mpps, axis=1).sort_index(axis=1)
return (vocs, jvs, mpps)
def cycle_from_file_path(path, pattern='cycle-<>'):
"""
Gets the cycle from the file path.
:param path: File path.
:param pattern: RegEx pattern describing teh channel pattern.
Passed to standard_functions#metadata_from_file_name.
[Default: 'cycle-<>']
"""
cycle = std.metadata_from_file_name(pattern,
path,
is_numeric=True,
full_path=True)
return int(cycle)
def sample_from_file_name( file ):
name_search = '^(.*?)' # use lazy search
return std.metadata_from_file_name( name_search, file, delimeter = '--' )
def pressure_from_file_name(file):
pressure_search = '<>hpa'
return std.metadata_from_file_name(pressure_search,
file,
True,
decimal='p')
def temperature_from_file_name(file):
temperature_search = '<>'
return std.metadata_from_file_name(temperature_search,
file,
True,
decimal='k')
def channel_from_file_name( file ):
channel_search = '^Ch(\d+)'
return std.metadata_from_file_name( channel_search, file, is_numeric = True, delimeter = '_' )
def power_from_file_name(file):
power_search = '<>mw'
return std.metadata_from_file_name(power_search, file, True)
def angle_from_file_name(file):
angle_search = '<>deg'
return std.metadata_from_file_name(angle_search, file, True)
def sample_from_file_name(file):
name_search = '^(.*?)' # use lazy matching
return std.metadata_from_file_name(name_search, file)
def sample_from_file_name( file ):
name_search = '(.+?)'
return std.metadata_from_file_name( name_search, file, delimeter = '_', group = 1 )
def time_from_file_name(file):
time_search = '<>'
return std.metadata_from_file_name(time_search, file, True, decimal='s')
def get_metadata_values(md_map, file, metadata):
"""
Gets metadata values from a file path.
:param md_map: Dictionary of keys to callables to extract metadata.
Callables should accept a single parameter which is the file name.
:param file: The file path to search.
:param metadata: Metadata from the file name is turned into MultiIndex columns.
+ If list, use standard keywords to include in index [ 'sample' ]
+ If Dictionary, keys indicate level name.
Value can be a regex pattern to match or another dictionary.
If a dictionary, key 'search' is a pattern to match
passed to standard_functions#metadata_from_filename, and key-value pairs
are keyword arguments of standard_functions#metadata_from_filename.
+ Reseserved key 'standard' can be provided with a list
of standard metadata names.
[See also standard_functions#metadata_from_filename]
:returns: Tuple of metadata values.
"""
if isinstance(metadata, list):
# use standard metadata
return get_standard_metadata_values(md_map, file, metadata)
if isinstance(metadata, dict):
# use custom metadata
# key is name, value is regexp pattern or dictionary with pattern and arguments
header_names = list(metadata.keys())
# get number of values
val_len = len(header_names)
if 'standard' in header_names:
val_len += len(metadata['standard']) - 1
vals = header_names.copy()
for name, search in metadata.items():
index = header_names.index(name)
if name == 'standard':
# insert standard keys
vals[index] = get_standard_metadata_values(
md_map, file, search)
else:
# custom key
if isinstance(search, dict):
pattern = search['search']
kwargs = search.copy()
del kwargs['search']
else:
pattern = search
kwargs = {}
vals[index] = std.metadata_from_file_name(
pattern, file, **kwargs)
# flatten standard keys
if 'standard' in header_names:
index = header_names.index('standard')
vals = vals[:index] + list(vals[index]) + vals[index + 1:]
return tuple(vals)
def wavelength_from_file_name(file):
wavelength_search = '<>nm'
return std.metadata_from_file_name(wavelength_search, file, True)
