1039 Add functions for the Person to choose whether to comply to mask,test and isolation

cpp/benchmarks/abm.cpp

@@ -72,7 +72,7 @@ mio::abm::Simulation make_simulation(size_t num_persons, std::initializer_list<u
         //skip homes so persons always have a place to go, simulation might break otherwise
         auto pct_require_mask = 0.2;
         if (loc.get_type() != mio::abm::LocationType::Home &&
-            mio::UniformDistribution<double>::get_instance()(world.get_rng()) < pct_require_mask) {
+            mio::UniformDistribution<double>::get_instance()(model.get_rng()) < pct_require_mask) {
             loc.set_required_mask(mio::abm::MaskType::Community);
         }
     }

cpp/models/abm/intervention_type.h

@@ -33,7 +33,7 @@ namespace abm
  */
 enum class InterventionType : std::uint32_t
 {
-    Mask = 0,
+    Mask,
     Testing,
     Isolation,
 

cpp/models/abm/mask_type.h

@@ -33,7 +33,7 @@ namespace abm
  */
 enum class MaskType : std::uint32_t
 {
-    None = 0,
+    None,
     Community,
     Surgical,
     FFP2,

cpp/models/abm/mobility_data.h

@@ -33,7 +33,7 @@ namespace abm
  */
 enum class TransportMode : uint32_t
 {
-    Bike = 0,
+    Bike,
     CarDriver,
     CarPassenger,
     PublicTransport,
@@ -47,7 +47,7 @@ enum class TransportMode : uint32_t
  */
 enum class ActivityType : uint32_t
 {
-    Workplace = 0,
+    Workplace,
     Education,
     Shopping,
     Leisure,

cpp/models/abm/model.cpp

@@ -98,21 +98,20 @@ void Model::perform_mobility(TimePoint t, TimeSpan dt)
         Person& person    = m_persons[person_id];
         auto personal_rng = PersonalRandomNumberGenerator(m_rng, person);
 
-        auto try_mobility_rule = [&](auto rule) -> bool {
-            //run mobility rule and check if change of location can actually happen
+        auto try_migration_rule = [&](auto rule) -> bool {
+            //run migration rule and check if migration can actually happen
             auto target_type                  = rule(personal_rng, person, t, dt, parameters);
             const Location& target_location   = get_location(find_location(target_type, person_id));
             const LocationId current_location = person.get_location();
 
             // Check if the Person wears mask if required at targeted location
-            if ((target_location.is_mask_required() && person.is_compliant(personal_rng, InterventionType::Mask)) ||
-                !target_location.is_mask_required()) {
+            if (!target_location.is_mask_required() || person.is_compliant(personal_rng, InterventionType::Mask)) {
                 // Check if the capacity of targeted Location is not reached
                 if (target_location.get_id() != current_location &&
                     get_number_persons(target_location.get_id()) < target_location.get_capacity().persons) {
                     // Perform TestingStrategy if required
                     if (m_testing_strategy.run_strategy(personal_rng, person, target_location, t)) {
-                        migrate(person_id, target_location.get_id());
+                        change_location(person_id, target_location.get_id());
                         if (target_location.is_mask_required()) {
                             // If the current MaskProtection level is lower than required, the Person changes mask
                             if (parameters.get<MaskProtection>()[person.get_mask().get_type()] <
@@ -130,26 +129,26 @@ void Model::perform_mobility(TimePoint t, TimeSpan dt)
             return false;
         };
 
-        //run mobility rules one after the other if the corresponding location type exists
+        //run migration rules one after the other if the corresponding location type exists
         //shortcutting of bool operators ensures the rules stop after the first rule is applied
         if (m_use_mobility_rules) {
-            (has_locations({LocationType::Cemetery}) && try_mobility_rule(&get_buried)) ||
-                (has_locations({LocationType::Home}) && try_mobility_rule(&return_home_when_recovered)) ||
-                (has_locations({LocationType::Hospital}) && try_mobility_rule(&go_to_hospital)) ||
-                (has_locations({LocationType::ICU}) && try_mobility_rule(&go_to_icu)) ||
-                (has_locations({LocationType::School, LocationType::Home}) && try_mobility_rule(&go_to_school)) ||
-                (has_locations({LocationType::Work, LocationType::Home}) && try_mobility_rule(&go_to_work)) ||
-                (has_locations({LocationType::BasicsShop, LocationType::Home}) && try_mobility_rule(&go_to_shop)) ||
-                (has_locations({LocationType::SocialEvent, LocationType::Home}) && try_mobility_rule(&go_to_event)) ||
-                (has_locations({LocationType::Home}) && try_mobility_rule(&go_to_quarantine));
+            (has_locations({LocationType::Cemetery}) && try_migration_rule(&get_buried)) ||
+                (has_locations({LocationType::Home}) && try_migration_rule(&return_home_when_recovered)) ||
+                (has_locations({LocationType::Hospital}) && try_migration_rule(&go_to_hospital)) ||
+                (has_locations({LocationType::ICU}) && try_migration_rule(&go_to_icu)) ||
+                (has_locations({LocationType::School, LocationType::Home}) && try_migration_rule(&go_to_school)) ||
+                (has_locations({LocationType::Work, LocationType::Home}) && try_migration_rule(&go_to_work)) ||
+                (has_locations({LocationType::BasicsShop, LocationType::Home}) && try_migration_rule(&go_to_shop)) ||
+                (has_locations({LocationType::SocialEvent, LocationType::Home}) && try_migration_rule(&go_to_event)) ||
+                (has_locations({LocationType::Home}) && try_migration_rule(&go_to_quarantine));
         }
         else {
-            //no daily routine mobility, just infection related
-            (has_locations({LocationType::Cemetery}) && try_mobility_rule(&get_buried)) ||
-                (has_locations({LocationType::Home}) && try_mobility_rule(&return_home_when_recovered)) ||
-                (has_locations({LocationType::Hospital}) && try_mobility_rule(&go_to_hospital)) ||
-                (has_locations({LocationType::ICU}) && try_mobility_rule(&go_to_icu)) ||
-                (has_locations({LocationType::Home}) && try_mobility_rule(&go_to_quarantine));
+            //no daily routine migration, just infection related
+            (has_locations({LocationType::Cemetery}) && try_migration_rule(&get_buried)) ||
+                (has_locations({LocationType::Home}) && try_migration_rule(&return_home_when_recovered)) ||
+                (has_locations({LocationType::Hospital}) && try_migration_rule(&go_to_hospital)) ||
+                (has_locations({LocationType::ICU}) && try_migration_rule(&go_to_icu)) ||
+                (has_locations({LocationType::Home}) && try_migration_rule(&go_to_quarantine));
         }
     }
 
@@ -164,13 +163,12 @@ void Model::perform_mobility(TimePoint t, TimeSpan dt)
             auto& person      = get_person(trip.person_id);
             auto personal_rng = PersonalRandomNumberGenerator(m_rng, person);
             if (!person.is_in_quarantine(t, parameters) && person.get_infection_state(t) != InfectionState::Dead) {
-                auto& target_location = get_location(trip.migration_destination);
+                auto& target_location = get_location(trip.destination);
                 // Check if the Person wears mask if required at targeted location
-                if ((target_location.is_mask_required() && person.is_compliant(personal_rng, InterventionType::Mask)) ||
-                    !target_location.is_mask_required()) {
+                if (!target_location.is_mask_required() || person.is_compliant(personal_rng, InterventionType::Mask)) {
                     // Perform TestingStrategy if required
                     if (m_testing_strategy.run_strategy(personal_rng, person, target_location, t)) {
-                        migrate(person.get_id(), target_location.get_id(), trip.trip_mode);
+                        change_location(person.get_id(), target_location.get_id(), trip.trip_mode);
                         if (target_location.is_mask_required()) {
                             // If the current MaskProtection level is lower than required, the Person changes mask
                             if (parameters.get<MaskProtection>()[person.get_mask().get_type()] <

cpp/models/abm/test_type.h

@@ -33,7 +33,7 @@ namespace abm
  */
 enum class TestType : std::uint32_t
 {
-    Generic = 0,
+    Generic,
     Antigen,
     PCR,
 

cpp/models/abm/testing_strategy.cpp

@@ -177,6 +177,11 @@ bool TestingStrategy::run_strategy(PersonalRandomNumberGenerator& rng, Person& p
         return true;
     }
 
+    // If the Person does not comply to Testing where there is a testing scheme at the target location, it is not allowed to enter.
+    if (!person.is_compliant(rng, InterventionType::Testing)) {
+        return false;
+    }
+
     //lookup schemes for this specific location as well as the location type
     //lookup in std::vector instead of std::map should be much faster unless for large numbers of schemes
     for (auto key : {std::make_pair(location.get_type(), location.get_id()),
@@ -188,10 +193,8 @@ bool TestingStrategy::run_strategy(PersonalRandomNumberGenerator& rng, Person& p
         if (iter_schemes != m_location_to_schemes_map.end()) {
             //apply all testing schemes that are found
             auto& schemes = iter_schemes->schemes;
-            // If the Person does not comply to Testing where there is a testing scheme at the target location, it is not allowed to enter.
-            // Otherwise, whether the Person is allowed to enter or not depends on the test result(s).
-            if (!person.is_compliant(rng, InterventionType::Testing) ||
-                !std::all_of(schemes.begin(), schemes.end(), [&rng, &person, t](TestingScheme& ts) {
+            // Whether the Person is allowed to enter or not depends on the test result(s).
+            if (!std::all_of(schemes.begin(), schemes.end(), [&rng, &person, t](TestingScheme& ts) {
                     return !ts.is_active() || ts.run_scheme(rng, person, t);
                 })) {
                 return false;

cpp/models/abm/vaccine.h

@@ -35,9 +35,9 @@ namespace abm
  */
 enum class ExposureType : std::uint32_t
 {
-    NoProtection     = 0,
-    NaturalInfection = 1,
-    GenericVaccine   = 2,
+    NoProtection,
+    NaturalInfection,
+    GenericVaccine,
     Count //last!!
 };
 

cpp/models/abm/virus_variant.h

@@ -36,7 +36,7 @@ namespace abm
 */
 enum class VirusVariant : std::uint32_t
 {
-    Wildtype = 0,
+    Wildtype,
 
     Count // last!!
 };