ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/ElectronEnergyRegression.cc

Comparing UserCode/MitPhysics/Utils/src/ElectronEnergyRegression.cc (file contents):
Revision 1.1 by sixie, Tue Oct 9 13:57:28 2012 UTC vs.
Revision 1.2 by sixie, Fri Dec 14 14:17:30 2012 UTC

#	Line 27 | Line 27 | void ElectronEnergyRegression::initializ
27		// Loading forest object according to different versions
28		TFile file(weightsFile.c_str());
29
30	<	if (type == kNoTrkVar || type == kWithTrkVar) {
30	>	if (type == kNoTrkVar || type == kWithTrkVarV1 || type == kWithTrkVarV2) {
31		forestCorrection_eb = (GBRForest*) file.Get("EBCorrection");
32		forestCorrection_ee = (GBRForest*) file.Get("EECorrection");
33		forestUncertainty_eb = (GBRForest*) file.Get("EBUncertainty");
#	Line 372 | Line 372 | double ElectronEnergyRegression::regress
372		return regressionResult;
373		}
374
375	<	double ElectronEnergyRegression::regressionValueWithTrkVarV1(
376	<	double SCRawEnergy,
377	<	double scEta,
378	<	double scPhi,
379	<	double R9,
380	<	double etawidth,
381	<	double phiwidth,
382	<	double NClusters,
383	<	double HoE,
384	<	double rho,
385	<	double vertices,
386	<	double EtaSeed,
387	<	double PhiSeed,
388	<	double ESeed,
389	<	double E3x3Seed,
390	<	double E5x5Seed,
391	<	double see,
392	<	double spp,
393	<	double sep,
394	<	double EMaxSeed,
395	<	double E2ndSeed,
396	<	double ETopSeed,
397	<	double EBottomSeed,
398	<	double ELeftSeed,
399	<	double ERightSeed,
400	<	double E2x5MaxSeed,
401	<	double E2x5TopSeed,
402	<	double E2x5BottomSeed,
403	<	double E2x5LeftSeed,
404	<	double E2x5RightSeed,
405	<	double IEtaSeed,
406	<	double IPhiSeed,
407	<	double EtaCrySeed,
408	<	double PhiCrySeed,
409	<	double PreShowerOverRaw,
410	<	double GsfTrackPIn,
411	<	double fbrem,
412	<	double Charge,
413	<	double EoP,
414	<	double TrackMomentumError,
415	<	bool printDebug)
375	>	double ElectronEnergyRegression::regressionValueWithTrkVarV1( std::vector<double> &inputvars,
376	>	bool printDebug)
377		{
378		// Checking if instance has been initialized
379		if (fIsInitialized == kFALSE) {
#	Line 421 | Line 382 | double ElectronEnergyRegression::regress
382		}
383
384		// Checking if fVersionType is correct
385	<	assert(fVersionType == kWithTrkVar);
385	>	assert(fVersionType == kWithTrkVarV1);
386	>
387	>	//Check that inputvars vector has the right number of inputs
388	>	assert(inputvars.size() == 42);
389
390	<	float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
390	>	//assign variables from inputvars array to named variables
391	>	double SCRawEnergy  = inputvars[0];
392	>	double scEta  = inputvars[1];
393	>	double scPhi  = inputvars[2];
394	>	double R9  = inputvars[3];
395	>	double etawidth  = inputvars[4];
396	>	double phiwidth  = inputvars[5];
397	>	double NClusters  = inputvars[6];
398	>	double HoE  = inputvars[7];
399	>	double rho  = inputvars[8];
400	>	double vertices  = inputvars[9];
401	>	double EtaSeed  = inputvars[10];
402	>	double PhiSeed  = inputvars[11];
403	>	double ESeed  = inputvars[12];
404	>	double E3x3Seed  = inputvars[13];
405	>	double E5x5Seed  = inputvars[14];
406	>	double see  = inputvars[15];
407	>	double spp  = inputvars[16];
408	>	double sep  = inputvars[17];
409	>	double EMaxSeed  = inputvars[18];
410	>	double E2ndSeed  = inputvars[19];
411	>	double ETopSeed  = inputvars[20];
412	>	double EBottomSeed  = inputvars[21];
413	>	double ELeftSeed  = inputvars[22];
414	>	double ERightSeed  = inputvars[23];
415	>	double E2x5MaxSeed  = inputvars[24];
416	>	double E2x5TopSeed  = inputvars[25];
417	>	double E2x5BottomSeed  = inputvars[26];
418	>	double E2x5LeftSeed  = inputvars[27];
419	>	double E2x5RightSeed  = inputvars[28];
420	>	double IEtaSeed  = inputvars[29];
421	>	double IPhiSeed  = inputvars[30];
422	>	double EtaCrySeed  = inputvars[31];
423	>	double PhiCrySeed  = inputvars[32];
424	>	double PreShowerOverRaw  = inputvars[33];
425	>	int    IsEcalDriven  = inputvars[34];
426	>	double GsfTrackPIn  = inputvars[35];
427	>	double fbrem  = inputvars[36];
428	>	double Charge  = inputvars[37];
429	>	double EoP  = inputvars[38];
430	>	double TrackMomentumError  = inputvars[39];
431	>	double EcalEnergyError  = inputvars[40];
432	>	int    Classification  = inputvars[41];
433	>
434	>	float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
435		if (fabs(scEta) <= 1.479) {           // Barrel
436		vals[0]  = SCRawEnergy;
437		vals[1]  = scEta;
#	Line 455 | Line 463 | double ElectronEnergyRegression::regress
463		vals[27] = E2x5BottomSeed/ESeed;
464		vals[28] = E2x5LeftSeed/ESeed;
465		vals[29] = E2x5RightSeed/ESeed;
466	<	vals[30] = GsfTrackPIn;
467	<	vals[31] = fbrem;
468	<	vals[32] = Charge;
469	<	vals[33] = EoP;
470	<	vals[34] = TrackMomentumError/GsfTrackPIn;
471	<	vals[35] = IEtaSeed;
472	<	vals[36] = IPhiSeed;
473	<	vals[37] = ((int) IEtaSeed)%5;
474	<	vals[38] = ((int) IPhiSeed)%2;
475	<	vals[39] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
476	<	vals[40] = ((int) IPhiSeed)%20;
477	<	vals[41] = EtaCrySeed;
478	<	vals[42] = PhiCrySeed;
466	>	vals[30] = IsEcalDriven;
467	>	vals[31] = GsfTrackPIn;
468	>	vals[32] = fbrem;
469	>	vals[33] = Charge;
470	>	vals[34] = EoP;
471	>	vals[35] = TrackMomentumError/GsfTrackPIn;
472	>	vals[36] = EcalEnergyError/SCRawEnergy;
473	>	vals[37] = Classification;
474	>	vals[38] = IEtaSeed;
475	>	vals[39] = IPhiSeed;
476	>	vals[40] = ((int) IEtaSeed)%5;
477	>	vals[41] = ((int) IPhiSeed)%2;
478	>	vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
479	>	vals[43] = ((int) IPhiSeed)%20;
480	>	vals[44] = EtaCrySeed;
481	>	vals[45] = PhiCrySeed;
482		}
483
484		else {        // Endcap
#	Line 501 | Line 512 | double ElectronEnergyRegression::regress
512		vals[27] = E2x5BottomSeed/ESeed;
513		vals[28] = E2x5LeftSeed/ESeed;
514		vals[29] = E2x5RightSeed/ESeed;
515	<	vals[30] = GsfTrackPIn;
516	<	vals[31] = fbrem;
517	<	vals[32] = Charge;
518	<	vals[33] = EoP;
519	<	vals[34] = TrackMomentumError/GsfTrackPIn;
520	<	vals[35] = PreShowerOverRaw;
515	>	vals[30] = IsEcalDriven;
516	>	vals[31] = GsfTrackPIn;
517	>	vals[32] = fbrem;
518	>	vals[33] = Charge;
519	>	vals[34] = EoP;
520	>	vals[35] = TrackMomentumError/GsfTrackPIn;
521	>	vals[36] = EcalEnergyError/SCRawEnergy;
522	>	vals[37] = Classification;
523	>	vals[38] = PreShowerOverRaw;
524		}
525
526		// Now evaluating the regression
527		double regressionResult = 0;
528
529	<	if (fVersionType == kWithTrkVar) {
529	>	if (fVersionType == kWithTrkVarV1) {
530		if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
531		else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
532		}
#	Line 520 | Line 534 | double ElectronEnergyRegression::regress
534
535		//print debug
536		if (printDebug) {
537	<	if (scEta <= 1.479) {
537	>	if (fabs(scEta) <= 1.479) {
538		std::cout << "Barrel :";
539	<	for (uint v=0; v < 43; ++v) std::cout << vals[v] << ", ";
539	>	for (uint v=0; v < 46; ++v) std::cout << vals[v] << ", ";
540		std::cout << "\n";
541		}
542		else {
543		std::cout << "Endcap :";
544	<	for (uint v=0; v < 36; ++v) std::cout << vals[v] << ", ";
544	>	for (uint v=0; v < 39; ++v) std::cout << vals[v] << ", ";
545		std::cout << "\n";
546		}
547		std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
#	Line 542 | Line 556 | double ElectronEnergyRegression::regress
556
557
558
559	<	double ElectronEnergyRegression::regressionUncertaintyWithTrkVarV1(
560	<	double SCRawEnergy,
561	<	double scEta,
548	<	double scPhi,
549	<	double R9,
550	<	double etawidth,
551	<	double phiwidth,
552	<	double NClusters,
553	<	double HoE,
554	<	double rho,
555	<	double vertices,
556	<	double EtaSeed,
557	<	double PhiSeed,
558	<	double ESeed,
559	<	double E3x3Seed,
560	<	double E5x5Seed,
561	<	double see,
562	<	double spp,
563	<	double sep,
564	<	double EMaxSeed,
565	<	double E2ndSeed,
566	<	double ETopSeed,
567	<	double EBottomSeed,
568	<	double ELeftSeed,
569	<	double ERightSeed,
570	<	double E2x5MaxSeed,
571	<	double E2x5TopSeed,
572	<	double E2x5BottomSeed,
573	<	double E2x5LeftSeed,
574	<	double E2x5RightSeed,
575	<	double IEtaSeed,
576	<	double IPhiSeed,
577	<	double EtaCrySeed,
578	<	double PhiCrySeed,
579	<	double PreShowerOverRaw,
580	<	double GsfTrackPIn,
581	<	double fbrem,
582	<	double Charge,
583	<	double EoP,
584	<	double TrackMomentumError,
585	<	bool printDebug)
559	>
560	>	double ElectronEnergyRegression::regressionUncertaintyWithTrkVarV1( std::vector<double> &inputvars,
561	>	bool printDebug)
562		{
563		// Checking if instance has been initialized
564		if (fIsInitialized == kFALSE) {
#	Line 591 | Line 567 | double ElectronEnergyRegression::regress
567		}
568
569		// Checking if fVersionType is correct
570	<	assert(fVersionType == kWithTrkVar);
570	>	assert(fVersionType == kWithTrkVarV1);
571	>
572	>	// Checking if fVersionType is correct
573	>	assert(inputvars.size() == 42);
574
575	<	float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
575	>	double SCRawEnergy  = inputvars[0];
576	>	double scEta  = inputvars[1];
577	>	double scPhi  = inputvars[2];
578	>	double R9  = inputvars[3];
579	>	double etawidth  = inputvars[4];
580	>	double phiwidth  = inputvars[5];
581	>	double NClusters  = inputvars[6];
582	>	double HoE  = inputvars[7];
583	>	double rho  = inputvars[8];
584	>	double vertices  = inputvars[9];
585	>	double EtaSeed  = inputvars[10];
586	>	double PhiSeed  = inputvars[11];
587	>	double ESeed  = inputvars[12];
588	>	double E3x3Seed  = inputvars[13];
589	>	double E5x5Seed  = inputvars[14];
590	>	double see  = inputvars[15];
591	>	double spp  = inputvars[16];
592	>	double sep  = inputvars[17];
593	>	double EMaxSeed  = inputvars[18];
594	>	double E2ndSeed  = inputvars[19];
595	>	double ETopSeed  = inputvars[20];
596	>	double EBottomSeed  = inputvars[21];
597	>	double ELeftSeed  = inputvars[22];
598	>	double ERightSeed  = inputvars[23];
599	>	double E2x5MaxSeed  = inputvars[24];
600	>	double E2x5TopSeed  = inputvars[25];
601	>	double E2x5BottomSeed  = inputvars[26];
602	>	double E2x5LeftSeed  = inputvars[27];
603	>	double E2x5RightSeed  = inputvars[28];
604	>	double IEtaSeed  = inputvars[29];
605	>	double IPhiSeed  = inputvars[30];
606	>	double EtaCrySeed  = inputvars[31];
607	>	double PhiCrySeed  = inputvars[32];
608	>	double PreShowerOverRaw  = inputvars[33];
609	>	int    IsEcalDriven  = inputvars[34];
610	>	double GsfTrackPIn  = inputvars[35];
611	>	double fbrem  = inputvars[36];
612	>	double Charge  = inputvars[37];
613	>	double EoP  = inputvars[38];
614	>	double TrackMomentumError  = inputvars[39];
615	>	double EcalEnergyError  = inputvars[40];
616	>	int    Classification  = inputvars[41];
617	>
618	>
619	>	float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
620		if (fabs(scEta) <= 1.479) {           // Barrel
621		vals[0]  = SCRawEnergy;
622		vals[1]  = scEta;
#	Line 625 | Line 648 | double ElectronEnergyRegression::regress
648		vals[27] = E2x5BottomSeed/ESeed;
649		vals[28] = E2x5LeftSeed/ESeed;
650		vals[29] = E2x5RightSeed/ESeed;
651	<	vals[30] = GsfTrackPIn;
652	<	vals[31] = fbrem;
653	<	vals[32] = Charge;
654	<	vals[33] = EoP;
655	<	vals[34] = TrackMomentumError/GsfTrackPIn;
656	<	vals[35] = IEtaSeed;
657	<	vals[36] = IPhiSeed;
658	<	vals[37] = ((int) IEtaSeed)%5;
659	<	vals[38] = ((int) IPhiSeed)%2;
660	<	vals[39] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
661	<	vals[40] = ((int) IPhiSeed)%20;
662	<	vals[41] = EtaCrySeed;
663	<	vals[42] = PhiCrySeed;
651	>	vals[30] = IsEcalDriven;
652	>	vals[31] = GsfTrackPIn;
653	>	vals[32] = fbrem;
654	>	vals[33] = Charge;
655	>	vals[34] = EoP;
656	>	vals[35] = TrackMomentumError/GsfTrackPIn;
657	>	vals[36] = EcalEnergyError/SCRawEnergy;
658	>	vals[37] = Classification;
659	>	vals[38] = IEtaSeed;
660	>	vals[39] = IPhiSeed;
661	>	vals[40] = ((int) IEtaSeed)%5;
662	>	vals[41] = ((int) IPhiSeed)%2;
663	>	vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
664	>	vals[43] = ((int) IPhiSeed)%20;
665	>	vals[44] = EtaCrySeed;
666	>	vals[45] = PhiCrySeed;
667		}
668
669		else {        // Endcap
#	Line 671 | Line 697 | double ElectronEnergyRegression::regress
697		vals[27] = E2x5BottomSeed/ESeed;
698		vals[28] = E2x5LeftSeed/ESeed;
699		vals[29] = E2x5RightSeed/ESeed;
700	<	vals[30] = GsfTrackPIn;
701	<	vals[31] = fbrem;
702	<	vals[32] = Charge;
703	<	vals[33] = EoP;
704	<	vals[34] = TrackMomentumError/GsfTrackPIn;
705	<	vals[35] = PreShowerOverRaw;
700	>	vals[30] = IsEcalDriven;
701	>	vals[31] = GsfTrackPIn;
702	>	vals[32] = fbrem;
703	>	vals[33] = Charge;
704	>	vals[34] = EoP;
705	>	vals[35] = TrackMomentumError/GsfTrackPIn;
706	>	vals[36] = EcalEnergyError/SCRawEnergy;
707	>	vals[37] = Classification;
708	>	vals[38] = PreShowerOverRaw;
709		}
710
711		// Now evaluating the regression
712		double regressionResult = 0;
713
714	<	if (fVersionType == kWithTrkVar) {
714	>	if (fVersionType == kWithTrkVarV1) {
715		if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
716		else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
717		}
718
719		//print debug
720		if (printDebug) {
721	<	if (scEta <= 1.479) {
721	>	if (fabs(scEta) <= 1.479) {
722		std::cout << "Barrel :";
723	<	for (uint v=0; v < 43; ++v) std::cout << vals[v] << ", ";
723	>	for (uint v=0; v < 46; ++v) std::cout << vals[v] << ", ";
724		std::cout << "\n";
725		}
726		else {
727		std::cout << "Endcap :";
728	<	for (uint v=0; v < 36; ++v) std::cout << vals[v] << ", ";
728	>	for (uint v=0; v < 39; ++v) std::cout << vals[v] << ", ";
729		std::cout << "\n";
730		}
731		std::cout << " SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
#	Line 712 | Line 741 | double ElectronEnergyRegression::regress
741
742
743
744	+
745	+
746		double ElectronEnergyRegression::regressionValueWithTrkVarV2( std::vector<double> &inputvars,
747		bool printDebug)
748		{
#	Line 721 | Line 752 | double ElectronEnergyRegression::regress
752		return 0;
753		}
754
724	–	//Check that inputvars vector has the right number of inputs
725	–	assert(inputvars.size() == 46);
726	–
755		// Checking if fVersionType is correct
756	<	assert(fVersionType == kWithTrkVar);
756	>	assert(fVersionType == kWithTrkVarV2);
757
758	<	//assign variables from inputvars array to named variables
759	<	double SCRawEnergy = inputvars[0];
732	<	double scEta = inputvars[1];
733	<	double scPhi = inputvars[2];
734	<	double R9 = inputvars[3];
735	<	double etawidth = inputvars[4];
736	<	double phiwidth = inputvars[5];
737	<	double NClusters = inputvars[6];
738	<	double HoE = inputvars[7];
739	<	double rho = inputvars[8];
740	<	double vertices = inputvars[9];
741	<	double EtaSeed = inputvars[10];
742	<	double PhiSeed = inputvars[11];
743	<	double ESeed = inputvars[12];
744	<	double E3x3Seed = inputvars[13];
745	<	double E5x5Seed = inputvars[14];
746	<	double see = inputvars[15];
747	<	double spp = inputvars[16];
748	<	double sep = inputvars[17];
749	<	double EMaxSeed = inputvars[18];
750	<	double E2ndSeed = inputvars[19];
751	<	double ETopSeed = inputvars[20];
752	<	double EBottomSeed = inputvars[21];
753	<	double ELeftSeed = inputvars[22];
754	<	double ERightSeed = inputvars[23];
755	<	double E2x5MaxSeed = inputvars[24];
756	<	double E2x5TopSeed = inputvars[25];
757	<	double E2x5BottomSeed = inputvars[26];
758	<	double E2x5LeftSeed = inputvars[27];
759	<	double E2x5RightSeed = inputvars[28];
760	<	double IEtaSeed = inputvars[29];
761	<	double IPhiSeed = inputvars[30];
762	<	double EtaCrySeed = inputvars[31];
763	<	double PhiCrySeed = inputvars[32];
764	<	double PreShowerOverRaw = inputvars[33];
765	<	double GsfTrackPIn = inputvars[34];
766	<	double fbrem = inputvars[35];
767	<	double Charge = inputvars[36];
768	<	double EoP = inputvars[37];
769	<	double TrackMomentumError = inputvars[38];
770	<	double detaIn = inputvars[39];
771	<	double dphiIn = inputvars[40];
772	<	double detaCalo = inputvars[41];
773	<	double dphiCalo = inputvars[42];
774	<	double GsfTrackChiSqr = inputvars[43];
775	<	double KFTrackNLayers = inputvars[44];
776	<	double ElectronEnergyOverPout = inputvars[45];
758	>	// Checking if fVersionType is correct
759	>	assert(inputvars.size() == 49);
760
761	+	double SCRawEnergy  = inputvars[0];
762	+	double scEta  = inputvars[1];
763	+	double scPhi  = inputvars[2];
764	+	double R9  = inputvars[3];
765	+	double etawidth  = inputvars[4];
766	+	double phiwidth  = inputvars[5];
767	+	double NClusters  = inputvars[6];
768	+	double HoE  = inputvars[7];
769	+	double rho  = inputvars[8];
770	+	double vertices  = inputvars[9];
771	+	double EtaSeed  = inputvars[10];
772	+	double PhiSeed  = inputvars[11];
773	+	double ESeed  = inputvars[12];
774	+	double E3x3Seed  = inputvars[13];
775	+	double E5x5Seed  = inputvars[14];
776	+	double see  = inputvars[15];
777	+	double spp  = inputvars[16];
778	+	double sep  = inputvars[17];
779	+	double EMaxSeed  = inputvars[18];
780	+	double E2ndSeed  = inputvars[19];
781	+	double ETopSeed  = inputvars[20];
782	+	double EBottomSeed  = inputvars[21];
783	+	double ELeftSeed  = inputvars[22];
784	+	double ERightSeed  = inputvars[23];
785	+	double E2x5MaxSeed  = inputvars[24];
786	+	double E2x5TopSeed  = inputvars[25];
787	+	double E2x5BottomSeed  = inputvars[26];
788	+	double E2x5LeftSeed  = inputvars[27];
789	+	double E2x5RightSeed  = inputvars[28];
790	+	double IEtaSeed  = inputvars[29];
791	+	double IPhiSeed  = inputvars[30];
792	+	double EtaCrySeed  = inputvars[31];
793	+	double PhiCrySeed  = inputvars[32];
794	+	double PreShowerOverRaw  = inputvars[33];
795	+	int    IsEcalDriven  = inputvars[34];
796	+	double GsfTrackPIn  = inputvars[35];
797	+	double fbrem  = inputvars[36];
798	+	double Charge  = inputvars[37];
799	+	double EoP  = inputvars[38];
800	+	double TrackMomentumError  = inputvars[39];
801	+	double EcalEnergyError  = inputvars[40];
802	+	int    Classification  = inputvars[41];
803	+	double detaIn  = inputvars[42];
804	+	double dphiIn  = inputvars[43];
805	+	double detaCalo  = inputvars[44];
806	+	double dphiCalo  = inputvars[45];
807	+	double GsfTrackChiSqr  = inputvars[46];
808	+	double KFTrackNLayers  = inputvars[47];
809	+	double ElectronEnergyOverPout  = inputvars[48];
810
811	<	float *vals = (fabs(scEta) <= 1.479) ? new float[50] : new float[43];
811	>	float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
812		if (fabs(scEta) <= 1.479) {           // Barrel
813		vals[0]  = SCRawEnergy;
814		vals[1]  = scEta;
#	Line 808 | Line 840 | double ElectronEnergyRegression::regress
840		vals[27] = E2x5BottomSeed/ESeed;
841		vals[28] = E2x5LeftSeed/ESeed;
842		vals[29] = E2x5RightSeed/ESeed;
843	<	vals[30] = GsfTrackPIn;
844	<	vals[31] = fbrem;
845	<	vals[32] = Charge;
846	<	vals[33] = EoP;
847	<	vals[34] = TrackMomentumError/GsfTrackPIn;
848	<	vals[35] = detaIn;
849	<	vals[36] = dphiIn;
850	<	vals[37] = detaCalo;
851	<	vals[38] = dphiCalo;
852	<	vals[39] = GsfTrackChiSqr;
853	<	vals[40] = KFTrackNLayers;
854	<	vals[41] = ElectronEnergyOverPout;
855	<	vals[42] = IEtaSeed;
856	<	vals[43] = IPhiSeed;
857	<	vals[44] = ((int) IEtaSeed)%5;
858	<	vals[45] = ((int) IPhiSeed)%2;
859	<	vals[46] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
860	<	vals[47] = ((int) IPhiSeed)%20;
861	<	vals[48] = EtaCrySeed;
862	<	vals[49] = PhiCrySeed;
843	>	vals[30] = IsEcalDriven;
844	>	vals[31] = GsfTrackPIn;
845	>	vals[32] = fbrem;
846	>	vals[33] = Charge;
847	>	vals[34] = EoP;
848	>	vals[35] = TrackMomentumError/GsfTrackPIn;
849	>	vals[36] = EcalEnergyError/SCRawEnergy;
850	>	vals[37] = Classification;
851	>	vals[38] = detaIn;
852	>	vals[39] = dphiIn;
853	>	vals[40] = detaCalo;
854	>	vals[41] = dphiCalo;
855	>	vals[42] = GsfTrackChiSqr;
856	>	vals[43] = KFTrackNLayers;
857	>	vals[44] = ElectronEnergyOverPout;
858	>	vals[45] = IEtaSeed;
859	>	vals[46] = IPhiSeed;
860	>	vals[47] = ((int) IEtaSeed)%5;
861	>	vals[48] = ((int) IPhiSeed)%2;
862	>	vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
863	>	vals[50] = ((int) IPhiSeed)%20;
864	>	vals[51] = EtaCrySeed;
865	>	vals[52] = PhiCrySeed;
866		}
867
868		else {        // Endcap
#	Line 861 | Line 896 | double ElectronEnergyRegression::regress
896		vals[27] = E2x5BottomSeed/ESeed;
897		vals[28] = E2x5LeftSeed/ESeed;
898		vals[29] = E2x5RightSeed/ESeed;
899	<	vals[30] = GsfTrackPIn;
900	<	vals[31] = fbrem;
901	<	vals[32] = Charge;
902	<	vals[33] = EoP;
903	<	vals[34] = TrackMomentumError/GsfTrackPIn;
904	<	vals[35] = detaIn;
905	<	vals[36] = dphiIn;
906	<	vals[37] = detaCalo;
907	<	vals[38] = dphiCalo;
908	<	vals[39] = GsfTrackChiSqr;
909	<	vals[40] = KFTrackNLayers;
910	<	vals[41] = ElectronEnergyOverPout;
911	<	vals[42] = PreShowerOverRaw;
899	>	vals[30] = IsEcalDriven;
900	>	vals[31] = GsfTrackPIn;
901	>	vals[32] = fbrem;
902	>	vals[33] = Charge;
903	>	vals[34] = EoP;
904	>	vals[35] = TrackMomentumError/GsfTrackPIn;
905	>	vals[36] = EcalEnergyError/SCRawEnergy;
906	>	vals[37] = Classification;
907	>	vals[38] = detaIn;
908	>	vals[39] = dphiIn;
909	>	vals[40] = detaCalo;
910	>	vals[41] = dphiCalo;
911	>	vals[42] = GsfTrackChiSqr;
912	>	vals[43] = KFTrackNLayers;
913	>	vals[44] = ElectronEnergyOverPout;
914	>	vals[45] = PreShowerOverRaw;
915		}
916
917		// Now evaluating the regression
918		double regressionResult = 0;
919
920	<	if (fVersionType == kWithTrkVar) {
920	>	if (fVersionType == kWithTrkVarV2) {
921		if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
922		else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
923		}
#	Line 887 | Line 925 | double ElectronEnergyRegression::regress
925
926		//print debug
927		if (printDebug) {
928	<	if (scEta <= 1.479) {
928	>	if (fabs(scEta) <= 1.479) {
929		std::cout << "Barrel :";
930	<	for (uint v=0; v < 50; ++v) std::cout << vals[v] << ", ";
930	>	for (uint v=0; v < 53; ++v) std::cout << vals[v] << ", ";
931		std::cout << "\n";
932		}
933		else {
934		std::cout << "Endcap :";
935	<	for (uint v=0; v < 43; ++v) std::cout << vals[v] << ", ";
935	>	for (uint v=0; v < 46; ++v) std::cout << vals[v] << ", ";
936		std::cout << "\n";
937		}
938		std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
#	Line 909 | Line 947 | double ElectronEnergyRegression::regress
947
948
949
950	+
951	+
952		double ElectronEnergyRegression::regressionUncertaintyWithTrkVarV2( std::vector<double> &inputvars,
953		bool printDebug)
954		{
#	Line 918 | Line 958 | double ElectronEnergyRegression::regress
958		return 0;
959		}
960
961	<	//Check that inputvars vector has the right number of inputs
962	<	assert(inputvars.size() == 46);
961	>	// Checking if fVersionType is correct
962	>	assert(fVersionType == kWithTrkVarV2);
963
964		// Checking if fVersionType is correct
965	<	assert(fVersionType == kWithTrkVar);
965	>	assert(inputvars.size() == 49);
966
967	<	//assign variables from inputvars array to named variables
968	<	double SCRawEnergy = inputvars[0];
969	<	double scEta = inputvars[1];
970	<	double scPhi = inputvars[2];
971	<	double R9 = inputvars[3];
972	<	double etawidth = inputvars[4];
973	<	double phiwidth = inputvars[5];
974	<	double NClusters = inputvars[6];
975	<	double HoE = inputvars[7];
976	<	double rho = inputvars[8];
977	<	double vertices = inputvars[9];
978	<	double EtaSeed = inputvars[10];
979	<	double PhiSeed = inputvars[11];
980	<	double ESeed = inputvars[12];
981	<	double E3x3Seed = inputvars[13];
982	<	double E5x5Seed = inputvars[14];
983	<	double see = inputvars[15];
984	<	double spp = inputvars[16];
985	<	double sep = inputvars[17];
986	<	double EMaxSeed = inputvars[18];
987	<	double E2ndSeed = inputvars[19];
988	<	double ETopSeed = inputvars[20];
989	<	double EBottomSeed = inputvars[21];
990	<	double ELeftSeed = inputvars[22];
991	<	double ERightSeed = inputvars[23];
992	<	double E2x5MaxSeed = inputvars[24];
993	<	double E2x5TopSeed = inputvars[25];
994	<	double E2x5BottomSeed = inputvars[26];
995	<	double E2x5LeftSeed = inputvars[27];
996	<	double E2x5RightSeed = inputvars[28];
997	<	double IEtaSeed = inputvars[29];
998	<	double IPhiSeed = inputvars[30];
999	<	double EtaCrySeed = inputvars[31];
1000	<	double PhiCrySeed = inputvars[32];
1001	<	double PreShowerOverRaw = inputvars[33];
1002	<	double GsfTrackPIn = inputvars[34];
1003	<	double fbrem = inputvars[35];
1004	<	double Charge = inputvars[36];
1005	<	double EoP = inputvars[37];
1006	<	double TrackMomentumError = inputvars[38];
1007	<	double detaIn = inputvars[39];
1008	<	double dphiIn = inputvars[40];
1009	<	double detaCalo = inputvars[41];
1010	<	double dphiCalo = inputvars[42];
1011	<	double GsfTrackChiSqr = inputvars[43];
1012	<	double KFTrackNLayers = inputvars[44];
1013	<	double ElectronEnergyOverPout = inputvars[45];
967	>	double SCRawEnergy  = inputvars[0];
968	>	double scEta  = inputvars[1];
969	>	double scPhi  = inputvars[2];
970	>	double R9  = inputvars[3];
971	>	double etawidth  = inputvars[4];
972	>	double phiwidth  = inputvars[5];
973	>	double NClusters  = inputvars[6];
974	>	double HoE  = inputvars[7];
975	>	double rho  = inputvars[8];
976	>	double vertices  = inputvars[9];
977	>	double EtaSeed  = inputvars[10];
978	>	double PhiSeed  = inputvars[11];
979	>	double ESeed  = inputvars[12];
980	>	double E3x3Seed  = inputvars[13];
981	>	double E5x5Seed  = inputvars[14];
982	>	double see  = inputvars[15];
983	>	double spp  = inputvars[16];
984	>	double sep  = inputvars[17];
985	>	double EMaxSeed  = inputvars[18];
986	>	double E2ndSeed  = inputvars[19];
987	>	double ETopSeed  = inputvars[20];
988	>	double EBottomSeed  = inputvars[21];
989	>	double ELeftSeed  = inputvars[22];
990	>	double ERightSeed  = inputvars[23];
991	>	double E2x5MaxSeed  = inputvars[24];
992	>	double E2x5TopSeed  = inputvars[25];
993	>	double E2x5BottomSeed  = inputvars[26];
994	>	double E2x5LeftSeed  = inputvars[27];
995	>	double E2x5RightSeed  = inputvars[28];
996	>	double IEtaSeed  = inputvars[29];
997	>	double IPhiSeed  = inputvars[30];
998	>	double EtaCrySeed  = inputvars[31];
999	>	double PhiCrySeed  = inputvars[32];
1000	>	double PreShowerOverRaw  = inputvars[33];
1001	>	int    IsEcalDriven  = inputvars[34];
1002	>	double GsfTrackPIn  = inputvars[35];
1003	>	double fbrem  = inputvars[36];
1004	>	double Charge  = inputvars[37];
1005	>	double EoP  = inputvars[38];
1006	>	double TrackMomentumError  = inputvars[39];
1007	>	double EcalEnergyError  = inputvars[40];
1008	>	int    Classification  = inputvars[41];
1009	>	double detaIn  = inputvars[42];
1010	>	double dphiIn  = inputvars[43];
1011	>	double detaCalo  = inputvars[44];
1012	>	double dphiCalo  = inputvars[45];
1013	>	double GsfTrackChiSqr  = inputvars[46];
1014	>	double KFTrackNLayers  = inputvars[47];
1015	>	double ElectronEnergyOverPout  = inputvars[48];
1016
1017	<	float *vals = (fabs(scEta) <= 1.479) ? new float[50] : new float[43];
1017	>	float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
1018		if (fabs(scEta) <= 1.479) {           // Barrel
1019		vals[0]  = SCRawEnergy;
1020		vals[1]  = scEta;
#	Line 1004 | Line 1046 | double ElectronEnergyRegression::regress
1046		vals[27] = E2x5BottomSeed/ESeed;
1047		vals[28] = E2x5LeftSeed/ESeed;
1048		vals[29] = E2x5RightSeed/ESeed;
1049	<	vals[30] = GsfTrackPIn;
1050	<	vals[31] = fbrem;
1051	<	vals[32] = Charge;
1052	<	vals[33] = EoP;
1053	<	vals[34] = TrackMomentumError/GsfTrackPIn;
1054	<	vals[35] = detaIn;
1055	<	vals[36] = dphiIn;
1056	<	vals[37] = detaCalo;
1057	<	vals[38] = dphiCalo;
1058	<	vals[39] = GsfTrackChiSqr;
1059	<	vals[40] = KFTrackNLayers;
1060	<	vals[41] = ElectronEnergyOverPout;
1061	<	vals[42] = IEtaSeed;
1062	<	vals[43] = IPhiSeed;
1063	<	vals[44] = ((int) IEtaSeed)%5;
1064	<	vals[45] = ((int) IPhiSeed)%2;
1065	<	vals[46] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
1066	<	vals[47] = ((int) IPhiSeed)%20;
1067	<	vals[48] = EtaCrySeed;
1068	<	vals[49] = PhiCrySeed;
1049	>	vals[30] = IsEcalDriven;
1050	>	vals[31] = GsfTrackPIn;
1051	>	vals[32] = fbrem;
1052	>	vals[33] = Charge;
1053	>	vals[34] = EoP;
1054	>	vals[35] = TrackMomentumError/GsfTrackPIn;
1055	>	vals[36] = EcalEnergyError/SCRawEnergy;
1056	>	vals[37] = Classification;
1057	>	vals[38] = detaIn;
1058	>	vals[39] = dphiIn;
1059	>	vals[40] = detaCalo;
1060	>	vals[41] = dphiCalo;
1061	>	vals[42] = GsfTrackChiSqr;
1062	>	vals[43] = KFTrackNLayers;
1063	>	vals[44] = ElectronEnergyOverPout;
1064	>	vals[45] = IEtaSeed;
1065	>	vals[46] = IPhiSeed;
1066	>	vals[47] = ((int) IEtaSeed)%5;
1067	>	vals[48] = ((int) IPhiSeed)%2;
1068	>	vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
1069	>	vals[50] = ((int) IPhiSeed)%20;
1070	>	vals[51] = EtaCrySeed;
1071	>	vals[52] = PhiCrySeed;
1072		}
1073
1074		else {        // Endcap
#	Line 1057 | Line 1102 | double ElectronEnergyRegression::regress
1102		vals[27] = E2x5BottomSeed/ESeed;
1103		vals[28] = E2x5LeftSeed/ESeed;
1104		vals[29] = E2x5RightSeed/ESeed;
1105	<	vals[30] = GsfTrackPIn;
1106	<	vals[31] = fbrem;
1107	<	vals[32] = Charge;
1108	<	vals[33] = EoP;
1109	<	vals[34] = TrackMomentumError/GsfTrackPIn;
1110	<	vals[35] = detaIn;
1111	<	vals[36] = dphiIn;
1112	<	vals[37] = detaCalo;
1113	<	vals[38] = dphiCalo;
1114	<	vals[39] = GsfTrackChiSqr;
1115	<	vals[40] = KFTrackNLayers;
1116	<	vals[41] = ElectronEnergyOverPout;
1117	<	vals[42] = PreShowerOverRaw;
1105	>	vals[30] = IsEcalDriven;
1106	>	vals[31] = GsfTrackPIn;
1107	>	vals[32] = fbrem;
1108	>	vals[33] = Charge;
1109	>	vals[34] = EoP;
1110	>	vals[35] = TrackMomentumError/GsfTrackPIn;
1111	>	vals[36] = EcalEnergyError/SCRawEnergy;
1112	>	vals[37] = Classification;
1113	>	vals[38] = detaIn;
1114	>	vals[39] = dphiIn;
1115	>	vals[40] = detaCalo;
1116	>	vals[41] = dphiCalo;
1117	>	vals[42] = GsfTrackChiSqr;
1118	>	vals[43] = KFTrackNLayers;
1119	>	vals[44] = ElectronEnergyOverPout;
1120	>	vals[45] = PreShowerOverRaw;
1121		}
1122
1123		// Now evaluating the regression
1124		double regressionResult = 0;
1125
1126	<	if (fVersionType == kWithTrkVar) {
1126	>	if (fVersionType == kWithTrkVarV2) {
1127		if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
1128		else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
1129		}
1130
1131		//print debug
1132		if (printDebug) {
1133	<	if (scEta <= 1.479) {
1133	>	if (fabs(scEta) <= 1.479) {
1134		std::cout << "Barrel :";
1135	<	for (uint v=0; v < 50; ++v) std::cout << vals[v] << ", ";
1135	>	for (uint v=0; v < 53; ++v) std::cout << vals[v] << ", ";
1136		std::cout << "\n";
1137		}
1138		else {
1139		std::cout << "Endcap :";
1140	<	for (uint v=0; v < 43; ++v) std::cout << vals[v] << ", ";
1140	>	for (uint v=0; v < 46; ++v) std::cout << vals[v] << ", ";
1141		std::cout << "\n";
1142		}
1143		std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines