137 lines
4.7 KiB
C++
137 lines
4.7 KiB
C++
/**
|
|
* @file engine_adaptive_scratchpad.h
|
|
* @brief Scratchpad implementation for the AdaptiveEngineView.
|
|
*
|
|
* This header defines the AdaptiveEngineViewScratchPad, a concrete implementation
|
|
* of AbstractScratchPad designed for use with the AdaptiveEngineView. It provides
|
|
* thread-local storage for active species and reactions that are dynamically
|
|
* determined during adaptive network computations.
|
|
*
|
|
* @par Purpose
|
|
* The AdaptiveEngineViewScratchPad stores:
|
|
* - The set of currently active species in the adaptive network
|
|
* - The set of currently active reactions based on network topology
|
|
* - Initialization state to track whether the scratchpad is ready for use
|
|
*
|
|
* @par Examples
|
|
* @code{.cpp}
|
|
* #include "gridfire/engine/scratchpads/engine_adaptive_scratchpad.h"
|
|
* #include "gridfire/engine/views/engine_adaptive.h"
|
|
*
|
|
* // Create and initialize the scratchpad from an AdaptiveEngineView
|
|
* gridfire::engine::scratch::AdaptiveEngineViewScratchPad scratch;
|
|
* AdaptiveEngineView engine = create_adaptive_engine();
|
|
* scratch.initialize(engine);
|
|
*
|
|
* if (scratch.is_initialized()) {
|
|
* // Access active species for computation
|
|
* for (const auto& species : scratch.active_species) {
|
|
* // Process each active species
|
|
* }
|
|
* }
|
|
*
|
|
* // Clone for parallel execution
|
|
* auto worker_scratch = scratch.clone();
|
|
* @endcode
|
|
*
|
|
* @par Thread Safety
|
|
* This class is **not thread-safe**. Each thread should have its own instance
|
|
* of AdaptiveEngineViewScratchPad. Use clone() to create independent copies
|
|
* for parallel workers.
|
|
*
|
|
* @see AbstractScratchPad
|
|
* @see AdaptiveEngineView
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "gridfire/engine/scratchpads/scratchpad_abstract.h"
|
|
#include "gridfire/engine/scratchpads/types.h"
|
|
|
|
#include "gridfire/engine/views/engine_adaptive.h"
|
|
|
|
namespace gridfire::engine::scratch {
|
|
|
|
/**
|
|
* @brief Scratchpad for storing working memory used by AdaptiveEngineView computations.
|
|
*
|
|
* AdaptiveEngineViewScratchPad provides temporary storage for the active species
|
|
* and reactions determined by the adaptive network algorithm. This allows the
|
|
* engine to avoid recalculating network topology on every evaluation.
|
|
*
|
|
* @par Thread Safety
|
|
* This class is **not thread-safe**. Each thread should operate on its own
|
|
* independent instance. Use clone() to create copies for parallel execution.
|
|
*/
|
|
struct AdaptiveEngineViewScratchPad final : AbstractScratchPad {
|
|
/// @brief Unique identifier for this scratchpad type.
|
|
static constexpr auto ID = ScratchPadType::ADAPTIVE_ENGINE_VIEW_SCRATCHPAD;
|
|
|
|
/// @brief Flag indicating whether the scratchpad has been initialized.
|
|
bool has_initialized = false;
|
|
|
|
|
|
/// @brief Vector of species currently active in the adaptive network.
|
|
std::vector<fourdst::atomic::Species> active_species;
|
|
|
|
/// @brief Set of reactions currently active in the adaptive network.
|
|
reaction::ReactionSet active_reactions;
|
|
|
|
/**
|
|
* @brief Check whether the scratchpad has been initialized.
|
|
* @return true if initialized, false otherwise.
|
|
*/
|
|
[[nodiscard]] bool is_initialized() const override { return has_initialized; }
|
|
|
|
/**
|
|
* @brief Initialize the scratchpad from an AdaptiveEngineView.
|
|
*
|
|
* Clears any existing state and prepares the scratchpad for use.
|
|
* This method is idempotent; calling it multiple times has no effect
|
|
* after the first successful initialization.
|
|
*
|
|
* @param engine The AdaptiveEngineView to initialize from.
|
|
*
|
|
* @par Examples
|
|
* @code{.cpp}
|
|
* AdaptiveEngineViewScratchPad scratch;
|
|
* AdaptiveEngineView engine = create_engine();
|
|
* scratch.initialize(engine);
|
|
* @endcode
|
|
*/
|
|
void initialize(const AdaptiveEngineView& engine) {
|
|
if (has_initialized) return;
|
|
active_species.clear();
|
|
active_reactions.clear();
|
|
has_initialized = true;
|
|
}
|
|
|
|
/**
|
|
* @brief Create a deep copy of this scratchpad.
|
|
*
|
|
* Creates an independent copy of all internal state, including
|
|
* active species and reactions. The clone can be modified without
|
|
* affecting the original.
|
|
*
|
|
* @return A unique pointer to the cloned scratchpad.
|
|
*
|
|
* @par Examples
|
|
* @code{.cpp}
|
|
* auto original = std::make_unique<AdaptiveEngineViewScratchPad>();
|
|
* original->initialize(engine);
|
|
*
|
|
* // Create independent copy for a worker thread
|
|
* auto worker_copy = original->clone();
|
|
* @endcode
|
|
*/
|
|
std::unique_ptr<AbstractScratchPad> clone() const override {
|
|
auto ptr = std::make_unique<AdaptiveEngineViewScratchPad>();
|
|
ptr->has_initialized = has_initialized;
|
|
ptr->active_species = active_species;
|
|
ptr->active_reactions = active_reactions;
|
|
return ptr;
|
|
}
|
|
};
|
|
|
|
} // namespace gridfire::engine::scratch
|