Run SA with provided QUBO. 
		Set qubo attribute in advance of calling this method.
165390
def run(self,shots=1,targetT=0.02,verbose=False):
		
		if self.qubo != []:
			self.qi()
		J = self.reJ()
		N = len(J)

		itetemp = 100
		Rtemp = 0.75

		self.E = []
		qq = []
		for i in range(shots):
			T = self.Ts
			q = np.random.choice([-1,1],N)
			EE = []
			EE.append(Ei(q,self.J)+self.ep)
			while T>targetT:
				x_list = np.random.randint(0, N, itetemp)
				for x in x_list:
					q2 = np.ones(N)*q[x]
					q2[x] = 1
					dE = -2*sum(q*q2*J[:,x])

					if dE < 0 or np.exp(-dE/T) > np.random.random_sample():
						q[x] *= -1
				EE.append(Ei(q,self.J)+self.ep)
				T *= Rtemp
			self.E.append(EE)
			qtemp = (np.asarray(q,int)+1)/2
			qq.append([int(s) for s in qtemp])
			if verbose == True:
				print(i,':',[int(s) for s in qtemp])
			if shots == 1:
				qq = qq[0]
		if shots == 1:
			self.E = self.E[0]
		return qq
975563
def run(self, gates, n_qubits, *args, **kwargs):
        """"""
        return self._run(gates, n_qubits, args, kwargs)
488323
def before(self, context):
        ""
        run.before_each.execute(context)
        self._invoke(self._before, context)
1237596
def run(configobj=None):
    
    acsrej(configobj['input'],
           configobj['output'],
           exec_path=configobj['exec_path'],
           time_stamps=configobj['time_stamps'],
           verbose=configobj['verbose'],
           shadcorr=configobj['shadcorr'],
           crrejtab=configobj['crrejtab'],
           crmask=configobj['crmask'],
           scalense=configobj['scalense'],
           initgues=configobj['initgues'],
           skysub=configobj['skysub'],
           crsigmas=configobj['crsigmas'],
           crradius=configobj['crradius'],
           crthresh=configobj['crthresh'],
           badinpdq=configobj['badinpdq'],
           readnoise_only=configobj['readnoise_only'])
569669
def SetAlpha(self, alpha):
        '''
        
        '''
        self._AlphaChannel = alpha
        if self._AlphaChannel is not None:
            self.QT_QMainWindow.setWindowOpacity(self._AlphaChannel)
1065633
def prepare_model(self, sess, allow_initialize=True):
    """"""
    if self._follower:
      self.wait_for_initialization()
    else:
      self._init_model(sess, allow_initialize)

    if sess is not self._sess:
      if self.threads:
        raise ValueError('You must call stop_queues() before '
                         'starting a new session with QueueRunners.')
      self._sess = sess
    self._start_threads(sess)
1374890
def run(self, *args, **kw):
        
        if self._runFunc is not None:
            # remove the two args sent by EditParDialog which we do not use
            if 'mode' in kw: kw.pop('mode')
            if '_save' in kw: kw.pop('_save')
            return self._runFunc(self, *args, **kw)
        else:
            raise taskpars.NoExecError('No way to run task "'+self.__taskName+\
                '". You must either override the "run" method in your '+ \
                'ConfigObjPars subclass, or you must supply a "run" '+ \
                'function in your package.')
1232366
def before_run(self):
        """"""
        # Actions and checks counters
        self.nb_checks = 0
        self.nb_internal_checks = 0
        self.nb_checks_launched = 0
        self.nb_actions_launched = 0

        self.nb_checks_results = 0
        self.nb_checks_results_timeout = 0
        self.nb_checks_results_passive = 0
        self.nb_checks_results_active = 0

        self.nb_actions_results = 0
        self.nb_actions_results_timeout = 0
        self.nb_actions_results_passive = 0

        self.nb_broks_dropped = 0
        self.nb_checks_dropped = 0
        self.nb_actions_dropped = 0

        # Broks, notifications, ... counters
        self.nb_broks = 0
        self.nb_notifications = 0
        self.nb_event_handlers = 0
        self.nb_external_commands = 0

        self.ticks = 0
659694
def run(self):
        
        if not (self.table):
            raise Exception("table need to be specified")

        path = self.s3_load_path()
        output = self.output()
        connection = output.connect()
        cursor = connection.cursor()

        self.init_copy(connection)
        self.copy(cursor, path)
        self.post_copy(cursor)

        if self.enable_metadata_columns:
            self.post_copy_metacolumns(cursor)

        # update marker table
        output.touch(connection)
        connection.commit()

        # commit and clean up
        connection.close()
490340
@Override
    public void run() {
        JCASecurityContext ctx = bootstrapContext.getJCASecurityContext();
        if (ctx != null)
            ctx.runInInboundSecurityContext(work);
        else
            work.run();
    }
349583
def run_to_abs_pos(self, **kwargs):
        
        for key in kwargs:
            setattr(self, key, kwargs[key])
        self.command = self.COMMAND_RUN_TO_ABS_POS
265214
def run(self, context):
        
        try:
            self._load_state(context)
            spec = self.module_router.endpoint_routing(context)
            resp = self._run_bound_endpoint(context, spec)
            self._save_state(resp, context)
        except SATOSANoBoundEndpointError:
            raise
        except SATOSAError:
            satosa_logging(logger, logging.ERROR, "Uncaught SATOSA error ", context.state,
                           exc_info=True)
            raise
        except UnknownSystemEntity as err:
            satosa_logging(logger, logging.ERROR,
                           "configuration error: unknown system entity " + str(err),
                           context.state, exc_info=False)
            raise
        except Exception as err:
            satosa_logging(logger, logging.ERROR, "Uncaught exception", context.state,
                           exc_info=True)
            raise SATOSAUnknownError("Unknown error") from err
        return resp
738602
public void run() {
    int maxruns = this.maxruns, maxsmall = this.maxsmall;
    double oldchi = getChiSq();
    while(maxruns-- > 0) {
      iterate();
      double newchi = getChiSq(), deltachi = newchi - oldchi;
      oldchi = newchi;
      // stop condition: only a small improvement in Chi.
      if(deltachi < 0 && deltachi > -small && --maxsmall < 0) {
        break;
      }
    }
  }
175104
def run_evaluate(self) -> None:
        
        result = None
        self.eval_error = False
        if self._needs_evaluation:
            result = self._schema.value.evaluate(self._evaluation_context)

        self.eval_error = result is None
        if self.eval_error:
            return

        # Only set the value if it conforms to the field type
        if not self._schema.is_type_of(result):
            try:
                result = self._schema.type_object(result)
            except Exception as err:
                logging.debug('{} in casting {} to {} for field {}. Error: {}'.format(
                    type(err).__name__, result, self._schema.type,
                    self._schema.fully_qualified_name, err))
                self.eval_error = True
                return

        try:
            result = self._schema.sanitize_object(result)
        except Exception as err:
            logging.debug('{} in sanitizing {} of type {} for field {}. Error: {}'.format(
                type(err).__name__, result, self._schema.type, self._schema.fully_qualified_name,
                err))
            self.eval_error = True
            return

        self.value = result
1113703
@Override
	public void run() {
		try {
			this.associationListener.onPayload(this.association, this.payloadData);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
1270315
public void run(String[] args) throws Exception {
    ServerConfiguration.Builder configBuilder = ServerConfiguration.newBuilder();
    ServerConfiguration config;
    try {
      config = configBuilder.build(args);
    } catch (Exception e) {
      System.out.println(e.getMessage());
      configBuilder.printUsage();
      return;
    }

    final Server server = newServer(config);
    server.start();

    System.out.println("QPS Server started on " + config.address);

    Runtime.getRuntime().addShutdownHook(new Thread() {
      @Override
      @SuppressWarnings("CatchAndPrintStackTrace")
      public void run() {
        try {
          System.out.println("QPS Server shutting down");
          server.shutdown();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    });
    server.awaitTermination();
  }
1172121
public void run() {
		// need <bean id="..." class="org.esupportail.commons.context.ApplicationContextHolder" />
		ApplicationContext applicationContext = ApplicationContextHolder.getContext();

		SessionFactory sessionFactory = HibernateUtils.getSessionFactory(applicationContext);
		boolean participate = HibernateUtils.openSession(sessionFactory);

		try {
			if (logger.isDebugEnabled()) {
				logger.debug("Starting new Thread to manage ack with : " + 
					     " - smid : " + acknowledgment.getSmsId() + 
					     " - ack status : " + acknowledgment.getSmsStatus());
			}

			// Send the ack to the business layer 
			final AckManagerBusiness ackManagerBusiness = (AckManagerBusiness) applicationContext.getBean(ACK_BUSINESS_MGR_BEAN_NAME);
			ackManagerBusiness.manageAck(acknowledgment);

		// error case, rollback
		} catch (RuntimeException e) {
			logger.error("Catching exception in AckManagerThread, now rollback : ", e);
			throw e;
		// close the session every time	
		} finally {
		    HibernateUtils.closeSession(sessionFactory, participate);
		}
	 }