AMCDumpToRaw.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    EventFilter/L1TRawToDigi
// Class:      AMCDumpToRaw
//
//
// Original Author:  James Brooke
//         Created:  Tue, 11 Mar 2014 14:55:45 GMT
//
//
 
// system include files
#include <memory>
 
// user include files
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
 
#include "DataFormats/FEDRawData/interface/FEDRawData.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"
 
#include "FWCore/Utilities/interface/CRC16.h"
 
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <iomanip>
#include <boost/algorithm/string.hpp>
 
#include "EventFilter/L1TRawToDigi/interface/AMC13Spec.h"
 
namespace l1t {
 
  class AMCDumpToRaw : public edm::EDProducer {
  public:
    explicit AMCDumpToRaw(const edm::ParameterSet&);
    ~AMCDumpToRaw() override;
 
    static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
  private:
    void beginJob() override;
    void produce(edm::Event&, const edm::EventSetup&) override;
    void endJob() override;
 
    void readEvent(std::vector<uint32_t>& load32);
 
    void formatAMC(amc13::Packet& amc13, const std::vector<uint32_t>& load32);
 
    void formatRaw(edm::Event& iEvent, amc13::Packet& amc13, FEDRawData& fed_data);
 
    //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;
    //virtual void endRun(edm::Run const&, edm::EventSetup const&) override;
    //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
    //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
 
    // ----------member data ---------------------------
    std::ifstream file_;
    std::string filename_;
 
    // DAQ params
    int fedId_;
    int iAmc_;
    int boardId_;
    int evType_;
    int fwVer_;
    int slinkHeaderSize_;  // in 8-bit words
    int slinkTrailerSize_;
  };
 
  //
  // constants, enums and typedefs
  //
 
  //
  // static data member definitions
  //
 
  //
  // constructors and destructor
  //
  AMCDumpToRaw::AMCDumpToRaw(const edm::ParameterSet& iConfig)
      : filename_(iConfig.getUntrackedParameter<std::string>("filename", "data.txt")),
        fedId_(iConfig.getUntrackedParameter<int>("fedId", 1)),
        iAmc_(iConfig.getUntrackedParameter<int>("iAmc", 1)),
        boardId_(iConfig.getUntrackedParameter<int>("boardId", 1)),
        evType_(iConfig.getUntrackedParameter<int>("eventType", 1)),
        fwVer_(iConfig.getUntrackedParameter<int>("fwVersion", 1)),
        slinkHeaderSize_(iConfig.getUntrackedParameter<int>("lenSlinkHeader", 8)),
        slinkTrailerSize_(iConfig.getUntrackedParameter<int>("lenSlinkTrailer", 8)) {
    produces<FEDRawDataCollection>();
  }
 
  AMCDumpToRaw::~AMCDumpToRaw() {
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
  }
 
  //
  // member functions
  //
 
  // ------------ method called for each event  ------------
  void AMCDumpToRaw::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
    using namespace edm;
 
    // create AMC 13 packet
    amc13::Packet amc13;
 
    std::vector<uint32_t> load32;
 
    readEvent(load32);
 
    formatAMC(amc13, load32);
 
    LogDebug("L1T") << "AMC13 size " << amc13.size();
 
    // prepare the raw data collection
    std::unique_ptr<FEDRawDataCollection> raw_coll(new FEDRawDataCollection());
    FEDRawData& fed_data = raw_coll->FEDData(fedId_);
 
    formatRaw(iEvent, amc13, fed_data);
 
    LogDebug("L1T") << "Packing FED ID " << fedId_ << " size " << fed_data.size();
 
    // put the collection in the event
    iEvent.put(std::move(raw_coll));
  }
 
  void AMCDumpToRaw::readEvent(std::vector<uint32_t>& load32) {
    // read file
    std::string line;
 
    // while not encountering dumb errors
    while (getline(file_, line) && !line.empty()) {
      std::istringstream iss(line);
      unsigned long d;
      iss >> std::hex >> d;
 
      load32.push_back(d);
    }
  }
 
  void AMCDumpToRaw::formatAMC(amc13::Packet& amc13, const std::vector<uint32_t>& load32) {
    // TODO this is an empty word to be replaced with a proper MP7
    // header containing at least the firmware version
 
    std::vector<uint64_t> load64;
    for (unsigned int i = 0; i < load32.size(); i += 2) {
      uint64_t word = load32[i];
      if (i + 1 < load32.size())
        word |= static_cast<uint64_t>(load32[i + 1]) << 32;
      load64.push_back(word);
    }
 
    LogDebug("L1T") << "Creating AMC packet " << iAmc_;
 
    amc13.add(iAmc_, boardId_, 0, 0, 0, load64);
  }
 
  void AMCDumpToRaw::formatRaw(edm::Event& iEvent, amc13::Packet& amc13, FEDRawData& fed_data) {
    unsigned int size = slinkHeaderSize_ + slinkTrailerSize_ + amc13.size() * 8;
    fed_data.resize(size);
    unsigned char* payload = fed_data.data();
    unsigned char* payload_start = payload;
 
    auto bxId = iEvent.bunchCrossing();
    auto evtId = iEvent.id().event();
 
    LogDebug("L1T") << "Creating FEDRawData ID " << fedId_ << ", size " << size;
 
    FEDHeader header(payload);
    header.set(payload, evType_, evtId, bxId, fedId_);
 
    amc13.write(iEvent, payload, slinkHeaderSize_, size - slinkHeaderSize_ - slinkTrailerSize_);
 
    payload += slinkHeaderSize_;
    payload += amc13.size() * 8;
 
    FEDTrailer trailer(payload);
    trailer.set(payload, size / 8, evf::compute_crc(payload_start, size), 0, 0);
  }
 
  // ------------ method called once each job just before starting event loop  ------------
  void AMCDumpToRaw::beginJob() {
    // open VME file
    file_.open(filename_.c_str(), std::ios::in);
    if (!file_.good()) {
      edm::LogInfo("TextToDigi") << "Failed to open ASCII file " << filename_ << std::endl;
    }
  }
 
  // ------------ method called once each job just after ending the event loop  ------------
  void AMCDumpToRaw::endJob() { file_.close(); }
 
  // ------------ method called when starting to processes a run  ------------
  /*
void 
AMCDumpToRaw::beginRun(edm::Run const&, edm::EventSetup const&)
{
}
*/
 
  // ------------ method called when ending the processing of a run  ------------
  /*
void 
AMCDumpToRaw::endRun(edm::Run const&, edm::EventSetup const&)
{
}
*/
 
  // ------------ method called when starting to processes a luminosity block  ------------
  /*
vvoid 
AMCDumpToRaw::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
{
}
*/
 
  // ------------ method called when ending the processing of a luminosity block  ------------
  /*
void 
AMCDumpToRaw::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
{
}
*/
 
  // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
  void AMCDumpToRaw::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
    //The following says we do not know what parameters are allowed so do no validation
    // Please change this to state exactly what you do use, even if it is no parameters
    edm::ParameterSetDescription desc;
    desc.setUnknown();
    descriptions.addDefault(desc);
  }
 
}  // namespace l1t
 
using namespace l1t;
//define this as a plug-in
DEFINE_FWK_MODULE(AMCDumpToRaw);