diff --git a/core/include/BTagDatabase.hpp b/core/include/BTagDatabase.hpp
index 2d792c6..9980f62 100644
--- a/core/include/BTagDatabase.hpp
+++ b/core/include/BTagDatabase.hpp
@@ -23,10 +23,10 @@
  * \brief Provides an interface to access b-tagging efficiencies and scale factors
  * 
  * The class provides an access to b-tagging MC efficiencies and data/MC scale factors. The scale
- * factors are provided in [1] and are implemented via automatically generated code. The code was
+ * factors are taken from [1] and are implemented via automatically generated code. The code was
  * created with the help of script [2].
- * [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagPOG#2012_Data_and_MC_Moriond13_presc
- * [2] /afs/cern.ch/user/a/aapopov/workspace/tHq/2012Alpha/2013.04.15_BTagSF/generateSFCode.py
+ * [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagPOG#2012_Data_and_MC_EPS13_prescript?rev=181
+ * [2] /afs/cern.ch/user/a/aapopov/workspace/tHq/2012Bravo/2014.02.17_BTagSF/generateSFCode.py
  * 
  * The class is copyable.
  */
@@ -88,14 +88,20 @@ class BTagDatabase
         void SetEfficiencies();
         
         // The code below was generated automatically
+        double GetSFTagTCHPT(double pt) const;
         double GetSFTagCSVL(double pt) const;
         double GetSFTagCSVM(double pt) const;
         double GetSFTagCSVT(double pt) const;
-        double GetSFTagTCHPT(double pt) const;
-        double GetSFTagJPL(double pt) const;
-        double GetSFTagJPM(double pt) const;
-        double GetSFTagJPT(double pt) const;
-
+        double GetSFTagCSVV1L(double pt) const;
+        double GetSFTagCSVV1M(double pt) const;
+        double GetSFTagCSVV1T(double pt) const;
+        double GetSFTagCSVSLV1L(double pt) const;
+        double GetSFTagCSVSLV1M(double pt) const;
+        double GetSFTagCSVSLV1T(double pt) const;
+        
+        double GetSFMistagTCHPTMean(double pt, double absEta) const;
+        double GetSFMistagTCHPTMin(double pt, double absEta) const;
+        double GetSFMistagTCHPTMax(double pt, double absEta) const;
         double GetSFMistagCSVLMean(double pt, double absEta) const;
         double GetSFMistagCSVLMin(double pt, double absEta) const;
         double GetSFMistagCSVLMax(double pt, double absEta) const;
@@ -105,20 +111,26 @@ class BTagDatabase
         double GetSFMistagCSVTMean(double pt, double absEta) const;
         double GetSFMistagCSVTMin(double pt, double absEta) const;
         double GetSFMistagCSVTMax(double pt, double absEta) const;
-        double GetSFMistagTCHPTMean(double pt, double absEta) const;
-        double GetSFMistagTCHPTMin(double pt, double absEta) const;
-        double GetSFMistagTCHPTMax(double pt, double absEta) const;
-        double GetSFMistagJPLMean(double pt, double absEta) const;
-        double GetSFMistagJPLMin(double pt, double absEta) const;
-        double GetSFMistagJPLMax(double pt, double absEta) const;
-        double GetSFMistagJPMMean(double pt, double absEta) const;
-        double GetSFMistagJPMMin(double pt, double absEta) const;
-        double GetSFMistagJPMMax(double pt, double absEta) const;
-        double GetSFMistagJPTMean(double pt, double absEta) const;
-        double GetSFMistagJPTMin(double pt, double absEta) const;
-        double GetSFMistagJPTMax(double pt, double absEta) const;
+        double GetSFMistagCSVV1LMean(double pt, double absEta) const;
+        double GetSFMistagCSVV1LMin(double pt, double absEta) const;
+        double GetSFMistagCSVV1LMax(double pt, double absEta) const;
+        double GetSFMistagCSVV1MMean(double pt, double absEta) const;
+        double GetSFMistagCSVV1MMin(double pt, double absEta) const;
+        double GetSFMistagCSVV1MMax(double pt, double absEta) const;
+        double GetSFMistagCSVV1TMean(double pt, double absEta) const;
+        double GetSFMistagCSVV1TMin(double pt, double absEta) const;
+        double GetSFMistagCSVV1TMax(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1LMean(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1LMin(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1LMax(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1MMean(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1MMin(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1MMax(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1TMean(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1TMin(double pt, double absEta) const;
+        double GetSFMistagCSVSLV1TMax(double pt, double absEta) const;
         // End of automatically generated code
-      
+    
     private:
         BTagger::Algorithm const algo;  ///< Chosen b-tagging algorithm
         BTagger::WorkingPoint const workingPoint;  ///< Chosen b-tagging working point
diff --git a/core/include/BTagger.hpp b/core/include/BTagger.hpp
index 2ccb9f2..2400585 100644
--- a/core/include/BTagger.hpp
+++ b/core/include/BTagger.hpp
@@ -31,9 +31,11 @@ class BTagger
         /// Supported b-tagging algorithms
         enum class Algorithm
         {
-            CSV,   ///< Combined secondary vertex
-            JP,    ///< Jet probability
-            TCHP   ///< Track counting high purity
+            CSV,     ///< Combined secondary vertex
+            JP,      ///< Jet probability
+            TCHP,    ///< Track counting high purity
+            CSVV1,   ///< Retrained CSV
+            CSVSLV1  ///< A version of CSV with additional information on soft leptons exploited
         };
         
         /// Supported working points for the b-tagging algorithms
diff --git a/core/src/BTagDatabase.cpp b/core/src/BTagDatabase.cpp
index b4fc498..936723a 100644
--- a/core/src/BTagDatabase.cpp
+++ b/core/src/BTagDatabase.cpp
@@ -31,11 +31,20 @@ BTagDatabase::BTagDatabase(BTagger const &bTagger,
     // The code below was generated automatically
     BTagger::Algorithm const algo = bTagger.GetAlgorithm();
     BTagger::WorkingPoint const wp = bTagger.GetWorkingPoint();
-
-    if (algo == BTagger::Algorithm::CSV and wp == BTagger::WorkingPoint::Loose)
+    
+    if (algo == BTagger::Algorithm::TCHP and wp == BTagger::WorkingPoint::Tight)
+    {
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagTCHPT;
+        tagUncertainties.assign({0.0624031, 0.034023, 0.0362764, 0.0341996, 0.031248, 0.0281222, 0.0316684, 0.0276272, 0.0208828, 0.0223511, 0.0224121, 0.0261939, 0.0268247, 0.0421413, 0.0532897, 0.0506714});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagTCHPTMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagTCHPTMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagTCHPTMax;
+        mistagOuterRegion = 2.4;
+    }
+    else if (algo == BTagger::Algorithm::CSV and wp == BTagger::WorkingPoint::Loose)
     {
         tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVL;
-        tagUncertainties.assign({0.0484285, 0.0126178, 0.0120027, 0.0141137, 0.0145441, 0.0131145, 0.0168479, 0.0160836, 0.0126209, 0.0136017, 0.019182, 0.0198805, 0.0386531, 0.0392831, 0.0481008, 0.0474291});
+        tagUncertainties.assign({0.033299, 0.0146768, 0.013803, 0.0170145, 0.0166976, 0.0137879, 0.0149072, 0.0153068, 0.0133077, 0.0123737, 0.0157152, 0.0175161, 0.0209241, 0.0278605, 0.0346928, 0.0350099});
         mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVLMean;
         mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVLMin;
         mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVLMax;
@@ -44,7 +53,7 @@ BTagDatabase::BTagDatabase(BTagger const &bTagger,
     else if (algo == BTagger::Algorithm::CSV and wp == BTagger::WorkingPoint::Medium)
     {
         tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVM;
-        tagUncertainties.assign({0.0554504, 0.0209663, 0.0207019, 0.0230073, 0.0208719, 0.0200453, 0.0264232, 0.0240102, 0.0229375, 0.0184615, 0.0216242, 0.0248119, 0.0465748, 0.0474666, 0.0718173, 0.0717567});
+        tagUncertainties.assign({0.0415707, 0.0204209, 0.0223227, 0.0206655, 0.0199325, 0.0174121, 0.0202332, 0.0182446, 0.0159777, 0.0218531, 0.0204688, 0.0265191, 0.0313175, 0.0415417, 0.0740446, 0.0596716});
         mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVMMean;
         mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVMMin;
         mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVMMax;
@@ -53,46 +62,64 @@ BTagDatabase::BTagDatabase(BTagger const &bTagger,
     else if (algo == BTagger::Algorithm::CSV and wp == BTagger::WorkingPoint::Tight)
     {
         tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVT;
-        tagUncertainties.assign({0.0567059, 0.0266907, 0.0263491, 0.0342831, 0.0303327, 0.024608, 0.0333786, 0.0317642, 0.031102, 0.0295603, 0.0474663, 0.0503182, 0.0580424, 0.0575776, 0.0769779, 0.0898199});
+        tagUncertainties.assign({0.0515703, 0.0264008, 0.0272757, 0.0275565, 0.0248745, 0.0218456, 0.0253845, 0.0239588, 0.0271791, 0.0273912, 0.0379822, 0.0411624, 0.0786307, 0.0866832, 0.0942053, 0.102403});
         mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVTMean;
         mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVTMin;
         mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVTMax;
         mistagOuterRegion = 2.4;
     }
-    else if (algo == BTagger::Algorithm::TCHP and wp == BTagger::WorkingPoint::Tight)
+    else if (algo == BTagger::Algorithm::CSVV1 and wp == BTagger::WorkingPoint::Loose)
     {
-        tagScaleFactorMethod = &BTagDatabase::GetSFTagTCHPT;
-        tagUncertainties.assign({0.0725549, 0.0275189, 0.0279695, 0.028065, 0.0270752, 0.0254934, 0.0262087, 0.0230919, 0.0294829, 0.0226487, 0.0272755, 0.0303747, 0.051223, 0.0542895, 0.0589887, 0.0584216});
-        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagTCHPTMean;
-        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagTCHPTMin;
-        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagTCHPTMax;
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVV1L;
+        tagUncertainties.assign({0.0345802, 0.0152688, 0.0149101, 0.0167145, 0.0167098, 0.013472, 0.0146024, 0.0156735, 0.0142592, 0.0147227, 0.0167101, 0.0191159, 0.0360389, 0.0331342, 0.0336916, 0.0298064});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVV1LMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVV1LMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVV1LMax;
+        mistagOuterRegion = 1.5;
+    }
+    else if (algo == BTagger::Algorithm::CSVV1 and wp == BTagger::WorkingPoint::Medium)
+    {
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVV1M;
+        tagUncertainties.assign({0.0376303, 0.0187774, 0.019884, 0.0215849, 0.0207925, 0.0180289, 0.0178674, 0.0159339, 0.019042, 0.020975, 0.0189178, 0.0246477, 0.0291784, 0.0428437, 0.0674624, 0.0479834});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVV1MMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVV1MMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVV1MMax;
+        mistagOuterRegion = 1.6;
+    }
+    else if (algo == BTagger::Algorithm::CSVV1 and wp == BTagger::WorkingPoint::Tight)
+    {
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVV1T;
+        tagUncertainties.assign({0.0564014, 0.0293159, 0.0315288, 0.0301526, 0.0266047, 0.0240973, 0.0254404, 0.0241548, 0.0233434, 0.0303961, 0.040912, 0.042942, 0.0440911, 0.0555312, 0.105762, 0.0886457});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVV1TMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVV1TMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVV1TMax;
         mistagOuterRegion = 2.4;
     }
-    else if (algo == BTagger::Algorithm::JP and wp == BTagger::WorkingPoint::Loose)
+    else if (algo == BTagger::Algorithm::CSVSLV1 and wp == BTagger::WorkingPoint::Loose)
     {
-        tagScaleFactorMethod = &BTagDatabase::GetSFTagJPL;
-        tagUncertainties.assign({0.0456879, 0.0229755, 0.0229115, 0.0219184, 0.0222935, 0.0189195, 0.0237255, 0.0236069, 0.0159177, 0.0196792, 0.0168556, 0.0168882, 0.0348084, 0.0355933, 0.0476836, 0.0500367});
-        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagJPLMean;
-        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagJPLMin;
-        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagJPLMax;
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVSLV1L;
+        tagUncertainties.assign({0.135344, 0.0288656, 0.0259088, 0.0199242, 0.0189792, 0.0178341, 0.0187104, 0.0239028, 0.0211104, 0.017689, 0.02823, 0.0259654, 0.0614497});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVSLV1LMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVSLV1LMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVSLV1LMax;
         mistagOuterRegion = 1.5;
     }
-    else if (algo == BTagger::Algorithm::JP and wp == BTagger::WorkingPoint::Medium)
+    else if (algo == BTagger::Algorithm::CSVSLV1 and wp == BTagger::WorkingPoint::Medium)
     {
-        tagScaleFactorMethod = &BTagDatabase::GetSFTagJPM;
-        tagUncertainties.assign({0.0584144, 0.0304763, 0.0311788, 0.0339226, 0.0343223, 0.0303401, 0.0329372, 0.0339472, 0.0368516, 0.0319189, 0.0354756, 0.0347098, 0.0408868, 0.0415471, 0.0567743, 0.0605397});
-        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagJPMMean;
-        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagJPMMin;
-        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagJPMMax;
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVSLV1M;
+        tagUncertainties.assign({0.0918443, 0.0282557, 0.0264246, 0.0242536, 0.0218046, 0.0207568, 0.0207962, 0.0208919, 0.0200894, 0.0258879, 0.0270699, 0.0256006, 0.0438219});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVSLV1MMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVSLV1MMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVSLV1MMax;
         mistagOuterRegion = 1.6;
     }
-    else if (algo == BTagger::Algorithm::JP and wp == BTagger::WorkingPoint::Tight)
+    else if (algo == BTagger::Algorithm::CSVSLV1 and wp == BTagger::WorkingPoint::Tight)
     {
-        tagScaleFactorMethod = &BTagDatabase::GetSFTagJPT;
-        tagUncertainties.assign({0.0673183, 0.0368276, 0.037958, 0.0418136, 0.0463115, 0.0409334, 0.0436405, 0.0419725, 0.0451182, 0.0394386, 0.0423327, 0.0393015, 0.0499883, 0.0509444, 0.0780023, 0.0856582});
-        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagJPTMean;
-        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagJPTMin;
-        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagJPTMax;
+        tagScaleFactorMethod = &BTagDatabase::GetSFTagCSVSLV1T;
+        tagUncertainties.assign({0.10761, 0.0333696, 0.0339123, 0.0302699, 0.0261626, 0.0274243, 0.0224287, 0.0239842, 0.0267866, 0.0254787, 0.0317589, 0.0365968, 0.0481259});
+        mistagScaleFactorMethodMean = &BTagDatabase::GetSFMistagCSVSLV1TMean;
+        mistagScaleFactorMethodMin = &BTagDatabase::GetSFMistagCSVSLV1TMin;
+        mistagScaleFactorMethodMax = &BTagDatabase::GetSFMistagCSVSLV1TMax;
         mistagOuterRegion = 2.4;
     }
     // End of automatically generated code
@@ -304,51 +331,99 @@ void BTagDatabase::SetEfficiencies()
 
 
 // The code below was generated automatically
+double BTagDatabase::GetSFTagTCHPT(double pt) const
+{
+    return 0.703389*((1.+(0.088358*pt))/(1.+(0.0660291*pt)));
+}
+
 double BTagDatabase::GetSFTagCSVL(double pt) const
 {
-    return 0.981149*((1.+(-0.000713295*pt))/(1.+(-0.000703264*pt)));
+    return 0.997942*((1.+(0.00923753*pt))/(1.+(0.0096119*pt)));
 }
 
 double BTagDatabase::GetSFTagCSVM(double pt) const
 {
-    return 0.726981*((1.+(0.253238*pt))/(1.+(0.188389*pt)));
+    return (0.938887+(0.00017124*pt))+(-2.76366e-07*(pt*pt));
 }
 
 double BTagDatabase::GetSFTagCSVT(double pt) const
 {
-    return 0.869965*((1.+(0.0335062*pt))/(1.+(0.0304598*pt)));
+    return (0.927563+(1.55479e-05*pt))+(-1.90666e-07*(pt*pt));
 }
 
-double BTagDatabase::GetSFTagTCHPT(double pt) const
+double BTagDatabase::GetSFTagCSVV1L(double pt) const
+{
+    return 1.7586*((1.+(0.799078*pt))/(1.+(1.44245*pt)));
+}
+
+double BTagDatabase::GetSFTagCSVV1M(double pt) const
+{
+    return 0.952067+(-2.00037e-05*pt);
+}
+
+double BTagDatabase::GetSFTagCSVV1T(double pt) const
+{
+    return (0.912578+(0.000115164*pt))+(-2.24429e-07*(pt*pt));
+}
+
+double BTagDatabase::GetSFTagCSVSLV1L(double pt) const
 {
-    return 0.305208*((1.+(0.595166*pt))/(1.+(0.186968*pt)));
+    return 0.970168*((1.+(0.00266812*pt))/(1.+(0.00250852*pt)));
 }
 
-double BTagDatabase::GetSFTagJPL(double pt) const
+double BTagDatabase::GetSFTagCSVSLV1M(double pt) const
 {
-    return 0.977721*((1.+(-1.02685e-06*pt))/(1.+(-2.56586e-07*pt)));
+    return ((0.939238+(0.000278928*pt))+(-7.49693e-07*(pt*pt)))+(2.04822e-10*(pt*(pt*pt)));
 }
 
-double BTagDatabase::GetSFTagJPM(double pt) const
+double BTagDatabase::GetSFTagCSVSLV1T(double pt) const
 {
-    return 0.87887*((1.+(0.0393348*pt))/(1.+(0.0354499*pt)));
+    return (0.928257+(9.3526e-05*pt))+(-4.1568e-07*(pt*pt));
 }
 
-double BTagDatabase::GetSFTagJPT(double pt) const
+double BTagDatabase::GetSFMistagTCHPTMean(double pt, double absEta) const
 {
-    return 0.802097*((1.+(0.013219*pt))/(1.+(0.0107842*pt)));
+    if (absEta < 2.4)
+        return ((1.20175+(0.000858187*pt))+(-1.98726e-06*(pt*pt)))+(1.31057e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagTCHPTMin(double pt, double absEta) const
+{
+    if (absEta < 2.4)
+        return ((0.968557+(0.000586877*pt))+(-1.34624e-06*(pt*pt)))+(9.09724e-10*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagTCHPTMax(double pt, double absEta) const
+{
+    if (absEta < 2.4)
+        return ((1.43508+(0.00112666*pt))+(-2.62078e-06*(pt*pt)))+(1.70697e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
 }
 
 double BTagDatabase::GetSFMistagCSVLMean(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((1.04901+(0.00152181*pt))+(-3.43568e-06*(pt*pt)))+(2.17219e-09*(pt*(pt*pt)));
+        return ((1.01177+(0.0023066*pt))+(-4.56052e-06*(pt*pt)))+(2.57917e-09*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((0.991915+(0.00172552*pt))+(-3.92652e-06*(pt*pt)))+(2.56816e-09*(pt*(pt*pt)));
+        return ((0.975966+(0.00196354*pt))+(-3.83768e-06*(pt*pt)))+(2.17466e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((0.962127+(0.00192796*pt))+(-4.53385e-06*(pt*pt)))+(3.0605e-09*(pt*(pt*pt)));
+        return ((0.93821+(0.00180935*pt))+(-3.86937e-06*(pt*pt)))+(2.43222e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.06121+(0.000332747*pt))+(-8.81201e-07*(pt*pt)))+(7.43896e-10*(pt*(pt*pt)));
+        return ((1.00022+(0.0010998*pt))+(-3.10672e-06*(pt*pt)))+(2.35006e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -359,13 +434,13 @@ double BTagDatabase::GetSFMistagCSVLMean(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVLMin(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((0.973773+(0.00103049*pt))+(-2.2277e-06*(pt*pt)))+(1.37208e-09*(pt*(pt*pt)));
+        return ((0.977761+(0.00170704*pt))+(-3.2197e-06*(pt*pt)))+(1.78139e-09*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((0.921518+(0.00129098*pt))+(-2.86488e-06*(pt*pt)))+(1.86022e-09*(pt*(pt*pt)));
+        return ((0.945135+(0.00146006*pt))+(-2.70048e-06*(pt*pt)))+(1.4883e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((0.895419+(0.00153387*pt))+(-3.48409e-06*(pt*pt)))+(2.30899e-09*(pt*(pt*pt)));
+        return ((0.911657+(0.00142008*pt))+(-2.87569e-06*(pt*pt)))+(1.76619e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((0.983607+(0.000196747*pt))+(-3.98327e-07*(pt*pt)))+(2.95764e-10*(pt*(pt*pt)));
+        return ((0.970045+(0.000862284*pt))+(-2.31714e-06*(pt*pt)))+(1.68866e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -376,13 +451,13 @@ double BTagDatabase::GetSFMistagCSVLMin(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVLMax(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((1.12424+(0.00201136*pt))+(-4.64021e-06*(pt*pt)))+(2.97219e-09*(pt*(pt*pt)));
+        return ((1.04582+(0.00290226*pt))+(-5.89124e-06*(pt*pt)))+(3.37128e-09*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((1.06231+(0.00215815*pt))+(-4.9844e-06*(pt*pt)))+(3.27623e-09*(pt*(pt*pt)));
+        return ((1.00683+(0.00246404*pt))+(-4.96729e-06*(pt*pt)))+(2.85697e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((1.02883+(0.00231985*pt))+(-5.57924e-06*(pt*pt)))+(3.81235e-09*(pt*(pt*pt)));
+        return ((0.964787+(0.00219574*pt))+(-4.85552e-06*(pt*pt)))+(3.09457e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.1388+(0.000468418*pt))+(-1.36341e-06*(pt*pt)))+(1.19256e-09*(pt*(pt*pt)));
+        return ((1.03039+(0.0013358*pt))+(-3.89284e-06*(pt*pt)))+(3.01155e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -393,11 +468,11 @@ double BTagDatabase::GetSFMistagCSVLMax(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVMMean(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((1.06238+(0.00198635*pt))+(-4.89082e-06*(pt*pt)))+(3.29312e-09*(pt*(pt*pt)));
+        return ((1.07541+(0.00231827*pt))+(-4.74249e-06*(pt*pt)))+(2.70862e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((1.08048+(0.00110831*pt))+(-2.96189e-06*(pt*pt)))+(2.16266e-09*(pt*(pt*pt)));
+        return ((1.05613+(0.00114031*pt))+(-2.56066e-06*(pt*pt)))+(1.67792e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.09145+(0.000687171*pt))+(-2.45054e-06*(pt*pt)))+(1.7844e-09*(pt*(pt*pt)));
+        return ((1.05625+(0.000487231*pt))+(-2.22792e-06*(pt*pt)))+(1.70262e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -408,11 +483,11 @@ double BTagDatabase::GetSFMistagCSVMMean(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVMMin(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((0.972746+(0.00104424*pt))+(-2.36081e-06*(pt*pt)))+(1.53438e-09*(pt*(pt*pt)));
+        return ((0.964527+(0.00149055*pt))+(-2.78338e-06*(pt*pt)))+(1.51771e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((0.9836+(0.000649761*pt))+(-1.59773e-06*(pt*pt)))+(1.14324e-09*(pt*(pt*pt)));
+        return ((0.946051+(0.000759584*pt))+(-1.52491e-06*(pt*pt)))+(9.65822e-10*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.00616+(0.000358884*pt))+(-1.23768e-06*(pt*pt)))+(6.86678e-10*(pt*(pt*pt)));
+        return ((0.956736+(0.000280197*pt))+(-1.42739e-06*(pt*pt)))+(1.0085e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -423,11 +498,11 @@ double BTagDatabase::GetSFMistagCSVMMin(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVMMax(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((1.15201+(0.00292575*pt))+(-7.41497e-06*(pt*pt)))+(5.0512e-09*(pt*(pt*pt)));
+        return ((1.18638+(0.00314148*pt))+(-6.68993e-06*(pt*pt)))+(3.89288e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((1.17735+(0.00156533*pt))+(-4.32257e-06*(pt*pt)))+(3.18197e-09*(pt*(pt*pt)));
+        return ((1.16624+(0.00151884*pt))+(-3.59041e-06*(pt*pt)))+(2.38681e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.17671+(0.0010147*pt))+(-3.66269e-06*(pt*pt)))+(2.88425e-09*(pt*(pt*pt)));
+        return ((1.15575+(0.000693344*pt))+(-3.02661e-06*(pt*pt)))+(2.39752e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -438,7 +513,7 @@ double BTagDatabase::GetSFMistagCSVMMax(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVTMean(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((1.01739+(0.00283619*pt))+(-7.93013e-06*(pt*pt)))+(5.97491e-09*(pt*(pt*pt)));
+        return ((1.00462+(0.00325971*pt))+(-7.79184e-06*(pt*pt)))+(5.22506e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -449,7 +524,7 @@ double BTagDatabase::GetSFMistagCSVTMean(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVTMin(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((0.953587+(0.00124872*pt))+(-3.97277e-06*(pt*pt)))+(3.23466e-09*(pt*(pt*pt)));
+        return ((0.845757+(0.00186422*pt))+(-4.6133e-06*(pt*pt)))+(3.21723e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -460,7 +535,7 @@ double BTagDatabase::GetSFMistagCSVTMin(double pt, double absEta) const
 double BTagDatabase::GetSFMistagCSVTMax(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((1.08119+(0.00441909*pt))+(-1.18764e-05*(pt*pt)))+(8.71372e-09*(pt*(pt*pt)));
+        return ((1.16361+(0.00464695*pt))+(-1.09467e-05*(pt*pt)))+(7.21896e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -468,10 +543,106 @@ double BTagDatabase::GetSFMistagCSVTMax(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagTCHPTMean(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVV1LMean(double pt, double absEta) const
+{
+    if (absEta < 0.5)
+        return ((1.03599+(0.00187708*pt))+(-3.73001e-06*(pt*pt)))+(2.09649e-09*(pt*(pt*pt)));
+    else if (absEta < 1.0)
+        return ((0.987393+(0.00162718*pt))+(-3.21869e-06*(pt*pt)))+(1.84615e-09*(pt*(pt*pt)));
+    else if (absEta < 1.5)
+        return ((0.950146+(0.00150932*pt))+(-3.28136e-06*(pt*pt)))+(2.06196e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((1.01923+(0.000898874*pt))+(-2.57986e-06*(pt*pt)))+(1.8149e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1LMin(double pt, double absEta) const
+{
+    if (absEta < 0.5)
+        return ((0.995735+(0.00146811*pt))+(-2.83906e-06*(pt*pt)))+(1.5717e-09*(pt*(pt*pt)));
+    else if (absEta < 1.0)
+        return ((0.947416+(0.00130297*pt))+(-2.50427e-06*(pt*pt)))+(1.41682e-09*(pt*(pt*pt)));
+    else if (absEta < 1.5)
+        return ((0.91407+(0.00123525*pt))+(-2.61966e-06*(pt*pt)))+(1.63016e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((0.979782+(0.000743807*pt))+(-2.14927e-06*(pt*pt)))+(1.49486e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1LMax(double pt, double absEta) const
+{
+    if (absEta < 0.5)
+        return ((1.0763+(0.00228243*pt))+(-4.61169e-06*(pt*pt)))+(2.61601e-09*(pt*(pt*pt)));
+    else if (absEta < 1.0)
+        return ((1.02741+(0.00194855*pt))+(-3.92587e-06*(pt*pt)))+(2.27149e-09*(pt*(pt*pt)));
+    else if (absEta < 1.5)
+        return ((0.986259+(0.00178067*pt))+(-3.93596e-06*(pt*pt)))+(2.49014e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((1.05868+(0.00105264*pt))+(-3.00767e-06*(pt*pt)))+(2.13498e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1MMean(double pt, double absEta) const
+{
+    if (absEta < 0.8)
+        return ((1.06383+(0.00279657*pt))+(-5.75405e-06*(pt*pt)))+(3.4302e-09*(pt*(pt*pt)));
+    else if (absEta < 1.6)
+        return ((1.03709+(0.00169762*pt))+(-3.52511e-06*(pt*pt)))+(2.25975e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((1.01679+(0.00211998*pt))+(-6.26097e-06*(pt*pt)))+(4.53843e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1MMin(double pt, double absEta) const
+{
+    if (absEta < 0.8)
+        return ((0.971686+(0.00195242*pt))+(-3.98756e-06*(pt*pt)))+(2.38991e-09*(pt*(pt*pt)));
+    else if (absEta < 1.6)
+        return ((0.947328+(0.00117422*pt))+(-2.32363e-06*(pt*pt)))+(1.46136e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((0.922527+(0.00176245*pt))+(-5.14169e-06*(pt*pt)))+(3.61532e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1MMax(double pt, double absEta) const
+{
+    if (absEta < 0.8)
+        return ((1.15605+(0.00363538*pt))+(-7.50634e-06*(pt*pt)))+(4.4624e-09*(pt*(pt*pt)));
+    else if (absEta < 1.6)
+        return ((1.12687+(0.00221834*pt))+(-4.71949e-06*(pt*pt)))+(3.05456e-09*(pt*(pt*pt)));
+    else if (absEta < 2.4)
+        return ((1.11102+(0.00247531*pt))+(-7.37745e-06*(pt*pt)))+(5.46589e-09*(pt*(pt*pt)));
+    else
+    {
+        throw runtime_error("Eta out of range.");
+        return -100.;
+    }
+}
+
+double BTagDatabase::GetSFMistagCSVV1TMean(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((1.1676+(0.00136673*pt))+(-3.51053e-06*(pt*pt)))+(2.4966e-09*(pt*(pt*pt)));
+        return ((1.15047+(0.00220948*pt))+(-5.17912e-06*(pt*pt)))+(3.39216e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -479,10 +650,10 @@ double BTagDatabase::GetSFMistagTCHPTMean(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagTCHPTMin(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVV1TMin(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((0.988346+(0.000914722*pt))+(-2.37077e-06*(pt*pt)))+(1.72082e-09*(pt*(pt*pt)));
+        return ((0.936862+(0.00149618*pt))+(-3.64924e-06*(pt*pt)))+(2.43883e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -490,10 +661,10 @@ double BTagDatabase::GetSFMistagTCHPTMin(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagTCHPTMax(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVV1TMax(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((1.34691+(0.00181637*pt))+(-4.64484e-06*(pt*pt)))+(3.27122e-09*(pt*(pt*pt)));
+        return ((1.36418+(0.00291794*pt))+(-6.6956e-06*(pt*pt)))+(4.33793e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -501,16 +672,16 @@ double BTagDatabase::GetSFMistagTCHPTMax(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPLMean(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1LMean(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((1.05617+(0.000986016*pt))+(-2.05398e-06*(pt*pt)))+(1.25408e-09*(pt*(pt*pt)));
+        return ((1.06344+(0.0014539*pt))+(-2.72328e-06*(pt*pt)))+(1.47643e-09*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((1.02884+(0.000471854*pt))+(-1.15441e-06*(pt*pt)))+(7.83716e-10*(pt*(pt*pt)));
+        return ((1.0123+(0.00151734*pt))+(-2.99087e-06*(pt*pt)))+(1.73428e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((1.02463+(0.000907924*pt))+(-2.07133e-06*(pt*pt)))+(1.37083e-09*(pt*(pt*pt)));
+        return ((0.975277+(0.00146932*pt))+(-3.17563e-06*(pt*pt)))+(2.03698e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.05387+(0.000951237*pt))+(-2.35437e-06*(pt*pt)))+(1.66123e-09*(pt*(pt*pt)));
+        return ((1.04201+(0.000827388*pt))+(-2.31261e-06*(pt*pt)))+(1.62629e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -518,16 +689,16 @@ double BTagDatabase::GetSFMistagJPLMean(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPLMin(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1LMin(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((0.918762+(0.000749113*pt))+(-1.48511e-06*(pt*pt)))+(8.78559e-10*(pt*(pt*pt)));
+        return ((1.01168+(0.000950951*pt))+(-1.58947e-06*(pt*pt)))+(7.96543e-10*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((0.893017+(0.000369124*pt))+(-8.68577e-07*(pt*pt)))+(5.79006e-10*(pt*(pt*pt)));
+        return ((0.960377+(0.00109821*pt))+(-2.01652e-06*(pt*pt)))+(1.13076e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((0.89415+(0.000712877*pt))+(-1.57703e-06*(pt*pt)))+(1.02034e-09*(pt*(pt*pt)));
+        return ((0.931687+(0.00110971*pt))+(-2.29681e-06*(pt*pt)))+(1.45867e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((0.918611+(0.000781707*pt))+(-1.8923e-06*(pt*pt)))+(1.312e-09*(pt*(pt*pt)));
+        return ((0.992838+(0.000660673*pt))+(-1.84971e-06*(pt*pt)))+(1.2758e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -535,16 +706,16 @@ double BTagDatabase::GetSFMistagJPLMin(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPLMax(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1LMax(double pt, double absEta) const
 {
     if (absEta < 0.5)
-        return ((1.19358+(0.00122182*pt))+(-2.62078e-06*(pt*pt)))+(1.62951e-09*(pt*(pt*pt)));
+        return ((1.11523+(0.00195443*pt))+(-3.85115e-06*(pt*pt)))+(2.15307e-09*(pt*(pt*pt)));
     else if (absEta < 1.0)
-        return ((1.16466+(0.000573985*pt))+(-1.43899e-06*(pt*pt)))+(9.88387e-10*(pt*(pt*pt)));
+        return ((1.06426+(0.0019339*pt))+(-3.95863e-06*(pt*pt)))+(2.3342e-09*(pt*(pt*pt)));
     else if (absEta < 1.5)
-        return ((1.15511+(0.00110197*pt))+(-2.56374e-06*(pt*pt)))+(1.72152e-09*(pt*(pt*pt)));
+        return ((1.0189+(0.00182641*pt))+(-4.04782e-06*(pt*pt)))+(2.61199e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((1.1891+(0.00112006*pt))+(-2.81586e-06*(pt*pt)))+(2.01249e-09*(pt*(pt*pt)));
+        return ((1.09118+(0.000992959*pt))+(-2.77313e-06*(pt*pt)))+(1.9769e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -552,14 +723,14 @@ double BTagDatabase::GetSFMistagJPLMax(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPMMean(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1MMean(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((0.980407+(0.00190765*pt))+(-4.49633e-06*(pt*pt)))+(3.02664e-09*(pt*(pt*pt)));
+        return ((1.06212+(0.00223614*pt))+(-4.25167e-06*(pt*pt)))+(2.42728e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((1.01783+(0.00183763*pt))+(-4.64972e-06*(pt*pt)))+(3.34342e-09*(pt*(pt*pt)));
+        return ((1.04547+(0.00216995*pt))+(-4.579e-06*(pt*pt)))+(2.91791e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((0.866685+(0.00396887*pt))+(-1.11342e-05*(pt*pt)))+(8.84085e-09*(pt*(pt*pt)));
+        return ((0.991865+(0.00324957*pt))+(-9.65897e-06*(pt*pt)))+(7.13694e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -567,14 +738,14 @@ double BTagDatabase::GetSFMistagJPMMean(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPMMin(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1MMin(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((0.813164+(0.00127951*pt))+(-2.74274e-06*(pt*pt)))+(1.78799e-09*(pt*(pt*pt)));
+        return ((0.903956+(0.00121678*pt))+(-2.04383e-06*(pt*pt)))+(1.10727e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((0.860873+(0.00110031*pt))+(-2.48023e-06*(pt*pt)))+(1.73776e-09*(pt*(pt*pt)));
+        return ((0.900637+(0.00120088*pt))+(-2.27069e-06*(pt*pt)))+(1.40609e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((0.740983+(0.00302736*pt))+(-8.12284e-06*(pt*pt)))+(6.281e-09*(pt*(pt*pt)));
+        return ((0.868875+(0.00222761*pt))+(-6.44897e-06*(pt*pt)))+(4.53261e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -582,14 +753,14 @@ double BTagDatabase::GetSFMistagJPMMin(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPMMax(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1MMax(double pt, double absEta) const
 {
     if (absEta < 0.8)
-        return ((1.14766+(0.00253327*pt))+(-6.24447e-06*(pt*pt)))+(4.26468e-09*(pt*(pt*pt)));
+        return ((1.22035+(0.00325183*pt))+(-6.45023e-06*(pt*pt)))+(3.74225e-09*(pt*(pt*pt)));
     else if (absEta < 1.6)
-        return ((1.17479+(0.00257252*pt))+(-6.81377e-06*(pt*pt)))+(4.94891e-09*(pt*(pt*pt)));
+        return ((1.19034+(0.00313562*pt))+(-6.87854e-06*(pt*pt)))+(4.42546e-09*(pt*(pt*pt)));
     else if (absEta < 2.4)
-        return ((0.992297+(0.00490671*pt))+(-1.41403e-05*(pt*pt)))+(1.14097e-08*(pt*(pt*pt)));
+        return ((1.11481+(0.00426745*pt))+(-1.28612e-05*(pt*pt)))+(9.74425e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -597,10 +768,10 @@ double BTagDatabase::GetSFMistagJPMMax(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPTMean(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1TMean(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((0.89627+(0.00328988*pt))+(-8.76392e-06*(pt*pt)))+(6.4662e-09*(pt*(pt*pt)));
+        return ((1.09494+(0.00193966*pt))+(-4.35021e-06*(pt*pt)))+(2.8973e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -608,10 +779,10 @@ double BTagDatabase::GetSFMistagJPTMean(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPTMin(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1TMin(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((0.666092+(0.00262465*pt))+(-6.5345e-06*(pt*pt)))+(4.73926e-09*(pt*(pt*pt)));
+        return ((0.813331+(0.00139561*pt))+(-3.15313e-06*(pt*pt)))+(2.12173e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
@@ -619,14 +790,14 @@ double BTagDatabase::GetSFMistagJPTMin(double pt, double absEta) const
     }
 }
 
-double BTagDatabase::GetSFMistagJPTMax(double pt, double absEta) const
+double BTagDatabase::GetSFMistagCSVSLV1TMax(double pt, double absEta) const
 {
     if (absEta < 2.4)
-        return ((1.12648+(0.00394995*pt))+(-1.0981e-05*(pt*pt)))+(8.19134e-09*(pt*(pt*pt)));
+        return ((1.37663+(0.00247963*pt))+(-5.53583e-06*(pt*pt)))+(3.66635e-09*(pt*(pt*pt)));
     else
     {
         throw runtime_error("Eta out of range.");
         return -100.;
     }
 }
-// End of automatically generated code
\ No newline at end of file
+// End of automatically generated code
diff --git a/core/src/BTagger.cpp b/core/src/BTagger.cpp
index f578ffe..7fac1f0 100644
--- a/core/src/BTagger.cpp
+++ b/core/src/BTagger.cpp
@@ -39,9 +39,14 @@ BTagger::BTagger(Algorithm algo_, WorkingPoint workingPoint_):
                 threshold = 3.41;
             else
                 throw runtime_error("BTagger::BTagger: Only tight working point is supported for "
-                 "TCHP b-tagging algorithm");
+                 "TCHP b-tagging algorithm.");
             
             break;
+        
+        case Algorithm::CSVV1:
+        case Algorithm::CSVSLV1:
+            throw logic_error("BTagger::BTagger: Algorithms CSVV1 and CSVSLV1 are not supported "
+             "yet.");
     }
     
     
@@ -59,6 +64,11 @@ BTagger::BTagger(Algorithm algo_, WorkingPoint workingPoint_):
         case Algorithm::TCHP:
             bTagMethod = &Jet::TCHP;
             break;
+        
+        case Algorithm::CSVV1:
+        case Algorithm::CSVSLV1:
+            throw logic_error("BTagger::BTagger: Algorithms CSVV1 and CSVSLV1 are not supported "
+             "yet.");
     }
 }
 
@@ -107,6 +117,14 @@ string BTagger::GetTextCode() const
         case Algorithm::TCHP:
             code += "TCHP";
             break;
+        
+        case Algorithm::CSVV1:
+            code += "CSVV1";
+            break;
+        
+        case Algorithm::CSVSLV1:
+            code += "CSVSLV1";
+            break;
     }
     
     switch (workingPoint)