docs: def _process_input_seed(seed_photon_fields):
          """
          take input list of seed_photon_fields and fix them into usable format
          """
  
          Tcmb = 2.72548 * u.K  # 0.00057 K
          Tfir = 30 * u.K
          ufir = 0.5 * u.eV / u.cm ** 3
          Tnir = 3000 * u.K
          unir = 1.0 * u.eV / u.cm ** 3
  
          # Allow for seed_photon_fields definitions of the type 'CMB-NIR-FIR' or
          # 'CMB'
          if type(seed_photon_fields) != list:
              seed_photon_fields = seed_photon_fields.split("-")
  
          result = OrderedDict()
  
          for idx, inseed in enumerate(seed_photon_fields):
              seed = {}
              if isinstance(inseed, six.string_types):
                  name = inseed
                  seed["type"] = "thermal"
                  if inseed == "CMB":
                      seed["T"] = Tcmb
                      seed["u"] = ar * Tcmb ** 4
                      seed["isotropic"] = True
                  elif inseed == "FIR":
                      seed["T"] = Tfir
                      seed["u"] = ufir
                      seed["isotropic"] = True
                  elif inseed == "NIR":
                      seed["T"] = Tnir
                      seed["u"] = unir
                      seed["isotropic"] = True
                  else:
                      log.warning(
                          "Will not use seed {0} because it is not "
                          "CMB, FIR or NIR".format(inseed)
                      )
                      raise TypeError
              elif type(inseed) == list and (
                  len(inseed) == 3 or len(inseed) == 4
              ):
                  isotropic = len(inseed) == 3
  
                  if isotropic:
                      name, T, uu = inseed
                      seed["isotropic"] = True
                  else:
                      name, T, uu, theta = inseed
                      seed["isotropic"] = False
                      seed["theta"] = validate_scalar(
                          "{0}-theta".format(name), theta, physical_type="angle"
                      )
  
                  thermal = T.unit.physical_type == "temperature"
  
                  if thermal:
                      seed["type"] = "thermal"
                      validate_scalar(
                          "{0}-T".format(name),
                          T,
                          domain="positive",
                          physical_type="temperature",
                      )
                      seed["T"] = T
                      if uu == 0:
                          seed["u"] = ar * T ** 4
                      else:
                          # pressure has same physical type as energy density
                          validate_scalar(
                              "{0}-u".format(name),
                              uu,
                              domain="positive",
                              physical_type="pressure",
                          )
                          seed["u"] = uu
                  else:
                      seed["type"] = "array"
                      # Ensure everything is in arrays
                      T = u.Quantity((T,)).flatten()
                      uu = u.Quantity((uu,)).flatten()
  
                      seed["energy"] = validate_array(
                          "{0}-energy".format(name),
                          T,
                          domain="positive",
                          physical_type="energy",
                      )
  
                      if np.isscalar(seed["energy"]) or seed["energy"].size == 1:
                          seed["photon_density"] = validate_scalar(
                              "{0}-density".format(name),
                              uu,
                              domain="positive",
                              physical_type="pressure",
                          )
                      else:
                          if uu.unit.physical_type == "pressure":
                              uu /= seed["energy"] ** 2
                          seed["photon_density"] = validate_array(
                              "{0}-density".format(name),
                              uu,
                              domain="positive",
                              physical_type="differential number density",
                          )
              else:
                  raise TypeError(
                      "Unable to process seed photon"
                      " field: {0}".format(inseed)
                  )
  
              result[name] = seed
  
          return result