internal TradeDayCalculator(TradeDayInfo data, bool isReset)
{
_info = data;
_isReset = isReset;
_orderPhaseUpdater = new OrderPhaseUpdater(data.CloseOrders, _info.Settings.ResetTime, _info.Instrument.Id, _info.TradeDay);
this.Balance = 0m;
_exchanger = new Exchanger(data.RateSetting);
}
private decimal CalculateValuedPL(decimal value, OrderRelation orderRelation, Exchanger exchanger)
{
return(exchanger.Exchange(value, orderRelation.RateIn, orderRelation.RateOut, orderRelation.Decimals));
}
internal decimal CalculateValuedCloseOrderPL(List <OrderRelation> valuedOrderRelations, Exchanger exchanger)
{
decimal result = 0m;
foreach (var eachOrderRelation in valuedOrderRelations)
{
decimal interestPL = this.CalculateValuedPL(eachOrderRelation.InterestPL, eachOrderRelation, exchanger);
decimal storagePL = this.CalculateValuedPL(eachOrderRelation.StoragePL, eachOrderRelation, exchanger);
decimal tradePL = this.CalculateValuedPL(eachOrderRelation.TradePL, eachOrderRelation, exchanger);
result += (interestPL + storagePL + tradePL);
}
return(result);
}
private static decimal CalculatePhysicalTradePL(PhysicalOrderRelation orderRelation, Exchanger exchanger)
{
decimal result = 0m;
if (orderRelation.PhysicalValueMatureDay == null || orderRelation.RealPhysicalValueMatureDate == orderRelation.PhysicalValueMatureDay)
{
result = exchanger.ExchangeByCommonDecimals(orderRelation.TradePL);
}
return(result);
}
private static void CalculateNotValuedOrderRelationPL(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
foreach (var eachOrderRelation in tradeDayInfo.OrderRelations)
{
Order closeOrder = eachOrderRelation.CloseOrder;
if (!closeOrder.ShouldCalculate(affectedOrders))
{
continue;
}
PhysicalOrder physicalCloseOrder = closeOrder as PhysicalOrder;
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= tradeDayInfo.Settings.ResetTime && eachOrderRelation.ValueTime == null)
{
OrderResetResult resetResult = CreateOrderResetResult(closeOrder, tradeDayInfo, resetOrderDict);
resetResult.NotValuedPL += new InterestStorage(exchanger.ExchangeByCommonDecimals(eachOrderRelation.InterestPL), exchanger.ExchangeByCommonDecimals(eachOrderRelation.StoragePL));
resetResult.TradePLNotValued += exchanger.ExchangeByCommonDecimals(eachOrderRelation.TradePL);
if (physicalOrderRelation != null)
{
resetResult.PhysicalTradePLNotValued += CalculatePhysicalTradePL(physicalOrderRelation, exchanger);
}
}
}
}
private static void CalculateValuedOrderRelationPL(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
foreach (var eachOrderRelation in tradeDayInfo.OrderRelations)
{
Order closeOrder = eachOrderRelation.CloseOrder;
if (!closeOrder.ShouldCalculate(affectedOrders))
{
continue;
}
if (closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= tradeDayInfo.Settings.ResetTime && eachOrderRelation.ValueTime > tradeDayInfo.Settings.BeginTime && eachOrderRelation.ValueTime <= tradeDayInfo.Settings.ResetTime)
{
var resetResult = CreateOrderResetResult(closeOrder, tradeDayInfo, resetOrderDict);
var valuedPL = eachOrderRelation.CalculateValuedPL();
resetResult.ValuedPL += new InterestStorage(valuedPL.InterestPL, valuedPL.StoragePL);
resetResult.TradePLValued += valuedPL.TradePL;
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (physicalOrderRelation != null)
{
resetResult.PhysicalTradePLValued += CalculatePhysicalTradePL(physicalOrderRelation, exchanger);
}
}
}
}
internal static void Calculate(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
CalculateNotValuedOrderRelationPL(tradeDayInfo, exchanger, resetOrderDict, affectedOrders);
CalculateValuedOrderRelationPL(tradeDayInfo, exchanger, resetOrderDict, affectedOrders);
}
private void CalculatePL(OrderDayHistory orderDayHistory, Dictionary <Guid, InterestStorage> dict, Exchanger exchanger)
{
var interestPL = exchanger.ExchangeByCommonDecimals(orderDayHistory.DayInterestPLNotValued);
var storagePL = exchanger.ExchangeByCommonDecimals(orderDayHistory.DayStoragePLNotValued);
InterestStorage interestStoragePL;
if (!dict.TryGetValue(orderDayHistory.OrderID, out interestStoragePL))
{
dict.Add(orderDayHistory.OrderID, new InterestStorage(interestPL, storagePL));
}
else
{
dict[orderDayHistory.OrderID] = new InterestStorage(interestStoragePL.Interest + interestPL, interestStoragePL.Storage + storagePL);
}
}
internal Dictionary <Guid, InterestStorage> Calculate(Guid accountId, Guid instrumentId, IEnumerable <Order> allExecuteOrders, DateTime tradeDay, Exchanger exchanger, List <Guid> affectedOrders)
{
if (!this.ShouldCalculate(instrumentId, tradeDay))
{
return(null);
}
Dictionary <Guid, InterestStorage> result = new Dictionary <Guid, InterestStorage>();
var instrumentOpenCloseHistorys = this.GetInstrumentDayOpenCloseHistorys(instrumentId, tradeDay);
var orderKeys = GetOrderKeys(allExecuteOrders, instrumentOpenCloseHistorys);
var historyOrders = ResetManager.Default.GetOrderDayHistorys(orderKeys);
if (historyOrders == null || historyOrders.Count == 0)
{
return(result);
}
foreach (var eachOrder in allExecuteOrders)
{
if (!eachOrder.IsOpen || !eachOrder.ShouldCalculate(affectedOrders))
{
continue;
}
foreach (var eachInstrument in instrumentOpenCloseHistorys)
{
foreach (var eachOrderDayHistory in historyOrders)
{
if (this.ShouldAddOrderDayHistoryToPL(eachOrder, eachOrderDayHistory, eachInstrument, tradeDay))
{
CalculatePL(eachOrderDayHistory, result, exchanger);
}
}
}
}
return(result);
}
internal static Dictionary <Guid, OpenOrderPLOfCurrentDay> Calculate(TradeDayInfo tradeDayInfo, Dictionary <Guid, TradeDayCommonResult> resetCommonResultDict, Exchanger exchanger)
{
if (tradeDayInfo.Settings.ValueDate == null && !tradeDayInfo.Settings.UseCompatibleMode)
{
return(null);
}
Dictionary <Guid, OpenOrderPLOfCurrentDay> result = new Dictionary <Guid, OpenOrderPLOfCurrentDay>();
foreach (var eachPair in resetCommonResultDict)
{
var orderId = eachPair.Key;
var commonResetResult = eachPair.Value;
if (!orderId.ShouldCalculate(tradeDayInfo.AffectedOrders))
{
continue;
}
var eachOrder = tradeDayInfo.GetOrder(orderId);
if (!IsOpenOrderOfCurrentDay(eachOrder, tradeDayInfo))
{
continue;
}
OpenOrderPLOfCurrentDay openOrderPLOfCurrentDay = new OpenOrderPLOfCurrentDay();
int decimals = tradeDayInfo.Settings.IsInterestUseAccountCurrency ? tradeDayInfo.RateSetting.RoundDecimals.Max : tradeDayInfo.RateSetting.RoundDecimals.Instrument;
var storage = Math.Round(eachOrder.LotBalance * commonResetResult.StoragePerLot, decimals, MidpointRounding.AwayFromZero);
var interest = Math.Round(eachOrder.LotBalance * commonResetResult.InterestPerLot, decimals, MidpointRounding.AwayFromZero);
openOrderPLOfCurrentDay.DayNotValued += tradeDayInfo.Settings.ShouldValueCurrentDayPL ? InterestStorage.Empty : new InterestStorage(interest, storage);
var exchangeStorage = exchanger.ExchangeByCommonDecimals(storage);
var exchangeInterest = exchanger.ExchangeByCommonDecimals(interest);
openOrderPLOfCurrentDay.NotValued += tradeDayInfo.Settings.ShouldValueCurrentDayPL ? InterestStorage.Empty : new InterestStorage(exchangeInterest, exchangeStorage);
bool isInterestValued = (eachOrder.InterestValueDate ?? tradeDayInfo.TradeDay) <= tradeDayInfo.TradeDay;
decimal interestPLValued = tradeDayInfo.Settings.ShouldValueCurrentDayPL && isInterestValued ? exchangeInterest : 0;
decimal storagePLValued = tradeDayInfo.Settings.ShouldValueCurrentDayPL ? exchangeStorage : 0;
openOrderPLOfCurrentDay.Valued += new InterestStorage(interestPLValued, storagePLValued);
openOrderPLOfCurrentDay.IsInterestValued = isInterestValued;
openOrderPLOfCurrentDay.IsStorageValued = true;
result.Add(orderId, openOrderPLOfCurrentDay);
}
return(result);
}