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