doc/tutorial/medcouplingcorba_fr.rst

   1
   2 Visualiser une instance de MEDCoupling dans ParaViS à travers CORBA
   3 -------------------------------------------------------------------
   4
   5 Il peut être intéressant de visualiser directement un maillage ou un champ en mémoire dans
   6 un process Python avec une session de ParaViS. Cela évite d'avoir à écrire le maillage (ou le champ) sur disque.
   7 Cette technique peut également être utilisée pour :
   8
   9 * faire des noeuds de visualisation dans le module YACS
  10 * maquetter un script Python, et profiter de l'interpreteur interactif Python tout en
  11   bénéficiant de l'interface graphique de ParaViS.
  12
  13 Nous allons pour ce faire bénéficier des mécanismes de distribution mis en oeuvre dans SALOME sur
  14 la base du standard `CORBA <http://fr.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture>`_.
  15 SALOME utilise l'implémentation `omniORB <http://omniorb.sourceforge.net/>`_ et
  16 `omniORBPy <http://omniorb.sourceforge.net/>`_ du standard.
  17
  18 Début de l'implémentation
  19 ~~~~~~~~~~~~~~~~~~~~~~~~~
  20
  21 Pour commencer l'exercice importer le module ``MEDCoupling``
  22 et la classe ``MEDCouplingUMeshServant`` du module Python ``MEDCouplingCorba``. ::
  23
  24         import MEDCoupling as mc
  25         from MEDCouplingCorba import MEDCouplingUMeshServant
  26
  27 Créer un maillage
  28 ~~~~~~~~~~~~~~~~~
  29
  30 Le but ici est de créer un maillage ``m`` non structuré trivial qui sera envoyé par CORBA à ParaViS. ::
  31
  32         arr = mc.DataArrayDouble(11)
  33         arr.iota(0)
  34         m = mc.MEDCouplingCMesh()
  35         m.setCoords(arr,arr)
  36         m = m.buildUnstructured()
  37
  38 .. note:: Le maillage ``m`` est non struturé, mais s'il est cartésien ça marche aussi !
  39
  40 Créer un servant CORBA
  41 ~~~~~~~~~~~~~~~~~~~~~~
  42
  43 Nous allons maintenant créer un *servant* CORBA à partir de ``m``, et faire du process Python courant
  44 un *serveur* CORBA. L'objet ``m`` devient ainsi disponible sur le bus CORBA et pourra être interrogé pour
  45 la visualisation par un service distant, typiquement dans notre cas, le module ParaVis.
  46
  47 Invoquer ``MEDCouplingUMeshServant._this()`` sur ``m`` pour en faire une reférence CORBA (``ref_m``).::
  48
  49         ref_m = MEDCouplingUMeshServant._this(m)
  50
  51 .. note:: Cette ligne ne se contente pas de faire un servant CORBA mais fait du processus courant Python un serveur CORBA.
  52
  53 Récupérer les identifiants pour ParaViS
  54 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  55
  56 Ce qui suit est général à tout code omniORBpy. Afficher l'IOR ``ior`` de ``ref_m`` (c'est à dire l'identifiant
  57 unique de l'objet sur le bus CORBA) pour pouvoir passer cette chaîne de caractères au plugin ParaMEDCorbaPlugin
  58 de ParaViS, et ainsi créer une nouvelle source dans ParaViS. ::
  59
  60         import CORBA
  61         orb = CORBA.ORB_init()
  62         ior = orb.object_to_string(ref_m)
  63         print ior
  64
  65 Puis, via un copier/coller dans l'IHM ParaViS (Menu "Source -> Para MED Corba Plugin Source"), passer l'IOR.
  66 On voit s'afficher notre maillage.
  67
  68 Utiliser ParaViS en interactif
  69 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  70
  71 Le but ici est juste de voir le principe. Il s'agit d'un point d'entrée pour réaliser des scripts ParaViS plus évolués.
  72 *Tout en laissant actif ParaViS*, importer le module ``pvsimple`` qui fournit l'interface haut niveau de visualisation : ::
  73
  74         import salome
  75         salome.salome_init()
  76         import pvsimple as pvs
  77
  78 .. note:: Le module ``pvsimple`` est, à peu de choses prêt, identique au module ``paraview.simple``.
  79         Il est juste adapté à une utilisation au sein de SALOME. Voir la formation PARAVIS à ce sujet.
  80
  81 Une fois cet import réalisé, le script est automatiquement connecté au même serveur de visualisation que
  82 l'interface graphique de SALOME (si le module PARAVIS est bien actif !). Nous pouvons donc envoyer des commandes
  83 au serveur de visualisation pour demander l'affichage de notre objet CORBA.  ::
  84
  85         # We now talk to the PVServer directly
  86         import pvsimple as pvs
  87         pvs.Connect(url)
  88         src1 = pvs.ParaMEDCorbaPluginSource()
  89         src1.IORCorba = ior      # This is where we need the CORBA reference of the object created
  90         dr = pvs.Show(src1)
  91
  92 .. note:: Cela correspond exactement à la manipulation précédente faite via l'interface graphique (ajout d'une nouvelle
  93         source, saisie de l'IOR, etc ...).
  94
  95 Solution
  96 ~~~~~~~~
  97
  98 Le script complet doit être exécuté avec le module PARAVIS (ou une fenêtre ParaView) actif dans l'IHM SALOME!
  99
 100 :ref:`python_testMEDCouplingcorba1_solution`