Schema for EPR measurement

[schumannj]

Schema for EPR:
- class EPR(Measurement):
- method = ‘Electron spin resonance’
- add data to the results subsection
- metadata of the instrument could go into a settings section
- files (one contains metadata and the other on the measurement data):
- ReRH_Nia-C_H_EPR_exp_raw.DSC
- ReRH_Nia-C_H_EPR_exp_raw.DTA

[schumannj]

• reader:

    ```python
    import struct
    import os
    import csv
    import json
    from itertools import zip_longest
    
    def parse_section(text, start_marker, end_marker):
        import re
        pattern = re.compile(rf"{re.escape(start_marker)}(.*?){re.escape(end_marker)}", re.DOTALL)
        match = pattern.search(text)
        return match.group(1).strip() if match else ""
    
    def refined_parse_key_value_pairs(section_text):
        data = {}
        # Remove asterisks and leading/trailing whitespace
        clean_lines = [line.strip().replace('*', '') for line in section_text.split('\n') if line.strip() and not line.startswith('*')]
        for line in clean_lines:
            if '=' in line:
                key, value = line.split('=', 1)
                data[key.strip()] = value.strip()
            elif '\t' in line:
                key, value = line.split('\t', 1)
                data[key.strip()] = value.strip()
        return data
    
    def generate_ydata_from_binary(inputfile):
        ydata = []
        with open(inputfile, 'rb') as file:
            indata = file.read()
        for i in range(0, len(indata), 8):
            pos = struct.unpack('>d', indata[i:i+8])
            ydata.append(pos[0])
        return ydata
    
    def generate_xdata_from_params(param_dict):
        xpoints = int(param_dict['XPTS'])
        xmin = float(param_dict['XMIN'])
        xwid = float(param_dict['XWID'])
        
        xmax = xmin + xwid
        xsampling = xwid / xpoints
        
        xdata = [xmin + (xsampling * i) for i in range(xpoints)]
        return xdata
    
    def read_dsc_file(file_path):
        with open(file_path, 'r') as file:
            dsc_contents = file.read()
        return dsc_contents
    
    def read_dta_file_full(file_path):
        with open(file_path, 'rb') as file:
            binary_data = file.read()
            
            data_dict = {
                'header_raw': binary_data[:128],  # First 128 bytes as raw header
                'data_points_raw': binary_data[128:],  # Remaining bytes as data points
            }
            
            try:
                data_dict['header_ascii'] = binary_data[:128].decode('ascii').strip()
            except UnicodeDecodeError:
                data_dict['header_ascii'] = None
            
            data_points_format = 'f' * ((len(binary_data) - 128) // 4)  # Assuming 4 bytes per float32
            try:
                data_dict['data_points_float'] = struct.unpack_from(data_points_format, binary_data, 128)
            except struct.error:
                data_dict['data_points_float'] = None
            
            return data_dict
    
    def parse_dta_dsc(dta_file, dsc_file):
        dta_data = read_dta_file_full(dta_file)
        dsc_contents = read_dsc_file(dsc_file)
    
        desc_section = parse_section(dsc_contents, '#DESC', '#SPL')
        spl_section = parse_section(dsc_contents, '#SPL', '#DSL')
        dsl_section = parse_section(dsc_contents, '#DSL', '#MHL')
        mhl_section = parse_section(dsc_contents, '#MHL', '*')
    
        desc_data = refined_parse_key_value_pairs(desc_section)
        spl_data = refined_parse_key_value_pairs(spl_section)
        dsl_data = refined_parse_key_value_pairs(dsl_section)
        mhl_data = refined_parse_key_value_pairs(mhl_section)
    
        dta_ydata = generate_ydata_from_binary(dta_file)
        dta_xdata = generate_xdata_from_params(desc_data)
    
        if len(dta_ydata) != len(dta_xdata):
            dta_ydata = dta_ydata[:len(dta_xdata)]
    
        merged_data = {
            'header': dta_data['header_ascii'],
            'data_points': dta_data['data_points_float'],
            'descriptor_info': desc_data,
            'standard_parameters': spl_data,
            'device_specific': dsl_data,
            'manipulation_history': mhl_data,
            'x_values': dta_xdata,
            'y_values': dta_ydata
        }
    
        return merged_data
    
    dta_file_path = '/mnt/data/ReRH_Nia-C_H_EPR_exp_raw.DTA'
    dsc_file_path = '/mnt/data/ReRH_Nia-C_H_EPR_exp_raw.DSC'
    
    merged_data = parse_dta_dsc(dta_file_path, dsc_file_path)
    
    # Save the merged data into a JSON file
    final_json_file_path = '/mnt/data/ReRH_Nia-C_H_EPR_exp_full_merged.json'
    with open(final_json_file_path, 'w') as json_file:
        json.dump(merged_data, json_file)
    
    final_json_file_path
    ```
  

  • Parser for EPR:

    • Do it in a similar thing as the xrd.parser in nomad-measurements does.

    nomad-measurements/src/nomad_measurements/xrd/parser at main · FAIRmat-NFDI/nomad-measurements

[ahm531]

In case additional parameters are needed (which my be missing from the file), the EPR is plotted in the paper in Figure 3D and is related to the sample ReRH_Nia-C_H lyophilizate.