delphin_output_lib_types.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 delphin_output_lib_types_h
#define delphin_output_lib_types_h

#include <string>
#include <vector>
#include <utility>

namespace DELPHIN {

class ReadNotification {
  public:
    ReadNotification() : abort(false) {}
    virtual ~ReadNotification() {}
    virtual void notify() = 0;
    virtual void notify(int) { notify(); }
    virtual void notify(const char *) { notify(); }
    virtual void notify(double) { notify(); }

    bool abort; // if true, stop whatever you are doing.
};
// ----------------------------------------------------------------------------

class MaterialDef {
  public:
    MaterialDef() {};
    MaterialDef(unsigned int n, unsigned int c, const std::string& nam) :
        nr(n), color(c), name(nam) {}
    unsigned int    nr;     
    unsigned int    color;  
    std::string     name;   
};

inline bool operator==(const MaterialDef& lhs, const MaterialDef& rhs) {
    return lhs.nr == rhs.nr && lhs.name == rhs.name && lhs.color == rhs.color;
}
// ----------------------------------------------------------------------------


class Grid {
  public:
    Grid() { clear(); }
    void clear();

    std::vector<double>     xwidths;            
    std::vector<double>     ywidths;            
    std::vector<double>     zwidths;            
    std::vector<double>     x_coords;           
    std::vector<double>     y_coords;           
    std::vector<double>     x_gridCoords;       
    std::vector<double>     y_gridCoords;       
    int                     constructionType;   
};
// ----------------------------------------------------------------------------

class ElementGeometry {
  public:
    unsigned int    n;      
    double          x;      
    double          y;      
    unsigned int    i;      
    unsigned int    j;      
    unsigned int    matnr;  
};

inline bool operator==(const ElementGeometry& lhs, const std::pair<unsigned int, unsigned int>& rhs) {
    return (lhs.i == rhs.first && lhs.j == rhs.second);
}
inline bool operator!=(const ElementGeometry& lhs, const std::pair<unsigned int, unsigned int>& rhs) {
    return !(lhs == rhs);
}
// ----------------------------------------------------------------------------


class SidesGeometry {
  public:
    unsigned int    n;      
    double          x;      
    double          y;      
    unsigned int    i;      
    unsigned int    j;      
    bool            vertical;   
};
// ----------------------------------------------------------------------------

struct SideIdentification {
    SideIdentification(unsigned int i, unsigned int j, bool vertical) : m_i(i), m_j(j), m_vertical(vertical) {}
    unsigned int m_i, m_j;
    bool m_vertical;
};
// ----------------------------------------------------------------------------

inline bool operator==(const SidesGeometry& lhs, const SideIdentification& rhs) {
    return (lhs.i == rhs.m_i &&
            lhs.j == rhs.m_j &&
            lhs.vertical == rhs.m_vertical);
}
inline bool operator!=(const SidesGeometry& lhs, const SideIdentification& rhs) {
    return !(lhs == rhs);
}
// ----------------------------------------------------------------------------


template <class T>
class rectangle {
  public:
    rectangle() : left(T()), top(T()), right(T()), bottom(T()) {};
    rectangle(T l, T t, T r, T b) : left(l), top(t), right(r), bottom(b) {};
    void set(T l, T t, T r, T b) { left=l; top=t; right=r; bottom=b; };

    T width()   const   { return right - left; };
    T height()  const   { return bottom - top; };

    T left;     
    T top;      
    T right;    
    T bottom;   
};
// ----------------------------------------------------------------------------

struct ElementData : public rectangle<int> {
    ElementData() : rectangle(-1,-1,-1,-1), x(-1), y(-1) {}
    double x, y;    // coordinates of element
};
// ----------------------------------------------------------------------------

struct LineData {
    double x1, y1;
    double x2, y2;
};
// ----------------------------------------------------------------------------

struct QuadElementData {
    int n1, n2, n3, n4;
};
// ----------------------------------------------------------------------------

} // namespace DELPHIN


#endif // delphin_output_lib_types_h

---