HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx

   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: Matthias Richter <Matthias.Richter@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 //**************************************************************************
  18
  19 /** @file   AliHLTTPCEsdWriterComponent.cxx
  20     @author Matthias Richter
  21     @date
  22     @brief  Writer component to store tracks of the HLT TPC conformal
  23             mapping tracker in the AliESD format
  24 */
  25
  26 // see header file for class documentation
  27 // or
  28 // refer to README to build package
  29 // or
  30 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  31
  32 #include <cassert>
  33 #include "AliHLTTPCEsdWriterComponent.h"
  34 #include "AliESDEvent.h"
  35 #include "AliESDtrack.h"
  36 #include "AliCDBEntry.h"
  37 #include "AliCDBManager.h"
  38 #include "TTree.h"
  39 #include "TList.h"
  40 #include "AliHLTTPCTrack.h"
  41 #include "AliHLTTPCTrackArray.h"
  42 #include "AliHLTTPCTrackletDataFormat.h"
  43 #include "AliHLTTPCDefinitions.h"
  44 #include "AliHLTTPCTransform.h"
  45 #include "AliHLTExternalTrackParam.h"
  46 #include "AliHLTGlobalBarrelTrack.h"
  47 #include "AliHLTTrackMCLabel.h"
  48 #include "TGeoGlobalMagField.h"
  49
  50 #include <vector>
  51
  52 /** ROOT macro for the implementation of ROOT specific class methods */
  53 ClassImp(AliHLTTPCEsdWriterComponent)
  54
  55 AliHLTTPCEsdWriterComponent::AliHLTTPCEsdWriterComponent()
  56   :
  57   fSolenoidBz(0)
  58 {
  59   // see header file for class documentation
  60   // or
  61   // refer to README to build package
  62   // or
  63   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  64 }
  65
  66 AliHLTTPCEsdWriterComponent::~AliHLTTPCEsdWriterComponent()
  67 {
  68   // see header file for class documentation
  69 }
  70
  71 AliHLTTPCEsdWriterComponent::AliWriter::AliWriter()
  72   :
  73   fTree(NULL),
  74   fESD(NULL),
  75   fBase(new AliHLTTPCEsdWriterComponent)
  76 {
  77   // see header file for class documentation
  78   // or
  79   // refer to README to build package
  80   // or
  81   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  82 }
  83
  84 AliHLTTPCEsdWriterComponent::AliWriter::~AliWriter()
  85 {
  86   // see header file for class documentation
  87   if (fBase) delete fBase;
  88   fBase=NULL;
  89 }
  90
  91 void AliHLTTPCEsdWriterComponent::AliWriter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
  92 {
  93   // see header file for class documentation
  94   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
  95   list.push_back(AliHLTTPCDefinitions::fgkTracksDataType);
  96   list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
  97 }
  98
  99 int AliHLTTPCEsdWriterComponent::AliWriter::InitWriter()
 100 {
 101   // see header file for class documentation
 102   int iResult=0;
 103   fESD = new AliESDEvent;
 104   if (fESD) {
 105     fESD->CreateStdContent();
 106     fTree = new TTree("esdTree", "Tree with HLT ESD objects");
 107     if (fTree) {
 108       fTree->SetDirectory(0);
 109       fESD->WriteToTree(fTree);
 110     }
 111   }
 112   if (fTree==NULL) {
 113     iResult=-ENOMEM;
 114   }
 115
 116   if (iResult>=0) {
 117     iResult=fBase->Reconfigure(NULL, NULL);
 118   }
 119
 120   return iResult;
 121 }
 122
 123 int AliHLTTPCEsdWriterComponent::AliWriter::CloseWriter()
 124 {
 125   // see header file for class documentation
 126   int iResult=0;
 127   if (fTree) {
 128     // the esd structure is written to the user info and is
 129     // needed in te ReadFromTree method to read all objects correctly
 130     if (fESD) fTree->GetUserInfo()->Add(fESD);
 131     WriteObject(kAliHLTVoidEventID, fTree);
 132     fTree->GetUserInfo()->Clear();
 133     TTree* pTree=fTree;
 134     fTree=NULL;
 135     delete pTree;
 136   } else {
 137     HLTWarning("not initialized");
 138   }
 139
 140   if (fESD) {
 141     delete fESD;
 142   }
 143   iResult=AliHLTRootFileWriterComponent::CloseWriter();
 144   return iResult;
 145 }
 146
 147 int AliHLTTPCEsdWriterComponent::AliWriter::DumpEvent( const AliHLTComponentEventData& evtData,
 148                                             const AliHLTComponentBlockData* blocks,
 149                                             AliHLTComponentTriggerData& /*trigData*/ )
 150 {
 151   // see header file for class documentation
 152   int iResult=0;
 153   TTree* pTree=fTree;
 154   assert(fBase);
 155   if (pTree && fBase) {
 156     if (fESD) {
 157       AliESDEvent* pESD=fESD;
 158
 159       pESD->Reset();
 160       pESD->SetMagneticField(GetBz());
 161       iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt);
 162
 163     } else {
 164       iResult=-ENOMEM;
 165     }
 166   }
 167   return iResult;
 168 }
 169
 170 int AliHLTTPCEsdWriterComponent::AliWriter::ScanArgument(int argc, const char** argv)
 171 {
 172   // see header file for class documentation
 173   int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
 174   return iResult;
 175 }
 176
 177 int AliHLTTPCEsdWriterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD,
 178                                                const AliHLTComponentBlockData* blocks,
 179                                                int nBlocks, int* pMinSlice,
 180                                                int* pMaxSlice)
 181 {
 182   // see header file for class documentation
 183
 184   int iResult=0;
 185   int iAddedDataBlocks=0;
 186
 187   if (pESD && blocks) {
 188       const AliHLTComponentBlockData* iter = NULL;
 189       int bIsTrackSegs=0;
 190
 191       // first read MC information (if present)
 192
 193       std::map<int,int> mcLabels;
 194
 195       for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
 196         iter = blocks+ndx;
 197         if(iter->fDataType == (kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC) ) {
 198           AliHLTTrackMCData* dataPtr = ( AliHLTTrackMCData* )( iter->fPtr );
 199           for( unsigned int il=0; il<dataPtr->fCount; il++ ){
 200             AliHLTTrackMCLabel &lab = dataPtr->fLabels[il];
 201             mcLabels[lab.fTrackID] = lab.fMCLabel;
 202           }
 203         }
 204       }
 205
 206
 207       // do the conversion of tracks
 208
 209       for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
 210         iter = blocks+ndx;
 211
 212         if( iter->fDataType == ( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC ) ){
 213           AliHLTTracksData* dataPtr = ( AliHLTTracksData* ) iter->fPtr;
 214           int nTracks = dataPtr->fCount;
 215           AliHLTExternalTrackParam* currOutTrack = dataPtr->fTracklets;
 216
 217           for( int itr=0; itr<nTracks; itr++ ){
 218             AliHLTGlobalBarrelTrack t(*currOutTrack);
 219             Float_t points[4] = {currOutTrack->fX, currOutTrack->fY, currOutTrack->fLastX, currOutTrack->fLastY };
 220
 221             Int_t mcLabel = -1;
 222             if( mcLabels.find(currOutTrack->fTrackID)!=mcLabels.end() )
 223               mcLabel = mcLabels[currOutTrack->fTrackID];
 224
 225             t.SetLabel( mcLabel );
 226
 227             AliESDtrack iotrack;
 228             iotrack.UpdateTrackParams( &t,AliESDtrack::kTPCin);
 229             iotrack.SetTPCPoints(points);
 230             pESD->AddTrack(&iotrack);
 231             unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + currOutTrack->fNPoints * sizeof( unsigned int );
 232             currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
 233           }
 234           iAddedDataBlocks++;
 235         }
 236
 237
 238         if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType))==1 ||
 239              iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ) {
 240           Int_t minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
 241           Int_t maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
 242           if (bIsTrackSegs==0) {
 243             // slice parameter and data specification ignored, tracks already in global coordinates
 244             minslice=-1;
 245             maxslice=-1;
 246             if (pMinSlice) *pMinSlice=0;
 247             if (pMaxSlice) *pMaxSlice=AliHLTTPCTransform::GetNSlice()-1;
 248           } else {
 249             if (pMinSlice && (*pMinSlice==-1 || *pMinSlice>minslice)) *pMinSlice=minslice;
 250             if (pMaxSlice && (*pMaxSlice==-1 || *pMaxSlice<maxslice)) *pMaxSlice=maxslice;
 251           }
 252           //HLTDebug("dataspec %#x minslice %d", iter->fSpecification, minslice);
 253           if (minslice >=-1 && minslice<AliHLTTPCTransform::GetNSlice()) {
 254             if (minslice!=maxslice) {
 255               HLTWarning("data from multiple sectors in one block: "
 256                          "possible mismatch in treatment of local coordinate system");
 257             }
 258             AliHLTTPCTrackArray tracks;
 259             AliHLTTPCTrackletData* inPtr = (AliHLTTPCTrackletData*) iter->fPtr;
 260             HLTDebug("reading block %d (slice %d): %d tracklets", ndx, minslice, inPtr->fTrackletCnt);
 261             if ((iResult=tracks.FillTracksChecked(inPtr->fTracklets, inPtr->fTrackletCnt, iter->fSize, minslice, 0/*don't rotate*/))>=0) {
 262               if ((iResult=Tracks2ESD(&tracks, pESD ))>=0) {
 263                 iAddedDataBlocks++;
 264               }
 265             }
 266           } else {
 267             HLTError("invalid sector number");
 268             iResult=-EBADF;
 269           }
 270         }
 271       }
 272
 273       if (iAddedDataBlocks>0 && pTree) {
 274         pTree->Fill();
 275       }
 276
 277   } else {
 278     iResult=-EINVAL;
 279   }
 280   if (iResult>=0) iResult=iAddedDataBlocks;
 281   return iResult;
 282 }
 283
 284
 285 int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD )
 286 {
 287   // see header file for class documentation
 288   int iResult=0;
 289
 290   if (pTracks && pESD) {
 291
 292     for (int i=0; i<pTracks->GetNTracks() && iResult>=0; i++) {
 293       AliHLTTPCTrack* pTrack=(*pTracks)[i];
 294       if (pTrack) {
 295
 296         if( pTrack->Convert2AliKalmanTrack() ){
 297           HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
 298           continue;
 299         }
 300
 301         Float_t points[4] = {pTrack->GetFirstPointX(), pTrack->GetFirstPointY(), pTrack->GetLastPointX(), pTrack->GetLastPointY() };
 302
 303         if(pTrack->GetSector() == -1){ // Set first and last points for global tracks
 304           Double_t s = TMath::Sin( pTrack->GetAlpha() );
 305           Double_t c = TMath::Cos( pTrack->GetAlpha() );
 306           points[0] =  pTrack->GetFirstPointX()*c + pTrack->GetFirstPointY()*s;
 307           points[1] = -pTrack->GetFirstPointX()*s + pTrack->GetFirstPointY()*c;
 308           points[2] =  pTrack->GetLastPointX() *c + pTrack->GetLastPointY() *s;
 309           points[3] = -pTrack->GetLastPointX() *s + pTrack->GetLastPointY() *c;
 310         }
 311
 312         AliESDtrack iotrack;
 313         iotrack.UpdateTrackParams(pTrack,AliESDtrack::kTPCin);
 314         iotrack.SetTPCPoints(points);
 315
 316         pESD->AddTrack(&iotrack);
 317       } else {
 318         HLTError("internal mismatch in array");
 319         iResult=-EFAULT;
 320       }
 321     }
 322
 323   } else {
 324     iResult=-EINVAL;
 325   }
 326   return iResult;
 327 }
 328
 329 int AliHLTTPCEsdWriterComponent::Configure(const char* arguments)
 330 {
 331   // see header file for class documentation
 332   int iResult=0;
 333   if (!arguments) return iResult;
 334
 335   // Check field
 336   if (!TGeoGlobalMagField::Instance()) {
 337     HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
 338     return -ENODEV;
 339   }
 340
 341   TString allArgs=arguments;
 342   TString argument;
 343   int bMissingParam=0;
 344
 345   TObjArray* pTokens=allArgs.Tokenize(" ");
 346   if (pTokens) {
 347     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
 348       argument=((TObjString*)pTokens->At(i))->GetString();
 349       if (argument.IsNull()) continue;
 350
 351       if (argument.CompareTo("-solenoidBz")==0) {
 352         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
 353         HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
 354         continue;
 355       } else {
 356         HLTError("unknown argument %s", argument.Data());
 357         iResult=-EINVAL;
 358         break;
 359       }
 360     }
 361     delete pTokens;
 362   }
 363   if (bMissingParam) {
 364     HLTError("missing parameter for argument %s", argument.Data());
 365     iResult=-EINVAL;
 366   }
 367
 368   return iResult;
 369 }
 370
 371 int AliHLTTPCEsdWriterComponent::Reconfigure(const char* cdbEntry, const char* chainId)
 372 {
 373   // see header file for class documentation
 374   int iResult=0;
 375   const char* path=NULL;
 376   const char* defaultNotify="";
 377   if (cdbEntry) {
 378     path=cdbEntry;
 379     defaultNotify=" (default)";
 380   }
 381   if (path) {
 382     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
 383     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 384     if (pEntry) {
 385       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
 386       if (pString) {
 387         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
 388         iResult=Configure(pString->GetString().Data());
 389       } else {
 390         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
 391       }
 392     } else {
 393       HLTError("can not fetch object \"%s\" from CDB", path);
 394     }
 395   }
 396
 397   return iResult;
 398 }
 399
 400 AliHLTTPCEsdWriterComponent::AliConverter::AliConverter()
 401   :
 402   fESD(NULL),
 403   fBase(new AliHLTTPCEsdWriterComponent),
 404   fWriteTree(0)
 405 {
 406   // see header file for class documentation
 407   // or
 408   // refer to README to build package
 409   // or
 410   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 411 }
 412
 413 AliHLTTPCEsdWriterComponent::AliConverter::~AliConverter()
 414 {
 415   // see header file for class documentation
 416   if (fBase) delete fBase;
 417   fBase=NULL;
 418
 419   if (fESD) delete fESD;
 420   fESD=NULL;
 421 }
 422
 423 void AliHLTTPCEsdWriterComponent::AliConverter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
 424 {
 425   // see header file for class documentation
 426   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
 427   list.push_back(AliHLTTPCDefinitions::fgkTracksDataType);
 428   list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
 429 }
 430
 431 AliHLTComponentDataType AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataType()
 432 {
 433   // see header file for class documentation
 434   return kAliHLTDataTypeESDTree;
 435 }
 436
 437 void AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
 438 {
 439   // see header file for class documentation
 440   constBase=2000000;
 441   inputMultiplier=10.0;
 442 }
 443
 444 int AliHLTTPCEsdWriterComponent::AliConverter::DoInit(int argc, const char** argv)
 445 {
 446   // see header file for class documentation
 447   int iResult=0;
 448   TString argument="";
 449   int bMissingParam=0;
 450   for (int i=0; i<argc && iResult>=0; i++) {
 451     argument=argv[i];
 452     if (argument.IsNull()) continue;
 453
 454     // -notree
 455     if (argument.CompareTo("-notree")==0) {
 456       fWriteTree=0;
 457
 458       // -tree
 459     } else if (argument.CompareTo("-tree")==0) {
 460       fWriteTree=1;
 461
 462       // -solenoidBz
 463     } else if (argument.CompareTo("-solenoidBz")==0) {
 464       HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
 465     } else {
 466       HLTError("unknown argument %s", argument.Data());
 467       break;
 468     }
 469   }
 470   if (bMissingParam) {
 471     HLTError("missing parameter for argument %s", argument.Data());
 472     iResult=-EINVAL;
 473   }
 474
 475   if (iResult>=0) {
 476     iResult=fBase->Reconfigure(NULL, NULL);
 477   }
 478
 479   return iResult;
 480 }
 481
 482 int AliHLTTPCEsdWriterComponent::AliConverter::DoDeinit()
 483 {
 484   // see header file for class documentation
 485   return 0;
 486 }
 487
 488 int AliHLTTPCEsdWriterComponent::AliConverter::DoEvent(const AliHLTComponentEventData& evtData,
 489                                                        const AliHLTComponentBlockData* blocks,
 490                                                        AliHLTComponentTriggerData& /*trigData*/,
 491                                                        AliHLTUInt8_t* /*outputPtr*/,
 492                                                        AliHLTUInt32_t& size,
 493                                                        AliHLTComponentBlockDataList& /*outputBlocks*/ )
 494 {
 495   // see header file for class documentation
 496   int iResult=0;
 497   // no direct writing to the output buffer
 498   size=0;
 499
 500   assert(fBase);
 501   if (!fESD) {
 502     fESD = new AliESDEvent;
 503     if (fESD) {
 504       fESD->CreateStdContent();
 505     } else {
 506       iResult=-ENOMEM;
 507     }
 508   }
 509
 510   AliESDEvent* pESD = fESD;
 511
 512   if (pESD && fBase) {
 513
 514     TTree* pTree = NULL;
 515     // TODO: Matthias 06.12.2007
 516     // Tried to write the ESD directly instead to a tree, but this did not work
 517     // out. Information in the ESD is different, needs investigation.
 518
 519     if (fWriteTree)
 520       pTree = new TTree("esdTree", "Tree with HLT ESD objects");
 521
 522     if (pTree) {
 523       pTree->SetDirectory(0);
 524     }
 525
 526     pESD->Reset();
 527     pESD->SetMagneticField(GetBz());
 528     if ((iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt))>0) {
 529       // TODO: set the specification correctly
 530       if (pTree) {
 531         // the esd structure is written to the user info and is
 532         // needed in te ReadFromTree method to read all objects correctly
 533         pTree->GetUserInfo()->Add(pESD);
 534         pESD->WriteToTree(pTree);
 535         iResult=PushBack(pTree, kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC, 0);
 536       } else {
 537         iResult=PushBack(pESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, 0);
 538       }
 539     }
 540     if (pTree) {
 541       // clear user info list to prevent objects from being deleted
 542       pTree->GetUserInfo()->Clear();
 543       delete pTree;
 544     }
 545   }
 546   return iResult;
 547 }
 548