Use getitem everywhere

docs/demos/connecting_new_consumer.ipynb

@@ -73,8 +73,8 @@
     "\n",
     "grid.set_feeder_ids()\n",
     "\n",
-    "grid.node.x_coor = np.random.uniform(100, 500, len(grid.node))\n",
-    "grid.node.y_coor = np.random.uniform(100, 500, len(grid.node))"
+    "grid.node[\"x_coor\"] = np.random.uniform(100, 500, len(grid.node))\n",
+    "grid.node[\"y_coor\"] = np.random.uniform(100, 500, len(grid.node))"
    ]
   },
   {
@@ -149,24 +149,26 @@
     "):\n",
     "    closest_node_idx = find_closest_node(\n",
     "        grid=grid,\n",
-    "        x=new_consumer.x_coor[0],\n",
-    "        y=new_consumer.y_coor[0],\n",
+    "        x=new_consumer[\"x_coor\"].item(),\n",
+    "        y=new_consumer[\"y_coor\"].item(),\n",
     "    )\n",
     "    closest_node = grid.node[closest_node_idx]\n",
     "\n",
     "    grid.append(new_consumer)\n",
-    "    new_consumer_load.node = new_consumer.id\n",
+    "    new_consumer_load[\"node\"] = new_consumer[\"id\"]\n",
     "    grid.append(new_consumer_load)\n",
     "\n",
-    "    dist = np.sqrt((closest_node.x_coor - new_consumer.x_coor) ** 2 + (closest_node.y_coor - new_consumer.y_coor) ** 2)\n",
+    "    distance = np.sqrt(\n",
+    "        (closest_node[\"x_coor\"] - new_consumer[\"x_coor\"]) ** 2 + (closest_node[\"y_coor\"] - new_consumer[\"y_coor\"]) ** 2\n",
+    "    )\n",
     "\n",
     "    new_line = ExtendedLineArray(\n",
     "        from_node=[closest_node.id],\n",
     "        to_node=[new_consumer.id],\n",
     "        from_status=[1],\n",
     "        to_status=[1],\n",
-    "        r1=[R_PER_KM * dist / 1_000],\n",
-    "        x1=[X_PER_KM * dist / 1_000],\n",
+    "        r1=[R_PER_KM * distance / 1_000],\n",
+    "        x1=[X_PER_KM * distance / 1_000],\n",
     "        c1=[0],\n",
     "        tan1=[0],\n",
     "        i_n=[200],\n",
@@ -231,8 +233,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"Overloaded nodes: {grid.node[grid.node.is_overloaded].id}\")\n",
-    "print(f\"Overloaded lines: {grid.line[grid.line.is_overloaded].id}\")"
+    "print(f\"Overloaded nodes: {grid.node[grid.node.is_overloaded]['id']}\")\n",
+    "print(f\"Overloaded lines: {grid.line[grid.line.is_overloaded]['id']}\")"
    ]
   },
   {
@@ -255,8 +257,8 @@
     "    connect_new_consumer(grid, new_consumer, new_consumer_load)\n",
     "update_grid(grid)\n",
     "\n",
-    "print(f\"Overloaded nodes: {grid.node[grid.node.is_overloaded].id}\")\n",
-    "print(f\"Overloaded lines: {grid.line[grid.line.is_overloaded].id}\")"
+    "print(f\"Overloaded nodes: {grid.node[grid.node.is_overloaded]['id']}\")\n",
+    "print(f\"Overloaded lines: {grid.line[grid.line.is_overloaded]['id']}\")"
    ]
   }
  ],

docs/examples/generators/generator_examples.ipynb

@@ -140,14 +140,14 @@
     "# Setup initial nodes and sources\n",
     "grid = Grid.empty()\n",
     "nodes = NodeArray.zeros(4)\n",
-    "nodes.id = [0, 1, 2, 3]\n",
-    "nodes.u_rated = [10_500] * 4\n",
+    "nodes[\"id\"] = [0, 1, 2, 3]\n",
+    "nodes[\"u_rated\"] = [10_500] * 4\n",
     "\n",
     "sources = SourceArray.zeros(1)\n",
-    "sources.id = [4]\n",
-    "sources.node = [0]\n",
-    "sources.status = [1]\n",
-    "sources.u_ref = [1]\n",
+    "sources[\"id\"] = [4]\n",
+    "sources[\"node\"] = [0]\n",
+    "sources[\"status\"] = [1]\n",
+    "sources[\"u_ref\"] = [1]\n",
     "\n",
     "grid.append(nodes)\n",
     "grid.append(sources)\n",

docs/examples/model/array_examples.ipynb

@@ -67,6 +67,7 @@
    "source": [
     "# Accessing a single column\n",
     "id_column = fancy_array[\"id\"]\n",
+    "# Alternative syntax (not recommended: not type-safe)\n",
     "id_column = fancy_array.id\n",
     "\n",
     "# Accessing multiple columns\n",
@@ -89,12 +90,14 @@
    "outputs": [],
    "source": [
     "# Setting new values to a column\n",
-    "fancy_array.id = np.array([9, 9, 9])\n",
     "fancy_array[\"id\"] = np.array([9, 9, 9])\n",
-    "fancy_array.id = [9, 9, 9]\n",
     "fancy_array[\"id\"] = [9, 9, 9]\n",
-    "fancy_array.id = 9\n",
-    "fancy_array[\"id\"] = 9"
+    "fancy_array[\"id\"] = 9\n",
+    "\n",
+    "# Alternative syntax (not recommended: not type-safe)\n",
+    "fancy_array.id = np.array([9, 9, 9])\n",
+    "fancy_array.id = [9, 9, 9]\n",
+    "fancy_array.id = 9"
    ]
   },
   {
@@ -176,7 +179,7 @@
    "outputs": [],
    "source": [
     "# Example analysis: sum of a column\n",
-    "total = np.sum(fancy_array.test_int)"
+    "total = np.sum(fancy_array[\"test_int\"])"
    ]
   },
   {

docs/examples/model/grid_examples.ipynb

@@ -107,13 +107,13 @@
    "source": [
     "from power_grid_model_ds.arrays import TransformerArray\n",
     "\n",
-    "trafo = TransformerArray.empty(1)\n",
-    "trafo.id = 301\n",
-    "trafo.from_status = 1\n",
-    "trafo.to_status = 1\n",
-    "trafo.from_node = 102\n",
-    "trafo.to_node = 106\n",
-    "grid.append(trafo, check_max_id=False)"
+    "transformer = TransformerArray.empty(1)\n",
+    "transformer[\"id\"] = 301\n",
+    "transformer[\"from_status\"] = 1\n",
+    "transformer[\"to_status\"] = 1\n",
+    "transformer[\"from_node\"] = 102\n",
+    "transformer[\"to_node\"] = 106\n",
+    "grid.append(transformer, check_max_id=False)"
    ]
   },
   {
@@ -284,8 +284,8 @@
     "from power_grid_model_ds.arrays import LineArray\n",
     "\n",
     "new_line_array = LineArray.zeros(1)\n",
-    "new_line_array.from_node = 102\n",
-    "new_line_array.to_node = 105\n",
+    "new_line_array[\"from_node\"] = 102\n",
+    "new_line_array[\"to_node\"] = 105\n",
     "grid.add_branch(branch=new_line_array)"
    ]
   },
@@ -330,8 +330,8 @@
     "from power_grid_model_ds.arrays import LinkArray\n",
     "\n",
     "new_link_array = LinkArray.zeros(1)\n",
-    "new_link_array.from_node = 102\n",
-    "new_link_array.to_node = 105\n",
+    "new_link_array[\"from_node\"] = 102\n",
+    "new_link_array[\"to_node\"] = 105\n",
     "grid.add_branch(branch=new_link_array)"
    ]
   },
@@ -355,8 +355,8 @@
     "from power_grid_model_ds.arrays import TransformerArray\n",
     "\n",
     "new_transformer_array = TransformerArray.zeros(1)\n",
-    "new_transformer_array.from_node = 102\n",
-    "new_transformer_array.to_node = 105\n",
+    "new_transformer_array[\"from_node\"] = 102\n",
+    "new_transformer_array[\"to_node\"] = 105\n",
     "grid.add_branch(branch=new_transformer_array)"
    ]
   },

docs/model_interface.ipynb

@@ -71,8 +71,8 @@
     "from power_grid_model_ds.arrays import LineArray\n",
     "\n",
     "new_line_array = LineArray.zeros(1)\n",
-    "new_line_array.from_node = 2\n",
-    "new_line_array.to_node = 5\n",
+    "new_line_array[\"from_node\"] = 2\n",
+    "new_line_array[\"to_node\"] = 5\n",
     "grid.add_branch(branch=new_line_array)"
    ]
   },

src/power_grid_model_ds/_core/data_source/generator/arrays/base.py

@@ -12,7 +12,7 @@
 class BaseGenerator:
     """Base class to build a generator for grid elements"""
 
-    def __init__(self, grid: Grid, seed: int) -> None:
+    def __init__(self, grid: Grid, seed: int | None) -> None:
         """Initializes generator with grid and amount"""
         self.grid = grid
 

src/power_grid_model_ds/_core/data_source/generator/arrays/line.py

@@ -52,19 +52,19 @@ def create_routes(self, number_of_routes: int):
         """Create a number of lines from the substation to unconnected nodes"""
         # each source should have at least one route
         number_of_sources = len(self.grid.source)
-        from_nodes = self.rng.choice(self.grid.source.node, number_of_routes - number_of_sources, replace=True)
-        not_source_mask = ~np.isin(self.grid.node.id, self.grid.source.node)
-        to_nodes = self.rng.choice(self.grid.node.id[not_source_mask], number_of_routes, replace=False)
+        from_nodes = self.rng.choice(self.grid.source["node"], number_of_routes - number_of_sources, replace=True)
+        not_source_mask = ~np.isin(self.grid.node["id"], self.grid.source["node"])
+        to_nodes = self.rng.choice(self.grid.node["id"][not_source_mask], number_of_routes, replace=False)
         capacities = 100 + self.rng.exponential(200, number_of_routes)
         line_array = self.grid.line.__class__.zeros(number_of_routes)
-        line_array.id = 1 + self.grid.max_id + np.arange(number_of_routes)
-        line_array.from_node = np.concatenate((self.grid.source.node, from_nodes))
-        line_array.to_node = to_nodes
-        line_array.from_status = [1] * number_of_routes
-        line_array.to_status = [1] * number_of_routes
-        line_array.r1 = self.rng.exponential(0.2, number_of_routes)
-        line_array.x1 = self.rng.exponential(0.02, number_of_routes)
-        line_array.i_n = capacities
+        line_array["id"] = 1 + self.grid.max_id + np.arange(number_of_routes)
+        line_array["from_node"] = np.concatenate((self.grid.source["node"], from_nodes))
+        line_array["to_node"] = to_nodes
+        line_array["from_status"] = [1] * number_of_routes
+        line_array["to_status"] = [1] * number_of_routes
+        line_array["r1"] = self.rng.exponential(0.2, number_of_routes)
+        line_array["x1"] = self.rng.exponential(0.02, number_of_routes)
+        line_array["i_n"] = capacities
         self.line_array = line_array
 
     def determine_number_of_routes(self) -> int:
@@ -78,56 +78,56 @@ def determine_number_of_routes(self) -> int:
     def connect_nodes(self):
         """Add a new line between an active and inactive line"""
         to_node = self.rng.choice(self.unconnected_nodes)
-        to_voltage = self.grid.node[self.grid.node.id == to_node].u_rated[0]
-        same_voltage_mask = self.grid.node.u_rated == to_voltage
-        same_voltage_nodes = self.grid.node[same_voltage_mask]
-        options_mask = np.isin(self.connected_nodes, same_voltage_nodes.id)
+        to_voltage = self.grid.node.data[self.grid.node["id"] == to_node]["u_rated"][0]
+        same_voltage_mask = self.grid.node["u_rated"] == to_voltage
+        same_voltage_nodes = self.grid.node.data[same_voltage_mask]
+        options_mask = np.isin(self.connected_nodes, same_voltage_nodes["id"])
         from_node = self.rng.choice(np.array(self.connected_nodes)[options_mask])
         capacity = 100 + self.rng.exponential(200, 1)
         new_line = self.grid.line.__class__.zeros(1)
-        new_line.id = 1 + max(max(self.line_array.id), self.grid.max_id)  # pylint: disable=nested-min-max
-        new_line.from_node = from_node
-        new_line.to_node = to_node
-        new_line.from_status = [1]
-        new_line.to_status = [1]
-        new_line.r1 = self.rng.exponential(0.2, 1)
-        new_line.x1 = self.rng.exponential(0.02, 1)
-        new_line.i_n = capacity
+        new_line["id"] = 1 + max(max(self.line_array["id"]), self.grid.max_id)  # pylint: disable=nested-min-max
+        new_line["from_node"] = from_node
+        new_line["to_node"] = to_node
+        new_line["from_status"] = [1]
+        new_line["to_status"] = [1]
+        new_line["r1"] = self.rng.exponential(0.2, 1)
+        new_line["x1"] = self.rng.exponential(0.02, 1)
+        new_line["i_n"] = capacity
         self.line_array = fp.concatenate(self.line_array, new_line)
 
     def create_nop_lines(self, number_of_nops: int):
         """Create the inactive lines between different routes (Normally Open Points)"""
-        nops = [self.rng.choice(self.grid.node.id, 2, replace=False) for _ in range(number_of_nops)]
+        nops = [self.rng.choice(self.grid.node["id"], 2, replace=False) for _ in range(number_of_nops)]
         from_nodes = [nop[0] for nop in nops]
         to_nodes = [nop[1] for nop in nops]
         capacities = 100 + self.rng.exponential(200, number_of_nops)
         nop_lines = self.grid.line.__class__.zeros(number_of_nops)
-        nop_lines.id = 1 + self.line_array.id.max() + np.arange(number_of_nops)
-        nop_lines.from_node = from_nodes
-        nop_lines.to_node = to_nodes
-        nop_lines.from_status = [1] * number_of_nops
-        nop_lines.to_status = [0] * number_of_nops
-        nop_lines.r1 = self.rng.exponential(0.2, number_of_nops)
-        nop_lines.x1 = self.rng.exponential(0.02, number_of_nops)
-        nop_lines.i_n = capacities
+        nop_lines["id"] = 1 + self.line_array["id"].max() + np.arange(number_of_nops)
+        nop_lines["from_node"] = from_nodes
+        nop_lines["to_node"] = to_nodes
+        nop_lines["from_status"] = [1] * number_of_nops
+        nop_lines["to_status"] = [0] * number_of_nops
+        nop_lines["r1"] = self.rng.exponential(0.2, number_of_nops)
+        nop_lines["x1"] = self.rng.exponential(0.02, number_of_nops)
+        nop_lines["i_n"] = capacities
         self.line_array = fp.concatenate(self.line_array, nop_lines)
 
     def set_unconnected_nodes(self) -> None:
         """From a line array and total set of nodes determine which are not yet connected"""
         connected_link_mask = np.logical_or(
-            np.isin(self.grid.node.id, self.line_array.from_node),
-            np.isin(self.grid.node.id, self.line_array.to_node),
+            np.isin(self.grid.node["id"], self.line_array["from_node"]),
+            np.isin(self.grid.node["id"], self.line_array["to_node"]),
         )
         connected_trafo_mask = np.logical_or(
-            np.isin(self.grid.node.id, self.trafo_array.from_node),
-            np.isin(self.grid.node.id, self.trafo_array.to_node),
+            np.isin(self.grid.node["id"], self.trafo_array["from_node"]),
+            np.isin(self.grid.node["id"], self.trafo_array["to_node"]),
         )
         connected_mask = np.logical_or(
             connected_link_mask,
             connected_trafo_mask,
         )
-        connected_nodes = self.grid.node.id[connected_mask]
-        unconnected_nodes = self.grid.node.id[~connected_mask]
+        connected_nodes = self.grid.node["id"][connected_mask]
+        unconnected_nodes = self.grid.node["id"][~connected_mask]
 
         self.unconnected_nodes = unconnected_nodes.tolist()
         self.connected_nodes = connected_nodes.tolist()

src/power_grid_model_ds/_core/data_source/generator/arrays/node.py

@@ -16,22 +16,22 @@ class NodeGenerator(BaseGenerator):
     def run(self, amount: int, voltage_level: int = 10_500):
         """Generate nodes in a grid with two possible load scenarios"""
         node_array = self.grid.node.__class__.zeros(amount)
-        node_array.id = 1 + self.grid.max_id + np.arange(amount)
-        node_array.u_rated = voltage_level
+        node_array["id"] = 1 + self.grid.max_id + np.arange(amount)
+        node_array["u_rated"] = voltage_level
 
         load_low_array = self.grid.sym_load.__class__.zeros(amount)
-        load_low_array.id = 1 + node_array.id.max() + np.arange(amount)
-        load_low_array.node = node_array.id
-        load_low_array.status = 1
+        load_low_array["id"] = 1 + node_array["id"].max() + np.arange(amount)
+        load_low_array["node"] = node_array["id"]
+        load_low_array["status"] = 1
         load_high_array = self.grid.sym_load.__class__.zeros(amount)
-        load_high_array.id = 1 + load_low_array.id.max() + np.arange(amount)
-        load_high_array.node = node_array.id
-        load_high_array.status = 1
+        load_high_array["id"] = 1 + load_low_array["id"].max() + np.arange(amount)
+        load_high_array["node"] = node_array["id"]
+        load_high_array["status"] = 1
 
         # power consumption in Watt
-        load_low_array.p_specified = np.round(self.rng.normal(200_000, 150_000, amount))
-        load_low_array.q_specified = np.round(self.rng.normal(20_000, 15_000, amount))
-        load_high_array.p_specified = np.round(self.rng.normal(-100_000, 350_000, amount))
-        load_high_array.q_specified = np.round(self.rng.normal(-5_000, 35_000, amount))
+        load_low_array["p_specified"] = np.round(self.rng.normal(200_000, 150_000, amount))
+        load_low_array["q_specified"] = np.round(self.rng.normal(20_000, 15_000, amount))
+        load_high_array["p_specified"] = np.round(self.rng.normal(-100_000, 350_000, amount))
+        load_high_array["q_specified"] = np.round(self.rng.normal(-5_000, 35_000, amount))
 
         return node_array, load_low_array, load_high_array

src/power_grid_model_ds/_core/data_source/generator/arrays/source.py

@@ -17,14 +17,14 @@ class SourceGenerator(BaseGenerator):
     def run(self, amount: int) -> tuple[NodeArray, SourceArray]:
         """Generate nodes in a grid which are sources (substations)"""
         substation_node_array = self.grid.node.__class__.empty(amount)
-        substation_node_array.id = 1 + self.grid.max_id + np.arange(amount)
-        substation_node_array.u_rated = 10_500
-        substation_node_array.node_type = NodeType.SUBSTATION_NODE.value
+        substation_node_array["id"] = 1 + self.grid.max_id + np.arange(amount)
+        substation_node_array["u_rated"] = 10_500
+        substation_node_array["node_type"] = NodeType.SUBSTATION_NODE.value
 
         source_array = self.grid.source.__class__.empty(amount)
-        source_array.id = 1 + substation_node_array.id.max() + np.arange(amount)
-        source_array.node = substation_node_array.id
-        source_array.status = 1
-        source_array.u_ref = 1
+        source_array["id"] = 1 + substation_node_array["id"].max() + np.arange(amount)
+        source_array["node"] = substation_node_array["id"]
+        source_array["status"] = 1
+        source_array["u_ref"] = 1
 
         return substation_node_array, source_array