// draw...
//
- if(fRnrElement == kFALSE)
+ if(fRnrSelf == kFALSE)
return;
TBuffer3D buffer(TBuffer3DTypes::kGeneric);
if(fSec3Ds[i] == el) fSec3Ds[i] = 0;
}
- RenderElementList::RemoveElementLocal(el);
+ RenderElement::RemoveElementLocal(el);
}
void TPCLoader::RemoveElements()
fSec3Ds[i] = 0;
}
- RenderElementList::RemoveElements();
+ RenderElement::RemoveElements();
}
/**************************************************************************/
void TPCSector2D::Paint(Option_t* )
{
- if(fRnrElement == kFALSE)
+ if(fRnrSelf == kFALSE)
return;
TBuffer3D buffer(TBuffer3DTypes::kGeneric);
void TPCSector3D::Paint(Option_t* /*option*/)
{
- if(fRnrElement == kFALSE)
+ if(fRnrSelf == kFALSE)
return;
TBuffer3D buffer(TBuffer3DTypes::kGeneric);
//________________________________________________________
-TRDLoader::TRDLoader(const Text_t* n, const Text_t* t) : Reve::RenderElementListBase(), TNamed(n,t), fSM(-1), fStack(-1), fLy(-1), fEvent(0)
+TRDLoader::TRDLoader(const Text_t* n, const Text_t* t) : Reve::RenderElement(), TNamed(n,t), fSM(-1), fStack(-1), fLy(-1), fEvent(0)
{
kLoadHits = kFALSE;
kLoadDigits = kFALSE;
List_i ichmb;
ichmb = fChildren.begin();
while(ichmb != fChildren.end()){
- (*ichmb)->SetRnrElement(kFALSE);
+ (*ichmb)->SetRnrSelf(kFALSE);
ichmb++;
}
ichmb = find_if(fChildren.begin(), fChildren.end(), ID<RenderElement*>(ism));
if(ichmb != fChildren.end()){
SM = (TRDNode*)(*ichmb);
- SM->SetRnrElement(kTRUE);
+ SM->SetRnrSelf(kTRUE);
}else{
gReve->AddRenderElement(this, SM = new TRDNode("SM", ism));
SM->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("Supermodule %2d", ism));
ichmb = find_if(SM->begin(), SM->end(), ID<RenderElement*>(istk));
if(ichmb != SM->end()){
STK = (TRDNode*)(*ichmb);
- STK->SetRnrElement(kTRUE);
+ STK->SetRnrSelf(kTRUE);
}else{
gReve->AddRenderElement(SM, STK = new TRDNode("Stack", istk));
STK->FindListTreeItem(gReve->GetListTree())->SetTipText(Form("SM %2d Stack %1d", ism, istk));
for(int ily=ily_start; ily<ily_stop; ily++){
det = fGeo->GetDetector(ily, istk, ism);
ichmb = find_if(STK->begin(), STK->end(), ID<RenderElement*>(det));
- if(ichmb != STK->end()) (*ichmb)->SetRnrElement(kTRUE);
+ if(ichmb != STK->end()) (*ichmb)->SetRnrSelf(kTRUE);
else{
gReve->AddRenderElement(STK, CHMB = new TRDChamber(det));
CHMB->SetGeometry(fGeo);
return kTRUE;
}
-//________________________________________________________
-void TRDLoader::Paint(Option_t *option)
-{
- List_i ichmb = fChildren.begin();
- while(ichmb != fChildren.end()){
- (dynamic_cast<TRDModule*>(*ichmb))->Paint(option);
- ichmb++;
- }
-}
-
//________________________________________________________
void TRDLoader::Unload()
{
kClusters = 2,
kESDs = 3
};
- class TRDLoader : public Reve::RenderElementListBase, public TNamed
+ class TRDLoader : public Reve::RenderElement, public TNamed
{
friend class TRDLoaderEditor;
public:
virtual Bool_t LoadHits(TTree *tH);
virtual Bool_t LoadTracklets(TTree *tT);
virtual Bool_t Open(const char *file, const char *dir = ".");
- virtual void Paint(Option_t *option="");
virtual void Unload();
protected:
//________________________________________________________
TRDNode::TRDNode(const char *typ, Int_t det) :
- Reve::RenderElementListBase(), TRDModule(typ, det)
+ Reve::RenderElement(), TRDModule(typ, det)
{
}
//________________________________________________________
void TRDNode::EnableListElements()
{
- SetRnrElement(kTRUE);
+ SetRnrSelf(kTRUE);
TRDNode *node = 0x0;
TRDChamber *chmb = 0x0;
List_i iter = fChildren.begin();
while(iter != fChildren.end()){
if((node = dynamic_cast<TRDNode*>(*iter))){
- node->SetRnrElement(kTRUE);
+ node->SetRnrSelf(kTRUE);
node->EnableListElements();
}
- if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrElement(kTRUE);
+ if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrSelf(kTRUE);
iter++;
}
gReve->Redraw3D();
//________________________________________________________
void TRDNode::DisableListElements()
{
- SetRnrElement(kFALSE);
+ SetRnrSelf(kFALSE);
TRDNode *node = 0x0;
TRDChamber *chmb = 0x0;
List_i iter = fChildren.begin();
while(iter != fChildren.end()){
if((node = dynamic_cast<TRDNode*>(*iter))){
- node->SetRnrElement(kFALSE);
+ node->SetRnrSelf(kFALSE);
node->DisableListElements();
}
- if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrElement(kFALSE);
+ if((chmb = dynamic_cast<TRDChamber*>(*iter))) chmb->SetRnrSelf(kFALSE);
iter++;
}
gReve->Redraw3D();
void TRDChamber::Paint(Option_t* option)
{
/* Info("Paint()", Form("%s", GetName()));*/
- if(!fRnrElement) return;
+ if(!fRnrSelf) return;
if(fDigits && fRnrDigits){
if(kDigitsNeedRecompute){
fDigits->ComputeRepresentation();
};
- class TRDNode : public Reve::RenderElementListBase, public TRDModule
+ class TRDNode : public Reve::RenderElement, public TRDModule
{
public:
TRDNode(const char *typ, Int_t det=0);
// $Id$
-Reve::PointSet* clusters_from_index(Int_t index=0)
+Reve::PointSet* clusters_from_index(Int_t index=0, RenderElement* cont=0)
{
AliESD* esd = Alieve::Event::AssertESD();
clusters->SetOwnIds(kTRUE);
AliESDtrack* at = esd->GetTrack(index);
- const AliTrackPointArray* pArr = at->GetTrackPointArray();
- if (pArr == 0) {
- Warning("clusters_from_index", "TrackPointArray not stored with ESD track.");
- continue;
- }
- Int_t np = pArr->GetNPoints();
- const Float_t* x = pArr->GetX();
- const Float_t* y = pArr->GetY();
- const Float_t* z = pArr->GetZ();
- for (Int_t i=0; i<np; ++i) {
- clusters->SetNextPoint(x[i], y[i], z[i]);
- AliTrackPoint *atp = new AliTrackPoint;
- pArr->GetPoint(*atp, i);
- clusters->SetPointId(atp); }
+ const AliTrackPointArray* pArr = at->GetTrackPointArray();
+ if (pArr == 0) {
+ Warning("clusters_from_index", "TrackPointArray not stored with ESD track.");
+ continue;
+ }
+ Int_t np = pArr->GetNPoints();
+ const Float_t* x = pArr->GetX();
+ const Float_t* y = pArr->GetY();
+ const Float_t* z = pArr->GetZ();
+ for (Int_t i=0; i<np; ++i) {
+ clusters->SetNextPoint(x[i], y[i], z[i]);
+ AliTrackPoint *atp = new AliTrackPoint;
+ pArr->GetPoint(*atp, i);
+ clusters->SetPointId(atp); }
+
+
+ if(clusters->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
+ Warning("clusters_from_index", Form("No clusters for index '%d'", index));
+ delete clusters;
+ return 0;
+ }
clusters->SetMarkerStyle(2);
clusters->SetMarkerSize(0.5);
sprintf(form,"Clusters idx=%d", index);
clusters->SetName(form);
+ char tip[1000];
+ sprintf(tip,"N=%d", clusters->Size());
+ clusters->SetTitle(tip);
+
using namespace Reve;
gReve->AddRenderElement(clusters);
gReve->Redraw3D();
// $Id$
-Reve::PointSet* clusters_from_label(Int_t label=0)
+Reve::PointSet* clusters_from_label(Int_t label=0, RenderElement* cont=0)
{
AliESD* esd = Alieve::Event::AssertESD();
Reve::PointSet* clusters = new Reve::PointSet(64);
}
}
}
+
+ if(clusters->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
+ Warning("clusters_from_label", Form("No clusters match label '%d'", label));
+ delete clusters;
+ return 0;
+ }
+
clusters->SetMarkerStyle(2);
clusters->SetMarkerSize(0.5);
clusters->SetMarkerColor(4);
sprintf(form,"Clusters lab=%d", label);
clusters->SetName(form);
+ char tip[1000];
+ sprintf(tip,"N=%d", clusters->Size());
+ clusters->SetTitle(tip);
+
using namespace Reve;
- gReve->AddRenderElement(clusters);
+ if(cont)
+ gReve->AddRenderElement(cont, clusters);
+ else
+ gReve->AddRenderElement(clusters);
gReve->Redraw3D();
return clusters;
gGeoManager = gReve->GetGeometry("$REVESYS/alice-data/alice_fullgeo.root");
- Reve::RenderElementList* list = new Reve::RenderElementList("HMPID");
+ Reve::RenderElementList* list = new Reve::RenderElementList("RICH");
gReve->AddGlobalRenderElement(list);
for(Int_t i=1; i<=7; ++i) {
//PH on some platforms (alphalinuxgcc, solariscc5, etc.)
//PH TGeoNode* node = gGeoManager->GetTopVolume()->FindNode(Form("HMPID_%d", i));
char form[1000];
- sprintf(form,"HMPID_%d", i);
+ sprintf(form,"RICH_%d", i);
TGeoNode* node = gGeoManager->GetTopVolume()->FindNode(form);
Reve::GeoTopNodeRnrEl* re = new Reve::GeoTopNodeRnrEl(gGeoManager, node);
// $Id$
-void hits_from_label(Int_t label=0)
+void hits_from_label(Int_t label=0, RenderElement* cont)
{
Reve::PointSet* h;
Reve::LoadMacro("its_hits.C");
//PH h = its_hits("fX:fY:fZ", Form("ITS.fTrack==%d", label));
char form[1000];
sprintf(form,"ITS.fTrack==%d", label);
- h = its_hits("fX:fY:fZ", form);
+ h = its_hits("fX:fY:fZ", form, cont);
if(h) h->SetMarkerSize(1);
Reve::LoadMacro("tpc_hits.C");
sprintf(form,"TPC2.fArray.fTrackID==%d", label);
- h = tpc_hits("TPC2.fArray.fR:TPC2.fArray.fFi:TPC2.fArray.fZ",form);
+ h = tpc_hits("TPC2.fArray.fR:TPC2.fArray.fFi:TPC2.fArray.fZ",form, cont);
//PH h = tpc_hits("TPC2.fArray.fR:TPC2.fArray.fFi:TPC2.fArray.fZ",
//PH Form("TPC2.fArray.fTrackID==%d", label));
if(h) h->SetMarkerSize(1);
Reve::LoadMacro("trd_hits.C");
sprintf(form,"TRD.fTrack==%d", label);
- h = trd_hits("fX:fY:fZ", form);
+ h = trd_hits("fX:fY:fZ", form, cont);
if(h) h->SetMarkerSize(1);
Reve::LoadMacro("tof_hits.C");
sprintf(form,"TOF.fTrack==%d", label);
- h = tof_hits("fX:fY:fZ", form);
+ h = tof_hits("fX:fY:fZ", form, cont);
if(h) h->SetMarkerSize(1);
gReve->Redraw3D();
Reve::PointSet*
its_hits(const char *varexp = "fX:fY:fZ",
- const char *selection = "")
+ const char *selection = "",
+ Reve::RenderElement* cont = 0)
{
AliRunLoader* rl = Alieve::Event::AssertRunLoader();
rl->LoadHits("ITS");
TPointSelector ps(ht, points, varexp, selection);
ps.Select();
- if( points->Size() == 0) {
+ if(points->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
Warning("its_hits", Form("No hits match '%s'", selection));
delete points;
return 0;
points->SetMarkerSize(.5);
points->SetMarkerColor((Color_t)2);
- gReve->AddRenderElement(points);
+ if(cont)
+ gReve->AddRenderElement(cont, points);
+ else
+ gReve->AddRenderElement(points);
gReve->Redraw3D();
return points;
// Create mother and daughters tracks with given label.
-Reve::TrackList*
+Reve::RenderElement*
kine_track(Int_t label,
Bool_t import_mother = kTRUE,
- Bool_t import_daughters = kTRUE,
- Reve::TrackList* cont = 0)
+ Bool_t import_daughters = kTRUE,
+ Reve::RenderElement* cont = 0)
+
{
if (label < 0) {
Warning("kine_track", "label not set.");
if (import_mother || (import_daughters && p->GetNDaughters()))
{
+ Track* toptrack = 0;
+ TrackList* tracklist = 0;
+ TrackRnrStyle* rs = 0;
+
if (cont == 0)
{
cont = new TrackList(Form("Kinematics of %d", label, p->GetNDaughters()));
rnrStyle->SetMagField( - gAlice->Field()->SolenoidField() );
char tooltip[1000];
sprintf(tooltip,"Ndaughters=%d", p->GetNDaughters());
- cont->SetTitle(tooltip);
+ cont->SetTitle(tooltip);
cont->SelectByPt(0.2, 100);
- rnrStyle->fColor = 8;
- rnrStyle->fMaxOrbs = 8;
+ rnrStyle->fColor = 8;
+ rnrStyle->fMaxOrbs = 8;
cont->SetEditPathMarks(kTRUE);
gReve->AddRenderElement(cont);
+ rs = cont->GetRnrStyle();
+ }
+ else {
+ // check if argument is TrackList
+ Reve::Track* t = dynamic_cast<Reve::Track*>(cont);
+ if(t)
+ {
+ rs = t->GetRnrStyle();
+ }
+ else {
+ Reve::TrackList* l = dynamic_cast<Reve::TrackList*>(cont);
+ if(l)
+ {
+ rs = l->GetRnrStyle();
+ }
+ else {
+ Error("kine_tracks.C", "TrackRenderStyle not set.");
+ }
+ }
}
-
+
if (import_mother)
{
- Track* track = new Reve::Track(p, label, cont->GetRnrStyle());
+ Track* track = new Reve::Track(p, label, rs);
char form[1000];
sprintf(form,"%s [%d]", p->GetName(), label);
track->SetName(form);
gReve->AddRenderElement(cont, track);
+
}
if (import_daughters && p->GetNDaughters())
for (int d=p->GetFirstDaughter(); d>0 && d<=p->GetLastDaughter(); ++d)
{
TParticle* dp = stack->Particle(d);
- Track* track = new Reve::Track(dp, d, cont->GetRnrStyle());
+ Track* track = new Reve::Track(dp, d, rs);
char form[1000];
sprintf(form,"%s [%d]", dp->GetName(), d);
track->SetName(form);
+ track->MakeTrack();
gReve->AddRenderElement(cont, track);
}
}
}
- if (cont)
- {
- // set path marks
- if(cont->GetEditPathMarks())
- {
- Alieve::KineTools kt;
- rl->LoadTrackRefs();
- kt.SetPathMarks(cont, stack, rl->TreeTR());
- }
- // update list tree
- cont->UpdateItems();
- cont->MakeTracks();
- cont->MakeMarkers();
- }
-
+ cont->UpdateItems();
gReve->Redraw3D();
return cont;
}
+
Reve::PointSet*
tof_hits(const char *varexp = "fX:fY:fZ",
- const char *selection = "")
+ const char *selection = "",
+ Reve::RenderElement* cont)
{
AliRunLoader* rl = Alieve::Event::AssertRunLoader();
rl->LoadHits("TOF");
TPointSelector ps(ht, points, varexp, selection);
ps.Select();
- if( points->Size() == 0) {
+ if( points->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
Warning("tof_hits", Form("No hits match '%s'", selection));
delete points;
return 0;
points->SetMarkerSize(.5);
points->SetMarkerColor((Color_t)2);
- gReve->AddRenderElement(points);
+ if(cont)
+ gReve->AddRenderElement(cont, points);
+ else
+ gReve->AddRenderElement(points);
+
gReve->Redraw3D();
return points;
Reve::PointSet*
tpc_hits(const char *varexp = "TPC2.fArray.fR:TPC2.fArray.fFi:TPC2.fArray.fZ",
- const char *selection = "TPC2.fArray.fR>80")
+ const char *selection = "TPC2.fArray.fR>80",
+ RenderElement* cont = 0)
{
// Extracts 'major' TPC hits (not the compressed ones).
// This gives ~2.5% of all hits.
TPointSelector ps(ht, points, varexp, selection);
ps.Select();
- if (points->Size() == 0) {
+ if (points->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
Warning("tpc_hits", Form("No hits match '%s'", selection));
delete points;
return 0;
points->SetMarkerSize(.5);
points->SetMarkerColor((Color_t)3);
- gReve->AddRenderElement(points);
+ if(cont)
+ gReve->AddRenderElement(cont, points);
+ else
+ gReve->AddRenderElement(points);
+
gReve->Redraw3D();
return points;
Reve::PointSet*
trd_hits(const char *varexp = "fX:fY:fZ",
- const char *selection = "")
+ const char *selection = "",
+ RenderElement* cont = 0)
{
AliRunLoader* rl = Alieve::Event::AssertRunLoader();
rl->LoadHits("TRD");
TPointSelector ps(ht, points, varexp, selection);
ps.Select();
- if (points->Size() == 0) {
+ if (points->Size() == 0 && gReve->GetKeepEmptyCont() == kFALSE) {
Warning("trd_hits", Form("No hits match '%s'", selection));
delete points;
return 0;
points->SetMarkerSize(.5);
points->SetMarkerColor((Color_t)7);
- gReve->AddRenderElement(points);
+ if(cont)
+ gReve->AddRenderElement(cont, points);
+ else
+ gReve->AddRenderElement(points);
+
gReve->Redraw3D();
return points;