C++ Instrument_const_sptr::getName方法代码示例

int MaskPeaksWorkspace::findPixelID(std::string bankName, int col, int row) {
  Geometry::Instrument_const_sptr Iptr = m_inputW->getInstrument();
  boost::shared_ptr<const IComponent> parent =
      Iptr->getComponentByName(bankName);
  if (parent->type().compare("RectangularDetector") == 0) {
    boost::shared_ptr<const RectangularDetector> RDet =
        boost::dynamic_pointer_cast<const RectangularDetector>(parent);

    boost::shared_ptr<Detector> pixel = RDet->getAtXY(col, row);
    return pixel->getID();
  } else {
    std::string bankName0 = bankName;
    // Only works for WISH
    bankName0.erase(0, 4);
    std::ostringstream pixelString;
    pixelString << Iptr->getName() << "/" << bankName0 << "/" << bankName
                << "/tube" << std::setw(3) << std::setfill('0') << col
                << "/pixel" << std::setw(4) << std::setfill('0') << row;
    boost::shared_ptr<const Geometry::IComponent> component =
        Iptr->getComponentByName(pixelString.str());
    boost::shared_ptr<const Detector> pixel =
        boost::dynamic_pointer_cast<const Detector>(component);
    return pixel->getID();
  }
}

void SaveDetectorsGrouping::printToXML(std::map<int, std::vector<detid_t> > groupdetidrangemap, std::string xmlfilename) {

    // 1. Get Instrument information
    Geometry::Instrument_const_sptr instrument = mGroupWS->getInstrument();
    std::string name = instrument->getName();
    g_log.debug() << "Instrument " << name << std::endl;

    // 2. Start document (XML)
    AutoPtr<Document> pDoc = new Document;
    AutoPtr<Element> pRoot = pDoc->createElement("detector-grouping");
    pDoc->appendChild(pRoot);
    pRoot->setAttribute("instrument", name);

    // Set description if was specified by user
    if(mGroupWS->run().hasProperty("Description"))
    {
        std::string description = mGroupWS->run().getProperty("Description")->value();
        pRoot->setAttribute("description", description);
    }

    // 3. Append Groups
    for (std::map<int, std::vector<detid_t> >::iterator it = groupdetidrangemap.begin();
            it != groupdetidrangemap.end(); ++it) {

        // a) Group Node
        int groupid = it->first;
        std::stringstream sid;
        sid << groupid;

        AutoPtr<Element> pChildGroup = pDoc->createElement("group");
        pChildGroup->setAttribute("ID",  sid.str());
        // Set name if was specified by user
        std::string groupNameProp = "GroupName_" + sid.str();
        if(mGroupWS->run().hasProperty(groupNameProp))
        {
            std::string groupName = mGroupWS->run().getProperty(groupNameProp)->value();
            pChildGroup->setAttribute("name", groupName);
        }

        pRoot->appendChild(pChildGroup);

        g_log.debug() << "Group ID = " << groupid << std::endl;

        // b) Detector ID Child Nodes
        std::stringstream ss;

        for (size_t i = 0; i < it->second.size()/2; i ++)
        {
            // i. Generate text value

            bool writedata = true;
            detid_t ist = it->second[i*2];
            detid_t ied = it->second[i*2+1];
            // "a-b" or "a"
            if (ist < ied) {
                ss << ist << "-" << ied;
            } else if (ist == ied) {
                ss << ist;
            } else {
                writedata = false;
                g_log.error() << "Impossible to have this situation!" << std::endl;
                throw std::invalid_argument("Impossible to have this sitaution!");
            }
            // add ","
            if (writedata && i < it->second.size()/2-1) {
                ss << ",";
            }

            g_log.debug() << "Detectors:  " << it->second[i*2] << ", " << it->second[i*2+1] << std::endl;
        } // FOREACH Detectors Range Set


        std::string textvalue = ss.str();

        g_log.debug() << "Detector IDs Node: " << textvalue << std::endl;

        // c) Create element
        AutoPtr<Element> pDetid = pDoc->createElement("detids");
        AutoPtr<Text> pText1 = pDoc->createTextNode(textvalue);
        pDetid->appendChild(pText1);
        pChildGroup->appendChild(pDetid);

    } // FOREACH GroupID

    // 4. Write file
    DOMWriter writer;
    writer.setNewLine("\n");
    writer.setOptions(XMLWriter::PRETTY_PRINT);

    std::ofstream ofs;
    ofs.open(xmlfilename.c_str(), std::fstream::out);

    ofs << "<?xml version=\"1.0\"?>\n";

    writer.writeNode(std::cout, pDoc);
    writer.writeNode(ofs, pDoc);
    ofs.close();

}

/** method does preliminary calculations of the detectors positions to convert
results into k-dE space ;
and places the results into static cash to be used in subsequent calls to this
algorithm */
void PreprocessDetectorsToMD::processDetectorsPositions(
    const API::MatrixWorkspace_const_sptr &inputWS,
    DataObjects::TableWorkspace_sptr &targWS) {
  g_log.information()
      << "Preprocessing detector locations in a target reciprocal space\n";
  //
  Geometry::Instrument_const_sptr instrument = inputWS->getInstrument();
  // this->pBaseInstr                = instrument->baseInstrument();
  //
  Geometry::IComponent_const_sptr source = instrument->getSource();
  Geometry::IComponent_const_sptr sample = instrument->getSample();
  if ((!source) || (!sample)) {
    g_log.error() << " Instrument is not fully defined. Can not identify "
                     "source or sample\n";
    throw Kernel::Exception::InstrumentDefinitionError(
        "Instrument not sufficiently defined: failed to get source and/or "
        "sample");
  }

  // L1
  try {
    double L1 = source->getDistance(*sample);
    targWS->logs()->addProperty<double>("L1", L1, true);
    g_log.debug() << "Source-sample distance: " << L1 << '\n';
  } catch (Kernel::Exception::NotFoundError &) {
    throw Kernel::Exception::InstrumentDefinitionError(
        "Unable to calculate source-sample distance for workspace",
        inputWS->getTitle());
  }
  // Instrument name
  std::string InstrName = instrument->getName();
  targWS->logs()->addProperty<std::string>(
      "InstrumentName", InstrName,
      true); // "The name which should unique identify current instrument");
  targWS->logs()->addProperty<bool>("FakeDetectors", false, true);

  // get access to the workspace memory
  auto &sp2detMap = targWS->getColVector<size_t>("spec2detMap");
  auto &detId = targWS->getColVector<int32_t>("DetectorID");
  auto &detIDMap = targWS->getColVector<size_t>("detIDMap");
  auto &L2 = targWS->getColVector<double>("L2");
  auto &TwoTheta = targWS->getColVector<double>("TwoTheta");
  auto &Azimuthal = targWS->getColVector<double>("Azimuthal");
  auto &detDir = targWS->getColVector<Kernel::V3D>("DetDirections");

  // Efixed; do we need one and does one exist?
  double Efi = targWS->getLogs()->getPropertyValueAsType<double>("Ei");
  float *pEfixedArray(nullptr);
  const Geometry::ParameterMap &pmap = inputWS->constInstrumentParameters();
  if (m_getEFixed)
    pEfixedArray = targWS->getColDataArray<float>("eFixed");

  // check if one needs to generate masked detectors column.
  int *pMasksArray(nullptr);
  if (m_getIsMasked)
    pMasksArray = targWS->getColDataArray<int>("detMask");

  //// progress message appearance
  size_t div = 100;
  size_t nHist = targWS->rowCount();
  Mantid::API::Progress theProgress(this, 0, 1, nHist);
  //// Loop over the spectra
  uint32_t liveDetectorsCount(0);
  const auto &spectrumInfo = inputWS->spectrumInfo();
  for (size_t i = 0; i < nHist; i++) {
    sp2detMap[i] = std::numeric_limits<uint64_t>::quiet_NaN();
    detId[i] = std::numeric_limits<int32_t>::quiet_NaN();
    detIDMap[i] = std::numeric_limits<uint64_t>::quiet_NaN();
    L2[i] = std::numeric_limits<double>::quiet_NaN();
    TwoTheta[i] = std::numeric_limits<double>::quiet_NaN();
    Azimuthal[i] = std::numeric_limits<double>::quiet_NaN();
    //     detMask[i]  = true;

    if (!spectrumInfo.hasDetectors(i) || spectrumInfo.isMonitor(i))
      continue;

    // if masked detectors state is not used, masked detectors just ignored;
    bool maskDetector = spectrumInfo.isMasked(i);
    if (m_getIsMasked)
      *(pMasksArray + liveDetectorsCount) = maskDetector ? 1 : 0;
    else if (maskDetector)
      continue;

    const auto &spDet = spectrumInfo.detector(i);

    // calculate the requested values;
    sp2detMap[i] = liveDetectorsCount;
    detId[liveDetectorsCount] = int32_t(spDet.getID());
    detIDMap[liveDetectorsCount] = i;
    L2[liveDetectorsCount] = spectrumInfo.l2(i);

    double polar = spectrumInfo.twoTheta(i);
    double azim = spDet.getPhi();
    TwoTheta[liveDetectorsCount] = polar;
    Azimuthal[liveDetectorsCount] = azim;

//.........这里部分代码省略.........