docs: def run(self):
          """Run robustness command."""
  
          reaction = self._get_objective()
          if not self._mm.has_reaction(reaction):
              self.fail('Specified biomass reaction is not in model: {}'.format(
                  reaction))
  
          varying_reaction = self._args.varying
          if not self._mm.has_reaction(varying_reaction):
              self.fail('Specified varying reaction is not in model: {}'.format(
                  varying_reaction))
  
          steps = self._args.steps
          if steps <= 0:
              self.argument_error('Invalid number of steps: {}\n'.format(steps))
  
          loop_removal = self._get_loop_removal_option()
          if loop_removal == 'tfba':
              solver = self._get_solver(integer=True)
          else:
              solver = self._get_solver()
  
          p = fluxanalysis.FluxBalanceProblem(self._mm, solver)
          if loop_removal == 'tfba':
              p.add_thermodynamic()
  
          try:
              p.check_constraints()
          except fluxanalysis.FluxBalanceError as e:
              self.report_flux_balance_error(e)
  
          # Determine minimum and maximum flux for varying reaction
          if self._args.maximum is None:
              p.maximize(varying_reaction)
              flux_max = p.get_flux(varying_reaction)
          else:
              flux_max = self._args.maximum
  
          if self._args.minimum is None:
              p.maximize({varying_reaction: -1})
              flux_min = p.get_flux(varying_reaction)
          else:
              flux_min = self._args.minimum
  
          if flux_min > flux_max:
              self.argument_error('Invalid flux range: {}, {}\n'.format(
                  flux_min, flux_max))
  
          logger.info('Varying {} in {} steps between {} and {}'.format(
              varying_reaction, steps, flux_min, flux_max))
  
          start_time = time.time()
  
          handler_args = (
              self._mm, solver, loop_removal, self._args.all_reaction_fluxes)
          executor = self._create_executor(
              RobustnessTaskHandler, handler_args, cpus_per_worker=2)
  
          def iter_tasks():
              for i in range(steps):
                  fixed_flux = flux_min + i*(flux_max - flux_min)/float(steps-1)
                  constraint = varying_reaction, fixed_flux
                  yield constraint, reaction
  
          # Run FBA on model at different fixed flux values
          with executor:
              for task, result in executor.imap_unordered(iter_tasks(), 16):
                  (varying_reaction, fixed_flux), _ = task
                  if result is None:
                      logger.warning('No solution found for {} at {}'.format(
                          varying_reaction, fixed_flux))
                  elif self._args.all_reaction_fluxes:
                      for other_reaction in self._mm.reactions:
                          print('{}\t{}\t{}'.format(
                              other_reaction, fixed_flux,
                              result[other_reaction]))
                  else:
                      print('{}\t{}'.format(fixed_flux, result))
  
          executor.join()
  
          logger.info('Solving took {:.2f} seconds'.format(
              time.time() - start_time))