Repository: entropicalabs/openqaoa (language: python)

Issue:
QAOA benchmark
Benchmark object for qaoa

- [x] Qaoa Benchmark object
- [x] decide the import
- [x] Create reference object
- [x] Run method for benchmarked object and reference
- [x] When running the benchmark it evaluates the points such that at each round there is more resolution
- [x] Plot method for results
- [x] Difference property between benchmarked values and reference
- [x] Mean difference property
- [x] Notebook
- [x] Tests

For examples read notebook 14 (new), here is a simple example:
```
from openqaoa import QAOA, create_device, QAOABenchmark
from openqaoa.problems import QUBO

qaoa = QAOA()
qaoa.set_device(create_device(name='qiskit.shot_simulator', location='local'))
qaoa.compile(QUBO.random_instance(5))
benchmark = QAOABenchmark(qaoa)
benchmark.run(n_points_axis=2**4, ranges=[(0,1),(0,1)], plot=True)
```


Discussion / hints:

Fix patch:
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 1eb621726..e020290b5 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -247,6 +247,7 @@ Contents
    notebooks/11_Mixer_example.ipynb
    notebooks/12_testing_azure.ipynb
    notebooks/13_optimizers.ipynb
+   notebooks/14_qaoa_benchmark.ipynb
    notebooks/X_dumping_data.ipynb
 
 
diff --git a/examples/13_optimizers.ipynb b/examples/13_optimizers.ipynb
index 3c9c5cd04..3b806e532 100644
--- a/examples/13_optimizers.ipynb
+++ b/examples/13_optimizers.ipynb
@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# X - QAOA parameters optimization with different optimization algorithms\n",
+    "# 13 - QAOA parameters optimization with different optimization algorithms\n",
     "\n",
     "This notebook will provide a brief overview of all the optimizers available in OpenQAOA for optimizing the QAOA parameters. If you would like to learn more about what an optimizer is and obtain a more comprehensive explanation of all the methods implemented in the library, please refer to our documentation on this topic at https://openqaoa.entropicalabs.com/optimizers/shot-adaptive-optimizers/."
    ]
diff --git a/examples/14_qaoa_benchmark.ipynb b/examples/14_qaoa_benchmark.ipynb
new file mode 100644
index 000000000..a9a5a3330
--- /dev/null
+++ b/examples/14_qaoa_benchmark.ipynb
@@ -0,0 +1,744 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 14 - QAOA Benchmark\n",
+    "\n",
+    "This notebook will provide an overview of QAOA Benchmarks."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a problem instance\n",
+    "We begin by creating a problem instance for a simple `MaximumCut` problem for a random graph created using the `random_instance` method of the class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openqaoa.problems import MaximumCut\n",
+    "\n",
+    "# Use the MinimumVertexCover class to instantiate the problem, and get the QUBO representation of the problem\n",
+    "prob = MaximumCut.random_instance(n_nodes=7, edge_probability=0.9, seed=10)\n",
+    "qubo = prob.qubo"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a QAOA object with the device to benchmark"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, we create the `QAOA` object with the device that we want to benchmark"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qpu_credentials ={\n",
+    "    \"hub\": \"ibm-q\",\n",
+    "    \"group\": \"open\", \n",
+    "    \"project\": \"main\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openqaoa import QAOA, create_device\n",
+    "\n",
+    "# create the QAOA object\n",
+    "q = QAOA()\n",
+    "\n",
+    "# set device and backend properties\n",
+    "qiskit_cloud = create_device(location='ibmq', name='ibm_oslo', **qpu_credentials, as_emulator=True)\n",
+    "q.set_device(qiskit_cloud)\n",
+    "q.set_backend_properties(n_shots=1000)\n",
+    "\n",
+    "# set properties\n",
+    "q.set_circuit_properties(p=1, param_type='standard')\n",
+    "\n",
+    "# compile with the problem\n",
+    "q.compile(qubo)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the code above, one can see that the `.set_classical_optimizer` method has not been used. This is because the benchmark process does not use the optimization loop."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Benchmark"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we create the benchmark object. This object has different methods that will allow us to benchmark the corresponding device and to plot the values taken."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openqaoa import QAOABenchmark\n",
+    "\n",
+    "# create the QAOABenchmark object, passing the QAOA object to benchmark as an argument\n",
+    "benchmark = QAOABenchmark(q)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When initializing the object two attributes are set: `.qaoa` and `.reference`.\n",
+    "- `.qaoa` will be the QAOA object passed, the object to be benchmarked.\n",
+    "- `.reference` will be a QAOA object with the same circuit properties as `.qaoa` but with an `analytical_simulator` backend. It will also be compiled with the same problem. This object will be the reference for the `.qaoa` object to be compared with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ".qaoa: <class 'openqaoa.algorithms.qaoa.qaoa_workflow.QAOA'> ,\t\t .qaoa.backend: <class 'openqaoa_qiskit.backends.qaoa_qiskit_qpu.QAOAQiskitQPUBackend'>\n",
+      ".reference: <class 'openqaoa.algorithms.qaoa.qaoa_workflow.QAOA'> ,\t .reference.backend: <class 'openqaoa.backends.qaoa_analytical_sim.QAOABackendAnalyticalSimulator'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('.qaoa:', type(benchmark.qaoa), ',\\t\\t .qaoa.backend:', type(benchmark.qaoa.backend))\n",
+    "print('.reference:', type(benchmark.reference), ',\\t .reference.backend:', type(benchmark.reference.backend))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run Benchmark"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `.run` method of the `QAOABenchmark` object will run the benchmark. \n",
+    "\n",
+    "It evaluates the QAOA circuit of the benchmarked object for a given number of points and ranges per parameter. <br>\n",
+    "It also evaluates the QAOA circuit of the reference object with the same given points.\n",
+    "\n",
+    "It has two required positional arguments: `n_points_axis` and `ranges`. \n",
+    "- `n_points_axis`: The number of points per axis\n",
+    "- `ranges`: The sweep ranges of the parameters. The expected format is a list of tuples: (min, max) or (value,). One tuple per parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting the main plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 33 values\n",
+      "\tParameter 1: 0 to 1.57, with 33 values\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 650x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " \n",
+      "Running reference.\n",
+      "Point 1089 out of 1089. Expected remaining time to complete: 00:00:00, it will be finished at 03:03:28. \n",
+      "Plotting the reference plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 33 values\n",
+      "\tParameter 1: 0 to 1.57, with 33 values\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 650x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "benchmark.run(n_points_axis=2**5+1, ranges=[(0, 3.14/2), (0, 3.14/2)], plot=True, plot_every=100) \n",
+    "# with plot=True, the plot is shown every `plot_every` evaluated points and at the end of the execution"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Showing results"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After running we can plot the results and get the mean difference and the standard deviation of the difference between the benchmarked and the reference:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-0.5407383175835657"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "benchmark.difference_mean"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.3463625010931868"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "benchmark.difference_std"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting the main plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 33 values\n",
+      "\tParameter 1: 0 to 1.57, with 33 values\n",
+      "Plotting the reference plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 33 values\n",
+      "\tParameter 1: 0 to 1.57, with 33 values\n",
+      "Plotting the difference plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 33 values\n",
+      "\tParameter 1: 0 to 1.57, with 33 values\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 650x1500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "benchmark.plot(main=True, reference=True, difference=True, labels=['beta', 'gamma'])\n",
+    "# with main=True, the plot of the benchmarked points is shown\n",
+    "# with reference=True, the plot of the reference points is shown\n",
+    "# with difference=True, the plot of the difference between the benchmarked and the reference points is shown\n",
+    "# with labels=['beta', 'gamma'], the labels of the axes are set to 'beta' and 'gamma', if not specified, default labels are used"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To access the raw data of the benchmark, use the following attributes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0.274, -0.074,  0.052, ..., -0.336,  0.196, -0.042],\n",
+       "       [-0.026, -0.012, -0.48 , ...,  0.276,  0.148, -0.016],\n",
+       "       [-0.19 , -0.192, -0.344, ...,  0.492,  0.13 , -0.096],\n",
+       "       ...,\n",
+       "       [-0.04 , -0.122,  0.15 , ..., -0.012, -0.044,  0.19 ],\n",
+       "       [ 0.034,  0.05 , -0.056, ..., -0.054, -0.01 , -0.004],\n",
+       "       [-0.202,  0.168,  0.074, ..., -0.09 , -0.214,  0.018]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "benchmark.values # the values of the benchmarked points"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00, ...,\n",
+       "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00],\n",
+       "       [ 0.00000000e+00, -3.30596324e-01, -6.36201769e-01, ...,\n",
+       "         6.90397010e-01,  3.48489595e-01,  5.50253502e-03],\n",
+       "       [ 0.00000000e+00, -6.07268558e-01, -1.14705888e+00, ...,\n",
+       "         1.33292239e+00,  6.62233861e-01,  1.02865946e-02],\n",
+       "       ...,\n",
+       "       [ 0.00000000e+00, -1.32919377e-02, -3.59491490e-02, ...,\n",
+       "        -3.36256986e-03,  3.38913220e-03,  1.35164298e-04],\n",
+       "       [ 0.00000000e+00, -2.52121083e-03, -7.71505865e-03, ...,\n",
+       "        -3.32741998e-03, -2.75178585e-04,  1.81992750e-05],\n",
+       "       [ 0.00000000e+00, -3.69897000e-07, -1.45593300e-06, ...,\n",
+       "        -1.46058600e-06, -3.72279000e-07, -1.90000000e-11]])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "benchmark.values_reference # the values of the reference points"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0.274     , -0.074     ,  0.052     , ..., -0.336     ,\n",
+       "         0.196     , -0.042     ],\n",
+       "       [-0.026     ,  0.31859632,  0.15620177, ..., -0.41439701,\n",
+       "        -0.20048959, -0.02150254],\n",
+       "       [-0.19      ,  0.41526856,  0.80305888, ..., -0.84092239,\n",
+       "        -0.53223386, -0.10628659],\n",
+       "       ...,\n",
+       "       [-0.04      , -0.10870806,  0.18594915, ..., -0.00863743,\n",
+       "        -0.04738913,  0.18986484],\n",
+       "       [ 0.034     ,  0.05252121, -0.04828494, ..., -0.05067258,\n",
+       "        -0.00972482, -0.0040182 ],\n",
+       "       [-0.202     ,  0.16800037,  0.07400146, ..., -0.08999854,\n",
+       "        -0.21399963,  0.018     ]])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "benchmark.difference # the difference between the benchmarked and the reference points"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run 1D Benchmark"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One can also run the benchmark fixing the value of any parameter:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running benchmark.\n",
+      "Point 100 out of 100. Expected remaining time to complete: 00:00:00, it will be finished at 03:03:42. \n",
+      "Running reference.\n",
+      "Point 100 out of 100. Expected remaining time to complete: 00:00:00, it will be finished at 03:03:42. \n"
+     ]
+    }
+   ],
+   "source": [
+    "benchmark.run(n_points_axis=100, ranges=[(0, 3.14/2), (1,)])\n",
+    "# in this case the first parameter is swept from 0 to 3.14/2, while the second is fixed to 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting the main plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 100 values\n",
+      "\tParameter 1: 1\n",
+      "Plotting the reference plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 100 values\n",
+      "\tParameter 1: 1\n",
+      "Plotting the difference plot with the following parameters:\n",
+      "\tParameter 0: 0 to 1.57, with 100 values\n",
+      "\tParameter 1: 1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 650x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "benchmark.plot(main=True, reference=True, difference=True, labels=['beta', 'cost'], title=\"comparison\", one_plot=True)\n",
+    "# with one_plot=True, the three plots are shown in the same figure"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Benchmark with different circuit properties"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The same procedure can be applied to an object with circuit properties that are not the standard ones, for example: p=2 and param_type='extended'.\n",
+    "\n",
+    "However, for this properties the `analytical_simulator` backend is not available, so the `vectorized` backend is used instead for the reference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create the QAOA object\n",
+    "q2 = QAOA()\n",
+    "\n",
+    "# set device and backend properties\n",
+    "q2.set_device(qiskit_cloud)\n",
+    "q2.set_backend_properties(n_shots=1000)\n",
+    "\n",
+    "# set properties\n",
+    "q2.set_circuit_properties(p=2, param_type='extended')\n",
+    "\n",
+    "# compile with the problem\n",
+    "q2.compile(MaximumCut.random_instance(n_nodes=3, edge_probability=0.9, seed=10).qubo) #use a smaller problem to speed up the example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Warning: vectorized simulator will be used for the reference, since the analytical simulator is not available for the circuit properties of the benchmarked QAOA object\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create the new QAOABenchmark object, in this case the reference will use the vectorized simulator not the analytical one\n",
+    "benchmark2 = QAOABenchmark(q2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running benchmark.\n",
+      "Point 1089 out of 1089. Expected remaining time to complete: 00:00:00, it will be finished at 03:05:02. \n",
+      "Running reference.\n",
+      "Point 1089 out of 1089. Expected remaining time to complete: 00:00:00, it will be finished at 03:05:03. \n"
+     ]
+    }
+   ],
+   "source": [
+    "benchmark2.run(n_points_axis=2**5+1, ranges=[(1,), (1,), (1,), (0, 3.14), (1,), (1,), (-3.14, 3.14), (1,), (1,), (1,), (1,), (1,)]) \n",
+    "# see that the ranges are now 12-dimensional, one tuple is needed for each parameter. \n",
+    "# in this case, we are fixing 10 parameters, and sweeping the other two\n",
+    "# one can sweep more than "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 650x1500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "benchmark2.plot(main=True, reference=True, difference=True, verbose=False, title=['benchmarked', 'analytical', 'difference'],) "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Compare different QPUs or simulators"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this section we will show how one can compare the performance of two different QPUs or simulators.\n",
+    "\n",
+    "For that we will follow the same steps as before. Now, we will define two different QAOA objects (one for each QPU to compare) and the respective QAOABenchmark objects, and then ploting the values together.\n",
+    "\n",
+    "Here we will compare the IBM QPU with a shot-based simulator:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# we start defining the QAOA object for the ibm qpu:\n",
+    "\n",
+    "# create the QAOA object\n",
+    "q_ibm = QAOA()\n",
+    "\n",
+    "# set device and backend properties\n",
+    "qiskit_cloud = create_device(location='ibmq', name='ibm_oslo', **qpu_credentials, as_emulator=True)\n",
+    "q_ibm.set_device(qiskit_cloud)\n",
+    "q_ibm.set_backend_properties(n_shots=1000)\n",
+    "\n",
+    "# set properties\n",
+    "q_ibm.set_circuit_properties(p=1, param_type='standard')\n",
+    "\n",
+    "# compile with the problem\n",
+    "q_ibm.compile(qubo)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# now, we define the QAOA object for the shot-based simulator:\n",
+    "\n",
+    "# create the QAOA object\n",
+    "q_simulator = QAOA()\n",
+    "\n",
+    "# set device and backend properties\n",
+    "qiskit_simulator = create_device(location='local', name='qiskit.shot_simulator')\n",
+    "q_simulator.set_device(qiskit_simulator)\n",
+    "q_simulator.set_backend_properties(n_shots=1000)\n",
+    "\n",
+    "# set properties\n",
+    "q_simulator.set_circuit_properties(p=1, param_type='standard')\n",
+    "\n",
+    "# compile with the problem\n",
+    "q_simulator.compile(qubo)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running benchmark.\n",
+      "Point 100 out of 100. Expected remaining time to complete: 00:00:00, it will be finished at 03:05:21. \n",
+      "Running reference.\n",
+      "Point 100 out of 100. Expected remaining time to complete: 00:00:00, it will be finished at 03:05:21. \n",
+      "Running benchmark.\n",
+      "Point 100 out of 100. Expected remaining time to complete: 00:00:00, it will be finished at 03:05:23. \n"
+     ]
+    }
+   ],
+   "source": [
+    "# next step is to create the QAOABenchmark objects\n",
+    "\n",
+    "benchmark_ibm = QAOABenchmark(q_ibm)\n",
+    "benchmark_simulator = QAOABenchmark(q_simulator)\n",
+    "\n",
+    "# now we can run the benchmarks\n",
+    "benchmark_ibm.run(n_points_axis=100, ranges=[(3.14/4,), (0, 3.14/2)], plot=False)\n",
+    "benchmark_simulator.run(n_points_axis=100, ranges=[(3.14/4,), (0, 3.14/2)], plot=False, run_reference=False) #here we set reference=False because the reference is the same as in the ibm case"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# last step is to plot the results\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "fig, ax = plt.subplots()\n",
+    "benchmark_ibm.plot(main=True, reference=True, difference=False, ax=ax, labels_legend=['ibm', 'reference'], verbose=False)\n",
+    "benchmark_simulator.plot(main=True, reference=False, difference=False, ax=ax, labels_legend='simulator', verbose=False)\n",
+    "ax.legend()\n",
+    "ax.set_title('comparison QPU vs. simulator')\n",
+    "ax.set_ylabel('cost')\n",
+    "ax.set_xlabel('gamma')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "OQ",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "2374e833df7d90fe0779e245413a800a00448ba720136fdc7edf28b169de91eb"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/openqaoa-core/__init__.py b/src/openqaoa-core/__init__.py
index 6eee62d87..4db56ed3a 100644
--- a/src/openqaoa-core/__init__.py
+++ b/src/openqaoa-core/__init__.py
@@ -1,3 +1,3 @@
-from .algorithms import QAOA, RQAOA
+from .algorithms import QAOA, RQAOA, QAOABenchmark
 from .problems import QUBO
 from .backends import create_device
diff --git a/src/openqaoa-core/algorithms/__init__.py b/src/openqaoa-core/algorithms/__init__.py
index 3b4557928..069c4fd75 100644
--- a/src/openqaoa-core/algorithms/__init__.py
+++ b/src/openqaoa-core/algorithms/__init__.py
@@ -1,3 +1,3 @@
-from .qaoa import QAOA, QAOAResult
+from .qaoa import QAOA, QAOAResult, QAOABenchmark
 from .rqaoa import RQAOA, RQAOAResult
 from .jobs.managed_job import AWSJobs
diff --git a/src/openqaoa-core/algorithms/baseworkflow.py b/src/openqaoa-core/algorithms/baseworkflow.py
index 702e0477e..15eb2dd16 100644
--- a/src/openqaoa-core/algorithms/baseworkflow.py
+++ b/src/openqaoa-core/algorithms/baseworkflow.py
@@ -27,12 +27,16 @@
     DEVICE_ACCESS_OBJECT_MAPPER,
 )
 
+
 def check_compiled(func):
     def wrapper(self, *args, **kwargs):
         result = func(self, *args, **kwargs)
         if self.compiled:
-            raise ValueError("Cannot change properties of the object after compilation.")
+            raise ValueError(
+                "Cannot change properties of the object after compilation."
+            )
         return result
+
     return wrapper
 
 
@@ -533,11 +537,17 @@ def dump(
 
         options = {**options, **{"complex_to_string": True}}
 
-        project_id = self.header["project_id"] if not self.header["project_id"] is None else "None"
+        project_id = (
+            self.header["project_id"]
+            if not self.header["project_id"] is None
+            else "None"
+        )
 
         # get the full name
         if prepend_id == False and file_name == "":
-            raise ValueError("dump method missing argument: 'file_name'. Otherwise 'prepend_id' must be specified as True.")
+            raise ValueError(
+                "dump method missing argument: 'file_name'. Otherwise 'prepend_id' must be specified as True."
+            )
         elif prepend_id == False:
             file = file_path + file_name
         elif file_name == "":
diff --git a/src/openqaoa-core/algorithms/qaoa/__init__.py b/src/openqaoa-core/algorithms/qaoa/__init__.py
index 435b000b4..7b5ba4677 100644
--- a/src/openqaoa-core/algorithms/qaoa/__init__.py
+++ b/src/openqaoa-core/algorithms/qaoa/__init__.py
@@ -1,2 +1,3 @@
 from .qaoa_workflow import QAOA
 from .qaoa_result import QAOAResult
+from .qaoa_benchmark import QAOABenchmark
diff --git a/src/openqaoa-core/algorithms/qaoa/qaoa_benchmark.py b/src/openqaoa-core/algorithms/qaoa/qaoa_benchmark.py
new file mode 100644
index 000000000..f99d12a42
--- /dev/null
+++ b/src/openqaoa-core/algorithms/qaoa/qaoa_benchmark.py
@@ -0,0 +1,656 @@
+import numpy as np
+from math import log2
+from random import shuffle
+from typing import List, Union
+from matplotlib import pyplot as plt
+from copy import deepcopy
+from IPython.display import clear_output
+import time
+
+from . import QAOA
+from ...backends import create_device
+
+
+class QAOABenchmark:
+    """
+    Benchmark is a class that implements benchmarking for QAOA.
+
+    Attributes
+    ----------
+    qaoa : QAOA
+        The QAOA object to be benchmarked.
+    reference : QAOA
+        The reference QAOA object, which will be used to compare the results of the benchmarked QAOA object.
+    ranges : List[tuple]
+        The ranges of the variate parameters of the benchmarked QAOA object.
+    ranges_reference : List[tuple]
+        The ranges of the variate parameters of the reference QAOA object.
+    values : np.ndarray
+        The values of the benchmarked QAOA object.
+    values_reference : np.ndarray
+        The values of the reference QAOA object.
+    difference : np.ndarray
+        The difference between the values of the benchmarked QAOA object and the values of the reference QAOA object.
+    difference_mean : float
+        The mean of the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object.
+    """
+
+    def __init__(self, qaoa: QAOA):
+        """
+        Constructor for the Benchmark class.
+
+        Parameters
+        ----------
+        qaoa : QAOA
+            The QAOA object to be benchmarked.
+        """
+        # check if the QAOA object inputted is valid and save it
+        assert isinstance(qaoa, QAOA), "`qaoa` must be an instance of QAOA"
+        assert qaoa.compiled, "`qaoa` must be compiled before benchmarking"
+        self.qaoa = qaoa
+
+        # create a reference QAOA object, which will be used to compare the results of the benchmarked QAOA object
+        self.reference = QAOA()
+        self.reference.circuit_properties = (
+            self.qaoa.circuit_properties
+        )  # copy the circuit properties of the benchmarked QAOA object
+        try:
+            self.reference.set_device(
+                create_device(location="local", name="analytical_simulator")
+            )
+            self.reference.compile(self.qaoa.problem)
+        except:
+            self.reference.set_device(
+                create_device(location="local", name="vectorized")
+            )
+            self.reference.compile(self.qaoa.problem)
+            print(
+                "Warning: vectorized simulator will be used for the reference, since the analytical simulator is not available for the circuit properties of the benchmarked QAOA object"
+            )
+
+        # initialize values and ranges
+        self.values = None
+        self.values_reference = None
+        self.ranges = None
+        self.ranges_reference = None
+
+    @property
+    def difference(self):
+        "The difference between the values of the benchmarked QAOA object and the values of the reference QAOA object."
+        if self.values is None:
+            raise Exception(
+                "You must run the benchmark before calculating the difference"
+            )
+        if self.values_reference is None:
+            raise Exception(
+                "You must run the reference before calculating the difference"
+            )
+        if self.values.shape != self.values_reference.shape:
+            raise Exception(
+                "The ranges and number of points of the values and reference values must be the same"
+            )
+        return self.values - self.values_reference
+
+    @property
+    def difference_mean(self):
+        "The mean of the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object."
+        return np.mean(self.difference)
+
+    @property
+    def difference_std(self):
+        "The standard deviation of the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object."
+        return np.std(self.difference)
+
+    def __assert_run_inputs(
+        self,
+        n_points_axis: int,
+        ranges: List[tuple],
+        run_main: bool,
+        run_reference: bool,
+        plot: bool,
+        plot_difference: bool,
+        plot_options: dict,
+        verbose: bool,
+    ):
+        "Private method that checks the inputs of the run (and run_reference) method."
+        assert isinstance(
+            n_points_axis, int
+        ), "The number of points per axis must be an integer"
+        assert (
+            isinstance(ranges, list) or ranges is None
+        ), "The ranges argument must be a list of tuples: (min, max) or (value,)"
+        assert len(ranges) == len(
+            self.qaoa.variate_params
+        ), "The number of ranges must be equal to the number of variate parameters, which is {}".format(
+            len(self.qaoa.variate_params)
+        )
+        assert all(
+            [isinstance(r, tuple) or isinstance(r, list) for r in ranges]
+        ), "Each range must be a tuple: (min, max) or (value,)"
+        assert all(
+            [len(r) == 1 or len(r) == 2 for r in ranges]
+        ), "Each range must be a tuple of length 1 or 2: (min, max) or (value,)"
+        assert (
+            len([r for r in ranges if len(r) == 2]) > 0
+        ), "At least one range must be a tuple of length 2: (min, max)"
+        for bools in [
+            "run_main",
+            "run_reference",
+            "plot",
+            "plot_difference",
+            "verbose",
+        ]:
+            assert isinstance(
+                eval(bools), bool
+            ), "The {} argument must be a boolean".format(bools)
+        assert (
+            run_main or run_reference
+        ), "You must run the main or the reference or both"
+        assert isinstance(
+            plot_options, dict
+        ), "The plot_options argument must be a dictionary"
+
+    def __print_expected_time(self, k, n_points):
+        "Private method that prints the expected remaining time to complete the benchmark."
+        print("\rPoint {} out of {}.".format(k + 1, n_points), end="")
+        if k == 0:
+            self.__start_time = time.time()
+        elif k > 0:
+            expected_time = (time.time() - self.__start_time) * (n_points - k) / k
+            print(
+                " Expected remaining time to complete: {}, it will be finished at {}.".format(
+                    time.strftime("%H:%M:%S", time.localtime(expected_time)),
+                    time.strftime(
+                        "%H:%M:%S", time.localtime(time.time() + expected_time)
+                    ),
+                ),
+                end="",
+            )
+
+    def run(
+        self,
+        n_points_axis,
+        ranges: List[tuple],
+        run_main: bool = True,
+        run_reference: bool = True,
+        plot: bool = False,
+        plot_every: int = 1000,
+        plot_difference: bool = False,
+        plot_options: dict = {},
+        verbose: bool = True,
+    ):
+        """
+        Evaluates the QAOA circuit of the benchmarked (and the reference) QAOA object for a given number of points per axis and ranges.
+
+        Parameters
+        ----------
+        n_points_axis : int
+            The number of points per axis. It is recommended to use a number that is a power of 2 + 1: 2**k+1 (where, k is an integer).
+            Using this number will ensure that the points evaluated are ordered such that there are k rounds, each round covers the whole range,
+            and each round has the double number of points (per axis) of the previous round.
+        ranges : List[tuple]
+            The sweep ranges of the parameters. The expected format is a list of tuples: (min, max) or (value,). One tuple per parameter.
+            If the length of the tuple is 1, the parameter will be fixed to the value of the tuple.
+            If the length of the tuple is 2, the parameter will be swept from the first value of the tuple to the second value of the tuple.
+        run_main : bool, optional
+            If True, the benchmarked QAOA object will be evaluated for the requested points.
+            The default is True.
+        run_reference : bool, optional
+            If True, the reference QAOA object will be evaluated for the same points.
+            The default is True.
+        plot : bool, optional
+            If True, the values will be plotted.
+            The default is False.
+        plot_every : int, optional
+            The number of evaluations after which the plot will be updated.
+            The default is 1000.
+        plot_difference : bool, optional
+            If True, the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object will be plotted.
+            The default is False.
+        plot_options : dict, optional
+            The options for the plot. The expected format is a dictionary with the keys of the plot method of this class.
+            The default is {}.
+        verbose : bool, optional
+            If True, the expected remaining time to complete the benchmark will be printed.
+            The default is True.
+        """
+
+        # check the inputs
+        self.__assert_run_inputs(
+            n_points_axis,
+            ranges,
+            run_main,
+            run_reference,
+            plot,
+            plot_difference,
+            plot_options,
+            verbose,
+        )
+
+        # plot options
+        plot_options = {**{"verbose": verbose}, **plot_options}
+
+        # save the ranges
+        if run_main:
+            self.ranges = ranges
+        if run_reference:
+            self.ranges_reference = ranges
+
+        # get only the ranges that will be swept, and the number of parameters swept
+        ranges_to_use = [r for r in ranges if len(r) == 2]
+        n_params = len(ranges_to_use)
+
+        # prepare the axes of the grid
+        axes = [
+            np.linspace(r[0], r[1], n_points_axis) for r in ranges_to_use
+        ]  # the starting and ending points are given by the ranges and the number of points is given by n_points_axis
+
+        # function that given the values used for the parameters swept, returns the values of all the parameters in order
+        params = lambda new_params: [
+            r[0] if len(r) == 1 else new_params.pop(0) for r in ranges
+        ]
+
+        # copy the parameters object, which will be updated before each evaluation
+        params_obj = deepcopy(self.qaoa.variate_params)
+
+        # initialize the array that will contain the values of the benchmarked QAOA object
+        if run_main:
+            self.values = np.zeros([n_points_axis for _ in range(n_params)])
+        if run_reference:
+            self.values_reference = np.zeros([n_points_axis for _ in range(n_params)])
+
+        # initialize the arrays that will contain the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object
+        both_qaoa = [
+            qaoa
+            for qaoa, boolean in zip(
+                [self.qaoa, self.reference], [run_main, run_reference]
+            )
+            if boolean
+        ]
+        both_values = [
+            values
+            for values, boolean in zip(
+                [self.values, self.values_reference], [run_main, run_reference]
+            )
+            if boolean
+        ]
+        both_strings = [
+            string
+            for string, boolean in zip(
+                ["benchmark", "reference"], [run_main, run_reference]
+            )
+            if boolean
+        ]
+
+        # loop over the benchmarked QAOA object and the reference QAOA object (if requested)
+        for qaoa, values, string in zip(both_qaoa, both_values, both_strings):
+
+            if verbose:
+                print(f"Running {string}.")
+
+            # evaluate all the points in the grid, in the order provided by the function __ordered_points. We loop over the indices of the grid.
+            for k, i_point in enumerate(self.__ordered_points(n_params, n_points_axis)):
+
+                if verbose:
+                    self.__print_expected_time(
+                        k, n_points_axis**n_params
+                    )  # print the expected remaining time, info for the user
+
+                new_params = [
+                    axis[i] for axis, i in zip(axes, i_point)
+                ]  # from the indices of the grid, get the values of the parameters that will be evaluated
+                params_obj.update_from_raw(params(new_params))
+                values[tuple(i_point[::-1])] = qaoa.backend.expectation(params_obj)
+
+                # plot every 'plot_every' points and at the end
+                if (
+                    (
+                        (k % plot_every == 0 and k > 0)
+                        or k + 1 == n_points_axis**n_params
+                    )
+                    and plot
+                    and string == "benchmark"
+                ):
+                    clear_output(wait=True)
+
+                    if (not k + 1 == n_points_axis**n_params) and n_params == 1:
+                        plot_opt = {"marker": "o", "linestyle": "", "markersize": 3}
+                    else:
+                        plot_opt = {}
+                    self.plot(plot_options=plot_opt, **plot_options)
+
+            if verbose:
+                print(
+                    " "
+                )  # print a blank line, necessary because previous print: end=""
+
+        # plot the reference if requested
+        if plot and run_reference:
+            self.plot(main=False, reference=True, difference=False, **plot_options)
+
+        # plot the difference if requested and the reference has been run
+        if plot_difference:
+            try:
+                self.plot(main=False, reference=False, difference=True, **plot_options)
+            except:
+                print(
+                    "The difference cannot be plotted because the reference has not been run."
+                )
+
+    def plot(
+        self,
+        ax: plt.Axes = None,
+        title: Union[str, List[str]] = None,
+        labels: List[str] = None,
+        labels_legend: Union[str, List[str]] = None,
+        main: bool = True,
+        reference: bool = False,
+        difference: bool = False,
+        one_plot: bool = False,
+        # params_to_plot:List[int] = None, TODO: difficult because you need to specify the values of the other parameters
+        plot_options: dict = {},
+        verbose: bool = True,
+    ):
+        """
+        Plots the values of the benchmarked QAOA object and/or the values of the reference QAOA
+          object and/or the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object.
+
+        Parameters
+        ----------
+        ax : plt.Axes, optional
+            The matplotlib Axes object to plot on. If None, a new figure will be created.
+            The default is None.
+        title : Union[str, List[str]], optional
+            The title of the plot. The expected format is a string or a list of strings: one for each plot.
+            If None, the title will be the default: `main plot`, `reference plot` or `difference plot`.
+            The default is None.
+        labels : List[str], optional
+            The labels of the axes. The expected format is a list of two strings: one for each axis.
+            If None, the labels will be the number of the parameters.
+            The default is None.
+        labels_legend : Union[str, List[str]], optional
+            The labels of the legend. The expected format is a string or a list of strings: one for each line.
+            It is only available if the sweep is over just one parameter, and if `one_plot` is True or `ax` is not None.
+            If None, the labels will be the default: `main`, `reference` or `difference`.
+            The default is None.
+        main : bool, optional
+            If True, the values of the benchmarked QAOA object will be plotted.
+            The default is True.
+        reference : bool, optional
+            If True, the values of the reference QAOA object will be plotted.
+            The default is False.
+        difference : bool, optional
+            If True, the difference between the values of the benchmarked QAOA object and the values of the reference QAOA object will be plotted.
+            The default is False.
+        one_plot : bool, optional
+            If True, the values of the benchmarked QAOA object,
+            the values of the reference QAOA object and the difference between the values of the benchmarked QAOA object
+            and the values of the reference QAOA object will be plotted in the same plot.
+            It is not available if the sweep is over more than one parameter.
+            The default is False.
+        plot_options : dict, optional
+            The options for the plot (plt.plot for one parameter, plt.pcolorfast for two parameters).
+        """
+
+        # check the inputs
+        assert (
+            isinstance(ax, plt.Axes) or ax is None
+        ), "ax must be a matplotlib Axes or None"
+        assert (
+            isinstance(labels, list) or labels is None
+        ), "labels must be a list of two strings or None"
+        assert (
+            all([isinstance(label, str) for label in labels])
+            if labels is not None
+            else True
+        ), "labels must be a list of two strings or None"
+        assert (
+            len(labels) == 2 if labels is not None else True
+        ), "labels must be a list of two strings, one for each axis"
+        for plot in ["main", "reference", "difference"]:
+            assert isinstance(eval(plot), bool), plot + " must be a boolean"
+        assert (
+            main or reference or difference
+        ), "You must specify at least one of the main, reference or difference plots"
+        assert isinstance(plot_options, dict), "plot_options must be a dictionary"
+
+        # if labels_legend is not a list or tuple, make it a list
+        if not isinstance(labels_legend, (list, tuple)):
+            labels_legend = [labels_legend for _ in range(3)]
+
+        # create a dictionary where the keys are the three possible plots and the values are a tuple
+        # with the boolean (which says if the plot is requested) and the values to plot
+        values = {
+            "main": (main, self.values if main else None),
+            "reference": (reference, self.values_reference if reference else None),
+            "difference": (difference, self.difference if difference else None),
+        }
+
+        # create the figure and axes if the axis are not provided
+        ax_input = ax  # save the input axis
+        nrows = 1
+        if ax_input is None:
+            nrows = (
+                1 if one_plot else sum([1 if values[key][0] else 0 for key in values])
+            )
+            fig, ax = plt.subplots(nrows=nrows, ncols=1, figsize=(6.5, 5 * nrows))
+
+        # plot the requested plots
+        count_sp = 0  # counter of subplots
+        for key in values:
+            if values[key][0]:  # skip the plot if it is not requested
+
+                # raise an exception if the values for a plo requested are not available
+                if values[key][1] is None:
+                    raise Exception(
+                        "You must run the benchmark before plotting the results, there are no values for the "
+                        + key
+                        + " plot"
+                    )
+
+                # get the ranges to use, use the reference ranges if the key is "reference", otherwise use the main ranges
+                ranges = self.ranges if key != "reference" else self.ranges_reference
+                ranges_to_use = [r for r in ranges if len(r) == 2]
+                n_params = len(ranges_to_use)
+
+                # create the axes, the range is provided by the ranges_to_use and the number of values is provided by the values[key][1].shape
+                axes = [
+                    np.linspace(r[0], r[1], values[key][1].shape[i])
+                    for i, r in enumerate(ranges_to_use)
+                ]
+
+                # skip the plot if there are more than two parameters to plot, and print a warning
+                if n_params > 2:
+                    print(
+                        "Only 1 or 2 parameters can be plotted using this method. You are trying to plot "
+                        + str(n_params)
+                        + " parameters. You can use the argument params_to_plot to specify which parameters to plot."
+                    )
+                    break
+                # if verbose, print the parameters used for the plot
+                elif verbose:
+                    print(
+                        "Plotting the " + key + " plot with the following parameters:"
+                    )
+                    for i, r in enumerate(ranges):
+                        if len(r) == 2:
+                            print(
+                                "\tParameter "
+                                + str(i)
+                                + ": "
+                                + str(r[0])
+                                + " to "
+                                + str(r[1])
+                                + ", with "
+                                + str(values[key][1].shape[i])
+                                + " values"
+                            )
+                        else:
+                            print("\tParameter " + str(i) + ": " + str(r[0]))
+
+                ## plot the values
+
+                # if we are plotting only one plot, use the same axes, otherwise different axes for each subplot
+                axis = ax if nrows == 1 else ax[count_sp]
+
+                # set the labels and plot the values
+                if n_params == 1:
+                    axis.set_xlabel(
+                        "Parameter {}".format(
+                            [i for i, r in enumerate(ranges) if len(r) == 2][0]
+                        )
+                    )
+                    axis.set_ylabel("Expectation value")
+
+                    label_legend = (
+                        labels_legend[count_sp]
+                        if labels_legend[count_sp] is not None
+                        else key
+                    )
+                    axis.plot(*axes, values[key][1], label=label_legend, **plot_options)
+                else:
+                    if one_plot:
+                        raise Exception(
+                            "For two parameters, you must specify one_plot=False"
+                        )
+
+                    axis.set_xlabel(
+                        "Parameter {}".format(
+                            [i for i, r in enumerate(ranges) if len(r) == 2][0]
+                        )
+                    )
+                    axis.set_ylabel(
+                        "Parameter {}".format(
+                            [i for i, r in enumerate(ranges) if len(r) == 2][1]
+                        )
+                    )
+                    plot = axis.pcolorfast(*axes, values[key][1], **plot_options)
+                    _ = plt.colorbar(plot)
+
+                # set the title
+                if not one_plot and title is None:
+                    axis.set_title(key + " plot")
+                elif not title is None:
+                    if not isinstance(title, list) and not isinstance(title, tuple):
+                        axis.set_title(title)
+                    else:
+                        if len(title) < nrows:
+                            raise Exception(
+                                "If title is a list or tuple, it must have the same length as the number of plots"
+                            )
+                        axis.set_title(title[count_sp])
+
+                # replace the labels if specified
+                if labels is not None:
+                    axis.set_xlabel(labels[0])
+                    axis.set_ylabel(labels[1])
+
+                # increase the counter for the axes
+                count_sp += 1
+
+        # add legend if one_plot
+        if one_plot:
+            ax.legend()
+
+        # show the figure if the axis were not provided
+        if ax_input is None:
+            if nrows > 1:
+                fig.subplots_adjust(hspace=0.3)  # add some space between the subplots
+            plt.show()
+            plt.close(fig)
+
+    @staticmethod
+    def __ordered_points(n_params, n_points_axis):
+        """
+        This method creates a grid of points for each parameter, and then creates all the combinations of these points.
+        The points are ordered such that we evaluate the grid by rounds, the first round the resolution is very low,
+        next rounds the resolution is higher,
+        and also, every n_points = 2**n_params one point is used at each round, and the points are shuffled.
+
+        It works very well for n_points_axis = 2**k + 1 (where k is any integer), but it also works for other values.
+
+        Parameters
+        ----------
+        n_params : int
+            The number of parameters to sweep.
+        n_points_axis : int
+            The number of points per axis.
+
+        Returns
+        -------
+        points : list
+            The list of points to evaluate in order.
+        """
+
+        assert (
+            isinstance(n_params, int) and n_params > 0
+        ), "The number of parameters must be an integer, and greater than 0"
+        assert (
+            isinstance(n_points_axis, int) and n_points_axis > 3
+        ), "The number of points per axis must be an integer, and greater than 3"
+
+        ## we create a grid of points for each axis
+        axis_points = list(range(n_points_axis))
+
+        ## first we create all the points to evaluate and we order them such that every n_points = 2**n_params one point is used at each round, and the points are shuffled
+
+        # we separate the points in two lists, [0, 2, 4, ...] and [1, 3, 5, ...]
+        axis_points_separated = (
+            [[i] for i in axis_points[::2]],
+            [[i] for i in axis_points[1::2]],
+        )
+
+        # we create a list of lists, where each list will tell how to combine the two lists of points to create the points for each round
+        zero_one = [[0], [1]]
+        order_list = zero_one
+        for _ in range(n_params - 1):
+            order_list = [order + y for order in order_list for y in zero_one]
+
+        # the variable points will be a list of lists, where each list is a round of points to evaluate
+        points = [
+            axis_points_separated[order[0]] for order in order_list
+        ]  # we start with the first axis
+
+        # we create the points for each round by combining the points of the previous round with the points of the next axis
+        for k in range(1, n_params):
+            for x in range(len(points)):
+                points[x] = [
+                    point_i + point_j
+                    for point_i in points[x]
+                    for point_j in axis_points_separated[order_list[x][k]]
+                ]
+
+        # we shuffle the points at each round
+        for i in range(len(points)):
+            shuffle(points[i])
+
+        # the final list of points to evaluate is a concatenation of all the rounds
+        ordered_points = []
+        for round in range(len(points)):
+            ordered_points += points[round]
+
+        ## then we reorder the points such that the first round we have a grid of points with very low resolution, and then at each round we increase the resolution
+        values = np.zeros([n_points_axis for _ in range(n_params)])
+
+        used_axis_points = []
+        reordered_points = []
+        for round in range(1, int(log2(len(axis_points) - 1)) + 1):
+            new = [
+                k
+                for k in axis_points[:: (len(axis_points) - 1) // 2**round]
+                if k not in used_axis_points
+            ]
+            used_axis_points += new
+
+            points_ = ordered_points.copy()
+            for point in ordered_points:
+                if (
+                    all([i in used_axis_points for i in point])
+                    and values[tuple(point)] == 0
+                ):
+                    values[tuple(point)] = round
+                    reordered_points.append(points_.pop(points_.index(point)))
+
+            ordered_points = points_  # there are less points now
+
+        return reordered_points
diff --git a/src/openqaoa-core/algorithms/qaoa/qaoa_workflow.py b/src/openqaoa-core/algorithms/qaoa/qaoa_workflow.py
index 4d86be5d7..73a0173d4 100644
--- a/src/openqaoa-core/algorithms/qaoa/qaoa_workflow.py
+++ b/src/openqaoa-core/algorithms/qaoa/qaoa_workflow.py
@@ -1,8 +1,13 @@
-from typing import List, Callable, Optional
-import requests
+from typing import List, Callable, Optional, Union, Dict
+from copy import deepcopy
+import numpy as np
+
 from .qaoa_result import QAOAResult
 from ..workflow_properties import CircuitProperties
 from ..baseworkflow import Workflow, check_compiled
+from ...backends.basebackend import QAOABaseBackendStatevector
+from ...backends import QAOABackendAnalyticalSimulator
+from ...backends.cost_function import cost_function
 from ...backends.devices_core import DeviceLocal, DeviceBase
 from ...backends.qaoa_backend import get_qaoa_backend
 from ...problems import QUBO
@@ -11,6 +16,9 @@
     QAOADescriptor,
     create_qaoa_variational_params,
 )
+from ...qaoa_components.variational_parameters.variational_baseparams import (
+    QAOAVariationalBaseParams,
+)
 from ...utilities import get_mixer_hamiltonian, generate_timestamp
 from ...optimizers.qaoa_optimizer import get_optimizer
 
@@ -305,6 +313,101 @@ def optimize(self, verbose=False):
             print(f"optimization completed.")
         return
 
+    def evaluate_circuit(
+        self,
+        params: Union[List[float], Dict[str, List[float]], QAOAVariationalBaseParams],
+    ):
+        """
+        A method to evaluate the QAOA circuit at a given set of parameters
+
+        Parameters
+        ----------
+        params: list or dict or QAOAVariationalBaseParams or None
+            List of parameters or dictionary of parameters. Which will be used to evaluate the QAOA circuit.
+            If None, the variational parameters of the QAOA object will be used.
+
+        Returns
+        -------
+        result: dict
+            A dictionary containing the results of the evaluation:
+            - "expectation": the expectation value of the cost Hamiltonian
+            - "uncertainty": the uncertainty of the expectation value of the cost Hamiltonian
+            - "measurement_results": either the state of the QAOA circuit output (if the QAOA circuit is
+            evaluated on a state simulator) or the counts of the QAOA circuit output
+            (if the QAOA circuit is evaluated on a QPU or shot-based simulator)
+        """
+
+        # before evaluating the circuit we check that the QAOA object has been compiled
+        if self.compiled == False:
+            raise ValueError("Please compile the QAOA before optimizing it!")
+
+        ## Check the type of the input parameters and save them as a QAOAVariationalBaseParams object at the variable `params_obj`
+
+        # if the parameters are passed as a dictionary we copy and update the variational parameters of the QAOA object
+        if isinstance(params, dict):
+            params_obj = deepcopy(self.variate_params)
+            # we check that the dictionary contains all the parameters of the QAOA object that are not empty
+            for key, value in params_obj.asdict().items():
+                if value.size > 0:
+                    assert (
+                        key in params.keys()
+                    ), f"The parameter `{key}` is missing from the input dictionary"
+            params_obj.update_from_dict(params)
+
+        # if the parameters are passed as a list we copy and update the variational parameters of the QAOA object
+        elif isinstance(params, list) or isinstance(params, np.ndarray):
+            assert len(params) == len(
+                self.variate_params
+            ), "The number of parameters does not match the number of parameters in the QAOA circuit"
+            params_obj = deepcopy(self.variate_params)
+            params_obj.update_from_raw(params)
+
+        # if the parameters are passed as a QAOAVariationalBaseParams object we just take it as it is
+        elif isinstance(params, QAOAVariationalBaseParams):
+            # check whether the input params object is supported for circuit evaluation
+            assert (
+                len(self.variate_params.mixer_1q_angles) == len(params.mixer_1q_angles)
+                and len(self.variate_params.mixer_2q_angles)
+                == len(self.variate_params.mixer_2q_angles)
+                and len(self.variate_params.cost_1q_angles)
+                == len(self.variate_params.cost_1q_angles)
+                and len(self.variate_params.cost_2q_angles)
+                == len(self.variate_params.cost_2q_angles)
+            ), "Specify a supported params object"
+            params_obj = params
+
+        # if the parameters are passed in a different format, we raise an error
+        else:
+            raise TypeError(
+                f"The input params must be a list or a dictionary. Instead, received {type(params)}"
+            )
+
+        ## Evaluate the QAOA circuit and return the results
+        output_dict = {
+            "cost": None,
+            "uncertainty": None,
+            "measurement_results": None,
+        }
+        # if the backend is the analytical simulator, we just return the expectation value of the cost Hamiltonian
+        if isinstance(self.backend, QAOABackendAnalyticalSimulator):
+            output_dict.update({"cost": self.backend.expectation(params_obj)[0]})
+
+        else:
+            cost, uncertainty = self.backend.expectation_w_uncertainty(params_obj)
+            measurement_results = (
+                self.backend.measurement_outcomes
+                if isinstance(self.backend.measurement_outcomes, dict)
+                else self.backend.measurement_outcomes.tolist()
+            )
+            output_dict.update(
+                {
+                    "cost": cost,
+                    "uncertainty": uncertainty,
+                    "measurement_results": measurement_results,
+                }
+            )
+        return output_dict
+
     def _serializable_dict(
         self, complex_to_string: bool = False, intermediate_mesurements: bool = True
     ):
diff --git a/src/openqaoa-core/backends/qaoa_device.py b/src/openqaoa-core/backends/qaoa_device.py
index eb49640bb..2b27aa453 100644
--- a/src/openqaoa-core/backends/qaoa_device.py
+++ b/src/openqaoa-core/backends/qaoa_device.py
@@ -6,6 +6,7 @@
 from openqaoa_pyquil.backends import DevicePyquil
 from openqaoa_azure.backends import DeviceAzure
 
+
 def device_class_arg_mapper(
     device_class: DeviceBase,
     hub: str = None,
@@ -56,6 +57,7 @@ def device_class_arg_mapper(
     }
     return final_device_kwargs
 
+
 LOCATION_MAPPER = {
     "ibmq": DeviceQiskit,
     "qcs": DevicePyquil,
@@ -64,6 +66,7 @@ def device_class_arg_mapper(
     "azure": DeviceAzure,
 }
 
+
 def create_device(location: str, name: str, **kwargs):
     """
     This function returns an instance of the appropriate device class.
@@ -85,8 +88,10 @@ def create_device(location: str, name: str, **kwargs):
     """
     location = location.lower()
     if location not in LOCATION_MAPPER:
-        raise ValueError(f"Invalid device location, Choose from: {list(LOCATION_MAPPER.keys())}")
-    
+        raise ValueError(
+            f"Invalid device location, Choose from: {list(LOCATION_MAPPER.keys())}"
+        )
+
     device_class = LOCATION_MAPPER[location]
 
     return device_class(device_name=name, **kwargs)
diff --git a/src/openqaoa-core/backends/qaoa_vectorized.py b/src/openqaoa-core/backends/qaoa_vectorized.py
index 7ee3207bf..7cf6683a6 100644
--- a/src/openqaoa-core/backends/qaoa_vectorized.py
+++ b/src/openqaoa-core/backends/qaoa_vectorized.py
@@ -890,7 +890,7 @@ def expectation(self, params: Type[QAOAVariationalBaseParams]) -> float:
         # Reshape wavefunction
         wavefn_ = self.wavefn
 
-        self.measurement_outcomes = self.wavefn.flatten()
+        self.measurement_outcomes = wavefn_.flatten()
 
         # Compute the expectation value and its standard deviation
         ham_wf = self.ham_op * wavefn_
@@ -922,7 +922,7 @@ def expectation_w_uncertainty(
         # Reshape wavefunction
         wavefn_ = self.wavefn
 
-        self.measurement_outcomes = self.wavefn.flatten()
+        self.measurement_outcomes = wavefn_.flatten()
 
         # Compute the expectation value and its standard deviation
         ham_wf = self.ham_op * wavefn_
diff --git a/src/openqaoa-core/qaoa_components/variational_parameters/fourierparams.py b/src/openqaoa-core/qaoa_components/variational_parameters/fourierparams.py
index 70586bfb8..69614dc94 100644
--- a/src/openqaoa-core/qaoa_components/variational_parameters/fourierparams.py
+++ b/src/openqaoa-core/qaoa_components/variational_parameters/fourierparams.py
@@ -57,8 +57,8 @@ def __init__(
         super().__init__(qaoa_descriptor)
         assert q is not None, f"Depth q for {type(self).__name__} must be specified"
         self.q = q
-        self.u = u
         self.v = v
+        self.u = u
         self.betas = dct(self.v, n=self.p)
         self.gammas = dst(self.u, n=self.p)
 
diff --git a/src/openqaoa-core/qaoa_components/variational_parameters/variational_baseparams.py b/src/openqaoa-core/qaoa_components/variational_parameters/variational_baseparams.py
index d1d0f925d..86278a19e 100644
--- a/src/openqaoa-core/qaoa_components/variational_parameters/variational_baseparams.py
+++ b/src/openqaoa-core/qaoa_components/variational_parameters/variational_baseparams.py
@@ -132,6 +132,55 @@ def raw(self) -> np.ndarray:
         """
         raise NotImplementedError()
 
+    def update_from_dict(self, new_values: dict):
+        """
+        Update all the parameters from a dictionary.
+
+        The input has the same format as the output of ``self.asdict()``.
+
+        Parameters
+        ----------
+        new_values: `dict`
+            A dictionary with the new parameters. Must have the same keys as
+            the output of ``self.asdict()``.
+
+        """
+
+        assert isinstance(new_values, dict), f"Expected dict, got {type(new_values)}"
+
+        for key, value in new_values.items():
+            if key not in self.asdict().keys():
+                raise KeyError(
+                    f"'{key}' not in {self.__class__.__name__}, expected keys: {list(self.asdict().keys())}"
+                )
+            else:
+                if getattr(self, key).shape != np.array(value).shape:
+                    raise ValueError(
+                        f"Shape of '{key}' does not match. Expected shape {getattr(self, key).shape}, got {np.array(value).shape}."
+                    )
+
+        raw_params = []
+        for key, value in self.asdict().items():
+            if key in new_values.keys():
+                raw_params += list(np.array(new_values[key]).flatten())
+            else:
+                raw_params += list(np.array(value).flatten())
+
+        self.update_from_raw(raw_params)
+
+    def asdict(self) -> dict:
+        """
+        Return the parameters as a dictionary.
+
+        Returns
+        -------
+        dict:
+            The parameters as a dictionary. Has the same output format as the
+            expected input of ``self.update_from_dict``.
+
+        """
+        return {k[2:]: v for k, v in self.__dict__.items() if k[0:2] == "__"}
+
     @classmethod
     def linear_ramp_from_hamiltonian(
         cls, qaoa_descriptor: QAOADescriptor, time: float = None


Test patch:
diff --git a/tests/test_benchmark.py b/tests/test_benchmark.py
new file mode 100644
index 000000000..74efca2ca
--- /dev/null
+++ b/tests/test_benchmark.py
@@ -0,0 +1,630 @@
+import unittest
+import numpy as np
+import matplotlib.pyplot as plt
+
+from openqaoa import QAOA, create_device, QAOABenchmark
+from openqaoa.problems import QUBO
+
+
+def there_is_an_error(function, **kwargs):
+    error = False
+    try:
+        function(**kwargs)
+    except:
+        error = True
+    return error
+
+
+class TestingBenchmark(unittest.TestCase):
+    def test_simple_benchmark(self):
+        "Test the simplest benchmark."
+
+        qaoa = QAOA()
+        qaoa.set_device(create_device(name="analytical_simulator", location="local"))
+        qaoa.compile(QUBO.random_instance(5))
+
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(n_points_axis=2**4, ranges=[(0, 2), (-2, 5)])
+
+        assert benchmark.ranges == [
+            (0, 2),
+            (-2, 5),
+        ], "The ranges saved are not correct."
+        assert benchmark.ranges_reference == [
+            (0, 2),
+            (-2, 5),
+        ], "The ranges saved for the reference are not correct."
+        assert benchmark.values.shape == (
+            16,
+            16,
+        ), "The shape of the values matrix is not correct."
+        assert benchmark.values_reference.shape == (
+            16,
+            16,
+        ), "The shape of the values matrix of the reference is not correct."
+        assert benchmark.difference.shape == (
+            16,
+            16,
+        ), "The shape of the difference matrix is not correct."
+        assert all(
+            benchmark.difference.flatten() == 0
+        ), "The difference matrix should be all 0."
+        assert benchmark.difference_mean == 0, "The difference mean should be 0."
+
+    def test_type_qaoa_reference(self):
+        "Test the type of the qaoa reference."
+
+        qaoa_analytical = QAOA()
+        qaoa_analytical.set_device(
+            create_device(name="analytical_simulator", location="local")
+        )
+        qaoa_analytical.compile(QUBO.random_instance(5))
+
+        qaoa_vectorized = QAOA()
+        qaoa_vectorized.set_device(create_device(name="vectorized", location="local"))
+        qaoa_vectorized.compile(QUBO.random_instance(5))
+
+        # standard qaoa should have a analytical reference
+        qaoa = QAOA()
+        qaoa.set_device(create_device(name="qiskit.shot_simulator", location="local"))
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+        assert isinstance(
+            benchmark.reference, QAOA
+        ), "The qaoa reference should be a QAOA object."
+        assert isinstance(
+            benchmark.reference.backend, type(qaoa_analytical.backend)
+        ), "The qaoa reference should have an analytical backend."
+
+        # p>1 qaoa should have a vectorized reference
+        qaoa = QAOA()
+        qaoa.set_device(create_device(name="qiskit.shot_simulator", location="local"))
+        qaoa.set_circuit_properties(p=2)
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+        assert isinstance(
+            benchmark.reference, QAOA
+        ), "The qaoa reference should be a QAOA object."
+        assert isinstance(
+            benchmark.reference.backend, type(qaoa_vectorized.backend)
+        ), "The qaoa reference should have a vectorized backend."
+
+    def __compare_values_benchmark(
+        self,
+        qaoa,
+        n_points_axis,
+        ranges,
+        run_reference=False,
+        verbose=True,
+        plot_options={},
+    ):
+        "private function to compare the values of the benchmark with the values obtained by evaluating the circuit manually."
+
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(
+            n_points_axis=n_points_axis,
+            ranges=ranges,
+            run_reference=run_reference,
+            verbose=verbose,
+            plot_options=plot_options,
+        )
+
+        ranges_to_use = [r for r in ranges if len(r) == 2]
+        values = np.zeros([n_points_axis for _ in range(len(ranges_to_use))])
+        axes = [np.linspace(r[0], r[1], n_points_axis) for r in ranges_to_use]
+
+        params = lambda x: [r[0] if len(r) == 1 else x.pop(0) for r in ranges]
+
+        if len(ranges_to_use) == 1:
+            for i in range(n_points_axis):
+                values[i] = qaoa.evaluate_circuit(params([axes[0][i]]))["cost"]
+        elif len(ranges_to_use) == 2:
+            for i in range(n_points_axis):
+                for j in range(n_points_axis):
+                    values[j, i] = qaoa.evaluate_circuit(
+                        params([axes[0][i], axes[1][j]])
+                    )["cost"]
+        elif len(ranges_to_use) == 3:
+            for i in range(n_points_axis):
+                for j in range(n_points_axis):
+                    for k in range(n_points_axis):
+                        values[k, j, i] = qaoa.evaluate_circuit(
+                            params([axes[0][i], axes[1][j], axes[2][k]])
+                        )["cost"]
+        else:
+            raise ValueError(
+                "Bug in the tests: The number of ranges must be 1, 2 or 3."
+            )
+
+        assert (
+            benchmark.ranges == ranges
+        ), "The ranges saved are not correct. Inputs: n_points_axis={}, ranges={}".format(
+            n_points_axis, ranges
+        )
+        assert (
+            benchmark.values.shape == values.shape
+        ), "The shape of the values matrix is not correct. Inputs: n_points_axis={}, ranges={}".format(
+            n_points_axis, ranges
+        )
+        assert all(
+            benchmark.values.flatten() == values.flatten()
+        ), "The values matrix is not correct. Inputs: n_points_axis={}, ranges={}".format(
+            n_points_axis, ranges
+        )
+
+        if run_reference:
+            assert (
+                benchmark.ranges_reference == ranges
+            ), "The ranges saved for the reference are not correct. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+            assert (
+                benchmark.values_reference.shape == values.shape
+            ), "The shape of the values matrix of the reference is not correct. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+            assert (
+                benchmark.difference.shape == values.shape
+            ), "The difference matrix should have the same shape as the values matrix. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+            assert isinstance(
+                benchmark.difference_mean, float
+            ), "The difference mean should be a float. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+        else:
+            assert (
+                benchmark.values_reference is None
+            ), "There should be no reference values, since run_reference=False. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+            assert (
+                benchmark.ranges_reference is None
+            ), "There should be no reference ranges, since run_reference=False. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+
+            error = False
+            try:
+                benchmark.difference
+            except:
+                error = True
+            assert (
+                error
+            ), "There should be no difference matrix, since run_reference=False. An error should be raised. Inputs: n_points_axis={}, ranges={}, run_reference={}".format(
+                n_points_axis, ranges, run_reference
+            )
+
+    def test_values_1D(self):
+        "Test the values of the benchmark for 1D ranges."
+
+        # standard case
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        self.__compare_values_benchmark(
+            qaoa, n_points_axis=10, ranges=[(-24.78, 65.97), (356.467,)]
+        )
+
+        # extended parameters
+        qaoa = QAOA()
+        qaoa.set_circuit_properties(param_type="extended")
+        qaoa.compile(
+            QUBO(
+                n=5,
+                terms=[[0, 1], [1, 2], [2, 3], [3, 4], [4, 2], [4, 0]],
+                weights=[1, 2, 1, 2, 1, 2],
+            )
+        )
+        self.__compare_values_benchmark(
+            qaoa,
+            n_points_axis=10,
+            ranges=[
+                (-24.78,),
+                (65.97,),
+                (356.467,),
+                (-24.78,),
+                (65.97,),
+                (0.03, 0.031),
+                (356.467,),
+                (2,),
+                (-24.78,),
+                (65.97,),
+                (356.467,),
+            ],
+        )
+
+    def test_values_2D(self):
+        "Test the values of the benchmark for 2D ranges."
+
+        # standard case
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        self.__compare_values_benchmark(
+            qaoa,
+            n_points_axis=4,
+            ranges=[(-1.43, 2.78), (12.3, 25.68)],
+            verbose=False,
+            plot_options={"verbose": False},
+        )
+
+        # p=2
+        qaoa = QAOA()
+        qaoa.set_circuit_properties(p=2)
+        qaoa.compile(QUBO.random_instance(5))
+        self.__compare_values_benchmark(
+            qaoa,
+            n_points_axis=4,
+            ranges=[(-1.43, 2.78), (12.3,), (0.5, 1.5), (1,)],
+            run_reference=True,
+        )
+
+    def test_values_3D(self):
+        "Test the values of the benchmark for 3D ranges."
+
+        # standard case
+        qaoa = QAOA()
+        qaoa.set_circuit_properties(p=2)
+        qaoa.compile(QUBO.random_instance(5))
+        self.__compare_values_benchmark(
+            qaoa,
+            n_points_axis=4,
+            ranges=[(-1.43, 2.78), (12.3, 25.68), (0.5, 1.5), (1,)],
+            verbose=True,
+        )
+
+        # p=3
+        qaoa = QAOA()
+        qaoa.set_circuit_properties(p=3)
+        qaoa.compile(QUBO.random_instance(5))
+        self.__compare_values_benchmark(
+            qaoa,
+            n_points_axis=4,
+            ranges=[(-1.43, 2.78), (245,), (0.5, 1.5), (1,), (0.5, 1.5), (19,)],
+            run_reference=True,
+        )
+
+    def test_difference(self):
+        "Test the property difference and difference_mean."
+
+        # device shot-based
+        qaoa = QAOA()
+        qaoa.set_device(create_device(location="local", name="qiskit.shot_simulator"))
+        qaoa.compile(QUBO.random_instance(5))
+
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (-5, 9)])
+
+        assert (
+            np.abs(benchmark.difference_mean) > 0
+        ), "The difference mean should be non-zero."
+        assert np.all(
+            benchmark.difference == benchmark.values - benchmark.values_reference
+        ), "The difference matrix should be the difference between the values and the reference values."
+        assert benchmark.difference_mean == np.mean(
+            benchmark.difference
+        ), "The difference mean should be the mean of the difference matrix."
+
+        # test raise errors if not run main or run reference
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        error = False
+        try:
+            benchmark.difference
+        except:
+            error = True
+        assert (
+            error
+        ), "An error should be raised if the difference is called before running the benchmark."
+
+        benchmark.run(
+            n_points_axis=4,
+            ranges=[(-np.pi, 23), (3, 4)],
+            run_reference=True,
+            run_main=False,
+        )
+        error = False
+        try:
+            benchmark.difference
+        except:
+            error = True
+        assert (
+            error
+        ), "An error should be raised if the difference is called before running the benchmark."
+
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        benchmark.run(
+            n_points_axis=4,
+            ranges=[(-np.pi, 23), (3, 4)],
+            run_reference=False,
+            run_main=True,
+        )
+        error = False
+        try:
+            benchmark.difference
+        except:
+            error = True
+        assert (
+            error
+        ), "An error should be raised if the difference is called before running the benchmark."
+
+    def test_input_checks(self):
+        "Test the input assertions of the run method."
+
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        assert there_is_an_error(
+            benchmark.run,
+            ranges=[(1, 2), (1, 3)],
+        ), "An error should be raised when n_points_axis is not passed."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+        ), "An error should be raised when ranges is not passed."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4.5,
+            ranges=[(1, 2), (1, 3)],
+        ), "An error should be raised when n_points_axis is not an integer."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=56,
+        ), "An error should be raised when ranges is not a list."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[
+                (1, 2),
+            ],
+        ), "An error when len(ranges) != len(qaoa.circuit_parameters)."
+        assert there_is_an_error(
+            benchmark.run, n_points_axis=4, ranges=[(1, 2), (3,), (34,)]
+        ), "An error when len(ranges) != len(qaoa.circuit_parameters)."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1, 2), "yes"],
+        ), "An error should be raised when ranges is not a list of tuples."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1, 2), (1, 3, 4)],
+        ), "An error should be raised when ranges is not a list of tuples of length 2."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1,), (1,)],
+        ), "An error should be raised when ranges all ranges are tuples of length 1."
+        assert there_is_an_error(
+            benchmark.run, n_points_axis=4, ranges=[(1, 2), (1, 3)], run_main="fhn"
+        ), "An error should be raised when run_main or run_reference are not booleans."
+        assert there_is_an_error(
+            benchmark.run, n_points_axis=4, ranges=[(1, 2), (1, 3)], run_reference="fhn"
+        ), "An error should be raised when run_main or run_reference are not booleans."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1, 2), (1, 3)],
+            plot="fhn",
+            plot_reference=True,
+        ), "An error should be raised when plot or plot_reference are not booleans."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1, 2), (1, 3)],
+            plot=True,
+            plot_reference="fhn",
+        ), "An error should be raised when plot or plot_reference are not booleans."
+        assert there_is_an_error(
+            benchmark.run,
+            n_points_axis=4,
+            ranges=[(1, 2), (1, 2)],
+            run_main=False,
+            run_reference=False,
+        ), "An error should be raised if nor run_main nor run_reference are True."
+        assert there_is_an_error(
+            benchmark.run, n_points_axis=4, ranges=[(1, 2), (1, 3)], plot_options="fhn"
+        ), "An error should be raised when plot_options is not a dictionary."
+        assert there_is_an_error(
+            benchmark.run, n_points_axis=4, ranges=[(1, 2), (1, 3)], verbose="d"
+        ), "An error should be raised when verbose is not a boolean."
+
+    def test_plot(self):
+        "Test the plot method."
+
+        # test standard plot
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        # 2D
+        benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (-5, 9)])
+        benchmark.plot()
+        benchmark.plot(main=False, reference=True)
+        benchmark.plot(main=False, difference=True)
+        benchmark.plot(main=True, reference=True, difference=True)
+        benchmark.plot(main=False, reference=True, difference=True)
+        benchmark.plot(main=True, reference=False, difference=True)
+        benchmark.plot(main=True, reference=True, difference=False)
+
+        # 1D
+        benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (1,)])
+        benchmark.plot()
+        benchmark.plot(main=False, reference=True)
+        benchmark.plot(main=False, difference=True)
+        benchmark.plot(main=True, reference=True, difference=True)
+        benchmark.plot(main=False, reference=True, difference=True)
+        benchmark.plot(main=True, reference=False, difference=True)
+        benchmark.plot(main=True, reference=True, difference=False)
+        benchmark.plot(main=True, reference=True, difference=True, one_plot=True)
+        benchmark.plot(main=False, reference=True, difference=True, one_plot=True)
+        benchmark.plot(main=True, reference=False, difference=True, one_plot=True)
+        benchmark.plot(main=True, reference=True, difference=False, one_plot=True)
+
+        # 3D
+        qaoa = QAOA()
+        qaoa.set_circuit_properties(p=2)
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (-5, 9), (0, 1), (1,)])
+        benchmark.plot()
+
+    def test_plot_inputs(self):
+        "Test the plot method with different inputs."
+
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        # 2D
+        benchmark.run(n_points_axis=4, ranges=[(-np.pi / 2, np.pi / 2), (1, 3)])
+        benchmark.plot(labels=["a", "b"], plot_options={"cmap": "gray"})
+        benchmark.plot(
+            main=True,
+            reference=True,
+            difference=True,
+            labels=["a", "b"],
+            title=["a", "b", "c"],
+            labels_legend="test",
+            plot_options={"cmap": "gray"},
+        )
+        benchmark.plot(
+            main=True, reference=True, difference=True, verbose=False, title="s"
+        )
+        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
+        benchmark.plot(ax=ax)
+        plt.show()
+        plt.close(fig)
+
+        # 1D
+        benchmark.run(n_points_axis=4, ranges=[(-np.pi / 2, np.pi / 2), (1,)])
+        benchmark.plot(labels=["a", "b"], plot_options={"linewidth": 2})
+        benchmark.plot(
+            main=True,
+            reference=True,
+            difference=True,
+            labels=["a", "b"],
+            title=["a", "b", "c"],
+            plot_options={"linewidth": 2},
+        )
+        benchmark.plot(
+            main=True,
+            reference=True,
+            difference=True,
+            verbose=False,
+            one_plot=True,
+            title="s",
+            labels_legend=["a", "b", "c"],
+        )
+        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
+        benchmark.plot(ax=ax)
+        plt.show()
+        plt.close(fig)
+
+    def test_plot_input_checks(self):
+        "Test the plot method assertion inputs."
+
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        benchmark.run(n_points_axis=4, ranges=[(0, np.pi), (-5, 9)])
+        assert there_is_an_error(
+            benchmark.plot, ax=""
+        ), "An error should be raised when ax is not a matplotlib Axes"
+        assert there_is_an_error(
+            benchmark.plot, labels=""
+        ), "An error should be raised when labels is not a list of two strings"
+        assert there_is_an_error(
+            benchmark.plot, labels=[""]
+        ), "An error should be raised when labels is not a list of two strings"
+        assert there_is_an_error(
+            benchmark.plot, labels=["", "", ""]
+        ), "An error should be raised when labels is not a list of two strings"
+        assert there_is_an_error(
+            benchmark.plot, main=""
+        ), "An error should be raised when main is not a boolean"
+        assert there_is_an_error(
+            benchmark.plot, reference=""
+        ), "An error should be raised when reference is not a boolean"
+        assert there_is_an_error(
+            benchmark.plot, difference=""
+        ), "An error should be raised when difference is not a boolean"
+        assert there_is_an_error(
+            benchmark.plot, plot_options=""
+        ), "An error should be raised when plot_options is not a dict"
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=True, difference=True, one_plot=True
+        ), "An error should be raised when one_plot is True and more than one plot is requested when 2D"
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=True, difference=True, title=["a", "d"]
+        ), "An error should be raised when one_plot is True and more than one plot is requested when 2D"
+
+        # plot without values
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=False
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=False, reference=True
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=False, reference=False, difference=True
+        ), "An error should be raised when no values are available"
+
+        benchmark.run(
+            n_points_axis=4,
+            ranges=[(0, np.pi), (1,)],
+            run_main=True,
+            run_reference=False,
+        )
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=True
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=False, reference=True
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=False, reference=False, difference=True
+        ), "An error should be raised when no values are available"
+
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(
+            n_points_axis=4,
+            ranges=[(0, np.pi), (1,)],
+            run_main=False,
+            run_reference=True,
+        )
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=True
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=True, reference=False
+        ), "An error should be raised when no values are available"
+        assert there_is_an_error(
+            benchmark.plot, main=False, reference=False, difference=True
+        ), "An error should be raised when no values are available"
+
+    def test_run_w_plots(self):
+
+        qaoa = QAOA()
+        qaoa.compile(QUBO.random_instance(5))
+        benchmark = QAOABenchmark(qaoa)
+        benchmark.run(
+            n_points_axis=4,
+            ranges=[(-np.pi / 2, np.pi / 2), (1, 3)],
+            plot=True,
+            run_reference=True,
+            plot_difference=True,
+        )
diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py
index 42df0a32e..7e84f427b 100644
--- a/tests/test_notebooks.py
+++ b/tests/test_notebooks.py
@@ -79,10 +79,15 @@ def test_13_optimizers():
     notebook_test_function("./examples/13_optimizers.ipynb")
 
 
+@pytest.mark.qpu
+def test_14_benchmark():
+    notebook_test_function("./examples/14_qaoa_benchmark.ipynb")
+
+
 def test_X_dumping_data():
     notebook_test_function("./examples/X_dumping_data.ipynb")
-       
-       
+
+
 ### Community Tutorials
 
 # @pytest.mark.notebook
diff --git a/tests/test_parameters.py b/tests/test_parameters.py
index 363071b7c..f8fe3bbc1 100644
--- a/tests/test_parameters.py
+++ b/tests/test_parameters.py
@@ -10,6 +10,7 @@
 from openqaoa.qaoa_components.ansatz_constructor.gatemaplabel import GateMapType
 from openqaoa.qaoa_components.variational_parameters.variational_params_factory import (
     PARAMS_CLASSES_MAPPER,
+    VARIATIONAL_PARAMS_DICT_KEYS,
 )
 
 register = [0, 1, 2]
@@ -584,94 +585,156 @@ def test_str_and_repr(self):
 
             self.assertEqual(variate_params.__str__(), variate_params.__repr__())
 
-    # # Plot Tests
-
-    # def test_StandardParams_plot(self):
-
-    #     register_wo_bias = [0, 1, 2]
-    #     terms_wo_bias = [[0, 1], [0, 2]]
-    #     weights_wo_bias = [1, -2.0]
-
-    #     p = 5
-    #     hyperparams = HyperParams(terms,weights,register,p)
-    #     params = StandardParams.linear_ramp_from_hamiltonian(hyperparams)
-    #     fig, ax = plt.subplots()
-    #     params.plot(ax=ax)
-    #     # plt.show()
-
-    #     p = 8
-    #     hyperparams = HyperParams(terms,weights,register,p)
-    #     params = StandardParams(hyperparams,([0.1]*p, [0.2]*p))
-    #     fig, ax = plt.subplots()
-    #     params.plot(ax=ax)
-    #     # plt.show()
-
-    #     p = 2
-    #     hyperparams = HyperParams(terms_wo_bias,weights_wo_bias,register_wo_bias,p)
-    #     params = StandardParams(hyperparams,([5]*p, [10]*p))
-    #     fig, ax = plt.subplots()
-    #     params.plot(ax=ax)
-    #     # plt.show()
-
-    # def test_ExtendedParams_plot(self):
-
-    #     register_wo_bias = [0, 1, 2]
-    #     terms_wo_bias = [[0, 1], [0, 2]]
-    #     weights_wo_bias = [1, -2.0]
-
-    #     p = 5
-    #     hyperparams = HyperParams(terms_wo_bias,weights_wo_bias,register_wo_bias,p)
-    #     params = ExtendedParams.linear_ramp_from_hamiltonian(hyperparams, p)
-    #     fig, ax = plt.subplots()
-    #     params.plot(ax=ax)
-    #     # plt.show()
-
-    #     p = 8
-    #     hyperparams = HyperParams(terms_wo_bias,weights_wo_bias,register_wo_bias,p)
-    #     params = ExtendedParams(hyperparams,
-    #                             ([0.1] * p*len(register),
-    #                             [],
-    #                             [0.2] * p*len(weights_wo_bias)))
-    #     fig, ax = plt.subplots()
-    #     params.plot(ax=ax)
-    #     # plt.show()
-
-    # def test_extended_get_constraints(self):
-    #     register = [0,1,2,3]
-    #     terms = [[0, 1], [1, 2], [2, 3], [3, 0]]
-    #     weights = [0.1, 0.3, 0.5, -0.7]
-    #     p = 2
-
-    #     hyperparams = HyperParams(terms,weights,register,p)
-    #     params = ExtendedParams.linear_ramp_from_hamiltonian(hyperparams)
-
-    #     actual_constraints = params.get_constraints()
-
-    #     expected_constraints = [(0, 2 * np.pi), (0, 2 * np.pi),
-    #                             (0, 2 * np.pi), (0, 2 * np.pi),
-    #                             (0, 2 * np.pi), (0, 2 * np.pi),
-    #                             (0, 2 * np.pi), (0, 2 * np.pi),
-    #                             (0, 2 * np.pi / weights[0]),
-    #                             (0, 2 * np.pi / weights[1]),
-    #                             (0, 2 * np.pi / weights[2]),
-    #                             (0, 2 * np.pi / weights[3]),
-    #                             (0, 2 * np.pi / weights[0]),
-    #                             (0, 2 * np.pi / weights[1]),
-    #                             (0, 2 * np.pi / weights[2]),
-    #                             (0, 2 * np.pi / weights[3])]
-
-    #     assert(np.allclose(expected_constraints, actual_constraints))
-
-    #     cost_function = QAOACostVector(params)
-    #     np.random.seed(0)
-    #     random_angles = np.random.uniform(-100, 100, size=len(params.raw()))
-    #     value = cost_function(random_angles)
-
-    #     normalised_angles = [random_angles[i] % actual_constraints[i][1]
-    #                         for i in range(len(params.raw()))]
-    #     normalised_value = cost_function(normalised_angles)
-
-    #     assert(np.allclose(value, normalised_value))
+    def test_qaoa_variational_params_asdict(self):
+
+        p = 4
+        q = 2
+
+        number_of_params = {
+            "standard": {"betas": p, "gammas": p},
+            "standard_w_bias": {"betas": p, "gammas_singles": p, "gammas_pairs": p},
+            "extended": {
+                "betas_singles": len(register) * p,
+                "betas_pairs": 0,
+                "gammas_singles": sum([1 for term in terms if len(term) == 1]) * p,
+                "gammas_pairs": sum([1 for term in terms if len(term) == 2]) * p,
+            },
+            "fourier": {"v": q, "u": q},
+            "fourier_extended": {
+                "v_singles": len(register) * q,
+                "v_pairs": 0,
+                "u_singles": sum([1 for term in terms if len(term) == 1]) * q,
+                "u_pairs": sum([1 for term in terms if len(term) == 2]) * q,
+            },
+            "fourier_w_bias": {"v": q, "u_singles": q, "u_pairs": q},
+            "annealing": {"schedule": p},
+        }
+
+        qaoa_descriptor = QAOADescriptor(cost_hamiltonian, mixer_hamiltonian, p=p)
+
+        for each_key_value in PARAMS_CLASSES_MAPPER.keys():
+
+            # create the variational params object
+            variate_params = create_qaoa_variational_params(
+                qaoa_descriptor,
+                params_type=each_key_value,
+                init_type="rand",
+                q=q,
+                total_annealing_time=2,
+            )
+
+            # get the dict and check that it is a dict
+            variate_params_dict = variate_params.asdict()
+            assert isinstance(
+                variate_params_dict, dict
+            ), f"asdict() should return a dict, it did not for type: '{each_key_value}'."
+
+            # check that the keys are correct
+            expected_keys = VARIATIONAL_PARAMS_DICT_KEYS[each_key_value]
+            for key in [
+                "q",
+                "total_annealing_time",
+            ]:  # from expected_keys, remove the "q" and "total_annealing_time" keys, if there are any
+                if key in expected_keys:
+                    expected_keys.remove(key)
+            assert set(variate_params_dict.keys()) == set(
+                expected_keys
+            ), f"asdict() should return a dict with the correct keys, it did not for type: '{each_key_value}'."
+
+            # check that the number of values is correct
+            for key, value in variate_params_dict.items():
+                assert (
+                    value.size == number_of_params[each_key_value][key]
+                ), f"asdict() should return a dict with the correct number of values, it did not for type: '{each_key_value}'. \
+                \n Expected {number_of_params[each_key_value][key]} values for key '{key}', but got {value.size} values."
+
+            # check that the values are correct
+            list_params_raw = []
+            for key, value in variate_params_dict.items():
+                list_params_raw += value.flatten().tolist()
+
+            assert np.allclose(
+                list_params_raw, variate_params.raw().tolist()
+            ), f"asdict() should return a dict with the correct values, it did not for type: '{each_key_value}'."
+
+    def test_qaoa_variational_params_update_from_dict(self):
+
+        qaoa_descriptor = QAOADescriptor(cost_hamiltonian, mixer_hamiltonian, p=2)
+
+        for each_key_value in PARAMS_CLASSES_MAPPER.keys():
+            variate_params = create_qaoa_variational_params(
+                qaoa_descriptor,
+                params_type=each_key_value,
+                init_type="rand",
+                q=1,
+                total_annealing_time=1,
+            )
+
+            # get the params as a dict
+            variate_params_dict = variate_params.asdict()
+
+            # create a new dict with random values
+            new_dict = {
+                k: np.random.rand(*v.shape) for k, v in variate_params_dict.items()
+            }
+
+            # update the variational params object with the new dict
+            variate_params.update_from_dict(new_dict)
+
+            # check that the values are correct
+            for key, value in variate_params.asdict().items():
+                assert np.allclose(
+                    value, new_dict[key]
+                ), f"update_from_dict() should update the values correctly, it did not for type: '{each_key_value}'."
+
+            # check that if we pass in a dict with the wrong keys, an error is raised
+            wrong_dict = new_dict
+            wrong_dict["wrong_key"] = np.random.rand(1)
+            error = False
+            try:
+                variate_params.update_from_dict(wrong_dict)
+            except:
+                error = True
+            assert (
+                error
+            ), f"update_from_dict() should raise an error if the dict has the wrong keys, it did not for type: '{each_key_value}'."
+
+            # check that if we pass in a dict with more values than expected, an error is raised
+            wrong_dict = new_dict
+            wrong_dict.pop("wrong_key")
+            for key in wrong_dict.keys():
+                wrong_dict[key] = np.append(wrong_dict[key], np.random.rand(1))
+            error = False
+            try:
+                variate_params.update_from_dict(wrong_dict)
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"update_from_dict() should raise an error if the dict has more values than expected, it did not for type: '{each_key_value}'."
+
+            # check that if we pass in a dict with less values than expected, an error is raised
+            wrong_dict = new_dict
+            for key in wrong_dict.keys():
+                wrong_dict[key] = wrong_dict[key][:-2]
+            error = False
+            try:
+                variate_params.update_from_dict(wrong_dict)
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"update_from_dict() should raise an error if the dict has less values than expected, it did not for type: '{each_key_value}'."
+
+            # check that if we pass something that is not a dict, an error is raised
+            error = False
+            try:
+                variate_params.update_from_dict(1)
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"update_from_dict() should raise an error if the input is not a dict, it did not for type: '{each_key_value}'."
 
 
 if __name__ == "__main__":
diff --git a/tests/test_utilities.py b/tests/test_utilities.py
index 405dd4ea9..10c305d50 100644
--- a/tests/test_utilities.py
+++ b/tests/test_utilities.py
@@ -537,8 +537,9 @@ def test_energy_expectation(self):
         correct_energy = 11.2
 
         # Test energy was computed correctly
-        assert np.allclose(energy, correct_energy), f"The energy expectation value for rings of disagrees was not computed correctly"
-
+        assert np.allclose(
+            energy, correct_energy
+        ), f"The energy expectation value for rings of disagrees was not computed correctly"
 
         ## Second test - Minimum Vertex Cover on a Ring
 
@@ -558,7 +559,9 @@ def test_energy_expectation(self):
         mvc = MinimumVertexCover(G, field=field, penalty=penalty).qubo
 
         # Minimum Vertex Cover Hamiltonian
-        hamiltonian = Hamiltonian.classical_hamiltonian(mvc.terms, mvc.weights, mvc.constant)
+        hamiltonian = Hamiltonian.classical_hamiltonian(
+            mvc.terms, mvc.weights, mvc.constant
+        )
 
         # Input measurement counts dictionary
         input_measurement_counts = {
@@ -575,8 +578,9 @@ def test_energy_expectation(self):
         correct_energy = 30
 
         # Test energy was computed correctly
-        assert np.allclose(energy, correct_energy), f"The energy expectation value for Minimum Vertex Cover was not computed correctly"
-
+        assert np.allclose(
+            energy, correct_energy
+        ), f"The energy expectation value for Minimum Vertex Cover was not computed correctly"
 
     def test_energy_spectrum_hamiltonian(self):
         """
diff --git a/tests/test_workflows.py b/tests/test_workflows.py
index 430658f50..45a9ee708 100644
--- a/tests/test_workflows.py
+++ b/tests/test_workflows.py
@@ -3,6 +3,7 @@
 import networkx as nw
 import numpy as np
 import datetime
+from copy import deepcopy
 
 from qiskit.providers.fake_provider import FakeVigo
 from qiskit.providers.aer.noise import NoiseModel
@@ -19,6 +20,7 @@
 )
 from openqaoa.algorithms.rqaoa.rqaoa_workflow_properties import RqaoaParameters
 from openqaoa.backends import create_device, DeviceLocal
+from openqaoa.backends.cost_function import cost_function
 from openqaoa.backends.devices_core import SUPPORTED_LOCAL_SIMULATORS
 from openqaoa.qaoa_components import (
     Hamiltonian,
@@ -46,7 +48,9 @@
     QAOAQiskitBackendShotBasedSimulator,
     QAOAQiskitBackendStatevecSimulator,
 )
-
+from openqaoa.qaoa_components.variational_parameters.variational_params_factory import (
+    PARAMS_CLASSES_MAPPER,
+)
 
 ALLOWED_LOCAL_SIMUALTORS = SUPPORTED_LOCAL_SIMULATORS
 LOCAL_DEVICES = ALLOWED_LOCAL_SIMUALTORS + ["6q-qvm", "Aspen-11"]
@@ -1340,19 +1344,220 @@ def test_qaoa_from_dict_and_load(self):
             error
         ), "RQAOA.from_dict should raise an error when using a QAOA dictionary"
 
+    def test_qaoa_evaluate_circuit(self):
+        """
+        test the evaluate_circuit method
+        """
+
+        # problem
+        problem = MinimumVertexCover.random_instance(
+            n_nodes=6, edge_probability=0.8
+        ).qubo
+
+        # run qaoa with different param_type, and save the objcets in a list
+        qaoas = []
+        for param_type in PARAMS_CLASSES_MAPPER.keys():
+            q = QAOA()
+            q.set_circuit_properties(p=3, param_type=param_type, init_type="rand")
+            q.compile(problem)
+            qaoas.append(q)
+
+        # for each qaoa object, test the evaluate_circuit method
+        for q in qaoas:
+
+            # evaluate the circuit with random dict of params
+            params = {
+                k: np.random.rand(*v.shape)
+                for k, v in q.variate_params.asdict().items()
+            }
+            result = q.evaluate_circuit(params)
+            assert (
+                abs(result["cost"]) >= 0
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return a cost, here cost is {result['cost']}"
+            assert (
+                abs(result["uncertainty"]) > 0
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return an uncertanty, here uncertainty is {result['uncertainty']}"
+            assert (
+                len(result["measurement_results"]) > 0
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return a wavefunction when using a state-based simulator"
+
+            # evaluate the circuit with a list of params, taking the params from the dict, so we should get the same result
+            params2 = []
+            for value in params.values():
+                params2 += value.flatten().tolist()
+            result2 = q.evaluate_circuit(params2)
+            assert (
+                result == result2
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return the same result when passing a dict or a list of params"
+
+            # evaluate the circuit with np.ndarray of params, taking the params from the dict, so we should get the same result
+            result2 = q.evaluate_circuit(np.array(params2))
+            assert (
+                result == result2
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return the same result when passing a dict or a list of params"
+
+            # evaluate the circuit with the params as a QAOAVariationalBaseParams object, so we should get the same result
+            params_obj = deepcopy(q.variate_params)
+            params_obj.update_from_raw(params2)
+            result3 = q.evaluate_circuit(params_obj)
+            assert (
+                result == result3
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return the same result when passing a dict or a list of params"
+
+            # run the circuit with the params manually, we should get the same result
+            result4 = {}
+            (
+                result4["cost"],
+                result4["uncertainty"],
+            ) = q.backend.expectation_w_uncertainty(params_obj)
+            result4["measurement_results"] = q.backend.wavefunction(params_obj)
+            assert (
+                result == result4
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should return the same result when passing the optimized params manually"
+
+            # evaluate the circuit with a wrong input, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit(1)
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when passing a wrong input"
+
+            # evaluate the circuit with a list longer than it should, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit(params2 + [1])
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when passing a list longer than it should"
+
+            # evaluate the circuit with a list shorter than it should, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit(params2[:-1])
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when passing a list shorter than it should"
+
+            # evaluate the circuit with a dict with a wrong key, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit({**params, "wrong_key": 1})
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when passing a dict with a wrong key"
+
+            # evaluate the circuit with a dict with a value longer than it should, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit(
+                    {**params, list(params.keys())[0]: np.random.rand(40)}
+                )
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when passing a dict with a value longer than it should"
+
+            # evaluate the circuit without passing any param, it should raise an error
+            error = False
+            try:
+                q.evaluate_circuit()
+            except Exception:
+                error = True
+            assert (
+                error
+            ), f"param_type={q.circuit_properties.param_type}. `evaluate_circuit` should raise an error when not passing any param"
+
+        # check that it works with shots
+        q = QAOA()
+        device = create_device(location="local", name="qiskit.qasm_simulator")
+        q.set_device(device)
+        q.set_circuit_properties(p=3)
+
+        # try to evaluate the circuit before compiling
+        error = False
+        try:
+            q.evaluate_circuit()
+        except Exception:
+            error = True
+        assert (
+            error
+        ), f"param_type={param_type}. `evaluate_circuit` should raise an error if the circuit is not compiled"
+
+        # compile and evaluate the circuit, and check that the result is correct
+        q.compile(problem)
+        result = q.evaluate_circuit([1, 2, 1, 2, 1, 2])
+        assert isinstance(
+            result["measurement_results"], dict
+        ), "When using a shot-based simulator, `evaluate_circuit` should return a dict of counts"
+        assert (
+            abs(result["cost"]) >= 0
+        ), "When using a shot-based simulator, `evaluate_circuit` should return a cost"
+        assert (
+            abs(result["uncertainty"]) > 0
+        ), "When using a shot-based simulator, `evaluate_circuit` should return an uncertanty"
+
+        cost = cost_function(
+            result["measurement_results"],
+            q.backend.qaoa_descriptor.cost_hamiltonian,
+            q.backend.cvar_alpha,
+        )
+        cost_sq = cost_function(
+            result["measurement_results"],
+            q.backend.qaoa_descriptor.cost_hamiltonian.hamiltonian_squared,
+            q.backend.cvar_alpha,
+        )
+        uncertainty = np.sqrt(cost_sq - cost**2)
+        assert (
+            np.round(cost, 12) == result["cost"]
+        ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct cost"
+        assert (
+            np.round(uncertainty, 12) == result["uncertainty"]
+        ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct uncertainty"
+
+        # check that it works with analytical simulator
+        q = QAOA()
+        device = create_device(location="local", name="analytical_simulator")
+        q.set_device(device)
+        q.set_circuit_properties(p=1, param_type="standard")
+        q.compile(problem)
+        result = q.evaluate_circuit([1, 2])
+        assert (
+            abs(result["cost"]) >= 0
+        ), "When using an analytical simulator, `evaluate_circuit` should return a cost"
+        assert (
+            result["uncertainty"] == None
+        ), "When using an analytical simulator, `evaluate_circuit` should return uncertainty None"
+        assert (
+            result["measurement_results"] == None
+        ), "When using an analytical simulator, `evaluate_circuit` should return no measurement results"
+
     def test_change_properties_after_compilation(self):
-        device = create_device(location='local', name='qiskit.shot_simulator')
+        device = create_device(location="local", name="qiskit.shot_simulator")
         q = QAOA()
         q.compile(QUBO.random_instance(4))
-        
+
         with self.assertRaises(ValueError):
             q.set_device(device)
         with self.assertRaises(ValueError):
-            q.set_circuit_properties(p=1, param_type='standard', init_type='rand', mixer_hamiltonian='x')
+            q.set_circuit_properties(
+                p=1, param_type="standard", init_type="rand", mixer_hamiltonian="x"
+            )
         with self.assertRaises(ValueError):
             q.set_backend_properties(prepend_state=None, append_state=None)
         with self.assertRaises(ValueError):
-            q.set_classical_optimizer(maxiter=100, method='vgd', jac="finite_difference")
+            q.set_classical_optimizer(
+                maxiter=100, method="vgd", jac="finite_difference"
+            )
 
 
 class TestingRQAOA(unittest.TestCase):
@@ -2180,7 +2385,13 @@ def test_rqaoa_dumping_step_by_step(self):
         project_id = "None"
         experiment_id, atomic_id = r.header["experiment_id"], r.header["atomic_id"]
         file_names = {
-            id: project_id + "--" + experiment_id + "--" + id + "--" + "test_dumping_step_by_step.json.gz"
+            id: project_id
+            + "--"
+            + experiment_id
+            + "--"
+            + id
+            + "--"
+            + "test_dumping_step_by_step.json.gz"
             for id in r.result["atomic_ids"].values()
         }
         file_names[atomic_id] = (
@@ -2407,20 +2618,24 @@ def test_rqaoa_from_dict_and_load(self):
         ), "Optimizer.from_dict should raise an error when using a RQAOA dictionary"
 
     def test_change_properties_after_compilation(self):
-        device = create_device(location='local', name='qiskit.shot_simulator')
+        device = create_device(location="local", name="qiskit.shot_simulator")
         r = RQAOA()
         r.compile(QUBO.random_instance(4))
-        
+
         with self.assertRaises(ValueError):
             r.set_device(device)
         with self.assertRaises(ValueError):
-            r.set_circuit_properties(p=1, param_type='standard', init_type='rand', mixer_hamiltonian='x')
+            r.set_circuit_properties(
+                p=1, param_type="standard", init_type="rand", mixer_hamiltonian="x"
+            )
         with self.assertRaises(ValueError):
             r.set_backend_properties(prepend_state=None, append_state=None)
         with self.assertRaises(ValueError):
-            r.set_classical_optimizer(maxiter=100, method='vgd', jac="finite_difference")
+            r.set_classical_optimizer(
+                maxiter=100, method="vgd", jac="finite_difference"
+            )
         with self.assertRaises(ValueError):
-            r.set_rqaoa_parameters(rqaoa_type='adaptive', n_cutoff=3, n_steps=3)
+            r.set_rqaoa_parameters(rqaoa_type="adaptive", n_cutoff=3, n_steps=3)
 
 
 if __name__ == "__main__":