L1TDigiToRaw.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    EventFilter/L1TRawToDigi
// Class:      L1TDigiToRaw
// 
//
// Original Author:  Matthias Wolf
//         Created:  Mon, 10 Feb 2014 14:29:40 GMT
//
//

// system include files
#include <iomanip>
#include <memory>

#define EDM_ML_DEBUG 1

// user include files
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"

#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Utilities/interface/CRC16.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "FWCore/Utilities/interface/InputTag.h"

#include "EventFilter/L1TRawToDigi/interface/AMC13Spec.h"

#include "PackingSetupFactory.h"

namespace l1t {
   class L1TDigiToRaw : public edm::stream::EDProducer<> {
      public:
         explicit L1TDigiToRaw(const edm::ParameterSet&);
         ~L1TDigiToRaw() override;

         static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);

         using edm::stream::EDProducer<>::consumes;

      private:
         void produce(edm::Event&, const edm::EventSetup&) override;

         void beginRun(edm::Run const&, edm::EventSetup const&) override {};
         void endRun(edm::Run const&, edm::EventSetup const&) override {};
         void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override {};
         void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override {};

         // ----------member data ---------------------------
         int evtType_;
         int fedId_;
         unsigned fwId_;

         // header and trailer sizes in chars
         int slinkHeaderSize_;
         int slinkTrailerSize_;

         std::unique_ptr<PackingSetup> setup_;
         std::unique_ptr<PackerTokens> tokens_;

         bool ctp7_mode_;
   };
}

namespace l1t {
   L1TDigiToRaw::L1TDigiToRaw(const edm::ParameterSet& config) :
      fedId_(config.getParameter<int>("FedId")),
      ctp7_mode_(config.getUntrackedParameter<bool>("CTP7"))
   {
      // Register products
      produces<FEDRawDataCollection>();

      fwId_ = config.getParameter<unsigned int>("FWId");
      evtType_ = config.getUntrackedParameter<int>("eventType", 1);

      auto cc = edm::ConsumesCollector(consumesCollector());

      setup_ = PackingSetupFactory::get()->make(config.getParameter<std::string>("Setup"));
      tokens_ = setup_->registerConsumes(config, cc);

      slinkHeaderSize_ = config.getUntrackedParameter<int>("lenSlinkHeader", 8);
      slinkTrailerSize_ = config.getUntrackedParameter<int>("lenSlinkTrailer", 8);
   }


   L1TDigiToRaw::~L1TDigiToRaw()
   {
   }

   // ------------ method called to produce the data  ------------
   void
   L1TDigiToRaw::produce(edm::Event& event, const edm::EventSetup& setup)
   {
      using namespace edm;

      LogDebug("L1T") << "Packing data with FED ID " << fedId_;

      amc13::Packet amc13;

      auto bxId = event.bunchCrossing();
      // Note: L1ID != event ID
      // See e.g. triggerCount vs. eventNumber
      // in EventFilter/FEDInterface/interface/FED1024.h
      // But the trigger count is not stored in cmssw event class
      auto evtId = event.id().event();
      auto orbit = event.eventAuxiliary().orbitNumber();
      LogDebug("L1T") << "Forming FED with metadata bxId=" << bxId << ", l1ID=" << evtId << ", orbit=" << orbit;

      // Create all the AMC payloads to pack into the AMC13
      for (const auto& item: setup_->getPackers(fedId_, fwId_)) {
         auto amc_no = item.first.first;
         auto board = item.first.second;
         auto packers = item.second;

         Blocks block_load;
         for (const auto& packer: packers) {
            LogDebug("L1T") << "Adding packed blocks";
            packer->setBoard(board);
            auto blocks = packer->pack(event, tokens_.get());
            block_load.insert(block_load.end(), blocks.begin(), blocks.end());
         }

         std::sort(block_load.begin(), block_load.end());

         LogDebug("L1T") << "Concatenating blocks";

         std::vector<uint32_t> load32;
         // CTP7 stores this info in AMC user header
         if ( not ctp7_mode_ ) {
            // TODO Infrastructure firmware version.  Currently not used.
            // Would change the way the payload has to be unpacked.
            load32.push_back(0);
            load32.push_back(fwId_);
         }
         for (const auto& block: block_load) {
            LogDebug("L1T") << "Adding block " << block.header().getID() << " with size " << block.payload().size();
            auto load = block.payload();

#ifdef EDM_ML_DEBUG
            std::stringstream s("");
            s << "Block content:" << std::endl << std::hex << std::setfill('0');
            for (const auto& word: load)
               s << std::setw(8) << word << std::endl;
            LogDebug("L1T") << s.str();
#endif

            if ( block.header().getType() == CTP7 ) {
              // Header is two words for CTP7, first word is just a magic
              load32.push_back(0xA110CA7E);
            }
            load32.push_back(block.header().raw());
            load32.insert(load32.end(), load.begin(), load.end());
         }

         LogDebug("L1T") << "Converting payload";

         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;
            } else {
               word |= static_cast<uint64_t>(0xffffffff) << 32;
            }
            load64.push_back(word);
         }

         LogDebug("L1T") << "Creating AMC packet";

         unsigned amc_user_header = 0;
         if ( ctp7_mode_ ) amc_user_header = fwId_;
         amc13.add(amc_no, board, evtId, orbit, bxId, load64, amc_user_header);
      }

      std::unique_ptr<FEDRawDataCollection> raw_coll(new FEDRawDataCollection());
      FEDRawData& fed_data = raw_coll->FEDData(fedId_);

      unsigned int size = slinkHeaderSize_ + slinkTrailerSize_ + amc13.size() * 8;
      fed_data.resize(size);
      unsigned char * payload = fed_data.data();
      unsigned char * payload_start = payload;

      FEDHeader header(payload);
      header.set(payload, evtType_, evtId, bxId, fedId_);

      amc13.write(event, 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);

      event.put(std::move(raw_coll));
   }

   // ------------ method called when starting to processes a run  ------------
   /*
   void
   L1TDigiToRaw::beginRun(edm::Run const&, edm::EventSetup const&)
   {
   }
   */
    
   // ------------ method called when ending the processing of a run  ------------
   /*
   void
   L1TDigiToRaw::endRun(edm::Run const&, edm::EventSetup const&)
   {
   }
   */
    
   // ------------ method called when starting to processes a luminosity block  ------------
   /*
   void
   L1TDigiToRaw::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
   {
   }
   */
    
   // ------------ method called when ending the processing of a luminosity block  ------------
   /*
   void
   L1TDigiToRaw::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
   {
   }
   */
    
   // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
   void
   L1TDigiToRaw::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
     edm::ParameterSetDescription desc;
     desc.add<unsigned int>("FWId", -1);
     desc.add<int>("FedId");
     desc.addUntracked<int>("eventType", 1);
     desc.add<std::string>("Setup");
     desc.addOptional<edm::InputTag>("InputLabel",edm::InputTag(""));
     desc.addOptional<edm::InputTag>("InputLabel2",edm::InputTag(""));
     desc.addUntracked<int>("lenSlinkHeader", 8);
     desc.addUntracked<int>("lenSlinkTrailer", 8);
     desc.addUntracked<bool>("CTP7", false);

     PackingSetupFactory::get()->fillDescription(desc);

     descriptions.add("l1tDigiToRaw", desc);
   }
}

using namespace l1t;
//define this as a plug-in
DEFINE_FWK_MODULE(L1TDigiToRaw);