Kelly:
authorkaamodt <kaamodt@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 29 Mar 2009 18:40:54 +0000 (18:40 +0000)
committerkaamodt <kaamodt@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 29 Mar 2009 18:40:54 +0000 (18:40 +0000)
- committing testing macro for testing the noise map component together with the histogram handler
- added doxygen style documentation in the header and the testing macro
- small histo additions (axis names etc)
- removed compilation warning message

HLT/TPCLib/AliHLTTPCNoiseMapComponent.cxx
HLT/TPCLib/AliHLTTPCNoiseMapComponent.h
HLT/TPCLib/macros/noiseMapHistoHandler.C [new file with mode: 0644]

index 9cb0a78..a848141 100644 (file)
@@ -231,6 +231,12 @@ void AliHLTTPCNoiseMapComponent::InitializeHistograms(UInt_t minSlice, UInt_t ma
      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);
@@ -239,7 +245,13 @@ void AliHLTTPCNoiseMapComponent::InitializeHistograms(UInt_t minSlice, UInt_t ma
      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;
   
@@ -257,6 +269,12 @@ int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtDat
   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", 
@@ -295,14 +313,12 @@ int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtDat
     while(pDigitReader->NextChannel()) { // pad loop 
       
       fCurrentRow  = pDigitReader->GetRow();  
-      fCurrentRow += pDigitReader->GetRowOffset();
-      
+      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,
@@ -334,19 +350,13 @@ int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtDat
      
      
       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);
+       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);
+       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.;
@@ -358,7 +368,9 @@ int AliHLTTPCNoiseMapComponent::DoEvent(const AliHLTComponentEventData& /*evtDat
     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();
  
index d35b471..e4e02e5 100644 (file)
@@ -25,26 +25,59 @@ class AliTPCCalPad;
 /**
  * @class AliHLTTPCNoiseMapComponent
  * 
- * Implementation of the component to fill histograms with TPC output and read
- * the noise map from HCDB by request.
+ * Implementation of a component to fill histograms with TPC raw output 
+ * and read the noise map from HCDB by request.
  * 
  * The component implements the interface methods of the @ref AliHLTProcessor.
- * It reads the data pad by pad and fills histograms per partition
+ * It reads the raw data pad by pad and fills histograms per partition
  * 
  * The component has the following component arguments:
- * 
- * -read-noisemap  Reads the noise map from the HCDB (and plots it in a histogram)
+ * <h2>General properties:</h2>
+ *
+ * Component ID: \b TPCNoiseMap <br>
+ * Library: \b libAliHLTTPC.so     <br>
+ * Input Data Types: @ref kAliHLTDataTypeDDLRaw <br>
+ * Output Data Types: @ref kAliHLTDataTypeHistogram <br>
+ *
+ * <h2>Mandatory arguments:</h2>
+ *
+ * <h2>Optional arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li -read-noisemap      <i> teststring   </i> <br>
+ *      Reads the noise map from the HCDB (and plots it in a histogram)
+ *
+ * \li -reset-histograms       <br>
+ *      Resets histograms
  *
- * It returns an AliTPCCalPad object that can be used 
- * for other plots (e.g. noise subtraction in histograms) 
+ * <h2>Configuration:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li -config1      <i> teststring   </i> <br>
+ *      a configuration argument with one parameter
+ * \li -config2                            <br>
+ *      a configuration argument without parameters
  *
- * It makes use of the class AliHLTTPCNoise (see header for usage).
+ * <h2>Default CDB entries:</h2>
+ * The component has two CDB entries in
+ * <tt>HLT/ConfigTPC/TPCNoiseMapComponent</tt>.
+ * It does not load any configuration from the global <tt>ConfigHLT</tt>
+ * folder.
+ * \li -TObjString object holding a string with the configuration parameters
+ *      explained above
  *
- * -reset-histograms Resets histograms
+ * <h2>Performance:</h2>
+ * No clue
  *
- * @ingroup alihlt_tpc
- */
+ * <h2>Memory consumption:</h2>
+ * No clue
+ *
+ * <h2>Output size:</h2>
+ * Much data
+ *
+ * More detailed description.
+ *
+ * @ingroup alihlt_tpc_components
+ */ 
+
 class AliHLTTPCNoiseMapComponent : public AliHLTProcessor {
     
    public:
diff --git a/HLT/TPCLib/macros/noiseMapHistoHandler.C b/HLT/TPCLib/macros/noiseMapHistoHandler.C
new file mode 100644 (file)
index 0000000..8ae2629
--- /dev/null
@@ -0,0 +1,124 @@
+
+//**************************************************************************
+//* 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   noiseMapTest.C
+ * @author Kalliopi.Kanaki@ift.uib.no
+ * @date   
+ * @brief  Test macro for noise map component in combination with histogram handler
+
+ * Usage:
+ * <pre>
+ *   aliroot -b -q noiseMapTest.C | tee noiseMapTest.log
+ *   aliroot -b -q noiseMapTest.C'("./")' | tee noiseMapTest.log
+ * </pre>
+ *
+ * The macro assumes raw data to be available in the rawx folders, either
+ * simulated or real data. A different input can be specified as parameter
+ * <pre>
+ *   aliroot -b -q noiseMapTest.C'("input.root")'
+ * </pre>
+ *
+ * In the first section an analysis chain is defined. The scale of the
+ * chain can be defined by choosing the range of sectors and partitions.
+ *
+ * The reconstruction is steered by the AliReconstruction object in the
+ * usual way.
+ *
+ * @ingroup alihlt_tpc
+ */
+
+void noiseMapHistoHandler(const char* input="./"){
+  
+  if (!input) {
+    cerr << "please specify input or run without arguments" << endl;
+    return;
+  }
+  
+  
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // 
+  // init the HLT system in order to define the analysis chain below
+  //
+  gSystem->Load("libHLTrec.so");
+  AliHLTSystem* gHLT=AliHLTReconstructorBase::GetInstance();
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // define the analysis chain to be run
+  //
+    
+  int iMinSlice = 35; 
+  int iMaxSlice = 35;
+  int iMinPart  = 0;
+  int iMaxPart  = 5;
+
+  TString rootFileWriter, histoInput;
+
+  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
+    for (int part=iMinPart; part<=iMaxPart; part++) {
+     
+      TString argument, publisher, noise;
+     
+      // raw data publisher components
+      int ddlno=768;
+      if (part>1) ddlno+=72+4*slice+(part-2);
+      else ddlno+=2*slice+part;
+      argument.Form("-minid %d -datatype 'DDL_RAW ' 'TPC '  -dataspec 0x%02x%02x%02x%02x", ddlno, slice, slice, part, part);
+      publisher.Form("DP_%02d_%d", slice, part);
+      AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL, argument.Data());
+      
+      // noise filling
+      noise.Form("NM_%02d_%d", slice, part);
+      AliHLTConfiguration noiseconf(noise.Data(), "TPCNoiseMap", publisher.Data(), "");
+      
+      
+      if (histoInput.Length()>0) histoInput+=" ";
+      histoInput+=noise;
+    }
+  }
+  
+  //cout << "histogram handler input:   " << histoInput.Data() << endl;
+  
+  AliHLTConfiguration histconf("hist", "TPCHistogramHandler", histoInput.Data(),"-use-general -ignore-specification");
+  //AliHLTConfiguration histconf("hist", "TPCHistogramHandler", histoInput.Data(),"-sum-noise-histograms");
+  
+  //root file writer component
+  
+  //AliHLTConfiguration rootFileconf("sink1", "ROOTFileWriter", noise.Data(), "-datafile partition");
+  AliHLTConfiguration rootFileconf("sink1", "ROOTFileWriter", "hist", "-datafile TPC -concatenate-events -concatenate-blocks");
+  
+  
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // Init and run the reconstruction
+  // All but HLT reconstruction is switched off
+  //
+  AliReconstruction rec;
+  rec.SetInput(input);
+  rec.SetRunVertexFinder(kFALSE);
+  rec.SetRunLocalReconstruction("HLT");
+  rec.SetRunTracking("");
+  rec.SetLoadAlignFromCDB(0);
+  rec.SetRunQA(":");
+  //rec.SetFillESD("HLT");
+  rec.SetFillESD("");
+  rec.SetFillTriggerESD(false);
+  rec.SetOption("HLT", "libAliHLTTPC.so loglevel=0x7c chains=sink1");
+  rec.Run();
+}