Add more examples

environment.yml

@@ -2,9 +2,16 @@ channels:
 - conda-forge
 dependencies:
 - python =3.12
-- myqueue
-- rich
-- pip
-- matplotlib
+- myqueue =26.3.0
+- rich =15.0.0
+- texteditor =1.4.1
+- pip =25.2
+- ase=3.24.0
+- matplotlib=3.10.1
+- xmlschema=3.4.3
+- optimade=1.2.3
+- qe=7.5
+- qe-tools=2.0.0
+- conda_subprocess =0.0.11
 - pip:
   - git+https://gitlab.com/asm-dtu/perqueue.git

nfdi/source/envs/postprocessing.yaml

@@ -0,0 +1,5 @@
+channels:
+  - conda-forge
+dependencies:
+  - paraview=5.9.1=hfc1cbd4_3_egl
+  - tectonic=0.8.0=ha1fef3e_1

nfdi/source/envs/preprocessing.yaml

@@ -0,0 +1,5 @@
+channels:
+  - conda-forge
+dependencies:
+  - gmsh=4.6.0=hd134328_0
+  - meshio=5.0.5=pyhd8ed1ab_0

nfdi/source/envs/processing.yaml

@@ -0,0 +1,5 @@
+channels:
+  - conda-forge
+dependencies:
+  - fenics=2019.1.0=py39hf3d152e_26
+  - sympy=1.13.3

nfdi/source/macros.tex.template

@@ -0,0 +1,3 @@
+\newcommand{\domainSize}{${DOMAINSIZE}}
+\newcommand{\numDofs}{${NUMDOFS}}
+\newcommand{\plotDataPath}{${PLOTDATAPATH}}

nfdi/source/paper.tex

@@ -0,0 +1,22 @@
+\documentclass[12pt]{article}
+\usepackage{graphicx}
+\usepackage{pgfplots}
+
+\input{macros}
+
+\title{An exemplary workflow}
+
+\begin{document}
+\maketitle
+
+\begin{figure}[h]
+    \centering%
+    \begin{tikzpicture}
+        \begin{axis}[]
+            \addplot[color=red,smooth,thick] table[col sep=comma,header=true,x index=2,y index=0] {\plotDataPath};
+        \end{axis}
+    \end{tikzpicture}
+    \caption{Solution of the poisson equation over the line $L = \{(x, y)\in\Omega = {(0, \domainSize{})}^2 | x = y\}$ using \numDofs{} DoFs in the finite element model.}%
+\end{figure}
+
+\end{document}

nfdi/source/poisson.py

@@ -0,0 +1,108 @@
+"""
+solution of the poisson equation on the unit square
+"""
+
+from argparse import ArgumentParser
+import dolfin as df
+
+
+def boundary_expression():
+    """Defines the function to be used for the boundary conditions"""
+    return "1.0 + x[0] * x[0] + 2.0 * x[1] * x[1]"
+
+
+def solve_poisson(
+    meshfile: str, degree: int, bc_expression: str = boundary_expression()
+):
+    """solves the poisson equation
+
+    Parameters
+    ----------
+    meshfile : str
+        FilePath to the mesh in xdmf format.
+    degree : int
+        Degree of the finite element space.
+
+    Returns
+    -------
+    solution : df.Function
+    """
+    mesh = df.Mesh()
+    with df.XDMFFile(meshfile) as instream:
+        instream.read(mesh)
+    func_space = df.FunctionSpace(mesh, "CG", degree)
+    boundary_data = df.Expression(bc_expression, degree=2)
+
+    def boundary(_, on_boundary):
+        return on_boundary
+
+    boundary_conditions = df.DirichletBC(func_space, boundary_data, boundary)
+    trial_function = df.TrialFunction(func_space)
+    test_function = df.TestFunction(func_space)
+    source = df.Constant(-6.0)
+    lhs = df.dot(df.grad(trial_function), df.grad(test_function)) * df.dx
+    rhs = source * test_function * df.dx
+
+    solution = df.Function(func_space)
+    df.solve(lhs == rhs, solution, boundary_conditions)
+    return solution
+
+
+def solve_and_write_output(
+    mesh: str, degree: int, outputfile: str, numdofs=None, return_dofs=False
+):
+    """solves the poisson equation and writes the solution
+    and the number of degrees of freedom to the given file
+
+    Parameters
+    ----------
+    meshfile : str
+        FilePath to the mesh in xdmf format.
+    degree : int
+        Degree of the finite element space.
+    outputfile : str
+        FilePath to the output file into which the solution is written.
+    numdofs : optional, str
+        FilePath to which the number of degrees of freedom is written.
+    return_dofs : optional, bool
+        If True, return number of degrees of freedom.
+    """
+    discrete_solution = solve_poisson(mesh, degree)
+    discrete_solution.rename("u", discrete_solution.name())
+    resultFile = df.File(outputfile)
+    resultFile << discrete_solution
+
+    dofs = discrete_solution.function_space().dim()
+    print(f"Number of dofs used: {dofs}")
+
+    if numdofs is not None:
+        with open(numdofs, "w") as handle:
+            handle.write("{}\n".format(dofs))
+    if return_dofs:
+        return dofs
+
+
+if __name__ == "__main__":
+    PARSER = ArgumentParser(description="run script for the poisson problem")
+    PARSER.add_argument("-m", "--mesh", required=True, help="mesh file to be used")
+    PARSER.add_argument(
+        "-d", "--degree", required=True, help="polynomial order to be used"
+    )
+    PARSER.add_argument(
+        "-o",
+        "--outputfile",
+        required=True,
+        help="file name for the output to be written",
+    )
+    PARSER.add_argument(
+        "-n",
+        "--num-dofs",
+        required=False,
+        default=None,
+        help="file name for the number of DoFs to be written",
+    )
+    ARGS = vars(PARSER.parse_args())
+
+    solve_and_write_output(
+        ARGS["mesh"], int(ARGS["degree"]), ARGS["outputfile"], ARGS["num_dofs"]
+    )

nfdi/source/postprocessing.py

@@ -0,0 +1,54 @@
+"""
+$ pvbatch postprocessing.py -h
+"""
+
+import sys
+import argparse
+from paraview.simple import (
+    PlotOverLine,
+    PVDReader,
+    SaveData,
+    UpdatePipeline,
+)
+
+
+def main(args):
+    pvd_file = args.pvd
+    source = PVDReader(registrationName="poisson.pvd", FileName=[pvd_file])
+    source.PointArrays = [args.field]
+    UpdatePipeline()
+
+    (xmin, xmax, ymin, ymax, zmin, zmax) = source.GetDataInformation().GetBounds()
+    # init the 'Line' selected for 'Source'
+    plotOverLine1 = PlotOverLine(
+        registrationName="PlotOverLine1", Input=source, Source="Line"
+    )
+    plotOverLine1.Source.Point1 = [xmin, ymin, zmin]
+    plotOverLine1.Source.Point2 = [xmax, ymax, zmax]
+    UpdatePipeline()
+
+    # save data
+    SaveData(
+        args.csv,
+        proxy=plotOverLine1,
+        ChooseArraysToWrite=1,
+        PointDataArrays=["arc_length", args.field, "vtkValidPointMask"],
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog=f"pvbatch {__file__}",
+        description="Plots the solution over a line and writes the data to file.",
+        usage="%(prog)s [options] pvd csv",
+    )
+    parser.add_argument("pvd", type=str, help="The source pvd filepath.")
+    parser.add_argument("csv", type=str, help="The target csv filepath.")
+    parser.add_argument(
+        "--field",
+        type=str,
+        default="u",
+        help="Field variable to plot (default: u)",
+    )
+    args = parser.parse_args(sys.argv[1:])
+    main(args)

nfdi/source/prepare_paper_macros.py

@@ -0,0 +1,43 @@
+"""
+places the correct values into the paper macros template file
+"""
+
+import string
+import argparse
+
+PARSER = argparse.ArgumentParser(
+    description="Place computed values in the paper macros template file"
+)
+PARSER.add_argument(
+    "-f", "--macro-template-file",
+    required=False,  default="macros.tex.template",
+    help="The macro template file"
+)
+PARSER.add_argument(
+    "-o", "--output-macro-file",
+    required=False, default="macros.tex",
+    help="The macro file to be written"
+)
+PARSER.add_argument(
+    "-s", "--domain-size",
+    required=True, help="The computed domain size",
+)
+PARSER.add_argument(
+    "-n", "--num-dofs",
+    required=True, help="The computed number of dofs",
+)
+PARSER.add_argument(
+    "-p", "--plot-data-path",
+    required=True, help="The path to the data for the plot over line"
+)
+ARGS = vars(PARSER.parse_args())
+
+
+with open(ARGS["output_macro_file"], "w") as out_file:
+    with open(ARGS["macro_template_file"], "r") as in_file:
+        raw = string.Template(in_file.read())
+        out_file.write(raw.substitute({
+            "DOMAINSIZE": ARGS["domain_size"],
+            "NUMDOFS": ARGS["num_dofs"],
+            "PLOTDATAPATH": ARGS["plot_data_path"]
+        }))

nfdi/source/unit_square.geo

@@ -0,0 +1,9 @@
+DefineConstant[ domain_size = 1.0 ];
+DefineConstant[ mesh_size = domain_size/4.0 ];
+
+SetFactory("OpenCASCADE");
+Rectangle(1) = {0, 0, 0, domain_size, domain_size, 0};
+Physical Surface(1) = {1};
+
+Printf("Used domain size: %f", domain_size);
+Printf("Used mesh size: %f", mesh_size);

nfdi/workflow.json

@@ -0,0 +1,33 @@
+{
+  "version": "0.1.0",
+  "nodes": [
+    {"id": 0, "type": "function", "value": "workflow.generate_mesh"},
+    {"id": 1, "type": "function", "value": "workflow.convert_to_xdmf"},
+    {"id": 2, "type": "function", "value": "workflow.poisson"},
+    {"id": 3, "type":  "function", "value": "workflow.plot_over_line"},
+    {"id": 4, "type": "function", "value": "workflow.substitute_macros"},
+    {"id": 5, "type": "function", "value": "workflow.compile_paper"},
+    {"id": 6, "type": "input", "value": 2.0, "name": "domain_size"},
+    {"id": 7, "type": "input", "value": "source", "name": "source_directory"},
+    {"id": 8, "type": "output", "name": "result"}
+  ],
+  "edges": [
+    {"target": 0, "targetPort": "domain_size", "source": 6, "sourcePort": null},
+    {"target": 0, "targetPort": "source_directory", "source": 7, "sourcePort": null},
+    {"target": 1, "targetPort": "gmsh_output_file", "source": 0, "sourcePort": null},
+    {"target": 2, "targetPort": "meshio_output_xdmf", "source": 1, "sourcePort": "xdmf_file"},
+    {"target": 2, "targetPort": "meshio_output_h5", "source": 1, "sourcePort": "h5_file"},
+    {"target": 2, "targetPort": "source_directory", "source": 7, "sourcePort": null},
+    {"target": 3, "targetPort": "poisson_output_pvd_file", "source": 2, "sourcePort": "pvd_file"},
+    {"target": 3, "targetPort": "poisson_output_vtu_file", "source": 2, "sourcePort": "vtu_file"},
+    {"target": 3, "targetPort": "source_directory", "source": 7, "sourcePort": null},
+    {"target": 4, "targetPort": "pvbatch_output_file", "source": 3, "sourcePort": null},
+    {"target": 4, "targetPort": "ndofs", "source": 2, "sourcePort": "numdofs"},
+    {"target": 4, "targetPort": "domain_size", "source": 6, "sourcePort": null},
+    {"target": 4, "targetPort": "source_directory", "source": 7, "sourcePort": null},
+    {"target": 5, "targetPort": "macros_tex", "source": 4, "sourcePort": null},
+    {"target": 5, "targetPort": "plot_file", "source": 3, "sourcePort": null},
+    {"target": 5, "targetPort": "source_directory", "source": 7, "sourcePort": null},
+    {"target": 8, "targetPort": null, "source": 5, "sourcePort": null}
+  ]
+}