EventDisplay/BesVisLib/BesVisLib-00-04-04/src/TofROOTGeo.cxx

Go to the documentation of this file.

//$id$
/*
 *    2004/11/29   Zhengyun You      Peking University
 *                 Tof Geometry General for EventDisplay
 *
 *    2004/12/9    Zhengyun You      Peking University
 *                 named from TofGeo to TofROOTGeo
 *                 inherit from class SubDetectorROOTGeo
 */
 
using namespace std;
 
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <iomanip>
 
#include <TGeoManager.h>
#include <TGeoTube.h>
#include <TGeoArb8.h>
#include <TMath.h>
 
#include "BesVisLib/TofROOTGeo.h"
#include "Identifier/TofID.h"
#include "BesVisLib/BesEvent.h"
#include "BesVisLib/BesView.h"
#include "RawEvent/RawDataUtil.h"
 
 
TofROOTGeo::TofROOTGeo()
        : SubDetectorROOTGeo()
{
    // Default constructor.
    k_TMatch = kTRUE;
    k_QMatch = kTRUE;
    for (int part = 0; part < m_kPart; part++) {
        for (int layer = 0; layer < m_kLayerBr; layer++) {
            m_NodeAl[part][layer] = 0;
            m_NodeScin[part][layer] = 0;
            for (int scin = 0; scin < m_kScinBr; scin++) {
                m_NodePVF[part][layer][scin] = 0;
                m_PhysicalScin[part][layer][scin] = 0;
                m_Tof2DScin[part][layer][scin] = 0;
            }
        }
    }
 
    m_TofColor    = 6;
    m_BucketColor = 4;
    m_ScinColor   = kYellow;
}
 
TofROOTGeo::~TofROOTGeo()
{ }
 
void
TofROOTGeo::InitFromGDML( const char *gdmlFile, const char *setupName )
{
    m_ROOTGeoInit = 2;
 
    ReadGdml(gdmlFile, setupName);
    SetNode();
}
 
void
TofROOTGeo::InitFromROOT( TGeoVolume *vol )
{
    m_ROOTGeoInit = 1;
 
    SetVolumeTof(vol);
    SetNode();
}
 
void
TofROOTGeo::Init2DGeometry()
{
    if (m_ROOTGeoInit != 1 && m_ROOTGeoInit != 2) {
        cout << "TofROOTGeo::Init2DGeometry, ROOT Geometry not Initialized yet!" << endl;
        return;
    }
    m_2DGeoInit = 1;
 
    Double_t local[3] = {0.0, 0.0, 0.0};
    Double_t master[3] = {0.0, 0.0, 0.0};
    //Int_t    nPoints = 8;
    //Double_t  P[300] = {0.0};
    //Double_t  center[3] = {0.0, 0.0, 0.0};
    TString  name;
 
    // Tof Scintillators
    for (Int_t part = 0; part < m_kPart; part++) {
        for (Int_t layer = 0; layer < GetLayerNb(part); layer++) {
            for (int scin = 0; scin < GetScinNb(part); scin++) {
                TGeoPhysicalNode *scinPhyNode = GetPhysicalScin(part, layer, scin);
                if (part == 1) {
                    name = TString("Tof Part 1");
                    name += " Layer ";
                    name += layer;
                    name += " Phi ";
                    name += scin;
                }
                else {
                    if (part == 0) name = TString("EastEc");
                    else if (part == 2) name = TString("WestEc");
                    name = TString("Tof Part ");
                    name += part;
                    name += " Phi ";
                    name += scin;
                }
                TGeoArb8 *scinShape = (TGeoArb8*)scinPhyNode->GetShape();
                Double_t *localArb8Point, masterArb8Point[24];
                localArb8Point = scinShape->GetVertices();
 
                for (Int_t i = 0; i < 8; i++) {
                    local[0] = localArb8Point[2*i];
                    local[1] = localArb8Point[2*i+1];
                    if (i < 4) local[2] = scinShape->GetDz() * (-1.0);
                    else local[2] = scinShape->GetDz();
 
                    //cout << i << " local x: " << local[0] << " y: " << local[1] << " z: " << local[2] << endl;
                    scinPhyNode->GetMatrix(-1*scinPhyNode->GetLevel())->LocalToMaster(local, &master[0]); // transform to top
                    //cout << " master x: " << master[0] << " y: " << master[1] << " z: " << master[2] << endl;
 
                    for (Int_t j = 0; j < 3; j++) {
                        masterArb8Point[3*i+j] = master[j];
                    }
                }
 
                m_Tof2DScin[part][layer][scin] = new Tof2DScin(name, name, 8, &masterArb8Point[0], part);
            }
        }
    }
}
 
void
TofROOTGeo::SetNode()
{
    if (m_ROOTGeoInit == 2) { // from GDML
        m_Tof = GetTopVolume();
        if (!m_Tof) std::cout << "m_Tof = 0" << std::endl;
 
        for (int part = 0; part < m_kPart; part++) {
            for (int layer = 0; layer < GetLayerNb(part); layer++) {
                std::stringstream osnameAl;
                if (part == 1)      osnameAl << "pv_" << "logical" << "AlBr" << layer+1 << "_0";
                else if (part == 0)  osnameAl << "pv_" << "logical" << "AlEcEast" << "_0";
                else                osnameAl << "pv_" << "logical" << "AlEcWest" << "_0";
                m_NodeAl[part][layer] = GetNode( osnameAl.str() );
 
                std::stringstream osnameScin;
                if (part == 1)      osnameScin << "pv_" << "logical" << "ScinBr" << layer+1 << "_0";
                else if (part == 0)  osnameScin << "pv_" << "logical" << "ScinEcEast" << "_0";
                else                osnameScin << "pv_" << "logical" << "ScinEcWest" << "_0";
 
                m_NodeScin[part][layer] = GetNode( osnameScin.str() );
 
                for (int scin = 0; scin < GetScinNb(part); scin++) {
                    std::stringstream osnamePVF;
                    if (part == 1) {
                        osnamePVF << "pv_" << "logicalPVFBr"<< layer+1 << "_" << (2*m_kScinBr*3 - 1) - (layer*m_kScinBr + scin)*3;
                    }
                    else if (part == 2) {
                        osnamePVF << "pv_" << "logicalPVFEcWest" << "_" << (2*m_kScinEc - 1) - scin*2;
 
                    }
                    else if (part == 0) {
                        osnamePVF << "pv_" << "logicalPVFEcEast" << "_" << (2*m_kScinEc - 1) - scin*2;
                    }
                    m_NodePVF[part][layer][scin] = GetNode( osnamePVF.str() );
                }
            }
        }
    }
    else if (m_ROOTGeoInit == 1) { // from ROOT object
        for (int part = 0; part < m_kPart; part++) {
            int ipart = 0;
            if (part == 1) ipart = 2;
            if (part ==2 ) ipart = 1;
            for (int layer = 0; layer < GetLayerNb(part); layer++) {
                for (int scin = 0; scin < GetScinNb(part); scin++) {
                    int iNode = 0;
//    if (part == 1) {
//      iNode = layer*m_kScinBr + scin;
//    }
//    else if (part == 2) { // West placed first in Tof.gdml
//      iNode = 2*m_kScinBr + scin;
//    }
//    else if (part == 0) {
//      iNode = 2*m_kScinBr + m_kScinEc + scin;
//    }
                    if (part != 1){
                        iNode = (2*m_kScinEc - 1) - scin*2;
                    }
                    if (part == 1) {
                        iNode = (2*m_kScinBr*3 - 1) - (layer*m_kScinBr + scin)*3;
                    }
 
                    m_NodePVF[part][layer][scin] = m_Tof->GetNode( ipart )->GetVolume()->GetNode(iNode);//fix me, change structure now
                }
                m_NodeAl[part][layer] = m_NodePVF[part][layer][0]->GetVolume()->GetNode(0);
                //cout << m_NodeAl[part][layer]->GetName() << endl;
                m_NodeScin[part][layer] = m_NodeAl[part][layer]->GetVolume()->GetNode(0);
                //cout << m_NodeScin[part][layer]->GetName() << endl;
            }
        }
    }
 
    //std::cout << "TofROOTGeo::SetNode, end of set node" << std::endl;
}
 
void
TofROOTGeo::SetVolumeDefaultVis()
{
    //std::cout << "begin of set defaultvis" << std::endl;
 
    m_Tof->SetLineColor(m_TofColor);
    m_Tof->SetVisibility(0);
 
    for (int part = 0; part < m_kPart; part++) {
        GetVolumePart(part)->SetLineColor(m_ScinColor);
        GetVolumePart(part)->SetVisibility(0);
        for (int layer = 0; layer < GetLayerNb(part); layer++) {
            GetVolumePVF(part, layer)->SetLineColor(m_ScinColor);
            GetVolumePVF(part, layer)->SetVisibility(0);
 
            GetVolumeAl(part, layer)->SetLineColor(m_ScinColor);
            GetVolumeAl(part, layer)->SetVisibility(0);
 
            GetVolumeScin(part, layer)->SetLineColor(m_ScinColor);
            GetVolumeScin(part, layer)->SetVisibility(0);
 
            GetVolumeBucket(part, layer)->SetLineColor(m_BucketColor);
            GetVolumeBucket(part, layer)->SetVisibility(0);
        }
    }
    //std::cout << "end of set defaultvis" << std::endl;
}
 
void
TofROOTGeo::SetTMatch(Bool_t input = false){
    k_TMatch = input;
}
 
void
TofROOTGeo::SetQMatch(Bool_t input = false){
    k_QMatch = input;
}
 
void
TofROOTGeo::SetAllVisible()
{
    m_Tof->SetLineColor(m_TofColor);
    m_Tof->SetVisibility(0);
 
    for (int part = 0; part < m_kPart; part++) {
        for (int layer = 0; layer < GetLayerNb(part); layer++) {
            GetVolumePVF(part, layer)->SetLineColor(m_ScinColor);
            GetVolumePVF(part, layer)->SetVisibility(1);
 
            GetVolumeAl(part, layer)->SetLineColor(m_ScinColor);
            GetVolumeAl(part, layer)->SetVisibility(1);
 
            GetVolumeScin(part, layer)->SetLineColor(m_ScinColor);
            GetVolumeScin(part, layer)->SetVisibility(1);
 
            GetVolumeBucket(part, layer)->SetLineColor(m_BucketColor);
            GetVolumeBucket(part, layer)->SetVisibility(1);
        }
    }
}
 
void
TofROOTGeo::SetQuarterVisible()
{
    /*
    for (int part = 0; part < m_kPart; part++) {
      GetVolumeScin(part)->SetVisibility(1);
      GetVolumeBucket(part)->SetVisibility(1);
      
      int nScin = 0;
      if (part == 1) nScin = m_kAssemblyBr;
      else nScin = m_kAssemblyEc;
      for (int scin = 0; scin < nScin; scin++) {
        if (scin < nScin/4) GetScin(part, scin)->SetVisibility(0);
        else                GetScin(part, scin)->SetVisibility(1);
      
        int nBucket = 0;
        if (part == 1) nBucket = m_kBucketBr;
        else nBucket = m_kBucketEc;
        for (int bucket = 0; bucket < nBucket; bucket++) {
      if (scin < nScin/4) GetBucket(part, scin, bucket)->SetVisibility(0);
      else                GetBucket(part, scin, bucket)->SetVisibility(1);
        }
      }
    }
    */
}
 
void
TofROOTGeo::SetHalfVisible()
{
    /*
    for (int part = 0; part < m_kPart; part++) {
      GetVolumeScin(part)->SetVisibility(1);
      GetVolumeBucket(part)->SetVisibility(1);
      
      int nScin = 0;
      if (part == 1) nScin = m_kAssemblyBr;
      else nScin = m_kAssemblyEc;
      for (int scin = 0; scin < nScin; scin++) {
        if (scin < nScin/4+1 ||
        scin > nScin*3/4 ) GetScin(part, scin)->SetVisibility(1);
        else                   GetScin(part, scin)->SetVisibility(0);
      
        int nBucket = 0;
        if (part == 1) nBucket = m_kBucketBr;
        else nBucket = m_kBucketEc;
        for (int bucket = 0; bucket < nBucket; bucket++) {
      if (scin < nScin/4+1 ||
          scin > nScin*3/4 ) GetBucket(part, scin, bucket)->SetVisibility(1);
      else                   GetBucket(part, scin, bucket)->SetVisibility(0);
        }
      }
    }
    */
}
 
void
TofROOTGeo::SetNoEndVisible()
{
    /*
    int part = 1;
    GetVolumeScin(0)->SetVisibility(1);
    GetVolumeBucket(0)->SetVisibility(1);
      
    int nScin = 0;
    nScin = m_kAssemblyBr;
    for (int scin = 0; scin < nScin; scin++) {
      GetScin(part, scin)->SetVisibility(1);
 
      int nBucket = 0;
      nBucket = m_kBucketBr;
      for (int bucket = 0; bucket < nBucket; bucket++) {
        GetBucket(part, scin, bucket)->SetVisibility(1);
      }
    }
    */
}
 
void
TofROOTGeo::SetPhysicalNode()
{
    if (gGeoManager == 0) std::cout << "Create gGeoManager first" << std::endl;
    TGeoNode *bes = gGeoManager->GetTopNode();
    //std::cout << "Tof m_childNo " << m_childNo << std::endl;
    //TGeoNode *nodeTof = bes->GetVolume()->GetNode(0);
    TGeoNode *nodeTof = bes->GetDaughter(1);
    for (int part = 0; part < m_kPart; part++) {
 
//     std::stringstream osnamePart;
//     if (part == 1)      osnamePart << "pv_" << "logicalBrTof" << "_2";
//     else if(part == 0)  osnamePart << "pv_" << "logicalEcTofEast" << "_0";
//     else                osnamePart << "pv_" << "logicalEcTofWest" << "_1";
 
//    TGeoNode *nodePart = GetNode( osnamePart.str() );
 
        int ipart = 0;
        if (part == 1) ipart = 2;
        if (part ==2 ) ipart = 1;
        TGeoNode *nodePart;
        nodePart = nodeTof->GetVolume()->GetNode(ipart);
 
        for (int layer = 0; layer < GetLayerNb(part); layer++) {
            TGeoNode *nodeAl   = GetAl(part, layer);
            TGeoNode *nodeScin = GetScin(part, layer);
            for (int scin = 0; scin < GetScinNb(part); scin++) {
                TGeoNode *nodePVF = GetPVF(part, layer, scin);
                m_PhysicalScin[part][layer][scin] = gGeoManager->MakePhysicalNode( TString("/") + bes->GetName() +
                                                    TString("/") + nodeTof->GetName() +
                                                    TString("/") + nodePart->GetName() +
                                                    TString("/") + nodePVF->GetName() +
                                                    TString("/") + nodeAl->GetName() +
                                                    TString("/") + nodeScin->GetName() );
                //cout<<"in SetPhysicalNode() "<<part<<" "<<layer<<" "<<scin<<" "<<endl;
                //cout<<"                     "<<bes->GetName()<<" "<<nodeTof->GetName()<<" "<<nodePVF->GetName()<<" "<<nodeAl->GetName()<<" "<<nodeScin->GetName()<<endl;
                m_PhysicalScin[part][layer][scin]->SetVisibility(0);
                m_PhysicalScin[part][layer][scin]->SetIsVolAtt(kFALSE);
                m_PhysicalScin[part][layer][scin]->SetLineColor(m_ScinColor);
            }
        }
    }
 
    SetDetector();
}
 
void
TofROOTGeo::SetDetector()
{
    BesView *view = 0;
    if (gPad) view = (BesView*)gPad->GetView();
    //if (view) cout << "viewVisFull3DTof " << view->GetVisFull3DTof() << endl;
 
    m_DetectorsArray->Clear();
    for (int part = 0; part < m_kPart; part++) {
        for (int layer = 0; layer < GetLayerNb(part); layer++) {
            for (int scin = 0; scin < GetScinNb(part); scin++) {
                TGeoPhysicalNode *phyNode = 0;
                phyNode = GetPhysicalScin(part, layer, scin);
                if (phyNode) {
                    phyNode->SetVisibility(0); // set all invisible before set any visible
                    if (part == 2 ||
                            (scin >= GetScinNb(part)*0/4 && scin < GetScinNb(part)*8/8)) {
                        m_DetectorsArray->Add( phyNode );
                    }
                    else if (view && view->GetVisFull3DTof()) {
                        m_DetectorsArray->Add( phyNode );
                    }
                }
            }
        }
    }
}
 
void
TofROOTGeo::SetHits()
{
    // set previous event hits to default vis
    for (int i = 0; i < m_HitsArray->GetEntries(); i++) {
        TGeoPhysicalNode *phyNode = (TGeoPhysicalNode*)m_HitsArray->At(i);
    if (phyNode){
        //phyNode->SetLineColor(m_ScinColor);
        phyNode->SetVisibility(0);
    }
    }
    m_HitsArray->Clear("C");
 
    // set previous event 2D hits info to default
    for (int i = 0; i < m_2DHitsArray->GetEntries(); i++) {
      Tof2DScin *aScin = (Tof2DScin*)m_2DHitsArray->At(i);
      aScin->ClearInfo();
      aScin->AddInfo(aScin->GetTitle());
      aScin->CloseInfo();
      aScin->ResetTimeCharge();
    }
    m_2DHitsArray->Clear("C");
 
    if (gEvent) m_TofDigiCol = gEvent->GetTofDigiCol();
 
    for (int i = 0; i < m_TofDigiCol->GetEntries(); i++) {
      TTofDigi *aTofDigi = (TTofDigi*)m_TofDigiCol->At(i);
 
      Identifier atofID( aTofDigi->getIntId() );
      int part  = TofID::barrel_ec(  atofID );
      int layer = TofID::layer(      atofID );
      int scin  = TofID::phi_module( atofID );
 
      //Double_t charge = Double_t(aTofDigi->getChargeChannel()) / TOF_CHARGE_FACTOR;
      //Double_t time   = Double_t(aTofDigi->getTimeChannel())   / TOF_TIME_FACTOR;
 
      Double_t charge = RawDataUtil::TofCharge(aTofDigi->getChargeChannel());
      Double_t time   = RawDataUtil::TofTime(aTofDigi->getTimeChannel());
 
      TGeoPhysicalNode *phyNode = 0;
      phyNode = GetPhysicalScin( part, layer, scin );
      if (phyNode) {
    m_HitsArray->Add( phyNode );
      }
 
      Tof2DScin *aScin = 0;
      aScin = m_Tof2DScin[part][layer][scin];
      if (aScin) {
    char data[100];
 
    if (aScin->GetCharge() == 0.0) {
      aScin->ClearInfo();
      aScin->AddInfo(aScin->GetTitle());
      sprintf(data, "time1 = %-.3f ns, charge1 = %-.3f MeV", time, charge);
      aScin->AddInfo( TString(data) );
    }
    else {
      sprintf(data, "time2 = %-.3f ns, charge2 = %-.3f MeV", time, charge);
      aScin->AddInfo( TString(data) );
      sprintf(data, "Fired");
      aScin->AddInfo( TString(data) );
    }
 
    aScin->CloseInfo();
    aScin->SetCharge(aScin->GetCharge() + charge);
 
    m_2DHitsArray->Add(aScin);
      }
    }
}
 
  void
TofROOTGeo::SetVisTofDetector()
{
  /*
     for (int part = 0; part < m_kPart; part++) {
     for (int layer = 0; layer < GetLayerNb(part); layer++) {
     for (int scin = 0; scin < GetScinNb(part); scin++) {
     TGeoPhysicalNode *phyNode = GetPhysicalScin(part, layer, scin);
     if (phyNode) phyNode->SetLineColor(m_ScinColor);
     }
     }
     }
     */
 
  BesView *view = 0;
  if (gPad) view = (BesView*)gPad->GetView();
 
  //cout << "VisTofEast " << view->GetVisTofEast() << endl;
  for (int i = 0; i < m_DetectorsArray->GetEntries(); i++) {
    TGeoPhysicalNode *phyNode = (TGeoPhysicalNode*)m_DetectorsArray->At(i);
    phyNode->SetVisibility(0);
    if (view && view->GetVisTofGlobal()) {
      int part = GetPart(phyNode);
      if (part == 0 && view->GetVisTofEast()   ||
      part == 1 && view->GetVisTofBarrel() ||
      part == 2 && view->GetVisTofWest()   )
    phyNode->SetVisibility(1);
    }
  }
}
 
  void
TofROOTGeo::SetVisTofHits()
{
  BesView *view = 0;
  if (gPad) view = (BesView*)gPad->GetView();
 
  for (int i = 0; i < m_HitsArray->GetEntries(); i++) {
    TGeoPhysicalNode *phyNode = (TGeoPhysicalNode*)m_HitsArray->At(i);
    if (phyNode){
      if (view && view->GetVisTofHitsGlobal()) {
    int part = GetPart(phyNode);
    if (part == 0 && view->GetVisTofHitsEast()   ||
        part == 1 && view->GetVisTofHitsBarrel() ||
        part == 2 && view->GetVisTofHitsWest()   ) {
      phyNode->SetVisibility(1);
      phyNode->SetLineColor(kGreen);
      continue;
    }
      }
      phyNode->SetVisibility(0);
    }
  }
}
 
  int
TofROOTGeo::GetPartNb()
{
  int nPart = m_kPart;
  return nPart;
}
 
  int
TofROOTGeo::GetScinNb(int part)
{
  int nScin = m_kScinBr;
  if (part != 1) nScin = m_kScinEc;
  return nScin;
}
 
  int
TofROOTGeo::GetLayerNb(int part)
{
  int nLayer = m_kLayerBr;
  if (part != 1) nLayer = m_kLayerEc;
  return nLayer;
}
 
/*
   TGeoVolumeAssembly*
   TofROOTGeo::GetVolumeAssembly( int part )
   {
   std::stringstream osname;
   if (part == 0 || part == 2) {
   osname << "logical" << "Tof" << "AssemblyEc";
   }
   else {
   if (part == 1) {
   osname << "logical" << "Tof" << "AssemblyBr";
   }
   }
 
   return GetAssemblyVolume( osname.str() );
   }
   */
 
  TGeoVolume*
TofROOTGeo::GetVolumePart(int part)
{
  std::stringstream osname;
  if (part == 1) {
    osname << "logicalBrTof";
  }
  else if (part == 0){
    osname << "logicalEcTofWest";
  }
  else {
    osname << "logicalEcTofEast";
  }
 
  return GetLogicalVolume( osname.str() );
 
 
 
}
 
  TGeoVolume*
TofROOTGeo::GetVolumePVF( int part, int layer )
{
  std::stringstream osname;
  if (part == 0) {
    osname << "logical" << "PVFEcEast";
  }
  else if (part == 2){
    osname << "logical" << "PVFEcWest";
  }
  else {
    if (part == 1) {
      osname << "logical" << "PVFBr" << layer+1;
    }
  }
 
  return GetLogicalVolume( osname.str() );
}
 
  TGeoVolume*
TofROOTGeo::GetVolumeAl( int part, int layer )
{
  std::stringstream osname;
  if (part == 0) {
    osname << "logical" << "AlEcEast";
  }
  else if (part == 2){
    osname << "logical" << "AlEcWest";
  }
  else {
    if (part == 1) {
      osname << "logical" << "AlBr" << layer+1;
    }
  }
 
  return GetLogicalVolume( osname.str() );
}
 
  TGeoVolume*
TofROOTGeo::GetVolumeScin( int part, int layer )
{
  std::stringstream osname;
  if (part == 0) {
    osname << "logical" << "ScinEcEast";
  }
  else if (part == 2){
    osname << "logical" << "ScinEcWest";
  }
  else {
    if (part == 1) {
      osname << "logical" << "ScinBr" << layer+1;
    }
  }
 
  return GetLogicalVolume( osname.str() );
}
 
  TGeoVolume*
TofROOTGeo::GetVolumeBucket( int part, int layer )
{
  std::stringstream osname;
  if (part == 0 || part == 2) {
    osname << "logical" << "BucketEc";
  }
  else {
    if (part == 1) {
      osname << "logical" << "BucketBr" << layer+1;
    }
  }
 
  return GetLogicalVolume( osname.str() );
}
 
  TGeoNode*
TofROOTGeo::GetPVF( int part, int layer, int scin )
{
  if (m_NodePVF[part][layer][scin] != 0) {
    return m_NodePVF[part][layer][scin];
  }
  else {
    std::cout << "Node: " << "Part" << part << "Layer" << layer << "PVF" << scin << " not found" << std::endl;
    return 0;
  }
 
  return m_NodePVF[part][layer][scin];
}
 
  TGeoNode*
TofROOTGeo::GetAl( int part, int layer )
{
  if (m_NodeAl[part][layer] != 0) {
    return m_NodeAl[part][layer];
  }
  else {
    std::cout << "Node: " << "Part" << part << "Layer" << layer << "Al" << " not found" << std::endl;
    return 0;
  }
 
  return m_NodeAl[part][layer];
}
 
  TGeoNode*
TofROOTGeo::GetScin( int part, int layer )
{
  if (m_NodeScin[part][layer] != 0) {
    return m_NodeScin[part][layer];
  }
  else {
    std::cout << "Node: " << "Part" << part << "Layer" << layer << "Scin" << " not found" << std::endl;
    return 0;
  }
 
  return m_NodeScin[part][layer];
}
 
 
/*
   TGeoNode *
   TofROOTGeo::GetBucket( int part, int scin, int bucket )
   {
   std::stringstream osname;
   if (part == 0) {
   osname << "pv_" << "logical" << "Tof" << "BucketEc" << "_" << m_kAssemblyBr + m_kAssemblyEc + scin << "_1";
   }
   else if (part == 1) {
   osname << "pv_" << "logical" << "Tof" << "BucketBr" << "_" << scin << "_" << bucket+1;
   }
   else if (part == 2) {
   osname << "pv_" << "logical" << "Tof" << "BucketEc" << "_" << m_kAssemblyBr + scin << "_1";
   }
 
   return GetNode( osname.str() );
   }
   */
 
  TGeoPhysicalNode*
TofROOTGeo::GetPhysicalScin( int part, int layer, int scin )
{
  if (m_PhysicalScin[part][layer][scin] != 0) {
    return m_PhysicalScin[part][layer][scin];
  }
  else {
    std::cout << "PhysicalNode: " << "Part"
      << part << "Layer" << layer << "Scin"
      << scin << " not found" << std::endl;
    return 0;
  }
}
 
  Tof2DScin*
TofROOTGeo::Get2DScin( Int_t part, Int_t layer, Int_t scin)
{
  if (m_Tof2DScin[part][layer][scin]) return m_Tof2DScin[part][layer][scin];
  else return 0;
}
 
  Int_t
TofROOTGeo::GetPart(TGeoPhysicalNode* phyNode)
{
  for (Int_t part = 0; part < m_kPart; part++) {
    for (Int_t layer = 0; layer < GetLayerNb(part); layer++) {
      for (int scin = 0; scin < GetScinNb(part); scin++) {
    if (phyNode == GetPhysicalScin(part, layer, scin)) {
      //cout << "GetPart()" << part << endl;
      return part;
    }
      }
    }
  }
 
  cout << "TofROOTGeo::GetPart, this scintillator physical node does not exist!" << endl;
  return -1;
}
 
  void
TofROOTGeo::Draw(Option_t *option)
{
  TString opt = option;
  opt.ToUpper();
 
  if (!m_2DGeoInit) cout << "TofROOTGeo::Draw2D(), 2D Geometry not initialized!" << endl;
  BesView *view = (BesView*)gPad->GetView();
  if (!view) cout << "TofROOTGeo::Draw(), BesView not found" << endl;
 
  if (view->GetVisTofGlobal()) { // TofVisGlobal
    TString scinOpt;
 
    //if (opt.Contains("XY")) {
    // west part drawn first usually
    for (Int_t part = m_kPart-1; part >= 0; part--) {
      for (Int_t layer = 0; layer < GetLayerNb(part); layer++) {
    for (int scin = 0; scin < GetScinNb(part); scin++) {
 
      if (m_Tof2DScin[part][layer][scin]) {
        //cout << "part " << part << " layer " << layer << " scin " << scin << endl;
        //m_Tof2DScin[part][layer][scin]->SetHighlighted(false);
        m_Tof2DScin[part][layer][scin]->SetFired(false);
        if ( (part == 0 && view->GetVisTofEast())   ||
        (part == 1 && view->GetVisTofBarrel()) ||
        (part == 2 && view->GetVisTofWest()) )
          m_Tof2DScin[part][layer][scin]->Draw(scinOpt);
      }
    }
      }
    }
  }
  }
 
  void
    TofROOTGeo::DrawHits(Option_t *option)
    {
      // cout << "Draw Hits" << endl;
      BesView *view = (BesView*)gPad->GetView();
      if (!view) cout << "TofROOTGeo::DrawHits(), BesView not found" << endl;
 
      //cout << "VisTofHitsGlobal " << view->GetVisTofHitsGlobal() << endl;
      //cout << "VisTofHitsEast   " << view->GetVisTofHitsEast()   << endl;
      //cout << "VisTofHitsBarrel " << view->GetVisTofHitsBarrel() << endl;
      //cout << "VisTofHitsWest   " << view->GetVisTofHitsWest()   << endl;
 
      if (view->GetVisTofHitsGlobal()) {
 
    // reset time and charge to zero
    for (Int_t part = m_kPart-1; part >= 0; part--) {
      for (Int_t layer = 0; layer < GetLayerNb(part); layer++) {
        for (int scin = 0; scin < GetScinNb(part); scin++) {
          if (m_Tof2DScin[part][layer][scin]) {
        m_Tof2DScin[part][layer][scin]->ResetTimeCharge();
          }
        }
      }
    }
 
    if (m_TofDigiCol) {
      for (int i = 0; i < m_TofDigiCol->GetEntries(); i++) {
        TTofDigi *aTofDigi = (TTofDigi*)m_TofDigiCol->At(i);
 
        Identifier aTofID( aTofDigi->getIntId() );
        int part   = TofID::barrel_ec( aTofID );
        int layer  = TofID::layer( aTofID );
        int scin   = TofID::phi_module( aTofID );
 
        Double_t charge = Double_t(aTofDigi->getChargeChannel()) / TOF_CHARGE_FACTOR;
        //cout << "charge " << charge << endl;
 
        Tof2DScin *aScin = 0;
        aScin = m_Tof2DScin[part][layer][scin];
        // Mdc TQMatch for example
        //
        //if (aWire &&
        //        ((overflow == 0)||(overflow == 12))){
        //    if ((k_TMatch) &&
        //            (aMdcDigi->getTimeChannel() == 0x7FFFFFFF)){
        //        continue;
        //    }
        //    if ((k_QMatch) &&
        //            (aMdcDigi->getChargeChannel() == 0x7FFFFFFF)){
        //        continue;
        //    }
        //}
 
        if (aScin) {
          if ((k_TMatch)&&
          (aTofDigi->getTimeChannel() == 0x7FFFFFFF)){
        continue;
          }
          if ((k_QMatch)&&
          (aTofDigi->getChargeChannel() == 0x7FFFFFFF)){
        continue;
          }
 
          aScin->SetCharge(aScin->GetCharge() + charge);
 
          if ( (part == 0 && view->GetVisTofHitsEast())   ||
          (part == 1 && view->GetVisTofHitsBarrel()) ||
          (part == 2 && view->GetVisTofHitsWest()) ) {
        aScin->SetFired(true);
        aScin->Draw();
          }
        }
      }
    }
      }
    }