///////////////////////////////////////////////////////////////////////
// Driver
int main(int argc, char* argv[]) {
if (argc < 11 || argc > 13) {
printf("Make a mask set to 1 for grid nodes within radius of any point.\n");
printf("Usage: %s srcGrid pointFile paramFile epsilonDest Rmin2Dest switchDist cutoffDist Vmax blurCount [both | 6 | 12 [x | y | z | xy | xyz]] outFile\n", argv[0]);
return 0;
}
const char* srcFile = argv[1];
const char* pointFile = argv[2];
const char* paramFile = argv[3];
const double epsilonDest = strtod(argv[4], NULL);
const double Rmin2Dest = strtod(argv[5], NULL);
const double switchDist = strtod(argv[6], NULL);
const double cutoffDist = strtod(argv[7], NULL);
double Vmax = strtod(argv[8], NULL);
const int blurCount = atoi(argv[9]);
const char *component = (argc > 11) ? argv[10] : "";
const char* wrap = (argc > 12) ? argv[11] : "";
const char* outFile = argv[argc-1];
// Figure out which LJ component to output
// ljcomp = 0 : combined
// ljcomp = 1 : 6
// ljcomp = 2 : 12
const int ljcomp = (strcmp(component, "12") == 0) ? 2 : (strcmp(component, "6") == 0) ? 1 : 0;
if (ljcomp == 2) {
// If we're doing the '12' component, double 'Vmax'. We do this
// because -1 * 'Vmax' is used for the lower bound of the 6
// component, so if we just used 'Vmax' for the 12 component,
// and if both component are pegged, then they add to zero,
// which is bad
Vmax *= 2;
}
// Figure out wrapping situation
bool wrapX = false, wrapY = false, wrapZ = false;
for (unsigned int i = 0; i < strlen(wrap); i++) {
wrapX = wrapX || (tolower(wrap[i]) == 'x');
wrapY = wrapY || (tolower(wrap[i]) == 'y');
wrapZ = wrapZ || (tolower(wrap[i]) == 'z');
}
printf("Wrapping X Y Z = %d %d %d\n", wrapX, wrapY, wrapZ);
// Load the grids.
Grid src(srcFile);
src.zero();
int n = src.length();
printf("Loaded `%s' which contains %d nodes.\n", srcFile, n);
// Load the coordinates.
printf("Loading the coordinates.\n");
Scatter pos(pointFile);
printf("Loaded %d points from `%s'.\n", pos.length(), pointFile);
// Load LJ parameters
printf("Loading the source parameters.\n");
Scatter param(paramFile);
printf("Loaded %d points from `%s'.\n", param.length(), paramFile);
// Generate the cell decomposition.
double cutoff = 1.2*cutoffDist;
Matrix3 sys = src.getBox();
Vector3 origin = src.getOrigin();
printf("\nGenerating cell decomposition for %s with cutoff = %.10g...\n", argv[1], cutoff);
CellDecomposition cell(sys, origin, cutoff);
printf("Cell decomposition of %i cells\n", cell.length());
cell.decompose(pos);
printf("Cell decomposition contains %i points\n", cell.countPoints());
printf("cutoffDist = %f\n", cutoffDist);
// Make the mask.
Grid mask(src);
int counter = 0;
int complete = 0;
#pragma omp parallel for
for (int i = 0; i < n; i++) {
Vector3 r = src.getPosition(i);
// Get the indices (in pos) of possible neighboring points.
IndexList neigh = cell.neighborhood(r);
const int nNeighs = neigh.length();
for (int j = 0; j < nNeighs; j++) {
// Get the position of each possible neighboring point.
Vector3 p = pos.get(neigh.get(j));
if (within(p, r, cutoffDist, src)) {
// wrap selected directions
Vector3 d1 = p - r;
Vector3 d2 = src.wrapDiff(p - r);
Vector3 d = Vector3(wrapX ? d2.x : d1.x,
wrapY ? d2.y : d1.y,
wrapZ ? d2.z : d1.z);
double R = d.length();
Vector3 par = param.get(neigh.get(j));
double ignored = par.x;
double epsilon = par.y;
double Rmin2 = par.z;
//printf("got epsilon = %f Rmin2 = %f\n", epsilon, Rmin2);
double val = (Rmin2 + Rmin2Dest) / R;
double V = mask.getValue(i);
double V_curr;
switch (ljcomp) {
case 0:
// both
V_curr = sqrt(epsilon * epsilonDest) * (pow(val, 12) - 2 * pow(val, 6));
break;
case 1:
// 6 component
V_curr = sqrt(epsilon * epsilonDest) * - 2 * pow(val, 6);
break;
case 2:
// 12 component
V_curr = sqrt(epsilon * epsilonDest) * pow(val, 12);
break;
}
//printf("%d: R = %f ep = %f epD = %f Rmin2 = %f Rmin2D = %f V = %f\n", neigh.get(j), R, epsilon, epsilonDest, Rmin2, Rmin2Dest, V_curr);
if (R >= switchDist) {
double RR = (R - switchDist)/(cutoffDist - switchDist);
V_curr *= 1 + RR*RR * (2*RR - 3);
}
double V_new = (V + V_curr > Vmax) ? Vmax : (V + V_curr < -Vmax) ? -Vmax : V + V_curr;
mask.setValue(i, V_new);
//break;
}
}
// Write the progress.
#pragma omp critical
{
int comp = (100*(long)counter)/n;
if (abs(complete - comp) >= 5) {
printf("%d percent complete\n", comp);
complete = comp;
}
counter++;
}
}
// Blur.
for (int j = 0; j < blurCount; j++) mask.blur();
char comments[256];
sprintf(comments, "%s patched", srcFile);
mask.write(outFile, comments);
printf("Wrote `%s'.\n", outFile);
return 0;
}
///////////////////////////////////////////////////////////////////////
// Driver
int main(int argc, char* argv[]) {
if ( argc != 11 && argc != 10) {
printf("Usage: %s srcGrid poreLength poreDiamX poreDiamY cornerRad wellWidth wellDepth barrierHeight [surfWidth] outGrid\n", argv[0]);
printf("If `surfWidth' is specified, then the upper and lower membrane surfaces only barriers. The pore is unaffected.\n");
return 0;
}
const char* srcGrid = argv[1];
const char* outGrid = argv[argc-1];
const double poreLength = strtod(argv[2], NULL);
const double poreDiamX = strtod(argv[3], NULL);
const double poreDiamY = strtod(argv[4], NULL);
const double cornerRad = strtod(argv[5], NULL);
const double wellWidth = strtod(argv[6], NULL);
const double wellDepth = strtod(argv[7], NULL);
const double barrierHeight = strtod(argv[8], NULL);
const double surfWidth = strtod(argv[9], NULL);
bool surfBarrier = (argc == 11);
CylinderPore pore(poreLength, poreDiamX, poreDiamY, cornerRad);
//double wallShift = wellWidth*1.5;
WallEnergy wall(-fabs(wellWidth), -0.5*fabs(wellWidth), -fabs(wellDepth), 0.0, barrierHeight);
WallEnergy wallSurf(-fabs(surfWidth), -0.5*fabs(surfWidth), 0.0, 0.0, barrierHeight);
// Load the grid.
Grid src(srcGrid);
printf("Loaded the grid `%s'.\n", srcGrid);
// Mark the pore.
printf("Marking the pore...\n");
const int n = src.length();
for (int i = 0; i < n; i++) {
Vector3 r = src.wrapDiffNearest(src.getPosition(i));
if (pore.in(r)) src.setValue(i, 1.0);
else src.setValue(i, 0.0);
}
src.write("test.dx");
// Find the surface.
printf("Marking the surface...\n");
Grid surf(src);
surf.blur();
int surfNum = 0;
for (int i = 0; i < n; i++) {
double v = surf.getValue(i);
if (v > 0.01 && v < 0.99) {
surf.setValue(i, 1.0);
surfNum++;
}
else surf.setValue(i, 0.0);
}
// Write the surface grid.
char outSurf[256];
sprintf(outSurf, "surf_%s", outGrid);
surf.write(outSurf, "surface");
printf("Wrote the surface `%s'.\n", outSurf);
// Make a list of surface positions.
Vector3* surfPos = new Vector3[surfNum];
int j = 0;
for (int i = 0; i < n; i++) {
if (surf.getValue(i) > 0.0) {
surfPos[j] = surf.getPosition(i);
j++;
}
}
printf("Extracted %d surface nodes.\n", surfNum);
// Generate the cell decomposition.
double cutoff = 1.5*wellWidth;
Matrix3 sys = src.getBox();
Vector3 origin = src.getOrigin();
printf("\nGenerating cell decomposition for %s with cutoff = %.10g...\n", argv[1], cutoff);
CellDecomposition cell(sys, origin, cutoff);
printf("Cell decomposition of %i cells\n", cell.length());
cell.decompose(surfPos, surfNum);
printf("Cell decomposition contains %i points\n", cell.countPoints());
// Now go through the grid to create the output potential.
Grid dest(src);
int complete = 0;
for (int i = 0; i < n; i++) {
double v = src.getValue(i);
// If the position is inside the membrane, set it to the max value.
if (v > 0.0) {
dest.setValue(i, barrierHeight);
continue;
}
// Find the distance to the surface.
Vector3 r = src.getPosition(i);
// Get the indices (in pos) of possible neighboring points.
IndexList neigh = cell.neighborhood(r);
const int nNeighs = neigh.length();
if (nNeighs < 1) {
dest.setValue(i, 0.0);
continue;
}
// Find the minimum distance to a surface point.
Vector3 d = src.wrapDiffNearest(surfPos[neigh.get(0)] - r);
double minDist = d.length();
for (int j = 1; j < nNeighs; j++) {
Vector3 d = src.wrapDiffNearest(surfPos[neigh.get(j)] - r);
if (d.length() < minDist) minDist = d.length();
}
// Set the value using the WallEnergy function.
if (surfBarrier) {
double w = pore.surfaceWeight(r);
dest.setValue(i, (1.0-w)*wall.energy(-minDist) + w*wallSurf.hardEnergy(-minDist));
}
else dest.setValue(i, wall.energy(-minDist));
// Write the progress.
int comp = (100*i)/n;
if (abs(complete - comp) >= 5) {
printf("%d percent complete\n", comp);
complete = comp;
}
}
delete[] surfPos;
char comments[256];
sprintf(comments, "poreLength %g poreDiamX %g poreDiamY %g cornerRad %g wellWidth %g wellDepth %g barrierHeight %g", poreLength, poreDiamX, poreDiamY, cornerRad, wellWidth, wellDepth, barrierHeight);
dest.write(outGrid, comments);
printf("Wrote `%s'.\n", outGrid);
return 0;
}
