Reinitialise the stored displacements, number of hops, and list of sites visited for this `Atom`.

        Args:
            None

        Returns:
            None
357202
def reset( self ):
        
        self.number_of_hops = 0
        self.dr = np.array( [ 0.0, 0.0, 0.0 ] )
        self.summed_dr2 = 0.0
        self.sites_visited = [ self._site.number ]
216039
def reindex(self):
        
        for wh in self.whoosheers:
            index = type(self).get_or_create_index(_get_app(self), wh)
            writer = index.writer(timeout=_get_config(self)['writer_timeout'])
            for model in wh.models:
                method_name = "{0}_{1}".format(UPDATE_KWD, model.__name__.lower())
                for item in model.query.all():
                    getattr(wh, method_name)(writer, item)
            writer.commit()
1255458
def reassembly(self, info):
        
        BUFID = info.bufid  # Buffer Identifier
        DSN = info.dsn      # Data Sequence Number
        ACK = info.ack      # Acknowledgement Number
        FIN = info.fin      # Finish Flag (Termination)
        RST = info.rst      # Reset Connection Flag (Termination)
        SYN = info.syn      # Synchronise Flag (Establishment)

        # when SYN is set, reset buffer of this session
        if SYN and BUFID in self._buffer:
            self._dtgram += self.submit(self._buffer[BUFID], bufid=BUFID)
            del self._buffer[BUFID]

        # initialise buffer with BUFID & ACK
        if BUFID not in self._buffer:
            self._buffer[BUFID] = {
                'hdl': [Info(first=info.len, last=sys.maxsize)],
                ACK: dict(
                    ind=[info.num],
                    isn=info.dsn,
                    len=info.len,
                    raw=info.payload,
                ),
            }
        else:
            # initialise buffer with ACK
            if ACK not in self._buffer[BUFID]:
                self._buffer[BUFID][ACK] = dict(
                    ind=[info.num],
                    isn=info.dsn,
                    len=info.len,
                    raw=info.payload,
                )
            else:
                # append packet index
                self._buffer[BUFID][ACK]['ind'].append(info.num)

                # record fragment payload
                ISN = self._buffer[BUFID][ACK]['isn']   # Initial Sequence Number
                RAW = self._buffer[BUFID][ACK]['raw']   # Raw Payload Data
                if DSN >= ISN:  # if fragment goes after existing payload
                    LEN = self._buffer[BUFID][ACK]['len']
                    GAP = DSN - (ISN + LEN)     # gap length between payloads
                    if GAP >= 0:    # if fragment goes after existing payload
                        RAW += bytearray(GAP) + info.payload
                    else:           # if fragment partially overlaps existing payload
                        RAW[DSN-ISN:] = info.payload
                else:           # if fragment exceeds existing payload
                    LEN = info.len
                    GAP = ISN - (DSN + LEN)     # gap length between payloads
                    self._buffer[BUFID][ACK]['isn'] = DSN
                    if GAP >= 0:    # if fragment exceeds existing payload
                        RAW = info.payload + bytearray(GAP) + RAW
                    else:           # if fragment partially overlaps existing payload
                        RAW = info.payload + RAW[ISN-GAP:]
                self._buffer[BUFID][ACK]['raw'] = RAW       # update payload datagram
                self._buffer[BUFID][ACK]['len'] = len(RAW)  # update payload length

            # update hole descriptor list
            HDL = self._buffer[BUFID]['hdl']
            for (index, hole) in enumerate(HDL):                            # step one
                if info.first > hole.last:                                  # step two
                    continue
                if info.last < hole.first:                                  # step three
                    continue
                del HDL[index]                                              # step four
                if info.first > hole.first:                                 # step five
                    new_hole = Info(
                        first=hole.first,
                        last=info.first - 1,
                    )
                    HDL.insert(index, new_hole)
                    index += 1
                if info.last < hole.last and not FIN and not RST:           # step six
                    new_hole = Info(
                        first=info.last + 1,
                        last=hole.last
                    )
                    HDL.insert(index, new_hole)
                break                                                       # step seven
            self._buffer[BUFID]['hdl'] = HDL                                # update HDL

        # when FIN/RST is set, submit buffer of this session
        if FIN or RST:
            self._dtgram += self.submit(self._buffer[BUFID], bufid=BUFID)
            del self._buffer[BUFID]
1230482
def Reset(self):
    """"""
    # The first state
    self.state = "INITIAL"
    self.state_stack = []

    # The buffer we are parsing now
    self.buffer = ""
    self.error = 0
    self.verbose = 0

    # The index into the buffer where we are currently pointing
    self.processed = 0
    self.processed_buffer = ""
1043183
def refresh(self):
        
        self.setUpdatesEnabled(False)
        self.blockSignals(True)
        self.clear()
        tableType = self.tableType()
        if not tableType:
            self.setUpdatesEnabled(True)
            self.blockSignals(False)
            return
        
        schema = tableType.schema()
        columns = list(sorted(schema.columns(),
                              key=lambda x: x.name().strip('_')))
        for column in columns:
            XOrbColumnItem(self, column)
        
        self.setUpdatesEnabled(True)
        self.blockSignals(False)
73191
def _reset(self):
        

        self._filename = None
        self._block_map = {}
        self._ast = []
        self._ast.append(None)  # header
        self._ast.append([])    # options list
        self._ast.append([])
524664
def reset(self):
    
    self._poolingActivation = numpy.zeros((self._numColumns), dtype="int32")
    self._poolingColumns = []
    self._overlapDutyCycles = numpy.zeros(self._numColumns, dtype=realDType)
    self._activeDutyCycles = numpy.zeros(self._numColumns, dtype=realDType)
    self._minOverlapDutyCycles = numpy.zeros(self._numColumns,
                                             dtype=realDType)
    self._minActiveDutyCycles = numpy.zeros(self._numColumns,
                                            dtype=realDType)
    self._boostFactors = numpy.ones(self._numColumns, dtype=realDType)
305925
public void reinitialize ()
  {
    m_aRWLock.writeLocked (m_aCountries::clear);

    for (final Locale aLocale : LocaleCache.getInstance ().getAllLocales ())
    {
      final String sCountry = aLocale.getCountry ();
      if (StringHelper.hasText (sCountry))
        addCountry (sCountry);
    }

    if (LOGGER.isDebugEnabled ())
      LOGGER.debug ("Reinitialized " + CountryCache.class.getName ());
  }
1048677
def reindex(self):
        ''''''
        for i in range(self.count()):
            w = self.points[i]
            w.idx = i
            w.count = self.count()
            w.target_system = self.target_system
            w.target_component = self.target_component
        self.last_change = time.time()
124995
def revisit(self, node, include_self=True):
        

        successors = self.successors(node) #, skip_reached_fixedpoint=True)

        if include_self:
            self._sorted_nodes.add(node)

        for succ in successors:
            self._sorted_nodes.add(succ)

        # reorder it
        self._sorted_nodes = OrderedSet(sorted(self._sorted_nodes, key=lambda n: self._node_to_index[n]))
888614
def reload(self):
        ''
        self.rows = []

#        if len(self.origCols) == 1 and self.origCols[0].type in (int, float, currency):
#            self.numericBinning()
#        else:
        self.discreteBinning()

        # automatically add cache to all columns now that everything is binned
        for c in self.nonKeyVisibleCols:
            c._cachedValues = collections.OrderedDict()
429979
public void reinitialize ()
  {
    m_aRWLock.writeLocked ( () -> {
      m_aProtocols.clear ();

      // Add all default protocols
      for (final EURLProtocol aProtocol : EURLProtocol.values ())
        m_aProtocols.put (aProtocol.getProtocol (), aProtocol);
    });

    // Load all SPI implementations
    for (final IURLProtocolRegistrarSPI aRegistrar : ServiceLoaderHelper.getAllSPIImplementations (IURLProtocolRegistrarSPI.class))
    {
      final ICommonsSet <? extends IURLProtocol> aURLProtocols = aRegistrar.getAllProtocols ();
      if (aURLProtocols != null)
        for (final IURLProtocol aSPIProtocol : aURLProtocols)
          registerProtocol (aSPIProtocol);
    }

    if (LOGGER.isDebugEnabled ())
      LOGGER.debug (getRegisteredProtocolCount () + " URL protocols registered");
  }
1232097
def _reindex(self):
        
        self.index = []
        for path in self.paths:
            target_path = os.path.normpath(os.path.join(BASE_PATH,
                                                        path))
            for root, subdirs, files in os.walk(target_path):
                for f in files:
                    self.index.append(
                        (os.path.join(root, f).lower(),
                         os.path.join(root, f)))
930770
async def _refresh_table(self):
        
        results = []
        for node_id in self.protocol.get_refresh_ids():
            node = Node(node_id)
            nearest = self.protocol.router.find_neighbors(node, self.alpha)
            spider = NodeSpiderCrawl(self.protocol, node, nearest,
                                     self.ksize, self.alpha)
            results.append(spider.find())

        # do our crawling
        await asyncio.gather(*results)

        # now republish keys older than one hour
        for dkey, value in self.storage.iter_older_than(3600):
            await self.set_digest(dkey, value)
636112
def _reset_internal(self):
        
        super()._reset_internal()

        # reset positions of objects
        self.model.place_objects()

        # reset joint positions
        init_pos = np.array([-0.5538, -0.8208, 0.4155, 1.8409, -0.4955, 0.6482, 1.9628])
        init_pos += np.random.randn(init_pos.shape[0]) * 0.02
        self.sim.data.qpos[self._ref_joint_pos_indexes] = np.array(init_pos)
818434
def reset(self):
        
        self.current_table = None
        self.tables = []
        self.data = [{}]
        self.additional_data = {}
        self.lines = []
        self.set_state('document')
        self.current_file = None
        self.set_of_energies = set()
282932
def reset_internal_states(self, record=None):
        
        self._record = None
        self._count = 0
        self._record = record