def update(self):
print "lecture {0}".format(self.acces_fichier)
# cas ou acces_fichier contient une etoile
if "*" in self.acces_fichier:
maillage = vtk.vtkMultiBlockDataSet()
for fichier in glob.glob(self.acces_fichier):
print fichier
bloc = LecteurVTK(acces_fichier=fichier).get_output()
numero_bloc = int(
fichier.split(self.acces_fichier.split("*")[0])[1].split(self.acces_fichier.split("*")[1])[0]
)
maillage.SetBlock(numero_bloc, bloc)
self.output = maillage
self._mettre_a_jour = False
return 0
# appel des lecteurs vtk standards
elif self.acces_fichier[-4:] == ".vtm":
w = vtkIOXMLPython.vtkXMLMultiBlockDataReader()
w.SetFileName(self.acces_fichier)
elif self.acces_fichier[-4:] == ".vtp":
w = vtkIOXMLPython.vtkXMLPolyDataReader()
w.SetFileName(self.acces_fichier)
elif self.acces_fichier[-4:] == ".vts":
w = vtkIOXMLPython.vtkXMLStructuredGridReader()
w.SetFileName(self.acces_fichier)
elif self.acces_fichier[-4:] == ".vtu":
w = vtkIOXMLPython.vtkXMLUnstructuredGridReader()
w.SetFileName(self.acces_fichier)
else:
w = vtkIOXMLPython.vtkDataSetReader()
w.SetFileName(self.acces_fichier)
w.Update()
self.output = w.GetOutput()
self._mettre_a_jour = False
return 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
def set_output(self, vtkDataObject):
"""fonction pour indiquer la sortie d'un filtre ou source programmable
"""
#la sortie polydata, entre autres, n'est pas bien gere par le filtre programmable
#on transforme alors dans ce cas en multibloc d'un seul bloc, qui marche bien.
if not isinstance(vtkDataObject, vtk.vtkMultiBlockDataSet):
m = vtk.vtkMultiBlockDataSet()
m.SetBlock(0, vtkDataObject)
vtkDataObject = m
#on met en sortie
self.GetOutput().ShallowCopy(vtkDataObject)
def dupliquer_canal(input, angle_periodicite, nb_canaux=2):
"""
duplique pour mettre plusieurs canaux cote-a-cote
s'applique a un multibloc ou a un monobloc
angle_periodicite en degres
*****
pour un multibloc
possibilite d'indiquer des listes d'angle de periodicite et de nb_canaux
dans ce cas, pour le bloc numero N, la valeur de l'angle utilisee est le N-ieme angle dans la liste
idem pour nb_canaux
"""
#cas multibloc
if isinstance(input, vtk.vtkMultiBlockDataSet):
multibloc_duplique = vtk_new_shallowcopy(input)
nb_blocs = multibloc_duplique.GetNumberOfBlocks()
if isinstance(angle_periodicite, list):
if not(isinstance(nb_canaux, list)):
raise IOError, "lorsque une liste d'angles est donnee en entree, le nb_canaux doit aussi etre une liste"
for numbloc in get_numeros_blocs_non_vides(multibloc_duplique):
angle_rotation = angle_periodicite[numbloc]
nb_reconstruire = nb_canaux[numbloc]
for num_canal in range(2, nb_reconstruire + 1):
multibloc_duplique.SetBlock(numbloc + (num_canal - 1) * (nb_blocs // 10 + 1) * 10,
RotationX(multibloc_duplique.GetBlock(numbloc), (num_canal - 1) * angle_rotation)
)
else:
for numbloc in get_numeros_blocs_non_vides(multibloc_duplique):
for num_canal in range(2, nb_canaux + 1):
multibloc_duplique.SetBlock(numbloc + (num_canal - 1) * (nb_blocs // 10 + 1) * 10,
RotationX(multibloc_duplique.GetBlock(numbloc), (num_canal - 1) * angle_periodicite)
)
#monobloc
else:
if isinstance(angle_periodicite, list):
raise IOError, "impossible de donner plusieurs angles de periodicite pour un monobloc... !"
multibloc_duplique = vtk.vtkMultiBlockDataSet()
multibloc_duplique.SetBlock(1, input)
for num_canal in range(2, nb_canaux + 1):
multibloc_duplique.SetBlock(num_canal,
RotationX(input, (num_canal - 1) * angle_periodicite))
return multibloc_duplique
def Update(self):
"""execute le calcul"""
if self.input is None:
raise IOError, "input n'est pas renseigne"
# execution du calcul
if isinstance(self.input, vtk.vtkMultiBlockDataSet):
self.output = vtk.vtkMultiBlockDataSet()
for numbloc in get_numeros_blocs_non_vides(self.input):
c = self.__getCalculator__()
c.SetInput(self.input.GetBlock(numbloc))
c.Update()
self.output.SetBlock(numbloc,
vtk_new_shallowcopy(c.GetOutput()))
else:
self.output = vtk_new_instance(self.input)
c = self.__getCalculator__()
c.SetInput(self.input)
c.Update()
self.output = vtk_new_shallowcopy(c.GetOutput())
# on indique que la mise a jour a ete effectuee
self._mettre_a_jour = False
return 0
def UVParametrization(input, hubFileName, tipFileName, stepSize=2.0, relativeExtension=0.1):
#~ hubFileName = "E:\Documents and Settings\u000160\Bureau\sketch\hub.dat"
#~ tipFileName = "E:\Documents and Settings\u000160\Bureau\sketch\shroud.dat"
#~ stepSize = 2.5
#~ relativeExtension = 0.1
#hubFileName = self.hubFileName
#tipFileName = self.tipFileName
#stepSize = self.stepSize
#relativeExtension = self.relativeExtension
spline, numberOfPoints = CreateSpline(hubFileName, tipFileName, stepSize,
relativeExtension=relativeExtension)
grid = parametrize(spline, numberOfPoints=numberOfPoints,
relativeExtension=relativeExtension)
if input.IsA('vtkMultiBlockDataSet'):
output = vtk.vtkMultiBlockDataSet()
output.CopyStructure(input)
iter = input.NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
curOutput = curInput.NewInstance()
curOutput.UnRegister(None)
output.SetDataSet(iter, curOutput)
curOutput.ShallowCopy(curInput)
parametrize_dataset(curOutput, grid)
iter.GoToNextItem()
else:
output = input.NewInstance()
output.UnRegister(None)
output.ShallowCopy(input)
parametrize_dataset(output, grid)
return output
def lire_solution(self, acces_fichier, fmt_fichier='bin_v3d', precision='i4r8', \
endian='big', decalage_numbloc_lus=0, \
iteration=None, canaux_a_reconstruire=['tout', 'tout'], \
rotation_temporelle=True,
traitement_non_numeros=False, seulement_les_numeros=None,
assembler_vecteurs = True):
"""lecture de fichiers contenant des donnees
fmt_fichier peut etre
- vtk !!! PAS ENCORE POUR CHOROCHRONIQUE !!!
- bin_v3d
- fmt_v3d
par defaut, tous les canaux sont reconstruits
voir la classe LecteurV3D pour l'utilite des cles
- traitement_non_numeros
- seulement_les_numeros
rotation_temporelle peut prendre les valeurs suivantes
- True --> rotation normale, avec prise en compte de la vitesse
de rotation de chacun des blocs
- False --> pas de prise en compte des vitesse de rotation
les domaines sont fixes quelle que soit le numero d'iteration
- un entier --> l'entier indique le numero de la roue qui doit rester fixe
dans le repere absolu. L'autre roue tourne en consequence
pour maintenir la coherence a l'interface des deux roues
0 pour la premiere roue
1 pour la deuxieme roue
"""
self._ajouter_omega_aux_noeuds()
if self.get('timestep') == 0:
if fmt_fichier[4:] == 'v3d':
r = lecture.LecteurV3D(acces_fichier = acces_fichier, fmt_fichier = fmt_fichier[:3],
precision = precision, endian = endian,
decalage_numbloc_lus = decalage_numbloc_lus,
traitement_non_numeros = traitement_non_numeros,
seulement_les_numeros = seulement_les_numeros,
assembler_vecteurs = assembler_vecteurs)
r.importer_maillage(self.Maillage.get('_vtkDataObject'))
r.update()
self.set('_vtkDataObject', r.get_output())
elif fmt_fichier == 'vtk':
r = lecture.LecteurVTK(acces_fichier = acces_fichier)
self.set('_vtkDataObject', r.get_output())
else:
raise IOError, 'le format {0} indique pour le fichier est inconnu'.format(fmt_fichier)
else:
# VERIFICATION DES DONNEES
if iteration == None:
raise IOError, "indiquer l'iteration a reconstruire"
# chorochronique : deux vitesses de rotation differentes seulement
liste_omega = []
for k in self.get('omega_par_blocs'):
if k not in liste_omega: liste_omega.append(k)
if len(liste_omega) != 2:
raise IOError, 'obligatoirement deux vitesses de rotation differentes'
# chorochronique : deux nombres d'aubes differents seulement
liste_nombre_aubes = []
for k in self.Maillage.get('nombre_aubes_par_bloc'):
if k not in liste_nombre_aubes: liste_nombre_aubes.append(k)
if len(liste_nombre_aubes) != 2:
raise IOError, "obligatoirement deux nombres d'aubes differents"
nombre_aubes_par_bloc = self.Maillage.get("nombre_aubes_par_bloc")
# inititer, itime et timestep doivent etre renseignes
for propriete in ['inititer', 'itime', 'timestep', 'omega_par_blocs']:
if self.get(propriete) == None:
raise IOError, "{0} doit etre renseigne".format(propriete)
else:
exec "{0} = self.get('{0}')".format(propriete)
omega_par_blocs = self.get("omega_par_blocs")
iterations_disponibles = []
for fich in glob.glob('{0}*'.format(acces_fichier)):
iteration_trouvee = int(fich.split(acces_fichier.split('*')[1])[1])
if not(iteration_trouvee in iterations_disponibles):
iterations_disponibles.append(iteration_trouvee)
self._vtkDataObject = vtk.vtkMultiBlockDataSet()
# RECONSTRUCTION
periode_tour = 2 * numpy.pi / abs(liste_omega[0] - liste_omega[1])
for numbloc in get_numeros_blocs_non_vides(
self.Maillage._vtkDataObject):
if seulement_les_numeros is None or numbloc in seulement_les_numeros:
numbloc = numbloc
roue_courante = liste_omega.index(omega_par_blocs[numbloc - 1])
roue_opposee = roue_courante - 1
numeros_canaux = canaux_a_reconstruire[roue_courante]
if numeros_canaux is None:
numeros_canaux = []
if not isinstance(numeros_canaux, list):
numeros_canaux = range(nombre_aubes_par_bloc[numbloc - 1])
# calcul de l'angle de la rotation du au temps en degres
if rotation_temporelle == True and type(rotation_temporelle) == bool:
rotation_temps = ((iteration - inititer) * timestep + itime) \
* liste_omega[roue_courante] * 180. / numpy.pi
elif type(rotation_temporelle) == int:
if rotation_temporelle not in [0, 1]:
raise IOError, "rotation_temporelle ne peut valoir que True; False; 0; 1;"
roue_fixe = rotation_temporelle
rotation_temps = ((iteration - inititer) * timestep + itime) \
* (liste_omega[roue_courante] - liste_omega[roue_fixe]) \
* 180. / numpy.pi
else:
rotation_temps = 0.0
for numero_canal in numeros_canaux:
# calcul de l'angle de la rotation du au numero de canal en degres
rotation_numero_canal = numero_canal * 360. / nombre_aubes_par_bloc[numbloc - 1]
# numero iteration a chercher
dephasage_en_iterations = periode_tour / (
nombre_aubes_par_bloc[numbloc - 1] * timestep
) * numpy.sign(
liste_omega[roue_courante] - liste_omega[roue_opposee]
)
iteration_canal = iteration + dephasage_en_iterations * numero_canal
# recherche parmi les iterations disponibles
# compte-tenu de la periodicite temporelle
periode_canal_en_iterations = periode_tour / (
liste_nombre_aubes[roue_opposee] * timestep
)
iteration_a_lire = iteration_canal - (
(iteration_canal - numpy.max(iterations_disponibles)) // periode_canal_en_iterations
+ 1) * periode_canal_en_iterations
iteration_a_lire = int(round(iteration_a_lire))
if not iteration_a_lire in iterations_disponibles:
raise Exception, 'no iteration founded for canal {0}\na candidate would be {1}'\
.format(numero_canal, iteration_a_lire)
if fmt_fichier[4:] == 'v3d':
r = lecture.LecteurV3D(fmt_fichier = fmt_fichier[:3],
precision = precision, endian = endian,
decalage_numbloc_lus = decalage_numbloc_lus,
traitement_non_numeros = traitement_non_numeros,
#seulement_les_numeros = seulement_les_numeros,
assembler_vecteurs = assembler_vecteurs)
r.importer_maillage(self.Maillage._vtkDataObject.GetBlock(numbloc))
r.set('acces_fichier', '{0}{1}{2}{3}'.format(
acces_fichier.split('*')[0],
numbloc,
acces_fichier.split('*')[1],
iteration_a_lire
))
r.update()
numero_bloc_canal = (numbloc + numero_canal * (
self.Maillage._vtkDataObject.GetNumberOfBlocks() // 10 + 1
)* 10) % (
(self.Maillage._vtkDataObject.GetNumberOfBlocks() // 10 + 1) * 10
* (nombre_aubes_par_bloc[numbloc - 1] + 1)
)
self._vtkDataObject.SetBlock(numero_bloc_canal,
RotationX(
r.get_output(), rotation_temps + rotation_numero_canal)
)
return 0
