---

TkrDisplay.cxx

Go to the documentation of this file.

#include "bfemDisplay/TkrDisplay.h"
#include "bfemDisplay/Enum.h"


Float_t ZLayer[ 26 ] = { 0.0 };

Int_t DieXlayer[ 26 ] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3 };


TkrDisplay::TkrDisplay( TNode *parent ) {


  parent->cd();

  // Note: All measurements in cm.  Numbers are half what they are in reality.  
  // This is to accomadate the fact that TBrik accept half lengths as input variables.
  // Coordinate system center in the center of the tower frame.

  m_TkrHeight           = 19.405;    // Tracker height
  m_TkrWidth            = 16.;       // Tracker width (1600*200um)
  m_TkrHeightOffset     = 19.405;    // Offset for tracker node 
  m_NumStrips           = 1600;      // Total number of strip
  m_StripDisplayWidth   = 0.5;
  m_StripHeight         = 0.5;       // Height of tracker log
  m_StripLength         = 16.;       // Length of tracker log

  m_StripWidth          = m_TkrWidth / ( Float_t )m_NumStrips;   
  m_LayerHeight         = 0.84375;
  m_reconOffsetZ        = 3.7;

  m_numTkrLayers        = 26;


  // Zero TObjArray pointers.

  m_TkrNodeList = 0;
  m_TkrHitList = 0;
  m_TkrReconHitList = 0;
  m_TkrReconNodeList = 0;



  // The BRIK which represents the outline of the tracker.
  TBRIK* tkrFrame = new TBRIK( "tkrFrame", "tkrFrame", "void", m_TkrWidth, m_TkrWidth, m_TkrHeight );
  tkrFrame->SetLineColor( 1 );

  // Top-level node for the tracker.
  m_tkrFrameNode = new TNode( "tkrFrameNode", "tkrFrameNode", "tkrFrame", 0.0, 0.0, m_TkrHeightOffset );

  m_tkrFrameNode->cd();

  // Top-level node for hits on strips parallel to Y-axis ( measured coordinate is X ).
  m_AllHitsX = new TNode( "AllHitsX", "AllHitsX", "tkrFrame" );
  m_AllHitsX->SetParent( m_tkrFrameNode );

  // Top-level node for hits on strips parallel to X-axis ( measured coordinate is Y ).
  m_tkrFrameNode->cd();
  m_AllHitsY = new TNode( "AllHitsY", "AllHitsY", "tkrFrame" );
  m_AllHitsY->SetParent( m_tkrFrameNode );
 
  // Z-coord of Si layers.

  ZLayer[ 0 ] = 0.0;
  ZLayer[ 1 ] = 0.3316;

  for ( Int_t i = 2; i < m_numTkrLayers; ++i ) {
    if ( i%2 ) ZLayer[ i ] = ZLayer[ 1 ] + Dz * ( i / 2 );
    else ZLayer[ i ] = Dz * ( i / 2 );
  }

  // Create nodes for displaying of layers.

  TBRIK *layerBrik;
  TNode *layNode;

  Float_t x, y;
   
  for ( Int_t ilay = 0; ilay < m_numTkrLayers; ilay++ ) {
       
    Float_t z = -m_TkrHeight + ZLayer[ ilay ];
       
    m_LayerWidth = m_TkrWidth * DieXlayer[ ilay ] / 5;  // ( Max. 5 ladders per layer. )

    Int_t isY = !( ilay%2 );   // First layer ( layer 0 ) has strips parallel to X.

    if ( isY ) {  // If isY = 1, Y is measured ==> strips along X

      x = 0.0;
      y = -m_TkrWidth + m_LayerWidth;

      layerBrik = new TBRIK( "layerBrik", "layerBrik", "void", m_TkrWidth, m_LayerWidth, 0.005 );

      m_AllHitsY->cd();
    
      layerBrik->SetLineColor( 4 );
      layerBrik->SetLineStyle( 3 );

      layNode = new TNode( "layerNode", "layerNode", layerBrik, x, y, z );
      layNode->SetParent( m_AllHitsY );

    }

    else {
   
      y = 0.0;
      x = -m_TkrWidth + m_LayerWidth;

      layerBrik = new TBRIK( "layerBrik", "layerBrik", "void", m_LayerWidth, m_TkrWidth, 0.005 );

      m_AllHitsX->cd();
    
      layerBrik->SetLineColor( 4 );
      layerBrik->SetLineStyle( 3 );

      layNode = new TNode( "layerNode", "layerNode", layerBrik, x, y, z );
      layNode->SetParent( m_AllHitsX );

    }
    
    // Draw Superglast absorbers.

    TBRIK *sglayer;
    Float_t sgZ;
    Char_t* sg_name;

    m_tkrFrameNode->cd();  // Remove this if want to split sg layers into X and Y.

    if ( ilay < 3 ) {

      sgZ = -m_TkrHeight + ZLayer[ 1 ] + ( ilay + 2 )*Dz;

      sg_name = getSGName( ilay );

      sglayer = new TBRIK( sg_name, "sglayer", "void", m_TkrWidth, m_TkrWidth, 0.1 );
      sglayer->SetLineColor( 2 );
      m_sgNode = new TNode( "supergNode", "supergNode", sg_name, 0.0, 0.0, sgZ );
 
    }

  }

}




void TkrDisplay::DrawEvents( DigiEvent *event, Recon *recon ) {

 
  // Draw displays the current event.

  TNNode *newnode;
  THits *tkrStrip;
    
  Char_t* tkr_name = 0;    // Names of TNode and shapes in Tracker Lists.
  Char_t* hit_name = 0;    // Names of elements in TkrHitList.
  Char_t* view;
    
  Float_t x, y, z;
  Int_t nhit = 0;


  // Delete the old hit and node arrays

  if ( m_TkrNodeList ) m_TkrNodeList->Delete();
  m_TkrNodeList = new TObjArray();

  if ( m_TkrHitList ) m_TkrHitList->Delete();
  m_TkrHitList = new TObjArray();

  // Retrieve info for this event.

  m_event = event;
  m_recon = recon;

  m_event->getTkrDigi()->Sort();

  Int_t nTKR = m_event->getTkrDigi()->GetEntries();   // Number of tracker layers.
    
  for (Int_t ilay = 0; ilay < nTKR; ilay++) {  // Loop over layers.

    const TkrLayer* layer =  m_event->getTkrLayer( ilay );
      
    Int_t isY = (Int_t)layer->getXY(); // if isY = 1 Y is measured ==> strips along X.
       
    Int_t LayerNum = layer->getLayerNum();
      
    TObjArray  *stripList = 0;
      
    stripList = ( ( TkrLayer* )layer )->getStrips();
       
    Int_t nStrips = stripList->GetEntries();
       
    z = -m_TkrHeight + ZLayer[ LayerNum ];  // Layer z-coord.
       
    m_LayerWidth = m_TkrWidth * DieXlayer[ LayerNum ] / 5;
  


    for ( Int_t iStrip=0; iStrip < nStrips; iStrip++ ) {  // Loop over strips.
         
      StripId* strip = ( StripId* )( stripList->At( iStrip ) );
      Int_t stripID = strip->getId();

      if ( stripID < 0 || stripID > 1600 ) {
        printf("==> Strip %i ==> out of boudary!!!\n",stripID); 
        continue; // Out of boundary!!!
      }

      tkr_name = getTkrName( LayerNum, stripID );

      hit_name = tkr_name;

      if ( isY ) {  // Assign node for hit on strips parallel to X-axis.

        m_AllHitsY->cd();

        view = "Y"; // Y is measured coordinate - strips along X

        x = 0.0;
        y = -m_TkrWidth + ( 1.0 + 2.0*( Float_t )stripID )*m_StripWidth;

        tkrStrip = new THits( tkr_name, tkr_name, "Si", m_StripLength, m_StripDisplayWidth, m_StripHeight );

        newnode = new TNNode( hit_name, hit_name, hit_name, x, y, z);

        newnode->setObject( tkrStrip );
        newnode->SetParent( m_AllHitsY );

        m_TkrNodeList->Add( newnode );

      }

      else {  // Assign node for hit on strips parallel to Y-axis.

        m_AllHitsX->cd();

        view = "X"; // X is measured coordinate - strips along Y.

        y = 0.0;
        x = -m_TkrWidth + ( 1.0 + 2.0*( Float_t )stripID )*m_StripWidth;

        tkrStrip = new THits( tkr_name,tkr_name, "Si", m_StripDisplayWidth, m_StripLength, m_StripHeight );

        newnode = new TNNode( hit_name, hit_name, hit_name, x, y, z);

        newnode->setObject( tkrStrip );
        newnode->SetParent( m_AllHitsX );

        m_TkrNodeList->Add( newnode );

      }  


      Int_t aTot = ( ( TkrLayer* )layer )->getToT(0); // read TOT left
      Int_t bTot = ( ( TkrLayer* )layer )->getToT(1); // read TOT right
        
      tkrStrip->SetLineColor( 1 );
      tkrStrip->SetX(x);
      tkrStrip->SetY(y);
      tkrStrip->SetZ(ZLayer[LayerNum]);
      tkrStrip->SetLayer(LayerNum);
      tkrStrip->SetView(view);
      tkrStrip->SetElement(stripID);
      tkrStrip->SetTot(aTot,0);
      tkrStrip->SetTot(bTot,1);

      m_TkrHitList->Add( tkrStrip );

      nhit++;

    }  // End loop over strips.

  }  // End loop over layers.

  if ( m_recon ) drawTkrRecon();

}



Char_t* TkrDisplay::getTkrName(Int_t i, Int_t stripID) {

   Char_t cs[40];

   TString *TkrName = new TString("TKRlayer");

   sprintf(cs,"%d",i);

   TkrName->Append(cs);

   TkrName->Append("_id");

   sprintf(cs,"%d",stripID);

   TkrName->Append(cs);

   return (Char_t*)TkrName->Data();

}


Char_t* TkrDisplay::getLayerName(Int_t i) {

   Char_t cs[40];

   TString *LayerName = new TString("Layer");

   sprintf(cs,"%d",i);

   LayerName->Append(cs);

   return (Char_t*)LayerName->Data();

}


Char_t* TkrDisplay::getSGName(Int_t i) {

   Char_t cs[40];

   TString *SGName = new TString("SGLayer");

   sprintf(cs,"%d",i);

   SGName->Append(cs);

   return (Char_t*)SGName->Data();

}

void TkrDisplay::drawTkrRecon() {



  // Draw reconstructed hits in the tracker: hit position and direction.

  // For the moment only in 2D.


  TkrRecon *tkrRecon = m_recon->getTkrRecon();

  TObjArray *trackList = tkrRecon->getTracks();


  Char_t hitName[ 30 ];
  Char_t rmName[ 30 ];

  Int_t nhit = 0;

  Double_t x, y, z;



  Int_t numTracks = trackList->GetEntries();


  
  // Create a new list of reconstructed hits.

  if ( m_TkrReconHitList ) m_TkrReconHitList->Delete();
  m_TkrReconHitList = new TObjArray();
  
  // Create a new list of nodes.

  if ( m_TkrReconNodeList ) m_TkrReconNodeList->Delete();
  m_TkrReconNodeList = new TObjArray();


  for ( Int_t itrack=0; itrack<numTracks; ++itrack ) {

    // Loop over all tracks for this event.


    TkrTrack *track = ( TkrTrack* )trackList->At( itrack );  // Retrieve a track.

    TObjArray *hitList = track->getHits();   // Get list of hits for this track.


    Int_t numHits = hitList->GetEntries();

    Int_t nHitsX = 0;
    Int_t nHitsY = 0;

    Float_t xLast, yLast, zLastX, zLastY;


    for ( Int_t ihit=0; ihit<numHits; ++ihit ) {

      // Loop over all hits in the track.

      TkrHit *hit = ( TkrHit* )hitList->At( ihit );  // Retrieve a hit.

      TkrLocator* locator = hit->getLocator();  // Get locator for this hit.

      TVector3 position = locator->getPosition();


      x = position.X();

      y = position.Y();

      z = -m_TkrHeight - /*m_reconOffsetZ*/ Dz + position.Z();



      // Slopes in degrees ( for rotation matrix ).

      Double_t angleX = locator->getSlopeX() * 360/( 2*3.14159 );

      Double_t angleY = locator->getSlopeY() * 360/( 2*3.14159 );


      // Hits in X have position.Y() all zero; hits in Y have position.X() all zero.  Use this to determine which

      // projection the hit refers to.  Obviously not perfect solution!  Angle of hit specified via the rotation

      // matrix of the hit TNode.



      if ( fabs( 1000000*angleX ) > fabs( 1000000*angleY ) ) {

        if ( nHitsX > 0 ) {

          m_AllHitsX->cd();

          // Start constructing track segements when have more than one recon point...

          Float_t dX = x - xLast;
          Float_t dZ = z - zLastX;

          // Determine length and angle of segment.

          Double_t angle = 180.0/3.14159*atan( dX / dZ );

          Float_t markerLength;

          if ( dZ != 0.0 ) markerLength = sqrt( dX*dX + dZ*dZ );
          else markerLength = 0.0;

          sprintf( hitName, "TRK%d_SEG%d", itrack, ihit );  // Name of hit ( unique for this event ).
          TReconHits *reconHit = new TReconHits( hitName, hitName, "Si" );
          Float_t secZ = 0.0;
          for ( Int_t secNum=0; secNum<10; ++secNum ) {
            secZ += markerLength / 10.0;
            reconHit->DefineSection( secNum, secZ, 0.0, 0.05 );
          }
          m_TkrReconHitList->Add( reconHit );  // Add to list of recon hits.

          reconHit->SetX( x );
          reconHit->SetY( y );
          reconHit->SetZ( z );
          reconHit->SetAngleX( angleX );
          reconHit->SetAngleY( angleY );

          reconHit->SetLineColor( 2 );

          sprintf( rmName, "Angle%s", hitName );  // Rotation matrix name.
          TRotMatrix *rm = new TRotMatrix( rmName, rmName, 90, 0, 90, 90, angle, 0 );

          TNNode *newnode = new TNNode( hitName, hitName, reconHit, x, 0.0, z, rm );

          newnode->setObject( reconHit );
          newnode->SetParent( m_AllHitsX );

          m_TkrReconNodeList->Add( newnode );

          ++nhit;

        }

        xLast = x;
        
        zLastX = z;

        ++nHitsX;

      }

      else  {

        if ( nHitsY > 0 ) {

          m_AllHitsY->cd();

          // Start constructing track segments when have more than one recon point...

          Float_t dY = y - yLast;
          Float_t dZ = z - zLastY;

          // Determine length and angle of segment.

          Double_t angle = 180.0/3.14159*atan( dY / dZ );

          Float_t markerLength;

          if ( dZ != 0.0 ) markerLength = sqrt( dY*dY + dZ*dZ );
          else markerLength = 0.0;

          sprintf( hitName, "TRK%d_SEG%d", itrack, ihit );  // Name of hit ( unique for this event ).
          TReconHits *reconHit = new TReconHits( hitName, hitName, "Si" );
          Float_t secZ = 0.0;
          for ( Int_t secNum=0; secNum<10; ++secNum ) {
            secZ += markerLength / 10.0;
            reconHit->DefineSection( secNum, secZ, 0.0, 0.05 );
          }
          m_TkrReconHitList->Add( reconHit );  // Add to list of recon hits.

          reconHit->SetX( x );
          reconHit->SetY( y );
          reconHit->SetZ( z );
          reconHit->SetAngleX( angleX );
          reconHit->SetAngleY( angleY );

          reconHit->SetLineColor( 2 );

          sprintf( rmName, "Angle%s", hitName );  // Rotation matrix name.
          TRotMatrix *rm = new TRotMatrix( rmName, rmName, 90, 0, 90, 90, angle, 90 );

          TNNode *newnode = new TNNode( hitName, hitName, reconHit, 0.0, y, z, rm );

          newnode->setObject( reconHit );
          newnode->SetParent( m_AllHitsY );

          m_TkrReconNodeList->Add( newnode );

          ++nhit;

        }

        yLast = y;
        
        zLastY = z;

        ++nHitsY;

      }

    }

  }

}


void TkrDisplay::setVisibility( Int_t vis ) {

  // Set visibility of tracker planes and hits.
  // Note: -2 = "node not drawn, sons not drawn", 2 = "node not drawn, sons drawn".

  switch( vis ) {

  case( kHideX ):
    m_AllHitsX->SetVisibility( -2 );
    m_AllHitsY->SetVisibility( 2 );
    break;

  case( kHideY ):
    m_AllHitsX->SetVisibility( 2 );
    m_AllHitsY->SetVisibility( -2 );
    break;

  case( kHideAll ):
    m_AllHitsX->SetVisibility( -2 );
    m_AllHitsY->SetVisibility( -2 );
    break;

  case( kHideNone ):
    m_AllHitsX->SetVisibility( 2 );
    m_AllHitsY->SetVisibility( 2 );
    break;

  }

}

---