[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 "AliHLTTPCDigitReaderPacked.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),
    fPlotSideA(0),
    fPlotSideC(0),    
    fApplyNoiseMap(0),
    fResetHistograms(0),
    fIsPacked(0),
    fIsUnpacked(0),
    fCurrentSlice(-99),
    fCurrentPartition(-99),
    fCurrentRow(-99),
    fHistSignal(NULL),
    fHistMaxSignal(NULL),
    fHistTotSignal(NULL),
    fHistPadRMS(NULL),
    fHistCDBMap(NULL),    
    fHistSideA(NULL),  
    fHistSideC(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], "-apply-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], "-plot-side-a")) {
        fPlotSideA = strtoul( argv[i+1], &cpErr ,0);
            
    if ( *cpErr ) {
        HLTError("Cannot convert plot-side-a specifier '%s'.", argv[i+1]);
        return EINVAL;
    }
      i+=2;
      continue;
    }
    
    if (!strcmp( argv[i], "-plot-side-c")) {
        fPlotSideC = strtoul( argv[i+1], &cpErr ,0);
    
    if ( *cpErr ) {
        HLTError("Cannot convert plot-side-c 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(fApplyNoiseMap){
     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
//   }
   
  if(fPlotSideA){
     fHistSideA = new TH2F("fHistSideA","TPC Side A",250,-250,250,250,-250,250);		
     fHistSideA->SetXTitle("global X (cm)"); fHistSideA->SetYTitle("global Y (cm)");
  }   
  
  if(fPlotSideC){    
     fHistSideC = new TH2F("fHistSideC","TPC Side C",250,-250,250,250,-250,250);
     fHistSideC->SetXTitle("global X (cm)"); fHistSideC->SetYTitle("global Y (cm)");
  }
 
  fHistMaxSignal = new TH2F("fHistMaxSignal","maximum signal",   250,-250,250,250,-250,250);
  fHistTotSignal = new TH2F("fHistTotSignal","total signal",     250,-250,250,250,-250,250);
  fHistPadRMS    = new TH2F("fHistPadRMS",   "RMS",              250,-250,250,250,-250,250);
  //fHistSignal    = new TH1F("fHistSignal", "signal distribution per pad",1024,0,1024);
 
//   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(fHistMaxSignal) delete fHistMaxSignal; fHistMaxSignal = NULL;
  if(fHistTotSignal) delete fHistTotSignal; fHistTotSignal = NULL;
  if(fHistPadRMS)    delete fHistPadRMS;    fHistPadRMS    = NULL;
  if(fHistSideA)     delete fHistSideA;     fHistSideA     = NULL;
  if(fHistSideC)     delete fHistSideC;     fHistSideC     = NULL;
       
  return 0;
}

int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& /*trigData*/){
// see header file for class documentation
 
  //HLTInfo("--- Entering DoEvent() in TPCNoiseMap ---");
 
  if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
   
  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 slice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter); 
     UInt_t partition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
     
     fSpecification = iter->fSpecification;
     
     AliHLTTPCDigitReader *pDigitReader = new AliHLTTPCDigitReaderDecoder;

     pDigitReader->InitBlock(iter->fPtr,iter->fSize,partition,slice);
     if(!pDigitReader) break;
       
     //sprintf(name,"hMaxSignal_slice%d_partition%d", slice, partition);
     //fHistMaxSignal = new TH2F(name,name,250,-250,250,250,-250,250);
            
     while(pDigitReader->Next()){ 
     //while( pDigitReader->NextChannel()) { // pad loop 
      
      fCurrentRow  = pDigitReader->GetRow();  
      fCurrentRow += pDigitReader->GetRowOffset();

      AliHLTTPCTransform::Slice2Sector(slice,fCurrentRow,thissector,thisrow);
      AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,pDigitReader->GetPad(),0);
      
      if(slice>17) xyz[1] = (-1.0)*xyz[1];
      else continue;
      
      AliHLTTPCTransform::Local2Global(xyz,slice);
      // 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();
      Float_t maxSignal     = 0.;
      Float_t totalSignal   = 0.;
      Float_t squaredSignal = 0.;
      Float_t rms = 0.; 
      
      //fHistSignal = new TH1F("fHistSignal", "signal distribution per pad",1024,0,1024);
      
      //fHistSignal->Reset();
      //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 over bunches
      rms = TMath::Sqrt(squaredSignal/pDigitReader->GetBunchSize());
            
      //} // end of inner while loop
           
      fHistMaxSignal->Fill(xyz[0],xyz[1],maxSignal);
      fHistTotSignal->Fill(xyz[0],xyz[1],totalSignal);
            
      fHistPadRMS->Fill(xyz[0],xyz[1],rms);
     
      //fHistPadRMS->Fill(xyz[0],xyz[1],fHistSignal->GetRMS());
      //delete fHistSignal; fHistSignal = NULL;
            
      if(fPlotSideA || fPlotSideC){
         if(slice<18) fHistSideA->Fill(xyz[0],xyz[1],maxSignal);
         else	      fHistSideC->Fill(xyz[0],xyz[1],maxSignal);			     
      } // end if plotting sides    
     } // end of while loop over pads
   
     pDigitReader->Reset();
     delete pDigitReader;
  } // end of for loop over data blocks
 
  if(fResetHistograms) ResetHistograms();
  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(fHistMaxSignal);
  histos.Add(fHistTotSignal);
  histos.Add(fHistPadRMS);
  histos.Add(fHistCDBMap);
  //histos.Add(fHistSignal);
  if(fPlotSideA) histos.Add(fHistSideA);
  if(fPlotSideC) histos.Add(fHistSideC);
  
  TIter iterator(&histos);
  while(TObject *pObj=iterator.Next()){ PushBack(pObj, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, fSpecification); }
    
  //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);    
 
//   if(fHistMaxSignal) delete fHistMaxSignal; fHistMaxSignal = NULL;
//   if(fHistTotSignal) delete fHistTotSignal; fHistTotSignal = NULL;
//   if(fHistPadRMS)    delete fHistPadRMS;    fHistPadRMS    = NULL;
//   if(fHistSideA)     delete fHistSideA;     fHistSideA     = NULL;
//   if(fHistSideC)     delete fHistSideC;     fHistSideC     = NULL;
  
}

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

  //if(fHistPartition) fHistPartition->Reset();  
  if(fHistMaxSignal) fHistMaxSignal->Reset();
  if(fHistTotSignal) fHistTotSignal->Reset();
  if(fHistPadRMS)    fHistPadRMS->Reset();

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