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 0 : virtual Type type() { return VisCal::P; };
61 :
62 : // Return type name as string
63 0 : 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 0 : 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 0 : virtual casacore::Vector<casacore::Float>& pa() { return pa_; };
75 :
76 : // Jones matrix elements are NOT trivial
77 0 : 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 12461 : virtual Type type() { return VisCal::T; };
126 :
127 : // Return type name as string
128 24 : virtual casacore::String typeName() { return "T Jones"; };
129 0 : virtual casacore::String longTypeName() { return "T Jones (polarization-independent troposphere"; };
130 :
131 : // Type of Jones matrix according to nPar()
132 4532 : virtual Jones::JonesType jonesType() { return Jones::Scalar; };
133 :
134 : // This type is accumulatable
135 0 : virtual casacore::Bool accumulatable() { return true; };
136 :
137 : // This type is smoothable
138 0 : virtual casacore::Bool smoothable() { return true; };
139 :
140 : // Hazard a guess at parameters
141 : virtual void guessPar(VisBuffer& vb);
142 : virtual void guessPar(SDBList& sdbs,const casacore::Bool& corrDepFlags=false); // VI2
143 :
144 : // Set up corruptor
145 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
146 :
147 : protected:
148 :
149 : // T has one trivial complex parameter
150 32594 : virtual casacore::Int nPar() { return 1; };
151 :
152 : // Jones matrix elements are trivial
153 4532 : virtual casacore::Bool trivialJonesElem() { return true; };
154 :
155 : // Are diff'd Js trivial?
156 0 : virtual casacore::Bool trivialDJ() { return true; };
157 :
158 : // Initialize trivial dJs
159 : virtual void initTrivDJ();
160 :
161 : private:
162 :
163 : // object that can simulate the corruption terms - internal to T;
164 : // public access is only to the CalCorruptor parts
165 : AtmosCorruptor *tcorruptor_p;
166 :
167 : };
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 : // **********************************************************
179 : // TfJones (freq-dep T)
180 : //
181 :
182 : class TfJones : public TJones {
183 : public:
184 :
185 : // Constructor
186 : TfJones(VisSet& vs);
187 : TfJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
188 : TfJones(const MSMetaInfoForCal& msmc);
189 : TfJones(const casacore::Int& nAnt);
190 :
191 : virtual ~TfJones();
192 :
193 : // Return the type enum
194 20249 : virtual Type type() { return VisCal::T; };
195 :
196 : // Return type name as string
197 50 : virtual casacore::String typeName() { return "Tf Jones"; };
198 0 : virtual casacore::String longTypeName() { return "Tf Jones (frequency-dependent atmospheric complex gain"; };
199 :
200 : // This is the freq-dep version of T
201 : // (this is the ONLY fundamental difference from T)
202 39276 : virtual casacore::Bool freqDepPar() { return true; };
203 :
204 : protected:
205 :
206 : // <nothing>
207 :
208 : private:
209 :
210 : // <nothing>
211 :
212 : };
213 :
214 :
215 :
216 :
217 :
218 : // **********************************************************
219 : // GJones
220 : //
221 :
222 : class GJones : public SolvableVisJones {
223 : public:
224 :
225 : // Constructor
226 : GJones(VisSet& vs);
227 : GJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
228 : GJones(const MSMetaInfoForCal& msmc);
229 : GJones(const casacore::Int& nAnt);
230 :
231 : virtual ~GJones();
232 :
233 : // Return the type enum
234 0 : virtual Type type() { return VisCal::G; };
235 :
236 : // Return type name as string
237 0 : virtual casacore::String typeName() { return "G Jones"; };
238 0 : virtual casacore::String longTypeName() { return "G Jones (electronic Gain)"; };
239 :
240 : // Local setSolve
241 : // (parses solmode)
242 : using SolvableVisJones::setSolve;
243 : virtual void setSolve(const casacore::Record& solve);
244 :
245 : // Type of Jones matrix according to nPar()
246 0 : virtual Jones::JonesType jonesType() { return Jones::Diagonal; };
247 :
248 : // This type is accumulatable
249 0 : virtual casacore::Bool accumulatable() { return true; };
250 :
251 : // This type is smoothable
252 0 : virtual casacore::Bool smoothable() { return true; };
253 :
254 : // Nominally, we will only use parallel hands for now
255 0 : virtual casacore::Bool phandonly() { return true; };
256 :
257 : // Hazard a guess at parameters
258 : virtual void guessPar(VisBuffer& vb);
259 : virtual void guessPar(SDBList& sdbs,const casacore::Bool& corrDepFlags=false); // VI2
260 :
261 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
262 :
263 : protected:
264 :
265 : // G has two trivial casacore::Complex parameters
266 0 : virtual casacore::Int nPar() { return 2; };
267 :
268 : // Jones matrix elements are trivial
269 0 : virtual casacore::Bool trivialJonesElem() { return true; };
270 :
271 : // dG/dp are trivial
272 0 : virtual casacore::Bool trivialDJ() { return true; };
273 :
274 : // Initialize trivial dJs
275 : virtual void initTrivDJ();
276 :
277 : private:
278 :
279 : GJonesCorruptor *gcorruptor_p;
280 :
281 : };
282 :
283 :
284 :
285 : // **********************************************************
286 : // BJones (freq-dep GJones)
287 : //
288 :
289 : class BJones : public GJones {
290 : public:
291 :
292 : // Constructor
293 : BJones(VisSet& vs);
294 : BJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
295 : BJones(const MSMetaInfoForCal& msmc);
296 : BJones(const casacore::Int& nAnt);
297 :
298 : virtual ~BJones();
299 :
300 : // Return the type enum
301 0 : virtual Type type() { return VisCal::B; };
302 :
303 : // Return type name as string
304 0 : virtual casacore::String typeName() { return "B Jones"; };
305 0 : virtual casacore::String longTypeName() { return "B Jones (bandpass)"; };
306 :
307 : // Local setSolve
308 : using GJones::setSolve;
309 : virtual void setSolve(const casacore::Record& solve);
310 :
311 : // This is the freq-dep version of G
312 : // (this is the ONLY fundamental difference from G)
313 0 : virtual casacore::Bool freqDepPar() { return true; };
314 :
315 : virtual void normalize();
316 :
317 : // Specialize post solve operations (adds chan gap fill)
318 : virtual void globalPostSolveTinker();
319 :
320 : // Fill in bracketted channel gaps in solutions
321 : virtual void fillChanGaps();
322 : virtual void fillChanGapArray(casacore::Array<casacore::Complex>& sol,
323 : casacore::Array<casacore::Bool>& solOK);
324 :
325 : protected:
326 :
327 : // B-specific weight scaling factors
328 : virtual void calcWtScale(); // B-specific channel-collapsing weight scale calc
329 :
330 : private:
331 :
332 : // widest channel gap to fill by interpolation
333 : casacore::Int maxchangap_p;
334 :
335 :
336 : };
337 :
338 :
339 :
340 : // **********************************************************
341 : // JJones
342 : //
343 :
344 : class JJones : public SolvableVisJones {
345 : public:
346 :
347 : // Constructor
348 : JJones(VisSet& vs);
349 : JJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
350 : JJones(const MSMetaInfoForCal& msmc);
351 : JJones(const casacore::Int& nAnt);
352 :
353 : virtual ~JJones();
354 :
355 : // J-specific solve setup
356 : using SolvableVisJones::setSolve;
357 : void setSolve(const casacore::Record& solvepar);
358 :
359 : // Return the type enum
360 0 : virtual Type type() { return VisCal::J; };
361 :
362 : // Return type name as string
363 0 : virtual casacore::String typeName() { return "J Jones"; };
364 0 : virtual casacore::String longTypeName() { return "J Jones (generic polarized gain)"; };
365 :
366 : // Type of Jones matrix according to nPar()
367 0 : virtual Jones::JonesType jonesType() { return Jones::General; };
368 :
369 : // Hazard a guess at parameters
370 : virtual void guessPar(VisBuffer& vb);
371 :
372 : // J-specific reReference
373 : // TBD: non-triv impl
374 0 : virtual void reReference() {};
375 :
376 : protected:
377 :
378 : // J has four trivial casacore::Complex parameters
379 0 : virtual casacore::Int nPar() { return 4; };
380 :
381 : // Jones matrix elements are trivial
382 0 : virtual casacore::Bool trivialJonesElem() { return true; };
383 :
384 : // dJ/dp are trivial
385 0 : virtual casacore::Bool trivialDJ() { return true; };
386 :
387 : // Initialize trivial dJs
388 : virtual void initTrivDJ();
389 :
390 : private:
391 :
392 : // <nothing>
393 :
394 : };
395 :
396 :
397 : // **********************************************************
398 : // JfJones (freq-dep J)
399 : //
400 :
401 : class JfJones : public JJones {
402 : public:
403 :
404 : // Constructor
405 : JfJones(VisSet& vs);
406 : JfJones(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
407 : JfJones(const MSMetaInfoForCal& msmc);
408 : JfJones(const casacore::Int& nAnt);
409 :
410 : virtual ~JfJones();
411 :
412 : // Return the type enum
413 0 : virtual Type type() { return VisCal::J; };
414 :
415 : // Return type name as string
416 0 : virtual casacore::String typeName() { return "Jf Jones"; };
417 0 : virtual casacore::String longTypeName() { return "Jf Jones (frequency-dependent generic polarized gain)"; };
418 :
419 : // This is the freq-dep version of J
420 : // (this is the ONLY fundamental difference from J)
421 0 : virtual casacore::Bool freqDepPar() { return true; };
422 :
423 : protected:
424 :
425 : // <nothing>
426 :
427 : private:
428 :
429 : // <nothing>
430 :
431 : };
432 :
433 :
434 : // **********************************************************
435 : // M: baseline-based (closure)
436 : //
437 :
438 : /*
439 :
440 : class MMueller : public SolvableVisMueller {
441 : public:
442 :
443 : // Constructor
444 : MMueller(VisSet& vs);
445 : MMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
446 : MMueller(const MSMetaInfoForCal& msmc);
447 : MMueller(const casacore::Int& nAnt);
448 :
449 : virtual ~MMueller();
450 :
451 : // Return the type enum
452 : virtual Type type() { return VisCal::M; };
453 :
454 : // Return type name as string
455 : virtual casacore::String typeName() { return "M Mueller"; };
456 : virtual casacore::String longTypeName() { return "M Mueller (baseline-based)"; };
457 :
458 : // Type of Jones matrix according to nPar()
459 : virtual Mueller::MuellerType muellerType() { return Mueller::Diag2; };
460 :
461 : // Local setApply
462 : using SolvableVisCal::setApply;
463 : virtual void setApply(const casacore::Record& apply);
464 :
465 : // M gathers/solves for itself
466 : virtual casacore::Bool useGenericGatherForSolve() { return false; };
467 :
468 : // M solves for itself (by copying averaged data)
469 : virtual void selfGatherAndSolve(VisSet& vs, VisEquation& ve) { newselfSolve(vs,ve); };
470 : virtual void newselfSolve(VisSet& vs, VisEquation& ve); // new supports combine
471 :
472 : // Local M version only supports normalization
473 : virtual void globalPostSolveTinker();
474 :
475 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
476 : protected:
477 :
478 : // M currently has just 2 complex parameters, i.e., both parallel hands
479 : virtual casacore::Int nPar() { return 2; };
480 :
481 : // Jones matrix elements are trivial
482 : virtual casacore::Bool trivialMuellerElem() { return true; };
483 :
484 : private:
485 : AtmosCorruptor *atmcorruptor_p;
486 :
487 : };
488 :
489 :
490 :
491 :
492 :
493 :
494 : // **********************************************************
495 : // MfMueller (freq-dep MMueller)
496 : //
497 :
498 : class MfMueller : public MMueller {
499 : public:
500 :
501 : // Constructor
502 : MfMueller(VisSet& vs);
503 : MfMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
504 : MfMueller(const MSMetaInfoForCal& msmc);
505 : MfMueller(const casacore::Int& nAnt);
506 :
507 : virtual ~MfMueller();
508 :
509 : // Return the type enum
510 : virtual Type type() { return VisCal::M; };
511 :
512 : // Return type name as string
513 : virtual casacore::String typeName() { return "Mf Mueller"; };
514 : virtual casacore::String longTypeName() { return "Mf Mueller (closure bandpass)"; };
515 :
516 : // This is the freq-dep version of M
517 : // (this is the ONLY fundamental difference from M)
518 : virtual casacore::Bool freqDepPar() { return true; };
519 :
520 : // Normalize baseline spectra (after B)
521 : virtual void normalize();
522 :
523 : protected:
524 :
525 : // <nothing>
526 :
527 : private:
528 :
529 : // <nothing>
530 :
531 : };
532 :
533 : */
534 :
535 :
536 : // **********************************************************
537 : // TOPac
538 : //
539 :
540 : class TOpac : public TJones {
541 : public:
542 :
543 : // Constructor
544 : TOpac(VisSet& vs);
545 : TOpac(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
546 : TOpac(const MSMetaInfoForCal& msmc);
547 :
548 : virtual ~TOpac();
549 :
550 : // Return the type enum
551 0 : virtual Type type() { return VisCal::T; };
552 :
553 : // Return type name as string
554 0 : virtual casacore::String typeName() { return "TOpac"; };
555 0 : virtual casacore::String longTypeName() { return "TOpac (Opacity corrections in amplitude)"; };
556 :
557 : // Type of Jones matrix according to nPar()
558 0 : Jones::JonesType jonesType() { return Jones::Scalar; };
559 :
560 : // We have casacore::Float parameters
561 0 : virtual VisCalEnum::VCParType parType() { return VisCalEnum::REAL; };
562 :
563 : // Local specialization of setApply to extract opacity
564 : void setApply(const casacore::Record& applypar);
565 :
566 : // Report apply-related info
567 : casacore::String applyinfo();
568 :
569 : protected:
570 :
571 : // TOpac has one casacore::Float par per ant
572 0 : virtual casacore::Int nPar() { return 1; };
573 :
574 : // Jones matrix elements are NOT trivial
575 0 : virtual casacore::Bool trivialJonesElem() { return false; };
576 :
577 : // Access to z.a. data
578 0 : casacore::Vector<casacore::Double>& za() { return za_; };
579 :
580 : // Detect zenith angle for this vb
581 : virtual void syncMeta(const VisBuffer& vb);
582 : virtual void syncMeta2(const vi::VisBuffer2& vb);
583 :
584 : // Calculate parameters (in this case, the z.a.)
585 : virtual void calcPar();
586 :
587 : // Calculate the TOpac matrix for all ants
588 : virtual void calcAllJones();
589 :
590 : private:
591 :
592 : // avoid compiler warnings
593 : using TJones::setApply;
594 :
595 : // opacity per spw
596 : casacore::Vector<casacore::Double> opacity_;
597 :
598 : // zenith angle per antenna
599 : casacore::Vector<casacore::Double> za_;
600 :
601 : };
602 :
603 :
604 : // **********************************************************
605 : // TfOpac (freq-dep TOpac)
606 : //
607 :
608 : class TfOpac : public TOpac {
609 : public:
610 :
611 : // Constructor
612 : TfOpac(VisSet& vs);
613 : TfOpac(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
614 : TfOpac(const MSMetaInfoForCal& msmc);
615 :
616 : virtual ~TfOpac();
617 :
618 : // Return the type enum
619 0 : virtual Type type() { return VisCal::T; };
620 :
621 : // Return type name as string
622 0 : virtual casacore::String typeName() { return "TfOpac"; };
623 0 : virtual casacore::String longTypeName() { return "TfOpac (frequency-dependent opacity"; };
624 :
625 : // This is the freq-dep version of TOpac
626 : // (this is the ONLY fundamental difference from TOpac)
627 0 : virtual casacore::Bool freqDepPar() { return true; };
628 :
629 : protected:
630 :
631 : // Calculate the TfOpac matrix for all ants
632 : virtual void calcAllJones();
633 :
634 : private:
635 :
636 : // Frequency weight scaling factors
637 : virtual void calcWtScale();
638 :
639 : };
640 :
641 : // **********************************************************
642 : // M: baseline-based (closure)
643 : //
644 :
645 :
646 : class MMueller : public SolvableVisMueller {
647 : public:
648 :
649 : // Constructor
650 : MMueller(VisSet& vs);
651 : MMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
652 : MMueller(const MSMetaInfoForCal& msmc);
653 : MMueller(const casacore::Int& nAnt);
654 :
655 : virtual ~MMueller();
656 :
657 : // Return the type enum
658 0 : virtual Type type() { return VisCal::M; };
659 :
660 : // Return type name as string
661 0 : virtual casacore::String typeName() { return "M Mueller"; };
662 0 : virtual casacore::String longTypeName() { return "M Mueller (baseline-based)"; };
663 :
664 : // Type of Jones matrix according to nPar()
665 0 : virtual Mueller::MuellerType muellerType() { return Mueller::Diag2; };
666 :
667 : // Local setApply
668 : using SolvableVisCal::setApply;
669 : virtual void setApply(const casacore::Record& apply);
670 :
671 : // M gathers/solves for itself under self-determined conditions
672 : // Initialization: VI1: False ; VI2: True
673 0 : virtual casacore::Bool useGenericGatherForSolve() { return useGenGathSolve_p; };
674 :
675 : // When generically gathering (VI2 only!), _don't_ use generic solveOne
676 : // (use selfSolveOne below, which is just copy from averaged data)
677 0 : virtual casacore::Bool useGenericSolveOne() { return !useGenGathSolve_p; };
678 :
679 : // M solves for itself (by copying averaged data)
680 0 : virtual void selfGatherAndSolve(VisSet& vs, VisEquation& ve) { newselfSolve(vs,ve); };
681 : virtual void newselfSolve(VisSet& vs, VisEquation& ve); // new supports combine
682 :
683 : // Local M version only supports normalization
684 : virtual void globalPostSolveTinker();
685 :
686 : // Modern solving
687 : virtual void selfSolveOne(SDBList& sdbs);
688 : using SolvableVisMueller::selfSolveOne; // VS/VI version (trap)
689 :
690 : virtual void createCorruptor(const VisIter& vi, const casacore::Record& simpar, const casacore::Int nSim);
691 : protected:
692 :
693 : // M currently has just 2 complex parameters, i.e., both parallel hands
694 0 : virtual casacore::Int nPar() { return 2; };
695 :
696 : // Jones matrix elements are trivial
697 0 : virtual casacore::Bool trivialMuellerElem() { return true; };
698 :
699 : // solve implementation
700 : virtual void solveOne(SDBList& sdbs);
701 :
702 : private:
703 : AtmosCorruptor *atmcorruptor_p;
704 :
705 : const bool useGenGathSolve_p; // true unless VisSet-driven ctor used
706 :
707 :
708 : };
709 :
710 :
711 : // **********************************************************
712 : // MfMueller (freq-dep MMueller)
713 : //
714 :
715 : class MfMueller : public MMueller {
716 : public:
717 :
718 : // Constructor
719 : MfMueller(VisSet& vs);
720 : MfMueller(casacore::String msname,casacore::Int MSnAnt,casacore::Int MSnSpw);
721 : MfMueller(const MSMetaInfoForCal& msmc);
722 : MfMueller(const casacore::Int& nAnt);
723 :
724 : virtual ~MfMueller();
725 :
726 : // Return the type enum
727 0 : virtual Type type() { return VisCal::M; };
728 :
729 : // Return type name as string
730 0 : virtual casacore::String typeName() { return "Mf Mueller"; };
731 0 : virtual casacore::String longTypeName() { return "Mf Mueller (closure bandpass)"; };
732 :
733 : // This is the freq-dep version of M
734 : // (this is the ONLY fundamental difference from M)
735 0 : virtual casacore::Bool freqDepPar() { return true; };
736 :
737 : // Normalize baseline spectra (after B)
738 : virtual void normalize();
739 :
740 : protected:
741 :
742 : // <nothing>
743 :
744 : private:
745 :
746 : // <nothing>
747 :
748 : };
749 :
750 :
751 :
752 : } //# NAMESPACE CASA - END
753 :
754 : #endif
755 :
|
