| //+------------------------------------------------------------------+
|
| //| RiskIntegration.mqh |
|
| //| Copyright 2025, Your Company Name |
|
| //| https://www.yoursite.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, Your Company Name"
|
| #property link "https://www.yoursite.com"
|
| #property version "1.00"
|
| #property strict
|
|
|
| // Include all risk management components
|
| #include "RiskParameters.mqh"
|
| #include "RiskMetrics.mqh"
|
| #include "PositionSizer.mqh"
|
| #include "DrawdownManager.mqh"
|
| #include "CorrelationMatrix.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Risk Integration Class |
|
| //+------------------------------------------------------------------+
|
| class CRiskIntegration
|
| {
|
| private:
|
| // Component instances
|
| CRiskParameters* m_riskParams; // Risk parameters
|
| CRiskMetrics* m_riskMetrics; // Risk metrics calculator
|
| CPositionSizer* m_positionSizer; // Position sizing
|
| CDrawdownManager* m_drawdownMgr; // Drawdown management
|
| CCorrelationMatrix* m_corrMatrix; // Correlation analysis
|
|
|
| // State
|
| bool m_isInitialized; // Initialization flag
|
| double m_accountEquity; // Current account equity
|
|
|
| // Private methods
|
| bool InitializeComponents();
|
| void UpdateAccountInfo();
|
|
|
| public:
|
| // Constructor/Destructor
|
| CRiskIntegration();
|
| ~CRiskIntegration();
|
|
|
| // Initialization
|
| bool Initialize();
|
| void Deinitialize();
|
| void Update();
|
|
|
| // Risk assessment
|
| bool CanOpenPosition(const string symbol, const ENUM_ORDER_TYPE type,
|
| const double price, const double stopLoss,
|
| const double takeProfit, double &suggestedSize);
|
|
|
| // Position management
|
| bool ValidatePositionSize(const string symbol, const double size);
|
| bool UpdatePositionMetrics(const string symbol, const double size,
|
| const double openPrice, const double currentPrice);
|
|
|
| // Getters
|
| bool IsInitialized() const { return m_isInitialized; }
|
| double GetAccountEquity() const { return m_accountEquity; }
|
| double GetMaxPositionSize() const;
|
|
|
| // Component access
|
| CRiskParameters* GetRiskParameters() { return m_riskParams; }
|
| CRiskMetrics* GetRiskMetrics() { return m_riskMetrics; }
|
| CPositionSizer* GetPositionSizer() { return m_positionSizer; }
|
| CDrawdownManager* GetDrawdownManager() { return m_drawdownMgr; }
|
| CCorrelationMatrix* GetCorrelationMatrix() { return m_corrMatrix; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CRiskIntegration::CRiskIntegration() :
|
| m_riskParams(NULL),
|
| m_riskMetrics(NULL),
|
| m_positionSizer(NULL),
|
| m_drawdownMgr(NULL),
|
| m_corrMatrix(NULL),
|
| m_isInitialized(false),
|
| m_accountEquity(0.0)
|
| {
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CRiskIntegration::~CRiskIntegration()
|
| {
|
| Deinitialize();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize risk integration |
|
| //+------------------------------------------------------------------+
|
| bool CRiskIntegration::Initialize()
|
| {
|
| if (m_isInitialized)
|
| return true;
|
|
|
| // Create components
|
| m_riskParams = new CRiskParameters();
|
| if (m_riskParams == NULL || !m_riskParams.Initialize())
|
| {
|
| Print("Failed to initialize risk parameters");
|
| return false;
|
| }
|
|
|
| m_riskMetrics = new CRiskMetrics();
|
| if (m_riskMetrics == NULL || !m_riskMetrics.Initialize())
|
| {
|
| Print("Failed to initialize risk metrics");
|
| return false;
|
| }
|
|
|
| m_positionSizer = new CPositionSizer();
|
| if (m_positionSizer == NULL || !m_positionSizer.Initialize(m_riskParams, m_riskMetrics))
|
| {
|
| Print("Failed to initialize position sizer");
|
| return false;
|
| }
|
|
|
| m_drawdownMgr = new CDrawdownManager();
|
| if (m_drawdownMgr == NULL || !m_drawdownMgr.Initialize())
|
| {
|
| Print("Failed to initialize drawdown manager");
|
| return false;
|
| }
|
|
|
| m_corrMatrix = new CCorrelationMatrix();
|
| if (m_corrMatrix == NULL || !m_corrMatrix.Initialize())
|
| {
|
| Print("Failed to initialize correlation matrix");
|
| return false;
|
| }
|
|
|
| // Update account information
|
| UpdateAccountInfo();
|
|
|
| m_isInitialized = true;
|
| Print("Risk integration initialized successfully");
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Deinitialize risk integration |
|
| //+------------------------------------------------------------------+
|
| void CRiskIntegration::Deinitialize()
|
| {
|
| if (m_corrMatrix != NULL)
|
| {
|
| m_corrMatrix.Deinitialize();
|
| delete m_corrMatrix;
|
| m_corrMatrix = NULL;
|
| }
|
|
|
| if (m_drawdownMgr != NULL)
|
| {
|
| m_drawdownMgr.Deinitialize();
|
| delete m_drawdownMgr;
|
| m_drawdownMgr = NULL;
|
| }
|
|
|
| if (m_positionSizer != NULL)
|
| {
|
| m_positionSizer.Deinitialize();
|
| delete m_positionSizer;
|
| m_positionSizer = NULL;
|
| }
|
|
|
| if (m_riskMetrics != NULL)
|
| {
|
| m_riskMetrics.Deinitialize();
|
| delete m_riskMetrics;
|
| m_riskMetrics = NULL;
|
| }
|
|
|
| if (m_riskParams != NULL)
|
| {
|
| delete m_riskParams;
|
| m_riskParams = NULL;
|
| }
|
|
|
| m_isInitialized = false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update risk metrics and state |
|
| //+------------------------------------------------------------------+
|
| void CRiskIntegration::Update()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| // Update account information
|
| UpdateAccountInfo();
|
|
|
| // Update drawdown manager
|
| if (m_drawdownMgr != NULL)
|
| {
|
| m_drawdownMgr.UpdateEquity(m_accountEquity);
|
| }
|
|
|
| // Update correlation matrix periodically
|
| static datetime lastCorrelationUpdate = 0;
|
| if (TimeCurrent() - lastCorrelationUpdate >= 3600) // Update hourly
|
| {
|
| if (m_corrMatrix != NULL)
|
| {
|
| m_corrMatrix.Update();
|
| }
|
| lastCorrelationUpdate = TimeCurrent();
|
| }
|
|
|
| // Update risk metrics
|
| if (m_riskMetrics != NULL)
|
| {
|
| m_riskMetrics.Update();
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if a position can be opened with the given parameters |
|
| //+------------------------------------------------------------------+
|
| bool CRiskIntegration::CanOpenPosition(const string symbol, const ENUM_ORDER_TYPE type,
|
| const double price, const double stopLoss,
|
| const double takeProfit, double &suggestedSize)
|
| {
|
| if (!m_isInitialized || symbol == "")
|
| return false;
|
|
|
| // Check if we're in a drawdown that exceeds limits
|
| if (m_drawdownMgr != NULL && m_riskParams != NULL)
|
| {
|
| if (m_drawdownMgr.IsDrawdownLimitReached(m_riskParams.GetMaxDrawdownPct()))
|
| {
|
| Print("Cannot open position: Maximum drawdown limit reached");
|
| return false;
|
| }
|
|
|
| if (m_drawdownMgr.IsDailyLossLimitReached(m_riskParams.GetMaxDailyLossPct()))
|
| {
|
| Print("Cannot open position: Daily loss limit reached");
|
| return false;
|
| }
|
| }
|
|
|
| // Calculate stop loss in pips
|
| double stopLossPips = 0.0;
|
| if (stopLoss > 0.0)
|
| {
|
| double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
| double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
|
| if (point > 0.0 && tickSize > 0.0)
|
| {
|
| if (type == ORDER_TYPE_BUY)
|
| stopLossPips = (price - stopLoss) / (point * 10.0);
|
| else
|
| stopLossPips = (stopLoss - price) / (point * 10.0);
|
|
|
| stopLossPips = MathMax(1.0, stopLossPips); // Ensure at least 1 pip
|
| }
|
| }
|
|
|
| // Get position size
|
| double riskPercent = (m_riskParams != NULL) ? m_riskParams.GetRiskPerTrade() : 1.0;
|
| double size = 0.0;
|
|
|
| if (m_positionSizer != NULL)
|
| {
|
| if (!m_positionSizer.CalculateSize(symbol, stopLossPips, riskPercent, m_accountEquity, size))
|
| {
|
| Print("Failed to calculate position size");
|
| return false;
|
| }
|
| }
|
|
|
| // Check correlation with existing positions
|
| if (m_corrMatrix != NULL && m_riskParams != NULL)
|
| {
|
| if (!m_corrMatrix.ValidateNewPosition(symbol, type, price, size))
|
| {
|
| Print("Cannot open position: Correlation limit exceeded");
|
| return false;
|
| }
|
| }
|
|
|
| // Check if size is within allowed limits
|
| if (!ValidatePositionSize(symbol, size))
|
| {
|
| return false;
|
| }
|
|
|
| suggestedSize = size;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Validate if position size is within allowed limits |
|
| //+------------------------------------------------------------------+
|
| bool CRiskIntegration::ValidatePositionSize(const string symbol, const double size)
|
| {
|
| if (!m_isInitialized || symbol == "" || size <= 0.0)
|
| return false;
|
|
|
| // Check minimum position size
|
| double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
| if (size < minLot)
|
| {
|
| PrintFormat("Position size (%.2f) is below minimum (%.2f)", size, minLot);
|
| return false;
|
| }
|
|
|
| // Check maximum position size
|
| double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
| if (maxLot > 0.0 && size > maxLot)
|
| {
|
| PrintFormat("Position size (%.2f) exceeds maximum (%.2f)", size, maxLot);
|
| return false;
|
| }
|
|
|
| // Check against risk parameters
|
| if (m_riskParams != NULL)
|
| {
|
| double maxLotsPerTrade = m_riskParams.GetMaxLotsPerTrade();
|
| if (maxLotsPerTrade > 0.0 && size > maxLotsPerTrade)
|
| {
|
| PrintFormat("Position size (%.2f) exceeds maximum per trade (%.2f)", size, maxLotsPerTrade);
|
| return false;
|
| }
|
|
|
| double maxRiskPerTrade = m_riskParams.GetMaxRiskPerTrade();
|
| if (maxRiskPerTrade > 0.0)
|
| {
|
| double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
| double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
| double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
|
| if (tickValue > 0.0 && tickSize > 0.0 && point > 0.0)
|
| {
|
| double riskAmount = size * (tickValue / tickSize) * point * 10.0; // Risk per pip
|
| double maxRiskAmount = m_accountEquity * (maxRiskPerTrade / 100.0);
|
|
|
| if (riskAmount > maxRiskAmount)
|
| {
|
| PrintFormat("Position risk (%.2f) exceeds maximum risk per trade (%.2f)",
|
| riskAmount, maxRiskAmount);
|
| return false;
|
| }
|
| }
|
| }
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update position metrics |
|
| //+------------------------------------------------------------------+
|
| bool CRiskIntegration::UpdatePositionMetrics(const string symbol, const double size,
|
| const double openPrice, const double currentPrice)
|
| {
|
| if (!m_isInitialized || symbol == "" || size <= 0.0 || openPrice <= 0.0)
|
| return false;
|
|
|
| // Update risk metrics with the new position
|
| if (m_riskMetrics != NULL)
|
| {
|
| // This is a simplified example - in practice, you would update all relevant metrics
|
| double pips = (currentPrice - openPrice) / (SymbolInfoDouble(symbol, SYMBOL_POINT) * 10.0);
|
| m_riskMetrics.UpdateTradeMetrics(pips > 0, MathAbs(pips));
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get maximum allowed position size based on risk parameters |
|
| //+------------------------------------------------------------------
|
| double CRiskIntegration::GetMaxPositionSize()
|
| {
|
| if (!m_isInitialized || m_riskParams == NULL)
|
| return 0.0;
|
|
|
| return m_riskParams.GetMaxLotsPerTrade();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update account information |
|
| //+------------------------------------------------------------------+
|
| void CRiskIntegration::UpdateAccountInfo()
|
| {
|
| m_accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
|
| // Update risk metrics with new equity
|
| if (m_riskMetrics != NULL)
|
| {
|
| m_riskMetrics.UpdateEquity(m_accountEquity);
|
| }
|
| }
|
