Escribir límites en una tabla de datos desde una tabla de límitesEste complemento JMP toma límites de especificación y cualquiera de los 23 tipos diferentes de límites de control (es decir, XBar, S, rango móvil, etc.) que se encuentran en una tabla de datos separada (lo llamo tabla de límites) y completa los límites apropiados propiedades de columna en una tabla de datos JMP.
Como se indicó anteriormente, la "Tabla de límites" es solo una tabla JMP.Para ser una tabla de límites válida, debe tener una columna que contenga los nombres de las columnas que se actualizarán, y luego una columna para cada límite específico cuyos valores se moverán a las propiedades de la columna de su tabla que tiene sus datos de medición. .A continuación se muestra un ejemplo de cómo se vería una tabla de límites.Nota: los nombres de las columnas no tienen que tener nombres específicos.Como se verá, las columnas que se utilizarán para las diferentes partes de la especificación y los límites de control se mapearán en una ventana de diálogo.
La “Tabla de Límites” tiene 7 columnas y 128 filas.Cada fila contiene los límites para una columna específica en su tabla de datos de medición.En este ejemplo, la columna llamada "Nombres de columna" contiene los nombres de las columnas en su tabla de datos de medición que se actualizarán.Todas las columnas de la "Tabla de límites" se asignarán en el complemento, en cuanto a la función que desempeña.
La siguiente tabla de datos de medición es la tabla de datos de capacidad de semiconductores de las tablas de datos de muestra de JMP.Para este ejemplo, se eliminaron los límites de especificación que forman parte de la tabla de datos enviados.
Para ejecutar el complemento, vaya a su tabla de datos de medición y haga clic en ella para convertirla en la tabla de datos "activa" actual. Luego ejecute el complemento. La ventana que aparece solicita al usuario que seleccione la "Tabla de límites" que se usará para la actualización.
Cuando seleccione la tabla a utilizar, la ventana se ampliará con los cuadros de selección para asignar las columnas de la "Tabla de límites" al papel que desempeñará en el movimiento de los límites a la tabla de datos de medición.
Aquí es donde se lleva a cabo el mapeo.El primer elemento a mapear, es identificar la columna en la "Tabla de Límites" que se usará como el Identificador de qué columnas actualizar.En nuestro ejemplo, la columna "Nombres de columna" contiene esta información y debe colocarse en el cuadro de selección Columna de ID.
A continuación, asignamos las columnas de límite al tipo de límite y si es el límite superior, objetivo o inferior para el límite especificado..Los límites de especificación y los límites de control se manejan por separado.Hay un botón de radio que debe establecerse en Límites de especificación o Límites de control, para que coincida con el tipo de límite que está mapeando.Para empezar, configuraremos los límites de especificación.En la "Tabla" de límites, las columnas denominadas LSL, Objetivo y USL contienen límites de especificación.Para mapearlos, simplemente seleccione cada uno y muévalo al cuadro de selección de límite apropiado.
Las columnas XBar LCL, XBar Target y XBar UCL contienen límites de control.Específicamente contienen límites de control XBar.Para asignarlos al complemento, primero se establece el botón de radio en "Límites de control".
El entorno de mapeo cambia ligeramente.Agregado a la pantalla, hay un cuadro de flecha hacia abajo, que permite establecer qué tipo de límite de control desea asignar.
El tipo de límite de control que está en la "Tabla de límites" son límites XBar, por lo que ese es el tipo de límite de control que seleccionamos.Luego solo mapeamos las columnas a las tiradas de límite que cada una de ellas juega
Si hubiera más tipos de límites de control en la "Tabla de límites", uno simplemente repetiría los pasos de seleccionar el tipo de límite que desea mapear y luego colocaría las columnas apropiadas en el cuadro de selección que representa el tipo de límite que es.
Cuando haya terminado con la asignación, simplemente haga clic en "Aceptar" para ejecutar el complemento.Cuando se complete, puede validar que ha tenido éxito yendo a la tabla de datos de medición y revisando las propiedades de la columna de límites
Ingeniería de calidadRe: Escribir límites a una tabla de datos desde una tabla de límites@txnelson ¡¡Muchas gracias por tu ayuda!!
¡El guión anterior funciona bien!
Re: Escribir límites a una tabla de datos desde una tabla de límitesJSL no deja de procesar un script solo porque se ha mostrado una ventana.Por lo tanto, a medida que se muestra la ventana, se ejecuta el generador de gráficos "Biv6".Debe cambiar el código del cuadro de diálogo de entrada para indicarle que ejecute el código "Biv6" al final del código que agrega los límites de especificación.
Si cambia el código de Graph Builder para que se encapsule en una función Expr(), no se ejecutará hasta que se ejecute Expr().
myGraphBuilder = Expr(
biv6 = Graph Builder(
Variables( X( :PPO_26_H ) ),
Show Control Panel( 0 ),
Elements( Histogram( X, Legend( 4 ) ), Box Plot( X, Legend( 6 ) ) ),
SendToReport(
Dispatch( {}, "PPO_26_H", ScaleBox, {Label Row( Set Font Size( 16 ) )} ),
Dispatch( {}, "graph title", TextEditBox, {Set Font Size( 24 )} )
)
);
biv6 << save picture( "c:\temp\biv6.png" );
);
Entonces, ahora solo tiene que decidir cuándo hacer que el cuadro de diálogo ejecute el Generador de gráficos.Mi sugerencia es colocarlo en el script "OK" del cuadro de botón, justo después de la ejecución de "runit" Expr().
Button Box( "OK",
WriteLimitColNames( LimitNum );
lowconcat = highconcat = "";
For( i = 1, i <= N Items( LowList ), i++,
lowconcat = lowconcat || LowList[i];
highconcat = highconcat || HighList[i];
);
LimitsChoosen = Length( lowconcat || highconcat ) > 0;
// Check to see if the required data has been input
If(
N Items( colListY << GetItems ) == 0, Dialog( "No ID Column Specified", Button( "OK" ) ), // Else
LimitsChoosen == 0, Dialog( "No Limit Columns Specified", Button( "OK" ) ), // Else
RecallList = {lowlist = {}, avglist = {}, highlist = {}};
RecallList["lowlist"] = lowlist;
RecallList["avglist"] = avglist;
RecallList["highlist"] = highlist;
// Place the selected values from the screen into the recall list
Insert Into( RecallList, Parse( "IDColumn = \!"" || Char( (colListY << get items)[1] ) || "\!"" ) );
If( IgnoreCB << get == 1,
IgnoreMissing = "Yes",
IgnoreMissing = "No"
);
ShowLims = ShowCB << get;
ShowRpt = ReportCB << get;
Insert Into( RecallList, Parse( "IgnoreMissing = \!"" || IgnoreMissing || "\!"" ) );
Insert Into( RecallList, Parse( "ShowLims = " || Char( showlims ) ) );
Insert Into( RecallList, Parse( "ShowRpt = " || Char( showRpt ) ) );
// Save recall string to Recall namespace
Recall:WriteLimits = RecallList;
nw << CloseWindow;
dtReport = New Table( "Report",
Private,
New Column( "Column", Character, "Nominal" ),
New Column( "Limit Type", Character, "Nominal" ),
New Column( "Level",
Character,
"Nominal",
Set Property( "Value Ordering", {"Lower", "Average", "Upper"} )
),
New Column( "Value", Numeric, "Continuous", Format( "Best", 10 ) ),
New Column( "Limit",
Character,
"Nominal",
Set Property( "Value Ordering", {"Spec Limit", "Control Limit"} )
),
New Column( "OldNew", Character, "Nominal", Set Property( "Value Ordering", {"Previous", "New"} ) )
);
dtReport:Column << set property( "Row Order Levels", 1 );
// Create a working copy of the limits table
dtLimits << Select Rows( NotFoundListRowNumbers );
dtLimits << invert row selection;
dtLimitsTemp = dtLimits << subset(invisible, selected rows(1), selected columns(0));
dtLimits << clear select;
dtOriginalLimits = dtLimits;
dtLimits = dtLimitsTemp;
wait(0);
// Run the actual code that updates the limits
runit;
myGraphBuilder;
);
),
Re: Escribir límites a una tabla de datos desde una tabla de límites¡Creador de gráficos y guarda la imagen!
Me gustaría que Graph buider guarde en la imagen después de la especificación pero no El siguiente script genera una imagen antes de que se aplique la especificación.
Open("C:\Users\A07\Desktop\data\Working data\Jump\spec_limit.jmp");
dt = open();
Names Default To Here( 1 );
Clear Symbols();
/*****************************************************************************/
/* */
/* This is the inital piece of code to be run in the script */
/* It initializes the environment and opens the initial user inptut dialog */
/* */
/*****************************************************************************/
Main = Expr(
dt = Current Data Table();
LastColListY = "";
// The recall values are saved into a namespace called "Recall"
// and if it currently doesn't exist, set it up
If( Namespace Exists( "Recall" ) == 0,
recall = New Namespace(
"Recall"
)
);
// Get a list of all of the numeric columns in the data table
AllNumericColumns = dt << get column names( numeric, string );
AllNumericColumnsCompressed = AllNumericColumns;
// Uppercase and compress the column names
For( i = 1, i <= N Items( AllNumericColumns ), i++,
AllNumericColumnsCompressed[i] = Uppercase( AllNumericColumnsCompressed[i] );
While( Pat Match( AllNumericColumnsCompressed[i], " ", "" ) > 0, Pat Match( AllNumericColumnsCompressed[i], " ", "" ) );
);
// This iist is the list of the names used within JMP Contol Limits and is used by the script
// to set the type of contol limit being updated
ControlLimitList = {"XBar", "R", "S", "Individual Measurement", "Moving Range", "Median Moving Range", "P", "NP", "C", "U", "UWMA", "EWMA",
"CUSUM", "Levey Jennings", "Individual on Group Means", "Individual on Group Std Devs", "Moving Range on Group Means",
"Moving Range on Group Stds", "Median Moving Range on Group Means", "Median Moving Range on Group Std Devs", "Run Chart", "G", "T"};
// Variale used to set the length of the column selection list
nc = N Col( dt );
lbWidth = 160;
// Create a list of all of the open tables
list_tables = {};
For( i = 1, i <= N Table(), i++,
Insert Into( list_tables, Data Table( i ) << get name )
);
// Display the Limits Table Selection window
nw = New Window( "Populate Limits",
V List Box(
Spacer Box( size( 1, 5 ) ),
H List Box( IconBB = Button Box( "" ), IconTB = Text Box( "Populate Limits Column Property from a separate table" ) ),
Spacer Box( size( 1, 20 ) ),
TheHlB = H List Box(
V List Box(
Text Box( "Select Limits Table" ),
Spacer Box( size( 1, 2 ) ),
Panel Box( "Set Limits in " || Char( dt << get name ) || " with",
TableLB = List Box( list_tables, n lines( 6 ), width( 220 ) ),
)
)
),
Spacer Box( size( 1, 10 ) ),
H List Box(
Spacer Box( size( 10, 1 ) ),
createtableBB = Button Box( "Create Limits Table from Current Active Data Table", createlimitstable )
),
Spacer Box( size( 1, 10 ) )
),
// When the user selection for the limits data table changes, reset the column dialog boxes
TableLB << on change(
// Delete the button box
Try( createtableBb << delete );
// Blank out the low,avg and high lists
resetlists;
// Delete the current column dialog boxes
Try( clusterdlg << delete );
// If the user has selected a new limits table, reset the window
If( Try( (tablelb << get selected)[1], "" ) != "",
dtlimits = Data Table( (tablelb << get selected)[1] );
Current Data Table( dtlimits );
// Reinput the code for the column dialog boxes....this is
// required, because the col list boxes do not lose the data
// table references without totally deleting the col list box
// and bringing in new instances
clusterexpr;
// Add the col dialog boxes to the current display
theHLB << append( clusterdlg );
// Reset required lists
AllLimitColList = AllLimitColListCompressed = {};
Try( AllLimitColList = Column( dtlimits, Column Names ) << get values );
AllLimitColListCompressed = AllLimitColList;
// Uppercase and remove blanks from the column list
For( i = 1, i <= N Items( AllLimitColList ), i++,
AllLimitColListCompressed[i] = Uppercase( AllLimitColListCompressed[i] );
While( Pat Match( AllLimitColListCompressed[i], " ", "" ) > 0, Pat Match( AllLimitColListCompressed[i], " ", "" ) );
);
);
),
// Set the icon
iconbb << set icon( "Update" )
);
);
/*****************************************************************************/
/* */
/* Create a Limits Table populating limits from the current data table */
/* */
/*****************************************************************************/
CreateLimitsTable = Expr(
HasBeenSeen = Repeat( 0, 24 );
dtnew = New Table( "Limits Table", invisible, New Column( "Column Names", character, values( AllNumericColumns ) ) );
// Pass through all of the specified parameters and extract any limits found in the
// active data table and move them to the new limits data table
For( allvars = 1, allvars <= N Items( AllNumericColumns ), allvars++,
col = Parse( "dt:" || AllNumericColumns[allvars] );
// Gather in the already set Control and Spec Limits
controls = col << get property( "Control Limits" );
specs = col << get property( "Spec Limits" );
// Process Spec Limits
If( !(Char( specs ) == "Scriptable[]" | Is Empty( specs ) == 1),
If( HasBeenSeen[24] == 0,
dtnew << New Column( "LSL" );
dtnew << New Column( "Target" );
dtnew << New Column( "USL" );
HasBeenSeen[24] = 1;
);
For( i = 1, i <= N Items( specs ), i++,
If( Is Missing( Try( Specs["LSL"], . ) ) == 0,
dtnew:LSL[AllVars] = Specs["LSL"]
);
If( Is Missing( Try( Specs["Target"], . ) ) == 0,
dtnew:Target[AllVars] = Specs["Target"]
);
If( Is Missing( Try( Specs["LSL"], . ) ) == 0,
dtnew:USL[AllVars] = Specs["USL"]
);
);
);
// All of the Control limits have the same structure. This code extracts all of the different
// types of control limits and moves them to the limits table
If( !(Char( controls ) == "Scriptable[]" | Is Empty( controls ) == 1),
For( i = 1, i <= N Items( controls ), i++,
If( Contains( ControlLimitList, Trim( Word( 1, Char( controls[i] ), "(,)" ) ) ) > 0,
Control Limit Type = Trim( Word( 1, Char( controls[i] ), "(,)" ) );
LimitListNumber = Contains( ControlLimitList, Trim( Word( 1, Char( controls[i] ), "(,)" ) ) );
If( HasBeenSeen[LimitListNumber] == 0,
dtnew << New Column( ControlLimitList[LimitListNumber] || "LCL" );
dtnew << New Column( ControlLimitList[LimitListNumber] || "AVG" );
dtnew << New Column( ControlLimitList[LimitListNumber] || "UCL" );
HasBeenSeen[LimitListNumber] = 1;
);
For( ctype = 2, ctype <= 6, ctype = ctype + 2,
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "Avg",
Column( dtnew, ControlLimitList[LimitListNumber] || "AVG" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "LCL",
Column( dtnew, ControlLimitList[LimitListNumber] || "LCL" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "UCL",
Column( dtnew, ControlLimitList[LimitListNumber] || "UCL" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
);
)
);
);
);
If( N Cols( dtnew ) == 1,
dtnew << New Column( "LSL" );
dtnew << New Column( "Target" );
dtnew << New Column( "USL" );
dtnew << New Column( "XBarLCL" );
dtnew << New Column( "XBarAVG" );
dtnew << New Column( "XBarUCL" );
);
Insert Into( List_Tables, "Limits Table" );
x = List_Tables;
TableLB << RemoveAll;
TableLB << append( list_tables );
dtnew << zoom window;
);
/*****************************************************************************/
/* */
/* Blank out all selections and reset to the current limit */
/* */
/*****************************************************************************/
resetLists = Expr(
lowList = avgList = highList = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""};
If( Try( LimitTypeRB << get, 1 ) == 1,
limitNum = 24,
LimitNum = cb << get
);
);
// Initialize the lists
ResetLists;
/*****************************************************************************/
/* */
/* Set the Control Limits for all specified control limits for a single */
/* row from the limits data table */
/* */
/*****************************************************************************/
SetControlLimits = Function( {c, CList, IgnoreMissing, i},
{c, CList, IgnoreMissing},
// Big List pulls in any existing limit control values. This allows for the addition of
// replacement of limit values without erasing any limits that currently exist.
c = AllNumericColumns[Contains( AllnumericColumnsCompressed, AllLimitColListCompressed[i] )];
biglist = Column( dt, c ) << getproperty( "control limits" );
// Roll across all of the types of contol limits found
For( cl = 1, cl <= N Items( CList ), cl++,
little = {__type__( Avg( avexpr ), UCL( ULexpr ), LCL( LLexpr ) )};
Substitute Into( little, Expr( __type__ ), Parse( controllimitnamesList[CList[cl]] ) );
// Get the new limits to be processed from the limits table
// If no column has been specified for one of the limits, a
// missing value is set
lcl = Try( Column( dtlimits, lowlist[CList[cl]] )[i], . );
tar = Try( Column( dtlimits, avglist[CList[cl]] )[i], . );
ucl = Try( Column( dtlimits, highlist[CList[cl]] )[i], . );
// If Control Limits were found interrogate them
If( Is Empty( biglist ) == 0,
For( _i_ = N Items( big list ), _i_ >= 1, _i_--,
If( Uppercase( Word( 1, biglist[_i_], "(" ) ) == Uppercase( controllimitnamesList[CList[cl]] ),
onelist = Char( biglist[_i_] );
xlcl = .;
xtarget = .;
xucl = .;
For( limitcnt = 2, limitcnt <= 7, limitcnt = limitcnt + 2,
alimit = Word( limitcnt, onelist, "(,)" );
If(
Contains( alimit, "LCL" ) > 0, xlcl = Num( Word( limitcnt + 1, onelist, "(,)" ) ),
Contains( alimit, "Avg" ) > 0, xtarget = Num( Word( limitcnt + 1, onelist, "(,)" ) ),
Contains( alimit, "UCL" ) > 0, xucl = Num( Word( limitcnt + 1, onelist, "(,)" ) )
);
);
Remove From( biglist, _i_ );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xtarget;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
);
// If the limits do not currently exist, but other control limits are there,
// insert the new control limits into the large control limit list
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) > 0,
// If Missing values from the limits table are to signal not to
// change the current limit, then process them accoringly
If( IgnoreMissing == "No",
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little, Expr( LLexpr ), Eval( xlcl ) );
lcl = xlcl;
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
);
,
If( Is Missing( lcl ) == 1 | LowList[CList[cl]] == "",
Substitute Into( little, Expr( LLexpr ), Eval( xlcl ) );
lcl = xcl;
,
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) )
);
If( Is Missing( ucl ) == 1 | HighList[CList[cl]] == "",
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
,
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) )
);
If( Is Missing( tar ) == 1 | AvgList[CList[cl]] == "",
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
,
Substitute Into( little, Expr( avexpr ), Eval( tar ) )
);
)
,
// Just add the new limits if not concerned about preserving data
// and replacing limits if missing values have been specified
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) < 3,
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little,
Expr( LLexpr ),
Eval( xlcl );
lcl = xlcl;
)
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
);
)
);
// If the big list doesn't exist, create it
If( Is Empty( biglist ) == 1,
biglist = {}
);
// Add the current limit type to the overall list of control limits
Insert Into( biglist, little );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = tar;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = ucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
)
,
// No control limits currently exist for the target column, so create the large
// control limit list by setting it equal to the new input limits
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = .;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = .;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = .;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) < 3,
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little, Expr( LLexpr ), Eval( . ) );
lcl = .;
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( . ) );
tar = .;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( . ) );
ucl = .;
);
);
// If the big list doesn't exist, create it
If( Is Empty( biglist ) == 1,
biglist = {}
);
// Add the current limit type to the overall list of control limits
Insert Into( biglist, little );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = tar;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = ucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
)
;
);
If( Char( biglist ) != "Scriptable[]" & Is Empty( biglist ) == 0 & biglist != {},
Column( dt, c ) << setproperty( "control limits", Eval( biglist ) )
);
);
/*****************************************************************************/
/* */
/* Set the Spec Limits for all specified control limits for a single */
/* row from the limits data table */
/* */
/*****************************************************************************/
SetSpecLimits = Function( {c, lsl, usl, avg, IgnoreMissing, showlims},
{c, lsl, usl, avg, IgnoreMissing, showlims},
// Get the current spec limits
Try( speclist = Column( dt, c ) << get property( "spec limits" ), {} );
Try( xlsl = speclist["LSL"], xlsl = . );
Try( xusl = speclist["USL"], xusl = . );
Try( xavg = speclist["Target"], xavg = . );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xavg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xusl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
// Process the limits
If( Is Missing( lsl ) + Is Missing( avg ) + Is Missing( usl ) < 3,
// If misssing value input is to be Ignored, that means that
// old values of the limits are to be moved forward if the new
// input values are missing values
If( IgnoreMissing == "Yes",
If( (Is Missing( xusl ) == 1 & Is Missing( usl ) == 0) | HighList[24] != "",
xusl = usl
);
If( (Is Missing( xlsl ) == 1 & Is Missing( lsl ) == 0) | LowList[24] != "",
xlsl = lsl
);
If( (Is Missing( xavg ) == 1 & Is Missing( avg ) == 0) | AvgList[24] != "",
xavg = avg
);
cmd = Expr(
Column( dt, c ) << SetProperty(
"Spec LImits",
{LSL( Expr( xlsl ) ), USL( Expr( xusl ) ), Target( Expr( xavg ) ), Show Limits( Expr( showlims ) )}
)
);
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xavg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xusl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
, // Else
If( LowList[24] == "",
lsl = xlsl
);
If( AvgList[24] == "",
avg = xavg
);
If( HighList[24] == "",
usl = xusl
);
cmd = Expr(
Column( dt, c ) << SetProperty(
"Spec LImits",
{LSL( Expr( lsl ) ), USL( Expr( usl ) ), Target( Expr( avg ) ), Show Limits( Expr( showlims ) )}
)
);
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = avg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = usl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
);
Eval( Eval Expr( cmd ) );
);
);
/*****************************************************************************/
/* */
/* Run through each of the columns in the limits table and call the functions*/
/* that update the limits, based upon what limits have been specified in the */
/* dialog input screen */
/* */
/*****************************************************************************/
runit = Expr(
ControlLimitNamesList = {"XBar", "R", "S", "Individual Measurement", "Moving Range", "Median Moving Range", "P", "NP", "C", "U", "UWMA", "EWMA",
"CUMSUM", "Levey Jennings", "Individual on Group Means", "Individual on Group Std Devs", "Moving Range on Group Means",
"Moving Range on Group Std Devs", "Median Moving Range on Group Means", "Median Moving Range on Group Std Devs", "Run Chart", "G", "T"};
// Create a list of which control limits have been specified
CList = {};
For( i = 1, i <= 23, i++,
If( LowList[i] || avgList[i] || highList[i] != "",
Insert Into( CList, i )
)
);
// If spec limits have been specified, setup a similar flag to the control limits
// to use for spec limit processing
SLList = {};
If( LowList[24] || avgList[24] || highList[24] != "",
Insert Into( SLList, 24 )
);
// Get Excluded Rows in the Limits Table so they can be bypassed in processing
Excluded Rows = As List( dtLimits << get excluded rows );
// Roll across the rows in the limits table and process the new limits
For( ii = 1, ii <= N Items( AllLimitColList ), ii++,
Process = "Yes";
If( N Items( Excluded Rows ) > 0,
If( Loc( Excluded Rows, ii ) > 0,
Process = "No",
Process = "Yes"
)
);
If( Process == "Yes",
targetName = AllNumericColumns[Contains( AllnumericColumnsCompressed, AllLimitColListCompressed[ii] )];
//ii=30
// If there are spec limits to be processed, call the setspeclimits function
If( N Items( SLList ) > 0,
return = setspeclimits(
Targetname,
Try( Column( dtlimits, lowlist[24] )[ii], . ),
Try( Column( dtlimits, highlist[24] )[ii], . ),
Try( Column( dtlimits, avglist[24] )[ii], . ),
IgnoreMissing,
showLims
)
);
// If Control limit changes have been specified, call the SetControlLimits function
If( N Items( CList ) > 0,
return = SetControlLimits( TargetName, CList, IgnoreMissing, ii )
);
);
);
ShowReport;
close(dtLimits, nosave );
dtLimits = dtOriginalLimits;
current data table(dt);
);
/*****************************************************************************/
/* */
/* This is the display for the column selections where the user matches the */
/* the limit columns from the limit data table with the columns in the */
/* data table */
/* */
/*****************************************************************************/
clusterexpr = Expr(
all Columns List = dtlimits << get column names;
Current Data Table( dtlimits );
clusterDlg = V List Box(
Border Box( Left( 3 ), top( 2 ),
V List Box(
Text Box( "Select Columns to Read the Limits From" ),
H List Box(
V List Box(
// Generate the master display box for the columns in the data table
Panel Box( "Select Columns",
cldvlb = H List Box(
Popup Box(
{"Clear", filterval = "" ; thefilter << set text( "" ) ; clearit ; ,
"Numeric", filterval = "" ; thefilter << set text( "" ) ; clearit ; For( II = 1,
II <= N Items( All Columns List ), II++,
If( Column( All Columns List[II] ) << get data type != "Numeric",
colListData << set selected( II )
)
) ; colListData << remove selected ; ,
"Character", filterval = "" ; thefilter << set text( "" ) ; clearit ; For( II = 1,
II <= N Items( All Columns List ), II++,
If( Column( All Columns List[II] ) << get data type != "Character",
colListData << set selected( II )
)
) ; colListData << remove selected ; ,
"Name Contains", filterval = "" ; filtervlb << prepend(
V List Box(
thefilter = Text Edit Box( "",
<<SET width=""> 0;
// Check to see if the required data has been input
If(
N Items( colListY << GetItems ) == 0, Dialog( "No ID Column Specified", Button( "OK" ) ), // Else
LimitsChoosen == 0, Dialog( "No Limit Columns Specified", Button( "OK" ) ), // Else
RecallList = {lowlist = {}, avglist = {}, highlist = {}};
RecallList["lowlist"] = lowlist;
RecallList["avglist"] = avglist;
RecallList["highlist"] = highlist;
// Place the selected values from the screen into the recall list
Insert Into( RecallList, Parse( "IDColumn = \!"" || Char( (colListY << get items)[1] ) || "\!"" ) );
If( IgnoreCB << get == 1,
IgnoreMissing = "Yes",
IgnoreMissing = "No"
);
ShowLims = ShowCB << get;
ShowRpt = ReportCB << get;
Insert Into( RecallList, Parse( "IgnoreMissing = \!"" || IgnoreMissing || "\!"" ) );
Insert Into( RecallList, Parse( "ShowLims = " || Char( showlims ) ) );
Insert Into( RecallList, Parse( "ShowRpt = " || Char( showRpt ) ) );
// Save recall string to Recall namespace
Recall:WriteLimits = RecallList;
nw << CloseWindow;
dtReport = New Table( "Report",
Private,
New Column( "Column", Character, "Nominal" ),
New Column( "Limit Type", Character, "Nominal" ),
New Column( "Level",
Character,
"Nominal",
Set Property( "Value Ordering", {"Lower", "Average", "Upper"} )
),
New Column( "Value", Numeric, "Continuous", Format( "Best", 10 ) ),
New Column( "Limit",
Character,
"Nominal",
Set Property( "Value Ordering", {"Spec Limit", "Control Limit"} )
),
New Column( "OldNew", Character, "Nominal", Set Property( "Value Ordering", {"Previous", "New"} ) )
);
dtReport:Column << set property( "Row Order Levels", 1 );
// Create a working copy of the limits table
dtLimits << Select Rows( NotFoundListRowNumbers );
dtLimits << invert row selection;
dtLimitsTemp = dtLimits << subset(invisible, selected rows(1), selected columns(0));
dtLimits << clear select;
dtOriginalLimits = dtLimits;
dtLimits = dtLimitsTemp;
wait(0);
// Run the actual code that updates the limits
runit;
);
),
Button Box( "Cancel",
clusterDlg << CloseWindow;
Names Default To Here( 1 );
),
Text Box( " " ),
Button Box( "Remove",
colListY << RemoveSelected;
collower << remove selected;
colaverage << remove selected;
colupper << remove selected;
),
Button Box( "Recall",
If( Is List( Recall:WriteLimits ) == 1,
Eval List( Recall:WriteLimits );
If( Try( (colListY << get items)[1], "" ) != IDcolumn,
colListY << RemoveAll;
colListY << append( IDcolumn );
);
If( IgnoreMissing == "Yes",
IgnoreCB << set( 1 ),
IgnoreCB << set( 0 )
);
ShowCB << set( ShowLims );
ReportCB << set( ShowRpt );
readLimitColNames( LimitNum );
)
),
Button Box( "Help", notImplemented )
)
)
),
)
)
),
// Set the default values for the check box options
IgnoreCB << set( 1 );
IgnoreMissing = "Yes";
ShowCB << set( 1 );
ShowLims = 1;
ReportCB << set( 1 );
ShowRpt = 1;
);
// Write the names to the Limit Lists ffrom the display window
WriteLimitColNames = Function( {lNum},
LowList[LNum] = Try( (colLower << get items)[1], "" );
AvgList[LNum] = Try( (colAverage << get items)[1], "" );
HighList[LNum] = Try( (colUpper << get items)[1], "" );
);
// Read the limit values from the Limit Lists and populate
// the display window with the values
ReadLimitColNames = Function( {lNum},
{lNum},
tmplist = lowlist;
ColLower << remove all;
lowlist = tmplist;
tmplist = {};
Insert Into( tmplist, lowlist[lnum] );
collower << append( tmplist );
tmplist = avglist;
ColAverage << remove all;
avglist = tmplist;
tmplist = {};
Insert Into( tmplist, avglist[lnum] );
colAverage << append( tmplist );
tmplist = Highlist;
ColUpper << remove all;
Highlist = tmplist;
tmplist = {};
Insert Into( tmplist, Highlist[lnum] );
ColUpper << append( tmplist );
);
// When the value for the column that contains the names of the data
// table columns that will have their limits changed, process the list,
// comparing it to the data table to check for columns not found
ColListY << On Change(
If( Try( (ColListY << get items)[1], "" ) != LastColListY,
If( Try( N Items( colListY << get items ), 0 ) > 0,
AllLimitColList = AllLimitColListCompressed = NotProcessedColumnsList = NotProcessedColumnsListCompressed = {};
LastColListY = (ColListY << get items)[1];
If( Try( (colListY << get items)[1], "" ) != "",
AllLimitColList = Column( dtlimits, (colListY << get items)[1] ) << get values;
AllLimitColListCompressed = AllLimitColList;
NotFoundList = {};
NotFoundListRowNumbers = {};
// Uppercase and compress the column names
For( i = N Items( AllLimitColList ), i > 0, i--,
AllLimitColListCompressed[i] = Uppercase( AllLimitColListCompressed[i] );
While( Pat Match( AllLimitColListCompressed[i], " ", "" ) > 0, Pat Match( AllLimitColListCompressed[i], " ", "" ) );
If( Contains( AllNumericColumnsCompressed, AllLimitColListCompressed[i] ) == 0,
Insert Into( NotFoundList, AllLimitColList[i] );
Insert Into( NotFoundListRowNumbers, i );
AllLimitColListCompressed = Remove( AllLimitColListCompressed, i, 1 );
AllLimitColList = Remove( AllLimitColList, i, 1 );
);
);
// Find all of the columns that are not going to be processed
NotProcessedColumnsListCompressed = NotProcessedColumnsList = dt << get column Names( string );
For( i = N Items( NotProcessedColumnsList ), i > 0, i--,
NotProcessedColumnsListCompressed[i] = Uppercase( NotProcessedColumnsListCompressed[i] );
While( Pat Match( NotProcessedColumnsListCompressed[i], " ", "" ) > 0,
Pat Match( NotProcessedColumnsListCompressed[i], " ", "" )
);
If( Contains( AllLimitColListCompressed, NotProcessedColumnsListCompressed[i] ) > 0,
//Insert Into( NotFoundList, AllLimitColList[i] );
NotProcessedColumnsListCompressed = Remove( NotProcessedColumnsListCompressed, i, 1 );
NotProcessedColumnsList = Remove( NotProcessedColumnsList, i, 1 );
);
);
// If there are columns that do not exist in the data table, notify the user
If( N Items( NotFoundList ) > 0,
winLocation = nw << get window position;
err = New Window( "Columns Not Found",
Border Box( top( 10 ), Left( 10 ), Right( 10 ), bottom( 10 ), sides( 15 ),
V List Box(
Spacer Box( size( 1, 10 ) ),
Text Box( "The following column(s) names(s) were referenced in the" ),
Text Box( "Limit Table, but no numeric column of that/those name(s)" ),
Text Box( "were found in the data table." ),
Spacer Box( size( 1, 10 ) ),
H List Box( Spacer Box( size( 60, 1 ) ), List Box( NotFoundList ) ),
Spacer Box( size( 1, 10 ) ),
Text Box( "No limits will be set for the above referenced columns" ),
Spacer Box( size( 1, 10 ) ),
H List Box(
continueBB = Button Box( "Continue Anyway", err << close window ),
stopBB = Button Box( "Stop Script",
err << close window;
nw << close window;
Throw();
)
)
)
)
);
err << move window( winLocation[1] + 100, winLocation[2] + 100 ) << zoom window;
);
);
)
)
);
);
/*****************************************************************************/
/* */
/* An Expr to run for any function that has not been implemented. It */
// displays a dialog window telling the user that the function has not been */
/* implemented yet */
/* */
/*****************************************************************************/
notImplemented = Expr(
Dialog( "Feature Not Implemented Yet", Button( "OK" ) )
);
/*****************************************************************************/
/* */
/* Code used in the column selection filter to reset the selection box */
/* */
/*****************************************************************************/
clearit = Expr(
For( II = 1, II <= N Items( colListData << get items ), II++,
colListData << set selected( II )
);
colListData << remove selected;
colListData << append( all columns list );
);
// Call the main expr as the inital piece of script to be run
main;
biv6 = Graph Builder(
Variables( X( :PPO_26_H ) ),
Show Control Panel( 0 ),
Elements( Histogram( X, Legend( 4 ) ), Box Plot( X, Legend( 6 ) ) ),
SendToReport(
Dispatch( {}, "PPO_26_H", ScaleBox, {Label Row( Set Font Size( 16 ) )} ),
Dispatch( {}, "graph title", TextEditBox, {Set Font Size( 24 )} )
)
);
biv6 << save picture("c:\temp\biv6.png");</SET>
Re: Escribir límites a una tabla de datos desde una tabla de límites¿De qué gráfico estás hablando?¿El informe resumido?
Re: Escribir límites a una tabla de datos desde una tabla de límitesGracias, este complemento muy bueno para mí.
Tengo una pregunta.
¿Cómo puedo hacer el gráfico después de que el complemento se ejecute primero?
Re: Escribir límites a una tabla de datos desde una tabla de límites¡Gracias, gran complemento y secuencias de comandos!
He estado trabajando en la automatización de algunos análisis y esto funciona perfectamente. No se requiere análisis de capacidad, y es muy lento para esto como más de 100 variables. Administre los límites de especificación sin importar desde una tabla por algún motivo y colgando.
Re: Escribir límites a una tabla de datos desde una tabla de límitesNo tengo conocimiento de ninguna configuración de preferencia que cambie el color predeterminado para las líneas de referencia de los límites de especificación.Lo que he hecho en el pasado ha sido crear mis propias Líneas de referencia en el color que quiero, y no usar el valor predeterminado de JMP para generar las Líneas de límites.
Re: Escribir límites a una tabla de datos desde una tabla de límitesHola @txnelson ,
de todos modos, ¿puedo cambiar el color de las líneas USL y LSL a rojo (desde el azul predeterminado)?
Gracias,
ana ana
Re: Escribir límites a una tabla de datos desde una tabla de límitesDado que JMP ha agregado la capacidad de administrar límites, que se hace cargo de la escritura de límites en la tabla de datos de una tabla de límites, no mejoraré el complemento.Sin embargo, a continuación hay una secuencia de comandos simple que debería darle un comienzo y una secuencia de comandos que leerá de una tabla de datos de límites y agregará Unidades a las columnas de otra tabla.
Names Default To Here( 1 );
Clear Symbols();
dt = Open( "$SAMPLE_DATA/big class.jmp" );
dtLimits = New Table( "Limits",
New Column( "Column Name", Character, values( {"height", "weight"} ) ),
New Column( "Units", Character, values( {"Inches", "Lbs"} ) )
);
colNamesList = {"height", "weight"};
For( i = 1, i <= N Items( colNamesList ), i++,
dtLimits << select where( :Column Name == colNamesList[i] );
If( N Rows( dtLimits << get selected rows ) > 0,
Eval(
Substitute(
Expr(
Column( dt, colNamesList[i] ) << set property( "Units", __units__ )
),
Expr( __units__ ), dtLimits:Units[i]
)
)
);
);Re: Escribir límites a una tabla de datos desde una tabla de límites@txnelson Este es un complemento fantástico. ¿Podemos agregar "Unidades" para la columna de otra hoja de especificaciones? ¿Tiene algún script JSL mejorado para eso?
Gracias,
Venkat
Re: Escribir límites a una tabla de datos desde una tabla de límites¡Perfecto! esto funciona correctamente. Continúe, haga esta versión del código para agregar ...
Re: Escribir límites a una tabla de datos desde una tabla de límitesAquí hay una versión que creo que corregirá el problema.Pruébelo y comuníquese conmigo si soluciona su problema.Luego publicaré el nuevo complemento en el Intercambio de archivos
Names Default To Here( 1 );
Clear Symbols();
/*****************************************************************************/
/* */
/* This is the inital piece of code to be run in the script */
/* It initializes the environment and opens the initial user inptut dialog */
/* */
/*****************************************************************************/
Main = Expr(
dt = Current Data Table();
LastColListY = "";
// The recall values are saved into a namespace called "Recall"
// and if it currently doesn't exist, set it up
If( Namespace Exists( "Recall" ) == 0,
recall = New Namespace(
"Recall"
)
);
// Get a list of all of the numeric columns in the data table
AllNumericColumns = dt << get column names( numeric, string );
AllNumericColumnsCompressed = AllNumericColumns;
// Uppercase and compress the column names
For( i = 1, i <= N Items( AllNumericColumns ), i++,
AllNumericColumnsCompressed[i] = Uppercase( AllNumericColumnsCompressed[i] );
While( Pat Match( AllNumericColumnsCompressed[i], " ", "" ) > 0, Pat Match( AllNumericColumnsCompressed[i], " ", "" ) );
);
// This iist is the list of the names used within JMP Contol Limits and is used by the script
// to set the type of contol limit being updated
ControlLimitList = {"XBar", "R", "S", "Individual Measurement", "Moving Range", "Median Moving Range", "P", "NP", "C", "U", "UWMA", "EWMA",
"CUSUM", "Levey Jennings", "Individual on Group Means", "Individual on Group Std Devs", "Moving Range on Group Means",
"Moving Range on Group Stds", "Median Moving Range on Group Means", "Median Moving Range on Group Std Devs", "Run Chart", "G", "T"};
// Variale used to set the length of the column selection list
nc = N Col( dt );
lbWidth = 160;
// Create a list of all of the open tables
list_tables = {};
For( i = 1, i <= N Table(), i++,
Insert Into( list_tables, Data Table( i ) << get name )
);
// Display the Limits Table Selection window
nw = New Window( "Populate Limits",
V List Box(
Spacer Box( size( 1, 5 ) ),
H List Box( IconBB = Button Box( "" ), IconTB = Text Box( "Populate Limits Column Property from a separate table" ) ),
Spacer Box( size( 1, 20 ) ),
TheHlB = H List Box(
V List Box(
Text Box( "Select Limits Table" ),
Spacer Box( size( 1, 2 ) ),
Panel Box( "Set Limits in " || Char( dt << get name ) || " with",
TableLB = List Box( list_tables, n lines( 6 ), width( 220 ) ),
)
)
),
Spacer Box( size( 1, 10 ) ),
H List Box(
Spacer Box( size( 10, 1 ) ),
createtableBB = Button Box( "Create Limits Table from Current Active Data Table", createlimitstable )
),
Spacer Box( size( 1, 10 ) )
),
// When the user selection for the limits data table changes, reset the column dialog boxes
TableLB << on change(
// Delete the button box
Try( createtableBb << delete );
// Blank out the low,avg and high lists
resetlists;
// Delete the current column dialog boxes
Try( clusterdlg << delete );
// If the user has selected a new limits table, reset the window
If( Try( (tablelb << get selected)[1], "" ) != "",
dtlimits = Data Table( (tablelb << get selected)[1] );
Current Data Table( dtlimits );
// Reinput the code for the column dialog boxes....this is
// required, because the col list boxes do not lose the data
// table references without totally deleting the col list box
// and bringing in new instances
clusterexpr;
// Add the col dialog boxes to the current display
theHLB << append( clusterdlg );
// Reset required lists
AllLimitColList = AllLimitColListCompressed = {};
Try( AllLimitColList = Column( dtlimits, Column Names ) << get values );
AllLimitColListCompressed = AllLimitColList;
// Uppercase and remove blanks from the column list
For( i = 1, i <= N Items( AllLimitColList ), i++,
AllLimitColListCompressed[i] = Uppercase( AllLimitColListCompressed[i] );
While( Pat Match( AllLimitColListCompressed[i], " ", "" ) > 0, Pat Match( AllLimitColListCompressed[i], " ", "" ) );
);
);
),
// Set the icon
iconbb << set icon( "Update" )
);
);
/*****************************************************************************/
/* */
/* Create a Limits Table populating limits from the current data table */
/* */
/*****************************************************************************/
CreateLimitsTable = Expr(
HasBeenSeen = Repeat( 0, 24 );
dtnew = New Table( "Limits Table", invisible, New Column( "Column Names", character, values( AllNumericColumns ) ) );
// Pass through all of the specified parameters and extract any limits found in the
// active data table and move them to the new limits data table
For( allvars = 1, allvars <= N Items( AllNumericColumns ), allvars++,
col = Parse( "dt:" || AllNumericColumns[allvars] );
// Gather in the already set Control and Spec Limits
controls = col << get property( "Control Limits" );
specs = col << get property( "Spec Limits" );
// Process Spec Limits
If( !(Char( specs ) == "Scriptable[]" | Is Empty( specs ) == 1),
If( HasBeenSeen[24] == 0,
dtnew << New Column( "LSL" );
dtnew << New Column( "Target" );
dtnew << New Column( "USL" );
HasBeenSeen[24] = 1;
);
For( i = 1, i <= N Items( specs ), i++,
If( Is Missing( Try( Specs["LSL"], . ) ) == 0,
dtnew:LSL[AllVars] = Specs["LSL"]
);
If( Is Missing( Try( Specs["Target"], . ) ) == 0,
dtnew:Target[AllVars] = Specs["Target"]
);
If( Is Missing( Try( Specs["LSL"], . ) ) == 0,
dtnew:USL[AllVars] = Specs["USL"]
);
);
);
// All of the Control limits have the same structure. This code extracts all of the different
// types of control limits and moves them to the limits table
If( !(Char( controls ) == "Scriptable[]" | Is Empty( controls ) == 1),
For( i = 1, i <= N Items( controls ), i++,
If( Contains( ControlLimitList, Trim( Word( 1, Char( controls[i] ), "(,)" ) ) ) > 0,
Control Limit Type = Trim( Word( 1, Char( controls[i] ), "(,)" ) );
LimitListNumber = Contains( ControlLimitList, Trim( Word( 1, Char( controls[i] ), "(,)" ) ) );
If( HasBeenSeen[LimitListNumber] == 0,
dtnew << New Column( ControlLimitList[LimitListNumber] || "LCL" );
dtnew << New Column( ControlLimitList[LimitListNumber] || "AVG" );
dtnew << New Column( ControlLimitList[LimitListNumber] || "UCL" );
HasBeenSeen[LimitListNumber] = 1;
);
For( ctype = 2, ctype <= 6, ctype = ctype + 2,
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "Avg",
Column( dtnew, ControlLimitList[LimitListNumber] || "AVG" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "LCL",
Column( dtnew, ControlLimitList[LimitListNumber] || "LCL" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
If( Trim( Word( ctype, Char( controls[i] ), "(,)" ) ) == "UCL",
Column( dtnew, ControlLimitList[LimitListNumber] || "UCL" )[AllVars] = Num(
Word( ctype + 1, Char( controls[i] ), "(,)" )
)
);
);
)
);
);
);
If( N Cols( dtnew ) == 1,
dtnew << New Column( "LSL" );
dtnew << New Column( "Target" );
dtnew << New Column( "USL" );
dtnew << New Column( "XBarLCL" );
dtnew << New Column( "XBarAVG" );
dtnew << New Column( "XBarUCL" );
);
Insert Into( List_Tables, "Limits Table" );
x = List_Tables;
TableLB << RemoveAll;
TableLB << append( list_tables );
dtnew << zoom window;
);
/*****************************************************************************/
/* */
/* Blank out all selections and reset to the current limit */
/* */
/*****************************************************************************/
resetLists = Expr(
lowList = avgList = highList = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""};
If( Try( LimitTypeRB << get, 1 ) == 1,
limitNum = 24,
LimitNum = cb << get
);
);
// Initialize the lists
ResetLists;
/*****************************************************************************/
/* */
/* Set the Control Limits for all specified control limits for a single */
/* row from the limits data table */
/* */
/*****************************************************************************/
SetControlLimits = Function( {c, CList, IgnoreMissing, i},
{c, CList, IgnoreMissing},
// Big List pulls in any existing limit control values. This allows for the addition of
// replacement of limit values without erasing any limits that currently exist.
c = AllNumericColumns[Contains( AllnumericColumnsCompressed, AllLimitColListCompressed[i] )];
biglist = Column( dt, c ) << getproperty( "control limits" );
// Roll across all of the types of contol limits found
For( cl = 1, cl <= N Items( CList ), cl++,
little = {__type__( Avg( avexpr ), UCL( ULexpr ), LCL( LLexpr ) )};
Substitute Into( little, Expr( __type__ ), Parse( controllimitnamesList[CList[cl]] ) );
// Get the new limits to be processed from the limits table
// If no column has been specified for one of the limits, a
// missing value is set
lcl = Try( Column( dtlimits, lowlist[CList[cl]] )[i], . );
tar = Try( Column( dtlimits, avglist[CList[cl]] )[i], . );
ucl = Try( Column( dtlimits, highlist[CList[cl]] )[i], . );
// If Control Limits were found interrogate them
If( Is Empty( biglist ) == 0,
For( _i_ = N Items( big list ), _i_ >= 1, _i_--,
If( Uppercase( Word( 1, biglist[_i_], "(" ) ) == Uppercase( controllimitnamesList[CList[cl]] ),
onelist = Char( biglist[_i_] );
xlcl = .;
xtarget = .;
xucl = .;
For( limitcnt = 2, limitcnt <= 7, limitcnt = limitcnt + 2,
alimit = Word( limitcnt, onelist, "(,)" );
If(
Contains( alimit, "LCL" ) > 0, xlcl = Num( Word( limitcnt + 1, onelist, "(,)" ) ),
Contains( alimit, "Avg" ) > 0, xtarget = Num( Word( limitcnt + 1, onelist, "(,)" ) ),
Contains( alimit, "UCL" ) > 0, xucl = Num( Word( limitcnt + 1, onelist, "(,)" ) )
);
);
Remove From( biglist, _i_ );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xtarget;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
);
// If the limits do not currently exist, but other control limits are there,
// insert the new control limits into the large control limit list
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) > 0,
// If Missing values from the limits table are to signal not to
// change the current limit, then process them accoringly
If( IgnoreMissing == "No",
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little, Expr( LLexpr ), Eval( xlcl ) );
lcl = xlcl;
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
);
,
If( Is Missing( lcl ) == 1 | LowList[CList[cl]] == "",
Substitute Into( little, Expr( LLexpr ), Eval( xlcl ) );
lcl = xcl;
,
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) )
);
If( Is Missing( ucl ) == 1 | HighList[CList[cl]] == "",
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
,
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) )
);
If( Is Missing( tar ) == 1 | AvgList[CList[cl]] == "",
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
,
Substitute Into( little, Expr( avexpr ), Eval( tar ) )
);
)
,
// Just add the new limits if not concerned about preserving data
// and replacing limits if missing values have been specified
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) < 3,
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little,
Expr( LLexpr ),
Eval( xlcl );
lcl = xlcl;
)
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( xtarget ) );
tar = xtarget;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( xucl ) );
ucl = xucl;
);
)
);
// If the big list doesn't exist, create it
If( Is Empty( biglist ) == 1,
biglist = {}
);
// Add the current limit type to the overall list of control limits
Insert Into( biglist, little );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = tar;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = ucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
)
,
// No control limits currently exist for the target column, so create the large
// control limit list by setting it equal to the new input limits
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = .;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = .;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = .;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
If( Is Missing( lcl ) + Is Missing( tar ) + Is Missing( ucl ) < 3,
If( LowList[CList[cl]] != "",
Substitute Into( little, Expr( LLexpr ), Eval( lcl ) ),
Substitute Into( little, Expr( LLexpr ), Eval( . ) );
lcl = .;
);
If( AvgList[CList[cl]] != "",
Substitute Into( little, Expr( avexpr ), Eval( tar ) ),
Substitute Into( little, Expr( avexpr ), Eval( . ) );
tar = .;
);
If( HighList[CList[cl]] != "",
Substitute Into( little, Expr( ULexpr ), Eval( ucl ) ),
Substitute Into( little, Expr( ULexpr ), Eval( . ) );
ucl = .;
);
);
// If the big list doesn't exist, create it
If( Is Empty( biglist ) == 1,
biglist = {}
);
// Add the current limit type to the overall list of control limits
Insert Into( biglist, little );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lcl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = tar;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = controllimitnamesList[CList[cl]];
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = ucl;
dtReport:Limit[N Rows( dtReport )] = "Control Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
)
;
);
If( Char( biglist ) != "Scriptable[]" & Is Empty( biglist ) == 0 & biglist != {},
Column( dt, c ) << setproperty( "control limits", Eval( biglist ) )
);
);
/*****************************************************************************/
/* */
/* Set the Spec Limits for all specified control limits for a single */
/* row from the limits data table */
/* */
/*****************************************************************************/
SetSpecLimits = Function( {c, lsl, usl, avg, IgnoreMissing, showlims},
{c, lsl, usl, avg, IgnoreMissing, showlims},
// Get the current spec limits
Try( speclist = Column( dt, c ) << get property( "spec limits" ), {} );
Try( xlsl = speclist["LSL"], xlsl = . );
Try( xusl = speclist["USL"], xusl = . );
Try( xavg = speclist["Target"], xavg = . );
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xavg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xusl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "Previous";
// Process the limits
If( Is Missing( lsl ) + Is Missing( avg ) + Is Missing( usl ) < 3,
// If misssing value input is to be Ignored, that means that
// old values of the limits are to be moved forward if the new
// input values are missing values
If( IgnoreMissing == "Yes",
If( (Is Missing( xusl ) == 1 & Is Missing( usl ) == 0) | HighList[24] != "",
xusl = usl
);
If( (Is Missing( xlsl ) == 1 & Is Missing( lsl ) == 0) | LowList[24] != "",
xlsl = lsl
);
If( (Is Missing( xavg ) == 1 & Is Missing( avg ) == 0) | AvgList[24] != "",
xavg = avg
);
cmd = Expr(
Column( dt, c ) << SetProperty(
"Spec LImits",
{LSL( Expr( xlsl ) ), USL( Expr( xusl ) ), Target( Expr( xavg ) ), Show Limits( Expr( showlims ) )}
)
);
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = xlsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = xavg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = xusl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
, // Else
If( LowList[24] == "",
lsl = xlsl
);
If( AvgList[24] == "",
avg = xavg
);
If( HighList[24] == "",
usl = xusl
);
cmd = Expr(
Column( dt, c ) << SetProperty(
"Spec LImits",
{LSL( Expr( lsl ) ), USL( Expr( usl ) ), Target( Expr( avg ) ), Show Limits( Expr( showlims ) )}
)
);
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport:Level[N Rows( dtReport )] = "Lower";
dtReport:Value[N Rows( dtReport )] = lsl;
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Average";
dtReport:Value[N Rows( dtReport )] = avg;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
dtReport << add Rows( 1 );
dtReport:Column[N Rows( dtReport )] = c;
dtReport:Limit Type[N Rows( dtReport )] = "_";
dtReport:Level[N Rows( dtReport )] = "Upper";
dtReport:Value[N Rows( dtReport )] = usl;
dtReport:Limit[N Rows( dtReport )] = "Spec Limit";
dtReport:OldNew[N Rows( dtReport )] = "New";
);
Eval( Eval Expr( cmd ) );
);
);
/*****************************************************************************/
/* */
/* Run through each of the columns in the limits table and call the functions*/
/* that update the limits, based upon what limits have been specified in the */
/* dialog input screen */
/* */
/*****************************************************************************/
runit = Expr(
ControlLimitNamesList = {"XBar", "R", "S", "Individual Measurement", "Moving Range", "Median Moving Range", "P", "NP", "C", "U", "UWMA", "EWMA",
"CUMSUM", "Levey Jennings", "Individual on Group Means", "Individual on Group Std Devs", "Moving Range on Group Means",
"Moving Range on Group Std Devs", "Median Moving Range on Group Means", "Median Moving Range on Group Std Devs", "Run Chart", "G", "T"};
// Create a list of which control limits have been specified
CList = {};
For( i = 1, i <= 23, i++,
If( LowList[i] || avgList[i] || highList[i] != "",
Insert Into( CList, i )
)
);
// If spec limits have been specified, setup a similar flag to the control limits
// to use for spec limit processing
SLList = {};
If( LowList[24] || avgList[24] || highList[24] != "",
Insert Into( SLList, 24 )
);
// Get Excluded Rows in the Limits Table so they can be bypassed in processing
Excluded Rows = As List( dtLimits << get excluded rows );
// Roll across the rows in the limits table and process the new limits
For( ii = 1, ii <= N Items( AllLimitColList ), ii++,
Process = "Yes";
If( N Items( Excluded Rows ) > 0,
If( Loc( Excluded Rows, ii ) > 0,
Process = "No",
Process = "Yes"
)
);
If( Process == "Yes",
targetName = AllNumericColumns[Contains( AllnumericColumnsCompressed, AllLimitColListCompressed[ii] )];
//ii=30
// If there are spec limits to be processed, call the setspeclimits function
If( N Items( SLList ) > 0,
return = setspeclimits(
Targetname,
Try( Column( dtlimits, lowlist[24] )[ii], . ),
Try( Column( dtlimits, highlist[24] )[ii], . ),
Try( Column( dtlimits, avglist[24] )[ii], . ),
IgnoreMissing,
showLims
)
);
// If Control limit changes have been specified, call the SetControlLimits function
If( N Items( CList ) > 0,
return = SetControlLimits( TargetName, CList, IgnoreMissing, ii )
);
);
);
ShowReport;
close(dtLimits, nosave );
dtLimits = dtOriginalLimits;
current data table(dt);
);
/*****************************************************************************/
/* */
/* Create and display a Summary Report */
/* */
/*****************************************************************************/
ShowReport = Expr(
If( N Rows( dtReport ) > 0,
// Calculate Required Scroll Bar Width
Current Data Table( dtReport );
Summarize( dtReport, Ltypes = By( :Limit Type ) );
hsize = N Items( Ltypes ) * 200 + 150;
// Generate a tabluate report for the display
tab = Tabulate(
Change Item Label( Statistics( Sum, " " ) ),
Remove Column Label( Grouping Columns( :Limit Type, :Limit, :OldNew ) ),
Show Control Panel( 0 ),
Include missing for grouping columns( 1 ),
Add Table(
Column Table( Grouping Columns( :Limit, :Limit Type, :OldNew ), Analysis Columns( :Value ) ),
Row Table( Grouping Columns( :Column, :Level ) )
),
SendToReport( Dispatch( {}, "Tabulate", OutlineBox, {Set Title( "Set Limits Report" )} ) )
);
Tab << on Close( Close( dtReport, nosave ) );
// Modify the output so the Tabulate table is in a scroll box of limited size
Report( tab ) << append( thescroll = Scroll Box( size( hsize, 700 ) ) );
thescroll << append( Report( Tab )[Box( 1 )] );
// Delete the non scroll box version of the table
Report( Tab )[Box( 1 )] << delete;
// If Non Processed columns are found in the data table, list them out
If( N Items( NotProcessedColumnsList ) > 0,
rptNotProcessedOB = Outline Box( "Columns Not Processed",
Border Box( top( 10 ), Left( 10 ), Right( 10 ), bottom( 10 ), sides( 15 ),
V List Box(
Spacer Box( size( 1, 10 ) ),
Text Box( "The following column(s) are in the data table" ),
Text Box( "but are not being processed because they were)" ),
Text Box( "not referenced in the limits table." ),
Spacer Box( size( 1, 10 ) ),
H List Box( Spacer Box( size( 60, 1 ) ), List Box( NotProcessedColumnsList ) ),
Spacer Box( size( 1, 10 ) ),
Text Box( "No limits will be set for the above referenced columns" ),
Spacer Box( size( 1, 10 ) )
)
)
);
rptNotProcessedOB << close;
Report( Tab ) << Append( rptNotProcessedOB );
);
// If columns were found in the limits table, but not in the data table
// list them out
If( N Items( NotFoundList ) > 0,
rptNotFoundOB = Outline Box( "Columns Not Found",
Border Box( top( 10 ), Left( 10 ), Right( 10 ), bottom( 10 ), sides( 15 ),
V List Box(
Spacer Box( size( 1, 10 ) ),
Text Box( "The following column(s) names(s) were referenced in the" ),
Text Box( "Limit Table, but no numeric column of that/those name(s)" ),
Text Box( "were found in the data table." ),
Spacer Box( size( 1, 10 ) ),
H List Box( Spacer Box( size( 60, 1 ) ), List Box( NotFoundList ) ),
Spacer Box( size( 1, 10 ) ),
Text Box( "No limits will be set for the above referenced columns" ),
Spacer Box( size( 1, 10 ) )
)
)
);
rptNotFoundOB << close;
Report( Tab ) << Append( Spacer Box( size( 1, 10 ) ) );
Report( Tab ) << Append( rptNotFoundOB );
);
)
);
/*****************************************************************************/
/* */
/* This is the display for the column selections where the user matches the */
/* the limit columns from the limit data table with the columns in the */
/* data table */
/* */
/*****************************************************************************/
clusterexpr = Expr(
all Columns List = dtlimits << get column names;
Current Data Table( dtlimits );
clusterDlg = V List Box(
Border Box( Left( 3 ), top( 2 ),
V List Box(
Text Box( "Select Columns to Read the Limits From" ),
H List Box(
V List Box(
// Generate the master display box for the columns in the data table
Panel Box( "Select Columns",
cldvlb = H List Box(
Popup Box(
{"Clear", filterval = "" ; thefilter << set text( "" ) ; clearit ; ,
"Numeric", filterval = "" ; thefilter << set text( "" ) ; clearit ; For( II = 1,
II <= N Items( All Columns List ), II++,
If( Column( All Columns List[II] ) << get data type != "Numeric",
colListData << set selected( II )
)
) ; colListData << remove selected ; ,
"Character", filterval = "" ; thefilter << set text( "" ) ; clearit ; For( II = 1,
II <= N Items( All Columns List ), II++,
If( Column( All Columns List[II] ) << get data type != "Character",
colListData << set selected( II )
)
) ; colListData << remove selected ; ,
"Name Contains", filterval = "" ; filtervlb << prepend(
V List Box(
thefilter = Text Edit Box( "",
<<SET width=""> 0;
// Check to see if the required data has been input
If(
N Items( colListY << GetItems ) == 0, Dialog( "No ID Column Specified", Button( "OK" ) ), // Else
LimitsChoosen == 0, Dialog( "No Limit Columns Specified", Button( "OK" ) ), // Else
RecallList = {lowlist = {}, avglist = {}, highlist = {}};
RecallList["lowlist"] = lowlist;
RecallList["avglist"] = avglist;
RecallList["highlist"] = highlist;
// Place the selected values from the screen into the recall list
Insert Into( RecallList, Parse( "IDColumn = \!"" || Char( (colListY << get items)[1] ) || "\!"" ) );
If( IgnoreCB << get == 1,
IgnoreMissing = "Yes",
IgnoreMissing = "No"
);
ShowLims = ShowCB << get;
ShowRpt = ReportCB << get;
Insert Into( RecallList, Parse( "IgnoreMissing = \!"" || IgnoreMissing || "\!"" ) );
Insert Into( RecallList, Parse( "ShowLims = " || Char( showlims ) ) );
Insert Into( RecallList, Parse( "ShowRpt = " || Char( showRpt ) ) );
// Save recall string to Recall namespace
Recall:WriteLimits = RecallList;
nw << CloseWindow;
dtReport = New Table( "Report",
Private,
New Column( "Column", Character, "Nominal" ),
New Column( "Limit Type", Character, "Nominal" ),
New Column( "Level",
Character,
"Nominal",
Set Property( "Value Ordering", {"Lower", "Average", "Upper"} )
),
New Column( "Value", Numeric, "Continuous", Format( "Best", 10 ) ),
New Column( "Limit",
Character,
"Nominal",
Set Property( "Value Ordering", {"Spec Limit", "Control Limit"} )
),
New Column( "OldNew", Character, "Nominal", Set Property( "Value Ordering", {"Previous", "New"} ) )
);
dtReport:Column << set property( "Row Order Levels", 1 );
// Create a working copy of the limits table
dtLimits << Select Rows( NotFoundListRowNumbers );
dtLimits << invert row selection;
dtLimitsTemp = dtLimits << subset(invisible, selected rows(1), selected columns(0));
dtLimits << clear select;
dtOriginalLimits = dtLimits;
dtLimits = dtLimitsTemp;
wait(0);
// Run the actual code that updates the limits
runit;
);
),
Button Box( "Cancel",
clusterDlg << CloseWindow;
Names Default To Here( 1 );
),
Text Box( " " ),
Button Box( "Remove",
colListY << RemoveSelected;
collower << remove selected;
colaverage << remove selected;
colupper << remove selected;
),
Button Box( "Recall",
If( Is List( Recall:WriteLimits ) == 1,
Eval List( Recall:WriteLimits );
If( Try( (colListY << get items)[1], "" ) != IDcolumn,
colListY << RemoveAll;
colListY << append( IDcolumn );
);
If( IgnoreMissing == "Yes",
IgnoreCB << set( 1 ),
IgnoreCB << set( 0 )
);
ShowCB << set( ShowLims );
ReportCB << set( ShowRpt );
readLimitColNames( LimitNum );
)
),
Button Box( "Help", notImplemented )
)
)
),
)
)
),
// Set the default values for the check box options
IgnoreCB << set( 1 );
IgnoreMissing = "Yes";
ShowCB << set( 1 );
ShowLims = 1;
ReportCB << set( 1 );
ShowRpt = 1;
);
// Write the names to the Limit Lists ffrom the display window
WriteLimitColNames = Function( {lNum},
LowList[LNum] = Try( (colLower << get items)[1], "" );
AvgList[LNum] = Try( (colAverage << get items)[1], "" );
HighList[LNum] = Try( (colUpper << get items)[1], "" );
);
// Read the limit values from the Limit Lists and populate
// the display window with the values
ReadLimitColNames = Function( {lNum},
{lNum},
tmplist = lowlist;
ColLower << remove all;
lowlist = tmplist;
tmplist = {};
Insert Into( tmplist, lowlist[lnum] );
collower << append( tmplist );
tmplist = avglist;
ColAverage << remove all;
avglist = tmplist;
tmplist = {};
Insert Into( tmplist, avglist[lnum] );
colAverage << append( tmplist );
tmplist = Highlist;
ColUpper << remove all;
Highlist = tmplist;
tmplist = {};
Insert Into( tmplist, Highlist[lnum] );
ColUpper << append( tmplist );
);
// When the value for the column that contains the names of the data
// table columns that will have their limits changed, process the list,
// comparing it to the data table to check for columns not found
ColListY << On Change(
If( Try( (ColListY << get items)[1], "" ) != LastColListY,
If( Try( N Items( colListY << get items ), 0 ) > 0,
AllLimitColList = AllLimitColListCompressed = NotProcessedColumnsList = NotProcessedColumnsListCompressed = {};
LastColListY = (ColListY << get items)[1];
If( Try( (colListY << get items)[1], "" ) != "",
AllLimitColList = Column( dtlimits, (colListY << get items)[1] ) << get values;
AllLimitColListCompressed = AllLimitColList;
NotFoundList = {};
NotFoundListRowNumbers = {};
// Uppercase and compress the column names
For( i = N Items( AllLimitColList ), i > 0, i--,
AllLimitColListCompressed[i] = Uppercase( AllLimitColListCompressed[i] );
While( Pat Match( AllLimitColListCompressed[i], " ", "" ) > 0, Pat Match( AllLimitColListCompressed[i], " ", "" ) );
If( Contains( AllNumericColumnsCompressed, AllLimitColListCompressed[i] ) == 0,
Insert Into( NotFoundList, AllLimitColList[i] );
Insert Into( NotFoundListRowNumbers, i );
AllLimitColListCompressed = Remove( AllLimitColListCompressed, i, 1 );
AllLimitColList = Remove( AllLimitColList, i, 1 );
);
);
// Find all of the columns that are not going to be processed
NotProcessedColumnsListCompressed = NotProcessedColumnsList = dt << get column Names( string );
For( i = N Items( NotProcessedColumnsList ), i > 0, i--,
NotProcessedColumnsListCompressed[i] = Uppercase( NotProcessedColumnsListCompressed[i] );
While( Pat Match( NotProcessedColumnsListCompressed[i], " ", "" ) > 0,
Pat Match( NotProcessedColumnsListCompressed[i], " ", "" )
);
If( Contains( AllLimitColListCompressed, NotProcessedColumnsListCompressed[i] ) > 0,
//Insert Into( NotFoundList, AllLimitColList[i] );
NotProcessedColumnsListCompressed = Remove( NotProcessedColumnsListCompressed, i, 1 );
NotProcessedColumnsList = Remove( NotProcessedColumnsList, i, 1 );
);
);
// If there are columns that do not exist in the data table, notify the user
If( N Items( NotFoundList ) > 0,
winLocation = nw << get window position;
err = New Window( "Columns Not Found",
Border Box( top( 10 ), Left( 10 ), Right( 10 ), bottom( 10 ), sides( 15 ),
V List Box(
Spacer Box( size( 1, 10 ) ),
Text Box( "The following column(s) names(s) were referenced in the" ),
Text Box( "Limit Table, but no numeric column of that/those name(s)" ),
Text Box( "were found in the data table." ),
Spacer Box( size( 1, 10 ) ),
H List Box( Spacer Box( size( 60, 1 ) ), List Box( NotFoundList ) ),
Spacer Box( size( 1, 10 ) ),
Text Box( "No limits will be set for the above referenced columns" ),
Spacer Box( size( 1, 10 ) ),
H List Box(
continueBB = Button Box( "Continue Anyway", err << close window ),
stopBB = Button Box( "Stop Script",
err << close window;
nw << close window;
Throw();
)
)
)
)
);
err << move window( winLocation[1] + 100, winLocation[2] + 100 ) << zoom window;
);
);
)
)
);
);
/*****************************************************************************/
/* */
/* An Expr to run for any function that has not been implemented. It */
// displays a dialog window telling the user that the function has not been */
/* implemented yet */
/* */
/*****************************************************************************/
notImplemented = Expr(
Dialog( "Feature Not Implemented Yet", Button( "OK" ) )
);
/*****************************************************************************/
/* */
/* Code used in the column selection filter to reset the selection box */
/* */
/*****************************************************************************/
clearit = Expr(
For( II = 1, II <= N Items( colListData << get items ), II++,
colListData << set selected( II )
);
colListData << remove selected;
colListData << append( all columns list );
);
// Call the main expr as the inital piece of script to be run
main;</SET>
.
Re: Escribir límites a una tabla de datos desde una tabla de límitesHola txnelson , Gracias por tu guión. Cuando lo ejecuto, se ejecuta sin ningún error. Sin embargo, cuando observo los límites de las especificaciones, para 'algunas de las columnas', el script asigna valores de límite incorrectos... Revisé los nombres de las columnas y el nombre no es el problema... No puedo encontrar una razón por la que funciona bien para algunas columnas y algunas columnas no... ¿me estoy perdiendo algo? ¿Puede usted ayudar?
Re: Escribir límites a una tabla de datos desde una tabla de límitesGracias por el maravilloso guión.Re: Escribir límites a una tabla de datos desde una tabla de límitesComplemento absolutamente brillante. Gran ahorro de tiempo. Especialmente porque "Mostrar como líneas de referencia del gráfico" se activa automáticamente.
Gracias por compartir.
Felipe
Re: Escribir límites a una tabla de datos desde una tabla de límitesGracias por tu comentario.En cuanto a ejecutar el complemento como parte de JSL, tendrá que profundizar en el código y extraer la parte de trabajo.El código está estructurado en funciones y EXPR, que deberían permitirle eliminar fácilmente el código que se llama desde el cuadro de diálogo.
Re: Escribir límites a una tabla de datos desde una tabla de límites¡Gran complemento! Iba a escribir más o menos lo mismo para un proyecto.
¿Es posible ejecutar el complemento a través de JSL? Me gustaría automatizar el proceso de agregar límites de especificación en mi aplicación.
Re: Escribir límites a una tabla de datos desde una tabla de límites@MikeD_Anderson es correcto. El complemento requiere JMP 12 o posterior
Re: Escribir límites a una tabla de datos desde una tabla de límitesPuede verificar la compatibilidad de la versión con el complemento. Podría haberlo limitado a 12 o más nuevo. Es posible que desee consultar con su administrador de licencias. Estoy bastante seguro de que tiene acceso a la versión 12 y 13... hubo muchas mejoras que puede encontrar muy útiles.
Mejor,
METRO
Re: Escribir límites a una tabla de datos desde una tabla de límiteseste archivo .jmpaddin no se está instalando en mi computadora.
Alguien con este problema?
/Onti
