Line data    Source code

       1             : /*
       2             :  * VisBuffer2.cc
       3             :  *
       4             :  *  Created on: Aug 21, 2012
       5             :  *      Author: jjacobs
       6             :  */
       7             : 
       8             : 
       9             : #include <stdcasa/UtilJ.h>
      10             : #include <msvis/MSVis/VisBuffer2.h>
      11             : #include <msvis/MSVis/VisBufferImpl2.h>
      12             : #include <msvis/MSVis/ViImplementation2.h>
      13             : #include <msvis/MSVis/VisibilityIterator2.h>
      14             : 
      15             : using namespace casacore;
      16             : namespace casa {
      17             : 
      18             : namespace vi {
      19             : 
      20             : VisBuffer2 *
      21           0 : VisBuffer2::factory(VisBufferOptions options)
      22             : {
      23           0 :         return new VisBufferImpl2(options);
      24             : }
      25             : 
      26             : void
      27        4063 : VisBuffer2::associateWithVi2 (const VisibilityIterator2 * vi)
      28             : {
      29        4063 :     associatedVi_p = vi;
      30        4063 : }
      31             : 
      32             : 
      33             : ms::MsRow *
      34           0 : VisBuffer2::getRow (Int) const
      35             : {
      36           0 :     ThrowIf (true, "Not implemented by this subclass.");
      37             : 
      38           0 :     return 0;
      39             : }
      40             : 
      41             : ms::MsRow *
      42           0 : VisBuffer2::getRowMutable (Int)
      43             : {
      44           0 :     ThrowIf (true, "Not implemented by this subclass.");
      45             : 
      46           0 :     return 0;
      47             : }
      48             : 
      49             : const VisibilityIterator2 *
      50           0 : VisBuffer2::getVi () const
      51             : {
      52           0 :     return associatedVi_p;
      53             : }
      54             : 
      55             : // Rotate visibility phase for phase center offsets
      56           0 : void VisBufferUtil2::phaseCenterShift (VisBuffer2 & /*vb*/, const Vector<Double>& /*phase*/)
      57             : {
      58             : 
      59             :   // AlwaysAssert(static_cast<Int>(phase.nelements()) == vb.nRows(), AipsError);
      60             : 
      61             :   // // phase is in metres
      62             :   // // phase*(-2*pi*f/c) gives phase for the channel of the given baseline in radian
      63             :   // //   sign convention will _correct_ data
      64             : 
      65             :   // Vector<Double> freq(frequency());
      66             :   // Double ph, udx;
      67             :   // Complex cph;
      68             : 
      69             :   // for (Int row = 0; row < nRow(); ++row){
      70             : 
      71             :   //   udx = phase(row) * -2.0 * C::pi/C::c; // in radian/Hz
      72             : 
      73             :   //   for (Int channel = 0; channel < nChannels(); ++channel) {
      74             :   //     // Calculate the Complex factor for this row and channel
      75             :   //     ph = udx * freq(channel);
      76             : 
      77             :   //     if(ph!=0.){
      78             :   //    cph = Complex(cos(ph), sin(ph));
      79             :   //    // Shift each correlation:
      80             :   //    for (Int icor = 0; icor < nCorr(); ++icor) {
      81             :   //      if (visCubeOK_p) {
      82             :   //        visCube_p(icor, channel, row) *= cph;
      83             :   //      }
      84             :   //      if (modelVisCubeOK_p) {
      85             :   //        modelVisCube_p(icor, channel, row) *= cph;
      86             :   //      }
      87             :   //      if (correctedVisCubeOK_p) {
      88             :   //        correctedVisCube_p(icor, channel, row) *= cph;
      89             :   //      }
      90             :   //      // Of course floatDataCube does not have a phase to rotate.
      91             :   //    }
      92             :   //     }
      93             : 
      94             :   //   }
      95             :   // }
      96             : 
      97           0 : }
      98             : 
      99             : // Rotate visibility phase for phase center offsets
     100             : void
     101           0 : VisBufferUtil2::phaseCenterShift (VisBuffer2 & /*vb*/, Double /*dx*/, Double /*dy*/)
     102             : {
     103             : 
     104             :   // // no-op if no net shift
     105             :   // if (!(abs(dx) > 0 || abs(dy) > 0)) {
     106             :   //   return;
     107             :   // }
     108             : 
     109             :   // // Offsets in radians (input is arcsec)
     110             :   // dx *= (C::pi / 180.0 / 3600.0);
     111             :   // dy *= (C::pi / 180.0 / 3600.0);
     112             : 
     113             :   // // Extra path as fraction of U and V
     114             :   // Vector<Double> udx;
     115             :   // udx = vb.uvw ().row(0);
     116             :   // Vector<Double> vdy;
     117             :   // vdy = vb.uvw ().row(1);
     118             :   // udx *= dx;  // in m
     119             :   // vdy *= dy;
     120             : 
     121             :   // // Combine axes
     122             :   // udx += vdy;
     123             : 
     124             :   // phaseCenterShift (vb, udx);
     125             : 
     126           0 : }
     127             : 
     128             : 
     129             : 
     130             : } // end namespace vi
     131             : 
     132             : using namespace casacore;
     133             : } // end namespace casa
     134             : 
     135             :