import numpy as np import pandas as pd import warnings import os from sklearn.pipeline import Pipeline from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder,KBinsDiscretizer from skmultilearn.model_selection import iterative_train_test_split from scipy import interpolate from scipy.stats import qmc def check_bounds(sample,bounds): sample_ok = True for i in range(len(sample)): if not bounds[i][0] <= sample[i] <= bounds[i][1]: sample_ok = False return sample_ok def check_feasibility(p_set:list,bounds:list)->bool: """ Checks if a set of parameters is suitable for geometry generation """ # Calculate forward displacement of wingtip forward_disp = -np.tan(np.deg2rad(p_set[4]))*1000 # Check that angle of attack and twist angle sum does not exceed limits if not bounds[0][0] < p_set[0] + p_set[1] < bounds[0][1]: return False # Check forward displacement if forward_disp + p_set[2] > bounds[2][1]: return False # Check backwards displacement if forward_disp + p_set[2] < bounds[3][0]: return False # Check if outboard chord is too large if p_set[3] - p_set[2] - forward_disp > bounds[3][1]: return False return True def check_feasibility_batch(points,bounds): """ Checks if each set of parameters is suitable for geometry generation """ feas_bounds = np.array([check_bounds(point,bounds) for point in points]) feas_constrains = np.array([check_feasibility(point,bounds) for point in points]) return np.logical_and(feas_bounds,feas_constrains) def build_F_inv(p_index, p_bounds, sens_funcs, num_points=200): a, b = p_bounds[p_index] # grid on axis i xs = np.linspace(a, b, num_points) ds = sens_funcs[p_index](xs) # sensitivities at grid points ds = np.maximum(ds, 1e-12) # Ensure no zeros are present, to avoid duplicates in cdf if np.all(ds == ds[0]): ds = np.ones_like(ds) pdf = ds cdf_vals = np.cumsum(pdf) cdf_vals = cdf_vals / cdf_vals[-1] # normalize to [0,1] inv_cdf = interpolate.make_interp_spline(cdf_vals,xs,k=1) def F_inv(u): u = np.clip(u, 0.0, 1.0) return inv_cdf(u) return F_inv # ----------------------------- # Warp using empirical per-axis CDF inverse # ----------------------------- def warp_samples(X, F_inv_funcs): M = X.shape[0] X_warped = np.empty_like(X) for i in range(len(F_inv_funcs)): X_warped[:, i] = F_inv_funcs[i](X[:, i]) return X_warped def clip_samples(X,bounds): for i in range(len(bounds)): X[:,i] = np.interp(X[:,i],(X[:,i].min(),X[:,i].max()),(bounds[i][0],bounds[i][1])) return X def compute_sample_weights(samples, sens_funcs, bounds): """ Compute importance weights based on sensitivity functions. Samples with higher sensitivity values get higher weights. Args: samples: Array of shape (n_samples, n_dims) sens_funcs: List of sensitivity functions, one per dimension bounds: Parameter bounds Returns: weights: Array of shape (n_samples,) with normalized weights """ n_samples = samples.shape[0] weights = np.ones(n_samples) # Multiply sensitivity values across all dimensions for i in range(samples.shape[1]): sens_values = sens_funcs[i](samples[:, i]) # Ensure positive values sens_values = np.maximum(sens_values, 1e-12) weights *= sens_values # Normalize weights to sum to 1 weights = weights / weights.sum() return weights # ----------------------------- # Maximin subset selection in warped space # ----------------------------- def maximin_subset(points, k): n = points.shape[0] selected = [] available = np.ones(n,dtype=bool) # 1) Start with the point farthest from the centroid mean_pt = np.mean(points, axis=0) dists_to_mean = np.linalg.norm(points - mean_pt, axis=1) first = int(np.argmax(dists_to_mean)) selected.append(first) available[first] = False # 2) Iteratively add points maximizing distance to the current set for _ in range(1, k): # Compute, for each candidate in 'remaining', the distance to its nearest # point in 'selected' cand_indices = np.nonzero(available)[0] cand_points = points[cand_indices] # shape (m, d) selected_points = points[np.array(selected)] # shape (s, d) # Compute pairwise distances: (m, s) dist_matrix = np.linalg.norm( cand_points[:, None, :] - selected_points[None, :, :], axis=2 ) # For each candidate, distance to the nearest selected point min_dist_to_selected = dist_matrix.min(axis=1) # Pick the candidate with the maximum of these minima pos = int(np.argmax(min_dist_to_selected)) chosen = int(cand_indices[pos]) selected.append(chosen) available[chosen] = False return np.array(selected, dtype=int) def weighted_maximin_selection(points, weights, k): """ Select k points using weighted maximin strategy. Combines space coverage (maximin) with importance sampling (weights). Args: points: Array of shape (n_samples, n_dims) weights: Array of shape (n_samples,) with sample importance weights k: Number of points to select Returns: selected_indices: Array of selected point indices """ n = points.shape[0] selected = [] available = np.ones(n, dtype=bool) # 1) Start with weighted probability selection for the first point # This ensures we start in a high-sensitivity region probs = weights / weights.sum() first = np.random.choice(n, p=probs) selected.append(first) available[first] = False # 2) Iteratively add points balancing distance and weight for _ in range(1, k): cand_indices = np.nonzero(available)[0] if len(cand_indices) == 0: break cand_points = points[cand_indices] cand_weights = weights[cand_indices] selected_points = points[np.array(selected)] # Compute pairwise distances to selected points dist_matrix = np.linalg.norm( cand_points[:, None, :] - selected_points[None, :, :], axis=2 ) # For each candidate, distance to the nearest selected point min_dist_to_selected = dist_matrix.min(axis=1) # Normalize distances to [0, 1] if min_dist_to_selected.max() > 0: norm_dists = min_dist_to_selected / min_dist_to_selected.max() else: norm_dists = np.ones_like(min_dist_to_selected) # Normalize weights to [0, 1] if cand_weights.max() > 0: norm_weights = cand_weights / cand_weights.max() else: norm_weights = np.ones_like(cand_weights) # Combined score: balance distance (70%) and weight (30%) # Adjust these ratios to prioritize coverage vs sensitivity scores = 0.7 * norm_dists + 0.3 * norm_weights # Pick the candidate with the highest combined score pos = int(np.argmax(scores)) chosen = int(cand_indices[pos]) selected.append(chosen) available[chosen] = False return np.array(selected, dtype=int) def weighted_maximin_selection_with_weight(points, weights, k, coverage_weight=0.5): """ Select k points using weighted maximin strategy with adjustable balance. Combines space coverage (maximin) with importance sampling (weights). Args: points: Array of shape (n_samples, n_dims) weights: Array of shape (n_samples,) with sample importance weights k: Number of points to select coverage_weight: Weight for coverage (0-1). Higher = more coverage, less sensitivity bias Returns: selected_indices: Array of selected point indices """ n = points.shape[0] selected = [] available = np.ones(n, dtype=bool) # 1) Start with weighted probability selection for the first point probs = weights / weights.sum() first = np.random.choice(n, p=probs) selected.append(first) available[first] = False # 2) Iteratively add points balancing distance and weight sensitivity_weight = 1.0 - coverage_weight for i in range(1, k): if i % 10 == 0: print(f"Selected {i} of {k} samples...") cand_indices = np.nonzero(available)[0] if len(cand_indices) == 0: break cand_points = points[cand_indices] cand_weights = weights[cand_indices] selected_points = points[np.array(selected)] # Compute pairwise distances to selected points dist_matrix = np.linalg.norm( cand_points[:, None, :] - selected_points[None, :, :], axis=2 ) min_dist_to_selected = dist_matrix.min(axis=1) # Normalize distances to [0, 1] if min_dist_to_selected.max() > 0: norm_dists = min_dist_to_selected / min_dist_to_selected.max() else: norm_dists = np.ones_like(min_dist_to_selected) # Normalize weights to [0, 1] if cand_weights.max() > 0: norm_weights = cand_weights / cand_weights.max() else: norm_weights = np.ones_like(cand_weights) # Combined score with adjustable balance scores = coverage_weight * norm_dists + sensitivity_weight * norm_weights # Pick the candidate with the highest combined score pos = int(np.argmax(scores)) chosen = int(cand_indices[pos]) selected.append(chosen) available[chosen] = False return np.array(selected, dtype=int) def iterative_split(samples, N, M, bound_names, max_attempts = 12): df = pd.DataFrame(data=samples, columns=bound_names) continuos_cols = [c for c in bound_names if c in ["CS","OS"]] with warnings.catch_warnings(record=True) as rw: bin_numeric = KBinsDiscretizer(n_bins=20,encode="ordinal",strategy='uniform') one_hot_encode = OneHotEncoder(handle_unknown="error",sparse_output=False,) col_trans1 = ColumnTransformer(transformers=[("bin_numeric",bin_numeric,continuos_cols)],remainder="passthrough",verbose_feature_names_out=False) col_trans2 = ColumnTransformer(transformers=[("one_hot_encode",one_hot_encode,df.columns)],remainder="drop",verbose_feature_names_out=False) pp = Pipeline([("col_trans1",col_trans1),("col_trans2",col_trans2)]) pp.set_output(transform="pandas") one_hot_labels : pd.DataFrame = pp.fit_transform(df) # type: ignore # Converting to numpy df = df.to_numpy() one_hot_labels = one_hot_labels.to_numpy() # type: ignore # Setup split parameters subset_size = N/len(samples) subset = [] attempt = 1 # Loop to ensure that the extracted subset lenght is correct while attempt < max_attempts: # Split data _,_,subset,_ = iterative_train_test_split(df,one_hot_labels,subset_size) if len(subset) < N: if attempt == max_attempts: print(f"Failed to obtain desired number of samples!") subset_size += 0.025 attempt += 1 else: break print(f"Obtained a subset with {len(subset)} samples in {attempt} attempts!") return subset def generate_feasible_samples(bounds, sens_funcs, N=128, M=512, max_attempts=12, p_bases=np.array([0.5,0.5,5,5,1]), coverage_weight=0.5): """ Two-stage sampling approach: 1. Generate feasible samples with uniform space coverage 2. Select N samples using weighted maximin (balancing coverage and sensitivity) Args: bounds: Parameter bounds array sens_funcs: List of sensitivity functions N: Target number of samples to select M: Initial candidate pool size max_attempts: Maximum attempts to generate enough feasible samples p_bases: Rounding bases for each parameter coverage_weight: Weight for space coverage vs sensitivity (0.5 = equal importance) Returns: X_selected: Selected samples M: Final candidate pool size used """ if len(bounds) != len(sens_funcs): raise ValueError(f"Expected bounds and sens_funcs to have the same length. Got {bounds.shape} and {sens_funcs.shape}") # Filtering input bounds = np.asarray(bounds,dtype=float) d = len(bounds) # Setup sampling loop - generate enough feasible samples for selection X_feasible = [] target_feasible = N * 3 # Generate 3x more samples than needed for good selection pool for attempt in range(1, max_attempts+1): # STAGE 1: Generate uniform Sobol samples for space coverage sampler = qmc.Sobol(d, scramble=True) X = sampler.random(n=M) # Scale to parameter bounds X_scaled = qmc.scale(X, bounds[:, 0]-p_bases/2, bounds[:, 1]+p_bases/2) # Round to closest acceptable value X_rounded = round_samples(X_scaled, p_bases) # Remove duplicates X_unique = np.unique(X_rounded, axis=0) # Applying feasibility filter feas_mask = check_feasibility_batch(X_unique, bounds) X_feasible = X_unique[feas_mask] # Check if we have enough feasible samples if len(X_feasible) >= target_feasible: print(f"Generated {len(X_feasible)} feasible samples in {attempt} attempts") break else: # Increase M if not enough points are feasible M = int(M * 2) if attempt == max_attempts: print(f"Warning: Only generated {len(X_feasible)} feasible samples (target was {target_feasible})") if len(X_feasible) == 0: raise ValueError("Could not generate any feasible samples with the given settings") elif len(X_feasible) < N: raise ValueError(f"Only {len(X_feasible)} feasible samples could be generated, but N={N} required. Increase M or max_attempts.") # STAGE 2: Select N samples using weighted maximin selection print(f"Selecting {N} samples from {len(X_feasible)} feasible candidates...") weights = compute_sample_weights(X_feasible, sens_funcs, bounds) # Adjust the weighted_maximin_selection to use the coverage_weight parameter # (We'll pass it directly in the call) selected_indices = weighted_maximin_selection_with_weight(X_feasible, weights, N, coverage_weight) X_selected = X_feasible[selected_indices] print(f"Selected {len(X_selected)} samples balancing space coverage and sensitivity") return X_selected, M def validate_samples(samples,bounds,sens_funcs): print("Checking if constraints were respected") valid = check_feasibility_batch(samples,bounds) if any(valid == False): raise ValueError("At least one samples does not respect the provided constraints") print("Checking if any samples are identical") if len(np.unique(samples, axis=0)) != len(samples): raise ValueError("At least one identical pair of parameters found") print("Validation complete") def round_samples(samples,p_bases): for i in range(len(p_bases)): samples[:,i] = round_to_base(samples[:,i],p_bases[i]) return samples def round_to_base(x,base=1): return base*np.rint(x/base) def main(): bound_names = ["CA","OA","CS","OS","AF"] N = 50 # target samples M = 2048 # candidate pool size csv_name = "samples_filling.csv" csv_path = "." csv_path = os.path.join(csv_path,csv_name) # Define parameter bounds bounds = np.array([ [-10.0, 5.0], # CA [-10.0, 10.0], # OA [550.0, 700.0], # CS [350.0, 700.0], # OS [-8.5, 20.0] # AF ], dtype=float) d = bounds.shape[0] # ========== SENSITIVITY FUNCTION DATA ========== # Define your parameter values, lift coefficients (CL), and drag coefficients (CD) # Aerodynamic efficiency will be calculated as CL/CD # s1: CA parameter s1_param_values = np.array([-10,-8,-6,-4,-2,0,2,4,5]) s1_lift = np.array([2.71597,2.59168,2.38756,2.11036,1.79931,1.46873,1.13276,0.79852,0.63399]) # Replace with CL values s1_drag = np.array([0.19559,0.16673,0.13793,0.11181,0.08745,0.06607,0.04852,0.03574,0.03121]) # Replace with CD values # s2: OA parameter s2_param_values = np.array([-10,-8,-6,-4,-2,0,2,4,6,8,10]) s2_lift = np.array([2.11753,2.00106,1.87441,1.74326,1.60771,1.46873,1.32822,1.18505,1.03937,0.88601,0.72393]) # Replace with CL values s2_drag = np.array([0.12137,0.10840,0.09681,0.08580,0.07550,0.06607,0.05760,0.05028,0.04426,0.04071,0.04110]) # Replace with CD values # s3: CS parameter s3_param_values = np.array([700,675,650,625,600,575,550]) s3_lift = np.array([1.59557,1.56641,1.53579,1.50281,1.46873,1.43109,1.39120]) # Replace with CL values s3_drag = np.array([0.07392,0.07200,0.07008,0.06806,0.06607,0.06395,0.06179]) # Replace with CD values # s4: OS parameter s4_param_values = np.array([700,650,600,550,500,455,400,350]) s4_lift = np.array([1.76696,1.72398,1.67319,1.60908,1.53883,1.46873,1.37725,1.29316]) # Replace with CL values s4_drag = np.array([0.08746,0.08379,0.07981,0.07517,0.07047,0.06607,0.06063,0.05588]) # Replace with CD values # s5: AF parameter s5_param_values = np.array([-8.5,-4,0,4,8,12,16,20]) s5_lift = np.array([1.31019,1.35985,1.39354,1.42229,1.45279,1.48344,1.50923,1.53197]) # Replace with CL values s5_drag = np.array([0.05940,0.06138,0.06270,0.06387,0.06528,0.06673,0.06792,0.06904]) # Replace with CD values # ========== CREATE INTERPOLATORS FOR LIFT AND DRAG (built once for efficiency) ========== _s1_lift_interp = interpolate.make_interp_spline(s1_param_values, s1_lift, k=3) _s1_drag_interp = interpolate.make_interp_spline(s1_param_values, s1_drag, k=3) _s1_lift_deriv = _s1_lift_interp.derivative() _s1_drag_deriv = _s1_drag_interp.derivative() _s2_lift_interp = interpolate.make_interp_spline(s2_param_values, s2_lift, k=3) _s2_drag_interp = interpolate.make_interp_spline(s2_param_values, s2_drag, k=3) _s2_lift_deriv = _s2_lift_interp.derivative() _s2_drag_deriv = _s2_drag_interp.derivative() _s3_lift_interp = interpolate.make_interp_spline(np.flip(s3_param_values), np.flip(s3_lift), k=3) _s3_drag_interp = interpolate.make_interp_spline(np.flip(s3_param_values), np.flip(s3_drag), k=3) _s3_lift_deriv = _s3_lift_interp.derivative() _s3_drag_deriv = _s3_drag_interp.derivative() _s4_lift_interp = interpolate.make_interp_spline(np.flip(s4_param_values), np.flip(s4_lift), k=3) _s4_drag_interp = interpolate.make_interp_spline(np.flip(s4_param_values), np.flip(s4_drag), k=3) _s4_lift_deriv = _s4_lift_interp.derivative() _s4_drag_deriv = _s4_drag_interp.derivative() _s5_lift_interp = interpolate.make_interp_spline(s5_param_values, s5_lift, k=3) _s5_drag_interp = interpolate.make_interp_spline(s5_param_values, s5_drag, k=3) _s5_lift_deriv = _s5_lift_interp.derivative() _s5_drag_deriv = _s5_drag_interp.derivative() # ========== SENSITIVITY FUNCTIONS ========== def s1(p): return np.abs(_s1_lift_deriv(p)) + np.abs(_s1_drag_deriv(p)) def s2(p): return np.abs(_s2_lift_deriv(p)) + np.abs(_s2_drag_deriv(p)) def s3(p): return np.abs(_s3_lift_deriv(p)) + np.abs(_s3_drag_deriv(p)) def s4(p): return np.abs(_s4_lift_deriv(p)) + np.abs(_s4_drag_deriv(p)) def s5(p): return np.abs(_s5_lift_deriv(p)) + np.abs(_s5_drag_deriv(p)) sens_funcs = [s1, s2, s3, s4, s5] # Generate the samples using two-stage approach # This now returns exactly N samples that balance space coverage and sensitivity samples,M = generate_feasible_samples(bounds=bounds,sens_funcs=sens_funcs,N=N,M=M,coverage_weight=0.5) # Validate the samples validate_samples(samples,bounds,sens_funcs) # Add column for profile profile_sampler = qmc.Sobol(1,scramble=True) profile_samples = profile_sampler.random(n=len(samples)) profile_samples = qmc.scale(profile_samples,0.5,12.5) profile_samples = round_to_base(profile_samples,base=1) samples = np.c_[profile_samples,samples] print("Saving to file...") try: np.savetxt(csv_name,samples,delimiter=",",header="P,"+",".join(bound_names),fmt='%f') print(f"Saved {csv_name}!") except: raise RuntimeError("Could not save .csv file") if __name__ == "__main__": main()