static void
SHA256Transform(uint32_t *H, const uint8_t *cp)
{
uint32_t a, b, c, d, e, f, g, h, t, T1, T2, W[64];
for (t = 0; t < 16; t++, cp += 4)
W[t] = (cp[0] << 24) | (cp[1] << 16) | (cp[2] << 8) | cp[3];
for (t = 16; t < 64; t++)
W[t] = sigma1(W[t - 2]) + W[t - 7] +
sigma0(W[t - 15]) + W[t - 16];
a = H[0]; b = H[1]; c = H[2]; d = H[3];
e = H[4]; f = H[5]; g = H[6]; h = H[7];
for (t = 0; t < 64; t++) {
T1 = h + SIGMA1(e) + Ch(e, f, g) + SHA256_K[t] + W[t];
T2 = SIGMA0(a) + Maj(a, b, c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
H[0] += a; H[1] += b; H[2] += c; H[3] += d;
H[4] += e; H[5] += f; H[6] += g; H[7] += h;
}
void testMassFit()
{
TFile* file = TFile::Open("plots_btodmunu_TTJets_Filtered.root");
TH1F* correctedBHisto = (TH1F*)file->Get("massBCorrected/massBCorrected_sig");
RooRealVar correctedBMass("correctedBMass", "correctedBMass", 2.0, 10.0);
RooDataHist data("data", "data", correctedBMass, correctedBHisto);
RooRealVar mean1("mean1", "mean1", 5.1, 4.0, 6.0);
RooRealVar sigma1("sigma1", "sigma1", 0.5, 0.1, 1.0);
RooGaussian gaus1("gaus1", "gaus1", correctedBMass, mean1, sigma1);
RooRealVar mean2("mean2", "mean2", 4.8, 3.0, 6.0);
RooRealVar sigma2("sigma2", "sigma2", 0.9, 0.1, 3.5);
RooGaussian gaus2("gaus2", "gaus2", correctedBMass, mean2, sigma2);
RooRealVar fGaus1("fGaus1", "fGaus1", 0.7, 0.0, 1.0);
RooAddPdf model("model", "model", gaus1, gaus2, fGaus1);
model.fitTo(data);
RooPlot* frame = correctedBMass.frame();
data.plotOn(frame);
model.plotOn(frame);
model.paramOn(frame);
frame->Draw();
}
static void sha256_compress(unsigned int* iv, const uint8_t* data) {
unsigned int a, b, c, d, e, f, g, h;
unsigned int s0, s1;
unsigned int t1, t2;
unsigned int work_space[16];
unsigned int n;
unsigned int i;
a = iv[0];
b = iv[1];
c = iv[2];
d = iv[3];
e = iv[4];
f = iv[5];
g = iv[6];
h = iv[7];
for (i = 0; i < 16; ++i) {
n = BigEndian(&data);
t1 = work_space[i] = n;
t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
t2 = Sigma0(a) + Maj(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
for (; i < 64; ++i) {
s0 = work_space[(i + 1) & 0x0f];
s0 = sigma0(s0);
s1 = work_space[(i + 14) & 0x0f];
s1 = sigma1(s1);
t1 = work_space[i & 0xf] += s0 + s1 + work_space[(i + 9) & 0xf];
t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
t2 = Sigma0(a) + Maj(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
iv[0] += a;
iv[1] += b;
iv[2] += c;
iv[3] += d;
iv[4] += e;
iv[5] += f;
iv[6] += g;
iv[7] += h;
}
static void sha256_block (SHA256_CTX *ctx, const void *in, size_t num, int host)
{
unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1,T2;
SHA_LONG X[16];
int i;
const unsigned char *data=in;
while (num--) {
a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3];
e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7];
if (host)
{
const SHA_LONG *W=(const SHA_LONG *)data;
for (i=0;i<16;i++)
{
T1 = X[i] = W[i];
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
data += SHA256_CBLOCK;
}
else
{
SHA_LONG l;
for (i=0;i<16;i++)
{
HOST_c2l(data,l); T1 = X[i] = l;
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
}
for (;i<64;i++)
{
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf];
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
}
}
/**
* sha512 compression function - 32-bit machines
* @param res The resulting hash value
* @param hash The chaining input value
* @param in The message input
*/
void sha512_comp (hashblock res, const hashblock hash, const messageblock in)
{
const uint64_t *W=in;
uint64_t A,E,T;
uint64_t X[9+80],*F;
uint64_t H[8];
int i;
for (i = 0; i < SHA512_DIGEST_LENGTH/8; i++) {
H[i]=PULL64(hash[i*8]);
}
F = X+80;
A = H[0]; F[1] = H[1];
F[2] = H[2]; F[3] = H[3];
E = H[4]; F[5] = H[5];
F[6] = H[6]; F[7] = H[7];
for (i=0;i<16;i++,F--)
{
#ifdef B_ENDIAN
T = W[i];
#else
T = PULL64(W[i]);
#endif
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E,F[5],F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A,F[1],F[2]);
}
for (;i<80;i++,F--)
{
T = sigma0(F[8+16-1]);
T += sigma1(F[8+16-14]);
T += F[8+16] + F[8+16-9];
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E,F[5],F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A,F[1],F[2]);
}
H[0] += A; H[1] += F[1];
H[2] += F[2]; H[3] += F[3];
H[4] += E; H[5] += F[5];
H[6] += F[6]; H[7] += F[7];
for (i = 0; i < SHA512_DIGEST_LENGTH/8; i++) {
PUSH64(H[i],res[i*8]);
}
}
static inline void init_w (uint64_t * W, const uint64_t * block)
{
int t;
for (t = 0; t < 16; t++)
W [t] = read_int ((char *) (block + t));
for (t = 16; t < 80; t++)
W [t] = sigma1 (W [t - 2]) + W [t - 7] +
sigma0 (W [t - 15]) + W [t - 16];
}
void
_sha2block128(uchar *p, ulong len, uint64 *s)
{
uint64 a, b, c, d, e, f, g, h, t1, t2;
uint64 *kp, *wp;
uint64 w[80];
uchar *end;
/* at this point, we have a multiple of 64 bytes */
for(end = p+len; p < end;){
a = s[0];
b = s[1];
c = s[2];
d = s[3];
e = s[4];
f = s[5];
g = s[6];
h = s[7];
for(wp = w; wp < &w[16]; wp++, p += 8)
wp[0] = ((vlong)p[0])<<56 | ((vlong)p[1])<<48 |
((vlong)p[2])<<40 | ((vlong)p[3])<<32 |
p[4] << 24 | p[5] << 16 | p[6] << 8 | p[7];
for(; wp < &w[80]; wp++) {
uint64 s0, s1;
s0 = sigma0(wp[-15]);
s1 = sigma1(wp[-2]);
// wp[0] = sigma1(wp[-2]) + wp[-7] + sigma0(wp[-15]) + wp[-16];
wp[0] = s1 + wp[-7] + s0 + wp[-16];
}
for(kp = K512, wp = w; wp < &w[80]; ) {
t1 = h + SIGMA1(e) + Ch(e,f,g) + *kp++ + *wp++;
t2 = SIGMA0(a) + Maj(a,b,c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
/* save state */
s[0] += a;
s[1] += b;
s[2] += c;
s[3] += d;
s[4] += e;
s[5] += f;
s[6] += g;
s[7] += h;
}
}
/*
* This code should give better results on 32-bit CPU with less than
* ~24 registers, both size and performance wise...
*/
void sha512_block_data_order(uint64_t *state, const uint64_t *W, size_t num) {
uint64_t A, E, T;
uint64_t X[9 + 80], *F;
int i;
while (num--) {
F = X + 80;
A = state[0];
F[1] = state[1];
F[2] = state[2];
F[3] = state[3];
E = state[4];
F[5] = state[5];
F[6] = state[6];
F[7] = state[7];
for (i = 0; i < 16; i++, F--) {
T = from_be_u64(W[i]);
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A, F[1], F[2]);
}
for (; i < 80; i++, F--) {
T = sigma0(F[8 + 16 - 1]);
T += sigma1(F[8 + 16 - 14]);
T += F[8 + 16] + F[8 + 16 - 9];
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A, F[1], F[2]);
}
state[0] += A;
state[1] += F[1];
state[2] += F[2];
state[3] += F[3];
state[4] += E;
state[5] += F[5];
state[6] += F[6];
state[7] += F[7];
W += 16;
}
}
/**
* sha512 compression function - 64-bit machines
* @param res The resulting hash value
* @param hash The chaining input value
* @param in The message input
*/
void sha512_comp (hashblock res, const hashblock hash, const messageblock in)
{
// CHANGE type casting added due to c++
const uint64_t *W=reinterpret_cast<const uint64_t*>(in);
uint64_t a,b,c,d,e,f,g,h,s0,s1,T1,T2;
uint64_t X[16];
uint64_t H[8];
int i;
for (i = 0; i < SHA512_DIGEST_LENGTH/8; i++) {
H[i]=PULL64(hash[i*8]);
}
a = H[0]; b = H[1]; c = H[2]; d = H[3];
e = H[4]; f = H[5]; g = H[6]; h = H[7];
for (i=0;i<16;i++)
{
#ifdef B_ENDIAN
T1 = X[i] = W[i];
#else
T1 = X[i] = PULL64(W[i]);
#endif
T1 += h + Sigma1(e) + Ch(e,f,g) + K512[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
for (;i<80;i++)
{
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf];
T1 += h + Sigma1(e) + Ch(e,f,g) + K512[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
H[0] += a; H[1] += b; H[2] += c; H[3] += d;
H[4] += e; H[5] += f; H[6] += g; H[7] += h;
for (i = 0; i < SHA512_DIGEST_LENGTH/8; i++) {
PUSH64(H[i],res[i*8]);
}
}
void
_sha2block64(uchar *p, ulong len, uint32 *s)
{
uint32 a, b, c, d, e, f, g, h, t1, t2;
uint32 *kp, *wp;
uint32 w[64];
uchar *end;
/* at this point, we have a multiple of 64 bytes */
for(end = p+len; p < end;){
a = s[0];
b = s[1];
c = s[2];
d = s[3];
e = s[4];
f = s[5];
g = s[6];
h = s[7];
for(wp = w; wp < &w[16]; wp++, p += 4)
wp[0] = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
for(; wp < &w[64]; wp++)
wp[0] = sigma1(wp[-2]) + wp[-7] +
sigma0(wp[-15]) + wp[-16];
for(kp = K256, wp = w; wp < &w[64]; ) {
t1 = h + SIGMA1(e) + Ch(e,f,g) + *kp++ + *wp++;
t2 = SIGMA0(a) + Maj(a,b,c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
/* save state */
s[0] += a;
s[1] += b;
s[2] += c;
s[3] += d;
s[4] += e;
s[5] += f;
s[6] += g;
s[7] += h;
}
}
/*****************************************
* sha256 compression function *
* *
* H points to chaining input *
* in points to the message input *
* *
*****************************************/
void sha256_comp (hashblock res, const hashblock hash, const void *in)
{
uint32_t a,b,c,d,e,f,g,h,s0,s1,T1,T2;
uint32_t H[8];
uint32_t X[16],l;
int i;
// CHANGE type casting added due to c++
const unsigned char *data=static_cast<const unsigned char*>(in);
for (i = 0; i < SHA256_DIGEST_LENGTH/4; i++) {
HOST_c2l(hash, H[i]);
}
a = H[0]; b = H[1]; c = H[2]; d = H[3];
e = H[4]; f = H[5]; g = H[6]; h = H[7];
for (i=0;i<16;i++)
{
HOST_c2l(data,l); T1 = X[i] = l;
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g;
g = f;
f = e;
e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
for (;i<64;i++)
{
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf];
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
H[0] += a; H[1] += b; H[2] += c; H[3] += d;
H[4] += e; H[5] += f; H[6] += g; H[7] += h;
for (i = 0; i < SHA256_DIGEST_LENGTH/4; i++) {
HOST_l2c(H[i], res);
}
}
void sha256_block_data_order (SHA256_CTX *ctx, const void *in)
{
unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1,T2,t;
SHA_LONG X[16],l,Ki;
int i;
const unsigned char *data=in;
a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3];
e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7];
for (i=0;i<16;i++)
{
HOST_c2l(data,l); X[i] = l;
Ki=K256[i];
T1 = l + h + Sigma1(e) + Ch(e,f,g) + Ki;
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
for (;i<64;i++)
{
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
T1 = X[i&0xf];
t = X[(i+9)&0xf];
T1 += s0 + s1 + t;
X[i&0xf] = T1;
Ki=K256[i];
T1 += h + Sigma1(e) + Ch(e,f,g) + Ki;
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
t=ctx->h[0]; ctx->h[0]=t+a;
t=ctx->h[1]; ctx->h[1]=t+b;
t=ctx->h[2]; ctx->h[2]=t+c;
t=ctx->h[3]; ctx->h[3]=t+d;
t=ctx->h[4]; ctx->h[4]=t+e;
t=ctx->h[5]; ctx->h[5]=t+f;
t=ctx->h[6]; ctx->h[6]=t+g;
t=ctx->h[7]; ctx->h[7]=t+h;
return;
}
static inline void
init_w_native_byte_order (uint64_t * W, const uint64_t * block)
{
W [ 0] = block [ 0];
W [ 1] = block [ 1];
W [ 2] = block [ 2];
W [ 3] = block [ 3];
W [ 4] = block [ 4];
W [ 5] = block [ 5];
W [ 6] = block [ 6];
W [ 7] = block [ 7];
W [ 8] = block [ 8];
W [ 9] = block [ 9];
W [10] = block [10];
W [11] = block [11];
W [12] = block [12];
W [13] = block [13];
W [14] = block [14];
W [15] = block [15];
int t;
for (t = 16; t < 80; t++)
W [t] = sigma1 (W [t - 2]) + W [t - 7] +
sigma0 (W [t - 15]) + W [t - 16];
}
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");
*/
}
int main ( )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for RECTANGLE.
Discussion:
This driver computes the interpolation of the Franke function
on the rectangle R(A,B) = [A1,B1] x [A2,B2] with A=(A1,A2)=(0,0)
and B=(B1,B2)=(1,1) (unit square) at the FAMILY = 1 of Padua points.
The degree of interpolation is DEG = 60 and the number of target
points is NTG = NTG1^2, NTG1 = 100.
The maps from the reference square [-1,1]^2 to the rectangle
are SIGMA1 and SIGMA2 with inverses ISIGM1 and ISIGM2.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
16 February 2014
Author:
Original FORTRAN77 version by Marco Caliari, Stefano De Marchi,
Marco Vianello.
This C version by John Burkardt.
Reference:
Marco Caliari, Stefano de Marchi, Marco Vianello,
Algorithm 886:
Padua2D: Lagrange Interpolation at Padua Points on Bivariate Domains,
ACM Transactions on Mathematical Software,
Volume 35, Number 3, October 2008, Article 21, 11 pages.
Parameters:
Local, int DEGMAX, the maximum degree of interpolation.
Local, int NPDMAX, the maximum number of Padua points
= (DEGMAX + 1) * (DEGMAX + 2) / 2.
Local, int NTG1MX, the maximum value of the parameter determining
the number of target points.
Local, int NTGMAX, the maximum number of target points,
dependent on NTG1MX.
Local, int DEG, the degree of interpolation,
Local, int NTG1, the parameter determining the number
of target points.
Local, int FAMILY, specifies the desired family of Padua points.
Local, int NPD, the number of Padua points = (DEG + 1) * (DEG + 2) / 2.
Local, int NTG, the number of target points, dependent on NTG1.
Local, double PD1[NPDMAX], the first coordinates of
the Padua points.
Local, double PD2[NPDMAX], the second coordinates of the
Padua points.
Local, double WPD[NPDMAX], the weights.
Local, double FPD[NPDMAX], the function at the Padua points.
Workspace, double RAUX1[(DEGMAX+1)*(DEGMAX+2)].
Workspace, double RAUX2[(DEGMAX+1)*(DEGMAX+2)].
Local, double C0[(0:DEGMAX+1)*(0:DEGMAX+1)], the coefficient matrix.
Local, double TG1[NTGMAX], the first coordinates of the
target points.
Local, double TG2[NTGMAX], the second coordinates of the
target points.
Local, double INTFTG[NTGMAX], the values of the
interpolated function.
Local, double MAXERR, the maximum norm of the error at target
points.
Local, double ESTERR, the estimated error.
*/
{
# define DEGMAX 60
# define NTG1MX 100
# define NPDMAX ( ( DEGMAX + 1 ) * ( DEGMAX + 2 ) / 2 )
# define NTGMAX ( NTG1MX * NTG1MX )
double a1;
double a2;
double b1;
double b2;
double c0[(DEGMAX+2)*(DEGMAX+2)];
int deg;
int degmax = DEGMAX;
double esterr;
int family;
char filename[255];
double fmax;
double fmin;
double fpd[NPDMAX];
double fxy;
int i;
double intftg[NTGMAX];
double ixy;
double maxdev;
double maxerr;
double mean;
int npd;
int npdmax = NPDMAX;
int ntg;
int ntg1;
int ntg1mx = NTG1MX;
int ntgmax = NTGMAX;
FILE *output;
double pd1[NPDMAX];
double pd2[NPDMAX];
double raux1[(DEGMAX+1)*(DEGMAX+2)];
double raux2[(DEGMAX+1)*(DEGMAX+2)];
double tg1[NTGMAX];
double tg2[NTGMAX];
double wpd[NPDMAX];
double x;
double y;
a1 = 0.0;
a2 = 0.0;
b1 = 1.0;
b2 = 1.0;
family = 1;
deg = 60;
ntg1 = 100;
timestamp ( );
printf ( "\n" );
printf ( "RECTANGLE:\n" );
printf ( " C version\n" );
printf ( " Interpolation of the Franke function\n" );
printf ( " on the unit square [0,1] x [0,1]\n" );
printf ( " of degree = %d\n", deg );
if ( degmax < deg )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "RECTANGLE - Fatal error!\n" );
fprintf ( stderr, " DEGMAX < DEG.\n" );
fprintf ( stderr, " DEG = %d\n", deg );
fprintf ( stderr, " DEGMAX = %d\n", degmax );
exit ( 1 );
}
/*
Build the first family of Padua points in the square [-1,1]^2
*/
pdpts ( deg, pd1, pd2, wpd, &npd );
/*
Compute the Franke function at Padua points mapped to the region.
*/
for ( i = 0; i < npd; i++ )
{
x = sigma1 ( pd1[i], pd2[i], a1, a2, b1, b2, family, deg );
y = sigma2 ( pd1[i], pd2[i], a1, a2, b1, b2, family, deg );
fpd[i] = franke ( x, y );
}
/*
Write X, Y, F(X,Y) to a file.
*/
strcpy ( filename, "rectangle_fpd.txt" );
output = fopen ( filename, "wt" );
for ( i = 0; i < npd; i++ )
{
x = sigma1 ( pd1[i], pd2[i], a1, a2, b1, b2, family, deg );
y = sigma2 ( pd1[i], pd2[i], a1, a2, b1, b2, family, deg );
fprintf ( output, "%g %g %g\n", x, y, fpd[i] );
}
fclose ( output );
printf ( "\n" );
printf ( " Wrote F(x,y) at Padua points in '%s'\n", filename );
/*
Compute the matrix C0 of the coefficients in the bivariate
orthonormal Chebyshev basis
*/
padua2 ( deg, degmax, npd, wpd, fpd, raux1, raux2, c0, &esterr );
/*
Evaluate the target points in the region.
*/
target ( a1, b1, a2, b2, ntg1, ntgmax, tg1, tg2, &ntg );
/*
Evaluate the interpolant at the target points.
*/
for ( i = 0; i < ntg; i++ )
{
x = isigm1 ( tg1[i], tg2[i], a1, a2, b1, b2, family, deg );
y = isigm2 ( tg1[i], tg2[i], a1, a2, b1, b2, family, deg );
intftg[i] = pd2val ( deg, degmax, c0, x, y );
}
/*
Write the function value at target points to a file.
*/
strcpy ( filename, "rectangle_ftg.txt" );
output = fopen ( filename, "wt" );
for ( i = 0; i < ntg; i++ )
{
fprintf ( output, "%g %g %g\n",
tg1[i], tg2[i], franke ( tg1[i], tg2[i] ) );
}
fclose ( output );
printf ( " Wrote F(x,y) at target points in '%s'\n", filename );
/*
Write the interpolated function value at target points to a file.
*/
strcpy ( filename, "ellipse_itg.txt" );
output = fopen ( filename, "wt" );
for ( i = 0; i < ntg; i++ )
{
fprintf ( output, "%g %g %g\n", tg1[i], tg2[i], intftg[i] );
}
fclose ( output );
printf ( " Wrote I(F)(x,y) at target points in '%s'\n", filename );
/*
Compute the error relative to the max deviation from the mean.
*/
maxerr = 0.0;
mean = 0.0;
fmax = - r8_huge ( );
fmin = + r8_huge ( );
for ( i = 0; i < ntg; i++ )
{
fxy = franke ( tg1[i], tg2[i] );
ixy = intftg[i];
maxerr = r8_max ( maxerr, fabs ( fxy - ixy ) );
mean = mean + fxy;
fmax = r8_max ( fmax, fxy );
fmin = r8_min ( fmin, fxy );
}
if ( fmax == fmin )
{
maxdev = 1.0;
}
else
{
mean = mean / ( double ) ( ntg );
maxdev = r8_max ( fmax - mean, mean - fmin );
}
/*
Print error ratios.
*/
printf ( "\n" );
printf ( " Estimated error: %g\n", esterr / maxdev );
printf ( " Actual error: %g\n", maxerr / maxdev );
printf ( " Expected error: %g\n", 0.2468E-10 );
/*
Terminate.
*/
printf ( "\n" );
printf ( "RECTANGLE:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
# undef DEGMAX
# undef NTG1MX
# undef NPDMAX
# undef NTGMAX
}
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");
*/
}
/** Perform one SHA-512 transformation, processing a 128-byte chunk. */
void Transform(uint64_t *s, const unsigned char *chunk) {
uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
Round(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22ull, w0 = ReadBE64(chunk + 0));
Round(h, a, b, c, d, e, f, g, 0x7137449123ef65cdull, w1 = ReadBE64(chunk + 8));
Round(g, h, a, b, c, d, e, f, 0xb5c0fbcfec4d3b2full, w2 = ReadBE64(chunk + 16));
Round(f, g, h, a, b, c, d, e, 0xe9b5dba58189dbbcull, w3 = ReadBE64(chunk + 24));
Round(e, f, g, h, a, b, c, d, 0x3956c25bf348b538ull, w4 = ReadBE64(chunk + 32));
Round(d, e, f, g, h, a, b, c, 0x59f111f1b605d019ull, w5 = ReadBE64(chunk + 40));
Round(c, d, e, f, g, h, a, b, 0x923f82a4af194f9bull, w6 = ReadBE64(chunk + 48));
Round(b, c, d, e, f, g, h, a, 0xab1c5ed5da6d8118ull, w7 = ReadBE64(chunk + 56));
Round(a, b, c, d, e, f, g, h, 0xd807aa98a3030242ull, w8 = ReadBE64(chunk + 64));
Round(h, a, b, c, d, e, f, g, 0x12835b0145706fbeull, w9 = ReadBE64(chunk + 72));
Round(g, h, a, b, c, d, e, f, 0x243185be4ee4b28cull, w10 = ReadBE64(chunk + 80));
Round(f, g, h, a, b, c, d, e, 0x550c7dc3d5ffb4e2ull, w11 = ReadBE64(chunk + 88));
Round(e, f, g, h, a, b, c, d, 0x72be5d74f27b896full, w12 = ReadBE64(chunk + 96));
Round(d, e, f, g, h, a, b, c, 0x80deb1fe3b1696b1ull, w13 = ReadBE64(chunk + 104));
Round(c, d, e, f, g, h, a, b, 0x9bdc06a725c71235ull, w14 = ReadBE64(chunk + 112));
Round(b, c, d, e, f, g, h, a, 0xc19bf174cf692694ull, w15 = ReadBE64(chunk + 120));
Round(a, b, c, d, e, f, g, h, 0xe49b69c19ef14ad2ull, w0 += sigma1(w14) + w9 + sigma0( w1));
Round(h, a, b, c, d, e, f, g, 0xefbe4786384f25e3ull, w1 += sigma1(w15) + w10 + sigma0( w2));
Round(g, h, a, b, c, d, e, f, 0x0fc19dc68b8cd5b5ull, w2 += sigma1( w0) + w11 + sigma0( w3));
Round(f, g, h, a, b, c, d, e, 0x240ca1cc77ac9c65ull, w3 += sigma1( w1) + w12 + sigma0( w4));
Round(e, f, g, h, a, b, c, d, 0x2de92c6f592b0275ull, w4 += sigma1( w2) + w13 + sigma0( w5));
Round(d, e, f, g, h, a, b, c, 0x4a7484aa6ea6e483ull, w5 += sigma1( w3) + w14 + sigma0( w6));
Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcbd41fbd4ull, w6 += sigma1( w4) + w15 + sigma0( w7));
Round(b, c, d, e, f, g, h, a, 0x76f988da831153b5ull, w7 += sigma1( w5) + w0 + sigma0( w8));
Round(a, b, c, d, e, f, g, h, 0x983e5152ee66dfabull, w8 += sigma1( w6) + w1 + sigma0( w9));
Round(h, a, b, c, d, e, f, g, 0xa831c66d2db43210ull, w9 += sigma1( w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0xb00327c898fb213full, w10 += sigma1( w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0xbf597fc7beef0ee4ull, w11 += sigma1( w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0xc6e00bf33da88fc2ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xd5a79147930aa725ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0x06ca6351e003826full, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x142929670a0e6e70ull, w15 += sigma1(w13) + w8 + sigma0( w0));
Round(a, b, c, d, e, f, g, h, 0x27b70a8546d22ffcull, w0 += sigma1(w14) + w9 + sigma0( w1));
Round(h, a, b, c, d, e, f, g, 0x2e1b21385c26c926ull, w1 += sigma1(w15) + w10 + sigma0( w2));
Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc5ac42aedull, w2 += sigma1( w0) + w11 + sigma0( w3));
Round(f, g, h, a, b, c, d, e, 0x53380d139d95b3dfull, w3 += sigma1( w1) + w12 + sigma0( w4));
Round(e, f, g, h, a, b, c, d, 0x650a73548baf63deull, w4 += sigma1( w2) + w13 + sigma0( w5));
Round(d, e, f, g, h, a, b, c, 0x766a0abb3c77b2a8ull, w5 += sigma1( w3) + w14 + sigma0( w6));
Round(c, d, e, f, g, h, a, b, 0x81c2c92e47edaee6ull, w6 += sigma1( w4) + w15 + sigma0( w7));
Round(b, c, d, e, f, g, h, a, 0x92722c851482353bull, w7 += sigma1( w5) + w0 + sigma0( w8));
Round(a, b, c, d, e, f, g, h, 0xa2bfe8a14cf10364ull, w8 += sigma1( w6) + w1 + sigma0( w9));
Round(h, a, b, c, d, e, f, g, 0xa81a664bbc423001ull, w9 += sigma1( w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0xc24b8b70d0f89791ull, w10 += sigma1( w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0xc76c51a30654be30ull, w11 += sigma1( w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0xd192e819d6ef5218ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xd69906245565a910ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0xf40e35855771202aull, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x106aa07032bbd1b8ull, w15 += sigma1(w13) + w8 + sigma0( w0));
Round(a, b, c, d, e, f, g, h, 0x19a4c116b8d2d0c8ull, w0 += sigma1(w14) + w9 + sigma0( w1));
Round(h, a, b, c, d, e, f, g, 0x1e376c085141ab53ull, w1 += sigma1(w15) + w10 + sigma0( w2));
Round(g, h, a, b, c, d, e, f, 0x2748774cdf8eeb99ull, w2 += sigma1( w0) + w11 + sigma0( w3));
Round(f, g, h, a, b, c, d, e, 0x34b0bcb5e19b48a8ull, w3 += sigma1( w1) + w12 + sigma0( w4));
Round(e, f, g, h, a, b, c, d, 0x391c0cb3c5c95a63ull, w4 += sigma1( w2) + w13 + sigma0( w5));
Round(d, e, f, g, h, a, b, c, 0x4ed8aa4ae3418acbull, w5 += sigma1( w3) + w14 + sigma0( w6));
Round(c, d, e, f, g, h, a, b, 0x5b9cca4f7763e373ull, w6 += sigma1( w4) + w15 + sigma0( w7));
Round(b, c, d, e, f, g, h, a, 0x682e6ff3d6b2b8a3ull, w7 += sigma1( w5) + w0 + sigma0( w8));
Round(a, b, c, d, e, f, g, h, 0x748f82ee5defb2fcull, w8 += sigma1( w6) + w1 + sigma0( w9));
Round(h, a, b, c, d, e, f, g, 0x78a5636f43172f60ull, w9 += sigma1( w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0x84c87814a1f0ab72ull, w10 += sigma1( w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0x8cc702081a6439ecull, w11 += sigma1( w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0x90befffa23631e28ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xa4506cebde82bde9ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0xbef9a3f7b2c67915ull, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0xc67178f2e372532bull, w15 += sigma1(w13) + w8 + sigma0( w0));
Round(a, b, c, d, e, f, g, h, 0xca273eceea26619cull, w0 += sigma1(w14) + w9 + sigma0( w1));
Round(h, a, b, c, d, e, f, g, 0xd186b8c721c0c207ull, w1 += sigma1(w15) + w10 + sigma0( w2));
Round(g, h, a, b, c, d, e, f, 0xeada7dd6cde0eb1eull, w2 += sigma1( w0) + w11 + sigma0( w3));
Round(f, g, h, a, b, c, d, e, 0xf57d4f7fee6ed178ull, w3 += sigma1( w1) + w12 + sigma0( w4));
Round(e, f, g, h, a, b, c, d, 0x06f067aa72176fbaull, w4 += sigma1( w2) + w13 + sigma0( w5));
Round(d, e, f, g, h, a, b, c, 0x0a637dc5a2c898a6ull, w5 += sigma1( w3) + w14 + sigma0( w6));
Round(c, d, e, f, g, h, a, b, 0x113f9804bef90daeull, w6 += sigma1( w4) + w15 + sigma0( w7));
Round(b, c, d, e, f, g, h, a, 0x1b710b35131c471bull, w7 += sigma1( w5) + w0 + sigma0( w8));
Round(a, b, c, d, e, f, g, h, 0x28db77f523047d84ull, w8 += sigma1( w6) + w1 + sigma0( w9));
Round(h, a, b, c, d, e, f, g, 0x32caab7b40c72493ull, w9 += sigma1( w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0x3c9ebe0a15c9bebcull, w10 += sigma1( w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0x431d67c49c100d4cull, w11 += sigma1( w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0x4cc5d4becb3e42b6ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0x597f299cfc657e2aull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faecull, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x6c44198c4a475817ull, w15 += sigma1(w13) + w8 + sigma0( w0));
s[0] += a;
s[1] += b;
s[2] += c;
s[3] += d;
s[4] += e;
s[5] += f;
s[6] += g;
s[7] += h;
}
/* main */
int main(int argc, char *argv[]) {
std::ios_base::sync_with_stdio(false);
// arguments: p1 p2 [y|(* \ {y})] [true|false]
size_t p1 = argc > 2 ? fast_atoi(argv[1]) : 1; // default = 1
size_t p2 = argc > 2 ? fast_atoi(argv[2]) : 1; // default = 1
bool has_constraints = false; // if there are constraints
if (argc > 3) has_constraints = strcmp(argv[3],"1") || strcmp(argv[3], "y");
/* if default_constraints_mode is true:
* constraints in input mean ONLY THESE MATCH
* otherwise:
* constraints in input mean ALL EXCEPT THESE MATCH
*/
bool default_constraints_mode = false; // the semantic of the constraints
//if (has_constraints) default_constraints_mode = strcmp(argv[4], "t");
/* (1) read strings, extract sigmas and constraints too */
std::string s1, s2;
std::string sigma1(""), sigma2("");
read_stdin(s1, s2);
extract_sigma(s1, sigma1);
extract_sigma(s2, sigma2);
size_t sigma1l = sigma1.size();
size_t sigma2l = sigma2.size();
size_t s1l = s1.size();
size_t s2l = s2.size();
std::vector<p_constr> constraints;
if (has_constraints)
read_constraints(constraints);
/* define the mapping from char -> int */
std::map<char, int> map1;
std::map<char, int> map2;
define_mapping(sigma1, map1);
define_mapping(sigma2, map2);
/* integer representations of strings and sigmas */
unsigned* s1i = new unsigned[s1l];
unsigned* s2i = new unsigned[s2l];
unsigned* sigma1i = new unsigned[sigma1l];
unsigned* sigma2i = new unsigned[sigma2l];
for (size_t i = 0; i < sigma1l; ++i) sigma1i[i] = i; // sigma1
for (size_t i = 0; i < sigma2l; ++i) sigma2i[i] = i; // sigma2
for (size_t i = 0; i < s1l; ++i) s1i[i] = map1[s1[i]]; // s1
for (size_t i = 0; i < s2l; ++i) s2i[i] = map2[s2[i]]; // s2
if (_DEBUG) {
std::cout << "strings: " << s1 << ", " << s2 << endl;
std::cout << "sigmas: " << sigma1 << ", " << sigma2 << endl;
std::cout << "int rep (s1): ";
for (size_t i = 0; i < s1l; ++i) std::cout << s1i[i]; std::cout << endl;
std::cout << "int rep (s2): ";
for (size_t i = 0; i < s2l; ++i) std::cout << s2i[i]; std::cout << endl;
std::cout << "int rep (sigma1): ";
for (size_t i = 0; i < sigma1l; ++i) std::cout << sigma1i[i]; std::cout << endl;
std::cout << "int rep (sigma2): ";
for (size_t i = 0; i < sigma2l; ++i) std::cout << sigma2i[i]; std::cout << endl;
}
/* identity (classical) matching schema */
matching_schema<bool> ms(sigma1l, sigma2l, p1, p2, true, default_constraints_mode);
ms.set_general(sigma1, sigma2, false);
if (has_constraints)
ms.set_constraints(map1, map2, constraints, !default_constraints_mode);
if (_DEBUG) {
if (has_constraints) {
std::cout << "Constraints: ";
for(std::vector<p_constr>::size_type i = 0; i < constraints.size(); ++i)
std::cout << constraints[i].first << ", " << constraints[i].second << endl;
}
ms.print_matching_schema(sigma1, sigma2);
}
//int d = bruteforce(s1i, s2i, s1l, s2l, sigma1i, sigma2i, sigma1l, sigma2l, ms);
int d = hill_climbing(s1i, s2i, s1l, s2l, sigma1i, sigma2i, sigma1l, sigma2l, p1, ms);
std::cout << d << endl;
//Alignment<int> a = compute_alignment(s1i, s2i, s1l, s2l, ms);
//std::cout << distance_from_alignment(a, sigma1, sigma2, ms, false) << endl;
return 0;
}
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());
}
static inline void sha256_transform(__m128i *state, __m128i *block, __m128i *dst)
{
__m128i W[64], t1, t2;
W[0] = block[ 0];
W[1] = block[ 1];
W[2] = block[ 2];
W[3] = block[ 3];
W[4] = block[ 4];
W[5] = block[ 5];
W[6] = block[ 6];
W[7] = block[ 7];
W[8] = block[ 8];
W[9] = block[ 9];
W[10] = block[10];
W[11] = block[11];
W[12] = block[12];
W[13] = block[13];
W[14] = block[14];
W[15] = block[15];
W[16] = add4(sigma1(W[16 - 2]), W[16 - 7], sigma0(W[16 - 15]), W[16 - 16]);
W[17] = add4(sigma1(W[17 - 2]), W[17 - 7], sigma0(W[17 - 15]), W[17 - 16]);
W[18] = add4(sigma1(W[18 - 2]), W[18 - 7], sigma0(W[18 - 15]), W[18 - 16]);
W[19] = add4(sigma1(W[19 - 2]), W[19 - 7], sigma0(W[19 - 15]), W[19 - 16]);
W[20] = add4(sigma1(W[20 - 2]), W[20 - 7], sigma0(W[20 - 15]), W[20 - 16]);
W[21] = add4(sigma1(W[21 - 2]), W[21 - 7], sigma0(W[21 - 15]), W[21 - 16]);
W[22] = add4(sigma1(W[22 - 2]), W[22 - 7], sigma0(W[22 - 15]), W[22 - 16]);
W[23] = add4(sigma1(W[23 - 2]), W[23 - 7], sigma0(W[23 - 15]), W[23 - 16]);
W[24] = add4(sigma1(W[24 - 2]), W[24 - 7], sigma0(W[24 - 15]), W[24 - 16]);
W[25] = add4(sigma1(W[25 - 2]), W[25 - 7], sigma0(W[25 - 15]), W[25 - 16]);
W[26] = add4(sigma1(W[26 - 2]), W[26 - 7], sigma0(W[26 - 15]), W[26 - 16]);
W[27] = add4(sigma1(W[27 - 2]), W[27 - 7], sigma0(W[27 - 15]), W[27 - 16]);
W[28] = add4(sigma1(W[28 - 2]), W[28 - 7], sigma0(W[28 - 15]), W[28 - 16]);
W[29] = add4(sigma1(W[29 - 2]), W[29 - 7], sigma0(W[29 - 15]), W[29 - 16]);
W[30] = add4(sigma1(W[30 - 2]), W[30 - 7], sigma0(W[30 - 15]), W[30 - 16]);
W[31] = add4(sigma1(W[31 - 2]), W[31 - 7], sigma0(W[31 - 15]), W[31 - 16]);
W[32] = add4(sigma1(W[32 - 2]), W[32 - 7], sigma0(W[32 - 15]), W[32 - 16]);
W[33] = add4(sigma1(W[33 - 2]), W[33 - 7], sigma0(W[33 - 15]), W[33 - 16]);
W[34] = add4(sigma1(W[34 - 2]), W[34 - 7], sigma0(W[34 - 15]), W[34 - 16]);
W[35] = add4(sigma1(W[35 - 2]), W[35 - 7], sigma0(W[35 - 15]), W[35 - 16]);
W[36] = add4(sigma1(W[36 - 2]), W[36 - 7], sigma0(W[36 - 15]), W[36 - 16]);
W[37] = add4(sigma1(W[37 - 2]), W[37 - 7], sigma0(W[37 - 15]), W[37 - 16]);
W[38] = add4(sigma1(W[38 - 2]), W[38 - 7], sigma0(W[38 - 15]), W[38 - 16]);
W[39] = add4(sigma1(W[39 - 2]), W[39 - 7], sigma0(W[39 - 15]), W[39 - 16]);
W[40] = add4(sigma1(W[40 - 2]), W[40 - 7], sigma0(W[40 - 15]), W[40 - 16]);
W[41] = add4(sigma1(W[41 - 2]), W[41 - 7], sigma0(W[41 - 15]), W[41 - 16]);
W[42] = add4(sigma1(W[42 - 2]), W[42 - 7], sigma0(W[42 - 15]), W[42 - 16]);
W[43] = add4(sigma1(W[43 - 2]), W[43 - 7], sigma0(W[43 - 15]), W[43 - 16]);
W[44] = add4(sigma1(W[44 - 2]), W[44 - 7], sigma0(W[44 - 15]), W[44 - 16]);
W[45] = add4(sigma1(W[45 - 2]), W[45 - 7], sigma0(W[45 - 15]), W[45 - 16]);
W[46] = add4(sigma1(W[46 - 2]), W[46 - 7], sigma0(W[46 - 15]), W[46 - 16]);
W[47] = add4(sigma1(W[47 - 2]), W[47 - 7], sigma0(W[47 - 15]), W[47 - 16]);
W[48] = add4(sigma1(W[48 - 2]), W[48 - 7], sigma0(W[48 - 15]), W[48 - 16]);
W[49] = add4(sigma1(W[49 - 2]), W[49 - 7], sigma0(W[49 - 15]), W[49 - 16]);
W[50] = add4(sigma1(W[50 - 2]), W[50 - 7], sigma0(W[50 - 15]), W[50 - 16]);
W[51] = add4(sigma1(W[51 - 2]), W[51 - 7], sigma0(W[51 - 15]), W[51 - 16]);
W[52] = add4(sigma1(W[52 - 2]), W[52 - 7], sigma0(W[52 - 15]), W[52 - 16]);
W[53] = add4(sigma1(W[53 - 2]), W[53 - 7], sigma0(W[53 - 15]), W[53 - 16]);
W[54] = add4(sigma1(W[54 - 2]), W[54 - 7], sigma0(W[54 - 15]), W[54 - 16]);
W[55] = add4(sigma1(W[55 - 2]), W[55 - 7], sigma0(W[55 - 15]), W[55 - 16]);
W[56] = add4(sigma1(W[56 - 2]), W[56 - 7], sigma0(W[56 - 15]), W[56 - 16]);
W[57] = add4(sigma1(W[57 - 2]), W[57 - 7], sigma0(W[57 - 15]), W[57 - 16]);
W[58] = add4(sigma1(W[58 - 2]), W[58 - 7], sigma0(W[58 - 15]), W[58 - 16]);
W[59] = add4(sigma1(W[59 - 2]), W[59 - 7], sigma0(W[59 - 15]), W[59 - 16]);
W[60] = add4(sigma1(W[60 - 2]), W[60 - 7], sigma0(W[60 - 15]), W[60 - 16]);
W[61] = add4(sigma1(W[61 - 2]), W[61 - 7], sigma0(W[61 - 15]), W[61 - 16]);
W[62] = add4(sigma1(W[62 - 2]), W[62 - 7], sigma0(W[62 - 15]), W[62 - 16]);
W[63] = add4(sigma1(W[63 - 2]), W[63 - 7], sigma0(W[63 - 15]), W[63 - 16]);
// read existing state
__m128i a = state[0];
__m128i b = state[1];
__m128i c = state[2];
__m128i d = state[3];
__m128i e = state[4];
__m128i f = state[5];
__m128i g = state[6];
__m128i h = state[7];
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0x428a2f98), W[0]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0x71374491), W[1]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0xb5c0fbcf), W[2]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0xe9b5dba5), W[3]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x3956c25b), W[4]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0x59f111f1), W[5]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x923f82a4), W[6]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0xab1c5ed5), W[7]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0xd807aa98), W[8]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0x12835b01), W[9]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0x243185be), W[10]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0x550c7dc3), W[11]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x72be5d74), W[12]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0x80deb1fe), W[13]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x9bdc06a7), W[14]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0xc19bf174), W[15]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0xe49b69c1), W[16]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0xefbe4786), W[17]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0x0fc19dc6), W[18]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0x240ca1cc), W[19]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x2de92c6f), W[20]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0x4a7484aa), W[21]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x5cb0a9dc), W[22]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0x76f988da), W[23]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0x983e5152), W[24]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0xa831c66d), W[25]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0xb00327c8), W[26]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0xbf597fc7), W[27]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0xc6e00bf3), W[28]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0xd5a79147), W[29]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x06ca6351), W[30]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0x14292967), W[31]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0x27b70a85), W[32]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0x2e1b2138), W[33]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0x4d2c6dfc), W[34]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0x53380d13), W[35]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x650a7354), W[36]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0x766a0abb), W[37]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x81c2c92e), W[38]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0x92722c85), W[39]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0xa2bfe8a1), W[40]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0xa81a664b), W[41]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0xc24b8b70), W[42]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0xc76c51a3), W[43]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0xd192e819), W[44]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0xd6990624), W[45]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0xf40e3585), W[46]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0x106aa070), W[47]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0x19a4c116), W[48]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0x1e376c08), W[49]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0x2748774c), W[50]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0x34b0bcb5), W[51]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x391c0cb3), W[52]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0x4ed8aa4a), W[53]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0x5b9cca4f), W[54]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0x682e6ff3), W[55]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
t1 = add5(h, Sigma1(e), Ch(e, f, g), _mm_set1_epi32(0x748f82ee), W[56]);
t2 = add2(Sigma0(a), Maj(a, b, c));
d = add2(d, t1);
h = add2(t1, t2);
t1 = add5(g, Sigma1(d), Ch(d, e, f), _mm_set1_epi32(0x78a5636f), W[57]);
t2 = add2(Sigma0(h), Maj(h, a, b));
c = add2(c, t1);
g = add2(t1, t2);
t1 = add5(f, Sigma1(c), Ch(c, d, e), _mm_set1_epi32(0x84c87814), W[58]);
t2 = add2(Sigma0(g), Maj(g, h, a));
b = add2(b, t1);
f = add2(t1, t2);
t1 = add5(e, Sigma1(b), Ch(b, c, d), _mm_set1_epi32(0x8cc70208), W[59]);
t2 = add2(Sigma0(f), Maj(f, g, h));
a = add2(a, t1);
e = add2(t1, t2);
t1 = add5(d, Sigma1(a), Ch(a, b, c), _mm_set1_epi32(0x90befffa), W[60]);
t2 = add2(Sigma0(e), Maj(e, f, g));
h = add2(h, t1);
d = add2(t1, t2);
t1 = add5(c, Sigma1(h), Ch(h, a, b), _mm_set1_epi32(0xa4506ceb), W[61]);
t2 = add2(Sigma0(d), Maj(d, e, f));
g = add2(g, t1);
c = add2(t1, t2);
t1 = add5(b, Sigma1(g), Ch(g, h, a), _mm_set1_epi32(0xbef9a3f7), W[62]);
t2 = add2(Sigma0(c), Maj(c, d, e));
f = add2(f, t1);
b = add2(t1, t2);
t1 = add5(a, Sigma1(f), Ch(f, g, h), _mm_set1_epi32(0xc67178f2), W[63]);
t2 = add2(Sigma0(b), Maj(b, c, d));
e = add2(e, t1);
a = add2(t1, t2);
dst[0] = add2(state[0], a);
dst[1] = add2(state[1], b);
dst[2] = add2(state[2], c);
dst[3] = add2(state[3], d);
dst[4] = add2(state[4], e);
dst[5] = add2(state[5], f);
dst[6] = add2(state[6], g);
dst[7] = add2(state[7], h);
}
void pSubChain::calc_inertia_body()
{
// for space
// if(!children[1]) return;
#ifdef USE_MPI
if(sim->rank != rank) return;
if(children[0] && sim->rank != children[0]->rank)
{
// cerr << sim->rank << ": joint (" << last_joint->name << "): recv_inertia from " << children[0]->rank << endl;
children[0]->recv_inertia();
}
if(children[1] && children[0] != children[1] && sim->rank != children[1]->rank)
{
// cerr << sim->rank << ": joint (" << last_joint->name << "): recv_inertia from " << children[1]->rank << endl;
children[1]->recv_inertia();
}
#endif
int i, j;
// cerr << "---- " << last_joint->name << ": calc_inertia_body" << endl;
// P
if(children[1])
{
P.add(children[0]->Lambda[last_index[0]][last_index[0]], children[1]->Lambda[last_index[1]][last_index[1]]);
}
else
{
P.set(children[0]->Lambda[last_index[0]][last_index[0]]);
}
// cerr << "Lambda[0] = " << children[0]->Lambda[last_index[0]][last_index[0]] << endl;
// cerr << "Lambda[1] = " << children[1]->Lambda[last_index[1]][last_index[1]] << endl;
#ifdef PSIM_TEST
{
fMat U1(6,6), V1T(6,6), U2(6,6), V2T(6,6);
fVec sigma1(6), sigma2(6);
children[0]->Lambda[last_index[0]][last_index[0]].svd(U1, sigma1, V1T);
children[1]->Lambda[last_index[1]][last_index[1]].svd(U2, sigma2, V2T);
double s1 = sigma1.length(), s2 = sigma2.length();
if(s1 > 1e-8 && s2 > 1e-8)
{
double ratio = (s1 < s2) ? s2/s1 : s1/s2;
if(max_sigma_ratio < 0.0 || ratio > max_sigma_ratio)
{
max_sigma_ratio = ratio;
max_sigma_ratio_joint = last_joint;
}
sigma_ratios(last_joint->i_dof) = ratio;
// cerr << last_joint->name << ": " << s1 << ", " << s2 << " -> " << ratio << endl;
}
}
#endif
if(children[0] == children[1])
{
P -= children[0]->Lambda[last_index[0]][last_index[1]];
P -= children[0]->Lambda[last_index[1]][last_index[0]];
}
// P should be symmetric
// P += tran(P);
// P *= 0.5;
P.symmetric();
#ifndef USE_DCA
// Gamma
if(n_const > 0)
{
for(i=0; i<n_const; i++)
{
for(j=0; j<n_const; j++)
Gamma(i, j) = P(const_index[i], const_index[j]);
}
if(children[0] != children[1])
{
// Gamma is symmetric, positive-definite
if(Gamma_inv.inv_posv(Gamma))
Gamma_inv.inv_svd(Gamma);
// Gamma_inv.inv_porfs(Gamma);
#ifdef PSIM_TEST
fMat U(n_const, n_const), VT(n_const, n_const);
fVec sigma(n_const);
Gamma.svd(U, sigma, VT);
double cn = sigma(0) / sigma(n_const-1);
if(max_condition_number < 0.0 || cn > max_condition_number)
{
max_condition_number = cn;
max_condition_number_joint = last_joint;
}
condition_numbers(last_joint->i_dof) = cn;
// cerr << "condition_number = " << cn << endl;
// fMat Gamma_inv2(n_const, n_const);
// Gamma_inv2.inv_svd(Gamma, 2000);
// cerr << last_joint->name << ": " << cn << endl;
// fMat I(n_const, n_const);
// I.identity();
// cerr << last_joint->name << ": " << I - Gamma*Gamma_inv << endl;
// cerr << last_joint->name << ": " << Gamma_inv - Gamma_inv2 << endl;
#endif
}
else
{
// Gamma may be singular
Gamma_inv.inv_svd(Gamma);
// cerr << Gamma_inv * Gamma << endl;
}
}
// W, IW
W.zero();
for(i=0; i<n_const; i++)
{
for(int j=0; j<n_const; j++)
{
W(const_index[i], const_index[j]) = -Gamma_inv(i, j);
}
}
#else // #ifndef USE_DCA
static fMat SV, VSV;
SV.resize(n_dof, 6);
VSV.resize(n_dof, 6);
Vhat.inv_posv(P);
if(n_dof > 0)
{
for(i=0; i<n_dof; i++)
{
for(int j=0; j<n_dof; j++)
{
SVS(i,j) = Vhat(joint_index[i], joint_index[j]);
}
for(int j=0; j<6; j++)
{
SV(i,j) = Vhat(joint_index[i], j);
}
}
// cerr << "SVS = " << SVS << endl;
VSV.lineq(SVS, SV);
// cerr << "VSV = " << VSV << endl;
W.mul(tran(SV), VSV);
// W *= -1.0;
}
else
{
W.zero();
}
W -= Vhat;
#endif
// cerr << "P = " << P << endl;
// cerr << "W = " << W << endl;
IW.mul(P, W);
for(i=0; i<6; i++)
{
IW(i, i) += 1.0;
}
// cerr << "IW = " << IW << endl;
// Lambda
if(n_const == 0)
{
for(i=0; i<n_outer_joints; i++)
{
int org_i = outer_joints_origin[i];
int index_i = outer_joints_index[i];
for(j=i; j<n_outer_joints; j++)
{
int org_j = outer_joints_origin[j];
int index_j = outer_joints_index[j];
if(children[org_i] == children[org_j])
{
Lambda[i][j].set(children[org_i]->Lambda[index_i][index_j]);
}
if(i != j)
{
Lambda[j][i].tran(Lambda[i][j]);
}
}
}
}
else
{
for(i=0; i<n_outer_joints; i++)
{
int org_i = outer_joints_origin[i];
int index_i = outer_joints_index[i];
fMat& Lambda_i = children[org_i]->Lambda[index_i][last_index[org_i]];
#ifndef USE_DCA
int m, n;
static fMat LKi, KLj, GKLj;
LKi.resize(6, n_const);
KLj.resize(n_const, 6);
GKLj.resize(n_const, 6);
for(m=0; m<6; m++)
{
for(n=0; n<n_const; n++)
LKi(m, n) = Lambda_i(m, const_index[n]);
}
for(j=i; j<n_outer_joints; j++)
{
int org_j = outer_joints_origin[j];
int index_j = outer_joints_index[j];
fMat& Lambda_j = children[org_j]->Lambda[last_index[org_j]][index_j];
for(m=0; m<n_const; m++)
{
for(n=0; n<6; n++)
KLj(m, n) = Lambda_j(const_index[m], n);
}
GKLj.mul(Gamma_inv, KLj);
// GKLj.lineq_posv(Gamma, KLj);
Lambda[i][j].mul(LKi, GKLj);
if(children[org_i] == children[org_j])
{
Lambda[i][j] -= children[org_i]->Lambda[index_i][index_j];
Lambda[i][j] *= -1.0;
}
if(i != j)
{
Lambda[j][i].tran(Lambda[i][j]);
}
else
{
Lambda[i][j].symmetric();
}
}
#else // #ifndef USE_DCA
for(j=i; j<n_outer_joints; j++)
{
int org_j = outer_joints_origin[j];
int index_j = outer_joints_index[j];
fMat& Lambda_j = children[org_j]->Lambda[last_index[org_j]][index_j];
static fMat WL(6,6);
WL.mul(W, Lambda_j);
WL *= -1.0;
Lambda[i][j].mul(Lambda_i, WL);
if(children[org_i] == children[org_j])
{
Lambda[i][j] -= children[org_i]->Lambda[index_i][index_j];
Lambda[i][j] *= -1.0;
}
if(i != j)
{
Lambda[j][i].tran(Lambda[i][j]);
}
else
{
Lambda[i][j].symmetric();
}
}
#endif
}
}
#ifdef USE_MPI
if(parent && sim->rank != parent->rank)
{
// cerr << sim->rank << ": joint (" << last_joint->name << "): send_inertia to " << parent->rank << endl;
send_inertia(parent->rank);
}
#endif
}
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MinimallyAugmented::ModifiedConstraint::
computeConstraints()
{
if (isValidConstraints)
return NOX::Abstract::Group::Ok;
std::string callingFunction =
"LOCA::TurningPoint::MinimallyAugmented::ModifiedConstraint::computeConstraints()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute J
status = grpPtr->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Set up bordered systems
Teuchos::RCP<const LOCA::BorderedSolver::JacobianOperator> op =
Teuchos::rcp(new LOCA::BorderedSolver::JacobianOperator(grpPtr));
borderedSolver->setMatrixBlocksMultiVecConstraint(op,
a_vector,
b_vector,
Teuchos::null);
// Get linear solver parameters
Teuchos::RCP<Teuchos::ParameterList> linear_solver_params =
parsedParams->getSublist("Linear Solver");
// Solve for w and v
if (isFirstSolve) {
std::cout << "solving for base w,v..." << std::endl;
// Create RHS
NOX::Abstract::MultiVector::DenseMatrix one(1,1);
if (nullVecScaling == NVS_OrderN)
one(0,0) = dn;
else
one(0,0) = 1.0;
// Compute sigma_1 and right null vector v
status = borderedSolver->initForSolve();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
status = borderedSolver->applyInverse(*linear_solver_params,
NULL,
&one,
*v_vector,
sigma1);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Compute sigma_2 and left null vector w
if (!isSymmetric) {
status = borderedSolver->initForTransposeSolve();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
status = borderedSolver->applyInverseTranspose(*linear_solver_params,
NULL,
&one,
*w_vector,
sigma2);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
else {
*w_vector = *v_vector;
sigma2.assign(sigma1);
}
isFirstSolve = false;
}
// solve for updates to w and v
else {
std::cout << "solving for updates..." << std::endl;
// Compute J*v + a*sigma_1
status = grpPtr->applyJacobianMultiVector(*v_vector, *v_residual);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
v_residual->update(Teuchos::NO_TRANS, 1.0, *a_vector, sigma1, 0.0);
// Compute b^T*v - n
NOX::Abstract::MultiVector::DenseMatrix sigma1_residual(1,1);
v_vector->multiply(1.0, *b_vector, sigma1_residual);
if (nullVecScaling == NVS_OrderN)
sigma1_residual(0,0) -= dn;
else
sigma1_residual(0,0) -= 1.0;
if (includeNewtonTerms) {
// Compute (Jv)_x*dx
Teuchos::RCP<NOX::Abstract::MultiVector> Jv_x_dx =
deltaX->clone(NOX::ShapeCopy);
status = grpPtr->computeDJnDxaMulti((*v_vector)[0], *deltaX, *Jv_x_dx);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// Compute (Jv)_p
Teuchos::RCP<NOX::Abstract::MultiVector> Jv_p1 =
deltaX->clone(2);
std::vector<int> idx(1); idx[0] = 0;
Teuchos::RCP<NOX::Abstract::MultiVector> Jv_p =
Jv_p1->subView(idx);
status = grpPtr->computeDJnDpMulti(bifParamID, (*v_vector)[0], *Jv_p1,
false);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// compute v_residual += (Jv)_x*dx + (Jv)_p*dp
v_residual->update(1.0, *Jv_x_dx, deltaP, *Jv_p, 1.0);
// Compute J
status = grpPtr->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
// Compute update to sigma_1 and right null vector v
NOX::Abstract::MultiVector::DenseMatrix sigma1_update(1,1);
status = borderedSolver->initForSolve();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
status = borderedSolver->applyInverse(*linear_solver_params,
v_residual.get(),
&sigma1_residual,
*v_vector_update,
sigma1_update);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// apply updates
v_vector->update(-1.0, *v_vector_update, 1.0);
sigma1(0,0) -= sigma1_update(0,0);
if (!isSymmetric) {
// Compute J^T*w + b*sigma_w
status = grpPtr->applyJacobianTransposeMultiVector(*w_vector,
*w_residual);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
w_residual->update(Teuchos::NO_TRANS, 1.0, *b_vector, sigma2, 0.0);
// Compute a^T*w - n
NOX::Abstract::MultiVector::DenseMatrix sigma2_residual(1,1);
w_vector->multiply(1.0, *a_vector, sigma2_residual);
if (nullVecScaling == NVS_OrderN)
sigma2_residual(0,0) -= dn;
else
sigma2_residual(0,0) -= 1.0;
if (includeNewtonTerms) {
// Compute (J^T*w)_x*dx
Teuchos::RCP<NOX::Abstract::MultiVector> Jtw_x_dx =
deltaX->clone(NOX::ShapeCopy);
status = grpPtr->computeDwtJnDx((*w_vector)[0], (*deltaX)[0],
(*Jtw_x_dx)[0]);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// Compute (J^T*w)_p
Teuchos::RCP<NOX::Abstract::MultiVector> Jtw_p1 =
deltaX->clone(2);
std::vector<int> idx(1); idx[0] = 0;
Teuchos::RCP<NOX::Abstract::MultiVector> Jtw_p =
Jtw_p1->subView(idx);
status = grpPtr->computeDwtJDp(bifParamID, (*w_vector)[0], *Jtw_p1,
false);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// compute w_residual += (J^T*w)_x*dx + (J^T*w)_p*dp
w_residual->update(1.0, *Jtw_x_dx, deltaP, *Jtw_p, 1.0);
// Compute J
status = grpPtr->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
// Compute update to sigma_2 and left null vector w
NOX::Abstract::MultiVector::DenseMatrix sigma2_update(1,1);
status = borderedSolver->initForTransposeSolve();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
status = borderedSolver->applyInverseTranspose(*linear_solver_params,
w_residual.get(),
&sigma2_residual,
*w_vector_update,
sigma2_update);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
// apply updates
w_vector->update(-1.0, *w_vector_update, 1.0);
sigma2(0,0) -= sigma2_update(0,0);
}
else {
*w_vector = *v_vector;
sigma2.assign(sigma1);
}
}
// Compute sigma = -w^T*J*v
status = grpPtr->applyJacobianMultiVector(*v_vector, *Jv_vector);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
if (!isSymmetric) {
status = grpPtr->applyJacobianTransposeMultiVector(*w_vector, *Jtw_vector);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
else
*Jtw_vector = *Jv_vector;
Jv_vector->multiply(-1.0, *w_vector, constraints);
// Scale sigma
double w_norm = (*w_vector)[0].norm();
double v_norm = (*v_vector)[0].norm();
double Jv_norm = (*Jv_vector)[0].norm();
double Jtw_norm = (*Jtw_vector)[0].norm();
if (nullVecScaling == NVS_OrderN)
sigma_scale = dn;
else
sigma_scale = 1.0;
constraints.scale(1.0/sigma_scale);
if (globalData->locaUtils->isPrintType(NOX::Utils::OuterIteration)) {
globalData->locaUtils->out() << "\n\t||Right null vector v|| = "
<< globalData->locaUtils->sciformat(v_norm);
globalData->locaUtils->out() << "\n\t||Left null vector w|| = "
<< globalData->locaUtils->sciformat(w_norm);
globalData->locaUtils->out() << "\n\t||Jv|| = "
<< globalData->locaUtils->sciformat(Jv_norm);
globalData->locaUtils->out() << "\n\t||J^T*w|| = "
<< globalData->locaUtils->sciformat(Jtw_norm);
globalData->locaUtils->out() <<
"\n\tRight estimate for singularity of Jacobian (sigma1) = " <<
globalData->locaUtils->sciformat(sigma1(0,0));
globalData->locaUtils->out() <<
"\n\tLeft estimate for singularity of Jacobian (sigma2) = " <<
globalData->locaUtils->sciformat(sigma2(0,0));
globalData->locaUtils->out() <<
"\n\tFinal Estimate for singularity of Jacobian (sigma) = " <<
globalData->locaUtils->sciformat(constraints(0,0)) << std::endl;
}
isValidConstraints = true;
// Update a and b if requested
if (updateVectorsEveryIteration) {
if (globalData->locaUtils->isPrintType(NOX::Utils::OuterIteration)) {
globalData->locaUtils->out() <<
"\n\tUpdating null vectors for the next nonlinear iteration" <<
std::endl;
}
*a_vector = *w_vector;
*b_vector = *v_vector;
scaleNullVectors((*a_vector)[0],(*b_vector)[0]);
}
return finalStatus;
}
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");
*/
}
