Matrix<double> BspCurvBasisFuncSet::CreateMatrixIntegral(int lev) const
{
KnotSet kset = KnotSet(*kts,ord,num).CreateKnotSetDeriv(lev);
Matrix<double> mat(kset.GetNum()-(ord-lev),kset.GetNum()-(ord-lev));
BspCurvBasisFuncSet basis(kset.GetKnots(),ord-lev,kset.GetNum());
Matrix<double> mat1(kset.GetNum()-ord+lev,kset.GetNum()-ord+lev,0.0);
for (int i=0; i<kset.GetNum()-ord+lev; i++)
for (int j=0; j<=i; j++) {
// create the two std::sets representing the two knot std::sets
Vector<double> temp1((*(basis.b))[i].GetKnots());
Vector<double> temp2((*(basis.b))[j].GetKnots());
std::set<double> s1(temp1.begin(),temp1.end());
std::set<double> s2(temp2.begin(),temp2.end());
// if there is an intersection
if (*(--s2.end()) > *(s1.begin())) {
// form the intersection
std::set<double> s3;
std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),std::inserter(s3,s3.begin()));
// if there is an intersection
if (s3.size() > 1) {
Vector<double> v(s3.size());
std::set<double>::iterator s = s3.begin();
// copy the elements into a vector
for (unsigned int k=0; k<s3.size(); k++) v[k] = *s++;
// create the compbezcurvs
Vector<BezCurv<double> > vec1(s3.size()-1);
Vector<BezCurv<double> > vec2(s3.size()-1);
BspCurv<double> b1((*(basis.b))[i].GetBspCurv()), b2((*(basis.b))[j].GetBspCurv());
// find the segments of intersection
for (unsigned int k=0; k<s3.size()-1; k++) {
int segb1 = b1.GetKnotSet().Find_segment(v[k]);
int segb2 = b2.GetKnotSet().Find_segment(v[k]);
vec1[k] = b1.GetSegment(segb1);
vec2[k] = b2.GetSegment(segb2);
}
CompBezCurv<double> cb1(vec1,s3.size()-1,v);
CompBezCurv<double> cb2(vec2,s3.size()-1,v);
CompBezCurv<double> prod = cb1.Product(cb2);
mat1[i][j] = prod.ConvertBspCurv().Integrate((*kts)[ord-1],(*kts)[num-ord]);
}
}
}
for (int i=0; i<kset.GetNum()-ord+lev-1; i++)
for (int j=i+1; j<kset.GetNum()-ord+lev; j++) mat1[i][j] = mat1[j][i];
return mat1;
}
void iterator_invalidation_test() {
#if !defined(NDEBUG) && !defined(BOOST_CB_DISABLE_DEBUG)
cb_space_optimized cb1(10, 1);
cb1.push_back(2);
cb1.push_back(3);
cb1.push_back(4);
cb_space_optimized::iterator it1 = cb1.end();
cb_space_optimized::const_iterator it2 = cb1.begin();
cb_space_optimized::iterator it3 = cb1.begin() + 6;
cb1.set_capacity(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.rset_capacity(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.resize(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
it1 = cb1.end();
it2 = cb1.begin();
it3 = cb1.begin() + 6;
cb1.rresize(10);
BOOST_CHECK(it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
{
cb_space_optimized cb2(10, 1);
cb2.push_back(2);
cb2.push_back(3);
cb2.push_back(4);
it1 = cb2.end();
it2 = cb2.begin();
it3 = cb2.begin() + 6;
}
BOOST_CHECK(!it1.is_valid(&cb1));
BOOST_CHECK(!it2.is_valid(&cb1));
BOOST_CHECK(!it3.is_valid(&cb1));
#endif // #if !defined(NDEBUG) && !defined(BOOST_CB_DISABLE_DEBUG)
}
void Test_M2MInterfaceImpl::test_set_queue_sleep_handler()
{
callback_handler cb(this,&Test_M2MInterfaceImpl::test_callback_handler);
impl->set_queue_sleep_handler(cb);
CHECK(impl->_callback_handler != NULL);
callback_handler cb1(NULL);
impl->set_queue_sleep_handler(cb1);
CHECK(impl->_callback_handler == NULL);
}
/**
* Test per verificare il funzionamento dei const_iterator con procedure d'appoggio
*/
void testConstIterator() {
cbuffer<float> cb(5);
cb.insert(2.1);
cb.insert(1.5);
cb.insert(3.0);
stampaIterator(cb);
cbuffer<float> cb1(4,3);
confrontoIterator(cb,cb1); //da testare con assert(bg!=bg1) in confrontoIterator
//confrontoIterator(cb,cb); //da testare con assert(bg==bg1) in confrontoIterator
}
int main()
{
cb1(f1);
cb2(f2);
return 0;
}
/**
* Test per verificare il funzionamento degli iterator
*/
void testIterator(){
cbuffer<int> cb(10,1);
cb.insert(3);
cb.insert(1);
cb.insert(2);
cbuffer<int>::iterator bg=cb.begin();
cbuffer<int>::iterator fn=cb.end();
std::cout << cb << std::endl;
int i=1;
assert(bg!=fn);
cb.del();
bg=cb.begin();
fn=cb.end();
while(bg!=fn){
*bg=i++;
std::cout << *bg << " ";
bg++;
}
std::cout << std::endl << "size: " << cb.get_size() << " items: " << cb.get_items() << std::endl << std::endl;
cbuffer<std::string> cb1(5);
cb1.insert("ciao");
cb1.insert("come");
cb1.insert("stai");
cb1.insert("?");
cb1.insert("bene");
cbuffer<std::string>::iterator bg1=cb1.begin();
cbuffer<std::string>::iterator fn1=cb1.end();
assert(bg1!=fn1);
while(bg1!=fn1){
std::cout << *bg1 << " ";
bg1++;
}
std::cout << std::endl << "size: " << cb1.get_size() << " items: " << cb1.get_items() << std::endl << std::endl;
cbuffer<double> cb2(10);
cbuffer<double>::iterator bg2=cb2.begin();
cbuffer<double>::iterator fn2=cb2.end();
assert(bg2==fn2);
cb2.insert(3.8);
cb2.insert(1.9);
cb2.insert(2.5);
bg2=cb2.begin();
fn2=cb2.end();
while(bg2!=fn2){
std::cout << *bg2 << " ";
bg2++;
}
std::cout << std::endl << "size: " << cb2.get_size() << " items: " << cb2.get_items() << std::endl;
}
/**
* Test sull'uso dei costruttori della classe cbuffer. In totale creo 5 cbuffer.
*/
void testCostructor(){
cbuffer<double> cb(10, 1.2);
cbuffer<int> cb2(11,3);
std::cout << "size: "<<cb.get_size()<<" items: "<<cb.get_items()<<" //" << cb << std::endl;
std::cout << "size: "<<cb2.get_size()<<" items: "<<cb2.get_items()<<" //" << cb2 << std::endl;
cb=cb2;
cbuffer<double> cb3(cb2);
std::cout << "size: "<<cb.get_size()<<" items: "<<cb.get_items()<<" //" << cb << std::endl;
std::cout << "size: "<<cb3.get_size()<<" items: "<<cb3.get_items()<<" //" << cb3 << std::endl;
cbuffer<char> cb1(5,'a');
cbuffer<char> cb4(cb1);
std::cout << "size: "<<cb4.get_size()<<" items: "<<cb4.get_items()<<" //" << cb4 << std::endl;
}
/**
* Test per verificare il corretto funzionamento della funzione globale check
*/
void testCheck(){
predicato pred;
cbuffer<int> cb(10,2);
cb[0]=1;
check(cb, pred);
cbuffer<double> cb1(10,2.5);
cb1[2]=6;
check(cb1, pred);
cbuffer<std::string> cb2(10,"bomber");
check(cb2, pred);
cbuffer<char> cb3(10,'x');
cb3.insert('a');
cb3[0]='e';
cb3[6]='u';
check(cb3,pred);
}
void TestSymDiv_E2(tmv::DivType dt, PosDefCode pdc)
{
const int N = 10;
std::vector<tmv::SymMatrixView<T> > s;
std::vector<tmv::SymMatrixView<std::complex<T> > > cs;
MakeSymList(s,cs,pdc);
tmv::Matrix<T> a1(N,N);
for (int i=0; i<N; ++i) for (int j=0; j<N; ++j) a1(i,j) = T(1-3*i+j);
a1.diag().addToAll(T(10)*N);
a1 /= T(10);
tmv::Matrix<std::complex<T> > ca1 = a1 * std::complex<T>(3,-4);
tmv::BandMatrix<T> b1(a1,1,3);
tmv::BandMatrix<std::complex<T> > cb1(ca1,1,3);
tmv::BandMatrix<T> b1v = b1.view();
tmv::BandMatrix<std::complex<T> > cb1v = cb1.view();
#if (XTEST & 2)
tmv::BandMatrix<T> b3(a1.colRange(0,N-2),1,3);
tmv::BandMatrix<std::complex<T> > cb3(ca1.colRange(0,N-2),1,3);
tmv::BandMatrix<T> b4(a1.rowRange(0,N-2),1,3);
tmv::BandMatrix<std::complex<T> > cb4(ca1.rowRange(0,N-2),1,3);
tmv::BandMatrix<T> b3v = b3.view();
tmv::BandMatrix<std::complex<T> > cb3v = cb3.view();
tmv::BandMatrix<T> b4v = b4.view();
tmv::BandMatrix<std::complex<T> > cb4v = cb4.view();
#endif
for(size_t i=START;i<s.size();i++) {
if (showstartdone)
std::cout<<"Start loop: i = "<<i<<", si = "<<tmv::TMV_Text(s[i])<<
" "<<s[i]<<std::endl;
tmv::SymMatrixView<T> si = s[i];
tmv::SymMatrixView<std::complex<T> > csi = cs[i];
TestMatrixDivArith1(dt,b1v,si,cb1v,csi,"Sym/SquareBandMatrix");
if (dt == tmv::LU) continue;
#if (XTEST & 2)
TestMatrixDivArith1(dt,b3v,si,cb3v,csi,"Sym/NonSquareBandMatrix");
TestMatrixDivArith1(dt,b4v,si,cb4v,csi,"Sym/NonSquareBandMatrix");
#endif
}
}
/* 55 */
int sio2_func1(s32 *arg)
{
int i, ret = 1;
if (cb1)
return cb1(arg);
for (i = 0; i < 4; i++, arg++) {
if ((*arg + 1) < 2)
arg[4] = 1;
else {
arg[4] = 0;
ret = 0;
}
}
return ret;
}
int main()
{
A a;
B b;
C c;
std::shared_ptr<A> ca1(a.clone());
std::shared_ptr<A> cb1(b.clone());
std::shared_ptr<A> cc1(c.clone());
ca1->tell();
cb1->tell();
cc1->tell();
std::shared_ptr<A> ca2(ca1->clone());
std::shared_ptr<A> cb2(cb1->clone());
std::shared_ptr<A> cc2(cc1->clone());
ca2->tell();
cb2->tell();
cc2->tell();
return 0;
}
// min_capacity test (it is useful to use a debug tool)
void min_capacity_test() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
cb_space_optimized cb1(capacity_ctrl(10, 10));
cb_space_optimized cb2(capacity_ctrl(10, 5), 1);
cb_space_optimized cb3(capacity_ctrl(20, 10), v.begin(), v.end());
BOOST_CHECK(cb1.size() == 0);
BOOST_CHECK(cb1.capacity().capacity() == 10);
BOOST_CHECK(cb1.capacity().min_capacity() == 10);
BOOST_CHECK(cb2[0] == 1);
BOOST_CHECK(cb2.size() == 10);
BOOST_CHECK(cb2.capacity() == 10);
BOOST_CHECK(cb2.capacity().min_capacity() == 5);
BOOST_CHECK(cb3[0] == 1);
BOOST_CHECK(cb3.size() == 5);
BOOST_CHECK(cb3.capacity() == 20);
BOOST_CHECK(cb3.capacity().min_capacity() == 10);
BOOST_CHECK(cb1.capacity().min_capacity() <= cb1.internal_capacity());
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
cb2.erase(cb2.begin() + 2, cb2.end());
BOOST_CHECK(cb2.size() == 2);
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
cb2.clear();
cb3.clear();
BOOST_CHECK(cb2.empty());
BOOST_CHECK(cb3.empty());
BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
}
/**
* Test per verificare la corretta esecuzione di vari metodi fondamentali. (utilizzo
* di stampa come procedura d'appoggio).
*/
void testValueGetSetOperator(){
cbuffer<int> cb1(5);
cbuffer<float> cb2(4,2.2);
cbuffer<std::string> cb3(3,"stringa");
std::cout << "test get_size() e get_items(): " << std::endl;
std::cout << "cb1 size: " << cb1.get_size() << std::endl;
std::cout << "cb2 size: " << cb2.get_size() << std::endl;
std::cout << "cb3 size: " << cb3.get_size() << std::endl;
std::cout << "cb1 items: " << cb1.get_items() << std::endl;
std::cout << "cb2 items: " << cb2.get_items() << std::endl;
std::cout << "cb3 items: " << cb3.get_items() << std::endl;
std::cout << "test get_cbuffer(size_type) e set_cbuffer(size_type, const &T):" << std::endl;
cb2.set_cbuffer(3, 4);
std::cout << "cb2[3] set 4 " << std::endl;
std::cout << "cb2[3] get: " << cb2.get_cbuffer(3) << std::endl;
std::cout << "test T& value(size_type index):" << std::endl;
cb3.value(0)="fiorellino";
std::cout << "scrittura cb3.value(0)"<< std::endl;
std::cout << "lettura cb3.value(0)= " << cb3.value(0) << std::endl;
std::cout << "test operator[]" << std::endl;
cb3[2]="alberello";
std::cout << "scrittura cb3[2] " << std::endl;
std::cout << "lettra cb3[2] " << cb3[2] << std::endl;
std::cout << "stampa(const cbuffer<int>)" << std::endl;
cbuffer<int> cb4(6);
cb4.insert(1);
cb4.insert(2);
cb4.insert(3);
cb4.insert(4);
std::cout << cb4 << std::endl;
stampa(cb4);
}
void BDT_cuts_norm(){
gROOT->ProcessLine(".L ~/cern/project/lhcbStyle.C");
lhcbStyle();
const std::string filename("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/normalisation_samples/Lb2JpsipK_2011_2012_signal_withbdt.root");
const std::string treename = "withbdt";
const std::string filenameMC("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/normalisation_samples/Lb2JpsipK_MC_2011_2012_norm_withbdt.root");
TFile* file = TFile::Open( filename.c_str() );
if( !file ) std::cout << "file " << filename << " does not exist" << std::endl;
TTree* tree = (TTree*)file->Get( treename.c_str() );
if( !tree ) std::cout << "tree " << treename << " does not exist" << std::endl;
TFile* fileMC = TFile::Open( filenameMC.c_str() );
if( !fileMC ) std::cout << "file " << filenameMC << " does not exist" << std::endl;
TTree* treeMC = (TTree*)fileMC->Get( treename.c_str() );
if( !treeMC ) std::cout << "tree " << treename << " does not exist" << std::endl;
// -- signal, mass shape
RooRealVar Lambda_b0_DTF_MASS_constr1("Lambda_b0_DTF_MASS_constr1","m(J/#psi pK^{-})", 5550., 5700., "MeV/c^{2}");
RooRealVar Jpsi_M("Jpsi_M","m(#mu#mu)", 3000., 3200., "MeV/c^{2}");
RooRealVar chi_c_M("chi_c_M","m(J/#psi#gamma)", 3400., 3700., "MeV/c^{2}");
RooRealVar mean("mean","mean", 5630., 5610., 5650.);
RooRealVar sigma1("sigma1","sigma1", 10., 1., 100.);
RooRealVar sigma2("sigma2","sigma2", 30.0, 5.0, 300.0);
RooRealVar alpha1("alpha1","alpha1", 1.0, 0.5, 5.0);
RooRealVar n1("n1","n1", 1.8, 0.2, 15.0);
RooRealVar alpha2("alpha2","alpha2", -0.5, -5.5, 0.0);
RooRealVar n2("n2","n2", 0.7, 0.2, 10.0);
//RooRealVar bkgcat_chic("bkgcat_chic","bkgcat_chic", 0, 100);
RooRealVar bdtg3("bdtg3", "bdtg3", -1.0, 1.0);
RooRealVar frac2("frac2","frac2", 0.3, 0., 1.);
RooGaussian gauss1("gauss1","gauss1", Lambda_b0_DTF_MASS_constr1, mean, sigma1);
RooGaussian gauss2("gauss2","gauss2", Lambda_b0_DTF_MASS_constr1, mean, sigma2);
RooCBShape cb1("cb1","cb1", Lambda_b0_DTF_MASS_constr1, mean, sigma1, alpha1, n1);
RooCBShape cb2("cb2","cb2", Lambda_b0_DTF_MASS_constr1, mean, sigma2, alpha2, n2);
RooAddPdf sig("sig", "sig", RooArgList(cb1, cb2), RooArgList( frac2 ));
RooRealVar cbRatio("cbRatio","cb Ratio", 0.8, 0.1, 1.0);
RooRealVar sigYield("sigYield","sig Yield", 4e2, 1e0, 1e6);
RooRealVar bgYield("bgYield","bg Yield", 1e4, 1e0, 1e6);
//put in values from fit_MC here <<--- DON'T FORGET TO CHANGE THESE IF THE FIT CHANGES!!!
/*
EXT PARAMETER INTERNAL INTERNAL
NO. NAME VALUE ERROR STEP SIZE VALUE
1 alpha1 2.18020e+00 2.85078e-02 1.38432e-04 -2.56034e-01
2 alpha2 -2.79102e+00 6.74385e-02 1.51818e-04 -1.49177e-02
3 cbRatio 3.07172e-01 1.49204e-02 1.72642e-04 -5.69984e-01
4 mean 5.61985e+03 9.58397e-03 5.56682e-05 -9.66293e-02
5 n1 1.49358e+00 8.14447e-02 2.09300e-04 -9.70542e-01
6 n2 1.45276e+00 1.09864e-01 2.59028e-04 -8.39538e-01
7 sigma1 8.46303e+00 1.32851e-01 2.86985e-05 -1.01453e+00
8 sigma2 4.93976e+00 3.42842e-02 5.03572e-06 -1.44512e+00
*/
alpha1.setVal( 2.18020e+00 );
alpha2.setVal( -2.79102e+00 );
n1.setVal( 1.49358e+00 );
n2.setVal( 1.45276e+00 );
frac2.setVal( 3.07172e-01 );
sigma1.setVal( 8.46303e+00 );
sigma2.setVal( 4.93976e+00 );
alpha1.setConstant( true );
alpha2.setConstant( true );
frac2.setConstant( true );
n1.setConstant( true );
n2.setConstant( true );
sigma1.setConstant( true );
sigma2.setConstant( true );
// -- bg, mass shape
RooRealVar a1("a1","a1", -0.1, -0.5, 0.5);
RooChebychev comb("comb","comb", Lambda_b0_DTF_MASS_constr1, a1);
RooRealVar mean3("mean3","mean3", 5560., 5500., 5600.);
RooRealVar sigma3("sigma3","sigma3", 5., 1., 10.);
RooRealVar frac3("frac3","frac", 0.2, 0.0, 0.3);
RooGaussian gauss3("gauss3","gauss3", Lambda_b0_DTF_MASS_constr1, mean3, sigma3);
//RooAddPdf bg("bg","bg", RooArgList(comb), RooArgList(frac3));
// -- add signal & bg
RooAddPdf pdf("pdf", "pdf", RooArgList(sig, comb), RooArgList( sigYield, bgYield));
double efficiencies1[40];
double efficiencies1_error[40];
double bdt_cuts[40];
double efficiencies2[40];
double efficiencies2_error[40];
double sideband_bg_val[40];
double MC_pre = treeMC->GetEntries();
double effvals[40];
//loop starting here
for(int i=0; i < 40; i=i+1) {
double cut_val = -1.0 + i*0.05;
//double cut_val = -1.0; // testing
bdt_cuts[i] = cut_val;
std::stringstream c;
c << "bdtg3" << " >= " << cut_val;
const std::string cut = c.str();
//std::cout << cut;
RooArgSet obs;
obs.add(Lambda_b0_DTF_MASS_constr1);
//obs.add(chi_c_Mp);
//obs.add(mass_pK);
obs.add(Jpsi_M);
obs.add(chi_c_M);
obs.add(bdtg3);
RooDataSet ds("ds","ds", obs, RooFit::Import(*tree), RooFit::Cut(cut.c_str()));
RooPlot* plot = Lambda_b0_DTF_MASS_constr1.frame();
RooFitResult * result = pdf.fitTo( ds, RooFit::Extended() );
double sig_val = sigYield.getVal();
double bg_val = bgYield.getVal();
double sig_error = sigYield.getError();
double bg_error = bgYield.getError();
double efficiency1 = (sig_val)/(sqrt(sig_val + bg_val));
efficiencies1[i] = efficiency1;
double efficiency1_error_sq = (pow(sig_error,2)/(sig_val+bg_val) + (pow(sig_val,2)*(pow(sig_error,2)+pow(bg_error,2))/(4*pow((sig_val+bg_val),3))));
double efficiency1_error = sqrt(efficiency1_error_sq);
efficiencies1_error[i] = efficiency1_error;
/*
double MC_post = treeMC->GetEntries(cut.c_str());
double eff_val = MC_post/MC_pre;
//something here to get the sideband background count
Lambda_b0_DTF_MASS_constr1.setRange("R", 5650., 5700.);
RooFitResult * sideband = bg.fitTo( ds, RooFit::Range("R") );
sideband->Print();
Lambda_b0_DTF_MASS_constr1.setRange("R", 5650., 5700.);
RooAbsReal* integral = pdf.createIntegral(Lambda_b0_DTF_MASS_constr1, RooFit::Range("R"));
//std::cout << integral->getVal() << std::endl;
//std::cout << integral->getError() << std::endl;
//Double_t sideband_bg_val = integral->getVal();
//double sideband_bg_error = integral->getError();
std::stringstream r;
r << "bdtg3" << " >= " << cut_val << " && Lambda_b0_DTF_MASS_constr1 >= 5650 && Lambda_b0_DTF_MASS_constr1 <= 5700";
const std::string cut2 = r.str();
double integ = tree->GetEntries(cut2.c_str());
//double integ = integral->getVal();
double efficiency2 = eff_val/(5./2. + sqrt(integ));
efficiencies2[i] = efficiency2;
effvals[i]=eff_val;
std::cout << "\n" << integ << std::endl;
std::cout << "\n" << eff_val << std::endl;
std::cout << "\n" << efficiency2 << std::endl;
*/
//double efficiency2_error = efficiency2*sqrt(pow(eff_error/eff_val,2)+(1/(4*sideband_bg_val))*pow(sideband_bg_error/(5/2+sideband_bg_val),2));
//std::cout << "\n\n" << "BDT cut value = " << cut_val << "\n" ;
//std::cout << "S = " << sig_val << " +/- " << sig_error << "\n" ;
//std::cout << "B = " << bg_val << " +/- " << bg_error << "\n" ;
//std::cout << "S/sqrt(S+B) = " << efficiency << " +/- " << efficiency_error << "\n\n" ;
//ds.plotOn( plot );
//pdf.plotOn( plot );
//RooPlot* plotPullMass = mass.frame();
//plotPullMass->addPlotable( plot->pullHist() );
//plotPullMass->SetMinimum();
//plotPullMass->SetMaximum();
//std::cout << cut_val;
}
TCanvas *c1 = new TCanvas();
//double zeros[20];
//for (i=0, i<20, i++) zeros[i]=0.0;
TGraphErrors* graph = new TGraphErrors(40, bdt_cuts, efficiencies1, 0, efficiencies1_error);
graph->SetTitle("S/sqrt(S+B) vs BDTG3 cut");
//graph->SetMarkerColor(4);
//graph->SetMarkerStyle(20);
//graph->SetMarkerSize(1.0);
graph->GetXaxis()->SetTitle("BDTG3 cut (>)");
graph->GetXaxis()->SetRangeUser(-1.0,1.0);
graph->GetYaxis()->SetTitle("S/sqrt(S+B)");
//graph->Fit("pol5");
graph->Draw("AP");
c1->SaveAs("~/cern/plots/bdt_cuts_norm/Lb2JpsipK_2011_2012_BDTG3_cuts_S_sqrtS+B.pdf");
//return c1;
//std::cout << efficiencies1_error[5] << std::endl;
//gStyle->SetOptFit(1011);
/*TCanvas *c2 = new TCanvas();
TGraph* graph2 = new TGraph(40, bdt_cuts, efficiencies2);
graph2->SetTitle("eff/[5/2+sqrt(B)] vs BDTG3 cut");
graph2->SetMarkerColor(4);
graph2->SetMarkerStyle(20);
graph2->SetMarkerSize(1.0);
graph2->GetXaxis()->SetTitle("BDTG3 cut (>)");
graph2->GetXaxis()->SetRangeUser(-1.0,1.0);
graph2->GetYaxis()->SetTitle("eff/[5/2+sqrt(B)]");
//graph2->Fit("pol7");
graph2->Draw("AP");
c2->SaveAs("~/cern/plots/bdt_cuts_norm/Lb2JpsipK_2011_2012_BDTG3_cuts_Punzi.png");
//return c2;
*/
/*
TCanvas* c = new TCanvas();
TPad* pad1 = new TPad("pad1","pad1", 0, 0.3, 1, 1.0);
pad1->SetBottomMargin(0.1);
pad1->SetTopMargin(0.1);
pad1->Draw();
c->cd();
TPad* pad2 = new TPad("pad2","pad2", 0, 0, 1, 0.3);
pad2->SetBottomMargin(0.1);
pad2->SetTopMargin(0.0);
pad2->Draw();
//pdf.plotOn( plot, RooFit::Components( DfbPdf ), RooFit::LineColor( kRed ), RooFit::LineStyle(kDashed) );
//pdf.plotOn( plot, RooFit::Components( promptPdf ), RooFit::LineColor( kBlue ), RooFit::LineStyle(kDotted) );
//pdf.plotOn( plot, RooFit::Components( bgPdf ), RooFit::LineColor( kOrange ), RooFit::LineStyle(kDashDotted) );
pad1->cd();
plot->Draw();
pad2->cd();
plotPullMass->Draw("AP");
c->SaveAs(out_file_mass);
RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot",
ds, &pdf, RooArgList(sigYield, bgYield) );
RooDataSet * dataw_z = new RooDataSet(ds.GetName(),ds.GetTitle(),&ds,*(ds.get()),0,"sigYield_sw") ;
*/
/*
TCanvas* d = new TCanvas();
RooPlot* w_mass_chicp = mass_chicp.frame();
dataw_z->plotOn(w_mass_chicp, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_chicp->Draw();
d->SaveAs("m_chicp_sweighted.png");
TCanvas* e = new TCanvas();
RooPlot* w_mass_pK = mass_pK.frame();
dataw_z->plotOn(w_mass_pK, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_pK->Draw();
e->SaveAs("m_pK_sweighted.png");
*/
/*
TCanvas* f = new TCanvas();
RooPlot* w_mass_Jpsi = mass_Jpsi.frame();
dataw_z->plotOn(w_mass_Jpsi, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_Jpsi->Draw();
f->SaveAs("m_Jpsi_sweighted.png");
TCanvas* g = new TCanvas();
RooPlot* w_mass_Chic = mass_Chic.frame();
dataw_z->plotOn(w_mass_Chic, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_Chic->Draw();
g->SaveAs("m_Chic_sweighted.png");
*/
}
void fit_MC_norm(std::string input_file = "/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/normalisation_samples/reduced_Lb2JpsipK_MC_2011_2012_norm.root", std::string out_file_mass = "~/cern/plots/fitting/Lb2JpsipK_MC_2011_2012_cut_mass_fit.png"){
//
gROOT->ProcessLine(".L ~/cern/scripts/lhcbStyle.C");
//lhcbStyle();
const std::string filename(input_file.c_str());
const std::string treename = "DecayTree";
TFile* file = TFile::Open( filename.c_str() );
if( !file ) std::cout << "file " << filename << " does not exist" << std::endl;
TTree* tree = (TTree*)file->Get( treename.c_str() );
if( !tree ) std::cout << "tree " << treename << " does not exist" << std::endl;
// -- signal, mass shape
RooRealVar Lambda_b0_DTF_MASS_constr1("Lambda_b0_DTF_MASS_constr1","m(J/#psi pK^{-})", 5450., 5850., "MeV/c^{2}");
RooRealVar Jpsi_M("Jpsi_M","m(#mu#mu)", 3000., 3200., "MeV/c^{2}");
//RooRealVar chi_c_M("chi_c_M","m(J/#psi#gamma)", 3350., 3750., "MeV/c^{2}");
RooRealVar mean("mean","mean", 5620., 5595., 5650.);
RooRealVar sigma1("sigma1","sigma1", 10., 1., 100.);
RooRealVar sigma2("sigma2","sigma2", 100., 1., 1000.);
RooRealVar alpha1("alpha1","alpha1", 1.0, 0.5, 5.0);
RooRealVar n1("n1","n1", 1.8, 0.2, 15.0);
RooRealVar alpha2("alpha2","alpha2", -0.5, -5.5, 0.0);
RooRealVar n2("n2","n2", 0.7, 0.2, 10.0);
//RooRealVar bkgcat_chic("bkgcat_chic","bkgcat_chic", 0, 100);
RooGaussian gauss1("gauss1","gauss1", Lambda_b0_DTF_MASS_constr1, mean, sigma1);
RooGaussian gauss2("gauss2","gauss2", Lambda_b0_DTF_MASS_constr1, mean, sigma2);
RooCBShape cb1("cb1","cb1", Lambda_b0_DTF_MASS_constr1, mean, sigma1, alpha1, n1);
RooCBShape cb2("cb2","cb2", Lambda_b0_DTF_MASS_constr1, mean, sigma2, alpha2, n2);
/*
// the chi_c2 component
RooRealVar mean3("mean3","mean3", 5570., 5520., 5580.);
RooRealVar sigma3("sigma3","sigma3", 10., 1., 20.);
RooGaussian gauss3("gauss3","gauss3", Lambda_b0_DTF_MASS_constr1, mean3, sigma3);
*/
RooRealVar cbRatio("cbRatio","cbRatio", 0.8, 0.1, 1.0);
RooRealVar frac2("frac2","frac2", 0.3, 0., 1.);
/*
alpha1.setVal( 2.1 );
alpha2.setVal( -4.9 );
n1.setVal( 3.2 );
n2.setVal( 7.9 );
cbRatio.setVal( 0.6808 );
alpha1.setConstant( true );
alpha2.setConstant( true );
cbRatio.setConstant( true );
n1.setConstant( true );
n2.setConstant( true );
*/
// -- add signal & bg
//RooAddPdf pdf("pdf", "pdf", RooArgList(gauss1, gauss2), RooArgList( frac2 ));
RooAddPdf pdf("pdf", "pdf", RooArgList(cb1, cb2), RooArgList( cbRatio ));
RooArgSet obs;
obs.add(Lambda_b0_DTF_MASS_constr1);
obs.add(Jpsi_M);
//obs.add(chi_c_M);
//obs.add(bkgcat_chic);
RooDataSet ds("ds","ds", obs, RooFit::Import(*tree));
//RooFit::Cut("Lambda_b0_DTF_MASS_constr1 > 5580")
RooPlot* plot = Lambda_b0_DTF_MASS_constr1.frame();
plot->SetAxisRange(5500., 5750.);
pdf.fitTo( ds );
ds.plotOn( plot, RooFit::Binning(200) );
pdf.plotOn( plot );
//gauss3.plotOn( plot );
RooPlot* plotPullMass = Lambda_b0_DTF_MASS_constr1.frame();
plotPullMass->addPlotable( plot->pullHist() );
//plotPullMass->SetMinimum();
//plotPullMass->SetMaximum();
plotPullMass->SetAxisRange(5500., 5750.);
TCanvas* c = new TCanvas();
c->cd();
TPad* pad1 = new TPad("pad1","pad1", 0, 0.3, 1, 1.0);
pad1->SetBottomMargin(0.1);
pad1->SetTopMargin(0.1);
pad1->Draw();
//TPad* pad2 = new TPad("pad2","pad2", 0, 0.05, 1, 0.4);
TPad* pad2 = new TPad("pad2","pad2", 0, 0, 1, 0.3);
pad2->SetBottomMargin(0.1);
pad2->SetTopMargin(0.0);
pad2->Draw();
pdf.plotOn( plot, RooFit::Components( cb1 ), RooFit::LineColor( kRed ), RooFit::LineStyle(kDashed) );
pdf.plotOn( plot, RooFit::Components( cb2 ), RooFit::LineColor( kOrange ), RooFit::LineStyle(kDotted) );
//pdf.plotOn( plot, RooFit::Components( bgPdf ), RooFit::LineColor( kBlue ), RooFit::LineStyle(kDashDotted) );
pad1->cd();
//pad1->SetLogy();
plot->Draw();
pad2->cd();
plotPullMass->Draw("AP");
c->SaveAs(out_file_mass.c_str());
}
Matrix<double> BspCurvBasisFuncSet::CreateMatrixIntegral(int lev1, int lev2, double x1, double x2) const
{
KnotSet kset1 = KnotSet(*kts,ord,num).CreateKnotSetDeriv(lev1);
KnotSet kset2 = KnotSet(*kts,ord,num).CreateKnotSetDeriv(lev2);
Matrix<double> mat(kset1.GetNum()-(ord-lev1),kset2.GetNum()-(ord-lev2));
BspCurvBasisFuncSet basis1(kset1.GetKnots(),ord-lev1,kset1.GetNum());
BspCurvBasisFuncSet basis2(kset2.GetKnots(),ord-lev2,kset2.GetNum());
// find the first basis function for which the last distinct
// knot is greater than x1
int ind1=-1;
do {
ind1++;
} while ((*(basis1.b))[ind1].GetKnots()[ord-lev1] <= x1);
// find the last basis function for which the first distinct
// knot is less than x2
int ind2=-1;
do {
ind2++;
} while (ind2 < kset1.GetNum()-ord+lev1 && (*(basis1.b))[ind2].GetKnots()[0] < x2);
int ind3=-1;
do {
ind3++;
} while ((*(basis2.b))[ind3].GetKnots()[ord-lev2] <= x1);
// find the last basis function for which the first distinct
// knot is less than x2
int ind4=-1;
do {
ind4++;
} while (ind4 < kset2.GetNum()-ord+lev2 && (*(basis2.b))[ind2].GetKnots()[0] < x2);
Matrix<double> mat1(kset1.GetNum()-ord+lev1,kset2.GetNum()-ord+lev2,0.0);
int i1, i2;
if (ind1 < ind3) i1 = ind1; else i1 = ind3;
if (ind2 > ind4) i2 = ind2; else i2 = ind4;
for (int i=i1; i<=i2-1; i++)
for (int j=i1; j<=i2-1; j++) {
// create the two std::sets representing the two knot std::sets
Vector<double> temp1((*(basis1.b))[i].GetKnots());
Vector<double> temp2((*(basis2.b))[j].GetKnots());
std::set<double> s1(temp1.begin(),temp1.end());
std::set<double> s2(temp2.begin(),temp2.end());
if (*(--s2.end()) > *(s1.begin())) {
// form the intersection
std::set<double> s3;
std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),std::inserter(s3,s3.begin()));
// if there is an intersection
if (s3.size() > 1) {
Vector<double> v(s3.size());
std::set<double>::iterator s = s3.begin();
// copy the elements into a vector
for (unsigned int k=0; k<s3.size(); k++) v[k] = *s++;
// create the compbezcurvs
Vector<BezCurv<double> > vec1(s3.size()-1);
Vector<BezCurv<double> > vec2(s3.size()-1);
BspCurv<double> b1((*(basis1.b))[i].GetBspCurv()), b2((*(basis2.b))[j].GetBspCurv());
// find the segments of intersection
for (unsigned int k=0; k<s3.size()-1; k++) {
int segb1 = b1.GetKnotSet().Find_segment(v[k]);
int segb2 = b2.GetKnotSet().Find_segment(v[k]);
vec1[k] = b1.GetSegment(segb1);
vec2[k] = b2.GetSegment(segb2);
}
CompBezCurv<double> cb1(vec1,s3.size()-1,v);
CompBezCurv<double> cb2(vec2,s3.size()-1,v);
CompBezCurv<double> prod = cb1.Product(cb2);
mat1[i][j] = prod.ConvertBspCurv().Integrate(x1,x2);
}
}
}
return mat1;
}
int main(int argc, char *argv[])
{
Pooma::initialize(argc, argv);
Pooma::Tester tester(argc, argv);
// To declare a field, you first need to set up a layout. This requires
// knowing the physical vertex-domain and the number of external guard
// cell layers. Vertex domains contain enough points to hold all of the
// rectilinear centerings that POOMA is likely to support for quite
// awhile. Also, it means that the same layout can be used for all
// fields, regardless of centering.
Interval<2> physicalVertexDomain(14, 14);
Loc<2> blocks(3, 3);
GridLayout<2> layout1(physicalVertexDomain, blocks, GuardLayers<2>(1),
LayoutTag_t());
GridLayout<2> layout0(physicalVertexDomain, blocks, GuardLayers<2>(0),
LayoutTag_t());
Centering<2> cell = canonicalCentering<2>(CellType, Continuous, AllDim);
Centering<2> vert = canonicalCentering<2>(VertexType, Continuous, AllDim);
Centering<2> yedge = canonicalCentering<2>(EdgeType, Continuous, YDim);
Vector<2> origin(0.0);
Vector<2> spacings(1.0, 2.0);
// First basic test verifies that we're assigning to the correct areas
// on a brick.
typedef
Field<UniformRectilinearMesh<2>, double,
MultiPatch<GridTag, BrickTag_t> > Field_t;
Field_t b0(cell, layout1, origin, spacings);
Field_t b1(vert, layout1, origin, spacings);
Field_t b2(yedge, layout1, origin, spacings);
Field_t b3(yedge, layout1, origin, spacings);
Field_t bb0(cell, layout0, origin, spacings);
Field_t bb1(vert, layout0, origin, spacings);
Field_t bb2(yedge, layout0, origin, spacings);
b0.all() = 0.0;
b1.all() = 0.0;
b2.all() = 0.0;
b0 = 1.0;
b1 = 1.0;
b2 = 1.0;
bb0.all() = 0.0;
bb1.all() = 0.0;
bb2.all() = 0.0;
bb0 = 1.0;
bb1 = 1.0;
bb2 = 1.0;
// SPMD code follows.
// Note, SPMD code will work with the evaluator if you are careful
// to perform assignment on all the relevant contexts. The patchLocal
// function creates a brick on the local context, so you can just perform
// the assignment on that context.
int i;
for (i = 0; i < b0.numPatchesLocal(); ++i)
{
Patch<Field_t>::Type_t patch = b0.patchLocal(i);
// tester.out() << "context " << Pooma::context() << ": assigning to patch " << i
// << " with domain " << patch.domain() << std::endl;
patch += 1.5;
}
// This is safe to do since b1 and b2 are built with the same layout.
for (i = 0; i < b1.numPatchesLocal(); ++i)
{
b1.patchLocal(i) += 1.5;
b2.patchLocal(i) += 1.5;
}
for (i = 0; i < bb0.numPatchesLocal(); ++i)
{
Patch<Field_t>::Type_t patch = bb0.patchLocal(i);
// tester.out() << "context " << Pooma::context() << ": assigning to patch on bb0 " << i
// << " with domain " << patch.domain() << std::endl;
patch += 1.5;
}
// This is safe to do since bb1 and bb2 are built with the same layout.
for (i = 0; i < bb1.numPatchesLocal(); ++i)
{
bb1.patchLocal(i) += 1.5;
bb2.patchLocal(i) += 1.5;
}
tester.check("cell centered field is 2.5", all(b0 == 2.5));
tester.check("vert centered field is 2.5", all(b1 == 2.5));
tester.check("edge centered field is 2.5", all(b2 == 2.5));
tester.out() << "b0.all():" << std::endl << b0.all() << std::endl;
tester.out() << "b1.all():" << std::endl << b1.all() << std::endl;
tester.out() << "b2.all():" << std::endl << b2.all() << std::endl;
tester.check("didn't write into b0 boundary",
sum(b0.all()) == 2.5 * b0.physicalDomain().size());
tester.check("didn't write into b1 boundary",
sum(b1.all()) == 2.5 * b1.physicalDomain().size());
tester.check("didn't write into b2 boundary",
sum(b2.all()) == 2.5 * b2.physicalDomain().size());
tester.check("cell centered field is 2.5", all(bb0 == 2.5));
tester.check("vert centered field is 2.5", all(bb1 == 2.5));
tester.check("edge centered field is 2.5", all(bb2 == 2.5));
tester.out() << "bb0:" << std::endl << bb0 << std::endl;
tester.out() << "bb1:" << std::endl << bb1 << std::endl;
tester.out() << "bb2:" << std::endl << bb2 << std::endl;
typedef
Field<UniformRectilinearMesh<2>, double,
MultiPatch<GridTag, CompressibleBrickTag_t> > CField_t;
CField_t c0(cell, layout1, origin, spacings);
CField_t c1(vert, layout1, origin, spacings);
CField_t c2(yedge, layout1, origin, spacings);
CField_t cb0(cell, layout0, origin, spacings);
CField_t cb1(vert, layout0, origin, spacings);
CField_t cb2(yedge, layout0, origin, spacings);
c0.all() = 0.0;
c1.all() = 0.0;
c2.all() = 0.0;
c0 = 1.0;
c1 = 1.0;
c2 = 1.0;
cb0.all() = 0.0;
cb1.all() = 0.0;
cb2.all() = 0.0;
cb0 = 1.0;
cb1 = 1.0;
cb2 = 1.0;
// SPMD code follows.
// Note, SPMD code will work with the evaluator if you are careful
// to perform assignment on all the relevant contexts. The patchLocal
// function creates a brick on the local context, so you can just perform
// the assignment on that context.
for (i = 0; i < c0.numPatchesLocal(); ++i)
{
Patch<CField_t>::Type_t patch = c0.patchLocal(i);
tester.out() << "context " << Pooma::context() << ": assigning to patch " << i
<< " with domain " << patch.domain() << std::endl;
patch += 1.5;
}
// This is safe to do since c1 and c2 are built with the same layout.
for (i = 0; i < c1.numPatchesLocal(); ++i)
{
c1.patchLocal(i) += 1.5;
c2.patchLocal(i) += 1.5;
}
for (i = 0; i < cb0.numPatchesLocal(); ++i)
{
Patch<CField_t>::Type_t patch = cb0.patchLocal(i);
tester.out() << "context " << Pooma::context() << ": assigning to patch on cb0 " << i
<< " with domain " << patch.domain() << std::endl;
patch += 1.5;
}
// This is safe to do since cb1 and cb2 are cuilt with the same layout.
for (i = 0; i < cb1.numPatchesLocal(); ++i)
{
cb1.patchLocal(i) += 1.5;
cb2.patchLocal(i) += 1.5;
}
tester.check("cell centered field is 2.5", all(c0 == 2.5));
tester.check("vert centered field is 2.5", all(c1 == 2.5));
tester.check("edge centered field is 2.5", all(c2 == 2.5));
tester.out() << "c0.all():" << std::endl << c0.all() << std::endl;
tester.out() << "c1.all():" << std::endl << c1.all() << std::endl;
tester.out() << "c2.all():" << std::endl << c2.all() << std::endl;
tester.check("didn't write into c0 boundary",
sum(c0.all()) == 2.5 * c0.physicalDomain().size());
tester.check("didn't write into c1 boundary",
sum(c1.all()) == 2.5 * c1.physicalDomain().size());
tester.check("didn't write into c2 boundary",
sum(c2.all()) == 2.5 * c2.physicalDomain().size());
tester.check("cell centered field is 2.5", all(cb0 == 2.5));
tester.check("vert centered field is 2.5", all(cb1 == 2.5));
tester.check("edge centered field is 2.5", all(cb2 == 2.5));
tester.out() << "cb0:" << std::endl << cb0 << std::endl;
tester.out() << "cb1:" << std::endl << cb1 << std::endl;
tester.out() << "cb2:" << std::endl << cb2 << std::endl;
//------------------------------------------------------------------
// Scalar code example:
//
c0 = iota(c0.domain()).comp(0);
c1 = iota(c1.domain()).comp(1);
// Make sure all the data-parallel are done:
Pooma::blockAndEvaluate();
for (i = 0; i < c0.numPatchesLocal(); ++i)
{
Patch<CField_t>::Type_t local0 = c0.patchLocal(i);
Patch<CField_t>::Type_t local1 = c1.patchLocal(i);
Patch<CField_t>::Type_t local2 = c2.patchLocal(i);
Interval<2> domain = local2.domain(); // physical domain of local y-edges
// --------------------------------------------------------------
// I believe the following is probably the most efficient approach
// for sparse computations. For data-parallel computations, the
// evaluator will uncompress the patches and take brick views, which
// provide the most efficient access. If you are only performing
// the computation on a small portion of cells, then the gains would
// be outweighed by the act of copying the compressed value to all the
// cells.
//
// The read function is used on the right hand side, because
// operator() is forced to uncompress the patch just in case you want
// to write to it.
for(Interval<2>::iterator pos = domain.begin(); pos != domain.end(); ++pos)
{
Loc<2> edge = *pos;
Loc<2> rightCell = edge; // cell to right is same cell
Loc<2> leftCell = edge - Loc<2>(1,0);
Loc<2> topVert = edge + Loc<2>(0, 1);
Loc<2> bottomVert = edge;
local2(edge) =
local0.read(rightCell) + local0.read(leftCell) +
local1.read(topVert) + local1.read(bottomVert);
}
// This statement is optional, it tries to compress the patch after
// we're done computing on it. Since I used .read() for the local0 and 1
// they remained in their original state. compress() can be expensive, so
// it may not be worth trying unless space is really important.
compress(local2);
}
tester.out() << "c0" << std::endl << c0 << std::endl;
tester.out() << "c1" << std::endl << c1 << std::endl;
tester.out() << "c2" << std::endl << c2 << std::endl;
//------------------------------------------------------------------
// Interfacing with a c-function:
//
// This example handles the corner cases, where the patches from a
// cell centered field with no guard layers actually contain some
// extra data.
Pooma::blockAndEvaluate();
for (i = 0; i < cb0.numPatchesLocal(); ++i)
{
Patch<CField_t>::Type_t local0 = cb0.patchLocal(i);
Interval<2> physicalDomain = local0.physicalDomain();
double *data;
int size = physicalDomain.size();
if (physicalDomain == local0.totalDomain())
{
uncompress(local0);
data = &local0(physicalDomain.firsts());
nonsense(data, size);
}
else
{
// In this case, the engine has extra storage even though the
// field has the right domain. We copy it to a brick engine,
// call the function and copy it back. No uncompress is required,
// since the assignment will copy the compressed value into the
// brick.
// arrayView is a work-around. Array = Field doesn't work at
// the moment.
Array<2, double, Brick> brick(physicalDomain);
Array<2, double, CompressibleBrick> arrayView(local0.engine());
brick = arrayView(physicalDomain);
Pooma::blockAndEvaluate();
data = &brick(Loc<2>(0));
nonsense(data, size);
arrayView(physicalDomain) = brick;
// Note that we don't need a blockAndEvaluate here, since an iterate has
// been spawned to perform the copy.
}
// If you want to try compress(local0) here, you should do blockAndEvaluate
// first in case the local0 = brick hasn't been executed yet.
}
tester.out() << "cb0.all()" << std::endl << cb0 << std::endl;
b2 = positions(b2).comp(0);
RefCountedBlockPtr<double> block = pack(b2);
// The following functions give you access to the raw data from pack.
// Note that the lifetime of the data is managed by the RefCountedBlockPtr,
// so when "block" goes out of scope, the data goes away. (i.e. Don't write
// a function where you return block.beginPointer().)
double *start = block.beginPointer(); // start of the data
double *end = block.endPointer(); // one past the end
int size = block.size(); // size of the data
tester.out() << Pooma::context() << ":" << block.size() << std::endl;
unpack(b3, block);
tester.out() << "b2" << std::endl << b2 << std::endl;
tester.out() << "b3" << std::endl << b3 << std::endl;
tester.check("pack, unpack", all(b2 == b3));
int ret = tester.results("LocalPatch");
Pooma::finalize();
return ret;
}
extern "C" int main(int argc, char *argv[]) {
Callback cb("notify", &cbFunc, NULL);
checkpointNext("Objects:");
testNotify(" Normal", cb, 0x1337);
testNotify(" NULL", 0, 0x1337);
testNotify(" Invalid", 0xDEADBEEF, 0x1337);
cb.Delete();
testNotify(" Deleted", cb, 0x1337);
cb.Create("notify", &cbFunc, NULL);
checkpointNext("Values:");
testNotify(" Zero", cb, 0);
testNotify(" DEADBEEF", cb, 0xDEADBEEF);
checkpointNext("Notifies:");
int result = 0;
for (int i = 0; i < 10000; ++i) {
result = sceKernelNotifyCallback(cb, 1);
if (result != 0) {
checkpoint(" Failed at %d: %08x", i, result);
break;
}
}
if (result == 0) {
checkpoint(" 10000 notifies: OK");
}
checkpoint("sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Different thread:");
{
CallbackSleeper waiter1("better priority sleeping thread", 0x10);
CallbackSleeper waiter2("worse priority sleeping thread", 0x30);
sceKernelDelayThread(1000);
sceKernelNotifyCallback(waiter1.callbackID(), 0x1337);
sceKernelNotifyCallback(waiter2.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Return value:");
{
CallbackSleeper waiter("sleeping thread");
waiter.setReturn(0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #2", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Recursion:");
{
SelfNotifier waiter("sleeping thread");
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Mixing types:");
checkpoint(" scePowerRegisterCallback (causes notify): %08x", scePowerRegisterCallback(0, cb));
testNotify(" Manual notify", cb, 0x1337);
checkpoint(" sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Order:");
Callback cb1("notify1", &cbFunc, (void *)0xABC00001);
Callback cb2("notify2", &cbFunc, (void *)0xABC00002);
Callback cb3("notify3", &cbFunc, (void *)0xABC00003);
testNotify(" Notify cb #2", cb2, 0xDEF00001);
testNotify(" Notify cb #1", cb1, 0xDEF00002);
testNotify(" Notify cb #3", cb3, 0xDEF00003);
checkpoint(" sceKernelCheckCallback: %08x", sceKernelCheckCallback());
return 0;
}
extern "C" int main(int argc, char *argv[]) {
ExitCallbackArg arg;
ExitCallbackArgParams params;
arg.unknown1 = 0;
arg.params = ¶ms;
params.size = 12;
params.unk1 = 0x1337;
params.unk2 = 0x1337;
Callback cb1("count1", &cbFunc, NULL);
Callback cb2("count2", &cbFunc, &arg.common);
checkpointNext("Objects:");
checkpoint(" Normal: %08x", sceKernelRegisterExitCallback(cb1));
checkpoint(" NULL: %08x", sceKernelRegisterExitCallback(0));
checkpoint(" Invalid: %08x", sceKernelRegisterExitCallback(0xDEADBEEF));
cb1.Delete();
checkpoint(" Deleted: %08x", sceKernelRegisterExitCallback(cb1));
sceKernelSetCompiledSdkVersion(0x3090500);
cb1.Create("count1", &cbFunc, NULL);
checkpointNext("Objects (SDK 3.95+):");
checkpoint(" Normal: %08x", sceKernelRegisterExitCallback(cb1));
checkpoint(" NULL: %08x", sceKernelRegisterExitCallback(0));
checkpoint(" Invalid: %08x", sceKernelRegisterExitCallback(0xDEADBEEF));
cb1.Delete();
checkpoint(" Deleted: %08x", sceKernelRegisterExitCallback(cb1));
cb1.Create("count1", &cbFunc, NULL);
checkpointNext("LoadExecForUser_362A956B:");
testLoadExec362A956B(" With invalid CB", arg);
checkpoint(" Register without arg: %08x", sceKernelRegisterExitCallback(cb1));
testLoadExec362A956B(" Without arg", arg);
checkpoint(" Register invalid: %08x", sceKernelRegisterExitCallback(0));
testLoadExec362A956B(" With invalid again", arg);
checkpoint(" Register valid: %08x", sceKernelRegisterExitCallback(cb2));
int unknown1s[] = {-1, 0, 1, 2, 3, 4};
for (size_t i = 0; i < ARRAY_SIZE(unknown1s); ++i) {
char temp[32];
snprintf(temp, sizeof(temp), " arg.unknown1 = %d", unknown1s[i]);
arg.unknown1 = unknown1s[i];
params.unk1 = 0x1337;
params.unk2 = 0x1337;
testLoadExec362A956B(temp, arg);
}
arg.unknown1 = 0;
int sizes[] = {-1, 0, 1, 2, 3, 4, 11, 12, 13, 16};
for (size_t i = 0; i < ARRAY_SIZE(sizes); ++i) {
char temp[32];
snprintf(temp, sizeof(temp), " arg.param->size = %d", sizes[i]);
params.size = sizes[i];
params.unk1 = 0x1337;
params.unk2 = 0x1337;
testLoadExec362A956B(temp, arg);
}
params.size = 12;
cb1.Delete();
cb2.Delete();
return 0;
}
void fit_and_weights_norm(){
gROOT->ProcessLine(".x ~/cern/scripts/lhcbStyle.C");
//lhcbStyle();
gStyle->SetLabelSize(0.05,"x");
gStyle->SetLabelSize(0.05,"y");
gStyle->SetTitleSize(0.05,"x");
gStyle->SetPaperSize(20,26);
gStyle->SetPadTopMargin(0.0);
gStyle->SetPadRightMargin(0.05); // increase for colz plots
gStyle->SetPadBottomMargin(0.0);
gStyle->SetPadLeftMargin(0.14);
gStyle->SetTitleH(0.01);
//
const std::string filename("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/normalisation_samples/Lb2JpsipK_2011_2012_signal_withbdt_cut_05.root");
const std::string treename = "withbdt";
const std::string out_file_mass("~/cern/plots/fitting/Lb2JpsipK_2011_2012_mass_fit_after_bdtg3_05.png");
//
TFile* file = TFile::Open( filename.c_str() );
if( !file ) std::cout << "file " << filename << " does not exist" << std::endl;
TTree* tree = (TTree*)file->Get( treename.c_str() );
if( !tree ) std::cout << "tree " << treename << " does not exist" << std::endl;
// -- signal, mass shape
RooRealVar Lambda_b0_DTF_MASS_constr1("Lambda_b0_DTF_MASS_constr1","m(#chi_{c}pK^{-})", 5550., 5700., "MeV/c^{2}");
RooRealVar Jpsi_M("Jpsi_M","m(#mu#mu)", 3000., 3200., "MeV/c^{2}");
//RooRealVar chi_c_M("chi_c_M","m(J/#psi#gamma)", 3400., 3700., "MeV/c^{2}");
RooRealVar mean("mean","mean", 5630., 5610., 5650.);
RooRealVar sigma1("sigma1","sigma1", 10., 1., 100.);
RooRealVar sigma2("sigma2","sigma2", 30.0, 5.0, 300.0);
RooRealVar alpha1("alpha1","alpha1", 1.0, 0.5, 5.0);
RooRealVar n1("n1","n1", 1.8, 0.2, 15.0);
RooRealVar alpha2("alpha2","alpha2", -0.5, -5.5, 0.0);
RooRealVar n2("n2","n2", 0.7, 0.2, 10.0);
//RooRealVar bkgcat_chic("bkgcat_chic","bkgcat_chic", 0, 100);
RooRealVar bdtg3("bdtg3", "bdtg3", -1.0, 1.0); //
RooRealVar frac2("frac2","frac2", 0.3, 0., 1.);
Lambda_b0_DTF_MASS_constr1.setBins(75);
RooGaussian gauss1("gauss1","gauss1", Lambda_b0_DTF_MASS_constr1, mean, sigma1);
RooGaussian gauss2("gauss2","gauss2", Lambda_b0_DTF_MASS_constr1, mean, sigma2);
RooCBShape cb1("cb1","cb1", Lambda_b0_DTF_MASS_constr1, mean, sigma1, alpha1, n1);
RooCBShape cb2("cb2","cb2", Lambda_b0_DTF_MASS_constr1, mean, sigma2, alpha2, n2);
RooAddPdf sig("sig", "sig", RooArgList(cb1, cb2), RooArgList( frac2 ));
RooRealVar cbRatio("cbRatio","cb Ratio", 0.8, 0.1, 1.0);
RooRealVar sigYield("sigYield","sig Yield", 4e2, 1e1, 1e4);
RooRealVar bgYield("bgYield","bg Yield", 1e2, 1e0, 5e5);
//put in values from fit_MC here <<--- DON'T FORGET TO CHANGE THESE IF THE FIT CHANGES!!!
/*
EXT PARAMETER INTERNAL INTERNAL
NO. NAME VALUE ERROR STEP SIZE VALUE
1 alpha1 1.74154e+00 3.36750e-02 1.24897e-04 -4.64754e-01
2 alpha2 -2.02379e+00 6.38694e-02 1.18078e-04 2.87434e+00
3 cbRatio 3.81630e-01 2.53217e-02 1.04396e-03 -3.83487e-01
4 mean 5.61983e+03 1.06900e-02 5.57074e-05 -9.73350e-02
5 n1 3.61886e+00 1.29299e-01 2.50836e-04 -5.68053e-01
6 n2 3.28978e+00 1.59452e-01 3.00100e-04 -3.78398e-01
7 sigma1 7.37006e+00 1.49989e-01 2.60360e-05 -1.05787e+00
8 sigma2 4.90330e+00 4.88847e-02 5.78092e-06 -1.44570e+00
*/
alpha1.setVal( 1.74154e+00 );
alpha2.setVal( -2.02379e+00 );
n1.setVal( 3.61886e+00 );
n2.setVal( 3.28978e+00 );
frac2.setVal( 3.81630e-01 );
sigma1.setVal( 7.37006e+00 );
sigma2.setVal( 4.90330e+00 );
alpha1.setConstant( true );
alpha2.setConstant( true );
frac2.setConstant( true );
n1.setConstant( true );
n2.setConstant( true );
sigma1.setConstant( true );
sigma2.setConstant( true );
// -- bg, mass shape
RooRealVar a1("a1","a1", -0.1, -0.5, 0.5);
RooChebychev comb("comb","comb", Lambda_b0_DTF_MASS_constr1, a1);
RooRealVar mean3("mean3","mean3", 5560., 5500., 5600.);
RooRealVar sigma3("sigma3","sigma3", 5., 1., 10.);
RooRealVar frac3("frac3","frac", 0.2, 0.0, 0.3);
RooGaussian gauss3("gauss3","gauss3", Lambda_b0_DTF_MASS_constr1, mean3, sigma3);
RooAddPdf bg("bg","bg", RooArgList(gauss3, comb), RooArgList(frac3));
// -- add signal & bg
RooAddPdf pdf("pdf", "pdf", RooArgList(sig, comb), RooArgList( sigYield, bgYield));
RooArgSet obs;
obs.add(Lambda_b0_DTF_MASS_constr1);
obs.add(Jpsi_M);
//obs.add(chi_c_M);
//obs.add(proton_ProbNNp);
//obs.add(proton_ProbNNk);
//obs.add(kaon_ProbNNp);
//obs.add(kaon_ProbNNk);
RooDataSet ds("ds","ds", obs, RooFit::Import(*tree));
RooPlot* plot = Lambda_b0_DTF_MASS_constr1.frame();
RooFitResult * result = pdf.fitTo( ds, RooFit::Extended() );
ds.plotOn( plot );
pdf.plotOn( plot );
RooPlot* plotPullMass = Lambda_b0_DTF_MASS_constr1.frame();
plotPullMass->addPlotable( plot->pullHist() );
//plotPullMass->SetMinimum();
//plotPullMass->SetMaximum();
TCanvas* c = new TCanvas();
TPad* pad1 = new TPad("pad1","pad1", 0, 0.3, 1, 1.0);
pad1->SetBottomMargin(0.0);
pad1->SetTopMargin(0.01);
pad1->Draw();
c->cd();
TPad* pad2 = new TPad("pad2","pad2", 0, 0., 1, 0.3);
pad2->SetBottomMargin(0.0);
pad2->SetTopMargin(0.0);
pad2->Draw();
pdf.plotOn( plot, RooFit::Components( sig ), RooFit::LineColor( kTeal ), RooFit::LineStyle(kDashed) );
pdf.plotOn( plot, RooFit::Components( comb ), RooFit::LineColor( kOrange ), RooFit::LineStyle(kDashed) );
pdf.plotOn( plot, RooFit::Components( gauss3 ), RooFit::LineColor( kViolet ), RooFit::LineStyle(kDashed) );
pad1->cd();
plot->Draw();
pad2->cd();
plotPullMass->Draw("AP");
c->SaveAs(out_file_mass.c_str());
/*
RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot",
ds, &pdf, RooArgList(sigYield, bgYield) );
RooDataSet * dataw_z = new RooDataSet(ds.GetName(),ds.GetTitle(),&ds,*(ds.get()),0,"sigYield_sw") ;
TTree *tree_data = (TTree*)dataw_z->tree();
TFile * newfile = TFile::Open("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/weighted_data.root","RECREATE");
tree_data->Write();
newfile->Close();
*/
/*
TCanvas* d = new TCanvas();
RooPlot* w_chi_c_Mp = chi_c_Mp.frame();
dataw_z->plotOn(w_chi_c_Mp, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_chi_c_Mp->Draw();
d->SaveAs("m_chicp_sweighted.png");
TCanvas* e = new TCanvas();
RooPlot* w_mass_pK = mass_pK.frame();
dataw_z->plotOn(w_mass_pK, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_pK->Draw();
e->SaveAs("m_pK_sweighted.png");
*/
/*
TCanvas* f = new TCanvas();
RooPlot* w_Jpsi_M = Jpsi_M.frame();
dataw_z->plotOn(w_Jpsi_M, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_Jpsi_M->Draw();
f->SaveAs("~/cern/plots/m_Jpsi_sweighted.png");
TCanvas* g = new TCanvas();
RooPlot* w_chi_c_M = chi_c_M.frame();
dataw_z->plotOn(w_chi_c_M, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_chi_c_M->Draw();
g->SaveAs("~/cern/plots/m_Chic_sweighted.png");
*/
}
void fit_and_weights_norm(){
gROOT->ProcessLine(".L ~/cern/project/lhcbStyle.C");
lhcbStyle();
/*gStyle->SetLabelSize(0.05,"x");
gStyle->SetLabelSize(0.05,"y");
gStyle->SetTitleSize(0.05,"x");
gStyle->SetPaperSize(20,26);
gStyle->SetPadTopMargin(0.0);
gStyle->SetPadRightMargin(0.05); // increase for colz plots
gStyle->SetPadBottomMargin(0.0);
gStyle->SetPadLeftMargin(0.14);
gStyle->SetTitleH(0.01);*/
//
const std::string filename("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/normalisation_samples/Lb2JpsipK_2011_2012_signal_withbdt.root");
const std::string treename = "withbdt";
const std::string out_file_mass("~/cern/plots/fitting/Lb2JpsipK_2011_2012_mass_fit_after_bdtg3_cut_-055.pdf");
//
const std::string cuts("bdtg3>=-0.55");
TFile* file = TFile::Open( filename.c_str() );
if( !file ) std::cout << "file " << filename << " does not exist" << std::endl;
TTree* tree = (TTree*)file->Get( treename.c_str() );
if( !tree ) std::cout << "tree " << treename << " does not exist" << std::endl;
TTree* rTree1 = tree->CopyTree( cuts.c_str() );
// -- signal, mass shape
RooRealVar Lambda_b0_DTF_MASS_constr1("Lambda_b0_DTF_MASS_constr1","m(J/#psi p K^{-})", 5550., 5700., "MeV/c^{2}");
RooRealVar Jpsi_M("Jpsi_M","m(#mu#mu)", 3000., 3200., "MeV/c^{2}");
//RooRealVar chi_c_M("chi_c_M","m(J/#psi#gamma)", 3400., 3700., "MeV/c^{2}");
RooRealVar mean("mean","mean", 5620., 5600., 5650.);
RooRealVar sigma1("sigma1","sigma1", 10., 1., 100.);
RooRealVar sigma2("sigma2","sigma2", 5.0, 1.0, 300.0);
RooRealVar sigmaT("sigmaT", "sigmaT", 1.9, 1., 100.);
RooRealVar alpha1("alpha1","alpha1", 1.0, 0.5, 5.0);
RooRealVar n1("n1","n1", 1.5, 0.2, 15.0);
RooRealVar alpha2("alpha2","alpha2", -0.5, -5.5, 0.0);
RooRealVar n2("n2","n2", 1.5, 0.2, 10.0);
RooRealVar nu("nu", "nu", 2., 0.7, 100.);
//RooRealVar bkgcat_chic("bkgcat_chic","bkgcat_chic", 0, 100);
RooRealVar bdtg3("bdtg3", "bdtg3", -1.0, 1.0); //
RooRealVar frac2("frac2","frac2", 0.3, 0., 1.);
Lambda_b0_DTF_MASS_constr1.setBins(75);
RooGaussian gauss1("gauss1","gauss1", Lambda_b0_DTF_MASS_constr1, mean, sigma1);
RooGaussian gauss2("gauss2","gauss2", Lambda_b0_DTF_MASS_constr1, mean, sigma2);
RooCBShape cb1("cb1","cb1", Lambda_b0_DTF_MASS_constr1, mean, sigma1, alpha1, n1);
RooCBShape cb2("cb2","cb2", Lambda_b0_DTF_MASS_constr1, mean, sigma2, alpha2, n2);
//RooStudentT * student = new RooStudentT("student", "student", Lambda_b0_DTF_MASS_constr1, mean, sigmaT, nu);
RooAddPdf sig("sig", "sig", RooArgList(cb1, cb2), RooArgList( frac2 ));
RooRealVar cbRatio("cbRatio","cb Ratio", 0.3, 0.1, 1.0);
RooRealVar sigYield("sigYield","sig Yield", 4e2, 1e1, 1e5);
RooRealVar bgYield("bgYield","bg Yield", 1e2, 1e0, 5e5);
//put in values from fit_MC here <<--- DON'T FORGET TO CHANGE THESE IF THE FIT CHANGES!!!
/*
EXT PARAMETER INTERNAL INTERNAL
NO. NAME VALUE ERROR STEP SIZE VALUE
1 alpha1 2.18020e+00 2.85078e-02 1.38432e-04 -2.56034e-01
2 alpha2 -2.79102e+00 6.74385e-02 1.51818e-04 -1.49177e-02
3 cbRatio 3.07172e-01 1.49204e-02 1.72642e-04 -5.69984e-01
4 mean 5.61985e+03 9.58397e-03 5.56682e-05 -9.66293e-02
5 n1 1.49358e+00 8.14447e-02 2.09300e-04 -9.70542e-01
6 n2 1.45276e+00 1.09864e-01 2.59028e-04 -8.39538e-01
7 sigma1 8.46303e+00 1.32851e-01 2.86985e-05 -1.01453e+00
8 sigma2 4.93976e+00 3.42842e-02 5.03572e-06 -1.44512e+00
4 mean 5.62097e+03 4.02152e-02 6.00497e-04 3.08772e-01
5 sigYield 3.52933e+04 2.55400e+02 1.54032e-03 -1.69958e-02
6 sigma1 1.22322e+01 1.10970e+00 2.87462e-03 1.63838e-01
7 sigma2 5.54047e+00 1.41829e-01 1.08300e-03 -1.28653e-01
*/
mean.setVal(5.62097e+03);
sigma1.setVal(1.22322e+01);
sigma2.setVal(5.54047e+00);
mean.setConstant(true);
sigma1.setConstant(true);
sigma2.setConstant(true);
//alpha1.setVal( 2.18020e+00 );
//alpha2.setVal( -2.79102e+00 );
//n1.setVal( 1.49358e+00 );
//n2.setVal( 1.45276e+00 );
//frac2.setVal( 3.81630e-01 );
//sigma1.setVal( 7.37006e+00 );
//sigma2.setVal( 4.90330e+00 );
//double gauss
//alpha1.setVal( 2.18020e+00 );
//alpha2.setVal( -2.79102e+00 );
//n1.setVal( 1.49358e+00 );
//n2.setVal( 1.45276e+00 );
//alpha1.setConstant( true );
//alpha2.setConstant( true );
//frac2.setConstant( true );
//n1.setConstant( true );
//n2.setConstant( true );
//sigma1.setConstant( true );
//sigma2.setConstant( true );
// -- bg, mass shape
RooRealVar a1("a1","a1", -0.1, -0.5, 0.5);
RooExponential exp("exp", "exp", Lambda_b0_DTF_MASS_constr1, a1);
RooChebychev comb("comb","comb", Lambda_b0_DTF_MASS_constr1, a1);
RooRealVar mean3("mean3","mean3", 5560., 5500., 5600.);
RooRealVar sigma3("sigma3","sigma3", 5., 1., 100.);
RooRealVar frac3("frac3","frac", 0.2, 0.0, 0.3);
RooGaussian gauss3("gauss3","gauss3", Lambda_b0_DTF_MASS_constr1, mean3, sigma3);
//RooAddPdf bg("bg","bg", RooArgList(gauss3, comb), RooArgList(frac3));
// -- add signal & bg
RooAddPdf pdf("pdf", "pdf", RooArgList(sig, comb), RooArgList( sigYield, bgYield));
RooArgSet obs;
obs.add(Lambda_b0_DTF_MASS_constr1);
obs.add(Jpsi_M);
//obs.add(chi_c_M);
//obs.add(proton_ProbNNp);
//obs.add(proton_ProbNNk);
//obs.add(kaon_ProbNNp);
//obs.add(kaon_ProbNNk);
RooDataSet ds("ds","ds", obs, RooFit::Import(*rTree1));
RooPlot* plot = Lambda_b0_DTF_MASS_constr1.frame();
RooFitResult * result = pdf.fitTo( ds, RooFit::Extended() );
ds.plotOn( plot );
pdf.plotOn( plot );
RooPlot* plotPullMass = Lambda_b0_DTF_MASS_constr1.frame();
plotPullMass->addPlotable( plot->pullHist() );
//plotPullMass->SetMinimum();
//plotPullMass->SetMaximum();
TCanvas* c = new TCanvas();
TPad* pad1 = new TPad("pad1","pad1", 0, 0.3, 1, 0.95);
//pad1->SetBottomMargin(0.1);
//pad1->SetTopMargin(0.1);
pad1->Draw();
//TPad* pad2 = new TPad("pad2","pad2", 0, 0.05, 1, 0.4);
TPad* pad2 = new TPad("pad2","pad2", 0, 0.05, 1, 0.3);
pad2->Draw();
plotPullMass->GetXaxis()->SetLabelSize(0.1);
plotPullMass->GetYaxis()->SetLabelSize(0.1);
plotPullMass->GetXaxis()->SetTitleSize(0.1);
plotPullMass->GetYaxis()->SetTitleSize(0.1);
//pdf.plotOn( plot, RooFit::Components( sig ), RooFit::LineColor( kTeal ), RooFit::LineStyle(kDashed) );
pdf.plotOn( plot, RooFit::Components( comb ), RooFit::LineColor( kOrange ), RooFit::LineStyle(kDashed) );
//pdf.plotOn( plot, RooFit::Components( gauss3 ), RooFit::LineColor( kViolet ), RooFit::LineStyle(kDashed) );
pad1->cd();
plot->Draw();
pad2->cd();
plotPullMass->Draw("AP");
c->SaveAs(out_file_mass.c_str());
std::cout << rTree1->GetEntries() << " events with the following cut applied: " << cuts.c_str() << std::endl;
/*
RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot",
ds, &pdf, RooArgList(sigYield, bgYield) );
RooDataSet * dataw_z = new RooDataSet(ds.GetName(),ds.GetTitle(),&ds,*(ds.get()),0,"sigYield_sw") ;
TTree *tree_data = (TTree*)dataw_z->tree();
TFile * newfile = TFile::Open("/afs/cern.ch/work/a/apmorris/private/cern/ntuples/new_tuples/weighted_data.root","RECREATE");
tree_data->Write();
newfile->Close();
*/
/*
TCanvas* d = new TCanvas();
RooPlot* w_chi_c_Mp = chi_c_Mp.frame();
dataw_z->plotOn(w_chi_c_Mp, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_chi_c_Mp->Draw();
d->SaveAs("m_chicp_sweighted.png");
TCanvas* e = new TCanvas();
RooPlot* w_mass_pK = mass_pK.frame();
dataw_z->plotOn(w_mass_pK, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_mass_pK->Draw();
e->SaveAs("m_pK_sweighted.png");
*/
/*
TCanvas* f = new TCanvas();
RooPlot* w_Jpsi_M = Jpsi_M.frame();
dataw_z->plotOn(w_Jpsi_M, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_Jpsi_M->Draw();
f->SaveAs("~/cern/plots/m_Jpsi_sweighted.png");
TCanvas* g = new TCanvas();
RooPlot* w_chi_c_M = chi_c_M.frame();
dataw_z->plotOn(w_chi_c_M, RooFit::DataError(RooAbsData::SumW2), RooFit::Binning(20)) ;
w_chi_c_M->Draw();
g->SaveAs("~/cern/plots/m_Chic_sweighted.png");
*/
}