2055 lines
62 KiB
Plaintext
2055 lines
62 KiB
Plaintext
COMPILE FUNCTION obj_RDS_Test(Method,Parms,Override)
|
|
/*
|
|
Methods for RDS Metrology (RDS_TEST) table
|
|
|
|
02/14/2006 JCH - Initial Coding
|
|
|
|
Properties:
|
|
|
|
Methods:
|
|
|
|
New() ;* Creates New Records
|
|
|
|
*/
|
|
#pragma precomp SRP_PreCompiler
|
|
|
|
DECLARE SUBROUTINE Set_Status, Msg, obj_Tables, ErrMsg, Btree.Extract, Post_Metrology_Manual_Data_Entry_Log, SRP_Stopwatch
|
|
Declare subroutine Memory_Services, Environment_Services, Logging_Services, Database_Services
|
|
|
|
DECLARE FUNCTION Get_Status, Msg, Utility, obj_Tables, Dialog_Box, obj_WO_Log, NextKey, SRP_Encode
|
|
DECLARE FUNCTION obj_Prod_Spec, obj_RDS_Test, obj_Popup, Database_Services, SRP_Array, Memory_Services
|
|
Declare function Environment_Services, Logging_Services, Error_Services
|
|
|
|
|
|
$insert LOGICAL
|
|
$INSERT MSG_EQUATES
|
|
$INSERT RDS_EQU
|
|
$INSERT RDS_LAYER_EQUATES
|
|
$INSERT RDS_TEST_EQUATES
|
|
$INSERT RDS_TEST_PROP_EQUATES
|
|
$INSERT PRS_LAYER_EQU
|
|
$INSERT PROD_SPEC_EQU
|
|
$INSERT TW_USE_EQUATES
|
|
$INSERT CUST_EPI_PART_EQUATES
|
|
$INSERT REACT_RUN_EQUATES
|
|
|
|
EQU STAT_AVG$ TO 1
|
|
EQU STAT_STDV$ TO 2
|
|
EQU STAT_UNIF$ TO 3
|
|
EQU STAT_MIN$ TO 4
|
|
|
|
|
|
* This section used in PushProps method
|
|
|
|
EQU UNIT$THICK TO CHAR(230):'m' ;* Microns
|
|
EQU UNIT$THICKA TO CHAR(143) ;* Angstroms
|
|
EQU UNIT$RES TO CHAR(234):'-cm' ;* Ohms.Cm
|
|
EQU UNIT$SRES TO CHAR(234):'/':CHAR(220) ;* Ohms/Square
|
|
EQU UNIT$CRES TO CHAR(234):'-cm' ;* Ohms.Cm
|
|
EQU UNIT$CONC TO 'CM-3' ;* Carriers.Cubic Centimeter
|
|
EQU UNIT$STRESS TO 'dyne/cm-2' ;* Dyne/Square Centimeter
|
|
EQU UNIT$BOW TO CHAR(230):'m' ;* Microns
|
|
EQU UNIT$TRANS TO CHAR(230):'m' ;* Microns
|
|
|
|
EQU SHEETRHO_SPEC_UNITS$ TO 'ê/Ü'
|
|
EQU RES_SPEC_UNITS$ TO \EA2D636D\
|
|
|
|
EQU STAT_MAX$ TO 5
|
|
|
|
EQU CRLF$ TO \0D0A\
|
|
|
|
ErrTitle = 'Error in Stored Procedure "obj_RDS_Test"'
|
|
ErrorMsg = ''
|
|
|
|
IF NOT(ASSIGNED(Method)) THEN ErrorMsg = 'Unassigned parameter "Method" passed to subroutine'
|
|
IF NOT(ASSIGNED(Parms)) THEN Parms = ''
|
|
IF NOT(ASSIGNED(Override)) then Override = False$
|
|
|
|
IF ErrorMsg NE '' THEN
|
|
Set_Status(-1,ErrTitle:@SVM:ErrorMsg)
|
|
RETURN ''
|
|
END
|
|
|
|
Result = ''
|
|
|
|
BEGIN CASE
|
|
CASE Method = 'Create' ; GOSUB Create
|
|
CASE Method = 'CalcStats' ; GOSUB CalcStats
|
|
CASE Method = 'Resistivity' ; GOSUB Resistivity
|
|
CASE Method = 'CopyStats' ; GOSUB CopyStats
|
|
CASE Method = 'Delete' ; GOSUB Delete
|
|
CASE Method = 'CalcMissing' ; GOSUB CalcMissing ;* Used for the conversion process
|
|
CASE Method = 'OutOfSpec' ; GOSUB OutOfSpec
|
|
CASE Method = 'TestWfrCount' ; GOSUB TestWfrCount
|
|
CASE Method = 'PrimeWfrCount' ; GOSUB PrimeWfrCount
|
|
CASE Method = 'ProdTestCount' ; GOSUB ProdTestCount
|
|
CASE Method = 'CustTWCount' ; GOSUB CustTWCount
|
|
CASE Method = 'ReclaimCount' ; GOSUB ReclaimCount
|
|
CASE Method = 'SetReadSet' ; GOSUB SetReadSet
|
|
CASE Method = 'GetReadSet' ; GOSUB GetReadSet
|
|
CASE Method = 'SetZone' ; GOSUB SetZone
|
|
CASE Method = 'TWSignedOff' ; GOSUB TWSignedOff
|
|
CASE Method = 'ExpReadings' ; GOSUB ExpReadings
|
|
CASE Method = 'ExpTower' ; GOSUB ExpTower
|
|
CASE Method = 'ExpIR' ; GOSUB ExpIR
|
|
CASE Method = 'RefreshSpecs' ; GOSUB RefreshSpecs
|
|
CASE Method = 'TestComplete' ; GOSUB TestComplete
|
|
CASE Method = 'TestPropKeys' ; GOSUB TestPropKeys
|
|
CASE Method = 'PushProps' ; GOSUB PushProps
|
|
CASE Method = 'ExpCOA' ; GOSUB ExpCOA
|
|
|
|
CASE 1
|
|
ErrorMsg = 'Unknown Method ':QUOTE(Method):' passed to routine.'
|
|
|
|
END CASE
|
|
|
|
IF ErrorMsg NE '' THEN
|
|
Set_Status(-1,ErrTitle:@SVM:ErrorMsg)
|
|
RETURN ''
|
|
END
|
|
|
|
RETURN Result
|
|
|
|
|
|
* * * * * * *
|
|
Create:
|
|
* * * * * * *
|
|
|
|
RDSNo = Parms[1,@RM]
|
|
LayerSet = Parms[COL2()+1,@RM]
|
|
PSNId = Parms[COL2()+1,@RM]
|
|
Zone = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSNo = '' THEN ErrorMsg = 'Null parameter "RDSNo" passed to routine (':Method:').' ; RETURN
|
|
IF LayerSet = '' THEN ErrorMsg = 'Null parameter "LayerSet" passed to routine (':Method:').' ; RETURN
|
|
|
|
IF PSNId = '' THEN
|
|
PSNId = XLATE('RDS',RDSNo, RDS_PROD_SPEC_ID$ ,'X')
|
|
IF PSNId = '' THEN
|
|
ErrorMsg = 'Null parameter "PSNId" passed to routine (':Method:').' ; RETURN
|
|
END
|
|
END
|
|
|
|
LayerSpecs = obj_Prod_Spec('GetLayerProp',PSNId:@RM:LayerSet:@RM:1) ;* Last parameter specifies no output conversion on return data
|
|
|
|
LayerSpecs = FIELD(LayerSpecs,@FM,2,99) ;* Returns with the layer set ID in the first field of each line
|
|
|
|
IF Get_Status(errCode) THEN RETURN
|
|
|
|
WaferSize = XLATE( 'PROD_SPEC', PSNId, 'SUB_WAFER_SIZE', 'X' )
|
|
SubOrientation = XLATE('PROD_SPEC',PSNId,'SUB_ORIENTATION','X')
|
|
ResUnits = LayerSpecs<PRS_LAYER_RES_UNITS$>
|
|
|
|
ReactorType = XLATE('PROD_SPEC',PSNId,PROD_SPEC_REACTOR_TYPE$,'X')
|
|
ThickFilmMet = XLATE('PROD_SPEC',PSNId,PROD_SPEC_THICKFILM_MET$,'X') ;* Added 1/16/2009 JCH
|
|
|
|
RDSTestRec = ''
|
|
RDSTestRec<RDS_TEST_RDS_NO$> = RDSNo
|
|
RDSTestRec<RDS_TEST_LS_ID$> = LayerSet
|
|
RDSTestRec<RDS_TEST_ZONE$> = Zone
|
|
RDSTestRec<RDS_TEST_WAFER_SIZE$> = WaferSize
|
|
RDSTestRec<RDS_TEST_SUB_ORIENTATION$> = SubOrientation
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_DOPANT$> = LayerSpecs<PRS_LAYER_DOPANT$>
|
|
RDSTestRec<RDS_TEST_SPEC_RECIPE$> = LayerSpecs<PRS_LAYER_RECIPE$>
|
|
RDSTestRec<RDS_TEST_SPEC_RECIPE_NAME$> = LayerSpecs<PRS_LAYER_RECIPE_NAME$>
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_MIN$> = LayerSpecs<PRS_LAYER_THICK_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_TARGET$> = LayerSpecs<PRS_LAYER_THICK_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_MAX$> = LayerSpecs<PRS_LAYER_THICK_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_UNITS$> = LayerSpecs<PRS_LAYER_THICK_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_MIN$> = LayerSpecs<PRS_LAYER_RES_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_TARGET$> = LayerSpecs<PRS_LAYER_RES_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_MAX$> = LayerSpecs<PRS_LAYER_RES_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_UNITS$> = LayerSpecs<PRS_LAYER_RES_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_MIN$> = LayerSpecs<PRS_LAYER_CONC_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_TARGET$> = LayerSpecs<PRS_LAYER_CONC_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_MAX$> = LayerSpecs<PRS_LAYER_CONC_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_UNITS$> = LayerSpecs<PRS_LAYER_CONC_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_STRESS_MIN$> = LayerSpecs<PRS_LAYER_STRESS_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_STRESS_MAX$> = LayerSpecs<PRS_LAYER_STRESS_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_TRANS$> = LayerSpecs<PRS_LAYER_TRANS_SPEC$>
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_MIN$> = LayerSpecs<PRS_LAYER_CRES_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_TARGET$> = LayerSpecs<PRS_LAYER_CRES_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_MAX$> = LayerSpecs<PRS_LAYER_CRES_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_UNITS$> = LayerSpecs<PRS_LAYER_CRES_UNITS$>
|
|
|
|
|
|
FOR A = 11 TO 19
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_THICK_MEASUREMENT$,A-10>
|
|
NEXT A
|
|
|
|
FOR A = 24 TO 32
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_RES_MEASUREMENT$,A-23>
|
|
NEXT A
|
|
|
|
FOR A = 37 TO 45
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_CONC_MEASUREMENT$,A-36>
|
|
NEXT A
|
|
|
|
FOR A = 50 to 58
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_STRESS_MEASUREMENT$,A-49>
|
|
NEXT A
|
|
|
|
FOR A = 121 TO 129
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_CRES_MEASUREMENT$,A-120>
|
|
NEXT A
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_MPATTERN$> = LayerSpecs<PRS_LAYER_THICK_MEASUREMENT$,PRS_MPATTERN$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_MPATTERN$> = LayerSpecs<PRS_LAYER_RES_MEASUREMENT$,PRS_MPATTERN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_MPATTERN$> = LayerSpecs<PRS_LAYER_CONC_MEASUREMENT$,PRS_MPATTERN$>
|
|
RDSTestRec<RDS_TEST_SPEC_STRESS_MPATTERN$> = LayerSpecs<PRS_LAYER_STRESS_MEASUREMENT$,PRS_MPATTERN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_MPATTERN$> = LayerSpecs<PRS_LAYER_CRES_MEASUREMENT$,PRS_MPATTERN$>
|
|
|
|
|
|
RDSTestRec<RDS_TEST_REACTOR_TYPE$> = ReactorType
|
|
|
|
IF ReactorType = 'P' OR ReactorType = 'EPP' OR ThickFilmMet = 1 THEN
|
|
|
|
SpecMap = XLATE('PROD_SPEC',PSNId,PROD_SPEC_TEST_POINT_MAP$,'X') ;* Added 4/8/2009 JCH new field in PROD_SPEC
|
|
|
|
IF SpecMap NE '' THEN
|
|
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = SpecMap
|
|
|
|
END ELSE
|
|
|
|
;* Added ThickFilmMet check - 1/16/2009 JCH
|
|
|
|
AllTargetThicks = XLATE('PROD_SPEC',PSNId,'THICK_TARGET_ALL','X')
|
|
TargetCnt = COUNT(AllTargetThicks,@VM) + (AllTargetThicks NE '')
|
|
|
|
BEGIN CASE
|
|
CASE TargetCnt = 2
|
|
CombinedThick = SUM(AllTargetThicks)
|
|
|
|
CASE TargetCnt = 1 OR TargetCnt = 3
|
|
CombinedThick = AllTargetThicks[-1,'B':@VM]
|
|
|
|
END CASE
|
|
|
|
IF OCONV(CombinedThick,'MD2') > '65.0' THEN
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'FTIR_T'
|
|
END ELSE
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'FTIR'
|
|
END
|
|
END
|
|
|
|
END ELSE
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'ASM17' ;* 17 Point linear test pattern until PROD_SPEC is updated support other types
|
|
END
|
|
|
|
RDSTestKey = NextKey('RDS_TEST')
|
|
|
|
obj_Tables('WriteRec','RDS_TEST':@RM:RDSTestKey:@RM:@RM:RDSTestRec)
|
|
|
|
Result = RDSTestKey
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
CalcStats:
|
|
* * * * * * *
|
|
|
|
IF NOT(ASSIGNED(Readings)) THEN
|
|
Readings = Parms[1,@RM]
|
|
Conversion = Parms[COL2()+1,@RM]
|
|
END
|
|
|
|
IF Conversion = '' THEN ErrorMsg = 'Null parameter "Conversion" passed to routine (':Method:').'
|
|
|
|
IF ErrorMsg THEN RETURN
|
|
|
|
thisReadings = Readings
|
|
|
|
StatAvg = ''
|
|
StatStdv = ''
|
|
StatUnif = ''
|
|
StatMin = ''
|
|
StatMax = ''
|
|
StatRange = ''
|
|
StatRangePcnt = ''
|
|
|
|
AvgCount = 0
|
|
AvgTotal = 0
|
|
|
|
ReadCount = COUNT(thisReadings,@VM) + (thisReadings NE '')
|
|
|
|
FOR I = 1 TO ReadCount
|
|
thisReading = ThisReadings<1,I>
|
|
IF thisReading NE '' AND thisReading NE 0.00 THEN
|
|
AvgCount += 1
|
|
AvgTotal += thisReading
|
|
|
|
IF thisReading _LEX StatMin OR StatMin = '' THEN StatMin = thisReading
|
|
IF thisReading _GEX StatMax OR StatMax = '' THEN StatMax = thisReading
|
|
END
|
|
NEXT I
|
|
|
|
IF AvgCount > 0 THEN
|
|
|
|
StatAvg = AvgTotal/AvgCount
|
|
Mean = AvgTotal/AvgCount
|
|
|
|
StatRange = StatMax - StatMin
|
|
StatRangePcnt = (StatRange/Mean)*100
|
|
|
|
SumDiffSq = 0
|
|
|
|
FOR I = 1 TO ReadCount
|
|
|
|
thisReading = thisReadings<1,I>
|
|
|
|
IF thisReading NE '' THEN
|
|
*SumDiffSq += ( thisReading - Mean )**2
|
|
SumDiffSq += ( thisReading - Mean ) * ( thisReading - Mean )
|
|
|
|
END
|
|
NEXT I
|
|
|
|
IF SumDiffSq _GEX 0.00 AND AvgCount > 1 THEN
|
|
StatStdv = Sqrt( SumDiffSq / (AvgCount - 1) )
|
|
END
|
|
IF SumDiffSq _EQX 0 AND AvgCount > 1 THEN StatStdv = 0
|
|
END
|
|
|
|
IF StatMin NE '' AND StatMax NE '' AND StatMin _GEX 0 AND StatMin _GEX 0 THEN
|
|
|
|
StatUnif = OCONV(((StatMax - StatMin)/(StatMax + StatMin))*10000, 'MD2' )
|
|
END
|
|
|
|
StatAvg = ICONV(StatAvg,Conversion)
|
|
StatStdv = ICONV(StatStdv,'MD4')
|
|
StatMin = ICONV(StatMin,Conversion)
|
|
StatMax = ICONV(StatMax,Conversion)
|
|
StatRange = ICONV(StatRange,Conversion)
|
|
StatRangePcnt = ICONV(StatRangePcnt,'MD4')
|
|
|
|
Result = OCONV(StatAvg,Conversion):@RM
|
|
Result := OCONV(StatStdv,'MD4'):@RM
|
|
Result := StatUnif:@RM
|
|
Result := OCONV(StatMin,Conversion):@RM
|
|
Result := OCONV(StatMax,Conversion):@RM
|
|
Result := OCONV(StatRange,Conversion):@RM
|
|
Result := OCONV(StatRangePcnt,'MD4S%')
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
Resistivity:
|
|
* * * * * * *
|
|
|
|
IF NOT(ASSIGNED(RDSTestKey)) THEN
|
|
* Get parameters if not called from another method in this program
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
NoConversion = Parms[COL2()+1,@RM]
|
|
END
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
ReactorType = RDSTestRec<RDS_TEST_REACTOR_TYPE$>
|
|
RDSNo = RDSTestRec<RDS_TEST_RDS_NO$>
|
|
|
|
SheetRhoReads = OCONV(RDSTestRec<RDS_TEST_READ_SHEET_RHO$>,'MD3')
|
|
ThickReads = OCONV(RDSTestRec<RDS_TEST_READ_THICK$>,'MD2')
|
|
ThickOvergrowAvg = OCONV(RDSTestRec<RDS_TEST_THICK_OVERGROW_AVG$>,'MD2')
|
|
|
|
ReadCnt = COUNT(SheetRhoReads,@VM) + (SheetRhoReads NE '')
|
|
IF ReadCnt = '' THEN
|
|
ReadCnt = COUNT(ThickReads,@VM) + (ThickReads NE '')
|
|
END
|
|
|
|
FOR I = 1 TO ReadCnt
|
|
SheetRhoRead = SheetRhoReads<1,I>
|
|
CalcValue = ThickReads<1,I>
|
|
|
|
ThickRead = OCONV(ICONV((CalcValue),'MD2'),'MD2')
|
|
|
|
IF ThickOvergrowAvg NE '' THEN ThickRead = ThickOverGrowAvg
|
|
|
|
IF SheetRhoRead = '' AND ThickRead = '' THEN
|
|
Result<1,I> = ''
|
|
END ELSE
|
|
IF SheetRhoRead NE 0 AND ThickRead NE 0 THEN
|
|
IF NoConversion THEN
|
|
IF ReactorType = 'P' OR ReactorType = 'EPP' THEN
|
|
Result<1,I> = ICONV((SheetRhoRead * ThickRead)/10000,'MD3')*10
|
|
END ELSE
|
|
Result<1,I> = ICONV((SheetRhoRead * ThickRead)/10000,'MD4')
|
|
END
|
|
END ELSE
|
|
IF ReactorType = 'P' OR ReactorType = 'EPP' THEN
|
|
Result<1,I> = OCONV(ICONV((SheetRhoRead * ThickRead/10000)*10,'MD3'),'MD4')
|
|
END ELSE
|
|
Result<1,I> = OCONV(ICONV((SheetRhoRead * ThickRead/10000),'MD4'),'MD4')
|
|
END
|
|
END
|
|
END ELSE
|
|
Result<1,I> = ''
|
|
END
|
|
END
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
CopyStats:
|
|
* * * * * * *
|
|
SourceRDSTestKeys = Parms[1,@RM]
|
|
DestRDSTestKeys = Parms[COL2()+1,@RM]
|
|
|
|
IF SourceRDSTestKeys = '' THEN ErrorMsg = 'Null parameter "SourceRDSTestKeys" passed to routine. (':Method:')'
|
|
IF DestRDSTestKeys = '' THEN ErrorMsg = 'Null parameter "DestRDSTestKeys" passed to routine. (':Method:')'
|
|
|
|
RTParms = 'RDS_TEST'
|
|
LockedRDSTestKeys = ''
|
|
|
|
FOR I = 1 TO COUNT(DestRDSTestKeys,@VM) + (DestRDSTestKeys NE '')
|
|
DestRDSTestKey = DestRDSTestKeys<1,I>
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, DestRDSTestKey)
|
|
|
|
// No longer lock records when copying metrology. This avoids unnecessary overhad and contention for a simple
|
|
// operation. - 08/04/2017
|
|
* obj_Tables('LockRec',RTParms)
|
|
* IF Get_Status(errCode) THEN
|
|
* FOR N = 1 TO COUNT(LockedRDSTestKeys,@VM) + (LockedRDSTestKeys NE '')
|
|
* RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSTestKeys<1,N>)
|
|
* obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
* NEXT N
|
|
* ErrorMsg = 'Unable to lock RDS_TEST ':QUOTE(DestRDSTestKey):' for Update.'
|
|
*
|
|
* RETURN
|
|
* END ELSE
|
|
LockedRDSTestKeys<1,I> = DestRDSTestKey
|
|
* END
|
|
NEXT I
|
|
|
|
* RDSTestTableVar = FIELD(RTParms,@RM,3)
|
|
RDSTestTableVar = Database_Services('GetTableHandle', 'RDS_TEST')
|
|
|
|
RDSTestKeyCount = DCount(LockedRDSTestKeys, @VM)
|
|
FOR I = 1 TO RDSTestKeyCount
|
|
LockedRDSTestKey = LockedRDSTestKeys<1,I>
|
|
READ DestRDSTestRec FROM RDSTestTableVar,LockedRDSTestKey THEN
|
|
SourceRDSTestKey = SourceRDSTestKeys<1,I>
|
|
SourceRDSTestRec = XLATE('RDS_TEST',SourceRDSTestKey,'','X')
|
|
|
|
DestRDSTestRec<RDS_TEST_READ_THICK$> = SourceRDSTestRec<RDS_TEST_READ_THICK$>
|
|
DestRDSTestRec<RDS_TEST_READ_SHEET_RHO$> = SourceRDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
DestRDSTestRec<RDS_TEST_READ_RES$> = SourceRDSTestRec<RDS_TEST_READ_RES$>
|
|
DestRDSTestRec<RDS_TEST_READ_HGCV1_RES$> = SourceRDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
DestRDSTestRec<RDS_TEST_THICK_OVERGROW_AVG$> = SourceRDSTestRec<RDS_TEST_THICK_OVERGROW_AVG$>
|
|
DestRDSTestRec<RDS_TEST_HGCV_MEAN$> = SourceRDSTestRec<RDS_TEST_HGCV_MEAN$>
|
|
DestRDSTestRec<RDS_TEST_HGCV_STDV$> = SourceRDSTestRec<RDS_TEST_HGCV_STDV$>
|
|
DestRDSTestRec<RDS_TEST_THICK_AVG$> = SourceRDSTestRec<RDS_TEST_THICK_AVG$>
|
|
DestRDSTestRec<RDS_TEST_THICK_STDV$> = SourceRDSTestRec<RDS_TEST_THICK_STDV$>
|
|
DestRDSTestRec<RDS_TEST_THICK_UNIF$> = SourceRDSTestRec<RDS_TEST_THICK_UNIF$>
|
|
DestRDSTestRec<RDS_TEST_THICK_MIN$> = SourceRDSTestRec<RDS_TEST_THICK_MIN$>
|
|
DestRDSTestRec<RDS_TEST_THICK_MAX$> = SourceRDSTestRec<RDS_TEST_THICK_MAX$>
|
|
DestRDSTestRec<RDS_TEST_THICK_RANGE$> = SourceRDSTestRec<RDS_TEST_THICK_RANGE$>
|
|
DestRDSTestRec<RDS_TEST_THICK_RANGE_PCNT$> = SourceRDSTestRec<RDS_TEST_THICK_RANGE_PCNT$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_AVG$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_AVG$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_STDV$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_STDV$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_UNIF$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_UNIF$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_MIN$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_MIN$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_MAX$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_MAX$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_RANGE$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_RANGE$>
|
|
DestRDSTestRec<RDS_TEST_SHEETRHO_RANGE_PCNT$> = SourceRDSTestRec<RDS_TEST_SHEETRHO_RANGE_PCNT$>
|
|
DestRDSTestRec<RDS_TEST_RES_AVG$> = SourceRDSTestRec<RDS_TEST_RES_AVG$>
|
|
DestRDSTestRec<RDS_TEST_RES_STDV$> = SourceRDSTestRec<RDS_TEST_RES_STDV$>
|
|
DestRDSTestRec<RDS_TEST_RES_UNIF$> = SourceRDSTestRec<RDS_TEST_RES_UNIF$>
|
|
DestRDSTestRec<RDS_TEST_RES_MIN$> = SourceRDSTestRec<RDS_TEST_RES_MIN$>
|
|
DestRDSTestRec<RDS_TEST_RES_MAX$> = SourceRDSTestRec<RDS_TEST_RES_MAX$>
|
|
DestRDSTestRec<RDS_TEST_RES_RANGE$> = SourceRDSTestRec<RDS_TEST_RES_RANGE$>
|
|
DestRDSTestRec<RDS_TEST_RES_RANGE_PCNT$> = SourceRDSTestRec<RDS_TEST_RES_RANGE_PCNT$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_AVG$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_AVG$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_STDV$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_STDV$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_UNIF$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_UNIF$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_MIN$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_MIN$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_MAX$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_MAX$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_RANGE$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_RANGE$>
|
|
DestRDSTestRec<RDS_TEST_HGCV1_RES_RANGE_PCNT$> = SourceRDSTestRec<RDS_TEST_HGCV1_RES_RANGE_PCNT$>
|
|
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSTestKey)
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, DestRDSTestRec)
|
|
* obj_Tables('WriteRec',RTParms) ;* Write and unlock RDS_TEST records
|
|
obj_Tables('WriteOnlyRec',RTParms) ;* Write but don't worry about unlocking.
|
|
|
|
END
|
|
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
Delete:
|
|
* * * * * * *
|
|
|
|
|
|
MetKeys = Parms[1,@RM]
|
|
|
|
IF MetKeys = '' THEN RETURN
|
|
|
|
CONVERT @VM:@SVM TO @FM:@FM IN MetKeys
|
|
|
|
OPEN 'RDS_TEST' TO MetFile ELSE
|
|
ErrorMsg = 'Unable to open "RDS_TEST" table.(':Method:').'
|
|
RETURN
|
|
END
|
|
|
|
OPEN 'TW_USE' TO UseFile ELSE
|
|
ErrorMsg = 'Unable to open "TW_USE" table.(':Method:').'
|
|
RETURN
|
|
END
|
|
|
|
KeyCnt = COUNT(MetKeys,@FM) + (MetKeys NE '')
|
|
|
|
FOR I = 1 TO KeyCnt
|
|
|
|
MetKey = MetKeys<I>
|
|
|
|
TWUseKeys = XLATE('RDS_TEST',MetKey,RDS_TEST_TW_USE_ID$,'X')
|
|
|
|
UseRecordsCleared = 1
|
|
|
|
UseCnt = COUNT(TWUseKeys,@VM) + (TWUseKeys NE '')
|
|
|
|
FOR N = 1 TO UseCnt
|
|
TWUseKey = TWUseKeys<1,N>
|
|
DELETE UseFile,TWUseKey ELSE UseRecordsCleared = 0
|
|
NEXT N
|
|
|
|
IF UseRecordsCleared = 1 THEN
|
|
DELETE MetFile,MetKeys<I> ELSE NULL
|
|
END
|
|
NEXT I
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
CalcMissing:
|
|
* * * * * * *
|
|
|
|
RDSTestRec = Parms[1,@RM]
|
|
|
|
IF RDSTestRec = '' THEN RETURN
|
|
|
|
* Calculate the resistivity values
|
|
|
|
SheetRhoReads = OCONV(RDSTestRec<RDS_TEST_READ_SHEET_RHO$>,'MD3')
|
|
ThickReads = OCONV(RDSTestRec<RDS_TEST_READ_THICK$>,'MD2')
|
|
ThickOvergrowAvg = OCONV(RDSTestRec<RDS_TEST_THICK_OVERGROW_AVG$>,'MD2')
|
|
ReactorType = RdsTestRec<RDS_TEST_REACTOR_TYPE$>
|
|
|
|
IF RDSTestRec<RDS_TEST_SPEC_RES_UNITS$> = RES_SPEC_UNITS$ THEN
|
|
|
|
* Calculate Resistivity Reads and Statistics
|
|
|
|
ReadCnt = COUNT(SheetRhoReads,@VM) + (SheetRhoReads NE '')
|
|
Readings = ''
|
|
|
|
FOR I = 1 TO ReadCnt
|
|
SheetRhoRead = SheetRhoReads<1,I>
|
|
ThickRead = ThickReads<1,I>
|
|
|
|
IF ThickOvergrowAvg _NEX '' THEN ThickRead = ThickOverGrowAvg
|
|
|
|
IF SheetRhoRead _NEX 0 AND SheetRhoRead NE '' AND ThickRead _NEX 0 AND ThickRead NE '' THEN
|
|
IF ReactorType = 'P' OR ReactorType = 'EPP' THEN
|
|
Readings<1,I> = OCONV(ICONV((SheetRhoRead * ThickRead/10000),'MD3')*10,'MD4Z') ;* Crutch for EpiPRO with to tight of specs 7/3/2008 JCH
|
|
END ELSE
|
|
Readings<1,I> = OCONV(ICONV((SheetRhoRead * ThickRead/10000),'MD4'),'MD4Z')
|
|
END
|
|
|
|
END ELSE
|
|
Readings<1,I> = ''
|
|
END
|
|
NEXT I
|
|
|
|
IF Readings NE '' THEN
|
|
Results = obj_RDS_Test('CalcStats',Readings:@RM:'MD4')
|
|
|
|
CONVERT @RM TO @FM IN Results
|
|
|
|
RDSTestRec<RDS_TEST_RES_AVG$> = ICONV(Results[1,@FM],'MD4')
|
|
RDSTestRec<RDS_TEST_RES_STDV$> = ICONV(Results[COL2()+1,@FM],'MD4')
|
|
RDSTestRec<RDS_TEST_RES_UNIF$> = ICONV(Results[COL2()+1,@FM],'MD2')
|
|
RDSTestRec<RDS_TEST_RES_MIN$> = ICONV(Results[COL2()+1,@FM],'MD4')
|
|
RDSTestRec<RDS_TEST_RES_MAX$> = ICONV(Results[COL2()+1,@FM],'MD4')
|
|
END
|
|
|
|
END ELSE
|
|
|
|
* Calculate SheetRho statistics
|
|
Readings = OCONV(RDSTestRec<RDS_TEST_READ_SHEET_RHO$>,'MD3')
|
|
|
|
IF Readings NE '' THEN
|
|
Results = obj_RDS_Test('CalcStats',Readings:@RM:'MD3')
|
|
|
|
CONVERT @RM TO @FM IN Results
|
|
|
|
RDSTestRec<RDS_TEST_SHEETRHO_AVG$> = ICONV(Results[1,@FM],'MD3')
|
|
RDSTestRec<RDS_TEST_SHEETRHO_STDV$> = ICONV(Results[COL2()+1,@FM],'MD4')
|
|
RDSTestRec<RDS_TEST_SHEETRHO_UNIF$> = ICONV(Results[COL2()+1,@FM],'MD3')
|
|
RDSTestRec<RDS_TEST_SHEETRHO_MIN$> = ICONV(Results[COL2()+1,@FM],'MD3')
|
|
RDSTestRec<RDS_TEST_SHEETRHO_MAX$> = ICONV(Results[COL2()+1,@FM],'MD3')
|
|
END
|
|
|
|
END
|
|
|
|
Result = RDSTestRec
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
OutOfSpec:
|
|
* * * * * * *
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
RDSNo = RdsTestRec<RDS_TEST_RDS_NO$>
|
|
LSId = RdsTestRec<RDS_TEST_LS_ID$>
|
|
ReactorType = RdsTestRec<RDS_TEST_REACTOR_TYPE$>
|
|
|
|
NoConversion = 1
|
|
|
|
GOSUB Resistivity ;* Calculate Resistvity values
|
|
|
|
ResReads = Result
|
|
Result = ''
|
|
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
HgCvReads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
SpecThickMin = RDSTestRec<RDS_TEST_SPEC_THICK_MIN$>
|
|
SpecThickMax = RDSTestRec<RDS_TEST_SPEC_THICK_MAX$>
|
|
|
|
SpecResMin = RDSTestRec<RDS_TEST_SPEC_RES_MIN$>
|
|
SpecResMax = RDSTestRec<RDS_TEST_SPEC_RES_MAX$>
|
|
|
|
SpecResUnits = RDSTestRec<RDS_TEST_SPEC_RES_UNITS$>
|
|
|
|
ReadLineCnt = COUNT(ThickReads,@VM) + (ThickReads NE '')
|
|
|
|
ThickSpecFlag = 0
|
|
SheetRhoSpecFlag = 0
|
|
ResistivitySpecFlag = 0
|
|
HgCvSpecFlag = 0
|
|
|
|
FOR I = 1 TO ReadLineCnt
|
|
ThickVal = ThickReads<1,I>
|
|
ThickVal = ICONV(ThickVal, "MD1")
|
|
IF ThickVal NE '' THEN
|
|
IF ThickVal > SpecThickMax OR ThickVal < SpecThickMin THEN ThickSpecFlag = 1
|
|
END
|
|
|
|
IF SpecResUnits = SHEETRHO_SPEC_UNITS$ THEN
|
|
ResVal = SheetRhoReads<1,I>
|
|
IF ResVal NE '' THEN
|
|
IF ResVal > SpecResMax OR ResVal < SpecResMin THEN SheetRhoSpecFlag = 1
|
|
END
|
|
END
|
|
|
|
IF SpecResUnits = RES_SPEC_UNITS$ THEN
|
|
ResVal = ResReads<1,I>
|
|
IF ResVal = 0 THEN ResVal = ''
|
|
IF ResVal NE '' THEN
|
|
IF ResVal > SpecResMax*10 OR ResVal < SpecResMin*10 THEN ResistivitySpecFlag = 1
|
|
END
|
|
|
|
HgCvVal = HgCvReads<1,I>
|
|
IF HgCvVal NE '' THEN
|
|
IF HgCvVal > SpecResMax OR HgCvVal < SpecResMin THEN HgCvSpecFlag = 1
|
|
END
|
|
END
|
|
|
|
NEXT I
|
|
|
|
ThickMinValue = RDSTestRec<RDS_TEST_THICK_MIN$>
|
|
ThickMaxValue = RDSTestRec<RDS_TEST_THICK_MAX$>
|
|
ThickMinValue = ICONV(ThickMinValue, "MD1")
|
|
ThickMaxValue = ICONV(ThickMaxValue, "MD1")
|
|
|
|
IF ThickMinValue < SpecThickMin AND ThickMinValue NE '' THEN ThickSpecFlag = 1
|
|
IF ThickMaxValue > SpecThickMax AND ThickMaxValue NE '' THEN ThickSpecFlag = 1
|
|
|
|
BEGIN CASE
|
|
CASE SpecResUnits = SHEETRHO_SPEC_UNITS$
|
|
|
|
ResMinValue = RDSTestRec<RDS_TEST_SHEETRHO_MIN$>
|
|
ResMaxValue = RDSTestRec<RDS_TEST_SHEETRHO_MAX$>
|
|
|
|
IF ResMinValue < SpecResMin AND ResMinValue NE ''THEN SheetRhoSpecFlag = 1
|
|
IF ResMaxValue > SpecResMax AND ResMaxValue NE '' THEN SheetRhoSpecFlag = 1
|
|
|
|
CASE SpecResUnits = RES_SPEC_UNITS$
|
|
|
|
ResMinValue = RDSTestRec<RDS_TEST_RES_MIN$>
|
|
ResMaxValue = RDSTestRec<RDS_TEST_RES_MAX$>
|
|
|
|
SpecResMin = SpecResMin*10
|
|
SpecResMax = SpecResMax*10
|
|
|
|
IF ResMinValue < SpecResMin AND ResMinValue NE '' THEN ResistivitySpecFlag = 1 ;* Spec adjusted for Resistivity change to MD4 - JCH 7/1/2008
|
|
IF ResMaxValue > SpecResMax AND ResMaxValue NE '' THEN ResistivitySpecFlag = 1 ;* Spec adjusted for Resistivity change to MD4 - JCH 7/1/2008
|
|
|
|
HgCvMinValue = RDSTestRec<RDS_TEST_RES_MIN$>
|
|
HgCvMaxValue = RDSTestRec<RDS_TEST_RES_MAX$>
|
|
|
|
IF HgCvMinValue < SpecResMin AND HgCvMinValue NE '' THEN HgCvSpecFlag = 1
|
|
IF HgCvMaxValue > SpecResMax AND HgCvMaxValue NE '' THEN HgCvSpecFlag = 1
|
|
|
|
CASE 1
|
|
NULL
|
|
|
|
END CASE
|
|
|
|
ASETSpecFlag = 0
|
|
|
|
ASETResults = RDSTestRec<RDS_TEST_ASET_RESULTS$>
|
|
|
|
IF ASETResults > 179 THEN ASETSpecFlag = 1
|
|
|
|
IF ThickSpecFlag OR SheetRhoSpecFlag OR ResistivitySpecFlag OR HgCvSpecFlag OR ASETSpecFlag THEN
|
|
Result = 1
|
|
END ELSE
|
|
Result = ''
|
|
|
|
END
|
|
|
|
RETURN Result
|
|
|
|
|
|
* * * * * * *
|
|
TestWfrCount:
|
|
* * * * * * *
|
|
|
|
RDSTestKeys = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKeys = '' THEN RETURN
|
|
|
|
TestWfrCnt = 0
|
|
|
|
PopupData = XLATE('SYSREPOSPOPUPS','LSL2**TW_TYPES',8,'X')
|
|
TestTypes = ''
|
|
|
|
FOR I = 1 TO COUNT(PopupData,@VM) + (PopupData NE '')
|
|
IF PopupData<1,I,3> NE 'PROD' AND PopupData<1,I,3> NE 'CUST'THEN
|
|
TestTypes<1,-1> = PopupData<1,I,1>
|
|
END
|
|
NEXT I
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TestTypes
|
|
|
|
FOR N = 1 TO COUNT(RDSTestKeys,@VM) + (RDSTestKeys NE '')
|
|
RDSTestKey = RDSTestKeys<1,N>
|
|
|
|
IF N = 1 AND RDSTestRec = '' THEN
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END ELSE
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
IF TWUseIDs NE '' THEN
|
|
TWTypes = XLATE('TW_USE',TWUseIDs,TW_USE_TW_TYPE$,'X')
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
END ELSE
|
|
TWTypes = RDSTestRec<RDS_TEST_TW_TYPE$>
|
|
TWCnts = RDSTestRec<RDS_TEST_TW_CNT$>
|
|
END
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TWTypes
|
|
|
|
FOR I = 1 TO COUNT(TWTypes,@VM) + (TWTypes NE '')
|
|
TWType = TWTypes<1,I>
|
|
|
|
LOCATE TWType IN TestTypes USING @VM SETTING Dummy THEN
|
|
TestWfrCnt += TWCnts<1,I>
|
|
END
|
|
NEXT I
|
|
|
|
NEXT N
|
|
|
|
IF TestWfrCnt > 0 THEN Result = TestWfrCnt ELSE Result = ''
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
PrimeWfrCount:
|
|
* * * * * * *
|
|
|
|
RDSTestKeys = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKeys = '' THEN RETURN
|
|
|
|
TestWfrCnt = 0
|
|
|
|
PopupData = XLATE('SYSREPOSPOPUPS','LSL2**TW_TYPES',8,'X')
|
|
PrimeTypes = ''
|
|
|
|
FOR I = 1 TO COUNT(PopupData,@VM) + (PopupData NE '')
|
|
IF PopupData<1,I,3> = 'PRIME' THEN
|
|
PrimeTypes<1,-1> = PopupData<1,I,1>
|
|
END
|
|
NEXT I
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN PrimeTypes
|
|
|
|
|
|
FOR N = 1 TO COUNT(RDSTestKeys,@VM) + (RDSTestKeys NE '')
|
|
RDSTestKey = RDSTestKeys<1,N>
|
|
|
|
IF N = 1 AND RDSTestRec = '' THEN
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END ELSE
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
IF TWUseIDs NE '' THEN
|
|
TWTypes = XLATE('TW_USE',TWUseIDs,TW_USE_TW_TYPE$,'X')
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
END ELSE
|
|
TWTypes = RDSTestRec<RDS_TEST_TW_TYPE$>
|
|
TWCnts = RDSTestRec<RDS_TEST_TW_CNT$>
|
|
END
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TWTypes
|
|
|
|
FOR I = 1 TO COUNT(TWTypes,@VM) + (TWTypes NE '')
|
|
TWType = TWTypes<1,I>
|
|
LOCATE TWType IN PrimeTypes USING @VM SETTING Dummy THEN
|
|
TestWfrCnt += TWCnts<1,I>
|
|
END
|
|
NEXT I
|
|
NEXT N
|
|
|
|
IF TestWfrCnt > 0 THEN Result = TestWfrCnt ELSE Result = ''
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ProdTestCount:
|
|
* * * * * * *
|
|
|
|
RDSTestKeys = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKeys = '' THEN RETURN
|
|
|
|
RDSTestKeysHex = SRP_Encode(RDSTestKeys, 'HEX')
|
|
If Memory_Services('IsValueExpired', RDSTestKeysHex, 1) then
|
|
// Caching effectively disabled until further notice.
|
|
// An unintended side effect of caching is stale data being displayed.
|
|
ProdTypes = Memory_Services('GetValue', 'PROD_TW_TYPES')
|
|
If ProdTypes EQ '' then
|
|
PopupData = XLATE('SYSREPOSPOPUPS','LSL2**TW_TYPES',8,'X')
|
|
ProdTypes = ''
|
|
|
|
FOR I = 1 TO COUNT(PopupData,@VM) + (PopupData NE '')
|
|
IF PopupData<1,I,3> = 'PROD' THEN
|
|
ProdTypes<1,-1> = PopupData<1,I,1>
|
|
END
|
|
NEXT I
|
|
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN ProdTypes
|
|
Memory_Services('SetValue', 'PROD_TW_TYPES', ProdTypes)
|
|
end
|
|
SRP_Stopwatch('Start', 'ProdTestCount-NoCache')
|
|
ProdWfrCnt = 0
|
|
|
|
FOR N = 1 TO COUNT(RDSTestKeys,@VM) + (RDSTestKeys NE '')
|
|
RDSTestKey = RDSTestKeys<1,N>
|
|
|
|
IF N = 1 AND RDSTestRec = '' THEN
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END ELSE
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
IF TWUseIDs NE '' THEN
|
|
TWTypes = XLATE('TW_USE',TWUseIDs,TW_USE_TW_TYPE$,'X')
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
END ELSE
|
|
TWTypes = RDSTestRec<RDS_TEST_TW_TYPE$>
|
|
TWCnts = RDSTestRec<RDS_TEST_TW_CNT$>
|
|
END
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TWTypes
|
|
|
|
FOR I = 1 TO COUNT(TWTypes,@VM) + (TWTypes NE '')
|
|
TWType = TWTypes<1,I>
|
|
LOCATE TWType IN ProdTypes USING @VM SETTING Dummy THEN
|
|
ProdWfrCnt += TWCnts<1,I>
|
|
END
|
|
NEXT I
|
|
NEXT N
|
|
IF ProdWfrCnt > 0 THEN Result = ProdWfrCnt ELSE Result = ''
|
|
Memory_Services('SetValue', RDSTestKeysHex, Result)
|
|
SRP_Stopwatch('Stop', 'ProdTestCount-NoCache')
|
|
end else
|
|
Result = Memory_Services('GetValue', RDSTestKeysHex)
|
|
end
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ReclaimCount:
|
|
* * * * * * *
|
|
|
|
RDSTestKeys = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKeys = '' THEN RETURN
|
|
|
|
PopupData = XLATE('SYSREPOSPOPUPS','LSL2**TW_TYPES',8,'X')
|
|
ReclTypes = ''
|
|
|
|
FOR I = 1 TO COUNT(PopupData,@VM) + (PopupData NE '')
|
|
IF PopupData<1,I,3> = 'RECL' THEN
|
|
ReclTypes<1,-1> = PopupData<1,I,1>
|
|
END
|
|
NEXT I
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN ReclTypes
|
|
|
|
ReclWfrCnt = 0
|
|
|
|
FOR N = 1 TO COUNT(RDSTestKeys,@VM) + (RDSTestKeys NE '')
|
|
RDSTestKey = RDSTestKeys<1,N>
|
|
|
|
IF N = 1 AND RDSTestRec = '' THEN
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END ELSE
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
IF TWUseIDs NE '' THEN
|
|
TWTypes = XLATE('TW_USE',TWUseIDs,TW_USE_TW_TYPE$,'X')
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
END ELSE
|
|
TWTypes = RDSTestRec<RDS_TEST_TW_TYPE$>
|
|
TWCnts = RDSTestRec<RDS_TEST_TW_CNT$>
|
|
END
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TWTypes
|
|
|
|
FOR I = 1 TO COUNT(TWTypes,@VM) + (TWTypes NE '')
|
|
TWType = TWTypes<1,I>
|
|
|
|
LOCATE TWType IN ReclTypes USING @VM SETTING Dummy THEN
|
|
ReclWfrCnt += TWCnts<1,I>
|
|
END
|
|
NEXT I
|
|
NEXT N
|
|
|
|
IF ReclWfrCnt > 0 THEN Result = ReclWfrCnt ELSE Result = ''
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
CustTWCount:
|
|
* * * * * * *
|
|
|
|
RDSTestKeys = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKeys = '' THEN RETURN
|
|
|
|
PopupData = XLATE('SYSREPOSPOPUPS','LSL2**TW_TYPES',8,'X')
|
|
CustTypes = ''
|
|
|
|
FOR I = 1 TO COUNT(PopupData,@VM) + (PopupData NE '')
|
|
IF PopupData<1,I,3> = 'CUST' THEN
|
|
CustTypes<1,-1> = PopupData<1,I,1>
|
|
END
|
|
NEXT I
|
|
|
|
CustWfrCnt = 0
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN CustTypes
|
|
|
|
FOR N = 1 TO COUNT(RDSTestKeys,@VM) + (RDSTestKeys NE '')
|
|
RDSTestKey = RDSTestKeys<1,N>
|
|
|
|
IF N = 1 AND RDSTestRec = '' THEN
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END ELSE
|
|
RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
END
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
IF TWUseIDs NE '' THEN
|
|
TWTypes = XLATE('TW_USE',TWUseIDs,TW_USE_TW_TYPE$,'X')
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
END ELSE
|
|
TWTypes = RDSTestRec<RDS_TEST_TW_TYPE$>
|
|
TWCnts = RDSTestRec<RDS_TEST_TW_CNT$>
|
|
END
|
|
|
|
RDSNo = RDSTestRec<RDS_TEST_RDS_NO$>
|
|
WONo = XLATE('REACT_RUN',RDSNo,REACT_RUN_WO_NO$,'X')
|
|
CustEpiPartKey = XLATE('WO_LOG',WONo,'CUST_EPI_PART_NO','X')
|
|
TWRetInst = XLATE('CUST_EPI_PART',CustEpiPartKey,CUST_EPI_PART_TW_RET_INST$,'X')
|
|
|
|
BEGIN CASE
|
|
CASE TWRetInst = 'C' ;* Customer supplied only
|
|
|
|
CONVERT @LOWER_CASE TO @UPPER_CASE IN TWTypes
|
|
|
|
FOR I = 1 TO COUNT(TWTypes,@VM) + (TWTypes NE '')
|
|
TWType = TWTypes<1,I>
|
|
|
|
LOCATE TWType IN CustTypes USING @VM SETTING Dummy THEN
|
|
CustWfrCnt += TWCnts<1,I>
|
|
END
|
|
NEXT I
|
|
|
|
CASE TWRetInst = 'P' ;* Last good P+ and P- test wafers
|
|
|
|
IF INDEX(TWTypes,'P+',1) THEN CustWfrCnt += 1
|
|
IF INDEX(TWTypes,'P-',1) THEN CustWfrCnt += 1
|
|
|
|
|
|
CASE TWRetInst = 'N' ;* None are sent to customer
|
|
CustWfrCnt = 0
|
|
|
|
CASE TWRetInst = ''
|
|
CustWfrCnt = 0
|
|
|
|
END CASE
|
|
NEXT N
|
|
|
|
IF CustWfrCnt > 0 THEN Result = CustWfrCnt ELSE Result = ''
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
GetReadSet:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
|
|
IF MetNo = '' THEN RETURN
|
|
|
|
MetRec = XLATE('RDS_TEST',MetNo,'','X')
|
|
|
|
IF MetRec = '' THEN RETURN
|
|
|
|
TestPointMap = MetRec<RDS_TEST_TEST_POINT_MAP$>
|
|
TestPoints = XLATE('RDS_TEST',MetNo,'TEST_POINTS','X')
|
|
|
|
ThickReads = OCONV(MetRec<RDS_TEST_READ_THICK$>,'MD2')
|
|
SheetRhoReads = OCONV(MetRec<RDS_TEST_READ_SHEET_RHO$>,'MD3')
|
|
HgCV1Reads = OCONV(MetRec<RDS_TEST_READ_HGCV1_RES$>,'MD3')
|
|
|
|
LineOut = 0
|
|
FOR I = 1 TO 17
|
|
IF ThickReads<1,I> NE '' OR SheetRhoReads<1,I> NE '' OR HgCV1Reads<1,I> NE '' THEN
|
|
LineOut += 1
|
|
Result<1,LineOut> = TestPoints<1,LineOut>
|
|
Result<2,LineOut> = ThickReads<1,I>
|
|
Result<3,LineOut> = SheetRhoReads<1,I>
|
|
Result<4,LineOut> = HgCV1Reads<1,I>
|
|
|
|
END
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
SetReadSet:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
ThickReads = Parms[COL2()+1,@RM]
|
|
SheetRhoReads = Parms[COL2()+1,@RM]
|
|
HgCV1Reads = Parms[COL2()+1,@RM]
|
|
|
|
IF MetNo = '' THEN ErrorMsg = 'Null parameter "MetNo" passed to routine. (':Method:')'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Readings = ThickReads
|
|
Conversion = 'MD2'
|
|
|
|
GOSUB CalcStats
|
|
|
|
ThickAvg = Result[1,@RM]
|
|
ThickStdev = Result[COL2()+1,@RM]
|
|
ThickUnif = Result[COL2()+1,@RM]
|
|
ThickMin = Result[COL2()+1,@RM]
|
|
ThickMax = Result[COL2()+1,@RM]
|
|
ThickRange = Result[COL2()+1,@RM]
|
|
ThickRangePcnt = Result[COL2()+1,@RM]
|
|
|
|
Result = ''
|
|
Readings = SheetRhoReads
|
|
Conversion = 'MD3'
|
|
|
|
GOSUB CalcStats
|
|
|
|
SheetRhoAvg = Result[1,@RM]
|
|
SheetRhoStdev = Result[COL2()+1,@RM]
|
|
SheetRhoUnif = Result[COL2()+1,@RM]
|
|
SheetRhoMin = Result[COL2()+1,@RM]
|
|
SheetRhoMax = Result[COL2()+1,@RM]
|
|
SheetRhoRange = Result[COL2()+1,@RM]
|
|
SheetRhoRangePcnt = Result[COL2()+1,@RM]
|
|
|
|
Result = ''
|
|
Readings = HgCV1Reads
|
|
Conversion = 'MD3'
|
|
|
|
GOSUB CalcStats
|
|
|
|
HgCV1Avg = Result[1,@RM]
|
|
HgCV1Stdev = Result[COL2()+1,@RM]
|
|
HgCV1Unif = Result[COL2()+1,@RM]
|
|
HgCV1Min = Result[COL2()+1,@RM]
|
|
HgCV1Max = Result[COL2()+1,@RM]
|
|
HgCV1Range = Result[COL2()+1,@RM]
|
|
HgCV1RangePcnt = Result[COL2()+1,@RM]
|
|
|
|
thisThickReads = ICONV(ThickReads,'MD2')
|
|
thisSheetRhoReads = ICONV(SheetRhoReads,'MD3')
|
|
thisHgCV1Reads = ICONV(HgCV1Reads,'MD3')
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS_TEST':@RM:MetNo
|
|
* MetRec = obj_Tables('ReadRec',RTParms)
|
|
MetRec = Database_Services('ReadDataRow', 'RDS_TEST', MetNo)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS_TEST record ':QUOTE(MetNo):' for SetReadSet update.'
|
|
RETURN
|
|
END
|
|
|
|
MetRec<RDS_TEST_THICK_AVG$> = ICONV(ThickAvg,'MD2')
|
|
MetRec<RDS_TEST_THICK_STDV$> = ICONV(ThickStdev,'MD4')
|
|
MetRec<RDS_TEST_THICK_UNIF$> = ICONV(ThickUnif,'MD2')
|
|
MetRec<RDS_TEST_THICK_MIN$> = ICONV(ThickMin,'MD2')
|
|
MetRec<RDS_TEST_THICK_MAX$> = ICONV(ThickMax,'MD2')
|
|
MetRec<RDS_TEST_THICK_RANGE$> = ICONV(ThickRange,'MD2')
|
|
MetRec<RDS_TEST_THICK_RANGE_PCNT$> = ICONV(ThickRangePcnt,'MD4S%')
|
|
|
|
MetRec<RDS_TEST_SHEETRHO_AVG$> = ICONV(SheetRhoAvg,'MD3')
|
|
MetRec<RDS_TEST_SHEETRHO_STDV$> = ICONV(SheetRhoStdev,'MD4')
|
|
MetRec<RDS_TEST_SHEETRHO_UNIF$> = ICONV(SheetRhoUnif,'MD2')
|
|
MetRec<RDS_TEST_SHEETRHO_MIN$> = ICONV(SheetRhoMin,'MD3')
|
|
MetRec<RDS_TEST_SHEETRHO_MAX$> = ICONV(SheetRhoMax,'MD3')
|
|
MetRec<RDS_TEST_SHEETRHO_RANGE$> = ICONV(SheetRhoRange,'MD3')
|
|
MetRec<RDS_TEST_SHEETRHO_RANGE_PCNT$> = ICONV(SheetRhoRangePcnt,'MD2')
|
|
|
|
MetRec<RDS_TEST_HGCV1_RES_AVG$> = ICONV(HgCV1Avg,'MD3')
|
|
MetRec<RDS_TEST_HGCV1_RES_STDV$> = ICONV(HgCV1Stdev,'MD4')
|
|
MetRec<RDS_TEST_HGCV1_RES_UNIF$> = ICONV(HgCV1Unif,'MD2')
|
|
MetRec<RDS_TEST_HGCV1_RES_MIN$> = ICONV(HgCV1Min,'MD3')
|
|
MetRec<RDS_TEST_HGCV1_RES_MAX$> = ICONV(HgCV1Max,'MD3')
|
|
MetRec<RDS_TEST_HGCV1_RES_RANGE$> = ICONV(HgCV1Range,'MD3')
|
|
MetRec<RDS_TEST_HGCV1_RES_RANGE_PCNT$> = ICONV(HgCV1RangePcnt,'MD4')
|
|
|
|
TestPointMap = MetRec<RDS_TEST_TEST_POINT_MAP$>
|
|
TestPoints = XLATE('TEST_POINT_MAP',TestPointMap,2,'X')
|
|
|
|
TPCnt = COUNT(TestPoints,@VM) + (TestPoints NE '')
|
|
DispCnt = 17
|
|
BlankLineCnt = (DispCnt - TPCnt)/2
|
|
|
|
IF BlankLineCnt > 0 THEN
|
|
ThickReads = STR(@VM,BlankLineCnt):thisThickReads:STR(@VM,BlankLineCnt)
|
|
SheetRhoReads = STR(@VM,BlankLineCnt):thisSheetRhoReads:STR(@VM,BlankLineCnt)
|
|
HgCV1Reads = STR(@VM,BlankLineCnt):thisHgCV1Reads:STR(@VM,BlankLineCnt)
|
|
END
|
|
|
|
RDSNo = MetRec<RDS_TEST_RDS_NO$>
|
|
|
|
// Check for thickness changes and log if necessary.
|
|
If SRP_Array('Clean', MetRec<RDS_TEST_READ_THICK$>, 'TrimTrailing', @VM) NE SRP_Array('Clean', ThickReads, 'TrimTrailing', @VM) then
|
|
Post_Metrology_Manual_Data_Entry_Log(@USER4, 'Thickness', RDSNo : ' / ' : MetNo)
|
|
end
|
|
// Save the changes
|
|
MetRec<RDS_TEST_READ_THICK$> = ThickReads
|
|
// Check for resistivity changes and log if necessary.
|
|
If SRP_Array('Clean', MetRec<RDS_TEST_READ_SHEET_RHO$>, 'TrimTrailing', @VM) NE SRP_Array('Clean', SheetRhoReads, 'TrimTrailing', @VM) then
|
|
Post_Metrology_Manual_Data_Entry_Log(@USER4, 'Resistivity', RDSNo : ' / ' : MetNo)
|
|
end
|
|
// Save the changes
|
|
MetRec<RDS_TEST_READ_SHEET_RHO$> = SheetRhoReads
|
|
// Check for HgRes changes and log if necessary.
|
|
If SRP_Array('Clean', MetRec<RDS_TEST_READ_HGCV1_RES$>, 'TrimTrailing', @VM) NE SRP_Array('Clean', HgCV1Reads, 'TrimTrailing', @VM) then
|
|
Post_Metrology_Manual_Data_Entry_Log(@USER4, 'HgRes', RDSNo : ' / ' : MetNo)
|
|
end
|
|
// Save the changes
|
|
MetRec<RDS_TEST_READ_HGCV1_RES$> = HgCV1Reads
|
|
|
|
|
|
Parms = MetRec
|
|
|
|
GOSUB CalcMissing ;* Calcs the resistivity
|
|
|
|
MetRec = Result
|
|
Result = ''
|
|
|
|
// Set the override flag if passed in.
|
|
MetRec<RDS_TEST_MODIFY_OVERRIDE$> = Override
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, MetRec)
|
|
|
|
Database_Services('WriteDataRow', 'RDS_TEST', MetNo, MetRec, True$, False$, True$)
|
|
* obj_Tables('WriteRec',RTParms)
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
SetZone:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
Zone = Parms[COL2()+1,@RM]
|
|
|
|
IF MetNo = '' THEN ErrorMsg = 'Null parameter "MetNo" passed to routine. (':Method:')'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS_TEST':@RM:MetNo
|
|
MetRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS_TEST record ':QUOTE(MetNo):' for SetReadSet update.'
|
|
RETURN
|
|
END
|
|
|
|
MetRec<RDS_TEST_ZONE$> = Zone
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, MetRec)
|
|
obj_Tables('WriteRec',RTParms)
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
TWSignedOff:
|
|
* * * * * * *
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
TWUseIDs = RDSTestRec<RDS_TEST_TW_USE_ID$>
|
|
|
|
TWCnts = XLATE('TW_USE',TWUseIDs,TW_USE_TW_QTY$,'X')
|
|
TWSigs = XLATE('TW_USE',TWUseIDs,TW_USE_SIGNATURE$,'X')
|
|
|
|
IF TWCnts = '' THEN
|
|
*Result = 0
|
|
Result = 1
|
|
END ELSE
|
|
Result = 1
|
|
FOR I = 1 TO COUNT(TWCnts,@VM) + (TWCnts NE '')
|
|
IF TWCnts<1,I> NE '' AND TWSigs<1,I> = '' THEN
|
|
Result = 0
|
|
END
|
|
UNTIL Result = 0
|
|
NEXT I
|
|
END
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ExpReadings:
|
|
* * * * * * *
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
ExpFormat = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
NoConversion = 1
|
|
|
|
GOSUB Resistivity
|
|
|
|
Resistivities = Result
|
|
Result = ''
|
|
|
|
TestPoints = XLATE('TEST_POINT_MAP',RDSTestRec<RDS_TEST_TEST_POINT_MAP$>,2,'X')
|
|
|
|
TPCnt = COUNT(TestPoints,@VM) +(TestPoints NE '')
|
|
DispCnt = 17
|
|
BlankLineCnt = (DispCnt - TPCnt)/2
|
|
IF BlankLineCnt > 0 THEN
|
|
TestPoints = STR(@VM,BlankLineCnt):TestPoints:STR(@VM,BlankLineCnt)
|
|
END
|
|
|
|
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
Hgcv1Reads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
ExpTestPoints = ''
|
|
ExpThickReads = ''
|
|
ExpSheetRhoReads = ''
|
|
ExpHgcv1Reads = ''
|
|
ExpResistivities = ''
|
|
|
|
ResLine = 0
|
|
FOR I = 1 TO 17
|
|
ThickRead = ThickReads<1,I>
|
|
SheetRhoRead = SheetRhoReads<1,I>
|
|
Hgcv1Read = Hgcv1Reads<1,I>
|
|
|
|
IF ThickRead = '' AND SheetRhoRead = '' AND Hgcv1Read = '' ELSE
|
|
ResLine += 1
|
|
ExpTestPoints<1,ResLine> = TestPoints<1,I>
|
|
ExpThickReads<1,ResLine> = ThickReads<1,I>
|
|
ExpSheetRhoReads<1,ResLine> = SheetRhoReads<1,I>
|
|
ExpHgcv1Reads<1,ResLine> = Hgcv1Reads<1,I>
|
|
ExpResistivities<1,ResLine> = Resistivities<1,I>
|
|
END
|
|
NEXT I
|
|
|
|
IF ExpFormat = 1 THEN
|
|
ExpThickReads = OCONV(ExpThickReads,'MD2')
|
|
ExpSheetRhoReads = OCONV(ExpSheetRhoReads,'MD3')
|
|
ExpHgcv1Reads = OCONV(ExpHgcv1Reads,'MD3')
|
|
ExpResistivities = OCONV(ExpResistivities,'MD4Z')
|
|
END
|
|
|
|
Result = ExpTestPoints:@FM:ExpThickReads:@FM:ExpSheetRhoReads:@FM:ExpHgcv1Reads:@FM:ExpResistivities
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ExpTower:
|
|
* * * * * * *
|
|
|
|
* Customer Specific data Export
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
NoConversion = 1
|
|
|
|
GOSUB Resistivity
|
|
|
|
Resistivities = Result
|
|
Result = ''
|
|
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
Hgcv1Reads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
ResSampSize = ''
|
|
ThickSampSize = ''
|
|
SheetRhoSampSize = ''
|
|
Hgcv1SampSize = ''
|
|
|
|
FOR I = 1 TO 17
|
|
IF Resistivities<1,I> NE '' THEN ResSampSize += 1
|
|
IF ThickReads<1,I> NE '' THEN ThickSampSize += 1
|
|
IF SheetRhoReads<1,I> NE '' THEN SheetRhoSampSize += 1
|
|
IF Hgcv1Reads<1,I> NE '' THEN Hgcv1SampSize += 1
|
|
NEXT I
|
|
|
|
|
|
IF ThickSampSize > 0 THEN
|
|
NewLine = '"Thickness"':@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_THICK_AVG$>,'MD2'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_THICK_STDV$>,'MD4'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_THICK_MIN$>,'MD2'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_THICK_MAX$>,'MD2'):@VM
|
|
NewLine := ThickSampSize:@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_THICK_MIN$>,'MD2'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_THICK_MAX$>,'MD2'):@VM
|
|
NewLine := '':@VM
|
|
NewLine := '':@VM
|
|
NewLine := '"um"'
|
|
Result<-1> = NewLine
|
|
END
|
|
|
|
/*
|
|
IF SheetRhoSampSize > 0 THEN
|
|
NewLine = '"SheetRho"':@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SHEETRHO_AVG$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SHEETRHO_STDV$>,'MD4'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SHEETRHO_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SHEETRHO_MAX$>,'MD3'):@VM
|
|
NewLine := SheetRhoSampSize:@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MAX$>,'MD3'):@VM
|
|
NewLine := '':@VM
|
|
NewLine := '':@VM
|
|
NewLine := '"Ohm-cm"'
|
|
Result<-1> = NewLine
|
|
END
|
|
*/
|
|
|
|
IF Hgcv1SampSize > 0 THEN
|
|
NewLine = '"Resistivity-HgCv1"':@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_AVG$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_STDV$>,'MD4'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_MAX$>,'MD3'):@VM
|
|
NewLine := Hgcv1SampSize:@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MAX$>,'MD3'):@VM
|
|
NewLine := '':@VM
|
|
NewLine := '':@VM
|
|
NewLine := '"Ohm-cm"'
|
|
Result<-1> = NewLine
|
|
END
|
|
|
|
IF ResSampSize > 0 THEN
|
|
NewLine = '"Resistivity-Calc"':@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_RES_AVG$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_RES_STDV$>,'MD4'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_RES_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_RES_MAX$>,'MD3'):@VM
|
|
NewLine := ResSampSize:@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MIN$>,'MD3'):@VM
|
|
NewLine := OCONV(RDSTestRec<RDS_TEST_SPEC_RES_MAX$>,'MD3'):@VM
|
|
NewLine := '':@VM
|
|
NewLine := '':@VM
|
|
NewLine := '"Ohm-cm"'
|
|
Result<-1> = NewLine
|
|
END
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ExpIR:
|
|
* * * * * * *
|
|
|
|
* Customer Specific data Export
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
NoConversion = 1
|
|
|
|
GOSUB Resistivity
|
|
|
|
Resistivities = Result
|
|
Result = ''
|
|
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
Hgcv1Reads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
ResSampSize = ''
|
|
ThickSampSize = ''
|
|
SheetRhoSampSize = ''
|
|
Hgcv1SampSize = ''
|
|
|
|
Line = ''
|
|
FOR I = 1 TO 17
|
|
|
|
IF ThickReads<1,I> = '' THEN
|
|
Line<1,I> = ''
|
|
END ELSE
|
|
Line<1,I> = OCONV(ThickReads<1,I>,'MD2')
|
|
END
|
|
|
|
IF Resistivities<1,I> = '' THEN
|
|
Line<1,I+17> = ''
|
|
END ELSE
|
|
Line<1,I+17> = OCONV(Resistivities<1,I>,'MD4')
|
|
END
|
|
|
|
IF Hgcv1Reads<1,I> = '' THEN
|
|
Line<1,I+34> = ''
|
|
END ELSE
|
|
Line<1,I+34> = OCONV(Hgcv1Reads<1,I>,'MD3')
|
|
END
|
|
NEXT I
|
|
|
|
Result<-1> = Line
|
|
|
|
|
|
RETURN
|
|
|
|
* * * * * * *
|
|
ExpCOA:
|
|
* * * * * * *
|
|
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
NoConversion = 1
|
|
GOSUB Resistivity
|
|
|
|
|
|
|
|
Resistivities = Result
|
|
Result = ''
|
|
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
Hgcv1Reads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
TimeSTamp = RDSTestRec<RDS_TEST_MODIFY_DTM$>
|
|
|
|
*JRO New Reads
|
|
ThickAvg = OCONV(RDSTestRec<RDS_TEST_THICK_AVG$>, 'MD2')
|
|
ThickStdDev = OCONV(RDSTestRec<RDS_TEST_THICK_STDV$>, 'MD4')
|
|
ThickMin = OCONV(RDSTestRec<RDS_TEST_THICK_MIN$>, 'MD2')
|
|
ThickMax = OCONV(RDSTestRec<RDS_TEST_THICK_MAX$>, 'MD2')
|
|
|
|
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
Hgcv1Reads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
if RDSTestRec<RDS_TEST_RES_AVG$> NE '' THEN
|
|
ResAvg = OCONV(RDSTestRec<RDS_TEST_RES_AVG$>, 'MD4')
|
|
ResStdDev = OCONV(RDSTestRec<RDS_TEST_RES_STDV$>, 'MD4')
|
|
ResMin = OCONV(RDSTestRec<RDS_TEST_RES_MIN$>, 'MD4')
|
|
ResMax = OCONV(RDSTestRec<RDS_TEST_RES_MAX$>, 'MD4')
|
|
End else
|
|
ResAvg = OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_AVG$>, 'MD3')
|
|
ResStdDev = OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_STDV$ >, 'MD3')
|
|
ResMin = OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_MIN$>, 'MD3')
|
|
ResMax = OCONV(RDSTestRec<RDS_TEST_HGCV1_RES_MAX$>, 'MD3')
|
|
end
|
|
|
|
ResSampSize = ''
|
|
ThickSampSize = ''
|
|
SheetRhoSampSize = ''
|
|
Hgcv1SampSize = ''
|
|
|
|
Line = ''
|
|
|
|
|
|
Line = ThickAvg : @VM : ThickStdDev : @VM : ThickMin : @VM : ThickMax: @VM : ResAvg: @VM :ResStdDev: @VM :ResMin: @VM :ResMax
|
|
|
|
Result = Line
|
|
|
|
RETURN
|
|
|
|
* * * * * * *
|
|
RefreshSpecs:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
|
|
IF MetNo = '' THEN RETURN
|
|
|
|
TableVar = ''
|
|
OtParms = 'RDS_TEST':@RM:MetNo:@RM:TableVar
|
|
|
|
RDSTestRec = obj_Tables('ReadRec',OtParms)
|
|
|
|
IF Get_Status(errCode) THEN RETURN
|
|
|
|
RDSNo = RDSTestRec<RDS_TEST_RDS_NO$ >
|
|
|
|
PSNId = XLATE('REACT_RUN',RDSNo,'PS_NO','X')
|
|
|
|
LayerSet = RDSTestRec<RDS_TEST_LS_ID$>
|
|
|
|
LayerSpecs = obj_Prod_Spec('GetLayerProp',PSNId:@RM:LayerSet:@RM:1) ;* Last parameter specifies no output conversion on return data
|
|
|
|
LayerSpecs = FIELD(LayerSpecs,@FM,2,99) ;* Returns with the layer set ID in the first field of each line
|
|
|
|
IF Get_Status(errCode) THEN
|
|
obj_Tables('UnlockRec',OtParms)
|
|
RETURN
|
|
END
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_DOPANT$> = LayerSpecs<PRS_LAYER_DOPANT$>
|
|
RDSTestRec<RDS_TEST_SPEC_RECIPE$> = LayerSpecs<PRS_LAYER_RECIPE$>
|
|
RDSTestRec<RDS_TEST_SPEC_RECIPE_NAME$> = LayerSpecs<PRS_LAYER_RECIPE_NAME$>
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_MIN$> = LayerSpecs<PRS_LAYER_THICK_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_TARGET$> = LayerSpecs<PRS_LAYER_THICK_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_MAX$> = LayerSpecs<PRS_LAYER_THICK_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_THICK_UNITS$> = LayerSpecs<PRS_LAYER_THICK_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_MIN$> = LayerSpecs<PRS_LAYER_RES_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_TARGET$> = LayerSpecs<PRS_LAYER_RES_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_MAX$> = LayerSpecs<PRS_LAYER_RES_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_RES_UNITS$> = LayerSpecs<PRS_LAYER_RES_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_MIN$> = LayerSpecs<PRS_LAYER_CONC_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_TARGET$> = LayerSpecs<PRS_LAYER_CONC_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_MAX$> = LayerSpecs<PRS_LAYER_CONC_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_CON_UNITS$> = LayerSpecs<PRS_LAYER_CONC_UNITS$>
|
|
RDSTestRec<RDS_TEST_SPEC_STRESS_MIN$> = LayerSpecs<PRS_LAYER_STRESS_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_STRESS_MAX$> = LayerSpecs<PRS_LAYER_STRESS_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_TRANS$> = LayerSpecs<PRS_LAYER_TRANS_SPEC$>
|
|
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_MIN$> = LayerSpecs<PRS_LAYER_CRES_MIN$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_TARGET$> = LayerSpecs<PRS_LAYER_CRES_TARGET$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_MAX$> = LayerSpecs<PRS_LAYER_CRES_MAX$>
|
|
RDSTestRec<RDS_TEST_SPEC_CRES_UNITS$> = LayerSpecs<PRS_LAYER_CRES_UNITS$>
|
|
|
|
|
|
FOR A = 11 TO 19
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_THICK_MEASUREMENT$,A-10>
|
|
NEXT A
|
|
|
|
FOR A = 24 TO 32
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_RES_MEASUREMENT$,A-23>
|
|
NEXT A
|
|
|
|
FOR A = 37 TO 45
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_CONC_MEASUREMENT$,A-36>
|
|
NEXT A
|
|
|
|
FOR A = 50 to 58
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_STRESS_MEASUREMENT$,A-49>
|
|
NEXT A
|
|
|
|
FOR A = 121 TO 129
|
|
RDSTestRec<A> = LayerSpecs<PRS_LAYER_CRES_MEASUREMENT$,A-120>
|
|
NEXT A
|
|
|
|
|
|
WaferSize = XLATE( 'PROD_SPEC', PSNId, 'SUB_WAFER_SIZE', 'X' )
|
|
SubOrientation = XLATE('PROD_SPEC',PSNId,'SUB_ORIENTATION','X')
|
|
ResUnits = LayerSpecs<PRS_LAYER_RES_UNITS$>
|
|
|
|
ReactorType = XLATE('PROD_SPEC',PSNId,PROD_SPEC_REACTOR_TYPE$,'X')
|
|
ThickFilmMet = XLATE('PROD_SPEC',PSNId,PROD_SPEC_THICKFILM_MET$,'X') ;* Added 1/16/2009 JCH
|
|
|
|
RDSTestRec<RDS_TEST_REACTOR_TYPE$> = ReactorType
|
|
|
|
IF ReactorType = 'P' OR ReactorType = 'EPP' OR ThickFilmMet = 1 THEN
|
|
|
|
SpecMap = XLATE('PROD_SPEC',PSNId,PROD_SPEC_TEST_POINT_MAP$,'X') ;* Added 4/8/2009 JCH new field in PROD_SPEC
|
|
|
|
IF SpecMap NE '' THEN
|
|
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = SpecMap
|
|
|
|
END ELSE
|
|
|
|
;* Added ThickFilmMet check - 1/16/2009 JCH
|
|
|
|
AllTargetThicks = XLATE('PROD_SPEC',PSNId,'THICK_TARGET_ALL','X')
|
|
TargetCnt = COUNT(AllTargetThicks,@VM) + (AllTargetThicks NE '')
|
|
|
|
BEGIN CASE
|
|
CASE TargetCnt = 2
|
|
CombinedThick = SUM(AllTargetThicks)
|
|
|
|
CASE TargetCnt = 1 OR TargetCnt = 3
|
|
CombinedThick = AllTargetThicks[-1,'B':@VM]
|
|
|
|
END CASE
|
|
|
|
IF OCONV(CombinedThick,'MD2') > '65.0' THEN
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'FTIR_T'
|
|
END ELSE
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'FTIR'
|
|
END
|
|
END
|
|
|
|
END ELSE
|
|
RDSTestRec<RDS_TEST_TEST_POINT_MAP$> = 'ASM17' ;* 17 Point linear test pattern until PROD_SPEC is updated support other types
|
|
END
|
|
|
|
|
|
|
|
OtParms = FieldStore(OtParms,@RM,4,1,RDSTestRec)
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
*obj_Tables('UnlockRec',OtParms)
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
TestComplete:
|
|
* * * * * * *
|
|
|
|
RDSTestKey = Parms[1,@RM]
|
|
RDSTestRec = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSTestKey = '' THEN RETURN
|
|
|
|
IF RDSTestRec = '' THEN RDSTestRec = XLATE('RDS_TEST',RDSTestKey,'','X')
|
|
|
|
RDSNo = RdsTestRec<RDS_TEST_RDS_NO$>
|
|
LSId = RdsTestRec<RDS_TEST_LS_ID$>
|
|
ReactorType = RdsTestRec<RDS_TEST_REACTOR_TYPE$>
|
|
|
|
NoConversion = 1
|
|
|
|
GOSUB Resistivity ;* Calculate Resistvity values
|
|
|
|
ResReads = Result
|
|
Result = ''
|
|
|
|
SheetRhoReads = RDSTestRec<RDS_TEST_READ_SHEET_RHO$>
|
|
ThickReads = RDSTestRec<RDS_TEST_READ_THICK$>
|
|
HgCvReads = RDSTestRec<RDS_TEST_READ_HGCV1_RES$>
|
|
|
|
SpecThickMin = RDSTestRec<RDS_TEST_SPEC_THICK_MIN$>
|
|
SpecThickMax = RDSTestRec<RDS_TEST_SPEC_THICK_MAX$>
|
|
SpecThickTool = RDSTestRec<RDS_TEST_SPEC_THICK_MTOOL$>
|
|
|
|
|
|
SpecResMin = RDSTestRec<RDS_TEST_SPEC_RES_MIN$>
|
|
SpecResMax = RDSTestRec<RDS_TEST_SPEC_RES_MAX$>
|
|
SpecResTool = RDSTestRec<RDS_TEST_SPEC_RES_MTOOL$>
|
|
|
|
SpecResUnits = RDSTestRec<RDS_TEST_SPEC_RES_UNITS$>
|
|
|
|
ReadLineCnt = COUNT(ThickReads,@VM) + (ThickReads NE '')
|
|
|
|
ThickCompFlag = 0
|
|
SheetRhoCompFlag = 0
|
|
ResistivityCompFlag = 0
|
|
HgCvCompFlag = 0
|
|
|
|
FOR I = 1 TO ReadLineCnt
|
|
ThickVal = ThickReads<1,I>
|
|
IF ThickVal NE '' OR SpecThickTool = 'SRP' THEN
|
|
ThickCompFlag = 1
|
|
END
|
|
|
|
IF SpecResUnits = SHEETRHO_SPEC_UNITS$ THEN
|
|
ResVal = SheetRhoReads<1,I>
|
|
IF ResVal NE '' THEN
|
|
SheetRhoCompFlag = 1
|
|
END
|
|
END
|
|
|
|
IF SpecResUnits = RES_SPEC_UNITS$ THEN
|
|
ResVal = ResReads<1,I>
|
|
IF ResVal = 0 THEN ResVal = ''
|
|
IF ResVal NE '' THEN
|
|
ResistivityCompFlag = 1
|
|
END
|
|
|
|
HgCvVal = HgCvReads<1,I>
|
|
IF HgCvVal NE '' THEN
|
|
HgCvCompFlag = 1
|
|
END
|
|
END
|
|
|
|
NEXT I
|
|
|
|
IF SpecResTool = 'SRP' THEN
|
|
SheetRhoCompFlag = 1
|
|
ResistivityCompFlag = 1
|
|
END
|
|
|
|
ReadingsComp = 0
|
|
|
|
BEGIN CASE
|
|
CASE SpecResUnits = SHEETRHO_SPEC_UNITS$
|
|
|
|
IF ThickCompFlag = 1 AND SheetRhoCompFlag = 1 THEN
|
|
ReadingsComp = 1
|
|
END
|
|
|
|
CASE SpecResUnits = RES_SPEC_UNITS$
|
|
|
|
IF ThickCompFlag = 1 AND ( HgCvCompFlag = 1 OR ResistivityCompFlag = 1) THEN
|
|
ReadingsComp = 1
|
|
END
|
|
|
|
CASE 1
|
|
NULL
|
|
|
|
END CASE
|
|
|
|
|
|
GOSUB TWSignedOff
|
|
|
|
TWCompFlag = Result
|
|
Result = ''
|
|
|
|
IF SpecResUnits NE '' THEN
|
|
IF ReadingsComp = 1 AND TWCompFlag = 1 THEN
|
|
Result = 1
|
|
END ELSE
|
|
Result = 0
|
|
END
|
|
END ELSE
|
|
Result = TWCompFlag
|
|
END
|
|
RETURN Result
|
|
|
|
|
|
* * * * * * *
|
|
TestPropKeys:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
|
|
IF MetNo = '' THEN RETURN
|
|
|
|
OPEN 'DICT.RDS_TEST_PROP' TO DictVar ELSE RETURN
|
|
|
|
Btree.Extract('MET_NO':@VM:MetNo:@FM, 'RDS_TEST_PROP', DictVar, TestPropKeys, '', '')
|
|
|
|
SortedProps = obj_Popup('AllCodes','MET_PROPERTY':@RM:2) ;* All Met Prop codes in the MET_PROPERTY popup
|
|
|
|
tpCnt = COUNT(TestPropKeys,@VM) + (TestPropKeys NE '')
|
|
|
|
SortedKeys = ''
|
|
|
|
FOR I = 1 TO tpCnt
|
|
TestPropKey = TestPropKeys<1,I>
|
|
TestProp = FIELD(TestPropKey,'*',2)
|
|
LOCATE TestProp IN SortedProps USING @VM SETTING Pos THEN
|
|
SortedKeys = INSERT(SortedKeys,1,Pos,0,TestPropKey)
|
|
END
|
|
NEXT I
|
|
|
|
|
|
CONVERT @VM TO ' ' IN SortedKeys
|
|
SortedKeys = TRIM(SortedKeys)
|
|
CONVERT ' ' TO @VM IN SortedKeys
|
|
|
|
Result = SortedKeys
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
PushProps:
|
|
* * * * * * *
|
|
|
|
MetNo = Parms[1,@RM]
|
|
|
|
IF MetNo = '' THEN RETURN
|
|
|
|
MetRec = XLATE('RDS_TEST',MetNo,'','X')
|
|
|
|
IF MetRec = '' THEN RETURN
|
|
|
|
RETURN
|
|
|
|
|
|
IF MetRec<RDS_TEST_SPEC_THICK_MIN$> NE '' THEN
|
|
|
|
IF MetRec<RDS_TEST_SPEC_THICK_UNITS$> = UNIT$THICK THEN
|
|
Prop = 'THICK'
|
|
END ELSE
|
|
Prop = 'THICKA'
|
|
|
|
|
|
END
|
|
|
|
MetPropKey = MetNo:'*':Prop
|
|
|
|
MetPropRec = ''
|
|
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MIN$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_THICK_MIN$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MAX$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_THICK_MAX$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_TARGET$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_THICK_TARGET$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_UNITS$> = MetRec<RDS_TEST_SPEC_THICK_UNITS$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTOOL$> = MetRec<RDS_TEST_SPEC_THICK_MTOOL$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTYPE$> = MetRec<RDS_TEST_SPEC_THICK_MTYPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MRECIPE$> = MetRec<RDS_TEST_SPEC_THICK_MRECIPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFREQ$> = MetRec<RDS_TEST_SPEC_THICK_MFREQ$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPROVEIN$> = MetRec<RDS_TEST_SPEC_THICK_MPROVEIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFIRST$ > = MetRec<RDS_TEST_SPEC_THICK_MFIRST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MLAST$> = MetRec<RDS_TEST_SPEC_THICK_MLAST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MSPC$> = MetRec<RDS_TEST_SPEC_THICK_MSPC$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MOVERGROW$> = MetRec<RDS_TEST_SPEC_THICK_MOVERGROW$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPATTERN$> = MetRec<RDS_TEST_SPEC_THICK_MPATTERN$>
|
|
MetPropRec<RDS_TEST_PROP_READING$> = ICONV(OCONV(MetRec<RDS_TEST_READ_THICK$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
|
|
OtParms = 'RDS_TEST_PROP':@RM:MetPropKey:@RM:@RM:MetPropRec
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
END ;* End of Thickness Property
|
|
|
|
|
|
IF MetRec<RDS_TEST_SPEC_RES_MIN$> NE '' THEN
|
|
|
|
Prop = ''
|
|
|
|
IF MetRec<RDS_TEST_SPEC_RES_UNITS$> = UNIT$RES THEN
|
|
Prop = 'RES'
|
|
END
|
|
|
|
IF MetRec<RDS_TEST_SPEC_RES_UNITS$> = UNIT$SRES THEN
|
|
Prop = 'SRES'
|
|
END
|
|
|
|
|
|
MetPropKey = MetNo:'*':Prop
|
|
MetPropRec = ''
|
|
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MIN$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_RES_MIN$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MAX$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_RES_MAX$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_TARGET$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_RES_TARGET$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_UNITS$> = MetRec<RDS_TEST_SPEC_RES_UNITS$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTOOL$> = MetRec<RDS_TEST_SPEC_RES_MTOOL$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTYPE$> = MetRec<RDS_TEST_SPEC_RES_MTYPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MRECIPE$> = MetRec<RDS_TEST_SPEC_RES_MRECIPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFREQ$> = MetRec<RDS_TEST_SPEC_RES_MFREQ$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPROVEIN$> = MetRec<RDS_TEST_SPEC_RES_MPROVEIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFIRST$ > = MetRec<RDS_TEST_SPEC_RES_MFIRST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MLAST$> = MetRec<RDS_TEST_SPEC_RES_MLAST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MSPC$> = MetRec<RDS_TEST_SPEC_RES_MSPC$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MOVERGROW$> = MetRec<RDS_TEST_SPEC_RES_MOVERGROW$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPATTERN$> = MetRec<RDS_TEST_SPEC_RES_MPATTERN$>
|
|
|
|
IF Prop = 'RES' THEN
|
|
MetPropRec<RDS_TEST_PROP_READING$> = ICONV(OCONV(MetRec<RDS_TEST_READ_SHEET_RHO$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
END ELSE
|
|
MetPropRec<RDS_TEST_PROP_READING$> = ICONV(OCONV(MetRec<RDS_TEST_READ_RES$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
END
|
|
|
|
|
|
OtParms = 'RDS_TEST_PROP':@RM:MetPropKey:@RM:@RM:MetPropRec
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
END ;* End of RES or SRES Property
|
|
|
|
|
|
IF MetRec<RDS_TEST_SPEC_CRES_MIN$> NE '' THEN
|
|
|
|
Prop = 'CRES'
|
|
|
|
MetPropKey = MetNo:'*':Prop
|
|
|
|
MetPropRec = ''
|
|
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MIN$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CRES_MIN$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MAX$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CRES_MAX$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_TARGET$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CRES_TARGET$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_UNITS$> = MetRec<RDS_TEST_SPEC_CRES_UNITS$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTOOL$> = MetRec<RDS_TEST_SPEC_CRES_MTOOL$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTYPE$> = MetRec<RDS_TEST_SPEC_CRES_MTYPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MRECIPE$> = MetRec<RDS_TEST_SPEC_CRES_MRECIPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFREQ$> = MetRec<RDS_TEST_SPEC_CRES_MFREQ$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPROVEIN$> = MetRec<RDS_TEST_SPEC_CRES_MPROVEIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFIRST$ > = MetRec<RDS_TEST_SPEC_CRES_MFIRST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MLAST$> = MetRec<RDS_TEST_SPEC_CRES_MLAST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MSPC$> = MetRec<RDS_TEST_SPEC_CRES_MSPC$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MOVERGROW$> = MetRec<RDS_TEST_SPEC_CRES_MOVERGROW$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPATTERN$> = MetRec<RDS_TEST_SPEC_CRES_MPATTERN$>
|
|
MetPropRec<RDS_TEST_PROP_READING$> = ICONV(OCONV(MetRec<RDS_TEST_READ_HGCV1_RES$>,'MD3'),'[MET_PROP_CONV,':Prop:']')
|
|
|
|
OtParms = 'RDS_TEST_PROP':@RM:MetPropKey:@RM:@RM:MetPropRec
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
END ;* End of CRES or HgCv Resistivity Property
|
|
|
|
|
|
|
|
IF MetRec<RDS_TEST_SPEC_CON_MIN$> NE '' OR MetRec<RDS_TEST_SPEC_CON_MTOOL$> NE '' THEN
|
|
|
|
Prop = 'CONC'
|
|
|
|
MetPropKey = MetNo:'*':Prop
|
|
|
|
MetPropRec = ''
|
|
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MIN$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CON_MIN$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MAX$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CON_MAX$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_TARGET$> = ICONV(OCONV(MetRec<RDS_TEST_SPEC_CON_TARGET$>,'MD2'),'[MET_PROP_CONV,':Prop:']')
|
|
MetPropRec<RDS_TEST_PROP_SPEC_UNITS$> = MetRec<RDS_TEST_SPEC_CON_UNITS$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTOOL$> = MetRec<RDS_TEST_SPEC_CON_MTOOL$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTYPE$> = MetRec<RDS_TEST_SPEC_CON_MTYPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MRECIPE$> = MetRec<RDS_TEST_SPEC_CON_MRECIPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFREQ$> = MetRec<RDS_TEST_SPEC_CON_MFREQ$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPROVEIN$> = MetRec<RDS_TEST_SPEC_CON_MPROVEIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFIRST$ > = MetRec<RDS_TEST_SPEC_CON_MFIRST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MLAST$> = MetRec<RDS_TEST_SPEC_CON_MLAST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MSPC$> = MetRec<RDS_TEST_SPEC_CON_MSPC$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MOVERGROW$> = MetRec<RDS_TEST_SPEC_CON_MOVERGROW$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPATTERN$> = MetRec<RDS_TEST_SPEC_CON_MPATTERN$>
|
|
|
|
OtParms = 'RDS_TEST_PROP':@RM:MetPropKey:@RM:@RM:MetPropRec
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
END ;* End of Concentration Property
|
|
|
|
|
|
IF MetRec<RDS_TEST_SPEC_STRESS_MIN$> NE '' OR MetRec<RDS_TEST_SPEC_STRESS_MTOOL$> NE '' THEN
|
|
|
|
Prop = 'STRESS'
|
|
|
|
MetPropKey = MetNo:'*':Prop
|
|
|
|
MetPropRec = ''
|
|
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MIN$> = MetRec<RDS_TEST_SPEC_STRESS_MIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MAX$> = MetRec<RDS_TEST_SPEC_STRESS_MAX$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_TARGET$> = MetRec<RDS_TEST_SPEC_STRESS_TARGET$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_UNITS$> = MetRec<RDS_TEST_SPEC_STRESS_UNITS$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTOOL$> = MetRec<RDS_TEST_SPEC_STRESS_MTOOL$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MTYPE$> = MetRec<RDS_TEST_SPEC_STRESS_MTYPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MRECIPE$> = MetRec<RDS_TEST_SPEC_STRESS_MRECIPE$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFREQ$> = MetRec<RDS_TEST_SPEC_STRESS_MFREQ$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPROVEIN$> = MetRec<RDS_TEST_SPEC_STRESS_MPROVEIN$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MFIRST$ > = MetRec<RDS_TEST_SPEC_STRESS_MFIRST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MLAST$> = MetRec<RDS_TEST_SPEC_STRESS_MLAST$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MSPC$> = MetRec<RDS_TEST_SPEC_STRESS_MSPC$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MOVERGROW$> = MetRec<RDS_TEST_SPEC_STRESS_MOVERGROW$>
|
|
MetPropRec<RDS_TEST_PROP_SPEC_MPATTERN$> = MetRec<RDS_TEST_SPEC_STRESS_MPATTERN$>
|
|
|
|
OtParms = 'RDS_TEST_PROP':@RM:MetPropKey:@RM:@RM:MetPropRec
|
|
obj_Tables('WriteRec',OtParms)
|
|
|
|
END ;* End of STRESS Property
|
|
|
|
|
|
RETURN
|