//Write a single line (indent based on number of running timers; just ignore tabs for no timings)
//Escapes unicode
void Logger::writeLogLine(char logLetter, const std::wstring& logLine)
{
if (isLogging(logLetter)) {
//Open file
std::ofstream log(filePaths[logLetter].c_str(), std::ios::app);
//Append main line if non-empty.
if (!logLine.empty()) {
//Indent
std::wstring newLine = std::wstring(filetimeStacks[logLetter].size()*logTabDepth, L' ') + logLine;
//Generate line
std::stringstream msg;
for (size_t i=0; i<newLine.length(); i++) {
if (newLine[i]<=0xFF && newLine[i]!=0x00)
msg <<(char)newLine[i];
else
msg <<"\\u" <<std::hex <<std::uppercase <<newLine[i] <<std::dec <<std::nouppercase;
}
//Write line
log <<msg.str();
}
//Write a trailing newline anyway
log <<std::endl;
log.close();
}
}
void OSCQueryDevice::slot_createDevice()
{
const auto& cur_settings = settings();
const auto& stgs
= cur_settings.deviceSpecificSettings.value<OSCQuerySpecificSettings>();
try
{
std::unique_ptr<ossia::net::protocol_base> ossia_settings
= std::make_unique<ossia::oscquery::oscquery_mirror_protocol>(
stgs.host.toStdString());
auto& p = static_cast<ossia::oscquery::oscquery_mirror_protocol&>(
*ossia_settings);
m_mirror = &p;
if (stgs.rate)
{
ossia_settings = std::make_unique<ossia::net::rate_limiting_protocol>(
std::chrono::milliseconds{*stgs.rate}, std::move(ossia_settings));
}
// run the commands in the Qt event loop
// FIXME they should be disabled upon manual disconnection
m_dev = std::make_unique<ossia::net::generic_device>(
std::move(ossia_settings), settings().name.toStdString());
deviceChanged(nullptr, m_dev.get());
p.set_command_callback([=] { sig_command(); });
p.set_disconnect_callback([=] { sig_disconnect(); });
p.set_fail_callback([=] { sig_disconnect(); });
setLogging_impl(Device::get_cur_logging(isLogging()));
enableCallbacks();
m_connected = true;
}
catch (std::exception& e)
{
qDebug() << "Could not connect: " << e.what();
m_connected = false;
if (!m_dev)
m_mirror = nullptr;
}
catch (...)
{
// TODO save the reason of the non-connection.
m_connected = false;
if (!m_dev)
m_mirror = nullptr;
}
connectionChanged(m_connected);
}
//Reset
void Logger::resetLogFile(char logLetter)
{
if (isLogging(logLetter)) {
//Reset the saved filetimes
filetimeStacks[logLetter].clear();
//Ensure the file path has been added.
//filePaths[logLetter] = (logLetter==waitzarLogchar) ? mainLogFileName : (logLetter==keymagicLogchar) ? keymagicLogFileName : (logLetter==typingLogchar) ? typingLogFileName : uni2ZawgyiLogFileName;
//Reset log file contents
std::ofstream log(filePaths[logLetter].c_str(), std::ios::out);
log.close();
}
}
void Rotation::logValues(void)
{
if(isLogging()) {
QRotationSensor *rotation = dynamic_cast<QRotationSensor*>(m_sensor);
QRotationReading *reading = rotation->reading();
QString line = QString("%1\t%2\t%3\t%4\n")
.arg(QDateTime::currentMSecsSinceEpoch()/1000.0, 0, 'f', 3)
.arg(reading->x())
.arg(reading->y())
.arg(reading->z());
m_logFile.write(line.toUtf8());
}
}
core::IConnectionSettingsBase* ConnectionBaseWidget::createConnection() const {
std::string conName = common::ConvertToString(connectionName());
std::string conFolder = common::ConvertToString(UIFolderText());
if (conFolder.empty()) {
conFolder = defaultNameConnectionFolder;
}
core::connection_path_t path(common::file_system::stable_dir_path(conFolder) + conName);
core::IConnectionSettingsBase* conn = createConnectionImpl(path);
conn->SetNsSeparator(
common::ConvertToString(toRawCommandLine(namespaceSeparator_->currentText())));
conn->SetDelimiter(common::ConvertToString(toRawCommandLine(delimiter_->currentText())));
if (isLogging()) {
conn->SetLoggingMsTimeInterval(loggingInterval());
}
return conn;
}
/** Process groups. Groups are processed differently depending on transmission
* runs and polarization analysis. If transmission run is a matrix workspace, it
* will be applied to each of the members in the input workspace group. If
* transmission run is a workspace group, the behaviour is different depending
* on polarization analysis. If polarization analysis is off (i.e.
* 'PolarizationAnalysis' is set to 'None') each item in the transmission group
* is associated with the corresponding item in the input workspace group. If
* polarization analysis is on (i.e. 'PolarizationAnalysis' is 'PA' or 'PNR')
* items in the transmission group will be summed to produce a matrix workspace
* that will be applied to each of the items in the input workspace group. See
* documentation of this algorithm for more details.
*/
bool ReflectometryReductionOneAuto2::processGroups() {
// this algorithm effectively behaves as MultiPeriodGroupAlgorithm
m_usingBaseProcessGroups = true;
// Get our input workspace group
auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
getPropertyValue("InputWorkspace"));
// Get name of IvsQ workspace (native binning)
const std::string outputIvsQ = getPropertyValue("OutputWorkspace");
// Get name of IvsQ (native binning) workspace
const std::string outputIvsQBinned =
getPropertyValue("OutputWorkspaceBinned");
// Get name of IvsLam workspace
const std::string outputIvsLam =
getPropertyValue("OutputWorkspaceWavelength");
// Create a copy of ourselves
Algorithm_sptr alg =
createChildAlgorithm(name(), -1, -1, isLogging(), version());
alg->setChild(false);
alg->setRethrows(true);
// Copy all the non-workspace properties over
const std::vector<Property *> props = getProperties();
for (auto &prop : props) {
if (prop) {
IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
if (!wsProp)
alg->setPropertyValue(prop->name(), prop->value());
}
}
const bool polarizationAnalysisOn =
getPropertyValue("PolarizationAnalysis") != "None";
// Check if the transmission runs are groups or not
const std::string firstTrans = getPropertyValue("FirstTransmissionRun");
WorkspaceGroup_sptr firstTransG;
MatrixWorkspace_sptr firstTransSum;
if (!firstTrans.empty()) {
auto firstTransWS =
AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans);
firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS);
if (!firstTransG) {
alg->setProperty("FirstTransmissionRun", firstTrans);
} else if (polarizationAnalysisOn) {
firstTransSum = sumTransmissionWorkspaces(firstTransG);
}
}
const std::string secondTrans = getPropertyValue("SecondTransmissionRun");
WorkspaceGroup_sptr secondTransG;
MatrixWorkspace_sptr secondTransSum;
if (!secondTrans.empty()) {
auto secondTransWS =
AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans);
secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS);
if (!secondTransG) {
alg->setProperty("SecondTransmissionRun", secondTrans);
} else if (polarizationAnalysisOn) {
secondTransSum = sumTransmissionWorkspaces(secondTransG);
}
}
std::vector<std::string> IvsQGroup, IvsQUnbinnedGroup, IvsLamGroup;
// Execute algorithm over each group member
for (size_t i = 0; i < group->size(); ++i) {
const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1);
const std::string IvsQBinnedName =
outputIvsQBinned + "_" + std::to_string(i + 1);
const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1);
if (firstTransG) {
if (!polarizationAnalysisOn)
alg->setProperty("FirstTransmissionRun",
firstTransG->getItem(i)->getName());
else
alg->setProperty("FirstTransmissionRun", firstTransSum);
}
if (secondTransG) {
if (!polarizationAnalysisOn)
alg->setProperty("SecondTransmissionRun",
secondTransG->getItem(i)->getName());
else
alg->setProperty("SecondTransmissionRun", secondTransSum);
}
alg->setProperty("InputWorkspace", group->getItem(i)->getName());
alg->setProperty("OutputWorkspace", IvsQName);
alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName);
alg->setProperty("OutputWorkspaceWavelength", IvsLamName);
alg->execute();
IvsQGroup.push_back(IvsQName);
IvsQUnbinnedGroup.push_back(IvsQBinnedName);
IvsLamGroup.push_back(IvsLamName);
}
// Group the IvsQ and IvsLam workspaces
Algorithm_sptr groupAlg = createChildAlgorithm("GroupWorkspaces");
groupAlg->setChild(false);
groupAlg->setRethrows(true);
groupAlg->setProperty("InputWorkspaces", IvsLamGroup);
groupAlg->setProperty("OutputWorkspace", outputIvsLam);
groupAlg->execute();
groupAlg->setProperty("InputWorkspaces", IvsQGroup);
groupAlg->setProperty("OutputWorkspace", outputIvsQ);
groupAlg->execute();
groupAlg->setProperty("InputWorkspaces", IvsQUnbinnedGroup);
groupAlg->setProperty("OutputWorkspace", outputIvsQBinned);
groupAlg->execute();
// Set other properties so they can be updated in the Reflectometry interface
setPropertyValue("ThetaIn", alg->getPropertyValue("ThetaIn"));
setPropertyValue("MomentumTransferMin",
alg->getPropertyValue("MomentumTransferMin"));
setPropertyValue("MomentumTransferMax",
alg->getPropertyValue("MomentumTransferMax"));
setPropertyValue("MomentumTransferStep",
alg->getPropertyValue("MomentumTransferStep"));
setPropertyValue("ScaleFactor", alg->getPropertyValue("ScaleFactor"));
if (!polarizationAnalysisOn) {
// No polarization analysis. Reduction stops here
setPropertyValue("OutputWorkspace", outputIvsQ);
setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned);
setPropertyValue("OutputWorkspaceWavelength", outputIvsLam);
return true;
}
if (!group->isMultiperiod()) {
g_log.warning("Polarization corrections can only be performed on "
"multiperiod workspaces.");
setPropertyValue("OutputWorkspace", outputIvsQ);
setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned);
setPropertyValue("OutputWorkspaceWavelength", outputIvsLam);
return true;
}
Algorithm_sptr polAlg = createChildAlgorithm("PolarizationCorrection");
polAlg->setChild(false);
polAlg->setRethrows(true);
polAlg->setProperty("InputWorkspace", outputIvsLam);
polAlg->setProperty("OutputWorkspace", outputIvsLam);
polAlg->setProperty("PolarizationAnalysis",
getPropertyValue("PolarizationAnalysis"));
polAlg->setProperty("CPp", getPropertyValue("CPp"));
polAlg->setProperty("CRho", getPropertyValue("CRho"));
polAlg->setProperty("CAp", getPropertyValue("CAp"));
polAlg->setProperty("CAlpha", getPropertyValue("CAlpha"));
polAlg->execute();
// Now we've overwritten the IvsLam workspaces, we'll need to recalculate
// the IvsQ ones
alg->setProperty("FirstTransmissionRun", "");
alg->setProperty("SecondTransmissionRun", "");
alg->setProperty("CorrectionAlgorithm", "None");
alg->setProperty("ThetaIn", Mantid::EMPTY_DBL());
alg->setProperty("ProcessingInstructions", "0");
for (size_t i = 0; i < group->size(); ++i) {
const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1);
const std::string IvsQBinnedName =
outputIvsQBinned + "_" + std::to_string(i + 1);
const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1);
alg->setProperty("InputWorkspace", IvsLamName);
alg->setProperty("OutputWorkspace", IvsQName);
alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName);
alg->setProperty("OutputWorkspaceWavelength", IvsLamName);
alg->execute();
}
setPropertyValue("OutputWorkspace", outputIvsQ);
setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned);
setPropertyValue("OutputWorkspaceWavelength", outputIvsLam);
return true;
}
void logToFile(const char* text) {
if (isLogging()) {
outFile << text << endl;
}
}
void EmulationHandler::recv( const QByteArray& ar) {
m_teEmu->onRcvBlock(ar.data(), ar.count() );
if ( isLogging() ) {
m_log->append( ar );
}
}
void EmulationHandler::clearLog() {
if (isLogging()) {
delete m_log;
m_log = 0;
}
}
void EmulationHandler::startLogging(const QString fileName) {
m_logFileName = fileName;
if (!isLogging())
m_log = new Logger(m_logFileName);
}