semvec/pypi-packages huggingface dataset:
KratosSwimmingDEMApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

## Swimming DEM Application
KratosShapeOptimizationApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

# ShapeOptimizationApplication

The Kratos ShapeOptimizationApplication contains an implementation of the Vertex Morphing method for node-based shape optimization.

It can be used in combination with the Adjoint Sensitivity Analysis capabilities of the Kratos StructuralMechanicsApplication and ConvectionDiffusionApplication.
Additionally it offers an interface to use external response functions via custom python code.


## Examples

A few application examples can be found [here](https://github.com/KratosMultiphysics/Examples/tree/master/shape_optimization)


### References

- Bletzinger, K.-U. A consistent frame for sensitivity filtering and the vertex assigned morphing of optimal shape. Struct Multidisc Optim 49, 873–895 (2014). https://doi.org/10.1007/s00158-013-1031-5
- Bletzinger, K.-U. (2017). Shape Optimization. In Encyclopedia of Computational Mechanics Second Edition (eds E. Stein, R. Borst and T.J.R. Hughes). https://doi.org/10.1002/9781119176817.ecm2109
KratosShallowWaterApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

# Shallow water application

This is a research application that provides a set of tools for oceanographic and hydrographic simulations over shallow domains. The background of the stabilization method is explained in [^1].

## Overview

|               | BDF                | Crank-Nicolson     | Adams-Moulton      |
|---------------|:------------------:|:------------------:|:------------------:|
| Gravity waves | :heavy_check_mark: | :heavy_check_mark: |                    |
| Saint-Venant  | :heavy_check_mark: |                    |                    |
| Boussinesq    | :heavy_check_mark: |                    | :heavy_check_mark: |

## Dependencies

This application does not have other application dependencies at compile time. The following Python libraries may be required:

- `scipy` is used by the wave generator and by the benchmarks
- `numpy` is used to generate solitary waves and analytical solutions by the benchmarks

If the coupling with the Navier-Stokes equations is required [^2], add the following applications to compilation:

- [HDF5Application](../HDF5Application/README.md)
- [MappingApplication](../MappingApplication/README.md)
- [PfemFluidDynamicsApplication](../PfemFluidDynamicsApplication/README.md)

## References

[^1]: M. Masó, I. De-Pouplana, E. Oñate. A FIC-FEM stabilized formulation for the shallow water equations over partially dry domains. Computer Methods in Applied Mechanics and Engineering, 389C (2022) 114362 [10.1016/j.cma.2021.114362](https://doi.org/10.1016/j.cma.2021.114362)

[^2]: M. Masó, A. Franci, I. de-Pouplana, A. Cornejo and E. Oñate, A Lagrangian-Eulerian procedure for the coupled solution of the Navier-Stokes and shallow water equations for landslide-generated waves. Advanced Modelling and Simulation in Engineering Sciences, (2022) [10.21203/rs.3.rs-1457837/v1](https://doi.org/10.21203/rs.3.rs-1457837/v1) (in press)
KratosPoromechanicsApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

## Poromechanics Application

The Poromechanics Application contains developments in coupled solid-pore fluid interaction problems within Kratos Multiphysics.

### Features:

- UPl small displacement element for saturated porous media (with
equal order interpolation, unstable under incompressible-undrained
conditions)

- Stable UPl small displacement element for saturated porous media
(with higher order interpolation for displacements)

- FIC-Stabilized UPl small displacement element for saturated porous media
(with equal order interpolation for displacements)

- UPl Quasi-zero-thickness interface elements for defining cracks and
joints

- Local linear elastic damage model (Simo-Ju and modified Von Mises)

- Non-local linear elastic damage model (Simo-Ju and modified Von
Mises)

- Bilinear cohesive fracture model (for quasi-zero-thickness interface elements)

- Fracture propagation utility based on the combination of the
damage model with the insertion of interface elements after remeshing
with GiD

- GiD GUI available in [KratosPoroGiDInterface](https://github.com/ipouplana/KratosPoroGiDInterface)
KratosOptimizationApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

# OptimizationApplication

The Kratos OptimizationApplication is a framework for solving optimization problems in continuum mechanics. It is supposed to handle both gradient-based (adjoint-based) and gradient-free methods. 

## Main Features

* State-of-the-art techniques and algorithms for shape, thickness and material/topology optimization. 
* Efficient and consistent filtering techniques for parametrization-free shape, thickness and material/topology optimization.       
* Abstract problem formulation which enables concurrent and nested multilevel-multi-scale optimization problems.    
* Adaptive gradient-projection technique, developed specially for problems with an arbitrary large number of design variables of different scales.
* Modular implementation which enables analysis and optimization of multi-physics problems.    
* Realization and implementation of additive manufacturing constraints, e.g. hangover conditions (support structures), stackability and geometric limitations.
KratosMeshMovingApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

## MeshMoving Application

The MeshMoving Application (formerly ALEapplication) contains different mesh-update techniques.

A typical application for the use of mesh-moving is in Fluid-Structure Interaction (FSI) when the fluid mesh is moved after the displacements of the structure are mapped on the interface

### Features:

- laplacian mesh motion solver

- structural similarity mesh motion solver

- computation of mesh velocities (ALE)

- ALE-fluid solver for the usage in FSI

- works both in OpenMP and MPI

### Usage

Check the tests for examples on how to use the solvers.
KratosMedApplication 10.4.0
KRATOS Multiphysics ("Kratos") is a framework for building parallel,         multi-disciplinary simulation software, aiming at modularity,         extensibility, and high performance. Kratos is written in C++,         and counts with an extensive Python interface.     
License: BSD-4-Clause
Requires Python: >=3.8

# MedApplication

The Med Application is an interface to the MED-library. This library writes med-files, which contain mesh, field results and other data, and is based on [HDF5](https://www.hdfgroup.org/solutions/hdf5/). This format is used by [Salome](https://www.salome-platform.org/) and [Code_Aster](https://code-aster.org).

## Installation
The MED-library is an external library, which must be installed before the application can be compiled

### Ubuntu

On Ubuntu, it can be installed with `sudo apt-get install libmedc-dev`. This installs all required dependencies, including HDF5

The source code is available on the Salome website for a manual installation. In this case also HDF5 needs to be installed separately.

Use `MED_ROOT` to specify the path to the MED installation in the CMake of Kratos.

### Arch / Manjaro

Packages related to *Salome* and *MED* for arch-based distros can be installed from the [AUR](https://en.wikipedia.org/wiki/Arch_Linux#Arch_User_Repository_(AUR)). The MedApplication requires [med-serial](https://aur.archlinux.org/packages/med-serial) (for non-MPI builds) or [med-openmpi](https://archlinux.org/packages/extra/x86_64/med-openmpi/) (for MPI builds with OpenMPI).
```
yay -S med-serial med-openmpi
```

## Usage
- In Salome, mesh groups are translated into SubModelParts. Different geometries and nodes can be added.
- SubSub ... Modelparts can be created by specifying a name with `.`. I.e. like it usually works in Kratos
- The number of characters is restricted in Med: 64 for main mesh name, and 80 for groups. Everything beyond these limits is cut.


## Development
- Use [HDFView](https://www.hdfgroup.org/downloads/hdfview/) to inspect the med-files.
- Make sure to check the return value of every med-library function call.
- The med library does not check if wrong data is written to the file. This must be ensured by the user, the med-library is a thin wrapper around HDF.