RPAlignmentCorrectionsMethods Class Reference

#include <RPAlignmentCorrectionsMethods.h>

Public Member Functions
	RPAlignmentCorrectionsMethods ()

Static Public Member Functions
static RPAlignmentCorrectionsData	GetCorrectionsData (xercesc::DOMNode *)
static RPAlignmentCorrectionsData	GetCorrectionsDataFromFile (const std::string &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 26 of file RPAlignmentCorrectionsMethods.h.

Constructor & Destructor Documentation

RPAlignmentCorrectionsMethods::RPAlignmentCorrectionsMethods ( )

inline

Definition at line 30 of file RPAlignmentCorrectionsMethods.h.

References data, f, MillePedeFileConverter_cfg::fileName, hiDetachedTripletStep_cff::precise, and AlCaHLTBitMon_QueryRunRegistry::string.

{}

Member Function Documentation

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

static

Definition at line 88 of file RPAlignmentCorrectionsMethods.cc.

References a, RPAlignmentCorrectionsData::AddRPCorrection(), RPAlignmentCorrectionsData::AddSensorCorrection(), class-composition::children, Exception, i, j, gen::n, and mps_fire::result.

Referenced by RPAlignmentCorrectionsDataSequence::LoadXMLFile().

{
  RPAlignmentCorrectionsData result;
  
  DOMNodeList *children = root->getChildNodes();
  for (unsigned int i = 0; i < children->getLength(); i++)
  {
    DOMNode *n = children->item(i);
    if (n->getNodeType() != DOMNode::ELEMENT_NODE)
      continue;
   
    // check node type
    unsigned char nodeType = 0;
    if (!strcmp(XMLString::transcode(n->getNodeName()), "det")) nodeType = 1;
    if (!strcmp(XMLString::transcode(n->getNodeName()), "rp")) nodeType = 2;

    if (!nodeType)
      throw cms::Exception("RPAlignmentCorrectionsMethods") << "Unknown node `" << XMLString::transcode(n->getNodeName()) << "'.";

    // check children
    if (n->getChildNodes()->getLength() > 0)
    {
        edm::LogProblem("RPAlignmentCorrectionsMethods") << ">> RPAlignmentCorrectionsMethods::LoadXMLFile > Warning: tag `" <<
          XMLString::transcode(n->getNodeName()) << "' has " << n->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 decId = 0;
    bool idSet = false;

    // get attributes
    DOMNamedNodeMap* attr = n->getAttributes();
    for (unsigned int j = 0; j < attr->getLength(); j++)
    {    
      DOMNode *a = attr->item(j);
 
      //printf("\t%s\n", XMLString::transcode(a->getNodeName()));

      if (!strcmp(XMLString::transcode(a->getNodeName()), "id"))
      {
        decId = atoi(XMLString::transcode(a->getNodeValue()));
        idSet = true;
      } else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_r"))
          sh_r = atof(XMLString::transcode(a->getNodeValue()));
        else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_r_e"))
          sh_r_e = atof(XMLString::transcode(a->getNodeValue()));
          else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_x"))
            sh_x = atof(XMLString::transcode(a->getNodeValue()));
            else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_x_e"))
              sh_x_e = atof(XMLString::transcode(a->getNodeValue()));
              else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_y"))
                sh_y = atof(XMLString::transcode(a->getNodeValue()));
                else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_y_e"))
                  sh_y_e = atof(XMLString::transcode(a->getNodeValue()));
                  else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_z"))
                    sh_z = atof(XMLString::transcode(a->getNodeValue()));
                    else if (!strcmp(XMLString::transcode(a->getNodeName()), "sh_z_e"))
                      sh_z_e = atof(XMLString::transcode(a->getNodeValue()));
                      else if (!strcmp(XMLString::transcode(a->getNodeName()), "rot_z"))
                        rot_z = atof(XMLString::transcode(a->getNodeValue()));
                        else if (!strcmp(XMLString::transcode(a->getNodeName()), "rot_z_e"))
                          rot_z_e = atof(XMLString::transcode(a->getNodeValue()));
                        else
                          edm::LogProblem("RPAlignmentCorrectionsMethods") << ">> RPAlignmentCorrectionsMethods::LoadXMLFile > Warning: unknown attribute `"
                            << XMLString::transcode(a->getNodeName()) << "'.";
    }

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

    // build alignment
    RPAlignmentCorrectionData a(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)
    {
      const unsigned int arm = decId / 1000;
      const unsigned int st = (decId / 100) % 10;
      const unsigned int rp = (decId / 10) % 10;
      const unsigned int det = decId % 10;
      result.AddSensorCorrection(TotemRPDetId(arm, st, rp, det), a, true);
    }

    if (nodeType == 2)
    {
      const unsigned int arm = (decId / 100) % 10;
      const unsigned int st = (decId / 10) % 10;
      const unsigned int rp = decId % 10;
      result.AddRPCorrection(TotemRPDetId(arm, st, rp), a, true);
    }
  }

  return result;
}

RPAlignmentCorrectionsData RPAlignmentCorrectionsMethods::GetCorrectionsDataFromFile ( const std::string &  fileName )

static

Definition at line 35 of file RPAlignmentCorrectionsMethods.cc.

References edmIntegrityCheck::d, Exception, python.rootplot.argparse::message, createfilelist::parser, fetchall_from_DQM_v2::release, and AlCaHLTBitMon_QueryRunRegistry::string.

{
  printf(">> RPAlignmentCorrectionsMethods::LoadXMLFile(%s)\n", fileName.c_str());

  // prepend CMSSW src dir
  char *cmsswPath = getenv("CMSSW_BASE");
  size_t start = fileName.find_first_not_of("   ");
  string fn = fileName.substr(start);
  if (cmsswPath && fn[0] != '/' && fn.find("./") != 0)
    fn = string(cmsswPath) + string("/src/") + fn;

  // load DOM tree first the file
  try {
    XMLPlatformUtils::Initialize();
  }
  catch (const XMLException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "An XMLException caught with message: " << message << ".\n";
    XMLString::release(&message);
  }

  XercesDOMParser* parser = new XercesDOMParser();
  parser->setValidationScheme(XercesDOMParser::Val_Always);
  parser->setDoNamespaces(true);

  try {
    parser->parse(fn.c_str());
  }
  catch (...) {
    throw cms::Exception("RPAlignmentCorrectionsMethods") << "Cannot parse file `" << fn << "' (exception)." << endl;
  }

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

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

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

  RPAlignmentCorrectionsData d = GetCorrectionsData(elementRoot);

  XMLPlatformUtils::Terminate();

  return d;
}

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 197 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.

{
  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 297 of file RPAlignmentCorrectionsMethods.cc.

References RPAlignmentCorrectionsData::GetRPMap(), and RPAlignmentCorrectionsData::GetSensorMap().

Referenced by RPAlignmentCorrectionsDataSequence::WriteXMLFile().

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

  RPAlignmentCorrectionsData::mapType sensors = data.GetSensorMap();
  RPAlignmentCorrectionsData::mapType rps = data.GetRPMap();

  for (RPAlignmentCorrectionsData::mapType::const_iterator it = sensors.begin(); it != sensors.end(); ++it) {
    // start a RP block
    unsigned int rp = it->first / 10;
    if (firstRP || prevRP != rp) {
      if (!firstRP)
        fprintf(rf, "\n");
      firstRP = false;

      RPAlignmentCorrectionsData::mapType::const_iterator 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 (RPAlignmentCorrectionsData::mapType::const_iterator it = rps.begin(); it != rps.end(); ++it) {
    set<unsigned int>::iterator 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 &  , 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 277 of file RPAlignmentCorrectionsMethods.cc.

References Exception.

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

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