Analytical

Analytical Workflow

Steps in Analysis

1. Problem Definition
   └─> What needs to be measured?

2. Method Selection
   └─> Choose appropriate technique

3. Sampling
   └─> Representative sample collection

4. Sample Preparation
   └─> Extraction, digestion, cleanup

5. Measurement
   └─> Instrumental analysis

6. Data Analysis
   └─> Calibration, calculations

7. Reporting
   └─> Results, uncertainty, conclusions

Spectroscopy

Electromagnetic Spectrum

class SpectroscopicAnalysis:
    """Spectroscopy calculations"""
    
    # Beer-Lambert Law
    def beer_lambert(self, absorbance, path_length, concentration):
        """
        A = ε × b × c
        A = absorbance
        ε = molar absorptivity (L/mol·cm)
        b = path length (cm)
        c = concentration (mol/L)
        """
        return absorbance / (path_length * concentration)
    
    def concentration_from_absorbance(self, A, epsilon, b):
        """
        c = A / (ε × b)
        """
        return A / (epsilon * b)
    
    def multiple_wavelength(self, wavelengths, absorbances):
        """
        Simultaneous determination (multi-component)
        [A] = ε⁻¹ × A_total
        """
        pass

Atomic Spectroscopy

Chromatography

Column Chromatography

class ChromatographicAnalysis:
    """Chromatography calculations"""
    
    def retention_factor(self, t_r, t_0):
        """
        k' = (t_R - t_0) / t_0
        
        t_R = retention time
        t_0 = dead time
        """
        return (t_r - t_0) / t_0
    
    def selectivity_factor(self, k1, k2):
        """
        α = k2 / k1 (for k2 > k1)
        """
        return k2 / k1
    
    def number_of_theoretical_plates(self, t_r, w):
        """
        N = 16 × (t_R/w)²
        
        w = peak width at baseline
        """
        return 16 * (t_r / w) ** 2
    
    def resolution(self, t_r1, t_r2, w1, w2):
        """
        R_s = 2(t_R2 - t_R1)/(w1 + w2)
        
        R_s < 1: Overlapping
        R_s = 1: Partially resolved  
        R_s > 1.5: Baseline resolved
        """
        return 2 * (t_r2 - t_r1) / (w1 + w2)
    
    def plate_height(self, L, N):
        """
        H = L / N
        """
        return L / N

HPLC Parameters

Electrochemistry

Electroanalytical Methods

class ElectrochemicalAnalysis:
    """Electrochemistry calculations"""
    
    # Nernst equation
    def nernst_potential(self, E0, R, T, n, activities):
        """
        E = E₀ + (RT/nF) × ln(Q)
        at 25°C: E = E₀ + (0.0592/n) × log(Q)
        """
        import numpy as np
        
        R = 8.314  # J/mol·K
        T = 298.15  # K
        F = 96485   # C/mol
        
        return E0 + (R * T / (n * F)) * np.log(activities)
    
    # Faraday's laws
    def coulomb_to_moles(self, charge, n):
        """
        n = Q / (n × F)
        
        n = moles of electrons
        n = electrons per reaction
        F = Faraday constant
        """
        return charge / (n * 96485)

Method Validation

Validation Parameters

class MethodValidation:
    """Method validation calculations"""
    
    def limit_of_detection(self, blank_measurements, slope):
        """
        LOD = 3 × σ_blank / slope
        """
        import numpy as np
        
        sigma = np.std(blank_measurements)
        lod = 3 * sigma / slope
        
        return lod
    
    def limit_of_quantitation(self, blank_measurements, slope):
        """
        LOQ = 10 × σ_blank / slope
        """
        import numpy as np
        
        sigma = np.std(blank_measurements)
        loq = 10 * sigma / slope
        
        return loq
    
    def recovery(self, measured, spiked, blank):
        """
        Recovery = (measured - blank) / spiked × 100%
        """
        return (measured - blank) / spiked * 100

Statistical Analysis

Error Analysis

class StatisticalAnalysis:
    """Statistical calculations"""
    
    def confidence_interval(self, values, confidence=0.95):
        """
        CI = x̄ ± t × s / √n
        
        t = t-statistic
        s = standard deviation
        n = number of measurements
        """
        import numpy as np
        from scipy import stats
        
        mean = np.mean(values)
        n = len(values)
        s = np.std(values, ddof=1)
        
        t_value = stats.t.ppf((1 + confidence) / 2, n - 1)
        
        margin = t_value * s / np.sqrt(n)
        
        return mean - margin, mean + margin
    
    def outlier_test(self, values, method='grubbs'):
        """
        Grubbs' test for outliers
        """
        import numpy as np
        from scipy import stats
        
        n = len(values)
        mean = np.mean(values)
        s = np.std(values, ddof=1)
        
        G = max(abs(values - mean)) / s
        
        t = stats.t.ppf(0.975, n - 2)
        G_critical = ((n - 1) / np.sqrt(n)) * np.sqrt(t**2 / (n - 2 + t**2))
        
        return G > G_critical
    
    def linear_regression(self, x, y):
        """
        y = mx + b with statistics
        """
        import numpy as np
        from scipy import stats
        
        slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
        
        return {
            "slope": slope,
            "intercept": intercept,
            "r_squared": r_value ** 2,
            "p_value": p_value,
            "standard_error": std_err
        }

Quality Assurance

Quality Control Charts

Reference Materials

Sample Preparation

Techniques

Common Errors to Avoid

1. Ignoring uncertainty — Always quantify measurement uncertainty
2. Inadequate calibration — Use appropriate standards
3. Not validating methods — Follow validation protocols
4. Ignoring matrix effects — Matrix-matched standards
5. Confusing precision with accuracy — Different concepts
6. Insufficient replicates — Need statistical power
7. Ignoring detection limits — Report appropriately
8. Poor documentation — GLP requires complete records