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
This function runs multiple simulations in parallel.