diff --git a/ql/experimental/mcbasket/adaptedpathpayoff.cpp b/ql/experimental/mcbasket/adaptedpathpayoff.cpp
index d4bc7f0..dcd5915 100644
--- a/ql/experimental/mcbasket/adaptedpathpayoff.cpp
+++ b/ql/experimental/mcbasket/adaptedpathpayoff.cpp
@@ -27,10 +27,12 @@ namespace QuantLib {
    */
   AdaptedPathPayoff::ValuationData::ValuationData(
                                               const Matrix       & path,
+                                              const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                                               Array              & payments,
                                               Array              & exercises,
                                               std::vector<Array> & states) :
     path_(path),
+    forwardTermStructures_(forwardTermStructures),
     payments_(payments), exercises_(exercises), states_(states),
     maximumTimeRead_(0)
   { }
@@ -49,6 +51,12 @@ namespace QuantLib {
     return path_[asset][time];
   }
 
+  const Handle<YieldTermStructure> & AdaptedPathPayoff::ValuationData::getYieldTermStructure(Size time) {
+    maximumTimeRead_ = std::max(maximumTimeRead_, time);
+
+    return forwardTermStructures_[time];
+  }
+
   void AdaptedPathPayoff::ValuationData::setPayoffValue(Size time, Real value) {
     /*
       This is to ensure the payoff is an adapted function.
@@ -78,10 +86,11 @@ namespace QuantLib {
 
 
   void AdaptedPathPayoff::value(const Matrix       & path,
+                                const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                                 Array              & payments,
                                 Array              & exercises,
                                 std::vector<Array> & states) const {
-    ValuationData data(path, payments, exercises, states);
+    ValuationData data(path, forwardTermStructures, payments, exercises, states);
 
     operator()(data);
   }
diff --git a/ql/experimental/mcbasket/adaptedpathpayoff.hpp b/ql/experimental/mcbasket/adaptedpathpayoff.hpp
index c8eee53..1cba94b 100644
--- a/ql/experimental/mcbasket/adaptedpathpayoff.hpp
+++ b/ql/experimental/mcbasket/adaptedpathpayoff.hpp
@@ -38,6 +38,8 @@ namespace QuantLib {
 
             Real getAssetValue(Size time, Size asset);
 
+            const Handle<YieldTermStructure> & getYieldTermStructure(Size time);
+
             void setPayoffValue(Size time, Real value);
 
             // set the exercise payoff if the option is exercised at time "time"
@@ -49,11 +51,13 @@ namespace QuantLib {
             friend class AdaptedPathPayoff;
 
             ValuationData(const Matrix       & path, 
+                          const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                           Array              & payments, 
                           Array              & exercises, 
                           std::vector<Array> & states);
 
             const Matrix & path_;
+            const std::vector<Handle<YieldTermStructure> > & forwardTermStructures_;
 
             Array & payments_;
             Array & exercises_;
@@ -63,6 +67,7 @@ namespace QuantLib {
         };
 
         virtual void value(const Matrix       & path, 
+                           const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                            Array              & payments, 
                            Array              & exercises, 
                            std::vector<Array> & states) const;
diff --git a/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.cpp b/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.cpp
index 136da53..bcc20b3 100644
--- a/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.cpp
+++ b/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.cpp
@@ -36,6 +36,7 @@ namespace QuantLib {
     LongstaffSchwartzMultiPathPricer::LongstaffSchwartzMultiPathPricer(
         const boost::shared_ptr<PathPayoff>& payoff,
         const std::vector<Size> & timePositions,
+        const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
         const Array & discounts,
         Size polynomOrder,
         LsmBasisSystem::PolynomType polynomType)
@@ -44,6 +45,7 @@ namespace QuantLib {
       coeff_     (new Array[timePositions.size() - 1]),
       lowerBounds_(new Real[timePositions.size()]),
       timePositions_(timePositions),
+      forwardTermStructures_(forwardTermStructures),
       dF_        (discounts),
       v_         (LsmBasisSystem::multiPathBasisSystem(payoff->basisSystemDimension(),
                                                        polynomOrder,
@@ -75,7 +77,7 @@ namespace QuantLib {
         
         PathInfo info(numberOfTimes);
 
-        payoff_->value(path, info.payments, info.exercises, info.states);
+        payoff_->value(path, forwardTermStructures_, info.payments, info.exercises, info.states);
 
         return info;
     }
@@ -255,7 +257,7 @@ namespace QuantLib {
 
             lowerBounds_[i] = QL_MAX_REAL;
 
-            // the we add in any case the payment at time t
+            // then we add in any case the payment at time t
             // which is made even if cancellation happens at t
             for (Size j = 0; j < n; ++j) {
                 const Real payoff = paths_[j].payments[i];
diff --git a/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp b/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp
index 5842921..9131b27 100644
--- a/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp
+++ b/ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp
@@ -50,6 +50,7 @@ namespace QuantLib {
         LongstaffSchwartzMultiPathPricer(
             const boost::shared_ptr<PathPayoff>& ,
             const std::vector<Size> &,
+            const std::vector<Handle<YieldTermStructure> > &,
             const Array &,
             Size ,
             LsmBasisSystem::PolynomType );
@@ -78,6 +79,7 @@ namespace QuantLib {
         boost::scoped_array<Real> lowerBounds_;
 
         const std::vector<Size> timePositions_;
+        const std::vector<Handle<YieldTermStructure> > forwardTermStructures_;
         const Array dF_;
 
         mutable std::vector<PathInfo> paths_;
diff --git a/ql/experimental/mcbasket/mcamericanpathengine.hpp b/ql/experimental/mcbasket/mcamericanpathengine.hpp
index f641831..94ede84 100644
--- a/ql/experimental/mcbasket/mcamericanpathengine.hpp
+++ b/ql/experimental/mcbasket/mcamericanpathengine.hpp
@@ -25,6 +25,7 @@
 #include <ql/experimental/mcbasket/pathmultiassetoption.hpp>
 #include <ql/processes/blackscholesprocess.hpp>
 #include <ql/processes/stochasticprocessarray.hpp>
+#include <ql/termstructures/yield/impliedtermstructure.hpp>
 #include <boost/function.hpp>
 
 namespace QuantLib {
@@ -45,6 +46,7 @@ namespace QuantLib {
                                Size timeStepsPerYear,
                                bool brownianBridge,
                                bool antitheticVariate,
+                               bool controlVariate,
                                Size requiredSamples,
                                Real requiredTolerance,
                                Size maxSamples,
@@ -67,6 +69,7 @@ namespace QuantLib {
         MakeMCAmericanPathEngine& withStepsPerYear(Size steps);
         MakeMCAmericanPathEngine& withBrownianBridge(bool b = true);
         MakeMCAmericanPathEngine& withAntitheticVariate(bool b = true);
+        MakeMCAmericanPathEngine& withControlVariate(bool b = true);        
         MakeMCAmericanPathEngine& withSamples(Size samples);
         MakeMCAmericanPathEngine& withAbsoluteTolerance(Real tolerance);
         MakeMCAmericanPathEngine& withMaxSamples(Size samples);
@@ -76,7 +79,7 @@ namespace QuantLib {
         operator boost::shared_ptr<PricingEngine>() const;
       private:
         boost::shared_ptr<StochasticProcessArray> process_;
-        bool brownianBridge_, antithetic_;
+        bool brownianBridge_, antithetic_, controlVariate_;
         Size steps_, stepsPerYear_, samples_, maxSamples_, calibrationSamples_;
         Real tolerance_;
         BigNatural seed_;
@@ -90,6 +93,7 @@ namespace QuantLib {
                    Size timeStepsPerYear,
                    bool brownianBridge,
                    bool antitheticVariate,
+                   bool controlVariate,
                    Size requiredSamples,
                    Real requiredTolerance,
                    Size maxSamples,
@@ -101,7 +105,7 @@ namespace QuantLib {
                                                       timeStepsPerYear,
                                                       brownianBridge,
                                                       antitheticVariate,
-                                                      false,
+                                                      controlVariate,
                                                       requiredSamples,
                                                       requiredTolerance,
                                                       maxSamples,
@@ -127,12 +131,21 @@ namespace QuantLib {
         const std::vector<Time> & times = theTimeGrid.mandatoryTimes();
         const Size numberOfTimes = times.size();
 
+        const std::vector<Date> & fixings = this->arguments_.fixingDates;
+
+        QL_REQUIRE(fixings.size() == numberOfTimes, "Invalid dates/times");
+
         std::vector<Size> timePositions(numberOfTimes);
         Array discountFactors(numberOfTimes);
+        std::vector<Handle<YieldTermStructure> > forwardTermStructures(numberOfTimes);
+
+        const Handle<YieldTermStructure> & riskFreeRate = process->riskFreeRate();
 
         for (Size i = 0; i < numberOfTimes; ++i) {
             timePositions[i] = theTimeGrid.index(times[i]);
-            discountFactors[i] = process->riskFreeRate()->discount(times[i]);
+            discountFactors[i] = riskFreeRate->discount(times[i]);
+            forwardTermStructures[i] = Handle<YieldTermStructure>(
+                        new ImpliedTermStructure(riskFreeRate, fixings[i]));
         }
 
         const Size polynomialOrder = 2;
@@ -141,6 +154,7 @@ namespace QuantLib {
         return boost::shared_ptr<LongstaffSchwartzMultiPathPricer> (
             new LongstaffSchwartzMultiPathPricer(this->arguments_.payoff,
                                                  timePositions,
+                                                 forwardTermStructures,
                                                  discountFactors,
                                                  polynomialOrder,
                                                  polynomType));
@@ -151,6 +165,7 @@ namespace QuantLib {
     inline MakeMCAmericanPathEngine<RNG>::MakeMCAmericanPathEngine(
                      const boost::shared_ptr<StochasticProcessArray>& process)
     : process_(process), brownianBridge_(false), antithetic_(false),
+      controlVariate_(false),
       steps_(Null<Size>()), stepsPerYear_(Null<Size>()),
       samples_(Null<Size>()), maxSamples_(Null<Size>()),
       calibrationSamples_(Null<Size>()),
@@ -186,6 +201,13 @@ namespace QuantLib {
 
     template <class RNG>
     inline MakeMCAmericanPathEngine<RNG>&
+    MakeMCAmericanPathEngine<RNG>::withControlVariate(bool b) {
+        controlVariate_ = b;
+        return *this;
+    }
+
+    template <class RNG>
+    inline MakeMCAmericanPathEngine<RNG>&
     MakeMCAmericanPathEngine<RNG>::withSamples(Size samples) {
         QL_REQUIRE(tolerance_ == Null<Real>(),
                    "tolerance already set");
@@ -240,6 +262,7 @@ namespace QuantLib {
                                         stepsPerYear_,
                                         brownianBridge_,
                                         antithetic_,
+                                        controlVariate_,
                                         samples_,
                                         tolerance_,
                                         maxSamples_,
diff --git a/ql/experimental/mcbasket/mclongstaffschwartzpathengine.hpp b/ql/experimental/mcbasket/mclongstaffschwartzpathengine.hpp
index d91d185..a6fe940 100644
--- a/ql/experimental/mcbasket/mclongstaffschwartzpathengine.hpp
+++ b/ql/experimental/mcbasket/mclongstaffschwartzpathengine.hpp
@@ -175,7 +175,9 @@ namespace QuantLib {
                 this->process_->time(fixings[i]);
         }
 
-        return TimeGrid(fixingTimes.begin(), fixingTimes.end(), timeSteps_);
+        const Size numberOfTimeSteps = timeSteps_ != Null<Size>() ? timeSteps_ : timeStepsPerYear_ * fixingTimes.back();
+
+        return TimeGrid(fixingTimes.begin(), fixingTimes.end(), numberOfTimeSteps);
      }
 
     template <class GenericEngine, template <class> class MC,
diff --git a/ql/experimental/mcbasket/mcpathbasketengine.cpp b/ql/experimental/mcbasket/mcpathbasketengine.cpp
index 8232029..5b894df 100644
--- a/ql/experimental/mcbasket/mcpathbasketengine.cpp
+++ b/ql/experimental/mcbasket/mcpathbasketengine.cpp
@@ -24,8 +24,9 @@ namespace QuantLib {
     EuropeanPathMultiPathPricer::EuropeanPathMultiPathPricer(
                                        boost::shared_ptr<PathPayoff> & payoff,
                                        const std::vector<Size> & timePositions,
+                                       const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                                        const Array & discounts)
-    :  payoff_(payoff), timePositions_(timePositions), discounts_(discounts) {}
+    :  payoff_(payoff), timePositions_(timePositions), forwardTermStructures_(forwardTermStructures), discounts_(discounts) {}
 
     Real EuropeanPathMultiPathPricer::operator()(const MultiPath& multiPath)
                                                                        const {
@@ -52,7 +53,7 @@ namespace QuantLib {
         Array exercises;
         std::vector<Array> states;
 
-        payoff_->value(path, values, exercises, states);
+        payoff_->value(path, forwardTermStructures_, values, exercises, states);
 
         Real discountedPayoff = DotProduct(values, discounts_);
 
diff --git a/ql/experimental/mcbasket/mcpathbasketengine.hpp b/ql/experimental/mcbasket/mcpathbasketengine.hpp
index 2b6b810..453cbc8 100644
--- a/ql/experimental/mcbasket/mcpathbasketengine.hpp
+++ b/ql/experimental/mcbasket/mcpathbasketengine.hpp
@@ -29,6 +29,7 @@
 #include <ql/pricingengines/mcsimulation.hpp>
 #include <ql/processes/blackscholesprocess.hpp>
 #include <ql/processes/stochasticprocessarray.hpp>
+#include <ql/termstructures/yield/impliedtermstructure.hpp>
 #include <ql/timegrid.hpp>
 
 namespace QuantLib {
@@ -48,6 +49,7 @@ namespace QuantLib {
         // constructor
         MCPathBasketEngine(const boost::shared_ptr<StochasticProcessArray>&,
                            Size timeSteps,
+                           Size timeStepsPerYear,
                            bool brownianBridge,
                            bool antitheticVariate,
                            bool controlVariate,
@@ -76,6 +78,7 @@ namespace QuantLib {
         // data members
         boost::shared_ptr<StochasticProcessArray> process_;
         Size timeSteps_;
+        Size timeStepsPerYear_;
         Size requiredSamples_;
         Size maxSamples_;
         Real requiredTolerance_;
@@ -88,11 +91,13 @@ namespace QuantLib {
       public:
         EuropeanPathMultiPathPricer(boost::shared_ptr<PathPayoff> & payoff,
                                     const std::vector<Size> & timePositions,
+                                    const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                                     const Array & discounts);
         Real operator()(const MultiPath& multiPath) const;
       private:
         boost::shared_ptr<PathPayoff> payoff_;
         std::vector<Size> timePositions_;
+        std::vector<Handle<YieldTermStructure> > forwardTermStructures_;
         Array discounts_;
     };
 
@@ -103,6 +108,7 @@ namespace QuantLib {
     inline MCPathBasketEngine<RNG,S>::MCPathBasketEngine(
              const boost::shared_ptr<StochasticProcessArray>& process,
              Size timeSteps,
+             Size timeStepsPerYear,
              bool brownianBridge,
              bool antitheticVariate,
              bool controlVariate,
@@ -111,10 +117,24 @@ namespace QuantLib {
              Size maxSamples,
              BigNatural seed)
     : McSimulation<MultiVariate,RNG,S>(antitheticVariate, controlVariate),
-      process_(process), timeSteps_(timeSteps),
+      process_(process), timeSteps_(timeSteps), timeStepsPerYear_(timeStepsPerYear),
       requiredSamples_(requiredSamples), maxSamples_(maxSamples),
       requiredTolerance_(requiredTolerance),
-      brownianBridge_(brownianBridge), seed_(seed) {}
+      brownianBridge_(brownianBridge), seed_(seed) {
+        QL_REQUIRE(timeSteps != Null<Size>() ||
+                   timeStepsPerYear != Null<Size>(),
+                   "no time steps provided");
+        QL_REQUIRE(timeSteps == Null<Size>() ||
+                   timeStepsPerYear == Null<Size>(),
+                   "both time steps and time steps per year were provided");
+        QL_REQUIRE(timeSteps != 0,
+                   "timeSteps must be positive, " << timeSteps <<
+                   " not allowed");
+        QL_REQUIRE(timeStepsPerYear != 0,
+                   "timeStepsPerYear must be positive, " 
+                   << timeStepsPerYear << " not allowed");
+        this->registerWith(process_);
+    }
 
 
     template<class RNG, class S>
@@ -148,7 +168,9 @@ namespace QuantLib {
                 this->process_->time(fixings[i]);
         }
 
-        return TimeGrid(fixingTimes.begin(), fixingTimes.end(), timeSteps_);
+        const Size numberOfTimeSteps = timeSteps_ != Null<Size>() ? timeSteps_ : timeStepsPerYear_ * fixingTimes.back();
+        
+        return TimeGrid(fixingTimes.begin(), fixingTimes.end(), numberOfTimeSteps);
     }
 
     template <class RNG, class S>
@@ -169,17 +191,27 @@ namespace QuantLib {
         const std::vector<Time> & times = theTimeGrid.mandatoryTimes();
         const Size numberOfTimes = times.size();
 
+        const std::vector<Date> & fixings = this->arguments_.fixingDates;
+
+        QL_REQUIRE(fixings.size() == numberOfTimes, "Invalid dates/times");
+
         std::vector<Size> timePositions(numberOfTimes);
         Array discountFactors(numberOfTimes);
+        std::vector<Handle<YieldTermStructure> > forwardTermStructures(numberOfTimes);
+
+        const Handle<YieldTermStructure> & riskFreeRate = process->riskFreeRate();
 
         for (Size i = 0; i < numberOfTimes; ++i) {
             timePositions[i] = theTimeGrid.index(times[i]);
-            discountFactors[i] = process->riskFreeRate()->discount(times[i]);
+            discountFactors[i] = riskFreeRate->discount(times[i]);
+            forwardTermStructures[i] = Handle<YieldTermStructure>(
+                        new ImpliedTermStructure(riskFreeRate, fixings[i]));
         }
 
         return boost::shared_ptr<
             typename MCPathBasketEngine<RNG,S>::path_pricer_type>(
                         new EuropeanPathMultiPathPricer(payoff, timePositions,
+                                                        forwardTermStructures,
                                                         discountFactors));
     }
 
@@ -191,6 +223,7 @@ namespace QuantLib {
         MakeMCPathBasketEngine(const boost::shared_ptr<StochasticProcessArray>&);
         // named parameters
         MakeMCPathBasketEngine& withSteps(Size steps);
+        MakeMCPathBasketEngine& withStepsPerYear(Size steps);
         MakeMCPathBasketEngine& withBrownianBridge(bool b = true);
         MakeMCPathBasketEngine& withSamples(Size samples);
         MakeMCPathBasketEngine& withAbsoluteTolerance(Real tolerance);
@@ -203,7 +236,7 @@ namespace QuantLib {
       private:
         boost::shared_ptr<StochasticProcessArray> process_;
         bool antithetic_, controlVariate_;
-        Size steps_, samples_, maxSamples_;
+        Size steps_, stepsPerYear_, samples_, maxSamples_;
         Real tolerance_;
         bool brownianBridge_;
         BigNatural seed_;
@@ -214,7 +247,7 @@ namespace QuantLib {
         const boost::shared_ptr<StochasticProcessArray>& process)
     : process_(process),
       antithetic_(false), controlVariate_(false),
-      steps_(Null<Size>()),
+      steps_(Null<Size>()), stepsPerYear_(Null<Size>()),
       samples_(Null<Size>()), maxSamples_(Null<Size>()),
       tolerance_(Null<Real>()), brownianBridge_(false), seed_(0) {}
 
@@ -227,6 +260,13 @@ namespace QuantLib {
 
     template <class RNG, class S>
     inline MakeMCPathBasketEngine<RNG,S>&
+    MakeMCPathBasketEngine<RNG,S>::withStepsPerYear(Size steps) {
+        stepsPerYear_ = steps;
+        return *this;
+    }
+
+    template <class RNG, class S>
+    inline MakeMCPathBasketEngine<RNG,S>&
     MakeMCPathBasketEngine<RNG,S>::withSamples(Size samples) {
         QL_REQUIRE(tolerance_ == Null<Real>(),
                    "tolerance already set");
@@ -288,6 +328,7 @@ namespace QuantLib {
         return boost::shared_ptr<PricingEngine>(new
             MCPathBasketEngine<RNG,S>(process_,
                                       steps_,
+                                      stepsPerYear_,
                                       brownianBridge_,
                                       antithetic_,
                                       controlVariate_,
diff --git a/ql/experimental/mcbasket/pathpayoff.hpp b/ql/experimental/mcbasket/pathpayoff.hpp
index 6c49f44..90e3640 100644
--- a/ql/experimental/mcbasket/pathpayoff.hpp
+++ b/ql/experimental/mcbasket/pathpayoff.hpp
@@ -26,6 +26,8 @@
 
 #include <ql/math/matrix.hpp>
 #include <ql/patterns/visitor.hpp>
+#include <ql/termstructures/yieldtermstructure.hpp>
+#include <ql/handle.hpp>
 #include <functional>
 
 namespace QuantLib {
@@ -49,9 +51,12 @@ namespace QuantLib {
           for a single path. If the option is cancelled at time i, all payments
           on and before i are taken into account + the value of exercises[i].
           i.e.: cancellation at i does not cancel payments[i]!
+
+          forwardTermStructures contains the yield term structure at each fixing date
          */
 
         virtual void value(const Matrix       & path, 
+                           const std::vector<Handle<YieldTermStructure> > & forwardTermStructures,
                            Array              & payments, 
                            Array              & exercises, 
                            std::vector<Array> & states) const = 0;
