DetectorFileMantid.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "DetectorFile.h"
#include "NeXusFile.hpp"

// name of xml file  /mantid_workspace_1/instrument/instrument_source
// xml info  /mantid_workspace_1/instrument/instrument_xml/data
// parameter map info  /mantid_workspace_1/instrument/instrument_parameter_map/data
// name  /mantid_workspace_1/instrument/name
// 
//   /mantid_workspace_1/instrument/physical_detectors/azimuthal_angle    float64
//   /mantid_workspace_1/instrument/physical_detectors/detector_number    in32
//   /mantid_workspace_1/instrument/physical_detectors/distance
//   /mantid_workspace_1/instrument/physical_detectors/polar_angle
//   
// same for physical_monitors
//
//

        DetectorFileMantid::DetectorFileMantid(const char* filename) : m_nlines(0), m_nuse(0), m_good(false), m_file(0), m_current_line(0)
        {
                setLoggerName("DetectorFileMantid");
                uint64_t number_of_detectors = 0, number_of_monitors = 0;
                try
                {
                        m_file = new NeXus::File(filename);
                }
                catch(const std::exception& ex)
                {
                        LOGSTR_ERROR("error opening \"" << filename <<"\": " << ex.what());
                        return;
                }
                try
                {
                        getItem("/mantid_workspace_1/instrument/physical_detectors/azimuthal_angle", m_azimuthal_angle);
                        getItem("/mantid_workspace_1/instrument/physical_detectors/polar_angle", m_polar_angle);
                        getItem("/mantid_workspace_1/instrument/physical_detectors/distance", m_distance);
                        getItem("/mantid_workspace_1/instrument/physical_detectors/detector_number", m_detector_number);
                        getItem("/mantid_workspace_1/instrument/physical_detectors/number_of_detectors", number_of_detectors);
                        if ( number_of_detectors != m_detector_number.size() )
                        {
                                throw std::runtime_error("number of detectors");
                        }
                        std::vector<double> dbl_vec;
                        std::vector<int32_t> int32_vec;
                        getItem("/mantid_workspace_1/instrument/physical_monitors/azimuthal_angle", dbl_vec);
                        m_azimuthal_angle.insert(m_azimuthal_angle.end(), dbl_vec.begin(), dbl_vec.end());
                        getItem("/mantid_workspace_1/instrument/physical_monitors/polar_angle", dbl_vec);
                        m_polar_angle.insert(m_polar_angle.end(), dbl_vec.begin(), dbl_vec.end());
                        getItem("/mantid_workspace_1/instrument/physical_monitors/distance", dbl_vec);
                        m_distance.insert(m_distance.end(), dbl_vec.begin(), dbl_vec.end());
                        getItem("/mantid_workspace_1/instrument/physical_monitors/detector_number", int32_vec);
                        m_detector_number.insert(m_detector_number.end(), int32_vec.begin(), int32_vec.end());
                        getItem("/mantid_workspace_1/instrument/physical_monitors/number_of_monitors", number_of_monitors);
                        if ( number_of_monitors != int32_vec.size() )
                        {
                                throw std::runtime_error("number of monitors");
                        }
                        getItem("/mantid_workspace_1/instrument/instrument_source", m_instrument_xml_file_name);
                        getItem("/mantid_workspace_1/instrument/instrument_xml/data", m_instrument_xml);  // instrument_xml is an NXnote
                        getItem("/mantid_workspace_1/instrument/instrument_parameter_map/data", m_instrument_parameter_map);  // instrument_parameter_map is an NXnote
                        getItem("/mantid_workspace_1/instrument/name", m_instrument_name);
                        m_nuse = 1;  // one user table, for phi(m_azimuthal_angle)
                        m_nlines = number_of_detectors + number_of_monitors;
                        m_good = true;
                }
                catch(const std::exception& ex)
                {
                        LOGSTR_ERROR("error loading from \"" << filename <<"\": " << ex.what());
                        m_good = false;
                }
                m_file->close();
        }

        template <typename T>
        void DetectorFileMantid::getItem(const std::string& name, std::vector<T>& value)
        {
                m_file->openPath(name);
                m_file->getData(value);
        }

        template <typename T>
        void DetectorFileMantid::getItem(const std::string& name, T& value)
        {
                m_file->openPath(name);
                m_file->getData(&value);    // doesn't check type, so use temporary vector
//              std::vector<T> tvec(1);
//              m_file->getData(tvec);
//              value = tvec.front();
        }

        template <>
        void DetectorFileMantid::getItem(const std::string& name, std::string& value)
        {
                m_file->openPath(name);
                value = m_file->getStrData();
        }

        void DetectorFileMantid::readLine(int& det_no, DETECTOR& det)
        {
                if ( m_good && (m_current_line < m_nlines) )
                {
                        det_no = m_detector_number[m_current_line];
                        det.code = 0;
                        det.l2 = m_distance[m_current_line];
                        det.theta = m_polar_angle[m_current_line];
                        det.offset = 0.0;
                        det.ut[0] = m_azimuthal_angle[m_current_line];
                        ++m_current_line;
                }
                else
                {
                        m_good = false;
                        det_no = 0;
                        memset(&det, 0, sizeof(det));
                }
        }

        DetectorFileMantid::~DetectorFileMantid()
        {
                delete m_file;
                m_file = 0;
        }