Gage Rr Analyzer

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 2. ANOVA Method (Crossed Study) 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 }

3. Variance Components Calculation 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[ 'PartOperator' ][ 'SS' ] + anova_table[ 'Repeatability' ][ 'SS' ]) /
(anova_table[ 'PartOperator' ][ '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 } 4. %GRR and Metrics Calculation 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

5. Acceptance Criteria Evaluation 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 6. Gage R&R Report Generation 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 Process Integration This skill integrates with the following processes: statistical-process-control-implementation.js design-of-experiments-execution.js Output Format { "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" ] } Best Practices Proper study design

• Minimum 10 parts, 3 operators, 2-3 trials Representative parts
• Select parts spanning expected range Blind measurements
• Operators shouldn't know which part Randomize order
• Prevent systematic bias Same conditions
• Control environmental factors Trained operators
• Ensure consistent technique Constraints Use parts representing production range Document measurement procedure Report all variance components Follow AIAG MSA guidelines