docs: def add_dynamics_2(self, component, runnable, regime, dynamics):
          """
          Adds dynamics to a runnable component based on the dynamics
          specifications in the component model.
  
          This method builds dynamics dependent on child components.
  
          @param component: Component model containing dynamics specifications.
          @type component: lems.model.component.FatComponent
  
          @param runnable: Runnable component to which dynamics is to be added.
          @type runnable: lems.sim.runnable.Runnable
  
          @param regime: The dynamics regime to be used to generate
          dynamics code in the runnable component.
          @type regime: lems.model.dynamics.Regime
  
          @param dynamics: Shared dynamics specifications.
          @type dynamics: lems.model.dynamics.Regime
  
          @raise SimBuildError: Raised when a time derivative expression refers
          to an undefined variable.
  
          @raise SimBuildError: Raised when there are invalid time
          specifications for the <Run> statement.
  
          @raise SimBuildError: Raised when the component reference for <Run>
          cannot be resolved.
          """
  
          if isinstance(regime, Dynamics) or regime.name == '':
              suffix = ''
          else:
              suffix = '_regime_' + regime.name
  
          # Process kinetic schemes
          ks_code = []
          for ks in regime.kinetic_schemes:
              
              raise NotImplementedError("KineticScheme element is not stable in PyLEMS yet, see https://github.com/LEMS/pylems/issues/15")
          
              try:
                  ###nodes = {node.id:node for node in runnable.__dict__[ks.nodes]}
                  nodes = {}
                  for node in runnable.__dict__[ks.nodes]:
                      nodes[node.id] = node
                  edges = runnable.__dict__[ks.edges]
  
                  for edge in edges:
                      from_ = edge.__dict__[ks.edge_source]
                      to = edge.__dict__[ks.edge_target]
  
                      ks_code += [('self.{0}.{2} += dt * (-self.{3}.{4} * self.{0}.{2}_shadow'
                                   ' + self.{3}.{5} * self.{1}.{2}_shadow)').format(
                          from_, to, ks.state_variable, edge.id,
                          ks.forward_rate, ks.reverse_rate)]
  
                      ks_code += [('self.{1}.{2} += dt * (self.{3}.{4} * self.{0}.{2}_shadow'
                                   ' - self.{3}.{5} * self.{1}.{2}_shadow)').format(
                          from_, to, ks.state_variable, edge.id,
                          ks.forward_rate, ks.reverse_rate)]
  
                  ks_code += ['sum = 0']
                  for node in nodes:
                      nodes[node].__dict__[ks.state_variable] = 1.0 / len(nodes)
                      nodes[node].__dict__[ks.state_variable + '_shadow'] = 1.0 / len(nodes)
                      ks_code += ['sum += self.{0}.{1}'.format(node, ks.state_variable)]
  
                  for node in nodes:
                      ks_code += ['self.{0}.{1} /= sum'.format(node, ks.state_variable)]
  
                  for node in nodes:
                      ks_code += [('self.{0}.{1}_shadow = '
                                   'self.{0}.{1}').format(node,
                                                          ks.state_variable)]
  
              except Exception as e:
                  raise SimBuildError(("Unable to construct kinetic scheme '{0}' "
                                       "for component '{1}' - {2}").format(ks.name,
                                                                           component.id,
                                                                           str(e)))
  
          runnable.add_method('update_kinetic_scheme' + suffix, ['self', 'dt'],
                              ks_code)