Program Listing for File PhysicalModalBody.h

↰ Return to documentation for file (include/Karana/SOAFlexDyn/PhysicalModalBody.h)

/*
*Copyright(c)2024-2026KaranaDynamicsPtyLtd.Allrightsreserved.
*
*NOTICETOUSER:
*
*Thissourcecodeand/ordocumentation(the"LicensedMaterials")is
*theconfidentialandproprietaryinformationofKaranaDynamicsInc.
*UseoftheseLicensedMaterialsisgovernedbythetermsandconditions
*ofaseparatesoftwarelicenseagreementbetweenKaranaDynamicsandthe
*Licensee("LicenseAgreement").Unlessexpresslypermittedunderthat
*agreement,anyreproduction,modification,distribution,ordisclosure
*oftheLicensedMaterials,inwholeorinpart,toanythirdparty
*withoutthepriorwrittenconsentofKaranaDynamicsisstrictlyprohibited.
*
*THELICENSEDMATERIALSAREPROVIDED"ASIS"WITHOUTWARRANTYOFANYKIND.
*KARANADYNAMICSDISCLAIMSALLWARRANTIES,EXPRESSORIMPLIED,INCLUDING
*BUTNOTLIMITEDTOWARRANTIESOFMERCHANTABILITY,NON-INFRINGEMENT,AND
*FITNESSFORAPARTICULARPURPOSE.
*
*INNOEVENTSHALLKARANADYNAMICSBELIABLEFORANYDAMAGESWHATSOEVER,
*INCLUDINGBUTNOTLIMITEDTOLOSSOFPROFITS,DATA,ORUSE,EVENIF
*ADVISEDOFTHEPOSSIBILITYOFSUCHDAMAGES,WHETHERINCONTRACT,TORT,
*OROTHERWISEARISINGOUTOFORINCONNECTIONWITHTHELICENSEDMATERIALS.
*
*U.S.GovernmentEndUsers:TheLicensedMaterialsarea"commercialitem"
*asdefinedat48C.F.R.2.101,andareprovidedtotheU.S.Government
*onlyasacommercialenditemunderthetermsofthislicense.
*
*AnyuseoftheLicensedMaterialsinindividualorcommercialsoftwaremust
*include,intheuserdocumentationandinternalsourcecodecomments,
*thisNotice,Disclaimer,andU.S.GovernmentUseProvision.
*/


#pragmaonce

#include"Karana/SOADyn/HingeNode.h"
#include"Karana/SOADyn/Node.h"
#include"Karana/SOADyn/PhysicalBody.h"

namespaceKarana::Dynamics{

namespacekc=Karana::Core;

structPhysicalModalBodyParams:publicPhysicalBodyParams{

size_tnmodes=4;
km::Vecstiffness=km::Vec::NullaryExpr(4,1,[](inti,intj){
return.1*(i+j+1);
});
km::Vecdamping=km::Vec::NullaryExpr(
4,1,[](inti,intj){return.01*(i+j+1);});
km::Matpnode_nodal_matrix=km::Mat::NullaryExpr(6,4,[](inti,intj){
return.1*(i+j+1);
});
km::Matonode_nodal_matrix=km::Mat::NullaryExpr(6,4,[](inti,intj){
return.2*(i+j+1);
});

PhysicalModalBodyParams&operator=(constPhysicalModalBodyParams&p){
if(this!=&p){
PhysicalBodyParams::operator=(p);
//AssignDerived-specificmembershere
nmodes=p.nmodes;
stiffness=p.stiffness;
damping=p.damping;
pnode_nodal_matrix=p.pnode_nodal_matrix;
onode_nodal_matrix=p.onode_nodal_matrix;
}

return*this;
}
};

classModalNodeDeformationProvider:publicNodeDeformationProvider{

//foraccessto_deformation_provider
friendclassPhysicalModalBody;

public:
ModalNodeDeformationProvider(std::string_viewname,kc::ks_ptr<Node>node);

~ModalNodeDeformationProvider();

voidsetNodalMatrix(constkm::Mat&nodal_matrix);

constkm::Mat6n&getNodalMatrix()const{return_nodal_matrix;}

kc::ks_ptr<kf::Frame>undeformedFrame()const{return_undeformed_frame;}

kc::ks_ptr<kf::Frame>deformedTransFrame()const{return_deformed_trans_frame;}

kc::ks_ptr<kf::Frame>deformedRotFrame()const{return_deformed_rot_frame;}

//verifythatthenodalmatrixhasbeeninitialized
boolisReady()constoverride;

std::stringdumpString(std::string_viewprefix,
constKarana::Core::Base::DumpOptions*options)constoverride;

structDeformationParams:publicNodeDeformationProvider::DeformationParams{
km::Matnodal_matrix;

DeformationParams()=default;

//Addingsuppression,asCodeCheckercomplainsthismethodhasthesamenameasa
//methodinthebaseversion.ThisisjustaCodeCheckerfalsepositive.
//codechecker_suppress[cppcheck-duplInheritedMember]
DeformationParams&operator=(constNodeDeformationProvider::DeformationParams*p){
if(this!=p){
NodeDeformationProvider::DeformationParams::operator=(
p);//Callbaseclassassignmentoperator
nodal_matrix=static_cast<constDeformationParams*>(p)->nodal_matrix;
}

return*this;
}
};

protected:
kc::ks_ptr<NodeDeformationProvider::DeformationParams>_getParams()constoverride;
void_setParams(constNodeDeformationProvider::DeformationParams&params)override;

void_discard(kc::ks_ptr<Base>&base)override;

km::HomTran_transFrameRelTransformHelper()const;

km::SpatialVector_transFrameRelSpVelHelper()const;

km::SpatialVector_transFrameRelSpAccelHelper()const;

km::HomTran_rotFrameRelTransformHelper()const;

km::SpatialVector_rotFrameRelSpVelHelper()const;

km::SpatialVector_rotFrameRelSpAccelHelper()const;

km::HomTran_transFrameRelTransformReversedHelper()const;

km::SpatialVector_transFrameRelSpVelReversedHelper()const;

km::SpatialVector_transFrameRelSpAccelReversedHelper()const;

km::HomTran_rotFrameRelTransformReversedHelper()const;

km::SpatialVector_rotFrameRelSpVelReversedHelper()const;

km::SpatialVector_rotFrameRelSpAccelReversedHelper()const;

protected:
km::Mat6n_nodal_matrix;


kc::ks_ptr<kf::Frame>_undeformed_frame=nullptr;

kc::ks_ptr<kf::Frame>_deformed_trans_frame=nullptr;

kc::ks_ptr<kf::Frame>_deformed_rot_frame=nullptr;
};

classPhysicalModalBody:publicPhysicalBody{

//Foraccesstodiscard
friendclassModalNodeDeformationProvider;

//Foraccesstopframe2otherPhi()
friendclassCompoundSubhinge;

public:
statickc::ks_ptr<PhysicalModalBody>
create(std::string_viewname,kc::ks_ptr<Multibody>mbs,size_tnmodes);

PhysicalModalBody(std::string_viewname,kc::ks_ptr<Multibody>mb,size_tnmodes);

~PhysicalModalBody();

voidsetBodyToJointTransform(constkm::HomTran&t)override;
km::HomTrangetBodyToJointTransform()constoverride;

boolisReady()constoverride;

km::VecgetStiffnessVector()const;

voidsetStiffnessVector(constkm::Vec&stiffness);

km::VecgetDampingVector()const;

voidsetDampingVector(constkm::Vec&damping);

std::stringdumpString(std::string_viewprefix,
constKarana::Core::Base::DumpOptions*options)constoverride;

voidsetParams(constPhysicalBodyParams&params)override;

staticstd::vector<kc::ks_ptr<PhysicalBody>>
//Addingsuppression,asCodeCheckercomplainsthismethodhasthesamenameasamethodin
//thebaseversion.ThisisjustaCodeCheckerfalsepositive.
//codechecker_suppress[cppcheck-duplInheritedMember]
addSerialChain(std::string_viewname,
size_tnbodies,
PhysicalBody&root,
HingeBase::HingeTypehtype=HingeBase::HingeType::REVOLUTE,
PhysicalBodyParams*params=nullptr);

staticstd::vector<kc::ks_ptr<PhysicalBody>>
//Addingsuppression,asCodeCheckercomplainsthismethodhasthesamenameasamethodin
//thebaseversion.ThisisjustaCodeCheckerfalsepositive.
//codechecker_suppress[cppcheck-duplInheritedMember]
addTree(std::string_viewname,
size_tbranch_length,
size_tnbranches,
size_tdepth,
PhysicalBody&root,
HingeBase::HingeTypehtype=HingeBase::HingeType::REVOLUTE,
PhysicalBodyParams*params=nullptr);

public:
constkm::MatatbiCoordMapMatrix()constoverride{
return_atbi_coord_map_matrix_cache->get();
}

km::Matjacobian(constkf::Frame&target,booloriented)constoverride;

km::Mat66getNodeUpsilonFromPnode(constNode&node)override;

km::Mat66getNodeUpsilonFromBody(constNode&node)override;

km::MatgetUpsilonMatrix()override;

protected:
constkm::Mat&_atbiCoordMapMatrix()const{return_atbi_coord_map_matrix_cache->get();}

structATBIMatrices:publicCoordBase::ATBIMatrices{

//public:

km::MatP;

km::Mat66Pplus;//NOLINT(readability-identifier-naming)

km::MatHP;//NOLINT(readability-identifier-naming)

km::MatD;

km::MatDinv;//NOLINT(readability-identifier-naming)

km::MatG;

km::Mattauper;

km::Matpsi;

voidresize(size_tmodal_n_u,size_tbody_n_u){
P.resize(modal_n_u+body_n_u,modal_n_u+body_n_u);
P.setZero();

HP.resize(modal_n_u,body_n_u);
D.resize(modal_n_u,modal_n_u);
Dinv.resize(modal_n_u,modal_n_u);
G.resize(body_n_u,modal_n_u);
tauper.resize(body_n_u,body_n_u+modal_n_u);
psi.resize(body_n_u,body_n_u+modal_n_u);

km::makeNotReady(HP);
km::makeNotReady(D);
km::makeNotReady(Dinv);
km::makeNotReady(G);
km::makeNotReady(tauper);
km::makeNotReady(psi);
}
};

structATBIFilterVectors:publicCoordBase::ATBIFilterVectors{

public:
km::Vecz;

km::SpatialVectorzplus;

km::Vecepsilon;

km::Vecnu;

voidresize(size_tmodal_n_u){
z.resize(modal_n_u+6);

epsilon.resize(modal_n_u);
nu.resize(modal_n_u);
km::makeNotReady(epsilon);
km::makeNotReady(nu);
}

voiddump(std::string_viewindent)const;
};

structATBISmootherVectors{
km::SpatialVectoralpha_plus;
};

protected:
structSZNodeMatrices{
km::MatS;
km::Mat66Z;
};

structModalUpsilonMatrices{

km::MatUpsilon;//NOLINT(readability-identifier-naming)
};

km::MatpframeCoordMapMatrix()constoverride;

km::MatgetATBIMatPsi()constoverride;

km::MatgetATBID()constoverride;

km::MatgetATBIDinv()constoverride;

km::MatgetATBIG()constoverride;

km::MatgetATBITauper()constoverride;

protected:
km::Mat_oframe2pframePsi()constoverride;

km::Mat_oframe2pframePhi()constoverride;

km::Mat_pframe2otherPhi(constkf::Frame&other)constoverride;

void_setupNode(Node&nd,boolforce_node)override;

void_detachNode(kc::ks_ptr<Node>&node)override;

km::Mat_getM()const;

km::Mat_getMff()const;

km::Mat_getMfr()const;

void_discardNodeDeformationProvider(kc::ks_ptr<Node>nd);

void_discardPnodeDeformationProvider();

protected:
km::SpatialVector_getPnodeATBIFilterZ()override;

km::Mat66_getPnodeATBIMatricesP()override;

km::SpatialVector_getOnodeATBISmootherAlphaPlus(constHingeOnode&ond)override;

void_processPnodeATBISmootherVectors()override;

void_processModalATBISmootherVectors()override;

km::SpatialVector_getPnodeInvDynForcesF()override;

SZNodeMatrices_computeSZMatrices(constNode&node);

km::Mat66_pnodeToChildNodeTransform(constNode&node)override;

kc::ks_ptr<kf::Frame>_getPnodeDeformedTransFrame()constoverride;

km::Mat_bodyToChildNodeTransform(constNode&node,
constkf::Frame&from_frame)constoverride;

void_computeATBICoordMapMatrix(km::Mat&val)const;

km::Mat_computeHst_Mfl(constkf::Frame&at_frame)const;

constkm::Vec_externalModalForces()const;

constkm::Vec_constraintModalForces()const;

protected:
void_setupNodeDeformation(kc::ks_ptr<Node>nd);

void_setupPnodeDeformation();

void_discardHingePnode()override;
void_discardHingeOnode(kc::ks_ptr<HingeOnode>&onode)override;

kc::ks_ptr<HingePnode>_createPnode(boolfloating_frame)override;

kc::ks_ptr<HingeOnode>_createOnode(std::string_viewname)override;

void_setBodyToNodeTransform(Node&node,constkm::HomTran&t)override;

km::HomTran_getBodyToNodeTransform(constNode&node)constoverride;

km::Mat_getMassAtFrame(constkf::Frame&frame)const;

void_getPnodeCRBInertiaMatrix(km::Mat&R)override;

protected:
void_oneTimeSetupDataCaches();

void_oneTimeTeardownDataCaches();

protected:
km::Vec_stiffness_vector;

km::Vec_damping_vector;

bool_using_modal_integrals=false;

ModalUpsilonMatrices_modal_upsilon_matrices;

kc::ks_ptr<kc::DataCache<km::Mat>>_atbi_coord_map_matrix_cache=nullptr;
};

}//namespaceKarana::Dynamics