improve intracellular parsing

- if the intracellular type is set but the macro is not passed, the parser will now throw an error
- if the intracellular is passed at the command line and the given cell type is not set therein, consider that to mean this cell type is not using intracellular
- if the intracellular mappings file is passed in, it cannot include a MaBoSS intracellular model since that is not yet supported.

Author: drbergman

VERSION.txt

@@ -1 +1 @@
-1.14.2-drbergman-1.3.0
+1.14.2-drbergman-1.3.1

core/PhysiCell_cell.cpp

@@ -2318,7 +2318,6 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 	// otherwise, modify properties of that model 
 
 	// set up the death models 
-//	int death_model_index = 0; 
 	node = cd_node.child( "phenotype" );
 	node = node.child( "death" ); 
 	if( node )
@@ -2412,17 +2411,13 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 				if( node_temp )
 				{ death_params.lysed_fluid_change_rate = xml_get_my_double_value( node_temp ); }
 
-	//			death_params.time_units = 
-	//				get_string_attribute_value( node, "unlysed_fluid_change_rate", "units" ); 
-				
 				node = node.parent(); 
 			}
 
 			// set the model 
 			// if the model already exists, just overwrite the parameters 
             if (model == PhysiCell_constants::apoptosis_death_model) 
             {
-//					pCD->phenotype.death.add_death_model( rate , &apoptosis , apoptosis_parameters );
                 if( death_model_already_exists == false )
                 {
                     pCD->phenotype.death.add_death_model( rate , &apoptosis , death_params ); 
@@ -2437,7 +2432,6 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
             else if (model == PhysiCell_constants::necrosis_death_model) 
             {
                 // set necrosis parameters 
-//					pCD->phenotype.death.add_death_model( rate , &necrosis , necrosis_parameters );
                 if( death_model_already_exists == false )
                 {
                     pCD->phenotype.death.add_death_model( rate , &necrosis , death_params ); 
@@ -2960,11 +2954,7 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 			// pCI->dead_phagocytosis_rate = xml_get_my_double_value(node_dpr); 
 			dead_phagocytosis_rate = xml_get_my_double_value(node_dpr); 
 		}
-/*
-		pCI->apoptotic_phagocytosis_rate = pCI->dead_phagocytosis_rate; 
-		pCI->necrotic_phagocytosis_rate = pCI->dead_phagocytosis_rate; 
-		pCI->other_dead_phagocytosis_rate = pCI->dead_phagocytosis_rate; 
-*/
+
 		pCI->apoptotic_phagocytosis_rate = dead_phagocytosis_rate; 
 		pCI->necrotic_phagocytosis_rate = dead_phagocytosis_rate; 
 		pCI->other_dead_phagocytosis_rate = dead_phagocytosis_rate; 
@@ -3141,64 +3131,14 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 
 	// intracellular
 	node = cd_node.child( "phenotype" );
-	node = node.child( "intracellular" ); 
-	if( node )
+	node = node.child("intracellular");
+	if (node)
+	{
+		parse_intracellular_model(node, pCD, pParent);
+	}
+	else
 	{
-		std::string model_type = node.attribute( "type" ).value(); 
-
-#ifdef ADDON_PHYSIBOSS
-		if (model_type == "maboss") {
-			argument_parser.read_intracellular_files(node, pCD->name, model_type);
-			// If it has already be copied
-			if (pParent != NULL && pParent->phenotype.intracellular != NULL) {
-				pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
-				
-			// Otherwise we need to create a new one
-			} else {
-				MaBoSSIntracellular* pIntra = new MaBoSSIntracellular(node);
-				pCD->phenotype.intracellular = pIntra->getIntracellularModel();
-			}
-		}
-#endif
-
-#ifdef ADDON_ROADRUNNER
-		if (model_type == "roadrunner") 
-        {
-			argument_parser.read_intracellular_files(node, pCD->name, model_type);
-			// If it has already be copied
-			if (pParent != NULL && pParent->phenotype.intracellular != NULL) 
-            {
-				pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
-            }	
-			// Otherwise we need to create a new one
-			else 
-            {
-				RoadRunnerIntracellular* pIntra = new RoadRunnerIntracellular(node);
-				pCD->phenotype.intracellular = pIntra->getIntracellularModel();
-			}
-			pCD->phenotype.intracellular->validate_PhysiCell_tokens(pCD->phenotype);
-			pCD->phenotype.intracellular->validate_SBML_species();
-		}
-#endif
-
-#ifdef ADDON_PHYSIDFBA
-		if (model_type == "dfba") {
-			argument_parser.read_intracellular_files(node, pCD->name, model_type);
-			// If it has already be copied
-			if (pParent != NULL && pParent->phenotype.intracellular != NULL) {
-				pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
-			// Otherwise we need to create a new one
-			} else {
-				dFBAIntracellular* pIntra = new dFBAIntracellular(node);
-				pCD->phenotype.intracellular = pIntra->getIntracellularModel();
-			}
-		}
-#endif
-
-	} else{
-
 		pCD->phenotype.intracellular = NULL;
-
 	}
 
 	// set up custom data 
@@ -3283,10 +3223,90 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 		exit(-1);
 #endif
 	}
-	
+
 	return pCD;
 }
 
+void parse_intracellular_model(pugi::xml_node node, Cell_Definition* pCD, Cell_Definition* pParent)
+{
+	std::string model_type = node.attribute( "type" ).value(); 
+	bool uses_intracellular = argument_parser.read_intracellular_files(node, pCD->name, model_type);
+	if (!uses_intracellular) {
+		return;
+	}
+
+	if (model_type == "maboss")
+	{
+#ifdef ADDON_PHYSIBOSS
+		// If it has already be copied
+		if (pParent != NULL && pParent->phenotype.intracellular != NULL)
+		{
+			pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
+
+			// Otherwise we need to create a new one
+		}
+		else
+		{
+			MaBoSSIntracellular *pIntra = new MaBoSSIntracellular(node);
+			pCD->phenotype.intracellular = pIntra->getIntracellularModel();
+		}
+#else
+		std::cerr << "ERROR: MaBoSS intracellular model is not supported in this build." << std::endl
+				  << "\tMake sure to compile with the -D ADDON_PHYSIBOSS flag." << std::endl;
+		exit(-1);
+#endif
+	}
+
+	else if (model_type == "roadrunner")
+	{
+#ifdef ADDON_ROADRUNNER
+		// If it has already be copied
+		if (pParent != NULL && pParent->phenotype.intracellular != NULL)
+		{
+			pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
+		}
+		// Otherwise we need to create a new one
+		else
+		{
+			RoadRunnerIntracellular *pIntra = new RoadRunnerIntracellular(node);
+			pCD->phenotype.intracellular = pIntra->getIntracellularModel();
+		}
+		pCD->phenotype.intracellular->validate_PhysiCell_tokens(pCD->phenotype);
+		pCD->phenotype.intracellular->validate_SBML_species();
+#else
+		std::cerr << "ERROR: RoadRunner intracellular model is not supported in this build." << std::endl
+				  << "\tMake sure to compile with the -D ADDON_ROADRUNNER flag." << std::endl;
+		exit(-1);
+#endif
+	}
+
+	else if (model_type == "dfba")
+	{
+#ifdef ADDON_PHYSIDFBA
+		// If it has already be copied
+		if (pParent != NULL && pParent->phenotype.intracellular != NULL)
+		{
+			pCD->phenotype.intracellular->initialize_intracellular_from_pugixml(node);
+			// Otherwise we need to create a new one
+		}
+		else
+		{
+			dFBAIntracellular *pIntra = new dFBAIntracellular(node);
+			pCD->phenotype.intracellular = pIntra->getIntracellularModel();
+		}
+#else
+		std::cerr << "ERROR: dFBA intracellular model is not supported in this build." << std::endl
+				  << "\tMake sure to compile with the -D ADDON_PHYSIDFBA flag." << std::endl;
+#endif
+	}
+
+	else
+	{
+		std::cerr << "ERROR: Intracellular model type " << model_type << " is not supported." << std::endl;
+		exit(-1);
+	}
+}
+
 void initialize_cell_definitions_from_pugixml( pugi::xml_node root )
 {
 	pugi::xml_node node_options; 

core/PhysiCell_cell.h

@@ -292,6 +292,8 @@ Cell_Definition* initialize_cell_definition_from_pugixml( pugi::xml_node cd_node
 void initialize_cell_definitions_from_pugixml( pugi::xml_node root ); 
 void initialize_cell_definitions_from_pugixml( void );
 
+void parse_intracellular_model(pugi::xml_node node, Cell_Definition* pCD, Cell_Definition* pParent);
+
 extern std::vector<double> (*cell_division_orientation)(void);
 
 void attach_cells( Cell* pCell_1, Cell* pCell_2 );

modules/PhysiCell_settings.cpp

@@ -1106,10 +1106,31 @@ void ArgumentParser::print_usage(std::ostream& os, const char* program_name)
 	   << "   " << program_name << " path_to_config_file " << options_requiring_flag << std::endl;
 }
 
-void ArgumentParser::read_intracellular_files(pugi::xml_node& node_config_intracellular, const std::string &cell_definition, const std::string &intracellular_type)
+
+/**
+ * @brief Reads intracellular files based on the provided configuration and cell definition.
+ *
+ * This function attempts to read intracellular mappings from an XML file specified by the 
+ * `path_to_intracellular_mappings_file`. If the file is not provided, it will look in the 
+ * configuration node as usual. It ensures that there is only one intracellular mapping per 
+ * cell type and sets the intracellular files accordingly. If this file is found and a mapping
+ * is found for the given cell definition and intracellular type, the function will set the
+ * intracellular files, but not the parameters which are set in the config file.
+ *
+ * @param node_config_intracellular The XML node containing the intracellular configuration.
+ * @param cell_definition The name of the cell definition to look for in the mappings file.
+ * @param intracellular_type The type of intracellular model to look for.
+ * @return true if either no intracellular file was passed in at the command line or intracellular
+ *         mappings are found and set, false otherwise.
+ *
+ * @throws std::runtime_error if there are errors in loading or parsing the XML file, or if 
+ *         multiple mappings are found where only one is expected.
+ */
+bool ArgumentParser::read_intracellular_files(pugi::xml_node& node_config_intracellular, const std::string &cell_definition, const std::string &intracellular_type)
 {
-	if (path_to_intracellular_mappings_file=="")
-	{ return; }
+	bool uses_intracellular = path_to_intracellular_mappings_file==""; // if an intracellular file was not passed in at the command line, then go ahead and look in the config as normal
+	if (uses_intracellular)
+	{ return uses_intracellular; }
 
 	pugi::xml_document physicell_intracellular_mappings_doc;
 
@@ -1147,7 +1168,7 @@ void ArgumentParser::read_intracellular_files(pugi::xml_node& node_config_intrac
 	}
 
 	if (!found)
-	{ return; }
+	{ return false; } // no intracellular mappings for this cell type
 
 	pugi::xml_node node_intracellular_ids = node_this_cell_definition.child("intracellular_ids");
 	if (!node_intracellular_ids)
@@ -1171,7 +1192,7 @@ void ArgumentParser::read_intracellular_files(pugi::xml_node& node_config_intrac
 	}
 
 	if (!one_id_found)
-	{ return; }
+	{ return false; } // reaching here (currently) means that there are no intracellular mappings for this cell type. above, we handle the case of finding 2+
 
 	pugi::xml_node node_intracellulars = mappings_root.child("intracellulars");
 	if (!node_intracellulars)
@@ -1216,8 +1237,16 @@ void ArgumentParser::read_intracellular_files(pugi::xml_node& node_config_intrac
 		exit(-1);
 	}
 
+	if (intracellular_type == "maboss")
+	{
+		std::cerr << "ERROR: MaBoSS intracellular model in intracellular mappings file not yet supported!" << std::endl
+				  << "You must remove the MaBoSS model from the mappings file and use the config file to specify the MaBoSS model." << std::endl;
+		exit(-1);
+	}
+
 	std::string base_path_to_filename = path_to_intracellular_mappings_file.substr(0, path_to_intracellular_mappings_file.find_last_of(".")) + "_" + cell_definition + "_ID" + intracellular_ids[0];
 	set_intracellular_files(node_config_intracellular, node_this_intracellular, base_path_to_filename, intracellular_type);
+	return true; // intracellular mappings found for this cell type, so we will use them
 }
 
 void set_intracellular_files(pugi::xml_node &node_config_intracellular, const pugi::xml_node &node_this_intracellular, const std::string &base_path_to_filename, const std::string &intracellular_type)
@@ -1246,7 +1275,6 @@ void set_intracellular_files(pugi::xml_node &node_config_intracellular, const pu
 			std::cerr << "ERROR: Failed to set sbml_filename in config file!" << std::endl;
 			exit(-1);
 		}
-		std::cout << "sbml_filename = " << xml_get_string_value(node_config_intracellular, "sbml_filename") << std::endl;
 	}
 	else
 	{

modules/PhysiCell_settings.h

@@ -255,7 +255,7 @@ class ArgumentParser {
 
 	ArgumentParser() {};
 
-	void read_intracellular_files(pugi::xml_node& node_config_intracellular, const std::string &cell_definition, const std::string &intracellular_type);
+	bool read_intracellular_files(pugi::xml_node& node_config_intracellular, const std::string &cell_definition, const std::string &intracellular_type);
 
 	void print_usage(std::ostream& os, const char* program_name);
 };