/// <summary>
/// Initializes this alpha handler to accept insights from the specified algorithm
/// </summary>
/// <param name="job">The algorithm job</param>
/// <param name="algorithm">The algorithm instance</param>
/// <param name="messagingHandler">Handler used for sending insights</param>
/// <param name="api">Api instance</param>
public virtual void Initialize(AlgorithmNodePacket job, IAlgorithm algorithm, IMessagingHandler messagingHandler, IApi api)
{
// initializing these properties just in case, doens't hurt to have them populated
Job = job;
Algorithm = algorithm;
MessagingHandler = messagingHandler;
_fitnessScore = new FitnessScoreManager();
_securityValuesProvider = new AlgorithmSecurityValuesProvider(algorithm);
InsightManager = CreateInsightManager();
// send scored insights to messaging handler
InsightManager.AddExtension(CreateAlphaResultPacketSender());
var statistics = new StatisticsInsightManagerExtension(algorithm);
RuntimeStatistics = statistics.Statistics;
InsightManager.AddExtension(statistics);
_charting = new ChartingInsightManagerExtension(algorithm, statistics);
InsightManager.AddExtension(_charting);
// when insight is generated, take snapshot of securities and place in queue for insight manager to process on alpha thread
algorithm.InsightsGenerated += (algo, collection) => InsightManager.Step(collection.DateTimeUtc, CreateSecurityValuesSnapshot(), collection);
}
/// <summary>
/// Initializes this alpha handler to accept insights from the specified algorithm
/// </summary>
/// <param name="job">The algorithm job</param>
/// <param name="algorithm">The algorithm instance</param>
/// <param name="messagingHandler">Handler used for sending insights</param>
/// <param name="api">Api instance</param>
public virtual void Initialize(AlgorithmNodePacket job, IAlgorithm algorithm, IMessagingHandler messagingHandler, IApi api)
{
// initializing these properties just in case, doesn't hurt to have them populated
Job = job;
Algorithm = algorithm;
MessagingHandler = messagingHandler;
_fitnessScore = new FitnessScoreManager();
_insights = new List <Insight>();
_securityValuesProvider = new AlgorithmSecurityValuesProvider(algorithm);
InsightManager = CreateInsightManager();
var statistics = new StatisticsInsightManagerExtension(algorithm);
RuntimeStatistics = statistics.Statistics;
InsightManager.AddExtension(statistics);
AddInsightManagerCustomExtensions(statistics);
// when insight is generated, take snapshot of securities and place in queue for insight manager to process on alpha thread
algorithm.InsightsGenerated += (algo, collection) =>
{
lock (_insights)
{
_insights.AddRange(collection.Insights);
}
};
}
/// <summary>
/// Initializes this alpha handler to accept alphas from the specified algorithm
/// </summary>
/// <param name="job">The algorithm job</param>
/// <param name="algorithm">The algorithm instance</param>
/// <param name="messagingHandler">Handler used for sending alphas</param>
/// <param name="api">Api instance</param>
public virtual void Initialize(AlgorithmNodePacket job, IAlgorithm algorithm, IMessagingHandler messagingHandler, IApi api)
{
// initializing these properties just in case, doens't hurt to have them populated
Job = job;
Algorithm = algorithm;
_messagingHandler = messagingHandler;
_isNotFrameworkAlgorithm = !algorithm.IsFrameworkAlgorithm;
if (_isNotFrameworkAlgorithm)
{
return;
}
_securityValuesProvider = new AlgorithmSecurityValuesProvider(algorithm);
AlphaManager = CreateAlphaManager();
var statistics = new StatisticsAlphaManagerExtension();
RuntimeStatistics = statistics.Statistics;
AlphaManager.AddExtension(statistics);
_charting = new ChartingAlphaManagerExtension(algorithm, statistics);
AlphaManager.AddExtension(_charting);
// when alpha is generated, take snapshot of securities and place in queue for alpha manager to process on alpha thread
algorithm.AlphasGenerated += (algo, collection) => _alphaQueue.Enqueue(new AlphaQueueItem(collection.DateTimeUtc, CreateSecurityValuesSnapshot(), collection));
}
/// <summary>
/// Initializes a new instance of the <see cref="QCAlgorithmFramework"/> class
/// </summary>
public QCAlgorithmFramework()
{
_securityValuesProvider = new AlgorithmSecurityValuesProvider(this);
// set model defaults
Execution = new ImmediateExecutionModel();
RiskManagement = new NullRiskManagementModel();
}
/// <summary>
/// Creates a new instance of <see cref="ReadOnlySecurityValuesCollection"/> to hold all <see cref="SecurityValues"/> for
/// the specified symbol at the current instant in time
/// </summary>
/// <param name="securityValuesProvider">Security values provider fetches security values for each symbol</param>
/// <param name="symbols">The symbols to get values for</param>
/// <returns>A collection of</returns>
public static ReadOnlySecurityValuesCollection GetValues(this ISecurityValuesProvider securityValuesProvider, IEnumerable <Symbol> symbols)
{
var values = new Dictionary <Symbol, SecurityValues>();
foreach (var symbol in symbols.Distinct())
{
values[symbol] = securityValuesProvider.GetValues(symbol);
}
return(new ReadOnlySecurityValuesCollection(values));
}
/// <summary>
/// Initializes a new instance of the <see cref="AlphaManager"/> class
/// </summary>
/// <param name="securityValuesProvider">Providers security values, such as price/volatility</param>
/// <param name="scoreFunctionProvider">Provides scoring functions by alpha type/score type</param>
/// <param name="extraAnalysisPeriodRatio">Ratio of the alpha period to keep the analysis open</param>
public AlphaManager(ISecurityValuesProvider securityValuesProvider, IAlphaScoreFunctionProvider scoreFunctionProvider, double extraAnalysisPeriodRatio)
{
if (extraAnalysisPeriodRatio < 0)
{
throw new ArgumentOutOfRangeException(nameof(extraAnalysisPeriodRatio), "extraAnalysisPeriodRatio must be greater than or equal to zero.");
}
_scoreFunctionProvider = scoreFunctionProvider;
_securityValuesProvider = securityValuesProvider;
_extraAnalysisPeriodRatio = extraAnalysisPeriodRatio;
_openAlphaContexts = new ConcurrentDictionary <Guid, AlphaAnalysisContext>();
_closedAlphaContexts = new ConcurrentDictionary <Guid, AlphaAnalysisContext>();
_updatedAlphaContextsByAlphaId = new ConcurrentDictionary <Guid, AlphaAnalysisContext>();
}
/// <summary>
/// Initializes a new instance of the <see cref="QCAlgorithmFramework"/> class
/// </summary>
public QCAlgorithmFramework()
{
_securityValuesProvider = new AlgorithmSecurityValuesProvider(this);
// set model defaults
Execution = new ImmediateExecutionModel();
RiskManagement = new NullRiskManagementModel();
// set generated and close times on all insights
InsightsGenerated += (algorithm, data) =>
{
foreach (var insight in data.Insights)
{
SetGeneratedAndClosedTimes(insight);
}
};
}
/// <summary>
/// Initializes this alpha handler to accept insights from the specified algorithm
/// </summary>
/// <param name="job">The algorithm job</param>
/// <param name="algorithm">The algorithm instance</param>
/// <param name="messagingHandler">Handler used for sending insights</param>
/// <param name="api">Api instance</param>
/// <param name="transactionHandler">Algorithms transaction handler</param>
public virtual void Initialize(AlgorithmNodePacket job, IAlgorithm algorithm, IMessagingHandler messagingHandler, IApi api, ITransactionHandler transactionHandler)
{
// initializing these properties just in case, doesn't hurt to have them populated
Job = job;
Algorithm = algorithm;
MessagingHandler = messagingHandler;
_fitnessScore = new FitnessScoreManager();
_insights = new List <Insight>();
_securityValuesProvider = new AlgorithmSecurityValuesProvider(algorithm);
InsightManager = CreateInsightManager();
var statistics = new StatisticsInsightManagerExtension(algorithm);
RuntimeStatistics = statistics.Statistics;
InsightManager.AddExtension(statistics);
AddInsightManagerCustomExtensions(statistics);
var baseDirectory = Config.Get("results-destination-folder", Directory.GetCurrentDirectory());
var directory = Path.Combine(baseDirectory, AlgorithmId);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
_alphaResultsPath = Path.Combine(directory, "alpha-results.json");
// when insight is generated, take snapshot of securities and place in queue for insight manager to process on alpha thread
algorithm.InsightsGenerated += (algo, collection) =>
{
lock (_insights)
{
_insights.AddRange(collection.Insights);
}
};
}
