Line data    Source code

       1             : 
       2             : #include <msvis/MSVis/VisibilityIterator2.h>
       3             : #include <msvis/MSVis/ViImplementation2.h>
       4             : #include <msvis/MSVis/VisBufferImpl2.h>
       5             : #include <casacore/measures/Measures/MDirection.h>
       6             : #include <casacore/measures/Measures/MEpoch.h>
       7             : #include <casacore/casa/Quanta/MVTime.h>
       8             : #include <casacore/ms/MSOper/MSDerivedValues.h>
       9             : #include <casacore/casa/Arrays.h>
      10             : 
      11             : #include <algorithm>
      12             : using namespace std;
      13             : 
      14             : using namespace casacore;
      15             : namespace casa {
      16             : 
      17             : namespace vi {
      18             : 
      19             : // #pragma message "Change to pure abstract method before checkin."
      20             : // Vector<MPosition>
      21             : // ViImplementation2::antennaPositions () const
      22             : // {
      23             : //     return Vector<MPosition> ();
      24             : // }
      25             : 
      26             : 
      27             : VisBuffer2 *
      28         858 : ViImplementation2::createAttachedVisBuffer(VisBufferOptions options)
      29             : {
      30         858 :         return new VisBufferImpl2(this, options);
      31             : }
      32             : 
      33             : VisBuffer2 *
      34       17683 : ViImplementation2::getVisBuffer(const VisibilityIterator2 * vi) const
      35             : {
      36       17683 :         VisBuffer2 *result = getVisBuffer();
      37       17683 :         ThrowIf(result == nullptr, "VI Implementation has no VisBuffer.");
      38       17683 :         result->associateWithVi2(vi);
      39       17683 :         return result;
      40             : }
      41             : 
      42             : void
      43           0 : ViImplementation2::azel0Calculate (Double time, MSDerivedValues & msd,
      44             :         MDirection & azel0, const MEpoch & mEpoch0)
      45             : {
      46             :     // Refactored into a static method to allow VisBufferAsync to use
      47             : 
      48           0 :     MEpoch mEpoch = mEpoch0;
      49             : 
      50           0 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
      51             : 
      52           0 :     msd.setEpoch (mEpoch);
      53             : 
      54           0 :     msd.setAntenna (-1);
      55             : 
      56           0 :     azel0 = msd.azel ();
      57             : 
      58           0 :     if (aips_debug) {
      59           0 :         cout << "At time: " << MVTime (mEpoch.getValue ()) <<
      60           0 :              " AzEl = " << azel0.getAngle ("deg") << endl;
      61             :     }
      62           0 : }
      63             : 
      64             : void
      65         420 : ViImplementation2::azelCalculate (Double time, MSDerivedValues & msd, Vector<MDirection> & azel,
      66             :                                         Int nAnt, const MEpoch & mEpoch0)
      67             : {
      68             :     // Refactored into a static method to allow VisBufferAsync to use
      69             : 
      70         420 :     MEpoch mEpoch = mEpoch0;
      71             : 
      72         420 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
      73             : 
      74         420 :     msd.setEpoch (mEpoch);
      75             : 
      76             :     // Calculate az/el for all antennas.
      77             : 
      78         420 :     azel.resize (nAnt);
      79             : 
      80       12180 :     for (Int iant = 0; iant < nAnt; iant++) {
      81             : 
      82       11760 :         msd.setAntenna (iant);
      83       11760 :         azel (iant) = msd.azel ();
      84             : 
      85       11760 :         if (aips_debug) {
      86             : 
      87           0 :             if (iant == 0){
      88           0 :                 cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
      89           0 :                      " has AzEl = " << azel (iant).getAngle ("deg") << endl;
      90             :             }
      91             :         }
      92             :     }
      93         420 : }
      94             : 
      95             : 
      96             : Vector<Float>
      97           0 : ViImplementation2::feed_paCalculate (Double time, MSDerivedValues & msd,
      98             :                                            Int nAntennas, const MEpoch & mEpoch0,
      99             :                                             const Vector<Float> & receptor0Angle)
     100             : {
     101           0 :     MEpoch mEpoch = mEpoch0;
     102             : 
     103           0 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
     104             : 
     105           0 :     msd.setEpoch (mEpoch);
     106             : 
     107             :     // Calculate pa for all antennas.
     108             : 
     109           0 :     Vector<Float> feedpa (nAntennas);
     110             : 
     111           0 :     for (Int iant = 0; iant < nAntennas; iant++) {
     112             : 
     113           0 :         msd.setAntenna (iant);
     114           0 :         feedpa (iant) = msd.parAngle ();
     115             : 
     116             :         // add angle for receptor 0
     117             : 
     118           0 :         feedpa (iant) += receptor0Angle (iant);
     119             : 
     120           0 :         if (aips_debug && iant == 0) {
     121             : 
     122           0 :             cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
     123           0 :                     " has PA = " << feedpa (iant) * 57.28 << endl;
     124             :         }
     125             :     }
     126             : 
     127           0 :     return feedpa;
     128           0 : }
     129             : 
     130             : // MSDerivedValues
     131             : // ViImplementation2::makeMsd ()
     132             : // {
     133             : //     MSDerivedValues result;
     134             : 
     135             : //     result.setAntennaPositions (antennaPositions());
     136             : //     result.setAntennaMount (antennaMounts());
     137             : //     result.setFieldCenter (phaseCenter());
     138             : 
     139             : //     return result;
     140             : // }
     141             : 
     142             : 
     143             : Double
     144           0 : ViImplementation2::hourangCalculate (Double time, MSDerivedValues & msd, const MEpoch & mEpoch0)
     145             : {
     146           0 :     MEpoch mEpoch = mEpoch0;
     147             : 
     148           0 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
     149             : 
     150           0 :     msd.setEpoch (mEpoch);
     151             : 
     152           0 :     msd.setAntenna (-1);
     153             : 
     154           0 :     Double hourang = msd.hourAngle ();
     155             : 
     156           0 :     return hourang;
     157           0 : }
     158             : 
     159             : Float
     160           0 : ViImplementation2::parang0Calculate (Double time, MSDerivedValues & msd, const MEpoch & mEpoch0)
     161             : {
     162           0 :     MEpoch mEpoch = mEpoch0;
     163             : 
     164           0 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
     165           0 :     msd.setEpoch (mEpoch);
     166             : 
     167             :     // Calculate pa for all antennas.
     168           0 :     msd.setAntenna (-1);
     169           0 :     Float parang0 = msd.parAngle ();
     170             : 
     171           0 :     if (aips_debug)
     172           0 :         cout << "At time: " << MVTime (mEpoch.getValue ()) <<
     173           0 :              " PA = " << parang0 * 57.28 << " deg" << endl;
     174             : 
     175           0 :     return parang0;
     176           0 : }
     177             : 
     178             : Vector<Float>
     179           0 : ViImplementation2::parangCalculate (Double time, MSDerivedValues & msd, int nAntennas, const MEpoch mEpoch0)
     180             : {
     181           0 :     MEpoch mEpoch = mEpoch0;
     182           0 :     mEpoch.set (MVEpoch (Quantity (time, "s")));
     183             : 
     184           0 :     msd.setEpoch (mEpoch);
     185             : 
     186             :     // Calculate pa for all antennas.
     187             : 
     188           0 :     Vector<Float> parang (nAntennas);
     189             : 
     190           0 :     for (Int iant = 0; iant < nAntennas; iant++) {
     191             : 
     192           0 :         msd.setAntenna (iant);
     193           0 :         parang (iant) = msd.parAngle ();
     194             : 
     195           0 :         if (aips_debug && iant == 0) {
     196           0 :             cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
     197           0 :                  " has PA = " << parang (iant) * 57.28 << endl;
     198             :         }
     199             :     }
     200             : 
     201           0 :     return parang;
     202           0 : }
     203             : 
     204             : void
     205           0 : ViImplementation2::doWeightScaling (Bool hasWeightScaling,
     206             :                                     WeightScaling * scaling,
     207             :                                     const Array<Float>& unscaled,
     208             :                                     Array<Float>& scaled)
     209             : {
     210           0 :     if (hasWeightScaling){
     211             : 
     212             :         // Apply the scaling function to each of the weights.
     213             : 
     214           0 :         scaled.resize (unscaled.shape());
     215             : 
     216             :         std::transform <Array<Float>::const_contiter,
     217             :                         Array<Float>::contiter,
     218             :                         WeightScaling &>
     219           0 :             (unscaled.cbegin(), unscaled.cend(), scaled.cbegin(), * scaling);
     220             : 
     221             :     }
     222             :     else{
     223             : 
     224             :         // No scaling function so simply copy raw weights to scaled.
     225             : 
     226           0 :         scaled.assign (unscaled);
     227             :     }
     228           0 : }
     229             : 
     230             : // void
     231             : // ViImplementation2::setVisBufferFillable (VisBuffer2 * vb, Bool fillable)
     232             : // {
     233             : //     // Method to allow access to protected method of VB2
     234             : 
     235             : //     vb->setFillable (fillable);
     236             : // }
     237             : 
     238             : // pair<bool, casacore::MDirection>
     239             : // ViImplementation2::getPointingAngle (int antenna, double time) const
     240             : // {
     241             : //     throw AipsError ("Not implemented");
     242             : // }
     243             : 
     244             : } // end namespace vi
     245             : 
     246             : using namespace casacore;
     247             : } // end namespace casa