/// <summary>
/// Function: recursive helper function for cloning process.
/// </summary>
/// <param name="initialDate">Clone's initialDate</param>
/// <param name="refDate">Clone's refDate</param>
/// <param name="clones">internal table of previously cloned base ids and respective cloned strategies</param>
/// <param name="initial_values">internal table of initial values for the new cloned strategies</param>
/// <param name="simulated">true if the strategy is simulated and not persistent</param>
private Tree Clone_Internal(DateTime initialDate, DateTime refDate, Dictionary <int, Strategy> clones, Dictionary <int, double> initial_values, bool simulated)
{
Dictionary <int, Strategy> clones_internal = new Dictionary <int, Strategy>();
foreach (Strategy strat in _strategyDB.Values.ToList())
{
Tree tree_clone = strat.Tree.Clone_Internal(initialDate, refDate, clones, initial_values, simulated);
if (tree_clone != null)
{
if (!clones.ContainsKey(strat.ID))
{
clones.Add(strat.ID, tree_clone.Strategy);
}
clones_internal.Add(strat.ID, tree_clone.Strategy);
}
}
foreach (Strategy strategy in _strategyDB.Values.ToList())
{
if (strategy.Portfolio == null)
{
if (!clones.ContainsKey(strategy.ID))
{
Strategy subclone = strategy.Clone(null, initialDate, refDate, clones, simulated);
if (!clones.ContainsKey(strategy.ID))
{
clones.Add(strategy.ID, subclone);
}
clones_internal.Add(strategy.ID, subclone);
initial_values.Add(subclone.ID, strategy.GetTimeSeries(TimeSeriesType.Last).Values[0]);
}
else
{
clones_internal.Add(strategy.ID, clones[strategy.ID]);
}
}
}
if (_parentStrategy.Portfolio != null)
{
Portfolio portfolioClone = _parentStrategy.Portfolio.Clone(simulated);
foreach (int[] ids in _parentStrategy.Portfolio.ReserveIds.ToList())
{
Currency ccy = Currency.FindCurrency(ids[0]);
Instrument longReserve = Instrument.FindInstrument(ids[1]);
Instrument shortReserve = Instrument.FindInstrument(ids[2]);
portfolioClone.AddReserve(ccy, longReserve.InstrumentType == InstrumentType.Strategy ? clones[longReserve.ID] : longReserve, shortReserve.InstrumentType == InstrumentType.Strategy ? clones[shortReserve.ID] : shortReserve);
}
Strategy strategyClone = _parentStrategy.Clone(portfolioClone, initialDate, refDate, clones, simulated);
if (!clones.ContainsKey(_parentStrategy.ID))
{
clones.Add(_parentStrategy.ID, strategyClone);
}
initial_values.Add(strategyClone.ID, _parentStrategy.GetAUM(DateTime.Now, TimeSeriesType.Last));
Tree clone = strategyClone.Tree;
foreach (Strategy st in clones_internal.Values.ToList())
{
bool isResidual = st.IsResidual;
if (st.Portfolio != null)
{
st.Portfolio.ParentPortfolio = clone.Strategy.Portfolio;
}
if (isResidual)
{
st.Portfolio.MasterPortfolio.Residual = st;
}
clone.AddSubStrategy(st);
}
if (_parentStrategy.IsResidual)
{
strategyClone.Portfolio.MasterPortfolio.Residual = strategyClone;
}
return(clone);
}
return(null);
}
public static CashFlowGroup CreateStrategy(Instrument instrument, BusinessDay initialDate, double amount, BusinessDay startDate, BusinessDay endDate, InterestRateTenorType ttype, Portfolio parent)
{
if (instrument.InstrumentType == InstrumentType.Strategy)
{
CashFlowGroup Strategy = new CashFlowGroup(instrument);
Strategy.TimeSeriesRoll = TimeSeriesRollType.Last;
Strategy.Amount = amount;
Strategy.StartDate = startDate.DateTime;
Strategy.EndDate = endDate.DateTime;
Strategy.Frequency = ttype;
Portfolio portfolio = null;
if (parent != null)
{
Instrument portfolio_instrument = Instrument.CreateInstrument(instrument.Name + "/Portfolio", InstrumentType.Portfolio, instrument.Name + "/Portfolio", instrument.Currency, FundingType.TotalReturn, instrument.SimulationObject);
portfolio = Portfolio.CreatePortfolio(portfolio_instrument, parent.LongReserve, parent.ShortReserve, parent);
portfolio.TimeSeriesRoll = TimeSeriesRollType.Last;
foreach (Instrument reserve in parent.Reserves)
{
portfolio.AddReserve(reserve.Currency, parent.Reserve(reserve.Currency, PositionType.Long), parent.Reserve(reserve.Currency, PositionType.Short));
}
if (parent.Strategy != null)
{
parent.Strategy.AddInstrument(Strategy, initialDate.DateTime);
}
}
else
{
Currency main_currency = instrument.Currency;
//ConstantStrategy main_cash_strategy = ConstantStrategy.CreateStrategy(instrument.Name + "/" + main_currency + "/Cash", main_currency, initialDate, 1.0, instrument.SimulationObject);
Instrument main_cash_strategy = Instrument.FindInstrument(main_currency.Name + " - Cash");
Instrument portfolio_instrument = Instrument.CreateInstrument(instrument.Name + "/Portfolio", InstrumentType.Portfolio, instrument.Name + "/Portfolio", main_currency, FundingType.TotalReturn, instrument.SimulationObject);
portfolio = Portfolio.CreatePortfolio(portfolio_instrument, main_cash_strategy, main_cash_strategy, parent);
portfolio.TimeSeriesRoll = TimeSeriesRollType.Last;
portfolio.AddReserve(main_currency, main_cash_strategy, main_cash_strategy);
}
portfolio.Strategy = Strategy;
Strategy.GenerateCashFlows(initialDate.DateTime);
double npv = Strategy.NPV(initialDate);
Strategy.Startup(initialDate, npv, portfolio);
Strategy.InitialDate = new DateTime(1990, 01, 06);
double npv2 = Strategy.NPV(initialDate);
// if (parent != null)
// parent.CreatePosition(Strategy, initialDate.DateTime, (Strategy[initialDate.DateTime] == 0.0 ? 0 : 1.0), npv2);
if (!instrument.SimulationObject)
{
Strategy.Portfolio.MasterPortfolio.Strategy.Tree.SaveNewPositions();
Strategy.Portfolio.MasterPortfolio.Strategy.Tree.Save();
}
return(Strategy);
}
else
{
throw new Exception("Instrument not a Strategy");
}
}
