示例#1
0
 def loadAndSaveMarketData(self, pricingDate, marketId):
     ''' assumes that 'EOD' marketId exists '''
     eodCurve = InterestRateCurve()
     eodCurve.ccy = self.tCBond.ccy
     eodCurve.index = Enum.Index('LIBOR')
     eodCurve.term = 'M'
     eodCurve.numTerms = 3
     eodCurve.pricingDate = pricingDate
     eodCurve.marketId = 'EOD'
     eodCurve.load()
     irCurve = InterestRateCurve()
     irCurve.ccy = self.tCBond.ccy
     irCurve.index = Enum.Index('LIBOR')
     irCurve.term = 'M'
     irCurve.numTerms = 3
     irCurve.pricingDate = pricingDate
     irCurve.marketId = marketId
     eodRates = eodCurve.getRates()
     for rate in eodRates:
         irCurve.addRate(rate)
     irCurve.save()
     eodBondOAS = BondOAS.objects.get(tCBond=self.tCBond, pricingDate=pricingDate,
                                   marketId='EOD')
     bondOAS = BondOAS(tCBond=self.tCBond, pricingDate=pricingDate,
                       marketId=marketId,mid=eodBondOAS.mid)
     bondOAS.save()
示例#2
0
    def setupQL(self, pricingDate, marketId=''):
        QuantLib.Settings.instance().evaluationDate = pricingDate.ql()
        # Get market data curve based on Ccy/Index
        self.pricingDate = pricingDate
        curve = InterestRateCurve()
        curve.pricingDate = pricingDate
        curve.ccy = self.tCBond.ccy
        #TODO Fix term to make it TimePeriod
        curve.index = Enum.Index('LIBOR')
        curve.term = 'M'
        curve.numTerms = 3
        curve.marketId = marketId
#        print 'marketDataContainer in setupQL'
 #       print self.marketDataContainer
        if self.marketDataContainer == None:
            raise ErrorHandling.MarketDataMissing('marketDataContainer is None')
        newCurve = self.marketDataContainer.find(curve)
        #print 'newCurve in setupQL'
        #print newCurve
        if newCurve == None:
            raise ErrorHandling.MarketDataMissing('Cannot find market data %s' % curve)
        #load OAS and adjust discount curve
        bondOAS = self.marketDataContainer.find(BondOAS(marketId=marketId,pricingDate=pricingDate,
                                                        tCBond=self.tCBond))
        newCurve.shift(shiftAmount=bondOAS.mid)
        # Map curve to QuantLib deposit rates
        depositCurve = newCurve.buildZeroCurve()
        #print 'deposit curve in setupQL'
        #print depositCurve.nodes()
        #Pricing Engine
        discountTermStructure = QuantLib.RelinkableYieldTermStructureHandle()
        discountTermStructure.linkTo(depositCurve)

        fixedSchedule = QuantLib.Schedule(pricingDate.ql(), 
                                          Date.createQLDateFromPythonDate(self.tCBond.endDate),
                                          QuantLib.Period(1,QuantLib.Years),
                                          self.tCBond.paymentCalendar.ql(),
                                          self.tCBond.paymentRollRule.ql(), 
                                          self.tCBond.paymentRollRule.ql(),
                                          QuantLib.DateGeneration.Forward, 
                                          False)
                
        coupons = []
        coupons.append(float(self.tCBond.coupon))
        #print self.tCBond.coupon
        #print self.tCBond.coupon.__class__
#        coupons.append(0.04)
        self.qlBond = QuantLib.FixedRateBond(2, 
                                      100, 
                                      fixedSchedule, 
                                      coupons, 
                                      self.tCBond.basis.ql(), 
                                      self.tCBond.paymentRollRule.ql(), 
                                      100, 
                                      pricingDate.ql())
        
        bondEngine = \
            QuantLib.DiscountingBondEngine(discountTermStructure)
        self.qlBond.setPricingEngine(bondEngine)
        self.upToDate = True
 def loadInterestRateFromCSVFile(self, fileName):
     '''
     Downloads prices from fileName. fileName needs to include full path
     '''
     file = open(fileName,'r')
     lastDate = Date.Date(month=1,day=1,year=1972)
     for line in file:
         items = line.split(',')
         #skip first line which is headers
         if items[0] == 'date':
             continue
         #create new curve if date has changed
         curveDate = self.createDateFromString(items[0])
         if curveDate <> lastDate:
             newCurve = InterestRateCurve()
             newCurve.pricingDate = curveDate
             newCurve.ccy = items[1]
             newCurve.index = items[2]
             newCurve.marketId = items[3]
             newCurve.term = items[4]
             newCurve.numTerms = int(items[5])
             newCurve.save()
             newCurve.load()
             #Delete all rates in case the curve already existed
             rates = InterestRate.objects.filter(curve=newCurve)
             if rates:
                 rates.delete()
         curve = InterestRateCurve()
         curve.pricingDate = curveDate
         curve.ccy = items[1]
         curve.index = items[2]
         curve.marketId = items[3]
         curve.term = items[4]
         curve.numTerms = int(items[5])
         curve.load()
         rate = InterestRate()
         rate.curve = curve
         rate.type = items[6]
         rate.term = items[7]
         rate.numTerms = int(items[8])
         rate.mid = float(items[9])
         rate.save()
         lastDate = curveDate
示例#4
0
 def marketData(self, pricingDate, marketId=''):
     irCurve = InterestRateCurve()
     irCurve.ccy = self._tcSwap.ccy
     irCurve.index = Index('LIBOR')
     irCurve.term = 'M'
     irCurve.numTerms = 3
     irCurve.pricingDate = pricingDate
     irCurve.marketId = marketId
     irCurve.load()
     l = []
     l.append(irCurve)
     return l
 def loadDummyIRCurve(self, pricingDate):
     curve = InterestRateCurve()
     curve.ccy = 'USD'
     curve.index = Enum.Index('LIBOR')
     curve.term = 'M'
     curve.numTerms = 3
     curve.pricingDate = pricingDate
     curve.marketId = 'TEST1'
     r1 = InterestRate()
     r1.type = 'Deposit'
     r1.term = 'M'
     r1.numTerms = 1
     r1.mid = 0.01
     r1.curve = curve
     r2 = InterestRate()
     r2.type = 'Deposit'
     r2.term = 'M'
     r2.numTerms = 3
     r2.mid = 0.01
     r2.curve = curve
     r3 = InterestRate()
     r3.type = 'Swap'
     r3.term = 'Y'
     r3.numTerms = 1
     r3.mid = 0.01
     r3.curve = curve
     r4 = InterestRate()
     r4.type = 'Swap'
     r4.term = 'Y'
     r4.numTerms = 5
     r4.mid = 0.01
     r4.curve = curve
     r5 = InterestRate()
     r5.type = 'Swap'
     r5.term = 'Y'
     r5.numTerms = 10
     r5.mid = 0.01
     r5.curve = curve
     r6 = InterestRate()
     r6.type = 'Swap'
     r6.term = 'Y'
     r6.numTerms = 30
     r6.mid = 0.01
     r6.curve = curve
     curve.addRate(r1)
     curve.addRate(r2)
     curve.addRate(r3)
     curve.addRate(r4)
     curve.addRate(r5)
     curve.addRate(r6)
     curve.save()
示例#6
0
 def loadAndSaveMarketData(self, pricingDate, marketId):
     ''' assumes that 'EOD' marketId exists
     algorithm is to load the EOD curve and save it with marketId
     '''
     eodCurve = InterestRateCurve()
     eodCurve.ccy = self._tcSwap.ccy
     eodCurve.index = Index('LIBOR')
     eodCurve.term = 'M'
     eodCurve.numTerms = 3
     eodCurve.pricingDate = pricingDate
     eodCurve.marketId = 'EOD'
     eodCurve.load()
     irCurve = InterestRateCurve()
     irCurve.ccy = self._tcSwap.ccy
     irCurve.index = Index('LIBOR')
     irCurve.term = 'M'
     irCurve.numTerms = 3
     irCurve.pricingDate = pricingDate
     irCurve.marketId = marketId
     eodRates = eodCurve.getRates()
     for rate in eodRates:
         irCurve.addRate(rate)
     irCurve.save()
 def testLoadAndSaveMarketData_TODO(self):
     #curve should never exist
     self.pos.loadAndSaveMarketData(pricingDate=Date.Date(1,1,2009), 
                                    marketId=self.marketId)
     #now, curve should exist
     irCurve = InterestRateCurve()
     irCurve.ccy = Enum.Currency('USD')
     irCurve.index = Enum.Index('LIBOR')
     irCurve.term = 'M'
     irCurve.numTerms = 3
     irCurve.pricingDate = Date.Date(1,1,2009)
     irCurve.marketId = self.marketId
     irCurve.load()
     #now, delete again so that next test will work
     irCurve.delete()
示例#8
0
 def marketData(self, pricingDate, marketId=''):
     irCurve = InterestRateCurve()
     irCurve.ccy = self.tCBond.ccy
     irCurve.index = Enum.Index('LIBOR')
     irCurve.term = 'M'
     irCurve.numTerms = 3
     irCurve.pricingDate = pricingDate
     irCurve.marketId = marketId
     irCurve.load()
     l = []
     l.append(irCurve)
     ##print pricingDate
     bondOAS = BondOAS.objects.get(tCBond=self.tCBond, pricingDate=pricingDate,
                                   marketId=marketId)
     l.append(bondOAS)
     return l
 def testSingleIRCurveScenario(self):
     irA = InterestRateCurve()
     irA.ccy = "USD"
     irA.index = "LIBOR"
     irA.term = 'M'
     irA.numTerms = 3
     irA.marketId = 'TEST1'
     irA.pricingDate = Date.Date(month=9, day=12, year=2011)
     irA.load()
     scenarioBase = MarketDataScenario.MarketDataScenario()
     scenarioBase.name = 'Base'
     scenarioBase.marketData = irA
     #print scenarioBase
     scenarioUp = MarketDataScenario.MarketDataScenario()
     scenarioUp.name = 'Up'
     irB = copy.copy(irA)
     for item in irB.rates:
         item.mid = item.mid * 1.01
     scenarioUp.marketData = irB
示例#10
0
    def _setupQL(self, pricingDate, marketId=''):
        QuantLib.Settings.instance().evaluationDate = pricingDate.ql()
#        print 'in setupql'
        self._pricingDate = pricingDate
        # Get market data curve based on Ccy/Index
        curve = InterestRateCurve()
        curve.pricingDate = pricingDate
        curve.ccy = self._tcSwap.ccy
        curve.index = Index('LIBOR')
        curve.term = 'M'
        curve.numTerms = self._tcSwap.floatingIndexNumTerms
        curve.marketId = marketId
        if self.marketDataContainer == None:
            raise ErrorHandling.MarketDataMissing('marketDataContainer is None')
        newCurve = self.marketDataContainer.find(curve)
        if newCurve == None:
            raise ErrorHandling.MarketDataMissing('Cannot find market data %s' % curve)
        depositCurve = newCurve.buildZeroCurve()
        discountTermStructure = QuantLib.RelinkableYieldTermStructureHandle()
        discountTermStructure.linkTo(depositCurve)

        swapEngine = QuantLib.DiscountingSwapEngine(discountTermStructure)

        #TODO fix the discounting curve to make if projected fwd curve
        index = QuantLib.Euribor6M(discountTermStructure)

        #fixingDate = Date.Date(month=9,day=10,year=2012)
        #index.addFixing(fixingDate.ql(),0.02)
        
        #tcSwap dates are python dates
        fixedSchedule = QuantLib.Schedule(Date.createQLDateFromPythonDate(self._tcSwap.startDate),
                                          Date.createQLDateFromPythonDate(self._tcSwap.endDate),
                                          #fixedLegTenor is QuantLib.Period(n,unit)
                                          #Period is an integer (n) and TimePeriod (unit)
                                          #TODO fix payment freq
                                          QuantLib.Period(6,QuantLib.Months),
                                          self._tcSwap.fixedPaymentCalendar.ql(),
                                          self._tcSwap.fixedPaymentRollRule.ql(),
                                          self._tcSwap.fixedPaymentRollRule.ql(),
                                          QuantLib.DateGeneration.Forward, 
                                          False)
        
        floatingSchedule = QuantLib.Schedule(Date.createQLDateFromPythonDate(self._tcSwap.startDate),
                                          Date.createQLDateFromPythonDate(self._tcSwap.endDate),
                                          #fixedLegTenor is QuantLib.Period(n,unit)
                                          #Period is an integer (n) and TimePeriod (unit)
                                          #TODO fix payment freq
                                          QuantLib.Period(3,QuantLib.Months),
                                          self._tcSwap.floatingPaymentCalendar.ql(),
                                          self._tcSwap.floatingPaymentRollRule.ql(),
                                          self._tcSwap.floatingPaymentRollRule.ql(),
                                          QuantLib.DateGeneration.Forward, 
                                          False) 
    
    #TODO: FIx to decide if it's payer or receiver fixed
        self._qlSwap = QuantLib.VanillaSwap(QuantLib.VanillaSwap.Payer, 
                                            self.amount,
                                            fixedSchedule, 
                                            self._tcSwap.fixedCoupon, 
                                            self._tcSwap.fixedBasis.ql(),
                                            floatingSchedule, 
                                            #TODO fix index
                                            index,
                                            self._tcSwap.floatingSpread,
                                            self._tcSwap.floatingBasis.ql())
        
        self._qlSwap.setPricingEngine(swapEngine)
        self.upToDate = True
示例#11
0
    def dataForSuccessfulTest(self):
        '''
        This saves all data so that system tests run successfully
        Pricing date is 9/12/2011 with market data id TEST1
        '''
        testDatePython = date(month=9,day=12,year=2011)
        testDate = Date(month=9,day=12,year=2011)
        testFirstDate = Date(month=8,day=30,year=2011)
        
        if not Location.objects.filter(name='Test1').exists():
            location = Location()
            location.name = 'Test1'
            location.pricingDate = date(month=9,day=12,year=2011)
            location.save()
        location = Location.objects.get(name='Test1')
            
        if not User.objects.filter(username='******').exists():
            user = User.objects.create_user(username='******',email='*****@*****.**',\
                                            password='******')
            user.is_staff = True
            user.is_superuser = True
            user.save()

        if not User.objects.filter(username='******').exists():
            User.objects.create_user(username='******',email='*****@*****.**',\
                                     password='******')

        if not User.objects.filter(username='******').exists():
            User.objects.create_user(username='******',email='*****@*****.**',\
                                     password='******')

        if not User.objects.filter(username='******').exists():
            User.objects.create_user(username='******',email='*****@*****.**',\
                                     password='******')

        user1 = User.objects.get(username='******')
        if not UserProfile.objects.filter(user=user1).exists():
            up1 = UserProfile()
            up1.user = user1
            up1.location = location
            up1.marketId = 'EOD'
            up1.save()
            
        user2 = User.objects.get(username='******')
        if not UserProfile.objects.filter(user=user2).exists():
            up2 = UserProfile()
            up2.user = user2
            up2.location = location
            up2.marketId = 'EOD'
            up2.save()

        user3 = User.objects.get(username='******')
        if not UserProfile.objects.filter(user=user3).exists():
            up3 = UserProfile()
            up3.user = user3
            up3.location = location
            up3.marketId = 'TEST1'
            up3.save()

        user4 = User.objects.get(username='******')
        if not UserProfile.objects.filter(user=user4).exists():
            up4 = UserProfile()
            up4.user = user4
            up4.location = location
            up4.marketId = 'DEMO'
            up4.save()
        
        if not TCBond.objects.filter(name='TEST1').exists():
            bond = TCBond()
            bond.name = 'TEST1'
            bond.ccy = 'USD'
            cusip = Enum.BondIdentifierType('CUSIP') 
            if not Identifier.objects.filter(name='123456789', type=cusip):
                identifier = Identifier()
                identifier.name='123456789'
                identifier.type=cusip
                identifier.save()
            identifier = Identifier.objects.get(name='123456789', type=cusip)  
            bond.identifiers = identifier
            bond.startDate = Date(month=9,day=12,year=2010).toPythonDate()
            bond.endDate = Date(month=9,day=12,year=2020).toPythonDate()
            bond.coupon = 0.01
            bond.basis = '30360'
            bond.paymentFrequency = Enum.Frequency('S')
            bond.paymentRollRule = Enum.Roll('MF')
            bond.paymentCalendar = Calendar.createCalendar('US')
            bond.assetType = Enum.AssetType('NYMUNIBOND')
            bond.save()

        if not Equity.objects.filter(ticker='TEST1').exists():
            equity = Equity()
            equity.ticker = 'TEST1'
            equity.assetType = Enum.AssetType('EQUITYUS')
            equity.save()
        equity = Equity.objects.get(ticker='TEST1')
        stockPrice = StockPrice()
        stockPrice.equity = equity
        stockPrice.pricingDate = testDate
        stockPrice.marketId = 'TEST1'
        stockPrice.mid = 123.45
        stockPrice.save()
        equity = Equity.objects.get(ticker='TEST1')
        stockPrice = StockPrice()
        stockPrice.equity = equity
        stockPrice.pricingDate = testFirstDate
        stockPrice.marketId = 'TEST1'
        stockPrice.mid = 123.44
        stockPrice.save()
        if not Equity.objects.filter(ticker='TEST2').exists():
            equity = Equity()
            equity.ticker = 'TEST2'
            equity.assetType = Enum.AssetType('EQUITYUS')
            equity.save()
        equity = Equity.objects.get(ticker='TEST2')
        stockPrice = StockPrice()
        stockPrice.equity = equity
        stockPrice.pricingDate = testDate
        stockPrice.marketId = 'TEST1'
        stockPrice.mid = 543.21
        stockPrice.save()
        equity = Equity.objects.get(ticker='TEST2')
        stockPrice = StockPrice()
        stockPrice.equity = equity
        stockPrice.pricingDate = testFirstDate
        stockPrice.marketId = 'TEST1'
        stockPrice.mid = 543.11
        stockPrice.save()
        
        if not Portfolio.objects.filter(name='TEST1', user='******').exists():
            portfolio =Portfolio()
            portfolio.name = 'TEST1'
            portfolio.user = '******'
            portfolio.save()
        portfolio =Portfolio.objects.get(name='TEST1', user='******')
        
        if not ModelPosition.objects.filter(asOf=testDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('EQUITY'),
                                       ticker = 'TEST1', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('EQUITY')
            position.ticker = 'TEST1'
            position.amount = 100.0
            position.save()

        if not ModelPosition.objects.filter(asOf=testDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('EQUITY'),
                                       ticker = 'TEST2', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('EQUITY')
            position.ticker = 'TEST2'
            position.amount = 100.0
            position.save()

        if not ModelPosition.objects.filter(asOf=testDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('BOND'),
                                       ticker = 'TEST1', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('BOND')
            position.ticker = 'TEST1'
            position.amount = 100.0
            position.save()
       
        if not ModelPosition.objects.filter(asOf=testFirstDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('EQUITY'),
                                       ticker = 'TEST1', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testFirstDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('EQUITY')
            position.ticker = 'TEST1'
            position.amount = 100.0
            position.save()

        if not ModelPosition.objects.filter(asOf=testFirstDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('EQUITY'),
                                       ticker = 'TEST2', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testFirstDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('EQUITY')
            position.ticker = 'TEST2'
            position.amount = 100.0
            position.save()

        if not ModelPosition.objects.filter(asOf=testFirstDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('BOND'),
                                       ticker = 'TEST1', amount = 100.0).exists():
            position = ModelPosition()
            position.asOf=testFirstDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('BOND')
            position.ticker = 'TEST1'
            position.amount = 100.0
            position.save()
            
        if not ModelPosition.objects.filter(asOf=testFirstDate, portfolio=portfolio, 
                                       positionType = Enum.PositionType('CASH'),
                                       ticker = 'Cash', amount = 1000.0).exists():
            position = ModelPosition()
            position.asOf=testFirstDate
            position.portfolio = portfolio
            position.positionType = Enum.PositionType('CASH')
            position.ticker = 'Cash'
            position.amount = 1000.0
            position.save()
            
        curve = InterestRateCurve()
        curve.ccy = 'USD'
        curve.index = Enum.Index('LIBOR')
        curve.term = Enum.TimePeriod('M')
        curve.numTerms = 3
        curve.pricingDate =testDate
        curve.marketId = 'TEST1'

        curve.addRate(InterestRate(type='Deposit', term=Enum.TimePeriod('M'),
                                   numTerms=1,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Deposit', term=Enum.TimePeriod('M'),
                                   numTerms=3,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=1,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=5,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=10,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=30,mid=0.01,curve=curve))
        curve.save()

        curve = InterestRateCurve()
        curve.ccy = 'USD'
        curve.index = Enum.Index('LIBOR')
        curve.term = Enum.TimePeriod('M')
        curve.numTerms = 3
        curve.pricingDate = testFirstDate
        curve.marketId = 'TEST1'

        curve.addRate(InterestRate(type='Deposit', term=Enum.TimePeriod('M'),
                                   numTerms=1,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Deposit', term=Enum.TimePeriod('M'),
                                   numTerms=3,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=1,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=5,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=10,mid=0.01,curve=curve))
        curve.addRate(InterestRate(type='Swap', term=Enum.TimePeriod('Y'),
                                   numTerms=30,mid=0.01,curve=curve))
        curve.save()
        
        if not SwaptionVolatilitySurface.objects.filter(ccy=Enum.Currency('USD'), index=Enum.Index('LIBOR'), term=Enum.TimePeriod('M'), numTerms=3, 
                                                        pricingDate=testDate, marketId='TEST1'):
            #Special case where I just append the vols. Should use a function
            vols = SwaptionVolatilitySurface(ccy=Enum.Currency('USD'), index=Enum.Index('LIBOR'), term=Enum.TimePeriod('M'), numTerms=3, 
                                             pricingDate=testDate, marketId='TEST1')
            volPoints = []
            volPoints.append(SwaptionVolatility(expiryTerm=Enum.TimePeriod('Y'), expiryNumTerms=1, underlyingTerm=Enum.TimePeriod('Y'),
                                                underlyingNumTerms=3, mid=0.40, surface=vols))
            volPoints.append(SwaptionVolatility(expiryTerm=Enum.TimePeriod('Y'), expiryNumTerms=3, underlyingTerm=Enum.TimePeriod('Y'),
                                                underlyingNumTerms=3, mid=0.45, surface=vols))
            volPoints.append(SwaptionVolatility(expiryTerm=Enum.TimePeriod('Y'), expiryNumTerms=1, underlyingTerm=Enum.TimePeriod('Y'),
                                                underlyingNumTerms=5, mid=0.5, surface=vols))
            volPoints.append(SwaptionVolatility(expiryTerm=Enum.TimePeriod('Y'), expiryNumTerms=3, underlyingTerm=Enum.TimePeriod('Y'),
                                                underlyingNumTerms=5, mid=0.55, surface=vols))
            vols.addVolatilities(volPoints)
            vols.save()
            
        if not BondOAS.objects.filter(tCBond=TCBond.objects.get(name='TEST1'),pricingDate=testDate,
                                   marketId='TEST1'):
            bondOAS = BondOAS(tCBond=TCBond.objects.get(name='TEST1'),pricingDate=testDate,
                              marketId='TEST1',mid=0.0012)
            bondOAS.save()
        #done for only one test BondPositionTest.testLoadAndSaveMarketData
        if not BondOAS.objects.filter(tCBond=TCBond.objects.get(name='TEST1'),pricingDate=Date(month=1,day=1,year=2009),
                                      marketId='EOD'):
            bondOAS = BondOAS(tCBond=TCBond.objects.get(name='TEST1'),pricingDate=Date(month=1,day=1,year=2009),
                              marketId='EOD',mid=0.01)
            bondOAS.save()
        #now load zero oas for all dates we do testing
        timePeriods = VARUtilities.VARTimePeriodsAndSteps()
        timePeriods.generate(start = Date(month=8,day=30,year=2011), end = Date(month=9,day=12,year=2011), 
                             num = 1, term = Enum.TimePeriod('D'), calendar = Calendar.US())
        for timeStep in timePeriods.timeSteps:
            if not BondOAS.objects.filter(tCBond=TCBond.objects.get(name='TEST1'), pricingDate=timeStep, marketId='TEST1'):
                bondOAS = BondOAS(tCBond=TCBond.objects.get(name='TEST1'), pricingDate=timeStep, marketId='TEST1',mid=0.0)
                bondOAS.save()
        
        fileLoader = MarketDataLoader.EquityPriceLoader()
        fileLoader.loadStockPriceFromCSVFile(ROOT_PATH+'/misc/data/StockPricesForHVaRTests.csv')
        fileLoader.loadInterestRateFromCSVFile(ROOT_PATH+'/misc/data/InterestRatesForHVaRTests.csv')

        if not HvarConfiguration.objects.filter(name='TEST1').exists():
            config = HvarConfiguration()
            config.name = 'TEST1'
            config.startDate = Date(month=8,day=30,year=2011).toPythonDate()
            config.endDate = Date(month=9,day=12,year=2011).toPythonDate()
            config.stepSize = 1
            config.stepUnit = Enum.TimePeriod('D')
            config.calendar = Calendar.US()
            config.confLevel = 0.95
            config.marketId = 'TEST1'
            config.save()