DCDFile.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: DCDFile.h,v 1.33.18.1 2007/03/25 21:23:41 oliver Exp $
//

#ifndef BALL_FORMAT_DCDFILE_H
#define BALL_FORMAT_DCDFILE_H

#ifndef BALL_FORMAT_TRAJECTORYFILE_H
# include <BALL/FORMAT/trajectoryFile.h>
#endif

namespace BALL
{
  class BALL_EXPORT DCDFile
    : public TrajectoryFile
  {

    public:

    BALL_CREATE(DCDFile)

    

    DCDFile()
      ;

    DCDFile(const DCDFile& file)
      throw(Exception::FileNotFound);

    DCDFile(const String& name, File::OpenMode open_mode = std::ios::in)
      throw(Exception::FileNotFound);

    virtual ~DCDFile()
      ;



    const DCDFile& operator = (const DCDFile& file)
      ;

    virtual void clear()
      ;



    bool operator == (const DCDFile& file) const
      ;

    bool isSwappingBytes() const
      ;

    bool hasVelocities() const
      ;




    virtual bool open(const String& name, File::OpenMode open_mode = std::ios::in)
      throw(Exception::FileNotFound);

    bool init()
      ;

    virtual bool readHeader()
      ;

    virtual bool writeHeader()
      ;

    virtual bool seekAndWriteHeader()
      ;

    // ?????:
    // should append() also write the header? what is more intuitive?
    virtual bool append(const SnapShot& snapshot)
      ;

    virtual bool read(SnapShot& snapshot)
      ;

    virtual bool flushToDisk(const std::vector<SnapShot>& buffer)
      throw(File::CannotWrite);



    void enableVelocityStorage()
      ;

    void disableVelocityStorage()
      ;


    protected:

    //_ 
    void writeSize_(const Size& data)
       { *this << BinaryFileAdaptor<Size>(data);}

    //_ 
    void writeFloat_(const float& data)
       { *this << BinaryFileAdaptor<float>(data);}

    //_
    void writeVector_(const vector<Vector3>& v)
      ;
    
    //_
    float readFloat_()
      ; 

    //_
    Size readSize_()
      ;

    //_
    bool readSize_(Size expected_size, const String& what)
      ;

    //_
    bool readVector_(vector<Vector3>& v)
      ;

    //_
    Size verbosity_;

    // a flag indicating that we have to swap bytes when reading data
    bool swap_bytes_;

    // a floag indicating that this DCD file contains atom velocities
    bool has_velocities_;

    //_
    bool charmm_extra_block_A_;

    //_
    bool charmm_extra_block_B_;

    //_
    String CORD_;

    //_
    Size step_number_of_starting_time_;

    //_
    Size steps_between_saves_;

    //_
    double time_step_length_;

    //_
    Size number_of_comments_;

    /*_ We had a problem with read(Snapshot), as it
        still returned true at the end of file. No idea
        why the stream was still good! To fix this,
        I added this member to count the current read snapshot.
    */
    Position current_snapshot_;

    BinaryFileAdaptor<Size>  adapt_size_;
    BinaryFileAdaptor<float> adapt_float_;
  };
} // namespace BALL

#endif // BALL_FORMAT_DCDFILE_H