41#include <TRestExperimentList.h>
42#include <TRestSensitivity.h>
99 }
while (Chi2 - chi0 < target);
108 }
while (Chi2 - chi0 > target);
113void TRestSensitivity::GenerateCurve() {
116 if (GetNumberOfCurves() > 0)
118 exp->GenerateMockDataSet();
121 RESTInfo <<
"Generating sensitivity curve" <<
RESTendl;
122 std::vector<Double_t> curve;
124 RESTInfo <<
"Generating node : " << node <<
RESTendl;
129 RESTInfo <<
"Curve has been generated. You may use now TRestSensitivity::ExportCurve( fname.txt )."
133void TRestSensitivity::GenerateCurves(Int_t N) {
134 for (
int n = 0; n < N; n++) GenerateCurve();
137std::vector<Double_t> TRestSensitivity::GetCurve(
size_t n) {
138 if (n >= GetNumberOfCurves()) {
139 RESTWarning <<
"Requested curve number : " << n <<
" but only " << GetNumberOfCurves() <<
" generated"
141 return std::vector<Double_t>();
146std::vector<Double_t> TRestSensitivity::GetAveragedCurve() {
147 if (GetNumberOfCurves() <= 0)
return std::vector<Double_t>();
149 std::vector<double> averagedCurve(
fCurves[0].size(), 0.0);
151 for (
const auto& row :
fCurves) {
152 for (
size_t i = 0; i < row.size(); ++i) {
153 averagedCurve[i] += row[i];
157 for (
double& avg : averagedCurve) {
158 avg /=
static_cast<double>(
fCurves.size());
161 return averagedCurve;
164void TRestSensitivity::ExportAveragedCurve(std::string fname) {
165 std::vector<Double_t> curve = GetAveragedCurve();
166 if (curve.empty()) std::cout <<
"Curve is empty" << std::endl;
167 if (curve.empty())
return;
170 std::ofstream outputFile(fname);
174 RESTError <<
"TRestSensitivity::ExportCurve. Error opening file for writing!" <<
RESTendl;
179 RESTError <<
"TRestSensitivity::ExportCurve. Curve has not been properly generated" <<
RESTendl;
181 RESTError <<
"Try invoking TRestSensitivity::GenerateCurve" <<
RESTendl;
187 outputFile << node <<
" " << curve[m] << std::endl;
193 RESTInfo <<
"TRestSensitivity::ExportCurve. File has been written successfully!" <<
RESTendl;
196void TRestSensitivity::ExportCurve(std::string fname,
int n = 0) {
197 std::vector<Double_t> curve = GetCurve(n);
198 if (curve.empty())
return;
201 std::ofstream outputFile(fname);
205 RESTError <<
"TRestSensitivity::ExportCurve. Error opening file for writing!" <<
RESTendl;
210 RESTError <<
"TRestSensitivity::ExportCurve. Curve has not been properly generated" <<
RESTendl;
211 RESTError <<
"Try invoking TRestSensitivity::GenerateCurve" <<
RESTendl;
217 outputFile << node <<
" " << curve[m] << std::endl;
223 RESTInfo <<
"TRestSensitivity::ExportCurve. File has been written successfully!" <<
RESTendl;
235 Double_t target = sigma * sigma;
253 if (!experiment->IsDataReady()) {
254 RESTError <<
"TRestSensitivity::UnbinnedLogLikelihood. Experiment " << experiment->GetName()
272 if (experiment->GetBackground()->
HasNodes()) {
274 <<
"TRestSensitivity::UnbinnedLogLikelihood is not ready to have background parameter nodes!"
279 Double_t signal = g4 * experiment->GetSignal()->
GetTotalRate() * experiment->GetExposureInSeconds();
283 if (experiment->GetExperimentalCounts() == 0)
return lhood;
285 if (ROOT::IsImplicitMTEnabled()) ROOT::DisableImplicitMT();
287 std::vector<std::vector<Double_t>> trackingData;
288 for (
const auto& var : experiment->GetSignal()->GetVariables()) {
289 auto values = experiment->GetExperimentalDataFrame().Take<Double_t>(var);
290 std::vector<Double_t> vDbl = std::move(*values);
291 trackingData.push_back(vDbl);
294 for (
size_t n = 0; n < trackingData[0].size(); n++) {
295 std::vector<Double_t> point;
296 for (
size_t m = 0; m < trackingData.size(); m++) point.push_back(trackingData[m][n]);
298 Double_t bckRate = experiment->GetBackground()->
GetRate(point);
299 Double_t sgnlRate = experiment->GetSignal()->
GetRate(point);
301 Double_t expectedRate = bckRate + g4 * sgnlRate;
302 lhood += TMath::Log(expectedRate);
311TH1D* TRestSensitivity::SignalStatisticalTest(Double_t node, Int_t N) {
312 std::vector<Double_t> couplings;
313 for (
int n = 0; n < N; n++) {
314 for (
const auto& exp :
fExperiments) exp->GetSignal()->RegenerateActiveNodeDensity();
316 Double_t coupling = TMath::Sqrt(TMath::Sqrt(
GetCoupling(node)));
317 couplings.push_back(coupling);
321 double min_value = *std::min_element(couplings.begin(), couplings.end());
322 double max_value = *std::max_element(couplings.begin(), couplings.end());
325 fSignalTest =
new TH1D(
"SignalTest",
"A signal test", 100, 0.9 * min_value, 1.1 * max_value);
326 for (
const auto& coup : couplings)
fSignalTest->Fill(coup);
339 while (metadata !=
nullptr) {
341 if (metadata->InheritsFrom(
"TRestExperimentList")) {
343 std::vector<TRestExperiment*> exList = experimentsList->GetExperiments();
345 }
else if (metadata->InheritsFrom(
"TRestExperiment")) {
367 std::vector<std::vector<Double_t>> curves(levels.size());
369 for (
const auto& l : levels) {
370 if (l >= 1 || l <= 0) {
371 RESTError <<
"The level value should be between 0 and 1" <<
RESTendl;
376 std::vector<int> intLevels;
377 for (
const auto& l : levels) {
378 int val = (int)round(l *
fCurves.size());
380 if (val < 0) val = 0;
382 intLevels.push_back(val);
385 for (
size_t m = 0; m <
fCurves[0].size(); m++) {
386 std::vector<Double_t> v;
387 for (
size_t n = 0; n <
fCurves.size(); n++) v.push_back(
fCurves[n][m]);
389 std::sort(v.begin(), v.begin() + v.size());
391 for (
size_t n = 0; n < intLevels.size(); n++) curves[n].push_back(v[intLevels[n]]);
397TCanvas* TRestSensitivity::DrawCurves() {
402 fCanvas =
new TCanvas(
"canv",
"This is the canvas title", 600, 450);
405 TPad* pad1 =
new TPad(
"pad1",
"This is pad1", 0.01, 0.02, 0.99, 0.97);
411 pad1->cd()->SetRightMargin(0.09);
412 pad1->cd()->SetLeftMargin(0.15);
413 pad1->cd()->SetBottomMargin(0.15);
415 std::vector<TGraph*> graphs;
417 for (
size_t n = 0; n < 20; n++) {
419 TGraph* gr =
new TGraph();
420 gr->SetName(grname.c_str());
421 for (
size_t m = 0; m < this->GetCurve(n).size(); m++)
423 TMath::Sqrt(TMath::Sqrt(this->GetCurve(n)[m])));
425 gr->SetLineColorAlpha(kBlue + n, 0.3);
427 graphs.push_back(gr);
430 TGraph* avGr =
new TGraph();
431 std::vector<Double_t> avCurve = GetAveragedCurve();
432 for (
size_t m = 0; m < avCurve.size(); m++)
434 avGr->SetLineColor(kBlack);
435 avGr->SetLineWidth(2);
437 graphs[0]->GetXaxis()->SetLimits(0, 0.25);
441 graphs[0]->GetXaxis()->SetTitle(
"mass [eV]");
442 graphs[0]->GetXaxis()->SetTitleSize(0.05);
443 graphs[0]->GetXaxis()->SetLabelSize(0.05);
444 graphs[0]->GetYaxis()->SetTitle(
"g_{a#gamma} [10^{-10} GeV^{-1}]");
445 graphs[0]->GetYaxis()->SetTitleOffset(1.5);
446 graphs[0]->GetYaxis()->SetTitleSize(0.05);
450 graphs[0]->Draw(
"AL");
451 for (
unsigned int n = 1; n < graphs.size(); n++) graphs[n]->Draw(
"L");
478TCanvas* TRestSensitivity::DrawLevelCurves() {
483 fCanvas =
new TCanvas(
"canv",
"This is the canvas title", 500, 400);
489 std::vector<std::vector<Double_t>> levelCurves =
GetLevelCurves({0.025, 0.16, 0.375, 0.625, 0.84, 0.975});
491 std::vector<TGraph*> graphs;
492 for (
size_t n = 0; n < levelCurves.size(); n++) {
494 TGraph* gr =
new TGraph();
495 gr->SetName(grname.c_str());
496 for (
size_t m = 0; m < levelCurves[n].size(); m++)
499 gr->SetLineColor(kBlack);
501 graphs.push_back(gr);
504 TGraph* centralGr =
new TGraph();
506 for (
size_t m = 0; m < centralCurve.size(); m++)
508 TMath::Sqrt(TMath::Sqrt(centralCurve[m])));
509 centralGr->SetLineColor(kBlack);
510 centralGr->SetLineWidth(2);
511 centralGr->SetMarkerSize(0.1);
513 graphs[0]->GetYaxis()->SetRangeUser(0, 0.5);
514 graphs[0]->GetXaxis()->SetRangeUser(0.001, 0.25);
515 graphs[0]->GetXaxis()->SetLimits(0.0001, 0.25);
516 graphs[0]->GetXaxis()->SetTitle(
"mass [eV]");
517 graphs[0]->GetXaxis()->SetTitleSize(0.04);
518 graphs[0]->GetXaxis()->SetTitleOffset(1.15);
519 graphs[0]->GetXaxis()->SetLabelSize(0.04);
522 graphs[0]->GetYaxis()->SetTitle(
"g_{a#gamma} [10^{-10} GeV^{-1}]");
523 graphs[0]->GetYaxis()->SetTitleOffset(1.5);
524 graphs[0]->GetYaxis()->SetTitleSize(0.04);
525 graphs[0]->GetYaxis()->SetLabelSize(0.04);
528 graphs[0]->Draw(
"AL");
530 TGraph* randomGr =
new TGraph();
531 std::vector<Double_t> randomCurve =
fCurves[13];
532 for (
size_t m = 0; m < randomCurve.size(); m++)
534 TMath::Sqrt(TMath::Sqrt(randomCurve[m])));
535 randomGr->SetLineColor(kBlack);
536 randomGr->SetLineWidth(1);
537 randomGr->SetMarkerSize(0.3);
538 randomGr->SetMarkerStyle(4);
540 std::vector<TGraph*> shadeGraphs;
542 int M = (int)levelCurves.size();
543 for (
int x = 0; x < M / 2; x++) {
544 TGraph* shade =
new TGraph();
545 int N = levelCurves[0].size();
546 for (
size_t m = 0; m < levelCurves[0].size(); m++)
548 TMath::Sqrt(TMath::Sqrt(levelCurves[x][m])));
549 for (
int m = N - 1; m >= 0; --m)
551 TMath::Sqrt(TMath::Sqrt(levelCurves[M - 1 - x][m])));
552 shade->SetFillColorAlpha(kRed, 0.25);
554 shadeGraphs.push_back(shade);
557 for (
unsigned int n = 1; n < graphs.size(); n++) graphs[n]->Draw(
"Lsame");
558 randomGr->Draw(
"LPsame");
576 std::vector<Double_t> nodes = experiment->GetSignal()->GetParameterizationNodes();
586void TRestSensitivity::PrintParameterizationNodes() {
587 std::cout <<
"Curve sensitivity nodes: ";
589 std::cout << std::endl;
598 RESTMetadata <<
" - Number of parameterization nodes : " << GetNumberOfNodes() <<
RESTendl;
599 RESTMetadata <<
" - Number of experiments loaded : " << GetNumberOfExperiments() <<
RESTendl;
600 RESTMetadata <<
" - Number of sensitivity curves generated : " << GetNumberOfCurves() <<
RESTendl;
602 RESTMetadata <<
" You may access experiment info using TRestSensitivity::GetExperiment(n)" <<
RESTendl;
Int_t FindActiveNode(Double_t node)
It returns the position of the fParameterizationNodes element for the variable name given by argument...
Double_t GetTotalRate()
This method integrates the rate to all the parameter space defined in the density function....
Bool_t HasNodes()
It returns true if any nodes have been defined.
Double_t GetRate(std::vector< Double_t > point)
It returns the intensity/rate (in seconds) corresponding to the generated distribution or formula eva...
Int_t SetActiveNode(Double_t node)
It returns the position of the fParameterizationNodes element for the variable name given by argument...
A helper metadata class to create a list of TRestExperiment instances.
It includes a model definition and experimental data used to obtain a final experimental sensitivity.
It combines a number of experimental conditions allowing to calculate a combined experimental sensiti...
void Initialize() override
It will initialize the data frame with the filelist and column names (or observables) that have been ...
~TRestSensitivity()
Default destructor.
std::vector< std::vector< Double_t > > fCurves
A vector of calculated sensitivity curves defined as a funtion of the parametric node.
std::vector< TRestExperiment * > fExperiments
A list of experimental conditions included to get a final sensitivity plot.
void InitFromConfigFile() override
It customizes the retrieval of XML data values of this class.
TCanvas * fCanvas
A canvas to draw.
void PrintMetadata() override
Prints on screen the information about the metadata members of TRestAxionSolarFlux.
TH1D * fSignalTest
It is used to generate a histogram with the signal distribution produced with different signal sample...
void ExtractExperimentParameterizationNodes(Bool_t rescan=false)
It scans all the experiment signals parametric nodes to build a complete list of nodes used to build ...
TRestSensitivity()
Default constructor.
std::vector< std::vector< Double_t > > GetLevelCurves(const std::vector< Double_t > &levels)
This method is used to obtain the list of curves that satisfy that each value inside the curve is pla...
Double_t GetCoupling(Double_t node, Double_t sigma=2, Double_t precision=0.01)
It will return the coupling value for which Chi=sigma.
Double_t UnbinnedLogLikelihood(const TRestExperiment *experiment, Double_t node, Double_t g4=0)
It returns the Log(L) for the experiment and coupling given by argument.
std::vector< Double_t > fParameterizationNodes
The fusioned list of parameterization nodes found at each experiment signal.
Double_t ApproachByFactor(Double_t node, Double_t g4, Double_t chi0, Double_t target, Double_t factor)
It will return a value of the coupling, g4, such that (chi-chi0) gets closer to the target value give...
std::string IntegerToString(Int_t n, std::string format="%d")
Gets a string from an integer.