ccamclay.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_COUPLEDCAMCLAY_H
#define MECHSYS_COUPLEDCAMCLAY_H

// MechSys
#include "models/coupled/genericc.h"
#include "models/camclay.h"
#include "models/flow/linearflow.h"

class CCamClay : public GenericC<CamClay, LinearFlow>
{
public:
    // Constructor
    CCamClay(Array<REAL> const & Prms, Array<REAL> const & IniData);

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

}; // class CCamClay




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

    /* example.mat
     * #-------------------------------
     * #             0      1     2   3      5      6
     * #           lam    kap phics   G      k gammaW
     * CCamClay 0.0891 0.0196  31.6 200 1.0e-4   10.0
     */


    // Check number of parameters
    const size_t n_equi_prms = CamClay   ::NPRMS; // CamClay     { lam kap nu rcs c }
    const size_t n_flow_prms = LinearFlow::NPRMS; // LinearFlow { k gammaW}
    const size_t n_prms      = n_equi_prms+n_flow_prms;
    if (Prms.size()!=n_prms)
        throw new Fatal(_("CCamClay::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 = CamClay   ::NIDAT; // CamClay     { SigX SigY SigZ vini OCR }
    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(_("CCamClay::Constructor: The number of initial data is not sufficiet (it must be equal to 5). { SigX SigY SigZ vini OCR Pp }"));

    // 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 CCamClay model
CoupledModel * CCamClayMaker(Array<REAL> const & Prms, Array<REAL> const & IniData)
{
    return new CCamClay(Prms, IniData); 
}

// Register an CCamClay model into ModelFactory array map
int CCamClayRegister()
{
    CoupledModelFactory["CCamClay"] = CCamClayMaker;
    return 0;
}

// Execute the autoregistration
int __CCamClay_dummy_int = CCamClayRegister();

// }}}

#endif // MECHSYS_COUPLEDCAMCLAY_H

// vim:fdm=marker

---