b2material_property.H

//------------------------------------------------------------------------
// b2material_property.H --
//
//
// written by Mathias Doreille and Thomas Ludwig
//
// Copyright (c) 2004-2015 SMR Engineering & Development SA
//                         2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef _B2_MATERIAL_PROPERTY_H_
#define _B2_MATERIAL_PROPERTY_H_
 
#include <vector>
 
#include "b2failure_criterion.H"
#include "utils/b2allocator.H"
#include "utils/b2object.H"
#include "utils/b2rtable.H"
 
namespace b2000 { namespace b2dbv3 {
 
class MaterialProperty : public b2000::Object {
public:
    MaterialProperty() : failure_criterion(nullptr) {}
 
    void init(const RTable& rtable_, Allocator& allocator) {
        rtable = rtable_;
 
        // Instantiate the failure criterion (if defined).
        failure_criterion = nullptr;
        const std::string failure_type = rtable.get_string("FAILURE__TYPE", "");
        if (failure_type != "") {
            FailureCriterion::type_t* t = nullptr;
            try {
                t = FailureCriterion::type.get_subtype(failure_type, failure_criterion::module);
            } catch (KeyError& e) {
                KeyError() << "The failure criterion \"" << failure_type << "\" is invalid."
                           << THROW;
            }
            assert(t != nullptr);
            failure_criterion = t->new_object(allocator);
            failure_criterion->init(rtable);
        }
    }
 
    virtual int number_of_layer() const { return 1; }
 
    virtual const RTable& get_rtable(int layer_id = 0) const { return rtable; }
 
    virtual const FailureCriterion* get_failure_criterion(int layer_id = 0) const {
        return failure_criterion;
    }
 
    const std::string& get_object_name() const override { return object_name; }
 
    void set_object_name(const std::string& name) { object_name = name; };
 
    typedef ObjectTypeComplete<MaterialProperty> type_t;
    static type_t type;
 
protected:
    RTable rtable;
    FailureCriterion* failure_criterion;
 
private:
    std::string object_name;
};
 
class LaminateProperty : public MaterialProperty {
public:
    struct Layer {
        b2000::csda<double> thickness;
        b2000::csda<double> angle;
        int plygroup;
        MaterialProperty* material;
 
        Layer(const b2000::csda<double> thickness_, const b2000::csda<double> angle_,
              const int plygroup_, MaterialProperty* material_)
            : thickness(thickness_), angle(angle_), plygroup(plygroup_), material(material_) {}
    };
 
    typedef std::vector<Layer> Layers;
 
    void append_layer(
          const b2000::csda<double> thickness_, const b2000::csda<double> angle_,
          const int plygroup_, MaterialProperty* material_) {
        layers.push_back(Layer(thickness_, angle_, plygroup_, material_));
    }
 
    const Layer& operator[](const int layer_id) const {
        assert(layer_id >= 0 && size_t(layer_id) < layers.size());
        return layers[layer_id];
    }
 
    Layer& operator[](const int layer_id) {
        assert(layer_id >= 0 && size_t(layer_id) < layers.size());
        return layers[layer_id];
    }
 
    int number_of_layer() const override { return layers.size(); }
 
    const RTable& get_rtable(int layer_id = 0) const override {
        assert(layer_id >= 0 && size_t(layer_id) < layers.size());
        return layers[layer_id].material->get_rtable();
    }
 
    const FailureCriterion* get_failure_criterion(int layer_id = 0) const override {
        assert(layer_id >= 0 && size_t(layer_id) < layers.size());
        return layers[layer_id].material->get_failure_criterion();
    }
 
    typedef ObjectTypeComplete<LaminateProperty, MaterialProperty::type_t> type_t;
    static type_t type;
 
private:
    Layers layers;
};
 
}}  // namespace b2000::b2dbv3
 
#endif /* _B2_MATERIAL_PROPERTY_H_ */