QString GeneratedVector::descriptionTip() const {
return i18n("Generated Vector: %1\n"
" %2 values from %3 to %4").arg(Name()).arg(length()).arg(_v[0]).arg(_v[length()-1]);
}
// calculates which video dir to use
bool cVideoDirectory::GetPreferedVideoDir(void)
{
cVideoDirectory d;
int nDirs = 1,
vidUse = Setup.nVidPrefer;
int i, top, topFree, x;
if (name == NULL)
return(false);
// count available video dirs
while (d.Next() == true)
nDirs++;
if (vidUse > nDirs)
vidUse = nDirs;
// check for prefered video dir
for (i = 0, top = -1, topFree = 0; i < vidUse; i++) {
if (IsVidDirOK(i, &x) == true) {
if (top == -1) {
// nothing set yet, use first 'ok' dir
top = i;
topFree = x;
}
else {
// check if we got a higher priority
if (Setup.VidPreferPrio[ i ] >= Setup.VidPreferPrio[ top ]) {
top = i;
topFree = x;
}
// check if we got same priority but more space
else if (Setup.VidPreferPrio[ i ] == Setup.VidPreferPrio[ top ] && x >= topFree) {
top = i;
topFree = x;
}
}
}
}
if (top == -1) {
isyslog("VidPrefer: no prefered video directory could be determined!");
// something went wrong here...
// let VDR determine the video directory
int MaxFree = FreeMB();
while (Next()) {
int Free = FreeDiskSpaceMB(Name());
if (Free > MaxFree) {
Store();
MaxFree = Free;
}
}
}
else {
isyslog("VidPrefer: prefered video directory '%d' set.", top);
if (stored != NULL)
free(stored);
stored = GetVidPath(top);
}
return true;
}
void roo_fitWH()
{
TString poscharge = "Plus";
TString negcharge = "Minus";
std::vector<TString> charge(2);
charge.at(0) = poscharge;
charge.at(1) = negcharge;
TString canvas_name_plus = "muon_MC_WHelicityFramePlots_PlusICVar";
TCanvas *c0 = new TCanvas(canvas_name_plus,"",450,400);
TString canvas_name_minus = "muon_MC_WHelicityFramePlots_MinusICVar";
TCanvas *c1 = new TCanvas(canvas_name_minus,"",450,400);
// Run both for + and - charges
for(unsigned int j=0; j<charge.size(); j++) {
// if (j==1) break; // do only + charge fit
if (realData) { sfactor=36; }
// Nominal values are taken from a fit to the MC W data (scaled to 100pb-1)
RooRealVar *fLnom, *fRnom, *f0nom;
if (j==0) {
fLnom=new RooRealVar("fL_nom","fLnom",0.556);
fRnom=new RooRealVar("fR_nom","fRnom",0.234);
f0nom=new RooRealVar("f0_nom","f0nom",0.210);
} else {
fLnom=new RooRealVar("fL_nom","fLnom",0.523);
fRnom=new RooRealVar("fR_nom","fRnom",0.265);
f0nom=new RooRealVar("f0_nom","f0nom",0.212);
}
TString Hist1 = "RECO_PolPlots_50toinf/RECO_ICVarPF"+ charge.at(j) + "_LH";
TString Hist2 = "RECO_PolPlots_50toinf/RECO_ICVarPF"+ charge.at(j) + "_RH";
TString Hist3 = "RECO_PolPlots_50toinf/RECO_ICVarPF"+ charge.at(j) + "_LO";
TString Hist_data1 = "RECO_PolPlots_50toinf/RECO_ICVarPF"+ charge.at(j);
TH1D *mc1 = (TH1D*)sigfile->Get(Hist1);
TH1D *mc2 = (TH1D*)sigfile->Get(Hist2);
TH1D *mc3 = (TH1D*)sigfile->Get(Hist3);
TH1D *sighist = (TH1D*)sigfile->Get(Hist_data1); // W signal histogram
TH1D *bkghist=(TH1D*)bkgfile->Get(Hist_data1); // Bkg histogram
TH1D *hdata=(TH1D*)datafile->Get(Hist_data1); // Real data histogram
// //we are only fitting for fL and fR
// double accFactor1 = refTempHist1->Integral() / mc1->Integral();
// double accFactor2 = refTempHist2->Integral() / mc2->Integral();
// double accFactor3 = refTempHist3->Integral() / mc3->Integral();
// double normFactor = (mc1->Integral() + mc2->Integral() + mc3->Integral()) / (refTempHist1->Integral() + refTempHist2->Integral() + refTempHist3->Integral());
mc1->Rebin(rbin); mc2->Rebin(rbin); mc3->Rebin(rbin);
sighist->Rebin(rbin); bkghist->Rebin(rbin); hdata->Rebin(rbin);
// Scale to sfactor/pb if MC
//if (!realData) {
if (toyMC) sfactor=400;
sighist->Scale(sfactor); bkghist->Scale(sfactor);
// }
//datahist->Scale(invWeightW);//to get MC errors - otherwise comment out
Double_t nbkg=0;
TH1D *datahist;
if (realData) { datahist=hdata;
} else {
datahist=(TH1D*)sighist->Clone();
if (addbkg) {datahist->Add(bkghist); }
}
if (addbkg) {
//nbkg=bkghist->Integral();
nbkg=bkghist->Integral(bkghist->FindBin(xmin+quanta),bkghist->FindBin(xmax-quanta));
}
//Double_t istat=datahist->Integral();
//Double_t f_sig=(sighist->Integral())/istat; // signal fraction
Double_t istat=datahist->Integral(datahist->FindBin(xmin+quanta),datahist->FindBin(xmax-quanta));
Double_t f_sig=(sighist->Integral(sighist->FindBin(xmin+quanta),sighist->FindBin(xmax-quanta)))/istat;
Double_t f_bkg=nbkg/istat; // bkg fraction
// Start RooFit session
RooRealVar x("x","LP",xmin,xmax);
// Import binned Data
RooDataHist data1("data1","dataset with WHICVarPlus",x,mc1);
RooDataHist data2("data2","dataset with WHICVarPlus",x,mc2);
RooDataHist data3("data3","dataset with WHICVarPlus",x,mc3);
RooDataHist test("data","dataset with WHICVarPlus",x,datahist);
RooDataHist data_bkg("data4","dataset with ICVar",x,bkghist);
// Relative fractions - allow them to float to negative values too if needs be
// if (fitMode==0) {
RooRealVar f1("fL","fL fraction",fLnom->getVal(),0.,1.);
RooRealVar f2("fR","fR fraction", fRnom->getVal(),0.,1.);
RooFormulaVar f3("f0","1-fL-fR",RooArgList(f1,f2));
if (fitMode) {
f1.setVal((fLnom->getVal()-fRnom->getVal())); f1.setRange(-1.,1.);
f1.setPlotLabel("f_{L}-f_{R}");
f2.setVal(f0nom->getVal());
f2.setPlotLabel("f_{0}");
}
// } else {
// RooRealVar f1("fL","fL fraction",(fLnom->getVal()-fRnom->getVal()),-1.,1.);
// RooRealVar f2("fR","fR fraction", (fLnom->getVal()+fRnom->getVal()),-1.,1.);
// RooFormulaVar f3("f0","1-fL-fR",RooArgList(f1,f2));
// }
RooRealVar fsub("fsub","fsub par",(fLnom->getVal()-fRnom->getVal()),-1.,1.);
RooRealVar fsum("fsum","fsum par",(fLnom->getVal()+fRnom->getVal()), -1.,1.);
// Background template
RooHistPdf *bkg = new RooHistPdf("bkg","bkg",x,data_bkg);
// Bkg fraction
RooRealVar fbkg("f_{bkg}","f_bkg fraction",f_bkg);
// Templates
RooHistPdf h1("h1","h1",x,data1); // left-handed template histogram
RooHistPdf h2("h2","h2",x,data2); // right-handed template histo
RooHistPdf h3("h3","h3",x,data3); // longitudinal template histo
// Construct model PDF
RooAbsPdf *sig, *model;
if (charge.at(j) == "Plus") { // plus charge PDFs
if (addParameter) { sig = new RooWPlusExtended("sigmodel","model",x,f1,f2,fsub);
} else { sig = new RooWPlus("sigmodel","model",x,f1,f2); }
} else if (charge.at(j) == "Minus") { // minus charge PDFs
if (addParameter) { sig = new RooWMinusExtended("sigmodel","model",x,f1,f2,fsub);
} else { sig = new RooWMinus("sigmodel","model",x,f1,f2); }
}
if (addbkg) {
model = new RooAddPdf("model","model",RooArgList(*bkg,*sig),fbkg);
} else { model = sig; }
// Set the Fit Range
x.setRange("fitrange",-0.0,1.3);
// Construct likelihood ( + penalty term)
RooNLLVar nll("nll","nll",*model,test,Range("fitrange"));
RooRealVar pen("pen","penalty term",(0.5*1./(0.01*0.01)));
RooFormulaVar nllPen("nllPen","nll+pen*fsub^2",RooArgList(nll,pen,fsub));
// Fitting
RooMinuit *m;
if (!addParameter) { m = new RooMinuit(nll); }
else { m = new RooMinuit(nllPen);}
if (!toyMC) {
m->migrad(); m->hesse();
}
RooFitResult *res1 = m->save();
// Re-diced data
// Int_t nevt=static_cast<int>(istat);
// RooDataSet *gtest = model->generate(x,nevt);
// Fitting
// RooFitResult * res1 = model.fitTo(test,Minos(kFALSE), Save());
// res1->Print();
if(makePlots) {
// Temp PDF for plotting purposes
// RooAddPdf temp("temp","component 1",RooArgList(*h1,*h2,*h3),RooArgList(*f1,*f2)) ;
// Plotting
gROOT->SetStyle("Plain");
gStyle->SetOptFit(0);
gStyle->SetOptTitle(0);
gStyle->SetOptStat(0); //gStyle->SetCanvasDefH(600); //Height of canvas
//gStyle->SetCanvasDefW(600); //Width of canvas
if(charge.at(j) == "Plus") { c0->cd();
//c0->Divide(2,1);c0->cd(1);
}
if(charge.at(j) == "Minus") { c1->cd();
//c1->Divide(2,1);c1->cd(1);
}
//RooPlot* frame = new RooPlot(0.0,1.3,0,800);
RooPlot* frame = x.frame();
test.plotOn(frame,Name("data"));
model->plotOn(frame,Name("model"));
// model->paramOn(frame);//, Format("NELU", AutoPrecision(2)), Layout(0.1,0.5,0.9));
// h1.plotOn(frame);
// h2.plotOn(frame);
// h3.plotOn(frame);
// model->plotOn(frame, Components(h1),LineColor(kRed),LineStyle(kDashed));
// temp->plotOn(frame, Components(h2),LineColor(kGreen),LineStyle(kDashed));
// temp->plotOn(frame, Components(h3),LineColor(kYellow),LineStyle(kDashed));
if (addbkg) {
// model->plotOn(frame, Components(h1),FillColor(5),DrawOption("F"));
//model->plotOn(frame,Components(*bkg),FillColor(5),DrawOption(""));
}
hdata->GetYaxis()->SetTitle("Events / 0.1");
if(charge.at(j) == "Plus") { hdata->GetXaxis()->SetTitle("#it{L_{P}}(#mu^{+})");}
if(charge.at(j) == "Minus") {hdata->GetXaxis()->SetTitle("#it{L_{P}}(#mu^{-})");}
hdata->GetXaxis()->SetTitleSize(0.06);
hdata->GetXaxis()->SetTitleOffset(1.);
hdata->GetYaxis()->SetTitleSize(0.06);
hdata->GetYaxis()->SetTitleOffset(1.2);
hdata->GetXaxis()->SetLabelSize(0.055);
hdata->GetYaxis()->SetLabelSize(0.055);
hdata->GetXaxis()->SetRangeUser(0.0,1.29);
hdata->GetYaxis()->SetRangeUser(0.0,600);
hdata->SetMarkerStyle(20);
// mc1->Draw("same");
// Goodness-of-fit
Double_t chi2= frame->chiSquare("model","data",3);
Double_t nllmin=res1->minNll();
cout << "" << endl;
cout << "Printing out the goodness-of-fit measure:" << endl;
cout << "chi2 = " << chi2 << "\t" << "min NLL = " << nllmin << endl;
res1->Print();
// TCanvas* testt = new TCanvas ("testt","hj");
cout <<"intetral: "<< hdata->Integral()<<endl;
hdata->GetXaxis()->SetRangeUser(0.0,1.29);
cout << hdata->Integral()<<endl;
hdata->Draw("");
// frame->Draw("same");
mc1->GetXaxis()->SetRangeUser(0.0,1.29);
float f_l_a = mc1->Integral();
mc2->GetXaxis()->SetRangeUser(0.0,1.29);
float f_r_a = mc2->Integral();
mc3->GetXaxis()->SetRangeUser(0.0,1.29);
float f_0_a = mc3->Integral();
float allData = hdata->Integral();
float EWKBkg = allData*(f_bkg);
float WData = allData*(1-f_bkg);
float f_l = 0.5*(1-f2.getVal()+f1.getVal());
float f_r = 0.5*(1-f2.getVal()-f1.getVal());
float f_0 = f2.getVal();
cout << "f_l: "<< f_l<< ",f_r: "<< f_r<< ", f_0: "<< f_0<< " 1= "<< f_l+f_r+f_0<< endl;
float allW = f_l*f_l_a+f_r*f_r_a+f_0*f_0_a;
//hdata->Draw("");
// bkghist->GetXaxis()->SetRangeUser(0.0,1.3);
bkghist->Scale(EWKBkg/bkghist->Integral());
bkghist->Draw("samehist");
bkghist->SetLineColor(kYellow);
bkghist->SetFillColor(kYellow);
mc1->Scale(f_l*WData/allW);
mc2->Scale(f_r*WData/allW);
mc3->Scale(f_0*WData/allW);
mc1->SetLineColor(kRed);
mc2->SetLineColor(kGreen);
mc3->SetLineColor(kBlue);
mc1->SetLineWidth(3);
mc2->SetLineWidth(3);
mc3->SetLineWidth(3);
mc1->SetLineStyle(2);
mc2->SetLineStyle(3);
mc3->SetLineStyle(4);
mc1->Draw("samehist");
mc2->Draw("samehist");
mc3->Draw("samehist");
TH1D* allHists = (TH1D*)mc1->Clone();
allHists->Add(mc2,1);
allHists->Add(mc3,1);
allHists->Add(bkghist,1);
allHists->SetLineWidth(3);
// frame->SetOptFit(0);
frame->Draw("same");
// allHists->Draw("same");
TLegend* aleg;
//if(charge.at(j) == "Minus") aleg = new TLegend(0.2,0.69,0.6,0.9,"");
// if(charge.at(j) == "Plus")
//aleg = new TLegend(0.5,0.6,0.7,0.9,"");//new TLegend(0.8,0.69,0.95,0.9,"");
aleg = new TLegend(0.2017937,0.7419355,0.4775785,0.9193548,NULL,"brNDC");
aleg->SetNColumns(2);
aleg->SetFillColor(0);
aleg->SetLineColor(0);
aleg->AddEntry(mc1,"f_{L}","lf");
aleg->AddEntry(mc2,"f_{R}","lf");
aleg->AddEntry(mc3,"f_{0}","lf");
aleg->AddEntry(bkghist,"EWK","lf");
TH1* dummyhist = new TH1F("", "", 1, 0, 1);
dummyhist->SetLineColor(kBlue);
dummyhist->SetLineWidth(3);
aleg->AddEntry(dummyhist, "fit result", "lf");
aleg->AddEntry(hdata, "data","P");
aleg->Draw("same");
//TLatex* preliminary;
//TLatex* text;
//if(false) {
//text = new TLatex(0.35,480,"#splitline{f_{L}-f_{R}=0.240#pm0.036(stat.)#pm0.031(syst.)}{f_{0}=0.183#pm0.087(stat.)#pm0.123(syst.)}");
//preliminary = new TLatex(0.35,550,"CMS preliminary: #it{L} = 36pb^{-1}@ 7 TeV");
//}
//if(true){
//text = new TLatex(0.05,480,"#splitline{f_{L}-f_{R}=0.310#pm0.036(stat.)#pm0.017(syst.)}{f_{0}=0.171#pm0.085(stat.)#pm0.099(syst.)}");
//preliminary = new TLatex(0.05,550,"#splitline{CMS, #sqrt{s} = 7 TeV,}{#it{L_{int}} = 36 pb^{-1}}");}
//preliminary->SetTextSize(0.043);
//preliminary->Draw("same");
//text->SetTextSize(0.043);
// text->Draw("same");
/*
// Draw Minuit contours
if(charge.at(j) == "Plus") { c0->cd(2);
} else { c1->cd(2); }
// RooPlot *rcont=m->contour(f1,f2,1,2);
// rcont->Draw();
RooPlot *rcontour=new RooPlot(f1,f2);
res1->plotOn(rcontour,f1,f2,"ME123VHB");
rcontour->Draw();
if (fitMode) {
rcontour->GetXaxis()->SetTitle("f_{L}-f_{R}");
rcontour->GetYaxis()->SetTitle("f_{0}");
} else {
rcontour->GetXaxis()->SetTitle("f_{L}");
rcontour->GetYaxis()->SetTitle("f_{R}");
}
*/
}
TLatex * text = new TLatex(0.7451931,500.8655,"#splitline{CMS, #sqrt{s} = 7 TeV}{L_{ int} = 36 pb^{-1}}");
text->SetTextSize(0.043);
text->SetLineWidth(2);
text->Draw("same");
const TMatrixDSym& cor = res1->correlationMatrix();
const TMatrixDSym& cov = res1->covarianceMatrix();
//Print correlation, covariance matrix
cout << "correlation matrix" << endl; cor.Print();
cout << "covariance matrix" << endl; cov.Print();
cout << f1 << endl; cout << f2 << endl;
if (!fitMode) {
cout << "f0 = " << f3 << " +/- " << f3.getPropagatedError(*res1) << endl;
}
}
if(makePlots) {
c0->Print(canvas_name_plus+".pdf");
c1->Print(canvas_name_minus+".pdf");
}
if (toyMC) {
// MC STudies
Int_t nevt=istat;
Int_t nEXP=100;
RooMCStudy mgr(*model,*model,x,"","mhrv");
mgr.generateAndFit(nEXP,nevt,kTRUE);
TCanvas *cp0 = new TCanvas("c0","",1200,400);
cp0->Divide(3,1);
cp0->cd(1);
RooPlot *p1=mgr.plotParam(f1); p1->Draw();
if (fitMode) p1->SetTitle(";f_{L}-f_{R};number of toys");
cp0->cd(2);
RooPlot *p2 = mgr.plotError(f1); p2->Draw();
if (fitMode) p2->SetTitle(";#delta (f_{L}-f_{R});number of toys");
cp0->cd(3);
// f1 pull
RooPlot* m1pframe = mgr.plotPull(f1,-3.,3.,30,kTRUE);
m1pframe->Draw();
if (fitMode) {
m1pframe->SetTitle(";f_{L}-f_{R};number of toys");
}
TCanvas *cp02 = new TCanvas("c1","",1200,400);
cp02->Divide(3,1);
cp02->cd(1);
RooPlot *p3=mgr.plotParam(f2); p3->Draw();
if (fitMode) p3->SetTitle(";f_{0};number of toys");
cp02->cd(2);
RooPlot *p4=mgr.plotError(f2); p4->Draw();
if (fitMode) p4->SetTitle(";#delta f_{0}; number of toys");
cp02->cd(3);
// f2 pull
RooPlot* m2pframe = mgr.plotPull(f2,-3.,3.,30,kTRUE);
m2pframe->Draw();
if (fitMode) {
m2pframe->SetTitle(";f_{0};number of toys");
}
TCanvas *cnll = new TCanvas("cnll","");
RooPlot* nllframe = mgr.plotNLL();
// nllframe->Draw();
}
return;
}
void TopWindow::Open(Ctrl *owner)
{
LLOG("TopWindow::Open");
GuiLock __;
if(dokeys && (!GUI_AKD_Conservative() || GetAccessKeysDeep() <= 1))
DistributeAccessKeys();
USRLOG(" OPEN " + Desc(this));
LLOG("OPEN " << Name() << " owner: " << UPP::Name(owner));
IgnoreMouseUp();
bool weplace = owner && center == 1 || center == 2 || !GetRect().IsEmpty();
if(fullscreen)
SetRect(0, 0, Xwidth, Xheight);
else
CenterRect(owner);
LLOG("Open NextRequest " << NextRequest(Xdisplay));
Create(owner, false, false);
XSetWMProperties (Xdisplay, GetWindow(), NULL, NULL, NULL, 0, NULL, NULL, NULL);
xminsize.cx = xmaxsize.cx = Null;
title2.Clear();
if(!weplace) {
LLOG("SyncCaption");
SyncCaption();
}
LLOG("SyncSizeHints");
size_hints->flags = 0;
SyncSizeHints();
Rect r = GetRect();
size_hints->x = r.left;
size_hints->y = r.top;
size_hints->width = r.Width();
size_hints->height = r.Height();
size_hints->win_gravity = StaticGravity;
size_hints->flags |= PPosition|PSize|PWinGravity;
if(owner) {
ASSERT(owner->IsOpen());
LLOG("XSetTransientForHint");
XSetTransientForHint(Xdisplay, GetWindow(), owner->GetWindow());
}
LLOG("XSetWMNormalHints");
XSetWMNormalHints(Xdisplay, GetWindow(), size_hints);
Atom protocols[3];
protocols[0] = XAtom("WM_DELETE_WINDOW");
protocols[1] = XAtom("WM_TAKE_FOCUS");
protocols[2] = XAtom("_NET_WM_PING");
LLOG("XSetWMProtocols");
XSetWMProtocols(Xdisplay, GetWindow(), protocols, 3);
String x = GetExeTitle().ToString();
const char *progname = ~x;
class_hint->res_name = (char *)progname;
class_hint->res_class = (char *)progname;
XSetClassHint(Xdisplay, GetWindow(), class_hint);
LLOG("WndShow(" << visible << ")");
WndShow(visible);
if(visible) {
XEvent e;
LLOG("XWindowEvent");
XWindowEvent(Xdisplay, top->window, VisibilityChangeMask, &e);
ignoretakefocus = true;
SetTimeCallback(500, THISBACK(EndIgnoreTakeFocus));
LLOG("SetWndFocus");
SetWndFocus();
for(int i = 0; i < 50; i++) {
// X11 tries to move our window, so ignore the first set of ConfigureNotify
// and move the window into position after FocusIn - but not if we want WM to
// place the window
if(weplace)
while(XCheckTypedWindowEvent(Xdisplay, top->window, ConfigureNotify, &e)) {
if(e.xconfigure.window != top->window)
ProcessEvent(&e);
}
if(XCheckTypedWindowEvent(Xdisplay, top->window, FocusIn, &e)) {
ProcessEvent(&e);
if(e.xfocus.window == top->window)
break;
}
Sleep(10);
}
}
if(weplace) {
WndSetPos(GetRect());
LLOG("SyncCaption");
SyncCaption();
}
LLOG(">Open NextRequest " << NextRequest(Xdisplay));
LLOG(">OPENED " << Name());
PlaceFocus();
StateH(OPEN);
Vector<int> fe = GetPropertyInts(top->window, XAtom("_NET_FRAME_EXTENTS"));
if(fe.GetCount() >= 4 &&
fe[0] >= 0 && fe[0] <= 16 && fe[1] >= 0 && fe[1] <= 16 && //fluxbox returns wrong numbers - quick&dirty workaround
fe[2] >= 0 && fe[2] <= 64 && fe[3] >= 0 && fe[3] <= 48)
{
GuiLock __;
windowFrameMargin.left = max(windowFrameMargin.left, fe[0]);
windowFrameMargin.right = max(windowFrameMargin.right, fe[1]);
windowFrameMargin.top = max(windowFrameMargin.top, fe[2]);
windowFrameMargin.bottom = max(windowFrameMargin.bottom, fe[3]);
}
if(IsOpen() && top)
top->owner = owner;
long curr_pid = getpid();
static Window wm_client_leader;
ONCELOCK {
wm_client_leader = XCreateSimpleWindow(Xdisplay, Xroot, 0, 0, 1, 1, 0, 0, 0);
XChangeProperty(Xdisplay, wm_client_leader, XAtom("WM_CLIENT_LEADER"),
XA_WINDOW, 32, PropModeReplace, (byte *)&wm_client_leader, 1);
XChangeProperty(Xdisplay, wm_client_leader, XAtom("_NET_WM_PID"), XA_CARDINAL, 32,
PropModeReplace, (byte *) &curr_pid, 1);
}
Window win = GetWindow();
XChangeProperty(Xdisplay, win, XAtom("_NET_WM_PID"), XA_CARDINAL, 32,
PropModeReplace, (byte *) &curr_pid, 1);
XChangeProperty(Xdisplay, win, XAtom("WM_CLIENT_LEADER"),
XA_WINDOW, 32, PropModeReplace, (byte *)&wm_client_leader, 1);
int version = 5;
XChangeProperty(Xdisplay, win, XAtom("XdndAware"), XA_ATOM, 32,
0, (byte *)&version, 1);
SyncState();
FixIcons();
}
void fit2015(
TString FileName ="/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root",
int oniamode = 2, // oniamode-> 3: Z, 2: Upsilon and 1: J/Psi
bool isData = true, // isData = false for MC, true for Data
bool isPbPb = false, // isPbPb = false for pp, true for PbPb
bool doFit = false ,
bool inExcStat = true // if inExcStat is true, then the excited states are fitted
) {
InputOpt opt;
SetOptions(&opt, isData, isPbPb, oniamode,inExcStat);
if (isPbPb) {
FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/PbPbData/OniaTree_262548_262893.root";
} else {
FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root";
}
int nbins = 1; //ceil((opt.dMuon->M->Max - opt.dMuon->M->Min)/binw);
if (oniamode==1){
nbins = 140;
} else if (oniamode==2) {
nbins = 70;
} else if (oniamode==3) {
nbins = 40;
}
RooWorkspace myws;
TH1F* hDataOS = new TH1F("hDataOS","hDataOS", nbins, opt.dMuon.M.Min, opt.dMuon.M.Max);
makeWorkspace2015(myws, FileName, opt, hDataOS);
RooRealVar* mass = (RooRealVar*) myws.var("invariantMass");
RooDataSet* dataOS_fit = (RooDataSet*) myws.data("dataOS");
RooDataSet* dataSS_fit = (RooDataSet*) myws.data("dataSS");
RooAbsPdf* pdf = NULL;
if (oniamode==3) { doFit=false; }
if (doFit) {
int sigModel=0, bkgModel=0;
if (isData) {
if (oniamode==1){
sigModel = inExcStat ? 2 : 3;
bkgModel = 1;
} else {
sigModel = inExcStat ? 1 : 3; // gaussian
bkgModel = 2;
}
} else {
if (oniamode==1){
sigModel = inExcStat ? 2 : 3; // gaussian
bkgModel = 2;
} else {
sigModel = inExcStat ? 2 : 3; // gaussian
bkgModel = 3;
}
}
if (opt.oniaMode==1) buildModelJpsi2015(myws, sigModel, bkgModel,inExcStat);
else if (opt.oniaMode==2) buildModelUpsi2015(myws, sigModel, bkgModel,inExcStat);
pdf =(RooAbsPdf*) myws.pdf("pdf");
RooFitResult* fitObject = pdf->fitTo(*dataOS_fit,Save(),Hesse(kTRUE),Extended(kTRUE)); // Fit
}
RooPlot* frame = mass->frame(Bins(nbins),Range(opt.dMuon.M.Min, opt.dMuon.M.Max));
RooPlot* frame2 = NULL;
dataSS_fit->plotOn(frame, Name("dataSS_FIT"), MarkerColor(kRed), LineColor(kRed), MarkerSize(1.2));
dataOS_fit->plotOn(frame, Name("dataOS_FIT"), MarkerColor(kBlue), LineColor(kBlue), MarkerSize(1.2));
if (doFit) {
pdf->plotOn(frame,Name("thePdf"),Normalization(dataOS_fit->sumEntries(),RooAbsReal::NumEvent));
RooHist *hpull = frame -> pullHist(0,0,true);
hpull -> SetName("hpull");
frame2 = mass->frame(Title("Pull Distribution"),Bins(nbins),Range(opt.dMuon.M.Min,opt.dMuon.M.Max));
frame2 -> addPlotable(hpull,"PX");
}
drawPlot(frame,frame2, pdf, opt, doFit,inExcStat);
TString OutputFileName = "";
if (isPbPb) {
FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/PbPbData/OniaTree_262548_262893.root";
opt.RunNb.Start=262548;
opt.RunNb.End=262893;
if (oniamode==1) {OutputFileName = (TString)("JPSIPbPbDataset.root");}
if (oniamode==2) {OutputFileName = (TString)("YPbPbDataset.root");}
if (oniamode==3) {OutputFileName = (TString)("ZPbPbDataset.root");}
} else {
FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root";
opt.RunNb.Start=262163;
opt.RunNb.End=262328;
if (oniamode==1) {OutputFileName = (TString)("JPSIppDataset.root");}
if (oniamode==2) {OutputFileName = (TString)("YppDataset.root");}
if (oniamode==3) {OutputFileName = (TString)("ZppDataset.root");}
}
TFile* oFile = new TFile(OutputFileName,"RECREATE");
oFile->cd();
hDataOS->Write("hDataOS");
dataOS_fit->Write("dataOS_FIT");
oFile->Write();
oFile->Close();
}
//---------------------------------------------------------
bool CClip_Points::On_Execute(void)
{
int Method, iField;
CSG_Shapes *pPoints, *pPolygons, *pClip;
CSG_Parameter_Shapes_List *pClips;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pPolygons = Parameters("POLYGONS") ->asShapes();
pClips = Parameters("CLIPS") ->asShapesList();
Method = Parameters("METHOD") ->asInt();
iField = Parameters("FIELD") ->asInt();
//-----------------------------------------------------
if( !pPoints->is_Valid() )
{
Message_Add(_TL("Invalid points layer."));
return( false );
}
else if( !pPolygons->is_Valid() )
{
Message_Add(_TL("Invalid polygon layer."));
return( false );
}
//-----------------------------------------------------
if( iField >= pPolygons->Get_Field_Count() )
{
iField = -1;
}
pClips->Del_Items();
if( Method == 0 )
{
pClip = SG_Create_Shapes(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), pPoints->Get_Name(), pPolygons->Get_Name()), pPoints);
if( iField >= 0 )
{
pClip->Add_Field(pPolygons->Get_Field_Name(iField), pPolygons->Get_Field_Type(iField));
}
}
//-----------------------------------------------------
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape_Polygon *pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
if( Method == 1 )
{
CSG_String Name(pPoints->Get_Name());
Name += iField >= 0
? CSG_String::Format(SG_T(" [%s]"), pPolygon->asString(iField))
: CSG_String::Format(SG_T(" [%00d]"), 1 + pClips->Get_Count());
pClip = SG_Create_Shapes(SHAPE_TYPE_Point, Name, pPoints);
if( iField >= 0 )
{
pClip->Add_Field(pPolygons->Get_Field_Name(iField), pPolygons->Get_Field_Type(iField));
}
}
for(int iPoint=0; iPoint<pPoints->Get_Count() && Process_Get_Okay(false); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( pPolygon->Contains(pPoint->Get_Point(0)) )
{
pPoint = pClip->Add_Shape(pPoint, SHAPE_COPY);
if( iField >= 0 )
{
pPoint->Set_Value(pPoints->Get_Field_Count(), pPolygon->asString(iField));
}
}
}
if( Method == 1 )
{
if( pClip->Get_Count() > 0 )
{
pClips->Add_Item(pClip);
}
else
{
delete(pClip);
}
}
}
//-----------------------------------------------------
if( Method == 0 )
{
if( pClip->Get_Count() > 0 )
{
pClips->Add_Item(pClip);
}
else
{
delete(pClip);
}
}
return( pClips->Get_Count() > 0 );
}
SchemaElementDefinition HistoricElementSecurityData::elementDefinition() const
{
::blpapi_DataType_t dtype = (::blpapi_DataType_t)this->datatype();
SchemaElementDefinition result(dtype, Name("HistoricalDataTable"));
return result;
}
/**
* 1. Data sample : pp200 W->e nu with pile-up corresponding to 1 MHz min. bias
* events, 50 K event y2011, 10 K event y2012.
*
* 2. Proof of principal: no pile-up for both PPV and KFV
*
* a. Reconstructed primary track multiplicity versus corresponding MC
* "reconstructable" (i.e. in n STAR acceptance,no. TPC MC hits >= 15) tracks
* multiplicity.
*
* b. Corrected reconstructed primary track multiplicity (i.e. multiplied by
* QA/100.) versus corresponding MC "reconstructable" (i.e. in n STAR
* acceptance,no. TPC MC hits >= 15) tracks multiplicity.
*
* c. Efficiency primary vertex reconstruction versus MC "reconstructable"
* tracks multiplicity.
*
* 3. With pileup. repeat above (a-c) with old ranking scheme for
*
* I. Any reconstructed primary vertex which is matched with MC trigger
* vertex (MC = 1)
*
* II. The best (in sense of ranking) reconstructed primary vertex which is
* matched with MC trigger vertex (MC = 1)
*
* III. The best (in sense of ranking) reconstructed primary vertex which is
* not matched with MC trigger vertex (MC != 1)
*
* 4. With pileup. repeat above (a-c) with new ranking scheme for cases I-III
*/
void MuMcPrVKFV2012(Long64_t nevent, const char *file, const std::string& outFile, bool fillNtuple)
{
#ifdef __TMVA__
boost::replace_last(outFile, ".root", "");
outFile += ".TMVArank.root";
// create a set of variables and declare them to the reader
// - the variable names must corresponds in name and type to
// those given in the weight file(s) that you use
TString separator(":");
TString Vnames(vnames);
TObjArray *array = Vnames.Tokenize(separator);
std::vector<std::string> inputVars;
TIter next(array);
TObjString *objs;
while ((objs = (TObjString *) next())) {
std::cout << objs->GetString() << std::endl;
}
inputVars.push_back("beam");
inputVars.push_back("postx");
inputVars.push_back("prompt");
inputVars.push_back("cross");
inputVars.push_back("tof");
inputVars.push_back("notof");
inputVars.push_back("EEMC");
inputVars.push_back("noEEMC");
inputVars.push_back("chi2");
std::vector<double> *inputVec = new std::vector<double>( inputVars.size() );
IClassifierReader *classReader = new ReadBDT( inputVars );
#endif /* __TMVA__ */
TFile *fOut = TFile::Open(outFile.c_str(), "recreate");
data_t data;
// Book histograms
const int nMcRecMult = 75;
TArrayD xMult(nMcRecMult + 1);
xMult[0] = -0.5;
for (int i = 1; i <= nMcRecMult; i++) {
if (xMult[i - 1] < 50) xMult[i] = xMult[i - 1] + 1; // 1 - 50
else if (xMult[i - 1] < 100) xMult[i] = xMult[i - 1] + 2; // 51 - 75
else if (xMult[i - 1] < 200) xMult[i] = xMult[i - 1] + 10; // 76 - 85
else xMult[i] = xMult[i - 1] + 100; // 86 -100
}
TH1D *McRecMulT = new TH1D("McRecMulT", "Reconstructable multiplicity for trigger Mc Vertex", nMcRecMult, xMult.GetArray());
struct Name_t {
const Char_t *Name;
const Char_t *Title;
};
const Name_t HCases[3] = {
{"Any", "Any vertex matched with MC == 1"},
{"Good", "The best rank vertex with MC == 1"},
{"Bad", "The best rank vertex with MC != 1"}
};
const Name_t Plots[4] = {
{"Mult" , "the reconstructed (uncorrected) track multiplicity versus Reconstructable multiplicity"},
{"MultQA" , "the reconstructed (corrected for QA) track multiplicity versus Reconstructable multiplicity"},
{"McRecMul", "Reconstructable multiplicity"},
{"YvsX" , "Bad versus Good value"}
};
/* h p */
TH1 *hists[3][4];
for (int h = 0; h < 3; h++) {
for (int p = 0; p < 4; p++) {
TString Name(Plots[p].Name); Name += HCases[h].Name;
TString Title(Plots[p].Title); Title += " for "; Title += HCases[h].Title; Title += " vertex";
if (p < 2) hists[h][p] = new TH2D(Name, Title, nMcRecMult, xMult.GetArray(), nMcRecMult, xMult.GetArray());
else if (p == 2) hists[h][p] = new TH1D(Name, Title, nMcRecMult, xMult.GetArray());
}
}
TNtuple *VertexG = new TNtuple("VertexG", "good vertex & global params info", vnames);
TNtuple *VertexB = new TNtuple("VertexB", "bad vertex & global params info", vnames);
// ----------------------------------------------
StMuDstMaker *maker = new StMuDstMaker(0, 0, "", file, "st:MuDst.root", 1e9); // set up maker in read mode
// 0,0 this mean read mode
// dir read all files in this directory
// file bla.lis real all file in this list, if (file!="") dir is ignored
// filter apply filter to filenames, multiple filters are separated by ':'
// 10 maximum number of file to read
maker->SetStatus("*", 0);
std::vector<std::string> activeBranchNames = {
"MuEvent",
"PrimaryVertices",
"StStMuMcVertex",
"StStMuMcTrack"
};
// Set Active braches
for (const auto& branchName : activeBranchNames)
maker->SetStatus(branchName.c_str(), 1);
TChain *tree = maker->chain();
Long64_t nentries = tree->GetEntries();
nevent = TMath::Min(nevent, nentries);
std::cout << nentries << " events in chain " << nevent << " will be read." << std::endl;
tree->SetCacheSize(-1); //by setting the read cache to -1 we set it to the AutoFlush value when writing
tree->SetCacheLearnEntries(1); //one entry is sufficient to learn
tree->SetCacheEntryRange(0, nevent);
for (Long64_t ev = 0; ev < nevent; ev++) {
if (maker->Make()) break;
StMuDst *muDst = maker->muDst(); // get a pointer to the StMuDst class, the class that points to all the data
StMuEvent *muEvent = muDst->event(); // get a pointer to the class holding event-wise information
int referenceMultiplicity = muEvent->refMult(); // get the reference multiplicity
TClonesArray *PrimaryVertices = muDst->primaryVertices();
int nPrimaryVertices = PrimaryVertices->GetEntriesFast();
TClonesArray *MuMcVertices = muDst->mcArray(0);
int nMuMcVertices = MuMcVertices->GetEntriesFast();
TClonesArray *MuMcTracks = muDst->mcArray(1);
int nMuMcTracks = MuMcTracks->GetEntriesFast();
if ( nevent >= 10 && ev % int(nevent*0.1) == 0 )
{
std::cout << "Event #" << ev << "\tRun\t" << muEvent->runId()
<< "\tId: " << muEvent->eventId()
<< " refMult= " << referenceMultiplicity
<< "\tPrimaryVertices " << nPrimaryVertices
<< "\t" << " " << nMuMcVertices
<< "\t" << " " << nMuMcTracks
<< std::endl;
}
// const Double_t field = muEvent->magneticField()*kilogauss;
if (! nMuMcVertices || ! nMuMcTracks || nPrimaryVertices <= 0) {
std::cout << "Ev. " << ev << " has no MC information ==> skip it" << std::endl;
std::cout << "OR no reconstructed verticies found" << std::endl;
continue;
}
// Count number of MC tracks at a vertex with TPC reconstructable tracks
std::multimap<int, int> Mc2McHitTracks;
for (int m = 0; m < nMuMcTracks; m++) {
StMuMcTrack *McTrack = (StMuMcTrack *) MuMcTracks->UncheckedAt(m);
if (McTrack->No_tpc_hit() < 15) continue;
Mc2McHitTracks.insert(std::pair<int, int>(McTrack->IdVx(), McTrack->Id()));
}
// This is the "reconstructable" track multiplicity
int nMcTracksWithHits = Mc2McHitTracks.count(1);
// Let's skip events in which we do not expect to reconstruct any tracks
// (and thus vertex) from the primary vertex
if (nMcTracksWithHits <= 0) continue;
// This is our denominator histogram for efficiencies
McRecMulT->Fill(nMcTracksWithHits);
// ============= Build map between Rc and Mc vertices
std::map<StMuPrimaryVertex *, StMuMcVertex *> reco2McVertices;
TArrayF vertexRanks(nPrimaryVertices);
int mcMatchedVertexIndex = -1; // any vertex with MC==1 and highest reconstrated multiplicity.
int vertexMaxMultiplicity = -1;
// First loop over all verticies in this event. There is at least one
// must be available
for (int recoVertexIndex = 0; recoVertexIndex < nPrimaryVertices; recoVertexIndex++)
{
vertexRanks[recoVertexIndex] = -1e10;
StMuPrimaryVertex *recoVertex = (StMuPrimaryVertex *) PrimaryVertices->UncheckedAt(recoVertexIndex);
if ( !AcceptVX(recoVertex) ) continue;
// Check Mc
if (recoVertex->idTruth() < 0 || recoVertex->idTruth() > nMuMcVertices) {
std::cout << "ERROR: Illegal idTruth " << recoVertex->idTruth() << " The track is ignored" << std::endl;
continue;
}
StMuMcVertex *mcVertex = (StMuMcVertex *) MuMcVertices->UncheckedAt(recoVertex->idTruth() - 1);
if (mcVertex->Id() != recoVertex->idTruth()) {
std::cout << "ERROR: Mismatched idTruth " << recoVertex->idTruth() << " and mcVertex Id " << mcVertex->Id()
<< " The vertex is ignored" << std::endl;
continue;
}
reco2McVertices[recoVertex] = mcVertex;
vertexRanks[recoVertexIndex] = recoVertex->ranking();
if (recoVertex->idTruth() == 1 && recoVertex->noTracks() > vertexMaxMultiplicity)
{
mcMatchedVertexIndex = recoVertexIndex;
vertexMaxMultiplicity = recoVertex->noTracks();
}
FillData(data, recoVertex);
#ifdef __TMVA__
Float_t *dataArray = &data.beam;
for (size_t j = 0; j < inputVec->size(); j++)
(*inputVec)[j] = dataArray[j];
vertexRanks[recoVertexIndex] = classReader->GetMvaValue( *inputVec );
#endif
}
// If we reconstructed a vertex which matches the MC one we fill the
// numerator of the "Any" efficiency histogram
if (mcMatchedVertexIndex != -1) {
StMuPrimaryVertex *recoVertexMatchedMc = (StMuPrimaryVertex*) PrimaryVertices->UncheckedAt(mcMatchedVertexIndex);
double nTracks = recoVertexMatchedMc->noTracks();
double nTracksQA = nTracks * recoVertexMatchedMc->qaTruth() / 100.;
hists[0][0]->Fill(nMcTracksWithHits, nTracks);
hists[0][1]->Fill(nMcTracksWithHits, nTracksQA);
hists[0][2]->Fill(nMcTracksWithHits);
}
// Now deal with the highest rank vertex
int maxRankVertexIndex = TMath::LocMax(nPrimaryVertices, vertexRanks.GetArray());
StMuPrimaryVertex *recoVertexMaxRank = (StMuPrimaryVertex*) PrimaryVertices->UncheckedAt(maxRankVertexIndex);
StMuMcVertex *mcVertex = reco2McVertices[recoVertexMaxRank];
double nTracks = recoVertexMaxRank->noTracks();
double nTracksQA = nTracks * recoVertexMaxRank->qaTruth() / 100.;
// Fill numerator for "good" and "bad" efficiencies
int h = ( mcVertex && mcVertex->Id() == 1) ? 1 : 2;
hists[h][0]->Fill(nMcTracksWithHits, nTracks);
hists[h][1]->Fill(nMcTracksWithHits, nTracksQA);
hists[h][2]->Fill(nMcTracksWithHits);
// Proceed with filling ntuple only if requested by the user
if ( !fillNtuple ) continue;
// Second loop over all verticies in this event
for (int recoVertexIndex = 0; recoVertexIndex < nPrimaryVertices; recoVertexIndex++)
{
StMuPrimaryVertex *recoVertex = (StMuPrimaryVertex *) PrimaryVertices->UncheckedAt(recoVertexIndex);
if ( !AcceptVX(recoVertex) ) continue;
StMuMcVertex *mcVertex = reco2McVertices[recoVertex];
if ( !mcVertex ) {
std::cout << "No Match from RC to MC" << std::endl;
continue;
}
if (vtxeval::gDebugFlag) {
std::cout << Form("Vx[%3i]", recoVertexIndex) << *recoVertex << " " << *mcVertex;
int nMcTracksWithHitsatL = Mc2McHitTracks.count(recoVertex->idTruth());
std::cout << Form("Number of McTkHit %4i rank %8.3f", nMcTracksWithHitsatL, vertexRanks[recoVertexIndex]);
}
int IdPar = mcVertex->IdParTrk();
if (IdPar > 0 && IdPar <= nMuMcTracks) {
StMuMcTrack *mcTrack = (StMuMcTrack *) MuMcTracks->UncheckedAt(IdPar - 1);
if (mcTrack && vtxeval::gDebugFlag) std::cout << " " << mcTrack->GeName();
}
FillData(data, recoVertex);
double nTracks = recoVertex->noTracks();
if (mcVertex->Id() == 1 && nTracks == vertexMaxMultiplicity) {// good
VertexG->Fill(&data.beam);
}
else { // bad
VertexB->Fill(&data.beam);
}
}
if ( !gROOT->IsBatch() ) {
if (vtxeval::ask_user()) return;
}
else { vtxeval::gDebugFlag = false; }
}
fOut->Write();
}
//DEBUG.
void GaugeGroup::Display() const
{
Name().Display();
}//Close Display.
int
main(int argc, char* argv[])
{
Options options;
options.freshnessPeriod = getMinimumFreshnessPeriod();
options.shouldLimitSatisfied = false;
options.nMaxPings = 0;
options.shouldPrintTimestamp = false;
options.payloadSize = 0;
namespace po = boost::program_options;
po::options_description visibleOptDesc("Allowed options");
visibleOptDesc.add_options()
("help,h", "print this message and exit")
("version,V", "display version and exit")
("freshness,x", po::value<int>(),
("set freshness period in milliseconds (minimum " +
std::to_string(getMinimumFreshnessPeriod().count()) + " ms)").c_str())
("satisfy,p", po::value<int>(&options.nMaxPings), "set maximum number of pings to be satisfied")
("timestamp,t", "log timestamp with responses")
("size,s", po::value<int>(&options.payloadSize), "specify size of response payload")
;
po::options_description hiddenOptDesc("Hidden options");
hiddenOptDesc.add_options()
("prefix", po::value<std::string>(), "prefix to register")
;
po::options_description optDesc("Allowed options");
optDesc.add(visibleOptDesc).add(hiddenOptDesc);
try {
po::positional_options_description optPos;
optPos.add("prefix", -1);
po::variables_map optVm;
po::store(po::command_line_parser(argc, argv).options(optDesc).positional(optPos).run(), optVm);
po::notify(optVm);
if (optVm.count("help") > 0) {
usage(visibleOptDesc);
}
if (optVm.count("version") > 0) {
std::cout << "ndnpingserver " << tools::VERSION << std::endl;
exit(0);
}
if (optVm.count("prefix") > 0) {
options.prefix = Name(optVm["prefix"].as<std::string>());
}
else {
std::cerr << "ERROR: No prefix specified" << std::endl;
usage(visibleOptDesc);
}
if (optVm.count("freshness") > 0) {
options.freshnessPeriod = time::milliseconds(optVm["freshness"].as<int>());
if (options.freshnessPeriod.count() < getMinimumFreshnessPeriod().count()) {
std::cerr << "ERROR: Specified FreshnessPeriod is less than the minimum "
<< getMinimumFreshnessPeriod() << std::endl;
usage(visibleOptDesc);
}
}
if (optVm.count("satisfy") > 0) {
options.shouldLimitSatisfied = true;
if (options.nMaxPings < 1) {
std::cerr << "ERROR: Maximum number of pings to satisfy must be greater than 0" << std::endl;
usage(visibleOptDesc);
}
}
if (optVm.count("timestamp") > 0) {
options.shouldPrintTimestamp = true;
}
if (optVm.count("size") > 0) {
if (options.payloadSize < 0) {
std::cerr << "ERROR: Payload size must be greater than or equal to 0" << std::endl;
usage(visibleOptDesc);
}
}
}
catch (const po::error& e) {
std::cerr << "ERROR: " << e.what() << std::endl;
usage(visibleOptDesc);
}
std::cout << "PING SERVER " << options.prefix << std::endl;
return Runner(options).run();
}
void
VideoProducer::NodeRegistered()
{
if (fInitStatus != B_OK) {
ReportError(B_NODE_IN_DISTRESS);
return;
}
/* Set up the parameter web */
//TODO: remove and put sensible stuff there
BParameterWeb *web = new BParameterWeb();
BParameterGroup *main = web->MakeGroup(Name());
BParameterGroup *g;
/*
g = main->MakeGroup("Color");
BDiscreteParameter *state = g->MakeDiscreteParameter(
P_COLOR, B_MEDIA_RAW_VIDEO, "Color", "Color");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x00ff0000), "Red");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x0000ff00), "Green");
state->AddItem(B_HOST_TO_LENDIAN_INT32(0x000000ff), "Blue");
*/
BParameter *p;
g = main->MakeGroup("Info");
p = g->MakeTextParameter(
P_INFO, B_MEDIA_RAW_VIDEO, "", "Info", 256);
int32 id = P_LAST;
if (fCamDevice) {
#ifndef SINGLE_PARAMETER_GROUP
main = web->MakeGroup("Device");
#endif
fCamDevice->AddParameters(main, id);
if (fCamDevice->Sensor()) {
#ifndef SINGLE_PARAMETER_GROUP
main = web->MakeGroup("Sensor");
#endif
fCamDevice->Sensor()->AddParameters(main, id);
}
}
fColor = B_HOST_TO_LENDIAN_INT32(0x00ff0000);
fLastColorChange = system_time();
/* After this call, the BControllable owns the BParameterWeb object and
* will delete it for you */
SetParameterWeb(web);
fOutput.node = Node();
fOutput.source.port = ControlPort();
fOutput.source.id = 0;
fOutput.destination = media_destination::null;
strcpy(fOutput.name, Name());
/* Tailor these for the output of your device */
fOutput.format.type = B_MEDIA_RAW_VIDEO;
fOutput.format.u.raw_video = media_raw_video_format::wildcard;
fOutput.format.u.raw_video.interlace = 1;
fOutput.format.u.raw_video.display.format = B_RGB32;
fOutput.format.u.raw_video.field_rate = FIELD_RATE; // XXX: mmu
/* Start the BMediaEventLooper control loop running */
Run();
}
Size BarPane::Repos(bool _horz, int maxsize)
{
horz = _horz;
maxsize -= 2 * (horz ? hmargin : vmargin);
int bmargin = horz ? vmargin : hmargin;
breakpos.Clear();
Size asz(0, 0);
VeHo(asz) = bmargin;
Array<Item>::Iterator q = item.Begin();
while(q < item.End()) {
Size psz(0, 0);
Array<Item>::Iterator f = q;
while(q < item.End()) {
if(q->ctrl == NULL && IsNull(q->gapsize)) {
q++;
break;
}
int gapsize = q->gapsize;
if(gapsize == INT_MAX && q->ctrl == NULL) {
if(maxsize == INT_MAX) {
q++;
break;
}
gapsize = 0;
Array<Item>::Iterator w = q + 1;
while(w < item.End()) {
if(!w->ctrl) break;
Size sz = w->ctrl->GetMinSize();
if(HoVe(psz) + gapsize + HoVe(sz) > maxsize) break;
gapsize += HoVe(sz);
w++;
}
gapsize = maxsize - gapsize - HoVe(psz);
}
Size sz = q->ctrl ? q->ctrl->GetMinSize()
: Size(horz ? gapsize : 0, horz ? 0 : gapsize);
if(HoVe(sz) == INT_MAX)
HoVe(sz) = maxsize - HoVe(psz);
if(HoVe(psz) + HoVe(sz) > maxsize && HoVe(psz)) {
while(q < item.End() && q->ctrl == NULL && !IsNull(q->gapsize))
q++;
break;
}
VeHo(psz) = max(VeHo(psz), VeHo(sz));
if(q->ctrl) {
if(horz)
q->ctrl->LeftPos(psz.cx + hmargin, sz.cx);
else
q->ctrl->TopPos(psz.cy + vmargin, sz.cy);
}
HoVe(psz) += HoVe(sz);
q++;
}
int& bp = VeHo(asz);
if(bp > bmargin) {
breakpos.Add(bp + bmargin);
bp += 2 + 2 * bmargin;
}
while(f != q) {
if(f->ctrl) {
if(horz)
f->ctrl->TopPos(bp, psz.cy);
else
f->ctrl->LeftPos(bp, psz.cx);
}
f++;
}
bp += VeHo(psz);
HoVe(asz) = max(HoVe(asz), HoVe(psz));
}
VeHo(asz) += bmargin;
HoVe(asz) += horz ? 2 * hmargin : 2 * vmargin;
LLOG("Repos " << Name() << " " << asz);
return asz;
}
int GButton::Value()
{
return atoi(Name());
}
void visitBlock(Block *curr) {
if (curr->name.is() && branchesSeen.count(curr->name) == 0) {
curr->name = Name();
}
}
bool
RoomContainer::LoadArea(const res_ref& areaName, const char* longName,
const char* entranceName)
{
// Save the entrance name, it will be unloaded in UnloadArea
std::string savedEntranceName = entranceName ? entranceName : "";
_Unload();
SetName(areaName.CString());
GraphicsEngine::Get()->SetWindowCaption(Name());
std::cout << "Room::Load(" << areaName.CString() << ")" << std::endl;
fArea = gResManager->GetARA(Name());
if (fArea == NULL)
return false;
_InitWed(fArea->WedName().CString());
fBcs = gResManager->GetBCS(fArea->ScriptName());
Script* roomScript = NULL;
if (fBcs != NULL)
roomScript = fBcs->GetScript();
SetScript(roomScript);
GUI* gui = GUI::Get();
gui->Clear();
if (!gui->Load("GUIW")) {
// TODO: Delete other loaded stuff
gResManager->ReleaseResource(fArea);
fArea = NULL;
gResManager->ReleaseResource(fBcs);
fBcs = NULL;
SetScript(NULL);
delete roomScript;
return false;
}
gui->ShowWindow(uint16(-1));
Window* window = gui->GetWindow(uint16(-1));
gui->ShowWindow(0);
gui->ShowWindow(1);
/*gui->ShowWindow(2);
gui->ShowWindow(4);
if (Window* tmp = gui->GetWindow(4)) {
TextArea *textArea = dynamic_cast<TextArea*>(tmp->GetControlByID(3));
if (textArea != NULL)
textArea->SetText("This is a test");
}*/
//gui->GetWindow(15);
if (window != NULL) {
Control* control = window->GetControlByID(uint32(-1));
if (control != NULL)
control->AssociateRoom(this);
Label* label = dynamic_cast<Label*>(window->GetControlByID(268435459));
if (label != NULL)
label->SetText(longName);
}
_InitVariables();
_InitAnimations();
_InitRegions();
_LoadActors();
_InitDoors();
_InitContainers();
_InitBlitMask();
Core::Get()->EnteredArea(this, roomScript);
delete roomScript;
IE::point point = { 0, 0 };
if (!savedEntranceName.empty()) {
for (uint32 e = 0; e < fArea->CountEntrances(); e++) {
IE::entrance entrance = fArea->EntranceAt(e);
//std::cout << "current: " << entrance.name;
//std::cout << ", looking for " << entranceName << std::endl;
if (savedEntranceName == entrance.name) {
point.x = entrance.x;
point.y = entrance.y;
CenterArea(point);
break;
}
}
} else {
try {
IE::entrance entrance = fArea->EntranceAt(0);
point.x = entrance.x;
point.y = entrance.y;
} catch (std::out_of_range& ex) {
}
CenterArea(point);
}
Actor* player = Game::Get()->Party()->ActorAt(0);
if (player != NULL) {
player->SetPosition(point);
if (!player->IsSelected())
player->Select(true);
fSelectedActor = player;
}
//GUI::Get()->DrawTooltip("THIS IS A TEXT", 50, 40, 3000);
return true;
}
void GRPCHANGECommand::Execute()
{
SetFunction set = Check();
auto gids = acl::Group::GetGIDs(args[1]);
if (gids.empty())
{
control.Format(ftp::ActionNotOkay, "No group's exist matching that criteria.");
throw cmd::NoPostScriptError();
}
for (auto gid : gids)
{
auto group = acl::Group::Load(gid);
if (group)
{
set(*group);
logs::Siteop(client.User().Name(), "changed '%1%' for '%2%' to '%3%'", args[2], group->Name(), display);
}
}
assert(!display.empty());
control.Format(ftp::CommandOkay, "Setting %1% changed for %2%: %3%", args[2],
gids.size() == 1 ? acl::GIDToName(gids[0]) :
util::Format()("%i groups", gids.size()), display);
}
bool Ctrl::SetFocus()
{
GuiLock __;
LLOG("Ctrl::SetFocus(" << Name() << ")");
return SetFocus0(true);
}
void Axis::StepOverscrollAnimation(double aStepDurationMilliseconds) {
// Apply spring physics to the overscroll as time goes on.
// Note: this method of sampling isn't perfectly smooth, as it assumes
// a constant velocity over 'aDelta', instead of an accelerating velocity.
// (The way we applying friction to flings has the same issue.)
// Hooke's law with damping:
// F = -kx - bv
// where
// k is a constant related to the stiffness of the spring
// The larger the constant, the stiffer the spring.
// x is the displacement of the end of the spring from its equilibrium
// In our scenario, it's the amount of overscroll on the axis.
// b is a constant that provides damping (friction)
// v is the velocity of the point at the end of the spring
// See http://gafferongames.com/game-physics/spring-physics/
const float kSpringStiffness = gfxPrefs::APZOverscrollSpringStiffness();
const float kSpringFriction = gfxPrefs::APZOverscrollSpringFriction();
// Apply spring force.
float springForce = -1 * kSpringStiffness * mOverscroll;
// Assume unit mass, so force = acceleration.
float oldVelocity = mVelocity;
mVelocity += springForce * aStepDurationMilliseconds;
// Apply dampening.
mVelocity *= pow(double(1 - kSpringFriction), aStepDurationMilliseconds);
AXIS_LOG("%p|%s sampled overscroll animation, leaving velocity at %f\n",
mAsyncPanZoomController, Name(), mVelocity);
// At the peak of each oscillation, record new offset and scaling factors for
// overscroll, to ensure that GetOverscroll always returns a value of the
// same sign, and that this value is correctly adjusted as the spring is
// dampened.
bool velocitySignChange = (oldVelocity * mVelocity) < 0;
if (mFirstOverscrollAnimationSample == 0.0f) {
mFirstOverscrollAnimationSample = mOverscroll;
// It's possible to start sampling overscroll with velocity == 0, or
// velocity in the opposite direction of overscroll, so make sure we
// correctly record the peak in this case.
if (mOverscroll != 0 && ((mOverscroll > 0 ? oldVelocity : -oldVelocity) <= 0.0f)) {
velocitySignChange = true;
}
}
if (velocitySignChange) {
bool oddOscillation = (mOverscroll.value * mFirstOverscrollAnimationSample.value) < 0.0f;
mLastOverscrollPeak = oddOscillation ? mOverscroll : -mOverscroll;
mOverscrollScale = 2.0f;
}
// Adjust the amount of overscroll based on the velocity.
// Note that we allow for oscillations.
mOverscroll += (mVelocity * aStepDurationMilliseconds);
// Our mechanism for translating a set of mOverscroll values that oscillate
// around zero to a set of GetOverscroll() values that have the same sign
// (so content is always stretched, never compressed) assumes that
// mOverscroll does not exceed mLastOverscrollPeak in magnitude. If our
// calculations were exact, this would be the case, as a dampened spring
// should never attain a displacement greater in magnitude than a previous
// peak. In our approximation calculations, however, this may not hold
// exactly. To ensure the assumption is not violated, we clamp the magnitude
// of mOverscroll.
if (mLastOverscrollPeak != 0 && fabs(mOverscroll) > fabs(mLastOverscrollPeak)) {
mOverscroll = (mOverscroll >= 0) ? fabs(mLastOverscrollPeak) : -fabs(mLastOverscrollPeak);
}
}
/** Rename something.
* \verbatim
* This implements @name.
* \endverbatim
* \param player the enactor.
* \param name current name of object to rename.
* \param newname_ new name for object.
*/
void
do_name(dbref player, const char *name, char *newname_)
{
dbref thing;
char oldname[BUFFER_LEN];
char *newname = NULL;
char *alias = NULL;
PE_REGS *pe_regs;
if ((thing = match_controlled(player, name)) == NOTHING)
return;
/* check for bad name */
if ((*newname_ == '\0') || strchr(newname_, '[')) {
notify(player, T("Give it what new name?"));
return;
}
switch (Typeof(thing)) {
case TYPE_PLAYER:
switch (
ok_object_name(newname_, player, thing, TYPE_PLAYER, &newname, &alias)) {
case OPAE_INVALID:
case OPAE_NULL:
notify(player, T("You can't give a player that name or alias."));
if (newname)
mush_free(newname, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return;
case OPAE_TOOMANY:
notify(player, T("Too many aliases."));
mush_free(newname, "name.newname");
return;
case OPAE_SUCCESS:
break;
}
break;
case TYPE_EXIT:
if (ok_object_name(newname_, player, thing, TYPE_EXIT, &newname, &alias) !=
OPAE_SUCCESS) {
notify(player, T("That is not a reasonable name."));
if (newname)
mush_free(newname, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return;
}
break;
case TYPE_THING:
case TYPE_ROOM:
if (!ok_name(newname_, 0)) {
notify(player, T("That is not a reasonable name."));
return;
}
newname = mush_strdup(trim_space_sep(newname_, ' '), "name.newname");
break;
default:
/* Should never occur */
notify(player, T("I don't see that here."));
return;
}
/* Actually change it */
mush_strncpy(oldname, Name(thing), BUFFER_LEN);
if (IsPlayer(thing)) {
do_log(LT_CONN, 0, 0, "Name change by %s(#%d) to %s", Name(thing), thing,
newname);
if (Suspect(thing) && strcmp(Name(thing), newname) != 0)
flag_broadcast("WIZARD", 0,
T("Broadcast: Suspect %s changed name to %s."),
Name(thing), newname);
reset_player_list(thing, newname, alias);
}
set_name(thing, newname);
if (alias) {
if (*alias == ALIAS_DELIMITER) {
do_set_atr(thing, "ALIAS", NULL, player, 0);
} else {
/* New alias to set */
do_set_atr(thing, "ALIAS", alias, player, 0);
}
mush_free(alias, "name.newname");
}
queue_event(player, "OBJECT`RENAME", "%s,%s,%s", unparse_objid(thing),
newname, oldname);
if (!AreQuiet(player, thing))
notify(player, T("Name set."));
pe_regs = pe_regs_create(PE_REGS_ARG, "do_name");
pe_regs_setenv_nocopy(pe_regs, 0, oldname);
pe_regs_setenv_nocopy(pe_regs, 1, newname);
real_did_it(player, thing, NULL, NULL, "ONAME", NULL, "ANAME", NOTHING,
pe_regs, NA_INTER_PRESENCE, AN_SYS);
pe_regs_free(pe_regs);
mush_free(newname, "name.newname");
}
void Axis::SetVelocity(float aVelocity) {
AXIS_LOG("%p|%s direct-setting velocity to %f\n",
mAsyncPanZoomController, Name(), aVelocity);
mVelocity = aVelocity;
}
/** Check to see if someone can connect to a player.
* \param d DESC the connect attempt is being made for
* \param name name of player to connect to.
* \param password password of player to connect to.
* \param host host from which connection is being attempted.
* \param ip ip address from which connection is being attempted.
* \param errbuf buffer to return connection errors.
* \return dbref of connected player object or NOTHING for failure
* (with reason for failure returned in errbuf).
*/
dbref
connect_player(DESC *d, const char *name, const char *password,
const char *host, const char *ip, char *errbuf)
{
dbref player;
int count;
/* Default error */
strcpy(errbuf,
T("Either that player does not exist, or has a different password."));
if (!name || !*name)
return NOTHING;
/* validate name */
if ((player = lookup_player(name)) == NOTHING) {
/* Invalid player names are failures, too. */
count = mark_failed(ip);
strcpy(errbuf, T("There is no player with that name."));
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d,%s",
d->descriptor, ip, count, "invalid player", -1, name);
return NOTHING;
}
/* See if player is allowed to connect like this */
if (Going(player) || Going_Twice(player)) {
do_log(LT_CONN, 0, 0,
"Connection to GOING player %s not allowed from %s (%s)",
Name(player), host, ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d", d->descriptor,
ip, count_failed(ip), "player is going", player);
strcpy(errbuf, T("You cannot connect to that player at this time."));
return NOTHING;
}
/* Check sitelock patterns */
if (Guest(player) &&
(!Site_Can_Guest(host, player) || !Site_Can_Guest(ip, player))) {
if (!Deny_Silent_Site(host, AMBIGUOUS) &&
!Deny_Silent_Site(ip, AMBIGUOUS)) {
do_log(LT_CONN, 0, 0, "Connection to %s (GUEST) not allowed from %s (%s)",
name, host, ip);
strcpy(errbuf, T("Guest connections not allowed."));
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "failed sitelock", player);
}
return NOTHING;
} else if (!Guest(player) && (!Site_Can_Connect(host, player) ||
!Site_Can_Connect(ip, player))) {
if (!Deny_Silent_Site(host, player) && !Deny_Silent_Site(ip, player)) {
do_log(LT_CONN, 0, 0,
"Connection to %s (Non-GUEST) not allowed from %s (%s)", name,
host, ip);
strcpy(errbuf, T("Player connections not allowed."));
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "failed sitelock", player);
}
return NOTHING;
}
/* validate password */
if (!Guest(player))
if (!password_check(player, password)) {
/* Increment count of login failures */
ModTime(player)++;
check_lastfailed(player, host);
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "invalid password", player);
strcpy(errbuf, T("That is not the correct password."));
return NOTHING;
}
/* If it's a Guest player, and already connected, search the
* db for another Guest player to connect them to. */
if (Guest(player)) {
/* Enforce guest limit */
player = guest_to_connect(player);
if (!GoodObject(player)) {
do_log(LT_CONN, 0, 0, "Can't connect to a guest (too many connected)");
strcpy(errbuf, T("Too many guests are connected now."));
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count_failed(ip), "too many guests",
player);
return NOTHING;
}
}
if (Suspect_Site(host, player) || Suspect_Site(ip, player)) {
do_log(LT_CONN, 0, 0,
"Connection from Suspect site. Setting %s(#%d) suspect.",
Name(player), player);
set_flag_internal(player, "SUSPECT");
}
return player;
}
STKUNIT_UNIT_TEST(norm, string_function)
{
EXCEPTWATCH;
//stk::diag::WriterThrowSafe _write_throw_safe(dw());
//dw().setPrintMask(dw_option_mask.parse(vm["dw"].as<std::string>().c_str()));
//dw().setPrintMask(LOG_NORM+LOG_ALWAYS);
dw().m(LOG_NORM) << "TEST.norm.string_function " << stk::diag::dendl;
LocalFixture fix(4);
mesh::fem::FEMMetaData& metaData = fix.metaData;
mesh::BulkData& bulkData = fix.bulkData;
PerceptMesh& eMesh = fix.eMesh;
//mesh::FieldBase* coords_field = fix.coords_field;
StringFunction sfx = fix.sfx;
ConstantFunction sfx_res = fix.sfx_res;
/// Create the operator that will do the work
/// get the l2 norm
Norm<2> l2Norm(bulkData, &metaData.universal_part(), TURBO_NONE);
l2Norm(sfx, sfx_res);
double sfx_expect = std::sqrt(0.25/3.);
Teuchos::ScalarTraits<double>::seedrandom(12345);
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res.getValue());
int niter=1;
for (int iter=0; iter < niter; iter++)
{
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, eval(Math::random01(), Math::random01(), Math::random01(), 0.0, sfx_res));
}
/// the function to be integrated: (Integral[ abs(x), dxdydz]) =?= (2 * |x|^2/2 @ [0, 0.5]) ==> .25)
Norm<1> l1Norm(bulkData, &metaData.universal_part(), TURBO_NONE);
l1Norm(sfx, sfx_res);
sfx_expect = 0.25;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
/// the function to be integrated: (Max[ x^2+y^3+z^4, dxdydz]) =?= (@ [-0.5, 0.5]^3 ) ==> .5^2+.5^3+.5^4)
StringFunction sfmax("x^2 + y^3 + z^4", Name("sfmax"), Dimensions(3), Dimensions(1) );
Norm<-1> lInfNorm(bulkData, &metaData.universal_part(), TURBO_NONE);
lInfNorm.setCubDegree(10);
lInfNorm(sfmax, sfx_res);
double sf1=eval(.5,.5,.5,0.0, sfmax);
sfx_expect = 0.5*0.5 + 0.5*0.5*0.5 + 0.5*0.5*0.5*0.5;
std::cout << "sfmax= " << sf1 << " sfx_expect= " << sfx_expect << " sfx_res= " << sfx_res.getValue() << std::endl;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
/// indirection
StringFunction sfmax_1("sfmax", Name("sfmax_1"), Dimensions(3), Dimensions(1) );
double sf1_1=eval(.5,.5,.5,0.0, sfmax_1);
std::cout << "sfmax_1= " << sf1_1 << " sfx_expect= " << sfx_expect << std::endl;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sf1_1);
/// the function to be integrated: sqrt(Integral[(x*y*z)^2, dxdydz]) =?= (see unitTest1.py)
StringFunction sfxyz("x*y*z", Name("sfxyz"), Dimensions(3), Dimensions(1) );
l2Norm(sfxyz, sfx_res);
sfx_expect = 0.0240562612162344;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
/// indirection
std::cout << "tmp srk start..." << std::endl;
StringFunction sfxyz_2("sfxyz", Name("sfxyz_2"), Dimensions(3), Dimensions(1) );
l2Norm(sfxyz_2, sfx_res);
sfx_expect = 0.0240562612162344;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
/// the function to be integrated (but over a rotated domain): sqrt(Integral[(x*y*z)^2, dxdydz]) =?= (see unitTest2.py)
/// now rotate the mesh
Math::Matrix rmz = Math::rotationMatrix(2, 30);
Math::Matrix rm = rmz;
eMesh.transform_mesh(rm);
l2Norm(sfxyz, sfx_res);
sfx_expect = 0.0178406008037016;
// NOTE: we need extra quadrature accuracy to reproduce this result (cubDegree==4 in IntegratedOp almost gets it right)
// for now, we are satisfied with 2-3 digits
//STKUNIT_EXPECT_DOUBLE_EQ(sfx_res.getValue(), sfx_expect);
if (std::fabs(sfx_res.getValue()-sfx_expect) > 0.01*sfx_expect)
{
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
STKUNIT_EXPECT_TRUE(false);
}
}
int
_match(MENU *m, char c, ITEM **current)
{
int i, j;
int found;
/*
* Indicates search has cycled past the current item. If the current
* item is matched after cycled is true then NO_MATCH results.
*/
int cycled;
/* If a backspace is encountered then search backward from the */
/* current item. Otherwise, search forward from the current item. */
i = Index(*current);
if (c && c != '\b') { /* c could be null */
if (Pindex(m)+1 > MaxName(m)) {
return (E_NO_MATCH);
}
IthPattern(m, Pindex(m)) = c;
IthPattern(m, ++Pindex(m)) = '\0';
if (--i < 0) {
i = Nitems(m)-1;
}
}
j = i;
found = FALSE;
cycled = FALSE;
do {
if (c == '\b') {
if (--i < 0) {
i = Nitems(m)-1;
}
} else {
if (++i >= Nitems(m)) {
i = 0;
}
}
if (substr(m, Pattern(m), Name(IthItem(m, i)))) {
found = TRUE;
break;
}
cycled = TRUE;
} while (i != j);
if (found) {
if (i == Index(*current) && cycled) {
return (E_NO_MATCH);
}
*current = IthItem(m, i);
} else {
if (c && c != '\b') {
Pindex(m) -= 1;
IthPattern(m, Pindex(m)) = '\0';
}
return (E_NO_MATCH);
}
return (E_OK);
}
/// This test uses a back door to the function that passes in the element to avoid the lookup of the element when the
/// StringFunction contains references to FieldFunctions
void TEST_norm_string_function_turbo_verify_correctness(TurboOption turboOpt)
{
EXCEPTWATCH;
//stk::diag::WriterThrowSafe _write_throw_safe(dw());
//dw().setPrintMask(dw_option_mask.parse(vm["dw"].as<std::string>().c_str()));
//dw().setPrintMask(LOG_NORM+LOG_ALWAYS);
dw().m(LOG_NORM) << "TEST.norm.string_function " << stk::diag::dendl;
LocalFixture fix(4);
mesh::fem::FEMMetaData& metaData = fix.metaData;
mesh::BulkData& bulkData = fix.bulkData;
PerceptMesh& eMesh = fix.eMesh;
mesh::FieldBase* coords_field = fix.coords_field;
StringFunction sfx = fix.sfx;
ConstantFunction sfx_res = fix.sfx_res;
/// create a field function from the existing coordinates field
FieldFunction ff_coords("ff_coords", coords_field, &bulkData,
Dimensions(3), Dimensions(3), FieldFunction::SIMPLE_SEARCH );
/// the function to be integrated: sqrt(Integral[x^2, dxdydz]) =?= sqrt(x^3/3 @ [-0.5, 0.5]) ==> sqrt(0.25/3)
//StringFunction sfx("x", Name("sfx"), Dimensions(3), Dimensions(1) );
ff_coords.add_alias("mc");
//StringFunction sfcm("sqrt(mc[0]*mc[0]+mc[1]*mc[1]+mc[2]*mc[2])", Name("sfcm"), Dimensions(3), Dimensions(1));
StringFunction sfx_mc("mc[0]", Name("sfx_mc"), Dimensions(3), Dimensions(1) );
StringFunction sfx_mc1("mc[0]", Name("sfx_mc1"), Dimensions(3), Dimensions(1) );
if (1)
{
double x = -0.49+0.98*Math::random01();
double y = -0.49+0.98*Math::random01();
double z = -0.49+0.98*Math::random01();
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(eval(x,y,z,0.0, sfx), eval(x,y,z,0.0, sfx_mc));
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(eval(.034,0,0,0.0, sfx), eval(.034,0,0,0.0, sfx_mc));
}
/// A place to hold the result.
/// This is a "writable" function (we may want to make this explicit - StringFunctions are not writable; FieldFunctions are
/// since we interpolate values to them from other functions).
ConstantFunction sfx_res_turbo(0.0, "sfx_res_turbo");
ConstantFunction sfx_res_slow(0.0, "sfx_res_slow");
ConstantFunction sfx_res_fast(0.0, "sfx_res_fast");
ConstantFunction sfx_res_bucket(0.0, "sfx_res_bucket");
// STATE m_element....
/// Create the operator that will do the work
/// get the l2 norm
Norm<2> l2Norm(bulkData, &metaData.universal_part(), TURBO_NONE);
l2Norm(sfx, sfx_res);
Norm<2> l2Norm_turbo(bulkData, &metaData.universal_part(), turboOpt);
Norm<2> l2Norm_turbo_bucket(bulkData, &metaData.universal_part(), TURBO_BUCKET);
Norm<2> l2Norm_turbo1(bulkData, &metaData.universal_part(), turboOpt);
l2Norm_turbo(sfx, sfx_res_turbo);
l2Norm_turbo1(sfx_mc1, sfx_res_fast);
l2Norm_turbo_bucket(sfx_mc1, sfx_res_bucket);
l2Norm(sfx_mc, sfx_res_slow);
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(eval(.023,0,0,0.0, sfx), eval(.023,0,0,0.0, sfx_mc));
double sfx_expect = std::sqrt(0.25/3.);
std::cout << "sfx_expect= " << sfx_expect << std::endl;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_bucket.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_turbo.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_slow.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_fast.getValue()); //!
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res.getValue());
//Util::pause(true, "13a");
//STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_res_turbo.getValue(), sfx_expect);
STKUNIT_EXPECT_DOUBLE_EQ_APPROX_TOL(sfx_expect, sfx_res_turbo.getValue(), 1.e-8);
//Util::pause(true, "13");
/// the function to be integrated: (Integral[ abs(x), dxdydz]) =?= (2 * |x|^2/2 @ [0, 0.5]) ==> .25)
Norm<1> l1Norm(bulkData, &metaData.universal_part(), TURBO_NONE);
l1Norm(sfx, sfx_res);
Norm<1> l1Norm_turbo(bulkData, &metaData.universal_part(), TURBO_NONE);
l1Norm_turbo(sfx, sfx_res_turbo);
l1Norm_turbo(sfx_mc, sfx_res_fast);
l1Norm(sfx_mc, sfx_res_slow);
sfx_expect = 0.25;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res_turbo.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_slow.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_expect, sfx_res_fast.getValue());
//// ----- here
/// the function to be integrated: sqrt(Integral[(x*y*z)^2, dxdydz]) =?= (see unitTest1.py)
StringFunction sfxyz("x*y*z", Name("sfxyz"), Dimensions(3), Dimensions(1) );
l2Norm(sfxyz, sfx_res);
l2Norm_turbo(sfxyz, sfx_res_turbo);
sfx_expect = 0.0240562612162344;
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res_turbo.getValue());
/// the function to be integrated (but over a rotated domain): sqrt(Integral[(x*y*z)^2, dxdydz]) =?= (see unitTest2.py)
/// now rotate the mesh
Math::Matrix rmz = Math::rotationMatrix(2, 30);
Math::Matrix rm = rmz;
eMesh.transform_mesh(rm);
l2Norm(sfxyz, sfx_res);
l2Norm_turbo(sfxyz, sfx_res_turbo);
sfx_expect = 0.0178406008037016;
// NOTE: we need extra quadrature accuracy to reproduce this result (cubDegree==4 in IntegratedOp almost gets it right)
// for now, we are satisfied with 3 digits
//STKUNIT_EXPECT_DOUBLE_EQ_APPROX(sfx_res.getValue(), sfx_expect);
if (std::fabs(sfx_res.getValue()-sfx_expect) > 0.01*sfx_expect)
{
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res.getValue());
STKUNIT_EXPECT_TRUE(false);
}
if (std::fabs(sfx_res_turbo.getValue()-sfx_expect) > 0.01*sfx_expect)
{
STKUNIT_EXPECT_DOUBLE_EQ_APPROX( sfx_expect, sfx_res_turbo.getValue());
STKUNIT_EXPECT_TRUE(false);
}
}
void Update() {
ForegroundFLD->Int(OrigREC, Foreground());
BackgroundFLD->Int(OrigREC, Background());
StyleFLD->Int(OrigREC, Style());
OrigREC->Name(Name());
}
/// This test uses a back door to the function that passes in the element to avoid the lookup of the element when the
/// StringFunction contains references to FieldFunctions
void TEST_norm_string_function_turbo_timings(TurboOption turboOpt)
{
EXCEPTWATCH;
//stk::diag::WriterThrowSafe _write_throw_safe(dw());
//dw().setPrintMask(dw_option_mask.parse(vm["dw"].as<std::string>().c_str()));
//dw().setPrintMask(LOG_NORM+LOG_ALWAYS);
dw().m(LOG_NORM) << "TEST.norm.string_function " << stk::diag::dendl;
/// create a meta data/bulk data empty pair
PerceptMesh eMesh(3u);
if (1)
{
// Need a symmetric mesh around the origin for some of the tests below to work correctly (i.e. have analytic solutions)
const size_t nxyz = 4;
const size_t num_x = nxyz;
const size_t num_y = nxyz;
const size_t num_z = nxyz;
std::string config_mesh =
Ioss::Utils::to_string(num_x) + "x" +
Ioss::Utils::to_string(num_y) + "x" +
Ioss::Utils::to_string(num_z) + "|bbox:-0.5,-0.5,-0.5,0.5,0.5,0.5";
eMesh.new_mesh(GMeshSpec(config_mesh));
eMesh.commit();
}
mesh::fem::FEMMetaData& metaData = *eMesh.get_fem_meta_data();
mesh::BulkData& bulkData = *eMesh.get_bulk_data();
/// the coordinates field is always created by the PerceptMesh read operation, here we just get the field
mesh::FieldBase *coords_field = metaData.get_field<mesh::FieldBase>("coordinates");
/// create a field function from the existing coordinates field
FieldFunction ff_coords("ff_coords", coords_field, &bulkData,
Dimensions(3), Dimensions(3), FieldFunction::SIMPLE_SEARCH );
/// the function to be integrated: sqrt(Integral[x^2, dxdydz]) =?= sqrt(x^3/3 @ [-0.5, 0.5]) ==> sqrt(0.25/3)
StringFunction sfx("x", Name("sfx"), Dimensions(3), Dimensions(1) );
ff_coords.add_alias("mc");
//StringFunction sfcm("sqrt(mc[0]*mc[0]+mc[1]*mc[1]+mc[2]*mc[2])", Name("sfcm"), Dimensions(3), Dimensions(1));
StringFunction sfx_mc("mc[0]", Name("sfx_mc"), Dimensions(3), Dimensions(1) );
/// the function to be integrated: sqrt(Integral[x^2, dxdydz]) =?= sqrt(x^3/3 @ [-0.5, 0.5]) ==> sqrt(0.25/3)
/// A place to hold the result.
/// This is a "writable" function (we may want to make this explicit - StringFunctions are not writable; FieldFunctions are
/// since we interpolate values to them from other functions).
ConstantFunction sfx_res(0.0, "sfx_res");
ConstantFunction sfx_res_turbo(0.0, "sfx_res_turbo");
ConstantFunction sfx_res_slow(0.0, "sfx_res_slow");
ConstantFunction sfx_res_fast(0.0, "sfx_res_fast");
#define COL_SEP "|"
#define EXPR_CELL_WIDTH (80)
#define TIME_IT2(expr_none,expr_turbo,msg,topt) \
{ \
double TURBO_NONE_time = 0; \
double TURBO_ON_time = 0; \
TIME_IT(expr_none,TURBO_NONE_time); \
TIME_IT(expr_turbo,TURBO_ON_time); \
if (1) std::cout << msg << #topt << "for expression= " << QUOTE(expr_none) << " timings= " << std::endl; \
if (1) std::cout << "TURBO_NONE_time= " << TURBO_NONE_time << " " \
<< ( turboOpt==TURBO_ELEMENT?"TURBO_ELEMENT_time":"TURBO_BUCKET_time") <<"= " << TURBO_ON_time \
<< " ratio= " << TURBO_NONE_time/TURBO_ON_time << std::endl; \
}
int numIter = 1;
for (int iter = 0; iter < numIter; iter++)
{
/// Create the operator that will do the work
/// get the l2 norm
Norm<2> l2Norm (bulkData, &metaData.universal_part(), TURBO_NONE);
Norm<2> l2Norm_turbo(bulkData, &metaData.universal_part(), turboOpt);
//double TURBO_ELEMENT_time=0;
TIME_IT2(l2Norm(sfx, sfx_res); , l2Norm_turbo(sfx, sfx_res_turbo);, "Should be the same turboOpt= ", turboOpt );
void MachNullCheckNode::format( PhaseRegAlloc *ra_, outputStream *st ) const {
int reg = ra_->get_reg_first(in(1)->in(_vidx));
tty->print("%s %s", Name(), Matcher::regName[reg]);
}
void exec(char *buff, char **bufc, int tflags, dbref player, dbref cause,
int eval, char **dstr, char *cargs[], int ncargs)
{
#define NFARGS 30
char *fargs[NFARGS];
char *preserve[MAX_GLOBAL_REGS];
char *tstr, *tbuf, *tbufc, *savepos, *atr_gotten, *start, *oldp, *savestr;
char savec, ch, *str;
char *realbuff = NULL, *realbp = NULL;
dbref aowner;
int at_space, nfargs, gender, i, j, alldone, feval; long aflags;
int is_trace, is_top, save_count;
int ansi;
FUN *fp;
UFUN *ufp;
static const char *subj[5] = { "", "it", "she", "he", "they" };
static const char *poss[5] = { "", "its", "her", "his", "their" };
static const char *obj[5] = { "", "it", "her", "him", "them" };
static const char *absp[5] = { "", "its", "hers", "his", "theirs" };
if(*dstr == NULL)
return;
// dprintk("%d/%s", player, *dstr);
at_space = 1;
gender = -1;
alldone = 0;
ansi = 0;
is_trace = Trace(player) && !(eval & EV_NOTRACE);
is_top = 0;
/* Extend the buffer if we need to. */
if(((*bufc) - buff) > (LBUF_SIZE - SBUF_SIZE)) {
realbuff = buff;
realbp = *bufc;
buff = (char *) malloc(LBUF_SIZE);
*bufc = buff;
}
oldp = start = *bufc;
/*
* If we are tracing, save a copy of the starting buffer
*/
savestr = NULL;
if(is_trace) {
is_top = tcache_empty();
savestr = alloc_lbuf("exec.save");
StringCopy(savestr, *dstr);
}
while (**dstr && !alldone) {
switch (**dstr) {
case ' ':
/*
* A space. Add a space if not compressing or if * *
*
* * * * previous char was not a space
*/
if(!(mudconf.space_compress && at_space) ||
(eval & EV_NO_COMPRESS)) {
safe_chr(' ', buff, bufc);
at_space = 1;
}
break;
case '\\':
/*
* General escape. Add the following char without *
* * * * special processing
*/
at_space = 0;
(*dstr)++;
if(**dstr)
safe_chr(**dstr, buff, bufc);
else
(*dstr)--;
break;
case '[':
/*
* Function start. Evaluate the contents of the * *
* * * square brackets as a function. If no closing
* * * * * bracket, insert the [ and continue.
*/
at_space = 0;
tstr = (*dstr)++;
if(eval & EV_NOFCHECK) {
safe_chr('[', buff, bufc);
*dstr = tstr;
break;
}
tbuf = parse_to(dstr, ']', 0);
if(*dstr == NULL) {
safe_chr('[', buff, bufc);
*dstr = tstr;
} else {
str = tbuf;
exec(buff, bufc, 0, player, cause,
(eval | EV_FCHECK | EV_FMAND), &str, cargs, ncargs);
(*dstr)--;
}
break;
case '{':
/*
* Literal start. Insert everything up to the * * *
* * terminating } without parsing. If no closing *
* * * * brace, insert the { and continue.
*/
at_space = 0;
tstr = (*dstr)++;
tbuf = parse_to(dstr, '}', 0);
if(*dstr == NULL) {
safe_chr('{', buff, bufc);
*dstr = tstr;
} else {
if(!(eval & EV_STRIP)) {
safe_chr('{', buff, bufc);
}
/*
* Preserve leading spaces (Felan)
*/
if(*tbuf == ' ') {
safe_chr(' ', buff, bufc);
tbuf++;
}
str = tbuf;
exec(buff, bufc, 0, player, cause,
(eval & ~(EV_STRIP | EV_FCHECK)), &str, cargs, ncargs);
if(!(eval & EV_STRIP)) {
safe_chr('}', buff, bufc);
}
(*dstr)--;
}
break;
case '%':
/*
* Percent-replace start. Evaluate the chars * * *
* following * and perform the appropriate * * *
* substitution.
*/
at_space = 0;
(*dstr)++;
savec = **dstr;
savepos = *bufc;
switch (savec) {
case '\0': /*
* Null - all done
*/
(*dstr)--;
break;
case '|': /* piped command output */
safe_str(mudstate.pout, buff, bufc);
break;
case '%': /*
* Percent - a literal %
*/
safe_chr('%', buff, bufc);
break;
case 'c':
case 'C':
(*dstr)++;
if(!**dstr)
(*dstr)--;
ansi = 1;
switch (**dstr) {
case 'h': /*
* hilite
*/
safe_str(ANSI_HILITE, buff, bufc);
break;
case 'i': /*
* inverse
*/
safe_str(ANSI_INVERSE, buff, bufc);
break;
case 'f': /*
* flash
*/
safe_str(ANSI_BLINK, buff, bufc);
break;
case 'u': /* underline */
safe_str(ANSI_UNDER, buff, bufc);
break;
case 'n': /*
* normal
*/
safe_str(ANSI_NORMAL, buff, bufc);
ansi = 0;
break;
case 'x': /*
* black fg
*/
safe_str(ANSI_BLACK, buff, bufc);
break;
case 'r': /*
* red fg
*/
safe_str(ANSI_RED, buff, bufc);
break;
case 'g': /*
* green fg
*/
safe_str(ANSI_GREEN, buff, bufc);
break;
case 'y': /*
* yellow fg
*/
safe_str(ANSI_YELLOW, buff, bufc);
break;
case 'b': /*
* blue fg
*/
safe_str(ANSI_BLUE, buff, bufc);
break;
case 'm': /*
* magenta fg
*/
safe_str(ANSI_MAGENTA, buff, bufc);
break;
case 'c': /*
* cyan fg
*/
safe_str(ANSI_CYAN, buff, bufc);
break;
case 'w': /*
* white fg
*/
safe_str(ANSI_WHITE, buff, bufc);
break;
case 'X': /*
* black bg
*/
safe_str(ANSI_BBLACK, buff, bufc);
break;
case 'R': /*
* red bg
*/
safe_str(ANSI_BRED, buff, bufc);
break;
case 'G': /*
* green bg
*/
safe_str(ANSI_BGREEN, buff, bufc);
break;
case 'Y': /*
* yellow bg
*/
safe_str(ANSI_BYELLOW, buff, bufc);
break;
case 'B': /*
* blue bg
*/
safe_str(ANSI_BBLUE, buff, bufc);
break;
case 'M': /*
* magenta bg
*/
safe_str(ANSI_BMAGENTA, buff, bufc);
break;
case 'C': /*
* cyan bg
*/
safe_str(ANSI_BCYAN, buff, bufc);
break;
case 'W': /*
* white bg
*/
safe_str(ANSI_BWHITE, buff, bufc);
break;
default:
safe_chr(**dstr, buff, bufc);
}
break;
case 'r': /*
* Carriage return
*/
case 'R':
safe_str((char *) "\r\n", buff, bufc);
break;
case 't': /*
* Tab
*/
case 'T':
safe_chr('\t', buff, bufc);
break;
case 'B': /*
* Blank
*/
case 'b':
safe_chr(' ', buff, bufc);
break;
case '0': /*
* Command argument number N
*/
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
i = (**dstr - '0');
if((i < ncargs) && (cargs[i] != NULL))
safe_str(cargs[i], buff, bufc);
break;
case 'V': /*
* Variable attribute
*/
case 'v':
(*dstr)++;
ch = ToUpper(**dstr);
if(!**dstr)
(*dstr)--;
if((ch < 'A') || (ch > 'Z'))
break;
i = 100 + ch - 'A';
atr_gotten = atr_pget(player, i, &aowner, &aflags);
safe_str(atr_gotten, buff, bufc);
free_lbuf(atr_gotten);
break;
case 'Q':
case 'q':
(*dstr)++;
i = (**dstr - '0');
if((i >= 0) && (i <= 9) && mudstate.global_regs[i]) {
safe_str(mudstate.global_regs[i], buff, bufc);
}
if(!**dstr)
(*dstr)--;
break;
case 'O': /*
* Objective pronoun
*/
case 'o':
if(gender < 0)
gender = get_gender(cause);
if(!gender)
tbuf = Name(cause);
else
tbuf = (char *) obj[gender];
safe_str(tbuf, buff, bufc);
break;
case 'P': /*
* Personal pronoun
*/
case 'p':
if(gender < 0)
gender = get_gender(cause);
if(!gender) {
safe_str(Name(cause), buff, bufc);
safe_chr('s', buff, bufc);
} else {
safe_str((char *) poss[gender], buff, bufc);
}
break;
case 'S': /*
* Subjective pronoun
*/
case 's':
if(gender < 0)
gender = get_gender(cause);
if(!gender)
tbuf = Name(cause);
else
tbuf = (char *) subj[gender];
safe_str(tbuf, buff, bufc);
break;
case 'A': /*
* Absolute posessive
*/
case 'a': /*
* idea from Empedocles
*/
if(gender < 0)
gender = get_gender(cause);
if(!gender) {
safe_str(Name(cause), buff, bufc);
safe_chr('s', buff, bufc);
} else {
safe_str((char *) absp[gender], buff, bufc);
}
break;
case '#': /*
* Invoker DB number
*/
tbuf = alloc_sbuf("exec.invoker");
sprintf(tbuf, "#%ld", cause);
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
break;
case '!': /*
* Executor DB number
*/
tbuf = alloc_sbuf("exec.executor");
sprintf(tbuf, "#%ld", player);
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
break;
case 'N': /*
* Invoker name
*/
case 'n':
safe_str(Name(cause), buff, bufc);
break;
case 'L': /*
* Invoker location db#
*/
case 'l':
if(!(eval & EV_NO_LOCATION)) {
tbuf = alloc_sbuf("exec.exloc");
sprintf(tbuf, "#%ld", where_is(cause));
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
}
break;
default: /*
* Just copy
*/
safe_chr(**dstr, buff, bufc);
}
if(isupper(savec))
*savepos = ToUpper(*savepos);
break;
case '(':
/*
* Arglist start. See if what precedes is a function. If so,
* execute it if we should.
*/
at_space = 0;
if(!(eval & EV_FCHECK)) {
safe_chr('(', buff, bufc);
break;
}
/*
* Load an sbuf with an uppercase version of the func name, and
* see if the func exists. Trim trailing spaces from the name
* if configured.
*/
**bufc = '\0';
tbufc = tbuf = alloc_sbuf("exec.tbuf");
safe_sb_str(oldp, tbuf, &tbufc);
*tbufc = '\0';
if(mudconf.space_compress) {
while ((--tbufc >= tbuf) && isspace(*tbufc));
tbufc++;
*tbufc = '\0';
}
for(tbufc = tbuf; *tbufc; tbufc++)
*tbufc = ToLower(*tbufc);
fp = (FUN *) hashfind(tbuf, &mudstate.func_htab);
/*
* If not a builtin func, check for global func
*/
ufp = NULL;
if(fp == NULL) {
ufp = (UFUN *) hashfind(tbuf, &mudstate.ufunc_htab);
}
/*
* Do the right thing if it doesn't exist
*/
if(!fp && !ufp) {
if(eval & EV_FMAND) {
*bufc = oldp;
safe_str((char *) "#-1 FUNCTION (", buff, bufc);
safe_str(tbuf, buff, bufc);
safe_str((char *) ") NOT FOUND", buff, bufc);
alldone = 1;
} else {
safe_chr('(', buff, bufc);
}
free_sbuf(tbuf);
eval &= ~EV_FCHECK;
break;
}
free_sbuf(tbuf);
/*
* Get the arglist and count the number of args * Neg
*
* * * * * * # of args means catenate subsequent
* args
*/
if(ufp)
nfargs = NFARGS;
else if(fp->nargs < 0)
nfargs = -fp->nargs;
else
nfargs = NFARGS;
tstr = *dstr;
if(fp && (fp->flags & FN_NO_EVAL))
feval = (eval & ~EV_EVAL) | EV_STRIP_ESC;
else
feval = eval;
*dstr =
parse_arglist(player, cause, *dstr + 1, ')', feval, fargs,
nfargs, cargs, ncargs);
/*
* If no closing delim, just insert the '(' and * * *
*
* * continue normally
*/
if(!*dstr) {
*dstr = tstr;
safe_chr(**dstr, buff, bufc);
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
}
/*
* Count number of args returned
*/
(*dstr)--;
j = 0;
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
j = i + 1;
nfargs = j;
/*
* If it's a user-defined function, perform it now.
*/
if(ufp) {
mudstate.func_nest_lev++;
if(!check_access(player, ufp->perms)) {
safe_str("#-1 PERMISSION DENIED", buff, &oldp);
*bufc = oldp;
} else {
tstr = atr_get(ufp->obj, ufp->atr, &aowner, &aflags);
if(ufp->flags & FN_PRIV)
i = ufp->obj;
else
i = player;
str = tstr;
if(ufp->flags & FN_PRES) {
for(j = 0; j < MAX_GLOBAL_REGS; j++) {
if(!mudstate.global_regs[j])
preserve[j] = NULL;
else {
preserve[j] = alloc_lbuf("eval_regs");
StringCopy(preserve[j],
mudstate.global_regs[j]);
}
}
}
exec(buff, &oldp, 0, i, cause, feval, &str, fargs,
nfargs);
*bufc = oldp;
if(ufp->flags & FN_PRES) {
for(j = 0; j < MAX_GLOBAL_REGS; j++) {
if(preserve[j]) {
if(!mudstate.global_regs[j])
mudstate.global_regs[j] =
alloc_lbuf("eval_regs");
StringCopy(mudstate.global_regs[j],
preserve[j]);
free_lbuf(preserve[j]);
} else {
if(mudstate.global_regs[j])
*(mudstate.global_regs[i]) = '\0';
}
}
}
free_lbuf(tstr);
}
/*
* Return the space allocated for the args
*/
mudstate.func_nest_lev--;
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
}
/*
* If the number of args is right, perform the func.
* Otherwise return an error message. Note
* that parse_arglist returns zero args as one
* null arg, so we have to handle that case
* specially.
*/
if((fp->nargs == 0) && (nfargs == 1)) {
if(!*fargs[0]) {
free_lbuf(fargs[0]);
fargs[0] = NULL;
nfargs = 0;
}
}
if((nfargs == fp->nargs) || (nfargs == -fp->nargs) ||
(fp->flags & FN_VARARGS)) {
/*
* Check recursion limit
*/
mudstate.func_nest_lev++;
mudstate.func_invk_ctr++;
if(mudstate.func_nest_lev >= mudconf.func_nest_lim) {
safe_str("#-1 FUNCTION RECURSION LIMIT EXCEEDED", buff,
bufc);
} else if(mudstate.func_invk_ctr == mudconf.func_invk_lim) {
safe_str("#-1 FUNCTION INVOCATION LIMIT EXCEEDED",
buff, bufc);
} else if(!check_access(player, fp->perms)) {
safe_str("#-1 PERMISSION DENIED", buff, &oldp);
*bufc = oldp;
} else if(mudstate.func_invk_ctr < mudconf.func_invk_lim) {
fp->fun(buff, &oldp, player, cause, fargs, nfargs,
cargs, ncargs);
*bufc = oldp;
} else {
**bufc = '\0';
}
mudstate.func_nest_lev--;
} else {
*bufc = oldp;
tstr = alloc_sbuf("exec.funcargs");
sprintf(tstr, "%d", fp->nargs);
safe_str((char *) "#-1 FUNCTION (", buff, bufc);
safe_str((char *) fp->name, buff, bufc);
safe_str((char *) ") EXPECTS ", buff, bufc);
safe_str(tstr, buff, bufc);
safe_str((char *) " ARGUMENTS", buff, bufc);
free_sbuf(tstr);
}
/*
* Return the space allocated for the arguments
*/
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
default:
/*
* A mundane character. Just copy it
*/
at_space = 0;
safe_chr(**dstr, buff, bufc);
}
(*dstr)++;
}
/*
* If we're eating spaces, and the last thing was a space, eat it
* up. Complicated by the fact that at_space is initially
* true. So check to see if we actually put something in the
* buffer, too.
*/
if(mudconf.space_compress && at_space && !(eval & EV_NO_COMPRESS)
&& (start != *bufc))
(*bufc)--;
/*
* The ansi() function knows how to take care of itself. However,
* if the player used a %c sub in the string, and hasn't yet
* terminated the color with a %cn yet, we'll have to do it for
* them.
*/
if(ansi == 1)
safe_str(ANSI_NORMAL, buff, bufc);
**bufc = '\0';
/*
* Report trace information
*/
if(realbuff) {
**bufc = '\0';
*bufc = realbp;
safe_str(buff, realbuff, bufc);
free(buff);
buff = realbuff;
}
if(is_trace) {
tcache_add(savestr, start);
save_count = tcache_count - mudconf.trace_limit;;
if(is_top || !mudconf.trace_topdown)
tcache_finish(player);
if(is_top && (save_count > 0)) {
tbuf = alloc_mbuf("exec.trace_diag");
sprintf(tbuf, "%d lines of trace output discarded.", save_count);
notify(player, tbuf);
free_mbuf(tbuf);
}
}
}
std::pair<int64_t,Name>
Index::selectChild(const Interest& interest,
IndexContainer::const_iterator startingPoint) const
{
BOOST_ASSERT(startingPoint != m_indexContainer.end());
bool isLeftmost = (interest.getChildSelector() <= 0);
ndn::ConstBufferPtr hash;
if (!interest.getPublisherPublicKeyLocator().empty())
{
KeyLocator keyLocator = interest.getPublisherPublicKeyLocator();
const Block& block = keyLocator.wireEncode();
hash = ndn::crypto::sha256(block.wire(), block.size());
}
if (isLeftmost)
{
for (IndexContainer::const_iterator it = startingPoint;
it != m_indexContainer.end(); ++it)
{
if (!interest.getName().isPrefixOf(it->getName()))
return std::make_pair(0, Name());
if (matchesSimpleSelectors(interest, hash, (*it)))
return std::make_pair(it->getId(), it->getName());
}
}
else
{
IndexContainer::const_iterator boundary = m_indexContainer.lower_bound(interest.getName());
if (boundary == m_indexContainer.end() || !interest.getName().isPrefixOf(boundary->getName()))
return std::make_pair(0, Name());
Name successor = interest.getName().getSuccessor();
IndexContainer::const_iterator last = interest.getName().size() == 0 ?
m_indexContainer.end() : m_indexContainer.lower_bound(interest.getName().getSuccessor());
while (true)
{
IndexContainer::const_iterator prev = last;
if (prev != boundary) {
--prev;
}
if (prev == boundary)
{
bool isMatch = matchesSimpleSelectors(interest, hash, (*prev));
if (isMatch)
{
return std::make_pair(prev->getId(), prev->getName());
}
else
return std::make_pair(0, Name());
}
IndexContainer::const_iterator first =
m_indexContainer.lower_bound(prev->getName().getPrefix(interest.getName().size() + 1));
IndexContainer::const_iterator match =
std::find_if(first, last, bind(&matchesSimpleSelectors, interest, hash, _1));
if (match != last)
{
return std::make_pair(match->getId(), match->getName());
}
last = first;
}
}
return std::make_pair(0, Name());
}
// xpcom getters
NS_IMETHODIMP nsCookie::GetName(nsACString &aName) { aName = Name(); return NS_OK; }