sdds.py

Go to the documentation of this file.

"""
@file sdds.py
@brief Python script providing the SDDS Python module.
@details
This module provides the `SDDS` class and associated methods to load, manipulate, and save SDDS files.
It supports both ASCII and binary SDDS formats and provides functionality to read, write, and manipulate SDDS data.
 
Dependencies:
    sddsdata module
"""
 
import sddsdata
import sys
import time
 
 
class SDDS:
    """
    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.
 
    Important:
    -   Each SDDS object must be initialized with a unique index ranging 
        from 0 to 19. This index is required to manage the internal SDDS 
        library resources and ensure no conflicts between multiple SDDS 
        objects in the same program.
    -   Ensure that the index is released (if necessary) before reusing it.
 
    Attributes:
        index (int): The index of the SDDS dataset (integer from 0 to 19).
        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`).
    """
 
    # Class constants for error printing modes
    SDDS_VERBOSE_PrintErrors = 1     # Verbose error printing mode
    SDDS_EXIT_PrintErrors = 2        # Exit on error printing mode
 
    # Class constants for SDDS check statuses
    SDDS_CHECK_OKAY = 0              # SDDS check status: okay
    SDDS_CHECK_NONEXISTENT = 1       # SDDS check status: non-existent
    SDDS_CHECK_WRONGTYPE = 2         # SDDS check status: wrong type
    SDDS_CHECK_WRONGUNITS = 3        # SDDS check status: wrong units
 
    # Class constants for data types
    SDDS_LONGDOUBLE = 1
    SDDS_DOUBLE = 2
    SDDS_REAL64 = 2
    SDDS_FLOAT = 3
    SDDS_REAL32 = 3
    SDDS_LONG64 = 4
    SDDS_INT64 = 4
    SDDS_ULONG64 = 5
    SDDS_UINT64 = 5
    SDDS_LONG = 6
    SDDS_INT32 = 6
    SDDS_ULONG = 7
    SDDS_UINT32 = 7
    SDDS_SHORT = 8
    SDDS_INT16 = 8
    SDDS_USHORT = 9
    SDDS_UINT16 = 9
    SDDS_STRING = 10
    SDDS_CHARACTER = 11
    SDDS_NUM_TYPES = 11
 
    # Class constants for modes
    SDDS_BINARY = 1
    SDDS_ASCII = 2
    SDDS_FLUSH_TABLE = 1
 
    def __init__(self, index):
        """
        Initializes a new SDDS object.
 
        Args:
            index (int): Integer index of the SDDS object. Must be between 0 and 19 inclusive.
 
        The attributes are initialized to their default values.
        """
        if 0 <= index < 20:
            self.index = index
        else:
            self.index = 0
        # Initialize data storage variables
        self.description = ["", ""]
        self.parameterNameparameterName = []
        self.arrayNamearrayName = []
        self.columnNamecolumnName = []
        self.parameterDefinition = []
        self.arrayDefinition = []
        self.arrayDimensions = []
        self.columnDefinition = []
        self.parameterData = []
        self.arrayData = []
        self.columnData = []
        self.mode = self.SDDS_ASCII
        self.loaded_pages = 0
 
    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.parameterNameparameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterNameparameterName)
 
            # Get array names
            self.arrayNamearrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayNamearrayName)
 
            # Get column names
            self.columnNamecolumnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnNamecolumnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterNameparameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayNamearrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnNamecolumnName]
 
            # 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
 
    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.parameterNameparameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterNameparameterName)
 
            # Get array names
            self.arrayNamearrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayNamearrayName)
 
            # Get column names
            self.columnNamecolumnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnNamecolumnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterNameparameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayNamearrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnNamecolumnName]
 
            # 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
 
    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.parameterNameparameterName = sddsdata.GetParameterNames(self.index)
            numberOfParameters = len(self.parameterNameparameterName)
 
            # Get array names
            self.arrayNamearrayName = sddsdata.GetArrayNames(self.index)
            numberOfArrays = len(self.arrayNamearrayName)
 
            # Get column names
            self.columnNamecolumnName = sddsdata.GetColumnNames(self.index)
            numberOfColumns = len(self.columnNamecolumnName)
 
            # Get parameter definitions
            self.parameterDefinition = [sddsdata.GetParameterDefinition(self.index, name) for name in self.parameterNameparameterName]
 
            # Get array definitions
            self.arrayDefinition = [sddsdata.GetArrayDefinition(self.index, name) for name in self.arrayNamearrayName]
 
            # Get column definitions
            self.columnDefinition = [sddsdata.GetColumnDefinition(self.index, name) for name in self.columnNamecolumnName]
 
            # 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
 
    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.parameterNameparameterName)
            numberOfArrays = len(self.arrayNamearrayName)
            numberOfColumns = len(self.columnNamecolumnName)
            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.parameterNameparameterName[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.arrayNamearrayName[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.columnNamecolumnName[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
 
    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]
 
    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.parameterNameparameterName.append(name)
        self.parameterDefinition.append(
            [symbol, units, description, formatString, type, fixedValue]
        )
        self.parameterData.append([])
 
    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.parameterNameparameterName.append(name)
        self.parameterDefinition.append(["", "", "", "", type, ""])
        self.parameterData.append([])
 
    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.arrayNamearrayName.append(name)
        self.arrayDefinition.append(
            [symbol, units, description, formatString, group_name, type, fieldLength, dimensions]
        )
        self.arrayData.append([])
        self.arrayDimensions.append([])
 
    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.arrayNamearrayName.append(name)
        self.arrayDefinition.append(["", "", "", "", "", type, 0, dimensions])
        self.arrayData.append([])
        self.arrayDimensions.append([])
 
    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.columnNamecolumnName.append(name)
        self.columnDefinition.append(
            [symbol, units, description, formatString, type, fieldLength]
        )
        self.columnData.append([])
 
    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.columnNamecolumnName.append(name)
        self.columnDefinition.append(["", "", "", "", type, 0])
        self.columnData.append([])
 
    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.parameterNameparameterName)
        if name in self.parameterNameparameterName:
            self.parameterData[self.parameterNameparameterName.index(name)] = valueList
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 
    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.parameterNameparameterName)
        if name in self.parameterNameparameterName:
            return(self.parameterData[self.parameterNameparameterName.index(name)])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 
    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.parameterNameparameterName)
        if name in self.parameterNameparameterName:
            i = self.parameterNameparameterName.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)
 
    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.parameterNameparameterName)
        if name in self.parameterNameparameterName:
            i = self.parameterNameparameterName.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)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            i = self.arrayNamearrayName.index(name)
            self.arrayDimensions[i] = dimensionList
            self.arrayData[i] = valueList
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            return(self.arrayData[self.arrayNamearrayName.index(name)])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            return(self.arrayDimensions[self.arrayNamearrayName.index(name)])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            i = self.arrayNamearrayName.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)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            i = self.arrayNamearrayName.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)
 
    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.arrayNamearrayName)
        if name in self.arrayNamearrayName:
            i = self.arrayNamearrayName.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)
 
    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.columnNamecolumnName)
        if name in self.columnNamecolumnName:
            self.columnData[self.columnNamecolumnName.index(name)] = valueList
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 
    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.columnNamecolumnName)
        if name in self.columnNamecolumnName:
            return(self.columnData[self.columnNamecolumnName.index(name)])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 
    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.columnNamecolumnName:
            i = self.columnNamecolumnName.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)
 
    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.columnNamecolumnName)
        if name in self.columnNamecolumnName:
            i = self.columnNamecolumnName.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)
 
    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.columnNamecolumnName)
        if name in self.columnNamecolumnName:
            i = self.columnNamecolumnName.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)
 
    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.columnNamecolumnName)
        if name in self.columnNamecolumnName:
            i = self.columnNamecolumnName.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)
 
    def getParameterCount(self):
        """
        Retrieves the number of parameters.
 
        Returns:
            int: The number of parameters.
        """
        return(len(self.parameterNameparameterName))
 
    def getArrayCount(self):
        """
        Retrieves the number of arrays.
 
        Returns:
            int: The number of arrays.
        """
        return(len(self.arrayNamearrayName))
 
    def getColumnCount(self):
        """
        Retrieves the number of columns.
 
        Returns:
            int: The number of columns.
        """
        return(len(self.columnNamecolumnName))
 
    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.parameterNameparameterName)
 
    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.arrayNamearrayName)
 
    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.columnNamecolumnName)
 
    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.parameterNameparameterName:
            return(self.parameterDefinition[self.parameterNameparameterName.index(name)][4])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 
    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.arrayNamearrayName:
            return(self.arrayDefinition[self.arrayNamearrayName.index(name)][5])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
    
    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.columnNamecolumnName:
            return(self.columnDefinition[self.columnNamecolumnName.index(name)][4])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 
    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.parameterNameparameterName:
            return(self.parameterDefinition[self.parameterNameparameterName.index(name)][1])
        else:
            msg = "Invalid parameter name " + name
            raise Exception(msg)
 
    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.arrayNamearrayName:
            return(self.arrayDefinition[self.arrayNamearrayName.index(name)][1])
        else:
            msg = "Invalid array name " + name
            raise Exception(msg)
    
    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.columnNamecolumnName:
            return(self.columnDefinition[self.columnNamecolumnName.index(name)][1])
        else:
            msg = "Invalid column name " + name
            raise Exception(msg)
 
    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
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
 
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")
 
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
 
 
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)
 
 
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
 
 
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
 
 
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
 
 
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