CCoordinate.h
//-----------------------------------------------------------------------------
// $Header: /asis/offline/ceres/cool/project/RCS/CCoordinate.h,v 2.1 1996/10/04 08:43:22 voigt Exp messer $
//
// COOL Program Library
// Copyright (C) CERES collaboration, 1996
//
// Declaration of coordinate classes.
//
// Detector Coordinates:
// ---------------------
// CRichPadCoord: x,y in pad units from raw data
// CPadCPadCoord: x,y in pad units from raw data
// CSidcCellCoord: anode, timebin from raw data
//
// Lab Coordinates:
// ----------------
// CRichPolarCoord: theta [mrad], phi [rad]
// all detector specific corrections applied.
// CRichXYCoord: x [mrad], y [mrad]
// all detector specific corrections applied.
//
// CLabCylinderCoord r [cm], phi [rad], z [cm]
// all detector specific corrections applied.
// CLabXYZCoord x [cm], y [cm], z [cm]
// all detector specific corrections applied.
// CEventCoord theta [mrad], phi [rad], z [cm]
// taking the vertex position into account.
// CEventXYZCoord dito in x, y, and z [all cm].
//
// Note that, the Rich coordinates differ from the other
// ones since 'z' doesn't play any role. Rich detectors
// measure 'theta' only.
//
// CLabCylinderCoord and CLabXYZCoord are used for both SiDCs and the
// pad chamber. Both measure absolute lab coordinates.
//
// Transformation routines are defined according to the referring scope:
// CLabCylinderCoord <-> CLabXYZCoord transform(to, from) (see below)
// CRichPolarCoord <-> CRichXYCoord CRich::transform(to, from)
// CRichPadCoord <-> CRichXYCoord CRich::transform(to, from)
// CSidcCellCoord <-> CLabCylinderCoord CSidc::transform(to, from)
// CSidcCellCoord <-> CLabXYZCoord CSidc::transform(to, from)
// CPadCPadCoord <-> CLabCylinderCoord CPadChamber::transform(to, from)
// CPadCPadCoord <-> CLabXYZCoord CPadChamber::transform(to, from)
// CEventCoord <-> CLabXYZCoord CVertex::transform(to, from)
// CEventCoord <-> CLabCylinderCoord CVertex::transform(to, from)
// CEventCoord <-> CEventXYZCoord transform(to, from) (see below)
// CEventXYZCoord <-> CLabCylinderCoord CVertex::transform(to, from)
// CEventXYZCoord <-> CLabCylinderCoord CVertex::transform(to, from)
//
// Please remember that overloading doesn't work between inherited classes.
// In some cases it's necessary to use the scope operator ::
// The compiler will tell you when ...
//
//-----------------------------------------------------------------------------
#ifndef CCOORDINATE_H
#define CCOORDINATE_H
#include "cool.h"
#include "CAngle.h"
class CRichPolarCoord {
public:
CRichPolarCoord() { theta = phi = 0; }
CRichPolarCoord(double th, double ph) {theta = th; phi = CAngle(ph);}
CRichPolarCoord(double th, CAngle ph) {theta = th; phi = ph;}
CBoolean operator== (const CRichPolarCoord& ) const;
public:
double getTheta() const { return theta; }
CAngle getPhi() const { return phi; }
void setTheta(const double t) { theta = t; }
void setPhi(const CAngle p) { phi = p; }
private:
double theta; // in mrad
CAngle phi; // in rad
};
class CRichXYCoord {
public:
CRichXYCoord() { x = y = 0; }
CRichXYCoord(double xx, double yy) {x = xx; y = yy;}
friend double abs(const CRichXYCoord &);
CBoolean operator== (const CRichXYCoord& ) const;
CRichXYCoord operator-= (const CRichXYCoord &);
CRichXYCoord operator+= (const CRichXYCoord &);
friend CRichXYCoord operator- (const CRichXYCoord &, const CRichXYCoord &);
friend CRichXYCoord operator+ (const CRichXYCoord &, const CRichXYCoord &);
public:
double getX() const { return x; }
double getY() const { return y; }
void setX(const double xx) { x = xx; }
void setY(const double yy) { y = yy; }
private:
double x; // in mrad
double y; // in mrad
};
class CRichPadCoord {
public:
CRichPadCoord() { x = y = 0; }
CRichPadCoord(double xx, double yy) {x = xx; y = yy;}
friend double abs(const CRichPadCoord &);
CBoolean operator== (const CRichPadCoord& ) const;
CRichPadCoord operator-= (const CRichPadCoord &);
CRichPadCoord operator+= (const CRichPadCoord &);
friend CRichPadCoord operator- (const CRichPadCoord &, const CRichPadCoord &);
friend CRichPadCoord operator+ (const CRichPadCoord &, const CRichPadCoord &);
public:
double getX() const { return x; }
double getY() const { return y; }
void setX(const double xx) { x = xx; }
void setY(const double yy) { y = yy; }
private:
double x; // in pads
double y; // in pads
};
class CPadCPadCoord {
public:
CPadCPadCoord() { x = y = 0; }
CPadCPadCoord(double xx, double yy) {x = xx; y = yy;}
friend double abs(const CPadCPadCoord &);
CBoolean operator== (const CPadCPadCoord& ) const;
CPadCPadCoord operator-= (const CPadCPadCoord &);
CPadCPadCoord operator+= (const CPadCPadCoord &);
friend CPadCPadCoord operator- (const CPadCPadCoord &, const CPadCPadCoord &);
friend CPadCPadCoord operator+ (const CPadCPadCoord &, const CPadCPadCoord &);
public:
double getX() const { return x; }
double getY() const { return y; }
void setX(const double xx) { x = xx; }
void setY(const double yy) { y = yy; }
private:
double x; // in pads
double y; // in pads
};
class CSidcCellCoord {
public:
CSidcCellCoord() { anode = timeBin = 0; }
CSidcCellCoord(double a, double t) {anode = a; timeBin = t;}
CBoolean operator== (const CSidcCellCoord& ) const;
public:
double getAnode() const { return anode; }
double getTimeBin() const { return timeBin; }
void setAnode(const double a) { anode = a; }
void setTimeBin(const double t) { timeBin = t; }
private:
double anode; // 0-359
double timeBin; // 0-255
};
class CLabXYZCoord;
class CLabCylinderCoord {
public:
friend void transform(CLabXYZCoord&, const CLabCylinderCoord&);
friend void transform(CLabCylinderCoord&, const CLabXYZCoord&);
public:
CLabCylinderCoord() { radius = phi = z = 0; }
CLabCylinderCoord(double r, CAngle ph, double zz) {radius = r; phi = ph; z = zz;}
CLabCylinderCoord(double r, double ph, double zz) {radius = r; phi = CAngle(ph); z = zz;}
CBoolean operator== (const CLabCylinderCoord& ) const;
CLabCylinderCoord operator-= (const CLabCylinderCoord &);
CLabCylinderCoord operator+= (const CLabCylinderCoord &);
friend double abs(const CLabCylinderCoord &); // abs in cm
friend CLabCylinderCoord operator- (const CLabCylinderCoord &, const CLabCylinderCoord &);
friend CLabCylinderCoord operator+ (const CLabCylinderCoord &, const CLabCylinderCoord &);
public:
double getRadius() const { return radius; }
CAngle getPhi() const { return phi; }
double getZ() const { return z; }
double getTheta() const { return (z!=0 ? atan2(radius,z)*1000. : 0); } // in mrad
void setRadius(const double r) { radius = r; }
void setPhi(const CAngle p) { phi = p; }
void setPhi(const double p) { phi = CAngle(p); }
void setZ(const double zz) { z = zz; }
private:
double radius; // in cm
CAngle phi; // in rad
double z; // in cm
};
class CLabXYZCoord {
public:
friend void transform(CLabXYZCoord&, const CLabCylinderCoord&);
friend void transform(CLabCylinderCoord&, const CLabXYZCoord&);
public:
CLabXYZCoord() { x = y = z = 0; }
CLabXYZCoord(double xx, double yy, double zz) {x = xx; y = yy; z = zz;}
CBoolean operator== (const CLabXYZCoord& ) const;
CLabXYZCoord operator-= (const CLabXYZCoord &);
CLabXYZCoord operator+= (const CLabXYZCoord &);
friend double abs(const CLabXYZCoord &); // abs in cm
friend CLabXYZCoord operator- (const CLabXYZCoord &, const CLabXYZCoord &);
friend CLabXYZCoord operator+ (const CLabXYZCoord &, const CLabXYZCoord &);
friend double operator* (const CLabXYZCoord &, const CLabXYZCoord &);
public:
double getX() const { return x; }
double getY() const { return y; }
double getZ() const { return z; }
void setX(const double xx) { x = xx; }
void setY(const double yy) { y = yy; }
void setZ(const double zz) { z = zz; }
private:
double x; // in cm
double y; // in cm
double z; // in cm
};
class CEventXYZCoord;
class CEventCoord {
public:
friend void transform(CEventXYZCoord&, const CEventCoord&);
friend void transform(CEventCoord&, const CEventXYZCoord&);
public:
CEventCoord() { theta = phi = z = 0; }
CEventCoord(double th, CAngle ph, double newZ) {theta = th; phi = ph; z = newZ;}
CBoolean operator== (const CEventCoord& ) const;
public:
double getTheta() const { return theta; }
CAngle getPhi() const { return phi; }
double getZ() const { return z; }
void setTheta(const double t) { theta = t; }
void setPhi(const CAngle p) { phi = p; }
void setPhi(const double p) { phi = CAngle(p); }
void setZ(const double newZ) { z = newZ; }
private:
double theta; // in mrad
CAngle phi; // in rad
double z; // in cm
};
class CEventXYZCoord {
public:
friend void transform(CEventXYZCoord&, const CEventCoord&);
friend void transform(CEventCoord&, const CEventXYZCoord&);
public:
CEventXYZCoord() { x = y = z = 0; }
CEventXYZCoord(double newX, double newY, double newZ) {x = newX; y = newY; z = newZ;}
CBoolean operator== (const CEventXYZCoord& ) const;
public:
double getX() const { return x; }
double getY() const { return y; }
double getZ() const { return z; }
void setX(const double newX) { x = newX; }
void setY(const double newY) { y = newY; }
void setZ(const double newZ) { z = newZ; }
friend double abs(const CEventXYZCoord &); // abs in cm
friend CEventXYZCoord operator- (const CEventXYZCoord &, const CEventXYZCoord &);
friend CEventXYZCoord operator+ (const CEventXYZCoord &, const CEventXYZCoord &);
friend double operator* (const CEventXYZCoord &, const CEventXYZCoord &);
private:
double x; // in cm
double y; // in cm
double z; // in cm
};
void transform(CLabXYZCoord&, const CLabCylinderCoord&);
void transform(CLabCylinderCoord&, const CLabXYZCoord&);
void transform(CEventXYZCoord&, const CEventCoord&);
void transform(CEventCoord&, const CEventXYZCoord&);
ostream& operator<<(ostream& ost, const CRichPolarCoord&);
ostream& operator<<(ostream& ost, const CRichXYCoord&);
ostream& operator<<(ostream& ost, const CRichPadCoord&);
ostream& operator<<(ostream& ost, const CLabXYZCoord&);
ostream& operator<<(ostream& ost, const CLabCylinderCoord&);
ostream& operator<<(ostream& ost, const CSidcCellCoord&);
ostream& operator<<(ostream& ost, const CEventCoord&);
ostream& operator<<(ostream& ost, const CEventXYZCoord&);
#endif /* CCOORDINATE_H */