Hyperiso/ExternalIntegration_2MartyInterface_2main__marty_8cpp_source.html

#include "MartyInterface.h"

#include "GeneralNumModelModifier.h"

#include "Extractor.h"

#include "Interpreter.h"

#include "IncludeManager.hpp"

#include "LineProcessor.h"

#include "ModelWriter.h"

#include "SMParamSetter.h"

#include "FileNameManager.h"

#include "MemoryManager.h"

#include "HyperisoMaster.h"

#include "config.hpp"

#include "ModelAPI.h"

#include "MartyParameterProxy.h"

#include "DefaultInterpreterPortsFactory.h"


int main() {

    HyperisoMaster hyp = HyperisoMaster();


    std::string base_path = project_root.data();

    HyperisoConfig config;

    config.model = Model::SM;

    hyp.init(base_path + "Test/InputFiles/testinput_thdm.lha", config);


    std::shared_ptr<ModelAPI> model_api = std::make_shared<ModelAPI>();

    std::shared_ptr<MartyParameterProxy> sm_params = std::make_shared<MartyParameterProxy>(ParameterType::SM);

    std::shared_ptr<MartyParameterProxy> bsm_params = std::make_shared<MartyParameterProxy>(ParameterType::BSM);

    std::shared_ptr<IInterpreterPortsFactory> ports = std::make_shared<DefaultInterpreterPortsFactory>();

    MartyInterface MartyInterface(model_api, sm_params, ports, bsm_params);


    std::cout << sm_params->operator()("MASS", 24) << std::endl;


    MartyInterface.calculate("C7", "SM", 81, project_tp_root.data() + std::string("MARTY/src/MARTY/src/marty/models/sm.h"));


    return 0;

}


DefaultInterpreterPortsFactory.h
Declares the default factory for interpreter ports.

main
int main()
Definition main_marty.cpp:17

Extractor.h
Declares utilities to extract parameter declarations from C++ code.

FileNameManager.h
Manages file and directory names for generated MARTY code and assets.

Model::SM
@ SM

ParameterType::SM
@ SM

ParameterType::BSM
@ BSM

GeneralNumModelModifier.h
Declares the helper used to prepare numeric MARTY models and parameter files.

HyperisoMaster.h
High-level helpers for initializing and monitoring the Hyperiso framework.

IncludeManager.hpp

Interpreter.h
Declares the Interpreter that maps MARTY parameters to Hyperiso IDs.

LineProcessor.h
Declares a line-based transformer for MARTY-generated C++ files.

MartyInterface.h
High-level façade around MARTY-based code generation and compilation.

MartyParameterProxy.h
Concrete parameter proxy that reads values from Hyperiso Parameters.

MemoryManager.h
Manages memory caching, parameter blocks, and LHA reader instances.

ModelWriter.h
Declares a helper that writes processed model code and parameters.

SMParamSetter.h

HyperisoMaster
High-level interface to initialize and monitor the main framework configuration.
Definition HyperisoMaster.h:61

HyperisoMaster::init
void init(const std::string &lhaFile, HyperisoConfig config)
Initializes Hyperiso using a LHA file and a full Config object.
Definition HyperisoMaster.cpp:185

MartyInterface
High-level interface to MARTY-based code generation and execution.
Definition MartyInterface.h:58

MartyInterface::calculate
void calculate(std::string wilson, std::string model, double Q_match, std::string model_path)
Convenience shortcut to generate, compile, and run the full pipeline.
Definition MartyInterface.cpp:367

HyperisoConfig
Configuration object controlling model, input flags and optional MARTY resources.
Definition Config.h:24

HyperisoConfig::model
Model model
Current model.
Definition Config.h:33