This method returns the realization of the process at a certain time index.

@param timeIndex Time index at which the process should be observed
@param componentIndex Component of the process vector
@return A vector of process realizations (on path)
11934
public RandomVariable getProcessValue(int timeIndex, int componentIndex)
	{
		if(timeIndex == 0) {
			return getInitialValue()[componentIndex];
		}

		// Lazy initialization, synchronized for thread safety
		synchronized(this) {
			if(discreteProcess == null || discreteProcess.length == 0) {
				doPrecalculateProcess();
			}
		}

		// Return value of process
		return discreteProcess[timeIndex][componentIndex];
	}
178792
@Override
  public SortedMap<String, Timer> getTimers(MetricFilter filter) {
    return this.innerMetricContext.getTimers(filter);
  }
697980
public List<Integer> getComponentTasks(String componentId) {
        List<Integer> ret = _componentToTasks.get(componentId);
        if (ret == null)
            return new ArrayList<>();
        else
            return new ArrayList<>(ret);
    }
933419
@SuppressWarnings("unchecked")
	<T extends Component> T getComponent (ComponentType componentType) {
		int componentTypeIndex = componentType.getIndex();

		if (componentTypeIndex < components.getCapacity()) {
			return (T)components.get(componentType.getIndex());
		} else {
			return null;
		}
	}
431312
protected JComponent getInnerComponent(JComponent component) {
		if (component instanceof JScrollPane) {
			return getInnerComponent((JComponent) ((JScrollPane) component).getViewport().getView());
		} if (component instanceof HasInnerComponent) {
            return getInnerComponent(((HasInnerComponent) component).getInnerComponent());
        }
		return component;
	}
889650
public Vector3D getCorner(int index) {
        Vector3D v = new Vector3D();
        if (index <= 0)
            v.set(x1, y1, z1);
        else
            v.set(x2, y2, z2);
        return v;
    }
1075689
public List<Component> getIndexProviders() {
        Problems problems = new SimpleProblems();
        List<Component> components = readComponents(doc, FieldName.INDEX_PROVIDERS, FieldName.CLASSNAME, INDEX_PROVIDER_ALIASES,
                                                    problems);
        assert !problems.hasErrors();
        return components;
    }
713061
public List<XEvent> subList(int fromIndex, int toIndex) {
		XTraceBufferedImpl sublist = (XTraceBufferedImpl) this.clone();
		this.clear();
		for (int i = fromIndex; i < toIndex; i++) {
			try {
				sublist.add(events.get(i));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sublist;
	}
430333
public CronPattern getPattern(int index) {
		final Lock readLock = lock.readLock();
		try {
			readLock.lock();
			return patterns.get(index);
		} finally {
			readLock.unlock();
		}
	}
776025
public T get(String componentId) {
		for (T component : components) {
			if (component.getId().equals(componentId)) {
				return component;
			}
		}
		return null;
	}
748194
@SuppressWarnings({ "PMD.DataflowAnomalyAnalysis" })
    /* default */ static ComponentVertex getComponentProxy(
            ComponentType component, Channel componentChannel) {
        ComponentProxy componentProxy = null;
        try {
            Field field = getManagerField(component.getClass());
            synchronized (component) {
                if (!field.isAccessible()) { // NOPMD, handle problem first
                    field.setAccessible(true);
                    componentProxy = (ComponentProxy) field.get(component);
                    if (componentProxy == null) {
                        componentProxy = new ComponentProxy(
                            field, component, componentChannel);
                    }
                    field.setAccessible(false);
                } else {
                    componentProxy = (ComponentProxy) field.get(component);
                    if (componentProxy == null) {
                        componentProxy = new ComponentProxy(
                            field, component, componentChannel);
                    }
                }
            }
        } catch (SecurityException | IllegalAccessException e) {
            throw (RuntimeException) (new IllegalArgumentException(
                "Cannot access component's manager attribute")).initCause(e);
        }
        return componentProxy;
    }
655767
public SequenceView<C> get(int index) {
		int start = toStartIndex(index);
		int end  = index + (getWindowSize() - 1);
		return getBackingSequence().getSubSequence(start, end);
	}
986030
@Override
    public double getParameter(int index){
        
        Compound component = substance.getVapor().getComponent();
            Alpha alpha = substance.getVapor().getAlpha();
            return alpha.getParameter( component, index);
    }
595013
synchronized JournalSegment<E> getSegment(long index) {
    assertOpen();
    // Check if the current segment contains the given index first in order to prevent an unnecessary map lookup.
    if (currentSegment != null && index > currentSegment.index()) {
      return currentSegment;
    }

    // If the index is in another segment, get the entry with the next lowest first index.
    Map.Entry<Long, JournalSegment<E>> segment = segments.floorEntry(index);
    if (segment != null) {
      return segment.getValue();
    }
    return getFirstSegment();
  }
1094932
public T getFromZeroBasedIdx(final int idx) {
        if (this.timeSeries != null && this.currentNowIdx != -1) {

            // we can use the default validation, because the index still must be in the borders of the time-series
            validateIdx(idx);
            return get(idx(currentNowIdx + idx));
        } else {
            return null;
        }
    }
1373069
private List<ProducerAO> getFilteredProducers(String intervalName, TimeUnit timeUnit, String category, String subsystem) throws APIException {
        if (!StringUtils.isEmpty(category)) {
            return getProducerAPI().getAllProducersByCategory(category, intervalName, timeUnit, true);
        }

        if (!StringUtils.isEmpty(subsystem)) {
            return getProducerAPI().getAllProducersBySubsystem(subsystem, intervalName, timeUnit, true);
        }

        return getProducerAPI().getAllProducers(intervalName, timeUnit, true);
    }
969783
public synchronized XEvent get(int index) throws IndexOutOfBoundsException,
			IOException {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException();
		}
		int bufferIndex = index;
		// correct buffer index from overflow
		for (int i = 0; i < overflowSize; i++) {
			if (overflowIndices[i] == index) {
				return overflowEntries[i];
			} else if (overflowIndices[i] < index) {
				bufferIndex--;
			} else {
				break;
			}
		}
		// determine deleted offset
		// step over flagged indices and adjust buffer index upwards
		// respectively
		for (int hole = holeFlags.nextSetBit(0); hole >= 0
				&& hole <= bufferIndex; hole = holeFlags.nextSetBit(hole + 1)) {
			bufferIndex++;
		}
		// buffer index should now point to the corresponding index
		// within the file buffer, so return it
		return buffer.get(bufferIndex);
	}