updated tutorial3

# Conflicts:
#	pyproject.toml

Author: kshitij-maths

pyproject.toml

@@ -0,0 +1,83 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pygem"
+dynamic = ["version"]
+description = "Python Geometrical Morphing"
+readme = {file = "README.md", content-type = "text/markdown"}
+keywords = ["dimension_reduction", "mathematics", "ffd", "morphing", "iges", "stl", "vtk", "openfoam"]
+authors = [
+    {name = "Marco Tezzele", email = "[email protected]"},
+    {name = "Nicola Demo", email = "[email protected]"},
+    {name = "Andrea Mola", email = "[email protected]"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10", 
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics"
+]
+requires-python = ">=3.9"
+dependencies = [
+    "future",
+    "numpy>=1.21.0",
+    "scipy>=1.7.0",
+    "matplotlib>=3.5.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/mathLab/PyGeM"
+Documentation = "http://mathlab.github.io/PyGeM/"
+Repository = "https://github.com/mathLab/PyGeM"
+"Bug Reports" = "https://github.com/mathLab/PyGeM/issues"
+
+[project.optional-dependencies]
+docs = [
+    "Sphinx>=5.0.0",
+    "sphinx_rtd_theme>=1.0.0"
+]
+test = [
+    "pytest>=6.0.0",
+    "pytest-cov>=3.0.0"
+]
+tut = [
+    "jupyter",
+    "notebook",
+    "ipywidgets",
+    "nbconvert",
+]
+dev = [
+    "Sphinx>=5.0.0",
+    "sphinx_rtd_theme>=1.0.0",
+    "pytest>=6.0.0",
+    "pytest-cov>=3.0.0",
+    "jupyter",
+    "notebook",
+    "ipywidgets",
+    "nbconvert",
+    "black>=23.0.0",
+    "pylint>=3.0.0"
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pygem*"]
+exclude = ["tests*", "docs*", "tutorials*"]
+
+[tool.setuptools.dynamic]
+version = { attr = "pygem.meta.__version__" }
+
+[tool.black]
+line-length = 88
+target-version = ['py39']

tutorials/tutorial1/tutorial-1-ffd.py

@@ -22,8 +22,6 @@
 
 np.random.seed(42)
 
-
-import numpy as np
 import mpl_toolkits.mplot3d
 import matplotlib.pyplot as plt
 

tutorials/tutorial2/tutorial-2-iges.py

@@ -5,43 +5,49 @@
 
 # ## Tutorial 2: Free Form Deformation on a cylinder in CAD file format
 
+import sys
+import platform
+print(f"Python Version: {sys.version}")
+print(f"Platform: {sys.platform}")
+print(f"System: {platform.system()} {platform.release()}")
+
+try:
+    import pygem
+    print(f"PyGeM version: {pygem.__version__}")
+except ImportError:
+    print(f"PyGeM not found. Installing...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-e", ".[tut]"])
+    import pygem
+    print(f"PyGeM version: {pygem.__version__}")
+
+import numpy as np
+np.random.seed(42)
+
 # In this tutorial we show again an application of _free form deformation_ method, now to a CAD file. These files, that are often adopted to model complex geometries, require an additional pre- and post-processing of the surfaces to perform the deformation.
 #
 # The **CAD** submodule of **PyGeM** takes care of the deformation to all CAD files (.step, .iges, etc.), so first of all we import from the submodule the `FFD` class.
 
-# In[1]:
-
-
 from pygem.cad import FFD
 
 
 # Since the visualisation of CAD files may be tricky (depending by the operating system, the graphical front-end, ...), we avoid for this tutorial any graphical renderer, letting to the reader the possibility to implement by himself the needed plotting routines.
 #
 # The `FFD` class in the **CAD** module shares the same interface with the original `FFD` class (for discrete geometries). We can simply parse a parameter file to set everything like we want (remember you can do the same directly setting the object attributes).
 
-# In[2]:
-
-
 ffd = FFD()
-ffd.read_parameters("../tests/test_datasets/parameters_test_ffd_iges.prm")
+ffd.read_parameters('../tests/test_datasets/parameters_test_ffd_iges.prm')
 print(ffd)
 
 
 # Almost already completed! We now specify the input file (the one which contains the shape to deform) and the output file: these are the two input argument to pass to the object in order to perform the deformation.
 
-# In[3]:
-
-
 input_cad_file_name = "../tests/test_datasets/test_pipe.iges"
 modified_cad_file_name = "test_pipe_deformed.iges"
 ffd(input_cad_file_name, modified_cad_file_name)
 
 
 # The output file is created and the deformed shape is stored into it. We skip any visual check because of the **CAD** format file, so as final proof we simply show the differences, lines by lines, between the input and the output. Even if we can't be sure about the correctness of the results, in this way we ensure the outcome is different from the original inpuit.
 
-# In[4]:
-
-
-get_ipython().system(
-    "diff -y ../tests/test_datasets/test_pipe.iges test_pipe_deformed.iges"
-)
+import subprocess
+subprocess.run(["diff", "-y", "../tests/test_datasets/test_pipe.iges", "test_pipe_deformed.iges"])

tutorials/tutorial3/tutorial-3-rbf.ipynb

@@ -6,41 +6,50 @@
 
 # In this tutorial we will show how to use the Radial Basis Functions interpolation technique to deform a cube.
 #
-# First of all we import the required **PyGeM** class, we import numpy and we set matplotlib for the notebook.
+# First of all we import the required **PyGeM** class, we import numpy and matplotlib
 
 # In[1]:
+import sys
+import platform
+print(f"Python Version: {sys.version}")
+print(f"Platform: {sys.platform}")
+print(f"System: {platform.system()} {platform.release()}")
+
+try:
+    import pygem
+    print(f"PyGeM version: {pygem.__version__}")
+except ImportError:
+    print(f"PyGeM not found. Installing...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-e", ".[tut]"])
+    import pygem
+    print(f"PyGeM version: {pygem.__version__}")
 
-
-get_ipython().run_line_magic("matplotlib", "inline")
-from pygem import RBF
 import numpy as np
+np.random.seed(42)
 import matplotlib.pyplot as plt
+from pygem import RBF
 
 
 # Using RBF, we can control the deformation by arranging some control points around the object to deform, then moving these latter to induce the morphing. Within **PyGeM**, the setting of such parameters can be done by parsing an input text file or manually touching the `RBF` attributes.
 #
 # Let's try togheter by using an input file: the first step is the creation of the new object. After this, we can use the `read_parameters` to set the parameters.
 
 # In[2]:
-
-
 rbf = RBF()
-rbf.read_parameters(filename="../tests/test_datasets/parameters_rbf_cube.prm")
+rbf.read_parameters(filename='../tests/test_datasets/parameters_rbf_cube.prm')
 
 
 # The following is the parameters file for this particular case. The Radial Basis Functions section describes the basis functions to use. Here we use Gaussian splines with the distance parameter equal to 0.5 (see the documentation of the [RBF](http://mathlab.github.io/PyGeM/rbf.html) class for more details). As control points we consider the 8 vertices of the cube (the first one is not exactly the vertex), and we move 3 of them. In the Control points section there are all the coordinates of the control points.
 
 # In[3]:
-
-
-get_ipython().run_line_magic("cat", "../tests/test_datasets/parameters_rbf_cube.prm")
+import subprocess
+subprocess.run(['cat', '../tests/test_datasets/parameters_rbf_cube.prm'])
 
 
 # Here we create a $10 \times10 \times 10$ lattice to mimic a cube.
 
 # In[4]:
-
-
 nx, ny, nz = (10, 10, 10)
 mesh = np.zeros((nx * ny * nz, 3))
 
@@ -56,8 +65,6 @@
 # Now we plot the points to see what we are doing.
 
 # In[5]:
-
-
 fig = plt.figure(1)
 ax = fig.add_subplot(111, projection="3d")
 ax.scatter(mesh[:, 0], mesh[:, 1], mesh[:, 2], c="blue", marker="o")
@@ -70,28 +77,22 @@
 # We can also plot the original control points and the deformed ones.
 
 # In[6]:
-
-
 rbf.plot_points()
 
 
 # Finally we perform the RBF interpolation using the `RBF` class.
 
 # In[7]:
-
-
 new_mesh = rbf(mesh)
 
 
 # We can plot the new points in order to see the deformation. Try different basis functions and radius to better fit your specific problem.
 
 # In[8]:
-
-
 fig = plt.figure(2)
 ax = fig.add_subplot(111, projection="3d")
 ax.scatter(new_mesh[:, 0], new_mesh[:, 1], new_mesh[:, 2], c="red", marker="o")
 ax.set_xlabel("X axis")
 ax.set_ylabel("Y axis")
 ax.set_zlabel("Z axis")
-plt.show()
+plt.show()