mod examples;
pub use examples::examples;
use serde::de::{self, Deserializer};
use serde::ser::{SerializeMap, Serializer};
use serde::{Deserialize, Serialize};
use crate::error::{Error, Result};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Config {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hamiltonian_type: Option<String>,
pub qubits: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub compute_resource: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cpu_cores: Option<usize>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub seed: Option<u64>,
pub parameters: Parameters,
pub initial_states: Vec<Vec<String>>,
pub target_states: Targets,
pub optimization: Optimization,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Parameters {
#[serde(rename = "Delta", default, skip_serializing_if = "Option::is_none")]
pub delta: Option<Vec<f64>>,
#[serde(rename = "sigma_Delta", default, skip_serializing_if = "Option::is_none")]
pub sigma_delta: Option<Vec<f64>>,
#[serde(rename = "Omega_R_max")]
pub omega_r_max: Vec<f64>,
#[serde(rename = "sigma_Omega_R_max")]
pub sigma_omega_r_max: Vec<f64>,
pub pulse_duration: Vec<f64>,
pub point_in_pulse: Vec<usize>,
pub wf_type: Vec<String>,
pub wf_mode: Vec<WaveformMode>,
pub amplitude_envelope: Vec<String>,
pub amplitude_order: Vec<u32>,
pub coverage: Vec<Coverage>,
pub sw: Vec<f64>,
pub pulse_offset: Vec<f64>,
pub pulse_bandwidth: Vec<f64>,
pub ratio_factor: Vec<f64>,
pub profile_order: Vec<u32>,
pub n_para: Vec<usize>,
#[serde(rename = "J", default, skip_serializing_if = "Option::is_none")]
pub j: Option<Vec<Vec<f64>>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub coupling_type: Option<String>,
#[serde(rename = "sigma_J", default, skip_serializing_if = "Option::is_none")]
pub sigma_j: Option<f64>,
#[serde(rename = "T1", default, skip_serializing_if = "Option::is_none")]
pub t1: Option<Vec<f64>>,
#[serde(rename = "T2", default, skip_serializing_if = "Option::is_none")]
pub t2: Option<Vec<f64>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub anharmonicities: Option<Vec<f64>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub zz_crosstalk: Option<Vec<Vec<f64>>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stark_shift_coeffs: Option<Vec<f64>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Optimization {
pub space: Space,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dissipation_mode: Option<Dissipation>,
#[serde(rename = "H0_snapshots")]
pub h0_snapshots: usize,
#[serde(rename = "Omega_R_snapshots")]
pub omega_r_snapshots: usize,
pub algorithm: String,
pub max_iter: usize,
pub targ_fid: f64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Space {
Hilbert,
Liouville,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Dissipation {
#[serde(rename = "non-dissipative")]
NonDissipative,
#[serde(rename = "dissipative")]
Dissipative,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum WaveformMode {
#[serde(rename = "cart")]
Cart,
#[serde(rename = "polar")]
Polar,
#[serde(rename = "polar_phase")]
PolarPhase,
}
impl WaveformMode {
pub const ALL: [WaveformMode; 3] = [WaveformMode::Cart, WaveformMode::Polar, WaveformMode::PolarPhase];
pub fn name(self) -> &'static str {
match self {
WaveformMode::Cart => "cart",
WaveformMode::Polar => "polar",
WaveformMode::PolarPhase => "polar_phase",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Coverage {
Single,
Broadband,
Selective,
BandSelective,
}
impl Coverage {
pub const ALL: [Coverage; 4] = [
Coverage::Single,
Coverage::Broadband,
Coverage::Selective,
Coverage::BandSelective,
];
pub fn name(self) -> &'static str {
match self {
Coverage::Single => "single",
Coverage::Broadband => "broadband",
Coverage::Selective => "selective",
Coverage::BandSelective => "band_selective",
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Targets {
Axis(Vec<Vec<String>>),
Gate(Vec<String>),
PhiBeta {
phi: Vec<Vec<String>>,
beta: Vec<Vec<f64>>,
},
}
impl Targets {
pub fn method(&self) -> &'static str {
match self {
Targets::Axis(_) => "Axis",
Targets::Gate(_) => "Gate",
Targets::PhiBeta { .. } => "Phi",
}
}
pub fn len(&self) -> usize {
match self {
Targets::Axis(v) => v.len(),
Targets::Gate(v) => v.len(),
Targets::PhiBeta { phi, .. } => phi.len(),
}
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn single_gate(&self) -> Option<&str> {
match self {
Targets::Gate(names) => {
let first = crate::setup::canonical_gate(names.first()?);
names
.iter()
.all(|n| crate::setup::canonical_gate(n) == first)
.then_some(first)
}
_ => None,
}
}
}
impl Serialize for Targets {
fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
match self {
Targets::Axis(v) => {
let mut m = s.serialize_map(Some(1))?;
m.serialize_entry("Axis", v)?;
m.end()
}
Targets::Gate(v) => {
let mut m = s.serialize_map(Some(1))?;
m.serialize_entry("Gate", v)?;
m.end()
}
Targets::PhiBeta { phi, beta } => {
let mut m = s.serialize_map(Some(2))?;
m.serialize_entry("Phi", phi)?;
m.serialize_entry("Beta", beta)?;
m.end()
}
}
}
}
#[derive(Deserialize)]
struct RawTargets {
#[serde(rename = "Axis", default)]
axis: Option<Vec<Option<Vec<String>>>>,
#[serde(rename = "Gate", default)]
gate: Option<Vec<Option<String>>>,
#[serde(rename = "Phi", default)]
phi: Option<Vec<Option<Vec<String>>>>,
#[serde(rename = "Beta", default)]
beta: Option<Vec<Option<Vec<f64>>>>,
}
fn complete<T>(v: Option<Vec<Option<T>>>) -> Option<Vec<T>> {
let v = v?;
if v.is_empty() {
return None;
}
v.into_iter().collect()
}
impl<'de> Deserialize<'de> for Targets {
fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
let raw = RawTargets::deserialize(d)?;
if let Some(axis) = complete(raw.axis) {
return Ok(Targets::Axis(axis));
}
if let Some(gate) = complete(raw.gate) {
return Ok(Targets::Gate(gate));
}
if let (Some(phi), Some(beta)) = (complete(raw.phi), complete(raw.beta)) {
return Ok(Targets::PhiBeta { phi, beta });
}
Err(de::Error::custom(
"target_states needs a complete \"Axis\", \"Gate\", or \"Phi\" and \"Beta\" list",
))
}
}
pub const STATE_AXES: [&str; 6] = ["Z", "-Z", "X", "-X", "Y", "-Y"];
pub const ROTATION_AXES: [&str; 6] = ["x", "-x", "y", "-y", "z", "-z"];
pub const HAMILTONIAN_TYPES: [&str; 3] = ["spin_chain", "superconducting", "duffing_transmon"];
impl Config {
pub fn from_json(json: &str) -> Result<Config> {
serde_json::from_str(json).map_err(|e| Error::Config(e.to_string()))
}
pub fn to_json(&self) -> String {
serde_json::to_string_pretty(self).expect("a Config always serialises")
}
pub fn n_qubits(&self) -> usize {
self.qubits.len()
}
pub fn is_dissipative(&self) -> bool {
self.optimization.dissipation_mode == Some(Dissipation::Dissipative)
}
pub fn space(&self) -> Space {
if self.is_dissipative() {
Space::Liouville
} else {
self.optimization.space
}
}
pub fn validate(&self) -> Vec<String> {
validate::validate(self)
}
pub fn check(&self) -> Result<()> {
let problems = self.validate();
if problems.is_empty() {
Ok(())
} else {
Err(Error::Config(problems.join("; ")))
}
}
}
mod validate;