RALICE/AliEventSelector.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 // $Id$
  17
  18 ///////////////////////////////////////////////////////////////////////////
  19 // Class AliEventSelector
  20 // TTask based processor to perform generic event selection.
  21 // This class is derived from AliAstrolab in order to also provide event
  22 // selection based on space and time matching with external (astrophysical)
  23 // objects and phenomena.
  24 //
  25 // After having applied the various selection criteria, this processor
  26 // introduces an AliDevice with the name "AliEventSelector" into the event.
  27 // This device contains named signal slots to indicate the settings
  28 // of the various selection parameters.
  29 // One of the slots has the name "Select" and the signal value of this
  30 // slot indicates the final selection result.
  31 //
  32 // value : -1 ==> Event rejected
  33 //          0 ==> Decision unknown (incomplete selection parameters)
  34 //          1 ==> Event selected
  35 //
  36 // Event selection may be performed based on various selection types,
  37 // e.g. individual track observables, total event observables or
  38 // space and time matching with external objects.
  39 // These types can be (de)activated via the SetSelector member function.
  40 //
  41 // The specific selection criteria for each selection type may be
  42 // specified via the SetRange memberfunction.
  43 //
  44 // The logic to be used in the selection process with the various criteria
  45 // is set via the memberfunction SetLogic.
  46 // Obviously, matching of tracks with various external objects is always
  47 // performed in logical "or".
  48 //
  49 // For investigation of individual track observables and/or matching with
  50 // external objects, the user may define a restricted set of tracks to
  51 // be used in the evaluation procedures. The definition of such a restricted
  52 // track set is performed via the memberfunction UseTracks.
  53 //
  54 // Example :
  55 // ---------
  56 // gSystem->Load("ralice");
  57 //
  58 // AliEventSelector sel;
  59 // sel.SetLabPosition(0.5,-90,"deg");    // The South Pole Neutrino Observatory
  60 // sel.SetLocalFrame(90,180,90,270,0,0); // Local frame has X-axis to the North
  61 //
  62 // sel.SetSelector("astro");
  63 // sel.SetSelector("track");
  64 // sel.SetSelector("event");
  65 // sel.SetLogic("and");
  66 // sel.UseTracks("*");
  67 //
  68 // sel.SetRange("track","p",0.5,1e20);   // Require at least 500 MeV/c track momentum
  69 // sel.SetRange("event","ntrk","*",1,3); // Only low multiplicity events
  70 //
  71 // // Match with Astrophysical objects within 5 degrees and 10 seconds
  72 // Float_t da=5;
  73 // Float_t dt=10;
  74 // sel.SetAstroMatch(da,dt,"from");
  75 //
  76 // // Some observed event to be investigated
  77 // AliEvent evt;
  78 // evt.SetUT(1989,7,30,8,14,23,738504,0);
  79 //
  80 // Float_t vec[3]={1,23.8,118.65};
  81 // Ali3Vector r;
  82 // r.SetVector(vec,"sph","deg");
  83 //
  84 // AliTrack t;
  85 // t.SetNameTitle("SomeTrack","Just a dummy test track");
  86 // r*=-1; // Let track originate from specified location
  87 // t.Set3Momentum(r);
  88 //
  89 // evt.AddTrack(t);
  90 //
  91 // // Enter some external (astrophysical) reference signals
  92 // Float_t alpha=194818.0;
  93 // Float_t delta=84400.;
  94 // sel.SetSignal(alpha,delta,"B",1950,"M",-1,"Altair");
  95 // alpha=124900.0;
  96 // delta=272400.;
  97 // sel.SetSignal(alpha,delta,"B",1950,"M",-1,"NGP");
  98 // alpha=64508.917;
  99 // delta=-164258.02;
 100 // sel.SetSignal(alpha,delta,"J",2000,"M",-1,"Sirius");
 101 // alpha=23149.08;
 102 // delta=891550.8;
 103 // sel.SetSignal(alpha,delta,"J",2000,"M",-1,"Polaris");
 104 // alpha=43600.;
 105 // delta=163100.;
 106 // sel.SetSignal(alpha,delta,"J",2000,"M",-1,"Aldebaran");
 107 // Float_t l=327.531;
 108 // Float_t b=-35.8903;
 109 // Float_t pos[3]={1,90.-b,l};
 110 // r.SetVector(pos,"sph","deg");
 111 // sel.SetUT(1989,7,30,8,14,16,0,0);
 112 // sel.SetSignal(&r,"gal","M",0,-1,"GRB890730"); // This matches our track
 113 //
 114 // // List all stored reference objects
 115 // sel.ListSignals("equ","T",5);
 116 //
 117 // // Let's see what the event selection makes of it
 118 // AliJob q;
 119 // q.Add(&sel);
 120 // q.ListEnvironment();
 121 // q.ProcessObject(&evt);
 122 //
 123 // AliDevice* evtsel=(AliDevice*)evt.GetDevice("AliEventSelector");
 124 // if (evtsel) evtsel->Data();
 125 //
 126 //--- Author: Nick van Eijndhoven 17-sep-2007 Utrecht University
 127 //- Modified: NvE $Date$ Utrecht University
 128 ///////////////////////////////////////////////////////////////////////////
 129
 130 #include "AliEventSelector.h"
 131 #include "Riostream.h"
 132
 133 ClassImp(AliEventSelector) // Class implementation to enable ROOT I/O
 134
 135 AliEventSelector::AliEventSelector(const char* name,const char* title) : AliAstrolab(name,title)
 136 {
 137 // Default constructor.
 138
 139  fFirst=1;
 140  fEvt=0;
 141  fParams=0;
 142  fSelect=0;
 143  fTrackflag=0;
 144  fEventflag=0;
 145  fAstroflag=0;
 146  fLogic=0;
 147  fUseNames=0;
 148  fUseNtk=0;
 149  fAstroDa=-1;
 150  fAstroDt=-1;
 151  fAstroDir=0;
 152
 153  for (Int_t i=0; i<=8; i=i+2)
 154  {
 155   fEventTracks[i]=0;
 156   fEventTracks[i+1]=-1;
 157   if (i<=4)
 158   {
 159    fTrackMomenta[i]=0;
 160    fTrackMomenta[i+1]=-1;
 161    fTrackEnergies[i]=0;
 162    fTrackEnergies[i+1]=-1;
 163    fEventMomenta[i]=0;
 164    fEventMomenta[i+1]=-1;
 165    fEventEnergies[i]=0;
 166    fEventEnergies[i+1]=-1;
 167   }
 168   if (i<=2)
 169   {
 170    fTrackRapidities[i]=0;
 171    fTrackRapidities[i+1]=-1;
 172   }
 173   if (i==0)
 174   {
 175    fTrackMasses[i]=0;
 176    fTrackMasses[i+1]=-1;
 177    fEventMasses[i]=0;
 178    fEventMasses[i+1]=-1;
 179    fTrackCharges[i]=0;
 180    fTrackCharges[i+1]=-1;
 181    fEventCharges[i]=0;
 182    fEventCharges[i+1]=-1;
 183    fTrackDevices[i]=0;
 184    fTrackDevices[i+1]=-1;
 185    fEventDevices[i]=0;
 186    fEventDevices[i+1]=-1;
 187   }
 188  }
 189  fTrackDevClass="";
 190  fEventDevClass="";
 191  fEventTrkName="";
 192 }
 193 ///////////////////////////////////////////////////////////////////////////
 194 AliEventSelector::~AliEventSelector()
 195 {
 196 // Default destructor.
 197
 198  if (fParams)
 199  {
 200   delete fParams;
 201   fParams=0;
 202  }
 203
 204  if (fUseNames)
 205  {
 206   delete fUseNames;
 207   fUseNames=0;
 208  }
 209  if (fUseNtk)
 210  {
 211   delete fUseNtk;
 212   fUseNtk=0;
 213  }
 214 }
 215 ///////////////////////////////////////////////////////////////////////////
 216 AliEventSelector::AliEventSelector(const AliEventSelector& q) : AliAstrolab(q)
 217 {
 218 // Copy constructor
 219
 220  fFirst=1;
 221  fEvt=0;
 222  fParams=new AliDevice(*(q.fParams));
 223  fSelect=q.fSelect;
 224  fTrackflag=q.fTrackflag;
 225  fEventflag=q.fEventflag;
 226  fAstroflag=q.fAstroflag;
 227  fLogic=q.fLogic;
 228  fAstroDa=q.fAstroDa;
 229  fAstroDt=q.fAstroDt;
 230  fAstroDir=q.fAstroDir;
 231
 232  for (Int_t i=0; i<10; i++)
 233  {
 234   fEventTracks[i]=q.fEventTracks[i];
 235
 236   if (i<6)
 237   {
 238    fTrackMomenta[i]=q.fTrackMomenta[i];
 239    fTrackEnergies[i]=q.fTrackEnergies[i];
 240    fEventMomenta[i]=q.fEventMomenta[i];
 241    fEventEnergies[i]=q.fEventEnergies[i];
 242   }
 243
 244   if (i<4) fTrackRapidities[i]=q.fTrackRapidities[i];
 245
 246   if (i<2)
 247   {
 248    fTrackMasses[i]=q.fTrackMasses[i];
 249    fEventMasses[i]=q.fEventMasses[i];
 250    fTrackCharges[i]=q.fTrackCharges[i];
 251    fEventCharges[i]=q.fEventCharges[i];
 252    fTrackDevices[i]=q.fTrackDevices[i];
 253    fEventDevices[i]=q.fEventDevices[i];
 254   }
 255  }
 256  fTrackDevClass=q.fTrackDevClass;
 257  fEventDevClass=q.fEventDevClass;
 258  fEventTrkName=q.fEventTrkName;
 259 }
 260 ///////////////////////////////////////////////////////////////////////////
 261 void AliEventSelector::SetSelector(TString type,Int_t flag)
 262 {
 263 // Specify the selection types to be used.
 264 // The various types my be selected in a cumulative way by specification
 265 // of the input argument "type".
 266 // The various possibilities are :
 267 //
 268 // type = "track" ==> Selection based on individual track observables (e.g. Pt)
 269 //        "event" ==> Selection based on total event observables (e.g. Invmass)
 270 //        "astro" ==> Selection based on correlation with external objects
 271 //
 272 // The specified selection types can be (de)activated via the input
 273 // argument "flag".
 274 //
 275 // flag = 0 ==> Don't use the specified selection type
 276 //        1 ==> Use the specified selection type
 277 //
 278 // For type="astro" the flag>0 value specifies further selections as follows :
 279 //
 280 // flag = 1 ==> Match individual track momentum directions with external (astrophysical) objects
 281 //        2 ==> Match event total momentum direction with external (astrophysical) objects
 282 //        3 ==> Match event position with external (astrophysical) objects
 283 //
 284 // For further details see memberfunction SetAstroMatch.
 285 //
 286 // The default value is flag=1.
 287 //
 288 // Note : In the default constructor all selection types are de-activated.
 289
 290  if (type=="track") fTrackflag=flag;
 291  if (type=="event") fEventflag=flag;
 292  if (type=="astro") fAstroflag=flag;
 293 }
 294 ///////////////////////////////////////////////////////////////////////////
 295 void AliEventSelector::SetLogic(TString type)
 296 {
 297 // Set type of the decision logic.
 298 //
 299 // type = "and"  ==> Event selection based on logical "and"
 300 //        "or"   ==> Event selection based on logical "or"
 301 //        "nand" ==> Event selection based on logical "nand"
 302 //        "nor"  ==> Event selection based on logical "nor"
 303 //
 304 // Note : In the default constructor the decision logic is set to "unknown".
 305
 306  if (type=="and") fLogic=1;
 307  if (type=="or") fLogic=2;
 308  if (type=="nand") fLogic=-1;
 309  if (type=="nor") fLogic=-2;
 310 }
 311 ///////////////////////////////////////////////////////////////////////////
 312 void AliEventSelector::UseTracks(TString name,Int_t n)
 313 {
 314 // Specification of the track names to be used for the investigation
 315 // of individual track observables and matching with external objects.
 316 //
 317 // name : Specifies the track name (e.g. "IceDwalk")
 318 //        In case name="*" all track names will be accepted.
 319
 320 // n : Specifies the max. number of these tracks to be used
 321 //
 322 // Note : n<0 will use all the existing tracks of the specified name
 323 //
 324 // The default is n=-1.
 325 //
 326 // Consecutive invokations of this memberfunction with different names
 327 // will result in an incremental effect.
 328 //
 329 // Example :
 330 // ---------
 331 // UseTracks("IceDwalk",5);
 332 // UseTracks("IceLinefit",2);
 333 // UseTracks("Pythia");
 334 //
 335 // This will use the first 5 IceDwalk, the first 2 IceLinefit and all the
 336 // Pythia tracks which are encountered in the event structure.
 337
 338  if (!fUseNames)
 339  {
 340   fUseNames=new TObjArray();
 341   fUseNames->SetOwner();
 342  }
 343
 344  if (!fUseNtk) fUseNtk=new TArrayI();
 345
 346  // Check if this classname has already been specified before
 347  TString s;
 348  Int_t nen=fUseNames->GetEntries();
 349  for (Int_t i=0; i<nen; i++)
 350  {
 351   TObjString* sx=(TObjString*)fUseNames->At(i);
 352   if (!sx) continue;
 353   s=sx->GetString();
 354   if (s==name) return;
 355  }
 356
 357  // New name to be added into the storage
 358  if (nen >= fUseNames->GetSize()) fUseNames->Expand(nen+1);
 359  if (nen >= fUseNtk->GetSize()) fUseNtk->Set(nen+1);
 360
 361  TObjString* namex=new TObjString();
 362  namex->SetString(name);
 363  fUseNames->Add(namex);
 364  fUseNtk->AddAt(n,nen);
 365 }
 366 ///////////////////////////////////////////////////////////////////////////
 367 void AliEventSelector::SetAstroMatch(Double_t da,Double_t dt,TString dir)
 368 {
 369 // Set the parameters for the matching of reference objects.
 370 //
 371 // da  : Maximum angular difference in degrees
 372 // dt  : Maximum absolute time difference in seconds
 373 // dir : "to"   ==> Check the location the track (or event) points to
 374 //       "from" ==> Check the location the track (or event) originates from
 375
 376  fAstroDa=fabs(da);
 377  fAstroDt=fabs(dt);
 378  fAstroDir=0;
 379  if (dir=="to") fAstroDir=1;
 380  if (dir=="from") fAstroDir=-1;
 381
 382  if (!fParams) fParams=new AliDevice();
 383
 384  fParams->AddNamedSlot("AstroDa");
 385  fParams->AddNamedSlot("AstroDt");
 386  fParams->AddNamedSlot("AstroDir");
 387  fParams->SetSignal(fAstroDa,"AstroDa");
 388  fParams->SetSignal(fAstroDt,"AstroDt");
 389  fParams->SetSignal(fAstroDir,"AstroDir");
 390 }
 391 ///////////////////////////////////////////////////////////////////////////
 392 void AliEventSelector::SetRange(TString type,TString obs,Double_t low,Double_t up)
 393 {
 394 // Set range for the specified observable.
 395 //
 396 // type : Selection type specifier (e.g. "track" or "event").
 397 // obs  : Observable specification.
 398 // low  : Lower bound of acceptance range
 399 // up   : Upper bound of acceptance range
 400 //
 401 // The various observables that are available for selection criteria are :
 402 //
 403 // obs : "p"   ==> Momentum value in GeV/c
 404 //       "pt"  ==> Transverse momentum value in GeV/c
 405 //       "pl"  ==> Longitudinal momentum value in GeV/c
 406 //       "e"   ==> Energy value in GeV
 407 //       "et"  ==> Transverse momentum value in GeV
 408 //       "el"  ==> Longitudinal momentum value in GeV
 409 //       "m"   ==> (Invariant) mass in GeV/c^2
 410 //       "q"   ==> Charge (electron charge is defined as -1)
 411 //       "y"   ==> Rapidity (only for "track")
 412 //       "eta" ==> Pseudo-rapidity (only for "track")
 413 //
 414 // Note : When up<low the specified observable will not be used for selection.
 415 //
 416 // In the default constructor all observables are de-activated for selection.
 417
 418  if (!fParams) fParams=new AliDevice();
 419
 420  if (type=="track") // Individual track observables
 421  {
 422   if (obs=="p")
 423   {
 424    fTrackMomenta[0]=low;
 425    fTrackMomenta[1]=up;
 426    fParams->AddNamedSlot("TrackMinP");
 427    fParams->AddNamedSlot("TrackMaxP");
 428    fParams->SetSignal(low,"TrackMinP");
 429    fParams->SetSignal(up,"TrackMaxP");
 430   }
 431   if (obs=="pt")
 432   {
 433    fTrackMomenta[2]=low;
 434    fTrackMomenta[3]=up;
 435    fParams->AddNamedSlot("TrackMinPt");
 436    fParams->AddNamedSlot("TrackMaxPt");
 437    fParams->SetSignal(low,"TrackMinPt");
 438    fParams->SetSignal(up,"TrackMaxPt");
 439   }
 440   if (obs=="pl")
 441   {
 442    fTrackMomenta[4]=low;
 443    fTrackMomenta[5]=up;
 444    fParams->AddNamedSlot("TrackMinPl");
 445    fParams->AddNamedSlot("TrackMaxPl");
 446    fParams->SetSignal(low,"TrackMinPl");
 447    fParams->SetSignal(up,"TrackMaxPl");
 448   }
 449   if (obs=="e")
 450   {
 451    fTrackEnergies[0]=low;
 452    fTrackEnergies[1]=up;
 453    fParams->AddNamedSlot("TrackMinE");
 454    fParams->AddNamedSlot("TrackMaxE");
 455    fParams->SetSignal(low,"TrackMinE");
 456    fParams->SetSignal(up,"TrackMaxE");
 457   }
 458   if (obs=="et")
 459   {
 460    fTrackEnergies[2]=low;
 461    fTrackEnergies[3]=up;
 462    fParams->AddNamedSlot("TrackMinEt");
 463    fParams->AddNamedSlot("TrackMaxEt");
 464    fParams->SetSignal(low,"TrackMinEt");
 465    fParams->SetSignal(up,"TrackMaxEt");
 466   }
 467   if (obs=="el")
 468   {
 469    fTrackEnergies[4]=low;
 470    fTrackEnergies[5]=up;
 471    fParams->AddNamedSlot("TrackMinEl");
 472    fParams->AddNamedSlot("TrackMaxEl");
 473    fParams->SetSignal(low,"TrackMinEl");
 474    fParams->SetSignal(up,"TrackMaxEl");
 475   }
 476   if (obs=="m")
 477   {
 478    fTrackMasses[0]=low;
 479    fTrackMasses[1]=up;
 480    fParams->AddNamedSlot("TrackMinM");
 481    fParams->AddNamedSlot("TrackMaxM");
 482    fParams->SetSignal(low,"TrackMinM");
 483    fParams->SetSignal(up,"TrackMaxM");
 484   }
 485   if (obs=="q")
 486   {
 487    fTrackCharges[0]=low;
 488    fTrackCharges[1]=up;
 489    fParams->AddNamedSlot("TrackMinQ");
 490    fParams->AddNamedSlot("TrackMaxQ");
 491    fParams->SetSignal(low,"TrackMinQ");
 492    fParams->SetSignal(up,"TrackMaxQ");
 493   }
 494   if (obs=="y")
 495   {
 496    fTrackRapidities[0]=low;
 497    fTrackRapidities[1]=up;
 498    fParams->AddNamedSlot("TrackMinY");
 499    fParams->AddNamedSlot("TrackMaxY");
 500    fParams->SetSignal(low,"TrackMinY");
 501    fParams->SetSignal(up,"TrackMaxY");
 502   }
 503   if (obs=="eta")
 504   {
 505    fTrackRapidities[2]=low;
 506    fTrackRapidities[3]=up;
 507    fParams->AddNamedSlot("TrackMinEta");
 508    fParams->AddNamedSlot("TrackMaxEta");
 509    fParams->SetSignal(low,"TrackMinEta");
 510    fParams->SetSignal(up,"TrackMaxEta");
 511   }
 512  }
 513
 514  if (type=="event") // Total event observables
 515  {
 516   if (obs=="p")
 517   {
 518    fEventMomenta[0]=low;
 519    fEventMomenta[1]=up;
 520    fParams->AddNamedSlot("EventMinP");
 521    fParams->AddNamedSlot("EventMaxP");
 522    fParams->SetSignal(low,"EventMinP");
 523    fParams->SetSignal(up,"EventMaxP");
 524   }
 525   if (obs=="pt")
 526   {
 527    fEventMomenta[2]=low;
 528    fEventMomenta[3]=up;
 529    fParams->AddNamedSlot("EventMinPt");
 530    fParams->AddNamedSlot("EventMaxPt");
 531    fParams->SetSignal(low,"EventMinPt");
 532    fParams->SetSignal(up,"EventMaxPt");
 533   }
 534   if (obs=="pl")
 535   {
 536    fEventMomenta[4]=low;
 537    fEventMomenta[5]=up;
 538    fParams->AddNamedSlot("EventMinPl");
 539    fParams->AddNamedSlot("EventMaxPl");
 540    fParams->SetSignal(low,"EventMinPl");
 541    fParams->SetSignal(up,"EventMaxPl");
 542   }
 543   if (obs=="e")
 544   {
 545    fEventEnergies[0]=low;
 546    fEventEnergies[1]=up;
 547    fParams->AddNamedSlot("EventMinE");
 548    fParams->AddNamedSlot("EventMaxE");
 549    fParams->SetSignal(low,"EventMinE");
 550    fParams->SetSignal(up,"EventMaxE");
 551   }
 552   if (obs=="et")
 553   {
 554    fEventEnergies[2]=low;
 555    fEventEnergies[3]=up;
 556    fParams->AddNamedSlot("EventMinEt");
 557    fParams->AddNamedSlot("EventMaxEt");
 558    fParams->SetSignal(low,"EventMinEt");
 559    fParams->SetSignal(up,"EventMaxEt");
 560   }
 561   if (obs=="el")
 562   {
 563    fEventEnergies[4]=low;
 564    fEventEnergies[5]=up;
 565    fParams->AddNamedSlot("EventMinEl");
 566    fParams->AddNamedSlot("EventMaxEl");
 567    fParams->SetSignal(low,"EventMinEl");
 568    fParams->SetSignal(up,"EventMaxEl");
 569   }
 570   if (obs=="m")
 571   {
 572    fEventMasses[0]=low;
 573    fEventMasses[1]=up;
 574    fParams->AddNamedSlot("EventMinM");
 575    fParams->AddNamedSlot("EventMaxM");
 576    fParams->SetSignal(low,"EventMinM");
 577    fParams->SetSignal(up,"EventMaxM");
 578   }
 579   if (obs=="q")
 580   {
 581    fEventCharges[0]=low;
 582    fEventCharges[1]=up;
 583    fParams->AddNamedSlot("EventMinQ");
 584    fParams->AddNamedSlot("EventMaxQ");
 585    fParams->SetSignal(low,"EventMinQ");
 586    fParams->SetSignal(up,"EventMaxQ");
 587   }
 588  }
 589 }
 590 ///////////////////////////////////////////////////////////////////////////
 591 void AliEventSelector::SetRange(TString type,TString obs,TString name,Int_t nlow,Int_t nup)
 592 {
 593 // Set range for the specified observable.
 594 //
 595 // type  : Selection type specifier (e.g. "track" or "event").
 596 // obs   : Observable specification.
 597 // name  : (Class) name of the objects to be searched for
 598 // nlow  : Lower bound of acceptance range
 599 // nup   : Upper bound of acceptance range
 600 //
 601 // The various observables that are available for selection criteria are :
 602 //
 603 // obs : "ndev" ==> Number of associated devices of the specified (derived) class name
 604 //       "ntrk" ==> Number of tracks with the specified name (name="*" ==> all tracks)
 605 //       "ntkc" ==> Total number of charged tracks (no name selection)
 606 //       "ntk0" ==> Total number of neutral tracks (no name selection)
 607 //       "ntk+" ==> Total number of positive tracks (no name selection)
 608 //       "ntk-" ==> Total number of negative tracks (no name selection)
 609 //
 610 // Note : For a certain (type,obs) combination only one (class) name can be specified.
 611
 612  if (!fParams) fParams=new AliDevice();
 613
 614  if (type=="track") // Individual track observables
 615  {
 616   if (obs=="ndev")
 617   {
 618    fTrackDevices[0]=nlow;
 619    fTrackDevices[1]=nup;
 620    fTrackDevClass=name;
 621    fParams->AddNamedSlot("TrackMinNdev");
 622    fParams->AddNamedSlot("TrackMaxNdev");
 623    fParams->SetSignal(float(nlow),"TrackMinNdev");
 624    fParams->SetSignal(float(nup),"TrackMaxNdev");
 625   }
 626  }
 627
 628  if (type=="event") // Total event observables
 629  {
 630   if (obs=="ndev")
 631   {
 632    fEventDevices[0]=nlow;
 633    fEventDevices[1]=nup;
 634    fEventDevClass=name;
 635    fParams->AddNamedSlot("EventMinNdev");
 636    fParams->AddNamedSlot("EventMaxNdev");
 637    fParams->SetSignal(float(nlow),"EventMinNdev");
 638    fParams->SetSignal(float(nup),"EventMaxNdev");
 639   }
 640   if (obs=="ntrk")
 641   {
 642    fEventTracks[0]=nlow;
 643    fEventTracks[1]=nup;
 644    fEventTrkName=name;
 645    fParams->AddNamedSlot("EventMinNtrk");
 646    fParams->AddNamedSlot("EventMaxNtrk");
 647    fParams->SetSignal(float(nlow),"EventMinNtrk");
 648    fParams->SetSignal(float(nup),"EventMaxNtrk");
 649   }
 650   if (obs=="ntkc")
 651   {
 652    fEventTracks[2]=nlow;
 653    fEventTracks[3]=nup;
 654    fParams->AddNamedSlot("EventMinNtkc");
 655    fParams->AddNamedSlot("EventMaxNtkc");
 656    fParams->SetSignal(float(nlow),"EventMinNtkc");
 657    fParams->SetSignal(float(nup),"EventMaxNtkc");
 658   }
 659   if (obs=="ntk0")
 660   {
 661    fEventTracks[4]=nlow;
 662    fEventTracks[5]=nup;
 663    fParams->AddNamedSlot("EventMinNtk0");
 664    fParams->AddNamedSlot("EventMaxNtk0");
 665    fParams->SetSignal(float(nlow),"EventMinNtk0");
 666    fParams->SetSignal(float(nup),"EventMaxNtk0");
 667   }
 668   if (obs=="ntk+")
 669   {
 670    fEventTracks[6]=nlow;
 671    fEventTracks[7]=nup;
 672    fParams->AddNamedSlot("EventMinNtk+");
 673    fParams->AddNamedSlot("EventMaxNtk+");
 674    fParams->SetSignal(float(nlow),"EventMinNtk+");
 675    fParams->SetSignal(float(nup),"EventMaxNtk+");
 676   }
 677   if (obs=="ntk-")
 678   {
 679    fEventTracks[8]=nlow;
 680    fEventTracks[9]=nup;
 681    fParams->AddNamedSlot("EventMinNtk-");
 682    fParams->AddNamedSlot("EventMaxNtk-");
 683    fParams->SetSignal(float(nlow),"EventMinNtk-");
 684    fParams->SetSignal(float(nup),"EventMaxNtk-");
 685   }
 686  }
 687 }
 688 ///////////////////////////////////////////////////////////////////////////
 689 void AliEventSelector::Exec(Option_t* opt)
 690 {
 691 // Implementation of the event selection procedures.
 692
 693  TString name=opt;
 694  AliJob* parent=(AliJob*)(gROOT->GetListOfTasks()->FindObject(name.Data()));
 695
 696  if (!parent) return;
 697
 698  fEvt=(AliEvent*)parent->GetObject("AliEvent");
 699  if (!fEvt) return;
 700
 701  Int_t ntkmax=0; // Max. number of tracks for a certain name
 702  Int_t nnames=0; // Number of track names to be processed
 703  if (fUseNames) nnames=fUseNames->GetEntries();
 704  TObjString* strx=0;
 705  TString str;
 706
 707  if (fFirst)
 708  {
 709   cout << " *AliEventSelector* Selection parameters." << endl;
 710   cout << " Selection types in use :";
 711   if (fTrackflag) cout << " track";
 712   if (fEventflag) cout << " event";
 713   if (fAstroflag) cout << " astro";
 714   if (!fTrackflag && !fEventflag && !fAstroflag) cout << " none";
 715   cout << endl;
 716   cout << " Selection logic in use :";
 717   if (fLogic==1) cout << " and";
 718   if (fLogic==2) cout << " or";
 719   if (fLogic==-1) cout << " nand";
 720   if (fLogic==-2) cout << " nor";
 721   if (!fLogic) cout << " unknown";
 722   cout << endl;
 723   if (nnames) cout << " Track name selections to be processed (-1=all)." << endl;
 724   for (Int_t i=0; i<nnames; i++)
 725   {
 726    strx=(TObjString*)fUseNames->At(i);
 727    if (!strx) continue;
 728    str=strx->GetString();
 729    ntkmax=fUseNtk->At(i);
 730    cout << " Maximally " << ntkmax << " track(s) per event of name : " << str.Data() << endl;
 731   }
 732   cout << endl;
 733
 734   fFirst=0;
 735  }
 736
 737  // Storage of the used parameters in the AliEventSelector device
 738  if (!fParams) fParams=new AliDevice();
 739  fParams->SetNameTitle("AliEventSelector","AliEventSelector processor parameters");
 740
 741  fSelect=0;
 742  if (fLogic)
 743  {
 744   if (fEventflag) Event();  // Check criteria for total event observables
 745   if (fTrackflag) Track(0); // Check criteria for total track observables
 746   if (fAstroflag) Astro();  // Check for matches with external objects
 747  }
 748
 749  if (fLogic<0) fSelect*=-1; // In case of "nand"/"nor" logic
 750
 751  fParams->AddNamedSlot("Logic");
 752  fParams->SetSignal(float(fLogic),"Logic");
 753  fParams->AddNamedSlot("Eventflag");
 754  fParams->SetSignal(float(fEventflag),"Eventflag");
 755  fParams->AddNamedSlot("Trackflag");
 756  fParams->SetSignal(float(fTrackflag),"Trackflag");
 757  fParams->AddNamedSlot("Astroflag");
 758  fParams->SetSignal(float(fAstroflag),"Astroflag");
 759  fParams->AddNamedSlot("Select");
 760  fParams->SetSignal(float(fSelect),"Select");
 761
 762  AliDevice* dx=(AliDevice*)fEvt->GetDevice("AliEventSelector");
 763  if (dx) fEvt->RemoveDevice(dx);
 764  fEvt->AddDevice(fParams);
 765 }
 766 ///////////////////////////////////////////////////////////////////////////
 767 void AliEventSelector::Track(Int_t mode)
 768 {
 769 // Check criteria for individual track observables.
 770 // This memberfunction serves also the track direction checking
 771 // for external (astrophysical) objects.
 772 // mode = 0 : Track observables (e.g. P, Pt etc...) are checked
 773 //        1 : Track direction is checked w.r.t. external (astrophysical) objects
 774
 775  if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 776
 777  if (fSelect>0) return; // Event is already flagged as select
 778
 779  if (!fUseNames) return;
 780
 781  if (mode==1 && !fAstroDir) return;
 782
 783  Int_t nnames=fUseNames->GetEntries(); // Number of track names to be processed
 784  Int_t ntkmax=0; // Max. number of tracks for a certain name
 785  TObjString* strx=0;
 786  TString str;
 787  Int_t ntk;
 788
 789  AliTrack* track=0;
 790  AliTimestamp* ts=0;
 791  Ali3Vector p;
 792  TObjArray* tracks=0;
 793  Double_t val;
 794  Int_t ival;
 795  for (Int_t i=0; i<nnames; i++) // Loop over selected track names
 796  {
 797   strx=(TObjString*)fUseNames->At(i);
 798   if (!strx) continue;
 799   str=strx->GetString();
 800   ntkmax=fUseNtk->At(i);
 801   if (str=="*")
 802   {
 803    tracks=fEvt->GetTracks();
 804   }
 805   else
 806   {
 807    tracks=fEvt->GetTracks(str);
 808   }
 809   ntk=0;
 810   if (tracks) ntk=tracks->GetEntries();
 811   if (ntkmax>0 && ntk>ntkmax) ntk=ntkmax;
 812
 813   for (Int_t jtk=0; jtk<ntk; jtk++) // Loop over tracks of a certain name
 814   {
 815    track=(AliTrack*)tracks->At(jtk);
 816    if (!track) continue;
 817
 818    if (!mode) // Check track observables
 819    {
 820     if (fTrackMomenta[1]>fTrackMomenta[0]) // Selection on P
 821     {
 822      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 823      val=track->GetMomentum(1);
 824      if (val>=fTrackMomenta[0] && val<=fTrackMomenta[1])
 825      {
 826       fSelect=1;
 827       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 828      }
 829     }
 830     if (fTrackMomenta[3]>fTrackMomenta[2]) // Selection on Pt
 831     {
 832      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 833      val=track->GetPt(1);
 834      if (val>=fTrackMomenta[2] && val<=fTrackMomenta[3])
 835      {
 836       fSelect=1;
 837       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 838      }
 839     }
 840     if (fTrackMomenta[5]>fTrackMomenta[4]) // Selection on Pl
 841     {
 842      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 843      val=track->GetPl(1);
 844      if (val>=fTrackMomenta[4] && val<=fTrackMomenta[5])
 845      {
 846       fSelect=1;
 847       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 848      }
 849     }
 850     if (fTrackEnergies[1]>fTrackEnergies[0]) // Selection on E
 851     {
 852      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 853      val=track->GetEnergy(1);
 854      if (val>=fTrackEnergies[0] && val<=fTrackEnergies[1])
 855      {
 856       fSelect=1;
 857       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 858      }
 859     }
 860     if (fTrackEnergies[3]>fTrackEnergies[2]) // Selection on Et
 861     {
 862      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 863      val=track->GetEt(1);
 864      if (val>=fTrackEnergies[2] && val<=fTrackEnergies[3])
 865      {
 866       fSelect=1;
 867       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 868      }
 869     }
 870     if (fTrackEnergies[5]>fTrackEnergies[4]) // Selection on El
 871     {
 872      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 873      val=track->GetEl(1);
 874      if (val>=fTrackEnergies[4] && val<=fTrackEnergies[5])
 875      {
 876       fSelect=1;
 877       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 878      }
 879     }
 880     if (fTrackMasses[1]>fTrackMasses[0]) // Selection on M
 881     {
 882      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 883      val=track->GetMass(1);
 884      if (val>=fTrackMasses[0] && val<=fTrackMasses[1])
 885      {
 886       fSelect=1;
 887       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 888      }
 889     }
 890     if (fTrackCharges[1]>fTrackCharges[0]) // Selection on Q
 891     {
 892      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 893      val=track->GetCharge();
 894      if (val>=fTrackCharges[0] && val<=fTrackCharges[1])
 895      {
 896       fSelect=1;
 897       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 898      }
 899     }
 900     if (fTrackRapidities[1]>fTrackRapidities[0]) // Selection on Y
 901     {
 902      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 903      val=track->GetRapidity();
 904      if (val>=fTrackRapidities[0] && val<=fTrackRapidities[1])
 905      {
 906       fSelect=1;
 907       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 908      }
 909     }
 910     if (fTrackRapidities[3]>fTrackRapidities[2]) // Selection on Eta
 911     {
 912      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 913      val=track->GetPseudoRapidity();
 914      if (val>=fTrackRapidities[2] && val<=fTrackRapidities[3])
 915      {
 916       fSelect=1;
 917       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 918      }
 919     }
 920     if (fTrackDevices[1]>fTrackDevices[0]) // Selection on Ndev
 921     {
 922      if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 923      ival=track->GetNsignals(fTrackDevClass.Data());
 924      if (ival>=fTrackDevices[0] && ival<=fTrackDevices[1])
 925      {
 926       fSelect=1;
 927       if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 928      }
 929     }
 930    }
 931    if (mode==1) // Check track direction w.r.t. external (astrophysical) objects
 932    {
 933     p=track->Get3Momentum();
 934     if (fAstroDir<0) p*=-1;
 935     ts=track->GetTimestamp();
 936     if (!ts) ts=(AliTimestamp*)fEvt;
 937
 938     SetSignal(&p,"loc","T",ts,0,"Track");
 939     TArrayI* arr=MatchRefSignal(fAstroDa,"deg",fAstroDt,"s");
 940     if (arr)
 941     {
 942      fSelect=1;
 943      return;
 944     }
 945    }
 946   } // End of loop over tracks of a certain name
 947  } // End of loop over selected track names
 948 }
 949 ///////////////////////////////////////////////////////////////////////////
 950 void AliEventSelector::Event()
 951 {
 952 // Check criteria for total event observables.
 953
 954  if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 955
 956  if (fSelect>0) return; // Event is already flagged as select
 957
 958  Double_t val=0;
 959  Int_t ival=0;
 960  if (fEventMomenta[1]>fEventMomenta[0]) // Selection on P
 961  {
 962   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 963   val=fEvt->GetMomentum(1);
 964   if (val>=fEventMomenta[0] && val<=fEventMomenta[1])
 965   {
 966    fSelect=1;
 967    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 968   }
 969  }
 970  if (fEventMomenta[3]>fEventMomenta[2]) // Selection on Pt
 971  {
 972   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 973   val=fEvt->GetPt(1);
 974   if (val>=fEventMomenta[2] && val<=fEventMomenta[3])
 975   {
 976    fSelect=1;
 977    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 978   }
 979  }
 980  if (fEventMomenta[5]>fEventMomenta[4]) // Selection on Pl
 981  {
 982   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 983   val=fEvt->GetPl(1);
 984   if (val>=fEventMomenta[4] && val<=fEventMomenta[5])
 985   {
 986    fSelect=1;
 987    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 988   }
 989  }
 990  if (fEventEnergies[1]>fEventEnergies[0]) // Selection on E
 991  {
 992   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
 993   val=fEvt->GetEnergy(1);
 994   if (val>=fEventEnergies[0] && val<=fEventEnergies[1])
 995   {
 996    fSelect=1;
 997    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
 998   }
 999  }
1000  if (fEventEnergies[3]>fEventEnergies[2]) // Selection on Et
1001  {
1002   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1003   val=fEvt->GetEt(1);
1004   if (val>=fEventEnergies[2] && val<=fEventEnergies[3])
1005   {
1006    fSelect=1;
1007    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1008   }
1009  }
1010  if (fEventEnergies[5]>fEventEnergies[4]) // Selection on El
1011  {
1012   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1013   val=fEvt->GetEl(1);
1014   if (val>=fEventEnergies[4] && val<=fEventEnergies[5])
1015   {
1016    fSelect=1;
1017    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1018   }
1019  }
1020  if (fEventMasses[1]>fEventMasses[0]) // Selection on Minv
1021  {
1022   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1023   val=fEvt->GetInvmass(1);
1024   if (val>=fEventMasses[0] && val<=fEventMasses[1])
1025   {
1026    fSelect=1;
1027    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1028   }
1029  }
1030  if (fEventCharges[1]>fEventCharges[0]) // Selection on Q
1031  {
1032   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1033   val=fEvt->GetCharge();
1034   if (val>=fEventCharges[0] && val<=fEventCharges[1])
1035   {
1036    fSelect=1;
1037    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1038   }
1039  }
1040  if (fEventDevices[1]>fEventDevices[0]) // Selection on Ndev
1041  {
1042   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1043   ival=fEvt->GetNdevices(fEventDevClass.Data());
1044   if (ival>=fEventDevices[0] && ival<=fEventDevices[1])
1045   {
1046    fSelect=1;
1047    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1048   }
1049  }
1050  if (fEventTracks[1]>fEventTracks[0]) // Selection on Ntrk
1051  {
1052   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1053   if (fEventTrkName=="*")
1054   {
1055    ival=fEvt->GetNtracks();
1056   }
1057   else
1058   {
1059    ival=fEvt->GetNtracks(fEventTrkName);
1060   }
1061   if (ival>=fEventTracks[0] && ival<=fEventTracks[1])
1062   {
1063    fSelect=1;
1064    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1065   }
1066  }
1067  if (fEventTracks[3]>fEventTracks[2]) // Selection on Ntkc
1068  {
1069   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1070   ival=fEvt->GetNtracks(0,3,0);
1071   if (ival>=fEventTracks[2] && ival<=fEventTracks[3])
1072   {
1073    fSelect=1;
1074    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1075   }
1076  }
1077  if (fEventTracks[5]>fEventTracks[4]) // Selection on Ntk0
1078  {
1079   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1080   ival=fEvt->GetNtracks(0,0,0);
1081   if (ival>=fEventTracks[4] && ival<=fEventTracks[5])
1082   {
1083    fSelect=1;
1084    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1085   }
1086  }
1087  if (fEventTracks[7]>fEventTracks[6]) // Selection on Ntk+
1088  {
1089   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1090   ival=fEvt->GetNtracks(0,1,0);
1091   if (ival>=fEventTracks[6] && ival<=fEventTracks[7])
1092   {
1093    fSelect=1;
1094    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1095   }
1096  }
1097  if (fEventTracks[9]>fEventTracks[8]) // Selection on Ntk-
1098  {
1099   if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1100   ival=fEvt->GetNtracks(0,-1,0);
1101   if (ival>=fEventTracks[8] && ival<=fEventTracks[9])
1102   {
1103    fSelect=1;
1104    if (abs(fLogic)==2) return; // Selections are made in logical "(n)or"
1105   }
1106  }
1107 }
1108 ///////////////////////////////////////////////////////////////////////////
1109 void AliEventSelector::Astro()
1110 {
1111 // Check for matches with external objects.
1112
1113  if (abs(fLogic)==1) fSelect=-1; // Selections are made in logical "(n)and"
1114
1115  if (fSelect>0) return; // Event is already flagged as select
1116
1117  // Check track directions w.r.t. external (astrophysical) objects
1118  if (fAstroflag==1)
1119  {
1120   Track(1);
1121   return;
1122  }
1123
1124  // Check total event momentum direction w.r.t. external (astrophysical) objects
1125  if (fAstroflag==2)
1126  {
1127   Ali3Vector p;
1128   p=fEvt->Get3Momentum();
1129   if (fAstroDir<0) p*=-1;
1130   SetSignal(&p,"loc","T",(AliTimestamp*)fEvt,0,"Event");
1131   TArrayI* arr=MatchRefSignal(fAstroDa,"deg",fAstroDt,"s");
1132   if (arr && fLogic) fSelect=1;
1133   return;
1134  }
1135
1136  // Check event position w.r.t. external (astrophysical) objects
1137  if (fAstroflag==3)
1138  {
1139   SetSignal((Ali3Vector*)fEvt,"loc","T",(AliTimestamp*)fEvt,0,"Event");
1140   TArrayI* arr=MatchRefSignal(fAstroDa,"deg",fAstroDt,"s");
1141   if (arr && fLogic) fSelect=1;
1142   return;
1143  }
1144 }
1145 ///////////////////////////////////////////////////////////////////////////
1146 TObject* AliEventSelector::Clone(const char* name) const
1147 {
1148 // Make a deep copy of the current object and provide the pointer to the copy.
1149 // This memberfunction enables automatic creation of new objects of the
1150 // correct type depending on the object type, a feature which may be very useful
1151 // for containers when adding objects in case the container owns the objects.
1152
1153  AliEventSelector* sel=new AliEventSelector(*this);
1154  if (name)
1155  {
1156   if (strlen(name)) sel->SetName(name);
1157  }
1158  return sel;
1159 }
1160 ///////////////////////////////////////////////////////////////////////////