pdkmaster.technology

pdkmaster.technology.edge

pdkmaster.technology.edge.EdgeT

alias of _Edge

class pdkmaster.technology.edge.MaskEdge(mask: _Mask)[source]

Bases: _Edge

Objects of this class represent the edges of shapes present on a Mask object.

class pdkmaster.technology.edge.Join(edges: Union[T, Iterable[T]])[source]

Bases: _Edge

Joim represent the resulting _Edge object from joining the edges from two or more _Edge objects.

class pdkmaster.technology.edge.Intersect(edges: Union[T, Iterable[T]])[source]

Bases: _Edge

Joim is the resulting _Edge object representing the overlapping parts of the edges from two or more _Edge objects.

Crossing edges can result in points but the handling of this is application dependent.

pdkmaster.technology.mask

pdkmaster.technology.mask.MaskT

alias of _Mask

pdkmaster.technology.mask.RuleMaskT

alias of _RuleMask

class pdkmaster.technology.mask.DesignMask(*, name: str)[source]

Bases: _RuleMask

A DesignMask object is a _Mask object with the shapes on the mask provided by shapes by the user. It is not a derived mask.

Parameters:

name – the name of the mask

property designmasks: Iterable[DesignMask]

The designasks property of a MaskT object gives a list of all designamsks used in a MaskT.

API Notes

  • The returned Iterable may contain same DesignMask object multiple times. User who need a unique set can use a set object for that.

class pdkmaster.technology.mask.Join(masks: Union[T, Iterable[T]], *args: _Mask)[source]

Bases: _Mask

A derived _Mask object that represenet the shapes resulting of joining all the shapes of the provided masks.

property designmasks: Iterable[DesignMask]

The designasks property of a MaskT object gives a list of all designamsks used in a MaskT.

API Notes

  • The returned Iterable may contain same DesignMask object multiple times. User who need a unique set can use a set object for that.

class pdkmaster.technology.mask.Intersect(masks: Union[T, Iterable[T]])[source]

Bases: _Mask

A derived _Mask object that represenet the shapes resulting of the intersection of all the shapes of the provided masks.

property designmasks: Iterable[DesignMask]

The designasks property of a MaskT object gives a list of all designamsks used in a MaskT.

API Notes

  • The returned Iterable may contain same DesignMask object multiple times. User who need a unique set can use a set object for that.

pdkmaster.technology.geometry

The pdkmaster.design.geometry module provides classes to represent shapes drawn in a DesignMask of a technology.

pdkmaster.technology.geometry.epsilon

value under which two coordinate values are considered equal. Default is 1e-6; as coordinates are assumed to be in µm this corresponds with 1 fm.

Type:

float

pdkmaster.technology.geometry.origin

(0.0, 0.0)

Type:

pdkmaster.technology.geometry.Point

class pdkmaster.technology.geometry.Rotation(value)[source]

Bases: Enum

Enum type to represent supported _Shape rotations

No = 'no'
R0 = 'no'
R90 = '90'
R180 = '180'
R270 = '270'
MX = 'mirrorx'
MX90 = 'mirrorx&90'
MY = 'mirrory'
MY90 = 'mirrory&90'
static from_name(rot: str) → Rotation[source]

Helper function to convert a rotation string representation to a Rotation value.

Parameters:

rot – string r of the rotation; supported values: (“no”, “90”, “180”, “270”, “mirrorx”, “mirrorx&90”, “mirrory”, “mirrory&90”)

Returns:

Corresponding Rotation value

class pdkmaster.technology.geometry.RotationContext[source]

Bases: object

Context for rotate operations that are considered to belong together.

Currently it will cache rotated MultiPartShape and link part to the rotated parts.

API Notes

class pdkmaster.technology.geometry.MoveContext[source]

Bases: object

Context for move operations that are considered to be part of one move.

Currently it will cache moved MultiPartShape and link part to the moved parts.

API Notes

pdkmaster.technology.geometry.ShapeT

alias of _Shape

pdkmaster.technology.geometry.RectangularT

alias of _Rectangular

pdkmaster.technology.geometry.PointsShapeT

alias of _PointsShape

class pdkmaster.technology.geometry.Point(*, x: float, y: float)[source]

Bases: _PointsShape, _Rectangular

A point object

Parameters:

  • x – X-coordinate

  • y – Y-coordinate

API Notes

  • Point objects are immutable, x and y coordinates may not be changed after object creation.

  • Point is a final class, no backwards compatibility is guaranteed for subclassing this class.

static from_float(*, point: Union[Tuple[float, float], List[float]]) → Point[source]
static from_point(*, point: Point, x: Optional[float] = None, y: Optional[float] = None) → Point[source]
property x: float

X-coordinate

property y: float

Y-coordinate

property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → Point[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → Point[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property points: Iterable[Point]
property left: float
property bottom: float
property right: float
property top: float
property area
class pdkmaster.technology.geometry.Line(*, point1: Point, point2: Point)[source]

Bases: _PointsShape, _Rectangular

A line shape

A line consist of a start point and an end point. It is considered to be directional so two lines with start en and point exchanged are not considered equal.

property point1: Point
property point2: Point
property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → Line[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → Line[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property points: Iterable[Point]
property left: float
property bottom: float
property right: float
property top: float
property area
class pdkmaster.technology.geometry.Polygon(*, points: Iterable[Point])[source]

Bases: _PointsShape

classmethod from_floats(*, points: Iterable[Union[Tuple[float, float], List[float]]]) → Polygon[source]

API Notes

  • This method is only meant to be called as Outline.from_floats not as obj.__class__.from_floats(). This means that subclasses may overload this method with incompatible call signature.

property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → Polygon[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → Polygon[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property points: Iterable[Point]
property area: float
class pdkmaster.technology.geometry.Rect(*, left: float, bottom: float, right: float, top: float)[source]

Bases: Polygon, _Rectangular

A rectangular shape object

Parameters:

  • left – Edge coordinates of the rectangle; left, bottom have to be smaller than resp. right, top.

  • bottom – Edge coordinates of the rectangle; left, bottom have to be smaller than resp. right, top.

  • right – Edge coordinates of the rectangle; left, bottom have to be smaller than resp. right, top.

  • top – Edge coordinates of the rectangle; left, bottom have to be smaller than resp. right, top.

API Notes

  • Rect objects are immutable, dimensions may not be changed after creation.

  • This class is final. No backwards guarantess given for subclasses in user code

static from_floats(*, values: Tuple[float, float, float, float]) → Rect[source]

API Notes

  • This method is only meant to be called as Outline.from_floats not as obj.__class__.from_floats(). This means that subclasses may overload this method with incompatible call signature.

static from_rect(*, rect: _Rectangular, left: Optional[float] = None, bottom: Optional[float] = None, right: Optional[float] = None, top: Optional[float] = None, bias: Union[float, Enclosure] = 0.0) → Rect[source]
static from_corners(*, corner1: Point, corner2: Point) → Rect[source]
static from_float_corners(*, corners: Tuple[Union[Tuple[float, float], List[float]], Union[Tuple[float, float], List[float]]]) → Rect[source]
static from_size()[source]
property left: float
property bottom: float
property right: float
property top: float
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → Rect[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → Rect[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property points: Iterable[Point]
property area: float
class pdkmaster.technology.geometry.MultiPath(first: Start, *instrs: Union[SetWidth, _Go, Knot])[source]

Bases: Polygon

A shape consisting of one or more paths. A single path consist of manhattan connections of varying width between points.

A MultiPath object is created specifying a list of instructions that build the MultiPath. The first instruction has to be the Start instructions and then follow by a list of other instructions. If a Knot instruction is included it has to be only once in the list as the last instruction.

class Start(*, point: Point, width: float)[source]

Bases: _Instruction

Indicates the start of a MultiPath

class SetWidth(width: float)[source]

Bases: _Instruction

Set the width for the next segment(s)

class GoLeft(dist: float)[source]

Bases: _Go

Go left from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class GoDown(dist: float)[source]

Bases: _Go

Go down from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class GoRight(dist: float)[source]

Bases: _Go

Go right from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class GoUp(dist: float)[source]

Bases: _Go

Go up from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class Knot(*, left: Optional[Optional[Union[T, Iterable[T]]]] = None, down: Optional[Optional[Union[T, Iterable[T]]]] = None, right: Optional[Optional[Union[T, Iterable[T]]]] = None, up: Optional[Optional[Union[T, Iterable[T]]]] = None)[source]

Bases: _Instruction

A node is a point where different subpaths start from.

Parameters:

  • left –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • down –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • right –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • up –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

API Notes

This class is final, subclassing may cause backwards compatibility problems.

NoStart = typing.Union[pdkmaster.technology.geometry.MultiPath.SetWidth, pdkmaster.technology.geometry.MultiPath._Go, pdkmaster.technology.geometry.MultiPath.Knot]
NoKnot = typing.Union[pdkmaster.technology.geometry.MultiPath.SetWidth, pdkmaster.technology.geometry.MultiPath._Go]
property first: Start
property instrs: Tuple[_Instruction]
class pdkmaster.technology.geometry.Ring(*, outer_bound: Rect, ring_width: float)[source]

Bases: MultiPath

A shape representating a ring shape polygon

Parameters:

  • outer_bound – the outer edge of the shape

  • ring_width – the width of the ring, it has to be smaller than half the width or height of the outer edge.

class pdkmaster.technology.geometry.RectRing(*, outer_bound: Rect, rect_width: float, rect_height: Optional[float] = None, min_rect_space: float)[source]

Bases: _Shape

A RectRing object is a shape that consists of a ring of Rect objects.

An exception will be raised when there is not enough room to put the four corner rects. If the ‘Rect’ objects needs to be on a grid all dimensions specified for this object - including outer bound placement, width & height - have to be double that grid number.

Parameters:

  • outer_bound – the outer bound of the ring; e.g. the generated rect shapes will be inside and touching the bound.

  • rect_width – the width of the generated rect objects.

  • rect_height – the height of the generated rect objects; by default it will be the same as rect_width.

  • min_rect_space – the minimum space between two rect structures.

property outer_bound: Rect
property rect_width: float
property rect_height: float
property min_rect_space: float
moved(*, dxy: Point, context: Optional[MoveContext] = None) → RectRing[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → RectRing[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
property area: float
class pdkmaster.technology.geometry.MultiPartShape(fullshape: Polygon, parts: Iterable[Polygon])[source]

Bases: Polygon

This shape represents a single polygon shape that consist of a build up of touching parts.

Main use case is to represent a shape where parts are on a different net as is typically the case for a WaferWire.

Parameters:

  • fullshape – The full shape

  • parts –

    The subshapes The subshapes should be touching shapes and joined should form the fullshape shape. Currently it is only checked if the areas match, in better checking may be implemented.

    The subshapes will be converted to MultiPartShape._Part objects before becoming member of the parts property

property fullshape: Polygon
property parts: Tuple[_Part, ...]
property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → MultiPartShape[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → MultiPartShape[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property points: Iterable[Point]
property area: float
class pdkmaster.technology.geometry.MultiShape(*, shapes: Iterable[_Shape])[source]

Bases: _Shape, Collection[_Shape]

A shape representing a group of shapes

Parameters:

shapes –

the sub shapes. Subshapes may or may not overlap. The object will fail to create if only one unique shape is provided including if the same shape is provided multiple times without another shape.

MultiShape objects part of the provided shapes will be flattened and it’s children will be joined with the other shapes.

property shapes: Iterable[_Shape]
property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
moved(*, dxy: Point, context: Optional[MoveContext] = None) → MultiShape[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → MultiShape[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property area: float
class pdkmaster.technology.geometry.RepeatedShape(*, shape: _Shape, offset0: Point, n: int, n_dxy: Point, m: int = 1, m_dxy: Optional[Point] = None)[source]

Bases: _Shape

A repetition of a shape allowing easy generation of array of objects. Implementation is generic so that one can represent any repetition with one or two vector that don’t need to be manhattan.

API Notes

  • The current implementation assumes repeated shapes don’t overlap. If they do area property will give wrong value.

property shape: _Shape
property offset0: Point
property n: int
property n_dxy: Point
property m: int
property m_dxy: Optional[Point]
moved(*, dxy: Point, context: Optional[MoveContext] = None) → RepeatedShape[source]

Move a _Shape object by a given vector

This method is called moved() to represent the fact the _Shape objects are immutable and a new object is created by the moved() method.

property pointsshapes: Iterable[_PointsShape]
property bounds: _Rectangular
rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → RepeatedShape[source]

Rotate a _Shape object by a given vector

This method is called rotated() to represent the fact the _Shape objects are immutable and a new object is created by the rotated() method.

property area: float
class pdkmaster.technology.geometry.ArrayShape(*, shape: _Shape, offset0: Point, rows: int, columns: int, pitch_y: Optional[float] = None, pitch_x: Optional[float] = None)[source]

Bases: RepeatedShape

Object representing a manhattan repeared shape.

This is a RepeatedShape subclass with repeat vectors either a horizontal and/or a vertical one.

Parameters:

  • shape – The object to repeat

  • offset0 – The placement of the first shape

  • rows – The number of rows and columns Both have to be equal or higher than 1 and either rows or columns has to be higher than 1.

  • columns – The number of rows and columns Both have to be equal or higher than 1 and either rows or columns has to be higher than 1.

  • pitch_y – The displacement for resp. the rows and the columns.

  • pitch_x – The displacement for resp. the rows and the columns.

property rows: int
property columns: int
property pitch_x: Optional[float]
property pitch_y: Optional[float]
class pdkmaster.technology.geometry.MaskShape(*, mask: DesignMask, shape: _Shape)[source]

Bases: object

property mask: DesignMask
property shape: _Shape
moved(*, dxy: Point, context: Optional[MoveContext] = None) → MaskShape[source]
rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → MaskShape[source]
property area: float
property bounds: _Rectangular
class pdkmaster.technology.geometry.MaskShapes(iterable: Union[T, Iterable[T]])[source]

Bases: ExtendedListMapping[MaskShape, DesignMask]

A TypedListMapping of MaskShape objects.

API Notes

Contrary to other classes a MaskShapes object is mutable if not frozen.

move(*, dxy: Point, context: Optional[MoveContext] = None) → None[source]
moved(*, dxy: Point, context: Optional[MoveContext] = None) → MaskShapes[source]

Moved MaskShapes object will not be frozen

rotate(*, rotation: Rotation, context: Optional[RotationContext] = None) → None[source]
rotated(*, rotation: Rotation, context: Optional[RotationContext] = None) → MaskShapes[source]

Rotated MaskShapes object will not be frozen

class pdkmaster.technology.geometry.Start(*, point: Point, width: float)

Bases: _Instruction

Indicates the start of a MultiPath

class pdkmaster.technology.geometry.SetWidth(width: float)

Bases: _Instruction

Set the width for the next segment(s)

class pdkmaster.technology.geometry.GoLeft(dist: float)

Bases: _Go

Go left from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class pdkmaster.technology.geometry.GoDown(dist: float)

Bases: _Go

Go down from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class pdkmaster.technology.geometry.GoRight(dist: float)

Bases: _Go

Go right from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class pdkmaster.technology.geometry.GoUp(dist: float)

Bases: _Go

Go up from the current location

API Notes

This class is final, subclassing may cause backwards compatibility problems.

class pdkmaster.technology.geometry.Knot(*, left: Optional[Optional[Union[T, Iterable[T]]]] = None, down: Optional[Optional[Union[T, Iterable[T]]]] = None, right: Optional[Optional[Union[T, Iterable[T]]]] = None, up: Optional[Optional[Union[T, Iterable[T]]]] = None)

Bases: _Instruction

A node is a point where different subpaths start from.

Parameters:

  • left –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • down –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • right –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

  • up –

    instructions for each subpath starting from the current location.

    At least two directions need to be specified. The first instruction in a direction that is not SetWidth may not be another Knot instruction.

    The direction in conflict with last _Go instruction may not be specified; e.g. if last instruction was GoUp, down may not be specified.

API Notes

This class is final, subclassing may cause backwards compatibility problems.

pdkmaster.technology.net

pdkmaster.technology.net.NetT

alias of _Net

pdkmaster.technology.net.Nets

alias of ExtendedListStrMapping[_Net]

pdkmaster.technology.primitive

The primitive defines the building blocks a technology

API Notes

This module provides several type aliases which names end with a T. No backwards

compatibility is guaranteed for any else than type annotations.

pdkmaster.technology.property_

class pdkmaster.technology.property_.Enclosure(spec: Union[float, Iterable[float]])[source]

Bases: object

Enclosure object are representing the enclosure value of one layer over another layer. Most of the time it is used to indicae the minimum required enclosure of one layer over another layer.

Enclosure constraints can symmetric or asymmetric. A symmetric enclosure can be specified with a single float value, an assymetric one with two float values. Internally always two float values are stored and be accessed through the spec attribute of an Enclosure object. For a symmetric object the two float values are the same.

When an enclosure is used as a constraint symmetric means that the enclosure has to be met in all directions. Asymmetric normally means that a smaller enclosure in one direction is allowed when both enclosures in the other direction are bigger than the bigger enclosure value. For this case the order of the two value don’t have a meaning.

An enclosure can also be used to specify when doing layout generation. The PDKMaster convention here is that the order has a meaning; the first value is for the horizontal direction and the second value for the vertical one. Also giving meaning to the wide() and tall() object methods

Enclosure objects are implemented as immutable objects.

property spec: Tuple[float, float]
static cast(v: Union[float, Iterable[float], Enclosure]) → Enclosure[source]
property first: float
property second: float
property is_assymetric: bool
min() → float[source]
max() → float[source]
wide() → Enclosure[source]
tall() → Enclosure[source]
pdkmaster.technology.property_.PropertyT

alias of _Property

pdkmaster.technology.property_.EnclosurePropertyT

alias of _EnclosureProperty

pdkmaster.technology.property_.ComparisonT

alias of _Comparison

class pdkmaster.technology.property_.Operators[source]

Bases: object

Operators is a class representing a bunch of boolean operators.

class Greater(*, left: _Property, right: Any)[source]

Bases: _Comparison

symbol: ClassVar[str] = '>'
class GreaterEqual(*, left: _Property, right: Any)[source]

Bases: _Comparison

symbol: ClassVar[str] = '>='
class Smaller(*, left: _Property, right: Any)[source]

Bases: _Comparison

symbol: ClassVar[str] = '<'
class SmallerEqual(*, left: _Property, right: Any)[source]

Bases: _Comparison

symbol: ClassVar[str] = '<='
class Equal(*, left: _Property, right: Any)[source]

Bases: _Comparison

symbol: ClassVar[str] = '=='
GT

alias of Greater

GE

alias of GreaterEqual

ST

alias of Smaller

SE

alias of SmallerEqual

EQ

alias of Equal

pdkmaster.technology.property_.Ops

alias of Operators

pdkmaster.technology.rule

pdkmaster.technology.rule.RuleT

alias of _Rule

pdkmaster.technology.rule.ConditionT

alias of _Condition

class pdkmaster.technology.rule.Rules(*args, **kwds)[source]

Bases: ExtendedList[_Rule]

pdkmaster.technology.technology_

class pdkmaster.technology.technology_.Technology(*, primitives: Primitives)[source]

Bases: ABC

A Technology object is the representation of a semiconductor process. It’s mainly a list of _Primitive objects with these primitives describing the capabilities of the technolgy.

the Technology class is an abstract base class so subclasses need to implement some of the abstract methods defined in this base class.

Subclasses need to overload the __init__() method and call the parent’s __init__() with the list of the primitives for this technology. After this list has been passed to the super class’s __init__() it is final and will be frozen.

Next to the __init__() abstract method subclasses also need to define some abstract properties to define some properties of the technology. These are name(), grid().

exception ConnectionError[source]

Bases: Exception

abstract property name: str

property with the name of the technology

abstract property grid: float

property with the minimum grid of the technology

Optionally primitives may define a bigger grid for their shapes.

is_ongrid(v: float, mult: int = 1) → bool[source]

Returns wether a value is on grid or not.

Parameters:

  • w – value to check

  • mult – value has to be on mult*grid

on_grid(dim: float, *, mult: int = 1, rounding: str = 'nearest') → float[source]
on_grid(dim: Point, *, mult: int = 1, rounding: str = 'nearest') → Point

Compute a value on grid from a given value.

Parameters:

  • dim – value to put on grid

  • mult – value will be put on mult*grid

  • rounding – how to round the value Has to be one of “floor”, “nearest”, “ceiling”; “nearest” is the default.

property base: Base
property dbu: float

Returns database unit compatible with technology grid. An exception is raised if the technology grid is not a multuple of 10pm.

This method is specifically for use to export to format that use the dbu.

property substrate_prim: _MaskPrimitive

Property representing the substrate of the technology; it’s defined as the area that is outside any of the wells of the technology.

As this value needs access to the list of wells it’s only available afcer the technology has been initialized and is not available during run of the _init() method.

property rules: Iterable[_Rule]

Return all the rules that are derived from the primitives of the technology.

property primitives: Primitives

Return the primitives of the technology.

property designmasks: Iterable[DesignMask]

Return all the DesignMask objects defined by the primitives of the technology.

The property makes sure there are no duplicates in the returned iterable.

pdkmaster.technology.wafer_

class pdkmaster.technology.wafer_.SubstrateNet(*, name: str)[source]

Bases: _Net

SubstrateNet is a net representing the bulk of a wafer.