semvec/pypi-packages huggingface dataset:
pyQvarsi 3.2.0
Quick Visualization, Analysis and Reporting of SImulations Python module (in short pyQvarsi)
Requires Python: >=3.9
Keywords: CFD, post-processing

[![License](https://img.shields.io/badge/license-MIT-orange)](https://opensource.org/licenses/mit)

# Quick Visualization, Analysis and Reporting of SImulations Python module

The Quick Visualization, Analysis and Reporting of SImulations Python module (in short pyQvarsi) are a set of tools developed in python to interface with CFD codes using mpi-enabled tools to compute post-processing quantities in parallel.

This tool has been developed with Python 3 in mind and might not be compatible with lower version of Python.

The instructions on how to use pyQvarsi can be found in its [wiki](https://gitlab.com/ArnauMiro/pyQvarsi/-/wikis/home). In particular, on the left sidebar there are thorough instructions on how to build and deploy this tool on various platforms. The user is referred there for detailed instructions and also to find a bit of a manual on how pyQvarsi works and some examples of how it can be used.

pyQvarsi also includes some executables that run tools to perform usual operations. The user is refered [here](https://gitlab.com/ArnauMiro/pyQvarsi/-/wikis/Scripts) for a thorough explanation.

Finally, a number of examples are provided as a means to demostrate the capabilities of the tool:
* example_FEM: A little example to show the FEM operations on a silly mesh.
* example_FEM_parallel: A little example to show the FEM operations on the cavtri_03 case.
* example_COMMU: A little example to read and compute the communications matrix (used for validation).
* example_MASSM: A little example to read and compute the mass matrix (used for validation).
* example_output: A little example how to use the output formats of this tool.
* example_output_parallel: A little example how to use the output formats of this tool in parallel.
* example_avg_parallel: An example on how to compute temporal averages and reduce with the tool.
* example_avgXZ_parallel: An example on how to compute temporal averages, average on the X and Z direction, reduce and compute the BL statistics from a channel flow using VELOC.
* example_avgXZ_AVVEL_parallel: An example on how to compute temporal averages, average on the X and Z direction, reduce and compute the BL statistics from a channel flow using AVVEL.
* example_dissi_parallel: An example on how to compute the dissipation and the Kolmogorov length and time scales.
* example_checkpint_parallel: An example on how to use the checkpoint when computing the dissipation.
* example_MEP: An example on how to apply MEP to obtain the regression.
* example_GEOM: An example on how to use the Geometry module in 2D.
* example_GEOM_3D: An example on how to use the Geometry module in 3D.

Please read the instructions carefully and address any questions to [arnau.mirojane(at)bsc.es](mailto:arnau.mirojane@bsc.es) or [benet.eiximeno(at)bsc.es](mailto:benet.eiximeno@bsc.es).
pyatf 0.0.12
Auto-Tuning Framework (ATF) is a generic, general-purpose auto-tuning approach for programs whose tuning parameters may be constrained
Requires Python: >=3.9
Keywords: auto-tuning, constraints, optimization, performance, tuning

# pyATF: The Auto-Tuning Framework (ATF) in Python

Auto-Tuning Framework (ATF) is a generic, general-purpose auto-tuning approach that automatically finds well-performing values of performance-critical parameters (a.k.a. tuning parameters), such as sizes of tiles and numbers of threads.
ATF works for programs written in arbitrary programming languages and belonging to arbitrary application domains, and it allows tuning for arbitrary objectives (e.g., high runtime performance and/or low energy consumption).

A major feature of ATF is that it supports auto-tuning programs whose tuning parameters have *interdependencies* among them, e.g., the value of one tuning parameter has to be smaller than the value of another tuning parameter.
For this, ATF introduces novel process to *generating*, *storing*, and *exploring* the search spaces of interdependent tuning parameters (discussed in detail [here](https://dl.acm.org/doi/abs/10.1145/3427093)).

ATF comes with easy-to-use user interfaces to make auto-tuning appealing also to common application developers.
The Interfaces are based on either:
1. *Domain-Specific Language (DSL)*, for auto-tuning at compile time (a.k.a. offline tuning) (discussed [here](https://onlinelibrary.wiley.com/doi/full/10.1002/cpe.4423?casa_token=FO9i0maAi_MAAAAA%3AwSOYWsoqfLqcbazsprmzKkmI5msUCY4An5A7CCwi-_V8u10VdpgejcWuiTwYhWnZpaCJZ3NmXt86sg));
2. *General Purpose Language (GPL)*, for auto-tuning at runtime (a.k.a. online tuning), e.g., of *C++ programs* (referred to as [cppATF](todo), and discussed [here](https://ieeexplore.ieee.org/abstract/document/8291912)) or *Python programs* (referred to as [pyATF](todo)).

**The full GitHub repository for *pyATF*, i.e., ATF with its GPL-based Python interface can be found [here](https://github.com/atf-tuner/pyATF).**

## Documentation

The full documentation is available [here](https://atf-tuner.org/pyATF/).

## Installation

pyATF requires Python 3.9+ and can be installed using `pip`:

    pip install pyatf

pyATF's pre-implemented OpenCL and CUDA cost functions require additional packages to be installed:

- OpenCL cost function:

      pip install numpy pyopencl

  For the OpenCL cost function, a matching OpenCL runtime is also required, e.g., for Intel CPUs:

      pip install intel-opencl-rt

- CUDA cost function:

      pip install numpy cuda-python
pika-marker 0.1.1
Python tool to write PIKA marker files
Requires Python: >=3.9

# PIKA Marker Python
Python package to write PIKA marker files with timestamps.


# Installation

```
pip install pika-marker
```

## Usage 

In your Python code you can use the static function `appendPikaMarker` or create a `PikaMarker` object
to write into a marker file

```
from pika_marker import PikaMarker, appendPikaMarker

appendPikaMarker(
    "marker_file.csv",
    "my_marker",
    additional="additional info",
    icon="🔥",
    timestamp=None
)


marker = PikaMarker("marker_file.csv")
marker.appendMarker(
    "marker 2",
    additional="first marker from object",
    icon="🔥"
)
marker.close()
```

It also provides a CLI tool `append-pika-marker`

```
append-pika-marker --help             
usage: append-pika-marker [-h] [-a ADDITIONAL] [-i ICON] [-t TIMESTAMP] file name

Append a PIKA marker to a marker file.

positional arguments:
  file                  Path to the marker file
  name                  Name of the marker

options:
  -h, --help            show this help message and exit
  -a, --additional ADDITIONAL
                        Additional text
  -i, --icon ICON       Icon or emoji
  -t, --timestamp TIMESTAMP
                        Unix timestamp (defaults to current time)
```