Esempio n. 1
0
    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
Esempio n. 2
0
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
Esempio n. 3
0
    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)
Esempio n. 4
0
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