docs: def _implicit_solver(self):
          """Invertes and solves the matrix problem for diffusion matrix
          and temperature T.
  
          The method is called by the
          :func:`~climlab.process.implicit.ImplicitProcess._compute()` function
          of the :class:`~climlab.process.implicit.ImplicitProcess` class and
          solves the matrix problem
  
          .. math::
  
              A \\cdot T_{\\textrm{new}} = T_{\\textrm{old}}
  
          for diffusion matrix A and corresponding temperatures.
          :math:`T_{\\textrm{old}}` is in this case the current state variable
          which already has been adjusted by the explicit processes.
          :math:`T_{\\textrm{new}}` is the new state of the variable. To
          derive the temperature tendency of the diffusion process the adjustment
          has to be calculated and muliplied with the timestep which is done by
          the :func:`~climlab.process.implicit.ImplicitProcess._compute()`
          function of the :class:`~climlab.process.implicit.ImplicitProcess`
          class.
  
          This method calculates the matrix inversion for every state variable
          and calling either :func:`solve_implicit_banded()` or
          :py:func:`numpy.linalg.solve()` dependent on the flag
          ``self.use_banded_solver``.
  
          :ivar dict state:               method uses current state variables
                                          but does not modify them
          :ivar bool use_banded_solver:   input flag whether to use
                                          :func:`_solve_implicit_banded()` or
                                          :py:func:`numpy.linalg.solve()` to do
                                          the matrix inversion
          :ivar array _diffTriDiag:        the diffusion matrix which is given
                                          with the current state variable to
                                          the method solving the matrix problem
  
          """
          #if self.update_diffusivity:
  
          # Time-stepping the diffusion is just inverting this matrix problem:
          newstate = {}
          for varname, value in self.state.items():
              if self.use_banded_solver:
                  newvar = _solve_implicit_banded(value, self._diffTriDiag)
              else:
                  newvar = np.linalg.solve(self._diffTriDiag, value)
              newstate[varname] = newvar
          return newstate