cellpy.readers.instruments.arbin_res

arbin res-type data files

Module Contents

Classes

DataLoader

Class for loading arbin-data from res-files.

Attributes

ALLOW_MULTI_TEST_FILE
DEBUG_MODE
NORMAL_HEADERS_RENAMING_DICT
ODBC
SEARCH_FOR_ODBC_DRIVERS
SUMMARY_HEADERS_RENAMING_DICT
TABLE_NAMES
USE_SQLALCHEMY_ACCESS_ENGINE
current_platform
dbloader
driver_dll

class DataLoader(*args, **kwargs)

Bases: cellpy.readers.instruments.base.BaseLoader

Class for loading arbin-data from res-files.

Parameters from configuration (prms.Instruments.Arbin):

- max_res_filesize: break if file size exceeds this limit.
- chunk_size: size of chunks to load.
- max_chunks: max number of chunks to load.
- use_subprocess: use mdbtools or not.
- detect_subprocess_need: detect if mdbtools is needed.
- sub_process_path: path to mdbtools (or similar).
- office_version: version of office (32 or 64 bit).

instrument_name = 'arbin_res'

raw_ext = 'res'

static get_headers_aux()

Defines the so-called auxiliary table column headings for Arbin .res-files

static get_headers_aux_global()

Defines the so-called auxiliary global column headings for Arbin .res-files

static get_headers_global()

Defines the so-called global column headings for Arbin .res-files

static get_headers_normal()

Defines the so-called normal column headings for Arbin .res-files

static get_raw_limits()

Limits used to identify type of step.

The raw limits are ‘epsilons’ used to check if the current and/or voltage is stable (for example for galvanostatic steps, one would expect that the current is stable (constant) and non-zero). If the (accumulated) change is less than ‘epsilon’, then cellpy interpret it to be stable. It is expected that different instruments (with different resolution etc.) have different resolutions and noice levels, thus different ‘epsilons’.

Returns:

the raw limits (dict)

static get_raw_units()

Units used by the instrument.

The internal cellpy units are given in the cellpy_units attribute.

Returns:

dictionary of units (str)

Example

A minimum viable implementation could look like this:

@staticmethod
def get_raw_units():
    raw_units = dict()
    raw_units["current"] = "A"
    raw_units["charge"] = "Ah"
    raw_units["mass"] = "g"
    raw_units["voltage"] = "V"
    return raw_units

loader(name, *args, bad_steps=None, dataset_number=None, data_points=None, increment_cycle_index=True, **kwargs)

Loads data from arbin .res files.

Parameters:

• name (str) – path to .res file.

• bad_steps (list of tuples) – (c, s) tuples of steps s (in cycle c) to skip loading.

• dataset_number (int) – the data set number (‘Test-ID’) to select if you are dealing with arbin files with more than one data-set. Defaults to selecting all data-sets and merging them.

• data_points (tuple of ints) – load only data from data_point[0] to data_point[1] (use None for infinite).

• increment_cycle_index (bool) – increment the cycle index if merging several datasets (default True).

Returns:

new data (Data)

repair(file_name)

try to repair a broken/corrupted file

ALLOW_MULTI_TEST_FILE = False

DEBUG_MODE

NORMAL_HEADERS_RENAMING_DICT

ODBC

SEARCH_FOR_ODBC_DRIVERS

SUMMARY_HEADERS_RENAMING_DICT

TABLE_NAMES

USE_SQLALCHEMY_ACCESS_ENGINE = True

current_platform

dbloader

driver_dll