ce6819b741
--- Added a "global" option to msr2data First, I hope, this major "surgery" does not cause any regressions in the standard features. If so, please revert to an older version and file a bug report. This new option is not yet documented and should be considered as experimental. Also the newly added code still needs some cleanup - many things have simply been written as a proof of concept. This will be done during further testing and fine-tuning stages.
1517 lines
54 KiB
C++
1517 lines
54 KiB
C++
/***************************************************************************
|
|
|
|
PMsr2Data.cpp
|
|
|
|
Author: Bastian M. Wojek / Andreas Suter
|
|
e-mail: andreas.suter@psi.ch
|
|
|
|
$Id$
|
|
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2009 by Bastian M. Wojek / 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. *
|
|
***************************************************************************/
|
|
|
|
#include <cctype>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <algorithm>
|
|
using namespace std;
|
|
|
|
#include <boost/algorithm/string/trim.hpp> // for stripping leading whitespace in std::string
|
|
#include <boost/algorithm/string/case_conv.hpp> // for to_lower() in std::string
|
|
#include <boost/algorithm/string/split.hpp> // split strings at certain characters
|
|
using namespace boost::algorithm;
|
|
|
|
#include <boost/lexical_cast.hpp> // for atoi-replacement
|
|
|
|
#include "PMsr2Data.h"
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p> Write formatted output to column-formatted ASCII output file
|
|
*/
|
|
void writeValues(ofstream &outFile, const double &value, const unsigned int &width)
|
|
{
|
|
if (fabs(value) >= 1.0e6 || (fabs(value) < 1.0e-4 && fabs(value) > 0.0))
|
|
outFile << scientific << setprecision(width - 8);
|
|
else
|
|
outFile.setf(ios::floatfield);
|
|
outFile << setw(width) << left << value;
|
|
return;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
PMsr2Data::PMsr2Data(const string &ext) : fFileExtension(ext), fRunListFile(false), fNumGlobalParam(0), fNumSpecParam(0), fNumTempRunBlocks(0)
|
|
{
|
|
fRunVector.clear();
|
|
fRunVectorIter = fRunVector.end();
|
|
fRunListFileStream = 0;
|
|
fSaxParser = 0;
|
|
fStartupHandler = 0;
|
|
fDataHandler = 0;
|
|
fMsrHandler = 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
PMsr2Data::~PMsr2Data()
|
|
{
|
|
fRunVector.clear();
|
|
fRunVectorIter = fRunVector.end();
|
|
fIndVar.clear();
|
|
|
|
if (fRunListFileStream) {
|
|
fRunListFileStream->close();
|
|
delete fRunListFileStream;
|
|
fRunListFileStream = 0;
|
|
}
|
|
if (fSaxParser) {
|
|
delete fSaxParser;
|
|
fSaxParser = 0;
|
|
}
|
|
if (fStartupHandler) {
|
|
delete fStartupHandler;
|
|
fStartupHandler = 0;
|
|
}
|
|
if (fDataHandler) {
|
|
delete fDataHandler;
|
|
fDataHandler = 0;
|
|
}
|
|
if (fMsrHandler) {
|
|
delete fMsrHandler;
|
|
fMsrHandler = 0;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
unsigned int PMsr2Data::GetPresentRun() const
|
|
{
|
|
if (fRunVectorIter != fRunVector.end())
|
|
return *fRunVectorIter;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::SetRunNumbers(unsigned int runNo)
|
|
{
|
|
if (runNo > 9999 || runNo < 1)
|
|
return 1;
|
|
|
|
fRunVector.clear();
|
|
fRunVector.push_back(runNo);
|
|
fRunVectorIter = fRunVector.begin();
|
|
|
|
return 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::SetRunNumbers(unsigned int runNoStart, unsigned int runNoEnd)
|
|
{
|
|
if ((runNoStart > 9999) || (runNoEnd > 9999) || (runNoStart < 1) || (runNoEnd < 1))
|
|
return 1;
|
|
|
|
fRunVector.clear();
|
|
if (runNoStart <= runNoEnd) {
|
|
for (unsigned int i(runNoStart); i<=runNoEnd; ++i)
|
|
fRunVector.push_back(i);
|
|
} else {
|
|
for (unsigned int i(runNoStart); i>=runNoEnd; --i)
|
|
fRunVector.push_back(i);
|
|
}
|
|
fRunVectorIter = fRunVector.begin();
|
|
|
|
return 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::SetRunNumbers(const vector<unsigned int> &runListVector)
|
|
{
|
|
if (runListVector.empty())
|
|
return -1;
|
|
|
|
for (vector<unsigned int>::const_iterator iter(runListVector.begin()); iter!=runListVector.end(); iter++) {
|
|
if (*iter > 9999 || *iter < 1)
|
|
return 1;
|
|
}
|
|
|
|
fRunVector = runListVector;
|
|
fRunVectorIter = fRunVector.begin();
|
|
|
|
return 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::SetRunNumbers(const string &runListFile)
|
|
{
|
|
fRunVector.clear();
|
|
|
|
ifstream in(runListFile.c_str());
|
|
if (!in) {
|
|
cerr << endl << ">> msr2data: **ERROR** The runlist file " << runListFile << " cannot be opened! Please check!";
|
|
cerr << endl;
|
|
return -1;
|
|
}
|
|
|
|
string line, indvar;
|
|
istringstream strLine;
|
|
vector<string> splitVec;
|
|
unsigned int cntr(0);
|
|
unsigned int runNo;
|
|
|
|
while (getline(in, line)) {
|
|
trim(line);
|
|
if (line.empty())
|
|
continue;
|
|
else if (line.at(0) == '#')
|
|
continue;
|
|
else
|
|
cntr++;
|
|
|
|
split( splitVec, line, is_any_of("#") ); // split the string if any comments appear on the line
|
|
|
|
if (cntr == 1) { // Read in the names of the independent variables in the runlist file
|
|
strLine.clear();
|
|
strLine.str(splitVec[0]);
|
|
strLine >> indvar; // "RUN"
|
|
if (indvar.compare("RUN")) {
|
|
cerr << endl << ">> msr2data: **ERROR** The format of the runlist file " << runListFile << " is not correct! Please check!";
|
|
cerr << endl;
|
|
}
|
|
while (strLine >> indvar)
|
|
fIndVar.push_back(indvar);
|
|
}
|
|
|
|
if (cntr > 1) {
|
|
strLine.clear();
|
|
strLine.str(splitVec[0]);
|
|
strLine >> runNo;
|
|
if (runNo > 9999 || runNo < 1)
|
|
return 1;
|
|
fRunVector.push_back(runNo);
|
|
}
|
|
|
|
splitVec.clear();
|
|
}
|
|
|
|
in.close();
|
|
fRunVectorIter = fRunVector.begin();
|
|
fRunListFile = true;
|
|
fRunListFileStream = new ifstream(runListFile.c_str());
|
|
return 0;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::ParseXmlStartupFile()
|
|
{
|
|
int status;
|
|
fSaxParser = new TSAXParser();
|
|
fStartupHandler = new PStartupHandler();
|
|
string startup_path_name(fStartupHandler->GetStartupFilePath().Data());
|
|
fSaxParser->ConnectToHandler("PStartupHandler", fStartupHandler);
|
|
status = fSaxParser->ParseFile(startup_path_name.c_str());
|
|
// check for parse errors
|
|
if (status) { // error
|
|
cerr << endl << ">> msr2data: **WARNING** reading/parsing musrfit_startup.xml." << endl;
|
|
// clean up
|
|
if (fSaxParser) {
|
|
delete fSaxParser;
|
|
fSaxParser = 0;
|
|
}
|
|
if (fStartupHandler) {
|
|
delete fStartupHandler;
|
|
fStartupHandler = 0;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::ReadMsrFile(const string &infile) const
|
|
{
|
|
int status;
|
|
fMsrHandler = new PMsrHandler(infile.c_str());
|
|
status = fMsrHandler->ReadMsrFile();
|
|
if (status != PMUSR_SUCCESS) {
|
|
switch (status) {
|
|
case PMUSR_MSR_FILE_NOT_FOUND:
|
|
cerr << endl << ">> msr2data: **ERROR** Could not find " << infile << endl;
|
|
break;
|
|
case PMUSR_MSR_SYNTAX_ERROR:
|
|
cerr << endl << ">> msr2data: **SYNTAX ERROR** in file " << infile << ", full stop here." << endl;
|
|
break;
|
|
default:
|
|
cerr << endl << ">> msr2data: **UNKOWN ERROR** when trying to read the msr-file" << endl;
|
|
break;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
bool PMsr2Data::ReadRunDataFile()
|
|
{
|
|
if (fStartupHandler)
|
|
fDataHandler = new PRunDataHandler(fMsrHandler, fStartupHandler->GetDataPathList());
|
|
else
|
|
fDataHandler = new PRunDataHandler(fMsrHandler);
|
|
|
|
bool success = fDataHandler->IsAllDataAvailable();
|
|
if (!success) {
|
|
cerr << endl << ">> msr2data: **WARNING** Could not read all data files, will continue without the data file information..." << endl;
|
|
delete fDataHandler;
|
|
fDataHandler = 0;
|
|
}
|
|
return success;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
bool PMsr2Data::PrepareNewInputFile(unsigned int tempRun) const
|
|
{
|
|
if (fRunVectorIter == fRunVector.end())
|
|
return false;
|
|
|
|
if (*fRunVectorIter == tempRun)
|
|
return true;
|
|
|
|
const unsigned int N(4); // number of digits for the runnumber
|
|
|
|
ostringstream strInfile;
|
|
strInfile << tempRun << fFileExtension << ".msr";
|
|
ifstream in(strInfile.str().c_str());
|
|
if (!in) {
|
|
cerr << endl << ">> msr2data: **ERROR** The template msr-file " << strInfile.str() << " cannot be opened! Please check!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
ostringstream strOutfile;
|
|
strOutfile << *fRunVectorIter << fFileExtension << ".msr";
|
|
ofstream out(strOutfile.str().c_str());
|
|
if (!out) {
|
|
cerr << endl << ">> msr2data: **ERROR** The new msr file " << strOutfile.str() << " cannot be opened! Please check!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
|
|
ostringstream tempRunNumber;
|
|
tempRunNumber.fill('0');
|
|
tempRunNumber.setf(ios::internal, ios::adjustfield);
|
|
tempRunNumber.width(N);
|
|
tempRunNumber << tempRun;
|
|
|
|
ostringstream newRunNumber;
|
|
newRunNumber.fill('0');
|
|
newRunNumber.setf(ios::internal, ios::adjustfield);
|
|
newRunNumber.width(N);
|
|
newRunNumber << *fRunVectorIter;
|
|
|
|
cout << endl << ">> msr2data: **INFO** Generating new input msr file " << strOutfile.str() << endl;
|
|
|
|
string line, firstOnLine;
|
|
istringstream strLine;
|
|
|
|
// write the run number in the TITLE line of the msr-file (is overwritten later by musrfit if called with the -t option)
|
|
getline(in, line);
|
|
out << *fRunVectorIter << endl;
|
|
|
|
while (getline(in, line)) {
|
|
if (line.empty()) {
|
|
out << endl;
|
|
continue;
|
|
}
|
|
if (!line.compare("SET BATCH") || !line.compare("END RETURN"))
|
|
continue;
|
|
|
|
strLine.clear();
|
|
strLine.str(line);
|
|
strLine >> firstOnLine;
|
|
if (!firstOnLine.compare("RUN")) {
|
|
string::size_type loc = line.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
line.replace(loc, N, newRunNumber.str());
|
|
} else {
|
|
cerr << endl << ">> msr2data: **WARNING** The template run file number does not match the \"file index\"";
|
|
cerr << endl << ">> msr2data: **WARNING** Unexpected things will happen... (for sure)";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
out << line << endl;
|
|
}
|
|
in.close();
|
|
out.close();
|
|
return true;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
bool compare_parameters(const PMsrParamStructure &par1, const PMsrParamStructure &par2)
|
|
{
|
|
if (par1.fIsGlobal) {
|
|
if (par2.fIsGlobal && (par2.fNo > par1.fNo))
|
|
return true;
|
|
else if (par2.fIsGlobal && (par2.fNo < par1.fNo))
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else if (par2.fIsGlobal)
|
|
return false;
|
|
else if (par2.fNo > par1.fNo)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
bool PMsr2Data::PrepareGlobalInputFile(unsigned int tempRun, const string &msrOutFile) const
|
|
{
|
|
const unsigned int N(4); // number of digits for the runnumber
|
|
const TString alpha("alpha"), beta("beta"), norm("norm"), bkgfit("bkgfit"), lifetime("lifetime");
|
|
|
|
ostringstream strInfile;
|
|
strInfile << tempRun << fFileExtension << ".msr";
|
|
// ifstream in(strInfile.str().c_str());
|
|
// if (!in) {
|
|
// cerr << endl << ">> msr2data: **ERROR** The template msr-file " << strInfile.str() << " cannot be opened! Please check!";
|
|
// cerr << endl;
|
|
// return false;
|
|
// }
|
|
// ostringstream strOutfile;
|
|
// strOutfile << tempRun << "+global" << fFileExtension << ".msr";
|
|
// ofstream out(strOutfile.str().c_str());
|
|
// if (!out) {
|
|
// cerr << endl << ">> msr2data: **ERROR** The new msr file " << strOutfile.str() << " cannot be opened! Please check!";
|
|
// cerr << endl;
|
|
// return false;
|
|
// }
|
|
|
|
// read template msr-file
|
|
int status(ReadMsrFile(strInfile.str()));
|
|
if (status != PMUSR_SUCCESS)
|
|
return false;
|
|
|
|
// check how many RUN blocks are in the template msr-file
|
|
fNumTempRunBlocks = fMsrHandler->GetMsrRunList()->size();
|
|
|
|
// check that the RUN block run numbers match the template run number
|
|
ostringstream tempRunNumber;
|
|
tempRunNumber.fill('0');
|
|
tempRunNumber.setf(ios::internal, ios::adjustfield);
|
|
tempRunNumber.width(N);
|
|
tempRunNumber << tempRun;
|
|
|
|
string tempRunName;
|
|
for (unsigned int i(0); i < fNumTempRunBlocks; ++i) {
|
|
tempRunName = fMsrHandler->GetMsrRunList()->at(i).GetRunName()->Data();
|
|
string::size_type loc = tempRunName.rfind(tempRunNumber.str());
|
|
if ( loc == string::npos ) {
|
|
cerr << endl << ">> msr2data: **ERROR** A template run file number does not match the \"file index\"";
|
|
cerr << endl << ">> msr2data: **ERROR** Please check the template file!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
cout << endl << ">> msr2data: **INFO** Generating new global input msr file " << msrOutFile << endl;
|
|
|
|
// search parameter list for run-specific parameters - the rest is assumed to be global
|
|
string tempParamName;
|
|
for (unsigned int i(0); i < fMsrHandler->GetMsrParamList()->size(); ++i) {
|
|
tempParamName = fMsrHandler->GetMsrParamList()->at(i).fName.Data();
|
|
string::size_type loc = tempParamName.rfind(tempRunNumber.str());
|
|
if ((tempParamName.length() > N) && (loc == tempParamName.length() - N)) {
|
|
fMsrHandler->GetMsrParamList()->at(i).fIsGlobal = false;
|
|
++fNumSpecParam;
|
|
} else {
|
|
fMsrHandler->GetMsrParamList()->at(i).fIsGlobal = true;
|
|
++fNumGlobalParam;
|
|
}
|
|
//cout << fMsrHandler->GetMsrParamList()->at(i).fNo << " is global: " << fMsrHandler->GetMsrParamList()->at(i).fIsGlobal << endl;
|
|
}
|
|
|
|
// Sort the parameters: global ones first, then run-specific
|
|
sort(fMsrHandler->GetMsrParamList()->begin(), fMsrHandler->GetMsrParamList()->end(), compare_parameters);
|
|
|
|
// Change the parameter numbers in all blocks according to the new order
|
|
PMsrLines *tempLines;
|
|
vector<string> tempVec;
|
|
int tempPar;
|
|
string line;
|
|
// THEORY block
|
|
tempLines = fMsrHandler->GetMsrTheory();
|
|
for (unsigned int i(0); i < tempLines->size(); ++i) {
|
|
line = (*tempLines)[i].fLine.Data();
|
|
split( tempVec, line, is_any_of(" ") ); // split the theory line at spaces
|
|
for (unsigned int j(1); j < tempVec.size(); ++j) {
|
|
try {
|
|
tempPar = boost::lexical_cast<unsigned int>(tempVec[j]);
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (unsigned int k(0); k < fMsrHandler->GetMsrParamList()->size(); ++k) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(k).fNo) {
|
|
tempVec[j] = boost::lexical_cast<string>(k + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch(boost::bad_lexical_cast &) {
|
|
// in case the cast does not work: do nothing - this means the entry is not a simple parameter
|
|
}
|
|
}
|
|
// replace the old theory line by the new one
|
|
(*tempLines)[i].fLine.Clear();
|
|
for (unsigned int j(0); j < tempVec.size(); ++j) {
|
|
(*tempLines)[i].fLine += TString(tempVec[j]) + TString(" ");
|
|
}
|
|
tempVec.clear();
|
|
}
|
|
|
|
// FUNCTIONS block
|
|
tempLines = fMsrHandler->GetMsrFunctions();
|
|
for (unsigned int i(0); i < tempLines->size(); ++i) {
|
|
line = (*tempLines)[i].fLine.Data();
|
|
split( tempVec, line, is_any_of(" ") ); // split the function line at spaces
|
|
for (unsigned int j(2); j < tempVec.size(); ++j) {
|
|
if (!tempVec[j].substr(0,3).compare("par")) {
|
|
try {
|
|
tempPar = boost::lexical_cast<unsigned int>(tempVec[j].substr(3));
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (unsigned int k(0); k < fMsrHandler->GetMsrParamList()->size(); ++k) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(k).fNo) {
|
|
tempVec[j] = "par";
|
|
tempVec[j].append(boost::lexical_cast<string>(k + 1));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch(boost::bad_lexical_cast &) {
|
|
cerr << endl << ">> msr2data: **ERROR** Something is wrong with the parameters used in the FUNCTIONS block!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - function parsing should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// replace the old function line by the new one
|
|
(*tempLines)[i].fLine.Clear();
|
|
for (unsigned int j(0); j < tempVec.size(); ++j) {
|
|
(*tempLines)[i].fLine += TString(tempVec[j]) + TString(" ");
|
|
}
|
|
tempVec.clear();
|
|
}
|
|
|
|
// RUN blocks
|
|
// substitute the old parameter numbers by the new ones and also
|
|
// search the RUN-blocks for run-specific parameters
|
|
|
|
vector<vector<pair<int, bool> > > runBlockParamIsGlobal(fNumTempRunBlocks);
|
|
pair<int, bool> runBlockTempParam;
|
|
vector<int> *tempMap;
|
|
unsigned int l(0);
|
|
|
|
// look in the following order through the RUN-blocks: norm, bkg-fit, alpha, beta, lifetime, maps
|
|
for (unsigned int i(0); i < fNumTempRunBlocks; ++i) {
|
|
tempPar = fMsrHandler->GetMsrRunList()->at(i).GetNormParamNo();
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetNormParamNo(l + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (l > fMsrHandler->GetMsrParamList()->size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The norm parameter specified in RUN block " << i + 1 << " does not exist!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - file checks should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at(l).fIsGlobal) { // norm of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(norm, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(norm, 0);
|
|
}
|
|
}
|
|
tempPar = fMsrHandler->GetMsrRunList()->at(i).GetBkgFitParamNo();
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetBkgFitParamNo(l + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (l > fMsrHandler->GetMsrParamList()->size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The backgr.fit parameter specified in RUN block " << i + 1 << " does not exist!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - file checks should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at(l).fIsGlobal) { // bkg-fit of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(bkgfit, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(bkgfit, 0);
|
|
}
|
|
}
|
|
tempPar = fMsrHandler->GetMsrRunList()->at(i).GetAlphaParamNo();
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetAlphaParamNo(l + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (l > fMsrHandler->GetMsrParamList()->size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The alpha parameter specified in RUN block " << i + 1 << " does not exist!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - file checks should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at(l).fIsGlobal) { // alpha of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(alpha, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(alpha, 0);
|
|
}
|
|
}
|
|
tempPar = fMsrHandler->GetMsrRunList()->at(i).GetBetaParamNo();
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetBetaParamNo(l + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (l > fMsrHandler->GetMsrParamList()->size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The beta parameter specified in RUN block " << i + 1 << " does not exist!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - file checks should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at(l).fIsGlobal) { // beta of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(beta, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(beta, 0);
|
|
}
|
|
}
|
|
tempPar = fMsrHandler->GetMsrRunList()->at(i).GetLifetimeParamNo();
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetLifetimeParamNo(l + 1);
|
|
break;
|
|
}
|
|
}
|
|
if (l > fMsrHandler->GetMsrParamList()->size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The lifetime parameter specified in RUN block " << i + 1 << " does not exist!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please report a bug - file checks should have failed earlier!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at(l).fIsGlobal) { // lifetime of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(lifetime, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetParGlobal(lifetime, 0);
|
|
}
|
|
}
|
|
tempMap = fMsrHandler->GetMsrRunList()->at(i).GetMap();
|
|
for (unsigned int j(0); j < tempMap->size(); ++j) {
|
|
tempPar = (*tempMap)[j];
|
|
if (tempPar > 0) {
|
|
// go through the whole parameter list and look for the correct parameter - this is stupid, however, I do not know what else to do
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
if (tempPar == fMsrHandler->GetMsrParamList()->at(l).fNo) {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetMap(l + 1, j);
|
|
break;
|
|
}
|
|
}
|
|
if (fMsrHandler->GetMsrParamList()->at((*tempMap)[j] - 1).fIsGlobal) { // map j of RUN block i is global
|
|
fMsrHandler->GetMsrRunList()->at(i).SetMapGlobal(j, 1);
|
|
} else {
|
|
fMsrHandler->GetMsrRunList()->at(i).SetMapGlobal(j, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tempMap = 0;
|
|
|
|
// finally fix the PARAMETER block after the reorganization
|
|
for (l = 0; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
fMsrHandler->GetMsrParamList()->at(l).fNo = l + 1;
|
|
}
|
|
|
|
// now go through the specified runs and add run-specific parameters and RUN blocks
|
|
|
|
map<UInt_t, TString> commentsP, commentsR;
|
|
TString tempTstr;
|
|
ostringstream newRunNumber;
|
|
newRunNumber.fill('0');
|
|
newRunNumber.setf(ios::internal, ios::adjustfield);
|
|
newRunNumber.width(N);
|
|
newRunNumber << *fRunVectorIter;
|
|
|
|
//cout << "Number of run specific parameters: " << fNumSpecParam << endl;
|
|
|
|
if (newRunNumber.str().compare(tempRunNumber.str())) { // first run number does not match the template run number
|
|
// substitute the template run-numbers in the parameter names
|
|
for (l = fNumGlobalParam; l < fMsrHandler->GetMsrParamList()->size(); ++l) {
|
|
tempParamName = fMsrHandler->GetMsrParamList()->at(l).fName.Data();
|
|
string::size_type loc = tempParamName.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
tempParamName.replace(loc, N, newRunNumber.str());
|
|
fMsrHandler->GetMsrParamList()->at(l).fName = tempParamName;
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** The indices of the run specific parameters do not match the template run number!";
|
|
cerr << endl << ">> msr2data: **ERROR** This should not happen! Please report a bug!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
// substitute the template run-numbers in the RUN names
|
|
for (unsigned int i(0); i < fNumTempRunBlocks; ++i) {
|
|
tempRunName = fMsrHandler->GetMsrRunList()->at(i).GetRunName()->Data();
|
|
string::size_type loc = tempRunName.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
tempRunName.replace(loc, N, newRunNumber.str());
|
|
tempTstr = TString(tempRunName);
|
|
fMsrHandler->GetMsrRunList()->at(i).SetRunName(tempTstr, 0);
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** A template run file number does not match the \"file index\"";
|
|
cerr << endl << ">> msr2data: **ERROR** Please check the template file!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
ostringstream tempStrStr;
|
|
|
|
// comments for the output-file
|
|
if (fNumGlobalParam) {
|
|
commentsP[1] = TString("Global parameters for all runs");
|
|
}
|
|
if (fNumSpecParam) {
|
|
tempStrStr.str("");
|
|
tempStrStr << "Specific parameters for run " << *fRunVectorIter;
|
|
tempTstr = tempStrStr.str();
|
|
commentsP[fNumGlobalParam + 1] = tempTstr;
|
|
}
|
|
if (fNumTempRunBlocks) {
|
|
tempStrStr.str("");
|
|
tempStrStr << "RUN blocks for run " << *fRunVectorIter;
|
|
tempTstr = tempStrStr.str();
|
|
commentsR[1] = tempTstr;
|
|
}
|
|
|
|
++fRunVectorIter;
|
|
|
|
UInt_t runcounter(0);
|
|
map<TString, Int_t> *runParGlobal(0);
|
|
map<TString, Int_t>::iterator iter;
|
|
PIntVector *runMapGlobal(0);
|
|
|
|
while (fRunVectorIter != fRunVector.end()) {
|
|
tempRunNumber.str(newRunNumber.str());
|
|
newRunNumber.str("");
|
|
newRunNumber.clear();
|
|
newRunNumber.fill('0');
|
|
newRunNumber.setf(ios::internal, ios::adjustfield);
|
|
newRunNumber.width(N);
|
|
newRunNumber << *fRunVectorIter;
|
|
|
|
// add parameters for each run
|
|
for (l = 0; l < fNumSpecParam; ++l) {
|
|
fMsrHandler->GetMsrParamList()->push_back(fMsrHandler->GetMsrParamList()->at(fNumGlobalParam + runcounter*fNumSpecParam + l));
|
|
tempParamName = fMsrHandler->GetMsrParamList()->back().fName.Data();
|
|
string::size_type loc = tempParamName.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
tempParamName.replace(loc, N, newRunNumber.str());
|
|
fMsrHandler->GetMsrParamList()->back().fName = tempParamName;
|
|
fMsrHandler->GetMsrParamList()->back().fNo += fNumSpecParam;
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** Something went wrong when appending new parameters!";
|
|
cerr << endl << ">> msr2data: **ERROR** This should not happen! Please report a bug!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
|
|
// add RUN blocks for each run
|
|
for (unsigned int i(0); i < fNumTempRunBlocks; ++i) {
|
|
fMsrHandler->GetMsrRunList()->push_back(fMsrHandler->GetMsrRunList()->at(runcounter*fNumTempRunBlocks + i));
|
|
tempRunName = fMsrHandler->GetMsrRunList()->back().GetRunName()->Data();
|
|
string::size_type loc = tempRunName.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
tempRunName.replace(loc, N, newRunNumber.str());
|
|
tempTstr = TString(tempRunName);
|
|
fMsrHandler->GetMsrRunList()->back().SetRunName(tempTstr, 0);
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** Something went wrong when appending new RUN blocks!";
|
|
cerr << endl << ">> msr2data: **ERROR** This should not happen! Please report a bug!";
|
|
cerr << endl;
|
|
return false;
|
|
}
|
|
// change run specific parameter numbers in the new RUN block
|
|
runParGlobal = fMsrHandler->GetMsrRunList()->back().GetParGlobal();
|
|
iter = runParGlobal->find(norm);
|
|
if (iter != runParGlobal->end()) {
|
|
if (!iter->second)
|
|
fMsrHandler->GetMsrRunList()->back().SetNormParamNo(fMsrHandler->GetMsrRunList()->back().GetNormParamNo() + fNumSpecParam);
|
|
}
|
|
iter = runParGlobal->find(bkgfit);
|
|
if (iter != runParGlobal->end()) {
|
|
if (!iter->second)
|
|
fMsrHandler->GetMsrRunList()->back().SetBkgFitParamNo(fMsrHandler->GetMsrRunList()->back().GetBkgFitParamNo() + fNumSpecParam);
|
|
}
|
|
iter = runParGlobal->find(alpha);
|
|
if (iter != runParGlobal->end()) {
|
|
if (!iter->second)
|
|
fMsrHandler->GetMsrRunList()->back().SetAlphaParamNo(fMsrHandler->GetMsrRunList()->back().GetAlphaParamNo() + fNumSpecParam);
|
|
}
|
|
iter = runParGlobal->find(beta);
|
|
if (iter != runParGlobal->end()) {
|
|
if (!iter->second)
|
|
fMsrHandler->GetMsrRunList()->back().SetBetaParamNo(fMsrHandler->GetMsrRunList()->back().GetBetaParamNo() + fNumSpecParam);
|
|
}
|
|
iter = runParGlobal->find(lifetime);
|
|
if (iter != runParGlobal->end()) {
|
|
if (!iter->second)
|
|
fMsrHandler->GetMsrRunList()->back().SetLifetimeParamNo(fMsrHandler->GetMsrRunList()->back().GetLifetimeParamNo() + fNumSpecParam);
|
|
}
|
|
runMapGlobal = fMsrHandler->GetMsrRunList()->back().GetMapGlobal();
|
|
for (l = 0; l < runMapGlobal->size(); ++l) {
|
|
if (!(*runMapGlobal)[l])
|
|
fMsrHandler->GetMsrRunList()->back().SetMap(fMsrHandler->GetMsrRunList()->back().GetMap()->at(l) + fNumSpecParam, l);
|
|
}
|
|
}
|
|
|
|
++runcounter;
|
|
|
|
// comments for the output-file
|
|
if (fNumSpecParam) {
|
|
tempStrStr.str("");
|
|
tempStrStr << "Specific parameters for run " << *fRunVectorIter;
|
|
tempTstr = tempStrStr.str();
|
|
commentsP[fNumGlobalParam + runcounter*fNumSpecParam + 1] = tempTstr;
|
|
}
|
|
if (fNumTempRunBlocks) {
|
|
tempStrStr.str("");
|
|
tempStrStr << "RUN blocks for run " << *fRunVectorIter;
|
|
tempTstr = tempStrStr.str();
|
|
commentsR[runcounter*fNumTempRunBlocks + 1] = tempTstr;
|
|
}
|
|
|
|
++fRunVectorIter;
|
|
}
|
|
|
|
// write the global msr-file
|
|
status = fMsrHandler->WriteMsrFile(msrOutFile.c_str(), &commentsP, 0, 0, &commentsR);
|
|
|
|
// set back the run-iterator to the start
|
|
fRunVectorIter = fRunVector.begin();
|
|
|
|
// in.close();
|
|
// out.close();
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------
|
|
/**
|
|
* <p>
|
|
*/
|
|
int PMsr2Data::WriteOutput(const string &outfile, bool db, bool withHeader, bool global, unsigned int counter) const
|
|
{
|
|
if (!to_lower_copy(outfile).compare("none")) {
|
|
fRunVectorIter++;
|
|
return PMUSR_SUCCESS;
|
|
}
|
|
|
|
const unsigned int N(4);
|
|
|
|
ostringstream curRunNumber;
|
|
curRunNumber.fill('0');
|
|
curRunNumber.setf(ios::internal, ios::adjustfield);
|
|
curRunNumber.width(N);
|
|
curRunNumber << *fRunVectorIter;
|
|
|
|
string msrTitle(fMsrHandler->GetMsrTitle()->Data());
|
|
string msrFileName(fMsrHandler->GetFileName().Data());
|
|
unsigned int msrNoOfParams(fMsrHandler->GetNoOfParams());
|
|
PMsrParamList *msrParamList(fMsrHandler->GetMsrParamList());
|
|
PMsrRunList *msrRunList(fMsrHandler->GetMsrRunList());
|
|
|
|
if (global && fRunVectorIter == fRunVector.begin()) {
|
|
// since the DB-ASCII-output is in principle independent of the original msr-file-generation
|
|
// the number of global and run specific parameters as well as the number of RUN blocks per run number have to be determined again
|
|
// in case no msr-file has been created before.
|
|
if (!fNumGlobalParam && !fNumSpecParam && !fNumTempRunBlocks) { // if not all parameters are zero they have been determined before
|
|
ostringstream tempRunNumber;
|
|
tempRunNumber.fill('0');
|
|
tempRunNumber.setf(ios::internal, ios::adjustfield);
|
|
tempRunNumber.width(N);
|
|
tempRunNumber << fRunVector.front();
|
|
|
|
// search parameter list for run-specific parameters
|
|
string tempName;
|
|
for (unsigned int i(0); i < msrParamList->size(); ++i) {
|
|
tempName = msrParamList->at(i).fName.Data();
|
|
string::size_type loc = tempName.rfind(tempRunNumber.str());
|
|
if ((tempName.length() > N) && (loc == tempName.length() - N)) {
|
|
if (!fNumSpecParam) {
|
|
fNumGlobalParam = i;
|
|
}
|
|
++fNumSpecParam;
|
|
}
|
|
}
|
|
if (!fNumSpecParam) {
|
|
fNumGlobalParam = msrParamList->size();
|
|
}
|
|
|
|
// look through the RUN blocks and count them
|
|
for (unsigned int i(0); i < msrRunList->size(); ++i) {
|
|
tempName = msrRunList->at(i).GetRunName()->Data();
|
|
string::size_type loc = tempName.rfind(tempRunNumber.str());
|
|
if ( loc != string::npos ) {
|
|
++fNumTempRunBlocks;
|
|
}
|
|
}
|
|
cerr << endl << ">> msr2data: **WARNING** At the moment the full integrity of the global msr file cannot be checked!";
|
|
cerr << endl << ">> msr2data: **WARNING** It should therefore be checked carefully that the run order is consistent";
|
|
cerr << endl << ">> msr2data: **WARNING** in the specified run list, the parameters and the RUN blocks in the msr file!";
|
|
cerr << endl << ">> msr2data: **WARNING** A simple check for the first specified run yields:";
|
|
cerr << endl << ">> msr2data: **WARNING** Number of global parameters: " << fNumGlobalParam;
|
|
cerr << endl << ">> msr2data: **WARNING** Number of run specific parameters: " << fNumSpecParam;
|
|
cerr << endl << ">> msr2data: **WARNING** Number of RUN blocks per run number: " << fNumTempRunBlocks;
|
|
cerr << endl;
|
|
}
|
|
// Two more simple consistency checks
|
|
bool okP(true), okR(true);
|
|
if ((msrParamList->size() - fNumGlobalParam)%fNumSpecParam) {
|
|
okP = false;
|
|
} else if ((msrParamList->size() - fNumGlobalParam)/fNumSpecParam != fRunVector.size()) {
|
|
okP = false;
|
|
}
|
|
|
|
if (!okP) {
|
|
cerr << endl << ">> msr2data: **ERROR** The number of parameters is not consistent with the specified run list!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please check carefully the integrity of the msr file!";
|
|
cerr << endl << ">> msr2data: **ERROR** No output will be written!";
|
|
cerr << endl;
|
|
return -1;
|
|
}
|
|
|
|
if (msrRunList->size()%fNumTempRunBlocks) {
|
|
okR = false;
|
|
} else if (msrRunList->size()/fNumTempRunBlocks != fRunVector.size()) {
|
|
okR = false;
|
|
}
|
|
|
|
if (!okR) {
|
|
cerr << endl << ">> msr2data: **ERROR** The number of RUN blocks is not consistent with the specified run list!";
|
|
cerr << endl << ">> msr2data: **ERROR** Please check carefully the integrity of the msr file!";
|
|
cerr << endl << ">> msr2data: **ERROR** No output will be written!";
|
|
cerr << endl;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
vector<string> dataParamNames;
|
|
vector<string> dataParamLabels;
|
|
vector<double> dataParam, dataParamErr;
|
|
|
|
if (fDataHandler) {
|
|
PRawRunData *rawRunData;
|
|
if (global) {
|
|
rawRunData = fDataHandler->GetRunData((*msrRunList)[fNumTempRunBlocks*counter].GetRunName()->Data());
|
|
} else {
|
|
rawRunData = fDataHandler->GetRunData((*msrRunList)[0].GetRunName()->Data());
|
|
}
|
|
|
|
switch (rawRunData->GetNoOfTemperatures()) {
|
|
case 1:
|
|
dataParamNames.push_back("dataT");
|
|
dataParamLabels.push_back("T (K)");
|
|
dataParam.push_back(rawRunData->GetTemperature(0));
|
|
dataParamErr.push_back(rawRunData->GetTempError(0));
|
|
break;
|
|
default:
|
|
ostringstream oss;
|
|
for (unsigned int i(0); i<rawRunData->GetNoOfTemperatures(); i++) {
|
|
oss << "dataT" << i;
|
|
dataParamNames.push_back(oss.str());
|
|
oss.str("");
|
|
oss << "T" << i << " (K)";
|
|
dataParamLabels.push_back(oss.str());
|
|
oss.str("");
|
|
dataParam.push_back(rawRunData->GetTemperature(i));
|
|
dataParamErr.push_back(rawRunData->GetTempError(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
double value;
|
|
value = rawRunData->GetField();
|
|
if (value != PMUSR_UNDEFINED) {
|
|
dataParamNames.push_back("dataB");
|
|
dataParamLabels.push_back("mu0 H (G)");
|
|
dataParam.push_back(value);
|
|
}
|
|
|
|
value = rawRunData->GetEnergy();
|
|
if (value != PMUSR_UNDEFINED) {
|
|
dataParamNames.push_back("dataE");
|
|
dataParamLabels.push_back("Implantation Energy (keV)");
|
|
dataParam.push_back(value);
|
|
}
|
|
|
|
value = rawRunData->GetTransport();
|
|
if (value != PMUSR_UNDEFINED) {
|
|
dataParamNames.push_back("dataTr");
|
|
dataParamLabels.push_back("Transport (kV)");
|
|
dataParam.push_back(value);
|
|
}
|
|
|
|
PDoubleVector ra(rawRunData->GetRingAnode());
|
|
if (ra.size() > 1) {
|
|
dataParamNames.push_back("dataRALRAR");
|
|
dataParamLabels.push_back("RAL-RAR (kV)");
|
|
dataParam.push_back(ra[0]-ra[1]);
|
|
}
|
|
if (ra.size() == 4) {
|
|
dataParamNames.push_back("dataRATRAB");
|
|
dataParamLabels.push_back("RAT-RAB (kV)");
|
|
dataParam.push_back(ra[2]-ra[3]);
|
|
}
|
|
rawRunData = 0;
|
|
}
|
|
|
|
// get the independent variable values from the runlist file if needed
|
|
PDoubleVector indVarValues;
|
|
|
|
if (fRunListFile) {
|
|
string line;
|
|
vector<string> splitVec;
|
|
unsigned int runNo;
|
|
double val;
|
|
istringstream strLine;
|
|
|
|
while (getline(*fRunListFileStream, line)) {
|
|
trim(line);
|
|
if (line.empty())
|
|
continue;
|
|
else if (line.at(0) == '#' || !line.substr(0,3).compare("RUN"))
|
|
continue;
|
|
else {
|
|
split( splitVec, line, is_any_of("#") ); // split the string if any comments appear on the line
|
|
strLine.clear();
|
|
strLine.str(splitVec[0]);
|
|
strLine >> runNo;
|
|
if (runNo != *fRunVectorIter) {
|
|
cerr << endl << ">> msr2data: **ERROR** The run number in the runlist file does not match the one which should be processed...";
|
|
cerr << endl << ">> msr2data: **ERROR** Something is very strange... Please report this bug!";
|
|
cerr << endl;
|
|
fRunVectorIter = fRunVector.end();
|
|
return -1;
|
|
}
|
|
while (strLine >> val) {
|
|
indVarValues.push_back(val);
|
|
}
|
|
if (indVarValues.size() != fIndVar.size()) {
|
|
cerr << endl << ">> msr2data: **ERROR** The number of data entries in the runlist file for the run number " << runNo;
|
|
cerr << endl << ">> msr2data: **ERROR** does not match the number of labels given in the RUN-line! Please check the file!";
|
|
cerr << endl;
|
|
fRunVectorIter = fRunVector.end();
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// The RUNLIST file stream and the run vector iterator might get out of synchronization, if the following check is placed before the above block...
|
|
PMsrStatisticStructure *msrStatistic(fMsrHandler->GetMsrStatistic());
|
|
if (!msrStatistic->fValid) { // in the GLOBAL mode this has already been checked before -> check should be negative anyway
|
|
cerr << endl << ">> msr2data: **WARNING** The fit of run " << *fRunVectorIter << " has not converged!";
|
|
cerr << endl << ">> msr2data: **WARNING** Its parameter data have not been appended to the output file " << outfile;
|
|
cerr << endl;
|
|
fRunVectorIter++;
|
|
|
|
delete fMsrHandler;
|
|
fMsrHandler = 0;
|
|
|
|
if (fDataHandler) {
|
|
delete fDataHandler;
|
|
fDataHandler = 0;
|
|
}
|
|
|
|
// clean up some vectors
|
|
dataParamNames.clear();
|
|
dataParamLabels.clear();
|
|
dataParam.clear();
|
|
dataParamErr.clear();
|
|
indVarValues.clear();
|
|
|
|
return -1;
|
|
}
|
|
|
|
// open the DB or dat file and write the data
|
|
|
|
ofstream outFile(outfile.c_str(), ios::app);
|
|
if (!outFile) {
|
|
cerr << endl << ">> msr2data: **ERROR** The output file " << outfile << " cannot be opened! Please check!";
|
|
cerr << endl;
|
|
fRunVectorIter = fRunVector.end();
|
|
return -1;
|
|
}
|
|
|
|
if (db) {
|
|
|
|
if (withHeader && (fRunVectorIter == fRunVector.begin())) {
|
|
outFile << "TITLE" << endl;
|
|
outFile << ">>>Put your title here<<<" << endl << endl;
|
|
outFile << "Abstract" << endl;
|
|
outFile << ">>>Put your abstract here<<<" << endl << endl;
|
|
outFile << "LABELS" << endl;
|
|
|
|
if (fDataHandler) {
|
|
for (unsigned int i(0); i < dataParamLabels.size(); ++i) {
|
|
outFile << dataParamLabels[i] << endl;
|
|
}
|
|
}
|
|
|
|
if (fRunListFile) {
|
|
for (unsigned int i(0); i < fIndVar.size(); ++i) {
|
|
outFile << fIndVar[i] << endl;
|
|
}
|
|
}
|
|
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
if (global) {
|
|
string tempName;
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
outFile << (*msrParamList)[i].fName.Data() << endl;
|
|
}
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
tempName = (*msrParamList)[fNumGlobalParam + fNumSpecParam*counter + i].fName.Data();
|
|
string::size_type loc = tempName.rfind(curRunNumber.str());
|
|
if (loc == tempName.length() - N) {
|
|
outFile << tempName.substr(0, loc) << endl;
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** The run index of some parameter does not match the run number being processed!";
|
|
cerr << endl << ">> msr2data: **ERROR** The output will be flawed!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
outFile << (*msrParamList)[i].fName.Data() << endl;
|
|
}
|
|
}
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << "CHISQ" << endl;
|
|
else
|
|
outFile << "maxLH" << endl;
|
|
|
|
outFile << "NDF" << endl;
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << "CHISQred" << endl;
|
|
else
|
|
outFile << "maxLHred" << endl;
|
|
|
|
outFile << "RUN" << endl;
|
|
|
|
outFile << endl << "Data";
|
|
|
|
if (fDataHandler) {
|
|
for (unsigned int i(0); i < dataParamNames.size(); ++i) {
|
|
outFile << " " << dataParamNames[i];
|
|
}
|
|
}
|
|
|
|
if (fRunListFile) {
|
|
for (unsigned int i(0); i < fIndVar.size(); ++i) {
|
|
outFile << " " << fIndVar[i];
|
|
}
|
|
}
|
|
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
if (global) {
|
|
string tempName;
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
outFile << " " << (*msrParamList)[i].fName.Data();
|
|
}
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
tempName = (*msrParamList)[fNumGlobalParam + fNumSpecParam*counter + i].fName.Data();
|
|
string::size_type loc = tempName.rfind(curRunNumber.str());
|
|
if (loc == tempName.length() - N) {
|
|
outFile << " " << tempName.substr(0, loc);
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** The run index of some parameter does not match the run number being processed!";
|
|
cerr << endl << ">> msr2data: **ERROR** The output will be flawed!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
outFile << " " << (*msrParamList)[i].fName.Data();
|
|
}
|
|
}
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << " " << "CHISQ";
|
|
else
|
|
outFile << " " << "maxLH";
|
|
|
|
outFile << " " << "NDF";
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << " " << "CHISQred";
|
|
else
|
|
outFile << " " << "maxLHred";
|
|
|
|
outFile << " " << "RUN" << endl;
|
|
|
|
outFile << "\\-e" << endl;
|
|
}
|
|
|
|
if (fDataHandler) {
|
|
for (unsigned int i(0); i < dataParam.size(); ++i) {
|
|
if (i < dataParamErr.size())
|
|
outFile << dataParamNames[i] << " = " << dataParam[i] << ", " \
|
|
<< dataParamErr[i] << ", " << dataParamErr[i] << ",\\" << endl;
|
|
else
|
|
outFile << dataParamNames[i] << " = " << dataParam[i] << ", 0, 0,\\" << endl;
|
|
}
|
|
}
|
|
|
|
if (fRunListFile) {
|
|
for (unsigned int i(0); i < indVarValues.size(); ++i) {
|
|
outFile << fIndVar[i] << " = " << indVarValues[i] << ", 0, 0,\\" << endl;
|
|
}
|
|
}
|
|
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
if (global) {
|
|
string tempName;
|
|
unsigned int idx;
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
outFile << (*msrParamList)[i].fName.Data() << " = " << (*msrParamList)[i].fValue << ", ";
|
|
if ((*msrParamList)[i].fPosErrorPresent)
|
|
outFile << (*msrParamList)[i].fPosError << ", ";
|
|
else
|
|
outFile << fabs((*msrParamList)[i].fStep) << ", ";
|
|
outFile << fabs((*msrParamList)[i].fStep) << ",\\" << endl;
|
|
}
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
idx = fNumGlobalParam + fNumSpecParam*counter + i;
|
|
tempName = (*msrParamList)[idx].fName.Data();
|
|
string::size_type loc = tempName.rfind(curRunNumber.str());
|
|
if (loc == tempName.length() - N) {
|
|
outFile << tempName.substr(0, loc) << " = " << (*msrParamList)[idx].fValue << ", ";
|
|
if ((*msrParamList)[idx].fPosErrorPresent)
|
|
outFile << (*msrParamList)[idx].fPosError << ", ";
|
|
else
|
|
outFile << fabs((*msrParamList)[idx].fStep) << ", ";
|
|
outFile << fabs((*msrParamList)[idx].fStep) << ",\\" << endl;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
outFile << (*msrParamList)[i].fName.Data() << " = " << (*msrParamList)[i].fValue << ", ";
|
|
if ((*msrParamList)[i].fPosErrorPresent)
|
|
outFile << (*msrParamList)[i].fPosError << ", ";
|
|
else
|
|
outFile << fabs((*msrParamList)[i].fStep) << ", ";
|
|
outFile << fabs((*msrParamList)[i].fStep) << ",\\" << endl;
|
|
}
|
|
}
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << "CHISQ = " << msrStatistic->fMin << ", 0, 0,\\" << endl;
|
|
else
|
|
outFile << "maxLH = " << msrStatistic->fMin << ", 0, 0,\\" << endl;
|
|
|
|
outFile << "NDF = " << msrStatistic->fNdf << ", 0, 0,\\" << endl;
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << "CHISQred = " << msrStatistic->fMin/msrStatistic->fNdf << ", 0, 0,\\" << endl;
|
|
else
|
|
outFile << "maxLHred = " << msrStatistic->fMin/msrStatistic->fNdf << ", 0, 0,\\" << endl;
|
|
|
|
outFile << *fRunVectorIter << ",,, " << msrTitle << endl;
|
|
|
|
} else { // no DB file but ASCII file with data columns
|
|
|
|
unsigned int length(0), maxlength(12);
|
|
for (unsigned int i(0); i < dataParamNames.size(); ++i) {
|
|
length = dataParamNames[i].length();
|
|
if (length > maxlength)
|
|
maxlength = length;
|
|
}
|
|
for (unsigned int i(0); i < fIndVar.size(); ++i) {
|
|
length = fIndVar[i].length();
|
|
if (length > maxlength)
|
|
maxlength = length;
|
|
}
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
string s;
|
|
if (global) {
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
s = (*msrParamList)[i].fName.Data();
|
|
length = s.length();
|
|
if (length > maxlength)
|
|
maxlength = length;
|
|
}
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
s = (*msrParamList)[fNumGlobalParam + fNumSpecParam*counter + i].fName.Data();
|
|
string::size_type loc = s.rfind(curRunNumber.str());
|
|
if (loc == s.length() - N) {
|
|
length = s.length() - N;
|
|
if (length > maxlength)
|
|
maxlength = length;
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** The run index of some parameter does not match the run number being processed!";
|
|
cerr << endl << ">> msr2data: **ERROR** The output will be flawed!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
s = (*msrParamList)[i].fName.Data();
|
|
length = s.length();
|
|
if (length > maxlength)
|
|
maxlength = length;
|
|
}
|
|
}
|
|
if (maxlength < 13)
|
|
maxlength = 13; // will use a minimum field width of 13 which corresponds to: -1.23456e-07 + ' '
|
|
else
|
|
maxlength += 1; // maximum length of parameter names + ' '
|
|
|
|
if (withHeader && (fRunVectorIter == fRunVector.begin())) {
|
|
|
|
if (fDataHandler) {
|
|
for (unsigned int i(0); i < dataParamNames.size(); ++i) {
|
|
s = dataParamNames[i];
|
|
if (i < dataParamErr.size()) {
|
|
outFile << setw(maxlength) << left << s << setw(maxlength + 3) << left << s + "Err";
|
|
} else
|
|
outFile << setw(maxlength) << left << s;
|
|
}
|
|
}
|
|
|
|
if (fRunListFile) {
|
|
for (unsigned int i(0); i < fIndVar.size(); ++i) {
|
|
outFile << setw(maxlength) << left << fIndVar[i];
|
|
}
|
|
}
|
|
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
if (global) {
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
s = (*msrParamList)[i].fName.Data();
|
|
outFile << setw(maxlength) << left << s \
|
|
<< setw(maxlength + 6) << left << s + "PosErr" \
|
|
<< setw(maxlength + 6) << left << s + "NegErr";
|
|
}
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
s = (*msrParamList)[fNumGlobalParam + fNumSpecParam*counter + i].fName.Data();
|
|
string::size_type loc = s.rfind(curRunNumber.str());
|
|
if (loc == s.length() - N) {
|
|
s = s.substr(0, loc);
|
|
outFile << setw(maxlength) << left << s \
|
|
<< setw(maxlength + 6) << left << s + "PosErr" \
|
|
<< setw(maxlength + 6) << left << s + "NegErr";
|
|
} else {
|
|
cerr << endl << ">> msr2data: **ERROR** The run index of some parameter does not match the run number being processed!";
|
|
cerr << endl << ">> msr2data: **ERROR** The output will be flawed!";
|
|
cerr << endl;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
s = (*msrParamList)[i].fName.Data();
|
|
outFile << setw(maxlength) << left << s \
|
|
<< setw(maxlength + 6) << left << s + "PosErr" \
|
|
<< setw(maxlength + 6) << left << s + "NegErr";
|
|
}
|
|
}
|
|
s.clear();
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << setw(maxlength) << left << "CHISQ";
|
|
else
|
|
outFile << setw(maxlength) << left << "maxLH";
|
|
|
|
outFile << setw(maxlength) << left << "NDF";
|
|
|
|
if (msrStatistic->fChisq)
|
|
outFile << setw(maxlength) << left << "CHISQred";
|
|
else
|
|
outFile << setw(maxlength) << left << "maxLHred";
|
|
|
|
outFile << setw(maxlength) << left << "RUN" << endl;
|
|
}
|
|
|
|
if (fDataHandler) {
|
|
for (unsigned int i(0); i < dataParam.size(); ++i) {
|
|
if (i < dataParamErr.size()) {
|
|
writeValues(outFile, dataParam[i], maxlength);
|
|
writeValues(outFile, dataParamErr[i], maxlength + 3);
|
|
} else {
|
|
writeValues(outFile, dataParam[i], maxlength);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fRunListFile) {
|
|
for (unsigned int i(0); i < indVarValues.size(); ++i) {
|
|
writeValues(outFile, indVarValues[i], maxlength);
|
|
}
|
|
}
|
|
|
|
// in the GLOBAL mode write only global parameters and those which belong to the actual run - in the NORMAL mode write all parameters
|
|
if (global) {
|
|
for (unsigned int i(0); i < fNumGlobalParam; ++i) {
|
|
writeValues(outFile, (*msrParamList)[i].fValue, maxlength);
|
|
|
|
if ((*msrParamList)[i].fPosErrorPresent)
|
|
writeValues(outFile, (*msrParamList)[i].fPosError, maxlength + 6);
|
|
else
|
|
writeValues(outFile, fabs((*msrParamList)[i].fStep), maxlength + 6);
|
|
|
|
writeValues(outFile, fabs((*msrParamList)[i].fStep), maxlength + 6);
|
|
}
|
|
unsigned int idx;
|
|
for (unsigned int i(0); i < fNumSpecParam; ++i) {
|
|
idx = fNumGlobalParam + fNumSpecParam*counter + i;
|
|
writeValues(outFile, (*msrParamList)[idx].fValue, maxlength);
|
|
|
|
if ((*msrParamList)[idx].fPosErrorPresent)
|
|
writeValues(outFile, (*msrParamList)[idx].fPosError, maxlength + 6);
|
|
else
|
|
writeValues(outFile, fabs((*msrParamList)[idx].fStep), maxlength + 6);
|
|
|
|
writeValues(outFile, fabs((*msrParamList)[idx].fStep), maxlength + 6);
|
|
}
|
|
} else {
|
|
for (unsigned int i(0); i < msrNoOfParams; ++i) {
|
|
writeValues(outFile, (*msrParamList)[i].fValue, maxlength);
|
|
|
|
if ((*msrParamList)[i].fPosErrorPresent)
|
|
writeValues(outFile, (*msrParamList)[i].fPosError, maxlength + 6);
|
|
else
|
|
writeValues(outFile, fabs((*msrParamList)[i].fStep), maxlength + 6);
|
|
|
|
writeValues(outFile, fabs((*msrParamList)[i].fStep), maxlength + 6);
|
|
}
|
|
}
|
|
|
|
writeValues(outFile, msrStatistic->fMin, maxlength);
|
|
|
|
writeValues(outFile, msrStatistic->fNdf, maxlength);
|
|
|
|
writeValues(outFile, msrStatistic->fMin/msrStatistic->fNdf, maxlength);
|
|
|
|
writeValues(outFile, *fRunVectorIter, maxlength);
|
|
outFile << endl;
|
|
|
|
}
|
|
|
|
if (global) {
|
|
cout << endl << ">> msr2data: **INFO** Parameter data of run " << *fRunVectorIter << " of file " << msrFileName \
|
|
<< " have been appended to " << outfile << endl;
|
|
} else {
|
|
cout << endl << ">> msr2data: **INFO** Parameter data of file " << msrFileName << " have been appended to " << outfile << endl;
|
|
}
|
|
|
|
fRunVectorIter++;
|
|
|
|
if (fRunVectorIter == fRunVector.end())
|
|
outFile << endl << endl;
|
|
outFile.close();
|
|
|
|
if (!global || (fRunVectorIter == fRunVector.end())) {
|
|
delete fMsrHandler;
|
|
fMsrHandler = 0;
|
|
|
|
if (fDataHandler) {
|
|
delete fDataHandler;
|
|
fDataHandler = 0;
|
|
}
|
|
}
|
|
|
|
msrParamList = 0;
|
|
msrRunList = 0;
|
|
|
|
// clean up some vectors
|
|
dataParamNames.clear();
|
|
dataParamLabels.clear();
|
|
dataParam.clear();
|
|
dataParamErr.clear();
|
|
indVarValues.clear();
|
|
|
|
return PMUSR_SUCCESS;
|
|
|
|
}
|
|
|
|
|