@@ -1013,7 +1013,7 @@ Rcpp::NumericMatrix RcppPwiz::get3DMap ( std::vector<int> scanNumbers, double wh

       //Rprintf("%d\n",1);

       for (int i = 0; i < scanNumbers.size(); i++)

         {

-	  SpectrumPtr s = slp->spectrum(scanNumbers[i] - 1, DetailLevel_FullMetadata);

+	  SpectrumPtr s = slp->spectrum(scanNumbers[i] - 1, DetailLevel_FullData);

 	  vector<MZIntensityPair> pairs;

 	  s->getMZIntensityPairs(pairs);

@@ -725,9 +725,9 @@ void RcppPwiz::addSpectrumList(MSData& msd,

     Spectrum& spct = *spectrumList->spectra[i];

     spct.set(MS_ms_level, msLevel[i]);

     // centroided

-    if (centroided[i] != NA_LOGICAL && centroided[i] == TRUE)

+    if (!Rcpp::LogicalVector::is_na(centroided[i]) && centroided[i] == TRUE)

       spct.set(MS_centroid_spectrum);

-    if (centroided[i] != NA_LOGICAL && centroided[i] == FALSE)

+    if (!Rcpp::LogicalVector::is_na(centroided[i]) && centroided[i] == FALSE)

       spct.set(MS_profile_spectrum);

     // [X] polarity

     if (polarity[i] == 0)

@@ -765,12 +765,13 @@ void RcppPwiz::addSpectrumList(MSData& msd,

     if (!Rcpp::StringVector::is_na(filterString[i]))

       spct_scan.set(MS_filter_string, filterString[i]);

-    if (ionMobilityDriftTime[i] != NA_REAL)

+    if (!Rcpp::NumericVector::is_na(ionMobilityDriftTime[i]))

       spct_scan.set(MS_ion_mobility_drift_time, ionMobilityDriftTime[i],

 		    UO_millisecond);

     // scanWindow

-    if (scanWindowLowerLimit[i] != NA_REAL && scanWindowUpperLimit[i] != NA_REAL) {

+    if (!Rcpp::NumericVector::is_na(scanWindowLowerLimit[i]) &&

+	!Rcpp::NumericVector::is_na(scanWindowUpperLimit[i])) {

       spct_scan.scanWindows.push_back(ScanWindow(scanWindowLowerLimit[i], scanWindowUpperLimit[i], MS_m_z));

     }

     // MSn - precursor:

@@ -804,7 +805,7 @@ void RcppPwiz::addSpectrumList(MSData& msd,

 	prec.spectrumID = spectrumId[precursor_idx];

       }

       // isolation window

-      if (isolationWindowTargetMZ[i] != NA_REAL) {

+      if (!Rcpp::NumericVector::is_na(isolationWindowTargetMZ[i])) {

 	prec.isolationWindow.set(MS_isolation_window_target_m_z, isolationWindowTargetMZ[i]);

 	prec.isolationWindow.set(MS_isolation_window_lower_offset, isolationWindowLowerOffset[i]);

 	prec.isolationWindow.set(MS_isolation_window_upper_offset, isolationWindowUpperOffset[i]);

@@ -374,6 +374,7 @@ Rcpp::List RcppPwiz::getPeakList(Rcpp::IntegerVector whichScan) {

     std::vector<double> data;

     Rcpp::NumericVector data_matrix;

     Rcpp::List res(n_want);

+    Rcpp::CharacterVector cn = Rcpp::CharacterVector::create("mz", "intensity");

     for (int i = 0; i < n_want; i++) {

       current_scan = whichScan[i];

       if (current_scan < 1 || current_scan > n_scans) {

@@ -385,6 +386,7 @@ Rcpp::List RcppPwiz::getPeakList(Rcpp::IntegerVector whichScan) {

       ints = sp->getIntensityArray();

       if (!mzs.get() || !ints.get()) {

 	Rcpp::NumericMatrix pks(0, 2);

+	Rcpp::colnames(pks) = cn;

 	res[i] = pks;

 	continue;

       }

@@ -394,6 +396,7 @@ Rcpp::List RcppPwiz::getPeakList(Rcpp::IntegerVector whichScan) {

       data.insert(data.end(), ints->data.begin(), ints->data.end());

       data_matrix = Rcpp::wrap(data);

       data_matrix.attr("dim") = Rcpp::Dimension(ints->data.size(), 2);

+      Rcpp::colnames(data_matrix) = cn;

       res[i] = data_matrix;

     }

     return res;

@@ -70,7 +70,7 @@ Rcpp::List RcppPwiz::getInstrumentInfo ( )

       if (!isInCacheInstrumentInfo)

         {

-	  vector<InstrumentConfigurationPtr> icp = msd->instrumentConfigurationPtrs; // NULL for mzData	    

+	  vector<InstrumentConfigurationPtr> icp = msd->instrumentConfigurationPtrs; // NULL for mzData

 	  if (icp.size() != 0)

             {

 	      CVTranslator cvTranslator;

@@ -88,13 +88,13 @@ Rcpp::List RcppPwiz::getInstrumentInfo ( )

 	      // defined.

 	      // Have to use try-catch

 	      try {

-		ionisation = std::string(adapter.ionisation());		  

+		ionisation = std::string(adapter.ionisation());

 	      } catch(...) {}

 	      try {

-		analyzer = std::string(adapter.analyzer());		  

+		analyzer = std::string(adapter.analyzer());

 	      } catch(...) {}

 	      try {

-		detector = std::string(adapter.detector());		  

+		detector = std::string(adapter.detector());

 	      } catch(...) {}

 	      instrumentInfo = Rcpp::List::create(

 						  Rcpp::_["manufacturer"]  = std::string(adapter.manufacturer()),

@@ -200,7 +200,7 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

     Rcpp::NumericVector isolationWindowUpperOffset(N_scans);

     Rcpp::NumericVector scanWindowLowerLimit(N_scans);

     Rcpp::NumericVector scanWindowUpperLimit(N_scans);

-    

+

     for (size_t i = 0; i < N_scans; i++) {

       int current_scan = whichScan[i];

       size_t current_index = static_cast<size_t>(current_scan - 1);

@@ -236,7 +236,7 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

       polarity[i] = (param.cvid==MS_negative_scan ? 0 : (param.cvid==MS_positive_scan ? +1 : -1 ) );

       // centroided

       param = sp->cvParamChild(MS_spectrum_representation);

-      centroided[i] = (param.cvid==MS_centroid_spectrum ? TRUE : (param.cvid==MS_profile_spectrum ? FALSE : NA_LOGICAL));      

+      centroided[i] = (param.cvid==MS_centroid_spectrum ? TRUE : (param.cvid==MS_profile_spectrum ? FALSE : NA_LOGICAL));

       // retentionTime

       retentionTime[i] = scan.cvParam(MS_scan_start_time).timeInSeconds();

       // ionInjectionTime

@@ -301,7 +301,7 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

 	isolationWindowUpperOffset[i] = NA_REAL;

       }

     }

-    

+

     Rcpp::List header(31);

     std::vector<std::string> names;

     size_t i = 0;

@@ -356,19 +356,19 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

     names.push_back("centroided");

     header[i++] = Rcpp::wrap(centroided);

     names.push_back("ionMobilityDriftTime");

-    header[i++] = Rcpp::wrap(ionMobilityDriftTime);      

+    header[i++] = Rcpp::wrap(ionMobilityDriftTime);

     names.push_back("isolationWindowTargetMZ");

-    header[i++] = Rcpp::wrap(isolationWindowTargetMZ);      

+    header[i++] = Rcpp::wrap(isolationWindowTargetMZ);

     names.push_back("isolationWindowLowerOffset");

-    header[i++] = Rcpp::wrap(isolationWindowLowerOffset);      

+    header[i++] = Rcpp::wrap(isolationWindowLowerOffset);

     names.push_back("isolationWindowUpperOffset");

-    header[i++] = Rcpp::wrap(isolationWindowUpperOffset);      

+    header[i++] = Rcpp::wrap(isolationWindowUpperOffset);

     names.push_back("scanWindowLowerLimit");

-    header[i++] = Rcpp::wrap(scanWindowLowerLimit);      

+    header[i++] = Rcpp::wrap(scanWindowLowerLimit);

     names.push_back("scanWindowUpperLimit");

-    header[i++] = Rcpp::wrap(scanWindowUpperLimit);      

+    header[i++] = Rcpp::wrap(scanWindowUpperLimit);

     header.attr("names") = names;

-    

+

     return header;

   }

   Rf_warningcall(R_NilValue, "pwiz not yet initialized.");

@@ -380,9 +380,9 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) {

     if (!isInCacheAllScanHeaderInfo) {

       SpectrumListPtr slp = msd->run.spectrumListPtr;

       size_t N = slp->size();

-      

+

       allScanHeaderInfo = getScanHeaderInfo(Rcpp::seq(1, N));

-      isInCacheAllScanHeaderInfo = TRUE;	    

+      isInCacheAllScanHeaderInfo = TRUE;

     }

     return allScanHeaderInfo ;

   }

@@ -496,7 +496,7 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

       addDataProcessing(newmsd, Rcpp::as<Rcpp::StringVector>(software_processing(sp)));

     }

   }

-  

+

   // o run

   // Initialize the run and fill with data from the original file.

   Run &original_run = msd->run;

@@ -510,7 +510,7 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

   }

   // Now filling with new data

   addSpectrumList(newmsd, spctr_header, spctr_data, rtime_seconds);

-  

+

   if (format == "mgf") {

     std::ofstream* mgfOutFileP = new std::ofstream(file.c_str());

     Serializer_MGF serializerMGF;

@@ -536,7 +536,7 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

   }

   else

     Rcpp::Rcerr << format << " format not supported! Please try mgf, mzML, mzXML or mz5." << std::endl;

-  

+

   // Cleanup.

   delete msd;

 }

@@ -570,7 +570,7 @@ void RcppPwiz::writeSpectrumList(const string& file, const string& format,

       addDataProcessing(newmsd, Rcpp::as<Rcpp::StringVector>(software_processing(sp)));

     }

   }

-  

+

   newmsd.run.id = "Experiment_1";

   // Now filling with new data

@@ -607,9 +607,9 @@ void RcppPwiz::writeSpectrumList(const string& file, const string& format,

  * o soft_proc: is supposed to be a character vector of length >= 2:

  *   soft_proc[0]: The software name (required).

  *   soft_proc[1]: The software version (required).

- *   soft_proc[2]: The CV ID of the software. Use "MS:-1" if not known, in 

+ *   soft_proc[2]: The CV ID of the software. Use "MS:-1" if not known, in

  *                 which case we are NOT writing the corresponding CV element.

- *   soft_proc[3-length]: CV IDs of the processing steps (optional). 

+ *   soft_proc[3-length]: CV IDs of the processing steps (optional).

  */

 void RcppPwiz::addDataProcessing(MSData& msd, Rcpp::StringVector soft_proc) {

   SoftwarePtr new_soft(new Software);

@@ -689,7 +689,7 @@ void RcppPwiz::addSpectrumList(MSData& msd,

   Rcpp::NumericVector isolationWindowUpperOffset = spctr_header["isolationWindowUpperOffset"];

   Rcpp::NumericVector scanWindowLowerLimit = spctr_header["scanWindowLowerLimit"];

   Rcpp::NumericVector scanWindowUpperLimit = spctr_header["scanWindowUpperLimit"];

-  

+

   // From MSnbase::Spectrum        Column in the header

   // msLevel integer               $msLevel

   // peaksCount integer

@@ -710,7 +710,7 @@ void RcppPwiz::addSpectrumList(MSData& msd,

   // precursorIntensity numeric    $precursorIntensity

   // precursorCharge integer       $precursorCharge

   // collisionEnergy numeric       $collisionEnergy

-  

+

   // Now filling with new data

   shared_ptr<SpectrumListSimple> spectrumList(new SpectrumListSimple);

   // Add the default Processing pointer (fix issue #151

@@ -771,7 +771,7 @@ void RcppPwiz::addSpectrumList(MSData& msd,

       spct_scan.scanWindows.push_back(ScanWindow(scanWindowLowerLimit[i], scanWindowUpperLimit[i], MS_m_z));

     }

     // MSn - precursor:

-    if (precursorScanNum[i] > 0 | precursorMZ[i] > 0) {

+    if ( (precursorScanNum[i] > 0) | (precursorMZ[i] > 0) ) {

       // Fill precursor data. This preserves the precursor data even if the

       // precursor scan is not available (e.g. after MS level filtering).

       spct.precursors.resize(1);

@@ -814,7 +814,7 @@ void RcppPwiz::addSpectrumList(MSData& msd,

     // [X] precursorCharge

     // [X] precursorIntensity

     // [ ] mergedScan

-    

+

     Rcpp::NumericMatrix spct_vals = spctr_data[i];

     // mz values

     Rcpp::NumericVector mz_vals = spct_vals( Rcpp::_, 0);

@@ -886,7 +886,7 @@ Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichCh

       return Rcpp::DataFrame::create();

     }

-    int N = clp->size();  

+    int N = clp->size();

     int N_chrom = whichChrom.size();

     Rcpp::StringVector chromatogramId(N_chrom); // the ID from the chrom

@@ -902,7 +902,7 @@ Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichCh

     Rcpp::NumericVector productIsolationWindowTargetMZ(N_chrom);

     Rcpp::NumericVector productIsolationWindowLowerOffset(N_chrom);

     Rcpp::NumericVector productIsolationWindowUpperOffset(N_chrom);

-        

+

     for (int i = 0; i < N_chrom; i++) {

       int current_chrom = whichChrom[i];

       if (current_chrom < 0 || current_chrom > N) {

@@ -918,7 +918,7 @@ Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichCh

 	precursorIsolationWindowTargetMZ[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_target_m_z).value.empty() ? NA_REAL : ch->precursor.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>();

 	precursorIsolationWindowLowerOffset[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_lower_offset).value.empty() ? NA_REAL : ch->precursor.isolationWindow.cvParam(MS_isolation_window_lower_offset).valueAs<double>();

 	precursorIsolationWindowUpperOffset[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_upper_offset).value.empty() ? NA_REAL : ch->precursor.isolationWindow.cvParam(MS_isolation_window_upper_offset).valueAs<double>();

-	precursorCollisionEnergy[i] = ch->precursor.activation.cvParam(MS_collision_energy).value.empty() ? NA_REAL : ch->precursor.activation.cvParam(MS_collision_energy).valueAs<double>(); 

+	precursorCollisionEnergy[i] = ch->precursor.activation.cvParam(MS_collision_energy).value.empty() ? NA_REAL : ch->precursor.activation.cvParam(MS_collision_energy).valueAs<double>();

       } else {

 	precursorIsolationWindowTargetMZ[i] = NA_REAL;

 	precursorIsolationWindowLowerOffset[i] = NA_REAL;

@@ -958,7 +958,7 @@ Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichCh

     chromHeader[i++] = Rcpp::wrap(productIsolationWindowLowerOffset);

     names.push_back("productIsolationWindowUpperOffset");

     chromHeader[i++] = Rcpp::wrap(productIsolationWindowUpperOffset);

-    

+

     chromHeader.attr("names") = names;

     return chromHeader;

   }

@@ -22,9 +22,7 @@ void RcppPwiz::open(Rcpp::StringVector fileName)

   filename = Rcpp::as<std::string>(fileName(0));

   msd = new MSDataFile(filename);

-  // Better not to guess the native ID format. For mzML/mzXML all should be fine

-  // with the default one.

-  // nativeIdFormat = id::getDefaultNativeIDFormat(*msd);

+  nativeIdFormat = id::getDefaultNativeIDFormat(*msd);

 }

 /* Release all memory on close. */

@@ -132,42 +130,40 @@ Rcpp::List RcppPwiz::getInstrumentInfo ( )

   return instrumentInfo;

 }

-// int RcppPwiz::getAcquisitionNumber(size_t index) const

-// {

-//   const SpectrumIdentity& si = msd->run.spectrumListPtr->spectrumIdentity(index);

-//   string scanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, si.id);

-//   if (scanNumber.empty()) {

-//     return static_cast<int>(index) + 1;

-//   }

-//   else

-//     return lexical_cast<int>(scanNumber);

-//   // return static_cast<int>(index) + 1;

-// }

-

-// Using this function instead of pwiz translateNativeIDToScanNumber because

-// it randomly causes segfaults on macOS.

 int RcppPwiz::getAcquisitionNumber(string id, size_t index) const

 {

-  if (id.find("controllerType") != std::string::npos) {

-    if (id.find("controllerType=0 controllerNumber=1") == std::string::npos)

-      return static_cast<int>(index) + 1;

-  }

-  string e;

-  std::smatch match;

-  if (id.find("scan=") != std::string::npos)

-    e ="scan=(\\d+)";

-  else if (id.find("index=") != std::string::npos)

-    e = "index=(\\d+)";

-  else if (id.find("spectrum=") != std::string::npos)

-    e = "spectrum=(\\d+)";

-  else if (id.find("scanId=") != std::string::npos)

-    e = "scanId=(\\d+)";

-  else return static_cast<int>(index) + 1;

-  if (std::regex_search(id, match, std::regex(e)))

-    return lexical_cast<int>(match[1]);

-  else return static_cast<int>(index) + 1;

+  // const SpectrumIdentity& si = msd->run.spectrumListPtr->spectrumIdentity(index);

+  string scanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, id);

+  if (scanNumber.empty())

+    return static_cast<int>(index) + 1;

+  else

+    return lexical_cast<int>(scanNumber);

 }

+// Using this function instead of pwiz translateNativeIDToScanNumber because

+// it randomly causes segfaults on macOS.

+// int RcppPwiz::getAcquisitionNumber(string id, size_t index) const

+// {

+//   if (id.find("controllerType") != std::string::npos) {

+//     if (id.find("controllerType=0 controllerNumber=1") == std::string::npos)

+//       return static_cast<int>(index) + 1;

+//   }

+//   string e;

+//   std::smatch match;

+//   if (id.find("scan=") != std::string::npos)

+//     e ="scan=(\\d+)";

+//   else if (id.find("index=") != std::string::npos)

+//     e = "index=(\\d+)";

+//   else if (id.find("spectrum=") != std::string::npos)

+//     e = "spectrum=(\\d+)";

+//   else if (id.find("scanId=") != std::string::npos)

+//     e = "scanId=(\\d+)";

+//   else return static_cast<int>(index) + 1;

+//   if (std::regex_search(id, match, std::regex(e)))

+//     return lexical_cast<int>(match[1]);

+//   else return static_cast<int>(index) + 1;

+// }

+

 Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

   if (msd != NULL) {

     SpectrumListPtr slp = msd->run.spectrumListPtr;

@@ -3,6 +3,7 @@

 RcppPwiz::RcppPwiz()

 {

   msd = NULL;

+  nativeIdFormat = CVID_Unknown;

   instrumentInfo = Rcpp::List::create();

   chromatogramsInfo = Rcpp::DataFrame::create();

   isInCacheInstrumentInfo = FALSE;

@@ -15,12 +16,15 @@ RcppPwiz::~RcppPwiz()

   RcppPwiz::close();

 }

-void RcppPwiz::open(const string& fileName)

+// void RcppPwiz::open(const string& fileName)

+void RcppPwiz::open(Rcpp::StringVector fileName)

 {

-  filename = fileName;

-  msd = new MSDataFile(fileName);

-

+  filename = Rcpp::as<std::string>(fileName(0));

+  msd = new MSDataFile(filename);

+  // Better not to guess the native ID format. For mzML/mzXML all should be fine

+  // with the default one.

+  // nativeIdFormat = id::getDefaultNativeIDFormat(*msd);

 }

 /* Release all memory on close. */

@@ -30,6 +34,7 @@ void RcppPwiz::close()

     {

       delete msd;

       msd = NULL;

+      nativeIdFormat = CVID_Unknown;

       instrumentInfo = Rcpp::List::create();

       chromatogramsInfo = Rcpp::DataFrame::create();

       isInCacheInstrumentInfo = FALSE;

@@ -127,12 +132,47 @@ Rcpp::List RcppPwiz::getInstrumentInfo ( )

   return instrumentInfo;

 }

+// int RcppPwiz::getAcquisitionNumber(size_t index) const

+// {

+//   const SpectrumIdentity& si = msd->run.spectrumListPtr->spectrumIdentity(index);

+//   string scanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, si.id);

+//   if (scanNumber.empty()) {

+//     return static_cast<int>(index) + 1;

+//   }

+//   else

+//     return lexical_cast<int>(scanNumber);

+//   // return static_cast<int>(index) + 1;

+// }

+

+// Using this function instead of pwiz translateNativeIDToScanNumber because

+// it randomly causes segfaults on macOS.

+int RcppPwiz::getAcquisitionNumber(string id, size_t index) const

+{

+  if (id.find("controllerType") != std::string::npos) {

+    if (id.find("controllerType=0 controllerNumber=1") == std::string::npos)

+      return static_cast<int>(index) + 1;

+  }

+  string e;

+  std::smatch match;

+  if (id.find("scan=") != std::string::npos)

+    e ="scan=(\\d+)";

+  else if (id.find("index=") != std::string::npos)

+    e = "index=(\\d+)";

+  else if (id.find("spectrum=") != std::string::npos)

+    e = "spectrum=(\\d+)";

+  else if (id.find("scanId=") != std::string::npos)

+    e = "scanId=(\\d+)";

+  else return static_cast<int>(index) + 1;

+  if (std::regex_search(id, match, std::regex(e)))

+    return lexical_cast<int>(match[1]);

+  else return static_cast<int>(index) + 1;

+}

+

 Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

   if (msd != NULL) {

     SpectrumListPtr slp = msd->run.spectrumListPtr;

-    int N = slp->size();

-    int N_scans = whichScan.size();

-    CVID nativeIdFormat = id::getDefaultNativeIDFormat(*msd);

+    size_t N = slp->size();

+    size_t N_scans = whichScan.size();

     Rcpp::IntegerVector seqNum(N_scans); // number in sequence observed file (1-based)

     Rcpp::IntegerVector acquisitionNum(N_scans); // scan number as declared in File (may be gaps)

     Rcpp::IntegerVector msLevel(N_scans);

@@ -165,23 +205,20 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

     Rcpp::NumericVector scanWindowLowerLimit(N_scans);

     Rcpp::NumericVector scanWindowUpperLimit(N_scans);

-    for (int i = 0; i < N_scans; i++) {

+    for (size_t i = 0; i < N_scans; i++) {

       int current_scan = whichScan[i];

-      SpectrumPtr sp = slp->spectrum(current_scan - 1, false);

+      size_t current_index = static_cast<size_t>(current_scan - 1);

+      // SpectrumPtr sp = slp->spectrum(current_index, false);

+      SpectrumPtr sp = slp->spectrum(current_index, DetailLevel_FullMetadata);

       Scan dummy;

       Scan& scan = sp->scanList.scans.empty() ? dummy : sp->scanList.scans[0];

+      if (scan.empty())

+	Rprintf("Scan with index %d empty.\n", current_scan);

       // seqNum

       seqNum[i] = current_scan;

-      // acquisitionNum

-      string id = sp->id;

-      string scanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, id);

-      if (scanNumber.empty()) {

-	acquisitionNum[i] = current_scan;

-      } else {

-	acquisitionNum[i] = lexical_cast<int>(scanNumber);

-      }

+      acquisitionNum[i] = getAcquisitionNumber(sp->id, current_index);

       // spectrumId

-      spectrumId[i] = sp->id;

+      spectrumId[i] = Rcpp::String(sp->id);

       // msLevel

       msLevel[i] = sp->cvParam(MS_ms_level).valueAs<int>();

       // peaksCount

@@ -231,14 +268,8 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

 	collisionEnergy[i] = precursor.activation.cvParam(MS_collision_energy).valueAs<double>();

 	// precursorScanNum

 	size_t precursorIndex = slp->find(precursor.spectrumID);

-	if (precursorIndex < slp->size()) {

-	  const SpectrumIdentity& precursorSpectrum = slp->spectrumIdentity(precursorIndex);

-	  string precursorScanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, precursorSpectrum.id);

-	  if (precursorScanNumber.empty()) {

-	    precursorScanNum[i] = precursorIndex + 1;

-	  } else {

-	    precursorScanNum[i] = lexical_cast<int>(precursorScanNumber);

-	  }

+	if (precursorIndex < N) {

+	  precursorScanNum[i] = getAcquisitionNumber(precursor.spectrumID, precursorIndex);

 	} else {

 	  precursorScanNum[i] = NA_INTEGER;

 	}

@@ -277,7 +308,7 @@ Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

     Rcpp::List header(31);

     std::vector<std::string> names;

-    int i = 0;

+    size_t i = 0;

     names.push_back("seqNum");

     header[i++] = Rcpp::wrap(seqNum);

     names.push_back("acquisitionNum");

@@ -352,7 +383,7 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) {

   if (msd != NULL) {

     if (!isInCacheAllScanHeaderInfo) {

       SpectrumListPtr slp = msd->run.spectrumListPtr;

-      int N = slp->size();

+      size_t N = slp->size();

       allScanHeaderInfo = getScanHeaderInfo(Rcpp::seq(1, N));

       isInCacheAllScanHeaderInfo = TRUE;	    

@@ -366,21 +397,23 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) {

 Rcpp::List RcppPwiz::getPeakList(Rcpp::IntegerVector whichScan) {

   if (msd != NULL) {

     SpectrumListPtr slp = msd->run.spectrumListPtr;

-    int n_scans = slp->size();

-    int n_want = whichScan.size();

+    size_t n_scans = slp->size();

+    size_t n_want = whichScan.size();

     int current_scan;

     SpectrumPtr sp;

     BinaryDataArrayPtr mzs,ints;

     std::vector<double> data;

     Rcpp::NumericVector data_matrix;

     Rcpp::List res(n_want);

-    for (int i = 0; i < n_want; i++) {

+    for (size_t i = 0; i < n_want; i++) {

       current_scan = whichScan[i];

       if (current_scan < 1 || current_scan > n_scans) {

 	Rprintf("Index whichScan out of bounds [1 ... %d].\n", n_scans);

 	return Rcpp::List::create( );

       }

-      sp = slp->spectrum(current_scan - 1, true);

+      size_t current_index = static_cast<size_t>(current_scan - 1);

+      // sp = slp->spectrum(current_index, true);

+      sp = slp->spectrum(current_index, DetailLevel_FullData);

       mzs = sp->getMZArray();

       ints = sp->getIntensityArray();

       if (!mzs.get() || !ints.get()) {

@@ -847,7 +880,7 @@ Rcpp::DataFrame RcppPwiz::getChromatogramsInfo( int whichChrom )

 Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichChrom)

 {

   if (msd != NULL) {

-    CVID nativeIdFormat_ = id::getDefaultNativeIDFormat(*msd);

+    // CVID nativeIdFormat_ = id::getDefaultNativeIDFormat(*msd);

     ChromatogramListPtr clp = msd->run.chromatogramListPtr;

     if (clp.get() == 0) {

       Rf_warningcall(R_NilValue, "The direct support for chromatogram info is only available in mzML format.");

@@ -980,7 +1013,7 @@ Rcpp::NumericMatrix RcppPwiz::get3DMap ( std::vector<int> scanNumbers, double wh

       //Rprintf("%d\n",1);

       for (int i = 0; i < scanNumbers.size(); i++)

         {

-	  SpectrumPtr s = slp->spectrum(scanNumbers[i] - 1, true);

+	  SpectrumPtr s = slp->spectrum(scanNumbers[i] - 1, DetailLevel_FullMetadata);

 	  vector<MZIntensityPair> pairs;

 	  s->getMZIntensityPairs(pairs);

@@ -38,43 +38,6 @@ void RcppPwiz::close()

     }

 }

-

-// void RcppPwiz::writeMSfile(const string& file, const string& format)

-// {

-//     if (msd != NULL)

-//     {

-//         if(format == "mgf")

-//         {

-//             std::ofstream* mgfOutFileP = new std::ofstream(file.c_str());

-//             Serializer_MGF serializerMGF;

-//             serializerMGF.write(*mgfOutFileP, *msd);

-//             mgfOutFileP->flush();

-//             mgfOutFileP->close();

-//         }

-//         else if(format == "mzxml")

-//         {

-//             std::ofstream mzXMLOutFileP(file.c_str());

-//             Serializer_mzXML::Config config;

-//             config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;

-//             Serializer_mzXML serializerMzXML(config);

-//             serializerMzXML.write(mzXMLOutFileP, *msd);

-//         }

-//         else if(format == "mzml")

-//         {

-//             std::ofstream mzXMLOutFileP(file.c_str());

-//             Serializer_mzML::Config config;

-//             config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;

-//             Serializer_mzML mzmlSerializer(config);

-//             mzmlSerializer.write(mzXMLOutFileP, *msd);

-//         }

-//         else

-//             Rcpp::Rcerr << format << " format not supported! Please try mgf, mzML, mzXML or mz5." << std::endl;

-//     }

-//     else

-//         Rcpp::Rcerr << "No pwiz object available! Please open a file first!" << std::endl;

-// }

-

-

 string RcppPwiz::getFilename() {

   return filename;

 }

@@ -400,34 +363,43 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) {

   return Rcpp::DataFrame::create( );

 }

-Rcpp::List RcppPwiz::getPeakList (int whichScan) {

+Rcpp::List RcppPwiz::getPeakList(Rcpp::IntegerVector whichScan) {

   if (msd != NULL) {

     SpectrumListPtr slp = msd->run.spectrumListPtr;

-    if ((whichScan <= 0) || (whichScan > slp->size())) {

-      Rprintf("Index whichScan out of bounds [1 ... %d].\n", slp->size());

-      return Rcpp::List::create( );

-    }

-    SpectrumPtr s = slp->spectrum(whichScan - 1, true);

-    vector<MZIntensityPair> pairs;

-    s->getMZIntensityPairs(pairs);

-

-    Rcpp::NumericMatrix peaks(pairs.size(), 2);

-

-    if(pairs.size()!=0) {

-      for (int i = 0; i < pairs.size(); i++) {

-	MZIntensityPair p = pairs.at(i);

-	peaks(i,0) = p.mz;

-	peaks(i,1) = p.intensity;

+    int n_scans = slp->size();

+    int n_want = whichScan.size();

+    int current_scan;

+    SpectrumPtr sp;

+    BinaryDataArrayPtr mzs,ints;

+    std::vector<double> data;

+    Rcpp::NumericVector data_matrix;

+    Rcpp::List res(n_want);

+    for (int i = 0; i < n_want; i++) {

+      current_scan = whichScan[i];

+      if (current_scan < 1 || current_scan > n_scans) {

+	Rprintf("Index whichScan out of bounds [1 ... %d].\n", n_scans);

+	return Rcpp::List::create( );

       }

+      sp = slp->spectrum(current_scan - 1, true);

+      mzs = sp->getMZArray();

+      ints = sp->getIntensityArray();

+      if (!mzs.get() || !ints.get()) {

+	Rcpp::NumericMatrix pks(0, 2);

+	res[i] = pks;

+	continue;

+      }

+      if (mzs->data.size() != ints->data.size())

+	Rcpp::Rcerr << "Sizes of mz and intensity arrays don't match." << std::endl;

+      data = mzs->data;

+      data.insert(data.end(), ints->data.begin(), ints->data.end());

+      data_matrix = Rcpp::wrap(data);

+      data_matrix.attr("dim") = Rcpp::Dimension(ints->data.size(), 2);

+      res[i] = data_matrix;

     }

-

-    return Rcpp::List::create(

-			      Rcpp::_["peaksCount"]  = pairs.size(),

-			      Rcpp::_["peaks"]  = peaks

-			      ) ;

+    return res;

   }

   Rf_warningcall(R_NilValue, "pwiz not yet initialized.");

-  return Rcpp::List::create( );

+  return Rcpp::List::create();

 }

 /**

@@ -391,7 +391,7 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) {

       SpectrumListPtr slp = msd->run.spectrumListPtr;

       int N = slp->size();

-      allScanHeaderInfo = getSpectrumHeader(Rcpp::seq(1, N));

+      allScanHeaderInfo = getScanHeaderInfo(Rcpp::seq(1, N));

       isInCacheAllScanHeaderInfo = TRUE;	    

     }

     return allScanHeaderInfo ;

@@ -164,247 +164,268 @@ Rcpp::List RcppPwiz::getInstrumentInfo ( )

   return instrumentInfo;

 }

-

-Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan)

-{

-  if (msd != NULL)

-    {

-      SpectrumListPtr slp = msd->run.spectrumListPtr;

-      int N = slp->size();

-      

-      int N_scans = whichScan.size();

-      

-      ScanHeaderStruct scanHeader;

-      RAMPAdapter * adapter = new  RAMPAdapter(filename);

-      Rcpp::IntegerVector seqNum(N_scans); // number in sequence observed file (1-based)

-      Rcpp::IntegerVector acquisitionNum(N_scans); // scan number as declared in File (may be gaps)

-      Rcpp::IntegerVector msLevel(N_scans);

-      Rcpp::IntegerVector polarity(N_scans);

-      Rcpp::IntegerVector peaksCount(N_scans);

-      Rcpp::NumericVector totIonCurrent(N_scans);

-      Rcpp::NumericVector retentionTime(N_scans);        /* in seconds */

-      Rcpp::NumericVector basePeakMZ(N_scans);

-      Rcpp::NumericVector basePeakIntensity(N_scans);

-      Rcpp::NumericVector collisionEnergy(N_scans);

-      Rcpp::NumericVector ionisationEnergy(N_scans);

-      Rcpp::NumericVector lowMZ(N_scans);

-      Rcpp::NumericVector highMZ(N_scans);

-      Rcpp::IntegerVector precursorScanNum(N_scans); /* only if MS level > 1 */

-      Rcpp::NumericVector precursorMZ(N_scans);  /* only if MS level > 1 */

-      Rcpp::IntegerVector precursorCharge(N_scans);  /* only if MS level > 1 */

-      Rcpp::NumericVector precursorIntensity(N_scans);  /* only if MS level > 1 */

-      //char scanType[SCANTYPE_LENGTH];

-      //char activationMethod[SCANTYPE_LENGTH];

-      //char possibleCharges[SCANTYPE_LENGTH];

-      //int numPossibleCharges;

-      //bool possibleChargesArray[CHARGEARRAY_LENGTH]; /* NOTE: does NOT include "precursorCharge" information; only from "possibleCharges" */

-      Rcpp::IntegerVector mergedScan(N_scans);  /* only if MS level > 1 */

-      Rcpp::IntegerVector mergedResultScanNum(N_scans); /* scan number of the resultant merged scan */

-      Rcpp::IntegerVector mergedResultStartScanNum(N_scans); /* smallest scan number of the scanOrigin for merged scan */

-      Rcpp::IntegerVector mergedResultEndScanNum(N_scans); /* largest scan number of the scanOrigin for merged scan */

-      Rcpp::NumericVector ionInjectionTime(N_scans); /* The time spent filling an ion trapping device*/

-      Rcpp::StringVector filterString(N_scans);

-      Rcpp::StringVector spectrumId(N_scans);

-      Rcpp::LogicalVector centroided(N_scans);

-      Rcpp::NumericVector ionMobilityDriftTime(N_scans);

-      Rcpp::NumericVector isolationWindowTargetMZ(N_scans);

-      Rcpp::NumericVector isolationWindowLowerOffset(N_scans);

-      Rcpp::NumericVector isolationWindowUpperOffset(N_scans);

-      Rcpp::NumericVector scanWindowLowerLimit(N_scans);

-      Rcpp::NumericVector scanWindowUpperLimit(N_scans);

-      

-      for (int i = 0; i < N_scans; i++)

-	{

-	  int current_scan = whichScan[i];

-	  adapter->getScanHeader(current_scan - 1, scanHeader, false);

-	  seqNum[i] = scanHeader.seqNum;

-	  acquisitionNum[i] = scanHeader.acquisitionNum;

-	  msLevel[i] = scanHeader.msLevel;

-	  

-	  SpectrumPtr sp = slp->spectrum(current_scan-1, false); // Is TRUE neccessary here ? 

-	  Scan dummy;

-	  Scan& scan = sp->scanList.scans.empty() ? dummy : sp->scanList.scans[0];

-	  CVParam param = sp->cvParamChild(MS_scan_polarity);

-	  polarity[i] = (param.cvid==MS_negative_scan ? 0 : (param.cvid==MS_positive_scan ? +1 : -1 ) );

-	  // ionInjectionTime[i] = scan.cvParam(MS_ion_injection_time).valueAs<double>();

-	  ionInjectionTime[i] = (scan.cvParam(MS_ion_injection_time).timeInSeconds() * 1000);

-	  filterString[i] = scan.cvParam(MS_filter_string).value.empty() ? NA_STRING : Rcpp::String(scan.cvParam(MS_filter_string).value);

-	  ionMobilityDriftTime[i] = scan.cvParam(MS_ion_mobility_drift_time).value.empty() ? NA_REAL : (scan.cvParam(MS_ion_mobility_drift_time).timeInSeconds() * 1000);

-

-	  if (!scan.scanWindows.empty()) {

-	    scanWindowLowerLimit[i] = scan.scanWindows[0].cvParam(MS_scan_window_lower_limit).valueAs<double>();

-	    scanWindowUpperLimit[i] = scan.scanWindows[0].cvParam(MS_scan_window_upper_limit).valueAs<double>();

-	  } else {

-	    scanWindowLowerLimit[i] = NA_REAL;

-	    scanWindowUpperLimit[i] = NA_REAL;

-	  }

-	  

-	  if (!sp->precursors.empty()) {

-	    IsolationWindow iwin = sp->precursors[0].isolationWindow;

-	    if (!iwin.empty()) {

-	      isolationWindowTargetMZ[i] = iwin.cvParam(MS_isolation_window_target_m_z).value.empty() ? NA_REAL : iwin.cvParam(MS_isolation_window_target_m_z).valueAs<double>();

-	      isolationWindowLowerOffset[i] = iwin.cvParam(MS_isolation_window_lower_offset).value.empty() ? NA_REAL : iwin.cvParam(MS_isolation_window_lower_offset).valueAs<double>();

-	      isolationWindowUpperOffset[i] = iwin.cvParam(MS_isolation_window_upper_offset).value.empty() ? NA_REAL : iwin.cvParam(MS_isolation_window_upper_offset).valueAs<double>();

-	    } else {

-	      isolationWindowTargetMZ[i] = NA_REAL;

-	      isolationWindowLowerOffset[i] = NA_REAL;

-	      isolationWindowUpperOffset[i] = NA_REAL;

-	    }

+Rcpp::DataFrame RcppPwiz::getScanHeaderInfo (Rcpp::IntegerVector whichScan) {

+  if (msd != NULL) {

+    SpectrumListPtr slp = msd->run.spectrumListPtr;

+    int N = slp->size();

+    int N_scans = whichScan.size();

+    CVID nativeIdFormat = id::getDefaultNativeIDFormat(*msd);

+    Rcpp::IntegerVector seqNum(N_scans); // number in sequence observed file (1-based)

+    Rcpp::IntegerVector acquisitionNum(N_scans); // scan number as declared in File (may be gaps)

+    Rcpp::IntegerVector msLevel(N_scans);

+    Rcpp::IntegerVector polarity(N_scans);

+    Rcpp::IntegerVector peaksCount(N_scans);

+    Rcpp::NumericVector totIonCurrent(N_scans);

+    Rcpp::NumericVector retentionTime(N_scans);        /* in seconds */

+    Rcpp::NumericVector basePeakMZ(N_scans);

+    Rcpp::NumericVector basePeakIntensity(N_scans);

+    Rcpp::NumericVector collisionEnergy(N_scans);

+    Rcpp::NumericVector ionisationEnergy(N_scans);

+    Rcpp::NumericVector lowMZ(N_scans);

+    Rcpp::NumericVector highMZ(N_scans);

+    Rcpp::IntegerVector precursorScanNum(N_scans); /* only if MS level > 1 */

+    Rcpp::NumericVector precursorMZ(N_scans);  /* only if MS level > 1 */

+    Rcpp::IntegerVector precursorCharge(N_scans);  /* only if MS level > 1 */

+    Rcpp::NumericVector precursorIntensity(N_scans);  /* only if MS level > 1 */

+    Rcpp::IntegerVector mergedScan(N_scans);  /* only if MS level > 1 */

+    Rcpp::IntegerVector mergedResultScanNum(N_scans); /* scan number of the resultant merged scan */

+    Rcpp::IntegerVector mergedResultStartScanNum(N_scans); /* smallest scan number of the scanOrigin for merged scan */

+    Rcpp::IntegerVector mergedResultEndScanNum(N_scans); /* largest scan number of the scanOrigin for merged scan */

+    Rcpp::NumericVector ionInjectionTime(N_scans); /* The time spent filling an ion trapping device*/

+    Rcpp::StringVector filterString(N_scans);

+    Rcpp::StringVector spectrumId(N_scans);

+    Rcpp::LogicalVector centroided(N_scans);

+    Rcpp::NumericVector ionMobilityDriftTime(N_scans);

+    Rcpp::NumericVector isolationWindowTargetMZ(N_scans);

+    Rcpp::NumericVector isolationWindowLowerOffset(N_scans);

+    Rcpp::NumericVector isolationWindowUpperOffset(N_scans);

+    Rcpp::NumericVector scanWindowLowerLimit(N_scans);

+    Rcpp::NumericVector scanWindowUpperLimit(N_scans);

+    

+    for (int i = 0; i < N_scans; i++) {

+      int current_scan = whichScan[i];

+      SpectrumPtr sp = slp->spectrum(current_scan - 1, false);

+      Scan dummy;

+      Scan& scan = sp->scanList.scans.empty() ? dummy : sp->scanList.scans[0];

+      // seqNum

+      seqNum[i] = current_scan;

+      // acquisitionNum

+      string id = sp->id;

+      string scanNumber = id::translateNativeIDToScanNumber(nativeIdFormat, id);

+      if (scanNumber.empty()) {

+	acquisitionNum[i] = current_scan;

+      } else {

+	acquisitionNum[i] = lexical_cast<int>(scanNumber);

+      }

+      // spectrumId

+      spectrumId[i] = sp->id;

+      // msLevel

+      msLevel[i] = sp->cvParam(MS_ms_level).valueAs<int>();

+      // peaksCount

+      peaksCount[i] = static_cast<int>(sp->defaultArrayLength);

+      // totIonCurrent

+      totIonCurrent[i] = sp->cvParam(MS_total_ion_current).valueAs<double>();

+      // basePeakMZ

+      basePeakMZ[i] = sp->cvParam(MS_base_peak_m_z).valueAs<double>();

+      // basePeakIntensity

+      basePeakIntensity[i] = sp->cvParam(MS_base_peak_intensity).valueAs<double>();

+      // ionisationEnerty

+      ionisationEnergy[i] = sp->cvParam(MS_ionization_energy_OBSOLETE).valueAs<double>();

+      // lowMZ

+      lowMZ[i] = sp->cvParam(MS_lowest_observed_m_z).valueAs<double>();

+      // highMZ

+      highMZ[i] = sp->cvParam(MS_highest_observed_m_z).valueAs<double>();

+      // polarity

+      CVParam param = sp->cvParamChild(MS_scan_polarity);

+      polarity[i] = (param.cvid==MS_negative_scan ? 0 : (param.cvid==MS_positive_scan ? +1 : -1 ) );

+      // centroided

+      param = sp->cvParamChild(MS_spectrum_representation);

+      centroided[i] = (param.cvid==MS_centroid_spectrum ? TRUE : (param.cvid==MS_profile_spectrum ? FALSE : NA_LOGICAL));      

+      // retentionTime

+      retentionTime[i] = scan.cvParam(MS_scan_start_time).timeInSeconds();

+      // ionInjectionTime

+      ionInjectionTime[i] = (scan.cvParam(MS_ion_injection_time).timeInSeconds() * 1000);

+      // filterString

+      filterString[i] = scan.cvParam(MS_filter_string).value.empty() ? NA_STRING : Rcpp::String(scan.cvParam(MS_filter_string).value);

+      // ionMobilityDriftTime

+      ionMobilityDriftTime[i] = scan.cvParam(MS_ion_mobility_drift_time).value.empty() ? NA_REAL : (scan.cvParam(MS_ion_mobility_drift_time).timeInSeconds() * 1000);

+      // scanWindowLowerLimit and scanWindowUpperLimit

+      if (!scan.scanWindows.empty()) {

+	scanWindowLowerLimit[i] = scan.scanWindows[0].cvParam(MS_scan_window_lower_limit).valueAs<double>();

+	scanWindowUpperLimit[i] = scan.scanWindows[0].cvParam(MS_scan_window_upper_limit).valueAs<double>();

+      } else {

+	scanWindowLowerLimit[i] = NA_REAL;

+	scanWindowUpperLimit[i] = NA_REAL;

+      }

+      // mergedScan - also not supported by RAMPAdapter

+      mergedScan[i] = NA_INTEGER;

+      mergedResultScanNum[i] = NA_INTEGER;

+      mergedResultStartScanNum[i] = NA_INTEGER;

+      mergedResultEndScanNum[i] = NA_INTEGER;

+      if (!sp->precursors.empty()) {

+	const Precursor& precursor = sp->precursors[0];

+	// collisionEnergy

+	collisionEnergy[i] = precursor.activation.cvParam(MS_collision_energy).valueAs<double>();