freestream

flux libre

Streaming gratuit et correspondance Landau pour les conditions initiales hydrodynamiques invariantes de boost.

freestream est une implémentation Python du streaming libre pré-équilibre pour les collisions lourdes, comme décrit dans

• J. Liu, C. Shen, U. Heinz, "Effets de l'évolution pré-équilibre sur les observables de collision lourde", PRC 91 064906 (2015), Arxiv: 1504.02160 [NUCL-TH].
• W. Broniowski, W. FLORKOWSKI, M. Chojnacki, A. Kisiel, "Approximation libre dans la dynamique précoce des collisions lourdes relativistes", PRC 80 034902 (2009), Arxiv: 0812.3393 [NUCL-THE].

Installation

Courir simplement

 pip install freestam

Les seules exigences sont Numpy (1,8.0 ou version ultérieure) et SciPy (0,14,0 ou version ultérieure).

Problème possible: un UnicodeDecodeError peut se produire si le paramètre régional du système n'est pas défini sur un codage UTF-8 (en raison des caractères grecs de cette lecture et des docstrings de code). Pour résoudre ce problème, configurez les paramètres régionaux ou définissez simplement la variable d'environnement LANG , par exemple, export LANG=en_US.UTF-8 .

Usage

freestream a une interface orientée objet via la classe FreeStreamer , qui prend trois paramètres:

 freestream . FreeStreamer ( initial , grid_max , time )

où

• initial est un tableau carré contenant l'état initial,
• grid_max est le maximum x et y de la grille en FM, c'est-à-dire la moitié de la largeur de la grille (voir l'exemple suivant),
• time est le temps de libérer le flux en FM / C.

Le réseau initial doit contenir une condition initiale bidimensionnelle (invariante de boost) discrétisée sur une grille carrée uniforme. Il est ensuite interprété comme un profil de densité de parties sans masse non interacturées au temps τ = 0+.

Le paramètre grid_max définit le bord le plus extérieur de la grille, pas le point médian de la cellule de la grille extérieure, par exemple

• Une grille 200 × 200 avec un maximum de 10,0 FM a des bords cellulaires à -10,00, -9,90, ..., +10,00 et des points médians cellulaires à -9,95, -9.85, ..., +9,95.
• Une grille 201 × 201 avec un maximum de 10,05 FM a des bords cellulaires à -10,05, -9,95, ..., +10,05 et des points médians cellulaires à -10,00, -9,90, ..., +10,00.

Il s'agit de la même définition que le paramètre Trento --grid-max .

Il est très important que la grille max soit réglée correctement pour éviter la propagation superluminale.

Supposons que initial est un réseau de conditions initiales N × N avec une grille max de 10,0 FM et nous voulons gratuitement du flux pour 1,0 FM. Nous créons d'abord un objet FreeStreamer :

 import freestream

fs = freestream . FreeStreamer ( initial , 10.0 , 1.0 )

Nous pouvons désormais extraire les différentes quantités nécessaires pour initialiser l'hydroélectricité de fs .

Tenseur d'énergie-momentum t ^μν

 Tuv = fs . Tuv ()

Tuv est un tableau N × N × 3 × 3 contenant le tenseur complet à chaque point de grille. Si nous ne voulons qu'un certain composant du tenseur, nous pouvons transmettre des indices à la fonction:

 T00 = fs . Tuv ( 0 , 0 )

T00 est un tableau N × N contenant T ⁰⁰ à chaque point de grille. Ceci est purement pour la commodité syntaxique: fs.Tuv(0, 0) est équivalent à fs.Tuv()[:, :, 0, 0] .

Densité d'énergie e et vitesse d'écoulement u ^μ

 e = fs . energy_density ()  # n x n
u = fs . flow_velocity ()  # n x n x 3

Nous pouvons également extraire les composants individuels de la vitesse d'écoulement:

 u1 = fs . flow_velocity ( 1 )  # n x n

Encore une fois, cela équivaut à fs.flow_velocity()[:, :, 1] .

Tensor de cisaillement π ^μν et pression en vrac π

Le tenseur de pression de cisaillement π ^μν fonctionne comme t ^μν :

 pi = fs . shear_tensor ()  # n x n x 3 x 3
pi01 = fs . shear_tensor ( 0 , 1 )  # n x n

La pression visqueuse en vrac π dépend de l'équation de l'état p (e) . Par défaut, l'EOS idéal P (E) = E / 3 est utilisé:

 bulk = fs . bulk_pressure ()

La pression en vrac est en fait nulle avec les EOS idéaux, mais il y aura de petites valeurs non nulles dues à une précision numérique.

Pour utiliser un autre EOS, transmettez un objet appelable à bulk_pressure() :

 bulk = fs . bulk_pressure ( eos )

Par exemple, supposons que nous ayons un tableau de pression et de densité d'énergie que nous voulons interpoler. Nous pouvons utiliser scipy.interpolate pour construire un spline et le passer à bulk_pressure() :

 import scipy . interpolate as interp

eos_spline = interp . InterpolatedUnivariateSpline ( energy_density , pressure )
bulk = fs . bulk_pressure ( eos_spline )

Autres notes

Le code doit s'exécuter en quelques secondes, selon la taille de la grille. Le temps de calcul est proportionnel au nombre de cellules de grille (c'est-à -dire ² ).

Assurez-vous que la grille est suffisamment grande pour s'adapter à l'expansion radiale. Le code ne vérifie pas le débordement.

FreeStreamer renvoie des références à ses tableaux internes, alors ne les modifiez pas en place - faites des copies!

Tests et internes

FreeStreamer utilise une spline cubique bidimensionnelle (scipy.interpolate.rectBivariaSpline) pour construire un profil de condition initial continu à partir d'une grille discrète. Ceci est très précis à condition que l'espacement de la grille soit suffisamment petit. La spline devient parfois très légèrement négative autour des limites nettes; FreeStreamer contraint ces valeurs négatives à zéro.

Le script test.py contient des tests unitaires et génère des visualisations pour l'inspection qualitative. Pour exécuter les tests, installez le nez et courez:

 nosetests -v test.py

Il y a deux tests unitaires:

• Comparaison avec une solution analytique pour un état initial gaussien symétrique (calculé en Mathematica).
• Comparaison avec une condition initiale générée de manière aléatoire sans interpolation.

Ces tests échouent occasionnellement car il y a un composant aléatoire et la tolérance est quelque peu stricte (chaque point de grille doit être d'accord à moins de 0,1%). Lorsqu'un test échoue, il imprimera une liste de rapports (observé / attendu). En règle générale, les échecs se produisent à la cellule de grille la plus externe où le système est très dilué, et même là, il ne manquera que de ~ 0,2%.

Pour générer des visualisations, exécutez test.py en tant que script avec deux arguments, le cas de test à visualiser et un fichier de sortie PDF. Il y a trois cas de test:

• gaussian1 , un gaussien symétrique étroit centré à l'origine.
• gaussian2 , un décalage gaussien asymétrique plus large de l'origine.
• random , une condition initiale générée de manière aléatoire (ce n'est en aucun cas réaliste, c'est uniquement pour la visualisation).

Par exemple:

 python test.py gaussian1 freestream.pdf

Exécutera le cas de test gaussian1 et enregistrera les résultats dans freestream.pdf . Le PDF contient des visualisations de l'état initial et de tout ce que FreeStreamer calcule. Dans chaque visualisation, les couleurs rouges indiquent des valeurs positives, le bleu signifie négatif et la valeur absolue maximale du tableau est annotée en haut à gauche.

Animations

Le script inclus animate.py génère des animations (comme celle en haut de cette page) à partir de conditions initiales enregistrées au format HDF5 (par exemple Trento Events). Il nécessite Python3 avec Matplotlib et H5Py, et bien sûr freestream doit être installé. Pour animer un événement Trento, générez d'abord certains événements au format HDF5, puis exécutez le script:

 Trento PB PB 10 -o Events.hdf
./animate.py events.hdf Event_0 freestream.mp4

Le premier argument est le nom de fichier HDF5, le second est l'ensemble de données à animer, et le dernier est le nom de fichier d'animation. Exécuter ./animate.py --help pour plus d'informations, y compris les options pour la durée d'animation, la catégorie, le colormap, etc.