Line data    Source code

       1             : // -*- C++ -*-
       2             : //# PolOuterProduct.cc: Implementation of the PolOuterProduct class
       3             : //# Copyright (C) 1997,1998,1999,2000,2001,2002,2003
       4             : //# Associated Universities, Inc. Washington DC, USA.
       5             : //#
       6             : //# This library is free software; you can redistribute it and/or modify it
       7             : //# under the terms of the GNU Library General Public License as published by
       8             : //# the Free Software Foundation; either version 2 of the License, or (at your
       9             : //# option) any later version.
      10             : //#
      11             : //# This library is distributed in the hope that it will be useful, but WITHOUT
      12             : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13             : //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
      14             : //# License for more details.
      15             : //#
      16             : //# You should have received a copy of the GNU Library General Public License
      17             : //# along with this library; if not, write to the Free Software Foundation,
      18             : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
      19             : //#
      20             : //# Correspondence concerning AIPS++ should be addressed as follows:
      21             : //#        Internet email: aips2-request@nrao.edu.
      22             : //#        Postal address: AIPS++ Project Office
      23             : //#                        National Radio Astronomy Observatory
      24             : //#                        520 Edgemont Road
      25             : //#                        Charlottesville, VA 22903-2475 USA
      26             : //#
      27             : //# $Id$
      28             : //
      29             : #include <synthesis/TransformMachines2/PolOuterProduct.h>
      30             : 
      31             : using namespace casacore;
      32             : namespace casa{
      33             :   using namespace refim;
      34             :   //---------------------------------------------------------------------
      35             :   //
      36             :   // Map indices to the vis. pols. used.  This remains fixed for a
      37             :   // given imaging run.
      38             :   //
      39             :   // cfIndices_p are filled by this method and is determined by the
      40             :   // Stokes-I setting for a given imaging run.  Since this also
      41             :   // depends on the Pol. mapping in the MS, this mapping is determined
      42             :   // once (but has to be determined programmatically for each MS and
      43             :   // can't be a hard-coded convention here).
      44             :   //
      45        3614 :   void PolOuterProduct::initCFMaps(const Vector<Int>& vbPol, const Vector<Int>& visPol2ImMap)
      46             :   {
      47        3614 :     Int np=0;
      48             : 
      49       11326 :     for (uInt i=0;i<visPol2ImMap.nelements(); i++) 
      50             :       {
      51             :         Int n;
      52        7712 :         if (visPol2ImMap(i) >= 0) 
      53             :           {
      54        7316 :             n=translateStokesToGeneric(vbPol(i));
      55        7316 :             cfIndices_p.resize(n+1,true);
      56        7316 :             if (muellerType_p == DIAGONAL)        cfIndices_p(n).resize(1);
      57           0 :             else if (muellerType_p == FULL)       cfIndices_p(n).resize(4);
      58             :         
      59       14632 :             for(uInt j=0;j<cfIndices_p(n).nelements();j++) cfIndices_p(n)(j)=np++;
      60             :           }
      61             :       }   
      62        3614 :   }
      63             :   //---------------------------------------------------------------------
      64             :   //
      65             :   // Make a map between the vbPol indices and indices to get the CFs
      66             :   // to be used.  This can be dynamic, depending on the meaning of the
      67             :   // pol. axis of the visCube in the VB (which can change per VB).
      68             :   //
      69          85 :   PolMapType& PolOuterProduct::makePol2CFMat_p(const Vector<Int>& vbPol, 
      70             :                                                const Vector<Int>& vbPol2ImMap,
      71             :                                                PolMapType& outerProdNdx2VBPolMap)
      72             :   {
      73          85 :     Int nVBPol=vbPol.nelements();
      74          85 :     outerProdNdx2VBPolMap.resize(nVBPol);
      75         255 :     for (Int i=0;i<nVBPol; i++)
      76         170 :       if (vbPol2ImMap(i) >= 0)
      77             :         {
      78         170 :           Int n = translateStokesToGeneric(vbPol(i));
      79         170 :           outerProdNdx2VBPolMap(i).assign(cfIndices_p(n));
      80             :         }
      81          85 :     return outerProdNdx2VBPolMap;
      82             :   }
      83             : 
      84          85 :   PolMapType& PolOuterProduct::makePol2CFMat(const Vector<Int>& vbPol, 
      85             :                                              const Vector<Int>& vbPol2ImMap)
      86          85 :   {return makePol2CFMat_p(vbPol,vbPol2ImMap, outerProductIndex2VBPolMap_p);}
      87             : 
      88          85 :   PolMapType& PolOuterProduct::makeConjPol2CFMat(const Vector<Int>& vbPol, 
      89             :                                                  const Vector<Int>& /*vbPol2ImMap*/)
      90             :   {
      91          85 :     Int nVBPol=vbPol.nelements();
      92             :     // Resize the conj. index map.
      93          85 :     conjOuterProductIndex2VBPolMap_p.resize(nVBPol);
      94         255 :     for (Int i=0;i<nVBPol;i++)
      95         170 :       conjOuterProductIndex2VBPolMap_p(i).assign(outerProductIndex2VBPolMap_p(i));
      96             :     //
      97             :     // For each conjOuterProduct entry, find the equivalent entire in outerProductMap.
      98             :     // Copy of the assocaited index from outerProductIndex map to conjOuterProductMap
      99             :     //
     100         255 :     for (uInt i=0;i<conjOuterProduct2VBPolMap_p.nelements();i++)
     101         340 :       for (uInt j=0;j<conjOuterProduct2VBPolMap_p(i).nelements();j++)
     102             :         {
     103         170 :           Int el=conjOuterProduct2VBPolMap_p(i)(j);
     104             : 
     105         510 :           for (uInt ii=0;ii<outerProduct2VBPolMap_p.nelements();ii++)
     106         510 :             for (uInt jj=0;jj<outerProduct2VBPolMap_p(ii).nelements();jj++)
     107         340 :               if (outerProduct2VBPolMap_p(ii)(jj) == el)
     108             :                 {
     109         170 :                   conjOuterProductIndex2VBPolMap_p(i)(j) = outerProductIndex2VBPolMap_p(ii)(jj); 
     110         170 :                   break;
     111             :                 }
     112             :         }
     113          85 :     return conjOuterProductIndex2VBPolMap_p;
     114             :     //    return makePol2CFMat_p(vbPol,vbPol2ImMap, conjOuterProductIndex2VBPolMap_p);
     115             :   }
     116             : 
     117             :   //---------------------------------------------------------------------
     118             :   //
     119             :   // Map the CF indices to physical outer product enums.
     120             :   //
     121             :   // The muellerRows_p mapping is an internal convention and is hard coded in protected method makeMap().
     122             :   //
     123         170 :   PolMapType& PolOuterProduct::makePolMat_p(const Vector<Int>& vbPol, 
     124             :                                             const Vector<Int>& vbPol2ImMap,
     125             :                                             PolMapType& outerProd2VBPolMap,
     126             :                                             RigidVector<RigidVector<Int, 4>, 4>& mRows)
     127             :   {
     128         170 :     Int nVBPol=vbPol.nelements();
     129             :     
     130         170 :     outerProd2VBPolMap.resize(nVBPol);
     131         510 :     for (Int i=0; i<nVBPol; i++)
     132             :       {
     133         340 :         if (vbPol2ImMap(i) >= 0)
     134             :           {
     135         340 :             if (muellerType_p == DIAGONAL)
     136             :               {
     137         340 :                 outerProd2VBPolMap(i).resize(1);
     138         340 :                 Int n=translateStokesToGeneric(vbPol(i));
     139         340 :                 if (n==GPP) outerProd2VBPolMap(i)(0)=mRows(n)(0);
     140         340 :                 if (n==GPQ) outerProd2VBPolMap(i)(0)=mRows(n)(1);
     141         340 :                 if (n==GQP) outerProd2VBPolMap(i)(0)=mRows(n)(2);
     142         340 :                 if (n==GQQ) outerProd2VBPolMap(i)(0)=mRows(n)(3);
     143             :               }
     144           0 :             else if (muellerType_p == FULL)
     145             :               {
     146           0 :                 outerProd2VBPolMap(i).resize(4);
     147           0 :                 Int n=translateStokesToGeneric(vbPol(i));
     148           0 :                 outerProd2VBPolMap(i).assign(mRows(n).vector());
     149             :               }
     150             :           }
     151             :       }
     152         170 :     return outerProd2VBPolMap;
     153             :   }
     154          85 :   PolMapType& PolOuterProduct::makePolMat(const Vector<Int>& vbPol, 
     155             :                                           const Vector<Int>& vbPol2ImMap)
     156          85 :   {return makePolMat_p(vbPol,vbPol2ImMap, outerProduct2VBPolMap_p, muellerRows_p);}
     157          85 :   PolMapType& PolOuterProduct::makeConjPolMat(const Vector<Int>& vbPol, 
     158             :                                           const Vector<Int>& vbPol2ImMap)
     159          85 :   {return makePolMat_p(vbPol,vbPol2ImMap, conjOuterProduct2VBPolMap_p, conjMuellerRows_p);}
     160             :   //
     161             :   //---------------------------------------------------------------------
     162             :   //
     163           0 :   void PolOuterProduct::makePolMap(const Vector<CrossPolCircular>& pols)
     164             :   {
     165           0 :     for (uInt i=0;i<pols.nelements(); i++)
     166           0 :       setElement(pols(i),i);
     167           0 :   }
     168             :   //---------------------------------------------------------------------
     169             :   //
     170             :   // ToDo:Make hardcoded maps for this
     171             :   namespace refim{
     172        7826 :   PolOuterProduct::GenericVBPol translateStokesToGeneric(const Int& vbPol)
     173             :   {
     174        7826 :     if ((vbPol==Stokes::RR) || (vbPol==Stokes::XX)) return PolOuterProduct::GPP;
     175        4053 :     if ((vbPol==Stokes::RL) || (vbPol==Stokes::XY)) return PolOuterProduct::GPQ;
     176        3905 :     if ((vbPol==Stokes::LR) || (vbPol==Stokes::YX)) return PolOuterProduct::GQP;
     177        3757 :     if ((vbPol==Stokes::LL) || (vbPol==Stokes::YY)) return PolOuterProduct::GQQ;
     178           0 :     return PolOuterProduct::JUSTWRONGVBPOL;
     179             :   }
     180             :   //
     181             :   //---------------------------------------------------------------------
     182             :   // ToDo: Make hardcoded maps for this
     183           0 :   Int translateGenericToStokes2(const PolOuterProduct::GenericVBPol& gPol,
     184             :                                const MSIter::PolFrame& polFrame)
     185             :   {
     186           0 :     if (polFrame==MSIter::Circular)
     187             :       {
     188           0 :         if (gPol==PolOuterProduct::GPP) return Stokes::RR;
     189           0 :         if (gPol==PolOuterProduct::GPQ) return Stokes::RL;
     190           0 :         if (gPol==PolOuterProduct::GQP) return Stokes::LR;
     191           0 :         if (gPol==PolOuterProduct::GQQ) return Stokes::LL;
     192             :       }
     193           0 :     else if (polFrame==MSIter::Linear)
     194             :       {
     195           0 :         if (gPol==PolOuterProduct::GPP) return Stokes::XX;
     196           0 :         if (gPol==PolOuterProduct::GPQ) return Stokes::XY;
     197           0 :         if (gPol==PolOuterProduct::GQP) return Stokes::YX;
     198           0 :         if (gPol==PolOuterProduct::GQQ) return Stokes::YY;
     199             :       }
     200           0 :     return PolOuterProduct::JUSTWRONGVBPOL;
     201             :   }
     202             :   }
     203             : };