docs: def run_simulations(self, parameter_list, data_folder):
          """
          This function runs multiple simulations in parallel.
          """
  
          # Open up a session
          s = drmaa.Session()
          s.initialize()
  
          # Create a job template for each parameter combination
          jobs = {}
          for parameter in parameter_list:
              # Initialize result
              current_result = {
                  'params': {},
                  'meta': {}
              }
              current_result['params'].update(parameter)
  
              command = " ".join([self.script_executable] + ['--%s=%s' % (param,
                                                                          value)
                                                             for param, value in
                                                             parameter.items()])
  
              # Run from dedicated temporary folder
              current_result['meta']['id'] = str(uuid.uuid4())
              temp_dir = os.path.join(data_folder, current_result['meta']['id'])
              if not os.path.exists(temp_dir):
                  os.makedirs(temp_dir)
  
              jt = s.createJobTemplate()
              jt.remoteCommand = os.path.dirname(
                  os.path.abspath(__file__)) + '/run_program.sh'
              jt.args = [command]
              jt.jobEnvironment = self.environment
              jt.workingDirectory = temp_dir
              jt.nativeSpecification = SIMULATION_GRID_PARAMS
              output_filename = os.path.join(temp_dir, 'stdout')
              error_filename = os.path.join(temp_dir, 'stderr')
              jt.outputPath = ':' + output_filename
              jt.errorPath = ':' + error_filename
  
              jobid = s.runJob(jt)
  
              # Save the template in our dictionary
              jobs[jobid] = {
                  'template': jt,
                  'result': current_result,
                  'output': output_filename,
                  'error': error_filename,
                  }
  
          # Check for job completion, yield results when they are ready
          try:
  
              while len(jobs):
                  found_done = False
                  for curjob in jobs.keys():
                      try:
                          status = s.jobStatus(curjob)
                      except drmaa.errors.DrmCommunicationException:
                          pass
                      if status is drmaa.JobState.DONE:
  
                          current_result = jobs[curjob]['result']
  
                          # TODO Actually compute time elapsed in the running
                          # state
                          current_result['meta']['elapsed_time'] = 0
  
                          try:
                              s.deleteJobTemplate(jobs[curjob]['template'])
                          except drmaa.errors.DrmCommunicationException:
                              pass
  
                          del jobs[curjob]
  
                          found_done = True
  
                          yield current_result
  
                          break
                  if not found_done:  # Sleep if we can't find a completed task
                      time.sleep(6)
  
          finally:
              try:
                  for v in jobs.values():
                      s.deleteJobTemplate(v['template'])
                  s.control(drmaa.JOB_IDS_SESSION_ALL,
                            drmaa.JobControlAction.TERMINATE)
                  s.synchronize([drmaa.JOB_IDS_SESSION_ALL], dispose=True)
                  s.exit()
              except(drmaa.errors.NoActiveSessionException):
                  pass