dofmanager.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 dofmanager_h
#define dofmanager_h

#include <cstdio>
#include <map>

#include "femcmpnn.h"
#include "intarray.h"
#include "valuemodetype.h"
#include "doftype.h"
#include "dofiditem.h"
#include "contextioresulttype.h"
#include "unknowntype.h"
#include "chartype.h"


#define _IFT_DofManager_dofidmask "dofidmask"
#define _IFT_DofManager_load "load"
#define _IFT_DofManager_bc "bc"
#define _IFT_DofManager_ic "ic"
#define _IFT_DofManager_mastermask "mastermask"
#define _IFT_DofManager_doftypemask "doftype"
#define _IFT_DofManager_boundaryflag "boundary"
#define _IFT_DofManager_globnum "globnum"
#define _IFT_DofManager_partitions "partitions"
#define _IFT_DofManager_sharedflag "shared"
#define _IFT_DofManager_remoteflag "remote"
#define _IFT_DofManager_nullflag "null"


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:
    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:
    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);
    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);

    virtual bool hasCoordinates() { return false; }
    virtual double giveCoordinate(int i) { return 0.0; }
    virtual FloatArray *giveCoordinates() { return NULL; }

    const IntArray *giveForcedDofIDs() { return dofidmask; }
    std :: map< int, int > *giveDofTypeMap()  { return dofTypemap; }
    std :: map< int, int > *giveMasterMap()  { return dofMastermap; }
    std :: map< int, int > *giveBcMap()  { return dofBCmap; }
    std :: map< int, int > *giveIcMap() { return dofICmap; }

    virtual void printOutputAt(FILE *file, TimeStep *tStep);
    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);

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

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

    virtual bool isDofTypeCompatible(dofType type) const { return false; }
    virtual void postInitialize();
    virtual void updateLocalNumbering(EntityRenumberingFunctor &f);

    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; }
};
} // end namespace oofem
#endif // dofmanager_h