/// <summary>
/// Initializes a new instance of the <see cref="PositionGroupKey"/> class
/// </summary>
/// <param name="buyingPowerModel">The group's buying power model</param>
/// <param name="positions">The positions comprising the group</param>
public PositionGroupKey(IPositionGroupBuyingPowerModel buyingPowerModel, IEnumerable <IPosition> positions)
{
BuyingPowerModel = buyingPowerModel;
// these have to be sorted for determinism
UnitQuantities = positions.Select(p => Tuple.Create(p.Symbol, p.UnitQuantity)).ToImmutableSortedSet();
IsDefaultGroup = UnitQuantities.Count == 1 && BuyingPowerModel.GetType() == typeof(SecurityPositionGroupBuyingPowerModel);
}
/// <summary>
/// Initializes a new instance of the <see cref="PositionGroupKey"/> class for groups with a single security
/// </summary>
/// <param name="buyingPowerModel">The group's buying power model</param>
/// <param name="security">The security</param>
public PositionGroupKey(IPositionGroupBuyingPowerModel buyingPowerModel, Security security)
{
IsDefaultGroup = buyingPowerModel.GetType() == typeof(SecurityPositionGroupBuyingPowerModel);
BuyingPowerModel = buyingPowerModel;
UnitQuantities = new[]
{
Tuple.Create(security.Symbol, security.SymbolProperties.LotSize)
};
}
/// <summary>
/// Computes the amount of buying power reserved by the provided position group
/// </summary>
public static decimal GetReservedBuyingPowerForPositionGroup(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup
)
{
return(model.GetReservedBuyingPowerForPositionGroup(
new ReservedBuyingPowerForPositionGroupParameters(portfolio, positionGroup)
).AbsoluteUsedBuyingPower);
}
/// <summary>
/// The margin that must be held in order to change positions by the changes defined by the provided position group
/// </summary>
public static decimal GetInitialMarginRequirement(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup
)
{
return(model.GetInitialMarginRequirement(
new PositionGroupInitialMarginParameters(portfolio, positionGroup)
).Value);
}
/// <summary>
/// Gets the margin currently allocated to the specified position group
/// </summary>
public static decimal GetMaintenanceMargin(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup
)
{
return(model.GetMaintenanceMargin(
new PositionGroupMaintenanceMarginParameters(portfolio, positionGroup)
));
}
/// <summary>
/// Computes the change in reserved buying power we expect the portfolio to experience if the specified position
/// group is added to the algorithm's holdings
/// </summary>
public static decimal GetChangeInReservedBuyingPower(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup,
Order order
)
{
return(model.GetReservedBuyingPowerImpact(
new ReservedBuyingPowerImpactParameters(portfolio, positionGroup, order)
).Delta);
}
/// <summary>
/// Gets the total margin required to execute the specified order in units of the account currency including fees
/// </summary>
public static decimal GetInitialMarginRequiredForOrder(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup,
Order order
)
{
return(model.GetInitialMarginRequiredForOrder(
new PositionGroupInitialMarginForOrderParameters(portfolio, positionGroup, order)
).Value);
}
/// <summary>
/// Gets the buying power available for a position group trade
/// </summary>
public static PositionGroupBuyingPower GetPositionGroupBuyingPower(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup,
OrderDirection direction
)
{
return(model.GetPositionGroupBuyingPower(new PositionGroupBuyingPowerParameters(
portfolio, positionGroup, direction
)));
}
/// <summary>
/// Check if there is sufficient buying power for the position group to execute this order.
/// </summary>
public static HasSufficientBuyingPowerForOrderResult HasSufficientBuyingPowerForOrder(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup,
Order order
)
{
return(model.HasSufficientBuyingPowerForOrder(new HasSufficientPositionGroupBuyingPowerForOrderParameters(
portfolio, positionGroup, order
)));
}
/// <summary>
/// Get the maximum market position group order quantity to obtain a delta in the buying power used by a position group.
/// The deltas sign defines the position side to apply it to, positive long, negative short.
/// </summary>
public static GetMaximumLotsResult GetMaximumLotsForDeltaBuyingPower(
this IPositionGroupBuyingPowerModel model,
SecurityPortfolioManager portfolio,
IPositionGroup positionGroup,
decimal deltaBuyingPower
)
{
return(model.GetMaximumLotsForDeltaBuyingPower(new GetMaximumLotsForDeltaBuyingPowerParameters(
portfolio, positionGroup, deltaBuyingPower
)));
}
/// <summary>Indicates whether the current object is equal to another object of the same type.</summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns>
public virtual bool Equals(IPositionGroupBuyingPowerModel other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(GetType() == other.GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="PositionManager"/> class
/// </summary>
/// <param name="securities">The algorithm's security manager</param>
public PositionManager(SecurityManager securities)
{
_securities = securities;
Groups = PositionGroupCollection.Empty;
_defaultModel = new SecurityPositionGroupBuyingPowerModel();
_resolver = new CompositePositionGroupResolver(new OptionStrategyPositionGroupResolver(securities),
new SecurityPositionGroupResolver(_defaultModel));
// we must be notified each time our holdings change, so each time a security is added, we
// want to bind to its SecurityHolding.QuantityChanged event so we can trigger the resolver
securities.CollectionChanged += (sender, args) =>
{
var items = args.NewItems ?? new List <object>();
if (args.OldItems != null)
{
foreach (var item in args.OldItems)
{
items.Add(item);
}
}
foreach (Security security in items)
{
if (args.Action == NotifyCollectionChangedAction.Add)
{
security.Holdings.QuantityChanged += HoldingsOnQuantityChanged;
if (security.Invested)
{
// if this security has holdings then we'll need to resolve position groups
_requiresGroupResolution = true;
}
}
else if (args.Action == NotifyCollectionChangedAction.Remove)
{
security.Holdings.QuantityChanged -= HoldingsOnQuantityChanged;
if (security.Invested)
{
// only trigger group resolution if we had holdings in the removed security
_requiresGroupResolution = true;
}
}
}
};
}
public BuyingPowerModelComparator(
IBuyingPowerModel securityModel,
IPositionGroupBuyingPowerModel positionGroupModel,
SecurityPortfolioManager portfolio = null,
ITimeKeeper timeKeeper = null,
IOrderProcessor orderProcessor = null
)
{
Portfolio = portfolio;
SecurityModel = securityModel;
PositionGroupModel = positionGroupModel;
if (portfolio == null)
{
var securities = new SecurityManager(timeKeeper ?? new TimeKeeper(DateTime.UtcNow));
Portfolio = new SecurityPortfolioManager(securities, new SecurityTransactionManager(null, securities));
}
if (orderProcessor != null)
{
Portfolio.Transactions.SetOrderProcessor(orderProcessor);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PositionGroup"/> class
/// </summary>
/// <param name="buyingPowerModel">The buying power model to use for this group</param>
/// <param name="positions">The positions comprising this group</param>
public PositionGroup(IPositionGroupBuyingPowerModel buyingPowerModel, params IPosition[] positions)
: this(new PositionGroupKey(buyingPowerModel, positions), positions.ToDictionary(p => p.Symbol))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityPositionGroupResolver"/> class
/// </summary>
/// <param name="buyingPowerModel">The buying power model to use for created groups</param>
public SecurityPositionGroupResolver(IPositionGroupBuyingPowerModel buyingPowerModel)
{
_buyingPowerModel = buyingPowerModel;
}
