docs: def generate(self, mA=1, age=9.6, feh=0.0, n=1e5, ichrone='mist',
                   orbpop=None, bands=None, **kwargs):
          """
          Generates population.
  
          Called if :class:`MultipleStarPopulation` is initialized without
          providing ``stars``, and if ``mA`` is provided.
  
          """
          ichrone = get_ichrone(ichrone, bands=bands)
  
          n = int(n)
          #star with m1 orbits (m2+m3).  So mA (most massive)
          # will correspond to either m1 or m2.
          m1, m2, m3 = self.multmass_fn(mA, f_binary=self.f_binary,
                                        f_triple=self.f_triple,
                                        qmin=self.qmin, minmass=self.minmass,
                                        n=n)
          #reset n if need be
          n = len(m1)
  
          feh = np.ascontiguousarray(np.atleast_1d(feh))
          age = np.ascontiguousarray(age)
  
          #generate stellar properties
          primary = ichrone(np.ascontiguousarray(m1), age, feh,
                            bands=bands)
          secondary = ichrone(np.ascontiguousarray(m2),age,feh,
                              bands=bands)
          tertiary = ichrone(np.ascontiguousarray(m3),age,feh,
                             bands=bands)
  
          #clean up columns that become nan when called with mass=0
          # Remember, we want mass=0 and mags=inf when something doesn't exist
          no_secondary = (m2==0)
          no_tertiary = (m3==0)
          for c in secondary.columns: #
              if re.search('_mag',c):
                  secondary[c][no_secondary] = np.inf
                  tertiary[c][no_tertiary] = np.inf
          secondary['mass'][no_secondary] = 0
          tertiary['mass'][no_tertiary] = 0
  
          if kwargs['period_short'] is None:
              if kwargs['period_long'] is None:
                  period_1 = self.period_long_fn(n)
                  period_2 = self.period_short_fn(n)
                  kwargs['period_short'] = np.minimum(period_1, period_2)
                  kwargs['period_long'] = np.maximum(period_1, period_2)
              else:
                  kwargs['period_short'] = self.period_short_fn(n)
  
                  #correct any short periods that are longer than period_long
                  bad = kwargs['period_short'] > kwargs['period_long']
                  n_bad = bad.sum()
                  good_inds = np.where(~bad)[0]
                  inds = np.random.randint(len(good_inds),size=n_bad)
                  kwargs['period_short'][bad] = \
                      kwargs['period_short'][good_inds[inds]]
          else:
              if kwargs['period_long'] is None:
                  kwargs['period_long'] = self.period_long_fn(n)
  
                  #correct any long periods that are shorter than period_short
                  bad = kwargs['period_long'] < kwargs['period_short']
                  n_bad = bad.sum()
                  good_inds = np.where(~bad)[0]
                  inds = np.random.randint(len(good_inds),size=n_bad)
                  kwargs['period_long'][bad] = \
                      kwargs['period_long'][good_inds[inds]]
  
          if 'ecc_short' not in kwargs:
              kwargs['ecc_short'] = self.ecc_fn(n, kwargs['period_short'])
          if 'ecc_long' not in kwargs:
              kwargs['ecc_long'] = self.ecc_fn(n, kwargs['period_long'])
  
          TriplePopulation.__init__(self, primary=primary,
                                    secondary=secondary, tertiary=tertiary,
                                    orbpop=orbpop, **kwargs)
  
          return self