CTPPSGeometryInfo.cc

Go to the documentation of this file.

/****************************************************************************
 *
 * Authors:
 *  Jan Kašpar (jan.kaspar@gmail.com)
 *
 ****************************************************************************/

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESWatcher.h"

#include "Geometry/Records/interface/IdealGeometryRecord.h"
#include "Geometry/Records/interface/VeryForwardRealGeometryRecord.h"
#include "Geometry/Records/interface/VeryForwardMisalignedGeometryRecord.h"
#include "Geometry/VeryForwardGeometryBuilder/interface/CTPPSGeometry.h"

#include "DataFormats/CTPPSDetId/interface/CTPPSDetId.h"
#include "DataFormats/CTPPSDetId/interface/TotemRPDetId.h"
#include "DataFormats/CTPPSDetId/interface/TotemTimingDetId.h"
#include "DataFormats/CTPPSDetId/interface/CTPPSPixelDetId.h"
#include "DataFormats/CTPPSDetId/interface/CTPPSDiamondDetId.h"

#include <iostream>
#include <iomanip>

//----------------------------------------------------------------------------------------------------

class CTPPSGeometryInfo : public edm::one::EDAnalyzer<>
{
  public:
    explicit CTPPSGeometryInfo( const edm::ParameterSet& );

  private:
    std::string geometryType_;

    bool printRPInfo_, printSensorInfo_;

    edm::ESWatcher<IdealGeometryRecord> watcherIdealGeometry_;
    edm::ESWatcher<VeryForwardRealGeometryRecord> watcherRealGeometry_;
    edm::ESWatcher<VeryForwardMisalignedGeometryRecord> watcherMisalignedGeometry_;

    void analyze( const edm::Event&, const edm::EventSetup& ) override;

    static std::string formatDetId( const CTPPSDetId &id, bool printDetails = true );

    void printGeometry( const CTPPSGeometry &, const edm::Event& );
};

//----------------------------------------------------------------------------------------------------

CTPPSGeometryInfo::CTPPSGeometryInfo( const edm::ParameterSet& iConfig ) :
  geometryType_   ( iConfig.getUntrackedParameter<std::string>( "geometryType", "real" ) ),
  printRPInfo_    ( iConfig.getUntrackedParameter<bool>( "printRPInfo", true ) ),
  printSensorInfo_( iConfig.getUntrackedParameter<bool>( "printSensorInfo", true ) )
{}

//----------------------------------------------------------------------------------------------------

void
CTPPSGeometryInfo::analyze( const edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  edm::ESHandle<CTPPSGeometry> geometry;

  if ( geometryType_ == "ideal" ) {
    if ( watcherIdealGeometry_.check( iSetup ) ) {
      iSetup.get<IdealGeometryRecord>().get( geometry );
      printGeometry( *geometry, iEvent );
    }
    return;
  }

  else if ( geometryType_ == "real" ) {
    if ( watcherRealGeometry_.check( iSetup ) ) {
      iSetup.get<VeryForwardRealGeometryRecord>().get( geometry );
      printGeometry( *geometry, iEvent );
    }
    return;
  }

  else if ( geometryType_ == "misaligned" ) {
    if ( watcherMisalignedGeometry_.check( iSetup ) ) {
      iSetup.get<VeryForwardMisalignedGeometryRecord>().get( geometry );
      printGeometry( *geometry, iEvent );
    }
    return;
  }

  throw cms::Exception("CTPPSGeometryInfo") << "Unknown geometry type: `" << geometryType_ << "'.";
}

//----------------------------------------------------------------------------------------------------

std::string
CTPPSGeometryInfo::formatDetId( const CTPPSDetId &id, bool printDetails )
{
  std::ostringstream oss;
  oss << id.rawId();

  const unsigned int rpDecId = id.arm()*100 + id.station()*10 + id.rp();

  if ( id.subdetId() == CTPPSDetId::sdTrackingStrip ) {
    TotemRPDetId fid( id );
    oss << " (strip RP " << std::setw(3) << rpDecId;
    if ( printDetails )
      oss <<  ", plane " << fid.plane();
    oss << ")";
  }

  else if ( id.subdetId() == CTPPSDetId::sdTrackingPixel ) {
    CTPPSPixelDetId fid( id );
    oss << " (pixel RP " << std::setw(3) << rpDecId;
    if ( printDetails )
      oss <<  ", plane " << fid.plane();
    oss << ")";
  }

  else if ( id.subdetId() == CTPPSDetId::sdTimingDiamond ) {
    CTPPSDiamondDetId fid( id );
    oss << " (diamd RP " << std::setw(3) << rpDecId;
    if ( printDetails )
      oss <<  ", plane " << fid.plane() << ", channel " << std::setw(2) << fid.channel();
    oss << ")";
  }

  else if ( id.subdetId() == CTPPSDetId::sdTimingFastSilicon ) {
    TotemTimingDetId fid( id );
    oss << " (totim RP " << std::setw(3) << rpDecId;
    if ( printDetails )
      oss <<  ", plane " << fid.plane() << ", channel " << std::setw(2) << fid.channel();
    oss << ")";
  }

  return oss.str();
}

//----------------------------------------------------------------------------------------------------

void
CTPPSGeometryInfo::printGeometry( const CTPPSGeometry& geometry, const edm::Event& event )
{
  time_t unixTime = event.time().unixTime();
  char timeStr[50];
  strftime( timeStr, 50, "%F %T", localtime( &unixTime ) );

  std::ostringstream oss;

  // RP geometry
  if ( printRPInfo_ ) {
    oss << "* RPs:\n"
        << "    ce: RP center in global coordinates, in mm\n";

    for ( auto it = geometry.beginRP(); it != geometry.endRP(); ++it ) {
      const DDTranslation &t = it->second->translation();

      oss << formatDetId( CTPPSDetId( it->first ), false )
        << std::fixed << std::setprecision( 3 ) << std::showpos
        << " | ce=(" << t.x() << ", " << t.y() << ", " << t.z() << ")\n";
    }

    edm::LogVerbatim("CTPPSGeometryInfo") << oss.str();
  }

  // sensor geometry
  if ( printSensorInfo_ ) {
    oss << "* sensors:\n"
      << "    ce: sensor center in global coordinates, in mm\n"
      << "    a1: local axis (1, 0, 0) in global coordinates\n"
      << "    a2: local axis (0, 1, 0) in global coordinates\n"
      << "    a3: local axis (0, 0, 1) in global coordinates\n";

    for ( auto it = geometry.beginSensor(); it != geometry.endSensor(); ++it ) {
      CTPPSDetId detId( it->first );

      const CLHEP::Hep3Vector gl_o  = geometry.localToGlobal( detId, CLHEP::Hep3Vector( 0, 0, 0 ) );
      const CLHEP::Hep3Vector gl_a1 = geometry.localToGlobal( detId, CLHEP::Hep3Vector( 1, 0, 0 ) ) - gl_o;
      const CLHEP::Hep3Vector gl_a2 = geometry.localToGlobal( detId, CLHEP::Hep3Vector( 0, 1, 0 ) ) - gl_o;
      const CLHEP::Hep3Vector gl_a3 = geometry.localToGlobal( detId, CLHEP::Hep3Vector( 0, 0, 1 ) ) - gl_o;

      oss << formatDetId( detId )
        << std::fixed << std::setprecision( 3 ) << std::showpos
        << " | ce=(" << gl_o.x() << ", " << gl_o.y() << ", " << gl_o.z() << ")"
        << " | a1=(" << gl_a1.x() << ", " << gl_a1.y() << ", " << gl_a1.z() << ")"
        << " | a2=(" << gl_a2.x() << ", " << gl_a2.y() << ", " << gl_a2.z() << ")"
        << " | a3=(" << gl_a3.x() << ", " << gl_a3.y() << ", " << gl_a3.z() << ")\n";
    }
  }

  edm::LogInfo("CTPPSGeometryInfo")
    << "New " << geometryType_ << " geometry found in run="
    << event.id().run() << ", event=" << event.id().event() << ", UNIX timestamp=" << unixTime
    << " (" << timeStr << ")\n"
    << oss.str();
}

//----------------------------------------------------------------------------------------------------

DEFINE_FWK_MODULE( CTPPSGeometryInfo );