AliParser.cxx

Go to the documentation of this file.

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

#include "AliParser.h"
#include <vector>
#include <map>
#include <iostream>
#include "TString.h"
#include "TError.h"
#include "TMatrixD.h"

std::vector<TString> AliParser::ExtractBetween(const char *str, const char *startStr, const char *endStr, Int_t verbose) {
  TString iTStr = TString(str);
  Int_t startPos = iTStr.Index(startStr);
  Int_t pos=0;
  Int_t endPos = iTStr.Index(endStr, startPos);
  std::vector<TString> res;

  while (startPos != -1) {
    pos = startPos+TString(startStr).Length();
    res.push_back(iTStr(pos, endPos - pos));
    startPos = iTStr.Index(startStr, endPos);
    endPos = iTStr.Index(endStr, startPos+1);
  }

  if (verbose == 4) {
    TString infoString = "";
    for (std::vector<TString>::iterator it = res.begin(); it != res.end(); ++it)
      infoString += *it + "|";
    ::Info("AliParser::ParseString", "Input string \"%s\" was parsed to %s", iTStr.Data(), infoString.Data());
  }
  return res;
}


std::vector<TString> AliParser::Split(const char *inputExpr, const char del, Int_t verbose) {
  std::vector<TString> res;
  TString inputTStr(inputExpr);
  Int_t startIndex = 0;
  std::map<char, char> ignoredBrackets;
  ignoredBrackets.insert(std::make_pair('(', ')'));
  ignoredBrackets.insert(std::make_pair('[', ']'));
  ignoredBrackets.insert(std::make_pair('{', '}'));
  ignoredBrackets.insert(std::make_pair('<', '>'));

  for (UShort_t i = 0; i <= inputTStr.Length(); ++i) {
    if (inputTStr(i) == TString(del) || i == inputTStr.Length()) {
      res.push_back(TString(inputTStr(startIndex, i - startIndex)));
      startIndex = i + 1;
    } else if (ignoredBrackets.find(inputTStr(i)) != ignoredBrackets.end()) {
      i = inputTStr.Index(ignoredBrackets[inputTStr(i)], i);
      continue;
    }
  }

  if (verbose == 4) {
    TString infoString = "";
    for (std::vector<TString>::iterator it = res.begin(); it != res.end(); ++it)
      infoString += *it + "|";
    ::Info("AliPainter::ParseString", "Input string \"%s\" was parsed to %s", inputExpr, infoString.Data());
  }
  return res;
}

std::vector<TString> AliParser::ExtractSurroundingBy(const char *inpString, const char begin, const char end, Int_t verbose) {
  std::vector<TString> parsedArr;
  TString exprsn(inpString);
  if (exprsn.CountChar(begin) != exprsn.CountChar(end)) {
    ::Error("AliPainter::DrawHistogram", "check brackets in %s", exprsn.Data());
    return parsedArr;
  }

  if (exprsn.Index(begin) != 0)
    parsedArr.push_back(TString(exprsn(0, exprsn.Index(begin))));
  else
    parsedArr.push_back(TString());

  TString verbStr = "";
  Int_t match = 0, startIndex = 0, finishIndex = 0;
  Bool_t isChange = kFALSE;

  for (Int_t i = 0; i < exprsn.Length(); ++i) {
    if (exprsn(i) == begin && match == 0) {
      match++;
      startIndex = i;
      isChange = kTRUE;
    } else if (exprsn(i) == begin && match > 0) match++;
    else if (exprsn(i) == end && match == 1) {
      match--;
      finishIndex = i;
    } else if (exprsn(i) == end && match > 1) match--;

    if (match == 0 && isChange) {
      parsedArr.push_back(TString(exprsn(startIndex + 1, finishIndex - startIndex - 1)));
      isChange = kFALSE;
    }
  }

  if (verbose == 4) {
    TString infoString = "";
    for (std::vector<TString>::iterator it = parsedArr.begin(); it != parsedArr.end(); ++it)
      infoString += *it + "|";
    ::Info("AliPainter::ParseString", "Input string \"%s\" was parsed to %s", inpString, infoString.Data());
  }
  return parsedArr;
}

//TODO: add also support to another options like -b, -n10, -n 10, --tools "...", ...
std::map<TString, TString> AliParser::Parse(const char *iStr, Int_t verbose, std::vector<TString> defKeys) {
  std::map<TString, TString> optMap;
  TString str(iStr);
  std::vector<TString> options = AliParser::Split(iStr, ',', verbose);
  for (UShort_t i = 0; i < options.size(); i++) {
    TString optionStr = options[i];
    TString key = "";
    TString value = "";
    key = TString(optionStr(0, optionStr.Index("="))).ReplaceAll(" ", "");
    value = TString(optionStr(optionStr.Index("=") + 1, optionStr.Length())).ReplaceAll(" ", "");
//    if (std::find(defKeys.begin(), defKeys.end(), key) == defKeys.end() && key != TString() && defKeys.size() > 0) {
//      TString defaultKeys = "";
//      for (std::vector<TString>::iterator it = defKeys.begin(); it != defKeys.end(); ++it)
//        defaultKeys += *it + ",";
//      ::Warning("AliPainter::DrawHistogram", "key \"%s\" not found in the list of default keys: \"%s\"", key.Data(),
//                defaultKeys.Data());
//    }
    optMap[key] = value;
  }
  return optMap;
}

std::vector<Int_t> AliParser::Slice2IArray(const char *inputString) {
  Int_t initArr[4] = {0, 0, 1, 1}; // start, stop, step, delta
  std::vector<TString> initValues = AliParser::Split(TString(inputString), ':');
  for (Int_t i=0; i < 4 && i < (Int_t) initValues.size(); ++i)
    initArr[i] = initValues[i].Atoi();
  std::vector<Int_t> vRanges;
  for (Int_t j = initArr[0]; j <= initArr[1] - initArr[3]; j += initArr[2]) {
    vRanges.push_back(j);
    vRanges.push_back(j + initArr[3]);
  }
  return  vRanges;
}

// TODO: code will crash if iRanges.size() is not even. Crash when (it+1) row 229
//::Error("AliParser", "SliceRanges: count of values should be even.");
//return TMatrixD();
/*
auto m = AliParser::Slice2Matrix("10,20,30:60:10:10,70:110:10:10")
{
  for(auto i=0;i<m.GetNrows();++i) {
    for(auto j=0;j<m.GetNcols();++j) {
      std::cout << " " << TMatrixDRow(m,i)[j];
    }
    std::cout << std::endl;
  }
}
 */
TMatrixD AliParser::Slice2Matrix(const char *iStr, Int_t verbose) {
  TString inputString(iStr);
  if (inputString == TString()) return TMatrixD();
  std::vector<TString> initRanges = AliParser::Split(iStr, ',', verbose);
  std::map<Int_t, std::vector<Double_t> > iRanges;
  std::vector<Double_t> tempVector;
  std::vector<Int_t> sliceVec;
  std::vector<Double_t> floatFlagArray;

  Int_t axisNum = 0;
  std::vector<TString>::iterator it = initRanges.begin();
  try {
    while (it < initRanges.end()) {
      tempVector.clear();
      sliceVec.clear();
      if (it->Contains(':')) {
        sliceVec = AliParser::Slice2IArray(it->Data());
        tempVector.insert(tempVector.end(), sliceVec.begin(), sliceVec.end());
        AliParser::FillFloatFlagArray(floatFlagArray, *it);
        AliParser::FillFloatFlagArray(floatFlagArray, *it);
        it++;
      } else {
        tempVector.push_back(it->Atof());
        tempVector.push_back((it + 1)->Atof());
        AliParser::FillFloatFlagArray(floatFlagArray, *it);
        AliParser::FillFloatFlagArray(floatFlagArray, *(it + 1));
        it += 2;
      }
      iRanges[axisNum] = tempVector;
      axisNum++;
    }
  }
  catch (std::exception &e) {
    std::cerr << "Exception catched : " << e.what() << std::endl;
    std::cout << "Most probably you have wrong number of range values. It should be even number." << std::endl;
    return TMatrixD();
  }
  Int_t *ind = new Int_t[iRanges.size()]();
  std::vector<Double_t> darr;
  AliParser::Map2Array(darr, iRanges, ind, 1);
  delete [] ind;
  darr.insert(darr.end(), floatFlagArray.begin(), floatFlagArray.end());
  Int_t rowCnt = 1;
  for (Int_t r = 0; r < (Int_t) iRanges.size(); ++r)
    rowCnt *= iRanges[r].size() / 2;
  TMatrixD matrix(rowCnt + 1, iRanges.size() * 2, &darr[0]);
  return matrix;
}

void AliParser::Map2Array(std::vector<Double_t> &array, std::map<Int_t, std::vector<Double_t> > iRanges, Int_t *indexes, Int_t cnt) {
  std::vector<Double_t> tempArray;
  Int_t d = 0;
  for (d = 0; d < (Int_t) iRanges.size(); ++d) {
    tempArray.push_back(iRanges[d][indexes[d]]);
    tempArray.push_back(iRanges[d][indexes[d] + 1]);
  }
  array.insert(array.end(), tempArray.begin(), tempArray.end());
  for (Int_t i = d - 1; i >= 0; --i) {
    if (indexes[i] + 2 >= (Int_t) iRanges[i].size())
      indexes[i] = 0;
    else {
      indexes[i] = indexes[i] + 2;
      break;
    }
  }
  Int_t rowCnt = 1;
  for (Int_t r = 0; r < (Int_t) iRanges.size(); ++r)
    rowCnt *= iRanges[r].size()/2;
  if (cnt == rowCnt) return;
  cnt++;
  AliParser::Map2Array(array, iRanges, indexes, cnt);
}

void AliParser::FillFloatFlagArray(std::vector<Double_t> &floatFlagArray, TString str) {
  if (str.Contains('.')) {
    floatFlagArray.push_back(1.);
  }
  else {
    floatFlagArray.push_back(0.);
  }
}