/// <summary>
/// Adds the security to the user defined universe for the specified
/// </summary>
private void AddToUserDefinedUniverse(Security security)
{
// add this security to the user defined universe
UserDefinedUniverse universe;
var key = new SecurityTypeMarket(security.Type, security.SubscriptionDataConfig.Market);
if (_userDefinedUniverses.TryGetValue(key, out universe))
{
universe.Add(security.Symbol);
}
else
{
// create a new universe, these subscription settings don't currently get used
// since universe selection proper is never invoked on this type of universe
var securityConfig = security.SubscriptionDataConfig;
var universeSymbol = UserDefinedUniverse.CreateSymbol(securityConfig.SecurityType, securityConfig.Market);
var uconfig = new SubscriptionDataConfig(securityConfig, symbol: universeSymbol, isInternalFeed: true, fillForward: false);
universe = new UserDefinedUniverse(uconfig,
new UniverseSettings(security.Resolution, security.Leverage, security.IsFillDataForward, security.IsExtendedMarketHours, TimeSpan.Zero),
QuantConnect.Time.OneDay,
new List <Symbol> {
security.Symbol
}
);
_userDefinedUniverses[key] = universe;
UniverseManager.Add(universe.Configuration.Symbol, universe);
}
}
/// <summary>
/// Adds the security to the user defined universe for the specified
/// </summary>
private void AddToUserDefinedUniverse(Security security)
{
// if we are adding a non-internal security which already has an internal feed, we remove it first
Security existingSecurity;
if (Securities.TryGetValue(security.Symbol, out existingSecurity))
{
if (!security.IsInternalFeed() && existingSecurity.IsInternalFeed())
{
var securityUniverse = UniverseManager.Select(x => x.Value).OfType <UserDefinedUniverse>().FirstOrDefault(x => x.Members.ContainsKey(security.Symbol));
securityUniverse?.Remove(security.Symbol);
Securities.Remove(security.Symbol);
}
}
Securities.Add(security);
// add this security to the user defined universe
Universe universe;
var subscription = security.Subscriptions.First();
var universeSymbol = UserDefinedUniverse.CreateSymbol(subscription.SecurityType, subscription.Market);
if (!UniverseManager.TryGetValue(universeSymbol, out universe))
{
// create a new universe, these subscription settings don't currently get used
// since universe selection proper is never invoked on this type of universe
var uconfig = new SubscriptionDataConfig(subscription, symbol: universeSymbol, isInternalFeed: true, fillForward: false);
if (security.Type == SecurityType.Base)
{
// set entry in market hours database for the universe subscription to match the custom data
var symbolString = MarketHoursDatabase.GetDatabaseSymbolKey(uconfig.Symbol);
MarketHoursDatabase.SetEntry(uconfig.Market, symbolString, uconfig.SecurityType, security.Exchange.Hours, uconfig.DataTimeZone);
}
universe = new UserDefinedUniverse(uconfig,
new UniverseSettings(security.Resolution, security.Leverage, security.IsFillDataForward, security.IsExtendedMarketHours, TimeSpan.Zero),
SecurityInitializer,
QuantConnect.Time.MaxTimeSpan,
new List <Symbol> {
security.Symbol
}
);
UniverseManager.Add(universeSymbol, universe);
}
var userDefinedUniverse = universe as UserDefinedUniverse;
if (userDefinedUniverse != null)
{
userDefinedUniverse.Add(security.Symbol);
}
else
{
// should never happen, someone would need to add a non-user defined universe with this symbol
throw new Exception("Expected universe with symbol '" + universeSymbol.Value + "' to be of type UserDefinedUniverse.");
}
}
/// <summary>
/// Used to send data updates to algorithm framework models
/// </summary>
/// <param name="slice">The current data slice</param>
public void OnFrameworkData(Slice slice)
{
if (UtcTime >= UniverseSelection.GetNextRefreshTimeUtc())
{
var universes = UniverseSelection.CreateUniverses(this).ToDictionary(u => u.Configuration.Symbol);
// remove deselected universes by symbol
foreach (var ukvp in UniverseManager)
{
var universeSymbol = ukvp.Key;
var qcUserDefined = UserDefinedUniverse.CreateSymbol(ukvp.Value.SecurityType, ukvp.Value.Market);
if (universeSymbol.Equals(qcUserDefined))
{
// prevent removal of qc algorithm created user defined universes
continue;
}
Universe universe;
if (!universes.TryGetValue(universeSymbol, out universe))
{
if (ukvp.Value.DisposeRequested)
{
UniverseManager.Remove(universeSymbol);
}
// mark this universe as disposed to remove all child subscriptions
ukvp.Value.Dispose();
}
}
// add newly selected universes
foreach (var ukvp in universes)
{
// note: UniverseManager.Add uses TryAdd, so don't need to worry about duplicates here
UniverseManager.Add(ukvp);
}
}
// we only want to run universe selection if there's no data available in the slice
if (!slice.HasData)
{
return;
}
// insight timestamping handled via InsightsGenerated event handler
var insightsEnumerable = Alpha.Update(this, slice);
// for performance only call 'ToArray' if not empty enumerable (which is static)
var insights = insightsEnumerable == Enumerable.Empty <Insight>()
? new Insight[] { } : insightsEnumerable.ToArray();
// only fire insights generated event if we actually have insights
if (insights.Length != 0)
{
OnInsightsGenerated(insights.Select(InitializeInsightFields));
}
ProcessInsights(insights);
}
public Option AddChineseOption(string underlying, Resolution resolution = Resolution.Minute, string market = null, bool fillDataForward = true, decimal leverage = 0m)
{
if (market == null)
{
if (!BrokerageModel.DefaultMarkets.TryGetValue(SecurityType.Option, out market))
{
throw new Exception("No default market set for security type: " + SecurityType.Option);
}
}
Symbol canonicalSymbol;
var alias = "?" + underlying;
if (!SymbolCache.TryGetSymbol(alias, out canonicalSymbol))
{
//canonicalSymbol = QuantConnect.Symbol.Create(underlying, SecurityType.Option, market, alias);
canonicalSymbol = QuantConnect.Symbol.CreateOption(underlying, market, OptionStyle.European, default(OptionRight), 0, SecurityIdentifier.DefaultDate, alias);
}
var marketHoursEntry = MarketHoursDatabase.FromDataFolder().GetEntry(market, underlying, SecurityType.Option);
var symbolProperties = SymbolPropertiesDatabase.FromDataFolder().GetSymbolProperties(market, underlying, SecurityType.Option, CashBook.AccountCurrency);
var canonicalSecurity = (Option)SecurityManager.CreateSecurity(new List <Type>()
{
typeof(ZipEntryName)
}, Portfolio, SubscriptionManager,
marketHoursEntry.ExchangeHours, marketHoursEntry.DataTimeZone, symbolProperties, SecurityInitializer, canonicalSymbol, resolution,
fillDataForward, leverage, false, false, false, LiveMode, true, false);
canonicalSecurity.IsTradable = false;
Securities.Add(canonicalSecurity);
// add this security to the user defined universe
Universe universe;
if (!UniverseManager.TryGetValue(canonicalSymbol, out universe))
{
var settings = new UniverseSettings(resolution, leverage, true, false, TimeSpan.Zero);
universe = new OptionChainUniverse(canonicalSecurity, settings, SubscriptionManager, SecurityInitializer);
UniverseManager.Add(canonicalSymbol, universe);
}
return(canonicalSecurity);
}
public void NotifiesWhenSecurityAdded()
{
var manager = new UniverseManager();
var universe = new FuncUniverse(CreateTradeBarConfig(), new UniverseSettings(Resolution.Minute, 2, true, false, TimeSpan.Zero), SecurityInitializer.Null,
data => data.Select(x => x.Symbol)
);
manager.CollectionChanged += (sender, args) =>
{
if (args.NewItems.OfType <object>().Single() != universe)
{
Assert.Fail("Expected args.NewItems to have exactly one element equal to universe");
}
else
{
Assert.IsTrue(args.Action == NotifyCollectionChangedAction.Add);
Assert.Pass();
}
};
manager.Add(universe.Configuration.Symbol, universe);
}
public void NotifiesWhenSecurityAdded()
{
var manager = new UniverseManager();
var universe = new FuncUniverse(CreateTradeBarConfig(), new UniverseSettings(Resolution.Minute, 2, true, false, TimeSpan.Zero), SecurityInitializer.Null,
data => data.Select(x => x.Symbol)
);
manager.CollectionChanged += (sender, args) =>
{
if (args.NewItems.OfType<object>().Single() != universe)
{
Assert.Fail("Expected args.NewItems to have exactly one element equal to universe");
}
else
{
Assert.IsTrue(args.Action == NotifyCollectionChangedAction.Add);
Assert.Pass();
}
};
manager.Add(universe.Configuration.Symbol, universe);
}
/// <summary>
/// Adds the security to the user defined universe for the specified
/// </summary>
private void AddToUserDefinedUniverse(Security security)
{
Securities.Add(security);
// add this security to the user defined universe
Universe universe;
var securityConfig = security.SubscriptionDataConfig;
var universeSymbol = UserDefinedUniverse.CreateSymbol(securityConfig.SecurityType, securityConfig.Market);
if (!UniverseManager.TryGetValue(universeSymbol, out universe))
{
// create a new universe, these subscription settings don't currently get used
// since universe selection proper is never invoked on this type of universe
var uconfig = new SubscriptionDataConfig(securityConfig, symbol: universeSymbol, isInternalFeed: true, fillForward: false);
universe = new UserDefinedUniverse(uconfig,
new UniverseSettings(security.Resolution, security.Leverage, security.IsFillDataForward, security.IsExtendedMarketHours, TimeSpan.Zero),
SecurityInitializer,
QuantConnect.Time.OneDay,
new List <Symbol> {
security.Symbol
}
);
UniverseManager.Add(universeSymbol, universe);
}
var userDefinedUniverse = universe as UserDefinedUniverse;
if (userDefinedUniverse != null)
{
userDefinedUniverse.Add(security.Symbol);
}
else
{
// should never happen, someone would need to add a non-user defined universe with this symbol
throw new Exception("Expected universe with symbol '" + universeSymbol.Value + "' to be of type UserDefinedUniverse.");
}
}
public void OnEndOfTimeStep()
{
if (_pendingUniverseAdditions.Count + _pendingUserDefinedUniverseSecurityAdditions.Count == 0)
{
// no point in looping through everything if there's no pending changes
return;
}
var requiredHistoryRequests = new Dictionary <Security, Resolution>();
// rewrite securities w/ derivatives to be in raw mode
lock (_pendingUniverseAdditionsLock)
{
foreach (var security in Securities.Select(kvp => kvp.Value).Union(
_pendingUserDefinedUniverseSecurityAdditions.Select(x => x.Security)))
{
// check for any derivative securities and mark the underlying as raw
if (Securities.Any(skvp => skvp.Key.SecurityType != SecurityType.Base && skvp.Key.HasUnderlyingSymbol(security.Symbol)))
{
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(security);
}
var configs = SubscriptionManager.SubscriptionDataConfigService
.GetSubscriptionDataConfigs(security.Symbol);
if (security.Symbol.HasUnderlying && security.Symbol.SecurityType != SecurityType.Base)
{
Security underlyingSecurity;
var underlyingSymbol = security.Symbol.Underlying;
var resolution = configs.GetHighestResolution();
// create the underlying security object if it doesn't already exist
if (!Securities.TryGetValue(underlyingSymbol, out underlyingSecurity))
{
underlyingSecurity = AddSecurity(underlyingSymbol.SecurityType,
underlyingSymbol.Value,
resolution,
underlyingSymbol.ID.Market,
false,
0,
configs.IsExtendedMarketHours());
}
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(underlyingSecurity);
if (LiveMode && underlyingSecurity.GetLastData() == null)
{
if (requiredHistoryRequests.ContainsKey(underlyingSecurity))
{
// lets request the higher resolution
var currentResolutionRequest = requiredHistoryRequests[underlyingSecurity];
if (currentResolutionRequest != Resolution.Minute && // Can not be less than Minute
resolution < currentResolutionRequest)
{
requiredHistoryRequests[underlyingSecurity] = (Resolution)Math.Max((int)resolution, (int)Resolution.Minute);
}
}
else
{
requiredHistoryRequests.Add(underlyingSecurity, (Resolution)Math.Max((int)resolution, (int)Resolution.Minute));
}
}
// set the underlying security on the derivative -- we do this in two places since it's possible
// to do AddOptionContract w/out the underlying already added and normalized properly
var derivative = security as IDerivativeSecurity;
if (derivative != null)
{
derivative.Underlying = underlyingSecurity;
}
}
}
if (!requiredHistoryRequests.IsNullOrEmpty())
{
// Create requests
var historyRequests = Enumerable.Empty <HistoryRequest>();
foreach (var byResolution in requiredHistoryRequests.GroupBy(x => x.Value))
{
historyRequests = historyRequests.Concat(
CreateBarCountHistoryRequests(byResolution.Select(x => x.Key.Symbol), 3, byResolution.Key));
}
// Request data
var historicLastData = History(historyRequests);
historicLastData.PushThrough(x =>
{
var security = requiredHistoryRequests.Keys.FirstOrDefault(y => y.Symbol == x.Symbol);
security?.Cache.AddData(x);
});
}
// add subscriptionDataConfig to their respective user defined universes
foreach (var userDefinedUniverseAddition in _pendingUserDefinedUniverseSecurityAdditions)
{
foreach (var subscriptionDataConfig in userDefinedUniverseAddition.SubscriptionDataConfigs)
{
userDefinedUniverseAddition.Universe.Add(subscriptionDataConfig);
}
}
// finally add any pending universes, this will make them available to the data feed
foreach (var universe in _pendingUniverseAdditions)
{
UniverseManager.Add(universe.Configuration.Symbol, universe);
}
_pendingUniverseAdditions.Clear();
_pendingUserDefinedUniverseSecurityAdditions.Clear();
}
if (!_rawNormalizationWarningSymbols.IsNullOrEmpty())
{
// Log our securities being set to raw price mode
Debug($"Warning: The following securities were set to raw price normalization mode to work with options: " +
$"{string.Join(", ", _rawNormalizationWarningSymbols.Take(_rawNormalizationWarningSymbolsMaxCount).Select(x => x.Value))}...");
// Set our warning list to null to stop emitting these warnings after its done once
_rawNormalizationWarningSymbols = null;
}
}
/// <summary>
/// Adds the universe to the algorithm
/// </summary>
/// <param name="universe">The universe to be added</param>
public void AddUniverse(Universe universe)
{
UniverseManager.Add(universe.Configuration.Symbol, universe);
}
/// <summary>
/// Used to send data updates to algorithm framework models
/// </summary>
/// <param name="slice">The current data slice</param>
public void OnFrameworkData(Slice slice)
{
if (UtcTime >= UniverseSelection.GetNextRefreshTimeUtc())
{
var universes = UniverseSelection.CreateUniverses(this).ToDictionary(u => u.Configuration.Symbol);
// remove deselected universes by symbol
foreach (var ukvp in UniverseManager)
{
var universeSymbol = ukvp.Key;
if (_userAddedUniverses.Contains(universeSymbol))
{
// prevent removal of qc algorithm created user defined universes
continue;
}
if (ukvp.Value.DisposeRequested)
{
// have to remove in the next loop after the universe is marked as disposed, when 'Dispose()' is called it will trigger universe selection
// and deselect all symbols, sending the removed security changes, which are picked up by the AlgorithmManager and tags securities
// as non tradable as long as they are not active in any universe (uses UniverseManager.ActiveSecurities)
// but they will remain tradable if a position is still being hold since they won't be remove from the UniverseManager
// but this last part will not happen if we remove the universe from the UniverseManager right away, since it won't be part of 'UniverseManager'.
// And we have to remove the universe even if it's present at 'universes' because that one is another New universe that should get added!
// 'UniverseManager' will skip duplicate entries getting added.
UniverseManager.Remove(universeSymbol);
}
Universe universe;
if (!universes.TryGetValue(universeSymbol, out universe))
{
// mark this universe as disposed to remove all child subscriptions
ukvp.Value.Dispose();
}
}
// add newly selected universes
foreach (var ukvp in universes)
{
// note: UniverseManager.Add uses TryAdd, so don't need to worry about duplicates here
UniverseManager.Add(ukvp);
}
}
// we only want to run universe selection if there's no data available in the slice
if (!slice.HasData)
{
return;
}
// insight timestamping handled via InsightsGenerated event handler
var insightsEnumerable = Alpha.Update(this, slice);
// for performance only call 'ToArray' if not empty enumerable (which is static)
var insights = insightsEnumerable == Enumerable.Empty <Insight>()
? new Insight[] { } : insightsEnumerable.ToArray();
// only fire insights generated event if we actually have insights
if (insights.Length != 0)
{
insights = InitializeInsights(insights);
OnInsightsGenerated(insights);
}
ProcessInsights(insights);
}
/// <summary>
/// Invoked at the end of every time step. This allows the algorithm
/// to process events before advancing to the next time step.
/// </summary>
public void OnEndOfTimeStep()
{
if (_pendingUniverseAdditions.Count + _pendingUserDefinedUniverseSecurityAdditions.Count == 0)
{
// no point in looping through everything if there's no pending changes
return;
}
// rewrite securities w/ derivatives to be in raw mode
lock (_pendingUniverseAdditionsLock)
{
foreach (var security in Securities.Select(kvp => kvp.Value).Union(_pendingUserDefinedUniverseSecurityAdditions.Keys))
{
// check for any derivative securities and mark the underlying as raw
if (Securities.Any(skvp => skvp.Key.HasUnderlyingSymbol(security.Symbol)))
{
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(security);
}
if (security.Symbol.HasUnderlying)
{
Security underlyingSecurity;
var underlyingSymbol = security.Symbol.Underlying;
// create the underlying security object if it doesn't already exist
if (!Securities.TryGetValue(underlyingSymbol, out underlyingSecurity))
{
underlyingSecurity = AddSecurity(underlyingSymbol.SecurityType, underlyingSymbol.Value, security.Resolution,
underlyingSymbol.ID.Market, false, 0, security.IsExtendedMarketHours);
}
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(underlyingSecurity);
// set the underying security on the derivative -- we do this in two places since it's possible
// to do AddOptionContract w/out the underlying already added and normalized properly
var derivative = security as IDerivativeSecurity;
if (derivative != null)
{
derivative.Underlying = underlyingSecurity;
}
}
}
// add securities to their respective user defined universes
foreach (var kvp in _pendingUserDefinedUniverseSecurityAdditions)
{
var security = kvp.Key;
var userDefinedUniverse = kvp.Value;
userDefinedUniverse.Add(security.Symbol);
}
// finally add any pending universes, this will make them available to the data feed
foreach (var universe in _pendingUniverseAdditions)
{
UniverseManager.Add(universe.Configuration.Symbol, universe);
}
_pendingUniverseAdditions.Clear();
_pendingUserDefinedUniverseSecurityAdditions.Clear();
}
}
/// <summary>
/// Invoked at the end of every time step. This allows the algorithm
/// to process events before advancing to the next time step.
/// </summary>
public void OnEndOfTimeStep()
{
if (_pendingUniverseAdditions.Count + _pendingUserDefinedUniverseSecurityAdditions.Count == 0)
{
// no point in looping through everything if there's no pending changes
return;
}
var requiredHistoryRequests = new Dictionary <Security, Resolution>();
// rewrite securities w/ derivatives to be in raw mode
lock (_pendingUniverseAdditionsLock)
{
foreach (var security in Securities.Select(kvp => kvp.Value).Union(_pendingUserDefinedUniverseSecurityAdditions.Keys))
{
// check for any derivative securities and mark the underlying as raw
if (Securities.Any(skvp => skvp.Key.HasUnderlyingSymbol(security.Symbol)))
{
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(security);
}
if (security.Symbol.HasUnderlying)
{
Security underlyingSecurity;
var underlyingSymbol = security.Symbol.Underlying;
// create the underlying security object if it doesn't already exist
if (!Securities.TryGetValue(underlyingSymbol, out underlyingSecurity))
{
underlyingSecurity = AddSecurity(underlyingSymbol.SecurityType, underlyingSymbol.Value, security.Resolution,
underlyingSymbol.ID.Market, false, 0, security.IsExtendedMarketHours);
}
// set data mode raw and default volatility model
ConfigureUnderlyingSecurity(underlyingSecurity);
if (LiveMode && underlyingSecurity.GetLastData() == null)
{
requiredHistoryRequests.Add(underlyingSecurity, (Resolution)Math.Max((int)security.Resolution, (int)Resolution.Minute));
}
// set the underlying security on the derivative -- we do this in two places since it's possible
// to do AddOptionContract w/out the underlying already added and normalized properly
var derivative = security as IDerivativeSecurity;
if (derivative != null)
{
derivative.Underlying = underlyingSecurity;
}
}
}
if (!requiredHistoryRequests.IsNullOrEmpty())
{
// Create requests
var historyRequests = Enumerable.Empty <HistoryRequest>();
foreach (var byResolution in requiredHistoryRequests.GroupBy(x => x.Value))
{
historyRequests = historyRequests.Concat(
CreateBarCountHistoryRequests(byResolution.Select(x => x.Key.Symbol), 3, byResolution.Key));
}
// Request data
var historicLastData = History(historyRequests);
historicLastData.PushThrough(x =>
{
var security = requiredHistoryRequests.Keys.FirstOrDefault(y => y.Symbol == x.Symbol);
security?.Cache.AddData(x);
});
}
// add securities to their respective user defined universes
foreach (var kvp in _pendingUserDefinedUniverseSecurityAdditions)
{
var security = kvp.Key;
var userDefinedUniverse = kvp.Value;
userDefinedUniverse.Add(security.Symbol);
}
// finally add any pending universes, this will make them available to the data feed
foreach (var universe in _pendingUniverseAdditions)
{
UniverseManager.Add(universe.Configuration.Symbol, universe);
}
_pendingUniverseAdditions.Clear();
_pendingUserDefinedUniverseSecurityAdditions.Clear();
}
}
/// <summary>
/// Used to send data updates to algorithm framework models
/// </summary>
/// <param name="slice">The current data slice</param>
public sealed override void OnFrameworkData(Slice slice)
{
if (UtcTime >= UniverseSelection.GetNextRefreshTimeUtc())
{
var universes = UniverseSelection.CreateUniverses(this).ToDictionary(u => u.Configuration.Symbol);
// remove deselected universes by symbol
foreach (var ukvp in UniverseManager)
{
var universeSymbol = ukvp.Key;
var qcUserDefined = UserDefinedUniverse.CreateSymbol(ukvp.Value.SecurityType, ukvp.Value.Market);
if (universeSymbol.Equals(qcUserDefined))
{
// prevent removal of qc algorithm created user defined universes
continue;
}
Universe universe;
if (!universes.TryGetValue(universeSymbol, out universe))
{
if (ukvp.Value.DisposeRequested)
{
UniverseManager.Remove(universeSymbol);
}
// mark this universe as disposed to remove all child subscriptions
ukvp.Value.Dispose();
}
}
// add newly selected universes
foreach (var ukvp in universes)
{
// note: UniverseManager.Add uses TryAdd, so don't need to worry about duplicates here
UniverseManager.Add(ukvp);
}
}
// we only want to run universe selection if there's no data available in the slice
if (!slice.HasData)
{
return;
}
// insight timestamping handled via InsightsGenerated event handler
var insights = Alpha.Update(this, slice).ToArray();
// only fire insights generated event if we actually have insights
if (insights.Length != 0)
{
// debug printing of generated insights
if (DebugMode)
{
Log($"{Time}: ALPHA: {string.Join(" | ", insights.Select(i => i.ToString()).OrderBy(i => i))}");
}
OnInsightsGenerated(insights);
}
// construct portfolio targets from insights
var targets = PortfolioConstruction.CreateTargets(this, insights).ToArray();
// set security targets w/ those generated via portfolio construction module
foreach (var target in targets)
{
var security = Securities[target.Symbol];
security.Holdings.Target = target;
}
if (DebugMode)
{
// debug printing of generated targets
if (targets.Length > 0)
{
Log($"{Time}: PORTFOLIO: {string.Join(" | ", targets.Select(t => t.ToString()).OrderBy(t => t))}");
}
}
var riskTargetOverrides = RiskManagement.ManageRisk(this, targets).ToArray();
// override security targets w/ those generated via risk management module
foreach (var target in riskTargetOverrides)
{
var security = Securities[target.Symbol];
security.Holdings.Target = target;
}
if (DebugMode)
{
// debug printing of generated risk target overrides
if (riskTargetOverrides.Length > 0)
{
Log($"{Time}: RISK: {string.Join(" | ", riskTargetOverrides.Select(t => t.ToString()).OrderBy(t => t))}");
}
}
// execute on the targets, overriding targets for symbols w/ risk targets
var riskAdjustedTargets = riskTargetOverrides.Concat(targets).DistinctBy(pt => pt.Symbol).ToArray();
if (DebugMode)
{
// only log adjusted targets if we've performed an adjustment
if (riskTargetOverrides.Length > 0)
{
Log($"{Time}: RISK ADJUSTED TARGETS: {string.Join(" | ", riskAdjustedTargets.Select(t => t.ToString()).OrderBy(t => t))}");
}
}
Execution.Execute(this, riskAdjustedTargets);
}