formatting and typos

Author: mknaranja

.clang-format

@@ -0,0 +1,22 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+SortIncludes:    false
+ColumnLimit:     120
+AlignTrailingComments: false
+AccessModifierOffset: -4
+AlignConsecutiveAssignments: true
+ReflowComments:  true
+BraceWrapping:   
+  AfterClass:    true
+  AfterFunction: true
+  BeforeElse: true
+  BeforeCatch: true
+  AfterNamespace:  true
+  AfterEnum: true
+BreakBeforeBraces: "Custom"
+PointerAlignment: Left
+AllowShortFunctionsOnASingleLine: false
+NamespaceIndentation: None
+BreakConstructorInitializersBeforeComma: true
+AlwaysBreakTemplateDeclarations: Yes
+AllowShortLambdasOnASingleLine: Empty

cpp-tutorials/exercises/exercise01.cpp

@@ -4,14 +4,21 @@
 
 int main()
 {
-    // MEmilio implements various models based on ordinary differential equations (ODEs). ODE-based models are a subclass of compartmental models in which individuals are grouped into subpopulations called compartments.
+    // MEmilio implements various models based on ordinary differential equations (ODEs). ODE-based models are a
+    // subclass of compartmental models in which individuals are grouped into subpopulations called compartments.
 
-    // In this tutorial we will setup and run MEmilio's ODE-based SECIR-type model. This model is particularly suited for pathogens with pre- or asymptomatic infection states and when severe or critical symptoms are possible. The model assumes perfect immunity after recovery. The used infection states or compartments are Susceptible (S), Exposed(E), Non-symptomatically Infected (Ins), Symptomatically Infected (Isy), Severely Infected (Isev), Critically Infected (Icri), Dead (D) and Recovered (R). The transitions are depicted in the following figure.
+    // In this tutorial we will setup and run MEmilio's ODE-based SECIR-type model. This model is particularly
+    // suited for pathogens with pre- or asymptomatic infection states and when severe or critical symptoms are possible.
+    // The model assumes perfect immunity after recovery. The used infection states or compartments are Susceptible (S),
+    // Exposed(E), Non-symptomatically Infected (Ins), Symptomatically Infected (Isy), Severely Infected (Isev),
+    // Critically Infected (Icri), Dead (D) and Recovered (R). The transitions are depicted in the following figure.
 
     // *** Set up model. ***
-    // We need to specify basic parameters. In this tutorial, we use a simple model without spatial resolution and with only one age group.
+    // We need to specify basic parameters. In this tutorial, we use a simple model without spatial resolution and
+    // with only one age group.
     size_t num_agegroups = 1;
-    //  We first define the `total_population` size and the simulation horizong through the start day `t0`, and the simulation's end point `tmax`. By default, the ODE is solved with adaptive time stepping and the initial time step is `dt`.
+    // We first define the `total_population` size and the simulation horizong through the start day `t0`, and the
+    // simulation's end point `tmax`. By default, the ODE is solved with adaptive time stepping and the initial time step is `dt`.
     ScalarType total_population = 100000;
     ScalarType t0               = 0;
     ScalarType tmax             = 100;
@@ -20,7 +27,9 @@ int main()
     // Create model
     mio::osecir::Model<ScalarType> model(num_agegroups);
 
-    // Next, we have to set the epidemiological model parameters which include the average stay times per infection state, the state transition probabilities, and the contact frequency. A list of all parameters can be found at https://memilio.readthedocs.io/en/latest/cpp/models/osecir.html. The parameters can be set as follows:
+    // Next, we have to set the epidemiological model parameters which include the average stay times per infection
+    // state, the state transition probabilities, and the contact frequency. A list of all parameters can be found
+    // at https://memilio.readthedocs.io/en/latest/cpp/models/osecir.html. The parameters can be set as follows:
     // Set infection state stay times (in days)
     model.parameters.get<mio::osecir::TimeInfectedNoSymptoms<ScalarType>>() = 2.;
     model.parameters.get<mio::osecir::TimeInfectedSymptoms<ScalarType>>()   = 6.;
@@ -42,15 +51,21 @@ int main()
 
     // EXERCISE: Please set the average time individuals spend in the exposed state (TimeExposed) to 4 days
 
-    // In addition to the parameters, the initial number of individuals in each compartment has to be set. If a compartment is not set, its initial value is zero by default. In this example, we start our simulation with 1 % of the population initially infected, distributing them equally to the `Exposed` and the `InfectedNoSymptoms` state, where the latter contains pre- and asymptomatic infectious individuals. With the last line, we set the remaining part of the population (99%) to be susceptible.
+    // In addition to the parameters, the initial number of individuals in each compartment has to be set. If a
+    // compartment is not set, its initial value is zero by default. In this example, we start our simulation with 1 %
+    // of the population initially infected, distributing them equally to the `Exposed` and the `InfectedNoSymptoms`
+    // state, where the latter contains pre- and asymptomatic infectious individuals. With the last line,
+    // we set the remaining part of the population (99%) to be susceptible.
     model.populations[{mio::AgeGroup(0), mio::osecir::InfectionState::Exposed}]            = 0.005 * total_population;
     model.populations[{mio::AgeGroup(0), mio::osecir::InfectionState::InfectedNoSymptoms}] = 0.005 * total_population;
     model.populations.set_difference_from_total({mio::AgeGroup(0), mio::osecir::InfectionState::Susceptible},
                                                 total_population);
 
     // EXERCISE: Please set 2% of the population initially infected. The initially infected should be distributed to the compartpartments as follows: 0.5% is initially exposed (state `Exposed`), 0.5% is non-symptomatically infected (state `InfectedNosymptoms`) and 1% is symptomatically infected (state `InfectedSymptoms`).
 
-    // To check that all initial parameter and compartmental values are in a meaningful range, MEmilio provides the `check_constraints` function. If a value exceeds its meaningful range, a warning is printed and the function returns `True`, otherwise it returns `False`.
+    // To check that all initial parameter and compartmental values are in a meaningful range, MEmilio provides the
+    // `check_constraints` function. If a value exceeds its meaningful range, a warning is printed and the function
+    // returns `True`, otherwise it returns `False`.
     model.check_constraints();
 
     // *** Simulate model. ***

cpp-tutorials/exercises/exercise03.cpp

@@ -4,10 +4,12 @@
 
 int main()
 {
-    // In the previous tutorial, we created, initialized and simulated MEmilio's ODE-based SECIR-type model with one (age) group. In this tutorial, we will show how to incorporate non-pharmaceutical interventions (NPIs) through the use of `Dampings` in the ODE-based SECIR-type model.
+    // In the previous tutorial, we created, initialized and simulated MEmilio's ODE-based SECIR-type model with one
+    // (age) group. In this tutorial, we will show how to incorporate non-pharmaceutical interventions (NPIs) through
+    // the use of `Dampings` in the ODE-based SECIR-type model.
 
     // *** Set up model. ***
-    // First we create and initialize a SECIR-type model with one age group. For a detailed description on taht, see Tutorial 1.
+    // First we create and initialize a SECIR-type model with one age group. For a detailed description, see Tutorial 1.
     size_t num_agegroups        = 1;
     ScalarType total_population = 100000;
     ScalarType t0               = 0;
@@ -39,13 +41,22 @@ int main()
 
     // EXERCISE: Please set the model's contact frequency to 10.
 
-    // After the model initialization, we add a contact reduction (`Damping`) that represents an NPI like e.g. mask wearing or social distancing. Dampings are a factor applied to the contact frequency and can be added to the model at fixed simulation time points before simulating. They have a *Level* and a *Type*. A damping with a given level and type replaces the previously active one with the same level and type, while all currently active dampings of one level and different types are summed up. If two dampings have different levels (independent of the type) they are combined multiplicatively. In the following we apply a `Damping` of 0.9 after 10 days and another damping of 0.6 after 20 days which means that the contacts are reduced by 10% and 40%, respectively. To always retain a minimum level of contacts, a minimum contact frequency can be set that is never deceeded. In our example we set this minimum contact rate to 0.
+    // After the model initialization, we add a contact reduction (`Damping`) that represents an NPI like
+    //  mask wearing or social distancing. Dampings are a factor applied to the contact frequency and can be added
+    // to the model at fixed simulation time points before simulating. They have a *Level* and a *Type*.
+    // A damping with a given level and type replaces the previously active one with the same level and type, while
+    // all currently active dampings of one level and different types are summed up. If two dampings have different
+    // levels (independent of the type) they are combined multiplicatively. In the following we apply a `Damping`
+    // of 0.9 after 10 days and another damping of 0.6 after 20 days which means that the contacts are reduced
+    // by 10% and 40%, respectively. To always retain a minimum level of contacts, a minimum contact frequency can
+    // be set that is never deceeded. In our example we set this minimum contact rate to 0.
     contact_matrix[0].add_damping(0.9, mio::SimulationTime<ScalarType>(10.));
     contact_matrix[0].add_damping(0.6, mio::SimulationTime<ScalarType>(20.));
 
     //EXERCISE: Please create a damping that replaces the 10% reduction after 10 days by a 20% reduction. Additionally, add a damping after 40 days that increases the contact rate by 50%.
 
-    // Again, we start with 0.5% of the population initially in `Exposed` and 0.5% initially in `InfectedNoSymptoms` while the remaining 99% is `Susceptible`.
+    // Again, we start with 0.5% of the population initially in `Exposed` and 0.5% initially in `InfectedNoSymptoms`
+    // while the remaining 99% is `Susceptible`.
     model.populations[{mio::AgeGroup(0), mio::osecir::InfectionState::Exposed}]            = 0.005 * total_population;
     model.populations[{mio::AgeGroup(0), mio::osecir::InfectionState::InfectedNoSymptoms}] = 0.005 * total_population;
     model.populations.set_difference_from_total({mio::AgeGroup(0), mio::osecir::InfectionState::Susceptible},

cpp-tutorials/exercises/exercise07.cpp

@@ -8,24 +8,31 @@
 
 int main()
 {
-    // In the previous tutorials, we saw how to set up and run an age-resolved ODE-based SECIR-type model. However, one limiting assumption of simple ODE-based models is the assumption of homogenous mixing within the population. To overcome this limitation and incorporate spatial heterogeneity, in this example we show how to use MEmilio's graph-based metapopulation model. This model realizes mobility between regions via graph edges, while every region is represented by a graph node containing it's own ODE-based model.
+    // In the previous tutorials, we saw how to set up and run an age-resolved ODE-based SECIR-type model.
+    // However, one limiting assumption of simple ODE-based models is the assumption of homogenous mixing within
+    // the population. To overcome this limitation and incorporate spatial heterogeneity, in this example we show
+    // how to use MEmilio's graph-based metapopulation model. This model realizes mobility between regions via
+    // graph edges, while every region is represented by a graph node containing it's own ODE-based model.
 
     // *** Set up model. ***
     // We set the simulation start time `t0`, the end time `tmax` and the initial step size `dt` as:
     ScalarType t0   = 0;
     ScalarType tmax = 100;
     ScalarType dt   = 0.1;
 
-    // Next, we need to specify the parameters. We will initialize a metapopulation model with two regions. The total population as well as the epidemiological parameters will be the same for both regions.
+    // Next, we need to specify the parameters. We will initialize a metapopulation model with two regions.
+    // The total population as well as the epidemiological parameters will be the same for both regions.
     ScalarType total_population_per_region = 100000;
 
     // We use a model with three age groups for both regions:
     size_t num_agegroups = 3;
     // Create model with three age groups
     mio::osecir::Model<ScalarType> model(num_agegroups);
 
-    // Now, we have to set the epidemiological model parameters which are dependent on age group. A list of all parameters can be found at https://memilio.readthedocs.io/en/latest/cpp/models/osecir.html.
-    // We choose an increasing risk of severe and critical infections for age group 2 and 3 compared to age group 1. The other parameters are equal for all age groups.
+    // Now, we have to set the epidemiological model parameters which are dependent on age group. A list of all
+    // parameters can be found at https://memilio.readthedocs.io/en/latest/cpp/models/osecir.html.
+    // We choose an increasing risk of severe and critical infections for age group 2 and 3 compared to age group 1.
+    // The other parameters are equal for all age groups.
 
     for (size_t i = 0; i < num_agegroups; i++) {
         // Set infection state stay times (in days)
@@ -65,7 +72,11 @@ int main()
     auto model_region1 = model;
     auto model_region2 = model;
 
-    // In the graph-based metapopulation model, every graph node gets it's own ODE-based model which is copied when adding a graph node and handing the model to it as parameter. Therefore we can choose different initial conditions (as well as differing parameters) for different graph nodes. In our example, we simulate two regions with only one region having initially infected individuals. We choose 1% initially infected for that region while the other region starts with a totally susceptible population.
+    // In the graph-based metapopulation model, every graph node gets it's own ODE-based model which is copied when
+    // adding a graph node and handing the model to it as parameter. Therefore we can choose different initial conditions
+    // (as well as differing parameters) for different graph nodes. In our example, we simulate two regions with only one
+    // region having initially infected individuals. We choose 1% initially infected for that region while the other
+    // region starts with a totally susceptible population.
     // The model compartments for the first node are initialized via:
     for (size_t i = 0; i < num_agegroups; i++) {
         model_region1.populations[{mio::AgeGroup(i), mio::osecir::InfectionState::Exposed}] =
@@ -86,9 +97,11 @@ int main()
     graph.add_node(0, model_region1, t0, dt);
 
     //EXERCISE: Please add the second node to the graph.
-
-    // If we would simulate the graph-based metapopulation model now, we would just have two independent ODE-based SECIR-type models running with different initial conditions. In reality, there is usually exchange between regions through individuals travelling or commuting from one region to another. This can be realized via graph edges.
-    // We here use a symmetric mobility i.e. we have the same number of individuals that travel from node 0 to node 1 as vice versa. We let 10% of the population commute via the edges twice a day.
+    // If we would simulate the graph-based metapopulation model now, we would just have two independent ODE-based
+    // SECIR-type models running with different initial conditions. In reality, there is usually exchange between
+    // regions through individuals travelling or commuting from one region to another. This can be realized via graph edges.
+    // We here use a symmetric mobility i.e. we have the same number of individuals that travel from node 0 to node 1
+    // as vice versa. We let 10% of the population commute via the edges twice a day.
     graph.add_edge(
         0, 1, Eigen::VectorX<ScalarType>::Constant((size_t)mio::osecir::InfectionState::Count * num_agegroups, 0.1));
 

cpp-tutorials/exercises/exercise10.cpp

@@ -12,10 +12,10 @@
 //
 // Large-scale studies, such as the POLYMOD project, have measured social contact patterns across different
 // locations (like home, school, work, and others) in various countries. For instance, see
-//   Mossong J, Hens N, Jit M, Beutels P, Auranen K, et al. (2008) Social Contacts and Mixing Patterns Relevant to the Spread of Infectious Diseases.
-//               PLoS Med 5(3): e74. https://doi.org/10.1371/journal.pmed.0050074
-//   Prem K, Cook AR, Jit M (2017) Projecting social contact matrices in 152 countries using contact surveys and demographic data.
-//               PLoS Comput Biol 13(9): e1005697. https://doi.org/10.1371/journal.pcbi.1005697
+//   Mossong J, Hens N, Jit M, Beutels P, Auranen K, et al. (2008) Social Contacts and Mixing Patterns Relevant to
+//               the Spread of Infectious Diseases. PLoS Med 5(3): e74. https://doi.org/10.1371/journal.pmed.0050074
+//   Prem K, Cook AR, Jit M (2017) Projecting social contact matrices in 152 countries using contact surveys and
+//               demographic data. PLoS Comput Biol 13(9): e1005697. https://doi.org/10.1371/journal.pcbi.1005697
 //
 // In this tutorial, we extend the approach from Tutorial 3 by splitting the contact matrix into
 // location-specific contact matrices using ContactMatrixGroup. This allows us to apply NPIs to individual

cpp-tutorials/exercises/exercise_ide.cpp

@@ -81,7 +81,7 @@ int main()
     // After having initialized the model, we now set the epidemiological parameters.
     // We start with setting the transition distributions between the InfectionStates. With this, we define the times
     // individuals spend on average in the respective InfectionStates.
-    // We start by defining a SmootherCosine object that is defined by an initial distribtion parameter.
+    // We start by defining a SmootherCosine object that is defined by an initial distribution parameter.
     mio::SmootherCosine<ScalarType> smoothcos(4.0);
     // This is passed to a StateAgeFunctionWrapper object which is the type of oject used within the model to allow
     // for variable transition distributions.