void testFind() { FrequencyData fd; copy(data_, data_+dataSize_, back_inserter(fd.data())); if (os_) copy(fd.data().begin(), fd.data().end(), ostream_iterator<FrequencyDatum>(*os_, "\n")); fd.analyze(); PeakData pd; pd.scans.resize(3); const double noiseFactor = 1; auto_ptr<PeakDetectorNaive> pdn1 = PeakDetectorNaive::create(noiseFactor, 1); pdn1->findPeaks(fd, pd.scans[0]); unit_assert(pd.scans[0].peakFamilies.size() == 3); auto_ptr<PeakDetectorNaive> pdn2 = PeakDetectorNaive::create(noiseFactor, 2); pdn2->findPeaks(fd, pd.scans[1]); unit_assert(pd.scans[1].peakFamilies.size() == 2); auto_ptr<PeakDetectorNaive> pdn3 = PeakDetectorNaive::create(noiseFactor, 3); pdn3->findPeaks(fd, pd.scans[2]); unit_assert(pd.scans[2].peakFamilies.size() == 1); if (os_) { *os_ << "pd:\n" << pd << endl; for (unsigned int i=0; i<pd.scans.size(); i++) { *os_ << "scan " << i << ":\n"; *os_ << pd.scans[i] << endl; } } }
void testNoiseFloorVarianceCalculation() { if (os_) *os_ << "testNoiseFloorVarianceCalculation()\n"; if (os_) *os_ << setprecision(10); // test noise floor calculation on sample frequency data string filename = "FrequencyDataTest.cfd.temp.txt"; ofstream temp(filename.c_str()); temp << sampleFrequencyData_; temp.close(); FrequencyData fd(filename); boost::filesystem::remove(filename); double result = fd.cutoffNoiseFloor(); if (os_) *os_ << "result: " << result << endl; unit_assert_equal(result, 29000, 1000); // test noise floor calculation on sample mass data FrequencyData fdMasses; CalibrationParameters cp = CalibrationParameters::thermo_FT(); for (RawMassDatum* p=sampleMassData_; p!=sampleMassData_+sampleMassDataSize_; ++p) fdMasses.data().push_back(FrequencyDatum(cp.frequency(p->mz), p->intensity)); fdMasses.analyze(); double result2 = fdMasses.cutoffNoiseFloor(); if (os_) *os_ << "result2: " << result2 << endl; unit_assert_equal(result2, 6000, 1000); }
int noise(const vector<string>& args) { if (args.size() != 2) throw runtime_error(usage_); const string& inputFilename = args[0]; const string& outputFilename = args[1]; const FrequencyData in(inputFilename); FrequencyData out; FrequencyData::container& data = out.data(); const double sd = 1/sqrt(2.); Random::initialize(); for (FrequencyData::const_iterator it=in.data().begin(); it!=in.data().end(); ++it) { complex<double> noise(Random::gaussian(sd), Random::gaussian(sd)); data.push_back(FrequencyDatum(it->x, noise)); } out.analyze(); out.write(outputFilename); return 0; }
void NoisyData::errorFunctionCheck() { cout << "errorFunctionCheck()\n"; const ublas::vector<double>& p = tlp_.parameters(); for (double delta=1.; delta>1e-9; delta/=10.) { TruncatedLorentzianParameters tlp_shifted(tlp_); tlp_shifted.f0 += delta; const ublas::vector<double>& p_shifted = tlp_shifted.parameters(); double e = 0; double e_shifted = 0; double de1 = 0; double de2 = 0; for (FrequencyData::iterator it=fd_.data().begin(); it!=fd_.data().end(); ++it) { double f = it->x; complex<double> L = L_(f, p); complex<double> L_shifted = L_(f, p_shifted); complex<double> noise = it->y - L; complex<double> dL = L_.dp(f, p)(TruncatedLorentzian::F0); complex<double> d2L = L_.dp2(f, p)(TruncatedLorentzian::F0, TruncatedLorentzian::F0); e += norm(noise); e_shifted += norm(it->y - L_shifted); complex<double> term1 = dL + d2L*delta; complex<double> term2 = dL*delta + .5*d2L*delta*delta - noise; de1 += 2*real(term1 * conj(term2)); complex<double> term = norm(dL)*delta - dL*conj(noise) - d2L*conj(noise)*delta; de2 += 2*real(term); } double differential = (e_shifted - e) / delta; cout << delta << " " << differential << " " << de1 << " " << de2 << endl; } }
void initializeWithTestData(FrequencyData& fd) { for (TestDatum* datum=testData_; datum<testData_+testDataSize_; datum++) fd.data().push_back(FrequencyDatum(datum->frequency, complex<double>(datum->real, datum->imaginary))); fd.observationDuration(testDataObservationDuration_); fd.calibrationParameters(CalibrationParameters(testDataCalibrationA_, testDataCalibrationB_)); fd.analyze(); }
void PeakDetectorNaiveImpl::findPeaks(const FrequencyData& fd, peakdata::Scan& result) const { result.scanNumber = fd.scanNumber(); result.retentionTime = fd.retentionTime(); result.observationDuration = fd.observationDuration(); result.calibrationParameters = fd.calibrationParameters(); result.peakFamilies.clear(); const double noiseLevel = sqrt(fd.variance()); const double threshold = noiseLevel * noiseFactor_; for (FrequencyData::const_iterator it=fd.data().begin(); it!=fd.data().end(); ++it) if (isPeak(it, fd.data(), threshold, detectionRadius_)) { result.peakFamilies.push_back(PeakFamily()); PeakFamily& peakFamily = result.peakFamilies.back(); peakFamily.peaks.push_back(Peak()); Peak& peak = peakFamily.peaks.back(); peak.frequency = it->x; peak.intensity = it->y.real(); peak.phase = it->y.imag(); } }
void NoisyData::analyzeData() { const ublas::vector<double>& p = tlp_.parameters(); double sum_norm_dLdf0 = 0; double sum_Re_dLdf0_conj_noise = 0; double sum_Re_d2Ldf02_conj_noise = 0; for (FrequencyData::iterator it=fd_.data().begin(); it!=fd_.data().end(); ++it) { double f = it->x; complex<double> noise = it->y - L_(f, p); complex<double> dLdf0 = L_.dp(f, p)(TruncatedLorentzian::F0); complex<double> d2Ldf02 = L_.dp2(f, p)(TruncatedLorentzian::F0, TruncatedLorentzian::F0); sum_Re_dLdf0_conj_noise += real(dLdf0 * conj(noise)); sum_norm_dLdf0 += norm(dLdf0); sum_Re_d2Ldf02_conj_noise += real(d2Ldf02 * conj(noise)); } predictedDeltaF0_ = sum_Re_dLdf0_conj_noise / (sum_norm_dLdf0 - sum_Re_d2Ldf02_conj_noise); crBound_ = noiseVariance_ / sum_norm_dLdf0; }
int main(int argc, char* argv[]) { if (argc < 4) { cout << "Usage: tlperror model.tlp data.cfd radius\n"; return 1; } const char* filenameModel = argv[1]; const char* filenameData = argv[2]; int radius = atoi(argv[3]); try { if (radius < 1) throw runtime_error("Positive radius required.\n"); TruncatedLorentzianParameters tlp(filenameModel); const FrequencyData fdOriginal(filenameData); auto_ptr<TruncatedLorentzianEstimator> estimator = TruncatedLorentzianEstimator::create(); const FrequencyData fd(fdOriginal, fdOriginal.max(), radius); double N = fd.data().size(); double error = estimator->error(fd, tlp); double normalizedError = estimator->normalizedError(fd, tlp); double noiseVariance = fd.noiseFloor() * fd.noiseFloor(); double zscore = (error/noiseVariance - N) / (sqrt(N)); double sumSquaresModel = estimator->sumSquaresModel(fd, tlp); cout << "# N error normalizedError noiseVariance z-score sumSquaresModel\n"; cout << N << " "; cout << error << " "; cout << normalizedError << " "; cout << noiseVariance << " "; cout << zscore << " "; cout << sumSquaresModel << " "; cout << endl; return 0; } catch (exception& e) { cout << e.what() << endl; return 1; } }
void NoisyData::generateData() { const ublas::vector<double>& p = tlp_.parameters(); const int sampleCount = 21; double delta = 1/tlp_.T; double fBegin = tlp_.f0 - delta*(sampleCount/2) + delta*relativeGridOffset_; double peakHeight = abs(L_(tlp_.f0, p)); double noiseLevel = peakHeight / signalToNoise_; noiseVariance_ = noiseLevel*noiseLevel; for (int i=0; i<sampleCount; i++) { double f = fBegin + i*delta; complex<double> value = L_(f, p); complex<double> noise(Random::gaussian(noiseLevel/sqrt(2.)), Random::gaussian(noiseLevel/sqrt(2.))); fd_.data().push_back(FrequencyDatum(f, value+noise)); } fd_.calibration(Calibration(1.075e8, -3.455e8)); fd_.observationDuration(tlp_.T); fd_.analyze(); // recache }
void test() { // create some data, f(x) = abs(5-(x-2)) FrequencyData fd; FrequencyData::container& data = fd.data(); for (int i=-5; i<=5; i++) data.push_back(FrequencyDatum(i+2, 5-abs(i))); fd.analyze(); // recache after changing data // verify peak() FrequencyData::const_iterator max = fd.max(); unit_assert(max->x == 2); unit_assert(max->y == 5.); // verify stats unit_assert(fd.mean() == 25./11); unit_assert(fd.meanSquare() == 85./11); unit_assert(fd.sumSquares() == 85.); unit_assert_equal(fd.variance(), 85./11 - 25.*25/11/11, 1e-12); // write out data if (os_) *os_ << "Writing " << filename1 << endl; fd.write(filename1, FrequencyData::Text); // read into const FrequencyData string filename2 = "FrequencyDataTest.output2.txt"; FrequencyData fd2(filename1, FrequencyData::Text); // verify normalize() fd2.normalize(); unit_assert(fd2.shift() == -2); unit_assert(fd2.scale() == 1./5); max = fd2.max(); unit_assert(max->x == 0); unit_assert(max->y == 1.); // verify transform(shift, scale) fd2.transform(-fd2.shift(), 1./fd2.scale()); // verify read/write if (os_) *os_ << "Writing " << filename2 << endl; fd2.write(filename2, FrequencyData::Text); diff(filename1, filename2); // test subrange string filename3 = "FrequencyDataTest.output3.txt"; FrequencyData fd3(fd2, fd2.data().begin(), fd2.max()); // copy first half if (os_) *os_ << "Writing " << filename3 << endl; fd3.write(filename3, FrequencyData::Text); FrequencyData fd4(fd2, fd2.max(), fd2.data().end()); // copy second half ofstream os(filename3.c_str(), ios::app); fd4.write(os, FrequencyData::Text); os.close(); diff(filename1, filename3); // read/write binary, and metadata fd.scanNumber(555); fd.retentionTime(444); fd.calibrationParameters(CalibrationParameters(1,1)); fd.observationDuration(666); fd.noiseFloor(777); string filename4a = "FrequencyDataTest.output4a.txt"; if (os_) *os_ << "Writing " << filename4a << endl; fd.write(filename4a, FrequencyData::Text); string filenameBinary1 = "FrequencyDataTest.output1.cfd"; if (os_) *os_ << "Writing " << filenameBinary1 << endl; fd.write(filenameBinary1); FrequencyData fd5(filenameBinary1); unit_assert(fd5.observationDuration() == 666); fd5.observationDuration(fd.observationDurationEstimatedFromData()); unit_assert(fd5.scanNumber() == 555); unit_assert(fd5.retentionTime() == 444); unit_assert(fd5.observationDuration() == 1); unit_assert(fd5.noiseFloor() == 777); if (os_) *os_ << "Calibration: " << fd5.calibrationParameters().A << " " << fd5.calibrationParameters().B << endl; string filename4b = "FrequencyDataTest.output4b.txt"; if (os_) *os_ << "Writing " << filename4b << endl; fd5.write(filename4b, FrequencyData::Text); diff(filename4a, filename4b); fd.calibrationParameters(CalibrationParameters()); // test window FrequencyData window1(fd, data.begin()+1, 2); FrequencyData window2(fd, fd.max(), 1); FrequencyData window3(fd, data.end()-2, 2); string filename5 = "FrequencyDataTest.output5.txt"; if (os_) *os_ << "Writing " << filename5 << endl; ofstream os5(filename5.c_str()); window1.write(os5, FrequencyData::Text); window2.write(os5, FrequencyData::Text); window3.write(os5, FrequencyData::Text); os5.close(); diff(filename1, filename5); }