EventBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_EVENTS_EVENTSBASE_HPP_
#define GEOS_EVENTS_EVENTSBASE_HPP_
 
#include "dataRepository/Group.hpp"
#include "dataRepository/ExecutableGroup.hpp"
 
 
namespace geos
{
 
class EventBase : public ExecutableGroup
{
public:
  explicit EventBase( string const & name,
                      Group * const parent );
 
  virtual ~EventBase() override;
 
  virtual void signalToPrepareForExecution( real64 const time,
                                            real64 const dt,
                                            integer const cycle,
                                            DomainPartition & domain ) override;
  virtual bool execute( real64 const time_n,
                        real64 const dt,
                        integer const cycleNumber,
                        integer const eventCounter,
                        real64 const eventProgress,
                        DomainPartition & 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,
                            DomainPartition & domain );
 
  virtual void estimateEventTiming( real64 const time,
                                    real64 const dt,
                                    integer const cycle,
                                    DomainPartition & domain ) = 0;
 
  virtual real64 getTimestepRequest( real64 const time ) override;
 
  virtual real64 getEventTypeDtRequest( real64 const time )
  {
    GEOS_UNUSED_VAR( time );
    return std::numeric_limits< real64 >::max();
  }
 
  virtual void validate() const {};
 
  void getExecutionOrder( array1d< integer > & eventCounters );
 
  void setProgressIndicator( array1d< integer > & eventCounters );
 
  struct viewKeyStruct
  {
    static constexpr char const * eventTargetString() { return "target"; }
    static constexpr char const * beginTimeString() { return "beginTime"; }
    static constexpr char const * endTimeString() { return "endTime"; }
    static constexpr char const * forceDtString() { return "forceDt"; }
    static constexpr char const * maxEventDtString() { return "maxEventDt"; }
    static constexpr char const * lastTimeString() { return "lastTime"; }
    static constexpr char const * lastCycleString() { return "lastCycle"; }
    static constexpr char const * eventForecastString() { return "eventForecast"; }
    static constexpr char const * targetExactStartStopString() { return "targetExactStartStop"; }
    static constexpr char const * currentSubEventString() { return "currentSubEvent"; }
    static constexpr char const * isTargetExecutingString() { return "isTargetExecuting"; }
    static constexpr char const * finalDtStretchString() { return "finalDtStretch"; }
 
    dataRepository::ViewKey eventTarget = { eventTargetString() };
    dataRepository::ViewKey beginTime = { beginTimeString() };
    dataRepository::ViewKey endTime = { endTimeString() };
    dataRepository::ViewKey forceDt = { forceDtString() };
    dataRepository::ViewKey maxEventDt = { maxEventDtString() };
    dataRepository::ViewKey lastTime = { lastTimeString() };
    dataRepository::ViewKey lastCycle = { lastCycleString() };
    dataRepository::ViewKey eventForecast = { eventForecastString() };
    dataRepository::ViewKey targetExactStartStop = { targetExactStartStopString() };
    dataRepository::ViewKey currentSubEvent = { currentSubEventString() };
    dataRepository::ViewKey isTargetExecuting = { isTargetExecutingString() };
  } viewKeys;
 
  using CatalogInterface = dataRepository::CatalogInterface< EventBase, 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; }
 
  string getEventName() const
  {
    return m_eventTarget;
  }
 
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; }
 
  ExecutableGroup * getEventTarget() const
  { return m_target; }
 
  bool isActive( real64 const time ) const
  { return ( time >= m_beginTime ) && ( time < m_endTime ); }
 
  bool isReadyForCleanup( real64 const time ) const
  { return isActive( time ) || isZero( time - m_endTime ); }
 
 
  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 geos */
 
#endif /* GEOS_EVENTS_EVENTSBASE_HPP_ */