code: def iter_thickness(self, depth_total):
          
          total = 0
          depth_prev = 0
  
          while depth_prev < depth_total:
              # Add a random exponential increment
              total += np.random.exponential(1.0)
  
              # Convert between x and depth using the inverse of \Lambda(t)
              depth = np.power(
                  (self.c_2 * total) / self.c_3 + total / self.c_3 + np.power(
                      self.c_1, self.c_2 + 1), 1 / (self.c_2 + 1)) - self.c_1
  
              thickness = depth - depth_prev
  
              if depth > depth_total:
                  thickness = (depth_total - depth_prev)
                  depth = depth_prev + thickness
  
              depth_mid = (depth_prev + depth) / 2
              yield thickness, depth_mid
  
              depth_prev = depth
docs: Iterate over the varied thicknesses.
  
          The layering is generated using a non-homogenous Poisson process. The
          following routine is used to generate the layering. The rate
          function, :math:`\lambda(t)`, is integrated from 0 to t to generate
          cumulative rate function, :math:`\Lambda(t)`. This function is then
          inverted producing :math:`\Lambda^{-1}(t)`. Random variables
          are produced using the a exponential random variation with
          :math:`\mu = 1` and converted to the nonhomogenous variables using
          the inverted function.
  
          Parameters
          ----------
          depth_total: float
              Total depth generated. Last thickness is truncated to achieve
              this depth.
  
          Yields
          ------
          float
              Varied thickness.