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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}

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}
+ ]
+}