source: branches/casa-release-4_3-test02/external-alma/atnf/PKSIO/NRODataset.h@ 3072

Last change on this file since 3072 was 2783, checked in by Takeshi Nakazato, 12 years ago

New Development: No

JIRA Issue: No

Ready for Test: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes/No

Module(s): Module Names change impacts.

Description: Describe your changes here...

more refactoring on NRO filler.


File size: 16.3 KB
Line 
1//#---------------------------------------------------------------------------
2//# NRODataset.h: Base class for NRO dataset.
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2000-2006
5//# Associated Universities, Inc. Washington DC, USA.
6//#
7//# This library is free software; you can redistribute it and/or modify it
8//# under the terms of the GNU Library General Public License as published by
9//# the Free Software Foundation; either version 2 of the License, or (at your
10//# option) any later version.
11//#
12//# This library is distributed in the hope that it will be useful, but WITHOUT
13//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
15//# License for more details.
16//#
17//# You should have received a copy of the GNU Library General Public License
18//# along with this library; if not, write to the Free Software Foundation,
19//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
20//#
21//# Correspondence concerning AIPS++ should be addressed as follows:
22//# Internet email: aips2-request@nrao.edu.
23//# Postal address: AIPS++ Project Office
24//# National Radio Astronomy Observatory
25//# 520 Edgemont Road
26//# Charlottesville, VA 22903-2475 USA
27//#
28//# $Id$
29//#---------------------------------------------------------------------------
30//# Original: 2009/02/27, Takeshi Nakazato, NAOJ
31//#---------------------------------------------------------------------------
32
33#ifndef NRO_DATASET_H
34#define NRO_DATASET_H
35
36#include <string>
37#include <stdio.h>
38#include <vector>
39#include <iostream>
40
41//#include <casa/aips.h>
42#include <casa/Logging/LogIO.h>
43#include <casa/Containers/Record.h>
44#include <casa/Utilities/CountedPtr.h>
45#include <atnf/PKSIO/NRODataRecord.h>
46#include <casa/namespace.h>
47#include <casa/iomanip.h>
48
49#define SCAN_HEADER_SIZE 424
50
51// <summary>
52// Base class for NRO accessor classes.
53// </summary>
54//
55// <prerequisite>
56// <li> <linkto class=NROReader>NROReader</linkto>
57// <li> <linkto class=NRODataRecord>NRODataRecord</linkto>
58// </prerequisite>
59//
60// <reviewed reviewer="" date="" tests="" demos="">
61// </reviewed>
62//
63// <etymology>
64// This class is a base class for classes that actually access data from NRO telescopes.
65// Concrete classes are defiened for each data type (OTF format or NRO FITS) and/or
66// telescopes (45m or ASTE).
67// The class have two filler method: fillHeader and fillRecord. The former reads header
68// information from the data. Since header data depends on the telescope and its configuration,
69// it is an abstract in this class and is defined in each concrete class.
70// On the other hand, the later reads each scan record (set of meta data
71// and spectral data). The method uses <linkto class=NRODataRecord>NRODataRecord</linkto>
72// to access scan record. It is implemented here since contents of scan record is
73// quite similar for several types of data.
74// </etymology>
75//
76// <synopsis>
77// Abstract class that is designed as a base class for all accessor classes.
78// </synopsis>
79//
80
81class NRODataset
82{
83 public:
84 // Constructor
85 NRODataset( std::string name ) ;
86
87 // Destructor
88 virtual ~NRODataset() ;
89
90 // Data initialization
91 virtual void initialize() = 0 ;
92
93 // open file
94 virtual int open() ;
95
96 // close file
97 virtual void close() ;
98
99 // Fill data header from file
100 virtual int fillHeader() ;
101
102 // Fill data record
103 virtual int fillRecord( int i ) ;
104
105 // simple getter
106 const std::string getLOFIL() const { return LOFIL ; } ;
107 const std::string getVER() const { return VER ; } ;
108 const std::string getGROUP() const { return GROUP ; } ;
109 const std::string getPROJ() const { return PROJ ; } ;
110 const std::string getSCHED() const { return SCHED ; } ;
111 const std::string getOBSVR() const { return OBSVR ; } ;
112 const std::string getLOSTM() const { return LOSTM ; } ;
113 const std::string getLOETM() const { return LOETM ; } ;
114 const int getARYNM() const { return ARYNM ; } ;
115 const int getNSCAN() const { return NSCAN ; } ;
116 const std::string getTITLE() const { return TITLE ; } ;
117 const std::string getOBJ() const { return OBJ ; } ;
118 const std::string getEPOCH() const { return EPOCH ; } ;
119 const double getRA0() const { return RA0 ; } ;
120 const double getDEC0() const { return DEC0 ; } ;
121 const double getGLNG0() const { return GLNG0 ; } ;
122 const double getGLAT0() const { return GLAT0 ; } ;
123 const int getNCALB() const { return NCALB ; } ;
124 const int getSCNCD() const { return SCNCD ; } ;
125 const std::string getSCMOD() const { return SCMOD ; } ;
126 const double getURVEL() const { return URVEL ; } ;
127 const std::string getVREF() const { return VREF ; } ;
128 const std::string getVDEF() const { return VDEF ; } ;
129 const std::string getSWMOD() const { return SWMOD ; } ;
130 const double getFRQSW() const { return FRQSW ; } ;
131 const double getDBEAM() const { return DBEAM ; } ;
132 const double getMLTOF() const { return MLTOF ; } ;
133 const double getCMTQ() const { return CMTQ ; } ;
134 const double getCMTE() const { return CMTE ; } ;
135 const double getCMTSOM() const { return CMTSOM ; } ;
136 const double getCMTNODE() const { return CMTNODE ; } ;
137 const double getCMTI() const { return CMTI ; } ;
138 const std::string getCMTTM() const { return CMTTM ; } ;
139 const double getSBDX() const { return SBDX ; } ;
140 const double getSBDY() const { return SBDY ; } ;
141 const double getSBDZ1() const { return SBDZ1 ; } ;
142 const double getSBDZ2() const { return SBDZ2 ; } ;
143 const double getDAZP() const { return DAZP ; } ;
144 const double getDELP() const { return DELP ; } ;
145 const int getCHBIND() const { return CHBIND ; } ;
146 const int getNUMCH() const { return NUMCH ; } ;
147 const int getCHMIN() const { return CHMIN ; } ;
148 const int getCHMAX() const { return CHMAX ; } ;
149 const double getALCTM() const { return ALCTM ; } ;
150 const double getIPTIM() const { return IPTIM ; } ;
151 const double getPA() const { return PA ; } ;
152 const int getSCNLEN() const { return SCNLEN ; } ;
153 const int getSBIND() const { return SBIND ; } ;
154 const int getIBIT() const { return IBIT ; } ;
155 const std::string getSITE() const { return SITE ; } ;
156 const std::vector<std::string> getRX() const { return RX ; } ;
157 const std::vector<double> getHPBW() const { return HPBW ; } ;
158 const std::vector<double> getEFFA() const { return EFFA ; } ;
159 const std::vector<double> getEFFB() const { return EFFB ; } ;
160 const std::vector<double> getEFFL() const { return EFFL ; } ;
161 const std::vector<double> getEFSS() const { return EFSS ; } ;
162 const std::vector<double> getGAIN() const { return GAIN ; } ;
163 const std::vector<std::string> getHORN() const { return HORN ; } ;
164 const std::vector<std::string> getPOLTP() const { return POLTP ; } ;
165 const std::vector<double> getPOLDR() const { return POLDR ; } ;
166 const std::vector<double> getPOLAN() const { return POLAN ; } ;
167 const std::vector<double> getDFRQ() const { return DFRQ ; } ;
168 const std::vector<std::string> getSIDBD() const { return SIDBD ; } ;
169 const std::vector<int> getREFN() const { return REFN ; } ;
170 const std::vector<int> getIPINT() const { return IPINT ; } ;
171 const std::vector<int> getMULTN() const { return MULTN ; } ;
172 const std::vector<double> getMLTSCF() const { return MLTSCF ; } ;
173 const std::vector<std::string> getLAGWIND() const { return LAGWIND ; } ;
174 const std::vector<double> getBEBW() const { return BEBW ; } ;
175 const std::vector<double> getBERES() const { return BERES ; } ;
176 const std::vector<double> getCHWID() const { return CHWID ; } ;
177 const std::vector<int> getARRY() const { return ARRY ; } ;
178 const std::vector<int> getNFCAL() const { return NFCAL ; } ;
179 const std::vector<double> getF0CAL() const { return F0CAL ; } ;
180 const std::vector< std::vector<double> > getFQCAL() const { return FQCAL ; } ;
181 const std::vector< std::vector<double> > getCHCAL() const { return CHCAL ; } ;
182 const std::vector< std::vector<double> > getCWCAL() const { return CWCAL ; } ;
183 const std::string getCDMY1() const { return CDMY1 ; } ;
184 const std::vector<double> getDSBFC() const { return DSBFC ;} ;
185 const int getDataSize() const { return datasize_ ; } ;
186 const int getRowNum() const { return rowNum_ ; } ;
187
188 // get various parameters
189 NRODataRecord *getRecord( int i ) ;
190 virtual std::vector< std::vector<double> > getSpectrum() ;
191 virtual std::vector<double> getSpectrum( int i ) ;
192 virtual int getIndex( int irow ) ;
193 virtual int getPolarizationNum() ;
194 virtual std::vector<double> getStartIntTime() ;
195 virtual double getStartIntTime( int i ) ;
196 virtual double getScanTime( int i ) ;
197 virtual double getMJD( const char *time ) ;
198 virtual std::vector<bool> getIFs() ;
199 virtual std::vector<double> getFrequencies( int i ) ;
200 virtual uInt getArrayId( std::string type ) ;
201 virtual uInt getSortedArrayId( std::string type ) ;
202 virtual uInt getPolNo( int irow ) ;
203
204 protected:
205 // initialize common part
206 void initializeCommon() ;
207
208 // fill header information
209 virtual int fillHeader( int sameEndian ) = 0 ;
210 int fillHeaderCommon( int sameEndian ) ;
211
212 // Endian conversion for int variable
213 void convertEndian( int &value ) ;
214
215 // Endian convertion for float variable
216 void convertEndian( float &value ) ;
217
218 // Endian conversion for double variable
219 void convertEndian( double &value ) ;
220
221 // Endian conversion for NRODataRecord
222 void convertEndian( NRODataRecord &r ) ;
223
224 // Read char data
225 int readHeader( char *v, int size ) ;
226
227 // Read int data
228 int readHeader( int &v, int b ) ;
229
230 // Read float data
231 int readHeader( float &v, int b ) ;
232
233 // Read double data
234 int readHeader( double &v, int b ) ;
235
236 // Release DataRecord
237 void releaseRecord() ;
238
239 // show primary information
240 void show() ;
241
242 // convert frequency frame
243 virtual double toLSR( double v, double t, double x, double y ) ;
244
245 // POLNO from RX
246 //uInt polNoFromRX( const char *rx ) ;
247 uInt polNoFromRX( const std::string &rx ) ;
248
249 // initialize array information (only for OTF data)
250 void initArray();
251
252 // return ARRYMAX
253 virtual int arrayMax() {return 0;} ;
254
255 // get scanNum from NSCAN (NSCAN or NSCAN + 1)
256 int getScanNum();
257
258 // Type of file record
259 std::string LOFIL ;
260
261 // Version
262 std::string VER ;
263
264 // Group name
265 std::string GROUP ;
266
267 // Project name
268 std::string PROJ ;
269
270 // Name of observation scheduling file
271 std::string SCHED ;
272
273 // Name of observer
274 std::string OBSVR ;
275
276 // Observation start time with format of "YYYYMMDDHHMMSS" (UTC)
277 std::string LOSTM ;
278
279 // observation end time with format of "YYYYMMDDHHMMSS" (UTC)
280 std::string LOETM ;
281
282 // Number of arrays (beams and IFs)
283 int ARYNM ;
284
285 // Number of scans
286 int NSCAN ;
287
288 // Title of observation
289 std::string TITLE ;
290
291 // Name of target object
292 std::string OBJ ;
293
294 // Equinox (B1950 or J2000)
295 std::string EPOCH ;
296
297 // Right ascension [rad]
298 double RA0 ;
299
300 // Declination [rad]
301 double DEC0 ;
302
303 // Galactic longitude [rad]
304 double GLNG0 ;
305
306 // Galactic latitude [rad]
307 double GLAT0 ;
308
309 // Calibration interval
310 int NCALB ;
311
312 // Scan coordinate (0: RADEC 1: LB 2: AZEL)
313 int SCNCD ;
314
315 // Scan sequence pattern
316 std::string SCMOD ;
317
318 // User-defined recessional velocity [m/s]
319 double URVEL ;
320
321 // Reference frame for recessional velocity (LSR or HEL or GAL)
322 std::string VREF ;
323
324 // Definition of recessional velocity (RAD or OPT)
325 std::string VDEF ;
326
327 // Switching mode (POS or BEAM or FREQ)
328 std::string SWMOD ;
329
330 // Switching frequency [Hz]
331 double FRQSW ;
332
333 // Off-beam angle of beam switching [rad]
334 double DBEAM ;
335
336 // Initial inclination angle of multi-beam array
337 double MLTOF ;
338
339 // Comet: Perihelion distance
340 double CMTQ ;
341
342 // Comet: Eccentricity
343 double CMTE ;
344
345 // Comet: Argument of perihelion
346 double CMTSOM ;
347
348 // Comet: Longitude of the ascending node
349 double CMTNODE ;
350
351 // Comet: Orbital inclination angle
352 double CMTI ;
353
354 // Comet: Time of the perihelion passage
355 std::string CMTTM ;
356
357 // Correction for position of subreflector DX [mm]
358 double SBDX ;
359
360 // Correction for position of subreflector DY [mm]
361 double SBDY ;
362
363 // Correction for position of subreflector DZ1 [mm]
364 double SBDZ1 ;
365
366 // Correction for position of subreflector DZ2 [mm]
367 double SBDZ2 ;
368
369 // Correction for pointing on azimuth [rad]
370 double DAZP ;
371
372 // Correction for pointing on elevation [rad]
373 double DELP ;
374
375 // Number of channel binding
376 int CHBIND ;
377
378 // Number of channel after binding
379 int NUMCH ;
380
381 // Channel range (minimum)
382 int CHMIN ;
383
384 // Channel range (maximum)
385 int CHMAX ;
386
387 // ALC time constant
388 double ALCTM ;
389
390 // Interval to get data from spectrometer
391 double IPTIM ;
392
393 // Position angle of the map
394 double PA ;
395
396 // Length of scan record [bytes]
397 int SCNLEN ;
398
399 // Range of space binding
400 int SBIND ;
401
402 // Quantization bit number (fixed to 12)
403 int IBIT ;
404
405 // Site (antenna) name (45m or ASTE)
406 std::string SITE ;
407
408 // Dummy data
409 std::string CDMY1 ;
410
411 // Type of detector frontend
412 std::vector<std::string> RX ;
413
414 // HPBW [rad]
415 std::vector<double> HPBW ;
416
417 // Aperture efficiencies
418 std::vector<double> EFFA ;
419
420 // Beam efficiencies
421 std::vector<double> EFFB ;
422
423 // Antenna efficiencies
424 std::vector<double> EFFL ;
425
426 // FSS efficiencies
427 std::vector<double> EFSS ;
428
429 // Antenna gain
430 std::vector<double> GAIN ;
431
432 // Type of polarization at feed horn (R or L or H or V)
433 std::vector<std::string> HORN ;
434
435 // Type of polarization (CIRC or LINR)
436 std::vector<std::string> POLTP ;
437
438 // Rotation direction of circular polarization
439 std::vector<double> POLDR ;
440
441 // Polarization angle of linear polarization
442 std::vector<double> POLAN ;
443
444 // Switching frequency of frequcency switching [Hz]
445 std::vector<double> DFRQ ;
446
447 // Type of sideband (LSB or USB or DSB)
448 std::vector<std::string> SIDBD ;
449
450 // Identifier of reference synthesizer
451 std::vector<int> REFN ;
452
453 // Temperature of calibrator
454 std::vector<int> IPINT ;
455
456 // Beam id of the multi-beam detector
457 std::vector<int> MULTN ;
458
459 // Scaling factor of the multi-beam detector
460 std::vector<double> MLTSCF ;
461
462 // Type of LAG window (NONE or HANN or HAMM or BLCK)
463 std::vector<std::string> LAGWIND ;
464
465 // Bandwidth at backend
466 std::vector<double> BEBW ;
467
468 // Spectral resolution at backend
469 std::vector<double> BERES ;
470
471 // Channel width at backend
472 std::vector<double> CHWID ;
473
474 // Array usage (1: used 0: not used)
475 std::vector<int> ARRY ;
476
477 // Frequency calibration: Number of measurement (max 10)
478 std::vector<int> NFCAL ;
479
480 // Frequency calibration: Central frequency [Hz]
481 std::vector<double> F0CAL ;
482
483 // Frequency calibration: Measured central frequency [Hz]
484 std::vector< std::vector<double> > FQCAL ;
485
486 // Frequency calibration: Measured channel number
487 std::vector< std::vector<double> > CHCAL ;
488
489 // Frequency calibration: Measured channel width [Hz]
490 std::vector< std::vector<double> > CWCAL ;
491
492 // DSB scaling factor
493 std::vector<double> DSBFC ;
494
495 // number of scan
496 int scanNum_ ;
497
498 // number of row
499 int rowNum_ ;
500
501 // length of scan (byte)
502 int scanLen_ ;
503
504 // length of spectral data (byte)
505 int dataLen_ ;
506
507 // Data size of the header [bytes]
508 int datasize_ ;
509
510 // maximum channel number
511 int chmax_ ;
512
513 // Current data id
514 int dataid_ ;
515
516 // Data record
517 CountedPtr<NRODataRecord> record_ ;
518
519 // input filename
520 std::string filename_ ;
521
522 // file pointer
523 FILE *fp_ ;
524
525 // OS endian
526 int same_ ;
527
528 // Logger
529 //LogIO os ;
530
531 // reference frequency for each array
532 std::vector<double> refFreq_ ;
533
534 // list of array names
535 std::vector<std::string> arrayNames_;
536
537 // record to store REFPIX, REFVAL, INCREMENT pair for each array
538 Record frec_ ;
539} ;
540
541// debug message output
542template<class T> inline void nro_debug_output( char *name, int len, std::vector<T> &val )
543{
544 for ( int i = 0 ; i < len ; i++ ) {
545 if ( i == 0 ) {
546 cout << setw(8) << left << name ;
547 }
548 else if ( ( i % 5 ) == 0 ) {
549 cout << endl << " " ;
550 }
551 cout << "\'" << val[i] << "\' " ;
552 }
553 cout << endl ;
554}
555
556template<class T> inline void nro_debug_output( char *name, int len1, int len2, std::vector< std::vector<T> > &val )
557{
558 for ( int i = 0 ; i < len1 ; i++ ) {
559 for ( int j = 0 ; j < len2 ; j++ ) {
560 if ( j == 0 ) {
561 if ( i < 10 )
562 cout << name << "0" << i << " " ;
563 else
564 cout << name << i << " " ;
565 }
566 else if ( ( j % 5 ) == 0 ) {
567 cout << endl << " " ;
568 }
569 cout << "\'" << val[i][j] << "\' " ;
570 }
571 cout << endl ;
572 }
573}
574
575
576#endif /* NRO_HEADER_H */
Note: See TracBrowser for help on using the repository browser.