TotemDAQMappingESSourceXML.cc

Go to the documentation of this file.

/****************************************************************************
*
* This is a part of TOTEM offline software.
* Authors:
*   Maciej Wróbel (wroblisko@gmail.com)
*   Jan Kašpar (jan.kaspar@cern.ch)
*   Marcin Borratynski (mborratynski@gmail.com)
*   Seyed Mohsen Etesami (setesami@cern.ch)
*   Laurent Forthomme
****************************************************************************/

#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/SourceFactory.h"
#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESProducer.h"
#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
#include "FWCore/Framework/interface/ESProducts.h"
#include "FWCore/Framework/interface/SourceFactory.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/CTPPSDetId/interface/TotemRPDetId.h"
#include "DataFormats/CTPPSDetId/interface/CTPPSDiamondDetId.h"

#include "CondFormats/DataRecord/interface/TotemReadoutRcd.h"
#include "CondFormats/CTPPSReadoutObjects/interface/TotemDAQMapping.h"
#include "CondFormats/CTPPSReadoutObjects/interface/TotemAnalysisMask.h"
#include "CondFormats/CTPPSReadoutObjects/interface/TotemFramePosition.h"
#include "Utilities/Xerces/interface/XercesStrUtils.h"

#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>

#include <memory>
#include <sstream>

//#define DEBUG 1

//----------------------------------------------------------------------------------------------------

using namespace std;

class TotemDAQMappingESSourceXML: public edm::ESProducer, public edm::EventSetupRecordIntervalFinder
{
public:
  static const std::string tagVFAT;
  static const std::string tagChannel;
  static const std::string tagAnalysisMask;

  static const std::string tagArm;

  static const std::string tagRPStation;
  static const std::string tagRPPot;
  static const std::string tagRPPlane;

  static const std::string tagChip1;
  static const std::string tagChip2;
 
  static const std::string tagDiamondPlane;
  static const std::string tagDiamondCh; 

  TotemDAQMappingESSourceXML(const edm::ParameterSet &);
  ~TotemDAQMappingESSourceXML() override;

  edm::ESProducts< std::shared_ptr<TotemDAQMapping>, std::shared_ptr<TotemAnalysisMask> > produce( const TotemReadoutRcd & );

private:
  unsigned int verbosity;

  string subSystemName;


  std::vector<std::string> mappingFileNames;

  struct ConfigBlock
  {
    edm::EventRange validityRange;

    std::vector<std::string> mappingFileNames;

    std::vector<std::string> maskFileNames;
  };

  vector<ConfigBlock> configuration;

  unsigned int currentBlock;

  bool currentBlockValid;

  enum NodeType { nUnknown, nSkip, nTop, nArm, nRPStation, nRPPot, nRPPlane, nDiamondPlane, nChip, nDiamondCh, nChannel };

  enum ParseType { pMapping, pMask };

  void ParseXML(ParseType, const string &file, const std::shared_ptr<TotemDAQMapping>&, const std::shared_ptr<TotemAnalysisMask>&);

  void ParseTreeRP(ParseType, xercesc::DOMNode *, NodeType, unsigned int parentID,
    const std::shared_ptr<TotemDAQMapping>&, const std::shared_ptr<TotemAnalysisMask>&);

  void ParseTreeDiamond(ParseType, xercesc::DOMNode *, NodeType, unsigned int parentID,
    const std::shared_ptr<TotemDAQMapping>&, const std::shared_ptr<TotemAnalysisMask>&);

private:
  string CompleteFileName(const string &fn);

  bool Test(xercesc::DOMNode *node, const std::string &name)
  {
    return !(name.compare(cms::xerces::toString(node->getNodeName())));
  }

  NodeType GetNodeType(xercesc::DOMNode *);

  string GetNodeContent(xercesc::DOMNode *parent)
  {
    return string(cms::xerces::toString(parent->getTextContent()));
  }

  string GetNodeValue(xercesc::DOMNode *node)
  {
    return cms::xerces::toString(node->getNodeValue());
  }

  TotemFramePosition ChipFramePosition(xercesc::DOMNode *chipnode);

  void GetChannels(xercesc::DOMNode *n, std::set<unsigned char> &channels);

  bool RPNode(NodeType type)
  {
    return ((type == nArm)||(type == nRPStation)||(type == nRPPot)||(type == nRPPlane)||(type == nChip));
  }

  bool DiamondNode(NodeType type)
  {
    return ((type == nArm)||(type == nRPStation)||(type == nRPPot)||(type == nDiamondPlane)||(type == nDiamondCh));
  }
  bool CommonNode(NodeType type)
  {
    return ((type==nChip)||(type==nArm));
  }

protected:
  void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&, const edm::IOVSyncValue&, edm::ValidityInterval&) override;
};

//----------------------------------------------------------------------------------------------------

using namespace std;
using namespace edm;
using namespace xercesc;

const string TotemDAQMappingESSourceXML::tagVFAT="vfat";
const string TotemDAQMappingESSourceXML::tagChannel="channel";
const string TotemDAQMappingESSourceXML::tagAnalysisMask="analysisMask";

// common XML position tags
const string TotemDAQMappingESSourceXML::tagArm = "arm";

// common XML Chip tags
const string TotemDAQMappingESSourceXML::tagChip1 = "vfat";
const string TotemDAQMappingESSourceXML::tagChip2 = "test_vfat";

// specific RP XML tags
const string TotemDAQMappingESSourceXML::tagRPStation = "station";
const string TotemDAQMappingESSourceXML::tagRPPot = "rp_detector_set";
const string TotemDAQMappingESSourceXML::tagRPPlane = "rp_plane";

// specific tags for diamond
const string TotemDAQMappingESSourceXML::tagDiamondPlane = "rp_plane_diamond";
const string TotemDAQMappingESSourceXML::tagDiamondCh = "diamond_channel";


//----------------------------------------------------------------------------------------------------

TotemDAQMappingESSourceXML::TotemDAQMappingESSourceXML(const edm::ParameterSet& conf) :
  verbosity(conf.getUntrackedParameter<unsigned int>("verbosity", 0)),
  subSystemName(conf.getUntrackedParameter<string>("subSystem")),
  currentBlock(0),
  currentBlockValid(false)
{
  for (const auto it : conf.getParameter<vector<ParameterSet>>("configuration"))
  {
    ConfigBlock b;
    b.validityRange = it.getParameter<EventRange>("validityRange");
    b.mappingFileNames = it.getParameter< vector<string> >("mappingFileNames");
    b.maskFileNames = it.getParameter< vector<string> >("maskFileNames");
    configuration.push_back(b);
  }

  setWhatProduced(this, subSystemName);
  findingRecord<TotemReadoutRcd>();
}

//----------------------------------------------------------------------------------------------------

void TotemDAQMappingESSourceXML::setIntervalFor(const edm::eventsetup::EventSetupRecordKey &key,
  const edm::IOVSyncValue& iosv, edm::ValidityInterval& oValidity)
{
  LogVerbatim("TotemDAQMappingESSourceXML")
    << ">> TotemDAQMappingESSourceXML::setIntervalFor(" << key.name() << ")";

  LogVerbatim("TotemDAQMappingESSourceXML")
    << "    run=" << iosv.eventID().run() << ", event=" << iosv.eventID().event();

  currentBlockValid = false;
  for (unsigned int idx = 0; idx < configuration.size(); ++idx)
  {
    const auto &bl = configuration[idx];

    edm::EventRange range = bl.validityRange;

    // If "<run>:min" is specified in python config, it is translated into event <run>:0:1.
    // However, the truly minimal event id often found in data is <run>:0:0. Therefore the
    // adjustment below is needed.
    if (range.startEventID().luminosityBlock() == 0 && range.startEventID().event() == 1)
      range = edm::EventRange(edm::EventID(range.startEventID().run(), 0, 0), range.endEventID());

    if (edm::contains(range, iosv.eventID()))
    {
      currentBlockValid = true;
      currentBlock = idx;
  
      const IOVSyncValue begin(range.startEventID());
      const IOVSyncValue end(range.endEventID());
      oValidity = edm::ValidityInterval(begin, end);
      
      LogVerbatim("TotemDAQMappingESSourceXML")
        << "    block found: index=" << currentBlock
        << ", interval=(" << range.startEventID() << " - " << range.endEventID() << ")";

      return;
    }
  }

  if (!currentBlockValid)
  {
    throw cms::Exception("TotemDAQMappingESSourceXML::setIntervalFor") <<
      "No configuration for event " << iosv.eventID();
  }
}

//----------------------------------------------------------------------------------------------------

TotemDAQMappingESSourceXML::~TotemDAQMappingESSourceXML()
{ 
}

//----------------------------------------------------------------------------------------------------

string TotemDAQMappingESSourceXML::CompleteFileName(const string &fn)
{
  FileInPath fip(fn);
  return fip.fullPath();
}

//----------------------------------------------------------------------------------------------------

edm::ESProducts< std::shared_ptr<TotemDAQMapping>, std::shared_ptr<TotemAnalysisMask> >
  TotemDAQMappingESSourceXML::produce( const TotemReadoutRcd & )
{
  assert(currentBlockValid);

  auto mapping = std::make_shared<TotemDAQMapping>();
  auto mask = std::make_shared<TotemAnalysisMask>();

  // initialize Xerces
  try
  {
    XMLPlatformUtils::Initialize();
  }
  catch (const XMLException& toCatch)
  {
    throw cms::Exception("TotemDAQMappingESSourceXML") << "An XMLException caught with message: " << cms::xerces::toString(toCatch.getMessage()) << ".\n";
  }

  // load mapping files
  for (const auto &fn : configuration[currentBlock].mappingFileNames)
    ParseXML(pMapping, CompleteFileName(fn), mapping, mask);

  // load mask files
  for (const auto &fn : configuration[currentBlock].maskFileNames)
    ParseXML(pMask, CompleteFileName(fn), mapping, mask);

  // release Xerces
  XMLPlatformUtils::Terminate();

  // commit the products
  return edm::es::products(mapping, mask);
}

//----------------------------------------------------------------------------------------------------

void TotemDAQMappingESSourceXML::ParseXML(ParseType pType, const string &file,
  const std::shared_ptr<TotemDAQMapping> &mapping, const std::shared_ptr<TotemAnalysisMask> &mask)
{
  unique_ptr<XercesDOMParser> parser(new XercesDOMParser());
  parser->parse(file.c_str());

  DOMDocument* domDoc = parser->getDocument();

  if (!domDoc)
    throw cms::Exception("TotemDAQMappingESSourceXML::ParseXML") << "Cannot parse file `" << file
      << "' (domDoc = NULL)." << endl;

  DOMElement* elementRoot = domDoc->getDocumentElement();

  if (!elementRoot)
    throw cms::Exception("TotemDAQMappingESSourceXML::ParseXML") << "File `" <<
      file << "' is empty." << endl;

  ParseTreeRP(pType, elementRoot, nTop, 0, mapping, mask);

  ParseTreeDiamond(pType, elementRoot, nTop, 0, mapping, mask);
}

//-----------------------------------------------------------------------------------------------------------

void TotemDAQMappingESSourceXML::ParseTreeRP(ParseType pType, xercesc::DOMNode * parent, NodeType parentType,
  unsigned int parentID, const std::shared_ptr<TotemDAQMapping>& mapping,
  const std::shared_ptr<TotemAnalysisMask>& mask)
{
#ifdef DEBUG
  printf(">> TotemDAQMappingESSourceXML::ParseTreeRP(%s, %u, %u)\n", cms::xerces::toString(parent->getNodeName()),
    parentType, parentID);
#endif

  DOMNodeList *children = parent->getChildNodes();

  for (unsigned int i = 0; i < children->getLength(); i++)
  {
    DOMNode *n = children->item(i);
    if (n->getNodeType() != DOMNode::ELEMENT_NODE)
      continue;

    NodeType type = GetNodeType(n);

#ifdef DEBUG
    printf("\tname = %s, type = %u\n", cms::xerces::toString(n->getNodeName()), type);
#endif

    // structure control
    if (!RPNode(type))
      continue;
  
    NodeType expectedParentType;
    switch (type)
    {
      case nArm: expectedParentType = nTop; break;
      case nRPStation: expectedParentType = nArm; break;
      case nRPPot: expectedParentType = nRPStation; break;
      case nRPPlane: expectedParentType = nRPPot; break;
      case nChip: expectedParentType = nRPPlane; break;
      case nChannel: expectedParentType = nChip; break;
      default: expectedParentType = nUnknown; break;
    }

    if (expectedParentType != parentType)
    {
      throw cms::Exception("TotemDAQMappingESSourceXML") << "Node " << cms::xerces::toString(n->getNodeName())
        << " not allowed within " << cms::xerces::toString(parent->getNodeName()) << " block.\n";
    }

    // parse tag attributes
    unsigned int id = 0, hw_id = 0;
    bool id_set = false, hw_id_set = false;
    bool fullMask = false;
    DOMNamedNodeMap* attr = n->getAttributes();

    for (unsigned int j = 0; j < attr->getLength(); j++)
    {
      DOMNode *a = attr->item(j);

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "id"))
      {
        sscanf(cms::xerces::toString(a->getNodeValue()).c_str(), "%u", &id);
        id_set = true;
      }

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "hw_id"))
      {
        sscanf(cms::xerces::toString(a->getNodeValue()).c_str(), "%x", &hw_id);
        hw_id_set = true;
      }

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "full_mask"))
        fullMask = (strcmp(cms::xerces::toString(a->getNodeValue()).c_str(), "no") != 0);
    }

    // content control
    if (!id_set)
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeRP") << "id not given for element `"
       << cms::xerces::toString(n->getNodeName()) << "'" << endl;

    if (!hw_id_set && type == nChip && pType == pMapping)
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeRP") << "hw_id not given for element `"
       << cms::xerces::toString(n->getNodeName()) << "'" << endl;

    if (type == nRPPlane && id > 9)
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeRP") <<
        "Plane IDs range from 0 to 9. id = " << id << " is invalid." << endl;

#ifdef DEBUG
    printf("\tID found: 0x%x\n", id);
#endif

    // store mapping data
    if (pType == pMapping && type == nChip)
    {
      const TotemFramePosition &framepos = ChipFramePosition(n);
      TotemVFATInfo vfatInfo;
      vfatInfo.hwID = hw_id;

      const unsigned int armIdx = (parentID / 1000) % 10; 
      const unsigned int stIdx = (parentID / 100) % 10; 
      const unsigned int rpIdx = (parentID / 10) % 10; 
      const unsigned int plIdx = parentID % 10; 

      vfatInfo.symbolicID.symbolicID = TotemRPDetId(armIdx, stIdx, rpIdx, plIdx, id);

      mapping->insert(framepos, vfatInfo);

      continue;
    }

    // store mask data
    if (pType == pMask && type == nChip)
    {
      const unsigned int armIdx = (parentID / 1000) % 10; 
      const unsigned int stIdx = (parentID / 100) % 10; 
      const unsigned int rpIdx = (parentID / 10) % 10; 
      const unsigned int plIdx = parentID % 10; 

      TotemSymbID symbId;
      symbId.symbolicID = TotemRPDetId(armIdx, stIdx, rpIdx, plIdx, id);

      TotemVFATAnalysisMask am;
      am.fullMask = fullMask;
      GetChannels(n, am.maskedChannels);

      mask->insert(symbId, am);

      continue;
    }

    // recursion (deeper in the tree)
    ParseTreeRP(pType, n, type,  parentID * 10 + id, mapping, mask);
  }
}

//----------------------------------------------------------------------------------------------------

void TotemDAQMappingESSourceXML::ParseTreeDiamond(ParseType pType, xercesc::DOMNode * parent, NodeType parentType,
  unsigned int parentID, const std::shared_ptr<TotemDAQMapping>& mapping,
  const std::shared_ptr<TotemAnalysisMask>& mask)
{

#ifdef DEBUG
  printf(">> TotemDAQMappingESSourceXML::ParseTreeDiamond(%s, %u, %u)\n", cms::xerces::toString(parent->getNodeName()),
     parentType, parentID);
#endif

  DOMNodeList *children = parent->getChildNodes();

  for (unsigned int i = 0; i < children->getLength(); i++)
  {  
    DOMNode *n = children->item(i);
    if (n->getNodeType() != DOMNode::ELEMENT_NODE)
      continue;
  
    NodeType type = GetNodeType(n);
#ifdef DEBUG
      printf("\tname = %s, type = %u\n", cms::xerces::toString(n->getNodeName()), type);
#endif

      // structure control
    if (!DiamondNode(type))
      continue;

    NodeType expectedParentType;
    switch (type)
    {
      case nArm: expectedParentType = nTop; break;
      case nRPStation: expectedParentType = nArm; break;
      case nRPPot: expectedParentType = nRPStation; break;
      case nDiamondPlane: expectedParentType = nRPPot; break;
      case nDiamondCh: expectedParentType = nDiamondPlane; break;
      default: expectedParentType = nUnknown; break;
    }

    if (expectedParentType != parentType)
    {
      throw cms::Exception("TotemDAQMappingESSourceXML") << "Node " << cms::xerces::toString(n->getNodeName())
        << " not allowed within " << cms::xerces::toString(parent->getNodeName()) << " block.\n";
    }

    // parse tag attributes
    unsigned int id =0,hw_id = 0; 
    bool id_set = false,hw_id_set = false; 
    DOMNamedNodeMap* attr = n->getAttributes();

    for (unsigned int j = 0; j < attr->getLength(); j++)
    {
      DOMNode *a = attr->item(j);

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "id"))
      {
        sscanf(cms::xerces::toString(a->getNodeValue()).c_str(), "%u", &id);
    id_set = true;
      }

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "hw_id"))
      {
        sscanf(cms::xerces::toString(a->getNodeValue()).c_str(), "%x", &hw_id);
    hw_id_set = true;
      }

    }

      // content control
    if (!id_set) 
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeDiamond") << "id not given for element `"
                                           << cms::xerces::toString(n->getNodeName()) << "'" << endl;


    if (!hw_id_set && type == nDiamondCh && pType == pMapping)
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeDiamond") << "hw_id not given for element `"
                                         << cms::xerces::toString(n->getNodeName()) << "'" << endl;
 
    if (type == nDiamondPlane && id > 3)
      throw cms::Exception("TotemDAQMappingESSourceXML::ParseTreeDiamond") <<
      "Plane IDs range from 0 to 3. id = " << id << " is invalid." << endl;

#ifdef DEBUG
      printf("\tID found: 0x%x\n", id);
#endif

      // store mapping data
    if (pType == pMapping &&type == nDiamondCh)
    {

      const TotemFramePosition &framepos = ChipFramePosition(n);
      
      TotemVFATInfo vfatInfo;
      vfatInfo.hwID = hw_id;     

      if (type == nDiamondCh)
      {
        unsigned int ArmNum = (parentID/ 10000) % 10;
        unsigned int StationNum = (parentID / 1000) % 10;
        unsigned int RpNum = (parentID/ 100) % 10;
        unsigned int PlaneNum = (parentID % 100) ;       

        vfatInfo.symbolicID.symbolicID = CTPPSDiamondDetId(ArmNum, StationNum, RpNum, PlaneNum, id);


      }


      mapping->insert(framepos, vfatInfo);

      continue;
    }

    unsigned int childId;
    if (pType == pMapping &&type == nDiamondPlane)
      childId = parentID * 100 + id;
    else
      childId = parentID * 10 + id;

    ParseTreeDiamond(pType,n ,type ,childId ,mapping ,mask);
   
  }

}


//----------------------------------------------------------------------------------------------------

TotemFramePosition TotemDAQMappingESSourceXML::ChipFramePosition(xercesc::DOMNode *chipnode)
{
  TotemFramePosition fp;
  unsigned char attributeFlag = 0;

  DOMNamedNodeMap* attr = chipnode->getAttributes();
  for (unsigned int j = 0; j < attr->getLength(); j++)
  {
    DOMNode *a = attr->item(j);
    if (fp.setXMLAttribute(cms::xerces::toString(a->getNodeName()), cms::xerces::toString(a->getNodeValue()), attributeFlag) > 1)
    {
      throw cms::Exception("TotemDAQMappingESSourceXML") <<
        "Unrecognized tag `" << cms::xerces::toString(a->getNodeName()) <<
        "' or incompatible value `" << cms::xerces::toString(a->getNodeValue()) <<
        "'." << endl;
    }
  }

  if (!fp.checkXMLAttributeFlag(attributeFlag))
  {
    throw cms::Exception("TotemDAQMappingESSourceXML") <<
      "Wrong/incomplete DAQ channel specification (attributeFlag = " << attributeFlag << ")." << endl;
  }

  return fp;
}

//----------------------------------------------------------------------------------------------------

TotemDAQMappingESSourceXML::NodeType TotemDAQMappingESSourceXML::GetNodeType(xercesc::DOMNode *n)
{
  // common node types
  if (Test(n, tagArm)) return nArm;
  if (Test(n, tagChip1)) return nChip;
  if (Test(n, tagChip2)) return nChip;

  // RP node types
  if (Test(n, tagRPStation)) return nRPStation;
  if (Test(n, tagRPPot)) return nRPPot;
  if (Test(n, tagRPPlane)) return nRPPlane;

  //diamond specifics
  if (Test(n, tagDiamondCh)) return nDiamondCh;
  if (Test(n, tagDiamondPlane)) return nDiamondPlane;

  // for backward compatibility
  if (Test(n, "trigger_vfat")) return nSkip;

  throw cms::Exception("TotemDAQMappingESSourceXML::GetNodeType") << "Unknown tag `"
    << cms::xerces::toString(n->getNodeName()) << "'.\n";
}

//----------------------------------------------------------------------------------------------------

void TotemDAQMappingESSourceXML::GetChannels(xercesc::DOMNode *n, set<unsigned char> &channels)
{
  DOMNodeList *children = n->getChildNodes();
  for (unsigned int i = 0; i < children->getLength(); i++)
  {
    DOMNode *n = children->item(i);
    if (n->getNodeType() != DOMNode::ELEMENT_NODE || !Test(n, "channel"))
      continue;

    DOMNamedNodeMap* attr = n->getAttributes();
    bool idSet = false;
    for (unsigned int j = 0; j < attr->getLength(); j++)
    {
      DOMNode *a = attr->item(j);

      if (!strcmp(cms::xerces::toString(a->getNodeName()).c_str(), "id"))
      {
        unsigned int id = 0;
        sscanf(cms::xerces::toString(a->getNodeValue()).c_str(), "%u", &id);
        channels.insert(id);
        idSet = true;
        break;
      }
    }

    if (!idSet)
    {
      throw cms::Exception("TotemDAQMappingESSourceXML::GetChannels") <<
        "Channel tags must have an `id' attribute.";
    }
  }
}

//----------------------------------------------------------------------------------------------------

DEFINE_FWK_EVENTSETUP_SOURCE(TotemDAQMappingESSourceXML);