// once this calibration function is called, the default calibration is
// overridden.
public virtual void OverrideDefaultCalibrator(CalibrationType calibType, double A, double B, double C)
{
mbln_use_specified_calibration = true;
menm_calibration_type = calibType;
var calib = new Calibrations.Calibrator(menm_calibration_type);
calib.NumPointsInScan = mint_num_points_in_scan;
calib.LowMassFrequency = mdbl_low_mass_freq;
calib.SampleRate = mdbl_sample_rate;
mdbl_calib_const_a = A;
mdbl_calib_const_b = B;
mdbl_calib_const_c = C;
calib.SetCalibrationEquationParams(mdbl_calib_const_a, mdbl_calib_const_b, mdbl_calib_const_c);
SetCalibrator(calib);
}
private void ExtractSettings(int start_p, string option_str)
{
short short_bluff;
double sample_rate;
double anal_trap_voltage;
double conductance_lim_voltage, source_trap_voltage;
short calibration_type;
double low_mass_frequency;
int temp_int;
Helpers.GetInt32(option_str, "dataPoints:", start_p, out temp_int);
mint_num_points_in_scan = temp_int;
Helpers.GetDouble(option_str, "dwell:", start_p, out sample_rate);
if (sample_rate != 0)
{
sample_rate = 1 / sample_rate;
}
if (Helpers.GetInt16(option_str, "Zerofill=true", start_p, out short_bluff))
{
mbln_zero_fill = true;
}
short temp;
Helpers.GetInt16(option_str, "ZerofillNumber=", start_p, out temp);
mshort_num_zero_fill = temp;
Helpers.GetDouble(option_str, "analyzerTrapVoltage:", start_p, out anal_trap_voltage);
Helpers.GetDouble(option_str, "conductanceLimitVoltage:", start_p, out conductance_lim_voltage);
Helpers.GetDouble(option_str, "sourceTrapVoltage:", start_p, out source_trap_voltage);
Helpers.GetInt16(option_str, "calType:", start_p, out calibration_type);
Helpers.GetDouble(option_str, "calReferenceFrequency:", start_p, out low_mass_frequency);
double calib_a = 0;
bool found_a;
found_a = Helpers.GetDouble(option_str, "calC0:", start_p, out calib_a);
double calib_b = 0;
bool found_b;
found_b = Helpers.GetDouble(option_str, "calC1:", start_p, out calib_b);
double calib_c = 0;
bool found_c;
found_c = Helpers.GetDouble(option_str, "calC2:", start_p, out calib_c);
Helpers.GetDouble(option_str, "chirpStartFrequency:", start_p, out low_mass_frequency);
if (Helpers.GetInt16(option_str, "detectType:analyzer", start_p, out short_bluff))
{
calib_b = calib_b * Math.Abs(anal_trap_voltage);
}
else
{
calib_b = calib_b * Math.Abs(source_trap_voltage);
}
if (calibration_type == 2)
{
// Call ErrorMess.LogError("Warning, type 2 calibration, make sure intensity option is defined in calibration generation dialog!", ps.FileName)
calib_c = calib_c * Math.Abs(anal_trap_voltage);
}
if (calib_a == 0 && calib_b == 0 && calib_c == 0)
{
//no header cal data found, use defaults!
//Call ErrorMess.LogError("No calibration data in file, using defaults...", ps.FileName)
calib_a = 108205311.2284;
calib_b = -1767155067.018;
calib_c = 29669467490280;
}
menm_calibration_type = (CalibrationType)calibration_type;
var calib = new Calibrations.Calibrator(menm_calibration_type);
calib.NumPointsInScan = this.mint_num_points_in_scan;
calib.LowMassFrequency = low_mass_frequency;
calib.SampleRate = sample_rate;
calib.SetCalibrationEquationParams(calib_a, calib_b, calib_c);
SetCalibrator(calib);
}
private bool LoadFile(string f_name, int scan_num)
{
const int flt_size = sizeof(float);
using (var fin = new FileStream(f_name, FileMode.Open, FileAccess.Read, FileShare.Read))
{
//std.ifstream fin(f_name, std.ios.binary);
var found_data = ReadHeader(fin);
if (!found_data)
{
fin.Close();
return(false);
}
var pos = fin.Position;
if (mint_allocated_size < mint_num_points_in_scan)
{
mint_allocated_size = mint_num_points_in_scan;
if (mptr_data != null)
{
mptr_data = null;
mptr_data_copy = null;
}
mptr_data = new float[mint_num_points_in_scan];
mptr_data_copy = new float[mint_num_points_in_scan];
}
fin.ReadByte();
pos = fin.Position;
fin.Flush();
fin.Seek(pos, SeekOrigin.Begin);
var buffer = new byte[mint_num_points_in_scan * flt_size];
var num_read = fin.Read(buffer, 0, mint_num_points_in_scan * flt_size);
//Buffer.BlockCopy(buffer, 0, mptr_data, 0, mint_num_points_in_scan * flt_size);
Buffer.BlockCopy(buffer, 0, mptr_data, 0, num_read);
}
var max_intensity = -1 * double.MaxValue;
var min_intensity = double.MaxValue;
const int interval_size = 2000;
var skip = (mint_num_points_in_scan - 1) / interval_size + 1;
var max_side = true; // to take reading from max size.
for (var i = 0; i < mint_num_points_in_scan; i += skip)
{
var current_max_intensity = -1 * double.MaxValue;
var current_min_intensity = double.MaxValue;
for (var j = i; j < mint_num_points_in_scan && j < i + skip; j++)
{
if (current_max_intensity < mptr_data[j])
{
current_max_intensity = mptr_data[j];
}
if (current_min_intensity > mptr_data[j])
{
current_min_intensity = mptr_data[j];
}
}
double current_intensity;
if (max_side)
{
current_intensity = current_max_intensity;
max_side = false;
}
else
{
current_intensity = current_min_intensity;
max_side = true;
}
if (max_intensity < current_intensity)
{
max_intensity = current_intensity;
}
if (min_intensity > current_intensity)
{
min_intensity = current_intensity;
}
}
mdbl_signal_range = (max_intensity - min_intensity);
if (mbln_tic_file)
{
menm_calibration_type = (CalibrationType)5;
}
if (menmApodizationType != ApodizationType.NOAPODIZATION)
{
Engine.Utilities.Apodization.Apodize(mdbl_apodization_min_x, mdbl_apodization_max_x,
mdbl_sample_rate, false, menmApodizationType, mptr_data, mint_num_points_in_scan,
mint_apodization_apex_percent);
}
if (mshort_num_zeros != 0)
{
mint_allocated_size = mint_num_points_in_scan * (1 << mshort_num_zeros);
var temp = new float[mint_allocated_size];
Buffer.BlockCopy(mptr_data, 0, temp, 0, mint_num_points_in_scan * sizeof(float));
for (var zeroIndex = mint_num_points_in_scan;
zeroIndex < mint_allocated_size;
zeroIndex++)
{
temp[zeroIndex] = 0;
}
if (mptr_data != null)
{
mptr_data = null;
mptr_data_copy = null;
}
mptr_data = temp;
mptr_data_copy = new float[mint_allocated_size];
}
if (!mbln_use_specified_calibration || mobj_calibrator == null)
{
var calib = new Calibrations.Calibrator(menm_calibration_type);
calib.NumPointsInScan = mint_num_points_in_scan;
calib.LowMassFrequency = mdbl_low_mass_freq;
calib.SampleRate = mdbl_sample_rate;
//[gord] this hack is meant to reverse the sign of calibrationConstantB, resulting in the correct
//m/z calculation for CalibrationType 9
if (menm_calibration_type == (CalibrationType)9)
{
mdbl_calib_const_b = -1 * mdbl_calib_const_b;
}
calib.SetCalibrationEquationParams(mdbl_calib_const_a, mdbl_calib_const_b, mdbl_calib_const_c);
SetCalibrator(calib);
}
else
{
mobj_calibrator.NumPointsInScan = mint_num_points_in_scan;
mobj_calibrator.LowMassFrequency = mdbl_low_mass_freq;
mobj_calibrator.SampleRate = mdbl_sample_rate;
}
return(true);
}
private int FindHeaderParams()
{
string line;
string sub;
var pos = 0;
double ML1 = 0;
double ML2 = 0;
double SW_h = 0;
double FR_low = 0;
var byte_order = 0;
var TD = 0;
var NF = 0;
if (!File.Exists(marr_headerName))
{
return(-1); // File does not exist!
}
// Open header
using (
var acqusHeader =
new StreamReader(new FileStream(marr_headerName, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
// Read first line
while (!acqusHeader.EndOfStream)
{
line = acqusHeader.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
// Find the name,value pair within the acqus header file.
if ((pos = line.IndexOf("##$ML1= ", StringComparison.InvariantCulture)) != -1)
{
pos += 7;
ML1 = double.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$ML2= ", StringComparison.InvariantCulture)) != -1)
{
pos += 7;
ML2 = double.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$SW_h= ", StringComparison.InvariantCulture)) != -1)
{
pos += 8;
SW_h = double.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$BYTORDA= ", StringComparison.InvariantCulture)) != -1)
{
pos += 12;
byte_order = int.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$TD= ", StringComparison.InvariantCulture)) != -1)
{
pos += 6;
TD = int.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$FR_low= ", StringComparison.InvariantCulture)) != -1)
{
pos += 9;
FR_low = double.Parse(line.Substring(pos, line.Length - pos - 1));
}
if ((pos = line.IndexOf("##$NF= ", StringComparison.InvariantCulture)) != -1)
{
pos += 6;
NF = int.Parse(line.Substring(pos, line.Length - pos - 1));
}
}
mint_num_spectra = NF;
// Done.
}
// It's in ICR-2LS...
SW_h *= 2.0;
if (SW_h > FR_low)
{
FR_low = 0.0;
}
var calib = new Calibrations.Calibrator(CalibrationType.A_OVER_F_PLUS_B);
SetDataSize(TD);
calib.NumPointsInScan = TD;
calib.LowMassFrequency = FR_low;
calib.SampleRate = SW_h;
calib.SetCalibrationEquationParams(ML1, ML2, 0.0);
SetCalibrator(calib);
return(0); // success
//[gord] delete later - this has been moved to method: GetNumSpectraFromFileSizeInfo, called elsewhere
//// Now we need to get the size of the data so we can find out the number of scans.
//int fh;
//fh = _open(marr_serName, _O_RDONLY | _O_BINARY );
//if (fh == ENOENT || fh == -1 )
//{
// // try using the fid extention instead of the .ser business.
// int len = strlen(marr_serName);
// marr_serName[len-3] = 'f';
// marr_serName[len-2] = 'i';
// marr_serName[len-1] = 'd';
// fh = _open(marr_serName, _O_RDONLY | _O_BINARY );
//}
///* Seek the beginning of the file: */
//__int64 pos64 = 0;
//pos64 = _lseeki64(fh, 0, SEEK_END );
//__int64 blockSizeInBytes = (__int64) (sizeof(int) * mint_num_points_in_scan);
//mint_num_spectra = (int)((pos64+2) / blockSizeInBytes); // add 2 just in case we have an exact multiple - 1.
//_close( fh );
}