StEventUtilities/StuDraw3DEvent.cxx

// $Id: StuDraw3DEvent.cxx,v 1.34 2012/04/27 00:20:23 perev Exp $
// *-- Author :    Valery Fine(fine@bnl.gov)   27/04/2008
#include "StuDraw3DEvent.h"
#include "TSystem.h"
#include "TVirtualPad.h"
#include "TColor.h"
#include "StEventHelper.h"
#include "StEvent.h"
#include "StTrack.h"
#include "StHit.h"
#include "StTpcHit.h"
#include "StFtpcHit.h"
#include "StEmcRawHit.h"
#include "StTrackNode.h"
#include "StTrackGeometry.h"
#include "StTpcHitCollection.h"
#include "StEmcCollection.h"
#include "StFtpcHitCollection.h"
#include "StFtpcSectorHitCollection.h"
#include "StFtpcPlaneHitCollection.h"
#include "StEmcDetector.h"
#include "StEmcModule.h"
#include "StMeasuredPoint.h"
#include "TMath.h"
#include "StTrackDetectorInfo.h"
#include "StEmcUtil/geometry/StEmcGeom.h"
#include "StEventHitIter.h"
#include "StMessMgr.h"


//____________________________________________________________________________________

ClassImp(StuDraw3DEvent)
//___________________________________________________
StuDraw3DEvent::StuDraw3DEvent( const char *detectorName,TVirtualPad *pad):StDraw3D(detectorName,pad)
{
   // The detectorName is a comma separated list of the OpenInventor files with no extension
   // For all names on the list one should provide the iv file with the "iv extension:
   //                         <name>.iv
   if (!gEventDisplay) gEventDisplay = this;
}

//____________________________________________________________________________________

//____________________________________________________________________________________
StuDraw3DEvent::~StuDraw3DEvent()
{
   if (gEventDisplay == this) gEventDisplay = 0;
}
//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::EmcHit(Int_t emcHitsSoftId, Color_t col,Style_t sty,Size_t siz, const char *detId)
{  
   TObject *model = 0;
   StEmcGeom *emcGeom =StEmcGeom::getEmcGeom(detId);
   if (emcGeom) {
      Int_t softId=emcHitsSoftId;
      Float_t eta;
      Float_t phi;
      emcGeom->getEtaPhi(softId,eta,phi);
      Float_t etaStep = 1.0/emcGeom->NEta();
      Float_t phiStep = TMath::Pi()/60; 
      static int entries = 0;
        //if (entries) return 0;
        // printf(" m=%d, e=%d, s=%d; eta=%e deta=%e phi=%e dphi=%e id %d\n",m, e, s,eta,etaStep ,phi, phiStep, softId);
      entries++;
      model  = Tower(emcGeom->Radius(), StarRoot::StEta(eta,etaStep)
                         , phi, phiStep
                         , col,sty+(strcmp(detId,"bemc")?0:kBarrelStyle),siz);
   } else {
      LOG_ERROR <<  __FILE__ << ":  there is no geometry information for \"" << detId << "\"" << endm;
   }
   return model;
}
//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::EmcHit(const StEmcRawHit &emcHit, Color_t col,Style_t sty,Size_t siz, const char *detId)
{  
   TObject *model = 0;
   if (!detId || !detId[0]) detId = "bemc";
   StEmcGeom *emcGeom =StEmcGeom::getEmcGeom(detId);
   if (emcGeom) {
      int m, e, s;
      Int_t softId;
      emcHit.modEtaSub(m,e,s);
      emcGeom->getId(m,e,s,softId);
      EmcHit(softId, col,sty,siz,detId);
      SetModel((TObject*)&emcHit);
   } else {
      LOG_ERROR <<  __FILE__ << ":  there is no geometry information for \"" << detId << "\"" << endm;
   }
   return model;
}

//____________________________________________________________________________________

//______________________________________________________________________________________
void StuDraw3DEvent::EmcHits(const StEvent* event,const char *detId) 
{
   Color_t colorResponce = 0;
   if (!detId || !detId[0]) detId = "bemc";
   StEmcCollection* emcC =(StEmcCollection*)event->emcCollection();
   if (emcC) {
      StEmcDetector* det = emcC->detector( strcmp(detId,"bemc") ? kEndcapEmcTowerId : kBarrelEmcTowerId); 
      for(unsigned int md=1; md <=det->numberOfModules(); md++) {
         StEmcModule*  module=det->module(md);
         StSPtrVecEmcRawHit&   hit=  module->hits();
     
         for(unsigned int ih=0;ih < hit.size();ih++){
            StEmcRawHit *h=hit[ih];
            double  rawAdc=h->adc()-5; // raw ADC 
            float energy =  h->energy();
                 Style_t style=0; // solid
//               energy = (rawAdc+5)/5;
//               printf(" EmcHits %d adc = %e energy = %e\n", ih,rawAdc, energy);
            if ( rawAdc>0  && energy > 0  && energy < 30) {
               // If edep less then MIP (~300 MeV), 60GeV <-> 4096 ADC counts
               if (  energy  < 0.3)   {   
                 colorResponce = kBlue; 
                // style = 4001;                 //wireframe 
               // If edep large then MIP but less then 1 GeV 
               } else if (  energy  < 1.0 ) colorResponce = kGreen;
               // If between 1 GeV and lowest HT threshold (4 GeV for Run7)
               else if (  energy  < 4.0 )   colorResponce = kYellow;
               // If above lowest HT thershold
               else                         colorResponce = kRed;
               if (energy > 1.0) {
                //  printf(" Emchit adc = %e energy = %e\n",rawAdc, energy);
               }
               static const double maxSize =  400.; // (cm)
               static const double scale   =  200.; // (cm/Gev)
               double size =(energy > 0.3 ? scale : scale/30.)*energy;
               if (size > maxSize)  size = maxSize ;
               EmcHit(*h,colorResponce,style, size,detId);
            }
         }
      }
   }
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::Track(const StTrack &track, Color_t col,Style_t sty,Size_t siz)
{
   StTrackHelper trPnt(&track);
   Int_t size;
   Float_t *xyz = trPnt.GetPoints(size);
   TObject *l = Line(size,xyz,col,sty,siz);
   SetModel((TObject*)&track);
   return l;
}


//___________________________________________________
TObject *StuDraw3DEvent::Track(const StTrack &track, EDraw3DStyle sty)
{
   const StDraw3DStyle &style =  Style(sty);
   return Track(track, style.Col(),style.Sty(),style.Siz() );
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::Hit(const StMeasuredPoint &hit
                  ,  Color_t col,  Style_t sty,  Size_t siz)
{
   // Draw the StMeasuredPoint, StHit, StVertex with the graphical attribute provided
   const StThreeVectorF& position = hit.position();
   TObject *p = Point(position.x(),position.y(),position.z(),col,sty,siz);
   SetModel((TObject*)&hit);
   return p;
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::Hit(const StMeasuredPoint &hit, EDraw3DStyle sty)
{
   const StDraw3DStyle &style =  Style(sty);
   return Hit(hit, style.Col(),style.Sty(),style.Siz() );
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::Vertex(const StMeasuredPoint &vertex
                  ,  Color_t col,  Style_t sty, Size_t siz)
{
   return Hit(vertex,col,sty,siz);
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::Vertex(const StMeasuredPoint &vtx, EDraw3DStyle sty)
{
   const StDraw3DStyle &style =  Style(sty);
   return Vertex(vtx, style.Col(),style.Sty(),style.Siz() );
}

//____________________________________________________________________________________

//____________________________________________________________________________________
void  StuDraw3DEvent::Hits(const StTrack &track)
{
    // Draw hits the "track" was built from
    // with the graphical attributes defined by "track"
   if (track.flag() > 0 &&  track.detectorInfo()&& !track.bad() ) {
      Style_t sty = Style(kUsedHit).Sty();
      Size_t  siz = Style(kUsedHit).Siz();
      double pt = track.geometry()->momentum().perp();
      Hits(track, StDraw3DStyle::Pt2Color(pt),sty,siz);
   }
}

//____________________________________________________________________________________

//____________________________________________________________________________________
void  StuDraw3DEvent::Hits(const StTrack &track
                  ,  Color_t col
                  ,  Style_t sty
                  ,  Size_t siz )
{
    // Draw hits the "track" was built from
    // with the graphical attributes "col", "sty", "siz"
   std::vector<float> hitPoints;
   const StPtrVecHit& trackHits = track.detectorInfo()->hits(kTpcId);
   unsigned int m=0;
   StHit *hit = 0;
   for (m=0; m<trackHits.size(); m++) {
      hit = trackHits[m];
      hitPoints.push_back( hit->position().x());
      hitPoints.push_back( hit->position().y());
      hitPoints.push_back( hit->position().z());
   }
   {
      std::vector<float>::iterator xyz = hitPoints.begin();
      Points(hitPoints.size()/3,&*xyz,col,sty,siz); 
   }
   // printf(" Tpc hits # %d\n", m);

   const StPtrVecHit& trackWestHits = track.detectorInfo()->hits(kFtpcWestId);

   hitPoints.clear();
   for (m=0; m<trackWestHits.size(); m++) {
      hit = trackWestHits[m];
      hitPoints.push_back( hit->position().x());
      hitPoints.push_back( hit->position().y());
      hitPoints.push_back( hit->position().z());
   }
   {
      std::vector<float>::iterator xyz = hitPoints.begin();
      Points(hitPoints.size()/3,&*xyz,col,sty,siz); 
   }
   // printf(" Ftpc West hits # %d\n", m);

   hitPoints.clear();
   const StPtrVecHit& trackEastHits = track.detectorInfo()->hits(kFtpcEastId);
   for (m=0; m<trackEastHits.size(); m++) {
      hit = trackEastHits[m];
      hitPoints.push_back( hit->position().x());
      hitPoints.push_back( hit->position().y());
      hitPoints.push_back( hit->position().z());
   }
   {
      std::vector<float>::iterator xyz = hitPoints.begin();
      Points(hitPoints.size()/3,&*xyz,col,sty,siz); 
   }
   // printf(" Ftpc East hits # %d\n", m);
}

//____________________________________________________________________________________

//____________________________________________________________________________________
void  StuDraw3DEvent::Hits(const StTrack &track,  EDraw3DStyle sty)
{
   // Draw hits the "track" was built from
   // using the "sty" graphical style provided
   const StDraw3DStyle &style =  Style(sty);
   Hits(track, style.Col(),style.Sty(),style.Siz());
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::TrackInOut(const StTrack &track, Bool_t in
                  ,  Color_t col,  Style_t sty,  Size_t siz)
{
   StInnOutPoints trInOut(&track,in);
   return Points(trInOut.Size(),trInOut.GetXYZ(0),col,sty,siz);
}

//____________________________________________________________________________________

//____________________________________________________________________________________
TObject *StuDraw3DEvent::TrackInOut(const StTrack &track, EDraw3DStyle sty,Bool_t in)
{
   const StDraw3DStyle &style =  Style(sty);
   return TrackInOut(track, in, style.Col(),style.Sty(),style.Siz() );
}


//____________________________________________________________________________________

//____________________________________________________________________________________
void StuDraw3DEvent::Tracks(const StEvent* event, StTrackType type)
{
   Hits(event,kTracksOnly,type);
}

//____________________________________________________________________________________

//____________________________________________________________________________________
void StuDraw3DEvent::Tracks(const StSPtrVecTrackNode &theNodes
      , StTrackType type)
{
   StTrack *track;
   StThreeVectorD p;
   unsigned int i;
   // double pt;
   //    int  minFitPoints = mAllGlobalTracks ? 1 : mMinFitPoints;
   for (i=0; i<theNodes.size(); i++) {
      track = theNodes[i]->track(type);
      if (track && track->flag() > 0
         //  &&   track->fitTraits().numberOfFitPoints(kTpcId) >= minFitPoints) 
         )
      {
         double pt = track->geometry()->momentum().perp();
         Track(*track,StDraw3DStyle::Pt2Color(pt));
      }
   }
}
//___________________________________________________
void StuDraw3DEvent::Hits(const StEvent *event,EStuDraw3DEvent trackHitsOnly, StTrackType type)
{
   if (!event) return; // no event
   const StTpcHitCollection* hits = event->tpcHitCollection();
   if (!hits) return; // there is no hits
   unsigned int m, n, h;
   if (trackHitsOnly != kUnusedHitsOnly) {
      Style_t sty = Style(kUsedHit).Sty();
      Size_t  siz = Style(kUsedHit).Siz();
      Style_t styPnt = Style(kTrackBegin).Sty();
      Size_t  sizPnt = Style(kTrackBegin).Siz();

      const StSPtrVecTrackNode& theNodes = event->trackNodes();
      for (unsigned int i=0; i<theNodes.size(); i++) {
         StTrack *track = theNodes[i]->track(type);
         if (track &&  track->flag() > 0
                   &&  track->detectorInfo() 
                   && !track->bad() 
         //  &&   track->fitTraits().numberOfFitPoints(kTpcId) >= minFitPoints) 
         )
        {
            double pt = track->geometry()->momentum().perp();
            Color_t trackColor = StDraw3DStyle::Pt2Color(pt);
            if ( trackHitsOnly != kUsedHits) {
               Track(*track,trackColor);
               TrackInOut(*track, true,  trackColor,  styPnt, sizPnt);
               TrackInOut(*track, false, trackColor,  styPnt, sizPnt);
            }
            if ( trackHitsOnly != kTracksOnly) {
               Hits(*track,trackColor,sty,siz);
               if (trackHitsOnly == kUsedHits) SetModel(track);
           }
        }
     }
   } else {
      const StTpcHit *hit;
      std::vector<float> hitPoints;
      for (n=0; n<hits->numberOfSectors(); n++) {
         for (m=0; m<hits->sector(n)->numberOfPadrows(); m++) { 
            for (h=0; h<hits->sector(n)->padrow(m)->hits().size(); h++) {
               hit = hits->sector(n)->padrow(m)->hits()[h];
                hitPoints.push_back( hit->position().x());
                hitPoints.push_back( hit->position().y());
                hitPoints.push_back( hit->position().z());
            }
         }
      }
      std::vector<float>::iterator xyz = hitPoints.begin();
      Points(hitPoints.size()/3,&*xyz,kUnusedHit);
      SetComment("Unused TPC hits");
   }
}

//___________________________________________________
void StuDraw3DEvent::FtpcHits(const StEvent *event,EStuDraw3DEvent trackHitsOnly, StTrackType type)
{
   if (!event) return; // no event
   unsigned int m, n, h;
   if (trackHitsOnly != kUnusedHitsOnly) {
      Style_t sty    = Style(kUsedHit).Sty();
      Size_t  siz    = Style(kUsedHit).Siz();
      Style_t styPnt = Style(kTrackBegin).Sty();
      Size_t  sizPnt = Style(kTrackBegin).Siz();
      int trackCounter = 0;
      const StSPtrVecTrackNode& theNodes = event->trackNodes();
      for (unsigned int i=0; i<theNodes.size(); i++) {
         StTrack *track = theNodes[i]->track(type);
         if (track &&  track->flag() > 0
                   &&  track->detectorInfo()                
                   &&  ( track->detectorInfo()->numberOfPoints(kFtpcWestId) || track->detectorInfo()->numberOfPoints(kFtpcEastId)  )
                   && !track->bad() 
         )
        {
           ++trackCounter;
            double pt = track->geometry()->momentum().perp();
            Color_t trackColor = StDraw3DStyle::Pt2Color(pt);
            if ( trackHitsOnly != kUsedHits) {
               Track(*track,trackColor);
               TrackInOut(*track, true,  trackColor,  styPnt, sizPnt);
               TrackInOut(*track, false, trackColor,  styPnt, sizPnt);
            }
            if ( trackHitsOnly != kTracksOnly) {
               Hits(*track,trackColor,sty,siz);
               if (trackHitsOnly == kUsedHits) SetModel(track);
           }
        }
     }
     printf(" Ftpc tracks total : %d\n", trackCounter);
   } else {
      const StHit *hit= 0;
      std::vector<float> hitPoints;
      const StFtpcHitCollection* ftpHits = event->ftpcHitCollection(); 
      if (ftpHits->numberOfHits()>0) {
          for (n=0;n<ftpHits-> numberOfPlanes();++n ) {
             for (m=0; m<ftpHits->plane(n)->numberOfSectors(); m++) { 
               for (h=0; h<ftpHits->plane(n)->sector(m)->hits().size(); h++) {
                  hit = ftpHits->plane(n)->sector(m)->hits()[h];
                  hitPoints.push_back( hit->position().x());
                  hitPoints.push_back( hit->position().y());
                  hitPoints.push_back( hit->position().z());
           } } }
          std::vector<float>::iterator xyz = hitPoints.begin();
          Points(hitPoints.size()/3,&*xyz,kUnusedHit);
          SetComment("Unused FTPC hits");
          printf(" FTPC hits counter total : %d\n", hitPoints.size()/3);
     }
  }
}

//____________________________________________________________________________________
//____________________________________________________________________________________
StuDraw3DEvent *StuDraw3DEvent::Display(){ return gEventDisplay;}

StuDraw3DEvent *gEventDisplay = new StuDraw3DEvent();
//____________________________________________________________________________________
void StuDraw3DEvent::Hits(StEventHitIter &iter)
{
  std::vector<float> hitPoints;
  for (const StHit *sth=0;(sth = *(iter));++iter) {
    const float *f = sth->position().xyz();
    hitPoints.push_back(f[0]);
    hitPoints.push_back(f[1]);
    hitPoints.push_back(f[2]);
  }
  std::vector<float>::iterator xyz = hitPoints.begin();
  Points(hitPoints.size()/3,&*xyz,kUsedHit);
}
//____________________________________________________________________________________
//_____________________________________________________________________________
void StuDraw3DEvent::Wait()
{
    if (gEventDisplay) gEventDisplay->UpdateModified();
    fprintf(stderr,"StvDraw::Waiting...\n");
    while(!gSystem->ProcessEvents()){gSystem->Sleep(200);}; 
}

---