engioptiqa 0.2.2__py3-none-any.whl

engioptiqa/__init__.py

@@ -0,0 +1,9 @@
+from .annealing_solvers import *
+from .problems import *
+__all__ = [
+    "AnnealingSolverAmplify",
+    "AnnealingSolverDWave",
+    "DesignOptimizationProblem",
+    "Rod1D",
+    "StructuralAnalysisProblem",
+]

engioptiqa/annealing_solvers/__init__.py

@@ -0,0 +1,7 @@
+from .annealing_solver_amplify import AnnealingSolverAmplify
+from .annealing_solver_dwave import AnnealingSolverDWave
+
+__all__ = [
+    "AnnealingSolverAmplify",
+    "AnnealingSolverDWave"
+]

engioptiqa/annealing_solvers/annealing_solver.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+class AnnealingSolver(ABC):
+
+    def __init__(self, token_file=None, proxy=None):
+        self.proxy = proxy
+        if token_file is not None:
+            self.token = open(token_file,"r").read().replace('\n', '')
+            self.setup_client()
+
+    @abstractmethod
+    def setup_client(self):
+        pass
+
+    @abstractmethod
+    def setup_solver(self):
+        pass
+
+    @abstractmethod
+    def solve_qubo_problem(self, problem):
+        pass

engioptiqa/annealing_solvers/annealing_solver_amplify.py

@@ -0,0 +1,55 @@
+from amplify import Solver
+from amplify.client import FixstarsClient
+from amplify.client.ocean import DWaveSamplerClient, LeapHybridSamplerClient
+
+from .annealing_solver import AnnealingSolver
+
+class AnnealingSolverAmplify(AnnealingSolver):
+    """
+        Initialize the Annealing Solver that uses the Amplify SDK.
+
+        :param client_type: The client type.
+        :param token_file: The path of the file that includes the token for the Fixstars Amplify Annealing Engine.
+    """
+    def __init__(self, client_type, token_file, proxy=None):
+        self.client_type = client_type
+        super().__init__(token_file, proxy)
+
+
+    def setup_client(self):
+
+        if self.client_type == 'fixstars':
+            self.client = FixstarsClient(token=self.token)
+        elif self.client_type == 'dwave':
+            self.client = DWaveSamplerClient(token=self.token)
+        elif self.client_type == 'dwave_hybrid':
+            self.client = LeapHybridSamplerClient(token=self.token)
+        else:
+            raise Exception('Unknown client type', self.client_type)
+        if self.proxy:
+            self.client.proxy = self.proxy
+        if self.client_type in ['dwave','dwave_hybrid']:
+            print('Available solvers:', self.client.solver_names)
+
+    
+    def setup_solver(self):
+
+        if self.client_type == 'fixstars':
+            print('Setting default timeout (ms): 800')
+            self.client.parameters.timeout = 800
+        elif self.client_type == 'dwave':
+            print('Choosing default solver: Advantage_system4.1')
+            self.client.solver = "Advantage_system4.1"
+            print('Setting default num_reads: 200')
+            self.client.parameters.num_reads = 200 
+        elif self.client_type == 'dwave_hybrid':
+            print('Choosing default solver: hybrid_binary_quadratic_model_version2')
+            self.client.solver = 'hybrid_binary_quadratic_model_version2'
+
+        self.solver = Solver(self.client)
+        print("Created solver")
+
+    def solve_qubo_problem(self, problem):
+        
+        problem.results = self.solver.solve(problem.binary_quadratic_model)
+        print('Number of solutions:', len(problem.results))

engioptiqa/annealing_solvers/annealing_solver_dwave.py

@@ -0,0 +1,93 @@
+from dwave.cloud import Client
+from dwave.samplers import SimulatedAnnealingSampler, SteepestDescentSolver
+from dwave.system import DWaveSampler, EmbeddingComposite, LeapHybridSampler
+
+from .annealing_solver import AnnealingSolver
+
+class AnnealingSolverDWave(AnnealingSolver):
+
+    def __init__(self, token_file=None, proxy=None):
+        self.client_type = 'dwave'
+        super().__init__(token_file, proxy)
+
+    def setup_client(self):
+
+        self.client = Client(token=self.token, proxy=self.proxy)
+        print("Available QPU solvers:")
+        for solver in self.client.get_solvers(qpu=True, online=True):
+            print("\t", solver)
+        print("Available hybrid solvers:")
+        for solver in self.client.get_solvers(name__regex='hybrid_binary.*', online=True):
+            print("\t", solver)
+
+    def setup_solver(self, solver_type=None, solver_name=None):
+        
+        if solver_name:
+            self.solver_name = solver_name
+            solver = self.client.get_solver(name=self.solver_name)
+            if solver.qpu:
+                self.solver_type = 'qpu'
+                self.solver = EmbeddingComposite(
+                    DWaveSampler(
+                        token=self.token, 
+                        proxy=self.proxy, 
+                        solver=dict(name=self.solver_name)
+                    )
+                )
+            else:
+                self.solver_type = 'hybrid'
+                self.solver = LeapHybridSampler(token=self.token, proxy=self.proxy)
+
+        elif solver_type:
+            self.solver_type = solver_type
+            if self.solver_type == 'qpu':
+                self.solver = EmbeddingComposite(
+                    DWaveSampler(token=self.token, proxy=self.proxy)
+                )
+                self.solver_name = self.solver.child.properties["chip_id"]
+             
+            elif self.solver_type == 'hybrid':
+                self.solver = LeapHybridSampler(token=self.token, proxy=self.proxy)
+                self.solver_name =  self.solver.properties["category"] + ' ' + self.solver.properties["version"]
+
+            elif self.solver_type == 'simulated_annealing':
+                self.solver = SimulatedAnnealingSampler() 
+                self.solver_name = 'simulated annealing'
+            else:
+                raise Exception('Unknown solver type', self.solver_type)
+        else:
+            raise Exception('Either a solver type or a specific solver name must be specified.')
+        
+        print("Use", self.solver_type, "solver:", self.solver_name)
+
+    def solve_qubo_problem(self, problem, **kwargs):
+
+        problem.results_indices = self.solver.sample(
+            problem.binary_quadratic_model_indices, 
+            **kwargs
+        )
+        print('Number of solutions:', len(problem.results_indices))
+        if hasattr(problem, 'mapping_i_to_q'):
+            problem.results =  problem.results_indices.relabel_variables(
+                problem.mapping_i_to_q,
+                inplace=False)
+        else:
+            problem.results = problem.results_indices 
+
+    def perform_local_search(self, problem):
+
+        if hasattr(problem, 'results_indices'):
+            solver_greedy = SteepestDescentSolver()
+            sampleset_pp = solver_greedy.sample(
+                problem.binary_quadratic_model_indices,
+                initial_states=problem.results_indices
+                ) 
+            if hasattr(problem, 'mapping_i_to_q'):
+                problem.results_pp = sampleset_pp.relabel_variables(
+                    problem.mapping_i_to_q,
+                    inplace=False)
+            else:
+                problem.results_pp = sampleset_pp
+            
+        else:
+            raise Exception('Trying to perform local search altough no results exist yet.')

engioptiqa/problems/__init__.py

@@ -0,0 +1,7 @@
+from .rod_1d import *
+
+__all__ = [
+    "DesignOptimizationProblem",
+    "Rod1D",
+    "StructuralAnalysisProblem"
+]

engioptiqa/problems/rod_1d/__init__.py

@@ -0,0 +1,9 @@
+from .design_optimization_problem import DesignOptimizationProblem
+from .rod_1d import Rod1D
+from .structural_analysis_problem import StructuralAnalysisProblem
+
+__all__ = [
+    "DesignOptimizationProblem",
+    "Rod1D",
+    "StructuralAnalysisProblem",
+]