Upload ICCAD.py

ICCAD.py

@@ -1,48 +1,310 @@
 import glob
 import os
-import re
 import datasets
 import io
 import math
 import pandas as pd
 import numpy as np
 from numpy import genfromtxt
+from dataclasses import dataclass
 
-from requests import get
+# transform
+import cv2
+import torch
+import torch.nn.functional as F
+import albumentations as A
+from albumentations.augmentations.blur.functional import gaussian_blur
+from scipy.ndimage import distance_transform_cdt, distance_transform_edt
+from patchify import patchify
 
 #datasets.logging.set_verbosity_debug()
 #logger = datasets.logging.get_logger(__name__)
 #datasets.logging.set_verbosity_info()
 #datasets.logging.set_verbosity_debug()
+pd.options.mode.chained_assignment = None
 
 _REPO = "https://huggingface.co/datasets/DaJhuan/ICCAD/resolve/main"
 
 _URLS = {
-    "fake_data_url": f"{_REPO}/fake-circuit-data.zip",
-    "real_data_url": f"{_REPO}/real-circuit-data.zip",
+    "fake_data_url": f"{_REPO}/fake-circuit-data_20230623.zip",
+    "real_data_url": f"{_REPO}/real-circuit-data_20230615.zip",
+    "BeGAN_01_data_url": f"{_REPO}/BeGAN-ver01.zip",
+    "BeGAN_02_data_url": f"{_REPO}/BeGAN-ver02.zip",
 }
 
+@dataclass
+class ICCAD_Config(datasets.BuilderConfig):
+    test_mode: bool = False
+    use_BeGAN: bool = False and not test_mode
+    patchify: bool = False
+    # transform
+    use_resize: bool = True
+    img_size: int = 288
+    dist_type: str = 'edt'
+    use_i_map: bool = True
+    use_r_map: bool = True
+    use_r_dist: bool = True
+    use_ir_map: bool = True
+    use_multi_dist: bool = False
+    use_power_map: bool = False
+
+# tranform
+def _transform(self, img, max_pool=False):
+    img_size = self.config.img_size
+    img = np.asarray(img)
+    
+    if self.config.patchify:
+        tf = A.Compose([
+                A.PadIfNeeded(min_height=None, min_width=None, pad_height_divisor=img_size, pad_width_divisor=img_size, border_mode=0, value=0),
+            ],
+        )
+        img = tf(image=img)['image']
+        img = patchify(img, patch_size=(img_size, img_size, img.shape[-1]), step=img_size)
+        img = img.reshape((-1, img_size, img_size, img.shape[-1])).transpose((0, 3, 1, 2))
+    elif self.config.use_resize:
+        img = A.Resize(img_size, img_size, interpolation=cv2.INTER_AREA)(image=img)["image"]
+        img = img.transpose((2, 0, 1))
+    elif max_pool:
+        img = torch.from_numpy(img).unsqueeze(0)
+        img = F.adaptive_max_pool2d(img, img_size)
+        img = img.squeeze(0).numpy()
+        img = img.transpose((2, 0, 1))
+    
+    return img
+
+def get_dist(self, x):
+    x = np.asarray(x)
+    if self.config.dist_type == 'cdt':
+        x = distance_transform_cdt(np.where(x == 0, 1, 0), metric='taxicab')
+    if self.config.dist_type == 'edt':
+        x = distance_transform_edt(np.where(x == 0, 1, 0))
+    return x
+
+def get_blur(x, ksize=1):
+    x = np.asarray(x)
+    if ksize > 1:
+        x = gaussian_blur(img=x, ksize=ksize)
+    return x
+    
+def get_image(self, data):
+    return {
+        "data_idx": data["data_idx"],
+        "H": data["H"],
+        "W": data["W"],
+        "image": _transform(self, np.stack([
+            data["ir_drop"],
+            data["current"],
+            data["eff_dist"],
+            data["pdn_density"],
+        ] + ([
+            get_blur(data["I_map"], ksize=1),
+        ] if self.config.use_i_map else []) + ([
+            get_blur(data["R_map_11"], ksize=1),
+            get_blur(data["R_map_14"], ksize=1),
+            get_blur(data["R_map_44"], ksize=1),
+            get_blur(data["R_map_47"], ksize=1),
+            get_blur(data["R_map_77"], ksize=1),
+            get_blur(data["R_map_78"], ksize=1),
+            get_blur(data["R_map_88"], ksize=1),
+            get_blur(data["R_map_89"], ksize=1),
+            get_blur(data["R_map_99"], ksize=1),
+        ] if self.config.use_r_map else []) + ([
+            get_dist(self, data["R_map_11"]),
+            get_dist(self, data["R_map_14"]),
+            get_dist(self, data["R_map_44"]),
+            get_dist(self, data["R_map_47"]),
+            get_dist(self, data["R_map_77"]),
+            get_dist(self, data["R_map_78"]),
+            get_dist(self, data["R_map_88"]),
+            get_dist(self, data["R_map_89"]),
+            get_dist(self, data["R_map_99"]),
+        ] if self.config.use_r_dist else []) + ([
+            get_blur(data["IR_map_14"], ksize=1),
+            get_blur(data["IR_map_47"], ksize=1),
+            get_blur(data["IR_map_78"], ksize=1),
+            get_blur(data["IR_map_89"], ksize=1),
+        ] if self.config.use_ir_map else []) + ([
+            data["R_multi_dist_14"],
+            data["R_multi_dist_47"],
+            data["R_multi_dist_78"],
+            data["R_multi_dist_89"],
+        ] if self.config.use_multi_dist else []) + ([
+            get_dist(self, data["R_map_11"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_14"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_44"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_47"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_77"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_78"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_88"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_89"]) * get_blur(data["I_map"], ksize=49),
+            get_dist(self, data["R_map_99"]) * get_blur(data["I_map"], ksize=49),
+        ] if self.config.use_power_map else []), axis=2))
+    }
+    
+def get_IR_map_H(Via_map, I_map):
+    index = np.argwhere(Via_map != 0)
+    index = index[index[:, 0].argsort()]
+    index = index[index[:, 1].argsort(kind="mergesort")]
+    
+    H, W = Via_map.shape
+    IR_map = np.zeros((H, W))
+    I_sim_map = np.zeros((H, W))
+    #start
+    for j in range(0, index[0, 0]):
+        I = I_map[j, index[0, 1]]
+        if I != 0:
+            R = int(index[0, 0] - j)
+            V = float(I * R)
+            IR_map[0 : j, index[0, 1]] += V
+            IR_map[j : index[0, 0], index[0, 1]] += V * np.arange(R, 0, -1) / R
+            
+            I_sim_map[index[0, 0], index[0, 1]] += I
+    #mid
+    for i in range(index.shape[0] - 1):
+        if index[i, 1] == index[i + 1, 1]:
+            R = index[i + 1, 0] - index[i, 0]
+            for j in range(index[i, 0], index[i + 1, 0]):
+                I = I_map[j, index[i, 1]]
+                if I != 0:
+                    R1 = int(j - index[i, 0])
+                    R2 = int(index[i + 1, 0] - j)
+                    V = float(I * (R1 * R2) / R)
+                    IR_map[index[i, 0] : j, index[i, 1]] += V * np.arange(R1) / R1
+                    IR_map[j, index[i, 1]] += V
+                    IR_map[j : index[i + 1, 0], index[i, 1]] += V * np.arange(R2, 0, -1) / R2
+                    
+                    I_sim_map[index[i, 0], index[i, 1]] += I * R2 / R
+                    I_sim_map[index[i + 1, 0], index[i + 1, 1]] += I * R1 / R
+        else:
+            for j in range(index[i, 0], H):
+                I = I_map[j, index[i, 1]]
+                if I != 0:
+                    R = int(j - index[i, 0])
+                    V = float(I * R)
+                    IR_map[index[i, 0] : j, index[i, 1]] += V * np.arange(R) / R
+                    IR_map[j : H, index[i, 1]] += V
+                    
+                    I_sim_map[index[i, 0], index[i, 1]] += I
+            for j in range(0, index[i + 1, 0]):
+                I = I_map[j, index[i + 1, 1]]
+                if I != 0:
+                    R = int(index[i + 1, 0] - j)
+                    V = float(I * R)
+                    IR_map[0 : j, index[i + 1, 1]] += V
+                    IR_map[j : index[i + 1, 0], index[i + 1, 1]] += V * np.arange(R, 0, -1) / R
+                    
+                    I_sim_map[index[i + 1, 0], index[i + 1, 1]] += I
+    #end
+    i = index.shape[0] - 1
+    for j in range(index[i, 0], H):
+        I = I_map[j, index[i, 1]]
+        if I != 0:
+            R = int(j - index[i, 0])
+            V = float(I * R)
+            IR_map[index[i, 0] : j, index[i, 1]] += V * np.arange(R) / R
+            IR_map[j : H, index[i, 1]] += V
+            
+            I_sim_map[index[i, 0], index[i, 1]] += I
+    
+    return I_sim_map, IR_map
+
+def get_IR_map_V(Via_map, I_map):
+    index = np.argwhere(Via_map != 0)
+    index = index[index[:, 1].argsort()]
+    index = index[index[:, 0].argsort(kind="mergesort")]
+    
+    H, W = Via_map.shape
+    IR_map = np.zeros((H, W))
+    I_sim_map = np.zeros((H, W))
+    #start
+    for j in range(0, index[0, 1]):
+        I = I_map[index[0, 0], j]
+        if I != 0:
+            R = int(index[0, 1] - j)
+            V = float(I * R)
+            IR_map[index[0, 0], 0 : j] += V
+            IR_map[index[0, 0], j : index[0, 1]] += V * np.arange(R, 0, -1) / R
+            
+            I_sim_map[index[0, 0], index[0, 1]] += I
+    #mid
+    for i in range(index.shape[0] - 1):
+        if index[i, 0] == index[i + 1, 0]:
+            R = index[i + 1, 1] - index[i, 1]
+            for j in range(index[i, 1], index[i + 1, 1]):
+                I = I_map[index[i, 0], j]
+                if I != 0:
+                    R1 = int(j - index[i, 1])
+                    R2 = int(index[i + 1, 1] - j)
+                    V = float(I * (R1 * R2) / R)
+                    IR_map[index[i, 0], index[i, 1] : j] += V * np.arange(R1) / R1
+                    IR_map[index[i, 0], j] += V
+                    IR_map[index[i, 0], j : index[i + 1, 1]] += V * np.arange(R2, 0, -1) / R2
+                    
+                    I_sim_map[index[i, 0], index[i, 1]] += I * R2 / R
+                    I_sim_map[index[i + 1, 0], index[i + 1, 1]] += I * R1 / R
+        else:
+            for j in range(index[i, 1], W):
+                I = I_map[index[i, 0], j]
+                if I != 0:
+                    R = int(j - index[i, 1])
+                    V = float(I * R)
+                    IR_map[index[i, 0], index[i, 1] : j] += V * np.arange(R) / R
+                    IR_map[index[i, 0], j : W] += V
+                    
+                    I_sim_map[index[i, 0], index[i, 1]] += I
+            for j in range(0, index[i + 1, 1]):
+                I = I_map[index[i + 1, 0], j]
+                if I != 0:
+                    R = int(index[i + 1, 1] - j)
+                    V = float(I * R)
+                    IR_map[index[i + 1, 0], 0 : j] += V
+                    IR_map[index[i + 1, 0], j : index[i + 1, 1]] += V * np.arange(R, 0, -1) / R
+                    
+                    I_sim_map[index[i + 1, 0], index[i + 1, 1]] += I
+    #end
+    i = index.shape[0] - 1
+    for j in range(index[i, 1], H):
+        I = I_map[index[i, 0], j]
+        if I != 0:
+            R = int(j - index[i, 1])
+            V = float(I * R)
+            IR_map[index[i, 0], index[i, 1] : j] += V * np.arange(R) / R
+            IR_map[index[i, 0], j : W] += V
+            
+            I_sim_map[index[i, 0], index[i, 1]] += I
+    
+    return I_sim_map, IR_map
 
 class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
+    DEFAULT_WRITER_data_SIZE = 10
+    
+    BUILDER_CONFIG_CLASS = ICCAD_Config
+    BUILDER_CONFIGS = [
+        ICCAD_Config(
+            name="ICCAD",
+            version=datasets.Version("1.0.0", ""),
+            description="ICCAD Problem C: Static IR Drop Estimation Using Machine Learning",
+        )
+    ]
+    
     def _info(self):
-        features = datasets.Features({
-            "data_idx": datasets.Value("string"),
-            "current": datasets.Image(),
-            "pdn_density": datasets.Image(),
-            "eff_dist": datasets.Image(),
-            "ir_drop": datasets.Image(),
-            "netlist": datasets.Value("string"),
-            "R_map_11": datasets.Image(),
-            "R_map_14": datasets.Image(),
-            "R_map_44": datasets.Image(),
-            "R_map_47": datasets.Image(),
-            "R_map_77": datasets.Image(),
-            "R_map_78": datasets.Image(),
-            "R_map_88": datasets.Image(),
-            "R_map_89": datasets.Image(),
-            "R_map_99": datasets.Image(),
-            "I_map": datasets.Image(),
-        })
+        img_size = self.config.img_size
+        in_chans = 1 + 3 + self.config.use_i_map + 9 * self.config.use_r_map + 9 * self.config.use_r_dist + 4 * self.config.use_ir_map + 4 * self.config.use_multi_dist + 9 * self.config.use_power_map
+        
+        if self.config.patchify:
+            features = datasets.Features({
+                "data_idx": datasets.Value("string"),
+                "H": datasets.Value("int32"),
+                "W": datasets.Value("int32"),
+                "image": datasets.Array4D((None, in_chans, img_size, img_size), 'float32'),
+            })
+        else:
+            features = datasets.Features({
+                "data_idx": datasets.Value("string"),
+                "H": datasets.Value("int32"),
+                "W": datasets.Value("int32"),
+                "image": datasets.Array3D((in_chans, img_size, img_size), 'float32'),
+            })
 
         return datasets.DatasetInfo(
             features=features,
@@ -64,16 +326,36 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
         real_irdrop = []
         real_netlist = []
         
-      
+        if self.config.use_BeGAN:
+            BeGAN_01_idx = []
+            BeGAN_01_cur = []
+            BeGAN_01_pdn = []
+            BeGAN_01_dist = []
+            BeGAN_01_irdrop = []
+            BeGAN_01_netlist = []
+
+            BeGAN_02_idx = []
+            BeGAN_02_cur = []
+            BeGAN_02_pdn = []
+            BeGAN_02_dist = []
+            BeGAN_02_irdrop = []
+            BeGAN_02_netlist = []
+        
+        
         # Download images
-        fake_data_files = os.path.join(dl_manager.download_and_extract(_URLS["fake_data_url"]), "fake-circuit-data")  # skip _MACOSX dir
-        real_data_files = os.path.join(dl_manager.download_and_extract(_URLS["real_data_url"]), "real-circuit-data")  # skip _MACOSX dir
-        #logger.info(f"text_data_files: {text_data_files}")
-        #logger.info(f"text_data_files: {text_data_files[10]}")
+        fake_data_files = os.path.join(dl_manager.download_and_extract(_URLS["fake_data_url"]), "fake-circuit-data_20230623")
+        real_data_files = os.path.join(dl_manager.download_and_extract(_URLS["real_data_url"]), "real-circuit-data_20230615")
 
         fake_path_files = sorted(glob.glob(os.path.join(fake_data_files, "*.sp")))
         real_path_files = sorted(glob.glob(os.path.join(real_data_files, "*")))
         
+        if self.config.use_BeGAN:
+            BeGAN_01_data_files = os.path.join(dl_manager.download_and_extract(_URLS["BeGAN_01_data_url"]), "BeGAN-ver01")
+            BeGAN_01_path_files = sorted(glob.glob(os.path.join(BeGAN_01_data_files, "*.sp")))
+
+            BeGAN_02_data_files = os.path.join(dl_manager.download_and_extract(_URLS["BeGAN_02_data_url"]), "BeGAN-ver02")
+            BeGAN_02_path_files = sorted(glob.glob(os.path.join(BeGAN_02_data_files, "*.sp")))
+        
         # for fake
         for path in fake_path_files:
             data_idx = os.path.basename(path).split(".")[0]
@@ -85,16 +367,16 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
                     fake_cur.append(data)
                 elif "eff_dist.csv" in os.path.basename(data):
                     fake_dist.append(data)
-                elif "ir_drop_map.csv" in os.path.basename(data):
+                elif "ir_drop.csv" in os.path.basename(data):
                     fake_irdrop.append(data)
                 elif "pdn_density.csv" in os.path.basename(data):
                     fake_pdn.append(data)
                 elif ".sp" in os.path.basename(data):
                     fake_netlist.append(data)
                 else:
-                    raise AssertionError('fake data path error')
+                    raise AssertionError(os.path.basename(data), "fake data path error")
             
-        assert len(fake_idx) == len(fake_cur) == len(fake_dist) == len(fake_irdrop) == len(fake_pdn) == len(fake_netlist), f'{(len(fake_idx), len(fake_cur), len(fake_dist), len(fake_irdrop), len(fake_pdn), len(fake_netlist))} fake data length not the same'
+        assert len(fake_idx) == len(fake_cur) == len(fake_dist) == len(fake_irdrop) == len(fake_pdn) == len(fake_netlist), f"{(len(fake_idx), len(fake_cur), len(fake_dist), len(fake_irdrop), len(fake_pdn), len(fake_netlist))} fake data length not the same"
         
         # for real
         for path in real_path_files:
@@ -114,13 +396,67 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
                 elif "netlist.sp" in os.path.basename(data):
                     real_netlist.append(data)
                 else:
-                    raise AssertionError('real data path error')
+                    raise AssertionError(os.path.basename(data), "real data path error")
                     
-        assert len(real_idx) == len(real_cur) == len(real_dist) == len(real_irdrop) == len(real_pdn) == len(real_netlist), f'{(len(real_idx), len(real_cur), len(real_dist), len(real_irdrop), len(real_pdn), len(real_netlist))} real data length not the same'
-               
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split('fake'),
+        assert len(real_idx) == len(real_cur) == len(real_dist) == len(real_irdrop) == len(real_pdn) == len(real_netlist), f"{(len(real_idx), len(real_cur), len(real_dist), len(real_irdrop), len(real_pdn), len(real_netlist))} real data length not the same"
+        if self.config.use_BeGAN:
+            # for BeGAN-ver01
+            for path in BeGAN_01_path_files:
+                data_idx = os.path.basename(path).split(".")[0]
+                BeGAN_01_idx.append(data_idx)
+                data_path = glob.glob(os.path.join(os.path.dirname(path), data_idx + "*.*"))
+
+                for data in data_path:
+                    if "current.csv" in os.path.basename(data):
+                        BeGAN_01_cur.append(data)
+                    elif "eff_dist.csv" in os.path.basename(data):
+                        BeGAN_01_dist.append(data)
+                    elif "ir_drop_map.csv" in os.path.basename(data):
+                        BeGAN_01_irdrop.append(data)
+                    elif "pdn_density.csv" in os.path.basename(data):
+                        BeGAN_01_pdn.append(data)
+                    elif ".sp" in os.path.basename(data):
+                        BeGAN_01_netlist.append(data)
+                    else:
+                        raise AssertionError(os.path.basename(data), "BeGAN-ver01 data path error")
+
+            assert len(BeGAN_01_idx) == len(BeGAN_01_cur) == len(BeGAN_01_dist) == len(BeGAN_01_irdrop) == len(BeGAN_01_pdn) == len(BeGAN_01_netlist), f"{(len(BeGAN_01_idx), len(BeGAN_01_cur), len(BeGAN_01_dist), len(BeGAN_01_irdrop), len(BeGAN_01_pdn), len(BeGAN_01_netlist))} BeGAN-ver02 data length not the same"
+
+            # for BeGAN-ver02
+            for path in BeGAN_02_path_files:
+                data_idx = os.path.basename(path).split(".")[0]
+                BeGAN_02_idx.append(data_idx)
+                data_path = glob.glob(os.path.join(os.path.dirname(path), data_idx + "*.*"))
+
+                for data in data_path:
+                    if "current.csv" in os.path.basename(data):
+                        BeGAN_02_cur.append(data)
+                    elif "eff_dist.csv" in os.path.basename(data):
+                        BeGAN_02_dist.append(data)
+                    elif "voltage.csv" in os.path.basename(data):
+                        BeGAN_02_irdrop.append(data)
+                    elif "regions.csv" in os.path.basename(data):
+                        BeGAN_02_pdn.append(data)
+                    elif ".sp" in os.path.basename(data):
+                        BeGAN_02_netlist.append(data)
+                    else:
+                        raise AssertionError(os.path.basename(data), "BeGAN-ver01 data path error")
+
+            assert len(BeGAN_02_idx) == len(BeGAN_02_cur) == len(BeGAN_02_dist) == len(BeGAN_02_irdrop) == len(BeGAN_02_pdn) == len(BeGAN_02_netlist), f"{(len(BeGAN_02_idx), len(BeGAN_02_cur), len(BeGAN_02_dist), len(BeGAN_02_irdrop), len(BeGAN_02_pdn), len(BeGAN_02_netlist))} BeGAN-ver01 data length not the same"
+            
+        return [datasets.SplitGenerator(
+                name=datasets.Split("real"),
+                gen_kwargs={
+                    "data_idx": real_idx,
+                    "current": real_cur,
+                    "pdn_density": real_pdn,
+                    "eff_dist": real_dist,
+                    "ir_drop": real_irdrop,
+                    "netlist": real_netlist,
+                })
+            ] if self.config.test_mode else [
+                datasets.SplitGenerator(
+                name=datasets.Split("fake"),
                 gen_kwargs={
                     "data_idx": fake_idx,
                     "current": fake_cur,
@@ -128,10 +464,9 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
                     "eff_dist": fake_dist,
                     "ir_drop": fake_irdrop,
                     "netlist": fake_netlist,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split('real'),
+                })
+            ] + [datasets.SplitGenerator(
+                name=datasets.Split("real"),
                 gen_kwargs={
                     "data_idx": real_idx,
                     "current": real_cur,
@@ -139,33 +474,76 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
                     "eff_dist": real_dist,
                     "ir_drop": real_irdrop,
                     "netlist": real_netlist,
-                },
-            ),
-        ]
+                })
+            ] + ([datasets.SplitGenerator(
+                name=datasets.Split("BeGAN_01"),
+                gen_kwargs={
+                    "data_idx": BeGAN_01_idx,
+                    "current": BeGAN_01_cur,
+                    "pdn_density": BeGAN_01_pdn,
+                    "eff_dist": BeGAN_01_dist,
+                    "ir_drop": BeGAN_01_irdrop,
+                    "netlist": BeGAN_01_netlist,
+                }),
+                datasets.SplitGenerator(
+                name=datasets.Split("BeGAN_02"),
+                gen_kwargs={
+                    "data_idx": BeGAN_02_idx,
+                    "current": BeGAN_02_cur,
+                    "pdn_density": BeGAN_02_pdn,
+                    "eff_dist": BeGAN_02_dist,
+                    "ir_drop": BeGAN_02_irdrop,
+                    "netlist": BeGAN_02_netlist,
+                })
+            ] if self.config.use_BeGAN else [])
       
       
     def _generate_examples(self, data_idx, current, pdn_density, eff_dist, ir_drop, netlist):
-        for i, (_data_idx, _current, _pdn_density, _eff_dist, _ir_drop, _netlist) in enumerate(zip(data_idx, current, pdn_density, eff_dist, ir_drop, netlist)):
+        for _idx, (_data_idx, _current, _pdn_density, _eff_dist, _ir_drop, _netlist) in enumerate(zip(data_idx, current, pdn_density, eff_dist, ir_drop, netlist)):
+            
+            netlist = open(_netlist, "r").read()
+            _H, _W = genfromtxt(_current, delimiter=",").shape
+            H, W = int(_H * 2.5) + 1, int(_W * 2.5) + 1
             
-            netlist = open(_netlist, 'r').read()
-            H, W = genfromtxt(_current, delimiter=',').shape
-            H, W = H + 1, W + 1
-
-            df = pd.read_csv(io.StringIO(netlist), sep = " ", names = ['type', 'n1', 'n2', 'values', 'tmp'])
-            df = df.drop(columns='tmp')
-            df = df.astype({'type': 'str', 'n1':'str', 'n2': 'str', 'values': 'float'})
-            df[['n1', 'm1', 'x1', 'y1']] = df['n1'].str.split('_', expand=True)
-            df[['n2', 'm2', 'x2', 'y2']] = df['n2'].str.split('_', expand=True)
-            df['m1'] = df['m1'].str.replace('m', '')
-            df['m2'] = df['m2'].str.replace('m', '')
-            df = df.drop(columns=['n1', 'n2'])
+            def resize(img, max_pool=False):
+                if max_pool:
+                    img = torch.from_numpy(img).unsqueeze(0)
+                    img = F.adaptive_max_pool2d(img, (_H, _W))
+                    img = img.squeeze(0).numpy()
+                else:
+                    img = A.Resize(_H, _W, interpolation=cv2.INTER_AREA)(image=img)["image"]
+                return img
+
+            df = pd.read_csv(io.StringIO(netlist), sep = " ", names = ["type", "n1", "n2", "values", "tmp"], low_memory=False)
+            df = df.drop(columns="tmp")
+            df = df.astype({"type": "str", "n1":"str", "n2": "str", "values": "float"})
+            df[["n1", "m1", "x1", "y1"]] = df["n1"].str.split("_", expand=True)
+            df[["n2", "m2", "x2", "y2"]] = df["n2"].str.split("_", expand=True)
+            df["m1"] = df["m1"].str.replace("m", "")
+            df["m2"] = df["m2"].str.replace("m", "")
+            df = df.drop(columns=["n1", "n2"])
+
+
+            # V
+            df_V = df[df["type"].str.contains("V")]
+            assert df_V[["x1", "y1"]].astype(int).mod(800).eq(0).all().all(), (_data_idx, "V map error")
+            df_V[["x1", "y1"]] = df_V[["x1", "y1"]].astype(int) // 800
+            df_V = df_V[["x1", "y1", "values"]].to_numpy()
 
+            V_map = np.zeros((H, W))
+            for row in df_V:
+                x = int(row[0])
+                y = int(row[1])
+                V_map[x, y] = row[2]
+                
+                
             # R
-            df_R = df[df['type'].str.contains('R')]
-            df_R[['m1', 'm2']] = df_R[['m1', 'm2']].astype(int)
-            df_R[['x1', 'y1', 'x2', 'y2']] = df_R[['x1', 'y1', 'x2', 'y2']].astype(float) / 2000 + 0.5
+            df_R = df[df["type"].str.contains("R")]
+            df_R[["m1", "m2"]] = df_R[["m1", "m2"]].astype(int)
+            assert df_R[["x1", "y1", "x2", "y2"]].astype(int).mod(800).eq(0).all().all(), (_data_idx, "R map error")
+            df_R[["x1", "y1", "x2", "y2"]] = df_R[["x1", "y1", "x2", "y2"]].astype(int) // 800
+            df_R = df_R[["m1", "x1", "y1", "m2", "x2", "y2", "values"]].to_numpy()
             
-            # m1
             R_map_11 = np.zeros((H, W))
             R_map_14 = np.zeros((H, W))
             R_map_44 = np.zeros((H, W))
@@ -176,197 +554,338 @@ class ICCAD_Dataset(datasets.GeneratorBasedBuilder):
             R_map_89 = np.zeros((H, W))
             R_map_99 = np.zeros((H, W))
             
-            for index, row in df_R.iterrows():
+            for row in df_R:
                 # m1 -> m1
-                if row['m1'] == 1 and row['m2'] == 1:
+                if row[0] == 1 and row[3] == 1:
                     # H line
-                    if row['x1'] != row['x2']:
-                        y = int(row['y1'])
-                        if row['x1'] < row['x2']:
-                            for x in range(int(row['x1']), int(math.ceil(row['x2']))):
-                                R_map_11[x][y] += row['values'] / (row['x2'] - row['x1'])
+                    if row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_11[int(row[1]) : int(row[4] + 1), y] = 1
                         else:
-                            for x in range(int(row['x2']), int(math.ceil(row['x1']))):
-                                R_map_11[x][y] += row['values'] / (row['x1'] - row['x2'])
+                            R_map_11[int(row[4]) : int(row[1] + 1), y] = 1
 
                     # V line
-                    elif row['y1'] != row['y2']:
-                        x = int(row['x1'])
-                        if row['y1'] < row['y2']:
-                            for y in range(int(row['y1']), int(math.ceil(row['y2']))):
-                                R_map_11[x][y] += row['values'] / (row['y2'] - row['y1'])
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_11[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['y2']), int(math.ceil(row['y1']))):
-                                R_map_11[x][y] += row['values'] / (row['y1'] - row['y2'])
+                            R_map_11[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m1 -> m4
-                elif row['m1'] == 1 and row['m2'] == 4:
+                elif row[0] == 1 and row[3] == 4:
                     # Via
-                    if row['x1'] == row['x2'] and row['y1'] == row['y2']:
-                        y = int(row['y1'])
-                        x = int(row['x1'])
-                        R_map_14[x][y] += row['values']
+                    if row[1] == row[4] and row[2] == row[5]:
+                        x = int(row[1])
+                        y = int(row[2])
+                        R_map_14[x, y] = 1
+                    
+                    # V line
+                    elif row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_14[int(row[1]) : int(row[4] + 1), y] = 1
+                        else:
+                            R_map_14[int(row[4]) : int(row[1] + 1), y] = 1
+
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_14[x, int(row[2]) : int(row[5] + 1)] = 1
+                        else:
+                            R_map_14[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m4 -> m4
-                elif row['m1'] == 4 and row['m2'] == 4:
-                    # H line
-                    if row['x1'] != row['x2']:
-                        y = int(row['y1'])
-                        if row['x1'] < row['x2']:
-                            for x in range(int(row['x1']), int(math.ceil(row['x2']))):
-                                R_map_44[x][y] += row['values'] / (row['x2'] - row['x1'])
+                elif row[0] == 4 and row[3] == 4:
+                    # V line
+                    if row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_44[int(row[1]) : int(row[4] + 1), y] = 1
                         else:
-                            for x in range(int(row['x2']), int(math.ceil(row['x1']))):
-                                R_map_44[x][y] += row['values'] / (row['x1'] - row['x2'])
+                            R_map_44[int(row[4]) : int(row[1] + 1), y] = 1
 
-                    # V line
-                    elif row['y1'] != row['y2']:
-                        x = int(row['x1'])
-                        if row['y1'] < row['y2']:
-                            for y in range(int(row['y1']), int(math.ceil(row['y2']))):
-                                R_map_44[x][y] += row['values'] / (row['y2'] - row['y1'])
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_44[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['y2']), int(math.ceil(row['y1']))):
-                                R_map_44[x][y] += row['values'] / (row['y1'] - row['y2'])
+                            R_map_44[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m4 -> m7
-                elif row['m1'] == 4 and row['m2'] == 7:
+                elif row[0] == 4 and row[3] == 7:
                     # Via
-                    if row['x1'] == row['x2'] and row['y1'] == row['y2']:
-                        y = int(row['y1'])
-                        x = int(row['x1'])
-                        R_map_47[x][y] += row['values']
+                    if row[1] == row[4] and row[2] == row[5]:
+                        x = int(row[1])
+                        y = int(row[2])
+                        R_map_47[x, y] = 1
+                                        
+                    # V line
+                    elif row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_47[int(row[1]) : int(row[4] + 1), y] = 1
+                        else:
+                            R_map_47[int(row[4]) : int(row[1] + 1), y] = 1
+
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_47[x, int(row[2]) : int(row[5] + 1)] = 1
+                        else:
+                            R_map_47[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m7 -> m7
-                elif row['m1'] == 7 and row['m2'] == 7:
-                    # H line
-                    if row['x1'] != row['x2']:
-                        y = int(row['y1'])
-                        if row['x1'] < row['x2']:
-                            for x in range(int(row['x1']), int(math.ceil(row['x2']))):
-                                R_map_77[x][y] += row['values'] / (row['x2'] - row['x1'])
+                elif row[0] == 7 and row[3] == 7:
+                    # V line
+                    if row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_77[int(row[1]) : int(row[4] + 1), y] = 1
                         else:
-                            for x in range(int(row['x2']), int(math.ceil(row['x1']))):
-                                R_map_77[x][y] += row['values'] / (row['x1'] - row['x2'])
+                            R_map_77[int(row[4]) : int(row[1] + 1), y] = 1
 
-                    # V line
-                    elif row['y1'] != row['y2']:
-                        x = int(row['x1'])
-                        if row['y1'] < row['y2']:
-                            for y in range(int(row['y1']), int(math.ceil(row['y2']))):
-                                R_map_77[x][y] += row['values'] / (row['y2'] - row['y1'])
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_77[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['y2']), int(math.ceil(row['y1']))):
-                                R_map_77[x][y] += row['values'] / (row['y1'] - row['y2'])
+                            R_map_77[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m7 -> m8
-                elif row['m1'] == 7 and row['m2'] == 8:
+                elif row[0] == 7 and row[3] == 8:
                     # Via
-                    if row['x1'] == row['x2'] and row['y1'] == row['y2']:
-                        y = int(row['y1'])
-                        x = int(row['x1'])
-                        R_map_78[x][y] += row['values']
-                    else:
-                        raise AssertionError('R map row error')
+                    if row[1] == row[4] and row[2] == row[5]:
+                        x = int(row[1])
+                        y = int(row[2])
+                        R_map_78[x, y] = 1
+                                            
+                    # V line
+                    elif row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_78[int(row[1]) : int(row[4] + 1), y] = 1
+                        else:
+                            R_map_78[int(row[4]) : int(row[1] + 1), y] = 1
 
-                # m8 -> m8
-                elif row['m1'] == 8 and row['m2'] == 8:
                     # H line
-                    if row['x1'] != row['x2']:
-                        y = int(row['y1'])
-                        if row['x1'] < row['x2']:
-                            for x in range(int(row['x1']), int(math.ceil(row['x2']))):
-                                R_map_88[x][y] += row['values'] / (row['x2'] - row['x1'])
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_78[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['x2']), int(math.ceil(row['x1']))):
-                                R_map_88[x][y] += row['values'] / (row['x1'] - row['x2'])
+                            R_map_78[x, int(row[5]) : int(row[2] + 1)] = 1
+                    else:
+                        raise AssertionError(_data_idx, "R map row error")
 
+                # m8 -> m8
+                elif row[0] == 8 and row[3] == 8:
                     # V line
-                    elif row['y1'] != row['y2']:
-                        x = int(row['x1'])
-                        if row['y1'] < row['y2']:
-                            for y in range(int(row['y1']), int(math.ceil(row['y2']))):
-                                R_map_88[x][y] += row['values'] / (row['y2'] - row['y1'])
+                    if row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_88[int(row[1]) : int(row[4] + 1), y] = 1
+                        else:
+                            R_map_88[int(row[4]) : int(row[1] + 1), y] = 1
+
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_88[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['y2']), int(math.ceil(row['y1']))):
-                                R_map_88[x][y] += row['values'] / (row['y1'] - row['y2'])
+                            R_map_88[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m8 -> m9
-                elif row['m1'] == 8 and row['m2'] == 9:
+                elif row[0] == 8 and row[3] == 9:
                     # Via
-                    if row['x1'] == row['x2'] and row['y1'] == row['y2']:
-                        y = int(row['y1'])
-                        x = int(row['x1'])
-                        R_map_89[x][y] += row['values']
+                    if row[1] == row[4] and row[2] == row[5]:
+                        x = int(row[1])
+                        y = int(row[2])
+                        R_map_89[x, y] = 1
+                                            
+                    # V line
+                    elif row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_89[int(row[1]) : int(row[4] + 1), y] = 1
+                        else:
+                            R_map_89[int(row[4]) : int(row[1] + 1), y] = 1
+
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_89[x, int(row[2]) : int(row[5] + 1)] = 1
+                        else:
+                            R_map_89[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                         
                 # m9 -> m9
-                elif row['m1'] == 9 and row['m2'] == 9:
-                    # H line
-                    if row['x1'] != row['x2']:
-                        y = int(row['y1'])
-                        if row['x1'] < row['x2']:
-                            for x in range(int(row['x1']), int(math.ceil(row['x2']))):
-                                R_map_99[x][y] += row['values'] / (row['x2'] - row['x1'])
+                elif row[0] == 9 and row[3] == 9:
+                    # V line
+                    if row[1] != row[4]:
+                        y = int(row[2])
+                        if row[1] < row[4]:
+                            R_map_99[int(row[1]) : int(row[4] + 1), y] = 1
                         else:
-                            for x in range(int(row['x2']), int(math.ceil(row['x1']))):
-                                R_map_99[x][y] += row['values'] / (row['x1'] - row['x2'])
+                            R_map_99[int(row[4]) : int(row[1] + 1), y] = 1
 
-                    # V line
-                    elif row['y1'] != row['y2']:
-                        x = int(row['x1'])
-                        if row['y1'] < row['y2']:
-                            for y in range(int(row['y1']), int(math.ceil(row['y2']))):
-                                R_map_99[x][y] += row['values'] / (row['y2'] - row['y1'])
+                    # H line
+                    elif row[2] != row[5]:
+                        x = int(row[1])
+                        if row[2] < row[5]:
+                            R_map_99[x, int(row[2]) : int(row[5] + 1)] = 1
                         else:
-                            for x in range(int(row['y2']), int(math.ceil(row['y1']))):
-                                R_map_99[x][y] += row['values'] / (row['y1'] - row['y2'])
+                            R_map_99[x, int(row[5]) : int(row[2] + 1)] = 1
                     else:
-                        raise AssertionError('R map row error')
+                        raise AssertionError(_data_idx, "R map row error")
                 else:
-                    raise AssertionError('R map layer not found', row['m1'], row['m2'])
+                    raise AssertionError(_data_idx, "R map layer not found", row[0], row[3])
+            
+            # clean not connect
+            # R_map_99[:, ~V_map.any(axis=0)] = 0
+            # R_map_89[:, ~V_map.any(axis=0)] = 0
+            
+            # clean wrong via
+            R_map_14[(R_map_11 == 0) | (R_map_44 == 0)] = 0
+            R_map_47[(R_map_44 == 0) | (R_map_77 == 0)] = 0
+            R_map_78[(R_map_77 == 0) | (R_map_88 == 0)] = 0
+            R_map_89[(R_map_88 == 0) | (R_map_99 == 0)] = 0
 
+            
             # I
-            df_I = df[df['type'].str.contains('I')]
-            df_I[['x1', 'y1']] = df_I[['x1', 'y1']].astype(float) / 2000 + 0.5
+            df_I = df[df["type"].str.contains("I")]
+            assert df_I[["x1", "y1"]].astype(int).mod(800).eq(0).all().all(), (_data_idx, "I map error")
+            df_I[["x1", "y1"]] = df_I[["x1", "y1"]].astype(int) // 800
+            df_I = df_I[["x1", "y1", "values"]].to_numpy()
 
             I_map = np.zeros((H, W))
-
-            for index, row in df_I.iterrows():
-                y = int(row['y1'])
-                x = int(row['x1'])
-                I_map[x][y] += row['values']
+            for row in df_I:
+                x = int(row[0])
+                y = int(row[1])
+                I_map[x, y] = row[2]
+            
+            assert (((I_map != 0) & (R_map_11 != 0)) == (I_map != 0)).all(), (_data_idx, np.argwhere(((I_map != 0) & (R_map_11 != 0)) != (I_map != 0)), "I R not connect")
             
+            # R sim
+            if self.config.use_ir_map:
+                I_sim_map_14, IR_map_14 = get_IR_map_H(R_map_14, I_map)
+                I_sim_map_47, IR_map_47 = get_IR_map_V(R_map_47, I_sim_map_14)
+                I_sim_map_78, IR_map_78 = get_IR_map_H(R_map_78, I_sim_map_47)
+                I_sim_map_89, IR_map_89 = get_IR_map_V(R_map_89, I_sim_map_78)
+
             
+            if self.config.use_multi_dist:
+                cdt = np.ones((H*2 - 1, W*2 - 1))
+                cdt[H - 1, W - 1] = 0
+                cdt = 1 / (get_dist(self, cdt) + 1e-8)
+                
+                # V dist
+                V_multi_dist = np.zeros((H, W))
+                for idx in np.argwhere(V_map != 0):
+                    x = H - idx[0] - 1
+                    y = W - idx[1] - 1
+                    V_multi_dist += cdt[x:x+H, y:y+W]
+
+                # Via dist
+                R_multi_dist_14 = np.zeros((H, W))
+                R_multi_dist_47 = np.zeros((H, W))
+                R_multi_dist_78 = np.zeros((H, W))
+                R_multi_dist_89 = np.zeros((H, W))
+                for idx in np.argwhere(R_map_14 != 0):
+                    x = H - idx[0] - 1
+                    y = W - idx[1] - 1
+                    R_multi_dist_14 += cdt[x:x+H, y:y+W]
+                for idx in np.argwhere(R_map_47 != 0):
+                    x = H - idx[0] - 1
+                    y = W - idx[1] - 1
+                    R_multi_dist_47 += cdt[x:x+H, y:y+W]
+                for idx in np.argwhere(R_map_78 != 0):
+                    x = H - idx[0] - 1
+                    y = W - idx[1] - 1
+                    R_multi_dist_78 += cdt[x:x+H, y:y+W]
+                for idx in np.argwhere(R_map_89 != 0):
+                    x = H - idx[0] - 1
+                    y = W - idx[1] - 1
+                    R_multi_dist_89 += cdt[x:x+H, y:y+W]
+
+
+            # resize
+            R_map_11 = resize(R_map_11) / (H * W) * (_H * _W)
+            R_map_14 = resize(R_map_14) / (H * W) * (_H * _W)
+            R_map_44 = resize(R_map_44) / (H * W) * (_H * _W)
+            R_map_47 = resize(R_map_47) / (H * W) * (_H * _W)
+            R_map_77 = resize(R_map_77) / (H * W) * (_H * _W)
+            R_map_78 = resize(R_map_78) / (H * W) * (_H * _W)
+            R_map_88 = resize(R_map_88) / (H * W) * (_H * _W)
+            R_map_89 = resize(R_map_89) / (H * W) * (_H * _W)
+            R_map_99 = resize(R_map_99) / (H * W) * (_H * _W)
+            I_map = resize(I_map) / (H * W) * (_H * _W)
+            V_map = resize(V_map) / (H * W) * (_H * _W)
+            if self.config.use_multi_dist:
+                V_multi_dist = resize(1 / V_multi_dist) / math.sqrt(H * W) * math.sqrt(_H * _W)
+                R_multi_dist_14 = resize(1 / R_multi_dist_14) / math.sqrt(H * W) * math.sqrt(_H * _W)
+                R_multi_dist_47 = resize(1 / R_multi_dist_47) / math.sqrt(H * W) * math.sqrt(_H * _W)
+                R_multi_dist_78 = resize(1 / R_multi_dist_78) / math.sqrt(H * W) * math.sqrt(_H * _W)
+                R_multi_dist_89 = resize(1 / R_multi_dist_89) / math.sqrt(H * W) * math.sqrt(_H * _W)
+            if self.config.use_ir_map:
+                IR_map_14 = resize(IR_map_14, max_pool=False) / (H * W) * (_H * _W) / (H * W) * (_H * _W)
+                IR_map_47 = resize(IR_map_47, max_pool=False) / (H * W) * (_H * _W) / (H * W) * (_H * _W)
+                IR_map_78 = resize(IR_map_78, max_pool=False) / (H * W) * (_H * _W) / (H * W) * (_H * _W)
+                IR_map_89 = resize(IR_map_89, max_pool=False) / (H * W) * (_H * _W) / (H * W) * (_H * _W)
+
             
-            yield i, {
-                "data_idx": _data_idx,
-                "current": genfromtxt(_current, delimiter=',') * 1e6,
-                "pdn_density": genfromtxt(_pdn_density, delimiter=','),
-                "eff_dist": genfromtxt(_eff_dist, delimiter=','),
-                "ir_drop": genfromtxt(_ir_drop, delimiter=',') * 1e3,
-                "netlist": open(_netlist, 'r').read(),
-                "R_map_11": R_map_11,
-                "R_map_14": R_map_14,
-                "R_map_44": R_map_44,
-                "R_map_47": R_map_47,
-                "R_map_77": R_map_77,
-                "R_map_78": R_map_78,
-                "R_map_88": R_map_88,
-                "R_map_89": R_map_89,
-                "R_map_99": R_map_99,
-                "I_map": I_map * 1e6,
-            }
+            yield _idx, get_image(self, {
+                **{
+                    "data_idx": _data_idx,
+                    "H": _H,
+                    "W": _W,
+                    "current": resize(genfromtxt(_current, delimiter=",")) * 1e6,
+                    "pdn_density": resize(genfromtxt(_pdn_density, delimiter=",")),
+                    "eff_dist": resize(genfromtxt(_eff_dist, delimiter=",")),
+                    "ir_drop": resize(genfromtxt(_ir_drop, delimiter=",")) * 1e3,
+                    "R_map_11": R_map_11,
+                    "R_map_14": R_map_14,
+                    "R_map_44": R_map_44,
+                    "R_map_47": R_map_47,
+                    "R_map_77": R_map_77,
+                    "R_map_78": R_map_78,
+                    "R_map_88": R_map_88,
+                    "R_map_89": R_map_89,
+                    "R_map_99": R_map_99,
+                    "I_map": I_map * 1e6,
+                    "V_map": V_map,
+                },
+                **({
+                    "V_multi_dist": V_multi_dist,
+                    "R_multi_dist_14": R_multi_dist_14,
+                    "R_multi_dist_47": R_multi_dist_47,
+                    "R_multi_dist_78": R_multi_dist_78,
+                    "R_multi_dist_89": R_multi_dist_89,
+                } if self.config.use_multi_dist else {}),
+                **({
+                    "IR_map_14": IR_map_14 * 1e3,
+                    "IR_map_47": IR_map_47 * 1e3,
+                    "IR_map_78": IR_map_78 * 1e3,
+                    "IR_map_89": IR_map_89 * 1e3,
+                } if self.config.use_ir_map else {})
+            })