Page Menu
Home
HEPForge
Search
Configure Global Search
Log In
Files
F19250686
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Award Token
Flag For Later
Size
22 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/src/Splines/SplineWriter.cxx b/src/Splines/SplineWriter.cxx
index 06be1b6d..4c7cb218 100644
--- a/src/Splines/SplineWriter.cxx
+++ b/src/Splines/SplineWriter.cxx
@@ -1,780 +1,782 @@
#include "SplineWriter.h"
using namespace SplineUtils;
// Spline reader should have access to every spline.
// Should know when reconfigure is called what its limits are and adjust
// accordingly. Then should pass it the index required in the stack as
// &xvals[index], and &pars[parindex]
void SplineWriter::Write(std::string name) {
// Create a TTree with each form and scan points in it.
TTree *tr = new TTree(name.c_str(), name.c_str());
// Loop over all splines and add a TString in the TTree for its inputs
tr->Branch("Spline", &fSpline);
tr->Branch("Type", &fType);
tr->Branch("Form", &fForm);
tr->Branch("Points", &fPoints);
tr->Fill();
tr->Write();
delete tr;
}
void SplineWriter::AddWeightsToTree(TTree *tr) {
// Add only the fitted spline coefficients to the ttree
std::cout << "Saving Spline Weights to TTree = "
<< Form("SplineWeights[%d]/F", (int)fValList.size()) << std::endl;
// sleep(1);
tr->Branch("SplineWeights", fWeightList,
Form("SplineWeights[%d]/D", (int)fValList.size()));
}
void SplineWriter::ReadWeightsFromTree(TTree *tr) {
tr->SetBranchAddress("SplineWeights", fWeightList);
}
void SplineWriter::AddCoefficientsToTree(TTree *tr) {
// Add only the fitted spline coefficients to the ttree
std::cout << "Saving Spline Coeff to TTree = "
<< Form("SplineCoeff[%d]/F", fNCoEff) << std::endl;
// sleep(1);
tr->Branch("SplineCoeff", fCoEffStorer, Form("SplineCoeff[%d]/F", fNCoEff));
}
void SplineWriter::SetupSplineSet() {
std::cout << "Setting up spline set" << std::endl;
fDrawSplines = FitPar::Config().GetParB("draw_splines");
// Create the coefficients double*
fNCoEff = 0;
for (size_t i = 0; i < fAllSplines.size(); i++) {
fNCoEff += fAllSplines[i].GetNPar();
}
fCoEffStorer = new float[fNCoEff];
std::cout << "NCoeff = " << fNCoEff << std::endl;
// Calculate the grid of parsets
// Setup the list of parameter coefficients.
std::vector<double> nomvals = fRW->GetDialValues();
fParVect.clear();
fSetIndex.clear();
fParVect.push_back(nomvals);
fSetIndex.push_back(0);
// fWeightList.push_back(1.0);
fValList.push_back(std::vector<double>(1, 0.0));
// Loop over all splines.
for (size_t i = 0; i < fAllSplines.size(); i++) {
// For each dial loop over all points within a given position
std::vector<double> newvals = nomvals;
std::vector<int>
pos; // = SplineUtils::GetSplitDialPositions(fRW, fSpline[i]);
std::vector<std::string> splitnames =
GeneralUtils::ParseToStr(fSpline[i], ";");
for (size_t j = 0; j < splitnames.size(); j++) {
int temppos = fRW->GetDialPos(splitnames[j]);
pos.push_back(temppos);
}
std::vector<std::vector<double> > vals =
SplineUtils::GetSplitDialPoints(fPoints[i]);
for (size_t j = 0; j < vals.size(); j++) {
for (size_t k = 0; k < pos.size(); k++) {
newvals[pos[k]] = vals[j][k];
}
fParVect.push_back(newvals);
fValList.push_back(vals[j]);
// fWeightList.push_back(1.0);
fSetIndex.push_back(i + 1);
}
}
fWeightList = new double[fValList.size()];
for (uint i = 0; i < fValList.size(); i++) {
fWeightList[i] = 1.0;
}
// Print out the parameter set
NUIS_LOG(FIT, "Parset | Index | Pars --- ");
for (size_t i = 0; i < fSetIndex.size(); i++) {
NUIS_LOGN(FIT, " Set " << i << ". | " << fSetIndex[i] << " | ");
if (LOG_LEVEL(FIT)) {
for (size_t j = 0; j < fParVect[i].size(); j++) {
NUIS_LOGN(FIT, " " << fParVect[i][j]);
}
NUIS_LOG(FIT, "");
}
}
}
void SplineWriter::GetWeightsForEvent(FitEvent *event) {
// Get Starting Weight
fRW->SetAllDials(&fParVect[0][0], fParVect[0].size());
double nomweight = fRW->CalcWeight(event);
event->RWWeight = nomweight;
if (fDrawSplines) {
std::cout << "Nominal Spline Weight = " << nomweight << std::endl;
}
fWeightList[0] = nomweight;
// Loop over parameter sets
for (size_t i = 1; i < fParVect.size(); i++) {
// Update FRW
fRW->SetAllDials(&fParVect[i][0], fParVect[i].size());
// Calculate a weight for event
double weight = fRW->CalcWeight(event);
if (weight >= 0.0 and weight < 200) {
// Fill Weight Set
fWeightList[i] = weight / nomweight;
if (fDrawSplines)
std::cout << "Calculating values from weight set " << i << " "
<< fParVect[i][0] << " = " << weight << " "
<< weight / nomweight << std::endl;
} else {
fWeightList[i] = 1.0;
}
}
}
void SplineWriter::GetWeightsForEvent(FitEvent *event, double *weights) {
// Get Starting Weight
fRW->SetAllDials(&fParVect[0][0], fParVect[0].size());
double nomweight = fRW->CalcWeight(event);
event->RWWeight = nomweight;
if (fDrawSplines) {
std::cout << "Nominal Spline Weight = " << nomweight << std::endl;
}
weights[0] = nomweight;
// Loop over parameter sets
for (size_t i = 1; i < fParVect.size(); i++) {
// Update FRW
fRW->SetAllDials(&fParVect[i][0], fParVect[i].size());
// Calculate a weight for event
double weight = fRW->CalcWeight(event);
if (weight >= 0.0 and weight < 200) {
// Fill Weight Set
weights[i] = weight / nomweight;
if (fDrawSplines)
std::cout << "Calculating values from weight set " << i << " "
<< fParVect[i][0] << " = " << weight << " "
<< weight / nomweight << std::endl;
} else {
weights[i] = 1.0;
}
fWeightList[i] = weights[i];
}
}
void SplineWriter::ReconfigureSet(int iset) {
fCurrentSet = iset;
fRW->SetAllDials(&fParVect[iset][0], fParVect[iset].size());
}
double SplineWriter::GetWeightForThisSet(FitEvent *event, int iset) {
if (iset != -1 and iset != fCurrentSet) {
ReconfigureSet(iset);
}
return fRW->CalcWeight(event);
}
void SplineWriter::SetWeights(double *weights) {
for (uint i = 0; i < fParVect.size(); i++) {
fWeightList[i] = weights[i];
}
}
void SplineWriter::FitSplinesForEvent(double *inputweights, float *coeff) {
int n = fAllSplines.size();
int coeffcount = 0;
for (int i = 0; i < n; i++) {
// DialVals
std::vector<std::vector<double> > dialvals;
std::vector<double> weightvals;
bool hasresponse = false;
for (size_t j = 0; j < fSetIndex.size(); j++) {
if (fSetIndex[j] != i + 1)
continue;
dialvals.push_back(fValList[j]);
double tempw = inputweights[j];
weightvals.push_back(tempw);
if (tempw != 1.0)
hasresponse = true;
}
// Perform Fit
if (hasresponse) {
// std::cout << "Fitting Coeff" << std::endl;
FitCoeff(&fAllSplines[i], dialvals, weightvals, &coeff[coeffcount],
fDrawSplines);
} else {
for (int j = 0; coeffcount + j < fNCoEff; j++) {
// std::cout << "Setting 0.0 response " << coeffcount + i << " " <<
// fNCoEff << std::endl;
coeff[coeffcount + j] = 0.0;
}
}
// std::cout << "Adding coeffcount" << std::endl;
// Offset coeffcount
coeffcount += (fAllSplines[i]).GetNPar();
}
// std::cout << "FitEvent" << std::endl;
return;
}
void SplineWriter::FitSplinesForEvent(TCanvas *fitcanvas, bool saveplot) {
// Loop over splines
// int count = 0;
int coeffcount = 0;
int n = fAllSplines.size();
std::vector<int> splinecounter;
for (int i = 0; i < n; i++) {
splinecounter.push_back(coeffcount);
coeffcount += fAllSplines[i].GetNPar();
}
// #pragma omp parallel for
for (int i = 0; i < n; i++) {
// Store X/Y Vals
std::vector<std::vector<double> > dialvals;
std::vector<double> weightvals;
bool hasresponse = false;
int npar = (fAllSplines[i]).GetNPar();
coeffcount = splinecounter[i];
for (size_t j = 0; j < fSetIndex.size(); j++) {
if (fSetIndex[j] != i + 1)
continue;
dialvals.push_back(fValList[j]);
double tempw = fWeightList[j];
weightvals.push_back(tempw);
if (tempw != 1.0)
hasresponse = true;
}
// Make a new graph and fit coeff if response
if (hasresponse) {
FitCoeff(&fAllSplines[i], dialvals, weightvals, &fCoEffStorer[coeffcount],
fDrawSplines);
} else {
for (int i = 0; i < npar; i++) {
fCoEffStorer[coeffcount + i] = 0.0;
}
}
}
// Check overrides
// if (saveplot) {
// coeffcount = 0;
// // Make new canvas to save stuff into
// if (fitcanvas) delete fitcanvas;
// fitcanvas = new TCanvas("c1", "c1", fAllSplines.size() * 400 , 600);
// fitcanvas->Divide(fAllSplines.size(), 1);
// // Clear out points
// for (size_t i = 0; i < fAllDrawnGraphs.size(); i++) {
// if (fAllDrawnGraphs[i]) delete fAllDrawnGraphs[i];
// if (fAllDrawnHists[i]) delete fAllDrawnHists[i];
// }
// fAllDrawnGraphs.clear();
// fAllDrawnHists.clear();
// for (size_t i = 0; i < fAllSplines.size(); i++) {
// fitcanvas->cd(i + 1);
// // Store X/Y Vals
// std::vector<std::vector<double> > dialvals;
// std::vector<double> weightvals;
// bool hasresponse = false;
// int npar = (fAllSplines[i]).GetNPar();
// for (size_t j = 0; j < fSetIndex.size(); j++) {
// if ((UInt_t)fSetIndex[j] != (UInt_t)i + 1) continue;
// dialvals.push_back(fValList[j]);
// weightvals.push_back(fWeightList[j] - 0.0);
// if (fWeightList[j] != 1.0) hasresponse = true;
// }
// if (hasresponse) {
// TGraph* gr = new TGraph(dialvals.size(), dialvals, weightvals);
// fAllDrawnGraphs.push_back(gr);
// // Get XMax Min
// int n = xvals.size();
// double xmin = 99999.9;
// double xmax = -99999.9;
// for (int j = 0; j < n; j++) {
// if (xvals[j] > xmax) xmax = xvals[j];
// if (xvals[j] < xmin) xmin = xvals[j];
// }
// TH1D* hist = new TH1D("temp", "temp", 100, xmin, xmax);
// fAllDrawnHists.push_back(hist);
// for (int k = 0; k < 100; k++) {
// double xtemp = hist->GetXaxis()->GetBinCenter(k + 1);
// fAllSplines[i].Reconfigure(xtemp);
// double ytemp = fAllSplines[i].DoEval(&fCoEffStorer[coeffcount]);
// hist->SetBinContent(k + 1, ytemp);
// }
// // gr->Draw("APL");
// hist->SetLineColor(kRed);
// hist->Draw("HIST C");
// hist->SetTitle("Spline Response");
// // hist->GetYaxis()->SetRangeUser(0.0, 3.0);
// // gStyle->SetOptStat(0);
// hist->SetStats(0);
// gr->SetMarkerStyle(20);
// gr->SetTitle("True Weight Points");
// gr->Draw("P SAME");
// gPad->BuildLegend(0.6, 0.6, 0.85, 0.85);
// gPad->Update();
// hist->SetTitle(fSpline[i].c_str());
// hist->GetXaxis()->SetTitle("Dial Variation");
// hist->GetYaxis()->SetTitle("Event Weight");
// fitcanvas->Update();
// }
// coeffcount += npar;
// }
// }
}
// Fitting
// ----------------------------------------------
void SplineWriter::FitCoeff(Spline *spl, std::vector<std::vector<double> > &v,
std::vector<double> &w, float *coeff, bool draw) {
std::vector<double> x;
std::vector<double> y;
std::vector<double> z;
for (size_t i = 0; i < v.size(); i++) {
x.push_back(v[i][0]);
if (v[i].size() > 1)
y.push_back(v[i][1]);
if (v[i].size() > 2)
z.push_back(v[i][2]);
}
switch (spl->GetType()) {
// Polynominal Graph Fits
case k1DPol1:
case k1DPol2:
case k1DPol3:
case k1DPol4:
case k1DPol5:
case k1DPol6:
FitCoeff1DGraph(spl, v.size(), &x[0], &w[0], coeff, draw);
break;
case k1DTSpline3:
GetCoeff1DTSpline3(spl, x.size(), &x[0], &w[0], coeff, draw);
break;
case k2DPol6:
case k2DGaus:
case k2DTSpline3:
FitCoeff2DGraph(spl, v.size(), &x[0], &y[0], &w[0], coeff, draw);
break;
default:
break;
}
#ifdef __MINUIT2_ENABLED__
if (fDrawSplines) {
fSplineFCNs[spl] = new SplineFCN(spl, v, w);
fSplineFCNs[spl]->SaveAs("mysplinetest_" + spl->GetName() + ".pdf", coeff);
sleep(1);
delete fSplineFCNs[spl];
}
#endif
}
void SplineWriter::FitCoeff1DGraph(Spline *spl, int n, double *x, double *y,
float *coeff, bool draw) {
TGraph *gr = new TGraph(n, x, y);
double xmin = 99999.9;
double xmax = -99999.9;
for (int i = 0; i < n; i++) {
if (x[i] > xmax)
xmax = x[i];
if (x[i] < xmin)
xmin = x[i];
}
double xwidth = xmax - xmin;
xmin = xmin - xwidth * 0.01;
xmax = xmax + xwidth * 0.01;
// Create a new function for fitting.
TF1 *func = spl->GetFunction();
// Run the actual spline fit
StopTalking();
// If linear fit with two points
if (n == 2 and spl->GetType() == k1DPol1) {
float m = (y[1] - y[0]) / (x[1] - x[0]);
float c = y[0] - (0.0 - x[0]) * m;
func->SetParameter(0, c);
func->SetParameter(1, m);
} else if (spl->GetType() == k1DPol1) {
gr->Fit(func, "WQ");
} else {
gr->Fit(func, "FMWQ");
}
StartTalking();
for (int i = 0; i < spl->GetNPar(); i++) {
coeff[i] = func->GetParameter(i);
}
if (draw) {
gr->Draw("APL");
gPad->Update();
gPad->SaveAs(("plot_test_" + spl->GetName() + ".pdf").c_str());
std::cout << "Saving Graph" << std::endl;
sleep(3);
}
// delete func;
delete gr;
}
double SplineFCN::operator()(const double *x) const { return DoEval(x); }
double SplineFCN::DoEval(const double *x) const {
float *fx = new float[fSpl->GetNPar()];
for (int i = 0; i < fSpl->GetNPar(); i++) {
fx[i] = x[i];
} //
double tot = 0;
for (size_t i = 0; i < fVal.size(); i++) {
int nonzero = 0;
for (size_t j = 0; j < fVal[i].size(); j++) {
fSpl->Reconfigure(fVal[i][j], j);
// std::cout << "Reconfiguring " << fVal[i][j] << " " << j << std::endl;
if (fVal[i][j] != 0.0)
nonzero++;
}
if (uncorrelated and nonzero > 1)
continue;
double w = fSpl->DoEval(fx);
double wdif = (w - fWeight[i]); // / (fWeight[i] * 0.05);
tot += sqrt(wdif * wdif);
}
// delete fx;
return tot;
}
void SplineFCN::UpdateWeights(std::vector<double> &w) {
for (uint i = 0; i < w.size(); i++) {
fWeight[i] = w[i];
}
}
void SplineFCN::SetCorrelated(bool state) { uncorrelated = !state; }
void SplineFCN::SaveAs(std::string name, const float *fx) {
if (fVal[0].size() > 2) {
TCanvas *c1 = new TCanvas("c1", "c1", 800, 600);
c1->Divide(2, 1);
TH1D *histmc =
new TH1D("hist", "hist", fVal.size(), 0.0, double(fVal.size()));
TH1D *histdt =
new TH1D("histdt", "histdt", fVal.size(), 0.0, double(fVal.size()));
for (size_t i = 0; i < fVal.size(); i++) {
for (size_t j = 0; j < fVal[i].size(); j++) {
fSpl->Reconfigure(fVal[i][j], j);
}
histmc->SetBinContent(i + 1, fSpl->DoEval(fx));
histdt->SetBinContent(i + 1, fWeight[i]);
}
// histmc->Add(histdt,-1.0);
c1->cd(1);
histmc->SetTitle("Spline;Parameter Set;Weight");
histmc->Draw("HIST");
histdt->SetLineColor(kRed);
histdt->Draw("SAME HIST");
c1->cd(2);
TH1D *histdif = (TH1D *)histmc->Clone();
histdif->Add(histdt, -1.0);
histdif->Draw("HIST");
c1->Update();
c1->SaveAs(name.c_str());
delete c1;
} else if (fVal[0].size() == 2) {
TGraph2D *histmc = new TGraph2D();
TGraph2D *histdt = new TGraph2D();
TGraph2D *histdif = new TGraph2D();
for (size_t i = 0; i < fVal.size(); i++) {
for (size_t j = 0; j < fVal[i].size(); j++) {
fSpl->Reconfigure(fVal[i][j], j);
}
histmc->SetPoint(histmc->GetN(), fVal[i][0], fVal[i][1],
fSpl->DoEval(fx));
histdt->SetPoint(histdt->GetN(), fVal[i][0], fVal[i][1], fWeight[i]);
histdif->SetPoint(histdif->GetN(), fVal[i][0], fVal[i][1],
fabs(fSpl->DoEval(fx) - fWeight[i]));
}
TCanvas *c1 = new TCanvas("c1", "c1", 800, 600);
c1->Divide(3, 1);
c1->cd(1);
histmc->SetTitle(("Spline;" + fSpl->GetName()).c_str());
histmc->Draw("COLZ");
gPad->Update();
c1->cd(2);
histdt->SetTitle(("Raw;" + fSpl->GetName()).c_str());
histdt->Draw("COLZ");
c1->cd(3);
histdif->SetTitle(("Dif;" + fSpl->GetName()).c_str());
histdif->Draw("COLZ");
gPad->SetRightMargin(0.15);
// gPad->SetLogz(1);
gPad->Update();
c1->SaveAs(name.c_str());
delete c1;
} else if (fVal[0].size() == 1) {
TGraph *histmc = new TGraph();
TGraph *histdt = new TGraph();
TGraph *histdif = new TGraph();
for (size_t i = 0; i < fVal.size(); i++) {
for (size_t j = 0; j < fVal[i].size(); j++) {
fSpl->Reconfigure(fVal[i][j], j);
}
histmc->SetPoint(histmc->GetN(), fVal[i][0], fSpl->DoEval(fx));
histdt->SetPoint(histdt->GetN(), fVal[i][0], fWeight[i]);
histdif->SetPoint(histdif->GetN(), fVal[i][0],
fabs(fSpl->DoEval(fx) - fWeight[i]));
}
TCanvas *c1 = new TCanvas("c1", "c1", 800, 600);
c1->Divide(2, 1);
c1->cd(1);
histmc->SetTitle(("Spline;" + fSpl->GetName()).c_str());
histmc->Draw("AC");
histmc->SetLineColor(kRed);
histdt->SetTitle(("Raw;" + fSpl->GetName()).c_str());
histdt->Draw("SAME P");
histdt->SetMarkerStyle(20);
gPad->Update();
c1->cd(2);
histdif->SetTitle(("Dif;" + fSpl->GetName()).c_str());
histdif->Draw("APL");
gPad->Update();
c1->SaveAs(name.c_str());
delete c1;
}
// gPad->SaveAs(name.c_str());
}
void SplineWriter::FitCoeff2DGraph(Spline *spl, int n, double *x, double *y,
double *w, float *coeff, bool draw) {
+#ifdef __USE_OPENMP__
#pragma omp critical
+#endif
{
TF2 *f2 = (TF2 *)spl->GetFunction();
TGraph2D *histmc = new TGraph2D(n, x, y, w);
f2->SetNpx(400);
StopTalking();
histmc->Fit(f2, "FMWQ");
StartTalking();
for (int i = 0; i < spl->GetNPar(); i++) {
coeff[i] = f2->GetParameter(i);
}
// delete f2;
delete histmc;
}
}
void SplineWriter::FitCoeffNDGraph(Spline *spl,
std::vector<std::vector<double> > &v,
std::vector<double> &w, float *coeff,
bool draw) {
#ifdef __MINUIT2_ENABLED__
if (fSplineFunctors.find(spl) != fSplineFunctors.end()) {
delete fSplineFunctors[spl];
fSplineFunctors.erase(spl);
}
if (fSplineFCNs.find(spl) != fSplineFCNs.end()) {
delete fSplineFCNs[spl];
fSplineFCNs.erase(spl);
}
if (fSplineMinimizers.find(spl) != fSplineMinimizers.end()) {
delete fSplineMinimizers[spl];
fSplineMinimizers.erase(spl);
}
if (fSplineMinimizers.find(spl) == fSplineMinimizers.end()) {
std::cout << "Building new ND minimizer for " << spl << std::endl;
fSplineFCNs[spl] = new SplineFCN(spl, v, w);
// fSplineFCNs[spl] = new SplineFCN(spl, v, w);
fSplineFunctors[spl] =
new ROOT::Math::Functor(*fSplineFCNs[spl], spl->GetNPar());
fSplineMinimizers[spl] =
ROOT::Math::Factory::CreateMinimizer("Minuit2", "Combined");
fSplineMinimizers[spl]->SetMaxFunctionCalls(1E8);
fSplineMinimizers[spl]->SetMaxIterations(1E8);
fSplineMinimizers[spl]->SetTolerance(1.E-6);
fSplineMinimizers[spl]->SetStrategy(2);
for (int j = 0; j < spl->GetNPar(); j++) {
fSplineMinimizers[spl]->SetVariable(j, Form("Par_%i", j), 0.1, 0.1);
}
}
// Create a new function for fitting.
// StopTalking();
// Update FCN
fSplineFCNs[spl]->UpdateWeights(w);
// fSplineMinimizers[spl]->SetDefaultOptions();
// fSplineMinimizers[spl]->Clear();
for (int j = 0; j < spl->GetNPar(); j++) {
if (j != 0) {
fSplineMinimizers[spl]->SetVariableValue(j, 0.1);
// fSplineMinimizers[spl]->SetParameter(j, Form("Par_%i", j), 0.1, 0.1,
// -100.0, 100.0 );
// fSplineMinimizers[spl]->SetVariableValue(j, 0.1);
}
}
// fSplineFCNs[spl]->SetCorrelated(false);
// fSplineFunctors[spl] = new ROOT::Math::Functor( *fSplineFCNs[spl],
// spl->GetNPar() );
// fSplineMinimizers[spl]->SetFunction(*fSplineFunctors[spl]);
// fSplineMinimizers[spl]->Minimize();
fSplineFCNs[spl]->SetCorrelated(true);
delete fSplineFunctors[spl];
fSplineFunctors[spl] =
new ROOT::Math::Functor(*fSplineFCNs[spl], spl->GetNPar());
fSplineMinimizers[spl]->SetFunction(*fSplineFunctors[spl]);
// ((TFitterMinuit*)fSplineMinimizers[spl])->CreateMinimizer(TFitterMinuit::kMigrad);
fSplineMinimizers[spl]->Minimize();
fSplineMinimizers[spl]->Minimize();
// ((TFitterMinuit*)fSplineMinimizers[spl])->CreateMinimizer(TFitterMinuit::kMigrad);
// fSplineMinimizers[spl]->Minimize();
// delete minimizer;
// StartTalking();
// Now Get Parameters
const double *values = fSplineMinimizers[spl]->X();
for (int i = 0; i < spl->GetNPar(); i++) {
std::cout << "Updated Coeff " << i << " " << values[i] << std::endl;
coeff[i] = values[i];
}
// Save a sample
fSplineFCNs[spl]->SaveAs("mysplinetest_" + spl->GetName() + ".pdf", coeff);
sleep(1);
// delete values;
// delete minimizer;
#endif
}
// Spline extraction Functions
void SplineWriter::GetCoeff1DTSpline3(Spline *spl, int n, double *x, double *y,
float *coeff, bool draw) {
StopTalking();
TSpline3 temp_spline = TSpline3("temp_spline", x, y, n);
StartTalking();
for (size_t i = 0; i < (UInt_t)n; i++) {
double a, b, c, d, e;
temp_spline.GetCoeff(i, a, b, c, d, e);
coeff[i * 4] = y[i];
coeff[i * 4 + 1] = c;
coeff[i * 4 + 2] = d;
coeff[i * 4 + 3] = e;
}
if (draw) {
TGraph *gr = new TGraph(n, x, y);
temp_spline.Draw("CA");
gr->Draw("PL SAME");
gPad->Update();
gPad->SaveAs(("plot_test_" + spl->GetName() + ".pdf").c_str());
delete gr;
}
return;
}
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Tue, Sep 30, 5:43 AM (5 h, 51 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
6566291
Default Alt Text
(22 KB)
Attached To
Mode
rNUISANCEGIT nuisancegit
Attached
Detach File
Event Timeline
Log In to Comment