02-dec-2007 NvE New memberfunctions GetNstrings() introduced in IceEvent.
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Dec 2007 12:35:33 +0000 (12:35 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Dec 2007 12:35:33 +0000 (12:35 +0000)
04-dec-2007 NvE New quality value based on both associated hits and strings introduced
                in IceDwalk. The user can select between various modes via the new
                memberfunction SetAsType().

RALICE/icepack/IceDwalk.cxx
RALICE/icepack/IceDwalk.h
RALICE/icepack/IceEvent.cxx
RALICE/icepack/IceEvent.h
RALICE/icepack/history.txt

index af981e2..ead2274 100644 (file)
 // 3) Construction of track candidates (TC's).
 //    These are TE's that fulfill both the conditions
 //
-//     nah >= 1
+//     nax >= 1
 //     qtc >= 0.8*qtcmax
 //
 //    where we have defined :
 //
-//    nah    : Number of associated hits for the specific TE.
+//    nax    : Associated hits and/or strings value for the specific TE.
 //    qtc    : The track quality number (see hereafter).
 //    qtcmax : Maximum quality number encountered for the TE's.
 //
+//    Note : The selection to use the number of associated hits and/or strings
+//           for the track quality number can be performed via the
+//           memberfunction SetAsType(). 
+//
 //    The track quality number qtc is defined as follows :
 //
-//     qtc=nah*(term1+term2)-term3-term4-term5
+//     qtc=nax*(term1+term2)-term3-term4-term5
 //
 //    here we have defined :
 //
 //    This jet quality number is refined on basis of the number of hits
 //    associated to the jet as :
 //
-//      qtcjet=qtcjet+0.2*(nah-nahmax)
+//      qtcjet=qtcjet+0.2*(nax-naxmax)
 //
 //    where we have defined :
 //
-//    nah    : Number of associated hits for the specific jet.
-//    nahmax : Maximum number of associated hits encountered for the jets.
+//    nax    : Associated hits and/or strings value for the specific jet.
+//    naxmax : Maximum number of associated hits (or strings) encountered for the jets.
 //
 //    This qtcjet value is then used to order the various jets w.r.t.
 //    decreasing qtcjet quality number.
@@ -298,6 +302,8 @@ IceDwalk::IceDwalk(const char* name,const char* title) : TTask(name,title)
  fMaxhitsI=1;
  fVgroupA=1;
  fVgroupI=1;
+ fAsTypeA=3;
+ fAsTypeI=3;
  fTrackname="";
  fCharge=0;
 }
@@ -585,6 +591,25 @@ void IceDwalk::SetVgroupUsage(Int_t flag,TString s)
  if (s=="I") fVgroupI=flag;
 }
 ///////////////////////////////////////////////////////////////////////////
+void IceDwalk::SetAsType(Int_t flag,TString s)
+{
+// Select number of associated hits and/or strings as quality indicator.
+//
+// flag = 1 : Number of associated hits (nah) is used as quality indicator
+//      = 2 : Number of associated strings (nas) is used as quality indicator
+//      = 3 : nah*nas is used as quality indicator
+//
+// The input argument "s" allows for detector specification.
+//
+// s = "A" --> Amanda
+//     "I" --> InIce
+//
+// By default the flag value is set to 3 in the constructor of this class.
+
+ if (s=="A") fAsTypeA=flag;
+ if (s=="I") fAsTypeI=flag;
+}
+///////////////////////////////////////////////////////////////////////////
 void IceDwalk::SetTrackName(TString s)
 {
 // Set (alternative) name identifier for the produced first guess tracks.
@@ -640,6 +665,7 @@ void IceDwalk::Exec(Option_t* opt)
  params.AddNamedSlot("MinmodA");
  params.AddNamedSlot("MaxhitsA");
  params.AddNamedSlot("VgroupA");
+ params.AddNamedSlot("AsTypeA");
 
  params.SetSignal(fDminA,"DminA");
  params.SetSignal(fDtmargA,"DtmargA");
@@ -655,6 +681,7 @@ void IceDwalk::Exec(Option_t* opt)
  params.SetSignal(fMinmodA,"MinmodA");
  params.SetSignal(fMaxhitsA,"MaxhitsA");
  params.SetSignal(fVgroupA,"VgroupA");
+ params.SetSignal(fAsTypeA,"AsTypeA");
 
  params.AddNamedSlot("DminI");
  params.AddNamedSlot("DtmargI");
@@ -670,6 +697,7 @@ void IceDwalk::Exec(Option_t* opt)
  params.AddNamedSlot("MinmodI");
  params.AddNamedSlot("MaxhitsI");
  params.AddNamedSlot("VgroupI");
+ params.AddNamedSlot("AsTypeI");
 
  params.SetSignal(fDminI,"DminI");
  params.SetSignal(fDtmargI,"DtmargI");
@@ -685,6 +713,7 @@ void IceDwalk::Exec(Option_t* opt)
  params.SetSignal(fMinmodI,"MinmodI");
  params.SetSignal(fMaxhitsI,"MaxhitsI");
  params.SetSignal(fVgroupI,"VgroupI");
+ params.SetSignal(fAsTypeI,"AsTypeI");
 
  fEvt->AddDevice(params);
 
@@ -853,11 +882,10 @@ void IceDwalk::Amanda()
 
  // Association of hits to the various track elements.
  Float_t qmax=0;
- Int_t nahmax=0;
- AssociateHits(tes,hits,fVgroupA,fMaxdhitA,qmax,nahmax);
+ AssociateHits(tes,hits,fVgroupA,fMaxdhitA,fAsTypeA,qmax);
 
  // Selection on quality (Q value) in case of multiple track candidates
- SelectQvalue(tes,qmax);
+ SelectQvalue(tes,fAsTypeA,qmax);
 
  Int_t nte=tes.GetEntries();
  if (!nte) return;
@@ -865,7 +893,7 @@ void IceDwalk::Amanda()
  // Clustering of track candidates into jets
  TObjArray jets;
  jets.SetOwner();
- ClusterTracks(tes,jets,fTangmaxA,fTinvolA,fTdistmaxA,qmax);
+ ClusterTracks(tes,jets,fTangmaxA,fTinvolA,fTdistmaxA,fAsTypeI,qmax);
 
  Int_t njets=jets.GetEntries();
  if (!njets) return;
@@ -875,7 +903,7 @@ void IceDwalk::Amanda()
  TObjArray jets2(*ordered);
 
  // Merging of jets
- MergeJets(jets2,fJangmaxA,fJdistmaxA,fJinvolA,fJiterateA);
+ MergeJets(jets2,fJangmaxA,fJdistmaxA,fJinvolA,fJiterateA,fAsTypeA);
 
  // Production and storage of the final tracks
  TString name=fTrackname;
@@ -1046,11 +1074,10 @@ void IceDwalk::InIce()
 
  // Association of hits to the various track elements.
  Float_t qmax=0;
- Int_t nahmax=0;
- AssociateHits(tes,hits,fVgroupI,fMaxdhitI,qmax,nahmax);
+ AssociateHits(tes,hits,fVgroupI,fMaxdhitI,fAsTypeI,qmax);
 
  // Selection on quality (Q value) in case of multiple track candidates
- SelectQvalue(tes,qmax);
+ SelectQvalue(tes,fAsTypeI,qmax);
 
  Int_t nte=tes.GetEntries();
  if (!nte) return;
@@ -1058,7 +1085,7 @@ void IceDwalk::InIce()
  // Clustering of track candidates into jets
  TObjArray jets;
  jets.SetOwner();
- ClusterTracks(tes,jets,fTangmaxI,fTinvolI,fTdistmaxI,qmax);
+ ClusterTracks(tes,jets,fTangmaxI,fTinvolI,fTdistmaxI,fAsTypeI,qmax);
 
  Int_t njets=jets.GetEntries();
  if (!njets) return;
@@ -1068,7 +1095,7 @@ void IceDwalk::InIce()
  TObjArray jets2(*ordered);
 
  // Merging of jets
- MergeJets(jets2,fJangmaxI,fJdistmaxI,fJinvolI,fJiterateI);
+ MergeJets(jets2,fJangmaxI,fJdistmaxI,fJinvolI,fJiterateI,fAsTypeI);
 
  // Production and storage of the final tracks
  TString name=fTrackname;
@@ -1079,7 +1106,7 @@ void IceDwalk::InIce()
  StoreTracks(jets2,fJangmaxI,name,title);
 }
 ///////////////////////////////////////////////////////////////////////////
-void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t maxdhit,Float_t& qmax,Int_t& nahmax)
+void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t maxdhit,Int_t astype,Float_t& qmax)
 {
  // Association of hits to the various track elements.
 
@@ -1111,6 +1138,7 @@ void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t
  times.SetStoreMode(1); // Enable median calculation
  AliSignal fit;         // Storage of Q value etc... for each track candidate
  fit.AddNamedSlot("QTC");
+ fit.AddNamedSlot("Nstrings");
  fit.AddNamedSlot("SpanL");
  fit.AddNamedSlot("MedianL");
  fit.AddNamedSlot("MeanL");
@@ -1132,14 +1160,15 @@ void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t
  fit.AddNamedSlot("term3");
  fit.AddNamedSlot("term4");
  fit.AddNamedSlot("term5");
- Float_t qtc=0;
- Int_t nah; // Number of associated hits for a certain TE
+ Int_t nah=0;   // Number of associated hits
+ Int_t nas=0;   // Number of associated strings
+ Float_t qtc=0; // Quality parameter for the track (candidate)
+ Float_t nax=0; // Associated hits and/or strings value to build the QTC for a certain TE
  Float_t lmin,lmax,spanl,medianl,meanl,sigmal,spreadl,expspreadl;
  Float_t hproj,hprojmin,hprojmax,span,median,mean,sigma,spread,expspread;
  Float_t mediant,meant,sigmat,spreadt;
  Float_t term1,term2,term3,term4,term5;
  qmax=0;
- nahmax=0;
  for (Int_t jte=0; jte<nte; jte++)
  {
   AliTrack* te=(AliTrack*)tes.At(jte);
@@ -1180,7 +1209,11 @@ void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t
   // Determine the Q quality of the various TE's.
   // Good quality TE's will be called track candidates (TC's)
   nah=te->GetNsignals();
-  if (nah>nahmax) nahmax=nah;
+  nas=fEvt->GetNstrings(*te,"IceGOM");
+  nax=0;
+  if (astype==1) nax=nah;
+  if (astype==2) nax=nas;
+  if (astype==3) nax=nah*nas;
   lmin=levers.GetMinimum(1);
   lmax=levers.GetMaximum(1);
   spanl=lmax-lmin;
@@ -1221,10 +1254,11 @@ void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t
   term5=0;
   if (spreadt>0) term5=fabs(mediant)/spreadt;
 
-  qtc=float(nah)*(term1+term2)-term3-term4-term5;
+  qtc=nax*(term1+term2)-term3-term4-term5;
   if (fabs(median)>span/2.) qtc=0; // Require projected hits on both sides of r0
 
   fit.SetSignal(qtc,"QTC");
+  fit.SetSignal(nas,"Nstrings");
   fit.SetSignal(spanl,"SpanL");
   fit.SetSignal(medianl,"MedianL");
   fit.SetSignal(meanl,"MeanL");
@@ -1251,23 +1285,35 @@ void IceDwalk::AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void IceDwalk::SelectQvalue(TObjArray& tes,Float_t qmax)
+void IceDwalk::SelectQvalue(TObjArray& tes,Int_t astype,Float_t qmax)
 {
  // Perform selection on Q value in case of multiple track candidates
 
  Int_t nte=tes.GetEntries();
- Int_t nah;
- Float_t qtc;
+ Int_t nah=0;
+ Int_t nas=0;
+ Float_t nax=0;
+ Float_t qtc=0;
  Ali3Vector p;
  for (Int_t jtc=0; jtc<nte; jtc++)
  {
   AliTrack* te=(AliTrack*)tes.At(jtc);
   if (!te) continue;
-  nah=te->GetNsignals();
   AliSignal* sx1=(AliSignal*)te->GetFitDetails();
   qtc=-1;
-  if (sx1) qtc=sx1->GetSignal("QTC");
-  if (!nah || qtc<0.8*qmax)
+  nah=te->GetNsignals();
+  nas=0;
+  if (sx1)
+  {
+   qtc=sx1->GetSignal("QTC");
+   nas=int(sx1->GetSignal("Nstrings"));
+  }
+  nax=0;
+  if (astype==1) nax=nah;
+  if (astype==2) nax=nas;
+  if (astype==3) nax=nah*nas;
+
+  if (nax<=0 || qtc<0.8*qmax)
   {
    tes.RemoveAt(jtc);
    delete te;
@@ -1285,7 +1331,7 @@ void IceDwalk::SelectQvalue(TObjArray& tes,Float_t qmax)
  tes.Compress();
 }
 ///////////////////////////////////////////////////////////////////////////
-void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_t tinvol,Float_t tdistmax,Float_t qmax)
+void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_t tinvol,Float_t tdistmax,Int_t astype,Float_t qmax)
 {
  // Cluster track candidates within a certain opening angle into jets.
  // Also the track should be within a certain maximum distance of the
@@ -1302,7 +1348,9 @@ void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_
  Float_t vec[3],err[3];
  AliPosition r0;
  Float_t t0,dist,dist2;
- Int_t nah=0,nahmax=0; // Determine the max. number of associated hits for the jets
+ Int_t nah=0; // Number of associated hits
+ Int_t nas=0; // Number of associated strings
+ Float_t nax=0,naxmax=0; // Associated hits and/or strings value for the jets
  Float_t qtc;
  for (Int_t jtc1=0; jtc1<nte; jtc1++)
  {
@@ -1372,7 +1420,12 @@ void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_
   {
    jets.Add(jx);
    nah=jx->GetNsignals();
-   if (nah>nahmax) nahmax=nah;
+   nas=fEvt->GetNstrings(*jx,"IceGOM");
+   nax=0;
+   if (astype==1) nax=nah;
+   if (astype==2) nax=nas;
+   if (astype==3) nax=nah*nas;
+   if (nax>naxmax) naxmax=nax;
   }
   else // Only keep single-track jets which have qtc=qmax 
   {
@@ -1383,7 +1436,12 @@ void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_
    {
     jets.Add(jx);
     nah=jx->GetNsignals();
-    if (nah>nahmax) nahmax=nah;
+    nas=fEvt->GetNstrings(*jx,"IceGOM");
+    nax=0;
+    if (astype==1) nax=nah;
+    if (astype==2) nax=nas;
+    if (astype==3) nax=nah*nas;
+    if (nax>naxmax) naxmax=nax;
    }
    else
    {
@@ -1395,7 +1453,7 @@ void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_
  Int_t njets=jets.GetEntries();
  if (!njets) return;
 
- // The sum of 0.15*(nah-nahmax) and average qtc value per track for each jet
+ // The sum of 0.15*(nax-naxmax) and average qtc value per track for each jet
  // will be stored as the jet energy to enable sorting on this value lateron
  Float_t sortval=0;
  Int_t ntk=0;
@@ -1404,14 +1462,19 @@ void IceDwalk::ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_
   AliJet* jx=(AliJet*)jets.At(ijet);
   if (!jx) continue;
   nah=jx->GetNsignals();
+  nas=fEvt->GetNstrings(*jx,"IceGOM");
+  nax=0;
+  if (astype==1) nax=nah;
+  if (astype==2) nax=nas;
+  if (astype==3) nax=nah*nas;
   ntk=jx->GetNtracks();
-  sortval=0.15*float(nah-nahmax);
+  sortval=0.15*(nax-naxmax);
   if (ntk) sortval+=jx->GetMomentum()/float(ntk);
   jx->SetScalar(sortval);
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void IceDwalk::MergeJets(TObjArray& jets2,Float_t jangmax,Float_t jdistmax,Int_t jinvol,Int_t jiterate)
+void IceDwalk::MergeJets(TObjArray& jets2,Float_t jangmax,Float_t jdistmax,Int_t jinvol,Int_t jiterate,Int_t astype)
 {
  // Merge jets within a certain opening to provide the final track(s).
  // Also the jet should be within a certain maximum distance of the
@@ -1425,7 +1488,10 @@ void IceDwalk::MergeJets(TObjArray& jets2,Float_t jangmax,Float_t jdistmax,Int_t
  AliJet* jx1=0;
  AliJet* jx2=0;
  Int_t merged=1;
- Int_t ntk,nah,nahmax;
+ Int_t ntk;
+ Int_t nah=0;
+ Int_t nas=0;
+ Float_t nax=0,naxmax=0;
  Float_t ang,dist,dist2,t0;
  AliSample pos;
  AliSample time;
@@ -1437,7 +1503,7 @@ void IceDwalk::MergeJets(TObjArray& jets2,Float_t jangmax,Float_t jdistmax,Int_t
   while (merged)
   {
    merged=0;
-   nahmax=0;
+   naxmax=0;
    for (Int_t jet1=0; jet1<njets; jet1++)
    {
     jx1=(AliJet*)jets2.At(jet1);
@@ -1506,20 +1572,30 @@ void IceDwalk::MergeJets(TObjArray& jets2,Float_t jangmax,Float_t jdistmax,Int_t
     jx1->SetReferencePoint(r0);
 
     nah=jx1->GetNsignals();
-    if (nah>nahmax) nahmax=nah;
+    nas=fEvt->GetNstrings(*jx1,"IceGOM");
+    nax=0;
+    if (astype==1) nax=nah;
+    if (astype==2) nax=nas;
+    if (astype==3) nax=nah*nas;
+    if (nax>naxmax) naxmax=nax;
    } // End of jet1 loop
 
    jets2.Compress();
 
-   // The sum of 0.15*(nah-nahmax) and average qtc value per track for each jet
+   // The sum of 0.15*(nax-naxmax) and average qtc value per track for each jet
    // will be stored as the jet energy to enable sorting on this value
    for (Int_t jjet=0; jjet<njets; jjet++)
    {
     AliJet* jx=(AliJet*)jets2.At(jjet);
     if (!jx) continue;
     nah=jx->GetNsignals();
+    nas=fEvt->GetNstrings(*jx,"IceGOM");
+    nax=0;
+    if (astype==1) nax=nah;
+    if (astype==2) nax=nas;
+    if (astype==3) nax=nah*nas;
     ntk=jx->GetNtracks();
-    sortval=0.15*float(nah-nahmax);
+    sortval=0.15*float(nax-naxmax);
     if (ntk) sortval+=jx->GetMomentum()/float(ntk);
     jx->SetScalar(sortval);
    }
index e7ef935..e5cb603 100644 (file)
@@ -33,6 +33,7 @@ class IceDwalk : public TTask
   void SetMinMod(Int_t nmin,TString s="A");               // Set min. number of good fired (D)OMs for events to be processed
   void SetMaxHits(Int_t nmax,TString s="A");              // Set max. number of good hits per (D)OM to be processed
   void SetVgroupUsage(Int_t flag,TString s="A");          // (De)activate usage of distinct phase and group velocities
+  void SetAsType(Int_t flag,TString s);                   // Select # assoc. hits or strings for quality indicator
   void SetTrackName(TString s);                           // Set (alternative) name for the produced first guess tracks
   void SetCharge(Float_t charge);                         // Set user defined charge for the produced first guess tracks
 
@@ -66,17 +67,19 @@ class IceDwalk : public TTask
   Int_t fMaxhitsI;    // The maximum number of good hits per InIce DOM to be processed
   Int_t fVgroupA;     // Amanda flag to indicate usage of distinct phase and group velocities
   Int_t fVgroupI;     // InIce flag to indicate usage of distinct phase and group velocities
+  Int_t fAsTypeA;     // Amanda flag to indicate usage of # assoc. hits or strings for quality
+  Int_t fAsTypeI;     // InIce flag to indicate usage of # assoc. hits or strings for quality
   TString fTrackname; // The name identifier for the produced first guess tracks
   Float_t fCharge;    // User defined charge of the produced first guess tracks
 
   virtual void Amanda(); // Direct walk reconstruction for Amanda OM signals
   virtual void InIce();  // Direct walk reconstruction for InIce DOM signals
-  virtual void AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t maxdhit,Float_t& qmax,Int_t& nahmax);// Hit association
-  virtual void SelectQvalue(TObjArray& tes,Float_t qmax);                  // TC selection via Q-value
-  virtual void ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_t tinvol,Float_t tdistmax,Float_t qmax);// Track clustering  
-  virtual void MergeJets(TObjArray& jets,Float_t jangmax,Float_t jdistmax,Int_t jinvol,Int_t jiterate);// Jet Merging
+  virtual void AssociateHits(TObjArray& tes,TObjArray& hits,Int_t vgroup,Float_t maxdhit,Int_t astype,Float_t& qmax);// Hit association
+  virtual void SelectQvalue(TObjArray& tes,Int_t astype,Float_t qmax); // TC selection via Q-value
+  virtual void ClusterTracks(TObjArray& tes,TObjArray& jets,Float_t tangmax,Int_t tinvol,Float_t tdistmax,Int_t astype,Float_t qmax);// Track clustering  
+  virtual void MergeJets(TObjArray& jets,Float_t jangmax,Float_t jdistmax,Int_t jinvol,Int_t jiterate,Int_t astype);// Jet Merging
   virtual void StoreTracks(TObjArray& jets,Float_t jangmax,TString name,TString title); // Final track storage
 
- ClassDef(IceDwalk,9) // TTask derived class to perform (improved) direct walk reconstruction
+ ClassDef(IceDwalk,10) // TTask derived class to perform (improved) direct walk reconstruction
 };
 #endif
index a66e609..a40a913 100644 (file)
@@ -284,16 +284,177 @@ ClassImp(IceEvent) // Class implementation to enable ROOT I/O
 IceEvent::IceEvent() : AliEvent()
 {
 // Default constructor.
+
+ fStrings=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 IceEvent::~IceEvent()
 {
 // Default destructor.
+
+ if (fStrings)
+ {
+  delete fStrings;
+  fStrings=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 IceEvent::IceEvent(const IceEvent& evt) : AliEvent(evt)
 {
 // Copy constructor.
+
+ fStrings=0;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t IceEvent::GetNstrings(TString classname)
+{
+// Provide the number of fired strings of modules of the specified classname for this event.
+
+ // Fetch all fired modules of the specified class for this event
+ TObjArray* mods=GetDevices(classname);
+ if (!mods) return 0;
+ Int_t nmods=mods->GetEntries();
+ if (!nmods) return 0;
+
+ // Check for the string ids of the good fired modules
+ if (!fStrings) fStrings=new TArrayI(200);
+ fStrings->Reset();
+ Int_t idxmax=fStrings->GetSize();
+ Int_t nstrings=0;
+ Int_t jstring=0;
+ Int_t match=0;
+ for (Int_t imod=0; imod<nmods; imod++)
+ {
+  IceGOM* omx=(IceGOM*)mods->At(imod);
+  if (!omx) continue;
+  if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
+
+  // Update the number of fired strings
+  jstring=omx->GetString();
+  match=0;
+  if (nstrings) idxmax=nstrings;
+  for (Int_t idx=0; idx<idxmax; idx++)
+  {
+   if (jstring==fStrings->At(idx))
+   {
+    match=1;
+    break;
+   }
+  } 
+  if (!match) // String number was not present in array
+  {
+   nstrings++;
+   fStrings->AddAt(jstring,nstrings-1);
+  }
+ }
+
+ return nstrings; 
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t IceEvent::GetNstrings(AliTrack& t,TString classname)
+{
+// Provide the number of fired strings of modules of the specified classname,
+// associated with the specified track.
+
+ // Fetch all associated signals for this track
+ Int_t nh=t.GetNsignals();
+ if (!nh) return 0;
+
+ // Check for the string ids of the associated good fired modules of the specified class
+ if (!fStrings) fStrings=new TArrayI(200);
+ fStrings->Reset();
+ Int_t idxmax=fStrings->GetSize();
+ Int_t nstrings=0;
+ Int_t jstring=0;
+ Int_t match=0;
+ for (Int_t ih=1; ih<=nh; ih++)
+ {
+  AliSignal* sx=t.GetSignal(ih);
+  if (!sx) continue;
+  AliDevice* dev=sx->GetDevice();
+  if (!dev) continue;
+  if (!(dev->InheritsFrom(classname.Data()))) continue;
+  IceGOM* omx=(IceGOM*)dev;
+  if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
+
+  // Update the number of fired strings
+  jstring=omx->GetString();
+  match=0;
+  if (nstrings) idxmax=nstrings;
+  for (Int_t idx=0; idx<idxmax; idx++)
+  {
+   if (jstring==fStrings->At(idx))
+   {
+    match=1;
+    break;
+   }
+  } 
+  if (!match) // String number was not present in array
+  {
+   nstrings++;
+   fStrings->AddAt(jstring,nstrings-1);
+  }
+ }
+
+ return nstrings; 
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t IceEvent::GetNstrings(AliJet& j,TString classname)
+{
+// Provide the number of fired strings of modules of the specified classname,
+// associated with the specified jet.
+
+ Int_t ntk=j.GetNtracks();
+ if (!ntk) return 0;
+
+ if (!fStrings) fStrings=new TArrayI(200);
+ fStrings->Reset();
+ Int_t idxmax=fStrings->GetSize();
+ Int_t nstrings=0;
+ Int_t jstring=0;
+ Int_t match=0;
+ Int_t nh=0;
+ for (Int_t itk=1; itk<=ntk; itk++)
+ {
+  AliTrack* tx=j.GetTrack(itk);
+  if (!tx) continue;
+
+  // Fetch all associated signals for this track
+  nh=tx->GetNsignals();
+  if (!nh) return 0;
+
+  // Check for the string ids of the associated good fired modules of the specified class
+  for (Int_t ih=1; ih<=nh; ih++)
+  {
+   AliSignal* sx=tx->GetSignal(ih);
+   if (!sx) continue;
+   AliDevice* dev=sx->GetDevice();
+   if (!dev) continue;
+   if (!(dev->InheritsFrom(classname.Data()))) continue;
+   IceGOM* omx=(IceGOM*)dev;
+   if (omx->GetDeadValue("ADC") || omx->GetDeadValue("LE") || omx->GetDeadValue("TOT")) continue;
+
+   // Update the number of fired strings
+   jstring=omx->GetString();
+   match=0;
+   if (nstrings) idxmax=nstrings;
+   for (Int_t idx=0; idx<idxmax; idx++)
+   {
+    if (jstring==fStrings->At(idx))
+    {
+     match=1;
+     break;
+    }
+   } 
+   if (!match) // String number was not present in array
+   {
+    nstrings++;
+    fStrings->AddAt(jstring,nstrings-1);
+   }
+  } // End of loop over the track hits
+ } // End of loop over the tracks
+
+ return nstrings; 
 }
 ///////////////////////////////////////////////////////////////////////////
 TObject* IceEvent::Clone(const char* name) const
index 12375db..43ac58d 100644 (file)
@@ -7,6 +7,7 @@
 // $Id$
 
 #include "AliEvent.h"
+#include "IceGOM.h"
 
 class IceEvent : public AliEvent
 {
@@ -15,7 +16,13 @@ class IceEvent : public AliEvent
   virtual ~IceEvent();                               // Default destructor
   IceEvent(const IceEvent& evt);                     // Copy constructor
   virtual TObject* Clone(const char* name="") const; // Make a deep copy and provide its pointer
+  Int_t GetNstrings(TString classname);              // Number of fired strings for good mods. of the specified class for this event 
+  Int_t GetNstrings(AliTrack& t,TString classname);  // Number of fired strings for good mods. of the specified class associated to this track
+  Int_t GetNstrings(AliJet& j,TString classname);    // Number of fired strings for good mods. of the specified class associated to this jet
 
- ClassDef(IceEvent,1) // Handling of IceCube event data.
+ protected:
+  TArrayI* fStrings; //! Temp. array to hold the string ids of fired modules
+
+ ClassDef(IceEvent,2) // Handling of IceCube event data.
 };
 #endif
index 910736a..a221e83 100644 (file)
 21-nov-2007 NvE (De)calibration functions reset to 0 in IceMakeHits to indicate uncalibrated
                 data. This will allow correct re-processing of IceMakeHits on already calibrated
                 signals.
+02-dec-2007 NvE New memberfunctions GetNstrings() introduced in IceEvent.
+04-dec-2007 NvE New quality value based on both associated hits and strings introduced
+                in IceDwalk. The user can select between various modes via the new
+                memberfunction SetAsType().
                  
+