dofmanager.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   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 dofmanager_h
#define dofmanager_h
 
#include <cstdio>
#include <map>
 
#include "femcmpnn.h"
#include "intarray.h"
#include "floatarray.h"
#include "valuemodetype.h"
#include "doftype.h"
#include "dofiditem.h"
#include "contextioresulttype.h"
#include "unknowntype.h"
#include "chartype.h"
#include "paramkey.h"
 
namespace oofem {
class DataStream;
class Dof;
class Domain;
class EntityRenumberingFunctor;
class FloatMatrix;
class PrimaryField;
class UnknownNumberingScheme;
class Load;
class TimeStep;
class FloatArray;
class IntArray;

enum dofManagerParallelMode {
    DofManager_local, 
    DofManager_shared, 
    DofManager_remote, 
    DofManager_null, 
};

class OOFEM_EXPORT DofManager : public FEMComponent
{
protected:
    FloatArray coordinates;

    std::vector< Dof * > dofArray;
    IntArray loadArray;
    bool isBoundaryFlag;
    bool hasSlaveDofs;
    int globalNumber;
 
    dofManagerParallelMode parallel_mode;

    IntArray partitions;

    IntArray dofidmask;
    std :: map< int, int > dofTypemap;
    std :: map< int, int > dofMastermap;
    std :: map< int, int > dofBCmap;
    std :: map< int, int > dofICmap;
 
    // List of BCs (to enable writing to DynamicInputRecord)
    IntArray mBC;
 
public:
    static ParamKey IPK_DofManager_dofidmask;
    static ParamKey IPK_DofManager_load;
    static ParamKey IPK_DofManager_bc;
    static ParamKey IPK_DofManager_ic;
    static ParamKey IPK_DofManager_mastermask;
    static ParamKey IPK_DofManager_doftypemask;
    static ParamKey IPK_DofManager_boundaryflag;
    static ParamKey IPK_DofManager_globnum;
    static ParamKey IPK_DofManager_partitions;
    static ParamKey IPK_DofManager_sharedflag;
    static ParamKey IPK_DofManager_remoteflag;
    static ParamKey IPK_DofManager_nullflag;
 
 
public:
    std::vector< Dof* > :: iterator begin() { return dofArray.begin(); }
    std::vector< Dof* > :: iterator end() { return dofArray.end(); }
    std::vector< Dof* > :: const_iterator begin() const { return dofArray.begin(); }
    std::vector< Dof* > :: const_iterator end() const { return dofArray.end(); }

    DofManager(int n, Domain * aDomain);
    virtual ~DofManager();


    Dof *giveDofWithID(int dofID) const;
    int giveNumberOfDofs() const;

    void askNewEquationNumbers(TimeStep *tStep);
    int giveNumberOfPrimaryMasterDofs(const IntArray &dofIDArray) const;
    void giveLocationArray(const IntArray &dofIDArry, IntArray &locationArray,
                           const UnknownNumberingScheme &s) const;
    void giveMasterDofIDArray(const IntArray &dofIDArry, IntArray &masterDofIDs) const;
    void giveCompleteLocationArray(IntArray &locationArray, const UnknownNumberingScheme &s) const;
    void giveCompleteMasterDofIDArray(IntArray &dofIDArray) const;
    std :: vector< Dof* > :: const_iterator findDofWithDofId(DofIDItem dofID) const;
    void giveUnknownVector(FloatArray &answer, const IntArray &dofMask, ValueModeType mode, TimeStep *tStep, bool padding = false);
    void giveUnknownVector(FloatArray &answer, const IntArray &dofMask,
                           PrimaryField &field, ValueModeType mode, TimeStep *tStep, bool padding = false);
    void giveCompleteUnknownVector(FloatArray &answer, ValueModeType mode, TimeStep *tStep);
    void giveUnknownVectorOfType(FloatArray &answer, UnknownType ut, ValueModeType mode, TimeStep *tStep);
    virtual void givePrescribedUnknownVector(FloatArray &answer, const IntArray &dofMask,
                                            ValueModeType mode, TimeStep *tStep);


    bool computeM2GTransformation(FloatMatrix &answer, const IntArray &dofIDArry);
    virtual bool computeL2GTransformation(FloatMatrix &answer, const IntArray &dofIDArry);
    virtual bool computeM2LTransformation(FloatMatrix &answer, const IntArray &dofIDArry);
    virtual bool requiresTransformation();


    virtual void computeLoadVector(FloatArray &answer, Load *load, CharType type, TimeStep *tStep, ValueModeType mode);
    IntArray *giveLoadArray();
    void setLoadArray(IntArray &load);


    double giveCoordinate(int i) const {
        if ( i > this->coordinates.giveSize() ) {
            return 0.;
        }
        return this->coordinates.at(i);
    }

    const FloatArray &giveCoordinates() const { return this->coordinates; }

    void setCoordinates(const FloatArray &coords) {
        this->coordinates = coords;
    }
    

    const IntArray *giveForcedDofIDs() { return &dofidmask; }
    std :: map< int, int > *giveDofTypeMap()  { return &dofTypemap; }
    std :: map< int, int > *giveMasterMap()  { return (dofMastermap.empty()?NULL: &dofMastermap);}
    std :: map< int, int > *giveBcMap()  { return (dofBCmap.empty()? NULL:&dofBCmap); }
    std :: map< int, int > *giveIcMap() { return (dofICmap.empty()? NULL: &dofICmap); }
 
    void printOutputAt(FILE *file, TimeStep *tStep) override;
    virtual void updateYourself(TimeStep *tStep);
 
    // Miscellaneous
    bool isBoundary() { return isBoundaryFlag; }
    void setBoundaryFlag(bool isBoundary) { this->isBoundaryFlag = isBoundary; }
    virtual bool hasAnySlaveDofs();
    virtual bool giveMasterDofMans(IntArray &masters);
 
    void initializeFrom(InputRecord &ir) override { initializeFrom(ir, 1); };
    void initializeFrom(InputRecord &ir, int priority) override;
    void initializeFinish() override;
    void postInitialize() override;
 
    void giveInputRecord(DynamicInputRecord &input) override;
 
    void printYourself() override;
    void saveContext(DataStream &stream, ContextMode mode) override;
    void restoreContext(DataStream &stream, ContextMode mode) override;

    virtual bool isDofTypeCompatible(dofType type) const { return false; }

    void updateLocalNumbering(EntityRenumberingFunctor &f) override;


    void setNumberOfDofs(int _ndofs);

    void appendDof(Dof *dof);

    void removeDof(DofIDItem id);

    bool hasDofID(DofIDItem id) const;
 
#ifdef __OOFEG
    virtual void drawYourself(oofegGraphicContext &gc, TimeStep *tStep) { }
#endif

    int giveGlobalNumber() const { return globalNumber; }
    int giveLabel() const { return globalNumber; }
    void setGlobalNumber(int newNumber) { globalNumber = newNumber; }

    dofManagerParallelMode giveParallelMode() const { return parallel_mode; }
    void setParallelMode(dofManagerParallelMode _mode) { parallel_mode = _mode; }
    const IntArray *givePartitionList()  { return & partitions; }
    void setPartitionList(const IntArray *_p) { partitions = * _p; }
    void removePartitionFromList(int _part) {
        int _pos = partitions.findFirstIndexOf(_part);
        if ( _pos ) {
            partitions.erase(_pos);
        }
    }

    void mergePartitionList(IntArray &_p);
    int givePartitionsConnectivitySize();
    bool isLocal();
    bool isShared() { return parallel_mode == DofManager_shared; }
    bool isNull() { return parallel_mode == DofManager_null; }
 
    const char *giveClassName() const override {return "DofManager";}
    const char *giveInputRecordName() const override {return "dofmanager";}
};
} // end namespace oofem
#endif // dofmanager_h