private IEnumerable <Slice> History(IEnumerable <HistoryRequest> requests, DateTimeZone timeZone)
{
var sentMessage = false;
// filter out any universe securities that may have made it this far
var reqs = requests.Where(hr => !UniverseManager.ContainsKey(hr.Symbol)).ToList();
foreach (var request in reqs)
{
// prevent future requests
if (request.EndTimeUtc > UtcTime)
{
request.EndTimeUtc = UtcTime;
if (request.StartTimeUtc > request.EndTimeUtc)
{
request.StartTimeUtc = request.EndTimeUtc;
}
if (!sentMessage)
{
sentMessage = true;
Debug("Request for future history modified to end now.");
}
}
}
// filter out future data to prevent look ahead bias
return(((IAlgorithm)this).HistoryProvider.GetHistory(reqs, timeZone));
}
public void AddUniverseOptions(Symbol underlyingSymbol, Func <OptionFilterUniverse, OptionFilterUniverse> optionFilter)
{
// We need to load the universe associated with the provided Symbol and provide that universe to the option filter universe.
// The option filter universe will subscribe to any changes in the universe of the underlying Symbol,
// ensuring that we load the option chain for every asset found in the underlying's Universe.
Universe universe;
if (!UniverseManager.TryGetValue(underlyingSymbol, out universe))
{
// The universe might be already added, but not registered with the UniverseManager.
universe = _pendingUniverseAdditions.SingleOrDefault(u => u.Configuration.Symbol == underlyingSymbol);
if (universe == null)
{
underlyingSymbol = AddSecurity(underlyingSymbol).Symbol;
}
// Recheck again, we should have a universe addition pending for the provided Symbol
universe = _pendingUniverseAdditions.SingleOrDefault(u => u.Configuration.Symbol == underlyingSymbol);
if (universe == null)
{
// Should never happen, but it could be that the subscription
// created with AddSecurity is not aligned with the Symbol we're using.
throw new InvalidOperationException($"Universe not found for underlying Symbol: {underlyingSymbol}.");
}
}
// Allow all option contracts through without filtering if we're provided a null filter.
AddUniverseOptions(universe, optionFilter ?? (_ => _));
}
private IEnumerable <Slice> History(IEnumerable <HistoryRequest> requests, DateTimeZone timeZone)
{
var sentMessage = false;
// filter out any universe securities that may have made it this far
var filteredRequests = requests.Where(hr => !UniverseManager.ContainsKey(hr.Symbol)).ToList();
for (var i = 0; i < filteredRequests.Count; i++)
{
var request = filteredRequests[i];
// prevent future requests
if (request.EndTimeUtc > UtcTime)
{
var endTimeUtc = UtcTime;
var startTimeUtc = request.StartTimeUtc;
if (request.StartTimeUtc > request.EndTimeUtc)
{
startTimeUtc = request.EndTimeUtc;
}
filteredRequests[i] = new HistoryRequest(startTimeUtc, endTimeUtc,
request.DataType, request.Symbol, request.Resolution, request.ExchangeHours,
request.DataTimeZone, request.FillForwardResolution, request.IncludeExtendedMarketHours,
request.IsCustomData, request.DataNormalizationMode, request.TickType);
if (!sentMessage)
{
sentMessage = true;
Debug("Request for future history modified to end now.");
}
}
}
// filter out future data to prevent look ahead bias
return(((IAlgorithm)this).HistoryProvider.GetHistory(filteredRequests, timeZone));
}
/// <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);
}
//Awake is always called before any Start functions
void Awake()
{
if (instance == null)
instance = this;
else if (instance != this)
Destroy(gameObject);
Init();
}
public override void OnEndOfAlgorithm()
{
if (_optionCount == 0)
{
throw new Exception("Option universe chain did not add any option!");
}
if (UniverseManager.Any(pair => pair.Value.DisposeRequested))
{
throw new Exception("There shouldn't be any disposed universe, they should be removed and replaced by new universes");
}
}
private void Awake()
{
//NextUniverse ();
#region Singleton
if (Instance != null)
{
return;
}
Instance = this;
#endregion
currentUniverse = 0;
}
internal static void Main(string [] args)
{
Catalog.Init("gnome-do", AssemblyInfo.LocaleDirectory);
Gtk.Application.Init();
// We are conservative with the log at first.
Log.DisplayLevel = LogLevel.Error;
if (CorePreferences.PeekDebug)
{
Log.DisplayLevel = LogLevel.Debug;
}
PluginManager.Initialize();
Services.System.EnsureSingleApplicationInstance();
Preferences = new CorePreferences();
// Now we can set the preferred log level.
if (Preferences.QuietStart)
{
Log.DisplayLevel = LogLevel.Error;
}
// Check for debug again in case QuietStart is also set.
if (Preferences.Debug)
{
Log.DisplayLevel = LogLevel.Debug;
}
try {
Services.System.SetProcessName("gnome-do");
} catch (Exception e) {
Log.Error("Failed to set process name: {0}", e.Message);
}
Controller.Initialize();
UniverseManager.Initialize();
if (!Preferences.QuietStart)
{
Controller.Summon();
}
Gtk.Application.Run();
RelevanceProvider.Serialize(RelevanceProvider.DefaultProvider);
}
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 NotifiesWhenSecurityAddedViaIndexer()
{
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[universe.Configuration.Symbol] = universe;
}
public void NotifiesWhenSecurityAddedViaIndexer()
{
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[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 NotifiesWhenSecurityRemoved()
{
var manager = new UniverseManager();
var universe = new FuncUniverse(CreateTradeBarConfig(), new SubscriptionSettings(Resolution.Minute, 2, true, false),
data => data.Select(x => x.Symbol)
);
manager.Add(universe.Configuration.Symbol, universe);
manager.CollectionChanged += (sender, args) =>
{
if (args.OldItems.OfType<object>().Single() != universe)
{
Assert.Fail("Expected args.OldItems to have exactly one element equal to universe");
}
else
{
Assert.IsTrue(args.Action == NotifyCollectionChangedAction.Remove);
Assert.Pass();
}
};
manager.Remove(universe.Configuration.Symbol);
}
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 security to the user defined universe
/// </summary>
/// <param name="security">The security to add</param>
/// <param name="configurations">The <see cref="SubscriptionDataConfig"/> instances we want to add</param>
private Security AddToUserDefinedUniverse(
Security security,
List <SubscriptionDataConfig> configurations)
{
var subscription = configurations.First();
// if we are adding a non-internal security which already has an internal feed, we remove it first
if (Securities.TryGetValue(security.Symbol, out var existingSecurity))
{
if (!subscription.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);
}
else
{
var isTradable = security.IsTradable;
// We will reuse existing so we return it to the user.
// We will use the IsTradable flag of the new security, since existing could of been set to false when removed
security = existingSecurity;
security.IsTradable = isTradable;
}
}
else
{
Securities.Add(security);
}
// add this security to the user defined universe
Universe universe;
var universeSymbol = UserDefinedUniverse.CreateSymbol(security.Type, security.Symbol.ID.Market);
lock (_pendingUniverseAdditionsLock)
{
if (!UniverseManager.TryGetValue(universeSymbol, out universe))
{
universe = _pendingUniverseAdditions.FirstOrDefault(x => x.Configuration.Symbol == universeSymbol);
if (universe == null)
{
// 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,
exchangeTimeZone: DateTimeZone.Utc,
dataTimeZone: DateTimeZone.Utc);
// this is the universe symbol, has no real entry in the mhdb, will default to market and security type
// set entry in market hours database for the universe subscription to match the config
var symbolString = MarketHoursDatabase.GetDatabaseSymbolKey(uconfig.Symbol);
MarketHoursDatabase.SetEntry(uconfig.Market, symbolString, uconfig.SecurityType,
SecurityExchangeHours.AlwaysOpen(uconfig.ExchangeTimeZone), uconfig.DataTimeZone);
universe = new UserDefinedUniverse(uconfig,
new UniverseSettings(
subscription.Resolution,
security.Leverage,
subscription.FillDataForward,
subscription.ExtendedMarketHours,
TimeSpan.Zero),
QuantConnect.Time.MaxTimeSpan,
new List <Symbol>());
AddUniverse(universe);
}
}
}
var userDefinedUniverse = universe as UserDefinedUniverse;
if (userDefinedUniverse != null)
{
lock (_pendingUniverseAdditionsLock)
{
_pendingUserDefinedUniverseSecurityAdditions.Add(
new UserDefinedUniverseAddition(userDefinedUniverse, configurations, security));
}
}
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 {nameof(UserDefinedUniverse)} but was {universe.GetType().Name}.");
}
return(security);
}
/// <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>
/// 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>
/// 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();
}
}
void Update()
{
int layerMask = 1 << 8;
layerMask = ~layerMask;
RaycastHit hit;
// Does the ray intersect any objects excluding the player layer
if (Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), out hit, Mathf.Infinity, layerMask))
{
Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * hit.distance, Color.yellow);
GameObject btn = hit.transform.gameObject;
if (btn.name == "Music")
{
clickPlayer();
if (playMusic == true)
{
M.sprite = btnOnHover;
}
else
{
M.sprite = btnOffHover;
}
if (Input.GetMouseButton(0))
{
if (btn.GetComponent <BoxCollider>().isTrigger)
{
musicHandler.ToggleMusic();
btn.GetComponent <BoxCollider>().isTrigger = false;
StartCoroutine(LateCall(btn));
}
}
}
else if (btn.name == "Sound")
{
if (playSound == true)
{
clickPlayer();
Snd.sprite = btnOnHover;
}
else
{
clickPlayer();
Snd.sprite = btnOffHover;
}
if (Input.GetMouseButton(0))
{
if (btn.GetComponent <BoxCollider>().isTrigger)
{
playSound = !playSound;
btn.GetComponent <BoxCollider>().isTrigger = false;
StartCoroutine(LateCall(btn));
}
}
}
else if (btn.name == "Return")
{
clickPlayer();
B.sprite = normalHover;
if (Input.GetMouseButton(0))
{
SceneManager.LoadScene("mainMenu");
}
}
else if (btn.name == "Exit")
{
clickPlayer();
E.sprite = normalHover;
if (Input.GetMouseButton(0))
{
Application.Quit();
}
}
else if (btn.name == "lowCoverage")
{
clickPlayer();
if (low == true)
{
lC.sprite = btnOnHover;
hC.sprite = btnOff;
mC.sprite = btnOff;
}
else
{
lC.sprite = btnOffHover;
if (medium)
{
hC.sprite = btnOff;
mC.sprite = btnOn;
}
else if (high)
{
hC.sprite = btnOn;
mC.sprite = btnOff;
}
}
if (Input.GetMouseButton(0))
{
low = true;
medium = false;
high = false;
UniverseManager.updateCoverage(150);
}
}
else if (btn.name == "mediumCoverage")
{
clickPlayer();
if (medium == true)
{
mC.sprite = btnOnHover;
hC.sprite = btnOff;
lC.sprite = btnOff;
}
else
{
mC.sprite = btnOffHover;
if (low)
{
hC.sprite = btnOff;
lC.sprite = btnOn;
}
else if (high)
{
hC.sprite = btnOn;
lC.sprite = btnOff;
}
}
if (Input.GetMouseButton(0))
{
low = false;
medium = true;
high = false;
UniverseManager.updateCoverage(300);
}
}
else if (btn.name == "highCoverage")
{
clickPlayer();
if (high == true)
{
hC.sprite = btnOnHover;
lC.sprite = btnOff;
mC.sprite = btnOff;
}
else
{
hC.sprite = btnOffHover;
if (low)
{
mC.sprite = btnOff;
lC.sprite = btnOn;
}
else if (medium)
{
mC.sprite = btnOn;
lC.sprite = btnOff;
}
}
if (Input.GetMouseButton(0))
{
low = false;
medium = false;
high = true;
UniverseManager.updateCoverage(600);
}
}
if (!low && !medium && !high)
{
low = true;
}
}
else
{
clicked = false;
if (playMusic)
{
M.sprite = btnOn;
}
else
{
M.sprite = btnOff;
}
if (playSound)
{
Snd.sprite = btnOn;
}
else
{
Snd.sprite = btnOff;
}
if (low)
{
lC.sprite = btnOn;
}
else
{
lC.sprite = btnOff;
}
if (medium)
{
mC.sprite = btnOn;
}
else
{
mC.sprite = btnOff;
}
if (high)
{
hC.sprite = btnOn;
}
else
{
hC.sprite = btnOff;
}
E.sprite = normal;
B.sprite = normal;
}
}
// Start is called before the first frame update
void Start()
{
ShipList = new List <Ship>();
ShipToObjectMap = new Dictionary <Ship, GameObject>();
um = FindObjectOfType <UniverseManager>();
}
/// <summary>
/// Validate a symbol for a history request.
/// Universe and canonical symbols are only valid for future security types
/// </summary>
private bool HistoryRequestValid(Symbol symbol)
{
return(symbol.SecurityType == SecurityType.Future || !UniverseManager.ContainsKey(symbol) && !symbol.IsCanonical());
}
/// <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);
}
/// <summary>
/// Calculate the maximum runtime for this algorithm job.
/// </summary>
/// <param name="start">State date of the algorithm</param>
/// <param name="finish">End date of the algorithm</param>
/// <param name="subscriptionManager">Subscription Manager</param>
/// <param name="universeManager">Universe manager containing configured universes</param>
/// <param name="controls">Job controls instance</param>
/// <returns>Timespan maximum run period</returns>
private TimeSpan GetMaximumRuntime(DateTime start, DateTime finish, SubscriptionManager subscriptionManager, UniverseManager universeManager, Controls controls)
{
// option/futures chain subscriptions
var derivativeSubscriptions = subscriptionManager.Subscriptions
.Where(x => x.Symbol.IsCanonical())
.Select(x => controls.GetLimit(x.Resolution))
.Sum();
// universe coarse/fine/custom subscriptions
var universeSubscriptions = universeManager
// use max limit for universes without explicitly added securities
.Sum(u => u.Value.Members.Count == 0 ? controls.GetLimit(u.Value.UniverseSettings.Resolution) : u.Value.Members.Count);
var subscriptionCount = derivativeSubscriptions + universeSubscriptions;
double maxRunTime = 0;
var jobDays = (finish - start).TotalDays;
maxRunTime = 10 * subscriptionCount * jobDays;
//Rationalize:
if ((maxRunTime / 3600) > 12)
{
//12 hours maximum
maxRunTime = 3600 * 12;
}
else if (maxRunTime < 60)
{
//If less than 60 seconds.
maxRunTime = 60;
}
Log.Trace("BacktestingSetupHandler.GetMaxRunTime(): Job Days: " + jobDays + " Max Runtime: " + Math.Round(maxRunTime / 60) + " min");
//Override for windows:
if (OS.IsWindows)
{
maxRunTime = 24 * 60 * 60;
}
return(TimeSpan.FromSeconds(maxRunTime));
}
void Start()
{
manager = plane.GetComponent <UniverseManager>();
generator = plane.GetComponent <ObstacleGenerator>();
isFollowing = false;
}
/// <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);
}
