RPAlignmentCorrectionsMethods Class Reference

#include <RPAlignmentCorrectionsMethods.h>

Public Member Functions
	RPAlignmentCorrectionsMethods ()

Static Public Member Functions
static std::string	iovValueToString (const edm::IOVSyncValue &)
static RPAlignmentCorrectionsDataSequence	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 RPAlignmentCorrectionsDataSequence &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 RPAlignmentCorrectionsData &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 RPAlignmentCorrectionsData	getCorrectionsData (xercesc::DOMNode *)
	load corrections data corresponding to one IOV More...
static void	writeXML (const RPAlignmentCorrectionData &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 RPAlignmentCorrectionsData &, 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 20 of file RPAlignmentCorrectionsMethods.h.

Constructor & Destructor Documentation

RPAlignmentCorrectionsMethods::RPAlignmentCorrectionsMethods ( )

inline

Definition at line 23 of file RPAlignmentCorrectionsMethods.h.

References MillePedeFileConverter_cfg::fileName, loadFromXML(), hiDetachedQuadStep_cff::precise, AlCaHLTBitMon_QueryRunRegistry::string, and writeToXML().

{}

Member Function Documentation

RPAlignmentCorrectionsData RPAlignmentCorrectionsMethods::getCorrectionsData ( xercesc::DOMNode *  )

staticprotected

load corrections data corresponding to one IOV

Definition at line 212 of file RPAlignmentCorrectionsMethods.cc.

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

Referenced by loadFromXML(), and writeToXML().

{
  RPAlignmentCorrectionsData 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("RPAlignmentCorrectionsMethods") << "Unknown node `" << cms::xerces::toString( node->getNodeName() ) << "'.";

    // check children
    if ( node->getChildNodes()->getLength() > 0 )
    {
        edm::LogProblem("RPAlignmentCorrectionsMethods") << "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("RPAlignmentCorrectionsMethods") << ">> RPAlignmentCorrectionsMethods::getCorrectionsData > Warning: unknown attribute `"
          << cms::xerces::toString( a->getNodeName() ) << "'.";
    }

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

    // build alignment
    const RPAlignmentCorrectionData 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;
}

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

static

Definition at line 96 of file RPAlignmentCorrectionsMethods.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), edm::EventID::luminosityBlock(), and edm::EventID::run().

Referenced by CTPPSIncludeAlignmentsFromXML::Merge(), CTPPSIncludeAlignmentsFromXML::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;
}

RPAlignmentCorrectionsDataSequence RPAlignmentCorrectionsMethods::loadFromXML ( const std::string &  fileName )

static

loads sequence of alignment corrections from XML file

Definition at line 112 of file RPAlignmentCorrectionsMethods.cc.

References edm::IOVSyncValue::beginOfTime(), class-composition::children, edm::IOVSyncValue::endOfTime(), Exception, plotBeamSpotDB::first, getCorrectionsData(), mps_fire::i, RPAlignmentCorrectionsDataSequence::insert(), plotBeamSpotDB::last, convertSQLitetoXML_cfg::output, createfilelist::parser, AlCaHLTBitMon_QueryRunRegistry::string, stringToIOVValue(), and cms::xerces::toString().

Referenced by CTPPSIncludeAlignmentsFromXML::PrepareSequence(), and RPAlignmentCorrectionsMethods().

{
  // prepare output
  RPAlignmentCorrectionsDataSequence output;

  // load DOM tree
  try {
    XMLPlatformUtils::Initialize();
  } catch ( const XMLException& toCatch ) {
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "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("RPAlignmentCorrectionsMethods") << "Cannot parse file `" << fileName << "' (parser = NULL).";

  DOMDocument* xmlDoc = parser->getDocument();

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

  DOMElement* elementRoot = xmlDoc->getDocumentElement();
  if ( !elementRoot )
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "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("RPAlignmentCorrectionsMethods") << "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("RPAlignmentCorrectionsMethods") << ">> RPAlignmentCorrectionsDataSequence::loadFromXML > Warning: unknown attribute `"
          << attr_name << "'.";
    }

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

    // process data
    RPAlignmentCorrectionsData corrections = RPAlignmentCorrectionsMethods::getCorrectionsData( node );

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

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

  return output;
}

edm::IOVSyncValue RPAlignmentCorrectionsMethods::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 RPAlignmentCorrectionsMethods.cc.

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

Referenced by loadFromXML(), and writeToXML().

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

void RPAlignmentCorrectionsMethods::writeToXML ( const RPAlignmentCorrectionsDataSequence &  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 301 of file RPAlignmentCorrectionsMethods.cc.

References Exception, iovValueToString(), AlCaHLTBitMon_ParallelJobs::p, and writeXMLBlock().

Referenced by RPAlignmentCorrectionsMethods(), and writeToXML().

{
  FILE* rf = fopen( fileName.c_str(), "w" );
  if ( !rf )
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "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 );
}

static void RPAlignmentCorrectionsMethods::writeToXML ( const RPAlignmentCorrectionsData &  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 34 of file RPAlignmentCorrectionsMethods.h.

References edm::IOVSyncValue::beginOfTime(), data, edm::IOVSyncValue::endOfTime(), f, getCorrectionsData(), RPAlignmentCorrectionsDataSequence::insert(), iovValueToString(), hiDetachedQuadStep_cff::precise, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, stringToIOVValue(), writeToXML(), writeXML(), and writeXMLBlock().

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

void RPAlignmentCorrectionsMethods::writeXML ( const RPAlignmentCorrectionData &  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 416 of file RPAlignmentCorrectionsMethods.cc.

References RPAlignmentCorrectionData::getRotX(), RPAlignmentCorrectionData::getRotXUnc(), RPAlignmentCorrectionData::getRotY(), RPAlignmentCorrectionData::getRotYUnc(), RPAlignmentCorrectionData::getRotZ(), RPAlignmentCorrectionData::getRotZUnc(), RPAlignmentCorrectionData::getShX(), RPAlignmentCorrectionData::getShXUnc(), RPAlignmentCorrectionData::getShY(), RPAlignmentCorrectionData::getShYUnc(), RPAlignmentCorrectionData::getShZ(), RPAlignmentCorrectionData::getShZUnc(), and WRITE.

Referenced by writeToXML(), and 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 );
    }
  }
}

void RPAlignmentCorrectionsMethods::writeXMLBlock ( const RPAlignmentCorrectionsData &  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 331 of file RPAlignmentCorrectionsMethods.cc.

References CTPPSDetId::arm(), CTPPSDetId::getRPId(), RPAlignmentCorrectionsData::getRPMap(), RPAlignmentCorrectionsData::getSensorMap(), CTPPSPixelDetId::plane(), TotemRPDetId::plane(), CTPPSDiamondDetId::plane(), CTPPSDetId::rp(), 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.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");
    }
  }
}