示例#1
0
def _save_drop_contour_fit_residuals_figure(drop: IFTDropAnalysis, out_file,
                                            fig_size: Tuple[float, float],
                                            dpi: int) -> None:
    residuals = drop.bn_residuals.get()
    if residuals is None:
        return

    fig = simple_grapher(label_x=r'Arclength parameter',
                         label_y='Residual',
                         data_x=residuals[:, 0],
                         data_y=residuals[:, 1],
                         color='blue',
                         marker='.',
                         line_style='',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#2
0
def _save_drop_contour_fit_residuals_figure(drop: PendantAnalysisJob, out_file,
                                            fig_size: Tuple[float, float],
                                            dpi: int) -> None:
    arclengths = drop.bn_arclengths.get()
    residuals = drop.bn_residuals.get()
    if arclengths is None or residuals is None:
        return

    fig = simple_grapher(label_x=r'Arclength',
                         label_y='Residual',
                         data_x=arclengths,
                         data_y=residuals,
                         color='blue',
                         marker='.',
                         line_style='',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#3
0
def _save_surface_area_figure(drops: Sequence[PendantAnalysisJob], out_file,
                              fig_size: Tuple[float, float], dpi: int) -> None:
    drops = [
        drop for drop in drops if math.isfinite(drop.bn_image_timestamp.get())
        and math.isfinite(drop.bn_surface_area.get())
    ]

    start_time = min(drop.bn_image_timestamp.get() for drop in drops)
    data = ((drop.bn_image_timestamp.get() - start_time,
             drop.bn_surface_area.get() * 1e6) for drop in drops)

    fig = simple_grapher('Time [s]',
                         'Surface area [mm²]',
                         *zip(*data),
                         marker='.',
                         line_style='-',
                         color='green',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#4
0
def _save_ift_figure(drops: Sequence[PendantAnalysisJob], out_file,
                     fig_size: Tuple[float, float], dpi: int) -> None:
    drops = [
        drop for drop in drops if math.isfinite(drop.bn_image_timestamp.get())
        and math.isfinite(drop.bn_interfacial_tension.get())
    ]

    start_time = min(drop.bn_image_timestamp.get() for drop in drops)
    data = ((drop.bn_image_timestamp.get() - start_time,
             drop.bn_interfacial_tension.get() * 1e3) for drop in drops)

    fig = simple_grapher('Time [s]',
                         'Interfacial tension [mN m⁻¹]',
                         *zip(*data),
                         marker='.',
                         line_style='-',
                         color='red',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#5
0
def _save_volume_figure(drops: Sequence[IFTDropAnalysis], out_file,
                        fig_size: Tuple[float, float], dpi: int) -> None:
    drops = [
        drop for drop in drops if math.isfinite(drop.bn_image_timestamp.get())
        and math.isfinite(drop.bn_volume.get())
    ]

    start_time = min(drop.bn_image_timestamp.get() for drop in drops)
    data = ((drop.bn_image_timestamp.get() - start_time,
             drop.bn_volume.get() * 1e9) for drop in drops)

    fig = simple_grapher('Time (s)',
                         'Volume (mm³)',
                         *zip(*data),
                         marker='.',
                         line_style='-',
                         color='blue',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#6
0
def _save_right_angle_figure(drops: Sequence[ConanAnalysis], out_file,
                             fig_size: Tuple[float, float], dpi: int) -> None:
    drops = [
        drop for drop in drops if math.isfinite(drop.bn_image_timestamp.get())
        and math.isfinite(drop.bn_right_angle.get())
    ]

    data = [
        *zip(*((drop.bn_image_timestamp.get(),
                math.degrees(drop.bn_right_angle.get())) for drop in drops))
    ]

    fig = simple_grapher('Time (s)',
                         'Right angle (degrees)',
                         *data,
                         marker='.',
                         line_style='-',
                         color='blue',
                         fig_size=fig_size,
                         dpi=dpi)

    fig.savefig(out_file)
示例#7
0
def _save_right_angle_plot(
        jobs: Sequence[ConanAnalysisJob],
        out_file,
        fig_size: Tuple[float, float],
        dpi: int,
) -> None:
    jobs = [ job for job in jobs
             if job.timestamp is not None and job.right_angle is not None ]

    fig = simple_grapher(
        'Time [s]',
        'Right CA [°]',
        [job.timestamp for job in jobs],
        [math.degrees(job.right_angle) for job in jobs],
        marker='.',
        line_style='-',
        color='blue',
        fig_size=fig_size,
        dpi=dpi
    )

    fig.savefig(out_file)