TRRFile.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_FORMAT_TRRFILE_H
#define BALL_FORMAT_TRRFILE_H

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

namespace BALL
{
  class BALL_EXPORT TRRFile
    : public TrajectoryFile
  {

    public:


    class BALL_EXPORT TRRHeader
    {
      public: 

      Size        MAGIC;
      Size        VERSION;
      Size        title_string_length;
      String      title_string;
      Size        ir_size;
      Size        e_size;

      Size        bounding_box_data_size;

      Size        vir_size;

      Size        pres_size;

      Size        top_size;

      Size        sym_size;

      Size        position_data_size;

      Size        velocity_data_size;

      Size        force_data_size;

      Size        number_of_atoms;

      Size        timestep_index;

      Size        nre;

      float       timestep_time;

      float       lambda;

      TRRHeader()
        : MAGIC(1993),
          VERSION(13),
          title_string_length(24),
          title_string("Created by BALL::TRRFile"),
          ir_size(0),
          e_size(0),
          vir_size(0),
          pres_size(0),
          top_size(0),
          sym_size(0),
          velocity_data_size(0),
          force_data_size(0),
          timestep_index(0),
          nre(0),
          timestep_time(0.002),
          lambda(0)
      {
      }
    };



    TRRFile();

    TRRFile(const String& name, File::OpenMode open_mode = std::ios::in);

    virtual ~TRRFile();


    virtual void clear();


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



    virtual bool init();

    virtual bool writeNextHeader(const TRRHeader& header);

    virtual bool readNextHeader(TRRHeader& header);
    
    virtual bool append(const SnapShot& snapshot);

    virtual bool read(SnapShot& snapshot);

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



    bool hasVelocities() const;

    void setVelocityStorage(bool storage);

    bool hasForces() const;

    void setForceStorage(bool storage);

    Size getPrecision() const;

    bool setPrecision(const Size precision);

    float getTimestep() const;

    void setTimestep(float timestep);

    Vector3 getBoundingBoxX() const;

    Vector3 getBoundingBoxY() const;

    Vector3 getBoundingBoxZ() const;

    void setBoundingBox(const Vector3& x, const Vector3& y, const Vector3& z);


    private:
      const TRRFile& operator = (const TRRFile& file);

    protected:

    // the current step's header
    TRRHeader header_;
    
    // the precision of the file in bytes per value
    Size precision_;
    
    // a flag deciding if the file contains velocities
    bool has_velocities_;

    // a flag deciding if the file contains forces
    bool has_forces_;

    // the index of the current timestep / snapshot
    Size timestep_index_;

    // the length of the timestep
    float timestep_;

    // three vectors containing the base vectors of the box in
    // nanometers
    Vector3 box1_, box2_, box3_;

    BinaryFileAdaptor<Size> adapt_size_;
    BinaryFileAdaptor<char> adapt_char_;
    BinaryFileAdaptor<float> adapt_float_;
    BinaryFileAdaptor<double> adapt_double_;
  };
} // namespace BALL

#endif // BALL_FORMAT_TRRFILE_H 

---