sdds Namespace Reference

Classes
class	Array
class	Column
class	Description
class	Parameter
class	SDDS
	A class to represent and manipulate SDDS datasets. More...
class	SddsFile

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

Variables
	SDDS_VERBOSE_PrintErrors = SDDS.SDDS_VERBOSE_PrintErrors
	SDDS_EXIT_PrintErrors = SDDS.SDDS_EXIT_PrintErrors
	SDDS_CHECK_OKAY = SDDS.SDDS_CHECK_OKAY
	SDDS_CHECK_NONEXISTENT = SDDS.SDDS_CHECK_NONEXISTENT
	SDDS_CHECK_WRONGTYPE = SDDS.SDDS_CHECK_WRONGTYPE
	SDDS_CHECK_WRONGUNITS = SDDS.SDDS_CHECK_WRONGUNITS
	SDDS_LONGDOUBLE = SDDS.SDDS_LONGDOUBLE
	SDDS_DOUBLE = SDDS.SDDS_DOUBLE
	SDDS_REAL64 = SDDS.SDDS_REAL64
	SDDS_FLOAT = SDDS.SDDS_FLOAT
	SDDS_REAL32 = SDDS.SDDS_REAL32
	SDDS_LONG64 = SDDS.SDDS_LONG64
	SDDS_INT64 = SDDS.SDDS_INT64
	SDDS_ULONG64 = SDDS.SDDS_ULONG64
	SDDS_UINT64 = SDDS.SDDS_UINT64
	SDDS_LONG = SDDS.SDDS_LONG
	SDDS_INT32 = SDDS.SDDS_INT32
	SDDS_ULONG = SDDS.SDDS_ULONG
	SDDS_UINT32 = SDDS.SDDS_UINT32
	SDDS_SHORT = SDDS.SDDS_SHORT
	SDDS_INT16 = SDDS.SDDS_INT16
	SDDS_USHORT = SDDS.SDDS_USHORT
	SDDS_UINT16 = SDDS.SDDS_UINT16
	SDDS_STRING = SDDS.SDDS_STRING
	SDDS_CHARACTER = SDDS.SDDS_CHARACTER
	SDDS_NUM_TYPES = SDDS.SDDS_NUM_TYPES
	SDDS_BINARY = SDDS.SDDS_BINARY
	SDDS_ASCII = SDDS.SDDS_ASCII
	SDDS_FLUSH_TABLE = SDDS.SDDS_FLUSH_TABLE

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 1383 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(0)
    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 1454 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(0)
    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 1510 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(0)
 
    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 1571 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(0)
 
    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 1639 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(0)
 
    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 1674 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(0)
 
    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

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 1759 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(0)
 
    # 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
 

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 1331 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 1305 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 1357 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 1856 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(0)
 
    # 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)

Variable Documentation

SDDS_ASCII

sdds.SDDS_ASCII = SDDS.SDDS_ASCII

Definition at line 1302 of file sdds.py.

SDDS_BINARY

sdds.SDDS_BINARY = SDDS.SDDS_BINARY

Definition at line 1301 of file sdds.py.

SDDS_CHARACTER

sdds.SDDS_CHARACTER = SDDS.SDDS_CHARACTER

Definition at line 1299 of file sdds.py.

SDDS_CHECK_NONEXISTENT

sdds.SDDS_CHECK_NONEXISTENT = SDDS.SDDS_CHECK_NONEXISTENT

Definition at line 1278 of file sdds.py.

SDDS_CHECK_OKAY

sdds.SDDS_CHECK_OKAY = SDDS.SDDS_CHECK_OKAY

Definition at line 1277 of file sdds.py.

SDDS_CHECK_WRONGTYPE

sdds.SDDS_CHECK_WRONGTYPE = SDDS.SDDS_CHECK_WRONGTYPE

Definition at line 1279 of file sdds.py.

SDDS_CHECK_WRONGUNITS

sdds.SDDS_CHECK_WRONGUNITS = SDDS.SDDS_CHECK_WRONGUNITS

Definition at line 1280 of file sdds.py.

SDDS_DOUBLE

sdds.SDDS_DOUBLE = SDDS.SDDS_DOUBLE

Definition at line 1282 of file sdds.py.

SDDS_EXIT_PrintErrors

sdds.SDDS_EXIT_PrintErrors = SDDS.SDDS_EXIT_PrintErrors

Definition at line 1276 of file sdds.py.

SDDS_FLOAT

sdds.SDDS_FLOAT = SDDS.SDDS_FLOAT

Definition at line 1284 of file sdds.py.

SDDS_FLUSH_TABLE

sdds.SDDS_FLUSH_TABLE = SDDS.SDDS_FLUSH_TABLE

Definition at line 1303 of file sdds.py.

SDDS_INT16

sdds.SDDS_INT16 = SDDS.SDDS_INT16

Definition at line 1295 of file sdds.py.

SDDS_INT32

sdds.SDDS_INT32 = SDDS.SDDS_INT32

Definition at line 1291 of file sdds.py.

SDDS_INT64

sdds.SDDS_INT64 = SDDS.SDDS_INT64

Definition at line 1287 of file sdds.py.

SDDS_LONG

sdds.SDDS_LONG = SDDS.SDDS_LONG

Definition at line 1290 of file sdds.py.

SDDS_LONG64

sdds.SDDS_LONG64 = SDDS.SDDS_LONG64

Definition at line 1286 of file sdds.py.

SDDS_LONGDOUBLE

sdds.SDDS_LONGDOUBLE = SDDS.SDDS_LONGDOUBLE

Definition at line 1281 of file sdds.py.

SDDS_NUM_TYPES

sdds.SDDS_NUM_TYPES = SDDS.SDDS_NUM_TYPES

Definition at line 1300 of file sdds.py.

SDDS_REAL32

sdds.SDDS_REAL32 = SDDS.SDDS_REAL32

Definition at line 1285 of file sdds.py.

SDDS_REAL64

sdds.SDDS_REAL64 = SDDS.SDDS_REAL64

Definition at line 1283 of file sdds.py.

SDDS_SHORT

sdds.SDDS_SHORT = SDDS.SDDS_SHORT

Definition at line 1294 of file sdds.py.

SDDS_STRING

sdds.SDDS_STRING = SDDS.SDDS_STRING

Definition at line 1298 of file sdds.py.

SDDS_UINT16

sdds.SDDS_UINT16 = SDDS.SDDS_UINT16

Definition at line 1297 of file sdds.py.

SDDS_UINT32

sdds.SDDS_UINT32 = SDDS.SDDS_UINT32

Definition at line 1293 of file sdds.py.

SDDS_UINT64

sdds.SDDS_UINT64 = SDDS.SDDS_UINT64

Definition at line 1289 of file sdds.py.

SDDS_ULONG

sdds.SDDS_ULONG = SDDS.SDDS_ULONG

Definition at line 1292 of file sdds.py.

SDDS_ULONG64

sdds.SDDS_ULONG64 = SDDS.SDDS_ULONG64

Definition at line 1288 of file sdds.py.

SDDS_USHORT

sdds.SDDS_USHORT = SDDS.SDDS_USHORT

Definition at line 1296 of file sdds.py.

SDDS_VERBOSE_PrintErrors

sdds.SDDS_VERBOSE_PrintErrors = SDDS.SDDS_VERBOSE_PrintErrors

Definition at line 1275 of file sdds.py.