field_mesh_step.hh

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 *
 * This program 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 General Public License for more details.
 *
 *
 * @file    field_mesh_step.hh
 * @brief
 */
 
#ifndef FIELD_MESH_STEP_HH_
#define FIELD_MESH_STEP_HH_
 
#include "fields/field_common.hh"                      // for FieldCommon::T...
#include "fields/field_value_cache.hh"                 // for FieldValueCache
#include "mesh/mesh.h"
 
template <int spacedim> class ElementAccessor;
 
namespace IT=Input::Type;
 
 
/**
 * Specialized field represents mesh step ('h') of FieldFormula.
 */
class FieldMeshStep : public FieldCommon {
public:
    /// Constructor
    FieldMeshStep()
      : value_cache_( FieldValueCache<double>(1, 1) )
    {
        this->multifield_ = false;
        unsigned int cache_size = CacheMapElementNumber::get();
        value_cache_.reinit(cache_size);
        value_cache_.resize(cache_size);
        this->set_shape(1, 1);
    }
 
    IT::Instance get_input_type() override {
        ASSERT_PERMANENT(false).error("This method can't be used for FieldMeshStep");
 
        IT::Abstract abstract = IT::Abstract();
        IT::Instance inst = IT::Instance( abstract, std::vector<IT::TypeBase::ParameterPair>() );
        return inst;
    }
 
    IT::Array get_multifield_input_type() override {
        ASSERT_PERMANENT(false).error("This method can't be used for FieldMeshStep");
 
        IT::Array arr = IT::Array( IT::Integer() );
        return arr;
    }
 
    void set_mesh(const Mesh &mesh) override {
        shared_->mesh_ = &mesh;
    }
 
    bool is_constant(FMT_UNUSED Region reg) override {
        return false;
    }
 
    bool set_time(FMT_UNUSED const TimeStep &time, FMT_UNUSED LimitSide limit_side) override {
        return false;
    }
 
    void copy_from(FMT_UNUSED const FieldCommon & other) override {
        ASSERT_PERMANENT(false).error("Forbidden method for FieldMeshStep!");
    }
 
    void field_output(FMT_UNUSED std::shared_ptr<OutputTime> stream, FMT_UNUSED OutputTime::DiscreteSpace type) override {
        ASSERT_PERMANENT(false).error("Forbidden method for FieldMeshStep!");
    }
 
    FieldResult field_result(FMT_UNUSED RegionSet region_set) const override {
        return result_none;
    }
 
    std::string get_value_attribute() const override {
        double limit = std::numeric_limits<double>::max();
        return fmt::format("{{ \"shape\": [ 1, 1 ], \"type\": \"Double\", \"limit\": [ {}, {} ] }}", -limit, +limit);
    }
 
    void set_input_list(FMT_UNUSED const Input::Array &list, FMT_UNUSED const TimeGovernor &tg) override
    {}
 
    /// Implements FieldCommon::cache_allocate
    void cache_reallocate(FMT_UNUSED const ElementCacheMap &cache_map, FMT_UNUSED unsigned int region_idx) const override
    {}
 
    /// Implements FieldCommon::cache_update
    void cache_update(ElementCacheMap &cache_map, unsigned int region_patch_idx) const override {
        const std::vector<double> meassure_dim_coef = {1, 1, 2, 6};
        unsigned int reg_chunk_begin = cache_map.region_chunk_begin(region_patch_idx);
        unsigned int reg_chunk_end = cache_map.region_chunk_end(region_patch_idx);
        unsigned int region_idx = cache_map.eval_point_data(reg_chunk_begin).i_reg_;
        unsigned int last_element_idx = -1;
        ElementAccessor<3> elm;
        double h_val = 0.0;
 
        const MeshBase *mesh; // Holds bulk or boundary mesh by region_idx
        if (region_idx%2 == 1) mesh = shared_->mesh_;
        else mesh = shared_->mesh_->bc_mesh();
 
        for (unsigned int i_data = reg_chunk_begin; i_data < reg_chunk_end; ++i_data) { // i_eval_point_data
            unsigned int elm_idx = cache_map.eval_point_data(i_data).i_element_;
            if (elm_idx != last_element_idx) {
                elm = mesh->element_accessor( elm_idx );
                double exp = 1.0 / elm.dim();
                h_val = pow( (elm.measure() * meassure_dim_coef[elm.dim()]), exp );
                last_element_idx = elm_idx;
            }
            value_cache_.set(i_data) = h_val;
        }
    }
 
    /// Implements FieldCommon::value_cache
    FieldValueCache<double> * value_cache() override {
        return &value_cache_;
    }
 
    /// Implements FieldCommon::value_cache
    const FieldValueCache<double> * value_cache() const override {
        return &value_cache_;
    }
 
    /// Implements FieldCommon::set_dependency().
    std::vector<const FieldCommon *> set_dependency(FMT_UNUSED unsigned int i_reg) const override {
        return std::vector<const FieldCommon *>();
    }
 
private:
    /**
     * Field value data cache
     *
     * See implementation of Field<spacedim, Value>::value_cache_
     */
    mutable FieldValueCache<double> value_cache_;
};
 
#endif /* FIELD_MESH_STEP_HH_ */