---

VisTrackingGeometry.cc

Go to the documentation of this file.

//<<<<<< INCLUDES                                                       >>>>>>

#include "VisReco/VisRecoGeometry/interface/VisTrackingGeometry.h"
#include "VisFramework/VisFrameworkBase/interface/debug.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
#include "Geometry/CommonDetUnit/interface/GeomDetType.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
#include "DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h"
#include "DataFormats/GeometrySurface/interface/TkRotation.h"
#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
#include "Iguana/Inventor/interface/IgSoG4Trap.h"
#include "Iguana/Inventor/interface/IgSoCube.h"
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoIndexedFaceSet.h>
#include <Inventor/nodes/SoIndexedTriangleStripSet.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoAnnotation.h>
#include <Inventor/nodes/SoTransform.h>
#include <iostream>

//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>

SoSeparator*            
VisTrackingGeometry::buildDet (DetectorRep type, edm::ESHandle<TrackerGeometry> &pDD, int subDetector)
{
    SoSeparator *sep = new SoSeparator;    
 
    SoMaterial *mat = new SoMaterial;
    mat->ambientColor.setValue (0.88445997, 0.840042, 0.53582799);
    mat->diffuseColor.setValue (0.66334498, 0.630032, 0.401871);
    mat->specularColor.setValue (0.49999201, 0.49999201, 0.49999201);
    mat->emissiveColor.setValue (0, 0, 0);
    mat->shininess = 0.1;
    mat->transparency = 0;
    sep->addChild (mat);

    for (TrackingGeometry::DetUnitContainer::const_iterator idet = pDD->detUnits ().begin (); idet != pDD->detUnits ().end (); idet++)    
    {
        if ((**idet).type ().subDetector () == subDetector)
        {
            if (visible ((*idet)->surface ().position (), type, subDetector))
            {
                SoSeparator* separator = new SoSeparator;
                addWafer (separator, *idet,type);
                sep->addChild (separator);
            }
        } 
    }
    return sep;
}

SoSeparator*            
VisTrackingGeometry::buildDet (DetectorRep type, std::vector<const GeomDetUnit *>& detUnits)
{
    SoSeparator *sep = new SoSeparator;    
 
    SoMaterial *mat = new SoMaterial;
    mat->ambientColor.setValue (0.88445997, 0.840042, 0.53582799);
    mat->diffuseColor.setValue (0.66334498, 0.630032, 0.401871);
    mat->specularColor.setValue (0.49999201, 0.49999201, 0.49999201);
    mat->emissiveColor.setValue (0, 0, 0);
    mat->shininess = 0.1;
    mat->transparency = 0;
    sep->addChild (mat);
    for (std::vector<const GeomDetUnit *>::const_iterator idet = detUnits.begin (); idet != detUnits.end (); idet++)    
    {

            if (visible ( (*idet)->surface ().position (), type, (**idet).type ().subDetector ()))
            {
                SoSeparator* separator = new SoSeparator;
                addWafer (separator, *idet,type);
                sep->addChild (separator);
            }
    }
    return sep;
}

SoAnnotation*
VisTrackingGeometry::buildDet_anno (DetectorRep type, std::vector<const GeomDetUnit *>& detUnits)
{
    SoAnnotation *sep = new SoAnnotation;

    SoMaterial *mat = new SoMaterial;
    mat->ambientColor.setValue (0.88445997, 0.840042, 0.53582799);
    mat->diffuseColor.setValue (0.66334498, 0.630032, 0.401871);
    mat->specularColor.setValue (0.49999201, 0.49999201, 0.49999201);
    mat->emissiveColor.setValue (0, 0, 0);
    mat->shininess = 0.1;
    mat->transparency = 0;
    sep->addChild (mat);
    for (std::vector<const GeomDetUnit *>::const_iterator idet = detUnits.begin (); idet != detUnits.end (); idet++)
    {
        SoAnnotation* separator = new SoAnnotation;
        addWafer (separator, *idet, type);
        sep->addChild (separator);
    }
    return sep;
}

bool
VisTrackingGeometry::visible (const GlobalPoint & point, DetectorRep type, int subDetector)
{
    bool visible = false;
    double width = 1.0;
    double length = 10.0;
    if (subDetector == GeomDetEnumerators::TOB) width = 10.0;
    if (subDetector == GeomDetEnumerators::TIB) width = 5.5;
    if (subDetector == GeomDetEnumerators::TID) width = 15.0;
    if (subDetector == GeomDetEnumerators::TEC) width = 30.0;
    if (subDetector == GeomDetEnumerators::CSC) width = 55.0;


    switch (type)
    {
    case FullDet:
        visible = true;
        //point.z () > 0. ? visible = true : visible = false;
        //visible = false;
        break;
    case RZDet:
        if (subDetector == GeomDetEnumerators::TID || subDetector == GeomDetEnumerators::TEC) point.x () < width ? visible = true : visible = false; 
     else {
            if(subDetector == GeomDetEnumerators::PixelEndcap)visible = true ; else fabs (point.x ()) < width ? visible = true : visible = false;
            }
        break;
    case RPhiDet:
        fabs (point.z ()) < length ? visible = true : visible = false;
        break;
    case CSCME1:
        fabs( point.z ()) < 800. ? visible = true : visible = false;
        break; 
    case CSCME2:
        fabs( point.z ()) > 800. && fabs( point.z ()) < 900. ? 
            visible = true : visible = false;
        break;
    case CSCME3:
        fabs( point.z ()) > 900. && fabs( point.z ()) < 1000. ? 
            visible = true : visible = false;
        break;
        //     visible = false;
    case CSCME4:
        fabs( point.z ()) > 1000. ? visible = true : visible = false;
        break;
    default:
        break;
    }
    
    return visible;
}

void
VisTrackingGeometry::addWafer (SoSeparator *separator, const GeomDetUnit *det, DetectorRep type)
{    
    // position of the wafer's center
    float posx = det->surface ().position ().x () / 100.0;  // cm -> m
    float posy = det->surface ().position ().y () / 100.0;  // cm -> m
    float posz = det->surface ().position ().z () / 100.0;  // cm -> m
    if(type==RZDet) {posx=0;posy=sqrt(det->surface ().position ().x ()*det->surface ().position ().x ()+det->surface ().position ().y ()*det->surface ().position ().y ()) / 100.0; if (det->surface ().position ().y () < 0.0)posy = - posy;}
    float angle;
    SbVec3f axis;
    createRotation (det, axis, angle);
    SoTransform *transform = new SoTransform;
    transform->translation.setValue (posx, posy, posz);
    if(type==RZDet){
     int subdet = det->geographicalId().subdetId(); 
     if(subdet==1 || subdet==3 || subdet==5)//barrel
      {
          SbMatrix sbm (1, 0, 0, 0,
                        0, 0, -1, 0,
                        0, 1, 0, 0,
                        0, 0, 0, 1);
    SbRotation sbr (sbm);
    sbr.getValue (axis, angle);
           transform->rotation.setValue (axis, angle);
        }  else transform->rotation.setValue (axis, angle);
        }  else transform->rotation.setValue (axis, angle);

    // Trapezoidal
    const Bounds *b = &((det->surface ()).bounds ());
    if (dynamic_cast<const TrapezoidalPlaneBounds *> (b))
    {
        const TrapezoidalPlaneBounds *b2 = dynamic_cast<const TrapezoidalPlaneBounds *> (b);
        std::vector< float > par = b2->parameters ();
        
        // these parameters are half-lengths, as in CMSIM/GEANT3
        float hBottomEdge = par [0];
        float hTopEdge    = par [1];
        float thickness   = par [2];
        float apothem     = par [3];

        IgSoG4Trap *g4Trap = new IgSoG4Trap ();
        g4Trap->dz = thickness / 100.; 
        g4Trap->dy1 = apothem / 100.;
        g4Trap->dy2 = apothem / 100.;
        g4Trap->dx1 = hBottomEdge / 100.;
        g4Trap->dx2 = hTopEdge / 100.;
        g4Trap->dx3 = hBottomEdge / 100.;
        g4Trap->dx4 = hTopEdge / 100.;
        g4Trap->alp1 = 0.0;
        g4Trap->alp2 = 0.0;
        separator->addChild (transform);
        separator->addChild (g4Trap);
    }
    if (dynamic_cast<const RectangularPlaneBounds *> (b))
    {
        IgSoCube *cube = new IgSoCube ();
            
        // Rectangular
        float length = det->surface ().bounds ().length () / 100.0; // cm -> m
        float width = det->surface ().bounds ().width () / 100.0;   // cm -> m
        float thickness = det->surface ().bounds ().thickness () / 100.0;  // cm -> m
        
        transform->scaleFactor.setValue (width, length, thickness);
        separator->addChild (transform);
        separator->addChild (cube);
    }
}

void
VisTrackingGeometry::createRotation (const GeomDetUnit *det, SbVec3f & axis, float & angle)
{    
    // Extract the coeff of the rotation matrix
    // with a projection on the basis vectors
    TkRotation< float > rot = det->surface ().rotation ();
    Basic3DVector< float > nx (1., 0., 0.); // x basis vector
    Basic3DVector< float > ny (0., 1., 0.); // y basis vector
    Basic3DVector< float > nz (0., 0., 1.); // z basis vector
    Basic3DVector< float > px = rot * nx; // Rxx Ryx Rzx
    Basic3DVector< float > py = rot * ny; // Rxy Ryy Rzy
    Basic3DVector< float > pz = rot * nz; // Rxz Ryz Rzz
    /* the rotation matrix is
     *  Rxx Rxy Rxz
     *  Ryx Ryy Ryz
     *  Rzx Rzy Rzz
     */
    // SbMatrix in row major order.
    // The 4th dimension is set empiricly set to
    // the identity
    SbMatrix sbm (px.x (), py.x (), pz.x (), 0,
                  px.y (), py.y (), pz.y (), 0,
                  px.z (), py.z (), pz.z (), 0,
                  0, 0, 0, 1);
    SbRotation sbr (sbm);

    float x;
    float y;
    float z;

    sbr.getValue (axis, angle);
    axis.getValue (x, y, z);
}

void
VisTrackingGeometry::addBoxWafer (SoSeparator *separator, const GeomDetUnit *det)
{    
    const int NVERT = 8;

    Basic3DVector< float > nx (1., 0., 0.); // x basis vector
    Basic3DVector< float > ny (0., 1., 0.); // y basis vector
    Basic3DVector< float > nz (0., 0., 1.); // z basis vector

    float posx = 0.;
    float posy = 0.;
    float posz = 0.;
    float x = 0.;
    float y = 0.;
    float z = 0.;

    static int faceIndices[] = 
        {0, 4, 3, 7, 2, 6, 1, 5, 0, 4, SO_END_FACE_INDEX,
         1, 0, 2, 3, SO_END_FACE_INDEX,
         6, 7, 5, 4, SO_END_FACE_INDEX
        };     

    static SoIndexedTriangleStripSet *detFaceSet = 0;
    if (detFaceSet == 0)
    {
        detFaceSet = new SoIndexedTriangleStripSet;
        detFaceSet->coordIndex.setValues(0, sizeof (faceIndices)/sizeof (int), faceIndices);
    }
    
    TkRotation< float > detRot = det->surface ().rotation ();
    Basic3DVector< float > px = detRot * nx; // Rxx Ryx Rzx
    Basic3DVector< float > py = detRot * ny; // Rxy Ryy Rzy
    Basic3DVector< float > pz = detRot * nz; // Rxz Ryz Rzz

    // set the rotation matrix
    SbMatrix rotMatrix (px.x (), py.x (), pz.x (), 0,
                        px.y (), py.y (), pz.y (), 0,
                        px.z (), py.z (), pz.z (), 0,
                        0, 0, 0, 1);

    // position of the wafer's center
    posx = det->surface ().position ().x () / 100.0;  // cm -> m
    posy = det->surface ().position ().y () / 100.0;  // cm -> m
    posz = det->surface ().position ().z () / 100.0;  // cm -> m

    x = det->surface ().bounds ().width () / 100.0;   // cm -> m
    y = det->surface ().bounds ().length () / 100.0; // cm -> m
    z = det->surface ().bounds ().thickness () / 100.0;  // cm -> m
                
    SbVec3f points [NVERT] = {
        SbVec3f ( 0.5f, -0.5f, -0.5f),      // Origin (0, 0, 0) in the center of the cube:
        SbVec3f ( 0.5f,  0.5f, -0.5f),      //   7------6      Z
        SbVec3f ( 0.5f,  0.5f,  0.5f),      //  /|     /|      |
        SbVec3f ( 0.5f, -0.5f,  0.5f),      // 3------2 |      |
        SbVec3f (-0.5f, -0.5f, -0.5f),      // | 4----|-5     /--->Y
        SbVec3f (-0.5f,  0.5f, -0.5f),      // |/     |/     /
        SbVec3f (-0.5f,  0.5f,  0.5f),      // 0------1     X
        SbVec3f (-0.5f, -0.5f,  0.5f)       // 
    };
    
    SoMFVec3f vertexData;
    vertexData.setValues (0, NVERT, points);

    SoCoordinate3 *detCoords = new SoCoordinate3;
    detCoords->point = vertexData;
    
    SoTransform *detTransform = new SoTransform;
    detTransform->translation.setValue (posx, posy, posz);
    detTransform->rotation = SbRotation (rotMatrix);
    detTransform->scaleFactor.setValue (x, y, z);

    // Create the separator for the faces.
    SoSeparator *facesNode = new SoSeparator;
    facesNode->addChild (detTransform);
    facesNode->addChild (detCoords);
    facesNode->addChild (detFaceSet);

    separator->addChild (facesNode);
}

int
VisTrackingGeometry::subDetector (const std::string &key) 
{ 
    std::map<std::string, GeomDetEnumerators::SubDetector> type; 

    type ["PixelBarrel"] = GeomDetEnumerators::PixelBarrel;
    type ["TIB"] = GeomDetEnumerators::TIB;
    type ["TOB"] = GeomDetEnumerators::TOB;
    type ["PixelEndcap"] = GeomDetEnumerators::PixelEndcap;
    type ["TID"] = GeomDetEnumerators::TID;
    type ["TEC"] = GeomDetEnumerators::TEC;
    type ["CSC"] = GeomDetEnumerators::CSC;

    return type [key]; 
}

---