CheezyDisplay.cxx

Go to the documentation of this file.

// $Id: CheezyDisplay.cxx,v 1.29 2005/08/26 19:07:29 rhatcher Exp $
//
// CheezyDisplay
//
// CheezyDisplay 
//
// Author:  R. Hatcher 2000.05.15
//

#include "RerootExodus/CheezyDisplay.h"

#include "Conventions/Munits.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliStripHandle.h"

#include "TCanvas.h"
#include "TPad.h"
#include "TH2.h"
#include "TPolyMarker.h"
#include "TVector3.h"

#include "MessageService/MsgService.h"
CVSID("$Id: CheezyDisplay.cxx,v 1.29 2005/08/26 19:07:29 rhatcher Exp $");

#include <cassert>

ClassImp(CheezyDisplay)

//_____________________________________________________________________________
CheezyDisplay::CheezyDisplay()
   : TNamed("CheezyDisplay","quick and dirty uv vs. z display")
   , fCanvas(0)
{
   // default constructor
   SetupDisplay();
}

//_____________________________________________________________________________
CheezyDisplay::CheezyDisplay(const char *name, const char *title, TCanvas* canvas)
   : TNamed(name,title)
   , fCanvas(canvas)
{
   // named constructor
   SetupDisplay();
}

//_____________________________________________________________________________
void CheezyDisplay::SetupDisplay()
{
   // Create the display

   // zero out pointer to objects not-yet-created
   fUview = fVview = 0;
   fPM_TU = fPM_TV = fPM_UE = fPM_VE = fPM_UW = fPM_VW = 0;

   // defaults
   fDrawSide[0]    = kTRUE;  // draw truth info
   fMarkerColor[0] = 16;     // kRed or 16=gray
   fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
   fMarkerSize[0]  = 0.65;

   fDrawSide[1]    = kTRUE;  // draw East info
   fMarkerColor[1] = kBlue;  // blue
   fMarkerType[1]  = 21;     //
   fMarkerSize[1]  = 0.55;

   fDrawSide[2]    = kTRUE;  // draw West info
   fMarkerColor[2] = kGreen; // green
   fMarkerType[2]  = 21;     //
   fMarkerSize[2]  = 0.45;   // smaller than East, drawn second

   fDrawTruth      = kTRUE;  // draw the Truth(tm)
   fDrawOnlyBest   = kFALSE; // draw all possibilities
   fWgtThresh      = -1;     // no real weight threshold cut

   // Create the canvas
   if (!fCanvas) 
       fCanvas = new TCanvas(GetName(),GetTitle(),600,600);

   // Create the pads;  Pad takes xlo, ylo, xhi, yhi in NC
   fUpad  = new TPad("upad","U pad",0.010,0.505,0.990,0.990);
   fVpad  = new TPad("vpad","V pad",0.010,0.010,0.990,0.495);

   // white background
   fUpad->SetFillColor(10);
   fVpad->SetFillColor(10);

   // tweak the margins to maximize histogram use of pads
   fUpad->SetLeftMargin(0.05);
   fUpad->SetRightMargin(0.0001);
   fUpad->SetTopMargin(0.0001);
   fUpad->SetBottomMargin(0.055);
   fVpad->SetLeftMargin(0.05);
   fVpad->SetRightMargin(0.0001);
   fVpad->SetTopMargin(0.0001);
   fVpad->SetBottomMargin(0.055);

   // draw the pads and the canvas
   fUpad->Draw();
   fVpad->Draw();
   fCanvas->Draw();

}

//_____________________________________________________________________________
CheezyDisplay::~CheezyDisplay()
{
   // delete all the owned sub-objects
   delete fUview;
   delete fVview;
   delete fUpad;
   delete fVpad;
   delete fCanvas;
}

//_____________________________________________________________________________
void CheezyDisplay::SetVldContext(VldContext& vldc)
{
   // Configure for a particular detector type

   Detector::Detector_t new_detector = vldc.GetDetector();
   Detector::Detector_t old_detector = fVldContext.GetDetector();

   // always set the current context (geometry builds off this)
   fVldContext = vldc; 

   if ( new_detector == old_detector ) return;

   // detector type changes - clear the lists
   ClearLists();

   Float_t zmin,zmax,tmin_u,tmax_u,tmin_v,tmax_v;
   Float_t spacing = 5.94;
   Float_t dt = 20;

   UgliGeomHandle ugh(fVldContext);
   ugh.GetZExtent(zmin,zmax);
   zmin /= Munits::cm;  // convert to cm
   zmax /= Munits::cm;  // convert to cm

   zmin -= 5*spacing;
   zmax += 5*spacing + 20;

   switch (new_detector) {
   case Detector::kNear:

//      zmin =        -5.0 * spacing;
//      zmax =  (float)282 * spacing + 20. + 5.0*spacing;

      tmin_u = -210  -dt;
      tmax_u =  275  +dt;
         
      tmin_v = -275  -dt;
      tmax_v =  210  +dt;

      fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
      fMarkerType[1]  = 20;     //
      fMarkerType[2]  = 20;     //

      fMarkerSize[0]  = 0.65;
      fMarkerSize[1]  = 0.5;
      fMarkerSize[2]  = 0.5;

      break;

   case Detector::kCalDet:

//      zmin =        -5.0 * spacing;
//      zmax =  (float)5*12 * spacing + 20. + 5.0*spacing;

      tmin_u = -50  -dt;
      tmax_u =  50  +dt;
         
      tmin_v = -50  -dt;
      tmax_v =  50  +dt;

      fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
      fMarkerType[1]  = 21;     //
      fMarkerType[2]  = 21;     //

      fMarkerSize[0]  = 0.65;
      fMarkerSize[1]  = 0.55;
      fMarkerSize[2]  = 0.45;   // smaller than East, drawn second

      break;

   case Detector::kFar:
   default:

//      zmin =        -5.0 * spacing;
//      zmax =  (float)484 * spacing  + 125. + 5.0*spacing;

      tmin_u = tmin_v = -405 -dt;
      tmax_u = tmax_v =  405 +dt;

      fMarkerType[0]  = 24;     // 24=circle, 25=box, 20=solid disk
      fMarkerType[1]  = 20;     //
      fMarkerType[2]  = 20;     //

      fMarkerSize[0]  = 0.65;
      fMarkerSize[1]  = 0.5;
      fMarkerSize[2]  = 0.5;

      break;
   }

   // clear the primitives from the pads
   fUpad->Clear("");
   fVpad->Clear("");

   // remove old histograms if they exists
   if ( fUview ) { delete fUview; fUview=0; }
   if ( fVview ) { delete fVview; fVview=0; }

   // create histograms that we'll use for World Coordinates
   fUview = new TH2F("Uview","U view",1,zmin,zmax,1,tmin_u,tmax_u);
   fVview = new TH2F("Vview","V view",1,zmin,zmax,1,tmin_v,tmax_v);

   // don't draw the Stats box
   fUview->SetStats(kFALSE);
   fVview->SetStats(kFALSE);

   // take away any association with a "directory" for these histograms
   fUview->SetDirectory(0);
   fVview->SetDirectory(0);
}

//_____________________________________________________________________________
void CheezyDisplay::ClearLists()
{
   // Clear the lists of SEIdAltL's

   fTrueSEIdUview.erase(fTrueSEIdUview.begin(),fTrueSEIdUview.end());
   fTrueSEIdVview.erase(fTrueSEIdVview.begin(),fTrueSEIdVview.end());

   fMuxSEIdUEast.erase(fMuxSEIdUEast.begin(),fMuxSEIdUEast.end());
   fMuxSEIdVEast.erase(fMuxSEIdVEast.begin(),fMuxSEIdVEast.end());
   fMuxSEIdUWest.erase(fMuxSEIdUWest.begin(),fMuxSEIdUWest.end());
   fMuxSEIdVWest.erase(fMuxSEIdVWest.begin(),fMuxSEIdVWest.end());

}

//_____________________________________________________________________________
void CheezyDisplay::AddStripEndId(const PlexStripEndId seid, const Bool_t truth)
{
   // Add an element to be drawn by encapulating it in a alt list

   PlexSEIdAltL altlist;
   altlist.AddStripEndId(seid,PlexPixelSpotId());
   AddSEIdAltL(altlist,truth);

}
//_____________________________________________________________________________
void CheezyDisplay::AddSEIdAltL(const PlexSEIdAltL altl, const Bool_t truth)
{
   // Add an element to be drawn to the right list

   if (altl.size() == 0) return;

   // determine view -- assume consistency within AltL
   PlaneView::PlaneView_t view = altl.GetPlaneView();

   Detector::Detector_t detector = altl.GetDetector();

   // If CalDet & PlaneView::kA or kB then print limited warning 
   // and ignore this entry
   static Int_t msgab = 2;
   if (Detector::kCalDet == detector) {
      if (PlaneView::kA == view || PlaneView::kB == view) {
         if (msgab>0) {
            MSG("Cheezy",Msg::kWarning)
               << " ignoring PlaneView kA and kB digits" << endl;
            msgab--;
         }
         return;
      }
   }

   switch (detector) {
   case Detector::kNear:
   case Detector::kFar:
   case Detector::kCalDet:
     break; // do nothing
   default:
     // unknown detector!
     MSG("Cheezy",Msg::kError)
       << "unknown detector in AltL" << endl;
     altl.Print();
     assert(0); 
   }
   static Int_t msgend  = 2;
   static Int_t msgview = 2;
   Bool_t badend  = kFALSE;
   Bool_t badview = kFALSE;

   if (truth) {
      switch (view) {
      case PlaneView::kU: fTrueSEIdUview.push_back(altl); break;
      case PlaneView::kV: fTrueSEIdVview.push_back(altl); break;
      default: badview = kTRUE;
      }
   } else {
      switch (altl.GetEnd()) {
      case StripEnd::kEast:
         switch (view) {
         case PlaneView::kU: fMuxSEIdUEast.push_back(altl); break;
         case PlaneView::kV: fMuxSEIdVEast.push_back(altl); break;
         default: badview = kTRUE;
         }
         break;
      case StripEnd::kWest:
         switch (view) {
         case PlaneView::kU: fMuxSEIdUWest.push_back(altl); break;
         case PlaneView::kV: fMuxSEIdVWest.push_back(altl); break;
         default: badview = kTRUE;
         }
         break;
      default:
         badend = kTRUE;
         break;
      }
   }

   if (badend && msgend>0) {
      MSG("Cheezy",Msg::kWarning)
         << "CheezyDisplay::AddSEIdAltL bad end \""
         << StripEnd::AsString(altl.GetEnd()) << "\""
         << endl;
      msgend--;
   }
   if (badview && msgview>0) {
      MSG("Cheezy",Msg::kWarning)
         << "CheezyDisplay::AddSEIdAltL bad view \""
         << PlaneView::AsString(view) << "\""
         << endl;
      msgview--;
   }


}

//_____________________________________________________________________________
void CheezyDisplay::Draw(Option_t* /* opt */)
{
   // Draw the display

   // delete all current polymarkers
   // safe to do even if pointer to 0
   SafeDelete(fPM_TU);
   SafeDelete(fPM_TV);
   SafeDelete(fPM_UE);
   SafeDelete(fPM_UW);
   SafeDelete(fPM_VE);
   SafeDelete(fPM_VW);

   MSG("Cheezy",Msg::kDebug) 
      << "Draw()  Truth " << (int)fDrawTruth
      << " OnlyBest " << (int)fDrawOnlyBest
      << " WgtThresh " << fWgtThresh << endl;

   // change to the U view pad
   fUpad->cd();
   if (fUview) fUview->Draw();

   if (fDrawSide[0] && fDrawTruth ) {
      fPM_TU = BuildPolyMarker(fTrueSEIdUview,0,0,kTRUE);
      if (fPM_TU) fPM_TU->Draw();
   }

   if (fDrawSide[1]) {
      fPM_UE = BuildPolyMarker(fMuxSEIdUEast,+1,1,kFALSE);
      if (fPM_UE) fPM_UE->Draw();
   }

   if (fDrawSide[2]) {
      fPM_UW = BuildPolyMarker(fMuxSEIdUWest,-1,2,kFALSE);
      if (fPM_UW) fPM_UW->Draw();
   }

   // change to the V view pad
   fVpad->cd();
   if (fVview) fVview->Draw();

   if (fDrawSide[0] && fDrawTruth ) {
      fPM_TV = BuildPolyMarker(fTrueSEIdVview,0,0,kTRUE);
      if (fPM_TV) fPM_TV->Draw();
   }

   if (fDrawSide[1]) {
      fPM_VE = BuildPolyMarker(fMuxSEIdVEast,+1,1,kFALSE);
      if (fPM_VE) fPM_VE->Draw();
   }

   if (fDrawSide[2]) {
      fPM_VW = BuildPolyMarker(fMuxSEIdVWest,-1,2,kFALSE);
      if (fPM_VW) fPM_VW->Draw();
   }

   fCanvas->Update();

}

//_____________________________________________________________________________
void CheezyDisplay::SetMarkerStyle(const Int_t   iside,
                           const Int_t   color, 
                           const Int_t   mtype,
                           const Float_t size)
{
   // Each view has three "sides" 0=Truth, 1=East, 2=West

   if (iside< 0 || iside > 2) return; // protection

   if (color < 0 || mtype < 0 || size < 0) {
      fDrawSide[iside] = kFALSE;
   } else {
      fDrawSide[iside]    = kTRUE;
      fMarkerColor[iside] = color;
      fMarkerType[iside]  = mtype;
      fMarkerSize[iside]  = size;
   }
}

//_____________________________________________________________________________
TPolyMarker* CheezyDisplay::BuildPolyMarker(std::vector<PlexSEIdAltL>& altl_list,
                                            Float_t yoff, Int_t iside, Bool_t truth)
{
   // Create a TPolyMarker from a PlexStripEndId list

   vector<PlexSEIdAltL>::iterator ilist;
   vector<PlexStripEndId>::iterator i;
   Int_t elements;

   TPolyMarker *pm = 0;
   vector<PlexStripEndId> seidlist;

   // make a list of the actual stripend id's to draw
   // makes use of automagic expansion of vector size
   elements = 0;
   for (ilist = altl_list.begin(); ilist != altl_list.end(); ++ilist) {
      PlexSEIdAltL altlist = (*ilist);
      if (truth) {
         PlexStripEndId truth = altlist.GetBestSEId();
         seidlist.push_back(truth);
      } else if (fDrawOnlyBest) {
         PlexStripEndId best = altlist.GetBestSEId();
         if (altlist.GetBestWeight() > fWgtThresh) 
            seidlist.push_back(best);
      } else {
         altlist.SetFirst();
         while ( altlist.IsValid() ) {
            PlexStripEndId seid = altlist.GetCurrentSEId();
            if (altlist.GetCurrentWeight() > fWgtThresh)
               seidlist.push_back(seid);
            altlist.Next();
         }
      }  
   }

   // count the relevant points
   elements = seidlist.size();
   // Allocate the PolyMarker
   if ( ! elements ) {
//    no elements  -- return null pointer
      return 0;
   }
   pm = new TPolyMarker(elements);

   if (iside<0 || iside>2) iside = 0;  // protection
   pm->SetMarkerStyle(fMarkerType[iside]);
   pm->SetMarkerColor(fMarkerColor[iside]);
   pm->SetMarkerSize(fMarkerSize[iside]);

   Float_t x,y;
   x = y = 0;
      
   Int_t j = 0;
   for (i = seidlist.begin(); i != seidlist.end(); ++i) {
      PlaneStripToXY((*i),yoff,x,y);
      pm->SetPoint(j,x,y);
      j++;                       
   }

   return pm;

}

//_____________________________________________________________________________
void CheezyDisplay::PlaneStripToXY(PlexStripEndId seid, Float_t xoff,
                                   Float_t &x, Float_t &y)
{

//   x = RerootExodus::RerootPlaneZ0(seid) + xoff;
//   y = RerootExodus::SEIdToTPos(seid);
//   return;

   UgliGeomHandle ugh(fVldContext);
   UgliStripHandle ush = ugh.GetStripHandle(seid);

   if (ush.IsValid()) {
      // Ugli uses Minos units
      // Cheezy expects "cm"
      x = ush.GlobalPos(0).Z()/Munits::cm + xoff;
      y = ush.GetTPos()/Munits::cm;
   } else {
      static Int_t msg_invalid = 5;
      if (msg_invalid>0) {
         MSG("Cheezy",Msg::kWarning)
            << "UgliStripHandle was invalid " << seid.AsString("c") <<
            endl;
         msg_invalid--;
      }
      // fake it
      x = seid.GetPlane() * 5.94 + xoff;
      const Float_t dy = 4.1;
      Float_t yoff = 0;
      switch (seid.GetDetector()) {
      case Detector::kNear:
         // in the near detector the offset depends on 
         // PlaneView and PlaneCoverage
         switch (seid.GetPlaneView()) {
         case PlaneView::kU:
            // in U view it matters whether it is a partial or full plane
            switch (seid.GetPlaneCoverage()) {
            case PlaneCoverage::kNearPartial:
               yoff = -6.4;
               break;
            case PlaneCoverage::kNearFull:
               yoff = -125.7;
               break;
            default:
               yoff = 0;
               break;
            }
            break;
         case PlaneView::kV:
            // in V view both partial and full planes start at same pos
            yoff = -273.8;
            break;
         default:  // not U or V in Near
            yoff = -100;
            break;
         }
         break;
      case Detector::kFar:
         yoff = (-96 + 0.5) * dy;
         break;
      case Detector::kCalDet:
         yoff = (-12 + 0.5) * dy;
         break;
      default:  // not Near, Far, CalDet
         yoff = 0;
         break;
      }
      y = yoff + seid.GetStrip() * dy;
   }

}
//_____________________________________________________________________________

---