# Copyright 2022 GlobalFoundries PDK Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

########################################################################################################################
## MOS capacitor Pcells Generators for Klayout of GF180MCU
########################################################################################################################

import pya

def number_spc_contacts(box_width, min_enc, cont_spacing, cont_width):
    """ Calculate number of cantacts in a given dimensions and the free space for symmetry.
        By getting the min enclosure,the width of the box,the width ans spacing of the contacts.
        Parameters
        ----------
        box_width    (double) : length you place the via or cont. in
        min_enc      (double) : spacing between the edge of the box and the first contact.
        cont_spacing (double) : spacing between different contacts
        cont_width   (double) : contacts in the same direction
    """
    spc_cont = box_width - 2 * min_enc
    num_cont = int((spc_cont + cont_spacing) / (cont_width + cont_spacing))
    free_spc = box_width - (num_cont * cont_width +
                            (num_cont - 1) * cont_spacing)
    return num_cont, free_spc

def draw_nmoscap(layout, l, w ,volt, deepnwell, pcmpgr):
    '''
    Usage:-
     used to draw NMOS capacitor (Outside DNWELL) by specifying parameters
    Arguments:-
     layout : Object of layout
     l      : Float of diff length
     w      : Float of diff width
    '''

    # Define layers
    dnwell         = layout.layer(12 , 0 )
    lvpwell        = layout.layer(204, 0 )
    comp           = layout.layer(22 , 0 )
    poly           = layout.layer(30 , 0 )
    nplus          = layout.layer(32 , 0 )
    pplus          = layout.layer(31 , 0 )
    contact        = layout.layer(33 , 0 )
    lvpwell        = layout.layer(204 , 0)
    metal1         = layout.layer(34 , 0 )
    mos_cap_mk     = layout.layer(166, 5 )
    dualgate       = layout.layer(55 , 0 )

    # VARIABLES
    dbu_PERCISION         = 1/layout.dbu
    cmp_w                 = w    * dbu_PERCISION
    cmp_l                 = l    * dbu_PERCISION
    poly_ext              = 0.46 * dbu_PERCISION
    implant_cmp_enc       = 0.16 * dbu_PERCISION
    cmp_poly_enc          = 0.44 * dbu_PERCISION
    cont_size             = 0.22 * dbu_PERCISION
    cont_min_spc          = 0.25 * dbu_PERCISION
    comp_cont_enc         = 0.07 * dbu_PERCISION
    met_cont_enc          = 0.06 * dbu_PERCISION
    metal_cmp_ext_x       = 0.65 * dbu_PERCISION
    metal_cmp_ext_y       = 0.76 * dbu_PERCISION
    met_width             = 1    * dbu_PERCISION
    poly_met_enc_x        = 0.21 * dbu_PERCISION
    poly_met_enc_y        = 0.01 * dbu_PERCISION
    met_con_min           = 0.34 * dbu_PERCISION
    cmp_met_cont_enc_diff = 0.01 * dbu_PERCISION
    cmp_cont_poly_spc     = 0.17 * dbu_PERCISION
    dual_gate_cmp_enc_x   = 0.96 * dbu_PERCISION
    dual_gate_cmp_enc_y   = 1.36 * dbu_PERCISION
    pcmp2ncmp_spc         = 0.36 * dbu_PERCISION
    ply2gr_spc            = 0.3  * dbu_PERCISION
    gr_w                  = 0.36 * dbu_PERCISION
    lvpwell_enc_pcmp      = 0.12 * dbu_PERCISION
    dnwell_enc_lvpwell    = 2.5  * dbu_PERCISION
    dg_enc_dnwell         = 0.5  * dbu_PERCISION
    pcmp_gr2dnw           = 2.5  * dbu_PERCISION

    if volt == "5/6V":
        lvpwell_enc_pcmp      = 0.16 * dbu_PERCISION

    # Inserting nmoscap cell
    cell_index  = layout.add_cell("nmoscap")
    nmoscap_cell = layout.cell(cell_index)

    # Inserting a contact cell
    cont_cell_index = layout.add_cell("contact")
    cont_cell = layout.cell(cont_cell_index)
    cont_cell.shapes(contact).insert(pya.Box.new(0, 0, cont_size, cont_size))

    # Inserting diffusion
    nmoscap_cell.shapes(comp).insert(pya.Box(0, 0, cmp_w, cmp_l))
    nmoscap_cell.shapes(nplus).insert(pya.Box(-implant_cmp_enc, -poly_ext, cmp_w+implant_cmp_enc, cmp_l+poly_ext))

    # Inserting poly
    nmoscap_cell.shapes(poly).insert(pya.Box(cmp_poly_enc, -poly_ext, cmp_w-cmp_poly_enc, cmp_l+poly_ext))

    # Inserting left metal
    nmoscap_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y, -metal_cmp_ext_x+met_width, cmp_l))

    # Inserting right metal
    nmoscap_cell.shapes(metal1).insert(pya.Box(cmp_w+metal_cmp_ext_x-met_width, -metal_cmp_ext_y, cmp_w+metal_cmp_ext_x, cmp_l))

    # Inserting poly metal
    nmoscap_cell.shapes(metal1).insert(pya.Box(cmp_poly_enc+poly_met_enc_x, -poly_ext+poly_met_enc_y, cmp_w-cmp_poly_enc-poly_met_enc_x , cmp_l+poly_ext-poly_met_enc_y))

    # Inserting left contacts
    num_left_con_1, left_con_free_spc_1 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    num_left_con_2, left_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_met_cont_enc_diff+left_con_free_spc_1 / 2, left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_left_con_1, num_left_con_2)
    nmoscap_cell.insert(left_con_arr)

    # Inserting right contacts
    num_right_con_1, right_con_free_spc_1 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    num_right_con_2, right_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w-cmp_met_cont_enc_diff-met_con_min+right_con_free_spc_1 / 2, right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_right_con_1, num_right_con_2)
    nmoscap_cell.insert(right_con_arr)

    # Inserting top contacts
    num_top_con_1, top_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_met_enc_x, comp_cont_enc, cont_min_spc, cont_size)
    num_top_con_2, top_con_free_spc_2 = number_spc_contacts(poly_ext-poly_met_enc_y, comp_cont_enc, cont_min_spc, cont_size)
    top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_met_enc_x+top_con_free_spc_1 / 2, cmp_l+top_con_free_spc_2/2+(cmp_cont_poly_spc-top_con_free_spc_2/2))),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_top_con_1, num_top_con_2)
    nmoscap_cell.insert(top_con_arr)

    # Inserting bottom contacts
    num_bot_con_1, bot_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_met_enc_x, comp_cont_enc, cont_min_spc, cont_size)
    num_bot_con_2, bot_con_free_spc_2 = number_spc_contacts(poly_ext-poly_met_enc_y, comp_cont_enc, cont_min_spc, cont_size)
    bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_met_enc_x+bot_con_free_spc_1 / 2, -poly_ext+poly_met_enc_y+bot_con_free_spc_2/2-(cmp_cont_poly_spc-bot_con_free_spc_2/2))),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_bot_con_1, num_bot_con_2)
    nmoscap_cell.insert(bot_con_arr)

    # Inserting marker
    nmoscap_cell.shapes(mos_cap_mk).insert(pya.Box(0, 0, cmp_w, cmp_l))

    # Inserting marker
    if deepnwell == True:
        # Inserting PCOMP Guard Ring
        cmp_inner = pya.Box(-pcmp2ncmp_spc, -ply2gr_spc-poly_ext, cmp_w+pcmp2ncmp_spc, cmp_l+poly_ext+ply2gr_spc)
        cmp_outer = pya.Box(-pcmp2ncmp_spc-gr_w, -ply2gr_spc-poly_ext-gr_w, cmp_w+pcmp2ncmp_spc+gr_w, cmp_l+poly_ext+gr_w+ply2gr_spc)
        cmp_gr = pya.Region(cmp_outer) - pya.Region(cmp_inner)
        nmoscap_cell.shapes(comp).insert(cmp_gr)
        nmoscap_cell.shapes(metal1).insert(cmp_gr)

        pp_inner = pya.Box(-pcmp2ncmp_spc+implant_cmp_enc, -ply2gr_spc-poly_ext+implant_cmp_enc, cmp_w+pcmp2ncmp_spc-implant_cmp_enc, cmp_l+poly_ext+ply2gr_spc-implant_cmp_enc)
        pp_outer = pya.Box(-pcmp2ncmp_spc-gr_w-implant_cmp_enc, -ply2gr_spc-poly_ext-gr_w-implant_cmp_enc, cmp_w+pcmp2ncmp_spc+gr_w+implant_cmp_enc, cmp_l+poly_ext+gr_w+ply2gr_spc+implant_cmp_enc)
        pp_gr = pya.Region(pp_outer) - pya.Region(pp_inner)
        nmoscap_cell.shapes(pplus).insert(pp_gr)

        # Inserting PCOMP Guard Ring contacts
        num_y_con, y_con_free_spc = number_spc_contacts(2*(gr_w+ply2gr_spc+poly_ext)+cmp_l, comp_cont_enc, cont_min_spc, cont_size)
        num_x_con, x_con_free_spc = number_spc_contacts(cmp_w+2*(comp_cont_enc+pcmp2ncmp_spc-cont_min_spc), comp_cont_enc, cont_min_spc, cont_size)

        left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-pcmp2ncmp_spc-comp_cont_enc-cont_size, -ply2gr_spc-poly_ext-gr_w+y_con_free_spc/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        1, num_y_con)
        nmoscap_cell.insert(left_con_arr)

        bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-pcmp2ncmp_spc+cont_min_spc-comp_cont_enc+x_con_free_spc/2, -ply2gr_spc-poly_ext-comp_cont_enc-cont_size)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_x_con, 1)
        nmoscap_cell.insert(bot_con_arr)

        right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w+pcmp2ncmp_spc+comp_cont_enc, -ply2gr_spc-poly_ext-gr_w+y_con_free_spc/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        1, num_y_con)
        nmoscap_cell.insert(right_con_arr)

        top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-pcmp2ncmp_spc+cont_min_spc-comp_cont_enc+x_con_free_spc/2, cmp_l+ply2gr_spc+poly_ext+comp_cont_enc)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_x_con, 1)
        nmoscap_cell.insert(top_con_arr)

        # Inserting Double Guard Ring
        if pcmpgr == True:
            cmp_inner = pya.Box(-pcmp2ncmp_spc-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw, -ply2gr_spc-poly_ext-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw, cmp_w+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+pcmp_gr2dnw, cmp_l+poly_ext+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+ply2gr_spc+pcmp_gr2dnw)
            cmp_outer = pya.Box(-pcmp2ncmp_spc-2*gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw, -ply2gr_spc-poly_ext-2*gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw, cmp_w+pcmp2ncmp_spc+2*gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+pcmp_gr2dnw, cmp_l+poly_ext+2*gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+ply2gr_spc+pcmp_gr2dnw)
            cmp_gr = pya.Region(cmp_outer) - pya.Region(cmp_inner)
            nmoscap_cell.shapes(comp).insert(cmp_gr)

            pp_inner = pya.Box(-pcmp2ncmp_spc-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw+implant_cmp_enc, -ply2gr_spc-poly_ext-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw+implant_cmp_enc, cmp_w+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+pcmp_gr2dnw-implant_cmp_enc, cmp_l+poly_ext+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+ply2gr_spc+pcmp_gr2dnw-implant_cmp_enc)
            pp_outer = pya.Box(-pcmp2ncmp_spc-2*gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw-implant_cmp_enc, -ply2gr_spc-poly_ext-2*gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw-implant_cmp_enc, cmp_w+pcmp2ncmp_spc+2*gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+pcmp_gr2dnw+implant_cmp_enc, cmp_l+poly_ext+2*gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+ply2gr_spc+pcmp_gr2dnw+implant_cmp_enc)
            pp_gr = pya.Region(pp_outer) - pya.Region(pp_inner)
            nmoscap_cell.shapes(pplus).insert(pp_gr)

        # Inserting lvpwell
        nmoscap_cell.shapes(lvpwell).insert(pya.Box(-pcmp2ncmp_spc-gr_w-lvpwell_enc_pcmp, -ply2gr_spc-poly_ext-gr_w-lvpwell_enc_pcmp, cmp_w+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp, cmp_l+poly_ext+gr_w+lvpwell_enc_pcmp+ply2gr_spc))

        nmoscap_cell.shapes(dnwell).insert(pya.Box(-pcmp2ncmp_spc-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell, -ply2gr_spc-poly_ext-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell, cmp_w+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell, cmp_l+poly_ext+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+ply2gr_spc))

    else:
        # Inserting lvpwell
        nmoscap_cell.shapes(lvpwell).insert(pya.Box(0, 0, cmp_w, cmp_l))

        # Inserting bottom metal
        nmoscap_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y-met_width, cmp_w+metal_cmp_ext_x, -metal_cmp_ext_y))


    if volt == "5/6V":
        # Inserting dualgate
        if deepnwell == True:
            nmoscap_cell.shapes(dualgate).insert(pya.Box(-pcmp2ncmp_spc-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-dg_enc_dnwell, -ply2gr_spc-poly_ext-gr_w-lvpwell_enc_pcmp-dnwell_enc_lvpwell-dg_enc_dnwell, cmp_w+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+dg_enc_dnwell, cmp_l+poly_ext+pcmp2ncmp_spc+gr_w+lvpwell_enc_pcmp+dnwell_enc_lvpwell+dg_enc_dnwell))
        else:
            nmoscap_cell.shapes(dualgate).insert(pya.Box(-dual_gate_cmp_enc_x, -dual_gate_cmp_enc_y, cmp_w+dual_gate_cmp_enc_x, cmp_l+dual_gate_cmp_enc_y))


    nmoscap_cell.flatten(True)
    return nmoscap_cell

def draw_pmoscap(layout, l, w , volt, deepnwell, pcmpgr):
    '''
    Usage:-
     used to draw PMOS capacitor (Outside DNWELL) by specifying parameters
    Arguments:-
     layout : Object of layout
     l      : Float of diff length
     w      : Float of diff width
    '''

    # Define layers
    dnwell         = layout.layer(12 , 0 )
    comp           = layout.layer(22 , 0 )
    poly           = layout.layer(30 , 0 )
    pplus          = layout.layer(31 , 0 )
    nplus          = layout.layer(32 , 0 )
    contact        = layout.layer(33 , 0 )
    nwell          = layout.layer(21 , 0 )
    metal1         = layout.layer(34 , 0 )
    mos_cap_mk     = layout.layer(166, 5 )
    dualgate       = layout.layer(55 , 0 )

    # VARIABLES
    dbu_PERCISION         = 1/layout.dbu
    cmp_w                 = w    * dbu_PERCISION
    cmp_l                 = l    * dbu_PERCISION
    poly_ext              = 0.46 * dbu_PERCISION
    implant_cmp_enc       = 0.16 * dbu_PERCISION
    cmp_poly_enc          = 0.44 * dbu_PERCISION
    cont_size             = 0.22 * dbu_PERCISION
    cont_min_spc          = 0.25 * dbu_PERCISION
    comp_cont_enc         = 0.07 * dbu_PERCISION
    met_cont_enc          = 0.06 * dbu_PERCISION
    metal_cmp_ext_x       = 0.65 * dbu_PERCISION
    met_width             = 1    * dbu_PERCISION
    poly_met_enc_x        = 0.19 * dbu_PERCISION
    poly_met_enc_y        = 0.01 * dbu_PERCISION
    met_con_min           = 0.34 * dbu_PERCISION
    cmp_met_cont_enc_diff = 0.01 * dbu_PERCISION
    gr_width              = 0.36 * dbu_PERCISION
    ncmp_pcmp_spc         = 0.36 * dbu_PERCISION
    poly_ncmp_spc         = 0.3  * dbu_PERCISION
    nwell_cmp_enc         = 0.16 * dbu_PERCISION
    cmp_met_spc           = 0.11 * dbu_PERCISION
    cont_spc_gr           = 0.11 * dbu_PERCISION
    dual_gate_cmp_enc_x   = 0.96 * dbu_PERCISION
    dual_gate_cmp_enc_y   = 1.36 * dbu_PERCISION
    dnwell_enc_ncmp       = 0.62 * dbu_PERCISION
    dg_enc_dnwell         = 0.5  * dbu_PERCISION
    pcmp_gr2dnw           = 2.5  * dbu_PERCISION

    if volt == "5/6V":
        dnwell_enc_ncmp       = 0.66 * dbu_PERCISION

    # Inserting pmoscap cell
    cell_index  = layout.add_cell("pmoscap")
    pmoscap_cell = layout.cell(cell_index)

    # Inserting a contact cell
    cont_cell_index = layout.add_cell("contact")
    cont_cell = layout.cell(cont_cell_index)
    cont_cell.shapes(contact).insert(pya.Box.new(0, 0, cont_size, cont_size))

    # Inserting diffusion
    pmoscap_cell.shapes(comp).insert(pya.Box(0, 0, cmp_w, cmp_l))
    pmoscap_cell.shapes(pplus).insert(pya.Box(-implant_cmp_enc, -poly_ext, cmp_w+implant_cmp_enc, cmp_l+poly_ext))

    # Inserting poly
    pmoscap_cell.shapes(poly).insert(pya.Box(cmp_poly_enc, -poly_ext, cmp_w-cmp_poly_enc, cmp_l+poly_ext))

    # Inserting left cmp metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(-ncmp_pcmp_spc-gr_width, 0 , -metal_cmp_ext_x+met_width, cmp_l))

    # Inserting right cmp metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(cmp_w+metal_cmp_ext_x-met_width, 0, cmp_w+ncmp_pcmp_spc+gr_width, cmp_l))

    # Inserting top cmp metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(cmp_poly_enc+poly_met_enc_x, cmp_l+cmp_met_spc , cmp_w-cmp_poly_enc-poly_met_enc_x , cmp_l+poly_ext-poly_met_enc_y))

    # Inserting bottom cmp metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(cmp_poly_enc+poly_met_enc_x, -poly_ext+poly_met_enc_y, cmp_w-cmp_poly_enc-poly_met_enc_x , -cmp_met_spc))

    # Inserting left cmp contacts
    num_left_con_1, left_con_free_spc_1 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    num_left_con_2, left_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_met_cont_enc_diff+left_con_free_spc_1 / 2, left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_left_con_1, num_left_con_2)
    pmoscap_cell.insert(left_con_arr)

    # Inserting right cmp contacts
    num_right_con_1, right_con_free_spc_1 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    num_right_con_2, right_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w-cmp_met_cont_enc_diff-met_con_min+right_con_free_spc_1 / 2, right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_right_con_1, num_right_con_2)
    pmoscap_cell.insert(right_con_arr)

    # Inserting top cmp contacts
    num_top_con_1, top_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_met_enc_x, met_cont_enc, cont_min_spc, cont_size)
    num_top_con_2, top_con_free_spc_2 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_met_enc_x+top_con_free_spc_1 / 2, cmp_l+cmp_met_spc+top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_top_con_1, num_top_con_2)
    pmoscap_cell.insert(top_con_arr)

    # Inserting bottom cmp contacts
    num_bot_con_1, bot_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_met_enc_x, met_cont_enc, cont_min_spc, cont_size)
    num_bot_con_2, bot_con_free_spc_2 = number_spc_contacts(met_con_min, met_cont_enc, cont_min_spc, cont_size)
    bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_met_enc_x+bot_con_free_spc_1 / 2, -poly_ext+poly_met_enc_y+bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_bot_con_1, num_bot_con_2)
    pmoscap_cell.insert(bot_con_arr)

    # Inserting left GR diff
    pmoscap_cell.shapes(comp).insert(pya.Box(-ncmp_pcmp_spc-gr_width, -poly_ext-poly_ncmp_spc , -ncmp_pcmp_spc , cmp_l+poly_ext+poly_ncmp_spc))
    pmoscap_cell.shapes(nplus).insert(pya.Box(-ncmp_pcmp_spc-gr_width-implant_cmp_enc, -poly_ext-poly_ncmp_spc+implant_cmp_enc , -ncmp_pcmp_spc+implant_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc-implant_cmp_enc))
    # Inserting right GR diff
    pmoscap_cell.shapes(comp).insert(pya.Box(cmp_w+ncmp_pcmp_spc, -poly_ext-poly_ncmp_spc , cmp_w+ncmp_pcmp_spc+gr_width , cmp_l+poly_ext+poly_ncmp_spc))
    pmoscap_cell.shapes(nplus).insert(pya.Box(cmp_w+ncmp_pcmp_spc-implant_cmp_enc, -poly_ext-poly_ncmp_spc+implant_cmp_enc , cmp_w+ncmp_pcmp_spc+gr_width+implant_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc-implant_cmp_enc))
    # Inserting top GR diff
    pmoscap_cell.shapes(comp).insert(pya.Box(-ncmp_pcmp_spc-gr_width, cmp_l+poly_ext+poly_ncmp_spc , cmp_w+ncmp_pcmp_spc+gr_width , cmp_l+poly_ext+poly_ncmp_spc+gr_width))
    pmoscap_cell.shapes(nplus).insert(pya.Box(-ncmp_pcmp_spc-gr_width-implant_cmp_enc, cmp_l+poly_ext+poly_ncmp_spc-implant_cmp_enc , cmp_w+ncmp_pcmp_spc+gr_width+implant_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc+gr_width+implant_cmp_enc))
    # Inserting bottom GR diff
    pmoscap_cell.shapes(comp).insert(pya.Box(-ncmp_pcmp_spc-gr_width, -poly_ext-poly_ncmp_spc-gr_width , cmp_w+ncmp_pcmp_spc+gr_width , -poly_ext-poly_ncmp_spc))
    pmoscap_cell.shapes(nplus).insert(pya.Box(-ncmp_pcmp_spc-gr_width-implant_cmp_enc, -poly_ext-poly_ncmp_spc-gr_width-implant_cmp_enc , cmp_w+ncmp_pcmp_spc+gr_width+implant_cmp_enc , -poly_ext-poly_ncmp_spc+implant_cmp_enc))

    # Inserting left GR metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(-ncmp_pcmp_spc-gr_width, -poly_ext-poly_ncmp_spc , -ncmp_pcmp_spc , cmp_l+poly_ext+poly_ncmp_spc))
    # Inserting right GR metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(cmp_w+ncmp_pcmp_spc, -poly_ext-poly_ncmp_spc , cmp_w+ncmp_pcmp_spc+gr_width , cmp_l+poly_ext+poly_ncmp_spc))
    # Inserting top GR metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(-ncmp_pcmp_spc-gr_width, cmp_l+poly_ext+poly_ncmp_spc , cmp_w+ncmp_pcmp_spc+gr_width , cmp_l+poly_ext+poly_ncmp_spc+gr_width))
    # Inserting bottom GR metal
    pmoscap_cell.shapes(metal1).insert(pya.Box(-ncmp_pcmp_spc-gr_width, -poly_ext-poly_ncmp_spc-gr_width , cmp_w+ncmp_pcmp_spc+gr_width , -poly_ext-poly_ncmp_spc))

    # Inserting left GR cont
    num_gr_left_con_1, gr_left_con_free_spc_1 = number_spc_contacts(gr_width, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_left_con_2, gr_left_con_free_spc_2 = number_spc_contacts(cmp_l+2*poly_ext+2*poly_ncmp_spc-2*cont_spc_gr, comp_cont_enc, cont_min_spc, cont_size)
    gr_left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-ncmp_pcmp_spc-gr_width+gr_left_con_free_spc_1 / 2, cont_spc_gr-poly_ext-poly_ncmp_spc+gr_left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_left_con_1, num_gr_left_con_2)
    pmoscap_cell.insert(gr_left_con_arr)

    # Inserting right GR cont
    num_gr_right_con_1, gr_right_con_free_spc_1 = number_spc_contacts(gr_width, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_right_con_2, gr_right_con_free_spc_2 = number_spc_contacts(cmp_l+2*poly_ext+2*poly_ncmp_spc-2*cont_spc_gr, comp_cont_enc, cont_min_spc, cont_size)
    gr_right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w+ncmp_pcmp_spc+gr_right_con_free_spc_1 / 2, cont_spc_gr-poly_ext-poly_ncmp_spc+gr_right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_right_con_1, num_gr_right_con_2)
    pmoscap_cell.insert(gr_right_con_arr)

    # Inserting top GR cont
    num_gr_top_con_1, gr_top_con_free_spc_1 = number_spc_contacts(cmp_w+2*ncmp_pcmp_spc+2*gr_width, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_top_con_2, gr_top_con_free_spc_2 = number_spc_contacts(gr_width, comp_cont_enc, cont_min_spc, cont_size)
    gr_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-ncmp_pcmp_spc-gr_width+comp_cont_enc, cmp_l+poly_ext+poly_ncmp_spc +gr_top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_top_con_1, num_gr_top_con_2)
    pmoscap_cell.insert(gr_top_con_arr)

    # Inserting bottom GR cont
    num_gr_top_con_1, gr_top_con_free_spc_1 = number_spc_contacts(cmp_w+2*ncmp_pcmp_spc+2*gr_width, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_top_con_2, gr_top_con_free_spc_2 = number_spc_contacts(gr_width, comp_cont_enc, cont_min_spc, cont_size)
    gr_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-ncmp_pcmp_spc-gr_width+comp_cont_enc, -poly_ext-poly_ncmp_spc-gr_width +gr_top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_top_con_1, num_gr_top_con_2)
    pmoscap_cell.insert(gr_top_con_arr)

    # Inserting marker
    pmoscap_cell.shapes(mos_cap_mk).insert(pya.Box(0, 0, cmp_w, cmp_l))

    # Inserting marker
    if deepnwell == True:
        # Inserting dnwell
        pmoscap_cell.shapes(dnwell).insert(pya.Box(-ncmp_pcmp_spc-gr_width-dnwell_enc_ncmp, -poly_ext-poly_ncmp_spc-gr_width-dnwell_enc_ncmp, cmp_w+ncmp_pcmp_spc+gr_width+dnwell_enc_ncmp , cmp_l+poly_ext+poly_ncmp_spc+gr_width+dnwell_enc_ncmp))

        # Inserting Double Guard Ring
        if pcmpgr == True:
            cmp_inner = pya.Box(-ncmp_pcmp_spc-gr_width-dnwell_enc_ncmp-pcmp_gr2dnw, -poly_ext-poly_ncmp_spc-gr_width-dnwell_enc_ncmp-pcmp_gr2dnw, cmp_w+ncmp_pcmp_spc+gr_width+dnwell_enc_ncmp+pcmp_gr2dnw , cmp_l+poly_ext+poly_ncmp_spc+gr_width+dnwell_enc_ncmp+pcmp_gr2dnw)
            cmp_outer = pya.Box(-ncmp_pcmp_spc-2*gr_width-dnwell_enc_ncmp-pcmp_gr2dnw, -poly_ext-poly_ncmp_spc-2*gr_width-dnwell_enc_ncmp-pcmp_gr2dnw, cmp_w+ncmp_pcmp_spc+2*gr_width+dnwell_enc_ncmp+pcmp_gr2dnw , cmp_l+poly_ext+poly_ncmp_spc+2*gr_width+dnwell_enc_ncmp+pcmp_gr2dnw)
            cmp_gr = pya.Region(cmp_outer) - pya.Region(cmp_inner)
            pmoscap_cell.shapes(comp).insert(cmp_gr)

            pp_inner = pya.Box(-ncmp_pcmp_spc-gr_width-dnwell_enc_ncmp-pcmp_gr2dnw+implant_cmp_enc, -poly_ext-poly_ncmp_spc-gr_width-dnwell_enc_ncmp-pcmp_gr2dnw+implant_cmp_enc, cmp_w+ncmp_pcmp_spc+gr_width+dnwell_enc_ncmp+pcmp_gr2dnw-implant_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc+gr_width+dnwell_enc_ncmp+pcmp_gr2dnw-implant_cmp_enc)
            pp_outer = pya.Box(-ncmp_pcmp_spc-2*gr_width-dnwell_enc_ncmp-pcmp_gr2dnw-implant_cmp_enc, -poly_ext-poly_ncmp_spc-2*gr_width-dnwell_enc_ncmp-pcmp_gr2dnw-implant_cmp_enc, cmp_w+ncmp_pcmp_spc+2*gr_width+dnwell_enc_ncmp+pcmp_gr2dnw+implant_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc+2*gr_width+dnwell_enc_ncmp+pcmp_gr2dnw+implant_cmp_enc)
            pp_gr = pya.Region(pp_outer) - pya.Region(pp_inner)
            pmoscap_cell.shapes(pplus).insert(pp_gr)

    else:
        # Inserting nwell
        pmoscap_cell.shapes(nwell).insert(pya.Box(-ncmp_pcmp_spc-gr_width-nwell_cmp_enc, -poly_ext-poly_ncmp_spc-gr_width-nwell_cmp_enc, cmp_w+ncmp_pcmp_spc+gr_width+nwell_cmp_enc , cmp_l+poly_ext+poly_ncmp_spc+gr_width+nwell_cmp_enc))

    if volt == "5/6V":
        # Inserting dualgate
        if deepnwell == True:
            pmoscap_cell.shapes(dualgate).insert(pya.Box(-ncmp_pcmp_spc-gr_width-dnwell_enc_ncmp-dg_enc_dnwell, -poly_ext-poly_ncmp_spc-gr_width-dnwell_enc_ncmp-dg_enc_dnwell, cmp_w+ncmp_pcmp_spc+gr_width+dnwell_enc_ncmp+dg_enc_dnwell, cmp_l+poly_ext+poly_ncmp_spc+gr_width+dnwell_enc_ncmp+dg_enc_dnwell))
        else:
            pmoscap_cell.shapes(dualgate).insert(pya.Box(-dual_gate_cmp_enc_x, -dual_gate_cmp_enc_y, cmp_w+dual_gate_cmp_enc_x, cmp_l+dual_gate_cmp_enc_y))

    pmoscap_cell.flatten(True)
    return pmoscap_cell

def draw_nmoscap_b(layout, l, w , volt):
    '''
    Usage:-
     used to draw 3.3V NMOS capacitor (inside NWell) by specifying parameters
    Arguments:-
     layout : Object of layout
     l      : Float of diff length
     w      : Float of diff width
    '''

    # Define layers
    comp           = layout.layer(22 , 0 )
    poly           = layout.layer(30 , 0 )
    nplus          = layout.layer(32 , 0 )
    contact        = layout.layer(33 , 0 )
    nwell          = layout.layer(21 , 0 )
    metal1         = layout.layer(34 , 0 )
    mos_cap_mk     = layout.layer(166, 5 )
    dualgate       = layout.layer(55 , 0 )

    # VARIABLES
    dbu_PERCISION         = 1/layout.dbu
    cmp_w                 = w    * dbu_PERCISION
    cmp_l                 = l    * dbu_PERCISION
    poly_ext              = 0.3  * dbu_PERCISION
    implant_cmp_enc       = 0.16 * dbu_PERCISION
    cmp_poly_enc          = 0.44 * dbu_PERCISION
    cont_size             = 0.22 * dbu_PERCISION
    cont_min_spc          = 0.25 * dbu_PERCISION
    comp_cont_enc         = 0.07 * dbu_PERCISION
    met_cont_enc          = 0.06 * dbu_PERCISION
    metal_cmp_ext_x       = 0.59 * dbu_PERCISION
    metal_cmp_ext_y       = 2.2  * dbu_PERCISION
    met_width             = 1    * dbu_PERCISION
    poly_met_enc_x        = 0.17 * dbu_PERCISION
    poly_met_enc_y        = 0.01 * dbu_PERCISION
    met_con_min           = 0.34 * dbu_PERCISION
    cmp_met_cont_enc_diff = 0.01 * dbu_PERCISION
    cmp_cont_poly_spc     = 0.17 * dbu_PERCISION
    nwell_cmp_enc_x       = 0.18 * dbu_PERCISION
    nwell_cmp_enc_y       = 1.38 * dbu_PERCISION
    poly_extra_in         = 0.27 * dbu_PERCISION
    poly_extra_out        = 0.9  * dbu_PERCISION
    dualgate_cmp_enc_x    = 0.24 * dbu_PERCISION
    dualgate_cmp_enc_y    = 1.6  * dbu_PERCISION

    # Inserting nmoscap cell
    cell_index  = layout.add_cell("nmoscap_b")
    nmoscap_b_cell = layout.cell(cell_index)

    # Inserting a contact cell
    cont_cell_index = layout.add_cell("contact")
    cont_cell = layout.cell(cont_cell_index)
    cont_cell.shapes(contact).insert(pya.Box.new(0, 0, cont_size, cont_size))

    # Inserting diffusion
    nmoscap_b_cell.shapes(comp).insert(pya.Box(0, 0, cmp_w, cmp_l))
    nmoscap_b_cell.shapes(nplus).insert(pya.Box(-nwell_cmp_enc_x, -nwell_cmp_enc_y, cmp_w+nwell_cmp_enc_x, cmp_l+nwell_cmp_enc_y))

    # Inserting nwell
    nmoscap_b_cell.shapes(nwell).insert(pya.Box(-nwell_cmp_enc_x, -nwell_cmp_enc_y, cmp_w+nwell_cmp_enc_x, cmp_l+nwell_cmp_enc_y))

    # Inserting poly
    nmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc, -poly_ext, cmp_w-cmp_poly_enc, cmp_l+poly_ext))

    # Inserting extra poly
    nmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc+poly_extra_in, cmp_l+poly_ext, cmp_w-cmp_poly_enc-poly_extra_in, cmp_l+poly_ext+poly_extra_out))  #top
    nmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc+poly_extra_in, -poly_ext-poly_extra_out, cmp_w-cmp_poly_enc-poly_extra_in, -poly_ext))            #bot

    # Inserting left metal
    nmoscap_b_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y, -metal_cmp_ext_x+met_width, cmp_l))

    # Inserting right metal
    nmoscap_b_cell.shapes(metal1).insert(pya.Box(cmp_w+metal_cmp_ext_x-met_width, -metal_cmp_ext_y-met_width, cmp_w+metal_cmp_ext_x, cmp_l))

    # Inserting bottom metal
    nmoscap_b_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y-met_width, cmp_w+metal_cmp_ext_x, -metal_cmp_ext_y))

    # Inserting poly metal
    nmoscap_b_cell.shapes(metal1).insert(pya.Box(cmp_poly_enc+poly_extra_in, -poly_ext-poly_extra_out, cmp_w-cmp_poly_enc-poly_extra_in, cmp_l+poly_ext+poly_extra_out))

    # Inserting left cmp contacts
    num_left_con_1, left_con_free_spc_1 = number_spc_contacts(met_con_min, comp_cont_enc, cont_min_spc, cont_size)
    num_left_con_2, left_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_met_cont_enc_diff+left_con_free_spc_1 / 2, left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_left_con_1, num_left_con_2)
    nmoscap_b_cell.insert(left_con_arr)

    # Inserting right cmp contacts
    num_right_con_1, right_con_free_spc_1 = number_spc_contacts(met_con_min, comp_cont_enc, cont_min_spc, cont_size)
    num_right_con_2, right_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w-cmp_met_cont_enc_diff-met_con_min+right_con_free_spc_1 / 2, right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_right_con_1, num_right_con_2)
    nmoscap_b_cell.insert(right_con_arr)

    # Inserting top poly contacts
    num_top_con_1, top_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_extra_in, comp_cont_enc, cont_min_spc, cont_size)
    num_top_con_2, top_con_free_spc_2 = number_spc_contacts(poly_extra_out, comp_cont_enc, cont_min_spc, cont_size)
    top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_extra_in+top_con_free_spc_1 / 2, cmp_l+poly_ext+top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_top_con_1, num_top_con_2)
    nmoscap_b_cell.insert(top_con_arr)

    # Inserting bottom poly contacts
    num_bot_con_1, bot_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_extra_in, comp_cont_enc, cont_min_spc, cont_size)
    num_bot_con_2, bot_con_free_spc_2 = number_spc_contacts(poly_extra_out, comp_cont_enc, cont_min_spc, cont_size)
    bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_extra_in+bot_con_free_spc_1 / 2, -poly_ext-poly_extra_out+bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_bot_con_1, num_bot_con_2)
    nmoscap_b_cell.insert(bot_con_arr)

    # Inserting marker
    nmoscap_b_cell.shapes(mos_cap_mk).insert(pya.Box(0, 0, cmp_w, cmp_l))

    if volt == "5/6V":
        # Inserting dualgate
        nmoscap_b_cell.shapes(dualgate).insert(pya.Box(-dualgate_cmp_enc_x, -dualgate_cmp_enc_y, cmp_w+dualgate_cmp_enc_x, cmp_l+dualgate_cmp_enc_y))


    nmoscap_b_cell.flatten(True)
    return nmoscap_b_cell

def draw_pmoscap_b(layout, l, w , volt):
    '''
    Usage:-
     used to draw PMOS capacitor (inside Psub) by specifying parameters
    Arguments:-
     layout : Object of layout
     l      : Float of diff length
     w      : Float of diff width
    '''

    # Define layers
    comp           = layout.layer(22 , 0 )
    poly           = layout.layer(30 , 0 )
    pplus          = layout.layer(31 , 0 )
    contact        = layout.layer(33 , 0 )
    metal1         = layout.layer(34 , 0 )
    mos_cap_mk     = layout.layer(166, 5 )
    dualgate       = layout.layer(55 , 0 )

    # VARIABLES
    dbu_PERCISION         = 1/layout.dbu
    cmp_w                 = w    * dbu_PERCISION
    cmp_l                 = l    * dbu_PERCISION
    poly_ext              = 0.3  * dbu_PERCISION
    cmp_poly_enc          = 0.44 * dbu_PERCISION
    cont_size             = 0.22 * dbu_PERCISION
    cont_min_spc          = 0.25 * dbu_PERCISION
    comp_cont_enc         = 0.07 * dbu_PERCISION
    met_cont_enc          = 0.06 * dbu_PERCISION
    metal_cmp_ext_x       = 0.59 * dbu_PERCISION
    metal_cmp_ext_y       = 2.2  * dbu_PERCISION
    met_width             = 1    * dbu_PERCISION
    met_con_min           = 0.34 * dbu_PERCISION
    cmp_met_cont_enc_diff = 0.01 * dbu_PERCISION
    nwell_cmp_enc_x       = 0.18 * dbu_PERCISION
    nwell_cmp_enc_y       = 1.38 * dbu_PERCISION
    poly_extra_in         = 0.27 * dbu_PERCISION
    poly_extra_out        = 0.9  * dbu_PERCISION
    dualgate_cmp_enc_x    = 0.24 * dbu_PERCISION
    dualgate_cmp_enc_y    = 1.6  * dbu_PERCISION

    # Inserting pmoscap cell
    cell_index  = layout.add_cell("pmoscap_b")
    pmoscap_b_cell = layout.cell(cell_index)

    # Inserting a contact cell
    cont_cell_index = layout.add_cell("contact")
    cont_cell = layout.cell(cont_cell_index)
    cont_cell.shapes(contact).insert(pya.Box.new(0, 0, cont_size, cont_size))

    # Inserting diffusion
    pmoscap_b_cell.shapes(comp).insert(pya.Box(0, 0, cmp_w, cmp_l))
    pmoscap_b_cell.shapes(pplus).insert(pya.Box(-nwell_cmp_enc_x, -nwell_cmp_enc_y, cmp_w+nwell_cmp_enc_x, cmp_l+nwell_cmp_enc_y))

    # Inserting poly
    pmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc, -poly_ext, cmp_w-cmp_poly_enc, cmp_l+poly_ext))

    # Inserting extra poly
    pmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc+poly_extra_in, cmp_l+poly_ext, cmp_w-cmp_poly_enc-poly_extra_in, cmp_l+poly_ext+poly_extra_out))  #top
    pmoscap_b_cell.shapes(poly).insert(pya.Box(cmp_poly_enc+poly_extra_in, -poly_ext-poly_extra_out, cmp_w-cmp_poly_enc-poly_extra_in, -poly_ext))            #bot

    # Inserting left metal
    pmoscap_b_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y, -metal_cmp_ext_x+met_width, cmp_l))

    # Inserting right metal
    pmoscap_b_cell.shapes(metal1).insert(pya.Box(cmp_w+metal_cmp_ext_x-met_width, -metal_cmp_ext_y-met_width, cmp_w+metal_cmp_ext_x, cmp_l))

    # Inserting bottom metal
    pmoscap_b_cell.shapes(metal1).insert(pya.Box(-metal_cmp_ext_x, -metal_cmp_ext_y-met_width, cmp_w+metal_cmp_ext_x, -metal_cmp_ext_y))

    # Inserting poly metal
    pmoscap_b_cell.shapes(metal1).insert(pya.Box(cmp_poly_enc+poly_extra_in, -poly_ext-poly_extra_out, cmp_w-cmp_poly_enc-poly_extra_in, cmp_l+poly_ext+poly_extra_out))

    # Inserting left cmp contacts
    num_left_con_1, left_con_free_spc_1 = number_spc_contacts(met_con_min, comp_cont_enc, cont_min_spc, cont_size)
    num_left_con_2, left_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_met_cont_enc_diff+left_con_free_spc_1 / 2, left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_left_con_1, num_left_con_2)
    pmoscap_b_cell.insert(left_con_arr)

    # Inserting right cmp contacts
    num_right_con_1, right_con_free_spc_1 = number_spc_contacts(met_con_min, comp_cont_enc, cont_min_spc, cont_size)
    num_right_con_2, right_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_w-cmp_met_cont_enc_diff-met_con_min+right_con_free_spc_1 / 2, right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_right_con_1, num_right_con_2)
    pmoscap_b_cell.insert(right_con_arr)

    # Inserting top poly contacts
    num_top_con_1, top_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_extra_in, comp_cont_enc, cont_min_spc, cont_size)
    num_top_con_2, top_con_free_spc_2 = number_spc_contacts(poly_extra_out, comp_cont_enc, cont_min_spc, cont_size)
    top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_extra_in+top_con_free_spc_1 / 2, cmp_l+poly_ext+top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_top_con_1, num_top_con_2)
    pmoscap_b_cell.insert(top_con_arr)

    # Inserting bottom poly contacts
    num_bot_con_1, bot_con_free_spc_1 = number_spc_contacts(cmp_w-2*cmp_poly_enc-2*poly_extra_in, comp_cont_enc, cont_min_spc, cont_size)
    num_bot_con_2, bot_con_free_spc_2 = number_spc_contacts(poly_extra_out, comp_cont_enc, cont_min_spc, cont_size)
    bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(cmp_poly_enc+poly_extra_in+bot_con_free_spc_1 / 2, -poly_ext-poly_extra_out+bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_bot_con_1, num_bot_con_2)
    pmoscap_b_cell.insert(bot_con_arr)

    # Inserting marker
    pmoscap_b_cell.shapes(mos_cap_mk).insert(pya.Box(0, 0, cmp_w, cmp_l))

    if volt == "5/6V":
        # Inserting dualgate
        pmoscap_b_cell.shapes(dualgate).insert(pya.Box(-dualgate_cmp_enc_x, -dualgate_cmp_enc_y, cmp_w+dualgate_cmp_enc_x, cmp_l+dualgate_cmp_enc_y))


    pmoscap_b_cell.flatten(True)
    return pmoscap_b_cell