ClassImp(CLASS)
-CLASS::CLASS(const TGWindow *p, Int_t id, Int_t width, Int_t height,
+CLASS::CLASS(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back)
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+ fM(0)
+ // Initialize widget pointers to 0
{
- fM = 0;
MakeTitle("STEM");
- //!!! create the widgets here ...
-
- // Register the editor.
- TClass *cl = STEM::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
+ // Create widgets
+ // fXYZZ = new TGSomeWidget(this, ...);
+ // AddFrame(fXYZZ, new TGLayoutHints(...));
+ // fXYZZ->Connect("SignalName()", "Alieve::CLASS", this, "DoXYZZ()");
}
CLASS::~CLASS()
/**************************************************************************/
-void CLASS::SetModel(TVirtualPad* pad, TObject* obj, Int_t event)
+void CLASS::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(STEM::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
+ fM = dynamic_cast<STEM*>(obj);
- fM = dynamic_cast<STEM*>(fModel);
-
- SetActive();
+ // Set values of widgets
+ // fXYZZ->SetValue(fM->GetXYZZ());
}
/**************************************************************************/
+
+// Implements callback/slot methods
+
+// void CLASS::DoXYZZ()
+// {
+// fM->SetXYZZ(fXYZZ->GetValue());
+// Update();
+// }
class CLASS : public TGedFrame
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
STEM* fM; // fModel dynamic-casted to CLASS
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+
public:
- CLASS(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
- ~CLASS();
+ CLASS(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~CLASS();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
+ // Declare callback/slot methods
// void DoXYZZ();
ClassDef(CLASS, 0); // Editor for STEM
ClassImp(CLASS)
-CLASS::CLASS()
+CLASS::CLASS() : TGLObject(), fM(0)
{
// fCached = false; // Disable display list.
}
Bool_t CLASS::SetModel(TObject* obj)
{
-#if ROOT_VERSION_CODE <= ROOT_VERSION(5,11,2)
- if(set_model(obj, "Alieve::STEM")) {
-#else
- if(SetModelCheckClass(obj, "Alieve::STEM")) {
-#endif
- fSector = (TPCSector3D*) fExternalObj;
+ if(SetModelCheckClass(obj, STEM::Class())) {
+ fM = dynamic_cast<STEM*>(obj);
return kTRUE;
}
return kFALSE;
void CLASS::SetBBox()
{
// !! This ok if master sub-classed from TAttBBox
- #if ROOT_VERSION_CODE <= ROOT_VERSION(5,11,2)
- set_axis_aligned_bbox(((STEM*)fExternalObj)->AssertBBox());
-#else
SetAxisAlignedBBox(((STEM*)fExternalObj)->AssertBBox());
-#endif
-
}
/**************************************************************************/
#include <TGLObject.h>
+class TGLViewer;
+class TGLScene;
+
namespace Alieve {
class STEM;
class CLASS : public TGLObject
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
STEM* fM; // fModel dynamic-casted to CLASS
virtual Bool_t SetModel(TObject* obj);
virtual void SetBBox();
+ // To support two-level selection
+ // virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
+ // virtual void ProcessSelection(UInt_t* ptr, TGLViewer*, TGLScene*);
+
ClassDef(CLASS, 0);
}; // endclass CLASS
class CLASS
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
public:
CLASS();
+ virtual ~CLASS() {}
ClassDef(CLASS, 1);
}; // endclass CLASS
+2006-10-09 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * VSDCreator.cxx:
+ Youri's changes (merge of V0 and V0MI) were lost after CVS
+ gymnastics (reverting EVE-head to work with tagged version of
+ ROOT).
+
+2006-10-02 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * .SKEL-ged.cxx:
+ * .SKEL-ged.h:
+ * .SKEL-gl.cxx:
+ * .SKEL-gl.h:
+ * .SKEL.h:
+ Changes for new geditor and gl two-level selection; added
+ delarations of private copy-ctor and assignment-op.
+
+ * TPCSector2D.cxx:
+ * TPCSector2D.h:
+ * TPCSector2DEditor.cxx:
+ * TPCSector2DEditor.h:
+ * TPCSector2DGL.cxx:
+ * TPCSector2DGL.h:
+ Added control of pick-mode and display of pad/pad-row histograms
+ as a response to second-level selection hit.
+
+ * TPCSectorViz.h:
+ Added methods GetMin/MaxTime().
+
+ * TPCSectorVizEditor.cxx:
+ Increased widget limits on fThreshold and fMaxVal.
+
+2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * TPCLoaderEditor.cxx:
+ * TPCLoaderEditor.h:
+ * TPCSector2DEditor.cxx:
+ * TPCSector2DEditor.h:
+ * TPCSector3DEditor.cxx:
+ * TPCSector3DEditor.h:
+ * TPCSectorVizEditor.cxx:
+ * TPCSectorVizEditor.h:
+ Conform to new TGedFrame paradigm in ROOT.
+
2006-09-06 Matevz Tadel <matevz.tadel@cern.ch>
* MUONDigitsInfo.cxx:
ClassImp(TPCLoaderEditor)
-TPCLoaderEditor::TPCLoaderEditor(const TGWindow *p, Int_t id,
+TPCLoaderEditor::TPCLoaderEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fM (0),
"Alieve::TPCLoaderEditor", this, "DoDeleteSectors3D()");
AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
}
-
- // Register the editor.
- TClass *cl = TPCLoader::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
TPCLoaderEditor::~TPCLoaderEditor()
/**************************************************************************/
-void TPCLoaderEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
+void TPCLoaderEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(TPCLoader::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fM = dynamic_cast<TPCLoader*>(fModel);
+ fM = dynamic_cast<TPCLoader*>(obj);
// !!!! order changed, need TGTextEntry::SetText NO BLOODY EMIT.
fFile->SetToolTipText(gSystem->DirName(fM->fFile));
fEvent->SetValue(fM->fEvent);
fEvent->SetEnabled(fM->fEvent >= 0);
fDoubleSR->SetState(fM->fDoubleSR ? kButtonDown : kButtonUp);
-
- SetActive();
}
/**************************************************************************/
void TPCLoaderEditor::DoOpen()
{
fM->OpenFile();
- SetModel(fPad, fModel, 0);
+ SetModel(fM);
}
/**************************************************************************/
void TPCLoaderEditor::DoEvent()
{
fM->GotoEvent((Int_t) fEvent->GetValue());
- SetModel(fPad, fModel, 0);
+ SetModel(fM);
}
void TPCLoaderEditor::DoDoubleSR()
TGTextButton* fDeleteSectors3D;
public:
- TPCLoaderEditor(const TGWindow* p=0, Int_t id=-1, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ TPCLoaderEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~TPCLoaderEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void FileSelect();
void FileChanged();
fShowMax (kTRUE),
fAverage (kFALSE),
- fUseTexture (kTRUE)
+ fUseTexture (kTRUE),
+ fPickEmpty (kFALSE),
+ fPickMode (0)
{}
TPCSector2D::~TPCSector2D()
Bool_t fAverage;
Bool_t fUseTexture;
+ Bool_t fPickEmpty;
+ Int_t fPickMode; // 0-print, 1-1dhisto of pad, 2-2dhisto of padrow
public:
TPCSector2D(const Text_t* n="TPCSector2D", const Text_t* t=0);
void SetShowMax(Bool_t sm) { fShowMax = sm; IncRTS(); }
void SetAverage(Bool_t avg) { fAverage = avg; IncRTS(); }
+ Int_t GetPickMode() const { return fPickMode; }
+ void SetPickMode(Int_t mode) { fPickMode = mode; }
+
virtual void ComputeBBox();
virtual void Paint(Option_t* option="");
#include "TPCSector2DEditor.h"
#include <Alieve/TPCSector2D.h>
-#include <TVirtualPad.h>
-#include <TColor.h>
-
-#include <TGLabel.h>
#include <TGButton.h>
-#include <TGNumberEntry.h>
-#include <TGColorSelect.h>
-#include <TGSlider.h>
-#include <TGDoubleSlider.h>
+#include <TGComboBox.h>
+#include <TGLabel.h>
using namespace Reve;
using namespace Alieve;
ClassImp(TPCSector2DEditor)
-TPCSector2DEditor::TPCSector2DEditor(const TGWindow *p, Int_t id,
- Int_t width, Int_t height,
+TPCSector2DEditor::TPCSector2DEditor(const TGWindow *p,
+ Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0),
- fShowMax(0), fAverage(0), fUseTexture(0)
+ fShowMax(0), fAverage(0), fUseTexture(0), fPickEmpty(0), fPickMode(0)
{
MakeTitle("TPCSector2D");
- fUseTexture = new TGCheckButton(this, "UseTexture");
- AddFrame(fUseTexture, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
- fUseTexture->Connect
- ("Toggled(Bool_t)","Alieve::TPCSector2DEditor", this, "DoUseTexture()");
-
{
TGHorizontalFrame* f = new TGHorizontalFrame(this);
fShowMax = new TGCheckButton(f, "ShowMax");
fAverage = new TGCheckButton(f, "Average");
f->AddFrame(fAverage, new TGLayoutHints(kLHintsLeft, 3, 1, 1, 0));
fAverage->Connect("Toggled(Bool_t)","Alieve::TPCSector2DEditor", this, "DoAverage()");
- AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
+ AddFrame(f);
+ }
+ {
+ TGHorizontalFrame* f = new TGHorizontalFrame(this);
+ fUseTexture = new TGCheckButton(f, "UseTexture");
+ f->AddFrame(fUseTexture, new TGLayoutHints(kLHintsTop, 3, 9, 1, 0));
+ fUseTexture->Connect("Toggled(Bool_t)","Alieve::TPCSector2DEditor", this, "DoUseTexture()");
+ fPickEmpty = new TGCheckButton(f, "PickEmpty");
+ f->AddFrame(fPickEmpty, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
+ fPickEmpty->Connect("Toggled(Bool_t)","Alieve::TPCSector2DEditor", this, "DoPickEmpty()");
+ AddFrame(f);
+ }
+ {
+ TGHorizontalFrame* f = new TGHorizontalFrame(this);
+ TGLabel* lab = new TGLabel(f, "PickMode");
+ f->AddFrame(lab, new TGLayoutHints(kLHintsLeft|kLHintsBottom, 1, 10, 1, 2));
+ fPickMode = new TGComboBox(f);
+ fPickMode->AddEntry("Print", 0);
+ fPickMode->AddEntry("1D histo", 1);
+ fPickMode->AddEntry("2D histo", 2);
+ TGListBox* lb = fPickMode->GetListBox();
+ lb->Resize(lb->GetWidth(), 3*16);
+ fPickMode->Resize(80, 20);
+ fPickMode->Connect("Selected(Int_t)", "Alieve::TPCSector2DEditor", this, "DoPickMode(Int_t)");
+ f->AddFrame(fPickMode, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
+ AddFrame(f);
}
-
- // Register the editor.
- TClass *cl = TPCSector2DEditor::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
TPCSector2DEditor::~TPCSector2DEditor()
/**************************************************************************/
-void TPCSector2DEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void TPCSector2DEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(TPCSector2D::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fM = dynamic_cast<TPCSector2D*>(fModel);
+ fM = dynamic_cast<TPCSector2D*>(obj);
fShowMax->SetState(fM->fShowMax ? kButtonDown : kButtonUp);
SetupAverage();
fUseTexture->SetState(fM->fUseTexture ? kButtonDown : kButtonUp);
-
- SetActive();
+ fPickEmpty->SetState(fM->fPickEmpty ? kButtonDown : kButtonUp);
+ fPickMode->Select(fM->fPickMode, kFALSE);
}
/**************************************************************************/
fM->fUseTexture = fUseTexture->IsOn();
Update();
}
+
+void TPCSector2DEditor::DoPickEmpty()
+{
+ fM->fPickEmpty = fPickEmpty->IsOn();
+ // Update();
+}
+
+void TPCSector2DEditor::DoPickMode(Int_t mode)
+{
+ fM->fPickMode = mode;
+ // Update();
+}
#include <TGedFrame.h>
class TGCheckButton;
-class TGNumberEntry;
-class TGColorSelect;
-class TGDoubleHSlider;
-class TGHSlider;
+class TGComboBox;
namespace Alieve {
TGCheckButton* fAverage;
TGCheckButton* fUseTexture;
+ TGCheckButton* fPickEmpty;
+ TGComboBox* fPickMode;
public:
- TPCSector2DEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ TPCSector2DEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~TPCSector2DEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoShowMax();
void DoAverage();
void SetupAverage();
void DoUseTexture();
+ void DoPickEmpty();
+ void DoPickMode(Int_t mode);
ClassDef(TPCSector2DEditor, 0); // Editor for TPCSector2D
}; // endclass TPCSector2DEditor
#include <Alieve/TPCData.h>
+#include <TH1S.h>
+#include <TH2S.h>
+#include <TVirtualPad.h>
#include <TStopwatch.h>
#include <TGLDrawFlags.h>
/**************************************************************************/
+void TPCSector2DGL::ProcessSelection(UInt_t* ptr, TGLViewer*, TGLScene*)
+{
+ if (ptr[0] != 3) return;
+ ptr += 3; // skip n, zmin, zmax
+ Int_t row = ptr[1];
+ Int_t pad = ptr[2];
+ Int_t seg = fSector->fSectorID;
+ if (row < 0 || row >= TPCSectorData::GetNAllRows()) return;
+ if (pad < 0 || pad >= TPCSectorData::GetNPadsInRow(row)) return;
+ // EVE -> Std convention
+ Int_t sseg = seg, srow = row;
+ if (row >= TPCSectorData::GetInnSeg().GetNRows()) {
+ sseg += 18;
+ srow -= TPCSectorData::GetInnSeg().GetNRows();
+ }
+ switch (fSector->fPickMode)
+ {
+ case 0: {
+ printf("TPCSector2DGL::ProcessSelection segment=%d, row=%d, pad=%d\n",
+ sseg, srow, pad);
+ break;
+ }
+ case 1: {
+ if (fSectorData == 0) return;
+ Int_t mint = fSector->GetMinTime();
+ Int_t maxt = fSector->GetMaxTime();
+ TH1S* h = new TH1S(Form("Seg%d_Row%d_Pad%d", sseg, srow, pad),
+ Form("Segment %d, Row %d, Pad %d", sseg, srow, pad),
+ maxt - mint +1 , mint, maxt);
+ h->SetXTitle("Time");
+ h->SetYTitle("ADC");
+ TPCSectorData::PadIterator i = fSectorData->MakePadIterator(row, pad);
+ while (i.Next())
+ h->Fill(i.Time(), i.Signal());
+ h->Draw();
+ gPad->Modified();
+ gPad->Update();
+ break;
+ }
+ case 2: {
+ if (fSectorData == 0) return;
+ Int_t mint = fSector->GetMinTime();
+ Int_t maxt = fSector->GetMaxTime();
+ Int_t npad = TPCSectorData::GetNPadsInRow(row);
+ TH2S* h = new TH2S(Form("Seg%d_Row%d", sseg, srow),
+ Form("Segment %d, Row %d", sseg, srow),
+ maxt - mint +1 , mint, maxt,
+ npad, 0, npad - 1);
+ h->SetXTitle("Time");
+ h->SetYTitle("Pad");
+ h->SetZTitle("ADC");
+ TPCSectorData::RowIterator i = fSectorData->MakeRowIterator(row);
+ while (i.NextPad())
+ while (i.Next())
+ h->Fill(i.Time(), i.Pad(), i.Signal());
+ h->Draw();
+ gPad->Modified();
+ gPad->Update();
+ break;
+ }
+ } // switch
+}
+
+/**************************************************************************/
+
void TPCSector2DGL::DirectDraw(const TGLDrawFlags& flags) const
{
// Actual GL drawing.
glPushName(0);
for (Int_t pad=deltaPad; pad<maxPad; pad++, pix+=4) {
x = x_off + pad*padW;
- // !!! Potentially replace following 'if', add an option to TPCSector2D.
- // !!! Details depend on how data is processed during extraction.
- if (pix[3] != 0) {
+ if (pix[3] != 0 || fSector->fPickEmpty) {
glLoadName(pad - deltaPad);
glBegin(GL_QUADS);
glVertex2f(x+padW, y_d);
#include <Alieve/TPCSector2D.h>
#include <Alieve/TPCSectorData.h>
+class TGLViewer;
+class TGLScene;
namespace Alieve {
virtual void SetBBox();
virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
+ virtual void ProcessSelection(UInt_t* ptr, TGLViewer*, TGLScene*);
+
static void TraceStepsUp (const TPCSectorData::SegmentInfo& s);
static void TraceStepsDown(const TPCSectorData::SegmentInfo& s);
ClassImp(TPCSector3DEditor)
-TPCSector3DEditor::TPCSector3DEditor(const TGWindow *p, Int_t id,
+TPCSector3DEditor::TPCSector3DEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0),
fRnrFrame(0), fDriftVel(0), fPointFrac(0), fPointSize(0)
{
fPointSize->Connect("ValueSet(Double_t)",
"Alieve::TPCSector3DEditor", this, "DoPointSize()");
AddFrame(fPointSize, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
-
- // Register the editor.
- TClass *cl = TPCSector3D::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
TPCSector3DEditor::~TPCSector3DEditor()
/**************************************************************************/
-void TPCSector3DEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
+void TPCSector3DEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(TPCSector3D::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fM = dynamic_cast<TPCSector3D*>(fModel);
+ fM = dynamic_cast<TPCSector3D*>(obj);
fRnrFrame->SetState(fM->fRnrFrame ? kButtonDown : kButtonUp);
fDriftVel->SetValue(fM->fDriftVel);
fPointFrac->SetValue(fM->fPointFrac);
fPointSize->SetValue(fM->fPointSize);
-
- SetActive();
}
/**************************************************************************/
Reve::RGValuator* fPointSize;
public:
- TPCSector3DEditor(const TGWindow* p, Int_t id, Int_t width=170, Int_t height=30,
+ TPCSector3DEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
virtual ~TPCSector3DEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoRnrFrame();
void DoDriftVel();
Int_t GetSectorID() const { return fSectorID; }
TPCSectorData* GetSectorData() const;
+ Int_t GetMinTime() const { return fMinTime; }
+ Int_t GetMaxTime() const { return fMaxTime; }
void SetMinTime(Int_t mt) { fMinTime = mt; IncRTS(); }
void SetMaxTime(Int_t mt) { fMaxTime = mt; IncRTS(); }
void SetThreshold(Short_t t);
ClassImp(TPCSectorVizEditor)
-TPCSectorVizEditor::TPCSectorVizEditor(const TGWindow *p, Int_t id,
+TPCSectorVizEditor::TPCSectorVizEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fM(0),
fSectorID (0), fTrans (0),
fRnrInn (0), fRnrOut1 (0), fRnrOut2(0),
fTime (0)
{
MakeTitle("TPCSectorViz");
+ fPriority = 40;
Int_t labelW = 60;
fThreshold->SetLabelWidth(labelW);
fThreshold->Build();
fThreshold->GetSlider()->SetWidth(120);
- fThreshold->SetLimits(0,149);
+ fThreshold->SetLimits(0,250);
fThreshold->Connect("ValueSet(Double_t)",
"Alieve::TPCSectorVizEditor", this, "DoThreshold()");
AddFrame(fThreshold, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fMaxVal->SetLabelWidth(labelW);
fMaxVal->Build();
fMaxVal->GetSlider()->SetWidth(120);
- fMaxVal->SetLimits(0, 299);
+ fMaxVal->SetLimits(0, 500);
fMaxVal->Connect("ValueSet(Double_t)",
"Alieve::TPCSectorVizEditor", this, "DoMaxVal()");
AddFrame(fMaxVal, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
fTime->Connect("ValueSet()",
"Alieve::TPCSectorVizEditor", this, "DoTime()");
AddFrame(fTime, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
-
-
- // Register the editor.
- TClass *cl = TPCSectorViz::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
TPCSectorVizEditor::~TPCSectorVizEditor()
/**************************************************************************/
-void TPCSectorVizEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
+void TPCSectorVizEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(TPCSectorViz::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fM = dynamic_cast<TPCSectorViz*>(fModel);
+ fM = dynamic_cast<TPCSectorViz*>(obj);
fSectorID->SetValue(fM->fSectorID);
fTrans->SetState(fM->fTrans ? kButtonDown : kButtonUp);
fMaxVal->SetValue(fM->fMaxVal);
fTime->SetValues(fM->fMinTime, fM->fMaxTime);
-
- SetActive();
}
/**************************************************************************/
Reve::RGDoubleValuator* fTime;
public:
- TPCSectorVizEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ TPCSectorVizEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~TPCSectorVizEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoSectorID();
void DoTrans();
+2006-10-12 Matevz Tadel <matevz.tadel@cern.ch>
+
+ Merge changes from EVE-dev to HEAD.
+ Delete all intermediate tags.
+ Tag HEAD: EVE-head-after-merge.
+ Tag EVE-dev: EVE-dev-after-merge.
+
+2006-10-12 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * macros/reve_sa_init.C:
+ New file: initialization script for reve when launched from
+ root.exe (there is unsolved problem with exception-catching in
+ main event-loop).
+
+2006-10-11 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * alice-macros/geom_all.C:
+ New file: full alice geometry.
+
+ * alice-macros/geom_trd_tof.C:
+ New file: combined top-level TRD and TOF geometry.
+
+ * macros/alieve_create_vsd.C:
+ Added loading of libRGL; removed '.so' extensions from all
+ libraries for call to gSystem->Load.
+
+2006-10-11 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * alice-macros/geom_pmd.C:
+ New file: PMD geometry.
+
+ * alice-macros/trd_hits.C:
+ Changed default color.
+
+ * alice-macros/trd_hits_z_split.C:
+ New file: TRD hits split by z-coordinate.
+
+2006-10-04 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * alice-macros/esd_tracks.C:
+ Added function esd_tracks_vertex_cut() that imports esd-tracks and
+ stores them into several containers according to their distance to
+ primary vertex.
+
+ * alice-macros/tpc_digits.C:
+ Added new mode (3): import all sectors and display them in 3D.
+
+2006-10-02 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * alice-macros/hits_from_label.C:
+ Reduce marker size (new convention).
+
+ * alice-macros/tpc_digits.C:
+ Follow-up to change in interface of RGTopFrame.
+
+2006-09-27 Matevz TADEL <matevz.tadel@ijs.si>
+
+ Merged HEAD to EVE-dev. Tagged EVE-dev as
+ EVE-dev-after-second-merge.
+ HEAD was reverted back to work with offical version of ROOT.
+ Now I can get HEAD back to what was until now by:
+ 1. going to EVE-head-after-merge
+ 2. update -j EVE-dev-after-merge -j EVE-dev
+
+2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
+
+ * alice-macros/clusters_from_label.C:
+ Add point-set containing clusters directly as render element (it
+ was wrapped in a RenderElementObjPtr by mistake (not fixed when
+ changing it from TPolyMarker3D)).
+
+ * alice-macros/primary_vertex.C:
+ Removed code that gave vertex markers some volume (to avoid being
+ discarded by a too smart GLViewer).
+
2006-09-04 Matevz Tadel <matevz.tadel@cern.ch>
* alice-macros/its_hits.C:
ClassImp(CLASS)
-CLASS::CLASS(const TGWindow *p, Int_t id, Int_t width, Int_t height,
+CLASS::CLASS(const TGWindow *p, Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back)
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
+ fM(0)
+ // Initialize widget pointers to 0
{
- fM = 0;
MakeTitle("STEM");
- //!!! create the widgets here ...
-
- // Register the editor.
- TClass *cl = STEM::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
+ // Create widgets
+ // fXYZZ = new TGSomeWidget(this, ...);
+ // AddFrame(fXYZZ, new TGLayoutHints(...));
+ // fXYZZ->Connect("SignalName()", "Reve::CLASS", this, "DoXYZZ()");
}
CLASS::~CLASS()
/**************************************************************************/
-void CLASS::SetModel(TVirtualPad* pad, TObject* obj, Int_t event)
+void CLASS::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(STEM::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
+ fM = dynamic_cast<STEM*>(obj);
- fM = dynamic_cast<STEM*>(fModel);
-
- SetActive();
+ // Set values of widgets
+ // fXYZZ->SetValue(fM->GetXYZZ());
}
/**************************************************************************/
+
+// Implements callback/slot methods
+
+// void CLASS::DoXYZZ()
+// {
+// fM->SetXYZZ(fXYZZ->GetValue());
+// Update();
+// }
class CLASS : public TGedFrame
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
STEM* fM; // fModel dynamic-casted to CLASS
+ // Declare widgets
+ // TGSomeWidget* fXYZZ;
+
public:
- CLASS(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
- ~CLASS();
+ CLASS(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ virtual ~CLASS();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
+ // Declare callback/slot methods
// void DoXYZZ();
ClassDef(CLASS, 1); // Editor for STEM
ClassImp(CLASS)
-CLASS::CLASS()
+CLASS::CLASS() : TGLObject(), fM(0)
{
// fCached = false; // Disable display list.
}
Bool_t CLASS::SetModel(TObject* obj)
{
- return set_model(obj, "Reve::STEM");
+ if(SetModelCheckClass(obj, STEM::Class())) {
+ fM = dynamic_cast<STEM*>(obj);
+ return kTRUE;
+ }
+ return kFALSE;
}
void CLASS::SetBBox()
{
// !! This ok if master sub-classed from TAttBBox
- set_axis_aligned_bbox(((STEM*)fExternalObj)->AssertBBox());
+ SetAxisAlignedBBox(((STEM*)fExternalObj)->AssertBBox());
}
/**************************************************************************/
#include <TGLObject.h>
+class TGLViewer;
+class TGLScene;
+
namespace Reve {
-class CLASS
+class STEM;
+
+class CLASS : public TGLObject
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
STEM* fM; // fModel dynamic-casted to CLASS
virtual Bool_t SetModel(TObject* obj);
virtual void SetBBox();
+ // To support two-level selection
+ // virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
+ // virtual void ProcessSelection(UInt_t* ptr, TGLViewer*, TGLScene*);
+
ClassDef(CLASS, 0);
}; // endclass CLASS
class CLASS
{
+private:
+ CLASS(const CLASS&); // Not implemented
+ CLASS& operator=(const CLASS&); // Not implemented
+
protected:
public:
CLASS();
+ virtual ~CLASS() {}
ClassDef(CLASS, 1);
}; // endclass CLASS
Box(Color_t col = 1)
{ Reve::ColorFromIdx(col, color); }
Box(Color_t col, Float_t* p)
- { Reve::ColorFromIdx(col, color); memcpy(vertices, p, 32*sizeof(Float_t)); }
+ { Reve::ColorFromIdx(col, color); memcpy(vertices, p, 24*sizeof(Float_t)); }
Box(TRandom& rnd, Float_t origin, Float_t size);
+2006-10-12 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * BoxSet.h:
+ Fix wrong numerical constant in transformation assignment.
+
+ * RGBrowser.cxx:
+ Added comment about problems with getting context-menu for
+ pointed-to object.
+
+ * RGTopFrame.cxx:
+ * RGTopFrame.h:
+ Added data-members for important GUI elements (master-frame,
+ master-tab); added method 'AddCanvasTab(const char* name)'.
+
+ * Reve.cxx:
+ * Reve.h:
+ Use TString as exception base instead of std::string.
+
+ * VSDSelector.cxx:
+ * VSDSelector.h:
+ Brought in sync with changes in render-element
+ management/conventions.
+
+2006-10-04 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * RenderElement.cxx:
+ * RenderElement.h:
+ Made RenderElement::ExportToCINT() virtual and reimplemented it in
+ RenderElementObjPtr.
+
+ * Track.cxx:
+ * Track.h:
+ Added optional TrackRnrStyle* argument to TrackList constructors;
+ renamed mRnrStyle to fRnrStyle.
+
+2006-10-02 Matevz Tadel <matevz.tadel@cern.ch>
+
+ EVE-dev
+
+ * .SKEL-ged.cxx:
+ * .SKEL-ged.h:
+ * .SKEL-gl.cxx:
+ * .SKEL-gl.h:
+ * .SKEL.h:
+ Changes for new geditor and gl two-level selection; added
+ delarations of private copy-ctor and assignment-op.
+
+ * RGEditor.h:
+ Added method GetRnrElement().
+
+ * RGTopFrame.cxx:
+ * RGTopFrame.h:
+ * RenderElement.cxx:
+ Added RGTopFrame::PreDeleteRenderElement() and calls to it; so far
+ it checks if the object is being displayed in the editor but can
+ in principle check other things as well.
+
+ * RenderElementEditor.cxx:
+ Assgined RenderElementEditor fPriority 0 (to appear on top).
+
+2006-09-27 Matevz Tadel <matevz.tadel@cern.ch>
+
+ * RGTopFrame.cxx:
+ * RGTopFrame.h:
+ * VSDSelector.cxx:
+ Made GLCanvas un-editable to prevent users from drawing things
+ over 3D scene; renamed the canvas data member from fCC to
+ fGLCanvas. Renamed local variables not to dress-up as
+ data-members.
+
+2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
+
+ * RGBrowser.cxx:
+ Hack to fix RenderElementObjPtr's colors in tree-view is no longer
+ needed.
+
+ * RGEditor.cxx:
+ * RGEditor.h:
+ Properly update items of render-elements; call gReve::Redraw3D()
+ instead of pad modified/update. Added separate method
+ DisplayRenderElement() that caches the render-element in a
+ data-member to update it on change (needed for RenderElementObjPtr).
+
+ * RGTopFrame.cxx:
+ Use RGEditor::DisplayRenderElement() instead of
+ DisplayObject(). Removed some never-used static structures.
+
+ * RenderElement.cxx:
+ Removed Redraw3D() from UpdateItems() as it can now be called from
+ RGEditor::Update(); optimized item-updates in SetRnrElement() and
+ SetMainColor().
+
+ * PointSetArrayEditor.cxx:
+ * TrackEditors.cxx:
+ Added call to Update() in SetRange() methods.
+
+2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
+
+ * RGBrowser.cxx:
+ * RGEditor.cxx:
+ * RGEditor.h:
+ Use new functionality from TGedEditor.
+
+ * PointSetArrayEditor.cxx:
+ * PointSetArrayEditor.h:
+ * RGeoNodeEditors.cxx:
+ * RGeoNodeEditors.h:
+ * RenderElementEditor.cxx:
+ * RenderElementEditor.h:
+ * TrackEditors.cxx:
+ * TrackEditors.h:
+ Conform to new TGedFrame paradigm in ROOT.
+
2006-09-04 Matevz Tadel <matevz.tadel@cern.ch>
* MCHelixLine.hi:
ClassImp(PointSetArrayEditor)
-PointSetArrayEditor::PointSetArrayEditor(const TGWindow *p, Int_t id, Int_t width, Int_t height,
- UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+PointSetArrayEditor::PointSetArrayEditor(const TGWindow *p,
+ Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p,width, height, options | kVerticalFrame, back),
fM(0),
fRange(0)
{
fRange->Connect("ValueSet()",
"Reve::PointSetArrayEditor", this, "DoRange()");
AddFrame(fRange, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
-
- // Register the editor.
- TClass *cl = PointSetArray::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
PointSetArrayEditor::~PointSetArrayEditor()
/**************************************************************************/
-void PointSetArrayEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void PointSetArrayEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(PointSetArray::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fM = dynamic_cast<PointSetArray*>(fModel);
+ fM = dynamic_cast<PointSetArray*>(obj);
// printf("FullRange(%f, %f) Selected(%f,%f)\n",
// fM->GetMin(), fM->GetMax(), fM->GetCurMin(), fM->GetCurMax());
fRange->SetLimits(fM->fMin, fM->fMax, TGNumberFormat::kNESRealTwo);
fRange->SetValues(fM->fCurMin, fM->fCurMax);
-
- SetActive();
}
/**************************************************************************/
void PointSetArrayEditor::DoRange()
{
fM->SetRange(fRange->GetMin(), fRange->GetMax());
+ Update();
}
Reve::RGDoubleValuator* fRange;
public:
- PointSetArrayEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ PointSetArrayEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~PointSetArrayEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoRange();
fV2->MapSubwindows();
editor = new RGEditor(glpad);
- editor->GetCan()->ChangeOptions(0);
+ editor->GetTGCanvas()->ChangeOptions(0);
editor->SetWindowName("Reve Editor");
}
{
fClient->SetRoot(fV2);
editor = new RGEditor(glpad);
- editor->GetCan()->ChangeOptions(0);
+ editor->GetTGCanvas()->ChangeOptions(0);
fV2->RemoveFrame(editor);
fV2->AddFrame(editor, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 0, 0, 2, 2));
fClient->SetRoot();
fClient->SetRoot(fV1);
editor = new RGEditor(glpad);
- editor->GetCan()->ChangeOptions(0);
+ editor->GetTGCanvas()->ChangeOptions(0);
editor->ChangeOptions(editor->GetOptions() | kFixedHeight);
fV1->RemoveFrame(editor);
fV1->AddFrame(editor, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 0,2,2,2));
if(re == 0) return;
TObject* obj = re->GetObject();
- // A pathetic hack to get at least a bit of color coordination
- // for RenderElementObjPtr.
- if(item->GetColor() != re->GetMainColor()) {
- item->SetColor(re->GetMainColor());
- fListTree->GetClient()->NeedRedraw(fListTree);
- }
-
if(btn == 3) {
+ // If control pressed, show menu for renderelement itself.
+ // event->fState & kKeyControlMask
+ // ??? how do i get current event?
if (obj) {
fCtxMenu->Popup(x, y, obj);
}
// $Header$
#include "RGEditor.h"
+#include "RenderElement.h"
+#include "RGTopFrame.h"
#include <TGedFrame.h>
#include <TGCanvas.h>
RGEditor::RGEditor(TCanvas* canvas) : TGedEditor(canvas)
{}
+void RGEditor::DisplayRenderElement(RenderElement* re)
+{
+ fRnrElement = re;
+ TObject* obj = fRnrElement ? fRnrElement->GetObject() : 0;
+ SetModel(fPad, obj, kButton1Down);
+}
+
void RGEditor::DisplayObject(TObject* obj)
{
- fModel = obj;
-
- if(obj) {
- if(obj->IsA() != fClass && !obj->IsA()->InheritsFrom(fClass)) {
- fClass = obj->IsA();
- GetEditors();
- }
- } else {
- fCan->UnmapWindow();
- return;
- }
+ fRnrElement = 0;
+ SetModel(fPad, obj, kButton1Down);
+}
+
+void RGEditor::Update(TGedFrame* /*gframe*/)
+{
+ // Virtual method from TGedEditor ... called on every change.
- TGFrameElement *el;
- TIter next(fStyle->GetList());
- while ((el = (TGFrameElement *) next())) {
- if ((el->fFrame)->InheritsFrom(TGedFrame::Class()))
- ((TGedFrame *)(el->fFrame))->SetModel(fPad, fModel, 0);
+ if (fRnrElement) {
+ fRnrElement->UpdateItems();
}
- fCan->MapWindow();
+
+ gReve->Redraw3D();
}
namespace Reve {
+class RenderElement;
+
class RGEditor : public TGedEditor
{
protected:
+ RenderElement* fRnrElement;
public:
RGEditor(TCanvas* canvas=0);
virtual ~RGEditor() {}
+
+ RenderElement* GetRnrElement() const { return fRnrElement; }
+ void DisplayRenderElement(RenderElement* re);
void DisplayObject(TObject* obj);
- TGCanvas * GetCan() const {return fCan;}
+
+ virtual void Update(TGedFrame* gframe=0);
ClassDef(RGEditor, 1);
}; // endclass RGEditor
Reve::RGTopFrame* gReve = 0;
-namespace {
-
-enum RGBrowserMT {
- M_LAYOUT_1,
- M_LAYOUT_2,
- M_LAYOUT_3
-};
-
-const char *xpm_names[] = {
- "lay1.xpm",
- "lay2.xpm",
- "lay3.xpm",
- 0
-};
-
-ToolBarData_t tb_data[] = {
- { "", "Standard list layout", kFALSE, M_LAYOUT_1, NULL },
- { "", "TParticle latout", kFALSE, M_LAYOUT_2, NULL },
- { "", "TGeo layout", kFALSE, M_LAYOUT_3, NULL },
- { NULL, NULL, 0, 0, NULL }
-};
-
-} // unnamed namespace
-
/**************************************************************************/
RGTopFrame::RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look) :
TGMainFrame(p, w, h),
- fCC (0),
- fHistoCanvas (0),
+ fMasterFrame (0),
+ fMasterTab (0),
+ fGLCanvas (0),
fSelector (0),
fBrowser (0),
fStatusBar (0),
// Build GUI
- TGLayoutHints *fL0 = new TGLayoutHints(kLHintsCenterX |kLHintsCenterY | kLHintsExpandY| kLHintsExpandX);
- TGLayoutHints *fL1 = new TGLayoutHints(kLHintsCenterX |kLHintsCenterY | kLHintsExpandY| kLHintsExpandX,2,0,2,2);
- TGLayoutHints* fL2 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY,
- 2, 2, 2, 2);
- TGCompositeFrame* fMainFrame = new TGCompositeFrame(this, w, h,kHorizontalFrame | kRaisedFrame);
- fMainFrame->SetCleanup(kDeepCleanup);
- TGVerticalFrame* fV2 = new TGVerticalFrame(fMainFrame, GetWidth()-40, GetHeight()-40, kSunkenFrame);
+ TGLayoutHints *lay0 = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsExpandY | kLHintsExpandX);
+ TGLayoutHints *lay1 = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsExpandY | kLHintsExpandX, 2, 0, 2, 2);
+ TGLayoutHints *lay2 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2);
+
+ fMasterFrame = new TGCompositeFrame(this, w, h, kHorizontalFrame | kRaisedFrame);
+ TGVerticalFrame* fV2 = new TGVerticalFrame(fMasterFrame, GetWidth()-40, GetHeight()-40, kSunkenFrame);
- fMainFrame->AddFrame(fV2, fL1);
+ fMasterFrame->AddFrame(fV2, lay1);
- // ??? TGCanvas* fCanvasWindow = new TGCanvas(fV2,w,h);
- TGTab* fDisplayFrame = new TGTab(fV2, GetWidth(), GetHeight());
+ fMasterTab = new TGTab(fV2, GetWidth(), GetHeight());
// browser tab
- TGCompositeFrame* tFrame1 = fDisplayFrame->AddTab("Object Browser");
- fBrowser = new RGBrowser(tFrame1, w, h);
- tFrame1->AddFrame(fBrowser, fL2);
+ TGCompositeFrame* tframe1 = fMasterTab->AddTab("Object Browser");
+ fBrowser = new RGBrowser(tframe1, w, h);
+ tframe1->AddFrame(fBrowser, lay2);
// tree selection tab
- TGCompositeFrame* tFrame2 = fDisplayFrame->AddTab("Tree Selections");
- fSelector = new VSDSelector(fBrowser->GetListTree(), tFrame2);
+ TGCompositeFrame* tframe2 = fMasterTab->AddTab("Tree Selections");
+ fSelector = new VSDSelector(tframe2);
- // canvas
+ // gl-canvas
Reve::PushPad();
- TGCompositeFrame* tFrame3 = fDisplayFrame->AddTab("Canvas");
- TRootEmbeddedCanvas* fEmbeddedCanvas3 = new TRootEmbeddedCanvas("fEmbeddedCanvas3", tFrame3, 580, 360);
- tFrame3->AddFrame(fEmbeddedCanvas3, fL2);
- fEmbeddedCanvas3->GetCanvas()->SetBorderMode(0);
- fCC = fEmbeddedCanvas3->GetCanvas();
- // fCC->SetFillColor(1);
+ TGCompositeFrame* tframe3 = fMasterTab->AddTab("GLCanvas");
+ TRootEmbeddedCanvas* ecanvas3 = new TRootEmbeddedCanvas("GLCanvas", tframe3, 580, 360);
+ tframe3->AddFrame(ecanvas3, lay2);
+ fGLCanvas = ecanvas3->GetCanvas();
+ fGLCanvas->SetEditable(kFALSE);
Reve::PopPad();
- // histo canvas
- TGCompositeFrame* frame4 = fDisplayFrame->AddTab("HistoCanvas");
- TRootEmbeddedCanvas* ecanvas4 = new TRootEmbeddedCanvas("HistoCanvas", frame4, 580, 360);
- frame4->AddFrame(ecanvas4, fL2);
- fHistoCanvas = ecanvas4->GetCanvas();
- fHistoCanvas->SetBorderMode(0);
-
- fV2->AddFrame(fDisplayFrame, fL0);
- AddFrame(fMainFrame, fL0);
+ fV2->AddFrame(fMasterTab, lay0);
+ AddFrame(fMasterFrame, lay0);
// Create status bar
Int_t parts[] = {45, 45, 10};
fStatusBar = new TGStatusBar(this, 50, 10, kHorizontalFrame);
fStatusBar->SetParts(parts, 3);
- TGLayoutHints* fL6 = new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0);
- AddFrame(fStatusBar, fL6);
+ TGLayoutHints* lay6 = new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0);
+ AddFrame(fStatusBar, lay6);
fStatusBar->SetText("GUI created", 0);
MapSubwindows();
/**************************************************************************/
/**************************************************************************/
-
switch(look) {
case LT_Classic: {
- fBrowser->SetupClassicLook(fEditor, fCC);
- fCC->GetViewer3D("ogl");
+ fBrowser->SetupClassicLook(fEditor, fGLCanvas);
+ fGLCanvas->GetViewer3D("ogl");
break;
}
case LT_Editor: {
- fBrowser->SetupEditorLook(fEditor, fCC);
- fCC->GetViewer3D("ogl");
+ fBrowser->SetupEditorLook(fEditor, fGLCanvas);
+ fGLCanvas->GetViewer3D("ogl");
break;
}
case LT_GLViewer: {
- fBrowser->SetupGLViewerLook(fEditor, fCC);
+ fBrowser->SetupGLViewerLook(fEditor, fGLCanvas);
break;
}
}
}
- TGLViewer* glv = dynamic_cast<TGLViewer*>(fCC->GetViewer3D());
+ TGLViewer* glv = dynamic_cast<TGLViewer*>(fGLCanvas->GetViewer3D());
if(glv) {
glv->SetSmartRefresh(kTRUE);
glv->SetResetCamerasOnUpdate(kFALSE);
glv->SetResetCameraOnDoubleClick(kFALSE);
+ TGLSAViewer* glsav = dynamic_cast<TGLSAViewer*>(glv);
+ if(glsav) {
+ TGedEditor* e = glsav->GetGedEditor();
+ e->SetModel(e->GetPad(), glsav, kButton1Down);
+ }
}
/**************************************************************************/
/**************************************************************************/
+TCanvas* RGTopFrame::AddCanvasTab(const char* name)
+{
+ TGCompositeFrame *f = fMasterTab->AddTab(name);
+ TRootEmbeddedCanvas *ec = new TRootEmbeddedCanvas(name, f, 580, 360);
+ f->AddFrame(ec, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY,
+ 2, 2, 2, 2));
+
+ f->MapSubwindows();
+ f->MapWindow();
+ fMasterTab->GetTabTab(name)->MapWindow();
+ fMasterTab->Layout();
+
+ return ec->GetCanvas();
+}
+
+/**************************************************************************/
+
TGListTree* RGTopFrame::GetListTree() const
{
return fBrowser->GetListTree();
{
static const Exc_t eH("RGTopFrame::EditRenderElement ");
- TObject* tobj = 0;
- if(rnr_element) tobj = rnr_element->GetObject();
- fEditor->DisplayObject(tobj);
+ fEditor->DisplayRenderElement(rnr_element);
}
/**************************************************************************/
{
// printf("RGTopFrame::DoRedraw3D redraw triggered\n");
if (fResetCameras) {
- fCC->GetViewer3D()->ResetCamerasAfterNextUpdate();
+ fGLCanvas->GetViewer3D()->ResetCamerasAfterNextUpdate();
fResetCameras = kFALSE;
}
- fCC->Modified();
- fCC->Update();
+
+ fGLCanvas->Modified();
+ fGLCanvas->Update();
fTimerActive = kFALSE;
}
TRint theApp("App", &argc, argv);
- /* gReve = */ new RGTopFrame(gClient->GetRoot(), w, h, revemode);
+ /* gReve = */ new RGTopFrame(gClient ? gClient->GetRoot() : 0, w, h, revemode);
+
run_loop:
try {
theApp.Run();
}
- catch(std::string exc) {
- gReve->GetStatusBar()->SetText(exc.c_str());
- fprintf(stderr, "Exception: %s\n", exc.c_str());
+ catch(Exc_t& exc) {
+ gReve->GetStatusBar()->SetText(exc.Data());
+ fprintf(stderr, "Exception: %s\n", exc.Data());
goto run_loop;
}
return 0;
}
+void RGTopFrame::SpawnGui(LookType_e revemode)
+{
+ Int_t w = 540;
+ Int_t h = 500;
+ if(revemode == LT_GLViewer) {
+ w = 1024; h = 768;
+ }
+
+ /* gReve = */ new RGTopFrame(gClient->GetRoot(), w, h, revemode);
+}
+
/**************************************************************************/
/**************************************************************************/
rel->RemoveElement(rnr_element);
}
+void RGTopFrame::PreDeleteRenderElement(RenderElement* rnr_element)
+{
+ if (fEditor->GetRnrElement() == rnr_element)
+ fEditor->DisplayObject(0);
+}
+
/**************************************************************************/
void RGTopFrame::DrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
- if(pad == 0) pad = GetCC();
+ if(pad == 0) pad = fGLCanvas;
+
{ Reve::PadHolder pHolder(false, pad);
+ if (pad == fGLCanvas) fGLCanvas->SetEditable(kTRUE);
rnr_element->GetObject()->Draw();
+ if (pad == fGLCanvas) fGLCanvas->SetEditable(kFALSE);
}
Redraw3D();
}
void RGTopFrame::UndrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
- if(pad == 0) pad = GetCC();
+ if(pad == 0) pad = fGLCanvas;
{ Reve::PadHolder pHolder(false, pad);
pad->GetListOfPrimitives()->Remove(rnr_element->GetObject());
}
RenderElement* rnrEl = (RenderElement*) obj;
rnrEl->SetRnrElement(state);
+ Redraw3D();
}
/**************************************************************************/
return gGeoManager;
}
}
+
+/**************************************************************************/
+// Testing exceptions
+/**************************************************************************/
+
+void RGTopFrame::ThrowException(const char* text)
+{
+ static const Exc_t eH("RGTopFrame::ThrowException ");
+
+ throw(eH + text);
+}
class TMacro;
class TFolder;
class TCanvas;
+class TGTab;
class TGStatusBar;
class TGListTree;
class TGListTreeItem;
enum LookType_e { LT_Classic, LT_Editor, LT_GLViewer };
private:
- TCanvas *fCC;
- TCanvas *fHistoCanvas;
+ TGCompositeFrame *fMasterFrame;
+ TGTab *fMasterTab;
+
+ TCanvas *fGLCanvas;
VSDSelector *fSelector;
RGBrowser *fBrowser;
TGStatusBar *fStatusBar;
public:
RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look=LT_Classic);
- TCanvas* GetCC() { return fCC; }
+ TGCompositeFrame* GetMasterFrame() { return fMasterFrame; }
+ TGTab* GetMasterTab() { return fMasterTab; }
+
+ TCanvas* GetGLCanvas() { return fGLCanvas; }
VSDSelector* GetSelector() { return fSelector; }
RGBrowser* GetBrowser() { return fBrowser; }
TGStatusBar* GetStatusBar() { return fStatusBar; }
+ TCanvas* AddCanvasTab(const char* name);
+
TGListTree* GetListTree() const;
EventBase* GetCurrentEvent() const { return fCurrentEvent; }
RenderElementList* GetGlobalStore() const { return fGlobalStore; }
void RegisterRedraw3D();
void DoRedraw3D();
- static int SpawnGuiAndRun(int argc, char **argv);
+ static int SpawnGuiAndRun(int argc, char **argv);
+ static void SpawnGui(LookType_e revemode = LT_Editor);
// These are more like ReveManager stuff.
TGListTreeItem* AddEvent(EventBase* event); // Could have Reve::Event ...
TGListTreeItem* AddGlobalRenderElement(RenderElement* parent, RenderElement* rnr_element);
void RemoveRenderElement(RenderElement* parent, RenderElement* rnr_element);
+ void PreDeleteRenderElement(RenderElement* rnr_element);
void DrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad=0);
void UndrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad=0);
// Hmmph ... geometry management?
TGeoManager* GetGeometry(const TString& filename);
+ void ThrowException(const char* text="foo");
+
ClassDef(RGTopFrame, 0);
};
ClassImp(GeoNodeRnrElEditor)
-GeoNodeRnrElEditor::GeoNodeRnrElEditor(const TGWindow *p, Int_t id,
+GeoNodeRnrElEditor::GeoNodeRnrElEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p,width, height, options | kVerticalFrame, back),
fNodeRE (0),
"Reve::GeoNodeRnrElEditor", this, "DoTransparency()");
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
-
-
- // What is this crap?
- TClass *cl = GeoNodeRnrEl::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
/**************************************************************************/
-void GeoNodeRnrElEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void GeoNodeRnrElEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(GeoNodeRnrEl::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fNodeRE = dynamic_cast<GeoNodeRnrEl*>(fModel);
+ fNodeRE = dynamic_cast<GeoNodeRnrEl*>(obj);
TGeoNode* node = fNodeRE->fNode;
TGeoVolume* vol = node->GetVolume();
fVizVolumeDaughters->SetState(vol->IsVisDaughters() ? kButtonDown : kButtonUp);
fTransparency->SetNumber(vol->GetTransparency());
-
- SetActive();
}
/**************************************************************************/
ClassImp(GeoTopNodeRnrElEditor)
-GeoTopNodeRnrElEditor::GeoTopNodeRnrElEditor(const TGWindow *p, Int_t id,
+GeoTopNodeRnrElEditor::GeoTopNodeRnrElEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fTopNodeRE (0),
fVisOption (0),
"Reve::GeoTopNodeRnrElEditor", this, "DoVisLevel()");
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
-
-
- // What is this crap?
- TClass *cl = GeoNodeRnrEl::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
/**************************************************************************/
-void GeoTopNodeRnrElEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void GeoTopNodeRnrElEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(GeoTopNodeRnrEl::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fTopNodeRE = dynamic_cast<GeoTopNodeRnrEl*>(fModel);
+ fTopNodeRE = dynamic_cast<GeoTopNodeRnrEl*>(obj);
fVisOption->SetNumber(fTopNodeRE->GetVisOption());
fVisLevel->SetNumber(fTopNodeRE->GetVisLevel());
-
- SetActive();
}
/**************************************************************************/
TGNumberEntry* fTransparency;
public:
- GeoNodeRnrElEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ GeoNodeRnrElEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
virtual ~GeoNodeRnrElEditor() {}
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoVizNode();
void DoVizNodeDaughters();
TGNumberEntry* fVisLevel;
public:
- GeoTopNodeRnrElEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ GeoTopNodeRnrElEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
virtual ~GeoTopNodeRnrElEditor() {}
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoVisOption();
void DoVisLevel();
if(fDenyDestroy)
throw(eH + "this object is protected against destruction.");
+ gReve->PreDeleteRenderElement(this);
delete this;
gReve->Redraw3D();
}
if(fParents.empty() && fDestroyOnZeroRefCnt) {
// TObject* tobj = GetObject(eH);
// Warning(eH.Data(), Form("auto-destructing '%s' on zero reference count.", tobj->GetName()));
+ gReve->PreDeleteRenderElement(this);
delete this;
}
}
if(fMainColorPtr != 0) i->fItem->SetColor(GetMainColor());
gClient->NeedRedraw(i->fTree);
}
- gReve->Redraw3D(); // This will go away once editor can notify ALL changes.
}
/**************************************************************************/
{
static const Exc_t eH("RenderElement::ExportToCINT ");
- TObject* obj = GetObject(eH);
- const char* cname = obj->IsA()->GetName();
- gROOT->ProcessLine(Form("%s* %s = (%s*) %p;", cname, var_name, cname, obj));
+ const char* cname = IsA()->GetName();
+ gROOT->ProcessLine(Form("%s* %s = (%s*)0x%lx;", cname, var_name, cname, this));
}
/**************************************************************************/
{
if(rnr != fRnrElement) {
fRnrElement = rnr;
- UpdateItems();
+ for(sLTI_i i=fItems.begin(); i!=fItems.end(); ++i) {
+ if (i->fItem->IsChecked() != rnr) {
+ i->fItem->CheckItem(fRnrElement);
+ gClient->NeedRedraw(i->fTree);
+ }
+ }
}
}
{
if (fMainColorPtr) {
*fMainColorPtr = color;
- UpdateItems();
+ for(sLTI_i i=fItems.begin(); i!=fItems.end(); ++i) {
+ if(i->fItem->GetColor() != color) {
+ i->fItem->SetColor(GetMainColor());
+ gClient->NeedRedraw(i->fTree);
+ }
+ }
}
}
return fObject;
}
+void RenderElementObjPtr::ExportToCINT(Text_t* var_name)
+{
+ static const Exc_t eH("RenderElementObjPtr::ExportToCINT ");
+
+ TObject* obj = GetObject(eH);
+ const char* cname = obj->IsA()->GetName();
+ gROOT->ProcessLine(Form("%s* %s = (%s*)0x%lx;", cname, var_name, cname, obj));
+}
+
/**************************************************************************/
/**************************************************************************/
virtual void UpdateItems();
- void SpawnEditor(); // *MENU*
- void ExportToCINT(Text_t* var_name); // *MENU*
+ void SpawnEditor(); // *MENU*
+ virtual void ExportToCINT(Text_t* var_name); // *MENU*
- virtual void Destroy(); // *MENU*
+ virtual void Destroy(); // *MENU*
virtual Bool_t CanEditRnrElement() { return kTRUE; }
virtual Bool_t GetRnrElement() const { return fRnrElement; }
virtual ~RenderElementObjPtr();
virtual TObject* GetObject(Exc_t eh="RenderElementObjPtr::GetObject ");
+ virtual void ExportToCINT(Text_t* var_name);
Bool_t GetOwnObject() const { return fOwnObject; }
void SetOwnObject(Bool_t o) { fOwnObject = o; }
ClassImp(RenderElementEditor)
-RenderElementEditor::RenderElementEditor(const TGWindow *p, Int_t id,
+RenderElementEditor::RenderElementEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fRE (0),
fHFrame (0),
fMainColor (0)
{
MakeTitle("RenderElement");
+ fPriority = 0;
fHFrame = new TGHorizontalFrame(this);
"Reve::RenderElementEditor", this, "DoRnrElement()");
AddFrame(fHFrame, new TGLayoutHints(kLHintsTop, 0, 0, 1, 1));
-
- // Register the editor.
- TClass *cl = RenderElement::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
RenderElementEditor::~RenderElementEditor()
/**************************************************************************/
-void RenderElementEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void RenderElementEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(RenderElement::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fRE = dynamic_cast<RenderElement*>(fModel);
+ fRE = dynamic_cast<RenderElement*>(obj);
if (fRE->CanEditRnrElement()) {
fRnrElement->SetState(fRE->GetRnrElement() ? kButtonDown : kButtonUp);
}
fHFrame->Layout();
-
- SetActive();
}
/**************************************************************************/
TGColorSelect* fMainColor;
public:
- RenderElementEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ RenderElementEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~RenderElementEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoRnrElement();
void DoMainColor(Pixel_t color);
#include <TInterpreter.h>
#include <list>
-
+#include <string>
#include <iostream>
//______________________________________________________________________
namespace Reve {
+// TString .vs. string
+
+bool operator==(const TString& t, const std::string& s)
+{ return (s == t.Data()); }
+
+bool operator==(const std::string& s, const TString& t)
+{ return (s == t.Data()); }
+
+// Exc
+
+Exc_t::Exc_t(const std::string& s) : TString(s.c_str()) {}
+
+// Exc + ops
+
Exc_t operator+(const Exc_t &s1, const std::string &s2)
{ return Exc_t((std::string&)s1 + s2); }
Exc_t operator+(const Exc_t &s1, const char *s2)
{ return Exc_t((std::string&)s1 + s2); }
+// ----------------------------------------------------------------
void WarnCaller(const TString& warning)
{
// Setup Include and Macro paths.
static const Exc_t eH("Reve::SetupEnvironment");
+ static Bool_t setupDone = kFALSE;
+
+ if (setupDone) {
+ Info(eH.Data(), "has already been run.");
+ return;
+ }
if(gSystem->Getenv("REVESYS") == 0) {
if(gSystem->Getenv("ALICE_ROOT") != 0) {
gInterpreter->AddIncludePath(gSystem->Getenv("ALICE_ROOT"));
}
gROOT->SetMacroPath(macPath);
+
+ setupDone = kTRUE;
}
/**************************************************************************/
#ifndef REVE_Reve_H
#define REVE_Reve_H
-#include <string>
+// #include <string>
+#include <exception>
#include <TString.h>
#include <TError.h>
#include <Gtypes.h>
-inline bool operator==(const TString& t, const std::string& s)
-{ return (s == t.Data()); }
-
-inline bool operator==(const std::string& s, const TString& t)
-{ return (s == t.Data()); }
-
class TVirtualPad;
class TGeoManager;
namespace Reve {
-class Exc_t : public std::string
+bool operator==(const TString& t, const std::string& s);
+bool operator==(const std::string& s, const TString& t);
+
+class Exc_t : public std::exception, public TString
{
public:
Exc_t() {}
- Exc_t(const std::string& s) : std::string(s) {}
- Exc_t(const char* s) : std::string(s) {}
+ Exc_t(const TString& s) : TString(s) {}
+ Exc_t(const char* s) : TString(s) {}
+ Exc_t(const std::string& s);
- virtual ~Exc_t() {}
+ virtual ~Exc_t() throw () {}
- const char* Data() const { return c_str(); }
+ virtual const char* what() const throw () { return Data(); }
- ClassDef(Reve::Exc_t, 1);
+ ClassDef(Exc_t, 1);
};
Exc_t operator+(const Exc_t &s1, const std::string &s2);
fMarkerColor = 5;
// fMarker->SetMarkerSize(0.05);
- mRnrStyle = new TrackRnrStyle;
- SetMainColorPtr(&mRnrStyle->fColor);
+ if (fRnrStyle== 0) fRnrStyle = new TrackRnrStyle;
+ SetMainColorPtr(&fRnrStyle->fColor);
}
-TrackList::TrackList(Int_t n_tracks) :
+TrackList::TrackList(Int_t n_tracks, TrackRnrStyle* rs) :
RenderElementListBase(),
TPolyMarker3D(n_tracks),
fTitle(),
- mRnrStyle (0),
+ fRnrStyle (rs),
fRnrMarkers (kTRUE),
fRnrTracks (kTRUE)
{
Init();
}
-TrackList::TrackList(const Text_t* name, Int_t n_tracks) :
+TrackList::TrackList(const Text_t* name, Int_t n_tracks, TrackRnrStyle* rs) :
RenderElementListBase(),
TPolyMarker3D(n_tracks),
-
+
fTitle(),
- mRnrStyle (0),
+ fRnrStyle (rs),
fRnrMarkers (kTRUE),
fRnrTracks (kTRUE)
{
void TrackList::SetMaxR(Float_t x)
{
- mRnrStyle->fMaxR = x;
+ fRnrStyle->fMaxR = x;
MakeTracks();
MakeMarkers();
}
void TrackList::SetMaxZ(Float_t x)
{
- mRnrStyle->fMaxZ = x;
+ fRnrStyle->fMaxZ = x;
MakeTracks();
MakeMarkers();
}
void TrackList::SetMaxOrbs(Float_t x)
{
- mRnrStyle->fMaxOrbs = x;
+ fRnrStyle->fMaxOrbs = x;
MakeTracks();
}
void TrackList::SetMinAng(Float_t x)
{
- mRnrStyle->fMinAng = x;
+ fRnrStyle->fMinAng = x;
MakeTracks();
}
void TrackList::SetDelta(Float_t x)
{
- mRnrStyle->fDelta = x;
+ fRnrStyle->fDelta = x;
MakeTracks();
}
void TrackList::SetFitDaughters(Bool_t x)
{
- mRnrStyle->fFitDaughters = x;
+ fRnrStyle->fFitDaughters = x;
MakeTracks();
}
void TrackList::SetFitDecay(Bool_t x)
{
- mRnrStyle->fFitDecay = x;
+ fRnrStyle->fFitDecay = x;
MakeTracks();
}
protected:
TString fTitle;
- TrackRnrStyle* mRnrStyle;
+ TrackRnrStyle* fRnrStyle;
Bool_t fRnrMarkers;
Bool_t fRnrTracks;
public:
- TrackList(Int_t n_tracks=0);
- TrackList(const Text_t* name, Int_t n_tracks=0);
+ TrackList(Int_t n_tracks=0, TrackRnrStyle* rs=0);
+ TrackList(const Text_t* name, Int_t n_tracks=0, TrackRnrStyle* rs=0);
void Reset(Int_t n_tracks=0);
- virtual const Text_t* GetTile() const { return fTitle; }
+ virtual const Text_t* GetTitle() const { return fTitle; }
virtual void SetTitle(const Text_t* t) { fTitle = t; }
virtual Bool_t CanEditMainColor() { return kTRUE; }
virtual void AddElement(RenderElement* el);
- void SetRnrStyle(TrackRnrStyle* rst) { mRnrStyle= rst; }
- TrackRnrStyle* GetRnrStyle() { return mRnrStyle; }
+ void SetRnrStyle(TrackRnrStyle* rst) { fRnrStyle= rst; }
+ TrackRnrStyle* GetRnrStyle() { return fRnrStyle; }
Bool_t GetRnrTracks() const { return fRnrTracks; }
void SetRnrTracks(Bool_t);
void MakeTracks();
void MakeMarkers();
- Float_t GetMaxR() const { return mRnrStyle->fMaxZ; }
- Float_t GetMaxZ() const { return mRnrStyle->fMaxR; }
- Float_t GetMaxOrbs() const { return mRnrStyle->fMaxOrbs; }
- Float_t GetMinAng() const { return mRnrStyle->fMinAng; }
- Float_t GetDelta() const { return mRnrStyle->fDelta; }
- Bool_t GetFitDaughters() const { return mRnrStyle->fFitDaughters; }
- Bool_t GetFitDecay() const { return mRnrStyle->fFitDecay; }
+ Float_t GetMaxR() const { return fRnrStyle->fMaxZ; }
+ Float_t GetMaxZ() const { return fRnrStyle->fMaxR; }
+ Float_t GetMaxOrbs() const { return fRnrStyle->fMaxOrbs; }
+ Float_t GetMinAng() const { return fRnrStyle->fMinAng; }
+ Float_t GetDelta() const { return fRnrStyle->fDelta; }
+ Bool_t GetFitDaughters() const { return fRnrStyle->fFitDaughters; }
+ Bool_t GetFitDecay() const { return fRnrStyle->fFitDecay; }
void SetMaxR(Float_t x);
void SetMaxZ(Float_t x);
ClassImp(TrackListEditor)
-TrackListEditor::TrackListEditor(const TGWindow *p, Int_t id,
+TrackListEditor::TrackListEditor(const TGWindow *p,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, id, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, width, height, options | kVerticalFrame, back),
fTC (0),
fPtRange->Connect("ValueSet()",
"Reve::TrackListEditor", this, "DoPtRange()");
AddFrame(fPtRange, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
-
- // Register the editor.
- TClass *cl = TrackList::Class();
- TGedElement *ge = new TGedElement;
- ge->fGedFrame = this;
- ge->fCanvas = 0;
- cl->GetEditorList()->Add(ge);
}
TrackListEditor::~TrackListEditor()
/**************************************************************************/
-void TrackListEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
+void TrackListEditor::SetModel(TObject* obj)
{
- fModel = 0;
- fPad = 0;
-
- if (!obj || !obj->InheritsFrom(TrackList::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
- SetActive(kFALSE);
- return;
- }
-
- fModel = obj;
- fPad = pad;
-
- fTC = dynamic_cast<TrackList*>(fModel);
+ fTC = dynamic_cast<TrackList*>(obj);
fMaxR->SetNumber(fTC->GetMaxR());
fMaxZ->SetNumber(fTC->GetMaxZ());
fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);
fPtRange->SetValues(0.1, 10);
-
- SetActive();
}
/**************************************************************************/
void TrackListEditor::DoPtRange()
{
fTC->SelectByPt(fPtRange->GetMin(), fPtRange->GetMax());
+ Update();
}
RGDoubleValuator* fPtRange;
public:
- TrackListEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
+ TrackListEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
~TrackListEditor();
- virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
+ virtual void SetModel(TObject* obj);
void DoMaxR();
void DoMaxZ();
#include "VSDSelector.h"
+#include "VSDEvent.h"
#include "RGTopFrame.h"
#include <Reve/Track.h>
using Reve::Exc_t;
-VSDSelector::VSDSelector(TGListTree* lt, TGCompositeFrame *tFrame) :
+VSDSelector::VSDSelector(TGCompositeFrame *tFrame) :
VSD(),
- fListTree (lt),
-
mParticleSelection(0),
+ fRecursiveSelect(0),
+
mHitSelection(0),
mClusterSelection(0),
- mRecSelection(0),
-
- fRecursiveSelect(0)
+ mRecSelection(0)
{
//create gui
TGGroupFrame *gframe = new TGGroupFrame(tFrame, "Options", kVerticalFrame);
TGLayoutHints* lh0 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY , 5, 5, 5, 5);
gframe->SetTitlePos(TGGroupFrame::kRight); // right aligned
tFrame->AddFrame(gframe, lh0);
-
TGXYLayout* xyl = new TGXYLayout(gframe);
gframe->SetLayoutManager(xyl);
xyl->Layout();
TGXYLayoutHints* lh;
- Float_t x,y;
- y = 0.;
- UInt_t wH = 2;
+ UInt_t wH = 2;
UInt_t labelw = 15;
UInt_t entryw = 39;
- UInt_t butw = 10;
-
- x = 2.;
- y = 2.;
+ UInt_t butw = 10;
+
+ Float_t x = 2, y = 2;
+
{
// particles
TGLabel* label = new TGLabel(gframe, "ParticleSelection");
lh = new TGXYLayoutHints(x, y, butw, wH,0); lh->SetPadLeft(4); lh->SetPadRight(2);
gframe->AddFrame(but,lh);
but->Connect("Pressed()", "Reve::VSDSelector", this, "SelectClusters()");
- } x = 2.;
+ }
+
+ x = 2.;
y+= wH; y+= 1.;
{ // reconstructed tracks selection
const Text_t* dir_name)
{
VSD::LoadVSD(vsd_file_name, dir_name);
- fListTree->AddItem(0, dir_name);
+ // !!!! Should create VSDEvent ... but it is not done yet.
+ EventBase* ev = new EventBase(vsd_file_name, dir_name);
+ gReve->AddEvent(ev);
}
/**************************************************************************/
if(selection == 0)
selection = mParticleSelection->GetText();
-
- TGListTreeItem* parent = fListTree->FindItemByPathname("Event0");
- if(parent == 0) return;
-
-
TTreeQuery evl;
Int_t n = evl.Select(mTreeK, selection);
// printf("%d entries in selection '%s'.\n", n, selection);
if(n == 0)
throw (eH + "no entries found for selection in kinematics.");
-
- TrackList* cont = new TrackList();
- TrackRnrStyle* rs = new TrackRnrStyle();
- cont->SetRnrStyle(rs);
- rs->SetColor(4);
- TGListTreeItem *holder = fListTree->AddItem(parent, Form("MCTracks %s [%d]",selection,n));
- holder->SetUserData(cont);
- // printf("%d entries in selection '%s'.\n", n, selection);
+ TrackList* cont = new TrackList();
+ cont->GetRnrStyle()->SetColor(4);
+
+ gReve->AddRenderElement(cont);
if(n > 0) {
- Reve::PadHolder pHolder(true, gReve->GetCC());
+ Reve::PadHolder pHolder(true, gReve->GetGLCanvas());
for(Int_t i=0; i<n; i++) {
Int_t label = evl.GetEntry(i);
mTreeK->GetEntry(label);
Track* track = new Track(mpK, cont->GetRnrStyle());
+ track->SetName(Form("%s daughters:%d", mK.GetName(), mK.GetNDaughters()));
+ gReve->AddRenderElement(cont, track);
- TGListTreeItem* di = fListTree->AddItem
- (holder, Form("%s daughters:%d", mK.GetName(), mK.GetNDaughters()), track);
- di->SetUserData(track);
- cont->AddElement(track);
// printf("select daugters %s selection %s\n",mpK->GetName(),Form("fMother[0] == %d", track->GetLabel()));
if(fRecursiveSelect->IsOn()) {
if(mK.GetNDaughters())
- ImportDaughtersRec(di, cont, mK.GetFirstDaughter(), mK.GetLastDaughter());
+ ImportDaughtersRec(track, cont, mK.GetFirstDaughter(), mK.GetLastDaughter());
// add decay point to path marks
if(mK.decayed) {
Reve::PathMark* pm = new Reve::PathMark(Reve::PathMark::Decay);
track->MakeTrack();
}
cont->MakeMarkers();
- NotifyBrowser(parent);
}
}
-/**************************************************************************/
-
-void VSDSelector::ImportDaughtersRec(TGListTreeItem* parent, TrackList* cont,
+void VSDSelector::ImportDaughtersRec(RenderElement* parent, TrackList* cont,
Int_t first, Int_t last)
{
- Track* mother = (Track*)parent->GetUserData();
+ Track* mother = dynamic_cast<Track*>(parent);
for(Int_t i=first; i<=last; i++) {
mTreeK->GetEntry(i);
Track* track = new Track(mpK, cont->GetRnrStyle());
-
- TGListTreeItem* di = fListTree->AddItem
- (parent, Form("%s daughters:%d", mK.GetName(), mK.GetNDaughters()), track);
- di->SetUserData(track);
- cont->AddElement(track);
+ track->SetName(Form("%s daughters:%d", mK.GetName(), mK.GetNDaughters()));
+ gReve->AddRenderElement(parent, track);
+ cont->AddElement(track); // ?? is this ok ??
if(mK.GetNDaughters())
- ImportDaughtersRec(di, cont, mK.GetFirstDaughter(), mK.GetLastDaughter());
+ ImportDaughtersRec(track, cont, mK.GetFirstDaughter(), mK.GetLastDaughter());
// add daughter mark to mother
Reve::PathMark* dam = new Reve::PathMark(Reve::PathMark::Daughter);
track->MakeTrack();
}
}
+
+/**************************************************************************/
/**************************************************************************/
void VSDSelector::SelectHits()
container->SetTitle(Form("N=%d", container->GetN()));
container->SetMarkerColor(2);
container->SetMarkerStyle(20);
- container->SetMarkerSize(2);
+ container->SetMarkerSize(0.5);
gReve->AddRenderElement(container);
- gReve->DrawRenderElement(container);
+ gReve->Redraw3D();
}
/**************************************************************************/
container->SetTitle(Form("N=%d", container->GetN()));
container->SetMarkerColor(9);
container->SetMarkerStyle(20);
- container->SetMarkerSize(2);
+ container->SetMarkerSize(0.5);
gReve->AddRenderElement(container);
- gReve->DrawRenderElement(container);
+ gReve->Redraw3D();
}
/**************************************************************************/
throw (eH + "No entries found in ESD data.");
if(n > 0) {
- Reve::PadHolder pHolder(true, gReve->GetCC());
-
- TGListTreeItem* parent = fListTree->FindItemByPathname("Event0");
- TrackList* cont = new TrackList();
- TrackRnrStyle* rs = new TrackRnrStyle();
- cont->SetRnrStyle(rs);
- rs->SetColor(6);
- TGListTreeItem *holder = fListTree->AddItem(parent, Form("RecTracks %s [%d]",selection, n));
- holder->SetUserData(cont);
+ TrackList* cont = new TrackList(Form("RecTracks %s [%d]",selection, n), n);
+ cont->GetRnrStyle()->SetColor(6);
+
+ gReve->AddRenderElement(cont);
+
for (Int_t i=0; i<n; i++) {
Int_t label = evl.GetEntry(i);
mTreeR->GetEntry(label);
Track* track = new Track(mpR, cont->GetRnrStyle());
track->MakeTrack();
- track->Draw();
- TGListTreeItem* di =
- fListTree->AddItem(holder, "RecTrack", track);
- di->SetUserData(track);
- cont->AddElement(track);
+ gReve->AddRenderElement(cont, track);
}
-
cont->MakeMarkers();
- NotifyBrowser(parent);
+ gReve->Redraw3D();
}
}
-
-/**************************************************************************/
-
-void VSDSelector::NotifyBrowser(TGListTreeItem* parent)
-{
- Long_t args[2];
- args[0] = (Long_t)parent;
- args[1] = 0;
-
- fListTree->Emit("Clicked(TGListTreeItem*, Int_t)", args);
- fListTree->OpenItem(parent);
-}
namespace Reve {
+class RenderElement;
class TrackRnrStyle;
class TrackList;
-class VSDSelector : public ::Reve::VSD
+class VSDSelector : public VSD
{
VSDSelector(const VSDSelector&); // Not implemented
VSDSelector& operator=(const VSDSelector&); // Not implemented
-private:
- void NotifyBrowser(TGListTreeItem* parent);
- TGListTree* fListTree;
-
protected:
TGTextEntry* mParticleSelection;
+ TGCheckButton* fRecursiveSelect;
+
TGTextEntry* mHitSelection;
TGTextEntry* mClusterSelection;
TGTextEntry* mRecSelection;
public:
- TGCheckButton* fRecursiveSelect;
- VSDSelector(TGListTree* lt, TGCompositeFrame *tFrame);
+
+ VSDSelector(TGCompositeFrame *tFrame);
virtual void LoadVSD(const Text_t* vsd_file_name,
const Text_t* dir_name="Event0");
void SelectParticles (const Text_t* selection=0);
- void ImportDaughtersRec(TGListTreeItem* parent, TrackList* cont, Int_t first, Int_t last);
+ void ImportDaughtersRec(RenderElement* parent, TrackList* cont,
+ Int_t first, Int_t last);
+
void SelectHits();
void SelectClusters();
void SelectRecTracks();
}
}
clusters->SetMarkerStyle(2);
- clusters->SetMarkerSize(5);
+ clusters->SetMarkerSize(0.5);
clusters->SetMarkerColor(4);
clusters->SetName(Form("Clusters lab=%d", label));
using namespace Reve;
- Color_t* colp = FindColorVar(clusters, "fMarkerColor");
- RenderElementObjPtr* rnrEl = new RenderElementObjPtr(clusters, *colp);
- gReve->AddRenderElement(rnrEl);
+ gReve->AddRenderElement(clusters);
gReve->Redraw3D();
}
AliESDtrack* at,
AliExternalTrackParam* tp=0)
{
+ // Helper function
Double_t pbuf[3], vbuf[3];
Reve::RecTrack rt;
return track;
}
-Bool_t gkFixFailedITSExtr = kTRUE;
+Bool_t gkFixFailedITSExtr = kFALSE;
Reve::TrackList* esd_tracks(Double_t min_pt=0.1, Double_t max_pt=100)
{
AliESD* esd = Alieve::Event::AssertESD();
- AliPID pid;
Double_t minptsq = min_pt*min_pt;
Double_t maxptsq = max_pt*max_pt;
++count;
- // If ITS refit failed, take track parameters at inner TPC radius.
+ // If gkFixFailedITSExtr is TRUE (FALSE by default) and
+ // if ITS refit failed, take track parameters at inner TPC radius.
AliExternalTrackParam* tp = at;
if (gkFixFailedITSExtr && !at->IsOn(AliESDtrack::kITSrefit)) {
tp = at->GetInnerParam();
return cont;
}
+/**************************************************************************/
+// esd_tracks_from_array()
+/**************************************************************************/
+
Reve::TrackList* esd_tracks_from_array(TCollection* col, AliESD* esd=0)
{
// Retrieves AliESDTrack's from collection.
// See example usage with AliAnalysisTrackCuts in the next function.
if(esd == 0) esd = Alieve::Event::AssertESD();
- AliPID pid;
Reve::TrackList* cont = new Reve::TrackList("ESD Tracks");
cont->SetMainColor(Color_t(6));
esd_tracks_from_array(atc.GetAcceptedParticles(esd), esd);
}
+
+/**************************************************************************/
+// esd_tracks_vertex_cut
+/**************************************************************************/
+
+Float_t get_sigma_to_vertex(AliESDtrack* esdTrack)
+{
+ // Taken from: PWG0/esdTrackCuts/AliESDtrackCuts.cxx
+ // Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
+
+ Float_t b[2];
+ Float_t bRes[2];
+ Float_t bCov[3];
+ esdTrack->GetImpactParameters(b,bCov);
+ if (bCov[0]<=0 || bCov[2]<=0) {
+ AliDebug(1, "Estimated b resolution lower or equal zero!");
+ bCov[0]=0; bCov[2]=0;
+ }
+ bRes[0] = TMath::Sqrt(bCov[0]);
+ bRes[1] = TMath::Sqrt(bCov[2]);
+
+ // -----------------------------------
+ // How to get to a n-sigma cut?
+ //
+ // The accumulated statistics from 0 to d is
+ //
+ // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
+ // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
+ //
+ // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
+ // Can this be expressed in a different way?
+
+ if (bRes[0] == 0 || bRes[1] ==0)
+ return -1;
+
+ Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
+
+ // stupid rounding problem screws up everything:
+ // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
+ if (TMath::Exp(-d * d / 2) < 1e-10)
+ return 1000;
+
+ d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
+ return d;
+}
+
+Reve::RenderElementList* esd_tracks_vertex_cut()
+{
+ // Import ESD tracks, separate them into three containers according to
+ // primary-vertex cut.
+
+ AliESD* esd = Alieve::Event::AssertESD();
+
+ Reve::RenderElementList* cont = new Reve::RenderElementList("ESD Tracks", 0, kTRUE);
+ gReve->AddRenderElement(cont);
+ Reve::TrackList *tl[4];
+ Int_t tc[4];
+ Int_t count = 0;
+
+ tl[0] = new Reve::TrackList("Sigma < 3");
+ printf("%p %s\n", tl[0], tl[0]->IsA()->GetName());
+ tc[0] = 0;
+ tl[0]->GetRnrStyle()->SetMagField( esd->GetMagneticField() );
+ tl[0]->SetMainColor(Color_t(3));
+ gReve->AddRenderElement(cont, tl[0]);
+
+ tl[1] = new Reve::TrackList("3 < Sigma < 5");
+ tc[1] = 0;
+ tl[1]->GetRnrStyle()->SetMagField( esd->GetMagneticField() );
+ tl[1]->SetMainColor(Color_t(7));
+ gReve->AddRenderElement(cont, tl[1]);
+
+ tl[2] = new Reve::TrackList("5 < Sigma");
+ tc[2] = 0;
+ tl[2]->GetRnrStyle()->SetMagField( esd->GetMagneticField() );
+ tl[2]->SetMainColor(Color_t(46));
+ gReve->AddRenderElement(cont, tl[2]);
+
+ tl[3] = new Reve::TrackList("ITS refit failed");
+ tc[3] = 0;
+ tl[3]->GetRnrStyle()->SetMagField( esd->GetMagneticField() );
+ tl[3]->SetMainColor(Color_t(41));
+ gReve->AddRenderElement(cont, tl[3]);
+
+ for (Int_t n=0; n<esd->GetNumberOfTracks(); n++) {
+ AliESDtrack* at = esd->GetTrack(n);
+
+ Float_t s = get_sigma_to_vertex(at);
+ Int_t ti;
+ if (s < 3) ti = 0;
+ else if (s <= 5) ti = 1;
+ else ti = 2;
+
+ AliExternalTrackParam* tp = at;
+ // If ITS refit failed, take track parameters at inner TPC radius and
+ // put track in a special container.
+ // This ignores state of gkFixFailedITSExtr (used in esd_tracks()).
+ // Use BOTH functions to compare results.
+ if (!at->IsOn(AliESDtrack::kITSrefit)) {
+ tp = at->GetInnerParam();
+ ti = 3;
+ }
+
+ Reve::TrackList* tlist = tl[ti];
+ ++tc[ti];
+ ++count;
+
+ Reve::Track* track = esd_make_track(tlist->GetRnrStyle(), at, tp);
+ track->SetName(Form("track %d, sigma=%5.3f", at->GetLabel(), s));
+ gReve->AddRenderElement(tlist, track);
+ }
+
+ for (Int_t ti=0; ti<4; ++ti) {
+ Reve::TrackList* tlist = tl[ti];
+ const Text_t* tooltip = Form("N tracks=%d", tc[ti]);
+ tlist->SetTitle(tooltip); // Not broadcasted automatically ...
+ tlist->UpdateItems();
+
+ tlist->MakeTracks();
+ tlist->MakeMarkers();
+ }
+ cont->SetTitle(Form("N all tracks = %d", count));
+ cont->UpdateItems();
+ gReve->Redraw3D();
+
+ return cont;
+}
--- /dev/null
+// $Id$
+
+void geom_all()
+{
+ using namespace std;
+
+ gGeoManager = gReve->GetGeometry("$REVESYS/alice-data/alice_fullgeo.root");
+
+ Reve::GeoTopNodeRnrEl* topn_re = new Reve::GeoTopNodeRnrEl
+ (gGeoManager, gGeoManager->GetTopNode());
+ gReve->AddGlobalRenderElement(topn_re);
+ gReve->Redraw3D();
+}
--- /dev/null
+// $Id$
+
+void geom_pmd()
+{
+ using namespace std;
+
+ gGeoManager = gReve->GetGeometry("$REVESYS/alice-data/alice_fullgeo.root");
+
+ for(Int_t i=1; i<=4; ++i) {
+ TGeoNode* node = gGeoManager->GetTopVolume()->FindNode(Form("EPM%d_1", i));
+
+ Reve::GeoTopNodeRnrEl* re = new Reve::GeoTopNodeRnrEl(gGeoManager, node);
+ re->SetUseNodeTrans(kTRUE);
+ gReve->AddGlobalRenderElement(re);
+ }
+
+ gReve->Redraw3D();
+}
--- /dev/null
+// $Id$
+
+void geom_trd_tof()
+{
+ using namespace std;
+
+ gGeoManager = gReve->GetGeometry("$REVESYS/alice-data/alice_fullgeo.root");
+ TGeoNode* node = gGeoManager->GetTopVolume()->FindNode("B077_1");
+
+ Reve::GeoTopNodeRnrEl* its_re =
+ new Reve::GeoTopNodeRnrEl(gGeoManager, node);
+ gReve->AddGlobalRenderElement(its_re);
+ gReve->Redraw3D();
+}
Reve::PointSet* h;
Reve::LoadMacro("its_hits.C");
h = its_hits("fX:fY:fZ", Form("ITS.fTrack==%d", label));
- h->SetMarkerSize(5);
+ h->SetMarkerSize(1);
Reve::LoadMacro("tpc_hits.C");
h = tpc_hits("TPC2.fArray.fR:TPC2.fArray.fFi:TPC2.fArray.fZ",
Form("TPC2.fArray.fTrackID==%d", label));
- h->SetMarkerSize(5);
+ h->SetMarkerSize(1);
gReve->Redraw3D();
}
TPolyMarker3D* m = new TPolyMarker3D(8);
m->SetName(name);
-
- // Problem with volume/length suppression of objects in TGLViewer
- /*
- m->SetPoint(0, x[0]+e[0], x[1]+e[1], x[2]+e[2]);
- m->SetPoint(1, x[0]+e[0], x[1]-e[1], x[2]+e[2]);
- m->SetPoint(2, x[0]-e[0], x[1]-e[1], x[2]+e[2]);
- m->SetPoint(3, x[0]-e[0], x[1]+e[1], x[2]+e[2]);
-
- m->SetPoint(4, x[0]+e[0], x[1]+e[1], x[2]-e[2]);
- m->SetPoint(5, x[0]+e[0], x[1]-e[1], x[2]-e[2]);
- m->SetPoint(6, x[0]-e[0], x[1]+e[1], x[2]-e[2]);
- m->SetPoint(7, x[0]-e[0], x[1]-e[1], x[2]-e[2]);
- */
m->SetPoint(0, x[0], x[1], x[2]);
return m;
gReve->AddRenderElement(s);
gReve->Redraw3D();
- TGLViewer* cam = dynamic_cast<TGLViewer*>(gReve->GetCC()->GetViewer3D());
+ TGLViewer* cam = dynamic_cast<TGLViewer*>(gReve->GetGLCanvas()->GetViewer3D());
//cam->SetCurrentCamera(TGLViewer::kCameraOrthoXOY) ;
//cam->SetOrthoCamera(TGLViewer::kCameraOrthoXOY, 2*left, 2*right, 2*top, bottom);
//printf("%f %f %f %f\n", left, right, top, bottom);
break;
}
+ case 3: { // Display all sectors in 3D
+ gReve->DisableRedraw();
+ {
+ Reve::RenderElementList* l = new Reve::RenderElementList("TPC plate 1");
+ l->SetTitle("TPC Plate");
+ l->SetMainColor(Color_t(col));
+ gReve->AddRenderElement(l);
+
+ for(Int_t i = 0; i<18; i++) {
+ Alieve::TPCSector3D* s = new Alieve::TPCSector3D();
+ s->SetSectorID(i);
+ s->SetDataSource(g_tpc_data);
+ s->SetFrameColor(col);
+ s->SetTrans(true);
+ gReve->AddRenderElement(l, s);
+ }
+ }
+ {
+ Reve::RenderElementList* l = new Reve::RenderElementList("TPC plate 2");
+ l->SetTitle("TPC Plate");
+ l->SetMainColor(Color_t(col));
+
+ gReve->AddRenderElement(l);
+ for(Int_t i = 18; i<36; i++) {
+ Alieve::TPCSector3D* s = new Alieve::TPCSector3D();
+ s->SetSectorID(i);
+ s->SetDataSource(g_tpc_data);
+ s->SetFrameColor(col);
+ s->SetTrans(true);
+ gReve->AddRenderElement(l, s);
+ }
+ }
+ gReve->EnableRedraw();
+
+ break;
+ }
+
} // switch
}
--- /dev/null
+// $Id$
+
+Reve::PointSet*
+trd_hits(const char *varexp = "fX:fY:fZ",
+ const char *selection = "")
+{
+ AliRunLoader* rl = Alieve::Event::AssertRunLoader();
+ rl->LoadHits("TRD");
+
+ TTree* ht = rl->GetTreeH("TRD", false);
+
+ Reve::PointSet* points = new Reve::PointSet(Form("TRD Hits '%s'", selection));
+
+ TPointSelector ps(ht, points, varexp, selection);
+ ps.Select();
+
+ points->SetTitle(Form("N=%d", points->Size()));
+ points->SetMarkerSize(.5);
+ points->SetMarkerColor((Color_t)7);
+
+ gReve->AddRenderElement(points);
+ gReve->Redraw3D();
+
+ return points;
+}
--- /dev/null
+// $Id$
+
+void trd_hits_z_split(const char *varexp = "fX:fY:fZ:fZ",
+ const char *selection = "")
+{
+ AliRunLoader* rl = Alieve::Event::AssertRunLoader();
+ rl->LoadHits("TRD");
+
+ TTree* ht = rl->GetTreeH("TRD", false);
+
+ Reve::PointSetArray* l = new Reve::PointSetArray("TRD hits - Z Slices", "");
+ l->SetMarkerColor((Color_t)7);
+ l->SetMarkerStyle(20); // full circle
+ l->SetMarkerSize(.5);
+
+ gReve->AddRenderElement(l);
+ l->InitBins("Z", 20, -360, 360);
+
+ TPointSelector ps(ht, l, varexp, selection);
+ ps.Select();
+
+ l->CloseBins();
+
+ gReve->Redraw3D();
+}
HDRS := $(SRCS:.cxx=.h)
DHDR := Reve/LinkDef.h
-all-EVE: all-Reve all-reve all-Alieve
+all-EVE: all-Reve all-reve all-Alieve all-alieve
{
// Invoke as: aliroot alieve_create_vsd.C
- gSystem->Load("libPhysics.so");
- gSystem->Load("libEG.so");
- gSystem->Load("libTreePlayer.so");
- gSystem->Load("libGed.so");
+ gSystem->Load("libPhysics");
+ gSystem->Load("libEG");
+ gSystem->Load("libTreePlayer");
+ gSystem->Load("libGed");
+ gSystem->Load("libRGL");
- gSystem->Load("libReve.so");
- gSystem->Load("libAlieve.so");
+ gSystem->Load("libReve");
+ gSystem->Load("libAlieve");
Reve::DisablePODTObjectStreamers();
// Waiting for a better solution
// gSystem->Load("libg2c_sh");
// And the following works for gcc-4.
- // gSystem->Load("/usr/lib/libg2c");
- gSystem->Load("/usr/lib/gcc/i386-redhat-linux/4.1.0/libgfortran");
+ gSystem->Load("/usr/lib/libg2c");
+ // gSystem->Load("/usr/lib/gcc/i386-redhat-linux/4.1.0/libgfortran");
gSystem->Load("libmicrocern");
gSystem->Load("libpdf");
gSystem->Load("libpythia6");
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff