Struct OperatingConditions 

pub struct OperatingConditions<C: Ctx> {
    pub name: String,
    pub extra_ctx: C::Other,
    pub attributes: Attributes,
    pub calc_mode: Option<String>,
    pub parameteri: Option<f64>,
    pub process: f64,
    pub process_label: Option<String>,
    pub temperature: f64,
    pub tree_type: Option<TreeType>,
    pub voltage: f64,
    /* private fields */
}

Use this group to define operating conditions;

that is, process, voltage, and temperature. You define an operating_conditions group at the library-level, as shown here: Reference

Fields

name: String

name

extra_ctx: C::Other

attributes: Attributes

group undefined attributes

calc_mode: Option<String>

An optional attribute, you can use calc_mode to specify an associated process mode. Reference

parameteri: Option<f64>

Use this optional attribute to specify values for up to five user-defined variables. Reference

process: f64

Use the process attribute to specify a scaling factor to account for variations in the outcome of the actual semiconductor manufacturing steps.

A floating-point number from 0 through 100. Reference

process_label: Option<String>

Use the process_label attribute to specify the name of the current process. Reference

temperature: f64

Use the temperature attribute to specify the ambient temperature in which the design is to operate. Reference

tree_type: Option<TreeType>

Use the tree_type attribute to specify the environment interconnect model.

Valid values are best_case_tree, balanced_tree, and worst_case_tree. Reference

voltage: f64

Use the voltage attribute to specify the operating voltage of the design; typically 5 volts for a CMOS library.

A floating-point number from 0 through 1000, representing the absolute value of the actual voltage Reference

Implementations

impl<C: Ctx> OperatingConditions<C>

pub fn comments_this(&self) -> Option<&String>

pub fn comments_this_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_calc_mode(&self) -> Option<&String>

pub fn comments_calc_mode_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_parameteri(&self) -> Option<&String>

pub fn comments_parameteri_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_process(&self) -> Option<&String>

pub fn comments_process_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_process_label(&self) -> Option<&String>

pub fn comments_process_label_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_temperature(&self) -> Option<&String>

pub fn comments_temperature_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_tree_type(&self) -> Option<&String>

pub fn comments_tree_type_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

pub fn comments_voltage(&self) -> Option<&String>

pub fn comments_voltage_entry<'a>(&'a mut self) -> Entry<'a, u64, String>

Trait Implementations

impl<C: Ctx> Borrow<String> for OperatingConditions<C>

fn borrow(&self) -> &OperatingConditionsId

Immutably borrows from an owned value.

impl<C: Ctx> Borrow<str> for OperatingConditions<C>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<C: Clone + Ctx> Clone for OperatingConditions<C>

where C::Other: Clone,

fn clone(&self) -> OperatingConditions<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug + Ctx> Debug for OperatingConditions<C>

where C::Other: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, C: Ctx> Deserialize<'de> for OperatingConditions<C>

where C::Other: Serialize + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: Ctx> Item for OperatingConditions<C>

type Id = String

type IdReadonlyItem = IdReadonlyOperatingConditions<C>

unsafe fn __unsafe_deref_mut(&self) -> &mut Self::IdReadonlyItem

Safety

fn id(&self) -> &Self::Id

fn id_readonly(&mut self) -> &mut Self::IdReadonlyItem

impl<C: Ctx> Serialize for OperatingConditions<C>

where C::Other: Serialize + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.