diff --git a/cpp/examples/abm_minimal.cpp b/cpp/examples/abm_minimal.cpp
index 426526c120..1912da6c0e 100644
--- a/cpp/examples/abm_minimal.cpp
+++ b/cpp/examples/abm_minimal.cpp
@@ -41,7 +41,6 @@ int main()
     model.parameters.get<mio::abm::TimeExposedToNoSymptoms>() = mio::ParameterDistributionLogNormal(4., 1.);
 
     // Set the age group the can go to school is AgeGroup(1) (i.e. 5-14)
-    model.parameters.get<mio::abm::AgeGroupGotoSchool>()                    = false;
     model.parameters.get<mio::abm::AgeGroupGotoSchool>()[age_group_5_to_14] = true;
     // Set the age group the can go to work is AgeGroup(2) and AgeGroup(3) (i.e. 15-34 and 35-59)
     model.parameters.get<mio::abm::AgeGroupGotoWork>().set_multiple({age_group_15_to_34, age_group_35_to_59}, true);
diff --git a/cpp/memilio/io/history.h b/cpp/memilio/io/history.h
index 6abe2de15f..762f8b3ba0 100644
--- a/cpp/memilio/io/history.h
+++ b/cpp/memilio/io/history.h
@@ -21,6 +21,7 @@
 #define MIO_IO_HISTORY_H
 
 #include "memilio/utils/metaprogramming.h"
+#include <memory>
 #include <vector>
 #include <tuple>
 
@@ -108,6 +109,19 @@ class History
         return m_data;
     }
 
+    /**
+     * @brief Access the data of the given Logger.
+     * This function only works with Writers that stores its records in a tuple, like DataWriterToMemory.
+     * @return A read-only reference to the Logger's records.
+     */
+    template <class Logger>
+        requires(is_type_in_list_v<Logger, Loggers...> &&
+                 std::tuple_size_v<typename WriteWrapper::Data> == sizeof...(Loggers))
+    const auto& get_log() const
+    {
+        return std::get<index_of_type_v<Logger, Loggers...>>(m_data);
+    }
+
 private:
     typename WriteWrapper::Data m_data;
     std::tuple<Loggers...> m_loggers;
@@ -127,6 +141,35 @@ class History
     }
 };
 
+namespace details
+{
+
+template <class T>
+class AbstractHistory
+{
+public:
+    template <template <class...> class Writer, class... Loggers>
+    AbstractHistory(History<Writer, Loggers...>& history)
+        : m_history(static_cast<void*>(&history), [](void*) {})
+        , m_log([](const std::shared_ptr<void>& h, const T& t) {
+            using H = History<Writer, Loggers...>;
+            static_cast<H*>(h.get())->log(t);
+        })
+    {
+    }
+
+    void log(const T& t)
+    {
+        m_log(m_history, t);
+    }
+
+private:
+    std::shared_ptr<void> m_history; ///< A non-owning pointer to the History.
+    void (*m_log)(const std::shared_ptr<void>&, const T&); ///< Function pointer that stores the
+};
+
+} // namespace details
+
 template <class... Loggers>
 using HistoryWithMemoryWriter = History<DataWriterToMemory, Loggers...>;
 
diff --git a/cpp/memilio/utils/abstract_parameter_distribution.h b/cpp/memilio/utils/abstract_parameter_distribution.h
index 6c30b020c7..d8ff69f91e 100644
--- a/cpp/memilio/utils/abstract_parameter_distribution.h
+++ b/cpp/memilio/utils/abstract_parameter_distribution.h
@@ -27,10 +27,16 @@
 #include "parameter_distributions.h"
 #include <memory>
 #include <string>
+#include <concepts>
 
 namespace mio
 {
 
+template <class T>
+concept HasSampleFunction = requires(T t) {
+    { t.get_sample(std::declval<RandomNumberGenerator&>()) } -> std::convertible_to<ScalarType>;
+};
+
 /**
  * @brief This class represents an arbitrary ParameterDistribution.
  * @see mio::ParameterDistribution
@@ -44,7 +50,7 @@ class AbstractParameterDistribution
      * The implementation handed to the constructor should have get_sample function
      * overloaded with mio::RandomNumberGenerator and mio::abm::PersonalRandomNumberGenerator as input arguments
      */
-    template <class Impl>
+    template <HasSampleFunction Impl>
     AbstractParameterDistribution(Impl&& dist)
         : m_dist(std::make_shared<Impl>(std::move(dist)))
         , sample_impl1([](void* d, RandomNumberGenerator& rng) {
diff --git a/cpp/models/abm/mobility_data.h b/cpp/models/abm/mobility_data.h
index a192589d2a..ec0ec7ac63 100644
--- a/cpp/models/abm/mobility_data.h
+++ b/cpp/models/abm/mobility_data.h
@@ -55,7 +55,8 @@ enum class ActivityType : uint32_t
     PrivateMatters,
     OtherActivity,
     Home,
-    UnknownActivity
+    UnknownActivity,
+    Count //last!!
 };
 
 } // namespace abm
diff --git a/cpp/models/abm/simulation.h b/cpp/models/abm/simulation.h
index 8e6ff52839..06f8b55b52 100644
--- a/cpp/models/abm/simulation.h
+++ b/cpp/models/abm/simulation.h
@@ -23,6 +23,7 @@
 #include "abm/model.h"
 #include "abm/time.h"
 #include "memilio/io/history.h"
+#include <vector>
 
 namespace mio
 {
@@ -77,6 +78,20 @@ class Simulation
         }
     }
 
+    void advance(TimePoint tmax, std::vector<details::AbstractHistory<Simulation>> histories)
+    {
+        //log initial system state
+        for (auto& history : histories) {
+            history.log(*this);
+        }
+        while (m_t < tmax) {
+            evolve_model(tmax);
+            for (auto& history : histories) {
+                history.log(*this);
+            }
+        }
+    }
+
     /**
      * @brief Get the current time of the Simulation.
      */
diff --git a/pycode/examples/simulation/abm_minimal_example.py b/pycode/examples/simulation/abm_minimal_example.py
new file mode 100644
index 0000000000..a397e1a350
--- /dev/null
+++ b/pycode/examples/simulation/abm_minimal_example.py
@@ -0,0 +1,189 @@
+#############################################################################
+# Copyright (C) 2020-2026 MEmilio
+#
+# Authors: Carlotta Gerstein
+#
+# Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#############################################################################
+
+from memilio.simulation import AgeGroup
+import memilio.simulation.abm as abm
+import memilio.simulation as mio
+
+import numpy as np
+import random
+
+num_age_groups = 4
+
+model = abm.Model(num_age_groups)
+
+# Set parameters
+
+for age_group in range(num_age_groups):
+    model.parameters.TimeExposedToNoSymptoms[abm.VirusVariant.Wildtype, AgeGroup(age_group)] = mio.AbstractParameterLogNormalDistribution(mio.ParameterDistributionLogNormal(
+        4., 1.))
+
+model.parameters.AgeGroupGotoSchool[AgeGroup(1)] = True
+model.parameters.AgeGroupGotoWork[AgeGroup(2)] = True
+model.parameters.AgeGroupGotoWork[AgeGroup(3)] = True
+
+for age in range(num_age_groups):
+    model.parameters.InfectionProtectionFactor[abm.ProtectionType.GenericVaccine, AgeGroup(
+        age), abm.VirusVariant.Wildtype] = mio.TimeSeriesFunctor(
+        [[0, 0.0], [14, 0.67], [180, 0.4]])
+
+    model.parameters.SeverityProtectionFactor[abm.ProtectionType.GenericVaccine, AgeGroup(
+        age), abm.VirusVariant.Wildtype] = mio.TimeSeriesFunctor(
+        [[0, 0.0], [14, 0.85], [180, 0.7]])
+
+model.parameters.check_constraints()
+
+# Set populations
+
+n_households = 10
+
+child = abm.HouseholdMember(num_age_groups)
+child.age_weights[AgeGroup(0)] = 1.
+child.age_weights[AgeGroup(1)] = 1.
+
+parent = abm.HouseholdMember(num_age_groups)
+parent.age_weights[AgeGroup(2)] = 1.
+parent.age_weights[AgeGroup(3)] = 1.
+
+twoPersonHousehold_group = abm.HouseholdGroup()
+twoPersonHousehold_full = abm.Household()
+twoPersonHousehold_full.add_members(child, 1)
+twoPersonHousehold_full.add_members(parent, 1)
+twoPersonHousehold_group.add_households(twoPersonHousehold_full, n_households)
+abm.add_household_group_to_model(model, twoPersonHousehold_group)
+
+threePersonHousehold_group = abm.HouseholdGroup()
+threePersonHousehold_full = abm.Household()
+threePersonHousehold_full.add_members(child, 1)
+threePersonHousehold_full.add_members(parent, 2)
+threePersonHousehold_group.add_households(
+    threePersonHousehold_full, n_households)
+abm.add_household_group_to_model(model, threePersonHousehold_group)
+
+# Set locations
+
+event = model.add_location(abm.LocationType.SocialEvent)
+model.get_location(event).infection_parameters.MaximumContacts = 5
+
+hospital = model.add_location(abm.LocationType.Hospital)
+model.get_location(hospital).infection_parameters.MaximumContacts = 5
+icu = model.add_location(abm.LocationType.ICU)
+model.get_location(icu).infection_parameters.MaximumContacts = 5
+
+shop = model.add_location(abm.LocationType.BasicsShop)
+model.get_location(shop).infection_parameters.MaximumContacts = 20
+
+school = model.add_location(abm.LocationType.School)
+model.get_location(school).infection_parameters.MaximumContacts = 20
+
+work = model.add_location(abm.LocationType.Work)
+model.get_location(work).infection_parameters.MaximumContacts = 20
+
+model.parameters.AerosolTransmissionRates[abm.VirusVariant.Wildtype] = 10
+
+contacts = np.zeros((num_age_groups, num_age_groups))
+contacts[2, 3] = 10
+
+model.get_location(
+    work).infection_parameters.ContactRates.baseline = contacts
+
+# Testing Schemes
+
+validity_period = abm.days(1)
+probability = 0.5
+start_date = abm.TimePoint(0)
+end_date = abm.TimePoint(0) + abm.days(10)
+test_type = abm.TestType.Antigen
+test_parameters = model.parameters.TestData[test_type]
+
+testing_criteria_work = abm.TestingCriteria()
+testing_scheme_work = abm.TestingScheme(
+    testing_criteria_work, validity_period, start_date, end_date, test_parameters, probability)
+
+model.testing_strategy.add_scheme(
+    abm.LocationType.Work, testing_scheme_work)
+
+# Seed infections
+
+infection_distribution = [0.5, 0.3, 0.05, 0.05, 0.05, 0.05, 0.0, 0.0]
+for person in model.persons:
+    infection_state = abm.InfectionState(
+        mio.DiscreteDistribution.get_instance()(model.rng, infection_distribution))
+    prng = abm.PersonalRandomNumberGenerator(model.rng, person)
+    if infection_state != abm.InfectionState.Susceptible:
+        person.add_new_infection(mio.abm.Infection(
+            prng, abm.VirusVariant.Wildtype, person.age, model.parameters, start_date, infection_state))
+
+# Assign locations
+
+for person in model.persons:
+    person_id = person.id
+
+    model.assign_location(person_id, event)
+    model.assign_location(person_id, shop)
+
+    model.assign_location(person_id, hospital)
+    model.assign_location(person_id, icu)
+
+    if person.age == AgeGroup(1):
+        model.assign_location(person_id, school)
+
+    if person.age == AgeGroup(2) or person.age == AgeGroup(3):
+        model.assign_location(person_id, work)
+
+# Vaccinations
+
+vacc_rate = 0.7
+vaccination_priority = [AgeGroup(3), AgeGroup(2), AgeGroup(1)]
+vaccination_time = start_date - abm.days(20)
+
+persons_by_age = [[] for _ in range(num_age_groups)]
+for idx, person in enumerate(model.persons):
+    persons_by_age[person.age.get()].append(idx)
+
+for age in vaccination_priority:
+    indices = persons_by_age[age.get()]
+
+    random.shuffle(indices)
+
+    n_to_vaccinate = int(np.round(vacc_rate * len(indices)))
+    for i in range(n_to_vaccinate):
+        person = model.persons[indices[i]]
+        if person.get_infection_state(vaccination_time) == abm.InfectionState.Susceptible:
+            person.add_new_vaccination(
+                abm.ProtectionType.GenericVaccine, vaccination_time)
+
+# Simulate
+
+t_lockdown = start_date + abm.days(10)
+abm.close_social_events(t_lockdown, 0.9, model.parameters)
+
+t0 = start_date
+tmax = t0 + abm.days(10)
+sim = abm.Simulation(t0, model)
+
+
+history = abm.TimeSeriesWriterLogInfectionStateHistory(
+    mio.TimeSeries(len(abm.InfectionState.values())))
+history2 = abm.DataWriterLogDataForMobilityHistory()
+
+sim.advance(tmax, history, history2)
+
+history.get_log()[0].print_table()
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/geography/geolocation.h b/pycode/memilio-simulation/memilio/simulation/bindings/geography/geolocation.h
new file mode 100644
index 0000000000..5008744f91
--- /dev/null
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/geography/geolocation.h
@@ -0,0 +1,41 @@
+/* 
+* Copyright (C) 2020-2026 MEmilio
+*
+* Authors: Carlotta Gerstein
+*
+* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef PYMIO_GEOLOCATION_H
+#define PYMIO_GEOLOCATION_H
+
+#include "memilio/math/integrator.h"
+#include "memilio/geography/geolocation.h"
+#include "pybind_util.h"
+
+#include "pybind11/pybind11.h"
+#include <pybind11/eigen.h>
+
+namespace py = pybind11;
+
+namespace pymio
+{
+
+void bind_geolocation(pybind11::module_& m, std::string const& name)
+{
+    bind_class<mio::geo::GeographicalLocation, EnablePickling::Never>(m, name.c_str()).def(py::init<double, double>());
+}
+} // namespace pymio
+
+#endif //PYMIO_GEOLOCATION_H
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/math/time_series_functor.h b/pycode/memilio-simulation/memilio/simulation/bindings/math/time_series_functor.h
new file mode 100644
index 0000000000..d397e37c8b
--- /dev/null
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/math/time_series_functor.h
@@ -0,0 +1,72 @@
+/* 
+* Copyright (C) 2020-2026 MEmilio
+*
+* Authors: Carlotta Gerstein
+*
+* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef PYMIO_TIME_SERIES_FUNCTOR_H
+#define PYMIO_TIME_SERIES_FUNCTOR_H
+
+#include "memilio/math/time_series_functor.h"
+#include "memilio/math/interpolation.h"
+
+#include "pybind_util.h"
+#include "pybind11/pybind11.h"
+
+namespace py = pybind11;
+
+namespace pymio
+{
+
+void bind_time_series_functor(py::module_& m, std::string const& name)
+{
+    bind_class<mio::TimeSeriesFunctor<double>, EnablePickling::Never>(m, name.c_str())
+        .def(py::init())
+        .def(py::init<mio::TimeSeriesFunctorType, mio::TimeSeries<double>>())
+        .def(py::init([](const mio::TimeSeries<double>& data) {
+            if (data.get_num_time_points() == 0) {
+                throw py::value_error("Need at least one time point for LinearInterpolation.");
+            }
+            if (data.get_num_elements() != 1) {
+                throw py::value_error("LinearInterpolation requires exactly one value per time point.");
+            }
+            if (!data.is_strictly_monotonic()) {
+                throw py::value_error("Time points must be strictly monotonically increasing.");
+            }
+            return mio::TimeSeriesFunctor(mio::TimeSeriesFunctorType::LinearInterpolation, data);
+        }))
+        .def(py::init([](std::vector<std::vector<double>>&& table) {
+            mio::TimeSeries<double> data(std::move(table));
+            if (data.get_num_time_points() == 0) {
+                throw py::value_error("Need at least one time point for LinearInterpolation.");
+            }
+            if (data.get_num_elements() != 1) {
+                throw py::value_error("LinearInterpolation requires exactly one value per time point.");
+            }
+            if (!data.is_strictly_monotonic()) {
+                throw py::value_error("Time points must be strictly monotonically increasing.");
+            }
+            return mio::TimeSeriesFunctor<double>(mio::TimeSeriesFunctorType::LinearInterpolation, data);
+        }))
+        .def("__call__", [](mio::TimeSeriesFunctor<double>& self, double time) {
+            return self(time);
+        });
+}
+
+} // namespace pymio
+
+#endif //PYMIO_TIME_SERIES_FUNCTOR_H
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/models/abm.cpp b/pycode/memilio-simulation/memilio/simulation/bindings/models/abm.cpp
index 289395bf4c..1b3948bcd0 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/models/abm.cpp
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/models/abm.cpp
@@ -27,6 +27,10 @@
 
 //Includes from MEmilio
 #include "abm/simulation.h"
+#include "abm/household.h"
+#include "abm/lockdown_rules.h"
+#include "abm/common_abm_loggers.h"
+#include "memilio/utils/type_list.h"
 
 #include "pybind11/attr.h"
 #include "pybind11/cast.h"
@@ -37,6 +41,60 @@
 
 namespace py = pybind11;
 
+// The history types that are supported in the advance function of the simulation. If a new Logger is added, the corresponding History type has to be added here to be supported in the advance function of the simulation.
+using HistoryTypes = mio::TypeList<mio::History<mio::abm::TimeSeriesWriter, mio::abm::LogInfectionState>,
+                                   mio::History<mio::DataWriterToMemory, mio::abm::LogLocationInformation>,
+                                   mio::History<mio::DataWriterToMemory, mio::abm::LogPersonInformation>,
+                                   mio::History<mio::DataWriterToMemory, mio::abm::LogDataForMobility>>;
+
+mio::details::AbstractHistory<mio::abm::Simulation<mio::abm::Model>> to_abstract_history(py::object obj)
+{
+    std::optional<mio::details::AbstractHistory<mio::abm::Simulation<>>> result;
+    [&]<class... Ts>(mio::TypeList<Ts...>) {
+        (
+            [&]() {
+                if (!result && py::isinstance<Ts>(obj)) {
+                    result = mio::details::AbstractHistory<mio::abm::Simulation<>>(py::cast<Ts&>(obj));
+                }
+            }(),
+            ...);
+        if (!result) {
+            throw pybind11::type_error{};
+        }
+    }(HistoryTypes{});
+    return *result;
+}
+
+template <typename... Loggers>
+void bind_timeserieswriter_history(py::module_& m, const std::string& name)
+{
+    using HistoryType = mio::History<mio::abm::TimeSeriesWriter, Loggers...>;
+
+    pymio::bind_class<HistoryType, pymio::EnablePickling::Never>(m, name)
+        .def(py::init<mio::TimeSeries<double>>())
+        .def(
+            "get_log",
+            [](HistoryType& self) {
+                return self.get_log();
+            },
+            py::return_value_policy::reference_internal);
+}
+
+template <typename... Loggers>
+void bind_datawriter_history(py::module_& m, const std::string& name)
+{
+    using HistoryType = mio::History<mio::DataWriterToMemory, Loggers...>;
+
+    pymio::bind_class<HistoryType, pymio::EnablePickling::Never>(m, name)
+        .def(py::init<>())
+        .def(
+            "get_log",
+            [](HistoryType& self) {
+                return self.get_log();
+            },
+            py::return_value_policy::reference_internal);
+}
+
 PYBIND11_MODULE(_simulation_abm, m)
 {
     pymio::iterable_enum<mio::abm::InfectionState>(m, "InfectionState")
@@ -73,6 +131,25 @@ PYBIND11_MODULE(_simulation_abm, m)
         .value("Antigen", mio::abm::TestType::Antigen)
         .value("PCR", mio::abm::TestType::PCR);
 
+    pymio::iterable_enum<mio::abm::ActivityType>(m, "ActivityType")
+        .value("Workplace", mio::abm::ActivityType::Workplace)
+        .value("Education", mio::abm::ActivityType::Education)
+        .value("Shopping", mio::abm::ActivityType::Shopping)
+        .value("Leisure", mio::abm::ActivityType::Leisure)
+        .value("PrivateMatters", mio::abm::ActivityType::PrivateMatters)
+        .value("OtherActivity", mio::abm::ActivityType::OtherActivity)
+        .value("Home", mio::abm::ActivityType::Home)
+        .value("UnknownActivity", mio::abm::ActivityType::UnknownActivity);
+
+    pymio::iterable_enum<mio::abm::TransportMode>(m, "TransportMode")
+        .value("Unknown", mio::abm::TransportMode::Unknown)
+        .value("Bike", mio::abm::TransportMode::Bike)
+        .value("CarDriver", mio::abm::TransportMode::CarDriver)
+        .value("CarPassenger", mio::abm::TransportMode::CarPassenger)
+        .value("PublicTransport", mio::abm::TransportMode::PublicTransport)
+        .value("Walking", mio::abm::TransportMode::Walking)
+        .value("Other", mio::abm::TransportMode::Other);
+
     pymio::bind_class<mio::abm::TimeSpan, pymio::EnablePickling::Never>(m, "TimeSpan")
         .def(py::init<int>(), py::arg("seconds") = 0)
         .def_property_readonly("seconds", &mio::abm::TimeSpan::seconds)
@@ -127,12 +204,19 @@ PYBIND11_MODULE(_simulation_abm, m)
 
     pymio::bind_CustomIndexArray<mio::UncertainValue<double>, mio::abm::VirusVariant, mio::AgeGroup>(
         m, "_AgeParameterArray");
+    pymio::bind_CustomIndexArray<mio::AbstractParameterDistribution, mio::abm::VirusVariant, mio::AgeGroup>(
+        m, "_DistAgeParameterArray");
+    pymio::bind_CustomIndexArray<bool, mio::AgeGroup>(m, "_boolAgeParameterArray");
+    pymio::bind_CustomIndexArray<int, mio::AgeGroup>(m, "_intAgeParameterArray");
+    pymio::bind_CustomIndexArray<double, mio::abm::VirusVariant>(m, "_doubleVirusVariantArray");
     pymio::bind_CustomIndexArray<mio::abm::TestParameters, mio::abm::TestType>(m, "_TestData");
-    pymio::bind_Index<mio::abm::ProtectionType>(m, "ProtectionTypeIndex");
+    pymio::bind_CustomIndexArray<mio::TimeSeriesFunctor<double>, mio::abm::ProtectionType, mio::AgeGroup,
+                                 mio::abm::VirusVariant>(m, "_ProtectionFactorArray");
     pymio::bind_ParameterSet<mio::abm::ParametersBase, pymio::EnablePickling::Never>(m, "ParametersBase");
     pymio::bind_class<mio::abm::Parameters, pymio::EnablePickling::Never, mio::abm::ParametersBase>(m, "Parameters")
-        .def(py::init<int>())
-        .def("check_constraints", &mio::abm::Parameters::check_constraints);
+        .def(py::init<size_t>())
+        .def("check_constraints", &mio::abm::Parameters::check_constraints)
+        .def_property_readonly("num_age_groups", &mio::abm::Parameters::get_num_groups);
 
     pymio::bind_ParameterSet<mio::abm::LocalInfectionParameters, pymio::EnablePickling::Never>(
         m, "LocalInfectionParameters")
@@ -151,11 +235,19 @@ PYBIND11_MODULE(_simulation_abm, m)
                                           &mio::abm::Person::set_assigned_location))
         .def_property_readonly("location", py::overload_cast<>(&mio::abm::Person::get_location, py::const_))
         .def_property_readonly("age", &mio::abm::Person::get_age)
-        .def_property_readonly("is_in_quarantine", &mio::abm::Person::is_in_quarantine);
+        .def_property_readonly("is_in_quarantine", &mio::abm::Person::is_in_quarantine)
+        .def_property_readonly("id", &mio::abm::Person::get_id)
+        .def("add_new_infection", [](mio::abm::Person& self, mio::abm::Infection infection) {
+            self.add_new_infection(std::move(infection));
+        })
+        .def("add_new_vaccination", &mio::abm::Person::add_new_vaccination)
+        .def("get_infection_state", &mio::abm::Person::get_infection_state)
+        .def_property_readonly("vaccinations", py::overload_cast<>(&mio::abm::Person::get_vaccinations, py::const_));
 
     pymio::bind_class<mio::abm::TestingCriteria, pymio::EnablePickling::Never>(m, "TestingCriteria")
         .def(py::init<const std::vector<mio::AgeGroup>&, const std::vector<mio::abm::InfectionState>&>(),
-             py::arg("age_groups"), py::arg("infection_states"));
+             py::arg("age_groups"), py::arg("infection_states"))
+        .def(py::init<>());
 
     pymio::bind_class<mio::abm::TestingScheme, pymio::EnablePickling::Never>(m, "TestingScheme")
         .def(py::init<const mio::abm::TestingCriteria&, mio::abm::TimeSpan, mio::abm::TimePoint, mio::abm::TimePoint,
@@ -170,9 +262,18 @@ PYBIND11_MODULE(_simulation_abm, m)
 
     pymio::bind_class<mio::abm::TestingStrategy, pymio::EnablePickling::Never>(m, "TestingStrategy")
         .def(py::init<const std::vector<mio::abm::TestingStrategy::LocalStrategy>&,
-                      const std::vector<mio::abm::TestingStrategy::LocalStrategy>&>());
+                      const std::vector<mio::abm::TestingStrategy::LocalStrategy>&>())
+        .def("add_scheme",
+             py::overload_cast<const mio::abm::LocationType&, const mio::abm::TestingScheme&>(
+                 &mio::abm::TestingStrategy::add_scheme),
+             py::arg("location_type"), py::arg("testing_scheme"))
+        .def("add_scheme",
+             py::overload_cast<const mio::abm::LocationId&, const mio::abm::TestingScheme&>(
+                 &mio::abm::TestingStrategy::add_scheme),
+             py::arg("location_id"), py::arg("testing_scheme"));
 
     pymio::bind_class<mio::abm::Location, pymio::EnablePickling::Never>(m, "Location")
+        .def(py::init<mio::abm::LocationType, mio::abm::LocationId>(), py::arg("location_type"), py::arg("loc_id"))
         .def_property_readonly("type", &mio::abm::Location::get_type)
         .def_property_readonly("id", &mio::abm::Location::get_id)
         .def_property("infection_parameters",
@@ -210,6 +311,8 @@ PYBIND11_MODULE(_simulation_abm, m)
                                py::keep_alive<1, 0>{}) //keep this model alive while contents are referenced in ranges
         .def_property_readonly("persons", py::overload_cast<>(&mio::abm::Model::get_persons, py::const_),
                                py::keep_alive<1, 0>{})
+        .def("get_location", py::overload_cast<mio::abm::LocationId>(&mio::abm::Model::get_location),
+             py::arg("location_id"), py::return_value_policy::reference_internal)
         .def_property(
             "trip_list", py::overload_cast<>(&mio::abm::Model::get_trip_list),
             [](mio::abm::Model& self, const mio::abm::TripList& list) {
@@ -224,14 +327,72 @@ PYBIND11_MODULE(_simulation_abm, m)
             [](mio::abm::Model& self, mio::abm::TestingStrategy strategy) {
                 self.get_testing_strategy() = strategy;
             },
-            py::return_value_policy::reference_internal);
+            py::return_value_policy::reference_internal)
+        .def("seed_rng",
+             [](mio::abm::Model& self, std::vector<uint32_t> seeds) {
+                 self.get_rng().seed(seeds);
+             })
+        .def_property_readonly("rng", py::overload_cast<>(&mio::abm::Model::get_rng),
+                               py::return_value_policy::reference_internal);
+
+    auto sim_cls = pymio::bind_class<mio::abm::Simulation<>, pymio::EnablePickling::Never>(m, "Simulation")
+                       .def(py::init<mio::abm::TimePoint, size_t>())
+                       .def(py::init([](mio::abm::TimePoint t, mio::abm::Model model) {
+                                return mio::abm::Simulation(t, std::move(model));
+                            }),
+                            py::return_value_policy::reference_internal)
+                       .def_property_readonly("model", py::overload_cast<>(&mio::abm::Simulation<>::get_model))
+                       .def(
+                           "advance",
+                           [](mio::abm::Simulation<>& sim, mio::abm::TimePoint tmax) {
+                               sim.advance(tmax);
+                           },
+                           py::arg("tmax"))
+                       .def("advance", [](mio::abm::Simulation<>& sim, mio::abm::TimePoint tmax, py::args histories) {
+                           std::vector<mio::details::AbstractHistory<mio::abm::Simulation<>>> abs_histories;
+                           for (auto& value : histories) {
+                               abs_histories.push_back(to_abstract_history(py::cast<py::object>(value)));
+                           }
+                           sim.advance(tmax, abs_histories);
+                       });
+
+    pymio::bind_class<mio::abm::HouseholdMember, pymio::EnablePickling::Never>(m, "HouseholdMember")
+        .def(py::init<size_t>(), py::arg("num_agegroups") = 1)
+        .def_property("age_weights", &mio::abm::HouseholdMember::get_age_weights,
+                      &mio::abm::HouseholdMember::set_age_weight);
+
+    pymio::bind_class<mio::abm::HouseholdGroup, pymio::EnablePickling::Never>(m, "HouseholdGroup")
+        .def(py::init<>())
+        .def("add_households", &mio::abm::HouseholdGroup::add_households)
+        .def_property_readonly("num_households", &mio::abm::HouseholdGroup::get_total_number_of_households);
+
+    pymio::bind_class<mio::abm::Household, pymio::EnablePickling::Never>(m, "Household")
+        .def(py::init<>())
+        .def("add_members", &mio::abm::Household::add_members)
+        .def_property_readonly("num_members", &mio::abm::Household::get_total_number_of_members);
+
+    m.def("add_household_group_to_model", &mio::abm::add_household_group_to_model);
+
+    pymio::bind_class<mio::abm::Infection, pymio::EnablePickling::Never>(m, "Infection")
+        .def(py::init<mio::abm::PersonalRandomNumberGenerator&, mio::abm::VirusVariant, mio::AgeGroup,
+                      mio::abm::Parameters, mio::abm::TimePoint, mio::abm::InfectionState, mio::abm::ProtectionEvent,
+                      bool>(),
+             py::arg("rng"), py::arg("virus"), py::arg("age"), py::arg("params"), py::arg("start_date"),
+             py::arg("start_state") = mio::abm::InfectionState::Exposed,
+             py::arg("latest_protection") =
+                 mio::abm::ProtectionEvent(mio::abm::ProtectionType::NoProtection, mio::abm::TimePoint(0)),
+             py::arg("detected") = false);
+
+    m.def("close_social_events", &mio::abm::close_social_events);
+
+    bind_timeserieswriter_history<mio::abm::LogInfectionState>(m, "TimeSeriesWriterLogInfectionStateHistory");
+    bind_datawriter_history<mio::abm::LogLocationInformation>(m, "DataWriterLogLocationInformationHistory");
+    bind_datawriter_history<mio::abm::LogPersonInformation>(m, "DataWriterLogPersonInformationHistory");
+    bind_datawriter_history<mio::abm::LogDataForMobility>(m, "DataWriterLogDataForMobilityHistory");
 
-    pymio::bind_class<mio::abm::Simulation<>, pymio::EnablePickling::Never>(m, "Simulation")
-        .def(py::init<mio::abm::TimePoint, size_t>())
-        .def("advance",
-             static_cast<void (mio::abm::Simulation<>::*)(mio::abm::TimePoint)>(&mio::abm::Simulation<>::advance),
-             py::arg("tmax"))
-        .def_property_readonly("model", py::overload_cast<>(&mio::abm::Simulation<>::get_model));
+    pymio::bind_class<mio::abm::PersonalRandomNumberGenerator, pymio::EnablePickling::Never>(
+        m, "PersonalRandomNumberGenerator")
+        .def(py::init<const mio::RandomNumberGenerator&, mio::abm::Person&>(), py::arg("model_rng"), py::arg("person"));
 
     m.attr("__version__") = "dev";
 }
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/pybind_util.h b/pycode/memilio-simulation/memilio/simulation/bindings/pybind_util.h
index dc48195817..822ded1839 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/pybind_util.h
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/pybind_util.h
@@ -255,7 +255,7 @@ auto bind_Range(pybind11::module_& m, const std::string& class_name)
         .def(
             "__iter__",
             [](Range& self) {
-                return self;
+                return Iterator{{self.begin(), self.end()}};
             },
             pybind11::keep_alive<1, 0>{}) //keep alive the Range as long as there is an iterator
         .def(
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/simulation.cpp b/pycode/memilio-simulation/memilio/simulation/bindings/simulation.cpp
index 5bb3793ce1..6d84eaffb9 100755
--- a/pycode/memilio-simulation/memilio/simulation/bindings/simulation.cpp
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/simulation.cpp
@@ -28,7 +28,9 @@
 #include "epidemiology/dynamic_npis.h"
 #include "epidemiology/simulation_day.h"
 #include "math/integrator.h"
+#include "math/time_series_functor.h"
 #include "mobility/metapopulation_mobility_instant.h"
+#include "utils/abstract_parameter_distribution.h"
 #include "utils/date.h"
 #include "utils/logging.h"
 #include "utils/time_series.h"
@@ -36,6 +38,8 @@
 #include "utils/uncertain_value.h"
 #include "utils/index.h"
 #include "utils/custom_index_array.h"
+#include "utils/random_number_generator.h"
+#include "geography/geolocation.h"
 
 //Includes from MEmilio
 #include "memilio/mobility/metapopulation_mobility_instant.h"
@@ -53,9 +57,13 @@ PYBIND11_MODULE(_simulation, m)
 {
     pymio::bind_parameter_distribution(m, "ParameterDistribution");
     pymio::bind_parameter_distribution_normal(m, "ParameterDistributionNormal");
+    pymio::bind_parameter_distribution_lognormal(m, "ParameterDistributionLogNormal");
     pymio::bind_parameter_distribution_uniform(m, "ParameterDistributionUniform");
     pymio::bind_uncertain_value(m, "UncertainValue");
 
+    pymio::bind_abstract_parameter_distribution<mio::ParameterDistributionLogNormal>(
+        m, "AbstractParameterLogNormalDistribution");
+
     pymio::bind_CustomIndexArray<mio::UncertainValue<double>, mio::AgeGroup>(m, "AgeGroupArray");
     pymio::bind_class<mio::AgeGroup, pymio::EnablePickling::Required, mio::Index<mio::AgeGroup>>(m, "AgeGroup")
         .def(py::init<size_t>());
@@ -155,5 +163,12 @@ PYBIND11_MODULE(_simulation, m)
         mio::thread_local_rng().seed(mio::RandomNumberGenerator::generate_seeds());
     });
 
+    pymio::bind_random_number_generator(m, "RandomNumberGenerator");
+    pymio::bind_discrete_distribution(m, "DiscreteDistribution");
+
+    pymio::bind_time_series_functor(m, "TimeSeriesFunctor");
+
+    pymio::bind_geolocation(m, "GeographicalLocation");
+
     m.attr("__version__") = "dev";
 }
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/abstract_parameter_distribution.h b/pycode/memilio-simulation/memilio/simulation/bindings/utils/abstract_parameter_distribution.h
new file mode 100644
index 0000000000..6f17a175da
--- /dev/null
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/abstract_parameter_distribution.h
@@ -0,0 +1,45 @@
+/* 
+* Copyright (C) 2020-2026 MEmilio
+*
+* Authors: Carlotta Gerstein
+*
+* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef PYMIO_ABSTRACT_PARAMETER_DISTRIBUTION_H
+#define PYMIO_ABSTRACT_PARAMETER_DISTRIBUTION_H
+
+#include "memilio/utils/abstract_parameter_distribution.h"
+#include "memilio/utils/random_number_generator.h"
+#include "pybind_util.h"
+
+namespace py = pybind11;
+
+namespace pymio
+{
+template <class Dist>
+void bind_abstract_parameter_distribution(py::module_& m, std::string const& name)
+{
+    bind_class<mio::AbstractParameterDistribution, EnablePickling::Never>(m, name.c_str())
+        .def(py::init<Dist>(), py::arg("dist"))
+        .def("get",
+             [](mio::AbstractParameterDistribution& self, mio::RandomNumberGenerator& rng) {
+                 return self.get(rng);
+             })
+        .def("params", &mio::AbstractParameterDistribution::params);
+}
+} // namespace pymio
+
+#endif //PYMIO_ABSTRACT_PARAMETER_DISTRIBUTION_H
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/custom_index_array.h b/pycode/memilio-simulation/memilio/simulation/bindings/utils/custom_index_array.h
index 2fd49f2c3f..694896333f 100755
--- a/pycode/memilio-simulation/memilio/simulation/bindings/utils/custom_index_array.h
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/custom_index_array.h
@@ -231,7 +231,7 @@ void bind_CustomIndexArray(pybind11::module_& m, std::string const& name)
         //scalar assignment
         .def("__setitem__", &assign_scalar<C, Type, Tags...>);
 
-    //scalar assignment with conversion from double
+    // scalar assignment with conversion from double
     if constexpr (std::is_convertible<double, Type>::value) {
         c.def("__setitem__", &assign_scalar<C, double, Tags...>);
     }
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/index.h b/pycode/memilio-simulation/memilio/simulation/bindings/utils/index.h
index cbaf6f8315..3d497cdfc2 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/utils/index.h
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/index.h
@@ -51,6 +51,7 @@ void bind_Index(pybind11::module_& m, std::string const& name)
     c.def(pybind11::init<size_t>(), pybind11::arg("value"));
     c.def(pybind11::self == pybind11::self);
     c.def(pybind11::self != pybind11::self);
+    c.def("get", &mio::Index<Tag>::get);
 
     bind_Index_members_if_enum(c);
 }
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.cpp b/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.cpp
index 28498ddd2a..15abfced48 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.cpp
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.cpp
@@ -51,6 +51,15 @@ void bind_parameter_distribution_normal(py::module_& m, std::string const& name)
                       &mio::ParameterDistributionNormal::set_standard_dev);
 }
 
+void bind_parameter_distribution_lognormal(py::module_& m, std::string const& name)
+{
+    bind_class<mio::ParameterDistributionLogNormal, EnablePickling::IfAvailable, mio::ParameterDistribution>(
+        m, name.c_str())
+        .def(py::init<double, double>(), py::arg("log_mean"), py::arg("log_stddev"))
+        .def_property_readonly("log_mean", &mio::ParameterDistributionLogNormal::get_log_mean)
+        .def_property_readonly("log_standard_dev", &mio::ParameterDistributionLogNormal::get_log_stddev);
+}
+
 void bind_parameter_distribution_uniform(py::module_& m, std::string const& name)
 {
     bind_class<mio::ParameterDistributionUniform, EnablePickling::IfAvailable, mio::ParameterDistribution>(m,
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.h b/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.h
index d82bce8ec4..e516e525c2 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.h
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/parameter_distributions.h
@@ -29,6 +29,8 @@ void bind_parameter_distribution(pybind11::module_& m, std::string const& name);
 
 void bind_parameter_distribution_normal(pybind11::module_& m, std::string const& name);
 
+void bind_parameter_distribution_lognormal(pybind11::module_& m, std::string const& name);
+
 void bind_parameter_distribution_uniform(pybind11::module_& m, std::string const& name);
 
 } // namespace pymio
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/random_number_generator.h b/pycode/memilio-simulation/memilio/simulation/bindings/utils/random_number_generator.h
new file mode 100644
index 0000000000..5fe859fc4c
--- /dev/null
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/random_number_generator.h
@@ -0,0 +1,65 @@
+/* 
+* Copyright (C) 2020-2026 MEmilio
+*
+* Authors: Carlotta Gerstein
+*
+* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef PYMIO_RANDOM_NUMBER_GENERATOR_H
+#define PYMIO_RANDOM_NUMBER_GENERATOR_H
+
+#include "memilio/utils/random_number_generator.h"
+#include "pybind_util.h"
+
+namespace py = pybind11;
+
+namespace pymio
+{
+void bind_random_number_generator(py::module_& m, std::string const& name)
+{
+    bind_class<mio::RandomNumberGenerator, EnablePickling::Never>(m, name.c_str())
+        .def(py::init<>())
+        .def_property_readonly("key",
+                               [](const mio::RandomNumberGenerator& self) {
+                                   return self.get_key().get();
+                               })
+        .def_property(
+            "counter",
+            [](const mio::RandomNumberGenerator& self) {
+                return self.get_counter().get();
+            },
+            [](mio::RandomNumberGenerator& self, uint64_t counter) {
+                self.set_counter(mio::Counter<uint64_t>(counter));
+            })
+        .def_property_readonly("seeds", &mio::RandomNumberGenerator::get_seeds)
+        .def("increment_counter", &mio::RandomNumberGenerator::increment_counter)
+        .def("seed", &mio::RandomNumberGenerator::seed, py::arg("seeds"));
+}
+
+void bind_discrete_distribution(py::module_& m, std::string const& name)
+{
+    bind_class<mio::DiscreteDistribution<int>, EnablePickling::Never>(m, name.c_str())
+        .def_static("get_instance", &mio::DiscreteDistribution<int>::get_instance,
+                    py::return_value_policy::
+                        reference) // Note: reference_internal cannot be used here because this is a static function
+        .def("__call__", [](mio::DiscreteDistribution<int>& self, mio::RandomNumberGenerator& rng,
+                            std::vector<double> distribution) {
+            return self(rng, distribution);
+        });
+}
+} // namespace pymio
+
+#endif //PYMIO_RANDOM_NUMBER_GENERATOR_H
diff --git a/pycode/memilio-simulation/memilio/simulation/bindings/utils/time_series.cpp b/pycode/memilio-simulation/memilio/simulation/bindings/utils/time_series.cpp
index 862d22a72f..59f17b0e0f 100644
--- a/pycode/memilio-simulation/memilio/simulation/bindings/utils/time_series.cpp
+++ b/pycode/memilio-simulation/memilio/simulation/bindings/utils/time_series.cpp
@@ -19,6 +19,7 @@
 */
 #include "utils/time_series.h"
 #include "memilio/utils/time_series.h"
+#include "memilio/math/time_series_functor.h"
 #include "pybind_util.h"
 
 #include <pybind11/pybind11.h>
diff --git a/pycode/memilio-simulation/tests/test_abm.py b/pycode/memilio-simulation/tests/test_abm.py
index eca79085e3..12be51747a 100644
--- a/pycode/memilio-simulation/tests/test_abm.py
+++ b/pycode/memilio-simulation/tests/test_abm.py
@@ -116,6 +116,43 @@ def test_simulation(self):
         t1 = t0 + abm.days(1)
         sim.advance(t1)
 
+    def test_history(self):
+        """ """
+        t0 = abm.TimePoint(0)
+        sim = abm.Simulation(t0, num_age_groups)
+        model = sim.model
+
+        # add some locations and persons
+        home_id = model.add_location(abm.LocationType.Home)
+        social_event_id = model.add_location(abm.LocationType.SocialEvent)
+        work_id = model.add_location(abm.LocationType.Work)
+        p1_id = model.add_person(home_id, mio.AgeGroup(0))
+        p2_id = model.add_person(home_id, mio.AgeGroup(2))
+
+        for loc_id in [home_id, social_event_id, work_id]:
+            model.assign_location(p1_id, loc_id)
+            model.assign_location(p2_id, loc_id)
+
+        # trips
+        trip_list = abm.TripList()
+        trip_list.add_trips(
+            [abm.Trip(abm.PersonId(0), abm.TimePoint(0) + abm.hours(8), social_event_id), abm.Trip(abm.PersonId(1), abm.TimePoint(0) + abm.hours(8), work_id)])
+
+        model.trip_list = trip_list
+        model.use_mobility_rules = False
+        self.assertEqual(model.trip_list.num_trips(), 2)
+
+        # history
+        history = abm.TimeSeriesWriterLogInfectionStateHistory(
+            mio.TimeSeries(len(abm.InfectionState.values())))
+
+        # run
+        t1 = t0 + abm.hours(50)
+        sim.advance(t1, history)
+        log = history.get_log()[0]
+
+        self.assertEqual(log.get_num_time_points(), 51)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/pycode/memilio-simulation/tests/test_distributions.py b/pycode/memilio-simulation/tests/test_distributions.py
index 795f69c6c1..2751d6f8e6 100644
--- a/pycode/memilio-simulation/tests/test_distributions.py
+++ b/pycode/memilio-simulation/tests/test_distributions.py
@@ -47,6 +47,16 @@ def test_normal(self):
         self.assertGreaterEqual(n, -1)
         self.assertLessEqual(n, 1)
 
+    def test_lognormal(self):
+        """ """
+        N = mio.ParameterDistributionLogNormal(0.0, 0.5)
+        # properties
+        self.assertEqual(N.log_mean, 0.0)  # std_dev automatically adapted
+
+        # sample
+        n = N.get_sample()
+        self.assertGreaterEqual(n, 0)
+
     def test_polymorphic(self):
         """ """
         uv = mio.UncertainValue()
diff --git a/pycode/memilio-simulation/tests/test_random_number_generator.py b/pycode/memilio-simulation/tests/test_random_number_generator.py
new file mode 100644
index 0000000000..39be5ac379
--- /dev/null
+++ b/pycode/memilio-simulation/tests/test_random_number_generator.py
@@ -0,0 +1,53 @@
+#############################################################################
+# Copyright (C) 2020-2026 MEmilio
+#
+# Authors: Carlotta Gerstein
+#
+# Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#############################################################################
+import unittest
+
+import memilio.simulation as mio
+
+
+class Test_RandomNumberGenerator(unittest.TestCase):
+    """ """
+
+    def test_advance_counter(self):
+        """ """
+        RNG = mio.RandomNumberGenerator()
+
+        RNG.seed([42])
+        counter = RNG.counter
+
+        mio.DiscreteDistribution.get_instance()(RNG, [0.2, 0.4, 0.3, 0.1])
+        self.assertEqual(counter + 1, RNG.counter)
+
+    def test_discrete_distribution(self):
+        RNG = mio.RandomNumberGenerator()
+
+        sample = mio.DiscreteDistribution.get_instance()(RNG, [1.])
+        self.assertEqual(sample, 0)
+
+        samples = [mio.DiscreteDistribution.get_instance()(
+            RNG, [0.2, 0.4, 0.3, 0.1]) for _ in range(100)]
+
+        for s in samples:
+            self.assertGreaterEqual(s, 0)
+            self.assertLessEqual(s, 3)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pycode/memilio-simulation/tests/test_time_series_functor.py b/pycode/memilio-simulation/tests/test_time_series_functor.py
new file mode 100644
index 0000000000..7bf85b8d44
--- /dev/null
+++ b/pycode/memilio-simulation/tests/test_time_series_functor.py
@@ -0,0 +1,42 @@
+#############################################################################
+# Copyright (C) 2020-2026 MEmilio
+#
+# Authors: Carlotta Gerstein
+#
+# Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#############################################################################
+import unittest
+
+import memilio.simulation as mio
+
+
+class Test_TimeSeriesFunctor(unittest.TestCase):
+    """ """
+
+    def test_timeseries_functor(self):
+        """ """
+        functor = mio.TimeSeriesFunctor([[0, 0.0], [2, 0.67], [4, 0.4]])
+
+        self.assertEqual(functor(0), 0.0)
+        self.assertGreaterEqual(functor(1), 0.0)
+        self.assertLessEqual(functor(1), 0.67)
+        self.assertEqual(functor(2), 0.67)
+        self.assertGreaterEqual(functor(3), 0.4)
+        self.assertLessEqual(functor(3), 0.67)
+        self.assertEqual(functor(4), 0.4)
+
+
+if __name__ == '__main__':
+    unittest.main()