CTPPSRPAlignmentCorrectionsMethods Class Reference

#include <CTPPSRPAlignmentCorrectionsMethods.h>

Public Member Functions
	CTPPSRPAlignmentCorrectionsMethods ()

Static Public Member Functions
static std::string	iovValueToString (const edm::IOVSyncValue &)
static CTPPSRPAlignmentCorrectionsDataSequence	loadFromXML (const std::string &fileName)
	loads sequence of alignment corrections from XML file More...
static edm::IOVSyncValue	stringToIOVValue (const std::string &)
static void	writeToXML (const CTPPSRPAlignmentCorrectionsDataSequence &seq, const std::string &fileName, bool precise=false, bool wrErrors=true, bool wrSh_xy=true, bool wrSh_z=false, bool wrRot_xy=false, bool wrRot_z=true)
	writes sequence of alignment corrections into a single XML file More...
static void	writeToXML (const CTPPSRPAlignmentCorrectionsData &ad, const std::string &fileName, bool precise=false, bool wrErrors=true, bool wrSh_xy=true, bool wrSh_z=false, bool wrRot_xy=false, bool wrRot_z=true)
	writes alignment corrections into a single XML file, assigning infinite interval of validity More...

Static Protected Member Functions
static CTPPSRPAlignmentCorrectionsData	getCorrectionsData (xercesc::DOMNode *)
	load corrections data corresponding to one IOV More...
static void	writeXML (const CTPPSRPAlignmentCorrectionData &data, FILE *f, bool precise, bool wrErrors, bool wrSh_xy, bool wrSh_z, bool wrRot_xy, bool wrRot_z)
	writes data of a correction in XML format More...
static void	writeXMLBlock (const CTPPSRPAlignmentCorrectionsData &, FILE *, bool precise=false, bool wrErrors=true, bool wrSh_xy=true, bool wrSh_z=false, bool wrRot_xy=false, bool wrRot_z=true)
	writes a block of corrections into a file More...

Detailed Description

Definition at line 22 of file CTPPSRPAlignmentCorrectionsMethods.h.

Constructor & Destructor Documentation

CTPPSRPAlignmentCorrectionsMethods()

CTPPSRPAlignmentCorrectionsMethods::CTPPSRPAlignmentCorrectionsMethods ( )

inline

Definition at line 24 of file CTPPSRPAlignmentCorrectionsMethods.h.

{}

Member Function Documentation

getCorrectionsData()

CTPPSRPAlignmentCorrectionsData CTPPSRPAlignmentCorrectionsMethods::getCorrectionsData ( xercesc::DOMNode *  )

staticprotected

load corrections data corresponding to one IOV

Definition at line 209 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References a, class-composition::children, MillePedeFileConverter_cfg::e, Exception, mps_fire::i, dqmiolumiharvest::j, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, cms::xerces::toDouble(), cms::xerces::toString(), and cms::xerces::toUInt().

Referenced by loadFromXML().

                                                                                                    {
  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;
}

iovValueToString()

std::string CTPPSRPAlignmentCorrectionsMethods::iovValueToString ( const edm::IOVSyncValue &  val )

static

Definition at line 95 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References edm::IOVSyncValue::beginOfTime(), visDQMUpload::buf, edm::IOVSyncValue::endOfTime(), and heppy_batch::val.

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::Merge(), CTPPSRPAlignmentCorrectionsDataESSourceXML::setIntervalFor(), and writeToXML().

                                                                                         {
  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;
}

loadFromXML()

CTPPSRPAlignmentCorrectionsDataSequence CTPPSRPAlignmentCorrectionsMethods::loadFromXML ( const std::string &  fileName )

static

loads sequence of alignment corrections from XML file

Definition at line 109 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References edm::IOVSyncValue::beginOfTime(), class-composition::children, edm::IOVSyncValue::endOfTime(), Exception, MillePedeFileConverter_cfg::fileName, first, getCorrectionsData(), mps_fire::i, dqmiolumiharvest::j, dqmdumpme::last, convertSQLitetoXML_cfg::output, writedatasetfile::parser, AlCaHLTBitMon_QueryRunRegistry::string, stringToIOVValue(), and cms::xerces::toString().

Referenced by PPSModifySingularModes::beginRun(), and CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::PrepareSequence().

                                                                                                                 {
  // 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;
}

stringToIOVValue()

edm::IOVSyncValue CTPPSRPAlignmentCorrectionsMethods::stringToIOVValue ( const std::string &  str )

static

STRUCTURE OF CTPPS ALINGMENT XML FILE The file has the following structure <xml> <iov first="run:ls" last="run:ls"> <tag> <tag> ... </iov> <iov first="run:ls" last="run:ls"> ... </iov></xml> The time intervals are specified by the ‘first’ and ‘last’ run-lumisection pairs. If the <iov> tag is not present, an infinite validty is assumed for all the tags. The tag can be either "det" - the alignment correction is applied to one detector or "rp" - the alignment correction id applied to one RP Each tag must have an "id" attribute set. In addition the following attributes are recognized: sh_x - shift in x sh_x_e - the uncertainty of sh_x determination sh_y - shift in y sh_y_e - the uncertainty of sh_y determination sh_z - shift in z sh_z_e - the uncertainty of sh_z determination rot_x - rotation around x rot_x_e - the uncertainty of rot_x determination rot_y - rotation around y rot_y_e - the uncertainty of rot_y determination rot_z - rotation around z rot_z_e - the uncertainty of rot_z determination UNITS: shifts are in um, rotations are in mrad.

Definition at line 79 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), str, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by loadFromXML().

                                                                                         {
  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));
}

writeToXML() [1/2]

void CTPPSRPAlignmentCorrectionsMethods::writeToXML ( const CTPPSRPAlignmentCorrectionsDataSequence &  seq, const std::string &  fileName, bool  precise = false, bool  wrErrors = true, bool  wrSh_xy = true, bool  wrSh_z = false, bool  wrRot_xy = false, bool  wrRot_z = true  )

static

writes sequence of alignment corrections into a single XML file

Definition at line 315 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References data, Exception, MillePedeFileConverter_cfg::fileName, iovValueToString(), AlCaHLTBitMon_ParallelJobs::p, hltPixelTracks_cff::precise, hcal_runs::rf, and writeXMLBlock().

Referenced by PPSModifySingularModes::beginRun(), StraightTrackAlignment::finish(), and writeToXML().

                                                                  {
  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);
}

writeToXML() [2/2]

static void CTPPSRPAlignmentCorrectionsMethods::writeToXML ( const CTPPSRPAlignmentCorrectionsData &  ad, const std::string &  fileName, bool  precise = false, bool  wrErrors = true, bool  wrSh_xy = true, bool  wrSh_z = false, bool  wrRot_xy = false, bool  wrRot_z = true  )

inlinestatic

writes alignment corrections into a single XML file, assigning infinite interval of validity

Definition at line 40 of file CTPPSRPAlignmentCorrectionsMethods.h.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), MillePedeFileConverter_cfg::fileName, hltPixelTracks_cff::precise, alignCSCRings::s, and writeToXML().

                                              {
    const edm::ValidityInterval iov(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
    CTPPSRPAlignmentCorrectionsDataSequence s;
    s.insert(iov, ad);
    writeToXML(s, fileName, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z);
  }

writeXML()

void CTPPSRPAlignmentCorrectionsMethods::writeXML ( const CTPPSRPAlignmentCorrectionData &  data, FILE *  f, bool  precise, bool  wrErrors, bool  wrSh_xy, bool  wrSh_z, bool  wrRot_xy, bool  wrRot_z  )

staticprotected

writes data of a correction in XML format

Definition at line 433 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References data, and WRITE.

Referenced by writeXMLBlock().

                                                                {
  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);
    }
  }
}

writeXMLBlock()

void CTPPSRPAlignmentCorrectionsMethods::writeXMLBlock ( const CTPPSRPAlignmentCorrectionsData &  data, FILE *  rf, bool  precise = false, bool  wrErrors = true, bool  wrSh_xy = true, bool  wrSh_z = false, bool  wrRot_xy = false, bool  wrRot_z = true  )

staticprotected

writes a block of corrections into a file

Definition at line 347 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References CTPPSDetId::arm(), data, protons_cff::decRPId, CTPPSPixelDetId::plane(), CTPPSDiamondDetId::plane(), TotemRPDetId::plane(), hltPixelTracks_cff::precise, hcal_runs::rf, CTPPSDetId::rp(), CTPPSDetId::rpId(), CTPPSDetId::sdTimingDiamond, CTPPSDetId::sdTrackingPixel, CTPPSDetId::sdTrackingStrip, CTPPSDetId::station(), DetId::subdetId(), and writeXML().

Referenced by writeToXML().

                                                                     {
  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.rpId();
    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");
    }
  }
}