ltbams 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

ams/io/matpower.py

@@ -2,11 +2,16 @@
 MATPOWER parser.
 """
 import logging
+import re
 import numpy as np
 
-from andes.io.matpower import m2mpc
+from andes.io import read_file_like
+from andes.io.xlsx import confirm_overwrite
 from andes.shared import deg2rad, rad2deg
 
+from ams import __version__ as version
+from ams.shared import copyright_msg, nowarranty_msg, report_time
+
 logger = logging.getLogger(__name__)
 
 
@@ -29,6 +34,151 @@ def read(system, file):
     return mpc2system(mpc, system)
 
 
+def m2mpc(infile: str) -> dict:
+    """
+    Parse a MATPOWER file and return a dictionary containing the parsed data.
+
+    This function processes MATPOWER case files and extracts relevant fields
+    into a structured dictionary. It is revised from ``andes.io.matpower.m2mpc``.
+
+    Supported fields include:
+    - `baseMVA`: The system base power in MVA.
+    - `bus`: Bus data, including voltage, load, and generation information.
+    - `bus_name`: Names of the buses (if available).
+    - `gen`: Generator data, including power limits and voltage setpoints.
+    - `branch`: Branch data, including line impedances and ratings.
+    - `gencost`: Generator cost data (parsed but not used in this implementation).
+    - `areas`: Area data (parsed but not used in this implementation).
+    - `gentype`: Generator type information (if available).
+    - `genfuel`: Generator fuel type information (if available).
+
+    Parameters
+    ----------
+    infile : str
+        Path to the MATPOWER file to be parsed.
+
+    Returns
+    -------
+    dict
+        A dictionary containing the parsed MATPOWER data, where keys correspond
+        to MATPOWER struct names and values are numpy arrays or lists.
+    """
+
+    func = re.compile(r'function\s')
+    mva = re.compile(r'\s*mpc.baseMVA\s*=\s*')
+    bus = re.compile(r'\s*mpc.bus\s*=\s*\[?')
+    gen = re.compile(r'\s*mpc.gen\s*=\s*\[')
+    branch = re.compile(r'\s*mpc.branch\s*=\s*\[')
+    area = re.compile(r'\s*mpc.areas\s*=\s*\[')
+    gencost = re.compile(r'\s*mpc.gencost\s*=\s*\[')
+    bus_name = re.compile(r'\s*mpc.bus_name\s*=\s*{')
+    gentype = re.compile(r'\s*mpc.gentype\s*=\s*{')
+    genfuel = re.compile(r'\s*mpc.genfuel\s*=\s*{')
+    end = re.compile(r'\s*[\];}]')
+    has_digit = re.compile(r'.*\d+\s*]?;?')
+
+    field = None
+    info = True
+
+    mpc = {
+        'version': 2,  # not in use
+        'baseMVA': 100,
+        'bus': [],
+        'gen': [],
+        'branch': [],
+        'area': [],
+        'gencost': [],
+        'bus_name': [],
+        'gentype': [],
+        'genfuel': [],
+    }
+
+    input_list = read_file_like(infile)
+
+    for line in input_list:
+        line = line.strip().rstrip(';')
+        if not line:
+            continue
+        elif func.search(line):  # skip function declaration
+            continue
+        elif len(line.split('%')[0]) == 0:
+            if info is True:
+                logger.info(line[1:])
+                info = False
+            else:
+                continue
+        elif mva.search(line):
+            mpc["baseMVA"] = float(line.split('=')[1])
+
+        if not field:
+            if bus.search(line):
+                field = 'bus'
+            elif gen.search(line):
+                field = 'gen'
+            elif branch.search(line):
+                field = 'branch'
+            elif area.search(line):
+                field = 'area'
+            elif gencost.search(line):
+                field = 'gencost'
+            elif bus_name.search(line):
+                field = 'bus_name'
+            elif gentype.search(line):
+                field = 'gentype'
+            elif genfuel.search(line):
+                field = 'genfuel'
+            else:
+                continue
+        elif end.search(line):
+            field = None
+            continue
+
+        # parse mpc sections
+        if field:
+            if line.find('=') >= 0:
+                line = line.split('=')[1]
+            if line.find('[') >= 0:
+                line = re.sub(r'\[', '', line)
+            elif line.find('{') >= 0:
+                line = re.sub(r'{', '', line)
+
+            if field in ['bus_name', 'gentype', 'genfuel']:
+                # Handle string-based fields
+                line = line.split(';')
+                data = [i.strip('\'').strip() for i in line if i.strip()]
+                mpc[field].extend(data)
+            else:
+                if not has_digit.search(line):
+                    continue
+                line = line.split('%')[0].strip()
+                line = line.split(';')
+                for item in line:
+                    if not has_digit.search(item):
+                        continue
+                    try:
+                        data = np.array([float(val) for val in item.split()])
+                    except Exception as e:
+                        logger.error('Error parsing "%s"', infile)
+                        raise e
+                    mpc[field].append(data)
+
+    # convert mpc to np array
+    mpc_array = dict()
+    for key, val in mpc.items():
+        if isinstance(val, (float, int)):
+            mpc_array[key] = val
+        elif isinstance(val, list):
+            if len(val) == 0:
+                continue
+            if key in ['bus_name', 'gentype', 'genfuel']:
+                mpc_array[key] = np.array(val, dtype=object)
+            else:
+                mpc_array[key] = np.array(val)
+        else:
+            raise NotImplementedError("Unknown type for mpc, ", type(val))
+    return mpc_array
+
+
 def mpc2system(mpc: dict, system) -> bool:
     """
     Load an mpc dict into an empty AMS system.
@@ -97,7 +247,20 @@ def mpc2system(mpc: dict, system) -> bool:
         mpc_gen[:, 19] = system.PV.Rq.default * base_mva / 60
     else:
         mpc_gen = mpc['gen']
-    for data in mpc_gen:
+
+    # Ensure 'gentype' and 'genfuel' keys exist in mpc, with default values if missing
+    gentype = mpc.get('gentype', [''] * mpc_gen.shape[0])
+    genfuel = mpc.get('genfuel', [''] * mpc_gen.shape[0])
+
+    # Validate lengths of 'gentype' and 'genfuel' against the number of generators
+    if len(gentype) != mpc_gen.shape[0]:
+        raise ValueError(
+            f"'gentype' length ({len(gentype)}) does not match the number of generators ({mpc_gen.shape[0]})")
+    if len(genfuel) != mpc_gen.shape[0]:
+        raise ValueError(
+            f"'genfuel' length ({len(genfuel)}) does not match the number of generators ({mpc_gen.shape[0]})")
+
+    for data, gt, gf in zip(mpc_gen, gentype, genfuel):
         # bus  pg  qg  qmax  qmin  vg  mbase  status  pmax  pmin
         # 0    1   2   3     4     5   6      7       8     9
         # pc1  pc2  qc1min  qc1max  qc2min  qc2max  ramp_agc  ramp_10
@@ -142,7 +305,7 @@ def mpc2system(mpc: dict, system) -> bool:
                        Qc2min=qc2min, Qc2max=qc2max,
                        Ragc=ramp_agc, R10=ramp_10,
                        R30=ramp_30, Rq=ramp_q,
-                       apf=apf)
+                       apf=apf, gentype=gt, genfuel=gf)
         else:
             system.add('PV', idx=gen_idx, bus=bus_idx, busr=bus_idx,
                        name=None,
@@ -155,7 +318,7 @@ def mpc2system(mpc: dict, system) -> bool:
                        Qc2min=qc2min, Qc2max=qc2max,
                        Ragc=ramp_agc, R10=ramp_10,
                        R30=ramp_30, Rq=ramp_q,
-                       apf=apf)
+                       apf=apf, gentype=gt, genfuel=gf)
 
     for data in mpc['branch']:
         # fbus	tbus	r	x	b	rateA	rateB	rateC	ratio	angle
@@ -204,9 +367,8 @@ def mpc2system(mpc: dict, system) -> bool:
         gen_idx = np.arange(mpc['gen'].shape[0]) + 1
         mpc_cost = mpc['gencost']
         if mpc_cost[0, 0] == 1:
-            logger.warning("Type 1 gencost detected. "
-                           "This is not supported in AMS. "
-                           "Default type 2 cost parameters will be used as a fallback."
+            logger.warning("Type 1 gencost detected, which is not supported in AMS.\n"
+                           "Default type 2 cost parameters will be used as a fallback.\n"
                            "It is recommended to manually convert the gencost data to type 2.")
             mpc_cost = np.repeat(np.array([[2, 0, 0, 3, 0, 0, 0]]),
                                  mpc_cost.shape[0], axis=0)
@@ -238,14 +400,24 @@ def mpc2system(mpc: dict, system) -> bool:
                        c2=c2, c1=c1, c0=c0
                        )
 
+    # --- Area ---
+    area_id = np.unique(system.Bus.area.v).astype(int)
+    for area in area_id:
+        area_idx = f'AREA_{area}'
+        system.add('Area', idx=area_idx, name=area)
+    bus_area = system.Bus.area.v
+    bus_area = [f'AREA_{int(area)}' for area in bus_area]
+    system.Bus.area.v = bus_area
+
     # --- Zone ---
     zone_id = np.unique(system.Bus.zone.v).astype(int)
     for zone in zone_id:
         zone_idx = f'ZONE_{zone}'
-        system.add('Zone', idx=zone_idx, name=None)
+        system.add('Zone', idx=zone_idx, name=zone)
     bus_zone = system.Bus.zone.v
     bus_zone = [f'ZONE_{int(zone)}' for zone in bus_zone]
     system.Bus.zone.v = bus_zone
+
     return True
 
 
@@ -271,25 +443,29 @@ def _get_bus_id_caller(bus):
 
 def system2mpc(system) -> dict:
     """
-    Convert data from an AMS system to an mpc dict.
+    Convert a **setup** AMS system to a MATPOWER mpc dictionary.
+
+    This function is revised from ``andes.io.matpower.system2mpc``.
 
-    In the ``gen`` section, slack generators preceeds PV generators.
+    In the ``gen`` section, slack generators are listed before PV generators.
 
-    Compared to the ``andes.io.matpower.system2mpc``,
-    this function includes the generator cost data in the ``gencost``
-    section.
-    Additionally, ``c2`` and ``c1`` are scaled by ``base_mva`` to match
-    MATPOWER unit ``MW``.
+    In the converted MPC, the indices of area (bus[:, 6]) and zone (bus[:, 10])
+    may differ from the original MPC. However, the mapping relationship is preserved.
+    For example, if the original MPC numbers areas starting from 1, the converted
+    MPC may number them starting from 0.
+
+    The coefficients ``c2`` and ``c1`` in the generator cost data are scaled by
+    ``base_mva`` to match MATPOWER's unit convention (MW).
 
     Parameters
     ----------
     system : ams.core.system.System
-        AMS system
+        The AMS system to be converted.
 
     Returns
     -------
-    mpc: dict
-        MATPOWER mpc dict
+    mpc : dict
+        A dictionary in MATPOWER format representing the converted AMS system.
     """
 
     mpc = dict(version='2',
@@ -300,12 +476,16 @@ def system2mpc(system) -> dict:
                gencost=np.zeros((system.GCost.n, 7), dtype=np.float64),
                )
 
+    if not system.is_setup:
+        logger.warning("System is not setup and will be setup now.")
+        system.setup()
+
     if system.Bus.name.v is not None:
         mpc['bus_name'] = system.Bus.name.v
 
     base_mva = system.config.mva
 
-    # --- bus ---
+    # --- Bus ---
     bus = mpc['bus']
     gen = mpc['gen']
 
@@ -313,18 +493,16 @@ def system2mpc(system) -> dict:
 
     bus[:, 0] = to_busid(system.Bus.idx.v)
     bus[:, 1] = 1
+    if system.Area.n > 0:
+        bus[:, 6] = system.Area.idx2uid(system.Bus.area.v)
     bus[:, 7] = system.Bus.v0.v
     bus[:, 8] = system.Bus.a0.v * rad2deg
     bus[:, 9] = system.Bus.Vn.v
+    if system.Zone.n > 0:
+        bus[:, 10] = system.Zone.idx2uid(system.Bus.zone.v)
     bus[:, 11] = system.Bus.vmax.v
     bus[:, 12] = system.Bus.vmin.v
 
-    # --- zone ---
-    ZONE_I = system.Zone.idx.v
-    if len(ZONE_I) > 0:
-        mapping = {busi0: i for i, busi0 in enumerate(ZONE_I)}
-        bus[:, 10] = np.array([mapping[busi0] for busi0 in system.Bus.zone.v])
-
     # --- PQ ---
     if system.PQ.n > 0:
         pq_pos = system.Bus.idx2uid(system.PQ.bus.v)
@@ -410,4 +588,136 @@ def system2mpc(system) -> dict:
     else:
         mpc.pop('gencost')
 
+    # --- gentype ---
+    stg = system.StaticGen.get_all_idxes()
+    gentype = system.StaticGen.get(src='gentype', attr='v', idx=stg)
+    if any(gentype):
+        mpc['gentype'] = np.array(gentype)
+
+    # --- genfuel ---
+    genfuel = system.StaticGen.get(src='genfuel', attr='v', idx=stg)
+    if any(genfuel):
+        mpc['genfuel'] = np.array(genfuel)
+
+    # --- Bus Name ---
+    if any(system.Bus.name.v):
+        mpc['bus_name'] = np.array(system.Bus.name.v)
+
     return mpc
+
+
+def mpc2m(mpc: dict, outfile: str) -> str:
+    """
+    Write a MATPOWER mpc dict to a M-file.
+
+    Parameters
+    ----------
+    mpc : dict
+        MATPOWER mpc dictionary.
+    outfile : str
+        Path to the output M-file.
+    """
+    with open(outfile, 'w') as f:
+        # Add version info
+        f.write(f"%% Converted by AMS {version}\n")
+        f.write(f"%% {copyright_msg}\n\n")
+        f.write(f"%% {nowarranty_msg}\n")
+        f.write(f"%% Convert time: {report_time}\n\n")
+
+        f.write("function mpc = mpc_case\n")
+        f.write("mpc.version = '2';\n\n")
+
+        # Write baseMVA
+        f.write(f"%% system MVA base\nmpc.baseMVA = {mpc['baseMVA']};\n\n")
+
+        # Write bus data
+        f.write("%% bus data\n")
+        f.write("%% bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin\n")
+        f.write("mpc.bus = [\n")
+        for row in mpc['bus']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write generator data
+        f.write("%% generator data\n")
+        f.write("%% bus Pg Qg Qmax Qmin Vg mBase status Pmax Pmin\n")
+        f.write("%% Pc1 Pc2 Qc1min Qc1max Qc2min Qc2max ramp_agc ramp_10 ramp_30 ramp_q apf\n")
+        f.write("mpc.gen = [\n")
+        for row in mpc['gen']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write branch data
+        f.write("%% branch data\n")
+        f.write("%% fbus tbus r x b rateA rateB rateC ratio angle status angmin angmax PF QF PT QT\n")
+        f.write("mpc.branch = [\n")
+        for row in mpc['branch']:
+            f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+        f.write("];\n\n")
+
+        # Write generator cost data if available
+        if 'gencost' in mpc:
+            f.write("%% generator cost data\n")
+            f.write("%% 1 startup shutdown n x1 y1 ... xn yn\n")
+            f.write("%% 2 startup shutdown n c(n-1) ... c0\n")
+            f.write("mpc.gencost = [\n")
+            for row in mpc['gencost']:
+                f.write("    " + "\t".join(f"{val:.6g}" for val in row) + ";\n")
+            f.write("];\n\n")
+
+        # Write bus names if available and not all None
+        if 'bus_name' in mpc and any(mpc['bus_name']):
+            f.write("%% bus names\n")
+            f.write("mpc.bus_name = {\n")
+            for name in mpc['bus_name']:
+                f.write(f"    '{name}';\n")
+            f.write("};\n\n")
+
+        # Write generator types if available and not all None
+        if 'gentype' in mpc and any(mpc['gentype']):
+            f.write("%% generator types\n")
+            f.write("mpc.gentype = {\n")
+            for gentype in mpc['gentype']:
+                f.write(f"    '{gentype}';\n")
+            f.write("};\n\n")
+
+        # Write generator fuels if available and not all None
+        if 'genfuel' in mpc and any(mpc['genfuel']):
+            f.write("%% generator fuels\n")
+            f.write("mpc.genfuel = {\n")
+            for genfuel in mpc['genfuel']:
+                f.write(f"    '{genfuel}';\n")
+            f.write("};\n\n")
+
+    logger.info(f"Finished writing MATPOWER case to {outfile}")
+    return outfile
+
+
+def write(system, outfile: str, overwrite: bool = None) -> bool:
+    """
+    Export an AMS system to a MATPOWER mpc file.
+
+    This function converts an AMS system object into a MATPOWER-compatible
+    mpc dictionary and writes it to a specified output file in MATPOWER format.
+
+    Parameters
+    ----------
+    system : ams.system.System
+        A loaded system.
+    outfile : str
+        Path to the output file.
+    overwrite : bool, optional
+        None to prompt for overwrite selection; True to overwrite; False to not overwrite.
+
+    Returns
+    -------
+    bool
+        True if the file was successfully written, False otherwise.
+    """
+    if not confirm_overwrite(outfile, overwrite=overwrite):
+        return False
+
+    mpc = system2mpc(system)
+    mpc2m(mpc, outfile)
+    logger.info('MATPOWER m case file written to "%s"', outfile)
+    return True

ams/io/psse.py

@@ -1,5 +1,5 @@
 """
-Excel reader and writer for AMS.
+PSS/E .raw reader for AMS.
 This module is the existing module in ``andes.io.psse``.
 """
 

ams/io/pypower.py

@@ -101,3 +101,17 @@ def system2ppc(system) -> dict:
     mpc['branch'][:, 0] = np.array([bus_map[busi0] for busi0 in mpc['branch'][:, 0].astype(int)])
     mpc['branch'][:, 1] = np.array([bus_map[busi0] for busi0 in mpc['branch'][:, 1].astype(int)])
     return mpc
+
+
+def ppc2py(ppc: dict, outfile: str) -> str:
+    """
+    Placeholder.
+    """
+    return NotImplemented
+
+
+def write(system, outfile: str) -> bool:
+    """
+    Placeholder.
+    """
+    return NotImplemented

ams/models/group.py

@@ -175,20 +175,22 @@ class Reserve(GroupBase):
 
 class StaticGen(GroupBase):
     """
-    Generator group.
+    Static Generator Group.
+
+    The generator types and fuel types are referenced from MATPOWER.
 
     Notes
     -----
-    For co-simulation with ANDES, check
-    `ANDES StaticGen <https://docs.andes.app/en/latest/groupdoc/StaticGen.html#staticgen>`_
-    for replacing static generators with dynamic generators.
+    For co-simulation with ANDES, refer to the `ANDES StaticGen Documentation
+    <https://docs.andes.app/en/latest/groupdoc/StaticGen.html#staticgen>`_ for
+    replacing static generators with dynamic generators.
     """
 
     def __init__(self):
         super().__init__()
         self.common_params.extend(('bus', 'Sn', 'Vn', 'p0', 'q0', 'ra', 'xs', 'subidx',
                                    'pmax', 'pmin', 'pg0', 'ctrl', 'R10', 'td1', 'td2',
-                                   'area', 'zone'))
+                                   'area', 'zone', 'gentype', 'genfuel'))
         self.common_vars.extend(('p', 'q'))
 
 

ams/models/line.py

@@ -1,7 +1,7 @@
 from andes.models.line.line import LineData
 from andes.models.line.jumper import JumperData
 from andes.core.param import NumParam
-from andes.shared import deg2rad, np, spmatrix
+from andes.shared import deg2rad
 
 from ams.core.model import Model
 
@@ -49,167 +49,6 @@ class Line(LineData, Model):
         self.a1a = None
         self.a2a = None
 
-    # NOTE: following code are minly copied from `andes.models.line.Line`
-    # and they are not fully verified
-    # potential issues:
-    # `build_Bp` contains 'fdxb', which is not included in the input parameters,
-    # and the results are the negative of `Bbus` from `makeBdc` in PYPOWER
-    # `build_Bpp` ignores the line resistance for all three methods
-    # `build_Bdc` results are the negative of `Bbus` from `makeBdc` in PYPOWER
-    # `build_y` results have inignorable differences at diagonal elements with `makeYbus` in PYPOWER
-
-    def build_y(self):
-        """
-        Build bus admittance matrix. Copied from ``andes.models.line.line.Line``.
-
-        Returns
-        -------
-        Y : spmatrix
-            Bus admittance matrix.
-        """
-
-        nb = self.system.Bus.n
-
-        y1 = self.u.v * (self.g1.v + self.b1.v * 1j)
-        y2 = self.u.v * (self.g2.v + self.b2.v * 1j)
-        y12 = self.u.v / (self.r.v + self.x.v * 1j)
-        m = self.tap.v * np.exp(1j * self.phi.v)
-        m2 = self.tap.v**2
-        mconj = np.conj(m)
-
-        # build self and mutual admittances into Y
-        Y = spmatrix((y12 + y1 / m2), self.a1a, self.a1a, (nb, nb), 'z')
-        Y -= spmatrix(y12 / mconj, self.a1a, self.a2a, (nb, nb), 'z')
-        Y -= spmatrix(y12 / m, self.a2a, self.a1a, (nb, nb), 'z')
-        Y += spmatrix(y12 + y2, self.a2a, self.a2a, (nb, nb), 'z')
-
-        return Y
-
-    def build_Bp(self, method='fdpf'):
-        """
-        Function for building B' matrix.
-
-        Parameters
-        ----------
-        method : str
-            Method for building B' matrix. Choose from 'fdpf', 'fdbx', 'dcpf'.
-
-        Returns
-        -------
-        Bp : spmatrix
-            B' matrix.
-        """
-        nb = self.system.Bus.n
-
-        if method not in ("fdpf", "fdbx", "dcpf"):
-            raise ValueError(f"Invalid method {method}; choose from 'fdpf', 'fdbx', 'dcpf'")
-
-        # Build B prime matrix -- FDPF
-        # `y1`` neglects line charging shunt, and g1 is usually 0 in HV lines
-        # `y2`` neglects line charging shunt, and g2 is usually 0 in HV lines
-        y1 = self.u.v * self.g1.v
-        y2 = self.u.v * self.g2.v
-
-        # `m` neglected tap ratio
-        m = np.exp(self.phi.v * 1j)
-        mconj = np.conj(m)
-        m2 = np.ones(self.n)
-
-        if method in ('fdxb', 'dcpf'):
-            # neglect line resistance in Bp in XB method
-            y12 = self.u.v / (self.x.v * 1j)
-        else:
-            y12 = self.u.v / (self.r.v + self.x.v * 1j)
-
-        Bdc = spmatrix((y12 + y1) / m2, self.a1a, self.a1a, (nb, nb), 'z')
-        Bdc -= spmatrix(y12 / mconj, self.a1a, self.a2a, (nb, nb), 'z')
-        Bdc -= spmatrix(y12 / m, self.a2a, self.a1a, (nb, nb), 'z')
-        Bdc += spmatrix(y12 + y2, self.a2a, self.a2a, (nb, nb), 'z')
-        Bdc = Bdc.imag()
-
-        for item in range(nb):
-            if abs(Bdc[item, item]) == 0:
-                Bdc[item, item] = 1e-6 + 0j
-
-        return Bdc
-
-    def build_Bpp(self, method='fdpf'):
-        """
-        Function for building B'' matrix.
-
-        Parameters
-        ----------
-        method : str
-            Method for building B'' matrix. Choose from 'fdpf', 'fdbx', 'dcpf'.
-
-        Returns
-        -------
-        Bpp : spmatrix
-            B'' matrix.
-        """
-
-        nb = self.system.Bus.n
-
-        if method not in ("fdpf", "fdbx", "dcpf"):
-            raise ValueError(f"Invalid method {method}; choose from 'fdpf', 'fdbx', 'dcpf'")
-
-        # Build B double prime matrix
-        # y1 neglected line charging shunt, and g1 is usually 0 in HV lines
-        # y2 neglected line charging shunt, and g2 is usually 0 in HV lines
-        # m neglected phase shifter
-        y1 = self.u.v * (self.g1.v + self.b1.v * 1j)
-        y2 = self.u.v * (self.g2.v + self.b2.v * 1j)
-
-        m = self.tap.v
-        m2 = abs(m)**2
-
-        if method in ('fdbx', 'fdpf', 'dcpf'):
-            # neglect line resistance in Bpp in BX method
-            y12 = self.u.v / (self.x.v * 1j)
-        else:
-            y12 = self.u.v / (self.r.v + self.x.v * 1j)
-
-        Bpp = spmatrix((y12 + y1) / m2, self.a1a, self.a1a, (nb, nb), 'z')
-        Bpp -= spmatrix(y12 / np.conj(m), self.a1a, self.a2a, (nb, nb), 'z')
-        Bpp -= spmatrix(y12 / m, self.a2a, self.a1a, (nb, nb), 'z')
-        Bpp += spmatrix(y12 + y2, self.a2a, self.a2a, (nb, nb), 'z')
-        Bpp = Bpp.imag()
-
-        for item in range(nb):
-            if abs(Bpp[item, item]) == 0:
-                Bpp[item, item] = 1e-6 + 0j
-
-        return Bpp
-
-    def build_Bdc(self):
-        """
-        The MATPOWER-flavor Bdc matrix for DC power flow.
-
-        The method neglects line charging and line resistance. It retains tap ratio.
-
-        Returns
-        -------
-        Bdc : spmatrix
-            Bdc matrix.
-        """
-
-        nb = self.system.Bus.n
-
-        y12 = self.u.v / (self.x.v * 1j)
-        y12 = y12 / self.tap.v
-
-        Bdc = spmatrix(y12, self.a1a, self.a1a, (nb, nb), 'z')
-        Bdc -= spmatrix(y12, self.a1a, self.a2a, (nb, nb), 'z')
-        Bdc -= spmatrix(y12, self.a2a, self.a1a, (nb, nb), 'z')
-        Bdc += spmatrix(y12, self.a2a, self.a2a, (nb, nb), 'z')
-        Bdc = Bdc.imag()
-
-        for item in range(nb):
-            if abs(Bdc[item, item]) == 0:
-                Bdc[item, item] = 1e-6
-
-        return Bdc
-
 
 class Jumper(JumperData, Model):
     """