Upload 357 files

pyPDAF/mcp_output/README_MCP.md

@@ -0,0 +1,75 @@
+# pyPDAF
+
+Welcome to the `pyPDAF` project! This repository provides a Python interface for the Parallel Data Assimilation Framework (PDAF), enabling efficient data assimilation in numerical models.
+
+## Project Overview
+
+`pyPDAF` is designed to facilitate the integration of data assimilation techniques into numerical models. It supports both offline and online data assimilation processes, providing a flexible and scalable solution for various applications. The project includes a comprehensive set of tools and examples to help users get started quickly.
+
+### Repository
+
+- **GitHub Repository**: [pyPDAF](https://github.com/yumengch/pyPDAF)
+
+## Installation Instructions
+
+To install `pyPDAF`, ensure you have Python installed on your system. The project uses a `pyproject.toml` file for configuration, which means you can install it using a tool like `pip` or `poetry`.
+
+### Using pip
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/yumengch/pyPDAF.git
+   cd pyPDAF
+   ```
+
+2. Install the package:
+   ```
+   pip install .
+   ```
+
+### Using Poetry
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/yumengch/pyPDAF.git
+   cd pyPDAF
+   ```
+
+2. Install the package:
+   ```
+   poetry install
+   ```
+
+## Usage Methods
+
+`pyPDAF` provides several examples to demonstrate its capabilities. These examples are located in the `example` directory and are divided into `offline` and `online` modes.
+
+### Running Examples
+
+- **Offline Mode**: Navigate to `example/offline` and run the `main.py` script to see offline data assimilation in action.
+- **Online Mode**: Navigate to `example/online` and execute the `main.py` script to observe online data assimilation.
+
+## Available Tool Endpoints
+
+The `pyPDAF` package includes several tools and scripts to assist with data assimilation tasks:
+
+- **Collector**: Collects data for assimilation.
+- **Config**: Configuration files for setting up assimilation parameters.
+- **Filter Options**: Defines options for the assimilation filter.
+- **Localisation**: Handles localisation of data.
+- **Parallelisation**: Manages parallel execution of assimilation tasks.
+- **Prepost Processing**: Prepares data before and after assimilation.
+
+## Notes and Troubleshooting
+
+- Ensure all dependencies are installed correctly. If you encounter issues, verify your Python environment and package installations.
+- For detailed documentation on each module and function, refer to the `docs/source` directory.
+- If you experience performance issues, consider adjusting the parallelisation settings in the configuration files.
+
+## Troubleshooting Common Issues
+
+- **Installation Errors**: Ensure you have the latest version of `pip` or `poetry` and that your Python environment is correctly set up.
+- **Runtime Errors**: Check the configuration files for any incorrect settings or paths.
+- **Performance Issues**: Review the parallelisation settings and adjust them according to your system's capabilities.
+
+For further assistance, please refer to the [GitHub Issues](https://github.com/yumengch/pyPDAF/issues) page to report bugs or request features.

pyPDAF/mcp_output/analysis.json

@@ -0,0 +1,594 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/yumengch/pyPDAF",
+    "summary": "Imported via zip fallback, file count: 165",
+    "file_tree": {
+      ".github/workflows/conda_build_linux.yaml": {
+        "size": 1029
+      },
+      ".github/workflows/conda_build_mac_intel.yaml": {
+        "size": 1018
+      },
+      ".github/workflows/conda_build_mac_m1.yaml": {
+        "size": 1010
+      },
+      ".github/workflows/conda_build_win.yaml": {
+        "size": 1297
+      },
+      "README.md": {
+        "size": 4185
+      },
+      "conda.recipe/conda_build_config.yaml": {
+        "size": 533
+      },
+      "conda.recipe/meta.yaml": {
+        "size": 946
+      },
+      "docs/source/conf.py": {
+        "size": 2529
+      },
+      "docs/source/develop.md": {
+        "size": 14515
+      },
+      "docs/source/hidden_functions.md": {
+        "size": 31818
+      },
+      "docs/source/install.md": {
+        "size": 3251
+      },
+      "docs/source/introduction.md": {
+        "size": 2573
+      },
+      "docs/source/links.md": {
+        "size": 1071
+      },
+      "docs/source/naming_convention.md": {
+        "size": 1775
+      },
+      "docs/source/parallel.md": {
+        "size": 6287
+      },
+      "example/inputs_offline/ens_1.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_2.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_3.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_4.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_5.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_6.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_7.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_8.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/ens_9.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/obs.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/obsB.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/obsC.txt": {
+        "size": 479
+      },
+      "example/inputs_offline/state_ini.txt": {
+        "size": 9090
+      },
+      "example/inputs_offline/true.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_1.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_2.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_3.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_4.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_5.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_6.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_7.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_8.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ensB_9.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_1.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_2.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_3.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_4.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_5.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_6.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_7.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_8.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/ens_9.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/iobs_step1.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step10.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step11.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step12.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step13.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step14.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step15.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step16.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step17.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step18.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step2.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step3.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step4.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step5.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step6.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step7.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step8.txt": {
+        "size": 479
+      },
+      "example/inputs_online/iobs_step9.txt": {
+        "size": 479
+      },
+      "example/inputs_online/obs_step1.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step10.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step11.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step12.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step13.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step14.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step15.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step16.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step17.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step18.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step2.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step3.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step4.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step5.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step6.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step7.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step8.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/obs_step9.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/state_ini.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_initial.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step1.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step10.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step11.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step12.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step13.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step14.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step15.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step16.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step17.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step18.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step2.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step3.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step4.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step5.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step6.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step7.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step8.txt": {
+        "size": 9090
+      },
+      "example/inputs_online/true_step9.txt": {
+        "size": 9090
+      },
+      "example/offline/collector.py": {
+        "size": 2839
+      },
+      "example/offline/config.py": {
+        "size": 3345
+      },
+      "example/offline/config_obsA.py": {
+        "size": 2409
+      },
+      "example/offline/config_obsB.py": {
+        "size": 2403
+      },
+      "example/offline/filter_options.py": {
+        "size": 2692
+      },
+      "example/offline/localisation.py": {
+        "size": 4961
+      },
+      "example/offline/log.py": {
+        "size": 982
+      },
+      "example/offline/main.py": {
+        "size": 1486
+      },
+      "example/offline/model.py": {
+        "size": 3062
+      },
+      "example/offline/obs_a.py": {
+        "size": 13595
+      },
+      "example/offline/obs_b.py": {
+        "size": 12620
+      },
+      "example/offline/obs_factory.py": {
+        "size": 4945
+      },
+      "example/offline/parallelisation.py": {
+        "size": 11633
+      },
+      "example/offline/pdaf_system.py": {
+        "size": 4891
+      },
+      "example/offline/prepost_processing.py": {
+        "size": 7523
+      },
+      "example/offline/state_vector.py": {
+        "size": 1527
+      },
+      "example/online/collector.py": {
+        "size": 3219
+      },
+      "example/online/config.py": {
+        "size": 3421
+      },
+      "example/online/config_obsA.py": {
+        "size": 2416
+      },
+      "example/online/config_obsB.py": {
+        "size": 2410
+      },
+      "example/online/distributor.py": {
+        "size": 2449
+      },
+      "example/online/filter_options.py": {
+        "size": 2702
+      },
+      "example/online/localisation.py": {
+        "size": 4958
+      },
+      "example/online/log.py": {
+        "size": 982
+      },
+      "example/online/main.py": {
+        "size": 1799
+      },
+      "example/online/model.py": {
+        "size": 4492
+      },
+      "example/online/model_integrator.py": {
+        "size": 2846
+      },
+      "example/online/obs_a.py": {
+        "size": 13587
+      },
+      "example/online/obs_b.py": {
+        "size": 12612
+      },
+      "example/online/obs_factory.py": {
+        "size": 4937
+      },
+      "example/online/parallelisation.py": {
+        "size": 11700
+      },
+      "example/online/pdaf_system.py": {
+        "size": 5094
+      },
+      "example/online/prepost_processing.py": {
+        "size": 7018
+      },
+      "example/online/state_vector.py": {
+        "size": 1481
+      },
+      "pyproject.toml": {
+        "size": 464
+      },
+      "src/pyPDAF/PDAF/__init__.py": {
+        "size": 1474
+      },
+      "src/pyPDAF/PDAF3/__init__.py": {
+        "size": 1393
+      },
+      "src/pyPDAF/PDAFlocal/__init__.py": {
+        "size": 119
+      },
+      "src/pyPDAF/PDAFlocalomi/__init__.py": {
+        "size": 36
+      },
+      "src/pyPDAF/PDAFomi/__init__.py": {
+        "size": 1467
+      },
+      "src/pyPDAF/README.md": {
+        "size": 102
+      },
+      "src/pyPDAF/__init__.py": {
+        "size": 4136
+      },
+      "tests/test_example.py": {
+        "size": 2042
+      },
+      "tests/test_init.py": {
+        "size": 4467
+      },
+      "tool/compare_subroutines.py": {
+        "size": 4014
+      },
+      "tool/docstring/__init__.py": {
+        "size": 11
+      },
+      "tool/docstring/docstrings.py": {
+        "size": 55894
+      },
+      "tool/docstring/pdaf_assimilate_docstrings.py": {
+        "size": 47100
+      },
+      "tool/docstring/pdaf_diag_docstrings.py": {
+        "size": 4040
+      },
+      "tool/docstring/pdaf_put_state_docstrings.py": {
+        "size": 53643
+      },
+      "tool/docstring/pdaflocal_assimilate_docstrings.py": {
+        "size": 44589
+      },
+      "tool/docstring/pdaflocalomi_assimilate_docstrings.py": {
+        "size": 15307
+      },
+      "tool/docstring/pdaflocalomi_put_state_docstrings.py": {
+        "size": 19539
+      },
+      "tool/docstring/pdafomi_assimilate_docstrings.py": {
+        "size": 43817
+      },
+      "tool/docstring/pdafomi_put_state_docstrings.py": {
+        "size": 54897
+      },
+      "tool/get_decls.py": {
+        "size": 6809
+      },
+      "tool/get_decls_cb.py": {
+        "size": 8181
+      },
+      "tool/write_binding.py": {
+        "size": 16180
+      },
+      "tool/write_cb_pxd.py": {
+        "size": 3050
+      },
+      "tool/write_cb_pyx.py": {
+        "size": 11250
+      },
+      "tool/write_pdaf_pxd.py": {
+        "size": 5172
+      },
+      "tool/write_pdaf_pyx.py": {
+        "size": 20775
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.src.pyPDAF",
+      "source.tool.docstring"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.src.pyPDAF",
+        "module": "PDAF",
+        "functions": [],
+        "classes": [],
+        "description": "Core module for PDAF functionalities."
+      },
+      {
+        "package": "source.src.pyPDAF",
+        "module": "PDAF3",
+        "functions": [],
+        "classes": [],
+        "description": "Module for PDAF3 functionalities."
+      },
+      {
+        "package": "source.src.pyPDAF",
+        "module": "PDAFlocal",
+        "functions": [],
+        "classes": [],
+        "description": "Module for local PDAF functionalities."
+      },
+      {
+        "package": "source.src.pyPDAF",
+        "module": "PDAFlocalomi",
+        "functions": [],
+        "classes": [],
+        "description": "Module for local OMI PDAF functionalities."
+      },
+      {
+        "package": "source.src.pyPDAF",
+        "module": "PDAFomi",
+        "functions": [],
+        "classes": [],
+        "description": "Module for OMI PDAF functionalities."
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.8
+    },
+    "dependencies": {
+      "required": [],
+      "optional": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/yumengch/pyPDAF",
+    "repo_name": "pyPDAF",
+    "content": null,
+    "model": "gpt-4o",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

pyPDAF/mcp_output/env_info.json

@@ -0,0 +1,15 @@
+{
+  "environment": {
+    "type": "conda",
+    "name": "pyPDAF_294797_env",
+    "files": {},
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "original_tests": {
+    "passed": false,
+    "report_path": null
+  },
+  "timestamp": 1765295006.3769076,
+  "conda_available": true
+}

pyPDAF/mcp_output/mcp_logs/llm_statistics.json

@@ -0,0 +1,11 @@
+{
+  "total_calls": 5,
+  "failed_calls": 0,
+  "retry_count": 0,
+  "total_prompt_tokens": 16659,
+  "total_completion_tokens": 3952,
+  "total_tokens": 20611,
+  "average_prompt_tokens": 3331.8,
+  "average_completion_tokens": 790.4,
+  "average_tokens": 4122.2
+}

pyPDAF/mcp_output/mcp_logs/run_log.json

@@ -0,0 +1,55 @@
+{
+  "timestamp": 1765295196.2013648,
+  "node": "RunNode",
+  "test_result": {
+    "passed": false,
+    "report_path": null,
+    "stdout": "",
+    "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n    from src.pyPDAF import PDAF, PDAF3, PDAFlocal, PDAFlocalomi, PDAFomi\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/src/pyPDAF/__init__.py\", line 7, in <module>\n    import mpi4py\nModuleNotFoundError: No module named 'mpi4py'\n\n"
+  },
+  "run_result": {
+    "success": false,
+    "test_passed": false,
+    "exit_code": 1,
+    "stdout": "",
+    "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n    from src.pyPDAF import PDAF, PDAF3, PDAFlocal, PDAFlocalomi, PDAFomi\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/src/pyPDAF/__init__.py\", line 7, in <module>\n    import mpi4py\nModuleNotFoundError: No module named 'mpi4py'\n\n",
+    "timestamp": 1765295196.201337,
+    "error_type": "ImportError",
+    "error": "Module import failed: ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n    from src.pyPDAF import PDAF, PDAF3, PDAFlocal, PDAFlocalomi, PDAFomi\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/src/pyPDAF/__init__.py\", line 7, in <module>\n    import mpi4py\nModuleNotFoundError: No module named 'mpi4py'\n\n",
+    "details": {
+      "command": "/home/wshiah/code/miniconda3/bin/conda run -n pyPDAF_294797_env --cwd /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF python mcp_output/start_mcp.py",
+      "working_directory": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF",
+      "environment_type": "conda"
+    }
+  },
+  "environment": {
+    "type": "conda",
+    "name": "pyPDAF_294797_env",
+    "files": {},
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "plugin_info": {
+    "files": {
+      "mcp_output/start_mcp.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/README_MCP.md",
+      "mcp_output/tests_mcp/test_mcp_basic.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/tests_mcp/test_mcp_basic.py"
+    },
+    "adapter_mode": "import",
+    "endpoints": [],
+    "mcp_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/mcp_plugin",
+    "tests_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/tests_mcp",
+    "main_entry": "start_mcp.py",
+    "readme_path": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/mcp_output/README_MCP.md",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ]
+  },
+  "fastmcp_installed": false
+}

pyPDAF/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,152 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from src.pyPDAF.PDAF import *
+    from src.pyPDAF.PDAF3 import *
+    from src.pyPDAF.PDAFlocal import *
+    from src.pyPDAF.PDAFlocalomi import *
+    from src.pyPDAF.PDAFomi import *
+    from src.pyPDAF import *
+    from tool.docstring import *
+except ImportError as e:
+    print(f"Import failed: {e}. Ensure the source directory is correctly set.")
+    # Fallback handling can be implemented here if necessary
+
+class Adapter:
+    """
+    Adapter class for MCP plugin, utilizing the pyPDAF library.
+    """
+
+    def __init__(self):
+        """
+        Initialize the Adapter with default mode set to 'import'.
+        """
+        self.mode = "import"
+
+    # -------------------------------------------------------------------------
+    # PDAF Module Methods
+    # -------------------------------------------------------------------------
+
+    def initialize_pdaf(self):
+        """
+        Initialize the PDAF module.
+        
+        Returns:
+            dict: Status of the initialization.
+        """
+        try:
+            # Assuming there's an initialization function in PDAF
+            # This is a placeholder for actual initialization logic
+            status = "PDAF initialized successfully."
+            return {"status": status}
+        except Exception as e:
+            return {"status": f"Initialization failed: {e}"}
+
+    # -------------------------------------------------------------------------
+    # PDAF3 Module Methods
+    # -------------------------------------------------------------------------
+
+    def initialize_pdaf3(self):
+        """
+        Initialize the PDAF3 module.
+        
+        Returns:
+            dict: Status of the initialization.
+        """
+        try:
+            # Placeholder for actual initialization logic
+            status = "PDAF3 initialized successfully."
+            return {"status": status}
+        except Exception as e:
+            return {"status": f"Initialization failed: {e}"}
+
+    # -------------------------------------------------------------------------
+    # PDAFlocal Module Methods
+    # -------------------------------------------------------------------------
+
+    def initialize_pdaf_local(self):
+        """
+        Initialize the PDAFlocal module.
+        
+        Returns:
+            dict: Status of the initialization.
+        """
+        try:
+            # Placeholder for actual initialization logic
+            status = "PDAFlocal initialized successfully."
+            return {"status": status}
+        except Exception as e:
+            return {"status": f"Initialization failed: {e}"}
+
+    # -------------------------------------------------------------------------
+    # PDAFlocalomi Module Methods
+    # -------------------------------------------------------------------------
+
+    def initialize_pdaf_localomi(self):
+        """
+        Initialize the PDAFlocalomi module.
+        
+        Returns:
+            dict: Status of the initialization.
+        """
+        try:
+            # Placeholder for actual initialization logic
+            status = "PDAFlocalomi initialized successfully."
+            return {"status": status}
+        except Exception as e:
+            return {"status": f"Initialization failed: {e}"}
+
+    # -------------------------------------------------------------------------
+    # PDAFomi Module Methods
+    # -------------------------------------------------------------------------
+
+    def initialize_pdaf_omi(self):
+        """
+        Initialize the PDAFomi module.
+        
+        Returns:
+            dict: Status of the initialization.
+        """
+        try:
+            # Placeholder for actual initialization logic
+            status = "PDAFomi initialized successfully."
+            return {"status": status}
+        except Exception as e:
+            return {"status": f"Initialization failed: {e}"}
+
+    # -------------------------------------------------------------------------
+    # General Methods
+    # -------------------------------------------------------------------------
+
+    def execute_function(self, function_name, *args, **kwargs):
+        """
+        Execute a function from the imported modules.
+        
+        Parameters:
+            function_name (str): The name of the function to execute.
+            *args: Positional arguments for the function.
+            **kwargs: Keyword arguments for the function.
+        
+        Returns:
+            dict: Result of the function execution.
+        """
+        try:
+            func = globals().get(function_name)
+            if not func:
+                raise ValueError(f"Function {function_name} not found.")
+            result = func(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": f"Execution failed: {e}"}
+
+# Example usage
+if __name__ == "__main__":
+    adapter = Adapter()
+    print(adapter.initialize_pdaf())
+    print(adapter.execute_function('some_function', 1, 2, key='value'))

pyPDAF/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

pyPDAF/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,1622 @@
+"""
+MCP Service for pyPDAF - Parallel Data Assimilation Framework
+
+This module provides MCP (Model Context Protocol) tools for interacting with
+the pyPDAF library, which is a Python interface to the PDAF (Parallel Data
+Assimilation Framework) library for ensemble-based data assimilation.
+"""
+
+import os
+import sys
+from typing import List, Optional
+
+import numpy as np
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from src.pyPDAF import PDAF, PDAF3, PDAFlocal, PDAFlocalomi, PDAFomi
+
+mcp = FastMCP("pyPDAF_service")
+
+
+# ============================================================================
+# PDAF Core Module Tools
+# ============================================================================
+
+@mcp.tool(name="pdaf_correlation_function", description="Calculate the value of a correlation function at a given distance")
+def pdaf_correlation_function(ctype: int, length: float, distance: float) -> dict:
+    """
+    Calculate the value of the chosen correlation function according to the specified length scale.
+    
+    Args:
+        ctype: Type of correlation function
+               1: Gaussian with f(0)=1.0
+               2: 5th-order polynomial (Gaspari/Cohn, 1999)
+        length: Length scale of function
+                ctype=1: standard deviation
+                ctype=2: support length (f=0 for distance>length)
+        distance: Distance at which the function is evaluated
+    
+    Returns:
+        dict: A dictionary containing the success status and the correlation value.
+    """
+    try:
+        value = PDAF.correlation_function(ctype, length, distance)
+        return {"success": True, "result": {"value": float(value)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_deallocate", description="Finalize the PDAF system and free allocated memory")
+def pdaf_deallocate() -> dict:
+    """
+    Finalise the PDAF system including freeing some of the memory used by PDAF.
+    
+    Note: This function cannot free all allocated PDAF memory.
+    Therefore, one should not use PDAF.init afterwards.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.deallocate()
+        return {"success": True, "result": "PDAF memory deallocated successfully", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_eofcovar", description="Perform EOF analysis of an ensemble of state vectors by SVD")
+def pdaf_eofcovar(
+    dim: int,
+    nstates: int,
+    nfields: int,
+    dim_fields: List[int],
+    offsets: List[int],
+    remove_mstate: int,
+    do_mv: int,
+    states: List[List[float]],
+    meanstate: List[float],
+    verbose: int
+) -> dict:
+    """
+    EOF analysis of an ensemble of state vectors by singular value decomposition.
+    
+    This function performs a singular value decomposition of the ensemble anomaly.
+    The singular values and corresponding singular vectors can be used to
+    construct a covariance matrix for the initial ensemble.
+    
+    Args:
+        dim: Dimension of state vector
+        nstates: Number of state vectors
+        nfields: Number of fields in state vector
+        dim_fields: Size of each field (list of length nfields)
+        offsets: Start position of each field (list of length nfields)
+        remove_mstate: 1 to subtract mean state from states
+        do_mv: 1 for multivariate scaling; 0 for no scaling
+        states: State perturbations (2D list of shape [dim, nstates])
+        meanstate: Mean state (list of length dim)
+        verbose: Verbosity flag
+    
+    Returns:
+        dict: A dictionary containing:
+            - states: Updated state perturbations
+            - stddev: Standard deviation of field variability
+            - svals: Singular values divided by sqrt(nstates-1)
+            - svec: Singular vectors
+            - meanstate: Updated mean state
+            - status: Status flag
+    """
+    try:
+        states_np = np.array(states, dtype=np.float64)
+        meanstate_np = np.array(meanstate, dtype=np.float64)
+        dim_fields_np = np.array(dim_fields, dtype=np.int32)
+        offsets_np = np.array(offsets, dtype=np.int32)
+        
+        result = PDAF.eofcovar(
+            dim, nstates, nfields, dim_fields_np, offsets_np,
+            remove_mstate, do_mv, states_np, meanstate_np, verbose
+        )
+        
+        states_out, stddev, svals, svec, meanstate_out, status = result
+        return {
+            "success": True,
+            "result": {
+                "states": states_out.tolist(),
+                "stddev": stddev.tolist(),
+                "svals": svals.tolist(),
+                "svec": svec.tolist(),
+                "meanstate": meanstate_out.tolist(),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_force_analysis", description="Force PDAF to perform analysis at next assimilation call")
+def pdaf_force_analysis() -> dict:
+    """
+    Force PDAF to perform assimilation at the next function call.
+    
+    This function overwrites member index of the ensemble state
+    and forces that the analysis step is executed at the next call
+    to PDAF assimilation functions.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.force_analysis()
+        return {"success": True, "result": "Analysis forced successfully", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_fcst_info", description="Get forecast information including time steps and exit flag")
+def pdaf_get_fcst_info(steps: int = 0, time: float = 0.0, doexit: int = 0) -> dict:
+    """
+    Return the number of time steps, current model time, and exit flag.
+    
+    This is used when the flexible parallelization mode is used with
+    PDAF3.assimilate. This is also relevant for legacy assimilation functions.
+    
+    Args:
+        steps: Number of forecast time steps (input can be arbitrary)
+        time: Current model time
+        doexit: Whether to exit from forecasts
+    
+    Returns:
+        dict: A dictionary containing:
+            - steps: Number of forecast time steps for next assimilation
+            - time: Current model time
+            - doexit: Whether to exit from forecasts
+    """
+    try:
+        steps_out, time_out, doexit_out = PDAF.get_fcst_info(steps, time, doexit)
+        return {
+            "success": True,
+            "result": {
+                "steps": int(steps_out),
+                "time": float(time_out),
+                "doexit": int(doexit_out)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_print_filter_types", description="Print available filter types in PDAF")
+def pdaf_print_filter_types(verbose: int = 1) -> dict:
+    """
+    Print all available filter types in PDAF to the console.
+    
+    Args:
+        verbose: Verbosity flag. If 0, no output; if > 0, prints list to stdout.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.print_filter_types(verbose)
+        return {"success": True, "result": "Filter types printed to console", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_print_da_types", description="Print available DA method types in PDAF")
+def pdaf_print_da_types(verbose: int = 1) -> dict:
+    """
+    Print all available data assimilation method types in PDAF to the console.
+    
+    Args:
+        verbose: Verbosity flag. If 0, no output; if > 0, prints list to stdout.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.print_da_types(verbose)
+        return {"success": True, "result": "DA types printed to console", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_print_info", description="Print PDAF configuration and status information")
+def pdaf_print_info(printtype: int) -> dict:
+    """
+    Print PDAF configuration and status information.
+    
+    Args:
+        printtype: Type of information to print
+                   1: Print filter type and settings
+                   2: Print timing information
+                   3: Print memory usage
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.print_info(printtype)
+        return {"success": True, "result": f"Info type {printtype} printed to console", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_reset_forget", description="Reset the forgetting factor in PDAF")
+def pdaf_reset_forget(forget_in: float) -> dict:
+    """
+    Reset the forgetting factor used in ensemble filters.
+    
+    The forgetting factor is used for covariance inflation.
+    A value less than 1.0 inflates the ensemble spread.
+    
+    For local ensemble Kalman filters, the forgetting factor can be set
+    either globally (outside the loop over local domains) or differently
+    for each local analysis domain (within the loop).
+    
+    Args:
+        forget_in: New forgetting factor value
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.reset_forget(forget_in)
+        return {"success": True, "result": f"Forgetting factor reset to {forget_in}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_debug_flag", description="Activate or deactivate PDAF debug output")
+def pdaf_set_debug_flag(debugval: int) -> dict:
+    """
+    Activate or deactivate debug output for PDAF.
+    
+    When activated, debug information is sent to screen output.
+    The output ends when the debug flag is set to 0.
+    
+    Args:
+        debugval: Value for debugging flag (0 to disable, non-zero to enable)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.set_debug_flag(debugval)
+        return {"success": True, "result": f"Debug flag set to {debugval}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_offline_mode", description="Set PDAF to offline mode")
+def pdaf_set_offline_mode(screen: int) -> dict:
+    """
+    Set PDAF to offline mode for offline data assimilation.
+    
+    Args:
+        screen: Screen output level (0 for no output)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.set_offline_mode(screen)
+        return {"success": True, "result": f"Offline mode set with screen={screen}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_assim_flag", description="Get the flag indicating if DA was performed in last time step")
+def pdaf_get_assim_flag() -> dict:
+    """
+    Return the flag that indicates if the DA is performed in the last time step.
+    This only works for online DA systems.
+    
+    Returns:
+        dict: A dictionary containing:
+            - did_assim: 1 for assimilation performed, 0 otherwise
+    """
+    try:
+        did_assim = PDAF.get_assim_flag()
+        return {"success": True, "result": {"did_assim": int(did_assim)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_localfilter", description="Check whether a local filter is used")
+def pdaf_get_localfilter() -> dict:
+    """
+    Return whether a local filter is used.
+    
+    Returns:
+        dict: A dictionary containing:
+            - lfilter: 1 for local filters (domain-localized), 0 for global filters
+    """
+    try:
+        lfilter = PDAF.get_localfilter()
+        return {"success": True, "result": {"lfilter": int(lfilter)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_memberid", description="Get the ensemble member ID on the current process")
+def pdaf_get_memberid(memberid: int = 0) -> dict:
+    """
+    Return the ensemble member ID on the current process.
+    
+    This can be called during ensemble integration if ensemble-specific
+    forcing is read. It can also be used in user-supplied functions.
+    
+    Args:
+        memberid: Input member ID (can be any value)
+    
+    Returns:
+        dict: A dictionary containing:
+            - memberid: Index in the local ensemble
+    """
+    try:
+        result = PDAF.get_memberid(memberid)
+        return {"success": True, "result": {"memberid": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# PDAF Diagnostic Tools
+# ============================================================================
+
+@mcp.tool(name="pdaf_diag_ensmean", description="Compute ensemble mean of state vectors")
+def pdaf_diag_ensmean(dim: int, dim_ens: int, ens: List[List[float]]) -> dict:
+    """
+    Compute the ensemble mean of the state ensemble.
+    
+    Args:
+        dim: State dimension
+        dim_ens: Ensemble size
+        ens: State ensemble (2D list of shape [dim, dim_ens])
+    
+    Returns:
+        dict: A dictionary containing:
+            - state: Ensemble mean (list of length dim)
+            - status: Status flag (0=success)
+    """
+    try:
+        ens_np = np.array(ens, dtype=np.float64)
+        state = np.zeros(dim, dtype=np.float64)
+        
+        state_out, status = PDAF.diag_ensmean(dim, dim_ens, state, ens_np)
+        return {
+            "success": True,
+            "result": {
+                "state": state_out.tolist(),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_effsample", description="Compute effective sample size for particle filter")
+def pdaf_diag_effsample(dim_sample: int, weights: List[float]) -> dict:
+    """
+    Compute effective ensemble size from particle filter weights.
+    
+    This is a diagnostic for particle filters that measures how many
+    particles are effectively contributing to the estimate.
+    
+    Based on Doucet et al. (2001), it is defined as:
+    N_eff = 1 / sum(w_i^2)
+    where w_i is the weight of particle i.
+    
+    If N_eff = N, all weights are identical and the filter has no influence.
+    If N_eff = 0, the filter is collapsed.
+    
+    Args:
+        dim_sample: Sample size (number of particles)
+        weights: Particle weights (list of length dim_sample)
+    
+    Returns:
+        dict: A dictionary containing:
+            - n_eff: Effective sample size
+    """
+    try:
+        weights_np = np.array(weights, dtype=np.float64)
+        n_eff = PDAF.diag_effsample(dim_sample, weights_np)
+        return {"success": True, "result": {"n_eff": float(n_eff)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# PDAFomi Module Tools
+# ============================================================================
+
+@mcp.tool(name="pdafomi_init", description="Initialize PDAFomi with number of observation types")
+def pdafomi_init(n_obs: int) -> dict:
+    """
+    Allocate an array of obs_f derived type instances.
+    
+    This function initializes the number of observation types,
+    which should be called at the start of the DA system after PDAF.init.
+    
+    Args:
+        n_obs: Number of observation types
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.init(n_obs)
+        return {"success": True, "result": f"PDAFomi initialized with {n_obs} observation types", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_init_local", description="Initialize local observation types for local analysis")
+def pdafomi_init_local() -> dict:
+    """
+    Allocate an array of obs_l derived type instances for local analysis.
+    
+    This function initializes the number of observation types for each
+    local analysis domain, which should be called at the start of the
+    local analysis loop.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.init_local()
+        return {"success": True, "result": "PDAFomi local initialized", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_check_error", description="Check PDAFomi internal error flag")
+def pdafomi_check_error(flag: int = 0) -> dict:
+    """
+    Check the value of the PDAF-OMI internal error flag.
+    
+    Since PDAF-OMI executes internal routines in which errors could occur
+    due to inconsistent configuration of observations, this function
+    allows checking for such errors.
+    
+    Args:
+        flag: Error flag input (can be any value)
+    
+    Returns:
+        dict: A dictionary containing:
+            - flag: Error flag value (0 = no error)
+    """
+    try:
+        result = PDAFomi.check_error(flag)
+        return {"success": True, "result": {"flag": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_debug_flag", description="Activate or deactivate PDAFomi debug output")
+def pdafomi_set_debug_flag(debugval: int) -> dict:
+    """
+    Activate or deactivate debug output for PDAFomi.
+    
+    Args:
+        debugval: Value for debugging flag (0 to disable, non-zero to enable)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_debug_flag(debugval)
+        return {"success": True, "result": f"PDAFomi debug flag set to {debugval}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_doassim", description="Set whether to assimilate a given observation type")
+def pdafomi_set_doassim(i_obs: int, doassim: int) -> dict:
+    """
+    Set the doassim attribute for a given observation type.
+    
+    Args:
+        i_obs: Index of observation type
+        doassim: 0) do not assimilate; 1) assimilate the observation type
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_doassim(i_obs, doassim)
+        return {"success": True, "result": f"Observation type {i_obs} doassim set to {doassim}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_disttype", description="Set distance calculation method for observation localization")
+def pdafomi_set_disttype(i_obs: int, disttype: int) -> dict:
+    """
+    Set the observation localization distance calculation method.
+    
+    Args:
+        i_obs: Index of observation type
+        disttype: Type of distance calculation:
+                  0) Cartesian (any units)
+                  1) Cartesian periodic (any units)
+                  2) Geographic distance in metres (lat/lon in radians)
+                  3) Haversine formula for distance on sphere
+                  10) 3D Cartesian with separate horizontal/vertical
+                  11) 3D Cartesian periodic with separate horizontal/vertical
+                  12) Geographic horizontal + user vertical
+                  13) Haversine horizontal + user vertical
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_disttype(i_obs, disttype)
+        return {"success": True, "result": f"Observation type {i_obs} disttype set to {disttype}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_ncoord", description="Set number of spatial dimensions for observations")
+def pdafomi_set_ncoord(i_obs: int, ncoord: int) -> dict:
+    """
+    Set the number of spatial dimensions of observations.
+    
+    Args:
+        i_obs: Index of observation type
+        ncoord: Dimension of the observation coordinate (e.g., 2 for 2D)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_ncoord(i_obs, ncoord)
+        return {"success": True, "result": f"Observation type {i_obs} ncoord set to {ncoord}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_nobstypes", description="Get number of active observation types")
+def pdafomi_diag_nobstypes(nobs: int = 0) -> dict:
+    """
+    Get the number of observation types that are active in an assimilation run.
+    
+    Args:
+        nobs: Number of observation types (input can be arbitrary)
+    
+    Returns:
+        dict: A dictionary containing:
+            - nobs: Number of active observation types
+    """
+    try:
+        result = PDAFomi.diag_nobstypes(nobs)
+        return {"success": True, "result": {"nobs": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_dimobs", description="Get observation dimensions for each observation type")
+def pdafomi_diag_dimobs() -> dict:
+    """
+    Get observation dimension for each observation type.
+    
+    Returns:
+        dict: A dictionary containing:
+            - dim_obs: Observation dimension for each type (list)
+    """
+    try:
+        result = PDAFomi.diag_dimobs()
+        return {"success": True, "result": {"dim_obs": result.tolist()}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# PDAFlocal Module Tools
+# ============================================================================
+
+@mcp.tool(name="pdaflocal_set_indices", description="Set index mapping from local to global state vector")
+def pdaflocal_set_indices(dim_l: int, map_indices: List[int]) -> dict:
+    """
+    Set index vector to map local state vector to global state vectors.
+    
+    This is called in the user-supplied function py__init_dim_l_pdaf.
+    Each element of map is an index of the global state vector (1-based).
+    
+    E.g., map[0] = 2 means that the first element of local state vector
+    is the 2nd element of the global state vector.
+    
+    Args:
+        dim_l: Dimension of local state vector
+        map_indices: Index array for mapping between local and global state vector
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        map_np = np.array(map_indices, dtype=np.int32)
+        PDAFlocal.set_indices(dim_l, map_np)
+        return {"success": True, "result": f"Local indices set for dim_l={dim_l}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaflocal_set_increment_weights", description="Set local increment weights for vertical localization")
+def pdaflocal_set_increment_weights(dim_l: int, weights: List[float]) -> dict:
+    """
+    Initialize a PDAF-internal local array of increment weights.
+    
+    The weights are applied where the local state vector is weighted.
+    These can be used to apply vertical localization or implement
+    weakly-coupled assimilation.
+    
+    Args:
+        dim_l: Dimension of local state vector
+        weights: Weights array (list of length dim_l)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        weights_np = np.array(weights, dtype=np.float64)
+        PDAFlocal.set_increment_weights(dim_l, weights_np)
+        return {"success": True, "result": f"Increment weights set for dim_l={dim_l}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaflocal_clear_increment_weights", description="Deallocate local increment weight vector")
+def pdaflocal_clear_increment_weights() -> dict:
+    """
+    Deallocate the local increment weight vector set by set_increment_weights.
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFlocal.clear_increment_weights()
+        return {"success": True, "result": "Increment weights cleared", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# Additional PDAF Diagnostic Tools
+# ============================================================================
+
+@mcp.tool(name="pdaf_diag_stddev_nompi", description="Compute ensemble standard deviation without MPI")
+def pdaf_diag_stddev_nompi(
+    dim: int,
+    dim_ens: int,
+    ens: List[List[float]],
+    do_mean: int
+) -> dict:
+    """
+    Compute ensemble standard deviation and ensemble mean without MPI.
+    
+    Args:
+        dim: State dimension
+        dim_ens: Ensemble size
+        ens: State ensemble (2D list of shape [dim, dim_ens])
+        do_mean: Whether to compute ensemble mean (1=yes, 0=no)
+    
+    Returns:
+        dict: A dictionary containing:
+            - state: State vector (ensemble mean if do_mean=1)
+            - stddev: Standard deviation of ensemble
+            - status: Status flag (0=success)
+    """
+    try:
+        ens_np = np.array(ens, dtype=np.float64)
+        state = np.zeros(dim, dtype=np.float64)
+        
+        state_out, stddev, status = PDAF.diag_stddev_nompi(dim, dim_ens, state, ens_np, do_mean)
+        return {
+            "success": True,
+            "result": {
+                "state": state_out.tolist(),
+                "stddev": float(stddev),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_variance_nompi", description="Compute ensemble variance without MPI")
+def pdaf_diag_variance_nompi(
+    dim: int,
+    dim_ens: int,
+    ens: List[List[float]],
+    do_mean: int,
+    do_stddev: int
+) -> dict:
+    """
+    Compute ensemble variance/standard deviation and mean without MPI.
+    
+    Args:
+        dim: State dimension
+        dim_ens: Ensemble size
+        ens: State ensemble (2D list of shape [dim, dim_ens])
+        do_mean: Whether to compute ensemble mean (1=yes, 0=no)
+        do_stddev: Whether to compute the ensemble mean standard deviation (1=yes, 0=no)
+    
+    Returns:
+        dict: A dictionary containing:
+            - state: State vector (ensemble mean if do_mean=1)
+            - variance: Variance state vector
+            - stddev: Standard deviation of ensemble
+            - status: Status flag (0=success)
+    """
+    try:
+        ens_np = np.array(ens, dtype=np.float64)
+        state = np.zeros(dim, dtype=np.float64)
+        
+        state_out, variance, stddev, status = PDAF.diag_variance_nompi(
+            dim, dim_ens, state, ens_np, do_mean, do_stddev
+        )
+        return {
+            "success": True,
+            "result": {
+                "state": state_out.tolist(),
+                "variance": variance.tolist(),
+                "stddev": float(stddev),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_rmsd_nompi", description="Compute RMSD between two vectors without MPI")
+def pdaf_diag_rmsd_nompi(
+    dim_p: int,
+    statea_p: List[float],
+    stateb_p: List[float]
+) -> dict:
+    """
+    Compute the root mean squared distance between two vectors without MPI.
+    
+    Args:
+        dim_p: State dimension
+        statea_p: State vector A (list of length dim_p)
+        stateb_p: State vector B (list of length dim_p)
+    
+    Returns:
+        dict: A dictionary containing:
+            - rmsd_p: Root mean squared distance
+            - status: Status flag (0=success)
+    """
+    try:
+        statea_np = np.array(statea_p, dtype=np.float64)
+        stateb_np = np.array(stateb_p, dtype=np.float64)
+        
+        rmsd_p, status = PDAF.diag_rmsd_nompi(dim_p, statea_np, stateb_np)
+        return {
+            "success": True,
+            "result": {
+                "rmsd_p": float(rmsd_p),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_ensstats", description="Compute ensemble skewness and kurtosis")
+def pdaf_diag_ensstats(
+    dim: int,
+    dim_ens: int,
+    element: int,
+    ens: List[List[float]]
+) -> dict:
+    """
+    Compute the skewness and kurtosis of the ensemble for a given state vector element.
+    
+    The definition used for kurtosis follows Lawson & Hansen (2004).
+    
+    Args:
+        dim: PE-local state dimension
+        dim_ens: Ensemble size
+        element: ID of element to be used
+        ens: State ensemble (2D list of shape [dim, dim_ens])
+    
+    Returns:
+        dict: A dictionary containing:
+            - skewness: Skewness of ensemble
+            - kurtosis: Kurtosis of ensemble
+            - status: Status flag (0=success)
+    """
+    try:
+        ens_np = np.array(ens, dtype=np.float64)
+        state = np.zeros(dim, dtype=np.float64)
+        
+        skewness, kurtosis, status = PDAF.diag_ensstats(dim, dim_ens, element, state, ens_np)
+        return {
+            "success": True,
+            "result": {
+                "skewness": float(skewness),
+                "kurtosis": float(kurtosis),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_sample_ens", description="Generate ensemble from EOF modes and singular values")
+def pdaf_sample_ens(
+    dim: int,
+    dim_ens: int,
+    modes: List[List[float]],
+    svals: List[float],
+    state: List[float],
+    verbose: int,
+    flag: int = 0
+) -> dict:
+    """
+    Generate an ensemble from singular values and their vectors (EOF modes).
+    
+    The singular values and vectors are derived from ensemble anomalies.
+    This ensemble anomaly can be obtained from a time anomaly of a model
+    trajectory using PDAF.eofcovar.
+    
+    Args:
+        dim: Size of the state vector
+        dim_ens: Ensemble size
+        modes: Array of EOF modes/matrix of singular vectors (shape [dim, dim_ens-1])
+        svals: Singular values (list of length dim_ens-1)
+        state: PE-local model mean state (list of length dim)
+        verbose: Verbosity flag
+        flag: Status flag input
+    
+    Returns:
+        dict: A dictionary containing:
+            - modes: Updated EOF modes
+            - state: Updated mean state
+            - ens: Generated state ensemble (shape [dim, dim_ens])
+            - flag: Status flag
+    """
+    try:
+        modes_np = np.array(modes, dtype=np.float64)
+        svals_np = np.array(svals, dtype=np.float64)
+        state_np = np.array(state, dtype=np.float64)
+        
+        modes_out, state_out, ens, flag_out = PDAF.sample_ens(
+            dim, dim_ens, modes_np, svals_np, state_np, verbose, flag
+        )
+        return {
+            "success": True,
+            "result": {
+                "modes": modes_out.tolist(),
+                "state": state_out.tolist(),
+                "ens": ens.tolist(),
+                "flag": int(flag_out)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_local_weight", description="Compute localization weight for a given distance")
+def pdaf_local_weight(
+    wtype: int,
+    rtype: int,
+    cradius: float,
+    sradius: float,
+    distance: float,
+    nrows: int,
+    ncols: int,
+    a: List[List[float]],
+    var_obs: float,
+    verbose: int
+) -> dict:
+    """
+    Get localization weight for given distance, cut-off radius, support radius,
+    weighting type, and weighting function.
+    
+    Args:
+        wtype: Type of weight function:
+               0: unit weight (weight=1 up to distance=cradius)
+               1: exponential decrease (weight=1/e at distance=sradius)
+               2: 5th order polynomial (Gaspari and Cohn 1999)
+        rtype: Type of regulated weighting:
+               !=1: no regulation
+               1: regulated by variance of matrix A and observation variance
+        cradius: Cut-off radius where weight=0 beyond it
+        sradius: Support radius of localization function
+        distance: Distance to observation
+        nrows: Number of rows in matrix A
+        ncols: Number of columns in matrix A
+        a: Ensemble perturbation/anomaly matrix (shape [nrows, ncols])
+        var_obs: Observation variance
+        verbose: Verbosity flag
+    
+    Returns:
+        dict: A dictionary containing:
+            - weight: Localization weight
+    """
+    try:
+        a_np = np.array(a, dtype=np.float64)
+        
+        weight = PDAF.local_weight(
+            wtype, rtype, cradius, sradius, distance,
+            nrows, ncols, a_np, var_obs, verbose
+        )
+        return {"success": True, "result": {"weight": float(weight)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_local_type", description="Get the localization type of the selected filter")
+def pdaf_get_local_type() -> dict:
+    """
+    Return the information on the localization type of the selected filter.
+    
+    Returns:
+        dict: A dictionary containing:
+            - localtype: Localization type
+                0: no localization; global filter
+                1: domain localization (LESTKF, LETKF, LNETF, LSEIK)
+                2: covariance localization (LEnKF)
+                3: covariance loc. but observation handling like domain localization (ENSRF)
+    """
+    try:
+        localtype = PDAF.get_local_type()
+        return {"success": True, "result": {"localtype": int(localtype)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_ens_pointer", description="Get a numpy array view of the internal ensemble array")
+def pdaf_set_ens_pointer() -> dict:
+    """
+    Return the ensemble in a numpy array with the same memory address as
+    PDAF's internal ensemble array, allowing for manual ensemble modification.
+    
+    Returns:
+        dict: A dictionary containing:
+            - ens_shape: Shape of the ensemble array [dim, dim_ens]
+            - status: Status flag
+    """
+    try:
+        ens_ptr, status = PDAF.set_ens_pointer()
+        return {
+            "success": True,
+            "result": {
+                "ens_shape": list(ens_ptr.shape),
+                "ens": ens_ptr.tolist(),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# Additional PDAFomi Tools
+# ============================================================================
+
+@mcp.tool(name="pdafomi_set_obs_err_type", description="Set observation error distribution type")
+def pdafomi_set_obs_err_type(i_obs: int, obs_err_type: int) -> dict:
+    """
+    Set the type of observation error distribution for a given observation type.
+    
+    Args:
+        i_obs: Index of observation type
+        obs_err_type: Type of observation error distribution:
+                      0: Gaussian (default)
+                      1: double exponential (Laplacian)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_obs_err_type(i_obs, obs_err_type)
+        return {"success": True, "result": f"Observation type {i_obs} error type set to {obs_err_type}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_use_global_obs", description="Set whether to use global or process-local observations")
+def pdafomi_set_use_global_obs(i_obs: int, use_global_obs: int) -> dict:
+    """
+    Set switch for using process-local or global observations.
+    
+    By default (use_global_obs=1), PDAF-OMI gathers the entire observation
+    vector for all processes. Setting use_global_obs=0 uses only process-local
+    observations, which can save computational cost.
+    
+    Args:
+        i_obs: Index of observation type
+        use_global_obs: 0: Using process-local observations
+                        1: Using cross-process observations (default)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_use_global_obs(i_obs, use_global_obs)
+        return {"success": True, "result": f"Observation type {i_obs} use_global_obs set to {use_global_obs}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_obs_rmsd", description="Compute RMSD between observations and observed model state")
+def pdafomi_diag_obs_rmsd(nobs: int, verbose: int) -> dict:
+    """
+    Compute root mean squared distance between observations and observed
+    model state for each observation type.
+    
+    Args:
+        nobs: Number of observation types
+        verbose: Verbosity flag
+    
+    Returns:
+        dict: A dictionary containing:
+            - nobs: Number of observation types
+            - rmsd: Vector of RMSD values for each observation type
+    """
+    try:
+        nobs_out, rmsd = PDAFomi.diag_obs_rmsd(nobs, verbose)
+        return {
+            "success": True,
+            "result": {
+                "nobs": int(nobs_out),
+                "rmsd": rmsd.tolist()
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_stats", description="Compute statistics comparing observations and observed ensemble mean")
+def pdafomi_diag_stats(nobs: int, verbose: int) -> dict:
+    """
+    Compute a selection of 6 statistics comparing observations and
+    observed ensemble mean for each observation type.
+    
+    Statistics include:
+    - (1,:) correlations between observation and observed ensemble mean
+    - (2,:) centered RMS difference
+    - (3,:) mean bias (observation minus observed ensemble mean)
+    - (4,:) mean absolute difference
+    - (5,:) variance of observations
+    - (6,:) variance of observed ensemble mean
+    
+    Args:
+        nobs: Number of observation types
+        verbose: Verbosity flag
+    
+    Returns:
+        dict: A dictionary containing:
+            - nobs: Number of observation types
+            - obsstats: Array of observation statistics (shape [6, nobs])
+    """
+    try:
+        nobs_out, obsstats = PDAFomi.diag_stats(nobs, verbose)
+        return {
+            "success": True,
+            "result": {
+                "nobs": int(nobs_out),
+                "obsstats": obsstats.tolist()
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# Additional PDAF Setter Functions (不需要回调和MPI)
+# ============================================================================
+
+@mcp.tool(name="pdaf_set_comm_pdaf", description="Set the MPI communicator used by PDAF")
+def pdaf_set_comm_pdaf(in_comm_pdaf: int) -> dict:
+    """
+    Set the MPI communicator used by PDAF.
+    
+    By default, PDAF assumes it can use all available processes (MPI_COMM_WORLD).
+    By using this function, we limit the number of processes that can be used
+    by PDAF to the given MPI communicator.
+    
+    Args:
+        in_comm_pdaf: MPI communicator for PDAF (integer handle)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.set_comm_pdaf(in_comm_pdaf)
+        return {"success": True, "result": f"PDAF communicator set to {in_comm_pdaf}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_iparam", description="Set integer parameters for PDAF")
+def pdaf_set_iparam(idval: int, value: int, flag: int = 0) -> dict:
+    """
+    Set integer parameters for PDAF.
+    
+    This function provides an alternative way to set integer parameters
+    instead of providing all parameters in the call to PDAF.init.
+    
+    Args:
+        idval: Index of parameter
+        value: Parameter value
+        flag: Status flag input (default 0)
+    
+    Returns:
+        dict: A dictionary containing:
+            - flag: Status flag (0 for no error)
+    """
+    try:
+        result = PDAF.set_iparam(idval, value, flag)
+        return {"success": True, "result": {"flag": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_rparam", description="Set floating-point parameters for PDAF")
+def pdaf_set_rparam(idval: int, value: float, flag: int = 0) -> dict:
+    """
+    Set floating-point parameters for PDAF.
+    
+    This function provides an alternative way to set real parameters
+    instead of providing all parameters in the call to PDAF.init.
+    
+    Args:
+        idval: Index of parameter
+        value: Parameter value (float)
+        flag: Status flag input (default 0)
+    
+    Returns:
+        dict: A dictionary containing:
+            - flag: Status flag (0 for no error)
+    """
+    try:
+        result = PDAF.set_rparam(idval, value, flag)
+        return {"success": True, "result": {"flag": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_memberid", description="Set the ensemble member index to a given value")
+def pdaf_set_memberid(memberid: int) -> dict:
+    """
+    Set the ensemble member index to a given value.
+    
+    Args:
+        memberid: Index in the local ensemble
+    
+    Returns:
+        dict: A dictionary containing:
+            - memberid: The set member index
+    """
+    try:
+        result = PDAF.set_memberid(memberid)
+        return {"success": True, "result": {"memberid": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_set_seedset", description="Choose a seedset for the random number generator")
+def pdaf_set_seedset(seedset_in: int) -> dict:
+    """
+    Choose a seedset for the random number generator used in PDAF.
+    
+    Args:
+        seedset_in: Seedset index (1-20)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAF.set_seedset(seedset_in)
+        return {"success": True, "result": f"Seedset set to {seedset_in}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_get_obsmemberid", description="Get ensemble member ID when observation operator is applied")
+def pdaf_get_obsmemberid(memberid: int = 0) -> dict:
+    """
+    Return the ensemble member ID when observation operator is being applied.
+    
+    This function is used specifically for user-supplied function py__obs_op_pdaf.
+    
+    Args:
+        memberid: Input member ID (can be any value)
+    
+    Returns:
+        dict: A dictionary containing:
+            - memberid: Index in the local ensemble
+    """
+    try:
+        result = PDAF.get_obsmemberid(memberid)
+        return {"success": True, "result": {"memberid": int(result)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_local_weights", description="Get a vector of localization weights for given distances")
+def pdaf_local_weights(
+    wtype: int,
+    cradius: float,
+    sradius: float,
+    dim: int,
+    distance: List[float],
+    verbose: int
+) -> dict:
+    """
+    Get a vector of localization weights for given distances.
+    
+    This is a vectorized version of pdaf_local_weight without regulation.
+    
+    Args:
+        wtype: Type of weight function:
+               0: unit weight (weight=1 up to distance=cradius)
+               1: exponential decrease (weight=1/e at distance=sradius)
+               2: 5th order polynomial (Gaspari and Cohn 1999)
+        cradius: Cut-off radius where weight=0 beyond it
+        sradius: Support radius of localization function
+        dim: Size of distance and weight arrays
+        distance: Array of distances to observations (list of length dim)
+        verbose: Verbosity flag
+    
+    Returns:
+        dict: A dictionary containing:
+            - weights: Array of localization weights (list of length dim)
+    """
+    try:
+        distance_np = np.array(distance, dtype=np.float64)
+        weights = PDAF.local_weights(wtype, cradius, sradius, dim, distance_np, verbose)
+        return {"success": True, "result": {"weights": weights.tolist()}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_crps_nompi", description="Compute Continuous Ranked Probability Score without MPI")
+def pdaf_diag_crps_nompi(
+    dim: int,
+    dim_ens: int,
+    element: int,
+    oens: List[List[float]],
+    obs: List[float]
+) -> dict:
+    """
+    Obtain a Continuous Ranked Probability Score (CRPS) for an ensemble without MPI.
+    
+    Based on Hersbach (2000) decomposition of CRPS.
+    
+    Args:
+        dim: Dimension of state vector
+        dim_ens: Ensemble size
+        element: ID of element to be used (0 for mean over all elements)
+        oens: State ensemble (2D list of shape [dim, dim_ens])
+        obs: Observation/true state (list of length dim)
+    
+    Returns:
+        dict: A dictionary containing:
+            - CRPS: Continuous Ranked Probability Score
+            - reli: Reliability
+            - resol: Resolution
+            - uncert: Uncertainty
+            - status: Status flag (0=success)
+    """
+    try:
+        oens_np = np.array(oens, dtype=np.float64)
+        obs_np = np.array(obs, dtype=np.float64)
+        
+        crps, reli, resol, uncert, status = PDAF.diag_crps_nompi(
+            dim, dim_ens, element, oens_np, obs_np
+        )
+        return {
+            "success": True,
+            "result": {
+                "CRPS": float(crps),
+                "reli": float(reli),
+                "resol": float(resol),
+                "uncert": float(uncert),
+                "status": int(status)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_diag_compute_moments", description="Compute statistical moments from an ensemble")
+def pdaf_diag_compute_moments(
+    dim_p: int,
+    dim_ens: int,
+    ens: List[List[float]],
+    kmax: int,
+    bias: int
+) -> dict:
+    """
+    Compute the mean, variance, skewness, and excess kurtosis from an ensemble.
+    
+    Args:
+        dim_p: PE-local state dimension
+        dim_ens: Ensemble size
+        ens: State ensemble (2D list of shape [dim_p, dim_ens])
+        kmax: Maximum moment to compute (1=mean, 2=variance, 3=skewness, 4=kurtosis)
+        bias: 0 for unbiased estimates, 1 for biased estimates
+    
+    Returns:
+        dict: A dictionary containing:
+            - moments: Array of moments (shape [kmax, dim_p])
+    """
+    try:
+        ens_np = np.array(ens, dtype=np.float64)
+        moments = PDAF.diag_compute_moments(dim_p, dim_ens, ens_np, kmax, bias)
+        return {"success": True, "result": {"moments": moments.tolist()}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# Additional PDAFomi Setter Functions
+# ============================================================================
+
+@mcp.tool(name="pdafomi_set_inno_omit", description="Set innovation threshold for removing observation outliers")
+def pdafomi_set_inno_omit(i_obs: int, inno_omit: float) -> dict:
+    """
+    Set innovation threshold for removing observation outliers.
+    
+    By default, no observations are omitted. Observation omission is only
+    activated when inno_omit > 0.0. PDAF will omit observations where
+    the squared innovation of the ensemble mean is larger than the product
+    of inno_omit and observation error variance.
+    
+    Args:
+        i_obs: Index of observation type
+        inno_omit: Threshold of innovation to be omitted
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_inno_omit(i_obs, inno_omit)
+        return {"success": True, "result": f"Observation type {i_obs} inno_omit set to {inno_omit}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_inno_omit_ivar", description="Set inverse variance for omitted observations")
+def pdafomi_set_inno_omit_ivar(i_obs: int, inno_omit_ivar: float) -> dict:
+    """
+    Set the inverse of observation error variance for omitted observations.
+    
+    This should be set to a very small value relative to assimilated observations.
+    By default, it is set to 1e-12.
+    
+    Args:
+        i_obs: Index of observation type
+        inno_omit_ivar: Inverse of observation variance for omitted observations
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_inno_omit_ivar(i_obs, inno_omit_ivar)
+        return {"success": True, "result": f"Observation type {i_obs} inno_omit_ivar set to {inno_omit_ivar}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_domainsize", description="Set domain size for observation type")
+def pdafomi_set_domainsize(i_obs: int, domainsize: List[float]) -> dict:
+    """
+    Set the domain size for periodic boundary conditions.
+    
+    This is used when disttype is set to periodic distance calculation.
+    
+    Args:
+        i_obs: Index of observation type
+        domainsize: Domain size array (list of floats)
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        domainsize_np = np.array(domainsize, dtype=np.float64)
+        PDAFomi.set_domainsize(i_obs, domainsize_np)
+        return {"success": True, "result": f"Observation type {i_obs} domainsize set", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_set_name", description="Set the name of an observation type")
+def pdafomi_set_name(i_obs: int, name: str) -> dict:
+    """
+    Set the name identifier for an observation type.
+    
+    This name is used in diagnostic output to identify the observation type.
+    
+    Args:
+        i_obs: Index of observation type
+        name: Name string for the observation type
+    
+    Returns:
+        dict: A dictionary containing the success status.
+    """
+    try:
+        PDAFomi.set_name(i_obs, name)
+        return {"success": True, "result": f"Observation type {i_obs} name set to '{name}'", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_get_obs", description="Get observation vector and coordinates for an observation type")
+def pdafomi_diag_get_obs(id_obs: int) -> dict:
+    """
+    Get observation vector and corresponding coordinates for specified observation type.
+    
+    Args:
+        id_obs: Index of observation type to return
+    
+    Returns:
+        dict: A dictionary containing:
+            - dim_obs_diag: Observation dimension
+            - ncoord: Number of observation dimensions
+            - obs_p: Observation vector
+            - ocoord_p: Coordinate array
+    """
+    try:
+        dim_obs_diag, ncoord, obs_p, ocoord_p = PDAFomi.diag_get_obs(id_obs)
+        return {
+            "success": True,
+            "result": {
+                "dim_obs_diag": int(dim_obs_diag),
+                "ncoord": int(ncoord),
+                "obs_p": obs_p.tolist(),
+                "ocoord_p": ocoord_p.tolist()
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_get_hxmean", description="Get observed ensemble mean for an observation type")
+def pdafomi_diag_get_hxmean(id_obs: int) -> dict:
+    """
+    Get observed ensemble mean for a given observation type.
+    
+    Args:
+        id_obs: Index of observation type to return
+    
+    Returns:
+        dict: A dictionary containing:
+            - dim_obs_diag: Observation dimension
+            - hxmean_p: Observed ensemble mean
+    """
+    try:
+        dim_obs_diag, hxmean_p = PDAFomi.diag_get_hxmean(id_obs)
+        return {
+            "success": True,
+            "result": {
+                "dim_obs_diag": int(dim_obs_diag),
+                "hxmean_p": hxmean_p.tolist()
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdafomi_diag_get_ivar", description="Get inverse observation error variance for an observation type")
+def pdafomi_diag_get_ivar(id_obs: int) -> dict:
+    """
+    Get inverse of observation error variance for a given observation type.
+    
+    Args:
+        id_obs: Index of observation type to return
+    
+    Returns:
+        dict: A dictionary containing:
+            - dim_obs_diag: Observation dimension
+            - ivar: Inverse observation error variances
+    """
+    try:
+        dim_obs_diag, ivar = PDAFomi.diag_get_ivar(id_obs)
+        return {
+            "success": True,
+            "result": {
+                "dim_obs_diag": int(dim_obs_diag),
+                "ivar": ivar.tolist()
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# ============================================================================
+# Utility Functions
+# ============================================================================
+
+@mcp.tool(name="get_pdaf_module_info", description="Get information about available pyPDAF modules and their functions")
+def get_pdaf_module_info() -> dict:
+    """
+    Get information about available pyPDAF modules and their main functions.
+    
+    Returns:
+        dict: A dictionary containing module information.
+    """
+    try:
+        info = {
+            "PDAF": {
+                "description": "Core PDAF module with filter functions and utilities",
+                "main_functions": [
+                    "correlation_function", "deallocate", "eofcovar", "force_analysis",
+                    "get_fcst_info", "print_filter_types", "print_da_types", "print_info",
+                    "reset_forget", "set_debug_flag", "set_offline_mode", "sample_ens",
+                    "local_weight", "local_weights", "set_ens_pointer",
+                    "get_assim_flag", "get_localfilter", "get_local_type", "get_memberid",
+                    "diag_ensmean", "diag_stddev_nompi", "diag_stddev",
+                    "diag_variance_nompi", "diag_variance",
+                    "diag_rmsd_nompi", "diag_rmsd",
+                    "diag_effsample", "diag_ensstats", "diag_compute_moments"
+                ]
+            },
+            "PDAF3": {
+                "description": "PDAF3 module with initialization and assimilation functions",
+                "main_functions": [
+                    "init", "init_forecast", "set_parallel",
+                    "assimilate", "assim_offline",
+                    "assimilate_3dvar_all", "assim_offline_3dvar_all",
+                    "assimilate_local_nondiagr", "assimilate_global_nondiagr",
+                    "generate_obs", "generate_obs_offline"
+                ]
+            },
+            "PDAFomi": {
+                "description": "PDAF Observation Module Interface for flexible observation handling",
+                "main_functions": [
+                    "init", "init_local", "check_error", "gather_obs",
+                    "set_debug_flag", "set_doassim", "set_disttype", "set_ncoord",
+                    "set_obs_err_type", "set_use_global_obs",
+                    "set_inno_omit", "set_inno_omit_ivar",
+                    "diag_nobstypes", "diag_dimobs", "diag_obs_rmsd", "diag_stats",
+                    "diag_get_hx", "diag_get_hxmean", "diag_get_obs"
+                ]
+            },
+            "PDAFlocal": {
+                "description": "PDAF local analysis module for domain localization",
+                "main_functions": [
+                    "set_indices", "set_increment_weights", "clear_increment_weights"
+                ]
+            },
+            "PDAFlocalomi": {
+                "description": "PDAF local analysis with OMI observation handling",
+                "main_functions": []
+            }
+        }
+        return {"success": True, "result": info, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+def create_app() -> FastMCP:
+    """
+    Creates and returns the FastMCP application instance.
+    
+    Returns:
+        FastMCP: The FastMCP application instance.
+    """
+    return mcp

pyPDAF/mcp_output/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp>=0.1.0
+pydantic>=2.0.0

pyPDAF/mcp_output/simple_revise_error_analysis.json

@@ -0,0 +1,6 @@
+{
+  "status": "FAIL",
+  "next_action": "fix_directly",
+  "confidence": 0.9,
+  "summary": "The error is due to a missing Python module 'mpi4py'. This can be fixed directly by installing the missing module. Use the command 'conda install mpi4py' or 'pip install mpi4py' within the appropriate conda environment to resolve the issue. Ensure that the environment where the script is being executed has access to the 'mpi4py' module."
+}

pyPDAF/mcp_output/start_mcp.py

@@ -0,0 +1,33 @@
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+# Set path to source directory
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "source", "src")
+sys.path.insert(0, source_path)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

pyPDAF/mcp_output/tests_mcp/test_mcp_basic.py

@@ -0,0 +1,49 @@
+"""
+MCP Service Basic Test
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+def test_import_mcp_service():
+    """Test if MCP service can be imported normally"""
+    try:
+        from mcp_service import create_app
+        app = create_app()
+        assert app is not None
+        print("MCP service imported successfully")
+        return True
+    except Exception as e:
+        print("MCP service import failed: " + str(e))
+        return False
+
+def test_adapter_init():
+    """Test if adapter can be initialized normally"""
+    try:
+        from adapter import Adapter
+        adapter = Adapter()
+        assert adapter is not None
+        print("Adapter initialized successfully")
+        return True
+    except Exception as e:
+        print("Adapter initialization failed: " + str(e))
+        return False
+
+if __name__ == "__main__":
+    print("Running MCP service basic test...")
+    test1 = test_import_mcp_service()
+    test2 = test_adapter_init()
+    
+    if test1 and test2:
+        print("All basic tests passed")
+        sys.exit(0)
+    else:
+        print("Some tests failed")
+        sys.exit(1)

pyPDAF/mcp_output/tests_smoke/test_smoke.py

@@ -0,0 +1,29 @@
+import importlib, sys
+import os
+
+# Add current directory to Python path
+sys.path.insert(0, os.getcwd())
+
+source_dir = os.path.join(os.getcwd(), "source")
+if os.path.exists(source_dir):
+    sys.path.insert(0, source_dir)
+
+
+try:
+    importlib.import_module("src.pyPDAF")
+    print("OK - Successfully imported src.pyPDAF")
+except ImportError as e:
+    print(f"Failed to import src.pyPDAF: {e}")
+    fallback_packages = []
+
+    fallback_packages = ['pyPDAF', 'src.pyPDAF']
+
+    for pkg in fallback_packages:
+        try:
+            importlib.import_module(pkg)
+            print(f"OK - Successfully imported {pkg}")
+            break
+        except ImportError:
+            continue
+    else:
+        print("All import attempts failed")

pyPDAF/source/.github/workflows/conda_build_linux.yaml

@@ -0,0 +1,31 @@
+name: conda_build_linux
+on: [workflow_dispatch]
+jobs:
+  upload_conda_linux:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-activate-base: true
+          auto-update-conda: true
+          activate-environment: ""
+
+      - name: install pyPDAF
+        shell: bash -el {0}
+        run: |
+          conda install python anaconda-client conda-build conda-verify
+          anaconda logout --at anaconda.org
+          anaconda login  --at anaconda.org --hostname "$GITHUB_RUN_ID-$GITHUB_RUN_NUMBER" --username yumengch --password ${{ secrets.ANACONDA }}
+          conda  config --set anaconda_upload yes
+          conda-build -c conda-forge conda.recipe/
+          conda install -y -c conda-forge --use-local pypdaf
+          cd example
+          mpiexec -n 4 python -u online/main.py
+
+      - name: Setup tmate session
+        if: ${{ failure() }}
+        uses: mxschmitt/action-tmate@v3

pyPDAF/source/.github/workflows/conda_build_mac_intel.yaml

@@ -0,0 +1,34 @@
+name: conda_build_mac_intel
+on: [workflow_dispatch]
+jobs:
+  upload_conda_mac_intel:
+    runs-on: macos-15-intel
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-activate-base: true
+          auto-update-conda: true
+          activate-environment: ""
+
+      - name: build pyPDAF
+        shell: bash -el {0}
+        run: |
+          conda install python anaconda-client conda-build conda-verify
+          anaconda login  --at anaconda.org --username yumengch --password ${{ secrets.ANACONDA }}
+          conda  config --set anaconda_upload yes
+          conda-build -c conda-forge conda.recipe/
+
+      - name: install pyPDAF
+        shell: bash -el {0}
+        run: |
+          conda install -y -c conda-forge --use-local pypdaf
+          cd example
+          mpiexec -n 4 python -u online/main.py
+
+      - name: Setup tmate session
+        if: ${{ failure() }}
+        uses: mxschmitt/action-tmate@v3

pyPDAF/source/.github/workflows/conda_build_mac_m1.yaml

@@ -0,0 +1,34 @@
+name: conda_build_mac_m1
+on: [workflow_dispatch]
+jobs:
+  upload_conda_mac_m1:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-activate-base: true
+          auto-update-conda: true
+          activate-environment: ""
+
+      - name: build pyPDAF
+        shell: bash -el {0}
+        run: |
+          conda install python anaconda-client conda-build conda-verify
+          anaconda login  --at anaconda.org --username yumengch --password ${{ secrets.ANACONDA }}
+          conda  config --set anaconda_upload yes
+          conda-build -c conda-forge conda.recipe/
+
+      - name: install pyPDAF
+        shell: bash -el {0}
+        run: |
+          conda install -y -c conda-forge --use-local pypdaf
+          cd example
+          mpiexec -n 4 python -u online/main.py
+
+      - name: Setup tmate session
+        if: ${{ failure() }}
+        uses: mxschmitt/action-tmate@v3

pyPDAF/source/.github/workflows/conda_build_win.yaml

@@ -0,0 +1,45 @@
+name: conda_build_win
+on: [workflow_dispatch]
+jobs:
+  upload_conda_win:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-activate-base: true
+          activate-environment: ""
+
+      - name: setup anaconda
+        shell: cmd /C CALL {0}
+        run: |
+          conda install -n base python anaconda-client conda-build conda-verify
+
+
+      - name: anaconda login
+        shell: cmd /C CALL {0}
+        run: |
+          call conda activate base
+          anaconda login  --at anaconda.org  --hostname "$GITHUB_RUN_ID-$GITHUB_RUN_NUMBER" --username yumengch --password ${{ secrets.ANACONDA }}
+
+      - name: set anaconda upload
+        shell: cmd /C CALL {0}
+        run: |
+          call conda activate base
+          conda  config --set anaconda_upload yes
+
+      - name: build pyPDAF
+        shell: cmd /C CALL {0}
+        run: |
+          call conda activate base
+          conda build -c conda-forge conda.recipe/
+          conda install -y -c conda-forge --use-local pypdaf
+          cd example
+          mpiexec -n 4 python -u online/main.py
+
+      - name: Setup tmate session
+        if: ${{ failure() }}
+        uses: mxschmitt/action-tmate@v3

pyPDAF/source/.gitignore

@@ -0,0 +1,138 @@
+# 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/
+
+*.o
+*.mod
+*.pyc
+*.npz
+*.a
+*.c
+docs/build/
+docs/source/_autosummary

pyPDAF/source/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "PDAF"]
+	branch = PDAF_V3.0
+	path = PDAF
+	url = https://github.com/PDAF/PDAF.git

pyPDAF/source/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

pyPDAF/source/README.md

@@ -0,0 +1,94 @@
+# pyPDAF - A Python interface to the Fortran-written data assimilation library
+
+pyPDAF provides a Python interface to the established
+[Parallel Data Assimilation Framework (PDAF)](https://pdaf.awi.de/trac/wiki).
+The original framework is used with various regional and global
+climate models including atmosphere, ocean, hydrology, land surface
+and sea ice models. These models are typically written in Fortran
+which can be easily used with PDAF. pyPDAF can become useful
+in the following scenarios:
+- With an increasing number of Python-coded numerical models,
+  especially machine learning models, pyPDAF is a convenient tool
+  to implement data assimilation (DA) systems purely in Python.
+- Alternatively, pyPDAF can be used to set up offline
+  data assimilation system. In such a system, the model fields in
+  restart files are replaced by analyses generated by pyPDAF.
+  This can be an attractive alternative to the original Fortran
+  implementations considering the simplicity of code implementation
+  and package management in Python.
+
+The interface inherits the efficiency of the data assimilation
+algorithms in Fortran, and the flexibility to be applied to different
+models and observations. This means that users of pyPDAF can couple
+the DA algorithms with any types of model and observations without
+the need to coding the actual DA algorithms. This allows the users
+to focus on the specific research problems. The framework includes
+various ensemble DA algorithms including many variants of ensemble
+Kalman filters, particle filters and other non-linear filters.
+It also provides framework for variants of 3DVar. A full list of
+supported methods can be found
+[here](https://pdaf.awi.de/trac/wiki/AvailableOptionsforInitPDAF)
+
+## Getting Started
+It is recommended to install pyPDAF via `conda`:
+```bash
+conda create -n pypdaf -c conda-forge yumengch::pypdaf
+```
+You can also install from the source code using `pip` and `meson`. One can
+find the information in .
+
+## Building a DA system with pyPDAF
+To construct a data assimilation system, only 7 pyPDAF functions are necessary:
+### Initialise PDAF
+  - pyPDAF.set_parallel - one can omit it without parallelisation
+  - pyPDAF.init
+  - pyPDAF.PDAFomi.init
+  - pyPDAF.PDAFomi.init_local - only used in domain localisation
+  - pyPDAF.PDAFomi.set_domain_limits - only used in domain localisation
+  - pyPDAF.init_forecast
+
+### Data assimilation
+  - pyPDAF.assimilate
+
+### Finalise PDAF
+  - pyPDAF.deallocate
+
+However, users have to implement user-supplied functions to provide state vector
+and observation information.
+
+For users without prior experience with PDAF, we highly recommend to
+start with the tutorial here:
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/yumengch/pyPDAF/).
+
+To construct a parallel ensemble DA system,
+in [example](example) directory, we provide both `online`
+and `offline` examples.
+pyPDAF and PDAF both utilise `Message Passing Interface (MPI)`
+parallelisation. Hence, to run the example, it needs to be executed
+from commandline using `mpiexec`. For example,
+```bash
+cd example
+mpiexec -n 4 python -u online/main.py
+```
+will run the example with 4 processes.
+The example is based on
+the [tutorials](http://pdaf.awi.de/trac/wiki/FirstSteps) of the original PDAF.
+
+
+## Documentation:
+The most up-to-date pyPDAF has interface with ```PDAF-V3.0```.
+A [documentation](https://yumengch.github.io/pyPDAF/index.html) is provided.
+The interface follows the naming convention of PDAF. We divide PDAF subroutines
+into several subpackages including `PDAF`, `PDAF3`, `PDAFomi`, `PDAFlocal`, and
+`PDAFlocalomi`. These provide
+
+
+## Having questions?
+We welcome issues, pull requests, feature requests and any other discussions in the issues section.
+
+## Contributors:
+Yumeng Chen, Lars Nerger
+
+pyPDAF is mainly developed and maintained by National Centre for Earth Observation and University of Reading.
+
+<img src="https://github.com/nansencenter/DAPPER/blob/master/docs/images/logos/UoR-logo.png?raw=true" height="50" /> <img src="https://github.com/nansencenter/DAPPER/blob/master/docs/images/logos/nceologo1000.png?raw=true" height="50"/>

pyPDAF/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+pyPDAF Project Package Initialization File
+"""

pyPDAF/source/build/cp310/.gitignore

@@ -0,0 +1,3 @@
+
+# This file is generated by meson-python. It will not be recreated if deleted or modified.
+*

pyPDAF/source/build/cp310/.hgignore

@@ -0,0 +1,4 @@
+
+# This file is generated by meson-python. It will not be recreated if deleted or modified.
+syntax: glob
+**/*

pyPDAF/source/build/cp310/meson-info/meson-info.json

@@ -0,0 +1 @@
+{"meson_version": {"full": "1.10.0", "major": 1, "minor": 10, "patch": 0}, "directories": {"source": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source", "build": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310", "info": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-info"}, "introspection": {"version": {"full": "1.0.0", "major": 1, "minor": 0, "patch": 0}, "information": {"benchmarks": {"file": "intro-benchmarks.json", "updated": false}, "buildoptions": {"file": "intro-buildoptions.json", "updated": false}, "buildsystem_files": {"file": "intro-buildsystem_files.json", "updated": false}, "compilers": {"file": "intro-compilers.json", "updated": false}, "dependencies": {"file": "intro-dependencies.json", "updated": false}, "installed": {"file": "intro-installed.json", "updated": false}, "install_plan": {"file": "intro-install_plan.json", "updated": false}, "machines": {"file": "intro-machines.json", "updated": false}, "projectinfo": {"file": "intro-projectinfo.json", "updated": false}, "targets": {"file": "intro-targets.json", "updated": false}, "tests": {"file": "intro-tests.json", "updated": false}}}, "build_files_updated": false, "error": true, "error_list": ["File PDAF/src/PDAF3_init.F90 does not exist."]}

pyPDAF/source/build/cp310/meson-logs/meson-log.txt

@@ -0,0 +1,505 @@
+Build started at 2025-12-09T23:43:18.387370
+Main binary: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/bin/python3.10
+Build Options: -Dbuildtype=release -Db_ndebug=if-release -Db_vscrt=md --native-file=/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-python-native-file.ini
+Python system: Linux
+The Meson build system
+Version: 1.10.0
+Source dir: /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source
+Build dir: /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310
+Build type: native build
+Project name: pyPDAF
+Project version: 1.0.4
+-----------
+Detecting compiler via: `gfortran --help` -> 0
+stdout:
+Usage: gfortran [options] file...
+Options:
+  -pass-exit-codes         Exit with highest error code from a phase.
+  --help                   Display this information.
+  --target-help            Display target specific command line options.
+  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].
+                           Display specific types of command line options.
+  (Use '-v --help' to display command line options of sub-processes).
+  --version                Display compiler version information.
+  -dumpspecs               Display all of the built in spec strings.
+  -dumpversion             Display the version of the compiler.
+  -dumpmachine             Display the compiler's target processor.
+  -print-search-dirs       Display the directories in the compiler's search path.
+  -print-libgcc-file-name  Display the name of the compiler's companion library.
+  -print-file-name=<lib>   Display the full path to library <lib>.
+  -print-prog-name=<prog>  Display the full path to compiler component <prog>.
+  -print-multiarch         Display the target's normalized GNU triplet, used as
+                           a component in the library path.
+  -print-multi-directory   Display the root directory for versions of libgcc.
+  -print-multi-lib         Display the mapping between command line options and
+                           multiple library search directories.
+  -print-multi-os-directory Display the relative path to OS libraries.
+  -print-sysroot           Display the target libraries directory.
+  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.
+  -Wa,<options>            Pass comma-separated <options> on to the assembler.
+  -Wp,<options>            Pass comma-separated <options> on to the preprocessor.
+  -Wl,<options>            Pass comma-separated <options> on to the linker.
+  -Xassembler <arg>        Pass <arg> on to the assembler.
+  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.
+  -Xlinker <arg>           Pass <arg> on to the linker.
+  -save-temps              Do not delete intermediate files.
+  -save-temps=<arg>        Do not delete intermediate files.
+  -no-canonical-prefixes   Do not canonicalize paths when building relative
+                           prefixes to other gcc components.
+  -pipe                    Use pipes rather than intermediate files.
+  -time                    Time the execution of each subprocess.
+  -specs=<file>            Override built-in specs with the contents of <file>.
+  -std=<standard>          Assume that the input sources are for <standard>.
+  --sysroot=<directory>    Use <directory> as the root directory for headers
+                           and libraries.
+  -B <directory>           Add <directory> to the compiler's search paths.
+  -v                       Display the programs invoked by the compiler.
+  -###                     Like -v but options quoted and commands not executed.
+  -E                       Preprocess only; do not compile, assemble or link.
+  -S                       Compile only; do not assemble or link.
+  -c                       Compile and assemble, but do not link.
+  -o <file>                Place the output into <file>.
+  -pie                     Create a dynamically linked position independent
+                           executable.
+  -shared                  Create a shared library.
+  -x <language>            Specify the language of the following input files.
+                           Permissible languages include: c c++ assembler none
+                           'none' means revert to the default behavior of
+                           guessing the language based on the file's extension.
+
+Options starting with -g, -f, -m, -O, -W, or --param are automatically
+ passed on to the various sub-processes invoked by gfortran.  In order to pass
+ other options on to these processes the -W<letter> options must be used.
+
+For bug reporting instructions, please see:
+<file:///usr/share/doc/gcc-11/README.Bugs>.
+-----------
+-----------
+Detecting compiler via: `gfortran --version` -> 0
+stdout:
+GNU Fortran (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0
+Copyright (C) 2021 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+-----------
+pre-processor extraction using -cpp -x fortran failed, falling back w/o lang
+Running command: -E -dM -
+-----
+-----------
+Detecting linker via: `gfortran -Wl,--version` -> 0
+stdout:
+GNU ld (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) a later version.
+This program has absolutely no warranty.
+-----------
+stderr:
+collect2 version 11.4.0
+/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/ssddata/shiweijie/tmp/ccN6AZcP.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. --version -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o
+-----------
+Sanity testing Fortran compiler: gfortran
+Is cross compiler: False.
+Sanity check compiler command line: gfortran sanitycheckf.f -o sanitycheckf.exe
+Sanity check compile stdout:
+
+-----
+Sanity check compile stderr:
+
+-----
+Running test binary command:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckf.exe
+-----------
+Sanity check: `/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckf.exe` -> 0
+stdout:
+Fortran compilation is working.
+-----------
+Fortran compiler for the host machine: gfortran (gcc 11.4.0 "GNU Fortran (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0")
+Fortran linker for the host machine: gfortran ld.bfd 2.38
+-----------
+Detecting archiver via: `gcc-ar --version` -> 0
+stdout:
+GNU ar (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) any later version.
+This program has absolutely no warranty.
+-----------
+-----------
+Detecting compiler via: `cc --version` -> 0
+stdout:
+cc (Ubuntu 12.3.0-1ubuntu1~22.04.2) 12.3.0
+Copyright (C) 2022 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+-----------
+Running command: -cpp -x c -E -dM -
+-----
+-----------
+Detecting linker via: `cc -Wl,--version` -> 0
+stdout:
+GNU ld (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) a later version.
+This program has absolutely no warranty.
+-----------
+stderr:
+collect2 version 12.3.0
+/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/12/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper -plugin-opt=-fresolution=/ssddata/shiweijie/tmp/cciVQTKq.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/12/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/12 -L/usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/12/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/12/../../.. --version -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/12/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/crtn.o
+-----------
+Sanity testing C compiler: /usr/bin/ccache cc
+Is cross compiler: False.
+Sanity check compiler command line: /usr/bin/ccache cc sanitycheckc.c -o sanitycheckc.exe -D_FILE_OFFSET_BITS=64
+Sanity check compile stdout:
+
+-----
+Sanity check compile stderr:
+
+-----
+Running test binary command:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckc.exe
+-----------
+Sanity check: `/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckc.exe` -> 0
+C compiler for the host machine: /usr/bin/ccache cc (gcc 12.3.0 "cc (Ubuntu 12.3.0-1ubuntu1~22.04.2) 12.3.0")
+C linker for the host machine: cc ld.bfd 2.38
+-----------
+Detecting compiler via: `cython -V` -> 0
+stdout:
+Cython version 3.2.2
+-----------
+stderr:
+Cython version 3.2.2
+-----------
+Running compile:
+Working directory:  /ssddata/shiweijie/tmp/tmphfa7z9tr
+Code:
+print("hello world")
+-----------
+Command line: `cython /ssddata/shiweijie/tmp/tmphfa7z9tr/testfile.pyx -o /ssddata/shiweijie/tmp/tmphfa7z9tr/output.exe --fast-fail` -> 0
+Cython compiler for the host machine: cython (cython 3.2.2)
+-----------
+Detecting compiler via: `gfortran --help` -> 0
+stdout:
+Usage: gfortran [options] file...
+Options:
+  -pass-exit-codes         Exit with highest error code from a phase.
+  --help                   Display this information.
+  --target-help            Display target specific command line options.
+  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].
+                           Display specific types of command line options.
+  (Use '-v --help' to display command line options of sub-processes).
+  --version                Display compiler version information.
+  -dumpspecs               Display all of the built in spec strings.
+  -dumpversion             Display the version of the compiler.
+  -dumpmachine             Display the compiler's target processor.
+  -print-search-dirs       Display the directories in the compiler's search path.
+  -print-libgcc-file-name  Display the name of the compiler's companion library.
+  -print-file-name=<lib>   Display the full path to library <lib>.
+  -print-prog-name=<prog>  Display the full path to compiler component <prog>.
+  -print-multiarch         Display the target's normalized GNU triplet, used as
+                           a component in the library path.
+  -print-multi-directory   Display the root directory for versions of libgcc.
+  -print-multi-lib         Display the mapping between command line options and
+                           multiple library search directories.
+  -print-multi-os-directory Display the relative path to OS libraries.
+  -print-sysroot           Display the target libraries directory.
+  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.
+  -Wa,<options>            Pass comma-separated <options> on to the assembler.
+  -Wp,<options>            Pass comma-separated <options> on to the preprocessor.
+  -Wl,<options>            Pass comma-separated <options> on to the linker.
+  -Xassembler <arg>        Pass <arg> on to the assembler.
+  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.
+  -Xlinker <arg>           Pass <arg> on to the linker.
+  -save-temps              Do not delete intermediate files.
+  -save-temps=<arg>        Do not delete intermediate files.
+  -no-canonical-prefixes   Do not canonicalize paths when building relative
+                           prefixes to other gcc components.
+  -pipe                    Use pipes rather than intermediate files.
+  -time                    Time the execution of each subprocess.
+  -specs=<file>            Override built-in specs with the contents of <file>.
+  -std=<standard>          Assume that the input sources are for <standard>.
+  --sysroot=<directory>    Use <directory> as the root directory for headers
+                           and libraries.
+  -B <directory>           Add <directory> to the compiler's search paths.
+  -v                       Display the programs invoked by the compiler.
+  -###                     Like -v but options quoted and commands not executed.
+  -E                       Preprocess only; do not compile, assemble or link.
+  -S                       Compile only; do not assemble or link.
+  -c                       Compile and assemble, but do not link.
+  -o <file>                Place the output into <file>.
+  -pie                     Create a dynamically linked position independent
+                           executable.
+  -shared                  Create a shared library.
+  -x <language>            Specify the language of the following input files.
+                           Permissible languages include: c c++ assembler none
+                           'none' means revert to the default behavior of
+                           guessing the language based on the file's extension.
+
+Options starting with -g, -f, -m, -O, -W, or --param are automatically
+ passed on to the various sub-processes invoked by gfortran.  In order to pass
+ other options on to these processes the -W<letter> options must be used.
+
+For bug reporting instructions, please see:
+<file:///usr/share/doc/gcc-11/README.Bugs>.
+-----------
+-----------
+Detecting compiler via: `gfortran --version` -> 0
+stdout:
+GNU Fortran (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0
+Copyright (C) 2021 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+-----------
+pre-processor extraction using -cpp -x fortran failed, falling back w/o lang
+Running command: -E -dM -
+-----
+-----------
+Detecting linker via: `gfortran -Wl,--version` -> 0
+stdout:
+GNU ld (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) a later version.
+This program has absolutely no warranty.
+-----------
+stderr:
+collect2 version 11.4.0
+/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/ssddata/shiweijie/tmp/ccCNrRnf.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. --version -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o
+-----------
+Sanity testing Fortran compiler: gfortran
+Is cross compiler: False.
+Sanity check compiler command line: gfortran sanitycheckf.f -o sanitycheckf.exe
+Sanity check compile stdout:
+
+-----
+Sanity check compile stderr:
+
+-----
+Running test binary command:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckf.exe
+-----------
+Sanity check: `/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckf.exe` -> 0
+stdout:
+Fortran compilation is working.
+-----------
+Fortran compiler for the build machine: gfortran (gcc 11.4.0 "GNU Fortran (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0")
+Fortran linker for the build machine: gfortran ld.bfd 2.38
+-----------
+Detecting archiver via: `gcc-ar --version` -> 0
+stdout:
+GNU ar (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) any later version.
+This program has absolutely no warranty.
+-----------
+-----------
+Detecting compiler via: `cc --version` -> 0
+stdout:
+cc (Ubuntu 12.3.0-1ubuntu1~22.04.2) 12.3.0
+Copyright (C) 2022 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+-----------
+Running command: -cpp -x c -E -dM -
+-----
+-----------
+Detecting linker via: `cc -Wl,--version` -> 0
+stdout:
+GNU ld (GNU Binutils for Ubuntu) 2.38
+Copyright (C) 2022 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) a later version.
+This program has absolutely no warranty.
+-----------
+stderr:
+collect2 version 12.3.0
+/usr/bin/ld -plugin /usr/lib/gcc/x86_64-linux-gnu/12/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper -plugin-opt=-fresolution=/ssddata/shiweijie/tmp/ccPANPFY.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/12/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/12 -L/usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/12/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/12/../../.. --version -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/12/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/12/../../../x86_64-linux-gnu/crtn.o
+-----------
+Sanity testing C compiler: /usr/bin/ccache cc
+Is cross compiler: False.
+Sanity check compiler command line: /usr/bin/ccache cc sanitycheckc.c -o sanitycheckc.exe -D_FILE_OFFSET_BITS=64
+Sanity check compile stdout:
+
+-----
+Sanity check compile stderr:
+
+-----
+Running test binary command:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckc.exe
+-----------
+Sanity check: `/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/sanitycheckc.exe` -> 0
+C compiler for the build machine: /usr/bin/ccache cc (gcc 12.3.0 "cc (Ubuntu 12.3.0-1ubuntu1~22.04.2) 12.3.0")
+C linker for the build machine: cc ld.bfd 2.38
+-----------
+Detecting compiler via: `cython -V` -> 0
+stdout:
+Cython version 3.2.2
+-----------
+stderr:
+Cython version 3.2.2
+-----------
+Using cached compile:
+Cached command line:  cython /ssddata/shiweijie/tmp/tmphfa7z9tr/testfile.pyx -o /ssddata/shiweijie/tmp/tmphfa7z9tr/output.exe --fast-fail 
+
+Code:
+ print("hello world")
+Cached compiler stdout:
+ 
+Cached compiler stderr:
+ 
+Cython compiler for the build machine: cython (cython 3.2.2)
+Build machine cpu family: x86_64
+Build machine cpu: x86_64
+Host machine cpu family: x86_64
+Host machine cpu: x86_64
+Target machine cpu family: x86_64
+Target machine cpu: x86_64
+Program python found: YES (/home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/bin/python3.10)
+Searching for '/home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/lib/pkgconfig' via pkgconfig lookup in LIBPC
+Pkg-config binary missing from cross or native file, or env var undefined.
+Trying a default Pkg-config fallback at pkg-config
+Found pkg-config: YES (/usr/bin/pkg-config) 0.29.2
+Determining dependency 'python-3.10' with pkg-config executable '/usr/bin/pkg-config'
+env[PKG_CONFIG_PATH]: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/lib/pkgconfig
+env[PKG_CONFIG]: /usr/bin/pkg-config
+-----------
+Called: `/usr/bin/pkg-config --modversion python-3.10` -> 0
+stdout:
+3.10
+-----------
+env[PKG_CONFIG_PATH]: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/lib/pkgconfig
+env[PKG_CONFIG]: /usr/bin/pkg-config
+-----------
+Called: `/usr/bin/pkg-config --cflags python-3.10` -> 0
+stdout:
+-I/home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/include/python3.10
+-----------
+env[PKG_CONFIG_ALLOW_SYSTEM_LIBS]: 1
+env[PKG_CONFIG_PATH]: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/lib/pkgconfig
+env[PKG_CONFIG]: /usr/bin/pkg-config
+-----------
+Called: `/usr/bin/pkg-config --libs python-3.10` -> 0
+env[PKG_CONFIG_PATH]: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/lib/pkgconfig
+env[PKG_CONFIG]: /usr/bin/pkg-config
+-----------
+Called: `/usr/bin/pkg-config --libs python-3.10` -> 0
+Run-time dependency python found: YES 3.10
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpic6eo8o1
+Code:
+program test
+            use iso_c_binding
+            
+            type(c_ptr) :: x
+            print '(i0)', c_sizeof(x)
+        end program test
+        
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpic6eo8o1/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpic6eo8o1/output.exe -D_FILE_OFFSET_BITS=64 -O0` -> 0
+Program stdout:
+
+8
+
+Program stderr:
+
+
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmphe18afkr
+Code:
+
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmphe18afkr/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmphe18afkr/output.obj -D_FILE_OFFSET_BITS=64 -c -O0 --print-search-dirs` -> 0
+stdout:
+install: /usr/lib/gcc/x86_64-linux-gnu/11/
+programs: =/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/bin/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/bin/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/bin/
+libraries: =/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/lib/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/lib/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/11/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/11/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/lib/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/
+-----------
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp8b3tcq_b
+Code:
+stop; end program
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp8b3tcq_b/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp8b3tcq_b/output.exe -D_FILE_OFFSET_BITS=64 -O0 /usr/lib/x86_64-linux-gnu/libblas.so -Wl,--allow-shlib-undefined` -> 0
+Library blas found: YES
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpmo4yn5qg
+Code:
+stop; end program
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpmo4yn5qg/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpmo4yn5qg/output.exe -D_FILE_OFFSET_BITS=64 -O0 /usr/lib/x86_64-linux-gnu/liblapack.so -Wl,--allow-shlib-undefined` -> 0
+Library lapack found: YES
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp3nqb6j5j
+Code:
+extern int i;
+int i;
+
+-----------
+Command line: `cc /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp3nqb6j5j/testfile.c -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmp3nqb6j5j/output.obj -c -D_FILE_OFFSET_BITS=64 -O0 /O2` -> 1
+stderr:
+cc: warning: /O2: linker input file unused because linking not done
+cc: error: /O2: linker input file not found: No such file or directory
+-----------
+Compiler for C supports arguments /O2: NO 
+WARNING: Compiler for C does not support "/O2"
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmph2ojziwd
+Code:
+extern int i;
+int i;
+
+-----------
+Command line: `cc /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmph2ojziwd/testfile.c -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmph2ojziwd/output.obj -c -D_FILE_OFFSET_BITS=64 -O0 /GL` -> 1
+stderr:
+cc: warning: /GL: linker input file unused because linking not done
+cc: error: /GL: linker input file not found: No such file or directory
+-----------
+Compiler for C supports arguments /GL: NO 
+WARNING: Compiler for C does not support "/GL"
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpk6ys51bk
+Code:
+extern int i;
+int i;
+
+-----------
+Command line: `cc /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpk6ys51bk/testfile.c -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpk6ys51bk/output.obj -c -D_FILE_OFFSET_BITS=64 -O0 -O3` -> 0
+Compiler for C supports arguments -O3: YES 
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpnnh7ir7t
+Code:
+stop; end program
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpnnh7ir7t/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpnnh7ir7t/output.obj -D_FILE_OFFSET_BITS=64 -c -O0 -O3` -> 0
+Compiler for Fortran supports arguments -O3: YES 
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpjqfzue8b
+Code:
+stop; end program
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpjqfzue8b/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpjqfzue8b/output.obj -D_FILE_OFFSET_BITS=64 -c -O0 -fdefault-real-8` -> 0
+Compiler for Fortran supports arguments -fdefault-real-8: YES 
+Running compile:
+Working directory:  /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmprajkiv58
+Code:
+stop; end program
+-----------
+Command line: `gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmprajkiv58/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmprajkiv58/output.obj -D_FILE_OFFSET_BITS=64 -c -O0 -DUSE_PDAF` -> 0
+Compiler for Fortran supports arguments -DUSE_PDAF: YES 
+Using cached compile:
+Cached command line:  gfortran /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpnnh7ir7t/testfile.f90 -o /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-private/tmpnnh7ir7t/output.obj -D_FILE_OFFSET_BITS=64 -c -O0 -O3 
+
+Code:
+ stop; end program
+Cached compiler stdout:
+ 
+Cached compiler stderr:
+ 
+Compiler for Fortran supports arguments -O3: YES (cached)
+Running command: /home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/bin/python3.10 -c 'import os; os.chdir(".."); import numpy; print(numpy.get_include())'
+--- stdout ---
+/ssddata/shiweijie/tmp/pip-build-env-ygthrxi6/overlay/lib/python3.10/site-packages/numpy/_core/include
+
+--- stderr ---
+
+
+
+../../meson.build:88:18: ERROR: File PDAF/src/PDAF3_init.F90 does not exist.

pyPDAF/source/build/cp310/meson-logs/meson-setup.txt

@@ -0,0 +1,32 @@
+The Meson build system
+Version: 1.10.0
+Source dir: /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source
+Build dir: /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310
+Build type: native build
+Project name: pyPDAF
+Project version: 1.0.4
+Fortran compiler for the host machine: gfortran (gcc 11.4.0 "GNU Fortran (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0")
+Fortran linker for the host machine: gfortran ld.bfd 2.38
+C compiler for the host machine: /usr/bin/ccache cc (gcc 12.3.0 "cc (Ubuntu 12.3.0-1ubuntu1~22.04.2) 12.3.0")
+C linker for the host machine: cc ld.bfd 2.38
+Cython compiler for the host machine: cython (cython 3.2.2)
+Host machine cpu family: x86_64
+Host machine cpu: x86_64
+Program python found: YES (/home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/bin/python3.10)
+Found pkg-config: YES (/usr/bin/pkg-config) 0.29.2
+Run-time dependency python found: YES 3.10
+Library blas found: YES
+Library lapack found: YES
+Compiler for C supports arguments /O2: NO 
+WARNING: Compiler for C does not support "/O2"
+Compiler for C supports arguments /GL: NO 
+WARNING: Compiler for C does not support "/GL"
+Compiler for C supports arguments -O3: YES 
+Compiler for Fortran supports arguments -O3: YES 
+Compiler for Fortran supports arguments -fdefault-real-8: YES 
+Compiler for Fortran supports arguments -DUSE_PDAF: YES 
+Compiler for Fortran supports arguments -O3: YES (cached)
+
+../../meson.build:88:18: ERROR: File PDAF/src/PDAF3_init.F90 does not exist.
+
+A full log can be found at /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/pyPDAF/source/build/cp310/meson-logs/meson-log.txt

pyPDAF/source/build/cp310/meson-private/sanitycheckc.c

@@ -0,0 +1 @@
+int main(void) { int class=0; return class; }

pyPDAF/source/build/cp310/meson-private/sanitycheckf.f

@@ -0,0 +1,3 @@
+      PROGRAM MAIN
+      PRINT *, "Fortran compilation is working."
+      END

pyPDAF/source/build/cp310/meson-python-native-file.ini

@@ -0,0 +1,3 @@
+
+[binaries]
+python = '/home/wshiah/code/miniconda3/envs/pyPDAF_294797_env/bin/python3.10'

pyPDAF/source/conda.recipe/bld.bat

@@ -0,0 +1,14 @@
+@echo on
+
+set CXX=clang-cl
+set CC=clang-cl
+set FC=flang-new
+set MSMPI_INC=%LIBRARY_INC%
+set MSMPI_LIB64=%LIBRARY_LIB%
+
+"%PYTHON%" -m pip install . -v --no-build-isolation^
+    -Cbuild-dir=build --config-settings=setup-args="-Dblas_lib=openblas"^
+    --config-settings=setup-args="-Dincdirs="%LIBRARY_INC%^
+    --config-settings=setup-args="-Dlibdirs="%LIBRARY_LIB%^
+    --config-settings=setup-args="-Dmpi_mod="%LIBRARY_INC%"\mpi.f90"^
+    --config-settings=setup-args="-Dbuildtype=release"

pyPDAF/source/conda.recipe/build.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -ex
+
+CC=mpicc
+FC=mpifort
+
+$PYTHON -m pip install . -v --no-build-isolation \
+    --config-settings=setup-args="-Dblas_lib=['openblas',]" \
+    --config-settings=setup-args="-Dincdirs="$PREFIX"/include" \
+    --config-settings=setup-args="-Dlibdirs="$PREFIX"/lib" \
+    --config-settings=setup-args="-Dbuildtype=release"

pyPDAF/source/conda.recipe/conda_build_config.yaml

@@ -0,0 +1,31 @@
+python:
+    - 3.11
+    - 3.12
+    - 3.13
+
+c_compiler_version:
+    - 14 # [linux]
+
+# there seems to be bug in gfortran 15.1.0
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119928
+# therefore, we pin gfortran 14
+fortran_compiler_version:
+    - 14 # [not win]
+
+c_compiler:
+    - clang      # [win]
+
+fortran_compiler:
+    - flang      # [win]
+
+numpy_version:
+    - '>2'
+
+mpi:
+    - mpich    # [not win]
+    - msmpi    # [win]
+
+# meson-python 0.18 cannot be installed on Windows
+pymeson:
+    - <0.18  # [win]
+    - '>=0.18'  # [not win]

pyPDAF/source/conda.recipe/meta.yaml

@@ -0,0 +1,49 @@
+{% set version = "1.0.4" %}
+
+package:
+  name: pypdaf
+  version: {{ version }}
+
+source:
+  path: ..
+
+build:
+  number: 0
+
+requirements:
+  host:
+    - python
+    - meson-python {{ pymeson }}
+    - numpy {{numpy_version}}
+    - mpi=*={{ mpi }}
+    - mpi4py
+    - blas=*=openblas
+    - flang-rt_win-64 # [win]
+    - libflang # [win]
+  build:
+    - python
+    - {{ compiler('c') }}
+    - {{ compiler('fortran') }}
+    - vs2022_win-64     # [win]
+    - numpy {{numpy_version}}
+    - cython
+  run:
+    - flang-rt_win-64 # [win]
+    - python
+    - numpy
+    - mpi=*={{ mpi }}
+    - mpi4py
+    - blas=*=openblas
+
+pin_run_as_build:
+    mpi: x.x
+    mpi4py: x.x
+    blas: x.x
+
+about:
+  home: https://github.com/yumengch/pyPDAF
+  summary: A Python interface to PDAF
+  description: pyPDAF is a python interface to the Fortran-based PDAF library
+  license: GPL
+  doc_url: https://yumengch.github.io/pyPDAF/index.html
+  dev_url: https://github.com/yumengch/pyPDAF

pyPDAF/source/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?= -v
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

pyPDAF/source/docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

pyPDAF/source/docs/source/API.rst

@@ -0,0 +1,306 @@
+API
+===
+
+This page provides a list of pyPDAF functions that are intended for users.
+They are grouped by functionalities. Clicking on a function name will lead to
+its documentation page.
+
+These are not all available functions in pyPDAF. Similar to PDAF, pyPDAF maintains
+backward compatible legacy functions used prior to PDAF 3.0.
+For a complete list of functions,
+please refer to the [hidden and legacy function page](hidden_functions.md)
+
+.. contents::
+   :local:
+   :depth: 2
+
+Initialisation and finalisation
+-------------------------------
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.init
+   pyPDAF.set_parallel
+   pyPDAF.init_forecast
+   pyPDAF.PDAFomi.init
+   pyPDAF.PDAFomi.init_local
+   pyPDAF.deallocate
+
+DA algorithms
+------------------------------
+
+Sequential DA
+^^^^^^^^^^^^^
+
+diagnoal observation matrix
+"""""""""""""""""""""""""""
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.assimilate
+   pyPDAF.assim_offline
+
+non-diagnoal observation matrix
+"""""""""""""""""""""""""""""""
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.assimilate_local_nondiagr
+   pyPDAF.assimilate_global_nondiagr
+   pyPDAF.assimilate_lnetf_nondiagr
+   pyPDAF.assimilate_lknetf_nondiagr
+   pyPDAF.assimilate_enkf_nondiagr
+   pyPDAF.assimilate_nonlin_nondiagr
+
+   pyPDAF.assim_offline_local_nondiagr
+   pyPDAF.assim_offline_global_nondiagr
+   pyPDAF.assim_offline_lnetf_nondiagr
+   pyPDAF.assim_offline_lknetf_nondiagr
+   pyPDAF.assim_offline_enkf_nondiagr
+   pyPDAF.assim_offline_lenkf_nondiagr
+   pyPDAF.assim_offline_nonlin_nondiagr
+
+Variational DA
+^^^^^^^^^^^^^^
+
+diagnoal observation matrix
+"""""""""""""""""""""""""""
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.assimilate_3dvar_all
+   pyPDAF.assim_offline_3dvar_all
+
+non-diagnoal observation matrix
+"""""""""""""""""""""""""""""""
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.assimilate_3dvar_nondiagr
+   pyPDAF.assimilate_en3dvar_estkf_nondiagr
+   pyPDAF.assimilate_en3dvar_lestkf_nondiagr
+   pyPDAF.assimilate_hyb3dvar_estkf_nondiagr
+   pyPDAF.assimilate_hyb3dvar_lestkf_nondiagr
+
+   pyPDAF.assim_offline_3dvar_nondiagr
+   pyPDAF.assim_offline_en3dvar_estkf_nondiagr
+   pyPDAF.assim_offline_en3dvar_lestkf_nondiagr
+   pyPDAF.assim_offline_hyb3dvar_estkf_nondiagr
+   pyPDAF.assim_offline_hyb3dvar_lestkf_nondiagr
+
+
+OMI functions
+-------------
+
+setter functions
+^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.set_doassim
+   pyPDAF.PDAFomi.set_disttype
+   pyPDAF.PDAFomi.set_ncoord
+   pyPDAF.PDAFomi.set_obs_err_type
+   pyPDAF.PDAFomi.set_use_global_obs
+   pyPDAF.PDAFomi.set_inno_omit
+   pyPDAF.PDAFomi.set_inno_omit_ivar
+   pyPDAF.PDAFomi.set_id_obs_p
+   pyPDAF.PDAFomi.set_icoeff_p
+   pyPDAF.PDAFomi.set_domainsize
+   pyPDAF.PDAFomi.set_name
+   pyPDAF.PDAFomi.gather_obs
+
+
+Observation operators
+^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.obs_op_gridpoint
+   pyPDAF.PDAFomi.obs_op_gridavg
+   pyPDAF.PDAFomi.obs_op_extern
+   pyPDAF.PDAFomi.obs_op_interp_lin
+   pyPDAF.PDAFomi.obs_op_adj_gridavg
+   pyPDAF.PDAFomi.obs_op_adj_gridpoint
+   pyPDAF.PDAFomi.obs_op_adj_interp_lin
+   pyPDAF.PDAFomi.gather_obsstate
+
+Interpolations
+^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.get_interp_coeff_tri
+   pyPDAF.PDAFomi.get_interp_coeff_lin1d
+   pyPDAF.PDAFomi.get_interp_coeff_lin
+
+Localisation
+^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.init_dim_obs_l_iso
+   pyPDAF.PDAFomi.init_dim_obs_l_noniso
+   pyPDAF.PDAFomi.init_dim_obs_l_noniso_locweights
+   pyPDAF.PDAFomi.observation_localization_weights
+   pyPDAF.PDAFomi.set_domain_limits
+   pyPDAF.PDAFomi.get_domain_limits_unstr
+   pyPDAF.PDAFomi.set_localize_covar_iso
+   pyPDAF.PDAFomi.set_localize_covar_noniso
+   pyPDAF.PDAFomi.set_localize_covar_noniso_locweights
+
+Custom local observation initialisation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.set_localization
+   pyPDAF.PDAFomi.set_localization_noniso
+   pyPDAF.PDAFomi.set_dim_obs_l
+   pyPDAF.PDAFomi.store_obs_l_index
+   pyPDAF.PDAFomi.store_obs_l_index_vdist
+
+Diagnostics
+^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFomi.check_error
+   pyPDAF.PDAFomi.set_debug_flag
+   pyPDAF.PDAFomi.set_obs_diag
+   pyPDAF.PDAFomi.diag_dimobs
+   pyPDAF.PDAFomi.diag_get_hx
+   pyPDAF.PDAFomi.diag_get_hxmean
+   pyPDAF.PDAFomi.diag_get_ivar
+   pyPDAF.PDAFomi.diag_get_obs
+   pyPDAF.PDAFomi.diag_nobstypes
+   pyPDAF.PDAFomi.diag_obs_rmsd
+   pyPDAF.PDAFomi.diag_stats
+
+
+Localisation functions
+----------------------
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAFlocal.set_indices
+   pyPDAF.PDAFlocal.set_increment_weights
+   pyPDAF.PDAFlocal.clear_increment_weights
+   pyPDAF.PDAF.correlation_function
+   pyPDAF.PDAF.local_weight
+   pyPDAF.PDAF.local_weights
+
+Utilities
+---------
+
+PDAF state and setup information
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.get_fcst_info
+   pyPDAF.PDAF.get_assim_flag
+   pyPDAF.PDAF.get_localfilter
+   pyPDAF.PDAF.get_local_type
+   pyPDAF.PDAF.get_memberid
+   pyPDAF.PDAF.get_obsmemberid
+   pyPDAF.PDAF.get_smoother_ens
+   pyPDAF.PDAF.print_filter_types
+   pyPDAF.PDAF.print_da_types
+   pyPDAF.PDAF.print_info
+
+
+Observation MPI handling
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.gather_dim_obs_f
+   pyPDAF.PDAF.gather_obs_f
+   pyPDAF.PDAF.gather_obs_f2
+   pyPDAF.PDAF.gather_obs_f_flex
+   pyPDAF.PDAF.gather_obs_f2_flex
+
+
+Synthetic experiments
+^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.generate_obs
+   pyPDAF.generate_obs_offline
+
+
+Incremental analysis update
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.iau_init
+   pyPDAF.PDAF.iau_reset
+   pyPDAF.PDAF.iau_set_pointer
+
+Statistical diagnostics
+^^^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.diag_effsample
+   pyPDAF.PDAF.diag_ensstats
+   pyPDAF.PDAF.diag_histogram
+   pyPDAF.PDAF.diag_crps_mpi
+   pyPDAF.PDAF.diag_crps_nompi
+
+Ensemble generation
+^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.eofcovar
+   pyPDAF.PDAF.sample_ens
+
+PDAF debug options
+^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.set_debug_flag
+
+Advanced manipulation
+^^^^^^^^^^^^^^^^^^^^^
+.. autosummary::
+   :toctree: _autosummary
+   :recursive:
+
+   pyPDAF.PDAF.set_iparam
+   pyPDAF.PDAF.set_rparam
+   pyPDAF.PDAF.set_comm_pdaf
+
+   pyPDAF.PDAF.set_ens_pointer
+   pyPDAF.PDAF.set_memberid
+   pyPDAF.PDAF.set_offline_mode
+   pyPDAF.PDAF.set_seedset
+   pyPDAF.PDAF.set_smoother_ens
+
+   pyPDAF.PDAF.force_analysis
+   pyPDAF.PDAF.reset_forget
+

pyPDAF/source/docs/source/conf.py

@@ -0,0 +1,71 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'pyPDAF'
+copyright = '2025 University of Reading and National Centre for Earth Observation'
+author = 'Yumeng Chen, Lars Nerger'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.autosummary',
+              'sphinx.ext.mathjax',
+              'sphinx.ext.coverage', 'sphinx.ext.napoleon', 'myst_parser'
+              ]
+
+autosummary_generate = True
+
+autoclass_content = 'both'
+
+napoleon_google_docstring = False
+napoleon_numpy_docstring = True
+napoleon_include_init_with_doc = True
+napoleon_include_private_with_doc = True
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = True
+napoleon_preprocess_types = False
+napoleon_type_aliases = None
+napoleon_attr_annotations = True
+
+myst_heading_anchors = 3
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+source_suffix = {'.rst': 'restructuredtext', '.md': 'markdown'}
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+html_theme_options = {
+    "description": "A Python interface to Parallel Data Assimilation Framework.",
+    "github_button": True,
+    "github_user": "yumengch",
+    "github_repo": "pyPDAF",
+    "body_max_width": "none"
+}
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']

pyPDAF/source/docs/source/develop.md

@@ -0,0 +1,327 @@
+# Developer Guide
+
+The following guide explains the structure, implementation details, and mechanisms
+used in `pyPDAF`. This guide is aimed at developers who wish to understand the
+existing framework, make modifications, or contribute to its development.
+
+---
+
+## Overview
+
+`pyPDAF` bridges Python and Fortran by leveraging the `Cython` library.
+As Python is implemented in C, any interaction between Python and Fortran is
+effectively handled as C-to-Fortran communication.
+
+`Cython` automatically converts its module to `C` source code. The interoperability
+with `Fortran` is achieved by the Fortran 2003 feature `iso_c_binding` module.
+
+Contributions to the library can include raising issues, suggesting features,
+or submitting pull requests with code enhancements.
+
+---
+
+## Adding a new Fortran function in pyPDAF
+
+### Fortran Subroutines and Wrappers
+The Fortran subroutine wrappers that are interoperable with C functions are
+given in [src/fortran](https://github.com/yumengch/pyPDAF/tree/main/src/fortran).
+
+#### Interoperability with `bind(c)`
+Fortran subroutines use the `bind(c)` keyword for compatibility with C.
+
+Since PDAF does not use this keyword, `pyPDAF` provides its own wrapper subroutines that:
+1. Subroutine names begin with the prefix `c__` to denote compatibility.
+2. Arguments use corresponding C types.
+3. User-supplied functions must be declared with [specified interface](https://github.com/yumengch/pyPDAF/tree/main/src/fortran/pdaf_c_cb_interface.f90)
+4. Bind(c) user-supplied functions must be converted to Fortran subroutines by
+   pointers and wrapper subroutines in [src/fortran/pdaf_c_f_interface.f90](https://github.com/yumengch/pyPDAF/tree/main/src/fortran/pdaf_c_f_interface.f90).
+   This is a requirement in `flang`.
+5. We do not use features that interoperable with derived types. This is because
+   current standard does not support allocatable arrays in derived types.
+   Therefore, `obs_f` and `obs_l` in PDAFomi are allocated in Fortran referenced
+   by indices, and getting and setter functions.
+
+#### Example Wrapper Subroutine
+```fortran
+subroutine c__PDAFomi_set_doassim(i_obs, doassim) bind(c)
+   ! Index of observation types
+   integer(c_int), intent(in) :: i_obs
+   ! Flag to determine assimilation (0: no, 1: yes)
+   integer(c_int), intent(in) :: doassim
+   thisobs(i_obs)%doassim = doassim
+end subroutine c__PDAFomi_set_doassim
+```
+
+---
+
+### Cython Integration
+
+#### Cython Declarations
+To call Fortran subroutines in Python, `pyPDAF` uses Cython declarations
+defined in `.pxd` files (e.g., `src/pyPDAF/PDAF.pxd`). Example:
+```cython
+cdef extern void c__pdaf_eofcovar (
+    int* dim_state, int* nstates, int* nfields, int* dim_fields,
+    int* offsets, int* remove_mstate, int* do_mv, double* states,
+    double* stddev, double* svals, double* svec, double* meanstate,
+    int* verbose, int* status) noexcept;
+```
+
+#### Python Wrappers
+These Cython declarations are wrapped into Python functions to make them
+accessible to users. Wrappers should return all `intent(out)` or `intent(inout)`
+arguments in Python-friendly structures.
+
+Example:
+```cython
+def eofcovar(int  dim, int  nstates, int  nfields, int [::1] dim_fields,
+    int [::1] offsets, int  remove_mstate, int  do_mv,
+    double [::1,:] states, double [::1] meanstate, int  verbose):
+    """
+    EOF analysis of an ensemble of state vectors by singular value decomposition.
+
+    Typically, this function is used with :func:`pyPDAF.PDAF.SampleEns`
+    to generate an ensemble of a chosen size (up to the number of EOFs plus one).
+
+    Here, the function performs a singular value decomposition
+    of the ensemble anomaly of the input matrix,
+    which is usually an ensemble formed by state vectors
+    at multiple time steps.
+    The singular values and corresponding singular vectors
+    can be used to construct a covariance matrix.
+    This can be used as the initial error covariance for the initial ensemble.
+
+    A multivariate scaling can be performed to ensure that all fields
+    in the state vectors have unit variance.
+
+    It can be useful to store more EOFs than one finally
+    might want to use to have the flexibility
+    to carry the ensemble size.
+
+
+    See Also
+    --------
+    `PDAF webpage <https://pdaf.awi.de/trac/wiki/EnsembleGeneration>`_
+
+    Parameters
+    ----------
+    dim : int
+        Dimension of state vector
+    nstates : int
+        Number of state vectors
+    nfields : int
+        Number of fields in state vector
+    dim_fields : ndarray[np.intc, ndim=1]
+        Size of each field
+        Array shape: (nfields)
+    offsets : ndarray[np.intc, ndim=1]
+        Start position of each field
+        Array shape: (nfields)
+    remove_mstate : int
+        1: subtract mean state from states
+    do_mv : int
+        1: Do multivariate scaling; 0: no scaling
+    states : ndarray[np.float64, ndim=2]
+        State perturbations
+        Array shape: (dim, nstates)
+    meanstate : ndarray[np.float64, ndim=1]
+        Mean state (only changed if remove_mstate=1)
+        Array shape: (dim)
+    verbose : int
+        Verbosity flag
+
+    Returns
+    -------
+    states : ndarray[np.float64, ndim=2]
+        State perturbations
+        Array shape: (dim, nstates)
+    stddev : ndarray[np.float64, ndim=1]
+        Standard deviation of field variability
+        Array shape: (nfields)
+    svals : ndarray[np.float64, ndim=1]
+        Singular values divided by sqrt(nstates-1)
+        Array shape: (nstates)
+    svec : ndarray[np.float64, ndim=2]
+        Singular vectors
+        Array shape: (dim, nstates)
+    meanstate : ndarray[np.float64, ndim=1]
+        Mean state (only changed if remove_mstate=1)
+        Array shape: (dim)
+    status : int
+        Status flag
+    """
+    cdef cnp.ndarray[cnp.float64_t, ndim=2, mode="fortran", negative_indices=False, cast=False] states_np = np.asarray(states, dtype=np.float64, order="F")
+    cdef cnp.ndarray[cnp.float64_t, ndim=1, mode="fortran", negative_indices=False, cast=False] stddev_np = np.zeros((nfields), dtype=np.float64, order="F")
+    cdef double [::1] stddev = stddev_np
+    cdef cnp.ndarray[cnp.float64_t, ndim=1, mode="fortran", negative_indices=False, cast=False] svals_np = np.zeros((nstates), dtype=np.float64, order="F")
+    cdef double [::1] svals = svals_np
+    cdef cnp.ndarray[cnp.float64_t, ndim=2, mode="fortran", negative_indices=False, cast=False] svec_np = np.zeros((dim, nstates), dtype=np.float64, order="F")
+    cdef double [::1,:] svec = svec_np
+    cdef cnp.ndarray[cnp.float64_t, ndim=1, mode="fortran", negative_indices=False, cast=False] meanstate_np = np.asarray(meanstate, dtype=np.float64, order="F")
+    cdef int  status
+    with nogil:
+        c__pdaf_eofcovar(&dim, &nstates, &nfields, &dim_fields[0],
+                         &offsets[0], &remove_mstate, &do_mv, &states[0,0],
+                         &stddev[0], &svals[0], &svec[0,0], &meanstate[0],
+                         &verbose, &status)
+
+    return states_np, stddev_np, svals_np, svec_np, meanstate_np, status
+```
+
+---
+
+#### Handling Callback Functions
+
+Callback functions allow users to provide information for data assimilation.
+However, Fortran expects these routines to follow specific interfaces.
+These are handled in `src/pyPDAF/pdaf_c_cb_interface.pxd` and corresponding
+`src/pyPDAF/pdaf_c_cb_interface.pyx`.
+
+Example:
+```cython
+cdef void c__init_ens_pdaf(int* filtertype, int* dim_p, int* dim_ens,
+    double* state_p, double* uinv, double* ens_p, int* flag) noexcept with gil:
+    """Fill the ensemble array that is provided by PDAF with an initial ensemble of model states.
+
+    This function is called by :func:`pyPDAF.PDAF.init`. The initialised
+    ensemble array will be distributed to model by :func:`pyPDAF.PDAF.init_forecast`.
+
+    Parameters
+    ----------
+    filtertype : int
+            filter type given in PDAF_init
+    dim_p : int
+            PE-local state dimension given by PDAF_init
+    dim_ens : int
+            number of ensemble members
+    state_p : ndarray[np.float64, ndim=1]
+            PE-local model state
+            This array must be filled with the initial
+            state of the model for SEEK, but it is not
+            used for ensemble-based filters.
+            One can still make use of this array within
+            this function.
+            Array shape: (dim_p)
+    uinv : ndarray[np.float64, ndim=2]
+            This array is the inverse of matrix
+            formed by right singular vectors of error
+            covariance matrix of ensemble perturbations.
+            This array has to be filled in SEEK, but it is
+            not used for ensemble-based filters.
+            Nevertheless, one can still make use of this
+            array within this function e.g.,
+            for generating an initial ensemble perturbation
+            from a given covariance matrix.
+            Dimension of this array is determined by the
+            filter type.
+            * (dim_ens, dim_ens) for (L)ETKF, (L)NETF, (L)KNETF, and SEEK
+            * (dim_ens - 1, dim_ens - 1) for (L)SEIK, (L)ESTKF, and 3DVar using ensemble
+            * (1, 1) for (L)EnKF, particle filters and gen_obs
+            Array shape: (dim_ens - 1, dim_ens-1)
+    ens_p : ndarray[np.float64, ndim=2]
+            PE-local ensemble
+            Array shape: (dim_p, dim_ens)
+    flag : int
+            pdaf status flag
+
+    Returns
+    -------
+    state_p : ndarray[np.float64, ndim=1]
+            PE-local model state
+            This array must be filled with the initial
+            state of the model for SEEK, but it is not
+            used for ensemble-based filters.
+            One can still make use of this array within
+            this function.
+            Array shape: (dim_p)
+    uinv : ndarray[np.float64, ndim=2]
+            This array is the inverse of matrix
+            formed by right singular vectors of error
+            covariance matrix of ensemble perturbations.
+            This array has to be filled in SEEK, but it is
+            not used for ensemble-based filters.
+            Nevertheless, one can still make use of this
+            array within this function e.g.,
+            for generating an initial ensemble perturbation
+            from a given covariance matrix.
+            Dimension of this array is determined by the
+            filter type.
+            * (dim_ens, dim_ens) for (L)ETKF, (L)NETF, (L)KNETF, and SEEK
+            * (dim_ens - 1, dim_ens - 1) for (L)SEIK, (L)ESTKF, and 3DVar using ensemble
+            * (1, 1) for (L)EnKF, particle filters and gen_obs
+            Array shape: (dim_ens - 1, dim_ens-1)
+    ens_p : ndarray[np.float64, ndim=2]
+            PE-local ensemble
+            Array shape: (dim_p, dim_ens)
+    flag : int
+            pdaf status flag
+    """
+    cdef size_t uinv_len = max(dim_ens[0]-1, 1)
+    cdef double[::1] state_p_np = np.asarray(<double[:dim_p[0]:1]> state_p, order="F")
+    cdef double[::1,:] uinv_np = np.asarray(<double[:uinv_len:1,:uinv_len]> uinv, order="F")
+    cdef double[::1,:] ens_p_np = np.asarray(<double[:dim_p[0]:1,:dim_ens[0]]> ens_p, order="F")
+
+    state_p_np,uinv_np,ens_p_np,flag[0] = (<object>init_ens_pdaf)(
+                                                                  filtertype[0],
+                                                                  dim_p[0],
+                                                                  dim_ens[0],
+                                                                  state_p_np.base,
+                                                                  uinv_np.base,
+                                                                  ens_p_np.base,
+                                                                  flag[0])
+
+    cdef double[::1] state_p_new
+    if state_p != &state_p_np[0]:
+        state_p_new = np.asarray(<double[:dim_p[0]:1]> state_p, order="F")
+        state_p_new[...] = state_p_np
+        warnings.warn("The memory address of state_p is changed in c__add_obs_err_pdaf."
+            "The values are copied to the original Fortran array, and can slow-down the system.", RuntimeWarning)
+    cdef double[::1,:] uinv_new
+    if uinv != &uinv_np[0,0]:
+        uinv_new = np.asarray(<double[:uinv_len:1,:uinv_len]> uinv, order="F")
+        uinv_new[...] = uinv_np
+        warnings.warn("The memory address of uinv is changed in c__add_obs_err_pdaf."
+            "The values are copied to the original Fortran array, and can slow-down the system.", RuntimeWarning)
+    cdef double[::1,:] ens_p_new
+    if ens_p != &ens_p_np[0,0]:
+        ens_p_new = np.asarray(<double[:dim_p[0]:1,:dim_ens[0]]> ens_p, order="F")
+        ens_p_new[...] = ens_p_np
+        warnings.warn("The memory address of ens_p is changed in c__add_obs_err_pdaf."
+            "The values are copied to the original Fortran array, and can slow-down the system.", RuntimeWarning)
+```
+where `init_ens_pdaf` is defined in `src/pyPDAF/pdaf_c_cb_interface.pxd` as a pointer:
+`cdef void*  init_ens_pdaf = NULL;`.
+The pointer is associated in pyPDAF functions, for example, in `src/pyPDAF/PDAF3/_pdaf3_c.pyx`:
+```cython
+from pyPDAF cimport pdaf_c_cb_interface as pdaf_cb
+pdaf_cb.init_ens_pdaf = <void*>py__init_ens_pdaf
+```
+where `py__init_ens_pdaf` is the Python call-back function. The C function,
+`pdaf_cb.c__init_ens_pdaf`, is
+used for calling Fortran subroutines:
+```cython
+    with nogil:
+        c__pdaf3_init(&filtertype, &subtype, &stepnull, &param_int[0],
+                     &dim_pint, &param_real[0], &dim_preal,
+                     pdaf_cb.c__init_ens_pdaf, &in_screen, &outflag)
+```
+
+#### Caveats
+1. **Pass-by-Reference in Fortran:** Fortran passes arguments by reference, while Python’s behavior depends on the object type.
+2. **Maintaining Consistency:** When Python functions modify arguments, ensure the original reference is preserved.
+
+Example Safety Check:
+```python
+    cdef double[::1] state_p_new
+    if state_p != &state_p_np[0]:
+        state_p_new = np.asarray(<double[:dim_p[0]]> state_p)
+        state_p_new[...] = state_p_np
+        warnings.warn("The memory address of state_p is changed in c__init_ens_pdaf."
+         "The values are copied to the original Fortran array, and can slow-down the system.", RuntimeWarning)
+```
+
+#### Exposing the function to pyPDAF and Mypy
+To expose your function to pyPDAF or subpackages of pyPDAF, you need to import
+it in `__init__.py` in corresponding directories. Further, as pyPDAF supports
+type checking and other Python support features. You can add typing and docstring
+to stub files ending with `.pyi`.

pyPDAF/source/docs/source/hidden_functions.md

@@ -0,0 +1,749 @@
+# Legacy and internal PDAF functions
+
+This page gives all available functions in pyPDAF. They are accesible in the
+submodules. Due to the amount of functions available, this documentation cannot
+provide detailed explanations for each function.
+
+To use these functions, one has to import the individual module first. For example,
+if one wants to use PDAF subroutine `PDAF_assimilate_3dvar` located in
+`pyPDAF.PDAF.assim`, one can only use `pyPDAF.PDAF.assim.assimilate_3dvar` after
+`import pyPDAF.PDAF.assim`. One cannot simply access these functions by `import pyPDAF`
+like those functions given in [API](API.rst).
+
+However, the developers encourage the users to create new issues to request
+information for specific function or functionalities so that the developers
+can understand the needs from users.
+
+Explanations of certain legacy functions may be found in PDAF wiki page by the
+corresponding PDAF subroutines. One can find the name of PDAF subroutines by
+the pyPDAF subpackage name and function names. For example,
+`pyPDAF.PDAF._pdaf_c.deallocate` calls `PDAF_deallocate` in PDAF. The module names
+are typically irrelevant. This is similar for `PDAFomi` subroutines, e.g.,
+`PDAFomi_check_error` is `pyPDAF.PDAFomi._pdafomi_c.check_error`.
+
+One exception is for some `3dvar` functions. As numbers cannot be the first
+letter of variable or function names, an additional `_` is added for some PDAF
+internal functionss.
+
+
+## pyPDAF.PDAF
+### pyPDAF.PDAF._pdaf_c
+    - pyPDAF.PDAF._pdaf_c.correlation_function
+    - pyPDAF.PDAF._pdaf_c.deallocate
+    - pyPDAF.PDAF._pdaf_c.eofcovar
+    - pyPDAF.PDAF._pdaf_c.force_analysis
+    - pyPDAF.PDAF._pdaf_c.gather_dim_obs_f
+    - pyPDAF.PDAF._pdaf_c.gather_obs_f
+    - pyPDAF.PDAF._pdaf_c.gather_obs_f2
+    - pyPDAF.PDAF._pdaf_c.gather_obs_f2_flex
+    - pyPDAF.PDAF._pdaf_c.gather_obs_f_flex
+    - pyPDAF.PDAF._pdaf_c.get_fcst_info
+    - pyPDAF.PDAF._pdaf_c.init
+    - pyPDAF.PDAF._pdaf_c.init_forecast
+    - pyPDAF.PDAF._pdaf_c.local_weight
+    - pyPDAF.PDAF._pdaf_c.local_weights
+    - pyPDAF.PDAF._pdaf_c.print_da_types
+    - pyPDAF.PDAF._pdaf_c.print_filter_types
+    - pyPDAF.PDAF._pdaf_c.print_info
+    - pyPDAF.PDAF._pdaf_c.reset_forget
+    - pyPDAF.PDAF._pdaf_c.sample_ens
+
+### pyPDAF.PDAF.assim
+    - pyPDAF.PDAF.assim.assim_offline_3dvar
+    - pyPDAF.PDAF.assim.assim_offline_en3dvar_estkf
+    - pyPDAF.PDAF.assim.assim_offline_en3dvar_lestkf
+    - pyPDAF.PDAF.assim.assim_offline_enkf
+    - pyPDAF.PDAF.assim.assim_offline_ensrf
+    - pyPDAF.PDAF.assim.assim_offline_estkf
+    - pyPDAF.PDAF.assim.assim_offline_etkf
+    - pyPDAF.PDAF.assim.assim_offline_hyb3dvar_estkf
+    - pyPDAF.PDAF.assim.assim_offline_hyb3dvar_lestkf
+    - pyPDAF.PDAF.assim.assim_offline_lenkf
+    - pyPDAF.PDAF.assim.assim_offline_lestkf
+    - pyPDAF.PDAF.assim.assim_offline_letkf
+    - pyPDAF.PDAF.assim.assim_offline_lknetf
+    - pyPDAF.PDAF.assim.assim_offline_lnetf
+    - pyPDAF.PDAF.assim.assim_offline_lseik
+    - pyPDAF.PDAF.assim.assim_offline_netf
+    - pyPDAF.PDAF.assim.assim_offline_pf
+    - pyPDAF.PDAF.assim.assim_offline_seik
+    - pyPDAF.PDAF.assim.assimilate_3dvar
+    - pyPDAF.PDAF.assim.assimilate_en3dvar_estkf
+    - pyPDAF.PDAF.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAF.assim.assimilate_enkf
+    - pyPDAF.PDAF.assim.assimilate_ensrf
+    - pyPDAF.PDAF.assim.assimilate_estkf
+    - pyPDAF.PDAF.assim.assimilate_etkf
+    - pyPDAF.PDAF.assim.assimilate_hyb3dvar_estkf
+    - pyPDAF.PDAF.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAF.assim.assimilate_lenkf
+    - pyPDAF.PDAF.assim.assimilate_lestkf
+    - pyPDAF.PDAF.assim.assimilate_letkf
+    - pyPDAF.PDAF.assim.assimilate_lknetf
+    - pyPDAF.PDAF.assim.assimilate_lnetf
+    - pyPDAF.PDAF.assim.assimilate_lseik
+    - pyPDAF.PDAF.assim.assimilate_netf
+    - pyPDAF.PDAF.assim.assimilate_pf
+    - pyPDAF.PDAF.assim.assimilate_prepost
+    - pyPDAF.PDAF.assim.assimilate_seik
+    - pyPDAF.PDAF.assim.generate_obs
+    - pyPDAF.PDAF.assim.generate_obs_offline
+    - pyPDAF.PDAF.assim.get_state
+
+### pyPDAF.PDAF.callback
+    - pyPDAF.PDAF.callback.add_obs_error_cb
+    - pyPDAF.PDAF.callback.g2l_obs_cb
+    - pyPDAF.PDAF.callback.init_obs_f_cb
+    - pyPDAF.PDAF.callback.init_obs_l_cb
+    - pyPDAF.PDAF.callback.init_obscovar_cb
+    - pyPDAF.PDAF.callback.init_obserr_f_cb
+    - pyPDAF.PDAF.callback.init_obsvar_cb
+    - pyPDAF.PDAF.callback.init_obsvar_l_cb
+    - pyPDAF.PDAF.callback.init_obsvars_f_cb
+    - pyPDAF.PDAF.callback.likelihood_cb
+    - pyPDAF.PDAF.callback.likelihood_hyb_l_cb
+    - pyPDAF.PDAF.callback.likelihood_l_cb
+    - pyPDAF.PDAF.callback.localize_covar_cb
+    - pyPDAF.PDAF.callback.localize_covar_serial_cb
+    - pyPDAF.PDAF.callback.omit_by_inno_cb
+    - pyPDAF.PDAF.callback.omit_by_inno_l_cb
+    - pyPDAF.PDAF.callback.prodrinva_cb
+    - pyPDAF.PDAF.callback.prodrinva_hyb_l_cb
+    - pyPDAF.PDAF.callback.prodrinva_l_cb
+
+### pyPDAF.PDAF.diag
+    - pyPDAF.PDAF.diag.diag_compute_moments
+    - pyPDAF.PDAF.diag.diag_crps_mpi
+    - pyPDAF.PDAF.diag.diag_crps_nompi
+    - pyPDAF.PDAF.diag.diag_effsample
+    - pyPDAF.PDAF.diag.diag_ensmean
+    - pyPDAF.PDAF.diag.diag_ensstats
+    - pyPDAF.PDAF.diag.diag_histogram
+    - pyPDAF.PDAF.diag.diag_reliability_budget
+    - pyPDAF.PDAF.diag.diag_rmsd
+    - pyPDAF.PDAF.diag.diag_rmsd_nompi
+    - pyPDAF.PDAF.diag.diag_stddev
+    - pyPDAF.PDAF.diag.diag_stddev_nompi
+    - pyPDAF.PDAF.diag.diag_variance
+    - pyPDAF.PDAF.diag.diag_variance_nompi
+
+### pyPDAF.PDAF.get
+    - pyPDAF.PDAF.get.get_assim_flag
+    - pyPDAF.PDAF.get.get_local_type
+    - pyPDAF.PDAF.get.get_localfilter
+    - pyPDAF.PDAF.get.get_memberid
+    - pyPDAF.PDAF.get.get_obsmemberid
+    - pyPDAF.PDAF.get.get_smoother_ens
+
+### pyPDAF.PDAF.iau_internal
+    - pyPDAF.PDAF.iau_internal.iau_add_inc_ens
+    - pyPDAF.PDAF.iau_internal.iau_dealloc
+    - pyPDAF.PDAF.iau_internal.iau_init_weights
+    - pyPDAF.PDAF.iau_internal.iau_update_ens
+    - pyPDAF.PDAF.iau_internal.iau_update_inc
+
+### pyPDAF.PDAF.iau
+    - pyPDAF.PDAF.iau.iau_add_inc
+    - pyPDAF.PDAF.iau.iau_init
+    - pyPDAF.PDAF.iau.iau_init_inc
+    - pyPDAF.PDAF.iau.iau_reset
+    - pyPDAF.PDAF.iau.iau_set_ens_pointer
+    - pyPDAF.PDAF.iau.iau_set_pointer
+    - pyPDAF.PDAF.iau.iau_set_state_pointer
+    - pyPDAF.PDAF.iau.iau_set_weights
+
+### pyPDAF.PDAF.internal
+    - pyPDAF.PDAF.internal._3dvar_alloc
+    - pyPDAF.PDAF.internal._3dvar_analysis_cvt
+    - pyPDAF.PDAF.internal._3dvar_config
+    - pyPDAF.PDAF.internal._3dvar_costf_cg_cvt
+    - pyPDAF.PDAF.internal._3dvar_costf_cvt
+    - pyPDAF.PDAF.internal._3dvar_init
+    - pyPDAF.PDAF.internal._3dvar_memtime
+    - pyPDAF.PDAF.internal._3dvar_optim_cg
+    - pyPDAF.PDAF.internal._3dvar_optim_cgplus
+    - pyPDAF.PDAF.internal._3dvar_optim_lbfgs
+    - pyPDAF.PDAF.internal._3dvar_options
+    - pyPDAF.PDAF.internal._3dvar_set_iparam
+    - pyPDAF.PDAF.internal._3dvar_set_rparam
+    - pyPDAF.PDAF.internal._3dvar_update
+    - pyPDAF.PDAF.internal.add_particle_noise
+    - pyPDAF.PDAF.internal.alloc
+    - pyPDAF.PDAF.internal.alloc_bias
+    - pyPDAF.PDAF.internal.alloc_filters
+    - pyPDAF.PDAF.internal.alloc_sens
+    - pyPDAF.PDAF.internal.allreduce
+    - pyPDAF.PDAF.internal.configinfo_filters
+    - pyPDAF.PDAF.internal.en3dvar_analysis_cvt
+    - pyPDAF.PDAF.internal.en3dvar_costf_cg_cvt
+    - pyPDAF.PDAF.internal.en3dvar_costf_cvt
+    - pyPDAF.PDAF.internal.en3dvar_optim_cg
+    - pyPDAF.PDAF.internal.en3dvar_optim_cgplus
+    - pyPDAF.PDAF.internal.en3dvar_optim_lbfgs
+    - pyPDAF.PDAF.internal.en3dvar_update_estkf
+    - pyPDAF.PDAF.internal.en3dvar_update_lestkf
+    - pyPDAF.PDAF.internal.enkf_alloc
+    - pyPDAF.PDAF.internal.enkf_ana_rlm
+    - pyPDAF.PDAF.internal.enkf_ana_rsm
+    - pyPDAF.PDAF.internal.enkf_config
+    - pyPDAF.PDAF.internal.enkf_gather_resid
+    - pyPDAF.PDAF.internal.enkf_init
+    - pyPDAF.PDAF.internal.enkf_memtime
+    - pyPDAF.PDAF.internal.enkf_obs_ensemble
+    - pyPDAF.PDAF.internal.enkf_options
+    - pyPDAF.PDAF.internal.enkf_set_iparam
+    - pyPDAF.PDAF.internal.enkf_set_rparam
+    - pyPDAF.PDAF.internal.enkf_update
+    - pyPDAF.PDAF.internal.ens_omega
+    - pyPDAF.PDAF.internal.ensrf_alloc
+    - pyPDAF.PDAF.internal.ensrf_ana
+    - pyPDAF.PDAF.internal.ensrf_ana_2step
+    - pyPDAF.PDAF.internal.ensrf_config
+    - pyPDAF.PDAF.internal.ensrf_init
+    - pyPDAF.PDAF.internal.ensrf_memtime
+    - pyPDAF.PDAF.internal.ensrf_options
+    - pyPDAF.PDAF.internal.ensrf_set_iparam
+    - pyPDAF.PDAF.internal.ensrf_set_rparam
+    - pyPDAF.PDAF.internal.ensrf_update
+    - pyPDAF.PDAF.internal.estkf_alloc
+    - pyPDAF.PDAF.internal.estkf_ana
+    - pyPDAF.PDAF.internal.estkf_ana_fixed
+    - pyPDAF.PDAF.internal.estkf_aomega
+    - pyPDAF.PDAF.internal.estkf_config
+    - pyPDAF.PDAF.internal.estkf_init
+    - pyPDAF.PDAF.internal.estkf_memtime
+    - pyPDAF.PDAF.internal.estkf_omegaa
+    - pyPDAF.PDAF.internal.estkf_options
+    - pyPDAF.PDAF.internal.estkf_set_iparam
+    - pyPDAF.PDAF.internal.estkf_set_rparam
+    - pyPDAF.PDAF.internal.estkf_update
+    - pyPDAF.PDAF.internal.etkf_alloc
+    - pyPDAF.PDAF.internal.etkf_ana
+    - pyPDAF.PDAF.internal.etkf_ana_fixed
+    - pyPDAF.PDAF.internal.etkf_ana_t
+    - pyPDAF.PDAF.internal.etkf_config
+    - pyPDAF.PDAF.internal.etkf_init
+    - pyPDAF.PDAF.internal.etkf_memtime
+    - pyPDAF.PDAF.internal.etkf_options
+    - pyPDAF.PDAF.internal.etkf_set_iparam
+    - pyPDAF.PDAF.internal.etkf_set_rparam
+    - pyPDAF.PDAF.internal.etkf_update
+    - pyPDAF.PDAF.internal.fcst_operations
+    - pyPDAF.PDAF.internal.gather_ens
+    - pyPDAF.PDAF.internal.gen_obs
+    - pyPDAF.PDAF.internal.generate_rndmat
+    - pyPDAF.PDAF.internal.genobs_alloc
+    - pyPDAF.PDAF.internal.genobs_config
+    - pyPDAF.PDAF.internal.genobs_init
+    - pyPDAF.PDAF.internal.genobs_options
+    - pyPDAF.PDAF.internal.genobs_set_iparam
+    - pyPDAF.PDAF.internal.get_ensstats
+    - pyPDAF.PDAF.internal.hyb3dvar_analysis_cvt
+    - pyPDAF.PDAF.internal.hyb3dvar_costf_cg_cvt
+    - pyPDAF.PDAF.internal.hyb3dvar_costf_cvt
+    - pyPDAF.PDAF.internal.hyb3dvar_optim_cg
+    - pyPDAF.PDAF.internal.hyb3dvar_optim_cgplus
+    - pyPDAF.PDAF.internal.hyb3dvar_optim_lbfgs
+    - pyPDAF.PDAF.internal.hyb3dvar_update_estkf
+    - pyPDAF.PDAF.internal.hyb3dvar_update_lestkf
+    - pyPDAF.PDAF.internal.incr_local_obsstats
+    - pyPDAF.PDAF.internal.inflate_ens
+    - pyPDAF.PDAF.internal.inflate_weights
+    - pyPDAF.PDAF.internal.init_filters
+    - pyPDAF.PDAF.internal.init_local_obsstats
+    - pyPDAF.PDAF.internal.init_parallel
+    - pyPDAF.PDAF.internal.lenkf_alloc
+    - pyPDAF.PDAF.internal.lenkf_ana_rsm
+    - pyPDAF.PDAF.internal.lenkf_config
+    - pyPDAF.PDAF.internal.lenkf_init
+    - pyPDAF.PDAF.internal.lenkf_memtime
+    - pyPDAF.PDAF.internal.lenkf_options
+    - pyPDAF.PDAF.internal.lenkf_set_iparam
+    - pyPDAF.PDAF.internal.lenkf_set_rparam
+    - pyPDAF.PDAF.internal.lenkf_update
+    - pyPDAF.PDAF.internal.lestkf_alloc
+    - pyPDAF.PDAF.internal.lestkf_ana
+    - pyPDAF.PDAF.internal.lestkf_ana_fixed
+    - pyPDAF.PDAF.internal.lestkf_config
+    - pyPDAF.PDAF.internal.lestkf_init
+    - pyPDAF.PDAF.internal.lestkf_memtime
+    - pyPDAF.PDAF.internal.lestkf_options
+    - pyPDAF.PDAF.internal.lestkf_set_iparam
+    - pyPDAF.PDAF.internal.lestkf_set_rparam
+    - pyPDAF.PDAF.internal.lestkf_update
+    - pyPDAF.PDAF.internal.letkf_alloc
+    - pyPDAF.PDAF.internal.letkf_ana
+    - pyPDAF.PDAF.internal.letkf_ana_fixed
+    - pyPDAF.PDAF.internal.letkf_ana_t
+    - pyPDAF.PDAF.internal.letkf_config
+    - pyPDAF.PDAF.internal.letkf_init
+    - pyPDAF.PDAF.internal.letkf_memtime
+    - pyPDAF.PDAF.internal.letkf_options
+    - pyPDAF.PDAF.internal.letkf_set_iparam
+    - pyPDAF.PDAF.internal.letkf_set_rparam
+    - pyPDAF.PDAF.internal.letkf_update
+    - pyPDAF.PDAF.internal.lknetf_alloc
+    - pyPDAF.PDAF.internal.lknetf_alpha_neff
+    - pyPDAF.PDAF.internal.lknetf_ana_letkft
+    - pyPDAF.PDAF.internal.lknetf_ana_lnetf
+    - pyPDAF.PDAF.internal.lknetf_analysis_t
+    - pyPDAF.PDAF.internal.lknetf_compute_gamma
+    - pyPDAF.PDAF.internal.lknetf_config
+    - pyPDAF.PDAF.internal.lknetf_init
+    - pyPDAF.PDAF.internal.lknetf_memtime
+    - pyPDAF.PDAF.internal.lknetf_options
+    - pyPDAF.PDAF.internal.lknetf_reset_gamma
+    - pyPDAF.PDAF.internal.lknetf_set_gamma
+    - pyPDAF.PDAF.internal.lknetf_set_iparam
+    - pyPDAF.PDAF.internal.lknetf_set_rparam
+    - pyPDAF.PDAF.internal.lknetf_update_step
+    - pyPDAF.PDAF.internal.lknetf_update_sync
+    - pyPDAF.PDAF.internal.lnetf_alloc
+    - pyPDAF.PDAF.internal.lnetf_ana
+    - pyPDAF.PDAF.internal.lnetf_config
+    - pyPDAF.PDAF.internal.lnetf_init
+    - pyPDAF.PDAF.internal.lnetf_memtime
+    - pyPDAF.PDAF.internal.lnetf_options
+    - pyPDAF.PDAF.internal.lnetf_set_iparam
+    - pyPDAF.PDAF.internal.lnetf_set_rparam
+    - pyPDAF.PDAF.internal.lnetf_smoothert
+    - pyPDAF.PDAF.internal.lnetf_update
+    - pyPDAF.PDAF.internal.lseik_alloc
+    - pyPDAF.PDAF.internal.lseik_ana
+    - pyPDAF.PDAF.internal.lseik_ana_trans
+    - pyPDAF.PDAF.internal.lseik_config
+    - pyPDAF.PDAF.internal.lseik_init
+    - pyPDAF.PDAF.internal.lseik_memtime
+    - pyPDAF.PDAF.internal.lseik_options
+    - pyPDAF.PDAF.internal.lseik_resample
+    - pyPDAF.PDAF.internal.lseik_set_iparam
+    - pyPDAF.PDAF.internal.lseik_set_rparam
+    - pyPDAF.PDAF.internal.lseik_update
+    - pyPDAF.PDAF.internal.memcount
+    - pyPDAF.PDAF.internal.memcount_define
+    - pyPDAF.PDAF.internal.memcount_ini
+    - pyPDAF.PDAF.internal.mpi_init
+    - pyPDAF.PDAF.internal.mvnormalize
+    - pyPDAF.PDAF.internal.netf_alloc
+    - pyPDAF.PDAF.internal.netf_ana
+    - pyPDAF.PDAF.internal.netf_config
+    - pyPDAF.PDAF.internal.netf_init
+    - pyPDAF.PDAF.internal.netf_memtime
+    - pyPDAF.PDAF.internal.netf_options
+    - pyPDAF.PDAF.internal.netf_set_iparam
+    - pyPDAF.PDAF.internal.netf_set_rparam
+    - pyPDAF.PDAF.internal.netf_smoothert
+    - pyPDAF.PDAF.internal.netf_update
+    - pyPDAF.PDAF.internal.obs_dealloc
+    - pyPDAF.PDAF.internal.obs_dealloc_local
+    - pyPDAF.PDAF.internal.obs_init
+    - pyPDAF.PDAF.internal.obs_init_local
+    - pyPDAF.PDAF.internal.obs_init_obsvars
+    - pyPDAF.PDAF.internal.options_filters
+    - pyPDAF.PDAF.internal.pf_alloc
+    - pyPDAF.PDAF.internal.pf_ana
+    - pyPDAF.PDAF.internal.pf_config
+    - pyPDAF.PDAF.internal.pf_init
+    - pyPDAF.PDAF.internal.pf_memtime
+    - pyPDAF.PDAF.internal.pf_options
+    - pyPDAF.PDAF.internal.pf_resampling
+    - pyPDAF.PDAF.internal.pf_set_iparam
+    - pyPDAF.PDAF.internal.pf_set_rparam
+    - pyPDAF.PDAF.internal.pf_update
+    - pyPDAF.PDAF.internal.prepost
+    - pyPDAF.PDAF.internal.print_domain_stats
+    - pyPDAF.PDAF.internal.print_info_filters
+    - pyPDAF.PDAF.internal.print_local_obsstats
+    - pyPDAF.PDAF.internal.print_version
+    - pyPDAF.PDAF.internal.reset_dim_ens
+    - pyPDAF.PDAF.internal.reset_dim_p
+    - pyPDAF.PDAF.internal.scatter_ens
+    - pyPDAF.PDAF.internal.seik_alloc
+    - pyPDAF.PDAF.internal.seik_ana
+    - pyPDAF.PDAF.internal.seik_ana_newt
+    - pyPDAF.PDAF.internal.seik_ana_trans
+    - pyPDAF.PDAF.internal.seik_config
+    - pyPDAF.PDAF.internal.seik_init
+    - pyPDAF.PDAF.internal.seik_matrixt
+    - pyPDAF.PDAF.internal.seik_memtime
+    - pyPDAF.PDAF.internal.seik_omega
+    - pyPDAF.PDAF.internal.seik_options
+    - pyPDAF.PDAF.internal.seik_resample
+    - pyPDAF.PDAF.internal.seik_resample_newt
+    - pyPDAF.PDAF.internal.seik_set_iparam
+    - pyPDAF.PDAF.internal.seik_set_rparam
+    - pyPDAF.PDAF.internal.seik_ttimesa
+    - pyPDAF.PDAF.internal.seik_uinv
+    - pyPDAF.PDAF.internal.seik_update
+    - pyPDAF.PDAF.internal.set_forget
+    - pyPDAF.PDAF.internal.set_forget_local
+    - pyPDAF.PDAF.internal.set_iparam_filters
+    - pyPDAF.PDAF.internal.set_rparam_filters
+    - pyPDAF.PDAF.internal.sisort
+    - pyPDAF.PDAF.internal.smoother_enkf
+    - pyPDAF.PDAF.internal.smoother_lnetf
+    - pyPDAF.PDAF.internal.smoother_netf
+    - pyPDAF.PDAF.internal.smoother_shift
+    - pyPDAF.PDAF.internal.smoothing
+    - pyPDAF.PDAF.internal.smoothing_local
+    - pyPDAF.PDAF.internal.subtract_colmean
+    - pyPDAF.PDAF.internal.subtract_rowmean
+    - pyPDAF.PDAF.internal.timeit
+
+### pyPDAF.PDAF.put
+    - pyPDAF.PDAF.put.put_state_3dvar
+    - pyPDAF.PDAF.put.put_state_en3dvar_estkf
+    - pyPDAF.PDAF.put.put_state_en3dvar_lestkf
+    - pyPDAF.PDAF.put.put_state_enkf
+    - pyPDAF.PDAF.put.put_state_ensrf
+    - pyPDAF.PDAF.put.put_state_estkf
+    - pyPDAF.PDAF.put.put_state_etkf
+    - pyPDAF.PDAF.put.put_state_generate_obs
+    - pyPDAF.PDAF.put.put_state_hyb3dvar_estkf
+    - pyPDAF.PDAF.put.put_state_hyb3dvar_lestkf
+    - pyPDAF.PDAF.put.put_state_lenkf
+    - pyPDAF.PDAF.put.put_state_lestkf
+    - pyPDAF.PDAF.put.put_state_letkf
+    - pyPDAF.PDAF.put.put_state_lknetf
+    - pyPDAF.PDAF.put.put_state_lnetf
+    - pyPDAF.PDAF.put.put_state_lseik
+    - pyPDAF.PDAF.put.put_state_netf
+    - pyPDAF.PDAF.put.put_state_pf
+    - pyPDAF.PDAF.put.put_state_prepost
+    - pyPDAF.PDAF.put.put_state_seik
+
+### pyPDAF.PDAF.setter
+    - pyPDAF.PDAF.setter.set_comm_pdaf
+    - pyPDAF.PDAF.setter.set_debug_flag
+    - pyPDAF.PDAF.setter.set_ens_pointer
+    - pyPDAF.PDAF.setter.set_iparam
+    - pyPDAF.PDAF.setter.set_memberid
+    - pyPDAF.PDAF.setter.set_offline_mode
+    - pyPDAF.PDAF.setter.set_rparam
+    - pyPDAF.PDAF.setter.set_seedset
+    - pyPDAF.PDAF.setter.set_smoother_ens
+
+## pyPDAF.PDAF3
+### pyPDAF.PDAF3._pdaf3_c
+    - pyPDAF.PDAF3._pdaf3_c.init
+    - pyPDAF.PDAF3._pdaf3_c.init_forecast
+    - pyPDAF.PDAF3._pdaf3_c.set_parallel
+
+### pyPDAF.PDAF3.assim
+    - pyPDAF.PDAF3.assim.assim_offline
+    - pyPDAF.PDAF3.assim.assim_offline_3dvar
+    - pyPDAF.PDAF3.assim.assim_offline_3dvar_all
+    - pyPDAF.PDAF3.assim.assim_offline_3dvar_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_en3dvar
+    - pyPDAF.PDAF3.assim.assim_offline_en3dvar_estkf
+    - pyPDAF.PDAF3.assim.assim_offline_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_en3dvar_lestkf
+    - pyPDAF.PDAF3.assim.assim_offline_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_enkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_ensrf
+    - pyPDAF.PDAF3.assim.assim_offline_global
+    - pyPDAF.PDAF3.assim.assim_offline_global_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_hyb3dvar
+    - pyPDAF.PDAF3.assim.assim_offline_hyb3dvar_estkf
+    - pyPDAF.PDAF3.assim.assim_offline_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_hyb3dvar_lestkf
+    - pyPDAF.PDAF3.assim.assim_offline_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_lenkf
+    - pyPDAF.PDAF3.assim.assim_offline_lenkf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_lknetf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_lnetf_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_local
+    - pyPDAF.PDAF3.assim.assim_offline_local_nondiagr
+    - pyPDAF.PDAF3.assim.assim_offline_nonlin_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate
+    - pyPDAF.PDAF3.assim.assimilate_3dvar
+    - pyPDAF.PDAF3.assim.assimilate_3dvar_all
+    - pyPDAF.PDAF3.assim.assimilate_3dvar_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_en3dvar
+    - pyPDAF.PDAF3.assim.assimilate_en3dvar_estkf
+    - pyPDAF.PDAF3.assim.assimilate_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAF3.assim.assimilate_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_enkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_ensrf
+    - pyPDAF.PDAF3.assim.assimilate_global
+    - pyPDAF.PDAF3.assim.assimilate_global_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_hyb3dvar
+    - pyPDAF.PDAF3.assim.assimilate_hyb3dvar_estkf
+    - pyPDAF.PDAF3.assim.assimilate_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAF3.assim.assimilate_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_lenkf
+    - pyPDAF.PDAF3.assim.assimilate_lenkf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_lknetf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_lnetf_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_local
+    - pyPDAF.PDAF3.assim.assimilate_local_nondiagr
+    - pyPDAF.PDAF3.assim.assimilate_nonlin_nondiagr
+    - pyPDAF.PDAF3.assim.generate_obs
+    - pyPDAF.PDAF3.assim.generate_obs_offline
+
+### pyPDAF.PDAF3.put
+    - pyPDAF.PDAF3.put.put_state
+    - pyPDAF.PDAF3.put.put_state_3dvar
+    - pyPDAF.PDAF3.put.put_state_3dvar_all
+    - pyPDAF.PDAF3.put.put_state_3dvar_nondiagr
+    - pyPDAF.PDAF3.put.put_state_en3dvar
+    - pyPDAF.PDAF3.put.put_state_en3dvar_estkf
+    - pyPDAF.PDAF3.put.put_state_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_en3dvar_lestkf
+    - pyPDAF.PDAF3.put.put_state_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_enkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_ensrf
+    - pyPDAF.PDAF3.put.put_state_generate_obs
+    - pyPDAF.PDAF3.put.put_state_global
+    - pyPDAF.PDAF3.put.put_state_global_nondiagr
+    - pyPDAF.PDAF3.put.put_state_hyb3dvar
+    - pyPDAF.PDAF3.put.put_state_hyb3dvar_estkf
+    - pyPDAF.PDAF3.put.put_state_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_hyb3dvar_lestkf
+    - pyPDAF.PDAF3.put.put_state_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_lenkf
+    - pyPDAF.PDAF3.put.put_state_lenkf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_lknetf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_lnetf_nondiagr
+    - pyPDAF.PDAF3.put.put_state_local
+    - pyPDAF.PDAF3.put.put_state_local_nondiagr
+    - pyPDAF.PDAF3.put.put_state_nonlin_nondiagr
+
+## pyPDAF.PDAFlocal
+### pyPDAF.PDAFlocal._pdaflocal_c
+    - pyPDAF.PDAFlocal._pdaflocal_c.clear_increment_weights
+    - pyPDAF.PDAFlocal._pdaflocal_c.set_increment_weights
+    - pyPDAF.PDAFlocal._pdaflocal_c.set_indices
+
+### pyPDAF.PDAFlocal.assim
+    - pyPDAF.PDAFlocal.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAFlocal.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAFlocal.assim.assimilate_lestkf
+    - pyPDAF.PDAFlocal.assim.assimilate_letkf
+    - pyPDAF.PDAFlocal.assim.assimilate_lknetf
+    - pyPDAF.PDAFlocal.assim.assimilate_lnetf
+    - pyPDAF.PDAFlocal.assim.assimilate_lseik
+
+### pyPDAF.PDAFlocal.internal
+    - pyPDAF.PDAFlocal.internal.g2l_cb
+    - pyPDAF.PDAFlocal.internal.l2g_cb
+
+### pyPDAF.PDAFlocal.put
+    - pyPDAF.PDAFlocal.put.put_state_en3dvar_lestkf
+    - pyPDAF.PDAFlocal.put.put_state_hyb3dvar_lestkf
+    - pyPDAF.PDAFlocal.put.put_state_lestkf
+    - pyPDAF.PDAFlocal.put.put_state_letkf
+    - pyPDAF.PDAFlocal.put.put_state_lknetf
+    - pyPDAF.PDAFlocal.put.put_state_lnetf
+    - pyPDAF.PDAFlocal.put.put_state_lseik
+
+## pyPDAF.PDAFlocalomi
+### pyPDAF.PDAFlocalomi.assim
+    - pyPDAF.PDAFlocalomi.assim.assimilate
+    - pyPDAF.PDAFlocalomi.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAFlocalomi.assim.assimilate_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFlocalomi.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAFlocalomi.assim.assimilate_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFlocalomi.assim.assimilate_lknetf_nondiagr
+    - pyPDAF.PDAFlocalomi.assim.assimilate_lnetf_nondiagr
+    - pyPDAF.PDAFlocalomi.assim.assimilate_nondiagr
+
+### pyPDAF.PDAFlocalomi.put
+    - pyPDAF.PDAFlocalomi.put.put_state
+    - pyPDAF.PDAFlocalomi.put.put_state_en3dvar_lestkf
+    - pyPDAF.PDAFlocalomi.put.put_state_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFlocalomi.put.put_state_hyb3dvar_lestkf
+    - pyPDAF.PDAFlocalomi.put.put_state_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFlocalomi.put.put_state_lknetf_nondiagr
+    - pyPDAF.PDAFlocalomi.put.put_state_lnetf_nondiagr
+    - pyPDAF.PDAFlocalomi.put.put_state_nondiagr
+
+
+## pyPDAF.PDAFomi
+### pyPDAF.PDAFomi._pdafomi_c
+    - pyPDAF.PDAFomi._pdafomi_c.check_error
+    - pyPDAF.PDAFomi._pdafomi_c.gather_obs
+    - pyPDAF.PDAFomi._pdafomi_c.gather_obsstate
+    - pyPDAF.PDAFomi._pdafomi_c.get_domain_limits_unstr
+    - pyPDAF.PDAFomi._pdafomi_c.get_interp_coeff_lin
+    - pyPDAF.PDAFomi._pdafomi_c.get_interp_coeff_lin1d
+    - pyPDAF.PDAFomi._pdafomi_c.get_interp_coeff_tri
+    - pyPDAF.PDAFomi._pdafomi_c.init
+    - pyPDAF.PDAFomi._pdafomi_c.init_dim_obs_l_iso
+    - pyPDAF.PDAFomi._pdafomi_c.init_dim_obs_l_noniso
+    - pyPDAF.PDAFomi._pdafomi_c.init_dim_obs_l_noniso_locweights
+    - pyPDAF.PDAFomi._pdafomi_c.init_local
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_adj_gridavg
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_adj_gridpoint
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_adj_interp_lin
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_extern
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_gridavg
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_gridpoint
+    - pyPDAF.PDAFomi._pdafomi_c.obs_op_interp_lin
+    - pyPDAF.PDAFomi._pdafomi_c.observation_localization_weights
+    - pyPDAF.PDAFomi._pdafomi_c.set_debug_flag
+    - pyPDAF.PDAFomi._pdafomi_c.set_dim_obs_l
+    - pyPDAF.PDAFomi._pdafomi_c.set_domain_limits
+    - pyPDAF.PDAFomi._pdafomi_c.set_localization
+    - pyPDAF.PDAFomi._pdafomi_c.set_localization_noniso
+    - pyPDAF.PDAFomi._pdafomi_c.set_localize_covar_iso
+    - pyPDAF.PDAFomi._pdafomi_c.set_localize_covar_noniso
+    - pyPDAF.PDAFomi._pdafomi_c.set_localize_covar_noniso_locweights
+    - pyPDAF.PDAFomi._pdafomi_c.set_obs_diag
+    - pyPDAF.PDAFomi._pdafomi_c.store_obs_l_index
+    - pyPDAF.PDAFomi._pdafomi_c.store_obs_l_index_vdist
+
+### pyPDAF.PDAFomi.assim
+    - pyPDAF.PDAFomi.assim.assimilate_3dvar
+    - pyPDAF.PDAFomi.assim.assimilate_3dvar_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_estkf
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_enkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_ensrf
+    - pyPDAF.PDAFomi.assim.assimilate_global
+    - pyPDAF.PDAFomi.assim.assimilate_global_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_estkf
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lenkf
+    - pyPDAF.PDAFomi.assim.assimilate_lenkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lknetf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lnetf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_local
+    - pyPDAF.PDAFomi.assim.assimilate_local_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_nonlin_nondiagr
+    - pyPDAF.PDAFomi.assim.generate_obs
+
+### pyPDAF.PDAFomi.diag
+    - pyPDAF.PDAFomi.diag.diag_dimobs
+    - pyPDAF.PDAFomi.diag.diag_get_hx
+    - pyPDAF.PDAFomi.diag.diag_get_hxmean
+    - pyPDAF.PDAFomi.diag.diag_get_ivar
+    - pyPDAF.PDAFomi.diag.diag_get_obs
+    - pyPDAF.PDAFomi.diag.diag_nobstypes
+    - pyPDAF.PDAFomi.diag.diag_obs_rmsd
+    - pyPDAF.PDAFomi.diag.diag_stats
+
+### pyPDAF.PDAFomi.internal
+    - pyPDAF.PDAFomi.internal.add_obs_error
+    - pyPDAF.PDAFomi.internal.check_dist2
+    - pyPDAF.PDAFomi.internal.check_dist2_loop
+    - pyPDAF.PDAFomi.internal.check_dist2_noniso
+    - pyPDAF.PDAFomi.internal.check_dist2_noniso_loop
+    - pyPDAF.PDAFomi.internal.cnt_dim_obs_l
+    - pyPDAF.PDAFomi.internal.cnt_dim_obs_l_noniso
+    - pyPDAF.PDAFomi.internal.comp_dist2
+    - pyPDAF.PDAFomi.internal.dealloc
+    - pyPDAF.PDAFomi.internal.diag_omit_by_inno
+    - pyPDAF.PDAFomi.internal.g2l_obs
+    - pyPDAF.PDAFomi.internal.g2l_obs_internal
+    - pyPDAF.PDAFomi.internal.gather_dim_obs_f
+    - pyPDAF.PDAFomi.internal.gather_obs_f2_flex
+    - pyPDAF.PDAFomi.internal.gather_obs_f_flex
+    - pyPDAF.PDAFomi.internal.gather_obsdims
+    - pyPDAF.PDAFomi.internal.get_local_ids_obs_f
+    - pyPDAF.PDAFomi.internal.init_obs_f
+    - pyPDAF.PDAFomi.internal.init_obs_l
+    - pyPDAF.PDAFomi.internal.init_obsarrays_l
+    - pyPDAF.PDAFomi.internal.init_obsarrays_l_noniso
+    - pyPDAF.PDAFomi.internal.init_obscovar
+    - pyPDAF.PDAFomi.internal.init_obserr_f
+    - pyPDAF.PDAFomi.internal.init_obsvar_f
+    - pyPDAF.PDAFomi.internal.init_obsvar_l
+    - pyPDAF.PDAFomi.internal.init_obsvars_f
+    - pyPDAF.PDAFomi.internal.likelihood
+    - pyPDAF.PDAFomi.internal.likelihood_hyb_l
+    - pyPDAF.PDAFomi.internal.likelihood_l
+    - pyPDAF.PDAFomi.internal.limit_obs_f
+    - pyPDAF.PDAFomi.internal.local_weight
+    - pyPDAF.PDAFomi.internal.obs_op_adj_gatheronly
+    - pyPDAF.PDAFomi.internal.obs_op_gatheronly
+    - pyPDAF.PDAFomi.internal.obsstats
+    - pyPDAF.PDAFomi.internal.obsstats_l
+    - pyPDAF.PDAFomi.internal.ocoord_all
+    - pyPDAF.PDAFomi.internal.omit_by_inno
+    - pyPDAF.PDAFomi.internal.omit_by_inno_l
+    - pyPDAF.PDAFomi.internal.prodrinva
+    - pyPDAF.PDAFomi.internal.prodrinva_hyb_l
+    - pyPDAF.PDAFomi.internal.prodrinva_l
+    - pyPDAF.PDAFomi.internal.set_globalobs
+    - pyPDAF.PDAFomi.internal.weights_l
+    - pyPDAF.PDAFomi.internal.weights_l_sgnl
+
+### pyPDAF.PDAFomi.legacy
+    - pyPDAF.PDAFomi.legacy.deallocate_obs
+    - pyPDAF.PDAFomi.legacy.init_dim_obs_l_iso_old
+    - pyPDAF.PDAFomi.legacy.init_dim_obs_l_noniso_locweights_old
+    - pyPDAF.PDAFomi.legacy.init_dim_obs_l_noniso_old
+    - pyPDAF.PDAFomi.legacy.localize_covar_iso
+    - pyPDAF.PDAFomi.legacy.localize_covar_noniso
+    - pyPDAF.PDAFomi.legacy.localize_covar_noniso_locweights
+    - pyPDAF.PDAFomi.legacy.localize_covar_serial_iso
+    - pyPDAF.PDAFomi.legacy.localize_covar_serial_noniso
+    - pyPDAF.PDAFomi.legacy.localize_covar_serial_noniso_locweights
+
+### pyPDAF.PDAFomi.assim
+    - pyPDAF.PDAFomi.assim.assimilate_3dvar
+    - pyPDAF.PDAFomi.assim.assimilate_3dvar_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_estkf
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_lestkf
+    - pyPDAF.PDAFomi.assim.assimilate_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_enkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_ensrf
+    - pyPDAF.PDAFomi.assim.assimilate_global
+    - pyPDAF.PDAFomi.assim.assimilate_global_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_estkf
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_lestkf
+    - pyPDAF.PDAFomi.assim.assimilate_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lenkf
+    - pyPDAF.PDAFomi.assim.assimilate_lenkf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lknetf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_lnetf_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_local
+    - pyPDAF.PDAFomi.assim.assimilate_local_nondiagr
+    - pyPDAF.PDAFomi.assim.assimilate_nonlin_nondiagr
+    - pyPDAF.PDAFomi.assim.generate_obs
+
+### pyPDAF.PDAFomi.put
+    - pyPDAF.PDAFomi.put.put_state_3dvar
+    - pyPDAF.PDAFomi.put.put_state_3dvar_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_en3dvar_estkf
+    - pyPDAF.PDAFomi.put.put_state_en3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_en3dvar_lestkf
+    - pyPDAF.PDAFomi.put.put_state_en3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_enkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_ensrf
+    - pyPDAF.PDAFomi.put.put_state_generate_obs
+    - pyPDAF.PDAFomi.put.put_state_global
+    - pyPDAF.PDAFomi.put.put_state_global_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_hyb3dvar_estkf
+    - pyPDAF.PDAFomi.put.put_state_hyb3dvar_estkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_hyb3dvar_lestkf
+    - pyPDAF.PDAFomi.put.put_state_hyb3dvar_lestkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_lenkf
+    - pyPDAF.PDAFomi.put.put_state_lenkf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_lknetf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_lnetf_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_local
+    - pyPDAF.PDAFomi.put.put_state_local_nondiagr
+    - pyPDAF.PDAFomi.put.put_state_nonlin_nondiagr
+
+### pyPDAF.PDAFomi.setter
+    - pyPDAF.PDAFomi.setter.set_disttype
+    - pyPDAF.PDAFomi.setter.set_doassim
+    - pyPDAF.PDAFomi.setter.set_domainsize
+    - pyPDAF.PDAFomi.setter.set_icoeff_p
+    - pyPDAF.PDAFomi.setter.set_id_obs_p
+    - pyPDAF.PDAFomi.setter.set_inno_omit
+    - pyPDAF.PDAFomi.setter.set_inno_omit_ivar
+    - pyPDAF.PDAFomi.setter.set_name
+    - pyPDAF.PDAFomi.setter.set_ncoord
+    - pyPDAF.PDAFomi.setter.set_obs_err_type
+    - pyPDAF.PDAFomi.setter.set_use_global_obs

pyPDAF/source/docs/source/index.rst

@@ -0,0 +1,21 @@
+.. pyPDAF documentation master file, created by
+   sphinx-quickstart on Mon May  9 15:24:06 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+pyPDAF - A Python interface to Parallel Data Assimilation Framework
+===================================================================
+.. include:: introduction.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   install
+   naming_convention
+   parallel
+   develop
+   API
+   user_functions
+   hidden_functions
+   links

pyPDAF/source/docs/source/install.md

@@ -0,0 +1,74 @@
+
+# Installation
+
+There are two ways of installing pyPDAF.
+
+## Conda
+The easiest approach is using `conda`. Currently, `pyPDAF` is available from
+`conda` for `Windows`, `Linux` and `MacOS`. The installation can be obtained via:
+```bash
+conda create -n pypdaf -c conda-forge yumengch::pypdaf
+```
+After installation, `pyPDAF` can be used by activating the conda environment
+`conda activate pypdaf`.
+
+## Source code
+In some cases, it is desirable to compile pyPDAF so that one can use their
+favourite compiler as well as MPI and BLAS implementation.
+
+In this case, pyPDAF source code can be obtained from source
+```bash
+git clone --recurse-submodules https://github.com/yumengch/pyPDAF.git
+cd pyPDAF
+```
+
+The package can be installed with:
+```bash
+python -m pip install . -v \
+    --config-settings=setup-args="-Dblas_lib=[LIBS]" \
+    --config-settings=setup-args="-Dincdirs=[INCDIRS]" \
+    --config-settings=setup-args="-Dlibdirs=[LIBDIRS]" \
+    --config-settings=setup-args="-Dmpi_mod=MPIF90"^
+    --config-settings=setup-args="-Dbuildtype=release"
+```
+Here, `LIBS`, `INCDIRS`, and `LIBDIRS` are elements of a list, separated by
+`,` similar to a Python list.
+   - `LIBS` are all the required library names for BLAS libraries.
+   - `LIBDIRS` are directories of these libraries
+   - `INCDIRS` are include directories of libraries
+   - `MPIF90` is the path to `mpi.f90`. This is useful for the case where
+     `mpi.mod` is not directly provided but requires compiling by the user. This
+     is optional.
+
+One can adjust the compiler, compiler and linker flags by changing environment
+variables such as `CC`, `FC`, `CFLAGS` and `FCFLAGS`. See [flags](https://mesonbuild.com/Reference-tables.html#compiler-and-linker-flag-environment-variables) and [compiler](https://mesonbuild.com/Reference-tables.html#compiler-and-linker-selection-variables) table for references. One could also directly
+modify [`meson.build`](https://github.com/yumengch/pyPDAF/blob/main/meson.build) which might require more knowledge of meson.
+
+An example of installing pyPDAF in Linux or Mac:
+```bash
+CC=mpicc FC=mpifort python -m pip install . -v -Cbuild-dir=build \
+    --config-settings=setup-args="-Dblas_lib=['openblas']" \
+    --config-settings=setup-args="-Dincdirs=['/usr/lib/']" \
+    --config-settings=setup-args="-Dlibdirs=['/usr/include']" \
+    --config-settings=setup-args="-Dbuildtype=release"
+```
+In Windows, one can use
+```console
+set CXX=clang-cl
+set CC=clang-cl
+set FC=flang-new
+set MSMPI_INC=C:\Program Files (x86)\Microsoft SDKs\MPI\Include
+set MSMPI_LIB64=C:\Program Files (x86)\Microsoft SDKs\MPI\Lib\x64
+
+python -m pip install . -v ^
+    -Cbuild-dir=build --config-settings=setup-args="-Dblas_lib=openblas"^
+    --config-settings=setup-args="-Dincdirs="C:\Program Files (x86)\blas\include"^
+    --config-settings=setup-args="-Dlibdirs="C:\Program Files (x86)\blas\lib"^
+    --config-settings=setup-args="-Dmpi_mod=C:\Program Files (x86)\Microsoft SDKs\MPI\Include\mpi.f90"^
+    --config-settings=setup-args="-Dbuildtype=release"
+```
+where the variable `MSMPI_INC` and `MSMPI_LIB64` are required environment
+variable for using `MSMPI`.
+
+Please [raise an issue](https://github.com/yumengch/pyPDAF/issues/new) if you
+have any questions or problems with this.

pyPDAF/source/docs/source/introduction.md

@@ -0,0 +1,39 @@
+pyPDAF is a Python interface to the `Parallel Data Assimilation Framwork (PDAF) <http://pdaf.awi.de/trac/wiki>`_ written in Fortran.
+The latest pyPDAF supports PDAF-V3.0.
+
+As an interface to PDAF, pyPDAF supports all PDAF functionalities. You can use pyPDAF to construct
+a parallel ensemble data assimilation system purely in Python. The pyPDAF is designed as a framework
+that defines the workflow of given DA algorithms. Considering the versatility of the software,
+information on the model and observations are passed to the DA algorithms through user-supplied
+functions. With pyPDAF, all user-supplied functions can be implemented in Python. We expect that
+the coding of the user-supplied functions will be easier and more flexible than in Fortran due to
+the rich Python ecosystem.
+
+pyPDAF can be used with two modes:
+  - online mode: DA is performed without interrupting the model program. Here, the model code is
+    extended by calling PDAF functions to generate a single program. In online mode,
+    the filtering gets the model state and distributes the analysis to model by in-memory exchange.
+    This is the recommended mode for better efficiency.
+  - offline mode: DA is performed after the model program is finished. Here, a separate program
+    is generated to perform DA. In offline mode,
+    the filtering reads the model state from disk and writes the analysis to disk.
+
+
+The potential applications of pyPDAF include:
+  - online DA systems with Python models, e.g., machine-learning models
+  - offline DA systems
+
+This is a great tool for researchers who want to test and develop new DA systems.
+Compared to Fortran systems, the efficiency is decreased mainly from user-supplied functions
+and overhead for array conversions between Fortran and Python. The core DA algorithms are
+as efficient as in PDAF. Note that, for computational
+intensive user-supplied functions, the efficiency can be improved by using just-in-time compilation
+tools such as `numba`.
+
+To get started, we highly recommend to start from the Jupyter notebook
+example for
+`a serial ensemble DA system using a simple wave model <https://github.com/yumengch/pyPDAF/blob/main/tutorials/tutorial1_serial.ipynb>`_.
+
+We also provide more structured offline and online examples. One can adapt these examples based on their needs
+  - `A parallel online ensemble DA system using a simple wave model <https://github.com/yumengch/pyPDAF/tree/main/example/online>`_
+  - `A parallel offline ensemble DA system using a simple wave model <https://github.com/yumengch/pyPDAF/tree/main/example/offline>`_