00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef OPENMS_ANALYSIS_DECHARGING_FEATUREDECHARGER_H
00028 #define OPENMS_ANALYSIS_DECHARGING_FEATUREDECHARGER_H
00029
00030
00031 #include <OpenMS/CONCEPT/Exception.h>
00032 #include <OpenMS/KERNEL/Feature.h>
00033 #include <OpenMS/KERNEL/FeatureMap.h>
00034 #include <OpenMS/COMPARISON/CLUSTERING/HierarchicalClustering.h>
00035 #include <OpenMS/DATASTRUCTURES/DPosition.h>
00036 #include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
00037
00038
00039 #include <vector>
00040
00041 namespace OpenMS
00042 {
00061 class FeatureDecharger : public DefaultParamHandler
00062 {
00063 public:
00064
00065 typedef FeatureMap<> FeatureMapType;
00066 typedef Feature FeatureType;
00067 typedef DPosition<2> ClusterPointType;
00068 using DefaultParamHandler::param_;
00069 using DefaultParamHandler::defaults_;
00070
00074
00075 FeatureDecharger()
00076 : DefaultParamHandler("FeatureDecharger")
00077 {
00078 defaults_.setValue("cluster_rt_mz_relation", 100.0, "Multiplication factor for m/z coordinates used to balance the dimension differences of RT and m/z.", false);
00079
00080 HierarchicalClustering<> hc;
00081 defaults_.insert("hierarchical_clustering:",hc.getParameters());
00082
00083 defaultsToParam_();
00084 }
00085
00087 inline FeatureDecharger(const FeatureDecharger& source)
00088 : DefaultParamHandler(source),
00089 featuremap_dc_(source.featuremap_dc_)
00090 {}
00091
00093 inline FeatureDecharger& operator=(const FeatureDecharger& source)
00094 {
00095 if (&source==this)
00096 {
00097 return *this;
00098 }
00099
00100 DefaultParamHandler::operator=(source);
00101 featuremap_dc_ = source.featuremap_dc_;
00102
00103 return *this;
00104 };
00105
00106
00107
00109 virtual ~FeatureDecharger()
00110 {};
00112
00116
00118 const FeatureMapType& getFeatureMap() const
00119 {
00120 return featuremap_dc_;
00121 }
00122
00124
00126 void compute(FeatureMapType &map)
00127 {
00128
00129 std::vector<ClusterPointType> feature_stripped;
00130
00131
00132
00133 double RT_MZ_relation = param_.getValue("cluster_rt_mz_relation");
00134
00135
00136 for (FeatureMapType::iterator iter = map.begin(); iter!=map.end(); ++iter)
00137 {
00138 ClusterPointType point;
00139 double mass = iter->getMZ() * iter->getCharge() - iter->getCharge();
00140 iter->setMZ(mass);
00141 point.setX( iter->getRT() );
00142 point.setY( mass*RT_MZ_relation );
00143
00144 feature_stripped.push_back(point);
00145 }
00146
00147
00148
00149 HierarchicalClustering<ClusterPointType> hierclust;
00150 Param mod_param = param_.copy("hierarchical_clustering:",true);
00151 if (mod_param.empty())
00152 {
00153 std::cout << "HierarchicalClustering: param is emtpy. Using defaults!\n";
00154 }
00155 else
00156 {
00157 hierclust.setParameters(mod_param);
00158 }
00159
00160 hierclust.compute(feature_stripped);
00161
00162 HierarchicalClustering<ClusterPointType>::ClusterIdxVectorType clusters = hierclust.getClusters();
00163
00164 hierclust.printStatistics(std::cout);
00165
00166
00167 FeatureType feature;
00168 featuremap_dc_.clear();
00169 featuremap_dc_.assign(clusters.size(), feature);
00170
00171 uint idx_validCluster = 0;
00172 bool is_bad_cluster = false;
00173 uint bad_clusters = 0;
00174 uint bad_clusters_resolved = 0;
00175 for (uint i=0; i<clusters.size(); ++i)
00176 {
00177
00178 double rt_avg = 0;
00179 double m_avg = 0;
00180 double int_sum = 0;
00181
00182 is_bad_cluster = false;
00183
00184 std::vector < int > charge_variants(clusters[i].size());
00185
00186 for (uint j=0; j<clusters[i].size() ;++j)
00187 {
00188 rt_avg += map[clusters[i][j]].getRT();
00189 m_avg += map[clusters[i][j]].getMZ();
00190 int_sum += map[clusters[i][j]].getIntensity();
00191
00192
00193
00194
00195 charge_variants[j] = map[clusters[i][j]].getCharge();
00196 }
00197
00198
00199 std::sort(charge_variants.begin(), charge_variants.end());
00200 for (uint j = 1; j<clusters[i].size() ;++j)
00201 {
00202
00203 if (charge_variants[j-1]==charge_variants[j])
00204 {
00205 is_bad_cluster = true;
00206 ++bad_clusters;
00207
00208 if (charge_variants[0]==charge_variants[clusters[i].size()-1])
00209 {
00210 ++bad_clusters_resolved;
00211
00212 FeatureType feature;
00213 featuremap_dc_.insert(featuremap_dc_.end(), clusters[i].size(), feature);
00214
00215
00216
00217
00218
00219
00220 for (uint new_cl = 0; new_cl<clusters[i].size(); ++new_cl)
00221 {
00222 featuremap_dc_[idx_validCluster].setRT (map[clusters[i][new_cl]].getRT() );
00223 featuremap_dc_[idx_validCluster].setMZ ( map[clusters[i][new_cl]].getMZ() );
00224 featuremap_dc_[idx_validCluster].setIntensity ( map[clusters[i][new_cl]].getIntensity() );
00225 featuremap_dc_[idx_validCluster].setCharge ( 0 );
00226 ++idx_validCluster;
00227 }
00228 }
00229 }
00230 }
00231
00232 if (is_bad_cluster == false)
00233 {
00234 featuremap_dc_[idx_validCluster].setRT (rt_avg / clusters[i].size() );
00235 featuremap_dc_[idx_validCluster].setMZ ( m_avg / clusters[i].size() );
00236 featuremap_dc_[idx_validCluster].setIntensity ( int_sum );
00237 featuremap_dc_[idx_validCluster].setCharge ( 0 );
00238
00239
00240
00241
00242
00243 ++idx_validCluster;
00244 }
00245
00246 }
00247
00248
00249 featuremap_dc_.erase(featuremap_dc_.begin()+idx_validCluster, featuremap_dc_.end());
00250
00251
00252 std::cout << "STATISTICS:\n #valid cluster (incl. recovered):" << idx_validCluster << "\n #badCluster:" << bad_clusters << "\n #Cluster recovered from bad:" << bad_clusters_resolved << "\n";
00253
00254 featuremap_dc_.updateRanges();
00255
00256 return;
00257 }
00258
00259 protected:
00261 FeatureMapType featuremap_dc_;
00262 };
00263 }
00264
00265 #endif // OPENMS_ANALYSIS_DECHARGING_FEATUREDECHARGER_H