################################################################################################
# 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
#
#     https://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.
################################################################################################


if BEOL

    #===============================================
    #--------------------PAD------------------------
    #===============================================

    # Rule PAD.4 : Top layer metal enclose pad opening is 2.0µm
    logger.info('Executing rule PAD.4')
    pad4_l1 = top_metal.enclosing(pad,2.0.um).polygons(0.001)
    pad4_l2 = pad.not_outside(top_metal).not(top_metal)
    pad4_l = pad4_l1.or(pad4_l2)
    pad4_l.output('PAD.4', 'PAD.4 : Top layer metal enclose pad opening is 2.0µm')
    pad4_l1.forget
    pad4_l2.forget
    pad4_l.forget

    # Rule PAD.2 : Pad opening to pad opening is 9.0µm
    logger.info('Executing rule PAD.2')
    pad2_l1 = pad.space(9.0.um).polygons(0.001)
    pad2_l1.output('PAD.2', 'PAD.2 : Pad opening to pad opening is 9.0µm')
    pad2_l1.forget

    # Rule PAD.5 : Top metal enclose top via is 0.5µm
    logger.info('Executing rule PAD.5')
    pad5_l1 = top_metal.enclosing(top_via,0.5.um).polygons(0.001)
    pad5_l2 = top_via.not_inside(top_metal)
    pad5_l = pad5_l1.or(pad5_l2)
    pad5_l.output('PAD.5', 'PAD.5 : Top metal enclose top_via is 0.5µm')
    pad5_l1.forget
    pad5_l2.forget
    pad5_l.forget

    # Rule PAD.6 : Top metal-1 enclose top via is 0.5µm
    logger.info('Executing rule PAD.6')
    pad6_l1 = topmin1_metal.enclosing(top_via,0.5.um).polygons(0.001)
    pad6_l2 = top_via.not_inside(topmin1_metal)
    pad6_l = pad6_l1.or(pad6_l2)
    pad6_l.output('PAD.6', 'PAD.6 : Top metal-1 enclose top_via is 0.5µm')
    pad6_l1.forget
    pad6_l2.forget
    pad6_l.forget

    # Rule PAD.15 : Min pad opening space to nearest S/L guard ring (Inner edge of GUARD_RING_MK marking) is 30µm
    logger.info('Executing rule PAD.15')
    pad15_l1 = pad.separation(guard_ring_mk,30.0.um).polygons(0.001)
    pad15_l1.output('PAD.15','PAD.15 : Min pad opening space to nearest S/L guard ring (Inner edge of GUARD_RING_MK marking) is 30µm')
    pad15_l1.forget

    # Rule PAD.16 : Max pad opening space to nearest S/L guard ring (Inner edge of GUARD_RING_MK marking) is 200.0µm
    logger.info('Executing rule PAD.16')
    pad16_l1 = (pad.not_interacting(pad.separation(guard_ring_mk,200.01.um).polygons)).interacting(CHIP.interacting(guard_ring_mk))
    # pad16_l1 = pad.separation(guard_ring_mk,1000.um).polygons(0.001).not_interacting(pad.separation(guard_ring_mk,200.001.um).polygons(0.001))
    pad16_l1.output('PAD.16','PAD.16 : Max pad opening space to nearest S/L guard ring (Inner edge of GUARD_RING_MK marking) is 200.0µm')
    pad16_l1.forget

    # Rule PAD.19b : Pad opening to non-pad circuit Top Metal is 6.0µm
    logger.info('Executing rule PAD.19b')
    pad19b_l1 = pad.separation(top_metal.not_interacting(pad),6.0.um).polygons(0.001)
    pad19b_l1.output('PAD.19b','PAD.19b : Pad opening to non-pad circuit Top Metal is 6.0µm')
    pad19b_l1.forget

    if METAL_LEVEL == '2LM'
        all_mets = metal1.or(metal2)
    elsif METAL_LEVEL == '3LM'
        all_mets = metal1.or(metal2).or(metal3)
    elsif METAL_LEVEL == '4LM'
        all_mets = metal1.or(metal2).or(metal3).or(metal4)
    elsif METAL_LEVEL == '5LM'
        all_mets = metal1.or(metal2).or(metal3).or(metal4).or(metal5)
    else
        all_mets = metal1.or(metal2).or(metal3).or(metal4).or(metal5).or(top_metal)
    end #METAL_LEVEL
    
    # Rule PAD.20 : Pad metal to pad metal space is 5.0µm
    logger.info('Executing rule PAD.20')
    pad20_l1 = all_mets.interacting(pad).space(5.0.um).polygons(0.001)
    pad20_l1.output('PAD.20','PAD.20 : Pad metal to pad metal space is 5.0µm')
    pad20_l1.forget

    if GOLD == 'true'
        # Rule PAD.1_gold : Pad opening is 4.0µm
        logger.info('Executing rule PAD.1')
        pad1_l1 = pad.width(4.0.um).polygons(0.001)
        pad1_l1.output('PAD.1_gold','PAD.1_gold : Pad opening is 4.0µm')
        pad1_l1.forget 

    else 
        # Rule PAD.1 : Pad opening is 40.0µm
        logger.info('Executing rule PAD.1')
        pad1_l1 = pad.width(40.0.um).polygons(0.001)
        pad1_l1.output('PAD.1','PAD.1 : Pad opening is 40.0µm')
        pad1_l1.forget

        # Rule PAD.7 : metal5 enclose via4 is 0.5µm
        logger.info('Executing rule PAD.7')
        pad7_l1 = metal5.enclosing(via4,0.5.um).polygons(0.001)
        pad7_l2 = via4.not_inside(metal5)
        pad7_l = pad7_l1.or(pad7_l2)
        pad7_l.output('PAD.7', 'PAD.7 : metal5 enclose via4 is 0.5µm')
        pad7_l1.forget
        pad7_l2.forget
        pad7_l.forget

        # Rule PAD.8 : metal4 enclose via4 is 0.5µm
        logger.info('Executing rule PAD.8')
        pad8_l1 = metal4.enclosing(via4,0.5.um).polygons(0.001)
        pad8_l2 = via4.not_inside(metal4)
        pad8_l = pad8_l1.or(pad8_l2)
        pad8_l.output('PAD.8', 'PAD.8 : metal4 enclose via4 is 0.5µm')
        pad8_l1.forget
        pad8_l2.forget
        pad8_l.forget

        # Rule PAD.9 : metal4 enclose via3 is 0.5µm
        logger.info('Executing rule PAD.9')
        pad9_l1 = metal4.enclosing(via3,0.5.um).polygons(0.001)
        pad9_l2 = via3.not_inside(metal4)
        pad9_l = pad9_l1.or(pad9_l2)
        pad9_l.output('PAD.9', 'PAD.9 : metal4 enclose via3 is 0.5µm')
        pad9_l1.forget
        pad9_l2.forget
        pad9_l.forget

        # Rule PAD.10 : metal3 enclose via3 is 0.5µm
        logger.info('Executing rule PAD.10')
        pad10_l1 = metal3.enclosing(via3,0.5.um).polygons(0.001)
        pad10_l2 = via3.not_inside(metal3)
        pad10_l = pad10_l1.or(pad10_l2)
        pad10_l.output('PAD.10', 'PAD.10 : metal3 enclose via3 is 0.5µm')
        pad10_l1.forget
        pad10_l2.forget
        pad10_l.forget

        # Rule PAD.11 : metal3 enclose via2 is 0.5µm
        logger.info('Executing rule PAD.11')
        pad11_l1 = metal3.enclosing(via2,0.5.um).polygons(0.001)
        pad11_l2 = via2.not_inside(metal3)
        pad11_l = pad11_l1.or(pad11_l2)
        pad11_l.output('PAD.11', 'PAD.11 : metal3 enclose via2 is 0.5µm')
        pad11_l1.forget
        pad11_l2.forget
        pad11_l.forget

        # Rule PAD.12 : metal2 enclose via2 is 0.5µm
        logger.info('Executing rule PAD.12')
        pad12_l1 = metal2.enclosing(via2,0.5.um).polygons(0.001)
        pad12_l2 = via2.not_inside(metal2)
        pad12_l = pad12_l1.or(pad12_l2)
        pad12_l.output('PAD.12', 'PAD.12 : metal2 enclose via2 is 0.5µm')
        pad12_l1.forget
        pad12_l2.forget
        pad12_l.forget


        # Rule PAD.13 : metal2 enclose via1 is 0.5µm
        logger.info('Executing rule PAD.13')
        pad13_l1 = metal2.enclosing(via1,0.5.um).polygons(0.001)
        pad13_l2 = via1.not_inside(metal2)
        pad13_l = pad13_l1.or(pad13_l2)
        pad13_l.output('PAD.13', 'PAD.13 : metal2 enclose via1 is 0.5µm')
        pad13_l1.forget
        pad13_l2.forget
        pad13_l.forget

        # Rule PAD.14 : metal1 enclose via1 is 0.5µm
        logger.info('Executing rule PAD.14')
        pad14_l1 = metal1.enclosing(via1,0.5.um).polygons(0.001)
        pad14_l2 = via1.not_inside(metal1)
        pad14_l = pad14_l1.or(pad14_l2)
        pad14_l.output('PAD.14', 'PAD.14 : metal1 enclose via1 is 0.5µm')
        pad14_l1.forget
        pad14_l2.forget
        pad14_l.forget
    end #GOLD

    if WEDGE == 'true'     
        # Rule PAD.17 : Pad opening space to active circuit COMP is 15µm 
        logger.info('Executing rule PAD.17')
        pad17_l1 = pad.separation(comp,15.0.um).polygons(0.001)
        pad17_l1.output('PAD.17','PAD.17 : Pad opening space to active circuit COMP is 15µm')
        pad17_l1.forget

        # Rule PAD.18 : Pad opening space to active circuit poly2 is 15µm 
        logger.info('Executing rule PAD.18')
        pad18_l1 = pad.separation(poly2,15.0.um).polygons(0.001)
        pad18_l1.output('PAD.18','PAD.18 : Pad opening space to active circuit poly2 is 15µm')
        pad18_l1.forget

        met_19a = all_mets.not(top_metal)
        # Rule PAD.19a : Pad opening to non-pad circuit Metal1, 2, 3, 4,5 up to Top Metal - 1 is 6µm
        logger.info('Executing rule PAD.19')
        pad19a_l1 = pad.separation(met_19a.not_interacting(pad),6.0.um).polygons(0.001)
        pad19a_l1.output('PAD.19a','PAD.19a : Pad opening to non-pad circuit Metal1, 2, 3, 4,5 up to Top Metal - 1 is 6µm')
        pad19a_l1.forget 
    end #WEDGE
end #BEOL