Helios++
Helios software for LiDAR simulations
Simulation.h
1 #pragma once
2 
3 #include <Scanner.h>
4 #include <Color4f.h>
5 #include <SimulationStepLoop.h>
6 #include <PulseTaskDropper.h>
7 #include <PulseThreadPoolInterface.h>
8 #include <FullWaveformPulseRunnable.h>
9 #include <SimulationCycleCallback.h>
10 #ifdef PYTHON_BINDING
11 #include <PySimulationCycleCallback.h>
12 #endif
13 #ifdef DATA_ANALYTICS
14 #include <dataanalytics/HDA_StateJSONReporter.h>
15 #endif
16 #include <SimulationReporter.h>
17 
18 #include <chrono>
19 
23 class Simulation {
24 friend class SimulationReporter;
25 #ifdef DATA_ANALYTICS
26 friend class helios::analytics::HDA_StateJSONReporter;
27 #endif
28 protected:
29  // *** ATTRIBUTES *** //
30  // ******************** //
36 
42  std::shared_ptr<PulseThreadPoolInterface> threadPool;
48 
52  double mSimSpeedFactor = 1;
53 
58  std::shared_ptr<Scanner> mScanner = nullptr;
59 
65 
70  size_t callbackFrequency = 0;
71 
76  std::mutex mutex;
81  std::condition_variable condvar;
87  std::shared_ptr<std::unique_lock<std::mutex>> pauseLock = nullptr;
88 
93  bool mStopped = false;
98  bool mPaused = false;
99 
103  std::chrono::nanoseconds timeStart_ns;
104 
109  double currentGpsTime_ns = 0;
114  double stepGpsTime_ns = 0;
123  std::string fixedGpsTimeStart = "";
129 
130 public:
134  unsigned int mCurrentLegIndex = 0;
135 
140  bool exportToFile = true;
145  bool exitAtEnd = false;
149  bool finished = false;
150 
151  std::shared_ptr<SimulationCycleCallback> callback = nullptr;
152 
153  // *** CONSTRUCTION / DESTRUCTION *** //
154  // ************************************ //
164  Simulation(
165  int const parallelizationStrategy,
166  std::shared_ptr<PulseThreadPoolInterface> pulseThreadPoolInterface,
167  int const chunkSize,
168  std::string fixedGpsTimeStart=""
169  );
170 
171  // *** SIMULATION METHODS *** //
172  // **************************** //
177  virtual void prepareSimulation(int simFrequency_hz);
181  virtual void doSimStep();
185  virtual void onLegComplete() = 0;
186 
190  void start();
198  void stop() {this->mStopped = true;}
203  void pause(bool pause);
207  void shutdown();
208 
209 
210  // *** UTIL METHODS *** //
211  // ********************** //
216  double calcCurrentGpsTime();
217 
218 
219  // *** GETTERS and SETTERS *** //
220  // ***************************** //
233  void setSimSpeedFactor(double factor);
239  inline double getSimSpeedFactor() const {return this->mSimSpeedFactor;}
240 
246  void setScanner(std::shared_ptr<Scanner> scanner);
252  inline std::shared_ptr<Scanner> getScanner() {return this->mScanner;}
253 
254 
260  inline bool isPaused() const {return this->mPaused;}
266  inline bool isStopped() const {return this->mStopped;}
272  inline size_t getSimFrequency() const {return stepLoop.getFrequency();}
278  inline void setSimFrequency(size_t const simFrequency)
279  {stepLoop.setFrequency(simFrequency);}
287  inline size_t getCallbackFrequency() const
288  {return callbackFrequency;}
295  inline void setCallbackFrequency(size_t const callbackFrequency)
296  {this->callbackFrequency = callbackFrequency;}
304  {return stepLoop;}
305 };
Class implementing a task dropper to deal with pulse tasks.
Definition: PulseTaskDropper.h:27
Class to handle reports related to simulation.
Definition: SimulationReporter.h:13
Class extending LinearVoidStepLoop to support main simulation loop.
Definition: SimulationStepLoop.h:15
std::size_t getFrequency() const
Definition: SimulationStepLoop.h:42
void setFrequency(std::size_t const frequency)
Definition: SimulationStepLoop.h:46
Class representing a simulation.
Definition: Simulation.h:23
double currentGpsTime_ns
Time corresponding to simulation start (currentGpsTime in nanoseconds)
Definition: Simulation.h:109
void setSimSpeedFactor(double factor)
Set the simulation speed factor.
Definition: Simulation.cpp:236
size_t getCallbackFrequency() const
Get the callback frequency. It is, how many steps must elapse between consecutive callbacks.
Definition: Simulation.h:287
std::mutex mutex
Mutex to handle simulation pause and iterations on a multi threading context.
Definition: Simulation.h:76
void shutdown()
Handle simulation shutdown.
Definition: Simulation.cpp:104
void setSimFrequency(size_t const simFrequency)
Set simulation frequency.
Definition: Simulation.h:278
virtual void prepareSimulation(int simFrequency_hz)
Prepare the simulation before starting its main loop.
Definition: Simulation.cpp:48
std::shared_ptr< Scanner > mScanner
Scanner used by the simulation.
Definition: Simulation.h:58
PulseTaskDropper taskDropper
Pulse task dropper.
Definition: Simulation.h:47
std::shared_ptr< PulseThreadPoolInterface > threadPool
Pulse thread pool.
Definition: Simulation.h:42
int parallelizationStrategy
Specify the parallelization strategy.
Definition: Simulation.h:35
virtual void doSimStep()
Perform computations for current simulation step.
Definition: Simulation.cpp:70
unsigned int mCurrentLegIndex
Index of leg at current simulation stage.
Definition: Simulation.h:134
bool mStopped
Flag specifying if the simulation has been stopped (true) or not (false)
Definition: Simulation.h:93
bool mPaused
Flag specifying if the simulation has been paused (true) or not (false)
Definition: Simulation.h:98
size_t callbackFrequency
The callback frequency. It specifies how many steps must elapse between consecutive callbacks.
Definition: Simulation.h:70
double mSimSpeedFactor
Simulation speed factor.
Definition: Simulation.h:52
bool isPaused() const
Check if simulation is paused (true) or not (false)
Definition: Simulation.h:260
SimulationStepLoop stepLoop
The handler for simulation steps, it also contains the discrete time object that hanldes simulation f...
Definition: Simulation.h:64
virtual void onLegComplete()=0
Handle leg completion.
bool exportToFile
Flag specifying if simulation output must be exported to a file (true) or not (false)
Definition: Simulation.h:140
size_t getSimFrequency() const
Obtain simulation frequency.
Definition: Simulation.h:272
bool exitAtEnd
Flag specifying if simulation must end when current leg has been completed (true) or not (false)
Definition: Simulation.h:145
bool isStopped() const
Check if simulation is stopped (true) or not (false)
Definition: Simulation.h:266
void setCallbackFrequency(size_t const callbackFrequency)
Set the new callback frequency.
Definition: Simulation.h:295
std::chrono::nanoseconds timeStart_ns
Time corresponding to simulation start (nanoseconds)
Definition: Simulation.h:103
SimulationStepLoop & getStepLoop()
Get the simulation step loop of the simulation.
Definition: Simulation.h:303
std::shared_ptr< std::unique_lock< std::mutex > > pauseLock
Shared pointer to the lock used to handle the mutex for simulation pause purposes.
Definition: Simulation.h:87
double stepGpsTime_ns
The time step for GPS time (in nanoseconds)
Definition: Simulation.h:114
std::shared_ptr< Scanner > getScanner()
Obtain simulation scanner.
Definition: Simulation.h:252
std::condition_variable condvar
Condition variable tu handle simulation iterations on a multi threading context.
Definition: Simulation.h:81
std::string fixedGpsTimeStart
Given fixed time start for GPS time as a string.
Definition: Simulation.h:123
SimulationReporter reporter
The report to generate reports about simulation.
Definition: Simulation.h:128
double getSimSpeedFactor() const
Obtain simulation speed factor.
Definition: Simulation.h:239
void start()
Start the simmulation.
Definition: Simulation.cpp:118
void setScanner(std::shared_ptr< Scanner > scanner)
Set scanner for the simulation.
Definition: Simulation.cpp:252
bool finished
Flag specifying if simulation has finished (true) or not (false)
Definition: Simulation.h:149
void pause(bool pause)
Pause or unpause the simulation.
Definition: Simulation.cpp:90
Simulation(int const parallelizationStrategy, std::shared_ptr< PulseThreadPoolInterface > pulseThreadPoolInterface, int const chunkSize, std::string fixedGpsTimeStart="")
Simulation constructor.
Definition: Simulation.cpp:28
void stop()
Stop the simulation.
Definition: Simulation.h:198
double calcCurrentGpsTime()
Compute the current GPS time (nanoseconds)
Definition: Simulation.cpp:196