docs: Updates w.r.t. new structure.

Author: prmukherj

doc/source/api/visualization/graphics.rst

@@ -7,22 +7,7 @@ Graphics
 
 In the following example, a ``Graphics`` object is instantiated with a Fluent
 session as its context. The ``Graphics`` object is used to create a mesh,
-contour, vector, and surface. The contour is then deleted.
-
-.. code-block:: python
-
-        from ansys.fluent.visualization import  Graphics
-        graphics_session = Graphics(session)
-        
-        #Create object
-        mesh1 = graphics_session.Meshes["mesh-1"]
-        contour1 = graphics_session.Contours["contour-1"]
-        vector1 = graphics_session.Vectors["vector-1"]
-        surface1 = graphics_session.Surfaces["surface-1"]
-        pathlines1 = graphics_session.Pathlines["pathlines-1"]
-        
-        #Delete object
-        del graphics_session.Contours["contour-1"] 
+contour, vector, and surface.
 
 .. toctree::
    :maxdepth: 2

doc/source/api/visualization/graphics_windows_manager.rst

@@ -6,40 +6,39 @@ The ``GraphicsWindowsManager`` class provides for managing and directly interact
 with PyVista windows. By registering these methods with ``EventsManager``, you
 can update graphics during run time and create animations.
 
-The following example updates ``window-1`` during solution initialization and
-whenever data is read. During the calculation, it also updates ``window-1`` at
+The following example updates ``p_cont`` during solution initialization and
+whenever data is read. During the calculation, it also updates ``p_cont`` at
 the end of every time step and creates an animation.
 
 .. note::
   The animation is saved when the window is closed.
 
 .. code-block:: python
 
-    from ansys.fluent.visualization import Graphics
-    from ansys.fluent.visualization.graphics import graphics_windows_manager
-    
-    graphics_session = Graphics(session)
+    from ansys.fluent.visualization import Contour, GraphicsWindow
     
     #Create contour.
-    contour1 = graphics_session.Contours["contour-1"]
-    contour1.field = "velocity-magnitude"
-    contour1.surfaces = ['symmetry']
+    contour1 = Contour(
+        solver=session, field="velocity-magnitude", surfaces=["symmetry"]
+    )
     
-    #Display contour on window-1.
-    contour1.display("window-1")
+    #Display contour.
+    p_cont = GraphicsWindow()
+    p_cont.add_graphics(contour1)
+    p_cont.show()
     
-    #Create callback that refreshes window-1.    
-    def auto_refresh_contour(session_id, event_info):    
-        graphics_windows_manager.refresh_windows(session_id, ["window-1"])
-           
+    #Create callback that refreshes 'p_cont'.
+    def auto_refresh_contour(session, event_info):
+        # 'p_cont' uses 'graphics_windows_manager' in its implementation
+        p_cont.refresh_windows(session.id)
+
     #Register this callback with server events.    
-    cb_init_id = session.events_manager.register_callback('InitializedEvent', auto_refresh_contour)
-    cb_data_read_id = session.events_manager.register_callback('DataReadEvent', auto_refresh_contour)
-    cb_time_step_ended_id = session.events_manager.register_callback('TimestepEndedEvent', auto_refresh_contour)         
+    cb_init_id = session.events.register_callback('InitializedEvent', auto_refresh_contour)
+    cb_data_read_id = session.events.register_callback('DataReadEvent', auto_refresh_contour)
+    cb_time_step_ended_id = session.events.register_callback('TimestepEndedEvent', auto_refresh_contour)
 
-    #Create animation for window-1. 
-    graphics_windows_manager.animate_windows(session.id, ["window-1"])
-    
+    #Create animation.
+    p_cont.animate_windows(session.id)
     
 .. autoclass:: ansys.fluent.visualization.graphics.graphics_windows_manager.GraphicsWindowsManager
    :members:

doc/source/api/visualization/index.rst

@@ -6,41 +6,39 @@ Visualization
 Postprocessing of Fluent results can be done with either built-in Fluent
 postprocessing capabilities, PyVista, or Matplotlib integration.
 
-Fluent TUI command example
---------------------------
+Fluent command example
+----------------------
 
 Here visualization objects are constructed within Fluent. You can use
 standard Fluent commands to write graphics to a file.
 
 .. code:: python
 
-  solver_session.tui.display.objects.contour['contour-1'] = {'boundary_values': True, 'color_map': {'color': 'field-velocity', 'font_automatic': True, 'font_name': 'Helvetica', 'font_size': 0.032, 'format': '%0.2e', 'length': 0.54, 'log_scale': False, 'position': 1, 'show_all': True, 'size': 100, 'user_skip': 9, 'visible': True, 'width': 6.0}, 'coloring': {'smooth': False}, 'contour_lines': False, 'display_state_name': 'None', 'draw_mesh': False, 'field': 'pressure', 'filled': True, 'mesh_object': '', 'node_values': True, 'range_option': {'auto_range_on': {'global_range': True}}, 'surfaces': [2, 5]}
-  solver_session.tui.display.objects.contour['contour-1']()
-  solver_session.tui.display.objects.contour['contour-1'].field.set_state('velocity-magnitude')
-  solver_session.tui.display.objects.contour['contour-1'].field()
-  solver_session.tui.display.objects.contour['contour-1'].color_map.size.set_state(80.0)
-  solver_session.tui.display.objects.contour['contour-1'].color_map.size()
-  solver_session.tui.display.objects.contour['contour-1'].rename('my-contour')
-  del solver_session.tui.display.objects.contour['my-contour']
+  solver_session.settings.results.graphics.contour['contour-1'] = {'boundary_values': True, 'color_map': {'color': 'field-velocity', 'font_automatic': True, 'font_name': 'Helvetica', 'font_size': 0.032, 'format': '%0.2e', 'length': 0.54, 'log_scale': False, 'position': 1, 'show_all': True, 'size': 100, 'user_skip': 9, 'visible': True, 'width': 6.0}, 'coloring': {'smooth': False}, 'contour_lines': False, 'display_state_name': 'None', 'draw_mesh': False, 'field': 'pressure', 'filled': True, 'mesh_object': '', 'node_values': True, 'range_option': {'auto_range_on': {'global_range': True}}, 'surfaces': [2, 5]}
+  solver_session.settings.results.graphics.contour['contour-1']()
+  solver_session.settings.results.graphics.contour['contour-1'].field = 'velocity-magnitude'
+  solver_session.settings.results.graphics.contour['contour-1'].field()
+  solver_session.settings.results.graphics.contour['contour-1'].color_map.size.set_state(80.0)
+  solver_session.settings.results.graphics.contour['contour-1'].color_map.size()
+  solver_session.settings.results.graphics.contour['contour-1'].rename('my-contour')
+  del solver_session.settings.results.graphics.contour['contour-1']['my-contour']
 
-PyVista example (graphics)
---------------------------
+Visualization example (graphics)
+--------------------------------
 
 Here field data is extracted from the Fluent session into the Python
-environment. PyVista is then used to visualize the extracted data.
+environment. Visualization is then used to visualize the extracted data.
 
 .. code:: python
 
   # import module
-  from ansys.fluent.visualization import Graphics
+  from ansys.fluent.visualization import GraphicsWindow, Mesh, Contour, Surface
 
   # get the graphics objects for the session
-
-  graphics_session1 = Graphics(solver_session)
-  mesh1 = graphics_session1.Meshes["mesh-1"]
-  contour1 = graphics_session1.Contours["contour-1"]
-  contour2 = graphics_session1.Contours["contour-2"]
-  surface1 = graphics_session1.Surfaces["surface-1"]
+  mesh1 = Mesh(solver=solver_session)
+  contour1 = Contour(solver=solver_session)
+  contour2 = Contour(solver=solver_session)
+  surface1 = Surface(solver=solver_session)
 
   # set graphics objects properties
 
@@ -55,55 +53,41 @@ environment. PyVista is then used to visualize the extracted data.
   contour2.field = "temperature"
   contour2.surfaces = ['symmetry', 'wall']
 
-  # copy
-  graphics_session1.Contours["contour-3"] = contour2()
-
-  # update
-  contour3 = graphics_session1.Contours["contour-3"]
-  contour3.update(contour1())
-
-  # delete
-  del graphics_session1.Contours["contour-3"] 
-
-  # loop
-  for name, _ in graphics_session1.Contours.items():
-      print(name)
-
   # iso surface
-  surface1.surface.iso_surface.field= "velocity-magnitude"
-  surface1.surface.iso_surface.rendering= "contour"
-
-  # display 
-  contour1.display()
-  mesh1.display()
-  surface1.display()
+  surface1.definition.type = "iso-surface"
+  surface1.definition.iso_surface.field= "velocity-magnitude"
+  surface1.definition.iso_surface.rendering= "contour"
+
+  # display
+  plotter = GraphicsWindow(grid=(2, 2))
+  plotter.add_graphics(mesh1, position=(0, 0))
+  plotter.add_graphics(contour1, position=(0, 1))
+  plotter.add_graphics(contour2, position=(1, 0))
+  plotter.add_graphics(surface1, position=(1, 1))
+  plotter.show()
   
-  # To display in specific window e.g. window-2
-  contour1.display("window-2")
-  
-Matplotlib example (XY plots)
------------------------------
+Visualization example (XY plots)
+--------------------------------
 
 Here plot data is extracted from the Fluent session into the Python
-environment. Matplotlib is then used to plot data.
+environment. Visualization is then used to plot data.
 
 .. code:: python
 
   # import module
-  from ansys.fluent.visualization import Plots
+  from ansys.fluent.visualization import XYPlot
 
   # get the plots object for the session
-  plots_session1 = Plots(solver_session)
-  
-  #get xyplot object
-  plot1=plots_session1.XYPlots["plot-1"]
+  plots_session1 = XYPlot(solver=solver_session)
   
   #set properties
-  plot1.surfaces = ["symmetry"]
-  plot1.y_axis_function = "temperature"
+  plots_session1.surfaces = ["symmetry"]
+  plots_session1.y_axis_function = "temperature"
   
   #Draw plot
-  plot1.plot("window-1")
+  plotter = GraphicsWindow()
+  plotter.add_graphics(plots_session1)
+  plotter.show()
 
   solver_session.exit()
 

doc/source/api/visualization/plots.rst

@@ -11,32 +11,26 @@ a monitor plot.
 
 .. code-block:: python
 
-        from ansys.fluent.visualization import Plots
+        from ansys.fluent.visualization import GraphicsWindow, XYPlot, Monitor
     
-        plots_session = Plots(session)
-        plot1 = plots_session.XYPlots["plot-1"]        
+        plot1 = XYPlot(solver=session)
         plot1.surfaces = ['symmetry', 'wall']
         plot1.y_axis_function = "temperature"
-        plot1.plot("window-0")        
-        
-        
-        #To plot data on local surface created in PyVista
-        
-        from ansys.fluent.visualization import  Graphics
-        pyvista_surface_provider = Graphics(session).Surfaces       
-        plots_session = Plots(session, pyvista_surface_provider)
-        plot2 = plots_session.XYPlots["plot-2"]         
-        plot2.surfaces = ['iso-surface-1']
-        plot2.y_axis_function = "temperature"
-        plot2.plot("window-0")        
-        
+        plot1.plot("window-0")
+
+        plotter = GraphicsWindow()
+        plotter.add_graphics(plot1)
+        plotter.show()
         
         #To plot monitors
         
-        monitor1=plots_session.Monitors["monitor-1"]                       
+        monitor1 = Monitor(solver=session)
         monitor1.monitor_set_name = "residual"
-        monitor1.plot("window-0")        
-        
+
+        plotter = GraphicsWindow()
+        plotter.add_graphics(monitor1)
+        plotter.show()
+
 .. toctree::
    :maxdepth: 2
    :hidden:

doc/source/api/visualization/plotter_windows_manager.rst

@@ -7,43 +7,47 @@ The ``PlotterWindowsManager`` class provides for managing and directly interacti
 with Matplotlib windows. By registering these methods with ``EventsManager``, you can
 update plots during run time.
 
-The following example updates ``window-1`` and ``window-2`` during solution initialization 
+The following example updates ``p_xy`` and ``p_res`` during solution initialization
 and whenever data is read. During the calculation, it also updates both windows at the end
 of every time step.
 
 .. code-block:: python
 
-    from ansys.fluent.visualization import Plots
-    from ansys.fluent.visualization.plotter import plotter_windows_manager
+    from ansys.fluent.visualization import XYPlot, Monitor, GraphicsWindow
     
     plots_session = Plots(session)
     
     #Create xy plot.
-    plot1 = plots_session.XYPlots["plot-1"]
+    plot1 = XYPlot(solver=session)
     plot1.surfaces = ['symmetry']
     plot1.y_axis_function = "temperature"
     
     
-    # Plot XY plot on window-1.
-    plot1.plot("window-1")
+    # Plot XY plot.
+    p_xy = GraphicsWindow()
+    p_xy.add_graphics(plot1)
+    p_xy.show()
     
     #Create monitor plot.
-    monitor1 = plots_session.Monitors["monitor-1"]
+    monitor1 = Monitor(solver=session)
     monitor1.monitor_set_name = "residual"
     
     
-    #Plot monitor on window-2.
-    monitor1.plot("window-2")   
+    #Plot monitor.
+    p_res = GraphicsWindow()
+    p_res.add_graphics(monitor1)
+    p_res.show()
     
-    # Create callback that refreshes window-1 and window-2.    
-    def auto_refresh_plot(session_id, event_info):    
-        plotter_windows_manager.refresh_windows(session_id, ["window-1", "window-2"])
+    # Create callback that refreshes 'p_xy' and 'p_res'.
+    def auto_refresh_plot(session_id, event_info):
+        # 'p_xy' and 'p_res' uses 'plotter_windows_manager' in its implementation
+        p_xy.refresh_windows(session.id)
+        p_res.refresh_windows(session.id)
            
     #Register this callback with server events.    
-    cb_init_id = session.events_manager.register_callback('InitializedEvent', auto_refresh_plot)
-    cb_data_read_id = session.events_manager.register_callback('DataReadEvent', auto_refresh_plot)
-    cb_time_step_ended_id = session.events_manager.register_callback('TimestepEndedEvent', auto_refresh_plot)         
-
+    cb_init_id = session.events.register_callback('InitializedEvent', auto_refresh_plot)
+    cb_data_read_id = session.events.register_callback('DataReadEvent', auto_refresh_plot)
+    cb_time_step_ended_id = session.events.register_callback('TimestepEndedEvent', auto_refresh_plot)
 
 .. autoclass:: ansys.fluent.visualization.plotter.plotter_windows_manager.PlotterWindowsManager
    :members:

doc/source/getting_started/index.rst

@@ -56,16 +56,10 @@ You can launch Fluent from PyFluent using the ``launch_fluent`` function:
   session.check_health()
   session.start_transcript() # Streaming the transcript locally
 
-PyFluent-Visualization provides integrations with both
+PyFluent-Visualization seamlessly integrates with both
 `PyVista <https://www.pyvista.org/>`_ and `Matplotlib <https://matplotlib.org/>`_.
-
-If you want to interact with the Fluent graphical user interface, set the
-following environment variable:
-
-.. code::
-
-  set PYFLUENT_SHOW_SERVER_GUI=1    # Windows
-  export PYFLUENT_SHOW_SERVER_GUI=1 # Linux (bash)
+Additionally, it offers flexibility to incorporate other open-source data visualization tools,
+such as `Plotly <https://plotly.com/python/>`_.
 
 If you want to print the debug information for development, set the following
 environment variable: