Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:24:21 

0001 #ifndef PhysicsTools_Utilities_rootTf1_h
0002 #define PhysicsTools_Utilities_rootTf1_h
0003 #include "PhysicsTools/Utilities/interface/rootFunction.h"
0004 #include "PhysicsTools/Utilities/interface/Parameter.h"
0005 #include "TF1.h"
0006 
0007 namespace root {
0008 
0009   template <typename Tag, typename F>
0010   TF1 tf1_t(const char* name, F& f, double min, double max) {
0011     TF1 fun(name, root::function_t<1, Tag>(f), min, max, 0);
0012     return fun;
0013   }
0014 
0015   template <typename F>
0016   TF1 tf1(const char* name, F& f, double min, double max) {
0017     return tf1_t<helper::null_t>(name, f, min, max);
0018   }
0019 
0020   template <typename Tag, typename F>
0021   TF1 tf1_t(const char* name, F& f, double min, double max, const funct::Parameter& p0) {
0022     TF1 fun(name, root::function_t<1, Tag>(f, p0), min, max, 1);
0023     fun.SetParameter(0, *p0.ptr());
0024     fun.SetParName(0, p0.name().c_str());
0025     return fun;
0026   }
0027 
0028   template <typename F>
0029   TF1 tf1(const char* name, F& f, double min, double max, const funct::Parameter& p0) {
0030     return tf1_t<helper::null_t>(name, f, min, max, p0);
0031   }
0032 
0033   template <typename Tag, typename F>
0034   TF1 tf1_t(const char* name, F& f, double min, double max, const funct::Parameter& p0, const funct::Parameter& p1) {
0035     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1), min, max, 2);
0036     fun.SetParameter(0, *p0.ptr());
0037     fun.SetParName(0, p0.name().c_str());
0038     fun.SetParameter(1, *p1.ptr());
0039     fun.SetParName(1, p1.name().c_str());
0040     return fun;
0041   }
0042 
0043   template <typename F>
0044   TF1 tf1(const char* name, F& f, double min, double max, const funct::Parameter& p0, const funct::Parameter& p1) {
0045     return tf1_t<helper::null_t>(name, f, min, max, p0, p1);
0046   }
0047 
0048   template <typename Tag, typename F>
0049   TF1 tf1_t(const char* name,
0050             F& f,
0051             double min,
0052             double max,
0053             const funct::Parameter& p0,
0054             const funct::Parameter& p1,
0055             const funct::Parameter& p2) {
0056     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2), min, max, 3);
0057     fun.SetParameter(0, *p0.ptr());
0058     fun.SetParName(0, p0.name().c_str());
0059     fun.SetParameter(1, *p1.ptr());
0060     fun.SetParName(1, p1.name().c_str());
0061     fun.SetParameter(2, *p2.ptr());
0062     fun.SetParName(2, p2.name().c_str());
0063     return fun;
0064   }
0065 
0066   template <typename F>
0067   TF1 tf1(const char* name,
0068           F& f,
0069           double min,
0070           double max,
0071           const funct::Parameter& p0,
0072           const funct::Parameter& p1,
0073           const funct::Parameter& p2) {
0074     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2);
0075   }
0076 
0077   template <typename Tag, typename F>
0078   TF1 tf1_t(const char* name,
0079             F& f,
0080             double min,
0081             double max,
0082             const funct::Parameter& p0,
0083             const funct::Parameter& p1,
0084             const funct::Parameter& p2,
0085             const funct::Parameter& p3) {
0086     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3), min, max, 4);
0087     fun.SetParameter(0, *p0.ptr());
0088     fun.SetParName(0, p0.name().c_str());
0089     fun.SetParameter(1, *p1.ptr());
0090     fun.SetParName(1, p1.name().c_str());
0091     fun.SetParameter(2, *p2.ptr());
0092     fun.SetParName(2, p2.name().c_str());
0093     fun.SetParameter(3, *p3.ptr());
0094     fun.SetParName(3, p3.name().c_str());
0095     return fun;
0096   }
0097 
0098   template <typename F>
0099   TF1 tf1(const char* name,
0100           F& f,
0101           double min,
0102           double max,
0103           const funct::Parameter& p0,
0104           const funct::Parameter& p1,
0105           const funct::Parameter& p2,
0106           const funct::Parameter& p3) {
0107     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3);
0108   }
0109 
0110   template <typename Tag, typename F>
0111   TF1 tf1_t(const char* name,
0112             F& f,
0113             double min,
0114             double max,
0115             const funct::Parameter& p0,
0116             const funct::Parameter& p1,
0117             const funct::Parameter& p2,
0118             const funct::Parameter& p3,
0119             const funct::Parameter& p4) {
0120     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4), min, max, 5);
0121     fun.SetParameter(0, *p0.ptr());
0122     fun.SetParName(0, p0.name().c_str());
0123     fun.SetParameter(1, *p1.ptr());
0124     fun.SetParName(1, p1.name().c_str());
0125     fun.SetParameter(2, *p2.ptr());
0126     fun.SetParName(2, p2.name().c_str());
0127     fun.SetParameter(3, *p3.ptr());
0128     fun.SetParName(3, p3.name().c_str());
0129     fun.SetParameter(4, *p4.ptr());
0130     fun.SetParName(4, p4.name().c_str());
0131     return fun;
0132   }
0133 
0134   template <typename F>
0135   TF1 tf1(const char* name,
0136           F& f,
0137           double min,
0138           double max,
0139           const funct::Parameter& p0,
0140           const funct::Parameter& p1,
0141           const funct::Parameter& p2,
0142           const funct::Parameter& p3,
0143           const funct::Parameter& p4) {
0144     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4);
0145   }
0146 
0147   template <typename Tag, typename F>
0148   TF1 tf1_t(const char* name,
0149             F& f,
0150             double min,
0151             double max,
0152             const funct::Parameter& p0,
0153             const funct::Parameter& p1,
0154             const funct::Parameter& p2,
0155             const funct::Parameter& p3,
0156             const funct::Parameter& p4,
0157             const funct::Parameter& p5) {
0158     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5), min, max, 6);
0159     fun.SetParameter(0, *p0.ptr());
0160     fun.SetParName(0, p0.name().c_str());
0161     fun.SetParameter(1, *p1.ptr());
0162     fun.SetParName(1, p1.name().c_str());
0163     fun.SetParameter(2, *p2.ptr());
0164     fun.SetParName(2, p2.name().c_str());
0165     fun.SetParameter(3, *p3.ptr());
0166     fun.SetParName(3, p3.name().c_str());
0167     fun.SetParameter(4, *p4.ptr());
0168     fun.SetParName(4, p4.name().c_str());
0169     fun.SetParameter(5, *p5.ptr());
0170     fun.SetParName(5, p5.name().c_str());
0171     return fun;
0172   }
0173 
0174   template <typename F>
0175   TF1 tf1(const char* name,
0176           F& f,
0177           double min,
0178           double max,
0179           const funct::Parameter& p0,
0180           const funct::Parameter& p1,
0181           const funct::Parameter& p2,
0182           const funct::Parameter& p3,
0183           const funct::Parameter& p4,
0184           const funct::Parameter& p5) {
0185     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5);
0186   }
0187 
0188   template <typename Tag, typename F>
0189   TF1 tf1_t(const char* name,
0190             F& f,
0191             double min,
0192             double max,
0193             const funct::Parameter& p0,
0194             const funct::Parameter& p1,
0195             const funct::Parameter& p2,
0196             const funct::Parameter& p3,
0197             const funct::Parameter& p4,
0198             const funct::Parameter& p5,
0199             const funct::Parameter& p6) {
0200     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6), min, max, 7);
0201     fun.SetParameter(0, *p0.ptr());
0202     fun.SetParName(0, p0.name().c_str());
0203     fun.SetParameter(1, *p1.ptr());
0204     fun.SetParName(1, p1.name().c_str());
0205     fun.SetParameter(2, *p2.ptr());
0206     fun.SetParName(2, p2.name().c_str());
0207     fun.SetParameter(3, *p3.ptr());
0208     fun.SetParName(3, p3.name().c_str());
0209     fun.SetParameter(4, *p4.ptr());
0210     fun.SetParName(4, p4.name().c_str());
0211     fun.SetParameter(5, *p5.ptr());
0212     fun.SetParName(5, p5.name().c_str());
0213     fun.SetParameter(6, *p6.ptr());
0214     fun.SetParName(6, p6.name().c_str());
0215     return fun;
0216   }
0217 
0218   template <typename F>
0219   TF1 tf1(const char* name,
0220           F& f,
0221           double min,
0222           double max,
0223           const funct::Parameter& p0,
0224           const funct::Parameter& p1,
0225           const funct::Parameter& p2,
0226           const funct::Parameter& p3,
0227           const funct::Parameter& p4,
0228           const funct::Parameter& p5,
0229           const funct::Parameter& p6) {
0230     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6);
0231   }
0232 
0233   template <typename Tag, typename F>
0234   TF1 tf1_t(const char* name,
0235             F& f,
0236             double min,
0237             double max,
0238             const funct::Parameter& p0,
0239             const funct::Parameter& p1,
0240             const funct::Parameter& p2,
0241             const funct::Parameter& p3,
0242             const funct::Parameter& p4,
0243             const funct::Parameter& p5,
0244             const funct::Parameter& p6,
0245             const funct::Parameter& p7) {
0246     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7), min, max, 8);
0247     fun.SetParameter(0, *p0.ptr());
0248     fun.SetParName(0, p0.name().c_str());
0249     fun.SetParameter(1, *p1.ptr());
0250     fun.SetParName(1, p1.name().c_str());
0251     fun.SetParameter(2, *p2.ptr());
0252     fun.SetParName(2, p2.name().c_str());
0253     fun.SetParameter(3, *p3.ptr());
0254     fun.SetParName(3, p3.name().c_str());
0255     fun.SetParameter(4, *p4.ptr());
0256     fun.SetParName(4, p4.name().c_str());
0257     fun.SetParameter(5, *p5.ptr());
0258     fun.SetParName(5, p5.name().c_str());
0259     fun.SetParameter(6, *p6.ptr());
0260     fun.SetParName(6, p6.name().c_str());
0261     fun.SetParameter(7, *p7.ptr());
0262     fun.SetParName(7, p7.name().c_str());
0263     return fun;
0264   }
0265 
0266   template <typename F>
0267   TF1 tf1(const char* name,
0268           F& f,
0269           double min,
0270           double max,
0271           const funct::Parameter& p0,
0272           const funct::Parameter& p1,
0273           const funct::Parameter& p2,
0274           const funct::Parameter& p3,
0275           const funct::Parameter& p4,
0276           const funct::Parameter& p5,
0277           const funct::Parameter& p6,
0278           const funct::Parameter& p7) {
0279     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7);
0280   }
0281 
0282   template <typename Tag, typename F>
0283   TF1 tf1_t(const char* name,
0284             F& f,
0285             double min,
0286             double max,
0287             const funct::Parameter& p0,
0288             const funct::Parameter& p1,
0289             const funct::Parameter& p2,
0290             const funct::Parameter& p3,
0291             const funct::Parameter& p4,
0292             const funct::Parameter& p5,
0293             const funct::Parameter& p6,
0294             const funct::Parameter& p7,
0295             const funct::Parameter& p8) {
0296     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8), min, max, 9);
0297     fun.SetParameter(0, *p0.ptr());
0298     fun.SetParName(0, p0.name().c_str());
0299     fun.SetParameter(1, *p1.ptr());
0300     fun.SetParName(1, p1.name().c_str());
0301     fun.SetParameter(2, *p2.ptr());
0302     fun.SetParName(2, p2.name().c_str());
0303     fun.SetParameter(3, *p3.ptr());
0304     fun.SetParName(3, p3.name().c_str());
0305     fun.SetParameter(4, *p4.ptr());
0306     fun.SetParName(4, p4.name().c_str());
0307     fun.SetParameter(5, *p5.ptr());
0308     fun.SetParName(5, p5.name().c_str());
0309     fun.SetParameter(6, *p6.ptr());
0310     fun.SetParName(6, p6.name().c_str());
0311     fun.SetParameter(7, *p7.ptr());
0312     fun.SetParName(7, p7.name().c_str());
0313     fun.SetParameter(8, *p8.ptr());
0314     fun.SetParName(8, p8.name().c_str());
0315     return fun;
0316   }
0317 
0318   template <typename F>
0319   TF1 tf1(const char* name,
0320           F& f,
0321           double min,
0322           double max,
0323           const funct::Parameter& p0,
0324           const funct::Parameter& p1,
0325           const funct::Parameter& p2,
0326           const funct::Parameter& p3,
0327           const funct::Parameter& p4,
0328           const funct::Parameter& p5,
0329           const funct::Parameter& p6,
0330           const funct::Parameter& p7,
0331           const funct::Parameter& p8) {
0332     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8);
0333   }
0334 
0335   template <typename Tag, typename F>
0336   TF1 tf1_t(const char* name,
0337             F& f,
0338             double min,
0339             double max,
0340             const funct::Parameter& p0,
0341             const funct::Parameter& p1,
0342             const funct::Parameter& p2,
0343             const funct::Parameter& p3,
0344             const funct::Parameter& p4,
0345             const funct::Parameter& p5,
0346             const funct::Parameter& p6,
0347             const funct::Parameter& p7,
0348             const funct::Parameter& p8,
0349             const funct::Parameter& p9) {
0350     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9), min, max, 10);
0351     fun.SetParameter(0, *p0.ptr());
0352     fun.SetParName(0, p0.name().c_str());
0353     fun.SetParameter(1, *p1.ptr());
0354     fun.SetParName(1, p1.name().c_str());
0355     fun.SetParameter(2, *p2.ptr());
0356     fun.SetParName(2, p2.name().c_str());
0357     fun.SetParameter(3, *p3.ptr());
0358     fun.SetParName(3, p3.name().c_str());
0359     fun.SetParameter(4, *p4.ptr());
0360     fun.SetParName(4, p4.name().c_str());
0361     fun.SetParameter(5, *p5.ptr());
0362     fun.SetParName(5, p5.name().c_str());
0363     fun.SetParameter(6, *p6.ptr());
0364     fun.SetParName(6, p6.name().c_str());
0365     fun.SetParameter(7, *p7.ptr());
0366     fun.SetParName(7, p7.name().c_str());
0367     fun.SetParameter(8, *p8.ptr());
0368     fun.SetParName(8, p8.name().c_str());
0369     fun.SetParameter(9, *p9.ptr());
0370     fun.SetParName(9, p9.name().c_str());
0371     return fun;
0372   }
0373 
0374   template <typename F>
0375   TF1 tf1(const char* name,
0376           F& f,
0377           double min,
0378           double max,
0379           const funct::Parameter& p0,
0380           const funct::Parameter& p1,
0381           const funct::Parameter& p2,
0382           const funct::Parameter& p3,
0383           const funct::Parameter& p4,
0384           const funct::Parameter& p5,
0385           const funct::Parameter& p6,
0386           const funct::Parameter& p7,
0387           const funct::Parameter& p8,
0388           const funct::Parameter& p9) {
0389     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
0390   }
0391 
0392   template <typename Tag, typename F>
0393   TF1 tf1_t(const char* name,
0394             F& f,
0395             double min,
0396             double max,
0397             const funct::Parameter& p0,
0398             const funct::Parameter& p1,
0399             const funct::Parameter& p2,
0400             const funct::Parameter& p3,
0401             const funct::Parameter& p4,
0402             const funct::Parameter& p5,
0403             const funct::Parameter& p6,
0404             const funct::Parameter& p7,
0405             const funct::Parameter& p8,
0406             const funct::Parameter& p9,
0407             const funct::Parameter& p10) {
0408     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10), min, max, 11);
0409     fun.SetParameter(0, *p0.ptr());
0410     fun.SetParName(0, p0.name().c_str());
0411     fun.SetParameter(1, *p1.ptr());
0412     fun.SetParName(1, p1.name().c_str());
0413     fun.SetParameter(2, *p2.ptr());
0414     fun.SetParName(2, p2.name().c_str());
0415     fun.SetParameter(3, *p3.ptr());
0416     fun.SetParName(3, p3.name().c_str());
0417     fun.SetParameter(4, *p4.ptr());
0418     fun.SetParName(4, p4.name().c_str());
0419     fun.SetParameter(5, *p5.ptr());
0420     fun.SetParName(5, p5.name().c_str());
0421     fun.SetParameter(6, *p6.ptr());
0422     fun.SetParName(6, p6.name().c_str());
0423     fun.SetParameter(7, *p7.ptr());
0424     fun.SetParName(7, p7.name().c_str());
0425     fun.SetParameter(8, *p8.ptr());
0426     fun.SetParName(8, p8.name().c_str());
0427     fun.SetParameter(9, *p9.ptr());
0428     fun.SetParName(9, p9.name().c_str());
0429     fun.SetParameter(10, *p10.ptr());
0430     fun.SetParName(10, p10.name().c_str());
0431     return fun;
0432   }
0433 
0434   template <typename F>
0435   TF1 tf1(const char* name,
0436           F& f,
0437           double min,
0438           double max,
0439           const funct::Parameter& p0,
0440           const funct::Parameter& p1,
0441           const funct::Parameter& p2,
0442           const funct::Parameter& p3,
0443           const funct::Parameter& p4,
0444           const funct::Parameter& p5,
0445           const funct::Parameter& p6,
0446           const funct::Parameter& p7,
0447           const funct::Parameter& p8,
0448           const funct::Parameter& p9,
0449           const funct::Parameter& p10) {
0450     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
0451   }
0452 
0453   template <typename Tag, typename F>
0454   TF1 tf1_t(const char* name,
0455             F& f,
0456             double min,
0457             double max,
0458             const funct::Parameter& p0,
0459             const funct::Parameter& p1,
0460             const funct::Parameter& p2,
0461             const funct::Parameter& p3,
0462             const funct::Parameter& p4,
0463             const funct::Parameter& p5,
0464             const funct::Parameter& p6,
0465             const funct::Parameter& p7,
0466             const funct::Parameter& p8,
0467             const funct::Parameter& p9,
0468             const funct::Parameter& p10,
0469             const funct::Parameter& p11) {
0470     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11), min, max, 12);
0471     fun.SetParameter(0, *p0.ptr());
0472     fun.SetParName(0, p0.name().c_str());
0473     fun.SetParameter(1, *p1.ptr());
0474     fun.SetParName(1, p1.name().c_str());
0475     fun.SetParameter(2, *p2.ptr());
0476     fun.SetParName(2, p2.name().c_str());
0477     fun.SetParameter(3, *p3.ptr());
0478     fun.SetParName(3, p3.name().c_str());
0479     fun.SetParameter(4, *p4.ptr());
0480     fun.SetParName(4, p4.name().c_str());
0481     fun.SetParameter(5, *p5.ptr());
0482     fun.SetParName(5, p5.name().c_str());
0483     fun.SetParameter(6, *p6.ptr());
0484     fun.SetParName(6, p6.name().c_str());
0485     fun.SetParameter(7, *p7.ptr());
0486     fun.SetParName(7, p7.name().c_str());
0487     fun.SetParameter(8, *p8.ptr());
0488     fun.SetParName(8, p8.name().c_str());
0489     fun.SetParameter(9, *p9.ptr());
0490     fun.SetParName(9, p9.name().c_str());
0491     fun.SetParameter(10, *p10.ptr());
0492     fun.SetParName(10, p10.name().c_str());
0493     fun.SetParameter(11, *p11.ptr());
0494     fun.SetParName(11, p11.name().c_str());
0495     return fun;
0496   }
0497 
0498   template <typename F>
0499   TF1 tf1(const char* name,
0500           F& f,
0501           double min,
0502           double max,
0503           const funct::Parameter& p0,
0504           const funct::Parameter& p1,
0505           const funct::Parameter& p2,
0506           const funct::Parameter& p3,
0507           const funct::Parameter& p4,
0508           const funct::Parameter& p5,
0509           const funct::Parameter& p6,
0510           const funct::Parameter& p7,
0511           const funct::Parameter& p8,
0512           const funct::Parameter& p9,
0513           const funct::Parameter& p10,
0514           const funct::Parameter& p11) {
0515     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
0516   }
0517 
0518   template <typename Tag, typename F>
0519   TF1 tf1_t(const char* name,
0520             F& f,
0521             double min,
0522             double max,
0523             const funct::Parameter& p0,
0524             const funct::Parameter& p1,
0525             const funct::Parameter& p2,
0526             const funct::Parameter& p3,
0527             const funct::Parameter& p4,
0528             const funct::Parameter& p5,
0529             const funct::Parameter& p6,
0530             const funct::Parameter& p7,
0531             const funct::Parameter& p8,
0532             const funct::Parameter& p9,
0533             const funct::Parameter& p10,
0534             const funct::Parameter& p11,
0535             const funct::Parameter& p12) {
0536     TF1 fun(name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12), min, max, 13);
0537     fun.SetParameter(0, *p0.ptr());
0538     fun.SetParName(0, p0.name().c_str());
0539     fun.SetParameter(1, *p1.ptr());
0540     fun.SetParName(1, p1.name().c_str());
0541     fun.SetParameter(2, *p2.ptr());
0542     fun.SetParName(2, p2.name().c_str());
0543     fun.SetParameter(3, *p3.ptr());
0544     fun.SetParName(3, p3.name().c_str());
0545     fun.SetParameter(4, *p4.ptr());
0546     fun.SetParName(4, p4.name().c_str());
0547     fun.SetParameter(5, *p5.ptr());
0548     fun.SetParName(5, p5.name().c_str());
0549     fun.SetParameter(6, *p6.ptr());
0550     fun.SetParName(6, p6.name().c_str());
0551     fun.SetParameter(7, *p7.ptr());
0552     fun.SetParName(7, p7.name().c_str());
0553     fun.SetParameter(8, *p8.ptr());
0554     fun.SetParName(8, p8.name().c_str());
0555     fun.SetParameter(9, *p9.ptr());
0556     fun.SetParName(9, p9.name().c_str());
0557     fun.SetParameter(10, *p10.ptr());
0558     fun.SetParName(10, p10.name().c_str());
0559     fun.SetParameter(11, *p11.ptr());
0560     fun.SetParName(11, p11.name().c_str());
0561     fun.SetParameter(12, *p12.ptr());
0562     fun.SetParName(12, p12.name().c_str());
0563     return fun;
0564   }
0565 
0566   template <typename F>
0567   TF1 tf1(const char* name,
0568           F& f,
0569           double min,
0570           double max,
0571           const funct::Parameter& p0,
0572           const funct::Parameter& p1,
0573           const funct::Parameter& p2,
0574           const funct::Parameter& p3,
0575           const funct::Parameter& p4,
0576           const funct::Parameter& p5,
0577           const funct::Parameter& p6,
0578           const funct::Parameter& p7,
0579           const funct::Parameter& p8,
0580           const funct::Parameter& p9,
0581           const funct::Parameter& p10,
0582           const funct::Parameter& p11,
0583           const funct::Parameter& p12) {
0584     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
0585   }
0586 
0587   template <typename Tag, typename F>
0588   TF1 tf1_t(const char* name,
0589             F& f,
0590             double min,
0591             double max,
0592             const funct::Parameter& p0,
0593             const funct::Parameter& p1,
0594             const funct::Parameter& p2,
0595             const funct::Parameter& p3,
0596             const funct::Parameter& p4,
0597             const funct::Parameter& p5,
0598             const funct::Parameter& p6,
0599             const funct::Parameter& p7,
0600             const funct::Parameter& p8,
0601             const funct::Parameter& p9,
0602             const funct::Parameter& p10,
0603             const funct::Parameter& p11,
0604             const funct::Parameter& p12,
0605             const funct::Parameter& p13) {
0606     TF1 fun(
0607         name, root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13), min, max, 14);
0608     fun.SetParameter(0, *p0.ptr());
0609     fun.SetParName(0, p0.name().c_str());
0610     fun.SetParameter(1, *p1.ptr());
0611     fun.SetParName(1, p1.name().c_str());
0612     fun.SetParameter(2, *p2.ptr());
0613     fun.SetParName(2, p2.name().c_str());
0614     fun.SetParameter(3, *p3.ptr());
0615     fun.SetParName(3, p3.name().c_str());
0616     fun.SetParameter(4, *p4.ptr());
0617     fun.SetParName(4, p4.name().c_str());
0618     fun.SetParameter(5, *p5.ptr());
0619     fun.SetParName(5, p5.name().c_str());
0620     fun.SetParameter(6, *p6.ptr());
0621     fun.SetParName(6, p6.name().c_str());
0622     fun.SetParameter(7, *p7.ptr());
0623     fun.SetParName(7, p7.name().c_str());
0624     fun.SetParameter(8, *p8.ptr());
0625     fun.SetParName(8, p8.name().c_str());
0626     fun.SetParameter(9, *p9.ptr());
0627     fun.SetParName(9, p9.name().c_str());
0628     fun.SetParameter(10, *p10.ptr());
0629     fun.SetParName(10, p10.name().c_str());
0630     fun.SetParameter(11, *p11.ptr());
0631     fun.SetParName(11, p11.name().c_str());
0632     fun.SetParameter(12, *p12.ptr());
0633     fun.SetParName(12, p12.name().c_str());
0634     fun.SetParameter(13, *p13.ptr());
0635     fun.SetParName(13, p13.name().c_str());
0636     return fun;
0637   }
0638 
0639   template <typename F>
0640   TF1 tf1(const char* name,
0641           F& f,
0642           double min,
0643           double max,
0644           const funct::Parameter& p0,
0645           const funct::Parameter& p1,
0646           const funct::Parameter& p2,
0647           const funct::Parameter& p3,
0648           const funct::Parameter& p4,
0649           const funct::Parameter& p5,
0650           const funct::Parameter& p6,
0651           const funct::Parameter& p7,
0652           const funct::Parameter& p8,
0653           const funct::Parameter& p9,
0654           const funct::Parameter& p10,
0655           const funct::Parameter& p11,
0656           const funct::Parameter& p12,
0657           const funct::Parameter& p13) {
0658     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
0659   }
0660 
0661   template <typename Tag, typename F>
0662   TF1 tf1_t(const char* name,
0663             F& f,
0664             double min,
0665             double max,
0666             const funct::Parameter& p0,
0667             const funct::Parameter& p1,
0668             const funct::Parameter& p2,
0669             const funct::Parameter& p3,
0670             const funct::Parameter& p4,
0671             const funct::Parameter& p5,
0672             const funct::Parameter& p6,
0673             const funct::Parameter& p7,
0674             const funct::Parameter& p8,
0675             const funct::Parameter& p9,
0676             const funct::Parameter& p10,
0677             const funct::Parameter& p11,
0678             const funct::Parameter& p12,
0679             const funct::Parameter& p13,
0680             const funct::Parameter& p14) {
0681     TF1 fun(name,
0682             root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14),
0683             min,
0684             max,
0685             15);
0686     fun.SetParameter(0, *p0.ptr());
0687     fun.SetParName(0, p0.name().c_str());
0688     fun.SetParameter(1, *p1.ptr());
0689     fun.SetParName(1, p1.name().c_str());
0690     fun.SetParameter(2, *p2.ptr());
0691     fun.SetParName(2, p2.name().c_str());
0692     fun.SetParameter(3, *p3.ptr());
0693     fun.SetParName(3, p3.name().c_str());
0694     fun.SetParameter(4, *p4.ptr());
0695     fun.SetParName(4, p4.name().c_str());
0696     fun.SetParameter(5, *p5.ptr());
0697     fun.SetParName(5, p5.name().c_str());
0698     fun.SetParameter(6, *p6.ptr());
0699     fun.SetParName(6, p6.name().c_str());
0700     fun.SetParameter(7, *p7.ptr());
0701     fun.SetParName(7, p7.name().c_str());
0702     fun.SetParameter(8, *p8.ptr());
0703     fun.SetParName(8, p8.name().c_str());
0704     fun.SetParameter(9, *p9.ptr());
0705     fun.SetParName(9, p9.name().c_str());
0706     fun.SetParameter(10, *p10.ptr());
0707     fun.SetParName(10, p10.name().c_str());
0708     fun.SetParameter(11, *p11.ptr());
0709     fun.SetParName(11, p11.name().c_str());
0710     fun.SetParameter(12, *p12.ptr());
0711     fun.SetParName(12, p12.name().c_str());
0712     fun.SetParameter(13, *p13.ptr());
0713     fun.SetParName(13, p13.name().c_str());
0714     fun.SetParameter(14, *p14.ptr());
0715     fun.SetParName(14, p14.name().c_str());
0716     return fun;
0717   }
0718 
0719   template <typename F>
0720   TF1 tf1(const char* name,
0721           F& f,
0722           double min,
0723           double max,
0724           const funct::Parameter& p0,
0725           const funct::Parameter& p1,
0726           const funct::Parameter& p2,
0727           const funct::Parameter& p3,
0728           const funct::Parameter& p4,
0729           const funct::Parameter& p5,
0730           const funct::Parameter& p6,
0731           const funct::Parameter& p7,
0732           const funct::Parameter& p8,
0733           const funct::Parameter& p9,
0734           const funct::Parameter& p10,
0735           const funct::Parameter& p11,
0736           const funct::Parameter& p12,
0737           const funct::Parameter& p13,
0738           const funct::Parameter& p14) {
0739     return tf1_t<helper::null_t>(name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
0740   }
0741 
0742   template <typename Tag, typename F>
0743   TF1 tf1_t(const char* name,
0744             F& f,
0745             double min,
0746             double max,
0747             const funct::Parameter& p0,
0748             const funct::Parameter& p1,
0749             const funct::Parameter& p2,
0750             const funct::Parameter& p3,
0751             const funct::Parameter& p4,
0752             const funct::Parameter& p5,
0753             const funct::Parameter& p6,
0754             const funct::Parameter& p7,
0755             const funct::Parameter& p8,
0756             const funct::Parameter& p9,
0757             const funct::Parameter& p10,
0758             const funct::Parameter& p11,
0759             const funct::Parameter& p12,
0760             const funct::Parameter& p13,
0761             const funct::Parameter& p14,
0762             const funct::Parameter& p15) {
0763     TF1 fun(name,
0764             root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15),
0765             min,
0766             max,
0767             16);
0768     fun.SetParameter(0, *p0.ptr());
0769     fun.SetParName(0, p0.name().c_str());
0770     fun.SetParameter(1, *p1.ptr());
0771     fun.SetParName(1, p1.name().c_str());
0772     fun.SetParameter(2, *p2.ptr());
0773     fun.SetParName(2, p2.name().c_str());
0774     fun.SetParameter(3, *p3.ptr());
0775     fun.SetParName(3, p3.name().c_str());
0776     fun.SetParameter(4, *p4.ptr());
0777     fun.SetParName(4, p4.name().c_str());
0778     fun.SetParameter(5, *p5.ptr());
0779     fun.SetParName(5, p5.name().c_str());
0780     fun.SetParameter(6, *p6.ptr());
0781     fun.SetParName(6, p6.name().c_str());
0782     fun.SetParameter(7, *p7.ptr());
0783     fun.SetParName(7, p7.name().c_str());
0784     fun.SetParameter(8, *p8.ptr());
0785     fun.SetParName(8, p8.name().c_str());
0786     fun.SetParameter(9, *p9.ptr());
0787     fun.SetParName(9, p9.name().c_str());
0788     fun.SetParameter(10, *p10.ptr());
0789     fun.SetParName(10, p10.name().c_str());
0790     fun.SetParameter(11, *p11.ptr());
0791     fun.SetParName(11, p11.name().c_str());
0792     fun.SetParameter(12, *p12.ptr());
0793     fun.SetParName(12, p12.name().c_str());
0794     fun.SetParameter(13, *p13.ptr());
0795     fun.SetParName(13, p13.name().c_str());
0796     fun.SetParameter(14, *p14.ptr());
0797     fun.SetParName(14, p14.name().c_str());
0798     fun.SetParameter(15, *p15.ptr());
0799     fun.SetParName(15, p15.name().c_str());
0800     return fun;
0801   }
0802 
0803   template <typename F>
0804   TF1 tf1(const char* name,
0805           F& f,
0806           double min,
0807           double max,
0808           const funct::Parameter& p0,
0809           const funct::Parameter& p1,
0810           const funct::Parameter& p2,
0811           const funct::Parameter& p3,
0812           const funct::Parameter& p4,
0813           const funct::Parameter& p5,
0814           const funct::Parameter& p6,
0815           const funct::Parameter& p7,
0816           const funct::Parameter& p8,
0817           const funct::Parameter& p9,
0818           const funct::Parameter& p10,
0819           const funct::Parameter& p11,
0820           const funct::Parameter& p12,
0821           const funct::Parameter& p13,
0822           const funct::Parameter& p14,
0823           const funct::Parameter& p15) {
0824     return tf1_t<helper::null_t>(
0825         name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
0826   }
0827 
0828   template <typename Tag, typename F>
0829   TF1 tf1_t(const char* name,
0830             F& f,
0831             double min,
0832             double max,
0833             const funct::Parameter& p0,
0834             const funct::Parameter& p1,
0835             const funct::Parameter& p2,
0836             const funct::Parameter& p3,
0837             const funct::Parameter& p4,
0838             const funct::Parameter& p5,
0839             const funct::Parameter& p6,
0840             const funct::Parameter& p7,
0841             const funct::Parameter& p8,
0842             const funct::Parameter& p9,
0843             const funct::Parameter& p10,
0844             const funct::Parameter& p11,
0845             const funct::Parameter& p12,
0846             const funct::Parameter& p13,
0847             const funct::Parameter& p14,
0848             const funct::Parameter& p15,
0849             const funct::Parameter& p16) {
0850     TF1 fun(name,
0851             root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16),
0852             min,
0853             max,
0854             17);
0855     fun.SetParameter(0, *p0.ptr());
0856     fun.SetParName(0, p0.name().c_str());
0857     fun.SetParameter(1, *p1.ptr());
0858     fun.SetParName(1, p1.name().c_str());
0859     fun.SetParameter(2, *p2.ptr());
0860     fun.SetParName(2, p2.name().c_str());
0861     fun.SetParameter(3, *p3.ptr());
0862     fun.SetParName(3, p3.name().c_str());
0863     fun.SetParameter(4, *p4.ptr());
0864     fun.SetParName(4, p4.name().c_str());
0865     fun.SetParameter(5, *p5.ptr());
0866     fun.SetParName(5, p5.name().c_str());
0867     fun.SetParameter(6, *p6.ptr());
0868     fun.SetParName(6, p6.name().c_str());
0869     fun.SetParameter(7, *p7.ptr());
0870     fun.SetParName(7, p7.name().c_str());
0871     fun.SetParameter(8, *p8.ptr());
0872     fun.SetParName(8, p8.name().c_str());
0873     fun.SetParameter(9, *p9.ptr());
0874     fun.SetParName(9, p9.name().c_str());
0875     fun.SetParameter(10, *p10.ptr());
0876     fun.SetParName(10, p10.name().c_str());
0877     fun.SetParameter(11, *p11.ptr());
0878     fun.SetParName(11, p11.name().c_str());
0879     fun.SetParameter(12, *p12.ptr());
0880     fun.SetParName(12, p12.name().c_str());
0881     fun.SetParameter(13, *p13.ptr());
0882     fun.SetParName(13, p13.name().c_str());
0883     fun.SetParameter(14, *p14.ptr());
0884     fun.SetParName(14, p14.name().c_str());
0885     fun.SetParameter(15, *p15.ptr());
0886     fun.SetParName(15, p15.name().c_str());
0887     fun.SetParameter(16, *p16.ptr());
0888     fun.SetParName(16, p16.name().c_str());
0889     return fun;
0890   }
0891 
0892   template <typename F>
0893   TF1 tf1(const char* name,
0894           F& f,
0895           double min,
0896           double max,
0897           const funct::Parameter& p0,
0898           const funct::Parameter& p1,
0899           const funct::Parameter& p2,
0900           const funct::Parameter& p3,
0901           const funct::Parameter& p4,
0902           const funct::Parameter& p5,
0903           const funct::Parameter& p6,
0904           const funct::Parameter& p7,
0905           const funct::Parameter& p8,
0906           const funct::Parameter& p9,
0907           const funct::Parameter& p10,
0908           const funct::Parameter& p11,
0909           const funct::Parameter& p12,
0910           const funct::Parameter& p13,
0911           const funct::Parameter& p14,
0912           const funct::Parameter& p15,
0913           const funct::Parameter& p16) {
0914     return tf1_t<helper::null_t>(
0915         name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
0916   }
0917 
0918   template <typename Tag, typename F>
0919   TF1 tf1_t(const char* name,
0920             F& f,
0921             double min,
0922             double max,
0923             const funct::Parameter& p0,
0924             const funct::Parameter& p1,
0925             const funct::Parameter& p2,
0926             const funct::Parameter& p3,
0927             const funct::Parameter& p4,
0928             const funct::Parameter& p5,
0929             const funct::Parameter& p6,
0930             const funct::Parameter& p7,
0931             const funct::Parameter& p8,
0932             const funct::Parameter& p9,
0933             const funct::Parameter& p10,
0934             const funct::Parameter& p11,
0935             const funct::Parameter& p12,
0936             const funct::Parameter& p13,
0937             const funct::Parameter& p14,
0938             const funct::Parameter& p15,
0939             const funct::Parameter& p16,
0940             const funct::Parameter& p17) {
0941     TF1 fun(name,
0942             root::function_t<1, Tag>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17),
0943             min,
0944             max,
0945             18);
0946     fun.SetParameter(0, *p0.ptr());
0947     fun.SetParName(0, p0.name().c_str());
0948     fun.SetParameter(1, *p1.ptr());
0949     fun.SetParName(1, p1.name().c_str());
0950     fun.SetParameter(2, *p2.ptr());
0951     fun.SetParName(2, p2.name().c_str());
0952     fun.SetParameter(3, *p3.ptr());
0953     fun.SetParName(3, p3.name().c_str());
0954     fun.SetParameter(4, *p4.ptr());
0955     fun.SetParName(4, p4.name().c_str());
0956     fun.SetParameter(5, *p5.ptr());
0957     fun.SetParName(5, p5.name().c_str());
0958     fun.SetParameter(6, *p6.ptr());
0959     fun.SetParName(6, p6.name().c_str());
0960     fun.SetParameter(7, *p7.ptr());
0961     fun.SetParName(7, p7.name().c_str());
0962     fun.SetParameter(8, *p8.ptr());
0963     fun.SetParName(8, p8.name().c_str());
0964     fun.SetParameter(9, *p9.ptr());
0965     fun.SetParName(9, p9.name().c_str());
0966     fun.SetParameter(10, *p10.ptr());
0967     fun.SetParName(10, p10.name().c_str());
0968     fun.SetParameter(11, *p11.ptr());
0969     fun.SetParName(11, p11.name().c_str());
0970     fun.SetParameter(12, *p12.ptr());
0971     fun.SetParName(12, p12.name().c_str());
0972     fun.SetParameter(13, *p13.ptr());
0973     fun.SetParName(13, p13.name().c_str());
0974     fun.SetParameter(14, *p14.ptr());
0975     fun.SetParName(14, p14.name().c_str());
0976     fun.SetParameter(15, *p15.ptr());
0977     fun.SetParName(15, p15.name().c_str());
0978     fun.SetParameter(16, *p16.ptr());
0979     fun.SetParName(16, p16.name().c_str());
0980     fun.SetParameter(17, *p17.ptr());
0981     fun.SetParName(17, p17.name().c_str());
0982     return fun;
0983   }
0984 
0985   template <typename F>
0986   TF1 tf1(const char* name,
0987           F& f,
0988           double min,
0989           double max,
0990           const funct::Parameter& p0,
0991           const funct::Parameter& p1,
0992           const funct::Parameter& p2,
0993           const funct::Parameter& p3,
0994           const funct::Parameter& p4,
0995           const funct::Parameter& p5,
0996           const funct::Parameter& p6,
0997           const funct::Parameter& p7,
0998           const funct::Parameter& p8,
0999           const funct::Parameter& p9,
1000           const funct::Parameter& p10,
1001           const funct::Parameter& p11,
1002           const funct::Parameter& p12,
1003           const funct::Parameter& p13,
1004           const funct::Parameter& p14,
1005           const funct::Parameter& p15,
1006           const funct::Parameter& p16,
1007           const funct::Parameter& p17) {
1008     return tf1_t<helper::null_t>(
1009         name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
1010   }
1011 
1012   template <typename Tag, typename F>
1013   TF1 tf1_t(const char* name,
1014             F& f,
1015             double min,
1016             double max,
1017             const funct::Parameter& p0,
1018             const funct::Parameter& p1,
1019             const funct::Parameter& p2,
1020             const funct::Parameter& p3,
1021             const funct::Parameter& p4,
1022             const funct::Parameter& p5,
1023             const funct::Parameter& p6,
1024             const funct::Parameter& p7,
1025             const funct::Parameter& p8,
1026             const funct::Parameter& p9,
1027             const funct::Parameter& p10,
1028             const funct::Parameter& p11,
1029             const funct::Parameter& p12,
1030             const funct::Parameter& p13,
1031             const funct::Parameter& p14,
1032             const funct::Parameter& p15,
1033             const funct::Parameter& p16,
1034             const funct::Parameter& p17,
1035             const funct::Parameter& p18) {
1036     TF1 fun(name,
1037             root::function_t<1, Tag>(
1038                 f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18),
1039             min,
1040             max,
1041             19);
1042     fun.SetParameter(0, *p0.ptr());
1043     fun.SetParName(0, p0.name().c_str());
1044     fun.SetParameter(1, *p1.ptr());
1045     fun.SetParName(1, p1.name().c_str());
1046     fun.SetParameter(2, *p2.ptr());
1047     fun.SetParName(2, p2.name().c_str());
1048     fun.SetParameter(3, *p3.ptr());
1049     fun.SetParName(3, p3.name().c_str());
1050     fun.SetParameter(4, *p4.ptr());
1051     fun.SetParName(4, p4.name().c_str());
1052     fun.SetParameter(5, *p5.ptr());
1053     fun.SetParName(5, p5.name().c_str());
1054     fun.SetParameter(6, *p6.ptr());
1055     fun.SetParName(6, p6.name().c_str());
1056     fun.SetParameter(7, *p7.ptr());
1057     fun.SetParName(7, p7.name().c_str());
1058     fun.SetParameter(8, *p8.ptr());
1059     fun.SetParName(8, p8.name().c_str());
1060     fun.SetParameter(9, *p9.ptr());
1061     fun.SetParName(9, p9.name().c_str());
1062     fun.SetParameter(10, *p10.ptr());
1063     fun.SetParName(10, p10.name().c_str());
1064     fun.SetParameter(11, *p11.ptr());
1065     fun.SetParName(11, p11.name().c_str());
1066     fun.SetParameter(12, *p12.ptr());
1067     fun.SetParName(12, p12.name().c_str());
1068     fun.SetParameter(13, *p13.ptr());
1069     fun.SetParName(13, p13.name().c_str());
1070     fun.SetParameter(14, *p14.ptr());
1071     fun.SetParName(14, p14.name().c_str());
1072     fun.SetParameter(15, *p15.ptr());
1073     fun.SetParName(15, p15.name().c_str());
1074     fun.SetParameter(16, *p16.ptr());
1075     fun.SetParName(16, p16.name().c_str());
1076     fun.SetParameter(17, *p17.ptr());
1077     fun.SetParName(17, p17.name().c_str());
1078     fun.SetParameter(18, *p18.ptr());
1079     fun.SetParName(18, p18.name().c_str());
1080     return fun;
1081   }
1082 
1083   template <typename F>
1084   TF1 tf1(const char* name,
1085           F& f,
1086           double min,
1087           double max,
1088           const funct::Parameter& p0,
1089           const funct::Parameter& p1,
1090           const funct::Parameter& p2,
1091           const funct::Parameter& p3,
1092           const funct::Parameter& p4,
1093           const funct::Parameter& p5,
1094           const funct::Parameter& p6,
1095           const funct::Parameter& p7,
1096           const funct::Parameter& p8,
1097           const funct::Parameter& p9,
1098           const funct::Parameter& p10,
1099           const funct::Parameter& p11,
1100           const funct::Parameter& p12,
1101           const funct::Parameter& p13,
1102           const funct::Parameter& p14,
1103           const funct::Parameter& p15,
1104           const funct::Parameter& p16,
1105           const funct::Parameter& p17,
1106           const funct::Parameter& p18) {
1107     return tf1_t<helper::null_t>(
1108         name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
1109   }
1110 
1111   template <typename Tag, typename F>
1112   TF1 tf1_t(const char* name,
1113             F& f,
1114             double min,
1115             double max,
1116             const funct::Parameter& p0,
1117             const funct::Parameter& p1,
1118             const funct::Parameter& p2,
1119             const funct::Parameter& p3,
1120             const funct::Parameter& p4,
1121             const funct::Parameter& p5,
1122             const funct::Parameter& p6,
1123             const funct::Parameter& p7,
1124             const funct::Parameter& p8,
1125             const funct::Parameter& p9,
1126             const funct::Parameter& p10,
1127             const funct::Parameter& p11,
1128             const funct::Parameter& p12,
1129             const funct::Parameter& p13,
1130             const funct::Parameter& p14,
1131             const funct::Parameter& p15,
1132             const funct::Parameter& p16,
1133             const funct::Parameter& p17,
1134             const funct::Parameter& p18,
1135             const funct::Parameter& p19) {
1136     TF1 fun(name,
1137             root::function_t<1, Tag>(
1138                 f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19),
1139             min,
1140             max,
1141             20);
1142     fun.SetParameter(0, *p0.ptr());
1143     fun.SetParName(0, p0.name().c_str());
1144     fun.SetParameter(1, *p1.ptr());
1145     fun.SetParName(1, p1.name().c_str());
1146     fun.SetParameter(2, *p2.ptr());
1147     fun.SetParName(2, p2.name().c_str());
1148     fun.SetParameter(3, *p3.ptr());
1149     fun.SetParName(3, p3.name().c_str());
1150     fun.SetParameter(4, *p4.ptr());
1151     fun.SetParName(4, p4.name().c_str());
1152     fun.SetParameter(5, *p5.ptr());
1153     fun.SetParName(5, p5.name().c_str());
1154     fun.SetParameter(6, *p6.ptr());
1155     fun.SetParName(6, p6.name().c_str());
1156     fun.SetParameter(7, *p7.ptr());
1157     fun.SetParName(7, p7.name().c_str());
1158     fun.SetParameter(8, *p8.ptr());
1159     fun.SetParName(8, p8.name().c_str());
1160     fun.SetParameter(9, *p9.ptr());
1161     fun.SetParName(9, p9.name().c_str());
1162     fun.SetParameter(10, *p10.ptr());
1163     fun.SetParName(10, p10.name().c_str());
1164     fun.SetParameter(11, *p11.ptr());
1165     fun.SetParName(11, p11.name().c_str());
1166     fun.SetParameter(12, *p12.ptr());
1167     fun.SetParName(12, p12.name().c_str());
1168     fun.SetParameter(13, *p13.ptr());
1169     fun.SetParName(13, p13.name().c_str());
1170     fun.SetParameter(14, *p14.ptr());
1171     fun.SetParName(14, p14.name().c_str());
1172     fun.SetParameter(15, *p15.ptr());
1173     fun.SetParName(15, p15.name().c_str());
1174     fun.SetParameter(16, *p16.ptr());
1175     fun.SetParName(16, p16.name().c_str());
1176     fun.SetParameter(17, *p17.ptr());
1177     fun.SetParName(17, p17.name().c_str());
1178     fun.SetParameter(18, *p18.ptr());
1179     fun.SetParName(18, p18.name().c_str());
1180     fun.SetParameter(19, *p19.ptr());
1181     fun.SetParName(19, p19.name().c_str());
1182     return fun;
1183   }
1184 
1185   template <typename F>
1186   TF1 tf1(const char* name,
1187           F& f,
1188           double min,
1189           double max,
1190           const funct::Parameter& p0,
1191           const funct::Parameter& p1,
1192           const funct::Parameter& p2,
1193           const funct::Parameter& p3,
1194           const funct::Parameter& p4,
1195           const funct::Parameter& p5,
1196           const funct::Parameter& p6,
1197           const funct::Parameter& p7,
1198           const funct::Parameter& p8,
1199           const funct::Parameter& p9,
1200           const funct::Parameter& p10,
1201           const funct::Parameter& p11,
1202           const funct::Parameter& p12,
1203           const funct::Parameter& p13,
1204           const funct::Parameter& p14,
1205           const funct::Parameter& p15,
1206           const funct::Parameter& p16,
1207           const funct::Parameter& p17,
1208           const funct::Parameter& p18,
1209           const funct::Parameter& p19) {
1210     return tf1_t<helper::null_t>(
1211         name, f, min, max, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
1212   }
1213 
1214   template <typename Tag, typename F>
1215   TF1 tf1_t(const char* name, F& f, double min, double max, const std::vector<funct::Parameter>& p) {
1216     TF1 fun(name, root::function_t<1, Tag>(f, p), min, max, p.size());
1217     for (size_t i = 0; i < p.size(); ++i) {
1218       fun.SetParameter(i, *p[i].ptr());
1219       fun.SetParName(i, p[i].name().c_str());
1220     }
1221     return fun;
1222   }
1223 
1224   template <typename F>
1225   TF1 tf1(const char* name, F& f, double min, double max, const std::vector<funct::Parameter>& p) {
1226     return tf1_t<helper::null_t>(name, f, min, max, p);
1227   }
1228 
1229   template <typename Tag, typename F>
1230   TF1 tf1_t(const char* name, F& f, double min, double max, const std::vector<std::shared_ptr<double> >& p) {
1231     TF1 fun(name, root::function_t<1, Tag>(f, p), min, max, p.size());
1232     for (size_t i = 0; i < p.size(); ++i)
1233       fun.SetParameter(i, *p[i]);
1234     return fun;
1235   }
1236 
1237   template <typename F>
1238   TF1 tf1(const char* name, F& f, double min, double max, const std::vector<std::shared_ptr<double> >& p) {
1239     return tf1_t<helper::null_t>(name, f, min, max, p);
1240   }
1241 
1242 }  // namespace root
1243 
1244 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!