void I2D_PenalizationOperator::perform_timestep(Real dt)
{
vector<BlockInfo> vInfo = grid.getBlocksInfo();
BoundaryInfo& binfo=grid.getBoundaryInfo();
const BlockCollection<B>& coll = grid.getBlockCollection();
if (desired_velocities == NULL)
{
Penalization penalization(dt, lambda, Uinf);
block_processing.process(vInfo, coll, penalization);
}
else
{
PenalizationCustomizedVelocity penalization(dt, lambda, *desired_velocities, Uinf);
block_processing.process(vInfo, coll, penalization);
desired_velocities = NULL;
}
CurlDiff_4thOrder curl_diff;
block_processing.process< I2D_VectorBlockLab< Streamer_Velocity, 2 >::Lab >(vInfo, coll, binfo, curl_diff);
UpdateVelocities update;
block_processing.process(vInfo, coll, update);
}
void extremaltdsgnmat(int *covmod, double *data, double *dist, int *nSite, int *nObs, int *dim,
int *weighted, double *weights, double *locdsgnmat, double *locpenmat,
int *nloccoeff, int *npparloc, double *locpenalty, double *scaledsgnmat,
double *scalepenmat, int *nscalecoeff, int *npparscale,
double *scalepenalty, double *shapedsgnmat, double *shapepenmat,
int *nshapecoeff, int *npparshape, double *shapepenalty, int *usetempcov,
double *tempdsgnmatloc, double *temppenmatloc, int *ntempcoeffloc,
int *nppartempcoeffloc, double *temppenaltyloc, double *tempdsgnmatscale,
double *temppenmatscale, int *ntempcoeffscale, int *nppartempcoeffscale,
double *temppenaltyscale, double *tempdsgnmatshape, double *temppenmatshape,
int *ntempcoeffshape, int *nppartempcoeffshape, double *temppenaltyshape,
double *loccoeff, double *scalecoeff, double *shapecoeff,
double *tempcoeffloc, double *tempcoeffscale, double *tempcoeffshape,
double *nugget, double *range, double *smooth, double *smooth2, double *df,
double *dns){
//This is the extremal t model. It's named xxxdsgnmat as either linear
//models or p-splines are used for the gev parameters.
const int nPairs = *nSite * (*nSite - 1) / 2;
int flag = usetempcov[0] + usetempcov[1] + usetempcov[2];
double *trendlocs = malloc(*nObs * sizeof(double)),
*trendscales = malloc(*nObs * sizeof(double)),
*trendshapes = malloc(*nObs * sizeof(double)),
*jac = malloc(*nSite * *nObs * sizeof(double)),
*rho = malloc(nPairs * sizeof(double)),
*locs = malloc(*nSite * sizeof(double)),
*scales = malloc(*nSite * sizeof(double)),
*shapes = malloc(*nSite * sizeof(double)),
*frech = malloc(*nSite * *nObs * sizeof(double));
if (*df <= 0){
*dns = (1 - *df) * (1 - *df) * MINF;
return;
}
/*else if (*df >= 15){
*dns = (*df - 14) * (*df - 14) * MINF;
return;
}*/
if (*nugget >= 1){
*dns = *nugget * *nugget * MINF;
return;
}
//Stage 1: Compute the covariance at each location
switch (*covmod){
case 1:
*dns = whittleMatern(dist, nPairs, *nugget, 1 - *nugget, *range, *smooth, rho);
break;
case 2:
*dns = cauchy(dist, nPairs, *nugget, 1 - *nugget, *range, *smooth, rho);
break;
case 3:
*dns = powerExp(dist, nPairs, *nugget, 1 - *nugget, *range, *smooth, rho);
break;
case 4:
*dns = bessel(dist, nPairs, *dim, *nugget, 1 - *nugget, *range, *smooth, rho);
break;
case 5:
*dns = caugen(dist, nPairs, *nugget, 1 - *nugget, *range, *smooth, *smooth2, rho);
break;
}
if (*dns != 0)
return;
//Stage 2: Computing the GEV parameters using the design matrix
*dns = dsgnmat2Param(locdsgnmat, scaledsgnmat, shapedsgnmat, loccoeff, scalecoeff, shapecoeff,
*nSite, *nloccoeff, *nscalecoeff, *nshapecoeff, locs, scales, shapes);
if (flag){
dsgnmat2temptrend(tempdsgnmatloc, tempdsgnmatscale, tempdsgnmatshape, tempcoeffloc,
tempcoeffscale, tempcoeffshape, *nSite, *nObs, usetempcov, *ntempcoeffloc,
*ntempcoeffscale, *ntempcoeffshape, trendlocs, trendscales, trendshapes);
for (int i=0;i<*nSite;i++)
for (int j=0;j<*nObs;j++)
if (((scales[i] + trendscales[j]) <= 0) || ((shapes[i] + trendshapes[j]) <= -1)){
*dns = MINF;
return;
}
}
else if (*dns != 0.0)
return;
//Stage 3: Transformation to unit Frechet
if (flag)
*dns = gev2frechTrend(data, *nObs, *nSite, locs, scales, shapes, trendlocs, trendscales,
trendshapes, jac, frech);
else
*dns = gev2frech(data, *nObs, *nSite, locs, scales, shapes, jac, frech);
if (*dns != 0.0)
return;
if (*weighted)
*dns = wlplikextremalt(frech, rho, *df, jac, *nObs, *nSite, weights);
else
*dns = lplikextremalt(frech, rho, *df, jac, *nObs, *nSite);
//Stage 5: Removing the penalizing terms (if any)
// 1- For the location parameter
if (*locpenalty > 0)
*dns -= penalization(locpenmat, loccoeff, *locpenalty, *nloccoeff, *npparloc);
// 2- For the scale parameter
if (*scalepenalty > 0)
*dns -= penalization(scalepenmat, scalecoeff, *scalepenalty, *nscalecoeff, *npparscale);
// 3- For the shape parameter
if (*shapepenalty > 0)
*dns -= penalization(shapepenmat, shapecoeff, *shapepenalty, *nshapecoeff, *npparshape);
// 4- Doing the same thing for the temporal component
if (*temppenaltyloc > 0)
*dns -= penalization(temppenmatloc, tempcoeffloc, *temppenaltyloc, *ntempcoeffloc,
*nppartempcoeffloc);
if (*temppenaltyscale > 0)
*dns -= penalization(temppenmatscale, tempcoeffscale, *temppenaltyscale, *ntempcoeffscale,
*nppartempcoeffscale);
if (*temppenaltyshape > 0)
*dns -= penalization(temppenmatshape, tempcoeffshape, *temppenaltyshape, *ntempcoeffshape,
*nppartempcoeffshape);
// 4- Doing the same thing for the temporal component
if (*temppenaltyloc > 0)
*dns -= penalization(temppenmatloc, tempcoeffloc, *temppenaltyloc, *ntempcoeffloc,
*nppartempcoeffloc);
if (*temppenaltyscale > 0)
*dns -= penalization(temppenmatscale, tempcoeffscale, *temppenaltyscale, *ntempcoeffscale,
*nppartempcoeffscale);
if (*temppenaltyshape > 0)
*dns -= penalization(temppenmatshape, tempcoeffshape, *temppenaltyshape, *ntempcoeffshape,
*nppartempcoeffshape);
free(trendlocs); free(trendscales); free(trendshapes); free(jac); free(rho); free(locs);
free(scales); free(shapes); free(frech);
return;
}
void smithdsgnmat3d(double *data, double *distVec, int *nSite, int *nObs, int *weighted,
double *weights, double *locdsgnmat, double *locpenmat, int *nloccoeff,
int *npparloc, double *locpenalty, double *scaledsgnmat,
double *scalepenmat, int *nscalecoeff, int *npparscale,
double *scalepenalty, double *shapedsgnmat, double *shapepenmat,
int *nshapecoeff, int *npparshape, double *shapepenalty, int *usetempcov,
double *tempdsgnmatloc, double *temppenmatloc, int *ntempcoeffloc,
int *nppartempcoeffloc, double *temppenaltyloc, double *tempdsgnmatscale,
double *temppenmatscale, int *ntempcoeffscale, int *nppartempcoeffscale,
double *temppenaltyscale, double *tempdsgnmatshape, double *temppenmatshape,
int *ntempcoeffshape, int *nppartempcoeffshape, double *temppenaltyshape,
double *loccoeff, double *scalecoeff, double *shapecoeff, double *tempcoeffloc,
double *tempcoeffscale, double *tempcoeffshape, double *cov11, double *cov12,
double *cov13, double *cov22, double *cov23, double *cov33, double *dns){
//This is the Smith's model - 3d case. It's named xxxdsgnmat as
//either linear models or p-splines are used for the gev parameters.
const int nPairs = *nSite * (*nSite - 1) / 2;
int flag = usetempcov[0] + usetempcov[1] + usetempcov[2];
double *jac, *mahalDist, *locs, *scales, *shapes, *frech, *trendlocs, *trendscales,
*trendshapes;
jac = (double *)R_alloc(*nSite * *nObs, sizeof(double));
mahalDist = (double *)R_alloc(nPairs, sizeof(double));
locs = (double *)R_alloc(*nSite, sizeof(double));
scales = (double *)R_alloc(*nSite, sizeof(double));
shapes = (double *)R_alloc(*nSite, sizeof(double));
frech = (double *)R_alloc(*nSite * *nObs, sizeof(double));
//Stage 1: Computing the Mahalanobis distance
*dns = mahalDistFct3d(distVec, nPairs, cov11, cov12, cov13,
cov22, cov23, cov33, mahalDist);
if (*dns != 0.0)
return;
//Stage 2: Computing the GEV parameters using the design matrix
*dns = dsgnmat2Param(locdsgnmat, scaledsgnmat, shapedsgnmat,
loccoeff, scalecoeff, shapecoeff, *nSite,
*nloccoeff, *nscalecoeff, *nshapecoeff,
locs, scales, shapes);
if (flag){
int i, j;
trendlocs = (double *)R_alloc(*nObs, sizeof(double));
trendscales = (double *)R_alloc(*nObs, sizeof(double));
trendshapes = (double *)R_alloc(*nObs, sizeof(double));
dsgnmat2temptrend(tempdsgnmatloc, tempdsgnmatscale, tempdsgnmatshape, tempcoeffloc,
tempcoeffscale, tempcoeffshape, *nSite, *nObs, usetempcov, *ntempcoeffloc,
*ntempcoeffscale, *ntempcoeffshape, trendlocs, trendscales, trendshapes);
for (i=*nSite;i--;)
for (j=*nObs;j--;)
if (((scales[i] + trendscales[j]) <= 0) || ((shapes[i] + trendshapes[j]) <= -1)){
*dns = MINF;
return;
}
}
else if (*dns != 0.0)
return;
//Stage 3: Transformation to unit Frechet
if (flag)
*dns = gev2frechTrend(data, *nObs, *nSite, locs, scales, shapes, trendlocs, trendscales,
trendshapes, jac, frech);
else
*dns = gev2frech(data, *nObs, *nSite, locs, scales, shapes, jac, frech);
if (*dns != 0.0)
return;
if (*weighted)
*dns = wlpliksmith(frech, mahalDist, jac, *nObs, *nSite, weights);
else
*dns = lpliksmith(frech, mahalDist, jac, *nObs, *nSite);
//Stage 5: Removing the penalizing terms (if any)
// 1- For the location parameter
if (*locpenalty > 0)
*dns -= penalization(locpenmat, loccoeff, *locpenalty,
*nloccoeff, *npparloc);
// 2- For the scale parameter
if (*scalepenalty > 0)
*dns -= penalization(scalepenmat, scalecoeff, *scalepenalty,
*nscalecoeff, *npparscale);
// 3- For the shape parameter
if (*shapepenalty > 0)
*dns -= penalization(shapepenmat, shapecoeff, *shapepenalty,
*nshapecoeff, *npparshape);
return;
}