#include <strmappingext.h>

Inheritance diagram for StructMappingExtForce:

Collaboration diagram for StructMappingExtForce:

Classes
struct	NodeData

struct	OffsetData

Public Member Functions
	StructMappingExtForce (unsigned int uL, DataManager pDM, const StructNode pRefNode, bool bUseReferenceNodeForces, bool bRotateReferenceNodeForces, std::vector< const StructDispNode * > &Nodes, std::vector< Vec3 > &Offsets, std::vector< unsigned > &Labels, SpMapMatrixHandler pH, std::vector< uint32_t > &MappedLabels, bool bLabels, bool bOutputAccelerations, unsigned uRRot, ExtFileHandlerBase pEFH, bool bSendAfterPredict, int iCoupling, flag fOut)

virtual	~StructMappingExtForce (void)

virtual Force::Type	GetForceType (void) const

void	WorkSpaceDim (integer piNumRows, integer piNumCols) const

SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	Output (OutputHandler &OH) const

virtual void	GetConnectedNodes (std::vector< const Node * > &connectedNodes) const

Public Member Functions inherited from Elem
	Elem (unsigned int uL, flag fOut)

virtual	~Elem (void)

virtual unsigned int	iGetNumDof (void) const

virtual std::ostream &	DescribeDof (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeDof (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual std::ostream &	DescribeEq (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeEq (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual DofOrder::Order	GetDofType (unsigned int) const

virtual void	AssMats (VariableSubMatrixHandler &WorkMatA, VariableSubMatrixHandler &WorkMatB, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual bool	bInverseDynamics (void) const

void	SetInverseDynamicsFlags (unsigned uIDF)

unsigned	GetInverseDynamicsFlags (void) const

bool	bIsErgonomy (void) const

bool	bIsRightHandSide (void) const

virtual VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)

virtual SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)

virtual int	GetNumConnectedNodes (void) const

Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")

virtual	~WithLabel (void)

void	PutLabel (unsigned int uL)

void	PutName (const std::string &sN)

unsigned int	GetLabel (void) const

const std::string &	GetName (void) const

Public Member Functions inherited from SimulationEntity
	SimulationEntity (void)

virtual	~SimulationEntity (void)

virtual bool	bIsValidIndex (unsigned int i) const

virtual DofOrder::Order	GetEqType (unsigned int i) const

virtual Hint *	ParseHint (DataManager pDM, const char s) const

virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const

virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

virtual unsigned int	iGetNumPrivData (void) const

virtual unsigned int	iGetPrivDataIdx (const char *s) const

virtual doublereal	dGetPrivData (unsigned int i) const

virtual std::ostream &	OutputAppend (std::ostream &out) const

virtual void	ReadInitialState (MBDynParser &HP)

Public Member Functions inherited from ToBeOutput
	ToBeOutput (flag fOut=fDefaultOut)

virtual	~ToBeOutput (void)

virtual void	OutputPrepare (OutputHandler &OH)

virtual void	Output (OutputHandler &OH, const VectorHandler &X, const VectorHandler &XP) const

virtual flag	fToBeOutput (void) const

virtual bool	bToBeOutput (void) const

virtual void	SetOutputFlag (flag f=flag(1))

Public Member Functions inherited from ExtForce
	ExtForce (unsigned int uL, DataManager pDM, ExtFileHandlerBase pEFH, bool bSendAfterPredict, int iCoupling, flag fOut)

virtual	~ExtForce (void)

virtual void	SetValue (DataManager pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints h=0)

virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)

virtual void	AfterPredict (VectorHandler &X, VectorHandler &XP)

virtual void	InitialWorkSpaceDim (integer piNumRows, integer piNumCols) const

virtual VariableSubMatrixHandler &	InitialAssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)

virtual SubVectorHandler &	InitialAssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr)

Public Member Functions inherited from Force
	Force (unsigned int uL, flag fOut)

virtual	~Force (void)

virtual Elem::Type	GetElemType (void) const

virtual VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, doublereal, const VectorHandler &, const VectorHandler &)

virtual std::ostream &	Restart (std::ostream &out) const

virtual unsigned int	iGetInitialNumDof (void) const

Public Member Functions inherited from InitialAssemblyElem
	InitialAssemblyElem (unsigned int uL, flag fOut)

virtual	~InitialAssemblyElem (void)

Public Member Functions inherited from SubjectToInitialAssembly
	SubjectToInitialAssembly (void)

virtual	~SubjectToInitialAssembly (void)

Protected Member Functions
bool	Prepare (ExtFileHandlerBase *pEFH)

void	Send (ExtFileHandlerBase *pEFH, ExtFileHandlerBase::SendWhen when)

void	Recv (ExtFileHandlerBase *pEFH)

virtual void	SendToStream (std::ostream &outf, ExtFileHandlerBase::SendWhen when)

virtual void	SendToFileDes (int outfd, ExtFileHandlerBase::SendWhen when)

virtual void	RecvFromStream (std::istream &inf)

virtual void	RecvFromFileDes (int infd)

Protected Member Functions inherited from ExtForce
void	Send (ExtFileHandlerBase::SendWhen when)

void	Recv (void)

Protected Attributes
const StructNode *	pRefNode

bool	bUseReferenceNodeForces

bool	bRotateReferenceNodeForces

Vec3	F0

Vec3	M0

Vec3	F1

Vec3	M1

Vec3	F2

Vec3	M2

SpMapMatrixHandler *	pH

unsigned	m_uResSize

std::vector< NodeData >	Nodes

unsigned	uPoints

unsigned	uMappedPoints

bool	bLabels

bool	bOutputAccelerations

unsigned	uRRot

std::vector< uint32_t >	m_qlabels

STLVectorHandler	m_x

STLVectorHandler	m_xP

STLVectorHandler	m_xPP

STLVectorHandler	m_q

STLVectorHandler	m_qP

STLVectorHandler	m_qPP

STLVectorHandler	m_f

STLVectorHandler	m_p

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Protected Attributes inherited from ExtForce
Converged	c

ExtFileHandlerBase *	pEFH

bool	bSendAfterPredict

int	iCoupling

int	iCouplingCounter

bool	bFirstSend

bool	bFirstRecv

Additional Inherited Members
Public Types inherited from Elem
enum	Type { UNKNOWN = -1, AIRPROPERTIES = 0, INDUCEDVELOCITY, AUTOMATICSTRUCTURAL, GRAVITY, BODY, JOINT, JOINT_REGULARIZATION, BEAM, PLATE, FORCE, INERTIA, ELECTRICBULK, ELECTRIC, THERMAL, HYDRAULIC, BULK, LOADABLE, DRIVEN, EXTERNAL, AEROMODAL, AERODYNAMIC, GENEL, SOCKETSTREAM_OUTPUT, RTAI_OUTPUT = SOCKETSTREAM_OUTPUT, LASTELEMTYPE }

Public Types inherited from SimulationEntity
typedef std::vector< Hint * >	Hints

Public Types inherited from ToBeOutput
enum	{ OUTPUT = 0x1U, OUTPUT_MASK = 0xFU, OUTPUT_PRIVATE = 0x10U, OUTPUT_PRIVATE_MASK = ~OUTPUT_MASK }

Public Types inherited from ExtForce
enum	{ COUPLING_NONE = -2, COUPLING_STAGGERED = -1, COUPLING_LOOSE = 0, COUPLING_TIGHT = 1 }

Public Types inherited from Force
enum	Type { UNKNOWN = -1, ABSTRACTFORCE = 0, ABSTRACTINTERNALFORCE, ABSOLUTEDISPFORCE, ABSOLUTEINTERNALDISPFORCE, ABSOLUTEFORCE, FOLLOWERFORCE, ABSOLUTECOUPLE, FOLLOWERCOUPLE, ABSOLUTEINTERNALFORCE, FOLLOWERINTERNALFORCE, ABSOLUTEINTERNALCOUPLE, FOLLOWERINTERNALCOUPLE, TOTALFORCE, TOTALINTERNALFORCE, EXTERNALSTRUCTURAL, MODALFORCE, EXTERNALMODAL, LASTFORCETYPE }

Detailed Description

Definition at line 46 of file strmappingext.h.

Constructor & Destructor Documentation

StructMappingExtForce::StructMappingExtForce	(	unsigned int	uL,
		DataManager *	pDM,
		const StructNode *	pRefNode,
		bool	bUseReferenceNodeForces,
		bool	bRotateReferenceNodeForces,
		std::vector< const StructDispNode * > &	Nodes,
		std::vector< Vec3 > &	Offsets,
		std::vector< unsigned > &	Labels,
		SpMapMatrixHandler *	pH,
		std::vector< uint32_t > &	MappedLabels,
		bool	bLabels,
		bool	bOutputAccelerations,
		unsigned	uRRot,
		ExtFileHandlerBase *	pEFH,
		bool	bSendAfterPredict,
		int	iCoupling,
		flag	fOut
	)

Definition at line 47 of file strmappingext.cc.

References ASSERT, WithLabel::GetLabel(), SparseMatrixHandler::iGetNumCols(), SparseMatrixHandler::iGetNumRows(), m_qPP, m_uResSize, m_xPP, MBC_ROT_EULER_123, MBC_ROT_MAT, MBC_ROT_THETA, MBDYN_EXCEPT_ARGS, Nodes, uMappedPoints, uPoints, and Zero3.

 : Elem(uL, fOut), 
 ExtForce(uL, pDM, pEFH, bSendAfterPredict, iCoupling, fOut), 
 pRefNode(pRefNode),
 bUseReferenceNodeForces(bUseReferenceNodeForces),
 bRotateReferenceNodeForces(bRotateReferenceNodeForces),
 F0(Zero3), M0(Zero3),
 F1(Zero3), M1(Zero3),
 F2(Zero3), M2(Zero3),
 pH(pH),
 m_uResSize(0),
 uPoints(nodes.size()),
 uMappedPoints(pH ? unsigned(pH->iGetNumRows())/3 : 0),
 bLabels(bLabels),
 bOutputAccelerations(bOutputAccelerations),
 uRRot(uRRot),
 m_qlabels(pH ? mappedlabels : labels),
 m_x(3*uPoints),
 m_xP(3*uPoints),
 m_xPP(0),
 m_q(3*uMappedPoints),
 m_qP(3*uMappedPoints),
 m_qPP(0),
 m_f(3*uPoints),
 m_p(3*uMappedPoints)
 {
         ASSERT(nodes.size() == offsets.size());
         if (pH) {
                 ASSERT(3*uPoints == unsigned(pH->iGetNumCols()));
                 ASSERT(3*uMappedPoints == unsigned(pH->iGetNumRows()));
         }
 
         if (pRefNode) {
                 switch (uRRot) {
                 case MBC_ROT_THETA:
                 case MBC_ROT_MAT:
                 case MBC_ROT_EULER_123:
                         break;
 
                 default:
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "invalid reference node rotation type " << uRRot << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 if (bUseReferenceNodeForces) {
                         m_uResSize += 6;
                 }
         }
 
         const StructDispNode *pNode = 0;
         unsigned uNodes = 0;
         std::vector<const StructDispNode *>::const_iterator p;
         for (p = nodes.begin(); p != nodes.end(); ++p) {
                 if (*p != pNode) {
                         pNode = *p;
                         uNodes++;
                 }
         }
 
         Nodes.resize(uNodes);
         p = nodes.begin();
         std::vector<const StructDispNode *>::const_iterator pPrev = p;
         std::vector<NodeData>::iterator n = Nodes.begin();
         while (true) {
                 ++p;
                 if ((p == nodes.end()) || (*p != *pPrev)) {
                         n->pNode = *pPrev;
                         n->Offsets.resize(p - pPrev);
                         for (std::vector<OffsetData>::iterator i = n->Offsets.begin(); i != n->Offsets.end(); ++i) {
                                 i->Offset = ::Zero3;
                         }
                         n->F = Zero3;
                         n->M = Zero3;
 
                         if (dynamic_cast<const StructNode *>(n->pNode) == 0) {
                                 switch (n->Offsets.size()) {
                                 case 1:         // regular rotationless node
                                 case 2:         // special rotationless node for "membrane"
                                         break;
 
                                 default:
                                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                                 "too many offsets for StructDispNode(" << n->pNode->GetLabel() << ")"
                                                 << std::endl);
                                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                 }
 
                                 m_uResSize += 3;
 
                         } else {
                                 m_uResSize += 6;
                         }
 
                         if (p == nodes.end()) {
                                 break;
                         }
 
                         ++n;
                         pPrev = p;
                 }
         }
 
         unsigned uPts = 0;
         n = Nodes.begin();
         std::vector<Vec3>::const_iterator o = offsets.begin();
         std::vector<uint32_t>::iterator l = labels.begin();
         for (; o != offsets.end(); ++o, uPts++) {
                 if (uPts == n->Offsets.size()) {
                         ++n;
                         uPts = 0;
 
                         if (dynamic_cast<const StructNode *>(n->pNode) == 0) {
                                 for (std::vector<StructMappingExtForce::OffsetData>::const_iterator i = n->Offsets.begin();
                                         i != n->Offsets.end(); i++)
                                 {
                                         if (!i->Offset.IsNull()) {
                                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                                         "offset #" << (i - n->Offsets.begin())
                                                         << " (" << i->Offset << ") "
                                                         "for StructDispNode(" << n->pNode->GetLabel() << ") is not zero"
                                                         << std::endl);
                                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                         }
                                 }
                         }
                 }
 
                 // FIXME: pass labels
                 n->Offsets[uPts].uLabel = unsigned(-1);
                 n->Offsets[uPts].Offset = *o;
                 n->Offsets[uPts].F = Zero3;
 
                 if (bLabels) {
                         n->Offsets[uPts].uLabel = *l;
                         ++l;
                 }
         }
 
         if (bOutputAccelerations) {
                 for (unsigned i = 0; i < nodes.size(); i++) {
                         const DynamicStructDispNode *pDSN = dynamic_cast<const DynamicStructDispNode *>(Nodes[i].pNode);
                         if (pDSN == 0) {
                                 silent_cerr("StructMappingExtForce"
                                         "(" << GetLabel() << "): "
                                         "StructNode(" << Nodes[i].pNode->GetLabel() << ") "
                                         "is not dynamic"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
 
                         const_cast<DynamicStructDispNode *>(pDSN)->ComputeAccelerations(true);
                 }
 
                 m_xPP.resize(3*uPoints);
                 m_qPP.resize(3*uMappedPoints);
                 
         }
 }

Here is the call graph for this function:

StructMappingExtForce::~StructMappingExtForce ( void )

virtual

Definition at line 223 of file strmappingext.cc.

References NO_OP.

 {
         NO_OP;
 }

Member Function Documentation

SubVectorHandler & StructMappingExtForce::AssRes	(	SubVectorHandler &	WorkVec,
		doublereal	dCoef,
		const VectorHandler &	XCurr,
		const VectorHandler &	XPrimeCurr
	)

virtual

Implements Elem.

Definition at line 987 of file strmappingext.cc.

References VectorHandler::Add(), ASSERT, bRotateReferenceNodeForces, ToBeOutput::bToBeOutput(), bUseReferenceNodeForces, ExtForce::COUPLING_NONE, grad::Cross(), F0, F1, F2, StructNode::GetRCurr(), StructDispNode::GetXCurr(), ExtForce::iCoupling, StructDispNode::iGetFirstMomentumIndex(), M0, M1, M2, m_uResSize, Nodes, pRefNode, SubVectorHandler::PutRowIndex(), ExtForce::Recv(), VectorHandler::Resize(), VectorHandler::ResizeReset(), and Zero3.

 {
         ExtForce::Recv();
 
         if (iCoupling == COUPLING_NONE) {
                 WorkVec.Resize(0);
                 return WorkVec;
         }
 
 
         if (pRefNode) {
                 integer iSize(0);
 
                 WorkVec.ResizeReset(m_uResSize);
 
                 const Vec3& xRef = pRefNode->GetXCurr();
                 const Mat3x3& RRef = pRefNode->GetRCurr();
 
                 // manipulate
                 if (bUseReferenceNodeForces) {
                         if (bRotateReferenceNodeForces) {
                                 F1 = RRef*F0;
                                 M1 = RRef*M0;
 
                         } else {
                                 F1 = F0;
                                 M1 = M0;
                         }
                 }
 
                 F2 = Zero3;
                 M2 = Zero3;
                 for (unsigned n = 0; n < Nodes.size(); n++) {
                         integer iFirstIndex = Nodes[n].pNode->iGetFirstMomentumIndex();
                         integer iDim;
 
                         WorkVec.Add(iSize + 1, Nodes[n].F);
                         if (dynamic_cast<const StructNode *>(Nodes[n].pNode)) {
                                 WorkVec.Add(iSize + 4, Nodes[n].M);
                                 iDim = 6;
 
                         } else {
                                 iDim = 3;
                         }
 
                         for (int r = 1; r <= iDim; r++) {
                                 WorkVec.PutRowIndex(iSize + r, iFirstIndex + r);
                         }
 
                         if (bUseReferenceNodeForces || bToBeOutput()) {
                                 // compute Global Reference Node Forces, even if they are not used, for output only :)
                                 F2 += Nodes[n].F;
                                 M2 += Nodes[n].M + (Nodes[n].pNode->GetXCurr() - xRef).Cross(Nodes[n].F);
                         }
 
                         iSize += iDim;
                 }
 
                 if (bUseReferenceNodeForces) {
                         integer iFirstIndex = pRefNode->iGetFirstMomentumIndex();
                         for (int r = 1; r <= 6; r++) {
                                 WorkVec.PutRowIndex(iSize + r, iFirstIndex + r);
                         }
 
                         F1 -= F2;
                         M1 -= M2;
                         WorkVec.Add(iSize + 1, F1);
                         WorkVec.Add(iSize + 4, M1);
 
                         iSize += 6;
                 }
 
                 ASSERT(iSize == m_uResSize);
 
         } else {
                 integer iSize(0);
 
                 WorkVec.ResizeReset(m_uResSize);
 
                 for (unsigned n = 0; n < Nodes.size(); n++) {
                         integer iFirstIndex = Nodes[n].pNode->iGetFirstMomentumIndex();
                         integer iDim;
 
                         WorkVec.Add(iSize + 1, Nodes[n].F);
                         if (dynamic_cast<const StructNode *>(Nodes[n].pNode)) {
                                 WorkVec.Add(iSize + 4, Nodes[n].M);
                                 iDim = 6;
 
                         } else {
                                 iDim = 3;
                         }
 
                         for (int r = 1; r <= iDim; r++) {
                                 WorkVec.PutRowIndex(iSize + r, iFirstIndex + r);
                         }
 
                         iSize += iDim;
                 }
 
                 ASSERT(iSize == m_uResSize);
         }
 
         return WorkVec;
 }

Here is the call graph for this function:

void StructMappingExtForce::GetConnectedNodes ( std::vector< const Node * > & connectedNodes ) const

virtual

Reimplemented from Elem.

Definition at line 1126 of file strmappingext.cc.

References Nodes, and pRefNode.

 {
         unsigned n = Nodes.size();
         if (pRefNode) {
                 n++;
         }
         connectedNodes.resize(n);
 
         for (n = 0; n < Nodes.size(); n++) {
                 connectedNodes[n] = Nodes[n].pNode;
         }
 
         if (pRefNode) {
                 connectedNodes[n] = pRefNode;
         }
 }

virtual Force::Type StructMappingExtForce::GetForceType ( void ) const

inlinevirtual

Implements Force.

Definition at line 126 of file strmappingext.h.

References Force::EXTERNALSTRUCTURAL.

                                                    { 
                 return Force::EXTERNALSTRUCTURAL; 
         };

void StructMappingExtForce::Output ( OutputHandler & OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 1096 of file strmappingext.cc.

References ToBeOutput::bToBeOutput(), F0, F1, F2, OutputHandler::FORCES, OutputHandler::Forces(), WithLabel::GetLabel(), M0, M1, M2, Nodes, pRefNode, and OutputHandler::UseText().

 {
         if (bToBeOutput()) {
                 if (OH.UseText(OutputHandler::FORCES)) {
                         std::ostream& out = OH.Forces();
 
                         if (pRefNode) {
                                 out << GetLabel() << "#" << pRefNode->GetLabel()
                                         << " " << F0
                                         << " " << M0
                                         << " " << F1
                                         << " " << M1
                                         << " " << F2
                                         << " " << M2
                                         << std::endl;
                         }
 
                         for (unsigned n = 0; n < Nodes.size(); n++) {
                                 out << GetLabel() << "@" << Nodes[n].pNode->GetLabel()
                                         << " " << Nodes[n].F
                                         << " " << Nodes[n].M
                                         << std::endl;
                         }
                 }
 
                 /* TODO: NetCDF */
         }
 }

Here is the call graph for this function:

bool StructMappingExtForce::Prepare ( ExtFileHandlerBase * pEFH )

protectedvirtual

Implements ExtForce.

Definition at line 242 of file strmappingext.cc.

 {
         bool bResult = true;
 
         switch (pEFH->NegotiateRequest()) {
         case ExtFileHandlerBase::NEGOTIATE_NO:
                 break;
 
         case ExtFileHandlerBase::NEGOTIATE_CLIENT: {
                 std::ostream *outfp = pEFH->GetOutStream();
                 if (outfp) {
 
 #ifdef USE_SOCKET
                 } else {
                         char buf[sizeof(uint32_t) + sizeof(uint32_t)];
                         uint32_t *uint32_ptr;
 
                         uint32_ptr = (uint32_t *)&buf[0];
                         uint32_ptr[0] = MBC_NODAL | MBC_U_ROT_2_REF_NODE_ROT(uRRot);
                         if (pRefNode != 0) {
                                 uint32_ptr[0] |= MBC_REF_NODE;
                         }
 
                         if (bLabels) {
                                 uint32_ptr[0] |= MBC_LABELS;
                         }
 
                         if (bOutputAccelerations) {
                                 uint32_ptr[0] |= MBC_ACCELS;
                         }
 
                         uint32_ptr[1] = uPoints;
 
                         ssize_t rc = send(pEFH->GetOutFileDes(),
                                 (const void *)buf, sizeof(buf),
                                 pEFH->GetSendFlags());
                         if (rc == -1) {
                                 int save_errno = errno;
                                 char *err_msg = strerror(save_errno);
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "negotiation request send() failed "
                                         "(" << save_errno << ": " << err_msg << ")"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 
                         } else if (rc != sizeof(buf)) {
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "negotiation request send() failed "
                                         "(sent " << rc << " of " << sizeof(buf) << " bytes)"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
 #endif // USE_SOCKET
                 }
                 } break;
 
         case ExtFileHandlerBase::NEGOTIATE_SERVER: {
                 unsigned uN;
                 unsigned uNodal;
                 bool bRef;
                 unsigned uRR;
                 unsigned uR;
                 bool bA;
                 bool bL;
 
                 std::istream *infp = pEFH->GetInStream();
                 if (infp) {
                         // TODO: stream negotiation?
 
 #ifdef USE_SOCKET
                 } else {
                         char buf[sizeof(uint32_t) + sizeof(uint32_t)];
                         uint32_t *uint32_ptr;
 
                         ssize_t rc = recv(pEFH->GetInFileDes(),
                                 (void *)buf, sizeof(buf),
                                 pEFH->GetRecvFlags());
                         if (rc == -1) {
                                 int save_errno = errno;
                                 char *err_msg = strerror(save_errno);
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "negotiation response recv() failed "
                                         "(" << save_errno << ": " << err_msg << ")"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 
                         } else if (rc != sizeof(buf)) {
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "negotiation response recv() failed "
                                         "(got " << rc << " of " << sizeof(buf) << " bytes)"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
 
                         uint32_ptr = (uint32_t *)&buf[0];
                         uNodal = (uint32_ptr[0] & MBC_MODAL_NODAL_MASK);
                         bRef = (uint32_ptr[0] & MBC_REF_NODE);
                         uRR = (uint32_ptr[0] & MBC_REF_NODE_ROT_MASK);
                         uR = (uint32_ptr[0] & MBC_ROT_MASK);
                         bL = (uint32_ptr[0] & MBC_LABELS);
                         bA = (uint32_ptr[0] & MBC_ACCELS);
 
                         uN = uint32_ptr[1];
 #endif // USE_SOCKET
                 }
 
                 if (uNodal != MBC_NODAL) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: expecting MBC_NODAL "
                                 "(=" << MBC_MODAL << "), got " << uNodal
                                 << std::endl);
                         bResult = false;
                 }
 
                 if ((pRefNode != 0 && !bRef) || (pRefNode == 0 && bRef)) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: reference node configuration mismatch "
                                 "(local=" << (pRefNode != 0 ? "yes" : "no") << ", remote=" << (bRef ? "yes" : "no") << ")"
                                 << std::endl);
                         bResult = false;
                 }
 
                 if (uR != MBC_ROT_NONE) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: orientation output mismatch "
                                 "(local=" << MBC_ROT_NONE << ", remote=" << uR << ")"
                                 << std::endl);
                         bResult = false;
                 }
 
                 if (uRR != MBC_U_ROT_2_REF_NODE_ROT(uRRot)) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: reference node orientation output mismatch "
                                 "(local=" << MBC_U_ROT_2_REF_NODE_ROT(uRRot) << ", remote=" << uR << ")"
                                 << std::endl);
                         bResult = false;
                 }
 
                 if (bL != bLabels) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: labels output mismatch "
                                 "(local=" << (bLabels ? "yes" : "no") << ", remote=" << (bL ? "yes" : "no") << ")"
                                 << std::endl);
                         bResult = false;
                 }
 
                 if (bA != bOutputAccelerations) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: acceleration output mismatch "
                                 "(local=" << (bOutputAccelerations ? "yes" : "no") << ", remote=" << (bA ? "yes" : "no") << ")"
                                 << std::endl);
                         bResult = false;
                 }
 
                 unsigned uMP = pH ? uMappedPoints : uPoints;
                 if (uN != uMP) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "negotiation response failed: node number mismatch "
                                 "(local=" << uMP << ", remote=" << uN << ")"
                                 << std::endl);
                         bResult = false;
                 }
                 } break;
 
         default:
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return bResult;
 }

Here is the call graph for this function:

void StructMappingExtForce::Recv ( ExtFileHandlerBase * pEFH )

protectedvirtual

Implements ExtForce.

Definition at line 765 of file strmappingext.cc.

References ExtFileHandlerBase::GetInFileDes(), ExtFileHandlerBase::GetInStream(), RecvFromFileDes(), and RecvFromStream().

 {
         std::istream *infp = pEFH->GetInStream();
         if (infp) {
                 RecvFromStream(*infp);
 
         } else {
                 RecvFromFileDes(pEFH->GetInFileDes());
         }
 }

Here is the call graph for this function:

void StructMappingExtForce::RecvFromFileDes ( int infd )

protectedvirtual

Reimplemented in StructMembraneMappingExtForce.

Definition at line 830 of file strmappingext.cc.

References bLabels, buf, F0, WithLabel::GetLabel(), StructNode::GetRCurr(), ExtFileHandlerBase::GetRecvFlags(), labels, M0, m_f, m_p, m_qlabels, MatrixHandler::MatTVecMul(), MBDYN_EXCEPT_ARGS, Nodes, ExtForce::pEFH, pH, pRefNode, and Zero3.

Referenced by Recv().

 {
 #ifdef USE_SOCKET
         if (pRefNode) {
                 size_t ulen = 0;
                 char buf[sizeof(uint32_t) + 6*sizeof(doublereal)];
                 doublereal *f;
                 ssize_t len;
 
                 if (bLabels) {
                         ulen = sizeof(uint32_t);
                 }
 
                 ulen += 6*sizeof(doublereal);
 
                 len = recv(infd, (void *)buf, ulen, pEFH->GetRecvFlags());
                 if (len == -1) {
                         int save_errno = errno;
                         char *err_msg = strerror(save_errno);
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "recv() failed (" << save_errno << ": "
                                 << err_msg << ")" << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 
                 } else if (unsigned(len) != ulen) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "recv() failed " "(got " << len << " of "
                                 << ulen << " bytes)" << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 if (bLabels) {
                         uint32_t *uint32_ptr = (uint32_t *)buf;
                         unsigned l = uint32_ptr[0];
                         if (l != pRefNode->GetLabel()) {
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "invalid reference node label "
                                         "(wanted " << pRefNode->GetLabel() << ", got " << l << ")"
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                         f = (doublereal *)&uint32_ptr[1];
 
                 } else {
                         f = (doublereal *)buf;
                 }
 
                 F0 = Vec3(&f[0]);
                 M0 = Vec3(&f[3]);
         }
 
         if (bLabels) {
                 // Hack!
                 ssize_t len = recv(infd, (void *)&m_p[0], sizeof(uint32_t)*m_p.size(),
                         pEFH->GetRecvFlags());
                 if (len == -1) {
                         int save_errno = errno;
                         char *err_msg = strerror(save_errno);
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "recv() failed (" << save_errno << ": "
                                 << err_msg << ")" << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 
                 } else if (unsigned(len) != sizeof(double)*m_p.size()) {
                         silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                 "recv() failed " "(got " << len << " of "
                                 << sizeof(uint32_t)*m_p.size() << " bytes)" << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 uint32_t *labels = (uint32_t *)&m_p[0];
                 for (unsigned l = 0; l < m_qlabels.size(); l++) {
                         if (labels[l] != m_qlabels[l]) {
                                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                                         "label mismatch for point #" << l << "/" << m_qlabels.size()
                                         << " local=" << m_qlabels[l] << " remote=" << labels[l] << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                 }
         }
 
         size_t fsize;
         double *fp;
 
         if (pH) {
                 fp = &m_p[0];
                 fsize = sizeof(double)*m_p.size();
 
         } else {
                 fp = &m_f[0];
                 fsize = sizeof(double)*m_f.size();
         }
 
         ssize_t len = recv(infd, (void *)fp, fsize, pEFH->GetRecvFlags());
         if (len == -1) {
                 int save_errno = errno;
                 char *err_msg = strerror(save_errno);
                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                         "recv() failed (" << save_errno << ": "
                         << err_msg << ")" << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 
         } else if (unsigned(len) != fsize) {
                 silent_cerr("StructMappingExtForce(" << GetLabel() << "): "
                         "recv() failed " "(got " << len << " of "
                         << fsize << " bytes)" << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (pH) {
                 pH->MatTVecMul(m_f, m_p);
         }
 
         if (pRefNode) {
                 for (unsigned p3 = 0, n = 0; n < Nodes.size(); n++) {
                         Nodes[n].F = Zero3;
                         Nodes[n].M = Zero3;
                         const StructNode *pNode(dynamic_cast<const StructNode *>(Nodes[n].pNode));
                         if (pNode != 0) {
                                 for (unsigned o = 0; o < Nodes[n].Offsets.size(); o++, p3 += 3) {
                                         Nodes[n].Offsets[o].F = pRefNode->GetRCurr()*Vec3(&m_f[p3]);
                                         Nodes[n].F += Nodes[n].Offsets[o].F;
                                         Vec3 f(pNode->GetRCurr()*Nodes[n].Offsets[o].Offset);
                                         Nodes[n].M += f.Cross(Nodes[n].Offsets[o].F);
                                 }
 
                         } else {
                                 Nodes[n].Offsets[0].F = pRefNode->GetRCurr()*Vec3(&m_f[p3]);
                                 Nodes[n].F += Nodes[n].Offsets[0].F;
                         }
                 }
 
         } else {
                 for (unsigned p3 = 0, n = 0; n < Nodes.size(); n++) {
                         Nodes[n].F = Zero3;
                         Nodes[n].M = Zero3;
                         const StructNode *pNode(dynamic_cast<const StructNode *>(Nodes[n].pNode));
                         if (pNode != 0) {
                                 for (unsigned o = 0; o < Nodes[n].Offsets.size(); o++, p3 += 3) {
                                         Nodes[n].Offsets[o].F = Vec3(&m_f[p3]);
                                         Nodes[n].F += Nodes[n].Offsets[o].F;
                                         Vec3 f(pNode->GetRCurr()*Nodes[n].Offsets[o].Offset);
                                         Nodes[n].M += f.Cross(Nodes[n].Offsets[o].F);
                                 }
 
                         } else {
                                         Nodes[n].Offsets[0].F = Vec3(&m_f[p3]);
                                         Nodes[n].F += Nodes[n].Offsets[0].F;
                         }
                 }
         }
 #else // ! USE_SOCKET
         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 #endif // ! USE_SOCKET
 }

Here is the call graph for this function:

void StructMappingExtForce::RecvFromStream ( std::istream & inf )

protectedvirtual

Reimplemented in StructMembraneMappingExtForce.

Definition at line 777 of file strmappingext.cc.

References bLabels, F0, WithLabel::GetLabel(), M0, MBC_ROT_NONE, MBDYN_EXCEPT_ARGS, Nodes, Vec3::pGetVec(), pRefNode, and uRRot.

Referenced by Recv().

 {
 #if 0
         if (pRefNode) {
                 unsigned l;
                 doublereal *f = F0.pGetVec(), *m = M0.pGetVec();
 
                 if (bLabels) {
                         inf >> l;
                 }
 
                 inf >> f[0] >> f[1] >> f[2];
                 if (uRRot != MBC_ROT_NONE) {
                         inf >> m[0] >> m[1] >> m[2];
                 }
         }
 
         for (unsigned i = 0; i < Nodes.size(); i++) {
                 /* assume unsigned int label */
                 unsigned l;
                 doublereal f[3], m[3];
 
                 if (bLabels) {
                         inf >> l;
 
                         if (Nodes[i]->GetLabel() != l) {
                                 silent_cerr("StructMappingExtForce"
                                         "(" << GetLabel() << "): "
                                         "invalid " << i << "-th label " << l
                                         << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                 }
 
                 inf
                         >> f[0] >> f[1] >> f[2];
                 if (uRot != MBC_ROT_NONE) {
                         inf >> m[0] >> m[1] >> m[2];
                 }
 
                 if (!inf) {
                         break;
                 }
 
                 F[i] = Vec3(f);
                 if (uRot != MBC_ROT_NONE) {
                         M[i] = Vec3(m);
                 }
         }
 #endif
 }

Here is the call graph for this function:

void StructMappingExtForce::Send	(	ExtFileHandlerBase *	pEFH,
		ExtFileHandlerBase::SendWhen	when
	)

protectedvirtual

Implements ExtForce.

Definition at line 417 of file strmappingext.cc.

References ExtFileHandlerBase::GetOutFileDes(), ExtFileHandlerBase::GetOutStream(), SendToFileDes(), and SendToStream().

 {
         std::ostream *outfp = pEFH->GetOutStream();
         if (outfp) {
                 SendToStream(*outfp, when);
 
         } else {
                 SendToFileDes(pEFH->GetOutFileDes(), when);
         }
 }

Here is the call graph for this function:

void StructMappingExtForce::SendToFileDes	(	int	outfd,
		ExtFileHandlerBase::SendWhen	when
	)

protectedvirtual

Reimplemented in StructMembraneMappingExtForce.

Definition at line 600 of file strmappingext.cc.

References bLabels, bOutputAccelerations, Vec3::Cross(), dRaDegr, WithLabel::GetLabel(), StructNode::GetRCurr(), StructDispNode::GetVCurr(), StructNode::GetWCurr(), StructNode::GetWPCurr(), StructDispNode::GetXCurr(), StructDispNode::GetXPPCurr(), m_q, m_qlabels, m_qP, m_qPP, m_x, m_xP, m_xPP, MatR2EulerAngles123(), MatrixHandler::MatVecMul(), MBC_ROT_EULER_123, MBC_ROT_MAT, MBC_ROT_THETA, MBDYN_EXCEPT_ARGS, Mat3x3::MulTV(), Nodes, Mat3x3::pGetMat(), Vec3::pGetVec(), pH, pRefNode, STLVectorHandler::Put(), R, uRRot, and RotManip::VecRot().

Referenced by Send().

 {
 #ifdef USE_SOCKET
         if (pRefNode) {
                 const Vec3& xRef = pRefNode->GetXCurr();
                 const Mat3x3& RRef = pRefNode->GetRCurr();
                 const Vec3& xpRef = pRefNode->GetVCurr();
                 const Vec3& wRef = pRefNode->GetWCurr();
                 const Vec3& xppRef = pRefNode->GetXPPCurr();
                 const Vec3& wpRef = pRefNode->GetWPCurr();
 
                 if (bLabels) {
                         uint32_t l = pRefNode->GetLabel();
                         send(outfd, (void *)&l, sizeof(l), 0);
                 }
 
                 send(outfd, (void *)xRef.pGetVec(), 3*sizeof(doublereal), 0);
                 switch (uRRot) {
                 case MBC_ROT_MAT:
                         send(outfd, (void *)RRef.pGetMat(), 9*sizeof(doublereal), 0);
                         break;
 
                 case MBC_ROT_THETA: {
                         Vec3 Theta(RotManip::VecRot(RRef));
                         send(outfd, (void *)Theta.pGetVec(), 3*sizeof(doublereal), 0);
                         } break;
 
                 case MBC_ROT_EULER_123: {
                         Vec3 E(MatR2EulerAngles123(RRef)*dRaDegr);
                         send(outfd, (void *)E.pGetVec(), 3*sizeof(doublereal), 0);
                         } break;
                 }
                 send(outfd, (void *)xpRef.pGetVec(), 3*sizeof(doublereal), 0);
                 send(outfd, (void *)wRef.pGetVec(), 3*sizeof(doublereal), 0);
                 if (bOutputAccelerations) {
                         send(outfd, (void *)xppRef.pGetVec(), 3*sizeof(doublereal), 0);
                         send(outfd, (void *)wpRef.pGetVec(), 3*sizeof(doublereal), 0);
                 }
 
                 for (unsigned p3 = 0, n = 0; n < Nodes.size(); n++) {
                         const StructNode *pNode(dynamic_cast<const StructNode *>(Nodes[n].pNode));
                         if (pNode != 0) {
                                 for (unsigned o = 0; o < Nodes[n].Offsets.size(); o++, p3 += 3) {
                                         Vec3 f(pNode->GetRCurr()*Nodes[n].Offsets[o].Offset);
                                         Vec3 x(pNode->GetXCurr() + f);
                                         Vec3 Dx(x - xRef);
                                         Vec3 v(pNode->GetVCurr() + pNode->GetWCurr().Cross(f));
                                         Vec3 Dv(v - xpRef - wRef.Cross(Dx));
                                         const Vec3& w(pNode->GetWCurr());
 
                                         Vec3 xTilde(RRef.MulTV(Dx));
                                         m_x.Put(p3 + 1, xTilde);
 
                                         Vec3 vTilde(RRef.MulTV(Dv));
                                         m_xP.Put(p3 + 1, vTilde);
 
                                         if (bOutputAccelerations) {
                                                 const Vec3& xpp = pNode->GetXPPCurr();
                                                 const Vec3& wp = pNode->GetWPCurr();
 
                                                 Vec3 xppTilde(RRef.MulTV(xpp - xppRef - wpRef.Cross(Dx)
                                                         - wRef.Cross(wRef.Cross(Dx) + Dv*2)
                                                         + wp.Cross(f) + w.Cross(w.Cross(f))));
                                                 m_xPP.Put(p3 + 1, xppTilde);
                                         }
                                 }
 
                         } else {
                                 Vec3 Dx(Nodes[n].pNode->GetXCurr() - xRef);
                                 Vec3 Dv(Nodes[n].pNode->GetVCurr() - xpRef - wRef.Cross(Dx));
 
                                 Vec3 xTilde(RRef.MulTV(Dx));
                                 m_x.Put(p3 + 1, xTilde);
 
                                 Vec3 vTilde(RRef.MulTV(Dv));
                                 m_xP.Put(p3 + 1, vTilde);
 
                                 if (bOutputAccelerations) {
                                         Vec3 xppTilde(RRef.MulTV(Nodes[n].pNode->GetXPPCurr()
                                                 - xppRef - wpRef.Cross(Dx)
                                                 - wRef.Cross(wRef.Cross(Dx) + Dv*2)));
                                         m_xPP.Put(p3 + 1, xppTilde);
                                 }
 
                                 p3 += 3;
                         }
                 }
 
         } else {
                 for (unsigned p3 = 0, n = 0; n < Nodes.size(); n++) {
                         const StructNode *pNode(dynamic_cast<const StructNode *>(Nodes[n].pNode));
                         if (pNode != 0) {
                                 for (unsigned o = 0; o < Nodes[n].Offsets.size(); o++, p3 +=3 ) {
                                         /*
                                                 p = x + f
                                                 R = R
                                                 v = xp + w cross f
                                                 w = w
                                                 a = xpp + wp cross f + w cross w cross f
                                                 wp = wp
                                          */
 
                                         // Optimization of the above formulas
                                         const Mat3x3& R = pNode->GetRCurr();
                                         Vec3 f = R*Nodes[n].Offsets[o].Offset;
                                         Vec3 x = pNode->GetXCurr() + f;
                                         const Vec3& w = pNode->GetWCurr();
                                         Vec3 wCrossf = w.Cross(f);
                                         Vec3 v = pNode->GetVCurr() + wCrossf;
 
                                         m_x.Put(p3 + 1, x);
                                         m_xP.Put(p3 + 1, v);
 
                                         if (bOutputAccelerations) {
                                                 const Vec3& wp = pNode->GetWPCurr();
                                                 Vec3 xpp = pNode->GetXPPCurr() + wp.Cross(f) + w.Cross(wCrossf);
 
                                                 m_xPP.Put(p3 + 1, xpp);
                                         }
                                 }
 
                         } else {
                                 m_x.Put(p3 + 1, Nodes[n].pNode->GetXCurr());
                                 m_xP.Put(p3 + 1, Nodes[n].pNode->GetVCurr());
 
                                 if (bOutputAccelerations) {
                                         m_xPP.Put(p3 + 1, Nodes[n].pNode->GetXPPCurr());
                                 }
 
                                 p3 += 3;
                         }
                 }
         }
 
         if (bLabels) {
                 send(outfd, &m_qlabels[0], sizeof(uint32_t)*m_qlabels.size(), 0);
         }
 
         if (pH) {
                 pH->MatVecMul(m_q, m_x);
                 pH->MatVecMul(m_qP, m_xP);
 
                 send(outfd, &m_q[0], sizeof(double)*m_q.size(), 0);
                 send(outfd, &m_qP[0], sizeof(double)*m_qP.size(), 0);
 
                 if (bOutputAccelerations) {
                         pH->MatVecMul(m_qPP, m_xPP);
                         send(outfd, &m_qPP[0], sizeof(double)*m_qPP.size(), 0);
                 }
 
         } else {
                 send(outfd, &m_x[0], sizeof(double)*m_x.size(), 0);
                 send(outfd, &m_xP[0], sizeof(double)*m_xP.size(), 0);
 
                 if (bOutputAccelerations) {
                         send(outfd, &m_xPP[0], sizeof(double)*m_xPP.size(), 0);
                 }
         }
 
 #else // ! USE_SOCKET
         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 #endif // ! USE_SOCKET
 }

Here is the call graph for this function:

void StructMappingExtForce::SendToStream	(	std::ostream &	outf,
		ExtFileHandlerBase::SendWhen	when
	)

protectedvirtual

Reimplemented in StructMembraneMappingExtForce.

Definition at line 429 of file strmappingext.cc.

References a, bLabels, bOutputAccelerations, Vec3::Cross(), grad::Cross(), dRaDegr, WithLabel::GetLabel(), StructNode::GetRCurr(), StructDispNode::GetVCurr(), StructNode::GetWCurr(), StructNode::GetWPCurr(), StructDispNode::GetXCurr(), StructDispNode::GetXPPCurr(), MatR2EulerAngles123(), MBC_ROT_EULER_123, MBC_ROT_MAT, MBC_ROT_NONE, MBC_ROT_THETA, Mat3x3::MulTM(), Mat3x3::MulTV(), Nodes, pRefNode, R, and RotManip::VecRot().

Referenced by Send().

 {
         if (pRefNode) {
                 const Vec3& xRef = pRefNode->GetXCurr();
                 const Mat3x3& RRef = pRefNode->GetRCurr();
                 const Vec3& xpRef = pRefNode->GetVCurr();
                 const Vec3& wRef = pRefNode->GetWCurr();
                 const Vec3& xppRef = pRefNode->GetXPPCurr();
                 const Vec3& wpRef = pRefNode->GetWPCurr();
 
                 if (bLabels) {
                         outf
                                 << pRefNode->GetLabel()
                                 << " ";
                 }
 
                 outf
                         << xRef
                         << " " << RRef
                         << " " << xpRef
                         << " " << wRef;
 
                 if (bOutputAccelerations) {
                         outf
                                 << " " << xppRef
                                 << " " << wpRef;
                 }
                 outf << std::endl;
 
                 for (unsigned i = 0; i < Nodes.size(); i++) {
 #if 0
                         Vec3 f(Nodes[i]->GetRCurr()*Offsets[i]);
                         Vec3 x(Nodes[i]->GetXCurr() + f);
                         Vec3 Dx(x - xRef);
                         Mat3x3 DR(RRef.MulTM(Nodes[i]->GetRCurr()));
                         Vec3 v(Nodes[i]->GetVCurr() + Nodes[i]->GetWCurr().Cross(f));
                         Vec3 Dv(v - xpRef - wRef.Cross(Dx));
                         const Vec3& w(Nodes[i]->GetWCurr());
 
                         // manipulate
 
                         if (bLabels) {
                                 outf
                                         << Nodes[i]->GetLabel()
                                         << " ";
                         }
 
                         outf
                                 << RRef.MulTV(Dx);
 
                         switch (uRot) {
                         case MBC_ROT_NONE:
                                 break;
 
                         case MBC_ROT_MAT:
                                 outf
                                         << " " << DR;
                                 break;
 
                         case MBC_ROT_THETA:
                                 outf
                                         << " " << RotManip::VecRot(DR);
                                 break;
 
                         case MBC_ROT_EULER_123:
                                 outf
                                         << " " << MatR2EulerAngles123(DR)*dRaDegr;
                                 break;
                         }
 
                         outf
                                 << " " << RRef.MulTV(Dv);
                         
                         if (uRot != MBC_ROT_NONE) {
                                 outf
                                         << " " << RRef.MulTV(w - wRef);
                         }
 
                         if (bOutputAccelerations) {
                                 const Vec3& xpp(Nodes[i]->GetXPPCurr());
 
                                 outf
                                         << " " << RRef.MulTV(xpp - xppRef - wpRef.Cross(Dx)
                                                         - wRef.Cross(wRef.Cross(Dx) + Dv*2));
                                 if (uRot != MBC_ROT_NONE) {
                                         const Vec3& wp(Nodes[i]->GetWPCurr());
 
                                         outf
                                                 << " " << RRef.MulTV(wp - wpRef - wRef.Cross(w));
                                 }
                         }
                         outf << std::endl;
 #endif
                 }
 
         } else {
                 for (unsigned i = 0; i < Nodes.size(); i++) {
 #if 0
                         /*
                                 p = x + f
                                 R = R
                                 v = xp + w cross f
                                 w = w
                                 a = xpp + wp cross f + w cross w cross f
                                 wp = wp
                          */
 
                         // Optimization of the above formulas
                         const Mat3x3& R = Nodes[i]->GetRCurr();
                         Vec3 f = R*Offsets[i];
                         Vec3 x = Nodes[i]->GetXCurr() + f;
                         const Vec3& w = Nodes[i]->GetWCurr();
                         Vec3 wCrossf = w.Cross(f);
                         Vec3 v = Nodes[i]->GetVCurr() + wCrossf;
 
                         if (bLabels) {
                                 outf
                                         << Nodes[i]->GetLabel()
                                         << " ";
                         }
 
                         outf
                                 << x;
 
                         switch (uRot) {
                         case MBC_ROT_NONE:
                                 break;
 
                         case MBC_ROT_MAT:
                                 outf
                                         << " " << R;
                                 break;
 
                         case MBC_ROT_THETA:
                                 outf
                                         << " " << RotManip::VecRot(R);
                                 break;
 
                         case MBC_ROT_EULER_123:
                                 outf
                                         << " " << MatR2EulerAngles123(R)*dRaDegr;
                                 break;
                         }
                         outf
                                 << " " << v;
 
                         if (uRot != MBC_ROT_NONE) {
                                 outf
                                         << " " << w;
                         }
 
                         if (bOutputAccelerations) {
                                 const Vec3& wp = Nodes[i]->GetWPCurr();
                                 Vec3 a = Nodes[i]->GetXPPCurr() + wp.Cross(f) + w.Cross(wCrossf);
 
                                 outf
                                         << " " << a;
 
                                 if (uRot != MBC_ROT_NONE) {
                                         outf
                                                 << " " << wp;
                                 }
                         }
 
                         outf << std::endl;
 #endif
                 }
         }
 }

Here is the call graph for this function:

void StructMappingExtForce::WorkSpaceDim	(	integer *	piNumRows,
		integer *	piNumCols
	)		const

virtual

Implements Elem.

Definition at line 229 of file strmappingext.cc.

References ExtForce::COUPLING_NONE, ExtForce::iCoupling, Nodes, and pRefNode.

 {
         if (iCoupling == COUPLING_NONE) {
                 *piNumRows = 0;
                 *piNumCols = 0;
 
         } else {
                 *piNumRows = (pRefNode ? 6 : 0) + 6*Nodes.size();
                 *piNumCols = 1;
         }
 }