docs: def bend_rounded(Di, angle, fd=None, rc=None, bend_diameters=5.0,
                   Re=None, roughness=0.0, L_unimpeded=None, method='Rennels'):
      r'''Returns loss coefficient for rounded bend in a pipe of diameter `Di`,
      `angle`, with a specified either radius of curvature `rc` or curvature 
      defined by `bend_diameters`, Reynolds number `Re` and optionally pipe
      roughness, unimpeded length downstrean, and with the specified method.
      This calculation has five methods available.
      
      It is hard to describe one method as more conservative than another as
      depending on the conditions, the relative results change significantly.
      
      The 'Miller' method is the most complicated and slowest method; the 'Ito'
      method comprehensive as well and a source of original data, and the primary
      basis for the 'Rennels' method. The 'Swamee' method is very simple and
      generally does not match the other methods. The 'Crane' method may match 
      or not match other methods depending on the inputs.
      
      The Rennels [1]_ formula is:
      
      .. math::
          K = f\alpha\frac{r}{d} + (0.10 + 2.4f)\sin(\alpha/2)
          + \frac{6.6f(\sqrt{\sin(\alpha/2)}+\sin(\alpha/2))}
          {(r/d)^{\frac{4\alpha}{\pi}}}
  
      The Swamee [5]_ formula is:
          
      .. math::
          K = \left[0.0733 + 0.923 \left(\frac{d}{rc}\right)^{3.5} \right]
          \theta^{0.5}
          
      .. figure:: fittings/bend_rounded.png
         :scale: 30 %
         :alt: rounded bend; after [1]_
  
      Parameters
      ----------
      Di : float
          Inside diameter of pipe, [m]
      angle : float
          Angle of bend, [degrees]
      fd : float, optional
          Darcy friction factor; used only in Rennels method; calculated if not
          provided from Reynolds number, diameter, and roughness [-]
      rc : float, optional
          Radius of curvature of the entrance, optional [m]
      bend_diameters : float, optional (used if rc not provided)
          Number of diameters of pipe making up the bend radius [-]
      Re : float, optional
          Reynolds number of the pipe (used in Miller, Ito methods primarily, and
          Rennels method if no friction factor given), [m]
      roughness : float, optional
          Roughness of bend wall (used in Miller, Ito methods primarily, and
          Rennels method if no friction factor given), [m]   
      L_unimpeded : float, optional
          The length of unimpeded pipe without any fittings, instrumentation,
          or flow disturbances downstream (assumed 20 diameters if not 
          specified); used only in Miller method, [m]
      method : str, optional
          One of 'Rennels', 'Miller', 'Crane', 'Ito', or 'Swamee', [-]
  
      Returns
      -------
      K : float
          Loss coefficient [-]
  
      Notes
      -----
      When inputting bend diameters, note that manufacturers often specify
      this as a multiplier of nominal diameter, which is different than actual
      diameter. Those require that rc be specified.
      
      In the 'Rennels' method, `rc` is limited to 0.5 or above; which represents 
      a sharp, square, inner edge - and an outer bend radius of 1.0. Losses are 
      at a minimum when this value is large. Its first term represents surface 
      friction loss; the second, secondary flows; and the third, flow separation.
      It encompasses the entire range of elbow and pipe bend configurations.
      It was developed for bend angles between 0 and 180 degrees; and r/D
      ratios above 0.5. Only smooth pipe data was used in its development.
      Note the loss coefficient includes the surface friction of the pipe as if
      it was straight.
     
      Examples
      --------
      >>> bend_rounded(Di=4.020, rc=4.0*5, angle=30, Re=1E5)
      0.11519070808085191
  
      References
      ----------
      .. [1] Rennels, Donald C., and Hobart M. Hudson. Pipe Flow: A Practical
         and Comprehensive Guide. 1st edition. Hoboken, N.J: Wiley, 2012.
      .. [2] Miller, Donald S. Internal Flow Systems: Design and Performance
         Prediction. Gulf Publishing Company, 1990.
      .. [3] Crane Co. Flow of Fluids Through Valves, Fittings, and Pipe. Crane,
         2009.
      .. [4] Swamee, Prabhata K., and Ashok K. Sharma. Design of Water Supply 
         Pipe Networks. John Wiley & Sons, 2008.
      .. [5] Itō, H."Pressure Losses in Smooth Pipe Bends." Journal of Fluids 
         Engineering 82, no. 1 (March 1, 1960): 131-40. doi:10.1115/1.3662501
      .. [6] Blevins, Robert D. Applied Fluid Dynamics Handbook. New York, N.Y.: 
         Van Nostrand Reinhold Co., 1984.
      '''
      if method is None:
          method = 'Rennels'
      if rc is None:
          rc = Di*bend_diameters
      if method == 'Rennels':
          angle = radians(angle)
          if fd is None:
              if Re is None:
                  raise ValueError("The `Rennels` method requires either a "
                                   "specified friction factor or `Re`")
              fd = Colebrook(Re=Re, eD=roughness/Di, tol=-1)
          sin_term = sin(0.5*angle)
          return (fd*angle*rc/Di + (0.10 + 2.4*fd)*sin_term
          + 6.6*fd*(sin_term**0.5 + sin_term)/(rc/Di)**(4.*angle/pi))
      elif method == 'Miller':
          if Re is None:
              raise ValueError('Miller method requires Reynolds number')
          return bend_rounded_Miller(Di=Di, angle=angle, Re=Re, rc=rc, 
                                     bend_diameters=bend_diameters, 
                                     roughness=roughness, 
                                     L_unimpeded=L_unimpeded)
      elif method == 'Crane':
          return bend_rounded_Crane(Di=Di, angle=angle, rc=rc, 
                                    bend_diameters=bend_diameters)
      elif method == 'Ito':
          if Re is None:
              raise ValueError("The `Iso` method requires`Re`")
          return bend_rounded_Ito(Di=Di, angle=angle, Re=Re, rc=rc, bend_diameters=bend_diameters, 
                       roughness=roughness)
      elif method == 'Swamee':
          return (0.0733 + 0.923*(Di/rc)**3.5)*radians(angle)**0.5
      else:
          raise ValueError('Specified method not recognized; methods are %s'
                           %(bend_rounded_methods))