read_mercury_cg Namespace Reference

Functions
def	mercury_cg (name='Chain.stat', print_summary=True, row_major_index_order=False)
	This function reads a MercuryCG .stat file and returns a dictionary of the data. More...
def	get_raw_data (name)
	This function reads raw data from a file. More...
def	get_dimension (data, raw, row_major_index_order)
	This function determines the dimension of the data. More...
def	get_coordinates (data, raw, dim, row_major_index_order)
	This function gets the spatial coordinates and time of the data. More...
def	get_variables (data, raw, names, dim, row_major_index_order)
	This function gets the variables of the data from the .stat file. More...
def	extend_variables (data)
	This function extends the variables of the data dictionary by computing several fields from the standard fields. More...
def	read_header1 (header1)
	Parse the first header line of the input file. More...

Variables
string	required_pandas_version = "1.2.0"
string	required_numpy_version = "1.20.0"
	installed_pandas_version = pd.__version__
	installed_numpy_version = np.__version__

Function Documentation

extend_variables()

def read_mercury_cg.extend_variables

(

data

)

This function extends the variables of the data dictionary by computing several fields from the standard fields.

Parameters

[in,out]

data

The data dictionary to extend the variables of.

Returns

data: A dictionary with the data with possible extended variables computed from the standard variables.

def extend_variables(data):
    """!
     @brief This function extends the variables of the data dictionary by computing several fields from the standard
            fields.
 
     @param[in,out] data
     The data dictionary to extend the variables of.
 
     @return data:
     A dictionary with the data with possible extended variables computed from the standard variables.
    """
    if 'ParticleSize0' in data:
        data['ParticleNumber'] = data['ParticleSize0']
        mean = data['ParticleSize1'] / data['ParticleNumber']
        mom2 = data['ParticleSize2'] / data['ParticleNumber']
        mom3 = data['ParticleSize3'] / data['ParticleNumber']
        mom4 = data['ParticleSize4'] / data['ParticleNumber']
        mom5 = data['ParticleSize5'] / data['ParticleNumber']
        mom5 = mom5 - 5 * mean * mom4 + 10 * mean ** 2 * mom3 - 10 * mean ** 3 * mom2 + 4 * mean ** 5
        mom4 = mom4 - 4 * mean * mom3 + 6 * mean ** 2 * mom2 - 3 * mean ** 4
        mom3 = mom3 - 3 * mean * mom2 + 2 * mean ** 3
        mom2 = mom2 - mean ** 2
        std = np.sqrt(mom2)
        data['ParticleSize'] = {'Mean': mean, 'Variance': mom2, 'Skewness': mom3 / std ** 3,
                                'Kurtosis': mom4 / std ** 4, 'Hyperskewness': mom5 / std ** 5}
 
    if 'Density' in data:
        data['VelocityX'] = data['MomentumX'] / data['Density']
        data['VelocityY'] = data['MomentumY'] / data['Density']
        data['VelocityZ'] = data['MomentumZ'] / data['Density']
        data['VelocityX'][data['Density'] == 0] = 0
        data['VelocityY'][data['Density'] == 0] = 0
        data['VelocityZ'][data['Density'] == 0] = 0
        data['KineticStressXX'] = data['MomentumFluxXX'] - data['MomentumX'] * data['VelocityX']
        data['KineticStressXY'] = data['MomentumFluxXY'] - data['MomentumX'] * data['VelocityY']
        data['KineticStressXZ'] = data['MomentumFluxXZ'] - data['MomentumX'] * data['VelocityZ']
        data['KineticStressYY'] = data['MomentumFluxYY'] - data['MomentumY'] * data['VelocityY']
        data['KineticStressYZ'] = data['MomentumFluxYZ'] - data['MomentumY'] * data['VelocityZ']
        data['KineticStressZZ'] = data['MomentumFluxZZ'] - data['MomentumZ'] * data['VelocityZ']
        data['StressXX'] = data['ContactStressXX'] + data['KineticStressXX']
        data['StressXY'] = data['ContactStressXY'] + data['KineticStressXY']
        data['StressXZ'] = data['ContactStressXZ'] + data['KineticStressXZ']
        data['StressYX'] = data['ContactStressYX'] + data['KineticStressXY']
        data['StressYY'] = data['ContactStressYY'] + data['KineticStressYY']
        data['StressYZ'] = data['ContactStressYZ'] + data['KineticStressYZ']
        data['StressZX'] = data['ContactStressZX'] + data['KineticStressXZ']
        data['StressZY'] = data['ContactStressZY'] + data['KineticStressYZ']
        data['StressZZ'] = data['ContactStressZZ'] + data['KineticStressZZ']
        data['ContactPressure'] = (data['ContactStressXX'] + data['ContactStressYY'] + data['ContactStressZZ']) / 3
        data['KineticPressure'] = (data['KineticStressXX'] + data['KineticStressYY'] + data['KineticStressZZ']) / 3
        data['FluctuatingKineticEnergy'] = data['KineticStressXX'] + data['KineticStressYY'] + data['KineticStressZZ']
        data['KineticEnergy'] = data['MomentumFluxXX'] + data['MomentumFluxYY'] + data['MomentumFluxZZ']
        data['Pressure'] = (data['StressXX'] + data['StressYY'] + data['StressZZ']) / 3
        data['Temperature'] = data['KineticPressure'] / data['Density']
    return data
 
 

Referenced by mercury_cg().

get_coordinates()

def read_mercury_cg.get_coordinates	(		data,
			raw,
			dim,
			row_major_index_order
	)

This function gets the spatial coordinates and time of the data.

This function extracts the spatial coordinates and time from the raw data and adds them to the data dictionary.

Parameters

[in,out]	data	A dictionary where the keys are the variable names and the values are numpy arrays of the data.
[in]	raw	A pandas DataFrame containing the raw data.
[in]	dim	A list representing the dimension of the data for spatial coordinates and time if applicable.
[in]	row_major_index_order	A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is zyx.

Returns

data: The data dictionary updated with the spatial coordinates and time if applicable.

def get_coordinates(data, raw, dim, row_major_index_order):
    """!
     @brief This function gets the spatial coordinates and time of the data.
     @details This function extracts the spatial coordinates and time from the raw data and adds them to the data
     dictionary.
 
     @param[in,out] data
     A dictionary where the keys are the variable names and the values are numpy arrays of the data.
 
     @param[in] raw
     A pandas DataFrame containing the raw data.
 
     @param[in] dim
     A list representing the dimension of the data for spatial coordinates and time if applicable.
 
     @param[in] row_major_index_order
     A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is
     zyx.
 
     @return data:
     The data dictionary updated with the spatial coordinates and time if applicable.
    """
 
    order = "C" if row_major_index_order else "F"
    data['t'] = np.reshape(raw.values[:, 0], dim, order=order)
    coord = 'xyz'
    coord = ''.join(c for c, n in zip(coord, data['n']) if n != 1)
    for i in range(len(coord)):
        data[coord[i]] = np.reshape(raw.values[:, i + 1], dim, order=order)
    return data
 
 

Referenced by mercury_cg().

get_dimension()

def read_mercury_cg.get_dimension	(		data,
			raw,
			row_major_index_order
	)

This function determines the dimension of the data.

This function calculates the dimension of the data based on the number of data points and the row major index order.

Parameters

[in]	data	A dictionary where the keys are the variable names and the values are numpy arrays of the data.
[in]	raw	A pandas DataFrame containing the raw data.
[in]	row_major_index_order	A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is zyx.

Returns

dim: A list representing the dimension of the data for spatial coordinates and time if applicable.

def get_dimension(data, raw, row_major_index_order):
    """!
     @brief This function determines the dimension of the data.
     @details This function calculates the dimension of the data based on the number of data points and the row major
     index order.
 
     @param[in] data
     A dictionary where the keys are the variable names and the values are numpy arrays of the data.
 
     @param[in] raw
     A pandas DataFrame containing the raw data.
 
     @param[in] row_major_index_order
     A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is
     zyx.
 
     @return dim:
     A list representing the dimension of the data for spatial coordinates and time if applicable.
    """
 
    if row_major_index_order:
        dim = data['n'] + [int(len(raw) / np.prod(data['n']))]
    else:
        dim = list(reversed(data['n'])) + [int(len(raw) / np.prod(data['n']))]
    dim = [d for d in dim if d != 1]
    dim.append(1) if not dim else None
    return dim
 
 

References int().

Referenced by mercury_cg().

get_raw_data()

def read_mercury_cg.get_raw_data

(

name

)

This function reads raw data from a file.

This function reads raw data from a file and returns the raw data and the headers.

Parameters

[in]

name

The name of the file to read from.

Returns

raw, header1, header2: The raw data of the .stat file, first header with the MercuryCG parameters, and second header with field names.

def get_raw_data(name):
    """!
     @brief This function reads raw data from a file.
     @details This function reads raw data from a file and returns the raw data and the headers.
 
     @param[in] name
     The name of the file to read from.
 
     @return raw, header1, header2:
     The raw data of the .stat file, first header with the MercuryCG parameters, and second header with field names.
    """
 
    with open(name, 'r') as file:
        lines = file.readlines()
 
    # Extract headers
    header1 = lines[0].strip()
    if len(lines) > 1:
        header2 = lines[1].strip().split()
    else:
        header2 = None
 
    # Read data
    data_lines = lines[2:]
    raw = pd.DataFrame([(float(x) for x in line.strip().split()) for line in data_lines])
 
    return raw, header1, header2
 
 

References oomph::DoubleVectorHelpers.split().

Referenced by mercury_cg().

get_variables()

def read_mercury_cg.get_variables	(		data,
			raw,
			names,
			dim,
			row_major_index_order
	)

This function gets the variables of the data from the .stat file.

This function extracts the variables from the raw data and adds them to the data dictionary.

Parameters

[in]	data	A dictionary where the keys are the variable names and the values are numpy arrays of the data.
[in]	raw	A pandas DataFrame containing the raw data.
[in]	names	A list of strings representing the field names of the input from a MercuryCG .stat file.
[in]	dim	A list representing the dimension of the data for spatial coordinates and time if applicable.
[in]	row_major_index_order	A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is zyx.

Returns

data: The data dictionary updated with the variables as new keys of the dictionary.

def get_variables(data, raw, names, dim, row_major_index_order):
    """!
     @brief This function gets the variables of the data from the .stat file.
     @details This function extracts the variables from the raw data and adds them to the data dictionary.
 
     @param[in] data
     A dictionary where the keys are the variable names and the values are numpy arrays of the data.
 
     @param[in] raw
     A pandas DataFrame containing the raw data.
 
     @param[in] names
     A list of strings representing the field names of the input from a MercuryCG .stat file.
 
     @param[in] dim
     A list representing the dimension of the data for spatial coordinates and time if applicable.
 
     @param[in] row_major_index_order
     A boolean value indicating whether the index order is row major. If True, the index order is xyz, otherwise it is
     zyx.
 
     @return data:
     The data dictionary updated with the variables as new keys of the dictionary.
    """
 
    order = "C" if row_major_index_order else "F"
    is_variable = [':' in name for name in names]
    for i in range(len(names)):
        if is_variable[i]:
            colon = names[i].find(':')
            hyphen = names[i].find('-')
            # if no hyphen is found
            if hyphen == -1:
                a = np.NaN
                b = np.NaN
            else:
                a = int(names[i][:hyphen])
                b = int(names[i][hyphen + 1:colon])
            n = names[i][colon + 1:]
            if hyphen == -1:
                a = int(names[i][:colon])
                data[n] = np.reshape(raw.values[:, a - 1], dim, order=order)
            elif b - a == 2:
                data[n + 'X'] = np.reshape(raw.values[:, a - 1], dim, order=order)
                data[n + 'Y'] = np.reshape(raw.values[:, a], dim, order=order)
                data[n + 'Z'] = np.reshape(raw.values[:, a + 1], dim, order=order)
            elif b - a == 5 and n != 'ParticleSize':
                data[n + 'XX'] = np.reshape(raw.values[:, a - 1], dim, order=order)
                data[n + 'XY'] = np.reshape(raw.values[:, a], dim, order=order)
                data[n + 'XZ'] = np.reshape(raw.values[:, a + 1], dim, order=order)
                data[n + 'YY'] = np.reshape(raw.values[:, a + 2], dim, order=order)
                data[n + 'YZ'] = np.reshape(raw.values[:, a + 3], dim, order=order)
                data[n + 'ZZ'] = np.reshape(raw.values[:, a + 4], dim, order=order)
            elif b - a == 8:
                data[n + 'XX'] = np.reshape(raw.values[:, a - 1], dim, order=order)
                data[n + 'XY'] = np.reshape(raw.values[:, a], dim, order=order)
                data[n + 'XZ'] = np.reshape(raw.values[:, a + 1], dim, order=order)
                data[n + 'YX'] = np.reshape(raw.values[:, a + 2], dim, order=order)
                data[n + 'YY'] = np.reshape(raw.values[:, a + 3], dim, order=order)
                data[n + 'YZ'] = np.reshape(raw.values[:, a + 4], dim, order=order)
                data[n + 'ZX'] = np.reshape(raw.values[:, a + 5], dim, order=order)
                data[n + 'ZY'] = np.reshape(raw.values[:, a + 6], dim, order=order)
                data[n + 'ZZ'] = np.reshape(raw.values[:, a + 7], dim, order=order)
            else:
                for j in range(a, b + 1):
                    data[n + str(j - a)] = np.reshape(raw.values[:, j - 1], dim, order=order)
    return data
 
 

References int(), and compute_granudrum_aor.str.

Referenced by mercury_cg().

mercury_cg()

def read_mercury_cg.mercury_cg	(		name = 'Chain.stat',
			print_summary = True,
			row_major_index_order = False
	)

This function reads a MercuryCG .stat file and returns a dictionary of the data.

This function reads a MercuryCG .stat file, processes the data, and returns a dictionary of the data. The dictionary keys are the variable names and the values are numpy arrays of the data.

Parameters

[in]	name	The name of the .stat file created by MercuryCG to read from. Default is 'Chain.stat'.
[in]	print_summary	If True, print a summary of the data key shapes. Default is True.
[in]	row_major_index_order	If True, the index order for spatial coordinates is xyz, otherwise it is zyx. Default is False.

Returns

data: A dictionary where the keys are the variable names and the values are numpy arrays of the data.

def mercury_cg(name='Chain.stat', print_summary=True, row_major_index_order=False):
    """!
     @brief This function reads a MercuryCG .stat file and returns a dictionary of the data.
     @details This function reads a MercuryCG .stat file, processes the data, and returns a dictionary of the data.
     The dictionary keys are the variable names and the values are numpy arrays of the data.
 
     @param[in] name
     The name of the .stat file created by MercuryCG to read from. Default is 'Chain.stat'.
 
     @param[in] print_summary
     If True, print a summary of the data key shapes. Default is True.
 
     @param[in] row_major_index_order
     If True, the index order for spatial coordinates is xyz, otherwise it is zyx. Default is False.
 
     @return data:
     A dictionary where the keys are the variable names and the values are numpy arrays of the data.
    """
 
    # ignore division by zero errors. Division by zero values will be set to NaN.
    # This line is just to suppress the error in the terminal
    np.seterr(divide='ignore', invalid='ignore')
 
    raw, header1, header2 = get_raw_data(name)
    data = read_header1(header1)
    data['name'] = name
    print(name)
    print(header1)
    dim = get_dimension(data, raw, row_major_index_order)
    data = get_coordinates(data, raw, dim, row_major_index_order)
    data = get_variables(data, raw, header2, dim, row_major_index_order)
    data = extend_variables(data)
    if print_summary:
        for key, value in data.items():
            print(f"{key}: {np.array(value).shape}")
    return data
 
 

References extend_variables(), get_coordinates(), get_dimension(), get_raw_data(), get_variables(), Eigen::internal.print(), and read_header1().

Referenced by compute_granudrum_aor.compute_granudrum_aor().

read_header1()

def read_mercury_cg.read_header1

(

header1

)

Parse the first header line of the input file.

This function takes the first header line of the input file, splits it into separate words, and extracts the values associated with certain keys. The keys it looks for are 'n', 'width', 'timeMin', 'min', and 'max'. The values associated with these keys are then converted to floats and stored in a dictionary.

Parameters

[in]

header1

A string of the first header line of the input file.

Returns

data: A dictionary where the keys are the keys found in the header line and the values are lists of floats associated with these keys. If a key is not found in the header line, its value in the dictionary is an empty list.

def read_header1(header1):
    """!
     @brief Parse the first header line of the input file.
     @details This function takes the first header line of the input file, splits it into
     separate words, and extracts the values associated with certain keys. The keys
     it looks for are 'n', 'width', 'timeMin', 'min', and 'max'. The values associated
     with these keys are then converted to floats and stored in a dictionary.
 
     @param[in] header1
     A string of the first header line of the input file.
 
     @return data:
     A dictionary where the keys are the keys found in the header line and the
     values are lists of floats associated with these keys. If a key is not found
     in the header line, its value in the dictionary is an empty list.
    """
 
    opt = header1.split()
    keys = ['n', 'width', 'timeMin', 'min', 'max']
    key_to_num_values = {'n': 3, 'width': 1, 'timeMin': 1, 'min': 3, 'max': 3}
    # List comprehension to get all the values that exist in the header
    values = [[float(opt[opt.index(key) + i]) for i in range(1, key_to_num_values[key] + 1)] if
              key in opt else [] for key in keys]
 
    data = {key: value if key in opt else [] for key, value in zip(keys, values)}
    data['n'] = [int(n) for n in data['n']]
    return data

References int().

Referenced by mercury_cg().

Variable Documentation

installed_numpy_version

read_mercury_cg.installed_numpy_version = np.__version__

installed_pandas_version

read_mercury_cg.installed_pandas_version = pd.__version__

required_numpy_version

string read_mercury_cg.required_numpy_version = "1.20.0"

required_pandas_version

string read_mercury_cg.required_pandas_version = "1.2.0"