diff --git a/src/classes/PMusrCanvas.cpp b/src/classes/PMusrCanvas.cpp
index 81b15743..6e426fea 100644
--- a/src/classes/PMusrCanvas.cpp
+++ b/src/classes/PMusrCanvas.cpp
@@ -3273,57 +3273,17 @@ void PMusrCanvas::DecrementFourierPhase()
  */
 void PMusrCanvas::SaveDataAscii()
 {
-  // generate output filename
+  // collect relevant data
+  PMusrCanvasAsciiDump dump;
+  PMusrCanvasAsciiDumpVector dumpVector;
 
-  // in order to handle names with "." correctly this slightly odd data-filename generation
-  TObjArray *tokens = fMsrHandler->GetFileName().Tokenize(".");
-  TObjString *ostr;
-  TString str;
-  TString flnData = TString("");
-  TString flnTheo = TString("");
-  for (Int_t i=0; i<tokens->GetEntries()-1; i++) {
-    ostr = dynamic_cast<TObjString*>(tokens->At(i));
-    flnData += ostr->GetString() + TString(".");
-    flnTheo += ostr->GetString() + TString(".");
-  }
-  if (!fDifferenceView) {
-    flnData += "data.ascii";
-  } else {
-    flnData += "diff.ascii";
-  }
-  flnTheo += "theo.ascii";
-
-  if (tokens) {
-    delete tokens;
-    tokens = 0;
-  }
-
-  // open file
-  ofstream foutData;
-  ofstream foutTheo;
-
-  // open output data-file
-  foutData.open(flnData.Data(), iostream::out);
-  if (!foutData.is_open()) {
-    cerr << endl << ">> PMusrCanvas::SaveDataAscii: **ERROR** couldn't open file " << flnData.Data() << " for writing." << endl;
-    return;
-  }
-
-  if (!fDifferenceView) {
-    // open output theory-file
-    foutTheo.open(flnTheo.Data(), iostream::out);
-    if (!foutTheo.is_open()) {
-      cerr << endl << ">> PMusrCanvas::SaveDataAscii: **ERROR** couldn't open file " << flnTheo.Data() << " for writing." << endl;
-      return;
-    }
-  }
-
-  // extract data
-  Double_t time, xval, yval;
   Int_t xminBin;
   Int_t xmaxBin;
   Double_t xmin;
   Double_t xmax;
+  Double_t time, freq;
+  Double_t xval, yval;
+
   switch (fPlotType) {
     case MSR_PLOT_SINGLE_HISTO:
     case MSR_PLOT_ASYM:
@@ -3331,39 +3291,206 @@ void PMusrCanvas::SaveDataAscii()
       if (fDifferenceView) { // difference view plot
         switch (fCurrentPlotView) {
           case PV_DATA:
-            // write header
-            foutData << "% time (us)";
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", Diff" << j << ", eDiff" << j;
-            }
-            foutData << endl;
             // get current x-range
             xminBin = fHistoFrame->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fHistoFrame->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fHistoFrame->GetXaxis()->GetBinCenter(xminBin);
             xmax = fHistoFrame->GetXaxis()->GetBinCenter(xmaxBin);
-            // get difference data
-            for (Int_t i=1; i<fData[0].diff->GetNbinsX()-1; i++) {
-              time = fData[0].diff->GetBinCenter(i); // get time
-              if ((time < xmin) || (time > xmax))
-                continue;
-              foutData << time;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].diff->GetBinContent(i);
-                foutData << ", " << fData[j].diff->GetBinError(i);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all difference data bins
+              for (Int_t j=1; j<fData[i].diff->GetNbinsX(); j++) {
+                // get time
+                time = fData[i].diff->GetBinCenter(j);
+                // check if time is in the current range
+                if ((time >= xmin) && (time <= xmax)) {
+                  dump.dataX.push_back(time);
+                  dump.data.push_back(fData[i].diff->GetBinContent(j));
+                  dump.dataErr.push_back(fData[i].diff->GetBinError(j));
+                }
               }
-              foutData << endl;
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
             break;
           case PV_FOURIER_REAL:
+            // get current x-range
+            xminBin = fData[0].diffFourierRe->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fData[0].diffFourierRe->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fData[0].diffFourierRe->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fData[0].diffFourierRe->GetXaxis()->GetBinCenter(xmaxBin);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].diffFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].diffFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].diffFourierRe->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+            }
             break;
           case PV_FOURIER_IMAG:
+            // get current x-range
+            xminBin = fData[0].diffFourierIm->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fData[0].diffFourierIm->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fData[0].diffFourierIm->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fData[0].diffFourierIm->GetXaxis()->GetBinCenter(xmaxBin);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].diffFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].diffFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].diffFourierIm->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+            }
             break;
           case PV_FOURIER_REAL_AND_IMAG:
+            // get current x-range
+            xminBin = fData[0].diffFourierRe->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fData[0].diffFourierRe->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fData[0].diffFourierRe->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fData[0].diffFourierRe->GetXaxis()->GetBinCenter(xmaxBin);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].diffFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].diffFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].diffFourierRe->GetBinContent(j));
+                }
+              }
+              for (Int_t j=1; j<fData[i].diffFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].diffFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].diffFourierIm->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+            }
             break;
           case PV_FOURIER_PWR:
+            // get current x-range
+            xminBin = fData[0].dataFourierPwr->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fData[0].dataFourierPwr->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fData[0].dataFourierPwr->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fData[0].dataFourierPwr->GetXaxis()->GetBinCenter(xmaxBin);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierPwr->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierPwr->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierPwr->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+            }
             break;
           case PV_FOURIER_PHASE:
+            // get current x-range
+            xminBin = fData[0].dataFourierPhase->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fData[0].dataFourierPhase->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fData[0].dataFourierPhase->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fData[0].dataFourierPhase->GetXaxis()->GetBinCenter(xmaxBin);
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierPhase->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierPhase->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierPhase->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+            }
             break;
           default:
             break;
@@ -3371,349 +3498,303 @@ void PMusrCanvas::SaveDataAscii()
       } else { // not a difference view plot
         switch (fCurrentPlotView) {
           case PV_DATA:
-            // write header
-            foutData << endl << "% timeData (us)";
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", Data" << j << ", eData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << ", timeTheo (us)";
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", Theo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fHistoFrame->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fHistoFrame->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fHistoFrame->GetXaxis()->GetBinCenter(xminBin);
             xmax = fHistoFrame->GetXaxis()->GetBinCenter(xmaxBin);
-            // write data
-            for (Int_t i=1; i<fData[0].data->GetNbinsX()-1; i++) {
-              time = fData[0].data->GetBinCenter(i); // get time
-              if ((time < xmin) || (time > xmax))
-                continue;
-              foutData << time << ", ";
-              for (UInt_t j=0; j<fData.size()-1; j++) {
-                foutData << fData[j].data->GetBinContent(i) << ", ";
-                foutData << fData[j].data->GetBinError(i) << ", ";
+
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].data->GetNbinsX(); j++) {
+                // get time
+                time = fData[i].data->GetBinCenter(j);
+                // check if time is in the current range
+                if ((time >= xmin) && (time <= xmax)) {
+                  dump.dataX.push_back(time);
+                  dump.data.push_back(fData[i].data->GetBinContent(j));
+                  dump.dataErr.push_back(fData[i].data->GetBinError(j));
+                }
               }
-              // write last data set
-              foutData << fData[fData.size()-1].data->GetBinContent(i) << ", ";
-              foutData << fData[fData.size()-1].data->GetBinError(i) << ", ";
-              foutData << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theory->GetNbinsX(); j++) {
+                // get time
+                time = fData[i].theory->GetBinCenter(j);
+                // check if time is in the current range
+                if ((time >= xmin) && (time <= xmax)) {
+                  dump.theoryX.push_back(time);
+                  dump.theory.push_back(fData[i].theory->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theory->GetNbinsX()-1; i++) {
-              time = fData[0].theory->GetBinCenter(i); // get time
-              if ((time < xmin) || (time > xmax))
-                continue;
-              foutTheo << time << ", ";
-              for (UInt_t j=0; j<fData.size()-1; j++) {
-                foutTheo << fData[j].theory->GetBinContent(i) << ", ";
-              }
-              // write last data set
-              foutTheo << fData[fData.size()-1].theory->GetBinContent(i) << ", ";
-              foutTheo << endl;
-            }
             break;
           case PV_FOURIER_REAL:
-            // write header
-            str = TString("% ");
-            switch (fFourier.fUnits) {
-              case FOURIER_UNIT_FIELD:
-                str += TString(" Field (G)");
-                break;
-              case FOURIER_UNIT_FREQ:
-                str += TString(" Frequency (MHz)");
-                break;
-              case FOURIER_UNIT_CYCLES:
-                str += TString(" Angular Frequency (Mc/s)");
-                break;
-              default:
-                str += TString(" ????");
-                break;
-            }
-            foutData << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", RealFourierData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", RealFourierTheo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fData[0].dataFourierRe->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fData[0].dataFourierRe->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fData[0].dataFourierRe->GetXaxis()->GetBinCenter(xminBin);
             xmax = fData[0].dataFourierRe->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=1; i<fData[0].dataFourierRe->GetNbinsX()-1; i++) {
-              xval = fData[0].dataFourierRe->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].dataFourierRe->GetBinContent(i);
-              }
-              foutData << endl;
-            }
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theoryFourierRe->GetNbinsX()-1; i++) {
-              xval = fData[0].theoryFourierRe->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutTheo << ", " << fData[j].theoryFourierRe->GetBinContent(i);
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierRe->GetBinContent(j));
+                }
               }
-              foutTheo << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierRe->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
             break;
           case PV_FOURIER_IMAG:
-            // write header
-            str = TString("% ");
-            switch (fFourier.fUnits) {
-              case FOURIER_UNIT_FIELD:
-                str += TString(" Field (G)");
-                break;
-              case FOURIER_UNIT_FREQ:
-                str += TString(" Frequency (MHz)");
-                break;
-              case FOURIER_UNIT_CYCLES:
-                str += TString(" Angular Frequency (Mc/s)");
-                break;
-              default:
-                str += TString(" ????");
-                break;
-            }
-            foutData << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", ImagFourierData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", ImagFourierTheo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fData[0].dataFourierIm->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fData[0].dataFourierIm->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fData[0].dataFourierIm->GetXaxis()->GetBinCenter(xminBin);
             xmax = fData[0].dataFourierIm->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=1; i<fData[0].dataFourierIm->GetNbinsX()-1; i++) {
-              xval = fData[0].dataFourierIm->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].dataFourierIm->GetBinContent(i);
-              }
-              foutData << endl;
-            }
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theoryFourierIm->GetNbinsX()-1; i++) {
-              xval = fData[0].theoryFourierIm->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutTheo << ", " << fData[j].theoryFourierIm->GetBinContent(i);
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierIm->GetBinContent(j));
+                }
               }
-              foutTheo << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierIm->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
             break;
           case PV_FOURIER_REAL_AND_IMAG:
-            // write header
-            str = TString("% ");
-            switch (fFourier.fUnits) {
-              case FOURIER_UNIT_FIELD:
-                str += TString(" Field (G)");
-                break;
-              case FOURIER_UNIT_FREQ:
-                str += TString(" Frequency (MHz)");
-                break;
-              case FOURIER_UNIT_CYCLES:
-                str += TString(" Angular Frequency (Mc/s)");
-                break;
-              default:
-                str += TString(" ????");
-                break;
-            }
-            foutData << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", RealFourierData" << j << ", ImagFourierData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", RealFourierTheo" << j << ", ImagFourierTheo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fData[0].dataFourierRe->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fData[0].dataFourierRe->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fData[0].dataFourierRe->GetXaxis()->GetBinCenter(xminBin);
             xmax = fData[0].dataFourierRe->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=1; i<fData[0].dataFourierRe->GetNbinsX()-1; i++) {
-              xval = fData[0].dataFourierRe->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].dataFourierRe->GetBinContent(i);
-                foutData << ", " << fData[j].dataFourierIm->GetBinContent(i);
-              }
-              foutData << endl;
-            }
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              //-----------------------------
+              // Re
+              //-----------------------------
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theoryFourierRe->GetNbinsX()-1; i++) {
-              xval = fData[0].theoryFourierRe->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutTheo << ", " << fData[j].theoryFourierRe->GetBinContent(i);
-                foutTheo << ", " << fData[j].theoryFourierIm->GetBinContent(i);
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierRe->GetBinContent(j));
+                }
               }
-              foutTheo << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierRe->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierRe->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierRe->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+
+              //-----------------------------
+              // Im
+              //-----------------------------
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierIm->GetBinContent(j));
+                }
+              }
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierIm->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierIm->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierIm->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
+
             }
             break;
           case PV_FOURIER_PWR:
-            // write header
-            str = TString("% ");
-            switch (fFourier.fUnits) {
-              case FOURIER_UNIT_FIELD:
-                str += TString(" Field (G)");
-                break;
-              case FOURIER_UNIT_FREQ:
-                str += TString(" Frequency (MHz)");
-                break;
-              case FOURIER_UNIT_CYCLES:
-                str += TString(" Angular Frequency (Mc/s)");
-                break;
-              default:
-                str += TString(" ????");
-                break;
-            }
-            foutData << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", PwrFourierData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", PwrFourierTheo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fData[0].dataFourierPwr->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fData[0].dataFourierPwr->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fData[0].dataFourierPwr->GetXaxis()->GetBinCenter(xminBin);
             xmax = fData[0].dataFourierPwr->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=1; i<fData[0].dataFourierPwr->GetNbinsX()-1; i++) {
-              xval = fData[0].dataFourierPwr->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].dataFourierPwr->GetBinContent(i);
-              }
-              foutData << endl;
-            }
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theoryFourierPwr->GetNbinsX()-1; i++) {
-              xval = fData[0].theoryFourierPwr->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutTheo << ", " << fData[j].theoryFourierPwr->GetBinContent(i);
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierPwr->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierPwr->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierPwr->GetBinContent(j));
+                }
               }
-              foutTheo << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierPwr->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierPwr->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierPwr->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
             break;
           case PV_FOURIER_PHASE:
-            // write header
-            str = TString("% ");
-            switch (fFourier.fUnits) {
-              case FOURIER_UNIT_FIELD:
-                str += TString(" Field (G)");
-                break;
-              case FOURIER_UNIT_FREQ:
-                str += TString(" Frequency (MHz)");
-                break;
-              case FOURIER_UNIT_CYCLES:
-                str += TString(" Angular Frequency (Mc/s)");
-                break;
-              default:
-                str += TString(" ????");
-                break;
-            }
-            foutData << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutData << ", PhaseFourierData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << str.Data();
-            for (UInt_t j=0; j<fData.size(); j++) {
-              foutTheo << ", PhaseFourierTheo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fData[0].dataFourierPhase->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fData[0].dataFourierPhase->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fData[0].dataFourierPhase->GetXaxis()->GetBinCenter(xminBin);
             xmax = fData[0].dataFourierPhase->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=1; i<fData[0].dataFourierPhase->GetNbinsX()-1; i++) {
-              xval = fData[0].dataFourierPhase->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutData << ", " << fData[j].dataFourierPhase->GetBinContent(i);
-              }
-              foutData << endl;
-            }
+            // fill ascii dump data
+            for (UInt_t i=0; i<fData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
 
-            // write theory
-            for (Int_t i=1; i<fData[0].theoryFourierPhase->GetNbinsX()-1; i++) {
-              xval = fData[0].theoryFourierPhase->GetBinCenter(i); // get x-unit
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fData.size(); j++) {
-                foutTheo << ", " << fData[j].theoryFourierPhase->GetBinContent(i);
+              // go through all data bins
+              for (Int_t j=1; j<fData[i].dataFourierPhase->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].dataFourierPhase->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.dataX.push_back(freq);
+                  dump.data.push_back(fData[i].dataFourierPhase->GetBinContent(j));
+                }
               }
-              foutTheo << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fData[i].theoryFourierPhase->GetNbinsX(); j++) {
+                // get frequency
+                freq = fData[i].theoryFourierPhase->GetBinCenter(j);
+                // check if time is in the current range
+                if ((freq >= xmin) && (freq <= xmax)) {
+                  dump.theoryX.push_back(freq);
+                  dump.theory.push_back(fData[i].theoryFourierPhase->GetBinContent(j));
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
             break;
           default:
@@ -3725,33 +3806,38 @@ void PMusrCanvas::SaveDataAscii()
       if (fDifferenceView) { // difference view plot
         switch (fCurrentPlotView) {
           case PV_DATA:
-            // write header
-            foutData << "% " << fNonMusrData[0].diff->GetXaxis()->GetTitle() << ", ";
-            for (UInt_t j=0; j<fNonMusrData.size()-1; j++) {
-              foutData << "Diff" << j << ", eDiff" << j << ", ";
-            }
-            foutData << "Diff" << fNonMusrData.size()-1 << ", eDiff" << fNonMusrData.size()-1;
-            foutData << endl;
-
             // get current x-range
-            xminBin = fMultiGraphDiff->GetXaxis()->GetFirst(); // first bin of the zoomed range
-            xmaxBin = fMultiGraphDiff->GetXaxis()->GetLast();  // last bin of the zoomed range
-            xmin = fMultiGraphDiff->GetXaxis()->GetBinCenter(xminBin);
-            xmax = fMultiGraphDiff->GetXaxis()->GetBinCenter(xmaxBin);
+            xminBin = fMultiGraphData->GetXaxis()->GetFirst(); // first bin of the zoomed range
+            xmaxBin = fMultiGraphData->GetXaxis()->GetLast();  // last bin of the zoomed range
+            xmin = fMultiGraphData->GetXaxis()->GetBinCenter(xminBin);
+            xmax = fMultiGraphData->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=0; i<fNonMusrData[0].diff->GetN(); i++) {
-              fNonMusrData[0].diff->GetPoint(i,xval,yval); // get values
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fNonMusrData.size(); j++) {
-                fNonMusrData[j].diff->GetPoint(i,xval,yval); // get values
-                foutData << ", " << yval;
-                foutData << ", " << fNonMusrData[j].diff->GetErrorY(i);
+            // fill ascii dump data
+            for (UInt_t i=0; i<fNonMusrData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fNonMusrData[i].diff->GetN(); j++) {
+                // get x and y value
+                fNonMusrData[i].diff->GetPoint(j,xval,yval);
+                // check if time is in the current range
+                if ((xval >= xmin) && (xval <= xmax)) {
+                  dump.dataX.push_back(xval);
+                  dump.data.push_back(yval);
+                  dump.dataErr.push_back(fNonMusrData[i].diff->GetErrorY(j));
+                }
               }
-              foutData << endl;
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
+
             break;
           case PV_FOURIER_REAL:
             break;
@@ -3769,51 +3855,49 @@ void PMusrCanvas::SaveDataAscii()
       } else { // not a difference view plot
         switch (fCurrentPlotView) {
           case PV_DATA:
-            // write header
-            foutData << "% " << fNonMusrData[0].data->GetXaxis()->GetTitle() << ", ";
-            for (UInt_t j=0; j<fNonMusrData.size(); j++) {
-              foutData << ", Data" << j << ", eData" << j;
-            }
-            foutData << endl;
-
-            foutTheo << "% " << fNonMusrData[0].data->GetXaxis()->GetTitle() << ", ";
-            for (UInt_t j=0; j<fNonMusrData.size(); j++) {
-              foutTheo << ", Theo" << j;
-            }
-            foutTheo << endl;
-
             // get current x-range
             xminBin = fMultiGraphData->GetXaxis()->GetFirst(); // first bin of the zoomed range
             xmaxBin = fMultiGraphData->GetXaxis()->GetLast();  // last bin of the zoomed range
             xmin = fMultiGraphData->GetXaxis()->GetBinCenter(xminBin);
             xmax = fMultiGraphData->GetXaxis()->GetBinCenter(xmaxBin);
 
-            // write data
-            for (Int_t i=0; i<fNonMusrData[0].data->GetN(); i++) {
-              fNonMusrData[0].data->GetPoint(i,xval,yval); // get values
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutData << xval;
-              for (UInt_t j=0; j<fNonMusrData.size(); j++) {
-                fNonMusrData[j].data->GetPoint(i,xval,yval); // get values
-                foutData << ", " << yval;
-                foutData << ", " << fNonMusrData[j].data->GetErrorY(i);
+            // fill ascii dump data
+            for (UInt_t i=0; i<fNonMusrData.size(); i++) { // go through all the histogramms
+              // clean up dump
+              dump.dataX.clear();
+              dump.data.clear();
+              dump.dataErr.clear();
+              dump.theoryX.clear();
+              dump.theory.clear();
+
+              // go through all data bins
+              for (Int_t j=1; j<fNonMusrData[i].data->GetN(); j++) {
+                // get x and y value
+                fNonMusrData[i].data->GetPoint(j,xval,yval);
+                // check if time is in the current range
+                if ((xval >= xmin) && (xval <= xmax)) {
+                  dump.dataX.push_back(xval);
+                  dump.data.push_back(yval);
+                  dump.dataErr.push_back(fNonMusrData[i].data->GetErrorY(j));
+                }
               }
-              foutData << endl;
+
+              // go through all theory bins
+              for (Int_t j=1; j<fNonMusrData[i].theory->GetN(); j++) {
+                // get x and y value
+                fNonMusrData[i].theory->GetPoint(j,xval,yval);
+                // check if time is in the current range
+                if ((xval >= xmin) && (xval <= xmax)) {
+                  dump.theoryX.push_back(xval);
+                  dump.theory.push_back(yval);
+                }
+              }
+
+              // if anything found keep it
+              if (dump.dataX.size() > 0)
+                dumpVector.push_back(dump);
             }
 
-            // write theory
-            for (Int_t i=0; i<fNonMusrData[0].theory->GetN(); i++) {
-              fNonMusrData[0].theory->GetPoint(i,xval,yval); // get values
-              if ((xval < xmin) || (xval > xmax))
-                continue;
-              foutTheo << xval;
-              for (UInt_t j=0; j<fNonMusrData.size(); j++) {
-                fNonMusrData[j].theory->GetPoint(i,xval,yval); // get values
-                foutTheo << ", " << yval;
-              }
-              foutTheo << endl;
-            }
             break;
           case PV_FOURIER_REAL:
             break;
@@ -3834,9 +3918,251 @@ void PMusrCanvas::SaveDataAscii()
       break;
   }
 
+  // generate output filename
+
+  // in order to handle names with "." correctly this slightly odd data-filename generation
+  TObjArray *tokens = fMsrHandler->GetFileName().Tokenize(".");
+  TObjString *ostr;
+  TString str;
+  TString fln = TString("");
+  for (Int_t i=0; i<tokens->GetEntries()-1; i++) {
+    ostr = dynamic_cast<TObjString*>(tokens->At(i));
+    fln += ostr->GetString() + TString(".");
+  }
+  if (!fDifferenceView) {
+    fln += "data.ascii";
+  } else {
+    fln += "diff.ascii";
+  }
+
+  if (tokens) {
+    delete tokens;
+    tokens = 0;
+  }
+
+  // open file
+  ofstream fout;
+
+  // open output data-file
+  fout.open(fln.Data(), iostream::out);
+  if (!fout.is_open()) {
+    cerr << endl << ">> PMusrCanvas::SaveDataAscii: **ERROR** couldn't open file " << fln.Data() << " for writing." << endl;
+    return;
+  }
+
+  // find out what is the longest data/theory vector
+  UInt_t maxDataLength = 0;
+  UInt_t maxTheoryLength = 0;
+  for (UInt_t i=0; i<dumpVector.size(); i++) {
+    if (maxDataLength < dumpVector[i].dataX.size())
+      maxDataLength = dumpVector[i].dataX.size();
+    if (maxTheoryLength < dumpVector[i].theoryX.size())
+      maxTheoryLength = dumpVector[i].theoryX.size();
+  }
+
+  // write data to file
+  UInt_t maxLength = 0;
+
+  if (fDifferenceView) { // difference view
+    // write header
+    switch (fCurrentPlotView) {
+      case PV_DATA:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "x" << i << " , diff" << i << ", errDiff" << i << ", ";
+        }
+        fout << "x" << dumpVector.size()-1 << " , diff" << dumpVector.size()-1 << ", errDiff" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_REAL:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freq" << i << ", F_diffRe" << i << ", ";
+        }
+        fout << "freq" << dumpVector.size()-1 << ", F_diffRe" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_IMAG:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freq" << i << ", F_diffIm" << i << ", ";
+        }
+        fout << "freq" << dumpVector.size()-1 << ", F_diffIm" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_REAL_AND_IMAG:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size()/2; i++) {
+          fout << "freq" << i << ", F_diffRe" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()/2-1; i++) {
+          fout << "freq" << i << ", F_diffIm" << i << ", ";
+        }
+        fout << "freq" << dumpVector.size()/2-1 << ", F_diffIm" << dumpVector.size()/2-1 << endl;
+        break;
+      case PV_FOURIER_PWR:
+        break;
+      case PV_FOURIER_PHASE:
+        break;
+      default:
+        break;
+    }
+
+    maxLength = maxDataLength;
+
+    // write difference data
+    for (UInt_t i=0; i<maxLength; i++) {
+      // write difference data
+      for (UInt_t j=0; j<dumpVector.size()-1; j++) {
+        if (i<dumpVector[j].dataX.size()) {
+          fout << dumpVector[j].dataX[i] << ", ";
+          fout << dumpVector[j].data[i] << ", ";
+          if (dumpVector[j].dataErr.size() > 0)
+            fout << dumpVector[j].dataErr[i] << ", ";
+        } else {
+          if (dumpVector[j].dataErr.size() > 0)
+            fout << ", , , ";
+          else
+            fout << ", , ";
+        }
+      }
+      // write last difference entry
+      if (i<dumpVector[dumpVector.size()-1].dataX.size()) {
+        fout << dumpVector[dumpVector.size()-1].dataX[i] << ", ";
+        fout << dumpVector[dumpVector.size()-1].data[i] << ", ";
+        if (dumpVector[dumpVector.size()-1].dataErr.size() > 0)
+          fout << dumpVector[dumpVector.size()-1].dataErr[i];
+      } else {
+        if (dumpVector[dumpVector.size()-1].dataErr.size() > 0)
+          fout << ", , ";
+        else
+          fout << ", ";
+      }
+      fout << endl;
+    }
+  } else { // no difference view
+    // write header
+    switch (fCurrentPlotView) {
+      case PV_DATA:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size(); i++) {
+          fout << "xData" << i << " , data" << i << ", errData" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "xTheory" << i << " , theory" << i << ", ";
+        }
+        fout << "xTheory" << dumpVector.size()-1 << " , theory" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_REAL:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size(); i++) {
+          fout << "freq" << i << ", F_Re" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freqTheo" << i << ", F_theo" << i << ", ";
+        }
+        fout << "freqTheo" << dumpVector.size()-1 << ", F_theo" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_IMAG:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size(); i++) {
+          fout << "freq" << i << ", F_Im" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freqTheo" << i << ", F_theo" << i << ", ";
+        }
+        fout << "freqTheo" << dumpVector.size()-1 << ", F_theo" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_REAL_AND_IMAG:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size()/2; i++) {
+          fout << "freq" << i << ", F_Re" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()/2; i++) {
+          fout << "freq" << i << ", F_Im" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()/2; i++) {
+          fout << "freqTheo" << i << ", F_theoRe" << i << ", ";
+        }
+        for (UInt_t i=0; i<(dumpVector.size()-1)/2; i++) {
+          fout << "freqTheo" << i << ", F_theoIm" << i << ", ";
+        }
+        fout << "freqTheo" << (dumpVector.size()-1)/2 << ", F_theoIm" << (dumpVector.size()-1)/2 << endl;
+        break;
+      case PV_FOURIER_PWR:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size(); i++) {
+          fout << "freq" << i << ", F_Pwr" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freqTheo" << i << ", F_theo" << i << ", ";
+        }
+        fout << "freqTheo" << dumpVector.size()-1 << ", F_theo" << dumpVector.size()-1 << endl;
+        break;
+      case PV_FOURIER_PHASE:
+        fout << "% ";
+        for (UInt_t i=0; i<dumpVector.size(); i++) {
+          fout << "freq" << i << ", F_Phase" << i << ", ";
+        }
+        for (UInt_t i=0; i<dumpVector.size()-1; i++) {
+          fout << "freqTheo" << i << ", F_theo" << i << ", ";
+        }
+        fout << "freqTheo" << dumpVector.size()-1 << ", F_theo" << dumpVector.size()-1 << endl;
+        break;
+      default:
+        break;
+    }
+
+    if (maxDataLength > maxTheoryLength)
+      maxLength = maxDataLength;
+    else
+      maxLength = maxTheoryLength;
+
+    // write data and theory
+    for (UInt_t i=0; i<maxLength; i++) {
+      // write data
+      for (UInt_t j=0; j<dumpVector.size(); j++) {
+        if (i<dumpVector[j].dataX.size()) {
+          fout << dumpVector[j].dataX[i] << ", ";
+          fout << dumpVector[j].data[i] << ", ";
+          if (dumpVector[j].dataErr.size() > 0)
+            fout << dumpVector[j].dataErr[i] << ", ";
+        } else {
+          if (dumpVector[j].dataErr.size() > 0)
+            fout << ", , , ";
+          else
+            fout << ", , ";
+        }
+      }
+      // write theory
+      for (UInt_t j=0; j<dumpVector.size()-1; j++) {
+        if (i<dumpVector[j].theoryX.size()) {
+          fout << dumpVector[j].theoryX[i] << ", ";
+          fout << dumpVector[j].theory[i] << ", ";
+        } else {
+          fout << ", , ";
+        }
+      }
+      // write last theory entry
+      if (i<dumpVector[dumpVector.size()-1].theoryX.size()) {
+        fout << dumpVector[dumpVector.size()-1].theoryX[i] << ", ";
+        fout << dumpVector[dumpVector.size()-1].theory[i];
+      } else {
+        fout << ", ";
+      }
+      fout << endl;
+    }
+  }
+
   // close file
-  foutData.close();
-  foutTheo.close();
+  fout.close();
+
+  // clean up
+  for (UInt_t i=0; i<dumpVector.size(); i++) {
+    dumpVector[i].dataX.clear();
+    dumpVector[i].data.clear();
+    dumpVector[i].dataErr.clear();
+    dumpVector[i].theoryX.clear();
+    dumpVector[i].theory.clear();
+  }
+  dumpVector.clear();
 
   cout << endl << ">> Data windows saved in ascii format ..." << endl;
 }
diff --git a/src/include/PMusrCanvas.h b/src/include/PMusrCanvas.h
index 460d59ca..7e111a9e 100644
--- a/src/include/PMusrCanvas.h
+++ b/src/include/PMusrCanvas.h
@@ -138,6 +138,25 @@ typedef struct {
  */
 typedef vector<PMusrCanvasNonMusrDataSet> PMusrCanvasNonMusrDataList;
 
+//------------------------------------------------------------------------
+/**
+ * <p> data structure needed for ascii dump within musrview.
+ */
+typedef struct {
+  PDoubleVector dataX;
+  PDoubleVector data;
+  PDoubleVector dataErr;
+  PDoubleVector theoryX;
+  PDoubleVector theory;
+} PMusrCanvasAsciiDump;
+
+//------------------------------------------------------------------------
+/**
+ * <p> vectore of the above data structure. Used if there are multiple histogramms
+ * to be dumped.
+ */
+typedef vector<PMusrCanvasAsciiDump> PMusrCanvasAsciiDumpVector;
+
 //--------------------------------------------------------------------------
 /**
  * <p>The preprocessor tag __MAKECINT__ is used to hide away from rootcint