csubcam.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_COUPLEDSUBCAM_H
#define MECHSYS_COUPLEDSUBCAM_H

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

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

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

}; // class CSubCam




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

    /* example.mat
     * #-----------------------------------------------------------
     *             0       1      2     3      4        5      6 
     *            lam     kap  phics    G      c        k    gammaW
     * CSubCam  0.0891  0.0196   31.6  105  14000   1.0e-4   0.001
     *
     */

    // Check number of parameters
    const size_t n_equi_prms = SubCam    ::NPRMS; // SubCam     { 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(_("CSubCam::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 = SubCam    ::NIDAT; // SubCam     { 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(_("CSubCam::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 CSubCam model
CoupledModel * CSubCamMaker(Array<REAL> const & Prms, Array<REAL> const & IniData)
{
    return new CSubCam(Prms, IniData); 
}

// Register an CSubCam model into ModelFactory array map
int CSubCamRegister()
{
    CoupledModelFactory["CSubCam"] = CSubCamMaker;
    return 0;
}

// Execute the autoregistration
int __CSubCam_dummy_int = CSubCamRegister();

// }}}

#endif // MECHSYS_COUPLEDSUBCAM_H

// vim:fdm=marker

---