Data types/model/format

CF compliant data

Data stored in netCDF files that follow the NetCDF Climate and Forecast (CF) Metadata Convention should, for the most part, be treated as a first class citizen. The CF conventions permit data to be defined on general structured grids described by 1D, 2D, and 3D coordinate variables. No restrictions are placed the number of grids defined, nor whether they are static over time. The Grids are most typically described in spherical (lat, lon, and height) coordinates. These data should be displayable in has close to their native form as possible, without the need for resampling to a common grid, or projection to a Cartesian space. I.e. it should be able possible to display the data on a sphere.

There are aspects of the CF convention that are not suitable or practical to support within VAPOR. These should be identified and documented.

Combining data from multiple sources

It should be possible to display data arising from multiple sources and stored in distinctly different files. An example of this is coupled weather and regional ocean models, where the weather model used might be WRF, while the ocean model could be ROMS.

Models with unstructured grids

Numerous earth science numerical models new exist that employ some form of less structured, or fully unstructured grids. Examples include: MPAS, ICON, and HOMME. VAPOR should be able to operate directly on these data without having to resample them to a structured grid.

New visualizers

A user may want to extend an existing, or add an entirely new, visualizer. For example an isoline visualizer might be developed to meet the weather communities needs.

Typical Control Executive Use Case

This is just intended to illustrate how the ControlExecutive would function with the proposed new ControlExecutive API.  The following rendering session could be controlled by a GUI (like the current Qt GUI) or it could be run from a script.

  1. Startup :
    1. Start the app(GUI or script or whatever). 
    2. Setup initial configuration (determine which params are available, single visualizer) , construct VizWinMgr based on this.
    3. If GUI:  create EventRouters for each Params class
  2. Load a session file
    1. This is an existing method on Session.  This method causes all the Params instances to be set up with appropriate values from the session file
  3. Load a data set into existing session
    1. This is another existing method on Session.  Creates a Datamgr, which then (lazily) provides DataStatus API
    2. Invoke VizWinMgr::reinitializeParams() which goes through all of the params instances, calling Params::reinit, setting the Params for the new DataMgr
    3. If API:  call EventRouter::reinitTab() to set up the gui elements that depend on the data
    4. Create OpenGL context for each visualizer [currently a Qt GLWidget]
  4. Specify region, timestep, viewpoint
    1. These methods on RegionParams, AnimationParams, ViewpointParams should be modified to use extensibility API.
  5. Set desired parameters in one (or more ) RenderParams; for example setting a field variable in ArrowParams.  Note that most RenderParams do not yet support the extensibility API.
    1. Get the Params Instance:  Params::GetParamsInstance(_ArrowParamsTag, windowNum, instanceNum)
    2. Get the current variable names:  GetRootNode()->GetElementStringVec(_variableNamesTag...)
    3. Set the new variable names: GetRootNode()->SetElementStringVec(_variableNamesTag, newVarNames)
  6. Enable a renderer:
    1. Create an instance of the Renderer subclass
    2. Insert this renderer in the renderer queue (GLWindow::insertRenderer)
    3. Set appropriate dirty bits in VizWinMgr so that renderer will reinitialize the first time it renders
  7. Render the scene
    1. If GUI:  call VizWin::updateGL()
    2. Otherwise, bind to texture, then call GLWindow::paintGL on the appropriate visualizer.  [does bind to texture call makeCurrent()?]
  8. Render and capture an animation sequence.
    1. Call method on VizWinMgr to initiate animation sequence [e.g. specify output file]
    2. Loop over frames:
      1. set frame num
      2. set file name
      3. Bind to texture
      4. call updateGL() or equivalent
      5. Write buffer to file, close file
    3. VizWinMgr terminates animation.
  • No labels