/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/EventDisplay/BesVisLib/BesVisLib-00-04-04/src/BesGeometry.cxx

Go to the documentation of this file.

#include <iostream>
#include <TGeoManager.h>
#include <TGeoMaterial.h>
#include <TGeoMedium.h>
#include <TGeoVolume.h>
#include <TGeoTube.h>
#include <TGeoArb8.h>
#include <TGeoMatrix.h>
#include <TCanvas.h>

#include "BesVisLib/BesGeometry.h"
#include "BesVisLib/BesCircle2D.h"
#include "BesVisLib/BesPolygon2D.h"
#include "BesVisLib/Mdc2DWire.h"

BesGeometry *gBesGeometry = 0;

using namespace std;

#ifndef __CINT__
ClassImp(BesGeometry)
#endif

//_____________________________________________________________________________

BesGeometry::BesGeometry() : TObject(),
        m_Bes(0),
        m_BeamPipe(0),
        m_Mdc(0),
        m_Tof(0),
        m_Emc(0),
        m_Muc(0),
        m_MdcROOTGeo(0),
        m_TofROOTGeo(0),
        m_EmcROOTGeo(0),
        m_MucROOTGeo(0)
{
    // Create Bes geometry
    if (!gGeoManager) new TGeoManager("BesGeo", "BesGeometry");
    else gGeoManager-> ClearPhysicalNodes();

    m_BesR = 2840.0;
    m_BesZ = 5680.0;

    m_BeamPipeRMin = 31.5;
    m_BeamPipeRMax = 35.8;
    m_BeamPipeZ    = 150.0;
}


BesGeometry::~BesGeometry()
{
    delete m_Bes;
    delete m_BeamPipe;

    delete m_MdcROOTGeo;
    delete m_TofROOTGeo;
    delete m_EmcROOTGeo;
    delete m_MucROOTGeo;
}

void BesGeometry::InitFromGDML(const TString fPath)
{
    gGeoManager->SetVisOption(0);  // to show all visible volumes.
    gGeoManager->SetVisLevel(5);

    TGeoIdentity *identity = new TGeoIdentity();

    TGeoMaterial *mat = new TGeoMaterial("VOID",0,0,0);
    mat->SetTransparency(20);
    TGeoMedium   *med = new TGeoMedium("MED",1,mat);
    m_Bes = gGeoManager->MakeBox("volBes", med, m_BesR, m_BesR, 0.5*m_BesZ);

    TGeoVolume *topVolume = new TGeoVolume(); // temp top volume for load geometry more than once
    gGeoManager->SetTopVolume(topVolume);
    gGeoManager->SetTopVolume(m_Bes);

    Int_t iChildNo = 0;
    m_MdcROOTGeo = new MdcROOTGeo();
    m_MdcROOTGeo->InitFromGDML( (fPath + TString("Mdc.gdml")).Data(), "Mdc" );
    cout<<"in BesGeometry construct mdc1"<<endl;
    m_Mdc = m_MdcROOTGeo->GetVolumeMdc();
    if (m_Mdc)  cout << "Construct Mdc" << endl;
    else       cout << "Volume Mdc not found " << endl;
    m_Bes->AddNode(m_Mdc, iChildNo, identity);
    m_MdcROOTGeo->SetChildNo(iChildNo);//Connect bes with mdc, form physcialnode path.  m_Bes->GetNdaughters()-1

    iChildNo++;
    m_TofROOTGeo = new TofROOTGeo();
    m_TofROOTGeo->InitFromGDML( (fPath + TString("Tof.gdml")).Data(), "Tof" );
    cout<<"construct tof"<<endl;
    m_Tof = m_TofROOTGeo->GetVolumeTof();
    if (m_Tof)  cout << "Construct Tof" << endl;
    else       cout << "Volume Tof not found " << endl;
    m_Bes->AddNode(m_Tof, iChildNo, identity);
    m_TofROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    m_EmcROOTGeo = new EmcROOTGeo();
    m_EmcROOTGeo->InitFromGDML( (fPath + TString("Emc.gdml")).Data(), "Emc" );
    m_Emc = m_EmcROOTGeo->GetVolumeEmc();
    if (m_Emc)  cout << "Construct Emc" << endl;
    else       cout << "Volume Emc not found " << endl;
    m_Bes->AddNode(m_Emc, iChildNo, identity);
    m_EmcROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    m_MucROOTGeo = new MucROOTGeo();
    m_MucROOTGeo->InitFromGDML( (fPath + TString("Muc.gdml")).Data(), "Muc" );
    m_Muc = m_MucROOTGeo->GetVolumeMuc();
    if (m_Muc)  cout << "Construct Muc" << endl;
    else       cout << "Volume Muc not found " << endl;
    m_Bes->AddNode(m_Muc, iChildNo, identity);
    m_MucROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    Int_t beamPipeColor = 3;
    m_BeamPipe = gGeoManager->MakeTube("volBeamPipe", med, m_BeamPipeRMin, m_BeamPipeRMax, m_BeamPipeZ);
    m_BeamPipe->SetLineColor(beamPipeColor);
    m_Bes->AddNode(m_BeamPipe, iChildNo, identity);

    Int_t nDaughters = m_Bes->GetNodes()->GetEntries();
    cout << "volBes contains " << nDaughters  << " nodes : " << endl;
    for (Int_t i = 0; i < nDaughters; i++) {
        cout << i << " : " << m_Bes->GetNode(i)->GetName() << endl;
    }

    InitGeometry();
}

void BesGeometry::InitFromROOT(TGeoVolume *volBes)
{
    gGeoManager->SetVisOption(0);  // to show all visible volumes.
    gGeoManager->SetVisLevel(5);

    m_Bes = volBes;
    m_BesR = ((TGeoBBox*)m_Bes->GetShape())->GetDX();
    m_BesZ = ((TGeoBBox*)m_Bes->GetShape())->GetDZ()*2.0;

    TGeoVolume *topVolume = new TGeoVolume();
    gGeoManager->SetTopVolume(topVolume);
    gGeoManager->SetTopVolume(m_Bes);

    Int_t nDaughters = m_Bes->GetNodes()->GetEntries();

    //cout << "volBes contains " << nDaughters  << " nodes : " << endl;
    //for (Int_t i = 0; i < nDaughters; i++) {
    //    cout << i << " : " << m_Bes->GetNode(i)->GetName() << endl;
    //}

    Int_t iChildNo = 0;
    m_MdcROOTGeo = new MdcROOTGeo();
    TGeoNode *nodeMdc = m_Bes->GetNode(iChildNo);
    if (nodeMdc) m_Mdc = nodeMdc->GetVolume();
    //else cout << "Node logicalMdc not found" << endl;
    //if (m_Mdc)  cout << "Set Mdc" << endl;
    //else       cout << "Volume Mdc not found " << endl;
    m_MdcROOTGeo->InitFromROOT( m_Mdc );
    m_MdcROOTGeo->SetChildNo(iChildNo);//Connect bes with mdc, form physcialnode path.  m_Bes->GetNdaughters()-1

    iChildNo++;
    m_TofROOTGeo = new TofROOTGeo();
    TGeoNode *nodeTof = m_Bes->GetNode(iChildNo);
    if (nodeTof) m_Tof = nodeTof->GetVolume();
    //else cout << "Node logicalTof not found" << endl;
    //if (m_Tof)  cout << "Set Tof" << endl;
    //else       cout << "Volume Tof not found " << endl;
    m_TofROOTGeo->InitFromROOT( m_Tof );
    m_TofROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    m_EmcROOTGeo = new EmcROOTGeo();
    TGeoNode *nodeEmc = m_Bes->GetNode(iChildNo);
    if (nodeEmc) m_Emc = nodeEmc->GetVolume();
    //else cout << "Node logicalEmc not found" << endl;
    //if (m_Emc)  cout << "Set Emc" << endl;
    //else       cout << "Volume Emc not found " << endl;
    m_EmcROOTGeo->InitFromROOT( m_Emc );
    m_EmcROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    m_MucROOTGeo = new MucROOTGeo();
    TGeoNode *nodeMuc = m_Bes->GetNode(iChildNo);
    if (nodeMuc) m_Muc = nodeMuc->GetVolume();
    //else cout << "Node logicalMuc not found" << endl;
    //if (m_Muc)  cout << "Set Muc" << endl;
    //else       cout << "Volume Muc not found " << endl;
    m_MucROOTGeo->InitFromROOT( m_Muc );
    m_MucROOTGeo->SetChildNo(iChildNo);

    iChildNo++;
    TGeoNode *nodeBeamPipe = m_Bes->GetNode(iChildNo);
    if (nodeBeamPipe) {
        m_BeamPipe = nodeBeamPipe->GetVolume();
        m_BeamPipe->SetLineColor(4);
    }
    //else cout << "Node volBeamPipe not found " << endl;
    //cout << "Set beanmpi complete" << endl;
    InitGeometry();
    //cout << "init root ok" << endl;
}

void BesGeometry::InitGeometry()
{
    gGeoManager->SetDrawExtraPaths();  // draw physical node or not;
    gGeoManager->CloseGeometry();
    gGeoManager->SetNsegments(20);  // devide a circle to 20 slides

    // PhysicalNode necessary for fast setting node visible or not in an event
    // Should be set after gGeoManager closed
    m_MdcROOTGeo->SetPhysicalNode();    //here liang
    m_TofROOTGeo->SetPhysicalNode();    //here liang
    m_EmcROOTGeo->SetPhysicalNode();    //here liang
    m_MucROOTGeo->SetPhysicalNode();

    // 2D Geometry initialization should be after SetPhysicalNode();
    m_MdcROOTGeo->Init2DGeometry();    //here liang
    m_TofROOTGeo->Init2DGeometry();    //here liang
    m_EmcROOTGeo->Init2DGeometry();    //here liang
    m_MucROOTGeo->Init2DGeometry();

    Double_t  P[3*4] = {0.0};

    // BeamPipe
    Double_t beamPipeCenter[3] = {0.0, 0.0, 0.0};
    m_BeamPipeXY =
      new BesCircle2D("BeamPipe", "BeamPipe", m_BeamPipeRMin, m_BeamPipeRMax, &beamPipeCenter[0]);

    for (Int_t i = 0; i < 4; i++) {
        P[3*i]   = 0.0;
        if (i == 0 || i == 3) P[3*i+1] = -1.0*m_BeamPipeRMax;
        else P[3*i+1] = m_BeamPipeRMax;
        if (i == 0 || i == 1) P[3*i+2] = -1.0*m_BeamPipeZ;
        else P[3*i+2] = m_BeamPipeZ;
    }
    m_BeamPipeZR = new BesPolygon2D("BeamPipe", "BeamPipe", 4, &P[0]);

    // Auxiliary line
    if (!m_Bes) cout << "BesGeometry:InitGeometry, top volume m_Bes not found" << endl;
    TGeoBBox *besShape = (TGeoBBox*)m_Bes->GetShape();
    m_BesR = besShape->GetDX();
    m_BesZ = besShape->GetDZ()*2.0;
    for (Int_t i = 0; i < 4; i++) {
        P[3*i]   = 0.0;
        if (i == 0 || i == 3) P[3*i+1] = -1.0*m_BesR;
        else P[3*i+1] = m_BesR;
        if (i == 0 || i == 1) P[3*i+2] = -1.0*m_BesZ;
        else P[3*i+2] = m_BesZ;
    }

    m_ZRPlaneOnXY = new BesPolygon2D("ZRPlaneOnXY", "ZRPlaneOnXY", 4, &P[0]);
    m_ZRPlaneOnXY->SetRotatable(true);
    m_ZRPlaneOnXY->SetLineWidth(1);
    m_ZRPlaneOnXY->SetLineStyle(3);
    m_ZRPlaneOnXY->SetFillStyle(4000);
}

const char* BesGeometry::GetFilename(const char* RunPeriod)
{
    return RunPeriod;
}

void BesGeometry::SetDefaultVis()
{
    m_Bes->SetLineColor(2);
    m_Bes->SetVisibility(0);

    m_BeamPipe->SetLineColor(4);
    m_BeamPipe->SetVisibility(0);

    m_MdcROOTGeo->SetAllVisible();
    m_TofROOTGeo->SetAllVisible();
    m_EmcROOTGeo->SetAllVisible();
    m_MucROOTGeo->SetAllVisible();

}

void BesGeometry::Draw(Option_t *option)
{
    //
    // BesGeometry draw function
    TString opt = option;
    opt.ToUpper();

    if ( opt.Contains("3D") ) {
        Draw3D();
    }
    else if ( opt.Contains("XY") ) {
        Draw2DXY();
    }
    else if ( opt.Contains("ZR") ) {
        Draw2DZR();
    }
}

void BesGeometry::Draw3D()
{
    BesView *view = (BesView*)gPad->GetView();

    if (view && view->GetViewType() == k3DView) {

        if (m_MdcROOTGeo) {
            m_MdcROOTGeo->SetVisMdcDetector();
            m_MdcROOTGeo->SetVisMdcHits();
        }

        if (m_TofROOTGeo) {
            m_TofROOTGeo->SetVisTofDetector();
            m_TofROOTGeo->SetVisTofHits();
        }

        if (m_EmcROOTGeo) {
            m_EmcROOTGeo->SetVisEmcDetector();
            m_EmcROOTGeo->SetVisEmcHits();
        }

        if (m_MucROOTGeo) {
            m_MucROOTGeo->SetVisMucDetector();
            m_MucROOTGeo->SetVisMucHits();
        }
    }

    //if (gGeoManager) {
    //    cout << "gGeoManager exit" << endl;
    //}
    //else {
    //    cout << "gGeoManager do not exit" << endl;
    //}

    //if (m_Bes){
    //    cout << "m_Bes address:" << m_Bes << endl;
    //}


    //if (m_Bes) m_Bes->Draw();
    //if (view && view->GetVisAxis()) view->ShowAxis();
}

void BesGeometry::Draw2DXY()
{
    BesView *view = (BesView*)gPad->GetView();

    if (view && view->GetVisBeamPipe())    m_BeamPipeXY->Draw();

    if (m_MdcROOTGeo) m_MdcROOTGeo->Draw("XY");
    if (m_TofROOTGeo) m_TofROOTGeo->Draw("XY");
    if (m_EmcROOTGeo) m_EmcROOTGeo->Draw("XY");
    if (m_MucROOTGeo) m_MucROOTGeo->Draw("XY");

    if (view && view->GetVisZRPlaneOnXY()) m_ZRPlaneOnXY->Draw();
    if (view && view->GetVisAxis())        view->ShowAxis();
}

void BesGeometry::Draw2DZR()
{
    BesView *view = (BesView*)gPad->GetView();

    if (view && view->GetVisBeamPipe()) m_BeamPipeZR->Draw();

    if (m_MdcROOTGeo) m_MdcROOTGeo->Draw("ZR");
    if (m_TofROOTGeo) m_TofROOTGeo->Draw("ZR");
    if (m_EmcROOTGeo) m_EmcROOTGeo->Draw("ZR");
    if (m_MucROOTGeo) m_MucROOTGeo->Draw("ZR");

    if (view && view->GetVisAxis())     view->ShowAxis();
}

---