Changeset 8829 for trunk

Timestamp:

01/24/08 11:25:48 (17 years ago)

Author:

tbretz

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars

Files:

• Changelog (modified) (1 diff)
• mpointing/MPointing.cc (modified) (1 diff)
• mpointing/MPointing.h (modified) (1 diff)

trunk/MagicSoft/Mars/Changelog

@@ -18 +18 @@
 
                                                  -*-*- END OF LINE -*-*-
+
+ 2008/01/24 Thomas Bretz
+
+   * mpointing/MPointing.cc:
+     - added ClassImp for RaDec
+
+   * mpointing/MPointing.h:
+     - added code for classes AltAz and RaDec deriving from TVector2
+       not to be used in Mars and Cosy
+
+
 
  2008/01/24 Daniel Hoehne

trunk/MagicSoft/Mars/mpointing/MPointing.cc

@@ -92 +92 @@
 ClassImp(AltAz);
 ClassImp(ZdAz);
+ClassImp(RaDec);
 ClassImp(MPointing);
 

trunk/MagicSoft/Mars/mpointing/MPointing.h

@@ -19 +19 @@
 
 // ---------------------------------------------------
-// FIXME: Replace coord.h completely with this!
-//#ifndef __MARS__
-//#include "coord.h"
-//#else
-class AltAz : public TVector2
+
+#define XY TVector2
+
+inline TVector2 Div(const TVector2 &v1, const TVector2 &v2)
+{
+    return TVector2(v1.X()/v2.X(), v1.Y()/v2.Y());
+}
+inline TVector2 Mul(const TVector2 &v1, const TVector2 &v2)
+{
+    return TVector2(v1.X()*v2.X(), v1.Y()*v2.Y());
+}
+
+inline TVector2 operator-(const TVector2 &v) { return TVector2(-v.X(), -v.Y()); }
+
+class AltAz : public XY
 {
 public:
-    AltAz(Double_t alt, Double_t az) : TVector2(alt, az)
-    {
-    }
-    AltAz(const AltAz &aa) : TVector2(aa) { }
-    Double_t Alt() const { return fX; }
-    Double_t Az() const  { return fY; }
-    ClassDef(AltAz, 1)
+    AltAz(double alt=0, double az=0) : XY(alt, az) {}
+
+    double Alt() const { return fX; }
+    double Az()  const { return fY; }
+
+    void operator*=(double c) { fX*=c; fY*=c; }
+    void operator/=(double c) { fX*=c; fY*=c; }
+
+    void Alt(double d) { fX=d; }
+    void Az(double d)  { fY=d; }
+    void operator*=(const XY &c)    { fX*=c.X(); fY*=c.Y(); }
+    void operator/=(const XY &c)    { fX/=c.X(); fY/=c.Y(); }
+    void operator-=(const AltAz &c) { fX-=c.fX; fY-=c.fY; }
+    void operator+=(const AltAz &c) { fX+=c.fX; fY+=c.fY; }
+
+    AltAz operator/(double c) const { return AltAz(fX/c, fY/c); }
+    AltAz operator*(double c) const { return AltAz(fX*c, fY*c); }
+    AltAz operator*(const XY &c) const { return AltAz(fX*c.X(), fY*c.Y()); }
+    AltAz operator/(const XY &c) const { return AltAz(fX/c.X(), fY/c.Y()); }
+    AltAz operator+(const AltAz &c) const { return AltAz(fX+c.fX, fY+c.fY); }
+    AltAz operator-(const AltAz &c) const { return AltAz(fX-c.fX, fY-c.fY); }
+    AltAz operator-() const { return AltAz(-fX, -fY); }
+
+    ClassDef(AltAz, 0)
 };
 
-class ZdAz : public TVector2
+class ZdAz : public XY
 {
 public:
-    ZdAz(Double_t zd, Double_t az) : TVector2(zd, az)
-    {
-    }
-    ZdAz(const ZdAz &aa) : TVector2(aa) { }
-    Double_t Zd() const { return fX; }
-    Double_t Az() const { return fY; }
-    ClassDef(ZdAz, 1)
+    ZdAz(double zd=0, double az=0) : XY(zd, az) {}
+    ZdAz(const ZdAz &c) : XY(c) {}
+
+    void operator*=(double c) { fX*=c; fY*=c; }
+    void operator/=(double c) { fX*=c; fY*=c; }
+
+    double Zd() const { return fX; }
+    double Az() const { return fY; }
+
+    void Zd(double d) { fX=d; }
+    void Az(double d) { fY=d; }
+    void operator*=(const XY &c)   { fX*=c.X(); fY*=c.Y(); }
+    void operator/=(const XY &c)   { fX/=c.X(); fY/=c.Y(); }
+    void operator-=(const ZdAz &c) { fX-=c.fX; fY-=c.fY; }
+    void operator+=(const ZdAz &c) { fX+=c.fX; fY+=c.fY; }
+
+    ZdAz operator/(double c) const { return ZdAz(fX/c, fY/c); }
+    ZdAz operator*(double c) const { return ZdAz(fX*c, fY*c); }
+    ZdAz operator*(const XY &c) const { return ZdAz(fX*c.X(), fY*c.Y()); }
+    ZdAz operator/(const XY &c) const { return ZdAz(fX/c.X(), fY/c.Y()); }
+    ZdAz operator+(const ZdAz &c) const { return ZdAz(fX+c.fX, fY+c.fY); }
+    ZdAz operator-(const ZdAz &c) const { return ZdAz(fX-c.fX, fY-c.fY); }
+    ZdAz operator-() const { return ZdAz(-fX, -fY); }
+
+    // MSlewing only?!?
+    double Ratio() const { return fX/fY; }
+    void Round()         { fX=(int)(floor(fX+.5)); fY=(int)(floor(fY+.5)); }
+
+    ClassDef(ZdAz, 0)
 };
-//#endif
+
+class RaDec : public XY
+{
+public:
+    RaDec(double ra=0, double dec=0) : XY(ra, dec) {}
+
+    double Ra()  const { return fX; }
+    double Dec() const { return fY; }
+
+    void operator*=(double c) { fX*=c; fY*=c; }
+    void operator/=(double c) { fX*=c; fY*=c; }
+
+    void Ra(double x)  { fX = x; }
+    void Dec(double y) { fY = y; }
+
+    RaDec operator/(double c) const { return RaDec(fX/c, fY/c); }
+    RaDec operator*(double c) const { return RaDec(fX*c, fY*c); }
+    RaDec operator*(const XY &c) const { return RaDec(fX*c.X(), fY*c.Y()); }
+    RaDec operator+(const RaDec &c) const { return RaDec(fX+c.fX, fY+c.fY); }
+    RaDec operator-(const RaDec &c) const { return RaDec(fX-c.fX, fY-c.fY); }
+    RaDec operator-() const { return RaDec(-fX, -fY); }
+
+    ClassDef(RaDec, 0)
+};
+
 // ---------------------------------------------------