# Copyright 2022 Mabrains
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
# 
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

#===========================================================================================================================
#------------------------------------------------- SKY130 LVS RULE DECK ----------------------------------------------------
#===========================================================================================================================

require 'time'
require "logger"

exec_start_time = Time.now

logger = Logger.new(STDOUT)

logger.formatter = proc do |severity, datetime, progname, msg|
  "#{datetime}: Memory Usage (" + `pmap #{Process.pid} | tail -1`[10,40].strip + ") : #{msg}\n"
end

#================================================
#----------------- FILE SETUP -------------------
#================================================

logger.info("Starting running SKY130 Klayout LVS runset on %s" % [$input])

#=== GET LAYOUT ===
if $input
  source($input)
  logger.info("Layout file: #{$input}")
else
  logger.error("No layout loaded, please add your layout file")
end

#=== GET THREADS ===
if $thr
  threads($thr)
  logger.info("Number of threads: #{$thr}")
else
  threads(16)
  logger.info("Number of threads: 16")
end

#=== GET REPORT ===
if $report
  report_lvs($report)
  logger.info("Final report: #{$report}")
else
  report_lvs(source.cell_name+".lvsdb")
  logger.info("Final report: #{source.cell_name}.lvsdb")
end

#=== GET SUBSTRATE NAME ===
if $lvs_sub
  substrate_name = $lvs_sub
  logger.info("Substrate name: #{$lvs_sub}")
else
  substrate_name = "sky130_gnd"
  logger.info("No substrate name given, default name is sky130_gnd")
end

#=== CUSTOM WRITER CLASS ===
class SubcircuitModels < RBA::NetlistSpiceWriterDelegate

  def write_device(device)
    device_class = device.device_class
    if device_class.name.include?('fet')
      str = "M" + device.expanded_name
    elsif device_class.name.include?('diode')
      str = "D" + device.expanded_name
    elsif device_class.name.include?('npn') or device_class.name.include?('pnp')
      str = "Q" + device.expanded_name
    elsif device_class.name.include?('res')
      str = "R" + device.expanded_name
    elsif device_class.name.include?('ind') or device_class.name.include?('coil')
      str = "L" + device.expanded_name
    elsif device_class.name.include?('cap')
      str = "C" + device.expanded_name
    else
      str = "#{device.id}" + device.expanded_name
    end
    device_class.terminal_definitions.each do |td|
      str += " " + net_to_string(device.net_for_terminal(td.id))
    end
    str += " " + device_class.name
    unless device_class.name.include?('vpp') || device_class.name.include?('ind')
      device_class.parameter_definitions.each do |pd|
        str += " " + pd.name + ("=%.12g" % device.parameter(pd.id))
      end
    end
    emit_line(str)
  end      

end

#=== CUSTOM WRITER ===
custom_spice_writer = RBA::NetlistSpiceWriter::new(SubcircuitModels::new)

#=== NET NAMES OPTION ===
# true: use net names instead of numbers
# false: use numbers for nets
if $spice_net_names == "false"
  custom_spice_writer.use_net_names = false
  logger.info("Extracted netlist with net names: #{$spice_net_names}")
else
  custom_spice_writer.use_net_names = true
  logger.info("Extracted netlist with net names: true")
end

#=== COMMENTS OPTION ===
# true: put in comments with details
# false: no comments
if $spice_comments == "true"
  custom_spice_writer.with_comments = true
  logger.info("Extracted netlist with comments in details: #{$spice_comments}")
else
  custom_spice_writer.with_comments = false
  logger.info("Extracted netlist with comments in details: false")
end

if $target_netlist
  target_netlist($target_netlist, custom_spice_writer, "Extracted by KLayout with SKY130 LVS runset on : #{Time.now.strftime("%d/%m/%Y %H:%M")}")
  logger.info("Extracted netlist file: #{$target_netlist}")
else
  target_netlist(File.join(File.dirname(RBA::CellView::active.filename), source.cell_name+"_extracted.cir"), custom_spice_writer,  "Extracted by KLayout with SKY130 LVS runset on : #{Time.now.strftime("%d/%m/%Y %H:%M")}")
  logger.info("Extracted netlist file: #{source.cell_name}_extracted.cir")
end

#=== EXTRACTION SCALE ===
if $scale  == "true"
  device_scaling(1000000)
  logger.info("device_scaling: true")
else
  logger.info("device_scaling: false")
end

#=== PRINT DETAILS ===
if $verbose == "true"
  verbose(true)
  logger.info("Verbose mode: #{$verbose}")
else
  verbose(false)
  logger.info("Verbose mode: false")
end

# === TILING MODE ===
if $run_mode == "tiling"
  # use a tile size of 1mm - not used in deep mode-
  # tiles(500.um)
  # use a tile border of 10 micron:
  # tile_borders(10.um)
  tiles(1000)
  logger.info("Tiling  mode is enabled.")

elsif $run_mode == "deep"
  #=== HIER MODE ===
  deep
  logger.info("deep mode is enabled.")

elsif $run_mode == "flat"
  #=== FLAT MODE ===
  flat
  logger.info("flat  mode is enabled.")

else
  #=== DEFAULT MODE ===
  deep
  logger.info("deep  mode is enabled.")

end # run_mode


#================================================
# --------------- CUSTOM CLASSES ----------------
#================================================

#====================== CUSTOM READER =========================
class SubcircuitModelsReader < RBA::NetlistSpiceReaderDelegate

  def parse_element(s, element)
    if element == "C"
      super(s + " C=2e-16", element)
    elsif element == "R"
      super(s + " R=0", element)
    elsif element == "L"
      super(s + " L=0", element)
    else
      super
    end
  end

  # take and translate the element
  def element(circuit, el, name, model, value, nets, params)

    if el == "C" && model.include?('SKY130') && model.include?('VPP')

      if nets.size == 4
        cls = RBA::DeviceClassMOS4Transistor::new
        cls.name = model
        circuit.netlist.add(cls)

        # create a device
        device = circuit.create_device(cls, name)

        # and configure the device
        [ "S", "G", "D", "B" ].each_with_index do |t,index|
          device.connect_terminal(t, nets[index])
        end

      else
        cls = RBA::DeviceClassCapacitorWithBulk::new
        cls.name = model
        circuit.netlist.add(cls)

        # create a device
        device = circuit.create_device(cls, name)

        # and configure the device
        [ "A", "B", "W" ].each_with_index do |t,index|
          device.connect_terminal(t, nets[index])
        end
        
        device.set_parameter("C", params["C"] || 2e-16)
      
      end

    elsif el == "L" && model.include?('SKY130') && (model.include?('IND') || model.include?('COIL'))

      cls = RBA::DeviceClassResistorWithBulk::new
      cls.name = model
      circuit.netlist.add(cls)

      # create a device
      device = circuit.create_device(cls, name)

      # and configure the device
      [ "A", "B", "W" ].each_with_index do |t,index|
        device.connect_terminal(t, nets[index])
      end

      device.set_parameter("R", params["R"] || 0)

    else
      # all other elements are left to the standard implementation
      return super
    end

    return true

  end

end

# Instantiate a reader using the new delegate
reader = RBA::NetlistSpiceReader::new(SubcircuitModelsReader::new)

#=== GET NETLIST ===
if $schematic
  schematic($schematic, reader)
  logger.info("Netlist file: #{$schematic}")
else
  begin  
    schematic("#{source.cell_name}.cdl", reader)
    logger.info("Netlist file: #{source.cell_name}.cdl")
  rescue 
    puts "No schematic loaded , please add your netlist file"
    logger.error("No schematic loaded , please add your netlist file")
  end 
end

class BResistor < RBA::DeviceClassResistorWithBulk
  def initialize
    super
    enable_parameter("R", false)
    enable_parameter("W", true)
    enable_parameter("L", true)
  end
end

class NResistor < RBA::DeviceClassResistor
  def initialize
    super
    enable_parameter("R", false)
    enable_parameter("W", true)
    enable_parameter("L", true)
  end
end

class MIMCap < RBA::DeviceClassCapacitor
  def initialize
    super
    enable_parameter("C", false)
    enable_parameter("A", true)
    enable_parameter("P", true)
  end
end

class VarCap < RBA::DeviceClassCapacitorWithBulk
  def initialize
    super
    enable_parameter("C", false)
    enable_parameter("A", true)
    enable_parameter("P", true)
  end
end

# class Vpp3Cap < RBA::DeviceClassCapacitorWithBulk
#   def initialize
#     super
#     enable_parameter("C", false)
#     enable_parameter("A", false)
#     enable_parameter("P", false)
#   end
# end

class Diode < RBA::DeviceClassDiode
  def initialize
    super
    enable_parameter("A", true)
    enable_parameter("P", true)
  end
end

#================================================
#-------------    Custom Devices  ---------------
#================================================

#====================== CUSTOM FOUR TERMINAL BJT EXTRACTOR =========================
class FixBJT4Transistor < RBA::GenericDeviceExtractor

  def initialize(name)
    self.name = name
  end

  def setup
  
    define_layer("BJT", "BJT Seed Layer")
    define_layer("tC", "Collector Terminal")
    define_layer("tB", "Base Terminal")
    define_layer("tE", "Emitter Terminal")
    define_layer("tS", "Substrate Terminal")
    
    register_device_class(RBA::DeviceClassBJT4Transistor::new)
  end
  
  def get_connectivity(layout, layers)

    conn = RBA::Connectivity::new
    conn.connect(layers[0], layers[0])
    conn.connect(layers[0], layers[1])
    conn.connect(layers[0], layers[2])
    conn.connect(layers[0], layers[3])
    
    return conn

  end

  def extract_devices(layer_geometry)

    # layer_geometry provides the input layers in the order they are 
    # defined with "define_layer"
    # conductor is supposed to be "conductor outside marker"
    bjt          = layer_geometry[0]
    
    t_collector  = layer_geometry[1]
    t_base       = layer_geometry[2]
    t_emitter    = layer_geometry[3]
    t_bulk       = layer_geometry[4]
  
    bjt.each_merged do |c|
      dev_c = t_collector & c
      dev_b = t_base & c
      dev_e = t_emitter & c
      
      dev_c.each_merged do |cc|
        dev_b.each_merged do |b|
          dev_e.each_merged do |e|
            device = create_device()
          
            # provide the device terminals to connect the metal to later
            define_terminal(device, RBA::DeviceClassBJT4Transistor::TERMINAL_C, 1, cc)
            define_terminal(device, RBA::DeviceClassBJT4Transistor::TERMINAL_B, 2, b)
            define_terminal(device, RBA::DeviceClassBJT4Transistor::TERMINAL_E, 3, e)
            define_terminal(device, RBA::DeviceClassBJT4Transistor::TERMINAL_S, 4, e)
          end
        end
      end
    end 
  end
end

#====================== CUSTOM INDUCTOR EXTRACTOR =========================
class InductorExtractor < RBA::GenericDeviceExtractor

  def initialize(name)
    self.name = name
  end

  def setup

    define_layer("C1", "Conductor1")
    define_layer("C2", "Conductor2")
    define_layer("M", "Marker")

    register_device_class(RBA::DeviceClassResistorWithBulk::new)

  end

  def extract_devices(layer_geometry)

    # layer_geometry provides the input layers in the order they are 
    # defined with "define_layer"
    # conductor is supposed to be "conductor outside marker"
    conductor1 = layer_geometry[0]
    conductor2 = layer_geometry[1]
    marker     = layer_geometry[2]

    marker_merged = marker.merged

    # this will be the edge where the marker turns into conductor
    marker_edges  = (marker_merged.edges & (conductor1))
    marker_edges2 = (marker_merged.edges & (conductor2))

    marker_merged.each do |r|

      # identify the edges where this marker shape ends
      interface_edges = marker_edges.interacting(RBA::Region::new(r))

      # form terminal shapes from these edges
      terminals  = conductor1.merged.interacting(interface_edges.extended_out(1).merged)
      terminals2 = marker_edges2.extended_out(1).merged

      if (terminals.size > 1) and (terminals2.size > 0)

        terminals.each do |term|
          if "#{RBA::Region::new(term).interacting(conductor1.merged.interacting(RBA::Region::new(terminals[0])))}".empty?
            terminals = [terminals[0], term]
            break
          end
        end

        device = create_device
        device.set_parameter(RBA::DeviceClassResistorWithBulk::PARAM_R, 0)
        define_terminal(device, RBA::DeviceClassResistorWithBulk::TERMINAL_A, 0,   terminals[0]);
        define_terminal(device, RBA::DeviceClassResistorWithBulk::TERMINAL_B, 0,   terminals[1]);
        define_terminal(device, RBA::DeviceClassResistorWithBulk::TERMINAL_W, 1,  terminals2[0]);

      end
      
    end

  end

  def get_connectivity(layout, layers)
  
    # marker is used for extraction
    # conductor is used for producing the terminals
    conductor1 = layers[0]
    conductor2 = layers[1]
    marker     = layers[2]
    conn = RBA::Connectivity::new
    conn.connect(marker    , marker)
    conn.connect(conductor1, marker)
    conn.connect(conductor2, marker)

    return conn

  end

end

#====================== CUSTOM FOUR TERMINAL VPP EXTRACTOR =========================
class VPP4Extractor < RBA::GenericDeviceExtractor

  def initialize(name)
    self.name = name
  end

  def setup

    define_layer("C1", "Conductor1")
    define_layer("C2", "Conductor2")
    define_layer("M", "Marker")
    define_layer("B", "Bulk")

    register_device_class(RBA::DeviceClassMOS4Transistor::new)

  end

  def extract_devices(layer_geometry)

    # layer_geometry provides the input layers in the order they are 
    # defined with "define_layer"
    # conductor is supposed to be "conductor outside marker"
    conductor1 = layer_geometry[0]
    conductor2 = layer_geometry[1]
    marker     = layer_geometry[2]
    bulk       = layer_geometry[3]

    marker_merged = marker.merged
    bulk_merged   = bulk.merged

    # this will be the edge where the marker turns into conductor
    marker_edges  = (marker_merged & (conductor1))
    marker_edges2 = (marker_merged & (conductor2))

    marker_merged.each do |r|

      # identify the edges where this marker shape ends
      interface_edges = marker_edges.interacting(RBA::Region::new(r))

      # form terminal shapes from these edges
      terminals  = interface_edges.merged
      terminals2 = marker_edges2.merged

      if (terminals.size > 1) and (terminals2.size > 0)

        terminals.each do |term|
          if terminals[0] == term
            next
          end
          if !"#{RBA::Region::new(term).extents.interacting(RBA::Region::new(terminals[0]).extents)}".empty?
            terminals = [terminals[0], term]
            break
          end
        end

        device = create_device
        define_terminal(device, RBA::DeviceClassMOS4Transistor::TERMINAL_S, 0,   terminals[0]);
        define_terminal(device, RBA::DeviceClassMOS4Transistor::TERMINAL_G, 0,   terminals[1]);
        define_terminal(device, RBA::DeviceClassMOS4Transistor::TERMINAL_D, 1,  terminals2[0]);
        define_terminal(device, RBA::DeviceClassMOS4Transistor::TERMINAL_B, 3, bulk_merged[0]);

      end
      
    end

  end

  def get_connectivity(layout, layers)
  
    # marker is used for extraction
    # conductor is used for producing the terminals
    conductor1 = layers[0]
    conductor2 = layers[1]
    marker     = layers[2]
    bulk       = layers[3]
    conn = RBA::Connectivity::new
    conn.connect(marker    , marker)
    conn.connect(conductor1, marker)
    conn.connect(conductor2, marker)
    conn.connect(bulk      , marker)

    return conn

  end

end


#====================== CUSTOM THREE TERMINAL VPP EXTRACTOR =========================
class VPP3Extractor < RBA::GenericDeviceExtractor

  def initialize(name)
    self.name = name
  end

  def setup

    define_layer("C", "Conductor")
    define_layer("M", "Marker")
    define_layer("B", "Bulk")

    register_device_class(RBA::DeviceClassCapacitorWithBulk::new)

  end

  def extract_devices(layer_geometry)

    # layer_geometry provides the input layers in the order they are 
    # defined with "define_layer"
    # conductor is supposed to be "conductor outside marker"
    conductor  = layer_geometry[0]
    marker     = layer_geometry[1]
    bulk       = layer_geometry[2]

    marker_merged = marker.merged
    bulk_merged   = bulk.merged

    # this will be the edge where the marker turns into conductor
    marker_edges  = (marker_merged & (conductor))

    marker_merged.each do |r|

      # identify the edges where this marker shape ends
      interface_edges = marker_edges.interacting(RBA::Region::new(r))

      # form terminal shapes from these edges
      terminals  = interface_edges.merged
      
      if terminals.size > 1

        terminals.each do |term|
          if terminals[0] == term
            next
          end
          if !"#{RBA::Region::new(term).extents.interacting(RBA::Region::new(terminals[0]).extents)}".empty?
            terminals = [terminals[0], term]
            break
          end
        end

        device = create_device
        device.set_parameter(RBA::DeviceClassCapacitorWithBulk::PARAM_C, 2e-16)
        define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_A, 0,   terminals[0]);
        define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_B, 0,   terminals[1]);
        define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_W, 2, bulk_merged[0]);

      end
      
    end

  end

  def get_connectivity(layout, layers)
  
    # marker is used for extraction
    # conductor is used for producing the terminals
    conductor  = layers[0]
    marker     = layers[1]
    bulk       = layers[2]
    conn = RBA::Connectivity::new
    conn.connect(marker   , marker)
    conn.connect(conductor, marker)
    conn.connect(bulk     , marker)

    return conn

  end

end


#====================== CUSTOM VPP NHV EXTRACTOR =========================
class VPP3NHVExtractor < RBA::GenericDeviceExtractor

  def initialize(name)
    self.name = name
  end

  def setup
  
    define_layer("MARKER", "VPP Seed Layer")
    define_layer("tA", "Terminal A")
    define_layer("tB", "Terminal B")
    define_layer("tW", "Substrate Terminal")
    
    register_device_class(RBA::DeviceClassCapacitorWithBulk::new)
  end
  
  def get_connectivity(layout, layers)

    conn = RBA::Connectivity::new
    conn.connect(layers[0], layers[0])
    conn.connect(layers[0], layers[1])
    conn.connect(layers[0], layers[2])
    conn.connect(layers[0], layers[3])
    
    return conn

  end

  def extract_devices(layer_geometry)
    vpp_cap      = layer_geometry[0]
    t_top        = layer_geometry[1]
    t_bot        = layer_geometry[2]
    t_bulk       = layer_geometry[3]
  
    vpp_cap.each_merged do |c|
      dev_a = t_top & c
      dev_b = t_bot & c
      dev_w = t_bulk & c
      device = create_device()
    
      # provide the device terminals to connect the metal to later
      device.set_parameter(RBA::DeviceClassCapacitorWithBulk::PARAM_C, 2e-16)
      define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_A, 1, dev_a[0])
      define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_B, 2, dev_b[0])
      define_terminal(device, RBA::DeviceClassCapacitorWithBulk::TERMINAL_W, 3, dev_w[0])
    end 
  end
end


#================================================
#------------- LAYERS DERIVATIONS ---------------
#================================================

logger.info("Read in polygons from layers.")

#=== INPUTS ===
diff        = input(65 , 20 )
poly        = input(66 , 20 )
li          = input(67 , 20 )
met1        = input(68 , 20 )
met2        = input(69 , 20 )
met3        = input(70 , 20 )
met4        = input(71 , 20 )
met5        = input(72 , 20 )
pad         = input(76 , 20 )

#=== DRAWINGS ===
bound       = polygons(235, 4  )
sub_pin     = polygons(64 , 59 )
dnwell      = polygons(64 , 18 )
pwell_pin   = polygons(122, 16 )
pwell_res   = polygons(64 , 13 )
pwbm        = polygons(19 , 44 )
pwde        = polygons(124, 20 )
nwell       = polygons(64 , 20 )
nwell_pin   = polygons(64 , 16 )
tap         = polygons(65 , 44 )
psdm        = polygons(94 , 20 )
nsdm        = polygons(93 , 44 )
lvtn        = polygons(125, 44 )
hvtr        = polygons(18 , 20 )
hvtp        = polygons(78 , 44 )
tunm        = polygons(80 , 20 )
sonos       = polygons(80 , 20 )
coreid      = polygons(81 , 2  )
stdcell     = polygons(81 , 4  )
npnid       = polygons(82 , 20 )
pnpid       = polygons(82 , 44 )
rpm         = polygons(86 , 20 )
urpm        = polygons(79 , 20 )
ldntm       = polygons(11 , 44 )
hvntm       = polygons(125, 20 )
poly_pin    = polygons(66 , 16 )
poly_res    = polygons(66 , 13 )
poly_cut    = polygons(66 , 14 )
poly_short  = polygons(66 , 15 )
hvi         = polygons(75 , 20 )
licon       = polygons(66 , 44 )
npc         = polygons(95 , 20 )
diff_res    = polygons(65 , 13 )
diff_cut    = polygons(65 , 14 )
diode       = polygons(81 , 23 )
li_pin      = polygons(67 , 16 )
li_res      = polygons(67 , 13 )
li_cut      = polygons(67 , 14 )
mcon        = polygons(67 , 44 )
met1_pin    = polygons(68 , 16 )
met1_res    = polygons(68 , 13 )
met1_cut    = polygons(68 , 14 )
via1        = polygons(68 , 44 )
met2_pin    = polygons(69 , 16 )
met2_res    = polygons(69 , 13 )
met2_cut    = polygons(69 , 14 )
met2_fuse   = polygons(69 , 17 )
via2        = polygons(69 , 44 )
met3_pin    = polygons(70 , 16 )
met3_res    = polygons(70 , 13 )
met3_cut    = polygons(70 , 14 )
met3_fuse   = polygons(70 , 17 )
via3        = polygons(70 , 44 )
met4_pin    = polygons(71 , 16 )
met4_res    = polygons(71 , 13 )
met4_cut    = polygons(71 , 14 )
met4_fuse   = polygons(71 , 17 )
via4        = polygons(71 , 44 )
met5_pin    = polygons(72 , 16 )
met5_res    = polygons(72 , 13 )
met5_cut    = polygons(72 , 14 )
rdl         = polygons(74 , 20 )
rdl_pin     = polygons(74 , 16 )
glass       = polygons(76 , 20 )
capm        = polygons(89 , 44 )
capm2       = polygons(97 , 44 )
lowtapd     = polygons(81 , 14 )
fillobsm1   = polygons(62 , 24 )
fillobsm2   = polygons(105, 52 )
fillobsm3   = polygons(107, 24 )
fillobsm4   = polygons(112, 4  )
ncm         = polygons(92 , 44 )
natfet      = polygons(124, 21 )
nsm         = polygons(61 , 20 )
vhvi        = polygons(74 , 21 )
uhvi        = polygons(74 , 22 )
inductor    = polygons(82 , 24 )
vpp         = polygons(82 , 64 )
lvs_prune   = polygons(84 , 44 )
padcenter   = polygons(81 , 20 )
mf          = polygons(76 , 44 )
areaid_sl   = polygons(81 , 1  )
areaid_ce   = polygons(81 , 2  )
areaid_fe   = polygons(81 , 3  )
areaid_sc   = polygons(81 , 4  )
areaid_sf   = polygons(81 , 6  )
areaid_sw   = polygons(81 , 7  )
areaid_sr   = polygons(81 , 8  )
areaid_mt   = polygons(81 , 10 )
areaid_dt   = polygons(81 , 11 )
areaid_ft   = polygons(81 , 12 )
areaid_ww   = polygons(81 , 13 )
areaid_ld   = polygons(81 , 14 )
areaid_ns   = polygons(81 , 15 )
areaid_ij   = polygons(81 , 17 )
areaid_zr   = polygons(81 , 18 )
areaid_ed   = polygons(81 , 19 )
areaid_de   = polygons(81 , 23 )
areaid_rd   = polygons(81 , 24 )
areaid_dn   = polygons(81 , 50 )
areaid_cr   = polygons(81 , 51 )
areaid_cd   = polygons(81 , 52 )
areaid_st   = polygons(81 , 53 )
areaid_op   = polygons(81 , 54 )
areaid_en   = polygons(81 , 57 )
areaid_en20 = polygons(81 , 58 )
areaid_le   = polygons(81 , 60 )
areaid_hl   = polygons(81 , 63 )
areaid_sd   = polygons(81 , 70 )
areaid_po   = polygons(81 , 81 )
areaid_it   = polygons(81 , 84 )
areaid_et   = polygons(81 , 101)
areaid_lvt  = polygons(81 , 108)
areaid_re   = polygons(81 , 125)
areaid_ag   = polygons(81 , 79 )
cfom        = polygons(22 , 20 )
uhv_mos_1   = polygons(110, 14 )
uhv_mos_2   = polygons(173, 0  )
uhv_mos_3   = polygons(174, 0  )

logger.info("Read in labels from layers.")

#=== LABELS ===
sub_label       = labels(122, 5)
pwelliso_label  = labels(44 , 5)
nwell_label     = labels(64 , 5)
pwell_label     = labels(64 ,59)
tap_label       = labels(65 , 5)
diff_label      = labels(65 , 6)
poly_label      = labels(66 , 5)
poly_model      = labels(66 ,83)
li_label        = labels(67 , 5)
met1_label      = labels(68 , 5)
met2_label      = labels(69 , 5)
met3_label      = labels(70 , 5)
met4_label      = labels(71 , 5)
met5_label      = labels(72 , 5)
rdl_label       = labels(74 , 5)
pad_label       = labels(76 , 5)
txt_label       = labels(83 ,44)

#=== BULK LAYER ===
sub = polygon_layer

#================================================
#------------------ SWITCHES --------------------
#================================================

logger.info("Evaluate switches start")

# FUSE
if $fuse
  FUSE = $fuse
else
  FUSE = "m4"
end # FUSE

# SCH_SIMPLE
if $schematic_simplify == "true"
  SCH_SIMPLE = $schematic_simplify
else
  SCH_SIMPLE = false
end # SCH_SIMPLE

logger.info("SCH_SIMPLE enabled  %s" % [SCH_SIMPLE])

# NET_ONLY
if $net_only == "true"
  NET_ONLY = true
else
  NET_ONLY = false
end # NET_ONLY

logger.info("NET_ONLY enabled  %s" % [NET_ONLY])

# TOP_LVL_PINS
if $top_lvl_pins == "true"
  TOP_LVL_PINS = true
else
  TOP_LVL_PINS = false
end # TOP_LVL_PINS

logger.info("TOP_LVL_PINS enabled  %s" % [TOP_LVL_PINS])

# COMBINE
if $combine == "true"
  COMBINE = true
else
  COMBINE = false
end # COMBINE

logger.info("COMBINE enabled  %s" % [COMBINE])

# PURGE
if $purge == "true"
  PURGE = true
else
  PURGE = false
end # PURGE

logger.info("PURGE enabled  %s" % [PURGE])

# PURGE_NETS
if $purge_nets == "true"
  PURGE_NETS = true
else
  PURGE_NETS = false
end # PURGE_NETS

logger.info("PURGE_NETS enabled  %s" % [PURGE_NETS])

# SIMPLIFY
if $net_only == "true" || $top_lvl_pins == "true" || $combine == "true" || $purge == "true" || $purge_nets == "true"
  SIMPLIFY = false
else
  SIMPLIFY = true
end # SIMPLIFY

logger.info("SIMPLIFY enabled  %s" % [SIMPLIFY])

logger.info("Evaluate switches end.")

#================================================================
#------------------------- MAIN RUNSET --------------------------
#================================================================

logger.info("SKY130 LVS rules started")

#================================================
#------------- LAYERS DERIVATIONS ---------------
#================================================

logger.info("Starting deriving base layers.")

#==================================
# ------ GENERAL DERIVATIONS ------
#==================================

ncomp     = diff.and(nsdm)
pcomp     = diff.and(psdm)

sd        = diff.not(poly).not(diff_res).not(diff_cut).not(tap).not(areaid_po).not(npnid).not(pnpid).not(areaid_de).not(uhv_mos_1).not(uhv_mos_2).not(uhv_mos_3)
tgate     = poly.and(diff).not(poly_res).not(poly_cut).not(tap).not(tunm).not(rpm).not(npc).not(hvtr).not(uhv_mos_1).not(uhv_mos_2).not(uhv_mos_3)

ngate     = nsdm.and(tgate).not(nwell).not(pwde).not(hvtp).not(psdm)
nsd       = nsdm.and(sd).not(nwell).interacting(ngate)
ptap_conn = tap.and(psdm).not(nwell).not(diff_res).not(diff_cut).not(npnid).not(pnpid)
ptap_bjt  = tap.and(psdm).not(diff_res).not(diff_cut)

pgate     = psdm.and(tgate).and(nwell).not(ldntm).not(nsdm).not(areaid_le)
psd       = psdm.and(sd).and(nwell).interacting(pgate)
ntap_conn = tap.and(nsdm).and(nwell).not(diff_res).not(diff_cut).not(npnid).not(pnpid)
ntap_bjt  = tap.and(nsdm).not(diff_res).not(diff_cut)

poly_con  = poly.not(poly_res).not(vpp).not(npnid)
li_con    = li.not( li_res ).not(vpp)
met1_con  = met1.not(met1_res).not(vpp)
met2_con  = met2.not(met2_res).not(inductor).not(met2_fuse).not(vpp)
met3_con  = met3.not(met3_res).not(inductor).not(met3_fuse).not(vpp)
met4_con  = met4.not(met4_res).not(met4_fuse).not(vpp)
met5_con  = met5.not(met5_res).not(vpp)


#==================================
# ------ MOSFET DERIVATIONS -------
#==================================

logger.info("Starting MOSFET DERIVATIONS")

# ==============
# ---- PMOS ----
# ==============

logger.info("Starting PMOS layers DERIVATIONS")

# General PMOS derivations
pgate_low_voltage = pgate.not(hvi).not(uhvi).not(pwbm).not(pwde).not(areaid_en).not(areaid_en20)
pgate_low_voltage_not_pass = pgate_low_voltage.not_interacting(poly_model).not(ncm).not(areaid_ce)
pgate_high_voltage = pgate.and(hvi).not(hvtp).not(areaid_ce)

# 1.8V PMOS transistor standard
pgate_1p8v = pgate_low_voltage_not_pass.not(hvtp).not(lvtn)

# 1.8V PMOS transistor low threshold voltage
pgate_1p8v_lvt = pgate_low_voltage_not_pass.not(hvtp).and(lvtn)

# 1.8V PMOS transistor high threshold voltage
pgate_1p8v_hvt = pgate_low_voltage_not_pass.and(hvtp).not(lvtn)

# 5V gate 10.5V drain PMOS transistor
pgate_5p0v_hv = pgate_high_voltage.not(lvtn).not(areaid_en).not(areaid_en20)

# ==============
# ---- NMOS ----
# ==============

logger.info("Starting NMOS layers DERIVATIONS")

# General NMOS derivations
ngate_low_voltage = ngate.not(hvi).not(uhvi).not(pwbm).not(areaid_en).not(areaid_en20)
ngate_low_voltage_not_pass = ngate_low_voltage.not_interacting(poly_model).not(ncm).not(ldntm).not(areaid_ce).not(ldntm)
ngate_high_voltage = ngate.and(hvi).not(uhvi).not(ncm).not(areaid_ce).not(ldntm).not(pwbm)
ngate_nvt = ngate_high_voltage.and(lvtn).not(areaid_ed).not(areaid_ce)

# 1.8V NMOS transistor standard
ngate_1p8v = ngate_low_voltage_not_pass.not(lvtn)

# 1.8V NMOS transistor low threshold voltage
ngate_1p8v_lvt = ngate_low_voltage_not_pass.and(lvtn)

# 3.3V NMOS transistor native voltage
ngate_3p0v_nvt = ngate_nvt.and(areaid_le)

# 5V NMOS transistor native voltage
ngate_5p0v_nvt = ngate_nvt.not(areaid_le).not_interacting(vpp)

# 5V gate 10.5V drain NMOS transistor
ngate_5p0v_hv = ngate_high_voltage.not(lvtn).not(areaid_en).not(areaid_en20)


#================================
# ------ BJT DERIVATIONS --------
#================================

logger.info("Starting BJT DERIVATIONS")

# BJT DERIVATIONS
bjt_exclude = diff_res.or(diff_cut).or(pwbm).or(pwde).or(hvtr).or(lvtn).or(ncm).or(poly_res).or(poly_cut).or(li_res).or(li_cut)
npn_exclude = bjt_exclude.or(pwell_res)
pnp_exclude = bjt_exclude.or(dnwell)

#==============
# ---- npn ----
#==============

logger.info("Starting NPN layers DERIVATIONS")

# NPN general nodes DERIVATIONS
npn_e = ncomp.inside(dnwell).inside(npnid).not(npn_exclude)
npn_b = ptap_bjt.inside(dnwell).inside(npnid).not(npn_exclude)
npn_c = ntap_bjt.inside(nwell).inside(dnwell).interacting(npnid).not(npn_exclude)

# 5V NPN with emitter size of 1umx1um nodes DERIVATIONS
npn_5v0_1x1_e = npn_e.with_area(0.81.um, 1.21.um).interacting(npn_e.edges.with_length(0.9.um, 1.1.um)).not_interacting(poly)
npn_5v0_1x1_b = npn_b.interacting(npn_b.extents.interacting(npn_5v0_1x1_e))
npn_5v0_1x1_c = npn_c.interacting(npn_c.extents.interacting(npn_5v0_1x1_e))  

# 5V NPN with emitter size of 1umx2um DERIVATIONS
npn_5v0_1x2_e = npn_e.with_area(1.71.um, 2.31.um).interacting(npn_e.edges.with_length(1.9.um, 2.1.um)).not_interacting(poly)
npn_5v0_1x2_b = npn_b.interacting(npn_b.extents.interacting(npn_5v0_1x2_e))
npn_5v0_1x2_c = npn_c.interacting(npn_c.extents.interacting(npn_5v0_1x2_e))                       

# 11V NPN poly-gated with octagonal emitter nodes DERIVATIONS
npn_11v0_1x1_e = npn_e.interacting(poly)
npn_11v0_1x1_b = npn_b.interacting(npn_b.extents.interacting(npn_11v0_1x1_e))
npn_11v0_1x1_c = npn_c.interacting(npn_c.extents.interacting(npn_11v0_1x1_e)) 

#==============
# ---- pnp ----
#==============

logger.info("Starting PNP layers DERIVATIONS")

# PNP general nodes DERIVATIONS
pnp_e = pcomp.inside(nwell).inside(pnpid).not(pnp_exclude).not_interacting(poly)
pnp_b = ntap_bjt.inside(pnpid).not(pnp_exclude).not_interacting(poly)
pnp_c = ptap_bjt.interacting(pnpid).not(pnp_exclude).not_interacting(poly)

# 5V PNP with emitter size of 0.68umx0.68um DERIVATIONS
pnp_5v0_0p68x0p68_e = pnp_e.with_area(0.3364.um, 0.6084.um).interacting(pnp_e.edges.with_length(0.58.um, 0.78.um))
pnp_5v0_0p68x0p68_b = pnp_b.interacting(pnp_b.extents.interacting(pnp_5v0_0p68x0p68_e))
pnp_5v0_0p68x0p68_c = pnp_c.interacting(pnp_c.extents.interacting(pnp_5v0_0p68x0p68_e))  

# 5V PNP with emitter size of 3.4umx3.4um DERIVATIONS
pnp_5v0_3p4x3p4_e = pnp_e.with_area(10.24.um, 12.96.um).interacting(pnp_e.edges.with_length(3.2.um, 3.6.um))
pnp_5v0_3p4x3p4_b = pnp_b.interacting(pnp_b.extents.interacting(pnp_5v0_3p4x3p4_e))
pnp_5v0_3p4x3p4_c = pnp_c.interacting(pnp_c.extents.interacting(pnp_5v0_3p4x3p4_e))  


#================================
# ----- DIODE DERIVATIONS -------
#================================

logger.info("Starting DIODE DERIVATIONS")

# N+ diffusion diode
ndiode_terminal_n = ncomp.outside(dnwell).not(hvtp).interacting(areaid_de).not_interacting(areaid_ed)
ndiode_terminal_p = ptap_conn.holes.interacting(ndiode_terminal_n).not_interacting(areaid_ed)

# P+ diffusion diode
pdiode_terminal_n = pcomp.outside(dnwell).interacting(areaid_de).not_interacting(areaid_ed)
pdiode_terminal_p = nwell.interacting(areaid_de).not_interacting(areaid_ed)

# 5V N+ diffusion diode
ndiode_5v0_terminal_n = ndiode_terminal_n.not(hvi).not(lvtn)
ndiode_5v0_terminal_p = ndiode_terminal_p.interacting(ndiode_5v0_terminal_n)

# 5V N+ diffusion diode low threshold voltage  [lvt]
ndiode_5v0_lvt_terminal_n = ndiode_terminal_n.not(hvi).and(lvtn)
ndiode_5v0_lvt_terminal_p = ndiode_terminal_p.interacting(ndiode_5v0_lvt_terminal_n)

# 5V N+ diffusion diode native threshold voltage [lvt & hvi]
ndiode_5v0_nvt_terminal_n = ndiode_terminal_n.and(hvi).and(lvtn)
ndiode_5v0_nvt_terminal_p = ndiode_terminal_p.interacting(ndiode_5v0_nvt_terminal_n)

# 11V N+ diffusion diode 
ndiode_11v0_terminal_n = ndiode_terminal_n.and(hvi).not(lvtn)
ndiode_11v0_terminal_p = ndiode_terminal_p.interacting(ndiode_11v0_terminal_n)

# 5V P+ diffusion diode
pdiode_5v0_terminal_n = pdiode_terminal_n.not(hvtp).not(hvi).not(lvtn)
pdiode_5v0_terminal_p = pdiode_terminal_p.interacting(pdiode_5v0_terminal_n)

# 5V P+ diffusion diode low threshold voltage [lvt]
pdiode_5v0_lvt_terminal_n = pdiode_terminal_n.not(hvtp).not(hvi).and(lvtn)
pdiode_5v0_lvt_terminal_p = pdiode_terminal_p.interacting(pdiode_5v0_lvt_terminal_n)

# 5V P+ diffusion diode high threshold voltage [hvtp]
pdiode_5v0_hvt_terminal_n = pdiode_terminal_n.and(hvtp).not(hvi).not(lvtn)
pdiode_5v0_hvt_terminal_p = pdiode_terminal_p.interacting(pdiode_5v0_hvt_terminal_n)

# 11V P+ diffusion diode [hvi]
pdiode_11v0_terminal_n = pdiode_terminal_n.not(hvtp).and(hvi).not(lvtn)
pdiode_11v0_terminal_p = pdiode_terminal_p.interacting(pdiode_11v0_terminal_n)


#================================
# --- PHOTODIODE DERIVATIONS ----
#================================

logger.info("Starting PHOTODIODE DERIVATIONS")

# Photodiode
photodiode_exclude = diff.or(pwbm).or(pwde).or(hvtr).or(hvtp).or(areaid_de).or(areaid_ed)
photodiode_n_init = ntap_conn.and(nwell).and(dnwell).interacting(areaid_po).not(photodiode_exclude)
photodiode_n = photodiode_n_init.with_area(0.16.um, 0.1764.um).interacting(photodiode_n_init.edges.with_length(0.4.um, 0.42.um))
photodiode_p = ptap_conn.holes.interacting(photodiode_n)


#================================
# ---- RESISTOR DERIVATIONS -----
#================================

logger.info("Starting RESISTOR DERIVATIONS")

# ===============
# --DIFF & WELL--
# ===============

# RES DERIVATIONS
nplus_res_init  = ncomp.and(diff_res)
pplus_res_init  = pcomp.and(nwell).and(diff_res)

nplus_cont_init = ncomp.not_interacting(ngate).interacting(diff_res).not(diff_res)
pplus_cont_init = pcomp.and(nwell).not_interacting(pgate).interacting(diff_res).not(diff_res)

# N+ diffusion resistor
nplus_res       = nplus_res_init.not(hvi)
nplus_cont      = nplus_cont_init.not(hvi)

# N+ diffusion high voltage resistor
nplus_hv_res    = nplus_res_init.and(hvi)
nplus_hv_cont   = nplus_cont_init.and(hvi)

# P+ diffusion resistor
pplus_res       = pplus_res_init.not(hvi)
pplus_cont      = pplus_cont_init.not(hvi)

# P+ diffusion high voltage resistor
pplus_hv_res    = pplus_res_init.and(hvi)
pplus_hv_cont   = pplus_cont_init.and(hvi)

# Isolated PWELL resistor
pwell_resistor  = pwell_res.not(nwell).and(dnwell)
pwell_term      = ptap_conn.and(dnwell).interacting(pwell_res).not(pwell_res)
pwell_cont      = nwell.holes.covering(pwell_term)

# ==============
# ---- POLY ----
# ==============

# Poly resistor
poly_res_exclude = diff.or(diff_res).or(diff_cut).or(tap).or(pwbm).or(hvtr).or(hvtp).or(lvtn).or(li_cut).or(vpp).or(npnid) 
poly_res_init    = poly.and(poly_res).not(poly_res_exclude)

# Poly resistor generic
poly_res_generic = poly_res_init.not(rpm).not(urpm)

# 300 ohm Poly resistor
poly_res_300     = poly_res_init.and(psdm).and(rpm).not(urpm)

poly_high_0p35   = poly_res_300.interacting(poly_res_300.edges.with_length(0.34.um, 0.36.um))
poly_high_0p69   = poly_res_300.interacting(poly_res_300.edges.with_length(0.68.um, 0.7.um ))
poly_high_1p41   = poly_res_300.interacting(poly_res_300.edges.with_length(1.4.um , 1.42.um))
poly_high_2p85   = poly_res_300.interacting(poly_res_300.edges.with_length(2.84.um, 2.86.um))
poly_high_5p73   = poly_res_300.interacting(poly_res_300.edges.with_length(5.72.um, 5.74.um))

# 2K ohm Poly resistor
poly_res_2k      = poly_res_init.and(psdm).not(rpm).and(urpm)

poly_xhigh_0p35  = poly_res_2k.interacting(poly_res_2k.edges.with_length(0.34.um, 0.36.um))
poly_xhigh_0p69  = poly_res_2k.interacting(poly_res_2k.edges.with_length(0.68.um, 0.7.um ))
poly_xhigh_1p41  = poly_res_2k.interacting(poly_res_2k.edges.with_length(1.4.um , 1.42.um))
poly_xhigh_2p85  = poly_res_2k.interacting(poly_res_2k.edges.with_length(2.84.um, 2.86.um))
poly_xhigh_5p73  = poly_res_2k.interacting(poly_res_2k.edges.with_length(5.72.um, 5.74.um))

# ===============
# ---- METAL ----
# ===============

# Local inter-connect resistor
li_resistor   = li.and(li_res)

# Metal1 resistor
met1_resistor = met1.and(met1_res)

# Metal2 resistor
met2_resistor = met2.and(met2_res)

# Metal3 resistor
met3_resistor = met3.and(met3_res)

# Metal4 resistor
met4_resistor = met4.and(met4_res)

# Metal5 resistor
met5_resistor = met5.and(met5_res)


#==================================
# ------- FUSE DERIVATIONS --------
#==================================

logger.info("Starting FUSE DERIVATIONS")

if FUSE == "m2"

  # Metal2 fuse
  met2_fuse_res_layer  = met2.and(met2_fuse)

elsif FUSE == "m3"

  # Metal3 fuse
  met3_fuse_res_layer  = met3.and(met3_fuse)

else

  # Metal4 fuse
  met4_fuse_res_layer  = met4.and(met4_fuse)

end


#==================================
# ----- MIM DERIVATIONS ------
#==================================

logger.info("Starting MIM DERIVATIONS")

# mim on metal3
met3_ncap = met3_con.not(capm)

# mim on metal3
met4_ncap = met4_con.not(capm2) # mim on metal4


#==================================
# ----- VARACTOR DERIVATIONS ------
#==================================

logger.info("Starting VARACTOR DERIVATIONS")

# voltage varactor
varactor_exclude  = dnwell.or(hvtr).or(pwbm).or(pwde).or(ncm).or(tunm).or(rpm).or(ldntm).or(npc).or(psdm).or(li_res).or(li_cut).or(areaid_de)
varactor_gate =  poly_con.and(ntap_conn).not(varactor_exclude)

# Low threshold voltage varactor
varactor_gate_lvt = poly_con.interacting(varactor_gate.not(hvtp).not(hvi))
varactor_nsd_lvt  = ntap_conn.not(hvtp).not(hvi).interacting(varactor_gate_lvt).not(varactor_exclude)
varactor_bulk_lvt = ptap_conn.holes.interacting(varactor_gate_lvt)

# High threshold voltage varactor
varactor_gate_hvt = poly_con.interacting(varactor_gate.and(hvtp).not(hvi))
varactor_nsd_hvt  = ntap_conn.and(hvtp).not(hvi).interacting(varactor_gate_hvt).not(varactor_exclude)
varactor_bulk_hvt = ptap_conn.holes.interacting(varactor_gate_hvt)


#==================================
# ----- INDUCTOR DERIVATIONS ------
#==================================

logger.info("Starting INDUCTOR DERIVATIONS")

# General Inductor derivations
met3_ind = met3.and(inductor)

# RF Inductor with 3 turns and internal diameter of 90um
coil_1 = inductor.interacting(met3.or(met2).and(inductor.covering(met2.and(inductor), 3, 3)).holes.width(100.um, projection).with_distance(89.um, 91.um).polygons)

# RF Inductor with 5 turns and internal diameter of 125um
coil_2 = inductor.interacting(met3.or(met2).and(inductor.covering(met2.and(inductor), 5, 5)).holes.width(135.um, projection).with_distance(124.um, 126.um).polygons)

# RF Inductor with 5 turns and internal diameter of 220um
coil_3 = inductor.interacting(met3.or(met2).and(inductor.covering(met2.and(inductor), 5, 5)).holes.width(230.um, projection).with_distance(219.um, 221.um).polygons)


#==================================
# ------ VPP CAP DERIVATIONS ------
#==================================

logger.info("Starting VPP CAP DERIVATIONS")

# General VPP capacitor derivation
vpp_sub   = vpp.and(extent)

# ===============
# --- LENGTHS ---
# ===============

vpp_1_43  = vpp.edges.with_length(1.42 , 1.44 )
vpp_2_08  = vpp.edges.with_length(2.07 , 2.09 )
vpp_2_36  = vpp.edges.with_length(2.35 , 2.37 )
vpp_2_51  = vpp.edges.with_length(2.50 , 2.52 )
vpp_4_04  = vpp.edges.with_length(4.03 , 4.05 )
vpp_4_25  = vpp.edges.with_length(4.24 , 4.26 )
vpp_4_38  = vpp.edges.with_length(4.37 , 4.39 )
vpp_4_59  = vpp.edges.with_length(4.58 , 4.60 )
vpp_5_49  = vpp.edges.with_length(5.48 , 5.50 )
vpp_5_75  = vpp.edges.with_length(5.74 , 5.76 )
vpp_5_76  = vpp.edges.with_length(5.75 , 5.77 )
vpp_6_46  = vpp.edges.with_length(6.45 , 6.47 )
vpp_7_50  = vpp.edges.with_length(7.49 , 7.51 )
vpp_7_84  = vpp.edges.with_length(7.83 , 7.85 )
vpp_8_24  = vpp.edges.with_length(8.23 , 8.25 )
vpp_8_58  = vpp.edges.with_length(8.57 , 8.59 )
vpp_10_40 = vpp.edges.with_length(10.39, 10.41)
vpp_10_76 = vpp.edges.with_length(10.75, 10.77)
vpp_10_99 = vpp.edges.with_length(10.98, 11.00)
vpp_11_07 = vpp.edges.with_length(11.06, 11.08)
vpp_11_17 = vpp.edges.with_length(11.16, 11.18)
vpp_11_27 = vpp.edges.with_length(11.26, 11.28)
vpp_11_35 = vpp.edges.with_length(11.34, 11.36)
vpp_11_53 = vpp.edges.with_length(11.52, 11.54)
vpp_20_76 = vpp.edges.with_length(20.75, 20.77)
vpp_22_27 = vpp.edges.with_length(22.26, 22.28)
vpp_22_63 = vpp.edges.with_length(22.62, 22.64)
vpp_33_31 = vpp.edges.with_length(33.30, 33.32)
vpp_40_76 = vpp.edges.with_length(40.75, 40.77)
vpp_44_33 = vpp.edges.with_length(44.32, 44.34)
vpp_55_39 = vpp.edges.with_length(55.38, 55.40)
vpp_55_45 = vpp.edges.with_length(55.44, 55.46)
vpp_55_47 = vpp.edges.with_length(55.46, 55.48)

# ===============
# ---- METAL ----
# ===============

poly_vpp  = poly.and(vpp)
li_vpp    =   li.and(vpp)
met1_vpp  = met1.and(vpp)
met2_vpp  = met2.and(vpp)
met3_vpp  = met3.and(vpp)
met4_vpp  = met4.and(vpp)
met5_vpp  = met5.and(vpp)

licon_vpp = licon.and(vpp)
mcon_vpp  =  mcon.and(vpp)
via1_vpp  =  via1.and(vpp)
via2_vpp  =  via2.and(vpp)
via3_vpp  =  via3.and(vpp)
via4_vpp  =  via4.and(vpp)

# met4_xvpp = met4.interacting(met4.extents.edges.with_length(55.1.um , 55.12.um )).interacting(met4.extents.edges.with_length(28.89.um , 28.91.um ))

# ===============
# ---- AREAS ----
# ===============

vpp_04p4x04p6 = vpp.interacting(vpp_4_04).interacting(vpp_4_25)
vpp_06p8x06p1 = vpp.interacting(vpp_6_46).interacting(vpp_5_75)
vpp_08p6x07p8 = vpp.interacting(vpp_8_24).interacting(vpp_7_50)
vpp_11p5x11p7 = vpp.interacting(vpp_11_07).interacting(vpp_11_35)

# ===============
# ---- STACK ----
# ===============

vpp_m1m2            = vpp.not_interacting(poly).not_interacting(li).not_interacting(met3).not_interacting(met4).not_interacting(met5)
vpp_m1m2m3          = vpp.not_interacting(poly).not_interacting(li).interacting(met3).not_interacting(met4).not_interacting(met5)
vpp_m1m2m3m4        = vpp.not_interacting(poly).not_interacting(li).interacting(met3).interacting(met4).not_interacting(met5)
vpp_m1m2m3m4m5      = vpp.not_interacting(poly).not_interacting(li).interacting(met3).interacting(met4).interacting(met5)
vpp_l1m1m2          = vpp.not_interacting(poly).interacting(li).not_interacting(met3).not_interacting(met4).not_interacting(met5)
vpp_l1m1m2m3        = vpp.not_interacting(poly).interacting(li).interacting(met3).not_interacting(met4).not_interacting(met5)
vpp_l1m1m2m3m4      = vpp.not_interacting(poly).interacting(li).interacting(met3).interacting(met4).not_interacting(met5)
vpp_l1m1m2m3m4m5    = vpp.not_interacting(poly).interacting(li).interacting(met3).interacting(met4).interacting(met5)
vpp_pol1m1m2m3      = vpp.interacting(poly).interacting(li).interacting(met3).not_interacting(met4).not_interacting(met5)
vpp_pol1m1m2m3m4    = vpp.interacting(poly).interacting(li).interacting(met3).interacting(met4).not_interacting(met5)
vpp_pol1m1m2m3m4m5  = vpp.interacting(poly).interacting(li).interacting(met3).interacting(met4).interacting(met5)

# ===============
# --- DEVICES ---
# ===============

# vpp_02p4x04p6_m1m2_noshield device
vpp_02p4x04p6_m1m2_noshield = vpp.interacting(vpp_2_08).interacting(vpp_4_25)

# vpp_02p7x06p1_m1m2m3m4_shieldl1_fingercap device
vpp_02p7x06p1_m1m2m3m4_shieldl1_fingercap = vpp.interacting(vpp_2_36).interacting(vpp_5_76)

# vpp_02p7x11p1_m1m2m3m4_shieldl1_fingercap device
vpp_02p7x11p1_m1m2m3m4_shieldl1_fingercap = vpp.interacting(vpp_2_36).interacting(vpp_10_76)

# vpp_02p7x21p1_m1m2m3m4_shieldl1_fingercap device
vpp_02p7x21p1_m1m2m3m4_shieldl1_fingercap = vpp.interacting(vpp_2_36).interacting(vpp_20_76)

# vpp_02p7x41p1_m1m2m3m4_shieldl1_fingercap device
vpp_02p7x41p1_m1m2m3m4_shieldl1_fingercap = vpp.interacting(vpp_2_36).interacting(vpp_40_76)

# vpp_02p9x06p1_m1m2m3m4_shieldl1_fingercap2 device
vpp_02p9x06p1_m1m2m3m4_shieldl1_fingercap2 = vpp.interacting(vpp_2_51).interacting(vpp_5_76)

# vpp_03p9x03p9_m1m2_shieldl1_floatm3   device
vpp_03p9x03p9_m1m2_shieldl1_floatm3   = vpp.interacting(vpp_1_43).interacting(vpp_1_43)

# vpp_04p4x04p6_l1m1m2_noshield device
vpp_04p4x04p6_l1m1m2_noshield = vpp.interacting(vpp_04p4x04p6).interacting(vpp_l1m1m2).covering(li.holes)

# vpp_04p4x04p6_l1m1m2_noshield_o2subcell device
vpp_04p4x04p6_l1m1m2_noshield_o2subcell = vpp.interacting(vpp_4_38).interacting(vpp_4_59).interacting(vpp_l1m1m2)

# vpp_04p4x04p6_l1m1m2_shieldpo_floatm3 device
vpp_04p4x04p6_l1m1m2_shieldpo_floatm3 = vpp.interacting(vpp_04p4x04p6).interacting(vpp_pol1m1m2m3)

# vpp_04p4x04p6_m1m2m3_shieldl1 device
vpp_04p4x04p6_m1m2m3_shieldl1 = vpp.interacting(vpp_04p4x04p6).interacting(vpp_l1m1m2m3)

# vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4 device
vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4 = vpp.interacting(vpp_04p4x04p6).interacting(vpp_l1m1m2m3m4m5)

# vpp_04p4x04p6_m1m2_noshield device
vpp_04p4x04p6_m1m2_noshield = vpp.interacting(vpp_04p4x04p6).interacting(vpp_m1m2).covering(met1.holes)

# vpp_04p4x04p6_m1m2_noshield_o2 device
vpp_04p4x04p6_m1m2_noshield_o2 = vpp.interacting(vpp_04p4x04p6).interacting(vpp_m1m2).not_covering(met1.holes)

# vpp_04p4x04p6_m1m2_shieldl1 device
vpp_04p4x04p6_m1m2_shieldl1 = vpp.interacting(vpp_04p4x04p6).interacting(vpp_l1m1m2).not_covering(li.holes)

# vpp_05p9x05p9_m1m2m3m4_shieldl1_wafflecap device
vpp_05p9x05p9_m1m2m3m4_shieldl1_wafflecap = vpp.interacting(vpp_5_49).interacting(vpp_5_49)

# vpp_06p8x06p1_l1m1m2m3_shieldpom4 device
vpp_06p8x06p1_l1m1m2m3_shieldpom4 = vpp.interacting(vpp_06p8x06p1).interacting(vpp_pol1m1m2m3m4)

# vpp_06p8x06p1_m1m2m3_shieldl1m4 device
vpp_06p8x06p1_m1m2m3_shieldl1m4 = vpp.interacting(vpp_06p8x06p1).interacting(vpp_l1m1m2m3m4)

# vpp_08p6x07p8_l1m1m2_noshield device
vpp_08p6x07p8_l1m1m2_noshield = vpp.interacting(vpp_08p6x07p8).interacting(vpp_l1m1m2).covering(li.holes)

# vpp_08p6x07p8_l1m1m2_noshield_o2subcell device
vpp_08p6x07p8_l1m1m2_noshield_o2subcell = vpp.interacting(vpp_7_84).interacting(vpp_8_58).interacting(vpp_l1m1m2)

# vpp_08p6x07p8_l1m1m2_shieldpo_floatm3 device
vpp_08p6x07p8_l1m1m2_shieldpo_floatm3 = vpp.interacting(vpp_08p6x07p8).interacting(vpp_pol1m1m2m3)

# vpp_08p6x07p8_m1m2m3_shieldl1 device
vpp_08p6x07p8_m1m2m3_shieldl1 = vpp.interacting(vpp_08p6x07p8).interacting(vpp_l1m1m2m3)

# vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4 device
vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4 = vpp.interacting(vpp_08p6x07p8).interacting(vpp_l1m1m2m3m4m5)

# vpp_08p6x07p8_m1m2_noshield device
vpp_08p6x07p8_m1m2_noshield = vpp.interacting(vpp_08p6x07p8).interacting(vpp_m1m2)

# vpp_08p6x07p8_m1m2_shieldl1 device
vpp_08p6x07p8_m1m2_shieldl1 = vpp.interacting(vpp_08p6x07p8).interacting(vpp_l1m1m2).not_covering(li.holes)

# vpp_11p3x11p3_m1m2m3m4_shieldl1_wafflecap device
vpp_11p3x11p3_m1m2m3m4_shieldl1_wafflecap = vpp.interacting(vpp_10_99).interacting(vpp_10_99)

# vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv device
vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv = vpp.interacting(vpp_10_40).interacting(vpp_11_53)

# vpp_11p5x11p7_l1m1m2m3m4_shieldm5 device
vpp_11p5x11p7_l1m1m2m3m4_shieldm5 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2m3m4m5).covering(li.holes).covering(met4.holes)

# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5 device
vpp_11p5x11p7_l1m1m2m3m4_shieldpom5 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.covering(vpp))

# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x device
vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.not_covering(vpp))

# # vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6 device
# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.covering(vpp)).inside(vpp.sized(15.um).interacting(ptap_conn)).interacting(met4.not_covering(vpp))

# # vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7 device
# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.not_covering(vpp)).inside(vpp.sized(15.um).interacting(ptap_conn)).interacting(met4.not_covering(vpp))

# # vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8 device
# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.covering(vpp)).interacting(met4_xvpp)

# # vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9 device
# vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4m5).interacting(met5.not_covering(vpp)).interacting(met4_xvpp)

# vpp_11p5x11p7_l1m1m2m3_shieldm4 device
vpp_11p5x11p7_l1m1m2m3_shieldm4 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2m3m4)

# vpp_11p5x11p7_l1m1m2m3_shieldpom4 device
vpp_11p5x11p7_l1m1m2m3_shieldpom4 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3m4)

# vpp_11p5x11p7_l1m1m2_noshield device
vpp_11p5x11p7_l1m1m2_noshield = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2).covering(li.holes)

# vpp_11p5x11p7_l1m1m2_shieldpom3 device
vpp_11p5x11p7_l1m1m2_shieldpom3 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_pol1m1m2m3)

# vpp_11p5x11p7_m1m2m3m4_shieldl1m5 device
vpp_11p5x11p7_m1m2m3m4_shieldl1m5 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2m3m4m5).not_covering(li.holes).covering(met4.holes)

# vpp_11p5x11p7_m1m2m3m4_shieldm5 device
vpp_11p5x11p7_m1m2m3m4_shieldm5 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_m1m2m3m4m5)

# vpp_11p5x11p7_m1m2m3_shieldl1 device
vpp_11p5x11p7_m1m2m3_shieldl1 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2m3)

# vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4 device
vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2m3m4m5).not_covering(met4.holes)

# vpp_11p5x11p7_m1m2_noshield device
vpp_11p5x11p7_m1m2_noshield = vpp.interacting(vpp_11p5x11p7).interacting(vpp_m1m2)

# vpp_11p5x11p7_m1m2_shieldl1 device
vpp_11p5x11p7_m1m2_shieldl1 = vpp.interacting(vpp_11p5x11p7).interacting(vpp_l1m1m2).not_covering(li.holes)

# vpp_11p5x11p7_m1m4_noshield device
vpp_11p5x11p7_m1m4_noshield = vpp.interacting(vpp_11p5x11p7).interacting(vpp_m1m2m3m4)

# vpp_11p5x11p7_pol1m1m2m3m4m5_noshield device
vpp_11p5x11p7_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_11_17).interacting(vpp_11_27)

# vpp_11p5x23p1_pol1m1m2m3m4m5_noshield device
vpp_11p5x23p1_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_11_17).interacting(vpp_22_63)

# vpp_22p5x11p7_pol1m1m2m3m4m5_noshield device
vpp_22p5x11p7_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_22_27).interacting(vpp_11_27)

# vpp_22p5x23p1_pol1m1m2m3m4m5_noshield device
vpp_22p5x23p1_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_22_27).interacting(vpp_22_63)

# vpp_33p6x11p7_pol1m1m2m3m4m5_noshield device
vpp_33p6x11p7_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_33_31).interacting(vpp_11_27)

# vpp_33p6x23p1_pol1m1m2m3m4m5_noshield device
vpp_33p6x23p1_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_33_31).interacting(vpp_22_63)

# vpp_44p7x11p7_pol1m1m2m3m4m5_noshield device
vpp_44p7x11p7_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_44_33).interacting(vpp_11_27)

# vpp_44p7x23p1_pol1m1m2m3m4m5_noshield device
vpp_44p7x23p1_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_44_33).interacting(vpp_22_63)

# vpp_55p8x11p7_pol1m1m2m3m4m5_noshield device
vpp_55p8x11p7_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_55_45).interacting(vpp_11_27)

# vpp_55p8x11p7_pol1m1m2m3m4m5_noshield_m5pullin device
vpp_55p8x11p7_pol1m1m2m3m4m5_noshield_m5pullin = vpp.interacting(vpp_55_47).interacting(vpp_11_27)

# vpp_55p8x23p1_pol1m1m2m3m4m5_noshield device
vpp_55p8x23p1_pol1m1m2m3m4m5_noshield = vpp.interacting(vpp_55_45).interacting(vpp_22_63)

# vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_m5pullin device
vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_m5pullin = vpp.interacting(vpp_55_47).interacting(vpp_22_63)

# vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_test device
vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_test = vpp.interacting(vpp_55_39).interacting(vpp_22_63)


#==================================
# ------- SONOS DERIVATIONS -------
#==================================

logger.info("Starting SONOS DERIVATIONS")

# Build space flash special SONOSFET original/star
sonos_exclude = diff_res.or(diff_cut).or(tap).or(pwbm).or(pwde).or(hvtr).or(nwell).or(hvtp).or(ncm).or(hvi).or(rpm).or(poly_res).or(poly_cut).or(npc)
sonos_tgate   = poly.and(diff).not(sonos_exclude)
sonos_ngate   = nsdm.and(sonos_tgate).not(psdm)
sonos_gate    = sonos_ngate.and(lvtn).and(dnwell).and(tunm).and(ldntm).interacting(areaid_ce)
sonos_nsd     = nsdm.and(sd).not(nwell).interacting(sonos_gate)


#================================================
#------------ DEVICES CONNECTIVITY --------------
#================================================

logger.info("Starting SKY130 LVS connectivity setup")

#================================
# ----- GENERAL CONNECTIONS -----
#================================

logger.info("Starting SKY130 LVS connectivity setup (Inter-layer)")

# Inter-layer
connect(sub         ,     ptap_conn)
connect(dnwell      ,     ntap_conn)
connect(nwell       ,     ntap_conn)
connect(ptap_conn   ,         licon)
connect(ntap_conn   ,         licon)
connect(psd         ,         licon)
connect(nsd         ,         licon)
connect(poly_con    ,         licon)
connect(licon       ,        li_con)
connect(li_con      ,          mcon)
connect(mcon        ,      met1_con)
connect(met1_con    ,          via1)
connect(via1        ,      met2_con)
connect(met2_con    ,          via2)
connect(via2        ,     met3_ncap)
connect(met3_ncap   ,          via3) 
connect(via3        ,     met4_ncap)
connect(met4_ncap   ,          via4)
connect(via4        ,      met5_con)

logger.info("Starting SKY130 LVS connectivity setup (Attaching labels)")

# Attaching labels
connect(sub         ,      sub_label)
connect(nwell       ,    nwell_label)
connect(tap         ,      tap_label)
connect(nsd        ,      diff_label)
connect(psd        ,      diff_label)
connect(poly_con    ,     poly_label)
connect(li_con      ,       li_label)
connect(met1_con    ,     met1_label)
connect(met2_con    ,     met2_label)
connect(met3_ncap   ,     met3_label)
connect(met4_ncap   ,     met4_label)
connect(met5_con    ,     met5_label)
connect(rdl         ,      rdl_label)
connect(pad         ,      pad_label)

logger.info("Starting SKY130 LVS connectivity setup (Global connections)")

# Global
connect_global(sub  , substrate_name)

logger.info("Starting SKY130 LVS connectivity setup (Multifinger Devices)")

# Multifinger Devices
connect_implicit("*")


#================================
# ------ BJT CONNECTIONS --------
#================================

logger.info("Starting LVS BJT CONNECTIONS")

# ==============
# ---- npn ----
# ==============

# npn_5v0_1x1 nodes connections
connect(npn_5v0_1x1_e,licon)
connect(npn_5v0_1x1_b,licon)
connect(npn_5v0_1x1_c,licon)

# npn_5v0_1x2 nodes connections
connect(npn_5v0_1x2_e,licon)
connect(npn_5v0_1x2_b,licon)
connect(npn_5v0_1x2_c,licon)

# npn_11v0_1x1 nodes connections
connect(npn_11v0_1x1_e,licon)
connect(npn_11v0_1x1_b,licon)
connect(npn_11v0_1x1_c,licon)

# ==============
# ---- pnp ----
# ==============

# pnp_5v0_0p68x0p68 connections
connect(pnp_5v0_0p68x0p68_e,licon)
connect(pnp_5v0_0p68x0p68_b,licon)
connect(pnp_5v0_0p68x0p68_c,licon)

# pnp_5v0_3p4x3p4 nodes
connect(pnp_5v0_3p4x3p4_e,licon)
connect(pnp_5v0_3p4x3p4_b,licon)
connect(pnp_5v0_3p4x3p4_c,licon)


#================================
# ----- DIODE CONNECTIONS -------
#================================

logger.info("Starting LVS DIODE CONNECTIONS")

# N+ diffusion diode
connect(ndiode_terminal_n,     licon)
connect(ndiode_terminal_p, ptap_conn)

# P+ diffusion diode
connect(pdiode_terminal_n, licon)
connect(pdiode_terminal_p, nwell)


#================================
# --- PHOTODIODE CONNECTIONS ----
#================================

logger.info("Starting LVS PHOTODIODE CONNECTIONS")

# Photodiode
connect(photodiode_n,     licon)
connect(photodiode_p, ptap_conn)


#==================================
# ------ MIMCAP CONNECTIONS -------
#==================================

logger.info("Starting LVS MIMCAP CONNECTIONS")

# mim on metal3
connect(capm      , via3    )
connect(met3_ncap , met3_con)

# mim on metal4
connect(capm2     , via4    )
connect(met4_ncap , met4_con)


#================================
# ---- VARACTOR CONNECTIONS -----
#================================

logger.info("Starting LVS VARACTOR CONNECTIONS")

# Low threshold voltage varactor
connect(varactor_bulk_lvt, ptap_conn)

# High threshold voltage varactor
connect(varactor_bulk_hvt, ptap_conn)


#================================
# ---- RESISTOR CONNECTIONS -----
#================================

logger.info("Starting LVS RESISTOR CONNECTIONS")

# Diffusions and Wells
connect(nplus_cont    , licon)
connect(nplus_hv_cont , licon)
connect(pplus_cont    , licon)
connect(pplus_hv_cont , licon)
connect(pwell_term    , licon)


#================================
# ---- INDUCTOR CONNECTIONS -----
#================================

logger.info("Starting LVS INDUCTOR CONNECTIONS")

connect(met3_ind     ,  met3_ncap)
connect(met3_ind     , met3_label)


#================================
# ------- VPP CONNECTIONS -------
#================================

logger.info("Starting LVS VPP CAP CONNECTIONS")

# General VPP capacitor connections
connect(vpp_sub      , pwell_label)

connect(met1_vpp     ,   met1_con)
connect(met1_vpp     , met1_label)

connect(met2_vpp     ,   met2_con)
connect(met2_vpp     , met2_label)

connect(met3_vpp     ,  met3_ncap)
connect(met3_vpp     , met3_label)

connect(met4_vpp     ,  met4_ncap)
connect(met4_vpp     , met4_label)

connect(met5_vpp     ,   met5_con)
connect(met5_vpp     , met5_label)

connect(poly_vpp     ,  licon_vpp)
connect(licon_vpp    ,     li_vpp)
connect(li_vpp       ,   mcon_vpp)
connect(mcon_vpp     ,   met1_vpp)
connect(met1_vpp     ,   via1_vpp)
connect(via1_vpp     ,   met2_vpp)
connect(met2_vpp     ,   via2_vpp)
connect(via2_vpp     ,   met3_vpp)
connect(met3_vpp     ,   via3_vpp)
connect(via3_vpp     ,   met4_vpp)
connect(met4_vpp     ,   via4_vpp)
connect(via4_vpp     ,   met5_vpp)

#================================
# ---- SONOS CONNECTIONS -----
#================================

logger.info("Starting LVS SONOS CONNECTIONS")
connect(sonos_nsd    , licon)


#================================================
#------------- DEVICES EXTRACTION ---------------
#================================================

logger.info("Starting MOSFET EXTRACTION")

# ==============
# ---- PMOS ----
# ==============

logger.info("Starting PMOS EXTRACTION")

# 1.8V PMOS transistor standard
logger.info("Extracting 1.8V PMOS transistor standard")
extract_devices(mos4("sky130_fd_pr__pfet_01v8"), { "SD" => psd, "G" => pgate_1p8v, "tS" => psd, "tD" => psd, "tG" => poly_con, "W" => nwell })

# 1.8V PMOS transistor low threshold voltage
logger.info("Extracting 1.8V PMOS transistor low threshold voltage")
extract_devices(mos4("sky130_fd_pr__pfet_01v8_lvt"), { "SD" => psd, "G" => pgate_1p8v_lvt,   "tS" => psd, "tD" => psd, "tG" => poly_con, "W" => nwell })

# 1.8V PMOS transistor high threshold voltage
logger.info("Extracting 1.8V PMOS transistor high threshold voltage")
extract_devices(mos4("sky130_fd_pr__pfet_01v8_hvt"), { "SD" => psd, "G" => pgate_1p8v_hvt,   "tS" => psd, "tD" => psd, "tG" => poly_con, "W" => nwell })

# 5V gate 10.5V drain PMOS transistor
logger.info("Extracting 5V gate 10.5V drain PMOS transistor")
extract_devices(mos4("sky130_fd_pr__pfet_g5v0d10v5"), { "SD" => psd, "G" => pgate_5p0v_hv,   "tS" => psd, "tD" => psd, "tG" => poly_con, "W" => nwell })

# ==============
# ---- NMOS ----
# ==============

logger.info("Starting NMOS EXTRACTION")

# 1.8V NMOS transistor standard
logger.info("Extracting 1.8V NMOS transistor standard")
extract_devices(mos4("sky130_fd_pr__nfet_01v8"), { "SD" => nsd, "G" => ngate_1p8v, "tS" => nsd, "tD" => nsd, "tG" => poly_con, "W" => sub })

# 1.8V NMOS transistor low threshold voltage
logger.info("Extracting 1.8V NMOS transistor low threshold voltage")
extract_devices(mos4("sky130_fd_pr__nfet_01v8_lvt"), { "SD" => nsd, "G" => ngate_1p8v_lvt, "tS" => nsd, "tD" => nsd, "tG" => poly_con, "W" => sub })

# 3.3V NMOS transistor native voltage
logger.info("Extracting 3.3V NMOS transistor native voltage")
extract_devices(mos4("sky130_fd_pr__nfet_03v3_nvt"), { "SD" => nsd, "G" => ngate_3p0v_nvt, "tS" => nsd, "tD" => nsd, "tG" => poly_con, "W" => sub })

# 5V NMOS transistor native voltage
logger.info("Extracting 5V NMOS transistor native voltage")
extract_devices(mos4("sky130_fd_pr__nfet_05v0_nvt"), { "SD" => nsd, "G" => ngate_5p0v_nvt, "tS" => nsd, "tD" => nsd, "tG" => poly_con, "W" => sub })

# 5V gate 10.5V drain NMOS transistor
logger.info("Extracting 5V gate 10.5V drain NMOS transistor")
extract_devices(mos4("sky130_fd_pr__nfet_g5v0d10v5"), { "SD" => nsd, "G" => ngate_5p0v_hv, "tS" => nsd, "tD" => nsd, "tG" => poly_con, "W" => sub })


#================================
# ------- BJT EXTRACTION --------
#================================

logger.info("Starting BJT EXTRACTION")

# ====================
# ------ NPN --------
# ====================

logger.info("Starting NPN BJT EXTRACTION")

# sky130_fd_pr__npn_05v5_W1p00L1p00 BJT
logger.info("Extracting sky130_fd_pr__npn_05v5_W1p00L1p00 BJT")
cls = extract_devices(bjt4("sky130_fd_pr__npn_05v5_W1p00L1p00"), { "C" => npn_5v0_1x1_c.extents , "B" => npn_5v0_1x1_b.extents , "E" => npn_5v0_1x1_e,"S" => sub.extents,
                                  "tC" => npn_5v0_1x1_c , "tB" => npn_5v0_1x1_b, "tE" => npn_5v0_1x1_e, "tS" => sub })
ignore_parameter("sky130_fd_pr__npn_05v5_W1p00L1p00","AE")
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# sky130_fd_pr__npn_05v5_W1p00L2p00 BJT
logger.info("Extracting sky130_fd_pr__npn_05v5_W1p00L2p00 BJT")
cls = extract_devices(bjt4("sky130_fd_pr__npn_05v5_W1p00L2p00"), { "C" => npn_5v0_1x2_c.extents , "B" => npn_5v0_1x2_b.extents , "E" => npn_5v0_1x2_e,"S" => sub.extents,
                                "tC" => npn_5v0_1x2_c , "tB" => npn_5v0_1x2_b, "tE" => npn_5v0_1x2_e, "tS" => sub })
ignore_parameter("sky130_fd_pr__npn_05v5_W1p00L2p00","AE")
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# sky130_fd_pr__npn_11v0_W1p00L1p00 BJT
logger.info("Extracting sky130_fd_pr__npn_11v0_W1p00L1p00 BJT")
cls = extract_devices(FixBJT4Transistor::new("sky130_fd_pr__npn_11v0_W1p00L1p00"), { "BJT" => npn_11v0_1x1_c.extents, "tC" => npn_11v0_1x1_c , "tB" => npn_11v0_1x1_b, 
                                                                                "tE" => npn_11v0_1x1_e, "tS" => sub })
ignore_parameter("sky130_fd_pr__npn_11v0_W1p00L1p00","AE")
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# ====================
# ------- PNP --------
# ====================

logger.info("Starting PNP BJT EXTRACTION")

# sky130_fd_pr__pnp_05v5_W0p68L0p68 BJT
logger.info("Extracting sky130_fd_pr__pnp_05v5_W0p68L0p68 BJT")
cls = extract_devices(bjt3("sky130_fd_pr__pnp_05v5_W0p68L0p68"), { "C" => pnp_5v0_0p68x0p68_c.extents , "B" => pnp_5v0_0p68x0p68_b.extents , "E" => pnp_5v0_0p68x0p68_e,
                                  "tC" => pnp_5v0_0p68x0p68_c , "tB" => pnp_5v0_0p68x0p68_b, "tE" => pnp_5v0_0p68x0p68_e })
ignore_parameter("sky130_fd_pr__pnp_05v5_W0p68L0p68","AE")
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# sky130_fd_pr__pnp_05v5_W3p40L3p40 BJT
logger.info("Extracting sky130_fd_pr__pnp_05v5_W3p40L3p40 BJT")
cls = extract_devices(bjt3("sky130_fd_pr__pnp_05v5_W3p40L3p40"), { "C" => pnp_5v0_3p4x3p4_c.extents , "B" => pnp_5v0_3p4x3p4_b.extents , "E" => pnp_5v0_3p4x3p4_e,
                                "tC" => pnp_5v0_3p4x3p4_c , "tB" => pnp_5v0_3p4x3p4_b, "tE" => pnp_5v0_3p4x3p4_e })
ignore_parameter("sky130_fd_pr__pnp_05v5_W3p40L3p40","AE")
cls.supports_serial_combination = false
cls.supports_parallel_combination = false


#================================
# ------ DIODE EXTRACTION -------
#================================

logger.info("Starting DIODE EXTRACTION")

# 5V N+ diffusion diode
logger.info("Extracting 5V N+ diffusion diode")
extract_devices(diode("sky130_fd_pr__diode_pw2nd_05v5", Diode), { "P" => ndiode_5v0_terminal_p, "N" => ndiode_5v0_terminal_n, "tA" => ndiode_terminal_p , "tC" => ndiode_terminal_n})

# 5V N+ diffusion diode low threshold voltage
logger.info("Extracting 5V N+ diffusion diode low threshold voltage")
extract_devices(diode("sky130_fd_pr__diode_pw2nd_05v5_lvt", Diode), { "N" => ndiode_5v0_lvt_terminal_n , "P" => ndiode_5v0_lvt_terminal_p, "tA" => ndiode_terminal_n , "tC" => ndiode_terminal_p})

# 5V N+ diffusion diode native threshold voltage
logger.info("Extracting 5V N+ diffusion diode native threshold voltage")
extract_devices(diode("sky130_fd_pr__diode_pw2nd_05v5_nvt", Diode), { "N" => ndiode_5v0_nvt_terminal_n , "P" => ndiode_5v0_nvt_terminal_p, "tA" => ndiode_terminal_n , "tC" => ndiode_terminal_p})

# 11V N+ diffusion diode
logger.info("Extracting 11V N+ diffusion diode")
extract_devices(diode("sky130_fd_pr__diode_pw2nd_11v0", Diode), { "N" => ndiode_11v0_terminal_n , "P" => ndiode_11v0_terminal_p, "tA" => ndiode_terminal_n , "tC" => ndiode_terminal_p})

# 5V P+ diffusion diode
logger.info("Extracting 5V P+ diffusion diode")
extract_devices(diode("sky130_fd_pr__diode_pd2nw_05v5", Diode), { "N" => pdiode_5v0_terminal_n , "P" => pdiode_5v0_terminal_p, "tA" => pdiode_terminal_n, "tC" => pdiode_terminal_p})

# 5V P+ diffusion diode low threshold voltage
logger.info("Extracting5V P+ diffusion diode low threshold voltage")
extract_devices(diode("sky130_fd_pr__diode_pd2nw_05v5_lvt", Diode), { "N" => pdiode_5v0_lvt_terminal_n , "P" => pdiode_5v0_lvt_terminal_p, "tA" => pdiode_terminal_n, "tC" => pdiode_terminal_p})

# 5V P+ diffusion diode high threshold voltage
logger.info("Extracting 5V P+ diffusion diode high threshold voltage")
extract_devices(diode("sky130_fd_pr__diode_pd2nw_05v5_hvt", Diode), { "N" => pdiode_5v0_hvt_terminal_n , "P" => pdiode_5v0_hvt_terminal_p, "tA" => pdiode_terminal_n, "tC" => pdiode_terminal_p})

# 11V P+ diffusion diode
logger.info("Extracting 11V P+ diffusion diode")
extract_devices(diode("sky130_fd_pr__diode_pd2nw_11v0", Diode), { "N" => pdiode_11v0_terminal_n , "P" => pdiode_11v0_terminal_p, "tA" => pdiode_terminal_n, "tC" => pdiode_terminal_p})


#================================
#---- PHOTODIODE EXTRACTIONS ----
#================================

logger.info("Starting PHOTODIODE EXTRACTION")

# Photodiode
logger.info("Extracting Photodiode")
cls = extract_devices(diode("sky130_fd_pr__photodiode"), { "P" => photodiode_p, "N" => photodiode_n})
cls.supports_serial_combination = false
cls.supports_parallel_combination = false
ignore_parameter("sky130_fd_pr__photodiode","A")
ignore_parameter("sky130_fd_pr__photodiode","p")


#================================
# ---- RESISTOR EXTRACTIONS -----
#================================

logger.info("Starting RESISTOR EXTRACTION")

# ===============
# --DIFF & WELL--
# ===============

# sky130_fd_pr__res_generic_nd
logger.info("Extracting sky130_fd_pr__res_generic_nd device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_generic_nd", 120, BResistor), { "R" => nplus_res, "C" => nplus_cont, "W" => sub})

# sky130_fd_pr__res_generic_nd
logger.info("Extracting sky130_fd_pr__res_generic_nd device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_generic_nd_hv", 120, BResistor), { "R" => nplus_hv_res, "C" => nplus_hv_cont, "W" => sub})

# sky130_fd_pr__res_generic_pd
logger.info("Extracting sky130_fd_pr__res_generic_pd device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_generic_pd", 197, BResistor), { "R" => pplus_res, "C" => pplus_cont, "W" => nwell})

# sky130_fd_pr__res_generic_pd
logger.info("Extracting sky130_fd_pr__res_generic_pd device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_generic_pd_hv", 197, BResistor), { "R" => pplus_hv_res, "C" => pplus_hv_cont, "W" => nwell})

# sky130_fd_pr__res_iso_pw
logger.info("Extracting sky130_fd_pr__res_iso_pw device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_iso_pw", 3050, BResistor), { "R" => pwell_resistor, "C" => pwell_cont, "W" => dnwell, "tA" => pwell_term, "tB" => pwell_term, "tW" => dnwell})

# ==============
# ---- POLY ----
# ==============

# sky130_fd_pr__res_generic_po
logger.info("Extracting sky130_fd_pr__res_generic_po device")
extract_devices(resistor("sky130_fd_pr__res_generic_po", 48.2, NResistor), { "R" => poly_res_generic, "C" => poly_con })

# sky130_fd_pr__res_high_po_0p35
logger.info("Extracting sky130_fd_pr__res_high_po_0p35 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_high_po_0p35", 319.8, BResistor), { "R" => poly_high_0p35, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_high_po_0p69
logger.info("Extracting sky130_fd_pr__res_high_po_0p69 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_high_po_0p69", 319.8, BResistor), { "R" => poly_high_0p69, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_high_po_1p41
logger.info("Extracting sky130_fd_pr__res_high_po_1p41 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_high_po_1p41", 319.8, BResistor), { "R" => poly_high_1p41, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_high_po_2p85
logger.info("Extracting sky130_fd_pr__res_high_po_2p85 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_high_po_2p85", 319.8, BResistor), { "R" => poly_high_2p85, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_high_po_5p73
logger.info("Extracting sky130_fd_pr__res_high_po_5p73 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_high_po_5p73", 319.8, BResistor), { "R" => poly_high_5p73, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_xhigh_po_0p35
logger.info("Extracting sky130_fd_pr__res_xhigh_po_0p35 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_xhigh_po_0p35", 2000, BResistor), { "R" => poly_xhigh_0p35, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_xhigh_po_0p69
logger.info("Extracting sky130_fd_pr__res_xhigh_po_0p69 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_xhigh_po_0p69", 2000, BResistor), { "R" => poly_xhigh_0p69, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_xhigh_po_1p41
logger.info("Extracting sky130_fd_pr__res_xhigh_po_1p41 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_xhigh_po_1p41", 2000, BResistor), { "R" => poly_xhigh_1p41, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_xhigh_po_2p85
logger.info("Extracting sky130_fd_pr__res_xhigh_po_2p85 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_xhigh_po_2p85", 2000, BResistor), { "R" => poly_xhigh_2p85, "C" => poly_con, "W" => sub})

# sky130_fd_pr__res_xhigh_po_5p73
logger.info("Extracting sky130_fd_pr__res_xhigh_po_5p73 device")
extract_devices(resistor_with_bulk("sky130_fd_pr__res_xhigh_po_5p73", 2000, BResistor), { "R" => poly_xhigh_5p73, "C" => poly_con, "W" => sub})

# ===============
# ---- METAL ----
# ===============

# sky130_fd_pr__res_generic_l1
logger.info("Extracting sky130_fd_pr__res_generic_l1 device")
extract_devices(resistor("sky130_fd_pr__res_generic_l1", 12.2, NResistor), { "R" => li_resistor, "C" => li_con })

# sky130_fd_pr__res_generic_m1
logger.info("Extracting sky130_fd_pr__res_generic_m1 device")
extract_devices(resistor("sky130_fd_pr__res_generic_m1", 120, NResistor), { "R" => met1_resistor, "C" => met1_con })

# sky130_fd_pr__res_generic_m2
logger.info("Extracting sky130_fd_pr__res_generic_m2 device")
extract_devices(resistor("sky130_fd_pr__res_generic_m2", 120, NResistor), { "R" => met2_resistor, "C" => met2_con })

# sky130_fd_pr__res_generic_m3
logger.info("Extracting sky130_fd_pr__res_generic_m3 device")
extract_devices(resistor("sky130_fd_pr__res_generic_m3", 47, NResistor), { "R" => met3_resistor, "C" => met3_con })

# sky130_fd_pr__res_generic_m4
logger.info("Extracting sky130_fd_pr__res_generic_m4 device")
extract_devices(resistor("sky130_fd_pr__res_generic_m4", 47, NResistor), { "R" => met4_resistor, "C" => met4_con })

# sky130_fd_pr__res_generic_m5
logger.info("Extracting sky130_fd_pr__res_generic_m5 device")
extract_devices(resistor("sky130_fd_pr__res_generic_m5", 29, NResistor), { "R" => met5_resistor, "C" => met5_con })


#==================================
# ------- FUSE EXTRACTION -------
#==================================

logger.info("Starting FUSE EXTRACTION")

if FUSE == "m2"

  # sky130_fd_pr__fuse_m2
  logger.info("Extracting sky130_fd_pr__fuse_m2 device")
  extract_devices(resistor("sky130_fd_pr__fuse_m2", 120, NResistor), { "R" => met2_fuse_res_layer, "C" => met2_con })

elsif FUSE == "m3"

  # sky130_fd_pr__fuse_m3
  logger.info("Extracting sky130_fd_pr__fuse_m3 device")
  extract_devices(resistor("sky130_fd_pr__fuse_m3", 47, NResistor), { "R" => met3_fuse_res_layer, "C" => met3_ncap })

else

  # sky130_fd_pr__fuse_m4
  logger.info("Extracting sky130_fd_pr__fuse_m4 device")
  extract_devices(resistor("sky130_fd_pr__fuse_m4", 47, NResistor), { "R" => met4_fuse_res_layer, "C" => met4_ncap })

end


#==================================
# ------- MIMCAP EXTRACTION -------
#==================================

logger.info("Starting MIMCAP EXTRACTION")

# sky130_fd_pr__model__cap_mim capacitor
logger.info("Extracting sky130_fd_pr__model__cap_mim device")
extract_devices(capacitor("sky130_fd_pr__model__cap_mim", 2e-15, MIMCap), { "P1" => met3_con, "P2" => capm })


# sky130_fd_pr__model__cap_mim_m4 capacitor
logger.info("Extracting sky130_fd_pr__model__cap_mim_m4 device")
extract_devices(capacitor("sky130_fd_pr__model__cap_mim_m4", 2e-15, MIMCap), { "P1" => met4_con, "P2" => capm2 })


#==================================
# ------- VARACTOR EXTRACTION -----
#==================================

logger.info("Starting VARACTOR EXTRACTION")

# Low threshold voltage varactor
logger.info("Extracting low threshold voltage varactor")
extract_devices(capacitor_with_bulk("sky130_fd_pr__cap_var_lvt", 4.4e-15, VarCap), { "P1" => varactor_gate_lvt, "P2" => varactor_nsd_lvt, "W" => varactor_bulk_lvt, "tA" => poly_con, "tB" => ntap_conn})

# High threshold voltage varactor
logger.info("Extracting high threshold voltage varactor")
extract_devices(capacitor_with_bulk("sky130_fd_pr__cap_var_hvt", 4.4e-15, VarCap), { "P1" => varactor_gate_hvt, "P2" => varactor_nsd_hvt, "W" => varactor_bulk_hvt, "tA" => poly_con, "tB" => ntap_conn})


#==================================
# ------ INDUCTOR EXTRACTION ------
#==================================

logger.info("Starting INDUCTOR EXTRACTION")

# RF Inductor with 3 turns and internal diameter of 90um
logger.info("Extracting RF Inductor with 3 turns and internal diameter of 90um")
cls = extract_devices(InductorExtractor::new("sky130_fd_pr__rf_ind_03_90"), {"C1" => met3_ind, "C2" => met2_con, "M" => coil_1 })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# RF Inductor with 5 turns and internal diameter of 125um
logger.info("Extracting RF Inductor with 5 turns and internal diameter of 125um")
cls = extract_devices(InductorExtractor::new("sky130_fd_pr__rf_ind_05_125"), {"C1" => met3_ind, "C2" => met2_con, "M" => coil_2 })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# RF Inductor with 5 turns and internal diameter of 220um
logger.info("Extracting RF Inductor with 5 turns and internal diameter of 220um")
cls = extract_devices(InductorExtractor::new("sky130_fd_pr__rf_ind_05_220"), {"C1" => met3_ind, "C2" => met2_con, "M" => coil_3 })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false


#==================================
# ---------- VPP EXTRACTION -------
#==================================

logger.info("Starting VARACTOR EXTRACTION")

# VPP capacitor with dimensions of 2.4um x 4.6um and with layers of m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_02p4x04p6_m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p4x04p6_m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_02p4x04p6_m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 2.7um x 6.1um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_02p7x06p1_m1m2m3m4_shieldl1_fingercap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p7x06p1_m1m2m3m4_shieldl1_fingercap"), {"C" => met2_vpp, "M" => vpp_02p7x06p1_m1m2m3m4_shieldl1_fingercap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 2.7um x 11.1um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_02p7x11p1_m1m2m3m4_shieldl1_fingercap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p7x11p1_m1m2m3m4_shieldl1_fingercap"), {"C" => met2_vpp, "M" => vpp_02p7x11p1_m1m2m3m4_shieldl1_fingercap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 2.7um x 21.1um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_02p7x21p1_m1m2m3m4_shieldl1_fingercap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p7x21p1_m1m2m3m4_shieldl1_fingercap"), {"C" => met2_vpp, "M" => vpp_02p7x21p1_m1m2m3m4_shieldl1_fingercap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 2.7um x 41.1um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_02p7x41p1_m1m2m3m4_shieldl1_fingercap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p7x41p1_m1m2m3m4_shieldl1_fingercap"), {"C" => met2_vpp, "M" => vpp_02p7x41p1_m1m2m3m4_shieldl1_fingercap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 2.9um x 6.1um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_02p9x06p1_m1m2m3m4_shieldl1_fingercap2")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_02p9x06p1_m1m2m3m4_shieldl1_fingercap2"), {"C" => met2_vpp, "M" => vpp_02p9x06p1_m1m2m3m4_shieldl1_fingercap2, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 3.9um x 3.9um and with layers of m1m2 and shieldl1 with floatm3
logger.info("Extracting sky130_fd_pr__cap_vpp_03p9x03p9_m1m2_shieldl1_floatm3")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_03p9x03p9_m1m2_shieldl1_floatm3"), {"C1" => met2_vpp, "C2" => met3_vpp, "M" => vpp_03p9x03p9_m1m2_shieldl1_floatm3, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of l1m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_l1m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of l1m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_noshield_o2subcell")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_noshield_o2subcell"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_l1m1m2_noshield_o2subcell, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of l1m1m2 and shieldpo with floatm3
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldpo_floatm3")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldpo_floatm3"), {"C1" => met2_vpp, "C2" => met3_vpp, "M" => vpp_04p4x04p6_l1m1m2_shieldpo_floatm3, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of m1m2m3 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_m1m2m3_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of m1m2m3 and shieldl1m5 with floatm4
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_noshield_o2")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_noshield_o2"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_m1m2_noshield_o2, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 4.4um x 4.6um and with layers of m1m2 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_04p4x04p6_m1m2_shieldl1"), {"C" => met2_vpp, "M" => vpp_04p4x04p6_m1m2_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 5.9um x 5.9um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_05p9x05p9_m1m2m3m4_shieldl1_wafflecap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_05p9x05p9_m1m2m3m4_shieldl1_wafflecap"), {"C" => met2_vpp, "M" => vpp_05p9x05p9_m1m2m3m4_shieldl1_wafflecap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 6.8um x 6.1um and with layers of l1m1m2m3 and shieldpom4
logger.info("Extracting sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4"), {"C1" => met2_vpp, "C2" => met4_vpp, "M" => vpp_06p8x06p1_l1m1m2m3_shieldpom4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 6.8um x 6.1um and with layers of m1m2m3 and shieldl1m4
logger.info("Extracting sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4"), {"C1" => met2_vpp, "C2" => met4_vpp, "M" => vpp_06p8x06p1_m1m2m3_shieldl1m4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of l1m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_08p6x07p8_l1m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of l1m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_noshield_o2subcell")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_noshield_o2subcell"), {"C" => met2_vpp, "M" => vpp_08p6x07p8_l1m1m2_noshield_o2subcell, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of l1m1m2 and shieldpo with floatm3
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_shieldpo_floatm3")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_shieldpo_floatm3"), {"C1" => met2_vpp, "C2" => met3_vpp, "M" => vpp_08p6x07p8_l1m1m2_shieldpo_floatm3, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of m1m2m3 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1"), {"C" => met2_vpp, "M" => vpp_08p6x07p8_m1m2m3_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of m1m2m3 and shieldl1m5 with floatm4
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_08p6x07p8_m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 8.6um x 7.8um and with layers of m1m2 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_08p6x07p8_m1m2_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_08p6x07p8_m1m2_shieldl1"), {"C" => met2_vpp, "M" => vpp_08p6x07p8_m1m2_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.3um x 11.3um and with layers of m1m2m3m4 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_11p3x11p3_m1m2m3m4_shieldl1_wafflecap")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p3x11p3_m1m2m3m4_shieldl1_wafflecap"), {"C" => met2_vpp, "M" => vpp_11p3x11p3_m1m2m3m4_shieldl1_wafflecap, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.3um x 11.8um and with layers of l1m1m2m3m4 and shieldm5
logger.info("Extracting vpp cap sky130_fd_pr__cap_vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv")
cls = extract_devices(VPP3NHVExtractor::new("sky130_fd_pr__cap_vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv"),
                 { "MARKER" => vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv, "tA" =>  met2_vpp, "tB" => met1_vpp, "tW" => met5_vpp })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldm5
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldm5, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# # VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
# logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6")
# cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6, "B" => vpp_sub })
# cls.supports_serial_combination = false
# cls.supports_parallel_combination = false

# # VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
# logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7")
# cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7, "B" => vpp_sub })
# cls.supports_serial_combination = false
# cls.supports_parallel_combination = false

# # VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
# logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8")
# cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8, "B" => vpp_sub })
# cls.supports_serial_combination = false
# cls.supports_parallel_combination = false

# # VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
# logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9")
# cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9, "B" => vpp_sub })
# cls.supports_serial_combination = false
# cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3m4 and shieldpom5
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3 and shieldm4
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4"), {"C1" => met2_vpp, "C2" => met4_vpp, "M" => vpp_11p5x11p7_l1m1m2m3_shieldm4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2m3 and shieldpom4
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4"), {"C1" => met2_vpp, "C2" => met4_vpp, "M" => vpp_11p5x11p7_l1m1m2m3_shieldpom4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_l1m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of l1m1m2 and shieldpom3
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3"), {"C1" => met2_vpp, "C2" => met3_vpp, "M" => vpp_11p5x11p7_l1m1m2_shieldpom3, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2m3m4 and shieldl1m5
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_m1m2m3m4_shieldl1m5, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2m3m4 and shieldm5
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_m1m2m3m4_shieldm5, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2m3 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_m1m2m3_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2m3 and shieldl1m5 with floatm4
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4")
cls = extract_devices(VPP4Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4"), {"C1" => met2_vpp, "C2" => met5_vpp, "M" => vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2_noshield"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_m1m2_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m2 and shieldl1
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m2_shieldl1")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m2_shieldl1"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_m1m2_shieldl1, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of m1m4 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_m1m4_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_m1m4_noshield"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_m1m4_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x11p7_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x11p7_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_11p5x11p7_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 11.5um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_11p5x23p1_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_11p5x23p1_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_11p5x23p1_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 22.5um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_22p5x11p7_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_22p5x11p7_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_22p5x11p7_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 22.5um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_22p5x23p1_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_22p5x23p1_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_22p5x23p1_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 33.6um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_33p6x11p7_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_33p6x11p7_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_33p6x11p7_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 33.6um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_33p6x23p1_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_33p6x23p1_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_33p6x23p1_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 44.7um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_44p7x11p7_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_44p7x11p7_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_44p7x11p7_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 44.7um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_44p7x23p1_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_44p7x23p1_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_44p7x23p1_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 55.8um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_55p8x11p7_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_55p8x11p7_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_55p8x11p7_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 55.8um x 11.7um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_55p8x11p7_pol1m1m2m3m4m5_noshield_m5pullin")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_55p8x11p7_pol1m1m2m3m4m5_noshield_m5pullin"), {"C" => met2_vpp, "M" => vpp_55p8x11p7_pol1m1m2m3m4m5_noshield_m5pullin, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 55.8um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield"), {"C" => met2_vpp, "M" => vpp_55p8x23p1_pol1m1m2m3m4m5_noshield, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 55.8um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_m5pullin")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_m5pullin"), {"C" => met2_vpp, "M" => vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_m5pullin, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false

# VPP capacitor with dimensions of 55.8um x 23.1um and with layers of pol1m1m2m3m4m5 and noshield
logger.info("Extracting sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_test")
cls = extract_devices(VPP3Extractor::new("sky130_fd_pr__cap_vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_test"), {"C" => met2_vpp, "M" => vpp_55p8x23p1_pol1m1m2m3m4m5_noshield_test, "B" => vpp_sub })
cls.supports_serial_combination = false
cls.supports_parallel_combination = false


#==================================
# ------- SONOS EXTRACTION --------
#==================================

logger.info("Starting SONOS EXTRACTION")

# Build space flash special SONOSFET star
logger.info("Extracting Build space flash special SONOSFET star")
extract_devices(mos4("sky130_fd_bs_flash__special_sonosfet_star"), { "SD" => sonos_nsd, "G" => sonos_gate, "tS" => sonos_nsd, "tD" => sonos_nsd, "tG" => poly_con, "W" => sub })


#================================================
#------------- COMPARISON OPTIONS ---------------
#================================================

logger.info("Starting SKY130 LVS comparison section")

#=== FLATTEN CELLS ===
align

#=== NETLIST EXTRACTION ===
if SIMPLIFY
  netlist.simplify
end

#=== NETLIST OPTIONS ===
if NET_ONLY
  netlist
end

if TOP_LVL_PINS
  netlist.make_top_level_pins
end

if COMBINE
  netlist.combine_devices()
end

if PURGE
  netlist.purge
end

if PURGE_NETS
  netlist.purge_nets
end

#=== SCHEMATIC OPTIONS ===
if SCH_SIMPLE
  schematic.simplify
end

#=== IGNORE EXTREME VALUES ===
max_res(1e9)
min_caps(1e-16)

#=== COMPARE ===
compare

#=== TIME ESTIMATE ===
exec_end_time = Time.now
run_time = exec_end_time - exec_start_time
logger.info("LVS Total Run time %f seconds" % [run_time])

#=== DECISION ===
if ! compare
  logger.info("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
  logger.error("ERROR : Netlists don't match")
  logger.info("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
  exit(1)
else
  logger.info("==========================================")
  logger.info("INFO : Congratulations! Netlists match.")
  logger.info("==========================================")
end