vtkLiveInsituLink.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkLiveInsituLink_h
#define vtkLiveInsituLink_h
 
#include "vtkRemotingLiveModule.h" //needed for exports
 
#include "vtkSMObject.h"
#include "vtkSmartPointer.h" // Needed for Smart pointer
#include "vtkWeakPointer.h"  // Needed for Weak pointer
 
class vtkMultiProcessController;
class vtkSMSessionProxyManager;
class vtkPVXMLElement;
class vtkPVSessionBase;
class vtkTrivialProducer;
class vtkExtractsDeliveryHelper;
 
class VTKREMOTINGLIVE_EXPORT vtkLiveInsituLink : public vtkSMObject
{
public:
  static vtkLiveInsituLink* New();
  vtkTypeMacro(vtkLiveInsituLink, vtkSMObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(InsituPort, int);
  vtkGetMacro(InsituPort, int);
 
 
  vtkSetStringMacro(Hostname);
  vtkGetStringMacro(Hostname);
 
 
  enum
  {
    LIVE = 0,
    INSITU = 1
  };
  vtkSetClampMacro(ProcessType, int, LIVE, INSITU);
  vtkGetMacro(ProcessType, int);
 
 
  vtkSetMacro(ProxyId, unsigned int);
  vtkGetMacro(ProxyId, unsigned int);
 
 
  vtkGetMacro(SimulationPaused, int);
  void SetSimulationPaused(int paused);
 
  bool Initialize() { return this->Initialize(nullptr); }
  bool Initialize(vtkSMSessionProxyManager*);
 
  // **************************************************************************
  //      *** API to be used from the insitu library ***
 
  void InsituUpdate(double time, vtkIdType timeStep);
 
  void InsituPostProcess(double time, vtkIdType timeStep);
 
 
  int WaitForLiveChange();
  void OnLiveChanged();
 
  // **************************************************************************
 
  // **************************************************************************
  // API to be used from the LIVE side.
  // Register/unregister a producer for an extract.
  void RegisterExtract(
    vtkTrivialProducer* producer, const char* groupname, const char* proxyname, int portnumber);
  void UnRegisterExtract(vtkTrivialProducer* producer);
 
  void OnInsituUpdate(double time, vtkIdType timeStep);
  void OnInsituPostProcess(double time, vtkIdType timeStep);
  void LiveChanged();
  // **************************************************************************
 
  enum NotificationTags
  {
    CONNECTED = 1200,
    NEXT_TIMESTEP_AVAILABLE = 1201,
    DISCONNECTED = 1202
  };
 
  void UpdateInsituXMLState(const char* txt);
 
  static bool FilterXMLState(vtkPVXMLElement* xmlState);
 
  // ***************************************************************
  // Internal methods, public for callbacks.
  void InsituConnect(vtkMultiProcessController* proc0NodesController);
 
  void DropLiveInsituConnection();
 
protected:
  vtkLiveInsituLink();
  ~vtkLiveInsituLink() override;
 
  enum RMITags
  {
    UPDATE_RMI_TAG = 8800,
    POSTPROCESS_RMI_TAG = 8801,
    INITIALIZE_CONNECTION = 8802,
    DROP_CAT2PV_CONNECTION = 8803,
    // Message from LIVE, sent when simulation is paused,
    // signalling a change.  INSITU wakes up and checks for new
    // simulation state, changed extracts or if it should continue the
    // simulation
    LIVE_CHANGED = 8804
  };
 
  void InitializeLive();
 
  bool InitializeInsitu();
 
  void OnConnectionCreatedEvent();
 
  void OnConnectionClosedEvent(vtkObject*, unsigned long eventid, void* calldata);
 
  char* Hostname;
  int InsituPort;
  int ProcessType;
  unsigned int ProxyId;
 
  bool InsituXMLStateChanged;
  bool ExtractsChanged;
  int SimulationPaused;
 
  char* InsituXMLState;
  vtkWeakPointer<vtkPVSessionBase> LiveSession;
  vtkSmartPointer<vtkMultiProcessController> Proc0NodesController;
  vtkSmartPointer<vtkExtractsDeliveryHelper> ExtractsDeliveryHelper;
 
private:
  vtkLiveInsituLink(const vtkLiveInsituLink&) = delete;
  void operator=(const vtkLiveInsituLink&) = delete;
 
  vtkWeakPointer<vtkSMSessionProxyManager> InsituProxyManager;
 
  vtkSetStringMacro(URL);
  char* URL;
 
  vtkSetStringMacro(InsituXMLState);
 
  class vtkInternals;
  vtkInternals* Internals;
};
 
#endif