87d79edef8
Fixed min row limit issue causing cells to be colored incorrectly. Fixed sheet rho units in rds test modules
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 \EA2FDC\
|
|
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
|