Monitor functions implemented by Z.Chajecki.

diff --git a/HBTAN/AliHBTAnalysis.cxx b/HBTAN/AliHBTAnalysis.cxx
index ace1f2058d712edacc88169a324a40447dd9ce7d..2afb7684e89ba9f1ed86e7638f4c38c3db0fc6d0 100644 (file)
--- a/HBTAN/AliHBTAnalysis.cxx
+++ b/HBTAN/AliHBTAnalysis.cxx
@@ -11,6 +11,7 @@
 #include "AliHBTPair.h"
 #include "AliHBTPairCut.h"
 #include "AliHBTFunction.h"
+#include "AliHBTMonitorFunction.h"
 
 #include <TBenchmark.h>
 #include <TList.h>
@@ -30,10 +31,18 @@ AliHBTAnalysis::AliHBTAnalysis()
    fParticleFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
    fParticleAndTrackFunctions = new AliHBTTwoPairFctn* [fgkFctnArraySize];
    
+   fParticleMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];    
+   fTrackMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];    
+   fParticleAndTrackMonitorFunctions = new AliHBTMonTwoParticleFctn* [fgkFctnArraySize];    
+
    fNTrackFunctions = 0;
    fNParticleFunctions = 0;
    fNParticleAndTrackFunctions = 0;
   
+   fNParticleMonitorFunctions = 0; 
+   fNTrackMonitorFunctions = 0; 
+   fNParticleAndTrackMonitorFunctions = 0; 
+
    fPairCut = new AliHBTEmptyPairCut();//empty cut - accepts all particles
    
    fBufferSize = 2; 
@@ -50,6 +59,10 @@ AliHBTAnalysis::~AliHBTAnalysis()
    delete [] fParticleFunctions;
    delete [] fParticleAndTrackFunctions;
    
+   delete [] fParticleMonitorFunctions; 
+   delete [] fTrackMonitorFunctions; 
+   delete [] fParticleAndTrackMonitorFunctions; 
+
    delete fPairCut; // always have an copy of an object - we create we dstroy
  }
 
@@ -92,6 +105,8 @@ void AliHBTAnalysis::Process(Option_t* option)
  const char *oP = strstr(option,"Particles");
  
  Bool_t nonid = IsNonIdentAnalysis();
+ // nonid=0;
+ cout<<"nonid = "<<nonid<<endl; 
  
  if(oT && oP)
   { 
@@ -194,14 +209,25 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
          if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
 
          part1= partEvent->GetParticle(j);
-         track1= trackEvent->GetParticle(j);   
-        
+         track1= trackEvent->GetParticle(j);       
+       
+         UInt_t zz;
+         for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+         for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+           fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+        for(zz = 0; zz<fNParticleAndTrackMonitorFunctions; zz++)
+           fParticleAndTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1,part1);
+
+         if ( (fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
+           continue; 
+        
          for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
           {
             part2= partEvent->GetParticle(k);
             partpair->SetParticles(part1,part2);
            
-            track2= trackEvent->GetParticle(k);        
+            track2= trackEvent->GetParticle(k);       
             trackpair->SetParticles(track1,track2);
 
             if(fPairCut->Pass(partpair) || (fPairCut->Pass(trackpair))) //check pair cut
@@ -209,10 +235,9 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
                 if( ( fPairCut->Pass(partpair->GetSwapedPair()) ) || ( fPairCut->Pass(trackpair->GetSwapedPair()) ) ) 
                   continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
                 else 
-                 { //swaped pair meets all the criteria
+               { //swaped pair meets all the criteria
                    tmppartpair = partpair->GetSwapedPair();
                    tmptrackpair = trackpair->GetSwapedPair();
-                   
                  }
               }
             else
@@ -238,14 +263,17 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
   /***************************************/
   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last) ....
     {
-      
+  
+      if ((fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
+        continue;  
+
       partEvent= fReader->GetParticleEvent(i);
       if (!partEvent) continue;
       
       trackEvent = fReader->GetTrackEvent(i); 
       
 //      N=0;
-      
+
       for (Int_t j = 0; j< partEvent->GetNumberOfParticles(); j++) // ... Loop over all particles ...
        {
            
@@ -275,7 +303,7 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
               trackEvent2 = fReader->GetTrackEvent(k);
              
              if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-            
+            
              for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++)   //  ... on all particles
               {
                
@@ -290,12 +318,12 @@ void AliHBTAnalysis::ProcessTracksAndParticles()
                 if( (fPairCut->Pass(partpair)) || (fPairCut->Pass(trackpair)) ) //check pair cut
                   { //do not meets crietria of the 
                     if( ( fPairCut->Pass(partpair->GetSwapedPair()) ) || ( fPairCut->Pass(trackpair->GetSwapedPair()) ) )
-          continue;
-       else 
-        {
-          tmppartpair = partpair->GetSwapedPair();
-          tmptrackpair = trackpair->GetSwapedPair();
-        }
+          continue;
+       else 
+        {
+          tmppartpair = partpair->GetSwapedPair();
+          tmptrackpair = trackpair->GetSwapedPair();
+        }
                   }
                 else
                  {//meets criteria of the pair cut
@@ -355,16 +383,23 @@ void AliHBTAnalysis::ProcessTracks()
        {
          if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
 
-         track1= trackEvent->GetParticle(j);   
-        
+         track1= trackEvent->GetParticle(j);       
+        
+         UInt_t zz;
+         for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+           fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+
+         if ( fNTrackFunctions ==0 )
+           continue; 
+        
          for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
           {
-            track2= trackEvent->GetParticle(k);        
-            trackpair->SetParticles(track1,track2);
-            if(fPairCut->Pass(trackpair)) //check pair cut
-              { //do not meets crietria of the 
-                if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
-                else tmptrackpair = trackpair->GetSwapedPair();
+           track2= trackEvent->GetParticle(k);       
+           trackpair->SetParticles(track1,track2);
+           if(fPairCut->Pass(trackpair)) //check pair cut
+             { //do not meets crietria of the 
+              if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
+              else tmptrackpair = trackpair->GetSwapedPair();
               }
             else
               {
@@ -385,6 +420,9 @@ void AliHBTAnalysis::ProcessTracks()
   /***************************************/
   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last) ....
     {
+      if ( fNTrackFunctions ==0 )
+        continue; 
+
       trackEvent = fReader->GetTrackEvent(i);
       if (!trackEvent) continue;
 //      N=0;
@@ -415,7 +453,7 @@ void AliHBTAnalysis::ProcessTracks()
              if (!trackEvent2) continue;
              
              if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-            
+            
              for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++)   //  ... on all particles
               {
                
@@ -426,7 +464,7 @@ void AliHBTAnalysis::ProcessTracks()
                 if(fPairCut->Pass(trackpair)) //check pair cut
                   { //do not meets crietria of the 
                     if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
-       else tmptrackpair = trackpair->GetSwapedPair();
+       else tmptrackpair = trackpair->GetSwapedPair();
                   }
                 else
                   {
@@ -483,7 +521,14 @@ void AliHBTAnalysis::ProcessParticles()
          if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
 
          part1= partEvent->GetParticle(j);
-        
+        
+         UInt_t zz;
+         for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+
+         if ( fNParticleFunctions ==0 )
+           continue; 
+
          for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
           {
             part2= partEvent->GetParticle(k);
@@ -502,9 +547,8 @@ void AliHBTAnalysis::ProcessParticles()
               {
                 tmppartpair = partpair;
               }
-
+            
             UInt_t ii;
-                
             for(ii = 0;ii<fNParticleFunctions;ii++)
                    fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
            }
@@ -516,6 +560,9 @@ void AliHBTAnalysis::ProcessParticles()
   /***************************************/
   for (Int_t i = 0;i<Nev-1;i++)   //In each event (but last)....
     {
+      if ( fNParticleFunctions ==0 )
+        continue; 
+
       partEvent= fReader->GetParticleEvent(i);
       if (!partEvent) continue;
 
@@ -548,7 +595,7 @@ void AliHBTAnalysis::ProcessParticles()
              if (!partEvent2) continue;
              
              if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-            
+            
              for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++)   //  ... on all particles
               {
                
@@ -559,7 +606,7 @@ void AliHBTAnalysis::ProcessParticles()
                 if(fPairCut->Pass(partpair)) //check pair cut
                   { //do not meets crietria of the 
                     if( fPairCut->Pass(partpair->GetSwapedPair()) ) continue;
-       else tmppartpair = partpair->GetSwapedPair();
+       else tmppartpair = partpair->GetSwapedPair();
                   }
                 else
                   {
@@ -596,6 +643,15 @@ void AliHBTAnalysis::WriteFunctions()
                  
   for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
    fParticleAndTrackFunctions[ii]->Write();
+
+  for(ii = 0;ii<fNParticleMonitorFunctions;ii++)
+    fParticleMonitorFunctions[ii]->Write();
+
+  for(ii = 0;ii<fNTrackMonitorFunctions;ii++)
+    fTrackMonitorFunctions[ii]->Write();
+
+  for(ii = 0;ii<fNParticleAndTrackMonitorFunctions;ii++)
+   fParticleAndTrackMonitorFunctions[ii]->Write();
 }
 /*************************************************************************************/
 
@@ -633,9 +689,9 @@ void AliHBTAnalysis::AddParticleFunction(AliHBTOnePairFctn* f)
    }
   fParticleFunctions[fNParticleFunctions] = f;
   fNParticleFunctions++;
-  
-  
 }
+/*************************************************************************************/ 
+
 void AliHBTAnalysis::AddParticleAndTrackFunction(AliHBTTwoPairFctn* f)
 {
   if (f == 0x0) return;
@@ -646,11 +702,47 @@ void AliHBTAnalysis::AddParticleAndTrackFunction(AliHBTTwoPairFctn* f)
   fParticleAndTrackFunctions[fNParticleAndTrackFunctions] = f;
   fNParticleAndTrackFunctions++;
 }
+/*************************************************************************************/ 
+
+void AliHBTAnalysis::AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f)
+{
+  if (f == 0x0) return;
+
+  if (fNParticleMonitorFunctions == fgkFctnArraySize)
+    {
+      Error("AliHBTAnalysis::AddParticleMonitorFunction","Can not add this function, not enough place in the array.");
+   }
+  fParticleMonitorFunctions[fNParticleMonitorFunctions] = f;
+  fNParticleMonitorFunctions++;
+}
+/*************************************************************************************/ 
 
+void AliHBTAnalysis::AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f)
+{
+  if (f == 0x0) return;
 
+  if (fNTrackMonitorFunctions == fgkFctnArraySize)
+   {
+    Error("AliHBTAnalysis::AddTrackMonitorFunction","Can not add this function, not enough place in the array.");
+   }
+  fTrackMonitorFunctions[fNTrackMonitorFunctions] = f;
+  fNTrackMonitorFunctions++;
+}
 /*************************************************************************************/ 
 
+void AliHBTAnalysis::AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f)
+{
+  if (f == 0x0) return;
+  if (fNParticleAndTrackMonitorFunctions == fgkFctnArraySize)
+    {
+      Error("AliHBTAnalysis::AddParticleAndTrackMonitorFunction","Can not add this function, not enough place in the array.");
+    }
+  fParticleAndTrackMonitorFunctions[fNParticleAndTrackMonitorFunctions] = f;
+  fNParticleAndTrackMonitorFunctions++;
+}
+
 
+/*************************************************************************************/ 
 /*************************************************************************************/  
 
 Bool_t AliHBTAnalysis::RunCoherencyCheck()
@@ -758,8 +850,8 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
       /********************************/
       /*      Filtering out           */
       /********************************/
-      if (ninbuffer > fBufferSize)
-       {
+      if ((ninbuffer > fBufferSize) && (fBufferSize > 0))
+       {//if we have in buffer desired number of events, use the last. If fBufferSize<0 mix all events for background
         partEvent2  = (AliHBTEvent*)pbuffer.Remove(pbuffer.Last()); //remove from the end to be reset, filled and put on the beginning
         trackEvent2 = (AliHBTEvent*)tbuffer.Remove(tbuffer.Last());
         ninbuffer--;
@@ -780,6 +872,13 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
          part1= partEvent1->GetParticle(j);
          track1= trackEvent1->GetParticle(j);
 
+         UInt_t zz;
+         for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+         for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+           fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+         for(zz = 0; zz<fNParticleAndTrackMonitorFunctions; zz++)
+           fParticleAndTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1,part1);
 
          /***************************************/
          /******   filling numerators    ********/
@@ -811,6 +910,8 @@ void AliHBTAnalysis::ProcessTracksAndParticlesNonIdentAnal()
                      fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(trackpair,partpair);
              }
            }
+        
+
      /***************************************/
      /***** Filling denominators    *********/
      /***************************************/
@@ -896,8 +997,8 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
       /********************************/
       /*      Filtering out           */
       /********************************/
-      if (ninbuffer > fBufferSize)
-       {
+      if ((ninbuffer > fBufferSize) && (fBufferSize > 0))
+       {//if we have in buffer desired number of events, use the last. If fBufferSize<0 mix all events for background
         trackEvent2 = (AliHBTEvent*)tbuffer.Remove(tbuffer.Last());
         ninbuffer--;
        }
@@ -914,6 +1015,9 @@ void AliHBTAnalysis::ProcessTracksNonIdentAnal()
 
          track1= trackEvent1->GetParticle(j);
 
+        UInt_t zz;
+         for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+           fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
 
          /***************************************/
          /******   filling numerators    ********/
@@ -1011,8 +1115,8 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
       /********************************/
       /*      Filtering out           */
       /********************************/
-      if (ninbuffer > fBufferSize)
-       {
+      if ((ninbuffer > fBufferSize) && (fBufferSize > 0))
+       {//if we have in buffer desired number of events, use the last. If fBufferSize<0 mix all events for background
         partEvent2  = (AliHBTEvent*)pbuffer.Remove(pbuffer.Last()); //remove from the end to be reset, filled and put on the beginning
         ninbuffer--;
        }
@@ -1029,6 +1133,9 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
 
          part1= partEvent1->GetParticle(j);
 
+         UInt_t zz;
+         for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+           fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
 
          /***************************************/
          /******   filling numerators    ********/
@@ -1047,8 +1154,10 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
              {//meets criteria of the pair cut
               UInt_t ii;
               for(ii = 0;ii<fNParticleFunctions;ii++)
-                     fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
-
+                {
+                  //  if ((k%100) == 0) cout<<".";
+                  fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
+                }
              }
            }
      /***************************************/
@@ -1075,8 +1184,10 @@ void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
              {//meets criteria of the pair cut
               UInt_t ii;
               for(ii = 0;ii<fNParticleFunctions;ii++)
-                     fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
-
+               {
+                //  if ((k%100) == 0) cout<<"*";
+                 fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
+               }
              }
            }// for particles event2
          }//while event2
@@ -1200,14 +1311,20 @@ Bool_t AliHBTAnalysis::IsNonIdentAnalysis()
  //in the future is possible to perform more sophisticated check 
  //if cuts have excluding requirements
  
- if (fPairCut->IsEmpty()) return kFALSE;
- if (fPairCut->GetFirstPartCut()->IsEmpty()) return kFALSE;
- if (fPairCut->GetSecondPartCut()->IsEmpty()) return kFALSE;
+ if (fPairCut->IsEmpty()) 
+   return kFALSE;
+ 
+ if (fPairCut->GetFirstPartCut()->IsEmpty()) 
+   return kFALSE;
+
+ if (fPairCut->GetSecondPartCut()->IsEmpty()) 
+   return kFALSE;
  
  Int_t id1 = fPairCut->GetFirstPartCut()->GetPID();
  Int_t id2 = fPairCut->GetSecondPartCut()->GetPID();
- 
- if ( (id1==0) || (id2==0) || (id1==id2) ) return kFALSE;
 
+ if ( (id1==0) || (id2==0) || (id1==id2) ) 
+   return kFALSE;
+ 
  return kTRUE;
 }

diff --git a/HBTAN/AliHBTAnalysis.h b/HBTAN/AliHBTAnalysis.h
index 8dbddb57f2c385d55176e8a20f9c70dc4d49f3ff..e4483ad3a2f42f8353aa0a38d4894a2b7b9843f0 100644 (file)
--- a/HBTAN/AliHBTAnalysis.h
+++ b/HBTAN/AliHBTAnalysis.h
@@ -16,6 +16,8 @@ class AliHBTReader;
 class AliHBTOnePairFctn;      
 class AliHBTTwoPairFctn;
 
+class AliHBTMonOneParticleFctn;
+class AliHBTMonTwoParticleFctn;
 
 class TList;
 
@@ -31,10 +33,14 @@ class AliHBTAnalysis: public TObject
 
      void SetGlobalPairCut(AliHBTPairCut* cut);
      
-     void AddTrackFunction(AliHBTOnePairFctn*);
-     void AddParticleFunction(AliHBTOnePairFctn*);
-     void AddParticleAndTrackFunction(AliHBTTwoPairFctn*);
+     void AddTrackFunction(AliHBTOnePairFctn* f);
+     void AddParticleFunction(AliHBTOnePairFctn* f);
+     void AddParticleAndTrackFunction(AliHBTTwoPairFctn* f);
      
+     void AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f);    //z.ch.
+     void AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f);    //z.ch.
+     void AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f);//z.ch.
+
      void AddResolutionFunction(AliHBTTwoPairFctn* f){AddParticleAndTrackFunction(f);}
      
      void SetReader(AliHBTReader* r){fReader = r;}
@@ -67,10 +73,19 @@ class AliHBTAnalysis: public TObject
      AliHBTTwoPairFctn**  fParticleAndTrackFunctions; //!array of pointers to functions that analyze both 
                                         //reconstructed tracks and generated particles
                //i.e. - resolution analyzers
+
+     AliHBTMonOneParticleFctn**  fParticleMonitorFunctions; // array of pointers to monitoring functions
+     AliHBTMonOneParticleFctn**  fTrackMonitorFunctions; // which are used for single particle analysis,
+     AliHBTMonTwoParticleFctn**  fParticleAndTrackMonitorFunctions;  // cut monitoring, etc.
+
      UInt_t fNTrackFunctions; //!
      UInt_t fNParticleFunctions; //!
      UInt_t fNParticleAndTrackFunctions; //!
                
+     UInt_t fNParticleMonitorFunctions; //! 
+     UInt_t fNTrackMonitorFunctions; //! 
+     UInt_t fNParticleAndTrackMonitorFunctions; //! 
+
      /**********************************************/
      /* Control parameters  */
 

diff --git a/HBTAN/HBTAnalysisLinkDef.h b/HBTAN/HBTAnalysisLinkDef.h
index 472148270892afcc42fad0c76d20d592f38079d9..e32c4dab97e8675771bf63783ec7fb0a2613ef84 100644 (file)
--- a/HBTAN/HBTAnalysisLinkDef.h
+++ b/HBTAN/HBTAnalysisLinkDef.h
@@ -9,17 +9,26 @@
 #pragma link C++ class AliHBTEvent+;
 #pragma link C++ class AliHBTRun+;
 #pragma link C++ class AliHBTFunction+;
+#pragma link C++ class AliHBTMonitorFunction+;
 
 #pragma link C++ class AliHBTOnePairFctn+;
-#pragma link C++ class AliHBTTwoPairFctn+;
 #pragma link C++ class AliHBTOnePairFctn1D+;
 #pragma link C++ class AliHBTOnePairFctn2D+;
 #pragma link C++ class AliHBTOnePairFctn3D+;
-
+#pragma link C++ class AliHBTTwoPairFctn+;
 #pragma link C++ class AliHBTTwoPairFctn1D+;
 #pragma link C++ class AliHBTTwoPairFctn2D+;
 #pragma link C++ class AliHBTTwoPairFctn3D+;
 
+#pragma link C++ class AliHBTMonOneParticleFctn+;
+#pragma link C++ class AliHBTMonOneParticleFctn1D+;
+#pragma link C++ class AliHBTMonOneParticleFctn2D+;
+#pragma link C++ class AliHBTMonOneParticleFctn3D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn+;
+#pragma link C++ class AliHBTMonTwoParticleFctn1D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn2D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn3D+;
+
 #pragma link C++ class AliHBTPair+;
 #pragma link C++ class AliHBTParticleCut-;
 #pragma link C++ class AliHBTEmptyParticleCut-;
@@ -65,20 +74,68 @@
 
 #pragma link C++ class AliHBTInvMassCorrelFctn+;
 
-#pragma link C++ class AliHBTQOutResolVSQInvFctn+;
-#pragma link C++ class AliHBTQSideResolVSQInvFctn+;
-#pragma link C++ class AliHBTQLongResolVSQInvFctn+;
-#pragma link C++ class AliHBTQInvResolVSKtFctn+;
-#pragma link C++ class AliHBTQOutResolVSKtFctn+;
-#pragma link C++ class AliHBTQSideResolVSKtFctn+;
-#pragma link C++ class AliHBTQLongResolVSKtFctn+;
-#pragma link C++ class AliHBTQOutResolVSQOutFctn+;
-#pragma link C++ class AliHBTQSideResolVSQSideFctn+;
-#pragma link C++ class AliHBTQLongResolVSQLongFctn+;
+#pragma link C++ class AliHBTQInvResolVsQInvFctn+;
+#pragma link C++ class AliHBTQOutResolVsQInvFctn+;
+#pragma link C++ class AliHBTQSideResolVsQInvFctn+;
+#pragma link C++ class AliHBTQLongResolVsQInvFctn+;
+
+#pragma link C++ class AliHBTQInvResolVsKtFctn+;
+#pragma link C++ class AliHBTQOutResolVsKtFctn+;
+#pragma link C++ class AliHBTQSideResolVsKtFctn+;
+#pragma link C++ class AliHBTQLongResolVsKtFctn+;
+
+#pragma link C++ class AliHBTQOutResolVsQOutFctn+;
+#pragma link C++ class AliHBTQSideResolVsQSideFctn+;
+#pragma link C++ class AliHBTQLongResolVsQLongFctn+;
+
+#pragma link C++ class AliHBTPairThetaResolVsQInvFctn+;
+#pragma link C++ class AliHBTPairPhiResolVsQInvFctn+;
+#pragma link C++ class AliHBTPairThetaResolVsKtFctn+;
+#pragma link C++ class AliHBTPairPhiResolVsKtFctn+;
+
+#pragma link C++ class AliHBTQInvDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQOutDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQSideDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQLongDistributionVsKtFctn+;
+
+#pragma link C++ class AliHBTMonPxDistributionFctn+;
+#pragma link C++ class AliHBTMonPyDistributionFctn+;
+#pragma link C++ class AliHBTMonPzDistributionFctn+;
+#pragma link C++ class AliHBTMonPDistributionFctn+;
+#pragma link C++ class AliHBTMonPtDistributionFctn+;
+#pragma link C++ class AliHBTMonPhiDistributionFctn+;
+#pragma link C++ class AliHBTMonThetaDistributionFctn+;
+
+#pragma link C++ class AliHBTMonPxDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPyDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPzDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPhiDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonThetaDistributionVsPtFctn+;
+
+#pragma link C++ class AliHBTMonPxResolutionFctn+;
+#pragma link C++ class AliHBTMonPyResolutionFctn+;
+#pragma link C++ class AliHBTMonPzResolutionFctn+;
+#pragma link C++ class AliHBTMonPResolutionFctn+;
+#pragma link C++ class AliHBTMonPtResolutionFctn+;
+#pragma link C++ class AliHBTMonPhiResolutionFctn+;
+#pragma link C++ class AliHBTMonThetaResolutionFctn+;
+
+#pragma link C++ class AliHBTMonPxResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPyResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPzResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPtResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPhiResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonThetaResolutionVsPtFctn+;
 
-#pragma link C++ class AliHBTLLWeights+;
-#pragma link C++ class AliHBTLLWeightQInvFctn+;
 #pragma link C++ class AliHBTTwoTrackEffFctn+;
 #pragma link C++ class AliHBTTwoTrackEffFctn3D+;
 
+#pragma link C++ class AliHBTLLWeights+;
+#pragma link C++ class AliHBTLLWeightQInvFctn+;
+#pragma link C++ class AliHBTLLWeightTheorQInvFctn+;
+
+
+
 #endif

diff --git a/HBTAN/Makefile b/HBTAN/Makefile
index d012c74e7339aae7456d228c6aa386a4472d3153..1922fc742064317ae54d6ecfb24db191e154becc 100644 (file)
--- a/HBTAN/Makefile
+++ b/HBTAN/Makefile
@@ -17,11 +17,14 @@ SRCS          = AliHBTAnalysis.cxx AliHBTFunction.cxx \
                AliHBTPair.cxx AliHBTPairCut.cxx\
                 AliHBTCorrelFctn.cxx \
                 AliHBTReader.cxx AliHBTReaderTPC.cxx\
-                AliHBTQResolutionFctns.cxx AliHBTReaderPPprod.cxx\
+                AliHBTReaderPPprod.cxx\
                AliHBTReaderITSv1.cxx AliHBTReaderITSv2.cxx\
                AliHBTReaderKineTree.cxx AliHBTReaderInternal.cxx\
-               AliHBTTwoTrackEffFctn.cxx\
-               AliHBTLLWeights.cxx AliHBTLLWeightFctn.cxx
+               AliHBTTwoTrackEffFctn.cxx \
+               AliHBTQResolutionFctns.cxx AliHBTQDistributionFctns.cxx \
+               AliHBTMonitorFunction.cxx \
+               AliHBTMonResolutionFctns.cxx AliHBTMonDistributionFctns.cxx \
+               AliHBTLLWeights.cxx AliHBTLLWeightFctn.cxx 
 
 # Fortran sources
 
@@ -47,7 +50,7 @@ COBJS         = $(patsubst %.c,tgt_$(ALICE_TARGET)/%.o,$(CSRCS))
 
 # C++ Objects
 
-OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO)
+OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO) 
 
 # C++ compilation flags
 
@@ -69,7 +72,7 @@ ALIBRARY      = $(LIBDIR)/libHBTAN.a
 default:       $(SLIBRARY)
 
 
-$(LIBDIR)/libHBTAN.$(SL): $(OBJS) $(FOBJS)
+$(LIBDIR)/libHBTAN.$(SL): $(OBJS) $(FOBJS) 
 
 $(DICT):                       $(HDRS)
 

diff --git a/HBTAN/libHBTAN.pkg b/HBTAN/libHBTAN.pkg
index 950f37c05e72dd6e1c25d68c23702131434e5ac3..d708dc266d20fcff1d7640c2d347852f5cb9148e 100644 (file)
--- a/HBTAN/libHBTAN.pkg
+++ b/HBTAN/libHBTAN.pkg
@@ -1,11 +1,14 @@
 SRCS          =   \
-AliHBTAnalysis.cxx    AliHBTPair.cxx         AliHBTQResolutionFctns.cxx  AliHBTReaderPPprod.cxx\
-AliHBTCorrelFctn.cxx  AliHBTPairCut.cxx      AliHBTReader.cxx            AliHBTReaderTPC.cxx\
-AliHBTEvent.cxx       AliHBTParticle.cxx     AliHBTRun.cxx\
-AliHBTFunction.cxx    AliHBTParticleCut.cxx  \
-AliHBTReaderITSv1.cxx AliHBTReaderITSv2.cxx AliHBTReaderKineTree.cxx\
-AliHBTTwoTrackEffFctn.cxx AliHBTReaderInternal.cxx\
-AliHBTLLWeights.cxx AliHBTLLWeightFctn.cxx
+AliHBTAnalysis.cxx    AliHBTPair.cxx           AliHBTReaderPPprod.cxx \
+AliHBTReader.cxx      AliHBTReaderTPC.cxx \
+AliHBTCorrelFctn.cxx  AliHBTPairCut.cxx \
+AliHBTEvent.cxx       AliHBTParticle.cxx       AliHBTRun.cxx \
+AliHBTFunction.cxx    AliHBTMonitorFunction.cxx   AliHBTParticleCut.cxx  \
+AliHBTReaderITSv1.cxx AliHBTReaderITSv2.cxx    AliHBTReaderKineTree.cxx \
+AliHBTTwoTrackEffFctn.cxx       AliHBTReaderInternal.cxx\
+AliHBTQResolutionFctns.cxx      AliHBTQDistributionFctns.cxx    \
+AliHBTLLWeights.cxx             AliHBTLLWeightFctn.cxx\
+AliHBTMonDistributionFctns.cxx     AliHBTMonResolutionFctns.cxx 
 
 FSRCS   = fsiini.F  fsiw.F  led_bldata.F  ltran12.F