electrode.h

/******************************************************************************
 *   Copyright (C) 2006-2024 by the resistivity.net development team          *
 *   Carsten R�cker carsten@resistivity.net                                   *
 *                                                                            *
 *   Licensed under the Apache License, Version 2.0 (the "License");          *
 *   you may not use this file except in compliance with the License.         *
 *   You may obtain a copy of the License at                                  *
 *                                                                            *
 *       http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                            *
 *   Unless required by applicable law or agreed to in writing, software      *
 *   distributed under the License is distributed on an "AS IS" BASIS,        *
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *   See the License for the specific language governing permissions and      *
 *   limitations under the License.                                           *
 *                                                                            *
 ******************************************************************************/
 
#ifndef _BERT_ELECTRODE__H
#define _BERT_ELECTRODE__H
 
#include "bert.h"
 
#include <baseentity.h>
#include <pos.h>
 
namespace GIMLI{
 
// class Electrode -> ElectrodeNode -> ElectrodeRVector3 -> ElectrodeBoundary -> ElectrodeDomain

class DLLEXPORT Electrode : public GIMLI::BaseEntity{
public:
    Electrode();
 
    Electrode(const RVector3 & pos, int id = -1);
 
    Electrode(double x, double y, double z);
 
    virtual ~Electrode();
 
    Electrode(const Electrode & el);
 
    Electrode & operator = (const Electrode & el);
 
    bool operator == (const Electrode & e) const { return pos_ == e.pos(); }
 
    inline void setPos(const RVector3 & pos){ pos_ = pos; }
 
    inline const RVector3 & pos() const { return pos_; }
 
protected:
    RVector3 pos_;
};

class DLLEXPORT ElectrodeShape : public Electrode{
public:
    ElectrodeShape();
 
    ElectrodeShape(const RVector3 & pos);
 
    virtual ~ElectrodeShape();
 
    virtual std::vector < MeshEntity * > entities() const {
        THROW_TO_IMPL; return std::vector < MeshEntity * >();
    }
 
    virtual double domainSize() const { return size_; }
 
    //virtual double minRadius() const { return minRadius_; }

    virtual double geomMeanCellAttributes() const { THROW_TO_IMPL; return 0.0; }

    virtual double pot(const RVector & sol) const { THROW_TO_IMPL; return 0.0; }

    virtual void assembleRHS(RVector & rhs, double value, uint matrixSize) const {
        THROW_TO_IMPL; return;
    }

    virtual void setSingValue(RVector & sol, double scale, double k) const {
 
    };

    void setMID(uint id){ mID_ = id; }

    virtual int mID() const { return mID_; }
 
protected:

    double size_;
    //double minRadius_;
    int mID_;
};

class DLLEXPORT ElectrodeShapeNode : public ElectrodeShape{
public:
    ElectrodeShapeNode(Node & node);
 
    virtual ~ElectrodeShapeNode();
 
    void setNode(Node & node);
 
    inline const Node * node() const { return node_; }
 
    virtual std::vector < MeshEntity * > entities() const {
        std::vector < MeshEntity * > ents;
        ents.push_back(entity_);
        return ents;
    }
 
    virtual double geomMeanCellAttributes() const;

    virtual double pot(const RVector & sol) const;
 
    virtual void assembleRHS(RVector & rhs, double value, uint matrixSize) const;
 
    virtual void setSingValue(RVector & sol, double scale = 1.0, double k = 0.0) const;
 
protected:
    Node * node_;
    MeshEntity * entity_;
};
 

class DLLEXPORT ElectrodeShapeNodesWithBypass : public ElectrodeShapeNode {
public:
    ElectrodeShapeNodesWithBypass(std::vector < Node * > & nodes);
 
    virtual ~ElectrodeShapeNodesWithBypass();
 
protected:
    std::vector < Node * > nodes_;
};
 
 
 

class DLLEXPORT ElectrodeShapeEntity : public ElectrodeShape{
public:
    ElectrodeShapeEntity(MeshEntity & entity, const RVector3 & pos);
 
    virtual ~ElectrodeShapeEntity();
 
    inline void setEntity(MeshEntity & entity) { entity_ = & entity; }
    inline MeshEntity * entity() const { return entity_; }
 
    virtual std::vector < MeshEntity * > entities() const {
        std::vector < MeshEntity * > ents;
        ents.push_back(entity_);
        return ents;
    }
 
    virtual double geomMeanCellAttributes() const;

    virtual double pot(const RVector & sol) const;
 
    virtual void assembleRHS(RVector & rhs, double value, uint matrixSize) const;
 
    virtual void setSingValue(RVector & sol, double scale, double k) const;
 
protected:
    MeshEntity * entity_;
};
 

class DLLEXPORT ElectrodeShapeDomain : public ElectrodeShape{
public:
    ElectrodeShapeDomain(const std::vector < MeshEntity * > & entities);

    ElectrodeShapeDomain(const std::vector < Boundary * > & entities);
 
    virtual ~ElectrodeShapeDomain();
 
    inline void setEntities(std::vector < MeshEntity * > & entities) { entities_ = entities; }
 
    virtual std::vector < MeshEntity * > entities() const { return entities_; }
 
    virtual double geomMeanCellAttributes() const;
 
    virtual double pot(const RVector & sol) const;
 
    virtual void assembleRHS(RVector & rhs, double value, uint matrixSize) const;
 
protected:
    std::vector < MeshEntity * > entities_;
};
 
} //namespace BERT
 
#endif // _BERT_ELECTRODE__H