docs: def add_dynamics_1(self, component, runnable, regime, dynamics):
          """
          Adds dynamics to a runnable component based on the dynamics
          specifications in the component model.
  
          This method builds dynamics necessary for building 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
  
          if isinstance(regime, Regime) and regime.initial:
              runnable.new_regime = regime.name
  
          # Process state variables
          for sv in regime.state_variables:
              runnable.add_instance_variable(sv.name, 0)
  
          # Process time derivatives
          time_step_code = []
          for td in regime.time_derivatives:
              if td.variable not in regime.state_variables and td.variable not in dynamics.state_variables:
                  raise SimBuildError(('Time derivative for undefined state '
                                       'variable {0} in component {1}').format(td.variable, component.id))
  
              exp = self.build_expression_from_tree(runnable,
                                                    regime,
                                                    td.expression_tree)
              time_step_code += ['self.{0} += dt * ({1})'.format(td.variable,
                                                                 exp)]
          runnable.add_method('update_state_variables' + suffix, ['self', 'dt'],
                              time_step_code)
  
          # Process derived variables
          derived_variable_code = []
          derived_variables_ordering = order_derived_variables(regime)
          for dvn in derived_variables_ordering: #regime.derived_variables:
              if dvn in dynamics.derived_variables:
                  dv = dynamics.derived_variables[dvn]
                  runnable.add_derived_variable(dv.name)
                  if dv.value:
                      derived_variable_code += ['self.{0} = ({1})'.format(
                          dv.name,
                          self.build_expression_from_tree(runnable,
                                                          regime,
                                                          dv.expression_tree))]
                  elif dv.select:
                      if dv.reduce:
                          derived_variable_code += self.build_reduce_code(dv.name,
                                                                          dv.select,
                                                                          dv.reduce)
                      else:
                          derived_variable_code += ['self.{0} = (self.{1})'.format(
                              dv.name,
                              dv.select.replace('/', '.'))]
                  else:
                      raise SimBuildError(('Inconsistent derived variable settings'
                                           'for {0}').format(dvn))
              elif dvn in dynamics.conditional_derived_variables:
                  dv = dynamics.conditional_derived_variables[dvn]
                  runnable.add_derived_variable(dv.name)
                  derived_variable_code += self.build_conditional_derived_var_code(runnable,
                                                                                   regime,
                                                                                   dv)
              else:
                  raise SimBuildError("Unknown derived variable '{0}' in '{1}'",
                                       dvn, runnable.id)
          runnable.add_method('update_derived_variables' + suffix, ['self'],
                              derived_variable_code)
  
          # Process event handlers
          pre_event_handler_code = []
          post_event_handler_code = []
          startup_event_handler_code = []
          on_entry_added = False
          for eh in regime.event_handlers:
              if isinstance(eh, OnStart):
                  startup_event_handler_code += self.build_event_handler(runnable,
                                                                         regime,
                                                                         eh)
              elif isinstance(eh, OnCondition):
                  post_event_handler_code += self.build_event_handler(runnable,
                                                                      regime,
                                                                      eh)
              else:
                  if isinstance(eh, OnEntry):
                      on_entry_added = True
                  pre_event_handler_code += self.build_event_handler(runnable,
                                                                     regime,
                                                                     eh)
          if isinstance(regime, Regime) and not on_entry_added:
              pre_event_handler_code += self.build_event_handler(runnable, regime, OnEntry())
              
          runnable.add_method('run_startup_event_handlers' + suffix, ['self'],
                              startup_event_handler_code)
          runnable.add_method('run_preprocessing_event_handlers' + suffix, ['self'],
                              pre_event_handler_code)
          runnable.add_method('run_postprocessing_event_handlers' + suffix, ['self'],
                              post_event_handler_code)