prefix them with AliEve instead.
Modify all macros to use the new class names.
+++ /dev/null
-// $Header$
-
-#include "AliEVEHOMERManagerEditor.h"
-#include <Alieve/AliEVEHOMERManager.h>
-
-#include <TVirtualPad.h>
-#include <TColor.h>
-
-#include <TGLabel.h>
-#include <TGButton.h>
-#include <TGNumberEntry.h>
-#include <TGColorSelect.h>
-#include <TGDoubleSlider.h>
-//______________________________________________________________________
-// AliEVEHOMERManagerEditor
-//
-
-ClassImp(AliEVEHOMERManagerEditor)
-
-AliEVEHOMERManagerEditor::AliEVEHOMERManagerEditor(const TGWindow *p, Int_t width, Int_t height,
- UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
- fM(0),
- fButt(0)
- // Initialize widget pointers to 0
-{
- MakeTitle("AliEVEHOMERManager");
-
- // Create widgets
- // fXYZZ = new TGSomeWidget(this, ...);
- // AddFrame(fXYZZ, new TGLayoutHints(...));
- // fXYZZ->Connect("SignalName()", "Alieve::AliEVEHOMERManagerEditor", this, "DoXYZZ()");
- fButt = new TGTextButton(this, "Ooogadooga");
- AddFrame(fButt); //, new TGLayoutHints(...));
- fButt->Connect("Clicked()", "AliEVEHOMERManagerEditor", this, "DoButt()");
-
-}
-
-AliEVEHOMERManagerEditor::~AliEVEHOMERManagerEditor()
-{}
-
-/**************************************************************************/
-
-void AliEVEHOMERManagerEditor::SetModel(TObject* obj)
-{
- fM = dynamic_cast<AliEVEHOMERManager*>(obj);
-
- // Set values of widgets
- // fXYZZ->SetValue(fM->GetXYZZ());
-}
-
-/**************************************************************************/
-
-// Implements callback/slot methods
-
-// void AliEVEHOMERManagerEditor::DoXYZZ()
-// {
-// fM->SetXYZZ(fXYZZ->GetValue());
-// Update();
-// }
-
-void AliEVEHOMERManagerEditor::DoButt()
-{
- fM->CreateHOMERSourcesList();
-}
+++ /dev/null
-// $Header$
-
-#ifndef ALIEVE_AliEVEHOMERManagerEditor_H
-#define ALIEVE_AliEVEHOMERManagerEditor_H
-
-#include <TGedFrame.h>
-
-class TGCheckButton;
-class TGTextButton;
-class TGNumberEntry;
-class TGColorSelect;
-
-class AliEVEHOMERManager;
-
-class AliEVEHOMERManagerEditor : public TGedFrame
-{
-private:
- AliEVEHOMERManagerEditor(const AliEVEHOMERManagerEditor&); // Not implemented
- AliEVEHOMERManagerEditor& operator=(const AliEVEHOMERManagerEditor&); // Not implemented
-
-protected:
- AliEVEHOMERManager* fM; // fModel dynamic-casted to AliEVEHOMERManagerEditor
-
- // Declare widgets
- // TGSomeWidget* fXYZZ;
- TGTextButton *fButt;
-
-public:
- AliEVEHOMERManagerEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
- virtual ~AliEVEHOMERManagerEditor();
-
- virtual void SetModel(TObject* obj);
-
- // Declare callback/slot methods
- // void DoXYZZ();
- void DoButt();
-
- ClassDef(AliEVEHOMERManagerEditor, 0); // Editor for AliEVEHOMERManager
-}; // endclass AliEVEHOMERManagerEditor
-
-#endif
+++ /dev/null
-// $Header$
-
-#include "AliEVEHOMERSource.h"
-
-//______________________________________________________________________
-// AliEVEHOMERSource
-//
-
-ClassImp(AliEVEHOMERSource)
-
-AliEVEHOMERSource::AliEVEHOMERSource(const Text_t* n, const Text_t* t) :
- TEveElement(),
- TNamed(n, t),
- fSource(0)
-{}
-
-AliEVEHOMERSource::AliEVEHOMERSource(AliHLTHOMERSourceDesc* src, const Text_t* n, const Text_t* t) :
- TEveElement(),
- TNamed(n, t),
- fSource(src)
-{}
-
+++ /dev/null
-// $Header$
-
-#ifndef ALIEVE_AliEVEHOMERSource_H
-#define ALIEVE_AliEVEHOMERSource_H
-
-#include <TEveElement.h>
-
-#include <TNamed.h>
-
-class AliHLTHOMERSourceDesc;
-
-class AliEVEHOMERSource : public TEveElement,
- public TNamed
-{
-private:
- AliEVEHOMERSource(const AliEVEHOMERSource&); // Not implemented
- AliEVEHOMERSource& operator=(const AliEVEHOMERSource&); // Not implemented
-
-protected:
- AliHLTHOMERSourceDesc *fSource;
-
-public:
- AliEVEHOMERSource(const Text_t* n="HOMER Source", const Text_t* t="");
- AliEVEHOMERSource(AliHLTHOMERSourceDesc* src, const Text_t* n="HOMER Source", const Text_t* t="");
- virtual ~AliEVEHOMERSource() {}
-
- AliHLTHOMERSourceDesc* GetSource() const { return fSource; }
- void SetSource(AliHLTHOMERSourceDesc* src) { fSource = src; }
-
- ClassDef(AliEVEHOMERSource, 1);
-}; // endclass AliEVEHOMERSource
-
-#endif
+++ /dev/null
-// $Header$
-
-#include "AliEVEHOMERSourceList.h"
-
-//______________________________________________________________________
-// AliEVEHOMERSourceList
-//
-
-ClassImp(AliEVEHOMERSourceList)
-
-AliEVEHOMERSourceList::AliEVEHOMERSourceList(const Text_t* n, const Text_t* t) :
- TEveElementList(n, t)
-{
-
-}
-
-void AliEVEHOMERSourceList::SelectAll()
-{
- EnableListElements(kTRUE, kTRUE);
-}
-
-void AliEVEHOMERSourceList::DeselectAll()
-{
- DisableListElements (kFALSE, kFALSE);
-}
+++ /dev/null
-// $Header$
-
-#ifndef ALIEVE_AliEVEHOMERSourceList_H
-#define ALIEVE_AliEVEHOMERSourceList_H
-
-#include <TEveElement.h>
-
-#include <TObject.h>
-
-class AliEVEHOMERSourceList : public TEveElementList
-{
-private:
- AliEVEHOMERSourceList(const AliEVEHOMERSourceList&); // Not implemented
- AliEVEHOMERSourceList& operator=(const AliEVEHOMERSourceList&); // Not implemented
-
-protected:
-
-public:
- AliEVEHOMERSourceList(const Text_t* n="HOMER Source List", const Text_t* t="");
- virtual ~AliEVEHOMERSourceList() {}
-
- void SelectAll(); // *MENU*
- void DeselectAll(); // *MENU*
-
- ClassDef(AliEVEHOMERSourceList, 1);
-}; // endclass AliEVEHOMERSourceList
-
-#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "EventAlieve.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveEventManager.h"
#include <TEveUtil.h>
#include <TEveManager.h>
#include <TROOT.h>
#include <TSystem.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// Event
+// AliEveEventManager
//
// Provide interface for loading and navigating standard AliRoot data
// (AliRunLoader) and ESDs.
// by each sub-detector.
//
-ClassImp(Event)
+ClassImp(AliEveEventManager)
-Event* Alieve::gEvent = 0;
+AliEveEventManager* gEvent = 0;
-Bool_t Alieve::Event::fgAssertRunLoader = kFALSE;
-Bool_t Alieve::Event::fgAssertESDTree = kFALSE;
+Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
+Bool_t AliEveEventManager::fgAssertESDTree = kFALSE;
-TString Alieve::Event::fgCdbUri("local://$ALICE_ROOT");
+TString AliEveEventManager::fgCdbUri("local://$ALICE_ROOT");
-AliMagF* Alieve::Event::fgMagField = 0;
+AliMagF* AliEveEventManager::fgMagField = 0;
-Event::Event() :
+AliEveEventManager::AliEveEventManager() :
TEveEventManager(),
fPath (), fEventId (0),
fESDfriend (0), fESDfriendExists(kFALSE)
{}
-Event::Event(TString path, Int_t ev) :
- TEveEventManager("AliEVE Event"),
+AliEveEventManager::AliEveEventManager(TString path, Int_t ev) :
+ TEveEventManager("AliEVE AliEveEventManager"),
fPath (path), fEventId(-1),
fRunLoader (0),
/**************************************************************************/
-void Event::Open()
+void AliEveEventManager::Open()
{
- static const TEveException eH("Event::Open ");
+ static const TEveException eH("AliEveEventManager::Open ");
gSystem->ExpandPathName(fPath);
if (fPath[0] != '/')
cdb->SetRun(runNo);
}
- SetName(Form("Event %d", fEventId));
+ SetName(Form("AliEveEventManager %d", fEventId));
SetTitle(fPath);
}
-void Event::GotoEvent(Int_t event)
+void AliEveEventManager::GotoEvent(Int_t event)
{
- static const TEveException eH("Event::GotoEvent ");
+ static const TEveException eH("AliEveEventManager::GotoEvent ");
Int_t maxEvent = 0;
if (fRunLoader)
// additinal parents.
DestroyElements();
fEventId = event;
- SetName(Form("Event %d", fEventId));
+ SetName(Form("AliEveEventManager %d", fEventId));
UpdateItems();
if (fRunLoader) {
AfterNewEventLoaded();
}
-void Event::Close()
+void AliEveEventManager::Close()
{
if (fESDTree) {
delete fESD; fESD = 0;
// Static convenience functions.
-AliRunLoader* Event::AssertRunLoader()
+AliRunLoader* AliEveEventManager::AssertRunLoader()
{
- static const TEveException eH("Event::AssertRunLoader ");
+ static const TEveException eH("AliEveEventManager::AssertRunLoader ");
if (gEvent == 0)
throw(eH + "ALICE event not ready.");
return gEvent->fRunLoader;
}
-AliESDEvent* Event::AssertESD()
+AliESDEvent* AliEveEventManager::AssertESD()
{
- static const TEveException eH("Event::AssertESD ");
+ static const TEveException eH("AliEveEventManager::AssertESD ");
if (gEvent == 0)
throw(eH + "ALICE event not ready.");
return gEvent->fESD;
}
-AliESDfriend* Event::AssertESDfriend()
+AliESDfriend* AliEveEventManager::AssertESDfriend()
{
- static const TEveException eH("Event::AssertESDfriend ");
+ static const TEveException eH("AliEveEventManager::AssertESDfriend ");
if (gEvent == 0)
throw(eH + "ALICE event not ready.");
return gEvent->fESDfriend;
}
-AliMagF* Event::AssertMagField()
+AliMagF* AliEveEventManager::AssertMagField()
{
if (fgMagField == 0)
{
return fgMagField;
}
-TGeoManager* Event::AssertGeometry()
+TGeoManager* AliEveEventManager::AssertGeometry()
{
- static const TEveException eH("Event::AssertGeometry ");
+ static const TEveException eH("AliEveEventManager::AssertGeometry ");
if (AliGeomManager::GetGeometry() == 0)
{
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#ifndef ALIEVE_Event_H
-#define ALIEVE_Event_H
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_EventAlieve_H
+#define ALIEVE_EventAlieve_H
#include <TEveEventManager.h>
class TTree;
class TGeoManager;
-namespace Alieve {
-class Event : public TEveEventManager
+class AliEveEventManager : public TEveEventManager
{
private:
- Event(const Event&); // Not implemented
- Event& operator=(const Event&); // Not implemented
+ AliEveEventManager(const AliEveEventManager&); // Not implemented
+ AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
protected:
TString fPath;
static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd)
{ fgAssertRunLoader = assertRunloader; fgAssertESDTree = assertEsd; }
- Event();
- Event(TString path, Int_t ev=0);
+ AliEveEventManager();
+ AliEveEventManager(TString path, Int_t ev=0);
virtual void Open();
virtual void GotoEvent(Int_t event);
static TGeoManager* AssertGeometry();
- ClassDef(Event, 1);
-}; // endclass Event
-
-extern Event* gEvent;
+ ClassDef(AliEveEventManager, 1);
+}; // endclass AliEveEventManager
-}
+extern AliEveEventManager* gEvent;
#endif
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/** @file AliEVEHOMERManager.cxx
+/** @file AliEveHOMERManager.cxx
@author Jochen Thaeder
@date
@brief Manger for HOMER in offline
using namespace std;
#endif
-#include "AliEVEHOMERManager.h"
+#include "AliEveHOMERManager.h"
#define use_aliroot
#define use_root
#include "AliHLTHOMERSourceDesc.h"
#include "AliHLTHOMERBlockDesc.h"
-#include "AliEVEHOMERSource.h"
+#include "AliEveHOMERSource.h"
#include "AliLog.h"
#include "AliTPCPreprocessorOnline.h"
#include "AliTPCCalROC.h"
// ------------
-ClassImp(AliEVEHOMERManager)
+ClassImp(AliEveHOMERManager)
/*
* ---------------------------------------------------------------------------------
*/
//##################################################################################
-AliEVEHOMERManager::AliEVEHOMERManager( TString xmlFile ) :
- TEveElementList("AliEVEHOMERManager"),
+AliEveHOMERManager::AliEveHOMERManager( TString xmlFile ) :
+ TEveElementList("AliEveHOMERManager"),
fLibManager(new AliHLTHOMERLibManager),
fXMLFile(xmlFile),
}
//##################################################################################
-AliEVEHOMERManager::AliEVEHOMERManager( const AliEVEHOMERManager& m) :
+AliEveHOMERManager::AliEveHOMERManager( const AliEveHOMERManager& m) :
TEveElementList(m.GetName(), m.GetTitle())
{
// see header file for class documentation
}
//##################################################################################
-AliEVEHOMERManager& AliEVEHOMERManager::operator=( const AliEVEHOMERManager& ) {
+AliEveHOMERManager& AliEveHOMERManager::operator=( const AliEveHOMERManager& ) {
// see header file for class documentation
AliError( Form( "assignment constructor to be tested." ) );
}
//##################################################################################
-AliEVEHOMERManager::~AliEVEHOMERManager() {
+AliEveHOMERManager::~AliEveHOMERManager() {
// see header file for class documentation
if ( fLibManager ) {
*/
//##################################################################################
-Int_t AliEVEHOMERManager::CreateHOMERSourcesList() {
+Int_t AliEveHOMERManager::CreateHOMERSourcesList() {
// see header file for class documentation
// -- Initialize XML parser
TIter next(fSourceList);
AliHLTHOMERSourceDesc* src = 0;
while ((src = (AliHLTHOMERSourceDesc*) next())) {
- AliEVEHOMERSource* re = new AliEVEHOMERSource
+ AliEveHOMERSource* re = new AliEveHOMERSource
(src,
Form("%s-%s-%s %s", src->GetDetector().Data(), src->GetSubDetector().Data(),
src->GetSubSubDetector().Data(), src->GetDataType().Data()),
}
//##################################################################################
-void AliEVEHOMERManager::SetSourceState( AliHLTHOMERSourceDesc * source, Bool_t state ) {
+void AliEveHOMERManager::SetSourceState( AliHLTHOMERSourceDesc * source, Bool_t state ) {
// see header file for class documentation
if ( source->IsSelected() != state ) {
}
//##################################################################################
-Int_t AliEVEHOMERManager::GetTDSAttributes( TXMLNode * xmlNode ) {
+Int_t AliEveHOMERManager::GetTDSAttributes( TXMLNode * xmlNode ) {
// see header file for class documentation
Int_t iResult = 0;
}
//##################################################################################
-Int_t AliEVEHOMERManager::ResolveHostPortInformation ( TString xmlHostname, TString xmlPort, TString &hostname, Int_t &port ) {
+Int_t AliEveHOMERManager::ResolveHostPortInformation ( TString xmlHostname, TString xmlPort, TString &hostname, Int_t &port ) {
// see header file for class documentation
Int_t iResult = 1;
}
//##################################################################################
-Int_t AliEVEHOMERManager::ResolveSourceInformation( TString xmlParent, AliHLTHOMERSourceDesc *source ) {
+Int_t AliEveHOMERManager::ResolveSourceInformation( TString xmlParent, AliHLTHOMERSourceDesc *source ) {
// see header file for class documentation
Int_t iResult = 0;
*/
//##################################################################################
-Int_t AliEVEHOMERManager::ConnectHOMER(){
+Int_t AliEveHOMERManager::ConnectHOMER(){
// see header file for class documentation
Int_t iResult = 0;
}
//##################################################################################
-void AliEVEHOMERManager::DisconnectHOMER(){
+void AliEveHOMERManager::DisconnectHOMER(){
// see header file for class documentation
if ( ! IsConnected() )
}
//##################################################################################
-Int_t AliEVEHOMERManager::ReconnectHOMER(){
+Int_t AliEveHOMERManager::ReconnectHOMER(){
// see header file for class documentation
Int_t iResult = 0;
//##################################################################################
-void AliEVEHOMERManager::CreateReadoutList( const char** sourceHostnames, UShort_t *sourcePorts, UInt_t &sourceCount ){
+void AliEveHOMERManager::CreateReadoutList( const char** sourceHostnames, UShort_t *sourcePorts, UInt_t &sourceCount ){
// see header file for class documentation
AliHLTHOMERSourceDesc * source= NULL;
/*
* ---------------------------------------------------------------------------------
- * Event Handling
+ * AliEveEventManager Handling
* ---------------------------------------------------------------------------------
*/
//##################################################################################
-Int_t AliEVEHOMERManager::NextEvent(){
+Int_t AliEveHOMERManager::NextEvent(){
// see header file for class documentation
Int_t iResult = 0;
fEventID = (ULong64_t) fReader->GetEventID();
fCurrentBlk = 0;
- AliInfo( Form("Event 0x%016LX (%Lu) with %lu blocks", fEventID, fEventID, fNBlks) );
+ AliInfo( Form("AliEveEventManager 0x%016LX (%Lu) with %lu blocks", fEventID, fEventID, fNBlks) );
#if 1
}
//##################################################################################
-Int_t AliEVEHOMERManager::CreateBlockList() {
+Int_t AliEveHOMERManager::CreateBlockList() {
// see header file for class documentation
Int_t iResult = 0;
*/
//##################################################################################
-void* AliEVEHOMERManager::GetBlk( Int_t ndx ) {
+void* AliEveHOMERManager::GetBlk( Int_t ndx ) {
// see header file for class documentation
void* data = NULL;
}
//##################################################################################
-ULong_t AliEVEHOMERManager::GetBlkSize( Int_t ndx ) {
+ULong_t AliEveHOMERManager::GetBlkSize( Int_t ndx ) {
// see header file for class documentation
ULong_t length = 0;
}
//##################################################################################
-TString AliEVEHOMERManager::GetBlkOrigin( Int_t ndx ) {
+TString AliEveHOMERManager::GetBlkOrigin( Int_t ndx ) {
// see header file for class documentation
TString origin = "";
}
//##################################################################################
-TString AliEVEHOMERManager:: GetBlkType( Int_t ndx ) {
+TString AliEveHOMERManager:: GetBlkType( Int_t ndx ) {
// see header file for class documentation
TString type = "";
//##################################################################################
-ULong_t AliEVEHOMERManager:: GetBlkSpecification( Int_t ndx ) {
+ULong_t AliEveHOMERManager:: GetBlkSpecification( Int_t ndx ) {
// see header file for class documentation
ULong_t spec = 0;
}
//##################################################################################
-Bool_t AliEVEHOMERManager::CheckIfRequested( AliHLTHOMERBlockDesc * block ) {
+Bool_t AliEveHOMERManager::CheckIfRequested( AliHLTHOMERBlockDesc * block ) {
// see header file for class documentation
Bool_t requested = kFALSE;
}
//##################################################################################
-void AliEVEHOMERManager::TestSelect() {
+void AliEveHOMERManager::TestSelect() {
// see header file for class documentation
for (Int_t ii =0; ii < fSourceList->GetEntries() ; ii++ ) {
}
//##################################################################################
-void AliEVEHOMERManager::TestSelectClass( TString objectName ) {
+void AliEveHOMERManager::TestSelectClass( TString objectName ) {
// see header file for class documentation
TList* srcList = GetSourceList();
}
//##################################################################################
-void AliEVEHOMERManager::SelectRawTPC() {
+void AliEveHOMERManager::SelectRawTPC() {
// see header file for class documentation
TList* srcList = GetSourceList();
}
//##################################################################################
-void AliEVEHOMERManager::SelectClusterTPC() {
+void AliEveHOMERManager::SelectClusterTPC() {
// see header file for class documentation
TList* srcList = GetSourceList();
}
//##################################################################################
-void AliEVEHOMERManager::SelectESDTPC() {
+void AliEveHOMERManager::SelectESDTPC() {
// see header file for class documentation
TList* srcList = GetSourceList();
}
}
//##################################################################################
-void AliEVEHOMERManager::DumpTPCCalib(TString objectName, Bool_t dumpToFile) {
+void AliEveHOMERManager::DumpTPCCalib(TString objectName, Bool_t dumpToFile) {
// see header file for class documentation
if ( fTPCPre != NULL )
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
//-*- Mode: C++ -*-
#ifndef ALIEVEHOMERMANGER_H
#define ALIEVEHOMERMANGER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/** @file AliEVEHOMERManager.h
+/** @file AliEveHOMERManager.h
@author Jochen Thaeder
@date
@brief Manager for HOMER in offline
class AliHLTHOMERLibManager;
/**
- * @class AliEVEHOMERManager
+ * @class AliEveHOMERManager
*
- * This class is the main class of the AliEVEHOMERManager
+ * This class is the main class of the AliEveHOMERManager
* ... more to come
*
* @ingroup alihlt_homer
*/
-class AliEVEHOMERManager : public TEveElementList
+class AliEveHOMERManager : public TEveElementList
{
public:
* @param argc Number of command line arguments.
* @param argv Array of command line arguments.
*/
- AliEVEHOMERManager(TString xmlFile="" );
+ AliEveHOMERManager(TString xmlFile="" );
/** not a valid copy constructor, defined according to effective C++ style */
- AliEVEHOMERManager( const AliEVEHOMERManager& );
+ AliEveHOMERManager( const AliEveHOMERManager& );
/** not a valid assignment op, but defined according to effective C++ style */
- AliEVEHOMERManager& operator=( const AliEVEHOMERManager& );
+ AliEveHOMERManager& operator=( const AliEveHOMERManager& );
/** destructor */
- virtual ~AliEVEHOMERManager();
+ virtual ~AliEveHOMERManager();
/*
* ---------------------------------------------------------------------------------
/*
* ---------------------------------------------------------------------------------
- * Event Handling - public
+ * AliEveEventManager Handling - public
* ---------------------------------------------------------------------------------
*/
- /** Loads the next Event, after being connected
+ /** Loads the next AliEveEventManager, after being connected
* @return 0 on sucess, "HOMER" errors on error
*/
Int_t NextEvent();
Bool_t IsConnected() { return fConnected; }
/* ---------------------------------------------------------------------------------
- * Eve AliEVEHOMERManager::foo(nt Handling - private
+ * Eve AliEveHOMERManager::foo(nt Handling - private
* ---------------------------------------------------------------------------------
*/
AliTPCPreprocessorOnline* fTPCPre;
- ClassDef( AliEVEHOMERManager, 0 )
+ ClassDef( AliEveHOMERManager, 0 )
};
#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveHOMERManagerEditor.h"
+#include <Alieve/AliEveHOMERManager.h>
+
+#include <TVirtualPad.h>
+#include <TColor.h>
+
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGNumberEntry.h>
+#include <TGColorSelect.h>
+#include <TGDoubleSlider.h>
+//______________________________________________________________________
+// AliEveHOMERManagerEditor
+//
+
+ClassImp(AliEveHOMERManagerEditor)
+
+AliEveHOMERManagerEditor::AliEveHOMERManagerEditor(const TGWindow *p, Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+ fM(0),
+ fButt(0)
+ // Initialize widget pointers to 0
+{
+ MakeTitle("AliEveHOMERManager");
+
+ // Create widgets
+ // fXYZZ = new TGSomeWidget(this, ...);
+ // AddFrame(fXYZZ, new TGLayoutHints(...));
+ // fXYZZ->Connect("SignalName()", "AliEveHOMERManagerEditor", this, "DoXYZZ()");
+ fButt = new TGTextButton(this, "Ooogadooga");
+ AddFrame(fButt); //, new TGLayoutHints(...));
+ fButt->Connect("Clicked()", "AliEveHOMERManagerEditor", this, "DoButt()");
+
+}
+
+AliEveHOMERManagerEditor::~AliEveHOMERManagerEditor()
+{}
+
+/**************************************************************************/
+
+void AliEveHOMERManagerEditor::SetModel(TObject* obj)
+{
+ fM = dynamic_cast<AliEveHOMERManager*>(obj);
+
+ // Set values of widgets
+ // fXYZZ->SetValue(fM->GetXYZZ());
+}
+
+/**************************************************************************/
+
+// Implements callback/slot methods
+
+// void AliEveHOMERManagerEditor::DoXYZZ()
+// {
+// fM->SetXYZZ(fXYZZ->GetValue());
+// Update();
+// }
+
+void AliEveHOMERManagerEditor::DoButt()
+{
+ fM->CreateHOMERSourcesList();
+}
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_AliEVEHOMERManagerEditor_H
+#define ALIEVE_AliEVEHOMERManagerEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGTextButton;
+class TGNumberEntry;
+class TGColorSelect;
+
+class AliEveHOMERManager;
+
+class AliEveHOMERManagerEditor : public TGedFrame
+{
+private:
+ AliEveHOMERManagerEditor(const AliEveHOMERManagerEditor&); // Not implemented
+ AliEveHOMERManagerEditor& operator=(const AliEveHOMERManagerEditor&); // Not implemented
+
+protected:
+ AliEveHOMERManager* fM; // fModel dynamic-casted to AliEveHOMERManagerEditor
+
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+ TGTextButton *fButt;
+
+public:
+ AliEveHOMERManagerEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveHOMERManagerEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ // Declare callback/slot methods
+ // void DoXYZZ();
+ void DoButt();
+
+ ClassDef(AliEveHOMERManagerEditor, 0); // Editor for AliEveHOMERManager
+}; // endclass AliEveHOMERManagerEditor
+
+#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveHOMERSource.h"
+
+//______________________________________________________________________
+// AliEveHOMERSource
+//
+
+ClassImp(AliEveHOMERSource)
+
+AliEveHOMERSource::AliEveHOMERSource(const Text_t* n, const Text_t* t) :
+ TEveElement(),
+ TNamed(n, t),
+ fSource(0)
+{}
+
+AliEveHOMERSource::AliEveHOMERSource(AliHLTHOMERSourceDesc* src, const Text_t* n, const Text_t* t) :
+ TEveElement(),
+ TNamed(n, t),
+ fSource(src)
+{}
+
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_AliEVEHOMERSource_H
+#define ALIEVE_AliEVEHOMERSource_H
+
+#include <TEveElement.h>
+
+#include <TNamed.h>
+
+class AliHLTHOMERSourceDesc;
+
+class AliEveHOMERSource : public TEveElement,
+ public TNamed
+{
+private:
+ AliEveHOMERSource(const AliEveHOMERSource&); // Not implemented
+ AliEveHOMERSource& operator=(const AliEveHOMERSource&); // Not implemented
+
+protected:
+ AliHLTHOMERSourceDesc *fSource;
+
+public:
+ AliEveHOMERSource(const Text_t* n="HOMER Source", const Text_t* t="");
+ AliEveHOMERSource(AliHLTHOMERSourceDesc* src, const Text_t* n="HOMER Source", const Text_t* t="");
+ virtual ~AliEveHOMERSource() {}
+
+ AliHLTHOMERSourceDesc* GetSource() const { return fSource; }
+ void SetSource(AliHLTHOMERSourceDesc* src) { fSource = src; }
+
+ ClassDef(AliEveHOMERSource, 1);
+}; // endclass AliEveHOMERSource
+
+#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveHOMERSourceList.h"
+
+//______________________________________________________________________
+// AliEveHOMERSourceList
+//
+
+ClassImp(AliEveHOMERSourceList)
+
+AliEveHOMERSourceList::AliEveHOMERSourceList(const Text_t* n, const Text_t* t) :
+ TEveElementList(n, t)
+{
+
+}
+
+void AliEveHOMERSourceList::SelectAll()
+{
+ EnableListElements(kTRUE, kTRUE);
+}
+
+void AliEveHOMERSourceList::DeselectAll()
+{
+ DisableListElements (kFALSE, kFALSE);
+}
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_AliEVEHOMERSourceList_H
+#define ALIEVE_AliEVEHOMERSourceList_H
+
+#include <TEveElement.h>
+
+#include <TObject.h>
+
+class AliEveHOMERSourceList : public TEveElementList
+{
+private:
+ AliEveHOMERSourceList(const AliEveHOMERSourceList&); // Not implemented
+ AliEveHOMERSourceList& operator=(const AliEveHOMERSourceList&); // Not implemented
+
+protected:
+
+public:
+ AliEveHOMERSourceList(const Text_t* n="HOMER Source List", const Text_t* t="");
+ virtual ~AliEveHOMERSourceList() {}
+
+ void SelectAll(); // *MENU*
+ void DeselectAll(); // *MENU*
+
+ ClassDef(AliEveHOMERSourceList, 1);
+}; // endclass AliEveHOMERSourceList
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
//__________________________________________________________________________
-// ITSDigitsInfo
+// AliEveITSDigitsInfo
//
//
#include <TMath.h>
#include <TEveTreeTools.h>
#include <TEveTrans.h>
-#include "ITSDigitsInfo.h"
+#include "AliEveITSDigitsInfo.h"
#include <AliITSCalibrationSDD.h>
#include <AliITSdigit.h>
#include <AliITSdigitSPD.h>
#include <AliITSRawStreamSPD.h>
#include <AliITSRawStreamSDD.h>
#include <AliITSRawStreamSSD.h>
-using namespace Alieve;
+
using namespace std;
-ClassImp(ITSModuleSelection)
+ClassImp(AliEveITSModuleSelection)
-ITSModuleSelection::ITSModuleSelection():
+AliEveITSModuleSelection::AliEveITSModuleSelection():
fType(-1),
fLayer(-1),
fMinPhi(-TMath::Pi()),
{}
-ClassImp(ITSDigitsInfo)
+ClassImp(AliEveITSDigitsInfo)
/**************************************************************************/
-ITSDigitsInfo::ITSDigitsInfo() :
+AliEveITSDigitsInfo::AliEveITSDigitsInfo() :
TObject(),
TEveRefCnt(),
fSPDmap(), fSDDmap(), fSSDmap(),
InitInternals();
}
-void ITSDigitsInfo::InitInternals()
+void AliEveITSDigitsInfo::InitInternals()
{
- static const TEveException eH("ITSDigitsInfo::InitInternals ");
+ static const TEveException eH("AliEveITSDigitsInfo::InitInternals ");
fGeom = new AliITSgeom();
fGeom->ReadNewFile("$REVESYS/alice-data/ITSgeometry.det");
/**************************************************************************/
-ITSDigitsInfo:: ~ITSDigitsInfo()
+AliEveITSDigitsInfo:: ~AliEveITSDigitsInfo()
{
map<Int_t, TClonesArray*>::iterator j;
for(j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
/**************************************************************************/
-void ITSDigitsInfo::SetTree(TTree* tree)
+void AliEveITSDigitsInfo::SetTree(TTree* tree)
{
// Set digit-tree to be used for digit retrieval. Data is loaded on
// demand.
fTree = tree;
}
-void ITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
+void AliEveITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
{
// Read raw-data into internal structures. AliITSdigit is used to
// store raw-adata for all sub-detectors.
/**************************************************************************/
-void ITSDigitsInfo::SetITSSegmentation()
+void AliEveITSDigitsInfo::SetITSSegmentation()
{
// SPD
fSegSPD = new AliITSsegmentationSPD(fGeom);
fSegSSD = new AliITSsegmentationSSD(fGeom);
}
-void ITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
+void AliEveITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
{
z = fSPDZCoord[j];
}
/**************************************************************************/
-TClonesArray* ITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
+TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
{
switch(subdet) {
case 0: {
}
/**************************************************************************/
-void ITSDigitsInfo::GetModuleIDs(ITSModuleSelection* sel, std::vector<UInt_t>& ids)
+void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel, std::vector<UInt_t>& ids)
{
// loop SPD
Int_t idx0 = 0, idx1 = 0;
/**************************************************************************/
-void ITSDigitsInfo::Print(Option_t* ) const
+void AliEveITSDigitsInfo::Print(Option_t* ) const
{
printf("*********************************************************\n");
printf("SPD module dimension (%f,%f) \n",fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
/*
printf("num cells %d,%d scaled %d,%d \n",fSegSPD->Npz(),fSegSPD->Npx(),Nz,Nx);
- printf("%d digits in ITSModule %d\n",ne, module);
+ printf("%d digits in AliEveITSModule %d\n",ne, module);
Float_t zn = i*(3.48*2)/Nz - 3.48 ;
Float_t xo = -fSegSPD->Dx()*0.00005 + fSegSPD->Dpx(0)*od->GetCoord2()*0.0001;
Float_t xn = -fSegSPD->Dx()*0.00005 + j*0.0001*fSegSPD->Dx()/Nx;
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_ITSDigitsInfo_H
#define ALIEVE_ITSDigitsInfo_H
class AliRawReader;
-namespace Alieve {
/**************************************************************************/
-// ITSModuleSelection
+// AliEveITSModuleSelection
/**************************************************************************/
-class ITSModuleSelection
+class AliEveITSModuleSelection
{
public:
Int_t fType;
Float_t fMinTheta;
Float_t fMaxTheta;
- ITSModuleSelection();
- virtual ~ITSModuleSelection() {}
+ AliEveITSModuleSelection();
+ virtual ~AliEveITSModuleSelection() {}
- ClassDef(ITSModuleSelection, 1);
+ ClassDef(AliEveITSModuleSelection, 1);
};
/**************************************************************************/
-// ITSDigitsInfo
+// AliEveITSDigitsInfo
/**************************************************************************/
-class ITSDigitsInfo : public TObject, public TEveRefCnt
+class AliEveITSDigitsInfo : public TObject, public TEveRefCnt
{
- ITSDigitsInfo(const ITSDigitsInfo&); // Not implemented
- ITSDigitsInfo& operator=(const ITSDigitsInfo&); // Not implemented
+ AliEveITSDigitsInfo(const AliEveITSDigitsInfo&); // Not implemented
+ AliEveITSDigitsInfo& operator=(const AliEveITSDigitsInfo&); // Not implemented
private:
Float_t fSPDZCoord[192];
Int_t fSDDScaleZ[5];
Int_t fSSDScale [5];
- ITSDigitsInfo();
- virtual ~ITSDigitsInfo();
+ AliEveITSDigitsInfo();
+ virtual ~AliEveITSDigitsInfo();
void SetTree(TTree* tree);
void ReadRaw(AliRawReader* raw, Int_t mode);
void GetSPDLocalZ(Int_t j, Float_t& z);
- void GetModuleIDs(ITSModuleSelection* sel, std::vector<UInt_t>& ids);
+ void GetModuleIDs(AliEveITSModuleSelection* sel, std::vector<UInt_t>& ids);
virtual void Print(Option_t* opt="") const;
- ClassDef(ITSDigitsInfo, 1);
-}; // endclass ITSDigitsInfo
+ ClassDef(AliEveITSDigitsInfo, 1);
+}; // endclass AliEveITSDigitsInfo
-}
#endif
-#include "ITSModule.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveITSModule.h"
#include <AliITSdigitSPD.h>
#include <AliITSdigitSDD.h>
#include <AliITSdigitSSD.h>
#include <TStyle.h>
-using namespace Alieve;
-Bool_t ITSModule::fgStaticInitDone = kFALSE;
-TEveFrameBox* ITSModule::fgSPDFrameBox = 0;
-TEveFrameBox* ITSModule::fgSDDFrameBox = 0;
-TEveFrameBox* ITSModule::fgSSDFrameBox = 0;
+Bool_t AliEveITSModule::fgStaticInitDone = kFALSE;
+
+TEveFrameBox* AliEveITSModule::fgSPDFrameBox = 0;
+TEveFrameBox* AliEveITSModule::fgSDDFrameBox = 0;
+TEveFrameBox* AliEveITSModule::fgSSDFrameBox = 0;
-TEveRGBAPalette* ITSModule::fgSPDPalette = 0;
-TEveRGBAPalette* ITSModule::fgSDDPalette = 0;
-TEveRGBAPalette* ITSModule::fgSSDPalette = 0;
+TEveRGBAPalette* AliEveITSModule::fgSPDPalette = 0;
+TEveRGBAPalette* AliEveITSModule::fgSDDPalette = 0;
+TEveRGBAPalette* AliEveITSModule::fgSSDPalette = 0;
//__________________________________________________________________________
-// ITSModule
+// AliEveITSModule
//
//
-ClassImp(ITSModule)
+ClassImp(AliEveITSModule)
/**************************************************************************/
-ITSModule::ITSModule(const Text_t* n, const Text_t* t) :
+AliEveITSModule::AliEveITSModule(const Text_t* n, const Text_t* t) :
TEveQuadSet(n, t),
fInfo(0),
fID(-1), fDetID(-1),
fDx(0), fDz(0), fDy(0)
{}
-ITSModule::ITSModule(Int_t gid, ITSDigitsInfo* info) :
+AliEveITSModule::AliEveITSModule(Int_t gid, AliEveITSDigitsInfo* info) :
TEveQuadSet(Form("ITS module %d", gid)),
fInfo (0),
fID(-1), fDetID(-1),
SetID(gid);
}
-ITSModule::~ITSModule()
+AliEveITSModule::~AliEveITSModule()
{
if(fInfo) fInfo->DecRefCount();
}
/**************************************************************************/
-void ITSModule::InitStatics(ITSDigitsInfo* info)
+void AliEveITSModule::InitStatics(AliEveITSDigitsInfo* info)
{
if (fgStaticInitDone) return;
fgStaticInitDone = kTRUE;
/**************************************************************************/
-void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
+void AliEveITSModule::SetDigitsInfo(AliEveITSDigitsInfo* info)
{
if (fInfo == info) return;
if (fInfo) fInfo->DecRefCount();
/**************************************************************************/
-void ITSModule::SetID(Int_t gid, Bool_t trans)
+void AliEveITSModule::SetID(Int_t gid, Bool_t trans)
{
- static const TEveException eH("ITSModule::SetID ");
+ static const TEveException eH("AliEveITSModule::SetID ");
if(fInfo == 0)
- throw(eH + "ITSDigitsInfo not set.");
+ throw(eH + "AliEveITSDigitsInfo not set.");
if (gid < fInfo->fGeom->GetStartSPD() || gid > fInfo->fGeom->GetLastSSD())
throw(eH + Form("%d is not valid. ID range from %d to %d", gid,
SetTrans();
}
-void ITSModule::LoadQuads()
+void AliEveITSModule::LoadQuads()
{
// Here we still use 'z' for the name of axial coordinates.
// The transforamtion matrix aplied rotates y -> z.
/**************************************************************************/
-void ITSModule::SetTrans()
+void AliEveITSModule::SetTrans()
{
// Set transformation matrix based on module id (use geometry to
// retrieve this information).
/**************************************************************************/
-void ITSModule::DigitSelected(Int_t idx)
+void AliEveITSModule::DigitSelected(Int_t idx)
{
// Override control-click from TEveQuadSet
DigitBase_t* qb = GetDigit(idx);
TObject* obj = qb->fId.GetObject();
AliITSdigit* d = dynamic_cast<AliITSdigit*>(obj);
- printf("ITSModule::QuadSelected "); Print();
+ printf("AliEveITSModule::QuadSelected "); Print();
printf(" idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
if (d)
/**************************************************************************/
-void ITSModule::Print(Option_t* ) const
+void AliEveITSModule::Print(Option_t* ) const
{
printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
}
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#ifndef ALIEVE_ITSModule_H
+#define ALIEVE_ITSModule_H
+
+#include <TEveQuadSet.h>
+
+#include <Alieve/AliEveITSDigitsInfo.h>
+
+
+class AliEveITSModule : public TEveQuadSet
+{
+ AliEveITSModule(const AliEveITSModule&); // Not implemented
+ AliEveITSModule& operator=(const AliEveITSModule&); // Not implemented
+
+protected:
+ AliEveITSDigitsInfo* fInfo;
+
+ Int_t fID; // Module id
+ Int_t fDetID; // Detector id (0~SPD, 1~SDD, 2~SSD)
+
+ Int_t fLayer;
+ Int_t fLadder;
+ Int_t fDet;
+
+ Float_t fDx;
+ Float_t fDz;
+ Float_t fDy;
+
+ static Bool_t fgStaticInitDone;
+
+public:
+ AliEveITSModule(const Text_t* n="AliEveITSModule", const Text_t* t=0);
+ AliEveITSModule(Int_t gid, AliEveITSDigitsInfo* info);
+ virtual ~AliEveITSModule();
+
+ static void InitStatics(AliEveITSDigitsInfo* info);
+
+ AliEveITSDigitsInfo* GetDigitsInfo() const { return fInfo; }
+ void SetDigitsInfo(AliEveITSDigitsInfo* info);
+
+ Int_t GetSubDetID() const { return fDetID; }
+
+ Int_t GetID() const { return fID; }
+ void SetID(Int_t gid, Bool_t tran=kTRUE);
+
+ virtual void LoadQuads();
+ void SetTrans();
+
+ virtual void DigitSelected(Int_t idx);
+
+ virtual void Print(Option_t* opt="") const;
+
+ static TEveFrameBox* fgSPDFrameBox;
+ static TEveFrameBox* fgSDDFrameBox;
+ static TEveFrameBox* fgSSDFrameBox;
+
+ static TEveRGBAPalette* fgSPDPalette;
+ static TEveRGBAPalette* fgSDDPalette;
+ static TEveRGBAPalette* fgSSDPalette;
+
+ ClassDef(AliEveITSModule, 1);
+};
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "ITSModuleStepper.h"
-#include "ITSDigitsInfo.h"
-#include "ITSScaledModule.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveITSModuleStepper.h"
+#include "AliEveITSDigitsInfo.h"
+#include "AliEveITSScaledModule.h"
#include <TEveManager.h>
#include <TEveGedEditor.h>
// #include <FTFont.h>
#include <TGLAxis.h>
#include <TGLViewer.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// ITSModuleStepper
+// AliEveITSModuleStepper
//
-ClassImp(ITSModuleStepper)
+ClassImp(AliEveITSModuleStepper)
-ITSModuleStepper::ITSModuleStepper(ITSDigitsInfo* di) :
- TEveElementList("ITS 2DStore", "ITSModuleStepper", kTRUE),
+AliEveITSModuleStepper::AliEveITSModuleStepper(AliEveITSDigitsInfo* di) :
+ TEveElementList("ITS 2DStore", "AliEveITSModuleStepper", kTRUE),
fPosition(0),
fFontCol(8)
{
// override member from base TEveElementList
- fChildClass = ITSScaledModule::Class();
+ fChildClass = AliEveITSScaledModule::Class();
SetMainColorPtr(&fWCol);
fStepper = new TEveGridStepper();
fStepper->SetNs(5, 4);
- fScaleInfo = new DigitScaleInfo();
+ fScaleInfo = new AliEveDigitScaleInfo();
fScaleInfo->IncRefCount();
fAxis = new TGLAxis();
gEve->GetGLViewer()->AddOverlayElement(this);
}
-ITSModuleStepper::~ITSModuleStepper()
+AliEveITSModuleStepper::~AliEveITSModuleStepper()
{
gEve->GetGLViewer()->RemoveOverlayElement(this);
/**************************************************************************/
-void ITSModuleStepper::Capacity()
+void AliEveITSModuleStepper::Capacity()
{
Int_t N = fStepper->GetNx()*fStepper->GetNy();
if (N != GetNChildren())
DestroyElements();
for (Int_t m=0; m<N; m++)
{
- AddElement(new ITSScaledModule(m, fDigitsInfo, fScaleInfo));
+ AddElement(new AliEveITSScaledModule(m, fDigitsInfo, fScaleInfo));
}
}
}
/**************************************************************************/
-void ITSModuleStepper::SetFirst(Int_t first)
+void AliEveITSModuleStepper::SetFirst(Int_t first)
{
Int_t lastpage = fIDs.size()/Nxy();
if(fIDs.size() % Nxy() ) lastpage++;
Apply();
}
-void ITSModuleStepper::Start()
+void AliEveITSModuleStepper::Start()
{
fPosition = 0;
Apply();
}
-void ITSModuleStepper::Next()
+void AliEveITSModuleStepper::Next()
{
SetFirst(fPosition + Nxy());
}
-void ITSModuleStepper::Previous()
+void AliEveITSModuleStepper::Previous()
{
// move to the top left corner first
SetFirst(fPosition - Nxy());
}
-void ITSModuleStepper::End()
+void AliEveITSModuleStepper::End()
{
Int_t lastpage = fIDs.size()/Nxy();
if(fIDs.size() % Nxy() ) lastpage++;
/**************************************************************************/
-void ITSModuleStepper::DisplayDet(Int_t det, Int_t layer)
+void AliEveITSModuleStepper::DisplayDet(Int_t det, Int_t layer)
{
fSubDet = det;
fIDs.clear();
- ITSModuleSelection sel = ITSModuleSelection();
+ AliEveITSModuleSelection sel = AliEveITSModuleSelection();
sel.fType = det; sel.fLayer=layer;
fDigitsInfo->GetModuleIDs(&sel, fIDs);
//in reder menu define a space between left and right pager
/**************************************************************************/
-void ITSModuleStepper::DisplayTheta(Float_t min, Float_t max)
+void AliEveITSModuleStepper::DisplayTheta(Float_t min, Float_t max)
{
fIDs.clear();
- ITSModuleSelection sel = ITSModuleSelection();
+ AliEveITSModuleSelection sel = AliEveITSModuleSelection();
sel.fMaxTheta = max; sel.fMinTheta=min;
fDigitsInfo->GetModuleIDs(&sel, fIDs);
Start();
/**************************************************************************/
-Int_t ITSModuleStepper::GetCurrentPage()
+Int_t AliEveITSModuleStepper::GetCurrentPage()
{
Int_t idx = fPosition +1;
Int_t n = idx/Nxy();
/**************************************************************************/
-Int_t ITSModuleStepper::GetPages()
+Int_t AliEveITSModuleStepper::GetPages()
{
Int_t n = fIDs.size()/Nxy();
if(fIDs.size() % Nxy()) n++;
/**************************************************************************/
-void ITSModuleStepper::Apply()
+void AliEveITSModuleStepper::Apply()
{
- // printf("ITSModuleStepper::Apply fPosition %d \n", fPosition);
+ // printf("AliEveITSModuleStepper::Apply fPosition %d \n", fPosition);
gEve->DisableRedraw();
Capacity();
{
if(idx < fIDs.size())
{
- ITSScaledModule* mod = dynamic_cast<ITSScaledModule*>(*childit);
+ AliEveITSScaledModule* mod = dynamic_cast<AliEveITSScaledModule*>(*childit);
mod->SetID(fIDs[idx], kFALSE);
TEveTrans& tr = mod->RefHMTrans();
tr.UnitTrans();
/**************************************************************************/
-void ITSModuleStepper::Render(TGLRnrCtx& rnrCtx)
+void AliEveITSModuleStepper::Render(TGLRnrCtx& rnrCtx)
{
// render everyting in relative coordinates
glMatrixMode(GL_PROJECTION);
/**************************************************************************/
//______________________________________________________________________
-Float_t ITSModuleStepper::TextLength(const char* txt)
+Float_t AliEveITSModuleStepper::TextLength(const char* txt)
{
Float_t llx, lly, llz, urx, ury, urz;
fText->BBox(txt, llx, lly, llz, urx, ury, urz);
}
//______________________________________________________________________
-void ITSModuleStepper::RenderString(TString string, Int_t id)
+void AliEveITSModuleStepper::RenderString(TString string, Int_t id)
{
Float_t txtY = fWHeight*0.5;
Float_t txtl = TextLength(string.Data());
}
//______________________________________________________________________
-void ITSModuleStepper::RenderFrame(Float_t dx, Float_t dy, Int_t id)
+void AliEveITSModuleStepper::RenderFrame(Float_t dx, Float_t dy, Int_t id)
{
if(fRnrFrame == kFALSE)return;
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
UChar_t color[4];
if (fWActive == id)
- TEveUtil::ColorFromIdx(fWActiveCol, color);
+ TEveUtil::TEveUtil::ColorFromIdx(fWActiveCol, color);
else
- TEveUtil:: ColorFromIdx(fWCol, color);
+ TEveUtil:: TEveUtil::ColorFromIdx(fWCol, color);
glColor4ubv(color);
glBegin(GL_QUADS);
}
//______________________________________________________________________
-void ITSModuleStepper::RenderSymbol(Float_t dx, Float_t dy, Int_t id)
+void AliEveITSModuleStepper::RenderSymbol(Float_t dx, Float_t dy, Int_t id)
{
glLoadName(id);
UChar_t color[4];
if (fWActive == id)
- TEveUtil::ColorFromIdx(fWActiveCol, color);
+ TEveUtil::TEveUtil::ColorFromIdx(fWActiveCol, color);
else
- TEveUtil::ColorFromIdx(fWCol, color);
+ TEveUtil::TEveUtil::ColorFromIdx(fWCol, color);
glColor4ubv(color);
Float_t xs = dx/4, ys = dy/4;
}
//______________________________________________________________________
-void ITSModuleStepper::RenderPalette(Float_t dx, Float_t x, Float_t y)
+void AliEveITSModuleStepper::RenderPalette(Float_t dx, Float_t x, Float_t y)
{
glPushMatrix();
glLoadIdentity();
glTranslatef(1 -x- dx, -1+y*4, 0);
- ITSModule* qs = dynamic_cast<ITSModule*>(*BeginChildren());
+ AliEveITSModule* qs = dynamic_cast<AliEveITSModule*>(*BeginChildren());
TEveRGBAPalette* p = qs->GetPalette();
glBegin(GL_QUAD_STRIP);
glColor4ubv(p->ColorFromValue(p->GetMinVal()));
}
//______________________________________________________________________
-void ITSModuleStepper::RenderMenu()
+void AliEveITSModuleStepper::RenderMenu()
{
Float_t ww = 2*fWWidth;
Float_t wh = 2*fWHeight;
// scale info
glPushMatrix();
- ITSDigitsInfo* di = fDigitsInfo;
+ AliEveITSDigitsInfo* di = fDigitsInfo;
Int_t scale = fScaleInfo->GetScale() - 1;
- ITSScaledModule* sm = dynamic_cast<ITSScaledModule*>(*BeginChildren());
+ AliEveITSScaledModule* sm = dynamic_cast<AliEveITSScaledModule*>(*BeginChildren());
Int_t cnx = 0, cnz = 0;
switch(sm->GetSubDetID())
{
}
//______________________________________________________________________
-void ITSModuleStepper::RenderCellIDs()
+void AliEveITSModuleStepper::RenderCellIDs()
{
fText->SetTextSize(fStepper->GetDy()*0.1);
fText->SetTextColor(fFontCol);
{
if(idx < fIDs.size())
{
- ITSScaledModule* mod = dynamic_cast<ITSScaledModule*>(*childit);
+ AliEveITSScaledModule* mod = dynamic_cast<AliEveITSScaledModule*>(*childit);
TEveTrans& tr = mod->RefHMTrans();
TString name = Form("%d",mod->GetID());
tr.GetPos(x,y,z);
/**************************************************************************/
//______________________________________________________________________
-Bool_t ITSModuleStepper::Handle(TGLRnrCtx & /*rnrCtx*/,
+Bool_t AliEveITSModuleStepper::Handle(TGLRnrCtx & /*rnrCtx*/,
TGLOvlSelectRecord & rec,
Event_t * event)
{
break;
case 5:
{
- DigitScaleInfo* si = fScaleInfo;
+ AliEveDigitScaleInfo* si = fScaleInfo;
if(si->GetScale() < 5)
{
si->ScaleChanged(si->GetScale() + 1);
}
case 6:
{
- DigitScaleInfo* si = fScaleInfo;
+ AliEveDigitScaleInfo* si = fScaleInfo;
if(si->GetScale() > 1)
{
si->ScaleChanged(si->GetScale() - 1);
}
//______________________________________________________________________
-Bool_t ITSModuleStepper::MouseEnter(TGLOvlSelectRecord& /*rec*/)
+Bool_t AliEveITSModuleStepper::MouseEnter(TGLOvlSelectRecord& /*rec*/)
{
return kTRUE;
}
//______________________________________________________________________
-void ITSModuleStepper::MouseLeave()
+void AliEveITSModuleStepper::MouseLeave()
{
// Mouse has left the element.
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_ITSModuleStepper_H
#define ALIEVE_ITSModuleStepper_H
class TGLText;
class TGLAxis;
-namespace Alieve {
-class ITSDigitsInfo;
-class DigitScaleInfo;
+class AliEveITSDigitsInfo;
+class AliEveDigitScaleInfo;
-class ITSModuleStepper : public TEveElementList,
+class AliEveITSModuleStepper : public TEveElementList,
public TGLOverlayElement
{
friend class ITSModuleStepperGL;
vpInt_t fIDs;
UInt_t fPosition; // position of top corner ITS module in vector fIDs
- ITSModuleStepper(const ITSModuleStepper&); // Not implemented
- ITSModuleStepper& operator=(const ITSModuleStepper&); // Not implemented
+ AliEveITSModuleStepper(const AliEveITSModuleStepper&); // Not implemented
+ AliEveITSModuleStepper& operator=(const AliEveITSModuleStepper&); // Not implemented
protected:
- ITSDigitsInfo* fDigitsInfo;
- DigitScaleInfo* fScaleInfo;
+ AliEveITSDigitsInfo* fDigitsInfo;
+ AliEveDigitScaleInfo* fScaleInfo;
Int_t fSubDet;
TEveGridStepper* fStepper;
void SetFirst(Int_t first);
public:
- ITSModuleStepper(ITSDigitsInfo* di);
- virtual ~ITSModuleStepper();
+ AliEveITSModuleStepper(AliEveITSDigitsInfo* di);
+ virtual ~AliEveITSModuleStepper();
// external functions
void DisplayDet(Int_t det, Int_t layer = -1);
TGLText* GetFont() { return fText; }
void SetGLText(TGLText* t) { fText = t; }
- ClassDef(ITSModuleStepper, 0);
+ ClassDef(AliEveITSModuleStepper, 0);
};
-} // Alieve namespace
-
#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveITSModuleStepperEditor.h"
+#include <Alieve/AliEveITSModuleStepper.h>
+#include <TEveGridStepperEditor.h>
+#include <TEveManager.h>
+
+#include <TVirtualPad.h>
+#include <TColor.h>
+
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGNumberEntry.h>
+#include <TGColorSelect.h>
+#include <TGDoubleSlider.h>
+
+
+//______________________________________________________________________
+// AliEveITSModuleStepperEditor
+//
+
+ClassImp(AliEveITSModuleStepperEditor)
+
+AliEveITSModuleStepperEditor::AliEveITSModuleStepperEditor(const TGWindow *p, Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+
+ fM(0),
+ fStepper(0)
+{
+ MakeTitle("AliEveITSModuleStepper");
+
+ fStepper = new TEveGridStepperSubEditor(this);
+ fStepper->Connect("Changed()", "AliEveITSModuleStepperEditor", this, "UpdateStore()");
+ AddFrame(fStepper, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 0, 0));
+}
+
+AliEveITSModuleStepperEditor::~AliEveITSModuleStepperEditor()
+{}
+
+/**************************************************************************/
+
+void AliEveITSModuleStepperEditor::SetModel(TObject* obj)
+{
+ fM = dynamic_cast<AliEveITSModuleStepper*>(obj);
+ fStepper->SetModel(fM->GetStepper());
+}
+
+/**************************************************************************/
+
+void AliEveITSModuleStepperEditor::UpdateStore()
+{
+ fM->Apply();
+ Update();
+ gEve->Redraw3D(kTRUE);
+}
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_ITSModuleStepperEditor_H
+#define ALIEVE_ITSModuleStepperEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+
+class TEveGridStepperSubEditor;
+
+
+class AliEveITSModuleStepper;
+
+class AliEveITSModuleStepperEditor : public TGedFrame
+{
+private:
+ AliEveITSModuleStepperEditor(const AliEveITSModuleStepperEditor&); // Not implemented
+ AliEveITSModuleStepperEditor& operator=(const AliEveITSModuleStepperEditor&); // Not implemented
+
+protected:
+ AliEveITSModuleStepper* fM; // fModel dynamic-casted to AliEveITSModuleStepperEditor
+
+ TEveGridStepperSubEditor* fStepper;
+
+public:
+ AliEveITSModuleStepperEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveITSModuleStepperEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ void UpdateStore();
+ ClassDef(AliEveITSModuleStepperEditor, 0); // Editor for AliEveITSModuleStepper
+}; // endclass AliEveITSModuleStepperEditor
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "ITSScaledModule.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveITSScaledModule.h"
#include <AliITSdigitSPD.h>
#include <AliITSdigitSDD.h>
#include <AliITSdigitSSD.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// DigitScaleInfo
+// AliEveDigitScaleInfo
//
-ClassImp(DigitScaleInfo)
+ClassImp(AliEveDigitScaleInfo)
-DigitScaleInfo::DigitScaleInfo():
+AliEveDigitScaleInfo::AliEveDigitScaleInfo():
fScale(1),
fStatType (ST_Average),
fSyncPalette(kFALSE)
{
}
-void DigitScaleInfo::ScaleChanged(Int_t s)
+void AliEveDigitScaleInfo::ScaleChanged(Int_t s)
{
fScale = s;
- ITSScaledModule* sm;
+ AliEveITSScaledModule* sm;
std::list<TEveElement*>::iterator i = fBackRefs.begin();
while (i != fBackRefs.end())
{
- sm = dynamic_cast<ITSScaledModule*>(*i);
+ sm = dynamic_cast<AliEveITSScaledModule*>(*i);
if(sm) sm->LoadQuads();
++i;
}
}
-void DigitScaleInfo::StatTypeChanged(Int_t t)
+void AliEveDigitScaleInfo::StatTypeChanged(Int_t t)
{
fStatType = t;
fSyncPalette = kTRUE;
- ITSScaledModule* sm;
+ AliEveITSScaledModule* sm;
std::list<TEveElement*>::iterator i = fBackRefs.begin();
while (i != fBackRefs.end())
{
- sm = dynamic_cast<ITSScaledModule*>(*i);
+ sm = dynamic_cast<AliEveITSScaledModule*>(*i);
if(sm) sm->SetQuadValues();
++i;
}
}
//______________________________________________________________________
-// ITSScaledModule
+// AliEveITSScaledModule
//
-ClassImp(ITSScaledModule)
+ClassImp(AliEveITSScaledModule)
-ITSScaledModule::ITSScaledModule(Int_t gid, ITSDigitsInfo* info, DigitScaleInfo* si):
- ITSModule("ITSScaledModule", "ITSScaledModule"),
+AliEveITSScaledModule::AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si):
+ AliEveITSModule("AliEveITSScaledModule", "AliEveITSScaledModule"),
fNx(-1),
fNz(-1),
fNCx(-1),
fScaleInfo->IncRefCount(this);
}
-ITSScaledModule::~ITSScaledModule()
+AliEveITSScaledModule::~AliEveITSScaledModule()
{
fScaleInfo->DecRefCount(this);
}
/**************************************************************************/
-void ITSScaledModule::LoadQuads()
+void AliEveITSScaledModule::LoadQuads()
{
// Here we still use 'z' for the name of axial coordinates.
// The transforamtion matrix aplied rotates y -> z.
/**************************************************************************/
-void ITSScaledModule::SetQuadValues()
+void AliEveITSScaledModule::SetQuadValues()
{
if(fScaleInfo->GetSyncPalette()) SyncPalette();
{
using namespace TMath;
- case DigitScaleInfo::ST_Occup:
+ case AliEveDigitScaleInfo::ST_Occup:
v = Nint((100.0*sd->N) / (fNCx*fNCz));
break;
- case DigitScaleInfo::ST_Average:
+ case AliEveDigitScaleInfo::ST_Average:
v = Nint((Double_t) sd->sum / sd->N);
break;
- case DigitScaleInfo::ST_Rms:
+ case AliEveDigitScaleInfo::ST_Rms:
v = Nint(Sqrt(sd->sqr_sum) / sd->N);
break;
}
/**************************************************************************/
-void ITSScaledModule::SyncPalette()
+void AliEveITSScaledModule::SyncPalette()
{
- // printf("ITSScaledModule::SyncPalette()\n");
- if(fScaleInfo->GetStatType() == DigitScaleInfo::ST_Occup)
+ // printf("AliEveITSScaledModule::SyncPalette()\n");
+ if(fScaleInfo->GetStatType() == AliEveDigitScaleInfo::ST_Occup)
{
// SPD
- ITSModule::fgSPDPalette->SetLimits(0, 100);
- ITSModule::fgSPDPalette->SetMinMax(0, 100);
+ AliEveITSModule::fgSPDPalette->SetLimits(0, 100);
+ AliEveITSModule::fgSPDPalette->SetMinMax(0, 100);
// SDD
- ITSModule::fgSDDPalette->SetLimits(0, 100);
- ITSModule::fgSDDPalette->SetMinMax(0, 100);
+ AliEveITSModule::fgSDDPalette->SetLimits(0, 100);
+ AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
// SSD
- ITSModule::fgSSDPalette->SetLimits(0, 100);
- ITSModule::fgSDDPalette->SetMinMax(0, 100);
+ AliEveITSModule::fgSSDPalette->SetLimits(0, 100);
+ AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
}
else
{
- Alieve::ITSDigitsInfo& DI = *fInfo;
+ AliEveITSDigitsInfo& DI = *fInfo;
// SPD
- ITSModule::fgSPDPalette->SetLimits(0, DI.fSPDHighLim);
- ITSModule::fgSPDPalette->SetMinMax(DI.fSPDMinVal, DI.fSPDMaxVal);
+ AliEveITSModule::fgSPDPalette->SetLimits(0, DI.fSPDHighLim);
+ AliEveITSModule::fgSPDPalette->SetMinMax(DI.fSPDMinVal, DI.fSPDMaxVal);
// SDD
- ITSModule::fgSDDPalette->SetLimits(0, DI.fSDDHighLim);
- ITSModule::fgSDDPalette->SetMinMax(DI.fSDDMinVal, DI.fSDDMaxVal);
+ AliEveITSModule::fgSDDPalette->SetLimits(0, DI.fSDDHighLim);
+ AliEveITSModule::fgSDDPalette->SetMinMax(DI.fSDDMinVal, DI.fSDDMaxVal);
// SSD
- ITSModule::fgSSDPalette->SetLimits(0, DI.fSSDHighLim);
- ITSModule::fgSSDPalette->SetMinMax(DI.fSSDMinVal, DI.fSSDMaxVal);
+ AliEveITSModule::fgSSDPalette->SetLimits(0, DI.fSSDHighLim);
+ AliEveITSModule::fgSSDPalette->SetMinMax(DI.fSSDMinVal, DI.fSSDMaxVal);
}
fScaleInfo->SetSyncPalette(kFALSE);
/**************************************************************************/
-void ITSScaledModule::GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total)
+void AliEveITSScaledModule::GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total)
{
cnx =fNx;
cnz =fNz;
/**************************************************************************/
-void ITSScaledModule::DigitSelected(Int_t idx)
+void AliEveITSScaledModule::DigitSelected(Int_t idx)
{
// Override control-click from TEveQuadSet
- printf("ITSScaledModule::DigitSelected "); Print();
+ printf("AliEveITSScaledModule::DigitSelected "); Print();
DigitBase_t* qb = GetDigit(idx);
TObject* obj = qb->fId.GetObject();
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_ITSScaledModule_H
#define ALIEVE_ITSScaledModule_H
#include <TEveUtil.h>
-#include <Alieve/ITSModule.h>
+#include <Alieve/AliEveITSModule.h>
#include <TQObject.h>
-namespace Alieve {
/**************************************************************************/
-// DigitScaleInfo
+// AliEveDigitScaleInfo
/**************************************************************************/
-class DigitScaleInfo : public TQObject, public TEveRefBackPtr
+class AliEveDigitScaleInfo : public TQObject, public TEveRefBackPtr
{
public:
enum StatType_e { ST_Occup, ST_Average, ST_Rms };
// Bool_t fAutoUpdatePalette;
private:
- DigitScaleInfo(const DigitScaleInfo&); // Not implemented
- DigitScaleInfo& operator=(const DigitScaleInfo&); // Not implemented
+ AliEveDigitScaleInfo(const AliEveDigitScaleInfo&); // Not implemented
+ AliEveDigitScaleInfo& operator=(const AliEveDigitScaleInfo&); // Not implemented
protected:
Int_t fScale;
Bool_t fSyncPalette;
public:
- DigitScaleInfo();
- virtual ~DigitScaleInfo(){}
+ AliEveDigitScaleInfo();
+ virtual ~AliEveDigitScaleInfo(){}
Int_t GetScale() { return fScale; }
void ScaleChanged(Int_t s);
Bool_t GetSyncPalette(){return fSyncPalette;}
void SetSyncPalette(Bool_t x){fSyncPalette = x;}
- ClassDef(DigitScaleInfo, 1);
+ ClassDef(AliEveDigitScaleInfo, 1);
};
/**************************************************************************/
};
/**************************************************************************/
-// ITSScaledModule
+// AliEveITSScaledModule
/**************************************************************************/
-class ITSScaledModule : public ITSModule
+class AliEveITSScaledModule : public AliEveITSModule
{
friend class ITSSDSubEditor;
private:
map<Int_t, ScaledDigit> fDigitsMap;
- ITSScaledModule(const ITSScaledModule&); // Not implemented
- ITSScaledModule& operator=(const ITSScaledModule&); // Not implemented
+ AliEveITSScaledModule(const AliEveITSScaledModule&); // Not implemented
+ AliEveITSScaledModule& operator=(const AliEveITSScaledModule&); // Not implemented
protected:
Int_t fNx; // per module
Int_t fNCx; // per cell
Int_t fNCz;
- DigitScaleInfo* fScaleInfo;
+ AliEveDigitScaleInfo* fScaleInfo;
public:
- ITSScaledModule(Int_t gid, ITSDigitsInfo* info, DigitScaleInfo* si );
- virtual ~ITSScaledModule();
+ AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si );
+ virtual ~AliEveITSScaledModule();
virtual void DigitSelected(Int_t idx);
void SyncPalette();
void GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total);
- DigitScaleInfo* GetScaleInfo(){ return fScaleInfo; }
-
- ClassDef(ITSScaledModule, 1);
-}; // endclass ITSScaledModule
+ AliEveDigitScaleInfo* GetScaleInfo(){ return fScaleInfo; }
-}
+ ClassDef(AliEveITSScaledModule, 1);
+}; // endclass AliEveITSScaledModule
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "ITSScaledModuleEditor.h"
-#include <Alieve/ITSScaledModule.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveITSScaledModuleEditor.h"
+#include <Alieve/AliEveITSScaledModule.h>
#include <TEveTransEditor.h>
#include <TEveGValuators.h>
#include <TGNumberEntry.h>
#include <TGColorSelect.h>
#include <TGComboBox.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// ITSScaledModuleEditor
+// AliEveITSScaledModuleEditor
//
-ClassImp(ITSScaledModuleEditor)
+ClassImp(AliEveITSScaledModuleEditor)
- ITSScaledModuleEditor::ITSScaledModuleEditor(const TGWindow *p, Int_t width, Int_t height,
+ AliEveITSScaledModuleEditor::AliEveITSScaledModuleEditor(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
fInfoLabel0(0),
fInfoLabel1(0)
{
- MakeTitle("ITSScaledModule");
+ MakeTitle("AliEveITSScaledModule");
// Create widgets
{
TGHorizontalFrame* f = new TGHorizontalFrame(this);
fScale->GetNumberEntry()->SetToolTipText("Set cell size.");
f->AddFrame(fScale, new TGLayoutHints(kLHintsLeft, 1, 7, 1, 1));
fScale->Associate(f);
- fScale->Connect("ValueSet(Long_t)", "Alieve::ITSScaledModuleEditor", this, "DoScale()");
+ fScale->Connect("ValueSet(Long_t)", "AliEveITSScaledModuleEditor", this, "DoScale()");
TGLabel* lab = new TGLabel(f, "Statistic:");
f->AddFrame(lab, new TGLayoutHints(kLHintsLeft|kLHintsBottom, 1, 2, 1, 2));
TGListBox* lb = fStatistic->GetListBox();
lb->Resize(lb->GetWidth(), 3*16);
fStatistic->Resize(74, 20);
- fStatistic->Connect("Selected(Int_t)", "Alieve::ITSScaledModuleEditor", this, "DoStatType(Int_t)");
+ fStatistic->Connect("Selected(Int_t)", "AliEveITSScaledModuleEditor", this, "DoStatType(Int_t)");
f->AddFrame(fStatistic, new TGLayoutHints(kLHintsLeft, 1, 2, 1, 1));
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
}
/*************************************************************************/
-ITSScaledModuleEditor::~ITSScaledModuleEditor()
+AliEveITSScaledModuleEditor::~AliEveITSScaledModuleEditor()
{}
/*************************************************************************/
-void ITSScaledModuleEditor::CreateInfoFrame()
+void AliEveITSScaledModuleEditor::CreateInfoFrame()
{
fInfoFrame = CreateEditorTabSubFrame("Info");
TGCompositeFrame *title1 = new TGCompositeFrame(fInfoFrame, 145, 10,
/**************************************************************************/
-void ITSScaledModuleEditor::SetModel(TObject* obj)
+void AliEveITSScaledModuleEditor::SetModel(TObject* obj)
{
- fModule = dynamic_cast<ITSScaledModule*>(obj);
+ fModule = dynamic_cast<AliEveITSScaledModule*>(obj);
// widgets
fScale->SetIntNumber(fModule->GetScaleInfo()->GetScale());
/**************************************************************************/
-void ITSScaledModuleEditor::DoScale()
+void AliEveITSScaledModuleEditor::DoScale()
{
fModule->GetScaleInfo()->ScaleChanged(fScale->GetIntNumber());
/**************************************************************************/
-void ITSScaledModuleEditor::DoStatType(Int_t v)
+void AliEveITSScaledModuleEditor::DoStatType(Int_t v)
{
fModule->GetScaleInfo()->StatTypeChanged(v);
Update();
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_ITSScaledModuleEditor_H
+#define ALIEVE_ITSScaledModuleEditor_H
+
+#include <TGedFrame.h>
+#include <TEveRGBAPaletteEditor.h>
+
+class TGNumberEntry;
+class TGColorSelect;
+class TGComboBox;
+
+class TEveGValuator;
+class TEveGDoubleValuator;
+class TEveRGBAPalette;
+
+
+class AliEveDigitScaleInfo;
+class AliEveITSScaledModule;
+class AliITSsegmentation;
+
+/**************************************************************************/
+
+class AliEveITSScaledModuleEditor : public TGedFrame
+{
+private:
+ AliEveITSScaledModuleEditor(const AliEveITSScaledModuleEditor&); // Not implemented
+ AliEveITSScaledModuleEditor& operator=(const AliEveITSScaledModuleEditor&); // Not implemented
+
+ void CreateInfoFrame();
+
+protected:
+ TGVerticalFrame* fInfoFrame;
+
+ AliEveITSScaledModule* fModule; // fModel dynamic-casted to AliEveITSScaledModuleEditor
+
+ TGNumberEntry* fScale;
+ TGComboBox* fStatistic;
+
+ TGLabel* fInfoLabel0;
+ TGLabel* fInfoLabel1;
+
+public:
+ AliEveITSScaledModuleEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveITSScaledModuleEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ void DoScale();
+ void DoStatType(Int_t t);
+
+ ClassDef(AliEveITSScaledModuleEditor, 0); // Editor for AliEveITSScaledModule
+}; // endclass AliEveITSScaledModuleEditor
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "JetPlane.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveJetPlane.h"
#include <TString.h>
#include <TBuffer3D.h>
#include <TBuffer3DTypes.h>
#include <TVirtualPad.h>
#include <TVirtualViewer3D.h>
-using namespace Alieve;
//______________________________________________________________________
-// JetPlane
+// AliEveJetPlane
//
-Bool_t JetPlane::fgOneMomentumXYZ = kFALSE;
-Bool_t JetPlane::fgOneMomentumPhiTheta = kFALSE;
-Bool_t JetPlane::fgOneEta = kFALSE;
-Bool_t JetPlane::fgOneE = kFALSE;
-Bool_t JetPlane::fgOneChgMass = kFALSE;
+Bool_t AliEveJetPlane::fgOneMomentumXYZ = kFALSE;
+Bool_t AliEveJetPlane::fgOneMomentumPhiTheta = kFALSE;
+Bool_t AliEveJetPlane::fgOneEta = kFALSE;
+Bool_t AliEveJetPlane::fgOneE = kFALSE;
+Bool_t AliEveJetPlane::fgOneChgMass = kFALSE;
-ClassImp(JetPlane)
+ClassImp(AliEveJetPlane)
-JetPlane::JetPlane(Int_t iev) :
- TEveElementList(Form("JetPlane %i",iev), Form("%i",iev)),
+AliEveJetPlane::AliEveJetPlane(Int_t iev) :
+ TEveElementList(Form("AliEveJetPlane %i",iev), Form("%i",iev)),
fMinEta (-1.5 ),
fMaxEta ( 1.5 ),
/**************************************************************************/
-void JetPlane::AddJet(AliAODJet jet)
+void AliEveJetPlane::AddJet(AliAODJet jet)
{
fJets.push_back(jet);
}
/**************************************************************************/
-void JetPlane::AddTrack(AliAODTrack track)
+void AliEveJetPlane::AddTrack(AliAODTrack track)
{
fTracks.push_back(track);
}
/**************************************************************************/
-void JetPlane::ComputeBBox()
+void AliEveJetPlane::ComputeBBox()
{
BBoxInit();
BBoxCheckPoint(-350, -350, -20);
BBoxCheckPoint( 350, 350, 20);
}
-void JetPlane::Paint(Option_t* /*option*/)
+void AliEveJetPlane::Paint(Option_t* /*option*/)
{
TBuffer3D buff(TBuffer3DTypes::kGeneric);
Int_t reqSections = gPad->GetViewer3D()->AddObject(buff);
if (reqSections == TBuffer3D::kNone) {
- // printf("JetPlane::Paint viewer was happy with Core buff3d.\n");
+ // printf("AliEveJetPlane::Paint viewer was happy with Core buff3d.\n");
return;
}
}
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_JetPlane_H
#define ALIEVE_JetPlane_H
#include <vector>
-namespace Alieve {
-class JetPlane : public TEveElementList,
+class AliEveJetPlane : public TEveElementList,
public TAtt3D,
public TAttBBox
{
- friend class JetPlaneGL;
+ friend class AliEveJetPlaneGL;
private:
- JetPlane(const JetPlane&); // Not implemented
- JetPlane& operator=(const JetPlane&); // Not implemented
+ AliEveJetPlane(const AliEveJetPlane&); // Not implemented
+ AliEveJetPlane& operator=(const AliEveJetPlane&); // Not implemented
protected:
Float_t fMinEta;
static Bool_t fgOneChgMass;
public:
- JetPlane(Int_t iev);
- virtual ~JetPlane() {}
+ AliEveJetPlane(Int_t iev);
+ virtual ~AliEveJetPlane() {}
void AddJet(AliAODJet jet);
void AddTrack(AliAODTrack track);
void SetTransMatrix(Double_t* carr) { fHMTrans.SetFrom(carr); }
void SetTransMatrix(const TGeoMatrix& mat) { fHMTrans.SetFrom(mat); }
- ClassDef(JetPlane, 1);
-}; // endclass JetPlane
-
-}
+ ClassDef(AliEveJetPlane, 1);
+}; // endclass AliEveJetPlane
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "JetPlaneEditor.h"
-#include <Alieve/JetPlane.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveJetPlaneEditor.h"
+#include <Alieve/AliEveJetPlane.h>
#include <TEveGValuators.h>
#include <TVirtualPad.h>
#include <TGDoubleSlider.h>
#include <TGFrame.h>
#include <TGTab.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// JetPlaneEditor
+// AliEveJetPlaneEditor
//
-Alieve::JetPlaneEditor::StaticDataWindow* JetPlaneEditor::fgStaticWindow = 0;
+AliEveJetPlaneEditor::StaticDataWindow* AliEveJetPlaneEditor::fgStaticWindow = 0;
-ClassImp(JetPlaneEditor)
+ClassImp(AliEveJetPlaneEditor)
-JetPlaneEditor::JetPlaneEditor(const TGWindow *p, Int_t width, Int_t height,
+AliEveJetPlaneEditor::AliEveJetPlaneEditor(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0),
fInformationSetup(0)
// Initialize widget pointers to 0
{
- MakeTitle("JetPlane");
+ MakeTitle("AliEveJetPlane");
Int_t labelW = 67;
// Create widgets
// fXYZZ = new TGSomeWidget(this, ...);
// AddFrame(fXYZZ, new TGLayoutHints(...));
- // fXYZZ->Connect("SignalName()", "Alieve::JetPlaneEditor", this, "DoXYZZ()");
+ // fXYZZ->Connect("SignalName()", "AliEveJetPlaneEditor", this, "DoXYZZ()");
fRnrJets = new TGCheckButton(this, "Rnr Jets");
AddFrame(fRnrJets, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
- fRnrJets->Connect("Clicked()", "Alieve::JetPlaneEditor", this, "DoRnrJets()");
+ fRnrJets->Connect("Clicked()", "AliEveJetPlaneEditor", this, "DoRnrJets()");
fRnrTracks = new TGCheckButton(this, "Rnr Tracks");
AddFrame(fRnrTracks, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
- fRnrTracks->Connect("Clicked()", "Alieve::JetPlaneEditor", this, "DoRnrTracks()");
+ fRnrTracks->Connect("Clicked()", "AliEveJetPlaneEditor", this, "DoRnrTracks()");
fEnergyScale = new TEveGValuator(this, "Length scale:", 110, 0);
fEnergyScale->SetLabelWidth(labelW);
fEnergyScale->Build();
fEnergyScale->SetLimits(1, 500, 500, TGNumberFormat::kNESRealOne);
fEnergyScale->SetToolTip("Energy mapped to length of arrow.");
- fEnergyScale->Connect("ValueSet(Double_t)", "Alieve::JetPlaneEditor", this, "DoEnergyScale()");
+ fEnergyScale->Connect("ValueSet(Double_t)", "AliEveJetPlaneEditor", this, "DoEnergyScale()");
AddFrame(fEnergyScale, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
fEnergyColorScale = new TEveGValuator(this, "Color scale:", 110, 0);
fEnergyColorScale->Build();
fEnergyColorScale->SetLimits(-2, 2, 100, TGNumberFormat::kNESRealOne);
fEnergyColorScale->SetToolTip("Energy mapped to highest palette color.");
- fEnergyColorScale->Connect("ValueSet(Double_t)", "Alieve::JetPlaneEditor", this, "DoEnergyColorScale()");
+ fEnergyColorScale->Connect("ValueSet(Double_t)", "AliEveJetPlaneEditor", this, "DoEnergyColorScale()");
AddFrame(fEnergyColorScale, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
fOneSelection = new TGRadioButton(this, "&One TEveTrack/Jet");
fTwoSelection = new TGRadioButton(this, "&Two TEveTrack/Jet");
AddFrame(fOneSelection, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
AddFrame(fTwoSelection, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
- fOneSelection->Connect("Clicked()", "Alieve::JetPlaneEditor", this, "DoOneSelection()");
- fTwoSelection->Connect("Clicked()", "Alieve::JetPlaneEditor", this, "DoTwoSelection()");
+ fOneSelection->Connect("Clicked()", "AliEveJetPlaneEditor", this, "DoOneSelection()");
+ fTwoSelection->Connect("Clicked()", "AliEveJetPlaneEditor", this, "DoTwoSelection()");
// fInformationSetup = new TGTextButton(this, "TEveTrack/Jet Print");
// AddFrame(fInformationSetup, new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 0, 2, 2));
- // fInformationSetup->Connect("Clicked()", "Alieve::JetPlaneEditor", this, "DoStaticDataWindow()");
+ // fInformationSetup->Connect("Clicked()", "AliEveJetPlaneEditor", this, "DoStaticDataWindow()");
}
-JetPlaneEditor::~JetPlaneEditor()
+AliEveJetPlaneEditor::~AliEveJetPlaneEditor()
{}
/**************************************************************************/
-void JetPlaneEditor::SetModel(TObject* obj)
+void AliEveJetPlaneEditor::SetModel(TObject* obj)
{
- fM = dynamic_cast<JetPlane*>(obj);
+ fM = dynamic_cast<AliEveJetPlane*>(obj);
// Set values of widgets
// fXYZZ->SetValue(fM->GetXYZZ());
// Implements callback/slot methods
-// void JetPlaneEditor::DoXYZZ()
+// void AliEveJetPlaneEditor::DoXYZZ()
// {
// fM->SetXYZZ(fXYZZ->GetValue());
// Update();
// }
-void JetPlaneEditor::DoRnrJets()
+void AliEveJetPlaneEditor::DoRnrJets()
{
fM->SetRnrJets(fRnrJets->IsOn());
Update();
}
-void JetPlaneEditor::DoRnrTracks()
+void AliEveJetPlaneEditor::DoRnrTracks()
{
fM->SetRnrTracks(fRnrTracks->IsOn());
Update();
}
-void JetPlaneEditor::DoEnergyColorScale()
+void AliEveJetPlaneEditor::DoEnergyColorScale()
{
fM->SetEnergyColorScale(fEnergyColorScale->GetValue());
Update();
}
-void JetPlaneEditor::DoEnergyScale()
+void AliEveJetPlaneEditor::DoEnergyScale()
{
fM->SetEnergyScale(fEnergyScale->GetValue());
Update();
}
-void JetPlaneEditor::DoOneSelection()
+void AliEveJetPlaneEditor::DoOneSelection()
{
fTwoSelection->SetState(kButtonUp);
fM->SetOneSelection(fOneSelection->IsOn());
Update();
}
-void JetPlaneEditor::DoTwoSelection()
+void AliEveJetPlaneEditor::DoTwoSelection()
{
fOneSelection->SetState(kButtonUp);
fM->SetOneSelection(fOneSelection->IsOn());
Update();
}
-void JetPlaneEditor::DoStaticDataWindow()
+void AliEveJetPlaneEditor::DoStaticDataWindow()
{
printf("\n Soon available ... \n");
if (fgStaticWindow == 0)
/**************************************************************************/
-ClassImp(JetPlaneEditor::StaticDataWindow)
+ClassImp(AliEveJetPlaneEditor::StaticDataWindow)
-JetPlaneEditor::StaticDataWindow::StaticDataWindow(const TGWindow *p, const TGWindow *main,
+AliEveJetPlaneEditor::StaticDataWindow::StaticDataWindow(const TGWindow *p, const TGWindow *main,
UInt_t w, UInt_t h, UInt_t options) :
TGTransientFrame(p, main, w, h, options),
fFrame1(0),
// Create a dialog window. A dialog window pops up with respect to its
// "main" window.
- Connect("CloseWindow()", "JetPlaneEditor::StaticDataWindow", this, "DoClose()");
+ Connect("CloseWindow()", "AliEveJetPlaneEditor::StaticDataWindow", this, "DoClose()");
DontCallClose(); // to avoid double deletions.
// use hierarchical cleaning
fFrame1 = new TGHorizontalFrame(this, 60, 20, kFixedWidth);
fOkButton = new TGTextButton(fFrame1, "&Ok", 1);
- fOkButton->Connect("Clicked()", "JetPlaneEditor::StaticDataWindow", this, "DoOK()");
+ fOkButton->Connect("Clicked()", "AliEveJetPlaneEditor::StaticDataWindow", this, "DoOK()");
fCancelButton = new TGTextButton(fFrame1, "&Cancel", 2);
- fCancelButton->Connect("Clicked()", "JetPlaneEditor::StaticDataWindow", this, "DoCancel()");
+ fCancelButton->Connect("Clicked()", "AliEveJetPlaneEditor::StaticDataWindow", this, "DoCancel()");
fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,2, 2, 2, 2);
fL2 = new TGLayoutHints(kLHintsBottom | kLHintsRight, 2, 2, 5, 1);
// Tabs for one and two track information
fTab = new TGTab(this, 300, 300);
- fTab->Connect("Selected(Int_t)", "JetPlaneEditor::StaticDataWindow", this, "DoTab(Int_t)");
+ fTab->Connect("Selected(Int_t)", "AliEveJetPlaneEditor::StaticDataWindow", this, "DoTab(Int_t)");
fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
SetWindowName("TEveTrack/Jet Common Setup");
}
-JetPlaneEditor::StaticDataWindow::~StaticDataWindow()
+AliEveJetPlaneEditor::StaticDataWindow::~StaticDataWindow()
{
DeleteWindow();
}
-void JetPlaneEditor::StaticDataWindow::DoClose()
+void AliEveJetPlaneEditor::StaticDataWindow::DoClose()
{
UnmapWindow();
}
-void JetPlaneEditor::StaticDataWindow::DoOK()
+void AliEveJetPlaneEditor::StaticDataWindow::DoOK()
{
- // Read data from widgets, copy to static members of JetPlane
+ // Read data from widgets, copy to static members of AliEveJetPlane
SendCloseMessage();
}
-void JetPlaneEditor::StaticDataWindow::DoCancel()
+void AliEveJetPlaneEditor::StaticDataWindow::DoCancel()
{
SendCloseMessage();
}
-void JetPlaneEditor::StaticDataWindow::DoTab(Int_t /*id*/)
+void AliEveJetPlaneEditor::StaticDataWindow::DoTab(Int_t /*id*/)
{
// printf("Tab item %d activated\n", id);
}
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_JetPlaneEditor_H
#define ALIEVE_JetPlaneEditor_H
class TEveGValuator;
-namespace Alieve {
// class TEveGValuator;
-class JetPlane;
+class AliEveJetPlane;
-class JetPlaneEditor : public TGedFrame
+class AliEveJetPlaneEditor : public TGedFrame
{
private:
- JetPlaneEditor(const JetPlaneEditor&); // Not implemented
- JetPlaneEditor& operator=(const JetPlaneEditor&); // Not implemented
+ AliEveJetPlaneEditor(const AliEveJetPlaneEditor&); // Not implemented
+ AliEveJetPlaneEditor& operator=(const AliEveJetPlaneEditor&); // Not implemented
protected:
- JetPlane *fM; // fModel dynamic-casted to JetPlaneEditor
+ AliEveJetPlane *fM; // fModel dynamic-casted to AliEveJetPlaneEditor
// Declare widgets
// TGSomeWidget* fXYZZ;
TGButton *fInformationSetup;
public:
- JetPlaneEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ AliEveJetPlaneEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
- virtual ~JetPlaneEditor();
+ virtual ~AliEveJetPlaneEditor();
virtual void SetModel(TObject* obj);
protected:
static StaticDataWindow* fgStaticWindow;
- ClassDef(JetPlaneEditor, 1); // Editor for JetPlane
-}; // endclass JetPlaneEditor
-
-}
+ ClassDef(AliEveJetPlaneEditor, 1); // Editor for AliEveJetPlane
+}; // endclass AliEveJetPlaneEditor
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "JetPlaneGL.h"
-#include <Alieve/JetPlane.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveJetPlaneGL.h"
+#include <Alieve/AliEveJetPlane.h>
#include <TGLRnrCtx.h>
#include <TGLSelectRecord.h>
#include <TColor.h>
#include <TStyle.h>
#include <TROOT.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// JetPlaneGL
+// AliEveJetPlaneGL
//
-ClassImp(JetPlaneGL)
+ClassImp(AliEveJetPlaneGL)
-JetPlaneGL::JetPlaneGL() : TGLObject(), fM(0)
+AliEveJetPlaneGL::AliEveJetPlaneGL() : TGLObject(), fM(0)
{
fDLCache = kFALSE; // Disable display list -- axis pain.
}
-JetPlaneGL::~JetPlaneGL()
+AliEveJetPlaneGL::~AliEveJetPlaneGL()
{}
/**************************************************************************/
-Bool_t JetPlaneGL::SetModel(TObject* obj, const Option_t* /*opt*/)
+Bool_t AliEveJetPlaneGL::SetModel(TObject* obj, const Option_t* /*opt*/)
{
- if(SetModelCheckClass(obj, Alieve::JetPlane::Class())) {
- fM = dynamic_cast<JetPlane*>(obj);
+ if(SetModelCheckClass(obj, AliEveJetPlane::Class())) {
+ fM = dynamic_cast<AliEveJetPlane*>(obj);
return kTRUE;
}
return kFALSE;
}
-void JetPlaneGL::SetBBox()
+void AliEveJetPlaneGL::SetBBox()
{
// !! This ok if master sub-classed from TAttBBox
- SetAxisAlignedBBox(((JetPlane*)fExternalObj)->AssertBBox());
+ SetAxisAlignedBBox(((AliEveJetPlane*)fExternalObj)->AssertBBox());
}
/**************************************************************************/
-void JetPlaneGL::DirectDraw(TGLRnrCtx & /*rnrCtx*/) const
+void AliEveJetPlaneGL::DirectDraw(TGLRnrCtx & /*rnrCtx*/) const
{
Float_t minEta = (fM->fMinEta)*(fM->fEtaScale);
/**************************************************************************/
-void JetPlaneGL::ProcessSelection(TGLRnrCtx & /*rnrCtx*/, TGLSelectRecord & rec)
+void AliEveJetPlaneGL::ProcessSelection(TGLRnrCtx & /*rnrCtx*/, TGLSelectRecord & rec)
{
// printf("beep %u\n", rec.GetN());
// rec.Print();
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_JetPlaneGL_H
+#define ALIEVE_JetPlaneGL_H
+
+#include <TGLObject.h>
+
+class TGLViewer;
+class TGLScene;
+
+
+class AliEveJetPlane;
+
+class AliEveJetPlaneGL : public TGLObject
+{
+private:
+ AliEveJetPlaneGL(const AliEveJetPlaneGL&); // Not implemented
+ AliEveJetPlaneGL& operator=(const AliEveJetPlaneGL&); // Not implemented
+
+protected:
+ AliEveJetPlane* fM; // fModel dynamic-casted to AliEveJetPlaneGL
+
+ virtual void DirectDraw(TGLRnrCtx & rnrCtx) const;
+
+public:
+ AliEveJetPlaneGL();
+ virtual ~AliEveJetPlaneGL();
+
+ virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
+ virtual void SetBBox();
+
+ // To support two-level selection
+ virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
+ virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & rec);
+
+ ClassDef(AliEveJetPlaneGL, 0);
+}; // endclass AliEveJetPlaneGL
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "KineTools.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveKineTools.h"
#include <TObject.h>
#include <TTree.h>
#include <map>
//______________________________________________________________________
-// KineTools
+// AliEveKineTools
//
-using namespace Alieve;
+
using namespace std;
-ClassImp(KineTools)
+ClassImp(AliEveKineTools)
-KineTools::KineTools()
+AliEveKineTools::AliEveKineTools()
{}
/**************************************************************************/
-void KineTools::SetDaughterPathMarks(TEveElement* cont, AliStack* stack, Bool_t recurse)
+void AliEveKineTools::SetDaughterPathMarks(TEveElement* cont, AliStack* stack, Bool_t recurse)
{
// Import daughters birth points.
}
-void KineTools::SetTrackReferences(TEveElement* cont, TTree* treeTR, Bool_t recurse)
+void AliEveKineTools::SetTrackReferences(TEveElement* cont, TTree* treeTR, Bool_t recurse)
{
// set decay and reference points
- static const TEveException eH("KineTools::ImportPathMarks");
+ static const TEveException eH("AliEveKineTools::ImportPathMarks");
// Fill map
map<Int_t, TEveTrack*> tracks;
} // end loop through top branches
}
-void KineTools::SortPathMarks(TEveElement* cont, Bool_t recurse)
+void AliEveKineTools::SortPathMarks(TEveElement* cont, Bool_t recurse)
{
// Sort path-marks for all tracks by time.
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+// Tools for import of kinematics.
+// Preliminary/minimal solution.
+
+#ifndef ALIEVE_KineTools_H
+#define ALIEVE_KineTools_H
+
+#include <TEveUtil.h>
+#include <TObject.h>
+
+class TTree;
+class AliStack;
+
+class TEveTrackList;
+
+
+class AliEveKineTools
+{
+private:
+ AliEveKineTools(const AliEveKineTools&); // Not implemented
+ AliEveKineTools& operator=(const AliEveKineTools&); // Not implemented
+
+protected:
+ // data from TreeK
+public:
+ AliEveKineTools();
+ virtual ~AliEveKineTools(){}
+
+ // data from TreeTR
+ void SetDaughterPathMarks(TEveElement* cont, AliStack* stack, Bool_t recurse=kFALSE);
+ void SetTrackReferences (TEveElement* cont, TTree* treeTR=0, Bool_t recurse=kFALSE);
+ void SortPathMarks (TEveElement* cont, Bool_t recurse=kFALSE);
+
+ ClassDef(AliEveKineTools, 1);
+}; // endclass AliEveKineTools
+
+#endif
-#include "MUONChamber.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include <Alieve/MUONData.h>
-#include <Alieve/MUONChamberData.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveMUONChamber.h"
+
+#include <Alieve/AliEveMUONData.h>
+#include <Alieve/AliEveMUONChamberData.h>
#include <TBuffer3D.h>
#include <TBuffer3DTypes.h>
#include <TColor.h>
#include <TMath.h>
-using namespace Alieve;
//______________________________________________________________________
-// MUONChamber
+// AliEveMUONChamber
//
-ClassImp(MUONChamber)
+ClassImp(AliEveMUONChamber)
//______________________________________________________________________
-MUONChamber::MUONChamber(Int_t id, const Text_t* n, const Text_t* t) :
+AliEveMUONChamber::AliEveMUONChamber(Int_t id, const Text_t* n, const Text_t* t) :
TEveElement(fFrameColor),
TNamed(n,t),
fMUONData(0),
}
//______________________________________________________________________
-MUONChamber::~MUONChamber()
+AliEveMUONChamber::~AliEveMUONChamber()
{
//
// destructor
}
//______________________________________________________________________
-void MUONChamber::ComputeBBox()
+void AliEveMUONChamber::ComputeBBox()
{
//
// bounding box
}
//______________________________________________________________________
-void MUONChamber::Paint(Option_t*)
+void AliEveMUONChamber::Paint(Option_t*)
{
//
// draw...
buffer.SetSectionsValid(TBuffer3D::kCore);
Int_t reqSections = gPad->GetViewer3D()->AddObject(buffer);
if (reqSections == TBuffer3D::kNone) {
- //printf("MUONChamber::Paint viewer was happy with Core buff3d.\n");
+ //printf("AliEveMUONChamber::Paint viewer was happy with Core buff3d.\n");
return;
}
- printf("MUONChamber::Paint only GL supported.\n");
+ printf("AliEveMUONChamber::Paint only GL supported.\n");
return;
}
//______________________________________________________________________
-void MUONChamber::SetThreshold(Short_t t)
+void AliEveMUONChamber::SetThreshold(Short_t t)
{
//
// digits amplitude threshold
}
//______________________________________________________________________
-void MUONChamber::SetMaxVal(Int_t mv)
+void AliEveMUONChamber::SetMaxVal(Int_t mv)
{
//
// digits amplitude maximum value
}
//______________________________________________________________________
-void MUONChamber::SetClusterSize(Int_t size)
+void AliEveMUONChamber::SetClusterSize(Int_t size)
{
//
// cluster point size
}
//______________________________________________________________________
-void MUONChamber::SetHitSize(Int_t size)
+void AliEveMUONChamber::SetHitSize(Int_t size)
{
//
// hit point size
}
//______________________________________________________________________
-void MUONChamber::SetupColor(Int_t val, UChar_t* pixel) const
+void AliEveMUONChamber::SetupColor(Int_t val, UChar_t* pixel) const
{
//
// RGBA color for amplitude "val"
Int_t nCol = gStyle->GetNumberOfColors();
Int_t cBin = (Int_t) TMath::Nint(nCol*(val - fThreshold)/div);
- TEveUtil::ColorFromIdx(gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin)), pixel);
+ TEveUtil::TEveUtil::ColorFromIdx(gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin)), pixel);
}
//______________________________________________________________________
-Int_t MUONChamber::ColorIndex(Int_t val) const
+Int_t AliEveMUONChamber::ColorIndex(Int_t val) const
{
//
// index color
}
//______________________________________________________________________
-void MUONChamber::SetupColorArray() const
+void AliEveMUONChamber::SetupColorArray() const
{
//
// build array of colors
}
//______________________________________________________________________
-void MUONChamber::ClearColorArray()
+void AliEveMUONChamber::ClearColorArray()
{
//
// delete array of colors
}
//______________________________________________________________________
-void MUONChamber::SetDataSource(MUONData* data)
+void AliEveMUONChamber::SetDataSource(AliEveMUONData* data)
{
if (data == fMUONData) return;
}
//______________________________________________________________________
-MUONChamberData* MUONChamber::GetChamberData() const
+AliEveMUONChamberData* AliEveMUONChamber::GetChamberData() const
{
return fMUONData ? fMUONData->GetChamberData(fChamberID) : 0;
}
//______________________________________________________________________
-void MUONChamber::UpdateQuads()
+void AliEveMUONChamber::UpdateQuads()
{
fQuadSet1.Reset(TEveQuadSet::kQT_RectangleXY, kTRUE, 32);
fPointSet1.Reset();
fPointSet2.Reset();
- MUONChamberData* data = GetChamberData();
+ AliEveMUONChamberData* data = GetChamberData();
Float_t *buffer;
Float_t x0, y0, z, w, h, clsq;
}
//______________________________________________________________________
-void MUONChamber::SetChamberID(Int_t id)
+void AliEveMUONChamber::SetChamberID(Int_t id)
{
if (id < 0) id = 0;
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_MUONChamber_H
#define ALIEVE_MUONChamber_H
#include <TAtt3D.h>
#include <TAttBBox.h>
-namespace Alieve {
-class MUONData;
-class MUONChamberData;
-class MUONChamberEditor;
-class MUONChamberGL;
+class AliEveMUONData;
+class AliEveMUONChamberData;
+class AliEveMUONChamberEditor;
+class AliEveMUONChamberGL;
-class MUONChamber : public TEveElement,
+class AliEveMUONChamber : public TEveElement,
public TNamed,
public TAtt3D,
public TAttBBox
{
- friend class MUONChamberGL;
- friend class MUONChamberEditor;
+ friend class AliEveMUONChamberGL;
+ friend class AliEveMUONChamberEditor;
- MUONChamber(const MUONChamber&); // Not implemented
- MUONChamber& operator=(const MUONChamber&); // Not implemented
+ AliEveMUONChamber(const AliEveMUONChamber&); // Not implemented
+ AliEveMUONChamber& operator=(const AliEveMUONChamber&); // Not implemented
protected:
void UpdateQuads();
- MUONData* fMUONData; // data for the current event
+ AliEveMUONData* fMUONData; // data for the current event
Color_t fFrameColor; // main coloring
UInt_t fRTS; //! Rendering Time Stamp
Int_t fChamberID; // number of the chamber, 0 to 13
public:
- MUONChamber(Int_t id, const Text_t* n = "MUONChamber", const Text_t* t = 0);
- virtual ~MUONChamber();
+ AliEveMUONChamber(Int_t id, const Text_t* n = "AliEveMUONChamber", const Text_t* t = 0);
+ virtual ~AliEveMUONChamber();
virtual void ComputeBBox();
virtual void Paint(Option_t* option = "");
virtual UInt_t IncRTS() { return ++fRTS; };
virtual Bool_t CanEditMainColor() { return kTRUE; }
- void SetDataSource(MUONData *data);
+ void SetDataSource(AliEveMUONData *data);
void SetChamberID(Int_t id);
void SetFrameColor(Color_t col) { fFrameColor = col; IncRTS(); };
- MUONData* GetData() const { return fMUONData; };
- MUONChamberData* GetChamberData() const;
+ AliEveMUONData* GetData() const { return fMUONData; };
+ AliEveMUONChamberData* GetChamberData() const;
Int_t GetID() const { return fChamberID; };
void SetThreshold(Short_t t);
void SetMaxVal(Int_t mv);
void SetClusterSize(Int_t size);
void SetHitSize(Int_t size);
- ClassDef(MUONChamber,1); // Visualisation of the MUON chambers
+ ClassDef(AliEveMUONChamber,1); // Visualisation of the MUON chambers
};
-inline UChar_t* MUONChamber::ColorFromArray(Int_t val) const
+inline UChar_t* AliEveMUONChamber::ColorFromArray(Int_t val) const
{
if(val < fThreshold) val = fThreshold;
if(val > fMaxVal) val = fMaxVal;
return fColorArray + 4 * (val - fThreshold);
}
-inline void MUONChamber::ColorFromArray(Int_t val, UChar_t* pix) const
+inline void AliEveMUONChamber::ColorFromArray(Int_t val, UChar_t* pix) const
{
UChar_t* c = ColorFromArray(val);
pix[0] = c[0]; pix[1] = c[1]; pix[2] = c[2]; pix[3] = c[3];
}
-}
-
#endif
-#include "MUONChamberData.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveMUONChamberData.h"
#include <AliMUONGeometryTransformer.h>
#include <mapping/AliMpDEIterator.h>
#include <Riostream.h>
-#include "Alieve/EventAlieve.h"
+#include "Alieve/AliEveEventManager.h"
///////////////////////////////////////////////////////////////////////////////
///
-/// MUONChamberData: geometry and digits
+/// AliEveMUONChamberData: geometry and digits
///
///////////////////////////////////////////////////////////////////////////////
-using namespace Alieve;
-ClassImp(MUONChamberData)
-AliMUONGeometryTransformer* MUONChamberData::fgTransformer = 0;
+ClassImp(AliEveMUONChamberData)
+
+AliMUONGeometryTransformer* AliEveMUONChamberData::fgTransformer = 0;
//______________________________________________________________________
-MUONChamberData::MUONChamberData(Int_t chamber)
+AliEveMUONChamberData::AliEveMUONChamberData(Int_t chamber)
{
//
// constructor
//
- Event *event = Alieve::gEvent;
+ AliEveEventManager *event = gEvent;
TString dataPath = TString(event->GetTitle());
dataPath.Append("/geometry.root");
}
//______________________________________________________________________
-MUONChamberData::~MUONChamberData()
+AliEveMUONChamberData::~AliEveMUONChamberData()
{
//
// destructor
}
//______________________________________________________________________
-void MUONChamberData::DropData()
+void AliEveMUONChamberData::DropData()
{
//
// release the chamber data
}
//______________________________________________________________________
-void MUONChamberData::Init(Int_t chamber)
+void AliEveMUONChamberData::Init(Int_t chamber)
{
//
// initialize the drawing coordinates of the chamber
}
//______________________________________________________________________
-void MUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
+void AliEveMUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
{
//
// add a digit to this chamber
}
//______________________________________________________________________
-void MUONChamberData::RegisterCluster(Int_t /*detElemId*/, Int_t cathode, Float_t clsX, Float_t clsY, Float_t clsZ, Float_t charge)
+void AliEveMUONChamberData::RegisterCluster(Int_t /*detElemId*/, Int_t cathode, Float_t clsX, Float_t clsY, Float_t clsZ, Float_t charge)
{
//
// add a reconstructed point (cluster) to this chamber
}
//______________________________________________________________________
-void MUONChamberData::RegisterHit(Int_t /*detElemId*/, Float_t hitX, Float_t hitY, Float_t hitZ)
+void AliEveMUONChamberData::RegisterHit(Int_t /*detElemId*/, Float_t hitX, Float_t hitY, Float_t hitZ)
{
//
// add a simulation hit to this chamber
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_MUONChamberData_H
#define ALIEVE_MUONChamberData_H
class AliMUONGeometryTransformer;
-namespace Alieve {
-class MUONChamberData : public TObject
+class AliEveMUONChamberData : public TObject
{
- MUONChamberData(const MUONChamberData&); // Not implemented
- MUONChamberData& operator=(const MUONChamberData&); // Not implemented
+ AliEveMUONChamberData(const AliEveMUONChamberData&); // Not implemented
+ AliEveMUONChamberData& operator=(const AliEveMUONChamberData&); // Not implemented
private:
public:
- MUONChamberData(Int_t chamber);
- virtual ~MUONChamberData();
+ AliEveMUONChamberData(Int_t chamber);
+ virtual ~AliEveMUONChamberData();
void DropData();
Float_t* GetChamberBox() { return &fChamberBox[0]; };
- ClassDef(MUONChamberData,1); // class with data for one chamber
+ ClassDef(AliEveMUONChamberData,1); // class with data for one chamber
};
-}
-
#endif
-#include "MUONChamberEditor.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include <Alieve/MUONChamber.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveMUONChamberEditor.h"
+
+#include <Alieve/AliEveMUONChamber.h>
#include <TEveGValuators.h>
#include <TGColorSelect.h>
#include <TGSlider.h>
#include <TGDoubleSlider.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// MUONChamberEditor
+// AliEveMUONChamberEditor
//
-ClassImp(MUONChamberEditor)
+ClassImp(AliEveMUONChamberEditor)
//______________________________________________________________________
-MUONChamberEditor::MUONChamberEditor(const TGWindow *p,
+AliEveMUONChamberEditor::AliEveMUONChamberEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
// constructor
//
- MakeTitle("MUONChamber");
+ MakeTitle("AliEveMUONChamber");
Int_t labelW = 60;
fThreshold->GetSlider()->SetWidth(120);
fThreshold->SetLimits(0,4096);
fThreshold->Connect("ValueSet(Double_t)",
- "Alieve::MUONChamberEditor", this, "DoThreshold()");
+ "AliEveMUONChamberEditor", this, "DoThreshold()");
AddFrame(fThreshold, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fMaxVal = new TEveGValuator(this,"ADC max", 200, 0);
fMaxVal->GetSlider()->SetWidth(120);
fMaxVal->SetLimits(0, 4096);
fMaxVal->Connect("ValueSet(Double_t)",
- "Alieve::MUONChamberEditor", this, "DoMaxVal()");
+ "AliEveMUONChamberEditor", this, "DoMaxVal()");
AddFrame(fMaxVal, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fClusterSize = new TEveGValuator(this,"Cls size", 200, 0);
fClusterSize->SetLimits(0, 24);
fClusterSize->SetToolTip("Size of displayed clusters");
fClusterSize->Connect("ValueSet(Double_t)",
- "Alieve::MUONChamberEditor", this, "DoClusterSize()");
+ "AliEveMUONChamberEditor", this, "DoClusterSize()");
AddFrame(fClusterSize, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fHitSize = new TEveGValuator(this,"TEveHit size", 200, 0);
fHitSize->SetLimits(0, 24);
fHitSize->SetToolTip("Size of displayed clusters");
fHitSize->Connect("ValueSet(Double_t)",
- "Alieve::MUONChamberEditor", this, "DoHitSize()");
+ "AliEveMUONChamberEditor", this, "DoHitSize()");
AddFrame(fHitSize, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
}
//______________________________________________________________________
-MUONChamberEditor::~MUONChamberEditor()
+AliEveMUONChamberEditor::~AliEveMUONChamberEditor()
{
//
// destructor
}
//______________________________________________________________________
-void MUONChamberEditor::SetModel(TObject* obj)
+void AliEveMUONChamberEditor::SetModel(TObject* obj)
{
//
// ...
//
- fM = dynamic_cast<MUONChamber*>(obj);
+ fM = dynamic_cast<AliEveMUONChamber*>(obj);
fThreshold->SetValue(fM->fThreshold);
fMaxVal->SetValue(fM->fMaxVal);
}
//______________________________________________________________________
-void MUONChamberEditor::DoThreshold()
+void AliEveMUONChamberEditor::DoThreshold()
{
//
// set digit minimum amplitude
}
//______________________________________________________________________
-void MUONChamberEditor::DoMaxVal()
+void AliEveMUONChamberEditor::DoMaxVal()
{
//
// set digit maximum amplitude
}
//______________________________________________________________________
-void MUONChamberEditor::DoClusterSize()
+void AliEveMUONChamberEditor::DoClusterSize()
{
//
// set the cluster point size
}
//______________________________________________________________________
-void MUONChamberEditor::DoHitSize()
+void AliEveMUONChamberEditor::DoHitSize()
{
//
// set the hit point size
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#ifndef ALIEVE_MUONChamberEditor_H
+#define ALIEVE_MUONChamberEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+class TGDoubleHSlider;
+class TGHSlider;
+
+class TEveGValuator;
+
+
+class AliEveMUONChamber;
+
+class AliEveMUONChamberEditor : public TGedFrame
+{
+
+ AliEveMUONChamberEditor(const AliEveMUONChamberEditor&); // Not implemented
+ AliEveMUONChamberEditor& operator=(const AliEveMUONChamberEditor&); // Not implemented
+
+ protected:
+
+ AliEveMUONChamber* fM; // fModel dynamic-casted to AliEveMUONChamberEditor
+
+ TEveGValuator *fThreshold; // digit ADC min
+ TEveGValuator *fMaxVal; // digit ADC max
+ TEveGValuator *fClusterSize; // cluster point size
+ TEveGValuator *fHitSize; // hit point size
+
+ public:
+
+ AliEveMUONChamberEditor(const TGWindow* p = 0,
+ Int_t width = 170, Int_t height = 30,
+ UInt_t options = kChildFrame,
+ Pixel_t back = GetDefaultFrameBackground());
+
+ virtual ~AliEveMUONChamberEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ void DoThreshold();
+ void DoMaxVal();
+ void DoClusterSize();
+ void DoHitSize();
+
+ ClassDef(AliEveMUONChamberEditor, 0); // Editor for AliEveMUONChamber
+
+};
+
+#endif
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
#include <TMath.h>
-#include "MUONChamberGL.h"
+#include "AliEveMUONChamberGL.h"
-#include <Alieve/MUONChamber.h>
-#include <Alieve/MUONChamberData.h>
+#include <Alieve/AliEveMUONChamber.h>
+#include <Alieve/AliEveMUONChamberData.h>
#include <TEveQuadSetGL.h>
#include <TGLRnrCtx.h>
#include <TGLIncludes.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// MUONChamberGL
+// AliEveMUONChamberGL
//
-ClassImp(MUONChamberGL)
+ClassImp(AliEveMUONChamberGL)
//______________________________________________________________________
-MUONChamberGL::MUONChamberGL() :
+AliEveMUONChamberGL::AliEveMUONChamberGL() :
TGLObject(),
fChamber(0),
fRTS(0)
}
//______________________________________________________________________
-MUONChamberGL::~MUONChamberGL()
+AliEveMUONChamberGL::~AliEveMUONChamberGL()
{
//
// destructor
}
//______________________________________________________________________
-Bool_t MUONChamberGL::SetModel(TObject* obj, const Option_t* /*opt*/)
+Bool_t AliEveMUONChamberGL::SetModel(TObject* obj, const Option_t* /*opt*/)
{
//
// ...
//
- if(SetModelCheckClass(obj, Alieve::MUONChamber::Class())) {
+ if(SetModelCheckClass(obj, AliEveMUONChamber::Class())) {
- fChamber = (MUONChamber*) fExternalObj;
+ fChamber = (AliEveMUONChamber*) fExternalObj;
fQS1.SetModel(&fChamber->fQuadSet1);
fQS2.SetModel(&fChamber->fQuadSet2);
return kTRUE;
}
//______________________________________________________________________
-void MUONChamberGL::SetBBox()
+void AliEveMUONChamberGL::SetBBox()
{
//
// ...
//
- SetAxisAlignedBBox(((MUONChamber*)fExternalObj)->AssertBBox());
+ SetAxisAlignedBBox(((AliEveMUONChamber*)fExternalObj)->AssertBBox());
}
//______________________________________________________________________
-void MUONChamberGL::DirectDraw(TGLRnrCtx& rnrCtx) const
+void AliEveMUONChamberGL::DirectDraw(TGLRnrCtx& rnrCtx) const
{
//
// Actual GL drawing.
}
//______________________________________________________________________
-void MUONChamberGL::DrawQuads(TGLRnrCtx& rnrCtx) const
+void AliEveMUONChamberGL::DrawQuads(TGLRnrCtx& rnrCtx) const
{
//
// draw the digits as GL_QUADS
}
//______________________________________________________________________
-void MUONChamberGL::DrawPoints() const
+void AliEveMUONChamberGL::DrawPoints() const
{
//
// draw the clusters as GL_QUADS
}
//______________________________________________________________________
-void MUONChamberGL::DrawChamberFrame() const
+void AliEveMUONChamberGL::DrawChamberFrame() const
{
//
// draw the chamber frame as GL_LINE_LOOP
//
- MUONChamberData* chamberData = fChamber->GetChamberData();
+ AliEveMUONChamberData* chamberData = fChamber->GetChamberData();
Int_t nDetElem = chamberData->GetNDetElem();
Float_t *frameCoord;
Float_t xOrig, yOrig, xRad, yRad, x, y, z;
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#ifndef ALIEVE_MUONChamberGL_H
+#define ALIEVE_MUONChamberGL_H
+
+#include <TGLObject.h>
+#include <TEveQuadSetGL.h>
+
+class TEveQuadSetGL;
+
+
+class AliEveMUONChamber;
+
+class AliEveMUONChamberGL : public TGLObject
+{
+
+ AliEveMUONChamberGL(const AliEveMUONChamberGL&); // Not implemented
+ AliEveMUONChamberGL& operator=(const AliEveMUONChamberGL&); // Not implemented
+
+ protected:
+
+ virtual void DirectDraw(TGLRnrCtx & rnrCtx) const;
+ void DrawChamberFrame() const;
+ void DrawQuads(TGLRnrCtx& rnrCtx) const;
+ void DrawPoints() const;
+
+ AliEveMUONChamber* fChamber; // fModel dynamic-casted to AliEveMUONChamberGL
+ TEveQuadSetGL fQS1;
+ TEveQuadSetGL fQS2;
+
+ mutable UInt_t fRTS; // render time stamp
+
+ public:
+
+ AliEveMUONChamberGL();
+ virtual ~AliEveMUONChamberGL();
+
+ virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
+ virtual void SetBBox();
+
+ ClassDef(AliEveMUONChamberGL,1); // the GL drawing class of one chamber
+
+};
+
+#endif
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
//
// Sources:
//
// LoadRawTrigger = MUONRawStreamTrigger.C
//
-#include "MUONData.h"
+#include "AliEveMUONData.h"
-#include <Alieve/MUONChamberData.h>
-#include <Alieve/EventAlieve.h>
+#include <Alieve/AliEveMUONChamberData.h>
+#include <Alieve/AliEveEventManager.h>
#include <AliRawReader.h>
#include <AliRawReaderFile.h>
#include "TString.h"
#include "TClonesArray.h"
#include "TList.h"
-using namespace Alieve;
+
//______________________________________________________________________
-// MUONData
+// AliEveMUONData
//
-ClassImp(MUONData)
+ClassImp(AliEveMUONData)
-AliRawReader* MUONData::fgRawReader = 0;
+AliRawReader* AliEveMUONData::fgRawReader = 0;
//______________________________________________________________________
-MUONData::MUONData() :
+AliEveMUONData::AliEveMUONData() :
fChambers(14),
fNTrackList(0)
{
}
//______________________________________________________________________
-MUONData::~MUONData()
+AliEveMUONData::~AliEveMUONData()
{
//
// Destructor
}
//______________________________________________________________________
-void MUONData::Reset()
+void AliEveMUONData::Reset()
{
//
// Reset data
}
//______________________________________________________________________
-MUONData::MUONData(const MUONData &mdata) :
+AliEveMUONData::AliEveMUONData(const AliEveMUONData &mdata) :
TObject(mdata),
TEveRefCnt(),
fChambers(14),
}
//______________________________________________________________________
-MUONData& MUONData::operator=(const MUONData &mdata)
+AliEveMUONData& AliEveMUONData::operator=(const AliEveMUONData &mdata)
{
//
// Assignment operator
}
//______________________________________________________________________
-void MUONData::CreateChamber(Int_t chamber)
+void AliEveMUONData::CreateChamber(Int_t chamber)
{
//
// create data for the chamber with id=chamber (0 to 13)
//
if (fChambers[chamber] == 0)
- fChambers[chamber] = new MUONChamberData(chamber);
+ fChambers[chamber] = new AliEveMUONChamberData(chamber);
}
//______________________________________________________________________
-void MUONData::CreateAllChambers()
+void AliEveMUONData::CreateAllChambers()
{
//
// create all 14 chambers data
}
//______________________________________________________________________
-void MUONData::DropAllChambers()
+void AliEveMUONData::DropAllChambers()
{
//
// release data from all chambers
}
//______________________________________________________________________
-void MUONData::DeleteAllChambers()
+void AliEveMUONData::DeleteAllChambers()
{
//
// delete all chambers data
}
//______________________________________________________________________
-void MUONData::RegisterTrack(Int_t track)
+void AliEveMUONData::RegisterTrack(Int_t track)
{
//
// register (in a list) a track with hits in the chambers
}
//______________________________________________________________________
-void MUONData::LoadRecPoints(TTree* tree)
+void AliEveMUONData::LoadRecPoints(TTree* tree)
{
//
// load reconstructed points from the TreeR
}
//______________________________________________________________________
-void MUONData::LoadHits(TTree* tree)
+void AliEveMUONData::LoadHits(TTree* tree)
{
//
// load simulation hits from the TreeH
}
//______________________________________________________________________
-void MUONData::LoadDigits(TTree* tree)
+void AliEveMUONData::LoadDigits(TTree* tree)
{
//
// load digits from the TreeD
}
//______________________________________________________________________
-void MUONData::LoadRaw(TString fileName)
+void AliEveMUONData::LoadRaw(TString fileName)
{
//
// load raw data from fileName; tracker and trigger data
Int_t iEvent = 0;
while (fgRawReader->NextEvent())
{
- if (iEvent != Alieve::gEvent->GetEventId())
+ if (iEvent != gEvent->GetEventId())
{
iEvent++;
continue;
}
//______________________________________________________________________
-Int_t MUONData::GetTrack(Int_t index)
+Int_t AliEveMUONData::GetTrack(Int_t index)
{
//
// return track stack number for "index"-th track with hits in the chambers
}
//______________________________________________________________________
-MUONChamberData* MUONData::GetChamberData(Int_t chamber)
+AliEveMUONChamberData* AliEveMUONData::GetChamberData(Int_t chamber)
{
//
// return chamber data
-#include "MUONTrack.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include <Alieve/EventAlieve.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveMUONTrack.h"
+
+#include <Alieve/AliEveEventManager.h>
#include <AliMagF.h>
#include <AliMagFMaps.h>
#include <TParticlePDG.h>
#include <Riostream.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// MUONTrack
+// AliEveMUONTrack
// Produce TEveUtil:TEveTrack from AliMUONTrack with dipole field model
-ClassImp(MUONTrack)
+ClassImp(AliEveMUONTrack)
-AliMagF* MUONTrack::fFieldMap = 0;
+AliMagF* AliEveMUONTrack::fFieldMap = 0;
//______________________________________________________________________
-MUONTrack::MUONTrack(TEveRecTrack* t, TEveTrackPropagator* rs) :
+AliEveMUONTrack::AliEveMUONTrack(TEveRecTrack* t, TEveTrackPropagator* rs) :
TEveTrack(t,rs),
fTrack(0),
fPart(0),
// constructor
//
- fFieldMap = Alieve::Event::AssertMagField();
+ fFieldMap = AliEveEventManager::AssertMagField();
}
//______________________________________________________________________
-MUONTrack::~MUONTrack()
+AliEveMUONTrack::~AliEveMUONTrack()
{
//
// destructor
}
//______________________________________________________________________
-void MUONTrack::PrintMCTrackInfo()
+void AliEveMUONTrack::PrintMCTrackInfo()
{
//
// information about the MC particle
}
//______________________________________________________________________
-void MUONTrack::PrintMUONTrackInfo()
+void AliEveMUONTrack::PrintMUONTrackInfo()
{
//
// information about the reconstructed/reference track; at hits and at vertex
}
//______________________________________________________________________
-void MUONTrack::PrintMUONTriggerTrackInfo()
+void AliEveMUONTrack::PrintMUONTriggerTrackInfo()
{
//
// information about the trigger track
}
//______________________________________________________________________
-void MUONTrack::PrintESDTrackInfo()
+void AliEveMUONTrack::PrintESDTrackInfo()
{
//
// information about the reconstructed ESD track at vertex
setw(8) << setprecision(4) <<
mtp->P() << " GeV/c" << endl;
- AliESDEvent* esd = Alieve::Event::AssertESD();
+ AliESDEvent* esd = AliEveEventManager::AssertESD();
Double_t spdVertexX = 0;
Double_t spdVertexY = 0;
}
//______________________________________________________________________
-void MUONTrack::MUONTrackInfo()
+void AliEveMUONTrack::MUONTrackInfo()
{
//
// MENU function
}
//______________________________________________________________________
-void MUONTrack::MUONTriggerInfo()
+void AliEveMUONTrack::MUONTriggerInfo()
{
//
// MENU function
//
if (fIsMUONTrack) {
- TEveUtil::LoadMacro("MUON_trigger_info.C");
+ TEveUtil::TEveUtil::LoadMacro("MUON_trigger_info.C");
gROOT->ProcessLine(Form("MUON_trigger_info(%d);", fLabel));
}
if (fIsRefTrack) {
}
if (fIsESDTrack) {
- AliESDEvent* esd = Alieve::Event::AssertESD();
+ AliESDEvent* esd = AliEveEventManager::AssertESD();
ULong64_t triggerMask = esd->GetTriggerMask();
cout << endl;
}
//______________________________________________________________________
-void MUONTrack::MakeMUONTrack(AliMUONTrack *mtrack)
+void AliEveMUONTrack::MakeMUONTrack(AliMUONTrack *mtrack)
{
//
// builds the track with dipole field
if (fIsMUONTrack) {
if (mtrack->GetMatchTrigger()) {
- sprintf(form,"MUONTrack %2d (MT)", fLabel);
+ sprintf(form,"AliEveMUONTrack %2d (MT)", fLabel);
} else {
- sprintf(form,"MUONTrack %2d ", fLabel);
+ sprintf(form,"AliEveMUONTrack %2d ", fLabel);
}
SetName(form);
SetLineStyle(1);
}
//______________________________________________________________________
-void MUONTrack::MakeMUONTriggerTrack(AliMUONTriggerTrack *mtrack)
+void AliEveMUONTrack::MakeMUONTriggerTrack(AliMUONTriggerTrack *mtrack)
{
//
// builds the trigger track from one point and direction
}
//______________________________________________________________________
-void MUONTrack::MakeESDTrack(AliESDMuonTrack *mtrack)
+void AliEveMUONTrack::MakeESDTrack(AliESDMuonTrack *mtrack)
{
//
// builds the track with dipole field starting from the TParticle
}
//______________________________________________________________________
-void MUONTrack::MakeMCTrack(TParticle *part)
+void AliEveMUONTrack::MakeMCTrack(TParticle *part)
{
//
// builds the track with dipole field starting from the TParticle
}
//______________________________________________________________________
-void MUONTrack::MakeRefTrack(AliMUONTrack *mtrack)
+void AliEveMUONTrack::MakeRefTrack(AliMUONTrack *mtrack)
{
//
// builds the track with dipole field starting from the TParticle
}
//______________________________________________________________________
-void MUONTrack::Propagate(Float_t *xr, Float_t *yr, Float_t *zr, Int_t i1, Int_t i2)
+void AliEveMUONTrack::Propagate(Float_t *xr, Float_t *yr, Float_t *zr, Int_t i1, Int_t i2)
{
//
// propagate in magnetic field between hits of indices i1 and i2
}
//______________________________________________________________________
-void MUONTrack::GetField(Double_t *position, Double_t *field)
+void AliEveMUONTrack::GetField(Double_t *position, Double_t *field)
{
//
// returns field components at position, for a give field map
}
//______________________________________________________________________
-void MUONTrack::OneStepRungekutta(Double_t charge, Double_t step,
+void AliEveMUONTrack::OneStepRungekutta(Double_t charge, Double_t step,
Double_t* vect, Double_t* vout)
{
/// ******************************************************************
}
//______________________________________________________________________
-Int_t MUONTrack::ColorIndex(Float_t val)
+Int_t AliEveMUONTrack::ColorIndex(Float_t val)
{
//
// returns color index in the palette for a give value
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_MUONTrack_H
#define ALIEVE_MUONTrack_H
class TEveTrackPropagator;
class TEveRecTrack;
-namespace Alieve {
-class MUONTrack: public TEveTrack
+class AliEveMUONTrack: public TEveTrack
{
- MUONTrack(const MUONTrack&); // Not implemented
- MUONTrack& operator=(const MUONTrack&); // Not implemented
+ AliEveMUONTrack(const AliEveMUONTrack&); // Not implemented
+ AliEveMUONTrack& operator=(const AliEveMUONTrack&); // Not implemented
public:
- MUONTrack(TEveRecTrack* t, TEveTrackPropagator* rs);
- virtual ~MUONTrack();
+ AliEveMUONTrack(TEveRecTrack* t, TEveTrackPropagator* rs);
+ virtual ~AliEveMUONTrack();
virtual void MakeTrack(Bool_t /*recurse*/=kFALSE) {}
static AliMagF *fFieldMap; // pointer to the magnetic field map
- ClassDef(MUONTrack, 1); // Produce TEveUtil:TEveTrack from AliMUONTrack
+ ClassDef(AliEveMUONTrack, 1); // Produce TEveUtil:TEveTrack from AliMUONTrack
};
-}
-
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "PMDModule.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEvePMDModule.h"
#include "AliPMDdigit.h"
#include "AliPMDddldata.h"
#include <TClonesArray.h>
-using namespace Alieve;
-const Float_t PMDModule::fgkRad = 0.25;
-const Float_t PMDModule::fgkSqRoot3 = 1.732050808;
-const Float_t PMDModule::fgkZpos = 0.;
-Int_t PMDModule::fPreTotPads = 0;
-Int_t PMDModule::fCpvTotPads = 0;
-Int_t PMDModule::fPreTotAdc = 0;
-Int_t PMDModule::fCpvTotAdc = 0;
+
+const Float_t AliEvePMDModule::fgkRad = 0.25;
+const Float_t AliEvePMDModule::fgkSqRoot3 = 1.732050808;
+const Float_t AliEvePMDModule::fgkZpos = 0.;
+Int_t AliEvePMDModule::fPreTotPads = 0;
+Int_t AliEvePMDModule::fCpvTotPads = 0;
+Int_t AliEvePMDModule::fPreTotAdc = 0;
+Int_t AliEvePMDModule::fCpvTotAdc = 0;
//______________________________________________________________________
-// PMDModule
+// AliEvePMDModule
//
-ClassImp(PMDModule)
+ClassImp(AliEvePMDModule)
-PMDModule::PMDModule():
+AliEvePMDModule::AliEvePMDModule():
fH1(0),
fX(0.),
fY(0.),
}
// -------------------------------------------------------------------- //
-void PMDModule::DisplayInit(Int_t ism)
+void AliEvePMDModule::DisplayInit(Int_t ism)
{
TString smodule = "Module";
smodule+= ism;
// -------------------------------------------------------------------- //
-void PMDModule::DisplayDigitsData(Int_t ism, TTree *pmdt)
+void AliEvePMDModule::DisplayDigitsData(Int_t ism, TTree *pmdt)
{
DisplayInit(ism);
// -------------------------------------------------------------------- //
-void PMDModule::DisplayRawData(Int_t ism, TObjArray *ddlcont)
+void AliEvePMDModule::DisplayRawData(Int_t ism, TObjArray *ddlcont)
{
DisplayInit(ism);
// -------------------------------------------------------------------- //
-void PMDModule::RectGeomCellPos(Int_t ism, Int_t xpad, Int_t ypad,
+void AliEvePMDModule::RectGeomCellPos(Int_t ism, Int_t xpad, Int_t ypad,
Float_t &xpos, Float_t &ypos)
{
// This routine finds the cell eta,phi for the new PMD rectangular
// -------------------------------------------------------------------- //
-void PMDModule::GenerateBox(Int_t ism, Float_t &xism, Float_t &yism,
+void AliEvePMDModule::GenerateBox(Int_t ism, Float_t &xism, Float_t &yism,
Float_t &dxism, Float_t &dyism)
{
const Float_t kDia = 0.50;
// -------------------------------------------------------------------- //
-void PMDModule::SetPosition(Float_t x, Float_t y, Float_t z)
+void AliEvePMDModule::SetPosition(Float_t x, Float_t y, Float_t z)
{
fX = x;
fY = y;
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_PMDModule_H
#define ALIEVE_PMDModule_H
#include <TTree.h>
#include <TH1F.h>
-namespace Alieve {
-class PMDModule : public TEveQuadSet
+class AliEvePMDModule : public TEveQuadSet
{
private:
- PMDModule(const PMDModule&); // Not implemented
- PMDModule& operator=(const PMDModule&); // Not implemented
+ AliEvePMDModule(const AliEvePMDModule&); // Not implemented
+ AliEvePMDModule& operator=(const AliEvePMDModule&); // Not implemented
void RectGeomCellPos(Int_t ism, Int_t irow, Int_t icol,
Float_t &xpos, Float_t &ypos);
public:
- PMDModule();
- virtual ~PMDModule() { delete fH1; }
+ AliEvePMDModule();
+ virtual ~AliEvePMDModule() { delete fH1; }
Int_t GetPRETotPads() const { return fPreTotPads; }
Int_t GetCPVTotPads() const { return fCpvTotPads; }
void DisplayRawData(Int_t ism, TObjArray *ddlcont);
void SetPosition(Float_t x, Float_t y, Float_t z);
- ClassDef(PMDModule, 1);
-}; // endclass PMDModule
-
-}
+ ClassDef(AliEvePMDModule, 1);
+}; // endclass AliEvePMDModule
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "PMDModuleEditor.h"
-#include <Alieve/PMDModule.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEvePMDModuleEditor.h"
+#include <Alieve/AliEvePMDModule.h>
#include <TEveGedEditor.h>
#include <TVirtualPad.h>
#include <TH1F.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// PMDModuleEditor
+// AliEvePMDModuleEditor
//
-ClassImp(PMDModuleEditor)
+ClassImp(AliEvePMDModuleEditor)
-PMDModuleEditor::PMDModuleEditor(const TGWindow *p, Int_t width, Int_t height,
+AliEvePMDModuleEditor::AliEvePMDModuleEditor(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0),
fInfoLabel5(0)
// Initialize widget pointers to 0
{
- MakeTitle("PMDModule");
+ MakeTitle("AliEvePMDModule");
CreateInfoFrame();
}
-void PMDModuleEditor::CreateInfoFrame()
+void AliEvePMDModuleEditor::CreateInfoFrame()
{
fInfoFrame = CreateEditorTabSubFrame("Info");
kFixedWidth |
kOwnBackground);
- title1->AddFrame(new TGLabel(title1, "PMDModule Info"),
+ title1->AddFrame(new TGLabel(title1, "AliEvePMDModule Info"),
new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
title1->AddFrame(new TGHorizontal3DLine(title1),
new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
b = new TGTextButton(f, "Show");
f->AddFrame(b, new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 1, 1, 0, 0));
- b->Connect("Clicked()", "Alieve::PMDModuleEditor", this, "DisplayHistos()");
+ b->Connect("Clicked()", "AliEvePMDModuleEditor", this, "DisplayHistos()");
fInfoFrame->AddFrame(f, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
}
}
-PMDModuleEditor::~PMDModuleEditor()
+AliEvePMDModuleEditor::~AliEvePMDModuleEditor()
{}
/**************************************************************************/
-void PMDModuleEditor::SetModel(TObject* obj)
+void AliEvePMDModuleEditor::SetModel(TObject* obj)
{
- fM = dynamic_cast<PMDModule*>(obj);
+ fM = dynamic_cast<AliEvePMDModule*>(obj);
// Set values of widgets
fInfoLabel5->SetText(Form("Tot ADC for CPV : %d", fM->GetCPVTotAdc()));
}
-void PMDModuleEditor::DisplayHistos()
+void AliEvePMDModuleEditor::DisplayHistos()
{
fM->GetHisto()->Draw();
gPad->Modified();
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_PMDModuleEditor_H
+#define ALIEVE_PMDModuleEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+
+
+class AliEvePMDModule;
+
+class AliEvePMDModuleEditor : public TGedFrame
+{
+private:
+ AliEvePMDModuleEditor(const AliEvePMDModuleEditor&); // Not implemented
+ AliEvePMDModuleEditor& operator=(const AliEvePMDModuleEditor&); // Not implemented
+
+ void CreateInfoFrame();
+
+protected:
+ AliEvePMDModule* fM; // fModel dynamic-casted to AliEvePMDModuleEditor
+
+ TGVerticalFrame* fInfoFrame;
+
+ TGLabel* fInfoLabel0;
+ TGLabel* fInfoLabel1;
+ TGLabel* fInfoLabel2;
+ TGLabel* fInfoLabel3;
+ TGLabel* fInfoLabel4;
+ TGLabel* fInfoLabel5;
+
+public:
+ AliEvePMDModuleEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEvePMDModuleEditor();
+
+ virtual void SetModel(TObject* obj);
+ void DisplayHistos();
+ // void PrintADC();
+
+
+
+ // Declare callback/slot methods
+ // void DoXYZZ();
+
+ ClassDef(AliEvePMDModuleEditor, 0); // Editor for AliEvePMDModule
+}; // endclass AliEvePMDModuleEditor
+
+#endif
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
//////////////////////////////////////////////////////////////////////////
// //
// The main AliEVE drawing module for the T0 detector //
// //
//////////////////////////////////////////////////////////////////////////
-#include "EventAlieve.h"
-#include "T0Module.h"
+#include "AliEveEventManager.h"
+#include "AliEveT0Module.h"
#include <TStyle.h>
#include <TMath.h>
#include <TRandom.h>
#include "AliT0RawReader.h"
#include <AliCDBManager.h>
#include <AliCDBStorage.h>
-using namespace Alieve;
-ClassImp(T0Module)
+
+ClassImp(AliEveT0Module)
/**************************************************************************/
-T0Module::T0Module(const Text_t* n, Int_t sigType, AliT0digit *digits, AliT0RawReader *start)
+AliEveT0Module::AliEveT0Module(const Text_t* n, Int_t sigType, AliT0digit *digits, AliT0RawReader *start)
: TEveQuadSet(n), fSigType(sigType), fDigits(digits), fStart(start)
{
//
}
/**************************************************************************/
-T0Module::~T0Module()
+AliEveT0Module::~AliEveT0Module()
{
}
-void T0Module::LoadRaw(TString fileName, Int_t ievt)
+void AliEveT0Module::LoadRaw(TString fileName, Int_t ievt)
{
AliT0digit *digits = 0;
AliRawReader *reader = new AliRawReaderRoot(fileName,ievt);
// cout<<ievt<<endl;
TEveRGBAPalette* rawPalette = new TEveRGBAPalette(0, 3000);
rawPalette->SetLimits(1, 3000); // Set proper raw time range.
- TEveQuadSet* raw_a = new T0Module("T0_RAW_A", 2,digits, start); raw_a->SetPalette(rawPalette);
+ TEveQuadSet* raw_a = new AliEveT0Module("T0_RAW_A", 2,digits, start); raw_a->SetPalette(rawPalette);
raw_a->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
- TEveQuadSet* raw_c = new T0Module("T0_RAW_C", 3,digits, start); raw_c->SetPalette(rawPalette);
+ TEveQuadSet* raw_c = new AliEveT0Module("T0_RAW_C", 3,digits, start); raw_c->SetPalette(rawPalette);
raw_c->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
Float_t angle = 2 * TMath::Pi() / 12;
start->Next();
}
/**************************************************************************/
-void T0Module::MakeModules(AliT0digit *digits)
+void AliEveT0Module::MakeModules(AliT0digit *digits)
{
TRandom r(0);
TArrayI ADC(24);
TEveRGBAPalette* tdcPalette = new TEveRGBAPalette(0, 9999);
tdcPalette->SetLimits(1, 9999); // Set proper TDC range.
- TEveQuadSet* qa = new T0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
- TEveQuadSet* qc = new T0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
- TEveQuadSet* qat = new T0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
- TEveQuadSet* qct = new T0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);
+ TEveQuadSet* qa = new AliEveT0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
+ TEveQuadSet* qc = new AliEveT0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
+ TEveQuadSet* qat = new AliEveT0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
+ TEveQuadSet* qct = new AliEveT0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);
Float_t angle = 2 * TMath::Pi() / 12;
/**************************************************************************/
-void T0Module::DigitSelected(Int_t idx)
+void AliEveT0Module::DigitSelected(Int_t idx)
{
// Override control-click from TEveQuadSet
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_T0Module_H
#define ALIEVE_T0Module_H
#include <AliT0digit.h>
#include <AliT0RawReader.h>
-namespace Alieve {
-class T0Module : public TEveQuadSet
+class AliEveT0Module : public TEveQuadSet
{
- T0Module(const T0Module&);
- T0Module& operator=(const T0Module&);
+ AliEveT0Module(const AliEveT0Module&);
+ AliEveT0Module& operator=(const AliEveT0Module&);
public:
- T0Module(const Text_t* n="T0Module", Int_t sigType=0, AliT0digit *digits=0,AliT0RawReader *start=0);
- virtual ~T0Module();
+ AliEveT0Module(const Text_t* n="AliEveT0Module", Int_t sigType=0, AliT0digit *digits=0,AliT0RawReader *start=0);
+ virtual ~AliEveT0Module();
virtual void DigitSelected(Int_t idx);
AliT0digit *fDigits;
AliT0RawReader *fStart;
- ClassDef(T0Module,1);
+ ClassDef(AliEveT0Module,1);
};
/*
- class T0ModuleTDC : public T0Module
+ class T0ModuleTDC : public AliEveT0Module
{
public:
// constructor
};
*/
-}
#endif
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
//
-// TOFDigitsInfo
+// AliEveTOFDigitsInfo
//
#include <TEveTreeTools.h>
-#include "TOFDigitsInfo.h"
+#include "AliEveTOFDigitsInfo.h"
#include <AliTOFdigit.h>
#include <AliTOFGeometry.h>
//#include <AliTOFDigitMap.h>
-using namespace Alieve;
+
using namespace std;
//_________________________________________________________
-ClassImp(TOFDigitsInfo)
+ClassImp(AliEveTOFDigitsInfo)
- TOFDigitsInfo::TOFDigitsInfo():
+ AliEveTOFDigitsInfo::AliEveTOFDigitsInfo():
TObject(),
TEveRefCnt(),
fTree (0),
{}
/* ******************************************************* */
-TOFDigitsInfo:: ~TOFDigitsInfo()
+AliEveTOFDigitsInfo:: ~AliEveTOFDigitsInfo()
{
delete fGeom;
}
/* ******************************************************* */
-void TOFDigitsInfo::SetTree(TTree* tree)
+void AliEveTOFDigitsInfo::SetTree(TTree* tree)
{
- static const TEveException eH("TOFDigitsInfo::SetTree ");
+ static const TEveException eH("AliEveTOFDigitsInfo::SetTree ");
if(fGeom == 0) {
fGeom = new AliTOFGeometry();
}
/* ******************************************************* */
-void TOFDigitsInfo::LoadDigits()
+void AliEveTOFDigitsInfo::LoadDigits()
{
TClonesArray *digitsTOF = 0x0;
/* ******************************************************* */
-void TOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
+void AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
Int_t nStrip, Int_t nPadZ, Int_t nPadX,
Int_t indexDigit[3])
{
}
/* ******************************************************* */
-TClonesArray* TOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
+TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
Int_t nStrip)
{
}
/* ******************************************************* */
-TClonesArray* TOFDigitsInfo::GetDigits(Int_t nSector)
+TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector)
{
Int_t newCounter = 0;
}
/* ******************************************************* */
-void TOFDigitsInfo::GetDigits()
+void AliEveTOFDigitsInfo::GetDigits()
{
for (Int_t iSector=0; iSector<fGeom->NSectors(); iSector++) {
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_TOFDigitsInfo_H
#define ALIEVE_TOFDigitsInfo_H
#include <AliTOFGeometry.h>
#include <AliTOFDigitMap.h>
-namespace Alieve {
-class TOFDigitsInfo : public TObject, public TEveRefCnt
+class AliEveTOFDigitsInfo : public TObject, public TEveRefCnt
{
- TOFDigitsInfo(const TOFDigitsInfo&); // Not implemented
- TOFDigitsInfo& operator=(const TOFDigitsInfo&); // Not implemented
+ AliEveTOFDigitsInfo(const AliEveTOFDigitsInfo&); // Not implemented
+ AliEveTOFDigitsInfo& operator=(const AliEveTOFDigitsInfo&); // Not implemented
private:
AliTOFGeometry* fGeom;
AliTOFDigitMap* fTOFdigitMap;
- TOFDigitsInfo();
- virtual ~TOFDigitsInfo();
+ AliEveTOFDigitsInfo();
+ virtual ~AliEveTOFDigitsInfo();
void SetTree(TTree* tree);
void LoadDigits();
TClonesArray* GetDigits(Int_t nSector);
void GetDigits();
- ClassDef(TOFDigitsInfo, 1);
- }; // endclass TOFDigitsInfo
+ ClassDef(AliEveTOFDigitsInfo, 1);
+ }; // endclass AliEveTOFDigitsInfo
-}
#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveTOFDigitsInfoEditor.h"
+#include <Alieve/AliEveTOFDigitsInfo.h>
+
+#include <TVirtualPad.h>
+#include <TColor.h>
+
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGNumberEntry.h>
+#include <TGColorSelect.h>
+#include <TGDoubleSlider.h>
+
+
+//______________________________________________________________________
+// AliEveTOFDigitsInfoEditor
+//
+
+ClassImp(AliEveTOFDigitsInfoEditor)
+
+AliEveTOFDigitsInfoEditor::AliEveTOFDigitsInfoEditor(const TGWindow *p, Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+ fM(0)
+ // Initialize widget pointers to 0
+{
+ MakeTitle("AliEveTOFDigitsInfo");
+
+ // Create widgets
+ // fXYZZ = new TGSomeWidget(this, ...);
+ // AddFrame(fXYZZ, new TGLayoutHints(...));
+ // fXYZZ->Connect("SignalName()", "AliEveTOFDigitsInfoEditor", this, "DoXYZZ()");
+}
+
+AliEveTOFDigitsInfoEditor::~AliEveTOFDigitsInfoEditor()
+{}
+
+/**************************************************************************/
+
+void AliEveTOFDigitsInfoEditor::SetModel(TObject* obj)
+{
+ fM = dynamic_cast<AliEveTOFDigitsInfo*>(obj);
+
+ // Set values of widgets
+ // fXYZZ->SetValue(fM->GetXYZZ());
+}
+
+/**************************************************************************/
+
+// Implements callback/slot methods
+
+// void AliEveTOFDigitsInfoEditor::DoXYZZ()
+// {
+// fM->SetXYZZ(fXYZZ->GetValue());
+// Update();
+// }
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_TOFDigitsInfoEditor_H
+#define ALIEVE_TOFDigitsInfoEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+
+
+class AliEveTOFDigitsInfo;
+
+class AliEveTOFDigitsInfoEditor : public TGedFrame
+{
+private:
+ AliEveTOFDigitsInfoEditor(const AliEveTOFDigitsInfoEditor&); // Not implemented
+ AliEveTOFDigitsInfoEditor& operator=(const AliEveTOFDigitsInfoEditor&); // Not implemented
+
+protected:
+ AliEveTOFDigitsInfo* fM; // fModel dynamic-casted to AliEveTOFDigitsInfoEditor
+
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+
+public:
+ AliEveTOFDigitsInfoEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveTOFDigitsInfoEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ // Declare callback/slot methods
+ // void DoXYZZ();
+
+ ClassDef(AliEveTOFDigitsInfoEditor, 0); // Editor for AliEveTOFDigitsInfo
+}; // endclass AliEveTOFDigitsInfoEditor
+
+#endif
-#include "TOFSector.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveTOFSector.h"
#include <TEveManager.h>
#include <AliTOFGeometry.h>
#include <TStyle.h>
-using namespace Alieve;
+
using namespace std;
-Bool_t TOFSector::fgStaticInitDone = kFALSE;
-TEveFrameBox* TOFSector::fgTOFsectorFrameBox = 0;
-TEveRGBAPalette* TOFSector::fgTOFsectorPalette = 0;
+Bool_t AliEveTOFSector::fgStaticInitDone = kFALSE;
+TEveFrameBox* AliEveTOFSector::fgTOFsectorFrameBox = 0;
+TEveRGBAPalette* AliEveTOFSector::fgTOFsectorPalette = 0;
//_______________________________________________________
-ClassImp(TOFSector)
+ClassImp(AliEveTOFSector)
/* ************************************************************************ */
-TOFSector::TOFSector(const Text_t* n, const Text_t* t) :
+AliEveTOFSector::AliEveTOFSector(const Text_t* n, const Text_t* t) :
TEveQuadSet(n, t),
fTOFgeometry(new AliTOFGeometry()),
fTOFarray(0x0),
}
/* ************************************************************************ */
-TOFSector::TOFSector(TGeoManager *localGeoManager,
+AliEveTOFSector::AliEveTOFSector(TGeoManager *localGeoManager,
Int_t nSector)
:
TEveQuadSet(Form("Sector%i",nSector)),
}
/* ************************************************************************ */
-TOFSector::TOFSector(TGeoManager *localGeoManager,
+AliEveTOFSector::AliEveTOFSector(TGeoManager *localGeoManager,
Int_t nSector,
TClonesArray *tofArray)
:
}
/* ************************************************************************ */
-TOFSector::TOFSector(TGeoManager *localGeoManager,
+AliEveTOFSector::AliEveTOFSector(TGeoManager *localGeoManager,
Int_t nSector,
TTree *tofTree)
:
}
/* ************************************************************************ */
-TOFSector::~TOFSector()
+AliEveTOFSector::~AliEveTOFSector()
{
/*
fGeoManager = 0x0;
/* ************************************************************************ */
/*
-void TOFSector::SetDigitsInfo(TOFDigitsInfo* info)
+void AliEveTOFSector::SetDigitsInfo(AliEveTOFDigitsInfo* info)
{
if(fInfo) fInfo->DecRefCount();
fInfo = info;
}
*/
/* ************************************************************************ */
-void TOFSector::InitStatics()
+void AliEveTOFSector::InitStatics()
{
if (fgStaticInitDone) return;
}
/* ************************************************************************ */
-void TOFSector::InitModule()
+void AliEveTOFSector::InitModule()
{
fDx = fTOFgeometry->XPad()*fTOFgeometry->NpadX();
}
/* ************************************************************************ */
-void TOFSector::LoadQuads()
+void AliEveTOFSector::LoadQuads()
{
Reset(kQT_FreeQuad, kFALSE, 32);
}
/* ************************************************************ */
-void TOFSector::SetTrans()
+void AliEveTOFSector::SetTrans()
{
fHMTrans.UnitTrans();
//-----------------------------------------------------
-void TOFSector::SetSectorID(Int_t id)
+void AliEveTOFSector::SetSectorID(Int_t id)
{
fSectorID = id;
fSector = id;
//-----------------------------------------------------
-void TOFSector::SetPlate(Int_t nPlate, Bool_t r)
+void AliEveTOFSector::SetPlate(Int_t nPlate, Bool_t r)
{
fPlateFlag[nPlate] = r;
/**************************************************************************/
-void TOFSector::SetThreshold(Short_t t)
+void AliEveTOFSector::SetThreshold(Short_t t)
{
fThreshold = TMath::Min(t, (Short_t)(fMaxVal - 1));
// ClearColorArray();
/**************************************************************************/
-void TOFSector::SetMaxVal(Int_t mv)
+void AliEveTOFSector::SetMaxVal(Int_t mv)
{
fMaxVal = TMath::Max(mv, (Int_t)(fThreshold + 1));
//ClearColorArray();
/**************************************************************************/
-void TOFSector::DigitSelected(Int_t idx)
+void AliEveTOFSector::DigitSelected(Int_t idx)
{
// Override control-click from TEveQuadSet
DigitBase_t* qb = GetDigit(idx);
TObject* obj = qb->fId.GetObject();
AliTOFdigit* digs = dynamic_cast<AliTOFdigit*>(obj);
- // printf("TOFSector::QuadSelected "); Print();
+ // printf("AliEveTOFSector::QuadSelected "); Print();
printf(" idx = %5i, value = %5d, obj = 0x%lx, digit = 0x%lx ",
idx, qb->fValue, (ULong_t)obj, (ULong_t)digs);
if (digs)
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_TOFSector_H
#define ALIEVE_TOFSector_H
#include <AliTOFGeometry.h>
-namespace Alieve {
- class TOFSector : public TEveQuadSet
+ class AliEveTOFSector : public TEveQuadSet
{
- TOFSector(const TOFSector&); // Not implemented
- TOFSector& operator=(const TOFSector&); // Not implemented
+ AliEveTOFSector(const AliEveTOFSector&); // Not implemented
+ AliEveTOFSector& operator=(const AliEveTOFSector&); // Not implemented
//Int_t fSectorID;
private:
virtual void InitModule();
virtual void SetTrans();
- TOFSector(const Text_t* n="TOFSector", const Text_t* t=0);
- TOFSector(TGeoManager *localGeoManager, Int_t nSector);
+ AliEveTOFSector(const Text_t* n="AliEveTOFSector", const Text_t* t=0);
+ AliEveTOFSector(TGeoManager *localGeoManager, Int_t nSector);
- TOFSector(TGeoManager *localGeoManager, Int_t nSector,
+ AliEveTOFSector(TGeoManager *localGeoManager, Int_t nSector,
TClonesArray *tofArray);
- TOFSector(TGeoManager *localGeoManager,
+ AliEveTOFSector(TGeoManager *localGeoManager,
Int_t nSector, TTree *tofTree);
- virtual ~TOFSector();
+ virtual ~AliEveTOFSector();
static Bool_t fgStaticInitDone;
static void InitStatics();
static TEveFrameBox *fgTOFsectorFrameBox;
static TEveRGBAPalette *fgTOFsectorPalette;
- ClassDef(TOFSector, 1);
+ ClassDef(AliEveTOFSector, 1);
};
-}
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "TOFSectorEditor.h"
-#include <Alieve/TOFSector.h>
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveTOFSectorEditor.h"
+#include <Alieve/AliEveTOFSector.h>
#include <TVirtualPad.h>
#include <TColor.h>
#include <TGColorSelect.h>
#include <TGSlider.h>
#include <TGDoubleSlider.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// TOFSectorEditor
+// AliEveTOFSectorEditor
//
-ClassImp(TOFSectorEditor)
+ClassImp(AliEveTOFSectorEditor)
- TOFSectorEditor::TOFSectorEditor(const TGWindow *p, Int_t width, Int_t height,
+ AliEveTOFSectorEditor::AliEveTOFSectorEditor(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0) ,
/*
fHMTrans = new TEveTransSubEditor(this);
- fHMTrans->Connect("UseTrans()", "Alieve::TPCSectorVizEditor", this, "Update()");
- fHMTrans->Connect("TransChanged()", "Alieve::TPCSectorVizEditor", this, "Update()");
+ fHMTrans->Connect("UseTrans()", "AliEveTPCSectorVizEditor", this, "Update()");
+ fHMTrans->Connect("TransChanged()", "AliEveTPCSectorVizEditor", this, "Update()");
AddFrame(fHMTrans, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 0, 0));
- MakeTitle("TPCSectorViz");*/
+ MakeTitle("AliEveTPCSectorViz");*/
{
fPlate = new TGCheckButton*[5];
for (Int_t ii=0; ii<5; ii++) fPlate[ii] = new TGCheckButton;
//fPriority = 40;
- MakeTitle("TOFSector");
+ MakeTitle("AliEveTOFSector");
fSectorID = new TEveGValuator(this, "SectorID", 110, 0);
fSectorID->SetLabelWidth(60);
fSectorID->SetLimits(0, 17);
fSectorID->SetToolTip("The 18 Tof Sector's");
fSectorID->Connect("ValueSet(Double_t)",
- "Alieve::TOFSectorEditor", this, "DoSectorID()");
+ "AliEveTOFSectorEditor", this, "DoSectorID()");
// Reuse sectorID for auto-transformation button
fAutoTrans = new TGCheckButton(fSectorID, "AutoTrans");
fAutoTrans->SetToolTipText("Automatically set transformation to true position");
fSectorID->AddFrame(fAutoTrans, new TGLayoutHints(kLHintsLeft, 12, 0, 1, 0));
- fAutoTrans->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoAutoTrans()");
+ fAutoTrans->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoAutoTrans()");
AddFrame(fSectorID, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
// Create widgets
// fXYZZ = new TGSomeWidget(this, ...);
// AddFrame(fXYZZ, new TGLayoutHints(...));
- // fXYZZ->Connect("SignalName()", "Alieve::TOFSectorEditor", this, "DoXYZZ()"); {
+ // fXYZZ->Connect("SignalName()", "AliEveTOFSectorEditor", this, "DoXYZZ()"); {
TGHorizontalFrame* f = new TGHorizontalFrame(this);
Int_t nPlate = 0;
fPlate0 = new TGCheckButton(f, "Plate0");
f->AddFrame(fPlate0, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fPlate0->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate0()");
- //fPlate0->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate(Int_t)");
+ fPlate0->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate0()");
+ //fPlate0->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate(Int_t)");
nPlate = 1;
fPlate1 = new TGCheckButton(f, "Plate 1");
f->AddFrame(fPlate1, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fPlate1->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate1()");
- //fPlate1->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate(Int_t)");
+ fPlate1->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate1()");
+ //fPlate1->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate(Int_t)");
nPlate = 2;
fPlate2 = new TGCheckButton(f, "Plate 2");
f->AddFrame(fPlate2, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fPlate2->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate2()");
- //fPlate2->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate(Int_t)");
+ fPlate2->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate2()");
+ //fPlate2->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate(Int_t)");
nPlate = 3;
fPlate3 = new TGCheckButton(f, "Plate 3");
f->AddFrame(fPlate3, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fPlate3->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate3()");
- //fPlate3->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate(Int_t)");
+ fPlate3->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate3()");
+ //fPlate3->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate(Int_t)");
nPlate = 4;
fPlate4 = new TGCheckButton(f, "Plate 4");
f->AddFrame(fPlate4, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fPlate4->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate4()");
- //fPlate4->Connect("Toggled(Bool_t)","Alieve::TOFSectorEditor", this, "DoPlate(Int_t)");
+ fPlate4->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate4()");
+ //fPlate4->Connect("Toggled(Bool_t)","AliEveTOFSectorEditor", this, "DoPlate(Int_t)");
fPlate[0] = fPlate0;
fThreshold->GetSlider()->SetWidth(120);
fThreshold->SetLimits(0,250);
fThreshold->Connect("ValueSet(Double_t)",
- "Alieve::TOFSectorEditor", this, "DoThreshold()");
+ "AliEveTOFSectorEditor", this, "DoThreshold()");
AddFrame(fThreshold, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fMaxVal = new TEveGValuator(this,"MaxVal", 200, 0);
fMaxVal->GetSlider()->SetWidth(60);
fMaxVal->SetLimits(0, 500);
fMaxVal->Connect("ValueSet(Double_t)",
- "Alieve::TOFSectorEditor", this, "DoMaxVal()");
+ "AliEveTOFSectorEditor", this, "DoMaxVal()");
AddFrame(fMaxVal, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
}
-TOFSectorEditor::~TOFSectorEditor()
+AliEveTOFSectorEditor::~AliEveTOFSectorEditor()
{}
/**************************************************************************/
-void TOFSectorEditor::SetModel(TObject* obj)
+void AliEveTOFSectorEditor::SetModel(TObject* obj)
{
- fM = dynamic_cast<TOFSector*>(obj);
+ fM = dynamic_cast<AliEveTOFSector*>(obj);
fSectorID->SetValue(fM->GetSectorID());
fAutoTrans->SetState(fM->GetAutoTrans() ? kButtonDown : kButtonUp);
}
/**************************************************************************/
-void TOFSectorEditor::DoSectorID()
+void AliEveTOFSectorEditor::DoSectorID()
{
fM->SetSectorID((Int_t) fSectorID->GetValue());
Update();
}
-void TOFSectorEditor::DoAutoTrans()
+void AliEveTOFSectorEditor::DoAutoTrans()
{
fM->SetAutoTrans(fAutoTrans->IsOn());
Update();
/**************************************************************************/
-void TOFSectorEditor::DoPlate(Int_t nPlate)
+void AliEveTOFSectorEditor::DoPlate(Int_t nPlate)
{
fM->SetPlate(nPlate, fPlate[nPlate]->IsOn());
Update();
}
-void TOFSectorEditor::DoPlate0()
+void AliEveTOFSectorEditor::DoPlate0()
{
fM->SetPlate(0, fPlate0->IsOn());
Update();
}
-void TOFSectorEditor::DoPlate1()
+void AliEveTOFSectorEditor::DoPlate1()
{
fM->SetPlate(1, fPlate1->IsOn());
Update();
}
-void TOFSectorEditor::DoPlate2()
+void AliEveTOFSectorEditor::DoPlate2()
{
fM->SetPlate(2, fPlate2->IsOn());
Update();
}
-void TOFSectorEditor::DoPlate3()
+void AliEveTOFSectorEditor::DoPlate3()
{
fM->SetPlate(3, fPlate3->IsOn());
Update();
}
-void TOFSectorEditor::DoPlate4()
+void AliEveTOFSectorEditor::DoPlate4()
{
fM->SetPlate(4, fPlate4->IsOn());
Update();
}
-void TOFSectorEditor::DoThreshold()
+void AliEveTOFSectorEditor::DoThreshold()
{
fM->SetThreshold((Short_t) fThreshold->GetValue());
fThreshold->SetValue(fM->GetThreshold());
Update();
}
-void TOFSectorEditor::DoMaxVal()
+void AliEveTOFSectorEditor::DoMaxVal()
{
fM->SetMaxVal((Int_t) fMaxVal->GetValue());
fMaxVal->SetValue(fM->GetMaxVal());
/**************************************************************************/
/*
-void TOFSectorEditor::DoTime()
+void AliEveTOFSectorEditor::DoTime()
{
fM->SetMinTime((Int_t) fTime->GetMin());
fM->SetMaxTime((Int_t) fTime->GetMax());
// Implements callback/slot methods
-// void TOFSectorEditor::DoXYZZ()
+// void AliEveTOFSectorEditor::DoXYZZ()
// {
// fM->SetXYZZ(fXYZZ->GetValue());
// Update();
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_TOFSectorEditor_H
+#define ALIEVE_TOFSectorEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+class TGDoubleHSlider;
+
+class TGHSlider;
+
+class TEveGValuator;
+class TEveGDoubleValuator;
+class TEveTransSubEditor;
+
+
+ class AliEveTOFSector;
+
+ class AliEveTOFSectorEditor : public TGedFrame
+ {
+ //private:
+ AliEveTOFSectorEditor(const AliEveTOFSectorEditor&); // Not implemented
+ AliEveTOFSectorEditor& operator=(const AliEveTOFSectorEditor&); // Not implemented
+
+ protected:
+ AliEveTOFSector* fM; // fModel dynamic-casted to AliEveTOFSectorEditor
+
+ TEveGValuator* fSectorID;
+
+ TGCheckButton* fAutoTrans;
+
+ TGCheckButton** fPlate;
+
+ TGCheckButton* fPlate0;
+ TGCheckButton* fPlate1;
+ TGCheckButton* fPlate2;
+ TGCheckButton* fPlate3;
+ TGCheckButton* fPlate4;
+
+ TEveGValuator* fThreshold;
+ TEveGValuator* fMaxVal;
+
+
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+
+ public:
+ AliEveTOFSectorEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveTOFSectorEditor();
+
+ virtual void SetModel(TObject* obj);
+ void DoSectorID();
+ void DoAutoTrans();
+ void DoPlate0();
+ void DoPlate1();
+ void DoPlate2();
+ void DoPlate3();
+ void DoPlate4();
+
+ void DoPlate(Int_t nPlate);
+ void DoThreshold();
+ void DoMaxVal();
+
+
+ // Declare callback/slot methods
+ // void DoXYZZ();
+
+ ClassDef(AliEveTOFSectorEditor, 0); // Editor for AliEveTOFSector
+ }; // endclass AliEveTOFSectorEditor
+
+#endif
-#include "TOFStrip.h"
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#include "AliEveTOFStrip.h"
#include <TEveManager.h>
#include <AliTOFGeometry.h>
#include <TStyle.h>
-using namespace Alieve;
+
using namespace std;
-Bool_t TOFStrip::fgStaticInitDone = kFALSE;
-TEveFrameBox* TOFStrip::fgTOFstripFrameBox = 0;
-TEveRGBAPalette* TOFStrip::fgTOFstripPalette = 0;
+Bool_t AliEveTOFStrip::fgStaticInitDone = kFALSE;
+TEveFrameBox* AliEveTOFStrip::fgTOFstripFrameBox = 0;
+TEveRGBAPalette* AliEveTOFStrip::fgTOFstripPalette = 0;
//_______________________________________________________
-ClassImp(TOFStrip)
+ClassImp(AliEveTOFStrip)
/* ************************************************************************ */
-TOFStrip::TOFStrip(const Text_t* n, const Text_t* t) :
+AliEveTOFStrip::AliEveTOFStrip(const Text_t* n, const Text_t* t) :
TEveQuadSet(n, t),
fTOFgeometry(new AliTOFGeometry()),
fTOFarray(0),
}
/* ************************************************************************ */
-TOFStrip::TOFStrip(TGeoManager *localGeoManager,
+AliEveTOFStrip::AliEveTOFStrip(TGeoManager *localGeoManager,
Int_t nSector, Int_t nPlate, Int_t nStrip)
:
TEveQuadSet(Form("Strip%i",nStrip)),
}
/* ************************************************************************ */
-TOFStrip::TOFStrip(TGeoManager *localGeoManager,
+AliEveTOFStrip::AliEveTOFStrip(TGeoManager *localGeoManager,
Int_t nSector, Int_t nPlate, Int_t nStrip,
TClonesArray *tofArray)
:
}
/* ************************************************************************ */
-TOFStrip::~TOFStrip()
+AliEveTOFStrip::~AliEveTOFStrip()
{
fGeoManager = 0x0;
/* ************************************************************************ */
/*
-void TOFStrip::SetDigitsInfo(TOFDigitsInfo* info)
+void AliEveTOFStrip::SetDigitsInfo(AliEveTOFDigitsInfo* info)
{
if(fInfo) fInfo->DecRefCount();
fInfo = info;
}
*/
/* ************************************************************************ */
-void TOFStrip::InitStatics()
+void AliEveTOFStrip::InitStatics()
{
if (fgStaticInitDone) return;
}
/* ************************************************************************ */
-void TOFStrip::InitModule()
+void AliEveTOFStrip::InitModule()
{
fDx = fTOFgeometry->XPad()*fTOFgeometry->NpadX();
}
/* ************************************************************************ */
-void TOFStrip::LoadQuads()
+void AliEveTOFStrip::LoadQuads()
{
//Int_t n_col = gStyle->GetNumberOfColors();
}
/* ************************************************************ */
-void TOFStrip::SetTrans()
+void AliEveTOFStrip::SetTrans()
{
fHMTrans.UnitTrans();
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+#ifndef ALIEVE_TOFStrip_H
+#define ALIEVE_TOFStrip_H
+
+#include <TEveQuadSet.h>
+#include <TEveElement.h>
+
+#include <TEveRGBAPalette.h>
+#include <TEveFrameBox.h>
+
+#include <TGeoManager.h>
+#include <TClonesArray.h>
+
+#include <AliTOFGeometry.h>
+
+
+class AliEveTOFStrip : public TEveQuadSet
+{
+ AliEveTOFStrip(const AliEveTOFStrip&); // Not implemented
+ AliEveTOFStrip& operator=(const AliEveTOFStrip&); // Not implemented
+
+private:
+ void LoadQuads();
+
+protected:
+ virtual void InitModule();
+ virtual void SetTrans();
+
+ AliTOFGeometry* fTOFgeometry;
+
+ TClonesArray *fTOFarray;
+
+ Int_t fSector;
+ Int_t fPlate;
+ Int_t fStrip;
+
+ Float_t fDx;
+ Float_t fDz;
+
+ TGeoManager *fGeoManager;
+
+public:
+ AliEveTOFStrip(const Text_t* n="AliEveTOFStrip", const Text_t* t=0);
+ AliEveTOFStrip(TGeoManager *localGeoManager,
+ Int_t nSector, Int_t nPlate, Int_t nStrip);
+
+ AliEveTOFStrip(TGeoManager *localGeoManager,
+ Int_t nSector, Int_t nPlate, Int_t nStrip,
+ TClonesArray *tofArray);
+ virtual ~AliEveTOFStrip();
+
+ static Bool_t fgStaticInitDone;
+ static void InitStatics();
+
+ static TEveFrameBox* fgTOFstripFrameBox;
+
+ static TEveRGBAPalette* fgTOFstripPalette;
+
+ ClassDef(AliEveTOFStrip, 1);
+};
+#endif
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveTOFStripEditor.h"
+#include <Alieve/AliEveTOFStrip.h>
+
+#include <TVirtualPad.h>
+#include <TColor.h>
+
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGNumberEntry.h>
+#include <TGColorSelect.h>
+#include <TGDoubleSlider.h>
+
+
+//______________________________________________________________________
+// AliEveTOFStripEditor
+//
+
+ClassImp(AliEveTOFStripEditor)
+
+AliEveTOFStripEditor::AliEveTOFStripEditor(const TGWindow *p, Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+ fM(0)
+ // Initialize widget pointers to 0
+{
+ MakeTitle("AliEveTOFStrip");
+
+ // Create widgets
+ // fXYZZ = new TGSomeWidget(this, ...);
+ // AddFrame(fXYZZ, new TGLayoutHints(...));
+ // fXYZZ->Connect("SignalName()", "AliEveTOFStripEditor", this, "DoXYZZ()");
+}
+
+AliEveTOFStripEditor::~AliEveTOFStripEditor()
+{}
+
+/**************************************************************************/
+
+void AliEveTOFStripEditor::SetModel(TObject* obj)
+{
+ fM = dynamic_cast<AliEveTOFStrip*>(obj);
+
+ // Set values of widgets
+ // fXYZZ->SetValue(fM->GetXYZZ());
+}
+
+/**************************************************************************/
+
+// Implements callback/slot methods
+
+// void AliEveTOFStripEditor::DoXYZZ()
+// {
+// fM->SetXYZZ(fXYZZ->GetValue());
+// Update();
+// }
--- /dev/null
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#ifndef ALIEVE_TOFStripEditor_H
+#define ALIEVE_TOFStripEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGNumberEntry;
+class TGColorSelect;
+
+
+class AliEveTOFStrip;
+
+class AliEveTOFStripEditor : public TGedFrame
+{
+private:
+ AliEveTOFStripEditor(const AliEveTOFStripEditor&); // Not implemented
+ AliEveTOFStripEditor& operator=(const AliEveTOFStripEditor&); // Not implemented
+
+protected:
+ AliEveTOFStrip* fM; // fModel dynamic-casted to AliEveTOFStripEditor
+
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+
+public:
+ AliEveTOFStripEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~AliEveTOFStripEditor();
+
+ virtual void SetModel(TObject* obj);
+
+ // Declare callback/slot methods
+ // void DoXYZZ();
+
+ ClassDef(AliEveTOFStripEditor, 0); // Editor for AliEveTOFStrip
+}; // endclass AliEveTOFStripEditor
+
+#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "TPCData.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
-#include <Alieve/TPCSectorData.h>
+#include "AliEveTPCData.h"
+
+#include <Alieve/AliEveTPCSectorData.h>
#include <AliSimDigits.h>
#include <AliTPCParam.h>
#include <AliTPCRawStream.h>
#include <TTree.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// TPCData
+// AliEveTPCData
//
// A central manager for TPC data of an event. Can read digits (from
// a tree: LoadDigits()) and raw-data (via AliRawReader: LoadRaw()).
//
-// The sector data is stored in 36 TPCSectorData objects.
+// The sector data is stored in 36 AliEveTPCSectorData objects.
// Sectors 0 - 17: +z side, 18 - 35: -z side.
// No separation of inner/outer segments, use row numbers for addressing.
//
// You might still want to set load threshold (default iz zero).
//
-ClassImp(TPCData)
+ClassImp(AliEveTPCData)
-TPCData::TPCData() :
+AliEveTPCData::AliEveTPCData() :
fSectors(36), fSectorBlockSize(65536),
fLoadThreshold(0), fLoadPedestal(0), fAutoPedestal(kFALSE)
{
- TPCSectorData::InitStatics();
+ AliEveTPCSectorData::InitStatics();
}
-TPCData::~TPCData()
+AliEveTPCData::~AliEveTPCData()
{
DeleteAllSectors();
}
/**************************************************************************/
-void TPCData::CreateSector(Int_t sector)
+void AliEveTPCData::CreateSector(Int_t sector)
{
if(fSectors[sector] == 0)
- fSectors[sector] = new TPCSectorData(sector, fSectorBlockSize);
+ fSectors[sector] = new AliEveTPCSectorData(sector, fSectorBlockSize);
}
-void TPCData::CreateAllSectors()
+void AliEveTPCData::CreateAllSectors()
{
for(Int_t s=0; s<36; ++s)
CreateSector(s);
}
-void TPCData::DropAllSectors()
+void AliEveTPCData::DropAllSectors()
{
for(Int_t s=0; s<36; ++s) {
if(fSectors[s] != 0)
}
}
-void TPCData::DeleteAllSectors()
+void AliEveTPCData::DeleteAllSectors()
{
for(Int_t s=0; s<36; ++s) {
delete fSectors[s];
/**************************************************************************/
-TPCSectorData* TPCData::GetSectorData(Int_t sector, Bool_t spawnSectors)
+AliEveTPCSectorData* AliEveTPCData::GetSectorData(Int_t sector, Bool_t spawnSectors)
{
if(sector < 0 || sector > 35) return 0;
if(fSectors[sector] == 0 && spawnSectors)
/**************************************************************************/
-void TPCData::LoadDigits(TTree* tree, Bool_t spawnSectors)
+void AliEveTPCData::LoadDigits(TTree* tree, Bool_t spawnSectors)
{
// Load data from TTree of AliSimDigits.
// If spawnSectors is false only sectors that have been created previously
Int_t sector, row, pad, curPad;
Short_t time, signal;
Bool_t inFill = kFALSE;
- TPCSectorData* secData = 0;
+ AliEveTPCSectorData* secData = 0;
Int_t numEnt = (Int_t) tree->GetEntries();
for (Int_t ent=0; ent<numEnt; ent++) {
tree->GetEntry(ent);
- Alieve::TPCSectorData::GetParam().AdjustSectorRow(digit.GetID(), sector, row);
+ AliEveTPCSectorData::GetParam().AdjustSectorRow(digit.GetID(), sector, row);
if(sector >= 36) {
sector -= 36;
- row += TPCSectorData::GetInnSeg().GetNRows();
+ row += AliEveTPCSectorData::GetInnSeg().GetNRows();
}
secData = GetSectorData(sector, spawnSectors);
if(secData == 0)
}
}
-void TPCData::LoadRaw(AliTPCRawStream& input, Bool_t spawnSectors, Bool_t warn)
+void AliEveTPCData::LoadRaw(AliTPCRawStream& input, Bool_t spawnSectors, Bool_t warn)
{
// Load data from AliTPCRawStream.
// If spawnSectors is false only sectors that have been created previously
// via CreateSector() are loaded.
// If spawnSectors is true sectors are created if data for them is encountered.
- static const TEveException eH("TPCData::LoadRaw ");
+ static const TEveException eH("AliEveTPCData::LoadRaw ");
Int_t sector = -1, row = -1, pad = -1, rowOffset = 0;
Short_t time, signal;
Bool_t inFill = kFALSE;
Short_t lastTime = 9999;
Bool_t lastTimeWarn = kFALSE;
- TPCSectorData* secData = 0;
+ AliEveTPCSectorData* secData = 0;
Short_t threshold = fLoadThreshold;
sector = input.GetSector();
if(sector >= 36) {
sector -= 36;
- rowOffset = TPCSectorData::GetInnSeg().GetNRows();
+ rowOffset = AliEveTPCSectorData::GetInnSeg().GetNRows();
} else {
rowOffset = 0;
}
row = input.GetRow() + rowOffset;
pad = input.GetPad();
- if(pad >= TPCSectorData::GetNPadsInRow(row)) {
+ if(pad >= AliEveTPCSectorData::GetNPadsInRow(row)) {
if(warn) {
Warning(eH.Data(), "pad out of range (row=%d, pad=%d, maxpad=%d).",
- row, pad, TPCSectorData::GetNPadsInRow(row));
+ row, pad, AliEveTPCSectorData::GetNPadsInRow(row));
}
continue;
}
- TPCSectorData::PadRowHack* prh = secData->GetPadRowHack(row, pad);
+ AliEveTPCSectorData::PadRowHack* prh = secData->GetPadRowHack(row, pad);
if(prh != 0) {
threshold = prh->fThrExt + Short_t(prh->fThrFac*fLoadThreshold);
} else {
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_TPCData_H
#define ALIEVE_TPCData_H
class AliTPCRawStream;
class AliTPCRawStreamOld;
-namespace Alieve {
-class TPCSectorData;
+class AliEveTPCSectorData;
-class TPCData : public TObject, public TEveRefCnt
+class AliEveTPCData : public TObject, public TEveRefCnt
{
protected:
- std::vector<TPCSectorData*> fSectors;
+ std::vector<AliEveTPCSectorData*> fSectors;
Int_t fSectorBlockSize;
Short_t fLoadThreshold;
Short_t fLoadPedestal;
Bool_t fAutoPedestal;
public:
- TPCData();
- virtual ~TPCData();
+ AliEveTPCData();
+ virtual ~AliEveTPCData();
void CreateSector(Int_t sector);
void CreateAllSectors();
void DropAllSectors();
void DeleteAllSectors();
- TPCSectorData* GetSectorData(Int_t sector, Bool_t spawnSectors=kFALSE);
+ AliEveTPCSectorData* GetSectorData(Int_t sector, Bool_t spawnSectors=kFALSE);
Int_t GetSectorBlockSize() const { return fSectorBlockSize; }
void SetSectorBlockSize(Int_t bs) { fSectorBlockSize = bs; }
void LoadDigits(TTree* tree, Bool_t spawnSectors=kTRUE);
void LoadRaw(AliTPCRawStream& input, Bool_t spawnSectors=kTRUE, Bool_t warn=kFALSE);
- ClassDef(TPCData, 1); // Manages TPC data for an event.
-}; // endclass TPCData
-
-}
+ ClassDef(AliEveTPCData, 1); // Manages TPC data for an event.
+}; // endclass AliEveTPCData
#endif
-// $Header$
-
-#include "TPCLoader.h"
-#include "TPCData.h"
-#include <Alieve/TPCSector2D.h>
-#include <Alieve/TPCSector3D.h>
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveTPCLoader.h"
+#include "AliEveTPCData.h"
+#include <Alieve/AliEveTPCSector2D.h>
+#include <Alieve/AliEveTPCSector3D.h>
#include <TEveManager.h>
#include <TEveGedEditor.h>
#include <AliTPCRawStream.h>
#include <TSystem.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// TPCLoader
+// AliEveTPCLoader
//
-ClassImp(TPCLoader)
+ClassImp(AliEveTPCLoader)
-TPCLoader::TPCLoader(const Text_t* n, const Text_t* t) :
+AliEveTPCLoader::AliEveTPCLoader(const Text_t* n, const Text_t* t) :
TEveElementList(n, t),
fFile(),
fSetInitSectorParams(kFALSE),
fInitMinTime(0), fInitMaxTime(460), fInitThreshold(5), fInitMaxVal(128)
{
- fData = new TPCData;
+ fData = new AliEveTPCData;
}
-TPCLoader::~TPCLoader()
+AliEveTPCLoader::~AliEveTPCLoader()
{
delete fReader;
delete fData;
/**************************************************************************/
-void TPCLoader::RemoveElementLocal(TEveElement* el)
+void AliEveTPCLoader::RemoveElementLocal(TEveElement* el)
{
for(Int_t i=0; i<36; ++i) {
if(fSec2Ds[i] == el) fSec2Ds[i] = 0;
}
}
-void TPCLoader::RemoveElementsLocal()
+void AliEveTPCLoader::RemoveElementsLocal()
{
for(Int_t i=0; i<36; ++i) {
fSec2Ds[i] = 0;
/**************************************************************************/
-void TPCLoader::SetData(TPCData* d)
+void AliEveTPCLoader::SetData(AliEveTPCData* d)
{
delete fData;
fData = d;
/**************************************************************************/
-void TPCLoader::OpenFile()
+void AliEveTPCLoader::OpenFile()
{
- static const TEveException eH("TPCLoader::OpenFile ");
+ static const TEveException eH("AliEveTPCLoader::OpenFile ");
if(gSystem->AccessPathName(fFile, kReadPermission))
throw(eH + "can not read '" + fFile + "'.");
UpdateSectors(kTRUE);
}
-void TPCLoader::LoadEvent()
+void AliEveTPCLoader::LoadEvent()
{
- static const TEveException eH("TPCLoader::LoadEvent ");
+ static const TEveException eH("AliEveTPCLoader::LoadEvent ");
if(fReader == 0)
throw(eH + "data file not opened.");
fData->LoadRaw(input, kTRUE, kTRUE);
}
-void TPCLoader::NextEvent(Bool_t rewindOnEnd)
+void AliEveTPCLoader::NextEvent(Bool_t rewindOnEnd)
{
- static const TEveException eH("TPCLoader::NextEvent ");
+ static const TEveException eH("AliEveTPCLoader::NextEvent ");
if(fReader == 0)
throw(eH + "data file not opened.");
}
}
-void TPCLoader::GotoEvent(Int_t event)
+void AliEveTPCLoader::GotoEvent(Int_t event)
{
- static const TEveException eH("TPCLoader::GotoEvent ");
+ static const TEveException eH("AliEveTPCLoader::GotoEvent ");
if(fReader == 0)
throw(eH + "data file not opened.");
UpdateSectors();
}
-void* TPCLoader::LoopEvent(TPCLoader* loader)
+void* AliEveTPCLoader::LoopEvent(AliEveTPCLoader* loader)
{
loader->NextEvent();
loader->LoadEvent();
/**************************************************************************/
-void TPCLoader::UpdateSectors(Bool_t dropNonPresent)
+void AliEveTPCLoader::UpdateSectors(Bool_t dropNonPresent)
{
gEve->DisableRedraw();
for(Int_t i=0; i<=35; ++i)
{
- TPCSectorData* sd = fData->GetSectorData(i);
+ AliEveTPCSectorData* sd = fData->GetSectorData(i);
// 2D sectors
if(fSec2Ds[i] != 0)
else
{
if(sd != 0) {
- TPCSector2D* s = new TPCSector2D(Form("Sector2D %d", i));
+ AliEveTPCSector2D* s = new AliEveTPCSector2D(Form("Sector2D %d", i));
fSec2Ds[i] = s;
s->SetSectorID(i);
s->SetDataSource(fData);
gEve->EnableRedraw();
}
-void TPCLoader::ReloadSectors()
+void AliEveTPCLoader::ReloadSectors()
{
LoadEvent();
UpdateSectors();
}
-void TPCLoader::CreateSectors3D()
+void AliEveTPCLoader::CreateSectors3D()
{
gEve->DisableRedraw();
for(Int_t i=0; i<=35; ++i) {
- TPCSectorData* sd = fData->GetSectorData(i);
+ AliEveTPCSectorData* sd = fData->GetSectorData(i);
if(sd != 0 && fSec3Ds[i] == 0) {
- TPCSector3D* s = new TPCSector3D(Form("Sector3D %d", i));
+ AliEveTPCSector3D* s = new AliEveTPCSector3D(Form("Sector3D %d", i));
fSec3Ds[i] = s;
s->SetSectorID(i);
s->SetDataSource(fData);
gEve->EnableRedraw();
}
-void TPCLoader::DeleteSectors3D()
+void AliEveTPCLoader::DeleteSectors3D()
{
gEve->DisableRedraw();
for(Int_t i=0; i<=35; ++i) {
/**************************************************************************/
-void TPCLoader::SetInitParams(Int_t mint, Int_t maxt, Int_t thr, Int_t maxval)
+void AliEveTPCLoader::SetInitParams(Int_t mint, Int_t maxt, Int_t thr, Int_t maxval)
{
fSetInitSectorParams = kTRUE;
fInitMinTime = mint;
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_TPCLoader_H
#define ALIEVE_TPCLoader_H
class AliRawReaderRoot;
-namespace Alieve {
-class TPCData;
-class TPCSector2D;
-class TPCSector3D;
+class AliEveTPCData;
+class AliEveTPCSector2D;
+class AliEveTPCSector3D;
-class TPCLoader : public TEveElementList
+class AliEveTPCLoader : public TEveElementList
{
- friend class TPCLoaderEditor;
+ friend class AliEveTPCLoaderEditor;
- TPCLoader(const TPCLoader&); // Not implemented
- TPCLoader& operator=(const TPCLoader&); // Not implemented
+ AliEveTPCLoader(const AliEveTPCLoader&); // Not implemented
+ AliEveTPCLoader& operator=(const AliEveTPCLoader&); // Not implemented
protected:
TString fFile;
TString fTPCEquipementMap;
AliRawReaderRoot* fReader;
- TPCData* fData;
+ AliEveTPCData* fData;
- std::vector<TPCSector2D*> fSec2Ds;
- std::vector<TPCSector3D*> fSec3Ds;
+ std::vector<AliEveTPCSector2D*> fSec2Ds;
+ std::vector<AliEveTPCSector3D*> fSec3Ds;
Bool_t fSetInitSectorParams;
Int_t fInitMinTime;
Int_t fInitMaxVal;
public:
- TPCLoader(const Text_t* n="TPCLoader", const Text_t* t=0);
- virtual ~TPCLoader();
+ AliEveTPCLoader(const Text_t* n="AliEveTPCLoader", const Text_t* t=0);
+ virtual ~AliEveTPCLoader();
virtual void RemoveElementLocal(TEveElement* el);
virtual void RemoveElementsLocal();
void SetTPCEquipementMap(const Text_t* em) { fTPCEquipementMap = em; }
AliRawReaderRoot* GetReader() const { return fReader; }
void SetReader(AliRawReaderRoot* reader) { fReader = reader; }
- TPCData* GetData() const { return fData; }
- void SetData(TPCData* d);
+ AliEveTPCData* GetData() const { return fData; }
+ void SetData(AliEveTPCData* d);
void OpenFile();
void LoadEvent();
void NextEvent(Bool_t rewindOnEnd=kTRUE);
void GotoEvent(Int_t event);
- static void* LoopEvent(TPCLoader* loader);
+ static void* LoopEvent(AliEveTPCLoader* loader);
void UpdateSectors(Bool_t dropNonPresent=kFALSE);
void ReloadSectors();
void SetInitParams(Int_t mint, Int_t maxt, Int_t thr, Int_t maxval=128);
- ClassDef(TPCLoader, 1);
-}; // endclass TPCLoader
-
-}
+ ClassDef(AliEveTPCLoader, 1);
+}; // endclass AliEveTPCLoader
#endif
-// $Header$
-
-#include "TPCLoaderEditor.h"
-#include <Alieve/TPCLoader.h>
-#include <Alieve/TPCData.h>
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#include "AliEveTPCLoaderEditor.h"
+#include <Alieve/AliEveTPCLoader.h>
+#include <Alieve/AliEveTPCData.h>
#include <TEveManager.h>
#include <TEveGValuators.h>
#include <TGNumberEntry.h>
#include <TGFileDialog.h>
#include <TGToolTip.h>
-using namespace Alieve;
+
//______________________________________________________________________
-// TPCLoaderEditor
+// AliEveTPCLoaderEditor
//
-ClassImp(TPCLoaderEditor)
+ClassImp(AliEveTPCLoaderEditor)
- TPCLoaderEditor::TPCLoaderEditor(const TGWindow *p,
+ AliEveTPCLoaderEditor::AliEveTPCLoaderEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
TGedFrame(p, width, height, options | kVerticalFrame, back),
fCreateSectors3D (0),
fDeleteSectors3D (0)
{
- MakeTitle("TPCLoader");
+ MakeTitle("AliEveTPCLoader");
Int_t labelW;
fFile->SetWidth(140);
f->AddFrame(fFile);
fFile->Connect("DoubleClicked()",
- "Alieve::TPCLoaderEditor", this, "FileSelect()");
+ "AliEveTPCLoaderEditor", this, "FileSelect()");
fFile->Connect("TextChanged(const char *)",
- "Alieve::TPCLoaderEditor", this, "FileChanged()");
+ "AliEveTPCLoaderEditor", this, "FileChanged()");
fOpenFile = new TGTextButton(f, "Open");
f->AddFrame(fOpenFile);
fOpenFile->Connect("Clicked()",
- "Alieve::TPCLoaderEditor", this, "DoOpen()");
+ "AliEveTPCLoaderEditor", this, "DoOpen()");
AddFrame(f);
}
- fEvent = new TEveGValuator(this, "Event:", 110, 0);
+ fEvent = new TEveGValuator(this, "AliEveEventManager:", 110, 0);
fEvent->SetShowSlider(kFALSE);
fEvent->SetLabelWidth(labelW);
fEvent->SetNELength(6);
fEvent->SetLimits(0, 1000);
fEvent->SetToolTip("Current event number");
fEvent->Connect("ValueSet(Double_t)",
- "Alieve::TPCLoaderEditor", this, "DoEvent()");
- // Reuse Event for DoubleSR button
+ "AliEveTPCLoaderEditor", this, "DoEvent()");
+ // Reuse AliEveEventManager for DoubleSR button
fDoubleSR = new TGCheckButton(fEvent, "Double SR");
fDoubleSR->SetToolTipText("Double sampling rate");
fEvent->AddFrame(fDoubleSR, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
fDoubleSR->Connect("Toggled(Bool_t)",
- "Alieve::TPCLoaderEditor", this, "DoDoubleSR()");
+ "AliEveTPCLoaderEditor", this, "DoDoubleSR()");
AddFrame(fEvent);
- // TPCData load settings
+ // AliEveTPCData load settings
labelW = 90;
fDataLoadThreshold->SetToolTip("Minimum signal that will be stored (pedestal subtracted first).");
fDataLoadThreshold->Connect
("ValueSet(Double_t)",
- "Alieve::TPCLoaderEditor", this, "DoDataLoadThreshold()");
+ "AliEveTPCLoaderEditor", this, "DoDataLoadThreshold()");
AddFrame(fDataLoadThreshold, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
fDataLoadPedestal = new TEveGValuator(this, "Load pedestal:", 110, 0);
fDataLoadPedestal->SetToolTip("Pedestal that will be subtracted during data loading.");
fDataLoadPedestal->Connect
("ValueSet(Double_t)",
- "Alieve::TPCLoaderEditor", this, "DoDataLoadPedestal()");
+ "AliEveTPCLoaderEditor", this, "DoDataLoadPedestal()");
// Reuse DataLoadPedestal for DataAutoPedestal check button
fDataAutoPedestal = new TGCheckButton(fDataLoadPedestal, "Automatic");
fDataAutoPedestal->SetToolTipText("Determine per-pad pedestal during data loading.");
fDataAutoPedestal->Connect
("Toggled(Bool_t)",
- "Alieve::TPCLoaderEditor", this, "DoDataAutoPedestal()");
+ "AliEveTPCLoaderEditor", this, "DoDataAutoPedestal()");
fDataLoadPedestal->AddFrame(fDataAutoPedestal, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
AddFrame(fDataLoadPedestal);
fUpdateSectors = new TGTextButton(f, "Update Sectors");
f->AddFrame(fUpdateSectors, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
fUpdateSectors->Connect("Clicked()",
- "Alieve::TPCLoaderEditor", this, "DoUpdateSectors()");
+ "AliEveTPCLoaderEditor", this, "DoUpdateSectors()");
fReloadSectors = new TGTextButton(f, "Reload Sectors");
f->AddFrame(fReloadSectors, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
fReloadSectors->Connect("Clicked()",
- "Alieve::TPCLoaderEditor", this, "DoReloadSectors()");
+ "AliEveTPCLoaderEditor", this, "DoReloadSectors()");
AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
}
{
fCreateSectors3D = new TGTextButton(f, "Create 3D");
f->AddFrame(fCreateSectors3D, new TGLayoutHints(kLHintsExpandX, 0,4,0,0));
fCreateSectors3D->Connect("Clicked()",
- "Alieve::TPCLoaderEditor", this, "DoCreateSectors3D()");
+ "AliEveTPCLoaderEditor", this, "DoCreateSectors3D()");
fDeleteSectors3D = new TGTextButton(f, "Delete 3D");
f->AddFrame(fDeleteSectors3D, new TGLayoutHints(kLHintsExpandX, 4,0,0,0));
fDeleteSectors3D->Connect("Clicked()",
- "Alieve::TPCLoaderEditor", this, "DoDeleteSectors3D()");
+ "AliEveTPCLoaderEditor", this, "DoDeleteSectors3D()");
AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
}
}
-TPCLoaderEditor::~TPCLoaderEditor()
+AliEveTPCLoaderEditor::~AliEveTPCLoaderEditor()
{}
/**************************************************************************/
-void TPCLoaderEditor::SetModel(TObject* obj)
+void AliEveTPCLoaderEditor::SetModel(TObject* obj)
{
- fM = dynamic_cast<TPCLoader*>(obj);
+ fM = dynamic_cast<AliEveTPCLoader*>(obj);
// !!!! order changed, need TGTextEntry::SetText NO BLOODY EMIT.
fFile->SetText(fM->fFile);
fEvent->SetEnabled(fM->fEvent >= 0);
fDoubleSR->SetState(fM->fDoubleSR ? kButtonDown : kButtonUp);
- TPCData* tpcd = fM->GetData();
+ AliEveTPCData* tpcd = fM->GetData();
Bool_t tpcp = (tpcd != 0);
fDataLoadThreshold->SetEnabled(tpcp);
fDataLoadPedestal ->SetEnabled(tpcp && ! tpcd->GetAutoPedestal());
};
}
-void TPCLoaderEditor::FileSelect()
+void AliEveTPCLoaderEditor::FileSelect()
{
TGFileInfo fi;
fi.fIniDir = StrDup(gSystem->DirName (fM->fFile));
fFile->SetText(fi.fFilename);
}
-void TPCLoaderEditor::FileChanged()
+void AliEveTPCLoaderEditor::FileChanged()
{
fM->fFile = fFile->GetText();
}
-void TPCLoaderEditor::DoOpen()
+void AliEveTPCLoaderEditor::DoOpen()
{
fM->OpenFile();
SetModel(fM);
/**************************************************************************/
-void TPCLoaderEditor::DoEvent()
+void AliEveTPCLoaderEditor::DoEvent()
{
fM->GotoEvent((Int_t) fEvent->GetValue());
SetModel(fM);
}
-void TPCLoaderEditor::DoDoubleSR()
+void AliEveTPCLoaderEditor::DoDoubleSR()
{
fM->SetDoubleSR(fDoubleSR->IsOn());
Update();
/**************************************************************************/
-void TPCLoaderEditor::DoDataLoadThreshold()
+void AliEveTPCLoaderEditor::DoDataLoadThreshold()
{
if (fM->GetData() == 0) return;
fM->GetData()->SetLoadThreshold((Short_t) fDataLoadThreshold->GetValue());
}
-void TPCLoaderEditor::DoDataLoadPedestal()
+void AliEveTPCLoaderEditor::DoDataLoadPedestal()
{
if (fM->GetData() == 0) return;
fM->GetData()->SetLoadPedestal((Short_t) fDataLoadPedestal->GetValue());
}
-void TPCLoaderEditor::DoDataAutoPedestal()
+void AliEveTPCLoaderEditor::DoDataAutoPedestal()
{
if (fM->GetData() == 0) return;
fM->GetData()->SetAutoPedestal(fDataAutoPedestal->IsOn());
/**************************************************************************/
-void TPCLoaderEditor::DoUpdateSectors()
+void AliEveTPCLoaderEditor::DoUpdateSectors()
{
fM->UpdateSectors();
}
-void TPCLoaderEditor::DoReloadSectors()
+void AliEveTPCLoaderEditor::DoReloadSectors()
{
fM->ReloadSectors();
}
-void TPCLoaderEditor::DoCreateSectors3D()
+void AliEveTPCLoaderEditor::DoCreateSectors3D()
{
fM->CreateSectors3D();
}
-void TPCLoaderEditor::DoDeleteSectors3D()
+void AliEveTPCLoaderEditor::DoDeleteSectors3D()
{
fM->DeleteSectors3D();
}
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
#ifndef ALIEVE_TPCLoaderEditor_H
#define ALIEVE_TPCLoaderEditor_H
class TEveGValuator;
-namespace Alieve {
-class TPCLoader;
+class AliEveTPCLoader;
-class TPCLoaderEditor : public TGedFrame
+class AliEveTPCLoaderEditor : public TGedFrame
{
- TPCLoaderEditor(const TPCLoaderEditor&); // Not implemented
- TPCLoaderEditor& operator=(const TPCLoaderEditor&); // Not implemented
+ AliEveTPCLoaderEditor(const AliEveTPCLoaderEditor&); // Not implemented
+ AliEveTPCLoaderEditor& operator=(const AliEveTPCLoaderEditor&); // Not implemented
protected:
- TPCLoader* fM; // fModel dynamic-casted to TPCLoaderEditor
+ AliEveTPCLoader* fM; // fModel dynamic-casted to AliEveTPCLoaderEditor
TGTextEntry* fFile;
TGTextButton* fOpenFile;
TEveGValuator* fEvent;
TGCheckButton* fDoubleSR;
- // TPCData loading settings
+ // AliEveTPCData loading settings
TEveGValuator* fDataLoadThreshold;
TEveGValuator* fDataLoadPedestal;
TGCheckButton* fDataAutoPedestal;
TGTextButton* fDeleteSectors3D;
public:
- TPCLoaderEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ AliEveTPCLoaderEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
- ~TPCLoaderEditor();
+ ~AliEveTPCLoaderEditor();
virtual void SetModel(TObject* obj);
void DoCreateSectors3D();
void DoDeleteSectors3D();
- ClassDef(TPCLoaderEditor, 0); // Editor for TPCLoader
-}; // endclass TPCLoaderEditor
-
-}
+ ClassDef(AliEveTPCLoaderEditor, 0); // Editor for AliEveTPCLoader
+}; // endclass AliEveTPCLoaderEditor
#endif
-// $Header$
+// $Id$
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
-#include "TPCSector2D.h"
-#include "TPCSector3D.h"
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
-#include <Alieve/TPCData.h>
-#include <Alieve/TPCSectorData.h>
+#include "AliEveTPCSector2D.h"
+#include "AliEveTPCSector3D.h"
+
+#include <Alieve/AliEveTPCData.h>
+#include <Alieve/AliEveTPCSectorData.h>
#include <TEveManager.h>
#include <TH1S.h>
#include <TH2S.h>
#include <TVirtualPad.h>
-using namespace Alieve;
+
using namespace std;
//______________________________________________________________________
-// TPCSector2D
+// AliEveTPCSector2D
//
// Displays TPC raw-data in 2D.
//
// updates take the same time)
//
-ClassImp(T
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff