ABACUS/src/UTILS/Sort_RAW_File.cc

/**********************************************************

This software is part of J.-S. Caux's ABACUS library.

Copyright (c) J.-S. Caux.

-----------------------------------------------------------

File:  Sort_RAW_File.cc

Purpose:  orders the file in form factor or energy.

***********************************************************/

#include "ABACUS.h"

using namespace std;


namespace ABACUS {

  void Sort_RAW_File (const char ffsq_file[], char optionchar)
  {
    Sort_RAW_File (ffsq_file, optionchar, 'a'); // dummy whichDSF, doesn't matter
  }


  void Sort_RAW_File (const char ff_file[], char optionchar, char whichDSF)
  {
    // Sorts FF in decreasing order for 'f' option, or energies in increasing order for option 'e', and writes .dat_srt file

    if (!(optionchar == 'e' || optionchar == 'f')) ABACUSerror("Wrong option in Sort_FF");

    // Check size of threads file:
    struct stat statbuf;

    stat (ff_file, &statbuf);
    int filesize = statbuf.st_size;

    // Determine the number of entries approximately
    int entry_size = 2* sizeof(float) + 2*sizeof(int);

    //const int MAXDATA = 50000000;
    const int MAXDATA = filesize/entry_size + 10;

    DP* omega = new DP[MAXDATA];
    int* iK = new int[MAXDATA];
    DP* ff = new DP[MAXDATA];
    DP* ff_im = new DP[MAXDATA];
    DP* dev = new DP[MAXDATA];
    string* label = new string[MAXDATA];

    ifstream infile;
    infile.open(ff_file);

    if (infile.fail()) ABACUSerror("The input file was not opened successfully in Sort_RAW_File. ");

    stringstream outfilename;
    string outfilename_string;
    outfilename << ff_file << "_srt_" << optionchar;
    outfilename_string = outfilename.str();
    const char* outfilename_c_str = outfilename_string.c_str();

    ofstream outfile;
    outfile.open(outfilename_c_str);
    outfile.precision(16);

    int Ndata = 0;
    while (((infile.peek()) != EOF) && (Ndata < MAXDATA)) {

      infile >> omega[Ndata];
      infile >> iK[Ndata];
      if (whichDSF != 'Z') infile >> ff[Ndata];
      if (whichDSF == 'q') infile >> ff_im[Ndata];  // imaginary part of overlap, quench case
      infile >> dev[Ndata];
      infile >> label[Ndata];

      Ndata++;
    }
    infile.close();

    int* index = new int[Ndata];
    DP* ffsq = new DP[Ndata];

    for (int i = 0; i < Ndata; ++i) index[i] = i;
    for (int i = 0; i < Ndata; ++i) ffsq[i] = ff[i] * ff[i];

    if (optionchar == 'f') QuickSort(ffsq, index, 0, Ndata - 1);
    else if (optionchar == 'e') QuickSort(omega, index, 0, Ndata - 1);

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

      if (i > 0) outfile << endl;
      if (optionchar == 'f') {

	outfile << omega[index[Ndata - 1 - i] ] << "\t" << iK[index[Ndata - 1 - i] ];
	if (whichDSF != 'Z') outfile << "\t" << ff[index[Ndata - 1 - i] ];
	if (whichDSF == 'q') outfile << "\t" << ff_im[index[Ndata - 1 - i] ];
	outfile << "\t" << dev[index[Ndata - 1 - i] ] << "\t" << label[index[Ndata - 1 - i] ];
      }
      else if (optionchar == 'e') {
	outfile << omega[i] << "\t" << iK[index[i] ];
	if (whichDSF != 'Z') outfile << "\t" << ff[index[i] ];
	if (whichDSF == 'q') outfile << "\t" << ff_im[index[i] ];
	outfile << "\t" << dev[index[i] ] << "\t" << label[index[i] ];
      }
    }

    outfile.close();

    delete[] omega;
    delete[] iK;
    delete[] ff;
    delete[] ff_im;
    delete[] dev;
    delete[] label;

    delete[] index;
    delete[] ffsq;

    return;
  }

} // namespace ABACUS