KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
Namespaces | Functions | Variables
generate_frictionless_mortar_condition.py File Reference

Namespaces

 generate_frictionless_mortar_condition
 

Functions

def generate_frictionless_mortar_condition.convert_active_inactive_int (list_active)
 

Variables

bool generate_frictionless_mortar_condition.do_simplifications = False
 
string generate_frictionless_mortar_condition.mode = "c"
 
bool generate_frictionless_mortar_condition.impose_partion_of_unity = False
 
list generate_frictionless_mortar_condition.dim_combinations = [2,3,3,3,3]
 
list generate_frictionless_mortar_condition.nnodes_combinations = [2,3,4,3,4]
 
list generate_frictionless_mortar_condition.nnodes_master_combinations = [2,3,4,4,3]
 
int generate_frictionless_mortar_condition.normal_combs = 2
 
string generate_frictionless_mortar_condition.lhs_string = ""
 SUBSTITUTION ################################. More...
 
string generate_frictionless_mortar_condition.lhs_template_begin_string = "\n/***********************************************************************************/\n/***********************************************************************************/\n\ntemplate<>\nvoid AugmentedLagrangianMethodFrictionlessMortarContactCondition<TDim, TNumNodes, TNormalVariation, TNumNodesMaster>::CalculateLocalLHS(\n Matrix& rLocalLHS,\n const MortarConditionMatrices& rMortarConditionMatrices,\n const DerivativeDataType& rDerivativeData,\n const IndexType rActiveInactive,\n const ProcessInfo& rCurrentProcessInfo\n )\n{\n // Initialize values\n const BoundedMatrix<double, TNumNodes, TDim>& u1 = rDerivativeData.u1;\n const BoundedMatrix<double, TNumNodesMaster, TDim>& u2 = rDerivativeData.u2;\n const BoundedMatrix<double, TNumNodes, TDim>& X1 = rDerivativeData.X1;\n const BoundedMatrix<double, TNumNodesMaster, TDim>& X2 = rDerivativeData.X2;\n \n const array_1d<double, TNumNodes> LMNormal = MortarUtilities::GetVariableVector<TNumNodes>(this->GetParentGeometry(), LAGRANGE_MULTIPLIER_CONTACT_PRESSURE, 0);\n \n const BoundedMatrix<double, TNumNodes, TDim>& NormalSlave = rDerivativeData.NormalSlave;\n\n // The ALM parameters\n const array_1d<double, TNumNodes> DynamicFactor = MortarUtilities::GetVariableVector<TNumNodes>(this->GetParentGeometry(), DYNAMIC_FACTOR);\n const double ScaleFactor = rDerivativeData.ScaleFactor;\n const array_1d<double, TNumNodes>& PenaltyParameter = rDerivativeData.PenaltyParameter;\n \n // Mortar operators\n const BoundedMatrix<double, TNumNodes, TNumNodesMaster>& MOperator = rMortarConditionMatrices.MOperator;\n const BoundedMatrix<double, TNumNodes, TNumNodes>& DOperator = rMortarConditionMatrices.DOperator;\n // Mortar operators derivatives\n const array_1d<BoundedMatrix<double, TNumNodes, TNumNodesMaster>, SIZEDERIVATIVES2>& DeltaMOperator = rMortarConditionMatrices.DeltaMOperator;\n const array_1d<BoundedMatrix<double, TNumNodes, TNumNodes>, SIZEDERIVATIVES2>& DeltaDOperator = rMortarConditionMatrices.DeltaDOperator;\n\n"
 
string generate_frictionless_mortar_condition.lhs_template_end_string = "\n}\n"
 
string generate_frictionless_mortar_condition.rhs_string = ""
 
string generate_frictionless_mortar_condition.rhs_template_begin_string = "\n/***********************************************************************************/\n/***********************************************************************************/\n\ntemplate<>\nvoid AugmentedLagrangianMethodFrictionlessMortarContactCondition<TDim, TNumNodes, TNormalVariation, TNumNodesMaster>::CalculateLocalRHS(\n Vector& rLocalRHS,\n const MortarConditionMatrices& rMortarConditionMatrices,\n const DerivativeDataType& rDerivativeData,\n const IndexType rActiveInactive,\n const ProcessInfo& rCurrentProcessInfo\n )\n{\n // Initialize values\n const BoundedMatrix<double, TNumNodes, TDim>& u1 = rDerivativeData.u1;\n const BoundedMatrix<double, TNumNodesMaster, TDim>& u2 = rDerivativeData.u2;\n const BoundedMatrix<double, TNumNodes, TDim>& X1 = rDerivativeData.X1;\n const BoundedMatrix<double, TNumNodesMaster, TDim>& X2 = rDerivativeData.X2;\n \n const array_1d<double, TNumNodes> LMNormal = MortarUtilities::GetVariableVector<TNumNodes>(this->GetParentGeometry(), LAGRANGE_MULTIPLIER_CONTACT_PRESSURE, 0);\n \n const BoundedMatrix<double, TNumNodes, TDim>& NormalSlave = rDerivativeData.NormalSlave;\n\n // The ALM parameters\n const array_1d<double, TNumNodes> DynamicFactor = MortarUtilities::GetVariableVector<TNumNodes>(this->GetParentGeometry(), DYNAMIC_FACTOR);\n const double ScaleFactor = rDerivativeData.ScaleFactor;\n const array_1d<double, TNumNodes>& PenaltyParameter = rDerivativeData.PenaltyParameter;\n \n // Mortar operators\n const BoundedMatrix<double, TNumNodes, TNumNodesMaster>& MOperator = rMortarConditionMatrices.MOperator;\n const BoundedMatrix<double, TNumNodes, TNumNodes>& DOperator = rMortarConditionMatrices.DOperator;\n\n"
 
string generate_frictionless_mortar_condition.rhs_template_end_string = "\n}\n"
 
int generate_frictionless_mortar_condition.output_count = 0
 
int generate_frictionless_mortar_condition.total_combs = normal_combs * len(nnodes_combinations)
 
string generate_frictionless_mortar_condition.normalvarstring = "false"
 
 generate_frictionless_mortar_condition.number_dof = dim * (nnodes_master + nnodes) + nnodes
 
 generate_frictionless_mortar_condition.active_inactive_combinations = list(ibin(nnodes, 'all'))
 
int generate_frictionless_mortar_condition.active_inactive_comb = 0
 
 generate_frictionless_mortar_condition.u1 = custom_sympy_fe_utilities.DefineMatrix('u1',nnodes,dim)
 
 generate_frictionless_mortar_condition.u2 = custom_sympy_fe_utilities.DefineMatrix('u2',nnodes_master,dim)
 
 generate_frictionless_mortar_condition.LMNormal = custom_sympy_fe_utilities.DefineVector('LMNormal',nnodes)
 
 generate_frictionless_mortar_condition.NormalGap = custom_sympy_fe_utilities.DefineVector('NormalGap',nnodes)
 
 generate_frictionless_mortar_condition.DOperator = custom_sympy_fe_utilities.DefineMatrix('DOperator',nnodes,nnodes)
 
 generate_frictionless_mortar_condition.MOperator = custom_sympy_fe_utilities.DefineMatrix('MOperator',nnodes,nnodes_master)
 
 generate_frictionless_mortar_condition.NormalSlave = custom_sympy_fe_utilities.DefineMatrix('NormalSlave',nnodes,dim)
 
 generate_frictionless_mortar_condition.X1 = custom_sympy_fe_utilities.DefineMatrix('X1',nnodes,dim)
 
 generate_frictionless_mortar_condition.X2 = custom_sympy_fe_utilities.DefineMatrix('X2',nnodes_master,dim)
 
 generate_frictionless_mortar_condition.x1 = X1 + u1
 
 generate_frictionless_mortar_condition.x2 = X2 + u2
 
 generate_frictionless_mortar_condition.DynamicFactor = custom_sympy_fe_utilities.DefineVector('DynamicFactor',nnodes)
 
 generate_frictionless_mortar_condition.PenaltyParameter = custom_sympy_fe_utilities.DefineVector('PenaltyParameter',nnodes)
 
 generate_frictionless_mortar_condition.ScaleFactor = sympy.Symbol('ScaleFactor', positive=True)
 
 generate_frictionless_mortar_condition.w1 = custom_sympy_fe_utilities.DefineMatrix('w1',nnodes,dim)
 
 generate_frictionless_mortar_condition.w2 = custom_sympy_fe_utilities.DefineMatrix('w2',nnodes_master,dim)
 
 generate_frictionless_mortar_condition.wLMNormal = custom_sympy_fe_utilities.DefineVector('wLMNormal',nnodes)
 
list generate_frictionless_mortar_condition.u1_var = []
 
list generate_frictionless_mortar_condition.u2_var = []
 
list generate_frictionless_mortar_condition.lm_var = []
 
list generate_frictionless_mortar_condition.u12_var = u1_var.copy()
 
list generate_frictionless_mortar_condition.u1_lm_var = u1_var.copy()
 
list generate_frictionless_mortar_condition.all_var = u12_var.copy()
 
 generate_frictionless_mortar_condition.Dx1Mx2 = DOperator * x1 - MOperator * x2
 
 generate_frictionless_mortar_condition.Dw1Mw2 = DOperator * w1 - MOperator * w2
 
 generate_frictionless_mortar_condition.dofs = sympy.Matrix( sympy.zeros(number_dof, 1) )
 
 generate_frictionless_mortar_condition.testfunc = sympy.Matrix( sympy.zeros(number_dof, 1) )
 
int generate_frictionless_mortar_condition.count = 0
 
int generate_frictionless_mortar_condition.rv_galerkin = 0
 FUNCTIONAL DEFINITION ############################. More...
 
 generate_frictionless_mortar_condition.active = active_inactive[node]
 
tuple generate_frictionless_mortar_condition.augmented_contact_pressure = (ScaleFactor * LMNormal[node] + PenaltyParameter[node] * NormalGap[node])
 
 generate_frictionless_mortar_condition.rv = sympy.Matrix( sympy.zeros(1, 1) )
 Complete functional. More...
 
 generate_frictionless_mortar_condition.rhs
 
 generate_frictionless_mortar_condition.lhs
 
 generate_frictionless_mortar_condition.lhs_out = custom_sympy_fe_utilities.OutputMatrix_CollectingFactors(lhs,"lhs", mode, 1, number_dof)
 
 generate_frictionless_mortar_condition.rhs_out = custom_sympy_fe_utilities.OutputVector_CollectingFactors(rhs,"rhs", mode, 1, number_dof)
 
list generate_frictionless_mortar_condition.var_strings = []
 DEFINE VARIABLES AND DERIVATIVES #######################. More...
 
list generate_frictionless_mortar_condition.var_strings_subs = []
 
list generate_frictionless_mortar_condition.var_strings_aux_subs = []
 
list generate_frictionless_mortar_condition.der_var_strings = []
 
list generate_frictionless_mortar_condition.der_var_list = []
 
list generate_frictionless_mortar_condition.der_var_used_index = []
 
 generate_frictionless_mortar_condition.input = open("ALM_frictionless_mortar_contact_condition_template.cpp",'r').read()
 FINAL SAVING ##############################. More...
 
 generate_frictionless_mortar_condition.outputstring = input.replace("// replace_lhs", lhs_string)
 
 generate_frictionless_mortar_condition.output = open("ALM_frictionless_mortar_contact_condition.cpp",'w')