CheezyDisplay Class Reference

#include <CheezyDisplay.h>

List of all members.

Public Member Functions

 CheezyDisplay ()
 CheezyDisplay (const char *name, const char *title, TCanvas *canvas=0)
virtual ~CheezyDisplay ()
void SetVldContext (VldContext &vldc)
void ClearLists ()
void AddStripEndId (const PlexStripEndId seid, const Bool_t truth)
void AddSEIdAltL (const PlexSEIdAltL altl, const Bool_t truth)
void Draw (Option_t *option="")
void SetMarkerStyle (const Int_t iside, const Int_t color, const Int_t mtype, const Float_t size)
void SetDrawTruth (const Bool_t drawtruth)
void SetDrawOnlyBest (const Bool_t onlybest)
void SetWgtThresh (const Float_t threshold)
Bool_t IsSideDrawn (const Int_t iside) const
Int_t GetMarkerColor (const Int_t iside) const
Int_t GetMarkerType (const Int_t iside) const
Float_t GetMarkerSize (const Int_t iside) const

Private Member Functions

void SetupDisplay ()
TPolyMarker * BuildPolyMarker (std::vector< PlexSEIdAltL > &altl_list, Float_t yoff, Int_t iside, Bool_t truth)
void PlaneStripToXY (PlexStripEndId seid, Float_t xoff, Float_t &x, Float_t &y)

Private Attributes

VldContext fVldContext
TCanvas * fCanvas
TPad * fUpad
TPad * fVpad
TH2F * fUview
TH2F * fVview
std::vector< PlexSEIdAltLfTrueSEIdUview
std::vector< PlexSEIdAltLfTrueSEIdVview
std::vector< PlexSEIdAltLfMuxSEIdUEast
std::vector< PlexSEIdAltLfMuxSEIdVEast
std::vector< PlexSEIdAltLfMuxSEIdUWest
std::vector< PlexSEIdAltLfMuxSEIdVWest
Bool_t fDrawSide [3]
Int_t fMarkerColor [3]
Int_t fMarkerType [3]
Float_t fMarkerSize [3]
TPolyMarker * fPM_TU
TPolyMarker * fPM_TV
TPolyMarker * fPM_UE
TPolyMarker * fPM_VE
TPolyMarker * fPM_UW
TPolyMarker * fPM_VW
Bool_t fDrawTruth
Bool_t fDrawOnlyBest
Float_t fWgtThresh

Detailed Description

Definition at line 28 of file CheezyDisplay.h.


Constructor & Destructor Documentation

CheezyDisplay::CheezyDisplay (  ) 

Definition at line 32 of file CheezyDisplay.cxx.

00033    : TNamed("CheezyDisplay","quick and dirty uv vs. z display")
00034    , fCanvas(0)
00035 {
00036    // default constructor
00037    SetupDisplay();
00038 }

CheezyDisplay::CheezyDisplay ( const char *  name,
const char *  title,
TCanvas *  canvas = 0 
)

Definition at line 41 of file CheezyDisplay.cxx.

References SetupDisplay().

00042    : TNamed(name,title)
00043    , fCanvas(canvas)
00044 {
00045    // named constructor
00046    SetupDisplay();
00047 }

CheezyDisplay::~CheezyDisplay (  )  [virtual]

Definition at line 108 of file CheezyDisplay.cxx.

References fCanvas, fUpad, fUview, fVpad, and fVview.

00109 {
00110    // delete all the owned sub-objects
00111    delete fUview;
00112    delete fVview;
00113    delete fUpad;
00114    delete fVpad;
00115    delete fCanvas;
00116 }


Member Function Documentation

void CheezyDisplay::AddSEIdAltL ( const PlexSEIdAltL  altl,
const Bool_t  truth 
)

Definition at line 256 of file CheezyDisplay.cxx.

References bfld::AsString(), fMuxSEIdUEast, fMuxSEIdUWest, fMuxSEIdVEast, fMuxSEIdVWest, fTrueSEIdUview, fTrueSEIdVview, PlexSEIdAltL::GetDetector(), PlexSEIdAltL::GetEnd(), PlexSEIdAltL::GetPlaneView(), PlaneView::kA, PlaneView::kB, Detector::kCalDet, StripEnd::kEast, Msg::kError, Detector::kFar, Detector::kNear, PlaneView::kU, PlaneView::kV, Msg::kWarning, StripEnd::kWest, MSG, and PlexSEIdAltL::Print().

Referenced by AddStripEndId(), CheezyDisplayModule::Ana(), and CheezyPage::Update().

00257 {
00258    // Add an element to be drawn to the right list
00259 
00260    if (altl.size() == 0) return;
00261 
00262    // determine view -- assume consistency within AltL
00263    PlaneView::PlaneView_t view = altl.GetPlaneView();
00264 
00265    Detector::Detector_t detector = altl.GetDetector();
00266 
00267    // If CalDet & PlaneView::kA or kB then print limited warning 
00268    // and ignore this entry
00269    static Int_t msgab = 2;
00270    if (Detector::kCalDet == detector) {
00271       if (PlaneView::kA == view || PlaneView::kB == view) {
00272          if (msgab>0) {
00273             MSG("Cheezy",Msg::kWarning)
00274                << " ignoring PlaneView kA and kB digits" << endl;
00275             msgab--;
00276          }
00277          return;
00278       }
00279    }
00280 
00281    switch (detector) {
00282    case Detector::kNear:
00283    case Detector::kFar:
00284    case Detector::kCalDet:
00285      break; // do nothing
00286    default:
00287      // unknown detector!
00288      MSG("Cheezy",Msg::kError)
00289        << "unknown detector in AltL" << endl;
00290      altl.Print();
00291      assert(0); 
00292    }
00293    static Int_t msgend  = 2;
00294    static Int_t msgview = 2;
00295    Bool_t badend  = kFALSE;
00296    Bool_t badview = kFALSE;
00297 
00298    if (truth) {
00299       switch (view) {
00300       case PlaneView::kU: fTrueSEIdUview.push_back(altl); break;
00301       case PlaneView::kV: fTrueSEIdVview.push_back(altl); break;
00302       default: badview = kTRUE;
00303       }
00304    } else {
00305       switch (altl.GetEnd()) {
00306       case StripEnd::kEast:
00307          switch (view) {
00308          case PlaneView::kU: fMuxSEIdUEast.push_back(altl); break;
00309          case PlaneView::kV: fMuxSEIdVEast.push_back(altl); break;
00310          default: badview = kTRUE;
00311          }
00312          break;
00313       case StripEnd::kWest:
00314          switch (view) {
00315          case PlaneView::kU: fMuxSEIdUWest.push_back(altl); break;
00316          case PlaneView::kV: fMuxSEIdVWest.push_back(altl); break;
00317          default: badview = kTRUE;
00318          }
00319          break;
00320       default:
00321          badend = kTRUE;
00322          break;
00323       }
00324    }
00325 
00326    if (badend && msgend>0) {
00327       MSG("Cheezy",Msg::kWarning)
00328          << "CheezyDisplay::AddSEIdAltL bad end \""
00329          << StripEnd::AsString(altl.GetEnd()) << "\""
00330          << endl;
00331       msgend--;
00332    }
00333    if (badview && msgview>0) {
00334       MSG("Cheezy",Msg::kWarning)
00335          << "CheezyDisplay::AddSEIdAltL bad view \""
00336          << PlaneView::AsString(view) << "\""
00337          << endl;
00338       msgview--;
00339    }
00340 
00341 
00342 }

void CheezyDisplay::AddStripEndId ( const PlexStripEndId  seid,
const Bool_t  truth 
)

Definition at line 246 of file CheezyDisplay.cxx.

References AddSEIdAltL(), and PlexSEIdAltL::AddStripEndId().

Referenced by RerootToRawDataModule::Reco().

00247 {
00248    // Add an element to be drawn by encapulating it in a alt list
00249 
00250    PlexSEIdAltL altlist;
00251    altlist.AddStripEndId(seid,PlexPixelSpotId());
00252    AddSEIdAltL(altlist,truth);
00253 
00254 }

TPolyMarker * CheezyDisplay::BuildPolyMarker ( std::vector< PlexSEIdAltL > &  altl_list,
Float_t  yoff,
Int_t  iside,
Bool_t  truth 
) [private]

Definition at line 426 of file CheezyDisplay.cxx.

References fDrawOnlyBest, fMarkerColor, fMarkerSize, fMarkerType, fWgtThresh, PlexSEIdAltL::GetBestSEId(), PlexSEIdAltL::GetBestWeight(), PlexSEIdAltL::GetCurrentSEId(), PlexSEIdAltL::GetCurrentWeight(), PlexSEIdAltL::IsValid(), PlexSEIdAltL::Next(), PlaneStripToXY(), and PlexSEIdAltL::SetFirst().

Referenced by Draw().

00428 {
00429    // Create a TPolyMarker from a PlexStripEndId list
00430 
00431    vector<PlexSEIdAltL>::iterator ilist;
00432    vector<PlexStripEndId>::iterator i;
00433    Int_t elements;
00434 
00435    TPolyMarker *pm = 0;
00436    vector<PlexStripEndId> seidlist;
00437 
00438    // make a list of the actual stripend id's to draw
00439    // makes use of automagic expansion of vector size
00440    elements = 0;
00441    for (ilist = altl_list.begin(); ilist != altl_list.end(); ++ilist) {
00442       PlexSEIdAltL altlist = (*ilist);
00443       if (truth) {
00444          PlexStripEndId truth = altlist.GetBestSEId();
00445          seidlist.push_back(truth);
00446       } else if (fDrawOnlyBest) {
00447          PlexStripEndId best = altlist.GetBestSEId();
00448          if (altlist.GetBestWeight() > fWgtThresh) 
00449             seidlist.push_back(best);
00450       } else {
00451          altlist.SetFirst();
00452          while ( altlist.IsValid() ) {
00453             PlexStripEndId seid = altlist.GetCurrentSEId();
00454             if (altlist.GetCurrentWeight() > fWgtThresh)
00455                seidlist.push_back(seid);
00456             altlist.Next();
00457          }
00458       }  
00459    }
00460 
00461    // count the relevant points
00462    elements = seidlist.size();
00463    // Allocate the PolyMarker
00464    if ( ! elements ) {
00465 //    no elements  -- return null pointer
00466       return 0;
00467    }
00468    pm = new TPolyMarker(elements);
00469 
00470    if (iside<0 || iside>2) iside = 0;  // protection
00471    pm->SetMarkerStyle(fMarkerType[iside]);
00472    pm->SetMarkerColor(fMarkerColor[iside]);
00473    pm->SetMarkerSize(fMarkerSize[iside]);
00474 
00475    Float_t x,y;
00476    x = y = 0;
00477       
00478    Int_t j = 0;
00479    for (i = seidlist.begin(); i != seidlist.end(); ++i) {
00480       PlaneStripToXY((*i),yoff,x,y);
00481       pm->SetPoint(j,x,y);
00482       j++;                       
00483    }
00484 
00485    return pm;
00486 
00487 }

void CheezyDisplay::ClearLists (  ) 

Definition at line 231 of file CheezyDisplay.cxx.

References fMuxSEIdUEast, fMuxSEIdUWest, fMuxSEIdVEast, fMuxSEIdVWest, fTrueSEIdUview, and fTrueSEIdVview.

Referenced by CheezyDisplayModule::Ana(), CheezyPage::Clear(), RerootToRawDataModule::Reco(), and SetVldContext().

00232 {
00233    // Clear the lists of SEIdAltL's
00234 
00235    fTrueSEIdUview.erase(fTrueSEIdUview.begin(),fTrueSEIdUview.end());
00236    fTrueSEIdVview.erase(fTrueSEIdVview.begin(),fTrueSEIdVview.end());
00237 
00238    fMuxSEIdUEast.erase(fMuxSEIdUEast.begin(),fMuxSEIdUEast.end());
00239    fMuxSEIdVEast.erase(fMuxSEIdVEast.begin(),fMuxSEIdVEast.end());
00240    fMuxSEIdUWest.erase(fMuxSEIdUWest.begin(),fMuxSEIdUWest.end());
00241    fMuxSEIdVWest.erase(fMuxSEIdVWest.begin(),fMuxSEIdVWest.end());
00242 
00243 }

void CheezyDisplay::Draw ( Option_t *  option = ""  ) 

Definition at line 345 of file CheezyDisplay.cxx.

References BuildPolyMarker(), fCanvas, fDrawOnlyBest, fDrawSide, fDrawTruth, fMuxSEIdUEast, fMuxSEIdUWest, fMuxSEIdVEast, fMuxSEIdVWest, fPM_TU, fPM_TV, fPM_UE, fPM_UW, fPM_VE, fPM_VW, fTrueSEIdUview, fTrueSEIdVview, fUpad, fUview, fVpad, fVview, fWgtThresh, Msg::kDebug, and MSG.

Referenced by CheezyDisplayModule::Ana(), CheezyDisplayModule::HandleCommand(), RerootToRawDataModule::Reco(), and CheezyPage::Update().

00346 {
00347    // Draw the display
00348 
00349    // delete all current polymarkers
00350    // safe to do even if pointer to 0
00351    SafeDelete(fPM_TU);
00352    SafeDelete(fPM_TV);
00353    SafeDelete(fPM_UE);
00354    SafeDelete(fPM_UW);
00355    SafeDelete(fPM_VE);
00356    SafeDelete(fPM_VW);
00357 
00358    MSG("Cheezy",Msg::kDebug) 
00359       << "Draw()  Truth " << (int)fDrawTruth
00360       << " OnlyBest " << (int)fDrawOnlyBest
00361       << " WgtThresh " << fWgtThresh << endl;
00362 
00363    // change to the U view pad
00364    fUpad->cd();
00365    if (fUview) fUview->Draw();
00366 
00367    if (fDrawSide[0] && fDrawTruth ) {
00368       fPM_TU = BuildPolyMarker(fTrueSEIdUview,0,0,kTRUE);
00369       if (fPM_TU) fPM_TU->Draw();
00370    }
00371 
00372    if (fDrawSide[1]) {
00373       fPM_UE = BuildPolyMarker(fMuxSEIdUEast,+1,1,kFALSE);
00374       if (fPM_UE) fPM_UE->Draw();
00375    }
00376 
00377    if (fDrawSide[2]) {
00378       fPM_UW = BuildPolyMarker(fMuxSEIdUWest,-1,2,kFALSE);
00379       if (fPM_UW) fPM_UW->Draw();
00380    }
00381 
00382    // change to the V view pad
00383    fVpad->cd();
00384    if (fVview) fVview->Draw();
00385 
00386    if (fDrawSide[0] && fDrawTruth ) {
00387       fPM_TV = BuildPolyMarker(fTrueSEIdVview,0,0,kTRUE);
00388       if (fPM_TV) fPM_TV->Draw();
00389    }
00390 
00391    if (fDrawSide[1]) {
00392       fPM_VE = BuildPolyMarker(fMuxSEIdVEast,+1,1,kFALSE);
00393       if (fPM_VE) fPM_VE->Draw();
00394    }
00395 
00396    if (fDrawSide[2]) {
00397       fPM_VW = BuildPolyMarker(fMuxSEIdVWest,-1,2,kFALSE);
00398       if (fPM_VW) fPM_VW->Draw();
00399    }
00400 
00401    fCanvas->Update();
00402 
00403 }

Int_t CheezyDisplay::GetMarkerColor ( const Int_t  iside  )  const [inline]

Definition at line 58 of file CheezyDisplay.h.

References fMarkerColor.

00059       {return fMarkerColor[iside];}

Float_t CheezyDisplay::GetMarkerSize ( const Int_t  iside  )  const [inline]

Definition at line 62 of file CheezyDisplay.h.

References fMarkerSize.

00063       {return fMarkerSize[iside];}

Int_t CheezyDisplay::GetMarkerType ( const Int_t  iside  )  const [inline]

Definition at line 60 of file CheezyDisplay.h.

References fMarkerType.

00061       {return fMarkerType[iside];}

Bool_t CheezyDisplay::IsSideDrawn ( const Int_t  iside  )  const [inline]

Definition at line 56 of file CheezyDisplay.h.

References fDrawSide.

00057       {return fDrawSide[iside];}

void CheezyDisplay::PlaneStripToXY ( PlexStripEndId  seid,
Float_t  xoff,
Float_t &  x,
Float_t &  y 
) [private]

Definition at line 490 of file CheezyDisplay.cxx.

References PlexStripEndId::AsString(), Munits::cm, fVldContext, PlexPlaneId::GetDetector(), PlexPlaneId::GetPlane(), PlexPlaneId::GetPlaneCoverage(), PlexPlaneId::GetPlaneView(), PlexStripEndId::GetStrip(), UgliGeomHandle::GetStripHandle(), UgliStripHandle::GetTPos(), UgliStripHandle::GlobalPos(), UgliStripHandle::IsValid(), Detector::kCalDet, Detector::kFar, Detector::kNear, PlaneCoverage::kNearFull, PlaneCoverage::kNearPartial, PlaneView::kU, PlaneView::kV, Msg::kWarning, and MSG.

Referenced by BuildPolyMarker().

00492 {
00493 
00494 //   x = RerootExodus::RerootPlaneZ0(seid) + xoff;
00495 //   y = RerootExodus::SEIdToTPos(seid);
00496 //   return;
00497 
00498    UgliGeomHandle ugh(fVldContext);
00499    UgliStripHandle ush = ugh.GetStripHandle(seid);
00500 
00501    if (ush.IsValid()) {
00502       // Ugli uses Minos units
00503       // Cheezy expects "cm"
00504       x = ush.GlobalPos(0).Z()/Munits::cm + xoff;
00505       y = ush.GetTPos()/Munits::cm;
00506    } else {
00507       static Int_t msg_invalid = 5;
00508       if (msg_invalid>0) {
00509          MSG("Cheezy",Msg::kWarning)
00510             << "UgliStripHandle was invalid " << seid.AsString("c") <<
00511             endl;
00512          msg_invalid--;
00513       }
00514       // fake it
00515       x = seid.GetPlane() * 5.94 + xoff;
00516       const Float_t dy = 4.1;
00517       Float_t yoff = 0;
00518       switch (seid.GetDetector()) {
00519       case Detector::kNear:
00520          // in the near detector the offset depends on 
00521          // PlaneView and PlaneCoverage
00522          switch (seid.GetPlaneView()) {
00523          case PlaneView::kU:
00524             // in U view it matters whether it is a partial or full plane
00525             switch (seid.GetPlaneCoverage()) {
00526             case PlaneCoverage::kNearPartial:
00527                yoff = -6.4;
00528                break;
00529             case PlaneCoverage::kNearFull:
00530                yoff = -125.7;
00531                break;
00532             default:
00533                yoff = 0;
00534                break;
00535             }
00536             break;
00537          case PlaneView::kV:
00538             // in V view both partial and full planes start at same pos
00539             yoff = -273.8;
00540             break;
00541          default:  // not U or V in Near
00542             yoff = -100;
00543             break;
00544          }
00545          break;
00546       case Detector::kFar:
00547          yoff = (-96 + 0.5) * dy;
00548          break;
00549       case Detector::kCalDet:
00550          yoff = (-12 + 0.5) * dy;
00551          break;
00552       default:  // not Near, Far, CalDet
00553          yoff = 0;
00554          break;
00555       }
00556       y = yoff + seid.GetStrip() * dy;
00557    }
00558 
00559 }

void CheezyDisplay::SetDrawOnlyBest ( const Bool_t  onlybest  )  [inline]

Definition at line 51 of file CheezyDisplay.h.

References fDrawOnlyBest.

Referenced by CheezyPage::ApplyConfig(), and CheezyDisplayModule::HandleCommand().

00052       {fDrawOnlyBest = onlybest;}

void CheezyDisplay::SetDrawTruth ( const Bool_t  drawtruth  )  [inline]

Definition at line 49 of file CheezyDisplay.h.

References fDrawTruth.

Referenced by CheezyPage::ApplyConfig(), and CheezyDisplayModule::HandleCommand().

00050       {fDrawTruth    = drawtruth;}

void CheezyDisplay::SetMarkerStyle ( const Int_t  iside,
const Int_t  color,
const Int_t  mtype,
const Float_t  size 
)

Definition at line 406 of file CheezyDisplay.cxx.

References fDrawSide, fMarkerColor, fMarkerSize, and fMarkerType.

00410 {
00411    // Each view has three "sides" 0=Truth, 1=East, 2=West
00412 
00413    if (iside< 0 || iside > 2) return; // protection
00414 
00415    if (color < 0 || mtype < 0 || size < 0) {
00416       fDrawSide[iside] = kFALSE;
00417    } else {
00418       fDrawSide[iside]    = kTRUE;
00419       fMarkerColor[iside] = color;
00420       fMarkerType[iside]  = mtype;
00421       fMarkerSize[iside]  = size;
00422    }
00423 }

void CheezyDisplay::SetupDisplay (  )  [private]

Definition at line 50 of file CheezyDisplay.cxx.

References fCanvas, fDrawOnlyBest, fDrawSide, fDrawTruth, fMarkerColor, fMarkerSize, fMarkerType, fPM_TU, fPM_TV, fPM_UE, fPM_UW, fPM_VE, fPM_VW, fUpad, fUview, fVpad, fVview, fWgtThresh, and Nav::GetName().

Referenced by CheezyDisplay().

00051 {
00052    // Create the display
00053 
00054    // zero out pointer to objects not-yet-created
00055    fUview = fVview = 0;
00056    fPM_TU = fPM_TV = fPM_UE = fPM_VE = fPM_UW = fPM_VW = 0;
00057 
00058    // defaults
00059    fDrawSide[0]    = kTRUE;  // draw truth info
00060    fMarkerColor[0] = 16;     // kRed or 16=gray
00061    fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
00062    fMarkerSize[0]  = 0.65;
00063 
00064    fDrawSide[1]    = kTRUE;  // draw East info
00065    fMarkerColor[1] = kBlue;  // blue
00066    fMarkerType[1]  = 21;     //
00067    fMarkerSize[1]  = 0.55;
00068 
00069    fDrawSide[2]    = kTRUE;  // draw West info
00070    fMarkerColor[2] = kGreen; // green
00071    fMarkerType[2]  = 21;     //
00072    fMarkerSize[2]  = 0.45;   // smaller than East, drawn second
00073 
00074    fDrawTruth      = kTRUE;  // draw the Truth(tm)
00075    fDrawOnlyBest   = kFALSE; // draw all possibilities
00076    fWgtThresh      = -1;     // no real weight threshold cut
00077 
00078    // Create the canvas
00079    if (!fCanvas) 
00080        fCanvas = new TCanvas(GetName(),GetTitle(),600,600);
00081 
00082    // Create the pads;  Pad takes xlo, ylo, xhi, yhi in NC
00083    fUpad  = new TPad("upad","U pad",0.010,0.505,0.990,0.990);
00084    fVpad  = new TPad("vpad","V pad",0.010,0.010,0.990,0.495);
00085 
00086    // white background
00087    fUpad->SetFillColor(10);
00088    fVpad->SetFillColor(10);
00089 
00090    // tweak the margins to maximize histogram use of pads
00091    fUpad->SetLeftMargin(0.05);
00092    fUpad->SetRightMargin(0.0001);
00093    fUpad->SetTopMargin(0.0001);
00094    fUpad->SetBottomMargin(0.055);
00095    fVpad->SetLeftMargin(0.05);
00096    fVpad->SetRightMargin(0.0001);
00097    fVpad->SetTopMargin(0.0001);
00098    fVpad->SetBottomMargin(0.055);
00099 
00100    // draw the pads and the canvas
00101    fUpad->Draw();
00102    fVpad->Draw();
00103    fCanvas->Draw();
00104 
00105 }

void CheezyDisplay::SetVldContext ( VldContext vldc  ) 

Definition at line 119 of file CheezyDisplay.cxx.

References ClearLists(), Munits::cm, fMarkerSize, fMarkerType, fUpad, fUview, fVldContext, fVpad, fVview, VldContext::GetDetector(), UgliGeomHandle::GetZExtent(), Detector::kCalDet, Detector::kFar, and Detector::kNear.

Referenced by CheezyDisplayModule::Ana(), RerootToRawDataModule::Reco(), and CheezyPage::Update().

00120 {
00121    // Configure for a particular detector type
00122 
00123    Detector::Detector_t new_detector = vldc.GetDetector();
00124    Detector::Detector_t old_detector = fVldContext.GetDetector();
00125 
00126    // always set the current context (geometry builds off this)
00127    fVldContext = vldc; 
00128 
00129    if ( new_detector == old_detector ) return;
00130 
00131    // detector type changes - clear the lists
00132    ClearLists();
00133 
00134    Float_t zmin,zmax,tmin_u,tmax_u,tmin_v,tmax_v;
00135    Float_t spacing = 5.94;
00136    Float_t dt = 20;
00137 
00138    UgliGeomHandle ugh(fVldContext);
00139    ugh.GetZExtent(zmin,zmax);
00140    zmin /= Munits::cm;  // convert to cm
00141    zmax /= Munits::cm;  // convert to cm
00142 
00143    zmin -= 5*spacing;
00144    zmax += 5*spacing + 20;
00145 
00146    switch (new_detector) {
00147    case Detector::kNear:
00148 
00149 //      zmin =        -5.0 * spacing;
00150 //      zmax =  (float)282 * spacing + 20. + 5.0*spacing;
00151 
00152       tmin_u = -210  -dt;
00153       tmax_u =  275  +dt;
00154          
00155       tmin_v = -275  -dt;
00156       tmax_v =  210  +dt;
00157 
00158       fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
00159       fMarkerType[1]  = 20;     //
00160       fMarkerType[2]  = 20;     //
00161 
00162       fMarkerSize[0]  = 0.65;
00163       fMarkerSize[1]  = 0.5;
00164       fMarkerSize[2]  = 0.5;
00165 
00166       break;
00167 
00168    case Detector::kCalDet:
00169 
00170 //      zmin =        -5.0 * spacing;
00171 //      zmax =  (float)5*12 * spacing + 20. + 5.0*spacing;
00172 
00173       tmin_u = -50  -dt;
00174       tmax_u =  50  +dt;
00175          
00176       tmin_v = -50  -dt;
00177       tmax_v =  50  +dt;
00178 
00179       fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
00180       fMarkerType[1]  = 21;     //
00181       fMarkerType[2]  = 21;     //
00182 
00183       fMarkerSize[0]  = 0.65;
00184       fMarkerSize[1]  = 0.55;
00185       fMarkerSize[2]  = 0.45;   // smaller than East, drawn second
00186 
00187       break;
00188 
00189    case Detector::kFar:
00190    default:
00191 
00192 //      zmin =        -5.0 * spacing;
00193 //      zmax =  (float)484 * spacing  + 125. + 5.0*spacing;
00194 
00195       tmin_u = tmin_v = -405 -dt;
00196       tmax_u = tmax_v =  405 +dt;
00197 
00198       fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
00199       fMarkerType[1]  = 20;     //
00200       fMarkerType[2]  = 20;     //
00201 
00202       fMarkerSize[0]  = 0.65;
00203       fMarkerSize[1]  = 0.5;
00204       fMarkerSize[2]  = 0.5;
00205 
00206       break;
00207    }
00208 
00209    // clear the primitives from the pads
00210    fUpad->Clear("");
00211    fVpad->Clear("");
00212 
00213    // remove old histograms if they exists
00214    if ( fUview ) { delete fUview; fUview=0; }
00215    if ( fVview ) { delete fVview; fVview=0; }
00216 
00217    // create histograms that we'll use for World Coordinates
00218    fUview = new TH2F("Uview","U view",1,zmin,zmax,1,tmin_u,tmax_u);
00219    fVview = new TH2F("Vview","V view",1,zmin,zmax,1,tmin_v,tmax_v);
00220 
00221    // don't draw the Stats box
00222    fUview->SetStats(kFALSE);
00223    fVview->SetStats(kFALSE);
00224 
00225    // take away any association with a "directory" for these histograms
00226    fUview->SetDirectory(0);
00227    fVview->SetDirectory(0);
00228 }

void CheezyDisplay::SetWgtThresh ( const Float_t  threshold  )  [inline]

Definition at line 53 of file CheezyDisplay.h.

References fWgtThresh.

Referenced by CheezyPage::ApplyConfig(), and CheezyDisplayModule::HandleCommand().

00054       {fWgtThresh    = threshold;}


Member Data Documentation

TCanvas* CheezyDisplay::fCanvas [private]

Definition at line 78 of file CheezyDisplay.h.

Referenced by Draw(), SetupDisplay(), and ~CheezyDisplay().

Bool_t CheezyDisplay::fDrawOnlyBest [private]

Definition at line 105 of file CheezyDisplay.h.

Referenced by BuildPolyMarker(), Draw(), SetDrawOnlyBest(), and SetupDisplay().

Bool_t CheezyDisplay::fDrawSide[3] [private]

Definition at line 92 of file CheezyDisplay.h.

Referenced by Draw(), IsSideDrawn(), SetMarkerStyle(), and SetupDisplay().

Bool_t CheezyDisplay::fDrawTruth [private]

Definition at line 104 of file CheezyDisplay.h.

Referenced by Draw(), SetDrawTruth(), and SetupDisplay().

Int_t CheezyDisplay::fMarkerColor[3] [private]

Definition at line 93 of file CheezyDisplay.h.

Referenced by BuildPolyMarker(), GetMarkerColor(), SetMarkerStyle(), and SetupDisplay().

Float_t CheezyDisplay::fMarkerSize[3] [private]
Int_t CheezyDisplay::fMarkerType[3] [private]

Definition at line 87 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

Definition at line 89 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

Definition at line 88 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

Definition at line 90 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

TPolyMarker* CheezyDisplay::fPM_TU [private]

Definition at line 97 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

TPolyMarker* CheezyDisplay::fPM_TV [private]

Definition at line 98 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

TPolyMarker* CheezyDisplay::fPM_UE [private]

Definition at line 99 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

TPolyMarker* CheezyDisplay::fPM_UW [private]

Definition at line 101 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

TPolyMarker* CheezyDisplay::fPM_VE [private]

Definition at line 100 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

TPolyMarker* CheezyDisplay::fPM_VW [private]

Definition at line 102 of file CheezyDisplay.h.

Referenced by Draw(), and SetupDisplay().

Definition at line 85 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

Definition at line 86 of file CheezyDisplay.h.

Referenced by AddSEIdAltL(), ClearLists(), and Draw().

TPad* CheezyDisplay::fUpad [private]

Definition at line 79 of file CheezyDisplay.h.

Referenced by Draw(), SetupDisplay(), SetVldContext(), and ~CheezyDisplay().

TH2F* CheezyDisplay::fUview [private]

Definition at line 82 of file CheezyDisplay.h.

Referenced by Draw(), SetupDisplay(), SetVldContext(), and ~CheezyDisplay().

Definition at line 76 of file CheezyDisplay.h.

Referenced by PlaneStripToXY(), and SetVldContext().

TPad* CheezyDisplay::fVpad [private]

Definition at line 80 of file CheezyDisplay.h.

Referenced by Draw(), SetupDisplay(), SetVldContext(), and ~CheezyDisplay().

TH2F* CheezyDisplay::fVview [private]

Definition at line 83 of file CheezyDisplay.h.

Referenced by Draw(), SetupDisplay(), SetVldContext(), and ~CheezyDisplay().

Float_t CheezyDisplay::fWgtThresh [private]

Definition at line 106 of file CheezyDisplay.h.

Referenced by BuildPolyMarker(), Draw(), SetupDisplay(), and SetWgtThresh().


The documentation for this class was generated from the following files:

Generated on 22 Nov 2017 for loon by  doxygen 1.6.1