diff --git a/cpp/models/ode_secir/model.h b/cpp/models/ode_secir/model.h
index 840845e2ce..ae269a26d1 100755
--- a/cpp/models/ode_secir/model.h
+++ b/cpp/models/ode_secir/model.h
@@ -116,7 +116,8 @@ class Model : public FlowModel<FP, InfectionState, Populations<FP, AgeGroup, Inf
                 //symptomatic are less well quarantined when testing and tracing is overwhelmed so they infect more people
                 auto riskFromInfectedSymptomatic =
                     smoother_cosine(test_and_trace_required, params.template get<TestAndTraceCapacity<FP>>(),
-                                    params.template get<TestAndTraceCapacity<FP>>() * 5,
+                                    params.template get<TestAndTraceCapacity<FP>>() *
+                                        params.template get<TestAndTraceCapacityMaxRisk<FP>>(),
                                     params.template get<RiskOfInfectionFromSymptomatic<FP>>()[j],
                                     params.template get<MaxRiskOfInfectionFromSymptomatic<FP>>()[j]);
 
@@ -454,15 +455,16 @@ IOResult<FP> get_reproduction_number(size_t t_idx, const Simulation<FP, Base>& s
         }
         divN[(size_t)k] = 1 / temp;
 
-        riskFromInfectedSymptomatic[(size_t)k] =
-            smoother_cosine(test_and_trace_required, params.template get<TestAndTraceCapacity<FP>>(),
-                            (params.template get<TestAndTraceCapacity<FP>>()) * 5,
-                            params.template get<RiskOfInfectionFromSymptomatic<FP>>()[k],
-                            params.template get<MaxRiskOfInfectionFromSymptomatic<FP>>()[k]);
+        riskFromInfectedSymptomatic[(size_t)k] = smoother_cosine(
+            test_and_trace_required, params.template get<TestAndTraceCapacity<FP>>(),
+            (params.template get<TestAndTraceCapacity<FP>>()) * params.template get<TestAndTraceCapacityMaxRisk<FP>>(),
+            params.template get<RiskOfInfectionFromSymptomatic<FP>>()[k],
+            params.template get<MaxRiskOfInfectionFromSymptomatic<FP>>()[k]);
 
         for (mio::AgeGroup l = 0; l < (mio::AgeGroup)num_groups; l++) {
             if (test_and_trace_required < params.template get<TestAndTraceCapacity<FP>>() ||
-                test_and_trace_required > 5 * params.template get<TestAndTraceCapacity<FP>>()) {
+                test_and_trace_required > params.template get<TestAndTraceCapacityMaxRisk<FP>>() *
+                                              params.template get<TestAndTraceCapacity<FP>>()) {
                 riskFromInfectedSymptomatic_derivatives((size_t)k, (size_t)l) = 0;
             }
             else {
@@ -661,9 +663,11 @@ auto get_migration_factors(const Simulation<Base>& sim, FP /*t*/, const Eigen::R
     auto test_and_trace_required =
         ((1 - p_asymp) / params.template get<TimeInfectedNoSymptoms<FP>>().array().template cast<FP>() * y_INS.array())
             .sum();
-    auto test_and_trace_capacity     = double(params.template get<TestAndTraceCapacity<FP>>());
-    auto riskFromInfectedSymptomatic = smoother_cosine(test_and_trace_required, test_and_trace_capacity,
-                                                       test_and_trace_capacity * 5, p_inf.matrix(), p_inf_max.matrix());
+    auto test_and_trace_capacity          = double(params.template get<TestAndTraceCapacity<FP>>());
+    auto test_and_trace_capacity_max_risk = double(params.template get<TestAndTraceCapacityMaxRisk<FP>>());
+    auto riskFromInfectedSymptomatic =
+        smoother_cosine(test_and_trace_required, test_and_trace_capacity,
+                        test_and_trace_capacity * test_and_trace_capacity_max_risk, p_inf.matrix(), p_inf_max.matrix());
 
     //set factor for infected
     auto factors = Eigen::VectorXd::Ones(y.rows()).eval();
diff --git a/cpp/models/ode_secir/parameters.h b/cpp/models/ode_secir/parameters.h
index f5951e4571..014a510f93 100644
--- a/cpp/models/ode_secir/parameters.h
+++ b/cpp/models/ode_secir/parameters.h
@@ -348,14 +348,29 @@ struct TestAndTraceCapacity {
     }
 };
 
+/**
+ * @brief Multiplier for the test and trace capacity to determine when it is considered overloaded.
+ */
+template <typename FP = double>
+struct TestAndTraceCapacityMaxRisk {
+    using Type = UncertainValue<FP>;
+    static Type get_default(AgeGroup)
+    {
+        return Type(5.0);
+    }
+    static std::string name()
+    {
+        return "TestAndTraceCapacityMaxRisk";
+    }
+};
+
 template <typename FP = double>
-using ParametersBase =
-    ParameterSet<StartDay, Seasonality<FP>, ICUCapacity<FP>, TestAndTraceCapacity<FP>, ContactPatterns<FP>,
-                 DynamicNPIsInfectedSymptoms<FP>, TimeExposed<FP>, TimeInfectedNoSymptoms<FP>, TimeInfectedSymptoms<FP>,
-                 TimeInfectedSevere<FP>, TimeInfectedCritical<FP>, TransmissionProbabilityOnContact<FP>,
-                 RelativeTransmissionNoSymptoms<FP>, RecoveredPerInfectedNoSymptoms<FP>,
-                 RiskOfInfectionFromSymptomatic<FP>, MaxRiskOfInfectionFromSymptomatic<FP>,
-                 SeverePerInfectedSymptoms<FP>, CriticalPerSevere<FP>, DeathsPerCritical<FP>>;
+using ParametersBase = ParameterSet<
+    StartDay, Seasonality<FP>, ICUCapacity<FP>, TestAndTraceCapacity<FP>, TestAndTraceCapacityMaxRisk<FP>,
+    ContactPatterns<FP>, DynamicNPIsInfectedSymptoms<FP>, TimeExposed<FP>, TimeInfectedNoSymptoms<FP>,
+    TimeInfectedSymptoms<FP>, TimeInfectedSevere<FP>, TimeInfectedCritical<FP>, TransmissionProbabilityOnContact<FP>,
+    RelativeTransmissionNoSymptoms<FP>, RecoveredPerInfectedNoSymptoms<FP>, RiskOfInfectionFromSymptomatic<FP>,
+    MaxRiskOfInfectionFromSymptomatic<FP>, SeverePerInfectedSymptoms<FP>, CriticalPerSevere<FP>, DeathsPerCritical<FP>>;
 
 /**
  * @brief Parameters of an age-resolved SECIR/SECIHURD model.
@@ -445,6 +460,20 @@ class Parameters : public ParametersBase<FP>
             corrected = true;
         }
 
+        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
+            log_warning("Constraint check: Parameter TestAndTraceCapacity changed from {:0.4f} to {:d}",
+                        this->template get<TestAndTraceCapacity<FP>>(), 0);
+            this->template get<TestAndTraceCapacity<FP>>() = 0;
+            corrected                                      = true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRisk<FP>>() < 0.0) {
+            log_warning("Constraint check: Parameter TestAndTraceCapacityMaxRisk changed from {:0.4f} to {:d}",
+                        this->template get<TestAndTraceCapacityMaxRisk<FP>>(), 0);
+            this->template get<TestAndTraceCapacityMaxRisk<FP>>() = 0;
+            corrected                                             = true;
+        }
+
         for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
             if (this->template get<TimeExposed<FP>>()[i] < tol_times) {
                 log_warning("Constraint check: Parameter TimeExposed changed from {:.4f} to {:.4f}. Please "
@@ -567,6 +596,16 @@ class Parameters : public ParametersBase<FP>
             return true;
         }
 
+        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
+            log_error("Constraint check: Parameter TestAndTraceCapacity smaller {:d}", 0);
+            return true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRisk<FP>>() < 0.0) {
+            log_error("Constraint check: Parameter TestAndTraceCapacityMaxRisk smaller {:d}", 0);
+            return true;
+        }
+
         const double tol_times = 1e-1; // accepted tolerance for compartment stays
 
         for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
diff --git a/cpp/models/ode_secirvvs/model.h b/cpp/models/ode_secirvvs/model.h
index 96f8dd2a5d..cff82bf5f6 100644
--- a/cpp/models/ode_secirvvs/model.h
+++ b/cpp/models/ode_secirvvs/model.h
@@ -183,13 +183,15 @@ class Model
             //symptomatic are less well quarantined when testing and tracing is overwhelmed so they infect more people
             auto riskFromInfectedSymptomatic =
                 smoother_cosine(test_and_trace_required, params.template get<TestAndTraceCapacity<FP>>(),
-                                params.template get<TestAndTraceCapacity<FP>>() * 15,
+                                params.template get<TestAndTraceCapacity<FP>>() *
+                                    params.template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>(),
                                 params.template get<RiskOfInfectionFromSymptomatic<FP>>()[i],
                                 params.template get<MaxRiskOfInfectionFromSymptomatic<FP>>()[i]);
 
             auto riskFromInfectedNoSymptoms =
                 smoother_cosine(test_and_trace_required, params.template get<TestAndTraceCapacity<FP>>(),
-                                params.template get<TestAndTraceCapacity<FP>>() * 2,
+                                params.template get<TestAndTraceCapacity<FP>>() *
+                                    params.template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>(),
                                 params.template get<RelativeTransmissionNoSymptoms<FP>>()[i], 1.0);
 
             for (auto j = AgeGroup(0); j < n_agegroups; j++) {
@@ -835,7 +837,9 @@ auto get_migration_factors(const Simulation<Base>& sim, FP /*t*/, const Eigen::R
             .sum();
     auto riskFromInfectedSymptomatic =
         smoother_cosine(test_and_trace_required, double(params.template get<TestAndTraceCapacity<FP>>()),
-                        params.template get<TestAndTraceCapacity<FP>>() * 5, p_inf.matrix(), p_inf_max.matrix());
+                        params.template get<TestAndTraceCapacity<FP>>() *
+                            params.template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>(),
+                        p_inf.matrix(), p_inf_max.matrix());
 
     //set factor for infected
     auto factors = Eigen::VectorXd::Ones(y.rows()).eval();
diff --git a/cpp/models/ode_secirvvs/parameters.h b/cpp/models/ode_secirvvs/parameters.h
index cda7e78d1a..b39f496df1 100644
--- a/cpp/models/ode_secirvvs/parameters.h
+++ b/cpp/models/ode_secirvvs/parameters.h
@@ -119,6 +119,38 @@ struct TestAndTraceCapacity {
     }
 };
 
+/**
+ * @brief Multiplier for the test and trace capacity to determine when it is considered overloaded from cases without symptoms.
+ */
+template <typename FP = double>
+struct TestAndTraceCapacityMaxRiskNoSymptoms {
+    using Type = UncertainValue<FP>;
+    static Type get_default(AgeGroup)
+    {
+        return Type(2.0);
+    }
+    static std::string name()
+    {
+        return "TestAndTraceCapacityMaxRiskNoSymptoms";
+    }
+};
+
+/**
+ * @brief Multiplier for the test and trace capacity to determine when it is considered overloaded by symptomatic cases.
+ */
+template <typename FP = double>
+struct TestAndTraceCapacityMaxRiskSymptoms {
+    using Type = UncertainValue<FP>;
+    static Type get_default(AgeGroup)
+    {
+        return Type(15.0);
+    }
+    static std::string name()
+    {
+        return "TestAndTraceCapacityMaxRiskSymptoms";
+    }
+};
+
 /**
  * @brief the contact patterns within the society are modelled using an UncertainContactMatrix
  */
@@ -573,19 +605,18 @@ struct InfectiousnessNewVariant {
 };
 
 template <typename FP = double>
-using ParametersBase =
-    ParameterSet<StartDay, Seasonality<FP>, ICUCapacity<FP>, TestAndTraceCapacity<FP>, ContactPatterns<FP>,
-                 DynamicNPIsInfectedSymptoms<FP>, TimeExposed<FP>, TimeInfectedNoSymptoms<FP>, TimeInfectedSymptoms<FP>,
-                 TimeInfectedSevere<FP>, TimeInfectedCritical<FP>, TransmissionProbabilityOnContact<FP>,
-                 RelativeTransmissionNoSymptoms<FP>, RecoveredPerInfectedNoSymptoms<FP>,
-                 RiskOfInfectionFromSymptomatic<FP>, MaxRiskOfInfectionFromSymptomatic<FP>,
-                 SeverePerInfectedSymptoms<FP>, CriticalPerSevere<FP>, DeathsPerCritical<FP>, VaccinationGap<FP>,
-                 DaysUntilEffectivePartialImmunity<FP>, DaysUntilEffectiveImprovedImmunity<FP>,
-                 DailyFullVaccination<FP>, DailyFirstVaccination<FP>, ReducExposedPartialImmunity<FP>,
-                 ReducExposedImprovedImmunity<FP>, ReducInfectedSymptomsPartialImmunity<FP>,
-                 ReducInfectedSymptomsImprovedImmunity<FP>, ReducInfectedSevereCriticalDeadPartialImmunity<FP>,
-                 ReducInfectedSevereCriticalDeadImprovedImmunity<FP>, ReducTimeInfectedMild<FP>,
-                 InfectiousnessNewVariant<FP>, StartDayNewVariant>;
+using ParametersBase = ParameterSet<
+    StartDay, Seasonality<FP>, ICUCapacity<FP>, TestAndTraceCapacity<FP>, TestAndTraceCapacityMaxRiskNoSymptoms<FP>,
+    TestAndTraceCapacityMaxRiskSymptoms<FP>, ContactPatterns<FP>, DynamicNPIsInfectedSymptoms<FP>, TimeExposed<FP>,
+    TimeInfectedNoSymptoms<FP>, TimeInfectedSymptoms<FP>, TimeInfectedSevere<FP>, TimeInfectedCritical<FP>,
+    TransmissionProbabilityOnContact<FP>, RelativeTransmissionNoSymptoms<FP>, RecoveredPerInfectedNoSymptoms<FP>,
+    RiskOfInfectionFromSymptomatic<FP>, MaxRiskOfInfectionFromSymptomatic<FP>, SeverePerInfectedSymptoms<FP>,
+    CriticalPerSevere<FP>, DeathsPerCritical<FP>, VaccinationGap<FP>, DaysUntilEffectivePartialImmunity<FP>,
+    DaysUntilEffectiveImprovedImmunity<FP>, DailyFullVaccination<FP>, DailyFirstVaccination<FP>,
+    ReducExposedPartialImmunity<FP>, ReducExposedImprovedImmunity<FP>, ReducInfectedSymptomsPartialImmunity<FP>,
+    ReducInfectedSymptomsImprovedImmunity<FP>, ReducInfectedSevereCriticalDeadPartialImmunity<FP>,
+    ReducInfectedSevereCriticalDeadImprovedImmunity<FP>, ReducTimeInfectedMild<FP>, InfectiousnessNewVariant<FP>,
+    StartDayNewVariant>;
 
 /**
  * @brief Parameters of an age-resolved SECIR/SECIHURD model with paths for partial and improved immunity through vaccination.
@@ -685,6 +716,27 @@ class Parameters : public ParametersBase<FP>
             corrected = true;
         }
 
+        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
+            log_warning("Constraint check: Parameter TestAndTraceCapacity changed from {} to {}",
+                        this->template get<TestAndTraceCapacity<FP>>(), 0);
+            this->template set<TestAndTraceCapacity<FP>>(0);
+            corrected = true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>() < 0.0) {
+            log_warning("Constraint check: Parameter TestAndTraceCapacityMaxRiskSymptoms changed from {} to {}",
+                        this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>(), 0);
+            this->template set<TestAndTraceCapacityMaxRiskSymptoms<FP>>(0);
+            corrected = true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>() < 0.0) {
+            log_warning("Constraint check: Parameter TestAndTraceCapacityMaxRiskNoSymptoms changed from {} to {}",
+                        this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>(), 0);
+            this->template set<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>(0);
+            corrected = true;
+        }
+
         const double tol_times = 1e-1; // accepted tolerance for compartment stays
 
         for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
@@ -789,7 +841,7 @@ class Parameters : public ParametersBase<FP>
             }
 
             if (this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i] < 0.0) {
-                log_warning("Constraint check: Parameter DeathsPerCritical changed from {} to {}",
+                log_warning("Constraint check: Parameter DaysUntilEffectivePartialImmunity changed from {} to {}",
                             this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i], 0);
                 this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i] = 0;
                 corrected                                                      = true;
@@ -877,12 +929,27 @@ class Parameters : public ParametersBase<FP>
     {
         const double tol_times = 1e-1; // accepted tolerance for compartment stays
         if (this->template get<Seasonality<FP>>() < 0.0 || this->template get<Seasonality<FP>>() > 0.5) {
-            log_error("Constraint check: Parameter m_seasonality smaller {} or larger {}", 0, 0.5);
+            log_error("Constraint check: Parameter Seasonality smaller {} or larger {}", 0, 0.5);
             return true;
         }
 
         if (this->template get<ICUCapacity<FP>>() < 0.0) {
-            log_error("Constraint check: Parameter m_icu_capacity smaller {}", 0);
+            log_error("Constraint check: Parameter ICUCapacity smaller {}", 0);
+            return true;
+        }
+
+        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
+            log_error("Constraint check: Parameter TestAndTraceCapacity smaller {}", 0);
+            return true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>() < 0.0) {
+            log_error("Constraint check: Parameter TestAndTraceCapacityMaxRiskSymptoms smaller {}", 0);
+            return true;
+        }
+
+        if (this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>() < 0.0) {
+            log_error("Constraint check: Parameter TestAndTraceCapacityMaxRiskNoSymptoms smaller {}", 0);
             return true;
         }
 
diff --git a/cpp/tests/test_odesecir.cpp b/cpp/tests/test_odesecir.cpp
index c5dc9c3d3e..ef10f5b7ca 100644
--- a/cpp/tests/test_odesecir.cpp
+++ b/cpp/tests/test_odesecir.cpp
@@ -1033,63 +1033,74 @@ TEST(Secir, test_commuters)
 TEST(Secir, check_constraints_parameters)
 {
     auto model = mio::osecir::Model<double>(1);
-    ASSERT_EQ(model.parameters.check_constraints(), 0);
+    EXPECT_EQ(model.parameters.check_constraints(), 0);
 
     mio::set_log_level(mio::LogLevel::off);
     model.parameters.set<mio::osecir::Seasonality<double>>(-0.5);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::Seasonality<double>>(0.2);
     model.parameters.set<mio::osecir::ICUCapacity<double>>(-2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::ICUCapacity<double>>(2);
+    model.parameters.set<mio::osecir::TestAndTraceCapacity<double>>(-1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecir::TestAndTraceCapacity<double>>(1);
+    model.parameters.set<mio::osecir::TestAndTraceCapacityMaxRisk<double>>(-1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecir::TestAndTraceCapacityMaxRisk<double>>(1);
     model.parameters.set<mio::osecir::TimeExposed<double>>(-2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TimeExposed<double>>(2);
     model.parameters.set<mio::osecir::TimeInfectedNoSymptoms<double>>(-1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TimeInfectedNoSymptoms<double>>(5);
     model.parameters.set<mio::osecir::TimeInfectedSymptoms<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TimeInfectedSymptoms<double>>(2);
     model.parameters.set<mio::osecir::TimeInfectedSevere<double>>(-1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TimeInfectedSevere<double>>(2);
     model.parameters.set<mio::osecir::TimeInfectedCritical<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TimeInfectedCritical<double>>(2);
     model.parameters.set<mio::osecir::TransmissionProbabilityOnContact<double>>(2.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::TransmissionProbabilityOnContact<double>>(0.5);
     model.parameters.set<mio::osecir::RelativeTransmissionNoSymptoms<double>>(-1.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::RelativeTransmissionNoSymptoms<double>>(0.5);
     model.parameters.set<mio::osecir::RecoveredPerInfectedNoSymptoms<double>>(3.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::RecoveredPerInfectedNoSymptoms<double>>(0.5);
     model.parameters.set<mio::osecir::RiskOfInfectionFromSymptomatic<double>>(-2.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::RiskOfInfectionFromSymptomatic<double>>(0.5);
     model.parameters.set<mio::osecir::SeverePerInfectedSymptoms<double>>(-1.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::SeverePerInfectedSymptoms<double>>(0.5);
     model.parameters.set<mio::osecir::CriticalPerSevere<double>>(-1.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecir::CriticalPerSevere<double>>(0.5);
     model.parameters.set<mio::osecir::DeathsPerCritical<double>>(1.1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecir::DeathsPerCritical<double>>(0.5);
+    EXPECT_EQ(model.parameters.check_constraints(), 0);
     mio::set_log_level(mio::LogLevel::warn);
 }
 
@@ -1110,6 +1121,14 @@ TEST(Secir, apply_constraints_parameters)
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecir::ICUCapacity<double>>(), 0);
 
+    model.parameters.set<mio::osecir::TestAndTraceCapacity<double>>(-1);
+    EXPECT_EQ(model.parameters.apply_constraints(), 1);
+    EXPECT_EQ(model.parameters.get<mio::osecir::TestAndTraceCapacity<double>>(), 0);
+
+    model.parameters.set<mio::osecir::TestAndTraceCapacityMaxRisk<double>>(-1);
+    EXPECT_EQ(model.parameters.apply_constraints(), 1);
+    EXPECT_EQ(model.parameters.get<mio::osecir::TestAndTraceCapacityMaxRisk<double>>(), 0);
+
     model.parameters.set<mio::osecir::TimeExposed<double>>(-2);
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecir::TimeExposed<double>>()[indx_agegroup], tol_times);
@@ -1158,6 +1177,8 @@ TEST(Secir, apply_constraints_parameters)
     model.parameters.set<mio::osecir::DeathsPerCritical<double>>(1.1);
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecir::DeathsPerCritical<double>>()[indx_agegroup], 0);
+
+    EXPECT_EQ(model.parameters.apply_constraints(), 0);
     mio::set_log_level(mio::LogLevel::warn);
 }
 
diff --git a/cpp/tests/test_odesecirvvs.cpp b/cpp/tests/test_odesecirvvs.cpp
index 14708e7f5c..1e39925276 100644
--- a/cpp/tests/test_odesecirvvs.cpp
+++ b/cpp/tests/test_odesecirvvs.cpp
@@ -973,107 +973,122 @@ TEST(TestOdeSECIRVVS, test_commuters)
 TEST(TestOdeSECIRVVS, check_constraints_parameters)
 {
     auto model = mio::osecirvvs::Model<double>(1);
-    ASSERT_EQ(model.parameters.check_constraints(), 0);
+    EXPECT_EQ(model.parameters.check_constraints(), 0);
 
     mio::set_log_level(mio::LogLevel::off);
     model.parameters.set<mio::osecirvvs::Seasonality<double>>(-0.2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::Seasonality<double>>(0.2);
     model.parameters.set<mio::osecirvvs::ICUCapacity<double>>(-2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ICUCapacity<double>>(2);
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacity<double>>(-1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacity<double>>(1);
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskNoSymptoms<double>>(-1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskNoSymptoms<double>>(1);
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskSymptoms<double>>(-1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskSymptoms<double>>(1);
     model.parameters.set<mio::osecirvvs::TimeExposed<double>>(-2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TimeExposed<double>>(2);
     model.parameters.set<mio::osecirvvs::TimeInfectedNoSymptoms<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TimeInfectedNoSymptoms<double>>(5);
     model.parameters.set<mio::osecirvvs::TimeInfectedSymptoms<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TimeInfectedSymptoms<double>>(2);
     model.parameters.set<mio::osecirvvs::TimeInfectedSevere<double>>(-1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TimeInfectedSevere<double>>(2);
     model.parameters.set<mio::osecirvvs::TimeInfectedCritical<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TimeInfectedCritical<double>>(2);
     model.parameters.set<mio::osecirvvs::TransmissionProbabilityOnContact<double>>(2.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::TransmissionProbabilityOnContact<double>>(0.5);
     model.parameters.set<mio::osecirvvs::RelativeTransmissionNoSymptoms<double>>(-1.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::RelativeTransmissionNoSymptoms<double>>(0.5);
     model.parameters.set<mio::osecirvvs::RecoveredPerInfectedNoSymptoms<double>>(3.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::RecoveredPerInfectedNoSymptoms<double>>(0.5);
     model.parameters.set<mio::osecirvvs::RiskOfInfectionFromSymptomatic<double>>(-0.8);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::RiskOfInfectionFromSymptomatic<double>>(0.5);
     model.parameters.set<mio::osecirvvs::SeverePerInfectedSymptoms<double>>(-0.1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::SeverePerInfectedSymptoms<double>>(0.5);
     model.parameters.set<mio::osecirvvs::CriticalPerSevere<double>>(-1.0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::CriticalPerSevere<double>>(0.5);
     model.parameters.set<mio::osecirvvs::DeathsPerCritical<double>>(1.1);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::DeathsPerCritical<double>>(0.5);
     model.parameters.set<mio::osecirvvs::VaccinationGap<double>>(0.2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::VaccinationGap<double>>(2);
     model.parameters.set<mio::osecirvvs::DaysUntilEffectivePartialImmunity<double>>(-2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::DaysUntilEffectivePartialImmunity<double>>(30);
     model.parameters.set<mio::osecirvvs::DaysUntilEffectiveImprovedImmunity<double>>(-0.2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::DaysUntilEffectiveImprovedImmunity<double>>(30);
     model.parameters.set<mio::osecirvvs::ReducExposedPartialImmunity<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducExposedPartialImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducExposedImprovedImmunity<double>>(-0.2);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducExposedImprovedImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducInfectedSymptomsPartialImmunity<double>>(0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducInfectedSymptomsPartialImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducInfectedSymptomsImprovedImmunity<double>>(0.);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducInfectedSymptomsImprovedImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducInfectedSevereCriticalDeadPartialImmunity<double>>(-4);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducInfectedSevereCriticalDeadPartialImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducInfectedSevereCriticalDeadImprovedImmunity<double>>(-4);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducInfectedSevereCriticalDeadImprovedImmunity<double>>(0.5);
     model.parameters.set<mio::osecirvvs::ReducTimeInfectedMild<double>>(-0);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
 
     model.parameters.set<mio::osecirvvs::ReducTimeInfectedMild<double>>(1);
     model.parameters.set<mio::osecirvvs::InfectiousnessNewVariant<double>>(-4);
-    ASSERT_EQ(model.parameters.check_constraints(), 1);
+    EXPECT_EQ(model.parameters.check_constraints(), 1);
+
+    model.parameters.set<mio::osecirvvs::InfectiousnessNewVariant<double>>(1);
+    EXPECT_EQ(model.parameters.check_constraints(), 0);
 
     mio::set_log_level(mio::LogLevel::warn);
 }
@@ -1095,6 +1110,18 @@ TEST(TestOdeSECIRVVS, apply_constraints_parameters)
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecirvvs::Seasonality<double>>(), 0);
 
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacity<double>>(-1);
+    EXPECT_EQ(model.parameters.apply_constraints(), 1);
+    EXPECT_EQ(model.parameters.get<mio::osecirvvs::TestAndTraceCapacity<double>>(), 0);
+
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskNoSymptoms<double>>(-1);
+    EXPECT_EQ(model.parameters.apply_constraints(), 1);
+    EXPECT_EQ(model.parameters.get<mio::osecirvvs::TestAndTraceCapacityMaxRiskNoSymptoms<double>>(), 0);
+
+    model.parameters.set<mio::osecirvvs::TestAndTraceCapacityMaxRiskSymptoms<double>>(-1);
+    EXPECT_EQ(model.parameters.apply_constraints(), 1);
+    EXPECT_EQ(model.parameters.get<mio::osecirvvs::TestAndTraceCapacityMaxRiskSymptoms<double>>(), 0);
+
     model.parameters.set<mio::osecirvvs::TimeExposed<double>>(-2);
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecirvvs::TimeExposed<double>>()[indx_agegroup], tol_times);
@@ -1192,6 +1219,8 @@ TEST(TestOdeSECIRVVS, apply_constraints_parameters)
     EXPECT_EQ(model.parameters.apply_constraints(), 1);
     EXPECT_EQ(model.parameters.get<mio::osecirvvs::InfectiousnessNewVariant<double>>()[indx_agegroup], 1);
 
+    EXPECT_EQ(model.parameters.apply_constraints(), 0);
+
     mio::set_log_level(mio::LogLevel::warn);
 }