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 ( )

inline

Definition at line 25 of file CTPPSRPAlignmentCorrectionsMethods.h.

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

{}

Member Function Documentation

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

staticprotected

load corrections data corresponding to one IOV

Definition at line 209 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References a, CTPPSRPAlignmentCorrectionsData::addRPCorrection(), CTPPSRPAlignmentCorrectionsData::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().

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

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

static

Definition at line 92 of file CTPPSRPAlignmentCorrectionsMethods.cc.

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

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXML::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;
}

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

static

loads sequence of alignment corrections from XML file

Definition at line 108 of file CTPPSRPAlignmentCorrectionsMethods.cc.

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

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

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 75 of file CTPPSRPAlignmentCorrectionsMethods.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 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 299 of file CTPPSRPAlignmentCorrectionsMethods.cc.

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

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

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 36 of file CTPPSRPAlignmentCorrectionsMethods.h.

References edm::IOVSyncValue::beginOfTime(), data, edm::IOVSyncValue::endOfTime(), f, getCorrectionsData(), CTPPSRPAlignmentCorrectionsDataSequence::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());
      CTPPSRPAlignmentCorrectionsDataSequence s;
      s.insert(iov, ad);
      writeToXML(s, fileName, precise, wrErrors, wrSh_xy, wrSh_z, wrRot_xy, wrRot_z);
    }

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 412 of file CTPPSRPAlignmentCorrectionsMethods.cc.

References CTPPSRPAlignmentCorrectionData::getRotX(), CTPPSRPAlignmentCorrectionData::getRotXUnc(), CTPPSRPAlignmentCorrectionData::getRotY(), CTPPSRPAlignmentCorrectionData::getRotYUnc(), CTPPSRPAlignmentCorrectionData::getRotZ(), CTPPSRPAlignmentCorrectionData::getRotZUnc(), CTPPSRPAlignmentCorrectionData::getShX(), CTPPSRPAlignmentCorrectionData::getShXUnc(), CTPPSRPAlignmentCorrectionData::getShY(), CTPPSRPAlignmentCorrectionData::getShYUnc(), CTPPSRPAlignmentCorrectionData::getShZ(), CTPPSRPAlignmentCorrectionData::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 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 327 of file CTPPSRPAlignmentCorrectionsMethods.cc.

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