Tools module

tacoma.tools.bin_a_function(x, y, bins, mode='mean')[source]

Bin a step function \(y(t)\) over time bins. Binning can be done using either numpy.sum or numpy.mean.

Parameters:
  • x (numpy.ndarray) – domain values at which y changes
  • y (numpy.ndarray) – values of the cunt
  • bins (numpy.ndarray) – Bin to those bin edges
  • mode (string, default : mean) – Build either a mean over the bins or a sum.
Returns:

new_y – binned observable

Return type:

numpy.ndarray

tacoma.tools.complete_graph(N, tmax=1.0)[source]

Get a single frame which consists of a complete network.

Parameters:
  • N (int) – Number of nodes.
  • tmax (float, default : 1.0) – Maximum time of the static network.
Returns:

An instance of tacoma.edge_lists with t = [0.0], tmax = tmax.

Return type:

_tacoma.edge_lists

tacoma.tools.contact_coverage(temporal_network)[source]

Get the total number of discovered unique edges C(t), i.e. the contact coverage.

Parameters:temporal_network (_tacoma.edge_trajectories, _tacoma.edge_lists, _tacoma.edge_changes or list of _tacoma.edge_trajectory_entry) –
Returns:
  • t (numpy.ndarray) – Time points at which new edges have been discovered
  • C (numpy.ndarray) – total number of edges discovered up to time t.
tacoma.tools.convert_static_network(N, edge_list, tmax=1.0)[source]

Get a single frame which consists of the static network.

Parameters:
  • N (int) – Number of nodes.
  • edge_list (list of tuple of int) – The edges of the static graph
  • tmax (double, default : 1.0) – The maximum time until the network is looped.
Returns:

An instance of tacoma.edge_lists with t = [0.0], tmax = tmax.

Return type:

_tacoma.edge_lists

tacoma.tools.fit_contact_coverage(N, time, contact_coverage, intervals_to_discard_for_fit=[], kind='gamma')[source]

Fit the contact coverage \(C(t)\) to an edge activity rate distribution of kind kind.

Parameters:
  • N (int) – Number of nodes.
  • time (numpy.ndarray) – Time points at which the contact converage changed.
  • contact_coverage (numpy.ndarray) – Contact coverage at the corresponding times in time.
  • intervals_to_discard_for_fit (list of tuple of float) – a list of time intervals which have to be discarded for the fit
  • kind (string, default : 'gamma') – Rate distribution model for fit. Can be gamma, exponential, uniform, normal, delta, power-law.
Returns:

  • fit_function (function) – The fit function
  • popt (tuple of float) – The found optimal parameters to pass to fit_function
  • pstd (tuple of float) – standard uncertainty of the parameters

tacoma.tools.get_edge_life_times(temporal_network)[source]

For each edge compute the probability that it is active and the rate with which it is activated.

Parameters:temporal_network (_tacoma.edge_lists, _tacoma.edge_changes or _tacoma.edge_trajectories) –
Returns:
  • p (numpy.ndarray) – The probability to be switched on for each observed edge of the network (the remaining un-observed edges have probability p = 0).
  • omega (numpy.ndarray) – The rate with which the observed edges are switched on \(\omega = \left(\frac{1}{\tau^+} + \frac{1}{\tau^{-}}\right)^{-1}\) (the remaining un-observed edges have rate \(\omega = 0\)).
tacoma.tools.get_edge_probability_and_rate(temporal_network)[source]

For each edge compute the probability that it is active and the rate with which it is activated.

Parameters:temporal_network (_tacoma.edge_lists, _tacoma.edge_changes or _tacoma.edge_trajectories) –
Returns:
  • p (numpy.ndarray) – The probability to be switched on for each observed edge of the network (the remaining un-observed edges have probability p = 0).
  • omega (numpy.ndarray) – The rate with which the observed edges are switched on \(\omega = \left(\frac{1}{\tau^+} + \frac{1}{\tau^{-}}\right)^{-1}\) (the remaining un-observed edges have rate \(\omega = 0\)).
tacoma.tools.get_logarithmic_histogram(data, bins, return_bin_means=True, density=True)[source]

Get a logarithmic histogram.

Parameters:
  • data (array-like) – The data to bin.
  • bins (int) – The number of bins.
  • return_bin_means (bool, default : True) – return the geometric means of binning intervals, otherwise return bin edges
  • density (bool, default : True) – return probability density, if False, return counts
Returns:

  • x (numpy.ndarray) – Either geometric intervals or interval edges
  • y (numpy.ndarray) – Either probability density or counts.

tacoma.tools.get_reduced_time(t, intervals_to_discard)[source]

Reduce the provided time in a way that intervals are cut out.

Parameters:
  • t (numpy.ndarray) – time array to reduce
  • intervals_to_discard (list of tuple of float) – The time intervals which have to be discarded.
Returns:

new_t – reduced time with equal shape to t. Each time in intervals which have to be discarded are remapped to the beginning of the intervals.

Return type:

numpy.ndarray

tacoma.tools.group_size_histogram(group_sizes_and_durations)[source]

Returns the mean number of groups of size g (mean over both ensemble and time).

Parameters:group_sizes_and_durations (group_sizes_and_durations) – Result from the function measure_group_sizes_and_durations
Returns:
  • g (numpy.ndarray of float) – Group sizes
  • N (numpy.ndarray of float) – Mean number of groups of the corresponding size in g.
tacoma.tools.mean_coordination_number(group_sizes_and_durations)[source]

Returns the mean coordination number (mean over both ensemble and time). Following the definition by Zhao, Stehle, Bianconi, Barrat, the coordination number of node i is equal to the size of the group it is part of.

Parameters:group_sizes_and_durations (group_sizes_and_durations) – Result from the function measure_group_sizes_and_durations
Returns:mean_coordination_number – Temporal and ensemble mean of a node’s group size.
Return type:float
tacoma.tools.mean_group_size(group_sizes_and_durations)[source]

Returns the mean group size (mean over both ensemble and time).

Parameters:group_sizes_and_durations (group_sizes_and_durations) – Result from the function measure_group_sizes_and_durations
Returns:mean_group_size – Temporal and ensemble mean of the group size of all groups a network consists of at a certain time.
Return type:float
tacoma.tools.mean_number_of_groups(group_sizes_and_durations)[source]

Returns the mean number of groups (mean over both ensemble and time).

Parameters:group_sizes_and_durations (group_sizes_and_durations) – Result from the function measure_group_sizes_and_durations
Returns:mean_number_of_groups – Temporal and ensemble mean of the total number of groups a network consists of at a certain time.
Return type:float
tacoma.tools.rescale_time(temporal_network, new_t0, new_tmax)[source]

Rescale the time in this temporal network (inplace).

Parameters:
  • temporal_network (edge_lists or edge_changes) –
  • new_t0 (float) – The new value of t0.
  • new_tmax (float) – The new value of tmax.
Returns:

temporal_network – Same instance as input.

Return type:

edge_lists or edge_changes

tacoma.tools.sample_a_function(t, y, time_points, sample_width=0)[source]

Sample an observable \(y\) which is a step function and changes at corresponding values \(t\).

Parameters:
  • t (numpy.ndarray) – domain values at which y changes
  • y (numpy.ndarray) – observable to sample
  • time_points (numpy.ndarray) – time points for which to sample.
  • sample_width (float, default : 0.0) – sample as a temporal average over [t-sample_width/2, t+sample_width/2].
Returns:

new_y – values of y sampled at time_points.

Return type:

numpy.ndarray

tacoma.tools.slow_mean_degree(temporal_network)[source]

Returns the mean degree (mean over ensemble) but it takes ages to compute. You should instead use mean_degree.

Parameters:temporal_network (edge_lists or edge_changes) –
Returns:
  • t (float) – Temporal and ensemble mean of the node degree.
  • mean_degree (float) – Temporal and ensemble mean of the node degree.
tacoma.tools.time_RMSE(t, x1, x2, tmax=None)[source]

Get the root mean squared error (RMSE) of two observables over the same time. Combine with tacoma.tools.sample_a_function().

\[\mathrm{RMSE} = \left( \frac{1}{t_\mathrm{max}-t_0} \int\limits_{t_0}^{t_\mathrm{max}} dt\, \left( x_1(t) - x_2(t) \right)^2. \right)^{1/2}\]
Parameters:
  • t (numpy.ndarray) – times at which x1 and x2 change
  • x1 (numpy.ndarray) – The first observable to compute the RMSE.
  • x2 (numpy.ndarray) – The second observable to compute the RMSE.
  • tmax (float, default : None) – If this is None, the integral is computed until time t[-1], otherwise it’s evaluated until tmax.
Returns:

RMSE – The root mean squared error.

Return type:

float

tacoma.tools.time_average(t, x, tmax=None)[source]

Return a temporal average of an observable x(t),

\[\overline x = \frac{1}{t_\mathrm{max}-t_0} \int\limits_{t_0}^{t_\mathrm{max}} dt\, x(t).\]

Where it’s assumed that x changes as a step function, such that

\[\overline x = \frac{1}{t_\mathrm{max}-t_0} \left( (t_\mathrm{max} - t_{N_t-1}) x(t_{N_t-1}) + \sum_{i=1}^{N_t-1} (t_{i}-t_{i-1})x(t_{i-1}) \right).\]
Parameters:
  • t (numpy.ndarray) – Times at which x changes
  • x (numpy.ndarray) – Value of the observable at the corresponding times.
  • tmax (float, default : None) – If this is None, the integral is computed until time t[-1], otherwise it’s evaluated until tmax.
Returns:

average_x – The temporal average of x.

Return type:

float