RPCEventBuilder.cc

Go to the documentation of this file.

#include "RPCEventBuilder.h"
using namespace RPCEventBuilderLX;

#include <evt/Event.h>
using namespace evt;

#include <fwk/RunController.h>
using namespace fwk;

#include <cevt/CEvent.h>
#include <cevt/Station.h>
#include <cevt/Pad.h>
#include <cevt/PadRecData.h>
#include <cevt/PadSimData.h>
#include <cevt/StationSimData.h>
#include <cevt/StationRecData.h>
using namespace cevt;

#include <utl/config.h>
#include <utl/TimeStamp.h>
#include <utl/ErrorLogger.h>
#include <utl/MultiTimeDistribution.h>
#include <utl/TimeDistributionAlgorithm.h>
#include <utl/Accumulator.h>
using namespace utl;

#include <sstream>
 
using namespace std;

RPCEventBuilder::RPCEventBuilder() 
{;}

RPCEventBuilder::~RPCEventBuilder() 
{;}

VModule::ResultFlag RPCEventBuilder::Init(void) 
{
  INFO("RPCEventBuilder::Init()");
  return eSuccess;
}


VModule::ResultFlag RPCEventBuilder::Finish(void) 
{
  INFO("RPCEventBuilder::Finish()");
  return eSuccess;
}


VModule::ResultFlag RPCEventBuilder::Run(Event &event){

  INFO("RPCEventBuilder::Run()");

  if (!event.HasCEvent()) {
    ERROR("No CEvent found.");
    return eFailure;  
  }

  CEvent &rpcEvent = event.GetCEvent();

  // Loop over MARTA stations
  for (CEvent::StationIterator sIt = rpcEvent.StationsBegin();
       sIt != rpcEvent.StationsEnd(); ++sIt) {

    Station & station = *sIt;
    station.ClearHits();
    const int sId = station.GetId();

    if (!station.HasSimData()) {
      ostringstream info;
      info << "station " << sId << " does not have RPC sim data";
      INFO(info);
      continue;
    }

    // Station trigger time is defined as (cf. TankTriggerSimulatorOG) 
    // const TimeStamp triggerTime =
    // eventTime + TimeInterval(stop * sdet::Station::GetFADCBinSize()), 
    // For the momment the Pad signals are refered to the event time, 
    // the time of the core impact at ground. 
    // This is the reference time in the simulation that best resembles a GPS time stamp.

    // Find time of first hit in station        
      
    Accumulator::Safe<Accumulator::Min<double> > minTime;
    for(Station::ConstPadIterator pIt = station.PadsBegin(); 
        pIt != station.PadsEnd(); ++pIt) {
      
      const PadSimData& padSim = pIt->GetSimData();
      
      if (padSim.HasHitsTimeDistribution()) {    

        const TimeDistributionI& simDigits = padSim.GetHitsTimeDistribution();
        minTime(simDigits.GetStart()*simDigits.GetBinning());
      }
    }
      
    const double stationT0 = minTime.GetMin(); 
    
    // Loop over pads with signal for this station
    for(Station::PadIterator pIt = station.PadsBegin(); 
        pIt != station.PadsEnd(); ++pIt) {

      Pad & pad = *pIt;
      
      pad.ClearHits();
      const PadSimData& padSimData = pad.GetSimData();

      // Loop over components of the hitsized signal time distribution
      
      for (PadSimData::ConstHitsTimeDistributionsIterator tIt =
             padSimData.HitsTimeDistributionsBegin(); 
           tIt != padSimData.HitsTimeDistributionsEnd(); ++tIt) {
        
        const Station::SignalComponent component = 
          static_cast<Station::SignalComponent>(tIt->GetLabel());

        if (!pad.HasHits(component))
          pad.MakeHits(component);

        if (!station.HasHits(component))
          station.MakeHits(component);

        const TimeDistributionI & simDigitTimeDist = tIt->GetTimeDistribution();        

        TimeDistributionI & padHits = pad.GetHits(component);
        TimeDistributionI & stationHits = station.GetHits(component);

        const double timeBin = simDigitTimeDist.GetBinning();

        for (TimeDistributionI::SparseIterator it = simDigitTimeDist.SparseBegin();
             it != simDigitTimeDist.SparseEnd(); ++it) {

          padHits.AddTime(it->get<0>()*timeBin-stationT0,it->get<1>());
          stationHits.AddTime(it->get<0>()*timeBin-stationT0,it->get<1>());
        }       
      }
    
    } // end loop over pads 

    if (station.HasHits()) 
      station.SetHitsStartTime(event.GetHeader().GetTime()+TimeInterval(stationT0));
    else
      station.SetHitsStartTime(TimeStamp(0));

  } // end loop over stations

  return eSuccess;
}