RPAlignmentCorrectionsMethods Class Reference

#include <RPAlignmentCorrectionsMethods.h>

Public Member Functions
	RPAlignmentCorrectionsMethods ()

Static Public Member Functions
static RPAlignmentCorrectionsData	getCorrectionsData (xercesc::DOMNode *)
static RPAlignmentCorrectionsData	getCorrectionsDataFromFile (const edm::FileInPath &fileName)
static void	writeXML (const RPAlignmentCorrectionData &data, FILE *f, bool precise, bool wrErrors, bool wrSh_r, bool wrSh_xy, bool wrSh_z, bool wrRot_z)
static void	writeXMLBlock (const RPAlignmentCorrectionsData &, FILE *, bool precise=false, bool wrErrors=true, bool wrSh_r=true, bool wrSh_xy=true, bool wrSh_z=true, bool wrRot_z=true)
	writes a block of corrections into a file More...
static void	writeXMLFile (const RPAlignmentCorrectionsData &, const std::string &fileName, bool precise=false, bool wrErrors=true, bool wrSh_r=true, bool wrSh_xy=true, bool wrSh_z=true, bool wrRot_z=true)
	writes corrections into a single XML file More...

Detailed Description

Definition at line 38 of file RPAlignmentCorrectionsMethods.h.

Constructor & Destructor Documentation

RPAlignmentCorrectionsMethods::RPAlignmentCorrectionsMethods ( )

inline

Definition at line 41 of file RPAlignmentCorrectionsMethods.h.

References data, f, MillePedeFileConverter_cfg::fileName, getCorrectionsData(), getCorrectionsDataFromFile(), hiDetachedQuadStep_cff::precise, AlCaHLTBitMon_QueryRunRegistry::string, writeXML(), writeXMLBlock(), and writeXMLFile().

{}

Member Function Documentation

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

static

Definition at line 49 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 getCorrectionsDataFromFile(), RPAlignmentCorrectionsDataSequence::loadXMLFile(), and RPAlignmentCorrectionsMethods().

{
  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_r = 0., sh_x = 0., sh_y = 0., sh_z = 0., rot_z = 0.;
    double sh_r_e = 0., sh_x_e = 0., sh_y_e = 0., sh_z_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_r"    ) sh_r    = cms::xerces::toDouble( a->getNodeValue() );
      else if ( node_name == "sh_r_e"  ) sh_r_e  = cms::xerces::toDouble( a->getNodeValue() );
      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_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::LoadXMLFile > 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_r*1e-3, sh_r_e*1e-3,
      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_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;
}

RPAlignmentCorrectionsData RPAlignmentCorrectionsMethods::getCorrectionsDataFromFile ( const edm::FileInPath &  fileName )

static

Definition at line 14 of file RPAlignmentCorrectionsMethods.cc.

References Exception, edm::FileInPath::fullPath(), getCorrectionsData(), and createfilelist::parser.

Referenced by RPAlignmentCorrectionsMethods().

{
  edm::LogInfo("RPAlignmentCorrectionsMethods")
    << "LoadXMLFile(" << fileName << ")";

  // load DOM tree first the file
  XMLPlatformUtils::Initialize();

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

  if ( !parser )
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "Cannot parse file `" << fileName.fullPath() << "' (parser = NULL).";
  
  DOMDocument* xmlDoc = parser->getDocument();

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

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

  RPAlignmentCorrectionsData corr_data = getCorrectionsData( elementRoot );

  XMLPlatformUtils::Terminate();

  return corr_data;
}

void RPAlignmentCorrectionsMethods::writeXML ( const RPAlignmentCorrectionData &  data, FILE *  f, bool  precise, bool  wrErrors, bool  wrSh_r, bool  wrSh_xy, bool  wrSh_z, bool  wrRot_z  )

static

Definition at line 139 of file RPAlignmentCorrectionsMethods.cc.

References RPAlignmentCorrectionData::rot_z(), RPAlignmentCorrectionData::rot_z_e(), RPAlignmentCorrectionData::sh_r(), RPAlignmentCorrectionData::sh_r_e(), RPAlignmentCorrectionData::sh_x(), RPAlignmentCorrectionData::sh_x_e(), RPAlignmentCorrectionData::sh_y(), RPAlignmentCorrectionData::sh_y_e(), RPAlignmentCorrectionData::sh_z(), RPAlignmentCorrectionData::sh_z_e(), and WRITE.

Referenced by RPAlignmentCorrectionsMethods(), and writeXMLBlock().

{
  if ( wrSh_r ) {
    WRITE( data.sh_r, 2, 0.1 );
    if (wrErrors) {
      WRITE( data.sh_r_e, 2, 0.1 );
    }
    /*
    fprintf(f, " sh_r=\"%+8.2f\"", data.sh_r()*1E3);
    if (wrErrors)
      if (fabs(data.sh_r_e())*1E3 < 0.1)
        fprintf(f, " sh_r_e=\"%+8.1E\"", data.sh_r_e()*1E3);
      else
        fprintf(f, " sh_r_e=\"%+8.2f\"", data.sh_r_e()*1E3);
    */
  }

  if ( wrSh_xy ) {
    WRITE( data.sh_x, 2, 0.1 );
    WRITE( data.sh_y, 2, 0.1 );
    if ( wrErrors ) {
      WRITE( data.sh_x_e, 2, 0.1 );
      WRITE( data.sh_y_e, 2, 0.1 );
    }
    /*
    fprintf(f, " sh_x=\"%+8.2f\" sh_y=\"%+8.2f\"", data.sh_x()*1E3, data.sh_y()*1E3);
    if (wrErrors) {
      if (fabs(data.sh_x_e())*1E3 < 0.1)
        fprintf(f, " sh_x_e=\"%+8.1E\"", data.sh_x_e()*1E3);
      else
        fprintf(f, " sh_x_e=\"%+8.2f\"", data.sh_x_e()*1E3);

      if (fabs(data.sh_y_e())*1E3 < 0.1)
        fprintf(f, " sh_y_e=\"%+8.1E\"", data.sh_y_e()*1E3);
      else
        fprintf(f, " sh_y_e=\"%+8.2f\"", data.sh_y_e()*1E3);
    }
    */
  }

  // TODO: add the other 2 rotations

  if ( wrRot_z ) {
    WRITE( data.rot_z, 3, 0.01 );
    if ( wrErrors ) {
      WRITE( data.rot_z_e, 3, 0.01 );
    }
    /*
    fprintf(f, " rot_z=\"%+8.3f\"", data.rot_z()*1E3);
    if (wrErrors)
      if (fabs(data.rot_z_e())*1E3 < 0.01)
        fprintf(f, " rot_z_e=\"%+8.1E\"", data.rot_z_e()*1E3);
      else
        fprintf(f, " rot_z_e=\"%+8.3f\"", data.rot_z_e()*1E3);
    */
  }

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

    /*
    fprintf(f, " sh_z=\"%+8.2f\"", data.sh_z()*1E3);
    if (wrErrors)
      if (fabs(data.sh_z_e())*1E3 < 0.1)
        fprintf(f, " sh_z_e=\"%+8.1E\"", data.sh_z_e()*1E3);
      else
        fprintf(f, " sh_z_e=\"%+8.2f\"", data.sh_z_e()*1E3);
    */
  }
}

void RPAlignmentCorrectionsMethods::writeXMLBlock ( const RPAlignmentCorrectionsData &  data, FILE *  rf, bool  precise = false, bool  wrErrors = true, bool  wrSh_r = true, bool  wrSh_xy = true, bool  wrSh_z = true, bool  wrRot_z = true  )

static

writes a block of corrections into a file

Definition at line 241 of file RPAlignmentCorrectionsMethods.cc.

References RPAlignmentCorrectionsData::getRPMap(), RPAlignmentCorrectionsData::getSensorMap(), and writeXML().

Referenced by RPAlignmentCorrectionsMethods(), writeXMLFile(), and RPAlignmentCorrectionsDataSequence::writeXMLFile().

{
  bool firstRP = true;
  unsigned int prevRP = 0;
  std::set<unsigned int> writtenRPs;

  RPAlignmentCorrectionsData::mapType sensors = data.getSensorMap();
  RPAlignmentCorrectionsData::mapType rps = data.getRPMap();

  for ( const auto& it : sensors ) {
    // start a RP block
    unsigned int rp = it.first / 10;
    if ( firstRP || prevRP != rp ) {
      if ( !firstRP ) fprintf( rf, "\n" );
      firstRP = false;

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

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

  // write remaining RPs
  for ( const auto& it : rps ) {
    const auto& wit = writtenRPs.find( it.first );
    if ( wit == writtenRPs.end() ) {
      fprintf( rf, "\t<rp  id=\"%4u\"                                ", it.first );
      writeXML( it.second, rf, precise, wrErrors, false, wrSh_xy, wrSh_z, wrRot_z );
      fprintf( rf, "/>\n" );
    }
  }
}

void RPAlignmentCorrectionsMethods::writeXMLFile ( const RPAlignmentCorrectionsData &  data, const std::string &  fileName, bool  precise = false, bool  wrErrors = true, bool  wrSh_r = true, bool  wrSh_xy = true, bool  wrSh_z = true, bool  wrRot_z = true  )

static

writes corrections into a single XML file

Definition at line 221 of file RPAlignmentCorrectionsMethods.cc.

References Exception, and writeXMLBlock().

Referenced by RPAlignmentCorrectionsMethods().

{
  FILE* rf = fopen( fileName.c_str(), "w" );
  if ( !rf )
    throw cms::Exception("RPAlignmentCorrections::writeXMLFile") << "Cannot open file `" << fileName << "' to save alignments.";

  fprintf( rf, "<!--\nShifts in um, rotations in mrad.\n\nFor more details see RPAlignmentCorrections::LoadXMLFile in\n" );
  fprintf( rf, "Alignment/RPDataFormats/src/RPAlignmentCorrectionsSequence.cc\n-->\n\n" );
  fprintf( rf, "<xml DocumentType=\"AlignmentDescription\">\n" );

  writeXMLBlock( data, rf, precise, wrErrors, wrSh_r, wrSh_xy, wrSh_z, wrRot_z );

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