[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);

  } 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);
  }
    
  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;
    
  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];
      else continue;
      
      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
 
  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);
	234
	235	} else {
	236	sprintf(name1, "fHistSideCMaxSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	237	sprintf(name2, "fHistSideCTotSignal_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	238	sprintf(name3, "fHistSideCPadRMS_Slice_%.2d%.2d_Partition_%.2d%.2d", minSlice, maxSlice, minPartition, maxPartition);
	239	fHistSideCMaxSignal = new TH2F(name1,name1,250,-250,250,250,-250,250);
	240	fHistSideCTotSignal = new TH2F(name2,name2,250,-250,250,250,-250,250);
	241	fHistSideCPadRMS = new TH2F(name3,name3,250,-250,250,250,-250,250);
	242	}
	243
	244	fInitHist=kFALSE;
	245
	246	}
	247
bb7774d6	248	int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/){
a912b63b	249	// see header file for class documentation
c12197a2	250
21f63108	251
deeb9f12	252	if(GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
3f0fd8f1	253	//HLTInfo("--- Entering DoEvent() in TPCNoiseMap ---");
b1d702f1	254
21f63108	255	const AliHLTComponentBlockData *iter = NULL;
21f63108	256
c12197a2	257	Float_t xyz[3];
c12197a2	258	Int_t thissector, thisrow;
163d018f	259
21f63108	260	for(iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
21f63108	261
3f0fd8f1	262	// HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	263	// evtData.fEventID, evtData.fEventID,
	264	// DataType2Text(iter->fDataType).c_str(),
	265	// DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	266	//
	267	// if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){
	268	// HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!",
	269	// DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(),
	270	// DataType2Text(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC).c_str());
	271	// }
deeb9f12	272
a912b63b	273	if (iter->fDataType != (kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTPC)) continue;
c12197a2	274
3f0fd8f1	275	UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
	276	UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
	277	UInt_t maxSlice = AliHLTTPCDefinitions::GetMaxSliceNr(*iter);
	278	UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
	279
	280	if(fInitHist==kTRUE) InitializeHistograms(minSlice, maxSlice, minPartition, maxPartition);
a912b63b	281	fSpecification = iter->fSpecification;
deeb9f12	282
a912b63b	283	AliHLTTPCDigitReader *pDigitReader = new AliHLTTPCDigitReaderDecoder;
deeb9f12	284
3f0fd8f1	285	pDigitReader->InitBlock(iter->fPtr,iter->fSize,minPartition,minSlice);
a912b63b	286	if(!pDigitReader) break;
3f0fd8f1	287
a912b63b	288	// while(pDigitReader->Next()){
a912b63b	289
a912b63b	290	Float_t maxSignal = 0.;
	291	Float_t totalSignal = 0.;
	292	Float_t squaredSignal = 0.;
	293	Float_t rms = 0.;
	294
3f0fd8f1	295	while(pDigitReader->NextChannel()) { // pad loop
c12197a2	296
deeb9f12	297	fCurrentRow = pDigitReader->GetRow();
deeb9f12	298	fCurrentRow += pDigitReader->GetRowOffset();
3f0fd8f1	299
6d17f6d5	300
3f0fd8f1	301	AliHLTTPCTransform::Slice2Sector(minSlice,fCurrentRow,thissector,thisrow);
3a3550fa	302	AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
3f0fd8f1	303
3f0fd8f1	304	if(minSlice>17) xyz[1] = (-1.0)*xyz[1];
3a3550fa	305	else continue;
3a3550fa	306
3f0fd8f1	307	AliHLTTPCTransform::Local2Global(xyz,minSlice);
3a3550fa	308	// temporarily the transformation Raw2Global will be broken down to 2 steps,
	309	// as there is a correction necessary at the y coordinate of the local xyz.
	310
21f63108	311	//AliHLTTPCTransform::Raw2Global(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
3a3550fa	312	// transformation from pad-row coordinates to global ones
3a3550fa	313	// time info is not taken into account
21f63108	314
a912b63b	315	// AliTPCCalROC *calRoc = noisePad->GetCalROC(thissector);
	316	// calRoc->GetValue(thisrow,pDigitReader->GetPad());
	317
3f0fd8f1	318	while(pDigitReader->NextBunch()) {
deeb9f12	319
a912b63b	320	const UInt_t *bunchData = pDigitReader->GetSignals();
3f0fd8f1	321	//Int_t time = pDigitReader->GetTime();
163d018f	322
a912b63b	323	for(Int_t i=0;i<pDigitReader->GetBunchSize();i++){
deeb9f12	324
3a3550fa	325	if((Float_t)(bunchData[i])>maxSignal){ maxSignal = (Float_t)(bunchData[i]); }
3f0fd8f1	326	totalSignal += (Float_t)bunchData[i];
163d018f	327	squaredSignal += (Float_t)bunchData[i]*(Float_t)bunchData[i];
163d018f	328	//fHistSignal->Fill(time+i, bunchData[i]);
3f0fd8f1	329	} // end for loop
3f0fd8f1	330
a912b63b	331	rms = TMath::Sqrt(squaredSignal/pDigitReader->GetBunchSize());
163d018f	332
3f0fd8f1	333	} // end of inner while loop
163d018f	334
a912b63b	335
3f0fd8f1	336	if(minSlice<18){
	337	if(maxSignal>0)
	338	fHistSideAMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
	339	if(totalSignal>0)
	340	fHistSideATotSignal->Fill(xyz[0],xyz[1],totalSignal);
	341	if(rms>0)
	342	fHistSideAPadRMS->Fill(xyz[0],xyz[1],rms);
	343	} else if(minSlice>17){
	344	if(maxSignal>0)
	345	fHistSideCMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
	346	if(totalSignal>0)
	347	fHistSideCTotSignal->Fill(xyz[0],xyz[1],totalSignal);
	348	if(rms>0)
	349	fHistSideCPadRMS->Fill(xyz[0],xyz[1],rms);
	350	} else continue;
a912b63b	351
3f0fd8f1	352	maxSignal = 0.;
	353	totalSignal = 0.;
	354	squaredSignal = 0.;
	355	rms = 0.;
	356	} // end of while loop over pads
a912b63b	357
a912b63b	358	pDigitReader->Reset();
a912b63b	359	delete pDigitReader;
deeb9f12	360	} // end of for loop over data blocks
c12197a2	361
3f0fd8f1	362	if(fResetHistograms) ResetHistograms(); fResetHistograms = kFALSE;
deeb9f12	363	MakeHistosPublic();
3f0fd8f1	364
deeb9f12	365	return 0;
c12197a2	366	} // end DoEvent()
c12197a2	367
3a3550fa	368
deeb9f12	369	void AliHLTTPCNoiseMapComponent::MakeHistosPublic() {
6d17f6d5	370	// see header file for class documentation
b1d702f1	371
deeb9f12	372	// TFile *outputfile = new TFile("test.root","RECREATE");
55f2c86a	373	// fHistSignal->Write();
deeb9f12	374	// outputfile->Save();
deeb9f12	375	// outputfile->Close();
3a3550fa	376
deeb9f12	377	TObjArray histos;
3f0fd8f1	378	histos.Add(fHistSideAMaxSignal);
	379	histos.Add(fHistSideATotSignal);
	380	histos.Add(fHistSideAPadRMS);
	381
	382	histos.Add(fHistSideCMaxSignal);
	383	histos.Add(fHistSideCTotSignal);
	384	histos.Add(fHistSideCPadRMS);
	385
3a3550fa	386	histos.Add(fHistCDBMap);
163d018f	387	//histos.Add(fHistSignal);
21f63108	388
21f63108	389	TIter iterator(&histos);
3a3550fa	390	while(TObject *pObj=iterator.Next()){ PushBack(pObj, kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC, fSpecification); }
21f63108	391
21f63108	392	//PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);
c12197a2	393	}
c12197a2	394
21f63108	395	void AliHLTTPCNoiseMapComponent::ResetHistograms(){
	396	// see header file for class documentation
	397
3f0fd8f1	398	if(fHistSideAMaxSignal) fHistSideAMaxSignal->Reset();
	399	if(fHistSideATotSignal) fHistSideATotSignal->Reset();
	400	if(fHistSideAPadRMS) fHistSideAPadRMS->Reset();
	401
	402	if(fHistSideCMaxSignal) fHistSideCMaxSignal->Reset();
	403	if(fHistSideCTotSignal) fHistSideCTotSignal->Reset();
	404	if(fHistSideCPadRMS) fHistSideCPadRMS->Reset();
21f63108	405	}
21f63108	406
6d17f6d5	407	int AliHLTTPCNoiseMapComponent::Configure(const char* arguments) {
6d17f6d5	408	// see header file for class documentation
c12197a2	409
	410	int iResult=0;
	411	if (!arguments) return iResult;
	412	HLTInfo("parsing configuration string \'%s\'", arguments);
	413
	414	TString allArgs=arguments;
	415	TString argument;
	416	int bMissingParam=0;
	417
	418	TObjArray* pTokens=allArgs.Tokenize(" ");
	419	if (pTokens) {
	420	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	421	argument=((TObjString*)pTokens->At(i))->GetString();
	422	if (argument.IsNull()) continue;
	423
3f0fd8f1	424	if (argument.CompareTo("-read-noisemap")==0) {
	425	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	426	fReadNoiseMap = kTRUE;
	427	HLTInfo("got \'-read-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
deeb9f12	428
deeb9f12	429	}
3a3550fa	430	else if(argument.CompareTo("-reset-histograms")==0){
3f0fd8f1	431	//if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	432	fResetHistograms = kTRUE;
	433	HLTInfo("got \'-reset-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
c12197a2	434	}
	435	else {
	436	HLTError("unknown argument %s", argument.Data());
	437	iResult=-EINVAL;
	438	break;
	439	}
deeb9f12	440	} // end for
deeb9f12	441
c12197a2	442	delete pTokens;
deeb9f12	443
	444	} // end if pTokens
	445
c12197a2	446	if (bMissingParam) {
	447	HLTError("missing parameter for argument %s", argument.Data());
	448	iResult=-EINVAL;
	449	}
21f63108	450	return iResult;
c12197a2	451	}
c12197a2	452
6d17f6d5	453	int AliHLTTPCNoiseMapComponent::Reconfigure(const char* cdbEntry, const char* chainId) {
6d17f6d5	454	// see header file for class documentation
3f0fd8f1	455
	456	int iResult = 0;
	457	const char* path = "HLT/ConfigTPC/TPCNoiseMapComponent";
	458	const char* defaultNotify = "";
b1d702f1	459	if(cdbEntry){
	460	path = cdbEntry;
	461	defaultNotify = "(manual operator entry)";
c12197a2	462	}
deeb9f12	463
b1d702f1	464	if(path){
	465	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>" );
	466
	467	AliCDBPath argumentPath(path);
	468	AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
	469
	470	if(stor){
	471	Int_t version = stor->GetLatestVersion(path, GetRunNo());
	472	Int_t subVersion = stor->GetLatestSubVersion(path, GetRunNo(), version);
	473	AliCDBEntry *pEntry = stor->Get(argumentPath,GetRunNo(), version, subVersion);
	474
	475	if(pEntry){
	476	TObjString* pString = dynamic_cast<TObjString*>(pEntry->GetObject());
	477	if(pString){
	478	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	479	iResult = Configure(pString->GetString().Data());
	480	} // if pString is valid
	481	else {
	482	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	483	}
	484	} // if pEntry is valid
	485	else {
	486	HLTError("cannot fetch object \"%s\" from CDB", path);
	487	}
3f0fd8f1	488	} // end if stor is valid
3f0fd8f1	489	} // end if path is valid
c12197a2	490
c12197a2	491	return iResult;
b1d702f1	492
b1d702f1	493
c12197a2	494	}