Modifications in the balance function code + addition of the very first version of...

[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnExpression.cxx

#include <Riostream.h>
#include <TString.h>
#include <TObjString.h>
#include <TObjArray.h>

#include "AliLog.h"

#include "AliRsnCut.h"
#include "AliRsnCutSet.h"
#include "AliRsnExpression.h"

ClassImp(AliRsnExpression)

AliRsnCutSet *AliRsnExpression::sCutSet = 0;

//______________________________________________________________________________
AliRsnExpression::AliRsnExpression(TString exp) :
    TObject(),
    fVname(""),
    fArg1(0x0),
    fArg2(0x0),
    fOperator(0)
{
  // Default constructor
  TObjArray* tokens = Tokenize(exp);

  Int_t i = -1;
  AliRsnExpression* e = Expression(*tokens, i);
  // Copy !!!
  fArg1 = e->fArg1; e->fArg1 = 0;
  fArg2 = e->fArg2; e->fArg2 = 0;
  fOperator = e->fOperator;
  fVname = e->fVname;
  delete e;
  delete tokens;
}

//______________________________________________________________________________
AliRsnExpression::~AliRsnExpression()
{
  if (fArg1) delete fArg1;
  if (fArg2) delete fArg2;
}

AliRsnExpression::AliRsnExpression(const AliRsnExpression & exp) : TObject(exp),
    fVname(exp.fVname),
    fArg1(exp.fArg1),
    fArg2(exp.fArg2),
    fOperator(exp.fOperator)
{}

//______________________________________________________________________________
AliRsnExpression& AliRsnExpression::operator= (const AliRsnExpression& e)
{
  // AliRsnExpression assignment operator.

  if (this != &e)
  {
    TObject::operator= (e);
    fArg1 = e.fArg1;
    fArg2 = e.fArg2;
    fOperator = e.fOperator;
    fVname = e.fVname;
  }
  return *this;
}

//______________________________________________________________________________
AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b) :
    TObject(),
    fVname(""),
    fArg1(a),
    fArg2(b),
    fOperator(op)
{
  // Create a new expression
}

//______________________________________________________________________________
AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a) :
    TObject(),
    fVname(""),
    fArg1(0),
    fArg2(a),
    fOperator(op)
{
  // Create a unary expression.
}

//______________________________________________________________________________
Bool_t AliRsnExpression::Value(TObjArray &vars)
{
  //  Evaluate the expression
  if (fArg2 == 0 && fVname.IsNull())
  {
    AliError("Expression undefined.");
    return kFALSE;
  }

//   AliDebug(AliLog::kDebug,Form("fOperator %d",fOperator));

  switch (fOperator)
  {

    case kOpOR :
      return fArg1->Value(vars) || fArg2->Value(vars);

    case kOpAND :
      return fArg1->Value(vars) && fArg2->Value(vars);

    case kOpNOT :
      return !(fArg2->Value(vars));

    case 0 :
    {
//       Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() );
      AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data()));
//       return sCutSet->GetBoolValue ( indexx );
      return sCutSet->GetBoolValue(fVname.Atoi());
    }

    default:
      AliError("Illegal operator in expression!");

  }
  return kFALSE;
}


//______________________________________________________________________________
TString AliRsnExpression::Unparse() const
{
  // Unparse the expression

  TString opVals[4] = { "", "&", "|","!" };
  if (fArg2 == 0 && fVname.IsNull())
  {
    AliError("Expression undefined.");
    return "Error";
  }

  if (fArg2 == 0 && !fVname.IsNull()) return fVname;

  if (fArg1 == 0 && fArg2)
  {
    return opVals[fOperator]+fArg2->Unparse();
  }
  return "("+fArg1->Unparse() +" "+opVals[fOperator]+" "+fArg2->Unparse() +")";
}

//______________________________________________________________________________
TObjArray* AliRsnExpression::Tokenize(TString str) const
{
  // tokenize the expression

  // Remove spaces
  TString str1;
  for (Int_t i=0; i<str.Length(); i++)
  {
    if (str[i] == ' ') continue;
    str1.Append(str[i]);
  }
  // get variable tokens
  TObjArray* valtok = str1.Tokenize("!&|()");
  // put all variables together
  Int_t nvt = valtok->GetEntriesFast();
  TString sumval;
  for (Int_t i=0; i<nvt; i++)
  {
    TObjString* val = (TObjString*) valtok->At(i);
    sumval.Append(val->String());
  }
  // get the operator tokens
  TObjArray* optok = str1.Tokenize(sumval.Data());
  // put all operator in one string
  TString operators;
  Int_t nopt = optok->GetEntriesFast();
  for (Int_t i=0; i<nopt; i++)
  {
    TObjString* val1 = (TObjString*) optok->At(i);
    operators.Append(val1->String());
  }
  // add more room to be safe
  TObjString* blank = new TObjString(" ");
  operators.Append(" ");
  valtok->AddLast(blank);
  // Now put var. and oper. together
  TObjArray* tokens = new TObjArray(valtok->GetEntriesFast() + operators.Length());
  int io = 0,iv = 0;
  int index = 0;
  while (1)
  {
    TString so = operators[io];
    int indexO = str1.Index(so, index);
    TString val2 = ((TObjString*) valtok->At(iv))->String();
    int indexV = str1.Index(val2, index);
    if ((indexO < indexV || indexV < 0) && indexO >=0)
    {
      tokens->AddLast(new TObjString(so));
      index += so.Length();
      io++;
    }
    if ((indexV < indexO || indexO < 0) && indexV >=0)
    {
      tokens->AddLast(new TObjString(val2));
      index += val2.Length();
      iv++;
    }
    if (index >= str1.Length()) break;
  }

// //  Debug -> Print the tokens
//   Int_t nt = tokens->GetEntriesFast();
//   for ( Int_t i=0; i<nt; i++ )
//   {
//     TObjString* val3 = ( TObjString* ) tokens->At ( i );
//     AliInfo ( Form ( "%d %s",i,val3->String().Data() ) );
//   }
//
//
  delete valtok;
  delete optok;

  return tokens;
}


//______________________________________________________________________________
AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i)
{
  // create an element

  AliRsnExpression* result = 0;

  Int_t nt = st.GetEntriesFast();
  TString token = "@";
  TObjString* valt;
  // next token
  if (i < nt-1)
  {
    i++;
    valt = (TObjString*) st.At(i);
    token = valt->String();
  }
  // token type
  char ttok = (token[0]!='|' && token[0]!='&' &&
               token[0]!='!' && token[0]!='('&& token[0]!=')') ? 'w' : token[0];
  switch (ttok)
  {
    case 'w' :
    {
      result = new AliRsnVariableExpression(token);
      break;
    }
    case '(' :
      result = Expression(st, i);
      // next token
      if (i < nt-1)
      {
        i++;
        valt = (TObjString*) st.At(i);
        token = valt->String();
      }
      if (token[0] != ')')
      {
        //       i--; // push back
        AliErrorGeneral("AliRsnExpression::Element", "Mismatched parenthesis.");
        delete result;
        result = new AliRsnExpression;
      }
      break;
    default:
      i--; // push back
      AliErrorGeneral("AliRsnExpression::Element", Form("Unexpected symbol on input. %s", token.Data()));
      if (result) delete result;
      result = new AliRsnExpression;
  }
  return result;
}

//______________________________________________________________________________
AliRsnExpression* AliRsnExpression::Primary(TObjArray &st, Int_t &i)
{
  // create a primary

  Int_t nt = st.GetEntriesFast();
  TString token = "@";
  TObjString* valt;
  // next token
  if (i < nt-1)
  {
    i++;
    valt = (TObjString*) st.At(i);
    token = valt->String();
  }

  switch (token[0])
  {
    case '!' :
      return new AliRsnExpression(kOpNOT, Primary(st, i));
    default:
      i--; // push back
      return Element(st, i);
  }
}

//______________________________________________________________________________
AliRsnExpression* AliRsnExpression::Expression(TObjArray &st,Int_t &i)
{
  // create an expression

  AliRsnExpression* result = 0;
  Bool_t done = kFALSE;
  TString token;
  TObjString* valt;

  static int stack = 0;
  stack++;
  Int_t nt = st.GetEntriesFast();

  result = Primary(st, i);
//   cout <<"i "<<i<< "Primary " << result->Unparse() << endl;
  while (! done)
  {
    // next token
    if (i < nt-1) i++;
    else break;
    valt = (TObjString*) st.At(i);
    token = valt->String();
    switch (token[0])
    {
      case '&' :
        result = new AliRsnExpression(kOpAND, result, Primary(st, i));
//   cout <<"i "<<i<< " Expression AND " << result->Unparse() << endl;
        break;
      case '|' :
        result = new AliRsnExpression(kOpOR, result, Primary(st, i));
//   cout <<"i "<<i<< " Expression OR " << result->Unparse() << endl;
        break;
      default:
        done = kTRUE;
        i--; // push back
        break;
    }
  }
  stack--;
  if (stack == 0 && !token.IsNull() && token[0] == ')')
  {
    AliErrorGeneral("AliRsnExpression::Expression", "To many closing parenthesis.");
    delete result;
    result = new AliRsnExpression;
  }
  else
    if (stack == 0 && i< nt-1)
    {
      AliErrorGeneral("AliRsnExpression::Expression", Form("Unexpected symbol on input. %s", token.Data()));
      delete result;
      result = new AliRsnExpression;
    }
  return result;
}

////////////////////////////////////////////////////////////////////////////////

ClassImp(AliRsnVariableExpression)

//______________________________________________________________________________
Bool_t AliRsnVariableExpression::Value(TObjArray& /*pgm*/)
{

//   Int_t indexx = sCutSet->GetIndexByCutName ( fVname.Data() );
  AliDebug(AliLog::kDebug,Form("Vname %s",fVname.Data()));
//   return sCutSet->GetBoolValue ( indexx );

  return sCutSet->GetBoolValue(fVname.Atoi());
}