Refactor getPhrasedml->getPhraSEDML, separate classes for time course simulations, progress on MultipleModelTimeCourse.

Author: joseph-hellerstein

examples/usage_examples.ipynb

@@ -174,7 +174,7 @@ def _getSBMLFromReference(self)->str:
                 raise ValueError(f"Failed to fetch SBML from URL: {self.model_ref}")
         return sbml_str
 
-    def getPhrasedml(self):
+    def getPhraSEDML(self):
         params = ", ".join(f"{param} = {val}" for param, val in self.param_change_dct.items())
         if len(params) > 0:
             params = f" with {params}"
@@ -188,7 +188,7 @@ def __str__(self)->str:
         """
         Construct the PhraSED-ML string. This requires:
         """
-        return self.getPhrasedml()
+        return self.getPhraSEDML()
 
     @staticmethod 
     def findReferenceType(model_ref:str, model_ids:List[str], ref_type:Optional[str]=None)->str:

src/model.py

@@ -1,5 +1,19 @@
 '''Provides comparisons between multiple simulations.'''
 
+"""
+This module provides a class for comparing multiple models with common variables
+for the same time course. The class allows for the simulation of a collection of models
+with the same variables and generates plots and reports for the comparisons.
+The class is designed to be used with the PhraSED-ML format and provides methods
+for creating simulation directives, task directives, report directives, and plot directives.
+
+The generation of PhraSED-ML strings is done through the `getPhrasedml` method,
+which constructs the string by adding the necessary directives based on the provided
+model references, simulation parameters, and display variables. This "late generation" approach
+allows for flexibility in model definitions since the definitions in the constructor
+can reference other model definitions that occur later on.
+"""
+
 import constants as cn # type: ignore
 from simple_sedml_base import SimpleSEDMLBase  # type:ignore
 from typing import Optional, List
@@ -10,10 +24,16 @@
 class MultipleModelTimeCourse(SimpleSEDMLBase):
     """Provides comparisons between multiple simulations."""
 
-    def __init__(self, start:float=cn.D_START, end:float=cn.D_END, num_step:int=cn.D_NUM_STEP,
-                    num_point:int=cn.D_NUM_POINT, algorithm:str=cn.D_ALGORITHM,
-                    model_refs:Optional[List[str]]=None,
-                    compare_variables:Optional[List[str]]=None,
+    def __init__(self,
+                    model_refs:List[str],
+                    start:float=cn.D_START,
+                    end:float=cn.D_END,
+                    num_step:Optional[int]=None,
+                    num_point:Optional[int]=None,
+                    algorithm:str=cn.D_ALGORITHM,
+                    time_course_id:Optional[str]=None,
+                    display_variables:Optional[List[str]]=None,
+                    **parameter_dct,
                     ):
         """Simulates a collection of models with common variables for the same time course.
         All models have the compared_variables. The outputs are:
@@ -29,6 +49,7 @@ def __init__(self, start:float=cn.D_START, end:float=cn.D_END, num_step:int=cn.D
             models (Optional[List[str]], optional): List of model references. Defaults to None.
             variables (Optional[List[str]], optional): List of variables to be compared. Defaults to None.
                 if not provided, all variables in the model are used.
+            parameters (Optional[dict], optional): Dictionary of parameters whose values are changed
 
         Example 1: Compare two models with the same variables
             mmtc = MultipleModelTimeCourse(start=0, end=10, num_step=100,
@@ -44,22 +65,39 @@ def __init__(self, start:float=cn.D_START, end:float=cn.D_END, num_step:int=cn.D
             mmtc.addModel(model1_str, k1=0.2, k2=0.4)
             sedml_str = mmtc.getSEDMLString()
         """
+        # Error checks
+        if len(model_refs) == 0:
+            raise ValueError("No models have been added to the simulation.")
+        #
+        super().__init__()
+        #
         self.start = start
         self.end = end
         self.num_step = num_step
         self.num_point = num_point
         self.algorithm = algorithm
-        if model_refs is not None:
-            for model_ref in model_refs:
-                self.addModel(model_ref)
         self.model_refs = model_refs
-        if compare_variables is None:
-            compare_variables = []
-        self.compared_variables = compare_variables
-
+        self.time_course_id = time_course_id
+        if display_variables is None:
+            display_variables = []
+        self.display_variables = display_variables
+        self.parameter_dct = parameter_dct
+    
     def _makeSimulationDirective(self):
         self.addSimulation(SIM_ID, "uniform", start=self.start, end=self.end, num_step=self.num_step,
                     num_point=self.num_point, algorithm=self.algorithm)
+    
+    @staticmethod
+    def _makeTaskID(model_id:str)->str:
+        """Make a task ID from the model ID and simulation ID.
+
+        Args:
+            model_id (str): model ID
+
+        Returns:
+            str: task ID
+        """
+        return f"t{model_id}"
 
     def _makeTaskDirectives(self):
         """Make the task directives for the compared variables.
@@ -70,79 +108,82 @@ def _makeTaskDirectives(self):
         if len(self.model_dct) == 0:
             raise ValueError("No models have been added to the simulation.")
         #
-        for model_id in self.model_dct.keys():
+        for model_id in self.model_refs:
             task_id = self._makeTaskID(model_id)
             self.addTask(task_id, model_id, SIM_ID)
 
-    def _makeReportDirective(self):
-        """Make the report directive for the compared variables.
+    def _makeScopePrefix(self, model_id:str)->str:
+        """Makes the scoping prefix for the compared variables.
+
+        Args:
+            model_id (str): model ID
 
         Returns:
-            str: report directives
+            str: task name
         """
-        if self.compared_variables is None:
-            first_model_id = list(self.model_dct.keys())[0]
-            self.compared_variables = list(self.model_dct[first_model_id].getInformation().floating_species_dct.keys())
-        #
-        report_variables = []
-        for model_id in self.model_dct.keys():
-            task_prefix = self._makeTaskID(model_id) + "."
-            new_report_variable = [task_prefix + v for v in self.compared_variables]
-            report_variables.extend(new_report_variable)
-        self.addReport(*report_variables)
-
+        return self._makeTaskID(model_id) + "."
+    
     def _makeVariables(self):
         # Creates variables if it's None
-        if self.compared_variables is None:
+        if self.display_variables is None:
             first_model_id = list(self.model_dct.keys())[0]
-            self.compared_variables = list(self.model_dct[first_model_id].getInformation().floating_species_dct.keys())
+            self.display_variables = list(self.model_dct[first_model_id].getInformation().floating_species_dct.keys())
 
-    def _makePlotDirectives(self):
-        """Make the plot directives for the compared variables.
+    def _makeReportDirective(self, task_ids:List[str]):
+        """Make the report directive for the compared variables.
+
+        Args:
+            task_ids: list of task ids
 
         Returns:
-            str: plot directives
+            str: report directives
         """
-        #
+        # Calculate the task ids to consider
+        # Handle the case where no variables are provided
         self._makeVariables()
-        for variable in self.compared_variables:
-            plot_variables = []
-            for model_id in self.model_dct.keys():
-                task_prefix = self._makeTaskID(model_id) + "."
-                plot_variables.append(task_prefix + variable)
-            self.addPlot(*plot_variables, title=variable)
+        #
+        report_variables = []
+        for variable in self.display_variables:
+            new_report_variables = [self._makeScopePrefix(m) + variable for m in task_ids]
+            report_variables.extend(new_report_variables)
+        self.addReport(*report_variables)
 
-    @staticmethod
-    def _makeTaskID(model_id:str)->str:
-        """Make a task ID from the model ID and simulation ID.
+    def _makePlotDirective(self, task_ids:List[str]):
+        """Make the report directive for the compared variables.
+        There is one plot for each variable that plots comparisons of the models.
 
         Args:
-            model_id (str): model ID
+            task_ids: list of task ids
 
         Returns:
-            str: task ID
+            str: report directives
         """
-        return f"t{model_id}"
+        #
+        self._makeVariables()
+        for variable in self.display_variables:
+            plot_variables = [self._makeScopePrefix(m) + variable for m in task_ids]
+            self.addPlot(*plot_variables, title=variable)
 
-    def getPhrasedml(self)->str:
+    def getPhraSEDML(self)->str:
         """Construct the PhraSED-ML string. This requires:
             1. Create simulation and task directives
             2. Changing the model and report
         
         Returns:
-            str: _description_
+            str: Phrased-ML string
         """
-        ##
-        # Add the simulation directive
-        self.addSimulation(SIM_ID, "uniform", start=self.start, end=self.end, num_step=self.num_step,
-                    num_point=self.num_point, algorithm=self.algorithm)
-        # Add a task directive for each model
-        for model_id in self.model_dct.keys():
-            task_id = self._makeTaskID(model_id)
-            self.addTask(task_id, model_id, SIM_ID)
-            for plot in self.plot_dct.values():
-                plot.changeVariableScope(model_id, task_id)
-            # FIXME: do variable change for report
+        # Add the models specified in the constructors
+        exclude_ids = list(self.model_dct.keys())
+        for idx, model_ref in enumerate(self.model_refs):
+            model_id = f"model{idx}"
+            self.addModel(model_id, model_ref, is_overwrite=True, **self.parameter_dct)
+        # Calculate the task ids to consider
+        task_ids = list(set(self.model_dct.keys()) - set(exclude_ids))
+        # Add the other directives
+        self._makeSimulationDirective()
+        self._makeTaskDirectives()
+        self._makeReportDirective(task_ids)
+        self._makePlotDirectives(task_ids)
         #
         return self.self.super().getPhrasedml()
 
@@ -152,4 +193,4 @@ def __str__(self)->str:
         Returns:
             str:
         """
-        return self.getPhrasedml()
+        return self.getPhraSEDML()

src/multiple_model_time_course.py

@@ -1,13 +1,14 @@
 from typing import Optional, List, Union
+import constants as cn # type: ignore
 
 class Plot:
     def __init__(self, x_var:str, y_var:Union[str, List[str]], z_var:Optional[str]=None, title:Optional[str]=None,
-                 is_plot:bool=True)->None:  
+            is_plot:bool=True)->None:  
         """
         Plot class to represent a plot in the script. The following cases are supported:
-           plot x vs y (z is None, y is str)
-           plot x vs y1, y2, y3 (z is None, y is a list of str)
-           plot x vs y vs z  (z is a str, y is str)
+            plot x vs y (z is None, y is str)
+            plot x vs y1, y2, y3 (z is None, y is a list of str)
+            plot x vs y vs z  (z is a str, y is str)
 
         Args:
             x_var (str): x variable
@@ -21,7 +22,7 @@ def __init__(self, x_var:str, y_var:Union[str, List[str]], z_var:Optional[str]=N
         self.title = title
         self.is_plot = is_plot
 
-    def getPhrasedml(self)->str:
+    def getPhraSEDML(self)->str:
         if not self.is_plot:
             return ""
         if self.z_var is None:
@@ -46,24 +47,22 @@ def __str__(self)->str:
         Returns:
             str: PhraSED-ML string
         """
-        return self.getPhrasedml()
+        return self.getPhraSEDML()
 
-    #FIXME: test 
-    def changeVariableScope(self, old_scope:str, new_scope:str)->None:
-        """Change the scope of the variables in the plot. For example,
-        change "model1.x" to "task1.x"
+    def scopeVariables(self, scope:str)->None:
+        """_summary_
 
         Args:
-            old_scope (str): old scope
-            new_scope (str): new scope
+            scope (str)
         """
-        if self.x_var.startswith(old_scope + "."):
-            self.x_var = self.x_var.replace(old_scope, new_scope)
-        if isinstance(self.y_var, str) and self.y_var.startswith(old_scope + "."):
-            self.y_var = self.y_var.replace(old_scope, new_scope)
+        scope_prefix = scope + "."
+        self.x_var = scope_prefix + self.x_var
+        if isinstance(self.y_var, str):
+            self.y_var = scope_prefix + self.y_var
         elif isinstance(self.y_var, list):
             for i in range(len(self.y_var)):
-                if self.y_var[i].startswith(old_scope + "."):
-                    self.y_var[i] = self.y_var[i].replace(old_scope, new_scope)
-        if self.z_var is not None and self.z_var.startswith(old_scope + "."):
-            self.z_var = self.z_var.replace(old_scope, new_scope)
+                self.y_var[i] = scope_prefix + self.y_var[i]
+        else:
+            raise RuntimeError(f"y_var must be a string or a list of strings, not {type(self.y_var)}")
+        if self.z_var is not None:
+            self.z_var = scope_prefix + self.z_var

src/plot.py

@@ -22,8 +22,22 @@ def addVariables(self, *args):
         """
         self.variables.extend(args)
 
-    def getPhrasedml(self)->str:
+    def getPhraSEDML(self)->str:
         return "\n".join([f'report "{self.title}" {", ".join(self.variables)}'])
 
     def __str__(self)->str:
-        return self.getPhrasedml()
+        return self.getPhraSEDML()
+
+    def scopeVariables(self, scope:str)->None:
+        """Use the specified scope for all variables
+
+        Args:
+            scope (str): scope
+        """
+        scope_indicator = "."
+        scope_str = scope + scope_indicator
+        for idx in range(len(self.variables)):
+            # FIXME: Make scoping a utility
+            if scope_indicator in self.variables[idx]:
+                raise ValueError(f"Variable {self.variables[idx]} already has a scope. Cannot change scope.")
+            self.variables[idx] = scope_str + self.variables[idx]