docs: def plot_line_loading_diff(networkA, networkB, timestep=0):
      """
      Plot difference in line loading between two networks
      (with and without switches) as color on lines
  
      Positive values mean that line loading with switches is bigger than without
      Plot switches as small dots
      
      Parameters
      ----------
      networkA : PyPSA network container
          Holds topology of grid with switches
          including results from powerflow analysis
      networkB : PyPSA network container
          Holds topology of grid without switches
          including results from powerflow analysis
      filename : str
          Specify filename
          If not given, figure will be show directly
      timestep : int
          timestep to show, default is 0
      """
  
      # new colormap to make sure 0% difference has the same color in every plot
      def shiftedColorMap(
              cmap,
              start=0,
              midpoint=0.5,
              stop=1.0,
              name='shiftedcmap'):
          '''
          Function to offset the "center" of a colormap. Useful for
          data with a negative min and positive max and you want the
          middle of the colormap's dynamic range to be at zero
  
          Input
          -----
            cmap : The matplotlib colormap to be altered
            start : Offset from lowest point in the colormap's range.
                Defaults to 0.0 (no lower ofset). Should be between
                0.0 and `midpoint`.
            midpoint : The new center of the colormap. Defaults to
                0.5 (no shift). Should be between 0.0 and 1.0. In
                general, this should be  1 - vmax/(vmax + abs(vmin))
                For example if your data range from -15.0 to +5.0 and
                you want the center of the colormap at 0.0, `midpoint`
                should be set to  1 - 5/(5 + 15)) or 0.75
            stop : Offset from highets point in the colormap's range.
                Defaults to 1.0 (no upper ofset). Should be between
                `midpoint` and 1.0.
          '''
          cdict = {
              'red': [],
              'green': [],
              'blue': [],
              'alpha': []
          }
  
          # regular index to compute the colors
          reg_index = np.linspace(start, stop, 257)
  
          # shifted index to match the data
          shift_index = np.hstack([
              np.linspace(0.0, midpoint, 128, endpoint=False),
              np.linspace(midpoint, 1.0, 129, endpoint=True)
          ])
  
          for ri, si in zip(reg_index, shift_index):
              r, g, b, a = cmap(ri)
  
              cdict['red'].append((si, r, r))
              cdict['green'].append((si, g, g))
              cdict['blue'].append((si, b, b))
              cdict['alpha'].append((si, a, a))
  
          newcmap = matplotlib.colors.LinearSegmentedColormap(name, cdict)
          plt.register_cmap(cmap=newcmap)
  
          return newcmap
  
      # calculate difference in loading between both networks
      loading_switches = abs(
          networkA.lines_t.p0.mul(networkA.snapshot_weightings, axis=0).\
          loc[networkA.snapshots[timestep]].to_frame())
      loading_switches.columns = ['switch']
      loading_noswitches = abs(
          networkB.lines_t.p0.mul(networkB.snapshot_weightings, axis=0).\
          loc[networkB.snapshots[timestep]].to_frame())
      loading_noswitches.columns = ['noswitch']
      diff_network = loading_switches.join(loading_noswitches)
      diff_network['noswitch'] = diff_network['noswitch'].fillna(
          diff_network['switch'])
      diff_network[networkA.snapshots[timestep]] \
          = diff_network['switch'] - diff_network['noswitch']
  
      # get switches
      new_buses = pd.Series(index=networkA.buses.index.values)
      new_buses.loc[set(networkA.buses.index.values) -
                    set(networkB.buses.index.values)] = 0.1
      new_buses = new_buses.fillna(0)
  
      # plot network with difference in loading and shifted colormap
      loading = (diff_network.loc[:, networkA.snapshots[timestep]] /
                 (networkA.lines.s_nom)) * 100
      midpoint = 1 - max(loading) / (max(loading) + abs(min(loading)))
      shifted_cmap = shiftedColorMap(
          plt.cm.jet, midpoint=midpoint, name='shifted')
      ll = networkA.plot(line_colors=loading, line_cmap=shifted_cmap,
                         title="Line loading", bus_sizes=new_buses,
                         bus_colors='blue', line_widths=0.55)
  
      cb = plt.colorbar(ll[1])
      cb.set_label('Difference in line loading in % of s_nom')