Ignore:
Timestamp:
02/10/10 19:39:06 (14 years ago)
Author:
Takeshi Nakazato
Message:

New Development: No

JIRA Issue: Yes CAS-1908

Ready to Release: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes

Module(s): Module Names change impacts.

Description: Describe your changes here...

Changed a tagging as the source type is tagged by using SRCTYPE, not
an extra string in SRCNAME. To do this, I have defined a selection method
by SRCTYPE in STSelector class. I have newly added python_SrcType.cpp
that defines a Python interface of SrcType? enums which is defined
in atnf/PKSIO/SrcType.h.

Since I have added new file in the src directory, I have modified src/Makefile
to compile new file.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/alma/src/STMath.cpp

    r1682 r1693  
    4343#include <scimath/Mathematics/Convolver.h>
    4444#include <scimath/Functionals/Polynomial.h>
     45
     46#include <atnf/PKSIO/SrcType.h>
    4547
    4648#include <casa/Logging/LogIO.h>
    … …  
    819821  // make this operation non insitu
    820822  const Table& tin = in->table();
    821   Table ons = tin(tin.col("SRCTYPE") == Int(0));
    822   Table offs = tin(tin.col("SRCTYPE") == Int(1));
     823  Table ons = tin(tin.col("SRCTYPE") == Int(SrcType::PSON));
     824  Table offs = tin(tin.col("SRCTYPE") == Int(SrcType::PSOFF));
    823825  if ( offs.nrow() == 0 )
    824826    throw(AipsError("No 'off' scans present."));
    … …  
    12031205  setInsitu(false);
    12041206  STSelector sel;
    1205   std::vector<int> scan1, scan2, beams;
     1207  std::vector<int> scan1, scan2, beams, types;
    12061208  std::vector< vector<int> > scanpair;
    1207   std::vector<string> calstate;
     1209  //std::vector<string> calstate;
     1210  std::vector<int> calstate;
    12081211  String msg;
    12091212
    … …  
    12521255  scanpair.push_back(scan1);
    12531256  scanpair.push_back(scan2);
    1254   calstate.push_back("*calon");
    1255   calstate.push_back("*[^calon]");
     1257  //calstate.push_back("*calon");
     1258  //calstate.push_back("*[^calon]");
     1259  calstate.push_back(SrcType::NODCAL);
     1260  calstate.push_back(SrcType::NOD);
    12561261  CountedPtr< Scantable > ws = getScantable(s, false);
    12571262  uInt l=0;
    … …  
    12621267          sel.reset();
    12631268          sel.setScans(scanpair[i]);
    1264           sel.setName(calstate[k]);
     1269          //sel.setName(calstate[k]);
     1270          types.clear();
     1271          types.push_back(calstate[k]);
     1272          sel.setTypes(types);
    12651273          beams.clear();
    12661274          beams.push_back(j);
    … …  
    13771385  CountedPtr< Scantable > calsig, calref, out, out1, out2;
    13781386  Bool nofold=False;
     1387  vector<int> types ;
    13791388
    13801389  //split the data
    1381   sel.setName("*_fs");
     1390  //sel.setName("*_fs");
     1391  types.push_back( SrcType::FSON ) ;
     1392  sel.setTypes( types ) ;
    13821393  ws->setSelection(sel);
    13831394  sig = getScantable(ws,false);
    13841395  sel.reset();
    1385   sel.setName("*_fs_calon");
     1396  types.clear() ;
     1397  //sel.setName("*_fs_calon");
     1398  types.push_back( SrcType::FONCAL ) ;
     1399  sel.setTypes( types ) ;
    13861400  ws->setSelection(sel);
    13871401  sigwcal = getScantable(ws,false);
    13881402  sel.reset();
    1389   sel.setName("*_fsr");
     1403  types.clear() ;
     1404  //sel.setName("*_fsr");
     1405  types.push_back( SrcType::FSOFF ) ;
     1406  sel.setTypes( types ) ;
    13901407  ws->setSelection(sel);
    13911408  ref = getScantable(ws,false);
    13921409  sel.reset();
    1393   sel.setName("*_fsr_calon");
     1410  types.clear() ;
     1411  //sel.setName("*_fsr_calon");
     1412  types.push_back( SrcType::FOFFCAL ) ;
     1413  sel.setTypes( types ) ;
    13941414  ws->setSelection(sel);
    13951415  refwcal = getScantable(ws,false);
     1416  sel.reset() ;
     1417  types.clear() ;
    13961418
    13971419  calsig = dototalpower(sigwcal, sig, tcal=tcal);
    … …  
    35403562  }
    35413563  else {
    3542     string skystr = "*_sky" ;
    3543     string hotstr = "*_hot" ;
    3544     string coldstr = "*_cold" ;
    3545     string onstr = "*_" ;
    3546     string offstr = "*_" ;
    3547    
    3548     if ( calmode == "ps" || calmode == "otf" ) {
    3549       onstr += "pson" ;
    3550       offstr += "psoff" ;
    3551     }
    3552     else if ( calmode == "wob" ) {
    3553       onstr += "wobon" ;
    3554       offstr += "woboff" ;
    3555     }
    3556    
    35573564    vector<bool> masks = s->getMask( 0 ) ;
    3558    
     3565    vector<int> types ;
     3566
    35593567    // sky scan
    35603568    STSelector sel = STSelector() ;
    3561     sel.setName( skystr ) ;
     3569    types.push_back( SrcType::SKY ) ;
     3570    sel.setTypes( types ) ;
    35623571    s->setSelection( sel ) ;
    35633572    vector< CountedPtr<Scantable> > tmp( 1, getScantable( s, false ) ) ;
    … …  
    35653574    s->unsetSelection() ;
    35663575    sel.reset() ;
     3576    types.clear() ;
    35673577
    35683578    // hot scan
    3569     sel.setName( hotstr ) ;
     3579    types.push_back( SrcType::HOT ) ;
     3580    sel.setTypes( types ) ;
    35703581    s->setSelection( sel ) ;
    3571     tmp[0] = getScantable( s, false ) ;
     3582    tmp.clear() ;
     3583    tmp.push_back( getScantable( s, false ) ) ;
    35723584    CountedPtr<Scantable> ahot = average( tmp, masks, "TINT", "SCAN" ) ;
    35733585    s->unsetSelection() ;
    35743586    sel.reset() ;
     3587    types.clear() ;
    35753588   
    35763589    // cold scan
    3577     sel.setName( coldstr ) ;
     3590    CountedPtr<Scantable> acold ;
     3591//     types.push_back( SrcType::COLD ) ;
     3592//     sel.setTypes( types ) ;
     3593//     s->setSelection( sel ) ;
     3594//     tmp.clear() ;
     3595//     tmp.push_back( getScantable( s, false ) ) ;
     3596//     CountedPtr<Scantable> acold = average( tmp, masks, "TINT", "SCNAN" ) ;
     3597//     s->unsetSelection() ;
     3598//     sel.reset() ;
     3599//     types.clear() ;
     3600
     3601    // off scan
     3602    types.push_back( SrcType::PSOFF ) ;
     3603    sel.setTypes( types ) ;
    35783604    s->setSelection( sel ) ;
    3579     tmp[0] = getScantable( s, false ) ;
    3580     CountedPtr<Scantable> acold = average( tmp, masks, "TINT", "SCNAN" ) ;
    3581     s->unsetSelection() ;
    3582     sel.reset() ;
    3583 
    3584     // off scan
    3585     sel.setName( offstr ) ;
    3586     s->setSelection( sel ) ;
    3587     tmp[0] = getScantable( s, false ) ;
     3605    tmp.clear() ;
     3606    tmp.push_back( getScantable( s, false ) ) ;
    35883607    CountedPtr<Scantable> aoff = average( tmp, masks, "TINT", "SCAN" ) ;
    35893608    s->unsetSelection() ;
    35903609    sel.reset() ;
     3610    types.clear() ;
    35913611   
    35923612    // on scan
    … …  
    35953615    CountedPtr<Scantable> out = getScantable( s, true ) ;
    35963616    insitu_ = insitu ;
    3597     sel.setName( onstr ) ;
     3617    types.push_back( SrcType::PSON ) ;
     3618    sel.setTypes( types ) ;
    35983619    s->setSelection( sel ) ;
    35993620    TableCopy::copyRows( out->table(), s->table() ) ;
    36003621    s->unsetSelection() ;
    36013622    sel.reset() ;
     3623    types.clear() ;
    36023624   
    36033625    // process each on scan
    … …  
    36223644    }
    36233645
    3624     // remove additional string from SRCNAME
    3625     ScalarColumn<String> srcnameCol ;
    3626     srcnameCol.attach( out->table(), "SRCNAME" ) ;
    3627     Vector<String> srcnames( srcnameCol.getColumn() ) ;
    3628     for ( uInt i = 0 ; i < srcnames.nelements() ; i++ ) {
    3629       srcnames[i] = srcnames[i].substr( 0, srcnames[i].find( onstr.substr(1,onstr.size()-1) ) ) ;
    3630     }
    3631     srcnameCol.putColumn( srcnames ) ;
    3632 
    36333646    // flux unit
    36343647    out->setFluxUnit( "K" ) ;
    … …  
    36503663    // off scan
    36513664    STSelector sel = STSelector() ;
    3652     string taql = "SELECT FROM $1 WHERE SRCTYPE == 1" ;
    3653     sel.setTaQL( taql ) ;
     3665    vector<int> types ;
     3666    types.push_back( SrcType::PSOFF ) ;
     3667    sel.setTypes( types ) ;
    36543668    s->setSelection( sel ) ;
    36553669    // TODO 2010/01/08 TN
    … …  
    36923706    s->unsetSelection() ;
    36933707    sel.reset() ;
     3708    types.clear() ;
    36943709   
    36953710    // on scan
    … …  
    36983713    CountedPtr<Scantable> out = getScantable( s, true ) ;
    36993714    insitu_ = insitu ;
    3700     taql = "SELECT FROM $1 WHERE SRCTYPE == 0" ;
    3701     sel.setTaQL( taql ) ;
     3715    types.push_back( SrcType::PSON ) ;
     3716    sel.setTypes( types ) ;
    37023717    s->setSelection( sel ) ;
    37033718    TableCopy::copyRows( out->table(), s->table() ) ;
    37043719    s->unsetSelection() ;
    37053720    sel.reset() ;
     3721    types.clear() ;
    37063722   
    37073723    // process each on scan
    … …  
    37233739                                       const String antname )
    37243740{
    3725   string skystr = "*_sky" ;
    3726   string skystr1 = "*_fslo_sky" ;
    3727   string skystr2 = "*_fshi_sky" ;
    3728   string hotstr = "*_hot" ;
    3729   string hotstr1 = "*_fslo_hot" ;
    3730   string hotstr2 = "*_fshi_hot" ;
    3731   string coldstr = "*_cold" ;
    3732   string coldstr1 = "*_fslo_cold" ;
    3733   string coldstr2 = "*_fshi_cold" ;
    3734   string offstr1 = "*_fslo_off" ;
    3735   string offstr2 = "*_fshi_off" ;
    3736   string sigstr = "*_" ;
    3737   string refstr = "*_" ;
     3741  vector<int> types ;
    37383742
    37393743  // APEX calibration mode
    … …  
    37413745 
    37423746  if ( antname.find( "APEX" ) != string::npos ) {
    3743     sigstr += "fslo" ;
    3744     refstr += "fshi" ;   
    3745 
    37463747    // check if off scan exists or not
    37473748    STSelector sel = STSelector() ;
    3748     sel.setName( offstr1 ) ;
     3749    //sel.setName( offstr1 ) ;
     3750    types.push_back( SrcType::FLOOFF ) ;
     3751    sel.setTypes( types ) ;
    37493752    try {
    37503753      s->setSelection( sel ) ;
    … …  
    37533756      apexcalmode = 0 ;
    37543757    }
    3755   }
    3756   else {
    3757     sigstr += "fssig" ;
    3758     refstr += "fsref" ;
    3759   }
     3758    sel.reset() ;
     3759  }
     3760  s->unsetSelection() ;
     3761  types.clear() ;
    37603762
    37613763  vector<bool> masks = s->getMask( 0 ) ;
    … …  
    37633765  CountedPtr<Scantable> out ;
    37643766
    3765   if ( antname.find( "APEX" ) != string::npos && apexcalmode == 0 ) {
    3766     // APEX fs data without off scan
     3767  if ( antname.find( "APEX" ) != string::npos ) {
     3768    // APEX calibration
    37673769    // sky scan
    37683770    STSelector sel = STSelector() ;
    3769     sel.setName( skystr1 ) ;
     3771    types.push_back( SrcType::FLOSKY ) ;
     3772    sel.setTypes( types ) ;
    37703773    s->setSelection( sel ) ;
    37713774    vector< CountedPtr<Scantable> > tmp( 1, getScantable( s, false ) ) ;
    … …  
    37733776    s->unsetSelection() ;
    37743777    sel.reset() ;
    3775     sel.setName( skystr2 ) ;
     3778    types.clear() ;
     3779    types.push_back( SrcType::FHISKY ) ;
     3780    sel.setTypes( types ) ;
    37763781    s->setSelection( sel ) ;
    3777     tmp[0] = getScantable( s, false ) ;
     3782    tmp.clear() ;
     3783    tmp.push_back( getScantable( s, false ) ) ;
    37783784    CountedPtr<Scantable> askyhi = average( tmp, masks, "TINT", "SCAN" ) ;
    37793785    s->unsetSelection() ;
    37803786    sel.reset() ;
     3787    types.clear() ;
    37813788   
    37823789    // hot scan
    3783     sel.setName( hotstr1 ) ;
     3790    types.push_back( SrcType::FLOHOT ) ;
     3791    sel.setTypes( types ) ;
    37843792    s->setSelection( sel ) ;
    3785     tmp[0] = getScantable( s, false ) ;
     3793    tmp.clear() ;
     3794    tmp.push_back( getScantable( s, false ) ) ;
    37863795    CountedPtr<Scantable> ahotlo = average( tmp, masks, "TINT", "SCAN" ) ;
    37873796    s->unsetSelection() ;
    37883797    sel.reset() ;
    3789     sel.setName( hotstr2 ) ;
     3798    types.clear() ;
     3799    types.push_back( SrcType::FHIHOT ) ;
     3800    sel.setTypes( types ) ;
    37903801    s->setSelection( sel ) ;
    3791     tmp[0] = getScantable( s, false ) ;
     3802    tmp.clear() ;
     3803    tmp.push_back( getScantable( s, false ) ) ;
    37923804    CountedPtr<Scantable> ahothi = average( tmp, masks, "TINT", "SCAN" ) ;
    37933805    s->unsetSelection() ;
    37943806    sel.reset() ;
     3807    types.clear() ;
    37953808   
    37963809    // cold scan
    3797     sel.setName( coldstr1 ) ;
    3798     s->setSelection( sel ) ;
    3799     tmp[0] = getScantable( s, false ) ;
    3800     CountedPtr<Scantable> acoldlo = average( tmp, masks, "TINT", "SCAN" ) ;
    3801     s->unsetSelection() ;
    3802     sel.reset() ;
    3803     sel.setName( coldstr2 ) ;
    3804     s->setSelection( sel ) ;
    3805     tmp[0] = getScantable( s, false ) ;
    3806     CountedPtr<Scantable> acoldhi = average( tmp, masks, "TINT", "SCAN" ) ;
    3807     s->unsetSelection() ;
    3808     sel.reset() ;
    3809    
     3810    CountedPtr<Scantable> acoldlo, acoldhi ;
     3811//     types.push_back( SrcType::FLOCOLD ) ;
     3812//     sel.setTypes( types ) ;
     3813//     s->setSelection( sel ) ;
     3814//     tmp.clear() ;
     3815//     tmp.push_back( getScantable( s, false ) ) ;
     3816//     CountedPtr<Scantable> acoldlo = average( tmp, masks, "TINT", "SCAN" ) ;
     3817//     s->unsetSelection() ;
     3818//     sel.reset() ;
     3819//     types.clear() ;
     3820//     types.push_back( SrcType::FHICOLD ) ;
     3821//     sel.setTypes( types ) ;
     3822//     s->setSelection( sel ) ;
     3823//     tmp.clear() ;
     3824//     tmp.push_back( getScantable( s, false ) ) ;
     3825//     CountedPtr<Scantable> acoldhi = average( tmp, masks, "TINT", "SCAN" ) ;
     3826//     s->unsetSelection() ;
     3827//     sel.reset() ;
     3828//     types.clear() ;
     3829
    38103830    // ref scan
    38113831    bool insitu = insitu_ ;
    … …  
    38133833    sref = getScantable( s, true ) ;
    38143834    insitu_ = insitu ;
    3815     sel.setName( refstr ) ;
     3835    types.push_back( SrcType::FSLO ) ;
     3836    sel.setTypes( types ) ;
    38163837    s->setSelection( sel ) ;
    38173838    TableCopy::copyRows( sref->table(), s->table() ) ;
    38183839    s->unsetSelection() ;
    38193840    sel.reset() ;
     3841    types.clear() ;
    38203842   
    38213843    // sig scan
    … …  
    38233845    ssig = getScantable( s, true ) ;
    38243846    insitu_ = insitu ;
    3825     sel.setName( sigstr ) ;
     3847    types.push_back( SrcType::FSHI ) ;
     3848    sel.setTypes( types ) ;
    38263849    s->setSelection( sel ) ;
    38273850    TableCopy::copyRows( ssig->table(), s->table() ) ;
    38283851    s->unsetSelection() ;
    38293852    sel.reset() ; 
    3830 
    3831     // process each sig and ref scan
    3832     ArrayColumn<Float> tsysCollo ;
    3833     tsysCollo.attach( ssig->table(), "TSYS" ) ;
    3834     ArrayColumn<Float> tsysColhi ;
    3835     tsysColhi.attach( sref->table(), "TSYS" ) ;
    3836     for ( int i = 0 ; i < ssig->nrow() ; i++ ) {
    3837       vector< CountedPtr<Scantable> > sky( 2 ) ;
    3838       sky[0] = askylo ;
    3839       sky[1] = askyhi ;
    3840       vector< CountedPtr<Scantable> > hot( 2 ) ;
    3841       hot[0] = ahotlo ;
    3842       hot[1] = ahothi ;
    3843       vector< CountedPtr<Scantable> > cold( 2 ) ;
    3844       cold[0] = acoldlo ;
    3845       cold[1] = acoldhi ;
    3846       vector<float> sp = getFSCalibratedSpectra( ssig, sref, sky, hot, cold, i ) ;
    3847       ssig->setSpectrum( sp, i ) ;
    3848       string reftime = ssig->getTime( i ) ;
    3849       vector<int> ii( 1, ssig->getIF( i ) ) ;
    3850       vector<int> ib( 1, ssig->getBeam( i ) ) ;
    3851       vector<int> ip( 1, ssig->getPol( i ) ) ;
    3852       sel.setIFs( ii ) ;
    3853       sel.setBeams( ib ) ;
    3854       sel.setPolarizations( ip ) ;
    3855       askylo->setSelection( sel ) ;
    3856       vector<float> sptsys = getTsysFromTime( reftime, askylo, "linear" ) ;
    3857       const Vector<Float> Vtsyslo( sptsys ) ;
    3858       tsysCollo.put( i, Vtsyslo ) ;
    3859       askylo->unsetSelection() ;
     3853    types.clear() ;
     3854         
     3855    if ( apexcalmode == 0 ) {
     3856      // APEX fs data without off scan
     3857      // process each sig and ref scan
     3858      ArrayColumn<Float> tsysCollo ;
     3859      tsysCollo.attach( ssig->table(), "TSYS" ) ;
     3860      ArrayColumn<Float> tsysColhi ;
     3861      tsysColhi.attach( sref->table(), "TSYS" ) ;
     3862      for ( int i = 0 ; i < ssig->nrow() ; i++ ) {
     3863        vector< CountedPtr<Scantable> > sky( 2 ) ;
     3864        sky[0] = askylo ;
     3865        sky[1] = askyhi ;
     3866        vector< CountedPtr<Scantable> > hot( 2 ) ;
     3867        hot[0] = ahotlo ;
     3868        hot[1] = ahothi ;
     3869        vector< CountedPtr<Scantable> > cold( 2 ) ;
     3870        //cold[0] = acoldlo ;
     3871        //cold[1] = acoldhi ;
     3872        vector<float> sp = getFSCalibratedSpectra( ssig, sref, sky, hot, cold, i ) ;
     3873        ssig->setSpectrum( sp, i ) ;
     3874        string reftime = ssig->getTime( i ) ;
     3875        vector<int> ii( 1, ssig->getIF( i ) ) ;
     3876        vector<int> ib( 1, ssig->getBeam( i ) ) ;
     3877        vector<int> ip( 1, ssig->getPol( i ) ) ;
     3878        sel.setIFs( ii ) ;
     3879        sel.setBeams( ib ) ;
     3880        sel.setPolarizations( ip ) ;
     3881        askylo->setSelection( sel ) ;
     3882        vector<float> sptsys = getTsysFromTime( reftime, askylo, "linear" ) ;
     3883        const Vector<Float> Vtsyslo( sptsys ) ;
     3884        tsysCollo.put( i, Vtsyslo ) ;
     3885        askylo->unsetSelection() ;
     3886        sel.reset() ;
     3887        sky[0] = askyhi ;
     3888        sky[1] = askylo ;
     3889        hot[0] = ahothi ;
     3890        hot[1] = ahotlo ;
     3891        cold[0] = acoldhi ;
     3892        cold[1] = acoldlo ;
     3893        sp = getFSCalibratedSpectra( sref, ssig, sky, hot, cold, i ) ;
     3894        sref->setSpectrum( sp, i ) ;
     3895        reftime = sref->getTime( i ) ;
     3896        ii[0] = sref->getIF( i )  ;
     3897        ib[0] = sref->getBeam( i ) ;
     3898        ip[0] = sref->getPol( i ) ;
     3899        sel.setIFs( ii ) ;
     3900        sel.setBeams( ib ) ;
     3901        sel.setPolarizations( ip ) ;
     3902        askyhi->setSelection( sel ) ;   
     3903        sptsys = getTsysFromTime( reftime, askyhi, "linear" ) ;
     3904        const Vector<Float> Vtsyshi( sptsys ) ;
     3905        tsysColhi.put( i, Vtsyshi ) ;
     3906        askyhi->unsetSelection() ;
     3907        sel.reset() ;
     3908      }
     3909    }
     3910    else if ( apexcalmode == 1 ) {
     3911      // APEX fs data with off scan
     3912      // off scan
     3913      types.push_back( SrcType::FLOOFF ) ;
     3914      sel.setTypes( types ) ;
     3915      s->setSelection( sel ) ;
     3916      tmp.clear() ;
     3917      tmp.push_back( getScantable( s, false ) ) ;
     3918      CountedPtr<Scantable> aofflo = average( tmp, masks, "TINT", "SCAN" ) ;
     3919      s->unsetSelection() ;
    38603920      sel.reset() ;
    3861       sky[0] = askyhi ;
    3862       sky[1] = askylo ;
    3863       hot[0] = ahothi ;
    3864       hot[1] = ahotlo ;
    3865       cold[0] = acoldhi ;
    3866       cold[1] = acoldlo ;
    3867       sp = getFSCalibratedSpectra( sref, ssig, sky, hot, cold, i ) ;
    3868       sref->setSpectrum( sp, i ) ;
    3869       reftime = sref->getTime( i ) ;
    3870       ii[0] = sref->getIF( i )  ;
    3871       ib[0] = sref->getBeam( i ) ;
    3872       ip[0] = sref->getPol( i ) ;
    3873       sel.setIFs( ii ) ;
    3874       sel.setBeams( ib ) ;
    3875       sel.setPolarizations( ip ) ;
    3876       askyhi->setSelection( sel ) ;   
    3877       sptsys = getTsysFromTime( reftime, askyhi, "linear" ) ;
    3878       const Vector<Float> Vtsyshi( sptsys ) ;
    3879       tsysColhi.put( i, Vtsyshi ) ;
    3880       askyhi->unsetSelection() ;
     3921      types.clear() ;
     3922      types.push_back( SrcType::FHIOFF ) ;
     3923      sel.setTypes( types ) ;
     3924      s->setSelection( sel ) ;
     3925      tmp.clear() ;
     3926      tmp.push_back( getScantable( s, false ) ) ;
     3927      CountedPtr<Scantable> aoffhi = average( tmp, masks, "TINT", "SCAN" ) ;
     3928      s->unsetSelection() ;
    38813929      sel.reset() ;
    3882     }
    3883 
    3884   }
    3885   else if ( antname.find( "APEX" ) != string::npos && apexcalmode == 1 ) {
    3886     // APEX fs data with off scan
    3887     // sky scan
    3888     STSelector sel = STSelector() ;
    3889     sel.setName( skystr1 ) ;
    3890     s->setSelection( sel ) ;
    3891     vector< CountedPtr<Scantable> > tmp( 1, getScantable( s, false ) ) ;
    3892     CountedPtr<Scantable> askylo = average( tmp, masks, "TINT", "SCAN" ) ;
    3893     s->unsetSelection() ;
    3894     sel.reset() ;
    3895     sel.setName( skystr2 ) ;
    3896     s->setSelection( sel ) ;
    3897     tmp[0] = getScantable( s, false ) ;
    3898     CountedPtr<Scantable> askyhi = average( tmp, masks, "TINT", "SCAN" ) ;
    3899     s->unsetSelection() ;
    3900     sel.reset() ;
    3901    
    3902     // hot scan
    3903     sel.setName( hotstr1 ) ;
    3904     s->setSelection( sel ) ;
    3905     tmp[0] = getScantable( s, false ) ;
    3906     CountedPtr<Scantable> ahotlo = average( tmp, masks, "TINT", "SCAN" ) ;
    3907     s->unsetSelection() ;
    3908     sel.reset() ;
    3909     sel.setName( hotstr2 ) ;
    3910     s->setSelection( sel ) ;
    3911     tmp[0] = getScantable( s, false ) ;
    3912     CountedPtr<Scantable> ahothi = average( tmp, masks, "TINT", "SCAN" ) ;
    3913     s->unsetSelection() ;
    3914     sel.reset() ;
    3915    
    3916     // cold scan
    3917     sel.setName( coldstr1 ) ;
    3918     s->setSelection( sel ) ;
    3919     tmp[0] = getScantable( s, false ) ;
    3920     CountedPtr<Scantable> acoldlo = average( tmp, masks, "TINT", "SCAN" ) ;
    3921     s->unsetSelection() ;
    3922     sel.reset() ;
    3923     sel.setName( coldstr2 ) ;
    3924     s->setSelection( sel ) ;
    3925     tmp[0] = getScantable( s, false ) ;
    3926     CountedPtr<Scantable> acoldhi = average( tmp, masks, "TINT", "SCAN" ) ;
    3927     s->unsetSelection() ;
    3928     sel.reset() ;
    3929 
    3930     // off scan
    3931     sel.setName( offstr1 ) ;
    3932     s->setSelection( sel ) ;
    3933     tmp[0] = getScantable( s, false ) ;
    3934     CountedPtr<Scantable> aofflo = average( tmp, masks, "TINT", "SCAN" ) ;
    3935     s->unsetSelection() ;
    3936     sel.reset() ;
    3937     sel.setName( offstr2 ) ;
    3938     s->setSelection( sel ) ;
    3939     tmp[0] = getScantable( s, false ) ;
    3940     CountedPtr<Scantable> aoffhi = average( tmp, masks, "TINT", "SCAN" ) ;
    3941     s->unsetSelection() ;
    3942     sel.reset() ;
    3943    
    3944     // ref scan
    3945     bool insitu = insitu_ ;
    3946     insitu_ = false ;
    3947     sref = getScantable( s, true ) ;
    3948     insitu_ = insitu ;
    3949     sel.setName( refstr ) ;
    3950     s->setSelection( sel ) ;
    3951     TableCopy::copyRows( sref->table(), s->table() ) ;
    3952     s->unsetSelection() ;
    3953     sel.reset() ;
    3954    
    3955     // sig scan
    3956     insitu_ = false ;
    3957     ssig = getScantable( s, true ) ;
    3958     insitu_ = insitu ;
    3959     sel.setName( sigstr ) ;
    3960     s->setSelection( sel ) ;
    3961     TableCopy::copyRows( ssig->table(), s->table() ) ;
    3962     s->unsetSelection() ;
    3963     sel.reset() ;
    3964 
    3965     // process each sig and ref scan
    3966     ArrayColumn<Float> tsysCollo ;
    3967     tsysCollo.attach( ssig->table(), "TSYS" ) ;
    3968     ArrayColumn<Float> tsysColhi ;
    3969     tsysColhi.attach( sref->table(), "TSYS" ) ;
    3970     for ( int i = 0 ; i < ssig->nrow() ; i++ ) {
    3971       vector<float> sp = getCalibratedSpectra( ssig, aofflo, askylo, ahotlo, acoldlo, i, antname ) ;
    3972       ssig->setSpectrum( sp, i ) ;
    3973       sp = getCalibratedSpectra( sref, aoffhi, askyhi, ahothi, acoldhi, i, antname ) ;
    3974       string reftime = ssig->getTime( i ) ;
    3975       vector<int> ii( 1, ssig->getIF( i ) ) ;
    3976       vector<int> ib( 1, ssig->getBeam( i ) ) ;
    3977       vector<int> ip( 1, ssig->getPol( i ) ) ;
    3978       sel.setIFs( ii ) ;
    3979       sel.setBeams( ib ) ;
    3980       sel.setPolarizations( ip ) ;
    3981       askylo->setSelection( sel ) ;
    3982       vector<float> sptsys = getTsysFromTime( reftime, askylo, "linear" ) ;
    3983       const Vector<Float> Vtsyslo( sptsys ) ;
    3984       tsysCollo.put( i, Vtsyslo ) ;
    3985       askylo->unsetSelection() ;
    3986       sel.reset() ;
    3987       sref->setSpectrum( sp, i ) ;
    3988       reftime = sref->getTime( i ) ;
    3989       ii[0] = sref->getIF( i )  ;
    3990       ib[0] = sref->getBeam( i ) ;
    3991       ip[0] = sref->getPol( i ) ;
    3992       sel.setIFs( ii ) ;
    3993       sel.setBeams( ib ) ;
    3994       sel.setPolarizations( ip ) ;
    3995       askyhi->setSelection( sel ) ;   
    3996       sptsys = getTsysFromTime( reftime, askyhi, "linear" ) ;
    3997       const Vector<Float> Vtsyshi( sptsys ) ;
    3998       tsysColhi.put( i, Vtsyshi ) ;
    3999       askyhi->unsetSelection() ;
    4000       sel.reset() ;
    4001     }
    4002   }
    4003   else if ( antname.find( "APEX" ) == string::npos ) {
     3930      types.clear() ;
     3931     
     3932      // process each sig and ref scan
     3933      ArrayColumn<Float> tsysCollo ;
     3934      tsysCollo.attach( ssig->table(), "TSYS" ) ;
     3935      ArrayColumn<Float> tsysColhi ;
     3936      tsysColhi.attach( sref->table(), "TSYS" ) ;
     3937      for ( int i = 0 ; i < ssig->nrow() ; i++ ) {
     3938        vector<float> sp = getCalibratedSpectra( ssig, aofflo, askylo, ahotlo, acoldlo, i, antname ) ;
     3939        ssig->setSpectrum( sp, i ) ;
     3940        sp = getCalibratedSpectra( sref, aoffhi, askyhi, ahothi, acoldhi, i, antname ) ;
     3941        string reftime = ssig->getTime( i ) ;
     3942        vector<int> ii( 1, ssig->getIF( i ) ) ;
     3943        vector<int> ib( 1, ssig->getBeam( i ) ) ;
     3944        vector<int> ip( 1, ssig->getPol( i ) ) ;
     3945        sel.setIFs( ii ) ;
     3946        sel.setBeams( ib ) ;
     3947        sel.setPolarizations( ip ) ;
     3948        askylo->setSelection( sel ) ;
     3949        vector<float> sptsys = getTsysFromTime( reftime, askylo, "linear" ) ;
     3950        const Vector<Float> Vtsyslo( sptsys ) ;
     3951        tsysCollo.put( i, Vtsyslo ) ;
     3952        askylo->unsetSelection() ;
     3953        sel.reset() ;
     3954        sref->setSpectrum( sp, i ) ;
     3955        reftime = sref->getTime( i ) ;
     3956        ii[0] = sref->getIF( i )  ;
     3957        ib[0] = sref->getBeam( i ) ;
     3958        ip[0] = sref->getPol( i ) ;
     3959        sel.setIFs( ii ) ;
     3960        sel.setBeams( ib ) ;
     3961        sel.setPolarizations( ip ) ;
     3962        askyhi->setSelection( sel ) ;   
     3963        sptsys = getTsysFromTime( reftime, askyhi, "linear" ) ;
     3964        const Vector<Float> Vtsyshi( sptsys ) ;
     3965        tsysColhi.put( i, Vtsyshi ) ;
     3966        askyhi->unsetSelection() ;
     3967        sel.reset() ;
     3968      }
     3969    }
     3970  }
     3971  else {
    40043972    // non-APEX fs data
    40053973    // sky scan
    40063974    STSelector sel = STSelector() ;
    4007     sel.setName( skystr ) ;
     3975    types.push_back( SrcType::SKY ) ;
     3976    sel.setTypes( types ) ;
    40083977    s->setSelection( sel ) ;
    40093978    vector< CountedPtr<Scantable> > tmp( 1, getScantable( s, false ) ) ;
    … …  
    40113980    s->unsetSelection() ;
    40123981    sel.reset() ;
     3982    types.clear() ;
    40133983   
    40143984    // hot scan
    4015     sel.setName( hotstr ) ;
     3985    types.push_back( SrcType::HOT ) ;
     3986    sel.setTypes( types ) ;
    40163987    s->setSelection( sel ) ;
    4017     tmp[0] = getScantable( s, false ) ;
     3988    tmp.clear() ;
     3989    tmp.push_back( getScantable( s, false ) ) ;
    40183990    CountedPtr<Scantable> ahot = average( tmp, masks, "TINT", "SCAN" ) ;
    40193991    s->unsetSelection() ;
    40203992    sel.reset() ;
    4021 
    4022      // cold scan
    4023     sel.setName( coldstr ) ;
    4024     s->setSelection( sel ) ;
    4025     tmp[0] = getScantable( s, false ) ;
    4026     CountedPtr<Scantable> acold = average( tmp, masks, "TINT", "SCAN" ) ;
    4027     s->unsetSelection() ;
    4028     sel.reset() ;
     3993    types.clear() ;
     3994
     3995    // cold scan
     3996    CountedPtr<Scantable> acold ;
     3997//     types.push_back( SrcType::COLD ) ;
     3998//     sel.setTypes( types ) ;
     3999//     s->setSelection( sel ) ;
     4000//     tmp.clear() ;
     4001//     tmp.push_back( getScantable( s, false ) ) ;
     4002//     CountedPtr<Scantable> acold = average( tmp, masks, "TINT", "SCAN" ) ;
     4003//     s->unsetSelection() ;
     4004//     sel.reset() ;
     4005//     types.clear() ;
    40294006   
    40304007    // ref scan
    … …  
    40334010    sref = getScantable( s, true ) ;
    40344011    insitu_ = insitu ;
    4035     sel.setName( refstr ) ;
     4012    types.push_back( SrcType::FSOFF ) ;
     4013    sel.setTypes( types ) ;
    40364014    s->setSelection( sel ) ;
    40374015    TableCopy::copyRows( sref->table(), s->table() ) ;
    40384016    s->unsetSelection() ;
    40394017    sel.reset() ;
     4018    types.clear() ;
    40404019   
    40414020    // sig scan
    … …  
    40434022    ssig = getScantable( s, true ) ;
    40444023    insitu_ = insitu ;
    4045     sel.setName( sigstr ) ;
     4024    types.push_back( SrcType::FSON ) ;
     4025    sel.setTypes( types ) ;
    40464026    s->setSelection( sel ) ;
    40474027    TableCopy::copyRows( ssig->table(), s->table() ) ;
    40484028    s->unsetSelection() ;
    40494029    sel.reset() ;
     4030    types.clear() ;
    40504031
    40514032    // process each sig and ref scan
    … …  
    41414122          tmp[i] = dofold( ssig, sref, doffset ) ;
    41424123        }
    4143         // remove additional string from SRCNAME
    4144         ScalarColumn<String> srcnameCol ;
    4145         srcnameCol.attach( tmp[i]->table(), "SRCNAME" ) ;
    4146         Vector<String> srcnames( srcnameCol.getColumn() ) ;
    4147         for ( uInt i = 0 ; i < srcnames.nelements() ; i++ ) {
    4148           srcnames[i] = srcnames[i].substr( 0, srcnames[i].find( sigstr.substr(1,sigstr.size()-1) ) ) ;
    4149         }
    4150         srcnameCol.putColumn( srcnames ) ;
    41514124        ssig->unsetSelection() ;
    41524125        sref->unsetSelection() ;
    … …  
    46214594  sky->setSelection( sel ) ;
    46224595  hot->setSelection( sel ) ;
    4623   cold->setSelection( sel ) ;
     4596  //cold->setSelection( sel ) ;
    46244597  off->setSelection( sel ) ;
    46254598  vector<float> spsky = getSpectrumFromTime( reftime, sky, "linear" ) ;
    46264599  vector<float> sphot = getSpectrumFromTime( reftime, hot, "linear" ) ;
    4627   vector<float> spcold = getSpectrumFromTime( reftime, cold, "linear" ) ;
     4600  //vector<float> spcold = getSpectrumFromTime( reftime, cold, "linear" ) ;
    46284601  vector<float> spoff = getSpectrumFromTime( reftime, off, "linear" ) ;
    46294602  vector<float> spec = on->getSpectrum( index ) ;
    … …  
    46384611    }
    46394612  }
    4640   else if ( antname.find( "ALMA" ) != string::npos ) {
    4641     // two-load calibration
    4642     // from equation 5 and 12 of ALMA memo 318 (Mangum 2000)
    4643     //
    4644     // 2009/09/09 Takeshi Nakazato
    4645     for ( unsigned int j = 0 ; j < tcal.size() ; j++ ) {
    4646       //
    4647       // in case that Tcal is assumed as signal gain
    4648       //
    4649       //float K = ( sphot[j] - spcold[j] ) / ( thot - tcold ) ;
    4650       //float v = ( spec[j] - spoff[j] ) * exp( tsig ) / ( K * tcal[j] * eta ) ;
    4651       //
    4652       // in case that Tcal is defined as
    4653       //
    4654       //    Tcal = ( K * Gs * eta_l * exp( - tau_s ) )^-1
    4655       //
    4656       float v = tcal[j] * ( spec[j] - spsky[j] ) ;
    4657       sp[j] = v ;
    4658     }
    4659   }
    46604613  else {
    46614614    // Chopper-Wheel calibration (Ulich & Haas 1976)
    … …  
    46684621  sky->unsetSelection() ;
    46694622  hot->unsetSelection() ;
    4670   cold->unsetSelection() ;
     4623  //cold->unsetSelection() ;
    46714624  off->unsetSelection() ;
    46724625
    … …  
    47354688  sky->setSelection( sel ) ;
    47364689  hot->setSelection( sel ) ;
    4737   cold->setSelection( sel ) ;
     4690  //cold->setSelection( sel ) ;
    47384691  vector<float> spsky = getSpectrumFromTime( reftime, sky, "linear" ) ;
    47394692  vector<float> sphot = getSpectrumFromTime( reftime, hot, "linear" ) ;
    4740   vector<float> spcold = getSpectrumFromTime( reftime, cold, "linear" ) ;
     4693  //vector<float> spcold = getSpectrumFromTime( reftime, cold, "linear" ) ;
    47414694  vector<float> spref = ref->getSpectrum( index ) ;
    47424695  vector<float> spsig = sig->getSpectrum( index ) ;
    … …  
    47504703  sky->unsetSelection() ;
    47514704  hot->unsetSelection() ;
    4752   cold->unsetSelection() ;
     4705  //cold->unsetSelection() ;
    47534706
    47544707  return sp ;
    … …  
    47734726  sky[0]->setSelection( sel ) ;
    47744727  hot[0]->setSelection( sel ) ;
    4775   cold[0]->setSelection( sel ) ;
     4728  //cold[0]->setSelection( sel ) ;
    47764729  vector<float> spskys = getSpectrumFromTime( reftime, sky[0], "linear" ) ;
    47774730  vector<float> sphots = getSpectrumFromTime( reftime, hot[0], "linear" ) ;
    4778   vector<float> spcolds = getSpectrumFromTime( reftime, cold[0], "linear" ) ;
     4731  //vector<float> spcolds = getSpectrumFromTime( reftime, cold[0], "linear" ) ;
    47794732  vector<float> tcals = getTcalFromTime( reftime, sky[0], "linear" ) ;
    47804733  sel.reset() ;
    … …  
    47854738  sky[1]->setSelection( sel ) ;
    47864739  hot[1]->setSelection( sel ) ;
    4787   cold[1]->setSelection( sel ) ;
     4740  //cold[1]->setSelection( sel ) ;
    47884741  vector<float> spskyr = getSpectrumFromTime( reftime, sky[1], "linear" ) ;
    47894742  vector<float> sphotr = getSpectrumFromTime( reftime, hot[1], "linear" ) ;
    4790   vector<float> spcoldr = getSpectrumFromTime( reftime, cold[1], "linear" ) ;
     4743  //vector<float> spcoldr = getSpectrumFromTime( reftime, cold[1], "linear" ) ;
    47914744  vector<float> tcalr = getTcalFromTime( reftime, sky[1], "linear" ) ; 
    47924745  vector<float> spref = ref->getSpectrum( index ) ;
    … …  
    48004753  sky[0]->unsetSelection() ;
    48014754  hot[0]->unsetSelection() ;
    4802   cold[0]->unsetSelection() ;
     4755  //cold[0]->unsetSelection() ;
    48034756  sky[1]->unsetSelection() ;
    48044757  hot[1]->unsetSelection() ;
    4805   cold[1]->unsetSelection() ;
     4758  //cold[1]->unsetSelection() ;
    48064759
    48074760  return sp ;
Note: See TracChangeset for help on using the changeset viewer.