sdds.py File Reference

Detailed Description

Python script providing the SDDS Python module.

This module provides the SDDS class and associated methods to load, manipulate, and save SDDS files. It supports both ASCII and binary SDDS formats and provides functionality to read, write, and manipulate SDDS data.

Dependencies: sddsdata module

Definition in file sdds.py.

Go to the source code of this file.

Functions
SDDS	sdds.load (input_file)
	Loads an SDDS file into the SDDS object.
SDDS	sdds.loadSparse (input_file, interval, offset)
	Loads an SDDS file into the SDDS object with sparse data reading.
SDDS	sdds.loadLastRows (input_file, lastrows)
	Loads an SDDS file into the SDDS object, reading only the last few rows.
	sdds.save (SDDS sdds_obj, output_file)
	Saves the SDDS object's data to an SDDS file.
	sdds.sdds_data_type_to_string (data_type_code)
	Converts a numeric SDDS data type code to its string representation.
	sdds.sdds_data_type_to_short_string (data_type_code)
	Converts a numeric SDDS data type code to its short string representation.
	sdds.sdds_short_string_to_data_type (data_type_code)
	Converts a numeric SDDS data type code to its short string representation.
	sdds.demo1 (output)
	Demonstrates how to save a demo SDDS file using the SDDS class.
	sdds.demo2 (output)
	Demonstrates how to save a demo SDDS file using the SDDS class with simplified definitions.
	sdds.demo3 (output)
	Demonstrates how to save a demo SDDS file using sddsdata commands directly.
	sdds.demo4 (output)
	Demonstrates how to save a demo SDDS file using sddsdata commands and writing one row at a time.
	sdds.demo5 (output)
	Demonstrates how to open an existing SDDS file and add rows to the last page without loading the whole file into memory.
	sdds.demo6 (output)
	Demonstrates how to open an existing SDDS file and add a new page.
SddsFile	sdds.read (input_file)
	Mostly backward compatible with the PyLHC sdds module read() function.
	sdds.write (SddsFile sdds_file, output_file)
	Mostly backward compatible with the PyLHC sdds module write() function.

Function Documentation

demo1()

sdds.demo1

(

output

)

Demonstrates how to save a demo SDDS file using the SDDS class.

Args: output (str): The output SDDS filename to save the demo data.

This function creates an SDDS object, populates it with sample data, and saves it to the specified output file.

Definition at line 1494 of file sdds.py.

def demo1(output):
    """
    Demonstrates how to save a demo SDDS file using the SDDS class.
 
    Args:
        output (str): The output SDDS filename to save the demo data.
 
    This function creates an SDDS object, populates it with sample data, and saves it to the specified output file.
    """
    x = SDDS()
    x.description[0] = "text"
    x.description[1] = "contents"
    x.parameterName = ["ShortP", "LongP", "FloatP", "DoubleP", "StringP", "CharacterP"]
    x.parameterData = [[1, 6], [2, 7], [3.3, 8.8], [4.4, 9.8], ["five", "ten"], ["a", "b"]]
    x.parameterDefinition = [
        ["", "", "", "", x.SDDS_SHORT, ""],
        ["", "", "", "", x.SDDS_LONG, ""],
        ["", "", "", "", x.SDDS_FLOAT, ""],
        ["", "", "", "", x.SDDS_DOUBLE, ""],
        ["", "", "", "", x.SDDS_STRING, ""],
        ["", "", "", "", x.SDDS_CHARACTER, ""],
    ]
 
    x.arrayName = ["ShortA", "LongA", "FloatA", "DoubleA", "StringA", "CharacterA"]
    x.arrayDefinition = [
        ["", "", "", "", "", x.SDDS_SHORT, 0, 1],
        ["", "", "", "", "", x.SDDS_LONG, 0, 1],
        ["", "", "", "", "", x.SDDS_FLOAT, 0, 2],
        ["", "", "", "", "", x.SDDS_DOUBLE, 0, 1],
        ["", "", "", "", "", x.SDDS_STRING, 0, 1],
        ["", "", "", "", "", x.SDDS_CHARACTER, 0, 1],
    ]
    x.arrayDimensions = [
        [[6], [8]],
        [[5], [7]],
        [[2, 3], [2, 4]],
        [[4], [5]],
        [[4], [5]],
        [[4], [5]],
    ]
    x.arrayData = [
        [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7, 8]],
        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7]],
        [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7, 8]],
        [[1, 2, 3, 4], [1, 2, 3, 4, 5]],
        [["one", "two", "three", "four"], ["five", "six", "seven", "eight", "nine"]],
        [["a", "b", "c", "d"], ["e", "f", "g", "h", "i"]],
    ]
 
    x.columnName = ["ShortC", "LongC", "FloatC", "DoubleC", "StringC", "CharacterC"]
    x.columnData = [
        [[1, 2, 3], [-1, -2, -3, -4]],
        [[1, 2, 3], [-1, -2, -3, -4]],
        [[1, 2, 3], [-1, -2, -3.6, -4.4]],
        [[1, 2, 3], [-1, -2, -3.6, -4.4]],
        [["row 1", "row 2", "row 3"], ["row 1", "row 2", "row 3", "row 4"]],
        [["x", "y", "z"], ["i", "j", "k", "l"]],
    ]
    x.columnDefinition = [
        ["", "", "", "", x.SDDS_SHORT, 0],
        ["", "", "", "", x.SDDS_LONG, 0],
        ["", "", "", "", x.SDDS_FLOAT, 0],
        ["", "", "", "", x.SDDS_DOUBLE, 0],
        ["", "", "", "", x.SDDS_STRING, 0],
        ["", "", "", "", x.SDDS_CHARACTER, 0],
    ]
 
    x.save(output)
    del x
 
 

demo2()

sdds.demo2

(

output

)

Demonstrates how to save a demo SDDS file using the SDDS class with simplified definitions.

Args: output (str): The output SDDS filename to save the demo data.

This function shows how to use simplified methods to define parameters, arrays, and columns.

Definition at line 1565 of file sdds.py.

def demo2(output):
    """
    Demonstrates how to save a demo SDDS file using the SDDS class with simplified definitions.
 
    Args:
        output (str): The output SDDS filename to save the demo data.
 
    This function shows how to use simplified methods to define parameters, arrays, and columns.
    """
    x = SDDS()
    x.setDescription("text", "contents")
    names = ["Short", "Long", "Float", "Double", "String", "Character"]
    types = [x.SDDS_SHORT, x.SDDS_LONG, x.SDDS_FLOAT, x.SDDS_DOUBLE, x.SDDS_STRING, x.SDDS_CHARACTER]
    for i in range(6):
        x.defineSimpleParameter(names[i] + "P", types[i])
        if types[i] == x.SDDS_FLOAT:
            x.defineSimpleArray(names[i] + "A", types[i], 2)
        else:
            x.defineSimpleArray(names[i] + "A", types[i], 1)
        x.defineSimpleColumn(names[i] + "C", types[i])
    parameterData = [[1, 6], [2, 7], [3.3, 8.8], [4.4, 9.8], ["five", "ten"], ["a", "b"]]
    for i in range(6):
        x.setParameterValueList(names[i] + "P", parameterData[i])
 
    arrayDimensions = [
        [[6], [8]],
        [[5], [7]],
        [[2, 3], [2, 4]],
        [[4], [5]],
        [[4], [5]],
        [[4], [5]],
    ]
    arrayData = [
        [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7, 8]],
        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7]],
        [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7, 8]],
        [[1, 2, 3, 4], [1, 2, 3, 4, 5]],
        [["one", "two", "three", "four"], ["five", "six", "seven", "eight", "nine"]],
        [["a", "b", "c", "d"], ["e", "f", "g", "h", "i"]],
    ]
    for i in range(6):
        x.setArrayValueLists(names[i] + "A", arrayData[i], arrayDimensions[i])
 
    columnData = [
        [[1, 2, 3], [-1, -2, -3, -4]],
        [[1, 2, 3], [-1, -2, -3, -4]],
        [[1, 2, 3], [-1, -2, -3.6, -4.4]],
        [[1, 2, 3], [-1, -2, -3.6, -4.4]],
        [["row 1", "row 2", "row 3"], ["row 1", "row 2", "row 3", "row 4"]],
        [["x", "y", "z"], ["i", "j", "k", "l"]],
    ]
    for i in range(6):
        x.setColumnValueLists(names[i] + "C", columnData[i])
    x.save(output)
 
 

demo3()

sdds.demo3

(

output

)

Demonstrates how to save a demo SDDS file using sddsdata commands directly.

Args: output (str): The output SDDS filename to save the demo data.

This function shows how to use sddsdata module functions directly to create and save an SDDS file.

Definition at line 1621 of file sdds.py.

def demo3(output):
    """
    Demonstrates how to save a demo SDDS file using `sddsdata` commands directly.
 
    Args:
        output (str): The output SDDS filename to save the demo data.
 
    This function shows how to use `sddsdata` module functions directly to create and save an SDDS file.
    """
    x = SDDS()
 
    try:
        # Open SDDS output file
        if sddsdata.InitializeOutput(x.index, x.SDDS_BINARY, 1, "", "", output) != 1:
            raise ValueError("Failed to initialize SDDS output.")
        # Setting column_major to true. Only use this if you are going to write whole columns and not one row at a time.
        sddsdata.SetColumnMajorOrder(x.index)
        # Define parameters
        if sddsdata.DefineSimpleParameter(x.index, "ParameterA", "mm", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define parameter.")
        # Define arrays
        if sddsdata.DefineSimpleArray(x.index, "ArrayA", "DegC", x.SDDS_DOUBLE, 1) != 1:
            raise ValueError("Failed to define array.")
        if sddsdata.DefineSimpleArray(x.index, "ArrayB", "DegC", x.SDDS_DOUBLE, 2) != 1:
            raise ValueError("Failed to define array.")
        # Define columns
        if sddsdata.DefineSimpleColumn(x.index, "ColumnA", "Volts", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define column.")
        if sddsdata.DefineSimpleColumn(x.index, "ColumnB", "Amps", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define column.")
        # Write SDDS header
        if sddsdata.WriteLayout(x.index) != 1:
            raise ValueError("Failed to write SDDS layout.")
        # Start SDDS page. Allocate 100 rows.
        if sddsdata.StartPage(x.index, 100) != 1:
            raise ValueError("Failed to start SDDS page.")
        # Set parameter values
        if sddsdata.SetParameter(x.index, "ParameterA", 1.1) != 1:
            raise ValueError("Failed to set parameter value.")
        # Set array values
        if sddsdata.SetArray(x.index, "ArrayA", [1, 2, 3], [3]) != 1:
            raise ValueError("Failed to set array value.")
        if sddsdata.SetArray(x.index, "ArrayB", [1, 2, 3, 4, 5, 6], [2, 3]) != 1:
            raise ValueError("Failed to set array value.")
        # Set column values
        if sddsdata.SetColumn(x.index, "ColumnA", [1, 2, 3]) != 1:
            raise ValueError("Failed to set column value.")
        if sddsdata.SetColumn(x.index, "ColumnB", [1, 2, 3]) != 1:
            raise ValueError("Failed to set column value.")
        # Write page to disk
        if sddsdata.WritePage(x.index) != 1:
            raise ValueError("Failed to write SDDS page.")
        # Close SDDS output file
        if sddsdata.Terminate(x.index) != 1:
            raise ValueError("Failed to terminate SDDS output.")
 
    except:
        sddsdata.PrintErrors(x.SDDS_VERBOSE_PrintErrors)
        raise
 
 

demo4()

sdds.demo4

(

output

)

Demonstrates how to save a demo SDDS file using sddsdata commands and writing one row at a time.

Args: output (str): The output SDDS filename to save the demo data.

This function shows how to write data to an SDDS file one row at a time, useful for logging applications.

Definition at line 1682 of file sdds.py.

def demo4(output):
    """
    Demonstrates how to save a demo SDDS file using `sddsdata` commands and writing one row at a time.
 
    Args:
        output (str): The output SDDS filename to save the demo data.
 
    This function shows how to write data to an SDDS file one row at a time, useful for logging applications.
    """
    x = SDDS()
 
    try:
        # Open SDDS output file
        if sddsdata.InitializeOutput(x.index, x.SDDS_BINARY, 1, "", "", output) != 1:
            raise ValueError("Failed to initialize SDDS output.")
        # Turning on fsync mode and fixed rows count mode. These are useful for loggers.
        sddsdata.EnableFSync(x.index)
        sddsdata.SetFixedRowCountMode(x.index)
        # Define parameters
        if sddsdata.DefineSimpleParameter(x.index, "ParameterA", "mm", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define parameter.")
        # Define arrays
        if sddsdata.DefineSimpleArray(x.index, "ArrayA", "DegC", x.SDDS_DOUBLE, 1) != 1:
            raise ValueError("Failed to define array.")
        if sddsdata.DefineSimpleArray(x.index, "ArrayB", "DegC", x.SDDS_DOUBLE, 2) != 1:
            raise ValueError("Failed to define array.")
        # Define columns
        if sddsdata.DefineSimpleColumn(x.index, "ColumnA", "Volts", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define column.")
        if sddsdata.DefineSimpleColumn(x.index, "ColumnB", "Amps", x.SDDS_DOUBLE) != 1:
            raise ValueError("Failed to define column.")
        # Write SDDS header
        if sddsdata.WriteLayout(x.index) != 1:
            raise ValueError("Failed to write SDDS layout.")
        # Start SDDS page, allocate 2 rows.
        if sddsdata.StartPage(x.index, 2) != 1:
            raise ValueError("Failed to start SDDS page.")
        # Set parameter values
        if sddsdata.SetParameter(x.index, "ParameterA", 1.1) != 1:
            raise ValueError("Failed to set parameter value.")
        # Set array values
        if sddsdata.SetArray(x.index, "ArrayA", [1, 2, 3], [3]) != 1:
            raise ValueError("Failed to set array value.")
        if sddsdata.SetArray(x.index, "ArrayB", [1, 2, 3, 4, 5, 6], [2, 3]) != 1:
            raise ValueError("Failed to set array value.")
        # Set all columns, one row at a time
        if sddsdata.SetRowValues(x.index, 0, ["ColumnA", 1, "ColumnB", 1]) != 1:
            raise ValueError("Failed to set row values.")
        if sddsdata.SetRowValues(x.index, 1, ["ColumnA", 2, "ColumnB", 2]) != 1:
            raise ValueError("Failed to set row values.")
        # Update page because we reached the row allocation limit set in the StartPage command
        if sddsdata.UpdatePage(x.index, x.SDDS_FLUSH_TABLE) != 1:
            raise ValueError("Failed to update SDDS page.")
        # Set more rows
        if sddsdata.SetRowValues(x.index, 2, ["ColumnA", 3, "ColumnB", 3]) != 1:
            raise ValueError("Failed to set row values.")
        # Update page
        if sddsdata.UpdatePage(x.index, x.SDDS_FLUSH_TABLE) != 1:
            raise ValueError("Failed to update SDDS page.")
        # Close SDDS output file
        if sddsdata.Terminate(x.index) != 1:
            raise ValueError("Failed to terminate SDDS output.")
 
    except:
        sddsdata.PrintErrors(x.SDDS_VERBOSE_PrintErrors)
        raise
 
 

demo5()

sdds.demo5

(

output

)

Demonstrates how to open an existing SDDS file and add rows to the last page without loading the whole file into memory.

Args: output (str): The output SDDS filename to append data.

This function shows how to append data to an existing SDDS file efficiently.

Definition at line 1750 of file sdds.py.

def demo5(output):
    """
    Demonstrates how to open an existing SDDS file and add rows to the last page without loading the whole file into memory.
 
    Args:
        output (str): The output SDDS filename to append data.
 
    This function shows how to append data to an existing SDDS file efficiently.
    """
    x = SDDS()
 
    try:
        # Open SDDS output file
        rows = sddsdata.InitializeAppendToPage(x.index, output, 100)
        if rows == 0:
            raise ValueError("Failed to initialize appending to SDDS page.")
        # Set all columns, one row at a time
        if sddsdata.SetRowValues(x.index, rows, ["ColumnA", 4, "ColumnB", 4]) != 1:
            raise ValueError("Failed to set row values.")
        if sddsdata.SetRowValues(x.index, rows + 1, ["ColumnA", 5, "ColumnB", 5]) != 1:
            raise ValueError("Failed to set row values.")
        if sddsdata.SetRowValues(x.index, rows + 2, ["ColumnA", 6, "ColumnB", 6]) != 1:
            raise ValueError("Failed to set row values.")
        # Update page
        if sddsdata.UpdatePage(x.index, x.SDDS_FLUSH_TABLE) != 1:
            raise ValueError("Failed to update SDDS page.")
        # Close SDDS output file
        if sddsdata.Terminate(x.index) != 1:
            raise ValueError("Failed to terminate SDDS output.")
 
    except:
        sddsdata.PrintErrors(x.SDDS_VERBOSE_PrintErrors)
        raise
 
 

demo6()

sdds.demo6

(

output

)

Demonstrates how to open an existing SDDS file and add a new page.

Args: output (str): The output SDDS filename to append data.

This function shows how to append a new page to an existing SDDS file.

Definition at line 1785 of file sdds.py.

def demo6(output):
    """
    Demonstrates how to open an existing SDDS file and add a new page.
 
    Args:
        output (str): The output SDDS filename to append data.
 
    This function shows how to append a new page to an existing SDDS file.
    """
    x = SDDS()
 
    try:
        # Open SDDS output file
        if sddsdata.InitializeAppend(x.index, output) != 1:
            raise ValueError("Failed to initialize appending to SDDS file.")
        # Allocate rows
        if sddsdata.StartPage(x.index, 100) != 1:
            raise ValueError("Failed to start SDDS page.")
        # Set parameter values
        if sddsdata.SetParameter(x.index, "ParameterA", 1.1) != 1:
            raise ValueError("Failed to set parameter value.")
        # Set array values
        if sddsdata.SetArray(x.index, "ArrayA", [1, 2, 3], [3]) != 1:
            raise ValueError("Failed to set array value.")
        if sddsdata.SetArray(x.index, "ArrayB", [1, 2, 3, 4, 5, 6], [2, 3]) != 1:
            raise ValueError("Failed to set array value.")
        # Set all columns, one row at a time
        if sddsdata.SetRowValues(x.index, 0, ["ColumnA", 7, "ColumnB", 7]) != 1:
            raise ValueError("Failed to set row values.")
        if sddsdata.SetRowValues(x.index, 1, ["ColumnA", 8, "ColumnB", 8]) != 1:
            raise ValueError("Failed to set row values.")
        if sddsdata.SetRowValues(x.index, 2, ["ColumnA", 9, "ColumnB", 9]) != 1:
            raise ValueError("Failed to set row values.")
        # Write page
        if sddsdata.WritePage(x.index) != 1:
            raise ValueError("Failed to write SDDS page.")
        # Close SDDS output file
        if sddsdata.Terminate(x.index) != 1:
            raise ValueError("Failed to terminate SDDS output.")
 
    except:
        sddsdata.PrintErrors(x.SDDS_VERBOSE_PrintErrors)
        raise
 
@dataclass

load()

SDDS sdds.load

(

input_file

)

Loads an SDDS file into the SDDS object.

Args: input_file (str): The input SDDS filename to load.

Raises: Exception: If unable to read the SDDS data.

This method reads the SDDS file specified by input, and populates the object's data structures with the parameters, arrays, columns, and their respective data.

Definition at line 1323 of file sdds.py.

def load(input_file) -> SDDS:
    """
    Loads an SDDS file into the SDDS object.
 
    Args:
        input_file (str): The input SDDS filename to load.
 
    Raises:
        Exception: If unable to read the SDDS data.
 
    This method reads the SDDS file specified by `input`, and populates the object's data structures
    with the parameters, arrays, columns, and their respective data.
    """
 
    # Initialize an SDDS object
    sdds_obj = SDDS()
 
    # Load the file
    try:
        sdds_obj.load(input_file)
    except Exception as e:
        raise ValueError(f"Failed to load the SDDS file: {e}")
 
    return sdds_obj
 

loadLastRows()

SDDS sdds.loadLastRows	(		input_file,
			lastrows )

Loads an SDDS file into the SDDS object, reading only the last few rows.

Args: input_file (str): The input SDDS filename to load. lastrows (int): Number of last rows to read.

Raises: Exception: If unable to read the SDDS data.

This method reads only the last lastrows rows from each page of the SDDS file.

Definition at line 1373 of file sdds.py.

def loadLastRows(input_file, lastrows) -> SDDS:
    """
    Loads an SDDS file into the SDDS object, reading only the last few rows.
 
    Args:
        input_file (str): The input SDDS filename to load.
        lastrows (int): Number of last rows to read.
 
    Raises:
        Exception: If unable to read the SDDS data.
 
    This method reads only the last `lastrows` rows from each page of the SDDS file.
    """
    # Initialize an SDDS object
    sdds_obj = SDDS()
 
    # Load the file
    try:
        sdds_obj.loadLastRows(input_file, lastrows)
    except Exception as e:
        raise ValueError(f"Failed to load the SDDS file: {e}")
 
    return sdds_obj
 

loadSparse()

SDDS sdds.loadSparse	(		input_file,
			interval,
			offset )

Loads an SDDS file into the SDDS object with sparse data reading.

Args: input_file (str): The input SDDS filename to load. interval (int): Interval between pages to read. offset (int): Offset to start reading from.

Raises: Exception: If unable to read the SDDS data.

This method reads every interval pages from the SDDS file, starting from the page at offset.

Definition at line 1348 of file sdds.py.

def loadSparse(input_file, interval, offset) -> SDDS:
    """
    Loads an SDDS file into the SDDS object with sparse data reading.
 
    Args:
        input_file (str): The input SDDS filename to load.
        interval (int): Interval between pages to read.
        offset (int): Offset to start reading from.
 
    Raises:
        Exception: If unable to read the SDDS data.
 
    This method reads every `interval` pages from the SDDS file, starting from the page at `offset`.
    """
    # Initialize an SDDS object
    sdds_obj = SDDS()
 
    # Load the file
    try:
        sdds_obj.loadSparse(input_file, interval, offset)
    except Exception as e:
        raise ValueError(f"Failed to load the SDDS file: {e}")
 
    return sdds_obj
 

read()

SddsFile sdds.read

(

input_file

)

Mostly backward compatible with the PyLHC sdds module read() function.

Unlike the PyLHC version, this function reads all the SDDS pages and works with column data. The data is returned in a structured dictionary.

Args: input_file (str): The input SDDS file to be read.

Returns: dict: A dictionary with parameters, arrays, and columns data. Example structure: { pages = {integer}, binary = {boolean}, "definitions": {name: {"type:" string, "units": string, "description": string}, "values": {parameter_name: {[Page1Value, Page2Value, ...]}, {array_name: {[Page1List, Page2List, ...]}, {column_name: {[Page1List, Page2List, ...]}, "values": {array_name: {[page1DimList, Page2DimList, ...]} }

Definition at line 1870 of file sdds.py.

def read(input_file) -> SddsFile:
    """
    Mostly backward compatible with the PyLHC sdds module read() function.
    Unlike the PyLHC version, this function reads all the SDDS pages and works with column data.
    The data is returned in a structured dictionary.
 
    Args:
        input_file (str): The input SDDS file to be read.
 
    Returns:
        dict: A dictionary with parameters, arrays, and columns data.
              Example structure:
              {
                  pages =        {integer},
                  binary =       {boolean},
                  "definitions": {name: {"type:" string, "units": string, "description": string},
                  "values":      {parameter_name: {[Page1Value, Page2Value, ...]},
                                 {array_name:     {[Page1List, Page2List, ...]},
                                 {column_name:    {[Page1List, Page2List, ...]},
                  "values":      {array_name:     {[page1DimList, Page2DimList, ...]}
              }
    """
    # Initialize an SDDS object
    sdds_obj = SDDS()
 
    # Load the file
    try:
        sdds_obj.load(input_file)
    except Exception as e:
        raise ValueError(f"Failed to load the SDDS file: {e}")
 
    # Initialize the output dictionary
    sdds_data = SddsFile()
 
    # Store the data mode (ascii or binary)
    if sdds_obj.mode == SDDS.SDDS_BINARY:
        sdds_data.binary = True
    else:
        sdds_data.binary = False
 
    # Store description data
    text = sdds_obj.description[0] if sdds_obj.description[0] != "" else None
    contents = sdds_obj.description[1] if sdds_obj.description[1] != "" else None
    description_instance = Description(text=text, contents=contents)
    sdds_data.description = description_instance
 
    # Store number of pages
    sdds_data.pages = sdds_obj.loaded_pages
 
    # Store parameter data
    if sdds_obj.parameterName:
        for i, definition in enumerate(sdds_obj.parameterDefinition):
            name = sdds_obj.parameterName[i]
            symbol = definition[0] if definition[0] != '' else None
            units = definition[1] if definition[1] != '' else None
            description = definition[2] if definition[2] != '' else None
            formatString = definition[3] if definition[3] != '' else None
            datatype = sdds_data_type_to_short_string(definition[4])
            fixedValue = definition[5] if definition[5] != '' else None
            parameter_instance = Parameter(name=name, type=datatype, symbol=symbol, units=units, description=description, format_string=formatString, fixed_value=fixedValue)
            sdds_data.definitions.update({name: parameter_instance})
            sdds_data.values.update({name: sdds_obj.parameterData[i]})
 
    # Store array data
    if sdds_obj.arrayName:
        for i, definition in enumerate(sdds_obj.arrayDefinition):
            name = sdds_obj.arrayName[i]
            symbol = definition[0] if definition[0] != '' else None
            units = definition[1] if definition[1] != '' else None
            description = definition[2] if definition[2] != '' else None
            formatString = definition[3] if definition[3] != '' else None
            group_name = definition[4] if definition[4] != '' else None
            datatype = sdds_data_type_to_short_string(definition[5])
            fieldLength = definition[6] if definition[6] != 0 else None
            dimensions = definition[7] if definition[7] != '' else None
            array_instance = Array(name=name, type=datatype, symbol=symbol, units=units, description=description, format_string=formatString, group_name=group_name, field_length=fieldLength, dimensions=dimensions)
            sdds_data.definitions.update({name: array_instance})
            sdds_data.values.update({name: sdds_obj.arrayData[i]})
            sdds_data.array_dims.update({name: sdds_obj.arrayDimensions[i]})
 
    # Store column data
    if sdds_obj.columnName:
        for i, definition in enumerate(sdds_obj.columnDefinition):
            name = sdds_obj.columnName[i]
            symbol = definition[0] if definition[0] != '' else None
            units = definition[1] if definition[1] != '' else None
            description = definition[2] if definition[2] != '' else None
            formatString = definition[3] if definition[3] != '' else None
            datatype = sdds_data_type_to_short_string(definition[4])
            fieldLength = definition[5] if definition[5] != 0 else None
            column_instance = Column(name=name, type=datatype, symbol=symbol, units=units, description=description, format_string=formatString, field_length=fieldLength)
            sdds_data.definitions.update({name: column_instance})
            sdds_data.values.update({name: sdds_obj.columnData[i]})
 
    # Return the dictionary
    return sdds_data
 

save()

sdds.save	(	SDDS	sdds_obj,
			output_file )

Saves the SDDS object's data to an SDDS file.

Args: output (str): The output SDDS filename to save the data.

Raises: Exception: If unable to write the SDDS data.

This method writes the data stored in the SDDS object to the specified file, including the parameters, arrays, columns, and their data.

Definition at line 1397 of file sdds.py.

def save(sdds_obj : SDDS, output_file):
    """
    Saves the SDDS object's data to an SDDS file.
 
    Args:
        output (str): The output SDDS filename to save the data.
 
    Raises:
        Exception: If unable to write the SDDS data.
 
    This method writes the data stored in the SDDS object to the specified file, including the
    parameters, arrays, columns, and their data.
    """
    # Save the file
    try:
        sdds_obj.save(output_file)
    except Exception as e:
        raise ValueError(f"Failed to load the SDDS file: {e}")
 

sdds_data_type_to_short_string()

sdds.sdds_data_type_to_short_string

(

data_type_code

)

Converts a numeric SDDS data type code to its short string representation.

Args: data_type_code (int): Numeric code of the SDDS data type.

Returns: str: String representation of the SDDS data type.

Definition at line 1442 of file sdds.py.

def sdds_data_type_to_short_string(data_type_code):
    """
    Converts a numeric SDDS data type code to its short string representation.
    
    Args:
        data_type_code (int): Numeric code of the SDDS data type.
        
    Returns:
        str: String representation of the SDDS data type.
    """
    # Mapping of SDDS numeric data type codes to string representations
    data_type_map = {
        1: "longdouble",
        2: "double",
        3: "float",
        4: "long64",
        5: "ulong64",
        6: "long",
        7: "ulong",
        8: "short",
        9: "ushort",
        10: "string",
        11: "character",
    }
    return data_type_map.get(data_type_code, "Unknown Data Type")
 

sdds_data_type_to_string()

sdds.sdds_data_type_to_string

(

data_type_code

)

Converts a numeric SDDS data type code to its string representation.

Args: data_type_code (int): Numeric code of the SDDS data type.

Returns: str: String representation of the SDDS data type.

Definition at line 1416 of file sdds.py.

def sdds_data_type_to_string(data_type_code):
    """
    Converts a numeric SDDS data type code to its string representation.
    
    Args:
        data_type_code (int): Numeric code of the SDDS data type.
        
    Returns:
        str: String representation of the SDDS data type.
    """
    # Mapping of SDDS numeric data type codes to string representations
    data_type_map = {
        1: "SDDS_LONGDOUBLE",
        2: "SDDS_DOUBLE",
        3: "SDDS_FLOAT",
        4: "SDDS_LONG64",
        5: "SDDS_ULONG64",
        6: "SDDS_LONG",
        7: "SDDS_ULONG",
        8: "SDDS_SHORT",
        9: "SDDS_USHORT",
        10: "SDDS_STRING",
        11: "SDDS_CHARACTER",
    }
    return data_type_map.get(data_type_code, "Unknown Data Type")
 

sdds_short_string_to_data_type()

sdds.sdds_short_string_to_data_type

(

data_type_code

)

Converts a numeric SDDS data type code to its short string representation.

Args: data_type_code (string): String representation of the SDDS data type.

Returns: int: Numeric code of the SDDS data type.

Definition at line 1468 of file sdds.py.

def sdds_short_string_to_data_type(data_type_code):
    """
    Converts a numeric SDDS data type code to its short string representation.
    
    Args:
        data_type_code (string): String representation of the SDDS data type.
        
    Returns:
        int: Numeric code of the SDDS data type.
    """
    # Mapping of SDDS numeric data type codes to string representations
    data_type_map = {
        "longdouble": 1,
        "double": 2,
        "float": 3,
        "long64": 4,
        "ulong64": 5,
        "long": 6,
        "ulong": 7,
        "short": 8,
        "ushort": 9,
        "string": 10,
        "character": 11,
    }
    return data_type_map.get(data_type_code, "Unknown Data Type")
 

write()

sdds.write	(	SddsFile	sdds_file,
			output_file )

Mostly backward compatible with the PyLHC sdds module write() function.

Unlike the PyLHC version, this function writes all the SDDS pages and works with column data. The data is expected to be in a structured dictionary like that returned from the read() function.

Args: output_file (str): The output SDDS file to be written to.

Definition at line 1967 of file sdds.py.

def write(sdds_file: SddsFile, output_file):
    """
    Mostly backward compatible with the PyLHC sdds module write() function.
    Unlike the PyLHC version, this function writes all the SDDS pages and works with column data.
    The data is expected to be in a structured dictionary like that returned from the read() function.
 
    Args:
        output_file (str): The output SDDS file to be written to.
    """
    # Initialize an SDDS object
    sdds_obj = SDDS()
 
    # Set the data mode (ascii or binary)
    if hasattr(sdds_file, 'binary'):
        if sdds_file.binary:
            sdds_obj.mode = SDDS.SDDS_BINARY
        else:
            sdds_obj.mode = SDDS.SDDS_ASCII
 
    # Set description data
    if hasattr(sdds_file, 'description'):
        text = sdds_file.description.text if sdds_file.description.text != None else ''
        contents = sdds_file.description.contents if sdds_file.description.contents != None else ''
        sdds_obj.setDescription(text, contents)
    
    for name in sdds_file.definitions:
        if isinstance(sdds_file.definitions[name], Parameter):
            # Set parameter data
            parameter_instance = sdds_file.definitions[name]
            symbol = parameter_instance.symbol if parameter_instance.symbol != None else ""
            units = parameter_instance.units if parameter_instance.units != None else ""
            description = parameter_instance.description if parameter_instance.description != None else ""
            formatString = parameter_instance.format_string if parameter_instance.format_string != None else ""
            datatype = sdds_short_string_to_data_type(parameter_instance.type)
            fixedValue = parameter_instance.fixed_value if parameter_instance.fixed_value != None else ""
            sdds_obj.defineParameter(name, symbol=symbol, units=units, description=description,
                                     formatString=formatString, type=datatype, fixedValue=fixedValue)
            sdds_obj.setParameterValueList(name, sdds_file.values[name])
        elif isinstance(sdds_file.definitions[name], Array):
            # Set array data
            array_instance = sdds_file.definitions[name]
            symbol = array_instance.symbol if array_instance.symbol != None else ""
            units = array_instance.units if array_instance.units != None else ""
            description = array_instance.description if array_instance.description != None else ""
            formatString = array_instance.format_string if array_instance.format_string != None else ""
            group_name = array_instance.group_name if array_instance.group_name != None else ""
            datatype = sdds_short_string_to_data_type(array_instance.type)
            fieldLength = array_instance.field_length if array_instance.field_length != None else 0
            dimensions = array_instance.dimensions if array_instance.dimensions != None else 1
            sdds_obj.defineArray(name, symbol=symbol, units=units, description=description,
                                 formatString=formatString, group_name=group_name, type=datatype,
                                 fieldLength=fieldLength, dimensions=dimensions)
            sdds_obj.setArrayValueLists(name, sdds_file.values[name], sdds_file.array_dims[name])
        elif isinstance(sdds_file.definitions[name], Column):
            # Set column data
            column_instance = sdds_file.definitions[name]
            symbol = column_instance.symbol if column_instance.symbol != None else ""
            units = column_instance.units if column_instance.units != None else ""
            description = column_instance.description if column_instance.description != None else ""
            formatString = column_instance.format_string if column_instance.format_string != None else ""
            datatype = sdds_short_string_to_data_type(column_instance.type)
            fieldLength = column_instance.field_length if column_instance.field_length != None else 0
            sdds_obj.defineColumn(name, symbol=symbol, units=units, description=description,
                                  formatString=formatString, type=datatype, fieldLength=fieldLength)
            sdds_obj.setColumnValueLists(name, sdds_file.values[name])
 
    # Set the data to the output file
    sdds_obj.save(output_file)