update from Per Thomas - new classes for NeuralNet and FastFit + code warning fixes
authordsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 31 Jan 2010 04:04:44 +0000 (04:04 +0000)
committerdsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 31 Jan 2010 04:04:44 +0000 (04:04 +0000)
13 files changed:
EMCAL/AliCaloRawAnalyzer.cxx
EMCAL/AliCaloRawAnalyzer.h
EMCAL/AliCaloRawAnalyzerCrude.cxx
EMCAL/AliCaloRawAnalyzerCrude.h
EMCAL/AliCaloRawAnalyzerFastFit.cxx [new file with mode: 0644]
EMCAL/AliCaloRawAnalyzerFastFit.h [new file with mode: 0644]
EMCAL/AliCaloRawAnalyzerLMS.cxx
EMCAL/AliCaloRawAnalyzerLMS.h
EMCAL/AliCaloRawAnalyzerNN.cxx [new file with mode: 0644]
EMCAL/AliCaloRawAnalyzerNN.h [new file with mode: 0644]
EMCAL/AliCaloRawAnalyzerPeakFinder.cxx
EMCAL/AliCaloRawAnalyzerPeakFinder.h
EMCAL/libEMCALrec.pkg

index 524c296..68105b3 100644 (file)
@@ -2,7 +2,7 @@
  * This file is property of and copyright by                              *
  * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
  *                                                                        *
- * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no>                *
+ * Primary Author: Per Thomas Hille <perthomas.hille@yale.edu>            *
  *                                                                        *
  * Contributors are mentioned in the code where appropriate.              *
  * Please report bugs to p.t.hille@fys.uio.no                             *
 #include <iostream>
 using namespace std;
 
+ClassImp(AliCaloRawAnalyzer)  
 
-AliCaloRawAnalyzer::AliCaloRawAnalyzer() :  TObject(),
-                                             fMinTimeIndex(-1),
-                                             fMaxTimeIndex(-1),
-                                             fFitArrayCut(5),
-                                             fAmpCut(4),
-                                             fNsampleCut(5),
-                                             fIsZerosupressed( false ),
-                                             fVerbose( false )
+AliCaloRawAnalyzer::AliCaloRawAnalyzer(const char *name) :  TObject(),
+                                                           fMinTimeIndex(-1),
+                                                           fMaxTimeIndex(-1),
+                                                           fFitArrayCut(5),
+                                                           fAmpCut(4),
+                                                           fNsampleCut(5),
+                                                           fIsZerosupressed( false ),
+                                                           fVerbose( false )
 {
-  //Comment
+  //Comment 
+  sprintf(fName, "%s", name);
   for(int i=0; i < MAXSAMPLES; i++ )
     {
       fReversed[i] = 0;
@@ -146,6 +148,9 @@ AliCaloRawAnalyzer::EvaluatePedestal(const UShort_t * const data, const int /*le
          tmp += data[i];
        }
     }
+
+  //  cout << __FILE__ << __LINE__ << "XXXXXXXXXXX returning " <<   tmp/5 << endl;
+
   return  tmp/5;
 }
 
@@ -247,7 +252,6 @@ AliCaloRawAnalyzer::PrintBunch( const AliCaloBunchInfo &bunch ) const
   cout << endl; 
 }
 
-
 AliCaloFitResults
 AliCaloRawAnalyzer::Evaluate( const vector<AliCaloBunchInfo>  &/*bunchvector*/, const UInt_t /*altrocfg1*/,  const UInt_t /*altrocfg2*/)
 { // method to do the selection of what should possibly be fitted
@@ -255,7 +259,6 @@ AliCaloRawAnalyzer::Evaluate( const vector<AliCaloBunchInfo>  &/*bunchvector*/,
   return AliCaloFitResults( 0, 0, 0, 0, 0, 0, 0 );
 }
 
-
 int
 AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, Float_t & maxf, short & maxamp, short & maxampindex, Float_t & ped, int & first, int & last)
 { // method to do the selection of what should possibly be fitted
index 1a3029f..d755ac4 100644 (file)
@@ -2,7 +2,7 @@
 #define ALICALORAWANALYZER_H
 /**************************************************************************
  * This file is property of and copyright by                              *
- * the Relatvistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
+ * the Relatvistic Heavy Ion Group (RHIG), Yale University, US, 2009      *
  *                                                                        *
  * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no>                *
  *                                                                        *
 
 #include "Rtypes.h"
 #include "TObject.h"
-#include <vector>
-using namespace std;
 
 #define MAXSAMPLES 1008 //CRAP PTH
-#include "AliCaloRawAnalyzer.h"
+
+//#include "AliCaloRawAnalyzer.h"
+
+//class AliCaloBunchInfo;
+
+//#include "AliCaloBunchInfo.h"
+
+
+#include <vector>
+using namespace std;
 
 class AliCaloBunchInfo;
 class AliCaloFitResults;
 
+//class vector<AliCaloBunchInfo> ;
+
+//class  vector;
 
 class  AliCaloRawAnalyzer : public TObject
 {
  public:
-  AliCaloRawAnalyzer();
+  AliCaloRawAnalyzer(const char *name="AliCaloRawAnalyzer");
   virtual ~AliCaloRawAnalyzer();
-  virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 );
+  virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
+                                     const UInt_t altrocfg1,  const UInt_t altrocfg2 );
  
   void PrintBunches( const vector<AliCaloBunchInfo> &bunchvector ) const;
   void PrintBunch( const AliCaloBunchInfo &bunch ) const ;
 
-  virtual int PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, Float_t & maxf, short & maxamp, short & maxampindex, Float_t & ped, int & first, int & last);
+  virtual int PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, 
+                                    const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, 
+                                    Float_t & maxf, short & maxamp, short & maxampindex, Float_t & ped, int & first, int & last);
   void SetTimeConstraint(const int min, const int max );
   void SetVerbose(bool verbose = true){ fVerbose = verbose; };
   void SetIsZeroSuppressed(const bool iszs = true) { fIsZerosupressed = iszs; } ;
@@ -56,6 +69,7 @@ class  AliCaloRawAnalyzer : public TObject
 
   // access to array info
   Double_t GetReversed(const int i) const { return fReversed[i]; }
+  const char * GetAlgoName() const { return fName;  };
 
  protected:
   short Max( const AliCaloBunchInfo *const bunch, int *const maxindex) const;
@@ -63,7 +77,7 @@ class  AliCaloRawAnalyzer : public TObject
   bool IsInTimeRange( const int maxindex ) const;
   Float_t  ReverseAndSubtractPed( const AliCaloBunchInfo *bunch, const UInt_t altrocfg1,  const UInt_t altrocfg2, double *outarray ) const;
   int  SelectBunch( const vector<AliCaloBunchInfo> &bunchvector, short *const maxampbin, short *const maxamplitude ) const;
-  void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const;
+  virtual void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const;
   Float_t EvaluatePedestal(const UShort_t * const data, const int length ) const;
   
   Double_t fReversed[MAXSAMPLES]; //Reversed sequence of samples (pedestalsubtracted)
@@ -77,6 +91,11 @@ class  AliCaloRawAnalyzer : public TObject
   bool fIsZerosupressed; //Wether or not the data is zeros supressed, by default its assumed that the baseline is also subtracted if set to true
   bool fVerbose;     //Print debug information to std out if set to true
 
+  char fName[256]; // Name of the algorithm
+
+
+  ClassDef(AliCaloRawAnalyzer, 1)  
+
 };
 
 #endif
index 0ddd36e..d9b509a 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+
+// Evaluation of amplitude
+// as max sample value - pedestal
+// Not veru accurate, but very robust
+// --------------
+// --------------
+
 #include "AliCaloRawAnalyzerCrude.h"
 #include "AliCaloFitResults.h"
 #include "AliCaloBunchInfo.h"
 
 
-AliCaloRawAnalyzerCrude::AliCaloRawAnalyzerCrude()
+ClassImp(AliCaloRawAnalyzerCrude)  
+
+
+AliCaloRawAnalyzerCrude::AliCaloRawAnalyzerCrude() : AliCaloRawAnalyzer("Crude")
 {
 
 }
@@ -35,9 +45,10 @@ AliCaloRawAnalyzerCrude::~AliCaloRawAnalyzerCrude()
 AliCaloFitResults
 AliCaloRawAnalyzerCrude::Evaluate(const vector<AliCaloBunchInfo> &bunchvector, const UInt_t /*altrocfg1*/,  const UInt_t /*altrocfg2*/)
 {
+  // Evaluation of signal parameters
   if( bunchvector.size()  <=  0 )
     {
-      return AliCaloFitResults(-1, -1, -1, -1 , -1, -1, -1 );
+      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
     }
 
   Int_t amp = 0;
@@ -61,7 +72,7 @@ AliCaloRawAnalyzerCrude::Evaluate(const vector<AliCaloBunchInfo> &bunchvector, c
 
   //:EvaluatePedestal(const UShort_t * const data, const int length )
   //  double ped = EvaluatePedestal(sig, length) ;
-  return  AliCaloFitResults(amp, ped, -1, amp - ped, tof, -1, -1 );
+  return  AliCaloFitResults(amp, ped, 9999, amp - ped, tof, 9999, 9999 );
   
 } //end Crude
 
index b55ec9e..4f5f386 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+
+
+// Evaluation of amplitude
+// as max sample value - pedestal
+// Not veru accurate, but very robust
+
+
 #include "AliCaloRawAnalyzer.h"
 
 class AliCaloFitResults;
 class AliCaloBunchInfo;
 
-
 class  AliCaloRawAnalyzerCrude : public  AliCaloRawAnalyzer
 {
  public:
    virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
                                       const UInt_t altrocfg1,  const UInt_t altrocfg2 );
-  AliCaloRawAnalyzerCrude();
-  virtual ~AliCaloRawAnalyzerCrude();
+   
+   AliCaloRawAnalyzerCrude();
+   virtual ~AliCaloRawAnalyzerCrude();
+
+   ClassDef(AliCaloRawAnalyzerCrude, 1)  
 
 };
 
diff --git a/EMCAL/AliCaloRawAnalyzerFastFit.cxx b/EMCAL/AliCaloRawAnalyzerFastFit.cxx
new file mode 100644 (file)
index 0000000..e914cf5
--- /dev/null
@@ -0,0 +1,119 @@
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+// Extraction of Amplitude and peak
+// position using specila algorithm
+// from Alexei Pavlinov
+// ----------------
+// ----------------
+
+#include "AliCaloRawAnalyzerFastFit.h"
+#include "AliCaloFastAltroFitv0.h"
+#include "AliCaloFitResults.h"
+#include "AliCaloBunchInfo.h"
+
+#include <iostream>
+
+using namespace std;
+
+ClassImp( AliCaloRawAnalyzerFastFit )
+
+AliCaloRawAnalyzerFastFit::AliCaloRawAnalyzerFastFit() : AliCaloRawAnalyzer("Fast Fit (Alexei)")
+{
+  // Comment
+
+  for(int i=0; i <  1008; i++)
+    {
+      fXAxis[i] = i;
+    }
+
+}
+
+AliCaloRawAnalyzerFastFit::~AliCaloRawAnalyzerFastFit()
+{
+
+}
+
+
+AliCaloFitResults 
+AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
+                                   const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+{
+  // Comment
+
+  short maxampindex; //index of maximum amplitude
+  short maxamp; //Maximum amplitude
+  int index = SelectBunch( bunchvector,  &maxampindex,  &maxamp );
+  if( index >= 0)
+    {
+      Float_t ped = ReverseAndSubtractPed( &(bunchvector.at(index))  ,  altrocfg1, altrocfg2, fReversed  );
+      int first;
+      int last;
+      int maxrev =  maxampindex -  bunchvector.at(index).GetStartBin();
+
+      double maxf =  maxamp - ped;
+
+      if ( maxf > fAmpCut )
+       {
+         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(), maxrev , &first, &last);
+         int nsamples =  last - first;
+
+         //amp  = dAmp;
+         //      time = dTime * GetRawFormatTimeBinWidth();
+
+         //      int length =  bunchvector.at(index).GetLength(); 
+
+         if( ( nsamples  )  >= fNsampleCut )  
+           {
+             Double_t ordered[1008];
+
+             /*
+             cout << __FILE__ << __LINE__ << "!!!!!!! USING these samples" << endl; 
+             for(int i=0; i < nsamples ; i++ )
+               {
+                 ordered[i] = fReversed[first + nsamples -i -1];
+                 cout << ordered[i] << "\t" ;
+               }
+             cout << __FILE__ << __LINE__ << "!!!!!!! Done printing" << endl; 
+             */
+
+             Double_t eSignal = 1; // nominal 1 ADC error
+             Double_t dAmp = maxf; 
+             Double_t eAmp = 0;
+             Double_t dTime = 0;
+             Double_t eTime = 0;
+             Double_t chi2 = 0;
+             Double_t fTau = 0.235;
+             
+             //  AliCaloFastAltroFitv0::FastFit(fXAxis, &fReversed[first] , nsamples,
+             //                                     eSignal, fTau, dAmp, eAmp, dTime, eTime, chi2);
+             
+             AliCaloFastAltroFitv0::FastFit(fXAxis, ordered , nsamples,
+                                            eSignal, fTau, dAmp, eAmp, dTime, eTime, chi2);
+          
+             // return AliCaloFitResults( maxamp, ped , -1, fAmpA[tmpindex], tof, -2, -3 );  
+             return AliCaloFitResults(maxamp, ped, -1,  dAmp, dTime*100E-9,  -2,  -3 );
+           }
+
+       }
+    }    
+  
+  return AliCaloFitResults(9999 , 9999 , 9999,  9999, 9999, 9999, 9999 );
+}
diff --git a/EMCAL/AliCaloRawAnalyzerFastFit.h b/EMCAL/AliCaloRawAnalyzerFastFit.h
new file mode 100644 (file)
index 0000000..39b3778
--- /dev/null
@@ -0,0 +1,45 @@
+#ifndef ALICALORAWANALYZERFASTFIT_H
+#define ALICALORAWANALYZERFASTFIT_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include "AliCaloRawAnalyzer.h"
+#include "Rtypes.h"
+
+// Extraction of Amplitude and peak
+// position using specila algorithm
+// from Alexei Pavlinov
+
+
+class  AliCaloRawAnalyzerFastFit : public AliCaloRawAnalyzer
+{
+ public:
+  AliCaloRawAnalyzerFastFit();
+  virtual ~AliCaloRawAnalyzerFastFit();
+  virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
+                                     const UInt_t altrocfg1,  const UInt_t altrocfg2 ); 
+ private:
+  Double_t fXAxis[1008]; // Xaxis (time bins) corresponding to the ADC samples
+
+  ClassDef( AliCaloRawAnalyzerFastFit, 1 )
+
+
+};
+
+#endif
index 59e4691..91025e0 100644 (file)
@@ -37,9 +37,11 @@ using namespace std;
 
 
 #define BAD 4  //CRAP PTH
+ClassImp( AliCaloRawAnalyzerLMS )
 
 
-AliCaloRawAnalyzerLMS::AliCaloRawAnalyzerLMS() : AliCaloRawAnalyzer(),
+AliCaloRawAnalyzerLMS::AliCaloRawAnalyzerLMS() : AliCaloRawAnalyzer("Chi Square Fit"),
                                                 fkEulerSquared(7.389056098930650227),
                                                 fSig(0),
                                                 fTf1(0)
index edd625e..31c4817 100644 (file)
@@ -46,6 +46,8 @@ class  AliCaloRawAnalyzerLMS : public AliCaloRawAnalyzer
   TGraph *fSig;  // Signale holding the data to be fitted.
   TF1 *fTf1;     // Analytical formula of the Semi Gaussian to be fitted
 
+  ClassDef(AliCaloRawAnalyzerLMS, 1)
+
 };
 
 #endif
diff --git a/EMCAL/AliCaloRawAnalyzerNN.cxx b/EMCAL/AliCaloRawAnalyzerNN.cxx
new file mode 100644 (file)
index 0000000..070cc9a
--- /dev/null
@@ -0,0 +1,154 @@
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthomas.hille@yale.edu>                    *
+ * for the ALICE HLT Project.                                             * 
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Evaluation of peak position
+// and amplitude using Neural Networks (NN)
+// ------------------
+// ------------------
+// ------------------
+
+
+#include "AliCaloRawAnalyzerNN.h"
+#include "AliCaloNeuralFit.h"
+#include "AliCaloFitResults.h"
+#include "AliCaloBunchInfo.h"
+
+#include <iostream>
+
+using namespace std;
+
+ClassImp( AliCaloRawAnalyzerNN )
+
+AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network"), fNeuralNet(0)
+{
+  // Comment
+
+  fNeuralNet = new AliCaloNeuralFit();
+
+  for(int i=0; i < 5 ; i++)
+    {
+      fNNInput[i]  = 0;
+    }
+
+}
+
+
+AliCaloRawAnalyzerNN::~AliCaloRawAnalyzerNN()
+{
+  delete fNeuralNet;
+}
+
+
+AliCaloFitResults 
+AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
+                                      const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+{
+  // The eveluation of  Peak position and amplitude using the Neural Network
+  if( bunchvector.size()  <=  0 )
+    {
+      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+    } 
+  short maxindex;
+  short maxamp;
+
+  int bindex = SelectBunch( bunchvector, &maxindex , &maxamp ) ;
+  
+  if( bindex   < 0 )
+    {
+      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+    }
+  
+  int first = 0;
+  int last = 0;
+  Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( bindex ) )  ,  altrocfg1, altrocfg2, fReversed  );
+  
+  //  SelectSubarray ( fReversed,  bunchvector.at(bindex).GetLength(), &first, &last );
+  
+  short maxrev = maxindex  -  bunchvector.at(bindex).GetStartBin();
+
+  
+  SelectSubarray( fReversed,  bunchvector.at(bindex).GetLength(),  maxrev , &first, &last);
+
+  //  cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " << maxindex << ", first = " << first << ", last = " << last << endl;
+  // cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " <<  maxrev    << ", first = " << first << ", last = " << last << endl;
+  
+  if(maxrev  < 1000 )
+    {
+      if (  ( maxrev   - first) < 2  &&  (last -   maxrev ) < 2)
+       {
+         return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+       }
+      else
+       {
+         /*
+         cout << __FILE__ << __LINE__ << "!!!!!!!!:\t" << fReversed[maxrev -2 ]<< "\t" <<  
+           fReversed[ maxrev  -1 ] << "\t" <<  fReversed[maxrev  ]  <<   "\t" <<
+           fReversed[ maxrev  +1 ] << "\t" <<  fReversed[maxrev +2]  << endl;
+         */
+
+         for(int i=0; i < 5 ; i++)
+           {
+             fNNInput[i]  = fReversed[maxrev-2 +i]/(maxamp -ped);
+           } 
+
+         
+
+         //      double amp = fNeuralNet->Value( 0,  fReversed[maxrev-2], fReversed[maxrev -1],  fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
+         //  double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2], fReversed[maxrev -1],  fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
+         
+         //      double amp = fNeuralNet->Value( 0,  fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
+         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
+         
+         //      double amp = maxamp*fNeuralNet->Value( 0,  fReversed[maxrev-2]/(maxamp -ped), fReversed[maxrev -1]/(maxamp -ped),  fReversed[maxrev]/(maxamp-ped), fReversed[maxrev+1]/(maxamp -ped), fReversed[maxrev+2]/(maxamp-ped));
+         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp); 
+        
+
+         //      double amp = maxamp*fNeuralNet->Value( 0,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
+         //      double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + maxrev )*256 ;
+         
+         double amp = maxamp*fNeuralNet->Value( 0,  fNNInput[4],  fNNInput[3], fNNInput[2], fNNInput[1], fNNInput[0]);
+         double tof = (fNeuralNet->Value( 1,  fNNInput[4],  fNNInput[3], fNNInput[2], fNNInput[1], fNNInput[0]) + maxrev )*256 ;
+
+
+         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp);  
+
+         return AliCaloFitResults( maxamp, ped , -1, amp , tof, -2, -3 ); 
+
+       }
+    }
+  return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+}
+
+//amp = exportNN.Value(0,input[0],input[1],input[2],input[3],input[4])*(globMaxSig - pedEstimate);
+//time = (exportNN.Value(1,input[0],input[1],input[2],input[3],input[4])+globMaxId) * fgTimeBins;
+
+
+
+//SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxampindex -  bunchvector.at(index).GetStartBin(), &first, &last);
+
+
+/*
+void 
+AliCaloRawAnalyzerNN::SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const
+{
+
+}
+*/
diff --git a/EMCAL/AliCaloRawAnalyzerNN.h b/EMCAL/AliCaloRawAnalyzerNN.h
new file mode 100644 (file)
index 0000000..8632ee5
--- /dev/null
@@ -0,0 +1,51 @@
+#ifndef ALICALORAWANALYZERNN_H
+#define ALICALORAWANALYZERNN_H
+
+/**************************************************************************
+ * This file is property of and copyright by                              *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
+ *                                                                        *
+ * Primary Author: Per Thomas Hille <perthomas.hille@yale.edu>            *
+ *                                                                        *
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to p.t.hille@fys.uio.no                             *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Evaluation of peak position
+// and amplitude using Neural Networks (NN)
+// ------------------
+
+#include "AliCaloRawAnalyzer.h"
+
+class AliCaloBunchInfo;
+class AliCaloFitResults;
+class AliCaloNeuralFit;
+
+
+class  AliCaloRawAnalyzerNN : public AliCaloRawAnalyzer
+{
+ public:
+  AliCaloRawAnalyzerNN();
+  virtual ~AliCaloRawAnalyzerNN();
+  virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
+                                      const UInt_t altrocfg1,  const UInt_t altrocfg2 );
+  //  virtual void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const;
+
+ private:
+  AliCaloRawAnalyzerNN( const AliCaloRawAnalyzerNN   & );
+  AliCaloRawAnalyzerNN   & operator = ( const  AliCaloRawAnalyzerNN  & );
+  AliCaloNeuralFit *fNeuralNet; // pointer to the class whick actually implements the Neural Network for EMCAL
+  Double_t fNNInput[5]; // The 5 input Neurons to the network ( mix bin + to samples on each side )
+  ClassDef( AliCaloRawAnalyzerNN, 1 )
+
+};
+
+#endif
index 898f29d..b67a03c 100644 (file)
@@ -1,11 +1,11 @@
 /**************************************************************************
- * This file is property of and copyright by the Experimental Nuclear     *
- * Physics Group, Dep. of Physics                                         *
- * University of Oslo, Norway, 2007                                       *
+ * This file is property of and copyright by                              *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
+ *                                                                        *
+ * Primary Author: Per Thomas Hille  <perthomas.hille@yale.edu>           *
  *                                                                        *
- * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
  * Contributors are mentioned in the code where appropriate.              *
- * Please report bugs to perthi@fys.uio.no                                *
+ * Please report bugs to p.t.hille@fys.uio.no                             *
  *                                                                        *
  * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
 
 using namespace std;
 
-AliCaloRawAnalyzerPeakFinder::AliCaloRawAnalyzerPeakFinder() :AliCaloRawAnalyzer(), 
-                                                               fTof(0), 
-                                                               fAmp(0)
+ClassImp( AliCaloRawAnalyzerPeakFinder )
+
+AliCaloRawAnalyzerPeakFinder::AliCaloRawAnalyzerPeakFinder() :AliCaloRawAnalyzer("Peak-Finder")
+//    fTof(0), 
+//                                                           fAmp(0)
 {
   //comment
 
@@ -84,7 +86,7 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
 
   short maxampindex; //index of maximum amplitude
   short maxamp; //Maximum amplitude
-  fAmp = 0;
+  //  fAmp = 0;
   fAmpA[0] = 0;
   fAmpA[1] = 0;
   fAmpA[2] = 0;
@@ -119,11 +121,10 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
              int dt =  maxampindex - startbin -2; 
              for(int i=0; i < SAMPLERANGE; i++ )
                {
-                 //      int dt =  maxampindex - startbin -2;
                  
+                 //      int dt =  maxampindex - startbin -2;
                  //              double tmp[3];
-                 //      tmp[0]  =  fReversed[ dt  +i -1]; 
+                 //      tmp[0]  =  fReversed[ dt  +i -1]; 
                  //              tmp[1]  =  fReversed[ dt  +i];  
                  //              tmp[2]  =  fReversed[ dt  +i +1]; 
                  
@@ -136,7 +137,6 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
                }
              
              double diff = 9999;
-
              int tmpindex = 0;
 
              for(int k=0; k < 3; k ++)
@@ -158,9 +158,7 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
              
              tof = tof /  fAmpA[tmpindex];
 
-             //   return AliCaloFitResults( maxamp, ped , -1, fAmp, -1, -1, -1 );  
              return AliCaloFitResults( maxamp, ped , -1, fAmpA[tmpindex], tof, -2, -3 ); 
-                 
            }
 
          else
index 08cd7f9..6d187f8 100644 (file)
@@ -1,14 +1,15 @@
 #ifndef ALICALORAWANALYZERPEAKFINDER_H
 #define ALICALORAWANALYZERPEAKFINDER_H
 
+
 /**************************************************************************
- * This file is property of and copyright by the Experimental Nuclear     *
- * Physics Group, Dep. of Physics                                         *
- * University of Oslo, Norway, 2007                                       *
+ * This file is property of and copyright by                              *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009     *
+ *                                                                        *
+ * Primary Author: Per Thomas Hille  <perthomas.hille@yale.edu>           *
  *                                                                        *
- * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
  * Contributors are mentioned in the code where appropriate.              *
- * Please report bugs to perthi@fys.uio.no                                *
+ * Please report bugs to p.t.hille@fys.uio.no                             *
  *                                                                        *
  * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
@@ -19,6 +20,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+
 // The Peak-Finder algorithm
 // The amplitude is extracted  as a
 // weighted sum of the samples using the 
@@ -33,6 +35,7 @@
 
 class AliCaloBunchInfo;
 
+
 class  AliCaloRawAnalyzerPeakFinder : public AliCaloRawAnalyzer
 {
  public:
@@ -41,18 +44,22 @@ class  AliCaloRawAnalyzerPeakFinder : public AliCaloRawAnalyzer
   virtual AliCaloFitResults Evaluate( const vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 );
 
  private:
-  // AliCaloRawAnalyzerPeakFinder( const AliCaloRawAnalyzerPeakFinder   & );
-  // AliCaloRawAnalyzerPeakFinder   & operator = ( const  AliCaloRawAnalyzerPeakFinder  & );
+  AliCaloRawAnalyzerPeakFinder( const AliCaloRawAnalyzerPeakFinder   & );
+  AliCaloRawAnalyzerPeakFinder   & operator = ( const  AliCaloRawAnalyzerPeakFinder  & );
 
   void LoadVectors();
   double *fPFAmpVectors[MAXSTART][SAMPLERANGE]; // Vectors for Amplitude extraction 
   double *fPFTofVectors[MAXSTART][SAMPLERANGE]; // Vectors for TOF extraction
-  double fTof; 
-  double fAmp;
-  double fAmpA[3];
+
+  //  double fTof; 
+  //  double fAmp;
+
+  double fAmpA[3]; // The  amplitude of the signal (eveluate 3 times using 3 differtnt phase shifts of the input samples )
   // double fAmp2;
   // double fAmp3;
 
+  ClassDef( AliCaloRawAnalyzerPeakFinder, 1 )
+
 };
 
 #endif
index e4312e7..7a764a0 100644 (file)
@@ -14,9 +14,12 @@ AliCaloRawAnalyzer.cxx \
 AliCaloRawAnalyzerCrude.cxx \
 AliCaloRawAnalyzerLMS.cxx \
 AliCaloRawAnalyzerPeakFinder.cxx \
+AliCaloRawAnalyzerNN.cxx \
+AliCaloRawAnalyzerFastFit.cxx \
 AliCaloBunchInfo.cxx \
 AliCaloFitResults.cxx 
 
+
 HDRS= $(SRCS:.cxx=.h) 
 
 CINTHDRS:= $(HDRS) AliEMCALGeometry.h AliEMCALGeoUtils.h