Ignore:
Timestamp:
11/19/08 20:41:16 (16 years ago)
Author:
Malte Marquarding
Message:

update from livedata CVS

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/external/atnf/PKSIO/PKSreader.cc

    r1427 r1452  
    2626//#                        Charlottesville, VA 22903-2475 USA
    2727//#
    28 //# $Id: PKSreader.cc,v 19.6 2008-06-26 01:54:08 cal103 Exp $
     28//# $Id: PKSreader.cc,v 19.12 2008-11-17 06:58:07 cal103 Exp $
    2929//#---------------------------------------------------------------------------
    3030//# Original: 2000/08/23, Mark Calabretta, ATNF
     
    4141#include <casa/OS/File.h>
    4242
    43 
    4443//--------------------------------------------------------------- getPKSreader
    4544
     
    5049        const Int retry,
    5150        const Int interpolate,
    52         String &format,
    53         Vector<Bool> &beams,
    54         Vector<Bool> &IFs,
    55         Vector<uInt> &nChan,
    56         Vector<uInt> &nPol,
    57         Vector<Bool> &haveXPol,
    58         Bool   &haveBase,
    59         Bool   &haveSpectra)
     51        String &format)
    6052{
    6153  // Check accessibility of the input.
     
    6355  if (!inFile.exists()) {
    6456    format = "DATASET NOT FOUND";
    65     return 0;
     57    return 0x0;
    6658  }
    6759
    6860  if (!inFile.isReadable()) {
    6961    format = "DATASET UNREADABLE";
    70     return 0;
     62    return 0x0;
    7163  }
    7264
    7365  // Determine the type of input.
    74   PKSreader *reader = 0;
     66  PKSreader *reader = 0x0;
    7567  if (inFile.isRegular()) {
    7668    // Is it MBFITS or SDFITS?
     
    112104  }
    113105
     106  return reader;
     107}
     108
     109//--------------------------------------------------------------- getPKSreader
     110
     111// Search a list of directories for a Parkes Multibeam dataset and return an
     112// appropriate PKSreader for it.
     113
     114PKSreader* getPKSreader(
     115        const String name,
     116        const Vector<String> directories,
     117        const Int retry,
     118        const Int interpolate,
     119        Int    &iDir,
     120        String &format)
     121{
     122  PKSreader *reader = 0x0;
     123
     124  iDir = -1;
     125  Int nDir = directories.nelements();
     126  for (Int i = 0; i < nDir; i++) {
     127    String inName = directories(i) + "/" + name;
     128    reader = getPKSreader(inName, retry, interpolate, format);
     129    if (reader) {
     130      iDir = i;
     131      break;
     132    }
     133  }
     134
     135  return reader;
     136}
     137
     138//--------------------------------------------------------------- getPKSreader
     139
     140// Open an appropriate PKSreader for a Parkes Multibeam dataset.
     141
     142PKSreader* getPKSreader(
     143        const String name,
     144        const Int retry,
     145        const Int interpolate,
     146        String &format,
     147        Vector<Bool> &beams,
     148        Vector<Bool> &IFs,
     149        Vector<uInt> &nChan,
     150        Vector<uInt> &nPol,
     151        Vector<Bool> &haveXPol,
     152        Bool   &haveBase,
     153        Bool   &haveSpectra)
     154{
     155  PKSreader *reader = getPKSreader(name, retry, interpolate, format);
    114156
    115157  // Try to open it.
     
    119161      format += " OPEN ERROR";
    120162      delete reader;
    121     } else {
    122       return reader;
    123     }
    124   }
    125 
    126   return 0;
    127 }
    128 
    129 
    130 //--------------------------------------------------------------- getPKSreader
    131 
    132 // Search a list of directories for a Parkes Multibeam dataset and return an
     163      reader = 0x0;
     164    }
     165  }
     166
     167  return reader;
     168}
     169
     170//--------------------------------------------------------------- getPKSreader
     171
     172// Search a list of directories for a Parkes Multibeam dataset and open an
    133173// appropriate PKSreader for it.
    134174
     
    148188        Bool   &haveSpectra)
    149189{
    150   Int nDir = directories.nelements();
    151   for (iDir = 0; iDir < nDir; iDir++) {
    152     String inName = directories(iDir) + "/" + name;
    153     PKSreader *reader = getPKSreader(inName, retry, interpolate, format,
    154                                      beams, IFs, nChan, nPol, haveXPol,
    155                                      haveBase, haveSpectra);
    156     if (reader != 0) {
    157       return reader;
    158     }
    159   }
    160 
    161   iDir = -1;
    162   return 0;
    163 }
    164 
    165 
    166 //-------------------------------------------------------- PKSFITSreader::read
    167 
    168 // Read the next data record.
    169 
    170 Int PKSreader::read(
    171         Int             &scanNo,
    172         Int             &cycleNo,
    173         Double          &mjd,
    174         Double          &interval,
    175         String          &fieldName,
    176         String          &srcName,
    177         Vector<Double>  &srcDir,
    178         Vector<Double>  &srcPM,
    179         Double          &srcVel,
    180         String          &obsType,
    181         Int             &IFno,
    182         Double          &refFreq,
    183         Double          &bandwidth,
    184         Double          &freqInc,
    185         Double          &restFreq,
    186         Vector<Float>   &tcal,
    187         String          &tcalTime,
    188         Float           &azimuth,
    189         Float           &elevation,
    190         Float           &parAngle,
    191         Float           &focusAxi,
    192         Float           &focusTan,
    193         Float           &focusRot,
    194         Float           &temperature,
    195         Float           &pressure,
    196         Float           &humidity,
    197         Float           &windSpeed,
    198         Float           &windAz,
    199         Int             &refBeam,
    200         Int             &beamNo,
    201         Vector<Double>  &direction,
    202         Vector<Double>  &scanRate,
    203         Vector<Float>   &tsys,
    204         Vector<Float>   &sigma,
    205         Vector<Float>   &calFctr,
    206         Matrix<Float>   &baseLin,
    207         Matrix<Float>   &baseSub,
    208         Matrix<Float>   &spectra,
    209         Matrix<uChar>   &flagged,
    210         Complex         &xCalFctr,
    211         Vector<Complex> &xPol)
    212 {
    213   Int status;
    214   MBrecord MBrec;
    215 
    216   if ((status = read(MBrec))) {
    217     if (status != -1) {
    218       status = 1;
    219     }
    220 
    221     return status;
    222   }
    223 
    224   scanNo      = MBrec.scanNo;
    225   cycleNo     = MBrec.cycleNo;
    226   mjd         = MBrec.mjd;
    227   interval    = MBrec.interval;
    228   fieldName   = MBrec.fieldName;
    229   srcName     = MBrec.srcName;
    230   srcDir      = MBrec.srcDir;
    231   srcPM       = MBrec.srcPM;
    232   srcVel      = MBrec.srcVel;
    233   obsType     = MBrec.obsType;
    234   IFno        = MBrec.IFno;
    235   refFreq     = MBrec.refFreq;
    236   bandwidth   = MBrec.bandwidth;
    237   freqInc     = MBrec.freqInc;
    238   restFreq    = MBrec.restFreq;
    239   tcal        = MBrec.tcal;
    240   tcalTime    = MBrec.tcalTime;
    241   azimuth     = MBrec.azimuth;
    242   elevation   = MBrec.elevation;
    243   parAngle    = MBrec.parAngle;
    244   focusAxi    = MBrec.focusAxi;
    245   focusTan    = MBrec.focusTan;
    246   focusRot    = MBrec.focusRot;
    247   temperature = MBrec.temperature;
    248   pressure    = MBrec.pressure;
    249   humidity    = MBrec.humidity;
    250   windSpeed   = MBrec.windSpeed;
    251   windAz      = MBrec.windAz;
    252   refBeam     = MBrec.refBeam;
    253   beamNo      = MBrec.beamNo;
    254   direction   = MBrec.direction;
    255   scanRate    = MBrec.scanRate;
    256   tsys        = MBrec.tsys;
    257   sigma       = MBrec.sigma;
    258   calFctr     = MBrec.calFctr;
    259   baseLin     = MBrec.baseLin;
    260   baseSub     = MBrec.baseSub;
    261   spectra     = MBrec.spectra;
    262   flagged     = MBrec.flagged;
    263   xCalFctr    = MBrec.xCalFctr;
    264   xPol        = MBrec.xPol;
    265 
    266   return 0;
    267 }
     190  PKSreader *reader = getPKSreader(name, directories, retry, interpolate,
     191                                   iDir, format);
     192
     193  // Try to open it.
     194  if (reader) {
     195    if (reader->open(name, beams, IFs, nChan, nPol, haveXPol, haveBase,
     196                     haveSpectra)) {
     197      format += " OPEN ERROR";
     198      delete reader;
     199      reader = 0x0;
     200    }
     201  }
     202
     203  return reader;
     204}
Note: See TracChangeset for help on using the changeset viewer.