Adding DistanceToInfectionProbability into the tranmission model.

PiperOrigin-RevId: 322425960

Author: groeney

agent_based_epidemic_sim/applications/contact_tracing/graph_location.cc

@@ -52,17 +52,13 @@ class GraphLocation : public Location {
       auto second_infectivity = infectivity.find(edge.second);
       if (second_infectivity == infectivity.end()) continue;
 
-      // Generate a random proximity measure.
-      float proximity = absl::Uniform(gen_, 0.0, 100.0);
-
       // Note that we do not report times or durations.  A visit either occurs
       // on a given day or not.
       infection_broker->Send(
           {{
                .agent_uuid = edge.first,
                .exposure =
                    {
-                       .proximity = proximity,
                        .infectivity = second_infectivity->second,
                    },
                .exposure_type = InfectionOutcomeProto::CONTACT,
@@ -72,7 +68,6 @@ class GraphLocation : public Location {
                .agent_uuid = edge.second,
                .exposure =
                    {
-                       .proximity = proximity,
                        .infectivity = first_infectivity->second,
                    },
                .exposure_type = InfectionOutcomeProto::CONTACT,

agent_based_epidemic_sim/core/BUILD

@@ -145,6 +145,7 @@ cc_library(
     deps = [
         ":integral_types",
         ":visit",
+        "//agent_based_epidemic_sim/util:ostream_overload",
         "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:variant",
@@ -310,6 +311,12 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "constants",
+    hdrs = ["constants.h"],
+    deps = [":integral_types"],
+)
+
 cc_library(
     name = "seir_agent",
     srcs = [
@@ -321,6 +328,8 @@ cc_library(
     deps = [
         ":agent",
         ":broker",
+        ":constants",
+        ":enum_indexed_array",
         ":event",
         ":integral_types",
         ":public_policy",
@@ -329,6 +338,7 @@ cc_library(
         ":visit",
         ":visit_generator",
         "//agent_based_epidemic_sim/port:logging",
+        "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:span",
@@ -340,6 +350,7 @@ cc_test(
     srcs = ["seir_agent_test.cc"],
     deps = [
         ":broker",
+        ":constants",
         ":integral_types",
         ":public_policy",
         ":seir_agent",

agent_based_epidemic_sim/core/aggregated_transmission_model.cc

@@ -22,6 +22,28 @@ namespace {
 constexpr float kSusceptibility = 1;
 constexpr double kEpsilon = 1e-8;
 
+// Used as a constant when computing a distance to infection probability.
+// Details in (broken link).
+constexpr float kDistanceInfectionProbabilityS = 1.5;
+
+// Used as a constant when computing a distance to infection probability.
+// Details in (broken link).
+constexpr float kDistanceInfectionProbabilityB = 6.6;
+
+constexpr std::array<float, kNumberMicroExposureBuckets> kIndexToMeters = {
+    0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5};
+
+float DistanceToInfectionProbability(float distance) {
+  // Infectiousness is defined as a sigmoid curve that starts at 100% at 0
+  // distance, is 50% at 4 meters, and is 0% at 10 meters. These values are
+  // estimated heuristically.
+  return 1 - 1 / (1 + std::exp(-kDistanceInfectionProbabilityS * distance +
+                               kDistanceInfectionProbabilityB));
+}
+
+// Returns distance in meters as a function of MicroExposure bucket index.
+float ExtractDistanceFromIndex(size_t index) { return kIndexToMeters[index]; }
+
 float ProbabilityExposureInfects(const Exposure& exposure,
                                  const float transmissibility) {
   return std::log(1 -

agent_based_epidemic_sim/core/constants.h

@@ -0,0 +1,23 @@
+#ifndef AGENT_BASED_EPIDEMIC_SIM_CORE_CONSTANTS_H_
+#define AGENT_BASED_EPIDEMIC_SIM_CORE_CONSTANTS_H_
+
+#include <array>
+
+#include "base/integral_types.h"
+
+namespace abesim {
+inline const uint8 kMaxDaysAfterInfection = 14;
+
+// This table maps days since infection to an infectivity factor. It is computed
+// using a Gamma CDF distribution and the parameters are defined in
+// (broken link).
+inline const std::array<float, kMaxDaysAfterInfection + 1> kInfectivityArray = {
+    0.9706490058950823,    1.7351078930710577,    1.2019044766404108,
+    0.6227475415319733,    0.2804915619270876,    0.1163222813140352,
+    0.04568182435881363,   0.017259874839000156,  0.006335824965724157,
+    0.002274361283270409,  0.0008019921659041529, 0.00027871327592632333,
+    0.0000956941785834608, 0.0000325214311858168, 0};
+
+}  // namespace abesim
+
+#endif  // AGENT_BASED_EPIDEMIC_SIM_CORE_CONSTANTS_H_

agent_based_epidemic_sim/core/event.h

@@ -23,9 +23,12 @@
 #include "absl/types/variant.h"
 #include "agent_based_epidemic_sim/core/integral_types.h"
 #include "agent_based_epidemic_sim/core/visit.h"
+#include "agent_based_epidemic_sim/util/ostream_overload.h"
 
 namespace abesim {
 
+inline constexpr uint8 kNumberMicroExposureBuckets = 10;
+
 // An event representing a HealthState transition.
 struct HealthTransition {
   absl::Time time;
@@ -49,17 +52,23 @@ struct HealthTransition {
 static_assert(absl::is_trivially_copy_constructible<HealthTransition>::value,
               "HealthTransition must be trivially copyable.");
 
-// Represents an exposure of a SUSCEPTIBLE to an INFECTIOUS entity (contact,
-// fomite, location etc.) with a given infectivity.
+OVERLOAD_ARRAY_OSTREAM_OPS
+
+// Represents multiple "micro" exposures between a SUSCEPTIBLE and an INFECTIOUS
+// entity at different durations and distances (contact, fomite, location etc.)
+// with a constant infectivity and symptom_factor representing the infectivity
+// and symptom_factor of the infected individual.
 struct Exposure {
   absl::Time start_time;
   absl::Duration duration;
-  float proximity;
+  std::array<uint8, kNumberMicroExposureBuckets> micro_exposure_counts = {};
   float infectivity;
+  float symptom_factor;
 
   friend bool operator==(const Exposure& a, const Exposure& b) {
     return (a.start_time == b.start_time && a.duration == b.duration &&
-            a.infectivity == b.infectivity);
+            a.infectivity == b.infectivity &&
+            a.micro_exposure_counts == b.micro_exposure_counts);
   }
 
   friend bool operator!=(const Exposure& a, const Exposure& b) {
@@ -69,7 +78,8 @@ struct Exposure {
   friend std::ostream& operator<<(std::ostream& strm,
                                   const Exposure& exposure) {
     return strm << "{" << exposure.start_time << ", " << exposure.duration
-                << ", " << exposure.infectivity << "}";
+                << ", " << exposure.infectivity << ", "
+                << exposure.micro_exposure_counts << "}";
   }
 };
 

agent_based_epidemic_sim/core/location_discrete_event_simulator.cc

@@ -25,10 +25,6 @@ namespace {
 
 // TODO: Move  into an event message about visiting infectious agents.
 constexpr float kInfectivity = 1;
-constexpr float kProximityMin = 0;
-constexpr float kProximityMax = 10;
-
-absl::BitGen bitgen;
 
 // Corresponds to the record of a visiting agent in a location.
 struct VisitNode {
@@ -80,27 +76,48 @@ absl::Duration Overlap(const Visit& a, const Visit& b) {
          std::max(a.start_time, b.start_time);
 }
 
+const std::array<uint8, kNumberMicroExposureBuckets> GenerateMicroExposures(
+    absl::Duration overlap) {
+  std::array<uint8, kNumberMicroExposureBuckets> micro_exposure_counts = {};
+
+  // TODO: Use a distribution of duration@distance once it is
+  // figured out.
+  // Generate counts for each bucket and never over assign
+  // duration.
+  const uint8 total_counts_to_assign = absl::ToInt64Minutes(overlap);
+
+  if (total_counts_to_assign == 0) return micro_exposure_counts;
+
+  const uint8 buckets_to_fill =
+      std::min(kNumberMicroExposureBuckets, total_counts_to_assign);
+  const uint8 counts_per_bucket = total_counts_to_assign / buckets_to_fill;
+
+  for (auto i = 0; i < buckets_to_fill; i++) {
+    micro_exposure_counts[i] = counts_per_bucket;
+  }
+
+  return micro_exposure_counts;
+}
+
 void RecordContact(VisitNode* a, VisitNode* b) {
-  absl::Duration overlap = Overlap(*a->visit, *b->visit);
-  float proximity = absl::Uniform(bitgen, kProximityMin, kProximityMax);
+  const absl::Duration overlap = Overlap(*a->visit, *b->visit);
+  const std::array<uint8, kNumberMicroExposureBuckets> micro_exposure_counts =
+      GenerateMicroExposures(overlap);
+
   a->contacts.push_back(
       {.other_uuid = b->visit->agent_uuid,
        .other_state = b->visit->health_state,
-       .exposure = {
-           .duration = overlap,
-           .proximity = proximity,
-           .infectivity = b->visit->health_state == HealthState::INFECTIOUS
-                              ? kInfectivity
-                              : 0.0f}});
+       .exposure = {.duration = overlap,
+                    .micro_exposure_counts = micro_exposure_counts,
+                    .infectivity = b->visit->infectivity,
+                    .symptom_factor = b->visit->symptom_factor}});
   b->contacts.push_back(
       {.other_uuid = a->visit->agent_uuid,
        .other_state = a->visit->health_state,
-       .exposure = {
-           .duration = overlap,
-           .proximity = proximity,
-           .infectivity = a->visit->health_state == HealthState::INFECTIOUS
-                              ? kInfectivity
-                              : 0.0f}});
+       .exposure = {.duration = overlap,
+                    .micro_exposure_counts = micro_exposure_counts,
+                    .infectivity = a->visit->infectivity,
+                    .symptom_factor = a->visit->symptom_factor}});
 }
 }  // namespace
 

agent_based_epidemic_sim/core/location_discrete_event_simulator_test.cc

@@ -50,28 +50,36 @@ std::vector<InfectionOutcome> InfectionOutcomesFromContacts(
   return infection_outcomes;
 }
 
+// TODO: Add test coverage of health states ASYMPTOMATIC, MILD,
+// SEVERE.
+// TODO: Test that micro_exposure_counts never over-assigns
+// durations.
 TEST(LocationDiscreteEventSimulatorTest, ContactTracing) {
   const int64 kUuid = 42LL;
   std::vector<Visit> visits{Visit{.location_uuid = 42LL,
                                   .agent_uuid = 0LL,
                                   .start_time = absl::FromUnixSeconds(0LL),
-                                  .end_time = absl::FromUnixSeconds(100LL),
-                                  .health_state = HealthState::INFECTIOUS},
+                                  .end_time = absl::FromUnixSeconds(1000LL),
+                                  .health_state = HealthState::INFECTIOUS,
+                                  .infectivity = 1.0f},
                             Visit{.location_uuid = 42LL,
                                   .agent_uuid = 1LL,
-                                  .start_time = absl::FromUnixSeconds(10LL),
-                                  .end_time = absl::FromUnixSeconds(50LL),
-                                  .health_state = HealthState::SUSCEPTIBLE},
+                                  .start_time = absl::FromUnixSeconds(100LL),
+                                  .end_time = absl::FromUnixSeconds(500LL),
+                                  .health_state = HealthState::SUSCEPTIBLE,
+                                  .infectivity = 0.0f},
                             Visit{.location_uuid = 42LL,
                                   .agent_uuid = 2LL,
-                                  .start_time = absl::FromUnixSeconds(100LL),
-                                  .end_time = absl::FromUnixSeconds(200LL),
-                                  .health_state = HealthState::EXPOSED},
+                                  .start_time = absl::FromUnixSeconds(1000LL),
+                                  .end_time = absl::FromUnixSeconds(2000LL),
+                                  .health_state = HealthState::EXPOSED,
+                                  .infectivity = 0.0f},
                             Visit{.location_uuid = 42LL,
                                   .agent_uuid = 3LL,
-                                  .start_time = absl::FromUnixSeconds(40LL),
-                                  .end_time = absl::FromUnixSeconds(60LL),
-                                  .health_state = HealthState::RECOVERED}};
+                                  .start_time = absl::FromUnixSeconds(400LL),
+                                  .end_time = absl::FromUnixSeconds(600LL),
+                                  .health_state = HealthState::RECOVERED,
+                                  .infectivity = 0.0f}};
 
   std::vector<Contact> contacts;
   MockInfectionBroker infection_broker;
@@ -80,12 +88,18 @@ TEST(LocationDiscreteEventSimulatorTest, ContactTracing) {
         {
             .other_uuid = 1,
             .other_state = HealthState::SUSCEPTIBLE,
-            .exposure = {.duration = absl::Seconds(40), .infectivity = 0.0f},
+            .exposure = {.duration = absl::Seconds(400),
+                         .micro_exposure_counts = {1, 1, 1, 1, 1, 1, 0, 0, 0,
+                                                   0},
+                         .infectivity = 0.0f},
         },
         {
             .other_uuid = 3,
             .other_state = HealthState::RECOVERED,
-            .exposure = {.duration = absl::Seconds(20), .infectivity = 0.0f},
+            .exposure = {.duration = absl::Seconds(200),
+                         .micro_exposure_counts = {1, 1, 1, 0, 0, 0, 0, 0, 0,
+                                                   0},
+                         .infectivity = 0.0f},
         }};
     EXPECT_CALL(infection_broker,
                 Send(UnorderedElementsAreArray(InfectionOutcomesFromContacts(
@@ -97,12 +111,18 @@ TEST(LocationDiscreteEventSimulatorTest, ContactTracing) {
         {
             .other_uuid = 0,
             .other_state = HealthState::INFECTIOUS,
-            .exposure = {.duration = absl::Seconds(40), .infectivity = 1.0f},
+            .exposure = {.duration = absl::Seconds(400),
+                         .micro_exposure_counts = {1, 1, 1, 1, 1, 1, 0, 0, 0,
+                                                   0},
+                         .infectivity = 1.0f},
         },
         {
             .other_uuid = 3,
             .other_state = HealthState::RECOVERED,
-            .exposure = {.duration = absl::Seconds(10), .infectivity = 0.0f},
+            .exposure = {.duration = absl::Seconds(100),
+                         .micro_exposure_counts = {1, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                   0},
+                         .infectivity = 0.0f},
         }};
     EXPECT_CALL(infection_broker,
                 Send(UnorderedElementsAreArray(InfectionOutcomesFromContacts(
@@ -121,12 +141,20 @@ TEST(LocationDiscreteEventSimulatorTest, ContactTracing) {
         {
             .other_uuid = 0,
             .other_state = HealthState::INFECTIOUS,
-            .exposure = {.duration = absl::Seconds(20), .infectivity = 1.0f},
+            .exposure =
+                {
+                    .duration = absl::Seconds(200),
+                    .micro_exposure_counts = {1, 1, 1, 0, 0, 0, 0, 0, 0, 0},
+                    .infectivity = 1.0f,
+                },
         },
         {
             .other_uuid = 1,
             .other_state = HealthState::SUSCEPTIBLE,
-            .exposure = {.duration = absl::Seconds(10), .infectivity = 0.0f},
+            .exposure = {.duration = absl::Seconds(100),
+                         .micro_exposure_counts = {1, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                   0},
+                         .infectivity = 0.0f},
         }};
     EXPECT_CALL(infection_broker,
                 Send(UnorderedElementsAreArray(InfectionOutcomesFromContacts(

agent_based_epidemic_sim/core/pandemic.proto

@@ -60,7 +60,7 @@ message ExposureProto {
   google.protobuf.Timestamp start_time = 1;
   google.protobuf.Duration duration = 2;
   float infectivity = 3;
-  float proximity = 4;
+  repeated fixed32 micro_exposure_counts = 4;
 }
 
 // InfectionOutcomeProto represents a health state change brought about by a