bool
MappedSpectrum::transform( adcontrols::MassSpectrum& ms ) const
{
auto& prop = ms.getMSProperty();
int32_t nDelay = int32_t( ( delay_ / sampInterval_ ) + 0.5 );
auto si = SamplingInfo( sampInterval_, delay_, nDelay, nSamples_, num_average_, 0 /* mode */ );
si.fSampInterval( sampInterval_ );
prop.setSamplingInfo( si );
prop.setNumAverage( num_average_ );
prop.setTrigNumber( trig_number_, trig_number_origin_ );
prop.setTimeSinceEpoch( timeSinceEpoch_.second );
ms.resize( data_.size() );
ms.setCentroid( adcontrols::CentroidNative );
//auto scanlaw = prop.scanLaw();
for ( size_t idx = 0; idx < data_.size(); ++idx ) {
double tof = this->time( idx );
ms.setTime( idx, tof );
//if ( scanlaw )
// ms.setMass( idx, ms.compute_mass( data_[ idx ].first ) );
ms.setIntensity( idx, data_[ idx ].second );
}
return true;
}
bool
DataprocHandler::doCentroid( adcontrols::MSPeakInfo& pkInfo
, adcontrols::MassSpectrum& res
, const adcontrols::MassSpectrum& profile
, const adcontrols::CentroidMethod& m )
{
adcontrols::CentroidProcess peak_detector;
bool result = false;
res.clone( profile, false );
if ( peak_detector( m, profile ) ) {
result = peak_detector.getCentroidSpectrum( res );
pkInfo = peak_detector.getPeakInfo();
}
if ( profile.numSegments() > 0 ) {
for ( size_t fcn = 0; fcn < profile.numSegments(); ++fcn ) {
adcontrols::MassSpectrum centroid;
result |= peak_detector( profile.getSegment( fcn ) );
pkInfo.addSegment( peak_detector.getPeakInfo() );
peak_detector.getCentroidSpectrum( centroid );
res.addSegment( centroid );
}
}
return result;
}
bool
QuanSampleProcessor::doCentroid( adcontrols::MSPeakInfo& pkInfo
, adcontrols::MassSpectrum& res
, const adcontrols::MassSpectrum& profile
, const adcontrols::CentroidMethod& m )
{
adcontrols::CentroidProcess peak_detector;
bool result = false;
res.clone( profile, false );
if ( peak_detector( m, profile ) ) {
result = peak_detector.getCentroidSpectrum( res );
pkInfo = peak_detector.getPeakInfo();
}
if ( profile.numSegments() > 0 ) {
for ( size_t fcn = 0; fcn < profile.numSegments(); ++fcn ) {
auto centroid = std::make_shared< adcontrols::MassSpectrum >();
result |= peak_detector( profile.getSegment( fcn ) );
pkInfo.addSegment( peak_detector.getPeakInfo() );
peak_detector.getCentroidSpectrum( *centroid );
res << std::move( centroid );
}
}
return result;
}
bool
MSChromatogramExtractor::impl::doCentroid(adcontrols::MassSpectrum& centroid
, const adcontrols::MassSpectrum& profile
, const adcontrols::CentroidMethod& m )
{
adcontrols::CentroidProcess peak_detector;
bool result = false;
centroid.clone( profile, false );
if ( peak_detector( m, profile ) ) {
result = peak_detector.getCentroidSpectrum( centroid );
// pkInfo = peak_detector.getPeakInfo();
}
if ( profile.numSegments() > 0 ) {
for ( size_t fcn = 0; fcn < profile.numSegments(); ++fcn ) {
auto temp = std::make_shared< adcontrols::MassSpectrum >();
result |= peak_detector( profile.getSegment( fcn ) );
// pkInfo.addSegment( peak_detector.getPeakInfo() );
peak_detector.getCentroidSpectrum( *temp );
centroid << std::move( temp );
}
}
return result;
}
void operator () ( const adcontrols::MassSpectrum& data
, adportable::counting::counting_result& result
, std::vector< double >& processed ) {
assert ( method.algo_ == adcontrols::threshold_method::Differential );
assert ( findPositive == ( method.slope == adcontrols::threshold_method::CrossUp ) );
double level = method.threshold_level;
adportable::counting::peak_finder< findPositive > finder;
finder( data.getIntensityArray(), data.getIntensityArray() + data.size(), result.indices2(), level );
}
bool
TimeDigitalHistogram::translate( adcontrols::MassSpectrum& sp
, const TimeDigitalHistogram& hgrm )
{
sp.setCentroid( adcontrols::CentroidNative );
using namespace adcontrols::metric;
// ext_trig_delay should be managed before came here. (ex. histogram::move())
double ext_trig_delay = hgrm.this_protocol_.delay_pulses().at( adcontrols::TofProtocol::EXT_ADC_TRIG ).first;
adcontrols::MSProperty prop;
adcontrols::SamplingInfo info( hgrm.xIncrement()
, hgrm.initialXOffset() + ext_trig_delay
, int32_t( ( hgrm.initialXOffset() + ext_trig_delay ) / hgrm.xIncrement() ) // delay
, uint32_t( hgrm.actualPoints() ) // this is for acq. time range calculation
, uint32_t( hgrm.trigger_count() )
, hgrm.this_protocol_.mode() /* mode */);
prop.setAcceleratorVoltage( 0 ); // empty
prop.setSamplingInfo( info );
prop.setTimeSinceInjection( hgrm.initialXTimeSeconds() );
prop.setTimeSinceEpoch( hgrm.timeSinceEpoch().first );
prop.setNumAverage( uint32_t( hgrm.trigger_count() ) );
prop.setTrigNumber( uint32_t( hgrm.serialnumber().first ) );
prop.setDataInterpreterClsid( "adcontrols::TimeDigitalHistogram" );
TimeDigitalHistogram::device_data data( hgrm.this_protocol_ );
std::string ar;
adportable::binary::serialize<>()( data, ar );
prop.setDeviceData( ar.data(), ar.size() );
sp.setMSProperty( prop );
size_t size = hgrm.size();
sp.resize( size );
size_t idx = 0;
for ( auto it = hgrm.begin(); it != hgrm.end(); ++it, ++idx ) {
sp.setTime( idx, it->first );
sp.setIntensity( idx, it->second );
}
return true;
}
bool
rawdata::getSpectrum( int fcn, size_t pos, adcontrols::MassSpectrum& ms, uint32_t objid ) const
{
auto it = std::find_if( conf_.begin(), conf_.end(), [=]( const adutils::AcquiredConf::data& c ){
if ( objid == 0 )
return c.trace_method == signalobserver::eTRACE_SPECTRA && c.trace_id == L"MS.PROFILE";
else
return c.objid == objid;
});
if ( it == conf_.end() )
return false;
adcontrols::translate_state state;
uint64_t npos = npos0_ + pos;
if ( fcn < 0 && fcnIdx_.size() > 1 ) {
// find 'index' from <pos, fcn> array that indicates first 'pos' after protocol has been switched
auto index = std::lower_bound( fcnIdx_.begin(), fcnIdx_.end(), npos
, [] ( const std::pair< size_t, int >& a, size_t npos ) { return a.first < npos; } );
if ( index == fcnIdx_.end() )
return false;
while ( index != fcnIdx_.begin() && index->first > npos )
--index;
int rep = int( npos - index->first ); // id within a replicates (rep'licates is the offset from (fcn=0,rep=0) spectrum)
while ( index != fcnIdx_.begin() && index->second != 0 ) // find fcn=0
--index;
// read all protocols
while ( ( state = fetchSpectrum( it->objid, it->dataInterpreterClsid, index->first + rep, ms, it->trace_id ) )
== adcontrols::translate_indeterminate )
if ( ++index == fcnIdx_.end() ) // move forward to next protocol (rep'licates is the offset for actual spectrum)
break;
} else {
state = fetchSpectrum( it->objid, it->dataInterpreterClsid, npos, ms, it->trace_id );
}
if ( ms.getMSProperty().dataInterpreterClsid() == 0 ) {
// workaround for batchproc::import
adcontrols::MSProperty prop = ms.getMSProperty();
prop.setDataInterpreterClsid( adportable::utf::to_utf8( it->dataInterpreterClsid ).c_str() );
}
if ( fcn < 0 )
return state == adcontrols::translate_complete;
return state == adcontrols::translate_complete || state == adcontrols::translate_indeterminate;
}
bool
DataprocHandler::doMSCalibration( adcontrols::MSCalibrateResult& res
, adcontrols::MassSpectrum& centroid
, const adcontrols::MSCalibrateMethod& m
, const adcontrols::MSAssignedMasses& assigned )
{
using adcontrols::MSProperty;
const double tolerance = m.massToleranceDa();
const double threshold = centroid.getMaxIntensity() * m.minimumRAPercent() / 100;
res.tolerance( tolerance ); // set tolerance in result
res.threshold( threshold ); // set threshold in result
std::map< size_t, size_t > mode_map;
for ( adcontrols::MSAssignedMasses::vector_type::const_iterator it = assigned.begin(); it != assigned.end(); ++it )
mode_map[ it->mode() ]++;
// std::map<size_t, size_t>::iterator itMax = std::max_element( mode_map.begin(), mode_map.end() );
// int mode = static_cast<int>(itMax->first);
mass_calibrator calibrator( assigned, centroid.getMSProperty() );
adcontrols::MSCalibration calib;
if ( ! calibrator.polfit( calib, m.polynomialDegree() + 1 ) )
return false;
res.references( m.references() );
res.calibration( calib );
centroid.setCalibration( calib, true ); // m/z assign based on manually determined peaks
// continue auto-assign
assign_masses assign( tolerance, threshold );
adcontrols::MSAssignedMasses assignedMasses;
adcontrols::segment_wrapper< adcontrols::MassSpectrum > segments( centroid );
for ( size_t n = 0; n < segments.size(); ++n ) {
assign( assignedMasses, segments[n], m.references(), 0, static_cast<int>(n) );
}
mass_calibrator calibrator2( assignedMasses, centroid.getMSProperty() );
if ( calibrator2.polfit( calib, m.polynomialDegree() + 1 ) ) {
for ( auto it: assignedMasses )
it.mass( calibrator2.compute_mass( it.time(), it.mode(), calib ) );
centroid.setCalibration( calib, true );
res.calibration( calib );
res.assignedMasses( assignedMasses );
return true;
}
return false;
}
bool
DataprocHandler::doMSCalibration( adcontrols::MSCalibrateResult& res
, adcontrols::MassSpectrum& centroid
, const adcontrols::MSCalibrateMethod& m )
{
using adcontrols::MSProperty;
res.calibration( centroid.calibration() );
res.references( m.references() );
double tolerance = m.massToleranceDa();
double threshold = adcontrols::segments_helper::max_intensity( centroid ) * m.minimumRAPercent() / 100;
res.tolerance( tolerance );
res.threshold( threshold );
assign_masses assigner( tolerance, threshold );
adcontrols::MSAssignedMasses assignedMasses;
adcontrols::segment_wrapper< adcontrols::MassSpectrum > segments( centroid );
int n = 0;
for ( auto seg: segments )
assigner( assignedMasses, seg, res.references(), seg.mode(), n++ );
res.assignedMasses( assignedMasses ); // set peak assign result
// annotate each peak on spectrum
doAnnotateAssignedPeaks( centroid, assignedMasses );
mass_calibrator calibrator( assignedMasses, centroid.getMSProperty() );
adcontrols::MSCalibration calib;
if ( calibrator.polfit( calib, m.polynomialDegree() + 1 ) ) {
for ( auto it: assignedMasses ) {
double mass = calibrator.compute_mass( it.time(), it.mode(), calib );
it.mass( mass );
}
res.calibration( calib );
// res.assignedMasses( assignedMasses );
#if defined _DEBUG && 0
calibresult_validation( res, centroid, threshold );
#endif
return true;
}
return false;
}
bool
TimeDigitalHistogram::translate( adcontrols::MassSpectrum& sp
, const TimeDigitalHistogram& hgrm
, mass_assignor_t mass_assignee )
{
if ( translate( sp, hgrm ) ) {
const adcontrols::MSProperty& prop = sp.getMSProperty();
const auto& sinfo = prop.samplingInfo();
double lMass = mass_assignee( sinfo.fSampDelay(), prop.mode() );
double hMass = mass_assignee( sinfo.fSampDelay() + sinfo.fSampInterval() * sinfo.nSamples(), prop.mode() );
sp.setAcquisitionMassRange( lMass, hMass );
return sp.assign_masses( mass_assignee );
}
return false;
}
//virtual
bool
datafile::getSpectrum( int /* fcn*/, size_t idx, adcontrols::MassSpectrum& ms, uint32_t /* objid */) const
{
if ( unsigned( idx ) < spcfile_->number_of_subfiles() ) {
const galactic::spchdr& hdr = *spcfile_->spchdr();
const galactic::subhdr& sub = *spcfile_->subhdr( idx );
std::pair< double, double > range = std::make_pair( hdr.ffirst(), hdr.flast() );
const size_t npts = hdr.fnpts();
ms.resize( npts );
ms.setAcquisitionMassRange( range.first, range.second );
for ( size_t i = 0; i < npts; ++i ) {
ms.setMass( int(i), i * double(( range.second - range.first )) / ( npts - 1 ) + range.first );
ms.setIntensity( int(i), sub[i] );
}
return true;
}
return false;
}
static void
calibresult_validation( const adcontrols::MSCalibrateResult& res
, const adcontrols::MassSpectrum& centroid
, double threshold )
{
const adcontrols::MSReferences& ref = res.references();
const adcontrols::MSAssignedMasses& assigned = res.assignedMasses();
std::ofstream of( "massassign.txt" );
of << "#\tm/z(observed)\ttof(us)\tintensity\t\tformula,\tm/z(exact)\tm/z(calibrated)\terror(mDa)" << std::endl;
adcontrols::MSReferences::vector_type::const_iterator refIt = ref.begin();
for ( adcontrols::MSAssignedMasses::vector_type::const_iterator it = assigned.begin(); it != assigned.end(); ++it, ++refIt ) {
const adcontrols::MSAssignedMass& a = *it;
std::string formula = adportable::string::convert( a.formula() );
of << std::setprecision(8)
<< std::setw(4) << a.idMassSpectrum() << "\t" // id
<< std::setw(15) << std::fixed << centroid.getMass( a.idMassSpectrum() ) << "\t" // m/z(observed)
<< std::scientific << centroid.getTime( a.idMassSpectrum() ) << "\t" // tof
<< std::fixed << std::setprecision( 0 ) << centroid.getIntensity( a.idMassSpectrum() ) << "\t" // intensity
<< formula << "\t"
<< std::setprecision(8) << std::fixed << it->exactMass() << "\t" // mass(exact)
<< std::fixed << a.mass() << "\t" // m/z(calibrated)
<< std::setprecision(1) << ( a.mass() - it->exactMass() ) * 1000 << "\t" // error(mDa)
<< ( it->enable() ? "used" : "not used" )
<< std::endl;
}
const std::vector<double>& coeffs = res.calibration().coeffs();
of << "#--------------------------- Calibration coefficients: " << std::endl;
for ( size_t i = 0; i < coeffs.size(); ++i )
of << std::scientific << std::setprecision(14) << coeffs[i] << std::endl;
of << "#--------------------------- centroid peak list (#,mass,intensity)--------------------------" << std::endl;
adcontrols::MSReferences::vector_type::const_iterator it = res.references().begin();
for ( size_t i = 0; i < centroid.size(); ++i ) {
if ( centroid.getIntensity( i ) > threshold ) {
double mq = adcontrols::MSCalibration::compute( res.calibration().coeffs(), centroid.getTime( i ) );
double mass = mq * mq;
double error = 0;
if ( it != res.references().end() && std::abs( it->exactMass() - mass ) < 0.2 ) {
error = ( it->exactMass() - mass ) * 1000; // mDa
++it;
}
of << i << "\t"
<< std::setprecision(8) << std::fixed << centroid.getMass( i ) << "\t"
<< std::setprecision(8) << mass << "\t"
<< std::setprecision(1) << centroid.getIntensityArray()[i] << std::endl;
}
}
}
//virtual
bool
datafile::getSpectrum( int /* fcn*/, size_t idx, adcontrols::MassSpectrum& ms, uint32_t /* objid */) const
{
if ( lrpfile_ && unsigned( idx ) < lrpfile_->number_of_spectra() ) {
if ( auto msdata = (*lrpfile_)[ idx ] ) {
std::vector< double > time, intens;
if ( lrpfile_->getMS( *msdata, time, intens ) ) {
ms.resize( time.size() );
ms.setMassArray( time.data() );
ms.setIntensityArray( intens.data() );
ms.setAcquisitionMassRange( time.front(), time.back() );
return true;
}
}
}
return false;
}
bool
MSChromatogramExtractor::impl::doMSLock( adcontrols::lockmass::mslock& mslock
, const adcontrols::MassSpectrum& centroid
, const adcontrols::MSLockMethod& m )
{
// TODO: consider how to handle segmented spectrum -- current impl is always process first
adcontrols::MSFinder find( m.tolerance( m.toleranceMethod() ), m.algorithm(), m.toleranceMethod() );
for ( auto& msref : msrefs_ ) {
size_t idx = find( centroid, msref.second );
if ( idx != adcontrols::MSFinder::npos )
mslock << adcontrols::lockmass::reference( msref.first, msref.second, centroid.getMass( idx ), centroid.getTime( idx ) );
}
if ( mslock.fit() ) {
// mslock( centroid, true );
return true;
}
return false;
}
bool
fsio::save_mscalibfile( adfs::filesystem& fs, const adcontrols::MassSpectrum& ms )
{
return save( fs, ms, ms.dataClass(), L"/MSCalibration" );
}
bool
QuanSampleProcessor::doMSLock( adcontrols::MSPeakInfo& pkInfo // will override
, adcontrols::MassSpectrum& centroid // will override
, const adcontrols::MSLockMethod& m
, const adcontrols::QuanCompounds& compounds )
{
// find reference peak by mass window
adcontrols::lockmass::mslock mslock;
// TODO: consider how to handle segmented spectrum -- current impl is always process first
adcontrols::MSFinder find( m.tolerance( m.toleranceMethod() ), m.algorithm(), m.toleranceMethod() );
for ( auto& compound : compounds ) {
if ( compound.isLKMSRef() ) {
double exactMass = cformula_->getMonoIsotopicMass( compound.formula() );
size_t idx = find( centroid, exactMass );
if ( idx != adcontrols::MSFinder::npos ) {
// add found peaks into mslock
mslock << adcontrols::lockmass::reference( compound.formula(), exactMass, centroid.getMass( idx ), centroid.getTime( idx ) );
}
}
}
if ( mslock.fit() ) {
mslock( centroid, true );
mslock( pkInfo, true );
return true;
}
return false;
}
void
MSPropertyForm::render( std::ostream& o, const adcontrols::MassSpectrum& ms )
{
using adportable::utf;
using namespace adcontrols::metric;
static const char * const polarities [] = { "Indeterminant", "Positive", "Negative", "Mixed" };
adcontrols::segment_wrapper< const adcontrols::MassSpectrum > segments( ms );
std::vector< std::pair< std::string, std::string > > temp;
temp.push_back( std::make_pair( "Spectrum", ( ms.isCentroid() ? "Centroid" : "Profile" ) ) );
temp.push_back( std::make_pair( "Polarity", polarities[ ms.polarity() ] ) );
o << "<hr>";
o << "<table border=\"1\" cellpadding=\"1\">";
o << "<caption>Descriptions</caption>";
o << "<tr>";
o << "<th>key</th>"
<< "<th>description</th>"
<< "</tr>";
for ( auto it: temp ) {
o << "<tr>"
<< "<td>" << it.first << "</td>"
<< "<td>" << it.second << "</td>"
<< "</tr>";
}
for ( size_t i = 0; i < ms.getDescriptions().size(); ++i ) {
auto desc = ms.getDescriptions()[ i ];
o << "<tr>"
<< "<td>" << utf::to_utf8( desc.key() ) << "</td>"
<< "<td>" << utf::to_utf8( desc.text() ) << "</td>"
<< "</tr>";
}
o << "</table>";
std::pair< double, double > massrange = ms.getAcquisitionMassRange();
o << "Acquisition mass range: " << boost::format( "%.3lf -- %.3lf" ) % massrange.first % massrange.second;
o << "<table border=\"1\" cellpadding=\"4\">";
o << "<caption>Acquisition and calibration parameter(s)</caption>";
o << "<tr>";
o << "<th>#seg</th>"
<< "<th>samp. interval(ps)</th>"
<< "<th>sampling start (μs)</th>"
<< "<th>sampling end (μs)</th>"
<< "<th>num. samples</th>"
<< "<th>num. average</th>"
<< "<th>mode</th>"
<< "<th>classid</th>"
<< "</tr>";
int n = 0;
for ( auto& m: segments ) {
const adcontrols::MSCalibration& calib = m.calibration();
size_t nrowspan = calib.coeffs().empty() ? 1 : 2;
const adcontrols::MSProperty& prop = m.getMSProperty();
const adcontrols::MSProperty::SamplingInfo& info = prop.getSamplingInfo();
double start_delay = scale_to<double, micro>( info.sampInterval * info.nSamplingDelay, pico );
double time_end = scale_to<double, micro>( info.sampInterval * ( info.nSamplingDelay + info.nSamples ), pico );
o << "<tr>"
<< boost::format( "<td rowspan=\"%1%\">" ) % nrowspan << n++ << "</td>"
<< "<td>" << info.sampInterval << "</td>"
<< "<td>" << boost::format( "%.4lfμs" ) % start_delay << "</td>"
<< "<td>" << boost::format( "%.4lfμs" ) % time_end << "</td>"
<< "<td>" << info.nSamples << "</td>"
<< "<td>" << info.nAverage << "</td>"
<< "<td>" << info.mode << "</td>"
<< "<td>" << prop.dataInterpreterClsid() << "</td>"
<< "</tr>";
if ( ! calib.coeffs().empty() ) {
//-----------------------------
o << "<tr>";
o << "<td colspan=7><b>Calibration ID:</b><i>" << utf::to_utf8( calib.calibId() ) << "</i>"
<< " " << calib.date();
o << "<hr>";
o << "√<span style=\"text-decoration: overline\"> <i>m/z</i></span> = "
<< boost::format( "%.14lf" ) % calib.coeffs()[0] << " + ";
for ( size_t i = 1; i < calib.coeffs().size(); ++i )
o << boost::format( "\t%.14lf × t<sup>%d</sup>" ) % calib.coeffs()[i] % i;
if ( ! calib.t0_coeffs().empty() ) {
o << "<br>"
<< "T<sub>0</sub> = " << calib.t0_coeffs()[0];
for ( size_t i = 1; i < calib.t0_coeffs().size(); ++i )
o << boost::format( "\t%.14lf × √<span style=\"text-decoration: overline\"> <i>m/z</i></span><sup>%d</sup>" )
% calib.coeffs()[i] % i;
if ( calib.algorithm() == adcontrols::MSCalibration::MULTITURN_NORMALIZED )
o << "\t(MULTITURN_NORMAILZED algorithm)";
}
o << "</tr>";
//-----------------------------
}
}
o << "</table>";
o << "<hr>";
try {
// device (averager) dependent data (require data interpreter)
std::vector < std::pair< std::string, std::string > > textv;
auto& prop = ms.getMSProperty();
const char * ipClsid = prop.dataInterpreterClsid();
if ( ipClsid && (std::strlen( ipClsid )) > 0 ) {
auto& interpreter = prop.spectrometer().getDataInterpreter();
if ( interpreter.make_device_text( textv, ms.getMSProperty() ) ) {
o << "<table border=\"1\" cellpadding=\"4\">";
o << "<caption>Averager/digitizer dependent information</caption>";
o << "<tr>";
o << "<th>#seg</th>";
std::for_each( textv.begin(), textv.end(), [&] ( const std::pair< std::string, std::string>& text ) { o << "<th>" << text.first << "</th>"; } );
o << "</tr>";
int seg = 0;
for ( auto& m : segments ) {
if ( interpreter.make_device_text( textv, m.getMSProperty() ) ) {
o << "<tr>";
o << "<td>" << seg++ << "</td>";
std::for_each( textv.begin(), textv.end(), [&] ( const std::pair< std::string, std::string>& text ) { o << "<td>" << text.second << "</td>"; } );
o << "</tr>";
}
}
o << "</table>";
o << "<hr>";
}
}
else {
o << "<hr>No dataInterpreterClsid specifid.</hr>";
ADERROR() << "no dataInterpreterClisidSpecified.";
}
}
catch ( boost::exception& ex ) {
o << "<hr>data exception: " << boost::diagnostic_information( ex ) << "</hr>";
ADERROR() << boost::diagnostic_information( ex );
}
catch ( ... ) {
o << "<hr>data exception: " << boost::current_exception_diagnostic_information() << "</hr>";
ADERROR() << boost::current_exception_diagnostic_information();
}
}
adcontrols::translate_state
DataInterpreter::translate_profile( adcontrols::MassSpectrum& ms
, const char * data, size_t dsize
, const char * meta, size_t msize
, const adcontrols::MassSpectrometer& spectrometer
, size_t idData ) const
{
(void)idData;
adportable::debug(__FILE__, __LINE__) << "translate_profile( dsize=" << dsize << ", msize=" << msize << ")";
import_profile profile;
import_continuum_massarray ma;
const batchproc::MassSpectrometer* pSpectrometer = dynamic_cast< const batchproc::MassSpectrometer * >( &spectrometer );
if ( pSpectrometer == 0 )
return adcontrols::translate_error;
if ( adportable::bzip2::is_a( data, dsize ) ) {
std::string ar;
adportable::bzip2::decompress( ar, data, dsize );
adportable::debug(__FILE__, __LINE__) << "translate_profile deserialize import_profile w/ decompress";
if ( ! adportable::serializer< import_profile >::deserialize( profile, ar.data(), ar.size() ) )
return adcontrols::translate_error;
} else {
adportable::debug(__FILE__, __LINE__) << "translate_profile deserialize import_profile w/o decompress";
if ( ! adportable::serializer< import_profile >::deserialize( profile, data, dsize ) )
return adcontrols::translate_error;
}
if ( meta && msize ) {
if ( adportable::bzip2::is_a( meta, msize ) ) {
std::string ar;
adportable::bzip2::decompress( ar, meta, msize );
if ( ! adportable::serializer< import_continuum_massarray >::deserialize( ma, ar.data(), ar.size() ) )
return adcontrols::translate_error;
} else {
if ( ! adportable::serializer< import_continuum_massarray >::deserialize( ma, meta, msize ) )
return adcontrols::translate_error;
}
}
adportable::debug(__FILE__, __LINE__) << "translate_profile checkpoint 3";
const import_continuum_massarray& continuum_massarray = meta ? ma : pSpectrometer->continuum_massarray();
ms.setMSProperty( profile.prop_ );
ms.setPolarity( profile.polarity_ );
ms.resize( profile.intensities_.size() );
adportable::debug(__FILE__, __LINE__) << "translate_profile checkpoint 4";
ms.setMassArray( continuum_massarray.masses_.data() );
auto intens = profile.intensities_.data();
for ( size_t i = 0; i < ms.size(); ++i )
ms.setIntensity( i, *intens++ );
adportable::debug(__FILE__, __LINE__) << "translate_profile checkpoint 5";
ms.setAcquisitionMassRange( ms.getMass( 0 ), ms.getMass( ms.size() - 1 ) );
adportable::debug(__FILE__, __LINE__) << "translate_profile checkpoint 6";
return adcontrols::translate_complete;
}
bool
fsio::load_mscalibfile( adfs::filesystem& fs, adcontrols::MassSpectrum& ms )
{
return load( fs, ms, ms.dataClass(), L"/MSCalibration" );
}
//virtual
bool
datafile::getSpectrum( int fcn, size_t pos, adcontrols::MassSpectrum& ms, uint32_t objId ) const
{
(void)fcn;
try {
EDAL::IMSSpectrumCollectionPtr pSpectra = pAnalysis_->GetMSSpectrumCollection();
EDAL::IMSSpectrumPtr pSpectrum = pSpectra->GetItem( long(pos) + 1 ); // 1-origin
if ( pSpectrum->Polarity == EDAL::SpectrumPolarity::IonPolarity_Negative )
ms.setPolarity( adcontrols::MS_POLARITY::PolarityNegative );
else if ( pSpectrum->Polarity == EDAL::SpectrumPolarity::IonPolarity_Positive )
ms.setPolarity( adcontrols::MS_POLARITY::PolarityPositive );
else
ms.setPolarity( adcontrols::MS_POLARITY::PolarityIndeterminate );
adcontrols::MSProperty prop = ms.getMSProperty();
prop.setTimeSinceInjection( static_cast< unsigned long >( pSpectrum->RetentionTime /* sec */ * 1.0e6 ) ); // usec
ms.setMSProperty( prop ); // <- end of prop set
_variant_t vMasses, vIntens;
if ( objId <= 1 ) {
pSpectrum->GetMassIntensityValues( EDAL::SpectrumType_Profile, &vMasses, &vIntens );
ms.setCentroid( adcontrols::CentroidNone ); // profile
} else { // objId should be 2
pSpectrum->GetMassIntensityValues( EDAL::SpectrumType_Line, &vMasses, &vIntens );
ms.setCentroid( adcontrols::CentroidNative );
}
SafeArray sa_masses( vMasses );
ms.resize( sa_masses.size() );
ms.setMassArray( reinterpret_cast< const double *>( sa_masses.p() ) );
SafeArray sa_intensities( vIntens );
ms.setIntensityArray( reinterpret_cast< const double *>( sa_intensities.p() ) );
ms.setAcquisitionMassRange( ms.getMass( 0 ), ms.getMass( ms.size() - 1 ) );
return true;
} catch(_com_error& ex ) {
ADERROR() << std::wstring( ex.ErrorMessage() );
return false;
}
return false;
}
adfs::file
QuanSampleProcessor::processIt( adcontrols::QuanSample& sample
, adcontrols::MassSpectrum& profile
, QuanDataWriter * writer
, bool bSerialize )
{
if ( auto pCentroidMethod = procmethod_->find< adcontrols::CentroidMethod >() ) {
adcontrols::MassSpectrum centroid;
adcontrols::MSPeakInfo pkInfo;
adcontrols::MassSpectrum filtered;
bool result(false);
if ( pCentroidMethod->noiseFilterMethod() == adcontrols::CentroidMethod::eDFTLowPassFilter ) {
filtered.clone( profile, true );
for ( auto& ms : adcontrols::segment_wrapper<>( filtered ) ) {
adcontrols::waveform_filter::fft4c::lowpass_filter( ms, pCentroidMethod->cutoffFreqHz() );
double base( 0 ), rms( 0 );
const double * intens = ms.getIntensityArray();
adportable::spectrum_processor::tic( uint32_t( ms.size() ), intens, base, rms );
for ( size_t i = 0; i < ms.size(); ++i )
ms.setIntensity( i, intens[ i ] - base );
}
filtered.addDescription( adcontrols::description( L"process", dataproc::Constants::F_DFT_FILTERD ) );
result = doCentroid( pkInfo, centroid, filtered, *pCentroidMethod );
} else {
result = doCentroid( pkInfo, centroid, profile, *pCentroidMethod );
}
if ( result ) {
// doMSLock if required.
if ( auto pCompounds = procmethod_->find< adcontrols::QuanCompounds >() ) {
if ( auto lkMethod = procmethod_->find< adcontrols::MSLockMethod >() ) {
if ( lkMethod->enabled() )
doMSLock( pkInfo, centroid, *lkMethod, *pCompounds );
}
}
// Look up compounds
if ( auto pCompounds = procmethod_->find< adcontrols::QuanCompounds >() ) {
if ( auto pTgtMethod = procmethod_->find< adcontrols::TargetingMethod >() ) {
doMSFind( pkInfo, centroid, sample, *pCompounds, *pTgtMethod );
}
}
if ( bSerialize ) {
adcontrols::MassSpectrum * pProfile = &profile;
adcontrols::MassSpectrum * pFiltered = (filtered.size() > 0 ) ? &filtered : 0;
adcontrols::MassSpectrum * pCentroid = ¢roid;
adcontrols::MSPeakInfo * pPkInfo = &pkInfo;
if ( sample.channel() > 0 ) {
if ( auto p = profile.findProtocol( sample.channel() - 1 ) ) {
p->clearSegments();
pProfile = p;
}
if ( pFiltered ) {
if ( auto p = filtered.findProtocol( sample.channel() - 1 ) ) {
p->clearSegments();
pFiltered = p;
}
}
if ( auto p = centroid.findProtocol( sample.channel() - 1 ) ) {
p->clearSegments();
pCentroid = p;
}
if ( auto p = pkInfo.findProtocol( sample.channel() - 1 ) ) {
p->clearSegments();
pPkInfo = p;
}
}
std::lock_guard<std::mutex> lock( mutex_ );
if ( adfs::file file = writer->write( *pProfile, sample.name() ) ) {
for ( auto& resp: sample.results() )
resp.dataGuid_ = file.name();
if ( pFiltered )
writer->attach<adcontrols::MassSpectrum>( file, *pFiltered, dataproc::Constants::F_DFT_FILTERD );
auto afile = writer->attach< adcontrols::MassSpectrum >( file, *pCentroid, dataproc::Constants::F_CENTROID_SPECTRUM );
writer->attach< adcontrols::ProcessMethod >( afile, *procmethod_, L"ProcessMethod" );
writer->attach< adcontrols::MSPeakInfo >( file, *pPkInfo, dataproc::Constants::F_MSPEAK_INFO );
writer->attach< adcontrols::QuanSample >( file, sample, dataproc::Constants::F_QUANSAMPLE );
return file;
}
}
}
}
return adfs::file();
}
bool
waveform::fft::lowpass_filter( adcontrols::MassSpectrum& ms, double freq )
{
if ( ms.isCentroid() )
return false;
size_t totalSize = ms.size();
(void)totalSize;
size_t N = 32;
while ( N < ms.size() )
N *= 2;
const size_t NN = ms.size();
double sampInterval = ms.getMSProperty().getSamplingInfo().fSampInterval(); // seconds
if ( sampInterval == 0 )
sampInterval = ( ms.getTime( ms.size() - 1 ) - ms.getTime( 0 ) ) / ms.size();
const double T = N * sampInterval; // time full scale in seconds. Freq = n/T (Hz)
// power spectrum has N/2 points and is n/T Hz horizontal axis := data[N/2] = (N/2)/T Hz
size_t cutoff = size_t( T * freq );
adportable::array_wrapper<const double> pIntens( ms.getIntensityArray(), N );
std::vector< std::complex<double> > spc( N );
std::vector< std::complex<double> > fft( N );
size_t n;
for ( n = 0; n < N && n < NN; ++n )
spc[ n ] = std::complex<double>( pIntens[ n ] );
while ( n < N )
spc[ n++ ] = pIntens[ NN - 1 ];
adportable::fft::fourier_transform( fft, spc, false );
// appodization
for ( size_t i = cutoff; i < N - cutoff; ++i )
fft[ i ] = 0;
//adportable::fft::apodization( N/2 - N/16, N / 16, fft );
adportable::fft::fourier_transform( spc, fft, true );
std::vector<double> data( N );
for ( size_t i = 0; i < NN; ++i )
data[ i ] = spc[i].real();
ms.setIntensityArray( &data[0] );
return true;
}
bool
assign_masses::operator()( adcontrols::MSAssignedMasses& assignedMasses
, const adcontrols::MassSpectrum& centroid
, const adcontrols::MSReferences& references
, int mode
, int fcn )
{
using adportable::array_wrapper;
using adcontrols::MSReferences;
array_wrapper<const double> masses( centroid.getMassArray(), centroid.size() );
array_wrapper<const double> intens( centroid.getIntensityArray(), centroid.size() );
for ( MSReferences::vector_type::const_iterator it = references.begin(); it != references.end(); ++it ) {
double exactMass = it->exact_mass();
array_wrapper<const double>::const_iterator lBound = std::lower_bound( masses.begin(), masses.end(), exactMass - tolerance_ );
array_wrapper<const double>::const_iterator uBound = std::lower_bound( masses.begin(), masses.end(), exactMass + tolerance_ );
if ( lBound != masses.end() ) {
size_t lIdx = std::distance( masses.begin(), lBound );
size_t uIdx = std::distance( masses.begin(), uBound );
// find closest
size_t cIdx = lIdx;
for ( size_t i = lIdx + 1; i < uIdx; ++i ) {
double d0 = std::abs( masses[ cIdx ] - exactMass );
double d1 = std::abs( masses[ i ] - exactMass );
if ( d1 < d0 )
cIdx = i;
}
// find highest
array_wrapper<const double>::const_iterator hIt = std::max_element( intens.begin() + lIdx, intens.begin() + uIdx );
if ( *hIt < threshold_ )
continue;
size_t idx = std::distance( intens.begin(), hIt );
adcontrols::MSAssignedMass assigned( uint32_t( std::distance( references.begin(), it ) )
, fcn
, uint32_t(idx) // idMassSpectrum (index on centroid peak)
, it->display_formula()
, it->exact_mass()
, centroid.getTime( idx )
, masses[ idx ]
, it->enable()
, false // flags
, mode );
// duplicate assign check
adcontrols::MSAssignedMasses::vector_type::iterator assignIt =
std::find_if( assignedMasses.begin(), assignedMasses.end(), [&]( const adcontrols::MSAssignedMass& a ){
return a.idPeak() == idx && a.idMassSpectrum() == unsigned(fcn);
});
if ( assignIt != assignedMasses.end() ) {
// already assined to another refernce
if ( std::fabs( assignIt->exactMass() - assignIt->mass() ) >
std::fabs( assigned.exactMass() - assigned.mass() ) ) {
*assignIt = assigned; // replace
}
} else
assignedMasses << assigned;
}
}
return true;
}