leplic.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  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 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef leplic_h
#define leplic_h

#include "materialinterface.h"
#include "floatarray.h"
#include "mathfem.h"
#include "interface.h"


#define _IFT_LEPLIC_refVol "refvol"


namespace oofem {
class LEPlic;
class Polygon;
class Element;

class LEPlicElementInterface : public Interface
{
protected:
    bool permanentVofFlag;
    double vof, temp_vof;
    double p, temp_p;
    FloatArray normal, temp_normal;

public:
    LEPlicElementInterface() : permanentVofFlag(false), vof(0.), temp_vof(0.) { }
    virtual double computeLEPLICVolumeFraction(const FloatArray &n, const double p, LEPlic *matInterface, bool updFlag) = 0;
    virtual void formMaterialVolumePoly(Polygon &matvolpoly, LEPlic *matInterface,
                                        const FloatArray &normal, const double p, bool updFlag) = 0;
    virtual void formVolumeInterfacePoly(Polygon &matvolpoly, LEPlic *matInterface,
                                         const FloatArray &normal, const double p, bool updFlag) = 0;
    virtual double truncateMatVolume(const Polygon &matvolpoly, double &volume) = 0;
    virtual void giveElementCenter(LEPlic *mat_interface, FloatArray &center, bool updFlag) = 0;
    virtual void formMyVolumePoly(Polygon &myPoly, LEPlic *mat_interface, bool updFlag) = 0;
    virtual double computeMyVolume(LEPlic *matInterface, bool updFlag) = 0;
    bool isBoundary();
    virtual Element *giveElement() = 0;
    virtual double computeCriticalLEPlicTimeStep(TimeStep *tStep) = 0;

    void setTempLineConstant(double tp) { temp_p = tp; }
    void setTempInterfaceNormal(FloatArray tg) { temp_normal = std::move(tg); }
    void setTempVolumeFraction(double v) {
        if ( !permanentVofFlag ) {
            temp_vof = v;
        }
    }
    void setPermanentVolumeFraction(double v) {
        temp_vof = vof = v;
        permanentVofFlag = true;
    }
    void addTempVolumeFraction(double v) {
        if ( !permanentVofFlag ) {
            temp_vof += v;
            if ( temp_vof > 1.0 ) {
                temp_vof = 1.0;
            }
        }
    }
    double giveVolumeFraction() { return vof; }
    double giveTempVolumeFraction() { return temp_vof; }
    void giveTempInterfaceNormal(FloatArray &n) { n = temp_normal; }
    double giveTempLineConstant() { return temp_p; }
    void updateYourself(TimeStep *tStep) {
        vof = temp_vof;
        p = temp_p;
        normal = temp_normal;
    }

    contextIOResultType saveContext(DataStream &stream, ContextMode mode, void *obj = NULL);
    contextIOResultType restoreContext(DataStream &stream, ContextMode mode, void *obj = NULL);
};

class LEPlic : public MaterialInterface
{
protected:
    FloatArray updated_XCoords;
    FloatArray updated_YCoords;
    double orig_reference_fluid_volume;
public:
    LEPlic(int n, Domain * d) : MaterialInterface(n, d) {
        orig_reference_fluid_volume = 0.0;
    }

    virtual void updatePosition(TimeStep *tStep);
    virtual void updateYourself(TimeStep *tStep) { }
    virtual void giveMaterialMixtureAt(FloatArray &answer, FloatArray &position);
    virtual void giveElementMaterialMixture(FloatArray &answer, int ielem);
    virtual double giveNodalScalarRepresentation(int);
    virtual double computeCriticalTimeStep(TimeStep *tStep);

    void giveUpdatedCoordinate(FloatArray &answer, int num) {
        answer.resize(2);
        answer.at(1) = updated_XCoords.at(num);
        answer.at(2) = updated_YCoords.at(num);
    }

    double giveUpdatedXCoordinate(int num) { return updated_XCoords.at(num); }
    double giveUpdatedYCoordinate(int num) { return updated_YCoords.at(num); }

    virtual IRResultType initializeFrom(InputRecord *ir);
    virtual void giveInputRecord(DynamicInputRecord &input);

    // identification
    virtual const char *giveClassName() const { return "LEPlic"; }

protected:
    void doLagrangianPhase(TimeStep *tStep);
    void doInterfaceReconstruction(TimeStep *tStep, bool coord_upd, bool temp_vof);
    void doInterfaceRemapping(TimeStep *tStep);
    void doCellDLS(FloatArray &fvgrad, int ie, bool coord_upd, bool temp_vof_flag);
    void findCellLineConstant(double &p, FloatArray &fvgrad, int ie, bool coord_upd, bool temp_vof_flag);


    class computeLEPLICVolumeFractionWrapper
    {
protected:
        LEPlicElementInterface *iface;
        LEPlic *minterf;
        FloatArray normal;
        double target_vof;
        bool upd;
public:
        computeLEPLICVolumeFractionWrapper(LEPlicElementInterface * i, LEPlic * mi, const FloatArray & n, const double target_vof_val, bool upd_val) :
            iface(i), minterf(mi), normal(n), target_vof(target_vof_val), upd(upd_val) { }
        void setNormal(FloatArray n) { normal = std::move(n); }
        double eval(double x) { return fabs(iface->computeLEPLICVolumeFraction(normal, x, minterf, upd) - target_vof); }
    };
};
} // end namespace oofem
#endif // leplic_h