Parallel-in-Time
diff --git a/‎pySDC/core/base_transfer.py‎
Lines changed: 26 additions & 14 deletions b/‎pySDC/core/base_transfer.py‎
Lines changed: 26 additions & 14 deletions
diff --git a/‎pySDC/core/collocation.py‎
Lines changed: 13 additions & 4 deletions b/‎pySDC/core/collocation.py‎
Lines changed: 13 additions & 4 deletions
diff --git a/‎pySDC/core/common.py‎
Lines changed: 7 additions & 4 deletions b/‎pySDC/core/common.py‎
Lines changed: 7 additions & 4 deletions
@@ -1,16 +1,21 @@
 import logging
+from typing import Any, Dict, Optional, TYPE_CHECKING
 
 import scipy.sparse as sp
+import numpy as np
 
 from pySDC.core.errors import UnlockError
 from pySDC.helpers.pysdc_helper import FrozenClass
 from qmat.lagrange import LagrangeApproximation
 
+if TYPE_CHECKING:
+    from pySDC.core.level import Level
+
 
 # short helper class to add params as attributes
 class _Pars(FrozenClass):
-    def __init__(self, pars):
-        self.finter = False
+    def __init__(self, pars: Dict[str, Any]) -> None:
+        self.finter: bool = False
         for k, v in pars.items():
             setattr(self, k, v)
 
@@ -28,7 +33,14 @@ class BaseTransfer(object):
         coarse (pySDC.Level.level): reference to the coarse level
     """
 
-    def __init__(self, fine_level, coarse_level, base_transfer_params, space_transfer_class, space_transfer_params):
+    def __init__(
+        self,
+        fine_level: 'Level',
+        coarse_level: 'Level',
+        base_transfer_params: Dict[str, Any],
+        space_transfer_class: Any,
+        space_transfer_params: Dict[str, Any],
+    ) -> None:
         """
         Initialization routine
 
@@ -40,31 +52,31 @@ def __init__(self, fine_level, coarse_level, base_transfer_params, space_transfe
             space_transfer_params (dict): parameters for the space_transfer operations
         """
 
-        self.params = _Pars(base_transfer_params)
+        self.params: _Pars = _Pars(base_transfer_params)
 
         # set up logger
-        self.logger = logging.getLogger('transfer')
+        self.logger: logging.Logger = logging.getLogger('transfer')
 
-        self.fine = fine_level
-        self.coarse = coarse_level
+        self.fine: 'Level' = fine_level
+        self.coarse: 'Level' = coarse_level
 
         fine_grid = self.fine.sweep.coll.nodes
         coarse_grid = self.coarse.sweep.coll.nodes
 
         if len(fine_grid) == len(coarse_grid):
-            self.Pcoll = sp.eye(len(fine_grid)).toarray()
-            self.Rcoll = sp.eye(len(fine_grid)).toarray()
+            self.Pcoll: np.ndarray = sp.eye(len(fine_grid)).toarray()
+            self.Rcoll: np.ndarray = sp.eye(len(fine_grid)).toarray()
         else:
             self.Pcoll = self.get_transfer_matrix_Q(fine_grid, coarse_grid)
             self.Rcoll = self.get_transfer_matrix_Q(coarse_grid, fine_grid)
 
         # set up spatial transfer
-        self.space_transfer = space_transfer_class(
+        self.space_transfer: Any = space_transfer_class(
             fine_prob=self.fine.prob, coarse_prob=self.coarse.prob, params=space_transfer_params
         )
 
     @staticmethod
-    def get_transfer_matrix_Q(f_nodes, c_nodes):
+    def get_transfer_matrix_Q(f_nodes: np.ndarray, c_nodes: np.ndarray) -> np.ndarray:
         """
         Helper routine to quickly define transfer matrices from a coarse set
         to a fine set of nodes (fully Lagrangian)
@@ -78,7 +90,7 @@ def get_transfer_matrix_Q(f_nodes, c_nodes):
         approx = LagrangeApproximation(c_nodes)
         return approx.getInterpolationMatrix(f_nodes)
 
-    def restrict(self):
+    def restrict(self) -> None:
         """
         Space-time restriction routine
 
@@ -163,7 +175,7 @@ def restrict(self):
 
         return None
 
-    def prolong(self):
+    def prolong(self) -> None:
         """
         Space-time prolongation routine
 
@@ -202,7 +214,7 @@ def prolong(self):
 
         return None
 
-    def prolong_f(self):
+    def prolong_f(self) -> None:
         """
         Space-time prolongation routine w.r.t. the rhs f
 
 
@@ -1,4 +1,5 @@
 import logging
+from typing import Optional, Any
 import numpy as np
 from qmat import Q_GENERATORS
 
@@ -44,7 +45,15 @@ class CollBase(object):
         left_is_node (bool): flag to indicate whether left point is collocation node
     """
 
-    def __init__(self, num_nodes=None, tleft=0, tright=1, node_type='LEGENDRE', quad_type=None, **kwargs):
+    def __init__(
+        self,
+        num_nodes: Optional[int] = None,
+        tleft: float = 0,
+        tright: float = 1,
+        node_type: str = 'LEGENDRE',
+        quad_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
         """
         Initialization routine for a collocation object
 
@@ -59,7 +68,7 @@ def __init__(self, num_nodes=None, tleft=0, tright=1, node_type='LEGENDRE', quad
         if not tleft < tright:
             raise CollocationError('interval boundaries are corrupt, got %s and %s' % (tleft, tright))
 
-        self.logger = logging.getLogger('collocation')
+        self.logger: logging.Logger = logging.getLogger('collocation')
         try:
             self.generator = Q_GENERATORS["Collocation"](
                 nNodes=num_nodes, nodeType=node_type, quadType=quad_type, tLeft=tleft, tRight=tright
@@ -99,7 +108,7 @@ def __init__(self, num_nodes=None, tleft=0, tright=1, node_type='LEGENDRE', quad
         self.delta_m = self._gen_deltas
 
     @staticmethod
-    def evaluate(weights, data):
+    def evaluate(weights: np.ndarray, data: np.ndarray) -> np.ndarray:
         """
         Evaluates the quadrature over the full interval
 
@@ -116,7 +125,7 @@ def evaluate(weights, data):
         return np.dot(weights, data)
 
     @property
-    def _gen_deltas(self):
+    def _gen_deltas(self) -> np.ndarray:
         """
         Compute distances between the nodes
 
 
@@ -8,13 +8,14 @@
 classes.
 """
 
+from typing import Any, Optional, Set, Dict
 from pySDC.core.errors import ReadOnlyError
 
 
 class _MetaRegisterParams(type):
     """Metaclass for RegisterParams base class"""
 
-    def __new__(cls, name, bases, dct):
+    def __new__(cls, name: str, bases: tuple, dct: dict) -> type:
         obj = super().__new__(cls, name, bases, dct)
         obj._parNamesReadOnly = set()
         obj._parNames = set()
@@ -35,7 +36,9 @@ class RegisterParams(metaclass=_MetaRegisterParams):
         Names of all the parameters registered as read-only.
     """
 
-    def _makeAttributeAndRegister(self, *names, localVars=None, readOnly=False):
+    def _makeAttributeAndRegister(
+        self, *names: str, localVars: Optional[Dict[str, Any]] = None, readOnly: bool = False
+    ) -> None:
         """
         Register a list of attribute name as parameters of the class.
 
@@ -66,11 +69,11 @@ def _makeAttributeAndRegister(self, *names, localVars=None, readOnly=False):
             self._parNames = self._parNames.union(names)
 
     @property
-    def params(self):
+    def params(self) -> Dict[str, Any]:
         """Dictionary containing names and values of registered parameters"""
         return {name: getattr(self, name) for name in self._parNamesReadOnly.union(self._parNames)}
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name in self._parNamesReadOnly:
             raise ReadOnlyError(name)
         super().__setattr__(name, value)