feat: code release

.gitattributes

@@ -33,3 +33,34 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+solvers/advection/beta_0.1/seeds/visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/advection/beta_0.1/seeds/visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/advection/beta_0.1/seeds/visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/advection/beta_0.1/seeds/visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/advection/beta_0.1/seeds/visualization_4.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.01/seeds/burgers_visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.01/seeds/burgers_visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.01/seeds/burgers_visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.01/seeds/burgers_visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.01/seeds/burgers_visualization_4.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/burgers_visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/burgers_visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/burgers_visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/burgers_visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/burgers_visualization_4.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_0.1/seeds/output_2.txt filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_1.0/seeds/burgers_visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_1.0/seeds/burgers_visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_1.0/seeds/burgers_visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_1.0/seeds/burgers_visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/burgers/nu_1.0/seeds/burgers_visualization_4.png filter=lfs diff=lfs merge=lfs -text
+solvers/cns1d/eta_0.1/seeds/visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/cns1d/eta_0.1/seeds/visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/cns1d/eta_0.1/seeds/visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/cns1d/eta_0.1/seeds/visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/cns1d/eta_0.1/seeds/visualization_4.png filter=lfs diff=lfs merge=lfs -text
+solvers/reacdiff1d/nu_0.5_rho_1.0/seeds/visualization_0.png filter=lfs diff=lfs merge=lfs -text
+solvers/reacdiff1d/nu_0.5_rho_1.0/seeds/visualization_1.png filter=lfs diff=lfs merge=lfs -text
+solvers/reacdiff1d/nu_0.5_rho_1.0/seeds/visualization_2.png filter=lfs diff=lfs merge=lfs -text
+solvers/reacdiff1d/nu_0.5_rho_1.0/seeds/visualization_3.png filter=lfs diff=lfs merge=lfs -text
+solvers/reacdiff1d/nu_0.5_rho_1.0/seeds/visualization_4.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,131 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+.outputs/
+.hydra/

README.md

@@ -1,3 +1,34 @@
----
-license: mit
----
+## CodePDE
+
+This is the official implementation for [CodePDE: An Inference Framework for LLM-driven PDE Solver Generation](https://arxiv.org/abs/2505.08783), the first inference framework for generating PDE solvers using large language models (LLMs).
+
+### Dependencies
+
+The required packages are listed in `requirements.txt`, which can be installed by running `pip install -r requirements.txt`. 
+
+### Getting started
+
+Download the data using the `data/data_download.py` script from PDEbench. Then process the data with the `data/extract_data_subsets.py` script.
+
+Set up the configurations in `config` and run `python main.py`.
+
+In the _repeated sampling_ mode, the LLM generates solvers from scratch.
+
+In the _refinement_ mode, the LLM uses existing solvers in the `solvers` folder as "seeds" (e.g., `solvers/burgers/nu_0.01/seeds` for Burgers Equation with $\nu=0.01$) and tries to improve upon the "seeds".
+
+In the _funsearch_ mode, the LLM uses a few solvers generated in the _repeated sampling_ stage to warm start the program database and then generates new solvers via evolutionary search. The implementation assumes that the _repeated sampling_ results are stored under `../archived_logs`.
+
+### Contact
+
+May you have any questions on our work or implementation, feel free to reach out to [`[email protected]`]([email protected])!
+
+If you find this repository useful, please consider giving a star ⭐ and cite our paper.
+
+```
+@article{li2025codepde,
+  title={CodePDE: An Inference Framework for LLM-driven PDE Solver Generation},
+  author={Li, Shanda and Marwah, Tanya and Shen, Junhong and Sun, Weiwei and Risteski, Andrej and Yang, Yiming and Talwalkar, Ameet},
+  journal={arXiv preprint arXiv:2505.08783},
+  year={2025}
+}
+```

code_generation.py

@@ -0,0 +1,438 @@
+import json
+import math
+import os
+import re
+import shutil
+import signal
+import subprocess
+import time
+
+
+from llm_api import generate_response
+from prompt_files import general_prompt, pde_descriptions
+
+
+def file_to_string(file_path):
+    with open(file_path) as f:
+        string = ''.join(f.readlines())
+    return string
+
+
+def get_last_line(output_file):
+    with open(output_file, 'r') as f:
+        lines = f.readlines()
+    result_line = lines[-1]
+    return result_line
+
+
+def generate_pde_description(cfg, pde_name):
+    if pde_name == 'advection':
+        pde_description = pde_descriptions.advection_description.format(advection_beta=cfg.pde.beta)
+    elif pde_name == 'burgers':
+        pde_description = pde_descriptions.burgers_description.format(burgers_nu=cfg.pde.nu)
+    elif pde_name == 'reacdiff1d':
+        pde_description = pde_descriptions.reacdiff_1d_description.format(reacdiff1d_nu=cfg.pde.nu,
+            reacdiff1d_rho=cfg.pde.rho)
+    elif pde_name == 'cns1d':
+        pde_description = pde_descriptions.cns1d_description.format(cns1d_eta=cfg.pde.eta)
+    elif pde_name == 'darcy':
+        pde_description = pde_descriptions.darcy_description.format()
+    elif pde_name == 'ins2d':
+        pde_description = pde_descriptions.ins2d_description.format()
+    else:
+        raise ValueError(f'PDE {pde_name} not recognized')
+    return pde_description
+
+
+def generate_initial_prompt_without_seed(cfg, pde_name):
+    system_prompt = general_prompt.system_prompt
+    pde_description = generate_pde_description(cfg, pde_name)
+    
+    solver_template = file_to_string(f'solvers/{pde_name}/solver_template.py')
+
+    problem = general_prompt.code_generation_without_seed_prompt.format(
+        pde_description=pde_description,
+        solver_template=solver_template
+    )
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": problem}
+    ]
+    return messages 
+
+
+def generate_initial_prompt(
+    cfg,
+    seed_implementations:list,
+    working_folder: str,
+    pde_name:str = 'burgers'
+):
+    system_prompt = general_prompt.system_prompt
+
+    pde_description = generate_pde_description(cfg, pde_name)
+
+    if cfg.method.name == 'funsearch':
+        seed_folder = working_folder
+    else:
+        # cfg.method.name == 'refine'
+        seed_folder = os.path.join('solvers', pde_name, cfg.pde.pde_setting_name, 'seeds')
+    examples = [
+        general_prompt.code_sample.format(
+            id=example_id,
+            code=file_to_string(os.path.join(seed_folder, f'implementation_{seed_id}.py')),
+            code_output=get_last_line(os.path.join(seed_folder, f'output_{seed_id}.txt')),
+        )
+        for example_id, seed_id in enumerate(seed_implementations)
+    ]
+       
+    code_samples = ''.join(examples)
+    
+    problem = general_prompt.problem_prompt.format(
+        pde_description=pde_description,
+        code_samples=code_samples)
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": problem}
+    ]
+    return messages
+
+
+def generate_debugging_prompt(
+    round_idx:int,
+    working_folder: str,
+    debugging_reason:str = 'execution_error'
+):
+    # Load the prompt from the file
+    with open(os.path.join(working_folder, f'messages_{round_idx}.json'), 'r') as f:
+        messages = json.load(f)
+    # Load model response
+    model_response = file_to_string(os.path.join(working_folder, f'responses_{round_idx}.txt'))
+    messages.append({"role": "assistant", "content": model_response})
+    # Load the error message (truncated to the last 5000 characters)
+    code_output = file_to_string(os.path.join(working_folder, f'output_{round_idx}.txt'))[-5000:]
+    errors = file_to_string(os.path.join(working_folder, f'errors_{round_idx}.txt'))[-5000:]
+    if debugging_reason == 'execution_error':
+        feebdack = general_prompt.debugging_execution_error_prompt.format(
+            code_output=code_output,
+            error_message=errors
+        )
+    else: # debugging_reason == 'nan_inf'
+        feebdack = general_prompt.debugging_nan_inf_prompt.format(
+            code_output=code_output,
+            error_message=errors
+        )
+    messages.append({"role": "user", "content": feebdack})
+    return messages
+
+
+def generate_prompt(
+    cfg,
+    round_idx:int,
+    working_folder: str,
+    seed_implementations: list|None = None,
+    generation_mode:str='initial',
+    pde_name:str='burgers'
+):
+    if generation_mode == 'debugging_execution_error':
+        prompt = generate_debugging_prompt(
+            round_idx=round_idx,
+            working_folder=working_folder,
+            debugging_reason='execution_error'
+        )
+    elif generation_mode == 'debugging_nan_inf':
+        prompt = generate_debugging_prompt(
+            round_idx=round_idx,
+            working_folder=working_folder,
+            debugging_reason='nan_inf'
+        )
+    elif seed_implementations is None or len(seed_implementations) == 0:
+        prompt = generate_initial_prompt_without_seed(
+            cfg,
+            pde_name=pde_name
+        )
+    else:
+        prompt = generate_initial_prompt(
+            cfg,
+            seed_implementations=seed_implementations,
+            working_folder=working_folder,
+            pde_name=pde_name
+        )
+
+    return prompt
+
+
+def code_generation(
+    cfg, 
+    round_idx:int,
+    working_folder: str,
+    seed_implementations: list|None = None,
+    generation_mode: str = 'initial',
+    pde_name: str = 'burgers',
+    model_name='deepseek-chat'
+):
+
+    messages = generate_prompt(
+        cfg,
+        round_idx=round_idx,
+        working_folder=working_folder,
+        seed_implementations=seed_implementations,
+        generation_mode=generation_mode,
+        pde_name=pde_name
+    )
+
+    # Save the messages to a file
+    with open(os.path.join(working_folder, f'messages_{round_idx}.json'), 'w') as f:
+        json.dump(messages, f, ensure_ascii=False, indent=4) 
+    responses = generate_response(messages, cfg)
+    if 'claude' in model_name:
+        content = ''
+        for block in responses.content:
+            if block.type == 'thinking':
+                # Save the CoT of Claude-thinking
+                with open(os.path.join(working_folder, f'thinking_{round_idx}.txt'), 'w') as f:
+                    f.write(str(block.thinking))
+                if content == '':
+                    content = block.thinking
+            elif block.type == 'text':
+                # Extract the final response
+                content = block.text
+    elif 'gemini' in model_name:
+        content = responses.text
+    elif 'qwq' in model_name:
+        content = responses
+    else:
+        content = responses.choices[0].message.content
+    # Save the response to a file
+    with open(os.path.join(working_folder, f'responses_{round_idx}.txt'), 'w') as f:
+        f.write(content)
+
+    matches = re.findall(
+        r'```python(.*?)```',
+        content, re.DOTALL)
+
+    if not matches:
+        raise ValueError('No relevant code block found in response')
+
+    generated_code = max(matches, key=len)
+
+    with open(os.path.join(working_folder, f'implementation_{round_idx}.py'), 'w') as f:
+        f.write(generated_code)
+
+
+def code_execution(
+    cfg, 
+    working_folder: str,
+    round_idx: int = 0,
+    pde_name: str = 'burgers',
+    eval_dataset: str = None
+):
+    # Copy the implementation file to solver.py to make the evaluator's life easier
+    os.system(f'cp {working_folder}/implementation_{round_idx}.py {working_folder}/solver.py')
+    
+    # Open files for standard output and error logging
+    job_out = open(os.path.join(working_folder, f'output_{round_idx}.txt'), 'w')
+    job_err = open(os.path.join(working_folder, f'errors_{round_idx}.txt'), 'w')
+
+    # Construct the base command
+    if eval_dataset is None:
+        eval_dataset = os.path.join(cfg.root_dataset_folder, cfg.pde.dataset_folder_for_eval)
+    cmd = (
+        f'CUDA_VISIBLE_DEVICES={cfg.assigned_gpu} '
+        f'python {working_folder}/evaluator.py '
+        f'--save-pth {working_folder} '
+        f'--run-id {round_idx} '
+        f'--dataset-path-for-eval '
+        f'{eval_dataset} '
+    )
+    # Note: In Funsearch, we will need to customize the eval_dataset to seperate development and testing
+
+    # Append PDE-specific hyperparameters to the command
+    if pde_name == 'advection':
+        hyperparam = f'--beta {cfg.pde.beta} '
+    elif pde_name == 'burgers':
+        hyperparam = f'--nu {cfg.pde.nu} '
+    elif pde_name == 'reacdiff1d':
+        hyperparam = f'--nu {cfg.pde.nu} --rho {cfg.pde.rho} '
+    elif pde_name == 'cns1d':
+        hyperparam = f'--eta {cfg.pde.eta} '
+    elif pde_name in ['darcy', 'ins2d']:
+        hyperparam = f' '  # No hyperparameters for these two
+    else:
+        raise ValueError(f'PDE {pde_name} not recognized')
+    
+    try:
+        # Start process using Popen
+        process = subprocess.Popen(
+            f'{cmd} {hyperparam}',
+            shell=True,
+            stdout=job_out,
+            stderr=job_err,
+            text=True,
+            preexec_fn=os.setsid  # Create a new process group
+        )
+        
+        # Wait for the process with timeout
+        exit_code = process.wait(timeout=cfg.pde.timeout)
+        stderr = None
+        status = "completed"
+  
+    except subprocess.TimeoutExpired:
+        # Kill the entire process group on timeout
+        os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+        
+        # Wait a moment for graceful termination
+        time.sleep(2)
+        
+        # If still running, use SIGKILL
+        if process.poll() is None:
+            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+        
+        # Clean up any GPU processes that might still be running
+        cleanup_gpu_processes(cfg.assigned_gpu)
+        
+        job_out.write(f"Process exceeded the {cfg.pde.timeout}-second timeout limit.\n")
+        job_err.write(f"Process exceeded the {cfg.pde.timeout}-second timeout limit.\n")
+        exit_code = -1
+        stderr = "TimeoutExpired: Process exceeded the timeout limit."
+        status = "timeout"
+        
+    finally:
+        # Always close the files
+        job_out.close()
+        job_err.close()
+
+    return {
+        "exit_code": exit_code,
+        "stderr": stderr,
+        "status": status
+    }
+
+def cleanup_gpu_processes(gpu_id):
+    """
+    Clean up any orphaned processes still using the specified GPU
+    """
+    try:
+        # Find all processes using this GPU
+        result = subprocess.run(
+            f"nvidia-smi --query-compute-apps=pid --format=csv,noheader,nounits -i {gpu_id}",
+            shell=True,
+            capture_output=True,
+            text=True
+        )
+        
+        # Extract process IDs
+        pids = result.stdout.strip().split('\n')
+        
+        # Kill each process
+        for pid in pids:
+            if pid and pid.isdigit():
+                try:
+                    os.kill(int(pid), signal.SIGKILL)
+                    print(f"Killed GPU process with PID {pid}")
+                except ProcessLookupError:
+                    pass  # Process already terminated
+    except Exception as e:
+        print(f"Error during GPU cleanup: {e}")
+
+
+def get_results(output_file):
+    result_line = get_last_line(output_file)
+
+    relative_error_match = re.search(r'nRMSE: (.*?)\t', result_line)
+    relative_error = float(relative_error_match.group(1))
+
+    elapsed_time_match = re.search(r'Time: (.*?)s', result_line)
+    elapsed_time = float(elapsed_time_match.group(1))
+
+    avg_rate_match = re.search(
+        r'Average convergence rate: (.*?)\t', result_line)
+    avg_rate = float(avg_rate_match.group(1))
+
+    return relative_error, elapsed_time, avg_rate
+
+
+def prepare_working_folder(
+    cfg, 
+    working_folder, 
+    pde_name='burgers',
+    use_sample_solver_init=False
+):
+    result_sheet_path = os.path.join(working_folder, 'test_results.csv')
+    print('Generating result sheet')
+    with open(result_sheet_path, 'w') as f:
+        f.write('round,nRMSE,elapsed_time,convergence_rate,num_trial\n')
+
+    evluator_path = os.path.join(working_folder, f'evaluator.py')
+    os.system(f'cp solvers/{pde_name}/evaluator.py {evluator_path}')
+    
+    if use_sample_solver_init:
+        # We don't copy the sample solvers, nor execute them.
+        pass
+
+
+def generate_and_debug(
+    cfg,
+    round_idx:int,
+    num_trials:int,
+    pde_name:str,
+    working_folder:str,
+    seed_implementations:list|None,
+    model_name:str
+):
+    generation_mode = 'initial'
+    for num_trial in range(1, num_trials+1):
+        # When num_trial==1, it is not debugging
+        # The output of the generated code will be saved in 
+        # os.path.join(working_folder, f'generated_code_{round_idx}.txt')
+        code_generation(
+            cfg, 
+            round_idx=round_idx,
+            working_folder=working_folder,
+            seed_implementations=seed_implementations,
+            generation_mode=generation_mode,
+            pde_name=pde_name,
+            model_name=model_name
+        )
+        print(f'Round {round_idx}, trial {num_trial} code generation completed successfully')
+
+        print(f'Round {round_idx}, trial {num_trial} code execution started')
+        execution_results = code_execution(
+            cfg, 
+            working_folder=working_folder,
+            round_idx=round_idx,
+            pde_name=pde_name
+        )
+
+        if execution_results['exit_code'] != 0:
+            print(f'Error in round {round_idx}, trial {num_trial} code execution.')
+            if num_trial < num_trials:
+                print(f'Let LLM debug the code')
+                generation_mode = 'debugging_execution_error'
+            else:
+                with open(os.path.join(working_folder, 'test_results.csv'), 'a') as f:
+                    f.write(f'{round_idx},failed,failed,failed,{num_trial}\n')
+                raise ValueError(f'Error in round {round_idx}, trial {num_trial} code execution.')
+            
+        else:
+            print(f'Round {round_idx}, trial {num_trial} completed successfully')
+            relative_error, elapsed_time, avg_rate = get_results(
+                os.path.join(working_folder, f'output_{round_idx}.txt')
+            )
+
+            if (
+                (math.isnan(relative_error) or math.isinf(relative_error))
+                and num_trial < num_trials
+            ):
+                # If we get NaN or Inf in nRMSE and still have chances to debug, we will debug the code
+                print(f'nRMSE is NaN/Inf in round {round_idx}, trial {num_trial} code execution.')
+                print(f'Let LLM debug the code')
+                generation_mode = 'debugging_nan_inf'
+            else:
+                # Otherwise, we will save the results and break the loop
+                with open(os.path.join(working_folder, 'test_results.csv'), 'a') as f:
+                    f.write(f'{round_idx},{relative_error},{elapsed_time},{avg_rate},{num_trial}\n')
+                print(f'nRMSE: {relative_error:.5f}\t| Time: {elapsed_time:.2f}s\t| Rate: {avg_rate}\t| Trial: {num_trial}')
+                return relative_error, elapsed_time, avg_rate
+    return None, None, None

configs/default.yaml

@@ -0,0 +1,21 @@
+# @package _global_
+defaults:
+  - _self_
+  - pde: burgers
+  - model: gpt-4.1
+  - method: repeated_sample
+
+log_path: ../working_logs
+# log_path: ../tmp_test
+
+folder_name_suffix: ''
+redirect_stdout: False
+assigned_gpu: 1
+
+working_folder: ${log_path}/${pde.name}/${pde.pde_setting_name}${folder_name_suffix}/${method.name}/${model.name}/${now:%Y-%m-%d-%H-%M-%S}/
+
+root_dataset_folder: ../dataset/CodePDE  # Replace with your dataset path. Absolute path is recommended.
+
+hydra:
+  run:
+    dir: ${working_folder}

configs/method/funsearch.yaml

@@ -0,0 +1,9 @@
+# @package method
+num_search_rounds: 2
+num_debugging_trials_per_sample: 5
+
+num_initial_seeds: 12
+
+name: 'funsearch'
+
+use_sample_solver_init: True

configs/method/refine.yaml

@@ -0,0 +1,9 @@
+# @package method
+num_repeated_samples: 2
+num_debugging_trials_per_sample: 5
+
+num_sample_for_refine: 5
+name: 'refine_sample${method.num_sample_for_refine}'
+
+start_round: 0
+use_sample_solver_init: True

configs/method/repeated_sample.yaml

@@ -0,0 +1,4 @@
+# @package method
+name: repeated_sample
+num_repeated_samples: 2
+num_debugging_trials_per_sample: 5

configs/model/claude-3-5-haiku.yaml

@@ -0,0 +1,6 @@
+# @package model
+family_name: claude
+name: claude-3-5-haiku-20241022
+api_key: <API_KEY>
+
+thinking: False

configs/model/claude-3-7-sonnet-thinking.yaml

@@ -0,0 +1,6 @@
+# @package model
+family_name: claude
+name: claude-3-7-sonnet-20250219
+api_key: <API_KEY>
+
+thinking: True

configs/model/claude-3-7-sonnet.yaml

@@ -0,0 +1,6 @@
+# @package model
+family_name: claude
+name: claude-3-7-sonnet-20250219
+api_key: <API_KEY>
+
+thinking: False

configs/model/deepseek-chat.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: deepseek
+name: deepseek-chat
+api_key: <API_KEY>
+base_url: https://api.deepseek.com

configs/model/deepseek-reasoner.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: deepseek
+name: deepseek-reasoner
+api_key: <API_KEY>
+base_url: https://api.deepseek.com

configs/model/gemini-2.0-flash-thinking.yaml

@@ -0,0 +1,4 @@
+# @package model
+family_name: gemini
+name: gemini-2.0-flash-thinking-exp
+api_key: <API_KEY>

configs/model/gemini-2.0-flash.yaml

@@ -0,0 +1,4 @@
+# @package model
+family_name: gemini
+name: gemini-2.0-flash
+api_key: <API_KEY>

configs/model/gemini-2.5-pro.yaml

@@ -0,0 +1,4 @@
+# @package model
+family_name: gemini
+name: gemini-2.5-pro-preview-06-05
+api_key: <API_KEY>

configs/model/gpt-4.1.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: gpt
+name: gpt-4.1-2025-04-14
+
+api_key: <API_KEY>

configs/model/gpt-4o-mini.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: gpt
+name: gpt-4o-mini-2024-07-18
+
+api_key: <API_KEY>

configs/model/gpt-4o.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: gpt
+name: gpt-4o-2024-08-06
+
+api_key: <API_KEY>

configs/model/o1-mini.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: o
+name: o1-mini
+
+api_key: <API_KEY>

configs/model/o3-mini.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: o
+name: o3-mini
+
+api_key: <API_KEY>

configs/model/o3.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: o
+name: o3
+
+api_key: <API_KEY>

configs/model/o4-mini.yaml

@@ -0,0 +1,5 @@
+# @package model
+family_name: o
+name: o4-mini
+
+api_key: <API_KEY>

configs/model/qwen-max.yaml

@@ -0,0 +1,6 @@
+# @package model
+family_name: qwen
+name: qwen-max
+
+api_key: <API_KEY>
+base_url: https://dashscope.aliyuncs.com/compatible-mode/v1

configs/model/qwq.yaml

@@ -0,0 +1,6 @@
+# @package model
+family_name: qwen
+name: qwq-plus
+
+api_key: <API_KEY>
+base_url: https://dashscope.aliyuncs.com/compatible-mode/v1

configs/pde/advection.yaml

@@ -0,0 +1,10 @@
+# @package pde
+name: advection
+beta: 0.1 # choices: [0.1, 0.2, 0.4, 0.7, 1.0, 2.0, 4.0, 7.0]
+
+pde_setting_name: 'beta_${pde.beta}'
+
+# To be appended to `root_dataset_folder` to get the full path
+dataset_folder_for_eval: Advection/1D_Advection_Sols_beta${pde.beta}_development.hdf5
+
+timeout: 1200

configs/pde/burgers.yaml

@@ -0,0 +1,10 @@
+# @package pde
+name: burgers
+nu: 0.01 # choices: [1.0, 2.0, 4.0, 0.1, 0.2, 0.4, 0.01, 0.02, 0.04, 0.001, 0.002, 0.004]
+
+pde_setting_name: nu_${pde.nu}
+
+# To be appended to `root_dataset_folder` to get the full path
+dataset_folder_for_eval: Burgers/1D_Burgers_Sols_Nu${pde.nu}_development.hdf5
+
+timeout: 1200

configs/pde/cns1d.yaml

@@ -0,0 +1,10 @@
+# @package pde
+name: cns1d
+eta: 0.1 # choices: [0.01, 0.1, 1.e-8]
+
+pde_setting_name: 'eta_${pde.eta}'
+
+# To be appended to `root_dataset_folder` to get the full path
+dataset_folder_for_eval: CNS/1D_CFD_Rand_Eta${pde.eta}_Zeta${pde.eta}_periodic_Train_development.hdf5
+
+timeout: 2400

configs/pde/darcy.yaml

@@ -0,0 +1,9 @@
+# @package pde
+name: darcy
+
+pde_setting_name: 'beta_1.0'
+
+# To be appended to `root_dataset_folder` to get the full path
+dataset_folder_for_eval: Darcy/piececonst_r421_N1024_smooth1_sample50_development.hdf5
+
+timeout: 1200

configs/pde/reacdiff1d.yaml

@@ -0,0 +1,11 @@
+# @package pde
+name: reacdiff1d
+nu: 0.5 # choices: [0.5, 1.0, 2.0, 5.0]
+rho: 1.0 # choices: [1.0, 2.0, 5.0, 10.0]
+
+pde_setting_name: 'nu_${pde.nu}_rho_${pde.rho}'
+
+# To be appended to `root_dataset_folder` to get the full path
+dataset_folder_for_eval: ReactionDiffusion/ReacDiff_Nu${pde.nu}_Rho${pde.rho}_development.hdf5
+
+timeout: 2400

data/data_download.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+import os
+import argparse
+from pathlib import Path
+
+import pandas as pd
+from torchvision.datasets.utils import download_url
+from tqdm import tqdm
+
+
+def parse_metadata(pde_names):
+    """
+    This function parses the argument to filter the metadata of files that need to be downloaded.
+
+    Args:
+    pde_names: List containing the name of the PDE to be downloaded
+    df      : The provided dataframe loaded from the csv file
+
+    Options for pde_names:
+    - Advection
+    - Burgers
+    - 1D_CFD
+    - Diff-Sorp
+    - 1D_ReacDiff
+    - 2D_CFD
+    - Darcy
+    - 2D_ReacDiff
+    - NS_Incom
+    - SWE
+    - 3D_CFD
+
+    Returns:
+    pde_df : Filtered dataframe containing metadata of files to be downloaded
+    """
+
+    meta_df = pd.read_csv(os.path.join(os.path.dirname(__file__), 'pdebench_data_urls.csv'))
+
+    # Ensure the pde_name is defined
+    pde_list = [
+        "advection",
+        "burgers",
+        "1d_cfd",
+        "diff_sorp",
+        "1d_reacdiff",
+        "2d_cfd",
+        "darcy",
+        "2d_reacdiff",
+        "ns_incom",
+        "swe",
+        "3d_cfd",
+    ]
+    pde_names = [pde_names]
+    pde_names = [name.lower() for name in pde_names]
+
+    assert all(name.lower() in pde_list for name in pde_names), "PDE name not defined."
+
+    # Filter the files to be downloaded
+    meta_df["PDE"] = meta_df["PDE"].str.lower()
+
+    return meta_df[meta_df["PDE"].isin(pde_names)]
+
+
+def download_data(root_folder, pde_name):
+    """ "
+    Download data splits specific to a given PDE.
+
+    Args:
+    root_folder: The root folder where the data will be downloaded
+    pde_name   : The name of the PDE for which the data to be downloaded
+    """
+
+    # print(f"Downloading data for {pde_name} ...")
+
+    # Load and parse metadata csv file
+    pde_df = parse_metadata(pde_name)
+
+    # Iterate filtered dataframe and download the files
+    for _, row in tqdm(pde_df.iterrows(), total=pde_df.shape[0]):
+        file_path = Path(root_folder) / row["Path"]
+        download_url(row["URL"], file_path, row["Filename"], md5=row["MD5"])
+
+
+if __name__ == "__main__":
+    arg_parser = argparse.ArgumentParser(
+        prog="Download Script",
+        description="Helper script to download the PDEBench datasets",
+        epilog="",
+    )
+
+    arg_parser.add_argument(
+        "--root_folder",
+        type=str,
+        # required=True,
+        help="Root folder where the data will be downloaded",
+        default="../dataset",
+    )
+    arg_parser.add_argument(
+        "--pde_name",
+        action="append",
+        help="Name of the PDE dataset to download. You can use this flag multiple times to download multiple datasets",
+        default="burgers",
+    )
+
+    args = arg_parser.parse_args()
+
+    download_data(args.root_folder, args.pde_name)

data/extract_data_subsets.py

@@ -0,0 +1,57 @@
+import h5py
+import numpy as np
+import os
+
+def work(dataset_path, subset_path, subset_selection):
+    # Load data from file
+    with h5py.File(dataset_path, 'r') as f:
+        # Load the data
+        t_coordinate = np.array(f['t-coordinate'])[:-1]  # Keep as is
+        x_coordinate = np.array(f['x-coordinate'])  # Keep as is
+        u = subset_selection(np.array(f['tensor']))
+
+        # Navier-Stokes data has different structure
+        # Vx = subset_selection((f['Vx']))
+        # density = subset_selection(np.array(f['density']))
+        # pressure = subset_selection(np.array(f['pressure']))
+
+    # Verify shapes
+    print(t_coordinate.shape, x_coordinate.shape, u.shape)
+    # (201,) (1024,) (100, 201, 1024) for burgers equation
+
+    # Save the subset to a new HDF5 file
+    with h5py.File(subset_path, 'w') as f:
+        # Create datasets in the new file
+        f.create_dataset('t-coordinate', data=t_coordinate)
+        f.create_dataset('tensor', data=u)
+        f.create_dataset('x-coordinate', data=x_coordinate)
+
+        # Uncomment if you want to save Navier-Stokes specific data
+        # f.create_dataset('Vx', data=Vx)
+        # f.create_dataset('density', data=density)
+        # f.create_dataset('pressure', data=pressure)
+
+    print(f"Subset data saved successfully at {subset_path}!")
+
+if __name__ == '__main__':
+
+    dataset_dir = '../dataset/1D/Burgers/Train'
+    test_subset_size = 100
+    dev_subset_size = 50
+    subset_dir = '../dataset/CodePDE/Burgers'
+    if not os.path.exists(subset_dir):
+        print(f"Creating: {subset_dir}")
+        os.makedirs(subset_dir)
+    else:
+        print(f"Exist: {subset_dir}")
+
+    for item in os.listdir(dataset_dir):
+        full_path = os.path.join(dataset_dir, item)
+        if os.path.isfile(full_path):
+            print(full_path)
+
+            subset_path = os.path.join(subset_dir, item)
+            work(full_path, subset_path, lambda x: x[:test_subset_size])
+
+            development_subset_path = subset_path.replace('.hdf5', '_development.hdf5')
+            work(full_path, development_subset_path, lambda x: x[-dev_subset_size:])

data/pdebench_data_urls.csv

@@ -0,0 +1,376 @@
+PDE,Filename,URL,Path,MD5
+Advection,1D_Advection_Sols_beta0.1.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255672,1D/Advection/Train/,b4be2fc3383f737c76033073e6d2ccfb
+Advection,1D_Advection_Sols_beta0.2.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255671,1D/Advection/Train/,d47b52c1be4b6bcaa8748a8df2f5fbb8
+Advection,1D_Advection_Sols_beta0.4.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255674,1D/Advection/Train/,d595bbfd2c659df995a93cd40d6ea568
+Advection,1D_Advection_Sols_beta0.7.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255666,1D/Advection/Train/,f89030c240a1e90b55649776854a84c2
+Advection,1D_Advection_Sols_beta1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255675,1D/Advection/Train/,1fe41923a4123db55bf4e89bea32e142
+Advection,1D_Advection_Sols_beta2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255677,1D/Advection/Train/,0e9beff98693089c38e213a1f2b9ac43
+Advection,1D_Advection_Sols_beta4.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255676,1D/Advection/Train/,a87b03ff425496360e2732921805f47d
+Advection,1D_Advection_Sols_beta7.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/255664,1D/Advection/Train/,72a286ad2fcba574bd20bc045ba82d58
+Burgers,1D_Burgers_Sols_Nu1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/281365,1D/Burgers/Train/,9021eba35332d127306f11ef84c1a60f
+Burgers,1D_Burgers_Sols_Nu2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/281364,1D/Burgers/Train/,70fe0c24d9313e70f6059e5212bdb3d7
+Burgers,1D_Burgers_Sols_Nu4.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268188,1D/Burgers/Train/,8af7f70166c00ffad377c80fa477d81f
+Burgers,1D_Burgers_Sols_Nu0.001.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268190,1D/Burgers/Train/,44cb784d5a07aa2b1c864cabdcf625f9
+Burgers,1D_Burgers_Sols_Nu0.002.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268193,1D/Burgers/Train/,edf1cd13622d151dfde3e4e5af7a95b4
+Burgers,1D_Burgers_Sols_Nu0.004.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268191,1D/Burgers/Train/,435e1fecb8a64a0b4563bb8d09f81c33
+Burgers,1D_Burgers_Sols_Nu0.01.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/281363,1D/Burgers/Train/,e6d9a4f62baf9a29121a816b919e2770
+Burgers,1D_Burgers_Sols_Nu0.02.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268189,1D/Burgers/Train/,7c8c717a3a7818145877baa57106b090
+Burgers,1D_Burgers_Sols_Nu0.04.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/281362,1D/Burgers/Train/,16f4c7afaf8c16238be157e54c9297c7
+Burgers,1D_Burgers_Sols_Nu0.1.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268185,1D/Burgers/Train/,660ba1008d3843bf4e28d2895eb607ce
+Burgers,1D_Burgers_Sols_Nu0.2.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268187,1D/Burgers/Train/,01d9333254dff2f3cad090b61f5cf695
+Burgers,1D_Burgers_Sols_Nu0.4.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/268192,1D/Burgers/Train/,58327a6107e8f9defb5075677cc42533
+1D_CFD,1D_CFD_Rand_Eta0.01_Zeta0.01_periodic_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164672,1D/CFD/Train/,2fdd00138f1d7abc794fb953021a9f43
+1D_CFD,1D_CFD_Rand_Eta0.1_Zeta0.1_periodic_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164668,1D/CFD/Train/,45655bd77d006ab539c52b7fbcf099b9
+1D_CFD,1D_CFD_Rand_Eta1.e-8_Zeta1.e-8_periodic_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/135485,1D/CFD/Train/,ad22fe08b8abc721179dbb34f2cc8b2a
+1D_CFD,1D_CFD_Rand_Eta1.e-8_Zeta1.e-8_trans_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133155,1D/CFD/Train/,79857a11ad9a69d77b8cf249a1c72d06
+1D_CFD,1D_CFD_Shock_Eta1.e-8_Zeta1.e-8_trans_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133156,1D/CFD/Train/,08dffc3d84033c7574a70614703dd753
+1D_CFD,Sod1.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133145,1D/CFD/Test/ShockTube/,ef8271ce332b986e961a7aaedcae24e7
+1D_CFD,Sod2.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133146,1D/CFD/Test/ShockTube/,10e47c5c6ee0d1028f912a52bbf613d0
+1D_CFD,Sod3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133147,1D/CFD/Test/ShockTube/,495f2d2e0cee9b4ae28d7fef29bb7c68
+1D_CFD,Sod4.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133148,1D/CFD/Test/ShockTube/,544399b3d05ae514d66fc96982ee9db8
+1D_CFD,Sod5.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133149,1D/CFD/Test/ShockTube/,ca7fa6631201e8bd506914d3b0b9fe50
+1D_CFD,Sod6.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133150,1D/CFD/Train/ShockTube/,adb2d95bf0d48e03bc0d8f4a2cbcd1c6
+1D_CFD,Sod7.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133151,1D/CFD/Test/ShockTube/,b8d73e1e3ef862ef732a5fa43c64612e
+Diff_Sorp,1D_diff-sorp_NA_NA.h5,https://darus.uni-stuttgart.de/api/access/datafile/133020,1D/diffusion-sorption/,9d466d1213065619d087319e16d9a938
+1D_ReacDiff,ReacDiff_Nu0.5_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133177,1D/ReactionDiffusion/Train/,69a429239778d529cd419ed5888ea835
+1D_ReacDiff,ReacDiff_Nu0.5_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133178,1D/ReactionDiffusion/Train/,ff7c724b18e7ebe02e19c179852f48ee
+1D_ReacDiff,ReacDiff_Nu0.5_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133179,1D/ReactionDiffusion/Train/,ac907daa7e483d203a5c77567cdea561
+1D_ReacDiff,ReacDiff_Nu0.5_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133180,1D/ReactionDiffusion/Train/,fb149e7540d8977af158bb8fec1048a3
+1D_ReacDiff,ReacDiff_Nu1.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133181,1D/ReactionDiffusion/Train/,bd73c2f3448d03e95e98c3831fc8fa70
+1D_ReacDiff,ReacDiff_Nu1.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133182,1D/ReactionDiffusion/Train/,a94e65631881a27ddae3ef74caf53093
+1D_ReacDiff,ReacDiff_Nu1.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133183,1D/ReactionDiffusion/Train/,112c01a76447162bd67c8c1073f58ca2
+1D_ReacDiff,ReacDiff_Nu1.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133184,1D/ReactionDiffusion/Train/,fa224c9d143de37ac6914d391e70f425
+1D_ReacDiff,ReacDiff_Nu2.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133185,1D/ReactionDiffusion/Train/,925a7e2c9b9e40ad2dd44b7002ec882b
+1D_ReacDiff,ReacDiff_Nu2.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133186,1D/ReactionDiffusion/Train/,a3e25a9fb8a99f010352ad3dd1afd596
+1D_ReacDiff,ReacDiff_Nu2.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133187,1D/ReactionDiffusion/Train/,426353b241acfbc64067acb1bdc80ade
+1D_ReacDiff,ReacDiff_Nu2.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133188,1D/ReactionDiffusion/Train/,f2890bdac5103a3b78fac5f80e57b760
+1D_ReacDiff,ReacDiff_Nu5.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133189,1D/ReactionDiffusion/Train/,0ed75b55f61bec11c47d379e34959e54
+1D_ReacDiff,ReacDiff_Nu5.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133190,1D/ReactionDiffusion/Train/,264c80af0e2a6cc1f70e87275e0f6ac4
+1D_ReacDiff,ReacDiff_Nu5.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133191,1D/ReactionDiffusion/Train/,f927f5d85f2e9bd97dff31b4dab051ae
+1D_ReacDiff,ReacDiff_Nu5.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133192,1D/ReactionDiffusion/Train/,c9c26e2b5f2d4bf5bcbbd4ba34fefd5e
+1D_ReacDiff,ReacDiff_react_Nu0.5_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133157,1D/ReactionDiffusion/Test/,6dc95d36e7126c104c5316485670f2c0
+1D_ReacDiff,ReacDiff_react_Nu0.5_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133158,1D/ReactionDiffusion/Test/,5bf21fbc428ac4346c0e7a04a5899f9b
+1D_ReacDiff,ReacDiff_react_Nu0.5_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133159,1D/ReactionDiffusion/Test/,5198a1572c201657dc19ad8592e24ac1
+1D_ReacDiff,ReacDiff_react_Nu0.5_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133160,1D/ReactionDiffusion/Test/,9968701e89a8b406f18ffbc2b74045d8
+1D_ReacDiff,ReacDiff_react_Nu1.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133161,1D/ReactionDiffusion/Test/,a258ff5be23d17d89cb10ac94f512165
+1D_ReacDiff,ReacDiff_react_Nu1.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133162,1D/ReactionDiffusion/Test/,09279a597860dcf48ef6f6539c46920f
+1D_ReacDiff,ReacDiff_react_Nu1.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133163,1D/ReactionDiffusion/Test/,27113922509f6336f5c8be8d99109828
+1D_ReacDiff,ReacDiff_react_Nu1.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133164,1D/ReactionDiffusion/Test/,24ab563c27bf07d653b881d3c652bfa5
+1D_ReacDiff,ReacDiff_react_Nu10.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133165,1D/ReactionDiffusion/Test/,5a0f4d1ff304b11b9b22c3b00b1f63d4
+1D_ReacDiff,ReacDiff_react_Nu10.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133166,1D/ReactionDiffusion/Test/,4cf67490b01e54f80d45c8e7936b804d
+1D_ReacDiff,ReacDiff_react_Nu10.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133167,1D/ReactionDiffusion/Test/,3c54c1cd3710b1f5b02a3de3782201ed
+1D_ReacDiff,ReacDiff_react_Nu10.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133168,1D/ReactionDiffusion/Test/,580f08d5755ee393e7092eafedb70e46
+1D_ReacDiff,ReacDiff_react_Nu2.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133169,1D/ReactionDiffusion/Test/,208882dcf594d52f8e5017904efd84c9
+1D_ReacDiff,ReacDiff_react_Nu2.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133170,1D/ReactionDiffusion/Test/,891f8b47e49348b5411882ecebbc1bfd
+1D_ReacDiff,ReacDiff_react_Nu2.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133171,1D/ReactionDiffusion/Test/,56e8e1e55ac92acf21b253511c370642
+1D_ReacDiff,ReacDiff_react_Nu2.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133172,1D/ReactionDiffusion/Test/,4498954ef4cd5c63ac530ee46c351790
+1D_ReacDiff,ReacDiff_react_Nu5.0_Rho1.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133173,1D/ReactionDiffusion/Test/,6b2c45748711bea8779dea3b48a53a7e
+1D_ReacDiff,ReacDiff_react_Nu5.0_Rho10.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133174,1D/ReactionDiffusion/Test/,b04c22629bf86d85929386aaf4a5f95d
+1D_ReacDiff,ReacDiff_react_Nu5.0_Rho2.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133175,1D/ReactionDiffusion/Test/,1738e4374456af974e4d0058d3426a69
+1D_ReacDiff,ReacDiff_react_Nu5.0_Rho5.0.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133176,1D/ReactionDiffusion/Test/,4e3cf0ac66e85dbb77c79861076db8e8
+2D_CFD,2D_CFD_Rand_M0.1_Eta0.01_Zeta0.01_periodic_128_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164687,2D/CFD/2D_Train_Rand/,5b21dcccaef4d2145ca579a71153c580
+2D_CFD,2D_CFD_Rand_M0.1_Eta0.1_Zeta0.1_periodic_128_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164688,2D/CFD/2D_Train_Rand/,b2733888745a1d64e36df813e979910b
+2D_CFD,2D_CFD_Rand_M0.1_Eta1e-08_Zeta1e-08_periodic_512_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164689,2D/CFD/2D_Train_Rand/,ae2552864d0856f58dc74132a2f95d20
+2D_CFD,2D_CFD_Rand_M1.0_Eta0.01_Zeta0.01_periodic_128_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164690,2D/CFD/2D_Train_Rand/,21969082d0e9524bcc4708e216148e60
+2D_CFD,2D_CFD_Rand_M1.0_Eta0.1_Zeta0.1_periodic_128_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164691,2D/CFD/2D_Train_Rand/,75a34f34a3dcd9bc8ae4b7adf8bf372c
+2D_CFD,2D_CFD_Rand_M1.0_Eta1e-08_Zeta1e-08_periodic_512_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164692,2D/CFD/2D_Train_Rand/,04fcc44c39acea69e2869b84cd653d4a
+2D_CFD,2D_CFD_Turb_M0.1_Eta1e-08_Zeta1e-08_periodic_512_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164685,2D/CFD/2D_Train_Turb/,844555000d342d2947162c6cf46798e7
+2D_CFD,2D_CFD_Turb_M1.0_Eta1e-08_Zeta1e-08_periodic_512_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164686,2D/CFD/2D_Train_Turb/,3f2c7376cde5fb072db0f9814f1c6992
+2D_CFD,2D_shock.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133193,2D/CFD/Test/2DShock/,b4098c20e2e0a25cd8ee229c9294b899
+2D_CFD,KH_M01_dk10_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133209,2D/CFD/Test/KH/,54e278b3a7419107a5cd6a8a019225d5
+2D_CFD,KH_M01_dk1_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133210,2D/CFD/Test/KH/,29ce31d3ce61de3b90ac0b42716c061c
+2D_CFD,KH_M01_dk2_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133211,2D/CFD/Test/KH/,de0b2a3343de028e4c162723ec571713
+2D_CFD,KH_M01_dk5_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133212,2D/CFD/Test/KH/,5bcaed9eb7db5fd55d51f7347a938413
+2D_CFD,KH_M02_dk1_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133213,2D/CFD/Test/KH/,fbc392f83affc2224a5703dad7bda28a
+2D_CFD,KH_M04_dk1_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133214,2D/CFD/Test/KH/,66626c935ab070a1e5df52bcf6aeccc7
+2D_CFD,KH_M1_dk1_Re1e3.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133215,2D/CFD/Test/KH/,338393c118196048a38d1df731a33b0a
+2D_CFD,OTVortex.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133216,2D/CFD/Test/TOV/,3b68cb29e3d1906a19ce2cb4ce71faa4
+Darcy,2D_DarcyFlow_beta0.01_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133217,2D/DarcyFlow/,d05c287d4c0b7d3178b0097084238251
+Darcy,2D_DarcyFlow_beta0.1_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133218,2D/DarcyFlow/,294f9a03a4aa16b0e386469ca8b471be
+Darcy,2D_DarcyFlow_beta1.0_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133219,2D/DarcyFlow/,81694ed31306ff2e5f6b76349b0b4389
+Darcy,2D_DarcyFlow_beta10.0_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133220,2D/DarcyFlow/,a7f23cf8011fc211b180828af39b7d1a
+Darcy,2D_DarcyFlow_beta100.0_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133221,2D/DarcyFlow/,7c09f3b1bb097737d3fd52ffb0c6f1c8
+2D_ReacDiff,2D_diff-react_NA_NA.h5,https://darus.uni-stuttgart.de/api/access/datafile/133017,2D/diffusion-reaction/,b8d0b86064193195ddc30c33be5dc949
+NS_Incom,ns_incom_inhom_2d_512-0.h5,https://darus.uni-stuttgart.de/api/access/datafile/133280,2D/NS_incom/,54109d46f9c957317bd670ddb2068ac0
+NS_Incom,ns_incom_inhom_2d_512-1.h5,https://darus.uni-stuttgart.de/api/access/datafile/136439,2D/NS_incom/,e280fd3208fccb8ad5c1ff46c4796864
+NS_Incom,ns_incom_inhom_2d_512-10.h5,https://darus.uni-stuttgart.de/api/access/datafile/133309,2D/NS_incom/,f497297295ce3f2ebfefd81d00de31da
+NS_Incom,ns_incom_inhom_2d_512-100.h5,https://darus.uni-stuttgart.de/api/access/datafile/133267,2D/NS_incom/,fcf3b743fc82ac8706cfa85a7b259dcd
+NS_Incom,ns_incom_inhom_2d_512-101.h5,https://darus.uni-stuttgart.de/api/access/datafile/133289,2D/NS_incom/,9d1cd827c95f80975d09eae0b4e6c3da
+NS_Incom,ns_incom_inhom_2d_512-102.h5,https://darus.uni-stuttgart.de/api/access/datafile/133291,2D/NS_incom/,ce1f0a7a5e52bf49db43084eef367639
+NS_Incom,ns_incom_inhom_2d_512-103.h5,https://darus.uni-stuttgart.de/api/access/datafile/133294,2D/NS_incom/,4e0a5f39d14745adf96655f220329550
+NS_Incom,ns_incom_inhom_2d_512-104.h5,https://darus.uni-stuttgart.de/api/access/datafile/133298,2D/NS_incom/,52f59ffdef04338f2630e98e32448086
+NS_Incom,ns_incom_inhom_2d_512-105.h5,https://darus.uni-stuttgart.de/api/access/datafile/133290,2D/NS_incom/,1010c2d0c807e5e355e336fe8d905067
+NS_Incom,ns_incom_inhom_2d_512-106.h5,https://darus.uni-stuttgart.de/api/access/datafile/133374,2D/NS_incom/,1127b6e69bd83b128a9420ae58187729
+NS_Incom,ns_incom_inhom_2d_512-107.h5,https://darus.uni-stuttgart.de/api/access/datafile/133375,2D/NS_incom/,38e676bfd97cc946cd6db2af48c487bf
+NS_Incom,ns_incom_inhom_2d_512-108.h5,https://darus.uni-stuttgart.de/api/access/datafile/133376,2D/NS_incom/,0355430cc9cee8e921378eda7c1c6b84
+NS_Incom,ns_incom_inhom_2d_512-109.h5,https://darus.uni-stuttgart.de/api/access/datafile/133305,2D/NS_incom/,eff2dd6e71649bb3f9f37f951bd54d63
+NS_Incom,ns_incom_inhom_2d_512-11.h5,https://darus.uni-stuttgart.de/api/access/datafile/133336,2D/NS_incom/,3342616df260d3ec60fbf24dfaabf9ae
+NS_Incom,ns_incom_inhom_2d_512-110.h5,https://darus.uni-stuttgart.de/api/access/datafile/133313,2D/NS_incom/,d9739419a2100b390742acf88e4548b3
+NS_Incom,ns_incom_inhom_2d_512-111.h5,https://darus.uni-stuttgart.de/api/access/datafile/133318,2D/NS_incom/,ea5239ab7204d53c476f48739a4e0d78
+NS_Incom,ns_incom_inhom_2d_512-112.h5,https://darus.uni-stuttgart.de/api/access/datafile/133324,2D/NS_incom/,cdaf99ff4ef69ee79ad60648a06259d7
+NS_Incom,ns_incom_inhom_2d_512-113.h5,https://darus.uni-stuttgart.de/api/access/datafile/133377,2D/NS_incom/,aee8074da1cf6e19ee421a7b86caeaa3
+NS_Incom,ns_incom_inhom_2d_512-114.h5,https://darus.uni-stuttgart.de/api/access/datafile/133378,2D/NS_incom/,f1b4550b00a887771e79a81c7336a4b0
+NS_Incom,ns_incom_inhom_2d_512-115.h5,https://darus.uni-stuttgart.de/api/access/datafile/133379,2D/NS_incom/,0756d685a754b84337d1de7280572c85
+NS_Incom,ns_incom_inhom_2d_512-116.h5,https://darus.uni-stuttgart.de/api/access/datafile/133380,2D/NS_incom/,f7c55c110dcf0aeaed03699bc0942f0d
+NS_Incom,ns_incom_inhom_2d_512-117.h5,https://darus.uni-stuttgart.de/api/access/datafile/133381,2D/NS_incom/,375331e30111457028de38b89e03c404
+NS_Incom,ns_incom_inhom_2d_512-118.h5,https://darus.uni-stuttgart.de/api/access/datafile/133383,2D/NS_incom/,6d2fbe4a0e32e1934d349616ca6b85d8
+NS_Incom,ns_incom_inhom_2d_512-119.h5,https://darus.uni-stuttgart.de/api/access/datafile/133385,2D/NS_incom/,993112f4fe3910230005cc35099c7d59
+NS_Incom,ns_incom_inhom_2d_512-12.h5,https://darus.uni-stuttgart.de/api/access/datafile/133574,2D/NS_incom/,71f407084513d7c0e93377c1b46e4bb4
+NS_Incom,ns_incom_inhom_2d_512-120.h5,https://darus.uni-stuttgart.de/api/access/datafile/133386,2D/NS_incom/,f7c0b147e5b3f217a1d534f303ab52f4
+NS_Incom,ns_incom_inhom_2d_512-121.h5,https://darus.uni-stuttgart.de/api/access/datafile/133441,2D/NS_incom/,785d733406eeec2694eb89769f72971b
+NS_Incom,ns_incom_inhom_2d_512-122.h5,https://darus.uni-stuttgart.de/api/access/datafile/133346,2D/NS_incom/,eeb2488aa0a5d1f14069dcfaaa0da71d
+NS_Incom,ns_incom_inhom_2d_512-123.h5,https://darus.uni-stuttgart.de/api/access/datafile/133442,2D/NS_incom/,57e341bea82fd33ec095e7070fd1ae38
+NS_Incom,ns_incom_inhom_2d_512-124.h5,https://darus.uni-stuttgart.de/api/access/datafile/133443,2D/NS_incom/,6aba12029ab0ddb165c1c71f3b1c8f27
+NS_Incom,ns_incom_inhom_2d_512-125.h5,https://darus.uni-stuttgart.de/api/access/datafile/133444,2D/NS_incom/,2b15572d1dda8048ab9713c2318d9322
+NS_Incom,ns_incom_inhom_2d_512-126.h5,https://darus.uni-stuttgart.de/api/access/datafile/133303,2D/NS_incom/,56bcc085c7c0d303dedf147e6c608730
+NS_Incom,ns_incom_inhom_2d_512-127.h5,https://darus.uni-stuttgart.de/api/access/datafile/133292,2D/NS_incom/,71b5191ed81e86ec68f0a7bcd6a07759
+NS_Incom,ns_incom_inhom_2d_512-128.h5,https://darus.uni-stuttgart.de/api/access/datafile/133454,2D/NS_incom/,72b8110ec99098530494bbf0b64f51f7
+NS_Incom,ns_incom_inhom_2d_512-129.h5,https://darus.uni-stuttgart.de/api/access/datafile/133293,2D/NS_incom/,0e2cda441dec2c19ffaefd8ad035220e
+NS_Incom,ns_incom_inhom_2d_512-13.h5,https://darus.uni-stuttgart.de/api/access/datafile/133304,2D/NS_incom/,424f6d2ab607612599645442a45234cf
+NS_Incom,ns_incom_inhom_2d_512-130.h5,https://darus.uni-stuttgart.de/api/access/datafile/133295,2D/NS_incom/,8a6f6b785ce64aecc9f46a31650662d0
+NS_Incom,ns_incom_inhom_2d_512-131.h5,https://darus.uni-stuttgart.de/api/access/datafile/133275,2D/NS_incom/,3c4541c0ed411fdc9641b27978318ad6
+NS_Incom,ns_incom_inhom_2d_512-132.h5,https://darus.uni-stuttgart.de/api/access/datafile/133296,2D/NS_incom/,3c4541c0ed411fdc9641b27978318ad6
+NS_Incom,ns_incom_inhom_2d_512-133.h5,https://darus.uni-stuttgart.de/api/access/datafile/133297,2D/NS_incom/,ba2bb63092d5d0cb8fae29a0c18ff851
+NS_Incom,ns_incom_inhom_2d_512-134.h5,https://darus.uni-stuttgart.de/api/access/datafile/133269,2D/NS_incom/,4b0b6e0c3d22772ea20dc4c3e07c5e7d
+NS_Incom,ns_incom_inhom_2d_512-135.h5,https://darus.uni-stuttgart.de/api/access/datafile/133274,2D/NS_incom/,e48583df141230425ea36d093b0b46f6
+NS_Incom,ns_incom_inhom_2d_512-136.h5,https://darus.uni-stuttgart.de/api/access/datafile/133299,2D/NS_incom/,4b0b6e0c3d22772ea20dc4c3e07c5e7d
+NS_Incom,ns_incom_inhom_2d_512-137.h5,https://darus.uni-stuttgart.de/api/access/datafile/133300,2D/NS_incom/,e48583df141230425ea36d093b0b46f6
+NS_Incom,ns_incom_inhom_2d_512-138.h5,https://darus.uni-stuttgart.de/api/access/datafile/133302,2D/NS_incom/,294b49a65b2fc861e23dfc40098d6e91
+NS_Incom,ns_incom_inhom_2d_512-139.h5,https://darus.uni-stuttgart.de/api/access/datafile/133575,2D/NS_incom/,14c9705c20d630e08f4387cc4880a646
+NS_Incom,ns_incom_inhom_2d_512-14.h5,https://darus.uni-stuttgart.de/api/access/datafile/133281,2D/NS_incom/,f8099cba29f6374b6454424ef521b86d
+NS_Incom,ns_incom_inhom_2d_512-140.h5,https://darus.uni-stuttgart.de/api/access/datafile/133698,2D/NS_incom/,f8c12c7ee3973eab55a531a24689ce95
+NS_Incom,ns_incom_inhom_2d_512-141.h5,https://darus.uni-stuttgart.de/api/access/datafile/133307,2D/NS_incom/,95a897a07713b654ce497b513ada21df
+NS_Incom,ns_incom_inhom_2d_512-142.h5,https://darus.uni-stuttgart.de/api/access/datafile/133306,2D/NS_incom/,b0c964793163e49d46ddfa783b7f2a87
+NS_Incom,ns_incom_inhom_2d_512-143.h5,https://darus.uni-stuttgart.de/api/access/datafile/133590,2D/NS_incom/,b35dd28ee302e41dd9500e65e681bd93
+NS_Incom,ns_incom_inhom_2d_512-144.h5,https://darus.uni-stuttgart.de/api/access/datafile/133591,2D/NS_incom/,d7b000376bcb6cf4949e2dec4232a926
+NS_Incom,ns_incom_inhom_2d_512-145.h5,https://darus.uni-stuttgart.de/api/access/datafile/133592,2D/NS_incom/,e90fad8268cf369136cebba09f3b06e8
+NS_Incom,ns_incom_inhom_2d_512-146.h5,https://darus.uni-stuttgart.de/api/access/datafile/133593,2D/NS_incom/,568fac9aab2f599c20da783e9c7f3f0a
+NS_Incom,ns_incom_inhom_2d_512-147.h5,https://darus.uni-stuttgart.de/api/access/datafile/133599,2D/NS_incom/,43194bdefada7b59cac975cc08e6d12d
+NS_Incom,ns_incom_inhom_2d_512-148.h5,https://darus.uni-stuttgart.de/api/access/datafile/133600,2D/NS_incom/,41a78815f65ff7b607d69dd508b3ffea
+NS_Incom,ns_incom_inhom_2d_512-149.h5,https://darus.uni-stuttgart.de/api/access/datafile/133601,2D/NS_incom/,3ebb3a014d7c33787cda458a689f7728
+NS_Incom,ns_incom_inhom_2d_512-15.h5,https://darus.uni-stuttgart.de/api/access/datafile/133609,2D/NS_incom/,74dd42aaf8b809925ff6dce345be11fd
+NS_Incom,ns_incom_inhom_2d_512-150.h5,https://darus.uni-stuttgart.de/api/access/datafile/133602,2D/NS_incom/,562bd9a0d25ce189a9635d385e3d6a3c
+NS_Incom,ns_incom_inhom_2d_512-151.h5,https://darus.uni-stuttgart.de/api/access/datafile/133271,2D/NS_incom/,1acb06d08a4ae3a17ddbe04a2e3fd5cf
+NS_Incom,ns_incom_inhom_2d_512-152.h5,https://darus.uni-stuttgart.de/api/access/datafile/133603,2D/NS_incom/,0023490cb7c00a4a75f9a252af9be71c
+NS_Incom,ns_incom_inhom_2d_512-153.h5,https://darus.uni-stuttgart.de/api/access/datafile/133594,2D/NS_incom/,669788ec079a3e695b68821c17d79a26
+NS_Incom,ns_incom_inhom_2d_512-154.h5,https://darus.uni-stuttgart.de/api/access/datafile/133604,2D/NS_incom/,547cfa5abca50bcd927630b8264d6876
+NS_Incom,ns_incom_inhom_2d_512-155.h5,https://darus.uni-stuttgart.de/api/access/datafile/133605,2D/NS_incom/,f28fcf6d99c0d1f1bb08a82be94114eb
+NS_Incom,ns_incom_inhom_2d_512-156.h5,https://darus.uni-stuttgart.de/api/access/datafile/133606,2D/NS_incom/,8c52c6258bdbbc7c4fe1cb7892b5bd23
+NS_Incom,ns_incom_inhom_2d_512-157.h5,https://darus.uni-stuttgart.de/api/access/datafile/133607,2D/NS_incom/,91f4ab6bd4eef91ab43908290539bdab
+NS_Incom,ns_incom_inhom_2d_512-158.h5,https://darus.uni-stuttgart.de/api/access/datafile/133321,2D/NS_incom/,299521efb9f871919b003e86d0e8d628
+NS_Incom,ns_incom_inhom_2d_512-159.h5,https://darus.uni-stuttgart.de/api/access/datafile/133608,2D/NS_incom/,54b54c80708366c74d4aee82688be26e
+NS_Incom,ns_incom_inhom_2d_512-16.h5,https://darus.uni-stuttgart.de/api/access/datafile/133311,2D/NS_incom/,b83a1465fee7f5dcb9826d1bbb4b6f71
+NS_Incom,ns_incom_inhom_2d_512-160.h5,https://darus.uni-stuttgart.de/api/access/datafile/133610,2D/NS_incom/,e90d31aff2172f508846473126c78947
+NS_Incom,ns_incom_inhom_2d_512-161.h5,https://darus.uni-stuttgart.de/api/access/datafile/133611,2D/NS_incom/,24b4b52f0a03dc52f7159ef10652c40a
+NS_Incom,ns_incom_inhom_2d_512-162.h5,https://darus.uni-stuttgart.de/api/access/datafile/133683,2D/NS_incom/,87d592f2be6a76751b2b36e8bf0d0a88
+NS_Incom,ns_incom_inhom_2d_512-163.h5,https://darus.uni-stuttgart.de/api/access/datafile/133612,2D/NS_incom/,2acf733c2833fb815487271bbb5ce66f
+NS_Incom,ns_incom_inhom_2d_512-164.h5,https://darus.uni-stuttgart.de/api/access/datafile/136435,2D/NS_incom/,8470816b05ecbabd2ec6036f346d4d79
+NS_Incom,ns_incom_inhom_2d_512-165.h5,https://darus.uni-stuttgart.de/api/access/datafile/133685,2D/NS_incom/,61d677b1edd03987c26648d7d136672d
+NS_Incom,ns_incom_inhom_2d_512-166.h5,https://darus.uni-stuttgart.de/api/access/datafile/133308,2D/NS_incom/,4f1dd0e87f4ad925dc82444da4df7d3a
+NS_Incom,ns_incom_inhom_2d_512-167.h5,https://darus.uni-stuttgart.de/api/access/datafile/133684,2D/NS_incom/,8e90f2ab307a6c5f8a2e1a3befa02d8f
+NS_Incom,ns_incom_inhom_2d_512-168.h5,https://darus.uni-stuttgart.de/api/access/datafile/133701,2D/NS_incom/,1f8ef01efadb38eb638c383e242d9511
+NS_Incom,ns_incom_inhom_2d_512-169.h5,https://darus.uni-stuttgart.de/api/access/datafile/133310,2D/NS_incom/,d2ae69de21cb38a24dbc174f34afeb70
+NS_Incom,ns_incom_inhom_2d_512-17.h5,https://darus.uni-stuttgart.de/api/access/datafile/133325,2D/NS_incom/,9c206312c353aa6dcaa3144d53753075
+NS_Incom,ns_incom_inhom_2d_512-170.h5,https://darus.uni-stuttgart.de/api/access/datafile/133312,2D/NS_incom/,d7f9e313387dfb3efc356c1d5606ebc3
+NS_Incom,ns_incom_inhom_2d_512-171.h5,https://darus.uni-stuttgart.de/api/access/datafile/133679,2D/NS_incom/,f6ade3872e3e0db0d6b8af4cc9fd7ed6
+NS_Incom,ns_incom_inhom_2d_512-172.h5,https://darus.uni-stuttgart.de/api/access/datafile/133314,2D/NS_incom/,986851271af43e55264a8db4229b2049
+NS_Incom,ns_incom_inhom_2d_512-173.h5,https://darus.uni-stuttgart.de/api/access/datafile/133315,2D/NS_incom/,e064a3b043136572de413744f470e795
+NS_Incom,ns_incom_inhom_2d_512-174.h5,https://darus.uni-stuttgart.de/api/access/datafile/133316,2D/NS_incom/,d4906a07e5e94b6e147570613205d19d
+NS_Incom,ns_incom_inhom_2d_512-175.h5,https://darus.uni-stuttgart.de/api/access/datafile/133317,2D/NS_incom/,7d7230752c444c2570396927e9f9b4bf
+NS_Incom,ns_incom_inhom_2d_512-176.h5,https://darus.uni-stuttgart.de/api/access/datafile/133319,2D/NS_incom/,47a59095761d69cecc886ddb3027b556
+NS_Incom,ns_incom_inhom_2d_512-177.h5,https://darus.uni-stuttgart.de/api/access/datafile/133320,2D/NS_incom/,979de8be5c402f6dc50060e92ca6245a
+NS_Incom,ns_incom_inhom_2d_512-178.h5,https://darus.uni-stuttgart.de/api/access/datafile/133342,2D/NS_incom/,a72fc652b38b2dc0b0aa406bb35cd676
+NS_Incom,ns_incom_inhom_2d_512-179.h5,https://darus.uni-stuttgart.de/api/access/datafile/133697,2D/NS_incom/,6dd8a78a85ad7c0e03daaabcb3826fdb
+NS_Incom,ns_incom_inhom_2d_512-18.h5,https://darus.uni-stuttgart.de/api/access/datafile/136437,2D/NS_incom/,272c1cdf65a90dc3e4308df8a15ef7dc
+NS_Incom,ns_incom_inhom_2d_512-180.h5,https://darus.uni-stuttgart.de/api/access/datafile/133326,2D/NS_incom/,f9ffc612a7438dc17524818b48acb7ac
+NS_Incom,ns_incom_inhom_2d_512-181.h5,https://darus.uni-stuttgart.de/api/access/datafile/133327,2D/NS_incom/,78ee160778aab06d0e88507944f661b4
+NS_Incom,ns_incom_inhom_2d_512-182.h5,https://darus.uni-stuttgart.de/api/access/datafile/133328,2D/NS_incom/,e9a36056e3e9fe23937fbf65e0dfc16a
+NS_Incom,ns_incom_inhom_2d_512-183.h5,https://darus.uni-stuttgart.de/api/access/datafile/133329,2D/NS_incom/,5107343596d93f8739b4f09926daeef7
+NS_Incom,ns_incom_inhom_2d_512-184.h5,https://darus.uni-stuttgart.de/api/access/datafile/133330,2D/NS_incom/,f4a7aff84a03fff6e1958617abf373c4
+NS_Incom,ns_incom_inhom_2d_512-185.h5,https://darus.uni-stuttgart.de/api/access/datafile/133331,2D/NS_incom/,f59cb88424414a28aad308499935619b
+NS_Incom,ns_incom_inhom_2d_512-186.h5,https://darus.uni-stuttgart.de/api/access/datafile/133666,2D/NS_incom/,d9bc339d2d2047f8f6a369ad2e4e9357
+NS_Incom,ns_incom_inhom_2d_512-187.h5,https://darus.uni-stuttgart.de/api/access/datafile/136436,2D/NS_incom/,4d0461fc34683816d5906d4809c84432
+NS_Incom,ns_incom_inhom_2d_512-188.h5,https://darus.uni-stuttgart.de/api/access/datafile/133332,2D/NS_incom/,3565b7f3ab620c3716a25865670b98fb
+NS_Incom,ns_incom_inhom_2d_512-189.h5,https://darus.uni-stuttgart.de/api/access/datafile/133668,2D/NS_incom/,d385ef198ae29ef5eff9aad6d129621a
+NS_Incom,ns_incom_inhom_2d_512-19.h5,https://darus.uni-stuttgart.de/api/access/datafile/133335,2D/NS_incom/,f67fec4521fc9a113cd16de7f7c283ff
+NS_Incom,ns_incom_inhom_2d_512-190.h5,https://darus.uni-stuttgart.de/api/access/datafile/136438,2D/NS_incom/,2dce11f971c3561083d580f7299f3e02
+NS_Incom,ns_incom_inhom_2d_512-191.h5,https://darus.uni-stuttgart.de/api/access/datafile/133663,2D/NS_incom/,fda967e4ca21881b00d5c67b984d4c78
+NS_Incom,ns_incom_inhom_2d_512-192.h5,https://darus.uni-stuttgart.de/api/access/datafile/133664,2D/NS_incom/,85542754064fcab3675930ac607b68e0
+NS_Incom,ns_incom_inhom_2d_512-193.h5,https://darus.uni-stuttgart.de/api/access/datafile/133371,2D/NS_incom/,2f67289963f5d9d3041acf67f45a38b7
+NS_Incom,ns_incom_inhom_2d_512-194.h5,https://darus.uni-stuttgart.de/api/access/datafile/133669,2D/NS_incom/,609d2d5dbd19ccdb6cee8ab67df66c38
+NS_Incom,ns_incom_inhom_2d_512-195.h5,https://darus.uni-stuttgart.de/api/access/datafile/133699,2D/NS_incom/,b39dbe9518dbc19da27345ce569489e4
+NS_Incom,ns_incom_inhom_2d_512-196.h5,https://darus.uni-stuttgart.de/api/access/datafile/133665,2D/NS_incom/,fc636092ce4175b3d908d156db66deb8
+NS_Incom,ns_incom_inhom_2d_512-197.h5,https://darus.uni-stuttgart.de/api/access/datafile/133702,2D/NS_incom/,0b3bd457d75ccb3120f649bcdb0089f2
+NS_Incom,ns_incom_inhom_2d_512-198.h5,https://darus.uni-stuttgart.de/api/access/datafile/133368,2D/NS_incom/,526cce686110114720bc9d84eb8d16ee
+NS_Incom,ns_incom_inhom_2d_512-199.h5,https://darus.uni-stuttgart.de/api/access/datafile/133667,2D/NS_incom/,123272aaaf52747c39e8c32b4955390b
+NS_Incom,ns_incom_inhom_2d_512-2.h5,https://darus.uni-stuttgart.de/api/access/datafile/133721,2D/NS_incom/,1d7a2aac41a410bea6c887f624273d20
+NS_Incom,ns_incom_inhom_2d_512-20.h5,https://darus.uni-stuttgart.de/api/access/datafile/133283,2D/NS_incom/,859c8c8cede4fd611548af291acfa362
+NS_Incom,ns_incom_inhom_2d_512-200.h5,https://darus.uni-stuttgart.de/api/access/datafile/136440,2D/NS_incom/,621c5bdf211ab8aa6d586ede4b51c5a2
+NS_Incom,ns_incom_inhom_2d_512-201.h5,https://darus.uni-stuttgart.de/api/access/datafile/133367,2D/NS_incom/,89b6667026a2f289b81e48b6d75ef4d6
+NS_Incom,ns_incom_inhom_2d_512-202.h5,https://darus.uni-stuttgart.de/api/access/datafile/133661,2D/NS_incom/,a70f3e38089caec832075b7c3ce86744
+NS_Incom,ns_incom_inhom_2d_512-203.h5,https://darus.uni-stuttgart.de/api/access/datafile/133660,2D/NS_incom/,f0bc2659a6f671813e88409bdb08531a
+NS_Incom,ns_incom_inhom_2d_512-204.h5,https://darus.uni-stuttgart.de/api/access/datafile/133671,2D/NS_incom/,c109d2aa5cf0688c5f0565b03d1e3ce0
+NS_Incom,ns_incom_inhom_2d_512-205.h5,https://darus.uni-stuttgart.de/api/access/datafile/133688,2D/NS_incom/,2fa87303d667e4d50935fe26f04437b4
+NS_Incom,ns_incom_inhom_2d_512-206.h5,https://darus.uni-stuttgart.de/api/access/datafile/136441,2D/NS_incom/,28a557b57ffce43cb9de4cc48642fc05
+NS_Incom,ns_incom_inhom_2d_512-207.h5,https://darus.uni-stuttgart.de/api/access/datafile/133282,2D/NS_incom/,01a63c9ad30ac4d140f86bb2fa929274
+NS_Incom,ns_incom_inhom_2d_512-208.h5,https://darus.uni-stuttgart.de/api/access/datafile/133340,2D/NS_incom/,d2aa05820caf6a38be4711ef797d3bf4
+NS_Incom,ns_incom_inhom_2d_512-209.h5,https://darus.uni-stuttgart.de/api/access/datafile/133333,2D/NS_incom/,9e17d624a2eea451f0956f9184ce63d8
+NS_Incom,ns_incom_inhom_2d_512-21.h5,https://darus.uni-stuttgart.de/api/access/datafile/133334,2D/NS_incom/,859c8c8cede4fd611548af291acfa362
+NS_Incom,ns_incom_inhom_2d_512-210.h5,https://darus.uni-stuttgart.de/api/access/datafile/133703,2D/NS_incom/,fb5de2b943891ed1ec1bbb682520bc78
+NS_Incom,ns_incom_inhom_2d_512-211.h5,https://darus.uni-stuttgart.de/api/access/datafile/133286,2D/NS_incom/,24f8fe56ffe24baaa03f6bf12762ef95
+NS_Incom,ns_incom_inhom_2d_512-212.h5,https://darus.uni-stuttgart.de/api/access/datafile/133284,2D/NS_incom/,8e4561fe4ae69d62000df136f980fae3
+NS_Incom,ns_incom_inhom_2d_512-213.h5,https://darus.uni-stuttgart.de/api/access/datafile/133285,2D/NS_incom/,d1101482e0d766334b92c4d0e11d73f3
+NS_Incom,ns_incom_inhom_2d_512-214.h5,https://darus.uni-stuttgart.de/api/access/datafile/133337,2D/NS_incom/,d1101482e0d766334b92c4d0e11d73f3
+NS_Incom,ns_incom_inhom_2d_512-215.h5,https://darus.uni-stuttgart.de/api/access/datafile/133287,2D/NS_incom/,f615b96dd71864673bba274240acfb12
+NS_Incom,ns_incom_inhom_2d_512-216.h5,https://darus.uni-stuttgart.de/api/access/datafile/133288,2D/NS_incom/,892986d49b49b431f3f172d7baa9977b
+NS_Incom,ns_incom_inhom_2d_512-217.h5,https://darus.uni-stuttgart.de/api/access/datafile/133338,2D/NS_incom/,a471e758505de149dba27c9fa2d29198
+NS_Incom,ns_incom_inhom_2d_512-218.h5,https://darus.uni-stuttgart.de/api/access/datafile/133339,2D/NS_incom/,f615b96dd71864673bba274240acfb12
+NS_Incom,ns_incom_inhom_2d_512-219.h5,https://darus.uni-stuttgart.de/api/access/datafile/133341,2D/NS_incom/,1965889c070e802965ebe19b01cdf2db
+NS_Incom,ns_incom_inhom_2d_512-22.h5,https://darus.uni-stuttgart.de/api/access/datafile/133344,2D/NS_incom/,2235dd8e60d0d43b49aba99819ddb8d3
+NS_Incom,ns_incom_inhom_2d_512-220.h5,https://darus.uni-stuttgart.de/api/access/datafile/133343,2D/NS_incom/,588ce18cf51ca3517527f3dd0b0ee443
+NS_Incom,ns_incom_inhom_2d_512-221.h5,https://darus.uni-stuttgart.de/api/access/datafile/133345,2D/NS_incom/,e57ad44f1ae4fa9f31ddff57578507ce
+NS_Incom,ns_incom_inhom_2d_512-222.h5,https://darus.uni-stuttgart.de/api/access/datafile/133347,2D/NS_incom/,892986d49b49b431f3f172d7baa9977b
+NS_Incom,ns_incom_inhom_2d_512-223.h5,https://darus.uni-stuttgart.de/api/access/datafile/133369,2D/NS_incom/,9da97766e3b311af6d79a946f8db5184
+NS_Incom,ns_incom_inhom_2d_512-224.h5,https://darus.uni-stuttgart.de/api/access/datafile/133370,2D/NS_incom/,44a864a879590427273a3dbf1aa2c190
+NS_Incom,ns_incom_inhom_2d_512-225.h5,https://darus.uni-stuttgart.de/api/access/datafile/133372,2D/NS_incom/,8e4561fe4ae69d62000df136f980fae3
+NS_Incom,ns_incom_inhom_2d_512-226.h5,https://darus.uni-stuttgart.de/api/access/datafile/133373,2D/NS_incom/,adf37d1dd066c2dc8fb3886369b5434f
+NS_Incom,ns_incom_inhom_2d_512-227.h5,https://darus.uni-stuttgart.de/api/access/datafile/136442,2D/NS_incom/,de46866be488bb59d0d1c8ddc13a4dcb
+NS_Incom,ns_incom_inhom_2d_512-228.h5,https://darus.uni-stuttgart.de/api/access/datafile/133723,2D/NS_incom/,43975b57db7c922f94703d1c63fdaebe
+NS_Incom,ns_incom_inhom_2d_512-229.h5,https://darus.uni-stuttgart.de/api/access/datafile/136443,2D/NS_incom/,805f1a7336301b2bcc4a9f0fcce43864
+NS_Incom,ns_incom_inhom_2d_512-23.h5,https://darus.uni-stuttgart.de/api/access/datafile/133617,2D/NS_incom/,d026b809986795e73f13368a763e56d2
+NS_Incom,ns_incom_inhom_2d_512-230.h5,https://darus.uni-stuttgart.de/api/access/datafile/136445,2D/NS_incom/,e43acdfb560a45181111256e4ce45cc1
+NS_Incom,ns_incom_inhom_2d_512-231.h5,https://darus.uni-stuttgart.de/api/access/datafile/133613,2D/NS_incom/,f56497f0ba427fdf9e215c885c6c1d3a
+NS_Incom,ns_incom_inhom_2d_512-232.h5,https://darus.uni-stuttgart.de/api/access/datafile/133692,2D/NS_incom/,599ff6b1ea10572a829a13e5fc9c2523
+NS_Incom,ns_incom_inhom_2d_512-233.h5,https://darus.uni-stuttgart.de/api/access/datafile/133614,2D/NS_incom/,b0cbda1f7435ccbe04bc6a09840624df
+NS_Incom,ns_incom_inhom_2d_512-234.h5,https://darus.uni-stuttgart.de/api/access/datafile/133700,2D/NS_incom/,6331197878327890af4da21d5c4065bf
+NS_Incom,ns_incom_inhom_2d_512-235.h5,https://darus.uni-stuttgart.de/api/access/datafile/133693,2D/NS_incom/,dd937dace08671e5b61a8f960d845561
+NS_Incom,ns_incom_inhom_2d_512-236.h5,https://darus.uni-stuttgart.de/api/access/datafile/133615,2D/NS_incom/,07a4596a86c3099cf7f6e7e5c47b71b6
+NS_Incom,ns_incom_inhom_2d_512-237.h5,https://darus.uni-stuttgart.de/api/access/datafile/133616,2D/NS_incom/,4c977f28e59fd8cc877f6d95d96011e5
+NS_Incom,ns_incom_inhom_2d_512-238.h5,https://darus.uni-stuttgart.de/api/access/datafile/133695,2D/NS_incom/,9d3bad375edf84cd86a648caca49b6b5
+NS_Incom,ns_incom_inhom_2d_512-239.h5,https://darus.uni-stuttgart.de/api/access/datafile/136446,2D/NS_incom/,bae42dea9f17c4ca5ec33997e3eb966f
+NS_Incom,ns_incom_inhom_2d_512-24.h5,https://darus.uni-stuttgart.de/api/access/datafile/133618,2D/NS_incom/,c7e0bdab4f18748914263534cf21422d
+NS_Incom,ns_incom_inhom_2d_512-240.h5,https://darus.uni-stuttgart.de/api/access/datafile/133268,2D/NS_incom/,10b14e2a9eb6fcf5a88a7a5447481aa7
+NS_Incom,ns_incom_inhom_2d_512-241.h5,https://darus.uni-stuttgart.de/api/access/datafile/136447,2D/NS_incom/,0aa745b2377c49379f91f7f000d8f23e
+NS_Incom,ns_incom_inhom_2d_512-242.h5,https://darus.uni-stuttgart.de/api/access/datafile/136448,2D/NS_incom/,79033da1fbd3167b560769c8292c15f4
+NS_Incom,ns_incom_inhom_2d_512-243.h5,https://darus.uni-stuttgart.de/api/access/datafile/136450,2D/NS_incom/,896aa796fbf2052da573c30694744794
+NS_Incom,ns_incom_inhom_2d_512-244.h5,https://darus.uni-stuttgart.de/api/access/datafile/136451,2D/NS_incom/,3063dee5e25740331b4c606939c3960e
+NS_Incom,ns_incom_inhom_2d_512-245.h5,https://darus.uni-stuttgart.de/api/access/datafile/136457,2D/NS_incom/,daf18bcc864d5db453f7321de3c199bf
+NS_Incom,ns_incom_inhom_2d_512-246.h5,https://darus.uni-stuttgart.de/api/access/datafile/136458,2D/NS_incom/,8f97135545fdea8eb504c6f76878b77c
+NS_Incom,ns_incom_inhom_2d_512-247.h5,https://darus.uni-stuttgart.de/api/access/datafile/136459,2D/NS_incom/,2e1f4cf38135b2f07a72462e0f995c2d
+NS_Incom,ns_incom_inhom_2d_512-248.h5,https://darus.uni-stuttgart.de/api/access/datafile/136460,2D/NS_incom/,edaec61956c5af7be9f8996b8498c8fd
+NS_Incom,ns_incom_inhom_2d_512-249.h5,https://darus.uni-stuttgart.de/api/access/datafile/136461,2D/NS_incom/,b05738fc7cdf18fecca88361ba58875f
+NS_Incom,ns_incom_inhom_2d_512-25.h5,https://darus.uni-stuttgart.de/api/access/datafile/133619,2D/NS_incom/,d5e37c12c61353533ab82c6c9e48e93f
+NS_Incom,ns_incom_inhom_2d_512-250.h5,https://darus.uni-stuttgart.de/api/access/datafile/166273,2D/NS_incom/,c9731467c80b809ce0f3f337ce3ed71e
+NS_Incom,ns_incom_inhom_2d_512-251.h5,https://darus.uni-stuttgart.de/api/access/datafile/166274,2D/NS_incom/,3a515e95b641360734702248b3bfcb6d
+NS_Incom,ns_incom_inhom_2d_512-252.h5,https://darus.uni-stuttgart.de/api/access/datafile/166275,2D/NS_incom/,283244af2adc86953dd6021bf6722ba4
+NS_Incom,ns_incom_inhom_2d_512-253.h5,https://darus.uni-stuttgart.de/api/access/datafile/166276,2D/NS_incom/,a471e758505de149dba27c9fa2d29198
+NS_Incom,ns_incom_inhom_2d_512-254.h5,https://darus.uni-stuttgart.de/api/access/datafile/166277,2D/NS_incom/,9da97766e3b311af6d79a946f8db5184
+NS_Incom,ns_incom_inhom_2d_512-255.h5,https://darus.uni-stuttgart.de/api/access/datafile/166278,2D/NS_incom/,1965889c070e802965ebe19b01cdf2db
+NS_Incom,ns_incom_inhom_2d_512-256.h5,https://darus.uni-stuttgart.de/api/access/datafile/166279,2D/NS_incom/,588ce18cf51ca3517527f3dd0b0ee443
+NS_Incom,ns_incom_inhom_2d_512-257.h5,https://darus.uni-stuttgart.de/api/access/datafile/166281,2D/NS_incom/,44a864a879590427273a3dbf1aa2c190
+NS_Incom,ns_incom_inhom_2d_512-258.h5,https://darus.uni-stuttgart.de/api/access/datafile/166282,2D/NS_incom/,adf37d1dd066c2dc8fb3886369b5434f
+NS_Incom,ns_incom_inhom_2d_512-259.h5,https://darus.uni-stuttgart.de/api/access/datafile/166283,2D/NS_incom/,588200460d5168ce1ba582101aa3547e
+NS_Incom,ns_incom_inhom_2d_512-26.h5,https://darus.uni-stuttgart.de/api/access/datafile/133689,2D/NS_incom/,563b6261312a32460d848e5b9ca82f79
+NS_Incom,ns_incom_inhom_2d_512-260.h5,https://darus.uni-stuttgart.de/api/access/datafile/166284,2D/NS_incom/,2e1e5883bec2e8e50048738266785bae
+NS_Incom,ns_incom_inhom_2d_512-261.h5,https://darus.uni-stuttgart.de/api/access/datafile/166285,2D/NS_incom/,b5f6b09ad77bbcafbc7d52710388669c
+NS_Incom,ns_incom_inhom_2d_512-262.h5,https://darus.uni-stuttgart.de/api/access/datafile/166286,2D/NS_incom/,8a8026b2cd2e59a7b1d796dca4404e3a
+NS_Incom,ns_incom_inhom_2d_512-263.h5,https://darus.uni-stuttgart.de/api/access/datafile/166287,2D/NS_incom/,8958869c63e7a496816d5c551d4d8115
+NS_Incom,ns_incom_inhom_2d_512-264.h5,https://darus.uni-stuttgart.de/api/access/datafile/166288,2D/NS_incom/,69e4911decfab00ff945884915084104
+NS_Incom,ns_incom_inhom_2d_512-265.h5,https://darus.uni-stuttgart.de/api/access/datafile/166290,2D/NS_incom/,3516776e1d47d573ee91815ca70360b6
+NS_Incom,ns_incom_inhom_2d_512-266.h5,https://darus.uni-stuttgart.de/api/access/datafile/166291,2D/NS_incom/,f50c0e5f4ad659c1b5d6f7343e072bdf
+NS_Incom,ns_incom_inhom_2d_512-267.h5,https://darus.uni-stuttgart.de/api/access/datafile/166292,2D/NS_incom/,85a8bd3bd539acb7685393393294e916
+NS_Incom,ns_incom_inhom_2d_512-268.h5,https://darus.uni-stuttgart.de/api/access/datafile/166293,2D/NS_incom/,3b43956b04c4e0e619ba671cdfbbc834
+NS_Incom,ns_incom_inhom_2d_512-269.h5,https://darus.uni-stuttgart.de/api/access/datafile/166294,2D/NS_incom/,1ca4a6528b2d73b55042eb6dbe487ff1
+NS_Incom,ns_incom_inhom_2d_512-27.h5,https://darus.uni-stuttgart.de/api/access/datafile/133620,2D/NS_incom/,3536aace9614abf8868d9c03bbccf9d4
+NS_Incom,ns_incom_inhom_2d_512-270.h5,https://darus.uni-stuttgart.de/api/access/datafile/166295,2D/NS_incom/,8bf9ac2f7dc47e3617ba9de2ac10d582
+NS_Incom,ns_incom_inhom_2d_512-271.h5,https://darus.uni-stuttgart.de/api/access/datafile/166296,2D/NS_incom/,907d7cd2c84312f52f94b27197128d00
+NS_Incom,ns_incom_inhom_2d_512-272.h5,https://darus.uni-stuttgart.de/api/access/datafile/166297,2D/NS_incom/,7d1dc19e1b08c09d86bed9a0c7448ceb
+NS_Incom,ns_incom_inhom_2d_512-273.h5,https://darus.uni-stuttgart.de/api/access/datafile/166298,2D/NS_incom/,e5e51712cc8921fcc4e89b9fe4690c7f
+NS_Incom,ns_incom_inhom_2d_512-274.h5,https://darus.uni-stuttgart.de/api/access/datafile/166299,2D/NS_incom/,5a3ea4a7cdeade672038ffdbf3a7886a
+NS_Incom,ns_incom_inhom_2d_512-28.h5,https://darus.uni-stuttgart.de/api/access/datafile/136462,2D/NS_incom/,aef3e1e349adc36e3d738d7d5534548b
+NS_Incom,ns_incom_inhom_2d_512-29.h5,https://darus.uni-stuttgart.de/api/access/datafile/136463,2D/NS_incom/,b5f7a9f28aab2baf06d6129a436dca79
+NS_Incom,ns_incom_inhom_2d_512-3.h5,https://darus.uni-stuttgart.de/api/access/datafile/136466,2D/NS_incom/,e9c92a19854e96c918d3a46d39994be4
+NS_Incom,ns_incom_inhom_2d_512-30.h5,https://darus.uni-stuttgart.de/api/access/datafile/136464,2D/NS_incom/,fa2275aaf761334ec2d80affb10d324f
+NS_Incom,ns_incom_inhom_2d_512-31.h5,https://darus.uni-stuttgart.de/api/access/datafile/133621,2D/NS_incom/,a30bc0bb2120dcb42a8335c6d264ac7d
+NS_Incom,ns_incom_inhom_2d_512-32.h5,https://darus.uni-stuttgart.de/api/access/datafile/133626,2D/NS_incom/,6579fe51ea46095aa1cd336be4701b34
+NS_Incom,ns_incom_inhom_2d_512-33.h5,https://darus.uni-stuttgart.de/api/access/datafile/133622,2D/NS_incom/,63ee81664764659f3b6436c055981c95
+NS_Incom,ns_incom_inhom_2d_512-34.h5,https://darus.uni-stuttgart.de/api/access/datafile/133623,2D/NS_incom/,e7c32d512bf95b97699c36381fea07ca
+NS_Incom,ns_incom_inhom_2d_512-35.h5,https://darus.uni-stuttgart.de/api/access/datafile/133624,2D/NS_incom/,c2715bd899018326e9679775d57e1dfd
+NS_Incom,ns_incom_inhom_2d_512-36.h5,https://darus.uni-stuttgart.de/api/access/datafile/136465,2D/NS_incom/,b085ae82d91f9baa2a7f9c8720f5ca48
+NS_Incom,ns_incom_inhom_2d_512-37.h5,https://darus.uni-stuttgart.de/api/access/datafile/133625,2D/NS_incom/,80c39f8aaf4168974f8bde94df177ab6
+NS_Incom,ns_incom_inhom_2d_512-38.h5,https://darus.uni-stuttgart.de/api/access/datafile/133645,2D/NS_incom/,d01ee492fcdb64cd52b7d0ae7b606370
+NS_Incom,ns_incom_inhom_2d_512-39.h5,https://darus.uni-stuttgart.de/api/access/datafile/133630,2D/NS_incom/,3f4f083589ab6d314584fa7ec795669e
+NS_Incom,ns_incom_inhom_2d_512-4.h5,https://darus.uni-stuttgart.de/api/access/datafile/166289,2D/NS_incom/,306a56ac14ea5686921cbb3f09c7dcb6
+NS_Incom,ns_incom_inhom_2d_512-40.h5,https://darus.uni-stuttgart.de/api/access/datafile/133627,2D/NS_incom/,c906a76f920bb63d575e347e76e47caf
+NS_Incom,ns_incom_inhom_2d_512-41.h5,https://darus.uni-stuttgart.de/api/access/datafile/133696,2D/NS_incom/,b55a275050a22b9c515d9d896dba6da0
+NS_Incom,ns_incom_inhom_2d_512-42.h5,https://darus.uni-stuttgart.de/api/access/datafile/133642,2D/NS_incom/,5aa8b626b64ba979905797b9e56dd34c
+NS_Incom,ns_incom_inhom_2d_512-43.h5,https://darus.uni-stuttgart.de/api/access/datafile/133650,2D/NS_incom/,d6ef4cf80d79f696dfc34d4947b14a77
+NS_Incom,ns_incom_inhom_2d_512-44.h5,https://darus.uni-stuttgart.de/api/access/datafile/133686,2D/NS_incom/,b8527daec6934026f5128a6d1f5db1e5
+NS_Incom,ns_incom_inhom_2d_512-45.h5,https://darus.uni-stuttgart.de/api/access/datafile/136467,2D/NS_incom/,7899ab1897fbd4665e4d7daea7c90bc2
+NS_Incom,ns_incom_inhom_2d_512-46.h5,https://darus.uni-stuttgart.de/api/access/datafile/136468,2D/NS_incom/,6853e9a78b6a2b2b756c4e6f8bcdac3e
+NS_Incom,ns_incom_inhom_2d_512-47.h5,https://darus.uni-stuttgart.de/api/access/datafile/136469,2D/NS_incom/,4737e1e1283748baae9617ceff1e777a
+NS_Incom,ns_incom_inhom_2d_512-48.h5,https://darus.uni-stuttgart.de/api/access/datafile/136470,2D/NS_incom/,5d3abc3ecbddeacb5270030954cc8064
+NS_Incom,ns_incom_inhom_2d_512-5.h5,https://darus.uni-stuttgart.de/api/access/datafile/136471,2D/NS_incom/,6a939d7418593d70faf7f90a191f841d
+NS_Incom,ns_incom_inhom_2d_512-50.h5,https://darus.uni-stuttgart.de/api/access/datafile/133678,2D/NS_incom/,f30303f48d036e9aeac07fd70e61c97b
+NS_Incom,ns_incom_inhom_2d_512-51.h5,https://darus.uni-stuttgart.de/api/access/datafile/133659,2D/NS_incom/,e82c2adbbc22b59168b7b587012d296d
+NS_Incom,ns_incom_inhom_2d_512-52.h5,https://darus.uni-stuttgart.de/api/access/datafile/133657,2D/NS_incom/,1a072500b92f728f24526182a8e22d71
+NS_Incom,ns_incom_inhom_2d_512-53.h5,https://darus.uni-stuttgart.de/api/access/datafile/133670,2D/NS_incom/,e82c2adbbc22b59168b7b587012d296d
+NS_Incom,ns_incom_inhom_2d_512-54.h5,https://darus.uni-stuttgart.de/api/access/datafile/133672,2D/NS_incom/,3516776e1d47d573ee91815ca70360b6
+NS_Incom,ns_incom_inhom_2d_512-55.h5,https://darus.uni-stuttgart.de/api/access/datafile/133662,2D/NS_incom/,49732762c231a410904cf8bddb0444cd
+NS_Incom,ns_incom_inhom_2d_512-56.h5,https://darus.uni-stuttgart.de/api/access/datafile/133673,2D/NS_incom/,f50c0e5f4ad659c1b5d6f7343e072bdf
+NS_Incom,ns_incom_inhom_2d_512-57.h5,https://darus.uni-stuttgart.de/api/access/datafile/133674,2D/NS_incom/,1a072500b92f728f24526182a8e22d71
+NS_Incom,ns_incom_inhom_2d_512-58.h5,https://darus.uni-stuttgart.de/api/access/datafile/133658,2D/NS_incom/,ae1e262d7f1a56369b13b6d5de80e03d
+NS_Incom,ns_incom_inhom_2d_512-59.h5,https://darus.uni-stuttgart.de/api/access/datafile/133656,2D/NS_incom/,b99c5b112d4a7dfca053cb2c78ebe581
+NS_Incom,ns_incom_inhom_2d_512-6.h5,https://darus.uni-stuttgart.de/api/access/datafile/136472,2D/NS_incom/,36156ac1f8cecb47d076a1ee0707dec5
+NS_Incom,ns_incom_inhom_2d_512-60.h5,https://darus.uni-stuttgart.de/api/access/datafile/133675,2D/NS_incom/,85a8bd3bd539acb7685393393294e916
+NS_Incom,ns_incom_inhom_2d_512-61.h5,https://darus.uni-stuttgart.de/api/access/datafile/133676,2D/NS_incom/,3b43956b04c4e0e619ba671cdfbbc834
+NS_Incom,ns_incom_inhom_2d_512-62.h5,https://darus.uni-stuttgart.de/api/access/datafile/133677,2D/NS_incom/,8bf9ac2f7dc47e3617ba9de2ac10d582
+NS_Incom,ns_incom_inhom_2d_512-63.h5,https://darus.uni-stuttgart.de/api/access/datafile/133680,2D/NS_incom/,49732762c231a410904cf8bddb0444cd
+NS_Incom,ns_incom_inhom_2d_512-64.h5,https://darus.uni-stuttgart.de/api/access/datafile/133628,2D/NS_incom/,c0e54ed459c84470986818d6d89be0c8
+NS_Incom,ns_incom_inhom_2d_512-65.h5,https://darus.uni-stuttgart.de/api/access/datafile/133635,2D/NS_incom/,69f1b9013bb76fba1006272951e12845
+NS_Incom,ns_incom_inhom_2d_512-66.h5,https://darus.uni-stuttgart.de/api/access/datafile/133629,2D/NS_incom/,c79245b195ec850a40c0957056bffad7
+NS_Incom,ns_incom_inhom_2d_512-67.h5,https://darus.uni-stuttgart.de/api/access/datafile/133277,2D/NS_incom/,f8465b71d9afe577ba30cbe5d0c490e6
+NS_Incom,ns_incom_inhom_2d_512-68.h5,https://darus.uni-stuttgart.de/api/access/datafile/133681,2D/NS_incom/,ae1e262d7f1a56369b13b6d5de80e03d
+NS_Incom,ns_incom_inhom_2d_512-69.h5,https://darus.uni-stuttgart.de/api/access/datafile/133631,2D/NS_incom/,b5159c70d9b14e480bb520961bafcae4
+NS_Incom,ns_incom_inhom_2d_512-7.h5,https://darus.uni-stuttgart.de/api/access/datafile/136473,2D/NS_incom/,e1b06fd07d09227a0767baa260f361e2
+NS_Incom,ns_incom_inhom_2d_512-70.h5,https://darus.uni-stuttgart.de/api/access/datafile/133632,2D/NS_incom/,3aee2aa9b1a14c7d04ce2770e95a354a
+NS_Incom,ns_incom_inhom_2d_512-71.h5,https://darus.uni-stuttgart.de/api/access/datafile/133634,2D/NS_incom/,2f5b2bf56e72d61c41d4b056ac540fb0
+NS_Incom,ns_incom_inhom_2d_512-72.h5,https://darus.uni-stuttgart.de/api/access/datafile/133682,2D/NS_incom/,b99c5b112d4a7dfca053cb2c78ebe581
+NS_Incom,ns_incom_inhom_2d_512-73.h5,https://darus.uni-stuttgart.de/api/access/datafile/133273,2D/NS_incom/,9d1c5e98ee4fe97c7498d2f574c165ae
+NS_Incom,ns_incom_inhom_2d_512-74.h5,https://darus.uni-stuttgart.de/api/access/datafile/133633,2D/NS_incom/,475427b7337f1fd7114b7e6c32a2f709
+NS_Incom,ns_incom_inhom_2d_512-75.h5,https://darus.uni-stuttgart.de/api/access/datafile/133694,2D/NS_incom/,170b32d051ed72716aab0f40b13f359e
+NS_Incom,ns_incom_inhom_2d_512-76.h5,https://darus.uni-stuttgart.de/api/access/datafile/133636,2D/NS_incom/,2666826a3944f5999a1053242e9588a9
+NS_Incom,ns_incom_inhom_2d_512-77.h5,https://darus.uni-stuttgart.de/api/access/datafile/133638,2D/NS_incom/,c58cc6dd09fb89c1b5fb95081f1220c9
+NS_Incom,ns_incom_inhom_2d_512-78.h5,https://darus.uni-stuttgart.de/api/access/datafile/133637,2D/NS_incom/,b183a32a3e2230968d5b7f20d9dbf818
+NS_Incom,ns_incom_inhom_2d_512-79.h5,https://darus.uni-stuttgart.de/api/access/datafile/133651,2D/NS_incom/,def3145be356b7d020ea09e5232bb60f
+NS_Incom,ns_incom_inhom_2d_512-8.h5,https://darus.uni-stuttgart.de/api/access/datafile/136449,2D/NS_incom/,2e6a62550680a255d4dfec24a761d5cf
+NS_Incom,ns_incom_inhom_2d_512-80.h5,https://darus.uni-stuttgart.de/api/access/datafile/133639,2D/NS_incom/,07a1edc16fb7d981155ad4173c42abf1
+NS_Incom,ns_incom_inhom_2d_512-81.h5,https://darus.uni-stuttgart.de/api/access/datafile/133276,2D/NS_incom/,3a58395f316b2158ea61844eadd4109f
+NS_Incom,ns_incom_inhom_2d_512-82.h5,https://darus.uni-stuttgart.de/api/access/datafile/133640,2D/NS_incom/,a0f4505418beb4da8b7f84a83efc3904
+NS_Incom,ns_incom_inhom_2d_512-83.h5,https://darus.uni-stuttgart.de/api/access/datafile/133272,2D/NS_incom/,89993b4f3ac2653f6377941e640e2233
+NS_Incom,ns_incom_inhom_2d_512-84.h5,https://darus.uni-stuttgart.de/api/access/datafile/133643,2D/NS_incom/,c5269398ec4edb0f5891d4efdb2fc89d
+NS_Incom,ns_incom_inhom_2d_512-85.h5,https://darus.uni-stuttgart.de/api/access/datafile/133641,2D/NS_incom/,090862c29ecbc2c4232ddbacca3fb230
+NS_Incom,ns_incom_inhom_2d_512-86.h5,https://darus.uni-stuttgart.de/api/access/datafile/133647,2D/NS_incom/,a712449bef87318a620d1663c4ffde27
+NS_Incom,ns_incom_inhom_2d_512-87.h5,https://darus.uni-stuttgart.de/api/access/datafile/133644,2D/NS_incom/,920a3dcb3b216f0d9a4ab0b9b4c8745a
+NS_Incom,ns_incom_inhom_2d_512-88.h5,https://darus.uni-stuttgart.de/api/access/datafile/133655,2D/NS_incom/,cc96b1e357f264f12dcfbb41736a53bf
+NS_Incom,ns_incom_inhom_2d_512-89.h5,https://darus.uni-stuttgart.de/api/access/datafile/133646,2D/NS_incom/,7fd484851410b7139bfea4166074fe00
+NS_Incom,ns_incom_inhom_2d_512-9.h5,https://darus.uni-stuttgart.de/api/access/datafile/136475,2D/NS_incom/,254bb44710b625f716b61d51d5d1e58e
+NS_Incom,ns_incom_inhom_2d_512-90.h5,https://darus.uni-stuttgart.de/api/access/datafile/133652,2D/NS_incom/,c6c4e27d6ba19b4ccb5f27e67dd9cdf1
+NS_Incom,ns_incom_inhom_2d_512-91.h5,https://darus.uni-stuttgart.de/api/access/datafile/136474,2D/NS_incom/,527b23b7e4ca4d18c5c036c41e15e4fe
+NS_Incom,ns_incom_inhom_2d_512-92.h5,https://darus.uni-stuttgart.de/api/access/datafile/133648,2D/NS_incom/,84fd5f64db474f8e20b670d01929d57a
+NS_Incom,ns_incom_inhom_2d_512-93.h5,https://darus.uni-stuttgart.de/api/access/datafile/133649,2D/NS_incom/,20583d7edf7da9a80f16a26c8388a65e
+NS_Incom,ns_incom_inhom_2d_512-94.h5,https://darus.uni-stuttgart.de/api/access/datafile/133691,2D/NS_incom/,8540e7f1cc6a9e2bc64726a325ddacfb
+NS_Incom,ns_incom_inhom_2d_512-95.h5,https://darus.uni-stuttgart.de/api/access/datafile/133690,2D/NS_incom/,25d4c08d5534d0f10c877220e258640c
+NS_Incom,ns_incom_inhom_2d_512-96.h5,https://darus.uni-stuttgart.de/api/access/datafile/133270,2D/NS_incom/,93e772cbfd36d434e97a079d701d5382
+NS_Incom,ns_incom_inhom_2d_512-97.h5,https://darus.uni-stuttgart.de/api/access/datafile/133653,2D/NS_incom/,ffa1d46e58f67aa1932fc4ffd2e7716a
+NS_Incom,ns_incom_inhom_2d_512-98.h5,https://darus.uni-stuttgart.de/api/access/datafile/133687,2D/NS_incom/,c28112e1339cda43f67dce03536e3455
+NS_Incom,ns_incom_inhom_2d_512-99.h5,https://darus.uni-stuttgart.de/api/access/datafile/133654,2D/NS_incom/,abfe923a224cb4515dd545d5858b2124
+SWE,2D_rdb_NA_NA.h5,https://darus.uni-stuttgart.de/api/access/datafile/133021,2D/shallow-water/,75d838c47aa410694bdc912ea7f22282
+3D_CFD,3D_CFD_Rand_M1.0_Eta1e-08_Zeta1e-08_periodic_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164693,3D/Train/,45892a12d1066d54af74badae55c438e
+3D_CFD,3D_CFD_Turb_M1.0_Eta1e-08_Zeta1e-08_periodic_Train.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/164694,3D/Train/,4f0eacaec5ff000bbd9a31026ea207b8
+3D_CFD,BlastWave.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133264,3D/Test/BlastWave/,f901a1ec75925c1d861ac99a825878f3
+3D_CFD,Turb_M01.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133224,3D/Test/Turbulence/,b27495031f434d01762bb0b819ac71e2
+3D_CFD,Turb_M05.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133225,3D/Test/Turbulence/,f9407dff1a75a1d14d93e7dd570af728
+3D_CFD,Turb_M1.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/135833,3D/Test/Turbulence/,3758f23f71684ac666e0b1e91da0a1c4
+3D_CFD,Turb_M2.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133227,3D/Test/Turbulence/,12e528dc8ab800f69474600ec58b24d3
+3D_CFD,Turb_M4.hdf5,https://darus.uni-stuttgart.de/api/access/datafile/133228,3D/Test/Turbulence/,8db384feba75903a8c5b21ebeba40083

funsearch.py

@@ -0,0 +1,160 @@
+import math
+import os
+import pandas as pd
+import random
+import shutil
+import time
+
+from code_generation import generate_and_debug, prepare_working_folder, code_execution, get_results
+from program_database import ProgramsDatabase, ProgramsDatabaseConfig
+    
+def get_seed_score(nRMSE, convergence_rate):
+    return {
+        'bucketed_convergence_rate': int(max(0, convergence_rate)*4),
+        'bucketed_nRMSE': int(-math.log10(min(1e9, nRMSE))*10)
+    }
+
+def funsearch(cfg):
+    num_trials = cfg.method.num_debugging_trials_per_sample
+    pde_name = cfg.pde.name
+    working_folder = cfg.working_folder
+    model_name = cfg.model.name
+    num_search_rounds = cfg.method.num_search_rounds
+    num_initial_seeds = cfg.method.num_initial_seeds
+    use_sample_solver_init = cfg.method.use_sample_solver_init
+    assert use_sample_solver_init, 'Sample solvers must be enabled for refinement'
+
+    sample_solver_folder = os.path.join(
+        'solvers', pde_name, cfg.pde.pde_setting_name, 'seeds'
+    )
+    sample_solver_info = pd.read_csv(
+        os.path.join(sample_solver_folder, 'seed_results.csv')
+    )
+
+    prepare_working_folder(
+        cfg, 
+        working_folder=working_folder, 
+        pde_name=pde_name,
+        use_sample_solver_init=use_sample_solver_init
+    )
+
+    pd_cfg = ProgramsDatabaseConfig()
+    program_db = ProgramsDatabase(pd_cfg)
+
+    # The first round: generate without seed
+    seed_path = os.path.join(
+        '../archived_logs', 
+        pde_name, 
+        cfg.pde.pde_setting_name,
+        'repeated_sample',
+        model_name
+    )
+    subdirectories = [d for d in os.listdir(seed_path) if os.path.isdir(os.path.join(seed_path, d))]
+    assert len(subdirectories) == 1, 'Only one subdirectory is expected'
+    seed_path = os.path.join(seed_path, subdirectories[0])
+    result_sheet = pd.read_csv(os.path.join(seed_path, 'test_results.csv'))
+
+    for i in range(num_initial_seeds):
+        relevant_files = [
+            'errors_{idx}.txt',
+            'implementation_{idx}.py',
+            'output_{idx}.txt',
+        ]
+
+        complete_seed = True
+        for file in relevant_files:
+            if not os.path.exists(os.path.join(seed_path, file.format(idx=i))):
+                complete_seed = False
+                break
+        if result_sheet[result_sheet['round'] == i].empty:
+            complete_seed = False
+        
+        seed_info = result_sheet[result_sheet['round'] == i].to_numpy().tolist()[0]
+        seed_info = [str(x) for x in seed_info]
+        if seed_info[1] == 'failed':
+            complete_seed = False
+
+        if not complete_seed:
+            continue
+
+        # The seed is complete, copy it to the working folder
+        for file in relevant_files:
+            source_file = os.path.join(seed_path, file.format(idx=int(i)))
+            destination_file = os.path.join(working_folder, file.format(idx=int(i)))
+            shutil.copy(source_file, destination_file)
+        with open(os.path.join(working_folder, 'test_results.csv'), 'a') as f:
+            seed_info[0] = str(int(i))
+            f.write(','.join(seed_info) + '\n')
+        
+        # Register the seed in the database
+        seed_score = get_seed_score(float(seed_info[1]), float(seed_info[3]))
+        with open(os.path.join(working_folder, f'implementation_{i}.py'), 'r') as f:
+            implementation = f.readlines()
+            program_len = len(implementation)
+        program_db.register_program(
+            program=i,
+            program_len=program_len,
+            island_id=None,
+            scores_per_test=seed_score,
+        )
+
+    for i in range(num_initial_seeds, num_initial_seeds+num_search_rounds):
+        island_id, seed_ids = program_db.get_seed()
+        try:
+            relative_error, elapsed_time, avg_rate = generate_and_debug(
+                cfg,
+                round_idx=i,
+                num_trials=num_trials,
+                pde_name=pde_name,
+                working_folder=working_folder,
+                seed_implementations=seed_ids,
+                model_name=model_name
+            )
+            seed_score = get_seed_score(float(relative_error), float(avg_rate))
+            with open(os.path.join(working_folder, f'implementation_{i}.py'), 'r') as f:
+                implementation = f.readlines()
+                program_len = len(implementation)
+            program_db.register_program(
+                program=i,
+                program_len=program_len,
+                island_id=island_id,
+                scores_per_test=seed_score,
+            )
+        except Exception as e:
+            print(f'Error in round {i}: {e}. Move on to the next sample.')
+        
+
+    # Finally, report the best program
+    results = pd.read_csv(os.path.join(working_folder, 'test_results.csv'))
+    keywords = ['nRMSE', 'elapsed_time', 'convergence_rate']
+    for keyword in keywords:
+        results[keyword] = pd.to_numeric(results[keyword], errors="coerce")
+    # Sort by nRMSE, elapsed_time, and convergence_rate
+    sorted_results = results.sort_values(by=keywords, ascending=[True, True, False])
+    best_idx = int(sorted_results.head(1)["round"].values[0])
+    
+    test_run_id = 999
+    shutil.copy(
+        os.path.join(working_folder, f'implementation_{best_idx}.py'),
+        os.path.join(working_folder, f'implementation_{test_run_id}.py')
+    )
+    execution_results = code_execution(
+        cfg,
+        working_folder = working_folder,
+        round_idx=test_run_id,
+        pde_name=pde_name,
+        eval_dataset=os.path.join(
+            cfg.root_dataset_folder, 
+            cfg.pde.dataset_folder_for_eval.replace('_development.hdf5', '.hdf5')
+        )
+    )
+
+    if execution_results['exit_code'] != 0:
+        relative_error, elapsed_time, avg_rate = None, None, None
+    else:
+        relative_error, elapsed_time, avg_rate = get_results(
+            os.path.join(working_folder, f'output_{test_run_id}.txt')
+        )
+    with open(os.path.join(working_folder, 'final_result.txt'), 'w') as f:
+        f.write('best_idx,relative_error,elapsed_time,avg_rate\n')
+        f.write(f'{best_idx},{relative_error},{elapsed_time},{avg_rate}\n')

llm_api.py

@@ -0,0 +1,129 @@
+from anthropic import Anthropic
+from google import genai
+from google.genai import types
+from openai import OpenAI
+import time
+
+
+def get_client(messages, cfg):
+    if 'gpt' in cfg.model.family_name or cfg.model.family_name == 'o':
+        client = OpenAI(api_key=cfg.model.api_key)
+    elif 'claude' in cfg.model.family_name:
+        client = Anthropic(api_key=cfg.model.api_key)
+    elif 'deepseek' in cfg.model.family_name:
+        client = OpenAI(api_key=cfg.model.api_key, base_url=cfg.model.base_url)
+    elif 'gemini' in cfg.model.family_name:
+        client = genai.Client(api_key=cfg.model.api_key)
+    elif cfg.model.family_name == 'qwen':
+        client = OpenAI(api_key=cfg.model.api_key, base_url=cfg.model.base_url)
+    else:
+        raise ValueError(f'Model {cfg.model.family_name} not recognized')
+    return client
+
+
+def generate_response(messages, cfg):
+    client = get_client(messages, cfg)
+    model_name = cfg.model.name
+    if 'o1' in model_name or 'o3' in model_name or 'o4' in model_name:
+        # Need to follow the restrictions
+        if 'o1' in model_name and len(messages)>0 and messages[0]['role'] == 'system':
+            system_prompt = messages[0]['content']
+            messages = messages[1:]
+            messages[0]['content'] = system_prompt + messages[0]['content']
+        # TODO: add these to the hydra config
+        num_tokens = 16384
+        temperature = 1.0
+        start_time = time.time()
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=messages,
+            max_completion_tokens=num_tokens,
+            temperature=temperature)
+        end_time = time.time()
+        print(f'It takes {model_name} {end_time - start_time:.2f}s to generate the response.')
+        return response
+    
+    if 'claude' in model_name:
+        num_tokens = 8192  # Give claude more tokens
+        temperature = 0.7
+
+        if len(messages)>0 and messages[0]['role'] == 'system':
+            system_prompt = messages[0]['content']
+            messages = messages[1:]
+
+        start_time = time.time() 
+        if cfg.model.thinking:
+            num_thinking_tokens = 12288
+            response = client.messages.create(
+                model=model_name,
+                max_tokens=num_tokens+num_thinking_tokens,
+                thinking= {"type": "enabled", "budget_tokens": num_thinking_tokens},
+                system=system_prompt,
+                messages=messages,
+                # temperature has to be set to 1 for thinking
+                temperature=1.0,
+            )
+        else:
+            response = client.messages.create(
+                model=model_name,
+                max_tokens=num_tokens,
+                system=system_prompt,
+                messages=messages,
+                temperature=temperature,
+            )
+        end_time = time.time()
+        print(f'It takes {model_name} {end_time - start_time:.2f}s to generate the response.')
+        return response
+
+    if 'gemini' in model_name:
+        start_time = time.time() 
+        if len(messages)>0 and messages[0]['role'] == 'system':
+            # If the first message is a system message, we need to prepend it to the user message
+            system_prompt = messages[0]['content']
+            messages = messages[1:]
+            messages[0]['content'] = system_prompt + messages[0]['content']
+
+        for message in messages:
+            if message['role'] == 'assistant':
+                message['role'] = 'model'
+    
+        chat = client.chats.create(
+            model=model_name,
+            history=[
+                types.Content(role=message['role'], parts=[types.Part(text=message['content'])])
+                for message in messages[:-1]
+            ],
+        )
+        response = chat.send_message(message=messages[-1]['content'])
+        end_time = time.time()
+        print(f'It takes {model_name} {end_time - start_time:.2f}s to generate the response.')
+        return response
+
+    num_tokens = 4096
+    temperature = 0.7
+
+    start_time = time.time()
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        max_tokens=num_tokens,
+        temperature=temperature,
+        stream=('qwq' in model_name),
+    )
+
+    if 'qwq' in model_name:
+        answer_content = ""
+        for chunk in response:
+            if chunk.choices:
+                delta = chunk.choices[0].delta
+                if hasattr(delta, 'reasoning_content') and delta.reasoning_content != None:
+                    # We don't need to print the reasoning content
+                    pass
+                else:
+                    answer_content += delta.content
+        response = answer_content
+
+    end_time = time.time()
+    print(f'It takes {model_name} {end_time - start_time:.2f}s to generate the response.')
+    return response
+

main.py

@@ -0,0 +1,33 @@
+import os
+import sys
+
+import hydra
+
+from refine import refine
+from repeated_sample import repeated_sample
+from funsearch import funsearch
+
+@hydra.main(config_path='configs', config_name='default', version_base=None)
+def main(cfg):
+
+    print(f'Method: {cfg.method.name}')
+    print(f'Model name: {cfg.model.name}')
+    print(f'PDE name: {cfg.pde.name}')
+    
+    print(f'Working folder: {cfg.working_folder}')
+    if not os.path.exists(cfg.working_folder):
+        os.makedirs(cfg.working_folder)
+    if cfg.redirect_stdout:
+        sys.stdout = open(os.path.join(cfg.working_folder, 'stdout.txt'), 'w')
+
+    if cfg.method.name[:6] == 'refine':
+        refine(cfg)
+    elif cfg.method.name == 'repeated_sample':
+        repeated_sample(cfg)
+    elif cfg.method.name == 'funsearch':
+        funsearch(cfg)
+    else:
+        raise NotImplementedError(f'Unknown method: {cfg.method.name}')
+
+if __name__ == "__main__":
+    main()

program_database.py

@@ -0,0 +1,270 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A programs database that implements the evolutionary algorithm."""
+from collections.abc import Mapping, Sequence
+import copy
+import dataclasses
+import time
+from typing import Any
+
+import numpy as np
+import scipy
+
+Signature = tuple[float, ...]
+ScoresPerTest = Mapping[Any, float]
+
+
+def _softmax(logits: np.ndarray, temperature: float) -> np.ndarray:
+  """Returns the tempered softmax of 1D finite `logits`."""
+  if not np.all(np.isfinite(logits)):
+    non_finites = set(logits[~np.isfinite(logits)])
+    raise ValueError(f'`logits` contains non-finite value(s): {non_finites}')
+  if not np.issubdtype(logits.dtype, np.floating):
+    logits = np.array(logits, dtype=np.float32)
+
+  result = scipy.special.softmax(logits / temperature, axis=-1)
+  # Ensure that probabilities sum to 1 to prevent error in `np.random.choice`.
+  index = np.argmax(result)
+  result[index] = 1 - np.sum(result[0:index]) - np.sum(result[index+1:])
+  return result
+
+
+def _reduce_score(scores_per_test: ScoresPerTest) -> float:
+  """Reduces per-test scores into a single score."""
+  return scores_per_test[list(scores_per_test.keys())[-1]]
+
+
+def _get_signature(scores_per_test: ScoresPerTest) -> Signature:
+  """Represents test scores as a canonical signature."""
+  return tuple(scores_per_test[k] for k in sorted(scores_per_test.keys()))
+
+
+@dataclasses.dataclass(frozen=True)
+class Prompt:
+  """A prompt produced by the ProgramsDatabase, to be sent to Samplers.
+
+  Attributes:
+    code: The prompt, ending with the header of the function to be completed.
+    version_generated: The function to be completed is `_v{version_generated}`.
+    island_id: Identifier of the island that produced the implementations
+       included in the prompt. Used to direct the newly generated implementation
+       into the same island.
+  """
+  code: str
+  version_generated: int
+  island_id: int
+
+
+@dataclasses.dataclass(frozen=True)
+class ProgramsDatabaseConfig:
+  """Configuration of a ProgramsDatabase.
+
+  Attributes:
+    functions_per_prompt: Number of previous programs to include in prompts.
+    num_islands: Number of islands to maintain as a diversity mechanism.
+    reset_period: How often (in seconds) the weakest islands should be reset.
+    cluster_sampling_temperature_init: Initial temperature for softmax sampling
+        of clusters within an island.
+    cluster_sampling_temperature_period: Period of linear decay of the cluster
+        sampling temperature.
+  """
+  functions_per_prompt: int = 2
+  num_islands: int = 4
+  reset_period: int = 60 * 60
+  cluster_sampling_temperature_init: float = 0.1
+  cluster_sampling_temperature_period: int = 5
+
+
+class ProgramsDatabase:
+  """A collection of programs, organized as islands."""
+
+  def __init__(
+      self,
+      config: ProgramsDatabaseConfig,
+  ) -> None:
+    self._config: ProgramsDatabaseConfig = config
+
+    # Initialize empty islands.
+    self._islands: list[Island] = []
+    for _ in range(config.num_islands):
+      self._islands.append(
+          Island(config.functions_per_prompt,
+                 config.cluster_sampling_temperature_init,
+                 config.cluster_sampling_temperature_period))
+    self._best_score_per_island: list[float] = (
+        [-float('inf')] * config.num_islands)
+    self._best_program_per_island: list[int | None] = (
+        [None] * config.num_islands)
+    self._best_scores_per_test_per_island: list[ScoresPerTest | None] = (
+        [None] * config.num_islands)
+
+    self._last_reset_time: float = time.time()
+
+  def get_seed(self) -> list[int]:
+    """Returns a prompt containing implementations from one chosen island."""
+    island_id = np.random.randint(len(self._islands))
+    seed_ids = self._islands[island_id].get_seed()
+    return island_id, seed_ids
+
+  def _register_program_in_island(
+      self,
+      program: int,
+      program_len: int,
+      island_id: int,
+      scores_per_test: ScoresPerTest,
+  ) -> None:
+    """Registers `program` in the specified island."""
+    self._islands[island_id].register_program(program, program_len, scores_per_test)
+    score = _reduce_score(scores_per_test)
+    if score > self._best_score_per_island[island_id]:
+      self._best_program_per_island[island_id] = program
+      self._best_scores_per_test_per_island[island_id] = scores_per_test
+      self._best_score_per_island[island_id] = score
+
+  def register_program(
+      self,
+      program: int,
+      program_len: int,
+      island_id: int | None,
+      scores_per_test: ScoresPerTest,
+  ) -> None:
+    """Registers `program` in the database."""
+    # In an asynchronous implementation we should consider the possibility of
+    # registering a program on an island that had been reset after the prompt
+    # was generated. Leaving that out here for simplicity.
+    if island_id is None:
+      # This is a program added at the beginning, so adding it to all islands.
+      for island_id in range(len(self._islands)):
+        self._register_program_in_island(program, program_len, island_id, scores_per_test)
+    else:
+      self._register_program_in_island(program, program_len, island_id, scores_per_test)
+
+    # Check whether it is time to reset an island.
+    if (time.time() - self._last_reset_time > self._config.reset_period):
+      self._last_reset_time = time.time()
+      self.reset_islands()
+
+  def reset_islands(self) -> None:
+    """Resets the weaker half of islands."""
+    # We sort best scores after adding minor noise to break ties.
+    indices_sorted_by_score: np.ndarray = np.argsort(
+        self._best_score_per_island +
+        np.random.randn(len(self._best_score_per_island)) * 1e-6)
+    num_islands_to_reset = self._config.num_islands // 2
+    reset_islands_ids = indices_sorted_by_score[:num_islands_to_reset]
+    keep_islands_ids = indices_sorted_by_score[num_islands_to_reset:]
+    for island_id in reset_islands_ids:
+      self._islands[island_id] = Island(
+          self._template,
+          self._function_to_evolve,
+          self._config.functions_per_prompt,
+          self._config.cluster_sampling_temperature_init,
+          self._config.cluster_sampling_temperature_period)
+      self._best_score_per_island[island_id] = -float('inf')
+      founder_island_id = np.random.choice(keep_islands_ids)
+      founder = self._best_program_per_island[founder_island_id]
+      founder_scores = self._best_scores_per_test_per_island[founder_island_id]
+      self._register_program_in_island(founder, island_id, founder_scores)
+
+
+class Island:
+  """A sub-population of the programs database."""
+
+  def __init__(
+      self,
+      functions_per_prompt: int,
+      cluster_sampling_temperature_init: float,
+      cluster_sampling_temperature_period: int,
+  ) -> None:
+    self._functions_per_prompt: int = functions_per_prompt
+    self._cluster_sampling_temperature_init = cluster_sampling_temperature_init
+    self._cluster_sampling_temperature_period = (
+        cluster_sampling_temperature_period)
+
+    self._clusters: dict[Signature, Cluster] = {}
+    self._num_programs: int = 0
+
+  def register_program(
+      self,
+      program: int,
+      program_len: int,
+      scores_per_test: ScoresPerTest,
+  ) -> None:
+    """Stores a program on this island, in its appropriate cluster."""
+    signature = _get_signature(scores_per_test)
+    if signature not in self._clusters:
+      score = _reduce_score(scores_per_test)
+      self._clusters[signature] = Cluster(score, [program], [program_len])
+    else:
+      self._clusters[signature].register_program(program, program_len)
+    self._num_programs += 1
+
+  def get_seed(self) -> tuple[str, int]:
+    """Constructs a prompt containing functions from this island."""
+    signatures = list(self._clusters.keys())
+    cluster_scores = np.array(
+        [self._clusters[signature].score for signature in signatures])
+
+    # Convert scores to probabilities using softmax with temperature schedule.
+    period = self._cluster_sampling_temperature_period
+    temperature = self._cluster_sampling_temperature_init * (
+        1 - (self._num_programs % period) / period)
+    probabilities = _softmax(cluster_scores, temperature)
+
+    # At the beginning of an experiment when we have few clusters, place fewer
+    # programs into the prompt.
+    functions_per_prompt = min(len(self._clusters), self._functions_per_prompt)
+
+    idx = np.random.choice(
+        len(signatures), size=functions_per_prompt, p=probabilities)
+    chosen_signatures = [signatures[i] for i in idx]
+    implementations = []
+    scores = []
+    for signature in chosen_signatures:
+      cluster = self._clusters[signature]
+      implementations.append(cluster.sample_program())
+      scores.append(cluster.score)
+
+    indices = np.argsort(scores)
+    sorted_implementations = [implementations[i] for i in indices]
+    return sorted_implementations
+
+
+class Cluster:
+  """A cluster of programs on the same island and with the same Signature."""
+
+  def __init__(self, score: float, init_programs: list[int], init_program_lengths: list[int]) -> None:
+    self._score = score
+    # We store the indices of the programs in the cluster
+    self._programs: list[int] = init_programs
+    self._lengths: list[int] = init_program_lengths
+
+  @property
+  def score(self) -> float:
+    """Reduced score of the signature that this cluster represents."""
+    return self._score
+
+  def register_program(self, program_idx: int, program_length: int) -> None:
+    """Adds `program` to the cluster."""
+    self._programs.append(program_idx)
+    self._lengths.append(program_length)
+
+  def sample_program(self) -> int:
+    """Samples a program, giving higher probability to shorther programs."""
+    normalized_lengths = (np.array(self._lengths) - min(self._lengths)) / (
+        max(self._lengths) + 1e-6)
+    probabilities = _softmax(-normalized_lengths, temperature=1.0)
+    return np.random.choice(self._programs, p=probabilities)

prompt_files/general_prompt.py

@@ -0,0 +1,126 @@
+system_prompt = '''
+You are an intelligent AI researcher for coding, numerical algorithms, and scientific computing.
+Your goal is to conduct cutting-edge research in the field of PDE solving by leveraging and creatively improving existing algorithms to maximize performances based on feedbacks.
+Follow the user's requirements carefully and make sure you understand them.
+Always document your code as comments to explain the reason behind them.
+Always use Markdown cells to present your code.
+'''
+
+code_generation_without_seed_prompt = '''
+Your task is to solve a partial differential equation (PDE) using Python in batch mode.
+{pde_description}
+
+You will be completing the following code skeleton provided below:
+
+```python
+{solver_template}
+```
+
+Your tasks are:
+1. Understand the above code samples.
+2. Implement the `solver` function to solve the PDE. You must not modify the function signature.
+
+The generated code needs to be clearly structured and bug-free. You must implement auxiliary functions or add additional arguments to the function if needed to modularize the code.
+
+Your generated code will be executed to evaluated. Make sure your `solver` function runs correctly and efficiently.
+You can use PyTorch or JAX with GPU acceleration.
+You must use print statements for to keep track of intermediate results, but do not print too much information. Those output will be useful for future code improvement and/or debugging.
+
+Your output must follow the following structure:
+
+1. A plan on the implementation idea.
+2. Your python implementation (modularized with appropriate auxiliary functions):
+
+```python
+[Your implementation (do NOT add a main function)]
+```
+
+You must use very simple algorithms that are easy to implement.
+'''
+
+problem_prompt = '''
+Your task is to solve a partial differential equation (PDE) using Python in batch mode.
+{pde_description}
+
+You will be improving the following exising code samples. The code samples are provided below:
+
+{code_samples}
+
+Your tasks are:
+1. Understand the above code samples. Compare their techniques and performances.
+2. Identify the parts that could potentially be improved. 
+3. Plan on how you can improve the function.
+4. Improve the function.
+
+The goal is to get a very low nRMSE (normalized RMSE) and make the code as fast as possible.
+
+You must analyze the implementation and test results of the examples provided in the code template, and think about how you can improve them to reduce the nRMSE. 
+If the RMSE is much higher than 1e-2 or becomes Nan, it is likely that there is a bug in the implementation and you must debug it or think about completely different approaches. 
+If the running time is much longer than 600s, you must prioritize making it more efficient.
+The convergence rate is the empirical order of convergence with respect to spatial resolution. It is also a good indicator of the performance of the algorithm which you may consider.
+
+You can implement auxiliary functions or add additional arguments to the function if needed.
+You can use PyTorch or JAX with GPU acceleration.
+You can consider known techniques and analyze their effiectiveness based on exisiting results. You should also consider combining existing techniques or even developing new techniques since you are doing cutting-edge research.
+
+Your generated code will be executed to evaluated. Make sure your `solver` function runs correctly and efficiently.
+You must use print statements for to keep track of intermediate results, but do not print too much information. Those output will be useful for future code improvement and/or debugging.
+
+Your output must follow the following structure:
+
+1. Summary of the existing implementation along with their performances. Identify what techniques work well, what could be buggy (due to high error or Nan), and what could be further improved.
+2. Rationale for the new implementation (think step-by-step) based on the summary of the existing implementation.
+3. Your python implementation (modularized with appropriate auxiliary functions):
+
+```python
+[Your implementation  (do NOT add a main function)]
+```
+'''
+
+code_sample = '''Code Sample {id}:
+```python
+{code}
+```
+
+Running the above code leads to the following output: {code_output}
+'''
+
+
+debugging_execution_error_prompt = '''
+Thank you for your implmentation! When running the code, I got the following output and error message:
+
+Code output: {code_output}
+
+Error message: {error_message}
+
+Can you think step-by-step to identify the root cause of the error and provide a solution to fix it? Please provide a detailed explanation of the error and the solution you propose. You can refer to the code implementation you provided earlier and analyze the error message to identify the issue.
+
+Your response should be in the following format:
+
+[Your rationale for debugging (think step-by-step)]
+
+```python
+[Your bug-free implementation]
+```
+'''
+
+
+debugging_nan_inf_prompt = '''
+Thank you for your implmentation! After running the code, the error becomes NaN or inf.
+
+The followings are the output and error message:
+
+Code output: {code_output}
+
+Error message: {error_message}
+
+Can you think step-by-step to identify the root cause of the error and provide a solution to fix it? You should check if any computation in the code is numerically stable or not. You should also consider to use smaller step sizes.
+
+Your response should be in the following format:
+
+[Your rationale for debugging (think step-by-step)]
+
+```python
+[Your bug-free implementation]
+```
+'''

prompt_files/pde_descriptions.py

@@ -0,0 +1,84 @@
+advection_description = '''
+The PDE is the 1D advection equation, given by
+
+\\[
+\\begin{{cases}}
+\\partial_t u(t, x) + \\beta \\partial_x u(t, x) = 0, & x \\in (0,1), \; t \\in (0,2] \\
+u(0, x) = u_0(x), & x \\in (0,1)
+\\end{{cases}}
+\\]
+
+where $\\beta$ is a constant representing the advection speed. In our task, we assume the periodic boundary condition.
+
+Given the discretization of $u_0(x)$ of shape [batch_size, N], where $N$ is the number of spatial points, you need to implement a solver to predict $u(t, \\cdot)$ for the specified subsequent time steps ($t = t_1, \\ldots, t_T$). The solution is of shape [batch_size, T+1, N] (with the initial time frame and the subsequent steps). Note that although the required time steps are specified, you should consider using smaller time steps internally to obtain more stable simulation.
+
+In particular, your code should be tailored to the case where $\\beta = {advection_beta}$, i.e., optimizing it particularly for this use case.
+'''
+
+
+burgers_description = '''
+The PDE is the burgers equation, given by
+
+\\[
+\\begin{{cases}}
+\\partial_t u(x, t) + \\partial_x \left( \\frac{{u^2(x, t)}}{{2}} \\right) = \\nu \\partial_{{xx}} u(x, t), & x \\in (0,1), \; t \\in (0,1] \\\\
+u(x, 0) = u_0(x), & x \\in (0,1)
+\\end{{cases}}
+\\]
+
+wheer $\\nu$ is a constant representing the viscosity. In our task, we assume the periodic boundary condition.
+
+Given the discretization of $u_0(x)$ of shape [batch_size, N] where $N$ is the number of spatial points, you need to implement a solver to predict u(\cdot, t) for the specified subseqent time steps ($t=t_1, ..., t_T$). The solution is of shape [batch_size, T+1, N] (with the initial time frame and the subsequent steps). Note that although the required time steps are specified, you should consider using smaller time steps internally to obtain more stable simulation.
+
+In particular, your code should be tailored to the case where $\\nu={burgers_nu}$, i.e., optimizing it particularly for this use case.
+'''
+
+reacdiff_1d_description = '''
+The PDE is a diffusion-reaction equation, given by
+
+\\[
+\\begin{{cases}}
+\\partial_t u(t, x) - \\nu \\partial_{{xx}} u(t, x) - \\rho u(1 - u) = 0, & x \\in (0,1), \; t \in (0,T] \\\\
+u(0, x) = u_0(x), & x \in (0,1)
+\end{{cases}}
+\\]
+
+where $\\nu$ and $\\rho$ are coefficients representing diffusion and reaction terms, respectively. In our task, we assume the periodic boundary condition.
+
+Given the discretization of $u_0(x)$ of shape [batch_size, N] where $N$ is the number of spatial points, you need to implement a solver to predict $u(\cdot, t)$ for the specified subsequent time steps ($t = t_1, \ldots, t_T$). The solution is of shape [batch_size, T+1, N] (with the initial time frame and the subsequent steps). Note that although the required time steps are specified, you should consider using smaller time steps internally to obtain more stable simulation.
+
+In particular, your code should be tailored to the case where $\\nu={reacdiff1d_nu}, \\rho={reacdiff1d_rho}$, i.e., optimizing it particularly for this use case.
+Think carefully about the structure of the reaction and diffusion terms in the PDE and how you can exploit this structure to derive accurate result.
+'''
+
+
+cns1d_description = '''
+The PDE is the 1D compressible Navier-Stokes equations, given by
+
+\\[
+\\begin{{cases}}
+\\partial_t \\rho + \\partial_x (\\rho v) = 0 \\\\
+\\rho(\\partial_t v + v\\partial_x v) = -\\partial_x p + \\eta\\partial_{{xx}} v + (\\zeta + \\eta/3)\\partial_x(\\partial_x v) \\\\
+\\partial_t \\left[\\epsilon + \\frac{{\\rho v^2}}{{2}}\\right] + \\partial_x\\left[\\left(\\epsilon + p + \\frac{{\\rho v^2}}{{2}}\\right)v - v\\sigma'\\right] = 0
+\\end{{cases}}
+\\]
+where $\\rho$ is the mass density, $v$ is the velocity, $p$ is the gas pressure, $\\epsilon = p/(\\Gamma - 1)$ is the internal energy with $\\Gamma = 5/3$, $\\sigma'=(\\zeta+\\frac{{4}}{{3}}\\eta) \\partial_x v$ is the viscous stress tensor, and $\\eta, \\zeta$ are the shear and bulk viscosity coefficients, respectively. In our task, we assume periodic boundary conditions. The spatial domain is $\\Omega = [-1,1]$.
+
+Given the discretization of the initial velocity, density, pressure, each of shape [batch_size, N] where $N$ is the number of spatial points, you need to implement a solver to predict the state variables for the specified subsequent time steps ($t = t_1, \\ldots, t_T$). The solver outputs velocity, density, pressure, each of shape [batch_size, T+1, N] (with the initial time frame and the subsequent steps). Note that although the required time steps are specified, you should consider using smaller time steps internally to obtain more stable simulation.
+
+In particular, your code should be tailored to the case where $\\eta = \\zeta = {cns1d_eta}$, i.e., optimizing it particularly for this use case.
+'''
+
+
+darcy_description = '''The PDE is the 2D Darcy flow equation, given by:
+
+\\[-\\nabla \\cdot (a(x) \\nabla u(x)) = 1, \\quad x \\in (0,1)^2\\]
+
+with the boundary condition:
+
+\\[ u(x) = 0, \\quad x \\in \\partial (0,1)^2 \\]
+
+where $u(x)$ is the solution function, and $a(x)$ is a batch of coefficient function. 
+
+Given the discretization of the coefficient function $a(x)$ of shape [batch_size, N, N], where $N$ is the number of spatial grid points in each direction, you need to implement a solver to predict $u(x)$ for the specified subsequent time steps. The solution should be of shape [batch_size, N, N].'''
+

refine.py

@@ -0,0 +1,71 @@
+import os
+import pandas as pd
+import random
+import time
+
+from code_generation import generate_and_debug, prepare_working_folder
+
+def select_seed_implementations(
+    total_num_sample_solvers,
+    num_sample_for_refine=None,
+):
+    if (
+        num_sample_for_refine is None or 
+        num_sample_for_refine > total_num_sample_solvers or
+        num_sample_for_refine == -1
+    ):
+        num_sample_for_refine = total_num_sample_solvers
+
+    # Select random samples for refinement
+    selected_indices = random.sample(range(total_num_sample_solvers), num_sample_for_refine)
+   
+    return selected_indices
+    
+
+
+def refine(cfg):
+    num_repeated_samples = cfg.method.num_repeated_samples
+    num_trials = cfg.method.num_debugging_trials_per_sample
+    pde_name = cfg.pde.name
+    working_folder = cfg.working_folder
+    model_name = cfg.model.name
+    num_sample_for_refine = cfg.method.num_sample_for_refine
+    start_round = cfg.method.start_round
+    use_sample_solver_init = cfg.method.use_sample_solver_init
+    assert use_sample_solver_init, 'Sample solvers must be enabled for refinement'
+
+    sample_solver_folder = os.path.join(
+        'solvers', pde_name, cfg.pde.pde_setting_name, 'seeds'
+    )
+    sample_solver_info = pd.read_csv(
+        os.path.join(sample_solver_folder, 'seed_results.csv')
+    )
+    total_num_sample_solvers = len(sample_solver_info)
+
+    if start_round == 0:
+        prepare_working_folder(
+            cfg, 
+            working_folder=working_folder, 
+            pde_name=pde_name,
+            use_sample_solver_init=use_sample_solver_init
+        )
+
+    for round_idx in range(start_round, num_repeated_samples):
+        try:
+            seed_implementations = select_seed_implementations(
+                total_num_sample_solvers=total_num_sample_solvers,
+                num_sample_for_refine=num_sample_for_refine
+            )
+            generate_and_debug(
+                cfg,
+                round_idx=round_idx,
+                num_trials=num_trials,
+                pde_name=pde_name,
+                working_folder=working_folder,
+                seed_implementations=seed_implementations,
+                model_name=model_name
+            )
+        except Exception as e:
+            print(f'Error in sample {round_idx}: {e}. Move on to the next sample.')
+        
+        time.sleep(2)  # Small delay to prevent API rate limit

repeated_sample.py

@@ -0,0 +1,45 @@
+import os
+import sys
+import time
+
+from code_generation import generate_and_debug, prepare_working_folder
+
+def repeated_sample(cfg):
+    num_repeated_samples = cfg.method.num_repeated_samples
+    num_trials = cfg.method.num_debugging_trials_per_sample
+    pde_name = cfg.pde.name
+    working_folder = cfg.working_folder
+    model_name = cfg.model.name
+
+    if not os.path.exists(working_folder):
+        os.makedirs(working_folder)
+
+    if cfg.redirect_stdout:
+        sys.stdout = open(os.path.join(working_folder, 'stdout.txt'), 'w')
+
+    print(f'Model name: {cfg.model.name}')
+    print(f'Working folder: {working_folder}')
+
+    prepare_working_folder(
+        cfg, 
+        working_folder=working_folder, 
+        pde_name=pde_name,
+        use_sample_solver_init=False
+    )
+
+
+    for sample_idx in range(num_repeated_samples):
+        try:
+            generate_and_debug(
+                cfg,
+                round_idx=sample_idx,
+                num_trials=num_trials,
+                pde_name=pde_name,
+                working_folder=working_folder,
+                seed_implementations=None,
+                model_name=model_name
+            )
+        except Exception as e:
+            print(f'Error in sample {sample_idx}: {e}. Move on to the next sample.')
+        
+        time.sleep(2)  # Small delay to prevent API rate limit

requirements.txt

@@ -0,0 +1,14 @@
+torch
+torchvision
+bitsandbytes
+openai
+pandas
+tqdm
+h5py
+matplotlib
+numpy
+scipy
+hydra-core
+anthropic
+jax
+google-genai

solvers/advection/beta_0.1/seeds/implementation_0.py

@@ -0,0 +1,83 @@
+
+import numpy as np
+
+def _fractional_periodic_shift(u, shift):
+    """
+    Periodically shifts the last axis of an array by a (possibly non-integer)
+    number of grid points using linear interpolation.
+
+    Parameters
+    ----------
+    u : np.ndarray
+        Input array of shape (..., N).
+    shift : float
+        Positive shift (to the right) measured in grid points.
+    Returns
+    -------
+    shifted : np.ndarray
+        Array of the same shape as `u`, shifted periodically.
+    """
+    N = u.shape[-1]
+    # Bring the shift back to the canonical interval [0, N)
+    shift = shift % N
+
+    # Integer and fractional parts of the shift
+    k = int(np.floor(shift))
+    f = shift - k          # 0 <= f < 1
+
+    if f < 1.0e-12:        # pure integer shift – avoid extra work
+        return np.roll(u, k, axis=-1)
+
+    # Values needed for linear interpolation
+    u_k   = np.roll(u,  k,     axis=-1)   # u[j - k]
+    u_k1  = np.roll(u,  k + 1, axis=-1)   # u[j - k - 1]
+
+    return (1.0 - f) * u_k + f * u_k1
+
+
+def solver(u0_batch, t_coordinate, beta):
+    """Solves the 1-D periodic advection equation u_t + beta * u_x = 0.
+
+    The method is *exact*: the initial profile is merely shifted by
+    beta * t for each requested time instant.
+
+    Parameters
+    ----------
+    u0_batch : np.ndarray
+        Initial data with shape [batch_size, N]
+    t_coordinate : np.ndarray
+        Time stamps (T+1,) beginning with 0.
+    beta : float
+        Constant advection speed.
+
+    Returns
+    -------
+    solutions : np.ndarray
+        Array of shape [batch_size, T+1, N] containing u(t_i, x_j).
+    """
+    # --------------------------- sanity checks ---------------------------
+    if t_coordinate.ndim != 1:
+        raise ValueError("t_coordinate must be one-dimensional")
+    if abs(t_coordinate[0]) > 1e-12:
+        raise ValueError("t_coordinate[0] must be 0.0")
+
+    batch_size, N = u0_batch.shape
+    T = len(t_coordinate) - 1          # number of future time frames
+
+    # Spatial step Δx assuming domain length L = 1
+    dx = 1.0 / N
+
+    # ---------- allocate result tensor and copy initial condition -------
+    solutions = np.empty((batch_size, T + 1, N), dtype=u0_batch.dtype)
+    solutions[:, 0, :] = u0_batch
+
+    # ----------------------- march through required times ---------------
+    for i, t in enumerate(t_coordinate[1:], start=1):
+        shift_flow = beta * t / dx     # shift in *grid points*
+        if i == 1:                     # tiny diagnostic once per run
+            print(f"[solver] beta={beta:.4g}, t={t:.4g}, "
+                  f"shift={shift_flow:.4g} grid points")
+        solutions[:, i, :] = _fractional_periodic_shift(u0_batch,
+                                                        shift_flow)
+
+    return solutions

solvers/advection/beta_0.1/seeds/implementation_1.py

@@ -0,0 +1,104 @@
+
+import numpy as np
+
+# Optional acceleration with PyTorch if it is installed and a GPU is visible.
+try:
+    import torch
+    _TORCH_AVAILABLE = True
+except ModuleNotFoundError:                # pragma: no cover
+    _TORCH_AVAILABLE = False
+
+
+def _select_backend(array):
+    """
+    Decide whether to run on numpy (CPU) or torch (CPU/GPU) based on the
+    type of `array` and on the availability of torch + CUDA.
+    """
+    if _TORCH_AVAILABLE and isinstance(array, torch.Tensor):
+        return "torch"
+    return "numpy"
+
+
+def _rfft(a, backend):
+    """Real-to-complex FFT along the last axis for both back-ends."""
+    if backend == "torch":
+        return torch.fft.rfft(a, dim=-1)
+    return np.fft.rfft(a, axis=-1)
+
+
+def _irfft(a, n, backend, dtype):
+    """
+    Inverse rFFT that returns a real array of length `n` and is cast back to
+    `dtype` for the NumPy backend (torch keeps dtype automatically).
+    """
+    if backend == "torch":
+        return torch.fft.irfft(a, n=n, dim=-1)
+    arr = np.fft.irfft(a, n=n, axis=-1)
+    return arr.astype(dtype, copy=False)
+
+
+def solver(u0_batch, t_coordinate, beta):
+    """Solves the 1-D periodic advection equation ∂_t u + β ∂_x u = 0.
+
+    Exact spectral shift method:
+        u(t,x) = u0(x − β t)   (periodic on [0,1))
+
+    Parameters
+    ----------
+    u0_batch : np.ndarray | torch.Tensor, shape (B, N)
+        Batch of initial conditions.
+    t_coordinate : np.ndarray | torch.Tensor, shape (T+1,)
+        Time stamps, starting with 0.0.
+    beta : float
+        Constant advection speed.
+
+    Returns
+    -------
+    solutions : same backend as `u0_batch`, shape (B, T+1, N)
+        Numerical solution for all requested times.
+    """
+    backend = _select_backend(u0_batch)
+    B, N = u0_batch.shape
+    T_plus_1 = t_coordinate.shape[0]
+
+    # Convert t_coordinate and wavenumbers to the active backend
+    if backend == "torch":
+        device = u0_batch.device
+        dtype = u0_batch.dtype
+        t_arr = torch.as_tensor(t_coordinate, dtype=dtype, device=device)
+        k = torch.arange(0, N // 2 + 1, dtype=dtype, device=device)
+    else:
+        dtype = u0_batch.dtype
+        t_arr = np.asarray(t_coordinate, dtype=dtype)
+        k = np.arange(0, N // 2 + 1, dtype=dtype)
+
+    # Allocate output container
+    if backend == "torch":
+        solutions = torch.empty((B, T_plus_1, N), dtype=dtype, device=u0_batch.device)
+    else:
+        solutions = np.empty((B, T_plus_1, N), dtype=dtype)
+
+    # Store initial condition
+    solutions[:, 0, :] = u0_batch
+
+    # Forward FFT of the initial condition
+    U0 = _rfft(u0_batch, backend=backend)          # shape (B, N//2+1)
+
+    # Build complex exponent  -i 2π k β t  (vectorised over all times)
+    if backend == "torch":
+        exponent = -2 * torch.pi * 1j * (beta * t_arr)[:, None] * k[None, :]
+        phase = torch.exp(exponent)                # shape (T+1, N//2+1)
+    else:
+        exponent = -2 * np.pi * 1j * (beta * t_arr)[:, None] * k[None, :]
+        phase = np.exp(exponent)                   # shape (T+1, N//2+1)
+
+    # Fill all requested time levels except t=0 (already done)
+    for idx in range(1, T_plus_1):
+        Ut = U0 * phase[idx]                       # broadcasting over batch
+        solutions[:, idx, :] = _irfft(Ut, n=N, backend=backend, dtype=dtype)
+
+    # Concise diagnostic
+    print(f"[solver] batch={B}, N={N}, times={T_plus_1-1}, "
+          f"beta={beta}, t_min={t_arr[0]:.3g}, t_max={t_arr[-1]:.3g}")
+
+    return solutions

solvers/advection/beta_0.1/seeds/implementation_2.py

@@ -0,0 +1,127 @@
+
+import numpy as np
+import torch # Import PyTorch
+
+# Check if GPU is available and set the device accordingly
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+    print("GPU found, using CUDA.")
+else:
+    device = torch.device("cpu")
+    print("GPU not found, using CPU.")
+
+def spectral_step(u_t, dt, k, beta):
+    """
+    Performs one time step of the advection equation using the spectral method.
+
+    Args:
+        u_t (torch.Tensor): Solution at the current time step [batch_size, N].
+        dt (float): Time step duration.
+        k (torch.Tensor): Wavenumbers [1, N].
+        beta (float): Advection speed.
+
+    Returns:
+        torch.Tensor: Solution at the next time step [batch_size, N].
+    """
+    # Compute the Fast Fourier Transform (FFT) along the spatial dimension (last dim)
+    u_hat = torch.fft.fft(u_t, dim=-1)
+
+    # Compute the propagator term in Fourier space: exp(-i * beta * k * dt)
+    # Ensure k has the correct shape for broadcasting and is on the same device/dtype
+    # Note: 1j is the imaginary unit in Python
+    propagator = torch.exp(-1j * beta * k * dt)
+
+    # Multiply the Fourier coefficients by the propagator
+    u_hat_next = u_hat * propagator
+
+    # Compute the Inverse Fast Fourier Transform (IFFT)
+    u_next = torch.fft.ifft(u_hat_next, dim=-1)
+
+    # Return the real part of the solution (numerical errors might introduce small imaginary parts)
+    return u_next.real
+
+def solver(u0_batch, t_coordinate, beta):
+    """Solves the 1D Advection equation using the Fourier spectral method.
+
+    Args:
+        u0_batch (np.ndarray): Initial condition [batch_size, N],
+            where batch_size is the number of different initial conditions,
+            and N is the number of spatial grid points.
+        t_coordinate (np.ndarray): Time coordinates of shape [T+1].
+            It begins with t_0=0 and follows the time steps t_1, ..., t_T.
+        beta (float): Constant advection speed. Specifically considered for beta=0.1.
+
+    Returns:
+        solutions (np.ndarray): Shape [batch_size, T+1, N].
+            solutions[:, 0, :] contains the initial conditions (u0_batch),
+            solutions[:, i, :] contains the solutions at time t_coordinate[i].
+    """
+    # --- 1. Initialization ---
+    print("Starting solver...")
+
+    # Get dimensions
+    batch_size, N = u0_batch.shape
+    num_time_steps = len(t_coordinate)
+    T = num_time_steps - 1 # Number of intervals
+
+    # Convert inputs to PyTorch tensors and move to the selected device
+    # Use float32 for efficiency on GPUs, and derive complex dtype
+    u0_batch_torch = torch.tensor(u0_batch, dtype=torch.float32, device=device)
+    t_coordinate_torch = torch.tensor(t_coordinate, dtype=torch.float32, device=device)
+
+    # Define spatial domain parameters (assuming domain is [0, 1])
+    L = 1.0 # Length of the spatial domain
+    dx = L / N # Spatial step size
+
+    # Calculate wavenumbers k for the spectral method
+    # k = 2 * pi * [0, 1, ..., N/2-1, -N/2, ..., -1] / L
+    # Use torch.fft.fftfreq for convenience
+    # Reshape k to [1, N] for broadcasting with u_hat [batch_size, N]
+    k_freq = torch.fft.fftfreq(N, d=dx, device=device)
+    k = 2 * np.pi * k_freq
+    k = k.reshape(1, N) # Reshape for broadcasting
+    # Ensure k is complex for calculations involving 1j
+    k = k.to(torch.complex64)
+
+
+    # Initialize the solutions tensor to store results at each required time step
+    # Shape: [batch_size, T+1, N]
+    solutions_torch = torch.zeros((batch_size, num_time_steps, N), dtype=torch.float32, device=device)
+
+    # Store the initial condition
+    solutions_torch[:, 0, :] = u0_batch_torch
+    print(f"Initial condition stored. Shape: {u0_batch_torch.shape}")
+
+    # Set the current solution state
+    u_current = u0_batch_torch
+
+    # --- 2. Time Stepping Loop ---
+    print(f"Starting time stepping for {T} intervals...")
+    for i in range(T):
+        # Calculate the time step duration for this interval
+        t_current = t_coordinate_torch[i]
+        t_next = t_coordinate_torch[i+1]
+        dt = (t_next - t_current).item() # Get dt as a float
+
+        # Perform one spectral step to get the solution at t_next
+        u_next = spectral_step(u_current, dt, k, beta)
+
+        # Store the solution at t_next
+        solutions_torch[:, i+1, :] = u_next
+
+        # Update the current solution for the next iteration
+        u_current = u_next
+
+        # Optional: Print progress
+        if (i + 1) % max(1, T // 10) == 0 or i == T - 1:
+             print(f"Computed step {i+1}/{T}, Time = {t_next.item():.4f}")
+
+    # --- 3. Finalization ---
+    print("Simulation finished.")
+
+    # Move the solutions tensor back to CPU and convert to NumPy array
+    solutions_np = solutions_torch.cpu().numpy()
+
+    print(f"Returning solutions array with shape: {solutions_np.shape}")
+    return solutions_np
+