lightsolver-lib 0.6.0__tar.gz → 0.8.0__tar.gz

{lightsolver_lib-0.6.0 → lightsolver_lib-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lightsolver-lib
-Version: 0.6.0
+Version: 0.8.0
 Summary: Tools for developers using LightSolver's Cloud Platform
 Author-email: Matan Arkin <matan@lightsolver.com>
 Project-URL: Homepage, https://lightsolver.com

{lightsolver_lib-0.6.0 → lightsolver_lib-0.8.0}/lightsolver_lib/__init__.py

@@ -16,7 +16,7 @@ __all__ = ['calc_ising_energies',
            'calc_ising_energy_from_states',
            'XYModelParams',
            'coupling_matrix_xy',
-            'embed_coupmat',
-            'analyze_sol_XY',
-            'generate_animation',
+           'embed_coupmat',
+           'analyze_sol_XY',
+           'generate_animation',
            ]

{lightsolver_lib-0.6.0 → lightsolver_lib-0.8.0}/lightsolver_lib/lightsolver_lib.py

@@ -1,4 +1,6 @@
 import numpy
+import plotly.graph_objects as go
+import plotly.express as px
 
 def calc_ising_energies(problem_mat_ising: numpy.ndarray, states_ising: numpy.ndarray) -> numpy.ndarray:
     """
@@ -124,8 +126,8 @@ def best_energy_search_xy(state: numpy.ndarray, probmat_ising: numpy.ndarray) ->
     - `best_energy` - Energy of the best state
     """
     is_single_state = len(state.shape) == 1
-    # if is_single_state:
-    #     state = state.reshape(-1, 1)    
+    if is_single_state:
+        state = state.reshape(-1, 1)
         
     n_lasers = state.shape[0]
     n_states = 1 if is_single_state else state.shape[1]
@@ -257,21 +259,18 @@ class XYModelParams():
     ## Parameters for converting an Ising model to the XY model.
 
     ### Members:
-    - `alphaR` - Reference lasers self coupling strength - default: 0.7
-    - `alphaI` - Vortex lasers self coupling strength - default: 0.7
+    - `minSelfCoup` - Vortex lasers minimal allowed self coupling strength - default: 0.5
     - `coupAmp` - Coupling amplitude, default: 0.3
     - `exFieldCoup` - Coupling of external field, default : 0.3
     """
-    def __init__(self, alphaR = 0.7, alphaI = 0.7, coupAmp = 0.3, exFieldCoup = 0.3):
-        self.alphaI = alphaI
-        self.alphaR = alphaR
+    def __init__(self, minSelfCoup = 0.7, coupAmp = 0.3, exFieldCoup = 0.3):
+        self.minSelfCoup = minSelfCoup
         self.coupAmp = coupAmp
         self.exFieldCoup = exFieldCoup
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, XYModelParams) and \
-            self.alphaI == other.alphaI and \
-            self.alphaR == other.alphaR and \
+            self.minSelfCoup == other.minSelfCoup and \
             self.coupAmp == other.coupAmp and \
             self.exFieldCoup == other.exFieldCoup
     
@@ -289,18 +288,243 @@ def coupling_matrix_xy(problem_matrix:numpy.ndarray, modelParamsXY:XYModelParams
     - `coupling_matrix` - The generated coupling matrix for the XY model
     """
     N = problem_matrix.shape[0]
-    max_sum_rows = numpy.max(numpy.sum(numpy.abs(problem_matrix), axis=1))
-
-    if external_field:
-        coupling_matrix = numpy.zeros((N + 1, N + 1), dtype=numpy.float32)
-        coupling_matrix[1:, 1:] = - (problem_matrix / max_sum_rows) * modelParamsXY.coupAmp
-        numpy.fill_diagonal(coupling_matrix[1:, 1:], modelParamsXY.alphaI)
-        coupling_matrix[1:, 0] = - modelParamsXY.exFieldCoup * (problem_matrix.diagonal() / max_sum_rows)
-        coupling_matrix[0, 0] = modelParamsXY.alphaR
+    problem_matrix[numpy.diag_indices(N)] = 0.5 * numpy.diag(problem_matrix)
+    max_sum_rows = numpy.max(numpy.sum(numpy.abs(problem_matrix),axis=1))
+    row_sum = 1
     
+    if external_field:
+        external_field_half = numpy.diag(problem_matrix)
+        sum_ex_field_half = numpy.sum(numpy.abs(external_field_half))
+        M = max(sum_ex_field_half, max_sum_rows) / (1 - modelParamsXY.minSelfCoup)
+        
+        coupling_matrix = numpy.zeros((N + 1, N + 1),dtype=numpy.float32)    
+        coupling_matrix[1:,1:] = -(problem_matrix / M) * modelParamsXY.coupAmp
+        coupling_matrix[1:, 0] = -modelParamsXY.exFieldCoup * (external_field_half / M)
+        coupling_matrix[0, 1:] = -modelParamsXY.exFieldCoup * (external_field_half / M)
+        coupling_matrix[numpy.diag_indices(N + 1)] = row_sum - numpy.sum(numpy.abs(coupling_matrix), axis=1)
     else:
-        coupling_matrix = numpy.zeros((N, N), dtype=numpy.float32)
-        coupling_matrix = - (problem_matrix / max_sum_rows) * modelParamsXY.coupAmp
-        numpy.fill_diagonal(coupling_matrix, modelParamsXY.alphaI)
+        M = max_sum_rows / (1 - modelParamsXY.minSelfCoup)
+        
+        coupling_matrix = numpy.zeros((N, N), dtype=numpy.float32)    
+        coupling_matrix = -(problem_matrix / M) * modelParamsXY.coupAmp    
+        coupling_matrix[numpy.diag_indices(N)] = row_sum - numpy.sum(numpy.abs(coupling_matrix), axis=1)
+
+    assert (numpy.diag(coupling_matrix) >= modelParamsXY.minSelfCoup).all()
+    assert (numpy.sum(numpy.abs(coupling_matrix), axis=1) <= 1).all()
+   
+    return coupling_matrix
+
+
+def embed_coupmat(coupling_matrix, indices=None, total_laser_num=15):
+        '''
+        ## Embed a coupling matrix into a larger matrix of size total_laser_num x total_laser_num.
+
+        ### Parameters:
+        - coupling_matrix: (N x N) complex matrix to embed
+        - indices: list of indices at which to embed the matrix. If None, embed from index 0.
+        - total_laser_num: total size of the output matrix (default 15)
+
+        ### Returns:
+        - embedded: (total_laser_num x total_laser_num) matrix with the coupling matrix embedded
+        '''
+        N = coupling_matrix.shape[0]
+
+        embedded = 0.001 * numpy.eye(total_laser_num).astype(numpy.complex64)   # small coupling for the rest of the lasers
+                                                                          # (value will remain for those not included in the problem)
+
+        if indices is None:
+            embedded[:N, :N] = coupling_matrix
+        else:
+            if len(indices) == 1:
+                start = indices[0]
+                embedded[start:start+N, start:start+N] = coupling_matrix
+            else:
+                indices = numpy.array(indices)
+                embedded[numpy.ix_(indices, indices)] = coupling_matrix
+
+        return embedded
+
+
+def analyze_sol_XY(problem_matrix, phases_diffs):
+    '''
+    ## Function to analyze the solution from LPU and return binary state and its energy. 
+    ## It recives the problem matrix and the phase difference solution and returns binary solution according to XY mapping.
+    ### Parameters:
+    - `problem_matrix` - The problem matrix (Ising model)   
+    - `phases_diffs` - The phase differences solution from the LPU
+    ### Returns:
+    - `min_energy` - The minimum energy found
+    - `best_state` - The binary state corresponding to the minimum energy
+    '''
+    # 
+    phases = (numpy.cumsum(phases_diffs, axis=1)) % (2 * numpy.pi)
+    N = phases.shape[1]
+
+    # Initialize:
+    energy = numpy.zeros(phases.shape[0])
+    x = numpy.zeros(shape=phases.shape)
+    correction = numpy.linspace(0, 0.1, N)                 # optional error sizes
+    correction = numpy.append(correction, -1*correction)   # error may go both ways
+
+    def _to_scalar(value):
+        # best_energy_search_xy may return a scalar-like ndarray; normalize it.
+        return float(numpy.asarray(value).reshape(-1)[0])
+
+    for i in range(phases.shape[0]) :
 
-    return coupling_matrix
+        min_bin_state, eng_new = best_energy_search_xy(numpy.exp(1J * phases[i, :]), numpy.real(problem_matrix))
+        min_bin_energy = _to_scalar(eng_new) if numpy.asarray(eng_new).size == 1 else eng_new
+
+        energies = [numpy.Inf]
+
+        for corr in correction:
+            correction_array = corr * numpy.arange(phases[i, :].shape[0])
+            new_state = phases[i, :] + correction_array
+            sol_new =(new_state[:])
+            laser_sol_new, eng_new = best_energy_search_xy(numpy.exp(1J * sol_new), numpy.real(problem_matrix))
+            eng_new_value = _to_scalar(eng_new) if numpy.asarray(eng_new).size == 1 else eng_new
+            if eng_new_value < min_bin_energy:
+                min_bin_state = laser_sol_new
+                min_bin_energy = eng_new_value
+            energies.append(eng_new_value)
+
+        corrected = numpy.argmin(energies)
+        x[i, :] = numpy.asarray(min_bin_state).reshape(-1)[:N]
+        energy[i] = numpy.min(energies)
+
+    min_ind = numpy.argmin(energy)
+
+    return numpy.min(energy), x[min_ind,:]
+
+
+def generate_animation(outWave, save=False):
+    '''
+    ## Generate an animated polar plot using Plotly to visualize the evolution of laser states.
+    ### Parameters:
+    - `outWave` - A 2D numpy array where each row represents the state of lasers at a specific time/frame.
+    - `save` - Boolean flag to save the animation as an HTML file (default is False).
+    ### Returns:
+    - None (displays the animation and optionally saves it).
+    '''
+    # Number of frames in the animation
+    num_frames = outWave.shape[0]
+    color_scale = px.colors.qualitative.Set1[:outWave.shape[1]]
+
+    fig = go.Figure()
+
+    # Create text for the polar plot
+    N = outWave.shape[1]
+    text = [str(int(a)) for a in numpy.linspace(1, N, num=N, endpoint=True)]
+
+    # Create data for the initial frame
+    theta = numpy.angle(outWave[0, :]) *  180 / numpy.pi
+    radius = numpy.abs(outWave[0, :])
+    initial_frame_data = [go.Scatterpolar(r=radius, theta=theta, mode='markers+text', marker=dict(size=10, color=color_scale), text=text, textposition='top center', showlegend=False),
+                          ]
+
+    # Create the layout
+    layout = go.Layout(
+        showlegend=False,
+        polar=dict(radialaxis=dict(visible=True)),
+    )
+
+    # Create the figure with the initial frame
+    fig.add_trace(initial_frame_data[0])                      # Add the initial trace
+    fig.update_layout(layout)
+    fig.update_xaxes(title_text="iteration")
+    fig.update_layout(showlegend=True)
+
+    # Define animation frames
+    animation_frames = []
+
+    for i in range(1, num_frames):
+        theta = numpy.angle(outWave[i, :]) *  180 / numpy.pi
+        r_values = numpy.abs(outWave[i, :])
+        frame_data = [go.Scatterpolar(r=r_values, theta=theta, mode='markers+text', marker=dict(size=10, color=color_scale), name='polar plot', text=text, textposition='top center', showlegend=False),
+                      ]
+        animation_frames.append(go.Frame(data=frame_data, name=f"frame_{i}"))
+
+    # Add frames to the figure
+    fig.frames = animation_frames
+
+    # Define animation options
+    animation_opts = dict(
+        frame=dict(duration=500, redraw=True),
+        fromcurrent=True
+    )
+
+    # Add play button
+    fig.update_layout(
+        updatemenus=[
+            {
+                'buttons': [
+                    {
+                        'args': [None, {'frame': {'duration': 500, 'redraw': True}, 'fromcurrent': True}],
+                        'label': 'Play',
+                        'method': 'animate'
+                    },
+                    {
+                        'args': [[None], {'frame': {'duration': 0, 'redraw': True}, 'mode': 'immediate', 'transition': {'duration': 0}}],
+                        'label': 'Pause',
+                        'method': 'animate'
+                    }
+                ],
+                'direction': 'left',
+                'pad': {'r': 10, 't': 87},
+                'showactive': False,
+                'type': 'buttons',
+                'x': 0.1,
+                'xanchor': 'right',
+                'y': 0.2,
+                'yanchor': 'top'
+            }
+        ],
+        template= "seaborn" # "plotly_dark"
+    )
+
+    # Define slider steps
+    steps = []
+    for i in range(num_frames):
+        step = dict(
+            method="animate",
+            args=[
+                [f"frame_{i}"],
+                dict(
+                    mode="immediate",
+                    frame=dict(duration=300, redraw=True),
+                    transition=dict(duration=0)
+                ),
+            ],
+            label=str(i)
+        )
+        steps.append(step)
+
+    # Add slider to layout
+    fig.update_layout(
+        sliders=[dict(
+            active=0,
+            currentvalue={"prefix": "Frame: "},
+            pad={"t": 50},
+            steps=steps
+        )]
+    )
+
+    fig.update_layout(
+            polar=dict(
+                radialaxis=dict(visible=True)
+            ),
+            xaxis=dict(domain=[0.65, 1]),
+            yaxis=dict(domain=[0.65, 1]),
+            yaxis2=dict(domain=[0, 0.35], anchor='x', overlaying='y', side='right')
+        )
+
+    fig.update_layout(
+            autosize=False,
+            width=1200,
+            height=800,
+        )
+    # Display & save the figure
+    fig.show()
+    # Save the figure as an HTML file
+    if save:
+        fig.write_html('polar_animation.html')

{lightsolver_lib-0.6.0 → lightsolver_lib-0.8.0}/lightsolver_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lightsolver-lib
-Version: 0.6.0
+Version: 0.8.0
 Summary: Tools for developers using LightSolver's Cloud Platform
 Author-email: Matan Arkin <matan@lightsolver.com>
 Project-URL: Homepage, https://lightsolver.com

{lightsolver_lib-0.6.0 → lightsolver_lib-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lightsolver-lib"
-version = "0.6.0"
+version = "0.8.0"
 description = "Tools for developers using LightSolver's Cloud Platform"
 readme = "README.md"
 requires-python = ">=3.8"