Batches

Batch(;n_runs::Integer = 0, print_infos::Bool = false, simargs...)

Creates a Batch object with a number of Simulation objects as specified in n_runs. The Simulation objects are not passed but rather instantiated inside this function. Therefore, you can specify any keyworded argument using simargs..., that you would otherwise pass to the Simulation() constructor.

This function suppresses the console info outputs of the Simulation() function. If you want to enable them, set the optional print_info argument to True.

Batch(simulations::Simulation...)

Creates a Batch object from Simulation objects. Note: All Simulation objects must be unique. You cannot pass the same simulation twice.

Batch(simulations::Vector{Simulation})

Creates a Batch object from a vector of Simulation objects. Note: All Simulation objects must be unique. You cannot pass the same simulation twice.

Batch(batches::Batch...)

Merge multiple Batches into one.

Batch(batches::Vector{Batch})

Merge multiple Batches into one.

add!(sim::Simulation, batch::Batch)

Adds a Simulation to a Batch.

append!(batch1::Batch, batch2::Batch)

Appends all simulations of batch2 to batch1.

customlogger!(batch::Batch, cl::CustomLogger)

Adds a CustomLogger to each of the Simulation objects that are contained in this batch. Note: This function will generate a duplicate of the passed logger for each of the simulation objects as otherwise, als data from all simulations would we written to the same logger.

merge(batches::Batch...)
merge(batches::Vector{Batch})

Generates a new Batch that contains all simulations of the input Batches.

remove!(sim::Simulation, batch::Batch)

Removes a Simulation from a Batch.

run!(batch::Batch; stepmod!::Function = x -> x)

Run all simulations within a Batch. You can pass a stepmod! function that is being executed for each simulation in each step. But be aware that it will be the same instance of the stepmod! function. So if you have any internal data collection, this might cause inconsistencies.

simulations(batch::Batch)

Returns the list of Simulations associated with a Batch.

BatchProcessor(rundata::Vector{ResultData})

Creates a BatchProcessor object for a vector of ResultData objects.

BatchProcessor(batch::Batch; stysle::String = "LightRD", print_infos::Bool = false)

Creates a BatchProcessor object from a Batch object. This constructor generates the ResultData object for each of the Simulations contained in the Batch. It supresses the usual info outputs that are being made during the ResultData generation. If you want to enable them, pass print_infos = true.

allocations(batchProcessor::BatchProcessor)

Returns a dataframe for the memory allocations of the associated simulation runs in this batch. The columns correspond to the names of the inner timers while each row corresponds to one run. (Note: This data is only available if the simulation runs were done via the main() function)

attack_rate(batchProcessor::BatchProcessor)

Returns a vector of the attack_rate accross the simulation runs in this batch.

config_files(batchProcessor::BatchProcessor)

Returns the associated config file.

cumulative_disease_progressions(batchProcessor::BatchProcessor)

Returns cumulative quarantines per tick accross the simulation runs in this batch.

cumulative_quarantines(batchProcessor::BatchProcessor)

Returns cumulative quarantines per tick accross the simulation runs in this batch.

effectiveR(batchProcessor::BatchProcessor)

Returns the effective R value for each tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

number_of_individuals(batchProcessor::BatchProcessor)

Returns a vector of number_of_individuals that were used in the associated simulations. Values are unique and can originate from multiple simulation runs.

pathogens(batchProcessor::BatchProcessor)

Returns a vector of pathogens that were used in the associated simulations. Values are unique and can originate from multiple simulation runs.

pathogens_by_name(batchProcessor::BatchProcessor)

Returns a {name, pathogen[]} dictionary of pathogens that were used in the associated simulations. This is done to keep multiple pathogen configurations of the same name with varying parameters. Names are unique and can originate from multiple simulation runs.

population_files(batchProcessor::BatchProcessor)

Returns the associated population file.

population_pyramid(batchProcessor::BatchProcessor)

Returns a {String, DataFrame} dictionary containing data to generate a population pyramid for each population files of this batch.

Dataframe Columns

run_ids(batchProcessor::BatchProcessor)

Returns the vector of simulation run IDs that are associated with this batch.

rundata(batchProcessor::BatchProcessor)

Returns the vector of ResultData objects of simulation runs that are associated with this batch.

runtime(batchProcessor::BatchProcessor)

Returns dataframe of the runtimes of the associated simulation runs in this batch. The columns correspond to the names of the inner timers while each row corresponds to one run. (Note: This data is only available if the simulation runs were done via the main() function)

setting_age_contacts(batchProcessor::BatchProcessor, settingtype::DataType)

Returns a {String, DataFrame} dictionary containing an age X age matrix with sampled contacts for a provided settingtype (i.e. Households) for each population files of this batch.

settingdata(batchProcessor::BatchProcessor)

Returns a {String, DataFrame} dictionary containing information about setting types in the population files in the simulation runs of this batch. Populations are distinguished by their population file name stored in the key of the result dictionary.

Dataframe Columns

start_conditions(batchProcessor::BatchProcessor)

Returns a vector of start_conditions that were used in the associated simulations. Values are unique and can originate from multiple simulation runs.

stop_criteria(batchProcessor::BatchProcessor)

Returns a vector of stop_criteria that were used in the associated simulations. Values are unique and can originate from multiple simulation runs.

strategies(batchProcessor::BatchProcessor)

Returns a vector of the strategies accross the simulation runs in this batch.

symptom_triggers(batchProcessor::BatchProcessor)

Returns a vector of the symptom_triggers accross the simulation runs in this batch.

tests(batchProcessor::BatchProcessor)

Returns newly exposed inviduals per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

testtypes(batchProcessor::BatchProcessor)

Returns a vector of the testtypes accross the simulation runs in this batch.

tick_cases(batchProcessor::BatchProcessor)

Returns newly exposed inviduals per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

tick_unit(batchProcessor::BatchProcessor)

Returns a vector of tick_units that were used in the associated simulations. Values are unique and can originate from multiple simulation runs.

total_infections(batchProcessor::BatchProcessor)

Returns a vector of the total_infections accross the simulation runs in this batch.

total_quarantines(batchProcessor::BatchProcessor)

Returns a vector of the total_quarantines accross the simulation runs in this batch.

total_tests(batchProcessor::BatchProcessor)

Returns a Dict of vectors of the total_tests per TestType accross the simulation runs in this batch.

BatchData(batchProcessor::BatchProcessor; style::String = "DefaultBatchData")

Create a BatchData object using a BatchProcessor and a style, that defines which calculations should be done. Post Processing requires a simulation to be done.

BatchData(batch::Batch; style::String = "DefaultBatchData", rd_style = "LightRD")

Create a BatchData object using a Batch and a style, that defines which calculations should be done during batch processing. As the provided batch has unprocessed simulation runs inside, this function also triggers post processing for the individual simulation runs. The rd_style argument defines the calculations that should be done during post processing of the individual runs. Post processing requires a simulation to be done.

BatchData(rds::Vector{ResultData}; style::String = "DefaultBatchData")

Create a BatchData object using a vector of ResultData objects and a style, that defines which calculations should be done during batch processing.

BatchData(bds::BatchData...; style::String = "DefaultBatchData")

Calls the merge() function for the input BatchData objects.

BatchData(bds::Vector{BatchData}; style::String = "DefaultBatchData")

Calls the merge() function for the input vector of BatchData objects.

allocations(bd::BatchData)

Returns allocation data of the simulation runs in this batch. (Note: This data is only available if the simulation runs were done via the main() function)

attack_rate(bd::BatchData)

Returns aggregated values for the attack_rate accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

cpu_data(bd::BatchData)

Returns the processor information (not available for ARM Macs)

cumulative_disease_progressions(bd::BatchData)

Returns aggregated values for cumulativediseaseprogressions per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

cumulative_quarantines(bd::BatchData)

Returns aggregated values cumulative_quarantines per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

dataframes(batchData)

Returns the dataframes dict of the batch data object.

effectiveR(bd::BatchData)

Returns aggregated values for the effective R value for each tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

execution_date(bd::BatchData)

Returns the timestamp of batch data generation.

exportJLD(batchData, directory)

Exports the BatchData object as a JLD2 file, storing it in the specified directory.

free_mem_size(bd::BatchData)

Returns the available system memory

GEMS_version(bd::BatchData)

Returns the GEMS version this BatchData object was generated with.

git_branch(bd::BatchData)

Returns the current git branch.

git_commit(bd::BatchData)

Returns the current git commit.

git_repo(bd::BatchData)

Returns the current git repository.

id(bd::BatchData)

Returns the stringified SHA1 hash that serves as a unique identifier.

import_batchdata(filepath::AbstractString)

Import the BatchData object from a jld2 file. Returns the BatchData object.

info(bd::BatchData)

Prints info about available fields in the BatchData object.

julia_version(bd::BatchData)

Returns the Julia version that was used to generate this result data object.

kernel(bd::BatchData)

Returns the system kernel information

merge(bds::BatchData...; style::String = "DefaultBatchData")
merge(bds::Vector{BatchData}; style::String = "DefaultBatchData")

Generates a new BatchData object from the union of all ResultData objects out of all the passed BatchData objects. Naturally, this requires the input BatchData objects to have internal ResultData objects. This requirement is met if the default style (DefaultBatchData) was used during the creation of the input objects. Simply: If you didn't apply any custom style, this should work.

Returns

• BatchData: (New) combined BatchData object with all internal ResultData objects

meta_data(bd::BatchData)

Returns the metadata dict of the batch data object.

number_of_runs(bd::BatchData)

Returns the number of runs in this batch.

runs(bd::BatchData)

Returns the ResultData objects of each of the runs in the the batch data object.

runtime(bd::BatchData)

Returns runtime data of the simulation runs in this batch. (Note: This data is only available if the simulation runs were done via the main() function)

sim_data(bd::BatchData)

Returns the simdata dict of the batch data object.

system_data(bd::BatchData)

Returns the systemdata dict of the batch data object.

tests(bd::BatchData)

Returns aggregated values for tests per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

tick_cases(bd::BatchData)

Returns aggregated values for newly exposed inviduals per tick accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

threads(bd::BatchData)

Returns the number of threads this Julia instance was started with

total_infections(bd::BatchData)

Returns aggregated values for total_infections accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

total_mem_size(bd::BatchData)

Returns the total system memory

total_quarantines(batchData)

Returns aggregated values for total_quarantines accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

total_tests(bd::BatchData)

Returns aggregated values for total_tests accross the simulation runs in this batch. It returns mean, standard deviation, range, and confidence intervals.

word_size(bd::BatchData)

Returns the system word size

DefaultBatchData <: BatchDataStyle

The default style for BatchData objects. It contains all that can currently be calculated in the BatchProcessor and all ResultData objects of the individual runs.

Fields

• data::Dict{String, Any}

  • meta_data::Dict{String, Any}

    • execution_date::String: Time this BatchData object was generated
    • GEMS_version::VersionNumber: GEMS version this BatchData object was generated with

  • system_data::Dict{String, Any}

    • kernel::String: System kernel
    • julia_version::String: Julia version that was used to generate this data object
    • word_size::Int64: System word size
    • threads::Int64: Number of threads this Julia instance was started with
    • cpu_data::Markdown.MD: Information on the processor (not available for ARM Macs)
    • total_mem_size::Float64: Total system memory
    • free_mem_size::Float64: Available system memory
    • git_repo::SubString{String}: Current Git repository
    • git_branch::SubString{String}: Current Git branch
    • git_commit::SubString{String}: Current Git commit ID

  • sim_data::Dict{String, Any}

    • runs::Vector{ResultData}: ResultData objects of individual simulation runs runs
    • number_of_runs::Int64: Number of simulation runs
    • total_infections::Dict{String, Real}: Summary statistics on total infections across simulation runs
    • attack_rate::Dict{String, Real}: Summary statistics on attack rates across simulation runs
    • total_quarantines::Dict{String, Real}: Summary statistics on total quarantines across simulation runs
    • total_tests::Dict{String, Real}: Summary statistics on total tests across simulation runs

  • dataframes::Dict{String, Any}

    • tick_cases::Dataframe: Aggregated data on infections per tick across simulation runs
    • effectiveR::Dataframe: Aggregated data on the effective reproduction number per tick across simulation runs
    • tests::Dataframe: Aggregated data on tests per tick across simulation runs
    • cumulative_quarantines::Dataframe: Aggregated data on cumulative quarantines per tick across simulation runs
    • cumulative_disease_progressions::Dataframe: Aggregated data on cumulative disease progressions per tick across simulation runs