EventBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_MANAGERS_EVENTS_EVENTSBASE_HPP_
#define GEOSX_MANAGERS_EVENTS_EVENTSBASE_HPP_

#include "dataRepository/Group.hpp"
#include "dataRepository/ExecutableGroup.hpp"
#include "fileIO/schema/schemaUtilities.hpp"


namespace geosx
{

class EventBase : public ExecutableGroup
{
public:
  explicit EventBase( std::string const & name,
                      Group * const parent );

  virtual ~EventBase() override;

  static string CatalogName() { return "EventBase"; }

  virtual void SignalToPrepareForExecution( real64 const time,
                                            real64 const dt,
                                            integer const cycle,
                                            dataRepository::Group * domain ) override;
  virtual void Execute( real64 const time_n,
                        real64 const dt,
                        integer const cycleNumber,
                        integer const eventCounter,
                        real64 const eventProgress,
                        dataRepository::Group * domain ) override;

  void Step( real64 const time,
             real64 const dt,
             integer const cycle,
             dataRepository::Group * domain );

  virtual Group * CreateChild( string const & childKey, string const & childName ) override;

  virtual void ExpandObjectCatalogs() override;

  void GetTargetReferences();

  virtual void CheckEvents( real64 const time,
                            real64 const dt,
                            integer const cycle,
                            dataRepository::Group * domain );

  virtual void EstimateEventTiming( real64 const time,
                                    real64 const dt,
                                    integer const cycle,
                                    dataRepository::Group * domain ) = 0;

  virtual real64 GetTimestepRequest( real64 const time ) override;

  virtual real64 GetEventTypeDtRequest( real64 const time )
  {
    GEOSX_UNUSED_VAR( time );
    return std::numeric_limits< real64 >::max();
  }


  void GetExecutionOrder( array1d< integer > & eventCounters );

  void SetProgressIndicator( array1d< integer > & eventCounters );

  struct viewKeyStruct
  {
    static constexpr auto eventTargetString = "target";
    static constexpr auto beginTimeString = "beginTime";
    static constexpr auto endTimeString = "endTime";
    static constexpr auto forceDtString = "forceDt";
    static constexpr auto maxEventDtString = "maxEventDt";
    static constexpr auto lastTimeString = "lastTime";
    static constexpr auto lastCycleString = "lastCycle";
    static constexpr auto eventForecastString = "eventForecast";
    static constexpr auto targetExactStartStopString = "targetExactStartStop";
    static constexpr auto currentSubEventString = "currentSubEvent";
    static constexpr auto isTargetExecutingString = "isTargetExecuting";
    static constexpr auto finalDtStretchString = "finalDtStretch";

    dataRepository::ViewKey eventTarget = { "target" };
    dataRepository::ViewKey beginTime = { "beginTime" };
    dataRepository::ViewKey endTime = { "endTime" };
    dataRepository::ViewKey forceDt = { "forceDt" };
    dataRepository::ViewKey maxEventDt = { "maxEventDt" };
    dataRepository::ViewKey lastTime = { "lastTime" };
    dataRepository::ViewKey lastCycle = { "lastCycle" };
    dataRepository::ViewKey eventForecast = { "eventForecast" };
    dataRepository::ViewKey targetExactStartStop = { "targetExactStartStop" };
    dataRepository::ViewKey currentSubEvent = { "currentSubEvent" };
    dataRepository::ViewKey isTargetExecuting = { "isTargetExecuting" };
  } viewKeys;

  using CatalogInterface = dataRepository::CatalogInterface< EventBase, std::string const &, Group * const >;
  static CatalogInterface::CatalogType & GetCatalog();

  integer GetExitFlag();

  void SetExitFlag( integer flag ){ m_exitFlag = flag; }

  real64  GetCurrentEventDtRequest() const { return m_currentEventDtRequest; }

  integer getForecast() const
  { return m_eventForecast; }

  bool isReadyForExec() const
  { return m_eventForecast <= 0; }

  bool hasToPrepareForExec() const
  { return m_eventForecast == 1; }

  bool isIdle() const
  { return m_eventForecast > 1; }

protected:

  void setReadyForExec()
  { m_eventForecast = 0; }

  void setPrepareForExec()
  { m_eventForecast = 1; }

  void setIdle()
  { m_eventForecast = std::numeric_limits< decltype( m_eventForecast ) >::max(); }

  void setForecast( integer forecast )
  { m_eventForecast = forecast; }

  bool isActive( real64 const time ) const
  { return ( time >= m_beginTime ) && ( time < m_endTime ); }

  ExecutableGroup * GetEventTarget() const
  { return m_target; }

  real64 m_lastTime;
  integer m_lastCycle;

private:
  string m_eventTarget;
  real64 m_beginTime;
  real64 m_endTime;
  real64 m_forceDt;
  real64 m_maxEventDt;
  real64 m_finalDtStretch;
  integer m_targetExactStartStop;
  integer m_currentSubEvent;
  integer m_targetExecFlag;
  integer m_eventForecast;
  integer m_exitFlag;
  integer m_eventCount;
  integer m_timeStepEventCount;
  real64 m_eventProgress;
  real64 m_currentEventDtRequest;

  ExecutableGroup * m_target;
};

} /* namespace geosx */

#endif /* GEOSX_MANAGERS_EVENTS_EVENTSBASE_HPP_ */