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