int AGOSEngine_PN::actCallD(int n) {
int pf[8];
funcentry(pf, n);
addstack(kJmpClassNum);
funccpy(pf);
setposition(n, 0);
return doline(1);
}
void Plots(TString plots="4Jets", TString sys="", bool EvtNorm=false){
/****************
Style
****************/
gROOT->SetStyle("Plain");
gStyle->SetOptFit(1000);
gStyle->SetOptStat("emruo");
gStyle->SetOptStat(kFALSE);
gStyle->SetPadTickY(1);
gStyle->SetPadTickX(1);
gROOT->ProcessLine(".L /home/brochero/ttbar/TopCodeljets/tdrStyle.C");
setTDRStyle();
Int_t chatch = 1756;
TColor *color = new TColor(chatch, 0.3, 0.5, 0.5, "", 0.45); // alpha = 0.5
TString files = dirnameIn + fl;
/****************
Channel
****************/
TString channel[3];
channel[0] = "mujets";
channel[1] = "ejets";
channel[2] = "lepjet";
/****************
Data
****************/
std::vector<histos> DataMu;
DataMu = loadhistograms(plots, files + "_DataSingleMu");
std::vector<histos> DataEG;
DataEG = loadhistograms(plots, files + "_DataSingleEG");
std::vector<histos> Data;
Data = addhistograms(DataMu, DataEG);
setuphistograms(Data, kBlack);
/****************
ttbar Signal
****************/
std::vector<histos> ttbar_0;
ttbar_0 = loadhistograms(plots, files + "_ttbar-PowhegPythia");
setuphistograms(ttbar_0, kRed+1);
std::vector<histos> ttbar_1;
ttbar_1 = loadhistograms(plots, files + "_ttbar-MCatNLO");
setuphistograms(ttbar_1, kRed+2);
std::vector<histos> ttbar_2;
ttbar_2 = loadhistograms(plots, files + "_ttbar-Madgraph");
setuphistograms(ttbar_2, kRed+3);
/****************
Z+Jets
****************/
std::vector<histos> ZJets;
ZJets = loadhistograms(plots, files + "_ZJets");
setuphistograms(ZJets, kAzure-2);
/****************
VV
****************/
std::vector<histos> WW;
WW = loadhistograms(plots, files + "_WW");
std::vector<histos> WZ;
WZ = loadhistograms(plots, files + "_WZ");
std::vector<histos> ZZ;
ZZ = loadhistograms(plots, files + "_ZZ");
std::vector<histos> VV;
VV = addhistograms(WW, WZ);
VV = addhistograms(VV, ZZ);
setuphistograms(VV, kYellow-3);
/****************
Single Top
****************/
std::vector<histos> tW;
tW = loadhistograms(plots, files + "_tW");
std::vector<histos> tbarW;
tbarW = loadhistograms(plots, files + "_tbarW");
std::vector<histos> t_tch;
t_tch = loadhistograms(plots, files + "_t-tchannel");
std::vector<histos> tbar_tch;
tbar_tch = loadhistograms(plots, files + "_tbar-tchannel");
std::vector<histos> Single_top;
Single_top = addhistograms(tW, tbarW);
Single_top = addhistograms(Single_top, t_tch);
Single_top = addhistograms(Single_top, tbar_tch);
setuphistograms(Single_top, kPink-3);
/****************
W+Jets
****************/
std::vector<histos> WJets;
WJets = loadhistograms(plots, files + "_WJets");
setuphistograms(WJets, kGreen-3);
/****************
ttbar Bkg
****************/
std::vector<histos> ttbar_bkg;
ttbar_bkg = loadhistograms(plots, files + "_ttbar-PowhegPythiaBkg");
setuphistograms(ttbar_bkg, kViolet-3);
/****************
QCD
****************/
std::vector<histos> QCD;
QCD = loadhistograms(plots, files + "_QCD-MuEnr");
setuphistograms(QCD, kOrange-3);
/****************
Stacks
****************/
std::vector<histos> Stack_bkg;
std::vector<histos> Stack;
histos st_bkg;
histos st;
for(unsigned int h=0; h<WJets.size(); h++){
TString variable;
for(int ch=0; ch<3; ch++){
st.mc[ch] = new THStack(variable, "");
st_bkg.mc[ch] = new THStack(variable, "");
st.mc[ch]->SetHistogram( (TH1F*)WJets[h].hist[ch]->Clone());
st_bkg.mc[ch]->SetHistogram( (TH1F*)WJets[h].hist[ch]->Clone());
}
Stack.push_back(st);
Stack_bkg.push_back(st_bkg);
}
//-------------------------------------------------------
// Background Stack
Stack_bkg = addstack(Stack_bkg, WJets);
Stack_bkg = addstack(Stack_bkg, QCD);
Stack_bkg = addstack(Stack_bkg, Single_top);
Stack_bkg = addstack(Stack_bkg, VV);
Stack_bkg = addstack(Stack_bkg, ttbar_bkg);
Stack_bkg = addstack(Stack_bkg, ZJets);
//-------------------------------------------------------
// Stack
Stack = addstack(Stack, WJets);
Stack = addstack(Stack, QCD);
Stack = addstack(Stack, Single_top);
Stack = addstack(Stack, VV);
Stack = addstack(Stack, ttbar_bkg);
Stack = addstack(Stack, ZJets);
Stack = addstack(Stack, ttbar_0);
//-------------------------------------------------------
// other ttbar Generators
ttbar_1 = addhistograms(ttbar_1, Stack_bkg);
ttbar_2 = addhistograms(ttbar_2, Stack_bkg);
/****************
Draw Histos
****************/
TCanvas *histocanvas;
histocanvas = new TCanvas("plots", "Plots");
for(unsigned int h=0; h<WJets.size(); h++){
for(int ch=0; ch<3; ch++){
histocanvas->Divide(1,2);
TPad *pad[2];
//Plot Pad
pad[0] = (TPad*)histocanvas->GetPad(1);
pad[0]->SetPad(0.01, 0.23, 0.99, 0.99);
pad[0]->SetTopMargin(0.1);
pad[0]->SetRightMargin(0.04);
//Ratio Pad
pad[1] = (TPad*)histocanvas->GetPad(2);
pad[1]->SetPad(0.01, 0.02, 0.99, 0.3);
gStyle->SetGridWidth(0.5);
gStyle->SetGridColor(14);
pad[1]->SetGridx();
pad[1]->SetGridy();
pad[1]->SetTopMargin(0.05);
pad[1]->SetBottomMargin(0.4);
pad[1]->SetRightMargin(0.04);
//-------------------------------------------------------
// Stack
pad[0]->cd();
Stack[h].mc[ch]->Draw("hist");
Stack[h].mc[ch]->GetYaxis()->SetTitle("Events");
Stack[h].mc[ch]->GetYaxis()->SetTitleOffset(1.2);
Stack[h].mc[ch]->GetYaxis()->SetTitleSize(0.07);
Stack[h].mc[ch]->GetYaxis()->SetLabelSize(0.055);
Stack[h].mc[ch]->GetYaxis()->SetNdivisions(607);
//Stack[h].mc[ch]->GetYaxis()->SetLabelSize(0.05);
TGaxis *hYaxis = (TGaxis*)Stack[h].mc[ch]->GetYaxis();
//hYaxis->SetMaxDigits(3);
Stack[h].mc[ch]->GetXaxis()->SetLabelSize(0.0);
Stack[h].mc[ch]->GetXaxis()->SetTitle("");
float maxh = Data[h].hist[ch]->GetMaximum();
if(maxh < Stack[h].mc[ch]->GetMaximum()) maxh = Stack[h].mc[ch]->GetMaximum();
Stack[h].mc[ch]->SetMaximum(1.7*maxh);
//-------------------------------------------------------
// Band error
TGraphErrors *thegraph = new TGraphErrors(Stack[h].hist[ch]);
thegraph->SetName("thegraph");
thegraph->SetFillStyle(1001);
thegraph->SetFillColor(chatch);
thegraph->SetLineColor(chatch);
thegraph->Draw("e2SAME");
//-------------------------------------------------------
// Other ttbar generators
ttbar_1[h].hist[ch]->SetLineColor(6);
ttbar_1[h].hist[ch]->SetLineStyle(2);
ttbar_1[h].hist[ch]->SetFillColor(0);
ttbar_1[h].hist[ch]->Draw("histoSAME");
ttbar_2[h].hist[ch]->SetLineColor(8);
ttbar_2[h].hist[ch]->SetLineStyle(4);
ttbar_2[h].hist[ch]->SetFillColor(0);
ttbar_2[h].hist[ch]->Draw("histoSAME");
//-------------------------------------------------------
// Data Histogram
Data[h].hist[ch]->SetMarkerStyle(20);
Data[h].hist[ch]->SetMarkerSize(0.7);
Data[h].hist[ch]->Draw("SAME");
/***********************
Legends
***********************/
TLegend *leg;
float legx1=0.76;
float legy1=0.54;
float legx2=0.90;
float legy2=0.87;
leg = new TLegend(legx1,legy1,legx2,legy2);
leg->SetFillColor(0);
leg->SetLineColor(1);
leg->SetTextFont(62);
leg->SetTextSize(0.03);
leg->AddEntry(Data[h].hist[ch],"Data","PL");
leg->AddEntry(ttbar_0[h].hist[ch],"t#bar{t} Signal","F");
leg->AddEntry(ZJets[h].hist[ch],"Z+Jets","F");
leg->AddEntry(ttbar_bkg[h].hist[ch],"t#bar{t} Bkg","F");
leg->AddEntry(VV[h].hist[ch],"VV","F");
leg->AddEntry(Single_top[h].hist[ch],"Single t","F");
leg->AddEntry(QCD[h].hist[ch],"QCD","F");
leg->AddEntry(WJets[h].hist[ch],"W+Jets","F");
leg->AddEntry("thegraph","Uncertainty","F");
leg->AddEntry((TObject*)0,"","");
leg->AddEntry(ttbar_1[h].hist[ch],"MC@NLO","L");
leg->AddEntry(ttbar_2[h].hist[ch],"Madgraph","L");
leg->Draw("SAME");
//-------------------------------------------------------
// CMS
TString htitleCMSChannel[3];
htitleCMSChannel[0] = "#mu^{#pm}+jets channel";
htitleCMSChannel[1] = "e^{#pm}+jets channel";
htitleCMSChannel[2] = "l^{#pm}+jets channel";
titlePr = new TLatex(-20.,50.,"Preliminary");
titlePr->SetNDC();
titlePr->SetTextAlign(12);
titlePr->SetX(0.25);
titlePr->SetY(0.93);
titlePr->SetTextColor(2);
titlePr->SetTextFont(42);
titlePr->SetTextSize(0.05);
titlePr->SetTextSizePixels(24);
titlePr->Draw("SAME");
title = new TLatex(-20.,50.,"CMS #sqrt{s} = 13TeV, L = 42 pb^{-1}(50ns)");
title->SetNDC();
title->SetTextAlign(12);
title->SetX(0.20);
title->SetY(0.83);
title->SetTextFont(42);
title->SetTextSize(0.05);
title->SetTextSizePixels(24);
title->Draw("SAME");
chtitle = new TLatex(-20.,50.,htitleCMSChannel[ch]);
chtitle->SetNDC();
chtitle->SetTextAlign(12);
chtitle->SetX(0.20);
chtitle->SetY(0.75);
chtitle->SetTextFont(42);
chtitle->SetTextSize(0.05);
chtitle->SetTextSizePixels(24);
chtitle->Draw("SAME");
/***********************
Ratio
***********************/
pad[1]->cd();
//-------------------------------------------------------
//Graph Ratio Clone
TH1F *Ratio;
Ratio = (TH1F*)Data[h].hist[ch]->Clone();
Ratio->Divide(Stack[h].hist[ch]);
TH1F *RatioSyst;
RatioSyst = (TH1F*)Data[h].hist[ch]->Clone();
RatioSyst->Divide(Stack[h].hist[ch]); // Should be the histogram with the Total Syst. Unc.
std::vector<double> ratioContent;
for(unsigned int b_r = 1; b_r <= RatioSyst->GetNbinsX(); b_r++){
RatioSyst->SetBinContent(b_r,1.0);
//RatioSyst->SetBinError(b_r,0.15); // Tempotal!!!
}
Ratio->SetMarkerStyle(20);
Ratio->SetMarkerSize(0.5);
Ratio->SetMarkerColor(1);
Ratio->SetLineColor(1);
Ratio->SetLineWidth(1);
Ratio->SetMaximum(2);
Ratio->SetMinimum(0);
Ratio->SetTitle("");
Ratio->GetYaxis()->SetTitle("Obs/Exp");
Ratio->GetYaxis()->CenterTitle();
Ratio->GetYaxis()->SetTitleOffset(0.45);
Ratio->GetYaxis()->SetTitleSize(0.16);
Ratio->GetYaxis()->SetLabelSize(0.15);
Ratio->GetYaxis()->SetNdivisions(402);
Ratio->GetXaxis()->SetNdivisions(509);
Ratio->GetXaxis()->SetTitleOffset(1.1);
Ratio->GetXaxis()->SetLabelSize(0.20);
Ratio->GetXaxis()->SetTitleSize(0.16);
Ratio->SetMinimum(0.6);
Ratio->SetMaximum(1.4);
TGraphErrors *thegraphRatioSyst = new TGraphErrors(RatioSyst);
thegraphRatioSyst->SetFillStyle(1001);
thegraphRatioSyst->SetFillColor(chatch);
thegraphRatioSyst->SetName("thegraphRatioSyst");
//-------------------------------------------------------
//Graph Ratio other ttbar generators
TH1F *Ratio_1;
Ratio_1 = (TH1F*)Data[h].hist[ch]->Clone();
Ratio_1->Divide(ttbar_1[h].hist[ch]);
Ratio_1->SetLineColor(6);
Ratio_1->SetLineStyle(2);
Ratio_1->SetLineWidth(2);
Ratio_1->SetFillColor(0);
TH1F *Ratio_2;
Ratio_2 = (TH1F*)Data[h].hist[ch]->Clone();
Ratio_2->Divide(ttbar_2[h].hist[ch]);
Ratio_2->SetLineColor(8);
Ratio_2->SetLineStyle(4);
Ratio_2->SetLineWidth(2);
Ratio_2->SetFillColor(0);
//-------------------------------------------------------
// Draw Ratios
Ratio->Draw();
thegraphRatioSyst->Draw("e2");
Ratio->Draw("histpSAME");
Ratio_1->Draw("histSAME");
Ratio_2->Draw("histSAME");
/***********************
Save Histos
***********************/
TString dirfigname_pdf=dirnameIn + "figures_" + fl + "/pdf/";
// make a dir if it does not exist!!
gSystem->mkdir(dirfigname_pdf, kTRUE);
histocanvas->SaveAs(dirfigname_pdf + WJets[h].hist[ch]->GetName() + ".pdf");
// clear Canvas
histocanvas->Clear();
}
}
} //end Plots.C
void AGOSEngine_PN::opn_opcode28() {
addstack(varval());
_stackbase->tagOfParentDoline = _tagOfActiveDoline;
setScriptReturn(false);
}
static int catsearch(struct vol *vol,
struct dir *dir,
int rmatches,
uint32_t *pos,
char *rbuf,
uint32_t *nrecs,
int *rsize,
int ext)
{
static u_int32_t cur_pos; /* Saved position index (ID) - used to remember "position" across FPCatSearch calls */
static DIR *dirpos; /* UNIX structure describing currently opened directory. */
struct dir *currentdir; /* struct dir of current directory */
int cidx, r;
struct dirent *entry;
int result = AFP_OK;
int ccr;
struct path path;
char *vpath = vol->v_path;
char *rrbuf = rbuf;
time_t start_time;
int num_rounds = NUM_ROUNDS;
int cwd = -1;
int error;
int unlen;
if (*pos != 0 && *pos != cur_pos) {
result = AFPERR_CATCHNG;
goto catsearch_end;
}
/* FIXME: Category "offspring count ! */
/* We need to initialize all mandatory structures/variables and change working directory appropriate... */
if (*pos == 0) {
clearstack();
if (dirpos != NULL) {
closedir(dirpos);
dirpos = NULL;
}
if (addstack(vpath, dir, -1) == -1) {
result = AFPERR_MISC;
goto catsearch_end;
}
/* FIXME: Sometimes DID is given by client ! (correct this one above !) */
}
/* Save current path */
if ((cwd = open(".", O_RDONLY)) < 0) {
result = AFPERR_MISC;
goto catsearch_end;
}
/* So we are beginning... */
start_time = time(NULL);
while ((cidx = reducestack()) != -1) {
if ((currentdir = dirlookup(vol, dstack[cidx].ds_did)) == NULL) {
result = AFPERR_MISC;
goto catsearch_end;
}
LOG(log_debug, logtype_afpd, "catsearch: current struct dir: \"%s\"", cfrombstr(currentdir->d_fullpath));
error = movecwd(vol, currentdir);
if (!error && dirpos == NULL)
dirpos = opendir(".");
if (dirpos == NULL)
dirpos = opendir(bdata(currentdir->d_fullpath));
if (error || dirpos == NULL) {
switch (errno) {
case EACCES:
dstack[cidx].ds_checked = 1;
continue;
case EMFILE:
case ENFILE:
case ENOENT:
result = AFPERR_NFILE;
break;
case ENOMEM:
case ENOTDIR:
default:
result = AFPERR_MISC;
} /* switch (errno) */
goto catsearch_end;
}
while ((entry = readdir(dirpos)) != NULL) {
(*pos)++;
if (!check_dirent(vol, entry->d_name))
continue;
LOG(log_debug, logtype_afpd, "catsearch(\"%s\"): dirent: \"%s\"",
cfrombstr(currentdir->d_fullpath), entry->d_name);
memset(&path, 0, sizeof(path));
path.u_name = entry->d_name;
if (of_stat(vol, &path) != 0) {
switch (errno) {
case EACCES:
case ELOOP:
case ENOENT:
continue;
case ENOTDIR:
case EFAULT:
case ENOMEM:
case ENAMETOOLONG:
default:
result = AFPERR_MISC;
goto catsearch_end;
}
}
switch (S_IFMT & path.st.st_mode) {
case S_IFDIR:
/* here we can short cut
ie if in the same loop the parent dir wasn't in the cache
ALL dirsearch_byname will fail.
*/
unlen = strlen(path.u_name);
path.d_dir = dircache_search_by_name(vol,
currentdir,
path.u_name,
unlen);
if (path.d_dir == NULL) {
/* path.m_name is set by adddir */
if ((path.d_dir = dir_add(vol,
currentdir,
&path,
unlen)) == NULL) {
result = AFPERR_MISC;
goto catsearch_end;
}
}
path.m_name = cfrombstr(path.d_dir->d_m_name);
if (addstack(path.u_name, path.d_dir, cidx) == -1) {
result = AFPERR_MISC;
goto catsearch_end;
}
break;
case S_IFREG:
path.d_dir = currentdir;
break;
default:
continue;
}
ccr = crit_check(vol, &path);
/* bit 0 means that criteria has been met */
if ((ccr & 1)) {
r = rslt_add ( vol, &path, &rrbuf, ext);
if (r == 0) {
result = AFPERR_MISC;
goto catsearch_end;
}
*nrecs += r;
/* Number of matches limit */
if (--rmatches == 0)
goto catsearch_pause;
/* Block size limit */
if (rrbuf - rbuf >= 448)
goto catsearch_pause;
}
/* MacOS 9 doesn't like servers executing commands longer than few seconds */
if (--num_rounds <= 0) {
if (start_time != time(NULL)) {
result=AFP_OK;
goto catsearch_pause;
}
num_rounds = NUM_ROUNDS;
}
} /* while ((entry=readdir(dirpos)) != NULL) */
closedir(dirpos);
dirpos = NULL;
dstack[cidx].ds_checked = 1;
} /* while (current_idx = reducestack()) != -1) */
/* We have finished traversing our tree. Return EOF here. */
result = AFPERR_EOF;
goto catsearch_end;
catsearch_pause:
cur_pos = *pos;
save_cidx = cidx;
catsearch_end: /* Exiting catsearch: error condition */
*rsize = rrbuf - rbuf;
if (cwd != -1) {
if ((fchdir(cwd)) != 0) {
LOG(log_debug, logtype_afpd, "error chdiring back: %s", strerror(errno));
}
close(cwd);
}
return result;
} /* catsearch() */
int setdf(float mval)
{
int i,j,k,n,nflat,ni,ip,imin,err,jn,in,np1,nt;
float fact[9],per=1.;
/* Initialize boundaries */
for(i=i1; i< n1; i++)
{
dir[i][i2]= -1;
dir[i][n2-1]= -1;
}
for(i=i2; i< n2; i++)
{
dir[i1][i]= -1;
dir[n1-1][i]= -1;
}
/* initialize internal pointers */
for(i=i2+1; i< n2-1; i++)for(j=i1+1; j<n1-1; j++)
{
if(elev[j][i] <= mval)dir[j][i]= -1;
else dir[j][i] = 0;
}
/* Direction factors */
for(k=1; k<= 8; k++)
fact[k]=(float)(1./sqrt(d1[k]*dy*d1[k]*dy+d2[k]*d2[k]*dx*dx));
/* printf("Problem Pixels \n"); */
/* printf(" Flats Unresolved\n"); */
/* Set positive slope directions - store unresolved on stack */
/*ttt n=1; Avoid iterating - work with stack only
while(n >= 1)
{ */
nis=0;
for(i=i2+1; i< n2-1; i++)for(j=i1+1; j<n1-1; j++)
{
if(elev[j][i] > mval)set(i,j,fact,mval);
/* Put unresolved pixels on stack */
if(dir[j][i] == 0)
{
err=addstack(i,j);
}
}
nflat=nis;
/* routine to drain flats to neighbors */
SetWorkingStatus();
imin=vdn(nflat);
n=nis;
printf("Number of pits to resolve: %d\n",n);
np1=n;
nt=np1*(1-per/100);
/* initialize apool to zero */
for(i=i2; i< n2; i++)for(j=i1; j<n1; j++)
apool[j][i]=0;
/* store unresolved stack location in apool for easy deletion
for(k=1; k<=nis; k++)
apool[js[k]][is[k]]= - k; */
/* pooln=0; */
while(nis > 0) /* While AA */
{
/* fp=fopen("temp.dat","w");
for(ip=1; ip <= nis; ip++)
{
i=is[ip];
j=js[ip];
fprintf(fp,"%d %d %f\n",i,j,elev[j][i]);
}
fclose(fp); */
i=is[imin];
j=js[imin];
/* if(i == 12 && j == 27)
{
printf("Here");
} */
/* pooln=pooln+1; */
pooln=1;
npool=0;
nf = 0; /* reset flag to that new min elev is found */
pool(i,j); /* Recursive call on unresolved point with lowest elevation */
/* Find the pour point of the pool */
/* err = gridwrite("pool.asc",(void **)apool,RPSHRDTYPE,nx,ny,dx,dy,
bndbox,csize,-9999,0); */
for(ip=1; ip<=npool; ip++)
{
i=ipool[ip];
j=jpool[ip];
for(k=1; k <=8; k++)
{
jn=j+d2[k];
in=i+d1[k];
if(apool[jn][in] != pooln) /* neighbor not in pool */
{
et=max2(elev[j][i],elev[jn][in]);
if(nf == 0) /* this is the first edge found */
{
emin=et;
nf=1;
/* ipour=i;
jpour=j; */
}
else
{
/* emin=min2(emin,et); */
if(emin > et)
{
emin = et;
/* ipour=i;
jpour=j; */
}
}
}
}
}
/* Fill the pool */
for(k=1; k<=npool; k++)
{
i=ipool[k];
j=jpool[k];
if(elev[j][i] <= emin)
{
if(dir[j][i] > 0) /* Can be in pool, but not flat */
{
dir[j][i]=0;
/* Add to stack */
err=addstack(i,j);
}
for(ip=1; ip <=8; ip++)
{
jn=j+d2[ip];
in=i+d1[ip];
if(elev[jn][in] > elev[j][i] && dir[jn][in] > 0)
/* Only zero direction of neighbors that are higher - because
lower or equal may be a pour point in a pit that must not be disrupted */
{
dir[jn][in] = 0;
err=addstack(in,jn);
}
}
elev[j][i] =emin;
}
apool[j][i]=0; /* Reinitialize for next time round */
}
/* reset unresolved stack */
ni=0;
for(ip=1; ip <= nis; ip++)
{
set(is[ip],js[ip],fact,mval);
if(dir[js[ip]][is[ip]] == 0) /* still on stack */
{
ni++;
is[ni]=is[ip];
js[ni]=js[ip];
/* apool[js[ni]][is[ni]] = -ni; /* Need to resave stack locations
since the stack is being shortened */
}
/* else
apool[js[ip]][is[ip]] = 0; /* Out of pool */
}
/* fp=fopen("temp.dat","w");
for(ip=1; ip <= nis; ip++)
{
i=is[ip];
j=js[ip];
fprintf(fp,"%d %d %f\n",i,j,elev[j][i]);
}
fclose(fp); */
n=nis;
imin=vdn(ni);
if(nis < nt){
printf("Percentage done %f\n",per);
per=per+1;
nt=np1*(1-per/100);
}
/* Debug writes
err = gridwrite("elev.asc",(void **)elev,RPFLTDTYPE,nx,ny,dx,dy,
bndbox,csize,mval,0);
err = gridwrite("pool.asc",(void **)apool,RPSHRDTYPE,nx,ny,dx,dy,
bndbox,csize,-9999,0); */
} /* end of while AA */
return(err);
}
static INLINE void tracepoint (int xp, int yp, int dir, unsigned int color, int xstart, int xend, int ystart, int yend)
{
unsigned char *calc;
cpixeldata_t mycolor;
int i, lookdir;
unsigned int c;
int x, y;
int periodicity = (dir & 8) != 0;
dir &= ~8;
calc = calculated + xp + yp * CALCWIDTH;
if (!(*calc & (CALCULATED | CALCULATING))) {
*calc |= CALCULATING;
mycolor = (cpixeldata_t) calculatepixel (xp, yp, periodicity);
putpixel (xp, yp, mycolor);
*calc |= CALCULATED;
*calc &= ~CALCULATING;
} else {
if (*calc & CALCULATING) {
/*Bad luck..some other procesor is working with out pixel :) try
*later.*/
addstack (xp, yp, dir, color, periodicity);
return;
}
mycolor = getpixel (xp, yp);
}
while (1) {
periodicity = (mycolor == inset || color == inset);
lookdir = turnright (dir);
for (i = 0; i < 3; i++) {
x = xp + dirrections[lookdir][0];
y = yp + dirrections[lookdir][1];
if (x >= xstart && x <= xend && y >= ystart && y <= yend) {
calc = calculated + x + y * CALCWIDTH;
if (!(*calc & (CALCULATED | CALCULATING))) {
*calc |= CALCULATING;
c = calculatepixel (x, y, periodicity);
putpixel (x, y, c);
*calc |= CALCULATED;
*calc &= ~CALCULATING;
} else {
if (*calc & CALCULATING) {
/*Bad luck..some other procesor is working with out pixel :) try
*later.*/
addstack (xp, yp, dir, color, periodicity);
return;
}
c = getpixel (x, y);
}
if (c == mycolor)
break;
if (c != color) {
int dir2 = turnright (lookdir);
int mask = (1 << dir2) + (1 << turnright (dir2));
if (!(*calc & mask)) {
addstack (x, y, dir2, mycolor, periodicity);
}
color = c;
}
}
lookdir = turnleft (lookdir);
}
x = xp + dirrections[lookdir][0];
y = yp + dirrections[lookdir][1];
if (x >= xstart && x <= xend && y >= ystart && y <= yend) {
calc = calculated + x + y * CALCWIDTH;
if (!(*calc & (1 << lookdir))) {
*calc |= (1 << lookdir);
if (size < 10) {
addstack (x, y, lookdir, color, periodicity);
return;
} else {
xp = x;
yp = y;
dir = lookdir;
calc = calculated + xp + yp * CALCWIDTH;
}
} else
return;
} else
return;
}
}
