Esempio n. 1
0
void AdjustDensityForBinWidth(TH1D &h) {
    double entries = h.GetEntries();
    int nbins = h.GetNbinsX();
    double low = h.GetBinLowEdge(1);
    double high = h.GetBinLowEdge(nbins+1);
    double width = (high-low)/nbins;
    for(int bin = 1; bin <= nbins; ++bin) {
        double content = h.GetBinContent(bin);
        double error = h.GetBinError(bin);
        double this_width = h.GetBinWidth(bin);
        double scale = width/this_width;
        h.SetBinContent(bin, content*scale);
        h.SetBinError(bin, error*scale);
    }
    h.SetEntries(entries);
}
Esempio n. 2
0
double BiPlot() {
	
	c = new TCanvas("canv","",600,400);
	c->SetLogy();
	/*Pretty plot*/
	gPad->SetLeftMargin(0.125);
	gPad->SetBottomMargin(0.15);
	gPad->SetTopMargin(0.05);
	gPad->SetRightMargin(0.05);
	
   TH1D *sum = new TH1D("sum","",3750,-6.97071,3582.199);
   {
   sum->SetBinContent(7,1);
   sum->SetBinContent(8,99);
   sum->SetBinContent(9,114);
   sum->SetBinContent(10,91);
   sum->SetBinContent(11,91);
   sum->SetBinContent(12,95);
   sum->SetBinContent(13,99);
   sum->SetBinContent(14,164);
   sum->SetBinContent(15,323);
   sum->SetBinContent(16,741);
   sum->SetBinContent(17,1318);
   sum->SetBinContent(18,1915);
   sum->SetBinContent(19,2192);
   sum->SetBinContent(20,2060);
   sum->SetBinContent(21,1475);
   sum->SetBinContent(22,944);
   sum->SetBinContent(23,616);
   sum->SetBinContent(24,381);
   sum->SetBinContent(25,231);
   sum->SetBinContent(26,194);
   sum->SetBinContent(27,164);
   sum->SetBinContent(28,153);
   sum->SetBinContent(29,144);
   sum->SetBinContent(30,132);
   sum->SetBinContent(31,116);
   sum->SetBinContent(32,128);
   sum->SetBinContent(33,110);
   sum->SetBinContent(34,107);
   sum->SetBinContent(35,114);
   sum->SetBinContent(36,105);
   sum->SetBinContent(37,99);
   sum->SetBinContent(38,92);
   sum->SetBinContent(39,94);
   sum->SetBinContent(40,110);
   sum->SetBinContent(41,107);
   sum->SetBinContent(42,94);
   sum->SetBinContent(43,103);
   sum->SetBinContent(44,82);
   sum->SetBinContent(45,99);
   sum->SetBinContent(46,92);
   sum->SetBinContent(47,115);
   sum->SetBinContent(48,111);
   sum->SetBinContent(49,112);
   sum->SetBinContent(50,95);
   sum->SetBinContent(51,116);
   sum->SetBinContent(52,119);
   sum->SetBinContent(53,131);
   sum->SetBinContent(54,120);
   sum->SetBinContent(55,139);
   sum->SetBinContent(56,157);
   sum->SetBinContent(57,154);
   sum->SetBinContent(58,167);
   sum->SetBinContent(59,160);
   sum->SetBinContent(60,155);
   sum->SetBinContent(61,154);
   sum->SetBinContent(62,145);
   sum->SetBinContent(63,135);
   sum->SetBinContent(64,136);
   sum->SetBinContent(65,119);
   sum->SetBinContent(66,127);
   sum->SetBinContent(67,146);
   sum->SetBinContent(68,130);
   sum->SetBinContent(69,147);
   sum->SetBinContent(70,129);
   sum->SetBinContent(71,125);
   sum->SetBinContent(72,121);
   sum->SetBinContent(73,126);
   sum->SetBinContent(74,115);
   sum->SetBinContent(75,122);
   sum->SetBinContent(76,154);
   sum->SetBinContent(77,209);
   sum->SetBinContent(78,205);
   sum->SetBinContent(79,235);
   sum->SetBinContent(80,195);
   sum->SetBinContent(81,127);
   sum->SetBinContent(82,143);
   sum->SetBinContent(83,84);
   sum->SetBinContent(84,95);
   sum->SetBinContent(85,63);
   sum->SetBinContent(86,75);
   sum->SetBinContent(87,75);
   sum->SetBinContent(88,49);
   sum->SetBinContent(89,78);
   sum->SetBinContent(90,64);
   sum->SetBinContent(91,67);
   sum->SetBinContent(92,56);
   sum->SetBinContent(93,43);
   sum->SetBinContent(94,43);
   sum->SetBinContent(95,38);
   sum->SetBinContent(96,37);
   sum->SetBinContent(97,35);
   sum->SetBinContent(98,29);
   sum->SetBinContent(99,23);
   sum->SetBinContent(100,36);
   sum->SetBinContent(101,27);
   sum->SetBinContent(102,24);
   sum->SetBinContent(103,18);
   sum->SetBinContent(104,25);
   sum->SetBinContent(105,30);
   sum->SetBinContent(106,30);
   sum->SetBinContent(107,31);
   sum->SetBinContent(108,32);
   sum->SetBinContent(109,18);
   sum->SetBinContent(110,24);
   sum->SetBinContent(111,27);
   sum->SetBinContent(112,23);
   sum->SetBinContent(113,18);
   sum->SetBinContent(114,30);
   sum->SetBinContent(115,24);
   sum->SetBinContent(116,21);
   sum->SetBinContent(117,27);
   sum->SetBinContent(118,20);
   sum->SetBinContent(119,24);
   sum->SetBinContent(120,26);
   sum->SetBinContent(121,26);
   sum->SetBinContent(122,13);
   sum->SetBinContent(123,21);
   sum->SetBinContent(124,27);
   sum->SetBinContent(125,23);
   sum->SetBinContent(126,25);
   sum->SetBinContent(127,29);
   sum->SetBinContent(128,18);
   sum->SetBinContent(129,23);
   sum->SetBinContent(130,23);
   sum->SetBinContent(131,21);
   sum->SetBinContent(132,21);
   sum->SetBinContent(133,22);
   sum->SetBinContent(134,21);
   sum->SetBinContent(135,18);
   sum->SetBinContent(136,20);
   sum->SetBinContent(137,19);
   sum->SetBinContent(138,20);
   sum->SetBinContent(139,20);
   sum->SetBinContent(140,21);
   sum->SetBinContent(141,24);
   sum->SetBinContent(142,17);
   sum->SetBinContent(143,32);
   sum->SetBinContent(144,26);
   sum->SetBinContent(145,20);
   sum->SetBinContent(146,25);
   sum->SetBinContent(147,16);
   sum->SetBinContent(148,21);
   sum->SetBinContent(149,11);
   sum->SetBinContent(150,24);
   sum->SetBinContent(151,25);
   sum->SetBinContent(152,19);
   sum->SetBinContent(153,18);
   sum->SetBinContent(154,17);
   sum->SetBinContent(155,15);
   sum->SetBinContent(156,24);
   sum->SetBinContent(157,17);
   sum->SetBinContent(158,17);
   sum->SetBinContent(159,20);
   sum->SetBinContent(160,31);
   sum->SetBinContent(161,23);
   sum->SetBinContent(162,22);
   sum->SetBinContent(163,23);
   sum->SetBinContent(164,21);
   sum->SetBinContent(165,15);
   sum->SetBinContent(166,25);
   sum->SetBinContent(167,17);
   sum->SetBinContent(168,16);
   sum->SetBinContent(169,23);
   sum->SetBinContent(170,15);
   sum->SetBinContent(171,17);
   sum->SetBinContent(172,22);
   sum->SetBinContent(173,24);
   sum->SetBinContent(174,15);
   sum->SetBinContent(175,16);
   sum->SetBinContent(176,14);
   sum->SetBinContent(177,13);
   sum->SetBinContent(178,17);
   sum->SetBinContent(179,15);
   sum->SetBinContent(180,24);
   sum->SetBinContent(181,15);
   sum->SetBinContent(182,17);
   sum->SetBinContent(183,15);
   sum->SetBinContent(184,20);
   sum->SetBinContent(185,22);
   sum->SetBinContent(186,14);
   sum->SetBinContent(187,20);
   sum->SetBinContent(188,21);
   sum->SetBinContent(189,23);
   sum->SetBinContent(190,18);
   sum->SetBinContent(191,12);
   sum->SetBinContent(192,25);
   sum->SetBinContent(193,16);
   sum->SetBinContent(194,19);
   sum->SetBinContent(195,17);
   sum->SetBinContent(196,21);
   sum->SetBinContent(197,15);
   sum->SetBinContent(198,26);
   sum->SetBinContent(199,19);
   sum->SetBinContent(200,26);
   sum->SetBinContent(201,11);
   sum->SetBinContent(202,10);
   sum->SetBinContent(203,16);
   sum->SetBinContent(204,24);
   sum->SetBinContent(205,20);
   sum->SetBinContent(206,17);
   sum->SetBinContent(207,13);
   sum->SetBinContent(208,14);
   sum->SetBinContent(209,16);
   sum->SetBinContent(210,14);
   sum->SetBinContent(211,17);
   sum->SetBinContent(212,23);
   sum->SetBinContent(213,10);
   sum->SetBinContent(214,13);
   sum->SetBinContent(215,16);
   sum->SetBinContent(216,19);
   sum->SetBinContent(217,15);
   sum->SetBinContent(218,14);
   sum->SetBinContent(219,23);
   sum->SetBinContent(220,22);
   sum->SetBinContent(221,15);
   sum->SetBinContent(222,14);
   sum->SetBinContent(223,17);
   sum->SetBinContent(224,20);
   sum->SetBinContent(225,14);
   sum->SetBinContent(226,12);
   sum->SetBinContent(227,18);
   sum->SetBinContent(228,15);
   sum->SetBinContent(229,20);
   sum->SetBinContent(230,15);
   sum->SetBinContent(231,18);
   sum->SetBinContent(232,19);
   sum->SetBinContent(233,24);
   sum->SetBinContent(234,28);
   sum->SetBinContent(235,17);
   sum->SetBinContent(236,8);
   sum->SetBinContent(237,12);
   sum->SetBinContent(238,19);
   sum->SetBinContent(239,10);
   sum->SetBinContent(240,22);
   sum->SetBinContent(241,19);
   sum->SetBinContent(242,21);
   sum->SetBinContent(243,13);
   sum->SetBinContent(244,9);
   sum->SetBinContent(245,14);
   sum->SetBinContent(246,22);
   sum->SetBinContent(247,16);
   sum->SetBinContent(248,15);
   sum->SetBinContent(249,8);
   sum->SetBinContent(250,23);
   sum->SetBinContent(251,14);
   sum->SetBinContent(252,17);
   sum->SetBinContent(253,19);
   sum->SetBinContent(254,14);
   sum->SetBinContent(255,16);
   sum->SetBinContent(256,18);
   sum->SetBinContent(257,19);
   sum->SetBinContent(258,21);
   sum->SetBinContent(259,10);
   sum->SetBinContent(260,21);
   sum->SetBinContent(261,12);
   sum->SetBinContent(262,13);
   sum->SetBinContent(263,18);
   sum->SetBinContent(264,22);
   sum->SetBinContent(265,8);
   sum->SetBinContent(266,13);
   sum->SetBinContent(267,18);
   sum->SetBinContent(268,14);
   sum->SetBinContent(269,10);
   sum->SetBinContent(270,18);
   sum->SetBinContent(271,13);
   sum->SetBinContent(272,15);
   sum->SetBinContent(273,15);
   sum->SetBinContent(274,12);
   sum->SetBinContent(275,17);
   sum->SetBinContent(276,15);
   sum->SetBinContent(277,12);
   sum->SetBinContent(278,13);
   sum->SetBinContent(279,21);
   sum->SetBinContent(280,17);
   sum->SetBinContent(281,6);
   sum->SetBinContent(282,12);
   sum->SetBinContent(283,16);
   sum->SetBinContent(284,10);
   sum->SetBinContent(285,10);
   sum->SetBinContent(286,16);
   sum->SetBinContent(287,12);
   sum->SetBinContent(288,12);
   sum->SetBinContent(289,16);
   sum->SetBinContent(290,18);
   sum->SetBinContent(291,14);
   sum->SetBinContent(292,13);
   sum->SetBinContent(293,19);
   sum->SetBinContent(294,14);
   sum->SetBinContent(295,14);
   sum->SetBinContent(296,12);
   sum->SetBinContent(297,10);
   sum->SetBinContent(298,22);
   sum->SetBinContent(299,18);
   sum->SetBinContent(300,19);
   sum->SetBinContent(301,15);
   sum->SetBinContent(302,18);
   sum->SetBinContent(303,17);
   sum->SetBinContent(304,15);
   sum->SetBinContent(305,13);
   sum->SetBinContent(306,15);
   sum->SetBinContent(307,17);
   sum->SetBinContent(308,14);
   sum->SetBinContent(309,9);
   sum->SetBinContent(310,18);
   sum->SetBinContent(311,11);
   sum->SetBinContent(312,14);
   sum->SetBinContent(313,12);
   sum->SetBinContent(314,10);
   sum->SetBinContent(315,12);
   sum->SetBinContent(316,15);
   sum->SetBinContent(317,11);
   sum->SetBinContent(318,12);
   sum->SetBinContent(319,17);
   sum->SetBinContent(320,8);
   sum->SetBinContent(321,9);
   sum->SetBinContent(322,14);
   sum->SetBinContent(323,19);
   sum->SetBinContent(324,22);
   sum->SetBinContent(325,12);
   sum->SetBinContent(326,14);
   sum->SetBinContent(327,16);
   sum->SetBinContent(328,12);
   sum->SetBinContent(329,13);
   sum->SetBinContent(330,18);
   sum->SetBinContent(331,13);
   sum->SetBinContent(332,11);
   sum->SetBinContent(333,15);
   sum->SetBinContent(334,13);
   sum->SetBinContent(335,14);
   sum->SetBinContent(336,9);
   sum->SetBinContent(337,22);
   sum->SetBinContent(338,17);
   sum->SetBinContent(339,16);
   sum->SetBinContent(340,10);
   sum->SetBinContent(341,16);
   sum->SetBinContent(342,17);
   sum->SetBinContent(343,8);
   sum->SetBinContent(344,14);
   sum->SetBinContent(345,11);
   sum->SetBinContent(346,14);
   sum->SetBinContent(347,14);
   sum->SetBinContent(348,11);
   sum->SetBinContent(349,12);
   sum->SetBinContent(350,11);
   sum->SetBinContent(351,11);
   sum->SetBinContent(352,17);
   sum->SetBinContent(353,11);
   sum->SetBinContent(354,16);
   sum->SetBinContent(355,14);
   sum->SetBinContent(356,10);
   sum->SetBinContent(357,13);
   sum->SetBinContent(358,23);
   sum->SetBinContent(359,15);
   sum->SetBinContent(360,21);
   sum->SetBinContent(361,19);
   sum->SetBinContent(362,15);
   sum->SetBinContent(363,12);
   sum->SetBinContent(364,13);
   sum->SetBinContent(365,12);
   sum->SetBinContent(366,11);
   sum->SetBinContent(367,12);
   sum->SetBinContent(368,16);
   sum->SetBinContent(369,18);
   sum->SetBinContent(370,22);
   sum->SetBinContent(371,20);
   sum->SetBinContent(372,14);
   sum->SetBinContent(373,12);
   sum->SetBinContent(374,17);
   sum->SetBinContent(375,12);
   sum->SetBinContent(376,12);
   sum->SetBinContent(377,8);
   sum->SetBinContent(378,21);
   sum->SetBinContent(379,14);
   sum->SetBinContent(380,21);
   sum->SetBinContent(381,16);
   sum->SetBinContent(382,15);
   sum->SetBinContent(383,9);
   sum->SetBinContent(384,14);
   sum->SetBinContent(385,19);
   sum->SetBinContent(386,10);
   sum->SetBinContent(387,17);
   sum->SetBinContent(388,16);
   sum->SetBinContent(389,16);
   sum->SetBinContent(390,15);
   sum->SetBinContent(391,18);
   sum->SetBinContent(392,15);
   sum->SetBinContent(393,16);
   sum->SetBinContent(394,18);
   sum->SetBinContent(395,21);
   sum->SetBinContent(396,16);
   sum->SetBinContent(397,16);
   sum->SetBinContent(398,20);
   sum->SetBinContent(399,20);
   sum->SetBinContent(400,11);
   sum->SetBinContent(401,10);
   sum->SetBinContent(402,11);
   sum->SetBinContent(403,15);
   sum->SetBinContent(404,16);
   sum->SetBinContent(405,15);
   sum->SetBinContent(406,10);
   sum->SetBinContent(407,14);
   sum->SetBinContent(408,8);
   sum->SetBinContent(409,20);
   sum->SetBinContent(410,15);
   sum->SetBinContent(411,15);
   sum->SetBinContent(412,13);
   sum->SetBinContent(413,20);
   sum->SetBinContent(414,13);
   sum->SetBinContent(415,18);
   sum->SetBinContent(416,14);
   sum->SetBinContent(417,10);
   sum->SetBinContent(418,12);
   sum->SetBinContent(419,11);
   sum->SetBinContent(420,9);
   sum->SetBinContent(421,13);
   sum->SetBinContent(422,17);
   sum->SetBinContent(423,12);
   sum->SetBinContent(424,8);
   sum->SetBinContent(425,13);
   sum->SetBinContent(426,10);
   sum->SetBinContent(427,10);
   sum->SetBinContent(428,8);
   sum->SetBinContent(429,7);
   sum->SetBinContent(430,5);
   sum->SetBinContent(431,7);
   sum->SetBinContent(432,11);
   sum->SetBinContent(433,9);
   sum->SetBinContent(434,8);
   sum->SetBinContent(435,10);
   sum->SetBinContent(436,7);
   sum->SetBinContent(437,12);
   sum->SetBinContent(438,9);
   sum->SetBinContent(439,6);
   sum->SetBinContent(440,17);
   sum->SetBinContent(441,6);
   sum->SetBinContent(442,10);
   sum->SetBinContent(443,7);
   sum->SetBinContent(444,11);
   sum->SetBinContent(445,7);
   sum->SetBinContent(446,10);
   sum->SetBinContent(447,9);
   sum->SetBinContent(448,5);
   sum->SetBinContent(449,12);
   sum->SetBinContent(450,10);
   sum->SetBinContent(451,8);
   sum->SetBinContent(452,10);
   sum->SetBinContent(453,11);
   sum->SetBinContent(454,12);
   sum->SetBinContent(455,10);
   sum->SetBinContent(456,6);
   sum->SetBinContent(457,9);
   sum->SetBinContent(458,11);
   sum->SetBinContent(459,11);
   sum->SetBinContent(460,9);
   sum->SetBinContent(461,7);
   sum->SetBinContent(462,6);
   sum->SetBinContent(463,6);
   sum->SetBinContent(464,5);
   sum->SetBinContent(465,10);
   sum->SetBinContent(466,6);
   sum->SetBinContent(467,6);
   sum->SetBinContent(468,11);
   sum->SetBinContent(469,8);
   sum->SetBinContent(470,9);
   sum->SetBinContent(471,9);
   sum->SetBinContent(472,7);
   sum->SetBinContent(473,6);
   sum->SetBinContent(474,10);
   sum->SetBinContent(475,15);
   sum->SetBinContent(476,9);
   sum->SetBinContent(477,9);
   sum->SetBinContent(478,10);
   sum->SetBinContent(479,7);
   sum->SetBinContent(480,9);
   sum->SetBinContent(481,8);
   sum->SetBinContent(482,7);
   sum->SetBinContent(483,14);
   sum->SetBinContent(484,12);
   sum->SetBinContent(485,17);
   sum->SetBinContent(486,15);
   sum->SetBinContent(487,8);
   sum->SetBinContent(488,8);
   sum->SetBinContent(489,9);
   sum->SetBinContent(490,8);
   sum->SetBinContent(491,10);
   sum->SetBinContent(492,12);
   sum->SetBinContent(493,15);
   sum->SetBinContent(494,10);
   sum->SetBinContent(495,12);
   sum->SetBinContent(496,17);
   sum->SetBinContent(497,11);
   sum->SetBinContent(498,23);
   sum->SetBinContent(499,19);
   sum->SetBinContent(500,15);
   sum->SetBinContent(501,23);
   sum->SetBinContent(502,29);
   sum->SetBinContent(503,30);
   sum->SetBinContent(504,53);
   sum->SetBinContent(505,61);
   sum->SetBinContent(506,83);
   sum->SetBinContent(507,117);
   sum->SetBinContent(508,112);
   sum->SetBinContent(509,96);
   sum->SetBinContent(510,114);
   sum->SetBinContent(511,90);
   sum->SetBinContent(512,65);
   sum->SetBinContent(513,36);
   sum->SetBinContent(514,17);
   sum->SetBinContent(515,16);
   sum->SetBinContent(516,11);
   sum->SetBinContent(517,4);
   sum->SetBinContent(518,9);
   sum->SetBinContent(519,3);
   sum->SetBinContent(520,10);
   sum->SetBinContent(521,10);
   sum->SetBinContent(522,6);
   sum->SetBinContent(523,5);
   sum->SetBinContent(524,3);
   sum->SetBinContent(525,2);
   sum->SetBinContent(526,11);
   sum->SetBinContent(527,5);
   sum->SetBinContent(528,8);
   sum->SetBinContent(529,9);
   sum->SetBinContent(530,3);
   sum->SetBinContent(531,7);
   sum->SetBinContent(532,8);
   sum->SetBinContent(533,12);
   sum->SetBinContent(534,5);
   sum->SetBinContent(535,11);
   sum->SetBinContent(536,11);
   sum->SetBinContent(537,10);
   sum->SetBinContent(538,10);
   sum->SetBinContent(539,11);
   sum->SetBinContent(540,8);
   sum->SetBinContent(541,12);
   sum->SetBinContent(542,10);
   sum->SetBinContent(543,6);
   sum->SetBinContent(544,11);
   sum->SetBinContent(545,5);
   sum->SetBinContent(546,5);
   sum->SetBinContent(547,4);
   sum->SetBinContent(548,8);
   sum->SetBinContent(549,13);
   sum->SetBinContent(550,12);
   sum->SetBinContent(551,14);
   sum->SetBinContent(552,7);
   sum->SetBinContent(553,11);
   sum->SetBinContent(554,12);
   sum->SetBinContent(555,7);
   sum->SetBinContent(556,15);
   sum->SetBinContent(557,3);
   sum->SetBinContent(558,13);
   sum->SetBinContent(559,6);
   sum->SetBinContent(560,8);
   sum->SetBinContent(561,8);
   sum->SetBinContent(562,5);
   sum->SetBinContent(563,13);
   sum->SetBinContent(564,7);
   sum->SetBinContent(565,16);
   sum->SetBinContent(566,7);
   sum->SetBinContent(567,12);
   sum->SetBinContent(568,6);
   sum->SetBinContent(569,15);
   sum->SetBinContent(570,14);
   sum->SetBinContent(571,5);
   sum->SetBinContent(572,7);
   sum->SetBinContent(573,9);
   sum->SetBinContent(574,10);
   sum->SetBinContent(575,11);
   sum->SetBinContent(576,12);
   sum->SetBinContent(577,10);
   sum->SetBinContent(578,15);
   sum->SetBinContent(579,14);
   sum->SetBinContent(580,12);
   sum->SetBinContent(581,15);
   sum->SetBinContent(582,14);
   sum->SetBinContent(583,21);
   sum->SetBinContent(584,14);
   sum->SetBinContent(585,31);
   sum->SetBinContent(586,36);
   sum->SetBinContent(587,22);
   sum->SetBinContent(588,34);
   sum->SetBinContent(589,35);
   sum->SetBinContent(590,34);
   sum->SetBinContent(591,36);
   sum->SetBinContent(592,30);
   sum->SetBinContent(593,26);
   sum->SetBinContent(594,19);
   sum->SetBinContent(595,16);
   sum->SetBinContent(596,13);
   sum->SetBinContent(597,12);
   sum->SetBinContent(598,8);
   sum->SetBinContent(599,12);
   sum->SetBinContent(600,17);
   sum->SetBinContent(601,15);
   sum->SetBinContent(602,6);
   sum->SetBinContent(603,17);
   sum->SetBinContent(604,20);
   sum->SetBinContent(605,16);
   sum->SetBinContent(606,11);
   sum->SetBinContent(607,18);
   sum->SetBinContent(608,9);
   sum->SetBinContent(609,11);
   sum->SetBinContent(610,12);
   sum->SetBinContent(611,9);
   sum->SetBinContent(612,10);
   sum->SetBinContent(613,5);
   sum->SetBinContent(614,6);
   sum->SetBinContent(615,12);
   sum->SetBinContent(616,9);
   sum->SetBinContent(617,9);
   sum->SetBinContent(618,4);
   sum->SetBinContent(619,10);
   sum->SetBinContent(620,12);
   sum->SetBinContent(621,6);
   sum->SetBinContent(622,7);
   sum->SetBinContent(623,10);
   sum->SetBinContent(624,7);
   sum->SetBinContent(625,3);
   sum->SetBinContent(626,11);
   sum->SetBinContent(627,9);
   sum->SetBinContent(628,11);
   sum->SetBinContent(629,13);
   sum->SetBinContent(630,6);
   sum->SetBinContent(631,3);
   sum->SetBinContent(632,6);
   sum->SetBinContent(633,12);
   sum->SetBinContent(634,7);
   sum->SetBinContent(635,11);
   sum->SetBinContent(636,6);
   sum->SetBinContent(637,6);
   sum->SetBinContent(638,8);
   sum->SetBinContent(639,9);
   sum->SetBinContent(640,9);
   sum->SetBinContent(641,13);
   sum->SetBinContent(642,8);
   sum->SetBinContent(643,9);
   sum->SetBinContent(644,13);
   sum->SetBinContent(645,3);
   sum->SetBinContent(646,9);
   sum->SetBinContent(647,8);
   sum->SetBinContent(648,6);
   sum->SetBinContent(649,5);
   sum->SetBinContent(650,13);
   sum->SetBinContent(651,8);
   sum->SetBinContent(652,9);
   sum->SetBinContent(653,4);
   sum->SetBinContent(654,7);
   sum->SetBinContent(655,11);
   sum->SetBinContent(656,5);
   sum->SetBinContent(657,9);
   sum->SetBinContent(658,11);
   sum->SetBinContent(659,6);
   sum->SetBinContent(660,6);
   sum->SetBinContent(661,7);
   sum->SetBinContent(662,11);
   sum->SetBinContent(663,13);
   sum->SetBinContent(664,8);
   sum->SetBinContent(665,10);
   sum->SetBinContent(666,21);
   sum->SetBinContent(667,10);
   sum->SetBinContent(668,6);
   sum->SetBinContent(669,7);
   sum->SetBinContent(670,10);
   sum->SetBinContent(671,13);
   sum->SetBinContent(672,11);
   sum->SetBinContent(673,8);
   sum->SetBinContent(674,13);
   sum->SetBinContent(675,4);
   sum->SetBinContent(676,9);
   sum->SetBinContent(677,14);
   sum->SetBinContent(678,8);
   sum->SetBinContent(679,12);
   sum->SetBinContent(680,8);
   sum->SetBinContent(681,4);
   sum->SetBinContent(682,8);
   sum->SetBinContent(683,18);
   sum->SetBinContent(684,4);
   sum->SetBinContent(685,3);
   sum->SetBinContent(686,9);
   sum->SetBinContent(687,14);
   sum->SetBinContent(688,8);
   sum->SetBinContent(689,7);
   sum->SetBinContent(690,5);
   sum->SetBinContent(691,7);
   sum->SetBinContent(692,6);
   sum->SetBinContent(693,10);
   sum->SetBinContent(694,11);
   sum->SetBinContent(695,8);
   sum->SetBinContent(696,6);
   sum->SetBinContent(697,13);
   sum->SetBinContent(698,10);
   sum->SetBinContent(699,9);
   sum->SetBinContent(700,6);
   sum->SetBinContent(701,10);
   sum->SetBinContent(702,8);
   sum->SetBinContent(703,10);
   sum->SetBinContent(704,11);
   sum->SetBinContent(705,6);
   sum->SetBinContent(706,6);
   sum->SetBinContent(707,3);
   sum->SetBinContent(708,8);
   sum->SetBinContent(709,8);
   sum->SetBinContent(710,10);
   sum->SetBinContent(711,8);
   sum->SetBinContent(712,9);
   sum->SetBinContent(713,6);
   sum->SetBinContent(714,8);
   sum->SetBinContent(715,10);
   sum->SetBinContent(716,2);
   sum->SetBinContent(717,7);
   sum->SetBinContent(718,8);
   sum->SetBinContent(719,10);
   sum->SetBinContent(720,5);
   sum->SetBinContent(721,9);
   sum->SetBinContent(722,8);
   sum->SetBinContent(723,12);
   sum->SetBinContent(724,11);
   sum->SetBinContent(725,10);
   sum->SetBinContent(726,6);
   sum->SetBinContent(727,2);
   sum->SetBinContent(728,4);
   sum->SetBinContent(729,3);
   sum->SetBinContent(730,9);
   sum->SetBinContent(731,4);
   sum->SetBinContent(732,14);
   sum->SetBinContent(733,5);
   sum->SetBinContent(734,4);
   sum->SetBinContent(735,11);
   sum->SetBinContent(736,11);
   sum->SetBinContent(737,8);
   sum->SetBinContent(738,9);
   sum->SetBinContent(739,11);
   sum->SetBinContent(740,9);
   sum->SetBinContent(741,11);
   sum->SetBinContent(742,8);
   sum->SetBinContent(743,4);
   sum->SetBinContent(744,4);
   sum->SetBinContent(745,6);
   sum->SetBinContent(746,6);
   sum->SetBinContent(747,10);
   sum->SetBinContent(748,8);
   sum->SetBinContent(749,4);
   sum->SetBinContent(750,11);
   sum->SetBinContent(751,8);
   sum->SetBinContent(752,4);
   sum->SetBinContent(753,5);
   sum->SetBinContent(754,8);
   sum->SetBinContent(755,12);
   sum->SetBinContent(756,4);
   sum->SetBinContent(757,5);
   sum->SetBinContent(758,9);
   sum->SetBinContent(759,6);
   sum->SetBinContent(760,9);
   sum->SetBinContent(761,4);
   sum->SetBinContent(762,6);
   sum->SetBinContent(763,5);
   sum->SetBinContent(764,9);
   sum->SetBinContent(765,11);
   sum->SetBinContent(766,7);
   sum->SetBinContent(767,8);
   sum->SetBinContent(768,8);
   sum->SetBinContent(769,10);
   sum->SetBinContent(770,9);
   sum->SetBinContent(771,6);
   sum->SetBinContent(772,10);
   sum->SetBinContent(773,7);
   sum->SetBinContent(774,14);
   sum->SetBinContent(775,7);
   sum->SetBinContent(776,7);
   sum->SetBinContent(777,10);
   sum->SetBinContent(778,6);
   sum->SetBinContent(779,3);
   sum->SetBinContent(780,5);
   sum->SetBinContent(781,6);
   sum->SetBinContent(782,9);
   sum->SetBinContent(783,10);
   sum->SetBinContent(784,7);
   sum->SetBinContent(785,8);
   sum->SetBinContent(786,6);
   sum->SetBinContent(787,11);
   sum->SetBinContent(788,3);
   sum->SetBinContent(789,3);
   sum->SetBinContent(790,4);
   sum->SetBinContent(791,3);
   sum->SetBinContent(792,8);
   sum->SetBinContent(793,8);
   sum->SetBinContent(794,9);
   sum->SetBinContent(795,1);
   sum->SetBinContent(796,6);
   sum->SetBinContent(797,8);
   sum->SetBinContent(798,2);
   sum->SetBinContent(799,9);
   sum->SetBinContent(800,7);
   sum->SetBinContent(801,11);
   sum->SetBinContent(802,9);
   sum->SetBinContent(803,3);
   sum->SetBinContent(804,10);
   sum->SetBinContent(805,11);
   sum->SetBinContent(806,8);
   sum->SetBinContent(807,5);
   sum->SetBinContent(808,6);
   sum->SetBinContent(809,6);
   sum->SetBinContent(810,3);
   sum->SetBinContent(811,10);
   sum->SetBinContent(812,9);
   sum->SetBinContent(813,10);
   sum->SetBinContent(814,5);
   sum->SetBinContent(815,6);
   sum->SetBinContent(816,7);
   sum->SetBinContent(817,6);
   sum->SetBinContent(818,3);
   sum->SetBinContent(819,4);
   sum->SetBinContent(820,7);
   sum->SetBinContent(821,8);
   sum->SetBinContent(822,8);
   sum->SetBinContent(823,6);
   sum->SetBinContent(824,10);
   sum->SetBinContent(825,9);
   sum->SetBinContent(826,10);
   sum->SetBinContent(827,1);
   sum->SetBinContent(828,11);
   sum->SetBinContent(829,4);
   sum->SetBinContent(830,5);
   sum->SetBinContent(831,6);
   sum->SetBinContent(832,13);
   sum->SetBinContent(833,5);
   sum->SetBinContent(834,8);
   sum->SetBinContent(835,13);
   sum->SetBinContent(836,5);
   sum->SetBinContent(837,7);
   sum->SetBinContent(838,15);
   sum->SetBinContent(839,7);
   sum->SetBinContent(840,8);
   sum->SetBinContent(841,8);
   sum->SetBinContent(842,2);
   sum->SetBinContent(843,5);
   sum->SetBinContent(844,3);
   sum->SetBinContent(845,10);
   sum->SetBinContent(846,13);
   sum->SetBinContent(847,9);
   sum->SetBinContent(848,10);
   sum->SetBinContent(849,12);
   sum->SetBinContent(850,1);
   sum->SetBinContent(851,6);
   sum->SetBinContent(852,3);
   sum->SetBinContent(853,3);
   sum->SetBinContent(854,8);
   sum->SetBinContent(855,6);
   sum->SetBinContent(856,7);
   sum->SetBinContent(857,3);
   sum->SetBinContent(858,5);
   sum->SetBinContent(859,12);
   sum->SetBinContent(860,5);
   sum->SetBinContent(861,6);
   sum->SetBinContent(862,8);
   sum->SetBinContent(863,5);
   sum->SetBinContent(864,12);
   sum->SetBinContent(865,7);
   sum->SetBinContent(866,10);
   sum->SetBinContent(867,7);
   sum->SetBinContent(868,4);
   sum->SetBinContent(869,9);
   sum->SetBinContent(870,7);
   sum->SetBinContent(871,7);
   sum->SetBinContent(872,6);
   sum->SetBinContent(873,9);
   sum->SetBinContent(874,11);
   sum->SetBinContent(875,6);
   sum->SetBinContent(876,9);
   sum->SetBinContent(877,12);
   sum->SetBinContent(878,4);
   sum->SetBinContent(879,6);
   sum->SetBinContent(880,9);
   sum->SetBinContent(881,10);
   sum->SetBinContent(882,5);
   sum->SetBinContent(883,7);
   sum->SetBinContent(884,9);
   sum->SetBinContent(885,10);
   sum->SetBinContent(886,4);
   sum->SetBinContent(887,11);
   sum->SetBinContent(888,3);
   sum->SetBinContent(889,5);
   sum->SetBinContent(890,9);
   sum->SetBinContent(891,10);
   sum->SetBinContent(892,8);
   sum->SetBinContent(893,9);
   sum->SetBinContent(894,9);
   sum->SetBinContent(895,4);
   sum->SetBinContent(896,7);
   sum->SetBinContent(897,5);
   sum->SetBinContent(898,5);
   sum->SetBinContent(899,11);
   sum->SetBinContent(900,6);
   sum->SetBinContent(901,6);
   sum->SetBinContent(902,7);
   sum->SetBinContent(903,5);
   sum->SetBinContent(904,9);
   sum->SetBinContent(905,8);
   sum->SetBinContent(906,2);
   sum->SetBinContent(907,10);
   sum->SetBinContent(908,6);
   sum->SetBinContent(909,6);
   sum->SetBinContent(910,6);
   sum->SetBinContent(911,5);
   sum->SetBinContent(912,8);
   sum->SetBinContent(913,8);
   sum->SetBinContent(914,5);
   sum->SetBinContent(915,2);
   sum->SetBinContent(916,4);
   sum->SetBinContent(917,10);
   sum->SetBinContent(918,6);
   sum->SetBinContent(919,6);
   sum->SetBinContent(920,4);
   sum->SetBinContent(921,7);
   sum->SetBinContent(922,8);
   sum->SetBinContent(923,7);
   sum->SetBinContent(924,12);
   sum->SetBinContent(925,8);
   sum->SetBinContent(926,7);
   sum->SetBinContent(927,7);
   sum->SetBinContent(928,6);
   sum->SetBinContent(929,7);
   sum->SetBinContent(930,4);
   sum->SetBinContent(931,5);
   sum->SetBinContent(932,7);
   sum->SetBinContent(933,7);
   sum->SetBinContent(934,7);
   sum->SetBinContent(935,7);
   sum->SetBinContent(936,7);
   sum->SetBinContent(937,6);
   sum->SetBinContent(938,3);
   sum->SetBinContent(939,10);
   sum->SetBinContent(940,9);
   sum->SetBinContent(941,10);
   sum->SetBinContent(942,6);
   sum->SetBinContent(943,5);
   sum->SetBinContent(944,9);
   sum->SetBinContent(945,4);
   sum->SetBinContent(946,2);
   sum->SetBinContent(947,5);
   sum->SetBinContent(948,8);
   sum->SetBinContent(949,6);
   sum->SetBinContent(950,10);
   sum->SetBinContent(951,5);
   sum->SetBinContent(952,9);
   sum->SetBinContent(953,4);
   sum->SetBinContent(954,12);
   sum->SetBinContent(955,7);
   sum->SetBinContent(956,9);
   sum->SetBinContent(957,10);
   sum->SetBinContent(958,7);
   sum->SetBinContent(959,10);
   sum->SetBinContent(960,5);
   sum->SetBinContent(961,8);
   sum->SetBinContent(962,2);
   sum->SetBinContent(963,6);
   sum->SetBinContent(964,4);
   sum->SetBinContent(965,5);
   sum->SetBinContent(966,8);
   sum->SetBinContent(967,3);
   sum->SetBinContent(968,5);
   sum->SetBinContent(969,3);
   sum->SetBinContent(970,5);
   sum->SetBinContent(971,2);
   sum->SetBinContent(972,5);
   sum->SetBinContent(973,4);
   sum->SetBinContent(974,4);
   sum->SetBinContent(975,9);
   sum->SetBinContent(976,5);
   sum->SetBinContent(977,9);
   sum->SetBinContent(978,6);
   sum->SetBinContent(979,7);
   sum->SetBinContent(980,6);
   sum->SetBinContent(981,6);
   sum->SetBinContent(982,7);
   sum->SetBinContent(983,5);
   sum->SetBinContent(984,4);
   sum->SetBinContent(985,10);
   sum->SetBinContent(986,10);
   sum->SetBinContent(987,7);
   sum->SetBinContent(988,8);
   sum->SetBinContent(989,9);
   sum->SetBinContent(990,6);
   sum->SetBinContent(991,10);
   sum->SetBinContent(992,9);
   sum->SetBinContent(993,6);
   sum->SetBinContent(994,10);
   sum->SetBinContent(995,3);
   sum->SetBinContent(996,10);
   sum->SetBinContent(997,7);
   sum->SetBinContent(998,5);
   sum->SetBinContent(999,8);
   sum->SetBinContent(1000,5);
   sum->SetBinContent(1001,9);
   sum->SetBinContent(1002,6);
   sum->SetBinContent(1003,7);
   sum->SetBinContent(1004,8);
   sum->SetBinContent(1005,14);
   sum->SetBinContent(1006,10);
   sum->SetBinContent(1007,3);
   sum->SetBinContent(1008,9);
   sum->SetBinContent(1009,11);
   sum->SetBinContent(1010,12);
   sum->SetBinContent(1011,6);
   sum->SetBinContent(1012,8);
   sum->SetBinContent(1013,5);
   sum->SetBinContent(1014,5);
   sum->SetBinContent(1015,10);
   sum->SetBinContent(1016,14);
   sum->SetBinContent(1017,5);
   sum->SetBinContent(1018,10);
   sum->SetBinContent(1019,8);
   sum->SetBinContent(1020,5);
   sum->SetBinContent(1021,11);
   sum->SetBinContent(1022,16);
   sum->SetBinContent(1023,15);
   sum->SetBinContent(1024,25);
   sum->SetBinContent(1025,19);
   sum->SetBinContent(1026,28);
   sum->SetBinContent(1027,50);
   sum->SetBinContent(1028,50);
   sum->SetBinContent(1029,81);
   sum->SetBinContent(1030,102);
   sum->SetBinContent(1031,115);
   sum->SetBinContent(1032,118);
   sum->SetBinContent(1033,139);
   sum->SetBinContent(1034,146);
   sum->SetBinContent(1035,145);
   sum->SetBinContent(1036,147);
   sum->SetBinContent(1037,153);
   sum->SetBinContent(1038,192);
   sum->SetBinContent(1039,186);
   sum->SetBinContent(1040,198);
   sum->SetBinContent(1041,171);
   sum->SetBinContent(1042,162);
   sum->SetBinContent(1043,92);
   sum->SetBinContent(1044,56);
   sum->SetBinContent(1045,35);
   sum->SetBinContent(1046,11);
   sum->SetBinContent(1047,10);
   sum->SetBinContent(1048,3);
   sum->SetBinContent(1049,4);
   sum->SetBinContent(1050,3);
   sum->SetBinContent(1051,5);
   sum->SetBinContent(1052,2);
   sum->SetBinContent(1053,7);
   sum->SetBinContent(1054,5);
   sum->SetBinContent(1055,2);
   sum->SetBinContent(1056,4);
   sum->SetBinContent(1057,1);
   sum->SetBinContent(1058,3);
   sum->SetBinContent(1059,1);
   sum->SetBinContent(1060,3);
   sum->SetBinContent(1061,4);
   sum->SetBinContent(1063,2);
   sum->SetBinContent(1064,2);
   sum->SetBinContent(1065,2);
   sum->SetBinContent(1066,1);
   sum->SetBinContent(1067,3);
   sum->SetBinContent(1068,6);
   sum->SetBinContent(1069,2);
   sum->SetBinContent(1070,1);
   sum->SetBinContent(1071,3);
   sum->SetBinContent(1072,2);
   sum->SetBinContent(1073,1);
   sum->SetBinContent(1074,4);
   sum->SetBinContent(1075,1);
   sum->SetBinContent(1076,2);
   sum->SetBinContent(1077,3);
   sum->SetBinContent(1078,4);
   sum->SetBinContent(1079,6);
   sum->SetBinContent(1080,8);
   sum->SetBinContent(1081,4);
   sum->SetBinContent(1082,9);
   sum->SetBinContent(1083,8);
   sum->SetBinContent(1084,12);
   sum->SetBinContent(1085,21);
   sum->SetBinContent(1086,15);
   sum->SetBinContent(1087,17);
   sum->SetBinContent(1088,19);
   sum->SetBinContent(1089,26);
   sum->SetBinContent(1090,38);
   sum->SetBinContent(1091,35);
   sum->SetBinContent(1092,39);
   sum->SetBinContent(1093,36);
   sum->SetBinContent(1094,39);
   sum->SetBinContent(1095,26);
   sum->SetBinContent(1096,44);
   sum->SetBinContent(1097,33);
   sum->SetBinContent(1098,42);
   sum->SetBinContent(1099,21);
   sum->SetBinContent(1100,9);
   sum->SetBinContent(1101,17);
   sum->SetBinContent(1102,11);
   sum->SetBinContent(1103,19);
   sum->SetBinContent(1104,13);
   sum->SetBinContent(1105,9);
   sum->SetBinContent(1106,20);
   sum->SetBinContent(1107,12);
   sum->SetBinContent(1108,6);
   sum->SetBinContent(1109,5);
   sum->SetBinContent(1110,3);
   sum->SetBinContent(1111,3);
   sum->SetBinContent(1113,2);
   sum->SetBinContent(1114,1);
   sum->SetBinContent(1117,1);
   sum->SetBinContent(1119,2);
   sum->SetBinContent(1120,1);
   sum->SetBinContent(1122,1);
   sum->SetBinContent(1123,2);
   sum->SetBinContent(1124,2);
   sum->SetBinContent(1125,1);
   sum->SetBinContent(1127,1);
   sum->SetBinContent(1129,2);
   sum->SetBinContent(1130,1);
   sum->SetBinContent(1132,2);
   sum->SetBinContent(1133,1);
   sum->SetBinContent(1135,1);
   sum->SetBinContent(1136,1);
   sum->SetBinContent(1141,2);
   sum->SetBinContent(1146,1);
   sum->SetBinContent(1147,1);
   sum->SetBinContent(1148,1);
   sum->SetBinContent(1149,1);
   sum->SetBinContent(1150,3);
   sum->SetBinContent(1151,1);
   sum->SetBinContent(1153,2);
   sum->SetBinContent(1155,1);
   sum->SetBinContent(1160,1);
   sum->SetBinContent(1161,2);
   sum->SetBinContent(1162,1);
   sum->SetBinContent(1163,2);
   sum->SetBinContent(1172,2);
   sum->SetBinContent(1173,3);
   sum->SetBinContent(1174,1);
   sum->SetBinContent(1180,1);
   sum->SetBinContent(1184,1);
   sum->SetBinContent(1190,1);
   sum->SetBinContent(1191,2);
   sum->SetBinContent(1196,3);
   sum->SetBinContent(1212,1);
   sum->SetBinContent(1218,1);
   sum->SetBinContent(1220,2);
   sum->SetBinContent(1223,1);
   sum->SetBinContent(1226,2);
   sum->SetBinContent(1230,1);
   sum->SetBinContent(1236,1);
   sum->SetBinContent(1237,1);
   sum->SetBinContent(1247,1);
   sum->SetBinContent(1249,1);
   sum->SetBinContent(1255,1);
   sum->SetBinContent(1258,1);
   sum->SetBinContent(1269,1);
   sum->SetBinContent(1272,1);
   sum->SetBinContent(1276,1);
   sum->SetBinContent(1280,1);
   sum->SetBinContent(1284,1);
   sum->SetBinContent(1286,1);
   sum->SetBinContent(1288,1);
   sum->SetBinContent(1290,1);
   sum->SetBinContent(1299,1);
   sum->SetBinContent(1303,1);
   sum->SetBinContent(1307,1);
   sum->SetBinContent(1311,1);
   sum->SetBinContent(1320,1);
   sum->SetBinContent(1325,1);
   sum->SetBinContent(1330,1);
   sum->SetBinContent(1343,1);
   sum->SetBinContent(1352,1);
   sum->SetBinContent(1368,1);
   sum->SetBinContent(1374,1);
   sum->SetBinContent(1378,1);
   sum->SetBinContent(1389,1);
   sum->SetBinContent(1404,1);
   sum->SetBinContent(1405,1);
   sum->SetBinContent(1413,1);
   sum->SetBinContent(1427,1);
   sum->SetBinContent(1431,1);
   sum->SetBinContent(1447,1);
   sum->SetBinContent(1455,1);
   sum->SetBinContent(1463,1);
   sum->SetBinContent(1488,1);
   sum->SetBinContent(1495,1);
   sum->SetBinContent(1501,1);
   sum->SetBinContent(1564,1);
   sum->SetBinContent(1566,1);
   sum->SetBinContent(1618,1);
   sum->SetEntries(16000);
	}
	sum->SetLineColor(kBlack);
	sum->SetStats(0);
	
	
	
	ax = sum->GetXaxis();
	ax->SetTitle("Energy (keV)");
	ax->CenterTitle();
	ax->SetTitleOffset(1.1);
	ax->SetTitleSize(0.07);
	ax->SetLabelSize(0.07);
	ax->SetTitleFont(132);
	ax->SetLabelFont(132);
	ax->SetNdivisions(8,true);
	ax->SetRangeUser(0,600);
	ax = sum->GetYaxis();
	ax->SetTitle("Intensity");
	ax->CenterTitle();
	ax->SetTitleOffset(0.9);
	ax->SetTitleSize(0.07);
	ax->SetLabelSize(0.07);
	ax->SetTitleFont(132);
	ax->SetLabelFont(132);
	ax->SetNdivisions(5,true);
	ax->SetTickLength(0);
   sum->Draw();
	
}
Esempio n. 3
0
// Called once for each event in the main event loop
// Return non-zero to indicate a problem and terminate the event loop
int TemplateCreator::ProcessEntry(TGlobalData* gData, const TSetupData* setup){

  // Prepare a few variables
  std::string bankname, detname;
  PulseIslandList thePulseIslands;
  StringPulseIslandMap::const_iterator it;

  // Loop over each detector
  for(it = gData->fPulseIslandToChannelMap.begin(); it != gData->fPulseIslandToChannelMap.end(); ++it){

    // Get the bank and detector names for this detector
    bankname = it->first;
    detname = setup->GetDetectorName(bankname);

    // See if we already have a converged template for this detector
    if (fConvergedStatuses[detname] == true) {
      continue;
    }

    // Create the pulse candidate finder for this detector
    PulseCandidateFinder* pulse_candidate_finder = new PulseCandidateFinder(detname, fOpts);

    // Create the TemplateFitter that we will use for this channel
    fTemplateFitter = new TemplateFitter(detname, fRefineFactor);

    // Get the TPIs
    thePulseIslands = it->second;
    if (thePulseIslands.size() == 0) continue; // no pulses here..

    // Try and get the template (it may have been created in a previous event)
    std::string template_name = "hTemplate_" + detname;
    TH1D* hTemplate = NULL;
    if (fTemplates.find(detname) != fTemplates.end()) {
      hTemplate = fTemplates[detname];
    }

    // Store a couple of numbers to get an idea of how many successful fits there are
    int& n_fit_attempts = fNFitAttempts[detname]; // number of pulses we try to fit to
    int& n_successful_fits = fNSuccessfulFits[detname];
    int& n_pulses_in_template = fNPulsesInTemplate[detname];

    // Loop through all the pulses
    for (PulseIslandList::iterator pulseIter = thePulseIslands.begin(); pulseIter != thePulseIslands.end(); ++pulseIter) {

      // First we will see how many candidate pulses there are on the TPI
      pulse_candidate_finder->FindPulseCandidates(*pulseIter);
      int n_pulse_candidates = pulse_candidate_finder->GetNPulseCandidates();

      // only continue if there is one pulse candidate on the TPI
      if (n_pulse_candidates == 1) {

	TPulseIsland* pulse = *pulseIter;

        // Add the first pulse directly to the template (although we may try and choose a random pulse to start with)
	if (hTemplate == NULL) {
	  std::string histname = "hTemplate_" + detname;
	  std::string histtitle = "Template Histogram for the " + detname + " channel";

	  int pulse_length = pulse->GetSamples().size();
	  if (pulse->GetPeakSample() >= pulse_length - pulse_length/5.0) {
	    if (Debug()) {
	      std::cout << "TemplateCreator: Pulse #" << pulseIter - thePulseIslands.begin() << " is too close to one end of the island and so won't be used as the first pulse in the template." << std::endl;
	    }
	    continue;
	  }
	  hTemplate = CreateRefinedPulseHistogram(pulse, histname.c_str(), histtitle.c_str(), true);
	  ++n_pulses_in_template;

	  if (Debug()) {
	    std::cout << "TemplateCreator: Adding " << detname << " Pulse #" << pulseIter - thePulseIslands.begin() << " directly to the template" << std::endl;
	  }
	  fTemplates[detname] = hTemplate;
	  continue;
	}

	// Get the samples so we can check for digitiser overflow
	const std::vector<int>& theSamples = (pulse)->GetSamples();
	int n_samples = theSamples.size();

	// Calculate the maximum ADC value for this digitiser
	int n_bits = TSetupData::Instance()->GetNBits(bankname);
	double max_adc_value = std::pow(2, n_bits);

	// Loop through the samples and check for digitizer overflow
	bool overflowed = false;
	for (int i = 0; i < n_samples; ++i) {
	  int sample_value = theSamples.at(i);
	  if (sample_value >= max_adc_value-1 && sample_value <= max_adc_value+1) {
	    if (Debug()) {
	      std::cout << "TemplateCreator: Pulse #" << pulseIter - thePulseIslands.begin() << " has overflowed the digitizer and won't be added to the template" << std::endl;
	    }
	    overflowed = true;
	    break;
	  }
	  else if (sample_value == 0) {
	    if (Debug()) {
	      std::cout << "TemplateCreator: Pulse #" << pulseIter - thePulseIslands.begin() << " has underflowed the digitizer and won't be added to the template" << std::endl;
	    }
	    overflowed = true;
	    break;
	  }
	}
	if (overflowed) {
	  continue; // skip this pulse
	}

	// Create the refined pulse waveform
	TH1D* hPulseToFit = CreateRefinedPulseHistogram(pulse, "hPulseToFit", "hPulseToFit", false);

	// Create some histograms that monitor the progression of the template
	if (fErrorVsPulseAddedHistograms.find(detname) == fErrorVsPulseAddedHistograms.end()) {
	  std::string error_histname = "hErrorVsPulseAdded_" + detname;
	  std::string error_histtitle = "Plot of the Error as each new Pulse is added to the template for the " + detname + " channel";
	  int n_bins = 10000;
	  TH1D* error_hist = new TH1D(error_histname.c_str(), error_histtitle.c_str(), n_bins,0,n_bins);
	  fErrorVsPulseAddedHistograms[detname] = error_hist;
	}

	// all the other pulses will be fitted to the template and then added to it
	// Get some initial estimates for the fitter
	double template_pedestal = hTemplate->GetBinContent(1);
	double template_amplitude;
	double template_time;

	double pulse_pedestal = hPulseToFit->GetBinContent(1);
	double pulse_amplitude;
	double pulse_time;

	double pedestal_offset_estimate = pulse_pedestal; // now we're dealing with actual pulses since we subtract the template_pedestal in the transformation
	double amplitude_scale_factor_estimate;
	double time_offset_estimate;
	if (TSetupData::Instance()->GetTriggerPolarity(bankname) == 1) { 
	  template_amplitude = (hTemplate->GetMaximum() - template_pedestal);
	  template_time = hTemplate->GetMaximumBin() - 1; // go from bin numbering (1, n_samples) to clock ticks (0, n_samples-1)

	  pulse_amplitude = (hPulseToFit->GetMaximum() - pulse_pedestal);
	  pulse_time = hPulseToFit->GetMaximumBin() - 1;

	  amplitude_scale_factor_estimate = pulse_amplitude / template_amplitude;  // estimated scale factor
	  time_offset_estimate = pulse_time - template_time;
	}
	else if (TSetupData::Instance()->GetTriggerPolarity(bankname) == -1) {
	  template_amplitude = (template_pedestal - hTemplate->GetMinimum());
	  template_time = hTemplate->GetMinimumBin() - 1; // go from bin numbering (1, n_samples) to clock ticks (0, n_samples-1)

	  pulse_amplitude = (pulse_pedestal - hPulseToFit->GetMinimum());
	  pulse_time = hPulseToFit->GetMinimumBin() - 1; // go from bin numbering (1, n_samples) to clock ticks (0, n_samples-1)

	  amplitude_scale_factor_estimate = pulse_amplitude / template_amplitude;  // estimated scale factor
	  time_offset_estimate = pulse_time - template_time;
	}

	fTemplateFitter->SetInitialParameterEstimates(pedestal_offset_estimate, amplitude_scale_factor_estimate, time_offset_estimate);
	
	if (Debug()) {
	  std::cout << "TemplateCreator: " << detname << "(" << bankname << "): Pulse #" << pulseIter - thePulseIslands.begin() << ": " << std::endl
		    << "TemplateCreator: Template: pedestal = " << template_pedestal << ", amplitude = " << template_amplitude << ", time = " << template_time << std::endl
		    << "TemplateCreator: Pulse: pedestal = " << pulse_pedestal << ", amplitude = " << pulse_amplitude << ", time = " << pulse_time << std::endl
		    << "TemplateCreator: Initial Estimates: pedestal = " << pedestal_offset_estimate << ", amplitude = " << amplitude_scale_factor_estimate 
		    << ", time = " << time_offset_estimate << std::endl;
	}

	int fit_status = fTemplateFitter->FitPulseToTemplate(hTemplate, hPulseToFit, bankname);
	++n_fit_attempts;
	if (fit_status != 0) {
	  if (Debug()) {
	    std::cout << "TemplateCreator: Problem with fit (status = " << fit_status << ")" << std::endl;
	  }
	  delete hPulseToFit; // delete this here since it is no longer needed
	  continue;
	}
	++n_successful_fits;

	if (Debug()) {
	  std::cout << "Template Creator: Fitted Parameters: PedOffset = " << fTemplateFitter->GetPedestalOffset() << ", AmpScaleFactor = " << fTemplateFitter->GetAmplitudeScaleFactor()
	            << ", TimeOffset = " << fTemplateFitter->GetTimeOffset() << ", Chi2 = " << fTemplateFitter->GetChi2() << ", NDoF = " << fTemplateFitter->GetNDoF() 
		    << ", Prob = " << TMath::Prob(fTemplateFitter->GetChi2(), fTemplateFitter->GetNDoF()) << std::endl << std::endl;
	}

	if (fPulseDebug) {
	  // Print out some templates as we go along
	  if (n_pulses_in_template <= 10 || 
	      (n_pulses_in_template <= 100 && n_pulses_in_template%10 == 0) ||
	      (n_pulses_in_template%100 == 0) ) {
	    std::stringstream newhistname;
	    newhistname << "hTemplate_" << n_pulses_in_template << "Pulses_" << detname;
	    TH1D* new_template = (TH1D*) hTemplate->Clone(newhistname.str().c_str());
	  }
	}

	// Add the pulse to the template (we'll do correct the sample values there)
	AddPulseToTemplate(hTemplate, hPulseToFit, bankname);
	++n_pulses_in_template;
	

	if (fPulseDebug) {
	  // Print out the uncorrected and corrected pulse that has been added to the template

	  // Create the histograms that we will use to plot the corrected and uncorrected pulses
	  std::stringstream histname;
	  histname << template_name << "_Event" << EventNavigator::Instance().EntryNo() << "_Pulse" << pulseIter - thePulseIslands.begin() << "_" << n_pulses_in_template << "Added";
	  TH1D* hUncorrectedPulse = (TH1D*) hPulseToFit->Clone(histname.str().c_str());
	  histname << "_Corrected";
	  TH1D* hCorrectedPulse = (TH1D*) hPulseToFit->Clone(histname.str().c_str());
	  hCorrectedPulse->SetEntries(0); // set entries back to 0
	  
	  double pedestal_error = SetupNavigator::Instance()->GetNoise(bankname);

	  // Loop through the bins of the uncorrected pulse and set the values in the corrected pulse histogram
	  for (int iPulseBin = 1; iPulseBin <= hPulseToFit->GetNbinsX(); ++iPulseBin) {
	    
	    double uncorrected_value = hPulseToFit->GetBinContent(iPulseBin);
	    double corrected_value = CorrectSampleValue(uncorrected_value, template_pedestal);
	    
	    hCorrectedPulse->SetBinContent(iPulseBin +0.5 - fTemplateFitter->GetTimeOffset(), corrected_value); 
	    hCorrectedPulse->SetBinError(iPulseBin +0.5 - fTemplateFitter->GetTimeOffset(), pedestal_error);
	  }
	}

	delete hPulseToFit;

	// we keep on adding pulses until adding pulses has no effect on the template
	bool converged = CheckConvergence(hTemplate, bankname);
	if (converged) {
	  fConvergedStatuses[detname] = true;
	  std::cout << "TemplateCreator: " << detname << " template terminated at iteration " << n_pulses_in_template << std::endl;
	  break; // break from the for loop
	}
      } // end if only one pulse candidate
    } //end for loop through channels
  }

  return 0;
}