CTPPSRPAlignmentCorrectionsMethods.cc

Go to the documentation of this file.

/****************************************************************************
 *
 * This is a part of CMS-TOTEM PPS offline software.
 * Authors:
 * Jan Kaspar
 * Helena Malbouisson
 * Clemencia Mora Herrera
 *
 ****************************************************************************/

#include "CondFormats/CTPPSReadoutObjects/interface/CTPPSRPAlignmentCorrectionsMethods.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/typelookup.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

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

#include "Utilities/Xerces/interface/XercesStrUtils.h"

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

#include <map>
#include <set>

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

//----------------------------------------------------------------------------------------------------
edm::IOVSyncValue CTPPSRPAlignmentCorrectionsMethods::stringToIOVValue(const std::string &str)
{
  if (str == "-inf")
    return edm::IOVSyncValue::beginOfTime();

  if (str == "+inf")
    return edm::IOVSyncValue::endOfTime();

  size_t sep_pos = str.find(":");
  const std::string &runStr = str.substr(0, sep_pos);
  const std::string &lsStr = str.substr(sep_pos+1);

  return edm::IOVSyncValue(edm::EventID(atoi(runStr.c_str()), atoi(lsStr.c_str()), 1));
}

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

std::string CTPPSRPAlignmentCorrectionsMethods::iovValueToString(const edm::IOVSyncValue &val)
{
  if (val == edm::IOVSyncValue::beginOfTime())
    return "-inf";

  if (val == edm::IOVSyncValue::endOfTime())
    return "+inf";

  char buf[50];
  sprintf(buf, "%u:%u", val.eventID().run(), val.eventID().luminosityBlock());
  return buf;
}

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

CTPPSRPAlignmentCorrectionsDataSequence
CTPPSRPAlignmentCorrectionsMethods::loadFromXML( const std::string& fileName )
{
  // prepare output
  CTPPSRPAlignmentCorrectionsDataSequence output;

  // load DOM tree
  try {
    XMLPlatformUtils::Initialize();
  } catch ( const XMLException& toCatch ) {
    throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "An XMLException caught with message: " << cms::xerces::toString( toCatch.getMessage() ) << ".";
  }

  auto parser = std::make_unique<XercesDOMParser>();
  parser->setValidationScheme( XercesDOMParser::Val_Always );
  parser->setDoNamespaces( true );
  parser->parse( fileName.c_str() );

  if ( !parser )
    throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Cannot parse file `" << fileName << "' (parser = NULL).";

  DOMDocument* xmlDoc = parser->getDocument();

  if ( !xmlDoc )
    throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Cannot parse file `" << fileName << "' (xmlDoc = NULL).";

  DOMElement* elementRoot = xmlDoc->getDocumentElement();
  if ( !elementRoot )
    throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "File `" << fileName << "' is empty.";

  // extract useful information form the DOM tree
  DOMNodeList* children = elementRoot->getChildNodes();
  for ( unsigned int i = 0; i < children->getLength(); i++ )
    {
      DOMNode* node = children->item( i );
      if ( node->getNodeType() != DOMNode::ELEMENT_NODE )
    continue;

      const std::string node_name = cms::xerces::toString( node->getNodeName() );

      // check node type
      unsigned char nodeType = 0;
      if      ( node_name == "iov" ) nodeType = 1;
      else if ( node_name == "det" ) nodeType = 2;
      else if ( node_name == "rp"  ) nodeType = 3;

      if ( nodeType == 0 )
          throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Unknown node `" << node_name << "'.";

        // for backward compatibility: support files with no iov block
        if ( nodeType == 2 || nodeType == 3 )
        {
          const edm::ValidityInterval iov(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
          output.insert(iov, getCorrectionsData(elementRoot));
          break;
        }

        // get attributes
        edm::IOVSyncValue first, last;
        bool first_set = false, last_set = false;
        DOMNamedNodeMap* attrs = node->getAttributes();
        for ( unsigned int j = 0; j < attrs->getLength(); j++ )
        {
          const DOMNode* attr = attrs->item( j );
          const std::string attr_name = cms::xerces::toString( attr->getNodeName() );

          if ( attr_name == "first" )
          {
            first_set = true;
            first = stringToIOVValue( cms::xerces::toString( attr->getNodeValue() ) );
          }
          else if ( attr_name == "last" ) {
            last_set = true;
            last = stringToIOVValue( cms::xerces::toString( attr->getNodeValue() ) );
          }
          else
            edm::LogProblem("CTPPSRPAlignmentCorrectionsMethods") << ">> CTPPSRPAlignmentCorrectionsDataSequence::loadFromXML > Warning: unknown attribute `"
              << attr_name << "'.";
        }

        // interval of validity must be set
        if ( !first_set || !last_set )
          throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "iov tag must have `first' and `last' attributes set.";

        // process data
        CTPPSRPAlignmentCorrectionsData corrections = CTPPSRPAlignmentCorrectionsMethods::getCorrectionsData( node );

        // save result
        output.insert(edm::ValidityInterval(first, last), corrections);
      }

  // clean up
  parser.reset();
  XMLPlatformUtils::Terminate();

  return output;
}


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

CTPPSRPAlignmentCorrectionsData
CTPPSRPAlignmentCorrectionsMethods::getCorrectionsData( DOMNode* root )
{
  CTPPSRPAlignmentCorrectionsData result;

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

      const std::string node_name = cms::xerces::toString( node->getNodeName() );

      // check node type
      unsigned char nodeType = 0;
      if      ( node_name == "det" ) nodeType = 1;
      else if ( node_name == "rp"  ) nodeType = 2;

      if ( nodeType == 0 )
          throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Unknown node `" << cms::xerces::toString( node->getNodeName() ) << "'.";

      // check children
      if ( node->getChildNodes()->getLength() > 0 )
        {
          edm::LogProblem("CTPPSRPAlignmentCorrectionsMethods") << "LoadXMLFile > Warning: tag `" <<
            cms::xerces::toString( node->getNodeName() ) << "' has " << node->getChildNodes()->getLength() << " children nodes - they will be all ignored.";
        }

      // default values
      double sh_x = 0., sh_y = 0., sh_z = 0., rot_x = 0., rot_y = 0., rot_z = 0.;
      double sh_x_e = 0., sh_y_e = 0., sh_z_e = 0., rot_x_e = 0., rot_y_e = 0., rot_z_e = 0.;
      unsigned int id = 0;
      bool idSet = false;

      // get attributes
      DOMNamedNodeMap* attr = node->getAttributes();
      for ( unsigned int j = 0; j < attr->getLength(); j++ )
        {
          DOMNode *a = attr->item( j );
          const std::string node_name = cms::xerces::toString( a->getNodeName() );

          if ( node_name == "id" )
          {
            id = cms::xerces::toUInt( a->getNodeValue() );
            idSet = true;
          }
          else if ( node_name == "sh_x"    ) sh_x    = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "sh_x_e"  ) sh_x_e  = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "sh_y"    ) sh_y    = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "sh_y_e"  ) sh_y_e  = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "sh_z"    ) sh_z    = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "sh_z_e"  ) sh_z_e  = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_x"   ) rot_x   = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_x_e" ) rot_x_e = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_y"   ) rot_y   = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_y_e" ) rot_y_e = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_z"   ) rot_z   = cms::xerces::toDouble( a->getNodeValue() );
          else if ( node_name == "rot_z_e" ) rot_z_e = cms::xerces::toDouble( a->getNodeValue() );
          else
            edm::LogProblem("CTPPSRPAlignmentCorrectionsMethods") << ">> CTPPSRPAlignmentCorrectionsMethods::getCorrectionsData > Warning: unknown attribute `"
                                 << cms::xerces::toString( a->getNodeName() ) << "'.";
       }

      // id must be set
      if ( !idSet )
        throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Id not set for tag `" << cms::xerces::toString( node->getNodeName() ) << "'.";

      // build alignment
      const CTPPSRPAlignmentCorrectionData align_corr(
                         sh_x*1e-3, sh_x_e*1e-3,
                         sh_y*1e-3, sh_y_e*1e-3,
                         sh_z*1e-3, sh_z_e*1e-3,
                         rot_x*1e-3, rot_x_e*1e-3,
                         rot_y*1e-3, rot_y_e*1e-3,
                         rot_z*1e-3, rot_z_e*1e-3
                         );

      // add the alignment to the right list
      if ( nodeType == 1 ) result.addSensorCorrection( id, align_corr, true );
      if ( nodeType == 2 ) result.addRPCorrection( id, align_corr, true );
    }

  return result;
}


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

void
CTPPSRPAlignmentCorrectionsMethods::writeToXML( const CTPPSRPAlignmentCorrectionsDataSequence &data, const std::string& fileName, bool precise, bool wrErrors,
  bool wrSh_xy, bool wrSh_z, bool wrRot_xy, bool wrRot_z )
{
  FILE* rf = fopen( fileName.c_str(), "w" );
  if ( !rf )
    throw cms::Exception("CTPPSRPAlignmentCorrectionsMethods") << "Cannot open file `" << fileName << "' to save alignments.";

  fprintf( rf, "<!-- Shifts in um, rotations in mrad. -->\n" );
  fprintf( rf, "<xml DocumentType=\"AlignmentDescription\">\n" );

  // write all IOVs
  for ( const auto &p : data )
  {
    fprintf( rf, "\t<iov first=\"%s\" last=\"%s\">\n",
      iovValueToString(p.first.first()).c_str(),
      iovValueToString(p.first.last()).c_str()
    );

    writeXMLBlock( p.second, rf, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z );

    fprintf( rf, "\t</iov>\n" );
  }

  fprintf( rf, "</xml>\n" );
  fclose( rf );
}

void
CTPPSRPAlignmentCorrectionsMethods::writeXMLBlock( const CTPPSRPAlignmentCorrectionsData& data, FILE* rf, bool precise, bool wrErrors,
                          bool wrSh_xy, bool wrSh_z, bool wrRot_xy, bool wrRot_z )
{
  bool firstRP = true;
  unsigned int prevRP = 0;
  std::set<unsigned int> writtenRPs;

  const auto &sensors = data.getSensorMap();
  const auto &rps = data.getRPMap();

  for (auto it = sensors.begin(); it != sensors.end(); ++it)
    {
      CTPPSDetId sensorId(it->first);
      unsigned int rpId = sensorId.getRPId();
      unsigned int decRPId = sensorId.arm()*100 + sensorId.station()*10 + sensorId.rp();

      // start a RP block
      if (firstRP || prevRP != rpId)
        {
          if (!firstRP)
            fprintf(rf, "\n");
          firstRP = false;

          fprintf(rf, "\t<!-- RP %3u -->\n", decRPId);

          auto rit = rps.find(rpId);
          if (rit != rps.end())
          {
            fprintf(rf, "\t<rp id=\"%u\"                  ", rit->first);
            writeXML( rit->second , rf, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z );
            fprintf(rf, "/>\n");
            writtenRPs.insert(rpId);
          }
        }
      prevRP = rpId;

      // write plane id
      unsigned int planeIdx = 1000;
      if (sensorId.subdetId() == CTPPSDetId::sdTrackingStrip) planeIdx = TotemRPDetId(it->first).plane();
      if (sensorId.subdetId() == CTPPSDetId::sdTrackingPixel) planeIdx = CTPPSPixelDetId(it->first).plane();
      if (sensorId.subdetId() == CTPPSDetId::sdTimingDiamond) planeIdx = CTPPSDiamondDetId(it->first).plane();
      fprintf(rf, "\t<!-- plane %u --> ", planeIdx);

      // write the correction
      fprintf(rf, "<det id=\"%u\"", it->first);
      writeXML(it->second, rf, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z);
      fprintf(rf, "/>\n");
    }

  // write remaining RPs
  for (auto it = rps.begin(); it != rps.end(); ++it)
    {
      std::set<unsigned int>::iterator wit = writtenRPs.find(it->first);
      if (wit == writtenRPs.end())
        {
          CTPPSDetId rpId(it->first);
          unsigned int decRPId = rpId.arm()*100 + rpId.station()*10 + rpId.rp();

          if (!firstRP)
            fprintf(rf, "\n");
          firstRP = false;

          fprintf(rf, "\t<!-- RP %3u -->\n", decRPId);

          fprintf(rf, "\t<rp id=\"%u\"                  ", it->first);
          writeXML(it->second, rf, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z);
          fprintf(rf, "/>\n");
        }
    }
  }

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

#define WRITE(q, tag, dig, lim) \
  if (precise) \
    fprintf(f, " " tag "=\"%.15E\"", q*1E3);\
  else \
    if (fabs(q*1E3) < lim && q != 0) \
      fprintf(f, " " tag "=\"%+8.1E\"", q*1E3);\
    else \
      fprintf(f, " " tag "=\"%+8." #dig "f\"", q*1E3);

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

void
CTPPSRPAlignmentCorrectionsMethods::writeXML( const CTPPSRPAlignmentCorrectionData& data, FILE* f, bool precise, bool wrErrors,
                     bool wrSh_xy, bool wrSh_z, bool wrRot_xy, bool wrRot_z )
{
  if ( wrSh_xy )
  {
    WRITE( data.getShX(), "sh_x", 2, 0.1 );
    WRITE( data.getShY(), "sh_y", 2, 0.1 );
    if ( wrErrors )
      {
        WRITE( data.getShXUnc(), "sh_x_e", 2, 0.1 );
        WRITE( data.getShYUnc(), "sh_y_e", 2, 0.1 );
      }
  }

  if ( wrSh_z )
  {
    WRITE( data.getShZ(), "sh_z", 2, 0.1 );
    if ( wrErrors )
      {
        WRITE( data.getShZUnc(), "sh_z_e", 2, 0.1 );
      }
  }

  if ( wrRot_xy )
  {
    WRITE( data.getRotX(), "rot_x", 3, 0.01 );
    WRITE( data.getRotY(), "rot_y", 3, 0.01 );
    if ( wrErrors )
      {
        WRITE( data.getRotXUnc(), "rot_x_e", 3, 0.01 );
        WRITE( data.getRotYUnc(), "rot_y_e", 3, 0.01 );
      }
  }

  if ( wrRot_z )
  {
    WRITE( data.getRotZ(), "rot_z", 3, 0.01 );
    if ( wrErrors )
      {
        WRITE( data.getRotZUnc(), "rot_z_e", 3, 0.01 );
      }
  }
}