//
//	By: 		Jaideep Singh
//
//	Date: 		08/04/06 rev. many times since, added various variables
//			02/09/07 added n2 density
//	
//	Description:	A set of functions designed to call the "masterdb" on uvapos1 and get run info.
//			If the run does not exist or if the info for the run does not exist, then the
//			my_result_is_NULL() flag will be set TRUE (until another query is made) and 
//			the value returned will be garbage depending on type:
//	
//						Int_t    -> -999999999
//						Double_t -> -999999999.0
//						TString  -> "NULL"
//						TDatime  -> "1995-01-01 00:00:00"
//								
//			The library must be compiled in the same directory as the analyzer AND
//			it must be complied using the version of ROOT used for the analyzer.
//			For example, analyzer-1.4.0 is located in: /work/halla/gdh/analyzer-1.4.0/
//			AND was compiled using ROOT 4.00/08, therefore this lib should be:
//			
//				(1) put in the /work/halla/gdh/analyzer-1.4.0/ directory
//				(2) compiled using ROOT 4.00/08 by: ".L lib_mysql_support_for_sagdh.C+" (note the plus sign)
//			
//			The end result should be the file "lib_mysql_support_for_sagdh_C.so" in the same directory.
//
//			To use this library, place the following line in your macro to load the lib:
//
//				gSystem->Load("lib_mysql_support_for_sagdh_C.so");
//			
//			Now you should have access to any of the functions defined in this library.  It is
//			highly recommended that a call to the database is always proceeded by a NULL check:
//
//				Int_t run_number = 4199;
//				Double_t beam_pol = get_my_beam_pol(run_number);
//				if (my_result_is_NULL())
//				{ cout << "Beam polarization for run " << run_number << " is Garbage!!!"   << endl; }
//				else
//				{ cout << "Beam polarization for run " << run_number << " is " << beam_pol << endl; }
//			 
//			The "get_my_usage();" function, prints the following:
//
//				Available Information for Run 4199 (Int_t):
//
//				get_my_usage(); ---> prints *this* out!!!
//				my_result_is_null() = 0 for FALSE and 1 for TRUE, always call this function to verify that the result is not garbage!
//				
//				get_my_n2_run_number(run_number)    = 4196 (Int_t)
//				get_my_empty_run_number(run_number) = 4195 (Int_t)
//				get_my_flag(run_number)         = 3 (Int_t)
//				get_my_split_number(run_number) = 0 (Int_t)
//				get_my_period(run_number)       = 2 (Int_t)
//				get_my_ps1(run_number) = 1 (Int_t)
//				get_my_ps2(run_number) = 1 (Int_t)
//				get_my_ps3(run_number) = 9999 (Int_t)
//				get_my_ps4(run_number) = 9999 (Int_t)
//				get_my_ps5(run_number) = 65535 (Int_t)
//				get_my_ps6(run_number) = 65535 (Int_t)
//				get_my_ps7(run_number) = 65535 (Int_t)
//				get_my_ps8(run_number) = 65535 (Int_t)
//				get_my_beam_pol_sign(run_number)   = -1 (Int_t)
//				get_my_target_pol_sign(run_number) = 1 (Int_t)
//				get_my_t1_accept(run_number,+1) = 720929 (Int_t)
//				get_my_t1_accept(run_number, 0) = 1455472 (Int_t)
//				get_my_t1_accept(run_number,-1) = 717841 (Int_t)
//				get_my_t2_accept(run_number,+1) = 10001 (Int_t)
//				get_my_t2_accept(run_number, 0) = 20392 (Int_t)
//				get_my_t2_accept(run_number,-1) = 10129 (Int_t)
//				get_my_runtype(run_number)   = "pro" (TString)
//				get_my_cell_name(run_number) = "priapus" (TString)
//				get_my_beam_hwp(run_number)  = "OUT" (TString)
//				get_my_target(run_number)    = "pol3he_270" (TString)
//				get_my_comments(run_number)  = "11.17;" (TString)
//				get_my_start_time(run_number) = "2003-08-29 07:21:06" (TDatime)
//				get_my_end_time(run_number)   = "2003-08-29 07:30:16" (TDatime)
//				get_my_beam_energy(run_number)          = 3.319E+03 (Double_t) in MeV
//				get_my_beam_energy_nom(run_number)      = 3.319E+03 (Double_t) in MeV
//				get_my_beam_energy_sigma(run_number)    = 4.300E-01 (Double_t) in MeV
//				get_my_rspec_momentum(run_number)       = 1.835E+03 (Double_t) in MeV
//				get_my_rspec_momentum_nom(run_number)   = 1.835E+03 (Double_t) in MeV
//				get_my_rspec_momentum_sigma(run_number) = 1.300E-03 (Double_t) in MeV
//				get_my_septum_current(run_number)       = 2.332E+02 (Double_t) in Amps
//				get_my_septum_current_set(run_number)   = 2.340E+02 (Double_t) in Amps
//				get_my_septum_current_sigma(run_number) = 0.000E+00 (Double_t) in Amps
//				get_my_beam_current_a(run_number)       = 9.963E+00 (Double_t) in microAmps
//				get_my_beam_current_a_sigma(run_number) = 4.210E-02 (Double_t) in microAmps
//				get_my_beam_current_c(run_number)       = 3.454E+01 (Double_t) in microAmps
//				get_my_beam_current_c_sigma(run_number) = 5.689E-01 (Double_t) in microAmps
//				get_my_beam_pol(run_number)             = 7.664E-01 (Double_t) 0.000 to 1.000
//				get_my_target_pol(run_number)           = 4.000E-01 (Double_t) 0.000 to 1.000
//				get_my_target_density(run_number)       = 1.000E+01 (Double_t) in amagats
//				get_my_n2_target_density(run_number)    = 1.000E+01 (Double_t) in amagats
//				get_my_bcm3(run_number,+1)              = 2.365E+03 (Double_t) in ?
//				get_my_bcm3(run_number, 0)              = 4.801E+03 (Double_t) in ?
//				get_my_bcm3(run_number,-1)              = 2.365E+03 (Double_t) in ?
//				get_my_bcm10(run_number,+1)             = 2.355E+03 (Double_t) in ?
//				get_my_bcm10(run_number, 0)             = 4.782E+03 (Double_t) in ?
//				get_my_bcm10(run_number,-1)             = 2.356E+03 (Double_t) in ?
//				get_my_t1_live(run_number,+1)           = 9.191E-01 (Double_t)
//				get_my_t1_live(run_number, 0)           = 9.161E-01 (Double_t)
//				get_my_t1_live(run_number,-1)           = 9.190E-01 (Double_t)
//				get_my_t2_live(run_number,+1)           = 8.806E-01 (Double_t)
//				get_my_t2_live(run_number, 0)           = 8.806E-01 (Double_t)
//				get_my_t2_live(run_number,-1)           = 8.857E-01 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","cer","lo")  = 3.200E+02 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","cer","hi")  = 1.000E+04 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","ep","lo")   = 8.000E-01 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","ep","hi")   = 1.500E+00 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","ps","lo")   = 1.500E-01 (Double_t)
//				get_my_pid_cut(run_number,"asy","e","ps","hi")   = 1.000E+00 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","cer","lo") = -1.000E+00 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","cer","hi") = 1.000E+02 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","ep","lo")  = 1.200E-01 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","ep","hi")  = 4.800E-01 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","ps","lo")  = 3.000E-02 (Double_t)
//				get_my_pid_cut(run_number,"asy","pi","ps","hi")  = 9.000E-02 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","cer","lo")  = 3.200E+02 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","cer","hi")  = 1.000E+04 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","ep","lo")   = 7.900E-01 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","ep","hi")   = 3.000E+00 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","ps","lo")   = 9.500E-02 (Double_t)
//				get_my_pid_cut(run_number,"cs","e","ps","hi")   = 3.000E+00 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","cer","lo") = -1.000E+09 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","cer","hi") = -1.000E+09 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","ep","lo")  = -1.000E+09 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","ep","hi")  = -1.000E+09 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","ps","lo")  = -1.000E+09 (Double_t)
//				get_my_pid_cut(run_number,"cs","pi","ps","hi")  = -1.000E+09 (Double_t)
//				get_my_efficiency(run_number,"e","cer","det") = 9.99500E-01 (Double_t)
//				get_my_efficiency(run_number,"e","cer","cut") = 9.98000E-01 (Double_t)
//				get_my_efficiency(run_number,"e","sh","det")  = 9.98700E-01 (Double_t)
//				get_my_efficiency(run_number,"e","sh","cut")  = 9.90500E-01 (Double_t)
//				get_my_efficiency(run_number,"e","sci","det") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"e","sci","cut") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"e","vdc","det") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"e","vdc","cut") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","cer","det") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","cer","cut") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","sh","det")  = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","sh","cut")  = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","sci","det") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","sci","cut") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","vdc","det") = -1.00000E+09 (Double_t)
//				get_my_efficiency(run_number,"pi","vdc","cut") = -1.00000E+09 (Double_t)
//


#include "TSQLServer.h"
#include "TSQLResult.h"
#include "TSQLRow.h"
#include "TString.h"
#include "TDatime.h"
#include "Riostream.h"

Bool_t f_is_my_result_NULL = 1;  // NULL flag used to indicate whether query result is NULL or not

// function used to GET value of NULL flag
Bool_t my_result_is_null()	
{ return f_is_my_result_NULL; }

// result is an instance of the class TSQLResult to a generic query to database
TSQLResult *my_generic_query(TString query)
{
	const Char_t *host   = "mysql://uvapos1.jlab.org/masterdb";
//	const Char_t *host   = "mysql://fwing-dhcp52.jlab.org/masterdb";
	const Char_t *uid    = "gdh_user";
	const Char_t *pwd    = "more_cowbell!";
	TSQLServer *masterdb = TSQLServer::Connect(host , uid , pwd);
	TSQLResult *result   = masterdb->Query(query);
	masterdb->Close();
	return result;
}

// result is an instance of the class TString to a generic query keyed by run number to the database
// if the result is an empty set, then the resulting string value is made identical to NULL: ""
TString my_generic_run_query(Int_t run_number = 4199 , const Char_t *column = "polbeam")
{
	TString query("select ");
	query += column;
	query += " from summary where run = ";
	query += run_number;
	TSQLResult *result   = my_generic_query(query);
//	Char_t *field        = result->GetFieldName(0);
	TString value;
	if (result->GetRowCount() == 0)
	{ value = ""; }
	else
	{
		TSQLRow *row = result->Next();
		value = row->GetField(0);
	}
	return value;
}

// result is an instance of the class TString to a query keyed by run number, handles NULL values
TString my_string_result(Int_t run_number = 4199 , const Char_t *column = "comments")
{ 
	f_is_my_result_NULL = 0;
	TString result = my_generic_run_query(run_number,column);
	if (result == "")
	{ 
		result = "NULL";
		f_is_my_result_NULL = 1;
	}
	return result;
}

// result is an integer to a query keyed by run number, handles NULL values
Int_t my_integer_result(Int_t run_number = 4199 , const Char_t *column = "flag")
{ 
	TString result = my_string_result(run_number,column);
	Int_t value;
	if (f_is_my_result_NULL)
	{ value = -999999999; }
	else
	{ value = atoi(result.Data()); }
	return value;
}

// result is a double precision float to a query keyed by run number, handles NULL values
Double_t my_double_result(Int_t run_number = 4199 , const Char_t *column = "polbeam")
{ 
	TString result = my_string_result(run_number,column);
	Double_t value;
	if (f_is_my_result_NULL)
	{ value = -999999999.0; }
	else
	{ value = atof(result.Data()); }
	return value;
}

// result is an instance of the class TDatime to a query keyed by run number, handles NULL values
TDatime my_timestamp_result(Int_t run_number = 4199 , Char_t *column = "start_time")
{
	TString column_convert = "from_unixtime(";
	column_convert += column;
	column_convert += ")";
	TString result = my_string_result(run_number,column_convert.Data());
	if (f_is_my_result_NULL)
	{ result = "1995-01-01 00:00:00"; }
	TDatime value(result.Data());
	return value;
}

// result to a specific query keyed by run number
Int_t get_my_n2_run_number(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"n2_run"); } 

Int_t get_my_empty_run_number(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"empty_run"); } 

Int_t get_my_flag(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"flag"); } 

Int_t get_my_split_number(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"num_file") - 1; } 

Int_t get_my_period(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"period"); } 

Int_t get_my_ps1(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps1"); } 

Int_t get_my_ps2(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps2"); } 

Int_t get_my_ps3(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps3"); } 

Int_t get_my_ps4(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps4"); } 

Int_t get_my_ps5(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps5"); } 

Int_t get_my_ps6(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps6"); } 

Int_t get_my_ps7(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps7"); } 

Int_t get_my_ps8(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"ps8"); } 

Int_t get_my_beam_pol_sign(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"polbeam_sign"); } 

Int_t get_my_target_pol_sign(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"poltar_sign"); } 

Int_t get_my_target_angle(Int_t run_number = 4199) 
{ return my_integer_result(run_number,"tarang"); } 


Int_t get_my_t1_accept(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t1_accept_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_t2_accept(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t2_accept_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_t1_count(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t1_count_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_t2_count(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t2_count_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_coda_count(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("coda_count_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_clock_count(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("clock_count_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_integer_result(run_number,helstr.Data());
} 

Int_t get_my_bcm3_count(Int_t run_number = 4199, Int_t helnum = 0, TString up_or_dn = "up") 
{ 
	TString helstr("bcm3_");
	if ((up_or_dn != "up") && (up_or_dn != "dn"))
	{
		f_is_my_result_NULL = 1;
		return -999999999;
	}
	else
	{
		helstr += up_or_dn;
		helstr += "_count_";
		if (helnum >= +1)
		{ helstr += "pos"; }
		else if (helnum <= -1)
		{ helstr += "neg"; }
		else
		{ helstr += "non"; }
		return my_integer_result(run_number,helstr.Data());
	}
} 

Int_t get_my_bcm10_count(Int_t run_number = 4199, Int_t helnum = 0, TString up_or_dn = "up") 
{ 
	TString helstr("bcm10_");
	if ((up_or_dn != "up") && (up_or_dn != "dn"))
	{
		f_is_my_result_NULL = 1;
		return -999999999;
	}
	else
	{
		helstr += up_or_dn;
		helstr += "_count_";
		if (helnum >= +1)
		{ helstr += "pos"; }
		else if (helnum <= -1)
		{ helstr += "neg"; }
		else
		{ helstr += "non"; }
		return my_integer_result(run_number,helstr.Data());
	}
} 

TString get_my_runtype(Int_t run_number = 4199)
{ return my_string_result(run_number,"runtype"); }

TString get_my_cell_name(Int_t run_number = 4199)
{ return my_string_result(run_number,"cell"); }

TString get_my_beam_hwp(Int_t run_number = 4199)
{ return my_string_result(run_number,"bhwp"); }

TString get_my_target1(Int_t run_number = 4199)
{ return my_string_result(run_number,"target1"); }

TString get_my_target2(Int_t run_number = 4199)
{ return my_string_result(run_number,"target2"); }

TString get_my_target(Int_t run_number = 4199)
{ 
	TString target1 = my_string_result(run_number,"target1");
	TString target2 = my_string_result(run_number,"target2");
	TString value;
	if (target1 == "NULL")
	{
		f_is_my_result_NULL = 1;
		value = "NULL"; 
	}
	else if (target2 == "NULL")
	{
		f_is_my_result_NULL = 0;
		value = target1;
	}
	else
	{
		f_is_my_result_NULL = 0;
		value = target1 + "_" + target2;
	}
	return value;
}

TString get_my_comments(Int_t run_number = 4199)
{ return my_string_result(run_number,"comments"); }

TDatime get_my_start_time(Int_t run_number = 4199)
{ return my_timestamp_result(run_number,"start_time"); }

TDatime get_my_end_time(Int_t run_number = 4199)
{ return my_timestamp_result(run_number,"end_time"); }

Double_t get_my_beam_energy_nom(Int_t run_number = 4199) 
{ return 1000.0*my_double_result(run_number,"nom_ebeam"); } 

Double_t get_my_beam_energy(Int_t run_number = 4199) 
{ return my_double_result(run_number,"ebeam"); } 

Double_t get_my_beam_energy_sigma(Int_t run_number = 4199) 
{ return my_double_result(run_number,"ebeam_sigma"); } 

Double_t get_my_rspec_momentum_nom(Int_t run_number = 4199) 
{ return my_double_result(run_number,"nom_pmom"); } 

Double_t get_my_rspec_momentum(Int_t run_number = 4199) 
{ return my_double_result(run_number,"pmom"); } 

Double_t get_my_rspec_momentum_sigma(Int_t run_number = 4199) 
{ return my_double_result(run_number,"pmom_sigma"); } 

Double_t get_my_septum_current(Int_t run_number = 4199) 
{ return my_double_result(run_number,"septum"); } 

Double_t get_my_septum_current_set(Int_t run_number = 4199) 
{ return my_double_result(run_number,"septum_set"); } 

Double_t get_my_septum_current_sigma(Int_t run_number = 4199) 
{ return my_double_result(run_number,"septum_sigma"); } 

Double_t get_my_beam_current_a(Int_t run_number = 4199) 
{ return my_double_result(run_number,"a_beam_curr"); } 

Double_t get_my_beam_current_a_sigma(Int_t run_number = 4199) 
{ return my_double_result(run_number,"a_beam_curr_sig"); } 

Double_t get_my_beam_current_c(Int_t run_number = 4199) 
{ return my_double_result(run_number,"c_beam_curr"); } 

Double_t get_my_beam_current_c_sigma(Int_t run_number = 4199) 
{ return my_double_result(run_number,"c_beam_curr_sig"); } 

Double_t get_my_beam_pol(Int_t run_number = 4199) 
{ return my_double_result(run_number,"polbeam"); } 

Double_t get_my_target_density(Int_t run_number = 4199) 
{ return my_double_result(run_number,"dentar"); } 

Double_t get_my_n2_target_density(Int_t run_number = 4199) 
{ return my_double_result(run_number,"dentar_n2"); } 

Double_t get_my_target_pol(Int_t run_number = 4199) 
{ return my_double_result(run_number,"poltar"); } 

Double_t get_my_n2_dilution(Int_t run_number = 4199) 
{ return my_double_result(run_number,"n2_dilution"); } 

Double_t get_my_empty_dilution(Int_t run_number = 4199) 
{ return my_double_result(run_number,"empty_dilution"); } 

Double_t get_my_bcm3(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("bcm3_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_double_result(run_number,helstr.Data());
} 

Double_t get_my_bcm10(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("bcm10_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_double_result(run_number,helstr.Data());
} 

Double_t get_my_t1_live(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t1_livetime_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_double_result(run_number,helstr.Data());
} 

Double_t get_my_t2_live(Int_t run_number = 4199, Int_t helnum = 0) 
{ 
	TString helstr("t2_livetime_");
	if (helnum >= +1)
	{ helstr += "pos"; }
	else if (helnum <= -1)
	{ helstr += "neg"; }
	else
	{ helstr += "non"; }
	return my_double_result(run_number,helstr.Data());
}

Double_t get_my_pid_cut(Int_t run_number = 4199 , TString analysis_type = "asy" , TString particle = "e" , TString type = "cer" , TString limit = "lo") 
{
	TString pidstr = "pid_" + analysis_type + "_"  + particle  + "_" + type + "_" + limit;
	if ( ((analysis_type == "cs") || (analysis_type == "asy")) && ((particle == "e") || (particle == "pi")) && ((type == "cer") || (type == "ep") || (type == "ps")) && ((limit == "hi") || (limit == "lo")) )
	{ return my_double_result(run_number,pidstr.Data()); }
	else
	{
		cout << "Invalid cut ";
		cout << "(analysis_type =\"" << analysis_type << "\" -> must be \"cs\" or \"asy\") and ";
		cout << "(particle =\"" << particle << "\" -> must be \"e\" or \"pi\") and ";
		cout << "(type = \"" << type << "\" -> must be \"cer\" , \"ep\" , or \"ps\") and ";
		cout << "(limit = \"" << limit << "\" -> must be \"lo\" or \"hi\")" << endl;
		f_is_my_result_NULL = 1;
		return -999999999.000;
	}
} 

Double_t get_my_efficiency(Int_t run_number = 4199 , TString particle = "e" , TString detector = "cer" , TString type = "det") 
{
	TString effstr = "eff_" + particle  + "_" + detector + "_" + type;
	if ( ((particle == "e") || (particle == "pi")) && ((detector == "cer") || (detector == "sh") || (detector == "sci") || (detector == "vdc")) && ((type == "det") || (type == "cut")) )
	{ return my_double_result(run_number,effstr.Data()); }
	else
	{
		cout << "Invalid efficiency ";
		cout << "(particle =\"" << particle << "\" -> must be \"e\" or \"pi\") and ";
		cout << "(detector = \"" << detector << "\" -> must be \"cer\" , \"sh\" , \"sci\" , or \"vdc\") and ";
		cout << "(type = \"" << type << "\" -> must be \"det\" or \"cut\")" << endl;
		f_is_my_result_NULL = 1;
		return -999999999.000;
	}
} 

// prints all possible values that can be queried for a particular run
// gives the function name, arguments, resulting data type
void get_my_usage(Int_t run_number = 4199)
{
	cout << endl;
	printf("Available Information for Run %d (Int_t):\n\n",run_number);
	cout << "get_my_usage(); ---> prints *this* out!!!\n";
	cout << "my_result_is_null() = 0 for FALSE and 1 for TRUE, always call this function to verify that the result is not garbage!\n\n";
	printf("get_my_n2_run_number(run_number)    = %d (Int_t)\n" , get_my_n2_run_number(run_number) );
	printf("get_my_empty_run_number(run_number) = %d (Int_t)\n" , get_my_empty_run_number(run_number) );
	printf("get_my_flag(run_number)         = %d (Int_t)\n" , get_my_flag(run_number) );
	printf("get_my_split_number(run_number) = %d (Int_t)\n" , get_my_split_number(run_number) );
	printf("get_my_period(run_number)       = %d (Int_t)\n" , get_my_period(run_number) );
	printf("get_my_ps1(run_number) = %d (Int_t)\n" , get_my_ps1(run_number) );
	printf("get_my_ps2(run_number) = %d (Int_t)\n" , get_my_ps2(run_number) );
	printf("get_my_ps3(run_number) = %d (Int_t)\n" , get_my_ps3(run_number) );
	printf("get_my_ps4(run_number) = %d (Int_t)\n" , get_my_ps4(run_number) );
	printf("get_my_ps5(run_number) = %d (Int_t)\n" , get_my_ps5(run_number) );
	printf("get_my_ps6(run_number) = %d (Int_t)\n" , get_my_ps6(run_number) );
	printf("get_my_ps7(run_number) = %d (Int_t)\n" , get_my_ps7(run_number) );
	printf("get_my_ps8(run_number) = %d (Int_t)\n" , get_my_ps8(run_number) );
	printf("get_my_beam_pol_sign(run_number)   = %d (Int_t)\n" , get_my_beam_pol_sign(run_number) );
	printf("get_my_target_pol_sign(run_number) = %d (Int_t)\n" , get_my_target_pol_sign(run_number) );
	printf("get_my_target_angle(run_number) = %d (Int_t)\n" , get_my_target_angle(run_number) );
	printf("get_my_t1_accept(run_number,+1) = %d (Int_t)\n" , get_my_t1_accept(run_number,+1) );
	printf("get_my_t1_accept(run_number, 0) = %d (Int_t)\n" , get_my_t1_accept(run_number, 0) );
	printf("get_my_t1_accept(run_number,-1) = %d (Int_t)\n" , get_my_t1_accept(run_number,-1) );
	printf("get_my_t2_accept(run_number,+1) = %d (Int_t)\n" , get_my_t2_accept(run_number,+1) );
	printf("get_my_t2_accept(run_number, 0) = %d (Int_t)\n" , get_my_t2_accept(run_number, 0) );
	printf("get_my_t2_accept(run_number,-1) = %d (Int_t)\n" , get_my_t2_accept(run_number,-1) );
	printf("get_my_bcm3_count(run_number,+1,\"up\") = %d (Int_t)\n" , get_my_bcm3_count(run_number,+1,"up") );
	printf("get_my_bcm3_count(run_number, 0,\"up\") = %d (Int_t)\n" , get_my_bcm3_count(run_number, 0,"up") );
	printf("get_my_bcm3_count(run_number,-1,\"up\") = %d (Int_t)\n" , get_my_bcm3_count(run_number,-1,"up") );
	printf("get_my_bcm3_count(run_number,+1,\"dn\") = %d (Int_t)\n" , get_my_bcm3_count(run_number,+1,"dn") );
	printf("get_my_bcm3_count(run_number, 0,\"dn\") = %d (Int_t)\n" , get_my_bcm3_count(run_number, 0,"dn") );
	printf("get_my_bcm3_count(run_number,-1,\"dn\") = %d (Int_t)\n" , get_my_bcm3_count(run_number,-1,"dn") );
	printf("get_my_bcm10_count(run_number,+1,\"up\") = %d (Int_t)\n" , get_my_bcm10_count(run_number,+1,"up") );
	printf("get_my_bcm10_count(run_number, 0,\"up\") = %d (Int_t)\n" , get_my_bcm10_count(run_number, 0,"up") );
	printf("get_my_bcm10_count(run_number,-1,\"up\") = %d (Int_t)\n" , get_my_bcm10_count(run_number,-1,"up") );
	printf("get_my_bcm10_count(run_number,+1,\"dn\") = %d (Int_t)\n" , get_my_bcm10_count(run_number,+1,"dn") );
	printf("get_my_bcm10_count(run_number, 0,\"dn\") = %d (Int_t)\n" , get_my_bcm10_count(run_number, 0,"dn") );
	printf("get_my_bcm10_count(run_number,-1,\"dn\") = %d (Int_t)\n" , get_my_bcm10_count(run_number,-1,"dn") );
	printf("get_my_clock_count(run_number,+1) = %d (Int_t)\n" , get_my_clock_count(run_number,+1) );
	printf("get_my_clock_count(run_number, 0) = %d (Int_t)\n" , get_my_clock_count(run_number, 0) );
	printf("get_my_clock_count(run_number,-1) = %d (Int_t)\n" , get_my_clock_count(run_number,-1) );
	printf("get_my_coda_count(run_number,+1) = %d (Int_t)\n" , get_my_coda_count(run_number,+1) );
	printf("get_my_coda_count(run_number, 0) = %d (Int_t)\n" , get_my_coda_count(run_number, 0) );
	printf("get_my_coda_count(run_number,-1) = %d (Int_t)\n" , get_my_coda_count(run_number,-1) );
	printf("get_my_t2_count(run_number,+1) = %d (Int_t)\n" , get_my_t2_count(run_number,+1) );
	printf("get_my_t2_count(run_number, 0) = %d (Int_t)\n" , get_my_t2_count(run_number, 0) );
	printf("get_my_t2_count(run_number,-1) = %d (Int_t)\n" , get_my_t2_count(run_number,-1) );
	printf("get_my_t1_count(run_number,+1) = %d (Int_t)\n" , get_my_t1_count(run_number,+1) );
	printf("get_my_t1_count(run_number, 0) = %d (Int_t)\n" , get_my_t1_count(run_number, 0) );
	printf("get_my_t1_count(run_number,-1) = %d (Int_t)\n" , get_my_t1_count(run_number,-1) );
	cout << "get_my_runtype(run_number)   = \"" << get_my_runtype(run_number)   << "\" (TString)\n";
	cout << "get_my_cell_name(run_number) = \"" << get_my_cell_name(run_number) << "\" (TString)\n";
	cout << "get_my_beam_hwp(run_number)  = \"" << get_my_beam_hwp(run_number)  << "\" (TString)\n";
	cout << "get_my_target1(run_number)   = \"" << get_my_target1(run_number)    << "\" (TString)\n";
	cout << "get_my_target2(run_number)   = \"" << get_my_target2(run_number)    << "\" (TString)\n";
	cout << "get_my_target(run_number)    = \"" << get_my_target(run_number)    << "\" (TString)\n";
	cout << "get_my_comments(run_number)  = \"" << get_my_comments(run_number)  << "\" (TString)\n";
	cout << "get_my_start_time(run_number) = \"" << get_my_start_time(run_number).AsSQLString() << "\" (TDatime)\n";
	cout << "get_my_end_time(run_number)   = \"" <<   get_my_end_time(run_number).AsSQLString() << "\" (TDatime)\n";
	printf("get_my_beam_energy(run_number)          = %.3E (Double_t) in MeV\n" , get_my_beam_energy(run_number) );
	printf("get_my_beam_energy_nom(run_number)      = %.3E (Double_t) in MeV\n" , get_my_beam_energy_nom(run_number) );
	printf("get_my_beam_energy_sigma(run_number)    = %.3E (Double_t) in MeV\n" , get_my_beam_energy_sigma(run_number) );
	printf("get_my_rspec_momentum(run_number)       = %.3E (Double_t) in MeV\n" , get_my_rspec_momentum(run_number) );
	printf("get_my_rspec_momentum_nom(run_number)   = %.3E (Double_t) in MeV\n" , get_my_rspec_momentum_nom(run_number) );
	printf("get_my_rspec_momentum_sigma(run_number) = %.3E (Double_t) in MeV\n" , get_my_rspec_momentum_sigma(run_number) );
	printf("get_my_septum_current(run_number)       = %.3E (Double_t) in Amps\n" , get_my_septum_current(run_number) );
	printf("get_my_septum_current_set(run_number)   = %.3E (Double_t) in Amps\n" , get_my_septum_current_set(run_number) );
	printf("get_my_septum_current_sigma(run_number) = %.3E (Double_t) in Amps\n" , get_my_septum_current_sigma(run_number) );
	printf("get_my_beam_current_a(run_number)       = %.3E (Double_t) in microAmps\n" ,	get_my_beam_current_a(run_number) );
	printf("get_my_beam_current_a_sigma(run_number) = %.3E (Double_t) in microAmps\n" , get_my_beam_current_a_sigma(run_number) );
	printf("get_my_beam_current_c(run_number)       = %.3E (Double_t) in microAmps\n" , get_my_beam_current_c(run_number) );
	printf("get_my_beam_current_c_sigma(run_number) = %.3E (Double_t) in microAmps\n" ,	get_my_beam_current_c_sigma(run_number) );
	printf("get_my_beam_pol(run_number)             = %.3E (Double_t) 0.000 to 1.000\n" , get_my_beam_pol(run_number) );
	printf("get_my_target_pol(run_number)           = %.3E (Double_t) 0.000 to 1.000\n" , get_my_target_pol(run_number) );
	printf("get_my_target_density(run_number)       = %.3E (Double_t) in amagats\n" , get_my_target_density(run_number) );
	printf("get_my_n2_target_density(run_number)    = %.3E (Double_t) in amagats\n" , get_my_n2_target_density(run_number) );
	printf("get_my_n2_dilution(run_number)          = %.3E (Double_t) \n" , get_my_n2_dilution(run_number) );
	printf("get_my_empty_dilution(run_number)       = %.3E (Double_t) \n" , get_my_empty_dilution(run_number) );
	printf("get_my_bcm3(run_number,+1)              = %.3E (Double_t) in ?\n" ,	get_my_bcm3(run_number,+1) );
	printf("get_my_bcm3(run_number, 0)              = %.3E (Double_t) in ?\n" ,	get_my_bcm3(run_number, 0) );
	printf("get_my_bcm3(run_number,-1)              = %.3E (Double_t) in ?\n" ,	get_my_bcm3(run_number,-1) );
	printf("get_my_bcm10(run_number,+1)             = %.3E (Double_t) in ?\n" , get_my_bcm10(run_number,+1) );
	printf("get_my_bcm10(run_number, 0)             = %.3E (Double_t) in ?\n" , get_my_bcm10(run_number, 0) );
	printf("get_my_bcm10(run_number,-1)             = %.3E (Double_t) in ?\n" , get_my_bcm10(run_number,-1) );
	printf("get_my_t1_live(run_number,+1)           = %.3E (Double_t)\n" , get_my_t1_live(run_number,+1) );
	printf("get_my_t1_live(run_number, 0)           = %.3E (Double_t)\n" , get_my_t1_live(run_number, 0) );
	printf("get_my_t1_live(run_number,-1)           = %.3E (Double_t)\n" , get_my_t1_live(run_number,-1) );
	printf("get_my_t2_live(run_number,+1)           = %.3E (Double_t)\n" , get_my_t2_live(run_number,+1) );
	printf("get_my_t2_live(run_number, 0)           = %.3E (Double_t)\n" , get_my_t2_live(run_number, 0) );
	printf("get_my_t2_live(run_number,-1)           = %.3E (Double_t)\n" , get_my_t2_live(run_number,-1) );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"cer\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","cer","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"cer\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","cer","hi") );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"ep\",\"lo\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","ep","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"ep\",\"hi\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","ep","hi") );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"ps\",\"lo\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","ps","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"e\",\"ps\",\"hi\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","e","ps","hi") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"cer\",\"lo\") = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","cer","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"cer\",\"hi\") = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","cer","hi") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"ep\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","ep","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"ep\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","ep","hi") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"ps\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","ps","lo") );
	printf("get_my_pid_cut(run_number,\"asy\",\"pi\",\"ps\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"asy","pi","ps","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"cer\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","cer","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"cer\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","cer","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"ep\",\"lo\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","ep","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"ep\",\"hi\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","ep","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"ps\",\"lo\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","ps","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"e\",\"ps\",\"hi\")   = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","e","ps","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"cer\",\"lo\") = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","cer","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"cer\",\"hi\") = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","cer","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"ep\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","ep","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"ep\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","ep","hi") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"ps\",\"lo\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","ps","lo") );
	printf("get_my_pid_cut(run_number,\"cs\",\"pi\",\"ps\",\"hi\")  = %.3E (Double_t)\n" , get_my_pid_cut(run_number,"cs","pi","ps","hi") );
	printf("get_my_efficiency(run_number,\"e\",\"cer\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","cer","det") );
	printf("get_my_efficiency(run_number,\"e\",\"cer\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","cer","cut") );
	printf("get_my_efficiency(run_number,\"e\",\"sh\",\"det\")  = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","sh","det") );
	printf("get_my_efficiency(run_number,\"e\",\"sh\",\"cut\")  = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","sh","cut") );
	printf("get_my_efficiency(run_number,\"e\",\"sci\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","sci","det") );
	printf("get_my_efficiency(run_number,\"e\",\"sci\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","sci","cut") );
	printf("get_my_efficiency(run_number,\"e\",\"vdc\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","vdc","det") );
	printf("get_my_efficiency(run_number,\"e\",\"vdc\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"e","vdc","cut") );
	printf("get_my_efficiency(run_number,\"pi\",\"cer\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","cer","det") );
	printf("get_my_efficiency(run_number,\"pi\",\"cer\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","cer","cut") );
	printf("get_my_efficiency(run_number,\"pi\",\"sh\",\"det\")  = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","sh","det") );
	printf("get_my_efficiency(run_number,\"pi\",\"sh\",\"cut\")  = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","sh","cut") );
	printf("get_my_efficiency(run_number,\"pi\",\"sci\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","sci","det") );
	printf("get_my_efficiency(run_number,\"pi\",\"sci\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","sci","cut") );
	printf("get_my_efficiency(run_number,\"pi\",\"vdc\",\"det\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","vdc","det") );
	printf("get_my_efficiency(run_number,\"pi\",\"vdc\",\"cut\") = %.5E (Double_t)\n" , get_my_efficiency(run_number,"pi","vdc","cut") );
	cout << endl;
}