# ASMD: AN AUTOMATIC FRAMEWORK FOR COMPILING MULTIMODAL DATASETS WITH AUDIO
AND SCORES

###### Abstract

This paper describes an open-source Python framework for handling datasets for
music processing tasks, built with the aim of improving the reproducibility of
research projects in music computing and assessing the generalization
abilities of machine learning models. The framework enables the automatic
download and installation of several commonly used datasets for multimodal
music processing. Specifically, we provide a Python API to access the datasets
through Boolean set operations based on particular attributes, such as
intersections and unions of composers, instruments, and so on. The framework
is designed to ease the inclusion of new datasets and the respective ground-
truth annotations so that one can build, convert, and extend one’s own
collection as well as distribute it by means of a compliant format to take
advantage of the API. All code and ground-truth are released under suitable
open licenses.

##  1 Introduction

A recent trend in computer science is the adoption of multimodal strategies
for increasing the effectiveness of algorithmic solutions in several
domains[1, 2, 3, 4, 5]. This comes as a natural consequence of the a) ever-
increasing availability of computational resources, which are now able to deal
with big data, and b) popularity of machine learning algorithms, the
performance of which is boosted as more data (including multimodal) becomes
available. As a result, machine learning technologies are now employed in
novel and unexplored ways.

In the context of music information processing, several tasks still pose
unsolved challenges to the research community, and multimodal approaches could
provide a promising path. The fields of multimodal music processing and
multimodal music representation have already been investigated in previous
works[6, 7].

Two issues that are more and more debated in several research fields are the
ability to reproduce published results[8, 9] and to generalize the resulting
models[10].

Reproducibility is associated with the differences occurring in various
implementations of the same method. As an example, one issue is related to the
different data formats used in music and in the available datasets, which
might cause troubles in the translation between representation formats and,
consequently, in the reproducibility of research.

The generalization problem instead is due, among other factors, to the need of
large and well-annotated datasets for training effective models. In
particular, the whole field of music information processing has only a limited
number of large datasets which could be much more useful if they could be
merged together. Music itself, moreover, is particularly affected by the
difficulty of creating accurate annotations to evaluate and train models,
often hindering the collection of large datasets and causing a low
generalization ability.

With these three keywords in mind (multimodal, reproducibility and
generalization), we have built ASMD to help researchers in the standardization
of music ground-truth annotations and in the distribution of datasets. ASMD is
the acronym for Audio-Score Meta-Dataset and provides a framework for
describing, converting, and accessing a single dataset which includes various
datasets – hence the expression Meta-Dataset; it was born as a side-project of
a research about audio-to-score alignment and, consequently, it contains audio
recordings and music scores for all the data included in the official release
– hence the Audio-Score part. However, we have endeavoured to make ASMD able
to include any contribute from anyone. ASMD is available under free
licenses.111Code is available at https://framagit.org/sapo/asmd/,
documentation is available at https://asmd.readthedocs.io/

A similar effort is held by mirdata [11], a Python package for downloading and
using common MIR datasets. However, our work is more focused on multimodality
and tries to keep the entire framework easily extensible and modular.

In the following sections, we describe a) the design principles, b) the
implementation details, c) a few use cases and, d) possible future works.

##  2 Design Principles and Specifications

In this section we present the principles which guided the design of the
framework. Throughout this paper, we are going to use the word annotation to
refer to any music-related data complementing an audio recording. For
instance, common types of annotations are music notes, f0 for each audio
frame, beat position, separated audio tracks, etc.

###  2.1 Generalization

With generalization, we mean the ability of including different datasets which
are distributed with various formats and annotation types in the model
generation process. This is an important issue especially during the
conversion procedure: since we aimed at distributing a conversion script to
recreate annotations from scratch for the sake of reproducibility, we need to
be able to handle all various storage systems – e.g. file name patterns,
directory structures, etc. – and file formats – e.g. midi, csv, musicxml, ad-
hoc formats, etc.

Also, our ground-truth format should be generic enough to represent all the
information contained in the available ground-truths and, at the same time, it
should permit to handle datasets with different ground-truth types – i.e. one
dataset could provide aligned notes and f0, while another one could provide
aligned notes and beat-tracking, and they should be completely accessible.

###  2.2 Modularity

Modularity refers to the re-use of parts of the framework in different
contexts. Modularity is important during both addition of new datasets and
usage of the API. To ease the conversion between ground-truth file formats,
the user should be able to re-use existing utilities to include additional
datasets. Moreover, the user should be allowed to use only some parts of the
datasets and the corresponding annotations.

###  2.3 Extensibility

The purpose of the framework is to create a tool to help the standardization
of music information processing research. Consequently, we aimed for a
framework that is completely open to new additions: it should be easy for the
user to add new datasets without editing sources from the framework itself.
Also, it should be easy to convert from existing formats in order to take
advantage of the API and to be able to merge existing datasets. Finally, the
framework should provide a usable format to add new annotations so that new
datasets can be natively created with the incorporated tools.

###  2.4 Set operability

Since the framework aims at merging multiple datasets, we wanted to add the
ability to perform set operations over datasets. As an example, within the
context of automatic music transcription research, several large datasets
exist consisting of piano music[12, 13, 14], but only few and considerably
smaller are available for other instruments[15, 16, 17, 18, 19]. Consequently,
a useful feature of the framework would be the ability to select only some
songs from multiple datasets based on particular attributes, such as the
instrument involved, the number of instruments, the composer or the type of
ground-truth available for that song.

###  2.5 Copyrights

A common issue with distributing music recordings and annotations are
copyrights. Today, most of the datasets typically used for music information
processing are released under Creative Commons Licenses, but there are many
exceptions of datasets released under closed terms[20, 16] or not released at
all because of copyright restrictions[21]. To overcome this problem, we wanted
all datasets to be downloadable from their official sources, in order to avoid
any form of redistribution. Nonetheless, all the annotations that we produced
were redistributable under Creative Commons License.

###  2.6 Audio-score oriented

Besides the effort to produce a general framework for music processing
experiments, this project was born as a utility during conducting research
addressing the audio-to-score problem. The underlying idea is that we have
various scores and large amounts of audio available to end-users, thus trained
models could easily take advantage of such multimodality (i.e. the ability of
the model to exploit both scores and audio). The main problem is the
availability of data for training the models: there is abundance of aligned
data, but without the corresponding scores; on the other hand, when scores are
available, aligned performances are almost invariably missing. Thus, the
choice of the datasets that are included at now has mainly been focused on
datasets providing audio, symbolic scores and alignment annotations. However,
since datasets fitting all these requirements are quite rare, we wanted to
augment the data available to increase the alignment data usable in our
research.

##  3 Implementation Details

This section details the implementation satisfying the design principles
outlined in section 2. Figure 1 depicts the structure of the overall framework
and the interactions between its modules.

###  3.1 The datasets.json file

The entire framework is based on a small-sized but fundamental JSON file
loaded by the API and the installation script to get the path where files are
installed. Moreover, the user can optionally set a custom directory where to
decompress downloaded files if the hard-disk space is a critical issue. Once
the installation path is found, the script looks for the existing directories
in that path to discover which datasets are already installed and skips them.
The API, instead, uses the information of the installation directory to
decouple the definition of each single dataset from the directory structure of
the user: a user can have the same dataset installed in multiple directories,
or use the same dataset from different datasets.json without interfering with
the API.

###  3.2 Definitions

In the context of this framework, a dataset definition is essentially a
JSON222https://www.json.org/json-en.html file which contains generic
description of a dataset. Definitions are built by using a pre-defined schema
allowing the definition of various information useful for the installation of
the dataset and for the usage of the API – e.g. for filtering the dataset. If
any of the information is not available for a dataset, the value unknown is
offered as well.

Examples of information contained in definitions are:

  * •

ensemble: if the dataset contains solo instrument music pieces or ensemble;

  * •

instruments: a list of instruments that are used in the dataset;

  * •

sources: if source-separated tracks are available, their format can be added
here;

  * •

recording: the format of audio recordings;

  * •

install: field containing all information for installing the dataset: URL for
downloading, shell commands for post-processing data, and so on;

  * •

ground-truth: field associated to each type of ground-truth supported by the
framework indicating whether the specific annotation type is available or not
– see Sec 3.3;

  * •

songs: a list of songs with meta-data such as the composer name and
instruments used in these songs and with the list of paths to the audio
recordings and to the annotations.

Figure 1: Block diagram of the proposed framework: API interacts with
definitions and datasets.json; the former contain references to the actual
sound recording files and annotations, while the latter contains references to
the dataset root path.

⬇

import audioscoredataset as asd

\pard = asd.Dataset()

d.filter(instruments=[’piano’], ensemble=False, composer=’Mozart’,
ground_truth=[’precise_alignment’])

\par# get audio and all the annotations

audio_array, sources_array, ground_truth_array = d.get_item(1)

\par# get only the annotations you want

audio_array = d.get_mix(2)

source_array = d.get_source(2)

ground_truth_list = d.get_gts(2)

\par# get a MIDI Toolbox-like numpy array

mat = d.get_score(2, score_type=[’precise_alignment’])

\par# get a pianoroll numpy array

mat = d.get_pianoroll(2, score_type=[’non_aligned’])

\par# or to process songs in parallel using joblib:

def processing(i, dataset, **args, *kwargs):

mat = d.get_score(2, score_type=[’precise_alignment’])

# other stuffs here

pass

\pard.filter(instruments=[’violin’]).parallel(processing, n_jobs=-1)

Example of usage for official definitions

Once a dataset has been described in this schema, its definition can be used
out-of-the-box by simply specifying to the API the path of its folder,
possibly containing other dataset definitions. All the paths specified in a
definition must be relative to the installation directory as described in Sec.
3.1.

For the sake of generalization, we had to deal with a wide heterogeneity in
path management among datasets. For instance, Bach10[18] provides one
different annotation file per each instrument in a song; in such a case we
list all the annotation files for each song and leave to the API the task of
reassembling them. PHENICX[16], instead, only provides source-separated tracks
and thus we list all of them to reference the mixed track; again, we leave to
the API the task of mixing them. In general, we have kept the following
principle: if a list of paths is provided where one would logically expect a
single path – such as in mixed tracks or annotation files – it is intended
that the files in the list should be “merged” whatever this means for that
specific file-type. For instance, if multiple audio recordings are provided
instead of only one, it is assumed that the mixed track is derivable by adding
(and normalizing) all listed tracks; if multiple annotation files are
provided, it is assumed that each annotation file refers to a different
instrument.

###  3.3 Annotations

Annotations are added in a custom JSON compressed format stored in the same
directory of the audio track that they refer to. In fact, annotation files can
be stored anywhere and their path must be provided in the dataset definition
relatively to the installation path defined in datasets.json. Moreover, one
annotation file must be provided for each instrument of the track; if multiple
instruments should refer to the same annotations – e.g. first and second
violins – the annotation file can be only one, but in the dataset definition
file, its path should be repeated once for each instrument referring to it.

Multiple types of annotations are available, but not all of them are provided
for all the datasets in the official collection. In the dataset definition,
the type of annotations available should be explained. In our implementation,
we used 3 different levels to describe ground truth availability and
reliability:

  1. 0:

annotation type not available

  2. 1:

annotation type available and manually or mechanically annotated: this type of
annotation has been added by a domain expert or some mechanical transducer –
e.g. Disklavier.

  3. 2:

annotation type available and algorithmically annotated: this type of
annotation has been added by exploiting a state-of-art algorithm.

The types of annotations currently supported are:

  1. 1.

precise alignment: onsets and offsets times in seconds, pitches, velocities
and note names for each note played in the recording, taking into account
asynchronies inside chords;

  2. 2.

broad alignment: same as precise alignment but the alignment does not consider
asynchronies inside chords;

  3. 3.

non aligned notes: same as precise alignment but not aligned (see 3.4 for more
information);

  4. 4.

f0: the f0 of this instrument for each audio frame in the corresponding track;

  5. 5.

beats non aligned: time instances of beats in the non-aligned data;

  6. 6.

instrument: General Midi program number associated with this instrument,
starting from 0, while value 128 indicates a drums kit.

###  3.4 Alignment

As described in section 2.6, this project originated for music alignment
research. One problem is the lack of large datasets containing audio
recordings, aligned notes and symbolic non aligned scores.

The approach that we used to overcome this problem is to statistically analyze
the available manual annotations and to augment the data by approximating them
through the statistical model. To prevent biases, we also replaced the manual
annotations with the approximated ones.

For now, the statistical analysis is simple: we compute the mean and the
standard deviation of offsets and onsets for each piece. Then, we store the
histogram of the standardized offsets and onsets of each note; we also store
histograms of the mean and standard deviation values of each piece. To create
new misaligned data, we chose a standardized value for each note accompanied
by a mean and a standard deviation for each piece, using the corresponding
histograms; with these data, we can compute a non-standardized value for each
note. Note that initially the histograms are normalized so that they satisfy
certain given constraints. In the distributed code, the standardized values
are normalized to $1$ (that is, the maximum value is $1$ second), while
standard deviations are normalized to $0.2$.

An additional problem is due to the fact that the time units in the aligned
data are seconds, while those in the scores are note lengths – e.g. breve,
semibreve and so on. Usually, one translates a note length to seconds by using
BPM; however, in some scores the BPM annotation is unavailable or is not
reliable. Hence, during the statistical analysis, we always consider the tempo
as $20$ BPM, which is a non-usual BPM, in the attempt of minimizing its
overall influence. If we used a usual BPM, such as $60$ or $120$, songs with
BPM near to that value would have biased the analysis. Moreover, models
trained using the produced alignment annotations are ensured to be BPM-
independent. Note that one can still try to derive BPM information by making a
BPM estimation over the audio[22, 23], a process which highly depends on the
algorithm’s precision.

###  3.5 API

The framework is complemented with a Python API written in
Cython.333https://cython.org/ It allows in particular to load various dataset
definitions aside of the official ones. The API provides methods to retrieve
audio and annotations in various structures, such as a matrix list of notes
similar to the one used by Matlab MIDI Toolbox[24] or pianorolls. Thanks to
the API, one can also filter the loaded datasets’ songs based on the original
dataset, active instrument, ensemble or solo instrumentation, composer,
available annotation types, etc.

Moreover, since the API basically consists in a class representing a large
dataset, it is very easy to extend it in order to use it in conjunction of
PyTorch or TensorFlow frameworks for training neural network models. In Sec. 4
we provide an example of the specific functionality.

###  3.6 Conversion

To give the user the ability to write his/her own definitions without having
to edit the framework code, we designed a conversion procedure as follows:

  1. 1.

the creator can use already developed conversion tools for the most common
file formats (MIDI, sonic visualizer, etc.);

  2. 2.

the creator can still write an ad-hoc function which converts a file from the
original format to the ASMD one; in this case the creator has to decorate the
conversion function with a special decorator provided by ASMD;

  3. 3.

the creator adds the needed conversion function in the install section in the
dataset definition;

  4. 4.

the user can run the conversion script for only a specific dataset or for all
other datasets.

All the technical details are available in the official
documentation.444https://asmd.readthedocs.io/

[t]

⬇

import audioscoredataset as asd

\pard = asd.Dataset([’path/to/directory/containing/custom/definitions’,
’path/to/the/official/definitions/’])

d.filter(instruments=[’piano’], ensemble=False, composer=’Mozart’,
ground_truth=[’precise_alignment’])

\par

Example of usage for custom definitions

[t]

⬇

import torch

import audioscoredataset as asd

from torch.utils.data import Dataset as TorchDataset

\parclass MyDataset(asd.Dataset, TorchDataset):

def __init__(self, *args, **kargs):

super().__init__([’path/to/definitions’]).filter(instruments=[’piano’])

\pardef __getitem__(self, i):

# for instance, return the MIDI Toolbox-like score

return torch.tensor(self.get_score(i))

\pardef another_awsome_method(self, *args, **kargs):

print(”Hello, world!”)

\parfor i, mat in enumerate(MyDataset()):

# train your nn model here

\par

Example for using ASMD inside PyTorch

##  4 Use Cases

This section demonstrates the efficacy of the ASMD framework through four
different use cases.

###  4.1 Using API with the official dataset collection

To use the API, the user should carry out the following steps:

  * •

import audioscoredataset;

  * •

create a audioscoredataset.Dataset object, giving the path of the
datasets.json file as an argument to the constructor;

  * •

use the filter method on the object to filter data according to his/her needs
(conveniently, it is also possible to re-filter them at a later stage, without
reloading the datasets.json file);

  * •

retrieve elements by calling the get_item method or similar ones.

After the execution of the filter method, the Dataset instance will contain a
field paths representing the list of correct paths to the files requested by
the user. Listing 1 shows an example of such an operation.

###  4.2 Using API with definitions for a customized dataset

Whenever the user wishes to apply customized definitions, he/she need simply
to provide the list of directories to the Dataset constructor, as shown in
listing 3.6.

[t]

⬇

from audioscoredataset.convert_from_file import convert, prototype_gt

from copy import deepcopy

\par# use @convert

@convert([’.myext’])

def function_which_converts(filename, *args, **kargs):

# prepare empty output

out = deepcopy(prototype_gt)

\par# open file

data = csv.reader(open(filename), delimiter=’,’)

\par# fill output dictionary

for row in data:

out[alignment][”onsets”].append(float(row[0]))

out[alignment][”offsets”].append(float(row[0]) + float(row[2]))

out[alignment][”pitches”].append(int(row[1])

\parreturn out

Example for writing a custom conversion function

###  4.3 Using ASMD with PyTorch

Integrate ASMD with PyTorch is straightforward. The user has to inherit from
both PyTorch and ASMD Dataset classes and to implement the __getitem__ method.
Listing 3.6 shows such an example.

###  4.4 Writing a conversion function and a custom dataset definition

Towards adding new definitions enabling users to download datasets, a user
should also provide a conversion function. Listing 4.2 is an example of one
can write its own conversion function. However, conversion functions for the
most common file types – such as Midi and Sonic Visualizer – are already
provided by the framework.

##  5 Conclusions

Future works will focus on the enhancement of conversion and installation
procedures, as well as on the definition of standards for music annotations.
In addition, multimodal music processing often requires processing of
annotation types not included in this version of the framework, but could
instead be handled in a future release. Some annotation types could be stored
in standalone formats and users should be able to distribute annotations
focusing only on a specific ground truth kind, thus enhancing the distributed
infrastructure of ASMD.

Studying the user experience of the framework should also be a priority: for
instance, users could be able to choose datasets also based on the estimation
of the download time since for some datasets that is a big issue. Labels used
in the annotation format are also relevant to ease the usage of the framework
by new users, especially in a multidisciplinary field such as the sound and
music computing.

This paper presented a new framework for multimodal music processing. We hope
that our efforts in easing the development of multimodal machine learning
approaches for music information processing will be useful to the sound and
music computing community. We are completely aware that for a truly general
and usable framework, the participation of various and different perspectives
is needed and we are therefore open to any contribution towards the creation
of utilities that allow training and testing multimodal models, ensuring
reasonable generalization ability and reliable reproducibility of scientific
results.

Acknowledgments
We would like to thank all people that worked on the datasets used in the ASMD
framework: Bach10[18], Maestro[12], MusicNet[15], PHENICX Anechoic[16],
SMD[13], Traditional Flute Dataset[17], TRIOS[19] and Vienna 4x22 Piano
Corpus[14].

## References

  * [1] T. Baltrusaitis, C. Ahuja, and L.-P. Morency, “Multimodal machine learning: A survey and taxonomy,” _IEEE Trans. on Pattern Analysis and Machine Intelligence_ , vol. 41, no. 2, pp. 423–443, 2018.
  * [2] S. Ntalampiras, F. Avanzini, and L. A. Ludovico, “Fusing acoustic and electroencephalographic modalities for user-independent emotion prediction,” in _2nd IEEE Int. Conf. on Cognitive Computing (ICCC)_ , 2019, pp. 36–41.
  * [3] S. Ntalampiras, D. Arsić, M. Hofmann, M. Andersson, and T. Ganchev, “PROMETHEUS: heterogeneous sensor database in support of research on human behavioral patterns in unrestricted environments,” _Signal, Image and Video Processing_ , vol. 8, no. 7, pp. 1211–1231, 2012.
  * [4] P. K. Atrey, M. A. Hossain, A. E. Saddik, and M. S. Kankanhalli, “Multimodal fusion for multimedia analysis: A survey,” _J. of Multimedia Systems_ , vol. 16, no. 6, pp. 345–379, 2010.
  * [5] M. Minsky, “Logical versus analogical or symbolic versus connectionist or neat versus scruffy,” _AI Magazine_ , vol. 12, no. 2, pp. 34–51, 1991.
  * [6] F. Simonetta, S. Ntalampiras, and F. Avanzini, “Multimodal Music Information Processing and Retrieval: Survey and Future Challenges,” in _1st Int. Work. on Multilayer Music Representation and Processing (MMRP)_ , 2019, pp. 10–18.
  * [7] L. A. Ludovico, A. Baratè, F. Simonetta, and D. A. Mauro, “On the adoption of standard encoding formats to ensure interoperability of music digital archives: The ieee 1599 format.” in _6th Int. Conf. on Digital Libraries for Musicology (DLfM)_ , 2019, pp. 20–24.
  * [8] M. Baker, “1,500 scientists lift the lid on reproducibility,” _Nature News_ , vol. 533, no. 7604, p. 452, 2016.
  * [9] M. Hutson, “Artificial intelligence faces reproducibility crisis,” _Science_ , vol. 359, no. 6377, pp. 725–726, 2018.
  * [10] Y. S. Abu-Mostafa, M. Magdon-Ismail, and H.-T. Lin, _Learning From Data_. AMLBook, 2012.
  * [11] R. M. Bittner, M. Fuentes, D. Rubinstein, A. Jansson, K. Choi, and T. Kell, “mirdata: Software for reproducible usage of datasets.” in _20th Int. Conf. on Music Information Retrieval Conference (ISMIR)_ , 2019.
  * [12] C. Hawthorne, A. Stasyuk, A. Roberts, I. Simon, C.-Z. A. Huang, S. Dieleman, E. Elsen, J. H. Engel, and D. Eck, “Enabling factorized piano music modeling and generation with the maestro dataset.” in _7th Int. Conf. on Learning Representations (ICLR)_ , 2019.
  * [13] M. Müller, V. Konz, W. Bogler, and V. Arifi-Müller, “Saarland music data (SMD),” in _12th Int. Conf. on Music Information Retrieval (ISMIR)_ , 2011.
  * [14] W. Goebl. (1999) The vienna 4x22 piano corpus. [Online]. Available: http://dx.doi.org/10.21939/4X22
  * [15] J. Thickstun, Z. Harchaoui, D. P. Foster, and S. M. Kakade, “Invariances and data augmentation for supervised music transcription.” in _43rd Int. Conf. on Acoustics, Speech, and Signal Processing (ICASSP)_ , 2018, pp. 2241–2245.
  * [16] M. Miron, J. J. Carabias-Orti, J. J. Bosch, E. Gómez, and J. Janer, “Score-informed source separation for multichannel orchestral recordings.” _J. Electrical and Computer Engineering_ , vol. 2016, pp. 1–19, 2016.
  * [17] J. P. Brum. (2018) Traditional flute dataset for score alignment”. [Online]. Available: https://www.kaggle.com/jbraga/traditional-flute-dataset
  * [18] Z. Duan and B. Pardo, “Soundprism: An online system for score-informed source separation of music audio.” _J. Sel. Topics Signal Processing_ , vol. 5, no. 6, pp. 1205–1215, 2011.
  * [19] J. Fritsch. (2012) The trios score-aligned multitrack recordings dataset. [Online]. Available: https://c4dm.eecs.qmul.ac.uk/rdr/handle/123456789/27
  * [20] F. Simonetta, F. Carnovalini, N. Orio, and A. Rodà, “Symbolic music similarity through a graph-based representation,” in _13th Audio Mostly Int. Conf. (AM’18)_ , 2018.
  * [21] F. Simonetta, C. Cancino-Chacón, S. Ntalampiras, and G. Widmer, “A convolutional approach to melody line identification in symbolic scores,” in _20th Int. Conf. on Music Information Retrieval Conference (ISMIR)_ , 2019\.
  * [22] H. Schreiber and M. Müller, “A single-step approach to musical tempo estimation using a convolutional neural network.” in _19th Int. Conf. on Music Information Retrieval (ISMIR)_ , 2018, pp. 98–105.
  * [23] S. Böck, F. Krebs, and G. Widmer, “Accurate tempo estimation based on recurrent neural networks and resonating comb filters.” in _16th Int. Conf. on Music Information Retrieval (ISMIR)_ , 2015, pp. 625–631.
  * [24] T. Eerola and P. Toiviainen, “Mir in matlab: The midi toolbox.” in _5th Int. Conf. on Music Information Retrieval (ISMIR)_ , 2004.


* Dreizler and Gross (1990) R. M. Dreizler and E. K. U. Gross, _Density Functional Theory: An Approach to the Quantum Many-Body Problem_ , Springer-Verlag, Berlin Heidelberg, 1990\.
  * Perdew _et al._ (1982) J. P. Perdew, R. G. Parr, M. Levy and J. L. Balduz, _Phys. Rev. Lett._ , 1982, 49, 1691–1694.
  * Janak (1978) J. F. Janak, _Phys. Rev. B_ , 1978, 18, 7165.
  * Baerends (2018) E. J. Baerends, _J. Chem. Phys._ , 2018, 149, 054105.
  * Slater _et al._ (1969) J. C. Slater, J. B. Mann, T. M. Wilson and J. H. Wood, _Phys. Rev._ , 1969, 184, 672.
  * Slater (1972) J. C. Slater, _Adv. Quantum Chem._ , 1972, 6, 1–92.
  * Slater (1974) J. C. Slater, _The self-consistent field for molecules and solids: Quantum theory of molecules and solids, Vol. 4_ , McGraw-—Hill, Inc., New York, 1974\.
  * Parr and Bartolotti (1983) R. G. Parr and L. J. Bartolotti, _J. Phys. Chem._ , 1983, 87, 2810–2815.
  * Lieb (1983) E. H. Lieb, _Int. J. Quant. Chem._ , 1983, 24, 243–277.
  * Baerends _et al._ (2013) E. J. Baerends, O. V. Gritsenko and R. van Meer, _Phys. Chem. Chem. Phys._ , 2013, 15, 16408–16425.
  * Perdew and Levy (1983) J. P. Perdew and M. Levy, _Phys. Rev. Lett._ , 1983, 51, 1884 – 1887\.
  * van Leeuwen _et al._ (1996) R. van Leeuwen, O. Gritsenko and E. J. Baerends, _Top. Curr. Chem._ , 1996, 180, 107 – 167.
  * Perdew (1985) J. P. Perdew, in _Density Functional Methods in Physics_ , ed. R. M. Dreizler and J. da Providencia, Plenum, New York, 1985, vol. 123 of NATO Advanced Study Institute Series B: Physics, pp. 265–308.
  * Sagredo and Burke (2020) F. Sagredo and K. Burke, _J. Chem. Theor. Comp._ , 2020, 16, 7225–7231.
  * Gyftopoulos and Hatsopoulos (1968) E. P. Gyftopoulos and G. N. Hatsopoulos, _Proc. Natl. Acad. Sci. USA_ , 1968, 60, 786–793.
  * Tolman (1938) R. C. Tolman, _The principles of statistical mechanics_ , Oxford University Press, London, 1938.
  * Rushbrooke (1949) G. S. Rushbrooke, _Introduction to statistical mechanics_ , Oxford University Press, London, 1949.
  * Hill (1956) T. L. Hill, _Statistical Mechanics. Principles and selected applications_ , McGraw-Hill, New York, 1956.
  * Hill (1960) T. L. Hill, _Introduction to statistical thermodynamics_ , Addison-Wesley, Reading, Mass., 1960.
  * Landsberg (1961) P. T. Landsberg, _Thermodynamics with quantum statistical illustrations_ , Interscience Publishers, New York - London, 1961.
  * Reif (1965) F. Reif, _Fundamentals of statistical and thermal physics_ , Mc-Graw-Hill, New York, 1965.
  * Landau and Lifshitz (1980) L. D. Landau and E. M. Lifshitz, _Statistical Physics, Part 1, 3rd Ed._ , Elsevier, 1980, vol. 5.
  * Pathria and Beale (2011) R. K. Pathria and P. D. Beale, _Statistical Mechanics, Third Ed._ , Elsevier, Amsterdam, 2011.
  * Hill (1964) T. L. Hill, _Thermodynamics of small systems. Part I and II_ , W. A. Benjamin, Inc., New York, 1964.
  * Briels (2022) W. Briels, _private communication_ , 2022.
  * Almbladh and von Barth (1985) C. O. Almbladh and U. von Barth, in _Density Functional Methods in Physics_ , ed. R. M. Dreizler and J. da Providencia, Plenum, New York, 1985, vol. 123 of NATO Advanced Study Institue Series B: Physics.
  * Gritsenko and Baerends (1996) O. V. Gritsenko and E. J. Baerends, _Phys. Rev. A_ , 1996, 54, 1957–1972.
  * Tempel _et al._ (2009) D. G. Tempel, T. J. Martínez and N. T. Maitra, _J. Chem. Theor. Comp._ , 2009, 5, 770 – 780.
  * Elliott _et al._ (2012) P. Elliott, J. I. Fuks, A. Rubio and N. T. Maitra, _Phys. Rev. Lett._ , 2012, 109, 266404.
  * Luo _et al._ (2014) K. Luo, J. I. Fuks, E. D. Sandoval, P. Elliott and N. P. Maitra, _J. Chem. Phys._ , 2014, 140, 18A515.
  * Giarusso _et al._ (2018) S. Giarusso, S. Vuckovic and P. Gori-Giorgi, _J. Chem. Theory Comput._ , 2018, 14, 4151–4167.
  * Krieger _et al._ (1992) J. B. Krieger, U. Li and G. J. Iafrate, _Phys. Rev. A_ , 1992, 45, 101–126.
  * Gritsenko _et al._ (1994) O. Gritsenko, R. van Leeuwen and E. J. Baerends, _J. Chem. Phys._ , 1994, 101, 8955–8963.
  * Gritsenko _et al._ (1995) O. V. Gritsenko, R. van Leeuwen, E. van Lenthe and E. J. Baerends, _Phys. Rev. A_ , 1995, 51, 1944.
  * Grüning _et al._ (2006) M. Grüning, A. Marini and A. Rubio, _J. Chem. Phys._ , 2006, 124, 154108.
  * Gritsenko _et al._ (2016) O. V. Gritsenko, L. Mentel and E. J. Baerends, _J. Chem. Phys._ , 2016, 144, 204114.
  * van Meer _et al._ (2014) R. van Meer, O. V. Gritsenko and E. J. Baerends, _J. Chem. Theory Comput._ , 2014, 10, 4432–4441.
  * Baerends (2017) E. J. Baerends, _Phys. Chem. Chem. Phys._ , 2017, 19, 15639 – 15656\.
  * Kuisma _et al._ (2010) M. Kuisma, J. Ojanen, J. Enkovaara and T. T. Rantala, _Phys. Rev. B_ , 2010, 82, 115106.
  * Yan _et al._ (2012) J. Yan, K. W. Jacobsen and K. S. Thygesen, _Phys. Rev. B_ , 2012, 86, 045208.
  * Castelli _et al._ (2015) I. E. Castelli, F. Hüser, M. Pandey, H. Li, K. S. Thygesen, B. Seger, A. Jain, K. A. Persson, G. Ceder and K. W. Jacobsen, _Adv. Energy Mater._ , 2015, 5, 1400915.
  * Tran _et al._ (2018) F. Tran, S. Ehsan and P. Blaha, _Phys. Rev. Materials_ , 2018, 2, 023802\.
  * Patra _et al._ (2021) A. Patra, S. Jana, P. Samal, F. Tran, L. Kalantari, J. Doumont and P. Blaha, _J. Phys. Chem. C_ , 2021, xxx, xxx.
  * Görling (2015) A. Görling, _Phys. Rev. B_ , 2015, 91, 245120.
  * Trushin _et al._ (2016) E. Trushin, M. Betzinger, S. Blügel and A. Görling, _Phys. Rev. B_ , 2016, 94, 075123.
  * Tran _et al._ (2019) F. Tran, J. Doumont, P. Blaha, M. A. L. Marques, S. Botti and P. Bartók, _J. Chem. Phys._ , 2019, 151, 161102.
  * Perdew _et al._ (2017) J. P. Perdew, W. T. Yang, K. Burke, Z. Yang, E. K. U. Gross, M. Scheffler, G. E. Scuseria, T. M. Henderson, I. Y. Zhang, A. Ruzsinszky, H. Peng, J. W. Sun, E. Trushin and A. Görling, _Proc. Natl. Acad. Sci. USA_ , 2017, 114, 2801 – 2806.
  * Noodleman _et al._ (1982) L. Noodleman, D. Post and E. J. Baerends, _Chem. Phys._ , 1982, 64, 159–166.
  * Bally and Sastry (1997) T. Bally and G. N. Sastry, _J. Phys. Chem. A_ , 1997, 101, 7923–7925.
  * Sodupe _et al._ (1999) M. Sodupe, J. Bertran, L. Rodríguez-Santiago and E. J. Baerends, _J. Phys. Chem. A_ , 1999, 103, 166–170.
  * Cohen _et al._ (2008) A. J. Cohen, P. Mori-Sánchez and W. T. Yang, _Science_ , 2008, 321, 792 – 794.
  * Yang _et al._ (2000) W. T. Yang, Y. Zhang and P. W. Ayers, _Phys. Rev. Lett._ , 2000, 84, 5172–5175.
  * Mori-Sánchez and Cohen (2014) P. Mori-Sánchez and A. J. Cohen, _Phys. Chem. Chem. Phys._ , 2014, 16, 14378–14387.
  * Yang _et al._ (2012) W. T. Yang, A. J. Cohen and P. Mori-Sánchez, _J. Chem. Phys._ , 2012, 136, 204111.
  * Zheng _et al._ (2011) X. Zheng, A. J. Cohen, P. Mori-Sánchez, X. Hu and W. T. Yang, _Phys. Rev. Lett._ , 2011, 107, 026403.
  * Cohen _et al._ (2008) A. J. Cohen, P. Mori-Sánchez and W. T. Yang, _Phys. Rev. B_ , 2008, 77, 115123.
  * Savin _et al._ (1998) A. Savin, C. J. Umrigar and X. Gonze, _Chem. Phys. Lett._ , 1998, 288, 391–395.
  * Garza _et al._ (2000) J. Garza, J. Nichols and D. Dixon, _J. Chem. Phys._ , 2000, 113, 6029–6034.
  * Della Sala and Görling (2003) F. Della Sala and A. Görling, _Int. J. Quant. Chem._ , 2003, 91, 131 – 138.
  * Theophilou (1979) A. K. Theophilou, _J. Phys. C._ , 1979, 12, 5419 –.
  * Gross _et al._ (1988) E. K. U. Gross, L. N. Oliveira and W. Kohn, _Phys. Rev. A_ , 1988, 37, 2805 – 2808.
  * Gross _et al._ (1988) E. K. U. Gross, L. N. Oliveira and W. Kohn, _Phys. Rev. A_ , 1988, 37, 2809 – 2820.
  * Oliveira _et al._ (1988) L. N. Oliveira, E. K. U. Gross and W. Kohn, _Phys. Rev. A_ , 1988, 37, 2821 – 2833.
  * Senjean and Fromager (2018) B. Senjean and E. Fromager, _Phys. Rev. A_ , 2018, 98, 022513\.
  * Deur and Fromager (2019) K. Deur and E. Fromager, _J. Chem. Phys._ , 2019, 150, 094106\.
  * Yang _et al._ (2017) Z. H. Yang, A. Pribram-Jones, K. Burke and C. A. Ullrich, _Phys. Rev. Lett._ , 2017, 119, 033003.
  * Gould _et al._ (2018) T. Gould, L. Kronik and S. Pittalis, _J. Chem. Phys._ , 2018, 148, 174101\.
  * Dirac (1930) P. A. M. Dirac, _The Principles of Quantum Mechanics_ , The Clarendon Press, Oxford, 1930.
  * von Neumann (1932) J. von Neumann, _Mathematical Foundations of Quantum Mechanics_ , Springer, Berlin, 1932.
  * Feynman and Hibbs (1965) R. P. Feynman and A. R. Hibbs, _Quantum Mechanics and Path Integrals_ , McGraw-Hill Inc., New York, 1965.
  * Levy (1995) M. Levy, _Phys. Rev. A_ , 1995, 52, R4313 – R4315.
  * Levy (1982) M. Levy, _Phys. Rev. A_ , 1982, 26, 1200–1208.
  * Schipper _et al._ (1998) P. R. T. Schipper, O. V. Gritsenko and E. J. Baerends, _Theor. Chem. Acc._ , 1998, 99, 329.
  * Schipper _et al._ (1999) P. R. T. Schipper, O. V. Gritsenko and E. J. Baerends, _J. Chem. Phys._ , 1999, 111, 4056.
  * Ullrich and Kohn (2001) C. A. Ullrich and W. Kohn, _Phys. Rev. Lett._ , 2001, 87, 093001\.
  * Filatov (2015) M. Filatov, _WIREs Comput. Mol. Sci._ , 2015, 5, 146 – 167.
  * Filatov and Shaik (2000) M. Filatov and S. Shaik, _J. Phys. Chem. A_ , 2000, 104, 6628 – 6636\.
  * Kazaryan _et al._ (2008) A. Kazaryan, J. Heuver and M. Filatov, _J. Phys. Chem. A_ , 2008, 112, 12980 – 12988.
  * Filatov (2016) M. Filatov, _Top. Curr. Chem._ , 2016, 368, 97 – 124.
  * Ashcroft and Mermin (1976) N. W. Ashcroft and N. D. Mermin, _Solid State Physics_ , Holt, Rinehart and Winston, London - New York, 1976.
  * Mermin (1965) N. D. Mermin, _Phys. Rev. A_ , 1965, 137, 1441 – 1443.
  * Mermin (1963) N. D. Mermin, _Ann. Phys._ , 1963, 21, 99–121.
  * He _et al._ (2014) X. He, S. Ryu and S. Hirata, _J. Chem. Phys._ , 2014, 140, 024702\.
  * Hermes and Hirata (2015) M. R. Hermes and S. Hirata, _J. Chem. Phys._ , 2015, 143, 102818\.
  * Harsha _et al._ (2019) G. Harsha, T. M. Henderson and G. E. Scuseria, _J. Chem. Phys._ , 2019, 150, 154109.
  * Harsha _et al._ (2020) G. Harsha, T. M. Henderson and G. E. Scuseria, _J. Chem. Phys._ , 2020, 153, 124115.
  * White and Chan (2018) A. F. White and G. K. L. Chan, _J. Chem. Theor. Comp._ , 2018, 14, 5690–5700.
  * Fetter and Walecka (2003) A. L. Fetter and J. D. Walecka, _Quantum Theory of Many-Particle Systems_ , Dover Publiations, Inc., 2003.
  * Negele and Orland (1988) J. W. Negele and H. Orland, _Quantum Many-Particle Systems_ , Addison-Wesley, Reading Massachusetts, 1988, vol. 68.
  * Gross _et al._ (1991) E. K. U. Gross, E. Runge and O. Heinonen, _Many-Particle Theory_ , IOP Publishing, Bristol, 1991.
  * Stefanucci and van Leeuwen (2013) G. Stefanucci and R. van Leeuwen, _Nonequilibrium Many-Body Theory of Quantum Systems_ , Cambridge Univeristy Press, Cambridge, 2013.
  * Fowler and Guggenheim (1935) R. Fowler and E. Guggenheim, _Statistical Thermodynamics_ , Cambridge University Press, Cambridge, UK, 1935.


11institutetext: Paulami Banerjee 22institutetext: Fraunhofer ITWM,
Kaiserslautern, 22email<EMAIL_ADDRESS>33institutetext:
Mohan Padmanabha 44institutetext: Fraunhofer ITWM, Kaiserslautern, 44email:
<EMAIL_ADDRESS>55institutetext: Chaitanya Sanghavi
66institutetext: Fraunhofer ITWM, Kaiserslautern, 66email:
<EMAIL_ADDRESS>77institutetext: Isabel Michel
88institutetext: Fraunhofer ITWM, Kaiserslautern, 88email:
<EMAIL_ADDRESS>99institutetext: Simone Gramsch
1010institutetext: Frankfurt University of Applied Sciences, Frankfurt am
Main, 1010email<EMAIL_ADDRESS>
# Machine Learning Optimized Approach for Parameter Selection in MESHFREE
Simulations

Banerjee  Paulami; Padmanabha  Mohan; Sanghavi  Chaitanya; Michel  Isabel and
Gramsch  Simone

###### Abstract

Meshfree simulation methods are emerging as compelling alternatives to
conventional mesh-based approaches, particularly in the fields of
Computational Fluid Dynamics (CFD) and continuum mechanics. In this
publication, we provide a comprehensive overview of our research combining
Machine Learning (ML) and Fraunhofer’s MESHFREE software (www.meshfree.eu), a
powerful tool utilizing a numerical point cloud in a Generalized Finite
Difference Method (GFDM). This tool enables the effective handling of complex
flow domains, moving geometries, and free surfaces, while allowing users to
finely tune local refinement and quality parameters for an optimal balance
between computation time and results accuracy. However, manually determining
the optimal parameter combination poses challenges, especially for less
experienced users. We introduce a novel ML-optimized approach, using active
learning, regression trees, and visualization on MESHFREE simulation data,
demonstrating the impact of input combinations on results quality and
computation time. This research contributes valuable insights into parameter
optimization in meshfree simulations, enhancing accessibility and usability
for a broader user base in scientific and engineering applications.

##  1 Introduction

Conventional numerical simulation tools use a mesh (grid) to solve partial
differential equations (PDEs). These mesh-based methods need a mesh that fits
the shape of the geometry of/around which the simulation is carried out. The
time and effort for mesh generation increases with the complexity of the
computational domain. Especially in fluid flow cases with a deformable domain
or free surface flows, this process gets even more complicated as the domain
changes with time and the mesh has to be adapted accordingly. Switching
towards meshfree methods will help to reduce this tedious process of re-
meshing.

There are different meshfree methods that are not subject to this problem. In
this chapter, we concentrate on a Generalized Finite Difference Method (GFDM)
based tool developed by Fraunhofer ITWM and Fraunhofer SCAI called MESHFREE
(beta version 11.3) 2022MESHFREESoftware . It employs a general continuum
mechanics approach which allows to solve a wide range of applications. In the
field of classical fluid dynamics, it has been used successfully for the water
management of vehicles 2021kuhnertCar , the evaluation and design of Pelton
turbines 2019kuhnertFSI , the prediction of solution mining processes
2021michel , or the transmission of aerosols 2024LeithaeuserAerosols .
MESHFREE is also very well suited to reliably simulate multiphase flows such
as below-boiling point evaporation 2023LeeEvaporation  as well as above-
boiling point vaporization 2024suchdeLiquidVapor . In addition, complex
material models can be efficiently integrated, for example for injection
molding 2022veltmaatInjection , metal cutting 2021UhlmannWetMetalCutting , or
processes in soil mechanics 2017MichelSoilMechanics . In GFDM, the domain is
discretized by a randomly distributed cloud of numerical points that are used
to solve the PDEs. Typically, the point cloud moves with the flow according to
a Lagrangian formulation. Additional key parameters beyond those typically
encountered in conventional mesh-based solvers are necessary, specifically
related to point cloud management. Familiarity with GFDM is essential to
comprehend these key parameters.

Recent research has showcased the potential of involving machine learning (ML)
models in both mesh-based and meshfree simulations. In huang2021machine  and
10.5555/3433701.3433712 , the authors explored the use of ML for optimal mesh
generation and super-resolution of spatio-temporal solutions, respectively. A
framework for learning mesh-based simulations using graph neural networks
called MeshGraphNets was introduced in pfaff2020learning . For meshfree
methods, hamrani2023machine  and lefloch2021mesh  delved into using ML for
surrogate modeling, with the former emphasizing the universal approximation
property of supervised ML models and the latter introducing a transport-based
meshfree approach. Building upon this foundation, zehnder2021ntopo  extended
the application of ML models to employ implicit neural representations for
meshfree topology optimization. Together, these studies emphasize the
promising role of ML in improving both the efficiency as well as accuracy of
both mesh-based and meshfree simulations.

The primary objective of this publication is to assist inexperienced users in
configuring the necessary parameters for setting up and executing MESHFREE
simulations effectively. In addition, using sound ML strategies, our trained
model provides users with an estimated range in which they can expect the
results – including result quality and computation time. The parameter
suggestions are tailored to achieve satisfactory results while optimizing
computational resources, using active learning approaches. In order to
investigate the influence of selected parameters on the simulation results, a
simplified 3D case was used, which represents a laminar flow around a
cylinder, as described in Schaefer1996 . The effect of the selected parameters
on the computation time as well as the drag and lift coefficients were
systematically recorded and employed as data for the use of informed
MLvon2021informed  strategies to effectively address both tasks. In the
following sections, we will take a deeper look into the mathematics behind
MESHFREE (Sections 2 and 3), the research question (Section 4), the considered
use case (Section 5), the approach we took to solve it (Section 6), and the
results we have obtained (Section 7). The concluding remarks are summarized in
Section 8.

##  2 Numerics Based on GFDM

This section covers numerical point cloud management in MESHFREE, encompassing
point distribution, neighborhood definition, and local refinement strategies.

###  2.1 Point Cloud Management

The computational domain is discretized with numerical points (also known as
point cloud) that are irregularly distributed in the interior and along the
boundary. The generation and management of the points is comparatively easy
and can be automated. An overview of different strategies can be found in
2023suchdePointCloudGeneration . A meshfree advancing front technique
Lhner1998AnAF  is used for the point generation in MESHFREE.

The computational domain consists of $N=N(t)$ number of points with time $t$
and positions $\vec{x_{i}}\in\mathbb{R}^{3}$, $i=1,...,N$. The
density/resolution of the point cloud is determined by the so-called
interaction radius $h=h(\vec{x},t)\in\mathbb{R}^{+}$, a sufficiently smooth
function. Based on $h$, the local neighborhood $S_{i}$ of a point
$\vec{x_{i}}$ is defined as follows (see 2021michel , 2019suchdefully ):

$S_{i}=\\{\vec{x}_{j}:||\vec{x}_{j}-\vec{x}_{i}||\leq h\\}.$

A sufficient quality of the point cloud has to be ensured locally throughout
the simulation as the points move with the flow velocity according to the
Lagrangian formulation. To avoid clustering, no neighboring points are allowed
within a distance of $r_{\mathrm{min}}h$, where $r_{\mathrm{min}}\in(0,1)$.
Additionally, to avoid large gaps there should be at least one neighboring
point within a distance of $r_{\mathrm{max}}h$ with
$r_{\mathrm{max}}\in(r_{\mathrm{min}},1)$. A typical choice is
$r_{\mathrm{min}}=0.2$ and $r_{\mathrm{max}}=0.4$, resulting in 40 to 50
neighboring points in each interior neighborhood in 3D 2017suchdeflux . The
number of neighboring points may be lower for points close to the boundaries
of the domain 2018suchdePointMovement .

MESHFREE allows different strategies for local refinement with respect to the
interaction radius $h$. The refinement can be geometry-dependent, where $h$
decreases with decreasing distance from the geometry (linear, spherical, or
radial). Furthermore, there is also the possibility to define the interaction
radius adaptively based on the simulation results such as velocity or pressure
gradients.

###  2.2 Differential Operators

MESHFREE employs a weighted least squares approximation approach to compute
differential operators (see 2021michel , 2018suchdeGFDMNS ). For example, the
derivative approximation for a function $u$ at point $\vec{x_{i}}$ is given by

$\partial^{*}u(\vec{x}_{i})\approx\widetilde{\partial}^{*}_{i}u=\sum_{j\in
S_{i}}c^{*}_{ij}u_{j},$

where $*=x,y,z,\Delta,..$, $\partial^{*}$ is the continuous differential and
$\widetilde{\partial}^{*}_{i}$ is the discrete differential at point
$\vec{x}_{i}$. The stencil coefficients $c^{*}_{ij}$ are determined by a
weighted least squares approximation that is independent of the function $u$.
These coefficients are computed using a norm minimization process which
ensures that monomials up to a specified order are differentiated exactly:

$\min\sum_{j\in S_{i}}\left(\frac{c^{*}_{ij}}{W_{ij}}\right)^{2},$

where $W_{ij}$ is a weighting function with highest weight for the closest
neighboring points. It is computed using the truncated Gaussian weighting
function

$W_{ij}=\begin{dcases}\exp\left(-c_{W}\frac{||\vec{x}_{j}-\vec{x}_{i}||^{2}}{h^{2}_{i}+h^{2}_{j}}\right),&\text{if
}\vec{x}_{j}\in S_{j}\\\ 0,&\text{otherwise}\end{dcases}$

for a constant $c_{W}\in[2,8]$. Smaller values of $c_{W}$ make the weighting
function broader, allowing a bigger contribution of distant neighbors.
Whereas, larger values lead to a stronger influence of the nearest neighbors.

##  3 Physical Model

The physical model in MESHFREE is based on the conservation equations for
mass, momentum, and energy in Lagrangian form. As temperature is irrelevant
for the later use case in Section 5, we consider the following reduced set of
equations:

$\displaystyle\frac{d\rho}{dt}$
$\displaystyle=-\rho\nabla^{\mathrm{T}}\vec{u},$
$\displaystyle\frac{d\vec{u}}{dt}$ $\displaystyle=-\frac{1}{\rho}\nabla
p+\frac{1}{\rho}(\nabla^{\mathrm{T}}\mathbf{S})^{\mathrm{T}}+\vec{g}.$

Here, $\frac{d}{dt}=\frac{\partial}{\partial t}+\vec{u}^{\mathrm{T}}\nabla$ is
the material derivative, $\nabla=\left(\frac{\partial}{\partial
x},\frac{\partial}{\partial y},\frac{\partial}{\partial
z}\right)^{\mathrm{T}}$ is the nabla operator, $\rho\in\mathbb{R}^{+}$ is the
density, $\vec{u}\in\mathbb{R}^{3}$ is the velocity, $p\in\mathbb{R}$ is the
pressure, $\vec{g}\in\mathbb{R}^{3}$ are the external forces, and
$\mathbf{S}\in\mathbb{R}^{3}\times\mathbb{R}^{3}$ is the stress tensor. For a
detailed description of the time integration scheme used to solved these
equations, see 2018suchdeGFDMNS  and 2018suchdePointMovement .

With regards to the later use case of 3D flow around a cylinder, drag force
$F_{\mathrm{D}}$ and lift force $F_{\mathrm{L}}$ on a surface $S$ are
determined by

$\displaystyle F_{\mathrm{D}}$
$\displaystyle=\int_{S}\left(\rho\nu\frac{\partial\vec{u}}{\partial\vec{n}}n_{y}-pn_{x}\right)dS,$
$\displaystyle F_{\mathrm{L}}$
$\displaystyle=-\int_{S}\left(\rho\nu\frac{\partial\vec{u}}{\partial\vec{n}}n_{x}+pn_{y}\right)dS,$

where $\vec{n}=(n_{x},n_{y},n_{z})^{\mathrm{T}}$ is the normal with respect to
$S$ and $\nu\in\mathbb{R}^{+}$ is the kinematic viscosity. Drag coefficient
$C_{\mathrm{D}}$ and lift coefficient $C_{\mathrm{L}}$ can be computed based
on the mean velocity $\overline{u}$ as well as the diameter $D_{\mathrm{cyl}}$
and the length $H_{\mathrm{cyl}}$ of the cylinder:

$\displaystyle C_{\mathrm{D}}$ $\displaystyle=\frac{2\cdot
F_{\mathrm{D}}}{\rho\bar{u}^{2}D_{\mathrm{cyl}}H_{\mathrm{cyl}}},$
$\displaystyle C_{\mathrm{L}}$ $\displaystyle=\frac{2\cdot
F_{\mathrm{L}}}{\rho\bar{u}^{2}D_{\mathrm{cyl}}H_{\mathrm{cyl}}}.$ (1)

##  4 Research Question

Setting up and running a fluid flow simulation potentially involves tuning
several parameters to obtain an accurate solution in optimized computation
time, e.g. certain parameters might require domain knowledge. The more complex
the application, the greater the number of parameters. Consequently, the
balance between results accuracy and computation time is a major challenge,
especially for inexperienced MESHFREE users. One option to assist
inexperienced users is to pre-select those parameters that have a big
influence and prescribe corresponding ranges with additional information about
the trade-off between accuracy and efficiency.

###  4.1 Parameter Selection

Similar to other simulation tools, the characteristic length of the domain
discretization is one of the most important parameters in MESHFREE, namely the
interaction radius $h$. Here, we use a geometry-dependent local refinement
with minimum interaction radius _Hmin_ close to the region of interest
(cylinder in the later use case) and maximum interaction radius _Hmax_ outside
of the region of interest with a linear increase from _Hmin_ to _Hmax_ in a
transfer region.

As described in Section 2, the GFDM approximation of differential operators at
a given point is computed based on neighboring points within the local
interaction radius $h$. The maximum number of neighboring points selected for
the approximation can be controlled by the parameter _max_N_stencil_ , where
the selection depends on the closest distance from the central point.

Due to the Lagrangian formulation, point positions are updated in each time
step. Consequently, the positions of the neighboring points will change as
well, requiring an update of the local neighborhood for all the points. This
is controlled by the parameter _COMP_DoOrganizeOnlyAfterHowManyCycles_.

The local solutions of pressure and velocity are computed with a fixed point
iteration. Accordingly, convergence criteria have to be set by parameters
_eps_p_ and _eps_v_ , respectively.

The approximation order of the local stencils $c^{*}_{ij}$ depends on the
chosen order of monomials and can be controlled separately for the gradient
operator (_ord_grad_), the Laplace operator (_ord_laplace_) and for the
creation of new points (_ord_eval_).

Furthermore, the constant $c_{W}$ in the weighting kernel $W_{ij}$ can be
adapted for the Laplace operator (_DIFFOP_kernel_Laplace_) as well as for the
normal derivative (_DIFFOP_kernel_Neumann_).

Table 4.1 provides an overview of the selected parameters. More details
regarding the respective parameters can be found in the MESHFREE
documentation, see 2024MESHFREEDocu .

Table 1: Parameters chosen for optimization and (range of) values

Parameter |  In MESHFREE |  Values
---|---|---
Local interaction radius |  |
$\bullet$ minimum |  _Hmin_ |  0.005 - 0.01 m
$\bullet$ maximum |  _Hmax_ |  0.03 - 0.1 m
Neighbor points |  |
$\bullet$ maximum number |  _max_N_stencil_ |  30, 40
$\bullet$ update |  _COMP_DoOrganizeOnlyAfterHowManyCycles_ |  1 - 4
Convergence criteria |  |
$\bullet$ velocity equation |  _eps_v_ |  $1e^{-4}$,$1e^{-5}$,$1e^{-6}$
$\bullet$ pressure equation |  _eps_p_ |  $1e^{-4}$,$1e^{-5}$,$1e^{-6}$
Order of monomials |  |
$\bullet$ gradient operator |  _ord_grad_ |  2, 3
$\bullet$ Laplace operator |  _ord_laplace_ |  2, 2.9, 3
$\bullet$ creation of new points |  _ord_eval_ |  2, 3
Weighting kernel $c_{W}$ |  |
$\bullet$ Laplace operator |  _DIFFOP_kernel_Laplace_ |  2, 6
$\bullet$ normal derivative |  _DIFFOP_kernel_Neumann_ |  2, 5

##  5 Use Case and Description of the Underlying Data

In this section, we outline the considered use case detailing the simulation
setup – including geometry, boundary conditions, and fluid properties.
Additionally, we describe the data generation process featuring initial
parameter ranges, sampling methodology, and an exploration of parameter
correlations.

###  5.1 Simulation Setup

To study the influence of the selected parameters on accuracy and efficiency,
a simple use case is employed. The 3D flow around a cylinder presented in
Schaefer1996  was chosen due to its relative simplicity in setup and
availability of validation data. Thereby, a 3D cylinder is placed in a hollow
rectangular extruded domain perpendicular to the flow direction. The setup of
the geometry is illustrated in Figure 1. The length of the considered channel
is $2.5\text{\,}\mathrm{m}$ along the $x$-axis. The height and width are
$$0.41\text{\,}\mathrm{m}$\times$0.41\text{\,}\mathrm{m}$$ in $y$-$z$-plane.
The cylinder extends along the entire width of the wall with a diameter of
$D=$0.1\text{\,}\mathrm{m}$$. The cylinder is positioned
$0.41\text{\,}\mathrm{m}$ downstream from the inflow and
$0.15\text{\,}\mathrm{m}$ above the bottom wall. At the end of the channel,
the flow exits through the outflow.

inflow2.5 moutflowwall0.41 m0.41 mcylinder0.1 m0.16 m0.41 m0.15
mwallwallwallZXY

Figure 1: Geometrical setup of the 3D flow around a cylinder

As described in Section 4.1, we employ a geometry-dependent definition of the
interaction radius around the cylinder. To be more precise, this is a radial
refinement in which the minimum interaction radius _Hmin_ is used up to a
distance of $0.17\text{\,}\mathrm{m}$ from the cylinder. Outside of this,
there is a linear increase towards the maximum interaction radius _Hmax_. As
an example, Figure 2 shows the resulting point cloud for _Hmin_ $\
=$8.5\text{\times}{10}^{-3}\text{\,}\mathrm{m}$$ and _Hmax_ $\
=$3.9\text{\times}{10}^{-2}\text{\,}\mathrm{m}$$. The cylinder is colored
magenta for better visibility.

Figure 2: Point cloud and resulting interaction radius distribution for _Hmin_
$\ =$8.5\text{\times}{10}^{-3}\text{\,}\mathrm{m}$$ and _Hmax_ $\
=$3.9\text{\times}{10}^{-2}\text{\,}\mathrm{m}$$

For the simulations, we consider an incompressible Newtonian fluid with
kinematic viscosity
$\nu=$1\text{\times}{10}^{-3}\text{\,}{\mathrm{m}}^{2}\text{\,}{\mathrm{s}}^{-1}$$
and density $\rho=$1.0\text{\,}\mathrm{kg}\text{\,}{\mathrm{m}}^{-3}$$. A
homogeneous Dirichlet boundary condition is used at the channel walls and on
the surface of the cylinder, i.e.
$\vec{u}=$0\text{\,}\mathrm{m}\text{\,}{\mathrm{s}}^{-1}$$. At the inflow, we
prescribe a velocity profile in $x$-direction according to Equation (2) and
zero velocity in tangential directions, i.e.
$u_{y}=u_{z}=$0\text{\,}\mathrm{m}\text{\,}{\mathrm{s}}^{-1}$$:

$u_{x=0}(y,z,t)=\frac{16\cdot
U_{m}yz(H_{\mathrm{ch}}-y)(H_{\mathrm{ch}}-z)}{H_{\mathrm{ch}}^{4}},$ (2)

where $U_{m}=$2.25\text{\,}\mathrm{m}\text{\,}{\mathrm{s}}^{-1}$$ is the
maximum inflow velocity, $H_{\mathrm{ch}}$ is the height of the channel, and
$t=$2\text{\,}\mathrm{s}$$ is the simulation time. Thus, the Reynolds number
$Re$ is determined as

$\displaystyle Re$ $\displaystyle=\frac{\overline{u}D_{\mathrm{cyl}}}{\nu},$
$\displaystyle\overline{u}$ $\displaystyle=\frac{4\cdot u_{x=0}\left(0.5\cdot
H_{\mathrm{ch}},0.5\cdot H_{\mathrm{ch}},t\right)}{9}.$

The drag and lift coefficients $C_{\mathrm{D}}$ and $C_{\mathrm{L}}$ are
evaluated according to Equation (1) in each time step. To mitigate result
fluctuations, the final drag and lift coefficients used in the informed ML
strategies are averaged over the last 100 time steps. Figure 3 shows an
example of the evolution of $C_{\mathrm{D}}$ (red line) and $C_{\mathrm{L}}$
(blue line) over the simulation time for a selected data sample. The dashed
lines represent the range of lift and drag coefficients for the benchmarks in
Schaefer1996 . Good agreement with these values can be observed at the end of
the MESHFREE simulation.

Figure 3: Comparison of the temporal evolution of drag (red line) and lift
(blue line) coefficients for a selected data sample with the corresponding
ranges for the benchmarks in Schaefer1996  (dashed lines)

###  5.2 Data Generation

The preliminary input parameter ranges were set as described in Table 4.1.
This served as the foundation for generating an initial sample space of 400
through Latin Hypercube Sampling (LHS) florian1992lhs . LHS has been employed
for its capacity to produce samples that closely mirror the true underlying
distribution, resulting in smaller sample sizes compared to simple random
sampling. This helped to enhance the efficiency in exploring the parameter
space. Each data sample served as a specific input parameter combination for a
MESHFREE simulation.

###  5.3 Initial Data Exploration

Figure 4: Correlation matrix for the selected parameters, drag and lift
coefficients, as well as computation time

Figure 4 illustrates the correlation among the selected input parameters,
simulation quality parameters like the drag and lift coefficients, as well as
computation time using a heat map visualization, offering valuable insights
into the relationships within the sampled space. As expected, the minimum
local interaction radius _Hmin_ has a strong inverse effect on the computation
time. Among the others, _ord_laplace_ influences both the drag coefficient and
the lift coefficient the most. The effects of individual input parameters on
each of the output parameters have been illustrated in a
dashboard111https://github.com/PaulamiBanerjee/ML4MESHFREE. We summarize here
a few of the takeaways derived from the plots available there.

  * •

The variance in both the drag coefficient and the lift coefficient increases
with an increase in _Hmax_.

  * •

_max_N_stencil_ = _40_ produces better results for the drag coefficient.

  * •

_ord_laplace_ = _2.9_ produces better results for both the drag coefficient
and the lift coefficient.

  * •

Using _DIFFOP_kernel_Neumann_ = _2_ gives relatively better results for the
lift coefficient.

Having gained these valuable insights from the initial data exploration, we
now delve into the methods employed in our research to further investigate the
influence of the selected parameters on accuracy and efficiency.

##  6 Approach

While much of the existing research involving the use of ML models in meshfree
methods focuses on surrogate modeling – aiming to comprehend the inherent
workings of the numeric solver – our objective is different. Rather than
creating a surrogate model for the MESHFREE software, our aim is to enhance
the user experience by assisting in selecting optimal parameter combinations
to achieve a good balance between results accuracy and computation time, as
already outlined in Section 4. Additionally, we have aspired to provide users
with an estimated range instead of point estimates, within which the drag and
lift coefficients of a particular simulation might reside, coupled with
insights about the computation time. With these objectives in mind and
acknowledging the limited data availability due to relying on simulations
whose computation times range from hours to days (depending on the input
parameter combination), we have adopted the following approach. Firstly, we
implemented a parameter range selection strategy using Active Learning and
secondly, we produced a conformal prediction of output parameter estimates
using decision-tree-based ensemble regression models.

###  6.1 Parameter Range Selection Using Active Learning

While selecting values that yield favorable results is relatively
straightforward in some instances (as highlighted in Section 5.3), it becomes
more challenging in others. This complexity is exemplified in Figure 5
illustrating the cause-and-effect relationship between _Hmax_ and the lift
coefficient $C_{\mathrm{L}}$. As _Hmax_ decreases, the resulting lift
coefficient are often within the red dashed lines, which indicate the
benchmark range in Schaefer1996 . This corresponds to intuitive expectations.
However, relying solely on visualization makes it difficult to pinpoint the
precise optimal range for this specific parameter in combination with the
other parameters.

Figure 5: Cause-and-effect relationship between _Hmax_ and lift coefficient
$C_{\mathrm{L}}$ (blue dots) and benchmark range in Schaefer1996  (red dashed
line)

In response to this challenge and recognizing the computational expense of
running exhaustive simulations across all parameter combinations, we have
turned to Active Learning strategies settles2009active . Active Learning
involves an adaptive learning algorithm that selectively identifies and labels
the most informative samples, mitigating the demand for extensive labeled
data. In our approach, the strategy entails training a Decision Tree
classifier as the learning algorithm.

In each iteration of the learning process, we establish a decision boundary
within the hypercube, where each dimension corresponds to a simulation
parameter. Analogous to setting distinct zones within the hypercube, this
decision boundary is particularly relevant in the context of our chosen
regression model. It delineates regions in the decision trees where splits
occur, guiding our focus during subsequent sampling. Feature ranges are then
refined to include 10% on either side of the decision boundary. This is done
to accommodate the uncertainty of the learning process. LHS was performed
within these refined feature ranges. MESHFREE simulations were conducted on
the newly generated sample space, and the resulting outputs were labeled. If
the resulting drag and lift coefficients do not lie within their respective
optimum ranges, the learner tree is queried on this newly generated data about
which cases it is more uncertain about, and the corresponding labels are
taught to the learner. This iterative process was systematically repeated
until we were able to successfully generate a whole set of data with all the
output parameters in the optimum ranges. Figure 6 illustrates the flow of
information in the described process.

Figure 6: Flow of information in the Active Learning module

###  6.2 Conformal Prediction using Ensemble Regression Models

Our objective is to forecast estimated intervals in which the three output
parameters (drag and lift coefficient, computation time) are most likely to
reside. To address this multi-output regression problem, we have implemented
decision-tree-based ensemble regression models and the concept of Conformal
Prediction taquet2022mapie  for predicting the estimated intervals.

Tree-based regression models are well-suited for tabular data
grinsztajn2022tree . However, the ideal scenario for any machine learning task
involves a substantial amount of data (ranging at least in tens of thousands).
In our case, the reliance on computationally expensive simulations has
resulted in a relatively limited dataset (ranging in hundreds). To address
this challenge, boosting algorithms mayr2014evolution  were incorporated in
the work as well. Boosting algorithms iteratively enhance the performance of a
weak learner by giving more weight to instances with higher uncertainty,
thereby creating a stronger ensemble model. An initial performance comparison
of various regression models for each of the output parameters was conducted.
The four best performing models in each case are presented in Table 6.2. This
comparison is based on the following error metrics: Mean Absolute Error (MAE),
Mean Squared Error (MSE), Coefficient of determination (R2), and Mean Absolute
Percentage Error (MAPE). Subsequently, three of the top performing models in
each case – Random Forest Regressor, Extra Trees Regressor, and Light Gradient
Boosting (LGBM) Regressor – were selected for further exploration.

Table 2: Initial performance comparison of regression models (b)  (c)

Figure 7: Feature importance scores for (a) drag coefficient, (b) lift
coefficient, and (c) computation time

To better understand the behavior of the models, we conducted a Feature
Importance analysis, which is illustrated in Figure 4.1. This shed light on
the significance of each input parameter in the models for predicting the
respective output parameter. Based on this analysis, the dimensionality of the
input parameter space for each regression model was reduced to include only
those parameters with feature importance score of more than 2%. The final set
of input parameters considered for each output parameter is outlined in Table
4.1.

Table 4: Final set of input parameters after Feature Importance analysis

Output Parameter |  Input Parameters
---|---
Drag coefficient |  {_Hmin, Hmax, COMP_DoOrganizeOnlyAfterHowManyCycles, max_N_stencil, ord_laplace, DIFFOP_kernel_Neumann_}
Lift coefficient |  {_Hmin, Hmax, max_N_stencil, ord_gradient, ord_laplace, DIFFOP_kernel_Neumann_}
Computation time |  {_Hmin, Hmax, DIFFOP_kernel_Laplace_}

The final regression models were then used to predict intervals within which
the output parameters might lie, given the high uncertainty associated with
point estimates (specific values for outputs that are predicted by regression
models). This approach acknowledges and quantifies the uncertainty inherent in
the predictions, enabling more informed decision-making. To achieve this, the
method of Conformal Prediction was implemented. It is a statistical tool used
in regression analysis to estimate prediction intervals for ML models.
Furthermore, it provides a framework that is model agnostic, allowing it to
adapt to various regression algorithms without relying on specific assumptions
about the data distribution or model form, which enhances its robustness and
applicability.

In this implementation, the tolerance parameter $\alpha$ plays a significant
role in balancing the trade-off between the size of the predicted intervals
and the quality of the prediction. After discussing with domain experts, we
have used $\alpha_{C_{\mathrm{D}}}=0.15$, $\alpha_{C_{\mathrm{L}}}=0.2$, and
$\alpha_{\mathrm{CT}}=0.1$ for the models predicting drag coefficient, lift
coefficient, and computation time (CT) intervals, respectively. This means
that the model may have 15%, 20%, and 10%, respectively, of the actual values
outside the predicted intervals. Figure 8 summarizes the flow of information
for the prediction of each output parameter as described in this subsection.

Figure 8: Flow diagram for each output parameter interval prediction

##  7 Results and Key Findings

In this section, we present the results of our investigation of the influence
of various parameters on simulation results quality and computation time using
the MESHFREE software. Our findings provide valuable guidance for optimizing
parameter selection as well as enhancing the efficiency and accuracy of fluid
flow simulations.

###  7.1 Active Learning Module

A representation of the final decision-tree from the Active Learning module
explained in Section 6.1 is illustrated in Figure 9. _class 1_ and _class 0_
in the leaf nodes refer to cases with optimal and non-optimal outputs,
respectively. Our findings regarding the optimized input parameter ranges are
as follows:

  * •

_Hmin_ should be kept between (ideally) _0.005_ and _0.007_.

  * •

_Hmax_ should be kept between (ideally) _0.046_ and _0.06_ with _Hmax_ $>$
_Hmin_.

  * •

_COMP_DoOrganizeOnlyAfterHowManyCycles_ can be chosen according to the initial
range. However, to keep the computation time to a minimum, a value of _3_ or
_4_ was found to be ideal.

  * •

Best results are achieved with _max_N_stencil_ = _40_.

  * •

_eps_p_ and _eps_v_ can be chosen according to the initial range, too. But
using a higher value is recommended to keep the computation time to a minimum.

  * •

_ord_grad_ can be chosen according to the initial range.

  * •

If _Hmax_ $\leq$ _0.046_ , _ord_laplace_ = _2.9_ provides the best results,
otherwise _3_.

  * •

_ord_eval_ can be chosen according to the initial range.

  * •

_DIFFOP_kernel_Laplace_ can be chosen according to the initial range.

  * •

_DIFFOP_kernel_Neumann_ can be chosen according to the initial range, too.
However, in combination with _ord_laplace_ = _2.9_ and _Hmax_ $\leq$ 0.046 a
value of _5_ is recommended.

Maintaining these optimized parameter ranges, the user will have an 87% chance
of achieving a good trade-off between accuracy and efficiency.

Figure 9: Final decision-tree for selecting optimized parameter ranges

###  7.2 Interval Prediction

Table 5: Error metrics of the final regression models

Model |  MAE |  MSE |  R2 |  MAPE
---|---|---|---|---
Drag coefficient model |  0.4661 |  0.4012 |  0.9879 |  0.1871
Lift coefficient model |  0.0134 |  0.0005 |  0.9812 |  3.3515
Computation time model |  1.4157 |  16.1815 |  0.9313 |  0.0906

The error metrics of the final ensemble models are shown in Table 7.2. A clear
improvement in the performance of the individual models can be observed, as
compared to Table 6.2. Tab 2 of the dashboard visualizes the performance of
our trained regression models on a test dataset of 20 random test cases. Here
is a summary of our observations:

  * •

A higher value for _COMP DoOrganizeOnlyAfterHowManyCycles_ leads to
predictions with lower variance in the drag coefficient, compared to lower
values.

  * •

For _max_N_stencil_ = _30_ , the actual values of the lift coefficient are
more often outside the upper and lower limits of the predicted interval,
indicating more incorrect predictions than for _max_N_stencil_ = _40_.

  * •

The actual outputs for cases with _ord_laplace_ = _2.9_ lie perfectly in
between the predicted interval for both the drag coefficient and the lift
coefficient.

The amount of stochasticity in the simulation due to specific feature
parameter values or a combination of them play a significant role in whether
our predicted intervals are able to accurately capture the actual output
within their range. Cases with _max_N_stencil_ = _40_ but higher values for
_Hmin_ as well as _Hmax_ are more likely to be incorrectly predicted than
others. While a higher value of _COMP_DoOrganizeOnlyAfterHowManyCycles_ also
brings in its fair share of randomness in the simulation, keeping a stencil
size of _max_N_stencil_ = _40_ was observed to neutralize its effect on the
predictions, reducing the corresponding computation time to a minimum.

We have implemented a predictor tool using our trained models in Tab 3 of the
dashboard, as shown in Figure 10. It helps users get an estimate on the ranges
for the simulation quality and computation time upon adjusting the input
parameter values. Parameters _eps_p_ , _eps_v_ and _ord_eval_ have been
excluded from this tool since they were not included in the predictions for
any of the output parameter intervals.

Figure 10: Tab 3 of dashboard showing the implemented tool for predictions

##  8 Conclusion and Outlook

In this publication, we delved into the realm of meshfree simulation methods,
particularly focusing on the integration of machine learning into the MESHFREE
software developed by Fraunhofer ITWM and Fraunhofer SCAI. By moving away from
conventional mesh-based approaches, this software streamlines the simulation
process by eliminating the need for extensive mesh generation and re-meshing,
especially in cases of complex and deformable domains or free surface flows.

During the investigation, we identified key parameters inherent in the
MESHFREE software stemming from the underlying GFDM. Understanding these
parameters is pivotal for configuring simulations effectively, particularly
for inexperienced users. Our primary goal was to empower users with the
ability to navigate the simulation tool seamlessly, even in the absence of
prior knowledge of meshfree methods and the specific method. To achieve this
goal, we have chosen a simple test case, the 3D flow around a cylinder
according to Schaefer1996 .

Our research emphasizes the importance of parameter selection for the balance
between simulation accuracy and computational cost. We addressed the challenge
of parameter interdependence and fine-tuning by providing pre-selected
parameter ranges tailored for optimal efficiency and accuracy, using active
learning strategies. By systematically recording the effects of parameters on
computation time, drag and lift coefficients, and using ensemble decision-
tree-based regression models, we facilitated informed decision-making and
optimized computational resources.

Future research efforts will explore advanced parameter optimization and
sensitivity analysis techniques to further improve the efficiency and
reliability of meshfree simulations. In addition, efforts should be directed
towards the development of user-friendly interfaces and tutorials to promote
the acceptance of meshfree simulation tools among an even broader user base
than today.

In essence, this study contributes to the continuous development of meshfree
simulation methods by providing insights and solutions to the challenges
encountered in effectively configuring and running simulations. By empowering
users with the necessary tools and knowledge, we are paving the way for a more
accessible and efficient approach to simulating fluid flows and more generally
continuum mechanical processes in various engineering applications.

###### Acknowledgements.

This research was partially funded by the Hessian Ministry of Higher
Education, Research, Science and the Arts, Germany (FL1, Mittelbau).

## Author Contribution

The authors contributed as follows: PB contributed to conceptualization, data
generation, methodology, visualization, results analysis and interpretation,
as well as writing the original draft, and reviewing and editing the
manuscript. MP was involved in conceptualization, use case design, data
generation, visualization, results analysis and interpretation, writing the
original draft, and reviewing and editing. CS contributed to
conceptualization, use case design, data generation, and reviewing and
editing. IM contributed to conceptualization, data generation, supervision,
and reviewing and editing. SG contributed to conceptualization, supervision,
and reviewing and editing.

All authors reviewed the results and approved the final version of the
manuscript.

## Conflict of Interest

The authors declare that there are no conflicts of interest associated with
this work.

## References

  * (1) Erdebilli, B. & Devrim-İçtenbaş, B. Ensemble voting regression based on machine learning for predicting medical waste: a case from Turkey. Mathematics. 10, 2466 (2022)
  * (2) Florian, A. An efficient sampling scheme: updated latin hypercube sampling. Probabilistic Engineering Mechanics. 7, 123-130 (1992)
  * (3) Grinsztajn, L., Oyallon, E. & Varoquaux, G. Why do tree-based models still outperform deep learning on typical tabular data? Advances In Neural Information Processing Systems. 35, 507-520 (2022)
  * (4) Hamrani, A., Akbarzadeh, A., Madramootoo, C. & Bouarab, F. Machine learning surrogate modeling for meshless methods: Leveraging universal approximation. International Journal Of Computational Methods. 20, 2141022 (2023)
  * (5) Huang, K., Krügener, M., Brown, A., Menhorn, F., Bungartz, H. & Hartmann, D. Machine learning-based optimal mesh generation in computational fluid dynamics. ArXiv Preprint ArXiv:2102.12923 (2021)
  * (6) Jiang, C., Esmaeilzadeh, S., Azizzadenesheli, K., Kashinath, K., Mustafa, M., Tchelepi, H., Marcus, P., Prabhat & Anandkumar, A. MeshfreeFlowNet: a physics-constrained deep continuous space-time super-resolution framework. Proceedings Of The International Conference For High Performance Computing, Networking, Storage And Analysis. https://ieeexplore.ieee.org/document/9355293 (2020)
  * (7) Kuhnert, J., Michel, I. & Mack, R. Fluid Structure Interaction (FSI) in the MESHFREE Finite Pointset Method (FPM): Theory and Applications. Meshfree Methods For Partial Differential Equations IX. pp. 73-92 (2019), https://doi.org/10.1007/978-3-030-15119-5-5
  * (8) Kuhnert, J. MESHFREE simulations in car design: Closing the gaps of classical simulation tools. German Success Stories In Industrial Mathematics. pp. 129-134 (2021), https://doi.org/10.1007/978-3-030-81455-7-21
  * (9) Lee, J., Bäder, D., Rehfeldt, S., Eisenträger, A., Kuhnert, J., Michel, I., Suchde, P. & Klein, H. Modeling evaporation with a meshfree collocation approach. Computational Particle Mechanics. 10, 1989-2007 (2023), https://doi.org/10.1007/s40571-023-00602-0
  * (10) LeFloch, P. & Mercier, J. Mesh-free algorithms for a class of problems arising in finance and machine learning. https://dx.doi.org/10.2139/ssrn.3790066 (2021)
  * (11) Leithäuser, C., Norrefeldt, V., Thiel, E., Buschhaus, M., Kuhnert, J. & Suchde, P. Predicting aerosol transmission in airplanes: Benefits of a joint approach using experiments and simulation. International Journal for Numerical Methods in Fluids. pp. 1-20 (2024), https://doi.org/10.1002/fld.5277
  * (12) Löhner, R. & Oñate, E. An advancing front point generation technique. Communications In Numerical Methods In Engineering. 14, 1097-1108 (1998), https://api.semanticscholar.org/CorpusID:121192064
  * (13) Mayr, A., Binder, H., Gefeller, O. & Schmid, M. The evolution of boosting algorithms. Methods Of Information In Medicine. 53, 419-427 (2014)
  * (14) MESHFREE Team. Online documentation for MESHFREE. Fraunhofer ITWM & SCAI. (2024) https://meshfree.pages.fraunhofer.de/docu/html/MESHFREE.html
  * (15) MESHFREE Team. MESHFREE software, beta ver. 11.3. Fraunhofer ITWM & SCAI. (2022) https://www.meshfree.eu/
  * (16) Michel, I., Seifarth, T., Kuhnert, J. & Suchde, P. A meshfree generalized finite difference method for solution mining processes. Computational Particle Mechanics. 8, 561-574 (2021), http://link.springer.com/article/10.1007/s40571-020-00353-2
  * (17) Michel, I., Bathaeian, I., Kuhnert, J., Kolymbas, D., Chen, C.-H., Polymerou, I., Vrettos, C. & Becker A. Meshfree generalized finite difference methods in soil mechanics – part II: numerical results. International Journal on Geomathematics. 8, 191-217 (2017), https://doi.org/10.1007/s13137-017-0096-5
  * (18) Pfaff, T., Fortunato, M., Sanchez-Gonzalez, A. & Battaglia, P. Learning mesh-based simulation with graph networks. ArXiv Preprint ArXiv:2010.03409 (2020)
  * (19) Schäfer, M., Turek, S., Durst, F., Krause, E. & Rannacher, R. Benchmark computations of laminar flow around a cylinder. Flow Simulation With High-Performance Computers II: DFG Priority Research Programme Results 1993–1995. pp. 547-566 (1996), https://doi.org/10.1007/978-3-322-89849-4-39
  * (20) Settles, B. Active learning literature survey. University of Wisconsin-Madison, Department of Computer Sciences. http://digital.library.wisc.edu/1793/60660 (2009)
  * (21) Suchde, P., Kraus, H., Bock-Marbach, B. & Kuhnert, J. Meshfree one-fluid modeling of liquid-vapor phase transitions. Computers & Fluids. 273, 106211 (2024), https://doi.org/10.1016/j.compfluid.2024.106211
  * (22) Suchde, P., Jacquemin, T. & Davydov, O. Point cloud generation for Meshfree methods: An overview. Archives of Computational Methods in Engineering. 30, 889-915 (2023), https://doi.org/10.1007/s11831-022-09820-w
  * (23) Suchde, P. & Kuhnert, J. A fully Lagrangian meshfree framework for PDEs on evolving surfaces. Journal of Computational Physics. 395 pp. 38-59 (2019), https://doi.org/10.1016/j.jcp.2019.06.031
  * (24) Suchde, P., Kuhnert, J. & Tiwari, S. On meshfree GFDM solvers for the incompressible Navier–Stokes equations. Computers & Fluids. 165, 1-12 (2018), https://doi.org/10.1016/j.compfluid.2018.01.008
  * (25) Suchde, P. & Kuhnert, J. Point cloud movement for fully Lagrangian meshfree methods. Journal of Computational and Applied Mathematics. 340, 89-100 (2018), https://doi.org/10.1016/j.cam.2018.02.020
  * (26) Suchde, P., Kuhnert, J., Schröder, S. & Klar, A. A flux conserving meshfree method for conservation laws. International Journal for Numerical Methods in Engineering. 112, 238-256 (2017), https://doi.org/10.1002/nme.5511
  * (27) Taquet, V., Blot, V., Morzadec, T., Lacombe, L. & Brunel, N. MAPIE: an open-source library for distribution-free uncertainty quantification. ArXiv Preprint ArXiv:2207.12274 (2022)
  * (28) Uhlmann, E., Barth, E., Seifarth, T., Höchel, M., Kuhnert, J. & Eisenträger, A. Simulation of metal cutting with cutting fluid using the Finite-Pointset-Method. Procedia CIRP. Volume 101, 98-101 (2021), https://doi.org/10.1016/j.procir.2021.02.013
  * (29) Veltmaat, L., Mehrens, F., Endres, H., Kuhnert, J. & Suchde, P. Mesh-free simulations of injection molding processes. Physics Of Fluids. 34, 33102 (2022), https://doi.org/10.1063/5.0085049
  * (30) Von Rueden, L., Mayer, S., Beckh, K., Georgiev, B., Giesselbach, S., Heese, R., Kirsch, B., Pfrommer, J., Pick, A., Ramamurthy, R. & Others Informed machine learning–a taxonomy and survey of integrating prior knowledge into learning systems. IEEE Transactions On Knowledge And Data Engineering. 35, 614-633 (2021)
  * (31) Zehnder, J., Li, Y., Coros, S. & Thomaszewski, B. Ntopo: Mesh-free topology optimization using implicit neural representations. Advances in Neural Information Processing Systems. 34, 10368-10381 (2021)