documentation and fixed data visualizer

Author: xLPMG

docs/source/files/assignments/project.rst

@@ -2,42 +2,47 @@
 10. Project Phase
 ###################
 
-In the project phase we decided to implement a userfriendly Gui. The aim is to make the usage of our Tsunami solver
+In the project phase we decided to implement a user-friendly Gui. The aim was to make the usage of our Tsunami solver
 as easy and interactive as possible. 
 
 *********************
-GUI (Client-side)
+Preface
 *********************
 
-..  image:: ../../_static/assets/task-10-Gui_help.png
-
-For the layout we chose to use multiple tabs, in order to make the use more clear.
-The first page gives general informations about the project and refers to our website.
-
-..  image:: ../../_static/assets/task-10-Gui_connectivity.png
+While we tried to stick to our plan as best as we could, we decided to do some things a little different.
+The biggest difference being a Client-Server approach although we explicitly mentioned we would not realize this.
+The original triggering point for this were all kinds of loading times and issues with concurrency: 
+for any GUI application, one of the key features is its responsiveness to user input. Be it numerical input or just clicking and moving things around - the GUI should react as fast as possible.
+Integrating a GUI directly into the solver application while maintaining this responsiveness meant that the GUI and every other task the actual solver does, need to be separated in different threads 
+to assure that the GUI thread has always time for the user.
 
-Tab number two handles the the connection to thhe server. The properties for interacting with the server are getting set here. 
-Furthermore, the connection can also be disconnected here.
+We started off with this directly integrated and threaded approach and quickly realized that handling correct communication between two or more asynchronous running threads was getting closer and closer to just having two separate applications communicating over an API.
+Knowing that this approach meant we would have to invest a lot more effort and work overtime, we decided on taking this path nontheless as it would come with a lot of other benefits as well.
+Now, using the Server-Client model we have a GUI that can just send commands to the server without needing to wait for a response (most of the time, unless you're specifically asking for data such as water/bathymetry data).
 
-..  image:: ../../_static/assets/task-10-Gui_windows.png
+It can also be used in scenarios when using a more powerful machine (e.g. HPC-Cluster) without display access. Just start the program as a server on the remote machine and control it from home via laptop - its that easy.
 
-On the next page the user can find all options of configuration for the simulation. The simulation parameters like cell amount, size and offset can be set here.
-In Addition to that, compiler and run time options can be found here. These contain differetn modes, compiler options, flags and usage choices. 
-After selecting the simulation has to be recompiled with the according button below.
+*********************
+GUI (Client-side)
+*********************
 
-..  image:: ../../_static/assets/task-10-Gui_select.png
+*********************
+Server-side
+*********************
 
-The last tab contains further actions to interact with the simulation. First, the simulation can be started or killed here.
-Also files for the bathymetry and displacement can be chosen. As an addition, the user can get data like the heigth from the simulation. 
+The first thing we did was to modularize our main ``tsunami_lab`` program. The original ``main.cpp`` had one main function that executed the whole program loop.
 
 *********************
-Server-side
+Build process
 *********************
 
 *********************
 Libraries
 *********************
 
+To keep the main code clean, we decided to export most of the code associated with communication to external libraries:
+the Communicator and the API.
+
 Communicator
 =====================
 

lib/xlpmg/Communicator.hpp

@@ -27,13 +27,11 @@ namespace xlpmg
     class Communicator
     {
     private:
-        // Timeout value for socket operations in seconds
-        int TIMEOUT = 20;
         // Log data for storing communication logs
         std::string logData = "";
-        // Socket related variables
+        // Client socket related variables
         int sockStatus, sockValread, sockClient_fd = -1;
-        // Socket related variables
+        // Server socket related variables
         int server_fd, new_socket;
 
         /**
@@ -113,25 +111,60 @@ namespace xlpmg
             }
         }
 
+        /**
+         * Sets the send timeout for a socket.
+         * @param socket The socket to set the send timeout for.
+         * @param timeout The timeout value in seconds.
+         */
+        void setSendTimeout(int socket, long timeout){
+            struct timeval tv;
+            tv.tv_sec = timeout;
+            tv.tv_usec = 0;
+            setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval));
+        }
+
+        /**
+         * Sets the receive timeout for a socket.
+         * @param socket The socket to set the receive timeout for.
+         * @param timeout The timeout value in seconds.
+         */
+        void setRecvTimeout(int socket, long timeout){
+            struct timeval tv;
+            tv.tv_sec = timeout;
+            tv.tv_usec = 0;
+            setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval));
+        }
+
     public:
+        // Timeout value for normal socket operations in seconds
+        static const long TIMEOUT = 2;
         //! default size of the reading buffer
-        const unsigned int BUFF_SIZE_READ_DEFAULT = 8096;
+        unsigned int BUFF_SIZE_READ_DEFAULT = 8096;
         //! actual size of the reading buffer
         unsigned int BUFF_SIZE_READ = BUFF_SIZE_READ_DEFAULT;
-
         //! default size of the sending buffer
-        const unsigned int BUFF_SIZE_SEND_DEFAULT = 8096;
+        unsigned int BUFF_SIZE_SEND_DEFAULT = 8096;
         //! actual size of the sending buffer
         unsigned int BUFF_SIZE_SEND = BUFF_SIZE_SEND_DEFAULT;
 
         //! true if there is a connection
         bool isConnected = false;
 
+        /**
+         * @brief Sets the read buffer size.
+         * 
+         * @param newSize The new size of the read buffer.
+         */
         void setReadBufferSize(unsigned int newSize)
         {
             BUFF_SIZE_READ = newSize;
         }
 
+        /**
+         * @brief Sets the send buffer size.
+         * 
+         * @param newSize The new size of the send buffer.
+         */
         void setSendBufferSize(unsigned int newSize)
         {
             BUFF_SIZE_SEND = newSize;
@@ -149,9 +182,6 @@ namespace xlpmg
         int startClient(char *IPADDRESS, int PORT)
         {
             struct sockaddr_in serv_addr;
-            struct timeval tv;
-            tv.tv_sec = TIMEOUT;
-            tv.tv_usec = 0;
 
             if ((sockClient_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
             {
@@ -161,8 +191,8 @@ namespace xlpmg
             }
             logEvent("Socket created.", INFO, true);
 
-            setsockopt(sockClient_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval));
-            setsockopt(sockClient_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval));
+            setSendTimeout(sockClient_fd, TIMEOUT);
+            setRecvTimeout(sockClient_fd, TIMEOUT);
 
             serv_addr.sin_family = AF_INET;
             serv_addr.sin_port = htons(PORT);
@@ -191,7 +221,7 @@ namespace xlpmg
 
         /**
          * @brief Stops all connections of the client socket.
-        */
+         */
         void stopClient()
         {
             // closing the connected socket
@@ -202,9 +232,10 @@ namespace xlpmg
         /**
          * @brief Receives a message from the server.
          * @return Message as string.
+         * @param timeout Timeout for the operation in seconds.
          * @param log Whether the message should be logged or not.
          */
-        std::string receiveFromServer(bool log = true)
+        std::string receiveFromServer(long timeout = TIMEOUT, bool log = true)
         {
             if (sockClient_fd < 0)
             {
@@ -217,6 +248,8 @@ namespace xlpmg
             bool finished = false;
             unsigned long totalBytes = 0;
 
+            setRecvTimeout(sockClient_fd, timeout);
+
             logEvent(std::to_string(totalBytes) + " Bytes (" + std::to_string(totalBytes / 1000000) + " MB) received             ", DEBUG, log);
 
             while (!finished)
@@ -255,33 +288,29 @@ namespace xlpmg
                     finished = true;
                 }
             }
+            setRecvTimeout(sockClient_fd, TIMEOUT);
             isConnected = true;
             return message;
         }
 
-        /**
-         * @brief Checks if the server is reachable.
-         * @return true if server responded.
-         */
-        bool checkServerResponse()
-        {
-            
-        }
-
         /**
          * @brief Sends a message to the server.
          * @param message String to send.
+         * @param timeout Timeout for the operation in seconds.
          * @param log Whether the message should be logged or not.
          * @return 0 if successful, 1 otherwise.
          */
-        int sendToServer(std::string message, bool log = true)
+        int sendToServer(std::string message, long timeout = TIMEOUT, bool log = true)
         {
             if (sockClient_fd < 0)
             {
                 logEvent("Sending failed: Socket not initialized.", ERROR, log);
                 isConnected = false;
                 return 1;
             }
+
+            setSendTimeout(sockClient_fd, timeout);
+
             // terminator
             message.append("#!");
 
@@ -317,6 +346,7 @@ namespace xlpmg
                     logEvent(bytesSentStr.c_str(), DEBUG, log, true);
                 }
             }
+            setSendTimeout(sockClient_fd, TIMEOUT);
             isConnected = true;
             return 0;
         }
@@ -370,10 +400,13 @@ namespace xlpmg
                 isConnected = false;
                 exit(EXIT_FAILURE);
             }
+            
             address.sin_family = AF_INET;
             address.sin_addr.s_addr = INADDR_ANY;
             address.sin_port = htons(PORT);
 
+            setSendTimeout(new_socket, TIMEOUT);
+
             // Forcefully attaching socket to the port 8080
             if (bind(server_fd, (struct sockaddr *)&address,
                      sizeof(address)) < 0)

lib/xlpmg/communicator_api.h

@@ -194,9 +194,9 @@ namespace xlpmg
   // HIGH
 
   //! Tells the server to start sending height data. (buffered)
-  inline const Message GET_HEIGHT_DATA = {MessageExpectation::EXPECT_RESPONSE, MessageUrgency::MEDIUM, "get_height_data"};
+  inline const Message GET_HEIGHT_DATA = {MessageExpectation::EXPECT_RESPONSE, MessageUrgency::HIGH, "get_height_data"};
   //! Tells the server to start sending bathymetry data. (buffered)
-  inline const Message GET_BATHYMETRY_DATA = {MessageExpectation::EXPECT_RESPONSE, MessageUrgency::MEDIUM, "get_bathymetry_data"};
+  inline const Message GET_BATHYMETRY_DATA = {MessageExpectation::EXPECT_RESPONSE, MessageUrgency::HIGH, "get_bathymetry_data"};
 
   // MEDIUM
 

src/Server.cpp

@@ -16,14 +16,11 @@ std::thread m_updateThread;
 std::atomic<bool> m_stopUpdating = false;
 bool m_isSimulationRunning = false;
 
-// updating
+// last update time point
 std::chrono::time_point m_lastDataUpdate = std::chrono::high_resolution_clock::now();
+// data update frequency in ms
 int m_dataUpdateFrequency = 10;
 
-// temp files
-std::string m_bathTempFile = "bathymetry_temp.nc";
-std::string m_displTempFile = "displacement_temp.nc";
-
 // system info
 tsunami_lab::systeminfo::SystemInfo l_systemInfo;
 double l_usedRAM = 0;
@@ -143,6 +140,12 @@ int main(int i_argc, char *i_argv[])
                     {
                         exitSimulationThread();
                     }
+                    else if (l_key == xlpmg::WRITE_CHECKPOINT.key)
+                    {
+                        std::cout << "Writing checkpoint" << std::endl;
+                        simulator->writeCheckpoint();
+                    }
+
                     else if (l_key == xlpmg::PAUSE_SIMULATION.key)
                     {
                         std::cout << "Pause simulation" << std::endl;
@@ -160,7 +163,7 @@ int main(int i_argc, char *i_argv[])
                 {
                     if (l_key == xlpmg::CHECK.key)
                     {
-                        l_communicator.sendToClient("OK");
+                        std::cout << "A client requested a check." << std::endl;
                     }
                     else if (l_key == xlpmg::START_SIMULATION.key)
                     {
@@ -417,26 +420,25 @@ int main(int i_argc, char *i_argv[])
                         xlpmg::Message l_heightDataMsg = xlpmg::SERVER_RESPONSE;
                         l_heightDataMsg.key = "height_data";
                         json l_data;
-
                         // get data from simulation
                         if (simulator->getWaveProp() != nullptr)
                         {
                             tsunami_lab::patches::WavePropagation *l_waveprop = simulator->getWaveProp();
                             const tsunami_lab::t_real *l_heightData = l_waveprop->getHeight();
-                            const tsunami_lab::t_real *l_bathymetryData = l_waveprop->getBathymetry();
                             // calculate array size
                             tsunami_lab::t_idx l_ncellsX, l_ncellsY;
                             simulator->getCellAmount(l_ncellsX, l_ncellsY);
                             for (tsunami_lab::t_idx y = 0; y < l_ncellsY; y++)
                             {
                                 for (tsunami_lab::t_idx x = 0; x < l_ncellsX; x++)
                                 {
-                                    l_data.push_back(l_heightData[x + l_waveprop->getStride() * y] + l_bathymetryData[x + l_waveprop->getStride() * y]);
+                                    l_data.push_back(l_heightData[x + l_waveprop->getStride() * y]);
                                 }
                             }
                         }
                         l_heightDataMsg.args = l_data;
                         l_communicator.sendToClient(xlpmg::messageToJsonString(l_heightDataMsg));
+                        
                     }
                     else if (l_key == xlpmg::GET_BATHYMETRY_DATA.key)
                     {
@@ -513,8 +515,6 @@ int main(int i_argc, char *i_argv[])
         {
             m_updateThread.join();
         }
-        std::remove(m_bathTempFile.c_str());
-        std::remove(m_displTempFile.c_str());
     }
     //------------------------------------------//
     //--------------STANDARD MODE---------------//