global.loops.perpoint.h

Go to the documentation of this file.

// check for existence in bad form using:
// grep "PLOOP" *.c | grep --invert-match "PLOOP("

// After conversion to PLOOP(pliter,pl) form, regexp to help replace:
// Too unsafe to include () or "\ " in []'s below -- catch afterwards rather than mis-replace
// Note, can't look for " PLOOP(..." since may be tab instead
// 1) PLOOP(\([-_>a-zA-Z0-9+]+\)) -> PLOOP(pliter,\1)
//    Start with longest name and work to smaller:
//    PFLUXBOUNDLOOP [none apparently]
//    PNOTINTERPLOOP [1]
//    PINTERPLOOP [some]
//    PBOUNDLOOP [several]
//    PDUMPLOOP [several]
//    PINVERTLOOP [none]
//    NUMPRIMLOOP [several]
//    PLOOP
//
// 2) Rename: NUMPRIMLOOPGEN -> NUMPRIMLOOP
//            PLOOPINTERP -> PINTERPLOOP
//            PLOOPNOTINTERP -> PNOTINTERPLOOP
//
// 3) Provide the additional variable:
//
//    regexp:
//             int pl -> int pl,pliter;
//             int dir,pl,sc -> int dir,pl,pliter,sc
//             int i,j,k,pl; -> int i,j,k,pl,pliter;
//             int dir,pl; -> int dir,pl,pliter;
//             int i, j, k, pl, l -> int i, j, k, pl, pliter, l
//             int pl,i,j,k; -> int pl,pliter,i,j,k;
//             int i, j, k, pl; -> int i,j,k,pl,pliter;
//             int i,j,k,l,pl; -> int i,j,k,l,pl,pliter;
//             int i, pl; -> int i,pl,pliter;
//             int i,j,k,pl,l; -> int i,j,k,pl,pliter,l;
//             int l,pl,dir; -> int l,pl,pliter,dir;
//
#if(1) // for now always control interpolated quantities (used to be only for SLPITNPR)

#define PLOOP(pliter,pl) for(pliter=nprstart,pl=nprlist[pliter];pliter<=nprend;pliter++,pl=nprlist[pliter])
//SUPERGODMARK
#define PRIMLOOP(pliter,pl) PLOOP(pliter,pl)
#define PINTERPLOOP(pliter,pl) for(pliter=npr2interpstart,pl=npr2interplist[pliter];pliter<=npr2interpend;pliter++,pl=npr2interplist[pliter])
#define PNOTINTERPLOOP(pliter,pl) for(pliter=npr2notinterpstart,pl=npr2notinterplist[pliter];pliter<=npr2notinterpend;pliter++,pl=npr2notinterplist[pliter])

#define PBOUNDLOOP(pliter,pl) for(pliter=nprboundstart,pl=nprboundlist[pliter];pliter<=nprboundend;pliter++,pl=nprboundlist[pliter])

#define PFLUXBOUNDLOOP(pliter,pl) for(pliter=nprfluxboundstart,pl=nprfluxboundlist[pliter];pliter<=nprfluxboundend;pliter++,pl=nprfluxboundlist[pliter])

#define PDUMPLOOP(pliter,pd) for(pliter=nprdumpstart,pd=nprdumplist[pliter];pliter<=nprdumpend;pliter++,pd=nprdumplist[pliter])

#define PINVERTLOOP(pliter,pi) for(pliter=nprinvertstart,pl=nprinvertlist[pliter];pliter<=nprinvertend;pliter++,pl=nprinvertlist[pliter])


#define NUMPRIMLOOP(pliter,pl) for(pliter=nprlocalstart,pl=nprlocallist[pliter];pliter<=nprlocalend;pliter++,pl=nprlocallist[pliter])





#else


#define PLOOP(pliter,pl) for(pl=0;pl<NPR;pl++) // original

#define PINTERPLOOP(pliter,pl) for(pl=0;pl<NPR2INTERP;pl++)
#define PNOTINTERPLOOP(pliter,pl) for(pl=0;pl<0;pl++) // do nothing

#define PBOUNDLOOP(pliter,pb) for(pb=0;pb<NPRBOUND;pb++)

#define PDUMPLOOP(pliter,pd) for(pd=0;pd<NPRDUMP;pd++)

#define PINVERTLOOP(pliter,pi) for(pi=0;pi<NPRINVERT;pi++)

#define NUMPRIMLOOP(pliter,pl) for(pl=0;pl<numprims;pl++)



#endif




#define PALLLOOP(pl) for(pl=0;pl<NPR;pl++)
#define PALLLOOPSPECIAL(pl,special) for(pl=0;pl<NPR+special;pl++)

#define PLOOPSPECIALONLY(pl,special) for(pl=NPR;pl<NPR+special;pl++)


#define PALLREALLOOP(pl) for(pl=0;pl<NPRREALSET;pl++)


#define PMAXNPRLOOP(pl) for(pl=0;pl<MAXNPR;pl++)

#define PLOOPALLINVERT(pl) for(pl=0;pl<=B3;pl++)

#define PLOOPALLINTERP(pl) for(pl=0;pl<NPR2INTERP;pl++)


#define PDIAGLOOP(pl) PALLLOOP(pl)





#define PLOOPNOB1(pl) for(pl=0;pl<B1;pl++)
#define PLOOPBONLY(pl) for(pl=B1;pl<=B3;pl++)
#define PLOOPNOB2(pl) for(pl=B3+1;pl<NPR;pl++)
#define PLOOPNOB2SPECIAL(pl,special) for(pl=B3+1;pl<NPR+special;pl++)


#define PLOOPRADONLY(pl) for(pl=PRAD0;pl<=PRAD3;pl++)



#define DLOOP(j,k) for(j=0;j<NDIM;j++)for(k=0;k<NDIM;k++)

#define DLOOPA(j) for(j=0;j<NDIM;j++)

#define SLOOP(j,k) for(j=1;j<NDIM;j++)for(k=1;k<NDIM;k++)

#define SLOOPA(j) for(j=1;j<NDIM;j++)

#define DSLOOP(j,k) for(j=0;j<NDIM;j++)for(k=1;k<NDIM;k++)

#define SSLOOP(j,k) for(j=1;j<NDIM;j++)for(k=1;k<NDIM;k++)

#define SDLOOP(j,k) for(j=1;j<NDIM;j++)for(k=0;k<NDIM;k++)

#define DIRLOOP(dir) for(dir=0;dir<COMPDIM*2;dir++)

#define DIRSIGNLOOP(dirsign) for(dirsign=-1;dirsign<=1;dirsign+=2)


#define DIMENLOOP(dir) for(dir=1;dir<=COMPDIM;dir++)


#define GRIDLOOP(gridpos) for(gridpos=0;gridpos<NPG;gridpos++)





#define FBOUNDLOOP(ff) for(ff=0;ff<NUMPFLAGSBOUND;ff++)

#define JETLOOP(jetio) for(jetio=0;jetio<NUMJETS;jetio++)

#define ENERREGIONLOOP(enerregion) for(enerregion=0;enerregion<NUMENERREGIONS;enerregion++) if(dothisenerreg[enerregion])

#define ENERREGIONALLLOOP(enerregion) for(enerregion=0;enerregion<NUMENERREGIONS;enerregion++)

#define FLOORLOOP(floor) for(floor=0;floor<NUMFAILFLOORFLAGS;floor++)

#define TSCALELOOP(tscale) for(tscale=0;tscale<NUMTSCALES;tscale++)


#define SCLOOP(sc) for(sc=0;sc<NUMSOURCES;sc++)

#define SCPHYSICSLOOP(sc) for(sc=GEOMSOURCE+1;sc<NUMSOURCES;sc++)

#define FLLOOP(fl) for(fl=0;fl<NUMFLUXTERMS;fl++)


#define PFLAGLOOP(pf) for(pf=0;pf<NUMPFLAGS;pf++)

#define FAILPFLAGLOOP(pf) for(pf=0;pf<NUMFAILPFLAGS;pf++)

#define ROMIOCOLLOOP(romiocoliter) for(romiocoliter=0;romiocoliter<romiocloopend;romiocoliter++)

#define BUFFERINIT nextbuf=0
#define COLINIT nextcol=0

#define COLLOOP(coliter) for(coliter=0;coliter<numfiles;coliter++)


#define DTSTAGELOOP(dtstage) for(dtstage=0;dtstage<MAXITERDTSTAGES;dtstage++)

#define INTERPENOTYPELOOP(interpi) for(interpi=0;interpi<NUMENOINTERPTYPES;interpi++)

#define ENODEBUGLOOP(enodebugi) for(enodebugi=0;enodebugi<NUMENODEBUGS;enodebugi++)

#define FINALSTEPLOOP(indexfinalstep) for(indexfinalstep=0;indexfinalstep<=1;indexfinalstep++)

#define FAILFLOORLOOP(indexfinalstep,tscale,floor) FINALSTEPLOOP(indexfinalstep) TSCALELOOP(tscale) FLOORLOOP(floor)