Namespaces
namespace	laser

Typedefs
using	mkgraph_data_structure = std::unordered_map< std::array< float, 2 >, std::vector< std::array< float, 2 > > >

Functions
void	read_database (std::string fname)

TGraphErrors *	get_iv_scan (std::string board, std::string channel, std::string step, int marker=1, int color=1)

TGraphErrors *	get_dcr_vbias_scan (std::string board, std::string channel, std::string step, int marker=1, int color=1)

TGraphErrors *	get_dcr_threshold_scan (std::string board, std::string channel, std::string step, int marker=1, int color=1)

TGraphErrors *	get_gain (std::string board, std::string channel, std::string step, int marker=1, int color=1)

std::array< float, 2 >	get_cross_talk (std::string board, std::string channel, std::string step, std::string check_name="")

TGraphErrors *	get_iv_scan (std::string board, std::string channel, std::string step, std::vector< std::pair< std::string, std::string > > other_filters, int marker=1, int color=1)

TGraphErrors *	get_dcr_vbias_scan (std::string board, std::string channel, std::string step, std::vector< std::pair< std::string, std::string > > other_filters, int marker=1, int color=1)

TGraphErrors *	get_dcr_threshold_scan (std::string board, std::string channel, std::string step, std::vector< std::pair< std::string, std::string > > other_filters, int marker=1, int color=1)

TGraphErrors *	get_gain (std::string board, std::string channel, std::string step, std::vector< std::pair< std::string, std::string > > other_filters, int marker=1, int color=1)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::array< float, 2 >	get_Yvalue_at_X (std::string board, std::string channel, std::string step, float target_voltage)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::array< float, 2 >	get_value_at_overvoltage (std::string board, std::string channel, std::string step, float target_overvoltage)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::vector< std::array< float, 2 > >	get_all_values_at_overvoltage (std::string board, std::string sensor, std::string step, float target_overvoltage)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::vector< std::array< float, 2 > >	get_all_values_at_overvoltage (std::vector< std::string > boards, std::string sensor, std::string step, float target_overvoltage)

std::unordered_map< std::string, std::string >	get_filename (std::string board, std::string channel, std::string step, std::vector< std::pair< std::string, std::string > > other_filters={{}})

std::string	get_database_info (std::string board, std::string step, std::string info)

std::vector< std::array< std::string, 2 > >	get_board_step_history (std::string board, bool is_dcr=false, bool return_runlist=false)

template<typename target_type >
void	set_standard_style (target_type *target, int marker_style=20, int marker_color=kBlack)

void	check_all_plots_loaded ()

bool	check_iv_goodness (TGraphErrors *gTarget)

std::array< float, 2 >	measure_cross_talk (TGraphErrors *gTarget, std::string plot_name="")

std::array< float, 2 >	measure_signal_amp (TGraphErrors *gTarget, std::string plot_name="")

std::array< float, 2 >	measure_fraction_of_damage (std::array< float, 2 > target_step, std::array< float, 2 > new_reference, std::array< float, 2 > maximum_reference)

std::vector< TGraphErrors * >	make_graph (mkgraph_data_structure data_structure)

void	set_multi_graph (std::vector< TGraphErrors * > &target_graphs, int target_color, int target_marker)

std::array< float, 2 >	measure_average (std::vector< std::array< float, 2 > > measurements, bool use_rms=false)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::vector< std::array< float, 2 > >	get_all_sensor_Yvalues_at_X (std::string board, std::string sensor, std::string step, float target_x)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter>
std::vector< std::array< float, 2 > >	get_all_sensor_Yvalues_at_X (std::vector< std::string > board_list, std::string sensor, std::string step, float target_x)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>
TGraphErrors *	get_average_sensor_Yvalues_at_X (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > target_x_list)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>
TGraphErrors *	get_average_sensor_Yvalues_at_X (std::string board, std::string sensor, std::string step, std::vector< float > target_x_list)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>
TGraphErrors *	get_average_sensor_values_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points, int marker=kCircle, int color=kBlue)

template<TGraphErrors ()(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>
TGraphErrors *	get_average_sensor_values_at_overvoltage (std::string board, std::string sensor, std::string step, std::vector< float > target_x_list, int marker=kCircle, int color=kBlue)

template<bool use_rms = false>
TGraphErrors *	get_average_iv_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points, int marker=kCircle, int color=kBlue)

template<bool use_rms = false>
TGraphErrors *	get_average_dcr_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points, int marker=kCircle, int color=kBlue)

std::array< float, 2 >	get_gain_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage)

template<bool use_rms = false>
TGraphErrors *	get_average_gain_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points, int marker=kCircle, int color=kBlue)

std::array< float, 2 >	get_dcr_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_dcr_at_overvoltage (std::string board, std::string sensor, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_dcr_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_dcr_at_overvoltage (std::string sensor, std::string step, float overvoltage)

std::tuple< float, float, float >	get_PDE_merit (std::vector< std::string > board_list, std::string sensor, std::string step, float window_of_acquisition=1.)

std::tuple< float, float, float >	get_relative_PDE_merit (std::tuple< float, float, float > target_merit, std::tuple< float, float, float > standard_merit)

template<bool use_rms>
TGraphErrors *	get_dcr_overvoltage_scan (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points)

std::array< float, 2 >	get_dcr_excess_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_dcr_excess_at_overvoltage (std::string board, std::string sensor, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_dcr_excess_at_overvoltage (std::vector< std::string > board_list, std::string sensor, std::string step, float overvoltage)

template<bool use_rms>
TGraphErrors *	get_dcr_increase_overvoltage_scan (std::vector< std::string > board_list, std::string sensor, std::string step, std::vector< float > overvoltage_points=standard_overvoltage_points)

std::array< float, 2 >	get_iv_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_iv_at_overvoltage (std::string board, std::string sensor, std::string step, float overvoltage)

std::array< float, 2 >	get_iv_excess_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage)

std::vector< std::array< float, 2 > >	get_all_iv_excess_at_overvoltage (std::string board, std::string sensor, std::string step, float overvoltage)

std::array< float, 2 >	get_iv_FOD_at_overvoltage (std::string board, std::string channel, std::string step, float overvoltage, std::string max_damage_step="TIFPA-IRR1", std::string new_step="NEW")

TCanvas *	get_history_iv_at_overvoltage (std::string board, std::vector< std::array< std::string, 2 > > steps, float overvoltage, bool time_axis=true, float min=1.e-10, float max=1.e-5)

std::array< float, 2 >	get_sig_amp (std::string board, std::string channel, std::string step, std::string check_name)

std::unordered_map< std::string, std::unordered_map< std::string, std::vector< std::string > > >	get_board_history (std::string board)

std::unordered_map< std::string, std::vector< std::string > >	get_board_state_infos (std::string board, std::string step)

std::vector< std::string >	get_board_state_info_history (std::string board, std::string step, std::string info)

void	show_database ()

std::array< std::array< float, 2 >, 2 >	measure_cross_talk_and_signal_amp (TGraphErrors *gTarget, std::string plot_name)

std::vector< std::array< float, 2 > >	measure_fraction_of_damage (std::vector< std::array< float, 2 > > target_step, std::vector< std::array< float, 2 > > new_reference, std::vector< std::array< float, 2 > > maximum_reference)

template<bool use_sqsum = true, bool skip_unfit_skim = false>
std::tuple< float, float, float >	measure_average_and_rms (std::vector< std::array< float, 2 > > measurements, float rms_tolerance=5.)

template<bool use_rms = false>
std::array< float, 2 >	measure_average (std::vector< std::array< float, 2 > > measurements)

void	set_as_main_line (TGraph *gTarget, int marker, int color)

void	set_as_main_line (TGraphErrors *gTarget, int marker, int color)

void	set_as_main_line (TH1 *hTarget, int marker, int color)

template<typename ArgType , std::array< float, 2 >(*)(std::string, std::string, std::string, ArgType) current_value_getter>
std::vector< TGraphErrors * >	get_steps_history (std::string board, std::string sensor, std::vector< std::string > step_list, ArgType target_fourth, int marker=kFullCircle, int color=kBlack, int sec_marker=kCircle, int sec_color=kGray)

std::vector< TGraphErrors * >	get_steps_history_iv (std::string board, std::string sensor, std::vector< std::string > step_list, float overvoltage, int marker=kFullCircle, int color=kBlack, int sec_marker=kCircle, int sec_color=kGray)

std::vector< TGraphErrors * >	get_steps_history_gain (std::string board, std::string sensor, std::vector< std::string > step_list, float overvoltage, int marker=kFullCircle, int color=kBlack, int sec_marker=kCircle, int sec_color=kGray)

std::vector< TGraphErrors * >	get_steps_history_CT (std::string board, std::string sensor, std::vector< std::string > step_list, std::string save_dir, int marker=kFullCircle, int color=kBlack, int sec_marker=kCircle, int sec_color=kGray)

std::array< float, 2 >	get_iv_FOD_at_overvoltage_std_TIFPA (std::string board, std::string channel, std::string step, float overvoltage)

std::vector< TGraphErrors * >	get_steps_history_FOD_std_TIFPA (std::string board, std::string sensor, std::vector< std::string > step_list, float overvoltage, int marker=kFullCircle, int color=kBlue, int sec_marker=kCircle, int sec_color=kGray)

template<typename ArgType , std::array< float, 2 >(*)(std::string, std::string, std::string, ArgType) current_value_getter>
std::vector< TGraphErrors * >	get_general_TGraphs (std::string sensor, std::vector< std::pair< std::string, std::vector< std::string > > > step_list_w_boards, ArgType target_fourth, int marker=kFullCircle, int color=kBlue)

std::vector< TGraphErrors * >	get_general_TGraphs_iv (std::string sensor, std::vector< std::pair< std::string, std::vector< std::string > > > step_list_w_boards, float overvoltage, int marker=kFullCircle, int color=kBlue)

std::vector< TGraphErrors * >	get_general_TGraphs_ct (std::string sensor, std::vector< std::pair< std::string, std::vector< std::string > > > step_list_w_boards, std::string fig_check_name, int marker=kFullCircle, int color=kBlue)

Variables
const double	k_boltz_eV = 8.617333262 * 1.e-5

const double	k_boltz_J = 1.380649 * 1.e-23

std::vector< std::string >	sensors_full = {"HPK S13360-3050VS", "HPK S13360-3075VS", "HPK S14161-3050HS"}

std::vector< std::string >	sensors_short = {"S13361_3050", "S13361_3075", "S14161_3050"}

std::vector< std::string >	all_boards

std::unordered_map< std::string, std::vector< std::string > >	standard_status_to_boards

std::unordered_map< std::string, std::string >	standard_status_to_status

std::unordered_map< std::string, std::vector< std::string > >	board_to_status_list

std::vector< std::string >	all_channels

std::unordered_map< std::string, std::string >	channel_to_sensor

std::unordered_map< std::string, std::string >	channel_to_sensor_short

std::unordered_map< std::string, std::vector< std::string > >	sensor_to_channels

std::unordered_map< std::string, std::vector< std::string > >	sensor_short_to_channels

std::vector< std::string >	all_statuses

std::vector< std::string >	TScan_statuses

std::unordered_map< std::string, double >	status_to_annealing_time

std::unordered_map< std::string, int >	status_to_color

std::unordered_map< std::string, int >	status_to_marker

std::vector< std::string >	all_sensors

std::unordered_map< std::string, int >	sensor_to_color

std::unordered_map< std::string, int >	sensor_to_marker

std::unordered_map< std::string, std::string >	sensor_to_code

std::unordered_map< std::string, std::string >	code_to_sensor

std::unordered_map< std::string, float >	sensor_to_vbd

std::unordered_map< std::string, float >	sensor_to_vbd_Tdep

std::unordered_map< std::string, float >	DTS_PDE

std::unordered_map< std::string, float >	DTS_OVop

std::vector< float >	standard_overvoltage_points

std::vector< std::string >	fields

std::vector< std::string >	criteria

std::string	basedir = "."

std::unordered_map< std::string, std::unordered_map< std::string, std::unordered_map< std::string, std::unordered_map< std::string, TGraphErrors * > > > >	cache_memory

std::unordered_map< std::string, std::unordered_map< std::string, std::unordered_map< std::string, std::vector< std::string > > > >	database_memory

Typedef Documentation

◆ mkgraph_data_structure

using database::mkgraph_data_structure = typedef std::unordered_map<std::array<float, 2>, std::vector<std::array<float, 2> >>

Function Documentation

◆ check_all_plots_loaded()

void database::check_all_plots_loaded ( )

◆ check_iv_goodness()

bool database::check_iv_goodness ( TGraphErrors * gTarget )

◆ get_all_dcr_at_overvoltage() [1/3]

std::vector< std::array< float, 2 > > database::get_all_dcr_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_dcr_at_overvoltage() [2/3]

std::vector< std::array< float, 2 > > database::get_all_dcr_at_overvoltage	(	std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_dcr_at_overvoltage() [3/3]

std::vector< std::array< float, 2 > > database::get_all_dcr_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_dcr_excess_at_overvoltage() [1/2]

std::vector< std::array< float, 2 > > database::get_all_dcr_excess_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_dcr_excess_at_overvoltage() [2/2]

std::vector< std::array< float, 2 > > database::get_all_dcr_excess_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_iv_at_overvoltage()

std::vector< std::array< float, 2 > > database::get_all_iv_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_iv_excess_at_overvoltage()

std::vector< std::array< float, 2 > > database::get_all_iv_excess_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	overvoltage
	)

◆ get_all_sensor_Yvalues_at_X() [1/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::vector< std::array< float, 2 > > database::get_all_sensor_Yvalues_at_X	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	target_x
	)

◆ get_all_sensor_Yvalues_at_X() [2/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::vector< std::array< float, 2 > > database::get_all_sensor_Yvalues_at_X	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		float	target_x
	)

◆ get_all_values_at_overvoltage() [1/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::vector< std::array< float, 2 > > database::get_all_values_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		float	target_overvoltage
	)

◆ get_all_values_at_overvoltage() [2/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::vector< std::array< float, 2 > > database::get_all_values_at_overvoltage	(	std::vector< std::string >	boards,
		std::string	sensor,
		std::string	step,
		float	target_overvoltage
	)

◆ get_average_dcr_at_overvoltage()

template<bool use_rms = false>

TGraphErrors * database::get_average_dcr_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`,
		int	marker = `kCircle`,
		int	color = `kBlue`
	)

◆ get_average_gain_at_overvoltage()

template<bool use_rms = false>

TGraphErrors * database::get_average_gain_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`,
		int	marker = `kCircle`,
		int	color = `kBlue`
	)

◆ get_average_iv_at_overvoltage()

template<bool use_rms = false>

TGraphErrors * database::get_average_iv_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`,
		int	marker = `kCircle`,
		int	color = `kBlue`
	)

◆ get_average_sensor_values_at_overvoltage() [1/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>

TGraphErrors * database::get_average_sensor_values_at_overvoltage	(	std::string	board,
		std::string	sensor,
		std::string	step,
		std::vector< float >	target_x_list,
		int	marker = `kCircle`,
		int	color = `kBlue`
	)

◆ get_average_sensor_values_at_overvoltage() [2/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>

TGraphErrors * database::get_average_sensor_values_at_overvoltage	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`,
		int	marker = `kCircle`,
		int	color = `kBlue`
	)

◆ get_average_sensor_Yvalues_at_X() [1/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>

TGraphErrors * database::get_average_sensor_Yvalues_at_X	(	std::string	board,
		std::string	sensor,
		std::string	step,
		std::vector< float >	target_x_list
	)

◆ get_average_sensor_Yvalues_at_X() [2/2]

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter, bool use_rms = false>

TGraphErrors * database::get_average_sensor_Yvalues_at_X	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	target_x_list
	)

◆ get_board_history()

std::unordered_map< std::string, std::unordered_map< std::string, std::vector< std::string > > > database::get_board_history ( std::string board )

◆ get_board_state_info_history()

std::vector< std::string > database::get_board_state_info_history	(	std::string	board,
		std::string	step,
		std::string	info
	)

◆ get_board_state_infos()

std::unordered_map< std::string, std::vector< std::string > > database::get_board_state_infos	(	std::string	board,
		std::string	step
	)

◆ get_board_step_history()

std::vector< std::array< std::string, 2 > > database::get_board_step_history	(	std::string	board,
		bool	is_dcr = `false`,
		bool	return_runlist = `false`
	)

◆ get_cross_talk()

std::array< float, 2 > database::get_cross_talk	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::string	check_name = `""`
	)

◆ get_database_info()

std::string database::get_database_info	(	std::string	board,
		std::string	step,
		std::string	info
	)

◆ get_dcr_at_overvoltage()

std::array< float, 2 > database::get_dcr_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_dcr_excess_at_overvoltage()

std::array< float, 2 > database::get_dcr_excess_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_dcr_increase_overvoltage_scan()

template<bool use_rms>

TGraphErrors * database::get_dcr_increase_overvoltage_scan	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`
	)

◆ get_dcr_overvoltage_scan()

template<bool use_rms>

TGraphErrors * database::get_dcr_overvoltage_scan	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		std::vector< float >	overvoltage_points = `standard_overvoltage_points`
	)

◆ get_dcr_threshold_scan() [1/2]

TGraphErrors * database::get_dcr_threshold_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_dcr_threshold_scan() [2/2]

TGraphErrors * database::get_dcr_threshold_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::vector< std::pair< std::string, std::string > >	other_filters,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_dcr_vbias_scan() [1/2]

TGraphErrors * database::get_dcr_vbias_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_dcr_vbias_scan() [2/2]

TGraphErrors * database::get_dcr_vbias_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::vector< std::pair< std::string, std::string > >	other_filters,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_filename()

std::unordered_map< std::string, std::string > database::get_filename	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::vector< std::pair< std::string, std::string > >	other_filters = `{{}}`
	)

◆ get_gain() [1/2]

TGraphErrors * database::get_gain	(	std::string	board,
		std::string	channel,
		std::string	step,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_gain() [2/2]

TGraphErrors * database::get_gain	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::vector< std::pair< std::string, std::string > >	other_filters,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_gain_at_overvoltage()

std::array< float, 2 > database::get_gain_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_general_TGraphs()

template<typename ArgType , std::array< float, 2 >(*)(std::string, std::string, std::string, ArgType) current_value_getter>

std::vector< TGraphErrors * > database::get_general_TGraphs	(	std::string	sensor,
		std::vector< std::pair< std::string, std::vector< std::string > > >	step_list_w_boards,
		ArgType	target_fourth,
		int	marker = `kFullCircle`,
		int	color = `kBlue`
	)

◆ get_general_TGraphs_ct()

std::vector< TGraphErrors * > database::get_general_TGraphs_ct	(	std::string	sensor,
		std::vector< std::pair< std::string, std::vector< std::string > > >	step_list_w_boards,
		std::string	fig_check_name,
		int	marker = `kFullCircle`,
		int	color = `kBlue`
	)

◆ get_general_TGraphs_iv()

std::vector< TGraphErrors * > database::get_general_TGraphs_iv	(	std::string	sensor,
		std::vector< std::pair< std::string, std::vector< std::string > > >	step_list_w_boards,
		float	overvoltage,
		int	marker = `kFullCircle`,
		int	color = `kBlue`
	)

◆ get_history_iv_at_overvoltage()

TCanvas * database::get_history_iv_at_overvoltage	(	std::string	board,
		std::vector< std::array< std::string, 2 > >	steps,
		float	overvoltage,
		bool	time_axis = `true`,
		float	min = `1.e-10`,
		float	max = `1.e-5`
	)

◆ get_iv_at_overvoltage()

std::array< float, 2 > database::get_iv_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_iv_excess_at_overvoltage()

std::array< float, 2 > database::get_iv_excess_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_iv_FOD_at_overvoltage()

std::array< float, 2 > database::get_iv_FOD_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage,
		std::string	max_damage_step = `"TIFPA-IRR1"`,
		std::string	new_step = `"NEW"`
	)

◆ get_iv_FOD_at_overvoltage_std_TIFPA()

std::array< float, 2 > database::get_iv_FOD_at_overvoltage_std_TIFPA	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	overvoltage
	)

◆ get_iv_scan() [1/2]

TGraphErrors * database::get_iv_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_iv_scan() [2/2]

TGraphErrors * database::get_iv_scan	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::vector< std::pair< std::string, std::string > >	other_filters,
		int	marker = `1`,
		int	color = `1`
	)

◆ get_PDE_merit()

std::tuple< float, float, float > database::get_PDE_merit	(	std::vector< std::string >	board_list,
		std::string	sensor,
		std::string	step,
		float	window_of_acquisition = `1.`
	)

◆ get_relative_PDE_merit()

std::tuple< float, float, float > database::get_relative_PDE_merit	(	std::tuple< float, float, float >	target_merit,
		std::tuple< float, float, float >	standard_merit
	)

◆ get_sig_amp()

std::array< float, 2 > database::get_sig_amp	(	std::string	board,
		std::string	channel,
		std::string	step,
		std::string	check_name
	)

◆ get_steps_history()

template<typename ArgType , std::array< float, 2 >(*)(std::string, std::string, std::string, ArgType) current_value_getter>

std::vector< TGraphErrors * > database::get_steps_history	(	std::string	board,
		std::string	sensor,
		std::vector< std::string >	step_list,
		ArgType	target_fourth,
		int	marker = `kFullCircle`,
		int	color = `kBlack`,
		int	sec_marker = `kCircle`,
		int	sec_color = `kGray`
	)

◆ get_steps_history_CT()

std::vector< TGraphErrors * > database::get_steps_history_CT	(	std::string	board,
		std::string	sensor,
		std::vector< std::string >	step_list,
		std::string	save_dir,
		int	marker = `kFullCircle`,
		int	color = `kBlack`,
		int	sec_marker = `kCircle`,
		int	sec_color = `kGray`
	)

◆ get_steps_history_FOD_std_TIFPA()

std::vector< TGraphErrors * > database::get_steps_history_FOD_std_TIFPA	(	std::string	board,
		std::string	sensor,
		std::vector< std::string >	step_list,
		float	overvoltage,
		int	marker = `kFullCircle`,
		int	color = `kBlue`,
		int	sec_marker = `kCircle`,
		int	sec_color = `kGray`
	)

◆ get_steps_history_gain()

std::vector< TGraphErrors * > database::get_steps_history_gain	(	std::string	board,
		std::string	sensor,
		std::vector< std::string >	step_list,
		float	overvoltage,
		int	marker = `kFullCircle`,
		int	color = `kBlack`,
		int	sec_marker = `kCircle`,
		int	sec_color = `kGray`
	)

◆ get_steps_history_iv()

std::vector< TGraphErrors * > database::get_steps_history_iv	(	std::string	board,
		std::string	sensor,
		std::vector< std::string >	step_list,
		float	overvoltage,
		int	marker = `kFullCircle`,
		int	color = `kBlack`,
		int	sec_marker = `kCircle`,
		int	sec_color = `kGray`
	)

◆ get_value_at_overvoltage()

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::array< float, 2 > database::get_value_at_overvoltage	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	target_overvoltage
	)

◆ get_Yvalue_at_X()

template<TGraphErrors *(*)(std::string, std::string, std::string, int, int) current_curve_getter>

std::array< float, 2 > database::get_Yvalue_at_X	(	std::string	board,
		std::string	channel,
		std::string	step,
		float	target_voltage
	)

◆ make_graph()

std::vector< TGraphErrors * > database::make_graph ( mkgraph_data_structure data_structure )

◆ measure_average() [1/2]

template<bool use_rms = false>

std::array< float, 2 > database::measure_average ( std::vector< std::array< float, 2 > > measurements )

◆ measure_average() [2/2]

std::array< float, 2 > database::measure_average	(	std::vector< std::array< float, 2 > >	measurements,
		bool	use_rms = `false`
	)

◆ measure_average_and_rms()

template<bool use_sqsum = true, bool skip_unfit_skim = false>

std::tuple< float, float, float > database::measure_average_and_rms	(	std::vector< std::array< float, 2 > >	measurements,
		float	rms_tolerance = `5.`
	)

◆ measure_cross_talk()

std::array< float, 2 > database::measure_cross_talk	(	TGraphErrors *	gTarget,
		std::string	plot_name = `""`
	)

◆ measure_cross_talk_and_signal_amp()

std::array< std::array< float, 2 >, 2 > database::measure_cross_talk_and_signal_amp	(	TGraphErrors *	gTarget,
		std::string	plot_name
	)

◆ measure_fraction_of_damage() [1/2]

std::array< float, 2 > database::measure_fraction_of_damage	(	std::array< float, 2 >	target_step,
		std::array< float, 2 >	new_reference,
		std::array< float, 2 >	maximum_reference
	)

◆ measure_fraction_of_damage() [2/2]

std::vector< std::array< float, 2 > > database::measure_fraction_of_damage	(	std::vector< std::array< float, 2 > >	target_step,
		std::vector< std::array< float, 2 > >	new_reference,
		std::vector< std::array< float, 2 > >	maximum_reference
	)

◆ measure_signal_amp()

std::array< float, 2 > database::measure_signal_amp	(	TGraphErrors *	gTarget,
		std::string	plot_name = `""`
	)

◆ read_database()

void database::read_database ( std::string fname )

◆ set_as_main_line() [1/3]

void database::set_as_main_line	(	TGraph *	gTarget,
		int	marker,
		int	color
	)

◆ set_as_main_line() [2/3]

void database::set_as_main_line	(	TGraphErrors *	gTarget,
		int	marker,
		int	color
	)

◆ set_as_main_line() [3/3]

void database::set_as_main_line	(	TH1 *	hTarget,
		int	marker,
		int	color
	)

◆ set_multi_graph()

void database::set_multi_graph	(	std::vector< TGraphErrors * > &	target_graphs,
		int	target_color,
		int	target_marker
	)

◆ set_standard_style()

template<typename target_type >

void database::set_standard_style	(	target_type *	target,
		int	marker_style = `20`,
		int	marker_color = `kBlack`
	)

◆ show_database()

void database::show_database ( )

Variable Documentation

◆ all_boards

std::vector<std::string> database::all_boards

Initial value:

= {
      "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15",
      "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
      "31", "32", "33", "34"}

◆ all_channels

std::vector<std::string> database::all_channels

Initial value:

= {
      "A1", "A2", "A3", "A4",
      "B1", "B2", "B3", "B4",
      "C1", "C2", "C3", "C4"}

◆ all_sensors

std::vector<std::string> database::all_sensors

Initial value:

= {
      "HPK S13360-3050VS",
      "HPK S13360-3075VS",
      "HPK S14161-3050HS"}

◆ all_statuses

std::vector<std::string> database::all_statuses

Initial value:

= {
      "NEW",                                                                                   
      "TIFPA-IRR1", "TIFPA-IRR1on",                                                            
      "SANN-100-30m", "SANN-100-2.5h", "SANN-100-24h",                                         
      "SANN-125-30m", "SANN-125-2.5h", "SANN-125-24h",                                         
      "SANN-150-30m", "SANN-150-2.5h", "SANN-150-24h", "SANN-150-73h", "SANN-150-250h",        
      "PANN1", "PANN2", "PANN3", "PANN3x",                                                     
      "TEMP313", "TEMP303", "TEMP293", "TEMP283", "TEMP278", "TEMP273", "TEMP263", "TEMP253"}

◆ basedir

std::string database::basedir = "."

◆ board_to_status_list

std::unordered_map<std::string, std::vector<std::string> > database::board_to_status_list

◆ cache_memory

std::unordered_map<std::string, std::unordered_map<std::string, std::unordered_map<std::string, std::unordered_map<std::string, TGraphErrors *> > > > database::cache_memory

◆ channel_to_sensor

std::unordered_map<std::string, std::string> database::channel_to_sensor

Initial value:

= {
      {"A1", "HPK S13360-3050VS"},
      {"A2", "HPK S13360-3050VS"},
      {"A3", "HPK S13360-3050VS"},
      {"A4", "HPK S13360-3050VS"},
      {"B1", "HPK S13360-3075VS"},
      {"B2", "HPK S13360-3075VS"},
      {"B3", "HPK S13360-3075VS"},
      {"B4", "HPK S13360-3075VS"},
      {"C1", "HPK S14161-3050HS"},
      {"C2", "HPK S14161-3050HS"},
      {"C3", "HPK S14161-3050HS"},
      {"C4", "HPK S14161-3050HS"}}

◆ channel_to_sensor_short

std::unordered_map<std::string, std::string> database::channel_to_sensor_short

Initial value:

= {
      {"A1", "S13361_3050"},
      {"A2", "S13361_3050"},
      {"A3", "S13361_3050"},
      {"A4", "S13361_3050"},
      {"B1", "S13361_3075"},
      {"B2", "S13361_3075"},
      {"B3", "S13361_3075"},
      {"B4", "S13361_3075"},
      {"C1", "S14161_3050"},
      {"C2", "S14161_3050"},
      {"C3", "S14161_3050"},
      {"C4", "S14161_3050"}}

◆ code_to_sensor

std::unordered_map<std::string, std::string> database::code_to_sensor

Initial value:

= {
      {"HPK_13_50", "HPK S13360-3050VS"},
      {"HPK_13_75", "HPK S13360-3075VS"},
      {"HPK_14_50", "HPK S14161-3050HS"}}

◆ criteria

std::vector<std::string> database::criteria

Initial value:

= {

"run", "quality", "step", "setup", "iv-mux-1", "iv-mux-2", "dcr-chip-2", "dcr-chip-3", "temp", "ann-temp", "ann-time"}

◆ database_memory

std::unordered_map<std::string, std::unordered_map<std::string, std::unordered_map<std::string, std::vector<std::string> > > > database::database_memory

◆ DTS_OVop

std::unordered_map<std::string, float> database::DTS_OVop

Initial value:

= {
      {"HPK S13360-3050VS", 3.},
      {"HPK S13360-3075VS", 3.},
      {"HPK S14161-3050HS", 2.7}}

◆ DTS_PDE

std::unordered_map<std::string, float> database::DTS_PDE

Initial value:

= {
      {"HPK S13360-3050VS", 0.4},
      {"HPK S13360-3075VS", 0.5},
      {"HPK S14161-3050HS", 0.5}}

◆ fields

std::vector<std::string> database::fields

Initial value:

= {

"run", "quality", "step", "setup", "iv-mux-1", "iv-mux-2", "dcr-chip-2", "dcr-chip-3"}

◆ k_boltz_eV

const double database::k_boltz_eV = 8.617333262 * 1.e-5

◆ k_boltz_J

const double database::k_boltz_J = 1.380649 * 1.e-23

◆ sensor_short_to_channels

std::unordered_map<std::string, std::vector<std::string> > database::sensor_short_to_channels

Initial value:

= {
      {"S13361_3050", {"A1", "A2", "A3", "A4"}},
      {"S13361_3075", {"B1", "B2", "B3", "B4"}},
      {"S14161_3050", {"C1", "C2", "C3", "C4"}}}

◆ sensor_to_channels

std::unordered_map<std::string, std::vector<std::string> > database::sensor_to_channels

Initial value:

= {
      {"HPK S13360-3050VS", {"A1", "A2", "A3", "A4"}},
      {"HPK S13360-3075VS", {"B1", "B2", "B3", "B4"}},
      {"HPK S14161-3050HS", {"C1", "C2", "C3", "C4"}}}

◆ sensor_to_code

std::unordered_map<std::string, std::string> database::sensor_to_code

Initial value:

= {
      {"HPK S13360-3050VS", "HPK_13_50"},
      {"HPK S13360-3075VS", "HPK_13_75"},
      {"HPK S14161-3050HS", "HPK_14_50"}}

◆ sensor_to_color

std::unordered_map<std::string, int> database::sensor_to_color

Initial value:

= {
      {"HPK S13360-3050VS", kRed},
      {"HPK S13360-3075VS", kGreen - 2},
      {"HPK S14161-3050HS", kAzure - 3}}

◆ sensor_to_marker

std::unordered_map<std::string, int> database::sensor_to_marker

Initial value:

= {
      {"HPK S13360-3050VS", 20},
      {"HPK S13360-3075VS", 21},
      {"HPK S14161-3050HS", 29}}

◆ sensor_to_vbd

std::unordered_map<std::string, float> database::sensor_to_vbd

Initial value:

= {
      {"HPK S13360-3050VS", 48.4},
      {"HPK S13360-3075VS", 47.9},
      {"HPK S14161-3050HS", 36.5}}

◆ sensor_to_vbd_Tdep

std::unordered_map<std::string, float> database::sensor_to_vbd_Tdep

Initial value:

= {
      {"HPK S13360-3050VS", 0.054},
      {"HPK S13360-3075VS", 0.054},
      {"HPK S14161-3050HS", 0.034}}

◆ sensors_full

std::vector<std::string> database::sensors_full = {"HPK S13360-3050VS", "HPK S13360-3075VS", "HPK S14161-3050HS"}

◆ sensors_short

std::vector<std::string> database::sensors_short = {"S13361_3050", "S13361_3075", "S14161_3050"}

◆ standard_overvoltage_points

std::vector<float> database::standard_overvoltage_points

Initial value:

= {

1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0}

◆ standard_status_to_boards

std::unordered_map<std::string, std::vector<std::string> > database::standard_status_to_boards

Initial value:

= {
      {"NEW", all_boards},
      {"TIFPA-IRR1", {"1", "2", "13", "14", "15", "16"}},
      {"LNL-IRR1", {"21", "22", "23", "24", "25"}},
      {"TIFPA-OANN", {"2"}}}

◆ standard_status_to_status

std::unordered_map<std::string, std::string> database::standard_status_to_status

Initial value:

= {
      {"NEW", "NEW"},
      {"TIFPA-IRR1", "TIFPA-IRR1"},
      {"LNL-IRR1", "LNL-IRR1"},
      {"TIFPA-OANN", "OANN-150-150h"}}

◆ status_to_annealing_time

std::unordered_map<std::string, double> database::status_to_annealing_time

Initial value:

= {
      {"NEW", -1},              
      {"TIFPA-IRR1", 0},        
      {"TIFPA-IRR1-ON", 158.3}, 
      {"SANN-100-30m", 30},     
      {"SANN-100-2.5h", 180},
      {"SANN-100-24h", 1620},
      {"SANN-125-30m", 1650}, 
      {"SANN-125-2.5h", 1830},
      {"SANN-125-24h", 3240},
      {"SANN-150-30m", 3270}, 
      {"SANN-150-2.5h", 3450},
      {"SANN-150-24h", 4860},
      {"SANN-150-73h", 9240},
      {"SANN-150-250h", 24240},
      {"SANN-175-30m", 24270},
      {"PANN1", 9000}, 
      {"PANN2", 18000},
      {"PANN3", 9000},
      {"PANN3x", 27000}}

◆ status_to_color

std::unordered_map<std::string, int> database::status_to_color

Initial value:

= {
      {"NEW", kAzure - 3},
      {"TIFPA-IRR1", kGreen + 2},
      {"TIFPA-IRR2", kGreen - 3},
      {"LNL-IRR1", kSpring - 7},
      {"LNL-IRR2", kGreen - 5},
      {"GIF-IRR1", kOrange},
      {"OANN-150-150h", kRed - 3}}

◆ status_to_marker

std::unordered_map<std::string, int> database::status_to_marker

Initial value:

= {
      {"NEW", 20},
      {"TIFPA-IRR1", 20},
      {"GIF-IRR1", 20},
      {"LNL-IRR1", 21},
      {"LNL-IRR2", 21},
      {"OANN-150-150h", 20}}

◆ TScan_statuses

std::vector<std::string> database::TScan_statuses

Initial value:

= {

"TEMP303", "TEMP293", "TEMP283", "TEMP278", "TEMP273", "TEMP263", "TEMP253"}

Namespaces

Typedefs

Functions

Variables

Typedef Documentation

◆ mkgraph_data_structure

Function Documentation

◆ check_all_plots_loaded()

◆ check_iv_goodness()

◆ get_all_dcr_at_overvoltage() [1/3]

◆ get_all_dcr_at_overvoltage() [2/3]

◆ get_all_dcr_at_overvoltage() [3/3]

◆ get_all_dcr_excess_at_overvoltage() [1/2]

◆ get_all_dcr_excess_at_overvoltage() [2/2]

◆ get_all_iv_at_overvoltage()

◆ get_all_iv_excess_at_overvoltage()

◆ get_all_sensor_Yvalues_at_X() [1/2]

◆ get_all_sensor_Yvalues_at_X() [2/2]

◆ get_all_values_at_overvoltage() [1/2]

◆ get_all_values_at_overvoltage() [2/2]

◆ get_average_dcr_at_overvoltage()

◆ get_average_gain_at_overvoltage()

◆ get_average_iv_at_overvoltage()

◆ get_average_sensor_values_at_overvoltage() [1/2]

◆ get_average_sensor_values_at_overvoltage() [2/2]

◆ get_average_sensor_Yvalues_at_X() [1/2]

◆ get_average_sensor_Yvalues_at_X() [2/2]

◆ get_board_history()

◆ get_board_state_info_history()

◆ get_board_state_infos()

◆ get_board_step_history()

◆ get_cross_talk()

◆ get_database_info()

◆ get_dcr_at_overvoltage()

◆ get_dcr_excess_at_overvoltage()

◆ get_dcr_increase_overvoltage_scan()

◆ get_dcr_overvoltage_scan()

◆ get_dcr_threshold_scan() [1/2]

◆ get_dcr_threshold_scan() [2/2]

◆ get_dcr_vbias_scan() [1/2]

◆ get_dcr_vbias_scan() [2/2]

◆ get_filename()

◆ get_gain() [1/2]

◆ get_gain() [2/2]

◆ get_gain_at_overvoltage()

◆ get_general_TGraphs()

◆ get_general_TGraphs_ct()

◆ get_general_TGraphs_iv()

◆ get_history_iv_at_overvoltage()

◆ get_iv_at_overvoltage()

◆ get_iv_excess_at_overvoltage()

◆ get_iv_FOD_at_overvoltage()

◆ get_iv_FOD_at_overvoltage_std_TIFPA()

◆ get_iv_scan() [1/2]

◆ get_iv_scan() [2/2]

◆ get_PDE_merit()

◆ get_relative_PDE_merit()

◆ get_sig_amp()

◆ get_steps_history()

◆ get_steps_history_CT()

◆ get_steps_history_FOD_std_TIFPA()

◆ get_steps_history_gain()

◆ get_steps_history_iv()

◆ get_value_at_overvoltage()

◆ get_Yvalue_at_X()

◆ make_graph()

◆ measure_average() [1/2]

◆ measure_average() [2/2]

◆ measure_average_and_rms()

◆ measure_cross_talk()

◆ measure_cross_talk_and_signal_amp()

◆ measure_fraction_of_damage() [1/2]

◆ measure_fraction_of_damage() [2/2]

◆ measure_signal_amp()

◆ read_database()

◆ set_as_main_line() [1/3]

◆ set_as_main_line() [2/3]

◆ set_as_main_line() [3/3]

◆ set_multi_graph()

◆ set_standard_style()