# 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.

########################################################################################################################
## Diode 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_np_diode(layout, l, w , volt, deepnwell, pcmpgr):
    '''
    Usage:-
     used to draw N+/LVPWELL diode (Outside DNWELL) by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diff length
     w          : Float of diff width
     volt       : String of operating voltage of the diode [3.3V, 5V/6V]
     deepnwell  : Boolean of using Deep NWELL device
     pcmpgr     : Boolean of using P+ Guard Ring for Deep NWELL devices only
    '''

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

    # Define variables
    dbu_PERCISION       = 1/layout.dbu
    pcmp2ncmp_spc       = 0.48 * dbu_PERCISION
    ncmp_w              = 0.36 * dbu_PERCISION
    pcmp_w              = w * dbu_PERCISION
    cmp_l               = l * dbu_PERCISION
    implant_comp_enc    = 0.16 * dbu_PERCISION
    comp_cont_enc       = 0.07 * dbu_PERCISION
    cont_size           = 0.22 * dbu_PERCISION
    cont_min_spc        = 0.28 * dbu_PERCISION
    dualgate_cmp_enc    = 0.24 * dbu_PERCISION
    dg_enc_dnwell       = 0.5  * dbu_PERCISION
    dnwell_enc_lvpwell  = 2.5  * dbu_PERCISION
    lvpwell_enc_ncmp    = 0.6  * dbu_PERCISION
    lvpwell_enc_pcmp    = 0.16 * dbu_PERCISION
    min_cmp_area        = 0.2025 * dbu_PERCISION * dbu_PERCISION
    tie_violat          = 0      * dbu_PERCISION
    pcmp_gr2dnw         = 2.5    * dbu_PERCISION

    # Inserting np cell
    cell_index      = layout.add_cell("np_diode")
    np_diode_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
    if (cmp_l * ncmp_w) < min_cmp_area:
        tie_violat = (min_cmp_area/ncmp_w - cmp_l)/2
    np_diode_cell.shapes(comp).insert(pya.Box(0, -tie_violat, ncmp_w, cmp_l+tie_violat))
    np_diode_cell.shapes(pplus).insert(pya.Box(-implant_comp_enc, -implant_comp_enc-tie_violat, ncmp_w+implant_comp_enc, cmp_l+implant_comp_enc+tie_violat))

    np_diode_cell.shapes(comp).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))
    np_diode_cell.shapes(nplus).insert(pya.Box(ncmp_w+pcmp2ncmp_spc-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    # Inserting metal
    np_diode_cell.shapes(metal1).insert(pya.Box(0, -tie_violat, ncmp_w, cmp_l+tie_violat))
    np_diode_cell.shapes(metal1).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))


    # Inserting pcomp contacts
    num_ncmp_con_1, ncmp_con_free_spc_1 = number_spc_contacts(ncmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_ncmp_con_2, ncmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    ncmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_con_free_spc_1 / 2, ncmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_ncmp_con_1, num_ncmp_con_2)
    np_diode_cell.insert(ncmp_con_arr)

    # Inserting ncomp contacts
    num_pcmp_con_1, pcmp_con_free_spc_1 = number_spc_contacts(pcmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_con_2, pcmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_w+pcmp2ncmp_spc+pcmp_con_free_spc_1 / 2, pcmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_con_1, num_pcmp_con_2)
    np_diode_cell.insert(pcmp_con_arr)

    # Inserting Deep NWELL layers
    if deepnwell == True:
        np_diode_cell.shapes(lvpwell).insert(pya.Box(-lvpwell_enc_pcmp, -lvpwell_enc_ncmp, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp, cmp_l+lvpwell_enc_ncmp))
        np_diode_cell.shapes(dnwell).insert(pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell, -lvpwell_enc_ncmp-dnwell_enc_lvpwell, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell))

        # Inserting Deep NWELL P+ Guard Ring
        if pcmpgr == True:
            cmp_inner   = pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw, -lvpwell_enc_ncmp-dnwell_enc_lvpwell-pcmp_gr2dnw, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw)
            cmp_outer   = pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw-ncmp_w, -lvpwell_enc_ncmp-dnwell_enc_lvpwell-pcmp_gr2dnw-ncmp_w, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw+ncmp_w, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw+ncmp_w)
            cmp_gr      = pya.Region(cmp_outer) - pya.Region(cmp_inner)
            np_diode_cell.shapes(comp).insert(cmp_gr)

            pp_inner = pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw+implant_comp_enc, -lvpwell_enc_ncmp-dnwell_enc_lvpwell-pcmp_gr2dnw+implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw-implant_comp_enc, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw-implant_comp_enc)
            pp_outer = pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell-pcmp_gr2dnw-ncmp_w-implant_comp_enc, -lvpwell_enc_ncmp-dnwell_enc_lvpwell-pcmp_gr2dnw-ncmp_w-implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw+ncmp_w+implant_comp_enc, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell+pcmp_gr2dnw+ncmp_w+implant_comp_enc)
            pp_gr    = pya.Region(pp_outer) - pya.Region(pp_inner)
            np_diode_cell.shapes(pplus).insert(pp_gr)

    if volt == "5/6V":
        # Inserting marker
        np_diode_cell.shapes(diode_mk).insert(pya.Box(-dualgate_cmp_enc, -dualgate_cmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+dualgate_cmp_enc, cmp_l+dualgate_cmp_enc))
        # Inserting dualgate
        if deepnwell == True:
            np_diode_cell.shapes(dualgate).insert(pya.Box(-lvpwell_enc_pcmp-dnwell_enc_lvpwell-dg_enc_dnwell, -lvpwell_enc_ncmp-dnwell_enc_lvpwell-dg_enc_dnwell, ncmp_w+pcmp2ncmp_spc+pcmp_w+lvpwell_enc_ncmp+dnwell_enc_lvpwell+dg_enc_dnwell, cmp_l+lvpwell_enc_ncmp+dnwell_enc_lvpwell+dg_enc_dnwell))
        else:
            np_diode_cell.shapes(dualgate).insert(pya.Box(-dualgate_cmp_enc, -dualgate_cmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+dualgate_cmp_enc, cmp_l+dualgate_cmp_enc))
    else:
        np_diode_cell.shapes(diode_mk).insert(pya.Box(-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    np_diode_cell.flatten(True)
    return np_diode_cell

def draw_pn_diode(layout, l, w , volt, deepnwell, pcmpgr):
    '''
    Usage:-
     used to draw 3.3V P+/Nwell diode (Outside DNWELL) by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diffusion length
     w          : Float of diffusion width
     volt       : String of operating voltage of the diode [3.3V, 5V/6V]
     deepnwell  : Boolean of using Deep NWELL device
     pcmpgr     : Boolean of using P+ Guard Ring for Deep NWELL devices only
    '''

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

    # Define variables
    dbu_PERCISION       = 1/layout.dbu
    pcmp2ncmp_spc       = 0.48      * dbu_PERCISION
    ncmp_w              = 0.36      * dbu_PERCISION
    pcmp_w              = w         * dbu_PERCISION
    cmp_l               = l         * dbu_PERCISION
    implant_comp_enc    = 0.16      * dbu_PERCISION
    comp_cont_enc       = 0.07      * dbu_PERCISION
    cont_size           = 0.22      * dbu_PERCISION
    cont_min_spc        = 0.28      * dbu_PERCISION

    nwell_ncmp_enc      = 0.12      * dbu_PERCISION
    nwell_pcmp_enc      = 0.43      * dbu_PERCISION
    dg_enc_dnwell       = 0.5       * dbu_PERCISION
    dnwell_enc_nwell    = 0.5       * dbu_PERCISION
    min_cmp_area        = 0.2025    * dbu_PERCISION * dbu_PERCISION
    tie_violat          = 0         * dbu_PERCISION
    pcmp_gr2dnw         = 2.5       * dbu_PERCISION
    dnwell_violat       = 0         * dbu_PERCISION

    if volt == "5/6V" or deepnwell == True:
        nwell_ncmp_enc  = 0.16      * dbu_PERCISION
        nwell_pcmp_enc  = 0.6       * dbu_PERCISION
        dnwell_violat   = 0.12      * dbu_PERCISION

    # Inserting pn cell
    cell_index      = layout.add_cell("pn_diode")
    pn_diode_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
    if (cmp_l * ncmp_w) < min_cmp_area:
        tie_violat = (min_cmp_area/ncmp_w - cmp_l)/2
    pn_diode_cell.shapes(comp).insert(pya.Box(0, -tie_violat, ncmp_w, cmp_l+tie_violat))
    pn_diode_cell.shapes(nplus).insert(pya.Box(-implant_comp_enc, -implant_comp_enc-tie_violat, ncmp_w+implant_comp_enc, cmp_l+implant_comp_enc+tie_violat))

    pn_diode_cell.shapes(comp).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))
    pn_diode_cell.shapes(pplus).insert(pya.Box(ncmp_w+pcmp2ncmp_spc-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    # Inserting metal
    pn_diode_cell.shapes(metal1).insert(pya.Box(0, -tie_violat, ncmp_w, cmp_l+tie_violat))
    pn_diode_cell.shapes(metal1).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))

    # Inserting nwell
    pn_diode_cell.shapes(nwell).insert(pya.Box(-nwell_ncmp_enc-dnwell_violat, -nwell_pcmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc, cmp_l+nwell_pcmp_enc))


    # Inserting pcomp contacts
    num_ncmp_con_1, ncmp_con_free_spc_1 = number_spc_contacts(ncmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_ncmp_con_2, ncmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    ncmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_con_free_spc_1 / 2, ncmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_ncmp_con_1, num_ncmp_con_2)
    pn_diode_cell.insert(ncmp_con_arr)

    # Inserting ncomp contacts
    num_pcmp_con_1, pcmp_con_free_spc_1 = number_spc_contacts(pcmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_con_2, pcmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_w+pcmp2ncmp_spc+pcmp_con_free_spc_1 / 2, pcmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_con_1, num_pcmp_con_2)
    pn_diode_cell.insert(pcmp_con_arr)

    # Inserting Deep NWELL layers
    if deepnwell == True:
        pn_diode_cell.shapes(dnwell).insert(pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell))

        # Inserting Deep NWELL P+ Guard Ring
        if pcmpgr == True:
            cmp_inner = pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-pcmp_gr2dnw-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell-pcmp_gr2dnw, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw)
            cmp_outer = pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-pcmp_gr2dnw-ncmp_w-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell-pcmp_gr2dnw-ncmp_w, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw+ncmp_w, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw+ncmp_w)
            cmp_gr = pya.Region(cmp_outer) - pya.Region(cmp_inner)
            pn_diode_cell.shapes(comp).insert(cmp_gr)

            pp_inner = pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-pcmp_gr2dnw+implant_comp_enc-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell-pcmp_gr2dnw+implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw-implant_comp_enc, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw-implant_comp_enc)
            pp_outer = pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-pcmp_gr2dnw-ncmp_w-implant_comp_enc-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell-pcmp_gr2dnw-ncmp_w-implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw+ncmp_w+implant_comp_enc, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell+pcmp_gr2dnw+ncmp_w+implant_comp_enc)
            pp_gr = pya.Region(pp_outer) - pya.Region(pp_inner)
            pn_diode_cell.shapes(pplus).insert(pp_gr)

    if volt == "5/6V":
        # Inserting dualgate
        if deepnwell == True:
            pn_diode_cell.shapes(dualgate).insert(pya.Box(-nwell_ncmp_enc-dnwell_enc_nwell-dg_enc_dnwell-dnwell_violat, -nwell_pcmp_enc-dnwell_enc_nwell-dg_enc_dnwell, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc+dnwell_enc_nwell+dg_enc_dnwell, cmp_l+nwell_pcmp_enc+dnwell_enc_nwell+dg_enc_dnwell))
        else:
            pn_diode_cell.shapes(dualgate).insert(pya.Box(-nwell_ncmp_enc-dnwell_violat-dnwell_violat, -nwell_pcmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+nwell_pcmp_enc, cmp_l+nwell_pcmp_enc))

    # Inserting marker
    pn_diode_cell.shapes(diode_mk).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))

    pn_diode_cell.flatten(True)
    return pn_diode_cell

def draw_nwp_diode(layout, l, w , volt):
    '''
    Usage:-
     used to draw 3.3V Nwell/Psub diode by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diff length
     w          : Float of diff width
     volt       : String of operating voltage of the diode [3.3V, 5V/6V]
    '''

    # Define layers
    comp                = layout.layer(22 , 0 )
    nplus               = layout.layer(32 , 0 )
    pplus               = layout.layer(31 , 0 )
    nwell               = layout.layer (21 , 0)
    contact             = layout.layer(33 , 0 )
    metal1              = layout.layer(34 , 0 )
    dualgate            = layout.layer(55 , 0 )
    well_diode_mk       = layout.layer(153, 51)

    # Define variables
    dbu_PERCISION       = 1/layout.dbu
    pcmp2ncmp_spc       = 0.44  * dbu_PERCISION
    ncmp_w              = 0.36  * dbu_PERCISION
    pcmp_w              = w     * dbu_PERCISION
    cmp_l               = l     * dbu_PERCISION
    implant_comp_enc    = 0.16  * dbu_PERCISION
    comp_cont_enc       = 0.07  * dbu_PERCISION
    cont_size           = 0.22  * dbu_PERCISION
    cont_min_spc        = 0.28  * dbu_PERCISION
    dualgate_cmp_enc    = 0.24  * dbu_PERCISION

    # Inserting nwp cell
    cell_index      = layout.add_cell("nwp_diode")
    nwp_diode_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
    nwp_diode_cell.shapes(comp).insert(pya.Box(0, 0, ncmp_w, cmp_l))
    nwp_diode_cell.shapes(pplus).insert(pya.Box(-implant_comp_enc, -implant_comp_enc, ncmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    nwp_diode_cell.shapes(comp).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))
    nwp_diode_cell.shapes(nplus).insert(pya.Box(ncmp_w+pcmp2ncmp_spc-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    # Inserting nwell
    nwp_diode_cell.shapes(nwell).insert(pya.Box(ncmp_w+pcmp2ncmp_spc-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    # Inserting metal
    nwp_diode_cell.shapes(metal1).insert(pya.Box(0, 0, ncmp_w, cmp_l))
    nwp_diode_cell.shapes(metal1).insert(pya.Box(ncmp_w+pcmp2ncmp_spc, 0, ncmp_w+pcmp2ncmp_spc+pcmp_w, cmp_l))

    # Inserting pcomp contacts
    num_ncmp_con_1, ncmp_con_free_spc_1 = number_spc_contacts(ncmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_ncmp_con_2, ncmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    ncmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_con_free_spc_1 / 2, ncmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_ncmp_con_1, num_ncmp_con_2)
    nwp_diode_cell.insert(ncmp_con_arr)

    # Inserting ncomp contacts
    num_pcmp_con_1, pcmp_con_free_spc_1 = number_spc_contacts(pcmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_con_2, pcmp_con_free_spc_2 = number_spc_contacts(cmp_l, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_w+pcmp2ncmp_spc+pcmp_con_free_spc_1 / 2, pcmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_con_1, num_pcmp_con_2)
    nwp_diode_cell.insert(pcmp_con_arr)

    if volt == "5/6V":
        # Inserting marker
        nwp_diode_cell.shapes(well_diode_mk).insert(pya.Box(-dualgate_cmp_enc, -dualgate_cmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+dualgate_cmp_enc, cmp_l+dualgate_cmp_enc))
        # Inserting dualgate
        nwp_diode_cell.shapes(dualgate).insert(pya.Box(-dualgate_cmp_enc, -dualgate_cmp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+dualgate_cmp_enc, cmp_l+dualgate_cmp_enc))
    else:
        # Inserting marker
        nwp_diode_cell.shapes(well_diode_mk).insert(pya.Box(-implant_comp_enc, -implant_comp_enc, ncmp_w+pcmp2ncmp_spc+pcmp_w+implant_comp_enc, cmp_l+implant_comp_enc))

    nwp_diode_cell.flatten(True)
    return nwp_diode_cell

def draw_dnwpw_diode(layout, l, w , volt):
    '''
    Usage:-
     used to draw LVPWELL/DNWELL diode by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diff length
     w          : Float of diff width
     volt       : String of operating voltage of the diode [3.3V, 5V/6V]
    '''

    # Define layers
    lvpwell                 = layout.layer(204, 0 )
    dnwell                  = layout.layer(12 , 0 )
    comp                    = layout.layer(22 , 0 )
    nplus                   = layout.layer(32 , 0 )
    pplus                   = layout.layer(31 , 0 )
    nwell                   = layout.layer(21 , 0 )
    contact                 = layout.layer(33 , 0 )
    metal1                  = layout.layer(34 , 0 )
    dualgate                = layout.layer(55 , 0 )
    well_diode_mk           = layout.layer(153, 51)

    # Define variables
    dbu_PERCISION           = 1/layout.dbu
    lvpwell_w               = w    * dbu_PERCISION
    lvpwell_l               = l    * dbu_PERCISION
    dnwell_lvpwell_enc      = 2.5  * dbu_PERCISION
    lvpwell_pcmp_enc        = 0.12 * dbu_PERCISION
    cmp_w                   = 0.36 * dbu_PERCISION
    pcmp2ncmp_spc           = 0.32 * dbu_PERCISION
    implant_comp_enc        = 0.16 * dbu_PERCISION
    ncmp_ext                = 0.56 * dbu_PERCISION
    lvpwell_gr_spc          = 5    * dbu_PERCISION
    cont_spc_tol            = 0.11 * dbu_PERCISION
    comp_cont_enc           = 0.07 * dbu_PERCISION
    cont_size               = 0.22 * dbu_PERCISION
    cont_min_spc            = 0.25 * dbu_PERCISION
    dualgate_lvpwell_enc    = 3    * dbu_PERCISION
    pcmp2ncmp_spc           = 0.32 * dbu_PERCISION
    lvpwell_pcmp_enc        = 0.12 * dbu_PERCISION

    if volt == "5/6V":
        pcmp2ncmp_spc       = 0.36 * dbu_PERCISION
        lvpwell_pcmp_enc    = 0.16 * dbu_PERCISION

    # Inserting dnwpw cell
    cell_index       = layout.add_cell("dnwpw_diode")
    dnwpw_diode_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 lvpwell
    dnwpw_diode_cell.shapes(lvpwell).insert(pya.Box(0, 0, lvpwell_w, lvpwell_l))

    # Inserting dnwell
    dnwpw_diode_cell.shapes(dnwell).insert(pya.Box(-dnwell_lvpwell_enc, -dnwell_lvpwell_enc, lvpwell_w+dnwell_lvpwell_enc, lvpwell_l+dnwell_lvpwell_enc))

    # Inserting p diffusion
    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_pcmp_enc, lvpwell_pcmp_enc , lvpwell_pcmp_enc+cmp_w, lvpwell_l-lvpwell_pcmp_enc))                                    # left
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(lvpwell_pcmp_enc-implant_comp_enc, lvpwell_pcmp_enc-implant_comp_enc , lvpwell_pcmp_enc+cmp_w+implant_comp_enc, lvpwell_l-lvpwell_pcmp_enc+implant_comp_enc))

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_w-lvpwell_pcmp_enc-cmp_w, lvpwell_pcmp_enc , lvpwell_w-lvpwell_pcmp_enc , lvpwell_l-lvpwell_pcmp_enc))               # right
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(lvpwell_w-lvpwell_pcmp_enc-cmp_w-implant_comp_enc, lvpwell_pcmp_enc-implant_comp_enc , lvpwell_w-lvpwell_pcmp_enc+implant_comp_enc , lvpwell_l-lvpwell_pcmp_enc+implant_comp_enc))

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_pcmp_enc+cmp_w, lvpwell_l-lvpwell_pcmp_enc-cmp_w , lvpwell_w-lvpwell_pcmp_enc-cmp_w , lvpwell_l-lvpwell_pcmp_enc))   # top
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(lvpwell_pcmp_enc+cmp_w+implant_comp_enc, lvpwell_l-lvpwell_pcmp_enc-cmp_w-implant_comp_enc , lvpwell_w-lvpwell_pcmp_enc-cmp_w-implant_comp_enc , lvpwell_l-lvpwell_pcmp_enc+implant_comp_enc)) # top

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_pcmp_enc+cmp_w, lvpwell_pcmp_enc , lvpwell_w-lvpwell_pcmp_enc-cmp_w , lvpwell_pcmp_enc+cmp_w))                       # bottom
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(lvpwell_pcmp_enc+cmp_w+implant_comp_enc, lvpwell_pcmp_enc-implant_comp_enc , lvpwell_w-lvpwell_pcmp_enc-cmp_w-implant_comp_enc, lvpwell_pcmp_enc+cmp_w+implant_comp_enc)) # bottom

    # Inserting pcomp metal
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_pcmp_enc, lvpwell_pcmp_enc , lvpwell_pcmp_enc+cmp_w, lvpwell_l-lvpwell_pcmp_enc))                                  # left
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_w-lvpwell_pcmp_enc-cmp_w, lvpwell_pcmp_enc , lvpwell_w-lvpwell_pcmp_enc , lvpwell_l-lvpwell_pcmp_enc))             # right
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_pcmp_enc+cmp_w, lvpwell_l-lvpwell_pcmp_enc-cmp_w , lvpwell_w-lvpwell_pcmp_enc-cmp_w , lvpwell_l-lvpwell_pcmp_enc)) # top
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_pcmp_enc+cmp_w, lvpwell_pcmp_enc , lvpwell_w-lvpwell_pcmp_enc-cmp_w , lvpwell_pcmp_enc+cmp_w))                     # bottom

    # Inserting pcomp contacts
    num_pcmp_left_con_1, pcmp_left_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_left_con_2, pcmp_left_con_free_spc_2 = number_spc_contacts(lvpwell_l-2*lvpwell_pcmp_enc, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_pcmp_enc+pcmp_left_con_free_spc_1 / 2, lvpwell_pcmp_enc+pcmp_left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_left_con_1, num_pcmp_left_con_2)
    dnwpw_diode_cell.insert(pcmp_left_con_arr)

    num_cmp_right_con_1, cmp_right_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_right_con_2, cmp_right_con_free_spc_2 = number_spc_contacts(lvpwell_l-2*lvpwell_pcmp_enc, comp_cont_enc, cont_min_spc, cont_size)
    cmp_right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_w-lvpwell_pcmp_enc-cmp_w+cmp_right_con_free_spc_1 / 2, lvpwell_pcmp_enc+cmp_right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_right_con_1, num_cmp_right_con_2)
    dnwpw_diode_cell.insert(cmp_right_con_arr)

    num_cmp_top_con_1, cmp_top_con_free_spc_1 = number_spc_contacts(lvpwell_w-2*lvpwell_pcmp_enc-2*cmp_w-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_top_con_2, cmp_top_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    cmp_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_pcmp_enc+cmp_w+cont_spc_tol+cmp_top_con_free_spc_1 / 2, lvpwell_l-lvpwell_pcmp_enc-cmp_w+cmp_top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_top_con_1, num_cmp_top_con_2)
    dnwpw_diode_cell.insert(cmp_top_con_arr)

    num_cmp_bot_con_1, cmp_bot_con_free_spc_1 = number_spc_contacts(lvpwell_w-2*lvpwell_pcmp_enc-2*cmp_w-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_bot_con_2, cmp_bot_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    cmp_bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_pcmp_enc+cmp_w+cont_spc_tol+cmp_bot_con_free_spc_1 / 2, lvpwell_pcmp_enc+cmp_bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_bot_con_1, num_cmp_bot_con_2)
    dnwpw_diode_cell.insert(cmp_bot_con_arr)

    # Inserting n diffusion
    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_pcmp_enc-pcmp2ncmp_spc-cmp_w, -ncmp_ext , lvpwell_pcmp_enc-pcmp2ncmp_spc, lvpwell_l+ncmp_ext))
    dnwpw_diode_cell.shapes(nplus).insert(pya.Box(lvpwell_pcmp_enc-pcmp2ncmp_spc-cmp_w-implant_comp_enc, -ncmp_ext-implant_comp_enc , lvpwell_pcmp_enc-pcmp2ncmp_spc+implant_comp_enc, lvpwell_l+ncmp_ext+implant_comp_enc))

    # Inserting ncomp metal
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_pcmp_enc-pcmp2ncmp_spc-cmp_w, -ncmp_ext , lvpwell_pcmp_enc-pcmp2ncmp_spc, lvpwell_l+ncmp_ext))

    # Inserting ncomp contacts
    num_pcmp_con_1, pcmp_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_con_2, pcmp_con_free_spc_2 = number_spc_contacts(lvpwell_l+2*ncmp_ext, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_pcmp_enc-pcmp2ncmp_spc-cmp_w+pcmp_con_free_spc_1 / 2, -ncmp_ext+pcmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_con_1, num_pcmp_con_2)
    dnwpw_diode_cell.insert(pcmp_con_arr)

    # Inserting GR
    dnwpw_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc+cmp_w))                     #left
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc-cmp_w-implant_comp_enc, -lvpwell_gr_spc-cmp_w-implant_comp_enc, -lvpwell_gr_spc+implant_comp_enc , lvpwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(lvpwell_w+lvpwell_gr_spc, -lvpwell_gr_spc-cmp_w, lvpwell_w+lvpwell_gr_spc+cmp_w , lvpwell_l+lvpwell_gr_spc+cmp_w))   #right
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(lvpwell_w+lvpwell_gr_spc-implant_comp_enc, -lvpwell_gr_spc-cmp_w-implant_comp_enc, lvpwell_w+lvpwell_gr_spc+cmp_w+implant_comp_enc , lvpwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc , lvpwell_w+lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc+cmp_w))              #top
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc+implant_comp_enc , lvpwell_l+lvpwell_gr_spc-implant_comp_enc , lvpwell_w+lvpwell_gr_spc-implant_comp_enc , lvpwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwpw_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc , -lvpwell_gr_spc-cmp_w , lvpwell_w+lvpwell_gr_spc , -lvpwell_gr_spc))                                #bot
    dnwpw_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc+implant_comp_enc , -lvpwell_gr_spc-cmp_w-implant_comp_enc , lvpwell_w+lvpwell_gr_spc-implant_comp_enc , -lvpwell_gr_spc+implant_comp_enc))

    # Inserting GR metal
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc+cmp_w))                    #left
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(lvpwell_w+lvpwell_gr_spc, -lvpwell_gr_spc-cmp_w, lvpwell_w+lvpwell_gr_spc+cmp_w , lvpwell_l+lvpwell_gr_spc+cmp_w))  #right
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc , lvpwell_w+lvpwell_gr_spc , lvpwell_l+lvpwell_gr_spc+cmp_w))            #top
    dnwpw_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc , -lvpwell_gr_spc-cmp_w , lvpwell_w+lvpwell_gr_spc , -lvpwell_gr_spc))                              #bot

    # Inserting GR contacts
    num_gr_left_con_1, gr_left_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_left_con_2, gr_left_con_free_spc_2 = number_spc_contacts(lvpwell_l+2*lvpwell_gr_spc+2*cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc-cmp_w+gr_left_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+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)
    dnwpw_diode_cell.insert(gr_left_con_arr)

    num_gr_right_con_1, gr_right_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_right_con_2, gr_right_con_free_spc_2 = number_spc_contacts(lvpwell_l+2*lvpwell_gr_spc+2*cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(lvpwell_w+lvpwell_gr_spc+gr_right_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+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)
    dnwpw_diode_cell.insert(gr_right_con_arr)

    num_gr_top_con_1, gr_top_con_free_spc_1 = number_spc_contacts(lvpwell_w+2*lvpwell_gr_spc-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_top_con_2, gr_top_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc+cont_spc_tol+gr_top_con_free_spc_1 / 2, lvpwell_l+lvpwell_gr_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)
    dnwpw_diode_cell.insert(gr_top_con_arr)

    num_gr_bot_con_1, gr_bot_con_free_spc_1 = number_spc_contacts(lvpwell_w+2*lvpwell_gr_spc-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_bot_con_2, gr_bot_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc+cont_spc_tol+gr_bot_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+gr_bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_bot_con_1, num_gr_bot_con_2)
    dnwpw_diode_cell.insert(gr_bot_con_arr)

    # Inserting marker
    dnwpw_diode_cell.shapes(well_diode_mk).insert(pya.Box(0, 0, lvpwell_w, lvpwell_l))

    if volt == "5/6V":
        # Inserting dualgate
        dnwpw_diode_cell.shapes(dualgate).insert(pya.Box(-dualgate_lvpwell_enc, -dualgate_lvpwell_enc, lvpwell_w+dualgate_lvpwell_enc, lvpwell_l+dualgate_lvpwell_enc))

    dnwpw_diode_cell.flatten(True)
    return dnwpw_diode_cell

def draw_dnwps_diode(layout, l, w , volt):
    '''
    Usage:-
     used to draw LVPWELL/DNWELL diode by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diff length
     w          : Float of diff width
     volt       : String of operating voltage of the diode [3.3V, 5V/6V]
    '''

    # Define layers
    lvpwell                 = layout.layer(204, 0 )
    dnwell                  = layout.layer(12 , 0 )
    comp                    = layout.layer(22 , 0 )
    nplus                   = layout.layer(32 , 0 )
    pplus                   = layout.layer(31 , 0 )
    nwell                   = layout.layer (21 , 0)
    contact                 = layout.layer(33 , 0 )
    metal1                  = layout.layer(34 , 0 )
    dualgate                = layout.layer(55 , 0 )
    well_diode_mk           = layout.layer(153, 51)

    # Define variables
    dbu_PERCISION           = 1/layout.dbu
    dnwell_w                = w    * dbu_PERCISION
    dnwell_l                = l    * dbu_PERCISION
    dnwell_pcmp_enc         = 0.62 * dbu_PERCISION
    cmp_w                   = 0.36 * dbu_PERCISION
    pcmp2ncmp_spc           = 0.32 * dbu_PERCISION
    implant_comp_enc        = 0.03 * dbu_PERCISION
    ncmp_ext                = 0.56 * dbu_PERCISION
    lvpwell_gr_spc          = 2.5  * dbu_PERCISION
    cont_spc_tol            = 0.11 * dbu_PERCISION
    comp_cont_enc           = 0.07 * dbu_PERCISION
    cont_size               = 0.22 * dbu_PERCISION
    cont_min_spc            = 0.25 * dbu_PERCISION
    dualgate_lvpwell_enc    = 0.5  * dbu_PERCISION

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


    # Inserting dnwps cell
    cell_index       = layout.add_cell("dnwps_diode")
    dnwps_diode_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 dnwell
    dnwps_diode_cell.shapes(dnwell).insert(pya.Box(0, 0, dnwell_w, dnwell_l))

    # Inserting n diffusion
    dnwps_diode_cell.shapes(comp).insert(pya.Box(dnwell_pcmp_enc, dnwell_pcmp_enc , dnwell_pcmp_enc+cmp_w, dnwell_l-dnwell_pcmp_enc))                                    # left
    dnwps_diode_cell.shapes(nplus).insert(pya.Box(dnwell_pcmp_enc-implant_comp_enc, dnwell_pcmp_enc-implant_comp_enc , dnwell_pcmp_enc+cmp_w+implant_comp_enc, dnwell_l-dnwell_pcmp_enc+implant_comp_enc))

    dnwps_diode_cell.shapes(comp).insert(pya.Box(dnwell_w-dnwell_pcmp_enc-cmp_w, dnwell_pcmp_enc , dnwell_w-dnwell_pcmp_enc , dnwell_l-dnwell_pcmp_enc))               # right
    dnwps_diode_cell.shapes(nplus).insert(pya.Box(dnwell_w-dnwell_pcmp_enc-cmp_w-implant_comp_enc, dnwell_pcmp_enc-implant_comp_enc , dnwell_w-dnwell_pcmp_enc+implant_comp_enc , dnwell_l-dnwell_pcmp_enc+implant_comp_enc))

    dnwps_diode_cell.shapes(comp).insert(pya.Box(dnwell_pcmp_enc+cmp_w, dnwell_l-dnwell_pcmp_enc-cmp_w , dnwell_w-dnwell_pcmp_enc-cmp_w , dnwell_l-dnwell_pcmp_enc))   # top
    dnwps_diode_cell.shapes(nplus).insert(pya.Box(dnwell_pcmp_enc+cmp_w+implant_comp_enc, dnwell_l-dnwell_pcmp_enc-cmp_w-implant_comp_enc , dnwell_w-dnwell_pcmp_enc-cmp_w-implant_comp_enc , dnwell_l-dnwell_pcmp_enc+implant_comp_enc)) # top

    dnwps_diode_cell.shapes(comp).insert(pya.Box(dnwell_pcmp_enc+cmp_w, dnwell_pcmp_enc , dnwell_w-dnwell_pcmp_enc-cmp_w , dnwell_pcmp_enc+cmp_w))                       # bottom
    dnwps_diode_cell.shapes(nplus).insert(pya.Box(dnwell_pcmp_enc+cmp_w+implant_comp_enc, dnwell_pcmp_enc-implant_comp_enc , dnwell_w-dnwell_pcmp_enc-cmp_w-implant_comp_enc, dnwell_pcmp_enc+cmp_w+implant_comp_enc)) # bottom

    # Inserting ncomp metal
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(dnwell_pcmp_enc, dnwell_pcmp_enc , dnwell_pcmp_enc+cmp_w, dnwell_l-dnwell_pcmp_enc))                                  # left
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(dnwell_w-dnwell_pcmp_enc-cmp_w, dnwell_pcmp_enc , dnwell_w-dnwell_pcmp_enc , dnwell_l-dnwell_pcmp_enc))             # right
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(dnwell_pcmp_enc+cmp_w, dnwell_l-dnwell_pcmp_enc-cmp_w , dnwell_w-dnwell_pcmp_enc-cmp_w , dnwell_l-dnwell_pcmp_enc)) # top
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(dnwell_pcmp_enc+cmp_w, dnwell_pcmp_enc , dnwell_w-dnwell_pcmp_enc-cmp_w , dnwell_pcmp_enc+cmp_w))                     # bottom

    # Inserting ncomp contacts
    num_pcmp_left_con_1, pcmp_left_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_pcmp_left_con_2, pcmp_left_con_free_spc_2 = number_spc_contacts(dnwell_l-2*dnwell_pcmp_enc, comp_cont_enc, cont_min_spc, cont_size)
    pcmp_left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(dnwell_pcmp_enc+pcmp_left_con_free_spc_1 / 2, dnwell_pcmp_enc+pcmp_left_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_pcmp_left_con_1, num_pcmp_left_con_2)
    dnwps_diode_cell.insert(pcmp_left_con_arr)

    num_cmp_right_con_1, cmp_right_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_right_con_2, cmp_right_con_free_spc_2 = number_spc_contacts(dnwell_l-2*dnwell_pcmp_enc, comp_cont_enc, cont_min_spc, cont_size)
    cmp_right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(dnwell_w-dnwell_pcmp_enc-cmp_w+cmp_right_con_free_spc_1 / 2, dnwell_pcmp_enc+cmp_right_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_right_con_1, num_cmp_right_con_2)
    dnwps_diode_cell.insert(cmp_right_con_arr)

    num_cmp_top_con_1, cmp_top_con_free_spc_1 = number_spc_contacts(dnwell_w-2*dnwell_pcmp_enc-2*cmp_w-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_top_con_2, cmp_top_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    cmp_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(dnwell_pcmp_enc+cmp_w+cont_spc_tol+cmp_top_con_free_spc_1 / 2, dnwell_l-dnwell_pcmp_enc-cmp_w+cmp_top_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_top_con_1, num_cmp_top_con_2)
    dnwps_diode_cell.insert(cmp_top_con_arr)

    num_cmp_bot_con_1, cmp_bot_con_free_spc_1 = number_spc_contacts(dnwell_w-2*dnwell_pcmp_enc-2*cmp_w-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_cmp_bot_con_2, cmp_bot_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    cmp_bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(dnwell_pcmp_enc+cmp_w+cont_spc_tol+cmp_bot_con_free_spc_1 / 2, dnwell_pcmp_enc+cmp_bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_cmp_bot_con_1, num_cmp_bot_con_2)
    dnwps_diode_cell.insert(cmp_bot_con_arr)

    # Inserting GR
    dnwps_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc+cmp_w))                     #left
    dnwps_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc-cmp_w-implant_comp_enc, -lvpwell_gr_spc-cmp_w-implant_comp_enc, -lvpwell_gr_spc+implant_comp_enc , dnwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwps_diode_cell.shapes(comp).insert(pya.Box(dnwell_w+lvpwell_gr_spc, -lvpwell_gr_spc-cmp_w, dnwell_w+lvpwell_gr_spc+cmp_w , dnwell_l+lvpwell_gr_spc+cmp_w))   #right
    dnwps_diode_cell.shapes(pplus).insert(pya.Box(dnwell_w+lvpwell_gr_spc-implant_comp_enc, -lvpwell_gr_spc-cmp_w-implant_comp_enc, dnwell_w+lvpwell_gr_spc+cmp_w+implant_comp_enc , dnwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwps_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc , dnwell_w+lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc+cmp_w))              #top
    dnwps_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc+implant_comp_enc , dnwell_l+lvpwell_gr_spc-implant_comp_enc , dnwell_w+lvpwell_gr_spc-implant_comp_enc , dnwell_l+lvpwell_gr_spc+cmp_w+implant_comp_enc))

    dnwps_diode_cell.shapes(comp).insert(pya.Box(-lvpwell_gr_spc , -lvpwell_gr_spc-cmp_w , dnwell_w+lvpwell_gr_spc , -lvpwell_gr_spc))                                #bot
    dnwps_diode_cell.shapes(pplus).insert(pya.Box(-lvpwell_gr_spc+implant_comp_enc , -lvpwell_gr_spc-cmp_w-implant_comp_enc , dnwell_w+lvpwell_gr_spc-implant_comp_enc , -lvpwell_gr_spc+implant_comp_enc))

    # Inserting GR metal
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc-cmp_w, -lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc+cmp_w))                    #left
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(dnwell_w+lvpwell_gr_spc, -lvpwell_gr_spc-cmp_w, dnwell_w+lvpwell_gr_spc+cmp_w , dnwell_l+lvpwell_gr_spc+cmp_w))  #right
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc , dnwell_w+lvpwell_gr_spc , dnwell_l+lvpwell_gr_spc+cmp_w))            #top
    dnwps_diode_cell.shapes(metal1).insert(pya.Box(-lvpwell_gr_spc , -lvpwell_gr_spc-cmp_w , dnwell_w+lvpwell_gr_spc , -lvpwell_gr_spc))                              #bot

    # Inserting GR contacts
    num_gr_left_con_1, gr_left_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_left_con_2, gr_left_con_free_spc_2 = number_spc_contacts(dnwell_l+2*lvpwell_gr_spc+2*cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_left_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc-cmp_w+gr_left_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+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)
    dnwps_diode_cell.insert(gr_left_con_arr)

    num_gr_right_con_1, gr_right_con_free_spc_1 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_right_con_2, gr_right_con_free_spc_2 = number_spc_contacts(dnwell_l+2*lvpwell_gr_spc+2*cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_right_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(dnwell_w+lvpwell_gr_spc+gr_right_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+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)
    dnwps_diode_cell.insert(gr_right_con_arr)

    num_gr_top_con_1, gr_top_con_free_spc_1 = number_spc_contacts(dnwell_w+2*lvpwell_gr_spc-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_top_con_2, gr_top_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_top_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc+cont_spc_tol+gr_top_con_free_spc_1 / 2, dnwell_l+lvpwell_gr_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)
    dnwps_diode_cell.insert(gr_top_con_arr)

    num_gr_bot_con_1, gr_bot_con_free_spc_1 = number_spc_contacts(dnwell_w+2*lvpwell_gr_spc-2*cont_spc_tol, comp_cont_enc, cont_min_spc, cont_size)
    num_gr_bot_con_2, gr_bot_con_free_spc_2 = number_spc_contacts(cmp_w, comp_cont_enc, cont_min_spc, cont_size)
    gr_bot_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(-lvpwell_gr_spc+cont_spc_tol+gr_bot_con_free_spc_1 / 2, -lvpwell_gr_spc-cmp_w+gr_bot_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_gr_bot_con_1, num_gr_bot_con_2)
    dnwps_diode_cell.insert(gr_bot_con_arr)

    # Inserting marker
    dnwps_diode_cell.shapes(well_diode_mk).insert(pya.Box(0, 0, dnwell_w, dnwell_l))

    if volt == "5/6V":
        # Inserting dualgate
        dnwps_diode_cell.shapes(dualgate).insert(pya.Box(-dualgate_lvpwell_enc, -dualgate_lvpwell_enc, dnwell_w+dualgate_lvpwell_enc, dnwell_l+dualgate_lvpwell_enc))

    dnwps_diode_cell.flatten(True)
    return dnwps_diode_cell

def draw_sc_diode(layout, l, w , m, pcmpgr):
    '''
    Usage:-
     used to draw N+/LVPWELL diode (Outside DNWELL) by specifying parameters
    Arguments:-
     layout     : Object of layout
     l          : Float of diff length
     w          : Float of diff width
     m          : Integer of number of fingers
     pcmpgr     : Boolean of using P+ Guard Ring for Deep NWELL devices only
    '''

    # Define layers
    comp                = layout.layer(22 , 0 )
    nplus               = layout.layer(32 , 0 )
    dnwell              = layout.layer(12 , 0 )
    pplus               = layout.layer(31 , 0 )
    contact             = layout.layer(33 , 0 )
    metal1              = layout.layer(34 , 0 )
    sc_diode_mk         = layout.layer(241, 0 )

    # Define variables
    dbu_PERCISION       = 1/layout.dbu
    ncmp_metcmp_spc     = 0.28 * dbu_PERCISION
    ncmp_w              = 0.36 * dbu_PERCISION
    sc_w                = w    * dbu_PERCISION
    sc_l                = l    * dbu_PERCISION
    implant_comp_enc    = 0.03 * dbu_PERCISION
    comp_cont_enc       = 0.07 * dbu_PERCISION
    cont_size           = 0.22 * dbu_PERCISION
    cont_min_spc        = 0.25 * dbu_PERCISION

    metcmp_min_spc      = 0.92 * dbu_PERCISION
    met_cmp_enc_in      = 0.23 * dbu_PERCISION
    met_ncmp_enc        = 0.46 * dbu_PERCISION
    dnwell_cmp_enc_x    = 0.76 * dbu_PERCISION
    dnwell_cmp_enc_y    = 1.4  * dbu_PERCISION
    sc_mk_cmp_enc       = 0.16 * dbu_PERCISION
    met_conn_w          = 0.23 * dbu_PERCISION
    pcmp_gr2dnw         = 2.5  * dbu_PERCISION

    ncmp_min_spc        = 2*ncmp_metcmp_spc + sc_w
    cmp_total_w         = (m+1)*ncmp_w + m*ncmp_min_spc

    # Inserting np cell
    cell_index      = layout.add_cell("sc_diode")
    sc_diode_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 ncomp sc finger cell
    ncmp_cell_index = layout.add_cell("ncomp")
    ncmp_cell       = layout.cell(ncmp_cell_index)
    ncmp_cell.shapes(comp).insert(pya.Box.new(0, 0, ncmp_w, sc_l))
    ncmp_cell.shapes(nplus).insert(pya.Box.new(-implant_comp_enc, -implant_comp_enc, ncmp_w+implant_comp_enc, sc_l+implant_comp_enc))
    ncmp_cell.shapes(metal1).insert(pya.Box.new(0 , -met_cmp_enc_in, ncmp_w, sc_l))
    ## Inserting pcomp contacts
    num_ncmp_con_1, ncmp_con_free_spc_1 = number_spc_contacts(ncmp_w, comp_cont_enc, cont_min_spc, cont_size)
    num_ncmp_con_2, ncmp_con_free_spc_2 = number_spc_contacts(sc_l, comp_cont_enc, cont_min_spc, cont_size)
    ncmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_con_free_spc_1 / 2, ncmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_ncmp_con_1, num_ncmp_con_2)
    ncmp_cell.insert(ncmp_con_arr)

    # Inserting comp_metal sc finger cell
    met_cmp_cell_index  = layout.add_cell("comp_metal")
    met_cmp_cell        = layout.cell(met_cmp_cell_index)
    met_cmp_cell.shapes(comp).insert(pya.Box.new(0, 0, sc_w, sc_l))

    if m > 1:
        met_cmp_cell.shapes(metal1).insert(pya.Box.new(0, 0, sc_w, sc_l+met_cmp_enc_in))
    else:
        met_cmp_cell.shapes(metal1).insert(pya.Box.new(0, 0, sc_w, sc_l))

    ## Inserting comp_metal contacts
    num_met_cmp_con_1, met_cmp_con_free_spc_1 = number_spc_contacts(sc_w, comp_cont_enc, cont_min_spc, cont_size)
    num_met_cmp_con_2, met_cmp_con_free_spc_2 = number_spc_contacts(sc_l, comp_cont_enc, cont_min_spc, cont_size)
    met_cmp_con_arr = pya.CellInstArray(cont_cell.cell_index(), pya.Trans(
        pya.Point(met_cmp_con_free_spc_1 / 2, met_cmp_con_free_spc_2/2)),
        pya.Vector(cont_min_spc + cont_size, 0), pya.Vector(0,cont_min_spc + cont_size),
        num_met_cmp_con_1, num_met_cmp_con_2)
    met_cmp_cell.insert(met_cmp_con_arr)

    # Inserting ncomp fingers
    ncmp_arr = pya.CellInstArray(ncmp_cell.cell_index(), pya.Trans(
        pya.Point(0, 0)),
        pya.Vector(ncmp_min_spc + ncmp_w, 0), pya.Vector(0,ncmp_min_spc + ncmp_w),
        m+1, 1)
    sc_diode_cell.insert(ncmp_arr)

    # Inserting metal comp fingers
    metcmp_arr = pya.CellInstArray(met_cmp_cell.cell_index(), pya.Trans(
        pya.Point(ncmp_w+ncmp_metcmp_spc, 0)),
        pya.Vector(metcmp_min_spc + sc_w, 0), pya.Vector(0,metcmp_min_spc + sc_w),
        m, 1)
    sc_diode_cell.insert(metcmp_arr)

    # Inserting Deep NWELL
    sc_diode_cell.shapes(dnwell).insert(pya.Box(-dnwell_cmp_enc_x, -dnwell_cmp_enc_y, cmp_total_w+dnwell_cmp_enc_x, sc_l+dnwell_cmp_enc_y))

    # Inserting Deep NWELL P+ Guard Ring
    if pcmpgr == True:
        cmp_inner   = pya.Box(-dnwell_cmp_enc_x-pcmp_gr2dnw, -dnwell_cmp_enc_y-pcmp_gr2dnw, cmp_total_w+dnwell_cmp_enc_x+pcmp_gr2dnw, sc_l+dnwell_cmp_enc_y+pcmp_gr2dnw)
        cmp_outer   = pya.Box(-dnwell_cmp_enc_x-ncmp_w-pcmp_gr2dnw, -dnwell_cmp_enc_y-ncmp_w-pcmp_gr2dnw, cmp_total_w+dnwell_cmp_enc_x+ncmp_w+pcmp_gr2dnw, sc_l+dnwell_cmp_enc_y+ncmp_w+pcmp_gr2dnw)
        cmp_gr      = pya.Region(cmp_outer) - pya.Region(cmp_inner)
        sc_diode_cell.shapes(comp).insert(cmp_gr)

        pp_inner    = pya.Box(-dnwell_cmp_enc_x+implant_comp_enc-pcmp_gr2dnw, -dnwell_cmp_enc_y+implant_comp_enc-pcmp_gr2dnw, cmp_total_w+dnwell_cmp_enc_x-implant_comp_enc+pcmp_gr2dnw, sc_l+dnwell_cmp_enc_y-implant_comp_enc+pcmp_gr2dnw)
        pp_outer    = pya.Box(-dnwell_cmp_enc_x-ncmp_w-implant_comp_enc-pcmp_gr2dnw, -dnwell_cmp_enc_y-ncmp_w-implant_comp_enc-pcmp_gr2dnw, cmp_total_w+dnwell_cmp_enc_x+ncmp_w+implant_comp_enc+pcmp_gr2dnw, sc_l+dnwell_cmp_enc_y+ncmp_w+implant_comp_enc+pcmp_gr2dnw)
        pp_gr       = pya.Region(pp_outer) - pya.Region(pp_inner)
        sc_diode_cell.shapes(pplus).insert(pp_gr)

    # Inserting sc_marker
    sc_diode_cell.shapes(sc_diode_mk).insert(pya.Box(-sc_mk_cmp_enc, -sc_mk_cmp_enc, cmp_total_w+sc_mk_cmp_enc, sc_l+sc_mk_cmp_enc))

    # Inserting connection metal  [bottom]
    sc_diode_cell.shapes(metal1).insert(pya.Box(0, -met_ncmp_enc, cmp_total_w, -met_ncmp_enc+met_conn_w))

    # Inserting connection metal  [Top]
    if m > 1:
        sc_diode_cell.shapes(metal1).insert(pya.Box(ncmp_w+ncmp_metcmp_spc, sc_l+met_ncmp_enc-met_conn_w, cmp_total_w-ncmp_w-ncmp_metcmp_spc, sc_l+met_ncmp_enc))

    sc_diode_cell.flatten(True)
    return sc_diode_cell