genel_.cc

Go to the documentation of this file.

/* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/elec/genel_.cc,v 1.15 2017/01/12 14:46:22 masarati Exp $ */
/*
 * MBDyn (C) is a multibody analysis code.
 * http://www.mbdyn.org
 *
 * Copyright (C) 1996-2017
 *
 * Pierangelo Masarati  <masarati@aero.polimi.it>
 * Paolo Mantegazza     <mantegazza@aero.polimi.it>
 *
 * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
 * via La Masa, 34 - 20156 Milano, Italy
 * http://www.aero.polimi.it
 *
 * Changing this copyright notice is forbidden.
 *
 * This program 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 (version 2 of the License).
 *
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "mbconfig.h"           /* This goes first in every *.c,*.cc file */

#include "dataman.h"
#include "genel_.h"

/* GenelClamp - begin */

GenelClamp::GenelClamp(unsigned int uLabel,
        const DofOwner* pDO,
        const DriveCaller* pDC,
        const ScalarDof& sd,
        flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
DriveOwner(pDC), SD(sd), dRct(0.)
{
        NO_OP;
}

GenelClamp::~GenelClamp(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

unsigned int
GenelClamp::iGetNumDof(void) const
{
        return 1;
}

/* esegue operazioni sui dof di proprieta' dell'elemento */
DofOrder::Order
GenelClamp::GetDofType(unsigned int i) const
{
        ASSERT(i == 0);
        return DofOrder::ALGEBRAIC;
}

/* esegue operazioni sui dof di proprieta' dell'elemento */
DofOrder::Order
GenelClamp::GetEqType(unsigned int i) const
{
        ASSERT(i == 0);
        return DofOrder::ALGEBRAIC;
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelClamp::Restart(std::ostream& out) const
{
        return out;
}

/* Tipo di Genel */
Genel::Type
GenelClamp::GetGenelType(void) const
{
        return Genel::CLAMP;
}

/* Dimensioni del workspace */
void
GenelClamp::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 2;
        *piNumCols = 2;
}

void
GenelClamp::Output(OutputHandler& OH ) const
{
        if (bToBeOutput()) {
                std::ostream& out = OH.Genels();
                out << std::setw(8) << GetLabel() << " " << dRct << std::endl;
        }
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelClamp::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelClamp::AssJac()" << std::endl);

        SparseSubMatrixHandler& WM = WorkMat.SetSparse();
        WM.Resize(2, 0);

        integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
        integer iColIndex = SD.pNode->iGetFirstColIndex() + 1;
        integer iFirstReactionIndex = iGetFirstIndex() + 1;

        WM.PutItem(1, iRowIndex, iFirstReactionIndex, 1.);
        WM.PutItem(2, iFirstReactionIndex, iColIndex, 1.);

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelClamp::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelClamp::AssRes()" << std::endl);

        WorkVec.Resize(2);

        integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
        integer iFirstReactionIndex = iGetFirstIndex() + 1;

        doublereal dVal = SD.pNode->dGetDofValue(1, SD.iOrder);
        dRct = XCurr(iFirstReactionIndex);

        WorkVec.PutItem(1, iRowIndex, -dRct);

        doublereal dConstr = dGet() - dVal;
        if (SD.iOrder == 0
                && SD.pNode->GetDofType(0) == DofOrder::DIFFERENTIAL
                && dCoef != 0.)
        {
                dConstr /= dCoef;
        }
        WorkVec.PutItem(2, iFirstReactionIndex, dConstr);

        return WorkVec;
}

void
GenelClamp::SetValue(DataManager *pDM,
        VectorHandler& X, VectorHandler& XP,
        SimulationEntity::Hints *ph)
{
        if (SD.iOrder == 0) {
                X.PutCoef(SD.pNode->iGetFirstRowIndex() + 1, dGet());
        } else if (SD.iOrder == 1) {
                XP.PutCoef(SD.pNode->iGetFirstRowIndex() + 1, dGet());
        }
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelClamp::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(1);
        connectedNodes[0] = SD.pNode;
}
/* ************************************************ */

/* GenelClamp - end */


/* GenelDistance - begin */

GenelDistance::GenelDistance(unsigned int uLabel,
        const DofOwner* pDO,
        const DriveCaller* pDC,
        const ScalarDof& sd1,
        const ScalarDof& sd2,
        flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
DriveOwner(pDC), SD1(sd1), SD2(sd2), dRct(0.)
{
        NO_OP;
}

GenelDistance::~GenelDistance(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD1.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }

        pn2s = dynamic_cast<const Node2Scalar *>(SD2.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

unsigned int
GenelDistance::iGetNumDof(void) const
{
        return 1;
}

DofOrder::Order
GenelDistance::GetDofType(unsigned int i ) const
{
        ASSERT(i == 0);
        return DofOrder::ALGEBRAIC;
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelDistance::Restart(std::ostream& out) const
{
        return out;
}

/* Tipo di Genel */
Genel::Type
GenelDistance::GetGenelType(void) const
{
        return Genel::DISTANCE;
}

/* Dimensioni del workspace */
void
GenelDistance::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 3;
        *piNumCols = 3;
}

void
GenelDistance::Output(OutputHandler& OH) const
{
        if (bToBeOutput()) {
                std::ostream& out = OH.Genels();
                out << std::setw(8) << GetLabel() << " " << dRct << std::endl;
        }
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelDistance::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelDistance::AssJac()" << std::endl);

        SparseSubMatrixHandler& WM = WorkMat.SetSparse();
        WM.ResizeReset(4, 0);

        integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
        integer iNode1ColIndex = SD1.pNode->iGetFirstColIndex() + 1;
        integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
        integer iNode2ColIndex = SD2.pNode->iGetFirstColIndex() + 1;
        integer iFirstReactionIndex = iGetFirstIndex() + 1;

        WM.PutItem(1, iNode1RowIndex, iFirstReactionIndex, -1.);
        WM.PutItem(2, iNode2RowIndex, iFirstReactionIndex, 1.);

        doublereal d = dCoef;
        if ((SD1.iOrder == 0) && (SD2.iOrder == 0)) {
                d = 1.;
        }

        if (SD1.iOrder == 1) {
                WM.PutItem(3, iFirstReactionIndex, iNode1ColIndex, -1.);
        } else {
                WM.PutItem(3, iFirstReactionIndex, iNode1ColIndex, -d);
        }

        if (SD2.iOrder == 1) {
                WM.PutItem(4, iFirstReactionIndex, iNode2ColIndex, 1.);
        } else {
                WM.PutItem(4, iFirstReactionIndex, iNode2ColIndex, d);
        }

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelDistance::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelDistance::AssRes()" << std::endl);

        WorkVec.ResizeReset(3);

        integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
        integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
        integer iFirstReactionIndex = iGetFirstIndex() + 1;

        doublereal dVal1 = SD1.pNode->dGetDofValue(1, SD1.iOrder);
        doublereal dVal2 = SD2.pNode->dGetDofValue(1, SD2.iOrder);
        dRct = XCurr(iFirstReactionIndex);

        WorkVec.PutItem(1, iNode1RowIndex, dRct);
        WorkVec.PutItem(2, iNode2RowIndex, -dRct);

        if ((SD1.iOrder == 0) && (SD2.iOrder == 0)) {
                ASSERT(dCoef != 0.);
                WorkVec.PutItem(3, iFirstReactionIndex,
                        (dGet() - dVal2 + dVal1)/dCoef);

        } else {
                WorkVec.PutItem(3, iFirstReactionIndex, dGet() - dVal2 + dVal1);
        }

        return WorkVec;
}

void
GenelDistance::SetValue(DataManager *pDM,
        VectorHandler& X, VectorHandler& XP,
        SimulationEntity::Hints *ph)
{
        if (SD2.iOrder == 0) {
                X.PutCoef(SD2.pNode->iGetFirstRowIndex() + 1,
                        dGet() - SD2.pNode->dGetX()
                        + SD1.pNode->dGetDofValue(1, SD1.iOrder));
        } else if (SD2.iOrder == 1) {
                XP.PutCoef(SD2.pNode->iGetFirstRowIndex() + 1,
                        dGet() - SD2.pNode->dGetXPrime()
                        + SD1.pNode->dGetDofValue(1, SD1.iOrder));
        }
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelDistance::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(2);
        connectedNodes[0] = SD1.pNode;
        connectedNodes[1] = SD2.pNode;
}
/* ************************************************ */

/* GenelDistance - end */


/* GenelSpring - begin */

GenelSpring::GenelSpring(unsigned int uLabel,
        const DofOwner* pDO,
        const ConstitutiveLaw1D* pCL,
        const ScalarDof& sd1,
        const ScalarDof& sd2,
        flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
ConstitutiveLaw1DOwner(pCL), SD1(sd1), SD2(sd2), dVal(0.)
{
        NO_OP;
}

GenelSpring::~GenelSpring(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD1.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }

        pn2s = dynamic_cast<const Node2Scalar *>(SD2.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelSpring::Restart(std::ostream& out) const
{
        return out;
}

void
GenelSpring::AfterConvergence(const VectorHandler& X,
        const VectorHandler& XP)
{
        ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
}

/* Tipo di Genel */
Genel::Type
GenelSpring::GetGenelType(void) const
{
        return Genel::SPRING;
}

/* Dimensioni del workspace */
void
GenelSpring::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 2;
        *piNumCols = 2;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelSpring::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpring::AssJac()" << std::endl);

        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(2, 2);

        integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex() + 1;
        integer iNode1ColIndex = SD1.pNode->iGetFirstColIndex() + 1;
        integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex() + 1;
        integer iNode2ColIndex = SD2.pNode->iGetFirstColIndex() + 1;

        WM.PutRowIndex(1, iNode1RowIndex);
        WM.PutColIndex(1, iNode1ColIndex);
        WM.PutRowIndex(2, iNode2RowIndex);
        WM.PutColIndex(2, iNode2ColIndex);

        doublereal dFDE = GetFDE();

        if (SD1.iOrder == 1) {
                WM.PutCoef(1, 1, dFDE);
                WM.PutCoef(2, 1, -dFDE);
        } else {
                WM.PutCoef(1, 1, dFDE*dCoef);
                WM.PutCoef(2, 1, -dFDE*dCoef);
        }

        if (SD2.iOrder == 1) {
                WM.PutCoef(1, 2, -dFDE);
                WM.PutCoef(2, 2, dFDE);
        } else {
                WM.PutCoef(1, 2, -dFDE*dCoef);
                WM.PutCoef(2, 2, dFDE*dCoef);
        }

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelSpring::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpring::AssRes()" << std::endl);

        WorkVec.ResizeReset(2);

        integer iNode1RowIndex = SD1.pNode->iGetFirstRowIndex()+1;
        integer iNode2RowIndex = SD2.pNode->iGetFirstRowIndex()+1;

        doublereal dVal1 = SD1.pNode->dGetDofValue(1, SD1.iOrder);
        doublereal dVal2 = SD2.pNode->dGetDofValue(1, SD2.iOrder);

        dVal = dVal2 - dVal1;
        ConstitutiveLaw1DOwner::Update(dVal, 0.);

        doublereal d = GetF();

        WorkVec.PutItem(1, iNode1RowIndex, d);
        WorkVec.PutItem(2, iNode2RowIndex, -d);

        return WorkVec;
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelSpring::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(2);
        connectedNodes[0] = SD1.pNode;
        connectedNodes[1] = SD2.pNode;
}
/* ************************************************ */

/* GenelSpring - end */


/* GenelSpringSupport - begin */

GenelSpringSupport::GenelSpringSupport(unsigned int uLabel,
        const DofOwner* pDO,
        const ConstitutiveLaw1D* pCL,
        const ScalarDof& sd, doublereal X0, flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
ConstitutiveLaw1DOwner(pCL), SD(sd), dVal(0.), dInitVal(X0)
{
        ASSERT(SD.iOrder == 0);
}

GenelSpringSupport::~GenelSpringSupport(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelSpringSupport::Restart(std::ostream& out) const
{
        return out;
}

void
GenelSpringSupport::AfterConvergence(const VectorHandler& X,
        const VectorHandler& XP)
{
        ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
}

/* Tipo di Genel */
Genel::Type
GenelSpringSupport::GetGenelType(void) const
{
        return Genel::SPRINGSUPPORT;
}

/* Dimensioni del workspace */
void
GenelSpringSupport::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 1;
        *piNumCols = 1;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelSpringSupport::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpringSupport::AssJac()" << std::endl);

        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(1, 1);

        integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
        integer iNodeColIndex = SD.pNode->iGetFirstColIndex() + 1;

        WM.PutRowIndex(1, iNodeRowIndex);
        WM.PutColIndex(1, iNodeColIndex);

        WM.PutCoef(1, 1, GetFDE()*dCoef);

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelSpringSupport::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpringSupport::AssRes()" << std::endl);

        WorkVec.ResizeReset(1);

        integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;

        dVal = SD.pNode->dGetX() - dInitVal;
        ConstitutiveLaw1DOwner::Update(dVal, 0.);

        WorkVec.PutItem(1, iNodeRowIndex, -GetF());

        return WorkVec;
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelSpringSupport::GetConnectedNodes(
        std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(1);
        connectedNodes[0] = SD.pNode;
}

unsigned int GenelSpringSupport::iGetNumPrivData(void) const
{
        return 2u;
}

unsigned int GenelSpringSupport::iGetPrivDataIdx(const char *s) const
{
        if (0 == strcmp(s, "F")) {
                return 1u;
        }

        if (0 == strcmp(s, "X")) {
                return 2u;
        }

        silent_cerr("genel(" << GetLabel() << "): private data \"" << s << "\" not available" << std::endl);
        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
}

doublereal GenelSpringSupport::dGetPrivData(unsigned int i) const
{
        switch (i) {
        case 1u:
                return GetF();
        case 2u:
                return dVal;
        default:
                silent_cerr("genel(" << GetLabel() << "): private data index " << i << " out of range" << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
}
/* ************************************************ */

/* GenelSpringSupport - end */


/* GenelCrossSpringSupport - begin */

GenelCrossSpringSupport::GenelCrossSpringSupport(unsigned int uLabel,
        const DofOwner* pDO,
        const ConstitutiveLaw1D* pCL,
        const ScalarDof& sdrow,
        const ScalarDof& sdcol,
        flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
ConstitutiveLaw1DOwner(pCL),
SDRow(sdrow), SDCol(sdcol), dVal(0.)
{
        ASSERT(SDCol.iOrder == 0);
}

GenelCrossSpringSupport::~GenelCrossSpringSupport(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SDRow.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }

        pn2s = dynamic_cast<const Node2Scalar *>(SDCol.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelCrossSpringSupport::Restart(std::ostream& out) const
{
        return out;
}

void
GenelCrossSpringSupport::AfterConvergence(const VectorHandler& X,
        const VectorHandler& XP)
{
        ConstitutiveLaw1DOwner::AfterConvergence(dVal, 0.);
}

/* Tipo di Genel */
Genel::Type
GenelCrossSpringSupport::GetGenelType(void) const
{
        return Genel::CROSSSPRINGSUPPORT;
}

/* Dimensioni del workspace */
void
GenelCrossSpringSupport::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 1;
        *piNumCols = 1;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelCrossSpringSupport::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelCrossSpringSupport::AssJac()" << std::endl);

        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(1, 1);

        integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;
        integer iNodeColIndex = SDCol.pNode->iGetFirstColIndex() + 1;

        WM.PutRowIndex(1, iNodeRowIndex);
        WM.PutColIndex(1, iNodeColIndex);

        WM.PutCoef(1, 1, GetFDE()*dCoef);

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelCrossSpringSupport::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelCrossSpringSupport::AssRes()" << std::endl);

        WorkVec.ResizeReset(1);

        integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex()+1;

        dVal = SDCol.pNode->dGetX();
        ConstitutiveLaw1DOwner::Update(dVal, 0.);

        WorkVec.PutItem(1, iNodeRowIndex, -GetF());

        return WorkVec;
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelCrossSpringSupport::GetConnectedNodes(
        std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(2);
        connectedNodes[0] = SDRow.pNode;
        connectedNodes[1] = SDCol.pNode;
}
/* ************************************************ */

/* GenelCrossSpringSupport - end */


/* GenelCrossSpringDamperSupport - begin */

GenelCrossSpringDamperSupport::GenelCrossSpringDamperSupport(
        unsigned int uLabel, const DofOwner* pDO,
        const ConstitutiveLaw1D* pCL,
        const ScalarDof& sdrow,
        const ScalarDof& sdcol,
        flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
ConstitutiveLaw1DOwner(pCL), SDRow(sdrow), SDCol(sdcol),
dVal(0.), dValPrime(0.)
{
        ASSERT(SDCol.iOrder == 0);
}

GenelCrossSpringDamperSupport::~GenelCrossSpringDamperSupport(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SDRow.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }

        pn2s = dynamic_cast<const Node2Scalar *>(SDCol.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelCrossSpringDamperSupport::Restart(std::ostream& out) const
{
        return out;
}

void
GenelCrossSpringDamperSupport::AfterConvergence(const VectorHandler& X,
        const VectorHandler& XP)
{
        ConstitutiveLaw1DOwner::AfterConvergence(dVal, dValPrime);
}

/* Tipo di Genel */
Genel::Type
GenelCrossSpringDamperSupport::GetGenelType(void) const
{
        return Genel::CROSSSPRINGDAMPERSUPPORT;
}

/* Dimensioni del workspace */
void
GenelCrossSpringDamperSupport::WorkSpaceDim(integer* piNumRows,
        integer* piNumCols) const
{
        *piNumRows = 1;
        *piNumCols = 1;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelCrossSpringDamperSupport::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelCrossSpringDamperSupport::AssJac()" << std::endl);

        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(1, 1);

        integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;
        integer iNodeColIndex = SDCol.pNode->iGetFirstColIndex() + 1;

        WM.PutRowIndex(1, iNodeRowIndex);
        WM.PutColIndex(1, iNodeColIndex);

        WM.PutCoef(1, 1, GetFDE()*dCoef+GetFDEPrime());

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelCrossSpringDamperSupport::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelCrossSpringDamperSupport::AssRes()" << std::endl);

        WorkVec.ResizeReset(1);

        integer iNodeRowIndex = SDRow.pNode->iGetFirstRowIndex() + 1;

        dVal = SDCol.pNode->dGetX();
        dValPrime = SDCol.pNode->dGetXPrime();
        ConstitutiveLaw1DOwner::Update(dVal, dValPrime);

        WorkVec.PutItem(1, iNodeRowIndex, -GetF());

        return WorkVec;
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelCrossSpringDamperSupport::GetConnectedNodes(
        std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(2);
        connectedNodes[0] = SDRow.pNode;
        connectedNodes[1] = SDCol.pNode;
}
/* ************************************************ */

/* GenelCrossSpringDamperSupport - end */


/* GenelSpringDamperSupport - begin */

GenelSpringDamperSupport::GenelSpringDamperSupport(unsigned int uLabel,
        const DofOwner* pDO,
        const ConstitutiveLaw1D* pCL,
        const ScalarDof& sd, doublereal X0, flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
ConstitutiveLaw1DOwner(pCL),
SD(sd), dVal(0.), dInitVal(X0), dValPrime(0.)
{
        ASSERT(sd.pNode->GetDofType(0) == DofOrder::DIFFERENTIAL);
        ASSERT(sd.iOrder == 0);
}

GenelSpringDamperSupport::~GenelSpringDamperSupport(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelSpringDamperSupport::Restart(std::ostream& out) const
{
        return out;
}

void
GenelSpringDamperSupport::AfterConvergence(const VectorHandler& X,
        const VectorHandler& XP)
{
        ConstitutiveLaw1DOwner::AfterConvergence(dVal, dValPrime);
}

/* Tipo di Genel */
Genel::Type
GenelSpringDamperSupport::GetGenelType(void) const
{
        return Genel::SPRINGDAMPERSUPPORT;
}

/* Dimensioni del workspace */
void
GenelSpringDamperSupport::WorkSpaceDim(integer* piNumRows,
        integer* piNumCols) const
{
        *piNumRows = 1;
        *piNumCols = 1;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelSpringDamperSupport::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpringDamperSupport::AssJac()" << std::endl);

        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(1, 1);

        integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
        integer iNodeColIndex = SD.pNode->iGetFirstColIndex() + 1;

        WM.PutRowIndex(1, iNodeRowIndex);
        WM.PutColIndex(1, iNodeColIndex);

        WM.PutCoef(1, 1, GetFDE()*dCoef + GetFDEPrime());

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelSpringDamperSupport::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelSpringDamperSupport::AssRes()" << std::endl);

        WorkVec.ResizeReset(1);

        integer iNodeRowIndex = SD.pNode->iGetFirstRowIndex()+1;

        dVal = SD.pNode->dGetX() - dInitVal;
        dValPrime = SD.pNode->dGetXPrime();

        ConstitutiveLaw1DOwner::Update(dVal, dValPrime);

        WorkVec.PutItem(1, iNodeRowIndex, -GetF());

        return WorkVec;
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelSpringDamperSupport::GetConnectedNodes(
        std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(1);
        connectedNodes[0] = SD.pNode;
}
/* ************************************************ */

/* GenelSpringDamperSupport - end */


/* GenelMass - begin */

GenelMass::GenelMass(unsigned int uLabel,
        const DofOwner* pDO, const DriveCaller* pDC,
        const ScalarDof& sd, flag fOutput)
: Elem(uLabel, fOutput),
Genel(uLabel, pDO, fOutput),
DriveOwner(pDC), SD(sd)
{
        NO_OP;
}

GenelMass::~GenelMass(void)
{
        const Node2Scalar *pn2s;

        pn2s = dynamic_cast<const Node2Scalar *>(SD.pNode);
        if (pn2s) {
                SAFEDELETE(pn2s);
        }
}

unsigned int
GenelMass::iGetNumDof(void) const
{
        return 1;
}

/* esegue operazioni sui dof di proprieta' dell'elemento */
DofOrder::Order
GenelMass::GetDofType(unsigned int i ) const
{
        ASSERT(i == 0);
        return DofOrder::DIFFERENTIAL;
}

/* Scrive il contributo dell'elemento al file di restart */
std::ostream&
GenelMass::Restart(std::ostream& out) const
{
        return out;
}

/* Tipo di Genel */
Genel::Type
GenelMass::GetGenelType(void) const
{
        return Genel::MASS;
}

/* Dimensioni del workspace */
void
GenelMass::WorkSpaceDim(integer* piNumRows, integer* piNumCols) const
{
        *piNumRows = 2;
        *piNumCols = 2;
}

/* assemblaggio jacobiano */
VariableSubMatrixHandler&
GenelMass::AssJac(VariableSubMatrixHandler& WorkMat,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelMass::AssJac()" << std::endl);

        SparseSubMatrixHandler& WM = WorkMat.SetSparse();
        WM.ResizeReset(3, 0);

        integer iRowIndex = SD.pNode->iGetFirstRowIndex() + 1;
        integer iColIndex = SD.pNode->iGetFirstColIndex() + 1;
        integer iDerivativeIndex = iGetFirstIndex() + 1;

        WM.PutItem(1, iRowIndex, iDerivativeIndex, dGet());
        WM.PutItem(2, iDerivativeIndex, iColIndex, -1.);
        WM.PutItem(3, iDerivativeIndex, iDerivativeIndex, dCoef);

        return WorkMat;
}

/* assemblaggio residuo */
SubVectorHandler&
GenelMass::AssRes(SubVectorHandler& WorkVec,
        doublereal dCoef,
        const VectorHandler& XCurr,
        const VectorHandler& XPrimeCurr)
{
        DEBUGCOUT("Entering GenelMass::AssRes()" << std::endl);

        WorkVec.ResizeReset(2);

        integer iRowIndex = SD.pNode->iGetFirstRowIndex()+1;
        integer iDerivativeIndex = iGetFirstIndex()+1;

        doublereal dVal = SD.pNode->dGetXPrime();
        doublereal dDer = XCurr(iDerivativeIndex);
        doublereal dDerPrime = XPrimeCurr(iDerivativeIndex);

        WorkVec.PutItem(1, iRowIndex, -dGet()*dDerPrime);
        WorkVec.PutItem(2, iDerivativeIndex, dVal - dDer);

        return WorkVec;
}

void
GenelMass::SetValue(DataManager *pDM,
        VectorHandler& X, VectorHandler& XP,
        SimulationEntity::Hints *ph)
{
        X.PutCoef(iGetFirstIndex() + 1, SD.pNode->dGetXPrime());
}

/* *******PER IL SOLUTORE PARALLELO******** */
/* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
 * utile per l'assemblaggio della matrice di connessione fra i dofs */
void
GenelMass::GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
        connectedNodes.resize(1);
        connectedNodes[0] = SD.pNode;
}
/* ************************************************ */

/* GenelMass - end */