CVC: Log output to /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/reports/finishing/Motor_Top.rpt
CVC: Error output to /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/reports/finishing/Motor_Top.rpt.error.gz
CVC: Debug output to /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/reports/finishing/Motor_Top.rpt.debug.gz
CVC: Circuit Validation Check  Version 1.1.0
CVC: Start: Mon Mar 21 23:49:59 2022

Using the following parameters for CVC (Circuit Validation Check) from /openlane/scripts/cvc/sky130A/cvcrc.sky130A
CVC_TOP = 'Motor_Top'
CVC_NETLIST = '/home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/tmp/finishing/Motor_Top.cdl'
CVC_MODE = 'Motor_Top'
CVC_MODEL_FILE = '/openlane/scripts/cvc/sky130A/cvc.sky130A.models'
CVC_POWER_FILE = '/home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/tmp/finishing/Motor_Top.power'
CVC_FUSE_FILE = ''
CVC_REPORT_FILE = '/home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/reports/finishing/Motor_Top.rpt'
CVC_REPORT_TITLE = 'CVC $CVC_TOP'
CVC_CIRCUIT_ERROR_LIMIT = '100'
CVC_SEARCH_LIMIT = '100'
CVC_LEAK_LIMIT = '0.0002'
CVC_SOI = 'false'
CVC_SCRC = 'false'
CVC_VTH_GATES = 'false'
CVC_MIN_VTH_GATES = 'false'
CVC_IGNORE_VTH_FLOATING = 'false'
CVC_IGNORE_NO_LEAK_FLOATING = 'false'
CVC_LEAK_OVERVOLTAGE = 'true'
CVC_LOGIC_DIODES = 'false'
CVC_ANALOG_GATES = 'true'
CVC_BACKUP_RESULTS = 'false'
CVC_MOS_DIODE_ERROR_THRESHOLD = '0'
CVC_SHORT_ERROR_THRESHOLD = '0'
CVC_BIAS_ERROR_THRESHOLD = '0'
CVC_FORWARD_ERROR_THRESHOLD = '0'
CVC_FLOATING_ERROR_THRESHOLD = '0'
CVC_GATE_ERROR_THRESHOLD = '0'
CVC_LEAK?_ERROR_THRESHOLD = '0'
CVC_EXPECTED_ERROR_THRESHOLD = '0'
CVC_OVERVOLTAGE_ERROR_THRESHOLD = '0'
CVC_PARALLEL_CIRCUIT_PORT_LIMIT = '0'
CVC_CELL_ERROR_LIMIT_FILE = ''
CVC_CELL_CHECKSUM_FILE = ''
CVC_LARGE_CIRCUIT_SIZE = '10000000'
CVC_NET_CHECK_FILE = ''
CVC_MODEL_CHECK_FILE = ''
End of parameters

CVC: Reading device model settings...
CVC: Reading power settings...
CVC: Parsing netlist /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/tmp/finishing/Motor_Top.cdl
Cdl fixed data size 531252
Usage CDL: Time: 0  Memory: 23876  I/O: 8  Swap: 0
CVC: Counting and linking...
CVC: Assigning IDs ...
Usage DB: Time: 0  Memory: 26080  I/O: 8  Swap: 0
CVC: 32704(32704) instances, 25140(25140) nets, 77570(77570) devices.
CVC: Setting models ...
Setting model tolerances...
CVC: Shorting switches...
	Shorted 0 short
Setting instance power...

ModelList> filename /openlane/scripts/cvc/sky130A/cvc.sky130A.models
 Model> sky130_fd_pr__cap_mim_m3_1         0 C->capacitor  Parameters>
 Model> sky130_fd_pr__cap_mim_m3_2         0 C->capacitor  Parameters>
 Model> sky130_fd_pr__cap_var         0 C->capacitor  Parameters>
 Model> condiode           0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__diode_pd2nw_05v5         0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__diode_pw2nd_05v5         0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__diode_pw2nd_11v0         0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__model__parasitic__diode_ps2dn         0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__model__parasitic__diode_ps2nw         0 D->diode      Parameters> Diodes> 1-2
 Model> sky130_fd_pr__model__parasitic__diode_pw2dn         0 D->diode      Parameters> Diodes> 1-2
 Model> nfet_01v8      38785 M->nmos       Parameters> Vth=0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 4-1 4-3
 Model> pfet_01v8_hvt     38785 M->pmos       Parameters> Vth=-0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_bs_flash__special_sonosfet_star         0 M->nmos       Parameters> Vth=0.2 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__esd_nfet_g5v0d10v5         0 M->nmos       Parameters> Vth=0.2 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__nfet_01v8         0 M->nmos       Parameters> Vth=0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__nfet_01v8_lvt         0 M->nmos       Parameters> Vth=0.1 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__nfet_03v3_nvt         0 M->nmos       Parameters> Vth=0.2 Vds=3.3 Vgs=3.3 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__nfet_05v0_nvt         0 M->nmos       Parameters> Vth=0.2 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__nfet_g5v0d10v5         0 M->nmos       Parameters> Vth=0.2 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__pfet_01v8         0 M->pmos       Parameters> Vth=-0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_pr__pfet_01v8_hvt         0 M->pmos       Parameters> Vth=-0.3 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_pr__pfet_01v8_lvt         0 M->pmos       Parameters> Vth=-0.1 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_pr__pfet_g5v0d10v5         0 M->pmos       Parameters> Vth=-0.2 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_pr__special_nfet_latch         0 M->nmos       Parameters> Vth=0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 4-1 4-3
 Model> sky130_fd_pr__special_pfet_pass         0 M->pmos       Parameters> Vth=-0.2 Vds=1.8 Vgs=1.8 R=L/W*7000 Diodes> 1-4 3-4
 Model> sky130_fd_pr__pnp_05v5         0 Q->bipolar    Parameters>
 Model> short              0 R->switch_on  Parameters>
 Model> sky130_fd_pr__res_generic_m1         0 R->resistor   Parameters> R=l/w
 Model> sky130_fd_pr__res_generic_m2         0 R->resistor   Parameters> R=l/w
 Model> sky130_fd_pr__res_generic_m3         0 R->resistor   Parameters> R=l/w
 Model> sky130_fd_pr__res_generic_m4         0 R->resistor   Parameters> R=l/w
 Model> sky130_fd_pr__res_generic_m5         0 R->resistor   Parameters> R=l/w
 Model> sky130_fd_pr__res_generic_nd         0 R->resistor   Parameters> R=l/w*120
 Model> sky130_fd_pr__res_generic_nd__hv         0 R->resistor   Parameters> R=l/w*114
 Model> sky130_fd_pr__res_generic_pd__hv         0 R->resistor   Parameters> R=l/w*191
 Model> sky130_fd_pr__res_generic_po         0 R->resistor   Parameters> R=l/w*48
 Model> sky130_fd_pr__res_high_po         0 R->resistor   Parameters> R=l/w*2000
 Model> sky130_fd_pr__res_xhigh_po         0 R->resistor   Parameters> R=l/w*2000
ModelList> end

Power List> filename /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/tmp/finishing/Motor_Top.power
 vccd1 power 1.8 -> 1.8 power
 vssd1 power 0.0 -> 0.0 power
 clock~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 io_ba_match~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 io_qei_ch_a~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 io_qei_ch_b~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 io_wbs_m2s_stb~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 io_wbs_m2s_we~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
 reset~>std_input input std_input -> min@0.0 max@1.8 input family(std_input;)
io_wbs_m2s_addr[15:0]~>std_input input std_input
 ->io_wbs_m2s_addr[0] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[10] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[11] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[12] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[13] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[14] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[15] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[1] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[2] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[3] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[4] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[5] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[6] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[7] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[8] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_addr[9] input std_input -> min@0.0 max@1.8 input family(std_input;)
io_wbs_m2s_data[31:0]~>std_input input std_input
 ->io_wbs_m2s_data[0] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[10] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[11] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[12] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[13] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[14] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[15] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[16] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[17] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[18] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[19] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[1] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[20] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[21] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[22] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[23] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[24] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[25] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[26] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[27] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[28] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[29] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[2] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[30] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[31] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[3] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[4] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[5] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[6] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[7] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[8] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_data[9] input std_input -> min@0.0 max@1.8 input family(std_input;)
io_wbs_m2s_sel[3:0]~>std_input input std_input
 ->io_wbs_m2s_sel[0] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_sel[1] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_sel[2] input std_input -> min@0.0 max@1.8 input family(std_input;)
 ->io_wbs_m2s_sel[3] input std_input -> min@0.0 max@1.8 input family(std_input;)
> expected values
> macros
 #define std_input min@vssd1 max@vccd1 -> min@0.0 max@1.8
Power List> end

CVC: Linking devices...
Usage EQUIV: Time: 0  Memory: 33320  I/O: 24  Swap: 0
Power nets 71
Hash dump:parameter->resistance map
Contains 53 buckets, 41 elements
Element count 0, 24
Element count 1, 17
Element count 2, 12
Unused hash: 0.45, average depth 1.59
Hash dump:text->circuit map
Contains 337 buckets, 438 elements
Element count 0, 90
Element count 1, 113
Element count 2, 90
Element count 3, 33
Element count 4, 9
Element count 5, 2
Unused hash: 0.27, average depth 2.20
Hash dump:string->text map
Contains 26267 buckets, 39840 elements
Element count 0, 5742
Element count 1, 8733
Element count 2, 6644
Element count 3, 3389
Element count 4, 1290
Element count 5, 349
Element count 6, 97
Element count 7, 19
Element count 8, 4
Unused hash: 0.22, average depth 2.51
CVC: Shorting non conducting resistors...
CVC: Calculating resistor voltages...
Usage RES: Time: 0  Memory: 33320  I/O: 32  Swap: 0
Power nets 71
CVC: Calculating min/max voltages...
Processing trivial nets found 7791 trivial nets
CVC: Ignoring invalid calculations...
CVC:   Removed 0 calculations
Copying master nets
CVC: Ignoring non-conducting devices...
CVC:   Ignored 0 devices
Usage MIN/MAX1: Time: 0  Memory: 34172  I/O: 32  Swap: 0
Power nets 9531
! Checking forward bias diode errors: 

! Checking nmos source/drain vs bias errors: 

! Checking nmos gate vs source errors: 

! Checking pmos source/drain vs bias errors: 

! Checking pmos gate vs source errors: 

Usage ERROR: Time: 0  Memory: 34172  I/O: 32  Swap: 0
CVC: Propagating Simulation voltages 1...
Usage SIM1: Time: 0  Memory: 34700  I/O: 32  Swap: 0
Power nets 9531
CVC: Propagating Simulation voltages 3...
Usage SIM2: Time: 0  Memory: 34964  I/O: 32  Swap: 0
Power nets 9531
Added 0 latch voltages
CVC: Calculating min/max voltages...
Processing trivial nets found 7791 trivial nets
CVC: Ignoring invalid calculations...
CVC:   Removed 0 calculations
Copying master nets
CVC: Ignoring non-conducting devices...
CVC:   Ignored 0 devices
Usage MIN/MAX2: Time: 0  Memory: 35492  I/O: 32  Swap: 0
Power nets 18991
! Checking overvoltage errors

! Checking nmos possible leak errors: 

! Checking pmos possible leak errors: 

! Checking mos floating input errors:

! Checking expected values:

CVC: Error Counts
CVC: Fuse Problems:         0
CVC: Min Voltage Conflicts: 0
CVC: Max Voltage Conflicts: 0
CVC: Leaks:                 0
CVC: LDD drain->source:     0
CVC: HI-Z Inputs:           0
CVC: Forward Bias Diodes:   0
CVC: NMOS Source vs Bulk:   0
CVC: NMOS Gate vs Source:   0
CVC: NMOS Possible Leaks:   0
CVC: PMOS Source vs Bulk:   0
CVC: PMOS Gate vs Source:   0
CVC: PMOS Possible Leaks:   0
CVC: Overvoltage-VBG:       0
CVC: Overvoltage-VBS:       0
CVC: Overvoltage-VDS:       0
CVC: Overvoltage-VGS:       0
CVC: Model errors:          0
CVC: Unexpected voltage :   0
CVC: Total:                 0
Usage Total: Time: 0  Memory: 36020  I/O: 72  Swap: 0
Virtual net update/access 250963/7076142
CVC: Log output to /home/ali112000/mpw5/UETRV-ECORE/openlane/Motor_Top/runs/Motor_Top/reports/finishing/Motor_Top.rpt
CVC: End: Mon Mar 21 23:50:00 2022

