TESDemoUse.cpp

Go to the documentation of this file.

#include "DataUtilities/DybArchiveList.h"

#include "src/TESDemoUse.h"

#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"

#include "Event/TESDemoPositron.h"
#include "Event/TESDemoNeutron.h"
#include "Event/TESDemoAntiNeutrino.h"

using namespace DayaBay;

TESDemoUse::TESDemoUse( const std::string& name, 
                        ISvcLocator* pSvcLocator ) :
  GaudiAlgorithm(name,
                 pSvcLocator)
{
   declareProperty("PositronPath",
                   m_positronPath="/Event/TESDemo/Positron",
                   "Path from which to retrieve the Positron candidates");
   declareProperty("NeutronPath",
                   m_neutronPath="/Event/TESDemo/Neutron",
                   "Path from which to retrieve the Neutron candidates");
   declareProperty("AntiNeutrinoPath",
                   m_antiNeutrinoPath="/Event/TESDemo/Anti-Neutrino",
                   "Path, in the TES, into which the Anti-Neutrinos are stored");
   declareProperty("TimeWindow",
                   m_window=0.00005,
                   "The maximum time between Neutron and Positrion");
}

StatusCode TESDemoUse::initialize() {

   info() << "in initialize" 
          << endreq;
   info() << m_positronPath 
          << endreq;
   info() << m_neutronPath 
          << endreq;
   info() << m_antiNeutrinoPath 
          << endreq;

   StatusCode status = service("EventDataArchiveSvc",
                               p_archiveSvc);
   if (status.isFailure()) {
     Error("Service [EventDataArchiveSvc] not found",
           status);
   }

   return StatusCode::SUCCESS;

}

StatusCode TESDemoUse::execute() {

  SmartDataPtr<TESDemoNeutron>  neutron(eventSvc(),
                                        m_neutronPath.value());
  if (0 == neutron) {
    return Print("No Neutron in this readout");
  }

  SmartDataPtr<DybArchiveList>  positrons(p_archiveSvc,
                                          m_positronPath.value());
  if (0 == positrons) {
    return Print("No Positrons have been found so far");
  }

  if (positrons->empty()) {
    return Print("No Positrons are currently available");
  }

  TESDemoAntiNeutrino::Container* antiNeutrinos = 0;
  bool searching = true;
  DybArchiveList::const_iterator finished = positrons->end();
  DybArchiveList::const_iterator iter = positrons->begin();
  while (searching &&
         finished != iter ) {
    
    TESDemoPositron* positron = dynamic_cast<TESDemoPositron*>(*iter);
    if (0 == positron) {
      return Error("Positron archive does not contain correct type");
    }

    double deltaTime = neutron->timeStamp().GetSeconds()
      -  positron->timeStamp().GetSeconds();
    if (m_window.value() < deltaTime) {
      searching = false;
    } else {
      TESDemoAntiNeutrino* antiNeutrino =
        new TESDemoAntiNeutrino(positron,
                                neutron);

      if (0 == antiNeutrinos) {
        antiNeutrinos = new TESDemoAntiNeutrino::Container();
      }
      antiNeutrinos->add(antiNeutrino);
      
      int positronId = positron->readout()->identifier();
      int neutronId = neutron->readout()->identifier();
      info() << "Stored one anti-neutrino built from readouts "
             << positronId
             << " and "
             << neutronId
             << endreq;
    }
    iter++;
  }

  if (0 == antiNeutrinos) {
    info() << "No Anti-Neutrino candidates found"
           << endreq;
    return StatusCode::SUCCESS;
  } else {
    info() << "Time span of anti-neutrinos is:" << endreq;
    info() << "    From: " << antiNeutrinos->earliest() << endreq;
    info() << "      To: " << antiNeutrinos->latest() << endreq;

    if (eventSvc()->registerObject(m_antiNeutrinoPath.value(),
                                   antiNeutrinos).isFailure()) {
      return Error("Failed to store anti-neutrinos in Event Store");
    }
  }

  return StatusCode::SUCCESS;
}

StatusCode TESDemoUse::finalize() {

  info() << "in finalize"
         << endreq;

  if (0 != p_archiveSvc) {
    p_archiveSvc->release();
  }

  return StatusCode::SUCCESS;

}