432 lines
16 KiB
C++
432 lines
16 KiB
C++
/***************************************************************************
|
|
|
|
musrview.cpp
|
|
|
|
Author: Andreas Suter
|
|
e-mail: andreas.suter@psi.ch
|
|
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2007-2021 by Andreas Suter *
|
|
* andreas.suter@psi.ch *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <iostream>
|
|
|
|
#include <TApplication.h>
|
|
#include <TSAXParser.h>
|
|
#include <TROOT.h>
|
|
|
|
#ifdef HAVE_GIT_REV_H
|
|
#include "git-revision.h"
|
|
#endif
|
|
|
|
#include "PMusr.h"
|
|
#include "PStartupHandler.h"
|
|
#include "PMsrHandler.h"
|
|
#include "PRunDataHandler.h"
|
|
#include "PRunListCollection.h"
|
|
#include "PMusrCanvas.h"
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>Sends the usage description to the standard output.
|
|
*/
|
|
void musrview_syntax()
|
|
{
|
|
std::cout << std::endl << "usage: musrview <msr-file> [Options]";
|
|
std::cout << std::endl << " <msr-file>: msr/mlog input file";
|
|
std::cout << std::endl << " Options:";
|
|
std::cout << std::endl << " --help : display this help and exit.";
|
|
std::cout << std::endl << " --version : output version information and exit.";
|
|
std::cout << std::endl << " --show-dynamic-path : dumps the dynamic search paths and exit.";
|
|
std::cout << std::endl << " -f, --fourier: will directly present the Fourier transform of the <msr-file>.";
|
|
std::cout << std::endl << " -a, --avg: will directly present the averaged data/Fourier of the <msr-file>.";
|
|
std::cout << std::endl << " -1, --one_to_one: calculate theory points only at data points.";
|
|
std::cout << std::endl << " --<graphic-format-extension>: ";
|
|
std::cout << std::endl << " will produce a graphics-output-file without starting a root session.";
|
|
std::cout << std::endl << " the name is based on the <msr-file>, e.g. 3310.msr -> 3310_0.png";
|
|
std::cout << std::endl << " supported graphic-format-extension:";
|
|
std::cout << std::endl << " eps, pdf, gif, jpg, png, svg, xpm, root";
|
|
std::cout << std::endl << " example: musrview 3310.msr --png, will produce a files 3310_X.png";
|
|
std::cout << std::endl << " where 'X' stands for the plot number (starting form 0)";
|
|
std::cout << std::endl << " --ascii: ";
|
|
std::cout << std::endl << " will produce an ascii dump of the data and fit as plotted.";
|
|
std::cout << std::endl << " --timeout <timeout>: <timeout> given in seconds after which musrview terminates.";
|
|
std::cout << std::endl << " If <timeout> <= 0, no timeout will take place. Default <timeout> is 0.";
|
|
std::cout << std::endl << std::endl;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* <p>The musrview program is used to show muSR fit results in graphical form.
|
|
* From it also Fourier transforms, difference between data an theory can be formed.
|
|
* For a detailed description/usage of the program, please see
|
|
* \htmlonly <a href="http://lmu.web.psi.ch/musrfit/user/html/user-manual.html#musrview">musrview online help</a>
|
|
* \endhtmlonly
|
|
* \latexonly musrview online help: \texttt{http://lmu.web.psi.ch/musrfit/user/html/user-manual.html#musrview}
|
|
* \endlatexonly
|
|
*
|
|
* <b>return:</b>
|
|
* - PMUSR_SUCCESS if everthing went smooth
|
|
* - PMUSR_WRONG_STARTUP_SYNTAX if syntax error is encountered
|
|
* - line number if an error in the msr-file was encountered which cannot be handled.
|
|
*
|
|
* \param argc number of input arguments
|
|
* \param argv list of input arguments
|
|
*/
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int result = PMUSR_SUCCESS;
|
|
bool show_syntax = false;
|
|
int status;
|
|
bool success = true;
|
|
char fileName[128];
|
|
bool fourier = false;
|
|
bool avg = false;
|
|
bool theoAtData = false; // theory points only at data points
|
|
bool graphicsOutput = false;
|
|
bool asciiOutput = false;
|
|
char graphicsExtension[128];
|
|
int timeout = 0;
|
|
|
|
memset(fileName, '\0', sizeof(fileName));
|
|
|
|
// add default shared library path /usr/local/lib if not already persent
|
|
const char *dsp = gSystem->GetDynamicPath();
|
|
if (strstr(dsp, "/usr/local/lib") == nullptr)
|
|
gSystem->AddDynamicPath("/usr/local/lib");
|
|
|
|
// check input arguments
|
|
if (argc == 1) {
|
|
musrview_syntax();
|
|
return PMUSR_SYNTAX_REQUEST;
|
|
}
|
|
for (int i=1; i<argc; i++) {
|
|
if (strstr(argv[i], ".msr") || strstr(argv[i], ".mlog")) {
|
|
if (strlen(fileName) == 0) {
|
|
strcpy(fileName, argv[i]);
|
|
} else {
|
|
std::cerr << std::endl << "**ERROR** only one file name allowed." << std::endl;
|
|
show_syntax = true;
|
|
break;
|
|
}
|
|
} else if (!strcmp(argv[i], "--version")) {
|
|
#ifdef HAVE_CONFIG_H
|
|
#ifdef HAVE_GIT_REV_H
|
|
std::cout << std::endl << "musrview version: " << PACKAGE_VERSION << ", git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
|
|
#else
|
|
std::cout << std::endl << "musrview version: " << PACKAGE_VERSION << " (" << BUILD_TYPE << "), ROOT version: " << ROOT_VERSION_USED << std::endl << std::endl;
|
|
#endif
|
|
#else
|
|
#ifdef HAVE_GIT_REV_H
|
|
std::cout << std::endl << "musrview git-branch: " << GIT_BRANCH << ", git-rev: " << GIT_CURRENT_SHA1 << std::endl << std::endl;
|
|
#else
|
|
std::cout << std::endl << "musrview version: unknown." << std::endl << std::endl;
|
|
#endif
|
|
#endif
|
|
return PMUSR_SUCCESS;
|
|
} else if (!strcmp(argv[i], "--show-dynamic-path")) {
|
|
std::cout << std::endl << "musrview: internal dynamic search paths for shared libraries/root dictionaries:";
|
|
std::cout << std::endl << " '" << gSystem->GetDynamicPath() << "'" << std::endl << std::endl;
|
|
return PMUSR_SUCCESS;
|
|
} else if (!strcmp(argv[i], "--help")) {
|
|
show_syntax = true;
|
|
break;
|
|
} else if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--fourier")) {
|
|
fourier = true;
|
|
} else if (!strcmp(argv[i], "-a") || !strcmp(argv[i], "--avg")) {
|
|
avg = true;
|
|
} else if (!strcmp(argv[i], "-1") || !strcmp(argv[i], "--one_to_one")) {
|
|
theoAtData = true;
|
|
} else if (!strcmp(argv[i], "--eps") || !strcmp(argv[i], "--pdf") || !strcmp(argv[i], "--gif") ||
|
|
!strcmp(argv[i], "--jpg") || !strcmp(argv[i], "--png") || !strcmp(argv[i], "--svg") ||
|
|
!strcmp(argv[i], "--xpm") || !strcmp(argv[i], "--root")) {
|
|
|
|
graphicsOutput = true;
|
|
strcpy(graphicsExtension, argv[i]+2);
|
|
} else if (!strcmp(argv[i], "--ascii")) {
|
|
asciiOutput = true;
|
|
} else if (!strcmp(argv[i], "--timeout")) {
|
|
if (i+1 < argc) {
|
|
TString str(argv[i+1]);
|
|
if (str.IsFloat()) {
|
|
timeout = str.Atoi();
|
|
} else {
|
|
show_syntax = true;
|
|
break;
|
|
}
|
|
i++;
|
|
} else {
|
|
show_syntax = true;
|
|
break;
|
|
}
|
|
} else {
|
|
show_syntax = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (show_syntax) {
|
|
musrview_syntax();
|
|
return PMUSR_WRONG_STARTUP_SYNTAX;
|
|
}
|
|
|
|
// read startup file
|
|
char startup_path_name[128];
|
|
TSAXParser *saxParser = new TSAXParser();
|
|
PStartupHandler *startupHandler = new PStartupHandler();
|
|
if (!startupHandler->StartupFileFound()) {
|
|
std::cerr << std::endl << ">> musrview **WARNING** couldn't find " << startupHandler->GetStartupFilePath().Data();
|
|
std::cerr << std::endl;
|
|
// clean up
|
|
if (saxParser) {
|
|
delete saxParser;
|
|
saxParser = nullptr;
|
|
}
|
|
if (startupHandler) {
|
|
delete startupHandler;
|
|
startupHandler = nullptr;
|
|
}
|
|
} else {
|
|
strcpy(startup_path_name, startupHandler->GetStartupFilePath().Data());
|
|
saxParser->ConnectToHandler("PStartupHandler", startupHandler);
|
|
//status = saxParser->ParseFile(startup_path_name);
|
|
// parsing the file as above seems to lead to problems in certain environments;
|
|
// use the parseXmlFile function instead (see PStartupHandler.cpp for the definition)
|
|
status = parseXmlFile(saxParser, startup_path_name);
|
|
// check for parse errors
|
|
if (status) { // error
|
|
std::cerr << std::endl << ">> musrview **WARNING** Reading/parsing musrfit_startup.xml failed.";
|
|
std::cerr << std::endl << ">> Any graph will appear with random symbols and colors!";
|
|
std::cerr << std::endl;
|
|
// clean up
|
|
if (saxParser) {
|
|
delete saxParser;
|
|
saxParser = nullptr;
|
|
}
|
|
if (startupHandler) {
|
|
delete startupHandler;
|
|
startupHandler = nullptr;
|
|
}
|
|
} else {
|
|
startupHandler->CheckLists();
|
|
}
|
|
}
|
|
|
|
// read msr-file
|
|
PMsrHandler *msrHandler = new PMsrHandler(fileName);
|
|
status = msrHandler->ReadMsrFile();
|
|
if (status != PMUSR_SUCCESS) {
|
|
switch (status) {
|
|
case PMUSR_MSR_FILE_NOT_FOUND:
|
|
std::cerr << std::endl << ">> musrview **ERROR** couldn't find '" << fileName << "'" << std::endl << std::endl;
|
|
break;
|
|
case PMUSR_MSR_SYNTAX_ERROR:
|
|
std::cerr << std::endl << ">> musrview **SYNTAX ERROR** in file " << fileName << ", full stop here." << std::endl << std::endl;
|
|
break;
|
|
default:
|
|
std::cerr << std::endl << ">> musrview **UNKNOWN ERROR** when trying to read the msr-file" << std::endl << std::endl;
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
// make a plot list vector
|
|
PMsrPlotList *msrPlotList = msrHandler->GetMsrPlotList();
|
|
PIntVector plotList;
|
|
bool runPresent;
|
|
for (unsigned int i=0; i<msrPlotList->size(); i++) {
|
|
for (unsigned int j=0; j<msrPlotList->at(i).fRuns.size(); j++) {
|
|
// check that run is not already in the plotList
|
|
runPresent = false;
|
|
for (unsigned int k=0; k<plotList.size(); k++) {
|
|
if (msrPlotList->at(i).fRuns[j] == static_cast<int>(plotList[k])) {
|
|
runPresent = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!runPresent) {
|
|
plotList.push_back(static_cast<int>(msrPlotList->at(i).fRuns[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
// read all the necessary runs (raw data)
|
|
PRunDataHandler *dataHandler;
|
|
if (startupHandler)
|
|
dataHandler = new PRunDataHandler(msrHandler, startupHandler->GetDataPathList());
|
|
else
|
|
dataHandler = new PRunDataHandler(msrHandler);
|
|
|
|
dataHandler->ReadData();
|
|
|
|
success = dataHandler->IsAllDataAvailable();
|
|
if (!success) {
|
|
std::cerr << std::endl << ">> musrview **ERROR** Couldn't read all data files, will quit ..." << std::endl;
|
|
result = PMUSR_DATA_FILE_READ_ERROR;
|
|
}
|
|
|
|
// generate the necessary histogramms for the view
|
|
PRunListCollection *runListCollection = nullptr;
|
|
if (result == PMUSR_SUCCESS) {
|
|
// feed all the necessary histogramms for the view
|
|
runListCollection = new PRunListCollection(msrHandler, dataHandler, theoAtData);
|
|
for (unsigned int i=0; i<msrHandler->GetMsrRunList()->size(); i++) {
|
|
// if run is in plotList add it, otherwise go to the next
|
|
runPresent = false;
|
|
for (unsigned int j=0; j<plotList.size(); j++) {
|
|
if (static_cast<unsigned int>(plotList[j]) == i+1) {
|
|
runPresent = true;
|
|
break;
|
|
}
|
|
}
|
|
if (runPresent) {
|
|
success = runListCollection->Add(i, kView);
|
|
if (!success) {
|
|
std::cerr << std::endl << ">> musrview **ERROR** Couldn't handle run no " << i << " ";
|
|
std::cerr << (*msrHandler->GetMsrRunList())[i].GetRunName()->Data();
|
|
result = PMUSR_MSR_RUN_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result == PMUSR_SUCCESS) {
|
|
// generate Root application needed for PMusrCanvas
|
|
if (graphicsOutput || asciiOutput) {
|
|
argv[argc] = (char*)malloc(16*sizeof(char));
|
|
strcpy(argv[argc], "-b");
|
|
argc++;
|
|
}
|
|
TApplication app("App", &argc, argv);
|
|
|
|
std::vector<PMusrCanvas*> canvasVector;
|
|
PMusrCanvas *musrCanvas;
|
|
|
|
bool ok = true;
|
|
for (unsigned int i=0; i<msrHandler->GetMsrPlotList()->size(); i++) {
|
|
|
|
if (startupHandler)
|
|
musrCanvas = new PMusrCanvas(i, msrHandler->GetMsrTitle()->Data(),
|
|
10+i*100, 10+i*100, 800, 600,
|
|
startupHandler->GetFourierDefaults(),
|
|
startupHandler->GetMarkerList(),
|
|
startupHandler->GetColorList(),
|
|
graphicsOutput||asciiOutput,
|
|
fourier, avg, theoAtData);
|
|
else
|
|
musrCanvas = new PMusrCanvas(i, msrHandler->GetMsrTitle()->Data(),
|
|
10+i*100, 10+i*100, 800, 600,
|
|
graphicsOutput||asciiOutput,
|
|
fourier, avg, theoAtData);
|
|
|
|
if (!musrCanvas->IsValid()) {
|
|
std::cerr << std::endl << ">> musrview **SEVERE ERROR** Couldn't invoke all necessary objects, will quit.";
|
|
std::cerr << std::endl;
|
|
ok = false;
|
|
break;
|
|
}
|
|
|
|
musrCanvas->SetTimeout(timeout);
|
|
|
|
// ugly but rootcling cannot handle the spirit-parser framework
|
|
musrCanvas->SetMsrHandler(msrHandler);
|
|
musrCanvas->SetRunListCollection(runListCollection);
|
|
|
|
musrCanvas->UpdateParamTheoryPad();
|
|
musrCanvas->UpdateDataTheoryPad();
|
|
musrCanvas->UpdateInfoPad();
|
|
|
|
if (!musrCanvas->IsValid()) { // something went wrong
|
|
ok = false;
|
|
break;
|
|
}
|
|
|
|
musrCanvas->Connect("Done(Int_t)", "TApplication", &app, "Terminate(Int_t)");
|
|
|
|
if (graphicsOutput) {
|
|
musrCanvas->SaveGraphicsAndQuit(fileName, graphicsExtension);
|
|
}
|
|
|
|
if (asciiOutput) {
|
|
// generate export data file name
|
|
TString str(fileName);
|
|
str.Remove(str.Last('.'));
|
|
str += ".dat";
|
|
// save data in batch mode
|
|
musrCanvas->ExportData(str.Data());
|
|
musrCanvas->Done(0);
|
|
}
|
|
|
|
// keep musrCanvas objects
|
|
canvasVector.push_back(musrCanvas);
|
|
}
|
|
|
|
// check that everything is ok
|
|
if (ok)
|
|
app.Run(true); // true needed that Run will return after quit so that cleanup works
|
|
|
|
// clean up
|
|
char canvasName[32];
|
|
for (unsigned int i=0; i<canvasVector.size(); i++) {
|
|
// check if canvas is still there before calling the destructor **TO BE DONE**
|
|
snprintf(canvasName, sizeof(canvasName), "fMainCanvas%d", i);
|
|
if (gROOT->GetListOfCanvases()->FindObject(canvasName) != nullptr) {
|
|
canvasVector[i]->~PMusrCanvas();
|
|
}
|
|
}
|
|
canvasVector.clear();
|
|
}
|
|
|
|
// clean up
|
|
plotList.clear();
|
|
if (saxParser) {
|
|
delete saxParser;
|
|
saxParser = nullptr;
|
|
}
|
|
if (startupHandler) {
|
|
delete startupHandler;
|
|
startupHandler = nullptr;
|
|
}
|
|
if (msrHandler) {
|
|
delete msrHandler;
|
|
msrHandler = nullptr;
|
|
}
|
|
if (dataHandler) {
|
|
delete dataHandler;
|
|
dataHandler = nullptr;
|
|
}
|
|
if (runListCollection) {
|
|
delete runListCollection;
|
|
runListCollection = nullptr;
|
|
}
|
|
|
|
return result;
|
|
}
|