Mdc2DWire.cxx

Go to the documentation of this file.

#include <TString.h>
#include <TColor.h>
#include <iostream>
#include "math.h"
#include "TMath.h"
#include "BesVisLib/Mdc2DWire.h"
#include "BesVisLib/BesView.h"
#include "BesVisLib/BesCursor.h"
 
using namespace std;
 
#ifndef __CINT__
ClassImp(Mdc2DWire)
#endif
 
//_____________________________________________________
 
Mdc2DWire::Mdc2DWire() {
 
}
 
//_____________________________________________________
 
Mdc2DWire::Mdc2DWire(const char* name,
                     const char* title,
                     Double_t rmin,
                     Double_t rmax,
                     Double_t dz,
                     Double_t phi,
                     Double_t *center )
{
 
    SetName(name);
    SetTitle(title);
    fTip = 0;
    fHighlighted = false;
    fFired = false;
    fColorfulWire = false;
    fWireType  = 1; // axial wire
    evTime = 0;
 
    Double_t r = 0.25*(rmax-rmin);
    fWireCircle = new BesCircle2D(name, title, 0.0, r, &center[0]);
 
    Double_t dx = fabs(r*cos(phi));
    Double_t dy = fabs(r*sin(phi));
    Double_t P[12] = { center[0] - dx, center[1] - dy, center[2] - dz,
                       center[0] + dx, center[1] + dy, center[2] - dz,
                       center[0] - dx, center[1] - dy, center[2] + dz,
                       center[0] + dx, center[1] + dy, center[2] + dz
                     };
 
    fWireCone = new BesPolygon2D(name, title, 4, P);
 
    Init();
}
 
//_____________________________________________________
 
Mdc2DWire::Mdc2DWire(const char* name, const char* title, Int_t N, Double_t *P)
{
    SetName(name);
    SetTitle(title);
    fTip = 0;
    fHighlighted = false;
    fFired = false;
    fColorfulWire = false;
    fWireType  = 2;  // stereo wire
 
    Double_t *tubeP = &P[3*N/2]; // east four points, P4~P7
    fTube = new BesPolygon2D(name, title, N/2, tubeP);
    fWireCircle = 0;
    fWireCone   = 0;
 
    for (Int_t i = 0; i < 3; i++) {
        fWestHole[i] = (P[i]    + P[3+i]  + P[6+i]  + P[9+i] )/4.0;  // (P0+P1+P2+P3)/4
        fEastHole[i] = (P[12+i] + P[15+i] + P[18+i] + P[21+i])/4.0;  // (P4+P5+P6+P7)/4
    }
    TVector3 westVec(fWestHole[0], fWestHole[1], fWestHole[2]);
    TVector3 eastVec(fEastHole[0], fEastHole[1], fEastHole[2]);
    fWestPhi = westVec.Phi() * TMath::RadToDeg();
    fEastPhi = eastVec.Phi() * TMath::RadToDeg();
    if (fWestPhi < 0.0) fWestPhi += 360.0;
    if (fEastPhi < 0.0) fEastPhi += 360.0;
 
    // ------XY------
    Double_t rMax = sqrt( (P[4*3]  -P[7*3])   * (P[4*3]-P[7*3])     +
                          (P[4*3+1]-P[7*3+1]) * (P[4*3+1]-P[7*3+1]) +
                          (P[4*3+2]-P[7*3+2]) * (P[4*3+2]-P[7*3+2]) ) / 2.0;
 
    Double_t rMinRatio = 0.0001; // min bubble radius = rMinRatio * rMax;
    Double_t rMaxRatio = 0.8;//0.6; // 0.4//yzhang
 
    Double_t newP[12];
    Double_t edge = rMaxRatio*0.0001; //*0.85
    for (Int_t i = 0; i < 3; i++) {
        newP[i]   = (0.5+edge*rMinRatio)*(P[i]+P[3+i])*0.5
                    + (0.5-edge*rMinRatio)*(P[6+i]+P[9+i])*0.5;   // near center of P0+P1
        newP[3+i] = (0.5-edge*rMinRatio)*(P[i]+P[3+i])*0.5
                    + (0.5+edge*rMinRatio)*(P[6+i]+P[9+i])*0.5;   // near center of P2+P3
        newP[6+i] = (0.5+edge*rMaxRatio)*(P[12+i]+P[15+i])*0.5
                    + (0.5-edge*rMaxRatio)*(P[18+i]+P[21+i])*0.5; // near center of P4+P5
        newP[9+i] = (0.5-edge*rMaxRatio)*(P[12+i]+P[15+i])*0.5
                    + (0.5+edge*rMaxRatio)*(P[18+i]+P[21+i])*0.5; // near center of P6+P7
    }
    fWireCone = new BesPolygon2D("WireCone", "WireCone", 4, &newP[0]);
 
    fWireCircle =
        new BesCircle2D("WireBubble", "WireBubble", 0.0, rMaxRatio*rMax, &fEastHole[0]);
 
    // ------ZR------
    fZRPosMarker2D =
        new BesMarker2D("MdcZRPos", "MdcZRPos", fEastHole[0], fEastHole[1], fEastHole[2]);
 
    Init();
}
 
//_____________________________________________________
 
Mdc2DWire::~Mdc2DWire() {
 
    if (fTube)          delete fTube;
    if (fWireCircle)    delete fWireCircle;
    if (fWireCone)      delete fWireCone;
    if (fZRPosMarker2D) delete fZRPosMarker2D;
 
    if (fTip) delete fTip;
}
 
//_____________________________________________________
 
void Mdc2DWire::Init() {
 
    SetStyle();
 
    fTip = new BesPaveText(0, 0, 0.1, 0.1);
    CloseInfo();
}
 
//_____________________________________________________
 
void Mdc2DWire::SetStyle()
{
    lcTube = kBlack; // grey;
    lwTube = 1;
    fcTube = kBlack; // grey 15;
    fsTube = 4000;
 
    lcWire = 15;
    if (fWireType == 1) lcWire = kGreen;
    if (fWireType == 2) lcWire = kBlue;
    lwCircle = 1;
    lwCone   = 1;
    fcCircle = kWhite;
    fcCone   = 0;
    fsCircle = 1001;
    fsCone   = 0;
 
    lcWireFired    = kRed;
    lwCircleFired  = 2;//yzhang 2;
    lwConeFired    = 2;
    fcCircleFired  = 1004; //kBlack;
    fcConeFired    = kBlack;
    fsCircleFired  = 1001;//solid
    fsConeFired    = 3001;
 
    lcWireHL   = kMagenta;//yzhang lcWire;
    lwCircleHL = 2;
    lwConeHL   = 2;
    fcCircleHL = kMagenta;//yzhang kBlack;
    fcConeHL   = kRed;
    fsCircleHL = 1001;
    fsConeHL   = 4000;
 
    sizeMarker   = 4;
    cMarker      = kBlue;
    cMarkerFired = kRed;    // color of fired marker
    cMarkerHL    = cMarker; // cMarkerFired;
    sMarker      = 24;
    sMarkerFired = 20;   // style of fired marker
    sMarkerHL    = 25;   // style of highlighted marker
}
 
void Mdc2DWire::ClearInfo()
{
    fInfoCon.clear();
    fTip->DeleteText();
}
 
void Mdc2DWire::CloseInfo()
{
    if (fTip) {
        fTip->Clear();
 
        if (fInfoCon.size() == 0) fInfoCon.push_back(GetTitle());
        fTip->SetText(fInfoCon);
    }
    else
        cout << "Mdc2DWire::CloseInfo, not initialized" << endl;
}
 
//_____________________________________________________
 
Int_t Mdc2DWire::DistancetoPrimitive(Int_t px, Int_t py) {
    BesView *view = (BesView*)gPad->GetView();
    if (view->GetViewType() & kXYView) {
        return fWireCircle->DistancetoPrimitive(px, py);
    }
    else if (view->GetViewType() & kZRView) {
        if (fZRPosMarker2D) {
            fZRPosMarker2D->DistancetoPrimitive(px, py);
            return fZRPosMarker2D->DistancetoPrimitive(px, py);
        }
    }
 
    return 999;
}
 
//_____________________________________________________
 
void Mdc2DWire::ExecuteEvent(Int_t event, Int_t px, Int_t py) {
 
    BesView *view = (BesView*)gPad->GetView();
 
    if (gBesCursor->GetType() == kBesHand) {
        if (view) view->ExecuteEvent(event, px, py);
    }
    else if (gBesCursor->GetType() == kBesPick){
 
        if (gPad) gPad->SetCursor(kPointer);
 
        Int_t    origColor = 1;
 
        switch (event) {
 
        case kMouseEnter :
 
            if ( fWireCircle )    origColor = fWireCircle->GetFillColor();
            if ( fZRPosMarker2D ) origColor = fZRPosMarker2D->GetMarkerColor();
            this->SetHighlighted(true);
 
            if (this->IsFired() || view->GetVisMdcWires()) {
                Draw("WIRE,SAME");
 
                fTip->SetPos(px, py);
                view->UpdateView(0);
 
                fTip->Draw("BR,SAME"); // "BR,ARC,SAME"
                gPad->Modified();
                gPad->Update();
            }
            break;
 
        case kMouseLeave:
 
            if (this->IsHighlighted()) {
                this->SetHighlighted(false);
                if (view->GetVisMdcWires()) Draw("WIRE,SAME");
 
                view->UpdateView(0);
                gPad->Modified();
                gPad->Update();
            }
            break;
        }
 
    }
}
 
//_____________________________________________________
 
void Mdc2DWire::Draw(Option_t *option) {
    //
    // Mdc2DWire draw function
    TString opt = option;
    opt.ToUpper();
 
    AppendPad(option);
}
 
//_____________________________________________________
 
void Mdc2DWire::Paint(Option_t *option) {
 
    TString opt = option;
    opt.ToUpper();
 
    BesView *view = (BesView*)gPad->GetView();
 
    //gStyle->SetPalette(1);
    if (view->GetViewType() & kXYView) {
 
        Double_t wcCenter[3], ncCenter[3];
        fWireCircle->GetCenter(&wcCenter[0]);
        view->WCtoNDC(wcCenter, &ncCenter[0]);
        Double_t x1, y1, x2, y2;
        Double_t d = 0.05;
        gPad->GetRange(x1, y1, x2, y2);
 
        // Only draw wire in pad range
        if (ncCenter[0] > x1-d && ncCenter[0] < x2+d &&
                ncCenter[1] > y1-d && ncCenter[1] < y2+d) {
            if (opt.Contains("TUBE") && fTube ) {
                fTube->SetLineColor(lcTube);
                fTube->SetLineWidth(lwTube);
                fTube->SetFillColor(fcTube);
                fTube->SetFillStyle(fsTube);
 
                fTube->Paint();
            }
 
            if (this->IsFired()) {
                if (fWireCircle) {
                    fWireCircle->SetLineColor(lcWireFired);
                    fWireCircle->SetLineWidth(lwCircleFired);
                    fWireCircle->SetFillColor(fcCircleFired);
                    fWireCircle->SetFillStyle(fsCircleFired);
                }
                if (fWireCone) {
                    fWireCone->SetLineColor(lcWireFired);
                    fWireCone->SetLineWidth(lwConeFired);
                    fWireCone->SetFillColor(fcConeFired);
                    fWireCone->SetFillStyle(fsConeFired);
                }
            }
            else {
                if (fWireCone) {
                    fWireCone->SetLineColor(lcWire);
                    fWireCone->SetLineWidth(lwCone);
                    fWireCone->SetFillColor(fcCone);
                    fWireCone->SetFillStyle(fsCone);
                }
                if (fWireCircle) {
                    fWireCircle->SetLineColor(lcWire);
                    fWireCircle->SetLineWidth(lwCircle);
                    fWireCircle->SetFillColor(fcCircle);
                    fWireCircle->SetFillStyle(fsCircle);
                }
            }
 
            if (this->IsHighlighted()) {
                if (fWireCircle) {
                    fWireCircle->SetLineColor(lcWireHL);
                    fWireCircle->SetLineWidth(lwCircleHL);
                    fWireCircle->SetFillColor(fcCircleHL);
                    fWireCircle->SetFillStyle(fsCircleHL);
                }
                if (fWireCone) {
                    fWireCone->SetLineColor(lcWireHL);
                    fWireCone->SetLineWidth(lwConeHL);
                    fWireCone->SetFillColor(fcConeHL);
                    fWireCone->SetFillStyle(fsConeHL);
                }
            }
            if (opt.Contains("WIRE")) {
                if (!fColorfulWire)   fWireCone->Paint();//yzhang remove stereo wire line
                if (fWireCircle) fWireCircle->Paint();
            }
        }
    }
 
    if (view->GetViewType() & kZRView) {
        if (HasZRSection()) {
            fZRPosMarker2D->SetWCX(fZRSectionPos[0]);
            fZRPosMarker2D->SetWCY(fZRSectionPos[1]);
            fZRPosMarker2D->SetWCZ(fZRSectionPos[2]);
            fZRPosMarker2D->SetMarkerColor(cMarker);
            fZRPosMarker2D->SetMarkerStyle(sMarker);
            fZRPosMarker2D->SetMarkerSizeMultiple(sizeMarker);
 
            if (this->IsFired()) {
                if (fZRPosMarker2D) {
                    fZRPosMarker2D->SetMarkerColor(cMarkerFired);
                    fZRPosMarker2D->SetMarkerStyle(sMarkerFired);
                }
            }
            else {
                if (fZRPosMarker2D) {
                    fZRPosMarker2D->SetMarkerColor(cMarker);
                    fZRPosMarker2D->SetMarkerStyle(sMarker);
                }
            }
 
            if (this->IsHighlighted()) {
                if (fZRPosMarker2D) {
                    fZRPosMarker2D->SetMarkerColor(cMarkerHL);
                    fZRPosMarker2D->SetMarkerStyle(sMarkerHL);
                }
            }
 
            if (opt.Contains("WIRE")) {
                if (fZRPosMarker2D) fZRPosMarker2D->Paint();
            }
        }
    }
}
 
//_____________________________________________________
 
char *Mdc2DWire::GetObjectInfo(Int_t px, Int_t py) const {
 
    BesView *view = (BesView*)gPad->GetView();
    if (view) return view->GetObjectInfo(px, py);
    else return TObject::GetObjectInfo(px, py);
}
 
//_____________________________________________________
 
bool Mdc2DWire::HasZRSection()
{
    if (fWireType != 2) return false;
 
    bool flag = false;
    BesView *view = (BesView*)gPad->GetView();
    Double_t viewPhi = view->GetLongitude();
    viewPhi = Range360(viewPhi);
    //if (GetName() == TString("Layer0Wire0")) cout << "view " << viewPhi << endl;
 
    Double_t zrPhi = viewPhi-90.0;
    zrPhi = Range360(zrPhi);
    //if (GetName() == TString("Layer0Wire0")) cout << zrPhi << endl;
 
    for (Int_t i = 0; i < 2; i++) {
        if (i==1) {
            zrPhi += 180.0;
            zrPhi = Range360(zrPhi);
        }
 
        if ( fabs(fEastPhi-fWestPhi) < 180.0 ) {  // no cross phi=0.0
            if ( (fEastPhi-zrPhi)*(fWestPhi-zrPhi) > 0.0 ) flag = false;
            else {
                Double_t factor = fabs( (fEastPhi-zrPhi)/(fEastPhi-fWestPhi) );
                for (Int_t i = 0; i < 3; i++) {
                    fZRSectionPos[i] =  factor*fWestHole[i] + (1.0-factor)*fEastHole[i];
                }
                flag = true;
                break;
            }
        }
        else { // cross phi=0.0
            if ( (fEastPhi-zrPhi)*(fWestPhi-zrPhi) < 0.0 ) flag = false;
            else { // range 0~360 -> -180~180
                Double_t tempEastPhi = fEastPhi;
                if (tempEastPhi >= 180.0) tempEastPhi -= 360.0;
                Double_t tempWestPhi = fWestPhi;
                if (tempWestPhi >= 180.0) tempWestPhi -= 360.0;
                Double_t tempZRPhi   = zrPhi;
                if (tempZRPhi   >= 180.0) tempZRPhi   -= 360.0;
 
                Double_t factor = fabs( (tempEastPhi-tempZRPhi)/(tempEastPhi-tempWestPhi) );
                for (Int_t i = 0; i < 3; i++) {
                    fZRSectionPos[i] =  factor*fWestHole[i] + (1.0-factor)*fEastHole[i];
                }
                flag = true;
                break;
            }
        }
    }
 
    return flag;
}
 
//_____________________________________________________
 
Double_t Mdc2DWire::Range360(Double_t input)
{
    if (input >= 360.0) {
        do {
            input -= 360.0;
        }
        while (input >= 360.0);
    }
    else if (input < 0.0) {
        do {
            input += 360.0;
        }
        while (input < 0.0);
    }
 
    return input;
}
 
//_____________________________________________________
 
void Mdc2DWire::SetTime(Double_t time)
{ 
    mdcTime = time;
}
 
//_____________________________________________________
 
void Mdc2DWire::SetCharge(Double_t charge)
{ 
    mdcCharge = charge;
}
 
//_____________________________________________________
 
void Mdc2DWire::SetQOverflow(Bool_t qOvfl)
{ 
    qOverflow = qOvfl;
}
 
//_____________________________________________________
 
void Mdc2DWire::SetEvTime(Double_t time)
{ 
    evTime = time;
}
 
//_____________________________________________________
 
void Mdc2DWire::SetColorfulWire(Bool_t colorfulWire, Bool_t subEvTime)
{ 
    fColorfulWire = colorfulWire;
    if(fColorfulWire){
    //yzhang change LINE COLOR of fired mdc wires 
    //n color bin = 50, time of max bin is 2000 
    //time max value = 1943.8125 ~ 2000 ns 
    //no time info color is kGray 
    //time > 2000 && time <=10000, color is kBlack
    int tempColor;
    if(subEvTime){ 
        // raw time - event start time
        double tempMdcTime = mdcTime - evTime; 
        if(fabs(evTime)>0.0001) tempMdcTime += 230;
        if(tempMdcTime>10000) { 
        tempColor = kGray;
        }else if(tempMdcTime>2000&&tempMdcTime<=10000){
        tempColor = kRed;
        }else if(tempMdcTime<-10){
        tempColor = kWhite;
        }else{
        tempColor = 51 + (int) (tempMdcTime/40);
        }
    }else{
        //raw time
        if(mdcTime>10000) { 
        tempColor= kGray;
        }else if(mdcTime>2000&&mdcTime<=10000){
        tempColor = kRed;
        }else{
        tempColor = 51 + (int) (mdcTime/40);
        }
    }
    lcWireFired = tempColor;
    //std::cout<< " mdcTime  "<<mdcTime <<" evTime "<< evTime << " t-t0 "<< mdcTime - evTime +230<< " lcWireFired " << lcWireFired <<std::endl;
 
    //yzhang change FILL COLOR of fired mdc wires
    //n color bin = 50,  charge of max bin is 2000
    //charge max value = 29783 ~ 30000
    //adc> 2000&&<=30000 color is kBlack
    //no adc color is kGray
    if(mdcCharge>30000){
        tempColor = kGray;
    }else if(mdcCharge>2000&&mdcCharge<=30000){
        tempColor = kRed;
    }else {
        tempColor = 51 + (int) (mdcCharge/40);
    }
    if(qOverflow) { tempColor = kBlack; }
    fcCircleFired  = tempColor;
    //std::cout<< " mdcCharge "<<mdcCharge<<" ovfl "<<qOverflow<<" fcCircleFired " << fcCircleFired<< std::endl;
    }else{
    lcWireFired = kRed;
    fcCircleFired  = 1004;
    } 
}