filesdata.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_FEM_FILESDATA_H
#define MECHSYS_FEM_FILESDATA_H

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

#include <iomanip>
#include <fstream>

#include "util/array.h"
#include "util/string.h"
#include "util/numstreams.h"
#include "fem/inputdata.h"
#include "util/fileparser.h"
#include "util/lineparser.h"
#include "util/exception.h"

using Util::_8s;
using Util::_6;
using Util::_a;

namespace FEM
{


class FilesData
{
public:
    // Auxiliar structures
    struct Node;      // Information of a single node
    struct Face;      // Information of a single face
    struct Element;   // Information of a single element
    struct BryCond;   // Information of a single boundary condition
    struct Attribute; // Information of a single attribute
    struct Stage;     // Information of a single stage
    // Public methods
    void ReadNodes         (FEM::InputData const & ID); // fill Nodes with size = number of nodes
    void ReadFaces         (FEM::InputData const & ID); // fill Faces with size = number of faces
    void ReadElements      (FEM::InputData const & ID); // fill Elements with size = number of elements
    void ReadNodeBry       (FEM::InputData const & ID); // fill Stages.NodeBrys with size = number of node bry marks
    void ReadFaceBry       (FEM::InputData const & ID); // fill Stages.FaceBrys with size = number of face bry marks
    void ReadAttributes    (FEM::InputData const & ID); // fill Stages.Attribute with size = number of attributes
    void ReadInitialValues (FEM::InputData const & ID); // fill IniVals arrays inside element structure
    void ReadAllFiles      (FEM::InputData const & ID) // {{{
    {
        ReadNodes         (ID);
        ReadFaces         (ID);
        ReadElements      (ID); 
        ReadNodeBry       (ID); 
        ReadFaceBry       (ID); 
        ReadAttributes    (ID); 
        ReadInitialValues (ID); 
    } // }}}
    // Write
    void WriteNodes         (FEM::InputData const & ID, bool DoOverwrite=false); // Write Nodes
    void WriteFaces         (FEM::InputData const & ID, bool DoOverwrite=false); // Write Faces
    void WriteElements      (FEM::InputData const & ID, bool DoOverwrite=false); // Write Elements
    void WriteNodeBry       (FEM::InputData const & ID, bool DoOverwrite=false); // Write Stages.NodeBrys
    void WriteFaceBry       (FEM::InputData const & ID, bool DoOverwrite=false); // Write Stages.FaceBrys
    void WriteAttributes    (FEM::InputData const & ID, bool DoOverwrite=false); // Write Stages.Attribute
    void WriteInitialValues (FEM::InputData const & ID, bool DoOverwrite=false); // Write IniVals
    void WriteAllFiles      (FEM::InputData const & ID, bool DoOverwrite=false) // {{{
    {
        WriteNodes         (ID, DoOverwrite);
        WriteFaces         (ID, DoOverwrite);
        WriteElements      (ID, DoOverwrite); 
        WriteNodeBry       (ID, DoOverwrite); 
        WriteFaceBry       (ID, DoOverwrite); 
        WriteAttributes    (ID, DoOverwrite); 
        WriteInitialValues (ID, DoOverwrite); 
    } // }}}
    void WriteNodes         (String const & fnNODE, bool DoOverwrite=false); // Write Nodes
    void WriteFaces         (String const & fnFACE, bool DoOverwrite=false); // Write Faces
    void WriteElements      (String const & fnELE,  bool DoOverwrite=false); // Write Elements
    void WriteNodeBry       (String const & fnNBC,  bool DoOverwrite=false); // Write Stages.NodeBrys
    void WriteFaceBry       (String const & fnFBC,  bool DoOverwrite=false); // Write Stages.FaceBrys
    void WriteAttributes    (String const & fnATT,  bool DoOverwrite=false); // Write Stages.Attribute
    void WriteInitialValues (String const & fnINI,  bool DoOverwrite=false); // Write IniVals
    // Setup method
    void SetupDependentValues()
    {
        _fill_nodes_idx_info   (); // fill the idx to NodeBrys inside Stages struct for all nodes
        _fill_faces_idx_info   (); // fill the idx to FaceBrys inside Stages struct for all faces
        _fill_elements_idx_info(); // fill the idx to Attributes inside Stages struct for all elements
    }
public:
    // Public data
    Array<FilesData::Node>    Nodes;            // Array with nodes, according to file    .node
    Array<FilesData::Face>    Faces;            // Array with faces, according to file    .face
    Array<FilesData::Element> Elements;         // Array with elements, according to file .ele
    Array<FilesData::Element> EmbElements;      // Array with  embedded elements, according to file .ele
    Array<FilesData::Stage>   Stages;           // Array with stages, according to files: .nbc, .fbc and .att
private:
    // Functions
    void _fill_nodes_idx_info   (); // fill the idx to NodeBrys inside Stages struct for all nodes
    void _fill_faces_idx_info   (); // fill the idx to FaceBrys inside Stages struct for all faces
    void _fill_elements_idx_info(); // fill the idx to attribute inside Stages struct for all elements
}; // class FilesData

// -------------------------- Auxiliar structures (Node, Face, Element, BryCond, Attribute, Stage) {{{

struct FilesData::Node
{
    int  Num;     // Number tag
    REAL X;       // X coordinate
    REAL Y;       // Y coordinate
    REAL Z;       // Z coordinate
    int  BryMark; // Boundary mark according to .node file
    int  IdxBry;  // Index to the NodeBrys array inside a Stage structure. It is constant for all stages
                  // IdxBry==-1 => Boundary condition is NOT prescribed
};

struct FilesData::Face
{
    int        Num;
    Array<int> Connects;
    int        BryMark;
    int        OwnerElement;
    int        IdxBry; // Index to the FaceBrys array inside a Stage structure. It is constant for all stages
                       // IdxBry==-1 => Boundary condition is NOT prescribed
};

struct FilesData::Element
{
    int                 Num;
    Array<int>          Connects;
    int                 AttMark;
    int                 IdxAtt; // Index to the Attributes array inside a Stage structure. It is constant for all stages
    Array<Array<REAL> > IniVals;
};

struct FilesData::BryCond
{
    int           BryMark;
    Array<String> Names;
    Array<REAL>   Values;
};

struct FilesData::Attribute
{
    int         AttMark;
    String      EleName; 
    bool        IsActive;
    String      ModelName; 
    String      MatFilename;
    Array<REAL> Properties;
    Array<REAL> ModelPrms;
};

struct FilesData::Stage
{
    Array<BryCond>   NodeBrys;   // size=number of node bry marks
    Array<BryCond>   FaceBrys;   // size=number of face bry marks
    Array<Attribute> Attributes; // size=number of element attributes
};

// }}}

// ------------------------- operator << {{{
std::ostream & operator<< (std::ostream & os,       FilesData::Node  const & node);
std::ostream & operator<< (std::ostream & os, Array<FilesData::Node> const & nodes);

std::ostream & operator<< (std::ostream & os, FilesData::Element  const & ele);
std::ostream & operator<< (std::ostream & os, Array<FilesData::Element> const & eles);

std::ostream & operator<< (std::ostream & os,       FilesData::Face  const & face);
std::ostream & operator<< (std::ostream & os, Array<FilesData::Face> const & faces);

std::ostream & operator<< (std::ostream & os,       FilesData::BryCond  const & BC);
std::ostream & operator<< (std::ostream & os, Array<FilesData::BryCond> const & BCs);

std::ostream & operator<< (std::ostream & os,       FilesData::Attribute  const & Att);
std::ostream & operator<< (std::ostream & os, Array<FilesData::Attribute> const & Atts);

std::ostream & operator<< (std::ostream & os, Array<FilesData::Stage> const & S);
// }}}
 

bool operator== (FilesData::BryCond const & a, int const & b) // {{{
{
    return a.BryMark == b; 
} // }}}

bool operator== (FilesData::Attribute const & a, int const & b) // {{{
{
    return a.AttMark == b; 
} // }}}

inline void FilesData::ReadNodes(FEM::InputData const & ID) // {{{
{
    /* example.node {{{
    ################################################ .node
    12
    1   0   0   0   
    2   10  0   0
    3   10  10  0
    4   0   10  0
    5   0   0   5
    6   10  0   5
    7   10  10  5
    8   0   10  5
    9   0   0   10  -3
    10  10  0   10  -3
    11  10  10  10  -3
    12  0   10  10  -3
    }}} */

    // Open file
    FileParser FP(ID.fnNODE);

    // Number of nodes
    int n_nodes;
    FP.ReadNextValue(n_nodes);

    // Allocate and read nodes
    Nodes.resize(n_nodes);
    for (int i=0; i<n_nodes; ++i) 
    {
        // Read current line
        FP.JumpCommentsOrBlanks();
        String str_line = FP.GetCurrentLine(); FP.Advance();

        // Parse values
        LineParser LP(str_line);
        LP >> Nodes[i].Num >> Nodes[i].X >> Nodes[i].Y >> Nodes[i].Z;
        if (!(LP >> Nodes[i].BryMark)) Nodes[i].BryMark=0;

        // Multiply Coordinates by the CoordsMult scale factor 
        Nodes[i].X *= ID.CoordsMult;
        Nodes[i].Y *= ID.CoordsMult;
        Nodes[i].Z *= ID.CoordsMult;
    }
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadNodes: <" << n_nodes << "> nodes read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::ReadFaces(FEM::InputData const & ID) // {{{
{
    /* example.face {{{
    ################################################ .face
    3
    1  4   1   2   3   4  -1  2
    2  4   5   6   7   8  -2  2
    3  4   9   1  11  12  -3  2
    }}} */

    // Open file
    FileParser FP(ID.fnFACE);

    // Number of faces
    int n_faces;
    FP.ReadNextValue(n_faces);

    // Allocate and read faces
    Faces.resize(n_faces);
    for (int i=0; i<n_faces; ++i) 
    {
        // Read current line
        FP.JumpCommentsOrBlanks();
        String str_line = FP.GetCurrentLine(); FP.Advance();

        // Parse values
        LineParser LP(str_line);
        int n_connect_nodes;
        LP >> Faces[i].Num >> n_connect_nodes;
        Faces[i].Connects.resize(n_connect_nodes);
        for (int j=0; j<n_connect_nodes; ++j)
        {
            if (!(LP>>Faces[i].Connects[j])) throw new Fatal(_("FilesData::ReadFaces: <.face> Face # (%d) must have (%d) nodes connected"),i,j);
        }
        if (!(LP>>Faces[i].BryMark))      throw new Fatal(_("FilesData::ReadFaces: <.face> Face # (%d) must have a column for BryMark")     ,i);
        if (!(LP>>Faces[i].OwnerElement)) throw new Fatal(_("FilesData::ReadFaces: <.face> Face # (%d) must have a column for OwnerElement"),i);
    }
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadFaces: <" << n_faces << "> faces read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::ReadElements(FEM::InputData const & ID) // {{{
{
    /* example.ele {{{
    ################################################ .ele
    2
    1   8   1   2   3   4   5   6    7   8   -10
    2   8   5   6   7   8   9   10  11  12   -10
    }}} */

    // Open file
    FileParser FP(ID.fnELE);

    // Number of elements
    int n_elements;
    FP.ReadNextValue(n_elements);

    // Allocate and read elements
    Elements.resize(n_elements);
    for (int i=0; i<n_elements; ++i) 
    {
        // Read current line
        FP.JumpCommentsOrBlanks();
        String str_line = FP.GetCurrentLine(); FP.Advance();

        // Parse values
        LineParser LP(str_line);
        int n_connect_nodes;
        LP >> Elements[i].Num >> n_connect_nodes;
        Elements[i].Connects.resize(n_connect_nodes);
        for (int j=0; j<n_connect_nodes; ++j)
        {
            LP >> Elements[i].Connects[j];
        }
        LP >> Elements[i].AttMark;
    }
    
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadElements: <" << n_elements << "> elements read" << std::endl;
#endif // }}} 
    
    // reading for embedded elements {{{
    int n_emb_elements;
    bool has_embeddeds = false;
    try {
        FP.ReadNextValue(n_emb_elements);
        has_embeddeds = true;
    } 
    catch (Exception * e)
    {
        delete e;
    }
    
    if (has_embeddeds)
    {
        // Allocate and read elements
        EmbElements.resize(n_emb_elements);
        for (int i=0; i<n_emb_elements; ++i) 
        {
            // Read current line
            FP.JumpCommentsOrBlanks();
            String str_line = FP.GetCurrentLine(); FP.Advance();

            // Parse values
            LineParser LP(str_line);
            int n_connect_nodes;
            LP >> EmbElements[i].Num >> n_connect_nodes;
            EmbElements[i].Connects.resize(n_connect_nodes);
            for (int j=0; j<n_connect_nodes; ++j)
            {
                LP >> EmbElements[i].Connects[j];
            }
            LP >> EmbElements[i].AttMark;
        }
    } // }}}
    
} // }}}

inline void FilesData::ReadNodeBry(FEM::InputData const & ID) // {{{
{
    /* example.nbc {{{
    ################################################ .nbc
    2 # number of stages 
    3 # number of boundary marks
    
    1 # stage one
    -1  Dux=0  Duy=0  Duz=0 
    -2  Dux=0  Duy=0  
    -3  Dux=0  Duy=0  Dfz=-5
    
    2 # stage two 
    -1  Dux=0  Duy=0  Duz=0 
    -2  Dux=0  Duy=0  
    -3  Dux=0  Duy=0  Dfz=-10
    }}} */

    // Open file
    FileParser FP(ID.fnNBC);

    // Number of stages
    int n_stages;
    FP.ReadNextValue(n_stages);

    // Number of boundary marks
    int n_bry_marks;
    FP.ReadNextValue(n_bry_marks);

    // Allocate stages
    if (Stages.size()!=0)
    {
        if (Stages.size()!=static_cast<size_t>(n_stages))
            throw new Fatal(_("FilesData::ReadNodeBry: number of stages must be equal to (%d)"), Stages.size());
    }
    else
        Stages.resize(n_stages);

    // Check number of stages
    if (n_stages<ID.nSTAGES)
        throw new Fatal(_("FilesData::ReadNodeBry: number of stages must be greater than or equal to (NSTAGES=%d)"), ID.nSTAGES);

    // Exit if there is no boundary mark
    if (n_bry_marks==0) return;

    // Read stages
    for (int i=0; i<n_stages; ++i) 
    {
        // Number of current stage
        int i_stage_p1; // number of current stage plus one
        FP.ReadNextValue(i_stage_p1);

        // Allocate and read boundaries
        Array<BryCond> & BCs = Stages[i].NodeBrys;
        BCs.resize(n_bry_marks);
        
        // Loop along boundary information (marks)
        for (int j=0; j<n_bry_marks; ++j)
        {
            // Read current line
            FP.JumpCommentsOrBlanks();
            String str_line = FP.GetCurrentLine(); FP.Advance();

            // Remove '=' symbols
            LineParser LP(str_line);
            LP.ReplaceAllChars('=',' ');

            // Parse bry marks
            LP >> BCs[j].BryMark;
            String lvalue;
            REAL   rvalue;
            while (LP >> lvalue)
            {
                if (!(std::isalpha(lvalue[0])))
                    throw new Fatal(_("FilesData::ReadNodeBry: (.nbc) file format invalid: nBrys=%d Stage=%d BryMark=%d"), n_bry_marks, i+1, BCs[j].BryMark);
                if (!(LP >> rvalue))
                    throw new Fatal(_("FilesData::ReadNodeBry: (.nbc) file format invalid: nBrys=%d Stage=%d BryMark=%d"), n_bry_marks, i+1, BCs[j].BryMark);
                BCs[j].Names.push_back(lvalue);
                BCs[j].Values.push_back(rvalue);
            }
        }
    }

#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadNodeBry: <" << n_bry_marks << "> boundary marks read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::ReadFaceBry(FEM::InputData const & ID) // {{{
{
    /* example.fbc {{{
    ################################################ .fbc
    2 # two stages 
    3 # number of boundary marks

    1 # stage one
    -1  Dux=0  Duy=0  Duz=0 
    -2  Dux=0  Duy=0  
    -3  Dux=0  Duy=0  Dtz=-0.2

    2 # stage two 
    -1  Dux=0  Duy=0  Duz=0 
    -2  Dux=0  Duy=0  
    -3  Dux=0  Duy=0  Dtz=-10
    }}} */

    // Open file
    FileParser FP(ID.fnFBC);

    // Number of stages
    int n_stages;
    FP.ReadNextValue(n_stages);

    // Number of boundary marks
    int n_bry_marks;
    FP.ReadNextValue(n_bry_marks);

    // Allocate stages
    if (Stages.size()!=0)
    {
        if (Stages.size()!=static_cast<size_t>(n_stages))
            throw new Fatal(_("FilesData::ReadFaceBry: number of stages must be equal to (%d)"), Stages.size());
    }
    else
        Stages.resize(n_stages);

    // Check number of stages
    if (n_stages<ID.nSTAGES)
        throw new Fatal(_("FilesData::ReadFaceBry: number of stages must be greater than or equal to (NSTAGES=%d)"), ID.nSTAGES);

    // Exit if there is no boundary mark
    if (n_bry_marks==0) return;

    // Read stages
    for (int i=0; i<n_stages; ++i) 
    {
        // Number of current stage
        int i_stage_p1; // number of current stage plus one
        FP.ReadNextValue(i_stage_p1);

        // Allocate and read boundaries
        Array<BryCond> & BCs = Stages[i].FaceBrys;
        BCs.resize(n_bry_marks);
        
        // Loop along boundary information (marks)
        for (int j=0; j<n_bry_marks; ++j)
        {
            // Read current line
            FP.JumpCommentsOrBlanks();
            String str_line = FP.GetCurrentLine(); FP.Advance();

            // Remove '=' symbols
            LineParser LP(str_line);
            LP.ReplaceAllChars('=',' ');

            // Parse bry marks
            LP >> BCs[j].BryMark;
            String lvalue;
            REAL   rvalue;
            while (LP >> lvalue)
            {
                if (!(std::isalpha(lvalue[0])))
                    throw new Fatal(_("FilesData::ReadFaceBry: Invalid name (not alpha) for DOF key name. Stage=%d, BryMark=%d"), i+1, BCs[j].BryMark);
                if (!(LP >> rvalue))
                    throw new Fatal(_("FilesData::ReadFaceBry: Could not read rvalue for Stage=%d and BryMark=%d"), i+1, BCs[j].BryMark);
                BCs[j].Names.push_back(lvalue);
                BCs[j].Values.push_back(rvalue);
            }
        }
    }
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadFaceBry: <" << n_bry_marks << "> boundary marks read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::ReadAttributes(FEM::InputData const & ID) // {{{
{
    /* example.att {{{
    ################################################ .att
    2 # nuber of stages
    2 # number of attribute marks

    # stage attribute section
    1 # stage one
    -10 hex8_8 Active   Elastic fo1.mat 20 10
    -20 hex8_8 Active   Elastic fo1.mat 18 10

    2 # stage two
    -10 hex8_8 Active   Elastic fo1.mat 20 10
    -20 hex8_8 Inactive Elastic fo1.mat 18 10
    }}} */

    // Open file
    FileParser FP(ID.fnATT);

    // Number of stages
    int n_stages;
    FP.ReadNextValue(n_stages);

    // Number of attribute marks
    int n_att_marks;
    FP.ReadNextValue(n_att_marks);

    // Allocate stages
    if (Stages.size()!=0)
    {
        if (Stages.size()!=static_cast<size_t>(n_stages))
            throw new Fatal(_("FilesData::ReadAttributes: number of stages must be equal to (%d)"), Stages.size());
    }
    else
        Stages.resize(n_stages);

    // Check number of stages
    if (n_stages<ID.nSTAGES)
        throw new Fatal(_("FilesData::ReadAttributes: number of stages must be greater than or equal to (NSTAGES=%d)"), ID.nSTAGES);

    // Read stages
    for (int i=0; i<n_stages; ++i) 
    {
        // Number of current stage
        int i_stage_p1; // number of current stage plus one
        FP.ReadNextValue(i_stage_p1);

        // Allocate and read attributes
        Array<Attribute> & Atts = Stages[i].Attributes;
        Atts.resize(n_att_marks);
        
        // Loop along attributes data
        for (int j=0; j<n_att_marks; ++j)
        {
            // Read current line
            FP.JumpCommentsOrBlanks();
            String str_line = FP.GetCurrentLine(); FP.Advance();

            // Parse att marks
            LineParser LP(str_line);
            String str_active_inactive;
            LP >> Atts[j].AttMark >> Atts[j].EleName >> str_active_inactive >> Atts[j].ModelName >> Atts[j].MatFilename;
            REAL prop_value;
            while (LP>>prop_value) Atts[j].Properties.push_back(prop_value);
            if      ( str_active_inactive=="true"  )  Atts[j].IsActive = true;
            else if ( str_active_inactive=="false" )  Atts[j].IsActive = false;
            else
                throw new Fatal(_("FilesData::ReadAttributes: Active/Inactive word is invalid < %s >"), str_active_inactive.c_str());

            // Read material parameters
            /* example.mat // {{{
            ################################################ .mat
            #Desc    Fujinomori-Old OCR=1
            #MatKey  FO1
            #
            #---------------------------------------
            #          lam    kap   nu rcs    c  gam
            @SubCam 0.0891 0.0196 0.20 3.2 5000  2.0
            #
            #-------------------------------------------
            #           lam    kap   nu rcs    c      A
            @NSubCam  0.0891 0.0196 0.20 3.2 5000 -0.001
            }}} */
            std::ostringstream oss;
            oss << ID.fullPATH << Atts[j].MatFilename;
            FileParser matFP(oss.str());
            matFP.FindKeyAndFillArray(Atts[j].ModelName, Atts[j].ModelPrms);
        }
    }
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadAttributes: <" << n_att_marks << "> attribute marks read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::ReadInitialValues(FEM::InputData const & ID) // {{{
{
    /* example.ini {{{
    ################################################ .ini
    2
    1   4 { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } 
    2   4 { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } { 0 0 0 0 0 0 1.6 1 } 
    }}} */

    // Open file
    FileParser FP(ID.fnINI);

    // Number of elements
    int n_elements;
    FP.ReadNextValue(n_elements);
    if (static_cast<size_t>(n_elements)!=Elements.size())
        throw new Fatal(_("FilesData::ReadInitialValues: The number of elements inside (.ini) file must be equal to (%d)"),Elements.size());

    // Read initial values
    for (int i=0; i<n_elements; ++i) 
    {
        // Read current line
        FP.JumpCommentsOrBlanks();
        String str_line = FP.GetCurrentLine(); FP.Advance();

        // Parse values
        LineParser LP(str_line);
        int elem_num;
        int n_ini_data;
        LP.StructuredLine(elem_num, n_ini_data, Elements[i].IniVals);
    }
#ifdef DO_DEBUG // {{{ 
    std::cout << "FilesData::ReadInitialValues: <" << n_elements << "> elements initial values read" << std::endl;
#endif // }}} 
} // }}}

inline void FilesData::_fill_nodes_idx_info() // {{{
{
    if (Stages.size()>0)
    {
        // Declare a reference to the first stage (All stages must have the same attribute marks and boundary marks)
        FilesData::Stage const & S = Stages[0];

        // Loop along the number of nodes
        for (size_t i=0; i<Nodes.size(); ++i)
        {
            // Declare an iterator of Attribute inside Stages structure
            Array<FilesData::BryCond>::const_iterator it;

            // Index to the NodeBrys array inside a Stage structure. It is constant for all stages
            if (Nodes[i].BryMark==0)
                Nodes[i].IdxBry = -1;
            else
            {
                // Find inside the Stages.NodeBrys array an boundary mark equal to the node [i] boundary mark
                it = std::find(S.NodeBrys.begin(), S.NodeBrys.end(), Nodes[i].BryMark);
                if (it==S.NodeBrys.end())
                    throw new Fatal(_("FilesData::_fill_nodes_idx_info: Could not find NodeBryMark (%d) inside .nbc file"), Nodes[i].BryMark);
                Nodes[i].IdxBry = it-S.NodeBrys.begin();
            }
        }
    }
    else
        throw new Fatal(_("FilesData::_fill_nodes_idx_info: Stages.size() is not greater than 0"));
} // }}}

inline void FilesData::_fill_faces_idx_info() // {{{
{
    if (Stages.size()>0)
    {
        // Declare a reference to the first stage (All stages must have the same attribute marks and boundary marks)
        FilesData::Stage const & S = Stages[0];

        // Loop along the number of faces
        for (size_t i=0; i<Faces.size(); ++i)
        {
            // Declare an iterator of Attribute inside Stages structure
            Array<FilesData::BryCond>::const_iterator it;

            // Index to the FaceBrys array inside a Stage structure. It is constant for all stages
            if (Faces[i].BryMark==0)
                Faces[i].IdxBry = -1;
            else
            {
                // Find inside the Stages.FaceBrys array an boundary mark equal to the face [i] boundary mark
                it = std::find(S.FaceBrys.begin(), S.FaceBrys.end(), Faces[i].BryMark);
                if (it==S.FaceBrys.end())
                    throw new Fatal(_("FilesData::_fill_faces_idx_info: Could not find FaceBryMark (%d) .fbc file"), Faces[i].BryMark);
                Faces[i].IdxBry = it-S.FaceBrys.begin();
            }
        }
    }
    else
        throw new Fatal(_("FilesData::_fill_faces_idx_info: Stages.size() is not greater than 0"));
} // }}}

inline void FilesData::_fill_elements_idx_info() // {{{
{
    if (Stages.size()>0)
    {
        // Declare a reference to the first stage (All stages must have the same attribute marks and boundary marks)
        FilesData::Stage const & S = Stages[0];

        // Loop along the number of elements
        for (size_t i=0; i<Elements.size(); ++i)
        {
            // Declare an iterator of Attribute inside Stages structure
            Array<FilesData::Attribute>::const_iterator it;

            // Find inside the Stages.Attributes array an attribute equal to the element [i] boundary mark
            it = std::find(S.Attributes.begin(), S.Attributes.end(), Elements[i].AttMark);
            if (it==S.Attributes.end())
                throw new Fatal(_("FilesData::_fill_elements_idx_info: Could not find ElementAttMark (%d) inside .att file"), Elements[i].AttMark);

            // Index to the attributes array inside a Stage structure. It is constant for all stages
            Elements[i].IdxAtt = it-S.Attributes.begin();
        }
        
        // Loop along the number of embedded elements ------------------ embedded elements
        for (size_t i=0; i<EmbElements.size(); ++i)
        {
            // Declare an iterator of Attribute inside Stages structure
            Array<FilesData::Attribute>::const_iterator it;

            // Find inside the Stages.Attributes array an attribute equal to the element [i] boundary mark
            it = std::find(S.Attributes.begin(), S.Attributes.end(), EmbElements[i].AttMark);
            if (it==S.Attributes.end())
                throw new Fatal(_("FilesData::_fill_elements_idx_info: Could not find AttMark(.ele)="), EmbElements[i].AttMark, _(" inside Stages[0].Attributes(.att)"));

            // Index to the attributes array inside a Stage structure. It is constant for all stages
            EmbElements[i].IdxAtt = it-S.Attributes.begin();
        }
    }
    else
        throw new Fatal(_("FilesData::_fill_elements_idx_info: Stages.size() is not greater than 0"));
} // }}}

// -------------------------- operator<< {{{

std::ostream & operator<< (std::ostream & os, FilesData::Node const & node)
{
    os << _6()<< node.Num << _8s()<< node.X << _8s()<< node.Y << _8s()<< node.Z << _6()<< node.BryMark << _6()<< node.IdxBry << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::Node> const & nodes)
{
    os << _("Number of nodes = ") << nodes.size() << std::endl;
    for (size_t i=0; i<nodes.size(); ++i)
        os << nodes[i];
    return os;
}

std::ostream & operator<< (std::ostream & os, FilesData::Face  const & face)
{
    os << _6()<< face.Num << _6()<< face.Connects.size();
    for (size_t i=0; i<face.Connects.size(); ++i)
        os << _6()<< face.Connects[i];
    os << _6()<< face.BryMark << _6()<< face.OwnerElement << _6()<< face.IdxBry << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::Face> const & faces)
{
    os << _("Number of faces = ") << faces.size() << std::endl;
    for (size_t i=0; i<faces.size(); ++i)
        os << faces[i];
    return os;
}

std::ostream & operator<< (std::ostream & os, FilesData::Element  const & ele)
{
    os << _6()<< ele.Num << _6()<< ele.Connects.size();
    for (size_t i=0; i<ele.Connects.size(); ++i)
        os << _6()<< ele.Connects[i];
    os << _6()<< ele.AttMark << _6()<< ele.IdxAtt;

    for (size_t j=0; j<ele.IniVals.size(); ++j)
    {
        os << " { ";
        for (size_t k=0; k<ele.IniVals[j].size(); k++)
        {
            os << ele.IniVals[j][k] << " ";
        }
        os << "}  ";
    }
    os << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::Element> const & eles)
{
    os << _("Number of elements = ") << eles.size() << std::endl;
    for (size_t i=0; i<eles.size(); ++i)
        os << eles[i];
    return os;
}

std::ostream & operator<< (std::ostream & os, FilesData::BryCond const & BC)
{
    os << _6()<< BC.BryMark << " ";
    for (size_t i=0; i<BC.Names.size(); ++i)
    {
        os << BC.Names[i] << "=" << BC.Values[i];
        if (i!=BC.Names.size()-1) os << " ";
    }
    os << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::BryCond> const & BCs)
{
    os << _("Number of boundary conditions = ") << BCs.size() << std::endl;
    for (size_t i=0; i<BCs.size(); ++i)
        os << "     " << BCs[i];
    return os;
}

std::ostream & operator<< (std::ostream & os, FilesData::Attribute  const & Att)
{
    os << _6()<< Att.AttMark << Att.EleName << _a() << Att.IsActive << Att.ModelName << Att.MatFilename;
    // Properties
    std::cout << " { ";
    for (size_t i=0; i<Att.Properties.size(); ++i)
        os << _8s()<< Att.Properties[i];
    // Parameters
    std::cout << " } ";
    for (size_t i=0; i<Att.ModelPrms.size(); ++i)
        os << _8s()<< Att.ModelPrms[i];
    os << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::Attribute> const & Atts)
{
    os << _("Number of attributes = ") << Atts.size() << std::endl;
    for (size_t i=0; i<Atts.size(); ++i)
        os << "     " << Atts[i];
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FilesData::Stage> const & S)
{
    os << _("Number of stages = ") << S.size() << std::endl;

    // NodeBrys
    os << _("   Node boundary conditions:\n");
    for (size_t i=0; i<S.size(); ++i)
        os << "      " << S[i].NodeBrys;

    // FaceBrys
    os << _("   Face boundary conditions:\n");
    for (size_t i=0; i<S.size(); ++i)
        os << "      " << S[i].FaceBrys;

    // Attributes
    os << _("   Element attributes:\n");
    for (size_t i=0; i<S.size(); ++i)
        os << "      " << S[i].Attributes;

    return os;
}

// }}}
 
inline void FilesData::WriteNodes(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteNodes(ID.fnNODE, DoOverwrite);
} // }}}

inline void FilesData::WriteNodes(String const & fnNODE, bool DoOverwrite) // {{{
{
    // Check if MainFilename exists
    if (!DoOverwrite)
        if (FileParser::CheckForFile(fnNODE))
            throw new Warning(_("File < %s > exists"), fnNODE.c_str());

    // Open file for output
    std::ofstream OF(fnNODE.GetSTL().c_str(), std::ios::out);

    // Write
    OF << "################################################### .node\n";
    OF << Nodes.size() << " # number of nodes\n";
    for (size_t i=0; i<Nodes.size(); ++i) 
    {
        OF << Nodes[i].Num << _8s()<< Nodes[i].X << _8s()<< Nodes[i].Y << _8s()<< Nodes[i].Z;
        if (Nodes[i].BryMark!=0) OF << "  " << Nodes[i].BryMark;
        OF << std::endl;
    }

    // Close
    OF.close();
} // }}}

inline void FilesData::WriteFaces(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteFaces(ID.fnFACE, DoOverwrite);
} // }}}

inline void FilesData::WriteFaces(String const & fnFACE, bool DoOverwrite) // {{{
{
    // Check if MainFilename exists
    if (!DoOverwrite)
        if (FileParser::CheckForFile(fnFACE))
            throw new Warning(_("File < %s > exists"), fnFACE.c_str());

    // Open file for output
    std::ofstream OF(fnFACE.GetSTL().c_str(), std::ios::out);

    // Write
    OF << "################################################### .face\n";
    OF << Faces.size() << " # number of faces\n";
    for (size_t i=0; i<Faces.size(); ++i) 
    {
        OF << Faces[i].Num << "  " << Faces[i].Connects.size() << "  ";
        for (size_t j=0; j<Faces[i].Connects.size(); ++j)
            OF << Faces[i].Connects[j] << " ";
        OF << " " << Faces[i].BryMark << "  " << Faces[i].OwnerElement << std::endl;
    }

    // Close
    OF.close();
} // }}}

inline void FilesData::WriteElements(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteElements(ID.fnELE, DoOverwrite);
} // }}}

inline void FilesData::WriteElements(String const & fnELE, bool DoOverwrite) // {{{
{
    // Check if MainFilename exists
    if (!DoOverwrite)
        if (FileParser::CheckForFile(fnELE))
            throw new Warning(_("File < %s > exists"), fnELE.c_str());

    // Open file for output
    std::ofstream OF(fnELE.GetSTL().c_str(), std::ios::out);

    // Write
    OF << "################################################### .ele\n";
    OF << Elements.size() << " # number of elements\n";
    for (size_t i=0; i<Elements.size(); ++i) 
    {
        OF << Elements[i].Num << "  " << Elements[i].Connects.size() << "  ";
        for (size_t j=0; j<Elements[i].Connects.size(); ++j)
            OF << Elements[i].Connects[j] << " ";
        OF << " " << Elements[i].AttMark << std::endl;
    }

    // Close
    OF.close();
} // }}}

inline void FilesData::WriteNodeBry(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteNodeBry(ID.fnNBC, DoOverwrite);
} // }}}

inline void FilesData::WriteNodeBry(String const & fnNBC, bool DoOverwrite) // {{{
{
    if (Stages.size()>0)
    {
        // Check if MainFilename exists
        if (!DoOverwrite)
            if (FileParser::CheckForFile(fnNBC))
                throw new Warning(_("File < %s > exists"), fnNBC.c_str());

        // Open file for output
        std::ofstream OF(fnNBC.GetSTL().c_str(), std::ios::out);

        // Write
        OF << "################################################### .nbc\n";
        OF << Stages.size()             << " # number of stages\n";
        OF << Stages[0].NodeBrys.size() << " # number of boundary marks\n";
        OF << std::endl;
        for (size_t i=0; i<Stages.size(); ++i) 
        {
            OF << i+1 << " # stage\n";
            Array<BryCond> & BCs = Stages[i].NodeBrys;
            for (size_t j=0; j<BCs.size(); ++j)
            {
                OF << BCs[j].BryMark << "  ";
                for (size_t k=0; k<BCs[j].Names.size(); ++k)
                    OF << BCs[j].Names[k] << "=" << BCs[j].Values[k] << " ";
                OF << std::endl;
            }
            OF << std::endl;
        }

        // Close
        OF.close();
    }
    else
        throw new Fatal(_("FilesData::WriteNodeBry: Stages.size() is not greater than 0"));
} // }}}

inline void FilesData::WriteFaceBry(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteFaceBry(ID.fnFBC, DoOverwrite);
} // }}}

inline void FilesData::WriteFaceBry(String const & fnFBC, bool DoOverwrite) // {{{
{
    if (Stages.size()>0)
    {
        // Check if MainFilename exists
        if (!DoOverwrite)
            if (FileParser::CheckForFile(fnFBC))
                throw new Warning(_("File < %s > exists"), fnFBC.c_str());

        // Open file for output
        std::ofstream OF(fnFBC.GetSTL().c_str(), std::ios::out);

        // Write
        OF << "################################################### .fbc\n";
        OF << Stages.size()             << " # number of stages\n";
        OF << Stages[0].FaceBrys.size() << " # number of boundary marks\n";
        OF << std::endl;
        for (size_t i=0; i<Stages.size(); ++i) 
        {
            OF << i+1 << " # stage\n";
            Array<BryCond> & BCs = Stages[i].FaceBrys;
            for (size_t j=0; j<BCs.size(); ++j)
            {
                OF << BCs[j].BryMark << "  ";
                for (size_t k=0; k<BCs[j].Names.size(); ++k)
                    OF << BCs[j].Names[k] << "=" << BCs[j].Values[k] << " ";
                OF << std::endl;
            }
            OF << std::endl;
        }

        // Close
        OF.close();
    }
    else
        throw new Fatal(_("FilesData::WriteFaceBry: Stages.size() is not greater than 0"));
} // }}}

inline void FilesData::WriteAttributes(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteAttributes(ID.fnATT, DoOverwrite);
} // }}}

inline void FilesData::WriteAttributes(String const & fnATT, bool DoOverwrite) // {{{
{
    if (Stages.size()>0)
    {
        // Check if MainFilename exists
        if (!DoOverwrite)
            if (FileParser::CheckForFile(fnATT))
                throw new Warning(_("File < %s > exists"), fnATT.c_str());

        // Open file for output
        std::ofstream OF(fnATT.GetSTL().c_str(), std::ios::out);

        // Write
        OF << "################################################### .att\n";
        OF << Stages.size()               << " # number of stages\n";
        OF << Stages[0].Attributes.size() << " # number of attributes\n";
        OF << std::endl;
        for (size_t i=0; i<Stages.size(); ++i) 
        {
            OF << i+1 << " # stage\n";
            Array<Attribute> & Atts = Stages[i].Attributes;
            for (size_t j=0; j<Atts.size(); ++j)
            {
                OF << Atts[j].AttMark <<"  "<< Atts[j].EleName <<" "<< _a()<<Atts[j].IsActive <<" "<< Atts[j].ModelName <<" "<< Atts[j].MatFilename <<" ";
                for (size_t k=0; k<Atts[j].Properties.size(); ++k)
                    OF << Atts[j].Properties[k] << " ";
                OF << std::endl;
            }
            OF << std::endl;
        }

        // Close
        OF.close();
    }
    else
        throw new Fatal(_("FilesData::WriteAttributes: Stages.size() is not greater than 0"));
} // }}}

inline void FilesData::WriteInitialValues(FEM::InputData const & ID, bool DoOverwrite) // {{{
{
    WriteInitialValues(ID.fnINI, DoOverwrite);
} // }}}

inline void FilesData::WriteInitialValues(String const & fnINI, bool DoOverwrite) // {{{
{
    // Check if MainFilename exists
    if (!DoOverwrite)
        if (FileParser::CheckForFile(fnINI))
            throw new Warning(_("File < %s > exists"), fnINI.c_str());

    // Open file for output
    std::ofstream OF(fnINI.GetSTL().c_str(), std::ios::out);

    // Write
    OF << "################################################### .ini\n";
    OF << Elements.size() << " # number of elements\n";
    for (size_t i=0; i<Elements.size(); ++i) 
    {
        OF << Elements[i].Num << " " << Elements[i].IniVals.size();
        for (size_t j=0; j<Elements[i].IniVals.size(); ++j)
        {
            OF << " { ";
            for (size_t k=0; k<Elements[i].IniVals[j].size(); ++k)
                OF << Elements[i].IniVals[j][k] << " ";
            OF << " } ";
        }
        OF << std::endl;
    }

    // Close
    OF.close();
} // }}}

}; // namespace FEM

#endif // MECHSYS_FEM_FILESDATA_H

// vim:fdm=marker

---