[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCNoiseMapComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        *
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* 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.                  *
//**************************************************************************

/** @file   AliHLTTPCNoiseMapComponent.cxx
    @author Kalliopi Kanaki
    @date   
    @brief  The TPC Noise Map component
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTTPCNoiseMapComponent.h"
#include "AliHLTTPCDigitReaderDecoder.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCDefinitions.h"

#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliHLTTPCNoiseMap.h"

#include "AliTPCCalPad.h"
#include "AliTPCROC.h"
#include "AliTPCCalROC.h"

#include <cstdlib>
#include <cerrno>
#include "TString.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TObjString.h"
#include <sys/time.h>
#include "TH2.h"
#include "TH3.h"

ClassImp(AliHLTTPCNoiseMapComponent) //ROOT macro for the implementation of ROOT specific class methods

AliHLTTPCNoiseMapComponent::AliHLTTPCNoiseMapComponent()
    :    
    fSpecification(0),
    fReadNoiseMap(0),
    fResetHistograms(0),
    fInitHist(kTRUE),    
    fCurrentRow(-99),
    fHistSignal(NULL),
    fHistSideAMaxSignal(NULL),
    fHistSideATotSignal(NULL),
    fHistSideAPadRMS(NULL),
    fHistSideCMaxSignal(NULL),
    fHistSideCTotSignal(NULL),
    fHistSideCPadRMS(NULL),
    fHistCDBMap(NULL)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCNoiseMapComponent::~AliHLTTPCNoiseMapComponent() { 
// see header file for class documentation

}

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTTPCNoiseMapComponent::GetComponentID() { 
// see header file for class documentation

  return "TPCNoiseMap";
}

void AliHLTTPCNoiseMapComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
// see header file for class documentation

  list.clear(); 
  list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
}

AliHLTComponentDataType AliHLTTPCNoiseMapComponent::GetOutputDataType() { 
// see header file for class documentation

  return kAliHLTDataTypeHistogram;
}

int AliHLTTPCNoiseMapComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
// see header file for class documentation

  tgtList.clear();
  tgtList.push_back(kAliHLTDataTypeHistogram);
  return tgtList.size();
}

void AliHLTTPCNoiseMapComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
// see header file for class documentation

  constBase=800000;
  inputMultiplier=0.0;
}

AliHLTComponent* AliHLTTPCNoiseMapComponent::Spawn() { 
// see header file for class documentation

  return new AliHLTTPCNoiseMapComponent();
}
	
int AliHLTTPCNoiseMapComponent::DoInit( int argc, const char** argv ) { 
// see header file for class documentation
 
  //Int_t i = 0;
  //Char_t* cpErr;
  
  int iResult=0;
  
  TString configuration="";
  TString argument="";
  for (int j=0; j<argc && iResult>=0; j++) {
    
    argument=argv[j];
    if (!configuration.IsNull()) configuration+=" ";
    configuration+=argument;    
  }
   
  if (!configuration.IsNull()) {
    iResult=Configure(configuration.Data());
  } else {
    //    iResult=Reconfigure(NULL, NULL);
  }

 
//   while ( i < argc ) {      
//     if (!strcmp( argv[i], "-read-noisemap")) {
//         fApplyNoiseMap = strtoul( argv[i+1], &cpErr ,0);
//             
//     if ( *cpErr ) {
//         HLTError("Cannot convert apply-noisemap specifier '%s'.", argv[i+1]);
//         return EINVAL;
//     }
//       i+=2;
//       continue;
//     }
//     
//     if (!strcmp( argv[i], "-reset-histograms")) {
//         fResetHistograms = strtoul( argv[i+1], &cpErr ,0);
//     
//     if ( *cpErr ) {
//         HLTError("Cannot convert reset-histograms specifier '%s'.", argv[i+1]);
//         return EINVAL;
//     }
//       i+=2;
//       continue;
//     }
//                    
//     Logging(kHLTLogError, "HLT::TPCNoiseMap::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
//     return EINVAL;
// 
//   } // end while
  
  if(fReadNoiseMap){
     AliHLTTPCNoiseMap *nm = AliHLTTPCNoiseMap::Instance();
     if(!nm) { 
         HLTWarning("AliHLTTPCNoiseMap instance not existent."); 
     }
     else {
         AliTPCCalPad *noisePad = nm->ReadNoiseMap(GetRunNo());
         if(noisePad) {
	    fHistCDBMap = noisePad->MakeHisto2D(1);
	    
	 }
     }
  }

//   if(fApplyNoiseMap){
//     //TFile *f = TFile::Open("/scratch/noiseComp/Run3398_4000_v0_s72.root");
//     TFile *f = TFile::Open("/home/kanaki/noiseComp/Run3398_4000_v0_s72.root");
//     AliCDBEntry *pEntry = (AliCDBEntry*)f->Get("AliCDBEntry"); 
//     noisePad = (AliTPCCalPad*)pEntry->GetObject();
//     //fHistCDBMap = noisePad->MakeHisto2D(1); //side C
//   }
   
//   HLTDebug("using AliHLTTPCDigitReaderDecoder");
//   pDigitReader = new AliHLTTPCDigitReaderDecoder(); // double-loop
//   pDigitReader = new AliHLTTPCDigitReaderPacked();
  
  return 0;

} // end DoInit()

int AliHLTTPCNoiseMapComponent::DoDeinit() { 
  // see header file for class documentation  

  if(fHistSideAMaxSignal) delete fHistSideAMaxSignal; fHistSideAMaxSignal = NULL;
  if(fHistSideATotSignal) delete fHistSideATotSignal; fHistSideATotSignal = NULL;
  if(fHistSideAPadRMS)    delete fHistSideAPadRMS;    fHistSideAPadRMS    = NULL;
  
  if(fHistSideCMaxSignal) delete fHistSideCMaxSignal; fHistSideCMaxSignal = NULL;
  if(fHistSideCTotSignal) delete fHistSideCTotSignal; fHistSideCTotSignal = NULL;
  if(fHistSideCPadRMS)	  delete fHistSideCPadRMS;    fHistSideCPadRMS    = NULL;
         
  return 0;
}

void AliHLTTPCNoiseMapComponent::InitializeHistograms(UInt_t minSlice, UInt_t maxSlice, UInt_t minPartition, UInt_t maxPartition){
  // see header file for class documentation
   
  Char_t name1[50], name2[50], name3[50];
 
  if(minSlice<18){
     sprintf(name1, "fHistSideAMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
     sprintf(name2, "fHistSideATotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
     sprintf(name3, "fHistSideAPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d",    minSlice, maxSlice, minPartition, maxPartition);
     fHistSideAMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
     fHistSideATotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
     fHistSideAPadRMS	 = new TH2F(name3,name3,250,-250,250,250,-250,250);
     fHistSideAMaxSignal->SetXTitle("x [cm]");
     fHistSideATotSignal->SetXTitle("x [cm]");
     fHistSideAPadRMS->SetXTitle("x [cm]");	
     fHistSideAMaxSignal->SetYTitle("y [cm]");
     fHistSideATotSignal->SetYTitle("y [cm]");
     fHistSideAPadRMS->SetYTitle("y [cm]");	

  } else {
     sprintf(name1, "fHistSideCMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
     sprintf(name2, "fHistSideCTotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
     sprintf(name3, "fHistSideCPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d",    minSlice, maxSlice, minPartition, maxPartition);  
     fHistSideCMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
     fHistSideCTotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
     fHistSideCPadRMS	 = new TH2F(name3,name3,250,-250,250,250,-250,250);
     fHistSideCMaxSignal->SetXTitle("x [cm]");
     fHistSideCTotSignal->SetXTitle("x [cm]");
     fHistSideCPadRMS->SetXTitle("x [cm]");     
     fHistSideCMaxSignal->SetYTitle("y [cm]");
     fHistSideCTotSignal->SetYTitle("y [cm]");
     fHistSideCPadRMS->SetYTitle("y [cm]");	
}
    
  fInitHist=kFALSE;
  
}

int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/){
  // see header file for class documentation
 
 
  if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
  //HLTInfo("--- Entering DoEvent() in TPCNoiseMap ---");
   
  const AliHLTComponentBlockData *iter = NULL;

  Float_t xyz[3]; 
  Int_t thissector, thisrow;
    
  /*if(fInitHist==kFALSE) {
     fHistSideAMaxSignal->Reset();
     fHistSideCMaxSignal->Reset();  
  }*/

  
  for(iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
      
//     HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
// 	    evtData.fEventID, evtData.fEventID,
// 	    DataType2Text(iter->fDataType).c_str(), 
// 	    DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
// 
//     if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){
//       HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!", 
// 		 DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
// 		 DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str());
//     }      
     
    if (iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC)) continue;
      
    UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter); 
    UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
    UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(*iter); 
    UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
    
    if(fInitHist==kTRUE) InitializeHistograms(minSlice, maxSlice, minPartition, maxPartition);    
    fSpecification = iter->fSpecification;
     
    AliHLTTPCDigitReader *pDigitReader = new AliHLTTPCDigitReaderDecoder;

    pDigitReader->InitBlock(iter->fPtr,iter->fSize,minPartition,minSlice);
    if(!pDigitReader) break;
                  
    //  while(pDigitReader->Next()){ 

    Float_t maxSignal     = 0.;
    Float_t totalSignal   = 0.;
    Float_t squaredSignal = 0.;
    Float_t rms = 0.; 
    
    while(pDigitReader->NextChannel()) { // pad loop 
      
      fCurrentRow  = pDigitReader->GetRow();  
      fCurrentRow += pDigitReader->GetRowOffset();      

      AliHLTTPCTransform::Slice2Sector(minSlice,fCurrentRow,thissector,thisrow);
      AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
            
      if(minSlice>17) xyz[1] = (-1.0)*xyz[1];
      
      AliHLTTPCTransform::Local2Global(xyz,minSlice);
      // temporarily the transformation Raw2Global will be broken down to 2 steps,
      // as there is a correction necessary at the y coordinate of the local xyz.
      
      //AliHLTTPCTransform::Raw2Global(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
      // transformation from pad-row coordinates to global ones
      // time info is not taken into account
      
      //       AliTPCCalROC *calRoc = noisePad->GetCalROC(thissector);
      //       calRoc->GetValue(thisrow,pDigitReader->GetPad());
      
      while(pDigitReader->NextBunch()) {
    
	const UInt_t *bunchData = pDigitReader->GetSignals();
      	//Int_t time = pDigitReader->GetTime();
     
	for(Int_t i=0;i<pDigitReader->GetBunchSize();i++){
          
	  if((Float_t)(bunchData[i])>maxSignal){ maxSignal = (Float_t)(bunchData[i]); }
	  totalSignal   += (Float_t)bunchData[i];
	  squaredSignal += (Float_t)bunchData[i]*(Float_t)bunchData[i];
	  //fHistSignal->Fill(time+i, bunchData[i]);
	} // end for loop

	rms = TMath::Sqrt(squaredSignal/pDigitReader->GetBunchSize());
            
      } // end of inner while loop           
     
     
      if(minSlice<18){
	if(maxSignal>0)   fHistSideAMaxSignal->Fill(xyz[0],xyz[1],maxSignal);	  
	if(totalSignal>0) fHistSideATotSignal->Fill(xyz[0],xyz[1],totalSignal);     
	if(rms>0)	  fHistSideAPadRMS->Fill(xyz[0],xyz[1],rms);
      } else if(minSlice>17){
	if(maxSignal>0)	  fHistSideCMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
	if(totalSignal>0) fHistSideCTotSignal->Fill(xyz[0],xyz[1],totalSignal);	
	if(rms>0)	  fHistSideCPadRMS->Fill(xyz[0],xyz[1],rms);
      } else continue;
      
      maxSignal     = 0.;
      totalSignal   = 0.;
      squaredSignal = 0.;
      rms = 0.; 
    } // end of while loop over pads
    
    pDigitReader->Reset();
    delete pDigitReader;
  } // end of for loop over data blocks
  
  //HLTImportant("fHistSideAMaxSignal entries at the end of event: %d", fHistSideAMaxSignal->GetEntries());
  
  if(fResetHistograms) ResetHistograms(); fResetHistograms = kFALSE;
  MakeHistosPublic();
 
  return 0;
} // end DoEvent()


void AliHLTTPCNoiseMapComponent::MakeHistosPublic() {
// see header file for class documentation
 
//   TFile *outputfile = new TFile("test.root","RECREATE");
//   fHistSignal->Write();
//   outputfile->Save();
//   outputfile->Close();

  TObjArray histos;
  histos.Add(fHistSideAMaxSignal);
  histos.Add(fHistSideATotSignal);
  histos.Add(fHistSideAPadRMS);
  
  histos.Add(fHistSideCMaxSignal);
  histos.Add(fHistSideCTotSignal);
  histos.Add(fHistSideCPadRMS);
  
  histos.Add(fHistCDBMap);
  //histos.Add(fHistSignal);
  
  TIter iterator(&histos);
  while(TObject *pObj=iterator.Next()){ PushBack(pObj, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, fSpecification); }
    
  //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);    
}

void AliHLTTPCNoiseMapComponent::ResetHistograms(){
// see header file for class documentation

  if(fHistSideAMaxSignal) fHistSideAMaxSignal->Reset();
  if(fHistSideATotSignal) fHistSideATotSignal->Reset();
  if(fHistSideAPadRMS)    fHistSideAPadRMS->Reset();
 
  if(fHistSideCMaxSignal) fHistSideCMaxSignal->Reset();
  if(fHistSideCTotSignal) fHistSideCTotSignal->Reset();
  if(fHistSideCPadRMS)	  fHistSideCPadRMS->Reset();
}

int AliHLTTPCNoiseMapComponent::Configure(const char* arguments) { 
// see header file for class documentation
  
  int iResult=0;
  if (!arguments) return iResult;
  HLTInfo("parsing configuration string \'%s\'", arguments);

  TString allArgs=arguments;
  TString argument;
  int bMissingParam=0;

  TObjArray* pTokens=allArgs.Tokenize(" ");
  if (pTokens) {
    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
      argument=((TObjString*)pTokens->At(i))->GetString();
      if (argument.IsNull()) continue;
     
      if (argument.CompareTo("-read-noisemap")==0) {
	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	fReadNoiseMap = kTRUE;
	HLTInfo("got \'-read-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	
      } 
      else if(argument.CompareTo("-reset-histograms")==0){
	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	fResetHistograms = kTRUE;
	HLTInfo("got \'-reset-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());	
      } 
      else {
	HLTError("unknown argument %s", argument.Data());
	iResult=-EINVAL;
	break;
      }
    } // end for
  
    delete pTokens;
  
  } // end if pTokens
  
  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }
  return iResult;  
}

int AliHLTTPCNoiseMapComponent::Reconfigure(const char* cdbEntry, const char* chainId) { 
// see header file for class documentation
  
  int iResult = 0;
  const char* path = "HLT/ConfigTPC/TPCNoiseMapComponent";
  const char* defaultNotify = "";
  if(cdbEntry){
      path          = cdbEntry;
      defaultNotify = "(manual operator entry)";
  }
  
  if(path){          
     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>" );
     
     AliCDBPath argumentPath(path);
     AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
        
     if(stor){
        Int_t version    = stor->GetLatestVersion(path, GetRunNo());
        Int_t subVersion = stor->GetLatestSubVersion(path, GetRunNo(), version);
        AliCDBEntry *pEntry = stor->Get(argumentPath,GetRunNo(), version, subVersion);

        if(pEntry){
            TObjString* pString = dynamic_cast<TObjString*>(pEntry->GetObject());
            if(pString){
               HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
               iResult = Configure(pString->GetString().Data());
            } // if pString is valid
	    else {
               HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
            }
        } // if pEntry is valid
	else {
           HLTError("cannot fetch object \"%s\" from CDB", path);
        }
     } // end if stor is valid
  } // end if path is valid
  
  return iResult;


}
Commit	Line	Data
6d17f6d5	1	// $Id$
	2
	3	//**************************************************************************
	4	//* This file is property of and copyright by the ALICE HLT Project *
	5	//* ALICE Experiment at CERN, All rights reserved. *
	6	//* *
	7	//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no> *
	8	//* for The ALICE HLT Project. *
	9	//* *
	10	//* Permission to use, copy, modify and distribute this software and its *
	11	//* documentation strictly for non-commercial purposes is hereby granted *
	12	//* without fee, provided that the above copyright notice appears in all *
	13	//* copies and that both the copyright notice and this permission notice *
	14	//* appear in the supporting documentation. The authors make no claims *
	15	//* about the suitability of this software for any purpose. It is *
	16	//* provided "as is" without express or implied warranty. *
	17	//**************************************************************************
c12197a2	18
	19	/** @file AliHLTTPCNoiseMapComponent.cxx
	20	@author Kalliopi Kanaki
	21	@date
	22	@brief The TPC Noise Map component
	23	*/
	24
c12197a2	25	#if __GNUC__>= 3
	26	using namespace std;
	27	#endif
21f63108	28
c12197a2	29	#include "AliHLTTPCNoiseMapComponent.h"
c12197a2	30	#include "AliHLTTPCDigitReaderDecoder.h"
c12197a2	31	#include "AliHLTTPCTransform.h"
c12197a2	32	#include "AliHLTTPCDefinitions.h"
21f63108	33
c12197a2	34	#include "AliCDBEntry.h"
c12197a2	35	#include "AliCDBManager.h"
b1d702f1	36	#include "AliCDBStorage.h"
3a3550fa	37	#include "AliHLTTPCNoiseMap.h"
21f63108	38
deeb9f12	39	#include "AliTPCCalPad.h"
21f63108	40	#include "AliTPCROC.h"
	41	#include "AliTPCCalROC.h"
	42
c12197a2	43	#include <cstdlib>
	44	#include <cerrno>
	45	#include "TString.h"
	46	#include "TFile.h"
	47	#include "TObjArray.h"
	48	#include "TObjString.h"
	49	#include <sys/time.h>
6d17f6d5	50	#include "TH2.h"
163d018f	51	#include "TH3.h"
c12197a2	52
c12197a2	53	ClassImp(AliHLTTPCNoiseMapComponent) //ROOT macro for the implementation of ROOT specific class methods
	54
	55	AliHLTTPCNoiseMapComponent::AliHLTTPCNoiseMapComponent()
6d17f6d5	56	:
deeb9f12	57	fSpecification(0),
3f0fd8f1	58	fReadNoiseMap(0),
21f63108	59	fResetHistograms(0),
3f0fd8f1	60	fInitHist(kTRUE),
21f63108	61	fCurrentRow(-99),
3a3550fa	62	fHistSignal(NULL),
3f0fd8f1	63	fHistSideAMaxSignal(NULL),
	64	fHistSideATotSignal(NULL),
	65	fHistSideAPadRMS(NULL),
	66	fHistSideCMaxSignal(NULL),
	67	fHistSideCTotSignal(NULL),
	68	fHistSideCPadRMS(NULL),
	69	fHistCDBMap(NULL)
c12197a2	70	{
	71	// see header file for class documentation
	72	// or
	73	// refer to README to build package
	74	// or
	75	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	76	}
	77
6d17f6d5	78	AliHLTTPCNoiseMapComponent::~AliHLTTPCNoiseMapComponent() {
6d17f6d5	79	// see header file for class documentation
c12197a2	80
	81	}
	82
c12197a2	83	// Public functions to implement AliHLTComponent's interface.
	84	// These functions are required for the registration process
	85
6d17f6d5	86	const char* AliHLTTPCNoiseMapComponent::GetComponentID() {
6d17f6d5	87	// see header file for class documentation
c12197a2	88
	89	return "TPCNoiseMap";
	90	}
	91
6d17f6d5	92	void AliHLTTPCNoiseMapComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
6d17f6d5	93	// see header file for class documentation
c12197a2	94
	95	list.clear();
	96	list.push_back( kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC );
	97	}
	98
6d17f6d5	99	AliHLTComponentDataType AliHLTTPCNoiseMapComponent::GetOutputDataType() {
6d17f6d5	100	// see header file for class documentation
c12197a2	101
deeb9f12	102	return kAliHLTDataTypeHistogram;
c12197a2	103	}
c12197a2	104
6d17f6d5	105	int AliHLTTPCNoiseMapComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
6d17f6d5	106	// see header file for class documentation
c12197a2	107
c12197a2	108	tgtList.clear();
deeb9f12	109	tgtList.push_back(kAliHLTDataTypeHistogram);
c12197a2	110	return tgtList.size();
	111	}
	112
6d17f6d5	113	void AliHLTTPCNoiseMapComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
6d17f6d5	114	// see header file for class documentation
c12197a2	115
0e588049	116	constBase=800000;
0e588049	117	inputMultiplier=0.0;
c12197a2	118	}
c12197a2	119
6d17f6d5	120	AliHLTComponent* AliHLTTPCNoiseMapComponent::Spawn() {
6d17f6d5	121	// see header file for class documentation
c12197a2	122
	123	return new AliHLTTPCNoiseMapComponent();
	124	}
	125
6d17f6d5	126	int AliHLTTPCNoiseMapComponent::DoInit( int argc, const char** argv ) {
6d17f6d5	127	// see header file for class documentation
21f63108	128
3f0fd8f1	129	//Int_t i = 0;
3f0fd8f1	130	//Char_t* cpErr;
c12197a2	131
	132	int iResult=0;
	133
	134	TString configuration="";
	135	TString argument="";
0e588049	136	for (int j=0; j<argc && iResult>=0; j++) {
c12197a2	137
0e588049	138	argument=argv[j];
c12197a2	139	if (!configuration.IsNull()) configuration+=" ";
21f63108	140	configuration+=argument;
c12197a2	141	}
	142
	143	if (!configuration.IsNull()) {
	144	iResult=Configure(configuration.Data());
	145	} else {
3f0fd8f1	146	// iResult=Reconfigure(NULL, NULL);
c12197a2	147	}
	148
	149
3f0fd8f1	150	// while ( i < argc ) {
	151	// if (!strcmp( argv[i], "-read-noisemap")) {
	152	// fApplyNoiseMap = strtoul( argv[i+1], &cpErr ,0);
	153	//
	154	// if ( *cpErr ) {
	155	// HLTError("Cannot convert apply-noisemap specifier '%s'.", argv[i+1]);
	156	// return EINVAL;
	157	// }
	158	// i+=2;
	159	// continue;
	160	// }
	161	//
	162	// if (!strcmp( argv[i], "-reset-histograms")) {
	163	// fResetHistograms = strtoul( argv[i+1], &cpErr ,0);
	164	//
	165	// if ( *cpErr ) {
	166	// HLTError("Cannot convert reset-histograms specifier '%s'.", argv[i+1]);
	167	// return EINVAL;
	168	// }
	169	// i+=2;
	170	// continue;
	171	// }
	172	//
	173	// Logging(kHLTLogError, "HLT::TPCNoiseMap::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	174	// return EINVAL;
	175	//
	176	// } // end while
c12197a2	177
3f0fd8f1	178	if(fReadNoiseMap){
3a3550fa	179	AliHLTTPCNoiseMap *nm = AliHLTTPCNoiseMap::Instance();
b1d702f1	180	if(!nm) {
	181	HLTWarning("AliHLTTPCNoiseMap instance not existent.");
	182	}
	183	else {
	184	AliTPCCalPad *noisePad = nm->ReadNoiseMap(GetRunNo());
	185	if(noisePad) {
	186	fHistCDBMap = noisePad->MakeHisto2D(1);
	187
	188	}
	189	}
3a3550fa	190	}
c12197a2	191
21f63108	192	// if(fApplyNoiseMap){
	193	// //TFile *f = TFile::Open("/scratch/noiseComp/Run3398_4000_v0_s72.root");
	194	// TFile *f = TFile::Open("/home/kanaki/noiseComp/Run3398_4000_v0_s72.root");
	195	// AliCDBEntry pEntry = (AliCDBEntry)f->Get("AliCDBEntry");
	196	// noisePad = (AliTPCCalPad*)pEntry->GetObject();
	197	// //fHistCDBMap = noisePad->MakeHisto2D(1); //side C
	198	// }
	199
21f63108	200	// HLTDebug("using AliHLTTPCDigitReaderDecoder");
	201	// pDigitReader = new AliHLTTPCDigitReaderDecoder(); // double-loop
	202	// pDigitReader = new AliHLTTPCDigitReaderPacked();
	203
c12197a2	204	return 0;
21f63108	205
c12197a2	206	} // end DoInit()
c12197a2	207
6d17f6d5	208	int AliHLTTPCNoiseMapComponent::DoDeinit() {
a912b63b	209	// see header file for class documentation
b1d702f1	210
3f0fd8f1	211	if(fHistSideAMaxSignal) delete fHistSideAMaxSignal; fHistSideAMaxSignal = NULL;
	212	if(fHistSideATotSignal) delete fHistSideATotSignal; fHistSideATotSignal = NULL;
	213	if(fHistSideAPadRMS) delete fHistSideAPadRMS; fHistSideAPadRMS = NULL;
	214
	215	if(fHistSideCMaxSignal) delete fHistSideCMaxSignal; fHistSideCMaxSignal = NULL;
	216	if(fHistSideCTotSignal) delete fHistSideCTotSignal; fHistSideCTotSignal = NULL;
	217	if(fHistSideCPadRMS) delete fHistSideCPadRMS; fHistSideCPadRMS = NULL;
	218
b1d702f1	219	return 0;
c12197a2	220	}
c12197a2	221
3f0fd8f1	222	void AliHLTTPCNoiseMapComponent::InitializeHistograms(UInt_t minSlice, UInt_t maxSlice, UInt_t minPartition, UInt_t maxPartition){
	223	// see header file for class documentation
	224
	225	Char_t name1[50], name2[50], name3[50];
	226
	227	if(minSlice<18){
	228	sprintf(name1, "fHistSideAMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	229	sprintf(name2, "fHistSideATotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	230	sprintf(name3, "fHistSideAPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	231	fHistSideAMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
	232	fHistSideATotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
	233	fHistSideAPadRMS = new TH2F(name3,name3,250,-250,250,250,-250,250);
b69ccd54	234	fHistSideAMaxSignal->SetXTitle("x [cm]");
	235	fHistSideATotSignal->SetXTitle("x [cm]");
	236	fHistSideAPadRMS->SetXTitle("x [cm]");
	237	fHistSideAMaxSignal->SetYTitle("y [cm]");
	238	fHistSideATotSignal->SetYTitle("y [cm]");
	239	fHistSideAPadRMS->SetYTitle("y [cm]");
3f0fd8f1	240
	241	} else {
	242	sprintf(name1, "fHistSideCMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	243	sprintf(name2, "fHistSideCTotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	244	sprintf(name3, "fHistSideCPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	245	fHistSideCMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
	246	fHistSideCTotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
	247	fHistSideCPadRMS = new TH2F(name3,name3,250,-250,250,250,-250,250);
b69ccd54	248	fHistSideCMaxSignal->SetXTitle("x [cm]");
	249	fHistSideCTotSignal->SetXTitle("x [cm]");
	250	fHistSideCPadRMS->SetXTitle("x [cm]");
	251	fHistSideCMaxSignal->SetYTitle("y [cm]");
	252	fHistSideCTotSignal->SetYTitle("y [cm]");
	253	fHistSideCPadRMS->SetYTitle("y [cm]");
	254	}
3f0fd8f1	255
	256	fInitHist=kFALSE;
	257
	258	}
	259
bb7774d6	260	int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/){
a912b63b	261	// see header file for class documentation
c12197a2	262
21f63108	263
deeb9f12	264	if(GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
3f0fd8f1	265	//HLTInfo("--- Entering DoEvent() in TPCNoiseMap ---");
b1d702f1	266
21f63108	267	const AliHLTComponentBlockData *iter = NULL;
21f63108	268
c12197a2	269	Float_t xyz[3];
c12197a2	270	Int_t thissector, thisrow;
163d018f	271
b69ccd54	272	/*if(fInitHist==kFALSE) {
	273	fHistSideAMaxSignal->Reset();
	274	fHistSideCMaxSignal->Reset();
	275	}*/
	276
	277
21f63108	278	for(iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
21f63108	279
3f0fd8f1	280	// HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	281	// evtData.fEventID, evtData.fEventID,
	282	// DataType2Text(iter->fDataType).c_str(),
	283	// DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	284	//
	285	// if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){
	286	// HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
	287	// DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
	288	// DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	289	// }
deeb9f12	290
a912b63b	291	if (iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC)) continue;
c12197a2	292
3f0fd8f1	293	UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
	294	UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
	295	UInt_t maxSlice = AliHLTTPCDefinitions::GetMaxSliceNr(*iter);
	296	UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
	297
	298	if(fInitHist==kTRUE) InitializeHistograms(minSlice, maxSlice, minPartition, maxPartition);
a912b63b	299	fSpecification = iter->fSpecification;
deeb9f12	300
a912b63b	301	AliHLTTPCDigitReader *pDigitReader = new AliHLTTPCDigitReaderDecoder;
deeb9f12	302
3f0fd8f1	303	pDigitReader->InitBlock(iter->fPtr,iter->fSize,minPartition,minSlice);
a912b63b	304	if(!pDigitReader) break;
3f0fd8f1	305
a912b63b	306	// while(pDigitReader->Next()){
a912b63b	307
a912b63b	308	Float_t maxSignal = 0.;
	309	Float_t totalSignal = 0.;
	310	Float_t squaredSignal = 0.;
	311	Float_t rms = 0.;
	312
3f0fd8f1	313	while(pDigitReader->NextChannel()) { // pad loop
c12197a2	314
deeb9f12	315	fCurrentRow = pDigitReader->GetRow();
b69ccd54	316	fCurrentRow += pDigitReader->GetRowOffset();
6d17f6d5	317
3f0fd8f1	318	AliHLTTPCTransform::Slice2Sector(minSlice,fCurrentRow,thissector,thisrow);
3a3550fa	319	AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
3f0fd8f1	320
3f0fd8f1	321	if(minSlice>17) xyz[1] = (-1.0)*xyz[1];
3a3550fa	322
3f0fd8f1	323	AliHLTTPCTransform::Local2Global(xyz,minSlice);
3a3550fa	324	// temporarily the transformation Raw2Global will be broken down to 2 steps,
	325	// as there is a correction necessary at the y coordinate of the local xyz.
	326
21f63108	327	//AliHLTTPCTransform::Raw2Global(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
3a3550fa	328	// transformation from pad-row coordinates to global ones
3a3550fa	329	// time info is not taken into account
21f63108	330
a912b63b	331	// AliTPCCalROC *calRoc = noisePad->GetCalROC(thissector);
	332	// calRoc->GetValue(thisrow,pDigitReader->GetPad());
	333
3f0fd8f1	334	while(pDigitReader->NextBunch()) {
deeb9f12	335
a912b63b	336	const UInt_t *bunchData = pDigitReader->GetSignals();
3f0fd8f1	337	//Int_t time = pDigitReader->GetTime();
163d018f	338
a912b63b	339	for(Int_t i=0;i<pDigitReader->GetBunchSize();i++){
deeb9f12	340
3a3550fa	341	if((Float_t)(bunchData[i])>maxSignal){ maxSignal = (Float_t)(bunchData[i]); }
3f0fd8f1	342	totalSignal += (Float_t)bunchData[i];
163d018f	343	squaredSignal += (Float_t)bunchData[i]*(Float_t)bunchData[i];
163d018f	344	//fHistSignal->Fill(time+i, bunchData[i]);
3f0fd8f1	345	} // end for loop
3f0fd8f1	346
a912b63b	347	rms = TMath::Sqrt(squaredSignal/pDigitReader->GetBunchSize());
163d018f	348
3f0fd8f1	349	} // end of inner while loop
163d018f	350
a912b63b	351
3f0fd8f1	352	if(minSlice<18){
b69ccd54	353	if(maxSignal>0) fHistSideAMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
	354	if(totalSignal>0) fHistSideATotSignal->Fill(xyz[0],xyz[1],totalSignal);
	355	if(rms>0) fHistSideAPadRMS->Fill(xyz[0],xyz[1],rms);
3f0fd8f1	356	} else if(minSlice>17){
b69ccd54	357	if(maxSignal>0) fHistSideCMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
	358	if(totalSignal>0) fHistSideCTotSignal->Fill(xyz[0],xyz[1],totalSignal);
	359	if(rms>0) fHistSideCPadRMS->Fill(xyz[0],xyz[1],rms);
3f0fd8f1	360	} else continue;
a912b63b	361
3f0fd8f1	362	maxSignal = 0.;
	363	totalSignal = 0.;
	364	squaredSignal = 0.;
	365	rms = 0.;
	366	} // end of while loop over pads
a912b63b	367
a912b63b	368	pDigitReader->Reset();
a912b63b	369	delete pDigitReader;
deeb9f12	370	} // end of for loop over data blocks
b69ccd54	371
	372	//HLTImportant("fHistSideAMaxSignal entries at the end of event: %d", fHistSideAMaxSignal->GetEntries());
	373
3f0fd8f1	374	if(fResetHistograms) ResetHistograms(); fResetHistograms = kFALSE;
deeb9f12	375	MakeHistosPublic();
3f0fd8f1	376
deeb9f12	377	return 0;
c12197a2	378	} // end DoEvent()
c12197a2	379
3a3550fa	380
deeb9f12	381	void AliHLTTPCNoiseMapComponent::MakeHistosPublic() {
6d17f6d5	382	// see header file for class documentation
b1d702f1	383
deeb9f12	384	// TFile *outputfile = new TFile("test.root","RECREATE");
55f2c86a	385	// fHistSignal->Write();
deeb9f12	386	// outputfile->Save();
deeb9f12	387	// outputfile->Close();
3a3550fa	388
deeb9f12	389	TObjArray histos;
3f0fd8f1	390	histos.Add(fHistSideAMaxSignal);
	391	histos.Add(fHistSideATotSignal);
	392	histos.Add(fHistSideAPadRMS);
	393
	394	histos.Add(fHistSideCMaxSignal);
	395	histos.Add(fHistSideCTotSignal);
	396	histos.Add(fHistSideCPadRMS);
	397
3a3550fa	398	histos.Add(fHistCDBMap);
163d018f	399	//histos.Add(fHistSignal);
21f63108	400
21f63108	401	TIter iterator(&histos);
3a3550fa	402	while(TObject *pObj=iterator.Next()){ PushBack(pObj, kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC, fSpecification); }
21f63108	403
21f63108	404	//PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);
c12197a2	405	}
c12197a2	406
21f63108	407	void AliHLTTPCNoiseMapComponent::ResetHistograms(){
	408	// see header file for class documentation
	409
3f0fd8f1	410	if(fHistSideAMaxSignal) fHistSideAMaxSignal->Reset();
	411	if(fHistSideATotSignal) fHistSideATotSignal->Reset();
	412	if(fHistSideAPadRMS) fHistSideAPadRMS->Reset();
	413
	414	if(fHistSideCMaxSignal) fHistSideCMaxSignal->Reset();
	415	if(fHistSideCTotSignal) fHistSideCTotSignal->Reset();
	416	if(fHistSideCPadRMS) fHistSideCPadRMS->Reset();
21f63108	417	}
21f63108	418
6d17f6d5	419	int AliHLTTPCNoiseMapComponent::Configure(const char* arguments) {
6d17f6d5	420	// see header file for class documentation
c12197a2	421
	422	int iResult=0;
	423	if (!arguments) return iResult;
	424	HLTInfo("parsing configuration string \'%s\'", arguments);
	425
	426	TString allArgs=arguments;
	427	TString argument;
	428	int bMissingParam=0;
	429
	430	TObjArray* pTokens=allArgs.Tokenize(" ");
	431	if (pTokens) {
	432	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	433	argument=((TObjString*)pTokens->At(i))->GetString();
	434	if (argument.IsNull()) continue;
	435
3f0fd8f1	436	if (argument.CompareTo("-read-noisemap")==0) {
	437	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	438	fReadNoiseMap = kTRUE;
	439	HLTInfo("got \'-read-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
deeb9f12	440
deeb9f12	441	}
3a3550fa	442	else if(argument.CompareTo("-reset-histograms")==0){
3f0fd8f1	443	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	444	fResetHistograms = kTRUE;
	445	HLTInfo("got \'-reset-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
c12197a2	446	}
	447	else {
	448	HLTError("unknown argument %s", argument.Data());
	449	iResult=-EINVAL;
	450	break;
	451	}
deeb9f12	452	} // end for
deeb9f12	453
c12197a2	454	delete pTokens;
deeb9f12	455
	456	} // end if pTokens
	457
c12197a2	458	if (bMissingParam) {
	459	HLTError("missing parameter for argument %s", argument.Data());
	460	iResult=-EINVAL;
	461	}
21f63108	462	return iResult;
c12197a2	463	}
c12197a2	464
6d17f6d5	465	int AliHLTTPCNoiseMapComponent::Reconfigure(const char* cdbEntry, const char* chainId) {
6d17f6d5	466	// see header file for class documentation
3f0fd8f1	467
	468	int iResult = 0;
	469	const char* path = "HLT/ConfigTPC/TPCNoiseMapComponent";
	470	const char* defaultNotify = "";
b1d702f1	471	if(cdbEntry){
	472	path = cdbEntry;
	473	defaultNotify = "(manual operator entry)";
c12197a2	474	}
deeb9f12	475
b1d702f1	476	if(path){
	477	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>" );
	478
	479	AliCDBPath argumentPath(path);
	480	AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
	481
	482	if(stor){
	483	Int_t version = stor->GetLatestVersion(path, GetRunNo());
	484	Int_t subVersion = stor->GetLatestSubVersion(path, GetRunNo(), version);
	485	AliCDBEntry *pEntry = stor->Get(argumentPath,GetRunNo(), version, subVersion);
	486
	487	if(pEntry){
	488	TObjString* pString = dynamic_cast<TObjString*>(pEntry->GetObject());
	489	if(pString){
	490	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	491	iResult = Configure(pString->GetString().Data());
	492	} // if pString is valid
	493	else {
	494	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	495	}
	496	} // if pEntry is valid
	497	else {
	498	HLTError("cannot fetch object \"%s\" from CDB", path);
	499	}
3f0fd8f1	500	} // end if stor is valid
3f0fd8f1	501	} // end if path is valid
c12197a2	502
c12197a2	503	return iResult;
b1d702f1	504
b1d702f1	505
c12197a2	506	}