BuilderUtils.cc

Go to the documentation of this file.

#include "Fireworks/Core/interface/BuilderUtils.h"
#include "Fireworks/Core/interface/Context.h"
#include "Fireworks/Core/interface/FWProxyBuilderBase.h"

#include "FWCore/Common/interface/EventBase.h"

#include "TGeoBBox.h"
#include "TColor.h"
#include "TROOT.h"
#include "TEveBox.h"
#include "TEveScalableStraightLineSet.h"
#include "TEveStraightLineSet.h"
#include "TEveTrans.h"
#include "TEveGeoNode.h"

#include <cmath>
#include <ctime>

namespace fireworks
{
   std::pair<double,double> getPhiRange( const std::vector<double>& phis, double phi )
   {
      double min =  100;
      double max = -100;

      for( std::vector<double>::const_iterator i = phis.begin();
           i != phis.end(); ++i )
      {
         double aphi = *i;
         // make phi continuous around jet phi
         if( aphi - phi > M_PI ) aphi -= 2*M_PI;
         if( phi - aphi > M_PI ) aphi += 2*M_PI;
         if( aphi > max ) max = aphi;
         if( aphi < min ) min = aphi;
      }

      if( min > max ) return std::pair<double,double>( 0, 0 );

      return std::pair<double,double>( min, max );
   }

   TEveGeoShape* getShape( const char* name,
                           TGeoBBox* shape,
                           Color_t color )
   {
      TEveGeoShape* egs = new TEveGeoShape( name );
      TColor* c = gROOT->GetColor( color );
      Float_t rgba[4] = { 1, 0, 0, 1 };
      if( c )
      {
         rgba[0] = c->GetRed();
         rgba[1] = c->GetGreen();
         rgba[2] = c->GetBlue();
      }
      egs->SetMainColorRGB( rgba[0], rgba[1], rgba[2] );
      egs->SetShape( shape );
      return egs;
   }

   void addRhoZEnergyProjection( FWProxyBuilderBase* pb, TEveElement* container,
                                 double r_ecal, double z_ecal,
                                 double theta_min, double theta_max,
                                 double phi )
   {
      TEveGeoManagerHolder gmgr( TEveGeoShape::GetGeoMangeur());
      double z1 = r_ecal / tan( theta_min );
      if( z1 > z_ecal ) z1 = z_ecal;
      if( z1 < -z_ecal ) z1 = -z_ecal;
      double z2 = r_ecal / tan( theta_max );
      if( z2 > z_ecal ) z2 = z_ecal;
      if( z2 < -z_ecal ) z2 = -z_ecal;
      double r1 = z_ecal * fabs( tan( theta_min ));
      if( r1 > r_ecal ) r1 = r_ecal;
      if( phi < 0 ) r1 = -r1;
      double r2 = z_ecal * fabs( tan( theta_max ));
      if( r2 > r_ecal ) r2 = r_ecal;
      if( phi < 0 ) r2 = -r2;

      if( fabs(r2 - r1) > 1 )
      {
         TGeoBBox *sc_box = new TGeoBBox( 0., fabs( r2 - r1 ) / 2, 1 );
         TEveGeoShape *element = new TEveGeoShape("r-segment");
         element->SetShape(sc_box);
         TEveTrans &t = element->RefMainTrans();
         t(1,4) = 0;
         t(2,4) = (r2+r1)/2;
         t(3,4) = fabs(z2)>fabs(z1) ? z2 : z1;
         pb->setupAddElement(element, container);
      }
      if( fabs(z2 - z1) > 1 )
      {
         TGeoBBox *sc_box = new TGeoBBox( 0., 1, ( z2 - z1 ) / 2 );
         TEveGeoShape *element = new TEveGeoShape("z-segment");
         element->SetShape( sc_box );
         TEveTrans &t = element->RefMainTrans();
         t(1,4) = 0;
         t(2,4) = fabs(r2)>fabs(r1) ? r2 : r1;
         t(3,4) = (z2+z1)/2;
         pb->setupAddElement(element, container);
      }
   }

   std::string getTimeGMT( const edm::EventBase& event )
   {
      time_t t( event.time().value() >> 32 );
      std::string text( asctime( gmtime( &t ) ) );
      size_t pos = text.find( '\n' );
      if( pos != std::string::npos ) text = text.substr( 0, pos );
      text += " GMT";
      return text;
   }

   std::string getLocalTime( const edm::EventBase& event )
   {

      time_t t( event.time().value() >> 32 );
      struct tm * xx =  localtime( &t );
      std::string text( asctime(xx) );
      size_t pos = text.find('\n');
      if( pos != std::string::npos ) text = text.substr( 0, pos );
      text += " ";
      if( xx->tm_isdst )
         text += tzname[1];
      else
         text += tzname[0];
      return text;
   }
  
   void invertBox( std::vector<float> &corners )
   {
      std::swap( corners[0], corners[9] );
      std::swap( corners[1], corners[10] );
      std::swap( corners[2], corners[11] );

      std::swap( corners[3], corners[6] );
      std::swap( corners[4], corners[7] );
      std::swap( corners[5], corners[8] );

      std::swap( corners[12], corners[21] );
      std::swap( corners[13], corners[22] );
      std::swap( corners[14], corners[23] );

      std::swap( corners[15], corners[18] );
      std::swap( corners[16], corners[19] );
      std::swap( corners[17], corners[20] );
   }

   void addBox( const std::vector<float> &corners, TEveElement* comp, FWProxyBuilderBase* pb )
   {
      TEveBox* eveBox = new TEveBox( "Box" );    
      eveBox->SetDrawFrame( false );
      eveBox->SetPickable( true );      
      eveBox->SetVertices( &corners[0] );

      pb->setupAddElement( eveBox, comp );
   }
   
   void addCircle( double eta, double phi, double radius, const unsigned int nLineSegments, TEveElement* comp, FWProxyBuilderBase* pb )
   {
      TEveStraightLineSet* container = new TEveStraightLineSet;
      
      for( unsigned int iphi = 0; iphi < nLineSegments; ++iphi )
      {
         container->AddLine( eta + radius * cos( 2 * M_PI / nLineSegments * iphi ),
                             phi + radius * sin( 2 * M_PI / nLineSegments * iphi ),
                             0.01,
                             eta + radius * cos( 2 * M_PI / nLineSegments * ( iphi + 1 )),
                             phi + radius * sin( 2 * M_PI / nLineSegments * ( iphi + 1 )),
                             0.01 );
      }
      pb->setupAddElement( container, comp );
   }

   void addDashedArrow( double phi, double size, TEveElement* comp, FWProxyBuilderBase* pb )
   {
      TEveScalableStraightLineSet* marker = new TEveScalableStraightLineSet;
      marker->SetLineWidth( 1 );
      marker->SetLineStyle( 2 );
      marker->AddLine( 0, 0, 0, size * cos( phi ), size * sin( phi ), 0 );
      marker->AddLine( size * 0.9 * cos( phi + 0.03 ), size * 0.9 * sin( phi + 0.03 ), 0, size * cos( phi ), size * sin( phi ), 0 );
      marker->AddLine( size * 0.9 * cos( phi - 0.03 ), size * 0.9 * sin( phi - 0.03 ), 0, size * cos( phi ), size * sin( phi ), 0 );
      pb->setupAddElement( marker, comp );      
   }
   
   void addDashedLine( double phi, double theta, double size, TEveElement* comp, FWProxyBuilderBase* pb )
   {
      double r( 0 );
      if( theta < pb->context().caloTransAngle() || M_PI - theta < pb->context().caloTransAngle())
         r = pb->context().caloZ2() / fabs( cos( theta ));
      else
         r = pb->context().caloR1() / sin( theta );
      
      TEveStraightLineSet* marker = new TEveStraightLineSet;
      marker->SetLineWidth( 2 );
      marker->SetLineStyle( 2 );
      marker->AddLine( r * cos( phi ) * sin( theta ), r * sin( phi ) * sin( theta ), r * cos( theta ),
                       ( r + size ) * cos( phi ) * sin( theta ), ( r + size ) * sin( phi ) * sin( theta ), ( r + size ) * cos( theta ));
      pb->setupAddElement( marker, comp );      
   }
   
   void addDoubleLines( double phi, TEveElement* comp, FWProxyBuilderBase* pb )
   {
      TEveStraightLineSet* mainLine = new TEveStraightLineSet;
      mainLine->AddLine( -5.191, phi, 0.01, 5.191, phi, 0.01 );
      pb->setupAddElement( mainLine, comp );
      
      phi = phi > 0 ? phi - M_PI : phi + M_PI;
      TEveStraightLineSet* secondLine = new TEveStraightLineSet;
      secondLine->SetLineStyle( 7 );
      secondLine->AddLine( -5.191, phi, 0.01, 5.191, phi, 0.01 );
      pb->setupAddElement( secondLine, comp );      
   }
   
   //______________________________________________________________________________
   void energyScaledBox3DCorners( const float* corners, float scale, std::vector<float>& scaledCorners, bool invert)
   {
      std::vector<float> centre( 3, 0 );

      for( unsigned int i = 0; i < 24; i += 3 )
      {  
         centre[0] += corners[i];
         centre[1] += corners[i + 1];
         centre[2] += corners[i + 2];
      }

      for( unsigned int i = 0; i < 3; ++i )
         centre[i] *= 1.0f / 8.0f;

      // Coordinates for a scaled version of the original box
      for( unsigned int i = 0; i < 24; i += 3 )
      { 
         scaledCorners[i] = centre[0] + ( corners[i] - centre[0] ) * scale;
         scaledCorners[i + 1] = centre[1] + ( corners[i + 1] - centre[1] ) * scale;
         scaledCorners[i + 2] = centre[2] + ( corners[i + 2] - centre[2] ) * scale;
      }
      
      if( invert )
         invertBox( scaledCorners );
   }

   void drawEnergyScaledBox3D( const float* corners, float scale, TEveElement* comp, FWProxyBuilderBase* pb, bool invert )
   {
      std::vector<float> scaledCorners( 24 );
      energyScaledBox3DCorners(corners, scale, scaledCorners, invert);
      addBox( scaledCorners, comp, pb );
   }
   //______________________________________________________________________________

   void etScaledBox3DCorners( const float* corners, float energy, float maxEnergy, std::vector<float>& scaledCorners, bool invert)
   {
      std::vector<float> centre( 3, 0 );

      for( unsigned int i = 0; i < 24; i += 3 )
      {  
         centre[0] += corners[i];
         centre[1] += corners[i + 1];
         centre[2] += corners[i + 2];
      }

      for( unsigned int i = 0; i < 3; ++i )
         centre[i] *= 1.0f / 8.0f;

      TEveVector c( centre[0], centre[1], centre[2] );
      float scale = energy / maxEnergy * sin( c.Theta());
      
      // Coordinates for a scaled version of the original box
      for( unsigned int i = 0; i < 24; i += 3 )
      { 
         scaledCorners[i] = centre[0] + ( corners[i] - centre[0] ) * scale;
         scaledCorners[i + 1] = centre[1] + ( corners[i + 1] - centre[1] ) * scale;
         scaledCorners[i + 2] = centre[2] + ( corners[i + 2] - centre[2] ) * scale;
      }
      
      if( invert )
         invertBox( scaledCorners );
   }

   void drawEtScaledBox3D( const float* corners, float energy, float maxEnergy, TEveElement* comp, FWProxyBuilderBase* pb, bool invert )
   {
      std::vector<float> scaledCorners( 24 );
      etScaledBox3DCorners(corners, energy, maxEnergy, scaledCorners, invert);
      addBox( scaledCorners, comp, pb );
   }

   //______________________________________________________________________________
   void energyTower3DCorners( const float* corners, float scale,  std::vector<float>& scaledCorners, bool reflect)
   {
      for( int i = 0; i < 24; ++i )
         scaledCorners[i] = corners[i];
      // Coordinates of a front face scaled 
      if( reflect )
      {
         // We know, that an ES rechit geometry in -Z needs correction. 
         // The back face is actually its front face.
         for( unsigned int i = 0; i < 12; i += 3 )
         {
            TEveVector diff( corners[i] - corners[i + 12], corners[i + 1] - corners[i + 13], corners[i + 2] - corners[i + 14] );
            diff.Normalize();
            diff *= scale;
        
            scaledCorners[i] = corners[i] + diff.fX;
            scaledCorners[i + 1] = corners[i + 1] + diff.fY;
            scaledCorners[i + 2] = corners[i + 2] + diff.fZ;
         }
      } 
      else
      {
         for( unsigned int i = 0; i < 12; i += 3 )
         {
            TEveVector diff( corners[i + 12] - corners[i], corners[i + 13] - corners[i + 1], corners[i + 14] - corners[i + 2] );
            diff.Normalize();
            diff *= scale;
        
            scaledCorners[i] = corners[i + 12];
            scaledCorners[i + 1] = corners[i + 13];
            scaledCorners[i + 2] = corners[i + 14];
        
            scaledCorners[i + 12] = corners[i + 12] + diff.fX;
            scaledCorners[i + 13] = corners[i + 13] + diff.fY;
            scaledCorners[i + 14] = corners[i + 14] + diff.fZ;
         }
      }
   }

   void drawEnergyTower3D( const float* corners, float scale, TEveElement* comp, FWProxyBuilderBase* pb, bool reflect )
   {
      std::vector<float> scaledCorners( 24 );
      energyTower3DCorners(corners, scale, scaledCorners, reflect);
      addBox( scaledCorners, comp, pb );
   }
  
   //______________________________________________________________________________

   void etTower3DCorners( const float* corners, float scale,  std::vector<float>& scaledCorners, bool reflect)
   {
      for( int i = 0; i < 24; ++i )
         scaledCorners[i] = corners[i];
      // Coordinates of a front face scaled 
      if( reflect )
      {
         // We know, that an ES rechit geometry in -Z needs correction. 
         // The back face is actually its front face.
         for( unsigned int i = 0; i < 12; i += 3 )
         {
            TEveVector diff( corners[i] - corners[i + 12], corners[i + 1] - corners[i + 13], corners[i + 2] - corners[i + 14] );
            diff.Normalize();
            diff *= ( scale * sin( diff.Theta()));
        
            scaledCorners[i] = corners[i] + diff.fX;
            scaledCorners[i + 1] = corners[i + 1] + diff.fY;
            scaledCorners[i + 2] = corners[i + 2] + diff.fZ;
         }
      } 
      else
      {
         for( unsigned int i = 0; i < 12; i += 3 )
         {
            TEveVector diff( corners[i + 12] - corners[i], corners[i + 13] - corners[i + 1], corners[i + 14] - corners[i + 2] );
            diff.Normalize();
            diff *= ( scale * sin( diff.Theta()));
        
            scaledCorners[i] = corners[i + 12];
            scaledCorners[i + 1] = corners[i + 13];
            scaledCorners[i + 2] = corners[i + 14];
        
            scaledCorners[i + 12] = corners[i + 12] + diff.fX;
            scaledCorners[i + 13] = corners[i + 13] + diff.fY;
            scaledCorners[i + 14] = corners[i + 14] + diff.fZ;
         }
      }
   }


   void drawEtTower3D( const float* corners, float scale, TEveElement* comp, FWProxyBuilderBase* pb, bool reflect )
   {
      std::vector<float> scaledCorners( 24 );
      etTower3DCorners(corners, scale, scaledCorners, reflect);
      addBox( scaledCorners, comp, pb );
   }


} // namespace fireworks