added missing files
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 24 Jun 2008 08:04:27 +0000 (08:04 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 24 Jun 2008 08:04:27 +0000 (08:04 +0000)
PWG2/RESONANCES/AliRsnExpression.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnExpression.h [new file with mode: 0644]

diff --git a/PWG2/RESONANCES/AliRsnExpression.cxx b/PWG2/RESONANCES/AliRsnExpression.cxx
new file mode 100644 (file)
index 0000000..8d9f590
--- /dev/null
@@ -0,0 +1,377 @@
+#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() );
+}
+
diff --git a/PWG2/RESONANCES/AliRsnExpression.h b/PWG2/RESONANCES/AliRsnExpression.h
new file mode 100644 (file)
index 0000000..32a84f6
--- /dev/null
@@ -0,0 +1,72 @@
+#ifndef ALIRSNEXPRESSION_H
+#define ALIRSNEXPRESSION_H
+
+#include <TObject.h>
+#include <TString.h>
+
+#include "AliRsnCutSet.h"
+
+class TObjArray;
+class AliRsnCutSet;
+/**
+  @author Martin Vala <Martin.Vala@cern.ch>
+ */
+
+// These are the valid operators types.
+
+enum { kOpAND=1,   // AND '&'
+       kOpOR,      // OR '|'
+       kOpNOT
+     };   // Unary negation '!'
+
+class AliRsnExpression : public TObject
+{
+
+  public:
+    AliRsnExpression() : fVname ( 0 ), fArg1 ( 0 ), fArg2 ( 0 ), fOperator ( 0 )  {}
+    AliRsnExpression ( TString exp );
+    virtual    ~AliRsnExpression();
+    AliRsnExpression ( const AliRsnExpression& exp );
+    AliRsnExpression&    operator= ( const AliRsnExpression& exp );
+
+    virtual Bool_t     Value ( TObjArray & vars );
+    virtual TString     Unparse() const;
+
+    void SetCutSet ( AliRsnCutSet* theValue ) { sCutSet = theValue; }
+    AliRsnCutSet* GetCutSet() const { return sCutSet; }
+
+
+    TString    fVname;   // Variable name
+    static AliRsnCutSet        *sCutSet;
+
+  private:
+    AliRsnExpression*   fArg1;         // left argument
+    AliRsnExpression*   fArg2;         // right argument
+    Int_t                 fOperator;     // operator
+
+    AliRsnExpression ( int op, AliRsnExpression* a );
+    AliRsnExpression ( int op, AliRsnExpression* a, AliRsnExpression* b );
+
+    TObjArray*    Tokenize ( TString str ) const;
+    static AliRsnExpression*    Element ( TObjArray &st, Int_t &i );
+    static AliRsnExpression*    Primary ( TObjArray &st, Int_t &i );
+    static AliRsnExpression*    Expression ( TObjArray &st, Int_t &i );
+
+    ClassDef ( AliRsnExpression, 1 ); // Class to evaluate an expression
+};
+
+
+///////////////////////////////////////////////////////////////////////////
+
+class AliRsnVariableExpression: public AliRsnExpression
+{
+  public:
+    AliRsnVariableExpression ( TString a) : AliRsnExpression() { fVname = a;  };
+    ~AliRsnVariableExpression() {}
+    virtual Bool_t    Value ( TObjArray& pgm );
+    virtual TString    Unparse() const { return fVname; }
+
+    ClassDef ( AliRsnVariableExpression, 1 ); // Class to define a variable expression
+};
+
+#endif