void Low_tangent(edge *e_l, point *o_l, edge *e_r, point *o_r, edge **l_low, point **OL, edge **r_low, point **OR) {
for (point *d_l = Other(e_l, o_l), *d_r = Other(e_r, o_r); ; )
if (C3(o_l, o_r, d_l) < -eps) e_l = Prev(e_l, d_l), o_l = d_l, d_l = Other(e_l, o_l);
else if (C3(o_l, o_r, d_r) < -eps) e_r = Next(e_r, d_r), o_r = d_r, d_r = Other(e_r, o_r);
else break;
*OL = o_l, *OR = o_r; *l_low = e_l, *r_low = e_r;
}
UTYPE
SIZE(C3(libat_,NAME,_fetch)) (UTYPE *mptr, UTYPE opval, int smodel)
{
if (maybe_specialcase_relaxed(smodel))
return C3(__atomic_,NAME,_fetch) (mptr, opval, __ATOMIC_RELAXED);
else if (maybe_specialcase_acqrel(smodel))
return C3(__atomic_,NAME,_fetch) (mptr, opval, __ATOMIC_ACQ_REL);
else
return C3(__atomic_,NAME,_fetch) (mptr, opval, __ATOMIC_SEQ_CST);
}
bool intersectsRect(Vector2 A, Vector2 B, double x, double y, double width, double height) {
Vector2 C0(x, y);
Vector2 D0(x + width, y);
Vector2 C1(x + width, y);
Vector2 D1(x + width, y + height);
Vector2 C2(x + width, y + height);
Vector2 D2(x, y + height);
Vector2 C3(x, y + height);
Vector2 D3(x, y);
bool I0, I1, I2, I3;
Vector2 buf;
I0 = intersects(A, B, C0, D0, buf);
I1 = intersects(A, B, C1, D1, buf);
I2 = intersects(A, B, C2, D2, buf);
I3 = intersects(A, B, C3, D3, buf);
if(I0 || I1 || I2 || I3) {
return false;
}
return true;
}
void ViewmdaModel::setC3(int i) {
if (m_d3<0) return;
if (C3()==i) return;
if ((i<0)||(i>=N3())) return;
m_current_index[m_d3]=i;
emit currentSliceChanged();
}
int main()
{
C0().f0();
C1().f0();
C1().f1();
C2().f0();
C2().f1();
C2().f2();
C3().f0();
C3().f1();
C3().f2();
C3().f3();
}
double SpinAdapted::StackCreCreCreCre::redMatrixElement(Csf c1, vector<Csf>& ladder, const StackSpinBlock* b)
{
assert( build_pattern == "(((CC)(C))(C))" );
double element = 0.0;
int I = get_orbs()[0];
int J = get_orbs()[1];
int K = get_orbs()[2];
int L = get_orbs()[3];
int Slaterlength = c1.det_rep.begin()->first.size();
vector<bool> backupSlater1(Slaterlength,0), backupSlater2(Slaterlength,0);
// Must take into account how the 4-index is built from a combination of the 2-index ops
std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(C))(C))");
assert( quantum_ladder.size() == 3 );
SpinQuantum deltaQuantum12 = quantum_ladder.at(0);
SpinQuantum deltaQuantum123 = quantum_ladder.at(1);
SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);
deltaQuantum[0] = deltaQuantum1234;
// Spin quantum data for CC
IrrepSpace sym12 = deltaQuantum12.get_symm();
int irrep12 = deltaQuantum12.get_symm().getirrep();
int spin12 = deltaQuantum12.get_s().getirrep();
// Spin quantum data for (CC)C
IrrepSpace sym123 = deltaQuantum123.get_symm();
int irrep123 = deltaQuantum123.get_symm().getirrep();
int spin123= deltaQuantum123.get_s().getirrep();
// Spin quantum data for total operator
IrrepSpace sym1234 = deltaQuantum1234.get_symm();
int irrep1234 = deltaQuantum1234.get_symm().getirrep();
int spin1234 = deltaQuantum1234.get_s().getirrep();
TensorOp C1(I, 1);
TensorOp C2(J, 1);
TensorOp C3(K, 1);
TensorOp C4(L, 1);
TensorOp CC = C1.product(C2, spin12, irrep12);
TensorOp CCC = CC.product(C3, spin123, irrep123);
TensorOp CCCC = CCC.product(C4, spin1234, irrep1234);
for (int i=0; i<ladder.size(); i++)
{
int index = 0; double cleb=0.0;
if (nonZeroTensorComponent(c1, deltaQuantum[0], ladder[i], index, cleb)) {
std::vector<double> MatElements = calcMatrixElements(c1, CCCC, ladder[i], backupSlater1, backupSlater2) ;
element = MatElements[index]/cleb;
break;
}
else
continue;
}
return element;
}
double SpinAdapted::CreDesCreDes::redMatrixElement(Csf c1, vector<Csf>& ladder, const SpinBlock* b)
{
assert( build_pattern == "(((CD)(C))(D))" );
double element = 0.0;
int I = get_orbs()[0];
int J = get_orbs()[1];
int K = get_orbs()[2];
int L = get_orbs()[3];
// Must take into account how the 4-index is built from a combination of the 2-index ops
std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CD)(C))(D))");
assert( quantum_ladder.size() == 3 );
SpinQuantum deltaQuantum12 = quantum_ladder.at(0);
SpinQuantum deltaQuantum123 = quantum_ladder.at(1);
SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);
deltaQuantum[0] = deltaQuantum1234;
// Spin quantum data for CD
IrrepSpace sym12 = deltaQuantum12.get_symm();
int irrep12 = deltaQuantum12.get_symm().getirrep();
int spin12 = deltaQuantum12.get_s().getirrep();
// Spin quantum data for (CD)C
IrrepSpace sym123 = deltaQuantum123.get_symm();
int irrep123 = deltaQuantum123.get_symm().getirrep();
int spin123= deltaQuantum123.get_s().getirrep();
// Spin quantum data for total operator
IrrepSpace sym1234 = deltaQuantum1234.get_symm();
int irrep1234 = deltaQuantum1234.get_symm().getirrep();
int spin1234 = deltaQuantum1234.get_s().getirrep();
TensorOp C1(I, 1);
TensorOp D2(J,-1);
TensorOp C3(K, 1);
TensorOp D4(L,-1);
TensorOp CD = C1.product(D2, spin12, irrep12);
TensorOp CDC = CD.product(C3, spin123, irrep123);
TensorOp CDCD = CDC.product(D4, spin1234, irrep1234);
for (int i=0; i<ladder.size(); i++)
{
int index = 0; double cleb=0.0;
if (nonZeroTensorComponent(c1, deltaQuantum[0], ladder[i], index, cleb)) {
std::vector<double> MatElements = calcMatrixElements(c1, CDCD, ladder[i]) ;
element = MatElements[index]/cleb;
break;
}
else
continue;
}
return element;
}
/*!
* @param rxn Reaction index of the current reaction. This is used
* as an index into vectors which have length n_total_rxn.
* @param k This is a vector of integer values specifying the
* species indices. The length of this vector species
* the number of different species in the description.
* The value of the entries are the species indices.
* These are used as indexes into vectors which have
* length n_total_species.
* @param order This is a vector of the same length as vector k.
* The order is used for the routine power(), which produces
* a power law expression involving the species vector.
* @param stoich This is used to handle fractional stoichiometric coefficients
* on the product side of irreversible reactions.
*/
void StoichManagerN::add(size_t rxn, const std::vector<size_t>& k, const vector_fp& order,
const vector_fp& stoich) {
//printf ("add called\n");
if (order.size() != k.size()) {
throw CanteraError("StoichManagerN::add()", "size of order and species arrays differ");
}
if (stoich.size() != k.size()) {
throw CanteraError("StoichManagerN::add()", "size of stoich and species arrays differ");
}
bool frac = false;
for (size_t n = 0; n < stoich.size(); n++) {
if (fmod(stoich[n], 1.0) || fmod(order[n], 1.0)) {
frac = true;
break;
}
}
if (frac || k.size() > 3) {
m_cn_list.push_back(C_AnyN(rxn, k, order, stoich));
} else {
// Try to express the reaction with unity stoichiometric
// coefficients (by repeating species when necessary) so that the
// simpler 'multiply' function can be used to compute the rate
// instead of 'power'.
std::vector<size_t> kRep;
for (size_t n = 0; n < k.size(); n++) {
for (size_t i = 0; i < stoich[n]; i++)
kRep.push_back(k[n]);
}
switch (kRep.size()) {
case 1:
m_c1_list.push_back(C1(rxn, kRep[0]));
break;
case 2:
m_c2_list.push_back(C2(rxn, kRep[0], kRep[1]));
break;
case 3:
m_c3_list.push_back(C3(rxn, kRep[0], kRep[1], kRep[2]));
break;
default:
m_cn_list.push_back(C_AnyN(rxn, k, order, stoich));
}
}
}
void Divide(int s, int t, edge **L, edge **R) {
edge *a, *b, *c, *ll, *lr, *rl, *rr, *tangent;
int n = t - s + 1;
if (n == 2) *L = *R = Make_edge(Q[s], Q[t]);
else if (n == 3) {
a = Make_edge(Q[s], Q[s + 1]), b = Make_edge(Q[s + 1], Q[t]);
Splice(a, b, Q[s + 1]);
double v = C3(Q[s], Q[s + 1], Q[t]);
if (v > eps) c = Join(a, Q[s], b, Q[t], 0), *L = a, *R = b;
else if (v < -eps) c = Join(a, Q[s], b, Q[t], 1), *L = c, *R = c;
else *L = a, *R = b;
} else if (n > 3) {
int split = (s + t) / 2;
Divide(s, split, &ll, &lr); Divide(split + 1, t, &rl, &rr);
Merge(lr, Q[split], rl, Q[split + 1], &tangent);
if (Oi(tangent) == Q[s]) ll = tangent;
if (Dt(tangent) == Q[t]) rr = tangent;
*L = ll; *R = rr;
}
}
cString cPlainKeyVia::PrintKeyNr(void)
{
char tmp[12];
const char *kn=tmp;
switch(keynr) {
case MBC3('T','P','S'):
kn="TPS"; break;
case MBC3('M','K',0): case MBC3('M','K',1): case MBC3('M','K',2):
case MBC3('M','K',3): case MBC3('M','K',4): case MBC3('M','K',5):
case MBC3('M','K',6): case MBC3('M','K',7): case MBC3('M','K',8):
case MBC3('M','K',9):
snprintf(tmp,sizeof(tmp),"TPSMK%d",C3(keynr)); break;
default:
{
char c2=C2(keynr);
if(c2=='D' || c2=='P' || c2=='X' || c2=='C' || c2=='E' || c2=='T')
snprintf(tmp,sizeof(tmp),"%c%01X",c2,keynr & 0x0f);
else
snprintf(tmp,sizeof(tmp),"%02X",keynr);
break;
}
}
return kn;
}
int main (int argc, char **argv) {
ImageDataset d;
d.loadImagesFromFile("train-images-idx3-ubyte");
d.loadLabelsFromFile("train-labels-idx1-ubyte");
std::shared_ptr<clneural::ActivationFunction> act(new clneural::SigmoidActivationFunction());
std::shared_ptr<clneural::ActivationFunction> act2(new clneural::LinearActivationFunction());
std::vector<std::list<unsigned int>> C1_connections(6, std::list<unsigned int>({0}));
clneural::ConvolutionalLayer::Dimension C1_input;
clneural::ConvolutionalLayer::Dimension C1_filter;
float training_speed = 0.7f;
C1_input.width = 32;
C1_input.height = 32;
C1_filter.width = 5;
C1_filter.height = 5;
std::shared_ptr<clneural::NeuralNetworkLayer> C1(new clneural::ConvolutionalLayer(C1_input, C1_filter, C1_connections, act, training_speed));
clneural::SubsamplingLayer::Dimension S2_input;
clneural::SubsamplingLayer::Dimension S2_filter;
S2_input.width = 28;
S2_input.height = 28;
S2_filter.width = 2;
S2_filter.height = 2;
std::shared_ptr<clneural::NeuralNetworkLayer> S2(new clneural::SubsamplingLayer(S2_input, S2_filter, 6, act2, training_speed));
std::vector<std::list<unsigned int>> C3_connections(16);
C3_connections[0] = std::list<unsigned int>({0,1,2});
C3_connections[1] = std::list<unsigned int>({1,2,3});
C3_connections[2] = std::list<unsigned int>({2,3,4});
C3_connections[3] = std::list<unsigned int>({3,4,5});
C3_connections[4] = std::list<unsigned int>({4,5,0});
C3_connections[5] = std::list<unsigned int>({5,0,1});
C3_connections[6] = std::list<unsigned int>({0,1,2,3});
C3_connections[7] = std::list<unsigned int>({1,2,3,4});
C3_connections[8] = std::list<unsigned int>({2,3,4,5});
C3_connections[9] = std::list<unsigned int>({3,4,5,0});
C3_connections[10] = std::list<unsigned int>({4,5,0,1});
C3_connections[11] = std::list<unsigned int>({5,0,1,2});
C3_connections[12] = std::list<unsigned int>({0,1,3,4});
C3_connections[13] = std::list<unsigned int>({1,2,4,5});
C3_connections[14] = std::list<unsigned int>({0,2,3,5});
C3_connections[15] = std::list<unsigned int>({0,1,2,3,4,5});
clneural::ConvolutionalLayer::Dimension C3_input;
clneural::ConvolutionalLayer::Dimension C3_filter;
C3_input.width = 14;
C3_input.height = 14;
C3_filter.width = 5;
C3_filter.height = 5;
std::shared_ptr<clneural::NeuralNetworkLayer> C3(new clneural::ConvolutionalLayer(C3_input, C3_filter, C3_connections, act, training_speed));
clneural::SubsamplingLayer::Dimension S4_input;
clneural::SubsamplingLayer::Dimension S4_filter;
S4_input.width = 10;
S4_input.height = 10;
S4_filter.width = 2;
S4_filter.height = 2;
std::shared_ptr<clneural::NeuralNetworkLayer> S4(new clneural::SubsamplingLayer(S4_input, S4_filter, 16, act2, training_speed));
std::shared_ptr<clneural::NeuralNetworkLayer> N1(new clneural::FullFeedforwardLayer(400, 84, act, training_speed));
std::shared_ptr<clneural::NeuralNetworkLayer> N2(new clneural::FullFeedforwardLayer(84, 10, act, training_speed));
clneural::NeuralNetwork n;
n.addLayer(C1);
n.addLayer(S2);
n.addLayer(C3);
n.addLayer(S4);
n.addLayer(N1);
n.addLayer(N2);
std::shared_ptr<OpenCLInterface> ocl = OpenCLInterface::getInstance();
ocl->initialize(CL_DEVICE_TYPE_CPU);
float dist = 0.0f;
for (unsigned int i = 0; i < 60000; i++) {
std::pair<std::vector<float>, uint8_t> trainelem = d.popRandomElementWithLabel();
std::vector<float> desired(10, 0.0f);
desired[trainelem.second] = 1.0f;
dist += n.trainNetwork(trainelem.first, desired);
std::vector<float> nout = n.getLastOutput();
if ((i % 1000) == 0) {
std::cout << "TIME: " << ((float) clock())/CLOCKS_PER_SEC << ", STEP:" << (i + 1) << ", MDIST: " << dist/1000.0f << ", OUT: (" << nout[0];
for (unsigned int j = 1; j < nout.size(); j++) std::cout << "," << nout[j];
std::cout << "), DESIRED: (" << desired[0];
for (unsigned int j = 1; j < desired.size(); j++) std::cout << "," << desired[j];
std::cout << ")" << std::endl;
dist = 0.0f;
}
}
n.saveToFile("conv_images1.net");
verifyNetwork(n);
return 0;
}
KJG_GENO_SUM_ALT(p + 2), \
KJG_GENO_SUM_ALT(p + 3)
#define A2(p) A1(p), A1(p + 4), A1(p + 8), A1(p + 12)
#define A3(p) A2(p), A2(p + 16), A2(p + 32), A2(p + 48)
const uint8_t KJG_GENO_SUM_ALT_LOOKUP[256] =
{ A3(0), A3(64), A3(128), A3(192) };
#define C1(p) \
KJG_GENO_COUNT(p), \
KJG_GENO_COUNT(p + 1), \
KJG_GENO_COUNT(p + 2), \
KJG_GENO_COUNT(p + 3)
#define C2(p) C1(p), C1(p + 4), C1(p + 8), C1(p + 12)
#define C3(p) C2(p), C2(p + 16), C2(p + 32), C2(p + 48)
const uint8_t KJG_GENO_COUNT_LOOKUP[256] =
{ C3(0), C3(64), C3(128), C3(192) };
// Functional interface
void
kjg_geno_pack (const size_t n, const uint8_t* u, uint8_t* p)
{
size_t i = 0, j = 0;
// pack the whole chunks
for (; i < n - 4; (i += 4), j++)
p[j] = kjg_geno_pack_unit (&u[i]);
// pack the last chunk
uint8_t remainder[4] =
{ 0, 0, 0, 0 };
int main ()
{
return C1 () + C2 () + C3 () + C4 () + C5 () + C6 () + C7 () + C8 ();
}
int multiple_detector_fit()
{
std::cout << "Beginning : ... " << std::endl;
Int_t npoints = 1000;
Double_t emin = 0.2;
Double_t emax = 3.0;
bool use100m = false;
bool use470m = true;
bool use600m = false;
std::vector<int> baselines;
std::vector<double> scales;
std::vector<std::string> names;
std::vector<double> volume;
if (use100m) baselines.push_back(100);
if (use470m) baselines.push_back(470);
if (use600m) baselines.push_back(600);
int nL = baselines.size();
double NULLVec[3][20];
double OscVec[3][1001][7][20];
for(int i = 0; i < 20; i++){
NULLVec[0][i] = 0;
NULLVec[1][i] = 0;
NULLVec[2][i] = 0;
}
for(int u = 0; u < 1000; u++){
for(int s = 0; s < 7; s++){
for(int i = 0; i < 20; i++){
OscVec[0][u][s][i] = 0;
OscVec[1][u][s][i] = 0;
OscVec[2][u][s][i] = 0;
}
}
}
int nbinsE = 0;
int counter = 0;
if (use100m){
std::string temp_name = "../MatrixFiles/combined_ntuple_100m_nu_processed_numu.root";
TFile temp_file(temp_name.c_str());
TH1D *NULL_100;
NULL_100 = (TH1D*)(temp_file.Get("NumuCC"));
nbinsE = NULL_100->GetNbinsX();
std::cout << nbinsE << std::endl;
for(int i = 1; i <= nbinsE; i++){
NULLVec[counter][i-1] = (NULL_100->GetBinContent(i));
}
for(int u = 0; u < npoints; u++){
for(int s = 0; s < 7; s++){
TH1D *OSC_100;
TString upoint = Form("%d",u);
TString name = "Universe_";
TString name2 = "_MultiSim_";
TString mul = Form("%d",s);
name += upoint;
name += name2;
name += mul;
OSC_100 = (TH1D*)(temp_file.Get(name));
for(int i = 1; i <= nbinsE; i++){
OscVec[counter][u][s][i-1] = (OSC_100->GetBinContent(i));
// if(OscVec[0][u][s][i-1] != OscVec[0][u][s][i-1]) std::cout << "erm" <<std::endl;
}
delete OSC_100;
}
}
counter++;
delete NULL_100;
temp_file.Close();
}
if (use470m){
std::string temp_name = "../MatrixFiles/combined_ntuple_470m_nu_processed_numu.root";
TFile temp_file(temp_name.c_str());
TH1D *NULL_470;
NULL_470 = (TH1D*)(temp_file.Get("NumuCC"));
nbinsE = NULL_470->GetNbinsX();
std::cout << nbinsE<< std::endl;
for(int i = 1; i <= nbinsE; i++){
NULLVec[counter][i-1] = (NULL_470->GetBinContent(i));
}
for(int u = 0; u < npoints; u++){
for(int s = 0; s < 7; s++){
TH1D *OSC_470;
TString upoint = Form("%d",u);//std::to_string(u);
TString name = "Universe_";
TString name2 = "_MultiSim_";
TString mul = Form("%d",s);// = std::to_string(s);
name += upoint;
name += name2;
name += mul;
OSC_470 = (TH1D*)(temp_file.Get(name));
for(int i = 1; i <= nbinsE; i++){
OscVec[counter][u][s][i-1] = (OSC_470->GetBinContent(i));
}
delete OSC_470;
}
}
counter++;
delete NULL_470;
temp_file.Close();
}
if (use600m){
std::string temp_name = "../MatrixFiles/combined_ntuple_600m_onaxis_nu_processed_numu.root";
TFile temp_file(temp_name.c_str());
TH1D *NULL_600;
NULL_600 = (TH1D*)(temp_file.Get("NumuCC"));
nbinsE = NULL_600->GetNbinsX();
std::cout << nbinsE<< std::endl;
for(int i = 1; i <= nbinsE; i++){
NULLVec[counter][i-1] = (NULL_600->GetBinContent(i));
}
for(int u = 0; u < npoints; u++){
for(int s = 0; s < 7; s++){
TH1D *OSC_600;
TString upoint = Form("%d",u);//std::to_string(u);
TString name = "Universe_";
TString name2 = "_MultiSim_";
TString mul = Form("%d",s);// = std::to_string(s);
name += upoint;
name += name2;
name += mul;
OSC_600 = (TH1D*)(temp_file.Get(name));
for(int i = 1; i <= nbinsE; i++){
OscVec[counter][u][s][i-1] = (OSC_600->GetBinContent(i));
}
delete OSC_600;
}
}
counter++;
delete NULL_600;
temp_file.Close();
}
// int nL = 3;
int mbins = (nbinsE*nL);
TMatrix M6 (mbins,mbins);
TMatrix M5 (mbins,mbins);
TMatrix M4 (mbins,mbins);
TMatrix M3 (mbins,mbins);
TMatrix M2 (mbins,mbins);
TMatrix M1 (mbins,mbins);
TMatrix M0 (mbins,mbins);
TMatrix C6 (mbins,mbins);
TMatrix C5 (mbins,mbins);
TMatrix C4 (mbins,mbins);
TMatrix C3 (mbins,mbins);
TMatrix C2 (mbins,mbins);
TMatrix C1 (mbins,mbins);
TMatrix C0 (mbins,mbins);
int N = 0;
TH1D *Fig6 = new TH1D("Fig6",";;",mbins,0,mbins);
TH1D *Fig5 = new TH1D("Fig5",";;",mbins,0,mbins);
TH1D *Fig4 = new TH1D("Fig4",";;",mbins,0,mbins);
TH1D *Fig3 = new TH1D("Fig3",";;",mbins,0,mbins);
TH1D *Fig2 = new TH1D("Fig2",";;",mbins,0,mbins);
TH1D *Fig1 = new TH1D("Fig1",";;",mbins,0,mbins);
TH1D *Fig0 = new TH1D("Fig0",";;",mbins,0,mbins);
int Erri = 0, Errj = 0;
std::cout << "Filling Error Matrix..." << std::endl;
for(int Lrow = 0; Lrow < nL; Lrow++){
for(int Erow = 0; Erow < nbinsE; Erow++){
Errj = 0;
for(int Lcol = 0; Lcol < nL; Lcol++){
for(int Ecol = 0; Ecol < nbinsE; Ecol++){
M6 (Erri,Errj) = 0;
M5 (Erri,Errj) = 0;
M4 (Erri,Errj) = 0;
M3 (Erri,Errj) = 0;
M2 (Erri,Errj) = 0;
M1 (Erri,Errj) = 0;
M0 (Erri,Errj) = 0;
N = 0;
for(int u = 0; u < npoints; u++){
M6 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][6][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][6][Ecol]);
M5 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][5][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][5][Ecol]);
M4 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][4][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][4][Ecol]);
M3 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][3][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][3][Ecol]);
M2 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][2][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][2][Ecol]);
M1 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][1][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][1][Ecol]);
M0 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][0][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][0][Ecol]);
N++;
}
M6 (Erri,Errj) /= N;
M5 (Erri,Errj) /= N;
M4 (Erri,Errj) /= N;
M3 (Erri,Errj) /= N;
M2 (Erri,Errj) /= N;
M1 (Erri,Errj) /= N;
M0 (Erri,Errj) /= N;
M6 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M5 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M4 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M3 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M2 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M1 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M0 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
if(Erri == Errj) Fig6->SetBinContent(Erri+1, sqrt(M6 (Erri,Errj)));
if(Erri == Errj) Fig5->SetBinContent(Erri+1, sqrt(M5 (Erri,Errj)));
if(Erri == Errj) Fig4->SetBinContent(Erri+1, sqrt(M4 (Erri,Errj)));
if(Erri == Errj) Fig3->SetBinContent(Erri+1, sqrt(M3 (Erri,Errj)));
if(Erri == Errj) Fig2->SetBinContent(Erri+1, sqrt(M2 (Erri,Errj)));
if(Erri == Errj) Fig1->SetBinContent(Erri+1, sqrt(M1 (Erri,Errj)));
if(Erri == Errj) Fig0->SetBinContent(Erri+1, sqrt(M0 (Erri,Errj)));
Errj++;
}}
Erri++;
}}
for(int i = 0; i < Erri; i++){
for(int j = 0; j < Errj; j++){
C6 (i,j) = M6(i,j) / sqrt(M6 (i,i) * M6 (j,j));
C5 (i,j) = M5(i,j) / sqrt(M5 (i,i) * M5 (j,j));
C4 (i,j) = M4(i,j) / sqrt(M4 (i,i) * M4 (j,j));
C3 (i,j) = M3(i,j) / sqrt(M3 (i,i) * M3 (j,j));
C2 (i,j) = M2(i,j) / sqrt(M2 (i,i) * M2 (j,j));
C1 (i,j) = M1(i,j) / sqrt(M1 (i,i) * M1 (j,j));
C0 (i,j) = M0(i,j) / sqrt(M0 (i,i) * M0 (j,j));
}
}
std::cout << "...Error Matrix Filled" << std::endl;
TCanvas* c6 = new TCanvas("c6","",700,700);
c6->SetLeftMargin(.1);
c6->SetBottomMargin(.1);
c6->SetTopMargin(.075);
c6->SetRightMargin(.15);
c6->cd();
M6.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
// TMatrixFBase->GetZaxis()->SetRangeUser(-0.05,0.4);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("Fractional Error Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
add_plot_label(" 0.2 GeV #minus 3.0 GeV ", 0.48,0.07,0.04);
TLatex *MD = new TLatex(.3,.01,"MicroBooNE (470m)");
MD->SetNDC();
MD->SetTextFont(62);
MD->SetTextSize(0.04);
MD->Draw();
TLatex *MD45 = new TLatex(.05,.3,"MicroBooNE (470m)");
MD45->SetNDC();
MD45->SetTextAngle(90);
MD45->SetTextFont(62);
MD45->SetTextSize(0.04);
MD45->Draw();
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Flux Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
c6->Print("total_1Det_matrix.pdf");
TCanvas* c61 = new TCanvas("c61","",700,700);
c61->SetLeftMargin(.1);
c61->SetBottomMargin(.1);
c61->SetTopMargin(.075);
c61->SetRightMargin(.15);
c61->cd();
C6.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
add_plot_label(" 0.2 GeV #minus 3.0 GeV ", 0.48,0.07,0.04);
MD->Draw();
MD45->Draw();
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Flux Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
c61->Print("total_1Det_correlation_matrix.pdf");
cout<<"\nEnd of routine.\n";
return 0;
}
int main(int argc, char *argv[]) {
int i, returnierr=0;
#ifdef EPETRA_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// Uncomment to debug in parallel int tmp; if (Comm.MyPID()==0) cin >> tmp; Comm.Barrier();
bool verbose = false;
bool veryVerbose = false;
// Check if we should print results to standard out
if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;
// Check if we should print lots of results to standard out
if (argc>2) if (argv[2][0]=='-' && argv[2][1]=='v') veryVerbose = true;
if (verbose && Comm.MyPID()==0)
std::cout << Epetra_Version() << std::endl << std::endl;
if (!verbose) Comm.SetTracebackMode(0); // This should shut down any error traceback reporting
if (verbose) std::cout << Comm << std::endl << std::flush;
bool verbose1 = verbose;
if (verbose) verbose = (Comm.MyPID()==0);
bool veryVerbose1 = veryVerbose;
if (veryVerbose) veryVerbose = (Comm.MyPID()==0);
int NumMyElements = 100;
if (veryVerbose1) NumMyElements = 10;
NumMyElements += Comm.MyPID();
int MaxNumMyElements = NumMyElements+Comm.NumProc()-1;
int * ElementSizeList = new int[NumMyElements];
long long * MyGlobalElements = new long long[NumMyElements];
for (i = 0; i<NumMyElements; i++) {
MyGlobalElements[i] = (Comm.MyPID()*MaxNumMyElements+i)*2;
ElementSizeList[i] = i%6 + 2; // elementsizes go from 2 to 7
}
Epetra_BlockMap Map(-1LL, NumMyElements, MyGlobalElements, ElementSizeList,
0, Comm);
delete [] ElementSizeList;
delete [] MyGlobalElements;
Epetra_MapColoring C0(Map);
int * elementColors = new int[NumMyElements];
int maxcolor = 24;
int * colorCount = new int[maxcolor];
int ** colorLIDs = new int*[maxcolor];
for (i=0; i<maxcolor; i++) colorCount[i] = 0;
for (i=0; i<maxcolor; i++) colorLIDs[i] = 0;
int defaultColor = C0.DefaultColor();
for (i=0; i<Map.NumMyElements(); i++) {
assert(C0[i]==defaultColor);
assert(C0(Map.GID64(i))==defaultColor);
if (i%2==0) C0[i] = i%6+5+i%14; // cycle through 5...23 on even elements
else C0(Map.GID64(i)) = i%5+1; // cycle through 1...5 on odd elements
elementColors[i] = C0[i]; // Record color of ith element for use below
colorCount[C0[i]]++; // Count how many of each color for checking below
}
if (veryVerbose)
std::cout << "Original Map Coloring using element-by-element definitions" << std::endl;
if (veryVerbose1)
std::cout << C0 << std::endl;
int numColors = 0;
for (i=0; i<maxcolor; i++)
if (colorCount[i]>0) {
numColors++;
colorLIDs[i] = new int[colorCount[i]];
}
for (i=0; i<maxcolor; i++) colorCount[i] = 0;
for (i=0; i<Map.NumMyElements(); i++) colorLIDs[C0[i]][colorCount[C0[i]]++] = i;
int newDefaultColor = -1;
Epetra_MapColoring C1(Map, elementColors, newDefaultColor);
if (veryVerbose)
std::cout << "Same Map Coloring using one-time construction" << std::endl;
if (veryVerbose1)
std::cout << C1 << std::endl;
assert(C1.DefaultColor()==newDefaultColor);
for (i=0; i<Map.NumMyElements(); i++) assert(C1[i]==C0[i]);
Epetra_MapColoring C2(C1);
if (veryVerbose)
std::cout << "Same Map Coloring using copy constructor" << std::endl;
if (veryVerbose1)
std::cout << C1 << std::endl;
for (i=0; i<Map.NumMyElements(); i++) assert(C2[i]==C0[i]);
assert(C2.DefaultColor()==newDefaultColor);
assert(numColors==C2.NumColors());
for (i=0; i<maxcolor; i++) {
int curNumElementsWithColor = C2.NumElementsWithColor(i);
assert(colorCount[i]==curNumElementsWithColor);
int * curColorLIDList = C2.ColorLIDList(i);
if (curNumElementsWithColor==0) {
assert(curColorLIDList==0);
}
else
for (int j=0; j<curNumElementsWithColor; j++) assert(curColorLIDList[j]==colorLIDs[i][j]);
}
int curColor = 1;
Epetra_Map * Map1 = C2.GenerateMap(curColor);
Epetra_BlockMap * Map2 = C2.GenerateBlockMap(curColor);
assert(Map1->NumMyElements()==colorCount[curColor]);
assert(Map2->NumMyElements()==colorCount[curColor]);
for (i=0; i<Map1->NumMyElements(); i++) {
assert(Map1->GID64(i)==Map.GID64(colorLIDs[curColor][i]));
assert(Map2->GID64(i)==Map.GID64(colorLIDs[curColor][i]));
assert(Map2->ElementSize(i)==Map.ElementSize(colorLIDs[curColor][i]));
}
// Now test data redistribution capabilities
Epetra_Map ContiguousMap(-1LL, Map.NumMyElements(), Map.IndexBase64(), Comm);
// This vector contains the element sizes for the original map.
Epetra_IntVector elementSizes(Copy, ContiguousMap, Map.ElementSizeList());
Epetra_LongLongVector elementIDs(Copy, ContiguousMap, Map.MyGlobalElements64());
Epetra_IntVector elementColorValues(Copy, ContiguousMap, C2.ElementColors());
long long NumMyElements0 = 0;
if (Comm.MyPID()==0) NumMyElements0 = Map.NumGlobalElements64();
Epetra_Map CMap0(-1LL, NumMyElements0, Map.IndexBase64(), Comm);
Epetra_Import importer(CMap0, ContiguousMap);
Epetra_IntVector elementSizes0(CMap0);
Epetra_LongLongVector elementIDs0(CMap0);
Epetra_IntVector elementColorValues0(CMap0);
elementSizes0.Import(elementSizes, importer, Insert);
elementIDs0.Import(elementIDs, importer, Insert);
elementColorValues0.Import(elementColorValues, importer, Insert);
Epetra_BlockMap MapOnPE0(-1LL,NumMyElements0, elementIDs0.Values(),
elementSizes0.Values(), Map.IndexBase64(), Comm);
Epetra_Import importer1(MapOnPE0, Map);
Epetra_MapColoring ColoringOnPE0(MapOnPE0);
ColoringOnPE0.Import(C2, importer1, Insert);
for (i=0; i<MapOnPE0.NumMyElements(); i++)
assert(ColoringOnPE0[i]==elementColorValues0[i]);
if (veryVerbose)
std::cout << "Same Map Coloring on PE 0 only" << std::endl;
if (veryVerbose1)
std::cout << ColoringOnPE0 << std::endl;
Epetra_MapColoring C3(Map);
C3.Export(ColoringOnPE0, importer1, Insert);
for (i=0; i<Map.NumMyElements(); i++) assert(C3[i]==C2[i]);
if (veryVerbose)
std::cout << "Same Map Coloring after Import/Export exercise" << std::endl;
if (veryVerbose1)
std::cout << ColoringOnPE0 << std::endl;
if (verbose) std::cout << "Checked OK\n\n" << std::endl;
if (verbose1) {
if (verbose) std::cout << "Test ostream << operator" << std::endl << std::flush;
std::cout << C0 << std::endl;
}
delete [] elementColors;
for (i=0; i<maxcolor; i++) if (colorLIDs[i]!=0) delete [] colorLIDs[i];
delete [] colorLIDs;
delete [] colorCount;
delete Map1;
delete Map2;
#ifdef EPETRA_MPI
MPI_Finalize();
#endif
return returnierr;
}
Func ColorMgather(Func stBasis, float angle, uint8_t * orders, Expr filterthreshold, Expr divisionthreshold, Expr divisionthreshold2) {
uint8_t x_order = orders[0];
uint8_t y_order = orders[1];
uint8_t t_order = orders[2];
uint8_t c_order = orders[3];
Func X("X"),Y("Y"),T("T"),Xrg("Xrg"),Yrg("Yrg"),Trg("Trg");
uint8_t max_order = x_order;
// std::vector<Expr>Xk_expr (max_order,cast<float>(0.0f));
// std::vector<Expr>Yk_expr (max_order,cast<float>(0.0f));
// std::vector<Expr>Tk_expr (max_order,cast<float>(0.0f));
uint8_t Xk_uI[max_order];
uint8_t Yk_uI[max_order];
uint8_t Tk_uI[max_order];
Func Xk[max_order]; Func Yk[max_order]; Func Tk[max_order];
// Expr Xk[max_order],Yk[max_order],Tk[max_order];
for (int iO=0; iO < x_order; iO++) {
Xk[iO](x,y,t) = Expr(0.0f);
Yk[iO](x,y,t) = Expr(0.0f);
Tk[iO](x,y,t) = Expr(0.0f);
Xk_uI[iO] = 0;
Yk_uI[iO] = 0;
Tk_uI[iO] = 0;
}
int k = 0;
for (int iXo = 0; iXo < x_order; iXo++) // x_order
for (int iYo = 0; iYo < y_order; iYo++) // y_oder
for (int iTo = 0; iTo < t_order; iTo++) // t_order
for (int iCo = 0; iCo < c_order; iCo ++ ) // c_order: index of color channel
{
if ((iYo+iTo+iCo == 0 || iYo+iTo+iCo == 1)
&& ((iXo+iYo+iTo+iCo+1) < (x_order + 1))) {
X = ColorMgetfilter(stBasis, angle, iXo+1, iYo, iTo, iCo);
Y = ColorMgetfilter(stBasis, angle, iXo, iYo+1, iTo, iCo);
T = ColorMgetfilter(stBasis, angle, iXo, iYo, iTo+1, iCo);
Xrg = ColorMgetfilter(stBasis, angle, iXo+1, iYo, iTo, iCo+1);
Yrg = ColorMgetfilter(stBasis, angle, iXo, iYo+1, iTo, iCo+1);
Trg = ColorMgetfilter(stBasis, angle, iXo, iYo, iTo+1, iCo+1);
k = iXo + iYo + iTo + iCo;
Xk[k](x,y,t) += X(x,y,t) + Xrg(x,y,t);
Yk[k](x,y,t) += Y(x,y,t) + Yrg(x,y,t);
Tk[k](x,y,t) += T(x,y,t) + Trg(x,y,t);
Xk[k].update(Xk_uI[k]); Xk_uI[k]++;
Yk[k].update(Yk_uI[k]); Yk_uI[k]++;
Tk[k].update(Tk_uI[k]); Tk_uI[k]++;
}
}
// Scheduling
for (int iO = 0; iO <= k; iO++) {
Xk[iO].compute_root();
Yk[iO].compute_root();
Tk[iO].compute_root();
}
std::vector<Expr> st_expr(6,cast<float>(0.0f));
for (int iK=0; iK <= k; iK++) {
st_expr[0] += Xk[iK](x,y,t)*Tk[iK](x,y,t);
st_expr[1] += Tk[iK](x,y,t)*Tk[iK](x,y,t);
st_expr[2] += Xk[iK](x,y,t)*Xk[iK](x,y,t);
st_expr[3] += Yk[iK](x,y,t)*Tk[iK](x,y,t);
st_expr[4] += Yk[iK](x,y,t)*Yk[iK](x,y,t);
st_expr[5] += Xk[iK](x,y,t)*Yk[iK](x,y,t);
}
Func st("st"); st(x,y,t) = Tuple(st_expr);
st.compute_root();
Expr x_clamped = clamp(x,0,width-1);
Expr y_clamped = clamp(y,0,height-1);
Func st_clamped("st_clamped"); st_clamped(x,y,t) = st(x_clamped,y_clamped,t);
// float win = 7.0;
// Image<float> meanfilter(7,7,"meanfilter_data");
// meanfilter(x,y) = Expr(1.0f/(win*win));
// RDom rMF(meanfilter);
uint8_t win = 7;
RDom rMF(0,win,0,win);
Func st_filtered[6];
for (uint8_t iPc=0; iPc<6; iPc++) {
// iPc: index of product component
// Apply average filter
st_filtered[iPc](x,y,t) = sum(rMF,st_clamped(x + rMF.x,y + rMF.y,t)[iPc]/Expr(float(win*win)),"mean_filter");
st_filtered[iPc].compute_root();
}
// Tuple st_tuple = Tuple(st_expr);
// 4 debug
// Func tmpOut("tmpOut"); tmpOut(x,y,t) = Tuple(st_filtered[0](x,y,t),st_filtered[1](x,y,t),st_filtered[2](x,y,t),st_filtered[3](x,y,t),st_filtered[4](x,y,t),st_filtered[5](x,y,t));
// return tmpOut;
Tuple pbx = Tuple(st_filtered[2](x,y,t),st_filtered[5](x,y,t),st_filtered[0](x,y,t));
Tuple pby = Tuple(st_filtered[5](x,y,t),st_filtered[4](x,y,t),st_filtered[3](x,y,t));
Tuple pbt = Tuple(st_filtered[0](x,y,t),st_filtered[3](x,y,t),st_filtered[1](x,y,t));
Func pbxy("pbxy"); pbxy = cross(pby,pbx); pbxy.compute_root();
Func pbxt("pbxt"); pbxt = cross(pbx,pbt); pbxt.compute_root();
Func pbyt("pbyt"); pbyt = cross(pby,pbt); pbyt.compute_root();
Func pbxyd("pbxyd"); pbxyd = dot(pby,pbx); pbxyd.compute_root();
Func pbxtd("pbxtd"); pbxtd = dot(pbx,pbt); pbxtd.compute_root();
Func pbytd("pbytd"); pbytd = dot(pby,pbt); pbytd.compute_root();
// 4 debug
// Func tmpOut("tmpOut"); tmpOut(x,y,t) = Tuple(pbxy(x,y,t)[0],pbxt(x,y,t)[0],pbyt(x,y,t)[0],pbxyd(x,y,t),pbxtd(x,y,t),pbytd(x,y,t));
// return tmpOut;
Func yt_xy("yt_xy"); yt_xy = dot(pbyt(x,y,t),pbxy(x,y,t)); yt_xy.compute_root();
Func xt_yt("xt_yt"); xt_yt = dot(pbxt(x,y,t),pbyt(x,y,t)); xt_yt.compute_root();
Func xt_xy("xt_xy"); xt_xy = dot(pbxt(x,y,t),pbxy(x,y,t)); xt_xy.compute_root();
Func yt_yt("yt_yt"); yt_yt = dot(pbyt(x,y,t),pbyt(x,y,t)); yt_yt.compute_root();
Func xt_xt("xt_xt"); xt_xt = dot(pbxt(x,y,t),pbxt(x,y,t)); xt_xt.compute_root();
Func xy_xy("xy_xy"); xy_xy = dot(pbxy(x,y,t),pbxy(x,y,t)); xy_xy.compute_root();
Tuple Tk_tuple = Tuple(Tk[0](x,y,t),Tk[1](x,y,t),Tk[2](x,y,t),
Tk[3](x,y,t),Tk[4](x,y,t));
Func Tkd("Tkd"); Tkd = dot(Tk_tuple,Tk_tuple); Tkd.compute_root();
// Expr Dimen = pbxyd/xy_xy;
Expr kill(1.0f);
Func Oxy; Oxy(x,y,t) = Mdefdiv(st_filtered[5](x,y,t) - Mdefdivang(yt_xy(x,y,t),yt_yt(x,y,t),pbxyd(x,y,t),divisionthreshold2)*st_filtered[3](x,y,t)*kill,st_filtered[4](x,y,t),divisionthreshold);
Oxy.compute_root();
Func Oyx; Oyx(x,y,t) = Mdefdiv(st_filtered[5](x,y,t) + Mdefdivang(xt_xy(x,y,t),xt_xt(x,y,t),pbxyd(x,y,t),divisionthreshold2)*st_filtered[0](x,y,t)*kill,st_filtered[2](x,y,t),divisionthreshold);
Oyx.compute_root();
Func C0; C0(x,y,t) = st_filtered[3](x,y,t) * Mdefdivang(Expr(-1.0f)*xt_yt(x,y,t),yt_yt(x,y,t),pbxyd(x,y,t),divisionthreshold2)*kill;
C0.compute_root();
Func M0; M0(x,y,t) = Mdefdiv(st_filtered[0](x,y,t) + C0(x,y,t), st_filtered[1](x,y,t)*pow(Mdefdivang(xt_yt(x,y,t),yt_yt(x,y,t),pbxyd(x,y,t),divisionthreshold2),Expr(2.0f)),divisionthreshold);
M0.compute_root();
Func C1; C1(x,y,t) = st_filtered[5](x,y,t) * Mdefdivang(Expr(-1.0f)*xt_xy(x,y,t),xy_xy(x,y,t),pbxyd(x,y,t),divisionthreshold2)*kill;
C1.compute_root();
Func P1; P1(x,y,t) = pow(Mdefdivang(xt_yt(x,y,t),xt_xt(x,y,t),pbxyd(x,y,t),divisionthreshold2),Expr(2.0f))*kill + 1.0f;
P1.compute_root();
// 4 debug
// Func tmpOut("tmpOut"); tmpOut(x,y,t) = Tuple(Oxy(x,y,t),Oyx(x,y,t),C0(x,y,t),M0(x,y,t),C1(x,y,t),P1(x,y,t));
// return tmpOut;
Func Q1; Q1(x,y,t) = st_filtered[2](x,y,t) * (pow(Oyx(x,y,t),Expr(2.0f))+Expr(1.0f));
Q1.compute_root();
Func M1; M1(x,y,t) = Mdefdiv(((st_filtered[0](x,y,t)-C1(x,y,t))*P1(x,y,t)),Q1(x,y,t),divisionthreshold);
M1.compute_root();
Func C2; C2(x,y,t) = st_filtered[0](x,y,t) * Mdefdivang(Expr(-1.0f)*xt_yt(x,y,t),xt_xt(x,y,t),pbxyd(x,y,t),divisionthreshold2)*kill;
C2.compute_root();
Func M2; M2(x,y,t) = Mdefdiv(st_filtered[3](x,y,t)+C2(x,y,t),st_filtered[1](x,y,t)*(pow(Mdefdivang(xt_yt(x,y,t),xt_xt(x,y,t),pbxyd(x,y,t),divisionthreshold2),Expr(2.0f))*kill+Expr(1.0f)),divisionthreshold);
M2.compute_root();
Func C3; C3(x,y,t) = st_filtered[5](x,y,t) * Mdefdivang(yt_xy(x,y,t),xy_xy(x,y,t),pbxyd(x,y,t),divisionthreshold2)*kill;
C3.compute_root();
Func P3; P3(x,y,t) = pow(Mdefdivang(xt_yt(x,y,t),yt_yt(x,y,t),pbxyd(x,y,t),divisionthreshold2),Expr(2.0f))*kill + Expr(1.0f);
P3.compute_root();
Func Q3; Q3(x,y,t) = st_filtered[4](x,y,t) * (pow(Oxy(x,y,t),Expr(2.0f))+Expr(1.0f));
Q3.compute_root();
Func M3; M3(x,y,t) = Mdefdiv(((st_filtered[3](x,y,t)-C3(x,y,t))*P3(x,y,t)),Q3(x,y,t),divisionthreshold);
M3.compute_root();
Func basisAtAngle;
basisAtAngle(x,y,t) = Tuple(M0(x,y,t),M1(x,y,t),M2(x,y,t),M3(x,y,t),Tkd(x,y,t));
return basisAtAngle;
// Func hsv2rgb(Func colorImage) { // Took this function
// Var x, y, c, t;
// Func output;
// output(x,y,c,t) = cast <float> (0.0f);
// Expr fR, fG, fB; // R,G & B values
// Expr fH = (colorImage(x,y,0,t)); //H value [0-360)
// Expr fS = (colorImage(x,y,1,t)); //S value
// Expr fV = (colorImage(x,y,2,t)); //V value
// //Conversion (I took the one on Wikipedia)
// // https://fr.wikipedia.org/wiki/Teinte_Saturation_Valeur#Conversion_de_TSV_vers_RVB
// Expr fHi = floor(fH / Expr(60.0f));
// Expr fF = fH / 60.0f - fHi;
// Expr fL = fV * (1 - fS);
// Expr fM = fV * (1 - fF * fS) ;
// Expr fN = fV * (1 - (1 - fF) * fS);
// fR = select((0 == fHi),fV,
// (1 == fHi),fM,
// (2 == fHi),fL,
// (3 == fHi),fL,
// (4 == fHi),fN,
// (5 == fHi),fV,
// 0.0f);
// fG = select((0 == fHi),fN,
// (1 == fHi),fV,
// (2 == fHi),fV,
// (3 == fHi),fM,
// (4 == fHi),fL,
// (5 == fHi),fL,
// 0.0f);
// fB = select((0 == fHi),fL,
// (1 == fHi),fL,
// (2 == fHi),fN,
// (3 == fHi),fV,
// (4 == fHi),fV,
// (5 == fHi),fM,
// 0.0f);
// output(x,y,0,t) = fR;
// output(x,y,1,t) = fG;
// output(x,y,2,t) = fB;
// return output;
// }
// Func angle2rgb (Func v) {
// Var x, y, c, t;
// Func ov, a;
// ov(x,y,c,t) = cast <float> (0.0f);
// Expr pi2(2*M_PI);
// a(x,y,c,t) = v(x,y,c,t) / pi2;
// ov(x,y,0,t) = a(x,y,c,t);
// ov(x,y,1,t) = 1;
// ov(x,y,2,t) = 1;
// return ov;
// }
// Func outputvelocity(Func Blur, Func Speed, Func Angle, int border, Expr speedthreshold, Expr filterthreshold) {
// extern Expr width;
// extern Expr height;
// Func Blur3, Speed3;
// Blur3(x,y,c,t) = cast <float> (0.0f);
// Speed3(x,y,c,t) = cast <float> (0.0f);
// //Scale the grey level images
// Blur(x,y,0,t) = (Blur(x,y,0,t) - minimum(Blur(x,y,0,t))) / (maximum(Blur(x,y,0,t)) - minimum(Blur(x,y,0,t)));
// //Concatenation along the third dimension
// Blur3(x,y,0,t) = Blur(x,y,0,t);
// Blur3(x,y,1,t) = Blur(x,y,0,t);
// Blur3(x,y,2,t) = Blur(x,y,0,t);
// //Speed scaled to 1
// //Concatenation along the third dimension
// Speed3(x,y,1,t) = Speed(x,y,0,t);
// Speed3(x,y,2,t) = Speed(x,y,0,t);
// //Use the log speed to visualise speed
// Func LogSpeed;
// LogSpeed(x,y,c,t) = fast_log(Speed3(x,y,c,t) + Expr(0.0000001f))/fast_log(Expr(10.0f));
// LogSpeed(x,y,c,t) = (LogSpeed(x,y,c,t) - minimum(LogSpeed(x,y,c,t))) / (maximum(LogSpeed(x,y,c,t)) - minimum(LogSpeed(x,y,c,t)));
// //Make a colour image
// // uint16_t rows = height;
// // uint16_t cols = width;
// // int depth = Angle.channels();
// //Do it the HSV way
// Func colorImage;
// colorImage(x,y,0,t) = Angle(x,y,0,t);
// //Do hsv to rgb
// Func colorImage1;
// colorImage1 = hsv2rgb(colorImage);
// // Assume the border equals to the size of spatial filter
// //Make the border
// // int bir = rows + 2 * border;
// // int bic = cols + 2 * border;
// Expr orows = height / Expr(2);
// Expr ocols = width / Expr(2);
// //Rotation matrix
// int ph = 0;
// Func mb, sb;
// // if (rx < border - 1 || rx >= rows+border -1 || ry < border - 1 || ry >= cols+border - 1) {
// Expr co1 = x - orows;
// Expr co2 = - (y - ocols);
// Expr cosPh(cos(ph));
// Expr sinPh(sin(ph));
// Expr rco1 = cosPh * co1 - sinPh * co2; //Using rotation matrix
// Expr rco2 = sinPh * co1 + cosPh * co2;
// // Expr justPi (M_PI);
// mb(x,y,c,t) =
// select (((x < (border - 1)) ||
// (x >= (height+border -1)) ||
// (y < (border - 1)) ||
// (y >= (width+border - 1))),
// atan2(rco1,rco2) + Expr(M_PI),mb(x,y,c,t));
// sb(x,y,c,t) =
// select (((x < (border - 1)) ||
// (x >= (height+border -1)) ||
// (y < (border - 1) ) ||
// (y >= (width+border - 1))),
// 1, sb (x,y,c,t));
// Func cb;
// cb = angle2rgb(mb);
// //Get the old data
// // Expr pi2(2*M_PI);
// colorImage1(x,y,0,t)=colorImage(x,y,0,t) * Expr(2*M_PI);
// colorImage1=angle2rgb(colorImage1);
// colorImage1(x,y,c,t)=select(abs(Speed3(x,y,c,t))<speedthreshold,Expr(0.0f),colorImage1(x,y,c,t));
// Func colorImage2;
// colorImage2(x,y,c,t) = colorImage1(x,y,c,t) * Speed(x,y,c,t);
// //Put the data in the border
// RDom bordx (border,rows + border);
// RDom bordy (border,cols + border);
// Func ang1, ang2;
// ang1 (x,y,c,t) = cast <float> (0.0f);
// ang2 (x,y,c,t) = cast <float> (0.0f);
// cb(bordx, bordy,c,t) = colorImage1(x,y,c,t);
// ang1 = cb;
// cb(bordx, bordy,c,t) = colorImage2(x,y,c,t);
// ang2 = cb;
// sb(bordx, bordy,c,t) = Speed3(x,y,c,t);
// Speed3 = sb;
// sb(bordx, bordy,c,t) = Blur3(x,y,c,t);
// Blur3 = sb;
// // Func I;
// // I (x,y,c,t) = Blur3(x,y,c,t) + Speed3(x,y - height,c,t) + ang1(x - width,y,c,t) + ang2(x - width,y - height,c,t);
// //I = cat(2,cat(1,Blur,Speed),cat(1,ang1,ang2));
// return I;
// }
}
int main(void){
// hier komt de test
/*
int i = 0, j;
char letter = 'a';
char buffer[3];
std::string* hulp;
for(; i < h_nodes; i++){
for(j = 0; j < v_nodes; j++){
sprintf(buffer, "%c%d" , letter, j);
hulp = new std::string(buffer);
new Node(*hulp);
delete hulp;
}
letter++;
if(letter > 'z'){
letter = 'a';
}
}
printf("%p\n", Node::getParticularNode(std::string("a1")));
Node::getParticularNode(std::string("a1"))->print();
printf("%p\n", Node::getParticularNode(std::string("b1")));
Node::getParticularNode(std::string("b1"))->print();
Node::deleteAllNodes();
printf("%p\n", Node::getParticularNode(std::string("a1")));
Node::getParticularNode(std::string("a1"))->print();
*/
Node A1("A1");
A1.addNeighbournode("B1", 4);
A1.addNeighbournode("B2", 2);
Node B1("B1");
B1.addNeighbournode("C1", 2);
Node B2("B2");
B2.addNeighbournode("C3", 1);
B2.setState(nodeUsed);
Node C1("C1");
C1.addNeighbournode("D1", 1);
Node C2("C2");
C2.addNeighbournode("D2", 3);
C2.addNeighbournode("D3", 6);
Node C3("C3");
C3.addNeighbournode("C2", 1);
C3.addNeighbournode("D4", 3);
Node D1("D1");
D1.addNeighbournode("D2", 9);
Node D2("D2");
D2.addNeighbournode("D1", 9);
D2.addNeighbournode("C2", 3);
Node D3("D3");
D3.addNeighbournode("D4", 2);
Node D4("D4");
D4.addNeighbournode("D3", 2);
dijkstra planner;
planner.calculateRoute(&A1, &D4);
planner.printpath();
return 0;
}
int multiple_detector_fit()
{
std::cout << "Beginning : ... " << std::endl;
Int_t npoints = 1000;
Double_t emin = 0.2;
Double_t emax = 3.0;
bool use100m = true;
bool use470m = true;
bool use600m = true;
std::vector<int> baselines;
std::vector<double> scales;
std::vector<std::string> names;
std::vector<double> volume;
if (use100m) baselines.push_back(100);
if (use470m) baselines.push_back(470);
if (use600m) baselines.push_back(600);
double NULLVec[2][20];
double OscVec[2][1001][7][20];
for(int i = 0; i < 20; i++){
NULLVec[0][i] = 0;
NULLVec[1][i] = 0;
}
for(int u = 0; u < 1000; u++){
for(int s = 0; s < 7; s++){
for(int i = 0; i < 20; i++){
OscVec[0][u][s][i] = 0;
OscVec[1][u][s][i] = 0;
}
}
}
int nbinsE = 0;
if (use100m){
std::string temp_name = /*"../MatrixFiles/combined_ntuple_100m_nu_processed_numu.root";*/"../MatrixFiles/combined_ntuple_100m_nu_processed_CoreyBins_numu.root";
TFile temp_file(temp_name.c_str());
TH1D *NULL_100;
NULL_100 = (TH1D*)(temp_file.Get("NumuCC"));
nbinsE = NULL_100->GetNbinsX();
std::cout << nbinsE << std::endl;
for(int i = 1; i <= nbinsE; i++){
NULLVec[0][i-1] = (NULL_100->GetBinContent(i));
}
for(int u = 0; u < npoints; u++){
for(int s = 0; s < 7; s++){
TH1D *OSC_100;
TString upoint = Form("%d",u);
TString name = "Universe_";
TString name2 = "_MultiSim_";
TString mul = Form("%d",s);
name += upoint;
name += name2;
name += mul;
OSC_100 = (TH1D*)(temp_file.Get(name));
for(int i = 1; i <= nbinsE; i++){
OscVec[0][u][s][i-1] = (OSC_100->GetBinContent(i));
// if(OscVec[0][u][s][i-1] != OscVec[0][u][s][i-1]) std::cout << "erm" <<std::endl;
}
delete OSC_100;
}
}
delete NULL_100;
temp_file.Close();
}
if (use470m){
std::string temp_name = /*"../MatrixFiles/combined_ntuple_600m_onaxis_nu_processed_numu.root";*/"../MatrixFiles/combined_ntuple_600m_onaxis_nu_processed_CoreyBins_numu.root";
TFile temp_file(temp_name.c_str());
TH1D *NULL_470;
NULL_470 = (TH1D*)(temp_file.Get("NumuCC"));
nbinsE = NULL_470->GetNbinsX();
std::cout << nbinsE<< std::endl;
for(int i = 1; i <= nbinsE; i++){
NULLVec[1][i-1] = (NULL_470->GetBinContent(i));
}
for(int u = 0; u < npoints; u++){
for(int s = 0; s < 7; s++){
TH1D *OSC_470;
TString upoint = Form("%d",u);//std::to_string(u);
TString name = "Universe_";
TString name2 = "_MultiSim_";
TString mul = Form("%d",s);// = std::to_string(s);
name += upoint;
name += name2;
name += mul;
OSC_470 = (TH1D*)(temp_file.Get(name));
for(int i = 1; i <= nbinsE; i++){
OscVec[1][u][s][i-1] = (OSC_470->GetBinContent(i));
if(OscVec[1][u][s][i-1] != OscVec[1][u][s][i-1]) OscVec[1][u][s][i-1] = NULLVec[1][i-1];//std::cout << "erm, u :" << u << " s : " << s << " E : " << i <<std::endl;
}
delete OSC_470;
}
}
delete NULL_470;
temp_file.Close();
}
int nL = 2;
int mbins = (nbinsE*nL);
TMatrix M6 (mbins,mbins);
TMatrix M5 (mbins,mbins);
TMatrix M4 (mbins,mbins);
TMatrix M3 (mbins,mbins);
TMatrix M2 (mbins,mbins);
TMatrix M1 (mbins,mbins);
TMatrix M0 (mbins,mbins);
TMatrix C6 (mbins,mbins);
TMatrix C5 (mbins,mbins);
TMatrix C4 (mbins,mbins);
TMatrix C3 (mbins,mbins);
TMatrix C2 (mbins,mbins);
TMatrix C1 (mbins,mbins);
TMatrix C0 (mbins,mbins);
int N = 0;
TH1D *Fig6 = new TH1D("Fig6",";;",mbins,0,mbins);
TH1D *Fig5 = new TH1D("Fig5",";;",mbins,0,mbins);
TH1D *Fig4 = new TH1D("Fig4",";;",mbins,0,mbins);
TH1D *Fig3 = new TH1D("Fig3",";;",mbins,0,mbins);
TH1D *Fig2 = new TH1D("Fig2",";;",mbins,0,mbins);
TH1D *Fig1 = new TH1D("Fig1",";;",mbins,0,mbins);
TH1D *Fig0 = new TH1D("Fig0",";;",mbins,0,mbins);
int Erri = 0, Errj = 0;
std::cout << "Filling Error Matrix..." << std::endl;
for(int Lrow = 0; Lrow < 2; Lrow++){
for(int Erow = 0; Erow < nbinsE; Erow++){
Errj = 0;
for(int Lcol = 0; Lcol < 2; Lcol++){
for(int Ecol = 0; Ecol < nbinsE; Ecol++){
M6 (Erri,Errj) = 0;
M5 (Erri,Errj) = 0;
M4 (Erri,Errj) = 0;
M3 (Erri,Errj) = 0;
M2 (Erri,Errj) = 0;
M1 (Erri,Errj) = 0;
M0 (Erri,Errj) = 0;
N = 0;
for(int u = 0; u < npoints; u++){
M6 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][6][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][6][Ecol]);
M5 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][5][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][5][Ecol]);
M4 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][4][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][4][Ecol]);
M3 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][3][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][3][Ecol]);
M2 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][2][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][2][Ecol]);
M1 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][1][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][1][Ecol]);
M0 (Erri,Errj) += (NULLVec[Lrow][Erow]-OscVec[Lrow][u][0][Erow])*(NULLVec[Lcol][Ecol]-OscVec[Lcol][u][0][Ecol]);
N++;
}
M6 (Erri,Errj) /= N;
M5 (Erri,Errj) /= N;
M4 (Erri,Errj) /= N;
M3 (Erri,Errj) /= N;
M2 (Erri,Errj) /= N;
M1 (Erri,Errj) /= N;
M0 (Erri,Errj) /= N;
M6 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M5 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M4 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M3 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M2 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M1 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
M0 (Erri,Errj) /= NULLVec[Lrow][Erow]*NULLVec[Lcol][Ecol];
if(Erri == Errj) Fig6->SetBinContent(Erri+1, sqrt(M6 (Erri,Errj)));
if(Erri == Errj) Fig5->SetBinContent(Erri+1, sqrt(M5 (Erri,Errj)));
if(Erri == Errj) Fig4->SetBinContent(Erri+1, sqrt(M4 (Erri,Errj)));
if(Erri == Errj) Fig3->SetBinContent(Erri+1, sqrt(M3 (Erri,Errj)));
if(Erri == Errj) Fig2->SetBinContent(Erri+1, sqrt(M2 (Erri,Errj)));
if(Erri == Errj) Fig1->SetBinContent(Erri+1, sqrt(M1 (Erri,Errj)));
if(Erri == Errj) Fig0->SetBinContent(Erri+1, sqrt(M0 (Erri,Errj)));
std::cout << M6 (Erri,Errj) << "\t";
Errj++;
}}
Erri++;
}}
for(int i = 0; i < Erri; i++){
for(int j = 0; j < Errj; j++){
C6 (i,j) = M6(i,j) / sqrt(M6 (i,i) * M6 (j,j));
C5 (i,j) = M5(i,j) / sqrt(M5 (i,i) * M5 (j,j));
C4 (i,j) = M4(i,j) / sqrt(M4 (i,i) * M4 (j,j));
C3 (i,j) = M3(i,j) / sqrt(M3 (i,i) * M3 (j,j));
C2 (i,j) = M2(i,j) / sqrt(M2 (i,i) * M2 (j,j));
C1 (i,j) = M1(i,j) / sqrt(M1 (i,i) * M1 (j,j));
C0 (i,j) = M0(i,j) / sqrt(M0 (i,i) * M0 (j,j));
}
}
std::cout << "...Error Matrix Filled" << std::endl;
TCanvas* c6 = new TCanvas("c6","",700,700);
c6->SetLeftMargin(.1);
c6->SetBottomMargin(.1);
c6->SetTopMargin(.075);
c6->SetRightMargin(.15);
c6->cd();
M6.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
// TMatrixFBase->GetZaxis()->SetRangeUser(-0.05,0.4);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("Fractional Error Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *ND = new TLatex(.15,.01,"LAr1-ND (100m) ");
ND->SetNDC();
ND->SetTextFont(62);
ND->SetTextSize(0.04);
ND->Draw();
TLatex *MD = new TLatex(.5,.01,"T600 (600m, on axis)");
MD->SetNDC();
MD->SetTextFont(62);
MD->SetTextSize(0.04);
MD->Draw();
TLatex *ND45 = new TLatex(.05,.15,"LAr1-ND (100m) ");
ND45->SetNDC();
ND45->SetTextAngle(90);
ND45->SetTextFont(62);
ND45->SetTextSize(0.04);
ND45->Draw();
TLatex *MD45 = new TLatex(.05,.54,"T600 (600m, on axis)");
MD45->SetNDC();
MD45->SetTextAngle(90);
MD45->SetTextFont(62);
MD45->SetTextSize(0.04);
MD45->Draw();
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Flux Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
// c6->Print("total_matrix.pdf");
TCanvas* c61 = new TCanvas("c61","",700,700);
c61->SetLeftMargin(.1);
c61->SetBottomMargin(.1);
c61->SetTopMargin(.075);
c61->SetRightMargin(.15);
c61->cd();
C6.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Flux Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
// c61->Print("total_correlation_matrix.pdf");
TCanvas* c5 = new TCanvas("c5","",700,700);
c5->SetLeftMargin(.1);
c5->SetBottomMargin(.1);
c5->SetTopMargin(.075);
c5->SetRightMargin(.15);
c5->cd();
M5.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("K^{+} Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{+} Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c5->Print("mult5_matrix.pdf");
TCanvas* c51 = new TCanvas("c51","",700,700);
c51->SetLeftMargin(.1);
c51->SetBottomMargin(.1);
c51->SetTopMargin(.075);
c51->SetRightMargin(.15);
c51->cd();
C5.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("K#lower[-0.15]{+} Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{+} Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c51->Print("mult5_correlation_matrix.pdf");
TCanvas* c4 = new TCanvas("c4","",700,700);
c4->SetLeftMargin(.1);
c4->SetBottomMargin(.1);
c4->SetTopMargin(.075);
c4->SetRightMargin(.15);
c4->cd();
M4.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("K#lower[-0.15]{-} Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{-} Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c4->Print("mult4_matrix.pdf");
TCanvas* c41 = new TCanvas("c41","",700,700);
c41->SetLeftMargin(.1);
c41->SetBottomMargin(.1);
c41->SetTopMargin(.075);
c41->SetRightMargin(.15);
c41->cd();
C4.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("K#lower[-0.15]{-} Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{-} Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c41->Print("mult4_correlation_matrix.pdf");
TCanvas* c3 = new TCanvas("c3","",700,700);
c3->SetLeftMargin(.1);
c3->SetBottomMargin(.1);
c3->SetTopMargin(.075);
c3->SetRightMargin(.15);
c3->cd();
M3.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("K#lower[-0.15]{0} Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{0} Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c3->Print("mult3_matrix.pdf");
TCanvas* c31 = new TCanvas("c31","",700,700);
c31->SetLeftMargin(.1);
c31->SetBottomMargin(.1);
c31->SetTopMargin(.075);
c31->SetRightMargin(.15);
c31->cd();
C3.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("K#lower[-0.15]{0} Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} K#lower[-0.15]{0} Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c31->Print("mult3_correlation_matrix.pdf");
TCanvas* c2 = new TCanvas("c2","",700,700);
c2->SetLeftMargin(.1);
c2->SetBottomMargin(.1);
c2->SetTopMargin(.075);
c2->SetRightMargin(.15);
c2->cd();
M2.Draw("COLZ");
gStyle->SetPalette(56,0);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->SetContour(999);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("#pi#lower[-0.15]{+} Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} #pi#lower[-0.15]{+} Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c2->Print("mult2_matrix.pdf");
TCanvas* c21 = new TCanvas("c21","",700,700);
c21->SetLeftMargin(.1);
c21->SetBottomMargin(.1);
c21->SetTopMargin(.075);
c21->SetRightMargin(.15);
c21->cd();
C2.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("#pi#lower[-0.15]{+} Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} #pi#lower[-0.15]{+} Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c21->Print("mult2_correlation_matrix.pdf");
TCanvas* c1 = new TCanvas("c1","",700,700);
c1->SetLeftMargin(.1);
c1->SetBottomMargin(.1);
c1->SetTopMargin(.075);
c1->SetRightMargin(.15);
c1->cd();
M1.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
//TMatrixFBase->GetZaxis()->SetTitle("#pi#lower[-0.15]{-} Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} #pi#lower[-0.15]{-} Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c1->Print("mult1_matrix.pdf");
TCanvas* c11 = new TCanvas("c11","",700,700);
c11->SetLeftMargin(.1);
c11->SetBottomMargin(.1);
c11->SetTopMargin(.075);
c11->SetRightMargin(.15);
c11->cd();
C1.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("#pi#lower[-0.15]{-} Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} #pi#lower[-0.15]{-} Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c11->Print("mult1_correlation_matrix.pdf");
TCanvas* c0 = new TCanvas("c0","",700,700);
c0->SetLeftMargin(.1);
c0->SetBottomMargin(.1);
c0->SetTopMargin(.075);
c0->SetRightMargin(.15);
c0->cd();
M0.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-0.005,0.045);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("Beam UniSim Covariance Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kBlue);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Beam Fractional Error Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c0->Print("mult0_matrix.pdf");
TCanvas* c01 = new TCanvas("c01","",700,700);
c01->SetLeftMargin(.1);
c01->SetBottomMargin(.1);
c01->SetTopMargin(.075);
c01->SetRightMargin(.15);
c01->cd();
C0.Draw("COLZ");
gStyle->SetPalette(56,0);
TMatrixFBase->SetContour(999);
//TMatrixFBase->GetZaxis()->SetRangeUser(-1,1);
TMatrixFBase->GetZaxis()->SetTitleFont(62);
TMatrixFBase->GetZaxis()->SetLabelFont(62);
TMatrixFBase->GetZaxis()->SetTitleSize(0.045);
// TMatrixFBase->GetZaxis()->SetTitle("Beam UniSim Correlation Matrix");
TMatrixFBase->GetZaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetXaxis()->SetTitle("");
TMatrixFBase->GetXaxis()->SetLabelSize(0);
TMatrixFBase->GetXaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetTitle("");
TMatrixFBase->GetYaxis()->SetTitleOffset(1.5);
TMatrixFBase->GetYaxis()->SetLabelSize(0);
TMatrixFBase->SetStats(0);
TLine *split = new TLine();
split->SetLineStyle(2);
split->SetLineWidth(5);
split->SetLineColor(kYellow);
split->DrawLineNDC(.1,.51,.849,.51);
split->DrawLineNDC(.475,.101,.475,.930);
add_plot_label("| 0.2 #minus 3.0 GeV | 0.2 #minus 3.0 GeV | ", 0.48,0.08,0.03);
TLatex *Total = new TLatex(.2,.96,"#nu#lower[0.3]{#mu} Beam Correlation Matrix");
Total->SetNDC();
Total->SetTextFont(62);
Total->SetTextSize(0.045);
Total->Draw();
ND->Draw();
MD->Draw();
ND45->Draw();
MD45->Draw();
// c01->Print("mult0_correlation_matrix.pdf");
TCanvas* c86 = new TCanvas("c86","",800,400);
c86->SetLeftMargin(.1);
c86->SetBottomMargin(.1);
c86->SetTopMargin(.05);
c86->SetRightMargin(.05);
c86->cd();
Fig6->GetYaxis()->SetTitle("Fractional Error");
Fig6->GetYaxis()->SetTitleFont(62);
Fig6->GetXaxis()->SetTitleFont(62);
Fig6->GetYaxis()->SetLabelFont(62);
Fig6->GetXaxis()->SetLabelFont(62);
Fig6->GetYaxis()->CenterTitle();
Fig6->GetYaxis()->SetTitleSize(0.06);
Fig6->GetYaxis()->SetTitleOffset(0.8);
Fig6->GetXaxis()->SetLabelSize(0.06);
Fig6->GetYaxis()->SetLabelSize(0.06);
Fig6->GetXaxis()->SetTitleOffset(1.5);
Fig6->SetStats(0);
Fig6->SetMinimum(-0.01);
Fig6->SetMaximum(0.21);
Fig6->SetMarkerStyle(8);
Fig6->GetYaxis()->SetNdivisions(509);
Fig6->GetXaxis()->SetNdivisions(509);
Fig6->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
TLatex *ND = new TLatex(.23,.85,"LAr1-ND (100m) ");
ND->SetNDC();
ND->SetTextFont(62);
ND->SetTextSize(0.05);
ND->Draw();
TLatex *MD = new TLatex(.65,.85,"T600 (600m, on axis)");
MD->SetNDC();
MD->SetTextFont(62);
MD->SetTextSize(0.05);
MD->Draw();
// c86->Print("FractionalErrors_Total.pdf");
TCanvas* c85 = new TCanvas("c85","",800,400);
c85->SetLeftMargin(.1);
c85->SetBottomMargin(.1);
c85->SetTopMargin(.05);
c85->SetRightMargin(.05);
c85->cd();
Fig5->GetYaxis()->SetTitle("K#lower[-0.2]{+} Fractional Error");
Fig5->GetYaxis()->SetTitleFont(62);
Fig5->GetXaxis()->SetTitleFont(62);
Fig5->GetYaxis()->SetLabelFont(62);
Fig5->GetXaxis()->SetLabelFont(62);
Fig5->GetYaxis()->CenterTitle();
Fig5->GetYaxis()->SetTitleSize(0.06);
Fig5->GetYaxis()->SetTitleOffset(0.8);
Fig5->GetXaxis()->SetLabelSize(0.06);
Fig5->GetYaxis()->SetLabelSize(0.06);
Fig5->GetXaxis()->SetTitleOffset(1.5);
Fig5->SetStats(0);
Fig5->SetMinimum(-0.01);
Fig5->SetMaximum(0.21);
Fig5->SetMarkerStyle(8);
Fig5->GetYaxis()->SetNdivisions(509);
Fig5->GetXaxis()->SetNdivisions(509);
Fig5->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c85->Print("FractionalErrors_Kplus.pdf");
TCanvas* c84 = new TCanvas("c84","",800,400);
c84->SetLeftMargin(.1);
c84->SetBottomMargin(.1);
c84->SetTopMargin(.05);
c84->SetRightMargin(.05);
c84->cd();
Fig4->GetYaxis()->SetTitle("K#lower[-0.2]{-} Fractional Error");
Fig4->GetYaxis()->SetTitleFont(62);
Fig4->GetXaxis()->SetTitleFont(62);
Fig4->GetYaxis()->SetLabelFont(62);
Fig4->GetXaxis()->SetLabelFont(62);
Fig4->GetYaxis()->CenterTitle();
Fig4->GetYaxis()->SetTitleSize(0.06);
Fig4->GetYaxis()->SetTitleOffset(0.8);
Fig4->GetXaxis()->SetLabelSize(0.06);
Fig4->GetYaxis()->SetLabelSize(0.06);
Fig4->GetXaxis()->SetTitleOffset(1.5);
Fig4->SetStats(0);
Fig4->SetMinimum(-0.01);
Fig4->SetMaximum(0.21);
Fig4->SetMarkerStyle(8);
Fig4->GetYaxis()->SetNdivisions(509);
Fig4->GetXaxis()->SetNdivisions(509);
Fig4->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c84->Print("FractionalErrors_Kmin.pdf");
TCanvas* c83 = new TCanvas("c83","",800,400);
c83->SetLeftMargin(.1);
c83->SetBottomMargin(.1);
c83->SetTopMargin(.05);
c83->SetRightMargin(.05);
c83->cd();
Fig3->GetYaxis()->SetTitle("K#lower[-0.2]{0} Fractional Error");
Fig3->GetYaxis()->SetTitleFont(62);
Fig3->GetXaxis()->SetTitleFont(62);
Fig3->GetYaxis()->SetLabelFont(62);
Fig3->GetXaxis()->SetLabelFont(62);
Fig3->GetYaxis()->CenterTitle();
Fig3->GetYaxis()->SetTitleSize(0.06);
Fig3->GetYaxis()->SetTitleOffset(0.8);
Fig3->GetXaxis()->SetLabelSize(0.06);
Fig3->GetYaxis()->SetLabelSize(0.06);
Fig3->GetXaxis()->SetTitleOffset(1.5);
Fig3->SetStats(0);
Fig3->SetMinimum(-0.01);
Fig3->SetMaximum(0.21);
Fig3->SetMarkerStyle(8);
Fig3->GetYaxis()->SetNdivisions(509);
Fig3->GetXaxis()->SetNdivisions(509);
Fig3->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c83->Print("FractionalErrors_K0.pdf");
TCanvas* c82 = new TCanvas("c82","",800,400);
c82->SetLeftMargin(.1);
c82->SetBottomMargin(.1);
c82->SetTopMargin(.05);
c82->SetRightMargin(.05);
c82->cd();
Fig2->GetYaxis()->SetTitle("#pi#lower[-0.2]{+} Fractional Error");
Fig2->GetYaxis()->SetTitleFont(62);
Fig2->GetXaxis()->SetTitleFont(62);
Fig2->GetYaxis()->SetLabelFont(62);
Fig2->GetXaxis()->SetLabelFont(62);
Fig2->GetYaxis()->CenterTitle();
Fig2->GetYaxis()->SetTitleSize(0.06);
Fig2->GetYaxis()->SetTitleOffset(0.8);
Fig2->GetXaxis()->SetLabelSize(0.06);
Fig2->GetYaxis()->SetLabelSize(0.06);
Fig2->GetXaxis()->SetTitleOffset(1.5);
Fig2->SetStats(0);
Fig2->SetMinimum(-0.01);
Fig2->SetMaximum(0.21);
Fig2->SetMarkerStyle(8);
Fig2->GetYaxis()->SetNdivisions(509);
Fig2->GetXaxis()->SetNdivisions(509);
Fig2->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c82->Print("FractionalErrors_piplus.pdf");
TCanvas* c81 = new TCanvas("c81","",800,400);
c81->SetLeftMargin(.1);
c81->SetBottomMargin(.1);
c81->SetTopMargin(.05);
c81->SetRightMargin(.05);
c81->cd();
Fig1->GetYaxis()->SetTitle("#pi#lower[-0.2]{-} Fractional Error");
Fig1->GetYaxis()->SetTitleFont(62);
Fig1->GetXaxis()->SetTitleFont(62);
Fig1->GetYaxis()->SetLabelFont(62);
Fig1->GetXaxis()->SetLabelFont(62);
Fig1->GetYaxis()->CenterTitle();
Fig1->GetYaxis()->SetTitleSize(0.06);
Fig1->GetYaxis()->SetTitleOffset(0.8);
Fig1->GetXaxis()->SetLabelSize(0.06);
Fig1->GetYaxis()->SetLabelSize(0.06);
Fig1->GetXaxis()->SetTitleOffset(1.5);
Fig1->SetStats(0);
Fig1->SetMinimum(-0.01);
Fig1->SetMaximum(0.21);
Fig1->SetMarkerStyle(8);
Fig1->GetYaxis()->SetNdivisions(509);
Fig1->GetXaxis()->SetNdivisions(509);
Fig1->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c81->Print("FractionalErrors_pimin.pdf");
TCanvas* c80 = new TCanvas("c80","",800,400);
c80->SetLeftMargin(.1);
c80->SetBottomMargin(.1);
c80->SetTopMargin(.05);
c80->SetRightMargin(.05);
c80->cd();
Fig0->GetYaxis()->SetTitle("Beam Fractional Error");
Fig0->GetYaxis()->SetTitleFont(62);
Fig0->GetXaxis()->SetTitleFont(62);
Fig0->GetYaxis()->SetLabelFont(62);
Fig0->GetXaxis()->SetLabelFont(62);
Fig0->GetYaxis()->CenterTitle();
Fig0->GetYaxis()->SetTitleSize(0.06);
Fig0->GetYaxis()->SetTitleOffset(0.8);
Fig0->GetXaxis()->SetLabelSize(0.06);
Fig0->GetYaxis()->SetLabelSize(0.06);
Fig0->GetXaxis()->SetTitleOffset(1.5);
Fig0->SetStats(0);
Fig0->SetMinimum(-0.01);
Fig0->SetMaximum(0.21);
Fig0->SetMarkerStyle(8);
Fig0->GetYaxis()->SetNdivisions(509);
Fig0->GetXaxis()->SetNdivisions(509);
Fig0->Draw("P");
split->SetLineColor(1);
split->SetLineWidth(2);
split->DrawLine(19,-0.01,19,0.21);
ND->Draw();
MD->Draw();
// c80->Print("FractionalErrors_beam.pdf");
cout<<"\nEnd of routine.\n";
return 0;
}
int main(void){
Marray<double,4> A4(3,3,3,3);
Marray<double,1> B1(3);
Marray<double,3> C3Test(3,3,3);
Marray<double,3> C3(3,3,3);
A4.sucesion(0,1);
B1.sucesion(0,1);
Index<'i'> iG;
Index<'j'> jG;
Index<'k'> kG;
Index<'l'> lG;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,j,k,l)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,jG,kG,lG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,j,l,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,jG,lG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,l,j,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,lG,jG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(j,i,k,l)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(jG,iG,kG,lG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(l,i,j,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(lG,iG,jG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
}
Molecule C6H6()
{
int nAtoms = 12;
// These are in Angstrom
Eigen::Vector3d C1(5.274, 1.999, -8.568);
Eigen::Vector3d C2(6.627, 2.018, -8.209);
Eigen::Vector3d C3(7.366, 0.829, -8.202);
Eigen::Vector3d C4(6.752, -0.379, -8.554);
Eigen::Vector3d C5(5.399, -0.398, -8.912);
Eigen::Vector3d C6(4.660, 0.791, -8.919);
Eigen::Vector3d H1(4.704, 2.916, -8.573);
Eigen::Vector3d H2(7.101, 2.950, -7.938);
Eigen::Vector3d H3(8.410, 0.844, -7.926);
Eigen::Vector3d H4(7.322, -1.296, -8.548);
Eigen::Vector3d H5(4.925, -1.330, -9.183);
Eigen::Vector3d H6(3.616, 0.776, -9.196);
// Scale
C1 /= convertBohrToAngstrom;
C2 /= convertBohrToAngstrom;
C3 /= convertBohrToAngstrom;
C4 /= convertBohrToAngstrom;
C5 /= convertBohrToAngstrom;
C6 /= convertBohrToAngstrom;
H1 /= convertBohrToAngstrom;
H2 /= convertBohrToAngstrom;
H3 /= convertBohrToAngstrom;
H4 /= convertBohrToAngstrom;
H5 /= convertBohrToAngstrom;
H6 /= convertBohrToAngstrom;
Eigen::MatrixXd geom(3, nAtoms);
geom.col(0) = C1.transpose();
geom.col(1) = C2.transpose();
geom.col(2) = C3.transpose();
geom.col(3) = C4.transpose();
geom.col(4) = C5.transpose();
geom.col(5) = C6.transpose();
geom.col(6) = H1.transpose();
geom.col(7) = H2.transpose();
geom.col(8) = H3.transpose();
geom.col(9) = H4.transpose();
geom.col(10) = H5.transpose();
geom.col(11) = H6.transpose();
Eigen::VectorXd charges(12), masses(12);
charges << 6.0, 6.0, 6.0, 6.0, 6.0, 6.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0;
masses << 12.00, 12.0, 12.0, 12.0, 12.0, 12.0, 1.0078250, 1.0078250, 1.0078250,
1.0078250, 1.0078250, 1.0078250;
double radiusC = 1.70 / convertBohrToAngstrom;
double radiusH = 1.20 / convertBohrToAngstrom;
std::vector<Atom> atoms;
atoms.push_back( Atom("Carbon", "C", charges(0), masses(0), radiusC, C1, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(1), masses(1), radiusC, C2, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(2), masses(2), radiusC, C3, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(3), masses(3), radiusC, C4, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(4), masses(4), radiusC, C5, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(5), masses(5), radiusC, C6, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(6), masses(6), radiusH, H1, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(7), masses(7), radiusH, H2, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(8), masses(8), radiusH, H3, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(9), masses(9), radiusH, H4, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(10), masses(10), radiusH, H5, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(11), masses(11), radiusH, H6, 1.0) );
std::vector<Sphere> spheres;
Sphere sph1(C1, radiusC);
Sphere sph2(C2, radiusC);
Sphere sph3(C3, radiusC);
Sphere sph4(C4, radiusC);
Sphere sph5(C5, radiusC);
Sphere sph6(C6, radiusC);
Sphere sph7(H1, radiusH);
Sphere sph8(H2, radiusH);
Sphere sph9(H3, radiusH);
Sphere sph10(H4, radiusH);
Sphere sph11(H5, radiusH);
Sphere sph12(H6, radiusH);
spheres.push_back(sph1);
spheres.push_back(sph2);
spheres.push_back(sph3);
spheres.push_back(sph4);
spheres.push_back(sph5);
spheres.push_back(sph6);
spheres.push_back(sph7);
spheres.push_back(sph8);
spheres.push_back(sph9);
spheres.push_back(sph10);
spheres.push_back(sph11);
spheres.push_back(sph12);
// D2h as generated by Oxy, Oxz, Oyz
Symmetry pGroup = buildGroup(0, 0, 0, 0);
return Molecule(nAtoms, charges, masses, geom, atoms, spheres, pGroup);
};
void whirlpool_block(WHIRLPOOL_CTX *ctx,const void *inp,size_t n)
{
int r;
const u8 *p=inp;
union { u64 q[8]; u8 c[64]; } S,K,*H=(void *)ctx->H.q;
#ifdef GO_FOR_MMX
GO_FOR_MMX(ctx,inp,n);
#endif
do {
#ifdef OPENSSL_SMALL_FOOTPRINT
u64 L[8];
int i;
for (i=0;i<64;i++) S.c[i] = (K.c[i] = H->c[i]) ^ p[i];
for (r=0;r<ROUNDS;r++)
{
for (i=0;i<8;i++)
{
L[i] = i ? 0 : RC[r];
L[i] ^= C0(K,i) ^ C1(K,(i-1)&7) ^
C2(K,(i-2)&7) ^ C3(K,(i-3)&7) ^
C4(K,(i-4)&7) ^ C5(K,(i-5)&7) ^
C6(K,(i-6)&7) ^ C7(K,(i-7)&7);
}
memcpy (K.q,L,64);
for (i=0;i<8;i++)
{
L[i] ^= C0(S,i) ^ C1(S,(i-1)&7) ^
C2(S,(i-2)&7) ^ C3(S,(i-3)&7) ^
C4(S,(i-4)&7) ^ C5(S,(i-5)&7) ^
C6(S,(i-6)&7) ^ C7(S,(i-7)&7);
}
memcpy (S.q,L,64);
}
for (i=0;i<64;i++) H->c[i] ^= S.c[i] ^ p[i];
#else
u64 L0,L1,L2,L3,L4,L5,L6,L7;
#ifdef __STRICT_ALIGNMENT
if ((size_t)p & 7)
{
memcpy (S.c,p,64);
S.q[0] ^= (K.q[0] = H->q[0]);
S.q[1] ^= (K.q[1] = H->q[1]);
S.q[2] ^= (K.q[2] = H->q[2]);
S.q[3] ^= (K.q[3] = H->q[3]);
S.q[4] ^= (K.q[4] = H->q[4]);
S.q[5] ^= (K.q[5] = H->q[5]);
S.q[6] ^= (K.q[6] = H->q[6]);
S.q[7] ^= (K.q[7] = H->q[7]);
}
else
#endif
{
const u64 *pa = (const u64*)p;
S.q[0] = (K.q[0] = H->q[0]) ^ pa[0];
S.q[1] = (K.q[1] = H->q[1]) ^ pa[1];
S.q[2] = (K.q[2] = H->q[2]) ^ pa[2];
S.q[3] = (K.q[3] = H->q[3]) ^ pa[3];
S.q[4] = (K.q[4] = H->q[4]) ^ pa[4];
S.q[5] = (K.q[5] = H->q[5]) ^ pa[5];
S.q[6] = (K.q[6] = H->q[6]) ^ pa[6];
S.q[7] = (K.q[7] = H->q[7]) ^ pa[7];
}
for(r=0;r<ROUNDS;r++)
{
#ifdef SMALL_REGISTER_BANK
L0 = C0(K,0) ^ C1(K,7) ^ C2(K,6) ^ C3(K,5) ^
C4(K,4) ^ C5(K,3) ^ C6(K,2) ^ C7(K,1) ^ RC[r];
L1 = C0(K,1) ^ C1(K,0) ^ C2(K,7) ^ C3(K,6) ^
C4(K,5) ^ C5(K,4) ^ C6(K,3) ^ C7(K,2);
L2 = C0(K,2) ^ C1(K,1) ^ C2(K,0) ^ C3(K,7) ^
C4(K,6) ^ C5(K,5) ^ C6(K,4) ^ C7(K,3);
L3 = C0(K,3) ^ C1(K,2) ^ C2(K,1) ^ C3(K,0) ^
C4(K,7) ^ C5(K,6) ^ C6(K,5) ^ C7(K,4);
L4 = C0(K,4) ^ C1(K,3) ^ C2(K,2) ^ C3(K,1) ^
C4(K,0) ^ C5(K,7) ^ C6(K,6) ^ C7(K,5);
L5 = C0(K,5) ^ C1(K,4) ^ C2(K,3) ^ C3(K,2) ^
C4(K,1) ^ C5(K,0) ^ C6(K,7) ^ C7(K,6);
L6 = C0(K,6) ^ C1(K,5) ^ C2(K,4) ^ C3(K,3) ^
C4(K,2) ^ C5(K,1) ^ C6(K,0) ^ C7(K,7);
L7 = C0(K,7) ^ C1(K,6) ^ C2(K,5) ^ C3(K,4) ^
C4(K,3) ^ C5(K,2) ^ C6(K,1) ^ C7(K,0);
K.q[0] = L0; K.q[1] = L1; K.q[2] = L2; K.q[3] = L3;
K.q[4] = L4; K.q[5] = L5; K.q[6] = L6; K.q[7] = L7;
L0 ^= C0(S,0) ^ C1(S,7) ^ C2(S,6) ^ C3(S,5) ^
C4(S,4) ^ C5(S,3) ^ C6(S,2) ^ C7(S,1);
L1 ^= C0(S,1) ^ C1(S,0) ^ C2(S,7) ^ C3(S,6) ^
C4(S,5) ^ C5(S,4) ^ C6(S,3) ^ C7(S,2);
L2 ^= C0(S,2) ^ C1(S,1) ^ C2(S,0) ^ C3(S,7) ^
C4(S,6) ^ C5(S,5) ^ C6(S,4) ^ C7(S,3);
L3 ^= C0(S,3) ^ C1(S,2) ^ C2(S,1) ^ C3(S,0) ^
C4(S,7) ^ C5(S,6) ^ C6(S,5) ^ C7(S,4);
L4 ^= C0(S,4) ^ C1(S,3) ^ C2(S,2) ^ C3(S,1) ^
C4(S,0) ^ C5(S,7) ^ C6(S,6) ^ C7(S,5);
L5 ^= C0(S,5) ^ C1(S,4) ^ C2(S,3) ^ C3(S,2) ^
C4(S,1) ^ C5(S,0) ^ C6(S,7) ^ C7(S,6);
L6 ^= C0(S,6) ^ C1(S,5) ^ C2(S,4) ^ C3(S,3) ^
C4(S,2) ^ C5(S,1) ^ C6(S,0) ^ C7(S,7);
L7 ^= C0(S,7) ^ C1(S,6) ^ C2(S,5) ^ C3(S,4) ^
C4(S,3) ^ C5(S,2) ^ C6(S,1) ^ C7(S,0);
S.q[0] = L0; S.q[1] = L1; S.q[2] = L2; S.q[3] = L3;
S.q[4] = L4; S.q[5] = L5; S.q[6] = L6; S.q[7] = L7;
#else
L0 = C0(K,0); L1 = C1(K,0); L2 = C2(K,0); L3 = C3(K,0);
L4 = C4(K,0); L5 = C5(K,0); L6 = C6(K,0); L7 = C7(K,0);
L0 ^= RC[r];
L1 ^= C0(K,1); L2 ^= C1(K,1); L3 ^= C2(K,1); L4 ^= C3(K,1);
L5 ^= C4(K,1); L6 ^= C5(K,1); L7 ^= C6(K,1); L0 ^= C7(K,1);
L2 ^= C0(K,2); L3 ^= C1(K,2); L4 ^= C2(K,2); L5 ^= C3(K,2);
L6 ^= C4(K,2); L7 ^= C5(K,2); L0 ^= C6(K,2); L1 ^= C7(K,2);
L3 ^= C0(K,3); L4 ^= C1(K,3); L5 ^= C2(K,3); L6 ^= C3(K,3);
L7 ^= C4(K,3); L0 ^= C5(K,3); L1 ^= C6(K,3); L2 ^= C7(K,3);
L4 ^= C0(K,4); L5 ^= C1(K,4); L6 ^= C2(K,4); L7 ^= C3(K,4);
L0 ^= C4(K,4); L1 ^= C5(K,4); L2 ^= C6(K,4); L3 ^= C7(K,4);
L5 ^= C0(K,5); L6 ^= C1(K,5); L7 ^= C2(K,5); L0 ^= C3(K,5);
L1 ^= C4(K,5); L2 ^= C5(K,5); L3 ^= C6(K,5); L4 ^= C7(K,5);
L6 ^= C0(K,6); L7 ^= C1(K,6); L0 ^= C2(K,6); L1 ^= C3(K,6);
L2 ^= C4(K,6); L3 ^= C5(K,6); L4 ^= C6(K,6); L5 ^= C7(K,6);
L7 ^= C0(K,7); L0 ^= C1(K,7); L1 ^= C2(K,7); L2 ^= C3(K,7);
L3 ^= C4(K,7); L4 ^= C5(K,7); L5 ^= C6(K,7); L6 ^= C7(K,7);
K.q[0] = L0; K.q[1] = L1; K.q[2] = L2; K.q[3] = L3;
K.q[4] = L4; K.q[5] = L5; K.q[6] = L6; K.q[7] = L7;
L0 ^= C0(S,0); L1 ^= C1(S,0); L2 ^= C2(S,0); L3 ^= C3(S,0);
L4 ^= C4(S,0); L5 ^= C5(S,0); L6 ^= C6(S,0); L7 ^= C7(S,0);
L1 ^= C0(S,1); L2 ^= C1(S,1); L3 ^= C2(S,1); L4 ^= C3(S,1);
L5 ^= C4(S,1); L6 ^= C5(S,1); L7 ^= C6(S,1); L0 ^= C7(S,1);
L2 ^= C0(S,2); L3 ^= C1(S,2); L4 ^= C2(S,2); L5 ^= C3(S,2);
L6 ^= C4(S,2); L7 ^= C5(S,2); L0 ^= C6(S,2); L1 ^= C7(S,2);
L3 ^= C0(S,3); L4 ^= C1(S,3); L5 ^= C2(S,3); L6 ^= C3(S,3);
L7 ^= C4(S,3); L0 ^= C5(S,3); L1 ^= C6(S,3); L2 ^= C7(S,3);
L4 ^= C0(S,4); L5 ^= C1(S,4); L6 ^= C2(S,4); L7 ^= C3(S,4);
L0 ^= C4(S,4); L1 ^= C5(S,4); L2 ^= C6(S,4); L3 ^= C7(S,4);
L5 ^= C0(S,5); L6 ^= C1(S,5); L7 ^= C2(S,5); L0 ^= C3(S,5);
L1 ^= C4(S,5); L2 ^= C5(S,5); L3 ^= C6(S,5); L4 ^= C7(S,5);
L6 ^= C0(S,6); L7 ^= C1(S,6); L0 ^= C2(S,6); L1 ^= C3(S,6);
L2 ^= C4(S,6); L3 ^= C5(S,6); L4 ^= C6(S,6); L5 ^= C7(S,6);
L7 ^= C0(S,7); L0 ^= C1(S,7); L1 ^= C2(S,7); L2 ^= C3(S,7);
L3 ^= C4(S,7); L4 ^= C5(S,7); L5 ^= C6(S,7); L6 ^= C7(S,7);
S.q[0] = L0; S.q[1] = L1; S.q[2] = L2; S.q[3] = L3;
S.q[4] = L4; S.q[5] = L5; S.q[6] = L6; S.q[7] = L7;
#endif
}
#ifdef __STRICT_ALIGNMENT
if ((size_t)p & 7)
{
int i;
for(i=0;i<64;i++) H->c[i] ^= S.c[i] ^ p[i];
}
else
#endif
{
const u64 *pa=(const u64 *)p;
H->q[0] ^= S.q[0] ^ pa[0];
H->q[1] ^= S.q[1] ^ pa[1];
H->q[2] ^= S.q[2] ^ pa[2];
H->q[3] ^= S.q[3] ^ pa[3];
H->q[4] ^= S.q[4] ^ pa[4];
H->q[5] ^= S.q[5] ^ pa[5];
H->q[6] ^= S.q[6] ^ pa[6];
H->q[7] ^= S.q[7] ^ pa[7];
}
#endif
p += 64;
} while(--n);
}
void Asaadi1::runProblem()
{
int numVars = 5; // 4 + 1 epigraph variable
// std::vector<VariableType> varTypes(numVars,VariableType::CONTINUOUS);
// std::vector<VariableType> varTypes = {
// VariableType::INTEGER,
// VariableType::INTEGER,
// VariableType::CONTINUOUS,
// VariableType::INTEGER,
// VariableType::CONTINUOUS
// };
std::vector<VariableType> varTypes = {
VariableType::INTEGER,
VariableType::INTEGER,
VariableType::INTEGER,
VariableType::INTEGER,
VariableType::CONTINUOUS
};
std::vector<double> costs = {0, 0, 0, 0, 1};
std::vector<double> lb = {0, 0, 0, 0, -INF};
std::vector<double> lb_unbounded(numVars, -INF);
std::vector<double> ub = {100, 100, 100, 100, INF};
std::vector<VariablePtr> vars;
for (int i = 0; i < numVars; i++)
{
auto var = std::make_shared<Variable>(costs.at(i), lb.at(i), ub.at(i), varTypes.at(i));
vars.push_back(var);
}
std::vector<VariablePtr> xvars = {
vars.at(0),
vars.at(1),
vars.at(2),
vars.at(3)
};
// Constraints
ConstraintSetPtr constraints = std::make_shared<ConstraintSet>();
// Constraint due to epigraph form
DenseVector c0(9);
c0.setZero();
DenseMatrix C0(9,5);
C0.setZero();
c0(0) = 1; C0(0,0) = 2;
c0(1) = 1; C0(1,1) = 2;
c0(2) = 2; C0(2,2) = 2;
c0(3) = 1; C0(3,3) = 2;
c0(4) = -5; C0(4,0) = 1;
c0(5) = -5; C0(5,1) = 1;
c0(6) = -21; C0(6,2) = 1;
c0(7) = 7; C0(7,3) = 1;
c0(8) = -1; C0(8,4) = 1; // -t (epigraph)
ConstraintPtr cPoly0 = std::make_shared<ConstraintPolynomial>(vars, c0, C0, false);
constraints->add(cPoly0);
DenseVector c1(9);
c1.setZero();
DenseMatrix C1(9,4);
C1.setZero();
c1(0) = -1; C1(0,0) = 2;
c1(1) = -1; C1(1,1) = 2;
c1(2) = -1; C1(2,2) = 2;
c1(3) = -1; C1(3,3) = 2;
c1(4) = -1; C1(4,0) = 1;
c1(5) = 1; C1(5,1) = 1;
c1(6) = -1; C1(6,2) = 1;
c1(7) = 1; C1(7,3) = 1;
c1(8) = 8; // -8 <= p(x) <=> 0 <= 8 + p(x)
ConstraintPtr cPoly1 = std::make_shared<ConstraintPolynomial>(xvars, -c1, C1, false);
constraints->add(cPoly1);
DenseVector c2(7);
c2.setZero();
DenseMatrix C2(7,4);
C2.setZero();
c2(0) = -1; C2(0,0) = 2;
c2(1) = -2; C2(1,1) = 2;
c2(2) = -1; C2(2,2) = 2;
c2(3) = -2; C2(3,3) = 2;
c2(4) = 1; C2(4,0) = 1;
c2(5) = 1; C2(5,3) = 1;
c2(6) = 10; // -10 <= p(x)
ConstraintPtr cPoly2 = std::make_shared<ConstraintPolynomial>(xvars, -c2, C2, false);
constraints->add(cPoly2);
DenseVector c3(7);
c3.setZero();
DenseMatrix C3(7,4);
C3.setZero();
c3(0) = -2; C3(0,0) = 2;
c3(1) = -1; C3(1,1) = 2;
c3(2) = -1; C3(2,2) = 2;
c3(3) = -2; C3(3,0) = 1;
c3(4) = 1; C3(4,1) = 1;
c3(5) = 1; C3(5,3) = 1;
c3(6) = 5; // -5 <= p(x)
ConstraintPtr cPoly3 = std::make_shared<ConstraintPolynomial>(xvars, -c3, C3, false);
constraints->add(cPoly3);
// Problem 1: all variables are continuous and unbounded (not bounded from below)
// f* = -44, x* = (0, 1, 2, -1)
// Problem 2: all variables are continuous and non-negative
// f* = -40.96, x* = (0, 1.038, 2.227, 0)
// Problem 3: variables x1, x2, and x4 are non-negative integers, x3 is non-negative and continous
// f* = -40.957, x* = (0, 1, 2.236, 0)
// Problem 4: all variables are non-negative integers
// f* = -38.000, x* = (0, 1, 2, 0)
cout << constraints->isConstraintConvex() << endl;
if (!constraints->isConstraintConvex())
cout << "NOOOOOOOOOOOOOT CONVEEEEEEEEEEEEEEEX!!!!!!!!!!" << endl;
else
cout << "CONVEEEEEEEEEEEEEEEX!!!!!!!!!!" << endl;
constraints->writeToGAMS("asaadi.gms");
//SolverBonmin solver(constraints);
BB::BranchAndBound solver(constraints);
SolverResult res = solver.optimize();
cout << res << endl;
cout << res.primalVariables << endl;
zopt_found = res.primalVariables;
fopt_found = res.objectiveValue;
}
