mtz_unmerge_io.hh

// mtz_unmerge_io.hh
// Phil Evans August 2003
//
// MTZ io for  Unmerged files
//
// Written for Pointless


#ifndef MTZ_IO_HEAD
#define MTZ_IO_HEAD

#include <string>
#include <map>

// Clipper
#include "clipper/clipper.h"
#include "clipper/clipper-ccp4.h"
using clipper::Message;
using clipper::Message_fatal;


// CCP4
#include "csymlib.h"    // CCP4 symmetry stuff
#include "ccp4_parser.h"
#include "ccp4_general.h"
#include "cmtzlib.h"    // CCP4 MTZlib headers (namespace CMtz)

#include "hkl_datatypes.hh"
#include "controls.hh"
#include "columnlabels.hh"
#include "hkl_unmerge.hh"
#include "range.hh"
#include "hash.hh"


using namespace scala;

namespace scala{class FileRead;}

namespace MtzIO {  
  //--------------------------------------------------------------
  class MtzUnmrgFile
    {
    public:
      MtzUnmrgFile();
      ~MtzUnmrgFile();
      
      bool open_read( const std::string filename_in );
      void close_read();

      // NB this code does not deal with writing files!
      
      FileRead FillHklList(const std::string& mtzname,
                           std::string& output,
                           const int& verbose,
                           hkl_unmerge_list& hkl_list);


      FileRead AddHklList(const int& fileSeries,
                          const std::string& mtzname,
                          file_select& file_sel, 
                          col_controls& column_selection,
                          MtzIO::column_labels& column_list,
                          const all_controls& controls,
                          const scala::PxdName& InputPxdName,
                          const scala::Scell& cell,
                          const double& cellTolerance,
                          std::string& output,
                          const int& verbose,
                          hkl_unmerge_list& hkl_list);
      
      int Nrec() const {return Nrecl_file;}
      int Ncols() const {return Ncolumns;}
      bool Sorted() const {return sorted;}
      bool Merged() const {return merged;}
      scala::SpaceGroup Spacegroup() const {return spacegroup_;}
      std::vector<Batch> BatchList();
      scala::Scell Cell() const {return averagecell;}

      CMtz::MTZ* mtz_file() const {return mtzin;}
      ResoRange ResRangeFile() const
      {return ResoRange(Range(minres, maxres));}
      ResoRange ResRange() const {return resrange;}

      void Rewind();
      bool Rrefl(std::vector<float>& cols, std::vector<bool>& col_mnf);

      bool get_dataset(const int& kdataset, Xdataset& this_dataset) const;
      bool get_batch(const int& kbatch,  CMtz::MTZBAT& this_batch) const;
      std::string get_title() const {return title;}
      std::string FilenameIn() const {return filename_in_;}
      column_select ColumnSelect() const {return col_select;}

      column_labels ColumnLabels()const {return column_list;}

    private:
      enum MTZmode { NONE, READ, WRITE, APPEND };
      CMtz::MTZ* mtzin;
      MTZmode mode;
      std::string filename_in_, filename_out_;
      scala::SpaceGroup spacegroup_;
      CMtz::SYMGRP mtzsym;  // symmetry from MTZ file
      std::string title;

      std::vector<Xdataset> xdatasets;  // list of crystal/datasets in file
      std::vector<CMtz::MTZBAT*> mtzbatches;       // list of batches in file

      std::vector<Xdataset> datasets;  // Selected list
      std::vector<Batch> batches;      // List of batches with acceptances
      std::vector<Run> runs;
      std::vector<int> offsets;        // batch offsets for each run

      Scell averagecell;
      bool sorted;
      bool merged;

      int IrefCnt;
      int Ncolumns;

      int Nrecl_file;
      float minres, maxres;  // Resolution range in file
      ResoRange resrange;    // Resolution range accepted
      int Nrej_batch;  // Number of observation parts rejected by batch

      column_select col_select; // column selection flags
      MtzIO::column_labels column_list; // column list

      // Private member functions
      int read_datasets(const CMtz::MTZ* mtzin,
                         std::vector<Xdataset>& Xdatasets);
      bool read_batches(const CMtz::MTZ* mtzin, 
                        std::vector<CMtz::MTZBAT*>& mtzbatches);

      Scell get_dset_batch_info(const int& fileSeries,
                                const file_select& file_sel,
                                const scala::PxdName& InputPxdName,
                                const scala::Scell& cell,
                                const column_select& col_sel,
                                bool& DifferentCell);

      int get_refs(hkl_unmerge_list& hkl_list,
                   file_select& file_sel, 
                   const column_select& col_sel,
                   const Scell& averagecell,
                   bool& ChangeIndex);

      bool IsCompatible(const hkl_unmerge_list& hkl_list,
                        const double& cellTolerance) const;
        
      // Make a list of runs from batches (for rebatching)
      void MakeRuns();

      // Return true if file is sorted and the index was not changed
      bool FileSorted() const;

      void OffsetBatches();

      // Get file column numbers for labels in column list
      // On exit:
      //   ColumnLabels  contains actual column numbers for labels found
      // Fails if compulsory column not found
      void get_col_lookup(column_labels& ColumnLabels);


  }; //   class MtzUnmrgFile;



}

#endif

---