AcousticDataFilter.h

Go to the documentation of this file.

#ifndef ACOUSTICDATAFILTER_H_
#define ACOUSTICDATAFILTER_H_
 
#include <string>
#include <sstream>
#include <iostream>
#include <ctime>
#include <unistd.h>
#include <stdio.h>
 
#include <vector>
#include <map>
 
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/atomic.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/thread/thread.hpp>
 
#include <boost/algorithm/string/trim.hpp>
 
#include <JRuncontrol/JDAQClient.hh>
#include <JLogger/JControlHostLogger.hh>
#include <JLogger/JMessageLogger.hh>
#include <JDAQ/JDAQTags.hh>
 
#include "toalib/km3_toa_lib.hpp"
#include "Tools/KM3NeT_Acoustic_Link.h"
#include "Tools/KM3NeT_DOM.h"
 
#define SERVER_THREAD_POOL 2
#define TRIGGER_THREAD_POOL 8
#define MAX_TOA_SIZE    1048576
 
 
/**
 * \author fsimeone
 */
 
typedef std::pair<std::size_t,pProbe>                                   probe_entry;
typedef std::pair<std::size_t,pDOM>                                     dom_entry;
 
//#define DEBUG_ACOUSTICDATAFILTER
 
class AcousticDataFilter : public KM3NETDAQ::JDAQClient
{
public:
        static const int DEBUG_LEVEL=1;
 
                                                                                        AcousticDataFilter(     const std::string& address,\
                                                                                                                                const std::string& port,\
                                                                                                                                const std::string& name,\
                                                                                                                const std::string& server,\
                                                                                                                                const std::string& wisdom,\
                                                                                                                                const std::string& output,\
                                                                                                                                const std::string& raw,\
                                                                                                                JLOGGER::JLogger*           logger,\
                                                                                                                const int          level);
        virtual                                                                 ~AcousticDataFilter();
        
        void                                                                    Send_toa_async(ToA_Packet packet){strand_.post(boost::bind(&AcousticDataFilter::Send_toa,this,packet));};
 
        virtual void                                                    actionEnter()                                                                           {};
        virtual void                                                    actionExit()                                                                            {exit_=true;};
        virtual void                                                    actionInit(int length, const char* buffer);
        virtual void                                                    actionConfigure(int length, const char* buffer);
        virtual void                                                    actionStart(int length, const char* buffer);
        virtual void                                                    actionPause(int length, const char* buffer);
        virtual void                                                    actionContinue(int length, const char* buffer); 
        virtual void                                                    actionStop(int length, const char* buffer);
        virtual void                                                    actionReset(int length, const char* buffer);
        virtual void                                                    actionQuit(int length, const char* buffer);
        //virtual void                                                  actionInput(int length, const char* buffer)                     {};
        virtual void                                                    actionRunning()                                                                         {};
 
        
private:
        const JNET::JTag &                                              clientTag() const { return KM3NETDAQ::RC_AFILTER; };
        
        void                                                                    Create_probes(std::vector<std::string> probes,std::size_t window);
        void                                                                    Create_DOMs(std::vector<std::string> doms,std::string& debug_file_path,std::size_t window,std::size_t overlap);
        void                                                                    Start_accept();
        void                                                                    Accept_completed(pLink link, const boost::system::error_code& error);
        void                                                                    Start();
        void                                                                    Stop();
        void                                                                    Open_toa_file();
        void                                                                    Send_toa(ToA_Packet packet);
 
        boost::atomic<bool>                                     exit_;
        boost::atomic<bool>                                     running_;
        std::string                                                     address_;
        std::string                                                     port_;
        
        std::map<std::size_t,pProbe>                    probes_;                                 
        std::map<std::size_t,pDOM>                              doms_;                                  
        std::vector<pLink>                                              links_;                         
        
        boost::thread_group                                     server_threads_;
        boost::asio::io_service                                 server_io_service_;
        boost::asio::io_service::work*                  server_work_;
        boost::asio::ip::tcp::acceptor                  server_acceptor_;
        boost::thread_group                                     trigger_threads_;
        boost::asio::io_service                                 trigger_io_service_;
        boost::asio::io_service::work*                  trigger_work_;
        boost::asio::io_service::strand                 strand_;
 
    std::string                             debug_file_path_;
        std::string                                                             toa_file_path_; 
        std::ofstream                                                   toa_file_;
        std::string                                                             wisdom_file_;
};
 
#endif /* ACOUSTICDATAFILTER_H_ */