ModelWrapper.h

// -*-c++-*-
//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis C. Pérez Tato
//
//  This program derives from OpenSees <http://opensees.berkeley.edu>
//  developed by the  «Pacific earthquake engineering research center».
//
//  Except for the restrictions that may arise from the copyright
//  of the original program (see copyright_opensees.txt)
//  XC 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 3 of the License, or 
//  (at your option) any later version.
//
//  This software 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, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------
//ModelWrapper.h

#ifndef MODELWRAPPER_H
#define MODELWRAPPER_H

#include "utility/kernel/CommandEntity.h"

namespace XC {

class Domain;
class AnalysisModel;
class ConstraintHandler;
class DOF_Numberer;
class FEM_ObjectBroker;
class ID;
class Communicator;
class SolutionStrategy;
class Integrator;

//
//
class ModelWrapper: public CommandEntity
  {
    AnalysisModel *theModel; 
    ConstraintHandler *theHandler; 
    DOF_Numberer *theDOFNumberer;  

    void free_analysis_model(void);
    void alloc_analysis_model(void);
    void copy_analysis_model(AnalysisModel *);

    void free_constraint_handler(void);
    bool alloc_constraint_handler(const std::string &);
    void copy_constraint_handler(const ConstraintHandler *);

    bool setup_numerador(void);
    void free_numerador(void);
    bool alloc_numerador(const std::string &);
    void copy_numerador(const DOF_Numberer *);

    void copy(const ModelWrapper &);
    void free_mem(void);

    SolutionStrategy *getSolutionStrategy(void);
    const SolutionStrategy *getSolutionStrategy(void) const;
  protected:
    friend class FEProblem;
    friend class SolutionStrategy;

  public:
    ModelWrapper(SolutionStrategy *owr= nullptr);
    ModelWrapper(const ModelWrapper &);
    ModelWrapper &operator=(const ModelWrapper &);
    ~ModelWrapper(void);

    std::string getName(void) const;
    
    Domain *getDomainPtr(void);
    const Domain *getDomainPtr(void) const;
    Integrator *getIntegratorPtr(void);
    const Integrator *getIntegratorPtr(void) const;

    inline ConstraintHandler *getConstraintHandlerPtr(void)
      { return theHandler; }
    inline const ConstraintHandler *getConstraintHandlerPtr(void) const
      { return theHandler; }
    inline DOF_Numberer *getDOF_NumbererPtr(void)
      { return theDOFNumberer; }
    inline const DOF_Numberer *getDOF_NumbererPtr(void) const
      { return theDOFNumberer; }
    inline AnalysisModel *getAnalysisModelPtr(void)
      { return theModel; }
    inline const AnalysisModel *getAnalysisModelPtr(void) const
      { return theModel; }
    int setNumberer(DOF_Numberer &theNumberer);
    void brokeConstraintHandler(const Communicator &,const ID &);
    void brokeNumberer(const Communicator &,const ID &);
    void brokeAnalysisModel(const Communicator &,const ID &);
    bool CheckPointers(void);

    DOF_Numberer &newNumberer(const std::string &);
    ConstraintHandler &newConstraintHandler(const std::string &);

    void clearAll(void);
  };

} // end of XC namespace

#endif