00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
#ifdef __ROOT__
00068
00069
#include "StGlobals.hh"
00070
00071
#include "TLine.h"
00072
#include "TFile.h"
00073
#include "TNtuple.h"
00074
#include "TText.h"
00075
#include "TPaveText.h"
00076
#include "StTrackDetectorInfo.h"
00077
00078
#include "StParticleDefinition.hh"
00079
00080
#include "StRrsMaker/StRichGeometryDb.h"
00081
#include "StRrsMaker/StRichCoordinateTransform.h"
00082
#include "StRrsMaker/StRichSinglePixel.h"
00083
#include "StRrsMaker/StRichSingleMCPixel.h"
00084
00085
#include "StRichPadMonitor.h"
00086
#include "StRichDrawableTPad.h"
00087
#include "StRichDrawableMCTPad.h"
00088
#include "StRichDrawableTG2T.h"
00089
#include "StRichDrawableTHit.h"
00090
#include "StRichDrawableTRings.h"
00091
#include "StRichDrawableTTrack.h"
00092
#include "StRichDrawableTMip.h"
00093
00094
00095
#include "StRichPIDMaker/StRichTrack.h"
00096
#include "StRichPIDMaker/StRichRingHit.h"
00097
00098
#include "StRichPadMonitorText.h"
00099
#include "StTrackGeometry.h"
00100
#include "StTrackFitTraits.h"
00101
00102
#include "StRchMaker/StRichSimpleHit.h"
00103
00104
#include "StEvent/StRichPidTraits.h"
00105
#include "StEvent/StRichPid.h"
00106
00107 StRichPadMonitor* StRichPadMonitor::mInstance = 0;
00108
00109 StRichPadMonitor* StRichPadMonitor::getInstance(StRichGeometryDb* geo)
00110 {
00111
if(!mInstance)
00112 mInstance =
new StRichPadMonitor(geo);
00113
00114
return mInstance;
00115 }
00116
00117 StRichPadMonitor::StRichPadMonitor(StRichGeometryDb* geoDb)
00118 : mGeometryDb(geoDb), mLegendE(0), mLegendPi(0), mLegendK(0), mLegendP(0),
00119 mFileEventNum(0), mFileName(0), mZVertex(0), mNumTracks(0)
00120 {
00121 pionminus = StPionMinus::instance();
00122 kaonminus = StKaonMinus::instance();
00123 antiproton = StAntiProton::instance();
00124
00125 pionplus = StPionPlus::instance();
00126 kaonplus = StKaonPlus::instance();
00127 proton = StProton::instance();
00128
00129 mListOfParticles.push_back(pionminus);
00130 mListOfParticles.push_back(pionplus);
00131 mListOfParticles.push_back(kaonminus);
00132 mListOfParticles.push_back(kaonplus);
00133 mListOfParticles.push_back(proton);
00134 mListOfParticles.push_back(antiproton);
00135
00136 mTransform = StRichCoordinateTransform::getTransform(geoDb);
00137
00138
00139 mRichCanvas =
new TCanvas(
"richCanvas",
"RICH Event Display",0,0,1200,900);
00140
00141 mRichCanvas->Range(-70,-50,105,50);
00142
00143
00144
00145
00146 mTextWindow =
new StRichPadMonitorText();
00147 StRichDrawableTPad::setPadMonitorText(mTextWindow);
00148 StRichDrawableTG2T::setPadMonitor(
this);
00149
00150
00151
00152 mRowPitch = mGeometryDb->rowPitch();
00153 mPadPitch = mGeometryDb->padPitch();
00154 mPadLength = mGeometryDb->padLength();
00155 mPadWidth = mGeometryDb->padWidth();
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
double yco = mGeometryDb->quadrantY0(2)+.5*mRowPitch;
00176
double xco = -mGeometryDb->quadrantX0(2)+.5*mPadPitch;
00177
double yci = -mGeometryDb->quadrantY0(4)-.5*mRowPitch;
00178
double xci = mGeometryDb->quadrantX0(4)-.5*mPadPitch;
00179
00180 TLine aLine;
00181 aLine.SetLineWidth(2);
00182
00183 TBox aBox;
00184 aBox.SetLineWidth(2);
00185 aBox.SetLineColor(1);
00186 aBox.SetFillStyle(0);
00187
00188
00189 aBox.DrawBox(xci,yci,xco,yco);
00190
00191
00192 aBox.DrawBox(-xci,yci,-xco,yco);
00193
00194
00195 aBox.DrawBox(-xci,-yci,-xco,-yco);
00196
00197
00198 aBox.DrawBox(xci,-yci,xco,-yco);
00199
00200
00201
00202
00203 this->drawColorBox();
00204 this->drawLegend();
00205
00206
00207
00208
00209
00210
00211
00212
00213 }
00214
00215
void StRichPadMonitor::drawColorBox()
00216 {
00217
double lowerX = 75.;
00218
double upperX = 77.;
00219
double lowerY = -35;
00220
double upperY;
00221
00222
00223
for(
int ii=0; ii<1024; ii++) {
00224 upperY = lowerY + .07;
00225 mColorBoxes.Add(
new TBox(lowerX,lowerY,upperX,upperY));
00226 ((TBox*)mColorBoxes.Last())->SetFillColor(GetColorAttribute(static_cast<double>(ii)));
00227 ((TBox*)mColorBoxes.Last())->Draw();
00228
if((ii == 10) || (ii == 50) || (ii == 100) ||
00229 (ii == 200) || (ii == 500) || (ii == 1000)) {
00230 mTextLabels.Add(
new TPaveText((lowerX-7),(lowerY-2),(lowerX-2),(lowerY+1)) );
00231
char text[5];
00232 sprintf(text,
"%d",ii);
00233 dynamic_cast<TPaveText*>(mTextLabels.Last())->AddText(text);
00234 dynamic_cast<TPaveText*>(mTextLabels.Last())->Draw();
00235 }
00236 lowerY = upperY;
00237 }
00238 }
00239
00240 StRichPadMonitor::~StRichPadMonitor()
00241 {
00242 cout <<
"in ~StRichPadMonitor" << endl;
00243 this->clearAll();
00244
00245
00246
00247
delete mRichCanvas;
00248
00249
delete mLegendE;
00250
delete mLegendPi;
00251
delete mLegendK;
00252
delete mLegendP;
00253
00254
delete mFileName;
00255
delete mFileEventNum;
00256
00257
delete mZVertex;
00258
delete mNumTracks;
00259 cout <<
"out ~StRichPadMonitor" << endl;
00260 }
00261
00262
void StRichPadMonitor::clearAll() {
00263 this->clearPads();
00264 this->clearG2T();
00265 this->clearHits();
00266 this->clearTracks();
00267 this->clearRingInfo();
00268 this->clearMisc();
00269 this->clearQuickRings();
00270 this->clearText();
00271 }
00272
00273
void StRichPadMonitor::clearPads()
00274 {
00275
00276
00277 mAllFilledPads.Delete();
00278 }
00279
00280
void StRichPadMonitor::clearG2T()
00281 {
00282
00283
00284
00285 mG2TSegments.Delete();
00286 }
00287
00288
void StRichPadMonitor::clearHits() {
00289
00290
00291
00292 mHits.Delete();
00293 }
00294
00295
void StRichPadMonitor::clearTracks() {
00296
00297
for(
unsigned int j=0; j<mVectorTracks.size(); j++) {
00298
delete mVectorTracks[j];
00299 }
00300
00301 mVectorTracks.clear();
00302 mVectorTracks.resize(0);
00303
00304 this->clearRingInfo();
00305 }
00306
00307
void StRichPadMonitor::clearRingInfo() {
00308 cout <<
"StRichPadMonitor::clearRingInfo()" << endl;
00309
00310 mRingInfo.Delete();
00311 }
00312
00313
void StRichPadMonitor::clearMisc()
00314 {
00315
00316
00317 mMisc.Delete();
00318 }
00319
00320
void StRichPadMonitor::clearQuickRings()
00321 {
00322 mQuickRings.Delete();
00323 }
00324
00325
void StRichPadMonitor::clearText()
00326 {
00327 mText.Delete();
00328 }
00329
00330
void StRichPadMonitor::drawPads()
00331 {
00332
00333
for(
int ii=0; ii<mAllFilledPads.GetLast()+1; ii++) {
00334 (mAllFilledPads[ii])->Draw();
00335 }
00336 }
00337
00338
void
00339 StRichPadMonitor::calculatePadPosition(
const StRichSinglePixel* pad,
00340
double* xl,
double* yl,
double* xu,
double* yu)
00341 {
00342
00343 StRichRawCoordinate raw(pad->pad(), pad->row());
00344 StRichLocalCoordinate local;
00345 (*mTransform)(raw,local);
00346
00347
00348
double yo = local.position().y();
00349
double xo = local.position().x();
00350 *yu = yo + mPadLength/2;
00351 *yl = *yu - mPadLength;
00352 *xu = xo + mPadWidth/2;
00353 *xl = *xu - mPadWidth;
00354 }
00355
00356
void StRichPadMonitor::drawPad(
const StRichSingleMCPixel& mcPad)
00357 {
00358
00359
00360
double xl,xu,yl,yu;
00361 this->calculatePadPosition(&mcPad,&xl,&yl,&xu,&yu);
00362 StRichDrawableMCTPad* dtp =
new StRichDrawableMCTPad(xl,yl,xu,yu,&mcPad);
00363 dtp->SetFillColor(GetColorAttribute(mcPad.charge()));
00364 dtp->SetLineColor(2);
00365 dtp->Draw();
00366 mAllFilledPads.Add(dtp);
00367 }
00368
00369
void StRichPadMonitor::drawPad(
const StRichSinglePixel& pad)
00370 {
00371
00372
00373
double xl,xu,yl,yu;
00374 calculatePadPosition(&pad,&xl,&yl,&xu,&yu);
00375 StRichDrawableTPad* dtp =
new StRichDrawableTPad(xl,yl,xu,yu,&pad);
00376 dtp->SetFillColor(GetColorAttribute(pad.charge()));
00377 dtp->SetLineColor(2);
00378 dtp->Draw();
00379 mAllFilledPads.Add(dtp);
00380 }
00381
00382
void StRichPadMonitor::drawG2T(
const StRichG2TInfo& g2t)
00383 {
00384
00385
00386 StRichDrawableTG2T* ttx =
new StRichDrawableTG2T(g2t);
00387 ttx->SetTextSize(.03);
00388 ttx->SetTextColor(1);
00389 ttx->Draw();
00390 mG2TSegments.Add(ttx);
00391 }
00392
00393
void StRichPadMonitor::drawGeantGroup(
int trackp,
int color)
00394 {
00395
00396
00397
for(
int ii=0; ii<mG2TSegments.GetLast()+1; ii++) {
00398
if(dynamic_cast<StRichDrawableTG2T*>(mG2TSegments.At(ii))->mTrackp == trackp) {
00399
int currentColor =
00400 dynamic_cast<StRichDrawableTG2T*>(mG2TSegments.At(ii))->GetTextColor();
00401
switch(currentColor) {
00402
case 1:
00403 currentColor = 2;
00404
break;
00405
case 2:
00406 currentColor = 1;
00407
break;
00408
default:
00409 currentColor = 1;
00410
break;
00411 }
00412 dynamic_cast<StRichDrawableTG2T*>(mG2TSegments.At(ii))->SetTextColor(currentColor);
00413 dynamic_cast<StRichDrawableTG2T*>(mG2TSegments.At(ii))->Paint();
00414 }
00415 }
00416 this->update();
00417 }
00418
00419
void StRichPadMonitor::drawHit(StRichSimpleHit* hit)
00420 {
00421
#ifndef SUN
00422
00423
00424
00425 StRichDrawableTHit* thit =
new StRichDrawableTHit(*hit);
00426 thit->SetMarkerSize(1.5);
00427 thit->SetMarkerColor(1);
00428 thit->Draw();
00429 mHits.Add(thit);
00430
#endif
00431
}
00432
00433
void StRichPadMonitor::doResiduals(
double zVertex,
long numPrim[],
int runId,
int eventId){
00434
00435
float tempArray[16] = {-999};
00436
float primaryArray[26] = {0};
00437
00438 TFile *residFile =
new TFile(
"resid.root",
"NEW");
00439 TNtuple *residNtuple = 0;
00440 TNtuple * primaryNtuple = 0;
00441
unsigned int appending = 0;
00442
00443
if( !residFile->IsOpen() ) {
00444
00445
delete residFile;
00446 residFile =
new TFile(
"resid.root",
"UPDATE");
00447 residNtuple = (TNtuple*)residFile->Get(
"residNtuple");
00448 primaryNtuple = (TNtuple*)residFile->Get(
"primaryNtuple");
00449 appending = 1;
00450 }
00451
else{
00452 residNtuple =
00453
new TNtuple(
"residNtuple",
00454
"Residual Info",
00455
"run:evt:hitX:hitY:hitCharge:mipX:mipY:mipPx:mipPy:mipPz:zVert:assocToClosestMip:particleTypes:eta:nTpcHits:nTpcFitHits");
00456 primaryNtuple =
new TNtuple(
"primaryNtuple",
"Track Info",
"run:evt:numPrim1:numPrim2:numPrim3:numPrim4:numPrim5:numPrim6:numPrim7:numPrim8:numPrim9:numPrim10:zVert:nTracks1:nTracks2:nTracks3:nTracks4:nTracks5:nTracks6:nTracks7:nTracks8:nTracks9:nTracks10:nTracks11:numHitsInRich:numPadsInRich");
00457 }
00458
00459 primaryArray[0] = runId;
00460 primaryArray[1] = eventId;
00461 primaryArray[2] = numPrim[0];
00462 primaryArray[3] = numPrim[1];
00463 primaryArray[4] = numPrim[2];
00464 primaryArray[5] = numPrim[3];
00465 primaryArray[6] = numPrim[4];
00466 primaryArray[7] = numPrim[5];
00467 primaryArray[8] = numPrim[6];
00468 primaryArray[9] = numPrim[7];
00469 primaryArray[10] = numPrim[8];
00470 primaryArray[11] = numPrim[9];
00471 primaryArray[12] = zVertex;
00472
00473
00474
for(
unsigned int zz=0; zz<mVectorTracks.size(); zz++) {
00475
00476 StRichTrack * currentRichTrack = mVectorTracks[zz]->getTrack();
00477
double momentum = currentRichTrack->getMomentum().mag();
00478
00479
if(momentum > 5)
00480 momentum = 5;
00481
00482 primaryArray[static_cast<unsigned int>(floor(13+2*momentum))]++;
00483
00484 }
00485
00486
00487 primaryArray[24] = mHits.GetEntries();
00488 primaryArray[25] = mAllFilledPads.GetEntries();
00489
00490 primaryNtuple->Fill(primaryArray);
00491 cout <<
"Fill primaryArray";
00492
float curHitX = 0;
00493
float curHitY = 0;
00494
float curMipX = 0;
00495
float curMipY = 0;
00496
00497
for(
int ii=0; ii< static_cast<int>(primaryArray[24]); ii++) {
00498
00499 StRichDrawableTHit * currentHit = static_cast<StRichDrawableTHit*>(mHits[ii]);
00500 StRichDrawableTMip * closestMIP = 0;
00501 StRichDrawableTMip * currentMIP = 0;
00502
00503
double closestResid = 9999;
00504
double currentResid = 9999;
00505
00506
for(
unsigned int jj=0;jj<mVectorTracks.size();jj++){
00507
00508 currentMIP = mVectorTracks[jj]->getProjectedMIP();
00509 curHitX = currentHit->GetX();
00510 curHitY = currentHit->GetY();
00511 curMipX = currentMIP->GetX();
00512 curMipY = currentMIP->GetY();
00513
00514 currentResid = ::sqrt( (curHitX-curMipX)*(curHitX-curMipX)+
00515 (curHitY-curMipY)*(curHitY-curMipY));
00516
00517
if(currentResid < closestResid){
00518 closestResid = currentResid;
00519 closestMIP = currentMIP;
00520 }
00521
00522 }
00523
00524 tempArray[0] = runId;
00525 tempArray[1] = eventId;
00526 tempArray[2] = curHitX;
00527 tempArray[3] = curHitY;
00528 tempArray[4] = currentHit->getCharge();
00529
00530
if(closestMIP != 0){
00531
00532 tempArray[5] = closestMIP->GetX();
00533 tempArray[6] = closestMIP->GetY();
00534
00535 StRichDrawableTTrack * curTTrack = closestMIP->getDrawableTTrack();
00536 StRichTrack * curRichTrack = curTTrack->getTrack();
00537
00538 StThreeVectorF tempMom = curRichTrack->getMomentumAtPadPlane();
00539 tempArray[7] = tempMom.x();
00540 tempArray[8] = tempMom.y();
00541 tempArray[9] = tempMom.z();
00542 tempArray[10] = zVertex;
00543 tempArray[14] = curRichTrack->getStTrack()->detectorInfo()->numberOfPoints(kTpcId);
00544 tempArray[15] = curRichTrack->getStTrack()->fitTraits().numberOfFitPoints(kTpcId);
00545
00546 tempArray[11] = 0;
00547
unsigned int array12 = 0;
00548
00549
for(
int ringCounter = 0 ; ringCounter < curTTrack->numberOfRings();ringCounter++){
00550
00551 StRichDrawableTRings* currentRing = curTTrack->getRing(ringCounter);
00552
if(currentRing){
00553
for(
int hitCounter = 0;hitCounter < currentRing->numberOfHits();hitCounter++){
00554 StRichDrawableTHit * loopHit = currentRing->getHit(hitCounter);
00555
if((fabs(loopHit->GetX() - curHitX) < .0001) &&
00556 (fabs(loopHit->GetY() - curHitY) < .0001)){
00557 tempArray[11] = 1;
00558 StParticleDefinition * currPart = currentRing->getParticle();
00559
if(currPart == pionplus || currPart == pionminus)
00560 array12 |= 1;
00561
else if(currPart == kaonplus || currPart == kaonminus)
00562 array12 |= 2;
00563
else if(currPart == proton || currPart == antiproton)
00564 array12 |= 4;
00565 }
00566 }
00567 }
00568 }
00569
00570 tempArray[12] = static_cast<float>(array12);
00571 tempArray[13] = static_cast<float>(curRichTrack->getStTrack()->geometry()->momentum().pseudoRapidity());
00572 }
00573 residNtuple->Fill(tempArray);
00574 }
00575
00576
if(appending) {
00577 residNtuple->Write(
"residNtuple",TObject::kOverwrite);
00578 primaryNtuple->Write(
"primaryNtuple",TObject::kOverwrite); }
00579
else{
00580 residNtuple->Write();
00581 primaryNtuple->Write();}
00582
00583 residFile->Close();
00584
delete residFile;
00585 }
00586
00587
void StRichPadMonitor::addPad(StRichSinglePixel* pad)
00588 {
00589
double xl,xu,yl,yu;
00590 this->calculatePadPosition(pad,&xl,&yl,&xu,&yu);
00591
00592 StRichDrawableTPad* dtp =
new StRichDrawableTPad(xl,yl,xu,yu, pad);
00593
00594 dtp->SetLineWidth(1);
00595 dtp->SetLineColor(2);
00596 dtp->SetFillColor(GetColorAttribute(pad->charge()));
00597 mAllFilledPads.Add(dtp);
00598 }
00599
00600
void StRichPadMonitor::update()
00601 {
00602 mRichCanvas->Update();
00603 }
00604
00605 Color_t StRichPadMonitor::GetColorAttribute(
double amp)
00606 {
00607
00608
00609
double tmpAmp;
00610
00611
00612
00613
00614 tmpAmp = (amp>256) ? 256 : amp;
00615 Color_t ret = (50+(static_cast<int>((tmpAmp/256.)*50)) );
00616
if(ret <= 50)
00617 ret +=1;
00618
00619
if(amp==1024)
00620 ret = 1;
00621
return ret;
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633 }
00634
00635
void StRichPadMonitor::addTrack(StRichTrack* track) {
00636
00637 mVectorTracks.push_back(
new StRichDrawableTTrack(track));
00638
00639
00640
00641
00642
00643
00644 mVectorTracks.back()->getProjectedMIP()->draw();
00645 }
00646
00647
void StRichPadMonitor::drawRingInfo() {
00648
00649 cout <<
"StRichPadMonitor::drawRingInfo() " << endl;
00650
00651
00652
int currentGoodTrack = 0;
00653
00654
float lowerY = 30;
00655
float upperY = 50;
00656
float ystep = 22;
00657
00658
float lowerX = 80.;
00659
float upperX = 95;
00660
float xstep = 20.;
00661
00662
float iy1,iy2,ix1,ix2;
00663
00664
00665
for(size_t itrack=0; itrack<mVectorTracks.size(); itrack++) {
00666 StRichTrack* tt = mVectorTracks[itrack]->getTrack();
00667
00668
if(tt->getMomentum().mag() < .3)
continue;
00669
00670
if(currentGoodTrack<4) {
00671 ix1 = lowerX;
00672 ix2 = upperX;
00673 iy1 = lowerY-(ystep*currentGoodTrack);
00674 iy2 = upperY-(ystep*currentGoodTrack);
00675 }
00676
else {
00677 ix1 = lowerX+xstep;
00678 ix2 = upperX+xstep;
00679 iy1 = lowerY-(ystep*(currentGoodTrack-4));
00680 iy2 = upperY-(ystep*(currentGoodTrack-4));
00681 }
00682
00683
00684
00685 TPaveText* particledata =
new TPaveText(ix1, iy1, ix2, iy2);
00686
00687
char title[50];
00688
00689
00690
00691 sprintf(title,
"%.3f %.3f", tt->getMomentum().mag(), tt->getTheta()*180./M_PI);
00692 particledata->AddText(title);
00693
int total[3] = {0,0,0};
00694
int inarea[3] = {0,0,0};
00695
int sig1[3] = {0,0,0};
00696
int sig2[3] = {0,0,0};
00697
float area[3] = {0.,0.,0.};
00698
float tarea[3] = {0.,0.,0.};
00699
00700
00701
00702
StRichPidTraits* theTraits = tt->getPidTrait();
00703
if(!theTraits) {cout <<
"drawringinfo error:::thetraits" << endl;}
00704
00705
const StSPtrVecRichPid& thePids = theTraits->
getAllPids();
00706
00707
00708
if(thePids.size() == 0)
continue;
00709
00710
for(size_t ii=0; ii<thePids.size(); ii++) {
00711
StRichPid* pid = thePids[ii];
00712
00713
if(!pid) {cout <<
"not okay " << ii << endl;
continue;}
00714
00715 area[ii] = pid->
getTotalArea();
00716 tarea[ii] = pid->
getTruncatedArea();
00717
00718
const StPtrVecRichHit& theHits = pid->
getAssociatedRichHits();
00719
00720
00721
for(size_t jj=0; jj<theHits.size(); jj++) {
00722
00723
switch(pid->
getParticleNumber()) {
00724
case -211:
00725
if(theHits[jj])
00726 total[0]++;
00727
if(theHits[jj]->isSet(eInAreaPi))
00728 inarea[0]++;
00729
if(theHits[jj]->isSet(e1SigmaPi))
00730 sig1[0]++;
00731
if(theHits[jj]->isSet(e2SigmaPi))
00732 sig2[0]++;
00733
break;
00734
case -321:
00735
if(theHits[jj])
00736 total[1]++;
00737
if(theHits[jj]->isSet(eInAreaK))
00738 inarea[1]++;
00739
if(theHits[jj]->isSet(e1SigmaK))
00740 sig1[1]++;
00741
if(theHits[jj]->isSet(e2SigmaK))
00742 sig2[1]++;
00743
break;
00744
case -2212:
00745
if(theHits[jj])
00746 total[2]++;
00747
if(theHits[jj]->isSet(eInAreap))
00748 inarea[2]++;
00749
if(theHits[jj]->isSet(e1Sigmap))
00750 sig1[2]++;
00751
if(theHits[jj]->isSet(e2Sigmap))
00752 sig2[2]++;
00753
break;
00754
default:
00755 cout <<
"StRichPadMonitor::drawRingInfo()";
00756 cout <<
"\tERROR unknown particle " << pid->
getParticleNumber() << endl;
00757
break;
00758 }
00759 }
00760 }
00761
00762
char totalc[30];
00763 sprintf(totalc,
"all %d %d %d",total[0],total[1],total[2]);
00764 particledata->AddText(totalc);
00765
00766
char pareac[30];
00767 sprintf(pareac,
"pa %d %d %d",inarea[0],inarea[1],inarea[2]);
00768 particledata->AddText(pareac);
00769
00770
char sig1c[30];
00771 sprintf(sig1c,
"1s %d %d %d",sig1[0],sig1[1],sig1[2]);
00772 particledata->AddText(sig1c);
00773
00774
char sig2c[30];
00775 sprintf(sig2c,
"2s %d %d %d",sig2[0],sig2[1],sig2[2]);
00776 particledata->AddText(sig2c);
00777
00778
char areac[30];
00779 sprintf(areac,
"A %.0f %.0f %.0f",area[0],area[1],area[2]);
00780 particledata->AddText(areac);
00781
00782
char tareac[30];
00783 sprintf(tareac,
"TA %.0f %.0f %.0f",tarea[0],tarea[1],tarea[2]);
00784 particledata->AddText(tareac);
00785
00786 particledata->SetTextSize(.02);
00787 particledata->Draw();
00788
00789 mRingInfo.Add(particledata);
00790 currentGoodTrack++;
00791 }
00792 }
00793
00794
void StRichPadMonitor::drawMarker(StThreeVectorF& from,
int type,
float size,
int color)
00795 {
00796
00797
00798 TMarker* marker =
new TMarker(from.x(),from.y(),type);
00799 marker->SetMarkerSize(size);
00800 marker->SetMarkerColor(color);
00801 marker->Draw();
00802
00803 mMisc.Add(marker);
00804 }
00805
00806
void StRichPadMonitor::drawLine(StThreeVectorF& from, StThreeVectorF& to)
00807 {
00808
00809
00810 TLine* line =
new TLine(from.x(),from.y(),to.x(),to.y());
00811 line->Draw();
00812
00813 mMisc.Add(line);
00814 }
00815
00816
void StRichPadMonitor::drawText(
double x,
double y,
char* txt)
00817 {
00818
00819
00820 TText* text =
new TText(x,y,txt);
00821 text->SetTextSize(.030);
00822 text->Draw();
00823
00824 mText.Add(text);
00825 }
00826
00827 StRichDrawableTTrack* StRichPadMonitor::getTrack(StRichTrack* track) {
00828
00829
for(
unsigned int i = 0; i < mVectorTracks.size() ; i++) {
00830
if(mVectorTracks[i]->getTrack() == track)
00831
return mVectorTracks[i];
00832 }
00833
00834
return 0;
00835 }
00836
00837
void StRichPadMonitor::drawQuickRing(vector<StThreeVectorF>& ipi, vector<StThreeVectorF>& opi,
00838 vector<StThreeVectorF>& ik, vector<StThreeVectorF>& ok,
00839 vector<StThreeVectorF>& ip, vector<StThreeVectorF>& op)
00840 {
00841
unsigned int ii;
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
enum {ssipi = 1000,ssopi = 1000};
00854 Float_t ixpi[ssipi];
00855 Float_t iypi[ssipi];
00856
for(ii=0; ii<ipi.size(); ii++) {
00857 ixpi[ii] = ipi[ii].x();
00858 iypi[ii] = ipi[ii].y();
00859 }
00860 TPolyLine* innerPi =
new TPolyLine(ipi.size(),ixpi,iypi);
00861 innerPi->SetLineStyle(1);
00862 innerPi->SetLineColor(2);
00863 innerPi->Draw();
00864 mQuickRings.Add(innerPi);
00865
00866 Float_t oxpi[ssopi];
00867 Float_t oypi[ssopi];
00868
for(ii=0; ii<opi.size(); ii++) {
00869 oxpi[ii] = opi[ii].x();
00870 oypi[ii] = opi[ii].y();
00871 }
00872 TPolyLine* outerPi =
new TPolyLine(opi.size(),oxpi,oypi);
00873 outerPi->SetLineStyle(1);
00874 outerPi->SetLineColor(2);
00875 outerPi->Draw();
00876 mQuickRings.Add(outerPi);
00877
00878
00879
00880
00881
00882
00883
00884
00885
const unsigned int ssik = 1000;
00886
const unsigned int ssok = 1000;
00887
00888
00889 Float_t ixk[ssik];
00890 Float_t iyk[ssik];
00891
for(ii=0; ii<ik.size(); ii++) {
00892 ixk[ii] = ik[ii].x();
00893 iyk[ii] = ik[ii].y();
00894 }
00895 TPolyLine* innerK =
new TPolyLine(ik.size(),ixk,iyk);
00896 innerK->SetLineStyle(1);
00897 innerK->SetLineColor(1);
00898 innerK->Draw();
00899 mQuickRings.Add(innerK);
00900
00901 Float_t oxk[ssok];
00902 Float_t oyk[ssok];
00903
for(ii=0; ii<ok.size(); ii++) {
00904 oxk[ii] = ok[ii].x();
00905 oyk[ii] = ok[ii].y();
00906 }
00907 TPolyLine* outerK =
new TPolyLine(ok.size(),oxk,oyk);
00908 outerK->SetLineStyle(1);
00909 outerK->SetLineColor(1);
00910 outerK->Draw();
00911 mQuickRings.Add(outerK);
00912
00913
00914
00915
00916
00917
00918
00919
00920
static const unsigned int ssip = 1000;
00921
static const unsigned int ssop = 1000;
00922
00923
00924 Float_t ixp[ssip];
00925 Float_t iyp[ssip];
00926
for(ii=0; ii<ip.size(); ii++) {
00927 ixp[ii] = ip[ii].x();
00928 iyp[ii] = ip[ii].y();
00929 }
00930 TPolyLine* innerP =
new TPolyLine(ip.size(),ixp,iyp);
00931 innerP->SetLineStyle(1);
00932 innerP->SetLineColor(3);
00933 innerP->Draw();
00934 mQuickRings.Add(innerP);
00935
00936 Float_t oxp[ssop];
00937 Float_t oyp[ssop];
00938
for(ii=0; ii<op.size(); ii++) {
00939 oxp[ii] = op[ii].x();
00940 oyp[ii] = op[ii].y();
00941 }
00942 TPolyLine* outerP =
new TPolyLine(op.size(),oxp,oyp);
00943 outerP->SetLineStyle(1);
00944 outerP->SetLineColor(3);
00945 outerP->Draw();
00946 mQuickRings.Add(outerP);
00947 }
00948
00949
void StRichPadMonitor::drawRings() {
00950
00951 cout <<
"StRichPadMonitor::drawRings()" << endl;
00952
00953
00954
00955
for(
unsigned int j=0; j<mVectorTracks.size(); j++) {
00956
for(
int i=0; i<mVectorTracks[j]->numberOfRings(); i++) {
00957
00958
00959
if( mVectorTracks[j]->getTrack()->getMomentum().mag() < 0.3 )
continue;
00960
00961
00962
00963
00964
00965
00966
00967 mVectorTracks[j]->getRing(i)->draw();
00968
00969 }
00970
00971
00972
00973
00974
00975
for (size_t particleIndex=0;
00976 particleIndex<mListOfParticles.size();
00977 particleIndex++) {
00978 StParticleDefinition* particle = mListOfParticles[particleIndex];
00979
00980
if (!particle)
continue;
00981 StRichDrawableTRings* currentTRing = mVectorTracks[j]->getRing(particle);
00982
00983
if (!currentTRing)
continue;
00984
00985 vector<StRichRingHit*> hits = mVectorTracks[j]->getTrack()->getRingHits(particle);
00986
00987
00988
00989
00990
for (size_t hitIndex=0; hitIndex<hits.size(); hitIndex++) {
00991
00992
if( hits[hitIndex] && hits[hitIndex]->getHit()) {
00993 currentTRing->addHit(hits[hitIndex]->getHit());
00994 }
00995 }
00996
00997 }
00998 }
00999 }
01000
01001
void StRichPadMonitor::hiLiteHits() {
01002
01003 cout <<
"StRichPadMonitor::hiLiteHits()" << endl;
01004
01005
01006
01007
01008
for(size_t ii=0; ii<mVectorTracks.size(); ii++) {
01009
01010
for (size_t particleIndex=0;
01011 particleIndex<mListOfParticles.size();
01012 particleIndex++) {
01013 StParticleDefinition* particle = mListOfParticles[particleIndex];
01014
01015
if (!particle)
continue;
01016 StRichDrawableTRings* currentTRing = mVectorTracks[ii]->getRing(particle);
01017
01018
if (!currentTRing)
continue;
01019 currentTRing->hilite();
01020
01021 }
01022 }
01023
01024 }
01025
01026
void StRichPadMonitor::hiLiteHits(
const StRichHitFlag& flag, StParticleDefinition* particle) {
01027
01028 cout <<
"StRichPadMonitor::hiLiteHits(flag)" << endl;
01029
if (!particle) {
01030 cout <<
"StRichPadMonitor::hiLiteHits()\n";
01031 cout <<
"\tparticleType pointer lost" << endl;
01032
return;
01033 }
01034
01035
01036
01037
01038
for(size_t ii=0; ii<mVectorTracks.size(); ii++) {
01039
01040 StRichDrawableTRings* currentTRing = mVectorTracks[ii]->getRing(particle);
01041
01042
if (!currentTRing)
continue;
01043 currentTRing->hilite(flag);
01044
01045 }
01046 }
01047
01048
void StRichPadMonitor::drawZVertex(
double zVert,
int numTracksPrim,
int numTracksSec) {
01049
01050
if(mZVertex)
delete mZVertex;
01051
if(mNumTracks)
delete mNumTracks;
01052
01053
char tempChar[200];
01054
01055
if(zVert < -67 || zVert > 67){
01056 sprintf(tempChar,
"%d Vertex Not Above RICH: at %f",numTracksPrim,zVert);
01057 mNumTracks =
new TText(2,0,tempChar);
01058 mZVertex =
new TMarker(0,0,29);
01059 }
01060
else {
01061 mZVertex =
new TMarker(zVert,0,29);
01062 sprintf(tempChar,
"%d",numTracksPrim);
01063 mNumTracks =
new TText(zVert+2,0,tempChar);
01064 }
01065
01066
01067 mNumTracks->SetTextColor(51);
01068 mNumTracks->SetTextSize(.023);
01069 mNumTracks->SetTextAlign(12);
01070 mNumTracks->Draw();
01071
01072 mZVertex->SetMarkerColor(51);
01073 mZVertex->SetMarkerSize(2.9);
01074 mZVertex->Draw();
01075 }
01076
01077
void StRichPadMonitor::drawLegend() {
01078
01079
01080
01081
01082
01083
01084 mLegendPi =
new TText(-60.0,-47.0,
"p");
01085 mLegendPi->SetTextColor(2);
01086 mLegendPi->SetTextFont(122);
01087 mLegendPi->Draw();
01088
01089 mLegendK =
new TText(-55.0,-47.0,
"K");
01090 mLegendK->SetTextColor(1);
01091 mLegendK->SetTextFont(122);
01092 mLegendK->Draw();
01093
01094 mLegendP =
new TText(-50.0,-47.0,
"p");
01095 mLegendP->SetTextColor(3);
01096 mLegendP->SetTextFont(1);
01097 mLegendP->Draw();
01098
01099 }
01100
01101
void StRichPadMonitor::drawEventInfo(Long_t runId,Long_t eventId) {
01102
01103
01104
if(mFileEventNum)
delete mFileEventNum;
01105
01106
if (sprintf(mFileTextEventNum,
"Run: %u \t Event: %u",
01107 static_cast<int>(runId),static_cast<int>(eventId))) {
01108
01109 mFileEventNum =
new TText(65.2,-46.5,mFileTextEventNum);
01110 mFileEventNum->SetTextColor(1);
01111 mFileEventNum->SetTextFont(1);
01112 mFileEventNum->SetTextSize(.05);
01113 mFileEventNum->SetTextAlign(31);
01114 mFileEventNum->Draw();
01115 }
01116
01117 }
01118
01119
void StRichPadMonitor::drawFileName(
char * fileName) {
01120
01121
if(mFileName)
delete mFileName;
01122
01123 mFileName =
new TText(65.2,-48.7,fileName);
01124 mFileName->SetTextColor(1);
01125 mFileName->SetTextFont(1);
01126 mFileName->SetTextSize(.019495);
01127 mFileName->SetTextAlign(31);
01128 mFileName->Draw();
01129 }
01130
01131
01132
void StRichPadMonitor::printCanvas(
char* directory,
char * filename,
int eventNum){
01133
01134
char tempChar[300];
01135
char* newFile =
new char[100];
01136
int i = 0;
01137
while(filename[i] !=
'\0')
01138 i++;
01139
while( (i != 0) && (filename[i] !=
'/'))
01140 i--;
01141
if(filename[i] ==
'/')
01142 i++;
01143
01144
int j=0;
01145
int ii=i;
01146
while(j != 99) {
01147
if (filename[ii]==
'r')
break;
01148 newFile[j] = filename[ii++];
01149 j++;
01150 }
01151 newFile[j]=
'\0';
01152
01153 sprintf(tempChar,
"%s_%s%d.ps",directory,newFile,eventNum);
01154 mRichCanvas->Print(tempChar);
01155
delete newFile;
01156 }
01157
01158
#endif