particletopologydescription.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 program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef particletopologydescription_h
#define particletopologydescription_h

#include "topologydescription.h"
#include "intarray.h"
#include "floatarray.h"
#include "floatmatrix.h"

#include <string>
#include <list>
#include <vector>
#include <memory>


#define _IFT_Circle_center "center"
#define _IFT_Circle_radius "radius"
#define _IFT_Circle_start "start"
#define _IFT_Circle_end "end"



#define _IFT_Line_start "start"
#define _IFT_Line_end "end"



#define _IFT_Point_coords "coords"



#define _IFT_Meshing_elementType "elementtype"
#define _IFT_Meshing_set "set"



#define _IFT_ParticleTopologyDescription_Name "particletopology"
#define _IFT_ParticleTopologyDescription_nsd "nsd"
#define _IFT_ParticleTopologyDescription_baseResolution "baseresolution"
#define _IFT_ParticleTopologyDescription_tubeWidth "tubewidth"
#define _IFT_ParticleTopologyDescription_neighbors "neighbors"
#define _IFT_ParticleTopologyDescription_boundingBoxA "bboxa"
#define _IFT_ParticleTopologyDescription_boundingBoxB "bboxb"
#define _IFT_ParticleTopologyDescription_numberOfSegments "nsegments"
#define _IFT_ParticleTopologyDescription_regionOutside "regionoutside"
#define _IFT_ParticleTopologyDescription_regionInside "regioninside"
#define _IFT_ParticleTopologyDescription_identification "id"



namespace oofem
{
template< class Point >class ParticleGrid;
class Domain;
struct Triangle_PSLG;

struct ParticlePoint {
    ParticlePoint() {};
    ParticlePoint(const FloatArray &foot, int id, const FloatArray &normal, double distance2) :
        foot(foot), id(id), normal(normal), distance2(distance2), removal(false) {};
    FloatArray foot; 
    // Auxiliary information
    FloatArray total_displacement; 
    int id; 
    FloatArray normal; 
    FloatArray corner; 
    double distance2; 
    int node; 
    int c_node; 
    bool removal; 
};

class ParticleTopologyDescription : public TopologyDescription
{
protected:
    bool useDisplacements;
    bool writeVTK;
    bool resampled;
    double maxdisp2;
    double tubeWidth;
    int m;
    std :: unique_ptr< ParticleGrid< ParticlePoint > > grid;

    std :: list< ParticlePoint >corners;

    IntArray regionOutside, regionInside;
    FloatMatrix mergeID, controlID;

    std :: vector< std :: string >regionElementType;
    IntArray regionSet;

    void resample();

    TopologyState checkOverlap();

    void removePoints(ParticleGrid< ParticlePoint > &g) const;

    bool findDisplacement(FloatArray &answer, int id, const FloatArray &footpoint, TimeStep *tStep) const;

    void collectNeighbors(std :: list< ParticlePoint * > &answer, const ParticlePoint *p, double dist = 0) const;

    static void getBoundingBox(FloatArray &x0, FloatArray &x1, const FloatArray &c, double width);

    void calculateShortestDistance(const ParticlePoint *p, std :: list< ParticlePoint * > &points, ParticleGrid< ParticlePoint > &grid) const;

    double shortestDistanceFromCurve(const FloatArray &a, double txi_min, double txi_max,
                                     const FloatArray &n0, const FloatArray &y0, const FloatArray &p, FloatArray &foot, FloatArray &normal) const;

    void addLineSegment(int id, const FloatArray &p0, const FloatArray &p1, ParticleGrid< ParticlePoint > &grid) const;
    void addCircleSegment(int id, const FloatArray &c, double r, double v0, double v1, ParticleGrid< ParticlePoint > &grid) const;
    void addCorner(int id, const FloatArray &c, ParticleGrid< ParticlePoint > &grid);

    void generatePSLG(Triangle_PSLG &PSLG);

public:
    ParticleTopologyDescription(Domain *d);
    virtual ~ParticleTopologyDescription();
    virtual bool instanciateYourself(DataReader &dr);

    virtual TopologyState updateYourself(TimeStep *tStep);

    virtual void generateMesh(std :: vector< FloatArray > &nodes, std :: vector< IntArray > &elements, std :: vector< IntArray > &segments,
                              std :: vector< IntArray > &n_markers, IntArray &e_markers, IntArray &s_markers, IntArray &e_egt, IntArray &s_egt);

    virtual void replaceFEMesh();

    virtual void doOutput(TimeStep *tStep);
    virtual void writeDataToFile(const char *name) const;
    virtual void writeVTKFile(const char *name) const;

    virtual const char *giveClassName() const { return "ParticleTopologyDescription"; }
};
} // end namespace oofem
#endif // particletopologydescription_h