vlsir/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/vlsir-662bfd41cd4ba7f4/out/
vlsir.spice.rs

1/// # Simulation Input
2///
3/// Consists of:
4/// * The design under test (DUT) circuit `ckt`,
5/// * Global simulator options, e.g. tolerance requirements,
6/// * A list of circuit-analyses to be completed,
7/// * An optional list of control-elements
8///
9#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
10#[allow(clippy::derive_partial_eq_without_eq)]
11#[derive(Clone, PartialEq, ::prost::Message)]
12pub struct SimInput {
13    /// # Circuit Input
14    /// The DUT circuit-package under test
15    #[prost(message, optional, tag = "1")]
16    pub pkg: ::core::option::Option<super::circuit::Package>,
17    /// Top-level module (name)
18    #[prost(string, tag = "2")]
19    pub top: ::prost::alloc::string::String,
20    /// # Simulation Configuration Input
21    /// List of simulator options
22    #[prost(message, repeated, tag = "10")]
23    pub opts: ::prost::alloc::vec::Vec<SimOptions>,
24    /// List of circuit analyses
25    #[prost(message, repeated, tag = "11")]
26    pub an: ::prost::alloc::vec::Vec<Analysis>,
27    /// Control elements.
28    /// `SimInput` level controls are applied to *all* analyses.
29    #[prost(message, repeated, tag = "12")]
30    pub ctrls: ::prost::alloc::vec::Vec<Control>,
31}
32/// # Simulation Result
33/// A list of results per analysis
34#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
35#[allow(clippy::derive_partial_eq_without_eq)]
36#[derive(Clone, PartialEq, ::prost::Message)]
37pub struct SimResult {
38    #[prost(message, repeated, tag = "1")]
39    pub an: ::prost::alloc::vec::Vec<AnalysisResult>,
40}
41/// # Simulator Options
42/// Global, cross-analysis settings.
43#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
44#[allow(clippy::derive_partial_eq_without_eq)]
45#[derive(Clone, PartialEq, ::prost::Message)]
46pub struct SimOptions {
47    /// Option name
48    #[prost(string, tag = "1")]
49    pub name: ::prost::alloc::string::String,
50    /// Option argument
51    #[prost(message, optional, tag = "2")]
52    pub value: ::core::option::Option<super::utils::ParamValue>,
53}
54/// # Analysis Union
55///
56/// Enumerated analysis-input types.
57/// Primary component of a `Sim`.
58///
59#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
60#[allow(clippy::derive_partial_eq_without_eq)]
61#[derive(Clone, PartialEq, ::prost::Message)]
62pub struct Analysis {
63    #[prost(oneof = "analysis::An", tags = "1, 2, 3, 4, 5, 10, 11, 20")]
64    pub an: ::core::option::Option<analysis::An>,
65}
66/// Nested message and enum types in `Analysis`.
67pub mod analysis {
68    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
69    #[allow(clippy::derive_partial_eq_without_eq)]
70    #[derive(Clone, PartialEq, ::prost::Oneof)]
71    pub enum An {
72        #[prost(message, tag = "1")]
73        Op(super::OpInput),
74        #[prost(message, tag = "2")]
75        Dc(super::DcInput),
76        #[prost(message, tag = "3")]
77        Tran(super::TranInput),
78        #[prost(message, tag = "4")]
79        Ac(super::AcInput),
80        #[prost(message, tag = "5")]
81        Noise(super::NoiseInput),
82        #[prost(message, tag = "10")]
83        Sweep(super::SweepInput),
84        #[prost(message, tag = "11")]
85        Monte(super::MonteInput),
86        #[prost(message, tag = "20")]
87        Custom(super::CustomAnalysisInput),
88    }
89}
90/// # Analysis Results Union
91///
92/// Union of result-types for each `Analysis`.
93#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
94#[allow(clippy::derive_partial_eq_without_eq)]
95#[derive(Clone, PartialEq, ::prost::Message)]
96pub struct AnalysisResult {
97    #[prost(oneof = "analysis_result::An", tags = "1, 2, 3, 4, 5, 10, 11, 20")]
98    pub an: ::core::option::Option<analysis_result::An>,
99}
100/// Nested message and enum types in `AnalysisResult`.
101pub mod analysis_result {
102    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
103    #[allow(clippy::derive_partial_eq_without_eq)]
104    #[derive(Clone, PartialEq, ::prost::Oneof)]
105    pub enum An {
106        #[prost(message, tag = "1")]
107        Op(super::OpResult),
108        #[prost(message, tag = "2")]
109        Dc(super::DcResult),
110        #[prost(message, tag = "3")]
111        Tran(super::TranResult),
112        #[prost(message, tag = "4")]
113        Ac(super::AcResult),
114        #[prost(message, tag = "5")]
115        Noise(super::NoiseResult),
116        #[prost(message, tag = "10")]
117        Sweep(super::SweepResult),
118        #[prost(message, tag = "11")]
119        Monte(super::MonteResult),
120        #[prost(message, tag = "20")]
121        Custom(super::CustomAnalysisResult),
122    }
123}
124/// # Operating Point Inputs
125#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
126#[allow(clippy::derive_partial_eq_without_eq)]
127#[derive(Clone, PartialEq, ::prost::Message)]
128pub struct OpInput {
129    /// (Optional) Analysis Name
130    #[prost(string, tag = "1")]
131    pub analysis_name: ::prost::alloc::string::String,
132    /// Control Elements
133    #[prost(message, repeated, tag = "5")]
134    pub ctrls: ::prost::alloc::vec::Vec<Control>,
135}
136/// Operating Point Results
137#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
138#[allow(clippy::derive_partial_eq_without_eq)]
139#[derive(Clone, PartialEq, ::prost::Message)]
140pub struct OpResult {
141    /// (Optional) Analysis Name
142    #[prost(string, tag = "1")]
143    pub analysis_name: ::prost::alloc::string::String,
144    /// Signal names and quantities
145    ///
146    /// FIXME: use `Signal` repeated Signal signals = 3;
147    #[prost(string, repeated, tag = "3")]
148    pub signals: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
149    /// Data values, in `signals` order
150    #[prost(double, repeated, tag = "5")]
151    pub data: ::prost::alloc::vec::Vec<f64>,
152}
153/// # Dc Sweep Inputs
154#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
155#[allow(clippy::derive_partial_eq_without_eq)]
156#[derive(Clone, PartialEq, ::prost::Message)]
157pub struct DcInput {
158    /// (Optional) Analysis Name
159    #[prost(string, tag = "1")]
160    pub analysis_name: ::prost::alloc::string::String,
161    /// Sweep Variable Name
162    #[prost(string, tag = "2")]
163    pub indep_name: ::prost::alloc::string::String,
164    /// Sweep Data
165    #[prost(message, optional, tag = "3")]
166    pub sweep: ::core::option::Option<Sweep>,
167    /// Control Elements
168    #[prost(message, repeated, tag = "5")]
169    pub ctrls: ::prost::alloc::vec::Vec<Control>,
170}
171/// # Dc Sweep Result
172///
173/// Provides result data for a `Dc` analysis.
174#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
175#[allow(clippy::derive_partial_eq_without_eq)]
176#[derive(Clone, PartialEq, ::prost::Message)]
177pub struct DcResult {
178    /// (Optional) Analysis Name
179    #[prost(string, tag = "1")]
180    pub analysis_name: ::prost::alloc::string::String,
181    /// Independent Variable Name
182    #[prost(string, tag = "2")]
183    pub indep_name: ::prost::alloc::string::String,
184    /// Ordered signal names and quantities
185    ///
186    /// FIXME: use `Signal` repeated Signal signals = 3;
187    #[prost(string, repeated, tag = "3")]
188    pub signals: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
189    /// Primary Data Field
190    #[prost(double, repeated, tag = "5")]
191    pub data: ::prost::alloc::vec::Vec<f64>,
192    /// Scalar measurement values
193    #[prost(map = "string, double", tag = "10")]
194    pub measurements: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
195}
196/// # Transient Analysis Inputs
197#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
198#[allow(clippy::derive_partial_eq_without_eq)]
199#[derive(Clone, PartialEq, ::prost::Message)]
200pub struct TranInput {
201    /// (Optional) Analysis Name
202    #[prost(string, tag = "1")]
203    pub analysis_name: ::prost::alloc::string::String,
204    /// Stop Time
205    #[prost(double, tag = "2")]
206    pub tstop: f64,
207    /// Time-step requirement or recommendation
208    #[prost(double, tag = "3")]
209    pub tstep: f64,
210    /// Initial Conditions. Mapping in the form of {signal-name: value}
211    #[prost(map = "string, double", tag = "4")]
212    pub ic: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
213    /// Control Elements
214    #[prost(message, repeated, tag = "5")]
215    pub ctrls: ::prost::alloc::vec::Vec<Control>,
216}
217/// # Transient Analysis Results
218#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
219#[allow(clippy::derive_partial_eq_without_eq)]
220#[derive(Clone, PartialEq, ::prost::Message)]
221pub struct TranResult {
222    /// (Optional) Analysis Name
223    #[prost(string, tag = "1")]
224    pub analysis_name: ::prost::alloc::string::String,
225    /// Ordered signal names and quantities
226    ///
227    /// FIXME: use `Signal` repeated Signal signals = 3;
228    #[prost(string, repeated, tag = "3")]
229    pub signals: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
230    /// Primary Data Field
231    #[prost(double, repeated, tag = "5")]
232    pub data: ::prost::alloc::vec::Vec<f64>,
233    /// Scalar measurement values
234    #[prost(map = "string, double", tag = "10")]
235    pub measurements: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
236}
237/// # Complex Number
238#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
239#[allow(clippy::derive_partial_eq_without_eq)]
240#[derive(Clone, PartialEq, ::prost::Message)]
241pub struct ComplexNum {
242    #[prost(double, tag = "1")]
243    pub re: f64,
244    #[prost(double, tag = "2")]
245    pub im: f64,
246}
247/// # AC Analysis Inputs
248#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
249#[allow(clippy::derive_partial_eq_without_eq)]
250#[derive(Clone, PartialEq, ::prost::Message)]
251pub struct AcInput {
252    /// (Optional) Analysis Name
253    #[prost(string, tag = "1")]
254    pub analysis_name: ::prost::alloc::string::String,
255    /// Start (min) frequency in Hz
256    #[prost(double, tag = "2")]
257    pub fstart: f64,
258    /// Stop (max) frequency in Hz
259    #[prost(double, tag = "3")]
260    pub fstop: f64,
261    /// Number of points per interval of frequency sweep.
262    #[prost(uint64, tag = "4")]
263    pub npts: u64,
264    /// Control Elements
265    #[prost(message, repeated, tag = "5")]
266    pub ctrls: ::prost::alloc::vec::Vec<Control>,
267}
268/// # AC Analysis Results
269///
270/// AC analysis produces a set of complex-valued results,
271/// along with a single real-valued independent variable, which is always frequency.
272///
273#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
274#[allow(clippy::derive_partial_eq_without_eq)]
275#[derive(Clone, PartialEq, ::prost::Message)]
276pub struct AcResult {
277    /// (Optional) Analysis Name
278    #[prost(string, tag = "1")]
279    pub analysis_name: ::prost::alloc::string::String,
280    /// Frequency Vector
281    #[prost(double, repeated, tag = "2")]
282    pub freq: ::prost::alloc::vec::Vec<f64>,
283    /// Ordered signal names and quantities
284    ///
285    /// FIXME: use `Signal` repeated Signal signals = 3;
286    #[prost(string, repeated, tag = "3")]
287    pub signals: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
288    /// Primary Data Field. Of length `len(signals) * num_points`.
289    #[prost(message, repeated, tag = "5")]
290    pub data: ::prost::alloc::vec::Vec<ComplexNum>,
291    /// Scalar measurement values
292    #[prost(map = "string, double", tag = "10")]
293    pub measurements: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
294}
295/// # Noise Analysis Inputs
296#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
297#[allow(clippy::derive_partial_eq_without_eq)]
298#[derive(Clone, PartialEq, ::prost::Message)]
299pub struct NoiseInput {
300    /// (Optional) Analysis Name
301    #[prost(string, tag = "1")]
302    pub analysis_name: ::prost::alloc::string::String,
303    /// Output Signal Name
304    #[prost(string, tag = "2")]
305    pub output_p: ::prost::alloc::string::String,
306    /// Output Signal Name, Negative.
307    /// Optional, defaults to VSS.
308    #[prost(string, tag = "3")]
309    pub output_n: ::prost::alloc::string::String,
310    /// Input Source Name
311    #[prost(string, tag = "4")]
312    pub input_source: ::prost::alloc::string::String,
313    /// Start (min) frequency in Hz
314    #[prost(double, tag = "10")]
315    pub fstart: f64,
316    /// Stop (max) frequency in Hz
317    #[prost(double, tag = "11")]
318    pub fstop: f64,
319    /// Number of points per interval of frequency sweep.
320    #[prost(uint64, tag = "12")]
321    pub npts: u64,
322    /// Control Elements
323    #[prost(message, repeated, tag = "20")]
324    pub ctrls: ::prost::alloc::vec::Vec<Control>,
325}
326/// # Noise Analysis Results
327///
328/// Noise analysis produces a set of complex-valued results,
329/// along with a single real-valued independent variable, which is always frequency.
330///
331#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
332#[allow(clippy::derive_partial_eq_without_eq)]
333#[derive(Clone, PartialEq, ::prost::Message)]
334pub struct NoiseResult {
335    /// (Optional) Analysis Name
336    #[prost(string, tag = "1")]
337    pub analysis_name: ::prost::alloc::string::String,
338    /// Ordered signal names and quantities
339    ///
340    /// FIXME: use `Signal` repeated Signal signals = 3;
341    #[prost(string, repeated, tag = "3")]
342    pub signals: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
343    /// Primary Data Values
344    /// Noise values are specified in per-Hz units, i.e. V^2/Hz for voltage noise, A^2/Hz for current noise.
345    #[prost(double, repeated, tag = "5")]
346    pub data: ::prost::alloc::vec::Vec<f64>,
347    /// Integrated noise values, mapped from signal name to value.
348    #[prost(map = "string, double", tag = "10")]
349    pub integrated_noise: ::std::collections::HashMap<
350        ::prost::alloc::string::String,
351        f64,
352    >,
353    /// Scalar measurement values
354    #[prost(map = "string, double", tag = "11")]
355    pub measurements: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
356}
357/// # Sweep
358///
359/// The "for loop" of Spice analyses.
360/// Defines a scalar variable `var` to be swept, and a set of inner child-analyses
361/// to be performed for each value of `var`.
362/// `Sweeps` themselves are `Analyses`, and therefore can be arbitrarily nested.
363///
364#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
365#[allow(clippy::derive_partial_eq_without_eq)]
366#[derive(Clone, PartialEq, ::prost::Message)]
367pub struct SweepInput {
368    /// (Optional) Analysis Name
369    #[prost(string, tag = "1")]
370    pub analysis_name: ::prost::alloc::string::String,
371    /// Sweep-variable name
372    #[prost(string, tag = "2")]
373    pub variable: ::prost::alloc::string::String,
374    /// Sweep-values
375    #[prost(message, optional, tag = "3")]
376    pub sweep: ::core::option::Option<Sweep>,
377    /// Child Analyses
378    #[prost(message, repeated, tag = "4")]
379    pub an: ::prost::alloc::vec::Vec<Analysis>,
380    /// Control Elements
381    #[prost(message, repeated, tag = "5")]
382    pub ctrls: ::prost::alloc::vec::Vec<Control>,
383}
384/// # Sweep Results
385#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
386#[allow(clippy::derive_partial_eq_without_eq)]
387#[derive(Clone, PartialEq, ::prost::Message)]
388pub struct SweepResult {
389    /// (Optional) Analysis Name
390    #[prost(string, tag = "1")]
391    pub analysis_name: ::prost::alloc::string::String,
392    /// Sweep-variable name
393    #[prost(string, tag = "2")]
394    pub variable: ::prost::alloc::string::String,
395    /// Sweep-values
396    #[prost(message, optional, tag = "3")]
397    pub sweep: ::core::option::Option<Sweep>,
398    /// Child Analysis Results
399    /// FIXME: should these just be a flattened list, or organized by sweep-value
400    #[prost(message, repeated, tag = "4")]
401    pub an: ::prost::alloc::vec::Vec<AnalysisResult>,
402}
403/// # Monte Carlo Simulation Input
404///
405/// Define a set of child analyses to be simulated across `npts` randomly-generated circuit variations.
406///
407///
408#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
409#[allow(clippy::derive_partial_eq_without_eq)]
410#[derive(Clone, PartialEq, ::prost::Message)]
411pub struct MonteInput {
412    /// (Optional) Analysis Name
413    #[prost(string, tag = "1")]
414    pub analysis_name: ::prost::alloc::string::String,
415    /// Number of points
416    #[prost(int64, tag = "2")]
417    pub npts: i64,
418    /// Random-number seed
419    #[prost(int64, tag = "3")]
420    pub seed: i64,
421    /// Child Analyses
422    #[prost(message, repeated, tag = "4")]
423    pub an: ::prost::alloc::vec::Vec<Analysis>,
424    /// Control Elements
425    #[prost(message, repeated, tag = "5")]
426    pub ctrls: ::prost::alloc::vec::Vec<Control>,
427}
428/// # Sweep Results
429#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
430#[allow(clippy::derive_partial_eq_without_eq)]
431#[derive(Clone, PartialEq, ::prost::Message)]
432pub struct MonteResult {
433    /// (Optional) Analysis Name
434    #[prost(string, tag = "1")]
435    pub analysis_name: ::prost::alloc::string::String,
436    /// Sweep-variable name
437    #[prost(string, tag = "2")]
438    pub variable: ::prost::alloc::string::String,
439    /// Sweep-values
440    #[prost(message, optional, tag = "3")]
441    pub sweep: ::core::option::Option<Sweep>,
442    /// Child Analysis Results
443    /// FIXME: should these just be a flattened list, or organized by iteration
444    #[prost(message, repeated, tag = "4")]
445    pub an: ::prost::alloc::vec::Vec<AnalysisResult>,
446}
447/// # Custom Analysis Input
448///
449/// String-defined, non-first-class analysis statement.
450/// Primarily for simulator-specific specialty analyses.
451/// Note the paired `Result` type is empty,
452/// as the schema has no means to comprehend externally-defined
453/// analysis data-shapes
454///
455#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
456#[allow(clippy::derive_partial_eq_without_eq)]
457#[derive(Clone, PartialEq, ::prost::Message)]
458pub struct CustomAnalysisInput {
459    /// (Optional) Analysis Name
460    #[prost(string, tag = "1")]
461    pub analysis_name: ::prost::alloc::string::String,
462    /// String-literal analysis command
463    #[prost(string, tag = "2")]
464    pub cmd: ::prost::alloc::string::String,
465    /// Control Elements
466    #[prost(message, repeated, tag = "5")]
467    pub ctrls: ::prost::alloc::vec::Vec<Control>,
468}
469/// # Custom Analysis Result
470///
471/// Does not return any data. Defined solely for filling slots in lists of analysis-results.
472#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
473#[allow(clippy::derive_partial_eq_without_eq)]
474#[derive(Clone, PartialEq, ::prost::Message)]
475pub struct CustomAnalysisResult {}
476/// # Sweep Union
477#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
478#[allow(clippy::derive_partial_eq_without_eq)]
479#[derive(Clone, PartialEq, ::prost::Message)]
480pub struct Sweep {
481    #[prost(oneof = "sweep::Tp", tags = "1, 2, 3")]
482    pub tp: ::core::option::Option<sweep::Tp>,
483}
484/// Nested message and enum types in `Sweep`.
485pub mod sweep {
486    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
487    #[allow(clippy::derive_partial_eq_without_eq)]
488    #[derive(Clone, PartialEq, ::prost::Oneof)]
489    pub enum Tp {
490        #[prost(message, tag = "1")]
491        Linear(super::LinearSweep),
492        #[prost(message, tag = "2")]
493        Log(super::LogSweep),
494        #[prost(message, tag = "3")]
495        Points(super::PointSweep),
496    }
497}
498/// # Linear Sweep
499#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
500#[allow(clippy::derive_partial_eq_without_eq)]
501#[derive(Clone, PartialEq, ::prost::Message)]
502pub struct LinearSweep {
503    #[prost(double, tag = "1")]
504    pub start: f64,
505    #[prost(double, tag = "2")]
506    pub stop: f64,
507    #[prost(double, tag = "3")]
508    pub step: f64,
509}
510/// # Log Sweep
511#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
512#[allow(clippy::derive_partial_eq_without_eq)]
513#[derive(Clone, PartialEq, ::prost::Message)]
514pub struct LogSweep {
515    #[prost(double, tag = "1")]
516    pub start: f64,
517    #[prost(double, tag = "2")]
518    pub stop: f64,
519    /// FIXME: move to int
520    #[prost(double, tag = "3")]
521    pub npts: f64,
522}
523/// # Enumerated (List of Points) Sweep
524#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
525#[allow(clippy::derive_partial_eq_without_eq)]
526#[derive(Clone, PartialEq, ::prost::Message)]
527pub struct PointSweep {
528    #[prost(double, repeated, tag = "1")]
529    pub points: ::prost::alloc::vec::Vec<f64>,
530    #[prost(double, tag = "2")]
531    pub stop: f64,
532    #[prost(double, tag = "3")]
533    pub npts: f64,
534}
535/// / # Control Elements Union
536#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
537#[allow(clippy::derive_partial_eq_without_eq)]
538#[derive(Clone, PartialEq, ::prost::Message)]
539pub struct Control {
540    #[prost(oneof = "control::Ctrl", tags = "1, 2, 5, 6, 7, 10")]
541    pub ctrl: ::core::option::Option<control::Ctrl>,
542}
543/// Nested message and enum types in `Control`.
544pub mod control {
545    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
546    #[allow(clippy::derive_partial_eq_without_eq)]
547    #[derive(Clone, PartialEq, ::prost::Oneof)]
548    pub enum Ctrl {
549        #[prost(message, tag = "1")]
550        Include(super::Include),
551        #[prost(message, tag = "2")]
552        Lib(super::LibInclude),
553        #[prost(message, tag = "5")]
554        Save(super::Save),
555        #[prost(message, tag = "6")]
556        Meas(super::Meas),
557        #[prost(message, tag = "7")]
558        Param(super::super::utils::Param),
559        #[prost(string, tag = "10")]
560        Literal(::prost::alloc::string::String),
561    }
562}
563/// # Signal-Saving Controls
564#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
565#[allow(clippy::derive_partial_eq_without_eq)]
566#[derive(Clone, PartialEq, ::prost::Message)]
567pub struct Save {
568    #[prost(oneof = "save::Save", tags = "1, 2")]
569    pub save: ::core::option::Option<save::Save>,
570}
571/// Nested message and enum types in `Save`.
572pub mod save {
573    /// Enumerated Modes
574    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
575    #[derive(
576        Clone,
577        Copy,
578        Debug,
579        PartialEq,
580        Eq,
581        Hash,
582        PartialOrd,
583        Ord,
584        ::prost::Enumeration
585    )]
586    #[repr(i32)]
587    pub enum SaveMode {
588        None = 0,
589        All = 1,
590    }
591    impl SaveMode {
592        /// String value of the enum field names used in the ProtoBuf definition.
593        ///
594        /// The values are not transformed in any way and thus are considered stable
595        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
596        pub fn as_str_name(&self) -> &'static str {
597            match self {
598                SaveMode::None => "NONE",
599                SaveMode::All => "ALL",
600            }
601        }
602        /// Creates an enum from field names used in the ProtoBuf definition.
603        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
604            match value {
605                "NONE" => Some(Self::None),
606                "ALL" => Some(Self::All),
607                _ => None,
608            }
609        }
610    }
611    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
612    #[allow(clippy::derive_partial_eq_without_eq)]
613    #[derive(Clone, PartialEq, ::prost::Oneof)]
614    pub enum Save {
615        #[prost(enumeration = "SaveMode", tag = "1")]
616        Mode(i32),
617        #[prost(string, tag = "2")]
618        Signal(::prost::alloc::string::String),
619    }
620}
621/// # Include External Content
622#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
623#[allow(clippy::derive_partial_eq_without_eq)]
624#[derive(Clone, PartialEq, ::prost::Message)]
625pub struct Include {
626    /// File-system path
627    /// FIXME: add more methods of specifying this
628    #[prost(string, tag = "1")]
629    pub path: ::prost::alloc::string::String,
630}
631/// # Library "Section" Include
632///
633/// Commonly used for "PVT corner" inclusion, in which a single includable file
634/// often defines several named "sections", e.g. "TT", "FF", "SS",
635/// only one of which at a time may be included in a simulation.
636#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
637#[allow(clippy::derive_partial_eq_without_eq)]
638#[derive(Clone, PartialEq, ::prost::Message)]
639pub struct LibInclude {
640    /// File-system path
641    /// FIXME: add more methods of specifying this
642    #[prost(string, tag = "1")]
643    pub path: ::prost::alloc::string::String,
644    /// Section name
645    #[prost(string, tag = "2")]
646    pub section: ::prost::alloc::string::String,
647}
648/// # Scalar Measurement
649#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
650#[allow(clippy::derive_partial_eq_without_eq)]
651#[derive(Clone, PartialEq, ::prost::Message)]
652pub struct Meas {
653    /// Analysis Name (FIXME: or analysis-type)
654    #[prost(string, tag = "1")]
655    pub analysis_type: ::prost::alloc::string::String,
656    /// Measurement Name
657    #[prost(string, tag = "2")]
658    pub name: ::prost::alloc::string::String,
659    /// Expression to be evaluated
660    #[prost(string, tag = "3")]
661    pub expr: ::prost::alloc::string::String,
662}
663/// # Signal Declaration
664///
665/// Declares a `Signal` name and type for output data.
666#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
667#[allow(clippy::derive_partial_eq_without_eq)]
668#[derive(Clone, PartialEq, ::prost::Message)]
669pub struct Signal {
670    /// Signal Name
671    #[prost(string, tag = "1")]
672    pub name: ::prost::alloc::string::String,
673    #[prost(enumeration = "signal::Quantity", tag = "2")]
674    pub quantity: i32,
675}
676/// Nested message and enum types in `Signal`.
677pub mod signal {
678    /// Physical Quantity
679    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
680    #[derive(
681        Clone,
682        Copy,
683        Debug,
684        PartialEq,
685        Eq,
686        Hash,
687        PartialOrd,
688        Ord,
689        ::prost::Enumeration
690    )]
691    #[repr(i32)]
692    pub enum Quantity {
693        Voltage = 0,
694        Current = 1,
695        None = 3,
696    }
697    impl Quantity {
698        /// String value of the enum field names used in the ProtoBuf definition.
699        ///
700        /// The values are not transformed in any way and thus are considered stable
701        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
702        pub fn as_str_name(&self) -> &'static str {
703            match self {
704                Quantity::Voltage => "VOLTAGE",
705                Quantity::Current => "CURRENT",
706                Quantity::None => "NONE",
707            }
708        }
709        /// Creates an enum from field names used in the ProtoBuf definition.
710        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
711            match value {
712                "VOLTAGE" => Some(Self::Voltage),
713                "CURRENT" => Some(Self::Current),
714                "NONE" => Some(Self::None),
715                _ => None,
716            }
717        }
718    }
719}
vlsir/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/vlsir-662bfd41cd4ba7f4/out/vlsir.spice.rs

vlsir/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/vlsir-662bfd41cd4ba7f4/out/
vlsir.spice.rs
