KM3NeT_Audio_Channel.cc

Go to the documentation of this file.

#include "KM3NeT_Audio_Channel.h"
/**
 * \author fsimeone
 */
 
 
#ifdef DEBUG_KM3NET_AUDIO_CHANNEL
#include <stdlib.h>
#include <iostream>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <Tools/KM3NeT_Debug.h>
#define DEBUG_MSG(str,lev) do { if (((uint8_t)lev)>=KM3NeT_Audio_Channel::DEBUG_LEVEL) { DBG_MSG << boost::posix_time::microsec_clock::local_time() << " DEBUG_KM3NET_AUDIO_CHANNEL(" << (void*)this << "): "<< str << '\n'; } }while( false )
#else
#define DEBUG_MSG(str,lev) do { } while ( false )
#endif
 
KM3NeT_Audio_Channel::KM3NeT_Audio_Channel(     boost::asio::io_service& io_service,\
                                                                                        callback_send_toa callback,\
                                                                                        uint32_t id,\
                                                                                        std::string& debug_path,\
                                                                                        uint32_t window,\
                                                                                        uint32_t overlap\
                                                                                        ):      strand_(io_service),\
                                                                                                finder_(window),\
                                                                                                data_(window,overlap)
{
        DEBUG_MSG("Constructor",0);
        id_=id;
        send_toa_=callback;
        test_=0;
        overlap_=overlap;
        test_file_=0;
        debug_files_path_=debug_path;
}
 
KM3NeT_Audio_Channel::~KM3NeT_Audio_Channel()
{
        DEBUG_MSG("Destructor",0);
        if ((test_)&&(test_file_)) std::fclose(test_file_);
}
 
void KM3NeT_Audio_Channel::Add_probe(pProbe probe, std::size_t id, std::size_t threshold)
{
    thresholds_.insert(threshold_entry(id,threshold));
    probes_id_.push_back(id);
        finder_.addProbeSignal(probe);
}
 
void KM3NeT_Audio_Channel::Append(real_type sample)
{
        if(data_.Append(sample))
        {
                ToA_Packet l_toa;
                l_toa.Time.Channel=1;
                real_type* buffer=data_.Get_window(&l_toa);
                strand_.post(boost::bind(&KM3NeT_Audio_Channel::Analysis,this,l_toa,buffer,data_.Get_size()));
        }
}
 
void KM3NeT_Audio_Channel::Analysis(ToA_Packet packet,real_type* buffer,uint32_t length)
{
        DEBUG_MSG("Analysis",2);
        if (test_)
        {
                if (!test_file_) Open_test_file(packet.Header.DOM_Identifier,packet.Time.Channel);
 
                if (std::ftell(test_file_)>MAX_DUMP_SIZE)
                {
                        DEBUG_MSG("Test file DOM="<<packet.Header.DOM_Identifier<<" ch="<<packet.Time.Channel<<" closed",2);
                        std::fclose(test_file_);
                        Open_test_file(packet.Header.DOM_Identifier,packet.Time.Channel);
                }
 
                if (test_file_) 
                {
                        std::fwrite( (char*) &packet.Header.Time_Stamp_seconds, sizeof(uint32_t), 1, test_file_);
                        std::fwrite( (char*) &packet.Header.Time_Stamp_ticks, sizeof(uint32_t), 1, test_file_);
                        std::fwrite( (char*) &length, sizeof(uint32_t), 1, test_file_);
                        std::fwrite( ((char*)buffer)+sizeof(real_type)*overlap_,sizeof(real_type), length-overlap_, test_file_);
                }
        }
        std::vector<KM3::TOALIB::CTOAInfo> toaList;
        finder_.copyFromBuffer(buffer,length);
        finder_.findTOAs(toaList);
        free(buffer);
 
        packet.Header.Number_of_Items=1;
        packet.Header.Frame_Length=sizeof(ToA_Packet);
        
        packet.Header.Detector_Identifier=htonl(packet.Header.Detector_Identifier);
        packet.Header.DOM_Identifier=htonl(packet.Header.DOM_Identifier);
        packet.Header.DQ_Status=htonl(packet.Header.DQ_Status);
        packet.Header.DOM_Status1=htonl(packet.Header.DOM_Status1);
        packet.Header.DOM_Status2=htonl(packet.Header.DOM_Status2);
        packet.Header.DOM_Status3=htonl(packet.Header.DOM_Status3);
        packet.Header.DOM_Status4=htonl(packet.Header.DOM_Status4);
        packet.Header.Data_Type=htonl(packet.Header.Data_Type);
        packet.Header.Frame_Length=htonl(packet.Header.Frame_Length);
        packet.Header.Number_of_Items=htonl(packet.Header.Number_of_Items);
        packet.Header.Run_Number=htonl(packet.Header.Run_Number);
        packet.Header.Sequence_Number=htonl(packet.Header.Sequence_Number);
        packet.Header.Time_Stamp_seconds=htonl(packet.Header.Time_Stamp_seconds);
        packet.Header.Time_Stamp_ticks=htonl(packet.Header.Time_Stamp_ticks);
 
        double sampling=128./packet.Time.Sampling_Rate;
        for (uint8_t i=0; i<toaList.size(); i++)
        {
                ToA_Packet l_toa;
                l_toa=packet;
                l_toa.Time.Reserved=0;
 
                if (toaList[i].getGoodness()>=thresholds_.find(probes_id_[i])->second)
                {
                        l_toa.Time.Emitter_ID=probes_id_[i];
                        l_toa.Time.Quality_Factor=toaList[i].getGoodness();
                        l_toa.Time.ToA+=sampling * toaList[i].getTime();
 
                        l_toa.Time.Emitter_ID=htonl(l_toa.Time.Emitter_ID);
                        l_toa.Time.Quality_Factor=htonl(l_toa.Time.Quality_Factor);
                        l_toa.Time.ToA=htonl(l_toa.Time.ToA);
 
                        send_toa_(l_toa);
                }
        }
}
 
void KM3NeT_Audio_Channel::Open_test_file(uint32_t id,uint8_t ch)
{
        std::string l_file=debug_files_path_;
        std::time_t seconds = std::time(0);
        l_file+="DOM_"+std::to_string((long long unsigned int)id)+"_CH"+std::to_string((long long unsigned int)ch)+"_"+std::to_string((long long unsigned int)seconds)+".bin";
        test_file_= std::fopen(l_file.c_str(),"wb");
    DEBUG_MSG("Test file opened at "<<seconds,2);
}