Line data Source code
1 : //# StandardVisCal.h: Declaration of standard (Solvable)VisCal types
2 : //# Copyright (C) 1996,1997,2000,2001,2002,2003,2011
3 : //# Associated Universities, Inc. Washington DC, USA.
4 : //#
5 : //# This library is free software; you can redistribute it and/or modify it
6 : //# under the terms of the GNU Library General Public License as published by
7 : //# the Free Software Foundation; either version 2 of the License, or (at your
8 : //# option) any later version.
9 : //#
10 : //# This library is distributed in the hope that it will be useful, but WITHOUT
11 : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 : //# License for more details.
14 : //#
15 : //# You should have received a copy of the GNU Library General Public License
16 : //# along with this library; if not, write to the Free Software Foundation,
17 : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 : //#
19 : //# Correspondence concerning AIPS++ should be adressed as follows:
20 : //# Internet email: casa-feedback@nrao.edu.
21 : //# Postal address: AIPS++ Project Office
22 : //# National Radio Astronomy Observatory
23 : //# 520 Edgemont Road
24 : //# Charlottesville, VA 22903-2475 USA
25 : //#
26 : //#
27 :
28 : #ifndef SYNTHESIS_STANDARDVISCAL_H
29 : #define SYNTHESIS_STANDARDVISCAL_H
30 :
31 : #include <casacore/casa/aips.h>
32 : #include <casacore/casa/Containers/Record.h>
33 : #include <casacore/casa/BasicSL/Complex.h>
34 : #include <synthesis/MeasurementComponents/VisCal.h>
35 : #include <synthesis/MeasurementComponents/SolvableVisCal.h>
36 : #include <synthesis/MeasurementComponents/CalCorruptor.h>
37 :
38 : namespace casa { //# NAMESPACE CASA - BEGIN
39 :
40 : // Forward declarations
41 : class VisEquation;
42 : class TJonesCorruptor;
43 :
44 :
45 : // **********************************************************
46 : // PJones
47 : //
48 :
49 : class PJones : public VisJones {
50 : public:
51 :
52 : // Constructor
53 : PJones(VisSet& vs);
54 : PJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
55 : PJones(const MSMetaInfoForCal& msmc);
56 :
57 : virtual ~PJones();
58 :
59 : // Return the type enum
60 39937 : virtual Type type() { return VisCal::P; };
61 :
62 : // Return type name as string
63 80 : virtual casacore::String typeName() { return "P Jones"; };
64 0 : virtual casacore::String longTypeName() { return "P Jones (parallactic angle phase)"; };
65 :
66 : // Type of Jones matrix according to nPar()
67 457440 : Jones::JonesType jonesType() { return pjonestype_; };
68 :
69 : protected:
70 :
71 : // P has one trivial casacore::Complex parameter
72 0 : virtual casacore::Int nPar() { return 1; };
73 :
74 106920 : virtual casacore::Vector<casacore::Float>& pa() { return pa_; };
75 :
76 : // Jones matrix elements are NOT trivial
77 35640 : virtual casacore::Bool trivialJonesElem() { return false; };
78 :
79 : // Calculate parallactic angle
80 : virtual void calcPar();
81 :
82 : // Detect basis and feed_pa for this vb
83 : virtual void syncMeta(const VisBuffer& vb);
84 : virtual void syncMeta2(const vi::VisBuffer2& vb);
85 :
86 : // Calculate a single PJones matrix
87 : virtual void calcOneJones(casacore::Vector<casacore::Complex>& mat, casacore::Vector<casacore::Bool>& mOk,
88 : const casacore::Vector<casacore::Complex>& par, const casacore::Vector<casacore::Bool>& pOk );
89 :
90 : private:
91 :
92 : Jones::JonesType pjonestype_;
93 :
94 : casacore::Vector<casacore::Float> pa_;
95 :
96 : };
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 : // **********************************************************
109 : // TJones
110 : //
111 :
112 : class TJones : public SolvableVisJones {
113 : public:
114 :
115 : // Constructor
116 : TJones(VisSet& vs);
117 : TJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
118 : TJones(const MSMetaInfoForCal& msmc);
119 : TJones(const casacore::Int& nAnt);
120 :
121 :
122 : virtual ~TJones();
123 :
124 : // Return the type enum
125 499008 : virtual Type type() { return VisCal::T; };
126 :
127 : // Return type name as string
128 118 : virtual casacore::String typeName() { return "T Jones"; };
129 12 : virtual casacore::String longTypeName() { return "T Jones (polarization-independent troposphere"; };
130 :
131 : // Local setSolve
132 : virtual void setSolve(const casacore::Record& solve);
133 :
134 : // Type of Jones matrix according to nPar()
135 2545266 : virtual Jones::JonesType jonesType() { return Jones::Scalar; };
136 :
137 : // This type is accumulatable
138 0 : virtual casacore::Bool accumulatable() { return true; };
139 :
140 : // This type is smoothable
141 4 : virtual casacore::Bool smoothable() { return true; };
142 :
143 : // Hazard a guess at parameters
144 : virtual void guessPar(VisBuffer& vb);
145 : virtual void guessPar(SDBList& sdbs,const casacore::Bool& corrDepFlags=false); // VI2
146 :
147 : // Set up corruptor
148 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
149 :
150 : protected:
151 :
152 : // T has one trivial complex parameter
153 19924137 : virtual casacore::Int nPar() { return 1; };
154 :
155 : // Jones matrix elements are trivial
156 123870 : virtual casacore::Bool trivialJonesElem() { return true; };
157 :
158 : // Are diff'd Js trivial?
159 9259167 : virtual casacore::Bool trivialDJ() { return true; };
160 :
161 : // Initialize trivial dJs
162 : virtual void initTrivDJ();
163 :
164 : private:
165 :
166 : // object that can simulate the corruption terms - internal to T;
167 : // public access is only to the CalCorruptor parts
168 : AtmosCorruptor *tcorruptor_p;
169 :
170 : };
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 : // **********************************************************
182 : // TfJones (freq-dep T)
183 : //
184 :
185 : class TfJones : public TJones {
186 : public:
187 :
188 : // Constructor
189 : TfJones(VisSet& vs);
190 : TfJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
191 : TfJones(const MSMetaInfoForCal& msmc);
192 : TfJones(const casacore::Int& nAnt);
193 :
194 : virtual ~TfJones();
195 :
196 : // Return the type enum
197 20249 : virtual Type type() { return VisCal::T; };
198 :
199 : // Return type name as string
200 50 : virtual casacore::String typeName() { return "Tf Jones"; };
201 0 : virtual casacore::String longTypeName() { return "Tf Jones (frequency-dependent atmospheric complex gain"; };
202 :
203 : // This is the freq-dep version of T
204 : // (this is the ONLY fundamental difference from T)
205 39276 : virtual casacore::Bool freqDepPar() { return true; };
206 :
207 : protected:
208 :
209 : // <nothing>
210 :
211 : private:
212 :
213 : // <nothing>
214 :
215 : };
216 :
217 :
218 :
219 :
220 :
221 : // **********************************************************
222 : // GJones
223 : //
224 :
225 : class GJones : public SolvableVisJones {
226 : public:
227 :
228 : // Constructor
229 : GJones(VisSet& vs);
230 : GJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
231 : GJones(const MSMetaInfoForCal& msmc);
232 : GJones(const casacore::Int& nAnt);
233 :
234 : virtual ~GJones();
235 :
236 : // Return the type enum
237 296316 : virtual Type type() { return VisCal::G; };
238 :
239 : // Return type name as string
240 1790 : virtual casacore::String typeName() { return "G Jones"; };
241 92 : virtual casacore::String longTypeName() { return "G Jones (electronic Gain)"; };
242 :
243 : // Local setSolve
244 : // (parses solmode)
245 : using SolvableVisJones::setSolve;
246 : virtual void setSolve(const casacore::Record& solve);
247 :
248 : // Type of Jones matrix according to nPar()
249 7524748 : virtual Jones::JonesType jonesType() { return Jones::Diagonal; };
250 :
251 : // This type is accumulatable
252 0 : virtual casacore::Bool accumulatable() { return true; };
253 :
254 : // This type is smoothable
255 11 : virtual casacore::Bool smoothable() { return true; };
256 :
257 : // Nominally, we will only use parallel hands for now
258 10564 : virtual casacore::Bool phandonly() { return true; };
259 :
260 : // Hazard a guess at parameters
261 : virtual void guessPar(VisBuffer& vb);
262 : virtual void guessPar(SDBList& sdbs,const casacore::Bool& corrDepFlags=false); // VI2
263 :
264 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
265 :
266 : protected:
267 :
268 : // G has two trivial casacore::Complex parameters
269 31890645 : virtual casacore::Int nPar() { return 2; };
270 :
271 : // Jones matrix elements are trivial
272 39257 : virtual casacore::Bool trivialJonesElem() { return true; };
273 :
274 : // dG/dp are trivial
275 10270441 : virtual casacore::Bool trivialDJ() { return true; };
276 :
277 : // Initialize trivial dJs
278 : virtual void initTrivDJ();
279 :
280 : private:
281 :
282 : GJonesCorruptor *gcorruptor_p;
283 :
284 : };
285 :
286 :
287 :
288 : // **********************************************************
289 : // BJones (freq-dep GJones)
290 : //
291 :
292 : class BJones : public GJones {
293 : public:
294 :
295 : // Constructor
296 : BJones(VisSet& vs);
297 : BJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
298 : BJones(const MSMetaInfoForCal& msmc);
299 : BJones(const casacore::Int& nAnt);
300 :
301 : virtual ~BJones();
302 :
303 : // Return the type enum
304 9014 : virtual Type type() { return VisCal::B; };
305 :
306 : // Return type name as string
307 157 : virtual casacore::String typeName() { return "B Jones"; };
308 14 : virtual casacore::String longTypeName() { return "B Jones (bandpass)"; };
309 :
310 : // Local setSolve
311 : using GJones::setSolve;
312 : virtual void setSolve(const casacore::Record& solve);
313 :
314 : // This is the freq-dep version of G
315 : // (this is the ONLY fundamental difference from G)
316 10635830 : virtual casacore::Bool freqDepPar() { return true; };
317 :
318 : virtual void normalize();
319 :
320 : // Specialize post solve operations (adds chan gap fill)
321 : virtual void globalPostSolveTinker();
322 :
323 : // Fill in bracketted channel gaps in solutions
324 : virtual void fillChanGaps();
325 : virtual void fillChanGapArray(casacore::Array<casacore::Complex>& sol,
326 : casacore::Array<casacore::Bool>& solOK);
327 :
328 : protected:
329 :
330 : // B-specific weight scaling factors
331 : virtual void calcWtScale(); // B-specific channel-collapsing weight scale calc
332 :
333 : private:
334 :
335 : // widest channel gap to fill by interpolation
336 : casacore::Int maxchangap_p;
337 :
338 :
339 : };
340 :
341 :
342 :
343 : // **********************************************************
344 : // JJones
345 : //
346 :
347 : class JJones : public SolvableVisJones {
348 : public:
349 :
350 : // Constructor
351 : JJones(VisSet& vs);
352 : JJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
353 : JJones(const MSMetaInfoForCal& msmc);
354 : JJones(const casacore::Int& nAnt);
355 :
356 : virtual ~JJones();
357 :
358 : // J-specific solve setup
359 : using SolvableVisJones::setSolve;
360 : void setSolve(const casacore::Record& solvepar);
361 :
362 : // Return the type enum
363 0 : virtual Type type() { return VisCal::J; };
364 :
365 : // Return type name as string
366 0 : virtual casacore::String typeName() { return "J Jones"; };
367 0 : virtual casacore::String longTypeName() { return "J Jones (generic polarized gain)"; };
368 :
369 :
370 : // Type of Jones matrix according to nPar()
371 0 : virtual Jones::JonesType jonesType() { return Jones::General; };
372 :
373 : // Hazard a guess at parameters
374 : virtual void guessPar(VisBuffer& vb);
375 :
376 : // J-specific reReference
377 : // TBD: non-triv impl
378 0 : virtual void reReference() {};
379 :
380 : protected:
381 :
382 : // J has four trivial casacore::Complex parameters
383 0 : virtual casacore::Int nPar() { return 4; };
384 :
385 : // Jones matrix elements are trivial
386 0 : virtual casacore::Bool trivialJonesElem() { return true; };
387 :
388 : // dJ/dp are trivial
389 0 : virtual casacore::Bool trivialDJ() { return true; };
390 :
391 : // Initialize trivial dJs
392 : virtual void initTrivDJ();
393 :
394 : private:
395 :
396 : // <nothing>
397 :
398 : };
399 :
400 :
401 : // **********************************************************
402 : // JfJones (freq-dep J)
403 : //
404 :
405 : class JfJones : public JJones {
406 : public:
407 :
408 : // Constructor
409 : JfJones(VisSet& vs);
410 : JfJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
411 : JfJones(const MSMetaInfoForCal& msmc);
412 : JfJones(const casacore::Int& nAnt);
413 :
414 : virtual ~JfJones();
415 :
416 : // Return the type enum
417 0 : virtual Type type() { return VisCal::J; };
418 :
419 : // Return type name as string
420 0 : virtual casacore::String typeName() { return "Jf Jones"; };
421 0 : virtual casacore::String longTypeName() { return "Jf Jones (frequency-dependent generic polarized gain)"; };
422 :
423 : // This is the freq-dep version of J
424 : // (this is the ONLY fundamental difference from J)
425 0 : virtual casacore::Bool freqDepPar() { return true; };
426 :
427 : protected:
428 :
429 : // <nothing>
430 :
431 : private:
432 :
433 : // <nothing>
434 :
435 : };
436 :
437 :
438 : // **********************************************************
439 : // M: baseline-based (closure)
440 : //
441 :
442 : /*
443 :
444 : class MMueller : public SolvableVisMueller {
445 : public:
446 :
447 : // Constructor
448 : MMueller(VisSet& vs);
449 : MMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
450 : MMueller(const MSMetaInfoForCal& msmc);
451 : MMueller(const casacore::Int& nAnt);
452 :
453 : virtual ~MMueller();
454 :
455 : // Return the type enum
456 : virtual Type type() { return VisCal::M; };
457 :
458 : // Return type name as string
459 : virtual casacore::String typeName() { return "M Mueller"; };
460 : virtual casacore::String longTypeName() { return "M Mueller (baseline-based)"; };
461 :
462 : // Type of Jones matrix according to nPar()
463 : virtual Mueller::MuellerType muellerType() { return Mueller::Diag2; };
464 :
465 : // Local setApply
466 : using SolvableVisCal::setApply;
467 : virtual void setApply(const casacore::Record& apply);
468 :
469 : // M gathers/solves for itself
470 : virtual casacore::Bool useGenericGatherForSolve() { return false; };
471 :
472 : // M solves for itself (by copying averaged data)
473 : virtual void selfGatherAndSolve(VisSet& vs, VisEquation& ve) { newselfSolve(vs,ve); };
474 : virtual void newselfSolve(VisSet& vs, VisEquation& ve); // new supports combine
475 :
476 : // Local M version only supports normalization
477 : virtual void globalPostSolveTinker();
478 :
479 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
480 : protected:
481 :
482 : // M currently has just 2 complex parameters, i.e., both parallel hands
483 : virtual casacore::Int nPar() { return 2; };
484 :
485 : // Jones matrix elements are trivial
486 : virtual casacore::Bool trivialMuellerElem() { return true; };
487 :
488 : private:
489 : AtmosCorruptor *atmcorruptor_p;
490 :
491 : };
492 :
493 :
494 :
495 :
496 :
497 :
498 : // **********************************************************
499 : // MfMueller (freq-dep MMueller)
500 : //
501 :
502 : class MfMueller : public MMueller {
503 : public:
504 :
505 : // Constructor
506 : MfMueller(VisSet& vs);
507 : MfMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
508 : MfMueller(const MSMetaInfoForCal& msmc);
509 : MfMueller(const casacore::Int& nAnt);
510 :
511 : virtual ~MfMueller();
512 :
513 : // Return the type enum
514 : virtual Type type() { return VisCal::M; };
515 :
516 : // Return type name as string
517 : virtual casacore::String typeName() { return "Mf Mueller"; };
518 : virtual casacore::String longTypeName() { return "Mf Mueller (closure bandpass)"; };
519 :
520 : // This is the freq-dep version of M
521 : // (this is the ONLY fundamental difference from M)
522 : virtual casacore::Bool freqDepPar() { return true; };
523 :
524 : // Normalize baseline spectra (after B)
525 : virtual void normalize();
526 :
527 : protected:
528 :
529 : // <nothing>
530 :
531 : private:
532 :
533 : // <nothing>
534 :
535 : };
536 :
537 : */
538 :
539 :
540 : // **********************************************************
541 : // TOPac
542 : //
543 :
544 : class TOpac : public TJones {
545 : public:
546 :
547 : // Constructor
548 : TOpac(VisSet& vs);
549 : TOpac(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
550 : TOpac(const MSMetaInfoForCal& msmc);
551 :
552 : virtual ~TOpac();
553 :
554 : // Return the type enum
555 0 : virtual Type type() { return VisCal::T; };
556 :
557 : // Return type name as string
558 0 : virtual casacore::String typeName() { return "TOpac"; };
559 0 : virtual casacore::String longTypeName() { return "TOpac (Opacity corrections in amplitude)"; };
560 :
561 :
562 : // Type of Jones matrix according to nPar()
563 0 : Jones::JonesType jonesType() { return Jones::Scalar; };
564 :
565 : // We have casacore::Float parameters
566 0 : virtual VisCalEnum::VCParType parType() { return VisCalEnum::REAL; };
567 :
568 : // Local specialization of setApply to extract opacity
569 : void setApply(const casacore::Record& applypar);
570 :
571 : // Report apply-related info
572 : casacore::String applyinfo();
573 :
574 : protected:
575 :
576 : // TOpac has one casacore::Float par per ant
577 0 : virtual casacore::Int nPar() { return 1; };
578 :
579 : // Jones matrix elements are NOT trivial
580 0 : virtual casacore::Bool trivialJonesElem() { return false; };
581 :
582 : // Access to z.a. data
583 0 : casacore::Vector<casacore::Double>& za() { return za_; };
584 :
585 : // Detect zenith angle for this vb
586 : virtual void syncMeta(const VisBuffer& vb);
587 : virtual void syncMeta2(const vi::VisBuffer2& vb);
588 :
589 : // Calculate parameters (in this case, the z.a.)
590 : virtual void calcPar();
591 :
592 : // Calculate the TOpac matrix for all ants
593 : virtual void calcAllJones();
594 :
595 : private:
596 :
597 : // avoid compiler warnings
598 : using TJones::setApply;
599 :
600 : // opacity per spw
601 : casacore::Vector<casacore::Double> opacity_;
602 :
603 : // zenith angle per antenna
604 : casacore::Vector<casacore::Double> za_;
605 :
606 : };
607 :
608 :
609 : // **********************************************************
610 : // TfOpac (freq-dep TOpac)
611 : //
612 :
613 : class TfOpac : public TOpac {
614 : public:
615 :
616 : // Constructor
617 : TfOpac(VisSet& vs);
618 : TfOpac(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
619 : TfOpac(const MSMetaInfoForCal& msmc);
620 :
621 : virtual ~TfOpac();
622 :
623 : // Return the type enum
624 0 : virtual Type type() { return VisCal::T; };
625 :
626 : // Return type name as string
627 0 : virtual casacore::String typeName() { return "TfOpac"; };
628 0 : virtual casacore::String longTypeName() { return "TfOpac (frequency-dependent opacity"; };
629 :
630 : // This is the freq-dep version of TOpac
631 : // (this is the ONLY fundamental difference from TOpac)
632 0 : virtual casacore::Bool freqDepPar() { return true; };
633 :
634 : protected:
635 :
636 : // Calculate the TfOpac matrix for all ants
637 : virtual void calcAllJones();
638 :
639 : private:
640 :
641 : // Frequency weight scaling factors
642 : virtual void calcWtScale();
643 :
644 : };
645 :
646 : // **********************************************************
647 : // M: baseline-based (closure)
648 : //
649 :
650 :
651 : class MMueller : public SolvableVisMueller {
652 : public:
653 :
654 : // Constructor
655 : MMueller(VisSet& vs);
656 : MMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
657 : MMueller(const MSMetaInfoForCal& msmc);
658 : MMueller(const casacore::Int& nAnt);
659 :
660 : virtual ~MMueller();
661 :
662 : // Return the type enum
663 101428 : virtual Type type() { return VisCal::M; };
664 :
665 : // Return type name as string
666 75 : virtual casacore::String typeName() { return "M Mueller"; };
667 30 : virtual casacore::String longTypeName() { return "M Mueller (baseline-based)"; };
668 :
669 : // Type of Jones matrix according to nPar()
670 101023 : virtual Mueller::MuellerType muellerType() { return Mueller::Diag2; };
671 :
672 : // Local setApply
673 : using SolvableVisCal::setApply;
674 : virtual void setApply(const casacore::Record& apply);
675 :
676 : // M gathers/solves for itself under self-determined conditions
677 : // Initialization: VI1: False ; VI2: True
678 16 : virtual casacore::Bool useGenericGatherForSolve() { return useGenGathSolve_p; };
679 :
680 : // When generically gathering (VI2 only!), _don't_ use generic solveOne
681 : // (use selfSolveOne below, which is just copy from averaged data)
682 1394 : virtual casacore::Bool useGenericSolveOne() { return !useGenGathSolve_p; };
683 :
684 : // M solves for itself (by copying averaged data)
685 5 : virtual void selfGatherAndSolve(VisSet& vs, VisEquation& ve) { newselfSolve(vs,ve); };
686 : virtual void newselfSolve(VisSet& vs, VisEquation& ve); // new supports combine
687 :
688 : // Local M version only supports normalization
689 : virtual void globalPostSolveTinker();
690 :
691 : // Modern solving
692 : virtual void selfSolveOne(SDBList& sdbs);
693 : using SolvableVisMueller::selfSolveOne; // VS/VI version (trap)
694 :
695 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
696 : protected:
697 :
698 : // M currently has just 2 complex parameters, i.e., both parallel hands
699 189654 : virtual casacore::Int nPar() { return 2; };
700 :
701 : // Jones matrix elements are trivial
702 264 : virtual casacore::Bool trivialMuellerElem() { return true; };
703 :
704 : // solve implementation
705 : virtual void solveOne(SDBList& sdbs);
706 :
707 : private:
708 : AtmosCorruptor *atmcorruptor_p;
709 :
710 : const bool useGenGathSolve_p; // true unless VisSet-driven ctor used
711 :
712 :
713 : };
714 :
715 :
716 : // **********************************************************
717 : // MfMueller (freq-dep MMueller)
718 : //
719 :
720 : class MfMueller : public MMueller {
721 : public:
722 :
723 : // Constructor
724 : MfMueller(VisSet& vs);
725 : MfMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
726 : MfMueller(const MSMetaInfoForCal& msmc);
727 : MfMueller(const casacore::Int& nAnt);
728 :
729 : virtual ~MfMueller();
730 :
731 : // Return the type enum
732 3780 : virtual Type type() { return VisCal::M; };
733 :
734 : // Return type name as string
735 5 : virtual casacore::String typeName() { return "Mf Mueller"; };
736 2 : virtual casacore::String longTypeName() { return "Mf Mueller (closure bandpass)"; };
737 :
738 : // This is the freq-dep version of M
739 : // (this is the ONLY fundamental difference from M)
740 258 : virtual casacore::Bool freqDepPar() { return true; };
741 :
742 : // Normalize baseline spectra (after B)
743 : virtual void normalize();
744 :
745 : protected:
746 :
747 : // <nothing>
748 :
749 : private:
750 :
751 : // <nothing>
752 :
753 : };
754 :
755 :
756 :
757 : } //# NAMESPACE CASA - END
758 :
759 : #endif
760 :
|
