RdDummyStationToChannelConverter.cc

Go to the documentation of this file.

#include "RdDummyStationToChannelConverter.h"

#include <fwk/CentralConfig.h>

#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/config.h>
#include <utl/TraceAlgorithm.h>

#include <evt/Event.h>
#include <revt/REvent.h>
#include <revt/Station.h>
#include <revt/Channel.h>
#include <rdet/RDetector.h>
#include <rdet/Channel.h>


using namespace revt;
using namespace fwk;
using namespace utl;
using namespace std;

namespace RdDummyStationToChannelConverter {

  RdDummyStationToChannelConverter::RdDummyStationToChannelConverter()
  {
  }


  RdDummyStationToChannelConverter::~RdDummyStationToChannelConverter()
  {
  }


  VModule::ResultFlag
  RdDummyStationToChannelConverter::Init()
  {
    // Initialize your module here. This method
    // is called once at the beginning of the run.
    // The eSuccess flag indicates the method ended
    // successfully.  For other possible return types,
    // see the VModule documentation.

    INFO("RdDummyStationToChannelConverter::Init()");


    return eSuccess;
  }


  VModule::ResultFlag
  RdDummyStationToChannelConverter::Run(evt::Event& event)
  {
    // Check if there are events at all
    if(!event.HasREvent()) {
      WARNING("No radio event found!");
      return eContinueLoop;
    }

    REvent& rEvent = event.GetREvent();

    // loop through stations and for every station through every channel
    for (REvent::StationIterator sIt = rEvent.StationsBegin();
         sIt != rEvent.StationsEnd(); ++sIt) {
      Station& station = *sIt;
//    stringstream fMessage;
      const revt::StationTimeSeries& stationtrace =
        station.GetStationTimeSeries();

      for (Station::ChannelIterator cIt = station.ChannelsBegin();
           cIt != station.ChannelsEnd(); ++cIt) {
        Channel& channel = *cIt;
/*      fMessage.str("");
        fMessage << "Copying channel "
                 << channel.GetId()
                 << " over from the StationTimeSeries of station "
                 << channel.GetStationId()
                 << ".";
        INFO(fMessage.str()); */

        // Work on the trace of this channel
        revt::ChannelTimeSeries& channeltrace =
          channel.GetChannelTimeSeries();

        // first clear the trace
        channeltrace.Clear();
        channeltrace.SetBinning(stationtrace.GetBinning());
        channel.SetNyquistZone(station.GetNyquistZone());

        const rdet::RDetector& rDetector =
          det::Detector::GetInstance().GetRDetector();
        const rdet::Channel& detChannel =
          rDetector.GetStation(station.GetId()).GetChannel(channel.GetId());
        double orientAzimuth = detChannel.GetOrientationAzimuth();
        double orientZenith = detChannel.GetOrientationZenith();

        if (orientAzimuth < 0 && orientAzimuth > -360 * deg)
          orientAzimuth += 360 * deg;

        // Doing some kind of dodgy association of the channels to the coordinates
        // The design-decision is that this module is only for testing purposes so
        // a proper coordinate transformation is not done here.
        stringstream fMessage;
        fMessage.str("");
        double alignMargin = 5*deg;
        if ( orientZenith > alignMargin ) {
          fMessage << "Encountering a channel that seems to be vertically aligned, not converting.";
          WARNING(fMessage.str());
          continue;
        }

        double correspondingCoordinate; // Will always be initialized or ignored in the code below
        double correspondingSign; // Will always be initialized or ignored in the code below
        fMessage.str("");
        fMessage << "Associating channel " << channel.GetId() << " for station " << station.GetId() << " at " <<
          orientAzimuth/deg << " deg azimuthal angle";
        if ( orientAzimuth < alignMargin or orientAzimuth > 360 * deg - alignMargin ) {
          fMessage << "with a positive x coordinate.";
          INFO(fMessage.str());
          correspondingCoordinate = 0;
          correspondingSign = 1;
        } else if ( orientAzimuth > 90 * deg - alignMargin or orientAzimuth < 90 * deg + alignMargin ) {
          fMessage << " with a positive y coordinate.";
          INFO(fMessage.str());
          correspondingCoordinate = 1;
          correspondingSign = 1;
        } else if ( orientAzimuth > 180 * deg - alignMargin or orientAzimuth < 180 * deg + alignMargin ) {
          fMessage << " with a negative x coordinate.";
          INFO(fMessage.str());
          correspondingCoordinate = 0;
          correspondingSign = -1;
        } else if ( orientAzimuth > 270 * deg - alignMargin or orientAzimuth < 270 * deg + alignMargin ) {
          fMessage << " with a negative y coordinate.";
          INFO(fMessage.str());
          correspondingCoordinate = 1;
          correspondingSign = -1;
        } else {
          fMessage.str("");
          fMessage << "No good dodgy conversion possible because the antenna does not seem to be aligned with " <<
            "any spatial coordinate within " << alignMargin/deg << "deg.";
          WARNING(fMessage.str());
          continue;
        }
        for (StationTimeSeries::SizeType i=0; i<stationtrace.GetSize(); ++i) {
          channeltrace.PushBack(stationtrace[i][correspondingCoordinate]*correspondingSign);
        }
      }
    }

    return eSuccess;
  }


  VModule::ResultFlag
  RdDummyStationToChannelConverter::Finish()
  {
    // Put any termination or cleanup code here.
    // This method is called once at the end of the run.

    INFO("RdDummyStationToChannelConverter::Finish()");

    return eSuccess;
  }

}