PWG2/RESONANCES/AliRsnExpression.cxx

   1 //
   2 // AliRsnExpresion class is used to
   3 // handle operators &|!
   4 // in AliRsnCut
   5 //
   6 // authors: Martin Vala (martin.vala@cern.ch)
   7 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
   8 //
   9
  10 #include <TString.h>
  11 #include <TObjString.h>
  12 #include <TObjArray.h>
  13
  14 #include "AliLog.h"
  15
  16 #include "AliRsnVariableExpression.h"
  17 #include "AliRsnExpression.h"
  18
  19 ClassImp(AliRsnExpression)
  20
  21 AliRsnCutSet *AliRsnExpression::fgCutSet = 0;
  22
  23 //______________________________________________________________________________
  24 AliRsnExpression::AliRsnExpression(TString exp) :
  25    TObject(),
  26    fVname(""),
  27    fArg1(0x0),
  28    fArg2(0x0),
  29    fOperator(0)
  30 {
  31    // Default constructor
  32    TObjArray* tokens = Tokenize(exp);
  33
  34    Int_t i = -1;
  35    AliRsnExpression* e = Expression(*tokens, i);
  36    // Copy !!!
  37    fArg1 = e->fArg1; e->fArg1 = 0;
  38    fArg2 = e->fArg2; e->fArg2 = 0;
  39    fOperator = e->fOperator;
  40    fVname = e->fVname;
  41    delete e;
  42    delete tokens;
  43 }
  44
  45 //______________________________________________________________________________
  46 AliRsnExpression::~AliRsnExpression()
  47 {
  48    if (fArg1) delete fArg1;
  49    if (fArg2) delete fArg2;
  50 }
  51
  52 AliRsnExpression::AliRsnExpression(const AliRsnExpression & exp) : TObject(exp),
  53    fVname(exp.fVname),
  54    fArg1(exp.fArg1),
  55    fArg2(exp.fArg2),
  56    fOperator(exp.fOperator)
  57 {}
  58
  59 //______________________________________________________________________________
  60 AliRsnExpression& AliRsnExpression::operator= (const AliRsnExpression& e)
  61 {
  62    // AliRsnExpression assignment operator.
  63
  64    if (this != &e) {
  65       TObject::operator= (e);
  66       fArg1 = e.fArg1;
  67       fArg2 = e.fArg2;
  68       fOperator = e.fOperator;
  69       fVname = e.fVname;
  70    }
  71    return *this;
  72 }
  73
  74 //______________________________________________________________________________
  75 AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a, AliRsnExpression* b) :
  76    TObject(),
  77    fVname(""),
  78    fArg1(a),
  79    fArg2(b),
  80    fOperator(op)
  81 {
  82    // Create a new expression
  83 }
  84
  85 //______________________________________________________________________________
  86 AliRsnExpression::AliRsnExpression(int op, AliRsnExpression* a) :
  87    TObject(),
  88    fVname(""),
  89    fArg1(0),
  90    fArg2(a),
  91    fOperator(op)
  92 {
  93    // Create a unary expression.
  94 }
  95
  96 //______________________________________________________________________________
  97 Bool_t AliRsnExpression::Value(TObjArray &vars)
  98 {
  99    //  Evaluate the expression
 100    if (fArg2 == 0 && fVname.IsNull()) {
 101       AliError("Expression undefined.");
 102       return kFALSE;
 103    }
 104    if (!fArg2) {
 105       AliError("Argument 2 is required.");
 106       return kFALSE;
 107    }
 108
 109
 110 //   AliDebug(AliLog::kDebug,Form("fOperator %d",fOperator));
 111
 112    switch (fOperator) {
 113
 114       case kOpOR :
 115          return fArg1->Value(vars) || fArg2->Value(vars);
 116
 117       case kOpAND :
 118          return fArg1->Value(vars) && fArg2->Value(vars);
 119
 120       case kOpNOT :
 121          return !(fArg2->Value(vars));
 122
 123       case 0 : {
 124 //       Int_t indexx = fgCutSet->GetIndexByCutName ( fVname.Data() );
 125          AliDebug(AliLog::kDebug, Form("Vname %s", fVname.Data()));
 126 //       return fgCutSet->GetBoolValue ( indexx );
 127          return fgCutSet->GetBoolValue(fVname.Atoi());
 128       }
 129
 130       default:
 131          AliError("Illegal operator in expression!");
 132
 133    }
 134    return kFALSE;
 135 }
 136
 137
 138 //______________________________________________________________________________
 139 TString AliRsnExpression::Unparse() const
 140 {
 141    // Unparse the expression
 142
 143    TString opVals[4] = { "", "&", "|", "!" };
 144    if (fArg2 == 0 && fVname.IsNull()) {
 145       AliError("Expression undefined.");
 146       return "Error";
 147    }
 148
 149    if (fArg2 == 0 && !fVname.IsNull()) return fVname;
 150
 151    if (fArg1 == 0 && fArg2) {
 152       return opVals[fOperator] + fArg2->Unparse();
 153    }
 154    return "(" + fArg1->Unparse() + " " + opVals[fOperator] + " " + fArg2->Unparse() + ")";
 155 }
 156
 157 //______________________________________________________________________________
 158 TObjArray* AliRsnExpression::Tokenize(TString str) const
 159 {
 160    // tokenize the expression
 161
 162    // Remove spaces
 163    TString str1;
 164    for (Int_t i = 0; i < str.Length(); i++) {
 165       if (str[i] == ' ') continue;
 166       str1.Append(str[i]);
 167    }
 168    // get variable tokens
 169    TObjArray* valtok = str1.Tokenize("!&|()");
 170    // put all variables together
 171    Int_t nvt = valtok->GetEntriesFast();
 172    TString sumval;
 173    for (Int_t i = 0; i < nvt; i++) {
 174       TObjString* val = (TObjString*) valtok->At(i);
 175       sumval.Append(val->String());
 176    }
 177    // get the operator tokens
 178    TObjArray* optok = str1.Tokenize(sumval.Data());
 179    // put all operator in one string
 180    TString operators;
 181    Int_t nopt = optok->GetEntriesFast();
 182    for (Int_t i = 0; i < nopt; i++) {
 183       TObjString* val1 = (TObjString*) optok->At(i);
 184       operators.Append(val1->String());
 185    }
 186    // add more room to be safe
 187    TObjString* blank = new TObjString(" ");
 188    operators.Append(" ");
 189    valtok->AddLast(blank);
 190    // Now put var. and oper. together
 191    TObjArray* tokens = new TObjArray(valtok->GetEntriesFast() + operators.Length());
 192    int io = 0, iv = 0;
 193    int index = 0;
 194    while (1) {
 195       TString so = operators[io];
 196       int indexO = str1.Index(so, index);
 197       TString val2 = ((TObjString*) valtok->At(iv))->String();
 198       int indexV = str1.Index(val2, index);
 199       if ((indexO < indexV || indexV < 0) && indexO >= 0) {
 200          tokens->AddLast(new TObjString(so));
 201          index += so.Length();
 202          io++;
 203       }
 204       if ((indexV < indexO || indexO < 0) && indexV >= 0) {
 205          tokens->AddLast(new TObjString(val2));
 206          index += val2.Length();
 207          iv++;
 208       }
 209       if (index >= str1.Length()) break;
 210    }
 211
 212 // //  Debug -> Print the tokens
 213 //   Int_t nt = tokens->GetEntriesFast();
 214 //   for ( Int_t i=0; i<nt; i++ )
 215 //   {
 216 //     TObjString* val3 = ( TObjString* ) tokens->At ( i );
 217 //     AliInfo ( Form ( "%d %s",i,val3->String().Data() ) );
 218 //   }
 219 //
 220 //
 221    delete valtok;
 222    delete optok;
 223
 224    return tokens;
 225 }
 226
 227
 228 //______________________________________________________________________________
 229 AliRsnExpression* AliRsnExpression::Element(TObjArray &st, Int_t &i)
 230 {
 231    // create an element
 232
 233    AliRsnExpression* result = 0;
 234
 235    Int_t nt = st.GetEntriesFast();
 236    TString token = "@";
 237    TObjString* valt;
 238    // next token
 239    if (i < nt - 1) {
 240       i++;
 241       valt = (TObjString*) st.At(i);
 242       token = valt->String();
 243    }
 244    // token type
 245    char ttok = (token[0] != '|' && token[0] != '&' &&
 246                 token[0] != '!' && token[0] != '(' && token[0] != ')') ? 'w' : token[0];
 247    switch (ttok) {
 248       case 'w' : {
 249          result = new AliRsnVariableExpression(token);
 250          break;
 251       }
 252       case '(' :
 253          result = Expression(st, i);
 254          // next token
 255          if (i < nt - 1) {
 256             i++;
 257             valt = (TObjString*) st.At(i);
 258             token = valt->String();
 259          }
 260          if (token[0] != ')') {
 261             //       i--; // push back
 262             AliErrorGeneral("AliRsnExpression::Element", "Mismatched parenthesis.");
 263             delete result;
 264             result = new AliRsnExpression;
 265          }
 266          break;
 267       default:
 268          i--; // push back
 269          AliErrorGeneral("AliRsnExpression::Element", Form("Unexpected symbol on input. %s", token.Data()));
 270          //if (result) delete result;
 271          result = new AliRsnExpression;
 272    }
 273    return result;
 274 }
 275
 276 //______________________________________________________________________________
 277 AliRsnExpression* AliRsnExpression::Primary(TObjArray &st, Int_t &i)
 278 {
 279    // create a primary
 280
 281    Int_t nt = st.GetEntriesFast();
 282    TString token = "@";
 283    TObjString* valt;
 284    // next token
 285    if (i < nt - 1) {
 286       i++;
 287       valt = (TObjString*) st.At(i);
 288       token = valt->String();
 289    }
 290
 291    switch (token[0]) {
 292       case '!' :
 293          return new AliRsnExpression(kOpNOT, Primary(st, i));
 294       default:
 295          i--; // push back
 296          return Element(st, i);
 297    }
 298 }
 299
 300 //______________________________________________________________________________
 301 AliRsnExpression* AliRsnExpression::Expression(TObjArray &st, Int_t &i)
 302 {
 303    // create an expression
 304
 305    AliRsnExpression* result = 0;
 306    Bool_t done = kFALSE;
 307    TString token;
 308    TObjString* valt;
 309
 310    static int stack = 0;
 311    stack++;
 312    Int_t nt = st.GetEntriesFast();
 313
 314    result = Primary(st, i);
 315 //   cout <<"i "<<i<< "Primary " << result->Unparse() << endl;
 316    while (! done) {
 317       // next token
 318       if (i < nt - 1) i++;
 319       else break;
 320       valt = (TObjString*) st.At(i);
 321       token = valt->String();
 322       switch (token[0]) {
 323          case '&' :
 324             result = new AliRsnExpression(kOpAND, result, Primary(st, i));
 325 //   cout <<"i "<<i<< " Expression AND " << result->Unparse() << endl;
 326             break;
 327          case '|' :
 328             result = new AliRsnExpression(kOpOR, result, Primary(st, i));
 329 //   cout <<"i "<<i<< " Expression OR " << result->Unparse() << endl;
 330             break;
 331          default:
 332             done = kTRUE;
 333             i--; // push back
 334             break;
 335       }
 336    }
 337    stack--;
 338    if (stack == 0 && !token.IsNull() && token[0] == ')') {
 339       AliErrorGeneral("AliRsnExpression::Expression", "To many closing parenthesis.");
 340       delete result;
 341       result = new AliRsnExpression;
 342    } else if (stack == 0 && i < nt - 1) {
 343       AliErrorGeneral("AliRsnExpression::Expression", Form("Unexpected symbol on input. %s", token.Data()));
 344       delete result;
 345       result = new AliRsnExpression;
 346    }
 347    return result;
 348 }