TimeHistoryCollection.hpp

Go to the documentation of this file.

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

#ifndef GEOSX_TimeHistoryCollection_HPP_
#define GEOSX_TimeHistoryCollection_HPP_

#include "managers/Tasks/TaskBase.hpp"
#include "managers/TimeHistory/HistoryDataSpec.hpp"
#include "managers/DomainPartition.hpp"
#include "managers/ProblemManager.hpp"
#include "dataRepository/BufferOpsDevice.hpp"

#include <functional>

namespace geosx
{
using namespace dataRepository;

class HistoryCollection : public TaskBase
{
public:
  HistoryCollection( string const & name, Group * parent ):
    TaskBase( name, parent ),
    m_collectionCount( 1 ),
    m_timeBufferCall(),
    m_bufferCalls()
  {   }


  void InitializePostSubGroups( Group * const group ) override
  {
    GEOSX_UNUSED_VAR( group );
    m_bufferCalls.resize( m_collectionCount );
  }

  virtual localIndex getCollectionCount( ) const
  {
    return m_collectionCount;
  }

  virtual HistoryMetadata getMetadata( ProblemManager & problemManager, localIndex collectionIdx )
  {
    GEOSX_UNUSED_VAR( problemManager );
    GEOSX_UNUSED_VAR( collectionIdx );
    return HistoryMetadata( );
  }

  virtual const string & getTargetName( ) const = 0;

  virtual void Execute( real64 const time_n,
                        real64 const dt,
                        integer const cycleNumber,
                        integer const eventCounter,
                        real64 const eventProgress,
                        Group * domain ) override
  {
    GEOSX_UNUSED_VAR( cycleNumber );
    GEOSX_UNUSED_VAR( eventCounter );
    GEOSX_UNUSED_VAR( eventProgress );
    for( localIndex collectionIdx = 0; collectionIdx < getCollectionCount(); ++collectionIdx )
    {
      // std::function defines the == and =! comparable against nullptr_t to check the
      //  function pointer is actually assigned (an error would be thrown on the call attempt even so)
      GEOSX_ERROR_IF( m_bufferCalls[collectionIdx] == nullptr,
                      "History collection buffer retrieval function is unassigned, did you declare a related TimeHistoryOutput event?" );
      // using GEOSX_ERROR_IF_EQ caused type issues since the values are used in streams
      // TODO : grab the metadata again, determine if the size has changed, update the buffer call if so...
      buffer_unit_type * buffer = m_bufferCalls[collectionIdx]();
      DomainPartition & domainPart = dynamicCast< DomainPartition & >( *domain );
      updateSetsIndices( domainPart );
      collect( domainPart, time_n, dt, collectionIdx, buffer );
    }
    int rank = MpiWrapper::Comm_rank();
    if( rank == 0 && m_timeBufferCall )
    {
      buffer_unit_type * timeBuffer = m_timeBufferCall();
      memcpy( timeBuffer, &time_n, sizeof(time_n) );
    }
  }

  void registerBufferCall( localIndex collectionIdx, std::function< buffer_unit_type *() > bufferCall )
  {
    GEOSX_ERROR_IF( collectionIdx >= this->getCollectionCount( ), "Invalid collection index specified." );
    m_bufferCalls[collectionIdx] = bufferCall;
  }

  HistoryMetadata getTimeMetadata( ) const
  {
    return HistoryMetadata( "Time", 1, std::type_index( typeid(real64) ) );
  }

  void registerTimeBufferCall( std::function< buffer_unit_type *() > timeBufferCall )
  {
    m_timeBufferCall = timeBufferCall;
  }

  virtual localIndex getNumMetaCollectors( ) const
  {
    return 0;
  }

  virtual std::unique_ptr< HistoryCollection > getMetaCollector( ProblemManager & problemManager, localIndex metaIdx )
  {
    GEOSX_UNUSED_VAR( problemManager );
    GEOSX_UNUSED_VAR( metaIdx );
    return std::unique_ptr< HistoryCollection >( nullptr );
  }

  virtual void updateSetsIndices ( DomainPartition & domain ) = 0;

protected:

  virtual void collect( DomainPartition & domain, real64 const time_n, real64 const dt, localIndex const collectionIdx, buffer_unit_type * & buffer ) = 0;

protected:
  localIndex m_collectionCount;
  std::function< buffer_unit_type *() > m_timeBufferCall;
  std::vector< std::function< buffer_unit_type *() > > m_bufferCalls;
};

}

#endif