msr2msr.cpp

Go to the documentation of this file.

/***************************************************************************
 
  msr2msr.cpp
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 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.             *
 ***************************************************************************/
 
#include <iostream>
#include <fstream>
 
#include <cctype>
#include <cstring>
#include <cstdlib>
 
#include <TString.h>
 
#include "PStringUtils.h"
 
//-------------------------------------------------------------
// msr block header tags
#define MSR_TAG_TITLE        0
#define MSR_TAG_FITPARAMETER 1
#define MSR_TAG_THEORY       2
#define MSR_TAG_FUNCTIONS    3
#define MSR_TAG_RUN          4
#define MSR_TAG_COMMANDS     5
#define MSR_TAG_PLOT         6
#define MSR_TAG_STATISTIC    7
#define MSR_TAG_NO_BLOCK     8
 
//-------------------------------------------------------------
// msr theory tags
#define MSR_THEORY_INTERN_FLD    0
#define MSR_THEORY_INTERN_BESSEL 1
 
//--------------------------------------------------------------------------
void msr2msr_syntax()
{
  std::cout << std::endl << "usage: msr2msr <msr-file-in> <msr-file-out> | [--help]";
  std::cout << std::endl << "  <msr-file-in> : input msr-file";
  std::cout << std::endl << "  <msr-file-out>: converted msr-output-file";
  std::cout << std::endl << "  if the <msr-file-in> is already in the 2008 format";
  std::cout << std::endl << "  the output file will be identical to the input file.";
  std::cout << std::endl << std::endl;
}
 
//--------------------------------------------------------------------------
bool msr2msr_run(char *str, const std::size_t size)
{
  // not the RUN line itself, hence nothing to be done
  if (!strstr(str, "RUN"))
    return true;
 
  TString run(str);
  TString line(str);
 
  // for filtering
  run.ToUpper();
 
  // remove run comment, i.e. (name ...
  Ssiz_t idx = line.Index("(");
  if (idx > 0)
    line.Remove(idx);
 
  // tokenize run
  std::vector<std::string> tokens = PStringUtils::Split(line.Data(), " \t");
  if (tokens.size() < 4) {
    std::cout << std::endl << "**ERROR**: Something is wrong with the RUN block header:";
    std::cout << std::endl << "  >> " << str;
    std::cout << std::endl << "  >> no <msr-file-out> is created";
    std::cout << std::endl;
    return false;
  }
 
  if (tokens.size() == 5) { // already a new msr file, do only add the proper run comment
    snprintf(str, size, "%s (name beamline institute data-file-format)", line.Data());
    return true;
  }
 
  if (run.Contains("NEMU")) {
    snprintf(str, size, "RUN %s MUE4 PSI WKM   (name beamline institute data-file-format)", tokens[1].c_str());
  } else if (run.Contains("PSI")) {
    snprintf(str, size, "RUN %s %s PSI PSI-BIN   (name beamline institute data-file-format)",
            tokens[1].c_str(), tokens[2].c_str());
  } else if (run.Contains("TRIUMF")) {
    snprintf(str, size, "RUN %s %s TRIUMF MUD   (name beamline institute data-file-format)",
            tokens[1].c_str(), tokens[2].c_str());
  } else if (run.Contains("RAL")) {
    snprintf(str, size, "RUN %s %s RAL NEXUS   (name beamline institute data-file-format)",
            tokens[1].c_str(), tokens[2].c_str());
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
bool msr2msr_param(char *str)
{
  // check for comment header which needs to be replaced
  if (strstr(str, "Nr.")) {
    strcpy(str, "#       No Name        Value     Step        Pos_Error   Boundaries");
    return true;
  }
 
  // handle parameter line
  TString line(str);
  char sstr[256];
  char spaces[256];
 
  std::vector<std::string> tokens = PStringUtils::Split(line.Data(), " \t");
  std::size_t noTokens = tokens.size();
  if (noTokens == 4) {
    // number
    snprintf(sstr, sizeof(sstr), "%10s", tokens[0].c_str());
    // name
    strcat(sstr, " ");
    strcat(sstr, tokens[1].c_str());
    memset(spaces, 0, sizeof(spaces));
    memset(spaces, ' ', 12-strlen(tokens[1].c_str()));
    strcat(sstr, spaces);
    // value
    strcat(sstr, tokens[2].c_str());
    if (strlen(tokens[2].c_str()) < 10) {
      memset(spaces, 0, sizeof(spaces));
      memset(spaces, ' ', 10-strlen(tokens[2].c_str()));
      strcat(sstr, spaces);
    } else {
      strcat(sstr, " ");
    }
    // step
    strcat(sstr, tokens[3].c_str());
    if (strlen(tokens[3].c_str()) < 12) {
      memset(spaces, 0, sizeof(spaces));
      memset(spaces, ' ', 12-strlen(tokens[3].c_str()));
      strcat(sstr, spaces);
    } else {
      strcat(sstr, " ");
    }
    strcat(sstr, "none");
    strcpy(str, sstr);
  } else if (noTokens == 6) {
    // number
    snprintf(sstr, sizeof(sstr), "%10s", tokens[0].c_str());
    // name
    strcat(sstr, " ");
    strcat(sstr, tokens[1].c_str());
    memset(spaces, 0, sizeof(spaces));
    memset(spaces, ' ', 12-strlen(tokens[1].c_str()));
    strcat(sstr, spaces);
    // value
    strcat(sstr, tokens[2].c_str());
    if (strlen(tokens[2].c_str()) < 10) {
      memset(spaces, 0, sizeof(spaces));
      memset(spaces, ' ', 10-strlen(tokens[2].c_str()));
      strcat(sstr, spaces);
    } else {
      strcat(sstr, " ");
    }
    // step
    strcat(sstr, tokens[3].c_str());
    if (strlen(tokens[3].c_str()) < 12) {
      memset(spaces, 0, sizeof(spaces));
      memset(spaces, ' ', 12-strlen(tokens[3].c_str()));
      strcat(sstr, spaces);
    } else {
      strcat(sstr, " ");
    }
    // pos. error
    strcat(sstr, "none        ");
    // lower boundary
    strcat(sstr, tokens[4].c_str());
    if (strlen(tokens[4].c_str()) < 8) {
      memset(spaces, 0, sizeof(spaces));
      memset(spaces, ' ', 8-strlen(tokens[4].c_str()));
      strcat(sstr, spaces);
    } else {
      strcat(sstr, " ");
    }
    // upper boundary
    strcat(sstr, tokens[5].c_str());
    strcpy(str, sstr);
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
bool msr2msr_theory(char *str, int &tag, int &noOfAddionalParams)
{
  // handle theory line
  TString line(str);
  std::vector<std::string> tokens;
  char sstr[256];
 
  if ((line.Contains("sktt") || line.Contains("statKTTab")) && line.Contains("glf")) { // static Gauss KT LF table
    // change cmd name
    strcpy(sstr, "statGssKTLF ");
 
    // tokenize the rest and extract the first two parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 3) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid statKTTab statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    for (Int_t i=1; i<3; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (frequency damping)");
    strcpy(str, sstr);
  } else if ((line.Contains("sktt") || line.Contains("statKTTab")) && line.Contains("llf")) { // static Lorentz KT LF table
    // change cmd name
    strcpy(sstr, "statExpKTLF ");
 
    // tokenize the rest and extract the first two parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 3) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid statKTTab statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    for (Int_t i=1; i<3; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (frequency damping)");
    strcpy(str, sstr);
  } else if ((line.Contains("dktt") || line.Contains("dynmKTTab")) && line.Contains("kdglf")) { // dynamic Gauss KT LF table
    // change cmd name
    strcpy(sstr, "dynGssKTLF ");
 
    // tokenize the rest and extract the first three parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 4) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid dynmKTTab statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    for (Int_t i=1; i<4; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (frequency damping hopping-rate)");
    strcpy(str, sstr);
  } else if ((line.Contains("dktt") || line.Contains("dynmKTTab")) && line.Contains("kdllf")) { // dynamic Lorentz KT LF table
    // change cmd name
    strcpy(sstr, "dynExpKTLF ");
 
    // tokenize the rest and extract the first three parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 4) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid dynmKTTab statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    for (Int_t i=1; i<4; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (frequency damping hopping-rate)");
    strcpy(str, sstr);
  } else if (line.Contains("internFld")) {
    tag = MSR_THEORY_INTERN_FLD;
    noOfAddionalParams++;
 
    // change cmd name
    strcpy(sstr, "internFld ");
 
    // tokenize the rest and extract the first three parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 4) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid internFld statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    strcat(sstr, "  _x_");
    for (Int_t i=1; i<4; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (fraction phase frequency Trate Lrate)");
    strcpy(str, sstr);
  } else if (line.Contains("internBsl")) {
    tag = MSR_THEORY_INTERN_BESSEL;
    noOfAddionalParams++;
 
    // change cmd name
    strcpy(sstr, "internBsl ");
 
    // tokenize the rest and extract the first three parameters
    tokens = PStringUtils::Split(line.Data(), " \t");
    std::size_t noTokens = tokens.size();
    if (noTokens < 4) {
      std::cout << std::endl << "**ERROR** in THEORY block";
      std::cout << std::endl << "  Line: '" << str << "' is not a valid internBsl statement.";
      std::cout << std::endl << "  Cannot handle file." << std::endl;
      return false;
    }
    strcat(sstr, "  _x_");
    for (Int_t i=1; i<4; i++) {
      strcat(sstr, "  ");
      strcat(sstr, tokens[i].c_str());
    }
    strcat(sstr, "  (fraction phase frequency Trate Lrate)");
    strcpy(str, sstr);
  }
 
  return true;
}
 
 
//--------------------------------------------------------------------------
bool msr2msr_is_comment(char *str)
{
  bool isComment = false;
 
  for (unsigned int i=0; i<strlen(str); i++) {
    if ((str[i] == ' ') || (str[i] == '\t'))
      continue;
    if (str[i] == '#') {
      isComment = true;
      break;
    } else {
      isComment = false;
      break;
    }
  }
 
  return isComment;
}
 
//--------------------------------------------------------------------------
bool msr2msr_is_whitespace(char *str)
{
  bool isWhitespace = true;
 
  if (strlen(str) != 0) {
    for (unsigned int i=0; i<strlen(str); i++) {
      if ((str[i] != ' ') && (str[i] != '\t')) {
        isWhitespace = false;
        break;
      }
    }
  }
 
  return isWhitespace;
}
 
//--------------------------------------------------------------------------
void msr2msr_replace(char *str, int paramNo)
{
  char temp[128];
  char no[16];
 
  memset(temp, 0, sizeof(temp));
 
  snprintf(no, sizeof(no), "%d", paramNo);
 
  int j=0;
  for (unsigned int i=0; i<strlen(str); i++) {
    if (str[i] != '_') {
      temp[j] = str[i];
      j++;
    } else {
      for (unsigned int k=0; k<strlen(no); k++)
        temp[j+k] = no[k];
      j += strlen(no);
      i += 2;
    }
  }
 
  strcpy(str, temp);
}
 
//--------------------------------------------------------------------------
bool msr2msr_finalize_theory(char *fln, int theoryTag, int noOfAddionalParams)
{  
  std::ifstream fin;
  fin.open(fln, std::iostream::in);
  if (!fin.is_open()) {
    std::cout << std::endl << "**ERROR**: Couldn't open input msr-file " << fln;
    std::cout << std::endl << "           Will quit." << std::endl;
    return 0;
  }
 
  // open temporary output msr-file
  std::ofstream fout;
  fout.open("__temp.msr", std::iostream::out);
  if (!fout.is_open()) {
    std::cout << std::endl << "**ERROR**: Couldn't open output msr-file __temp.msr";
    std::cout << std::endl << "           Will quit." << std::endl;
    fin.close();
    return 0;
  }
 
  char str[256];
  int  tag = -1;
  bool success = true;
  int  param = 0;
  int  count = 0;
  while (!fin.eof() && success) {
    fin.getline(str, sizeof(str));
 
    if (strstr(str, "FITPARAMETER")) {
      tag = MSR_TAG_FITPARAMETER;
    } else if (strstr(str, "THEORY")) {
      tag = MSR_TAG_THEORY;
    }
 
    if ((tag == MSR_TAG_FITPARAMETER) && !strstr(str, "FITPARAMETER")) {
      if ((theoryTag == MSR_THEORY_INTERN_FLD) || (theoryTag == MSR_THEORY_INTERN_BESSEL)) {
        if (!msr2msr_is_comment(str)) {
          param++;
          if (msr2msr_is_whitespace(str)) {
            // add needed parameters
            for (int i=0; i<noOfAddionalParams; i++) {
              fout << "        " << param+i << " frac" << i+1 << "       0.333333 0.0        none" << std::endl;
            }
          }
        }
      }
    }
 
    if (tag == MSR_TAG_THEORY) {
      if ((theoryTag == MSR_THEORY_INTERN_FLD) || (theoryTag == MSR_THEORY_INTERN_BESSEL)) {
        if (strstr(str, "_x_")) {
          msr2msr_replace(str, param+count);
          count++;
        }
      }
    }
 
    fout << str << std::endl;
  }
 
  // close files
  fout.close();
  fin.close();
 
 
  // cp __temp.msr fln
  snprintf(str, sizeof(str), "cp __temp.msr %s", fln);
  if (system(str) == -1) {
    std::cerr << "**ERROR** cmd: " << str << " failed." << std::endl;
    return false;
  }
  // rm __temp.msr
  strcpy(str, "rm __temp.msr");
  if (system(str) == -1) {
    std::cerr << "**ERROR** cmd: " << str << " failed." << std::endl;
    return false;
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
bool msr2msr_statistic(char *str, const std::size_t size) {
  bool success = true;
 
  char *pstr;
  int status;
  double chisq, chisqred;
  if (strstr(str, "  chi")) {
    pstr = strstr(str, "abs = ");
    if (pstr != nullptr) {
      status = sscanf(pstr, "abs = %lf", &chisq);
      if (status != 1) {
        success = false;
      }
    }
    pstr = strstr(str, "norm = ");
    if (pstr != nullptr) {
      status = sscanf(pstr, "norm = %lf", &chisqred);
      if (status != 1) {
        success = false;
      }
    }
    if (success) {
      snprintf(str, size, "  chisq = %lf, NDF = %d, chisq/NDF = %lf", chisq, static_cast<int>(chisq/chisqred), chisqred);
    }
  }
 
  return success;
}
 
//--------------------------------------------------------------------------
int main(int argc, char *argv[])
{
 
  // check the number of arguments
  if (argc != 3) {
    msr2msr_syntax();
    return 0;
  }
 
  // open input msr-file
  std::ifstream fin;
  fin.open(argv[1], std::iostream::in);
  if (!fin.is_open()) {
    std::cout << std::endl << "**ERROR**: Couldn't open input msr-file " << argv[1];
    std::cout << std::endl << "           Will quit." << std::endl;
    return 0;
  }
 
  // open output msr-file
  std::ofstream fout;
  fout.open(argv[2], std::iostream::out);
  if (!fout.is_open()) {
    std::cout << std::endl << "**ERROR**: Couldn't open output msr-file " << argv[2];
    std::cout << std::endl << "           Will quit." << std::endl;
    fin.close();
    return 0;
  }
 
  // read input file and write output file
  char str[256];
  int  tag = -1;
  int  theoryTag = -1;
  int  noOfAddionalParams = 0;
  bool success = true;
  while (!fin.eof() && success) {
    fin.getline(str, sizeof(str));
 
    if (strstr(str, "FITPARAMETER")) {
      tag = MSR_TAG_FITPARAMETER;
    } else if (strstr(str, "RUN")) { // analyze and change header
      tag = MSR_TAG_RUN;
    } else if (strstr(str, "THEORY")) {
      tag = MSR_TAG_THEORY;
    } else if (strstr(str, "STATISTIC")) {
      tag = MSR_TAG_STATISTIC;
    }
 
    switch (tag) {
      case MSR_TAG_FITPARAMETER:
        success = msr2msr_param(str);
        break;
      case MSR_TAG_THEORY:
        success = msr2msr_theory(str, theoryTag, noOfAddionalParams);
        break;
      case MSR_TAG_RUN:
        success = msr2msr_run(str, sizeof(str));
        break;
      case MSR_TAG_STATISTIC:
        success = msr2msr_statistic(str, sizeof(str));
        break;
      default:
        break;
    }
 
    fout << str << std::endl;
  }
 
  // close files
  fout.close();
  fin.close();
 
  // check if conversion seems to be OK
  if (!success) {
    snprintf(str, sizeof(str), "rm -rf %s", argv[2]);
    if (system(str) == -1) {
      std::cerr << "**ERROR** cmd: " << str << " failed." << std::endl;
      return 0;
    }
  }
 
  if (theoryTag != -1) {
    msr2msr_finalize_theory(argv[2], theoryTag, noOfAddionalParams);
  }
 
  std::cout << std::endl << "done ..." << std::endl;
 
  return 1;
}