source: trunk/MagicSoft/Mars/mtemp/MTelAxisFromStars.cc@ 4748

Last change on this file since 4748 was 4745, checked in by wittek, 21 years ago
*** empty log message ***
File size: 39.3 KB
Line 
1/* ======================================================================== *\
2!
3! *
4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5! * Software. It is distributed to you in the hope that it can be a useful
6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7! * It is distributed WITHOUT ANY WARRANTY.
8! *
9! * Permission to use, copy, modify and distribute this software and its
10! * documentation for any purpose is hereby granted without fee,
11! * provided that the above copyright notice appear in all copies and
12! * that both that copyright notice and this permission notice appear
13! * in supporting documentation. It is provided "as is" without express
14! * or implied warranty.
15! *
16!
17! Author(s): Wolfgang Wittek 07/2004 <mailto:wittek@mppmu.mpg.de>
18!
19! Copyright: MAGIC Software Development, 2000-2004
20!
21!
22\* ======================================================================== */
23
24/////////////////////////////////////////////////////////////////////////////
25//
26// MTelAxisFromStars
27//
28// This task
29// - determines the transformation from expected positions of stars
30// in the camera to measured positions of these stars in the camera
31// - applies this transformation to expected positions of other objects
32// to obtain the estimated positions of these objects in the camera
33// - puts the estimated positions into the relevant containers
34//
35// Input Containers :
36// MStarCam[MStarCam], MStarCamSource[MStarCam]
37//
38// Output Containers :
39// MSkyCamTrans, MSrcPosCam
40//
41/////////////////////////////////////////////////////////////////////////////
42#include <TList.h>
43#include <TSystem.h>
44
45#include <fstream>
46
47#include "MTelAxisFromStars.h"
48
49#include "MParList.h"
50
51
52#include "MLog.h"
53#include "MLogManip.h"
54
55#include "MReportDrive.h"
56#include "MPointingPos.h"
57#include "MSrcPosCam.h"
58
59#include "MStarCam.h"
60#include "MStarPos.h"
61#include "MSkyCamTrans.h"
62#include "MStarCamTrans.h"
63
64ClassImp(MTelAxisFromStars);
65
66using namespace std;
67
68// --------------------------------------------------------------------------
69//
70// Constructor
71//
72MTelAxisFromStars::MTelAxisFromStars(const char *name, const char *title)
73{
74 fName = name ? name : "MTelAxisFromStars";
75 fTitle = title ? title : "Calculate source position from star positions";
76
77 // if scale factor fLambda should NOT be fixed set fFixdScaleFactor to
78 // -1.0; otherwise set it to the value requested
79 fFixedScaleFactor = 1.0;
80
81 // if rotation angle fAlfa should NOT be fixed set fFixdRotationAngle to
82 // -1.0; otherwise set it to the requested value
83 fFixedRotationAngle = 0.0;
84
85 // default type of input is : the result of the Gauss fit
86 // type 0 : result from the weighted average
87 // type 1 : result from the Gauss fit
88 fInputType = 1;
89
90 // default value of fAberr
91 // the value 1.07 is valid if the expected position (with aberration)
92 // in the camera is calculated as the average of the positions obtained
93 // from the reflections at the individual mirrors
94 fAberr = 1.07;
95
96}
97
98// --------------------------------------------------------------------------
99//
100// Destructor
101//
102MTelAxisFromStars::~MTelAxisFromStars()
103{
104 delete fStarCamTrans;
105}
106
107// --------------------------------------------------------------------------
108//
109// Set links to containers
110//
111
112Int_t MTelAxisFromStars::PreProcess(MParList *pList)
113{
114 fDrive = (MReportDrive*)pList->FindObject(AddSerialNumber("MReportDrive"));
115 if (!fDrive)
116 {
117 *fLog << err << AddSerialNumber("MReportDrive")
118 << " not found... aborting." << endl;
119 return kFALSE;
120 }
121
122
123 fStarCam = (MStarCam*)pList->FindObject("MStarCam", "MStarCam");
124 if (!fStarCam)
125 {
126 *fLog << err << "MTelAxisFromStars::PreProcess; container 'MStarCam' not found... aborting." << endl;
127 return kFALSE;
128 }
129
130
131 fSourceCam = (MStarCam*)pList->FindObject("MSourceCam", "MStarCam");
132 if (!fSourceCam)
133 {
134 *fLog << err << "MTelAxisFromStars::PreProcess; container 'MSourceCam' not found... continue " << endl;
135 }
136
137
138 //-----------------------------------------------------------------
139 fSrcPos = (MSrcPosCam*)pList->FindCreateObj(AddSerialNumber("MSrcPosCam"), "MSrcPosCam");
140 if (!fSrcPos)
141 {
142 *fLog << err << "MTelAxisFromStars::PreProcess; MSrcPosCam not found... aborting" << endl;
143 return kFALSE;
144 }
145
146 fPntPos = (MSrcPosCam*)pList->FindCreateObj(AddSerialNumber("MSrcPosCam"), "MPntPosCam");
147 if (!fPntPos)
148 {
149 *fLog << err << "MTelAxisFromStars::PreProcess; MPntPosCam not found... aborting" << endl;
150 return kFALSE;
151 }
152
153 fPointPos = (MPointingPos*)pList->FindCreateObj(AddSerialNumber("MPointingPos"), "MPointingPos");
154 if (!fPointPos)
155 {
156 *fLog << err << "MTelAxisFromStars::PreProcess; MPointingPos not found... aborting" << endl;
157 return kFALSE;
158 }
159
160 fSourcePos = (MPointingPos*)pList->FindCreateObj(AddSerialNumber("MPointingPos"), "MSourcePos");
161 if (!fSourcePos)
162 {
163 *fLog << err << "MTelAxisFromStars::PreProcess; MSourcePos[MPointingPos] not found... aborting" << endl;
164 return kFALSE;
165 }
166
167 fSkyCamTrans = (MSkyCamTrans*)pList->FindCreateObj(AddSerialNumber("MSkyCamTrans"));
168 if (!fSkyCamTrans)
169 {
170 *fLog << err << "MTelAxisFromStars::PreProcess; MSkyCamTrans not found... aborting" << endl;
171 return kFALSE;
172 }
173
174 //-----------------------------------------------------------------
175 // book an MStarCamTrans object
176 // this is needed when calling one of the member functions of MStarCamTrans
177
178 MGeomCam *geom = (MGeomCam*)pList->FindObject(AddSerialNumber("MGeomCam"));
179 if (!geom)
180 {
181 *fLog << err << AddSerialNumber("MGeomCam")
182 << " not found... aborting." << endl;
183 return kFALSE;
184 }
185
186 MObservatory *obs = (MObservatory*)pList->FindObject(AddSerialNumber("MObservatory"));
187 if (!obs)
188 {
189 *fLog << err << AddSerialNumber("MObservatory")
190 << " not found... aborting." << endl;
191 return kFALSE;
192 }
193
194 fStarCamTrans = new MStarCamTrans(*geom, *obs);
195
196 return kTRUE;
197}
198
199// --------------------------------------------------------------------------
200//
201// Set optical aberration factor
202//
203// fAberr is the ratio between
204// the distance from the camera center with optical aberration and
205// the distance from the camera center with an ideal imaging
206//
207// fAberr = r_real/r_ideal
208//
209void MTelAxisFromStars::SetOpticalAberr(Double_t aberr)
210{
211 *fLog << all << "MTelAxisFromStars::SetOpticalAberr; the optical aberration factor is set equal to : "
212 << aberr ;
213
214 fAberr = aberr;
215}
216
217// --------------------------------------------------------------------------
218//
219// Set the type of the input
220//
221// type = 0 calculated star positions (by averaging)
222// type = 1 fitted star positions (by Gauss fit)
223//
224void MTelAxisFromStars::SetInputType(Int_t type)
225{
226 *fLog << all << "MTelAxisFromStars::SetInputType; input type is set equal to : "
227 << type ;
228 if (type == 0)
229 *fLog << " (calculated star positions)" << endl;
230 else
231 *fLog << " (fitted star positions)" << endl;
232
233 fInputType = type;
234}
235
236// --------------------------------------------------------------------------
237//
238// Fix the scale factor fLambda
239//
240//
241void MTelAxisFromStars::FixScaleFactorAt(Double_t lambda)
242{
243 *fLog << all << "MTelAxisFromStars::FixScaleFactorAt; scale factor will be fixed at : "
244 << lambda << endl;
245
246 fFixedScaleFactor = lambda;
247}
248
249
250// --------------------------------------------------------------------------
251//
252// Fix rotation angle fAlfa
253//
254//
255void MTelAxisFromStars::FixRotationAngleAt(Double_t alfa)
256{
257 *fLog << all << "MTelAxisFromStars::FixRotationAngleAt; rotation angle will be fixed at : "
258 << alfa << endl;
259
260 fFixedRotationAngle = alfa; // [degrees]
261}
262
263
264// --------------------------------------------------------------------------
265//
266// Process
267//
268// call FindSkyCamTrans to find the Sky-Camera transformation
269// call TransSkyCam to transform some sky directions
270// into the camera system
271// put the estimated source position into MSrcPosCam
272//
273
274Int_t MTelAxisFromStars::Process()
275{
276 //Int_t run = fRun->GetRunNumber();
277 //*fLog << "MTelAxisFromStars::Process; run = " << run << endl;
278
279 //--------------------------------------
280 // Define the input for FindSkyCamTrans
281 //
282
283 // get the expected (axy[0], axy[1]) and the measured positions
284 // (bxy[0], bxy[1]) of stars in the camera from MStarCam
285 Int_t fNumStars = fStarCam->GetNumStars();
286
287 if (fNumStars <= 0)
288 return kTRUE;
289
290 TArrayD axy[2];
291 axy[0].Set(fNumStars);
292 axy[1].Set(fNumStars);
293
294 TArrayD bxy[2];
295 bxy[0].Set(fNumStars);
296 bxy[1].Set(fNumStars);
297
298 // error matrix of bxy
299 TArrayD exy[2][2];
300 exy[0][0].Set(fNumStars);
301 exy[0][1].Set(fNumStars);
302 exy[1][0].Set(fNumStars);
303 exy[1][1].Set(fNumStars);
304
305 // transformation parameters
306 Double_t fLambda;
307 Double_t fAlfa;
308 Double_t fA[2][2];
309 Double_t fD[2];
310 Double_t fErrD[2][2];
311 Int_t fNumIter;
312 Int_t fNdof;
313 Double_t fChi2;
314 Double_t fChi2Prob;
315
316 MStarPos *star = 0;
317 TIter next(fStarCam->GetList());
318 Int_t ix = 0;
319
320 // loop over all stars
321 while ( (star = (MStarPos*)next()) )
322 {
323 axy[0][ix] = star->GetXExp();
324 axy[1][ix] = star->GetYExp();
325
326 if (fInputType == 0)
327 {
328 // values from averaging
329 bxy[0][ix] = star->GetMeanXCalc();
330 bxy[1][ix] = star->GetMeanYCalc();
331
332 // this is the error matrix for (MeanXCalc, MeanYCalc);
333 // this is the error matrix which should be used
334 exy[0][0][ix] = star->GetXXErrCalc();
335 exy[0][1][ix] = star->GetXYErrCalc();
336 exy[1][0][ix] = star->GetXYErrCalc();
337 exy[1][1][ix] = star->GetYYErrCalc();
338
339 //exy[0][0][ix] = star->GetSigmaXCalc()*star->GetSigmaXCalc();
340 //exy[0][1][ix] = 0.0;
341 //exy[1][0][ix] = 0.0;
342 //exy[1][1][ix] = star->GetSigmaYCalc()*star->GetSigmaYCalc();
343 }
344
345 else if (fInputType == 1)
346 {
347 // values from Gauss fit
348 bxy[0][ix] = star->GetMeanXFit();
349 bxy[1][ix] = star->GetMeanYFit();
350
351 // this is the error matrix for (MeanXFit, MeanYFit);
352 // this is the error matrix which should be used
353 exy[0][0][ix] = star->GetXXErrFit();
354 exy[0][1][ix] = star->GetXYErrFit();
355 exy[1][0][ix] = star->GetXYErrFit();
356 exy[1][1][ix] = star->GetYYErrFit();
357
358 // this is the error matrix constructed from SigmaXFit and SigmaYFit;
359 // it is used because the errors above are too small, at present
360 //exy[0][0][ix] = star->GetSigmaXFit() * star->GetSigmaXFit();
361 //exy[0][1][ix] = star->GetCorrXYFit() *
362 // star->GetSigmaXFit() * star->GetSigmaYFit();
363 //exy[1][0][ix] = exy[0][1][ix];
364 //exy[1][1][ix] = star->GetSigmaYFit() * star->GetSigmaYFit();
365 }
366
367 else
368 {
369 *fLog << err << "MTelAxisFromStars::Process; type of input is not defined"
370 << endl;
371 return kFALSE;
372 }
373
374 // don't include stars with undefined error
375 Double_t deter = exy[0][0][ix]*exy[1][1][ix]
376 - exy[0][1][ix]*exy[1][0][ix];
377
378 //*fLog << "ix ,deter, xx, xy, yy = " << ix << ": "
379 // << deter << ", " << exy[0][0][ix] << ", "
380 // << exy[0][1][ix] << ", " << exy[1][1][ix] << endl;
381 if (deter <= 0.0)
382 continue;
383
384 //*fLog << "MTelAxisFromStars : " << endl;
385 //*fLog << " ix, XExp, YExp, XFit, YFit, SigmaX2, SigmaXY, SigmaY2 = "
386 // << ix << " : "
387 // << axy[0][ix] << ", " << axy[1][ix] << ", "
388 // << bxy[0][ix] << ", " << bxy[1][ix] << ", "
389 // << exy[0][0][ix] << ", " << exy[0][1][ix] << ", "
390 // << exy[1][1][ix] << endl;
391
392 ix++;
393 }
394
395 //--------------------------------------
396 // Find the transformation from expected positions (axy[1], axy[2])
397 // to measured positions (bxy[1], bxy[2]) in the camera
398
399 Int_t fNStars = ix;
400
401 if (ix < fNumStars)
402 {
403 // reset the sizes of the arrays
404 Int_t fNStars = ix;
405 axy[0].Set(fNStars);
406 axy[1].Set(fNStars);
407
408 bxy[0].Set(fNStars);
409 bxy[1].Set(fNStars);
410
411 exy[0][0].Set(fNStars);
412 exy[0][1].Set(fNStars);
413 exy[1][0].Set(fNStars);
414 exy[1][1].Set(fNStars);
415 }
416
417 Bool_t fitOK;
418 if (fNStars < 1)
419 {
420 *fLog << "MTelAxisFromStars::Process; no star for MTelAxisFromStars"
421 << endl;
422 fitOK = kFALSE;
423 }
424 else
425 {
426 fitOK = FindSkyCamTrans(axy, bxy, exy,
427 fFixedRotationAngle, fFixedScaleFactor, fLambda,
428 fAlfa , fA, fD, fErrD,
429 fNumIter, fNdof, fChi2, fChi2Prob);
430 }
431
432 if (!fitOK)
433 {
434 *fLog << err
435 << "MTelAxisFromStars::Process; Fit to find transformation from star to camera system failed"
436 << endl;
437
438 if (fNStars > 0)
439 {
440 *fLog << err
441 << " fNumIter, fNdof, fChi2, fChi2Prob = " << fNumIter
442 << ", " << fNdof << ", " << fChi2 << ", " << fChi2Prob << endl;
443 }
444
445 return kTRUE;
446 }
447
448
449 //--------------------------------------
450 // Put the transformation parameters into the MSkyCamTrans container
451
452 fSkyCamTrans->SetParameters(fLambda, fAlfa, fA, fD, fErrD,
453 fNumStars, fNumIter, fNdof, fChi2, fChi2Prob);
454 fSkyCamTrans->SetReadyToSave();
455
456 //--------------------------------------
457 // Put the camera position (X, Y)
458 // obtained by transforming the camera center (0, 0)
459 // into MPntPosCam[MSrcPosCam]
460
461 fPntPos->SetXY(fD[0], fD[1]);
462 fPntPos->SetReadyToSave();
463
464
465 //--------------------------------------
466 // Put the corrected pointing position into MPointingPos
467 //
468 SetPointingPosition(fStarCamTrans, fDrive, fSkyCamTrans, fPointPos);
469
470
471 //--------------------------------------
472 // Put the estimated position of the source into SrcPosCam
473 //
474 // get the source direction from MReportDrive
475 // Note : this has to be changed for the wobble mode, where the source
476 // isn't in the center of the camera
477 Double_t decsource = fDrive->GetDec();
478 Double_t rasource = fDrive->GetRa();
479 //
480 Double_t radrive = fDrive->GetRa();
481 Double_t hdrive = fDrive->GetHa();
482 Double_t hsource = hdrive + radrive - rasource;
483 fSourcePos->SetSkyPosition(rasource, decsource, hsource);
484
485 SetSourcePosition(fStarCamTrans, fPointPos, fSourcePos, fSrcPos);
486
487 *fLog << "after calling SetSourcePosition : , X, Y ,fD = "
488 << fSrcPos->GetX() << ", " << fSrcPos->GetY() << ", "
489 << fD[0] << ", " << fD[1] << endl;
490
491 //--------------------------------------
492 // Apply the transformation to some expected positions (asxy[1], asxy[2])
493 // to obtain estimated positions (bsxy[1], bsxy[2]) in the camera
494 // and their error matrices esxy[2][2]
495
496 // get the expected positions (asxy[1], asxy[2]) from another MStarCam
497 // container (with the name "MSourceCam")
498 Int_t fNumStarsSource = 0;
499
500 if (fSourceCam)
501 fNumStarsSource = fSourceCam->GetNumStars();
502
503 //*fLog << "MTelAxisFromStars::Process; fNumStarsSource = "
504 // << fNumStarsSource << endl;
505
506 if (fNumStarsSource > 0)
507 {
508 TArrayD asxy[2];
509 asxy[0].Set(fNumStarsSource);
510 asxy[1].Set(fNumStarsSource);
511
512 TArrayD bsxy[2];
513 bsxy[0].Set(fNumStarsSource);
514 bsxy[1].Set(fNumStarsSource);
515
516 TArrayD esxy[2][2];
517 esxy[0][0].Set(fNumStarsSource);
518 esxy[0][1].Set(fNumStarsSource);
519 esxy[1][0].Set(fNumStarsSource);
520 esxy[1][1].Set(fNumStarsSource);
521
522 MStarPos *starSource = 0;
523 TIter nextSource(fSourceCam->GetList());
524 ix = 0;
525 while ( (starSource = (MStarPos*)nextSource()) )
526 {
527 asxy[0][ix] = starSource->GetXExp();
528 asxy[1][ix] = starSource->GetYExp();
529
530 ix++;
531 }
532
533 TransSkyCam(fLambda, fA, fD, fErrD, asxy, bsxy, esxy);
534
535 // put the estimated positions into the MStarCam container
536 // with name "MSourceCam"
537 TIter setnextSource(fSourceCam->GetList());
538 ix = 0;
539 while ( (starSource = (MStarPos*)setnextSource()) )
540 {
541 Double_t corr = esxy[0][1][ix]/ sqrt( esxy[0][0][ix] * esxy[1][1][ix] );
542 starSource->SetFitValues(100.0, 100.0, bsxy[0][ix], bsxy[1][ix],
543 sqrt(esxy[0][0][ix]), sqrt(esxy[1][1][ix]), corr,
544 esxy[0][0][ix], esxy[0][1][ix], esxy[1][1][ix],
545 fChi2, fNdof);
546
547 ix++;
548 }
549
550 }
551
552 //--------------------------------------
553
554 return kTRUE;
555}
556
557
558
559//---------------------------------------------------------------------------
560//
561// FindSkyCamTrans
562//
563// This routine determines the transformation
564//
565// ( cos(alfa) -sin(alfa) )
566// b = lambda * A * a + d A = ( )
567// ^ ^ ^ ( sin(alfa) cos(alfa) )
568// | | |
569// scale rotation shift
570// factor matrix
571//
572// from sky coordinates 'a' (projected onto the camera) to camera
573// coordinates 'b', using the positions of known stars in the camera.
574// The latter positions may have been determined by analysing the
575// DC currents in the different pixels.
576//
577// Input : a[2] x and y coordinates of stars projected onto the camera;
578// they were obtained from (RA, dec) of the stars and
579// (ThetaTel, PhiTel) and the time of observation;
580// these are the 'expected positions' of stars in the camera
581// b[2] 'measured positions' of these stars in the camera;
582// they may have been obtained from the DC currents
583// e[2][2] error matrix of b[2]
584// fixedrotationangle value [in degrees] at which rotation angle
585// alfa should be fixed; -1 means don't fix
586// fixedscalefactor value at which scale factor lambda
587// should be fixed; -1 means don't fix
588//
589// Output : lambda, alfadeg, A[2][2], d[2] fit results;
590// parameters describing the transformation
591// from 'expected positions' to the 'measured
592// positions' in the camera
593// errd[2][2] error matrix of d[2]
594// fNumIter number of iterations
595// fNdoF number of degrees of freedom
596// fChi2 chi-square value
597// fChi2Prob chi-square probability
598//
599// The units are assumed to be
600// [degrees] for alfadeg
601// [mm] for a, b, d
602// [1] for lambda
603
604Bool_t MTelAxisFromStars::FindSkyCamTrans(
605 TArrayD a[2], TArrayD b[2], TArrayD e[2][2],
606 Double_t &fixedrotationang, Double_t &fixedscalefac, Double_t &lambda,
607 Double_t &alfadeg, Double_t A[2][2], Double_t d[2], Double_t errd[2][2],
608 Int_t &fNumIter, Int_t &fNdof, Double_t &fChi2, Double_t &fChi2Prob)
609{
610 Int_t fNumStars = a[0].GetSize();
611
612 //*fLog << "MTelAxisFromStars::FindSkyCamTrans; expected and measured positions :"
613 // << endl;
614 for (Int_t ix=0; ix<fNumStars; ix++)
615 {
616 //*fLog << " ix, a[0], a[1], b[0], b[1], errxx, errxy, erryy = "
617 // << ix << " : "
618 // << a[0][ix] << ", " << a[1][ix] << "; "
619 // << b[0][ix] << ", " << b[1][ix] << "; "
620 // << e[0][0][ix] << ", " << e[0][1][ix] << ", "
621 // << e[1][1][ix] << endl;
622 }
623
624
625 //-------------------------------------------
626 // fix some parameters if the number of degrees of freedom is too low
627 // (<= 0.0)
628
629 Double_t fixedscalefactor = fixedscalefac;
630 Double_t fixedrotationangle = fixedrotationang;
631
632 // calculate number of degrees of freedom
633 fNdof = 2 * fNumStars - 4;
634 if (fixedscalefactor != -1.0)
635 fNdof += 1;
636 if (fixedrotationangle != -1.0)
637 fNdof += 1;
638
639 // if there is only 1 star fix both rotation angle and scale factor
640 if (fNumStars == 1)
641 {
642 if (fixedscalefactor == -1.0)
643 {
644 fixedscalefactor = 1.0;
645 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; scale factor is fixed at "
646 << fixedscalefactor << endl;
647 }
648 if (fixedrotationangle == -1.0)
649 {
650 fixedrotationangle = 0.0;
651 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; rotation angle is fixed at "
652 << fixedrotationangle << endl;
653 }
654 }
655 // otherwise fix only 1 parameter if possible
656 else if (fNdof < 0)
657 {
658 if (fNdof < -2)
659 {
660 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; number of degrees of freedom is too low : "
661 << fNdof << "; fNumStars = " << fNumStars << endl;
662 return kFALSE;
663 }
664 else if (fNdof == -2)
665 {
666 if (fixedscalefactor == -1.0 && fixedrotationangle == -1.0)
667 {
668 fixedscalefactor = 1.0;
669 fixedrotationangle = 0.0;
670 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; scale factor and rotation angle are fixed at "
671 << fixedscalefactor << " and " << fixedrotationangle
672 << " respectively" << endl;
673 }
674 else
675 {
676 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; number of degrees of freedom is too low : "
677 << fNdof << "; fNumStars = " << fNumStars << endl;
678 return kFALSE;
679 }
680 }
681 else if (fNdof == -1)
682 {
683 if (fixedrotationangle == -1.0)
684 {
685 fixedrotationangle = 0.0;
686 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; rotation angle is fixed at "
687 << fixedrotationangle << endl;
688 }
689 else if (fixedscalefactor == -1.0)
690 {
691 fixedscalefactor = 1.0;
692 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; scale factor is fixed at "
693 << fixedscalefactor << endl;
694 }
695 else
696 {
697 *fLog << warn << "MTelAxisFromStars::FindSkyCamTrans; number of degrees of freedom is too low : "
698 << fNdof << "; fNumStars = " << fNumStars<< endl;
699 return kFALSE;
700 }
701 }
702 }
703
704 // recalculate number of degrees of freedom
705 fNdof = 2 * fNumStars - 4;
706 if (fixedscalefactor != -1.0)
707 fNdof += 1;
708 if (fixedrotationangle != -1.0)
709 fNdof += 1;
710
711 if (fNdof < 0)
712 return kFALSE;
713 //-------------------------------------------
714
715
716 // get first approximation of scaling factor
717 if (fixedscalefactor != -1.0)
718 lambda = fixedscalefactor;
719 else
720 lambda = 1.0;
721
722 Double_t lambdaold = lambda;
723 Double_t dlambda = 0.0;
724
725 // get first approximation of rotation angle
726 Double_t alfa = 0.0;
727 if (fixedrotationangle != -1.0)
728 alfa = fixedrotationangle / kRad2Deg;
729
730
731
732 Double_t alfaold = alfa;
733 // maximum allowed change of alfa in 1 iteration step (5 degrees)
734 Double_t dalfamax = 5.0 / kRad2Deg;
735 Double_t dalfa = 0.0;
736
737 Double_t cosal = cos(alfa);
738 Double_t sinal = sin(alfa);
739
740 A[0][0] = cosal;
741 A[0][1] = -sinal;
742 A[1][0] = sinal;
743 A[1][1] = cosal;
744
745
746 Double_t absdold2 = 10000.0;
747 Double_t fChangeofd2 = 10000.0;
748
749
750 TArrayD Aa[2];
751 Aa[0].Set(fNumStars);
752 Aa[1].Set(fNumStars);
753
754
755 Double_t sumEbminlamAa[2];
756
757 TArrayD Ebminlambracd[2];
758 Ebminlambracd[0].Set(fNumStars);
759 Ebminlambracd[1].Set(fNumStars);
760
761 TArrayD EAa[2];
762 EAa[0].Set(fNumStars);
763 EAa[1].Set(fNumStars);
764
765 // invert the error matrices
766 TArrayD c[2][2];
767 c[0][0].Set(fNumStars);
768 c[0][1].Set(fNumStars);
769 c[1][0].Set(fNumStars);
770 c[1][1].Set(fNumStars);
771
772 for (Int_t ix=0; ix<fNumStars; ix++)
773 {
774 Double_t XX = e[0][0][ix];
775 Double_t XY = e[0][1][ix];
776 Double_t YY = e[1][1][ix];
777
778 // get inverse of error matrix
779 Double_t determ = XX*YY - XY*XY;
780 c[0][0][ix] = YY / determ;
781 c[0][1][ix] = -XY / determ;
782 c[1][0][ix] = -XY / determ;
783 c[1][1][ix] = XX / determ;
784 }
785
786
787
788 // calculate sum of inverted error matrices
789 Double_t determsumc;
790 Double_t sumc[2][2];
791 sumc[0][0] = 0.0;
792 sumc[0][1] = 0.0;
793 sumc[1][0] = 0.0;
794 sumc[1][1] = 0.0;
795
796 for (Int_t ix=0; ix<fNumStars; ix++)
797 {
798 sumc[0][0] += c[0][0][ix];
799 sumc[0][1] += c[0][1][ix];
800 sumc[1][0] += c[1][0][ix];
801 sumc[1][1] += c[1][1][ix];
802 }
803 determsumc = sumc[0][0]*sumc[1][1] - sumc[0][1]*sumc[1][0];
804
805 // calculate inverse of sum of inverted error matrices
806 Double_t sumcinv[2][2];
807 sumcinv[0][0] = sumc[1][1] / determsumc;
808 sumcinv[0][1] = -sumc[0][1] / determsumc;
809 sumcinv[1][0] = -sumc[1][0] / determsumc;
810 sumcinv[1][1] = sumc[0][0] / determsumc;
811
812 //*fLog << "sumcinv = " << sumcinv[0][0] << ", " << sumcinv[0][1]
813 // << ", " << sumcinv[1][1] << endl;
814
815
816 // minimize chi2 by iteration ***** start **********************
817
818 // stop iteration when change in |d|*|d| is less than 'told2'
819 // and change in alfa is less than 'toldalfa'
820 // and change in lambda is less than 'toldlambda'
821 // or chi2 is less than 'tolchi2'
822 Double_t told2 = 0.3*0.3; // [mm*mm]; 1/100 of an inner pixel diameter
823 Double_t toldalfa = 0.01 / kRad2Deg; // 0.01 degrees
824 Double_t toldlambda = 0.00006; // uncertainty of 1 mm of distance
825 // between camera and reflector
826 Double_t tolchi2 = 1.e-5;
827
828 Int_t fNumIterMax = 100;
829 fNumIter = 0;
830
831 for (Int_t i=0; i<fNumIterMax; i++)
832 {
833 fNumIter++;
834
835 // get next approximation of d ------------------
836 for (Int_t ix=0; ix<fNumStars; ix++)
837 {
838 Aa[0][ix] = A[0][0] * a[0][ix] + A[0][1]*a[1][ix];
839 Aa[1][ix] = A[1][0] * a[0][ix] + A[1][1]*a[1][ix];
840
841 //*fLog << "ix, Aa = " << ix << " : " << Aa[0][ix] << ", "
842 // << Aa[1][ix] << endl;
843 }
844
845 sumEbminlamAa[0] = 0.0;
846 sumEbminlamAa[1] = 0.0;
847
848 for (Int_t ix=0; ix<fNumStars; ix++)
849 {
850 sumEbminlamAa[0] += c[0][0][ix] * (b[0][ix] - lambda*Aa[0][ix])
851 + c[0][1][ix] * (b[1][ix] - lambda*Aa[1][ix]);
852
853 sumEbminlamAa[1] += c[1][0][ix] * (b[0][ix] - lambda*Aa[0][ix])
854 + c[1][1][ix] * (b[1][ix] - lambda*Aa[1][ix]);
855 }
856
857 //*fLog << "sumEbminlamAa = " << sumEbminlamAa[0] << ", "
858 // << sumEbminlamAa[1] << endl;
859
860 d[0] = sumcinv[0][0] * sumEbminlamAa[0]
861 + sumcinv[0][1] * sumEbminlamAa[1] ;
862
863 d[1] = sumcinv[1][0] * sumEbminlamAa[0]
864 + sumcinv[1][1] * sumEbminlamAa[1] ;
865
866 Double_t absdnew2 = d[0]*d[0] + d[1]*d[1];
867 fChangeofd2 = absdnew2 - absdold2;
868
869 //*fLog << "fNumIter : " << fNumIter
870 // << "; alfa, lambda, d[0], d[1], absdold2, absdnew2 = " << endl;
871 //*fLog << alfa << ", " << lambda << ", " << d[0] << ", " << d[1]
872 // << ", " << absdold2 << ", " << absdnew2 << endl;
873
874
875 if ( fabs(fChangeofd2) < told2 && fabs(dalfa) < toldalfa &&
876 fabs(dlambda) < toldlambda )
877 {
878 //*fLog << "Iteration stopped because of small changes : fChangeofd2, dalfa, dlambda = "
879 // << fChangeofd2 << ", " << dalfa << ", " << dlambda << endl;
880 break;
881 }
882 absdold2 = absdnew2;
883
884 // get next approximation of matrix A ----------------
885 if (fFixedRotationAngle == -1.0)
886 {
887 for (Int_t ix=0; ix<fNumStars; ix++)
888 {
889 Ebminlambracd[0][ix] =
890 c[0][0][ix] * ( b[0][ix] - lambda*Aa[0][ix] - d[0] )
891 + c[0][1][ix] * ( b[1][ix] - lambda*Aa[1][ix] - d[1] );
892
893 Ebminlambracd[1][ix] =
894 c[1][0][ix] * ( b[0][ix] - lambda*Aa[0][ix] - d[0] )
895 + c[1][1][ix] * ( b[1][ix] - lambda*Aa[1][ix] - d[1] );
896
897 //*fLog << "ix, Ebminlambracd = " << ix << " : "
898 // << Ebminlambracd[0][ix] << ", "
899 // << Ebminlambracd[1][ix] << endl;
900 }
901
902 // stop iteration if fChi2 is small enough
903 fChi2 = 0.0;
904 for (Int_t ix=0; ix<fNumStars; ix++)
905 {
906 fChi2 += (b[0][ix]-lambda*Aa[0][ix]-d[0] ) * Ebminlambracd[0][ix]
907 + (b[1][ix]-lambda*Aa[1][ix]-d[1] ) * Ebminlambracd[1][ix];
908 }
909 if ( fChi2 < tolchi2 )
910 {
911 //*fLog << "iteration stopped because of small fChi2 : "
912 // << fChi2 << endl;
913 break;
914 }
915
916
917 Double_t dchi2dA[2][2];
918 dchi2dA[0][0] = 0.0;
919 dchi2dA[0][1] = 0.0;
920 dchi2dA[1][0] = 0.0;
921 dchi2dA[1][1] = 0.0;
922
923 for (Int_t ix=0; ix<fNumStars; ix++)
924 {
925 dchi2dA[0][0] += Ebminlambracd[0][ix] * a[0][ix];
926 dchi2dA[0][1] += Ebminlambracd[0][ix] * a[1][ix];
927 dchi2dA[1][0] += Ebminlambracd[1][ix] * a[0][ix];
928 dchi2dA[1][1] += Ebminlambracd[1][ix] * a[1][ix];
929 }
930
931 //*fLog << "dchi2dA = " << dchi2dA[0][0] << ", " << dchi2dA[0][1]
932 // << ", " << dchi2dA[1][0] << ", " << dchi2dA[1][1] << endl;
933
934 // ********* 1st derivative (d chi2) / (d alfa) ************
935 Double_t dchi2dalfa = -2.0*lambda *
936 ( - sinal*(dchi2dA[0][0]+dchi2dA[1][1])
937 + cosal*(dchi2dA[1][0]-dchi2dA[0][1]) );
938
939
940 //Double_t dalfa1st = - fChi2 / dchi2dalfa;
941
942 //*fLog << "fChi2, dchi2dalfa = " << fChi2 << ", "
943 // << dchi2dalfa << endl;
944 //*fLog << "proposed change of alfa using 1st derivative = "
945 // << dalfa1st << endl;
946
947 // ********* 2nd derivative (d2 chi2) / (d alfa2) ******
948 Double_t term1 = 0.0;
949 Double_t term2 = 0.0;
950 Double_t term3 = 0.0;
951 Double_t term4 = 0.0;
952
953 for (Int_t ix=0; ix<fNumStars; ix++)
954 {
955 term1 += a[0][ix]*c[0][0][ix]*a[0][ix] + a[1][ix]*c[1][0][ix]*a[0][ix]
956 + a[0][ix]*c[0][1][ix]*a[1][ix] + a[1][ix]*c[1][1][ix]*a[1][ix];
957
958 term2 += a[0][ix]*c[1][0][ix]*a[0][ix] - a[1][ix]*c[0][0][ix]*a[0][ix]
959 + a[0][ix]*c[1][1][ix]*a[1][ix] - a[1][ix]*c[0][1][ix]*a[1][ix];
960
961 term3 = a[0][ix]*c[0][0][ix]*a[1][ix] + a[1][ix]*c[1][0][ix]*a[1][ix]
962 - a[0][ix]*c[0][1][ix]*a[0][ix] - a[1][ix]*c[1][1][ix]*a[0][ix];
963
964 term4 += a[0][ix]*c[1][0][ix]*a[1][ix] - a[1][ix]*c[0][0][ix]*a[1][ix]
965 - a[0][ix]*c[1][1][ix]*a[0][ix] + a[1][ix]*c[0][1][ix]*a[0][ix];
966 }
967
968 Double_t d2chi2dalfa2 =
969 - 2.0*lambda * ( - cosal*(dchi2dA[0][0]+dchi2dA[1][1])
970 - sinal*(dchi2dA[1][0]-dchi2dA[0][1]) )
971 + 2.0*lambda*lambda * ( sinal*sinal * term1 - sinal*cosal * term2
972 + sinal*cosal * term3 - cosal*cosal * term4);
973
974 // Gauss-Newton step
975 Double_t dalfa2nd = - dchi2dalfa / d2chi2dalfa2;
976
977 //*fLog << "proposed change of alfa using 2st derivative = "
978 // << dalfa2nd << endl;
979
980 //dalfa = dalfa1st;
981 dalfa = dalfa2nd;
982
983 // ******************************************
984
985
986 // restrict change of alfa
987 if ( fabs(dalfa) > dalfamax )
988 {
989 dalfa = TMath::Sign( dalfamax, dalfa );
990 }
991 alfa = alfaold + dalfa;
992
993 if ( alfa < -5.0/kRad2Deg )
994 alfa = -5.0/kRad2Deg;
995 else if ( alfa > 5.0/kRad2Deg )
996 alfa = 5.0/kRad2Deg;
997
998 dalfa = alfa - alfaold;
999
1000 alfaold = alfa;
1001
1002 sinal = sin(alfa);
1003 cosal = cos(alfa);
1004
1005 A[0][0] = cosal;
1006 A[0][1] = -sinal;
1007 A[1][0] = sinal;
1008 A[1][1] = cosal;
1009
1010 //*fLog << "alfa-alfaold = " << dalfa << endl;
1011 //*fLog << "new alfa = " << alfa << endl;
1012 }
1013
1014
1015 // get next approximation of lambda ----------------
1016 if (fFixedScaleFactor == -1.0)
1017 {
1018 for (Int_t ix=0; ix<fNumStars; ix++)
1019 {
1020 Aa[0][ix] = A[0][0]*a[0][ix] + A[0][1]*a[1][ix];
1021 Aa[1][ix] = A[1][0]*a[0][ix] + A[1][1]*a[1][ix];
1022
1023 EAa[0][ix] =
1024 c[0][0][ix] * Aa[0][ix] + c[0][1][ix] * Aa[1][ix];
1025 EAa[1][ix] =
1026 c[1][0][ix] * Aa[0][ix] + c[1][1][ix] * Aa[1][ix];
1027
1028 //*fLog << "ix, Aa = " << ix << " : " << Aa[0][ix] << ", "
1029 // << Aa[1][ix] << endl;
1030
1031 //*fLog << "ix, EAa = " << ix << " : " << EAa[0][ix] << ", "
1032 // << EAa[1][ix] << endl;
1033 }
1034
1035 Double_t num = 0.0;
1036 Double_t denom = 0.0;
1037 for (Int_t ix=0; ix<fNumStars; ix++)
1038 {
1039 num += (b[0][ix]-d[0]) * EAa[0][ix]
1040 + (b[1][ix]-d[1]) * EAa[1][ix];
1041
1042 denom += Aa[0][ix] * EAa[0][ix]
1043 + Aa[1][ix] * EAa[1][ix];
1044
1045 //*fLog << "ix : b-d = " << ix << " : " << b[0][ix]-d[0]
1046 // << ", " << b[1][ix]-d[1] << endl;
1047
1048 //*fLog << "ix : Aa = " << ix << " : " << Aa[0][ix]
1049 // << ", " << Aa[1][ix] << endl;
1050 }
1051
1052 lambda = num / denom;
1053
1054 if ( lambda < 0.9 )
1055 lambda = 0.9;
1056 else if ( lambda > 1.1 )
1057 lambda = 1.1;
1058
1059 dlambda = lambda - lambdaold;
1060 lambdaold = lambda;
1061
1062 //*fLog << "num, denom, lambda, dlambda = " << num
1063 // << ", " << denom << ", " << lambda << ", "
1064 // << dlambda << endl;
1065 }
1066
1067 }
1068 //------- end of iteration *****************************************
1069
1070 alfadeg = alfa * kRad2Deg;
1071
1072 // calculate error matrix of d[2]
1073 errd[0][0] = sumcinv[0][0];
1074 errd[0][1] = sumcinv[0][1];
1075 errd[1][0] = sumcinv[1][0];
1076 errd[1][1] = sumcinv[1][1];
1077
1078 // evaluate quality of fit
1079
1080 // calculate chi2
1081 for (Int_t ix=0; ix<fNumStars; ix++)
1082 {
1083 Ebminlambracd[0][ix] =
1084 c[0][0][ix] * ( b[0][ix] - lambda*Aa[0][ix] - d[0] )
1085 + c[0][1][ix] * ( b[1][ix] - lambda*Aa[1][ix] - d[1] );
1086
1087 Ebminlambracd[1][ix] =
1088 c[1][0][ix] * (b[0][ix] - lambda*Aa[0][ix] - d[0] )
1089 + c[1][1][ix] * (b[1][ix] - lambda*Aa[1][ix] - d[1] );
1090 }
1091
1092 fChi2 = 0.0;
1093 for (Int_t ix=0; ix<fNumStars; ix++)
1094 {
1095 fChi2 += (b[0][ix] - lambda*Aa[0][ix] - d[0] ) * Ebminlambracd[0][ix]
1096 + (b[1][ix] - lambda*Aa[1][ix] - d[1] ) * Ebminlambracd[1][ix];
1097 }
1098
1099 fChi2Prob = TMath::Prob(fChi2, fNdof);
1100
1101 *fLog << "MTelAxisFromStars::FindSkyCamTrans :" << endl;
1102 *fLog << " fNumStars, fChi2, fNdof, fChi2Prob, fNumIter, fChangeofd2, dalfa, dlambda = "
1103 << fNumStars << ", " << fChi2 << ", " << fNdof << ", "
1104 << fChi2Prob << ", "
1105 << fNumIter << ", " << fChangeofd2 << ", " << dalfa << ", "
1106 << dlambda << endl;
1107 *fLog << " lambda, alfadeg, d[0], d[1] = " << lambda << ", "
1108 << alfadeg << ", " << d[0] << ", " << d[1] << endl;
1109
1110 return kTRUE;
1111}
1112
1113// --------------------------------------------------------------------------
1114//
1115// Apply transformation (lambda, A, d)
1116// to the expected positions (a[1], a[2])
1117// to obtain the estimated positions (b[1], b[2])
1118//
1119// e[2][2] is the error matrix of b[2]
1120
1121void MTelAxisFromStars::TransSkyCam(
1122 Double_t &lambda, Double_t A[2][2], Double_t d[2], Double_t errd[2][2],
1123 TArrayD a[2], TArrayD b[2], TArrayD e[2][2])
1124{
1125 Int_t numpos = a[0].GetSize();
1126 if (numpos <= 0)
1127 return;
1128
1129 //*fLog << "MTelAxisFromStars::TransSkyCam; expected and estimated positions :"
1130 // << endl;
1131
1132 for (Int_t ix=0; ix<numpos; ix++)
1133 {
1134 //*fLog << "MTelAxisFromStars; ix = " << ix << endl;
1135
1136 b[0][ix] = lambda * (A[0][0]*a[0][ix] + A[0][1]*a[1][ix]) + d[0];
1137 b[1][ix] = lambda * (A[1][0]*a[0][ix] + A[1][1]*a[1][ix]) + d[1];
1138
1139 e[0][0][ix] = errd[0][0];
1140 e[0][1][ix] = errd[0][1];
1141 e[1][0][ix] = errd[1][0];
1142 e[1][1][ix] = errd[1][1];
1143
1144 //*fLog << " ix, a[0], a[1], b[0], b[1], errxx, errxy, erryy = "
1145 // << ix << " : "
1146 // << a[0][ix] << ", " << a[1][ix] << "; "
1147 // << b[0][ix] << ", " << b[1][ix] << "; "
1148 // << e[0][0][ix] << ", " << e[0][1][ix] << ", "
1149 // << e[1][1][ix] << endl;
1150 }
1151}
1152
1153// --------------------------------------------------------------------------
1154//
1155// SetPointingPosition
1156//
1157// put the corrected pointing direction into MPointingPos[MPointingPos];
1158// this direction corresponds to the position (0,0) in the camera
1159//
1160
1161Bool_t MTelAxisFromStars::SetPointingPosition(MStarCamTrans *fstarcamtrans,
1162 MReportDrive *fdrive, MSkyCamTrans *ftrans, MPointingPos *fpointpos)
1163{
1164 Double_t decdrive = fdrive->GetDec();
1165 Double_t hdrive = fdrive->GetHa();
1166 Double_t radrive = fdrive->GetRa();
1167
1168 // this is the estimated position (with optical aberration) in the camera
1169 // corresponding to the direction in MReportDrive
1170 Double_t Xpoint = (ftrans->GetShiftD())[0];
1171 Double_t Ypoint = (ftrans->GetShiftD())[1];
1172
1173 // get the sky direction corresponding to the position (0,0) in the camera
1174 Double_t decpoint = 0.0;
1175 Double_t hpoint = 0.0;
1176 fstarcamtrans->CelCamToCel0(decdrive, hdrive,
1177 Xpoint/fAberr, Ypoint/fAberr, decpoint, hpoint);
1178 Double_t rapoint = radrive - hpoint + hdrive;
1179 fpointpos->SetSkyPosition(rapoint, decpoint, hpoint);
1180
1181 // get the local direction corresponding to the position (0,0) in the camera
1182 Double_t thetadrive = fdrive->GetNominalZd();
1183 Double_t phidrive = fdrive->GetNominalAz();
1184 Double_t thetapoint = 0.0;
1185 Double_t phipoint = 0.0;
1186 fstarcamtrans->LocCamToLoc0(thetadrive, phidrive,
1187 Xpoint/fAberr, Ypoint/fAberr, thetapoint, phipoint);
1188 fpointpos->SetLocalPosition(thetapoint, phipoint);
1189 fpointpos->SetReadyToSave();
1190
1191 *fLog << "SetPointingPosition : decdrive, hdrive, radrive Xpoint, Ypoint = "
1192 << decdrive << ", " << hdrive << ", " << radrive << ", "
1193 << Xpoint << ", " << Ypoint << endl;
1194
1195 *fLog << "SetPointingPosition : thetadrive, phidrive, thetapoint, phipoint = "
1196 << thetadrive << ", " << phidrive << ", " << thetapoint << ", "
1197 << phipoint << endl;
1198
1199 return kTRUE;
1200}
1201
1202// --------------------------------------------------------------------------
1203//
1204// SetSourcePosition
1205//
1206// put the estimated position of the source in the camera into
1207// MSrcPosCam[MSrcPosCam]
1208//
1209// and the estimated local direction of the source into
1210// MSourcePos[MPointingPos]
1211//
1212
1213Bool_t MTelAxisFromStars::SetSourcePosition(MStarCamTrans *fstarcamtrans,
1214 MPointingPos *fpointpos, MPointingPos *fsourcepos, MSrcPosCam *fsrcpos)
1215{
1216 // get the corrected pointing direction
1217 // corresponding to the position (0,0) in the camera
1218 Double_t decpoint = fpointpos->GetDec();
1219 Double_t hpoint = fpointpos->GetHa();
1220
1221 // get the sky direction of the source
1222 Double_t decsource = fsourcepos->GetDec();
1223 Double_t hsource = fsourcepos->GetHa();
1224
1225 // get the estimated position (Xsource, Ysource) of the source in the camera;
1226 // this is a position for an ideal imaging, without optical aberration
1227 Double_t Xsource = 0.0;
1228 Double_t Ysource = 0.0;
1229 fstarcamtrans->Cel0CelToCam(decpoint, hpoint,
1230 decsource, hsource, Xsource, Ysource);
1231 fsrcpos->SetXY(Xsource*fAberr, Ysource*fAberr);
1232 fsrcpos->SetReadyToSave();
1233
1234 // get the estimated local direction of the source
1235 Double_t thetapoint = fpointpos->GetZd();
1236 Double_t phipoint = fpointpos->GetAz();
1237 Double_t thetasource = 0.0;
1238 Double_t phisource = 0.0;
1239 fstarcamtrans->Loc0CamToLoc(thetapoint, phipoint,
1240 Xsource, Ysource, thetasource, phisource);
1241 fsourcepos->SetLocalPosition(thetasource, phisource);
1242 fsourcepos->SetReadyToSave();
1243
1244 *fLog << "SetSourcePosition : decpoint, hpoint, decsource, hsource, Xsource, Ysource = "
1245 << decpoint << ", " << hpoint << ", " << decsource << ", "
1246 << hsource << ", " << Xsource << ", " << Ysource << endl;
1247 *fLog << "SetSourcePosition : thetapoint, phipoint, thetasource, phisource = "
1248 << thetapoint << ", " << phipoint << ", " << thetasource << ", "
1249 << phisource << endl;
1250
1251 return kTRUE;
1252}
1253
1254// --------------------------------------------------------------------------
1255//
1256//
1257Int_t MTelAxisFromStars::PostProcess()
1258{
1259
1260 return kTRUE;
1261}
1262
1263
1264// --------------------------------------------------------------------------
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
Note: See TracBrowser for help on using the repository browser.