pybamm-team#983 added Modulo operator

pybamm/expression_tree/binary_operators.py

@@ -730,6 +730,21 @@ def _binary_evaluate(self, left, right):
             return left < right
 
 
+class Modulo(BinaryOperator):
+    "Calculates the remainder of an integer division"
+
+    def __init__(self, left, right):
+        super().__init__("%", left, right)
+
+    def __str__(self):
+        """ See :meth:`pybamm.Symbol.__str__()`. """
+        return "{!s} mod {!s}".format(self.left, self.right)
+
+    def _binary_evaluate(self, left, right):
+        """ See :meth:`pybamm.BinaryOperator._binary_evaluate()`. """
+        return left % right
+
+
 class Minimum(BinaryOperator):
     " Returns the smaller of two objects "
 

pybamm/expression_tree/operations/convert_to_casadi.py

@@ -76,6 +76,8 @@ def _convert(self, symbol, t, y, y_dot, inputs):
             converted_left = self.convert(left, t, y, y_dot, inputs)
             converted_right = self.convert(right, t, y, y_dot, inputs)
 
+            if isinstance(symbol, pybamm.Modulo):
+                return casadi.fmod(converted_left, converted_right)
             if isinstance(symbol, pybamm.Minimum):
                 return casadi.fmin(converted_left, converted_right)
             if isinstance(symbol, pybamm.Maximum):

pybamm/expression_tree/symbol.py

@@ -466,6 +466,12 @@ def __abs__(self):
         return pybamm.simplify_if_constant(
             pybamm.AbsoluteValue(self), keep_domains=True
         )
+
+    def __mod__(self, other):
+        """return an :class:`Modulo` object"""
+        return pybamm.simplify_if_constant(
+            pybamm.Modulo(self, other), keep_domains=True
+        )
 
     def diff(self, variable):
         """

pybamm/solvers/base_solver.py

@@ -279,8 +279,8 @@ def report(string):
                 jac_call = None
             return func, func_call, jac_call
 
-        # Check for heaviside functions in rhs and algebraic and add discontinuity
-        # events if these exist.
+        # Check for heaviside and modulo functions in rhs and algebraic and add 
+        # discontinuity events if these exist.
         # Note: only checks for the case of t < X, t <= X, X < t, or X <= t, but also
         # accounts for the fact that t might be dimensional
         # Only do this for DAE models as ODE models can deal with discontinuities fine
@@ -315,6 +315,32 @@ def report(string):
                                 pybamm.EventType.DISCONTINUITY,
                             )
                         )
+                elif isinstance(symbol, pybamm.Modulo):
+                    found_t = False
+                    # Dimensionless
+                    if symbol.right.id == pybamm.t.id:
+                        expr = symbol.left
+                        found_t = True
+                    elif symbol.left.id == pybamm.t.id:
+                        expr = symbol.right
+                        found_t = True
+                    # Dimensional
+                    elif symbol.right.id == (pybamm.t * model.timescale).id:
+                        expr = symbol.left.new_copy() / symbol.right.right.new_copy()
+                        found_t = True
+                    elif symbol.left.id == (pybamm.t * model.timescale).id:
+                        expr = symbol.right.new_copy() / symbol.left.right.new_copy()
+                        found_t = True
+
+                    # Update the events if the heaviside function depended on t
+                    if found_t:
+                        model.events.append(
+                            pybamm.Event(
+                                str(symbol),
+                                expr.new_copy(),
+                                pybamm.EventType.DISCONTINUITY,
+                            )
+                        )
 
         # Process initial conditions
         initial_conditions = process(