🥮 mooncakes.io
    Sign in

    alicedhaha/moonrcinspect/src/model does not have a README file

    Capacitor

    source
    pub(all) struct Capacitor {
      id : Int
      from_node : Int
      to_node : Int?
      capacitance : Double
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    to_node = None represents a capacitance to ground.

    Connection

    source
    pub(all) struct Connection {
      node_id : Int
      direction : Direction
      coordinate : Point?
      load_capacitance : Double?
      driving_cell : String?
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    Design

    source
    pub(all) struct Design {
      header : DesignHeader
      name_map : Array[NameMapEntry]
      ports : Array[PortDecl]
      nets : Array[Net]
    } derive(
    Debug    )

    Design-level view exposed to library consumers.

    DesignHeader

    source
    pub(all) struct DesignHeader {
      spef_version : String?
      design_name : String?
      date : String?
      vendor : String?
      program : String?
      program_version : String?
      design_flow : Array[String]
      divider : String
      delimiter : String
      bus_delimiter_open : String
      bus_delimiter_close : String
      time_unit : UnitScale
      capacitance_unit : UnitScale
      resistance_unit : UnitScale
      inductance_unit : UnitScale
    } derive(
    Debug    )

    DesignHeader::default

    source
    fn DesignHeader::default() -> DesignHeader

    Direction

    source
    pub(all) enum Direction {
      Input
      Output
      Inout
      Unknown
    } derive(Eq, 
    Debug    )

    Direction::from_spef

    source
    fn Direction::from_spef(value : String) -> Direction

    Direction::spef_code

    source
    fn Direction::spef_code(self : Direction) -> String

    NameMapEntry

    source
    pub(all) struct NameMapEntry {
      index : Int
      name : String
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    Net

    source
    pub(all) struct Net {
      id : Int
      name : String
      declared_capacitance : Double
      nodes : Array[Node]
      connections : Array[Connection]
      resistors : Array[Resistor]
      capacitors : Array[Capacitor]
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    Net::coupling_capacitance

    source
    fn Net::coupling_capacitance(self : Net) -> Double

    Net::driver_nodes

    source
    fn Net::driver_nodes(self : Net) -> Array[Int]

    Net::effective_capacitance

    source
    fn Net::effective_capacitance(self : Net) -> Double

    Effective grounded capacitance using a 0.5 split for coupling capacitors.

    Net::find_node

    source
    fn Net::find_node(self : Net, node_id : Int) -> Node?

    Net::ground_capacitance

    source
    fn Net::ground_capacitance(self : Net) -> Double

    Net::pins

    source
    fn Net::pins(self : Net) -> Array[Pin]

    Net::total_resistance

    source
    fn Net::total_resistance(self : Net) -> Double

    Node

    source
    pub(all) struct Node {
      id : Int
      name : String
      kind : NodeKind
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    NodeKind

    source
    pub(all) enum NodeKind {
      Port
      InstancePin
      Internal
      External
    } derive(Eq, 
    Debug    )

    Pin

    source
    pub(all) struct Pin {
      node_id : Int
      name : String
      kind : NodeKind
      direction : Direction
      coordinate : Point?
      load_capacitance : Double?
      driving_cell : String?
    } derive(
    Debug    )

    Semantic pin view resolved from a connection and its backing node.

    Point

    source
    pub(all) struct Point {
      x : Double
      y : Double
    } derive(
    Debug    )

    PortDecl

    source
    pub(all) struct PortDecl {
      name : String
      direction : Direction
      coordinate : Point?
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    Quantity

    source
    pub(all) enum Quantity {
      Time
      Capacitance
      Resistance
      Inductance
    } derive(Eq, 
    Debug    )

    Physical quantity represented by a SPEF unit declaration.

    RCNetwork

    source

    RCNetwork::design

    source
    fn RCNetwork::design(self : RCNetwork) -> Design

    RCNetwork::empty

    source
    fn RCNetwork::empty() -> RCNetwork

    Resistor

    source
    pub(all) struct Resistor {
      id : Int
      from_node : Int
      to_node : Int
      resistance : Double
      span : 
    SourceSpan    ?
    } derive(
    Debug    )

    UnitScale

    source
    pub(all) struct UnitScale {
      quantity : Quantity
      magnitude : Double
      symbol : String
      multiplier : Double
    } derive(Eq, 
    Debug    )

    Unit declaration normalized to an SI multiplier.

    UnitScale::new

    source
    fn UnitScale::new(quantity : Quantity, magnitude : Double, symbol : String) -> UnitScale?

    UnitScale::to_si

    source
    fn UnitScale::to_si(self : UnitScale, value : Double) -> Double

    default_capacitance_unit

    source
    fn default_capacitance_unit() -> UnitScale

    default_inductance_unit

    source
    fn default_inductance_unit() -> UnitScale

    default_resistance_unit

    source
    fn default_resistance_unit() -> UnitScale

    default_time_unit

    source
    fn default_time_unit() -> UnitScale

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io