lts.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_LABTESTSIM_LABTESTSIM_H
#define MECHSYS_LABTESTSIM_LABTESTSIM_H

#ifdef HAVE_CONFIG_H
  #include "config.h"
#else
  #ifndef REAL
    #define REAL double
  #endif
#endif

#include "util/string.h"
#include "util/array.h"
#include "labtestsim/inputdata.h"
#include "labtestsim/equipment.h"
#include "labtestsim/ctx.h"
#include "labtestsim/ttx.h"
#include "models/coupled/coupledmodel.h"
#include "models/equilibmodel.h"

namespace LabTestSim
{

template<typename T_Model>
class LTS
{
public:
    // Constructor and destructor
     LTS (InputData const & ID);
    ~LTS ();

    // Methods
    void                       ReInitModel ();
    void                       ReInitModel (Array<REAL> const & ModelPrms);
    void                       Run         (size_t iEquip);
    void                       WriteFile   (size_t iEquip);
    void                       RunAll      ();
    void                       WriteAll    ();
    Equipment<T_Model> const * Equip       (int iEquip) const;

private:
    // Data
    InputData                  const & _idata;
    bool                               _is_initialized;
    Array< String              >       _equipments;     // size == num data files
    Array< Array<State>        >       _a_states;       // size == num data files
    Array< Array<REAL>         >       _a_ini_data;     // size == num data files
    Array< T_Model *           >       _a_p_model;      // size == num data files
    Array< Equipment<T_Model>* >       _a_p_equip;      // size == num data files

    // Private methods
    void _re_initialize(Array<REAL> const & ModelPrms);
}; // class LTS




template<typename T_Model>
inline LTS<T_Model>::LTS(InputData const & ID) // {{{
    : _idata          (ID)   ,
      _is_initialized (false)
{
    // Set integration constants
    CoupledModel::SetIntegSchemesCtes(ID.intSC);
    EquilibModel::SetIntegSchemesCtes(ID.intSC);

    // Number of data files
    size_t n_files = _idata.a_data.size();
    
    // Allocate arrays
    _equipments.resize(n_files);
    _a_states  .resize(n_files);
    _a_ini_data.resize(n_files);
    _a_p_model .resize(n_files, NULL);
    _a_p_equip .resize(n_files, NULL);
    
    // Fill _equipments, _a_states and _a_ini_data
    for (size_t i_file=0; i_file<n_files; ++i_file)
    {
        // Equipments
        _equipments[i_file] = _idata.a_EQUIPS[i_file];

        // Sa values
        FileParser::Table::const_iterator Sa_it = _idata.a_data[i_file].find("Sa");
        if (Sa_it==_idata.a_data[i_file].end())
            throw new Fatal(_("LTS::LTS File < %s >. Could not find tag <Sa> inside data"), _idata.a_fnDAT[i_file].c_str());

        // Sr values
        FileParser::Table::const_iterator Sr_it = _idata.a_data[i_file].find("Sr");
        if (Sr_it==_idata.a_data[i_file].end())
            throw new Fatal(_("LTS::LTS File < %s >. Could not find tag <Sr> inside data"), _idata.a_fnDAT[i_file].c_str());

        // St values
        FileParser::Table::const_iterator St_it = _idata.a_data[i_file].find("St");
        if (St_it==_idata.a_data[i_file].end())
            throw new Fatal(_("LTS::LTS File < %s >. Could not find tag <St> inside data"), _idata.a_fnDAT[i_file].c_str());

#ifdef USE_COUPLEDMODEL
        // Pp values (pore-pressure)
        FileParser::Table::const_iterator Pp_it = _idata.a_data[i_file].find("Pp");
        if (Pp_it==_idata.a_data[i_file].end())
            throw new Fatal(_("LTS::LTS File < %s >. Could not find tag <Pp> inside data"), _idata.a_fnDAT[i_file].c_str());
#endif

        // v values
        FileParser::Table::const_iterator v_it = _idata.a_data[i_file].find("v");
        if (v_it==_idata.a_data[i_file].end())
            throw new Fatal(_("LTS::LTS File < %s >. Could not find tag <v> inside data"), _idata.a_fnDAT[i_file].c_str());

        // Not using Sat and Exx => Hollow-Cylinder not working  TODO: Consider the Hollow-Cylinder case

        // Load states
        int n_states = Sa_it->second.size() - _idata.a_SKIPLAST[i_file] - _idata.a_SKIPFIRST[i_file];
        int skip = _idata.a_SKIPFIRST[i_file];
        Array<State> tmp_states;
        tmp_states.resize(n_states);
        for (int j_state=0; j_state<n_states; ++j_state)
        {
            tmp_states[j_state].Sa = Sa_it->second[skip+j_state];
            tmp_states[j_state].Sr = Sr_it->second[skip+j_state];
            tmp_states[j_state].St = St_it->second[skip+j_state];
#ifdef USE_COUPLEDMODEL
            tmp_states[j_state].Pp = Pp_it->second[skip+j_state];
#endif
        }
        _a_states[i_file] = tmp_states;

        // Initial states
        if (v_it->second[skip+0]==0.0)
            throw new Fatal(_("LTS::LTS File < %s >. v_ini must be different than zero"), _idata.a_fnDAT[i_file].c_str());
        Array<REAL> tmp_ini_data;
#ifdef USE_COUPLEDMODEL
        tmp_ini_data.resize(7);
#else
        tmp_ini_data.resize(5);
#endif
        tmp_ini_data[0] = _a_states[i_file][0].Sa;
        tmp_ini_data[1] = _a_states[i_file][0].Sr;
        tmp_ini_data[2] = _a_states[i_file][0].St;
        tmp_ini_data[3] = v_it->second[skip+0];
        tmp_ini_data[4] = ID.a_OCR[i_file];
#ifdef USE_COUPLEDMODEL
        tmp_ini_data[5] = ID.a_OSI[i_file];
        tmp_ini_data[6] = _a_states[i_file][0].Pp;
#endif
        _a_ini_data[i_file] = tmp_ini_data;
    }
} // }}}

template<typename T_Model>
inline LTS<T_Model>::~LTS() //{{{
{
    for (size_t i=0; i<_equipments.size(); ++i)
    {
        if (_a_p_model[i]!=NULL) delete _a_p_model[i];
        if (_a_p_equip[i]!=NULL) delete _a_p_equip[i];
    }
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::ReInitModel() // {{{
{
    // Read material parameters
    Array<REAL> model_prms;
    FileParser  FP(_idata.fnMAT);
    FP.FindKeyAndFillArray(_idata.MODEL, model_prms);

    // Initialize
    _re_initialize(model_prms);

    // Flag
    _is_initialized = true;
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::ReInitModel(Array<REAL> const & ModelPrms) // {{{
{
    // Initialize
    _re_initialize(ModelPrms);

    // Flag
    _is_initialized = true;
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::Run(size_t iEquip) // {{{
{
    // Check flag
    if (!_is_initialized) throw new Fatal(_("LTS::Run: LTS was not initialized"));

    // Run simulation
    _a_p_equip[iEquip]->Run(_idata.NDIV, _a_states[iEquip]);
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::WriteFile(size_t iEquip) // {{{
{
    // Check flag
    if (!_is_initialized) throw new Fatal(_("LTS::WriteFile: LTS was not initialized"));

    // Write output file
    _a_p_equip[iEquip]->WriteFile(_idata.a_fnCAL[iEquip], _idata.PRINCVALS);
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::RunAll() // {{{
{
    for (size_t i_equip=0; i_equip<_a_p_equip.size(); ++i_equip)
        Run (i_equip);
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::WriteAll() // {{{
{
    for (size_t i_equip=0; i_equip<_a_p_equip.size(); ++i_equip)
        WriteFile (i_equip);
} // }}}

template<typename T_Model>
inline Equipment<T_Model> const * LTS<T_Model>::Equip(int iEquip) const // {{{
{
    // Check flag
    if (!_is_initialized) throw new Fatal(_("LTS::WriteFile: LTS was not initialized"));

    return _a_p_equip[iEquip]; 
} // }}}

template<typename T_Model>
inline void LTS<T_Model>::_re_initialize(Array<REAL> const & ModelPrms) // {{{
{
    // Number of data files
    size_t n_files = _equipments.size();
    
    // Re-allocate structures
    for (size_t i=0; i<n_files; ++i)
    {
        // Clear old model
        if (_a_p_model[i]!=NULL) delete _a_p_model[i];

        // Clear old equipment
        if (_a_p_equip[i]!=NULL) delete _a_p_equip[i];

        // Allocate a new model
        ALLOCMODELFUNC(_idata.MODEL,ModelPrms,_a_ini_data[i], _a_p_model[i]);

        // Select and allocate an equipment
        if (_equipments[i]=="CTX")
            _a_p_equip[i] = new CTX<T_Model> (_a_p_model[i], _equipments[i], _idata.StopOnFailure, _idata.SAVEINTSTATES, _idata.Silent);

        else if (_equipments[i]=="TTX")
            _a_p_equip[i] = new TTX<T_Model> (_a_p_model[i], _equipments[i], _idata.StopOnFailure, _idata.SAVEINTSTATES, _idata.Silent);

        else
        {
            delete _a_p_model[i];
            throw new Fatal(_("LTS::_re_initialize: Invalid equipment key < %s >"), _equipments[i].c_str());
        }
    }
} // }}}

}; // LabTestSim

#endif // MECHSYS_LABTESTSIM_LABTESTSIM_H

// vim:fdm=marker

---