Index: trunk/MagicSoft/Cosy/main/MBending.cc
===================================================================
--- trunk/MagicSoft/Cosy/main/MBending.cc	(revision 2384)
+++ trunk/MagicSoft/Cosy/main/MBending.cc	(revision 2407)
@@ -1,2 +1,60 @@
+/* ======================================================================== *\
+!
+! *
+! * This file is part of MARS, the MAGIC Analysis and Reconstruction
+! * Software. It is distributed to you in the hope that it can be a useful
+! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
+! * It is distributed WITHOUT ANY WARRANTY.
+! *
+! * Permission to use, copy, modify and distribute this software and its
+! * documentation for any purpose is hereby granted without fee,
+! * provided that the above copyright notice appear in all copies and
+! * that both that copyright notice and this permission notice appear
+! * in supporting documentation. It is provided "as is" without express
+! * or implied warranty.
+! *
+!
+!
+!   Author(s): Thomas Bretz, 2003 <mailto:tbretz@astro.uni-wuerzburg.de>
+!
+!   Copyright: MAGIC Software Development, 2000-2003
+!
+!
+\* ======================================================================== */
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// MBending
+//
+//    Double_t fIe   ; // [rad] Index Error in Elevation
+//    Double_t fIa   ; // [rad] Index Error in Azimuth
+//
+//    Double_t fFlop ; // [rad] Vertical Sag
+//     * do not use if not data: Zd<0
+//
+//    Double_t fNpae ; // [rad] Az-El Nonperpendicularity
+//
+//    Double_t fCa   ; // [rad] Left-Right Collimation Error
+//
+//    Double_t fAn   ; // [rad] Azimuth Axis Misalignment (N-S)
+//    Double_t fAw   ; // [rad] Azimuth Axis Misalignment (E-W)
+//
+//    Double_t fTf   ; // [rad] Tube fluxture (sin)
+//     * same as ecec if no data: Zd<0
+//    Double_t fTx   ; // [rad] Tube fluxture (tan)
+//     * do not use with NPAE if no data: Zd<0
+//
+//    Double_t fNrx  ; // [rad] Nasmyth rotator displacement, horizontan
+//    Double_t fNry  ; // [rad] Nasmyth rotator displacement, vertical
+//
+//    Double_t fCrx  ; // [rad] Alt/Az Coude Displacement (N-S)
+//    Double_t fCry  ; // [rad] Alt/Az Coude Displacement (E-W)
+//
+//    Double_t fEces ; // [rad] Elevation Centering Error (sin)
+//    Double_t fAces ; // [rad] Azimuth Centering Error (sin)
+//    Double_t fEcec ; // [rad] Elevation Centering Error (cos)
+//    Double_t fAcec ; // [rad] Azimuth Centering Error (cos)
+//
+////////////////////////////////////////////////////////////////////////////
 #include "MBending.h"
 
@@ -10,4 +68,52 @@
 ClassImp(MBending);
 
+const Int_t MBending::fNumPar=19;
+
+void MBending::Init()
+{
+    fCoeff = new Double_t*[fNumPar];
+    fName  = new TString[fNumPar];
+    fDescr = new TString[fNumPar];
+
+    fCoeff[ 0] = &fIa;      fName[ 0] = "IA";
+    fCoeff[ 1] = &fIe;      fName[ 1] = "IE";
+    fCoeff[ 2] = &fFlop;    fName[ 2] = "FLOP";
+    fCoeff[ 3] = &fNpae;    fName[ 3] = "NPAE";
+    fCoeff[ 4] = &fCa;      fName[ 4] = "CA";
+    fCoeff[ 5] = &fAn;      fName[ 5] = "AN";
+    fCoeff[ 6] = &fAw;      fName[ 6] = "AW";
+    fCoeff[ 7] = &fTf;      fName[ 7] = "TF";
+    fCoeff[ 8] = &fTx;      fName[ 8] = "TX";
+    fCoeff[ 9] = &fEces;    fName[ 9] = "ECES";
+    fCoeff[10] = &fAces;    fName[10] = "ACES";
+    fCoeff[11] = &fEcec;    fName[11] = "ECEC";
+    fCoeff[12] = &fAcec;    fName[12] = "ACEC";
+    fCoeff[13] = &fNrx;     fName[13] = "NRX";
+    fCoeff[14] = &fNry;     fName[14] = "NRY";
+    fCoeff[15] = &fCrx;     fName[15] = "CRX";
+    fCoeff[16] = &fCry;     fName[16] = "CRY";
+    fCoeff[17] = &fMagic1;  fName[17] = "MAGIC1";
+    fCoeff[18] = &fMagic2;  fName[18] = "MAGIC2";
+
+    fDescr[ 0] =  "Index Error Azimuth";
+    fDescr[ 1] =  "Index Error Zenith Distance";
+    fDescr[ 2] =  "Vertical Sag";
+    fDescr[ 3] =  "Az-El Nonperpendicularity";
+    fDescr[ 4] =  "Left-Right Collimation Error";
+    fDescr[ 5] =  "Azimuth Axis Misalignment (N-S)";
+    fDescr[ 6] =  "Azimuth Axis Misalignment (E-W)";
+    fDescr[ 7] =  "Tube fluxture (sin)";
+    fDescr[ 8] =  "Tube fluxture (tan)";
+    fDescr[ 9] =  "Elevation Centering Error (sin)";
+    fDescr[10] =  "Azimuth Centering Error (sin)";
+    fDescr[11] =  "Elevation Centering Error (cos)";
+    fDescr[12] =  "Azimuth Centering Error (cos)";
+    fDescr[13] =  "Nasmyth rotator displacement (horizontal)";
+    fDescr[14] =  "Nasmyth rotator displacement (vertical)";
+    fDescr[15] =  "Alt/Az Coude Displacement (N-S)";
+    fDescr[16] =  "Alt/Az Coude Displacement (E-W)";
+    fDescr[17] =  "n/a";
+    fDescr[18] =  "n/a";
+}
 void MBending::Reset()
 {
@@ -62,6 +168,6 @@
     cout << endl;
 
-    cout << "  & = Name      Value           Sigma" << endl;
-    cout << "------------------------------------------" << endl;
+    cout << "  & = Name            Value                  Sigma" << endl;
+    cout << "--------------------------------------------------" << endl;
 
     while (fin)
@@ -90,26 +196,40 @@
 
         fin >> val;
-        cout << str << "\t" << val << "°      \t";
+        cout << str << "\t" << setw(11) << val << "°     \t";
         val *= kDeg2Rad;
 
-        if (str=="IA")     fIa   = val;
-        if (str=="IE")     fIe   = val;
-        if (str=="CA")     fCa   = val;
-        if (str=="AN")     fAn   = val;
-        if (str=="AW")     fAw   = val;
-        if (str=="NRX")    fNrx  = val;
-        if (str=="NRY")    fNry  = val;
-        if (str=="CRX")    fCrx  = val;
-        if (str=="CRY")    fCry  = val;
-        if (str=="NPAE")   fNpae = val;
-        if (str=="ECES")   fEces = val;
-        if (str=="ACES")   fAces = val;
-        if (str=="ECEC")   fEcec = val;
-        if (str=="ACEC")   fAcec = val;
-        //if (str=="MAGIC1") fMagic1 = val;
-        //if (str=="MAGIC2") fMagic2 = val;
+        Double_t *dest=NULL;
+
+        if (str=="IA")   dest = &fIa;
+        if (str=="IE")   dest = &fIe;
+        if (str=="FLOP") dest = &fFlop;
+        if (str=="NPAE") dest = &fNpae;
+        if (str=="CA")   dest = &fCa;
+        if (str=="AN")   dest = &fAn;
+        if (str=="AW")   dest = &fAw;
+        if (str=="TF")   dest = &fTf;
+        if (str=="TX")   dest = &fTx;
+        if (str=="NRX")  dest = &fNrx;
+        if (str=="NRY")  dest = &fNry;
+        if (str=="CRX")  dest = &fCrx;
+        if (str=="CRY")  dest = &fCry;
+        if (str=="ECES") dest = &fEces;
+        if (str=="ACES") dest = &fAces;
+        if (str=="ECEC") dest = &fEcec;
+        if (str=="ACEC") dest = &fAcec;
+
+        if (dest)
+            *dest = val;
 
         fin >> val;
-        cout << val*kDeg2Rad << endl;
+        cout << setw(9) << val << "°" << endl;
+
+        // Find corresponding error
+        for (int i=0; i<MBending::GetNumPar(); i++)
+            if (dest==fCoeff[i])
+            {
+                fError[i] = val*kDeg2Rad;
+                break;
+            }
     }
     cout << endl;
@@ -143,21 +263,19 @@
     fout << "S   00   000000   000000  0000000" << endl;
     fout << setprecision(8);
-    fout << " IA     " << kRad2Deg*fIa   << " -1" << endl;
-    fout << " IE     " << kRad2Deg*fIe   << " -1" << endl;
-    fout << " CA     " << kRad2Deg*fNpae << " -1" << endl;
-    fout << " NPAE   " << kRad2Deg*fCa   << " -1" << endl;
-    fout << " AN     " << kRad2Deg*fAn   << " -1" << endl;
-    fout << " AW     " << kRad2Deg*fAw   << " -1" << endl;
-    fout << " NRX    " << kRad2Deg*fNrx  << " -1" << endl;
-    fout << " NRY    " << kRad2Deg*fNry  << " -1" << endl;
-    fout << " CRX    " << kRad2Deg*fCrx  << " -1" << endl;
-    fout << " CRY    " << kRad2Deg*fCry  << " -1" << endl;
-    fout << " ECES   " << kRad2Deg*fEces << " -1" << endl;
-    fout << " ACES   " << kRad2Deg*fAces << " -1" << endl;
-    fout << " ECEC   " << kRad2Deg*fEcec << " -1" << endl;
-    fout << " ACEC   " << kRad2Deg*fAcec << " -1" << endl;
-    //fout << " MAGIC1 " << -kRad2Deg*fMagic1 << " -1" << endl;
-    //fout << " MAGIC2 " << -kRad2Deg*fMagic2 << " -1" << endl;
+    for (int i=0; i<fNumPar; i++)
+    {
+        fout << " " << setw(6) << GetName(i) << " ";
+        fout << setw(13) << *fCoeff[i]*kRad2Deg << "   ";
+        fout << setw(11) << fError[i]*kRad2Deg << endl;
+    }
     fout << "END" << endl;
+}
+
+Double_t MBending::Sign(Double_t val, Double_t alt)
+{
+    // Some pointing corrections are defined as Delta ZA, which
+    // is (P. Wallace) defined [0,90]deg while Alt is defined
+    // [0,180]deg
+    return (TMath::Pi()/2-alt < 0 ? -val : val);
 }
 
@@ -167,4 +285,14 @@
     // zdaz    [rad]
     AltAz p = aa;
+
+    const AltAz CRX(-fCrx*sin(p.Az()-p.Alt()),  fCrx*cos(p.Az()-p.Alt())/cos(p.Alt()));
+    const AltAz CRY(-fCry*cos(p.Az()-p.Alt()), -fCry*sin(p.Az()-p.Alt())/cos(p.Alt()));
+    p += CRX;
+    p += CRY;
+
+    const AltAz NRX(fNrx*sin(p.Alt()), -fNrx);
+    const AltAz NRY(fNry*cos(p.Alt()), -fNry*tan(p.Alt()));
+    p += NRX;
+    p += NRY;
 
     const AltAz CES(-fEces*sin(p.Alt()), -fAces*sin(p.Az()));
@@ -173,19 +301,8 @@
     p += CEC;
 
-    //    const AltAz MAGIC(0, -fMagic1*tan(p.Alt())-fMagic2);
-    //    p += MAGIC;
-
-    const AltAz CRX(-fCrx*sin(p.Az()-p.Alt()),  fCrx*cos(p.Az()-p.Alt())/cos(p.Alt()));
-    const AltAz CRY(-fCry*cos(p.Az()-p.Alt()), -fCry*sin(p.Az()-p.Alt())/cos(p.Alt()));
-    p += CRX;
-    p += CRY;
-
-    const AltAz NRX(fNrx*sin(p.Alt()), -fNrx);
-    const AltAz NRY(fNry*cos(p.Alt()), -fNry*tan(p.Alt()));
-    p += NRX;
-    p += NRY;
-
-    //    const AltAz MAGIC(-fMagic1*sin(p.Az()-fMagic2), 0);
-    //    p += MAGIC;
+    const AltAz TX(Sign(fTx/tan(p.Alt()), p.Alt()), 0);
+    const AltAz TF(Sign(fTf*cos(p.Alt()), p.Alt()), 0);
+    p += TX;
+    p += TF;
 
     const AltAz AW( fAw*sin(p.Az()), -fAw*cos(p.Az())*tan(p.Alt()));
@@ -194,7 +311,4 @@
     p += AN;
 
-    //    const AltAz MAGIC(-fMagic1*sin(p.Az()-fMagic2), 0);
-    //    p += MAGIC;
-
     const AltAz CA(0, -fCa/cos(p.Alt()));
     p += CA;
@@ -202,4 +316,7 @@
     const AltAz NPAE(0, -fNpae*tan(p.Alt()));
     p += NPAE;
+
+    const AltAz FLOP(Sign(fFlop, p.Alt()), 0);
+    p += FLOP;
 
     const AltAz I(fIe, fIa);
@@ -217,4 +334,7 @@
     const AltAz I(fIe, fIa);
     p -= I;
+
+    const AltAz FLOP(Sign(fFlop, p.Alt()), 0);
+    p -= FLOP;
 
     const AltAz NPAE(0, -fNpae*tan(p.Alt()));
@@ -229,6 +349,13 @@
     p -= AW;
 
-    //    const AltAz MAGIC(-fMagic1*sin(p.Az()-fMagic2), 0);
-    //    p -= MAGIC;
+    const AltAz TF(Sign(fTf*cos(p.Alt()), p.Alt()), 0);
+    const AltAz TX(Sign(fTx/tan(p.Alt()), p.Alt()), 0);
+    p -= TF;
+    p -= TX;
+
+    const AltAz CEC(-fEcec*cos(p.Alt()), -fAcec*cos(p.Az()));
+    const AltAz CES(-fEces*sin(p.Alt()), -fAces*sin(p.Az()));
+    p -= CEC;
+    p -= CES;
 
     const AltAz NRY(fNry*cos(p.Alt()), -fNry*tan(p.Alt()));
@@ -241,9 +368,4 @@
     p -= CRY;
     p -= CRX;
-
-    const AltAz CEC(-fEcec*cos(p.Alt()), -fAcec*cos(p.Az()));
-    const AltAz CES(-fEces*sin(p.Alt()), -fAces*sin(p.Az()));
-    p -= CEC;
-    p -= CES;
 
     return p;
@@ -272,78 +394,12 @@
     Clear();
 
-    switch (n)
-    {
-    case 16:
-        fMagic2=par[15]/kRad2Deg; // Magic User Defined
-    case 15:
-        fMagic1=par[14]/kRad2Deg; // Magic User Defined
-    case 14:
-        fAcec =par[13]/kRad2Deg; // Azimuth Centering Error (cos)
-    case 13:
-        fEcec =par[12]/kRad2Deg; // Elevation Centering Error (cos)
-    case 12:
-        fAces =par[11]/kRad2Deg; // Azimuth Centering Error (sin)
-    case 11:
-        fEces =par[10]/kRad2Deg; // Elevation Centering Error (sin)
-    case 10:
-        fCry  =par[9] /kRad2Deg; // Alt/Az Coude Displacement (E-W)
-    case 9:
-        fCrx  =par[8] /kRad2Deg; // Alt/Az Coude Displacement (N-S)
-    case 8:
-        fNry  =par[7] /kRad2Deg; // Nasmyth rotator displacement, vertical
-    case 7:
-        fNrx  =par[6] /kRad2Deg; // Nasmyth rotator displacement, horizontan
-    case 6:
-        fAw   =par[5] /kRad2Deg; // Azimuth Axis Misalignment (E-W)
-    case 5:
-        fAn   =par[4] /kRad2Deg; // Azimuth Axis Misalignment (N-S)
-    case 4:
-        fCa   =par[3] /kRad2Deg; // Left-Right Collimation Error
-    case 3:
-        fNpae =par[2] /kRad2Deg; // Az-El Nonperpendicularity
-    case 2:
-        fIe   =par[1] /kRad2Deg; // Index Error in Elevation
-    case 1:
-        fIa   =par[0] /kRad2Deg; // Index Error in Azimuth
-    }
+    while (n--)
+        *fCoeff[n] = par[n]/kRad2Deg;
 }
 
 void MBending::GetParameters(Double_t *par, Int_t n) const
 {
-    switch (n)
-    {
-    case 16:
-        par[15]=kRad2Deg*fMagic2; //
-    case 15:
-        par[14]=kRad2Deg*fMagic1; //
-    case 14:
-        par[13]=kRad2Deg*fAcec; // Azimuth Centering Error (cos)
-    case 13:
-        par[12]=kRad2Deg*fEcec; // Elevation Centering Error (cos)
-    case 12:
-        par[11]=kRad2Deg*fAces; // Azimuth Centering Error (sin)
-    case 11:
-        par[10]=kRad2Deg*fEces; // Elevation Centering Error (sin)
-    case 10:
-        par[9] =kRad2Deg*fCry;  // Alt/Az Coude Displacement (E-W)
-    case 9:
-        par[8] =kRad2Deg*fCrx;  // Alt/Az Coude Displacement (N-S)
-    case 8:
-        par[7] =kRad2Deg*fNry;  // Nasmyth rotator displacement, vertical
-    case 7:
-        par[6] =kRad2Deg*fNrx;  // Nasmyth rotator displacement, horizontan
-    case 6:
-        par[5] =kRad2Deg*fAw;   // Azimuth Axis Misalignment (E-W)
-    case 5:
-        par[4] =kRad2Deg*fAn;   // Azimuth Axis Misalignment (N-S)
-    case 4:
-        par[3] =kRad2Deg*fCa;   // Left-Right Collimation Error
-    case 3:
-        par[2] =kRad2Deg*fNpae; // Az-El Nonperpendicularity
-    case 2:
-        par[1] =kRad2Deg*fIe;   // Index Error in Elevation
-    case 1:
-        par[0] =kRad2Deg*fIa;   // Index Error in Azimuth
-    }
+    while (n--)
+        par[n] = *fCoeff[n]*kRad2Deg;
 }
 
@@ -351,43 +407,10 @@
 {
     if (n<0)
-        n = 16;
+        n = fNumPar;
 
     Int_t ierflg = 0;
 
-    switch (n)
-    {
-    case 16:
-        m.mnparm(15,"MAGIC2", fMagic2*kRad2Deg,  1, -360, 360, ierflg);
-    case 15:
-        m.mnparm(14,"MAGIC1", fMagic1*kRad2Deg,  1, -360, 360, ierflg);
-    case 14:
-        m.mnparm(13,"ACEC", fAcec*kRad2Deg,  1, -360, 360, ierflg);
-    case 13:
-        m.mnparm(12,"ECEC", fEcec*kRad2Deg,  1, -360, 360, ierflg);
-    case 12:
-        m.mnparm(11,"ACES", fAcec*kRad2Deg,  1, -360, 360, ierflg);
-    case 11:
-        m.mnparm(10,"ECES", fEcec*kRad2Deg,  1, -360, 360, ierflg);
-    case 10:
-        m.mnparm(9, "CRY",  fCry*kRad2Deg,  1, -360, 360, ierflg);
-    case 9:
-        m.mnparm(8, "CRX",  fCrx*kRad2Deg,  1, -360, 360, ierflg);
-    case 8:
-        m.mnparm(7, "NRY",  fNry*kRad2Deg,  1, -360, 360, ierflg);
-    case 7:
-        m.mnparm(6, "NRX",  fNrx*kRad2Deg,  1, -360, 360, ierflg);
-    case 6:
-        m.mnparm(5, "AW",   fAw*kRad2Deg,   1, -360, 360, ierflg);
-    case 5:
-        m.mnparm(4, "AN",   fAn*kRad2Deg,   1, -360, 360, ierflg);
-    case 4:
-        m.mnparm(3, "CA",   fCa*kRad2Deg,   1, -360, 360, ierflg);
-    case 3:
-        m.mnparm(2, "NPAE", fNpae*kRad2Deg, 1, -360, 360, ierflg);
-    case 2:
-        m.mnparm(1, "IE",   fIe*kRad2Deg,   1,  -90,  90, ierflg);
-    case 1:
-        m.mnparm(0, "IA",   fIa*kRad2Deg,   1, -360, 360, ierflg);
-    }
+    while (n--)
+        m.mnparm(n, fName[n], *fCoeff[n]*kRad2Deg,  1, -360, 360, ierflg);
 }
 
@@ -397,56 +420,9 @@
         n = m.GetNumPars();
 
-    Double_t err;
-
-    switch (n)
-    {
-    case 16:
-        m.GetParameter(15, fMagic2, err);
-        fMagic2 /= kRad2Deg;
-    case 15:
-        m.GetParameter(14, fMagic1, err);
-        fMagic1 /= kRad2Deg;
-    case 14:
-        m.GetParameter(13, fAcec, err);
-        fAcec /= kRad2Deg;
-    case 13:
-        m.GetParameter(12, fEcec, err);
-        fEcec /= kRad2Deg;
-    case 12:
-        m.GetParameter(11, fAces, err);
-        fAces /= kRad2Deg;
-    case 11:
-        m.GetParameter(10, fEces, err);
-        fEces /= kRad2Deg;
-    case 10:
-        m.GetParameter(9, fCry, err);
-        fCry /= kRad2Deg;
-    case 9:
-        m.GetParameter(8, fCrx, err);
-        fCrx /= kRad2Deg;
-    case 8:
-        m.GetParameter(7, fNry, err);
-        fNry /= kRad2Deg;
-    case 7:
-        m.GetParameter(6, fNrx, err);
-        fNrx /= kRad2Deg;
-    case 6:
-        m.GetParameter(5, fAw, err);
-        fAw /= kRad2Deg;
-    case 5:
-        m.GetParameter(4, fAn, err);
-        fAn /= kRad2Deg;
-    case 4:
-        m.GetParameter(3, fCa, err);
-        fCa /= kRad2Deg;
-    case 3:
-        m.GetParameter(2, fNpae, err);
-        fNpae /= kRad2Deg;
-    case 2:
-        m.GetParameter(1, fIe, err);
-        fIe /= kRad2Deg;
-    case 1:
-        m.GetParameter(0, fIa, err);
-        fIa /= kRad2Deg;
+    while (n--)
+    {
+        m.GetParameter(n, *fCoeff[n], fError[n]);
+        *fCoeff[n] /= kRad2Deg;
+        fError[n]  /= kRad2Deg;
     }
 }
@@ -480,54 +456,9 @@
     Double_t par, err;
 
-    switch (n)
-    {
-    case 16:
-        m.GetParameter(15, par, err);
-        cout << " 15 MAGIC2: " << setw(8) << par << " +- " << setw(4) <<  err << endl;
-    case 15:
-        m.GetParameter(14, par, err);
-        cout << " 14 MAGIC1: " << setw(8) << par << " +- " << setw(4) <<  err << endl;
-    case 14:
-        m.GetParameter(13, par, err);
-        cout << " 13 ACEC:   " << setw(8) << par << " +- " << setw(4) <<  err << "  Azimuth Centering Error (cos)" << endl;
-    case 13:
-        m.GetParameter(12, par, err);
-        cout << " 12 ECEC:   " << setw(8) << par << " +- " << setw(4) <<  err << "  Elevation Centering Error (cos)" << endl;
-    case 12:
-        m.GetParameter(11, par, err);
-        cout << " 11 ACES:   " << setw(8) << par << " +- " << setw(4) <<  err << "  Azimuth Centering Error (sin)" << endl;
-    case 11:
-        m.GetParameter(10, par, err);
-        cout << " 10 ECES:   " << setw(8) << par << " +- " << setw(4) <<  err << "  Elevation Centering Error (sin)" << endl;
-    case 10:
-        m.GetParameter(9, par, err);
-        cout << "  9 CRY:    " << setw(8) << par << " +- " << setw(4) <<  err << "  Alt/Az Coude Displacement (E-W)" << endl;
-    case 9:
-        m.GetParameter(8, par, err);
-        cout << "  8 CRX:    " << setw(8) << par << " +- " << setw(4) <<  err << "  Alt/Az Coude Displacement (N-S)" << endl;
-    case 8:
-        m.GetParameter(7, par, err);
-        cout << "  7 NRY:    " << setw(8) << par << " +- " << setw(4) <<  err << "  Nasmyth rotator displacement, vertical" << endl;
-    case 7:
-        m.GetParameter(6, par, err);
-        cout << "  6 NRX:    " << setw(8) << par << " +- " << setw(4) <<  err << "  Nasmyth rotator displacement, horizontan" << endl;
-    case 6:
-        m.GetParameter(5, par, err);
-        cout << "  5 AW:     " << setw(8) << par << " +- " << setw(4) <<  err << "  Azimuth Axis Misalignment (E-W)" << endl;
-    case 5:
-        m.GetParameter(4, par, err);
-        cout << "  4 AN:     " << setw(8) << par << " +- " << setw(4) <<  err << "  Azimuth Axis Misalignment (N-S)" << endl;
-    case 4:
-        m.GetParameter(3, par, err);
-        cout << "  3 CA:     " << setw(8) << par << " +- " << setw(4) <<  err << "  Left-Right Collimation Error" << endl;
-    case 3:
-        m.GetParameter(2, par, err);
-        cout << "  2 NPAE:   " << setw(8) << par << " +- " << setw(4) <<  err << "  Az-El Nonperpendicularity" << endl;
-    case 2:
-        m.GetParameter(1, par, err);
-        cout << "  1 IE:     " << setw(8) << par << " +- " << setw(4) <<  err << "  Index Error Elevation (Offset)" << endl;
-    case 1:
-        m.GetParameter(0, par, err);
-        cout << "  0 IA:     " << setw(8) << par << " +- " << setw(4) <<  err << "  Index Error Azimuth (Offset)" << endl;
-    }
-}
+    while (n--)
+    {
+        m.GetParameter(n, par, err);
+        cout << Form(" %2d %6s: ", n, (const char*)fName[n]);
+        cout << setw(8) << par << " \xb1 " << setw(6) <<  err << endl;
+    }
+}
Index: trunk/MagicSoft/Cosy/main/MBending.h
===================================================================
--- trunk/MagicSoft/Cosy/main/MBending.h	(revision 2384)
+++ trunk/MagicSoft/Cosy/main/MBending.h	(revision 2407)
@@ -3,4 +3,8 @@
 
 #include "coord.h"
+
+#ifndef ROOT_TArrayD
+#include <TArrayD.h>
+#endif
 
 class TMinuit;
@@ -9,11 +13,16 @@
 {
 private:
+    static const Int_t fNumPar;
+
     Double_t fIe   ; // [rad] Index Error in Elevation
     Double_t fIa   ; // [rad] Index Error in Azimuth
+    Double_t fFlop ; // [rad] Vertical Sag
+    Double_t fNpae ; // [rad] Az-El Nonperpendicularity
     Double_t fCa   ; // [rad] Left-Right Collimation Error
     Double_t fAn   ; // [rad] Azimuth Axis Misalignment (N-S)
     Double_t fAw   ; // [rad] Azimuth Axis Misalignment (E-W)
-    Double_t fNpae ; // [rad] Az-El Nonperpendicularity
-    Double_t fNrx  ; // [rad] Nasmyth rotator displacement, horizontan
+    Double_t fTf   ; // [rad] Tube fluxture (sin)
+    Double_t fTx   ; // [rad] Tube fluxture (tan)
+    Double_t fNrx  ; // [rad] Nasmyth rotator displacement, horizontal
     Double_t fNry  ; // [rad] Nasmyth rotator displacement, vertical
     Double_t fCrx  ; // [rad] Alt/Az Coude Displacement (N-S)
@@ -26,28 +35,27 @@
     Double_t fMagic2; // [rad] Magic Term (what is it?)
 
+    Double_t **fCoeff; //!
+    TString   *fName;  //!
+    TString   *fDescr; //!
+
+    TArrayD   fError;
+
+    void Init();
 
     void Clear()
     {
-        fIe  =0 ; // Index Error in Elevation
-        fIa  =0 ; // Index Error in Azimuth
-        fCa  =0 ; // Left-Right Collimation Error
-        fAn  =0 ; // Azimuth Axis Misalignment (N-S)
-        fAw  =0 ; // Azimuth Axis Misalignment (E-W)
-        fNpae=0 ; // Az-El Nonperpendicularity
-        fNrx =0 ; // Nasmyth rotator displacement, horizontan
-        fNry =0 ; // Nasmyth rotator displacement, vertical
-        fCrx =0 ; // Alt/Az Coude Displacement (N-S)
-        fCry =0 ; // Alt/Az Coude Displacement (E-W)
-        fEces=0 ; // Elevation Centering Error (sin)
-        fAces=0 ; // Azimuth Centering Error (sin)
-        fEcec=0 ; // Elevation Centering Error (cos)
-        fAcec=0 ; // Azimuth Centering Error (cos)
-        fMagic1=0; // Azimuth Centering Error (cos)
-        fMagic2=0; // Azimuth Centering Error (cos)
+        for (int i=0; i<fNumPar; i++)
+        {
+            *fCoeff[i] = 0;
+            fError[i] = 0;
+        }
     }
 
+    static Double_t Sign(Double_t val, Double_t alt);
+
 public:
-    MBending() { Clear(); }
-    MBending(const char *name) { Clear(); Load(name); }
+    MBending() { fError.Set(fNumPar); Init(); Clear(); }
+    MBending(const char *name) { fError.Set(fNumPar); Init(); Clear(); Load(name); }
+    virtual ~MBending() { delete fName; delete fCoeff; delete fDescr; }
 
     void Load(const char *name);
@@ -67,5 +75,5 @@
     ZdAz operator()(const ZdAz &zdaz, void (*fcn)(ZdAz &zdaz, Double_t *par)) const
     {
-        Double_t par[16];
+        Double_t par[fNumPar];
         GetParameters(par);
         ZdAz za = zdaz;
@@ -76,5 +84,5 @@
     AltAz operator()(const AltAz &aaz, void (*fcn)(AltAz &aaz, Double_t *par)) const
     {
-        Double_t par[16];
+        Double_t par[fNumPar];
         GetParameters(par);
         AltAz aa = aaz;
@@ -83,10 +91,29 @@
     }
 
-    void SetParameters(const Double_t *par, Int_t n=16);
-    void GetParameters(Double_t *par, Int_t n=16) const;
+    void SetParameters(const Double_t *par, Int_t n=fNumPar);
+    void GetParameters(Double_t *par, Int_t n=fNumPar) const;
+
+    void SetParameters(const TArrayD &par)
+    {
+        SetParameters(par.GetArray(), par.GetSize());
+    }
+    void GetParameters(TArrayD &par) const
+    {
+        par.Set(fNumPar);
+        GetParameters(par.GetArray());
+    }
+    void GetError(TArrayD &par) const
+    {
+        par = fError;
+        for (int i=0; i<fNumPar; i++)
+            par[i] *= kRad2Deg;
+    }
 
     void SetMinuitParameters(TMinuit &m, Int_t n=-1) const;
     void GetMinuitParameters(TMinuit &m, Int_t n=-1);
     void PrintMinuitParameters(TMinuit &m, Int_t n=-1) const;
+
+    const TString &GetName(int i) const { return fName[i]; }
+    const TString &GetDescription(int i) const { return fDescr[i]; }
 
     /*
@@ -107,4 +134,5 @@
      */
 
+    static const Int_t GetNumPar() { return fNumPar; }
     ClassDef(MBending, 1)
 };