EVE/Reve/Track.cxx

   1 // $Header$
   2
   3 #include "Track.h"
   4 #include "MCHelixLine.hi"
   5
   6 #include <TPolyLine3D.h>
   7 #include <TPolyMarker3D.h>
   8 #include <TColor.h>
   9
  10 // Updates
  11 #include <Reve/RGTopFrame.h>
  12 #include <TCanvas.h>
  13
  14 #include <vector>
  15
  16 using namespace Reve;
  17
  18 //______________________________________________________________________
  19 // Track
  20 //
  21
  22 ClassImp(Reve::Track)
  23
  24 Track::Track()
  25 {
  26   fRnrStyle = 0;
  27 }
  28
  29 Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs)
  30 {
  31   fRnrStyle = rs;
  32
  33   fName = t->GetName();
  34   fLineColor = fRnrStyle->GetColor();
  35   fMainColorPtr = &fLineColor;
  36
  37   fV.Set(t->Vx(), t->Vy(), t->Vz());
  38   fP.Set(t->Px(), t->Py(), t->Pz());
  39   fBeta   = t->P()/t->Energy();
  40
  41   TParticlePDG* pdgp = t->GetPDG();
  42   if(pdgp == 0) {
  43     t->ResetPdgCode(); pdgp = t->GetPDG();
  44   }
  45
  46   fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
  47   fLabel  = t->label;
  48 }
  49
  50 Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs)
  51 {
  52   fRnrStyle = rs;
  53   fName = t->GetName();
  54   fLineColor = fRnrStyle->GetColor();
  55   fMainColorPtr = &fLineColor;
  56
  57   fV = t->V;
  58   fP = t->P;
  59   fBeta   = t->beta;
  60   fCharge = t->sign;
  61   fLabel  = t->label;
  62 }
  63
  64 Track::~Track()
  65 {}
  66
  67 void Track::Reset(Int_t n_points)
  68 {
  69   delete [] TPolyLine3D::fP; TPolyLine3D::fP = 0;
  70   fN = n_points;
  71   if(fN) TPolyLine3D::fP = new Float_t [3*fN];
  72   memset(TPolyLine3D::fP, 0, 3*fN*sizeof(Float_t));
  73   fLastPoint = -1;
  74 }
  75
  76 /**************************************************************************/
  77
  78 void Track::MakeTrack()
  79 {
  80
  81   TrackRnrStyle& RS((fRnrStyle != 0) ? *fRnrStyle : TrackRnrStyle::fgDefStyle);
  82
  83   Float_t px = fP.x, py = fP.y, pz = fP.z;
  84
  85   MCVertex  mc_v0;
  86   mc_v0.x = fV.x;
  87   mc_v0.y = fV.y;
  88   mc_v0.z = fV.z;
  89   mc_v0.t = 0;
  90
  91   std::vector<MCVertex> track_points;
  92   Bool_t decay = kFALSE;
  93
  94   if ((TMath::Abs(fV.z) > RS.fMaxZ) || (fV.x*fV.x + fV.y*fV.y > RS.fMaxR*RS.fMaxR))
  95     goto make_polyline;
  96
  97   if (fCharge) { // Charged particle
  98
  99     Float_t a = RS.fgkB2C * RS.fMagField * fCharge;
 100
 101     MCHelix helix(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points, a); //m->cm
 102     helix.Init(TMath::Sqrt(px*px+py*py), pz);
 103
 104     if(!fPathMarks.empty()){
 105       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
 106         Reve::PathMark* pm = *i;
 107
 108         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
 109           if(TMath::Abs(pm->V.z) > RS.fMaxZ
 110              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
 111             goto helix_bounds;
 112
 113           //printf("%s fit daughter  \n", fName.Data());
 114           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
 115           fP.x -=  pm->P.x;
 116           fP.y -=  pm->P.y;
 117           fP.z -=  pm->P.z;
 118         }
 119         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
 120
 121           if(TMath::Abs(pm->V.z) > RS.fMaxZ
 122              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
 123             goto helix_bounds;
 124           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
 125           decay = true;
 126           break;
 127         }
 128       }
 129     }
 130   helix_bounds:
 131     //go to bounds
 132     if(!decay || RS.fFitDecay == kFALSE){
 133       helix.LoopToBounds(px,py,pz);
 134       // printf("%s loop to bounds  \n",fName.Data() );
 135     }
 136
 137   } else { // Neutral particle
 138
 139     MCLine line(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points);
 140
 141     if(!fPathMarks.empty()){
 142       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
 143         Reve::PathMark* pm = *i;
 144
 145         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
 146           if(TMath::Abs(pm->V.z) > RS.fMaxZ
 147              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
 148             goto line_bounds;
 149           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
 150           fP.x -=  pm->P.x;
 151           fP.y -=  pm->P.y;
 152           fP.z -=  pm->P.z;
 153         }
 154
 155         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
 156           if(TMath::Abs(pm->V.z) > RS.fMaxZ
 157              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
 158             goto line_bounds;
 159           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
 160           decay = true;
 161           break;
 162         }
 163       }
 164     }
 165
 166   line_bounds:
 167     if(!decay || RS.fFitDecay == kFALSE)
 168       line.GotoBounds(px,py,pz);
 169
 170   }
 171 make_polyline:
 172   Reset(track_points.size());
 173   for(std::vector<MCVertex>::iterator i=track_points.begin(); i!=track_points.end(); ++i)
 174     SetNextPoint(i->x, i->y, i->z);
 175 }
 176
 177 /**************************************************************************/
 178
 179 void Track::ImportHits()
 180 {
 181   Reve::LoadMacro("hits_from_label.C");
 182   gROOT->ProcessLine(Form("hits_from_label(%d);", fLabel));
 183 }
 184
 185 void Track::ImportClusters()
 186 {
 187   Reve::LoadMacro("clusters_from_label.C");
 188   gROOT->ProcessLine(Form("clusters_from_label(%d);", fLabel));
 189 }
 190
 191
 192 /**************************************************************************/
 193 /**************************************************************************/
 194
 195 //______________________________________________________________________
 196 // TrackRnrStyle
 197 //
 198
 199 ClassImp(Reve::TrackRnrStyle)
 200
 201 Float_t       TrackRnrStyle::fgDefMagField = 5;
 202 const Float_t TrackRnrStyle::fgkB2C        = 0.299792458e-3;
 203 TrackRnrStyle TrackRnrStyle::fgDefStyle;
 204
 205 void TrackRnrStyle::Init()
 206 {
 207   fMagField = fgDefMagField;
 208
 209   fMaxR  = 350;
 210   fMaxZ  = 450;
 211
 212   fMaxOrbs = 0.5;
 213   fMinAng  = 45;
 214
 215   fFitDaughters = kTRUE;
 216   fFitDecay     = kTRUE;
 217
 218   fDelta  = 0.1; //calculate step size depending on helix radius
 219 }
 220
 221 /**************************************************************************/
 222 /**************************************************************************/
 223
 224 //______________________________________________________________________
 225 // TrackList
 226 //
 227
 228 ClassImp(Reve::TrackList)
 229
 230 void TrackList::Init()
 231 {
 232   fMarkerStyle = 6;
 233   fMarkerColor = 5;
 234   // fMarker->SetMarkerSize(0.05);
 235
 236   fRnrMarkers = kTRUE;
 237   fRnrTracks  = kTRUE;
 238
 239   mRnrStyle = new TrackRnrStyle;
 240   SetMainColorPtr(&mRnrStyle->fColor);
 241 }
 242
 243 TrackList::TrackList(Int_t n_tracks) :
 244   TPolyMarker3D(n_tracks),
 245   RenderElementListBase()
 246 {
 247   Init();
 248 }
 249
 250 TrackList::TrackList(const Text_t* name, Int_t n_tracks) :
 251   TPolyMarker3D(n_tracks),
 252   RenderElementListBase()
 253 {
 254   Init();
 255   SetName(name);
 256 }
 257
 258 void TrackList::Reset(Int_t n_tracks)
 259 {
 260   delete [] fP; fP = 0;
 261   fN = n_tracks;
 262   if(fN) fP = new Float_t [3*fN];
 263   memset(fP, 0, 3*fN*sizeof(Float_t));
 264   fLastPoint = -1;
 265 }
 266
 267 /**************************************************************************/
 268
 269 void TrackList::Paint(Option_t* option)
 270 {
 271   if(fRnrElement) {
 272     if(fRnrMarkers) {
 273       TPolyMarker3D::Paint(option);
 274     }
 275     if(fRnrTracks) {
 276       for(lpRE_i i=fList.begin(); i!=fList.end(); ++i) {
 277         if((*i)->GetRnrElement())
 278           (*i)->GetObject()->Paint(option);
 279       }
 280     }
 281   }
 282 }
 283
 284 /**************************************************************************/
 285
 286 void TrackList::AddElement(RenderElement* el)
 287 {
 288   static const Exc_t eH("TrackList::AddElement ");
 289   if (dynamic_cast<Track*>(el)  == 0)
 290     throw(eH + "new element not a Track.");
 291   RenderElementListBase::AddElement(el);
 292 }
 293
 294 /**************************************************************************/
 295
 296 void TrackList::SetRnrMarkers(Bool_t rnr)
 297 {
 298   fRnrMarkers = rnr;
 299   gReve->Redraw3D();
 300 }
 301
 302 void TrackList::SetRnrTracks(Bool_t rnr)
 303 {
 304
 305   fRnrTracks = rnr;
 306   gReve->Redraw3D();
 307 }
 308
 309 /**************************************************************************/
 310
 311 void TrackList::MakeTracks()
 312 {
 313   for(lpRE_i i=fList.begin(); i!=fList.end(); ++i) {
 314     ((Track*)(*i))->MakeTrack();
 315   }
 316   gReve->Redraw3D();
 317 }
 318
 319
 320 void TrackList::MakeMarkers()
 321 {
 322   Reset(fList.size());
 323   for(lpRE_i i=fList.begin(); i!=fList.end(); ++i) {
 324     Track& t = *((Track*)(*i));
 325     if(t.GetN() > 0)
 326       SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
 327   }
 328   gReve->Redraw3D();
 329 }
 330
 331 /**************************************************************************/
 332 /*************************************************************************/
 333
 334 void TrackList::SetMaxR(Float_t x)
 335 {
 336   mRnrStyle->fMaxR = x;
 337   MakeTracks();
 338   MakeMarkers();
 339 }
 340
 341 void TrackList::SetMaxZ(Float_t x)
 342 {
 343   mRnrStyle->fMaxZ = x;
 344   MakeTracks();
 345   MakeMarkers();
 346 }
 347
 348 void TrackList::SetMaxOrbs(Float_t x)
 349 {
 350   mRnrStyle->fMaxOrbs = x;
 351   MakeTracks();
 352 }
 353
 354 void TrackList::SetMinAng(Float_t x)
 355 {
 356   mRnrStyle->fMinAng = x;
 357   MakeTracks();
 358 }
 359
 360 void TrackList::SetDelta(Float_t x)
 361 {
 362   mRnrStyle->fDelta = x;
 363   MakeTracks();
 364 }
 365
 366 void TrackList::SetFitDaughters(Bool_t x)
 367 {
 368   mRnrStyle->fFitDaughters = x;
 369   MakeTracks();
 370 }
 371
 372 void TrackList::SetFitDecay(Bool_t x)
 373 {
 374   mRnrStyle->fFitDecay = x;
 375   MakeTracks();
 376 }
 377
 378 /**************************************************************************/
 379 /**************************************************************************/
 380
 381 void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
 382 {
 383   Float_t minptsq = min_pt*min_pt;
 384   Float_t maxptsq = max_pt*max_pt;
 385   Float_t ptsq;
 386
 387   for(lpRE_i i=fList.begin(); i!=fList.end(); ++i) {
 388     ptsq = ((Track*)(*i))->fP.Perp2();
 389     (*i)->SetRnrElement(ptsq >= minptsq && ptsq <= maxptsq);
 390   }
 391 }
 392
 393 /**************************************************************************/
 394
 395 #include <TGFrame.h>
 396 #include <TGDoubleSlider.h>
 397 #include <TGXYLayout.h>
 398
 399 void TrackList::MakePtScrollbar()
 400 {
 401   TGMainFrame* mf = new TGMainFrame(gClient->GetRoot(), 320, 60);
 402
 403   TGDoubleHSlider* hs = new TGDoubleHSlider(mf);
 404   hs->SetRange(0.2, 10);
 405   hs->SetPosition(0.2, 10);
 406   hs->Resize(300, 25);
 407   mf->AddFrame(hs, new TGLayoutHints(kLHintsCenterX, 10, 10, 10, 10));
 408
 409   hs->Connect("PositionChanged()", "Reve::TrackList",
 410               this, "HandlePtScrollEvent()");
 411
 412   mf->SetWindowName("Pt Selector");
 413   mf->MapSubwindows();
 414   mf->Resize(mf->GetDefaultSize()); // this is used here to init layout algorithm
 415   mf->MapWindow();
 416 }
 417
 418 void TrackList::HandlePtScrollEvent()
 419 {
 420   TGDoubleHSlider* hs = (TGDoubleHSlider*)gTQSender;
 421
 422   Float_t min = hs->GetMinPosition(), max = hs->GetMaxPosition();
 423   printf("hslidor min=%f max=%f\n", min, max);
 424   SelectByPt(min, max);
 425 }