LEMClient_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    LEMClient_module.cc
// \brief   Fetch LEM PID result from remote server
// \author  Christopher Backhouse - bckhouse@caltech.edu
////////////////////////////////////////////////////////////////////////

// NOvASoft includes
#include "RecoBase/Cluster.h"
#include "Utilities/AssociationUtil.h"

// Framework includes
#include "art/Framework/Core/EDProducer.h"
#include "canvas/Persistency/Common/FindManyP.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "fhiclcpp/ParameterSet.h"

#include "LEM/LEMInput.h"
#include "LEM/PIDDetails.h"

#include "LEM/LEMWebSettings.h"
#include "LEM/WebUtils.h"

#include <cfloat>
#include <iostream>

#include <curl/curl.h>

namespace
{
  struct LEMClientParams
  {
    template<class T> using Atom = fhicl::Atom<T>;
    template<class T> using Table = fhicl::Table<T>;
    using Comment = fhicl::Comment;
    using Name = fhicl::Name;

    Atom<std::string> inputLabel{
      Name("InputLabel"),
      Comment("Where to find LEMInput objects")
    };

    Atom<std::string> releaseOverride{
      Name("ReleaseOverride"),
      Comment("Specify this release to the server. Empty string for current release.")
    };

    Table<lem::LEMWebSettings> web{Name("WebSettings")};
  };
}

namespace lem
{
  /// Fetch LEM PID result from remote server
  class LEMClient: public art::EDProducer
  {
  public:
    // Allows 'nova --print-description' to work
    using Parameters = art::EDProducer::Table<LEMClientParams>;

    explicit LEMClient(const Parameters& params);
    ~LEMClient();

    virtual void beginJob();
    virtual void produce(art::Event& evt);

  protected:
    LEMClientParams fParams;

    std::string fClientID;
  };

  //......................................................................
  LEMClient::LEMClient(const Parameters& params)
    : fParams(params())
  {
    produces<std::vector<lem::PIDDetails>>();
    produces<art::Assns<lem::PIDDetails, rb::Cluster>>();

    // Generate a unique ID so that the server can identify us.
    char host[1024];
    gethostname(host, 1023);
    host[1023] = 0;
    const char* user = getenv("USER");
    if(!user) user = "(unknown)";
    fClientID = TString::Format("%s@%s.%d.%ld",
                                user, host, getpid(), time(0)).Data();

    curl_global_init(CURL_GLOBAL_ALL);
  }

  //......................................................................
  LEMClient::~LEMClient()
  {
    curl_global_cleanup();
  }

  //......................................................................
  void LEMClient::beginJob()
  {
    // Randomize ports and so on properly
    srand(getpid());
  }

  //......................................................................
  void LEMClient::produce(art::Event& evt)
  {
    std::unique_ptr<std::vector<lem::PIDDetails> > pidcol(new std::vector<lem::PIDDetails>);
    std::unique_ptr<art::Assns<lem::PIDDetails, rb::Cluster>> assns(new art::Assns<lem::PIDDetails, rb::Cluster>);

    const std::string rel = fParams.releaseOverride().empty() ? get_release() : fParams.releaseOverride();

    const LEMWebSettings& web = fParams.web();

    const std::string args = TString::Format("rel=%s&id=%s&timeout=%d",
                                             rel.c_str(),
                                             fClientID.c_str(),
                                             web.queryTimeout()).Data();

    art::Handle<std::vector<LEMInput>> inputs;
    evt.getByLabel(fParams.inputLabel(), inputs);
    art::FindManyP<rb::Cluster> fmt(inputs, evt, fParams.inputLabel());

    const int inputMax = inputs->size();
    for(int inputIdx = 0; inputIdx < inputMax; ++inputIdx){
      const LEMInput& input = (*inputs)[inputIdx];

      // DBL_DIG of precision guarantee the number roundtrips safely
      std::string postdata = TString::Format("E=%.*g\n",
                                             DBL_DIG, input.totalGeV).Data();
      for(const LiteHit& hit: input.hits){
        postdata += TString::Format("%d %.*g\n",
                                    hit.cellIdx, DBL_DIG, hit.pecorr).Data();
      }

      bool ok;
      const std::string response = post_query(web.host(),
                                              "pid?"+args,
                                              postdata,
                                              web.minPort(),
                                              web.maxPort(),
                                              web.queryTimeout(),
                                              web.retryTimeout(),
                                              ok);
      if(!ok){
        std::cerr << "No response from server after many retries. Aborting"
                  << std::endl;
        abort();
      }

      pidcol->push_back(PIDDetails::FromString(response));

      // Get all the slices associated with this match list
      const std::vector<art::Ptr<rb::Cluster> > slices = fmt.at(inputIdx);
      assert(slices.size() == 1);
      util::CreateAssn(*this, evt, *pidcol, slices[0], *assns);
    }

    evt.put(std::move(pidcol));
    evt.put(std::move(assns));
  }

  DEFINE_ART_MODULE(LEMClient)

} //namespace lem
////////////////////////////////////////////////////////////////////////