def wagen1_plot(c: Config): """Plot of wagen1 compared to given specification.""" plt.landscape() wheel_print = (0.31, 0.25) wheel_prints = [] for w_i in range(len(truck1.axle_distances) + 1): if w_i in [1, 2]: wheel_prints.append([wheel_print, wheel_print]) else: wheel_prints.append([wheel_print]) plt.subplot(1, 2, 1) xlim, ylim = topview_vehicle(truck1, wheel_prints=wheel_prints) plt.title("Truck 1 specification") plt.xlabel("Width (m)") plt.ylabel("Length (m)") plt.subplot(1, 2, 2) topview_vehicle(truck1, xlim=xlim, ylim=ylim) plt.title("Truck 1 in simulation") plt.xlabel("Width (m)") plt.ylabel("Length (m)") plt.savefig(c.get_image_path("vehicles", "wagen-1", bridge=False) + ".pdf") plt.close()
def temperature_effect_date(c: Config, month: str, vert: bool): temp = __init__.load(name=month) point = Point(x=51, y=0, z=-8.4) plt.landscape() def plot_hours(): if not vert: return label_set = False for dt in temp["datetime"]: if np.isclose(float(dt.hour + dt.minute), 0): label = None if not label_set: label = "Time at vertical line = 00:00" label_set = True plt.axvline(x=dt, linewidth=1, color="black", label=label) # Plot the temperature. plt.subplot(2, 1, 1) plot_hours() plt.scatter( temp["datetime"], temp["temp"], c=temp["missing"], cmap=mpl.cm.get_cmap("bwr"), s=1, ) plt.ylabel("Temperature (°C)") plt.xlabel("Date") plt.gcf().autofmt_xdate() plt.title(f"Temperature in {str(month[0]).upper()}{month[1:]}") plt.legend() # Plot the effect at a point. response_type = ResponseType.YTranslation plt.subplot(2, 1, 2) plot_hours() effect = __init__.effect( c=c, response_type=response_type, points=[point], temps=temp["temp"] )[0] plt.scatter( temp["datetime"], effect * 1000, c=temp["missing"], cmap=mpl.cm.get_cmap("bwr"), s=1, ) plt.ylabel(f"{response_type.name()} (mm)") plt.xlabel("Date") plt.gcf().autofmt_xdate() plt.title(f"{response_type.name()} to unit thermal loading in {month}") # Save. plt.tight_layout() plt.savefig(c.get_image_path("classify/temperature", f"{month}.png")) plt.savefig(c.get_image_path("classify/temperature", f"{month}.pdf")) plt.close()
def plot_distributions( response_array: List[float], response_type: ResponseType, titles: List[str], save: str, cols: int = 5, expected: List[List[float]] = None, xlim: Optional[Tuple[float, float]] = None, ): # Transpose so points are indexed first. response_array = response_array.T # response_array, unit_str = resize_and_units(response_array, response_type) num_points = response_array.shape[0] amax, amin = np.amax(response_array), np.amin(response_array) # Determine the number of rows. rows = int(num_points / cols) if rows != num_points / cols: print_w( f"Cols don't divide number of points {num_points}, cols = {cols}") rows += 1 # Plot fem. for i in range(num_points): plt.subplot(rows, cols, i + 1) plt.xlim((amin, amax)) plt.title(titles[i]) label = None if expected is not None: if response_array.shape != expected.shape: expected = expected.T expected, _ = resize_and_units(expected, response_type) assert response_array.shape == expected.shape label = chisquare(response_array[i], expected[i]) plt.hist(response_array[i], label=label) if label is not None: plt.legend() if xlim is not None: plt.xlim(xlim) plt.savefig(save) plt.close()
def experiment_noise(c: Config): """Plot displacement and strain noise from dynamic test 1""" ################ # Displacement # ################ plt.portrait() # Find points of each sensor. displa_labels = ["U13", "U26", "U29"] displa_points = [] for displa_label in displa_labels: sensor_x, sensor_z = _displa_sensor_xz(displa_label) displa_points.append(Point(x=sensor_x, y=0, z=sensor_z)) # For each sensor plot and estimate noise. side = 700 for s_i, displa_label in enumerate(displa_labels): # First plot the signal, and smoothed signal. plt.subplot(len(displa_points), 2, (s_i * 2) + 1) with open(f"validation/experiment/D1a-{displa_label}.txt") as f: data = list(map(float, f.readlines())) # Find the center of the plot, minimum point in first 15000 points. data_center = 0 for i in range(15000): if data[i] < data[data_center]: data_center = i data = data[data_center - side:data_center + side] smooth = savgol_filter(data, 31, 3) plt.plot(data, linewidth=1) plt.plot(smooth, linewidth=1) plt.ylim(-0.8, 0.3) plt.title(f"{displa_label} in dynamic test") # Then plot subtraction of smoothed from noisey. plt.subplot(len(displa_points), 2, (s_i * 2) + 2) noise = data - smooth plt.plot(noise, label=f"σ = {np.around(np.std(noise), 4)}") plt.legend() plt.title(f"Noise from {displa_label}") plt.tight_layout() plt.savefig(c.get_image_path("params", "noise-displa.pdf")) plt.close() ########## # Strain # ########## plt.portrait() # Find points of each sensor. strain_labels = ["T1", "T10", "T11"] strain_points = [] for strain_label in strain_labels: sensor_x, sensor_z = _strain_sensor_xz(strain_label) strain_points.append(Point(x=sensor_x, y=0, z=sensor_z)) # For each sensor plot and estimate noise. side = 700 xmin, xmax = np.inf, -np.inf for s_i, strain_label in enumerate(strain_labels): # First plot the signal, and smoothed signal. plt.subplot(len(strain_points), 2, (s_i * 2) + 1) with open(f"validation/experiment/D1a-{strain_label}.txt") as f: data = list(map(float, f.readlines())) # Find the center of the plot, minimum point in first 15000 points. data_center = 0 for i in range(15000): if data[i] < data[data_center]: data_center = i data = data[data_center - side:data_center + side] smooth = savgol_filter(data, 31, 3) plt.plot(data, linewidth=1) plt.plot(smooth, linewidth=1) plt.title(f"{strain_label} in dynamic test") # Then plot subtraction of smoothed from noisey. plt.subplot(len(strain_points), 2, (s_i * 2) + 2) noise = data - smooth plt.plot(noise, label=f"σ = {np.around(np.std(noise), 4)}") plt.legend() plt.title(f"Noise from {strain_label}") plt.tight_layout() plt.savefig(c.get_image_path("params", "noise-strain.pdf")) plt.close()
def events(c: Config, x: float, z: float): """Plot events due to normal traffic.""" point = Point(x=x, y=0, z=z) # 10 seconds of 'normal' traffic. max_time = 10 traffic_scenario = normal_traffic(c=c, lam=5, min_d=2) # Create the 'TrafficSequence' and 'TrafficArray'. traffic_sequence = traffic_scenario.traffic_sequence( bridge=c.bridge, max_time=max_time ) traffic_array = to_traffic_array( c=c, traffic_sequence=traffic_sequence, max_time=max_time ) # Find when the simulation has warmed up, and when 'TrafficArray' begins. warmed_up_at = traffic_sequence[0][0].time_left_bridge(c.bridge) traffic_array_starts = (int(warmed_up_at / c.sensor_hz) + 1) * c.sensor_hz print(f"warmed up at = {warmed_up_at}") print(f"traffic_array_starts = {traffic_array_starts}") traffic_array_ends = traffic_array_starts + (len(traffic_array) * c.sensor_hz) print(f"traffic_array_ends = {traffic_array_ends}") point_lane_ind = c.bridge.closest_lane(z) vehicles = list(set(ts[0] for ts in traffic_sequence)) print(len(vehicles)) print(vehicles[0]) vehicles = sorted( set(ts[0] for ts in traffic_sequence if ts[0].lane == point_lane_ind), key=lambda v: -v.init_x_frac, ) print(len(vehicles)) print(vehicles[0]) event_indices = [] vehicle_times = [v.time_at(x=x - 2, bridge=c.bridge) for v in vehicles] for v, t in zip(vehicles, vehicle_times): print(f"Vehicle {v.init_x_frac} {v.mps} at time {t}") start_time = int(t / c.sensor_hz) * c.sensor_hz print(f"start_time = {start_time}") ta_start_time = np.around(start_time - traffic_array_starts, 8) print(f"ta start time = {ta_start_time}") ta_start_index = int(ta_start_time / c.sensor_hz) print(f"ta start index = {ta_start_index}") ta_end_index = ta_start_index + int(c.event_time_s / c.sensor_hz) print(f"ta end index = {ta_end_index}") if ta_start_index >= 0 and ta_end_index < len(traffic_array): event_indices.append((ta_start_index, ta_end_index)) print(event_indices) responses = ( responses_to_traffic_array( c=c, traffic_array=traffic_array, response_type=ResponseType.YTranslation, damage_scenario=healthy_scenario, points=[point], sim_runner=OSRunner(c), ) * 1000 ) # fem = add_displa_noise(fem) print(responses.shape) plt.portrait() for event_ind, (event_start, event_end) in enumerate(event_indices): plt.subplot(len(event_indices), 1, event_ind + 1) plt.plot(responses[event_start : event_end + 1]) plt.tight_layout() plt.savefig(c.get_image_path("classify/events", "events.pdf")) plt.close()
def time_series_plot(c: Config, n: float): """Plot 24min time series of cracking, for multiple cracked bridges. For each bridge (hard-coded), a time series of strain fem is plotted. For each bridge it is initially in healthy condition, and the crack occurs halfway through. Args: n: float, meters in front of the crack zone where to place sensor. """ # First construct one day (24 minutes) of traffic. total_mins = 24 total_seconds = total_mins * 60 traffic_scenario = normal_traffic(c=c, lam=5, min_d=2) traffic_sequence, traffic, traffic_array = load_traffic( c=c, traffic_scenario=traffic_scenario, max_time=total_seconds, ) traffic_array.shape # Temperatures for one day. temps_day = temperature.from_to_mins( temperature.load("holly-springs"), datetime.fromisoformat(f"2019-07-03T00:00"), datetime.fromisoformat(f"2019-07-03T23:59"), ) print(f"len temps = {len(temps_day['solar'])}") print(f"len temps = {len(temps_day['temp'])}") # Then generate some cracking time series. damages = [ HealthyDamage(), transverse_crack(), transverse_crack(length=14.0, at_x=48.0), ] sensors = [ Point(x=52, z=-8.4), # Sensor in middle of lane. Point(x=damages[1].crack_area(c.bridge)[0] - n, z=-8.4), # Sensor in front of crack zone. Point(x=damages[2].crack_area(c.bridge)[0] - n, z=-8.4), # Sensor in front of crack zone. ] [print(f"Sensor {i} = {sensors[i]}") for i in range(len(sensors))] time_series = [ crack_time_series( c=c, traffic_array=traffic_array, traffic_array_mins=total_mins, sensor=sensor, crack_frac=0.5, damage=damage, temps=temps_day["temp"], solar=temps_day["solar"], ) for damage, sensor in zip(damages, sensors) ] plt.portrait() for i, (y_trans, strain) in enumerate(time_series): x = np.arange(len(strain)) * c.sensor_hz / 60 x_m = sensors[i].x damage_str = "Healthy Bridge" if i == 1: damage_str = "0.5 m crack zone" if i == 2: damage_str = "14 m crack zone" plt.subplot(len(time_series), 2, i * 2 + 1) plt.plot(x, y_trans * 1000, color="tab:blue") if i < len(time_series) - 1: plt.tick_params(axis="x", bottom=False, labelbottom=False) else: plt.xlabel("Hours") plt.title(f"At x = {x_m} m\n{damage_str}") plt.ylabel("Y trans. (mm)") plt.subplot(len(time_series), 2, i * 2 + 2) plt.plot(x, strain * 1e6, color="tab:orange") if i < len(time_series) - 1: plt.tick_params(axis="x", bottom=False, labelbottom=False) else: plt.xlabel("Hours") plt.title(f"At x = {x_m} m,\n{damage_str}") plt.ylabel("Microstrain XXB") plt.tight_layout() plt.savefig(c.get_image_path("crack", "time-series-q5.pdf")) plt.close()