Skip to content

EigenmodeResults

A result object containing all modal data extracted from an Eigenmode simulation.

Each mode includes its frequency, quality factor, and optional label. The result can be flattened into tabular form or relabeled for use in quantum workflows.

Bases: BaseSimulationOutput

Result container for an Eigenmode simulation.

Stores computed modes, each with its frequency and quality factor. Provides utilities to transform, flatten, and relabel the results.

Attributes:

Name Type Description
type Literal[EIGENMODE_RESULT]

Simulation result type identifier (always 'eigenmode_result').
results dict[int, SingleModeResult]

Mapping of mode index to a SingleModeResult instance.
frequencies_unit str

The unit in which frequencies are expressed (default: 'GHz').
profile dict

Additional metadata or profile information.

change_frequencies_unit 

change_frequencies_unit(unit: str)

Change the unit of all stored frequencies.

Parameters:

Name Type Description Default
unit str

New frequency unit (e.g., 'MHz', 'GHz', etc.)

 required
Source code in src/quansys/simulation/eigenmode/results.py 
80
81
82
83
84
85
86
87
88
89
def change_frequencies_unit(self, unit: str):
    """
    Change the unit of all stored frequencies.

    Args:
        unit: New frequency unit (e.g., 'MHz', 'GHz', etc.)
    """
    self.frequencies_unit = unit
    for v in self.results.values():
        v.change_frequency_unit(self.frequencies_unit)

flatten 

flatten() -> FlatDictType

Flatten the result into a dictionary for tabular or CSV output.

Returns:

Type Description
FlatDictType

A flat dictionary with labeled keys and scalar values.
Source code in src/quansys/simulation/eigenmode/results.py 
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def flatten(self) -> FlatDictType:
    """
    Flatten the result into a dictionary for tabular or CSV output.

    Returns:
        A flat dictionary with labeled keys and scalar values.
    """
    result = {}
    for mode_number in self.results.keys():
        current = self.results[mode_number].flatten()
        result.update(current)

    # adding profile summary if exists
    if self.profile:
        # try:
        profile_dict = flat_profile(self.profile)
        # except Exception as exc:
        #     profile_dict = {}

        result.update(profile_dict)

    return result

generate_a_labeled_version 

generate_a_labeled_version(
    mode_to_labels: dict[int, str],
) -> EigenmodeResults

Create a new result object with mode labels assigned.

Parameters:

Name Type Description Default
mode_to_labels dict[int, str]

Mapping of mode index to label string.

 required

Returns:

Name Type Description
EigenmodeResults EigenmodeResults

A labeled version of the results.
Source code in src/quansys/simulation/eigenmode/results.py 
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def generate_a_labeled_version(self, mode_to_labels: dict[int, str]) -> EigenmodeResults:
    """
    Create a new result object with mode labels assigned.

    Args:
        mode_to_labels: Mapping of mode index to label string.

    Returns:
        EigenmodeResults: A labeled version of the results.
    """
    new_results = {}
    modes = sorted(mode_to_labels.keys())
    for i, mode in enumerate(modes):
        label = mode_to_labels[mode]
        item = self.results[mode].model_copy()
        item.label = label
        item.mode_number = i
        new_results[i] = item
    return EigenmodeResults(results=new_results, frequencies_unit=self.frequencies_unit)

generate_simple_form 

generate_simple_form() -> dict[int, dict[str, float]]

Convert the result set to a simplified dict format.

Returns:

Type Description
dict[int, dict[str, float]]

A dictionary mapping each mode to its frequency and quality factor.
Source code in src/quansys/simulation/eigenmode/results.py 
67
68
69
70
71
72
73
74
75
76
77
78
def generate_simple_form(self) -> dict[int, dict[str, float]]:
    """
    Convert the result set to a simplified dict format.

    Returns:
        A dictionary mapping each mode to its frequency and quality factor.
    """
    return {
        elem.mode_number: {'frequency': elem.frequency.value,
                           'quality_factor': elem.quality_factor}
        for elem in self.results.values()
    }