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>,
81 pub ratio_factor: Vec<f64>,
83 pub profile_order: Vec<u32>,
85 pub n_para: Vec<usize>,
87 #[serde(rename = "J", default, skip_serializing_if = "Option::is_none")]
89 pub j: Option<Vec<Vec<f64>>>,
90 #[serde(default, skip_serializing_if = "Option::is_none")]
92 pub coupling_type: Option<String>,
93 #[serde(rename = "sigma_J", default, skip_serializing_if = "Option::is_none")]
95 pub sigma_j: Option<f64>,
96 #[serde(rename = "T1", default, skip_serializing_if = "Option::is_none")]
98 pub t1: Option<Vec<f64>>,
99 #[serde(rename = "T2", default, skip_serializing_if = "Option::is_none")]
101 pub t2: Option<Vec<f64>>,
102 #[serde(default, skip_serializing_if = "Option::is_none")]
104 pub anharmonicities: Option<Vec<f64>>,
105 #[serde(default, skip_serializing_if = "Option::is_none")]
107 pub zz_crosstalk: Option<Vec<Vec<f64>>>,
108 #[serde(default, skip_serializing_if = "Option::is_none")]
110 pub stark_shift_coeffs: Option<Vec<f64>>,
111}
112
113#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
115pub struct Optimization {
116 pub space: Space,
118 #[serde(default, skip_serializing_if = "Option::is_none")]
120 pub dissipation_mode: Option<Dissipation>,
121 #[serde(rename = "H0_snapshots")]
123 pub h0_snapshots: usize,
124 #[serde(rename = "Omega_R_snapshots")]
126 pub omega_r_snapshots: usize,
127 pub algorithm: String,
129 pub max_iter: usize,
131 pub targ_fid: f64,
133}
134
135#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
137#[serde(rename_all = "lowercase")]
138pub enum Space {
139 Hilbert,
141 Liouville,
143}
144
145#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
147pub enum Dissipation {
148 #[serde(rename = "non-dissipative")]
150 NonDissipative,
151 #[serde(rename = "dissipative")]
153 Dissipative,
154}
155
156#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
158pub enum WaveformMode {
159 #[serde(rename = "cart")]
161 Cart,
162 #[serde(rename = "polar")]
164 Polar,
165 #[serde(rename = "polar_phase")]
167 PolarPhase,
168}
169
170impl WaveformMode {
171 pub const ALL: [WaveformMode; 3] = [WaveformMode::Cart, WaveformMode::Polar, WaveformMode::PolarPhase];
173
174 pub fn name(self) -> &'static str {
176 match self {
177 WaveformMode::Cart => "cart",
178 WaveformMode::Polar => "polar",
179 WaveformMode::PolarPhase => "polar_phase",
180 }
181 }
182}
183
184#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
186#[serde(rename_all = "snake_case")]
187pub enum Coverage {
188 Single,
190 Broadband,
192 Selective,
194 BandSelective,
196}
197
198impl Coverage {
199 pub const ALL: [Coverage; 4] = [
201 Coverage::Single,
202 Coverage::Broadband,
203 Coverage::Selective,
204 Coverage::BandSelective,
205 ];
206
207 pub fn name(self) -> &'static str {
209 match self {
210 Coverage::Single => "single",
211 Coverage::Broadband => "broadband",
212 Coverage::Selective => "selective",
213 Coverage::BandSelective => "band_selective",
214 }
215 }
216}
217
218#[derive(Clone, Debug, PartialEq)]
220pub enum Targets {
221 Axis(Vec<Vec<String>>),
223 Gate(Vec<String>),
225 PhiBeta {
227 phi: Vec<Vec<String>>,
229 beta: Vec<Vec<f64>>,
231 },
232}
233
234impl Targets {
235 pub fn method(&self) -> &'static str {
237 match self {
238 Targets::Axis(_) => "Axis",
239 Targets::Gate(_) => "Gate",
240 Targets::PhiBeta { .. } => "Phi",
241 }
242 }
243
244 pub fn len(&self) -> usize {
246 match self {
247 Targets::Axis(v) => v.len(),
248 Targets::Gate(v) => v.len(),
249 Targets::PhiBeta { phi, .. } => phi.len(),
250 }
251 }
252
253 pub fn is_empty(&self) -> bool {
255 self.len() == 0
256 }
257}
258
259impl Serialize for Targets {
260 fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
261 match self {
262 Targets::Axis(v) => {
263 let mut m = s.serialize_map(Some(1))?;
264 m.serialize_entry("Axis", v)?;
265 m.end()
266 }
267 Targets::Gate(v) => {
268 let mut m = s.serialize_map(Some(1))?;
269 m.serialize_entry("Gate", v)?;
270 m.end()
271 }
272 Targets::PhiBeta { phi, beta } => {
273 let mut m = s.serialize_map(Some(2))?;
274 m.serialize_entry("Phi", phi)?;
275 m.serialize_entry("Beta", beta)?;
276 m.end()
277 }
278 }
279 }
280}
281
282#[derive(Deserialize)]
284struct RawTargets {
285 #[serde(rename = "Axis", default)]
286 axis: Option<Vec<Option<Vec<String>>>>,
287 #[serde(rename = "Gate", default)]
288 gate: Option<Vec<Option<String>>>,
289 #[serde(rename = "Phi", default)]
290 phi: Option<Vec<Option<Vec<String>>>>,
291 #[serde(rename = "Beta", default)]
292 beta: Option<Vec<Option<Vec<f64>>>>,
293}
294
295fn complete<T>(v: Option<Vec<Option<T>>>) -> Option<Vec<T>> {
297 let v = v?;
298 if v.is_empty() {
299 return None;
300 }
301 v.into_iter().collect()
302}
303
304impl<'de> Deserialize<'de> for Targets {
305 fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
306 let raw = RawTargets::deserialize(d)?;
307 if let Some(axis) = complete(raw.axis) {
308 return Ok(Targets::Axis(axis));
309 }
310 if let Some(gate) = complete(raw.gate) {
311 return Ok(Targets::Gate(gate));
312 }
313 if let (Some(phi), Some(beta)) = (complete(raw.phi), complete(raw.beta)) {
314 return Ok(Targets::PhiBeta { phi, beta });
315 }
316 Err(de::Error::custom(
317 "target_states needs a complete \"Axis\", \"Gate\", or \"Phi\" and \"Beta\" list",
318 ))
319 }
320}
321
322pub const STATE_AXES: [&str; 6] = ["Z", "-Z", "X", "-X", "Y", "-Y"];
324pub const ROTATION_AXES: [&str; 6] = ["x", "-x", "y", "-y", "z", "-z"];
326pub const HAMILTONIAN_TYPES: [&str; 3] = ["spin_chain", "superconducting", "duffing_transmon"];
328
329impl Config {
330 pub fn from_json(json: &str) -> Result<Config> {
332 serde_json::from_str(json).map_err(|e| Error::Config(e.to_string()))
333 }
334
335 pub fn to_json(&self) -> String {
337 serde_json::to_string_pretty(self).expect("a Config always serialises")
338 }
339
340 pub fn n_qubits(&self) -> usize {
342 self.qubits.len()
343 }
344
345 pub fn is_dissipative(&self) -> bool {
347 self.optimization.dissipation_mode == Some(Dissipation::Dissipative)
348 }
349
350 pub fn space(&self) -> Space {
352 if self.is_dissipative() {
353 Space::Liouville
354 } else {
355 self.optimization.space
356 }
357 }
358
359 pub fn validate(&self) -> Vec<String> {
361 validate::validate(self)
362 }
363
364 pub fn check(&self) -> Result<()> {
366 let problems = self.validate();
367 if problems.is_empty() {
368 Ok(())
369 } else {
370 Err(Error::Config(problems.join("; ")))
371 }
372 }
373}
374
375mod validate;