fEventID(),
fCurrentBlk(0),
fAsyncBlockList(NULL),
- fEventBuffer(NULL),
+ fBlockList(NULL),
+ fEventBuffer(NULL),
fBufferTopIdx(-1),
fBufferLowIdx(-1),
fCurrentBufferIdx(-1),
fNavigateBufferIdx(-1),
+ fNEventsAvailable(0),
fConnected(kFALSE),
fTriggerString("ALL"),
fNEventsNotTriggered(0),
- fRetryNextEvent(kFALSE) {
+ fRetryNextEvent(kFALSE),
+ fIsBlockOwner(kTRUE)
+{
// see header file for class documentation
// or
// refer to README to build package
}
fEventBuffer = NULL;
+ if(fBlockList) {
+ fBlockList->Clear();
+ delete fBlockList;
+ }
+ fBlockList = NULL;
+
if ( fAsyncBlockList ) {
fAsyncBlockList->Clear();
delete fAsyncBlockList;
Int_t AliHLTHOMERManager::Initialize() {
// see header file for class documentation
+ HLTInfo("Initializing");
+
Int_t iResult = 0;
// -- Initialize ProxyHandler
iResult = fProxyHandler->Initialize();
if (iResult)
HLTError(Form("Initialize of ProxyHandler failed."));
- }
- else {
+
+ } else {
iResult = -1;
HLTError(Form("Creating of ProxyHandler failed."));
}
fAsyncBlockList->SetOwner(kTRUE);
}
+ //initialize normal block list
+ if( !fBlockList ) {
+ fBlockList = new TList();
+ fBlockList->SetOwner(kFALSE);
+ }
+
// -- Initialize Event Buffer and EventID array
if ( !fEventBuffer ) {
fEventBuffer = new TClonesArray( "TList", BUFFERSIZE );
// see header file for class documentation
Int_t iResult = 0;
-
+
if ( fSourceList != NULL )
delete fSourceList;
fSourceList = NULL;
for (UInt_t idx = 0; idx < sourceCount; idx++) {
+ if (sourcePorts[idx] > 60000)
+ continue;
+
HLTInfo(Form("Adding source %d as %s : %d", idx, sourceHostnames[idx], sourcePorts[idx]));
fReaderList->Add(dynamic_cast<TObject*>(fLibManager->OpenReader(sourceHostnames[idx], sourcePorts[idx])));
} // while( (object = next()) ) {
- // -- Check if NextEvent should be recalled,
- // to catch the next event with a trigger
- if ( fRetryNextEvent ) {
- usleep(1000000);
- fRetryNextEvent = kFALSE;
-
- HLTInfo(Form("Checked trigger of %d events, without triggering", fNEventsNotTriggered));
- return NextEvent();
- }
- else
- return 0;
+ return 0;
}
/* ---------------------------------------------------------------------------------
Int_t AliHLTHOMERManager::NavigateEventBufferFwd() {
// see header file for class documentation
+ HLTInfo(Form("fNavigateBufferIdx: %d, fCurrentBufferIdx %d, fBufferTopIdx %d", fNavigateBufferIdx, fCurrentBufferIdx, fBufferTopIdx));
+
// -- reached the top of the buffer
if ( fNavigateBufferIdx == fBufferTopIdx )
return -1;
newIdx = 0;
fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
+ fNEventsAvailable -= 1;
- return newIdx;
+ HLTInfo(Form("fNavigateBufferIdx: %d, fCurrentBufferIdx %d, fBufferTopIdx %d", fNavigateBufferIdx, fCurrentBufferIdx, fBufferTopIdx));
+
+
+ return 0;
}
///////////////////////////////////////////////////////////////////////////////////
TIter next( fSourceList );
while ( ( source = dynamic_cast<AliHLTHOMERSourceDesc*>(next()) ) ) {
+ ///Don't use sources from dev cluster
+ if(source->GetPort() > 60000) continue;
+
// -- If detector NO detector name given
if ( ! detector.CompareTo("ALL") ) {
// -- Continue if source is not selected
fBufferLowIdx = 0;
}
- fNavigateBufferIdx = fCurrentBufferIdx = fBufferTopIdx;
// -- Fill EventID
fEventID[fBufferTopIdx] = eventID;
// -- Clear Buffer slot
(reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Clear();
-
+ if(fBlockList->IsOwner()) HLTWarning("block list is owner!!");
+ HLTInfo(Form("fBlockList size %d", fBlockList->GetSize()));
+ //fBlockList->Clear();
+ fBlockList = new TList();
+ HLTInfo(Form("fBlockList size %d", fBlockList->GetSize()));
GetFirstBlk();
// -- Check sources list if block is requested
if ( CheckIfRequested( block ) ) {
(reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );
+ fBlockList->Add(block);
}
else {
// XXX HACK Jochen
(reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );
+ fBlockList->Add(block);
// delete block;
// block = NULL;
}
} while( GetNextBlk() );
+ //We have one more event available
+ fNEventsAvailable++;
+ HLTInfo(Form("fNEventsAvailable %d", fNEventsAvailable));
return;
}
GetFirstBlk();
- // -- Fill block list
do {
- // -- Create new block
AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();
block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),
GetBlkType(), GetBlkSpecification() );
+
+ fAsyncBlockList->Add( block );
+
// -- Check sources list if block is requested
- if ( CheckIfRequested( block ) )
- fAsyncBlockList->Add( block );
- else {
- // XXX HACK Jochen
- fAsyncBlockList->Add( block );
- // delete block;
- // block = NULL;
- }
+ // if ( CheckIfRequested( block ) )
+ // fAsyncBlockList->Add( block );
+ // else {
+ // // XXX HACK Jochen
+ // }
} while( GetNextBlk() );
return;
}
-//##################################################################################
+//__________________________________________________________________________________
+void AliHLTHOMERManager::AddToBlockList() {
+ // see header file for class documentation
+ HLTInfo("Adding blocks to the synchroneous block list");
+
+
+ GetFirstBlk();
+ do {
+
+ AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();
+ block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),
+ GetBlkType(), GetBlkSpecification() );
+ fBlockList->Add( block );
+
+ } while( GetNextBlk() );
+}
+
+//__________________________________________________________________________________
TList* AliHLTHOMERManager::GetBlockListEventBuffer( Int_t idx ) {
// see header file for class documentation
- if ( idx == -1 )
+ if(fBlockList)
+ return fBlockList;
+ else
return NULL;
+ if ( idx == -1 )
+ return NULL;
+
return reinterpret_cast<TList*>((*fEventBuffer)[idx]);
}
-/*
- * ---------------------------------------------------------------------------------
- * Block Handling - private
- * ---------------------------------------------------------------------------------
- */
-//##################################################################################
+//__________________________________________________________________________________
Int_t AliHLTHOMERManager::HandleBlocks() {
// see header file for class documentation
}
HLTInfo(Form("Event 0x%016lX (%lu) with %lu blocks", eventID, eventID, fNBlks));
-
-#if EVE_DEBUG
- // Loop for Debug only
- for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {
- Char_t tmp1[9], tmp2[5];
- memset( tmp1, 0, 9 );
- memset( tmp2, 0, 5 );
- void *tmp11 = tmp1;
- ULong64_t* tmp12 = static_cast<ULong64_t*>(tmp11);
- *tmp12 = fCurrentReader->GetBlockDataType(ii);
- void *tmp21 = tmp2;
- ULong_t* tmp22 = static_cast<ULong_t*>(tmp21);
- *tmp22 = fCurrentReader->GetBlockDataOrigin(ii);
- HLTInfo(Form( "Block %lu length: %lu - type: %s - origin: %s - spec 0x%08X",
- ii, fCurrentReader->GetBlockDataLength(ii), tmp1, tmp2, fCurrentReader->GetBlockDataSpec(ii) ));
- } // end for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {
-#endif
- // -- Check if blocks are from syncronous source
+ if ( IsSyncBlocks() ) {
+ //AddBlockListToBuffer();
+ AddToBlockList();
+ } else {
+ AddToAsyncBlockList();
+ }
- if ( IsSyncBlocks() )
- AddBlockListToBuffer();
- else
- AddToAsyncBlockList();
-
return iResult;
}
-//##################################################################################
+//__________________________________________________________________________________
Bool_t AliHLTHOMERManager::IsSyncBlocks() {
// see header file for class documentation
/** @file AliHLTHOMERManager.h
@author Jochen Thaeder
- @date
+ @author Svein Lindal <slindal@fys.uio.no>
+ @date October 2010
@brief Manager for HOMER in aliroot
*/
#include "AliHLTLoggingVariadicFree.h"
-#define BUFFERSIZE 10
+#define BUFFERSIZE 15
class AliHLTHOMERLibManager;
{
public:
- /*
- * ---------------------------------------------------------------------------------
- * Constructor / Destructor
- * ---------------------------------------------------------------------------------
- */
-
/** default constructor */
AliHLTHOMERManager();
/** destructor */
virtual ~AliHLTHOMERManager();
- /** Initialize
- * @return 0 on success, <0 for failure
- */
+ /** Initialize */
Int_t Initialize();
- /*
- * ---------------------------------------------------------------------------------
- * Source Handling - public
- * ---------------------------------------------------------------------------------
- */
-
- /** Create Sources List from HOMER-Proxy
- * @return 0 on success, <0 for failure, 1 for no active service
- */
+ /** Create Sources List from HOMER-Proxy */
virtual Int_t CreateSourcesList();
- /** Set state of a source
- * @param source Pointer to AliHLTHOMERSourceDesc object.
- * @param state New (selected/not selected) state.
- */
+ /** Set state of a source */
void SetSourceState( AliHLTHOMERSourceDesc* source, Bool_t state);
/** Get pointer to source List */
TList* GetSourceList() { return fSourceList; }
- /*
- * ---------------------------------------------------------------------------------
- * Connection Handling - public
- * ---------------------------------------------------------------------------------
- */
-
- /** Connect to HOMER sources, of a certain detector.
- * which gets created when state has changed
- * @param detector Detector to be connected to
- * @return 0 on success, <0 for failure
- */
+ /** Connect to HOMER sources, of a certain detector. */
Int_t ConnectHOMER( TString detector="ALL" );
/** Disconnect from HOMER sources */
void DisconnectHOMER();
- /** Reconnect from HOMER sources
- * @param detector Detector to be connected to
- * @return 0 on success, <0 for failure
- */
+ /** Reconnect from HOMER sources */
Int_t ReconnectHOMER( TString detector);
- /*
- * ---------------------------------------------------------------------------------
- * Event Handling - public
- * ---------------------------------------------------------------------------------
- */
- /** Loads the next Event, after being connected
- * @return 0 on success, <0 for failure
- */
+ /** Loads the next Event, after being connected */
virtual Int_t NextEvent();
- /** Loads the next Cycle, after being connected
- * @return 0 on success, <0 for failure
- */
+ /** Loads the next Cycle, after being connected */
virtual Int_t NextCycle() { return NextEvent(); }
/** Get event ID */
ULong_t GetEventID() { return fEventID[fCurrentBufferIdx]; }
- /* ---------------------------------------------------------------------------------
- * Buffer Handling - public
- * ---------------------------------------------------------------------------------
- */
-
- /** Get pointer to last requested BlockList
- * @return ptr to buffer, NULL if buffer boundary reached
- */
- TList* GetBlockList() { return GetBlockListEventBuffer(fCurrentBufferIdx); }
-
- /** Get pointer to last asynchrounous BlockList
- * @return ptr to buffer, NULL if none present
- */
+ Int_t GetNAvailableEvents() { return fNEventsAvailable;}
+
+ /** Get pointer to last requested BlockList */
+ TList* GetBlockList() { return fBlockList; }
TList* GetAsyncBlockList() { return fAsyncBlockList; }
- /** Navigate backwards in event buffer
- * @return index in buffer, -1 if boundary reached
- */
+ /** Navigate backwards in event buffer */
Int_t NavigateEventBufferBack();
- /** Navigate forwards in event buffer
- * @return index in buffer, -1 if boundary reached
- */
+ /** Navigate forwards in event buffer */
Int_t NavigateEventBufferFwd();
- /* ---------------------------------------------------------------------------------
- * Trigger Handling - public
- * ---------------------------------------------------------------------------------
- */
-
- /** Set and get the string used to select triggers
- * @param triggerString Trigger selection string
- */
+ /** Set and get the string used to select triggers */
void SetTriggerString ( TString triggerString ) { fTriggerString = triggerString; }
/** Get TriggerString */
TString GetTriggerString () { return fTriggerString; }
- ///////////////////////////////////////////////////////////////////////////////////
+ void SetBlockOwner(Bool_t owner) { fBlockList->SetOwner(owner); }
+ Bool_t GetBlockOwner() const { return fBlockList->IsOwner(); }
protected:
/** Dynamic loader manager for the HOMER library */
AliHLTHOMERLibManager* fLibManager; //! transient
- /** Indicates, if a sources have changes,
- * so that one has to reconnect. */
+ /** Indicates, if a sources have changes, so that one has to reconnect. */
Bool_t fStateHasChanged; // see above
- ///////////////////////////////////////////////////////////////////////////////////
+ Bool_t Connected() const { return fConnected; }
private:
/** assignment operator prohibited */
AliHLTHOMERManager& operator=(const AliHLTHOMERManager&);
- /*
- * ---------------------------------------------------------------------------------
- * Connection Handling - private
- * ---------------------------------------------------------------------------------
- */
-
- /** Create a readout list for Hostname and ports
- * @param socurceHostnames Array of selected hostnames
- * @param socurcePorts Array of selected ports
- * @param socurceCount Number of selected hostname:port
- * @param detector detector to be selected
- */
+ //==============Connection to homer ==========================
+
+ /** Create a readout list for Hostname and ports */
void CreateReadoutList( const char** sourceHostnames, UShort_t* sourcePorts,
UInt_t &sourceCount, TString detector );
/** Checks if already connected to HOMER sources */
Bool_t IsConnected() { return fConnected; }
-
- /* ---------------------------------------------------------------------------------
- * Buffer Handling - private
- * ---------------------------------------------------------------------------------
- */
/** Create and add Block List to Buffer */
void AddBlockListToBuffer();
/** Add bocks to asynchronous BlockList */
void AddToAsyncBlockList();
+ void AddToBlockList();
+
- /** Get pointer to block list in event buffer
- * @return ptr to buffer, NULL if not present
- */
+ //============ Block Handling ====================
+
+ /** Get pointer to block list in event buffer */
TList* GetBlockListEventBuffer( Int_t idx );
- /*
- * ---------------------------------------------------------------------------------
- * Block Handling - private
- * ---------------------------------------------------------------------------------
- */
-
/** Get Number of blocks in current event */
ULong_t GetNBlks() { return fNBlks; }
- // ----------------------------------------------------
-
- /** Handle Blocks and fill them in event buffer or asyncronous BlockList
- * @return 0 on success, <0 for failure
- */
+ /** Handle Blocks and fill them in event buffer or asyncronous BlockList */
Int_t HandleBlocks();
- /** Check is block are from syncronous source
- * @return kTRUE, if asyncronous kFALSE
- */
+ /** Check is block are from syncronous source */
Bool_t IsSyncBlocks();
- // ----------------------------------------------------
-
- /** Get pointer to block ndx in current event
- * @param ndx Block index
- * @return returns pointer to blk, NULL if no block present
- */
+ /** Get pointer to block ndx in current event */
void* GetBlk( Int_t ndx );
/** Get pointer to current block in current event */
/** Get next block in current event */
void* GetNextBlk() { return GetBlk(++fCurrentBlk); }
- // ----------------------------------------------------
-
- /** Get size of block ndx
- * @param ndx Block index
- * @return returns size blk, 0 otherwise
- */
+ /** Get size of block ndx */
ULong_t GetBlkSize( Int_t ndx );
/** Get size of current block */
ULong_t GetBlkSize() { return GetBlkSize( fCurrentBlk ); }
- // ----------------------------------------------------
-
- /** Get origin of block ndx
- * @param ndx Block index
- * @return origin of block
- */
+ /** Get origin of block ndx */
TString GetBlkOrigin( Int_t ndx );
/** Get origin of current block */
TString GetBlkOrigin(){ return GetBlkOrigin( fCurrentBlk ); }
- // ----------------------------------------------------
-
- /** Get type of block ndx
- * @param ndx Block index
- * @return type of block
- */
+ /** Get type of block ndx */
TString GetBlkType( Int_t ndx );
/** Get type of current block */
TString GetBlkType() { return GetBlkType( fCurrentBlk ); }
- // ----------------------------------------------------
-
- /** Get specification of block ndx
- * @param ndx Block index
- * @return specification of block
- */
+ //Get specification of block at ndx in bufferindex
ULong_t GetBlkSpecification( Int_t ndx );
/** Get specification of current block */
ULong_t GetBlkSpecification() { return GetBlkSpecification( fCurrentBlk ); }
- // ----------------------------------------------------
-
- /** Checks if current Block should was requested
- * @return returns kTRUE, if block should was requested
- */
+ //Check if requested in eve
Bool_t CheckIfRequested( AliHLTHOMERBlockDesc* block );
-
- /* ---------------------------------------------------------------------------------
- * Trigger Handling - private
- * ---------------------------------------------------------------------------------
- */
-
- /** Loops over the data block from all the readers in the readerlist until
- * a triggerdecsision has been found
- * Locates the triggerdecision required by fTriggerString and checks if it triggered
- * @return returns kTRUE, if event was triggered, kFALSE otherwise
- */
+
+ //Check trigger decision
Bool_t CheckTriggerDecision();
-
- /*
- * ---------------------------------------------------------------------------------
- * Members - private
- * ---------------------------------------------------------------------------------
- */
-
- /** Proxy Handler to get the list of sources */
- AliHLTHOMERProxyHandler *fProxyHandler; //! transient
-
- // == connection ==
-
- /** Pointer to current HOMER reader */
- AliHLTHOMERReader *fCurrentReader; //! transient
-
- /** List to pointer of HOMER readers */
- TList *fReaderList; //! transient
+
+ AliHLTHOMERProxyHandler * fProxyHandler; /** Proxy Handler to get the list of sources */ //! transient
+ AliHLTHOMERReader* fCurrentReader; /** Pointer to current HOMER reader */ //! transient
+ TList* fReaderList; /** List to pointer of HOMER readers */
// == sources ==
-
- /** List to HOMER sources */
- TList *fSourceList; //! transient
-
- // == events ==
-
- /** Number of blockes in current event */
- ULong_t fNBlks; // see above
-
- /** EventID of current event */
- ULong64_t fEventID[BUFFERSIZE]; // see above
-
- /** Current block in current event */
- ULong_t fCurrentBlk; // see above
-
- // == Asynchronous BlockList ==
-
- /** List containing asychronous blocks */
- TList *fAsyncBlockList; // see above
+ TList* fSourceList; /** List to HOMER sources */
+ ULong_t fNBlks; /** Number of blockes in current event */
+ ULong64_t fEventID[BUFFERSIZE]; /** EventID of current event */
+ ULong_t fCurrentBlk; /** Current block in current event */
+ TList* fAsyncBlockList; /** List containing asychronous blocks */
+ TList* fBlockList; /** List containing asychronous blocks */
// == event buffer ==
-
- /** Event Buffer */
- TClonesArray *fEventBuffer; // see above
-
- /** Buffer index to last received event */
- Int_t fBufferTopIdx; // see above
-
- /** Buffer index to last received event */
- Int_t fBufferLowIdx; // see above
-
- /** Buffer index to current event */
- Int_t fCurrentBufferIdx; // see above
-
- /** Navigate index through event buffer */
- Int_t fNavigateBufferIdx; // see above
+ TClonesArray * fEventBuffer; /** Event Buffer */
+ Int_t fBufferTopIdx; /** Buffer index to last received event */
+ Int_t fBufferLowIdx; /** Buffer index to last received event */
+ Int_t fCurrentBufferIdx; /** Buffer index to current event */
+ Int_t fNavigateBufferIdx; // Navigate index through event buffer */
+ Int_t fNEventsAvailable; //Number of available events
- // == states ==
+ Bool_t fConnected; /** Shows connection status */
+ TString fTriggerString; /** String indicating which trigger should be used to select events */
+ Int_t fNEventsNotTriggered; /** Number Events not triggered, before next triggered event is found */
- /** Shows connection status */
- Bool_t fConnected; // see above
-
- // == trigger selection ==
-
- /** String indicating which trigger should be used to select events */
- TString fTriggerString; // see above
-
- /** Number Events not triggered, before next triggered event is found */
- Int_t fNEventsNotTriggered; // see above
+ Bool_t fRetryNextEvent; /** Retry reading next event */
- /** Retry reading next event */
- Bool_t fRetryNextEvent; // see above
+ Bool_t fIsBlockOwner;
ClassDef(AliHLTHOMERManager, 1); // Manage connections to HLT data-sources.
};
//##################################################################################
Int_t AliHLTHOMERProxyHandler::Initialize() {
// see header file for class documentation
-
- Int_t iResult = 0 ;
-
IdentifyRealm();
-
- return iResult;
+ return 0;
}
/*
fRealm = kLoc;
}
+ //fRealm = kLoc;
+
return;
}
ClassImp(AliHLTEveAny);
AliHLTEveAny::AliHLTEveAny() :
- AliHLTEveBase()
+ AliHLTEveBase("Other")
{
// Constructor.
SetDetector("Any detector");
#include "AliHLTEveBase.h"
#include "AliHLTHOMERBlockDesc.h"
-//#include "TCollection.h"
-#include "AliEveHOMERManager.h"
+#include "TCollection.h"
+#include "TObjArray.h"
+#include "AliEveHLTEventManager.h"
#include "TCanvas.h"
#include "TEveWindow.h"
#include "TEveManager.h"
ClassImp(AliHLTEveBase);
-AliHLTEveBase::AliHLTEveBase() :
+AliHLTEveBase::AliHLTEveBase(const char * name) :
+ TEveElementList(name),
fEventManager(NULL),
fCanvas(NULL),
fHistoCount(0),
void AliHLTEveBase::AddHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount ) {
//See header file for documentation
-
+
+
if ( ! block->GetClassName().CompareTo("TObjArray")) {
+
+ // // TObjArray * blocks = dynamic_cast<TObjArray*>(block->GetTObject());
+ // // TIterator* next = block::MakeIterator();
+
TIter next((TObjArray*)(block->GetTObject()));
TObject *object;
#include "Rtypes.h"
#include "TString.h"
-
+#include "TEveElement.h"
class AliHLTHOMERBlockDesc;
-class AliEveHOMERManager;
+class AliEveHLTEventManager;
class TCanvas;
-class AliHLTEveBase{
+class AliHLTEveBase : public TEveElementList {
public:
/** Default constructor prohibited **/
- AliHLTEveBase();
+ AliHLTEveBase(const char * name);
/** Destructor **/
virtual ~AliHLTEveBase();
/** Reset the elements before reading in new event, to be implemented by children */
virtual void ResetElements() = 0;
- /** Set the parent AliEveHOMERManager instance */
- void SetEventManager(AliEveHOMERManager * em) { fEventManager = em; };
+ /** Set the parent AliEveHLTEventManager instance */
+ void SetEventManager(AliEveHLTEventManager * em) { fEventManager = em; };
TString GetDetector() const {return fDetector;}
- AliEveHOMERManager * fEventManager; //Pointer to AliEveHOMERManager instance
+ AliEveHLTEventManager * fEventManager; //Pointer to AliEveHLTEventManager instance
TCanvas * fCanvas; //Canvas for histograms
Int_t fHistoCount; //Counter for histograms, to track where to draw the next one
private:
+ /** Default constructor prohibited **/
+ AliHLTEveBase();
/** copy constructor prohibited */
AliHLTEveBase(const AliHLTEveBase&);
/** assignment operator prohibited */
/// @author Svein Lindal <slindal@fys.uio.no>
/// @brief Calorimeter base class for the HLT EVE display
+#include "TCollection.h"
+#include "TObjArray.h"
#include "AliHLTEveCalo.h"
#include "AliHLTHOMERBlockDesc.h"
#include "TCanvas.h"
#include "TEveBoxSet.h"
#include "AliPHOSGeometry.h"
#include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "AliHLTCaloDigitDataStruct.h"
#include "AliHLTCaloClusterDataStruct.h"
#include "TString.h"
#include "TH2F.h"
#include "TH1F.h"
-
-
+#include "TRefArray.h"
+#include "AliESDEvent.h"
+#include "AliESDCaloCluster.h"
ClassImp(AliHLTEveCalo);
AliHLTEveCalo::AliHLTEveCalo(Int_t nm, TString name) :
- AliHLTEveBase(),
+ AliHLTEveBase(name),
fBoxSetDigits(NULL),
fBoxSetClusters(NULL),
- fElementList(NULL),
fNModules(nm),
+ fClustersArray(NULL),
fName(name),
fPadTitles(NULL),
fInvMassCanvas(NULL)
fPadTitles[i] = "";
}
+ fClustersArray = new TRefArray();
}
delete fBoxSetClusters;
fBoxSetClusters = NULL;
- if(fElementList) {
-
- delete fElementList;
- }
- fElementList = NULL;
if(fPadTitles)
delete [] fPadTitles;
} else {
- if( !fElementList ) {
- fElementList = CreateElementList();
- fEventManager->GetEveManager()->AddElement(fElementList);
- }
if ( block->GetDataType().CompareTo("CALOCLUS") == 0 ){
//cout <<"Skipping calo clusters"<<endl;
// }
+void AliHLTEveCalo::ProcessEvent(AliESDEvent * event) {
+ //see header file for documentation
+
+
+
+ Int_t nClusters = GetClusters(event, fClustersArray);
+ for(int ic = 0; ic < nClusters; ic++) {
+ AliESDCaloCluster * cluster = dynamic_cast<AliESDCaloCluster*>(fClustersArray->At(ic));
+ ProcessESDCluster(cluster);
+ }
+
+}
+
void AliHLTEveCalo::ProcessClusters(AliHLTHOMERBlockDesc* block) {
//See header file for documentation
-
AliHLTCaloClusterHeaderStruct *dh = reinterpret_cast<AliHLTCaloClusterHeaderStruct*> (block->GetData());
AliHLTCaloClusterReader * clusterReader = new AliHLTCaloClusterReader();
clusterReader->SetMemory(dh);
#include "AliHLTEveBase.h"
#include "TString.h"
+class AliESDEvent;
+class AliESDCaloCluster;
+class TRefArray;
class TEveElementList;
class TEveBoxSet;
class AliHLTHOMERBlockDesc;
/** inherited from AliHLTEveBase */
void ResetElements();
+ /// Process esd event
+ void ProcessEvent(AliESDEvent * event);
protected :
/** Create the elementlist */
- virtual TEveElementList * CreateElementList() = 0;
+ virtual void CreateElementList() = 0;
/** Add clusters boxset to eve display */
virtual void AddClusters(Float_t * pos, Int_t module, Float_t energy) = 0;
/** Add digits boxset to eve display */
virtual void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy) = 0;
+
+ virtual void ProcessESDCluster(AliESDCaloCluster * cluster) = 0;
+
+
/** Process clusters block */
void ProcessClusters(AliHLTHOMERBlockDesc * block);
/** Process histogram block */
void ProcessHistogram(AliHLTHOMERBlockDesc * block );
+
/** Process and draw histograms */
void AddHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount );
+
Int_t GetPadNumber(TString name);
+ virtual Int_t GetClusters (AliESDEvent * event, TRefArray * clusters) = 0;
+
TEveBoxSet * fBoxSetDigits; //Boxset for clusters and digist
TEveBoxSet * fBoxSetClusters; //Boxset for clusters and digist
-
- TEveElementList * fElementList; //Element list to contain the clusters
const Int_t fNModules; //Number of modules in calorimeter
+
+ TRefArray * fClustersArray;
+
+
private:
/** default constructor prohibited */
#include "TEveBoxSet.h"
#include "AliPHOSGeometry.h"
#include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "AliHLTCaloDigitDataStruct.h"
#include "AliHLTCaloClusterDataStruct.h"
#include "TEveTrans.h"
#include "TGeoNode.h"
#include "AliEMCALGeoUtils.h"
+#include "TGeoManager.h"
+
+#include "TEveGeoShapeExtract.h"
+#include "TEveGeoNode.h"
ClassImp(AliHLTEveEmcal)
{
//Constructor
fGeoUtils = new AliEMCALGeoUtils("EMCAL_COMPLETE","EMCAL");
+ CreateElementList();
}
//Destructor, not implemented
}
-TEveElementList * AliHLTEveEmcal::CreateElementList() {
+void AliHLTEveEmcal::CreateElementList() {
- TGeoNode * gEMCALNode = fEventManager->GetGeoManager()->GetTopVolume()->FindNode("XEN1_1");
- fElementList = new TEveElementList("EMCAL Digits / Clusters");
- fElementList->SetTitle("Tooltip");
+ //TEveGeoShapeExtract * shape = new TEveGeoShapeExtract();
+ TGeoNode * gEMCALNode = gGeoManager->GetTopVolume()->FindNode("XEN1_1");
+ //TEveGeoNode * eveNode = new TEveGeoNode(gEMCALNode);
+ //TEveGeoShapeExtract* juice = eveNode->DumpShapeTree(this, shape, kFALSE);
+ //juice->Dump();
+ //eveNode->WriteExtract("out.root", kFALSE);
+
//gStyle->SetPalette(1, 0);
TEveRGBAPalette* pal = new TEveRGBAPalette(0, 512);
fBoxSetDigits[sm].RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
fBoxSetDigits[sm].SetPalette(pal);
- fElementList->AddElement(&fBoxSetDigits[sm]);
+ AddElement(&fBoxSetDigits[sm]);
//Clusters
fBoxSetClusters[sm].SetTitle(Form("Clusters Module %d", sm));
// fBoxSetClusters[sm].RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
fBoxSetClusters[sm].SetPalette(pal);
- fElementList->AddElement(&fBoxSetClusters[sm]);
+ AddElement(&fBoxSetClusters[sm]);
}
-
- return fElementList;
}
void AliHLTEveEmcal::AddClusters(Float_t * pos, Int_t module, Float_t energy) {
#ifndef ALIHLTEVEEMCAL_H
#define ALIHLTEVEEMCAL_H
+#include "AliESDEvent.h"
#include "AliHLTEveCalo.h"
class TEveElementList;
class AliEMCALGeoUtils;
void AddClusters(Float_t * pos, Int_t module, Float_t energy);
void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy);
+
+ Int_t GetClusters(AliESDEvent * event, TRefArray * clusters) { return event->GetEMCALClusters(clusters); }
- TEveElementList * CreateElementList();
+ void ProcessESDCluster(AliESDCaloCluster * cluster) { if(cluster) return;}
+
+ void CreateElementList();
AliEMCALGeoUtils * fGeoUtils;
#include "AliHLTEveHLT.h"
#include "AliHLTHOMERBlockDesc.h"
#include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "TEvePointSet.h"
#include "TEveTrack.h"
#include "AliEveMagField.h"
#include "TH1F.h"
#include "TH2F.h"
+#include "TThread.h"
ClassImp(AliHLTEveHLT)
AliHLTEveHLT::AliHLTEveHLT() :
- AliHLTEveBase(),
+ AliHLTEveBase("TPC tracks"),
fTrueField(kFALSE),
fUseIpOnFailedITS(kFALSE),
fUseRkStepper(kFALSE),
fTrackList(NULL),
+ fOldTrackList(NULL),
fPointSetVertex(NULL),
fTrCanvas(NULL),
fHistPt(NULL),
fHistMult(NULL)
{
// Constructor.
- CreateHistograms();
-
+ //CreateHistograms();
}
AliHLTEveHLT::~AliHLTEveHLT()
fTrackList = NULL;
}
-void AliHLTEveHLT::CreateHistograms(){
+void AliHLTEveHLT::ProcessEsdEvent( AliESDEvent * esd ) {
//See header file for documentation
- fHistPt = new TH1F("fHistPt", "transverse momentum", 100, 0, 10); // KK
- fHistP = new TH1F("fHistP", "signed momentum", 100,-7, 7);
- fHistEta = new TH1F("fHistEta", "pseudorapidity", 100,-2, 2);
- fHistTheta = new TH1F("fHistTheta", "polar angle", 180, 0,180);
- fHistPhi = new TH1F("fHistPhi", "azimuthal angle", 180, 0,360);
- fHistnClusters = new TH1F("fHistnClusters","TPC clusters per track", 160, 0,160);
- fHistMult = new TH1F("fHistMult", "event track multiplicity",50, 0, 50);
-
- fHistPt ->SetXTitle("p_{t} (GeV/c)"); // KK
- fHistP ->SetXTitle("P*charge (GeV/c)");
- fHistEta ->SetXTitle("#eta");
- fHistTheta->SetXTitle("#theta (degrees)");
- fHistPhi ->SetXTitle("#phi (degrees)");
-
+ if(!fTrackList) CreateTrackList();
+ if(!fPointSetVertex) CreateVertexPointSet();
+ ProcessEsdEvent(esd, fTrackList);
+
}
-
+///_____________________________________________________________________
void AliHLTEveHLT::ProcessBlock(AliHLTHOMERBlockDesc * block) {
//See header file for documentation
if ( ! block->GetDataType().CompareTo("ALIESDV0") ) {
fCanvas->Divide(3, 2);
}
ProcessHistograms( block , fCanvas);
- }
-
+ }
}
-
+///____________________________________________________________________________
void AliHLTEveHLT::UpdateElements() {
//See header file for documentation
- if(fCanvas) fCanvas->Update();
- DrawHistograms();
+ //if(fCanvas) fCanvas->Update();
+ //DrawHistograms();
if(fTrackList) fTrackList->ElementChanged();
if(fPointSetVertex) fPointSetVertex->ResetBBox();
}
-
+///_________________________________________________________________________________
void AliHLTEveHLT::ResetElements(){
- //See header file for documentation
- if(fTrackList) fTrackList->DestroyElements();
+ //See header file for documentation
+
+ cout << "destroy"<<endl;
+ if(fTrackList) {
+ RemoveElement(fTrackList);
+ fTrackList = NULL;
+ }
+
if(fPointSetVertex) fPointSetVertex->Reset();
+ cout<< "reset done"<<endl;
fHistoCount = 0;
}
+///_____________________________________________________________________________________
+void * AliHLTEveHLT::DestroyGarbage(void * arg) {
+ AliHLTEveHLT * hlt = reinterpret_cast<AliHLTEveHLT*>(arg);
+ if(hlt) hlt->DestroyOldTrackList();
+ return (void*)0;
+}
+///_____________________________________________________________________________________
+void AliHLTEveHLT::DestroyOldTrackList() {
+ cout << "Destroying the old tracklist's elements"<<endl;
+ fOldTrackList->DestroyElements();
+ cout << "Destroying the old tracklist itself"<<endl;
+ fOldTrackList->Destroy();
+}
+
+///_____________________________________________________________________________________
void AliHLTEveHLT::ProcessHistograms(AliHLTHOMERBlockDesc * block, TCanvas * canvas) {
//See header file for documentation
if ( ! block->GetClassName().CompareTo("TH1F")) {
}
}
canvas->cd();
-
-
-
-
}
+
void AliHLTEveHLT::CreateTrackList() {
//See header file for documentation
fTrackList = new TEveTrackList("ESD Tracks");
fTrackList->SetMainColor(6);
- gEve->AddElement(fTrackList);
+ AddElement(fTrackList);
}
+
void AliHLTEveHLT::CreateVertexPointSet() {
//See header file for documentation
fPointSetVertex = new TEvePointSet("Primary Vertex");
fPointSetVertex->SetMainColor(6);
fPointSetVertex->SetMarkerStyle((Style_t)kFullStar);
- gEve->AddElement(fPointSetVertex);
+ AddElement(fPointSetVertex);
}
//See header file for documentation
AliESDEvent* esd = (AliESDEvent *) (block->GetTObject());
+ if (!esd) return;
+
+ ProcessEsdEvent(esd, cont);
+}
+
+void AliHLTEveHLT::ProcessEsdEvent(AliESDEvent * esd, TEveTrackList * cont) {
+
esd->GetStdContent();
+ cout << esd->GetEventNumberInFile() << " " << esd->GetNumberOfCaloClusters() << endl;
+
+ //fEventManager->SetRunNumber(esd->GetRunNumber());
+
Double_t vertex[3];
const AliESDVertex * esdVertex = esd->GetPrimaryVertex();
AliEveTrack* track = dynamic_cast<AliEveTrack*>(MakeEsdTrack(esd->GetTrack(iter), cont));
cont->AddElement(track);
- fHistPt->Fill(esd->GetTrack(iter)->Pt()); // KK
- fHistP->Fill(esd->GetTrack(iter)->P()*esd->GetTrack(iter)->Charge());
- fHistEta->Fill(esd->GetTrack(iter)->Eta());
- fHistTheta->Fill(esd->GetTrack(iter)->Theta()*TMath::RadToDeg());
- fHistPhi->Fill(esd->GetTrack(iter)->Phi()*TMath::RadToDeg());
- if(esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin || (esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin && esd->GetTrack(iter)->GetStatus()&AliESDtrack::kITSin)){
- fHistnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());
- }
+ // fHistPt->Fill(esd->GetTrack(iter)->Pt()); // KK
+ // fHistP->Fill(esd->GetTrack(iter)->P()*esd->GetTrack(iter)->Charge());
+ // fHistEta->Fill(esd->GetTrack(iter)->Eta());
+ // fHistTheta->Fill(esd->GetTrack(iter)->Theta()*TMath::RadToDeg());
+ // fHistPhi->Fill(esd->GetTrack(iter)->Phi()*TMath::RadToDeg());
+ // if(esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin || (esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin && esd->GetTrack(iter)->GetStatus()&AliESDtrack::kITSin)){
+ // fHistnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());
+ //}
}
- fHistMult->Fill(esd->GetNumberOfTracks()); // KK
+//fHistMult->Fill(esd->GetNumberOfTracks()); // KK
cont->SetTitle(Form("N=%d", esd->GetNumberOfTracks()) );
cont->MakeTracks();
-
+
}
+
void AliHLTEveHLT::DrawHistograms(){
//See header file for documentation
//
for( double dxx=dx/2; TMath::Abs(dxx)>=1.; dxx*=.9 ){
- if( !t.TransportToX(x0+dxx, bz, .99 ) ) continue;
+ if( !t.TransportToX(x0+dxx, bz, .999 ) ) continue;
AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() );
trackParam.GetXYZ(vbuf);
trackParam.GetPxPyPz(pbuf);
//
for( ; TMath::Abs(dx)>=1.; dx*=.9 ){
- if( !t.TransportToX(x0+dx, bz, .99 ) ) continue;
+ if( !t.TransportToX(x0+dx, bz, .999 ) ) continue;
AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() );
trackParam.GetXYZ(vbuf);
trackParam.GetPxPyPz(pbuf);
return s;
}
+
class TString;
class AliExternalTrackParam;
class TH1F;
+class AliESDEvent;
class AliHLTEveHLT : public AliHLTEveBase {
/** inherited from AliHLTEveBase */
void ResetElements();
+ void ProcessEsdEvent( AliESDEvent * esd);
+
+ void DestroyOldTrackList();
+ static void * DestroyGarbage(void * arg);
+
private:
/** copy constructor prohibited */
// Process the ESD block and call the functions necessary to fill the tracklist
void ProcessEsdBlock( AliHLTHOMERBlockDesc * block, TEveTrackList * cont );
+ // Process ESD event
+ void ProcessEsdEvent( AliESDEvent * esd, TEveTrackList * cont);
+
//Set up the track propagator
void SetUpTrackPropagator(TEveTrackPropagator* trkProp, Float_t magF, Float_t maxR);
void DrawHistograms();
+
Bool_t fTrueField; //Use true field?
Bool_t fUseIpOnFailedITS; // Use IP as origin if ITS refit fails?
Bool_t fUseRkStepper; // Use Runge Kutta for something something?
TEveTrackList * fTrackList; //Eve tracklist
+ TEveTrackList * fOldTrackList; //Eve tracklist
TEvePointSet * fPointSetVertex; //Display primary vertex
TCanvas * fTrCanvas; //Canvas for track qa histos
#include "AliHLTEveITS.h"
#include "AliHLTHOMERBlockDesc.h"
#include "TCanvas.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "TH1F.h"
#include "TH2F.h"
ClassImp(AliHLTEveITS)
AliHLTEveITS::AliHLTEveITS(TString name) :
-AliHLTEveBase(),
+AliHLTEveBase(name.Data()),
fName(name),
fPointSet(NULL)
{
else if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
if(!fPointSet) {
fPointSet = CreatePointSet(fName);
- fEventManager->GetEveManager()->AddElement(fPointSet);
+ AddElement(fPointSet);
}
ProcessClusters(block, fPointSet);
}
#include "TCanvas.h"\r
#include "TEveStraightLineSet.h"\r
#include "TEvePointSet.h"\r
-#include "AliEveHOMERManager.h"\r
+#include "AliEveHLTEventManager.h"\r
#include "TEveManager.h"\r
\r
\r
ClassImp(AliHLTEveMuon);\r
\r
AliHLTEveMuon::AliHLTEveMuon() : \r
- AliHLTEveBase(),\r
+ AliHLTEveBase("Muon"),\r
fFullTrackList(NULL),\r
fTracks(NULL),\r
fClusters(NULL)\r
if ( (block->GetDataType().CompareTo("RECHITS") == 0) || (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {\r
if(!fClusters) {\r
fClusters = CreateClusters();\r
- fEventManager->GetEveManager()->AddElement(fClusters);\r
+ AddElement(fClusters);\r
}\r
ProcessClusters( block, fClusters );\r
\r
\r
if ( !fTracks ) {\r
fTracks = CreateTrackSet(); \r
- fEventManager->GetEveManager()->AddElement(fTracks);\r
- gEve->AddElement(fTracks);\r
+ AddElement(fTracks);\r
}\r
\r
ProcessTracks( block, fTracks );\r
\r
if ( !fFullTrackList ) {\r
fFullTrackList = CreateFullTrackList(); \r
- fEventManager->GetEveManager()->AddElement(fFullTrackList); \r
- gEve->AddElement(fFullTrackList);\r
+ AddElement(fFullTrackList);\r
}\r
\r
ProcessFullTracks( block, fFullTrackList );\r
\r
TEveStraightLineSet * AliHLTEveMuon::CreateTrackSet() {\r
// See header file\r
- TEveStraightLineSet * ls = new TEveStraightLineSet("MUON Tracks");\r
- ls->SetMainColor(kRed);\r
- ls->SetLineWidth(3);\r
- return ls;\r
+ TEveStraightLineSet * lineset = new TEveStraightLineSet("MUON Tracks");\r
+ lineset->SetMainColor(kRed);\r
+ lineset->SetLineWidth(3);\r
+ return lineset;\r
}\r
\r
TEveTrackList * AliHLTEveMuon::CreateFullTrackList(){\r
// See header file\r
- TEveTrackList * ls = new TEveTrackList("MUON Full Tracks");\r
- ls->SetMainColor(kBlue);\r
- return ls;\r
+ TEveTrackList * lineset = new TEveTrackList("MUON Full Tracks");\r
+ lineset->SetMainColor(kBlue);\r
+ return lineset;\r
}\r
\r
void AliHLTEveMuon::ProcessHistogram(AliHLTHOMERBlockDesc * block ) {\r
track->MakeESDTrack(muonESDTrack);\r
//track->SetTitle(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));\r
track->SetName(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));\r
- gEve->AddElement(track, fullTracks);\r
+ fullTracks->AddElement(track);\r
\r
mtrack++;\r
}//track loop\r
#include "AliPHOSGeoUtils.h"
#include "AliPHOSGeometry.h"
#include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "AliHLTCaloDigitDataStruct.h"
#include "AliHLTCaloClusterDataStruct.h"
{
// Constructor.
fGeoUtils = new AliPHOSGeoUtils("PHOS", "noCPV");
+ CreateElementList();
+
}
AliHLTEvePhos::~AliHLTEvePhos()
fGeoUtils = NULL;
}
-
-TEveElementList * AliHLTEvePhos::CreateElementList() {
+void AliHLTEvePhos::CreateElementList() {
//See header file for documentation
- TEveElementList * elementList = new TEveElementList("PHOS ");
fBoxSetClusters = new TEveBoxSet[fNModules];
fBoxSetDigits = new TEveBoxSet[fNModules];
for(int im = 0; im < fNModules; im++) {
TEveRGBAPalette* pal = new TEveRGBAPalette(0,512);
- pal->SetLimits(-1, 6);
+ pal->SetLimits(-1, 45);
//Create clusters box set
fBoxSetClusters[im].SetTitle(Form("Clusters Module %d", im));
t.SetupRotation(1, 2, angle );
t.SetPos(center.X(), center.Y(), center.Z());
- elementList->AddElement(&fBoxSetClusters[im]);
+ AddElement(&fBoxSetClusters[im]);
//Create digits box set
t2.SetupRotation(1, 2, angle );
t2.SetPos(center.X(), center.Y(), center.Z());
- elementList->AddElement(&fBoxSetDigits[im]);
+ AddElement(&fBoxSetDigits[im]);
}
- return elementList;
}
void AliHLTEvePhos::AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy) {
fBoxSetDigits[4-module].DigitValue(static_cast<Int_t>(energy));
}
+void AliHLTEvePhos::ProcessESDCluster(AliESDCaloCluster * cluster) {
+
+ Float_t pos[3];
+ cluster->GetPosition(pos);
+ TVector3 vec = TVector3(pos);
+ Float_t phi = vec.Phi() *180 / TMath::Pi();
+ if(phi < 0) phi += 360;
+
+ Int_t mid = 0;
+ if(phi > 320) return;
+ else if(phi > 300) mid = 4;
+ else if(phi > 280) mid = 3;
+ else if(phi > 260) mid = 2;
+ else return;
+
+ Int_t nCells = cluster->GetNCells();
+ AddClusters(pos, mid, cluster->E(), nCells);
+
+}
void AliHLTEvePhos::AddClusters(Float_t * pos, Int_t module, Float_t energy) {
fGeoUtils->Global2Local(localVector, globalVector, 5-module);
//See header file for documentation
- fBoxSetClusters[4-module].AddBox(localVector.X(), -70, localVector.Z(), 2.2, -energy*20, 2.2);
- fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy));
+ fBoxSetClusters[4-module].AddBox(localVector.X(), 0, localVector.Z(), 2.2, energy*40, 2.2 );
+ fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy*10));
+}
+void AliHLTEvePhos::AddClusters(Float_t * pos, Int_t module, Float_t energy, Int_t nCells) {
+
+ TVector3 localVector;
+ TVector3 globalVector(pos);
+
+ fGeoUtils->Global2Local(localVector, globalVector, 5-module);
+
+ Float_t cf = 2.2*TMath::Sqrt(nCells);
+ //See header file for documentation
+ fBoxSetClusters[4-module].AddBox(localVector.X(), 0, localVector.Z(), cf, energy*40, cf );
+ fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy*10));
}
#ifndef ALIHLTEVEPHOS_H
#define ALIHLTEVEPHOS_H
+#include "AliESDEvent.h"
#include "AliHLTEveCalo.h"
+
class TEveElementList;
class AliPHOSGeoUtils;
AliHLTEvePhos& operator = (const AliHLTEvePhos );
/** inherited from AliHLTEveCalo */
- TEveElementList * CreateElementList();
+ void CreateElementList();
/** inherited from AliHLTEveCalo */
void AddClusters(Float_t * pos, Int_t module, Float_t energy);
+ void AddClusters(Float_t * pos, Int_t module, Float_t energy, Int_t nCells);
/** inherited from AliHLTEveCalo */
void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy);
+ Int_t GetClusters(AliESDEvent * event, TRefArray * clusters) { return event->GetPHOSClusters(clusters); }
+
+ void ProcessESDCluster(AliESDCaloCluster * cluster);
+
AliPHOSGeoUtils * fGeoUtils; //PHOS geometry
ClassDef(AliHLTEvePhos, 0);
#include "AliHLTHOMERBlockDesc.h"
#include "TCanvas.h"
#include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "TEvePointSet.h"
#include "TColor.h"
ClassImp(AliHLTEveTPC)
AliHLTEveTPC::AliHLTEveTPC() :
- AliHLTEveBase(),
+ AliHLTEveBase("TPC Clusters"),
fEveClusters(NULL),
fEveColClusters(NULL),
fNColorBins(15),
if(!fEveColClusters){
fEveColClusters = CreatePointSetArray();
- fEventManager->GetEveManager()->AddElement(fEveColClusters);
+ AddElement(fEveColClusters);
}
ProcessClusters(block, fEveClusters, fEveColClusters);
if(fEveClusters) fEveClusters->ResetBBox();
if (fHistQMax || fHistQMaxOverCharge || fHistCharge )
- DrawHistograms();
+ // DrawHistograms();
if(fCanvas) fCanvas->Update();
//See header file for documentation
- if(!fHistCharge) fHistCharge = new TH1F("ClusterCharge","ClusterCharge",100,0,500);
- if(!fHistQMax) fHistQMax = new TH1F("QMax","QMax",50,0,250);
- if(!fHistQMaxOverCharge) fHistQMaxOverCharge = new TH1F("QMaxOverCharge","QMaxOverCharge",50,0,1);
+ // if(!fHistCharge) fHistCharge = new TH1F("ClusterCharge","ClusterCharge",100,0,500);
+ // if(!fHistQMax) fHistQMax = new TH1F("QMax","QMax",50,0,250);
+ // if(!fHistQMaxOverCharge) fHistQMaxOverCharge = new TH1F("QMaxOverCharge","QMaxOverCharge",50,0,1);
Int_t slice = block->GetSubDetector();
contCol->Fill(cos*sp->fX - sin*sp->fY, sin*sp->fX + cos*sp->fY, sp->fZ, sp->fCharge);
- fHistCharge->Fill(sp->fCharge);
- fHistQMax->Fill(sp->fQMax);
- fHistQMaxOverCharge->Fill(((Float_t)sp->fQMax)/((Float_t)sp->fCharge));
+ // fHistCharge->Fill(sp->fCharge);
+ // fHistQMax->Fill(sp->fQMax);
+ // fHistQMaxOverCharge->Fill(((Float_t)sp->fQMax)/((Float_t)sp->fCharge));
}
}
/// @author Svein Lindal <slindal@fys.uio.no>
/// @brief TPC processor for the HLT EVE display
+#include "TClonesArray.h"
#include "AliHLTEveTRD.h"
#include "AliHLTHOMERBlockDesc.h"
#include "TCanvas.h"
#include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
#include "TEveManager.h"
#include "TEvePointSet.h"
#include "TColor.h"
ClassImp(AliHLTEveTRD)
AliHLTEveTRD::AliHLTEveTRD() :
- AliHLTEveBase(),
+ AliHLTEveBase("TRD"),
fEveClusters(NULL),
fEveColClusters(NULL),
fNColorBins(15),
if(!fEveColClusters){
fEveColClusters = CreatePointSetArray();
- fEventManager->GetEveManager()->AddElement(fEveColClusters);
+ AddElement(fEveColClusters);
}
ProcessClusters(block, fEveColClusters);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff