[u/mrichter/AliRoot.git] / EMCAL / AliCaloRawAnalyzerNN.cxx

/**************************************************************************
 * 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
{

}
*/
Commit	Line	Data
e37e3c84	1	/**************************************************************************
	2	* This file is property of and copyright by the Experimental Nuclear *
	3	* Physics Group, Dep. of Physics *
	4	* University of Oslo, Norway, 2007 *
	5	* *
	6	* Author: Per Thomas Hille <perthomas.hille@yale.edu> *
	7	* for the ALICE HLT Project. *
	8	* Contributors are mentioned in the code where appropriate. *
	9	* Please report bugs to perthi@fys.uio.no *
	10	* *
	11	* Permission to use, copy, modify and distribute this software and its *
	12	* documentation strictly for non-commercial purposes is hereby granted *
	13	* without fee, provided that the above copyright notice appears in all *
	14	* copies and that both the copyright notice and this permission notice *
	15	* appear in the supporting documentation. The authors make no claims *
	16	* about the suitability of this software for any purpose. It is *
	17	* provided "as is" without express or implied warranty. *
	18	**************************************************************************/
	19
	20	// Evaluation of peak position
	21	// and amplitude using Neural Networks (NN)
	22	// ------------------
	23	// ------------------
	24	// ------------------
	25
	26
	27	#include "AliCaloRawAnalyzerNN.h"
	28	#include "AliCaloNeuralFit.h"
	29	#include "AliCaloFitResults.h"
	30	#include "AliCaloBunchInfo.h"
	31
	32	#include <iostream>
	33
	34	using namespace std;
	35
	36	ClassImp( AliCaloRawAnalyzerNN )
	37
	38	AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network"), fNeuralNet(0)
	39	{
	40	// Comment
	41
	42	fNeuralNet = new AliCaloNeuralFit();
	43
	44	for(int i=0; i < 5 ; i++)
	45	{
	46	fNNInput[i] = 0;
	47	}
	48
	49	}
	50
	51
	52	AliCaloRawAnalyzerNN::~AliCaloRawAnalyzerNN()
	53	{
	54	delete fNeuralNet;
	55	}
	56
	57
	58	AliCaloFitResults
	59	AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector,
	60	const UInt_t altrocfg1, const UInt_t altrocfg2 )
	61	{
	62	// The eveluation of Peak position and amplitude using the Neural Network
	63	if( bunchvector.size() <= 0 )
	64	{
65	return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
66	}
67
68	short maxindex;
69	short maxamp;
70
71	int bindex = SelectBunch( bunchvector, &maxindex , &maxamp ) ;
72
73	if( bindex < 0 )
74	{
75	return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
76	}
77
78	int first = 0;
79	int last = 0;
80
81	Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( bindex ) ) , altrocfg1, altrocfg2, fReversed );
82
83	// SelectSubarray ( fReversed, bunchvector.at(bindex).GetLength(), &first, &last );
84
85	short maxrev = maxindex - bunchvector.at(bindex).GetStartBin();
86
87
88	SelectSubarray( fReversed, bunchvector.at(bindex).GetLength(), maxrev , &first, &last);
89
90	// cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " << maxindex << ", first = " << first << ", last = " << last << endl;
91	// cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " << maxrev << ", first = " << first << ", last = " << last << endl;
92
93	if(maxrev < 1000 )
94	{
95	if ( ( maxrev - first) < 2 && (last - maxrev ) < 2)
96	{
97	return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
98	}
99	else
100	{
101	/*
102	cout << __FILE__ << __LINE__ << "!!!!!!!!:\t" << fReversed[maxrev -2 ]<< "\t" <<
103	fReversed[ maxrev -1 ] << "\t" << fReversed[maxrev ] << "\t" <<
104	fReversed[ maxrev +1 ] << "\t" << fReversed[maxrev +2] << endl;
105	*/
106
107	for(int i=0; i < 5 ; i++)
108	{
109	fNNInput[i] = fReversed[maxrev-2 +i]/(maxamp -ped);
110	}
111
112
113
114	// double amp = fNeuralNet->Value( 0, fReversed[maxrev-2], fReversed[maxrev -1], fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
115	// double tof = fNeuralNet->Value( 1, fReversed[maxrev-2], fReversed[maxrev -1], fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
116
117	// double amp = fNeuralNet->Value( 0, fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp, fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
118	// double tof = fNeuralNet->Value( 1, fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp, fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
119
120	// 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));
121	// double tof = fNeuralNet->Value( 1, fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp, fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp);
122
123
124	// double amp = maxamp*fNeuralNet->Value( 0, fNNInput[0], fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
125	// double tof = (fNeuralNet->Value( 1, fNNInput[0], fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + maxrev )*256 ;
126
127	double amp = maxamp*fNeuralNet->Value( 0, fNNInput[4], fNNInput[3], fNNInput[2], fNNInput[1], fNNInput[0]);
128	double tof = (fNeuralNet->Value( 1, fNNInput[4], fNNInput[3], fNNInput[2], fNNInput[1], fNNInput[0]) + maxrev )*256 ;
129
130
131	// double tof = fNeuralNet->Value( 1, fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp, fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp);
132
133	return AliCaloFitResults( maxamp, ped , -1, amp , tof, -2, -3 );
134
135	}
136	}
137	return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
138	}
139
140	//amp = exportNN.Value(0,input[0],input[1],input[2],input[3],input[4])*(globMaxSig - pedEstimate);
141	//time = (exportNN.Value(1,input[0],input[1],input[2],input[3],input[4])+globMaxId) * fgTimeBins;
142
143
144
145	//SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxampindex - bunchvector.at(index).GetStartBin(), &first, &last);
146
147
148	/*
149	void
150	AliCaloRawAnalyzerNN::SelectSubarray( const Double_t fData, const int length, const short maxindex, int const first, int *const last ) const
151	{
152
153	}
154	*/