Collect the different options for simulation. More...

Collaboration diagram for SimulationOptions:

Public Member Functions
	SimulationOptions ()

unsigned	getCurrentBatch () const

unsigned	getHardwareConcurrency () const

size_t	getMcPoints () const

unsigned	getNumberOfBatches () const

unsigned	getNumberOfThreads () const

bool	includeSpecular () const

bool	isIntegrate () const

void	setIncludeSpecular (bool include_specular)

void	setMonteCarloIntegration (bool flag=true, size_t mc_points=50)
	Enables/disables MonetCarlo integration. More...

void	setNumberOfBatches (int nbatches)
	Sets number of batches to split. More...

void	setNumberOfThreads (int nthreads)
	Sets number of threads to use during the simulation (0 - take the default value from the hardware) More...

void	setThreadInfo (const ThreadInfo &thread_info)
	Sets the batch and thread information to be used. More...

void	setUseAvgMaterials (bool use_avg_materials)

bool	useAvgMaterials () const

Private Attributes
bool	m_include_specular

bool	m_mc_integration

size_t	m_mc_points

ThreadInfo	m_thread_info

bool	m_use_avg_materials

Detailed Description

Collect the different options for simulation.

SimulationOptions

Definition at line 27 of file SimulationOptions.h.

Constructor & Destructor Documentation

◆ SimulationOptions()

SimulationOptions::SimulationOptions ( )

Definition at line 19 of file SimulationOptions.cpp.

     : m_mc_integration(false), m_include_specular(false), m_use_avg_materials(false), m_mc_points(1)
 {
     m_thread_info.n_threads = getHardwareConcurrency();
 }

References getHardwareConcurrency(), m_thread_info, and ThreadInfo::n_threads.

Here is the call graph for this function:

Member Function Documentation

◆ getCurrentBatch()

unsigned SimulationOptions::getCurrentBatch ( ) const

Definition at line 70 of file SimulationOptions.cpp.

 {
     if (m_thread_info.current_batch >= getNumberOfBatches())
         throw std::runtime_error(
             "Error in SimulationOptions::getCurrentBatch: current batch is out of range");
     return m_thread_info.current_batch;
 }

References ThreadInfo::current_batch, getNumberOfBatches(), and m_thread_info.

Referenced by ISimulation::runSimulation().

Here is the call graph for this function:

◆ getHardwareConcurrency()

unsigned SimulationOptions::getHardwareConcurrency ( ) const

Definition at line 78 of file SimulationOptions.cpp.

 {
     return std::thread::hardware_concurrency();
 }

Referenced by SimulationOptions(), and setNumberOfThreads().

◆ getMcPoints()

size_t SimulationOptions::getMcPoints ( ) const

inline

Definition at line 32 of file SimulationOptions.h.

32 { return m_mc_points; }

References m_mc_points.

Referenced by IInterferenceFunctionStrategy::MCIntegratedEvaluate(), and GUIObjectBuilder::populateDocumentModel().

◆ getNumberOfBatches()

unsigned SimulationOptions::getNumberOfBatches ( ) const

Definition at line 62 of file SimulationOptions.cpp.

 {
     if (m_thread_info.n_batches < 1)
         throw std::runtime_error("Error in SimulationOptions::getNumberOfBatches: Number of "
                                  "batches must be positive");
     return m_thread_info.n_batches;
 }

References m_thread_info, and ThreadInfo::n_batches.

Referenced by getCurrentBatch(), and ISimulation::runSimulation().

◆ getNumberOfThreads()

unsigned SimulationOptions::getNumberOfThreads ( ) const

Definition at line 46 of file SimulationOptions.cpp.

 {
     if (m_thread_info.n_threads < 1)
         throw std::runtime_error("Error in SimulationOptions::getNumberOfThreads: Number of "
                                  "threads must be positive");
     return m_thread_info.n_threads;
 }

References m_thread_info, and ThreadInfo::n_threads.

Referenced by ISimulation::runSingleSimulation().

◆ includeSpecular()

bool SimulationOptions::includeSpecular ( ) const

inline

Definition at line 59 of file SimulationOptions.h.

59 { return m_include_specular; }

References m_include_specular.

Referenced by DWBAComputation::DWBAComputation(), and GUIObjectBuilder::populateDocumentModel().

◆ isIntegrate()

bool SimulationOptions::isIntegrate ( ) const

Definition at line 25 of file SimulationOptions.cpp.

 {
     return m_mc_integration && m_mc_points > 1;
 }

References m_mc_integration, and m_mc_points.

Referenced by IInterferenceFunctionStrategy::evaluate(), and GUIObjectBuilder::populateDocumentModel().

◆ setIncludeSpecular()

void SimulationOptions::setIncludeSpecular ( bool include_specular )

inline

Definition at line 57 of file SimulationOptions.h.

57 { m_include_specular = include_specular; }

References m_include_specular.

Referenced by StandardSimulations::MiniGISASSpecularPeak(), and TransformToDomain::setSimulationOptions().

◆ setMonteCarloIntegration()

void SimulationOptions::setMonteCarloIntegration	(	bool	flag = `true`,
		size_t	mc_points = `50`
	)

Enables/disables MonetCarlo integration.

Parameters

flag	If true, MonteCarlo integration will be used, otherwise analytical calculations
mc_points	Number of points for MonteCarlo integrator

Definition at line 30 of file SimulationOptions.cpp.

 {
     m_mc_integration = flag;
     m_mc_points = mc_points;
 }

References m_mc_integration, and m_mc_points.

Referenced by StandardSimulations::MiniGISASMonteCarlo(), and TransformToDomain::setSimulationOptions().

◆ setNumberOfBatches()

void SimulationOptions::setNumberOfBatches ( int nbatches )

Sets number of batches to split.

Definition at line 54 of file SimulationOptions.cpp.

 {
     if (nbatches < 1)
         throw std::runtime_error("Error in SimulationOptions::setNumberOfBatches: Number of "
                                  "batches must be positive");
     m_thread_info.n_batches = nbatches;
 }

References m_thread_info, and ThreadInfo::n_batches.

◆ setNumberOfThreads()

void SimulationOptions::setNumberOfThreads ( int nthreads )

Sets number of threads to use during the simulation (0 - take the default value from the hardware)

Definition at line 36 of file SimulationOptions.cpp.

 {
     if (nthreads == 0)
         m_thread_info.n_threads = getHardwareConcurrency();
     else if (nthreads > 0)
         m_thread_info.n_threads = nthreads;
     else
         m_thread_info.n_threads = 1;
 }