Exemplo n.º 1
0
/** This method saves investigations  to a table workspace
 *  @param investigations :: a vector containing investigation data
 *  @param outputws :: shared pointer to output workspace
 */
void CICatHelper::saveInvestigations(
    const std::vector<ns1__investigation *> &investigations,
    API::ITableWorkspace_sptr &outputws) {
  try {
    std::vector<ns1__investigation *>::const_iterator citr;
    for (citr = investigations.begin(); citr != investigations.end(); ++citr) {
      API::TableRow t = outputws->appendRow();

      std::string id = std::to_string(*(*citr)->id);

      savetoTableWorkspace(&id, t);
      savetoTableWorkspace((*citr)->facility, t);
      savetoTableWorkspace((*citr)->title, t);
      savetoTableWorkspace((*citr)->instrument, t);
      savetoTableWorkspace((*citr)->invParamValue, t);

      std::string startDate = std::to_string(*(*citr)->invStartDate);
      savetoTableWorkspace(&startDate, t);

      std::string endDate = std::to_string(*(*citr)->invEndDate);
      savetoTableWorkspace(&endDate, t);

      std::string sessionID = m_session->getSessionId();
      savetoTableWorkspace(&sessionID, t);
    }
  } catch (std::runtime_error &) {
    throw std::runtime_error(
        "Error when saving  the ICat Search Results data to Workspace");
  }
}
Exemplo n.º 2
0
void EnggDiffFittingModel::mergeTables(
    const API::ITableWorkspace_sptr tableToCopy,
    API::ITableWorkspace_sptr targetTable) const {
  for (size_t i = 0; i < tableToCopy->rowCount(); ++i) {
    API::TableRow rowToCopy = tableToCopy->getRow(i);
    API::TableRow newRow = targetTable->appendRow();

    for (size_t j = 0; j < tableToCopy->columnCount(); ++j) {
      double valueToCopy;
      rowToCopy >> valueToCopy;
      newRow << valueToCopy;
    }
  }
}
Exemplo n.º 3
0
/**
   Read from the instrument file the dead wires and store the information in a TableWorkspace.
   If asked, the dead wires are removed from the data set.

   @param localWorkspace :: input raw data workspace, containing the information about the instrument
   @param outputws :: input dead wire liste workspace
  */
void PoldiRemoveDeadWires::runExcludWires3
(
    DataObjects::Workspace2D_sptr &localWorkspace,
    API::ITableWorkspace_sptr &outputws
)
{
    outputws->addColumn("int","DeadWires");

    boost::shared_ptr<const Mantid::Geometry::IComponent> comp = localWorkspace->getInstrument()->getComponentByName("holder");
    boost::shared_ptr<const Mantid::Geometry::ICompAssembly> bank = boost::dynamic_pointer_cast<const Mantid::Geometry::ICompAssembly>(comp);
    if (bank)
    {
        // Get a vector of children (recursively)
        std::vector<boost::shared_ptr<const Mantid::Geometry::IComponent> > children;
        bank->getChildren(children, true);

        std::vector<double> defaultDeadWires;
        int ewLine = 0;

        for (unsigned int it = 0; it < children.size(); ++it)
        {
            string wireName = children.at(it)->getName();
            std::vector<boost::shared_ptr<const Mantid::Geometry::IComponent> > tyty =
                localWorkspace.get()->getInstrument().get()->getAllComponentsWithName(wireName);

            std::vector<double> tempWire = tyty[0]->getNumberParameter("excluded");
            if(tempWire.size()>0) {
                int val = (int)tempWire[0];
                g_log.debug() << "_poldi : dead wires :" << val <<  std::endl;
                defaultDeadWires.push_back(val);
                for(unsigned int j=0; j<m_channelsPerSpectrum; j++) {
                    localWorkspace->maskBin(val-1,j,1);
                }
                ewLine++;


                TableRow t = outputws->appendRow();
                t << val ;

            }
        }
        g_log.information() << "_poldi : dead wires set to 0 (nb:" << ewLine << ")" <<  std::endl;
        setProperty("nbExcludedWires",ewLine);
    } else {
        g_log.information() << "_poldi : no dead wire removed" <<  std::endl;
    }
}
Exemplo n.º 4
0
/**
 * Loops through the response vector and saves the datasets details to a table
 * workspace.
 * @param response :: A vector containing the results of the search query.
 * @param outputws :: Shared pointer to output workspace.
 */
void ICat4Catalog::saveDataSets(std::vector<xsd__anyType *> response,
                                API::ITableWorkspace_sptr &outputws) {
  if (outputws->getColumnNames().empty()) {
    // Add rows headers to the output workspace.
    outputws->addColumn("long64", "ID");
    outputws->addColumn("str", "Name");
    outputws->addColumn("str", "Description");
    outputws->addColumn("str", "Type");
    outputws->addColumn("str", "Related investigation ID");
    outputws->addColumn("size_t", "Number of datafiles");
  }

  std::string emptyCell;
  for (auto &iter : response) {
    ns1__dataset *dataset = dynamic_cast<ns1__dataset *>(iter);
    if (dataset) {
      API::TableRow table = outputws->appendRow();

      savetoTableWorkspace(dataset->id, table);
      savetoTableWorkspace(dataset->name, table);

      if (dataset->description)
        savetoTableWorkspace(dataset->description, table);
      else
        savetoTableWorkspace(&emptyCell, table);

      if (dataset->type)
        savetoTableWorkspace(dataset->type->name, table);
      else
        savetoTableWorkspace(&emptyCell, table);

      if (dataset->investigation)
        savetoTableWorkspace(dataset->investigation->name, table);
      else
        savetoTableWorkspace(&emptyCell, table);

      size_t datafileCount = dataset->datafiles.size();
      savetoTableWorkspace(&datafileCount, table);
    } else {
      throw std::runtime_error("ICat4Catalog::saveDataSets expected a dataset. "
                               "Please contact the Mantid development team.");
    }
  }
}
Exemplo n.º 5
0
    /** This method loops through the response return_vector and saves the datasets details to a table workspace
     * @param response :: const reference to response object
     * @param outputws ::  shred pointer to workspace
     * @returns shared pointer to table workspace which stores the data
     */
    void  CICatHelper::saveDataSets(const ns1__getInvestigationIncludesResponse& response,API::ITableWorkspace_sptr& outputws)
    {
      //create table workspace
      if (outputws->getColumnNames().empty())
      {
        outputws->addColumn("str","Name");//File name
        outputws->addColumn("str","Status");
        outputws->addColumn("str","Type");
        outputws->addColumn("str","Description");
        outputws->addColumn("long64","Sample Id");
      }
      try
      {

        std::vector<ns1__dataset*> datasetVec;
        datasetVec.assign((response.return_)->datasetCollection.begin(),(response.return_)->datasetCollection.end());

        std::vector<ns1__dataset*>::const_iterator dataset_citr;
        for(dataset_citr=datasetVec.begin();dataset_citr!=datasetVec.end();++dataset_citr)
        {
          API::TableRow t = outputws->appendRow();

          // DataSet Name
          savetoTableWorkspace((*dataset_citr)->name,t);
          // DataSet Status
          savetoTableWorkspace((*dataset_citr)->datasetStatus,t);
          //DataSet Type
          savetoTableWorkspace((*dataset_citr)->datasetType,t);
          //DataSet Type
          savetoTableWorkspace((*dataset_citr)->description,t);
          //DataSet Type
          savetoTableWorkspace((*dataset_citr)->sampleId,t);
        }
      }

      catch(std::runtime_error& )
      {
        throw;
      }

      //return outputws;
    }
Exemplo n.º 6
0
/**
 * Saves result from "getDataFiles" to workspace.
 * @param response :: result response from the catalog.
 * @param outputws :: shared pointer to datasets
 */
void ICat4Catalog::saveDataFiles(std::vector<xsd__anyType *> response,
                                 API::ITableWorkspace_sptr &outputws) {
  if (outputws->getColumnNames().empty()) {
    // Add rows headers to the output workspace.
    outputws->addColumn("str", "Name");
    outputws->addColumn("str", "Location");
    outputws->addColumn("str", "Create Time");
    outputws->addColumn("long64", "Id");
    outputws->addColumn("long64", "File size(bytes)");
    outputws->addColumn("str", "File size");
    outputws->addColumn("str", "Description");
  }

  std::vector<xsd__anyType *>::const_iterator iter;
  for (iter = response.begin(); iter != response.end(); ++iter) {
    ns1__datafile *datafile = dynamic_cast<ns1__datafile *>(*iter);
    if (datafile) {
      API::TableRow table = outputws->appendRow();
      // Now add the relevant investigation data to the table.
      savetoTableWorkspace(datafile->name, table);
      savetoTableWorkspace(datafile->location, table);

      std::string createDate =
          formatDateTime(*datafile->createTime, "%Y-%m-%d %H:%M:%S");
      savetoTableWorkspace(&createDate, table);

      savetoTableWorkspace(datafile->id, table);
      savetoTableWorkspace(datafile->fileSize, table);

      std::string fileSize = bytesToString(*datafile->fileSize);
      savetoTableWorkspace(&fileSize, table);

      if (datafile->description)
        savetoTableWorkspace(datafile->description, table);
    } else {
      throw std::runtime_error("ICat4Catalog::saveDataFiles expected a "
                               "datafile. Please contact the Mantid "
                               "development team.");
    }
  }
}
Exemplo n.º 7
0
/** Extracts detector asymmetries and phases from fitting results
* and adds a new row to the results table with them
* @param paramTab :: [input] Output parameter table resulting from the fit
* @param resultsTab :: [input] Results table to update with a new row
* @param spectrumNumber :: [input] Spectrum number
*/
void CalMuonDetectorPhases::extractDetectorInfo(
    const API::ITableWorkspace_sptr &paramTab,
    const API::ITableWorkspace_sptr &resultsTab,
    const specnum_t spectrumNumber) {

  double asym = paramTab->Double(0, 1);
  double phase = paramTab->Double(2, 1);
  // If asym<0, take the absolute value and add \pi to phase
  // f(x) = A * sin( w * x + p) = -A * sin( w * x + p + PI)
  if (asym < 0) {
    asym = -asym;
    phase = phase + M_PI;
  }
  // Now convert phases to interval [0, 2PI)
  int factor = static_cast<int>(floor(phase / 2 / M_PI));
  if (factor) {
    phase = phase - factor * 2 * M_PI;
  }
  // Copy parameters to new row in results table
  API::TableRow row = resultsTab->appendRow();
  row << static_cast<int>(spectrumNumber) << asym << phase;
}
Exemplo n.º 8
0
/** Load PhaseTable file to a vector of HistData.
* @param phaseTable :: [input] phase table containing detector info
* @param deadTimeTable :: [output] phase table containing dead times
*/
void PhaseQuadMuon::loadPhaseTable(API::ITableWorkspace_sptr phaseTable, API::ITableWorkspace_sptr deadTimeTable)
{
  if ( phaseTable->rowCount() )
  {
    if ( phaseTable->columnCount()<4 )
    {
      throw std::invalid_argument("PhaseQuad: PhaseTable must contain at least four columns");
    }

    // Check number of histograms in inputWs match number of detectors in phase table
    if (m_nHist != static_cast<int>(phaseTable->rowCount()))
    {
      throw std::runtime_error("PhaseQuad: Number of histograms in phase table does not match number of spectra in workspace");
    }

    for (size_t i=0; i<phaseTable->rowCount(); ++i)
    {
      API::TableRow phaseRow = phaseTable->getRow(i);

      // The first three columns go to m_histData
      HistData tempHist;
      tempHist.detOK = phaseRow.Bool(0);
      tempHist.alpha = phaseRow.Double(1);
      tempHist.phi   = phaseRow.Double(2);
      m_histData.push_back(tempHist);

      // The last column goes to deadTimeTable
      API::TableRow deadRow = deadTimeTable->appendRow();
      deadRow << static_cast<int>(i)+1 << phaseRow.Double(3);
    }

  }
  else
  {
    throw std::invalid_argument("PhaseQuad: PhaseTable is empty");
  }

}
Exemplo n.º 9
0
/**
   Auto detecte the dead wires and store the information in the TableWorkspace.
   If asked, the dead wires are removed from the data set.

   @param localWorkspace :: input raw data workspace, containing the information about the instrument
   @param outputws :: input dead wire liste workspace
  */
void PoldiRemoveDeadWires::autoRemoveDeadWires
(
    DataObjects::Workspace2D_sptr &localWorkspace,
    API::ITableWorkspace_sptr &outputws
)
{


    double autoDeadWiresThreshold = 0;
    autoDeadWiresThreshold = getProperty("BadWiresThreshold");
    if(!autoDeadWiresThreshold) autoDeadWiresThreshold = m_defautDWThreshold;
    autoDeadWiresThreshold = 1.-autoDeadWiresThreshold;
//	double autoDeadWiresThreshold = 1-0.4;
    g_log.information() << "_poldi : auto removed wires : BadWiresThreshold:" << autoDeadWiresThreshold  <<  std::endl;
    int count = 0;

    double minValue=INFINITY;
    unsigned int minPos = 0;

    bool checkContinue = true;

    std::vector<double> average(this->m_numberOfSpectra);
    double globalAverage = 0;

    //compute the average intensity per spectrum
    for(unsigned int i=0; i<this->m_numberOfSpectra; i++) {
        if(!localWorkspace.get()->hasMaskedBins(i)) {
            average.at(i) = 0;
            MantidVec& tempY = localWorkspace.get()->dataY(i);
            for(unsigned int j=0; j<this->m_channelsPerSpectrum; j++) {
                average.at(i) += tempY[j];
            }
            average.at(i) /= static_cast<double>(this->m_channelsPerSpectrum);
            if(average[i]<minValue) {
                minValue = average[i];
                minPos   = i;
            }
        }
    }

    g_log.debug() << "_poldi : auto removed wires : average done"  <<  std::endl;

    while(checkContinue) {
        checkContinue = false;
        minValue=INFINITY;
        minPos = 0;
        int n = 0;
        // find the minimum average position, the most probably wrong spectra
        for(unsigned int i=0; i<this->m_numberOfSpectra; i++) {
            if(!localWorkspace.get()->hasMaskedBins(i)) {
                globalAverage += average[i];
                n++;
                if(average[i]<minValue) {
                    minValue = average[i];
                    minPos   = i;
                }
            }
        }
        globalAverage /=n;


        //applied the threshold to determine if a wires should be excluded
        //check if the wire is not already excluded
        if(!localWorkspace.get()->hasMaskedBins(minPos)) {

            if(average[minPos]<globalAverage*autoDeadWiresThreshold) {
                //mask the wires
                for(unsigned int j=0; j<this->m_channelsPerSpectrum; j++) {
                    localWorkspace->maskBin(minPos,j,1);
                }
                count++;
                checkContinue = true;
                TableRow t = outputws->appendRow();
                t << int(minPos) ;
            }
        }



        //applied the threshold to determine if a wires should be excluded
        //check if the wire is not already excluded
        if(!localWorkspace.get()->hasMaskedBins(minPos)) {
            //check the threshold on the left
            unsigned int left = minPos-1;
            //find the first used wires on the left
            while(localWorkspace.get()->hasMaskedBins(left) && left>0) {
                left--;
            }
            if(left>0 && average[minPos]<average[left]*autoDeadWiresThreshold) {
                //mask the wires
                for(unsigned int j=0; j<this->m_channelsPerSpectrum; j++) {
                    localWorkspace->maskBin(minPos,j,1);
                }
                count++;
                checkContinue = true;
                TableRow t = outputws->appendRow();
                t << int(minPos) ;
            }
        }

        if(!localWorkspace.get()->hasMaskedBins(minPos)) {
            //check the threshold on the right
            unsigned int right = minPos+1;
            //find the first used wires on the left
            while(localWorkspace.get()->hasMaskedBins(right) && right<this->m_numberOfSpectra) {
                right++;
            }
            if(right<m_numberOfSpectra-1 && average[minPos]<average[right]*autoDeadWiresThreshold) {
                //mask the wires
                for(unsigned int j=0; j<this->m_channelsPerSpectrum; j++) {
                    localWorkspace->maskBin(minPos,j,1);
                }
                count++;
                checkContinue = true;
                TableRow t = outputws->appendRow();
                t << int(minPos) ;
            }
        }

    }


    g_log.information() << "_poldi : auto removed wires (nb:" << count << ")" <<  std::endl;
    setProperty("nbAuteDeadWires",count);

}
Exemplo n.º 10
0
/**
 * This method loops through the response return_vector and saves the datafile
 * details to a table workspace
 * @param response :: const reference to response object
 * @param outputws :: shared pointer to table workspace which stores the data
 */
void CICatHelper::saveInvestigationIncludesResponse(
    const ns1__getInvestigationIncludesResponse &response,
    API::ITableWorkspace_sptr &outputws) {
  if (outputws->getColumnNames().empty()) {
    outputws->addColumn("str", "Name");
    outputws->addColumn("str", "Location");
    outputws->addColumn("str", "Create Time");
    outputws->addColumn("long64", "Id");
    outputws->addColumn("long64", "File size(bytes)");
    outputws->addColumn("str", "File size");
    outputws->addColumn("str", "Description");
  }

  try {
    std::vector<ns1__dataset *> datasetVec;
    datasetVec.assign((response.return_)->datasetCollection.begin(),
                      (response.return_)->datasetCollection.end());
    if (datasetVec.empty()) {
      throw std::runtime_error("No data files exists in the ICAT database for "
                               "the selected investigation");
    }
    std::vector<ns1__dataset *>::const_iterator dataset_citr;
    for (dataset_citr = datasetVec.begin(); dataset_citr != datasetVec.end();
         ++dataset_citr) {
      std::vector<ns1__datafile *> datafileVec;
      datafileVec.assign((*dataset_citr)->datafileCollection.begin(),
                         (*dataset_citr)->datafileCollection.end());
      if (datafileVec.empty()) {
        throw std::runtime_error("No data files exists in the ICAT database "
                                 "for the selected  investigation ");
      }

      std::vector<ns1__datafile *>::const_iterator datafile_citr;
      for (datafile_citr = datafileVec.begin();
           datafile_citr != datafileVec.end(); ++datafile_citr) {

        API::TableRow t = outputws->appendRow();

        // File Name
        savetoTableWorkspace((*datafile_citr)->name, t);
        savetoTableWorkspace((*datafile_citr)->location, t);

        // File creation Time.
        std::string *creationtime = nullptr;
        if ((*datafile_citr)->datafileCreateTime != nullptr) {
          time_t crtime = *(*datafile_citr)->datafileCreateTime;
          char temp[25];
          strftime(temp, 25, "%Y-%b-%d %H:%M:%S", localtime(&crtime));
          std::string ftime(temp);
          creationtime = new std::string;
          creationtime->assign(ftime);
        }
        savetoTableWorkspace(creationtime, t);
        if (creationtime)
          delete creationtime;

        //
        savetoTableWorkspace((*datafile_citr)->id, t);

        LONG64 fileSize =
            boost::lexical_cast<LONG64>(*(*datafile_citr)->fileSize);
        savetoTableWorkspace(&fileSize, t);

        savetoTableWorkspace((*datafile_citr)->description, t);
      }
    }

  } catch (std::runtime_error &) {
    throw;
  }
}
Exemplo n.º 11
0
/** Load PhaseList file to a vector of HistData and a deadTimeTable.
* @param filename :: [input] phase list .inf filename
* @param deadTimeTable :: [output] table containing dead times
*/
void PhaseQuadMuon::loadPhaseList(const std::string& filename, API::ITableWorkspace_sptr deadTimeTable )
{

  std::ifstream input(filename.c_str(), std::ios_base::in);

  if (input.is_open())
  {

    if ( input.eof() )
    {
      throw Exception::FileError("PhaseQuad: File is empty.", filename);
    }
    else
    {
      std::string line;

      // Header of .INF file is as follows:
      //
      // Comment on the output file
      // Top row of numbers are:
      // #histos, typ. first good bin#, typ. bin# when pulse over, mean lag.
      // Tabulated numbers are, per histogram:
      // det ok, asymmetry, phase, lag, deadtime_c, deadtime_m.
      //
      std::getline( input, line ); // Skip first line in header
      std::getline( input, line ); // Skip second line
      std::getline( input, line ); // ...
      std::getline( input, line );
      std::getline( input, line );

      // Read first useful line
      int nHist;
      input >> nHist >> m_tValid >> m_tPulseOver >> m_meanLag;
      if (m_nHist!=nHist)
      {
        throw std::runtime_error("PhaseQuad: Number of histograms in phase list does not match number of spectra in workspace");
      }

      // Read histogram data
      int cont=0;
      HistData tempData;
      double lag, dead, deadm;
      while( input >> tempData.detOK >> tempData.alpha >> tempData.phi >> lag >> dead >> deadm )
      {
        m_histData.push_back (tempData);
        cont++;

        // Add dead time to deadTimeTable
        API::TableRow row = deadTimeTable->appendRow();
        row << cont << dead;

      }

      if ( cont != m_nHist )
      {
        if ( cont < m_nHist )
        {
          throw Exception::FileError("PhaseQuad: Lines missing in phase list", filename);
        }
        else
        {
          throw Exception::FileError("PhaseQuad: Extra lines in phase list", filename);
        }
      }

    }
  }
  else
  {
    // Throw exception if file cannot be opened
    throw std::runtime_error("PhaseQuad: Unable to open PhaseList");
Exemplo n.º 12
0
/**
 * Saves investigations to a table workspace.
 * @param response :: A vector containing the results of the search query.
 * @param outputws :: Shared pointer to output workspace.
 */
void ICat4Catalog::saveInvestigations(std::vector<xsd__anyType *> response,
                                      API::ITableWorkspace_sptr &outputws) {
  if (outputws->getColumnNames().empty()) {
    // Add rows headers to the output workspace.
    outputws->addColumn("long64", "DatabaseID");
    outputws->addColumn("str", "InvestigationID");
    outputws->addColumn("str", "Facility");
    outputws->addColumn("str", "Title");
    outputws->addColumn("str", "Instrument");
    outputws->addColumn("str", "Run range");
    outputws->addColumn("str", "Start date");
    outputws->addColumn("str", "End date");
    outputws->addColumn("str", "SessionID");
  }

  // Add data to each row in the output workspace.
  std::vector<xsd__anyType *>::const_iterator iter;
  for (iter = response.begin(); iter != response.end(); ++iter) {
    // Cast from xsd__anyType to subclass (xsd__string).
    ns1__investigation *investigation =
        dynamic_cast<ns1__investigation *>(*iter);
    if (investigation) {
      API::TableRow table = outputws->appendRow();
      // Used to insert an empty string into the cell if value does not exist.
      std::string emptyCell;

      // Now add the relevant investigation data to the table (They always
      // exist).
      savetoTableWorkspace(investigation->id, table);
      savetoTableWorkspace(investigation->name, table);
      savetoTableWorkspace(investigation->facility->name, table);
      savetoTableWorkspace(investigation->title, table);
      savetoTableWorkspace(
          investigation->investigationInstruments.at(0)->instrument->name,
          table);

      // Verify that the run parameters vector exist prior to doing anything.
      // Since some investigations may not have run parameters.
      if (!investigation->parameters.empty()) {
        savetoTableWorkspace(investigation->parameters[0]->stringValue, table);
      } else {
        savetoTableWorkspace(&emptyCell, table);
      }

      // Again, we need to check first if start and end date exist prior to
      // insertion.
      if (investigation->startDate) {
        std::string startDate =
            formatDateTime(*investigation->startDate, "%Y-%m-%d");
        savetoTableWorkspace(&startDate, table);
      } else {
        savetoTableWorkspace(&emptyCell, table);
      }

      if (investigation->endDate) {
        std::string endDate =
            formatDateTime(*investigation->endDate, "%Y-%m-%d");
        savetoTableWorkspace(&endDate, table);
      } else {
        savetoTableWorkspace(&emptyCell, table);
      }
      std::string sessionID = m_session->getSessionId();
      savetoTableWorkspace(&sessionID, table);
    } else {
      throw std::runtime_error("ICat4Catalog::saveInvestigations expected an "
                               "investigation. Please contact the Mantid "
                               "development team.");
    }
  }
}