Écrire des limites dans une table de données à partir d'une table de limitesCe complément JMP prend les limites de spécification et l'un des 23 différents types de limites de contrôle (c'est-à-dire XBar, S, plage mobile, etc.) qui se trouvent dans une table de données distincte (je l'appelle une table de limites) et remplit les limites appropriées propriétés de colonne dans un tableau de données JMP.
Comme indiqué ci-dessus, le « tableau des limites » n'est qu'un tableau JMP.Pour être un tableau de limites valide, il doit avoir une colonne contenant les noms des colonnes à mettre à jour, puis une colonne pour chaque limite spécifique dont les valeurs vont être déplacées dans les propriétés de colonne de votre tableau contenant vos données de mesure. .Vous trouverez ci-dessous un exemple de ce à quoi pourrait ressembler un tableau des limites.Remarque : les noms des colonnes n'ont pas besoin d'avoir des noms spécifiques.Comme on le verra, les colonnes à utiliser pour les différentes parties de la spécification et les limites de contrôle seront mappées dans une fenêtre de dialogue.
Le « tableau des limites » comporte 7 colonnes et 128 lignes.Chaque ligne contient les limites d'une colonne spécifique de votre tableau de données de mesure.Dans cet exemple, la colonne nommée "Column Names" contient les noms des colonnes de votre tableau de données de mesure qui doivent être mises à jour.Toutes les colonnes du « tableau des limites » seront mappées dans le complément, en fonction du rôle qu'il joue.
Le tableau de données de mesure ci-dessous est le tableau de données de capacité des semi-conducteurs des exemples de tableaux de données JMP.Pour cet exemple, les limites de spécification qui font partie de la table de données expédiées ont été supprimées.
Pour exécuter le complément, accédez à votre tableau de données de mesure et cliquez dessus pour en faire le tableau de données "actif" actuel. Lancez ensuite l'Addin La fenêtre qui apparaît demande à l'utilisateur de sélectionner la « Table des limites » à utiliser pour la mise à jour.
Lorsque vous sélectionnez le tableau à utiliser, la fenêtre s'agrandit avec les cases de sélection pour mapper les colonnes du « tableau des limites » au rôle qu'il jouera dans le déplacement des limites dans le tableau des données de mesure.
C'est là que la cartographie a lieu.Le premier élément à mapper est d'identifier la colonne dans le "Tableau des limites" qui doit être utilisée comme identifiant des colonnes à mettre à jour.Dans notre exemple, la colonne "Column Names" contient ces informations et doit être placée dans la boîte de sélection ID Column.
Ensuite, nous mappons les colonnes de limite dans le type de limite et s'il s'agit de la limite supérieure, cible ou inférieure pour la limite spécifiée..Les limites de spécification et les limites de contrôle sont gérées séparément.Il existe un bouton radio qui doit être défini sur Spec Limits ou Control Limits, pour correspondre au type de limite que vous mappez.Pour commencer, nous allons configurer les limites de spécification.Dans le "Tableau des limites", les colonnes nommées LSL, Target et USL contiennent les limites de spécification.Pour les mapper, sélectionnez-les simplement et déplacez-les dans la zone de sélection de limite appropriée.
Les colonnes XBar LCL, XBar Target et XBar UCL contiennent des limites de contrôle.Plus précisément, ils contiennent des limites de contrôle XBar.Pour les mapper à l'Add=in, on définit d'abord le bouton radio sur "Control Limits".
L'environnement cartographique change légèrement.Ajouté à l'affichage, une boîte de flèche vers le bas, qui permet de définir le type de limite de contrôle que vous souhaitez mapper.
Le type de limite de contrôle qui se trouve dans le "Tableau des limites" sont les limites XBar, c'est donc le type de limite de contrôle que nous sélectionnons.Ensuite, nous mappons simplement les colonnes aux rouleaux de limite que chacun d'eux joue
S'il y avait plus de types de limites de contrôle dans le "Tableau des limites", il suffirait de répéter les étapes de sélection du type de limite que vous souhaitez mapper, puis de placer les colonnes appropriées dans la zone de sélection qui représente le type de limite dont il s'agit.
Lorsque vous avez terminé avec le mappage, cliquez simplement sur "OK" pour exécuter le complément.Lorsqu'il est terminé, vous pouvez valider qu'il a réussi en accédant au tableau des données de mesure et en examinant les propriétés de la colonne des limites
Ingénierie de la qualitéRe : Écrire des limites dans une table de données à partir d'une table de limites@txnelson Merci beaucoup pour votre aide!!
Le script ci-dessus fonctionne bien !
Re : Écrire des limites dans une table de données à partir d'une table de limitesJSL n'arrête pas de traiter un script simplement parce qu'une fenêtre a été affichée.Par conséquent, pendant que la fenêtre s'affiche, votre générateur de graphes "Biv6" est en cours d'exécution.Vous devez modifier le code de la boîte de dialogue d'entrée, pour lui dire d'exécuter le code "Biv6" à la fin du code qui ajoute les limites de spécification.
Si vous modifiez votre code Graph Builder pour qu'il soit encapsulé dans une fonction Expr(), il ne sera pas exécuté tant que Expr() n'est pas exécuté.
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" );
);
Donc, il ne vous reste plus qu'à décider quand la boîte de dialogue exécutera le générateur de graphes.Ma suggestion est de le placer dans le script "OK" de la boîte à boutons, juste après l'exécution du "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 : Écrire des limites dans une table de données à partir d'une table de limitesGénérateur de graphiques et sauvegardez l'image !
Je voudrais enregistrer le constructeur de graphiques dans l'image après la spécification, mais t Le script ci-dessous génère une image avant que la spécification ne soit appliquée.
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 : Écrire des limites dans une table de données à partir d'une table de limitesDe quel graphique parles-tu ?Le rapport de synthèse ?
Re : Écrire des limites dans une table de données à partir d'une table de limitesMerci, ce complément me convient très bien.
J'ai une question.
Comment puis-je créer le graphique après l'exécution du complément en premier?
Re : Écrire des limites dans une table de données à partir d'une table de limitesMerci, excellent complément et script !
J'ai travaillé sur l'automatisation de certaines analyses et cela fonctionne parfaitement. L'analyse de capacité n'est pas nécessaire, et elle est très lente car plus de 100 variables. Gérer les limites de spécifications qui ne sont pas importées d'une table pour une raison quelconque et qui se bloquent.
Re : Écrire des limites dans une table de données à partir d'une table de limitesJe ne suis au courant d'aucun paramètre de préférence qui modifiera la couleur par défaut des lignes de référence Spec Limits.Ce que j'ai fait dans le passé a été de créer mes propres lignes de référence dans la couleur que je voulais et de ne pas utiliser la valeur par défaut de JMP pour générer les lignes de limites.
Re : Écrire des limites dans une table de données à partir d'une table de limitesSalut @txnelson ,
de toute façon que je peux changer la couleur des lignes USL et LSL en rouge (à partir du bleu par défaut) ?
Merci,
Ann Ann
Re : Écrire des limites dans une table de données à partir d'une table de limitesÉtant donné que JMP a ajouté la possibilité de gérer les limites, qui prend en charge l'écriture des limites dans la table de données à partir d'une table de limites, je n'améliorerai pas le complément.Cependant, ci-dessous se trouve un script simple qui devrait vous donner un début et un script qui lira à partir d'une table de données de limites et ajoutera des unités aux colonnes d'une autre table
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 : Écrire des limites dans une table de données à partir d'une table de limites@txnelson C'est un addon fantastique, Pouvons-nous ajouter des "unités" pour la colonne à partir d'une autre fiche technique ? avez-vous un script JSL amélioré pour cela?
Merci,
Venkat
Re : Écrire des limites dans une table de données à partir d'une table de limitesParfait! cela fonctionne correctement. Veuillez continuer à créer cette version du code pour l'ajout ...
Re : Écrire des limites dans une table de données à partir d'une table de limitesVoici une version qui, je pense, corrigera le problème.Essayez-le et revenez-moi si cela résout votre problème.Je publierai ensuite le nouveau complément sur l'échange de fichiers
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 : Écrire des limites dans une table de données à partir d'une table de limitesSalut txnelson , Merci pour votre scénario. Lorsque je l'exécute, il s'exécute sans aucune erreur. Cependant, lorsque je regarde les limites des spécifications, pour 'certaines des colonnes', le script attribue des valeurs limites erronées... J'ai vérifié les noms de colonnes et la dénomination n'est pas le problème... Je ne peux pas comprendre pourquoi ça marche bien pour certaines colonnes et certains coulmnsn pas,,,,, est-ce que je manque quelque chose ? Pouvez-vous aider ?
Re : Écrire des limites dans une table de données à partir d'une table de limitesMerci pour le magnifique scénario.Re : Écrire des limites dans une table de données à partir d'une table de limitesComplément absolument génial. Grand gain de temps. D'autant plus que l'option "Afficher comme lignes de référence du graphique" est automatiquement activée.
Merci d'avoir partagé.
Philippe
Re : Écrire des limites dans une table de données à partir d'une table de limitesMerci pour votre commentaire.En ce qui concerne l'exécution du complément dans le cadre de JSL, vous devrez creuser dans le code et extraire la partie active.Le code est structuré en fonctions et en EXPR, ce qui devrait vous permettre de supprimer facilement le code appelé à partir de la boîte de dialogue.
Re : Écrire des limites dans une table de données à partir d'une table de limitesSuper complément ! J'allais juste écrire un peu la même chose pour un projet.
Est-il possible d'exécuter le complément via JSL ? Je souhaite automatiser le processus d'ajout de limites de spécifications dans mon application.
Re : Écrire des limites dans une table de données à partir d'une table de limites@MikeD_Anderson est correct. Le complément nécessite JMP 12 ou version ultérieure
Re : Écrire des limites dans une table de données à partir d'une table de limitesVous pouvez vérifier la compatibilité de la version avec le complément. Il aurait pu le limiter à 12 ou plus récent. Vous voudrez peut-être vérifier auprès de votre administrateur de licence. Je suis presque sûr que vous avez accès aux versions 12 et 13… il y avait beaucoup d'améliorations que vous pourriez trouver très utiles.
Meilleur,
M
Re : Écrire des limites dans une table de données à partir d'une table de limitesce fichier .jmpaddin n'est pas installé sur mon ordinateur.
Quelqu'un a ce problème?
/Onti
