SegmentationUtil.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
//==========================================================================
/*
 * SegmentationUtil.h
 *
 *  Created on: Oct 31, 2013
 *      Author: Christian Grefe, CERN
 */
 
#ifndef DDSEGMENTATION_SEGMENTATIONUTIL_H
#define DDSEGMENTATION_SEGMENTATIONUTIL_H
 
#include <DDSegmentation/Segmentation.h>
 
#include <cmath>
#include <vector>
 
namespace dd4hep {
namespace DDSegmentation {
namespace Util {
 
 
 
 
 
inline double magFromXYZ(const Vector3D& position) {
    return std::sqrt(position.X * position.X + position.Y * position.Y + position.Z * position.Z);
}
 
inline double radiusFromXYZ(const Vector3D& position) {
    return std::sqrt(position.X * position.X + position.Y * position.Y);
}
 
inline double cosThetaFromXYZ(const Vector3D& position) {
    return position.Z / magFromXYZ(position);
}
 
inline double thetaFromXYZ(const Vector3D& position) {
    return std::acos(cosThetaFromXYZ(position));
}
 
inline double phiFromXYZ(const Vector3D& position) {
    return std::atan2(position.Y, position.X);
}
 
// implementation taken from ROOT TVector3D
inline double etaFromXYZ(const Vector3D& aposition) {
    double cosTheta = cosThetaFromXYZ(aposition);
    if (cosTheta*cosTheta < 1) return -0.5* std::log((1.0-cosTheta)/(1.0+cosTheta));
    if (aposition.Z == 0) return 0;
    //Warning("PseudoRapidity","transvers momentum = 0! return +/- 10e10");
    if (aposition.Z > 0) return 10e10;
    else return -10e10;
}
 
 
inline Vector3D positionFromRPhiZ(double r, double phi, double z) {
    return Vector3D(r * std::cos(phi), r * std::sin(phi), z);
}
 
inline double magFromRPhiZ(double r, double /* phi */, double z) {
    return std::sqrt(r * r + z * z);
}
 
inline double xFromRPhiZ(double r, double phi, double /* z */) {
    return r * std::cos(phi);
}
 
inline double yFromRPhiZ(double r, double phi, double /* z */) {
    return r * std::sin(phi);
}
 
inline double thetaFromRPhiZ(double r, double /* phi */, double z) {
    return r * std::atan(z / r);
}
 
 
inline Vector3D positionFromRThetaPhi(double r, double theta, double phi) {
    return Vector3D(r * std::cos(phi), r * std::sin(phi), r * std::tan(theta));
}
 
inline Vector3D positionFromMagThetaPhi(double mag, double theta, double phi) {
    double r = mag * sin(theta);
    return Vector3D(r * std::cos(phi), r * std::sin(phi), mag * std::cos(theta));
}
inline Vector3D positionFromREtaPhi(double ar, double aeta, double aphi) {
    return Vector3D(ar * std::cos(aphi), ar * std::sin(aphi), ar * std::sinh(aeta));
}
 
 
} /* namespace Util */
} /* namespace DDSegmentation */
} /* namespace dd4hep */
 
#endif // DDSEGMENTATION_SEGMENTATIONUTIL_H