domain.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 domain_h
#define domain_h

#include "alist.h"
#include "domaintype.h"
#include "statecountertype.h"
#include "intarray.h"

#include <map>
#ifdef __PARALLEL_MODE
 #include <list>
 #include "entityrenumberingscheme.h"
#endif

#ifdef __OOFEG
 #include "oofeggraphiccontext.h"
#endif

namespace oofem {
class Element;
class Node;
class Material;
class GeneralBoundaryCondition;
class InitialCondition;
class Load;
class LoadTimeFunction;
class CrossSection;
class ElementSide;
class DofManager;
class OutputManager;
class EngngModel;
class ConnectivityTable;
class ErrorEstimator;
class SpatialLocalizer;
class NodalRecoveryModel;
class NonlocalBarrier;
class DomainTransactionManager;
class RandomFieldGenerator;
class XfemManager;
class TopologyDescription;
class DataReader;

#ifdef __PARALLEL_MODE
class ProcessCommunicator;
class LoadBalancer;
#endif

class Domain
{
private:
    AList< Element > *elementList;
    AList< DofManager > *dofManagerList;
    AList< Material > *materialList;
    AList< CrossSection > *crossSectionList;
    AList< GeneralBoundaryCondition > *bcList;
    AList< InitialCondition > *icList;
    AList< LoadTimeFunction > *loadTimeFunctionList;
    AList< NonlocalBarrier > *nonlocalBarierList;
    AList< RandomFieldGenerator > *randomFieldGeneratorList;

    IntArray defaultNodeDofIDArry;

    domainType dType;

    EngngModel *engineeringModel;

    ConnectivityTable *connectivityTable;
    SpatialLocalizer *spatialLocalizer;
    OutputManager *outputManager;
    int number;
    int serialNumber;
    NodalRecoveryModel *smoother;
    StateCounterType nonlocalUpdateStateCounter;
    XfemManager *xfemManager;
    TopologyDescription *topology;
    
    int freeDofID;

#ifdef __PARALLEL_MODE

    DomainTransactionManager *transactionManager;
    std :: map< int, DofManager * >dmanMap;
    bool dmanMapInitialized;
    std :: map< int, Element * >elementMap;
    bool elementMapInitialized;



    std :: list< Element * >recvElemList;
#endif

public:
    Domain(int n, int serNum, EngngModel *e);
    ~Domain();

    int giveNumber() { return this->number; }
    void setNumber(int nn) { this->number = nn; }
    int giveSerialNumber() { return this->serialNumber; }

    // management of the mesh components
    Element *giveElement(int n);
    EngngModel *giveEngngModel();
    Load *giveLoad(int n);
    GeneralBoundaryCondition *giveBc(int n);
    InitialCondition *giveIc(int n);

    LoadTimeFunction *giveLoadTimeFunction(int n);
    Material *giveMaterial(int n);
    CrossSection *giveCrossSection(int n);
    NonlocalBarrier *giveNonlocalBarrier(int n);
    RandomFieldGenerator *giveRandomFieldGenerator(int n);

    Node *giveNode(int n);
    ElementSide *giveSide(int n);
    DofManager *giveDofManager(int n);
    int instanciateYourself(DataReader *dr);
    void postInitialize();
    //int giveNumberOfNodes () {return nodeList->giveSize();}
    //int giveNumberOfSides () {return elementSideList->giveSize();}
    int giveNumberOfDofManagers() { return dofManagerList->giveSize(); }
    int giveNumberOfElements() { return elementList->giveSize(); }
    int giveNumberOfMaterialModels() { return materialList->giveSize(); }
    int giveNumberOfCrossSectionModels() { return crossSectionList->giveSize(); }
    int giveNumberOfBoundaryConditions() { return bcList->giveSize(); }
    int giveNumberOfInitialConditions() { return icList->giveSize(); }
    int giveNumberOfLoadTimeFunctions() { return loadTimeFunctionList->giveSize(); }
    int giveNumberOfRegions() { return this->giveNumberOfCrossSectionModels(); }
    int giveNumberOfNonlocalBarriers() { return nonlocalBarierList->giveSize(); }
    int giveNumberOfRandomFieldGenerators() { return randomFieldGeneratorList->giveSize(); }
    
    int giveCorrespondingCoordinateIndex(int);
    int giveNumberOfSpatialDimensions();

    void resizeDofManagers(int _newSize);
    void resizeElements(int _newSize);
    void resizeCrossSectionModels(int _newSize);
    void resizeMaterials(int _newSize);
    void resizeNonlocalBarriers(int _newSize);
    void resizeBoundaryConditions(int _newSize);
    void resizeInitialConditions(int _newSize);
    void resizeLoadTimeFunctions(int _newSize);
    void resizeRandomFieldGenerators(int _newSize);

    void setDofManager(int i, DofManager *obj);
    void setElement(int i, Element *obj);
    void setCrossSection(int i, CrossSection *obj);
    void setMaterial(int i, Material *obj);
    void setNonlocalBarrier(int i, NonlocalBarrier *obj);
    void setBoundaryCondition(int i, GeneralBoundaryCondition *obj);
    void setInitialCondition(int i, InitialCondition *obj);
    void setLoadTimeFunction(int i, LoadTimeFunction *obj);
    void setRandomFieldGenerator(int i, RandomFieldGenerator *obj);
    
    void setXfemManager(XfemManager *xfemManager);
    void setTopology(TopologyDescription *topo, bool destroyOld = true);
    void clearBoundaryConditions();
    void clear();

    contextIOResultType saveContext(DataStream *stream, ContextMode mode, void *obj = NULL);
    contextIOResultType restoreContext(DataStream *stream, ContextMode mode, void *obj = NULL);
    const IntArray &giveDefaultNodeDofIDArry();
    domainType giveDomainType() { return dType; }
    void setDomainType(domainType _dType) { this->dType = _dType; }
    int checkConsistency();

    double giveArea();
    double giveVolume();
    
    int giveNextFreeDofID();
    void resetFreeDofID();
    int giveMaxDofID() { return this->freeDofID - 1; }

    ConnectivityTable *giveConnectivityTable();
    SpatialLocalizer *giveSpatialLocalizer();
    OutputManager *giveOutputManager() { return outputManager; }
    ErrorEstimator *giveErrorEstimator();
    NodalRecoveryModel *giveSmoother();
    TopologyDescription *giveTopology() { return topology; }
    void setSmoother(NodalRecoveryModel *smoother, bool destroyOld = true);

#ifdef __PARALLEL_MODE

    DomainTransactionManager *giveTransactionManager();
    int commitTransactions(DomainTransactionManager *tm);

    void initGlobalDofManMap(bool forceinit = false);
    void initGlobalElementMap(bool forceinit = false);
    void renumberDofManagers();
    void renumberDofManData(DomainTransactionManager *tm);
    void renumberElements();
    void renumberElementData(DomainTransactionManager *tm);
    int LB_giveUpdatedLocalNumber(int oldnum, EntityRenumberingScheme scheme);
    int LB_giveUpdatedGlobalNumber(int oldnum, EntityRenumberingScheme scheme);


    int dofmanGlobal2Local(int _globnum);
    int elementGlobal2Local(int _globnum);
#endif

#ifdef __OOFEG
    void drawYourself(oofegGraphicContext &context);
    void drawElements(oofegGraphicContext &context);
    void drawNodes(oofegGraphicContext &context);
#endif

    const char *giveClassName() const { return "Domain"; }

    StateCounterType giveNonlocalUpdateStateCounter() { return this->nonlocalUpdateStateCounter; }
    void setNonlocalUpdateStateCounter(StateCounterType val) { this->nonlocalUpdateStateCounter = val; }

private:
    void resolveDomainDofsDefaults(const char *);

    void error(const char *file, int line, const char *format, ...);
    void warning(const char *file, int line, const char *format, ...);
};
} // end namespace oofem
#endif // domain_h