HLT/EMCAL/AliHLTEMCALRawHistoMaker.cxx

   1 /**************************************************************************\r
   2  * This file is property of and copyright by the ALICE HLT Project        * \r
   3  * All rights reserved.                                                   *\r
   4  * INFN Laboratori Nazionali di Frascati                                  *\r
   5  * Primary Authors: Federico Ronchetti                                    *\r
   6  *                                                                        *\r
   7  * Permission to use, copy, modify and distribute this software and its   *\r
   8  * documentation strictly for non-commercial purposes is hereby granted   *\r
   9  * without fee, provided that the above copyright notice appears in all   *\r
  10  * copies and that both the copyright notice and this permission notice   *\r
  11  * appear in the supporting documentation. The authors make no claims     *\r
  12  * about the suitability of this software for any purpose. It is          * \r
  13  * provided "as is" without express or implied warranty.                  *\r
  14  **************************************************************************/\r
  15 \r
  16 /**\r
  17  * @file   AliHLTEMCALRawHistoMaker.cxx\r
  18  * @author Federico Ronchetti\r
  19  * @date \r
  20  * @brief  Histogram maker/pusher for EMCAL HLT  \r
  21  */\r
  22   \r
  23 \r
  24 #include "AliHLTEMCALRawHistoMaker.h"\r
  25 #include "AliHLTEMCALConstants.h"\r
  26 #include "AliHLTEMCALMapper.h"\r
  27 #include "AliHLTCaloChannelDataStruct.h"\r
  28 #include "AliHLTCaloChannelDataHeaderStruct.h"\r
  29 #include "AliHLTCaloSharedMemoryInterfacev2.h"\r
  30 //#include "AliHLTCaloRawAnalyzer.h"\r
  31 #include "AliCaloRawAnalyzer.h"\r
  32 #include "AliCaloBunchInfo.h"\r
  33 #include "AliCaloFitResults.h"\r
  34 \r
  35 ClassImp(AliHLTEMCALRawHistoMaker);\r
  36 \r
  37 AliHLTEMCALRawHistoMaker::AliHLTEMCALRawHistoMaker():\r
  38   AliHLTCaloConstantsHandler("EMCAL"),\r
  39   fShmPtr(0),\r
  40   fMapperPtr(0),\r
  41   fRawCounterMemoryPtr(0),\r
  42   fAltroRawStreamPtr(0),\r
  43   fRawStreamPtr(0),\r
  44   fSTURawStreamPtr(0),\r
  45   fAnalyzerPtr(0),\r
  46   fEMCALConstants(NULL),
  47   hList(0),
  48   fChannelEMap(0), fChannelTMap(0), fChannelETMap(0), h2DTRU(0), h2DSTU(0)\r
  49 \r
  50 {\r
  51   // See header file for documentation\r
  52 \r
  53   fShmPtr = new AliHLTCaloSharedMemoryInterfacev2("EMCAL");\r
  54 \r
  55   fRawCounterMemoryPtr = new AliRawReaderMemory();\r
  56 \r
  57   fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawCounterMemoryPtr);\r
  58 \r
  59   fRawStreamPtr = new AliCaloRawStreamV3(fRawCounterMemoryPtr, "EMCAL");\r
  60 \r
  61   fSTURawStreamPtr = new AliEMCALTriggerSTURawStream(fRawCounterMemoryPtr);\r
  62 \r
  63   fEMCALConstants = new AliHLTEMCALConstants();
  64 \r
  65 \r
  66   // Booking sample histograms\r
  67 \r
  68   char id[100];\r
  69   char title[100];\r
  70  \r
  71   hList = new TObjArray;\r
  72 \r
  73   fChannelEMap = new TProfile2D *[fCaloConstants->GetNMODULES()];\r
  74   fChannelTMap = new TProfile2D *[fCaloConstants->GetNMODULES()];\r
  75   fChannelETMap = new TH2F *[fCaloConstants->GetNMODULES()];\r
  76   \r
  77   h2DTRU = new TH2I ("h2DTRU","",24,0,24,4,0,4);\r
  78   hList->Add(h2DTRU);\r
  79 \r
  80   h2DSTU = new TH2I ("h2DSTU","",24,0,24,4,0,4);\r
  81   hList->Add(h2DSTU);\r
  82 \r
  83   \r
  84   for (int i=0; i<fCaloConstants->GetNMODULES(); i++) {\r
  85     sprintf(title, "E(X vs Z): SM %d ", i);\r
  86     sprintf(id, "fChannelEMap%d", i);\r
  87     fChannelEMap[i] = new TProfile2D(id,title,48 ,0, 47, 24, 0, 23);\r
  88     \r
  89     hList->Add(fChannelEMap[i]);\r
  90     \r
  91     sprintf(title, "T(X vs Z): SM %d ", i);\r
  92     sprintf(id, "fChannelTMap%d", i);\r
  93     fChannelTMap[i] = new TProfile2D(id,title,48 ,0, 47, 24, 0, 23);\r
  94 \r
  95     hList->Add(fChannelTMap[i]);\r
  96 \r
  97     printf(title, "(E vs T): SM %d ", i);\r
  98     sprintf(id, "fChannelETMap%d", i);\r
  99     fChannelETMap[i] = new TH2F(id,title,100 ,0, 50, 100, 0, 500);\r
 100     \r
 101     hList->Add(fChannelETMap[i]);\r
 102   }\r
 103   \r
 104   \r
 105 }\r
 106 \r
 107 AliHLTEMCALRawHistoMaker::~AliHLTEMCALRawHistoMaker() \r
 108 {\r
 109   //See header file for documentation\r
 110 }\r
 111 \r
 112 // Pointer for histograms objects\r
 113 TObjArray* AliHLTEMCALRawHistoMaker::GetHistograms()\r
 114 {\r
 115   return hList;\r
 116 }\r
 117 \r
 118 \r
 119 Int_t\r
 120 AliHLTEMCALRawHistoMaker::MakeHisto(AliHLTCaloChannelDataHeaderStruct* channelDataHeader,\r
 121                 const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr,\r
 122                 const AliHLTUInt32_t size, int beverbose)\r
 123 {\r
 124         //int tmpsize =  0;\r
 125         Int_t crazyness          = 0;\r
 126         Int_t nSamples           = 0;\r
 127         Short_t channelCount     = 0;\r
 128 \r
 129         AliHLTCaloCoordinate coord;
 130         AliHLTCaloChannelDataStruct* currentchannel = 0;\r
 131         fShmPtr->SetMemory(channelDataHeader);\r
 132 \r
 133         AliHLTCaloChannelDataHeaderStruct *channelDataHeaderPtr = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(outputPtr);\r
 134         AliHLTCaloChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*>(outputPtr+sizeof(AliHLTCaloChannelDataHeaderStruct));\r
 135 \r
 136         fRawCounterMemoryPtr->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ),  static_cast<ULong_t>( iter->fSize )  );\r
 137         fRawCounterMemoryPtr->SetEquipmentID(    fMapperPtr->GetDDLFromSpec(  iter->fSpecification) + fCaloConstants->GetDDLOFFSET() );\r
 138         fRawCounterMemoryPtr->Reset();\r
 139 \r
 140         //fRawCounterMemoryPtr->NextEvent();\r
 141 \r
 142         //--- from STU macro\r
 143         //while ( rawReader->NextEvent() )\r
 144 \r
 145         while (fRawCounterMemoryPtr->NextEvent())\r
 146         {\r
 147                 fRawCounterMemoryPtr->Reset();\r
 148                 fRawCounterMemoryPtr->Select("EMCAL",44);\r
 149 \r
 150                 const UInt_t* evtId = fRawCounterMemoryPtr->GetEventId();\r
 151                 int evno_raw = (int)evtId[0];\r
 152 \r
 153                 UInt_t eventType = fRawCounterMemoryPtr->GetType();\r
 154 \r
 155                 if (beverbose)\r
 156                         cout << "I-RAWHISTOMAKER: event type: " << eventType << endl;\r
 157 \r
 158 //              if (eventType != AliRawEventHeaderBase::kPhysicsEvent) continue;\r
 159 \r
 160 //              fRawCounterMemoryPtr->DumpData();\r
 161 \r
 162 //              fRawCounterMemoryPtr->Reset();\r
 163 \r
 164                 fSTURawStreamPtr->ReadPayLoad();\r
 165 //              fSTURawStreamPtr->DumpPayLoad("ALL");\r
 166 \r
 167                 UInt_t adc[96];\r
 168 \r
 169                 for (Int_t i=0;i<96;i++)\r
 170                         adc[i] = 0;\r
 171 \r
 172                 fSTURawStreamPtr->GetADC(29, adc);\r
 173 \r
 174                 for (Int_t i=0;i<96;i++)\r
 175                 {\r
 176                         Int_t x = i / 4;\r
 177                         Int_t y = i % 4;\r
 178 \r
 179                         h2DSTU->Fill( x , y , adc[i] );\r
 180                 }\r
 181 \r
 182                 fRawCounterMemoryPtr->Reset();\r
 183                 fRawCounterMemoryPtr->Select("EMCAL",0,43);\r
 184 \r
 185                 while (fRawStreamPtr->NextDDL())\r
 186                 {\r
 187                         Int_t iRCU = fRawStreamPtr->GetDDLNumber() % 2;\r
 188 \r
 189                         while (fRawStreamPtr->NextChannel())\r
 190                         {\r
 191                                 Int_t iSM = fRawStreamPtr->GetModule();\r
 192 \r
 193                                 Int_t iTRUId = 3 * iSM + iRCU * fRawStreamPtr->GetBranch() + iRCU;\r
 194 \r
 195                                 if (iSM==0)\r
 196                                 {\r
 197                                         Int_t nsamples = 0;\r
 198                                         vector<AliCaloBunchInfo> bunchlist;\r
 199                                         while (fRawStreamPtr->NextBunch())\r
 200                                         {\r
 201                                                 nsamples += fRawStreamPtr->GetBunchLength();\r
 202                                                 bunchlist.push_back( AliCaloBunchInfo(fRawStreamPtr->GetStartTimeBin(), fRawStreamPtr->GetBunchLength(), fRawStreamPtr->GetSignals() ) );\r
 203                                         }\r
 204 \r
 205                                         Int_t max = 0;\r
 206 \r
 207                                         for (std::vector<AliCaloBunchInfo>::iterator itVectorData = bunchlist.begin(); itVectorData != bunchlist.end(); itVectorData++)\r
 208                                         {\r
 209                         AliCaloBunchInfo bunch = *(itVectorData);\r
 210 \r
 211                         const UShort_t* sig = bunch.GetData();\r
 212                         Int_t startBin = bunch.GetStartBin();\r
 213 \r
 214                         for (Int_t iS = 0; iS < bunch.GetLength(); iS++)\r
 215                         {\r
 216                                                         if ( sig[iS] > max ) max = sig[iS];\r
 217                                                 }\r
 218                                         }\r
 219 \r
 220                                         if (nsamples) // this check is needed for when we have zero-supp. on, but not sparse readout\r
 221                                         {\r
 222                                                 if (fRawStreamPtr->IsTRUData() && fRawStreamPtr->GetColumn() < 96)\r
 223                                                 {\r
 224                                                         if (iTRUId == 2)\r
 225                                                         {\r
 226                                                                 Int_t x = fRawStreamPtr->GetColumn() / 4;\r
 227                                                                 Int_t y = fRawStreamPtr->GetColumn() % 4;\r
 228 \r
 229                                                         h2DTRU->Fill( x , y , max );\r
 230                                                         }\r
 231                                                 }\r
 232                                         }\r
 233                                 }\r
 234                         }\r
 235                 }\r
 236 \r
 237 //              c_0->cd(1);\r
 238 //              h2DTRU->Draw("TEXT");\r
 239 //\r
 240 //              c_0->cd(2);\r
 241 //              h2DSTU->Draw("TEXT");\r
 242 //\r
 243 //              c_0->Update();\r
 244 //\r
 245 //              h2DTRU->Reset();\r
 246 //              h2DSTU->Reset();\r
 247         }\r
 248 \r
 249         //--- end of while\r
 250 \r
 251 \r
 252 //------ FIXME\r
 253 //------ old stuff to be removed or re-utilized\r
 254         //fRawDataWriter->NewEvent( );\r
 255 \r
 256         if(fAltroRawStreamPtr->NextDDL())\r
 257           {\r
 258             int cnt = 0;\r
 259             int fOffset = 0;\r
 260 \r
 261             while( fAltroRawStreamPtr->NextChannel()  )\r
 262               {\r
 263                 //       cout << __FILE__  << ":" << __LINE__ << ":" <<__FUNCTION__ << "T3"  << endl;\r
 264                 if(  fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 )\r
 265                   {\r
 266                     continue;\r
 267                   }\r
 268                 else\r
 269                   {\r
 270                     ++ cnt;\r
 271                     UShort_t* firstBunchPtr = 0;\r
 272                     int chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress());\r
 273                     //HLTError("Channel HW address: %d", fAltroRawStreamPtr->GetHWAddress());\r
 274 \r
 275 \r
 276                    //cout << fRawStreamPtr->GetCaloFlag() << endl;\r
 277                     //      return 1;\r
 278 \r
 279                     vector <AliCaloBunchInfo> bvctr;\r
 280                     while( fAltroRawStreamPtr->NextBunch() == true )\r
 281                       {\r
 282                         bvctr.push_back( AliCaloBunchInfo( fAltroRawStreamPtr->GetStartTimeBin(), fAltroRawStreamPtr->GetBunchLength(), fAltroRawStreamPtr->GetSignals() ) );\r
 283 \r
 284                         nSamples = fAltroRawStreamPtr->GetBunchLength();\r
 285 \r
 286 \r
 287                            // fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples,  fAltroRawStreamPtr->GetEndTimeBin()  );\r
 288                         firstBunchPtr = const_cast< UShort_t* >(  fAltroRawStreamPtr->GetSignals()  );\r
 289                       }\r
 290 \r
 291                     //return 1;\r
 292 \r
 293 \r
 294                     //    fAnalyzerPtr->SetData( firstBunchPtr, nSamples);\r
 295                   AliCaloFitResults res = fAnalyzerPtr->Evaluate( bvctr,  fAltroRawStreamPtr->GetAltroCFG1(), fAltroRawStreamPtr->GetAltroCFG2() );\r
 296 \r
 297                     HLTDebug("Channel energy: %f, max sig: %d, gain = %d, x = %d, z = %d", res.GetAmp(), res.GetMaxSig(), (chId >> 12)&0x1, chId&0x3f, (chId >> 6)&0x3f);\r
 298 \r
 299                     //        if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)\r
 300                     {\r
 301                       channelDataPtr->fChannelID =  chId;\r
 302                       channelDataPtr->fEnergy = static_cast<Float_t>( res.GetAmp()  ) - fOffset;\r
 303 \r
 304                       channelDataPtr->fTime = static_cast<Float_t>(  res.GetTof() );\r
 305                       channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);\r
 306                       channelCount++;\r
 307                       channelDataPtr++; // Updating position of the free output.\r
 308                     }\r
 309                   }\r
 310 \r
 311 \r
 312                   }\r
 313 \r
 314                    //fRawDataWriter->NewChannel();\r
 315 \r
 316           }\r
 317 \r
 318 \r
 319 //-------\r
 320         currentchannel = fShmPtr->NextChannel();\r
 321 \r
 322         while(currentchannel != 0) {\r
 323 \r
 324                 AliHLTCaloChannelRawDataStruct rawdata = fShmPtr->GetRawData();\r
 325 \r
 326                 fMapperPtr->ChannelId2Coordinate(currentchannel->fChannelID, coord);
 327 \r
 328                 fChannelTMap[coord.fModuleId]->Fill( coord.fZ,  coord.fX , currentchannel->fTime);\r
 329                 fChannelEMap[coord.fModuleId]->Fill( coord.fZ,  coord.fX , currentchannel->fEnergy);\r
 330                 fChannelETMap[coord.fModuleId]->Fill(currentchannel->fEnergy, currentchannel->fTime);\r
 331
 332                 currentchannel = fShmPtr->NextChannel(); // Get the next channel\r
 333 \r
 334         }\r
 335 \r
 336 \r
 337 return (0); \r
 338 }