celastic.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys 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.                                                                          *
 *                                                                                   *
 * MechSys 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      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_COUPLEDELASTIC_H
#define MECHSYS_COUPLEDELASTIC_H

#include "models/coupled/genericc.h"
#include "models/linearelastic.h"
#include "models/flow/linearflow.h"

class CElastic : public GenericC<LinearElastic, LinearFlow> // GenericC is a generic Coupled model (intermediate class)
{
public:
    // Constructor
    CElastic(Array<REAL> const & Prms, Array<REAL> const & IniData);

    // Derived methods
    String Name() const { return "CElastic"; }; 

}; // class CElastic




inline CElastic::CElastic(Array<REAL> const & Prms, Array<REAL> const & IniData) // {{{
{
    // ##################################################################### Setup Parameters

    /* example.mat 
     * #--------------------------------------
     * #        Young  Poisson        k  gamaW
     * Elastic  20000     0.25   1.0e-5     10
     */

    // Check number of parameters
    const size_t n_equi_prms = LinearElastic::NPRMS; // Elastic    { E nu }
    const size_t n_flow_prms = LinearFlow   ::NPRMS; // LinearFlow { k gamaW }
    const size_t n_prms      = n_equi_prms+n_flow_prms;
    if (Prms.size()!=n_prms)
        throw new Fatal(_("CElastic::Constructor: The number of parameters (%d) is incorrect. It must be equal to %d"), Prms.size(), n_prms);

    // Parameters
    Array<REAL> equi_prms; equi_prms.resize(n_equi_prms); for (size_t i=0; i<n_equi_prms; ++i) equi_prms[i]=Prms[i];
    Array<REAL> flow_prms; flow_prms.resize(n_flow_prms); for (size_t i=0; i<n_flow_prms; ++i) flow_prms[i]=Prms[i+n_equi_prms];

    // ##################################################################### Setup Initial State

    // Check number of initial data
    const size_t n_equi_idat = LinearElastic::NIDAT; // LinearElastic { SigX SigY SigZ }
    const size_t n_flow_idat = LinearFlow   ::NIDAT; // LinearFlow    { Pp }
    const size_t n_idat      = n_equi_idat+n_flow_idat;
    if (IniData.size()!=n_idat) // Layered analysis
        throw new Fatal(_("CElastic::Constructor: The number of initial data (%d) is not sufficiet (it must be equal to %d)"), IniData.size(), n_idat);

    // Initial data
    Array<REAL> equi_idat; equi_idat.resize(n_equi_idat); for (size_t i=0; i<n_equi_idat; ++i) equi_idat[i]=IniData[i];
    Array<REAL> flow_idat; flow_idat.resize(n_flow_idat); for (size_t i=0; i<n_flow_idat; ++i) flow_idat[i]=IniData[i+n_equi_idat];

    // ##################################################################### Allocate derived models
    
    // Allocate equilib and flow models
    AllocateSubModels(equi_prms, equi_idat, flow_prms, flow_idat);

} // }}}



// Allocate a new CElastic model
CoupledModel * CElasticMaker(Array<REAL> const & Prms, Array<REAL> const & IniData)
{
    return new CElastic(Prms, IniData); 
}

// Register an CElastic model into ModelFactory array map
int CElasticRegister()
{
    CoupledModelFactory["CElastic"] = CElasticMaker;
    return 0;
}

// Execute the autoregistration
int __CElastic_dummy_int = CElasticRegister();

// }}}

#endif // MECHSYS_COUPLEDELASTIC_H

// vim:fdm=marker

---