Ignore:
Timestamp:
Mar 22, 2019 2:52:55 PM (4 years ago)
Author:
srkline
Message:

many changes to the VCALC procedures to add in the hard/soft shadowing to the calculation, visualization of the shadowed regions, and the actual q-values. Added a separate panel to view the shadowed regions.

simpe fix to the real time routine to allow easy updating of both the raw 2D data and 1-D average

update to the USANS package to handle the new NICE generated data where the data is collected in terms of q-values rather than angle. On startup asks user which style of data they have. Sets a preference that can be un-checked if you have old-style ICP data. (there is nothing in the data file that I can key on).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/VSANS/VC_UtilityProcedures.ipf

    r1129 r1133  
    522522Function VC_Preset_WhiteBeam() 
    523523 
    524         VC_Preset_FrontMiddle_Ng0()             // moves Middle into contact (but w/ wrong lambda) 
    525524        // monochromator 
    526525        PopupMenu VCALCCtrl_0c,mode=1,popvalue="White Beam" 
     
    533532 
    534533// wavelength 
    535         SetVariable VCALCCtrl_0b,value=_NUM:5.3,disable=0       ,noedit=0       // allow user editing again 
    536          
     534        SetVariable VCALCCtrl_0b,value=_NUM:5.3//,disable=0     ,noedit=0       // allow user editing again 
     535 
     536        // adjust the front carriage 
     537        SetVariable VCALCCtrl_2a,value=_NUM:-20         //Left offset 
     538        SetVariable VCALCCtrl_2aa,value=_NUM:20         //Right offset 
     539        SetVariable VCALCCtrl_2b,value=_NUM:8                   //Top offset 
     540        SetVariable VCALCCtrl_2bb,value=_NUM:-8         //Bottom offset 
     541 
     542        SetVariable VCALCCtrl_2d,value=_NUM:120         //SDD 
     543 
     544        // middle carriage 
     545        SetVariable VCALCCtrl_3a,value=_NUM:-15         //Left offset 
     546        SetVariable VCALCCtrl_3aa,value=_NUM:15         //Right offset 
     547        SetVariable VCALCCtrl_3b,value=_NUM:15                  //Top offset (doesn't matter) 
     548        SetVariable VCALCCtrl_3bb,value=_NUM:-15                //Bottom offset (doesn't matter) 
     549 
     550        SetVariable VCALCCtrl_3d,value=_NUM:1900                //SDD 
     551         
     552// binning mode 
     553        PopupMenu popup_b,mode=1,popValue="F4-M4-B" 
     554 
     555// set preference to USE back detector 
     556        NVAR gIgnoreB = root:Packages:NIST:VSANS:Globals:gIgnoreDetB 
     557        gIgnoreB = 0 
     558         
     559                         
    537560        return(0) 
    538561end 
     
    574597         
    575598        // wavelength 
    576         SetVariable VCALCCtrl_0b,value=_NUM:4.75,disable=0      ,noedit=0       // allow user editing again 
     599        SetVariable VCALCCtrl_0b,value=_NUM:4.75//,disable=0    ,noedit=0       // allow user editing again 
    577600 
    578601        //number of guides 
     
    592615        Variable a2_to_GV,sam_to_GV,sdd,l2 
    593616        sdd = VC_getSDD(detStr)                 //sample pos to detector 
    594         ControlInfo VCALCCtrl_1d 
     617        ControlInfo/W=VCALC VCALCCtrl_1d 
    595618        a2_to_GV = V_Value 
    596         ControlInfo VCALCCtrl_1e 
     619        ControlInfo/W=VCALC VCALCCtrl_1e 
    597620        sam_to_GV = V_Value 
    598621        l2 = sdd - sam_to_GV + a2_to_GV 
     
    631654        Variable a2_to_GV,sam_to_GV,sdd 
    632655        sdd = VC_getSDD(detStr)                 //sample pos to detector 
    633         ControlInfo VCALCCtrl_1d 
     656        ControlInfo/W=VCALC VCALCCtrl_1d 
    634657        a2_to_GV = V_Value 
    635         ControlInfo VCALCCtrl_1e 
     658        ControlInfo/W=VCALC VCALCCtrl_1e 
    636659        sam_to_GV = V_Value 
    637660        l2 = sdd - sam_to_GV + a2_to_GV 
     
    642665     
    643666        // sample aperture diam [cm] 
    644         ControlInfo VCALCCtrl_1c 
     667        ControlInfo/W=VCALC VCALCCtrl_1c 
    645668        a2 = V_Value 
    646669     
     
    685708                case "B": 
    686709                case "B ": 
    687                         ControlInfo VCALCCtrl_4b 
     710                        ControlInfo/W=VCALC VCALCCtrl_4b 
    688711                        break 
    689712                case "ML": 
     
    691714                case "MT": 
    692715                case "MB": 
    693                         ControlInfo VCALCCtrl_3d 
     716                        ControlInfo/W=VCALC VCALCCtrl_3d 
    694717                        break 
    695718                case "FL": 
     
    697720                case "FT": 
    698721                case "FB": 
    699                         ControlInfo VCALCCtrl_2d 
     722                        ControlInfo/W=VCALC VCALCCtrl_2d 
    700723                        break            
    701724                default: 
     
    709732         
    710733        // VCALCCtrl_1e is Sample Pos to Gate Valve (cm) 
    711         ControlInfo VCALCCtrl_1e 
     734        ControlInfo/W=VCALC VCALCCtrl_1e 
    712735        sdd += V_Value 
    713736         
     
    739762        t_special = 1 
    740763 
    741         ControlInfo VCALCCtrl_0a 
     764        ControlInfo/W=VCALC VCALCCtrl_0a 
    742765        ng = V_Value 
    743766  
     
    858881        endswitch 
    859882 
    860  
    861 //      root:Packages:NIST:VSANS:VCALC:fSubS_qxqy_MLR 
    862 //      root:Packages:NIST:VSANS:VCALC:iBin_qxqy_MLR 
     883// TODO: 
     884// -- I had to put a lot of conditions on when not to try to apply the shadow factor 
     885// to avoid errors when iq had no points in the wave, or incorrectly applying the beamstop to the back panel. 
    863886         
    864887        Variable ii 
     
    868891                ext = StringFromList(ii, extStr, ";") 
    869892                Wave iq = $(folderStr+"iBin_qxqy_"+ext) 
    870                 Wave fs = $(folderStr+"fSubS_qxqy_"+ext) 
    871                 iq = (fs < 0.1) ? iq*0.1 : iq*fs 
    872 //              iq *= fs 
     893                Wave/Z fs = $(folderStr+"fSubS_qxqy_"+ext) 
     894                if(WaveExists(fs) && numpnts(iq) > 0 && cmpstr(ext,"B") != 0) 
     895                        iq = (fs < 0.1) ? iq*0.1 : iq*fs 
     896                endif 
    873897        endfor   
    874898         
    875899        return(0) 
    876900end 
     901 
     902 
     903 
     904// 
     905// instead of setting some of the data to NaN to exclude it, draw a proper mask to be used 
     906// during the I(q) averaging 
     907// 
     908// use both the "hard" and "soft" shadowing 
     909// -- chooses the more "conservative" of the shadowing values (soft value at short SDD + T/B) 
     910// 
     911// the MSK data will be in its ususal location from the initialization. 
     912// 
     913// FL shadows FT, FB, ML 
     914// FR shadows FT, FB, MR 
     915// FT shadows ML, MR, MT 
     916// FB shadows ML, MR, MB 
     917// ML shadows MT, MB, B 
     918// MR shadows MT, MB, B 
     919// MT shadows B 
     920// MB shadows B 
     921// 
     922Function VC_DrawVCALCMask() 
     923 
     924        VC_DrawVCALCMask_FL() 
     925        VC_DrawVCALCMask_FR() 
     926        VC_DrawVCALCMask_FT() 
     927        VC_DrawVCALCMask_FB() 
     928         
     929        VC_DrawVCALCMask_ML() 
     930        VC_DrawVCALCMask_MR() 
     931        VC_DrawVCALCMask_MT() 
     932        VC_DrawVCALCMask_MB() 
     933         
     934        return(0) 
     935end 
     936 
     937// FL shadows FT, FB, ML 
     938Function VC_DrawVCALCMask_FL() 
     939         
     940        Variable pixSizeX,pixSizeY,nPix,nt 
     941 
     942        Variable offset,offset_ML,L2_F,L2_M,delta_L,delta_S,D2 
     943        Variable delta_Xh,delta_Xs,delta_X_pix,delta 
     944        String type,target 
     945 
     946// FL shadows FT,FB,ML 
     947        type = "FL" 
     948 
     949        // lateral offset of FL 
     950        offset = VCALC_getPanelTranslation(type) 
     951        // sample aperture diam [cm] 
     952        D2 = VC_sampleApertureDiam() 
     953        // sdd F         [cm] = sample aperture to detector 
     954        L2_F = VC_calc_L2(type) 
     955        // depth of electronics (L/R panels) 
     956        delta_L = 33            //[cm] 
     957        // offset of 80/20 frame 
     958        delta_S = 2.5           //[cm] 
     959         
     960         
     961        // sdd of FT, or FB, or ML 
     962///// 
     963        target = "FT" 
     964        L2_M = VC_calc_L2(target) 
     965        // mask data 
     966        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     967 
     968// extent of shadow in [cm] (starting point of shadow from center of beam) 
     969// hard 
     970        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     971// soft 
     972        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     973 
     974        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     975        delta = min(delta_Xh,delta_Xs) 
     976 
     977// how many detector tubes to mask? 
     978        pixSizeX = VCALC_getPixSizeX(target) 
     979        pixSizeY = VCALC_getPixSizeY(target) 
     980 
     981        //since "target" is FT, use x-position 
     982        // at what "pixel" does the shadow start? 
     983        delta_X_pix = trunc(delta/pixSizeX)             //pixels from the center 
     984        nPix = VCALC_get_nPix_X(target) 
     985 
     986        if(delta_x_pix < trunc(nPix/2) )                        //still on the left side of the FT panel 
     987                nt = trunc(nPix/2) - delta_x_pix 
     988                mask[0,nt][] = 1 
     989        endif 
     990         
     991///// 
     992        target = "FB" 
     993        L2_M = VC_calc_L2(target) 
     994        // mask data 
     995        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     996 
     997// extent of shadow in [cm] (starting point of shadow from center of beam) 
     998// hard 
     999        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1000// soft 
     1001        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1002 
     1003        //use the smaller shadow value 
     1004        delta = min(delta_Xh,delta_Xs) 
     1005         
     1006// how many detector tubes to mask? 
     1007        pixSizeX = VCALC_getPixSizeX(target) 
     1008        pixSizeY = VCALC_getPixSizeY(target) 
     1009 
     1010        //since "target" is FB, use x-position 
     1011        // at what "pixel" does the shadow start? 
     1012        delta_X_pix = trunc(delta/pixSizeX) 
     1013        nPix = VCALC_get_nPix_X(target) 
     1014 
     1015        if(delta_x_pix < trunc(nPix/2) )                        //still on the left side of the FB panel 
     1016                nt = trunc(nPix/2) - delta_x_pix 
     1017                mask[0,nt][] = 1 
     1018        endif 
     1019 
     1020/// 
     1021// for ML, there can also be lateral offset of the ML panel 
     1022        target = "ML" 
     1023 
     1024        L2_M = VC_calc_L2(target) 
     1025        // mask data 
     1026        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1027 
     1028// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1029// hard 
     1030        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1031// soft 
     1032        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1033 
     1034        //use the smaller shadow value 
     1035        delta = min(delta_Xh,delta_Xs) 
     1036//      delta = delta_Xh 
     1037         
     1038// how many detector tubes to mask? 
     1039        pixSizeX = VCALC_getPixSizeX(target) 
     1040        pixSizeY = VCALC_getPixSizeY(target) 
     1041 
     1042// offset of ML, in "pixels" 
     1043        offset_ML = VCALC_getPanelTranslation(target)/pixSizeX          //[cm] 
     1044        offset_ML = -trunc(offset_ML) 
     1045        //since "target" is ML, use x-position 
     1046        // at what "pixel" does the shadow start? 
     1047        delta_X_pix = trunc(delta/pixSizeX) 
     1048        nPix = VCALC_get_nPix_X(target) 
     1049         
     1050        //is the delta_x_pix still on the left edge of ML? 
     1051        if(delta_x_pix < 0)             //entire panel is shadowed 
     1052                nt = nPix-1 
     1053                mask[0,nt][] = 1 
     1054        else 
     1055                if(delta_X_pix < nPix + offset_ML) 
     1056                        nt = nPix + offset_ML - delta_x_pix 
     1057                        mask[0,nt][] = 1 
     1058                endif 
     1059        endif 
     1060         
     1061        return(0) 
     1062end 
     1063 
     1064// FR shadows FT, FB, MR 
     1065Function VC_DrawVCALCMask_FR() 
     1066         
     1067        Variable pixSizeX,pixSizeY,nPix,nt 
     1068 
     1069        Variable offset,offset_MR,L2_F,L2_M,delta_L,delta_S,D2 
     1070        Variable delta_Xh,delta_Xs,delta_X_pix,delta 
     1071        String type,target 
     1072 
     1073// FR shadows FT, FB, MR 
     1074        type = "FR" 
     1075 
     1076        // lateral offset of FR 
     1077        offset = VCALC_getPanelTranslation(type) 
     1078        // sample aperture diam [cm] 
     1079        D2 = VC_sampleApertureDiam() 
     1080        // sdd F         [cm] = sample aperture to detector 
     1081        L2_F = VC_calc_L2(type) 
     1082        // depth of electronics (L/R panels) 
     1083        delta_L = 33            //[cm] 
     1084        // offset of 80/20 frame 
     1085        delta_S = 2.5           //[cm] 
     1086         
     1087         
     1088        // sdd of FT, or FB, or MR 
     1089///// 
     1090        target = "FT" 
     1091        L2_M = VC_calc_L2(target) 
     1092        // mask data 
     1093        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1094 
     1095// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1096// hard 
     1097        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1098// soft 
     1099        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1100 
     1101        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1102        delta = min(delta_Xh,delta_Xs) 
     1103 
     1104// how many detector tubes to mask? 
     1105        pixSizeX = VCALC_getPixSizeX(target) 
     1106        pixSizeY = VCALC_getPixSizeY(target) 
     1107 
     1108        //since "target" is FT, use x-position 
     1109        // at what "pixel" does the shadow start? 
     1110        delta_X_pix = trunc(delta/pixSizeX) 
     1111        nPix = VCALC_get_nPix_X(target) 
     1112 
     1113        if(delta_x_pix < trunc(nPix/2) )                        //still on the right side of the FT panel 
     1114                nt = trunc(nPix/2) - delta_x_pix 
     1115                mask[nPix-nt,nPix-1][] = 1 
     1116        endif 
     1117         
     1118///// 
     1119        target = "FB" 
     1120        L2_M = VC_calc_L2(target) 
     1121        // mask data 
     1122        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1123 
     1124// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1125// hard 
     1126        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1127// soft 
     1128        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1129 
     1130        //use the smaller shadow value 
     1131        delta = min(delta_Xh,delta_Xs) 
     1132         
     1133// how many detector tubes to mask? 
     1134        pixSizeX = VCALC_getPixSizeX(target) 
     1135        pixSizeY = VCALC_getPixSizeY(target) 
     1136 
     1137        //since "target" is FB, use x-position 
     1138        // at what "pixel" does the shadow start? 
     1139        delta_X_pix = trunc(delta/pixSizeX) 
     1140        nPix = VCALC_get_nPix_X(target) 
     1141 
     1142        if(delta_x_pix < trunc(nPix/2) )                        //still on the right side of the FB panel 
     1143                nt = trunc(nPix/2) - delta_x_pix 
     1144                mask[nPix-nt,nPix-1][] = 1 
     1145        endif 
     1146 
     1147/// 
     1148// for MR, there can also be lateral offset of the panel 
     1149        target = "MR" 
     1150 
     1151        L2_M = VC_calc_L2(target) 
     1152        // mask data 
     1153        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1154 
     1155// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1156// hard 
     1157        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1158// soft 
     1159        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1160 
     1161        //use the smaller shadow value 
     1162        delta = min(delta_Xh,delta_Xs) 
     1163         
     1164// how many detector tubes to mask? 
     1165        pixSizeX = VCALC_getPixSizeX(target) 
     1166        pixSizeY = VCALC_getPixSizeY(target) 
     1167 
     1168// offset of MR, in "pixels" 
     1169        offset_MR = VCALC_getPanelTranslation(target)/pixSizeX          //[cm] 
     1170        offset_MR = trunc(offset_MR) 
     1171        //since "target" is ML, use x-position 
     1172        // at what "pixel" does the shadow start? 
     1173        nPix = VCALC_get_nPix_X(target) 
     1174         
     1175        delta_X_pix = trunc(delta/pixSizeX) 
     1176         
     1177        //is the delta_x_pix still on the right edge of MR? 
     1178        if(delta_x_pix < 0)             //entire panel is shadowed 
     1179                nt = nPix-1 
     1180                mask[0,nt][] = 1 
     1181        else 
     1182                if(delta_X_pix < nPix + offset_MR) 
     1183                        nt = nPix + offset_MR - delta_x_pix 
     1184                        mask[nPix-nt,nPix-1][] = 1 
     1185                endif 
     1186        endif 
     1187                 
     1188        return(0) 
     1189end 
     1190 
     1191// FT shadows ML, MR, MT 
     1192Function VC_DrawVCALCMask_FT() 
     1193         
     1194        Variable pixSizeX,pixSizeY,nPix,nt 
     1195 
     1196        Variable offset,offset_MT,L2_F,L2_M,delta_L,delta_S,D2 
     1197        Variable delta_Xh,delta_Xs,delta_Y_pix,delta 
     1198        String type,target 
     1199 
     1200// FT shadows ML, MR, MT 
     1201        type = "FT" 
     1202 
     1203        //  offset of FT 
     1204        offset = VCALC_getPanelTranslation(type) 
     1205        // sample aperture diam [cm] 
     1206        D2 = VC_sampleApertureDiam() 
     1207        // sdd F         [cm] = sample aperture to detector 
     1208        L2_F = VC_calc_L2(type) 
     1209        // depth of electronics (T/B panels) 
     1210        delta_L = 61            //[cm] 
     1211        // offset of 80/20 frame 
     1212        delta_S = 2.5           //[cm] 
     1213         
     1214         
     1215        // sdd of ML, or MR, or MT 
     1216///// 
     1217        target = "ML" 
     1218        L2_M = VC_calc_L2(target) 
     1219        // mask data 
     1220        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1221 
     1222// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1223// hard 
     1224        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1225// soft 
     1226        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1227 
     1228        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1229        delta = min(delta_Xh,delta_Xs) 
     1230 
     1231// how many detector tubes to mask? 
     1232        pixSizeX = VCALC_getPixSizeX(target) 
     1233        pixSizeY = VCALC_getPixSizeY(target) 
     1234 
     1235        //since "target" is ML, use Y-position 
     1236        // at what "pixel" does the shadow start? 
     1237        delta_Y_pix = trunc(delta/pixSizeY) 
     1238        nPix = VCALC_get_nPix_Y(target) 
     1239 
     1240        if(delta_y_pix < trunc(nPix/2)) 
     1241                nt = trunc(nPix/2) - delta_y_pix 
     1242                mask[][nPix-nt,nPix-1] = 1 
     1243        endif 
     1244 
     1245///// 
     1246        target = "MR" 
     1247        L2_M = VC_calc_L2(target) 
     1248        // mask data 
     1249        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1250 
     1251// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1252// hard 
     1253        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1254// soft 
     1255        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1256 
     1257        //use the smaller shadow value 
     1258        delta = min(delta_Xh,delta_Xs) 
     1259 
     1260         
     1261// how many detector tubes to mask? 
     1262        pixSizeX = VCALC_getPixSizeX(target) 
     1263        pixSizeY = VCALC_getPixSizeY(target) 
     1264 
     1265        //since "target" is MR, use y-position 
     1266        // at what "pixel" does the shadow start? 
     1267        delta_y_pix = trunc(delta/pixSizey) 
     1268        nPix = VCALC_get_nPix_Y(target) 
     1269 
     1270        if(delta_y_pix < trunc(nPix/2)) 
     1271                nt = trunc(nPix/2) - delta_y_pix 
     1272                mask[][nPix-nt,nPix-1] = 1 
     1273        endif 
     1274         
     1275/// 
     1276// for MT, there can also be lateral offset of the MT panel 
     1277        target = "MT" 
     1278 
     1279        L2_M = VC_calc_L2(target) 
     1280        // mask data 
     1281        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1282 
     1283// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1284// hard 
     1285        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1286// soft 
     1287        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1288 
     1289        //use the smaller shadow value 
     1290        delta = min(delta_Xh,delta_Xs) 
     1291         
     1292// how many detector tubes to mask? 
     1293        pixSizeX = VCALC_getPixSizeX(target) 
     1294        pixSizeY = VCALC_getPixSizeY(target) 
     1295 
     1296// offset of MT, in "pixels" -in Y-direction 
     1297        offset_MT = VCALC_getPanelTranslation(target)/pixSizeY          //[cm] 
     1298        offset_MT = trunc(offset_MT)  
     1299        //since "target" is MT, use y-position 
     1300        // at what "pixel" does the shadow start? 
     1301        delta_Y_pix = trunc(delta/pixSizeY) 
     1302        nPix = VCALC_get_nPix_Y(target) 
     1303 
     1304        if(delta_Y_pix < nPix + offset_MT) 
     1305                nt = nPix + offset_MT - delta_y_pix 
     1306                mask[][nPix-nt,nPix-1] = 1 
     1307        endif 
     1308         
     1309         
     1310        return(0) 
     1311end 
     1312 
     1313// FB shadows ML, MR, MB 
     1314Function VC_DrawVCALCMask_FB() 
     1315         
     1316        Variable pixSizeX,pixSizeY,nPix,nt 
     1317 
     1318        Variable offset,offset_MB,L2_F,L2_M,delta_L,delta_S,D2 
     1319        Variable delta_Xh,delta_Xs,delta_Y_pix,delta 
     1320        String type,target 
     1321 
     1322// FB shadows ML, MR, MB 
     1323        type = "FB" 
     1324 
     1325        //  offset of FB 
     1326        offset = VCALC_getPanelTranslation(type) 
     1327         
     1328        // sample aperture diam [cm] 
     1329        D2 = VC_sampleApertureDiam() 
     1330        // sdd F         [cm] = sample aperture to detector 
     1331        L2_F = VC_calc_L2(type) 
     1332        // depth of electronics (T/B panels) 
     1333        delta_L = 61            //[cm] 
     1334        // offset of 80/20 frame 
     1335        delta_S = 2.5           //[cm] 
     1336         
     1337         
     1338        // sdd of ML, or MR, or MB 
     1339///// 
     1340        target = "ML" 
     1341        L2_M = VC_calc_L2(target) 
     1342        // mask data 
     1343        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1344 
     1345// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1346// hard 
     1347        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1348// soft 
     1349        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1350 
     1351        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1352        delta = min(delta_Xh,delta_Xs) 
     1353 
     1354         
     1355// how many detector tubes to mask? 
     1356        pixSizeX = VCALC_getPixSizeX(target) 
     1357        pixSizeY = VCALC_getPixSizeY(target) 
     1358 
     1359        //since "target" is ML, use Y-position 
     1360        // at what "pixel" does the shadow start? 
     1361        delta_Y_pix = trunc(delta/pixSizeY) 
     1362        nPix = VCALC_get_nPix_Y(target) 
     1363 
     1364        if(delta_y_pix < trunc(nPix/2)) 
     1365                nt = trunc(nPix/2) - delta_y_pix 
     1366                mask[][0,nt] = 1 
     1367        endif 
     1368         
     1369///// 
     1370        target = "MR" 
     1371        L2_M = VC_calc_L2(target) 
     1372        // mask data 
     1373        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1374 
     1375// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1376// hard 
     1377        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1378// soft 
     1379        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1380 
     1381        //use the smaller shadow value 
     1382        delta = min(delta_Xh,delta_Xs) 
     1383         
     1384// how many detector tubes to mask? 
     1385        pixSizeX = VCALC_getPixSizeX(target) 
     1386        pixSizeY = VCALC_getPixSizeY(target) 
     1387 
     1388        //since "target" is MR, use y-position 
     1389        // at what "pixel" does the shadow start? 
     1390        delta_y_pix = trunc(delta/pixSizeY) 
     1391        nPix = VCALC_get_nPix_Y(target) 
     1392 
     1393        if(delta_y_pix < trunc(nPix/2)) 
     1394                nt = trunc(nPix/2) - delta_y_pix 
     1395                mask[][0,nt] = 1 
     1396        endif 
     1397         
     1398/// 
     1399// for MB, there can also be lateral offset of the MT panel 
     1400        target = "MB" 
     1401 
     1402        L2_M = VC_calc_L2(target) 
     1403        // mask data 
     1404        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1405 
     1406// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1407// hard 
     1408        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1409// soft 
     1410        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1411 
     1412        //use the smaller shadow value 
     1413        delta = min(delta_Xh,delta_Xs) 
     1414         
     1415// how many detector tubes to mask? 
     1416        pixSizeX = VCALC_getPixSizeX(target) 
     1417        pixSizeY = VCALC_getPixSizeY(target) 
     1418 
     1419// offset of MT, in "pixels" -in Y-direction 
     1420        offset_MB = VCALC_getPanelTranslation(target)/pixSizeY          //[cm] 
     1421        offset_MB = -trunc(offset_MB) 
     1422        //since "target" is MT, use y-position 
     1423        // at what "pixel" does the shadow start? 
     1424        delta_Y_pix = trunc(delta/pixSizeY) 
     1425        nPix = VCALC_get_nPix_Y(target) 
     1426 
     1427        if(delta_Y_pix < nPix + offset_MB) 
     1428                nt = nPix + offset_MB - delta_y_pix 
     1429                mask[][0,nt] = 1 
     1430        endif 
     1431         
     1432 
     1433        return(0) 
     1434end 
     1435 
     1436// ML shadows MT, MB, B 
     1437Function VC_DrawVCALCMask_ML() 
     1438         
     1439        Variable pixSizeX,pixSizeY,nPix,nt 
     1440 
     1441        Variable offset,offset_B,L2_F,L2_M,delta_L,delta_S,D2 
     1442        Variable delta_Xh,delta_Xs,delta_X_pix,delta 
     1443        String type,target 
     1444 
     1445// ML shadows MT, MB, B 
     1446        type = "ML" 
     1447 
     1448        // lateral offset of ML 
     1449        offset = VCALC_getPanelTranslation(type) 
     1450        // sample aperture diam [cm] 
     1451        D2 = VC_sampleApertureDiam() 
     1452        // sdd F         [cm] = sample aperture to detector 
     1453        L2_F = VC_calc_L2(type) 
     1454        // depth of electronics (L/R panels) 
     1455        delta_L = 33            //[cm] 
     1456        // offset of 80/20 frame 
     1457        delta_S = 2.5           //[cm] 
     1458         
     1459         
     1460        // sdd of MT, or MB, or B 
     1461///// 
     1462        target = "MT" 
     1463        L2_M = VC_calc_L2(target) 
     1464        // mask data 
     1465        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1466 
     1467// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1468// hard 
     1469        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1470// soft 
     1471        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1472 
     1473        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1474        delta = min(delta_Xh,delta_Xs) 
     1475 
     1476// how many detector tubes to mask? 
     1477        pixSizeX = VCALC_getPixSizeX(target) 
     1478        pixSizeY = VCALC_getPixSizeY(target) 
     1479 
     1480        //since "target" is FT, use x-position 
     1481        // at what "pixel" does the shadow start? 
     1482        delta_X_pix = trunc(delta/pixSizeX)             //pixels from the center 
     1483        nPix = VCALC_get_nPix_X(target) 
     1484 
     1485        if(delta_x_pix < trunc(nPix/2) )                        //still on the left side of the FT panel 
     1486                nt = trunc(nPix/2) - delta_x_pix 
     1487                mask[0,nt][] = 1 
     1488        endif 
     1489         
     1490///// 
     1491        target = "MB" 
     1492        L2_M = VC_calc_L2(target) 
     1493        // mask data 
     1494        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1495 
     1496// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1497// hard 
     1498        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1499// soft 
     1500        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1501 
     1502        //use the smaller shadow value 
     1503        delta = min(delta_Xh,delta_Xs) 
     1504         
     1505// how many detector tubes to mask? 
     1506        pixSizeX = VCALC_getPixSizeX(target) 
     1507        pixSizeY = VCALC_getPixSizeY(target) 
     1508 
     1509        //since "target" is MB, use x-position 
     1510        // at what "pixel" does the shadow start? 
     1511        delta_X_pix = trunc(delta/pixSizeX) 
     1512        nPix = VCALC_get_nPix_X(target) 
     1513 
     1514        if(delta_x_pix < trunc(nPix/2) )                        //still on the left side of the MB panel 
     1515                nt = trunc(nPix/2) - delta_x_pix 
     1516                mask[0,nt][] = 1 
     1517        endif 
     1518 
     1519/// 
     1520// for B, there can also be lateral offset of the B panel 
     1521        target = "B" 
     1522 
     1523        L2_M = VC_calc_L2(target) 
     1524        // mask data 
     1525        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1526 
     1527// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1528// hard 
     1529        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1530// soft 
     1531        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1532 
     1533        //use the smaller shadow value 
     1534        delta = min(delta_Xh,delta_Xs) 
     1535//      delta = delta_Xh 
     1536         
     1537// how many detector tubes to mask? 
     1538        pixSizeX = VCALC_getPixSizeX(target) 
     1539        pixSizeY = VCALC_getPixSizeY(target) 
     1540 
     1541// offset of B, in "pixels" 
     1542        offset_B = VCALC_getPanelTranslation(target)/pixSizeX           //[cm] 
     1543        offset_B = -trunc(offset_B) 
     1544        //since "target" is B, use x-position 
     1545        // at what "pixel" does the shadow start? 
     1546        delta_X_pix = trunc(delta/pixSizeX) 
     1547        nPix = VCALC_get_nPix_X(target) 
     1548         
     1549        //is the delta_x_pix still on the left edge of B? 
     1550        if(delta_x_pix < 0)             //entire panel is shadowed 
     1551                nt = nPix-1 
     1552                mask[0,nt][] = 1 
     1553        else 
     1554                if(delta_X_pix < nPix + offset_B) 
     1555                        nt = nPix + offset_B - delta_x_pix 
     1556                        mask[0,nt][] = 1 
     1557                endif 
     1558        endif 
     1559         
     1560        return(0) 
     1561end 
     1562 
     1563// MR shadows MT, MB, B 
     1564Function VC_DrawVCALCMask_MR() 
     1565         
     1566        Variable pixSizeX,pixSizeY,nPix,nt 
     1567 
     1568        Variable offset,offset_B,L2_F,L2_M,delta_L,delta_S,D2 
     1569        Variable delta_Xh,delta_Xs,delta_X_pix,delta 
     1570        String type,target 
     1571 
     1572// MR shadows MT, MB, B 
     1573        type = "MR" 
     1574 
     1575        // lateral offset of FR 
     1576        offset = VCALC_getPanelTranslation(type) 
     1577        // sample aperture diam [cm] 
     1578        D2 = VC_sampleApertureDiam() 
     1579        // sdd F         [cm] = sample aperture to detector 
     1580        L2_F = VC_calc_L2(type) 
     1581        // depth of electronics (L/R panels) 
     1582        delta_L = 33            //[cm] 
     1583        // offset of 80/20 frame 
     1584        delta_S = 2.5           //[cm] 
     1585         
     1586         
     1587        // sdd of MT, or MB, or B 
     1588///// 
     1589        target = "MT" 
     1590        L2_M = VC_calc_L2(target) 
     1591        // mask data 
     1592        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1593 
     1594// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1595// hard 
     1596        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1597// soft 
     1598        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1599 
     1600        //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1601        delta = min(delta_Xh,delta_Xs) 
     1602 
     1603// how many detector tubes to mask? 
     1604        pixSizeX = VCALC_getPixSizeX(target) 
     1605        pixSizeY = VCALC_getPixSizeY(target) 
     1606 
     1607        //since "target" is MT, use x-position 
     1608        // at what "pixel" does the shadow start? 
     1609        delta_X_pix = trunc(delta/pixSizeX) 
     1610        nPix = VCALC_get_nPix_X(target) 
     1611 
     1612        if(delta_x_pix < trunc(nPix/2) )                        //still on the right side of the MT panel 
     1613                nt = trunc(nPix/2) - delta_x_pix 
     1614                mask[nPix-nt,nPix-1][] = 1 
     1615        endif 
     1616         
     1617///// 
     1618        target = "MB" 
     1619        L2_M = VC_calc_L2(target) 
     1620        // mask data 
     1621        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1622 
     1623// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1624// hard 
     1625        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1626// soft 
     1627        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1628 
     1629        //use the smaller shadow value 
     1630        delta = min(delta_Xh,delta_Xs) 
     1631         
     1632// how many detector tubes to mask? 
     1633        pixSizeX = VCALC_getPixSizeX(target) 
     1634        pixSizeY = VCALC_getPixSizeY(target) 
     1635 
     1636        //since "target" is FB, use x-position 
     1637        // at what "pixel" does the shadow start? 
     1638        delta_X_pix = trunc(delta/pixSizeX) 
     1639        nPix = VCALC_get_nPix_X(target) 
     1640 
     1641        if(delta_x_pix < trunc(nPix/2) )                        //still on the right side of the MB panel 
     1642                nt = trunc(nPix/2) - delta_x_pix 
     1643                mask[nPix-nt,nPix-1][] = 1 
     1644        endif 
     1645 
     1646/// 
     1647// for B, there can also be lateral offset of the panel 
     1648        target = "B" 
     1649 
     1650        L2_M = VC_calc_L2(target) 
     1651        // mask data 
     1652        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1653 
     1654// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1655// hard 
     1656        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1657// soft 
     1658        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1659 
     1660        //use the smaller shadow value 
     1661        delta = min(delta_Xh,delta_Xs) 
     1662         
     1663// how many detector tubes to mask? 
     1664        pixSizeX = VCALC_getPixSizeX(target) 
     1665        pixSizeY = VCALC_getPixSizeY(target) 
     1666 
     1667// offset of B, in "pixels" 
     1668        offset_B = VCALC_getPanelTranslation(target)/pixSizeX           //[cm] 
     1669        offset_B = trunc(offset_B) 
     1670        //since "target" is B, use x-position 
     1671        // at what "pixel" does the shadow start? 
     1672        nPix = VCALC_get_nPix_X(target) 
     1673         
     1674        delta_X_pix = trunc(delta/pixSizeX) 
     1675         
     1676        //is the delta_x_pix still on the right edge of B? 
     1677        if(delta_x_pix < 0)             //entire panel is shadowed 
     1678                nt = nPix-1 
     1679                mask[0,nt][] = 1 
     1680        else 
     1681                if(delta_X_pix < nPix + offset_B) 
     1682                        nt = nPix + offset_B - delta_x_pix 
     1683                        mask[nPix-nt,nPix-1][] = 1 
     1684                endif 
     1685        endif 
     1686         
     1687        return(0) 
     1688end 
     1689 
     1690 
     1691// MT shadows B 
     1692Function VC_DrawVCALCMask_MT() 
     1693         
     1694        Variable pixSizeX,pixSizeY,nPix,nt 
     1695 
     1696        Variable offset,offset_B,L2_F,L2_M,delta_L,delta_S,D2 
     1697        Variable delta_Xh,delta_Xs,delta_Y_pix,delta 
     1698        String type,target 
     1699 
     1700// MT shadows B 
     1701        type = "MT" 
     1702 
     1703        //  offset of MT 
     1704        offset = VCALC_getPanelTranslation(type) 
     1705        // sample aperture diam [cm] 
     1706        D2 = VC_sampleApertureDiam() 
     1707        // sdd F         [cm] = sample aperture to detector 
     1708        L2_F = VC_calc_L2(type) 
     1709        // depth of electronics (T/B panels) 
     1710        delta_L = 61            //[cm] 
     1711        // offset of 80/20 frame 
     1712        delta_S = 2.5           //[cm] 
     1713         
     1714         
     1715        // sdd of ML, or MR, or MT 
     1716/////// 
     1717//      target = "ML" 
     1718//      L2_M = VC_calc_L2(target) 
     1719//      // mask data 
     1720//      Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1721// 
     1722//// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1723//// hard 
     1724//      delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1725//// soft 
     1726//      delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1727// 
     1728//      //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1729//      delta = min(delta_Xh,delta_Xs) 
     1730// 
     1731//// how many detector tubes to mask? 
     1732//      pixSizeX = VCALC_getPixSizeX(target) 
     1733//      pixSizeY = VCALC_getPixSizeY(target) 
     1734// 
     1735//      //since "target" is ML, use Y-position 
     1736//      // at what "pixel" does the shadow start? 
     1737//      delta_Y_pix = trunc(delta/pixSizeY) 
     1738//      nPix = VCALC_get_nPix_Y(target) 
     1739// 
     1740//      if(delta_y_pix < trunc(nPix/2)) 
     1741//              nt = trunc(nPix/2) - delta_y_pix 
     1742//              mask[][nPix-nt,nPix-1] = 1 
     1743//      endif 
     1744 
     1745///// 
     1746//      target = "MR" 
     1747//      L2_M = VC_calc_L2(target) 
     1748//      // mask data 
     1749//      Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1750// 
     1751//// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1752//// hard 
     1753//      delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1754//// soft 
     1755//      delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1756// 
     1757//      //use the smaller shadow value 
     1758//      delta = min(delta_Xh,delta_Xs) 
     1759// 
     1760//       
     1761//// how many detector tubes to mask? 
     1762//      pixSizeX = VCALC_getPixSizeX(target) 
     1763//      pixSizeY = VCALC_getPixSizeY(target) 
     1764// 
     1765//      //since "target" is MR, use y-position 
     1766//      // at what "pixel" does the shadow start? 
     1767//      delta_y_pix = trunc(delta/pixSizey) 
     1768//      nPix = VCALC_get_nPix_Y(target) 
     1769// 
     1770//      if(delta_y_pix < trunc(nPix/2)) 
     1771//              nt = trunc(nPix/2) - delta_y_pix 
     1772//              mask[][nPix-nt,nPix-1] = 1 
     1773//      endif 
     1774         
     1775/// 
     1776// for B, there can also be lateral offset of the B panel 
     1777        target = "B" 
     1778 
     1779        L2_M = VC_calc_L2(target) 
     1780        // mask data 
     1781        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1782 
     1783// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1784// hard 
     1785        delta_Xh = D2/2 + (offset - D2/2)*(L2_M/L2_F) 
     1786// soft 
     1787        delta_Xs = D2/2 + (offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1788 
     1789        //use the smaller shadow value 
     1790        delta = min(delta_Xh,delta_Xs) 
     1791         
     1792// how many detector tubes to mask? 
     1793        pixSizeX = VCALC_getPixSizeX(target) 
     1794        pixSizeY = VCALC_getPixSizeY(target) 
     1795 
     1796// offset of B, in "pixels" -in Y-direction 
     1797        offset_B = VCALC_getPanelTranslation(target)/pixSizeY           //[cm] 
     1798        offset_B = trunc(offset_B)  
     1799        //since "target" is B, use y-position 
     1800        // at what "pixel" does the shadow start? 
     1801        delta_Y_pix = trunc(delta/pixSizeY) 
     1802        nPix = VCALC_get_nPix_Y(target) 
     1803 
     1804        if(delta_y_pix < trunc(nPix/2)) 
     1805                nt = trunc(nPix/2) - delta_y_pix 
     1806                mask[][nPix-nt,nPix-1] = 1 
     1807        endif 
     1808         
     1809        return(0) 
     1810end 
     1811 
     1812// MB shadows B 
     1813Function VC_DrawVCALCMask_MB() 
     1814         
     1815        Variable pixSizeX,pixSizeY,nPix,nt 
     1816 
     1817        Variable offset,offset_B,L2_F,L2_M,delta_L,delta_S,D2 
     1818        Variable delta_Xh,delta_Xs,delta_Y_pix,delta 
     1819        String type,target 
     1820 
     1821// MB shadows B 
     1822        type = "MB" 
     1823 
     1824        //  offset of MB 
     1825        offset = VCALC_getPanelTranslation(type) 
     1826         
     1827        // sample aperture diam [cm] 
     1828        D2 = VC_sampleApertureDiam() 
     1829        // sdd F         [cm] = sample aperture to detector 
     1830        L2_F = VC_calc_L2(type) 
     1831        // depth of electronics (T/B panels) 
     1832        delta_L = 61            //[cm] 
     1833        // offset of 80/20 frame 
     1834        delta_S = 2.5           //[cm] 
     1835         
     1836         
     1837        // sdd of ML, or MR, or MB 
     1838///// 
     1839//      target = "ML" 
     1840//      L2_M = VC_calc_L2(target) 
     1841//      // mask data 
     1842//      Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1843// 
     1844//// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1845//// hard 
     1846//      delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1847//// soft 
     1848//      delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1849// 
     1850//      //use the smaller shadow value (this means closer to the center, a larger shadow) 
     1851//      delta = min(delta_Xh,delta_Xs) 
     1852// 
     1853//       
     1854//// how many detector tubes to mask? 
     1855//      pixSizeX = VCALC_getPixSizeX(target) 
     1856//      pixSizeY = VCALC_getPixSizeY(target) 
     1857// 
     1858//      //since "target" is ML, use Y-position 
     1859//      // at what "pixel" does the shadow start? 
     1860//      delta_Y_pix = trunc(delta/pixSizeY) 
     1861//      nPix = VCALC_get_nPix_Y(target) 
     1862// 
     1863//      if(delta_y_pix < trunc(nPix/2)) 
     1864//              nt = trunc(nPix/2) - delta_y_pix 
     1865//              mask[][0,nt] = 1 
     1866//      endif 
     1867         
     1868///// 
     1869//      target = "MR" 
     1870//      L2_M = VC_calc_L2(target) 
     1871//      // mask data 
     1872//      Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1873// 
     1874//// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1875//// hard 
     1876//      delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1877//// soft 
     1878//      delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1879// 
     1880//      //use the smaller shadow value 
     1881//      delta = min(delta_Xh,delta_Xs) 
     1882//       
     1883//// how many detector tubes to mask? 
     1884//      pixSizeX = VCALC_getPixSizeX(target) 
     1885//      pixSizeY = VCALC_getPixSizeY(target) 
     1886// 
     1887//      //since "target" is MR, use y-position 
     1888//      // at what "pixel" does the shadow start? 
     1889//      delta_y_pix = trunc(delta/pixSizeY) 
     1890//      nPix = VCALC_get_nPix_Y(target) 
     1891// 
     1892//      if(delta_y_pix < trunc(nPix/2)) 
     1893//              nt = trunc(nPix/2) - delta_y_pix 
     1894//              mask[][0,nt] = 1 
     1895//      endif 
     1896         
     1897/// 
     1898// for B, there can also be lateral offset of the B panel 
     1899        target = "B" 
     1900 
     1901        L2_M = VC_calc_L2(target) 
     1902        // mask data 
     1903        Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+target+":data") 
     1904 
     1905// extent of shadow in [cm] (starting point of shadow from center of beam) 
     1906// hard 
     1907        delta_Xh = D2/2 + (-offset - D2/2)*(L2_M/L2_F) 
     1908// soft 
     1909        delta_Xs = D2/2 + (-offset + delta_S - D2/2)*(L2_M/(L2_F+delta_L)) 
     1910 
     1911        //use the smaller shadow value 
     1912        delta = min(delta_Xh,delta_Xs) 
     1913         
     1914// how many detector tubes to mask? 
     1915        pixSizeX = VCALC_getPixSizeX(target) 
     1916        pixSizeY = VCALC_getPixSizeY(target) 
     1917 
     1918// offset of B, in "pixels" -in Y-direction 
     1919        offset_B = VCALC_getPanelTranslation(target)/pixSizeY           //[cm] 
     1920        offset_B = -trunc(offset_B) 
     1921        //since "target" is MT, use y-position 
     1922        // at what "pixel" does the shadow start? 
     1923        delta_Y_pix = trunc(delta/pixSizeY) 
     1924        nPix = VCALC_get_nPix_Y(target) 
     1925 
     1926        if(delta_y_pix < trunc(nPix/2)) 
     1927                nt = trunc(nPix/2) - delta_y_pix 
     1928                mask[][0,nt] = 1 
     1929        endif 
     1930 
     1931        return(0) 
     1932end 
     1933 
     1934 
     1935 
     1936 
     1937// 
     1938// resets the mask to 0 = (use all) 
     1939// 
     1940Function VC_ResetVCALCMask() 
     1941 
     1942        Variable ii 
     1943        String detStr 
     1944         
     1945        for(ii=0;ii<ItemsInList(ksDetectorListAll);ii+=1) 
     1946                detStr = StringFromList(ii, ksDetectorListAll, ";") 
     1947                Wave mask = $("root:Packages:NIST:VSANS:MSK:entry:instrument:detector_"+detStr+":data") 
     1948                mask = 0         
     1949        endfor 
     1950         
     1951        return(0) 
     1952end 
     1953 
     1954 
Note: See TracChangeset for help on using the changeset viewer.