bool CampaignEventByYear::Configure( const Configuration * inputJson ) { if( !JsonConfigurable::_dryrun && #ifdef ENABLE_TYPHOID (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::TYPHOID_SIM) && #endif (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::STI_SIM) && (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::HIV_SIM) ) { throw IllegalOperationException( __FILE__, __LINE__, __FUNCTION__, "CampainEventByYear can only be used in STI and HIV simulations." ); } float start_year; initConfigTypeMap( "Start_Year", &start_year, Start_Year_DESC_TEXT, MIN_YEAR, MAX_YEAR, MIN_YEAR ); initConfigComplexType( "Nodeset_Config", &nodeset_config, Nodeset_Config_DESC_TEXT ); initConfigComplexType( "Event_Coordinator_Config", &event_coordinator_config, Event_Coordinator_Config_DESC_TEXT ); // Bypasss CampaignEvent base class so that we don't break without Start_Day! bool ret = JsonConfigurable::Configure( inputJson ); if( Simulation::base_year > 0 ) { start_day = (start_year - Simulation::base_year) * DAYSPERYEAR; } return ret; }
HIVARTStagingByCD4Diagnostic::HIVARTStagingByCD4Diagnostic() : HIVARTStagingAbstract() { initConfigComplexType("Threshold", &threshold, HIV_ASBCD_Threshold_DESC_TEXT); initConfigComplexType("If_Active_TB", &ifActiveTB, HIV_ASBCD_If_Active_TB_DESC_TEXT); initConfigComplexType("If_Pregnant", &ifPregnant, HIV_ASBCD_If_Pregnant_DESC_TEXT ); }
bool ScaleLarvalHabitat::Configure( const Configuration * inputJson ) { initConfigComplexType( "Larval_Habitat_Multiplier", &m_LHM, SLH_Larval_Habitat_Multiplier_DESC_TEXT ); // Don't call subclass SimpleVectorControlNode::Configure() because it will add cost_per_unit return BaseNodeIntervention::Configure( inputJson ); }
bool ReferenceTrackingEventCoordinator::Configure( const Configuration * inputJson ) { if( !JsonConfigurable::_dryrun && #ifdef ENABLE_TYPHOID (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::TYPHOID_SIM) && #endif (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::STI_SIM) && (GET_CONFIGURABLE( SimulationConfig )->sim_type != SimType::HIV_SIM) ) { throw IllegalOperationException( __FILE__, __LINE__, __FUNCTION__, "ReferenceTrackingEventCoordinator can only be used in STI, HIV, and TYPHOID simulations." ); } float update_period = DAYSPERYEAR; initConfigComplexType("Time_Value_Map", &year2ValueMap, RTEC_Time_Value_Map_DESC_TEXT ); initConfigTypeMap( "Update_Period", &update_period, RTEC_Update_Period_DESC_TEXT, 1.0, 10*DAYSPERYEAR, DAYSPERYEAR ); initConfigTypeMap( "End_Year", &end_year, RTEC_End_Year_DESC_TEXT, MIN_YEAR, MAX_YEAR, MAX_YEAR ); auto ret = StandardInterventionDistributionEventCoordinator::Configure( inputJson ); num_repetitions = -1; // unlimited if( JsonConfigurable::_dryrun == false ) { float dt = GET_CONFIGURABLE(SimulationConfig)->Sim_Tstep; tsteps_between_reps = update_period/dt; // this won't be precise, depending on math. if( tsteps_between_reps <= 0.0 ) { // don't let this be zero or it will only update one time tsteps_between_reps = 1; } } LOG_DEBUG_F( "ReferenceTrackingEventCoordinator configured with update_period = %f, end_year = %f, and tsteps_between_reps (derived) = %d.\n", update_period, end_year, tsteps_between_reps ); return ret; }
bool AbstractBednet::ConfigureBlockingAndKilling( const Configuration * inputJson ) { WaningConfig killing_config; WaningConfig blocking_config; initConfigComplexType( "Killing_Config", &killing_config, SB_Killing_Config_DESC_TEXT ); initConfigComplexType( "Blocking_Config", &blocking_config, SB_Blocking_Config_DESC_TEXT ); bool configured = BaseIntervention::Configure( inputJson ); if( configured && !JsonConfigurable::_dryrun ) { m_pEffectKilling = WaningEffectFactory::CreateInstance( killing_config ); m_pEffectBlocking = WaningEffectFactory::CreateInstance( blocking_config ); } return configured; }
bool DiagnosticTreatNeg::Configure( const Configuration * inputJson ) { EventOrConfig::Enum use_event_or_config; initConfig( "Event_Or_Config", use_event_or_config, inputJson, MetadataDescriptor::Enum("EventOrConfig", Event_Or_Config_DESC_TEXT, MDD_ENUM_ARGS( EventOrConfig ) ) ); if( use_event_or_config == EventOrConfig::Event || JsonConfigurable::_dryrun ) { initConfigTypeMap( "Negative_Diagnosis_Event", &negative_diagnosis_event, DTN_Negative_Diagnosis_Config_Event_DESC_TEXT ); initConfigTypeMap( "Defaulters_Event", &defaulters_event, DTN_Defaulters_Diagnosis_Config_Event_DESC_TEXT ); } if( use_event_or_config == EventOrConfig::Config || JsonConfigurable::_dryrun ) { initConfigComplexType("Negative_Diagnosis_Config", &negative_diagnosis_config, DTN_Negative_Diagnosis_Config_DESC_TEXT, "Event_Or_Config", "Config" ); initConfigComplexType("Defaulters_Config", &defaulters_config, DTN_Defaulters_Diagnosis_Config_DESC_TEXT, "Event_Or_Config", "Config" ); } bool ret = SimpleDiagnostic::Configure( inputJson ); if( ret ) { if( use_event_or_config == EventOrConfig::Config || JsonConfigurable::_dryrun ) { InterventionValidator::ValidateIntervention( negative_diagnosis_config._json ); InterventionValidator::ValidateIntervention( defaulters_config._json ); } if( !JsonConfigurable::_dryrun && negative_diagnosis_event.IsUninitialized() && (negative_diagnosis_config._json.Type() == ElementType::NULL_ELEMENT) ) { const char* msg = "You must define either Negative_Diagnosis_Event or Negative_Diagnosis_Config"; throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, msg ); } if( !JsonConfigurable::_dryrun && defaulters_event.IsUninitialized() && (defaulters_config._json.Type() == ElementType::NULL_ELEMENT) ) { const char* msg = "You must define either Defaulters_Event or Defaulters_Config"; throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, msg ); } } return ret ; }
bool MultiInterventionDistributor::Configure( const Configuration * inputJson ) { initConfigComplexType("Intervention_List", &intervention_list, MID_Intervention_List_DESC_TEXT); bool ret = BaseIntervention::Configure( inputJson ); if( ret ) { InterventionValidator::ValidateInterventionArray( intervention_list._json, inputJson->GetDataLocation() ); } return ret ; }
bool Responder::Configure( const Configuration * inputJson ) { initConfig( "Threshold_Type", m_ThresholdType, inputJson, MetadataDescriptor::Enum( "ThresholdType", ICE_Threshold_Type_DESC_TEXT, MDD_ENUM_ARGS( ThresholdType ) ) ); initConfigComplexType( "Action_List", &m_ActionList, ICE_Action_List_DESC_TEXT ); bool ret = JsonConfigurable::Configure( inputJson ); if( ret && !JsonConfigurable::_dryrun ) { CheckConfiguration( inputJson ); m_ActionList.CheckConfiguration(); } return ret; }
bool SimpleBednet::ConfigureUsage( const Configuration * inputJson ) { WaningConfig usage_config; initConfigComplexType( "Usage_Config", &usage_config, SB_Usage_Config_DESC_TEXT ); bool configured = JsonConfigurable::Configure( inputJson ); // AbstractBednet is responsible for calling BaseIntervention::Configure() if( configured && !JsonConfigurable::_dryrun ) { m_pEffectUsage = WaningEffectFactory::CreateInstance( usage_config ); } return configured; }
bool SimpleHousingModification::Configure( const Configuration * inputJson ) { initConfigComplexType("Killing_Config", &killing_config, HM_Killing_Config_DESC_TEXT ); initConfigComplexType("Blocking_Config", &blocking_config, HM_Blocking_Config_DESC_TEXT ); bool configured = JsonConfigurable::Configure( inputJson ); if( !JsonConfigurable::_dryrun ) { auto tmp_killing = Configuration::CopyFromElement( killing_config._json ); auto tmp_blocking = Configuration::CopyFromElement( blocking_config._json ); killing_effect = WaningEffectFactory::CreateInstance( tmp_killing ); blocking_effect = WaningEffectFactory::CreateInstance( tmp_blocking ); delete tmp_killing; delete tmp_blocking; tmp_killing = nullptr; tmp_blocking = nullptr; } return JsonConfigurable::Configure( inputJson ); }
bool WaningEffectMapAbstract::Configure( const Configuration * pInputJson ) { initConfigTypeMap( "Initial_Effect", &m_EffectCurrent, WEE_Initial_Effect_DESC_TEXT, 0, 1, 1); initConfigTypeMap( "Expire_At_Durability_Map_End", &m_ExpireAtDurationMapEnd, WEM_Expire_At_Durability_Map_End_DESC_TEXT, false ); initConfigComplexType( "Durability_Map", &m_DurationMap, WEM_Durability_Map_End_DESC_TEXT ); bool ret = JsonConfigurable::Configure(pInputJson); if( ret ) { m_EffectOriginal = m_EffectCurrent; } return ret; }
bool IncidenceCounter::Configure( const Configuration * inputJson ) { initConfigTypeMap( "Count_Events_For_Num_Timesteps", &m_CountEventsForNumTimeSteps, ICE_Count_Events_For_Num_Timesteps_DESC_TEXT, 1, INT_MAX, 1 ); initConfigComplexType( "Node_Property_Restrictions", &m_NodePropertyRestrictions, ICE_Node_Property_Restriction_DESC_TEXT ); m_DemographicRestrictions.ConfigureRestrictions( this, inputJson ); ConfigureTriggers( inputJson ); bool ret = JsonConfigurable::Configure( inputJson ); if( ret && !JsonConfigurable::_dryrun ) { m_DemographicRestrictions.CheckConfiguration(); CheckConfigurationTriggers(); } return ret; }
bool CoverageByNodeEventCoordinator::Configure( const Configuration * inputJson ) { initConfigComplexType("Coverage_By_Node", &coverage_by_node, Coverage_By_Node_DESC_TEXT ); bool configured = StandardInterventionDistributionEventCoordinator::Configure(inputJson); try { if( !JsonConfigurable::_dryrun ) { } } catch( const json::Exception &e ) { throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, e.what() ); // ( "Coverage_By_Node json problem: Coverage_By_Node is valid json but needs to be an array of (nodeID,coverage) pairs." ); } return configured; }
bool NodeLevelHealthTriggeredIVScaleUpSwitch::Configure( const Configuration * inputJson ) { initConfig("Demographic_Coverage_Time_Profile", demographic_coverage_time_profile, inputJson, MetadataDescriptor::Enum("Demographic_Coverage_Time_Profile", NodeHTI_Demographic_Coverage_Time_Profile_DESC_TEXT, MDD_ENUM_ARGS(ScaleUpProfile) ) ); if ( demographic_coverage_time_profile == ScaleUpProfile::Linear || JsonConfigurable::_dryrun ) { initConfigTypeMap("Initial_Demographic_Coverage", &initial_demographic_coverage, NodeHTI_Initial_Demographic_Coverage_DESC_TEXT, 0.0f, 1.0f, 0.0f); initConfigTypeMap("Primary_Time_Constant", &primary_time_constant, NodeHTI_Primary_Time_Constant_DESC_TEXT, 0, INFINITE_TIME); //this is actually the time to reach the final demographic coverage, input as absolute days, not number of dts } //this has to be an array rather than a single intervention json so that it can be empty if you don't want to phase anything out initConfigComplexType("Not_Covered_IndividualIntervention_Configs", ¬_covered_intervention_configs, NodeHTI_Not_Covered_IndividualIntervention_Configs_DESC_TEXT); bool ret= NodeLevelHealthTriggeredIV::Configure(inputJson); return ret; }
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; }
bool SimpleVaccine::Configure( const Configuration * inputJson ) { initConfigTypeMap("Vaccine_Take", &vaccine_take, SV_Vaccine_Take_DESC_TEXT, 0.0, 1.0, 1.0 ); initConfig( "Vaccine_Type", vaccine_type, inputJson, MetadataDescriptor::Enum("Vaccine_Type", SV_Vaccine_Type_DESC_TEXT, MDD_ENUM_ARGS(SimpleVaccineType))); initConfigComplexType("Waning_Config", &waning_config, IVM_Killing_Config_DESC_TEXT ); bool configured = JsonConfigurable::Configure( inputJson ); if( !JsonConfigurable::_dryrun ) { auto tmp_waning = Configuration::CopyFromElement( waning_config._json ); waning_effect = WaningEffectFactory::CreateInstance( tmp_waning ); delete tmp_waning; tmp_waning = nullptr; } //release_assert( vaccine_type ); LOG_DEBUG_F( "Vaccine configured with type %d and take %f.\n", vaccine_type, vaccine_take ); return configured; }
bool HIVDelayedIntervention::Configure( const Configuration * inputJson ) { // should be lifted to HIVIntervention class later initConfigTypeMap("Expiration_Period", &days_remaining, HIV_Delayed_Intervention_Expiration_Period_DESC_TEXT, 0, FLT_MAX, FLT_MAX); // DelayedIntervention::Configure split into PreConfigure and MainConfigure to separate initConfig's from initConfigTypeMap-depends-on, and postpone JsonConfigurable::Configure DelayedIntervention::PreConfigure(inputJson); DelayedIntervention::DistributionConfigure(inputJson); // HIVDelayedIntervention specific if( delay_distribution.GetType() == DistributionFunction::PIECEWISE_CONSTANT || delay_distribution.GetType() == DistributionFunction::PIECEWISE_LINEAR || JsonConfigurable::_dryrun ) { initConfigComplexType( "Time_Varying_Constants", &year2DelayMap, HIV_Delayed_Intervention_TVC_DESC_TEXT, "Delay_Distribution", "PIECEWISE_CONSTANT || PIECEWISE_LINEAR" ); } //DelayedIntervention::InterventionConfigure(inputJson); initConfigTypeMap( "Broadcast_Event", &broadcast_event, HIV_Delayed_Intervention_Broadcast_Event_DESC_TEXT ); initConfigTypeMap( "Broadcast_On_Expiration_Event", &broadcast_on_expiration_event, HIV_Delayed_Intervention_Broadcast_On_Expiration_Event_DESC_TEXT ); // skip DelayedIntervention::Configure() because we don't want those variables. bool ret = BaseIntervention::Configure(inputJson); if( ret ) { // don't validate the intervention configuration since not supported DelayValidate(); } LOG_DEBUG_F( "HIVDelayedIntervention configured with days_remaining = %f and remaining_delay_days = %f\n", (float) days_remaining, (float) remaining_delay_days ); return ret ; }
void StandardInterventionDistributionEventCoordinator::initializeInterventionConfig( const Configuration* inputJson ) { initConfigComplexType("Intervention_Config", &intervention_config, Intervention_Config_DESC_TEXT ); }
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 ; }
void MultiInterventionEventCoordinator::initializeInterventionConfig( const Configuration * inputJson ) { initConfigComplexType("Intervention_Configs", &intervention_config, MIEC_Intervention_Configs_DESC_TEXT ); }
bool CommunityHealthWorkerEventCoordinator::Configure( const Configuration * inputJson ) { initConfigTypeMap("Duration", &m_CoordinatorDaysRemaining, CHW_Duration_DESC_TEXT, 0.0f, FLT_MAX, FLT_MAX ); initConfigTypeMap("Max_Distributed_Per_Day", &m_MaxDistributedPerDay, CHW_Max_Distributed_Per_Day_DESC_TEXT, 1, INT_MAX, INT_MAX ); initConfigTypeMap("Waiting_Period", &m_QueueWaitingPeriodDays, CHW_Waiting_Period_DESC_TEXT, 0.0f, FLT_MAX, FLT_MAX ); initConfigTypeMap("Days_Between_Shipments", &m_DaysBetweenShipments, CHW_Days_Between_Shipments_DESC_TEXT, 1.0f, FLT_MAX, FLT_MAX ); initConfigTypeMap("Amount_In_Shipment", &m_AmountInShipment, CHW_Amount_In_Shipment_DESC_TEXT, 0, INT_MAX, INT_MAX ); initConfigTypeMap("Max_Stock", &m_MaxStock, CHW_Max_Stock_DESC_TEXT, 0, INT_MAX, INT_MAX ); DurationDistribution initial_amount; initial_amount.SetTypeNameDesc( "Initial_Amount_Distribution_Type", CHW_Initial_Amount_Distribution_Type_DESC_TEXT ); initial_amount.AddSupportedType( DistributionFunction::FIXED_DURATION, "Initial_Amount", CHW_Initial_Amount_DESC_TEXT, "", "" ); initial_amount.AddSupportedType( DistributionFunction::UNIFORM_DURATION, "Initial_Amount_Min", CHW_Initial_Amount_Min_DESC_TEXT, "Initial_Amount_Max", CHW_Initial_Amount_Max_DESC_TEXT ); initial_amount.AddSupportedType( DistributionFunction::GAUSSIAN_DURATION, "Initial_Amount_Mean", CHW_Initial_Amount_Mean_DESC_TEXT, "Initial_Amount_Std_Dev", CHW_Initial_Amount_Std_Dev_DESC_TEXT ); initial_amount.AddSupportedType( DistributionFunction::EXPONENTIAL_DURATION, "Initial_Amount", CHW_Initial_Amount_DESC_TEXT, "", "" ); initial_amount.Configure( this, inputJson ); m_DemographicRestrictions.ConfigureRestrictions( this, inputJson ); initConfigTypeMap("Trigger_Condition_List", &m_TriggerConditionList, CHW_Trigger_Condition_List_DESC_TEXT ); initConfigComplexType( "Node_Property_Restrictions", &m_NodePropertyRestrictions, CHW_Node_Property_Restriction_DESC_TEXT ); initConfigComplexType( "Intervention_Config", &m_InterventionConfig, CHW_Intervention_Config_DESC_TEXT ); bool retValue = JsonConfigurable::Configure( inputJson ); if( retValue && !JsonConfigurable::_dryrun) { // ------------------------------------------------------ // --- Check that the intervention exists and initialize // ------------------------------------------------------ InterventionValidator::ValidateIntervention( m_InterventionConfig._json, inputJson->GetDataLocation() ); m_DemographicRestrictions.CheckConfiguration(); Configuration* qi_as_config = Configuration::CopyFromElement( m_InterventionConfig._json ); m_InterventionName = std::string( json::QuickInterpreter(m_InterventionConfig._json)["class"].As<json::String>() ); m_pInterventionIndividual = InterventionFactory::getInstance()->CreateIntervention( qi_as_config ); if( m_pInterventionIndividual == nullptr ) { m_pInterventionNode = InterventionFactory::getInstance()->CreateNDIIntervention( qi_as_config ); } delete qi_as_config; qi_as_config = nullptr; // --------------------------------------------------------------------------- // --- If the user is attempting to define demographic restrictions when they // --- are using a node level intervention, then we need to error because these // --- restrictions are not doing anything. // --------------------------------------------------------------------------- if( (m_pInterventionNode != nullptr) && !m_DemographicRestrictions.HasDefaultRestrictions() ) { std::ostringstream msg ; msg << "In CommunityHealthWorkerEventCoordinator, demographic restrictions such as 'Demographic_Coverage'\n"; msg << "and 'Target_Gender' do not apply when distributing nodel level interventions such as "; msg << m_InterventionName; throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, msg.str().c_str() ); } else if( (m_pInterventionNode == nullptr) && (m_NodePropertyRestrictions.Size() > 0) ) { std::ostringstream msg; msg << "In CommunityHealthWorkerEventCoordinator, Node_Property_Restrictions only works when distributing node-level interventions.\n"; msg << m_InterventionName << " is a individual-targeted intervention.\n"; throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, msg.str().c_str() ); } for( auto& event_name : m_RemoveIndividualEventList ) { m_TriggerConditionList.push_back( event_name ); } // -------------------- // --- Initialize Stock // -------------------- initial_amount.CheckConfiguration(); m_CurrentStock = int( initial_amount.CalculateDuration() + 0.5); // round up if( m_CurrentStock > m_MaxStock ) { m_CurrentStock = m_MaxStock; } m_DaysToNextShipment = int( float(m_CurrentStock) / float(m_MaxDistributedPerDay) ); if( m_DaysToNextShipment > m_DaysBetweenShipments ) { m_DaysToNextShipment = m_DaysBetweenShipments; } } return retValue; }
bool NodeLevelHealthTriggeredIV::Configure( const Configuration * inputJson ) { JsonConfigurable::_useDefaults = InterventionFactory::useDefaults; if( JsonConfigurable::_dryrun || inputJson->Exist( "Actual_NodeIntervention_Config" ) ) { initConfigComplexType( "Actual_NodeIntervention_Config", &actual_node_intervention_config, BT_Actual_NodeIntervention_Config_DESC_TEXT ); } if( JsonConfigurable::_dryrun || inputJson->Exist( "Actual_IndividualIntervention_Config" ) ) { initConfigComplexType( "Actual_IndividualIntervention_Config", &actual_individual_intervention_config, BT_Actual_IndividualIntervention_Config_DESC_TEXT ); } if( !JsonConfigurable::_dryrun && ( ( inputJson->Exist( "Actual_IndividualIntervention_Config" ) && inputJson->Exist( "Actual_NodeIntervention_Config" )) || (!inputJson->Exist( "Actual_IndividualIntervention_Config" ) && !inputJson->Exist( "Actual_NodeIntervention_Config" )) ) ) { throw InvalidInputDataException( __FILE__, __LINE__, __FUNCTION__, "You must specify either 'Actual_IndividualIntervention_Config' or 'Actual_NodeIntervention_Config' (but do not specify both)." ); } initConfigTypeMap( "Distribute_On_Return_Home", &distribute_on_return_home, Distribute_On_Return_Home_DESC_TEXT, false ); initConfigTypeMap("Duration", &max_duration, BT_Duration_DESC_TEXT, -1.0f, FLT_MAX, -1.0f ); // -1 is a convention for indefinite duration initConfigTypeMap( "Blackout_Period", &blackout_period, Blackout_Period_DESC_TEXT, 0.0f, FLT_MAX, 0.0f ); initConfigTypeMap( "Blackout_Event_Trigger", &blackout_event_trigger, Blackout_Event_Trigger_DESC_TEXT ); initConfigTypeMap( "Blackout_On_First_Occurrence", &blackout_on_first_occurrence, Blackout_On_First_Occurrence_DESC_TEXT, false ); initConfigComplexType( "Node_Property_Restrictions", &node_property_restrictions, NLHTIV_Node_Property_Restriction_DESC_TEXT ); demographic_restrictions.ConfigureRestrictions( this, inputJson ); // -------------------------------------------------------------------------------------------------------------------- // --- Phase 0 - Pre V2.0 - Trigger_Condition was an enum and users had to have all indivual events in the enum list. // --- Phase 1 - V2.0 - Trigger_Condition was an enum but TriggerString and TriggerList were added to allow the // --- user to use new User Defined events (i.e. strings). // --- Phase 2 - 11/12/15 - Trigger_Condition is now a string and so users don't need to use Trigger_Condition_String // --- in order to use the User Defined events. However, we are leaving support here for // --- Trigger_Condition_String for backward compatibility (and I'm lazy). // --- Phase 3 - 11/9/16 Consolidate so that the user only defines Trigger_Condition_List // -------------------------------------------------------------------------------------------------------------------- JsonConfigurable::_useDefaults = InterventionFactory::useDefaults; // Why??? initConfigTypeMap( "Trigger_Condition_List", &m_trigger_conditions, NLHTI_Trigger_Condition_List_DESC_TEXT ); bool retValue = BaseNodeIntervention::Configure( inputJson ); //this section copied from standardevent coordinator if( retValue && !JsonConfigurable::_dryrun ) { demographic_restrictions.CheckConfiguration(); if( inputJson->Exist( "Actual_IndividualIntervention_Config" ) ) { InterventionValidator::ValidateIntervention( actual_individual_intervention_config._json, inputJson->GetDataLocation() ); using_individual_config = true; } else if( inputJson->Exist( "Actual_NodeIntervention_Config" ) ) { InterventionValidator::ValidateIntervention( actual_node_intervention_config._json, inputJson->GetDataLocation() ); using_individual_config = false; } event_occured_list.resize( EventTriggerFactory::GetInstance()->GetNumEventTriggers() ); bool blackout_configured = (inputJson->Exist("Blackout_Event_Trigger")) || (inputJson->Exist("Blackout_Period")) || (inputJson->Exist("Blackout_On_First_Occurrence")); bool blackout_all_configured = (inputJson->Exist("Blackout_Event_Trigger")) && (inputJson->Exist("Blackout_Period")) && (inputJson->Exist("Blackout_On_First_Occurrence")); if (blackout_configured && !blackout_all_configured) { std::vector<string> blackout_missing_str; if( !inputJson->Exist("Blackout_Event_Trigger") ) blackout_missing_str.push_back("Blackout_Event_Trigger"); if( !inputJson->Exist("Blackout_Period") ) blackout_missing_str.push_back("Blackout_Period"); if( !inputJson->Exist("Blackout_On_First_Occurrence") ) blackout_missing_str.push_back("Blackout_On_First_Occurrence"); throw MissingParameterFromConfigurationException(__FILE__, __LINE__, __FUNCTION__, inputJson->GetDataLocation().c_str(), blackout_missing_str, " All three Blackout parameters must be configured."); } if( distribute_on_return_home ) { if( (std::find( m_trigger_conditions.begin(), m_trigger_conditions.end(), EventTrigger::Emigrating ) != m_trigger_conditions.end()) || (std::find( m_trigger_conditions.begin(), m_trigger_conditions.end(), EventTrigger::Immigrating ) != m_trigger_conditions.end()) ) { throw InvalidInputDataException( __FILE__, __LINE__, __FUNCTION__, "When using Distribute_On_Return_Home, you cannot also use Emigrating or Immigrating." ); } m_trigger_conditions.push_back( EventTrigger::Emigrating ); m_trigger_conditions.push_back( EventTrigger::Immigrating ); } } JsonConfigurable::_useDefaults = false; return retValue; }