def update(self):
"""execute la lecture des fichiers
"""
for acces_fichier in self.acces_fichier if isinstance(self.acces_fichier, list) else [self.acces_fichier]:
# lecture monobloc
if not "*" in acces_fichier:
if self.output is None:
self.output = vtk.vtkStructuredGrid()
self.lire_monobloc(acces_fichier=acces_fichier)
# lecturemultiblocs
else:
if self.output is None:
self.output = vtk.vtkMultiBlockDataSet()
fichiers_non_numero = []
for fich in glob.glob(acces_fichier):
debut_acces_fichier = acces_fichier.split("*")[0]
fin_acces_fichier = acces_fichier.split("*")[1]
try:
numbloc = int(fich[len(debut_acces_fichier) : -len(fin_acces_fichier)])
except:
if self.traitement_non_numeros is True:
fichiers_non_numero.append(fich)
else:
if self.seulement_les_numeros is None or numbloc in self.seulement_les_numeros:
self.lire_monobloc(acces_fichier=fich, numbloc=numbloc)
for fich in fichiers_non_numero:
debut_acces_fichier = acces_fichier.split("*")[0]
fin_acces_fichier = acces_fichier.split("*")[1]
numbloc = self.output.GetNumberOfBlocks()
self.lire_monobloc(acces_fichier=fich, numbloc=numbloc)
self._mettre_a_jour = False
def parametrize(spline, numberOfPoints=101, relativeExtension=0.1):
from paraview.vtk import vtkFloatArray
arrayU = vtkFloatArray()
arrayV = vtkFloatArray()
arrayU.SetName('hsH')
arrayV.SetName('xm')
from paraview.vtk import vtkPoints
points = vtkPoints()
uvMin = -relativeExtension
uvMax = 1.0 + relativeExtension
for _v in linspace(uvMin, uvMax, numberOfPoints):
for _u in (uvMin, uvMax):
arrayU.InsertNextTuple1(_u)
arrayV.InsertNextTuple1(_v)
pnt = spline(_u, _v)
points.InsertNextPoint(pnt[0], pnt[1], 0.0)
from paraview.vtk import vtkStructuredGrid
grid = vtkStructuredGrid()
grid.SetExtent(1, 2, 1, numberOfPoints, 1, 1)
grid.SetPoints(points)
pointData = grid.GetPointData()
pointData.AddArray(arrayU)
pointData.AddArray(arrayV)
return grid
def lire_monobloc(self, acces_fichier, numbloc=None):
"""lecture d'un seul bloc
si numbloc est indique, alors le bloc est stocke comme numbloc
et le numero de bloc lu dans le v3d est ignore
"""
dictionnaire_lecture = lire_v3d(
acces_fichier=acces_fichier,
fmt_fichier=self.fmt_fichier,
endian=self.endian,
precision=self.precision,
compter_saut_de_ligne=self.compter_saut_de_ligne,
)
if numbloc is None:
numbloc = dictionnaire_lecture["numbloc"] + self.decalage_numbloc_lus
try:
bloc_temp = vtk_new_shallowcopy(
self.output if isinstance(self.output, vtk.vtkStructuredGrid) else self.output.GetBlock(numbloc)
)
except:
bloc_temp = vtk.vtkStructuredGrid()
# liste des donnees traitees
donnees_traitees = []
# GEOMETRIE
# si des coordonnees (x,y,z) sont comprises dans le fichier lu
if (
dictionnaire_lecture["data"].has_key("x")
and dictionnaire_lecture["data"].has_key("y")
and dictionnaire_lecture["data"].has_key("z")
):
numpyArrayCoords = numpy.vstack(
(
dictionnaire_lecture["data"]["x"],
dictionnaire_lecture["data"]["y"],
dictionnaire_lecture["data"]["z"],
)
).transpose(1, 0)
vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(numpyArrayCoords), deep=1)
points = vtk.vtkPoints()
points.SetData(vtkArray)
bloc_temp.SetDimensions(
dictionnaire_lecture["dims"][0], dictionnaire_lecture["dims"][1], dictionnaire_lecture["dims"][2]
)
bloc_temp.SetPoints(points)
donnees_traitees += ["x", "y", "z"]
# DONNEES
if not bloc_temp is None and bloc_temp.GetNumberOfPoints() != 0:
# si il y a rou rov row
if (
dictionnaire_lecture["data"].has_key("rou")
and dictionnaire_lecture["data"].has_key("rov")
and dictionnaire_lecture["data"].has_key("row")
and self.assembler_vecteurs is True
):
momentum = numpy.vstack(
(
dictionnaire_lecture["data"]["rou"],
dictionnaire_lecture["data"]["rov"],
dictionnaire_lecture["data"]["row"],
)
).transpose(1, 0)
vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(momentum), deep=1)
vtkArray.SetName("momentum")
self.ajouter_au_bloc(bloc_temp, vtkArray)
donnees_traitees += ["rou", "rov", "row"]
# si il y a trois donnees (et seulement trois) du type *_0 *_1 *_2
liste_temp = [nom[:-2] for nom in dictionnaire_lecture["data"].keys()]
for key in liste_temp:
if (
numpy.all(
[
key + "_{0}".format(composante) in dictionnaire_lecture["data"].keys()
for composante in range(3)
]
)
and numpy.all([key + "_{0}".format(composante) not in donnees_traitees for composante in range(3)])
and self.assembler_vecteurs is True
):
vector = numpy.vstack(
(
dictionnaire_lecture["data"][key + "_0"],
dictionnaire_lecture["data"][key + "_1"],
dictionnaire_lecture["data"][key + "_2"],
)
).transpose(1, 0)
vtkArray = numpy_support.numpy_to_vtk(numpy.ascontiguousarray(vector), deep=1)
vtkArray.SetName(key)
self.ajouter_au_bloc(bloc_temp, vtkArray)
donnees_traitees += [key + "_%s" % (composante) for composante in range(3)]
for key in dictionnaire_lecture["data"]:
if key not in donnees_traitees:
vtkArray = numpy_support.numpy_to_vtk(dictionnaire_lecture["data"][key], deep=1)
vtkArray.SetName(key)
self.ajouter_au_bloc(bloc_temp, vtkArray)
donnees_traitees += [key]
else:
print "## IGNORE -- LA GEOMETRIE N'EST PAS CHARGEE"
bloc_temp = None
if isinstance(self.output, vtk.vtkStructuredGrid):
self.output = bloc_temp
else:
self.output.SetBlock(numbloc, bloc_temp)
def calculer_champ_meridien(vtkDataObject,
maillage_regulier=None,
retourner_maillage_regulier=False,
hubFileName = "/media/FreeAgent GoFlex Drive/DATA_PI4/hub",
tipFileName = "/media/FreeAgent GoFlex Drive/DATA_PI4/shroud",
stepSize=2.0, relativeExtension=0.1,
numberOfPoints_xm = 75, numberOfPoints_h = 10,
dtheta = 2 * numpy.pi / (21 * 10)
):
"""Fonction qui retourne un plan, contenant le champ meridien
Le champ est le resultat d'une moyenne azimutale ponderee simple
"""
#Creation du maillage regulier
if maillage_regulier is None:
from UVParametrizationFilter import CreateSpline
spline, numberOfPoints = CreateSpline(hubFileName, tipFileName, stepSize,
relativeExtension=relativeExtension)
coords = get_vtk_array_as_numpy_array(vtkDataObject, "coords")
coordx = coords[:, 0]
coordy = coords[:, 1]
coordz = coords[:, 2]
coordtheta = numpy.arctan2(coordz, coordy)
min_theta = coordtheta.min()
max_theta = coordtheta.max()
ntheta = int((max_theta - min_theta) // dtheta)
print "Dimensions du grid ", numberOfPoints_xm, numberOfPoints_h, ntheta
points = vtk.vtkPoints()
uvMin = -relativeExtension
uvMax = 1.0 + relativeExtension
for _v in numpy.linspace(uvMin, uvMax, numberOfPoints_xm):
print _v
for _u in numpy.linspace(uvMin, uvMax, numberOfPoints_h):
for theta in numpy.linspace(min_theta, max_theta, ntheta):
pnt = spline(_u, _v)
x = pnt[0]
y = pnt[1] * numpy.cos(theta)
z = pnt[1] * numpy.sin(theta)
points.InsertNextPoint(x, y, z)
grid = vtk.vtkStructuredGrid()
grid.SetDimensions(ntheta, numberOfPoints_h, numberOfPoints_xm)
grid.SetPoints(points)
#on retourne le maillage_regulier si demande
if retourner_maillage_regulier == 1:
return grid
else:
grid = maillage_regulier
#Probe et moyenne azimutale, pour finalement retourner le plan
grid = VTKProbe(input = grid, source = vtkDataObject)
#pour le plan a retourner, on choisit arbitrairement le plan i=0 du maillage regulier
plan = Extraction(input = grid, formule_extraction='i=0').get_output()
#moyenne de chacune des grandeurs le long des lignes a x, r, constants
for nom_grandeur in get_noms_arrays_presents(vtkDataObject):
grandeur = get_vtk_array_as_numpy_array(grid, nom_grandeur)
if grandeur.size == grid.GetNumberOfPoints():
grandeur = grandeur.reshape(grid.GetDimensions()[::-1])
else:
grandeur = grandeur.reshape(grid.GetDimensions()[::-1] + (3,))
grandeur = numpy.ma.masked_less(grandeur, 0.1)
grandeur = numpy.mean(grandeur, axis=2)
grandeur = grandeur.ravel()
plan = ajouter_numpy_array_as_vtk_array(plan, grandeur, nom_grandeur)
return plan