docs: def fdpf(self):
          """
          Fast Decoupled Power Flow
  
          Returns
          -------
          bool, int
              Success flag, number of iterations
          """
          system = self.system
  
          # general settings
          self.niter = 1
          iter_max = self.config.maxit
          self.solved = True
          tol = self.config.tol
          error = tol + 1
  
          self.iter_mis = []
          if (not system.Line.Bp) or (not system.Line.Bpp):
              system.Line.build_b()
  
          # initialize indexing and Jacobian
          # ngen = system.SW.n + system.PV.n
          sw = system.SW.a
          sw.sort(reverse=True)
          no_sw = system.Bus.a[:]
          no_swv = system.Bus.v[:]
          for item in sw:
              no_sw.pop(item)
              no_swv.pop(item)
          gen = system.SW.a + system.PV.a
          gen.sort(reverse=True)
          no_g = system.Bus.a[:]
          no_gv = system.Bus.v[:]
          for item in gen:
              no_g.pop(item)
              no_gv.pop(item)
          Bp = system.Line.Bp[no_sw, no_sw]
          Bpp = system.Line.Bpp[no_g, no_g]
  
          Fp = self.solver.symbolic(Bp)
          Fpp = self.solver.symbolic(Bpp)
          Np = self.solver.numeric(Bp, Fp)
          Npp = self.solver.numeric(Bpp, Fpp)
          exec(system.call.fdpf)
  
          # main loop
          while error > tol:
              # P-theta
              da = matrix(div(system.dae.g[no_sw], system.dae.y[no_swv]))
              self.solver.solve(Bp, Fp, Np, da)
              system.dae.y[no_sw] += da
  
              exec(system.call.fdpf)
              normP = max(abs(system.dae.g[no_sw]))
  
              # Q-V
              dV = matrix(div(system.dae.g[no_gv], system.dae.y[no_gv]))
              self.solver.solve(Bpp, Fpp, Npp, dV)
              system.dae.y[no_gv] += dV
  
              exec(system.call.fdpf)
              normQ = max(abs(system.dae.g[no_gv]))
  
              err = max([normP, normQ])
              self.iter_mis.append(err)
              error = err
  
              self._iter_info(self.niter)
              self.niter += 1
  
              if self.niter > 4 and self.iter_mis[-1] > 1000 * self.iter_mis[0]:
                  logger.warning('Blown up in {0} iterations.'.format(self.niter))
                  self.solved = False
                  break
  
              if self.niter > iter_max:
                  logger.warning('Reached maximum number of iterations.')
                  self.solved = False
                  break
  
          return self.solved, self.niter