Measurement System Analysis skill for Gage R&R studies with variance component analysis.
Conducts Gage R&R studies using ANOVA to analyze measurement system repeatability, reproducibility, and part variation.
npx claudepluginhub a5c-ai/babysitterThis skill is limited to using the following tools:
You are gage-rr-analyzer - a specialized skill for conducting Measurement System Analysis (MSA) and Gage R&R studies.
This skill enables AI-powered MSA including:
from dataclasses import dataclass
from typing import List
import numpy as np
@dataclass
class GageRRStudyDesign:
"""
Design parameters for Gage R&R study
"""
num_parts: int = 10 # Typically 10
num_operators: int = 3 # Typically 2-3
num_trials: int = 3 # Typically 2-3 measurements per part per operator
def total_measurements(self):
return self.num_parts * self.num_operators * self.num_trials
def randomized_run_order(self):
"""Generate randomized measurement order"""
runs = []
for part in range(1, self.num_parts + 1):
for operator in range(1, self.num_operators + 1):
for trial in range(1, self.num_trials + 1):
runs.append({
"part": part,
"operator": operator,
"trial": trial
})
np.random.shuffle(runs)
return runs
def create_study_worksheet(design: GageRRStudyDesign):
"""
Create data collection worksheet
"""
runs = design.randomized_run_order()
worksheet = {
"study_info": {
"gage_name": "",
"gage_number": "",
"study_date": "",
"characteristic": "",
"specification": "",
"resolution": ""
},
"operators": [f"Operator_{i}" for i in range(1, design.num_operators + 1)],
"parts": [f"Part_{i}" for i in range(1, design.num_parts + 1)],
"run_order": runs,
"data_entry": []
}
return worksheet
import pandas as pd
from scipy import stats
def gage_rr_anova(data, parts_col='Part', operators_col='Operator', measurement_col='Measurement'):
"""
Gage R&R analysis using ANOVA method
data: DataFrame with Part, Operator, and Measurement columns
"""
df = pd.DataFrame(data)
# Get design parameters
n_parts = df[parts_col].nunique()
n_operators = df[operators_col].nunique()
n_trials = len(df) // (n_parts * n_operators)
# Calculate means
grand_mean = df[measurement_col].mean()
part_means = df.groupby(parts_col)[measurement_col].mean()
operator_means = df.groupby(operators_col)[measurement_col].mean()
cell_means = df.groupby([parts_col, operators_col])[measurement_col].mean()
# Sum of Squares
SS_total = ((df[measurement_col] - grand_mean) ** 2).sum()
SS_part = n_operators * n_trials * ((part_means - grand_mean) ** 2).sum()
SS_operator = n_parts * n_trials * ((operator_means - grand_mean) ** 2).sum()
# SS Interaction
SS_cell = n_trials * ((cell_means - grand_mean) ** 2).sum()
SS_interaction = SS_cell - SS_part - SS_operator
# SS Error (repeatability)
SS_error = SS_total - SS_part - SS_operator - SS_interaction
# Degrees of freedom
df_part = n_parts - 1
df_operator = n_operators - 1
df_interaction = df_part * df_operator
df_error = n_parts * n_operators * (n_trials - 1)
df_total = len(df) - 1
# Mean Squares
MS_part = SS_part / df_part
MS_operator = SS_operator / df_operator
MS_interaction = SS_interaction / df_interaction if df_interaction > 0 else 0
MS_error = SS_error / df_error
# F-statistics
F_part = MS_part / MS_interaction if MS_interaction > 0 else MS_part / MS_error
F_operator = MS_operator / MS_interaction if MS_interaction > 0 else MS_operator / MS_error
F_interaction = MS_interaction / MS_error if MS_interaction > 0 else 0
# p-values
p_part = 1 - stats.f.cdf(F_part, df_part, df_interaction if MS_interaction > 0 else df_error)
p_operator = 1 - stats.f.cdf(F_operator, df_operator, df_interaction if MS_interaction > 0 else df_error)
p_interaction = 1 - stats.f.cdf(F_interaction, df_interaction, df_error) if F_interaction > 0 else 1
anova_table = {
"Part": {"SS": SS_part, "df": df_part, "MS": MS_part, "F": F_part, "p": p_part},
"Operator": {"SS": SS_operator, "df": df_operator, "MS": MS_operator, "F": F_operator, "p": p_operator},
"Part*Operator": {"SS": SS_interaction, "df": df_interaction, "MS": MS_interaction, "F": F_interaction, "p": p_interaction},
"Repeatability": {"SS": SS_error, "df": df_error, "MS": MS_error},
"Total": {"SS": SS_total, "df": df_total}
}
return anova_table, {
"n_parts": n_parts,
"n_operators": n_operators,
"n_trials": n_trials,
"grand_mean": grand_mean
}
def calculate_variance_components(anova_table, design_params):
"""
Extract variance components from ANOVA
"""
n = design_params['n_trials']
k = design_params['n_operators']
p = design_params['n_parts']
MS_part = anova_table['Part']['MS']
MS_operator = anova_table['Operator']['MS']
MS_interaction = anova_table['Part*Operator']['MS']
MS_error = anova_table['Repeatability']['MS']
# Variance components
var_repeatability = MS_error
# Check if interaction is significant (p < 0.25 typically)
if anova_table['Part*Operator']['p'] < 0.25:
var_interaction = max(0, (MS_interaction - MS_error) / n)
var_operator = max(0, (MS_operator - MS_interaction) / (n * p))
else:
# Pool interaction with error
var_interaction = 0
pooled_ms = (anova_table['Part*Operator']['SS'] + anova_table['Repeatability']['SS']) / \
(anova_table['Part*Operator']['df'] + anova_table['Repeatability']['df'])
var_operator = max(0, (MS_operator - pooled_ms) / (n * p))
var_repeatability = pooled_ms
var_part = max(0, (MS_part - MS_operator) / (n * k)) if MS_part > MS_operator else \
max(0, (MS_part - MS_error) / (n * k))
# Reproducibility = Operator + Interaction
var_reproducibility = var_operator + var_interaction
# Gage R&R = Repeatability + Reproducibility
var_grr = var_repeatability + var_reproducibility
# Total variation
var_total = var_grr + var_part
return {
"repeatability": var_repeatability,
"reproducibility": var_reproducibility,
"operator": var_operator,
"interaction": var_interaction,
"gage_rr": var_grr,
"part_to_part": var_part,
"total": var_total
}
def calculate_grr_metrics(variance_components, tolerance=None):
"""
Calculate Gage R&R metrics
tolerance: specification range (USL - LSL) for %Tolerance calculation
"""
vc = variance_components
# Standard deviations (6*sigma for 99.73% spread)
std_repeatability = np.sqrt(vc['repeatability'])
std_reproducibility = np.sqrt(vc['reproducibility'])
std_grr = np.sqrt(vc['gage_rr'])
std_part = np.sqrt(vc['part_to_part'])
std_total = np.sqrt(vc['total'])
# Study variation (6 * sigma)
sv_repeatability = 6 * std_repeatability
sv_reproducibility = 6 * std_reproducibility
sv_grr = 6 * std_grr
sv_part = 6 * std_part
sv_total = 6 * std_total
metrics = {
"study_variation": {
"repeatability": sv_repeatability,
"reproducibility": sv_reproducibility,
"gage_rr": sv_grr,
"part_to_part": sv_part,
"total": sv_total
},
"percent_contribution": {
"repeatability": vc['repeatability'] / vc['total'] * 100,
"reproducibility": vc['reproducibility'] / vc['total'] * 100,
"gage_rr": vc['gage_rr'] / vc['total'] * 100,
"part_to_part": vc['part_to_part'] / vc['total'] * 100
},
"percent_study_variation": {
"repeatability": sv_repeatability / sv_total * 100,
"reproducibility": sv_reproducibility / sv_total * 100,
"gage_rr": sv_grr / sv_total * 100,
"part_to_part": sv_part / sv_total * 100
}
}
# %Tolerance (if specification provided)
if tolerance:
metrics["percent_tolerance"] = {
"repeatability": sv_repeatability / tolerance * 100,
"reproducibility": sv_reproducibility / tolerance * 100,
"gage_rr": sv_grr / tolerance * 100
}
# Number of Distinct Categories
ndc = int(1.41 * (std_part / std_grr)) if std_grr > 0 else np.inf
metrics["ndc"] = max(1, ndc)
return metrics
def evaluate_measurement_system(metrics):
"""
Evaluate measurement system against acceptance criteria
"""
grr_pct_sv = metrics['percent_study_variation']['gage_rr']
grr_pct_tol = metrics.get('percent_tolerance', {}).get('gage_rr', grr_pct_sv)
ndc = metrics['ndc']
evaluation = {
"grr_percent": grr_pct_sv,
"ndc": ndc,
"assessment": "",
"recommendations": []
}
# AIAG guidelines
if grr_pct_sv < 10:
evaluation["assessment"] = "ACCEPTABLE"
evaluation["recommendations"].append("Measurement system acceptable for use")
elif grr_pct_sv < 30:
evaluation["assessment"] = "MARGINAL"
evaluation["recommendations"].append("May be acceptable depending on application")
evaluation["recommendations"].append("Consider improvement opportunities")
else:
evaluation["assessment"] = "UNACCEPTABLE"
evaluation["recommendations"].append("Measurement system requires improvement")
evaluation["recommendations"].append("Do not use for process control until improved")
# NDC evaluation
if ndc < 2:
evaluation["ndc_assessment"] = "Cannot distinguish between parts"
evaluation["recommendations"].append("Measurement system cannot discriminate parts")
elif ndc < 5:
evaluation["ndc_assessment"] = "Marginal discrimination"
evaluation["recommendations"].append("Limited ability to distinguish between parts")
else:
evaluation["ndc_assessment"] = "Good discrimination"
# Component analysis
pct_repeat = metrics['percent_study_variation']['repeatability']
pct_reprod = metrics['percent_study_variation']['reproducibility']
if pct_repeat > pct_reprod * 2:
evaluation["primary_issue"] = "Repeatability (Equipment Variation)"
evaluation["recommendations"].append("Focus on gage maintenance, fixtures, or replacement")
elif pct_reprod > pct_repeat * 2:
evaluation["primary_issue"] = "Reproducibility (Appraiser Variation)"
evaluation["recommendations"].append("Focus on operator training and standard procedures")
else:
evaluation["primary_issue"] = "Both components significant"
evaluation["recommendations"].append("Address both equipment and operator variation")
return evaluation
def generate_grr_report(data, parts_col, operators_col, measurement_col,
tolerance=None, characteristic_name=""):
"""
Generate complete Gage R&R report
"""
# Run analysis
anova_table, design_params = gage_rr_anova(data, parts_col, operators_col, measurement_col)
variance_components = calculate_variance_components(anova_table, design_params)
metrics = calculate_grr_metrics(variance_components, tolerance)
evaluation = evaluate_measurement_system(metrics)
report = {
"study_info": {
"characteristic": characteristic_name,
"tolerance": tolerance,
"parts": design_params['n_parts'],
"operators": design_params['n_operators'],
"trials": design_params['n_trials'],
"total_measurements": len(data)
},
"anova_table": anova_table,
"variance_components": variance_components,
"metrics": metrics,
"evaluation": evaluation,
"conclusion": {
"grr_result": evaluation['assessment'],
"grr_percent": round(metrics['percent_study_variation']['gage_rr'], 2),
"ndc": metrics['ndc'],
"primary_contributor": evaluation['primary_issue']
}
}
return report
This skill integrates with the following processes:
statistical-process-control-implementation.jsdesign-of-experiments-execution.js{
"study_info": {
"characteristic": "Diameter",
"tolerance": 0.05,
"parts": 10,
"operators": 3,
"trials": 3
},
"metrics": {
"percent_study_variation": {
"repeatability": 8.5,
"reproducibility": 12.3,
"gage_rr": 15.2,
"part_to_part": 98.8
},
"ndc": 9
},
"evaluation": {
"assessment": "MARGINAL",
"primary_issue": "Reproducibility (Appraiser Variation)"
},
"recommendations": [
"Focus on operator training",
"Standardize measurement procedure"
]
}
Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Search, retrieve, and install Agent Skills from the prompts.chat registry using MCP tools. Use when the user asks to find skills, browse skill catalogs, install a skill for Claude, or extend Claude's capabilities with reusable AI agent components.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.