anonymous_namespace{Simulation.cpp} Namespace Reference

Functions
bool	detHasSameDimensions (const IDetector &detector, const OutputData< double > &data)
size_t	getIndexStep (size_t total_size, size_t n_handlers)
size_t	getStartIndex (size_t n_handlers, size_t current_handler, size_t n_elements)
size_t	getNumberOfElements (size_t n_handlers, size_t current_handler, size_t n_elements)
void	runComputations (std::vector< std::unique_ptr< IComputation >> computations)

Function Documentation

detHasSameDimensions()

bool anonymous_namespace{Simulation.cpp}::detHasSameDimensions	(	const IDetector &	detector,
		const OutputData< double > &	data
	)

Definition at line 33 of file Simulation.cpp.

{
    if (data.getRank() != detector.dimension())
        return false;
 
    for (size_t i = 0; i < detector.dimension(); ++i)
        if (data.getAxis(i).size() != detector.getAxis(i).size())
            return false;
 
    return true;
}

References IDetector::dimension(), IDetector::getAxis(), OutputData< T >::getAxis(), OutputData< T >::getRank(), and IAxis::size().

Referenced by Simulation::convertData().

Here is the call graph for this function:

getIndexStep()

size_t anonymous_namespace{Simulation.cpp}::getIndexStep	(	size_t	total_size,
		size_t	n_handlers
	)

Definition at line 45 of file Simulation.cpp.

{
    ASSERT(total_size > 0);
    ASSERT(n_handlers > 0);
    size_t result = total_size / n_handlers;
    return total_size % n_handlers ? ++result : result;
}

References ASSERT.

Referenced by getNumberOfElements(), and getStartIndex().

getStartIndex()

size_t anonymous_namespace{Simulation.cpp}::getStartIndex	(	size_t	n_handlers,
		size_t	current_handler,
		size_t	n_elements
	)

Definition at line 53 of file Simulation.cpp.

{
    const size_t handler_size = getIndexStep(n_elements, static_cast<size_t>(n_handlers));
    const size_t start_index = current_handler * handler_size;
    if (start_index >= n_elements)
        return n_elements;
    return start_index;
}

References getIndexStep().

Referenced by Simulation::runSimulation(), and Simulation::runSingleSimulation().

Here is the call graph for this function:

getNumberOfElements()

size_t anonymous_namespace{Simulation.cpp}::getNumberOfElements	(	size_t	n_handlers,
		size_t	current_handler,
		size_t	n_elements
	)

Definition at line 62 of file Simulation.cpp.

{
    const size_t handler_size = getIndexStep(n_elements, static_cast<size_t>(n_handlers));
    const size_t start_index = current_handler * handler_size;
    if (start_index >= n_elements)
        return 0;
    return std::min(handler_size, n_elements - start_index);
}

References getIndexStep().

Referenced by Simulation::runSimulation(), and Simulation::runSingleSimulation().

Here is the call graph for this function:

runComputations()

void anonymous_namespace{Simulation.cpp}::runComputations

(

std::vector< std::unique_ptr< IComputation >>

computations

)

Definition at line 71 of file Simulation.cpp.

{
    ASSERT(!computations.empty());
 
    if (computations.size() == 1) { // Running computation in current thread
        auto& computation = computations.front();
        computation->run();
        if (computation->isCompleted())
            return;
        std::string message = computation->errorMessage();
        throw Exceptions::RuntimeErrorException("Error in runComputations: Simulation has "
                                                "terminated unexpectedly with following error: "
                                                "message.\n"
                                                + message);
    }
 
    // Running computations in several threads.
    // The number of threads is equal to the number of computations.
 
    std::vector<std::unique_ptr<std::thread>> threads;
 
    // Run simulations in n threads.
    for (auto& comp : computations)
        threads.emplace_back(new std::thread([&comp]() { comp->run(); }));
 
    // Wait for threads to complete.
    for (auto& thread : threads)
        thread->join();
 
    // Check successful completion.
    std::vector<std::string> failure_messages;
    for (auto& comp : computations)
        if (!comp->isCompleted())
            failure_messages.push_back(comp->errorMessage());
 
    if (failure_messages.empty())
        return;
    throw Exceptions::RuntimeErrorException(
        "Error in runComputations: "
        "At least one simulation thread has terminated unexpectedly.\n"
        "Messages: "
        + StringUtils::join(failure_messages, " --- "));
}

References ASSERT, and StringUtils::join().

Referenced by Simulation::runSingleSimulation().

Here is the call graph for this function: