• Main Page
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

/export/development/ViennaGrid/release/ViennaGrid-1.0.0/viennagrid/io/data_accessor.hpp

Go to the documentation of this file.
00001 #ifndef VIENNAGRID_IO_DATA_ACCESSOR_HPP
00002 #define VIENNAGRID_IO_DATA_ACCESSOR_HPP
00003 
00004 /* =======================================================================
00005    Copyright (c) 2011, Institute for Microelectronics,
00006                        Institute for Analysis and Scientific Computing,
00007                        TU Wien.
00008 
00009                             -----------------
00010                      ViennaGrid - The Vienna Grid Library
00011                             -----------------
00012 
00013    Authors:      Karl Rupp                           rupp@iue.tuwien.ac.at
00014                  Josef Weinbub                    weinbub@iue.tuwien.ac.at
00015                
00016    (A list of additional contributors can be found in the PDF manual)
00017 
00018    License:      MIT (X11), see file LICENSE in the base directory
00019 ======================================================================= */
00020 
00021 
00022 #include <fstream>
00023 #include <sstream>
00024 #include <iostream>
00025 #include "viennagrid/domain.hpp"
00026 #include "viennagrid/forwards.h"
00027 #include "viennagrid/iterators.hpp"
00028 #include "viennagrid/io/helper.hpp"
00029 #include "viennagrid/io/vtk_common.hpp"
00030 #include "viennagrid/traits/container.hpp"
00031 //#include "viennagrid/algorithm/cell_normals.hpp"
00032 #include "viennadata/api.hpp"
00033 
00038 namespace viennagrid
00039 {
00040   namespace io
00041   {
00042     
00047     template <typename ElementType>
00048     class data_accessor_interface
00049     {
00050       public: 
00051         virtual std::string operator()(ElementType const & element, std::size_t segment_id) const = 0;
00052         virtual void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const = 0;
00053         
00054         //virtual bool active_on_segment(size_t i) const { return true; }
00055         
00056         virtual data_accessor_interface<ElementType> * clone() const = 0;
00057         
00058         virtual ~data_accessor_interface() {};
00059     };
00060 
00061     
00062     
00069     template <typename ElementType, typename KeyType, typename DataType>
00070     class global_scalar_data_accessor : public data_accessor_interface<ElementType>
00071     {
00072       typedef global_scalar_data_accessor<ElementType, KeyType, DataType>    self_type;
00073       
00074       public:
00075         global_scalar_data_accessor(KeyType const & k) : key_(k) {}
00076         //vtk_data_accessor_global() {}
00077 
00078         std::string operator()(ElementType const & element, std::size_t segment_id) const
00079         {
00080           std::stringstream ss;
00081           ss << viennadata::access<KeyType, DataType>(key_)(element);
00082           return ss.str();
00083         }
00084         
00085         void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00086         {
00087           viennadata::access<KeyType, DataType>(key_)(element) = static_cast<DataType>(value);
00088         }
00089         
00090         data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00091         
00092       private:
00093         KeyType key_;
00094     };
00095 
00102     template <typename ElementType, typename KeyType, typename DataType>
00103     class global_vector_data_accessor : public data_accessor_interface<ElementType>
00104     {
00105       typedef global_vector_data_accessor<ElementType, KeyType, DataType>    self_type;
00106       
00107       public:
00108         global_vector_data_accessor(KeyType const & k) : key_(k) {}
00109         //vtk_data_accessor_global() {}
00110 
00111         std::string operator()(ElementType const & element, std::size_t segment_id) const
00112         {
00113           std::stringstream ss;
00114           viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element), 3);
00115           ss << viennadata::access<KeyType, DataType>(key_)(element)[0] << " ";
00116           if (viennagrid::traits::size(viennadata::access<KeyType, DataType>(key_)(element)) > 1)
00117             ss << viennadata::access<KeyType, DataType>(key_)(element)[1] << " ";
00118           else
00119             ss << "0 ";
00120           if (viennagrid::traits::size(viennadata::access<KeyType, DataType>(key_)(element)) > 2)
00121             ss << viennadata::access<KeyType, DataType>(key_)(element)[2] << " ";
00122           else
00123             ss << "0 ";
00124           return ss.str();
00125         }
00126         
00127         void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00128         {
00129           viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element), 3);
00130           viennadata::access<KeyType, DataType>(key_)(element)[k] = value;
00131         }
00132         
00133         data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00134         
00135       private:
00136         KeyType key_;
00137     };
00138 
00139     
00146     template <typename ElementType, typename KeyType, typename DataType>
00147     class segment_scalar_data_accessor : public data_accessor_interface<ElementType>
00148     {
00149       typedef segment_scalar_data_accessor<ElementType, KeyType, DataType>    self_type;
00150       
00151       public:
00152         segment_scalar_data_accessor(KeyType const & k) : key_(k) {}
00153         //vtk_data_accessor_global() {}
00154 
00155         std::string operator()(ElementType const & element, std::size_t segment_id) const
00156         {
00157           std::stringstream ss;
00158           ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id];
00159           return ss.str();
00160         }
00161 
00162         void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00163         {
00164           viennadata::access<KeyType, DataType>(key_)(element)[segment_id] = value;
00165         }
00166 
00167         data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00168         
00169       private:
00170         KeyType key_;
00171     };
00172 
00179     template <typename ElementType, typename KeyType, typename DataType>
00180     class segment_vector_data_accessor : public data_accessor_interface<ElementType>
00181     {
00182       typedef segment_vector_data_accessor<ElementType, KeyType, DataType>    self_type;
00183       
00184       public:
00185         segment_vector_data_accessor(KeyType const & k) : key_(k) {}
00186         //vtk_data_accessor_global() {}
00187 
00188         std::string operator()(ElementType const & element, std::size_t segment_id) const
00189         {
00190           std::stringstream ss;
00191           viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element)[segment_id], 3);
00192           //ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id];
00193           ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][0] << " ";
00194           ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][1] << " ";
00195           ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][2];
00196           return ss.str();
00197         }
00198 
00199         void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00200         {
00201           viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element)[segment_id], 3);
00202           viennadata::access<KeyType, DataType>(key_)(element)[segment_id][k] = value;
00203         }
00204 
00205         data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00206         
00207       private:
00208         KeyType key_;
00209     };
00210     
00215     template <typename ElementType>
00216     class data_accessor_wrapper
00217     {
00218       public:
00219         template <typename T>
00220         data_accessor_wrapper(T const * t) : functor_(t) {}
00221         
00222         data_accessor_wrapper() {}
00223 
00224         data_accessor_wrapper(const data_accessor_wrapper & other) : functor_(other.clone()) {}
00225 
00226         data_accessor_wrapper & operator=(data_accessor_wrapper const & other)
00227         {
00228           functor_ = std::auto_ptr< const data_accessor_interface<ElementType> >(other.clone());
00229           return *this;
00230         }
00231         
00232         std::string operator()(ElementType const & element, std::size_t segment_id = 0) const
00233         {   
00234           return functor_->operator()(element, segment_id); 
00235         }
00236 
00237         void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00238         {   
00239           functor_->operator()(element, segment_id, k, value);
00240         }
00241 
00242         data_accessor_interface<ElementType> * clone() const { return functor_->clone(); }
00243 
00244       private:
00245         std::auto_ptr< const data_accessor_interface<ElementType> > functor_;
00246     };
00247 
00248   } //namespace io
00249 } //namespace viennagrid
00250 
00251 #endif

Generated on Wed Sep 14 2011 19:21:30 for ViennaGrid by  doxygen 1.7.1