int HullLibrary::calchullgen(btVector3 *verts,int verts_count, int vlimit)
{
if(verts_count <4) return 0;
if(vlimit==0) vlimit=1000000000;
int j;
btVector3 bmin(*verts),bmax(*verts);
btAlignedObjectArray<int> isextreme;
isextreme.reserve(verts_count);
btAlignedObjectArray<int> allow;
allow.reserve(verts_count);
for(j=0;j<verts_count;j++)
{
allow.push_back(1);
isextreme.push_back(0);
bmin.setMin (verts[j]);
bmax.setMax (verts[j]);
}
btScalar epsilon = (bmax-bmin).length() * btScalar(0.001);
btAssert (epsilon != 0.0);
int4 p = FindSimplex(verts,verts_count,allow);
if(p.x==-1) return 0; // simplex failed
btVector3 center = (verts[p[0]]+verts[p[1]]+verts[p[2]]+verts[p[3]]) / btScalar(4.0); // a valid interior point
btHullTriangle *t0 = allocateTriangle(p[2],p[3],p[1]); t0->n=int3(2,3,1);
btHullTriangle *t1 = allocateTriangle(p[3],p[2],p[0]); t1->n=int3(3,2,0);
btHullTriangle *t2 = allocateTriangle(p[0],p[1],p[3]); t2->n=int3(0,1,3);
btHullTriangle *t3 = allocateTriangle(p[1],p[0],p[2]); t3->n=int3(1,0,2);
isextreme[p[0]]=isextreme[p[1]]=isextreme[p[2]]=isextreme[p[3]]=1;
checkit(t0);checkit(t1);checkit(t2);checkit(t3);
for(j=0;j<m_tris.size();j++)
{
btHullTriangle *t=m_tris[j];
btAssert(t);
btAssert(t->vmax<0);
btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
t->vmax = maxdirsterid(verts,verts_count,n,allow);
t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
}
btHullTriangle *te;
vlimit-=4;
while(vlimit >0 && ((te=extrudable(epsilon)) != 0))
{
int3 ti=*te;
int v=te->vmax;
btAssert(v != -1);
btAssert(!isextreme[v]); // wtf we've already done this vertex
isextreme[v]=1;
//if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already
j=m_tris.size();
while(j--) {
if(!m_tris[j]) continue;
int3 t=*m_tris[j];
if(above(verts,t,verts[v],btScalar(0.01)*epsilon))
{
extrude(m_tris[j],v);
}
}
// now check for those degenerate cases where we have a flipped triangle or a really skinny triangle
j=m_tris.size();
while(j--)
{
if(!m_tris[j]) continue;
if(!hasvert(*m_tris[j],v)) break;
int3 nt=*m_tris[j];
if(above(verts,nt,center,btScalar(0.01)*epsilon) || cross(verts[nt[1]]-verts[nt[0]],verts[nt[2]]-verts[nt[1]]).length()< epsilon*epsilon*btScalar(0.1) )
{
btHullTriangle *nb = m_tris[m_tris[j]->n[0]];
btAssert(nb);btAssert(!hasvert(*nb,v));btAssert(nb->id<j);
extrude(nb,v);
j=m_tris.size();
}
}
j=m_tris.size();
while(j--)
{
btHullTriangle *t=m_tris[j];
if(!t) continue;
if(t->vmax>=0) break;
btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
t->vmax = maxdirsterid(verts,verts_count,n,allow);
if(isextreme[t->vmax])
{
t->vmax=-1; // already done that vertex - algorithm needs to be able to terminate.
}
else
{
t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
}
}
vlimit --;
}
return 1;
}
void
show_text(TextNode *node, int Ender)
{
/*int twidth, len;*/
/*int otext_x, otext_y, t;*/
/*XFontStruct *old_font;*/
/*int old_color;*/
for (; node != NULL; node = node->next) {
switch (node->type) {
case 0:
case Beginitems:
case Begintitems:
case Bound:
case Center:
case Free:
case HSpace:
case Indent:
case Indentrel:
case Item:
case Macro:
case Mbox:
case Newline:
case Noop:
case Par:
case Pound:
case Rbrace:
case Space:
case Tab:
case Table:
case Titem:
case VSpace:
break;
case Dash:
case Fi:
case Ifcond:
if (visible(node->y, node->height)) {
if (strlen(node->data.text) > 1) {
XDrawLine(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC, node->x,
node->y + gRegionOffset + y_off
- gTopOfGroupStack->cur_font->descent -
word_off_height,
node->x + node->width,
node->y + gRegionOffset + y_off - word_off_height -
gTopOfGroupStack->cur_font->descent);
}
else {
XDrawString(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC, node->x, node->y +
gRegionOffset - gTopOfGroupStack->cur_font->descent + y_off,
node->data.text, 1);
}
}
else {
if (above(node->y))
need_scroll_up_button = 1;
else if (below(node->y))
need_scroll_down_button = 1;
}
break;
case Lsquarebrace:
case Math:
case Punctuation:
case Rsquarebrace:
case Spadsrctxt:
case WindowId:
case Word:
if (visible(node->y, node->height))
XDrawString(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC, node->x, node->y +
gRegionOffset - gTopOfGroupStack->cur_font->descent + y_off,
node->data.text, node->width);
else {
if (above(node->y))
need_scroll_up_button = 1;
else if (below(node->y))
need_scroll_down_button = 1;
}
break;
case Verbatim:
push_group_stack();
tt_top_group();
if (visible(node->y, node->height))
XDrawString(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC, node->x, node->y +
gRegionOffset - gTopOfGroupStack->cur_font->descent + y_off,
node->data.text, node->width);
else {
if (above(node->y))
need_scroll_up_button = 1;
else if (below(node->y))
need_scroll_down_button = 1;
}
pop_group_stack();
break;
case Horizontalline:
if (visible(node->y, node->height)) {
line_top_group();
XDrawLine(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC, 0,
node->y + gRegionOffset + y_off,
gWindow->width,
node->y + gRegionOffset + y_off);
pop_group_stack();
}
else {
if (above(node->y))
need_scroll_up_button = 1;
else if (below(node->y))
need_scroll_down_button = 1;
}
break;
case Box:
if (visible(node->y, node->height))
XDrawRectangle(gXDisplay, gWindow->fDisplayedWindow, gWindow->fStandardGC,
node->x,
node->y + gRegionOffset + y_off - node->height,
node->width,
node->height);
else {
if (above(node->y))
need_scroll_up_button = 1;
else if (below(node->y))
need_scroll_down_button = 1;
}
break;
case Downlink:
case Link:
case LispDownLink:
case LispMemoLink:
case Lispcommand:
case Lispcommandquit:
case Lisplink:
case Lispwindowlink:
case Memolink:
case Qspadcall:
case Qspadcallquit:
case Returnbutton:
case Spadcall:
case Spadcallquit:
case Spaddownlink:
case Spadlink:
case Spadmemolink:
case Unixcommand:
case Unixlink:
case Upbutton:
case Windowlink:
if (pix_visible(node->y, node->height))
show_link(node);
break;
case Spadcommand:
case Spadgraph:
case Spadsrc:
show_spadcommand(node);
break;
case Pastebutton:
if (visible(node->y, node->height))
show_pastebutton(node);
break;
case Paste:
show_paste(node);
break;
case Group:
case Tableitem:
push_group_stack();
break;
case Controlbitmap:
show_image(node, gWindow->fControlGC);
break;
case Inputbitmap:
show_image(node, gWindow->fStandardGC);
break;
case Inputpixmap:
show_image(node, gWindow->fStandardGC);
break;
case BoldFace:
bf_top_group();
break;
case Emphasize:
if (gTopOfGroupStack->cur_font == gRmFont)
em_top_group();
else
rm_top_group();
break;
case It:
em_top_group();
break;
case Sl:
case Rm:
rm_top_group();
break;
case Tt:
tt_top_group();
break;
case Inputstring:
show_input(node);
break;
case Radiobox:
case SimpleBox:
show_simple_box(node);
break;
case Beep:
LoudBeepAtTheUser();
break;
case Description:
bf_top_group();
break;
case Endspadsrc:
case Endspadcommand:
gInAxiomCommand = 1;
case Endtableitem:
case Enddescription:
case Endpastebutton:
case Endlink:
case Endbutton:
case Endgroup:
pop_group_stack();
case Endverbatim:
case Endmath:
case Endbox:
case Endtable:
case Endmbox:
case Endparameter:
case Endpaste:
case Endinputbox:
case Endcenter:
case Endmacro:
case Endif:
case Endtitems:
case Enditems:
/*
* Now since I can show specific regions of the text, then at
* this point I should check to see if I am the end
*/
if (node->type == Ender)
return;
break;
case Endfooter:
case Endscrolling:
case Endheader:
case Endtitle:
/*
* regardless of what ender I have, I always terminate showing
* with one of these
*/
return;
default:
fprintf(stderr, "Show_text: Unknown Node Type %d\n", node->type);
break;
}
}
}
void Manager::createTitle()
{
leftButtonList_.clear();
rightButtonList_.clear();
TQString buttons;
if (options()->customButtonPositions())
buttons = options()->titleButtonsLeft() + "|" +
options()->titleButtonsRight();
else
buttons = "XSH|IA";
TQPtrList<Button> *buttonList = &leftButtonList_;
for (unsigned int i = 0; i < buttons.length(); ++i)
{
Button * tb = NULL;
switch (buttons[i].latin1())
{
case 'S': // Sticky
tb = new StickyButton(widget());
connect(this, TQT_SIGNAL(stickyChanged(bool)),
tb, TQT_SLOT(setOn(bool)));
connect(tb, TQT_SIGNAL(toggleSticky()), this, TQT_SLOT(slotToggleSticky()));
emit(stickyChanged(isOnAllDesktops()));
break;
case 'H': // Help
if (providesContextHelp())
{
tb = new HelpButton(widget());
connect(tb, TQT_SIGNAL(help()), this, TQT_SLOT(showContextHelp()));
}
break;
case 'I': // Minimize
if (isMinimizable())
{
tb = new IconifyButton(widget());
connect(tb, TQT_SIGNAL(iconify()), this, TQT_SLOT(minimize()));
}
break;
case 'A': // Maximize
if (isMaximizable())
{
tb = new MaximiseButton(widget());
connect(tb, TQT_SIGNAL(maximizeClicked(ButtonState)),
this, TQT_SLOT(slotMaximizeClicked(ButtonState)));
connect(this, TQT_SIGNAL(maximizeChanged(bool)),
tb, TQT_SLOT(setOn(bool)));
emit(maximizeChanged(maximizeMode() == MaximizeFull));
}
break;
case 'F': // Above
tb = new AboveButton(widget());
connect(tb, TQT_SIGNAL(above()), this, TQT_SLOT(slotAbove()));
break;
case 'B': // Lower
tb = new LowerButton(widget());
connect(tb, TQT_SIGNAL(lower()), this, TQT_SLOT(slotLower()));
break;
case 'X': // Close
if (isCloseable())
{
tb = new CloseButton(widget());
connect(tb, TQT_SIGNAL(closeWindow()), this, TQT_SLOT(closeWindow()));
}
break;
case '|':
buttonList = &rightButtonList_;
break;
}
if (tb != NULL)
{
connect(this, TQT_SIGNAL(activeChanged(bool)), tb, TQT_SLOT(setActive(bool)));
buttonList->append(tb);
}
}
int make_wu_headers(std::vector<dr2_compact_block_t> &tapebuffer, telescope_id
tel, std::vector<workunit> &wuheader) {
int procid=getpid();
double receiver_freq;
int bandno;
FILE *tmpfile;
char tmpstr[256];
char buf[64];
static const receiver_config &r(rcvr);
static const settings &s(splitter_settings);
bool group_is_vlar;
if (!strncmp(s.splitter_cfg->data_type,"encoded",
std::min(static_cast<size_t>(7),sizeof(s.splitter_cfg->data_type)))) {
noencode=0;
} else {
noencode=1;
}
tapebuffer[0].header.samplerate*=1e+6;
seconds sample_time(1.0/tapebuffer[0].header.samplerate);
seti_time start_time(tapebuffer[0].header.data_time
-tapebuffer[0].data.size()*0.5*sample_time);
seti_time end_time(tapebuffer[tapebuffer.size()-1].header.data_time);
workunit_grp wugrp;
sprintf(wugrp.name,"%s.%ld.%d.%d.%d",
tapebuffer[0].header.name,
procid,
tapebuffer[0].header.dataseq,
tel-AO_430,
s.id);
wugrp.receiver_cfg=r;
wugrp.recorder_cfg=s.recorder_cfg;
wugrp.splitter_cfg=s.splitter_cfg;
wugrp.analysis_cfg=s.analysis_cfg;
wugrp.data_desc.nsamples=NSAMPLES;
wugrp.data_desc.true_angle_range=0;
coordinate_t start_coord(cmap_interp(coord_history,start_time));
coordinate_t end_coord(cmap_interp(coord_history,end_time));
wugrp.data_desc.start_ra=start_coord.ra;
wugrp.data_desc.end_ra=end_coord.ra;
wugrp.data_desc.start_dec=start_coord.dec;
wugrp.data_desc.end_dec=end_coord.dec;
coordinate_t last_coord=start_coord;
double sample_rate=tapebuffer[0].header.samplerate/NSTRIPS;
// find the bracketing entries in the coordinate history
std::map<seti_time,coordinate_t>::iterator above(coord_history.upper_bound(end_time));
std::map<seti_time,coordinate_t>::iterator below(coord_history.lower_bound(start_time));
std::map<seti_time,coordinate_t>::iterator p;
if (above==coord_history.begin()) {
above++;
}
if (below==coord_history.end()) {
below=above;
below--;
}
if (above==below) {
below--;
}
// Calculate the angular distance the beam has traveled
for (p=below;p!=above;p++)
{
wugrp.data_desc.true_angle_range+=angdist(last_coord,p->second);
last_coord=p->second;
}
wugrp.data_desc.true_angle_range+=angdist(last_coord,end_coord);
if (wugrp.data_desc.true_angle_range==0) wugrp.data_desc.true_angle_range=1e-10;
// Calculate the number of unique signals that could be found in a workunit.
// We will use these numbers to calculate thresholds.
double numgauss=2.36368e+08/std::min(wugrp.data_desc.true_angle_range,10.0);
double numpulse=std::min(4.52067e+10/std::min(wugrp.data_desc.true_angle_range,10.0),2.00382e+11);
double numtrip=std::min(3.25215e+12/std::min(wugrp.data_desc.true_angle_range,10.0),1.44774e+13);
// check for VLAR workunits
if (wugrp.data_desc.true_angle_range < 0.12) {
group_is_vlar=true;
} else {
group_is_vlar=false;
}
// if (useanalysiscfgid > 0) {
// log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL,"Re-reading analysis cfg id: %d (set by user):\n",useanalysiscfgid);
// s.analysis_cfg = useanalysiscfgid;
// }
// Calculate a unique key to describe this analysis config.
long keyuniq=floor(std::min(wugrp.data_desc.true_angle_range*100,1000.0)+0.5)+
s.analysis_cfg.id*1024;
if ((keyuniq>((s.analysis_cfg.id+1)*1024)) ||(keyuniq<(s.analysis_cfg.id)*1024)) {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"Invalid keyuniq value!\n");
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"%d %d %f\n",keyuniq,s.analysis_cfg.id,wugrp.data_desc.true_angle_range);
exit(1);
}
keyuniq*=-1;
long save_keyuniq=keyuniq;
splitter_settings.analysis_cfg=wugrp.analysis_cfg;
sprintf(tmpstr,"where keyuniq=%d",keyuniq);
// Check if we've already done this analysis_config...
// Fetch through splitter_settings, since it's alias (s) is const.
splitter_settings.analysis_cfg.id=0;
splitter_settings.analysis_cfg->fetch(tmpstr);
if (s.analysis_cfg->id==0) {
if (keyuniq != save_keyuniq) {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"keyuniq value changed!\n");
exit(1);
}
// If not calculate the thresholds based upon the input analysis_config
// Triplets are distributed exponentially...
wugrp.analysis_cfg->triplet_thresh+=(log(numtrip)-29.0652);
// Gaussians are based upon chisqr...
double p_gauss=lcgf(32.0,wugrp.analysis_cfg->gauss_null_chi_sq_thresh*32.0);
p_gauss-=(log(numgauss)-19.5358);
wugrp.analysis_cfg->gauss_null_chi_sq_thresh=invert_lcgf(p_gauss,32,1e-4)*0.03125;
// Pulses thresholds are log of the probability
wugrp.analysis_cfg->pulse_thresh+=(log(numpulse)-24.7894);
wugrp.analysis_cfg->keyuniq=keyuniq;
wugrp.analysis_cfg->insert();
} else {
wugrp.analysis_cfg=s.analysis_cfg;
}
strlcpy(wugrp.data_desc.time_recorded,
short_jd_string(start_time.jd().uval()),
sizeof(wugrp.data_desc.time_recorded));
wugrp.data_desc.time_recorded_jd=start_time.jd().uval();
wugrp.data_desc.coords.clear();
wugrp.data_desc.coords.push_back(start_coord);
for (p=below;p!=above;p++)
{
wugrp.data_desc.coords.push_back(p->second);
}
wugrp.data_desc.coords.push_back(end_coord);
wugrp.tape_info->id=0;
sprintf(buf,"%d",tel-AO_ALFA_0_0);
wugrp.tape_info->fetch(std::string("where name=\'")+tapebuffer[0].header.name+"\' and beam="+buf);
wugrp.tape_info->start_time=tapebuffer[0].header.data_time.jd().uval();
wugrp.tape_info->last_block_time=wugrp.tape_info->start_time;
wugrp.tape_info->last_block_done=tapebuffer[0].header.dataseq;
wugrp.tape_info->beam=tel-AO_ALFA_0_0;
if (!nodb) {
if (wugrp.tape_info.id) {
if (!(wugrp.tape_info->update())) {
char buf[1024];
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"%s",sql_error_message());
exit(1);
}
} else {
strlcpy(wugrp.tape_info->name,tapebuffer[0].header.name,sizeof(wugrp.tape_info->name));
wugrp.tape_info->insert();
}
}
if (!nodb) {
sqlint8_t wgid;
if ((wgid=wugrp.insert())<=0) {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"Workunit_grp insert failed\nwgid=%d\nSQLCODE=%d\nLAST_NON_ZERO_SQLCODE=%d\n",wgid,sql_error_code(),sql_last_error_code());
exit( 1 );
}
wugrp.id=wgid;
}
int i;
wu_database_id.resize(NSTRIPS);
bin_data.resize(NSTRIPS);
wuheader.resize(NSTRIPS);
for (i=0;i<NSTRIPS;i++) {
bin_data[i].clear();
wuheader[i].group_info=wugrp;
wuheader[i].group_info.id=wugrp.id;
sprintf(wuheader[i].name,"%s.%ld.%d.%ld.%d.%d",tapebuffer[0].header.name,
procid, tapebuffer[0].header.dataseq,
tel-AO_430,s.id,i);
if (group_is_vlar) {
strlcat(wuheader[i].name,".vlar",sizeof(wuheader[i].name));
}
wuheader[i].subband_desc.sample_rate=tapebuffer[0].header.samplerate/NSTRIPS;
receiver_freq=tapebuffer[0].header.sky_freq;
bandno=((i+NSTRIPS/2)%NSTRIPS)-NSTRIPS/2;
wuheader[i].subband_desc.base=receiver_freq+
(double)(bandno)*wuheader[i].subband_desc.sample_rate;
wuheader[i].subband_desc.center=receiver_freq+wuheader[i].subband_desc.sample_rate*NSTRIPS*((double)IFFT_LEN*bandno/FFT_LEN+(double)IFFT_LEN/(2*FFT_LEN)-1.0/(2*FFT_LEN));
wuheader[i].subband_desc.number=i;
if (!nodb ) {
if (!(wu_database_id[i]=wuheader[i].id=wuheader[i].insert())) {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"Database error in make_wu_headers()\n");
exit(EXIT_FAILURE);
}
}
sprintf(tmpstr,"./wu_inbox/%s",wuheader[i].name);
if ((tmpfile=fopen(tmpstr,"w"))) {
fprintf(tmpfile,"<workunit>\n");
fprintf(tmpfile,wuheader[i].print_xml().c_str());
fclose(tmpfile);
} else {
log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL,"Unable to open file ./wu_inbox/%s, errno=%d\n",wuheader[i].name,errno);
exit(1);
}
bin_data[i].reserve(wuheaders[i].group_info->recorder_cfg->bits_per_sample*
wuheaders[i].group_info->data_desc.nsamples/8);
}
return(1);
}
ColoredPoint PerPoint(ColoredPoint p, const WaveformContext context) {
meanbass = 0.01*(meanbass*99+context.music->bass);
meantreb = 0.01*(meantreb*99+context.music->treb);
meanmid = 0.01*(meanmid*99+context.music->mid);
float bassdiff = (context.music->bass - meanbass)*15;
float trebdiff = (context.music->treb - meantreb)*15;
float middiff = (context.music->mid - meanmid)*15;
float ba = min(above(bassdiff,0)*bassdiff*.005,.11);
float tr = min(above(trebdiff,0)*trebdiff*.005,.11);
float mi = min(above(middiff,0)*middiff*.005,.11);
mi2_prg = mi2_prg+mi;
gam = abs(gam-above(mi2_prg,5));
mi2_prg= if_milk(above(mi2_prg,5),0,mi2_prg);
float s = context.sample_int;
//Gambe
p.x= if_milk(equal(int(s),1),.4,.4);
p.y= if_milk(equal(int(s),1),.2+((ba+tr)*.5)*gam,.2+((ba+tr)*.5)*gam);
p.x= if_milk(equal(int(s),2),.5+sin(ba*100)*.03,p.x);
p.y= if_milk(equal(int(s),2),.4,p.y);
p.x= if_milk(equal(int(s),3),.6,p.x);
p.y= if_milk(equal(int(s),3),.2+((ba+tr)*.5)*(1-gam),p.y);
p.x= if_milk(equal(int(s),4),.5+sin(ba*100)*.03,p.x);
p.y= if_milk(equal(int(s),4),.4,p.y);
//Corpo
p.x= if_milk(equal(int(s),5),.5,p.x);
p.y= if_milk(equal(int(s),5),.6,p.y);
//Braccia
p.x= if_milk(equal(int(s),6),.4-mi*.23,p.x);
p.y= if_milk(equal(int(s),6),.5+mi,p.y);
p.x= if_milk(equal(int(s),7),.5,p.x);
p.y= if_milk(equal(int(s),7),.6,p.y);
p.x= if_milk(equal(int(s),8),.6+tr*.23,p.x);
p.y= if_milk(equal(int(s),8),.5+tr,p.y);
p.x= if_milk(equal(int(s),9),.5,p.x);
p.y= if_milk(equal(int(s),9),.6,p.y);
//Testa
p.x= if_milk(equal(int(s),10),.5,p.x);
p.y= if_milk(equal(int(s),10),.62,p.y);
p.x= if_milk(equal(int(s),11),.47-ba*.23,p.x);
p.y= if_milk(equal(int(s),11),.62,p.y);
p.x= if_milk(equal(int(s),12),.47-ba*.23,p.x);
p.y= if_milk(equal(int(s),12),.67+ba*.23,p.y);
p.x= if_milk(equal(int(s),13),.53+ba*.23,p.x);
p.y= if_milk(equal(int(s),13),.67+ba*.23,p.y);
p.x= if_milk(equal(int(s),14),.53+ba*.23,p.x);
p.y= if_milk(equal(int(s),14),.62,p.y);
p.x= if_milk(equal(int(s),15),.50,p.x);
p.y= if_milk(equal(int(s),15),.62,p.y);
mi_prg= if_milk(above(mi_prg,5),0,mi_prg+mi*.1);
ba_prg= if_milk(above(ba_prg,5),0,ba_prg+ba*.1);
tr_prg= if_milk(above(tr_prg,5),0,tr_prg+tr*.1);
float temp_dim = dim + 0.2 * sin(mi_prg + rand_offset1);
float temp_xpos = xpos + 0.2 * cos(ba_prg + rand_offset2);
float temp_ypos = ypos + 0.2* sin(tr_prg + rand_offset3);
p.x=p.x*temp_dim+temp_xpos;
p.y=p.y*temp_dim+temp_ypos;
float hm=context.sample+mi2_prg;
float ht=context.sample+tr_prg;
float hb=context.sample+ba_prg;
p.r=hm;
p.g=ht;
p.b=hb;
p.a=.8;
return p;
}
bool operator > ( const Ptr < T > & p ) const
{ return above ( p ); }
bool operator <= ( const Ptr < T > & p ) const
{ return ! above ( p ); }
int main(int argc,char *argv[])
{
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&p);
MPI_Comm_rank(MPI_COMM_WORLD,&pid);
int i,j,k,i1,j1;
start_time=MPI_Wtime();
if(pid==0)
{
printf("There are %d processors\n",p);
}
start= n/(p-1)*pid;
end= min(start+p-2,n-1);
init();
printf(" Processor %d takes from %d to %d",pid,start,end);
above();
below();
for(k=0;k<10;k++)
{
printf("iter : %d\n",k);
above();
below();
for(i=start;i<=end;i++)
{
for(j=0;j<n;j++)
{
if((i==0)||(j==0)||(i==(n-1))||(j==(n-1)))
continue;
else if(i==start)
arr[0][i-1][j]=t[j];
else if(i==end)
arr[0][i+1][j]=b[j];
else
arr[1][i][j]=(4*arr[0][i][j]+2*(arr[0][i+1][j]+arr[0][i-1][j])+2*(arr[0][i][j+1]+arr[0][i][j-1])+arr[0][i+1][j+1]+arr[0][i-1][j-1]);
for(i1=start;i1<=end;i1++)
for(j1=0;j1<n;j1++)
arr[0][i1][j1]=arr[1][i1][j1];
}
}
MPI_Barrier(MPI_COMM_WORLD);
}
printf("\n");
/*for(i=start;i<=end;i++)
{
printf("\n");
for(j=0;j<n;j++)
printf("arr0:%lf arr1:%lf pid:%d\t",arr[0][i][j],arr[1][i][j],pid);
}*/
printf("\n");
end_time=MPI_Wtime();
if(pid==0)
printf("\nTime taken is %lf",end_time-start_time);
MPI_Finalize();
return 0;
}
