sdds.SDDS Class Reference

A class to represent and manipulate SDDS datasets. More...

Public Member Functions
	__init__ (self, index=None)
	Initializes a new SDDS object.
	__del__ (self)
	Destructor to release the index when the object is deleted.
	load (self, input)
	Loads an SDDS file into the SDDS object.
	loadSparse (self, input, interval, offset)
	Loads an SDDS file into the SDDS object with sparse data reading.
	loadLastRows (self, input, lastrows)
	Loads an SDDS file into the SDDS object, reading only the last few rows.
	save (self, output)
	Saves the SDDS object's data to an SDDS file.
	setDescription (self, text, contents)
	Sets the description for the SDDS object.
	defineParameter (self, name, symbol="", units="", description="", formatString="", type=SDDS_DOUBLE, fixedValue="")
	Defines a parameter for the SDDS object.
	defineSimpleParameter (self, name, type)
	Defines a simple parameter with minimal information.
	defineArray (self, name, symbol="", units="", description="", formatString="", group_name="", type=SDDS_DOUBLE, fieldLength=0, dimensions=1)
	Defines an array for the SDDS object.
	defineSimpleArray (self, name, type, dimensions)
	Defines a simple array with minimal information.
	defineColumn (self, name, symbol="", units="", description="", formatString="", type=SDDS_DOUBLE, fieldLength=0)
	Defines a column for the SDDS object.
	defineSimpleColumn (self, name, type)
	Defines a simple column with minimal information.
	setParameterValueList (self, name, valueList)
	Sets the list of parameter values for a parameter.
	getParameterValueList (self, name)
	Gets the list of parameter values for a parameter.
	setParameterValue (self, name, value, page=1)
	Sets a single parameter value at a specific page.
	getParameterValue (self, name, page=1)
	Gets a single parameter value at a specific page.
	setArrayValueLists (self, name, valueList, dimensionList)
	Sets the nested list of array values and dimensions for a single array.
	getArrayValueLists (self, name)
	Gets the nested list of array values for a single array.
	getArrayDimensionLists (self, name)
	Gets the nested list of array dimensions for a single array.
	setArrayValueList (self, name, valueList, dimensionList, page=1)
	Sets a single array value and dimension at a specific page.
	getArrayValueList (self, name, page=1)
	Gets a single array value at a specific page.
	getArrayDimensionList (self, name, page=1)
	Gets a single array dimension at a specific page.
	setColumnValueLists (self, name, valueList)
	Sets the nested list of column values for a single column.
	getColumnValueLists (self, name)
	Gets the nested list of column values for a single column.
	setColumnValueList (self, name, valueList, page=1)
	Sets a single column value list at a specific page.
	getColumnValueList (self, name, page=1)
	Gets a single column value list at a specific page.
	setColumnValue (self, name, value, page=1, row=1)
	Sets a single column value at a specific page and row.
	getColumnValue (self, name, page=1, row=1)
	Gets a single column value at a specific page and row.
	getParameterCount (self)
	Retrieves the number of parameters.
	getArrayCount (self)
	Retrieves the number of arrays.
	getColumnCount (self)
	Retrieves the number of columns.
	getParameterNames (self)
	Retrieves a list of all parameter names.
	getArrayNames (self)
	Retrieves a list of all array names.
	getColumnNames (self)
	Retrieves a list of all column names.
	getParameterDatatype (self, name)
	Retrieves the data type of a parameter.
	getArrayDatatype (self, name)
	Retrieves the data type of a array.
	getColumnDatatype (self, name)
	Retrieves the data type of a column.
	getParameterUnits (self, name)
	Retrieves the units of a parameter.
	getArrayDatatype (self, name)
	Retrieves the units of a array.
	getColumnDatatype (self, name)
	Retrieves the units of a column.
	pageCount (self)
	Retrieves the number or loaded pages.

Public Attributes
	index = i
list	description = ["", ""]
list	parameterName = []
list	arrayName = []
list	columnName = []
list	parameterDefinition = []
list	arrayDefinition = []
list	arrayDimensions = []
list	columnDefinition = []
list	parameterData = []
list	arrayData = []
list	columnData = []
int	mode = self.SDDS_ASCII
int	loaded_pages = 0
str	parameterName = "Invalid parameter name " + name
str	arrayName = "Invalid array name " + name
str	columnName = "Invalid column name " + name

Static Public Attributes
int	SDDS_VERBOSE_PrintErrors = 1
int	SDDS_EXIT_PrintErrors = 2
int	SDDS_CHECK_OKAY = 0
int	SDDS_CHECK_NONEXISTENT = 1
int	SDDS_CHECK_WRONGTYPE = 2
int	SDDS_CHECK_WRONGUNITS = 3
int	SDDS_LONGDOUBLE = 1
int	SDDS_DOUBLE = 2
int	SDDS_REAL64 = 2
int	SDDS_FLOAT = 3
int	SDDS_REAL32 = 3
int	SDDS_LONG64 = 4
int	SDDS_INT64 = 4
int	SDDS_ULONG64 = 5
int	SDDS_UINT64 = 5
int	SDDS_LONG = 6
int	SDDS_INT32 = 6
int	SDDS_ULONG = 7
int	SDDS_UINT32 = 7
int	SDDS_SHORT = 8
int	SDDS_INT16 = 8
int	SDDS_USHORT = 9
int	SDDS_UINT16 = 9
int	SDDS_STRING = 10
int	SDDS_CHARACTER = 11
int	SDDS_NUM_TYPES = 11
int	SDDS_BINARY = 1
int	SDDS_ASCII = 2
int	SDDS_FLUSH_TABLE = 1

Static Protected Attributes
	_used_indices = set()
int	_max_index = 1000

Detailed Description

A class to represent and manipulate SDDS datasets.

This class provides methods to load, manipulate, and save SDDS data. It supports ASCII and binary formats and facilitates operations on parameters, arrays, and columns.

Attributes: index (int): The index of the SDDS dataset (integer from 0 to 1000). description (list): List containing the description text and contents of the SDDS file. parameterName (list): List of parameter names. arrayName (list): List of array names. columnName (list): List of column names. parameterDefinition (list): List of parameter definitions. arrayDefinition (list): List of array definitions. arrayDimensions (list): List of array dimensions. columnDefinition (list): List of column definitions. parameterData (list): List of parameter data values. arrayData (list): List of array data values. columnData (list): List of column data values. mode (int): The data storage mode (SDDS_ASCII or SDDS_BINARY).

Definition at line 22 of file sdds.py.

Constructor & Destructor Documentation

__init__()

sdds.SDDS.__init__	(		self,
			index = None )

Initializes a new SDDS object.

Args: index (int, optional): Integer index of the SDDS object. If not provided, an available index will be automatically assigned. Must be between 0 and 1000.

Raises: ValueError: If no index is provided and all indices are in use.

Definition at line 85 of file sdds.py.

    def __init__(self, index=None):
        """
        Initializes a new SDDS object.
 
        Args:
            index (int, optional): Integer index of the SDDS object. If not provided, an available
                                   index will be automatically assigned. Must be between 0 and 1000.
 
        Raises:
            ValueError: If no index is provided and all indices are in use.
        """
        if index is None:
            # Automatically assign an unused index
            for i in range(self._max_index + 1):
                if i not in self._used_indices:
                    self.index = i
                    self._used_indices.add(i)
                    break
            else:
                raise ValueError("All SDDS indices are in use. Cannot create a new SDDS object.")
        elif 0 <= index <= self._max_index:
            if index in self._used_indices:
                raise ValueError(f"Index {index} is already in use.")
            self.index = index
            self._used_indices.add(index)
        else:
            raise ValueError(f"Index {index} must be between 0 and {self._max_index}.")
 
        # Initialize data storage variables
        self.description = ["", ""]
        self.parameterName = []
        self.arrayName = []
        self.columnName = []
        self.parameterDefinition = []
        self.arrayDefinition = []
        self.arrayDimensions = []
        self.columnDefinition = []
        self.parameterData = []
        self.arrayData = []
        self.columnData = []
        self.mode = self.SDDS_ASCII
        self.loaded_pages = 0
 

__del__()

sdds.SDDS.__del__

(

self

)

Destructor to release the index when the object is deleted.

Definition at line 128 of file sdds.py.

    def __del__(self):
        """
        Destructor to release the index when the object is deleted.
        """
        if hasattr(self, 'index') and self.index in self._used_indices:
            self._used_indices.remove(self.index)
            

Member Function Documentation

defineArray()

sdds.SDDS.defineArray	(		self,
			name,
			symbol = "",
			units = "",
			description = "",
			formatString = "",
			group_name = "",
			type = SDDS_DOUBLE,
			fieldLength = 0,
			dimensions = 1 )

Defines an array for the SDDS object.

Args: name (str): Array name. symbol (str, optional): Array symbol. units (str, optional): Array units. description (str, optional): Array description. formatString (str, optional): Format string for the array. group_name (str, optional): Group name for the array. type (int, optional): Data type of the array. Defaults to SDDS_DOUBLE, Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character. fieldLength (int, optional): Field length for the array. dimensions (int, optional): Number of dimensions of the array. Defaults to 1

This method adds an array definition to the SDDS object.

Definition at line 581 of file sdds.py.

    def defineArray(self, name, symbol="", units="", description="", formatString="", group_name="", type=SDDS_DOUBLE, fieldLength=0, dimensions=1):
        """
        Defines an array for the SDDS object.
 
        Args:
            name (str): Array name.
            symbol (str, optional): Array symbol.
            units (str, optional): Array units.
            description (str, optional): Array description.
            formatString (str, optional): Format string for the array.
            group_name (str, optional): Group name for the array.
            type (int, optional): Data type of the array. Defaults to SDDS_DOUBLE, Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
            fieldLength (int, optional): Field length for the array.
            dimensions (int, optional): Number of dimensions of the array. Defaults to 1
 
        This method adds an array definition to the SDDS object.
        """
        self.arrayName.append(name)
        self.arrayDefinition.append(
            [symbol, units, description, formatString, group_name, type, fieldLength, dimensions]
        )
        self.arrayData.append([])
        self.arrayDimensions.append([])
 

defineColumn()

sdds.SDDS.defineColumn	(		self,
			name,
			symbol = "",
			units = "",
			description = "",
			formatString = "",
			type = SDDS_DOUBLE,
			fieldLength = 0 )

Defines a column for the SDDS object.

Args: name (str): Column name. symbol (str, optional): Column symbol. units (str, optional): Column units. description (str, optional): Column description. formatString (str, optional): Format string for the column. type (int, optional): Data type of the column. Defaults to SDDS_DOUBLE. Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character. fieldLength (int, optional): Field length for the column.

This method adds a column definition to the SDDS object.

Definition at line 643 of file sdds.py.

    def defineColumn(self, name, symbol="", units="", description="", formatString="", type=SDDS_DOUBLE, fieldLength=0):
        """
        Defines a column for the SDDS object.
 
        Args:
            name (str): Column name.
            symbol (str, optional): Column symbol.
            units (str, optional): Column units.
            description (str, optional): Column description.
            formatString (str, optional): Format string for the column.
            type (int, optional): Data type of the column. Defaults to SDDS_DOUBLE. Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
            fieldLength (int, optional): Field length for the column.
 
        This method adds a column definition to the SDDS object.
        """
        self.columnName.append(name)
        self.columnDefinition.append(
            [symbol, units, description, formatString, type, fieldLength]
        )
        self.columnData.append([])
 

defineParameter()

sdds.SDDS.defineParameter	(		self,
			name,
			symbol = "",
			units = "",
			description = "",
			formatString = "",
			type = SDDS_DOUBLE,
			fixedValue = "" )

Defines a parameter for the SDDS object.

Args: name (str): Parameter name. symbol (str, optional): Parameter symbol. units (str, optional): Parameter units. description (str, optional): Parameter description. formatString (str, optional): Format string for the parameter. type (int, optional): Data type of the parameter. Defaults to SDDS_DOUBLE. Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character. fixedValue (str, optional): Fixed value of the parameter.

This method adds a parameter definition to the SDDS object.

Definition at line 524 of file sdds.py.

    def defineParameter(self, name, symbol="", units="", description="", formatString="", type=SDDS_DOUBLE, fixedValue=""):
        """
        Defines a parameter for the SDDS object.
 
        Args:
            name (str): Parameter name.
            symbol (str, optional): Parameter symbol.
            units (str, optional): Parameter units.
            description (str, optional): Parameter description.
            formatString (str, optional): Format string for the parameter.
            type (int, optional): Data type of the parameter. Defaults to SDDS_DOUBLE. Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
            fixedValue (str, optional): Fixed value of the parameter.
 
        This method adds a parameter definition to the SDDS object.
        """
        self.parameterName.append(name)
        self.parameterDefinition.append(
            [symbol, units, description, formatString, type, fixedValue]
        )
        self.parameterData.append([])
 

defineSimpleArray()

sdds.SDDS.defineSimpleArray	(		self,
			name,
			type,
			dimensions )

Defines a simple array with minimal information.

Args: name (str): Array name. type (int): Data type of the array. Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character. dimensions (int): Number of dimensions of the array.

This method adds an array definition with default attributes.

Definition at line 616 of file sdds.py.

    def defineSimpleArray(self, name, type, dimensions):
        """
        Defines a simple array with minimal information.
 
        Args:
            name (str): Array name.
            type (int): Data type of the array. Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
            dimensions (int): Number of dimensions of the array.
 
        This method adds an array definition with default attributes.
        """
        self.arrayName.append(name)
        self.arrayDefinition.append(["", "", "", "", "", type, 0, dimensions])
        self.arrayData.append([])
        self.arrayDimensions.append([])
 

defineSimpleColumn()

sdds.SDDS.defineSimpleColumn	(		self,
			name,
			type )

Defines a simple column with minimal information.

Args: name (str): Column name. type (int): Data type of the column. Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character.

This method adds a column definition with default attributes.

Definition at line 675 of file sdds.py.

    def defineSimpleColumn(self, name, type):
        """
        Defines a simple column with minimal information.
 
        Args:
            name (str): Column name.
            type (int): Data type of the column. Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
 
        This method adds a column definition with default attributes.
        """
        self.columnName.append(name)
        self.columnDefinition.append(["", "", "", "", type, 0])
        self.columnData.append([])
 

defineSimpleParameter()

sdds.SDDS.defineSimpleParameter	(		self,
			name,
			type )

Defines a simple parameter with minimal information.

Args: name (str): Parameter name. type (int): Data type of the parameter. Valid options include:

• SDDS_SHORT: 16-bit signed integer.
• SDDS_USHORT: 16-bit unsigned integer.
• SDDS_LONG: 32-bit signed integer.
• SDDS_ULONG: 32-bit unsigned integer.
• SDDS_LONG64: 64-bit signed integer.
• SDDS_ULONG64: 64-bit unsigned integer.
• SDDS_FLOAT: Single-precision floating-point number.
• SDDS_DOUBLE: Double-precision floating-point number.
• SDDS_LONGDOUBLE: Long double-precision floating-point number.
• SDDS_STRING: String (textual data).
• SDDS_CHARACTER: Single character.

This method adds a parameter definition with default attributes.

Definition at line 556 of file sdds.py.

    def defineSimpleParameter(self, name, type):
        """
        Defines a simple parameter with minimal information.
 
        Args:
            name (str): Parameter name.
            type (int): Data type of the parameter. Valid options include:
                - SDDS_SHORT: 16-bit signed integer.
                - SDDS_USHORT: 16-bit unsigned integer.
                - SDDS_LONG: 32-bit signed integer.
                - SDDS_ULONG: 32-bit unsigned integer.
                - SDDS_LONG64: 64-bit signed integer.
                - SDDS_ULONG64: 64-bit unsigned integer.
                - SDDS_FLOAT: Single-precision floating-point number.
                - SDDS_DOUBLE: Double-precision floating-point number.
                - SDDS_LONGDOUBLE: Long double-precision floating-point number.
                - SDDS_STRING: String (textual data).
                - SDDS_CHARACTER: Single character.
 
        This method adds a parameter definition with default attributes.
        """
        self.parameterName.append(name)
        self.parameterDefinition.append(["", "", "", "", type, ""])
        self.parameterData.append([])
 

getArrayCount()

sdds.SDDS.getArrayCount

(

self

)

Retrieves the number of arrays.

Returns: int: The number of arrays.

Definition at line 1140 of file sdds.py.

    def getArrayCount(self):
        """
        Retrieves the number of arrays.
 
        Returns:
            int: The number of arrays.
        """
        return(len(self.arrayName))
 

getArrayDatatype() [1/2]

sdds.SDDS.getArrayDatatype	(		self,
			name )

Retrieves the data type of a array.

Args: name (str): Array name.

Returns: int: Number representing the data type of the array.

Definition at line 1201 of file sdds.py.

    def getArrayDatatype(self, name):
        """
        Retrieves the data type of a array.
 
        Args:
            name (str): Array name.
        
        Returns:
            int: Number representing the data type of the array.
        """
        if name in self.arrayName:
            return(self.arrayDefinition[self.arrayName.index(name)][5])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
    

getArrayDatatype() [2/2]

sdds.SDDS.getArrayDatatype	(		self,
			name )

Retrieves the units of a array.

Args: name (str): Array name.

Returns: str: Units of the array.

Definition at line 1249 of file sdds.py.

    def getArrayDatatype(self, name):
        """
        Retrieves the units of a array.
    
        Args:
            name (str): Array name.
        
        Returns:
            str: Units of the array.
        """
        if name in self.arrayName:
            return(self.arrayDefinition[self.arrayName.index(name)][1])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
    

getArrayDimensionList()

sdds.SDDS.getArrayDimensionList	(		self,
			name,
			page = 1 )

Gets a single array dimension at a specific page.

Args: name (str): Array name. page (int, optional): Page number (1-based index, defaults to 1).

Returns: list: Array dimension.

Raises: Exception: If the array name or page is invalid.

Definition at line 923 of file sdds.py.

    def getArrayDimensionList(self, name, page=1):
        """
        Gets a single array dimension at a specific page.
 
        Args:
            name (str): Array name.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Returns:
            list: Array dimension.
            
        Raises:
            Exception: If the array name or page is invalid.
        """
        page = page - 1
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            i = self.arrayName.index(name)
            if len(self.arrayData[i]) == page:
                return(self.arrayDimensions[i][page:])
            elif len(self.arrayData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                return(self.arrayDimensions[i][page])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

getArrayDimensionLists()

sdds.SDDS.getArrayDimensionLists	(		self,
			name )

Gets the nested list of array dimensions for a single array.

This can be used to get dimensions for multiple pages at once.

Args: name (str): Array name.

Returns: list: Nested list of array dimensions.

Raises: Exception: If the array name is invalid.

Definition at line 842 of file sdds.py.

    def getArrayDimensionLists(self, name):
        """
        Gets the nested list of array dimensions for a single array. This can be used to get dimensions for multiple pages at once.
 
        Args:
            name (str): Array name.
 
        Returns:
            list: Nested list of array dimensions.
            
        Raises:
            Exception: If the array name is invalid.
        """
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            return(self.arrayDimensions[self.arrayName.index(name)])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

getArrayNames()

sdds.SDDS.getArrayNames

(

self

)

Retrieves a list of all array names.

Returns: list: A list of array names as strings, or an empty list.

Definition at line 1167 of file sdds.py.

    def getArrayNames(self):
        """
        Retrieves a list of all array names.
 
        Returns:
            list: A list of array names as strings, or an empty list.
        """
        return(self.arrayName)
 

getArrayValueList()

sdds.SDDS.getArrayValueList	(		self,
			name,
			page = 1 )

Gets a single array value at a specific page.

Args: name (str): Array name. page (int, optional): Page number (1-based index, defaults to 1).

Returns: list: Array values.

Raises: Exception: If the array name or page is invalid.

Definition at line 894 of file sdds.py.

    def getArrayValueList(self, name, page=1):
        """
        Gets a single array value at a specific page.
 
        Args:
            name (str): Array name.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Returns:
            list: Array values.
            
        Raises:
            Exception: If the array name or page is invalid.
        """
        page = page - 1
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            i = self.arrayName.index(name)
            if len(self.arrayData[i]) == page:
                return(self.arrayData[i][page:])
            elif len(self.arrayData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                return(self.arrayData[i][page])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

getArrayValueLists()

sdds.SDDS.getArrayValueLists	(		self,
			name )

Gets the nested list of array values for a single array.

This can be used to get values for multiple pages at once.

Args: name (str): Array name.

Returns: list: Nested list of array values.

Raises: Exception: If the array name is invalid.

Definition at line 822 of file sdds.py.

    def getArrayValueLists(self, name):
        """
        Gets the nested list of array values for a single array. This can be used to get values for multiple pages at once.
 
        Args:
            name (str): Array name.
 
        Returns:
            list: Nested list of array values.
            
        Raises:
            Exception: If the array name is invalid.
        """
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            return(self.arrayData[self.arrayName.index(name)])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

getColumnCount()

sdds.SDDS.getColumnCount

(

self

)

Retrieves the number of columns.

Returns: int: The number of columns.

Definition at line 1149 of file sdds.py.

    def getColumnCount(self):
        """
        Retrieves the number of columns.
 
        Returns:
            int: The number of columns.
        """
        return(len(self.columnName))
 

getColumnDatatype() [1/2]

sdds.SDDS.getColumnDatatype	(		self,
			name )

Retrieves the data type of a column.

Args: name (str): Column name.

Returns: int: Number representing the data type of the column.

Definition at line 1217 of file sdds.py.

    def getColumnDatatype(self, name):
        """
        Retrieves the data type of a column.
 
        Args:
            name (str): Column name.
        
        Returns:
            int: Number representing the data type of the column.
        """
        if name in self.columnName:
            return(self.columnDefinition[self.columnName.index(name)][4])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

getColumnDatatype() [2/2]

sdds.SDDS.getColumnDatatype	(		self,
			name )

Retrieves the units of a column.

Args: name (str): Column name.

Returns: str: Units of the column.

Definition at line 1265 of file sdds.py.

    def getColumnDatatype(self, name):
        """
        Retrieves the units of a column.
 
        Args:
            name (str): Column name.
        
        Returns:
            str: Units of the column.
        """
        if name in self.columnName:
            return(self.columnDefinition[self.columnName.index(name)][1])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

getColumnNames()

sdds.SDDS.getColumnNames

(

self

)

Retrieves a list of all column names.

Returns: list: A list of column names as strings, or an empty list.

Definition at line 1176 of file sdds.py.

    def getColumnNames(self):
        """
        Retrieves a list of all column names.
 
        Returns:
            list: A list of column names as strings, or an empty list.
        """
        return(self.columnName)
 

getColumnValue()

sdds.SDDS.getColumnValue	(		self,
			name,
			page = 1,
			row = 1 )

Gets a single column value at a specific page and row.

Args: name (str): Column name. page (int, optional): Page number (1-based index, defaults to 1). row (int, optional): Row number (1-based index, defaults to 1).

Returns: value: Column value.

Raises: Exception: If the column name, page, or row is invalid.

Definition at line 1090 of file sdds.py.

    def getColumnValue(self, name, page=1, row=1):
        """
        Gets a single column value at a specific page and row.
 
        Args:
            name (str): Column name.
            page (int, optional): Page number (1-based index, defaults to 1).
            row (int, optional): Row number (1-based index, defaults to 1).
 
        Returns:
            value: Column value.
            
        Raises:
            Exception: If the column name, page, or row is invalid.
        """
        page = page - 1
        row = row - 1
        numberOfColumns = len(self.columnName)
        if name in self.columnName:
            i = self.columnName.index(name)
            if len(self.columnData[i]) == page:
                if row == 0:
                    return(self.columnData[i][page:])
                else:
                    msg = "Invalid row " + str(row + 1)
                    raise Exception(msg)
            elif len(self.columnData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                if len(self.columnData[i][page]) == row:
                    return(self.columnData[i][page][row:])
                elif len(self.columnData[i][page]) < row or row < 0:
                    msg = "Invalid row " + str(row + 1)
                    raise Exception(msg)
                else:
                    return(self.columnData[i][page][row])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

getColumnValueList()

sdds.SDDS.getColumnValueList	(		self,
			name,
			page = 1 )

Gets a single column value list at a specific page.

Args: name (str): Column name. page (int, optional): Page number (1-based index, defaults to 1).

Returns: list: Column values.

Raises: Exception: If the column name or page is invalid.

Definition at line 1020 of file sdds.py.

    def getColumnValueList(self, name, page=1):
        """
        Gets a single column value list at a specific page.
 
        Args:
            name (str): Column name.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Returns:
            list: Column values.
            
        Raises:
            Exception: If the column name or page is invalid.
        """
        page = page - 1
        numberOfColumns = len(self.columnName)
        if name in self.columnName:
            i = self.columnName.index(name)
            if len(self.columnData[i]) == page:
                return(self.columnData[i][page:])
            elif len(self.columnData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                return(self.columnData[i][page])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

getColumnValueLists()

sdds.SDDS.getColumnValueLists	(		self,
			name )

Gets the nested list of column values for a single column.

This can be used to get values for multiple pages at once.

Args: name (str): Column name.

Returns: list: Nested list of column values.

Raises: Exception: If the column name is invalid.

Definition at line 972 of file sdds.py.

    def getColumnValueLists(self, name):
        """
        Gets the nested list of column values for a single column. This can be used to get values for multiple pages at once.
 
        Args:
            name (str): Column name.
 
        Returns:
            list: Nested list of column values.
 
        Raises:
            Exception: If the column name is invalid.
        """
        numberOfColumns = len(self.columnName)
        if name in self.columnName:
            return(self.columnData[self.columnName.index(name)])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

getParameterCount()

sdds.SDDS.getParameterCount

(

self

)

Retrieves the number of parameters.

Returns: int: The number of parameters.

Definition at line 1131 of file sdds.py.

    def getParameterCount(self):
        """
        Retrieves the number of parameters.
 
        Returns:
            int: The number of parameters.
        """
        return(len(self.parameterName))
 

getParameterDatatype()

sdds.SDDS.getParameterDatatype	(		self,
			name )

Retrieves the data type of a parameter.

Args: name (str): Parameter name.

Returns: int: Number representing the data type of the parameter.

Definition at line 1185 of file sdds.py.

    def getParameterDatatype(self, name):
        """
        Retrieves the data type of a parameter.
 
        Args:
            name (str): Parameter name.
        
        Returns:
            int: Number representing the data type of the parameter.
        """
        if name in self.parameterName:
            return(self.parameterDefinition[self.parameterName.index(name)][4])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

getParameterNames()

sdds.SDDS.getParameterNames

(

self

)

Retrieves a list of all parameter names.

Returns: list: A list of parameter names as strings, or an empty list.

Definition at line 1158 of file sdds.py.

    def getParameterNames(self):
        """
        Retrieves a list of all parameter names.
 
        Returns:
            list: A list of parameter names as strings, or an empty list.
        """
        return(self.parameterName)
 

getParameterUnits()

sdds.SDDS.getParameterUnits	(		self,
			name )

Retrieves the units of a parameter.

Args: name (str): Parameter name.

Returns: str: Units of the parameter.

Definition at line 1233 of file sdds.py.

    def getParameterUnits(self, name):
        """
        Retrieves the units of a parameter.
 
        Args:
            name (str): Parameter name.
        
        Returns:
            str: Units of the parameter.
        """
        if name in self.parameterName:
            return(self.parameterDefinition[self.parameterName.index(name)][1])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

getParameterValue()

sdds.SDDS.getParameterValue	(		self,
			name,
			page = 1 )

Gets a single parameter value at a specific page.

Args: name (str): Parameter name. page (int, optional): Page number (1-based index, defaults to 1).

Returns: value: Parameter value.

Raises: Exception: If the parameter name or page is invalid.

Definition at line 770 of file sdds.py.

    def getParameterValue(self, name, page=1):
        """
        Gets a single parameter value at a specific page.
 
        Args:
            name (str): Parameter name.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Returns:
            value: Parameter value.
            
        Raises:
            Exception: If the parameter name or page is invalid.
        """
        page = page - 1
        numberOfParameters = len(self.parameterName)
        if name in self.parameterName:
            i = self.parameterName.index(name)
            if len(self.parameterData[i]) == page:
                return(self.parameterData[i][page:])
            elif len(self.parameterData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                return(self.parameterData[i][page])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

getParameterValueList()

sdds.SDDS.getParameterValueList	(		self,
			name )

Gets the list of parameter values for a parameter.

This can be used to get values for multiple pages at once.

Args: name (str): Parameter name.

Returns: list: List of values for the parameter.

Raises: Exception: If the parameter name is invalid.

Definition at line 720 of file sdds.py.

    def getParameterValueList(self, name):
        """
        Gets the list of parameter values for a parameter. This can be used to get values for multiple pages at once.
 
        Args:
            name (str): Parameter name.
 
        Returns:
            list: List of values for the parameter.
            
        Raises:
            Exception: If the parameter name is invalid.
 
        """
        numberOfParameters = len(self.parameterName)
        if name in self.parameterName:
            return(self.parameterData[self.parameterName.index(name)])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

load()

sdds.SDDS.load	(		self,
			input )

Loads an SDDS file into the SDDS object.

Args: input (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 135 of file sdds.py.

    def load(self, input):
        """
        Loads an SDDS file into the SDDS object.
 
        Args:
            input (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.
        """
        try:
            # Open SDDS file
            if sddsdata.InitializeInput(self.index, input) != 1:
                time.sleep(1)
                if sddsdata.InitializeInput(self.index, input) != 1:
                    raise ValueError("Failed to initialize SDDS input.")
 
            # Get data storage mode (SDDS_ASCII or SDDS_BINARY)
            self.mode = sddsdata.GetMode(self.index)
 
            # Get description text and contents
            self.description = sddsdata.GetDescription(self.index)
 
            # Get parameter names
            self.parameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterName)
 
            # Get array names
            self.arrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayName)
 
            # Get column names
            self.columnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnName]
 
            # Initialize parameter, array, and column data
            self.parameterData = [[] for _ in range(numberOfParameters)]
            self.arrayData = [[] for _ in range(numberOfArrays)]
            self.columnData = [[] for _ in range(numberOfColumns)]
            self.arrayDimensions = [[] for _ in range(numberOfArrays)]
 
            # Read in SDDS data
            page = sddsdata.ReadPage(self.index)
            if page != 1:
                raise Exception("Unable to read SDDS data for the first page")
            while page > 0:
                self.loaded_pages += 1
                for i in range(numberOfParameters):
                    self.parameterData[i].append(sddsdata.GetParameter(self.index, i))
                for i in range(numberOfArrays):
                    self.arrayData[i].append(sddsdata.GetArray(self.index, i))
                    self.arrayDimensions[i].append(sddsdata.GetArrayDimensions(self.index, i))
                rows = sddsdata.RowCount(self.index)
                if rows > 0:
                    for i in range(numberOfColumns):
                        self.columnData[i].append(sddsdata.GetColumn(self.index, i))
                else:
                    for i in range(numberOfColumns):
                        self.columnData[i].append([])
                page = sddsdata.ReadPage(self.index)
 
            # Close SDDS file
            if sddsdata.Terminate(self.index) != 1:
                raise ValueError("Failed to terminate SDDS input.")
 
        except:
            sddsdata.PrintErrors(self.SDDS_VERBOSE_PrintErrors)
            raise
 

loadLastRows()

sdds.SDDS.loadLastRows	(		self,
			input,
			lastrows )

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

Args: input (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 297 of file sdds.py.

    def loadLastRows(self, input, lastrows):
        """
        Loads an SDDS file into the SDDS object, reading only the last few rows.
 
        Args:
            input (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.
        """
        try:
            # Open SDDS file
            if sddsdata.InitializeInput(self.index, input) != 1:
                time.sleep(1)
                if sddsdata.InitializeInput(self.index, input) != 1:
                    raise ValueError("Failed to initialize SDDS input.")
 
            # Get data storage mode (SDDS_ASCII or SDDS_BINARY)
            self.mode = sddsdata.GetMode(self.index)
 
            # Get description text and contents
            self.description = sddsdata.GetDescription(self.index)
 
            # Get parameter names
            self.parameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterName)
 
            # Get array names
            self.arrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayName)
 
            # Get column names
            self.columnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnName]
 
            # Initialize parameter, array, and column data
            self.parameterData = [[] for _ in range(numberOfParameters)]
            self.arrayData = [[] for _ in range(numberOfArrays)]
            self.columnData = [[] for _ in range(numberOfColumns)]
            self.arrayDimensions = [[] for _ in range(numberOfArrays)]
 
            # Read in SDDS data (last rows)
            page = sddsdata.ReadPageLastRows(self.index, lastrows)
            if page != 1:
                raise Exception("Unable to read SDDS data for the first page")
            while page > 0:
                for i in range(numberOfParameters):
                    self.parameterData[i].append(sddsdata.GetParameter(self.index, i))
                for i in range(numberOfArrays):
                    self.arrayData[i].append(sddsdata.GetArray(self.index, i))
                    self.arrayDimensions[i].append(sddsdata.GetArrayDimensions(self.index, i))
                rows = sddsdata.RowCount(self.index)
                if rows > 0:
                    for i in range(numberOfColumns):
                        self.columnData[i].append(sddsdata.GetColumn(self.index, i))
                else:
                    for i in range(numberOfColumns):
                        self.columnData[i].append([])
                page = sddsdata.ReadPageLastRows(self.index, lastrows)
 
            # Close SDDS file
            if sddsdata.Terminate(self.index) != 1:
                raise ValueError("Failed to terminate SDDS input.")
 
        except:
            sddsdata.PrintErrors(self.SDDS_VERBOSE_PrintErrors)
            raise
 

loadSparse()

sdds.SDDS.loadSparse	(		self,
			input,
			interval,
			offset )

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

Args: input (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 216 of file sdds.py.

    def loadSparse(self, input, interval, offset):
        """
        Loads an SDDS file into the SDDS object with sparse data reading.
 
        Args:
            input (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`.
        """
        try:
            # Open SDDS file
            if sddsdata.InitializeInput(self.index, input) != 1:
                time.sleep(1)
                if sddsdata.InitializeInput(self.index, input) != 1:
                    raise ValueError("Failed to initialize SDDS input.")
 
            # Get data storage mode (SDDS_ASCII or SDDS_BINARY)
            self.mode = sddsdata.GetMode(self.index)
 
            # Get description text and contents
            self.description = sddsdata.GetDescription(self.index)
 
            # Get parameter names
            self.parameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterName)
 
            # Get array names
            self.arrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayName)
 
            # Get column names
            self.columnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnName]
 
            # Initialize parameter, array, and column data
            self.parameterData = [[] for _ in range(numberOfParameters)]
            self.arrayData = [[] for _ in range(numberOfArrays)]
            self.columnData = [[] for _ in range(numberOfColumns)]
            self.arrayDimensions = [[] for _ in range(numberOfArrays)]
 
            # Read in SDDS data sparsely
            page = sddsdata.ReadPageSparse(self.index, interval, offset)
            if page != 1:
                raise Exception("Unable to read SDDS data for the first page")
            while page > 0:
                for i in range(numberOfParameters):
                    self.parameterData[i].append(sddsdata.GetParameter(self.index, i))
                for i in range(numberOfArrays):
                    self.arrayData[i].append(sddsdata.GetArray(self.index, i))
                    self.arrayDimensions[i].append(sddsdata.GetArrayDimensions(self.index, i))
                rows = sddsdata.RowCount(self.index)
                if rows > 0:
                    for i in range(numberOfColumns):
                        self.columnData[i].append(sddsdata.GetColumn(self.index, i))
                else:
                    for i in range(numberOfColumns):
                        self.columnData[i].append([])
                page = sddsdata.ReadPageSparse(self.index, interval, offset)
 
            # Close SDDS file
            if sddsdata.Terminate(self.index) != 1:
                raise ValueError("Failed to terminate SDDS input.")
 
        except:
            sddsdata.PrintErrors(self.SDDS_VERBOSE_PrintErrors)
            raise
 

pageCount()

sdds.SDDS.pageCount

(

self

)

Retrieves the number or loaded pages.

Returns: int: Number or loaded pages

Definition at line 1281 of file sdds.py.

    def pageCount(self):
        """
        Retrieves the number or loaded pages
 
        Returns:
            int: Number or loaded pages
        """
        return(self.loaded_pages)
 
 
 
# Expose constants to the module-level namespace

save()

sdds.SDDS.save	(		self,
			output )

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 377 of file sdds.py.

    def save(self, output):
        """
        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.
        """
        try:
            # Check for invalid SDDS data
            numberOfParameters = len(self.parameterName)
            numberOfArrays = len(self.arrayName)
            numberOfColumns = len(self.columnName)
            pages = 0
 
            if numberOfParameters != len(self.parameterData):
                raise Exception("Unmatched parameterName and parameterData")
            if numberOfArrays != len(self.arrayData):
                raise Exception("Unmatched arrayName and arrayData")
            if numberOfColumns != len(self.columnData):
                raise Exception("Unmatched columnName and columnData")
            if numberOfParameters != len(self.parameterDefinition):
                raise Exception("Unmatched parameterName and parameterDefinition")
            if numberOfArrays != len(self.arrayDefinition):
                raise Exception("Unmatched arrayName and arrayDefinition")
            if numberOfColumns != len(self.columnDefinition):
                raise Exception("Unmatched columnName and columnDefinition")
 
            if numberOfParameters > 0:
                pages = len(self.parameterData[0])
            elif numberOfColumns > 0:
                pages = len(self.columnData[0])
            elif numberOfArrays > 0:
                pages = len(self.arrayData[0])
 
            for i in range(numberOfParameters):
                if pages != len(self.parameterData[i]):
                    raise Exception("Unequal number of pages in parameter data")
            for i in range(numberOfArrays):
                if pages != len(self.arrayData[i]):
                    raise Exception("Unequal number of pages in array data")
                if pages != len(self.arrayDimensions[i]):
                    raise Exception("Unequal number of pages in array dimension data")
            for i in range(numberOfColumns):
                if pages != len(self.columnData[i]):
                    raise Exception("Unequal number of pages in column data")
            for page in range(pages):
                rows = 0
                if numberOfColumns > 0:
                    rows = len(self.columnData[0][page])
                for i in range(numberOfColumns):
                    if rows != len(self.columnData[i][page]):
                        raise Exception("Unequal number of rows in column data")
 
            # Open SDDS output file
            if sddsdata.InitializeOutput(self.index, self.mode, 1, self.description[0], self.description[1], output) != 1:
                raise ValueError("Failed to initialize SDDS output.")
 
            # Define parameters, arrays, and columns
            for i in range(numberOfParameters):
                if sddsdata.DefineParameter(
                    self.index,
                    self.parameterName[i],
                    self.parameterDefinition[i][0],
                    self.parameterDefinition[i][1],
                    self.parameterDefinition[i][2],
                    self.parameterDefinition[i][3],
                    self.parameterDefinition[i][4],
                    self.parameterDefinition[i][5],
                ) == -1:
                    raise ValueError("Failed to define parameter.")
 
            for i in range(numberOfArrays):
                if sddsdata.DefineArray(
                    self.index,
                    self.arrayName[i],
                    self.arrayDefinition[i][0],
                    self.arrayDefinition[i][1],
                    self.arrayDefinition[i][2],
                    self.arrayDefinition[i][3],
                    self.arrayDefinition[i][4],
                    self.arrayDefinition[i][5],
                    self.arrayDefinition[i][6],
                    self.arrayDefinition[i][7],
                ) == -1:
                    raise ValueError("Failed to define array.")
 
            for i in range(numberOfColumns):
                if sddsdata.DefineColumn(
                    self.index,
                    self.columnName[i],
                    self.columnDefinition[i][0],
                    self.columnDefinition[i][1],
                    self.columnDefinition[i][2],
                    self.columnDefinition[i][3],
                    self.columnDefinition[i][4],
                    self.columnDefinition[i][5],
                ) == -1:
                    raise ValueError("Failed to define column.")
 
            # Write SDDS header
            if sddsdata.WriteLayout(self.index) != 1:
                raise ValueError("Failed to write SDDS layout.")
 
            # Write SDDS data
            for page in range(pages):
                rows = 0
                if numberOfColumns > 0:
                    rows = len(self.columnData[0][page])
                if sddsdata.StartPage(self.index, rows) != 1:
                    raise ValueError("Failed to start SDDS page.")
                for i in range(numberOfParameters):
                    if sddsdata.SetParameter(self.index, i, self.parameterData[i][page]) != 1:
                        raise ValueError("Failed to set parameter value.")
                for i in range(numberOfArrays):
                    if sddsdata.SetArray(
                        self.index, i, self.arrayData[i][page], self.arrayDimensions[i][page]
                    ) != 1:
                        raise ValueError("Failed to set array value.")
                for i in range(numberOfColumns):
                    if sddsdata.SetColumn(self.index, i, self.columnData[i][page]) != 1:
                        raise ValueError("Failed to set column value.")
                if sddsdata.WritePage(self.index) != 1:
                    raise ValueError("Failed to write SDDS page.")
 
            # Close SDDS output file
            if sddsdata.Terminate(self.index) != 1:
                raise ValueError("Failed to terminate SDDS output.")
        except:
            sddsdata.PrintErrors(self.SDDS_VERBOSE_PrintErrors)
            raise
 

setArrayValueList()

sdds.SDDS.setArrayValueList	(		self,
			name,
			valueList,
			dimensionList,
			page = 1 )

Sets a single array value and dimension at a specific page.

Args: name (str): Array name. valueList (list): Array values. dimensionList (list): Array dimensions. page (int, optional): Page number (1-based index, defaults to 1).

Raises: Exception: If the array name or page is invalid.

This method sets the array values and dimensions at the specified page.

Definition at line 862 of file sdds.py.

    def setArrayValueList(self, name, valueList, dimensionList, page=1):
        """
        Sets a single array value and dimension at a specific page.
 
        Args:
            name (str): Array name.
            valueList (list): Array values.
            dimensionList (list): Array dimensions.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Raises:
            Exception: If the array name or page is invalid.
 
        This method sets the array values and dimensions at the specified page.
        """
        page = page - 1
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            i = self.arrayName.index(name)
            if len(self.arrayData[i]) == page:
                self.arrayData[i][page:] = [valueList]
                self.arrayDimensions[i][page:] = [dimensionList]
            elif len(self.arrayData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                self.arrayData[i][page] = valueList
                self.arrayDimensions[i][page] = dimensionList
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

setArrayValueLists()

sdds.SDDS.setArrayValueLists	(		self,
			name,
			valueList,
			dimensionList )

Sets the nested list of array values and dimensions for a single array.

This can be used to set values for multiple pages at once.

Args: name (str): Array name. valueList (list): Nested list of array values. dimensionList (list): Nested list of array dimensions.

Raises: Exception: If the array name is invalid.

This method assigns values and dimensions to an array across pages.

Definition at line 799 of file sdds.py.

    def setArrayValueLists(self, name, valueList, dimensionList):
        """
        Sets the nested list of array values and dimensions for a single array. This can be used to set values for multiple pages at once.
 
        Args:
            name (str): Array name.
            valueList (list): Nested list of array values.
            dimensionList (list): Nested list of array dimensions.
 
        Raises:
            Exception: If the array name is invalid.
 
        This method assigns values and dimensions to an array across pages.
        """
        numberOfArrays = len(self.arrayName)
        if name in self.arrayName:
            i = self.arrayName.index(name)
            self.arrayDimensions[i] = dimensionList
            self.arrayData[i] = valueList
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 

setColumnValue()

sdds.SDDS.setColumnValue	(		self,
			name,
			value,
			page = 1,
			row = 1 )

Sets a single column value at a specific page and row.

Args: name (str): Column name. value: Column value. page (int, optional): Page number (1-based index, defaults to 1). row (int, optional): Row number (1-based index, defaults to 1).

Raises: Exception: If the column name, page, or row is invalid.

This method sets the column value at the specified page and row.

Definition at line 1049 of file sdds.py.

    def setColumnValue(self, name, value, page=1, row=1):
        """
        Sets a single column value at a specific page and row.
 
        Args:
            name (str): Column name.
            value: Column value.
            page (int, optional): Page number (1-based index, defaults to 1).
            row (int, optional): Row number (1-based index, defaults to 1).
 
        Raises:
            Exception: If the column name, page, or row is invalid.
 
        This method sets the column value at the specified page and row.
        """
        page = page - 1
        row = row - 1
        numberOfColumns = len(self.columnName)
        if name in self.columnName:
            i = self.columnName.index(name)
            if len(self.columnData[i]) == page:
                if row == 0:
                    self.columnData[i][page:] = [[value]]
                else:
                    msg = "Invalid row " + str(row + 1)
                    raise Exception(msg)
            elif len(self.columnData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                if len(self.columnData[i][page]) == row:
                    self.columnData[i][page][row:] = [value]
                elif len(self.columnData[i][page]) < row or row < 0:
                    msg = "Invalid row " + str(row + 1)
                    raise Exception(msg)
                else:
                    self.columnData[i][page][row] = value
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

setColumnValueList()

sdds.SDDS.setColumnValueList	(		self,
			name,
			valueList,
			page = 1 )

Sets a single column value list at a specific page.

Args: name (str): Column name. valueList (list): Column values. page (int, optional): Page number (1-based index, defaults to 1).

Raises: Exception: If the column name or page is invalid.

This method sets the column values at the specified page.

Definition at line 992 of file sdds.py.

    def setColumnValueList(self, name, valueList, page=1):
        """
        Sets a single column value list at a specific page.
 
        Args:
            name (str): Column name.
            valueList (list): Column values.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Raises:
            Exception: If the column name or page is invalid.
 
        This method sets the column values at the specified page.
        """
        page = page - 1
        if name in self.columnName:
            i = self.columnName.index(name)
            if len(self.columnData[i]) == page:
                self.columnData[i][page:] = [valueList]
            elif len(self.columnData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                self.columnData[i][page] = valueList
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

setColumnValueLists()

sdds.SDDS.setColumnValueLists	(		self,
			name,
			valueList )

Sets the nested list of column values for a single column.

This can be used to set values for multiple pages at once.

Args: name (str): Column name. valueList (list): Nested list of column values.

Raises: Exception: If the column name is invalid.

This method assigns a list of values to a column across pages.

Definition at line 952 of file sdds.py.

    def setColumnValueLists(self, name, valueList):
        """
        Sets the nested list of column values for a single column. This can be used to set values for multiple pages at once.
 
        Args:
            name (str): Column name.
            valueList (list): Nested list of column values.
 
        Raises:
            Exception: If the column name is invalid.
 
        This method assigns a list of values to a column across pages.
        """
        numberOfColumns = len(self.columnName)
        if name in self.columnName:
            self.columnData[self.columnName.index(name)] = valueList
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 

setDescription()

sdds.SDDS.setDescription	(		self,
			text,
			contents )

Sets the description for the SDDS object.

Args: text (str): Description text. contents (str): Description contents.

Definition at line 514 of file sdds.py.

    def setDescription(self, text, contents):
        """
        Sets the description for the SDDS object.
 
        Args:
            text (str): Description text.
            contents (str): Description contents.
        """
        self.description = [text, contents]
 

setParameterValue()

sdds.SDDS.setParameterValue	(		self,
			name,
			value,
			page = 1 )

Sets a single parameter value at a specific page.

Args: name (str): Parameter name. value: Parameter value. page (int, optional): Page number (1-based index, defaults to 1).

Raises: Exception: If the parameter name or page is invalid.

This method sets the parameter value at the specified page.

Definition at line 741 of file sdds.py.

    def setParameterValue(self, name, value, page=1):
        """
        Sets a single parameter value at a specific page.
 
        Args:
            name (str): Parameter name.
            value: Parameter value.
            page (int, optional): Page number (1-based index, defaults to 1).
 
        Raises:
            Exception: If the parameter name or page is invalid.
 
        This method sets the parameter value at the specified page.
        """
        page = page - 1
        numberOfParameters = len(self.parameterName)
        if name in self.parameterName:
            i = self.parameterName.index(name)
            if len(self.parameterData[i]) == page:
                self.parameterData[i][page:] = [value]
            elif len(self.parameterData[i]) < page or page < 0:
                msg = "Invalid page " + str(page + 1)
                raise Exception(msg)
            else:
                self.parameterData[i][page] = value
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

setParameterValueList()

sdds.SDDS.setParameterValueList	(		self,
			name,
			valueList )

Sets the list of parameter values for a parameter.

This can be used to set values for multiple pages at once.

Args: name (str): Parameter name. valueList (list): List of values for the parameter.

Raises: Exception: If the parameter name is invalid.

This method assigns a list of values to a parameter across pages.

Definition at line 700 of file sdds.py.

    def setParameterValueList(self, name, valueList):
        """
        Sets the list of parameter values for a parameter. This can be used to set values for multiple pages at once.
 
        Args:
            name (str): Parameter name.
            valueList (list): List of values for the parameter.
 
        Raises:
            Exception: If the parameter name is invalid.
 
        This method assigns a list of values to a parameter across pages.
        """
        numberOfParameters = len(self.parameterName)
        if name in self.parameterName:
            self.parameterData[self.parameterName.index(name)] = valueList
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 

Member Data Documentation

_max_index

int sdds.SDDS._max_index = 1000

staticprotected

Definition at line 83 of file sdds.py.

_used_indices

sdds.SDDS._used_indices = set()

staticprotected

Definition at line 82 of file sdds.py.

arrayData

list sdds.SDDS.arrayData = []

Definition at line 123 of file sdds.py.

arrayDefinition

list sdds.SDDS.arrayDefinition = []

Definition at line 119 of file sdds.py.

arrayDimensions

list sdds.SDDS.arrayDimensions = []

Definition at line 120 of file sdds.py.

arrayName [1/2]

str sdds.SDDS.arrayName = []

Definition at line 116 of file sdds.py.

arrayName [2/2]

str sdds.SDDS.arrayName = "Invalid array name " + name

Definition at line 836 of file sdds.py.

columnData

list sdds.SDDS.columnData = []

Definition at line 124 of file sdds.py.

columnDefinition

list sdds.SDDS.columnDefinition = []

Definition at line 121 of file sdds.py.

columnName [1/2]

str sdds.SDDS.columnName = []

Definition at line 117 of file sdds.py.

columnName [2/2]

str sdds.SDDS.columnName = "Invalid column name " + name

Definition at line 986 of file sdds.py.

description

list sdds.SDDS.description = ["", ""]

Definition at line 114 of file sdds.py.

index

sdds.SDDS.index = i

Definition at line 100 of file sdds.py.

loaded_pages

sdds.SDDS.loaded_pages = 0

Definition at line 126 of file sdds.py.

mode

sdds.SDDS.mode = self.SDDS_ASCII

Definition at line 125 of file sdds.py.

parameterData

list sdds.SDDS.parameterData = []

Definition at line 122 of file sdds.py.

parameterDefinition

list sdds.SDDS.parameterDefinition = []

Definition at line 118 of file sdds.py.

parameterName [1/2]

str sdds.SDDS.parameterName = []

Definition at line 115 of file sdds.py.

parameterName [2/2]

str sdds.SDDS.parameterName = "Invalid parameter name " + name

Definition at line 735 of file sdds.py.

SDDS_ASCII

int sdds.SDDS.SDDS_ASCII = 2

static

Definition at line 79 of file sdds.py.

SDDS_BINARY

int sdds.SDDS.SDDS_BINARY = 1

static

Definition at line 78 of file sdds.py.

SDDS_CHARACTER

int sdds.SDDS.SDDS_CHARACTER = 11

static

Definition at line 74 of file sdds.py.

SDDS_CHECK_NONEXISTENT

int sdds.SDDS.SDDS_CHECK_NONEXISTENT = 1

static

Definition at line 51 of file sdds.py.

SDDS_CHECK_OKAY

int sdds.SDDS.SDDS_CHECK_OKAY = 0

static

Definition at line 50 of file sdds.py.

SDDS_CHECK_WRONGTYPE

int sdds.SDDS.SDDS_CHECK_WRONGTYPE = 2

static

Definition at line 52 of file sdds.py.

SDDS_CHECK_WRONGUNITS

int sdds.SDDS.SDDS_CHECK_WRONGUNITS = 3

static

Definition at line 53 of file sdds.py.

SDDS_DOUBLE

int sdds.SDDS.SDDS_DOUBLE = 2

static

Definition at line 57 of file sdds.py.

SDDS_EXIT_PrintErrors

int sdds.SDDS.SDDS_EXIT_PrintErrors = 2

static

Definition at line 47 of file sdds.py.

SDDS_FLOAT

int sdds.SDDS.SDDS_FLOAT = 3

static

Definition at line 59 of file sdds.py.

SDDS_FLUSH_TABLE

int sdds.SDDS.SDDS_FLUSH_TABLE = 1

static

Definition at line 80 of file sdds.py.

SDDS_INT16

int sdds.SDDS.SDDS_INT16 = 8

static

Definition at line 70 of file sdds.py.

SDDS_INT32

int sdds.SDDS.SDDS_INT32 = 6

static

Definition at line 66 of file sdds.py.

SDDS_INT64

int sdds.SDDS.SDDS_INT64 = 4

static

Definition at line 62 of file sdds.py.

SDDS_LONG

int sdds.SDDS.SDDS_LONG = 6

static

Definition at line 65 of file sdds.py.

SDDS_LONG64

int sdds.SDDS.SDDS_LONG64 = 4

static

Definition at line 61 of file sdds.py.

SDDS_LONGDOUBLE

int sdds.SDDS.SDDS_LONGDOUBLE = 1

static

Definition at line 56 of file sdds.py.

SDDS_NUM_TYPES

int sdds.SDDS.SDDS_NUM_TYPES = 11

static

Definition at line 75 of file sdds.py.

SDDS_REAL32

int sdds.SDDS.SDDS_REAL32 = 3

static

Definition at line 60 of file sdds.py.

SDDS_REAL64

int sdds.SDDS.SDDS_REAL64 = 2

static

Definition at line 58 of file sdds.py.

SDDS_SHORT

int sdds.SDDS.SDDS_SHORT = 8

static

Definition at line 69 of file sdds.py.

SDDS_STRING

int sdds.SDDS.SDDS_STRING = 10

static

Definition at line 73 of file sdds.py.

SDDS_UINT16

int sdds.SDDS.SDDS_UINT16 = 9

static

Definition at line 72 of file sdds.py.

SDDS_UINT32

int sdds.SDDS.SDDS_UINT32 = 7

static

Definition at line 68 of file sdds.py.

SDDS_UINT64

int sdds.SDDS.SDDS_UINT64 = 5

static

Definition at line 64 of file sdds.py.

SDDS_ULONG

int sdds.SDDS.SDDS_ULONG = 7

static

Definition at line 67 of file sdds.py.

SDDS_ULONG64

int sdds.SDDS.SDDS_ULONG64 = 5

static

Definition at line 63 of file sdds.py.

SDDS_USHORT

int sdds.SDDS.SDDS_USHORT = 9

static

Definition at line 71 of file sdds.py.

SDDS_VERBOSE_PrintErrors

sdds.SDDS.SDDS_VERBOSE_PrintErrors = 1

static

Definition at line 46 of file sdds.py.

---

The documentation for this class was generated from the following file:

• SDDS/python/sdds.py