1mod examples;
9
10pub use examples::examples;
11
12use serde::de::{self, Deserializer};
13use serde::ser::{SerializeMap, Serializer};
14use serde::{Deserialize, Serialize};
15
16use crate::error::{Error, Result};
17
18#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
20pub struct Config {
21 #[serde(default, skip_serializing_if = "Option::is_none")]
24 pub hamiltonian_type: Option<String>,
25 pub qubits: Vec<String>,
27 #[serde(default, skip_serializing_if = "Option::is_none")]
29 pub compute_resource: Option<String>,
30 #[serde(default, skip_serializing_if = "Option::is_none")]
32 pub cpu_cores: Option<usize>,
33 #[serde(default, skip_serializing_if = "Option::is_none")]
35 pub seed: Option<u64>,
36 pub parameters: Parameters,
38 pub initial_states: Vec<Vec<String>>,
40 pub target_states: Targets,
42 pub optimization: Optimization,
44}
45
46#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
48pub struct Parameters {
49 #[serde(rename = "Delta", default, skip_serializing_if = "Option::is_none")]
51 pub delta: Option<Vec<f64>>,
52 #[serde(rename = "sigma_Delta", default, skip_serializing_if = "Option::is_none")]
54 pub sigma_delta: Option<Vec<f64>>,
55 #[serde(rename = "Omega_R_max")]
57 pub omega_r_max: Vec<f64>,
58 #[serde(rename = "sigma_Omega_R_max")]
60 pub sigma_omega_r_max: Vec<f64>,
61 pub pulse_duration: Vec<f64>,
63 pub point_in_pulse: Vec<usize>,
65 pub wf_type: Vec<String>,
67 pub wf_mode: Vec<WaveformMode>,
69 pub amplitude_envelope: Vec<String>,
71 pub amplitude_order: Vec<u32>,
73 pub coverage: Vec<Coverage>,
75 pub sw: Vec<f64>,
77 pub pulse_offset: Vec<f64>,
79 pub pulse_bandwidth: Vec<f64>,
83 pub ratio_factor: Vec<f64>,
85 pub profile_order: Vec<u32>,
88 pub n_para: Vec<usize>,
90 #[serde(rename = "J", default, skip_serializing_if = "Option::is_none")]
92 pub j: Option<Vec<Vec<f64>>>,
93 #[serde(default, skip_serializing_if = "Option::is_none")]
95 pub coupling_type: Option<String>,
96 #[serde(rename = "sigma_J", default, skip_serializing_if = "Option::is_none")]
98 pub sigma_j: Option<f64>,
99 #[serde(rename = "T1", default, skip_serializing_if = "Option::is_none")]
101 pub t1: Option<Vec<f64>>,
102 #[serde(rename = "T2", default, skip_serializing_if = "Option::is_none")]
104 pub t2: Option<Vec<f64>>,
105 #[serde(default, skip_serializing_if = "Option::is_none")]
107 pub anharmonicities: Option<Vec<f64>>,
108 #[serde(default, skip_serializing_if = "Option::is_none")]
110 pub zz_crosstalk: Option<Vec<Vec<f64>>>,
111 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub stark_shift_coeffs: Option<Vec<f64>>,
114}
115
116#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
118pub struct Optimization {
119 pub space: Space,
121 #[serde(default, skip_serializing_if = "Option::is_none")]
123 pub dissipation_mode: Option<Dissipation>,
124 #[serde(rename = "H0_snapshots")]
126 pub h0_snapshots: usize,
127 #[serde(rename = "Omega_R_snapshots")]
129 pub omega_r_snapshots: usize,
130 pub algorithm: String,
132 pub max_iter: usize,
134 pub targ_fid: f64,
136}
137
138#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
140#[serde(rename_all = "lowercase")]
141pub enum Space {
142 Hilbert,
144 Liouville,
146}
147
148#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
150pub enum Dissipation {
151 #[serde(rename = "non-dissipative")]
153 NonDissipative,
154 #[serde(rename = "dissipative")]
156 Dissipative,
157}
158
159#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
161pub enum WaveformMode {
162 #[serde(rename = "cart")]
164 Cart,
165 #[serde(rename = "polar")]
167 Polar,
168 #[serde(rename = "polar_phase")]
170 PolarPhase,
171}
172
173impl WaveformMode {
174 pub const ALL: [WaveformMode; 3] = [WaveformMode::Cart, WaveformMode::Polar, WaveformMode::PolarPhase];
176
177 pub fn name(self) -> &'static str {
179 match self {
180 WaveformMode::Cart => "cart",
181 WaveformMode::Polar => "polar",
182 WaveformMode::PolarPhase => "polar_phase",
183 }
184 }
185}
186
187#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
189#[serde(rename_all = "snake_case")]
190pub enum Coverage {
191 Single,
193 Broadband,
195 Selective,
197 BandSelective,
199}
200
201impl Coverage {
202 pub const ALL: [Coverage; 4] = [
204 Coverage::Single,
205 Coverage::Broadband,
206 Coverage::Selective,
207 Coverage::BandSelective,
208 ];
209
210 pub fn name(self) -> &'static str {
212 match self {
213 Coverage::Single => "single",
214 Coverage::Broadband => "broadband",
215 Coverage::Selective => "selective",
216 Coverage::BandSelective => "band_selective",
217 }
218 }
219}
220
221#[derive(Clone, Debug, PartialEq)]
223pub enum Targets {
224 Axis(Vec<Vec<String>>),
226 Gate(Vec<String>),
228 PhiBeta {
230 phi: Vec<Vec<String>>,
232 beta: Vec<Vec<f64>>,
234 },
235}
236
237impl Targets {
238 pub fn method(&self) -> &'static str {
240 match self {
241 Targets::Axis(_) => "Axis",
242 Targets::Gate(_) => "Gate",
243 Targets::PhiBeta { .. } => "Phi",
244 }
245 }
246
247 pub fn len(&self) -> usize {
249 match self {
250 Targets::Axis(v) => v.len(),
251 Targets::Gate(v) => v.len(),
252 Targets::PhiBeta { phi, .. } => phi.len(),
253 }
254 }
255
256 pub fn is_empty(&self) -> bool {
258 self.len() == 0
259 }
260
261 pub fn single_gate(&self) -> Option<&str> {
265 match self {
266 Targets::Gate(names) => {
267 let first = crate::setup::canonical_gate(names.first()?);
269 names
270 .iter()
271 .all(|n| crate::setup::canonical_gate(n) == first)
272 .then_some(first)
273 }
274 _ => None,
275 }
276 }
277}
278
279impl Serialize for Targets {
280 fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
281 match self {
282 Targets::Axis(v) => {
283 let mut m = s.serialize_map(Some(1))?;
284 m.serialize_entry("Axis", v)?;
285 m.end()
286 }
287 Targets::Gate(v) => {
288 let mut m = s.serialize_map(Some(1))?;
289 m.serialize_entry("Gate", v)?;
290 m.end()
291 }
292 Targets::PhiBeta { phi, beta } => {
293 let mut m = s.serialize_map(Some(2))?;
294 m.serialize_entry("Phi", phi)?;
295 m.serialize_entry("Beta", beta)?;
296 m.end()
297 }
298 }
299 }
300}
301
302#[derive(Deserialize)]
304struct RawTargets {
305 #[serde(rename = "Axis", default)]
306 axis: Option<Vec<Option<Vec<String>>>>,
307 #[serde(rename = "Gate", default)]
308 gate: Option<Vec<Option<String>>>,
309 #[serde(rename = "Phi", default)]
310 phi: Option<Vec<Option<Vec<String>>>>,
311 #[serde(rename = "Beta", default)]
312 beta: Option<Vec<Option<Vec<f64>>>>,
313}
314
315fn complete<T>(v: Option<Vec<Option<T>>>) -> Option<Vec<T>> {
317 let v = v?;
318 if v.is_empty() {
319 return None;
320 }
321 v.into_iter().collect()
322}
323
324impl<'de> Deserialize<'de> for Targets {
325 fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
326 let raw = RawTargets::deserialize(d)?;
327 if let Some(axis) = complete(raw.axis) {
328 return Ok(Targets::Axis(axis));
329 }
330 if let Some(gate) = complete(raw.gate) {
331 return Ok(Targets::Gate(gate));
332 }
333 if let (Some(phi), Some(beta)) = (complete(raw.phi), complete(raw.beta)) {
334 return Ok(Targets::PhiBeta { phi, beta });
335 }
336 Err(de::Error::custom(
337 "target_states needs a complete \"Axis\", \"Gate\", or \"Phi\" and \"Beta\" list",
338 ))
339 }
340}
341
342pub const STATE_AXES: [&str; 6] = ["Z", "-Z", "X", "-X", "Y", "-Y"];
344pub const ROTATION_AXES: [&str; 6] = ["x", "-x", "y", "-y", "z", "-z"];
346pub const HAMILTONIAN_TYPES: [&str; 3] = ["spin_chain", "superconducting", "duffing_transmon"];
348
349impl Config {
350 pub fn from_json(json: &str) -> Result<Config> {
352 serde_json::from_str(json).map_err(|e| Error::Config(e.to_string()))
353 }
354
355 pub fn to_json(&self) -> String {
357 serde_json::to_string_pretty(self).expect("a Config always serialises")
358 }
359
360 pub fn n_qubits(&self) -> usize {
362 self.qubits.len()
363 }
364
365 pub fn is_dissipative(&self) -> bool {
367 self.optimization.dissipation_mode == Some(Dissipation::Dissipative)
368 }
369
370 pub fn space(&self) -> Space {
372 if self.is_dissipative() {
373 Space::Liouville
374 } else {
375 self.optimization.space
376 }
377 }
378
379 pub fn validate(&self) -> Vec<String> {
381 validate::validate(self)
382 }
383
384 pub fn check(&self) -> Result<()> {
386 let problems = self.validate();
387 if problems.is_empty() {
388 Ok(())
389 } else {
390 Err(Error::Config(problems.join("; ")))
391 }
392 }
393}
394
395mod validate;