laser_cholera.metapop package

class laser_cholera.metapop.Analyzer(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Census(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.DerivedValues(model)

Bases: object

check()

plot(fig=None)

class laser_cholera.metapop.EnvToHuman(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.EnvToHumanVax(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Environmental(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Exposed(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.HumanToHuman(model)

Bases: object

__call__(model, tick: int) → None

Calculate the current human-to-human transmission rate per patch.

$Lambda_{j,t+1} = frac {beta^{hum}_{jt}((S_{jt}(1 - tau_j))(I_{jt}(1 - tau_j) + sum_{forall i neq j (pi_{ij} tau_j I_{it})}))^{alpha_1}} {N^{alpha_2}_{jt}}$

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.HumanToHumanVax(model)

Bases: object

__call__(model, tick: int) → None

Calculate the current human-to-human transmission rate per patch.

$Lambda_{j,t+1} = frac {beta^{hum}_{jt}((S_{jt}(1 - tau_j))(I_{jt}(1 - tau_j) + sum_{forall i neq j (pi_{ij} tau_j I_{it})}))^{alpha_1}} {N^{alpha_2}_{jt}}$

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Infectious(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Parameters(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Recorder(model)

Bases: object

check()

class laser_cholera.metapop.Recovered(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Susceptible(model)

Bases: Component

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.Vaccinated(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.get_parameters(paramsource: str | Path | dict | None = None, do_validation: bool = True, overrides: dict | None = None) → PropertySetEx

Submodules

laser_cholera.metapop.analyzer module

class laser_cholera.metapop.analyzer.Analyzer(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.census module

class laser_cholera.metapop.census.Census(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.derivedvalues module

class laser_cholera.metapop.derivedvalues.DerivedValues(model)

Bases: object

check()

plot(fig=None)

laser_cholera.metapop.environmental module

class laser_cholera.metapop.environmental.Environmental(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.environmental.map_suitability_to_decay(fast, slow, suitability, beta_a, beta_b)

Map suitability to decay using a beta distribution.

Parameters:

• fast (float) – Fast decay time.

• slow (float) – Slow decay time.

• suitability (np.ndarray) – Suitability values.

• beta_a (float) – Alpha parameter for the beta distribution.

• beta_b (float) – Beta parameter for the beta distribution.

Returns:

np.ndarray – Decay rates corresponding to the suitability values.

laser_cholera.metapop.envtohuman module

Environmental transmission rate.

class laser_cholera.metapop.envtohuman.EnvToHuman(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.envtohumanvax module

Environmental transmission rate.

class laser_cholera.metapop.envtohumanvax.EnvToHumanVax(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.envtohumanvax.plot_helper(fig, title, data, names)

laser_cholera.metapop.exposed module

class laser_cholera.metapop.exposed.Exposed(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.humantohuman module

Human-to-human transmission rate.

class laser_cholera.metapop.humantohuman.HumanToHuman(model)

Bases: object

__call__(model, tick: int) → None

Calculate the current human-to-human transmission rate per patch.

$Lambda_{j,t+1} = frac {beta^{hum}_{jt}((S_{jt}(1 - tau_j))(I_{jt}(1 - tau_j) + sum_{forall i neq j (pi_{ij} tau_j I_{it})}))^{alpha_1}} {N^{alpha_2}_{jt}}$

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.humantohumanvax module

Human-to-human transmission rate.

class laser_cholera.metapop.humantohumanvax.HumanToHumanVax(model)

Bases: object

__call__(model, tick: int) → None

Calculate the current human-to-human transmission rate per patch.

$Lambda_{j,t+1} = frac {beta^{hum}_{jt}((S_{jt}(1 - tau_j))(I_{jt}(1 - tau_j) + sum_{forall i neq j (pi_{ij} tau_j I_{it})}))^{alpha_1}} {N^{alpha_2}_{jt}}$

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.humantohumanvax.plot_helper(fig, title, data, names)

laser_cholera.metapop.infectious module

class laser_cholera.metapop.infectious.Infectious(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.logsetup module

laser_cholera.metapop.logsetup.setup_logging(loglevel, outdir: Path)

laser_cholera.metapop.model module

class laser_cholera.metapop.model.Model(parameters: PropertySet, name: str = 'Cholera Metapop')

Bases: object

property components: list

Retrieve the list of model components.

Returns:

list – A list containing the components.

plot(fig: Figure | None = None)

run() → None

Execute the model for a specified number of ticks, recording the time taken for each phase.

This method initializes the start time, iterates over the number of ticks specified in the model parameters, and for each tick, it executes each phase of the model while recording the time taken for each phase.

The metrics for each tick are stored in a list. After completing all ticks, it records the finish time and, logs a summary of the timing metrics.

Variables:

• tstart (datetime) – The start time of the model execution.

• tfinish (datetime) – The finish time of the model execution.

• metrics (list) – A list of timing metrics for each tick and phase.

Returns:

None

visualize(pdf: bool = True) → str | None

Visualize each compoonent instances either by displaying plots or saving them to a PDF file.

Parameters:

pdf (bool) – If True, save the plots to a PDF file. If False, display the plots interactively. Default is True.

Returns:

None

laser_cholera.metapop.model.run_model(paramfile, **kwargs)

laser_cholera.metapop.params module

class laser_cholera.metapop.params.Parameters(model)

Bases: object

check()

plot(fig: Figure | None = None)

class laser_cholera.metapop.params.PropertySetEx(*kvps)

Bases: PropertySet

__str__() → str

Return a string representation of the PropertySet.

Include converters for datetime and NumPy types.

class laser_cholera.metapop.params.PseEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: JSONEncoder

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

laser_cholera.metapop.params.dict_to_propertysetex(parameters: dict) → PropertySetEx

laser_cholera.metapop.params.get_parameters(paramsource: str | Path | dict | None = None, do_validation: bool = True, overrides: dict | None = None) → PropertySetEx

laser_cholera.metapop.params.load_compressed_hdf5_parameters(filename: str | Path) → PropertySetEx

laser_cholera.metapop.params.load_compressed_json_parameters(filename: str | Path) → PropertySetEx

laser_cholera.metapop.params.load_hdf5(h5file) → PropertySetEx

laser_cholera.metapop.params.load_hdf5_parameters(filename: str | Path) → PropertySetEx

laser_cholera.metapop.params.load_json_parameters(filename: str | Path) → PropertySetEx

laser_cholera.metapop.params.validate_parameters(params: PropertySetEx) → None

laser_cholera.metapop.recorder module

class laser_cholera.metapop.recorder.Recorder(model)

Bases: object

check()

laser_cholera.metapop.recorder.save_compressed_hdf5_parameters(model, filename: str | Path) → Path

laser_cholera.metapop.recorder.save_hdf5(h5file: File, model) → None

laser_cholera.metapop.recorder.save_hdf5_parameters(model, filename: str | Path) → Path

laser_cholera.metapop.recovered module

class laser_cholera.metapop.recovered.Recovered(model)

Bases: object

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.scenario module

laser_cholera.metapop.susceptible module

class laser_cholera.metapop.susceptible.Component

Bases: object

class laser_cholera.metapop.susceptible.Susceptible(model)

Bases: Component

check()

plot(fig: Figure | None = None)

laser_cholera.metapop.utils module

laser_cholera.metapop.utils.fourier_series_double(t, beta0, a1, b1, a2, b2, p)

Computes the value of a Fourier series with two harmonics at a given time.

Parameters:

• t (array-like) – Time values.

• beta0 (float) – Constant term of the Fourier series.

• a1 (array-like) – Amplitudes of the first harmonic (cosine component).

• b1 (array-like) – Amplitudes of the first harmonic (sine component).

• a2 (array-like) – Amplitudes of the second harmonic (cosine component).

• b2 (array-like) – Amplitudes of the second harmonic (sine component).

• p (float) – Period of the Fourier series.

Returns:

numpy.ndarray – The computed Fourier series values at the given time points.

laser_cholera.metapop.utils.get_daily_seasonality(params)

laser_cholera.metapop.utils.get_pi_from_lat_long(params)

laser_cholera.metapop.utils.override_helper(overrides) → dict

laser_cholera.metapop.vaccinated module

class laser_cholera.metapop.vaccinated.Vaccinated(model)

Bases: object

check()

plot(fig: Figure | None = None)