fPeakRatio = 0.5;
fInputFile = 0;
fInputPtr = 0;
+ fRawEvent = 0;
SetTransformerParams();
SetThreshold();
//cout << "Cleaned class mem " << endl;
}
+void AliL3Hough::Init(Int_t netasegments,Int_t tv,AliRawEvent *rawevent,Float_t zvertex)
+{
+ //Normal constructor
+ fNEtaSegments = netasegments;
+ fVersion = tv;
+ fRawEvent = rawevent;
+ fZVertex = zvertex;
+
+ Init();
+}
+
void AliL3Hough::Init(Char_t *path,Bool_t binary,Int_t netasegments,Bool_t bit8,Int_t tv,Char_t *infile,Char_t *ptr,Float_t zvertex)
{
//Normal init of the AliL3Hough
else
#ifdef use_aliroot
{
- if(!fInputFile) {
- if(!fInputPtr) {
- /* In case of reading digits file */
- fMemHandler[i] = new AliL3FileHandler(kTRUE); //use static index
- if(!fBinary) {
+ if(!fRawEvent) {
+ if(!fInputFile) {
+ if(!fInputPtr) {
+ /* In case of reading digits file */
+ fMemHandler[i] = new AliL3FileHandler(kTRUE); //use static index
+ if(!fBinary) {
#if use_newio
- if(!fRunLoader) {
+ if(!fRunLoader) {
#endif
- Char_t filename[1024];
- sprintf(filename,"%s/digitfile.root",fPath);
- fMemHandler[i]->SetAliInput(filename);
+ Char_t filename[1024];
+ sprintf(filename,"%s/digitfile.root",fPath);
+ fMemHandler[i]->SetAliInput(filename);
#if use_newio
- }
- else {
- fMemHandler[i]->SetAliInput(fRunLoader);
- }
+ }
+ else {
+ fMemHandler[i]->SetAliInput(fRunLoader);
+ }
#endif
+ }
+ }
+ else {
+ /* In case of reading from DATE */
+ fMemHandler[i] = new AliL3DDLDataFileHandler();
+ fMemHandler[i]->SetReaderInput(fInputPtr,-1);
}
}
else {
- /* In case of reading from DATE */
+ /* In case of reading rawdata from ROOT file */
fMemHandler[i] = new AliL3DDLDataFileHandler();
- fMemHandler[i]->SetReaderInput(fInputPtr,-1);
+ fMemHandler[i]->SetReaderInput(fInputFile);
}
}
else {
- /* In case of reading rawdata from ROOT file */
+ /* In case of reading rawdata using AliRawEvent */
fMemHandler[i] = new AliL3DDLDataFileHandler();
- fMemHandler[i]->SetReaderInput(fInputFile);
+ fMemHandler[i]->SetReaderInput(fRawEvent);
}
}
#else
}
}
+#ifdef use_aliroot
+Int_t AliL3Hough::FillESD(AliESD *esd)
+{
+ if(!fGlobalTracks) return 0;
+ Int_t nglobaltracks = 0;
+ for(Int_t i=0; i<fGlobalTracks->GetNTracks(); i++)
+ {
+ AliL3HoughTrack *tpt = (AliL3HoughTrack *)fGlobalTracks->GetCheckedTrack(i);
+ if(!tpt) continue;
+
+ AliESDHLTtrack *esdtrack = new AliESDHLTtrack();
+
+ esdtrack->SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
+ esdtrack->SetNHits(tpt->GetNHits());
+ esdtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
+ esdtrack->SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
+ esdtrack->SetPt(tpt->GetPt());
+ esdtrack->SetPsi(tpt->GetPsi());
+ esdtrack->SetTgl(tpt->GetTgl());
+ esdtrack->SetCharge(tpt->GetCharge());
+ esdtrack->SetMCid(tpt->GetMCid());
+ esdtrack->SetWeight(tpt->GetWeight());
+ esdtrack->SetSector(tpt->GetSector());
+ esdtrack->SetBinXY(tpt->GetBinX(),tpt->GetBinY(),tpt->GetSizeX(),tpt->GetSizeY());
+ esdtrack->SetPID(tpt->GetPID());
+ esdtrack->ComesFromMainVertex(tpt->ComesFromMainVertex());
+
+ esd->AddHLTHoughTrack(esdtrack);
+ nglobaltracks++;
+ delete esdtrack;
+ }
+ return nglobaltracks;
+}
+#endif
+
void AliL3Hough::WriteDigits(Char_t *outfile)
{
//Write the current data to a new rootfile.
class AliL3Benchmark;
#include "TThread.h"
-//class TThread;
#ifdef use_newio
#include <AliRunLoader.h>
+#include <../RAW/AliRawEvent.h>
+#endif
+#ifdef use_aliroot
+#include <AliESD.h>
+#include <AliESDHLTtrack.h>
#endif
class AliL3Hough {
void SetRunLoader(AliRunLoader *runloader) {fRunLoader = runloader;}
#endif
+ void Init(Int_t netasegments,Int_t tv,AliRawEvent *rawevent,Float_t zvertex=0.0);
void Init(Char_t *path,Bool_t binary,Int_t netasegments=100,Bool_t bit8=kFALSE,Int_t tv=0,Char_t *infile=0,Char_t *ptr=0,Float_t zvertex=0.0);
void Init(Bool_t doit=kFALSE, Bool_t addhists=kFALSE);
void EvaluatePatch(Int_t i,Int_t roadwidth,Int_t nrowstomiss);
void WriteTracks(Int_t slice,Char_t *path="./");
void WriteTracks(Char_t *path);
+#ifdef use_aliroot
+ Int_t FillESD(AliESD *esd);
+#endif
void WriteDigits(Char_t *outfile="output_digits.root");
void InitEvaluate();
void DoBench(Char_t *filename);
private:
Char_t *fInputFile;//!
Char_t *fInputPtr;//!
+ AliRawEvent *fRawEvent;//!
Char_t fPath[1024]; // Path to the files
Bool_t fBinary; // Is input binary
Bool_t fAddHistograms; // Add all patch histograms at the end or not
fN2PeaksPrevEtaSlice = fNPeaks;
for(Int_t i=0; i<hist->GetNbinsY(); i++)
- delete localmaxima[i];
+ delete [] localmaxima[i];
delete [] localmaxima;
delete [] nmaxs;
// cout<<" fTrackNRows "<<(Int_t)fInitialGapCount[xbin + ybin*nxbins]<<" "<<xbin<<" "<<ybin<<" "<<(Int_t)fTrackNRows[xbin + ybin*nxbins]<<" "<<(Int_t)fTrackFirstRow[xbin + ybin*nxbins]<<" "<<(Int_t)fTrackLastRow[xbin + ybin*nxbins]<<" "<<endl;
}
}
- delete tracklength;
+ delete [] tracklength;
}
if(!fStartPadParams)
{
// frees all heap memory
if(fReader) delete fReader;
- if(fTPCStream) delete fTPCStream;
fReader = 0;
+ if(fTPCStream) delete fTPCStream;
fTPCStream = 0;
}
#ifdef use_newio
+Bool_t AliL3DDLDataFileHandler::SetReaderInput(AliRawEvent *rawevent)
+{
+ // sets the input of the reader
+ fEvent=-1;
+ fFilename="";
+ if(fReader) delete fReader;
+ fReader=new AliRawReaderRoot(rawevent);
+ if(fTPCStream) delete fTPCStream;
+ fTPCStream=new AliTPCRawStream(fReader);
+
+ return kTRUE;
+}
+
Bool_t AliL3DDLDataFileHandler::SetReaderInput(Char_t *name,Int_t event)
{
// sets the input of the reader
#define ALIL3DDLDATAFILEHANDLER_H
#ifdef use_newio
+#include "../RAW/AliRawEvent.h"
#include "../RAW/AliRawReader.h"
#include "../RAW/AliTPCRawStream.h"
#include <TString.h>
virtual ~AliL3DDLDataFileHandler();
#ifdef use_newio
+ Bool_t SetReaderInput(AliRawEvent *rawevent);
Bool_t SetReaderInput(Char_t *name,Int_t event=0);
Bool_t IsDigit(Int_t i=0) const;
AliL3DigitRowData *AliAltroDigits2Memory(UInt_t & nrow,Int_t event=0,Bool_t /*eventmerge*/=kFALSE){return DDLData2Memory(nrow,event);};
#ifdef use_newio
class AliRunLoader;
+class AliRawEvent;
#endif
class AliTPCRawStream;
//AliL3DDLDataFileHandler
#ifdef use_newio
+ virtual Bool_t SetReaderInput(AliRawEvent */*rawevent*/){fDummy=0; return 0;}
virtual Bool_t SetReaderInput(Char_t */*name*/,Int_t /*event*/=0){fDummy=0; return 0;}
#else
virtual Bool_t SetReaderInput(Char_t */*name*/,Bool_t /*add*/=kTRUE){fDummy=0; return 0;}
ifdef DATE_ROOT
ELIBSDIR:=${DATE_MONITOR_DIR}/${DATE_SYS}
-ELIBS:= STEER RAW monitor shift pythia6 pdf microcern
+ELIBS:= STEER CONTAINERS RAW monitor shift pythia6 pdf microcern TPCbase TPCsim TPCrec AliL3Src AliL3Comp AliL3Misc AliL3Hough
EINCLUDE+= ${DATE_COMMON_DEFS} ${DATE_MONITOR_DIR}
else
#include "libDateEb.h"
#endif
+#ifdef USE_HLT
+#include <AliL3StandardIncludes.h>
+#include "AliL3Logging.h"
+#include <AliL3Transform.h>
+#include "AliRawReaderRoot.h"
+#include <AliL3Hough.h>
+#include <AliESD.h>
+#endif
+
#include "AliRawEvent.h"
#include "AliRawEventHeader.h"
#include "AliRawEquipment.h"
// Event object used to store event data.
AliRawEvent *event = new AliRawEvent;
+#ifdef USE_HLT
+ //Init HLT
+ AliL3Log::fgLevel=AliL3Log::kError;
+ ALIDEBUG(1)
+ AliL3Log::fgLevel=AliL3Log::kWarning;
+ ALIDEBUG(2)
+ AliL3Log::fgLevel=AliL3Log::kWarning;
+ ALIDEBUG(3)
+ AliL3Log::fgLevel=AliL3Log::kNone;
+
+ if (!AliL3Transform::Init("./", kFALSE)) {
+ Error("Run","HLT initialization failed!");
+ return 1;
+ }
+
+ AliESD *esd = new AliESD;
+#endif
// Create new raw DB.
AliRawDB *rawdb;
if (fWriteMode == kRFIO)
- rawdb = new AliRawRFIODB(event, fMaxFileSize, fCompress);
+ rawdb = new AliRawRFIODB(event, esd, fMaxFileSize, fCompress);
else if (fWriteMode == kROOTD)
- rawdb = new AliRawRootdDB(event, fMaxFileSize, fCompress);
+ rawdb = new AliRawRootdDB(event, esd, fMaxFileSize, fCompress);
else if (fWriteMode == kCASTOR)
- rawdb = new AliRawCastorDB(event, fMaxFileSize, fCompress);
+ rawdb = new AliRawCastorDB(event, esd, fMaxFileSize, fCompress);
else if (fWriteMode == kDEVNULL)
- rawdb = new AliRawNullDB(event, fMaxFileSize, fCompress);
+ rawdb = new AliRawNullDB(event, esd, fMaxFileSize, fCompress);
else
- rawdb = new AliRawDB(event, fMaxFileSize, fCompress);
+ rawdb = new AliRawDB(event, esd, fMaxFileSize, fCompress);
if (rawdb->IsZombie()) return 1;
printf("Filling raw DB %s\n", rawdb->GetDBName());
// Check if event has any hard track flagged
Bool_t callFilter = kFALSE;
- // This needs to be re-engineered for the next ADC...
- //if (fUseFilter && TEST_USER_ATTRIBUTE(header.GetTypeAttribute(), 0))
- // callFilter = kTRUE;
+ if (fUseFilter)
+ callFilter = kTRUE;
// Check event type and skip "Start of Run", "End of Run",
// "Start of Run Files" and "End of Run Files"
// Read equipment raw data
AliRawData &subRaw = *equipment.GetRawData();
- Int_t eqSize = equipmentHeader.GetEquipmentSize() -
- equipHeaderSize;
+ // To be checked !
+ // Int_t eqSize = equipmentHeader.GetEquipmentSize() -
+ // equipHeaderSize;
+ Int_t eqSize = equipmentHeader.GetEquipmentSize();
if ((status = ReadRawData(subRaw, eqSize, ebdata)) != eqSize) {
if (status == 0) {
Error("Run", "unexpected EOF reading sub-event raw data");
toRead -= eqSize;
rawSize -= eqSize;
- if (callFilter) {
-#ifdef ALI_DATE
- if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
- Filter(subRaw);
- else {
- // set size of all sectors without hard track flag to 0
- subRaw.SetSize(0);
- }
-#endif
- }
}
} else { // Read only raw data but no equipment header
}
toRead -= rawSize;
- if (callFilter) {
-#ifdef ALI_DATE
- if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
- Filter(subRaw);
- else {
- // set size of all sectors without hard track flag to 0
- subRaw.SetSize(0);
- }
-#endif
- }
}
nsub++;
}
+ //HLT
+ if (callFilter) {
+#ifdef ALI_DATE
+ if(header.GetType() == AliRawEventHeader::kPhysicsEvent ||
+ header.GetType() == AliRawEventHeader::kCalibrationEvent)
+ Filter(
+#ifdef USE_HLT
+ event,esd
+#endif
+ );
+#endif
+ }
+
// Set stat info for first event of this file
if (rawdb->GetEvents() == 0)
stats->SetFirstId(header.GetRunNumber(), header.GetEventInRun());
// Make top event object ready for next event data
//printf("Event %d has %d sub-events\n", fNumEvents, event->GetNSubEvents());
event->Reset();
-
+#ifdef USE_HLT
+ // Clean up HLT ESD for the next event
+ // Probably we could add esd->Reset() method to AliESD?
+ esd->Reset();
+#endif
#ifdef USE_EB
if (!ebReleaseEvent(ebvec)) {
Error("Run", "problem releasing event (%s)", ebGetLastError());
}
//______________________________________________________________________________
-Int_t AliMDC::Filter(AliRawData &raw)
+Int_t AliMDC::Filter(
+#ifdef USE_HLT
+ AliRawEvent *event,AliESD *esd
+#endif
+ )
{
- // Call 3rd level filter for this raw data segment.
+ // Call 3rd level filter for this raw data event.
#ifdef USE_HLT
- // Add HLT code here
+ // Run the HLT code
+ {
+ TStopwatch timer;
+ timer.Start();
+
+ AliL3Hough *hough1 = new AliL3Hough();
+
+ hough1->SetThreshold(4);
+ hough1->SetTransformerParams(76,140,0.4,-1);
+ hough1->SetPeakThreshold(70,-1);
+ // Attention Z of the vertex to be taken from the event head!
+ // So far for debug purposes it is fixed by hand...
+ hough1->Init(100,4,event,3.82147);
+ hough1->SetAddHistograms();
+
+ AliL3Hough *hough2 = new AliL3Hough();
+
+ hough2->SetThreshold(4);
+ hough2->SetTransformerParams(76,140,0.4,-1);
+ hough2->SetPeakThreshold(70,-1);
+ hough2->Init(100,4,event,3.82147);
+ hough2->SetAddHistograms();
+
+ Int_t nglobaltracks = 0;
+ /* In case we run HLT code in 2 threads */
+ hough1->StartProcessInThread(0,17);
+ hough2->StartProcessInThread(18,35);
+
+ if(hough1->WaitForThreadFinish())
+ ::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
+ if(hough2->WaitForThreadFinish())
+ ::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
+
+ /* In case we run HLT code in the main thread
+ for(Int_t slice=0; slice<=17; slice++)
+ {
+ hough1->ReadData(slice,0);
+ hough1->Transform();
+ hough1->AddAllHistogramsRows();
+ hough1->FindTrackCandidatesRow();
+ hough1->AddTracks();
+ }
+ for(Int_t slice=18; slice<=35; slice++)
+ {
+ hough2->ReadData(slice,0);
+ hough2->Transform();
+ hough2->AddAllHistogramsRows();
+ hough2->FindTrackCandidatesRow();
+ hough2->AddTracks();
+ }
+ */
+
+ nglobaltracks += hough1->FillESD(esd);
+ nglobaltracks += hough2->FillESD(esd);
+
+ /* In case we want to debug the ESD
+ gSystem->MakeDirectory("hough1");
+ hough1->WriteTracks("./hough1");
+ gSystem->MakeDirectory("hough2");
+ hough2->WriteTracks("./hough2");
+ */
+
+ delete hough1;
+ delete hough2;
+
+ printf("Filter called for event %d\n", fNumEvents);
+ printf("Filter has found %d TPC tracks in %f seconds\n", nglobaltracks,timer.RealTime());
+ }
#else
- raw.GetSize();
- printf("Filter called for event %d\n", fNumEvents);
+ printf("Filter called for event %d\n", fNumEvents);
#endif
- return 0;
+ return 0;
}
//______________________________________________________________________________
#endif
// Forward class declarations
+class AliRawEvent;
class AliRawEventHeader;
class AliRawEquipmentHeader;
class AliRawData;
-
+#ifdef USE_HLT
+class AliESD;
+#endif
class AliMDC : public TObject {
Bool_t isSwapped, void *eb = 0);
Int_t ReadRawData(AliRawData &raw, Int_t size, void *eb = 0);
Int_t DumpEvent(Int_t toRead);
- Int_t Filter(AliRawData &raw);
+ Int_t Filter(
+#ifdef USE_HLT
+ AliRawEvent *event,AliESD *esd
+#endif
+ );
ClassDef(AliMDC,0) // MDC processor
};
//______________________________________________________________________________
-AliRawCastorDB::AliRawCastorDB(AliRawEvent *event, Double_t maxsize, Int_t compress)
- : AliRawDB(event, maxsize, compress, kFALSE)
+AliRawCastorDB::AliRawCastorDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress)
+ : AliRawDB(event,
+#ifdef USE_HLT
+ esd,
+#endif
+ maxsize, compress, kFALSE)
{
// Create a new raw DB that will be accessed via CASTOR and rootd.
class AliRawCastorDB : public AliRawDB {
public:
- AliRawCastorDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
+ AliRawCastorDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress);
~AliRawCastorDB() { Close(); }
const char *GetOpenOption() const { return "-RECREATE"; }
#include "AliRawEventHeader.h"
#include "AliMDC.h"
+#ifdef USE_HLT
+#include "AliESD.h"
+#endif
+
#include "AliRawDB.h"
//______________________________________________________________________________
-AliRawDB::AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
+AliRawDB::AliRawDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress,
Bool_t create)
{
// Create a new raw DB containing at most maxsize bytes.
fEvent = event;
+ fESD = esd;
fMaxSize = maxsize;
fCompress = compress;
//Int_t split = 1;
Int_t split = 0;
fTree->Branch("rawevent", "AliRawEvent", &fEvent, bufsize, split);
+
+#ifdef USE_HLT
+ // Create tree which will contain the HLT ESD information
+
+ fESDTree = new TTree("esdTree", Form("ALICE MDC%d HLT ESD tree", AliMDC::kMDC));
+ fESDTree->SetAutoSave(2000000000); // autosave when 2 Gbyte written
+ split = 99;
+ fESDTree->Branch("ESD", "AliESD", &fESD, bufsize, split);
+#endif
+
}
//______________________________________________________________________________
// Write the tree.
fTree->Write();
+ fESDTree->Write();
// Close DB, this also deletes the fTree
fRawDB->Close();
class AliRawEvent;
class TFile;
+#ifdef USE_HLT
+class AliESD;
+#endif
class AliRawDB : public TObject {
public:
- AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
+ AliRawDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress,
Bool_t create = kTRUE);
virtual ~AliRawDB() { Close(); }
virtual Int_t GetNetopt() const { return 0; }
virtual Bool_t Create();
virtual void Close();
- void Fill() { fTree->Fill(); }
+ void Fill() { fTree->Fill(); fESDTree->Fill(); }
Bool_t FileFull() { return (fRawDB->GetBytesWritten() > fMaxSize) ?
kTRUE : kFALSE; }
TFile *fRawDB; // DB to store raw data
TTree *fTree; // tree used to store raw data
AliRawEvent *fEvent; // AliRawEvent via which data is stored
+#ifdef USE_HLT
+ TTree *fESDTree; // tree for storing HLT ESD information
+ AliESD *fESD; // pointer to HLT ESD object
+#endif
Int_t fCompress; // compression mode (1 default)
Double_t fMaxSize; // maximum size in bytes of the raw DB
//______________________________________________________________________________
-AliRawNullDB::AliRawNullDB(AliRawEvent *event, Double_t maxsize, Int_t compress)
- : AliRawDB(event, maxsize, compress, kFALSE)
+AliRawNullDB::AliRawNullDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress)
+ : AliRawDB(event,
+#ifdef USE_HLT
+ esd,
+#endif
+ maxsize, compress, kFALSE)
{
// Create a new raw DB that will wrtie to /dev/null.
class AliRawNullDB : public AliRawDB {
public:
- AliRawNullDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
+ AliRawNullDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress);
~AliRawNullDB() { Close(); }
void Close();
//______________________________________________________________________________
-AliRawRFIODB::AliRawRFIODB(AliRawEvent *event, Double_t maxsize, Int_t compress)
- : AliRawDB(event, maxsize, compress, kFALSE)
+AliRawRFIODB::AliRawRFIODB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress)
+ : AliRawDB(event,
+#ifdef USE_HLT
+ esd,
+#endif
+ maxsize, compress, kFALSE)
{
// Create a new raw DB that will be accessed via RFIO.
class AliRawRFIODB : public AliRawDB {
public:
- AliRawRFIODB(AliRawEvent *event, Double_t maxsize, Int_t compress);
+ AliRawRFIODB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress);
~AliRawRFIODB() { Close(); }
void Close();
//______________________________________________________________________________
-AliRawRootdDB::AliRawRootdDB(AliRawEvent *event, Double_t maxsize, Int_t compress)
- : AliRawDB(event, maxsize, compress, kFALSE)
+AliRawRootdDB::AliRawRootdDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress)
+ : AliRawDB(event,
+#ifdef USE_HLT
+ esd,
+#endif
+ maxsize, compress, kFALSE)
{
// Create a new raw DB that will be accessed via rootd daemon.
class AliRawRootdDB : public AliRawDB {
public:
- AliRawRootdDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
+ AliRawRootdDB(AliRawEvent *event,
+#ifdef USE_HLT
+ AliESD *esd,
+#endif
+ Double_t maxsize, Int_t compress);
~AliRawRootdDB() { Close(); }
void Close();
$(DICT): $(HDRS)
@echo "Generating dictionary ..."
- rootcint -f $(DICT) -c $(ROOTH) $(HDRS)
+ rootcint -f $(DICT) -c $(CXXFLAGS) $(ROOTH) $(HDRS)
$(DICTO): $(DICT)
$(CXX) $(NOOPT) $(CXXFLAGS) -c $(DICT)
endif
ifneq ($(findstring hlt,$(MAKECMDGOALS)),)
-CXXFLAGS += -DUSE_HLT -I$(ALITPC)
-LIBS += -L$(ALITPC) -lSTEER -lTPC
+include ../HLT/hlt.conf
+CXXFLAGS += -DUSE_HLT ${HLTDEFS} -I${ALICE_ROOT}/include -I../HLT/src -I../HLT/hough -I../HLT/comp
+LIBS += -lEG -lVMC -lGeom -lThread -L../lib/tgt_linuxDEBUG -lSTEER -lRAW -lTPCbase -lTPCsim -lTPCrec -lCONTAINERS -lAliL3Src -lAliL3Misc -lAliL3Hough -lAliL3Comp
endif
##### DATE #####
ifdef DATE_ROOT
-DATEFLAGS = -DALI_DATE -D${DATE_SYS} -DDATE_SYS=${DATE_SYS} -Dlong32=${DATE_LONG32} -Dlong64=${DATE_LONG64} -DdatePointer=${DATE_POINTER} -I${DATE_COMMON_DEFS}
+DATEFLAGS = -DALI_DATE -D${DATE_SYS} -DDATE_SYS=${DATE_SYS} -Dlong32=${DATE_LONG32} -Dlong64='${DATE_LONG64}' -DdatePointer=${DATE_POINTER} -I${DATE_COMMON_DEFS}
CXXFLAGS += $(DATEFLAGS)
endif
##### DEPENDENCIES #####
-include Make-depend
+#include Make-depend
+include HLT/hlt.conf
+
+EDEFINE := ${HLTDEFS}
+PACKCXXFLAGS := ${HLTCXXFLAGS}
+PACKCFLAGS := ${HLTCLFAGS}
+PACKDCXXFLAGS:= ${HLTDCXXFLAGS}
+
SRCS:= AliRawEventHeader.cxx AliRawEquipmentHeader.cxx \
AliRawData.cxx AliRawEquipment.cxx AliRawEvent.cxx \
AliStats.cxx AliRawDB.cxx \
EHDRS:=$(ROOTSYS)/include/TH1F.h
-EDEFINE:= -DUSE_RDM
+EINCLUDE:=HLT/src HLT/hough HLT/comp
+
+EDEFINE+= -DUSE_RDM -DUSE_HLT
DHDR:= RAWLinkDef.h
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff