Targets

abstract type Target

A Target can customize behavior during plan, build!, and/or render!.

Given a target::Target, you would use it like this:

g = SchematicGraph("example")
# ... build up schematic graph here
floorplan = plan(g, target)
check!(floorplan)
build!(floorplan, target)
output = Cell(floorplan, target)

struct LayoutTarget <: Target
    technology::ProcessTechnology
    rendering_options::NamedTuple
    levels::Vector{Int}
    level_increment::GDSMeta
    indexed_layers::Vector{Symbol}
    map_meta_dict::Dict{DeviceLayout.Meta, Union{GDSMeta,Nothing}}
end

Contains information about how to render schematics, typically to a Cell (for the GDSII backend).

A LayoutTarget contains:

• technology::ProcessTechnology: used to map semantic layers to output layers when rendering to an output format (using layer_record(technology)).
• rendering_options: a NamedTuple of keyword arguments to be supplied to render!
• levels::Vector{Int}: a list of metadata levels to be rendered
• level_increment::GDSMeta: if there are multiple levels in the list, each successive level in the list will have its GDSMeta remapped by this increment
• indexed_layers::Vector{Symbol}: a list of layer symbols whose entities should have GDS datatype incremented by their metadata index, for example to give distinct layers to different port boundaries for simulation
• map_meta_dict::Dict{SemanticMeta, Union{GDSMeta,Nothing}}: used for memoization of the SemanticMeta -> GDSMeta map; it can also be populated manually to customize behavior

Rendering options might include tolerance (atol) or keyword flags like simulation=true that determine how or whether entities with an OptionalStyle with the corresponding flag are rendered.

When rendering ent::GeometryEntity with target::LayoutTarget, its metadata m is handled as follows:

1. If m is already a GDSMeta, use as is.
2. If target.map_meta_dict[m] exists (as a GDSMeta instance or nothing), use that. This can be manually assigned before rendering, overriding the default that would result from the steps below. If it does not yet exist, then the result of the steps below will be stored in target.map_meta_dict[m].
3. If layer(m) == layer(DeviceLayout.NORENDER_META) (that is, :norender), use nothing.
4. If !(level(m) in target.levels), use nothing.
5. If layer(m) is not present as a key in layer_record(target.technology) and is not of the form :GDS<layer>_<datatype>, then emit a warning and use GDSMeta(0,0), ignoring level and layer index.
6. If layer(m) is not present as a key in layer_record(target.technology) but is of the form :GDS<layer>_<datatype>, then take GDSMeta(layer, datatype) and add any increments according to level(m) and layerindex(m) as below.
7. If layer(m) is present as a key in layer_record(target.technology), then map layer(m) to a GDSMeta or nothing using layer_record(target.technology)[layer(m)]. If the result is nothing, use that. Otherwise, also consider level(m) and layerindex(m) as below.
8. If target.levels has more than one element and level(m) is the nth element, increment the result by (n-1) times the GDS layer and datatype of target.level_increment.
9. If layer(m) in target.indexed_layers, then increment the GDS datatype of the result by layerindex(m).

If the result is nothing, then ent is not rendered. Here are some examples:

julia> using DeviceLayout, DeviceLayout.SchematicDrivenLayout, DeviceLayout.PreferredUnits

julia> tech = ProcessTechnology((; base_negative=GDSMeta()), (;));

julia> meta = SemanticMeta(:base_negative);

julia> cs = CoordinateSystem("test", nm);

julia> render!.(cs, Ref(Rectangle(10μm, 10μm)), [
    meta,
    facing(meta),
    SemanticMeta(:GDS2_2, index=2, level=2),
    DeviceLayout.UNDEF_META,
    DeviceLayout.NORENDER_META,
    GDSMeta(2, 2)
    ]);

julia> cell = Cell("test", nm);

julia> render!(cell, cs, ArtworkTarget(tech; levels=[1, 2], indexed_layers=[:GDS2_2]));
│ ┌ Warning: Target technology does not have a mapping for layer `:undefined`; mapping to GDS layer/datatype 0/0
│ [...]

julia> cell.element_metadata == [
    GDSMeta(), # :base_negative => GDSMeta()
    GDSMeta(300), # :base_negative => GDSMeta() => GDSMeta(300) [level increment]
    GDSMeta(302, 4), # :GDS2_2 => GDSMeta(2, 2) => GDSMeta(302, 2) [level] => GDSMeta(302, 4) [index]
    GDSMeta(), # UNDEF_META is not in the layer record, so it's mapped to GDSMeta(0, 0)
    # NORENDER_META is skipped
    GDSMeta(2, 2) # GDSMeta(2, 2) is passed through without modification
    ]
true

ArtworkTarget(technology::ProcessTechnology;
    rendering_options = (; simulation=false, artwork=true),
    levels = [1,2],
    level_increment = GDSMeta(300,0),
    indexed_layers = Symbol[],
    map_meta_dict = Dict{SemanticMeta, Union{GDSMeta,Nothing}}()
)

A LayoutTarget with defaults set for artwork.

SimulationTarget(technology::ProcessTechnology;
    rendering_options = (; simulation=true, artwork=false),
    levels = [1,2],
    level_increment = GDSMeta(300,0),
    indexed_layers = Symbol[],
    map_meta_dict = Dict{SemanticMeta, Union{GDSMeta,Nothing}}()
)

A LayoutTarget with defaults set for simulation.

backing(l::Int)
backing(s::SemanticMeta)
backing(m::Meta)

The level backing l or metadata like s in the level backing level(s).

For example, level 3 backs level 2, so backing(2) == 3 and backing(SemanticMeta("lyr"; level=2)) == SemanticMeta(lyr; level=3)

If a metadata object m has no layer attribute, then backing(m) == m.

facing(l::Int)
facing(s::SemanticMeta)
facing(m::Meta)

The level facing l or metadata like s in the level facing level(s).

For example, level 2 faces level 1, so facing(2) == 1 and facing(SemanticMeta("lyr"; level=1)) == SemanticMeta(lyr; level=2)

If a metadata object m has no layer attribute, then facing(m) == m.

not_simulated(ent::GeometryEntity)

Return a version of ent that is rendered unless simulation=true in the rendering options.

The simulation option can be set as a keyword argument to render! or as an element in rendering_options in the Target provided to render!.

only_simulated(ent::GeometryEntity)

Return a GeometryEntity that is rendered if and only if simulation=true in the rendering options.

The simulation option can be set as a keyword argument to render! or as an element in rendering_options in the Target provided to render!.