node.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_NODE_H
#define MECHSYS_FEM_NODE_H

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

#include <map>
#include <sstream>

#include "util/array.h"
#include "util/string.h"
#include "util/exception.h"
#include "util/numstreams.h"
#include "fem/node.h"

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

namespace FEM
{

class Node
{
    friend std::ostream & operator<< (std::ostream & os, FEM::Node const & node);
public:
    Node() : _has_essential_vector(false), _has_natural_vector(false) {}
    struct DOFVarsStruct
    {
        REAL EssentialBry; // EssentialBry (U)
        REAL NaturalBry;   // NaturalBry (F)
        bool IsEssenPresc; // Is EssentialBry Prescribed?
        int  EqID;         // Position inside the system of equations
        REAL EssentialVal; // Essential value for the current state of this node
        REAL NaturalVal;   // Natural value for the current state of this node
        REAL _IncEssenVal; // (internal) In:  A given increment of essential value (temporary) Communication between Solver and Element
        REAL _IncNaturVal; // (internal) Out: A given increment of natural value (temporary) Communication between Solver and Element
        bool EssenPrescPersist; // Auxiliar variable only to perform persistent prescribed essential values of pwp (=0) on surfece after excavations (thats ugly and other solution must be reached in future)
    };
    // Methods
    void Initialize(int Number, REAL X, REAL Y, REAL Z);        // Initializes coordinates
    void ClearDOF();
    void AddDOF(String const & StrEssentialBry, String const & StrNaturalBry);
    bool IsEssential(String const & Name) const;
    bool HasVar     (String const & Name) const;
    DOFVarsStruct       & DOFVar(String const & Name);
    DOFVarsStruct const & DOFVar(String const & Name) const;
    Array<Node::DOFVarsStruct> & DOFVars() { return _dof_vars; }
    std::string OutMap();
    int  Number() const { return _number; }
    REAL X() const { return _x; }
    REAL Y() const { return _y; }
    REAL Z() const { return _z; }
    int & Refs() { return _refs; };
    int const & Refs() const { return _refs; };
    void ClearBryValues() // Just boundary information => do NOT change EssentialVal and NaturalVal (U and F values)
    {
        for (size_t i=0; i<_dof_vars.size(); ++i)
        {
            // Default => (ux=?,fx=0,False,-1)
            _dof_vars[i].EssentialBry = 0.0;
              _dof_vars[i].NaturalBry = 0.0;
            _dof_vars[i].IsEssenPresc = false;
                    _dof_vars[i].EqID = -1;
            if (_dof_vars[i].EssenPrescPersist) _dof_vars[i].IsEssenPresc = true; // that is ugly (other solution must be reached for pwp after excavations)
        }
    }
    String Out(bool PrintCaptionOnly=false) const;
    // Vectors
    void SetEssentialVector (String const & UX, String const & UY, String const & UZ);
    void SetNaturalVector   (String const & FX, String const & FY, String const & FZ);
    void OutEssentialVector (String & Str) const;
    void OutNaturalVector   (String & Str) const;
    bool HasEssentialVector () const { return _has_essential_vector; }
    bool HasNaturalVector   () const { return _has_natural_vector;   }
    int  nDOF() const { return _dof_vars.size(); }
private:
    // Auxiliar structures
    struct DOFInfo
    {
        size_t ArrayPos;    // Position inside the array of DOF variables
        bool   IsEssential; // Is essential? false => natural
    };
    // Data
    int  _number;
    int  _refs;
    REAL _x;
    REAL _y;
    REAL _z;
    std::map<String, DOFInfo, std::less<String> > _dof_map;
    Array<DOFVarsStruct>                          _dof_vars;
    // Vectors
    String _UX;
    String _UY;
    String _UZ;
    String _FX;
    String _FY;
    String _FZ;
    bool   _has_essential_vector;
    bool   _has_natural_vector;
}; // class Node

std::ostream & operator<< (std::ostream & os, FEM::Node::DOFVarsStruct const & Vars);
std::ostream & operator<< (std::ostream & os, Array<FEM::Node::DOFVarsStruct> const & AVars);
std::ostream & operator<< (std::ostream & os, FEM::Node const & node);
std::ostream & operator<< (std::ostream & os, Array<FEM::Node> const & nodes);




inline void Node::Initialize(int Number, REAL X, REAL Y, REAL Z) // {{{
{
    _number = Number;
    _x = X;
    _y = Y;
    _z = Z;
    _refs = 0;
}

// }}}

inline void Node::ClearDOF()
{
    _dof_vars.resize(0);
    _dof_map.clear();
}

inline void Node::AddDOF(String const & StrEssentialBry, String const & StrNaturalBry) // {{{
{
    // Check if StrEssentialBry was not already added
    if (_dof_map.find(StrEssentialBry)==_dof_map.end())
    {
        // Get initial size of _dof_map
        size_t n_dof = _dof_map.size()/2;

        // Add EssentialBry DOF to DOFMap
        DOFInfo          dof_info = {n_dof,true}; // {ArrayPos,IsEssential}
        _dof_map[StrEssentialBry] = dof_info;

        // Add NaturalBry DOF to DOFMap
              dof_info.ArrayPos = n_dof;
           dof_info.IsEssential = false;
        _dof_map[StrNaturalBry] = dof_info;

        // Setup _dof_vars (Degree of Freedom nodal variables). IEP=Is Essential Prescribed?
        DOFVarsStruct dof_struct = {0,0,false,-1,0,0,0,0,false}; // {u_bry,f_bry,IEP,EqID,U,F,dU,dF}   Default => (ux=?,fx=0,false,-1,0,0,0,0)
        _dof_vars.push_back(dof_struct);
    }
}

// }}}

inline bool Node::IsEssential(String const & Name) const // {{{
{
    std::map<String, DOFInfo>::const_iterator it = _dof_map.find(Name);
    if (it==_dof_map.end())
        throw new Fatal(_("Node::IsEssential: Could not find DOF variable name < %s > inside Node"), Name.c_str());
    return it->second.IsEssential;
}

// }}}

inline bool Node::HasVar(String const & Name) const // {{{
{
    std::map<String, DOFInfo>::const_iterator it = _dof_map.find(Name);
    if (it==_dof_map.end()) return false;
    return true;
}

// }}}

inline Node::DOFVarsStruct & Node::DOFVar(String const & Name) // {{{
{
    // Find Name
    std::map<String, DOFInfo>::const_iterator it = _dof_map.find(Name);
    if (it==_dof_map.end())
        throw new Fatal(_("Node::DOFVarsStruct: Node coords=<%.6f; %.6f; %.6f>. Could not find DOF variable name < %s > inside Node"), _x, _y, _z, Name.c_str());

    // Return a reference to a DOFVarsStruct
    return _dof_vars[ it->second.ArrayPos ];
}

// }}}

inline Node::DOFVarsStruct const & Node::DOFVar(String const & Name) const // {{{
{
    // Find Name
    std::map<String, DOFInfo>::const_iterator it = _dof_map.find(Name);
    if (it==_dof_map.end())
        throw new Fatal(_("Node::DOFVarsStruct: Node coords=<%.6f; %.6f; %.6f>. Could not find DOF variable name < %s > inside Node"), _x, _y, _z, Name.c_str());

    // Return a reference to a DOFVarsStruct
    return _dof_vars[ it->second.ArrayPos ];
}

// }}}

inline std::string Node::OutMap() // {{{
{
    std::ostringstream oss;
    std::map<String, DOFInfo>::const_iterator it;
    for (it=_dof_map.begin(); it!=_dof_map.end(); ++it)
    {
        oss << _6()<< it->first << _8s()<< it->second.ArrayPos << _a()<< it->second.IsEssential << std::endl;
    }
    return oss.str();
}

// }}}

inline String Node::Out(bool PrintCaptionOnly) const // {{{
{
    // Auxiliar variables
    std::ostringstream oss;
    std::map<String, DOFInfo>::const_iterator it;

    // Print caption
    if (PrintCaptionOnly)
    {
        // Print essential var name
        for (it=_dof_map.begin(); it!=_dof_map.end(); ++it)
            if (it->second.IsEssential==true)
                oss << _8s()<< it->first;

        // Print natural var name
        for (it=_dof_map.begin(); it!=_dof_map.end(); ++it)
            if (it->second.IsEssential==false)
                oss << _8s()<< it->first;

        oss << std::endl;
    }
    else
    {
        // Print essential values
        for (it=_dof_map.begin(); it!=_dof_map.end(); ++it)
            if (it->second.IsEssential==true)
                oss << _8s()<< _dof_vars[ it->second.ArrayPos ].EssentialVal ;

        // Print natural values
        for (it=_dof_map.begin(); it!=_dof_map.end(); ++it)
            if (it->second.IsEssential==false)
                oss << _8s()<< _dof_vars[ it->second.ArrayPos ].NaturalVal ;

        oss << std::endl;
    }

    return oss.str(); 
} // }}}

inline void Node::SetEssentialVector(String const & UX, String const & UY, String const & UZ) // {{{
{
    _UX = UX;
    _UY = UY;
    _UZ = UZ;
    _has_essential_vector = true;
} // }}}

inline void Node::SetNaturalVector(String const & FX, String const & FY, String const & FZ) // {{{
{
    _FX = FX;
    _FY = FY;
    _FZ = FZ;
    _has_natural_vector = true;
} // }}}

inline void Node::OutEssentialVector(String & Str) const // {{{
{
    if (_has_essential_vector)
    {
        std::map<String, DOFInfo>::const_iterator it;
        it=_dof_map.find(_UX); REAL ux=_dof_vars[ it->second.ArrayPos ].EssentialVal;
        it=_dof_map.find(_UY); REAL uy=_dof_vars[ it->second.ArrayPos ].EssentialVal;
        it=_dof_map.find(_UZ); REAL uz=_dof_vars[ it->second.ArrayPos ].EssentialVal;
        Str.Printf(_(" %e %e %e "),ux,uy,uz);
    }
    else Str.Printf(_(" 0 0 0 "));

} // }}}

inline void Node::OutNaturalVector(String & Str) const // {{{
{
    if (_has_natural_vector)
    {
        std::map<String, DOFInfo>::const_iterator it;
        it=_dof_map.find(_FX); REAL fx=_dof_vars[ it->second.ArrayPos ].NaturalVal;
        it=_dof_map.find(_FY); REAL fy=_dof_vars[ it->second.ArrayPos ].NaturalVal;
        it=_dof_map.find(_FZ); REAL fz=_dof_vars[ it->second.ArrayPos ].NaturalVal;
        Str.Printf(_(" %e %e %e "),fx,fy,fz);
    }
    else Str.Printf(_(" 0 0 0 "));
    
} // }}}

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

std::ostream & operator<< (std::ostream & os, FEM::Node::DOFVarsStruct const & V)
{
    os << _8s()<< V.EssentialBry << _8s()<< V.NaturalBry << _a()<< V.IsEssenPresc << _6()<< V.EqID << _8s()<< V.EssentialVal << _8s()<< V.NaturalVal;
    return os;
}

std::ostream & operator<< (std::ostream & os, Array<FEM::Node::DOFVarsStruct> const & AVars)
{
    for (size_t i=0; i<AVars.size(); ++i)
        os << AVars[i] << std::endl;
    return os;
}

std::ostream & operator<< (std::ostream & os, FEM::Node const & node)
{
    os << _8s()<< node._x << _8s()<< node._y << _8s()<< node._z << std::endl;
    for (size_t i=0; i<node._dof_vars.size(); ++i)
    {
        os << node._dof_vars[i];
        if (i!=node._dof_vars.size()-1) os << std::endl;
    }
    os << std::endl;
    return os;
}

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

// }}}

}; //namespace FEM

#endif // MECHSYS_FEM_NODE_H

// vim:fdm=marker

---