float SusceptibilityVector::BitingRiskAgeFactor(float _age)
{
float risk = 1.0f;
switch(SusceptibilityVectorConfig::age_dependent_biting_risk_type)
{
case AgeDependentBitingRisk::OFF:
// risk is independent by age
break;
case AgeDependentBitingRisk::LINEAR:
risk = LinearBitingFunction(_age);
break;
case AgeDependentBitingRisk::SURFACE_AREA_DEPENDENT:
risk = SurfaceAreaBitingFunction(_age);
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__,
"age_dependent_biting_risk_type", SusceptibilityVectorConfig::age_dependent_biting_risk_type,
AgeDependentBitingRisk::pairs::lookup_key(SusceptibilityVectorConfig::age_dependent_biting_risk_type) );
}
LOG_DEBUG_F("Age-dependent biting-risk = %f for %0.2f-year-old individual.\n", risk, _age/DAYSPERYEAR);
return risk;
}
void Action::CheckConfigurationTriggers()
{
if( m_EventToBroadcast.empty() || (m_EventToBroadcast == JsonConfigurable::default_string) )
{
throw InvalidInputDataException( __FILE__, __LINE__, __FUNCTION__, "You must define Event_To_Broadcast" );
}
switch( m_EventType )
{
case EventType::INDIVIDUAL:
{
m_TriggerIndividual = EventTriggerFactory::GetInstance()->CreateTrigger( "Event_To_Broadcast", m_EventToBroadcast );
break;
}
case EventType::NODE:
{
m_TriggerNode = EventTriggerNodeFactory::GetInstance()->CreateTrigger( "Event_To_Broadcast", m_EventToBroadcast );
break;
}
case EventType::COORDINATOR:
{
m_TriggerCoordinator = EventTriggerCoordinatorFactory::GetInstance()->CreateTrigger( "Event_To_Broadcast", m_EventToBroadcast );
break;
}
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Event_Type", m_EventType, EventType::pairs::lookup_key( m_EventType ) );
}
}
void SimpleVaccine::Update( float dt )
{
// -----------------------------------------------------------------
// --- Still update waning_effect even if the vaccine did not take.
// --- This allows it to expire on schedule.
// -----------------------------------------------------------------
waning_effect->Update(dt);
// ----------------------------------------------------------------------
// --- If the vaccine did not take, do not attempt to update the vaccine
// --- behavior within the individual.
// ----------------------------------------------------------------------
if( vaccine_took )
{
release_assert(ivc);
switch( vaccine_type )
{
case SimpleVaccineType::AcquisitionBlocking:
ivc->UpdateVaccineAcquireRate( waning_effect->Current() );
break;
case SimpleVaccineType::TransmissionBlocking:
ivc->UpdateVaccineTransmitRate( waning_effect->Current() );
break;
case SimpleVaccineType::MortalityBlocking:
ivc->UpdateVaccineMortalityRate( waning_effect->Current() );
break;
case SimpleVaccineType::Generic:
ivc->UpdateVaccineAcquireRate( waning_effect->Current() );
ivc->UpdateVaccineTransmitRate( waning_effect->Current() );
ivc->UpdateVaccineMortalityRate( waning_effect->Current() );
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "vaccine_type", vaccine_type, SimpleVaccineType::pairs::lookup_key( vaccine_type ) );
break;
}
}
if( !expired )
{
expired = waning_effect->Expired();
}
}
void IndividualHumanVector::Expose( const IContagionPopulation* cp, float dt, TransmissionRoute::Enum transmission_route )
{
release_assert( cp );
release_assert( susceptibility );
release_assert( interventions );
#if 1
// get rid of this. but seems to be needed for malaria garki. :( :( :(
if( !vector_interventions )
{
vector_interventions = static_cast<VectorInterventionsContainer*>(interventions);
}
#endif
release_assert( vector_interventions );
float acqmod = GetRelativeBitingRate() * susceptibility->getModAcquire() * interventions->GetInterventionReducedAcquire();
switch( transmission_route )
{
case TransmissionRoute::TRANSMISSIONROUTE_VECTOR_TO_HUMAN_INDOOR:
acqmod *= vector_interventions->GetblockIndoorVectorAcquire();
break;
case TransmissionRoute::TRANSMISSIONROUTE_VECTOR_TO_HUMAN_OUTDOOR:
acqmod *= vector_interventions->GetblockOutdoorVectorAcquire();
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "transmission_route", transmission_route, "Stringified enum value not available" );
}
// Accumulate vector of pairs of strain ids and cumulative infection probability
float infection_probability = cp->GetTotalContagion() * acqmod * dt;
if ( infection_probability > 0 )
{
// Increment total exposure
m_total_exposure += infection_probability;
// With a weighted random draw, pick a strain from the ContagionPopulation CDF
StrainIdentity strain_id;
strain_id.SetAntigenID(cp->GetAntigenId());
cp->ResolveInfectingStrain(&strain_id);
// Push this exposure and strain back to the storage array for all vector-to-human pools (e.g. indoor, outdoor)
m_strain_exposure.push_back( std::make_pair(strain_id, m_total_exposure) );
}
}
// I think we can get rid of this altogether
void
GenericDrug::Update(float dt)
{
if( !BaseIntervention::UpdateIndividualsInterventionStatus() ) return;
switch (durability_time_profile)
{
case PKPDModel::FIXED_DURATION_CONSTANT_EFFECT:
SimpleUpdate(dt);
break;
case PKPDModel::CONCENTRATION_VERSUS_TIME:
UpdateWithPkPd(dt);
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "durability_time_profile", durability_time_profile, PKPDModel::pairs::lookup_key(durability_time_profile) );
}
ApplyEffects();
}
bool ReferenceTrackingEventCoordinatorHIV::qualifiesDemographically( const IIndividualHumanEventContext * pIndividual )
{
bool qualifies = ReferenceTrackingEventCoordinator::qualifiesDemographically( pIndividual );
if( qualifies )
{
IIndividualHumanHIV* p_hiv_individual = nullptr;
if(const_cast<IIndividualHumanEventContext*>(pIndividual)->QueryInterface( GET_IID( IIndividualHumanHIV ), (void**)&p_hiv_individual ) != s_OK)
{
throw QueryInterfaceException( __FILE__, __LINE__, __FUNCTION__, "pIndividual", "IIndividualHumanHIV", "IIndividualHumanEventContext" );
}
IHIVInterventionsContainer* p_hiv_container = p_hiv_individual->GetHIVInterventionsContainer();
IHIVMedicalHistory* p_med_history = nullptr;
if( p_hiv_container->QueryInterface( GET_IID( IHIVMedicalHistory ), (void**)&p_med_history ) != s_OK)
{
throw QueryInterfaceException( __FILE__, __LINE__, __FUNCTION__, "p_hiv_container", "IHIVMedicalHistory", "IHIVInterventionsContainer" );
}
switch( target_disease_state )
{
case TargetDiseaseStateType::Everyone:
qualifies = true;
break;
case TargetDiseaseStateType::HIV_Positive:
qualifies = p_hiv_individual->HasHIV();
break;
case TargetDiseaseStateType::HIV_Negative:
qualifies = !p_hiv_individual->HasHIV();
break;
case TargetDiseaseStateType::Tested_Positive:
qualifies = p_med_history->EverTestedHIVPositive();
break;
case TargetDiseaseStateType::Tested_Negative:
qualifies = p_med_history->EverTested() && !p_med_history->EverTestedHIVPositive();
break;
case TargetDiseaseStateType::Not_Tested_Or_Tested_Negative:
qualifies = !p_med_history->EverTested() || !p_med_history->EverTestedHIVPositive();
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "target_disease_state", target_disease_state );
}
}
return qualifies;
}
float PairFormationParametersImpl::FormationRate( const IdmDateTime& rCurrentTime, float dt ) const
{
float formation_rate = 0.0 ;
switch( formation_rate_type )
{
case FormationRateType::CONSTANT:
formation_rate = formation_rate_constant ;
break;
case FormationRateType::SIGMOID_VARIABLE_WIDTH_HEIGHT:
formation_rate = formation_rate_sigmoid.variableWidthAndHeightSigmoid( rCurrentTime.Year() );
break;
case FormationRateType::INTERPOLATED_VALUES:
formation_rate = formation_rate_value_map.getValueLinearInterpolation( rCurrentTime.Year(), 0.0f );
break;
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Formation_Rate_Type", formation_rate_type );
}
return formation_rate;
}
uint32_t IncidenceCounterSurveillance::GetCountOfQualifyingPopulation( const std::vector<INodeEventContext*>& rNodes )
{
if( (m_PercentageEventsToCountIndividual.size() != 0) ||
(m_PercentageEventsToCountNode.size() != 0) ||
(m_PercentageEventsToCountCoordinator.size() != 0) )
{
return m_PercentageEventsCounted;
}
//Took Dan's methood from https://github.com/Bridenbecker/DtkTrunk/pull/10#discussion_r171112313
// Not finished/tested yet
int count = 0;
switch( m_CounterEventType )
{
case EventType::COORDINATOR:
{
count = 1;
break;
}
case EventType::NODE:
{
for( INodeEventContext* const& inec : rNodes )
{
if( m_NodePropertyRestrictions.Qualifies( inec->GetNodeContext()->GetNodeProperties() ) )
{
++count;
}
}
break;
}
case EventType::INDIVIDUAL:
{
count = IncidenceCounter::GetCountOfQualifyingPopulation( rNodes );
break;
}
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Counter_Event_Type", m_CounterEventType, EventType::pairs::lookup_key( m_CounterEventType ) );
}
return count;
}
bool InputEIR::Configure( const Configuration * inputJson )
{
initConfig( "Age_Dependence", age_dependence, inputJson, MetadataDescriptor::Enum("Age_Dependence", IE_Age_Dependence_DESC_TEXT, MDD_ENUM_ARGS(AgeDependentBitingRisk)) );
initConfigComplexType( "Monthly_EIR", &monthly_EIR, IE_Config_Type_DESC_TEXT);
switch(age_dependence)
{
case AgeDependentBitingRisk::OFF:
risk_function=nullptr;
break;
case AgeDependentBitingRisk::LINEAR:
risk_function = SusceptibilityVector::LinearBitingFunction;
break;
case AgeDependentBitingRisk::SURFACE_AREA_DEPENDENT:
risk_function = SusceptibilityVector::SurfaceAreaBitingFunction;
break;
default:
if( !JsonConfigurable::_dryrun )
{
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__,
"age_dependence", age_dependence,
AgeDependentBitingRisk::pairs::lookup_key(age_dependence) );
}
}
bool configured = BaseNodeIntervention::Configure( inputJson );
if(monthly_EIR.size() != MONTHSPERYEAR && JsonConfigurable::_dryrun == false )
{
throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__,
"'Monthly_EIR' parameterizes the mean number of infectious bites experienced by an individual for each month of the year. As such, it must be an array of EXACTLY length 12." );
}
return configured;
}
void IncidenceCounterSurveillance::CheckConfigurationTriggers()
{
switch( m_CounterEventType )
{
case EventType::INDIVIDUAL:
{
m_TriggerConditionListIndividual = EventTriggerFactory::GetInstance()->CreateTriggerList( "Trigger_Condition_List", m_TriggerConditionList );
break;
}
case EventType::NODE:
{
m_TriggerConditionListNode = EventTriggerNodeFactory::GetInstance()->CreateTriggerList( "Trigger_Condition_List", m_TriggerConditionList );
break;
}
case EventType::COORDINATOR:
{
m_TriggerConditionListCoordinator = EventTriggerCoordinatorFactory::GetInstance()->CreateTriggerList( "Trigger_Condition_List", m_TriggerConditionList );
break;
}
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Counter_Event_Type", m_CounterEventType, EventType::pairs::lookup_key( m_CounterEventType ) );
}
}
void IncidenceCounterSurveillance::SetPercentageEventsToCount( const std::vector<std::string>& rPercentageEvents )
{
switch( m_CounterEventType )
{
case EventType::INDIVIDUAL:
{
m_PercentageEventsToCountIndividual = EventTriggerFactory::GetInstance()->CreateTriggerList( "Percentage_Events_To_Count", rPercentageEvents );
break;
}
case EventType::NODE:
{
m_PercentageEventsToCountNode = EventTriggerNodeFactory::GetInstance()->CreateTriggerList( "Percentage_Events_To_Count", rPercentageEvents );
break;
}
case EventType::COORDINATOR:
{
m_PercentageEventsToCountCoordinator = EventTriggerCoordinatorFactory::GetInstance()->CreateTriggerList( "Percentage_Events_To_Count", rPercentageEvents );
break;
}
default:
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Counter_Event_Type", m_CounterEventType, EventType::pairs::lookup_key( m_CounterEventType ) );
}
}
bool PairFormationParametersImpl::Configure( const Configuration* inputJson )
{
initConfig( "Formation_Rate_Type",
formation_rate_type,
inputJson,
MetadataDescriptor::Enum("Formation_Rate_Type", "TBD"/*Formation_Rate_Type_DESC_TEXT*/, MDD_ENUM_ARGS( FormationRateType ) ) );
if( formation_rate_type == FormationRateType::CONSTANT )
{
initConfigTypeMap( "Formation_Rate_Constant", &formation_rate_constant, "TBD"/*Formation_Rate_DESC_TEXT*/, 0, 1, 0.001f );
}
else if( formation_rate_type == FormationRateType::SIGMOID_VARIABLE_WIDTH_HEIGHT )
{
initConfigTypeMap( "Formation_Rate_Sigmoid", &formation_rate_sigmoid, "TBD"/*Formation_Rate_Sigmoid_DESC_TEXT*/ );
}
else if( formation_rate_type == FormationRateType::INTERPOLATED_VALUES )
{
initConfigComplexType("Formation_Rate_Interpolated_Values", &formation_rate_value_map, "TBD"/*Formation_Rate_Interpolated_Values_DESC_TEXT*/ );
}
else
{
throw BadEnumInSwitchStatementException( __FILE__, __LINE__, __FUNCTION__, "Formation_Rate_Type", formation_rate_type );
}
initConfigTypeMap( "Extra_Relational_Rate_Ratio_Male", &rate_ratio[Gender::MALE ], PFA_Extra_Relational_Rate_Ratio_Male_DESC_TEXT, 1.0, FLT_MAX, 1.0f );
initConfigTypeMap( "Extra_Relational_Rate_Ratio_Female", &rate_ratio[Gender::FEMALE], PFA_Extra_Relational_Rate_Ratio_Female_DESC_TEXT, 1.0, FLT_MAX, 1.0f );
initConfigTypeMap( "Update_Period", &update_period, "TBD"/*Update_Period_DESC_TEXT*/, 0, FLT_MAX, 0 );
initConfigTypeMap( "Number_Age_Bins_Male", &male_age_bin_count, Number_Age_Bins_Male_DESC_TEXT, 1, 1000, 1 );
initConfigTypeMap( "Number_Age_Bins_Female", &female_age_bin_count, Number_Age_Bins_Female_DESC_TEXT, 1, 1000, 1 );
initConfigTypeMap( "Age_of_First_Bin_Edge_Male", &initial_male_age, Age_of_First_Bin_Edge_Male_DESC_TEXT, 0, 100, 1 );
initConfigTypeMap( "Age_of_First_Bin_Edge_Female", &initial_female_age, Age_of_First_Bin_Edge_Female_DESC_TEXT, 0, 100, 1 );
initConfigTypeMap( "Years_Between_Bin_Edges_Male", &male_age_increment, Years_Between_Bin_Edges_Male_DESC_TEXT, 0.1f, 100.0f, 1.0f );
initConfigTypeMap( "Years_Between_Bin_Edges_Female", &female_age_increment, Years_Between_Bin_Edges_Female_DESC_TEXT, 0.1f, 100.0f, 1.0f );
initConfigTypeMap( "Joint_Probabilities", &joint_probabilities, Joint_Probabilities_DESC_TEXT, 0.0, FLT_MAX, 0.0f );
bool ret = false;
bool prev_use_defaults = JsonConfigurable::_useDefaults ;
bool reset_track_missing = JsonConfigurable::_track_missing;
JsonConfigurable::_track_missing = false;
JsonConfigurable::_useDefaults = false ;
try
{
ret = JsonConfigurable::Configure( inputJson );
JsonConfigurable::_useDefaults = prev_use_defaults ;
JsonConfigurable::_track_missing = reset_track_missing;
}
catch( DetailedException& e )
{
JsonConfigurable::_useDefaults = prev_use_defaults ;
JsonConfigurable::_track_missing = reset_track_missing;
std::stringstream ss ;
ss << e.GetMsg() << "\n" << "Was reading values for " << RelationshipType::pairs::lookup_key( rel_type ) << "." ;
throw InvalidInputDataException( __FILE__, __LINE__, __FUNCTION__, ss.str().c_str() );
}
catch( json::Exception& e )
{
JsonConfigurable::_useDefaults = prev_use_defaults ;
JsonConfigurable::_track_missing = reset_track_missing;
std::stringstream ss ;
ss << e.what() << "\n" << "Was reading values for " << RelationshipType::pairs::lookup_key( rel_type ) << "." ;
throw InvalidInputDataException( __FILE__, __LINE__, __FUNCTION__, ss.str().c_str() );
}
if( ret )
{
CheckArraySizes();
InitializeAgeBins( Gender::MALE, male_age_bin_count, initial_male_age, male_age_increment );
InitializeAgeBins( Gender::FEMALE, female_age_bin_count, initial_female_age, female_age_increment );
InitializeMarginalValues();
InitializeCumulativeProbabilities();
}
return ret ;
}
