1270 lines
43 KiB
C++
1270 lines
43 KiB
C++
/***************************************************************************
|
|
|
|
PmuppScript.cpp
|
|
|
|
Author: Andreas Suter
|
|
e-mail: andreas.suter@psi.ch
|
|
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2007-2025 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. *
|
|
***************************************************************************/
|
|
|
|
/**
|
|
* @file PmuppScript.cpp
|
|
*
|
|
* @brief Implementation of the mupp scripting interface for batch processing.
|
|
*
|
|
* This file implements the non-interactive scripting system for mupp, enabling
|
|
* automated batch processing of parameter data analysis and plotting tasks.
|
|
*
|
|
* Key functionality implemented:
|
|
* - Script command parsing and execution
|
|
* - Path management with environment variable expansion
|
|
* - Data collection loading and selection
|
|
* - X-Y axis parameter configuration
|
|
* - Variable expression evaluation and storage
|
|
* - ROOT macro generation with full plot specification
|
|
* - Batch mode plot creation via ROOT subprocess
|
|
* - Label formatting for publication-quality plots
|
|
*
|
|
* Script command processing:
|
|
* The executeScript() method processes commands sequentially, maintaining
|
|
* state throughout execution. Each command type (loadPath, load, select,
|
|
* x, y, var, norm, plot, macro) has a dedicated handler method.
|
|
*
|
|
* ROOT macro generation:
|
|
* The macro() method creates complete ROOT C++ macros including:
|
|
* - Data array definitions
|
|
* - TGraphAsymmErrors objects for error bars
|
|
* - Canvas and styling setup
|
|
* - Axis labels and ranges
|
|
* - Marker and color configuration
|
|
* - Optional normalization
|
|
*
|
|
* Variable system:
|
|
* Variables are mathematical expressions combining collection parameters.
|
|
* The var_cmd() method integrates with PVarHandler for expression parsing
|
|
* and evaluation, enabling derived quantity calculations.
|
|
*/
|
|
|
|
#include <cmath>
|
|
#include <iostream>
|
|
|
|
#include <QProcessEnvironment>
|
|
#include <QString>
|
|
#include <QFile>
|
|
#include <QTextStream>
|
|
#include <QDateTime>
|
|
#include <QProcess>
|
|
|
|
#include <QtGlobal> // Q_ASSERT
|
|
|
|
#include "PmuppScript.h"
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Constructor for the script interpreter.
|
|
*
|
|
* Initializes the script execution environment with default settings:
|
|
* - Load path: current directory
|
|
* - Save path: current directory
|
|
* - Selection state: nothing selected
|
|
* - Normalization: disabled
|
|
* - Administration object for configuration access
|
|
*
|
|
* @param script list of script commands to be executed
|
|
*/
|
|
PmuppScript::PmuppScript(QStringList script) :
|
|
fScript(script)
|
|
{
|
|
fLoadPath = QString("./");
|
|
fSavePath = QString("./");
|
|
fSelected = -2; // nothing selected
|
|
fNorm = false;
|
|
|
|
fAdmin = std::make_unique<PmuppAdmin>();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Executes all script commands sequentially.
|
|
*
|
|
* Processes each command in the script list, dispatching to appropriate
|
|
* handler methods based on command type. Maintains state throughout
|
|
* execution including:
|
|
* - Loaded data collections
|
|
* - Current selection
|
|
* - Plot configurations
|
|
* - Variable definitions
|
|
*
|
|
* Command dispatch table:
|
|
* - "loadPath" → setLoadPath()
|
|
* - "savePath" → setSavePath()
|
|
* - "load " → loadCollection()
|
|
* - "selectAll" → selectAll()
|
|
* - "select " → select()
|
|
* - "x" → addX()
|
|
* - "y" → addY()
|
|
* - "norm" → sets fNorm flag
|
|
* - "plot" → plot()
|
|
* - "macro" → macro()
|
|
* - "var" → var_cmd()
|
|
* - "col" → (handled internally by var)
|
|
*
|
|
* Emits finished() signal upon completion or error.
|
|
*
|
|
* @return 0 on success, non-zero error code on failure
|
|
*/
|
|
int PmuppScript::executeScript()
|
|
{
|
|
fParamDataHandler = std::make_unique<PParamDataHandler>();
|
|
if (fParamDataHandler == nullptr) {
|
|
std::cerr << std::endl << "**ERROR** couldn't invoke data handler ..." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
QString cmd;
|
|
int status;
|
|
for (int i=0; i<fScript.size(); i++) {
|
|
status = 0;
|
|
cmd = fScript.at(i);
|
|
if (cmd.startsWith("loadPath")) {
|
|
setLoadPath(cmd);
|
|
} else if (cmd.startsWith("savePath")) {
|
|
setSavePath(cmd);
|
|
} else if (cmd.startsWith("load ")) {
|
|
status = loadCollection(cmd);
|
|
} else if (cmd.startsWith("selectAll")) {
|
|
status = selectAll();
|
|
} else if (cmd.startsWith("select ")) {
|
|
status = select(cmd);
|
|
} else if (cmd.startsWith("x")) {
|
|
status = addX(cmd);
|
|
} else if (cmd.startsWith("y")) {
|
|
status = addY(cmd);
|
|
} else if (cmd.startsWith("norm")) {
|
|
fNorm = true;
|
|
} else if (cmd.startsWith("plot")) {
|
|
status = plot(cmd);
|
|
} else if (cmd.startsWith("macro")) {
|
|
status = macro(cmd);
|
|
} else if (cmd.startsWith("var")) {
|
|
status = var_cmd(cmd);
|
|
} else if (cmd.startsWith("col")) {
|
|
// nothing to be done here, since var handles it internally
|
|
} else {
|
|
std::cerr << "**ERROR** found unkown script command '" << cmd.toLatin1().constData() << "'." << std::endl << std::endl;
|
|
status = -2;
|
|
}
|
|
// check for errors
|
|
if (status != 0) {
|
|
emit finished();
|
|
return status;
|
|
}
|
|
}
|
|
|
|
emit finished();
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Sets the load path for input data files.
|
|
*
|
|
* Parses the loadPath command string and extracts the directory path.
|
|
* Supports environment variable expansion: variables prefixed with '$'
|
|
* are replaced with their values from the system environment.
|
|
*
|
|
* Path processing:
|
|
* 1. Removes "loadPath " prefix from command
|
|
* 2. Tokenizes path by '/' separator
|
|
* 3. Expands environment variables ($VAR_NAME)
|
|
* 4. Reconstructs full path with '/' separators
|
|
*
|
|
* Example: "loadPath $HOME/data/musrfit/"
|
|
* → "/home/user/data/musrfit/"
|
|
*
|
|
* @param cmd loadPath command string including path specification
|
|
*/
|
|
void PmuppScript::setLoadPath(const QString cmd)
|
|
{
|
|
QString str = cmd;
|
|
QStringList tok;
|
|
|
|
// remove command from string
|
|
str = str.remove("loadPath ");
|
|
|
|
// tokenize path string
|
|
tok = str.split("/", Qt::SkipEmptyParts);
|
|
|
|
// check if there is a bash variable which needs to be resolved
|
|
QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
|
|
QString path = QString("");
|
|
for (int i=0; i<tok.size(); i++) {
|
|
str = tok.at(i);
|
|
if (str.startsWith("$")) {
|
|
str = str.remove("$");
|
|
QString var = procEnv.value(str, "");
|
|
path += var + "/";
|
|
} else {
|
|
path += str + "/";
|
|
}
|
|
}
|
|
|
|
fLoadPath = path;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Sets the save path for output files.
|
|
*
|
|
* Parses the savePath command string and extracts the directory path.
|
|
* Uses the same environment variable expansion mechanism as setLoadPath().
|
|
*
|
|
* Path processing:
|
|
* 1. Removes "savePath " prefix from command
|
|
* 2. Tokenizes path by '/' separator
|
|
* 3. Expands environment variables ($VAR_NAME)
|
|
* 4. Reconstructs full path with '/' separators
|
|
*
|
|
* Example: "savePath $HOME/plots/"
|
|
* → "/home/user/plots/"
|
|
*
|
|
* @param cmd savePath command string including path specification
|
|
*/
|
|
void PmuppScript::setSavePath(const QString cmd)
|
|
{
|
|
QString str = cmd;
|
|
QStringList tok;
|
|
|
|
// remove command from string
|
|
str = str.remove("savePath ");
|
|
|
|
// tokenize path string
|
|
tok = str.split("/", Qt::SkipEmptyParts);
|
|
|
|
// check if there is a bash variable which needs to be resolved
|
|
QProcessEnvironment procEnv = QProcessEnvironment::systemEnvironment();
|
|
QString path = QString("");
|
|
for (int i=0; i<tok.size(); i++) {
|
|
str = tok.at(i);
|
|
if (str.startsWith("$")) {
|
|
str = str.remove("$");
|
|
QString var = procEnv.value(str, "");
|
|
path += var + "/";
|
|
} else {
|
|
path += str + "/";
|
|
}
|
|
}
|
|
|
|
fSavePath = path;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Loads a data collection from file.
|
|
*
|
|
* Parses the load command to extract the filename, prepends the load path,
|
|
* and reads the parameter data file via the PParamDataHandler.
|
|
*
|
|
* Processing steps:
|
|
* 1. Removes "load " prefix from command string
|
|
* 2. Trims whitespace from filename
|
|
* 3. Prepends fLoadPath to create full file path
|
|
* 4. Calls ReadParamFile() to load the data
|
|
*
|
|
* @param str load command string (format: "load filename.ext")
|
|
*
|
|
* @return 0 on success, 1 if file reading fails
|
|
*/
|
|
int PmuppScript::loadCollection(const QString str)
|
|
{
|
|
QString fln = str;
|
|
fln = fln.remove("load ");
|
|
fln = fln.trimmed();
|
|
fln = fln.prepend(fLoadPath);
|
|
|
|
QStringList flnList;
|
|
flnList << fln;
|
|
|
|
QString errorMsg("");
|
|
if (!fParamDataHandler->ReadParamFile(flnList, errorMsg))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Selects a specific collection for plotting.
|
|
*
|
|
* Parses the select command to identify a collection by either:
|
|
* - Numeric index (0, 1, 2, ...)
|
|
* - Collection name string
|
|
*
|
|
* The selected collection becomes the target for subsequent x and y
|
|
* commands. Sets fSelected to the collection index.
|
|
*
|
|
* @param str select command string (format: "select <index|name>")
|
|
*
|
|
* @return 0 on success
|
|
* @return -1 wrong command syntax
|
|
* @return -2 collection index out of range
|
|
* @return -3 collection name not found
|
|
*/
|
|
int PmuppScript::select(const QString str)
|
|
{
|
|
QString cmd = str;
|
|
QStringList tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
if (tok.size() != 2) {
|
|
std::cerr << std::endl << "**ERROR** wrong 'select' command syntax." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
bool ok;
|
|
int ival = tok[1].toInt(&ok);
|
|
if (ok) { // collection index given
|
|
if (ival >= fParamDataHandler->GetNoOfCollections()) {
|
|
std::cerr << std::endl << "**ERROR** try to select a collection with index " << ival << ", which is >= # collections (" << fParamDataHandler->GetNoOfCollections() << ")." << std::endl << std::endl;
|
|
return -2;
|
|
}
|
|
fSelected = ival;
|
|
} else { // assume that a collection name is given
|
|
ival = fParamDataHandler->GetCollectionIndex(tok[1]);
|
|
if (ival == -1) {
|
|
std::cerr << std::endl << "**ERROR** couldn't find collection '" << tok[1].toLatin1().constData() << "'." << std::endl << std::endl;
|
|
return -3;
|
|
}
|
|
if (ival >= fParamDataHandler->GetNoOfCollections()) {
|
|
std::cerr << std::endl << "**ERROR** try to select a collection with index " << ival << ", which is >= # collections (" << fParamDataHandler->GetNoOfCollections() << ")." << std::endl << std::endl;
|
|
return -2;
|
|
}
|
|
fSelected = ival;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Selects all loaded collections for plotting.
|
|
*
|
|
* Enables batch plotting mode where subsequent x and y commands apply
|
|
* to all collections. Sets fSelected to -1 (all-selected state).
|
|
*
|
|
* This mode is useful for creating overlay plots showing multiple
|
|
* data sets with the same parameter axes.
|
|
*
|
|
* @return 0 on success, -1 if no collections are loaded
|
|
*/
|
|
int PmuppScript::selectAll()
|
|
{
|
|
int noColl = fParamDataHandler->GetNoOfCollections();
|
|
if ( noColl > 0) {
|
|
fSelected = -1; // all collections are selected
|
|
} else {
|
|
std::cerr << std::endl << "**ERROR** no collections present, hence it is not possible to select them." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Adds a parameter label to the X-axis.
|
|
*
|
|
* Configures the X-axis (independent variable) for the plot. The label
|
|
* can be either:
|
|
* - A parameter name from the collection (e.g., "dataT", "dataB")
|
|
* - A defined variable expression
|
|
*
|
|
* Behavior depends on selection state:
|
|
* - fSelected == -2: Error (no selection made)
|
|
* - fSelected == -1: Applies to all collections (creates fPlotInfo entries)
|
|
* - fSelected >= 0: Applies to specific collection (sets fPlotEntry)
|
|
*
|
|
* Validation:
|
|
* - Checks if label exists in collection(s) or as a variable
|
|
* - Reports error if label not found
|
|
*
|
|
* @param str x command string (format: "x <label>")
|
|
*
|
|
* @return 0 on success
|
|
* @return -1 wrong command syntax
|
|
* @return -2 no collection selected
|
|
* @return -3 selected collection not found
|
|
* @return -4 label not found in collection or variables
|
|
*/
|
|
int PmuppScript::addX(const QString str)
|
|
{
|
|
QString cmd = str, label;
|
|
QStringList tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
|
|
if (tok.size() != 2) {
|
|
std::cerr << std::endl << "**ERROR** in addX: number of tokens missmatch." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
label = tok[1].trimmed();
|
|
|
|
PmuppCollection *coll=0;
|
|
if (fSelected == -2) { // no selection -> error
|
|
std::cerr << std::endl << "**ERROR** in addX. addX called without previous 'select' command." << std::endl << std::endl;
|
|
return -2;
|
|
} else if (fSelected == -1) { // i.e. select ALL
|
|
// clean up plot info first
|
|
fPlotInfo.clear();
|
|
|
|
// make sure that label is found in ALL collections, or in variables
|
|
// first check collections
|
|
bool foundInColl(true), foundInVar(true);
|
|
QString collName("");
|
|
for (int i=0; i<fParamDataHandler->GetNoOfCollections(); i++) {
|
|
coll = fParamDataHandler->GetCollection(i);
|
|
if (!foundLabel(coll, label)) { // label not found
|
|
foundInColl = false;
|
|
collName = coll->GetName();
|
|
break;
|
|
}
|
|
}
|
|
// second check variables
|
|
if (!foundVariable(label)) { // label not found
|
|
foundInVar = false;
|
|
}
|
|
// make sure label(s) have been found
|
|
if (!foundInColl && !foundInVar) { // not all labels found, neither in collection nor variables.
|
|
std::cerr << std::endl << "**ERROR** couldn't find '" << label.toLatin1().constData() << "' in collection '" << collName.toLatin1().constData() << "'," << std::endl;
|
|
std::cerr << " nor is it a defined variable" << std::endl << std::endl;
|
|
return -4;
|
|
}
|
|
|
|
// resize fPlotInfo to the number of selections
|
|
fPlotInfo.resize(fParamDataHandler->GetNoOfCollections());
|
|
|
|
// feed plot info
|
|
for (int i=0; i<fPlotInfo.size(); i++) {
|
|
fPlotInfo[i].collIdx = i;
|
|
fPlotInfo[i].xLabel = label;
|
|
}
|
|
} else { // a specific selection
|
|
// check that label is found in the selected collection, or in variables
|
|
coll = fParamDataHandler->GetCollection(fSelected);
|
|
if (coll == 0) {
|
|
std::cerr << std::endl << "**ERROR** in addX: selected collection couldn't be found ..." << std::endl << std::endl;
|
|
return -3;
|
|
}
|
|
// first check collection
|
|
bool foundInColl(true), foundInVar(true);
|
|
QString collName("");
|
|
if (!foundLabel(coll, label)) { // label not found
|
|
foundInColl = false;
|
|
collName = coll->GetName();
|
|
}
|
|
// second check variables
|
|
if (!foundVariable(label)) { // label not found
|
|
foundInVar = false;
|
|
}
|
|
// make sure label(s) have been found
|
|
if (!foundInColl && !foundInVar) { // not all labels found, neither in collection nor variables.
|
|
std::cerr << std::endl << "**ERROR** couldn't find '" << label.toLatin1().constData() << "' in collection '" << collName.toLatin1().constData() << "'," << std::endl;
|
|
std::cerr << " nor is it a defined variable" << std::endl << std::endl;
|
|
return -4;
|
|
}
|
|
|
|
// feed plot entry
|
|
fPlotEntry.collIdx = fSelected;
|
|
fPlotEntry.xLabel = label;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Adds one or more parameter labels to the Y-axis.
|
|
*
|
|
* Configures the Y-axis (dependent variable(s)) for the plot. Multiple
|
|
* Y-axis parameters can be specified in a single command, enabling
|
|
* multi-curve plots.
|
|
*
|
|
* Each label can be either:
|
|
* - A parameter name from the collection
|
|
* - A defined variable expression
|
|
*
|
|
* Behavior depends on selection state:
|
|
* - fSelected == -2: Error (no selection made)
|
|
* - fSelected == -1: Applies to all collections (updates fPlotInfo)
|
|
* - fSelected >= 0: Applies to specific collection (updates fPlotEntry,
|
|
* adds to fPlotInfo)
|
|
*
|
|
* Validation:
|
|
* - Checks if each label exists in collection(s) or as a variable
|
|
* - Reports error on first missing label
|
|
*
|
|
* @param str y command string (format: "y <label1> [label2] [label3] ...")
|
|
*
|
|
* @return 0 on success
|
|
* @return -1 wrong command syntax (< 2 tokens)
|
|
* @return -2 no collection selected
|
|
* @return -3 selected collection not found
|
|
* @return -4 label not found in collection or variables
|
|
*/
|
|
int PmuppScript::addY(const QString str)
|
|
{
|
|
QString cmd = str;
|
|
QVector<QString> label;
|
|
QStringList tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
|
|
if (tok.size() < 2) {
|
|
std::cerr << std::endl << "**ERROR** in addY: number of tokens < 2." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
// collect all potential labels
|
|
for (int i=1; i<tok.size(); i++)
|
|
label.push_back(tok[i].trimmed());
|
|
|
|
PmuppCollection *coll=0;
|
|
if (fSelected == -2) { // no selection -> error
|
|
std::cerr << std::endl << "**ERROR** in addY. addY called without previous 'select' command." << std::endl << std::endl;
|
|
return -2;
|
|
} else if (fSelected == -1) { // i.e. select ALL
|
|
// make sure that label(s) is/are found in ALL collections, or in variables
|
|
// first check collections
|
|
bool foundInColl(true), foundInVar(true);
|
|
int idx = -1;
|
|
QString collName("");
|
|
for (int i=0; i<fParamDataHandler->GetNoOfCollections(); i++) {
|
|
coll = fParamDataHandler->GetCollection(i);
|
|
for (int j=0; j<label.size(); j++) {
|
|
if (!foundLabel(coll, label[j])) { // label not found
|
|
foundInColl = false;
|
|
collName = coll->GetName();
|
|
idx = j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// second check variables
|
|
for (int i=0; i<label.size(); i++) {
|
|
if (!foundVariable(label[i])) { // label not found
|
|
foundInVar = false;
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
// make sure label(s) have been found
|
|
if (!foundInColl && !foundInVar) { // not all labels found, neither in collection nor variables.
|
|
std::cerr << std::endl << "**ERROR** couldn't find '" << label[idx].toLatin1().constData() << "' in collection '" << collName.toLatin1().constData() << "'," << std::endl;
|
|
std::cerr << " nor is it a defined variable" << std::endl << std::endl;
|
|
return -4;
|
|
}
|
|
|
|
// feed plot info with y-label(s)
|
|
for (int i=0; i<fPlotInfo.size(); i++) {
|
|
fPlotInfo[i].yLabel = label;
|
|
}
|
|
} else { // a specific selection
|
|
// clear yLabel
|
|
fPlotEntry.yLabel.clear();
|
|
|
|
// check that label is found in the selected collection, or in the variables
|
|
coll = fParamDataHandler->GetCollection(fSelected);
|
|
if (coll == 0) {
|
|
std::cerr << std::endl << "**ERROR** in addY: selected collection couldn't be found ..." << std::endl << std::endl;
|
|
return -3;
|
|
}
|
|
|
|
// first check specific collection
|
|
bool foundInColl(true), foundInVar(true);
|
|
int idx = -1;
|
|
QString collName("");
|
|
for (int i=0; i<label.size(); i++) {
|
|
if (!foundLabel(coll, label[i])) { // label not found
|
|
foundInColl = false;
|
|
collName = coll->GetName();
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
// second check variables
|
|
for (int i=0; i<label.size(); i++) {
|
|
if (!foundVariable(label[i])) { // label not found
|
|
foundInVar = false;
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
// make sure label(s) have been found
|
|
if (!foundInColl && !foundInVar) { // not all labels found, neither in collection nor variables.
|
|
std::cerr << std::endl << "**ERROR** couldn't find '" << label[idx].toLatin1().constData() << "' in collection '" << collName.toLatin1().constData() << "'," << std::endl;
|
|
std::cerr << " nor is it a defined variable" << std::endl << std::endl;
|
|
return -4;
|
|
}
|
|
|
|
fPlotEntry.yLabel = label;
|
|
|
|
// add plot entry
|
|
fPlotInfo.push_back(fPlotEntry);
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Creates a plot file by generating and executing a ROOT macro.
|
|
*
|
|
* This method performs the complete workflow for batch plot creation:
|
|
* 1. Generates a temporary ROOT C++ macro (__out.C)
|
|
* 2. Launches root.exe in batch mode to execute the macro
|
|
* 3. Creates the output plot file (format determined by extension)
|
|
* 4. Cleans up the temporary macro file
|
|
*
|
|
* Supported output formats (via ROOT):
|
|
* - .pdf - PDF document
|
|
* - .png - PNG image
|
|
* - .eps - Encapsulated PostScript
|
|
* - .svg - Scalable Vector Graphics
|
|
* - .root - ROOT file
|
|
*
|
|
* The method configures environment variables (LD_LIBRARY_PATH/
|
|
* DYLD_LIBRARY_PATH) to ensure ROOT finds its libraries.
|
|
*
|
|
* @param str plot command string (format: "plot output_filename.ext")
|
|
*
|
|
* @return 0 on success
|
|
* @return -1 wrong command syntax or macro generation failed
|
|
* @return -2 failed to create QProcess
|
|
* @return -3 failed to start root.exe
|
|
*/
|
|
int PmuppScript::plot(const QString str)
|
|
{
|
|
QString cmd = str;
|
|
QStringList tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
if (tok.size() != 2) {
|
|
std::cerr << std::endl << "**ERROR** in plot: number of tokens != 2." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
QString flnOut = fSavePath + tok[1];
|
|
QString macroOut = fSavePath + "__out.C";
|
|
|
|
if (macro(QString("macro " + macroOut), flnOut) != 0) {
|
|
std::cerr << std::endl << "**ERROR** temporary macro generation failed." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
// call root via batch
|
|
QProcess *proc = new QProcess(this);
|
|
if (proc == nullptr) {
|
|
std::cerr << std::endl << "**ERROR** couldn't invoke root.exe in batch mode." << std::endl << std::endl;
|
|
return -2;
|
|
}
|
|
|
|
// make sure that the system environment variables are properly set
|
|
QString exec_cmd = "root.exe";
|
|
QStringList arg;
|
|
arg << "-b";
|
|
arg << macroOut;
|
|
arg << "-q";
|
|
|
|
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
|
|
#if defined(Q_OS_DARWIN)
|
|
env.insert("DYLD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:/usr/local/lib:" + env.value("DYLD_LIBRARY_PATH"));
|
|
#else
|
|
env.insert("LD_LIBRARY_PATH", env.value("ROOTSYS") + "/lib:" + env.value("LD_LIBRARY_PATH"));
|
|
#endif
|
|
proc->setProcessEnvironment(env);
|
|
proc->setWorkingDirectory(fSavePath);
|
|
proc->start(exec_cmd, arg);
|
|
if (!proc->waitForStarted()) {
|
|
std::cerr << std::endl << "**ERROR** Could not execute the output command: " << exec_cmd.toLatin1().constData() << std::endl << std::endl;
|
|
QFile::remove(macroOut);
|
|
return -3;
|
|
}
|
|
proc->waitForFinished();
|
|
|
|
QFile::remove(macroOut);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Generates a ROOT C++ macro for plotting.
|
|
*
|
|
* Creates a complete, standalone ROOT macro that can be executed
|
|
* independently. The macro includes:
|
|
*
|
|
* Generated content:
|
|
* - Header with timestamp and filename
|
|
* - ROOT initialization and style settings
|
|
* - Data array declarations (xx, yy, error arrays)
|
|
* - Data population from collections/variables
|
|
* - TGraphAsymmErrors object creation
|
|
* - Canvas setup and configuration
|
|
* - Marker and color styling from configuration
|
|
* - Axis labels and ranges
|
|
* - Optional normalization
|
|
* - Optional SaveAs() call for plot output
|
|
*
|
|
* Data handling:
|
|
* - Retrieves X/Y values from collections or variables
|
|
* - Handles asymmetric error bars (positive/negative)
|
|
* - Calculates axis ranges with 5% padding
|
|
* - Supports normalization to maximum Y value
|
|
*
|
|
* Styling:
|
|
* - Uses marker and color definitions from PmuppAdmin
|
|
* - Falls back to default black circles if config exhausted
|
|
* - Applies ROOT formatting for Greek letters and subscripts
|
|
*
|
|
* @param str macro command string (format: "macro filename.C")
|
|
* @param plotFln optional output plot filename (adds SaveAs to macro)
|
|
*
|
|
* @return 0 on success
|
|
* @return -1 wrong command syntax
|
|
* @return -2 failed to open macro file for writing
|
|
* @return -3 X or Y label data not found (internal error)
|
|
*/
|
|
int PmuppScript::macro(const QString str, const QString plotFln)
|
|
{
|
|
QVector<PmuppMarker> marker = fAdmin->getMarkers();
|
|
QVector<PmuppColor> color = fAdmin->getColors();
|
|
|
|
QString cmd = str;
|
|
QStringList tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
if (tok.size() != 2) {
|
|
std::cerr << std::endl << "**ERROR** macro command with wrong number of arguments (" << tok.size() << ")." << std::endl << std::endl;
|
|
return -1;
|
|
}
|
|
QString macroName = tok[1].trimmed();
|
|
|
|
QString fln = fSavePath + macroName;
|
|
QFile file(fln);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
std::cerr << std::endl << "**ERROR** Couldn't open macro file for writting." << std::endl << std::endl;
|
|
return -2;
|
|
}
|
|
|
|
QTextStream fout(&file);
|
|
|
|
// write header
|
|
fout << "// --------------------------" << Qt::endl;
|
|
fout << "// " << fln.toLatin1().constData() << Qt::endl;
|
|
fout << "// " << QDateTime::currentDateTime().toString("yy/MM/dd - HH:mm:ss") << Qt::endl;
|
|
fout << "// --------------------------" << Qt::endl;
|
|
fout << "{" << Qt::endl;
|
|
fout << " gROOT->Reset();" << Qt::endl;
|
|
fout << Qt::endl;
|
|
fout << " gStyle->SetOptTitle(0);" << Qt::endl;
|
|
fout << " gStyle->SetOptDate(0);" << Qt::endl;
|
|
fout << " gStyle->SetPadColor(TColor::GetColor(255,255,255)); // pad bkg to white" << Qt::endl;
|
|
fout << " gStyle->SetCanvasColor(TColor::GetColor(255,255,255)); // canvas bkg to white" << Qt::endl;
|
|
fout << Qt::endl;
|
|
fout << " Int_t nn=0, i=0;" << Qt::endl;
|
|
fout << " Double_t null[512];" << Qt::endl;
|
|
fout << " Double_t xx[512];" << Qt::endl;
|
|
fout << " Double_t yy[512];" << Qt::endl;
|
|
fout << " Double_t yyPosErr[512];" << Qt::endl;
|
|
fout << " Double_t yyNegErr[512];" << Qt::endl;
|
|
fout << Qt::endl;
|
|
|
|
// write data
|
|
QVector<double> xx, yy, yyPosErr, yyNegErr;
|
|
QString collName;
|
|
int count=0;
|
|
double x_min=0.0, x_max=0.0, x_min_new=0.0, x_max_new=0.0, y_min=0.0, y_max=0.0, y_min_new=0.0, y_max_new=0.0;
|
|
double dval, y_min_norm=1.0e10;
|
|
for (int i=0; i<fPlotInfo.size(); i++) {
|
|
// get collection name
|
|
collName = fParamDataHandler->GetCollectionName(i);
|
|
xx = fParamDataHandler->GetValues(collName, fPlotInfo[i].xLabel);
|
|
if (xx.size() == 0) { // it is a variable
|
|
int idx = getVarIndex(fPlotInfo[i].xLabel);
|
|
if (idx == -1) {
|
|
std::cerr << std::endl;
|
|
std::cerr << "**ERROR** Couldn't get x-label '" << fPlotInfo[i].xLabel.toLatin1().data() << "'." << std::endl;
|
|
std::cerr << " This should never happens." << std::endl;
|
|
return -3;
|
|
}
|
|
std::vector<double> xVal = fVarHandler[idx].getValues();
|
|
QVector<double> qvec(xVal.begin(), xVal.end());
|
|
xx = qvec;
|
|
}
|
|
// get x-axis min/max
|
|
minMax(xx, x_min, x_max);
|
|
if (count==0) {
|
|
x_min_new = x_min;
|
|
x_max_new = x_max;
|
|
} else {
|
|
if (x_min < x_min_new)
|
|
x_min_new = x_min;
|
|
if (y_max > x_max_new)
|
|
x_max_new = x_max;
|
|
}
|
|
|
|
for (int j=0; j<fPlotInfo[i].yLabel.size(); j++) {
|
|
yy = fParamDataHandler->GetValues(collName, fPlotInfo[i].yLabel[j]);
|
|
yyPosErr = fParamDataHandler->GetPosErr(collName, fPlotInfo[i].yLabel[j]);
|
|
yyNegErr = fParamDataHandler->GetNegErr(collName, fPlotInfo[i].yLabel[j]);
|
|
if (yy.size() == 0) { // it's a variable
|
|
int idx = getVarIndex(fPlotInfo[i].yLabel[j]);
|
|
if (idx == -1) {
|
|
std::cerr << std::endl;
|
|
std::cerr << "**ERROR** Couldn't get y-label '" << fPlotInfo[i].yLabel[j].toLatin1().data() << "'." << std::endl;
|
|
std::cerr << " This should never happens." << std::endl;
|
|
return -3;
|
|
}
|
|
std::vector<double> yVal = fVarHandler[idx].getValues();
|
|
QVector<double> qvecV(yVal.begin(), yVal.end());
|
|
yy = qvecV;
|
|
std::vector<double> yErr = fVarHandler[idx].getErrors();
|
|
QVector<double> qvecE(yErr.begin(), yErr.end());
|
|
yyPosErr = qvecE;
|
|
yyNegErr = qvecE;
|
|
}
|
|
// get y-axis min/max
|
|
minMax(yy, y_min, y_max);
|
|
if (count==0) {
|
|
y_min_new = y_min;
|
|
y_max_new = y_max;
|
|
} else {
|
|
if (y_min < y_min_new)
|
|
y_min_new = y_min;
|
|
if (y_max > y_max_new)
|
|
y_max_new = y_max;
|
|
}
|
|
fout << " // " << ++count << ". data set" << Qt::endl;
|
|
fout << " nn = " << xx.size() << ";" << Qt::endl;
|
|
fout << " // null-values" << Qt::endl;
|
|
for (int k=0; k<xx.size(); k++) {
|
|
fout << " null[" << k << "]=0.0;" << Qt::endl;
|
|
}
|
|
fout << " // x-values" << Qt::endl;
|
|
for (int k=0; k<xx.size(); k++) {
|
|
fout << " xx[" << k << "]=" << xx[k] << ";" << Qt::endl;
|
|
}
|
|
fout << " // y-values" << Qt::endl;
|
|
for (int k=0; k<yy.size(); k++) {
|
|
dval = yy[k];
|
|
if (fNorm) {
|
|
dval /= y_max;
|
|
if (dval < y_min_norm)
|
|
y_min_norm = dval;
|
|
}
|
|
fout << " yy[" << k << "]=" << dval << ";" << Qt::endl;
|
|
}
|
|
fout << " // yyNegErr-values" << Qt::endl;
|
|
for (int k=0; k<yyNegErr.size(); k++) {
|
|
dval = fabs(yyNegErr[k]);
|
|
if (fNorm)
|
|
dval /= fabs(y_max);
|
|
fout << " yyNegErr[" << k << "]=" << dval << ";" << Qt::endl;
|
|
}
|
|
fout << " // yyPosErr-values" << Qt::endl;
|
|
for (int k=0; k<yyPosErr.size(); k++) {
|
|
dval = fabs(yyPosErr[k]);
|
|
if (fNorm)
|
|
dval /= fabs(y_max);
|
|
fout << " yyPosErr[" << k << "]=" << dval << ";" << Qt::endl;
|
|
}
|
|
fout << Qt::endl;
|
|
fout << " TGraphAsymmErrors *g_" << i << "_" << j << " = new TGraphAsymmErrors(nn, xx, yy, null, null, yyNegErr, yyPosErr);" << Qt::endl;
|
|
fout << Qt::endl;
|
|
}
|
|
}
|
|
|
|
// x,y-min/max range
|
|
double diff;
|
|
if (x_min_new > 0.0)
|
|
x_min = 0.0;
|
|
else
|
|
x_min = x_min_new;
|
|
diff = x_max-x_min;
|
|
x_max = x_max_new + 0.05*diff;
|
|
diff = y_max_new - y_min_new;
|
|
y_min = y_min_new - 0.05 * diff;
|
|
y_max = y_max_new + 0.05 * diff;
|
|
if (fNorm) {
|
|
diff = 1.0 - y_min_norm;
|
|
y_min = y_min_norm - 0.05 * diff;
|
|
y_max = 1.0 + 0.05 * diff;
|
|
}
|
|
|
|
// plotting
|
|
fout << " //**********" << Qt::endl;
|
|
fout << " // plotting " << Qt::endl;
|
|
fout << " //**********" << Qt::endl;
|
|
fout << " TCanvas *c1 = new TCanvas(\"c1\", \"" << macroName.toLatin1().constData() << "\", 10, 10, 600, 700);" << Qt::endl;
|
|
fout << Qt::endl;
|
|
|
|
count = 0;
|
|
int rr, gg, bb;
|
|
for (int i=0; i<fPlotInfo.size(); i++) {
|
|
for (int j=0; j<fPlotInfo[i].yLabel.size(); j++) {
|
|
if (count == 0) {
|
|
if (count < marker.size()) {
|
|
fout << " g_" << i << "_" << j << "->SetMarkerStyle(" << marker[count].getMarker() << ");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerSize(" << marker[count].getMarkerSize() << ");" << Qt::endl;
|
|
color[count].getRGB(rr, gg, bb);
|
|
fout << " g_" << i << "_" << j << "->SetMarkerColor(TColor::GetColor(" << rr << "," << gg << "," << bb << "));" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetLineColor(TColor::GetColor(" << rr << "," << gg << "," << bb << "));" << Qt::endl;
|
|
} else {
|
|
fout << " g_" << i << "_" << j << "->SetMarkerStyle(20);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerSize(1.3);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerColor(TColor::GetColor(0,0,0));" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetLineColor(TColor::GetColor(0,0,0));" << Qt::endl;
|
|
}
|
|
fout << " g_" << i << "_" << j << "->SetFillColor(kWhite);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetXaxis()->SetTitle(\"" << getNicerLabel(fPlotInfo[0].xLabel).toLatin1().data() << "\");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetXaxis()->SetTitleSize(0.05);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetXaxis()->SetDecimals(kTRUE);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetXaxis()->SetLimits(" << x_min << "," << x_max << ");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetYaxis()->SetTitle(\"" << getNicerLabel(fPlotInfo[0].yLabel[0]).toLatin1().data() << "\");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetYaxis()->SetTitleSize(0.05);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetYaxis()->SetTitleOffset(1.30);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->GetYaxis()->SetRangeUser(" << y_min << "," << y_max << ");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->Draw(\"AP\");" << Qt::endl;
|
|
} else {
|
|
if (count < marker.size()) {
|
|
fout << " g_" << i << "_" << j << "->SetMarkerStyle(" << marker[count].getMarker() << ");" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerSize(" << marker[count].getMarkerSize() << ");" << Qt::endl;
|
|
color[count].getRGB(rr, gg, bb);
|
|
fout << " g_" << i << "_" << j << "->SetMarkerColor(TColor::GetColor(" << rr << "," << gg << "," << bb << "));" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetLineColor(TColor::GetColor(" << rr << "," << gg << "," << bb << "));" << Qt::endl;
|
|
} else {
|
|
fout << " g_" << i << "_" << j << "->SetMarkerStyle(20);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerSize(1.3);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetMarkerColor(TColor::GetColor(0,0,0));" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->SetLineColor(TColor::GetColor(0,0,0));" << Qt::endl;
|
|
}
|
|
fout << " g_" << i << "_" << j << "->SetFillColor(kWhite);" << Qt::endl;
|
|
fout << " g_" << i << "_" << j << "->Draw(\"Psame\");" << Qt::endl;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
fout << " c1->SetMargin(0.15, 0.05, 0.12, 0.05);" << Qt::endl;
|
|
fout << " c1->Update();" << Qt::endl;
|
|
if (!plotFln.isEmpty()) {
|
|
fout << Qt::endl;
|
|
fout << " c1->SaveAs(\"" << plotFln.toLatin1().constData() << "\");" << Qt::endl;
|
|
}
|
|
fout << "}" << Qt::endl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Processes a variable definition command.
|
|
*
|
|
* Variables enable defining derived quantities as mathematical expressions
|
|
* combining collection parameters. For example:
|
|
* - "var amplitude sigma+lambda"
|
|
* - "var asymmetry (forward-backward)/(forward+backward)"
|
|
*
|
|
* Processing steps:
|
|
* 1. Extracts variable name from command
|
|
* 2. Checks if variable is linked to a collection (via col command)
|
|
* 3. Locates optional error variable definition (varNameErr)
|
|
* 4. Creates PVarHandler for expression parsing and evaluation
|
|
* 5. Validates variable and stores handler if valid
|
|
*
|
|
* Error handling:
|
|
* - Error variables (ending in "Err") are processed silently
|
|
* - Invalid expressions write errors to ~/.musrfit/mupp/mupp_err.log
|
|
* - Error log is displayed and deleted on failure
|
|
*
|
|
* Integration with col command:
|
|
* The "col" command links variables to specific collections, enabling
|
|
* variable resolution during plot generation.
|
|
*
|
|
* @param str var command string (format: "var <name> <expression>")
|
|
*
|
|
* @return 0 on success
|
|
* @return 0 if variable not linked to collection (ignored)
|
|
* @return 0 if error variable (processing deferred)
|
|
* @return 1 if variable expression is invalid
|
|
*/
|
|
int PmuppScript::var_cmd(const QString str)
|
|
{
|
|
QStringList tok;
|
|
int idx=0;
|
|
|
|
// get linked collection index for further use
|
|
tok = str.split(' ', Qt::SkipEmptyParts);
|
|
if (tok[1].endsWith("Err")) // error variable no need to do something
|
|
return 0;
|
|
idx = getCollectionIndex(tok[1]);
|
|
if (idx == -1) // var not linked to collection, ignore it
|
|
return 0;
|
|
|
|
// check if the related error variable is present
|
|
QString varErr = QString("%1%2").arg(tok[1]).arg("Err");
|
|
QString varErrCmd("");
|
|
for (int i=0; i<fScript.size(); i++) {
|
|
if (fScript.at(i).contains(varErr, Qt::CaseSensitive)) {
|
|
varErrCmd = fScript.at(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::string parse_str = str.toLatin1().data();
|
|
if (!varErrCmd.isEmpty()) {
|
|
parse_str += "\n";
|
|
parse_str += varErrCmd.toLatin1().data();
|
|
}
|
|
|
|
PVarHandler varHandler(fParamDataHandler->GetCollection(idx), parse_str, tok[1].toLatin1().data());
|
|
if (!varHandler.isValid()) {
|
|
// deal with errors
|
|
QString mupp_err = QString("%1/.musrfit/mupp/mupp_err.log").arg(QString(qgetenv("HOME")));
|
|
|
|
// dump error messages if present
|
|
QFile fout(mupp_err);
|
|
if (fout.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QString msg;
|
|
while (!fout.atEnd()) {
|
|
msg = fout.readLine();
|
|
std::cerr << msg.toLatin1().data();
|
|
}
|
|
// delete potentially present mupp_err.log file
|
|
QFile::remove(mupp_err);
|
|
}
|
|
return 1;
|
|
}
|
|
fVarHandler.push_back(varHandler);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Checks if a parameter label exists in a collection.
|
|
*
|
|
* Searches the first run of the collection for a parameter matching
|
|
* the given label. Assumes all runs in a collection have the same
|
|
* parameter structure.
|
|
*
|
|
* @param coll pointer to collection to search
|
|
* @param label parameter label to find
|
|
*
|
|
* @return true if label found in collection, false otherwise
|
|
*/
|
|
bool PmuppScript::foundLabel(PmuppCollection *coll, const QString label)
|
|
{
|
|
bool result = false;
|
|
for (int i=0; i<coll->GetRun(0).GetNoOfParam(); i++) {
|
|
if (!coll->GetRun(0).GetParam(i).GetName().compare(label)) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Checks if a variable is defined in the variable handler.
|
|
*
|
|
* Searches the variable handler vector for a variable with the
|
|
* specified name. Used to validate variable references in x and y
|
|
* commands.
|
|
*
|
|
* @param var variable name to search for
|
|
*
|
|
* @return true if variable found, false otherwise
|
|
*/
|
|
bool PmuppScript::foundVariable(const QString var)
|
|
{
|
|
bool result = false;
|
|
for (int i=0; i<fVarHandler.size(); i++) {
|
|
if (!fVarHandler[i].getVarName().compare(var)) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Gets the index of a variable in the handler vector.
|
|
*
|
|
* Searches for a variable by name and returns its position in the
|
|
* fVarHandler vector. Used during macro generation to retrieve
|
|
* variable values.
|
|
*
|
|
* @param var variable name to search for
|
|
*
|
|
* @return variable index (0-based), or -1 if not found
|
|
*/
|
|
int PmuppScript::getVarIndex(const QString var)
|
|
{
|
|
int idx = -1;
|
|
for (int i=0; i<fVarHandler.size(); i++) {
|
|
if (!fVarHandler[i].getVarName().compare(var)) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Finds minimum and maximum values in a data vector.
|
|
*
|
|
* Scans through the data vector to determine the range. Used for
|
|
* automatic axis range calculation in plot generation.
|
|
*
|
|
* @param dvec data vector to analyze
|
|
* @param min output parameter: minimum value in vector
|
|
* @param max output parameter: maximum value in vector
|
|
*/
|
|
void PmuppScript::minMax(QVector<double> dvec, double &min, double &max)
|
|
{
|
|
min = 99.0e6;
|
|
max = -99.0e6;
|
|
for (int i=0; i<dvec.size(); i++) {
|
|
if (dvec[i] < min)
|
|
min = dvec[i];
|
|
if (dvec[i] > max)
|
|
max = dvec[i];
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Converts parameter labels to publication-quality ROOT format.
|
|
*
|
|
* Transforms standard parameter names into formatted labels suitable
|
|
* for publication plots, including:
|
|
* - Greek letters using ROOT markup (#sigma, #lambda, #alpha)
|
|
* - Subscripts and superscripts
|
|
* - Physical units
|
|
* - Normalization indicators (when fNorm is true)
|
|
*
|
|
* Special case handling:
|
|
* - dataE → "E (keV)"
|
|
* - dataT → "T (K)"
|
|
* - dataB → "B (G)"
|
|
* - sigma → "#sigma (1/#mus)" or normalized version
|
|
* - lambda → "#lambda (1/#mus)" or normalized version
|
|
* - rate → "Rate (1/#mus)" or normalized version
|
|
* - alpha_LR → "#alpha_{LR}" or normalized version
|
|
* - alpha_TB → "#alpha_{TB}" or normalized version
|
|
* - others → "label/ max(label)" if normalized
|
|
*
|
|
* @param label original parameter label string
|
|
*
|
|
* @return formatted label with ROOT markup
|
|
*/
|
|
QString PmuppScript::getNicerLabel(const QString label)
|
|
{
|
|
QString nice = label;
|
|
|
|
if (label == "dataE") {
|
|
nice = "E (keV)";
|
|
} else if (label == "dataT") {
|
|
nice = "T (K)";
|
|
} else if (label == "dataB") {
|
|
nice = "B (G)";
|
|
} else if (!label.compare("sigma", Qt::CaseInsensitive)) {
|
|
if (fNorm)
|
|
nice = "#sigma/max(#sigma)";
|
|
else
|
|
nice = "#sigma (1/#mus)";
|
|
} else if (!label.compare("lambda", Qt::CaseInsensitive)) {
|
|
if (fNorm)
|
|
nice = "#lambda/max(#lambda)";
|
|
else
|
|
nice = "#lambda (1/#mus)";
|
|
} else if (!label.compare("rate", Qt::CaseInsensitive)) {
|
|
if (fNorm)
|
|
nice = "Rate/max(Rate)";
|
|
else
|
|
nice = "Rate (1/#mus)";
|
|
} else if (!label.compare("alpha_LR", Qt::CaseInsensitive)) {
|
|
if (fNorm)
|
|
nice = "#alpha_{LR}/max(#alpha_{LR})";
|
|
else
|
|
nice = "#alpha_{LR}";
|
|
} else if (!label.compare("alpha_TB", Qt::CaseInsensitive)) {
|
|
if (fNorm)
|
|
nice = "#alpha_{TB}/max(#alpha_{TB})";
|
|
else
|
|
nice = "#alpha_{TB}";
|
|
} else {
|
|
if (fNorm) {
|
|
nice = label + "/ max(" + label + ")";
|
|
}
|
|
}
|
|
|
|
return nice;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
/**
|
|
* @brief Gets the collection index associated with a variable.
|
|
*
|
|
* Searches the script for a "col" command linking the variable to a
|
|
* collection. The col command format is:
|
|
* "col <collection_idx> -> <variable_name>"
|
|
*
|
|
* This association is necessary for variable evaluation, as the
|
|
* variable needs to know which collection's parameters to use.
|
|
*
|
|
* @param var_name variable name to search for
|
|
*
|
|
* @return collection index (0-based), or -1 if not found
|
|
*/
|
|
int PmuppScript::getCollectionIndex(const QString var_name)
|
|
{
|
|
int idx = -1;
|
|
QString cmd;
|
|
QStringList tok;
|
|
bool ok;
|
|
|
|
for (int i=0; i<fScript.size(); i++) {
|
|
cmd = fScript.at(i);
|
|
if (cmd.startsWith("col")) {
|
|
tok.clear();
|
|
tok = cmd.split(' ', Qt::SkipEmptyParts);
|
|
if (tok[3] == var_name) {
|
|
idx = tok[1].toInt(&ok);
|
|
if (!ok) {
|
|
Q_ASSERT(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|