delphin5_output.h

Go to the documentation of this file.

// Delphin 5 Output Library - for reading, writing and exporting of 
//                            Delphin 5 output data
//
// Copyright (C) 2005, 2006, 2009 
//               Andreas Nicolai <andreas.nicolai@tu-dresden.de>
//               http://www.bauklimatik-dresden.de
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

#ifndef delphin5_outputH
#define delphin5_outputH

#include <string>
#include <vector>
#include <utility>
#include <iosfwd>
#include <cstdio>

#include "delphin_output_lib_types.h"

namespace DELPHIN {

class Delphin5OutputData {
  public:
    enum type_t {
        T_FIELD_OUTPUT,
        T_FLUX_OUTPUT,
        NUM_T
    };
    
    enum spaceType_t {
        ST_SINGLE,
        ST_MEAN,
        ST_INTEGRAL,
        NUM_ST
    };
  
    enum timeType_t {
        TT_NONE,
        TT_MEAN,
        TT_INTEGRAL,
        NUM_TT
    };

    enum dataFormat_t {
        DF_2D,
        DF_3D,
        DF_4D,
        DF_4D_FLUX,
        NUM_DF
    };

    Delphin5OutputData() { clear(); }
    void clear();

    bool read(const std::string& fname, bool header_only, std::string& errmsg,
        bool generate_postproc_info=true, ReadNotification * notify = NULL);

    bool writeHeader(std::ostream& out, bool write_geometry, std::string& errmsg) const;

    bool write(std::ostream& out, std::string& errmsg);

    bool generatePostprocInfo(std::string& errmsg);

    std::vector<LineData> & constructionLines();

    std::vector<LineData> & boundaryLines();

    // *** Member variables ***

    std::string                         m_filename;

    // Header data

    type_t                              m_type;             
    std::string                         m_projectFile;      
    std::string                         m_quantity;         
    spaceType_t                         m_spaceType;        
    timeType_t                          m_timeType;         
    std::string                         m_valueUnit;        
    std::string                         m_timeUnit;         
    bool                                m_isBinary;         

    // Pre-Data tables

    std::vector<MaterialDef>            m_matDefs;      
    Grid                                m_grid;         
    std::vector<ElementGeometry>        m_elementsVec;  
    std::vector<SidesGeometry>          m_sidesVec;     
    
    // The actual data

    std::vector<int>                    m_nums;         

    std::vector<double>                 m_timepoints;   
    std::vector< std::vector<double> >  m_values;       


    // Generated data to be used in post-processing applications

    dataFormat_t                        m_dataFormat;

    std::vector< std::vector<int> >     m_elementMapping;

    std::vector< std::vector<int> >     m_valueMapping;

    rectangle<unsigned int>             m_gridLocation;

    rectangle<double>                   m_coordinateLimits;


private:
    bool readData(std::istream& in, std::string& errmsg, ReadNotification * notify);

    bool readHeader(std::istream& in,
        std::string& errmsg, bool generate_postproc_info, ReadNotification * notify);

    bool readBinaryHeader(std::istream& in,
        std::string& errmsg, bool generate_postproc_info, ReadNotification * notify);
    
    bool parseHeader(std::istream& in, std::string& geometry_data, std::string& errmsg, ReadNotification * notify);
    bool parseHeader(std::FILE * in, char* geometry_data, size_t size, ReadNotification * notify);
    bool parseGeometryData(std::istream& in, std::string& errmsg, ReadNotification * notify);
    bool parseGeometryData(const char * geodata, std::string& errmsg, ReadNotification * notify);
    void writeGeometryData(std::ostream& out) const;
    bool readBinaryGeometryData(std::istream& in, std::string& errmsg, ReadNotification * notify);
    void writeBinaryGeometryData(std::ostream& out) const;

    void generateConstructionLines();

    std::vector<LineData>       m_constructionLines;    
    std::vector<LineData>       m_boundaryLines;        

    std::size_t                 m_fileSize;             
    std::string                 m_binaryFileVersion;    
};

std::ostream& operator<<(std::ostream& out, Delphin5OutputData::type_t t);
void string2type(const std::string& str, Delphin5OutputData::type_t & t);

std::ostream& operator<<(std::ostream& out, Delphin5OutputData::spaceType_t t);
void string2spaceType(const std::string& str, Delphin5OutputData::spaceType_t & t);

std::ostream& operator<<(std::ostream& out, Delphin5OutputData::timeType_t t);
void string2timeType(const std::string& str, Delphin5OutputData::timeType_t & t);

} // namespace DELPHIN


#endif // delphin5_output_h

---