From 7ff709b872c13a04526087c265fe88a4a71babe0 Mon Sep 17 00:00:00 2001 From: Dylan Harries Date: Wed, 11 Jan 2017 09:55:30 +1030 Subject: [PATCH] Simplify constructor definition for mass eigenstates class by using in-class initialization for members --- meta/CConversion.m | 32 ++++++++++++++++--------------- meta/FlexibleSUSY.m | 2 +- meta/Parameters.m | 10 ++++++++++ meta/Phases.m | 16 ++++++++-------- meta/TreeMasses.m | 31 +++++++++++++++--------------- templates/mass_eigenstates.cpp.in | 14 -------------- templates/mass_eigenstates.hpp.in | 24 +++++++++++------------ 7 files changed, 64 insertions(+), 65 deletions(-) diff --git a/meta/CConversion.m b/meta/CConversion.m index 346fc277a..72679d766 100644 --- a/meta/CConversion.m +++ b/meta/CConversion.m @@ -92,6 +92,9 @@ CreateGetterReturnType::usage="creates C/C++ getter return type"; +CreateDefaultValue::usage="creates a default value for a given +parameter type"; + CreateDefaultConstructor::usage="creates C/C++ default constructor for a given parameter type"; @@ -348,27 +351,26 @@ CreateGetterPrototype[parameter_, type_] := CreateGetterPrototype[parameter, CreateGetterReturnType[type]]; -(* create default constructor initialization list *) -CreateDefaultConstructor[parameter_, type_] := +(* create default value for given parameter *) +CreateDefaultValue[type_] := Block[{}, Print["Error: unknown parameter type: " <> ToString[type]]; Return[""]; ]; -CreateDefaultConstructor[parameter_String, CConversion`ScalarType[_]] := - parameter <> "(0)"; - -CreateDefaultConstructor[parameter_String, CConversion`ArrayType[type_, entries_]] := - parameter <> "(" <> CreateCType[CConversion`ArrayType[type, entries]] <> "::Zero())"; +CreateDefaultValue[CConversion`ScalarType[_]] := "0"; +CreateDefaultValue[CConversion`ArrayType[type_, entries_]] := + CreateCType[CConversion`ArrayType[type, entries]] <> "::Zero()"; +CreateDefaultValue[CConversion`VectorType[type_, entries_]] := + CreateCType[CConversion`VectorType[type, entries]] <> "::Zero()"; +CreateDefaultValue[CConversion`MatrixType[type_, rows_, cols_]] := + CreateCType[CConversion`MatrixType[type, rows, cols]] <> "::Zero()"; +CreateDefaultValue[CConversion`TensorType[type_, dims__]] := + CreateCType[CConversion`TensorType[type, dims]] <> "::Zero()"; -CreateDefaultConstructor[parameter_String, CConversion`VectorType[type_, entries_]] := - parameter <> "(" <> CreateCType[CConversion`VectorType[type, entries]] <> "::Zero())"; - -CreateDefaultConstructor[parameter_String, CConversion`MatrixType[type_, rows_, cols_]] := - parameter <> "(" <> CreateCType[CConversion`MatrixType[type, rows, cols]] <> "::Zero())"; - -CreateDefaultConstructor[parameter_String, CConversion`TensorType[type_, dims__]] := - parameter <> "(" <> CreateCType[CConversion`TensorType[type, dims]] <> "::Zero())"; +(* create default constructor initialization list *) +CreateDefaultConstructor[parameter_String, type_] := + parameter <> "(" <> CreateDefaultValue[type] <> ")"; CreateDefaultDefinition[parameter_, type_] := Print["Error: unknown parameter type: " <> ToString[type]]; diff --git a/meta/FlexibleSUSY.m b/meta/FlexibleSUSY.m index faf308468..a0920742b 100644 --- a/meta/FlexibleSUSY.m +++ b/meta/FlexibleSUSY.m @@ -1266,7 +1266,7 @@ corresponding tadpole is real or imaginary (only in models with CP phasesGetterSetters = Phases`CreatePhasesGetterSetters[phases]; phasesInit = Phases`CreatePhasesInitialization[phases]; If[Parameters`GetExtraParameters[] =!= {}, - extraParameterDefs = StringJoin[Parameters`CreateParameterDefinition[#]& + extraParameterDefs = StringJoin[Parameters`CreateInitializedParameterDefinition[#]& /@ Parameters`GetExtraParameters[]]; extraParameterGetters = StringJoin[CConversion`CreateInlineGetters[CConversion`ToValidCSymbolString[#], Parameters`GetType[#]]& /@ diff --git a/meta/Parameters.m b/meta/Parameters.m index 92afbd61c..6ea534967 100644 --- a/meta/Parameters.m +++ b/meta/Parameters.m @@ -8,6 +8,7 @@ FindSymbolDef::usage=""; CreateParameterDefinition::usage=""; +CreateInitializedParameterDefinition::usage=""; CreateSetAssignment::usage=""; CreateDisplayAssignment::usage=""; CreateParameterSARAHNames::usage=""; @@ -701,6 +702,15 @@ CreateParameterDefinition[{par_, block_, type_}] := CConversion`CreateCType[type] <> " " <> CConversion`ToValidCSymbolString[par] <> ";\n"; +CreateInitializedParameterDefinition[{par_, type_}] := + CConversion`CreateCType[type] <> " " <> CConversion`ToValidCSymbolString[par] <> "{" <> CConversion`CreateDefaultValue[type] <> "};\n"; + +CreateInitializedParameterDefinition[par_] := + CreateInitializedParameterDefinition[{par, GetType[par]}]; + +CreateInitializedParameterDefinition[{par_, block_, type_}] := + CreateInitializedParameterDefinition[{par, type}]; + CreateSetAssignment[name_, startIndex_, parameterType_, struct_:"pars"] := Block[{}, Print["Error: CreateSetAssignment: unknown parameter type: ", ToString[parameterType]]; diff --git a/meta/Phases.m b/meta/Phases.m index adfc25417..1e64aef6c 100644 --- a/meta/Phases.m +++ b/meta/Phases.m @@ -32,18 +32,18 @@ GetPhaseType[Exp[_]] := CConversion`ScalarType[CConversion`realScalarCType]; GetPhaseType[_] := CConversion`ScalarType[CConversion`complexScalarCType]; -CreatePhaseInit[type_ /; type === CConversion`ScalarType[CConversion`realScalarCType]] := - "(0)"; +CreateDefaultPhaseValue[type_ /; type === CConversion`ScalarType[CConversion`realScalarCType]] := "0"; +CreateDefaultPhaseValue[type_ /; type === CConversion`ScalarType[CConversion`complexScalarCType]] := "1,0"; -CreatePhaseInit[type_ /; type === CConversion`ScalarType[CConversion`complexScalarCType]] := - "(1,0)"; +CreatePhaseInit[type_] := "(" <> CreateDefaultPhaseValue[type] <> ")"; CreatePhasesDefinition[phases_List] := - Module[{result = "", k}, + Module[{result = "", k, type}, For[k = 1, k <= Length[phases], k++, - result = result <> CConversion`CreateCType[ - GetPhaseType[phases[[k]]]] <> " " <> - CreatePhaseName[phases[[k]]] <> ";\n"; + type = GetPhaseType[phases[[k]]]; + result = result <> CConversion`CreateCType[type] + <> " " <> CreatePhaseName[phases[[k]]] + <> "{" <> CreateDefaultPhaseValue[type] <> "};\n"; ]; Return[result]; ]; diff --git a/meta/TreeMasses.m b/meta/TreeMasses.m index 1f82bc912..e7b25673c 100644 --- a/meta/TreeMasses.m +++ b/meta/TreeMasses.m @@ -1580,8 +1580,9 @@ the fundamental representation of SU(3) in SARAH. returnType = CConversion`ScalarType[CConversion`realScalarCType];, returnType = CConversion`ArrayType[CConversion`realScalarCType, dim]; ]; - result = CreateCType[returnType] <> " " <> - ToValidCSymbolString[FlexibleSUSY`M[MakeESSymbol[massESSymbol]]] <> ";\n"; + result = CConversion`CreateCType[returnType] <> " " <> + CConversion`ToValidCSymbolString[FlexibleSUSY`M[MakeESSymbol[massESSymbol]]] <> "{" <> + CConversion`CreateDefaultValue[returnType] <> "};\n"; Return[result]; ]; @@ -1592,24 +1593,24 @@ the fundamental representation of SU(3) in SARAH. ]; CreatePhysicalMassInitialization[massMatrix_TreeMasses`FSMassMatrix] := - Module[{result = "", massESSymbol, dim, matrixType}, + Module[{result = "", massESSymbol, dim, massType}, massESSymbol = GetMassEigenstate[massMatrix]; dim = GetDimension[massESSymbol]; - matrixType = CreateCType[CConversion`ArrayType[CConversion`realScalarCType, dim]]; - result = ", " <> ToValidCSymbolString[FlexibleSUSY`M[MakeESSymbol[massESSymbol]]]; If[dim == 1, - result = result <> "(0)";, - result = result <> "(" <> matrixType <> "::Zero())"; + massType = CConversion`ScalarType[CConversion`realScalarCType];, + massType = CConversion`ArrayType[CConversion`realScalarCType, dim]; ]; + result = ", " <> CConversion`ToValidCSymbolString[FlexibleSUSY`M[MakeESSymbol[massESSymbol]]] + <> "(" <> CConversion`CreateDefaultValue[massType] <> ")"; Return[result]; ]; DefineMatrix[Null, _] := ""; -DefineMatrix[matrix_Symbol, type_String] := - type <> " " <> ToValidCSymbolString[matrix] <> ";\n"; +DefineMatrix[matrix_Symbol, type_] := + CConversion`CreateCType[type] <> " " <> CConversion`ToValidCSymbolString[matrix] <> "{" <> CConversion`CreateDefaultValue[type] <> "};\n"; -DefineMatrix[matrix_List, type_String] := +DefineMatrix[matrix_List, type_] := Module[{result = ""}, (result = result <> DefineMatrix[#,type])& /@ matrix; Return[result]; @@ -1618,7 +1619,7 @@ the fundamental representation of SU(3) in SARAH. CreateMixingMatrixDefinition[massMatrix_TreeMasses`FSMassMatrix] := Module[{result, mixingMatrixSymbol, matrixType}, mixingMatrixSymbol = GetMixingMatrixSymbol[massMatrix]; - matrixType = CreateCType[GetMixingMatrixType[massMatrix]]; + matrixType = GetMixingMatrixType[massMatrix]; result = DefineMatrix[mixingMatrixSymbol, matrixType]; Return[result]; ]; @@ -1683,10 +1684,10 @@ the fundamental representation of SU(3) in SARAH. InitializeMatrix[Null, _] := ""; -InitializeMatrix[matrix_Symbol, type_String] := - ", " <> ToValidCSymbolString[matrix] <> "(" <> type <> "::Zero())"; +InitializeMatrix[matrix_Symbol, type_] := + ", " <> CConversion`ToValidCSymbolString[matrix] <> "(" <> CConversion`CreateDefaultValue[type] <> ")"; -InitializeMatrix[matrix_List, type_String] := +InitializeMatrix[matrix_List, type_] := Module[{result = ""}, (result = result <> InitializeMatrix[#, type])& /@ matrix; Return[result]; @@ -1695,7 +1696,7 @@ the fundamental representation of SU(3) in SARAH. CreateMixingMatrixInitialization[massMatrix_TreeMasses`FSMassMatrix] := Module[{result, mixingMatrixSymbol, matrixType}, mixingMatrixSymbol = GetMixingMatrixSymbol[massMatrix]; - matrixType = CreateCType[GetMixingMatrixType[massMatrix]]; + matrixType = GetMixingMatrixType[massMatrix]; result = InitializeMatrix[mixingMatrixSymbol, matrixType]; Return[result]; ]; diff --git a/templates/mass_eigenstates.cpp.in b/templates/mass_eigenstates.cpp.in index db71e30c0..91f02f56e 100644 --- a/templates/mass_eigenstates.cpp.in +++ b/templates/mass_eigenstates.cpp.in @@ -76,20 +76,6 @@ using namespace @ModelName@_info; CLASSNAME::@ModelName@_mass_eigenstates(const @ModelName@_input_parameters& input_) : @ModelName@_soft_parameters(input_) - , ewsb_loop_order(2) - , pole_mass_loop_order(2) - , calculate_sm_pole_masses(false) - , calculate_bsm_pole_masses(true) - , force_output(false) - , precision(1.0e-3) - , ewsb_iteration_precision(1.0e-5) - , physical() - , problems(@ModelName@_info::particle_names, @ModelName@_info::parameter_names) - , two_loop_corrections() -@physicalMassesInit@ -@mixingMatricesInit@ -@phasesInit@ -@extraParametersInit@ { } diff --git a/templates/mass_eigenstates.hpp.in b/templates/mass_eigenstates.hpp.in index 20405c134..bcd5e4236 100644 --- a/templates/mass_eigenstates.hpp.in +++ b/templates/mass_eigenstates.hpp.in @@ -32,9 +32,9 @@ #ifndef @ModelName@_MASS_EIGENSTATES_H #define @ModelName@_MASS_EIGENSTATES_H -#include "@ModelName@_soft_parameters.hpp" -#include "@ModelName@_physical.hpp" #include "@ModelName@_info.hpp" +#include "@ModelName@_physical.hpp" +#include "@ModelName@_soft_parameters.hpp" #include "two_loop_corrections.hpp" #include "error.hpp" #include "problems.hpp" @@ -138,16 +138,16 @@ private: virtual std::string what() const { return "Could not perform EWSB step."; } }; - unsigned ewsb_loop_order; ///< loop order for EWSB - unsigned pole_mass_loop_order; ///< loop order for pole masses - bool calculate_sm_pole_masses; ///< switch to calculate the pole masses of the Standard Model particles - bool calculate_bsm_pole_masses;///< switch to calculate the pole masses of the BSM particles - bool force_output; ///< switch to force output of pole masses - double precision; ///< RG running precision - double ewsb_iteration_precision; ///< precision goal of EWSB solution - @ModelName@_physical physical; ///< contains the pole masses and mixings - Problems<@ModelName@_info::NUMBER_OF_PARTICLES, @ModelName@_info::NUMBER_OF_PARAMETERS> problems; ///< problems - Two_loop_corrections two_loop_corrections; ///< used 2-loop corrections + unsigned ewsb_loop_order{2}; ///< loop order for EWSB + unsigned pole_mass_loop_order{2}; ///< loop order for pole masses + bool calculate_sm_pole_masses{false}; ///< switch to calculate the pole masses of the Standard Model particles + bool calculate_bsm_pole_masses{true}; ///< switch to calculate the pole masses of the BSM particles + bool force_output{false}; ///< switch to force output of pole masses + double precision{1.e-3}; ///< RG running precision + double ewsb_iteration_precision{1.e-5};///< precision goal of EWSB solution + @ModelName@_physical physical{}; ///< contains the pole masses and mixings + Problems<@ModelName@_info::NUMBER_OF_PARTICLES, @ModelName@_info::NUMBER_OF_PARAMETERS> problems{@ModelName@_info::particle_names, @ModelName@_info::parameter_names}; ///< problems + Two_loop_corrections two_loop_corrections{}; ///< used 2-loop corrections std::size_t get_number_of_ewsb_iterations() const; std::size_t get_number_of_mass_iterations() const;