int main(int argc, char *argv []) {
registerLattice();
gengetopt_args_info args_info;
std::string latticeType;
std::string inputFileName;
std::string outputFileName;
MoLocator* locator;
int nComponents;
double latticeConstant;
RealType rodRadius;
RealType rodLength;
Mat3x3d hmat;
DumpWriter *writer;
// Parse Command Line Arguments
if (cmdline_parser(argc, argv, &args_info) != 0)
exit(1);
/* get lattice type */
latticeType = "FCC";
/* get input file name */
if (args_info.inputs_num)
inputFileName = args_info.inputs[0];
else {
sprintf(painCave.errMsg, "No input .omd file name was specified "
"on the command line");
painCave.isFatal = 1;
cmdline_parser_print_help();
simError();
}
/* parse md file and set up the system */
SimCreator oldCreator;
SimInfo* oldInfo = oldCreator.createSim(inputFileName, false);
latticeConstant = args_info.latticeConstant_arg;
rodRadius = args_info.radius_arg;
rodLength = args_info.length_arg;
Globals* simParams = oldInfo->getSimParams();
vector<Vector3d> sites;
vector<Vector3d> orientations;
if (args_info.ellipsoid_flag) {
shapedLatticeEllipsoid nanoEllipsoid(latticeConstant, latticeType,
rodLength, rodRadius);
sites = nanoEllipsoid.getSites();
orientations = nanoEllipsoid.getOrientations();
} else {
/* Create nanorod */
shapedLatticeRod nanoRod(latticeConstant, latticeType,
rodRadius, rodLength);
/* Build a lattice and get lattice points for this lattice constant */
sites = nanoRod.getSites();
orientations = nanoRod.getOrientations();
}
std::vector<std::size_t> vacancyTargets;
vector<bool> isVacancy;
Vector3d myLoc;
RealType myR;
for (std::size_t i = 0; i < sites.size(); i++)
isVacancy.push_back(false);
// cerr << "checking vacancyPercent" << "\n";
if (args_info.vacancyPercent_given) {
// cerr << "vacancyPercent given" << "\n";
if (args_info.vacancyPercent_arg < 0.0 || args_info.vacancyPercent_arg > 100.0) {
sprintf(painCave.errMsg,
"vacancyPercent was set to a non-sensical value.");
painCave.isFatal = 1;
simError();
} else {
RealType vF = args_info.vacancyPercent_arg / 100.0;
// cerr << "vacancyPercent = " << vF << "\n";
RealType vIR;
RealType vOR;
if (args_info.vacancyInnerRadius_given) {
vIR = args_info.vacancyInnerRadius_arg;
} else {
vIR = 0.0;
}
if (args_info.vacancyOuterRadius_given) {
vOR = args_info.vacancyOuterRadius_arg;
} else {
vOR = rodRadius;
}
if (vIR >= 0.0 && vOR <= rodRadius && vOR >= vIR) {
for (std::size_t i = 0; i < sites.size(); i++) {
myLoc = sites[i];
myR = myLoc.length();
if (myR >= vIR && myR <= vOR) {
vacancyTargets.push_back(i);
}
}
std::random_shuffle(vacancyTargets.begin(), vacancyTargets.end());
std::size_t nTargets = vacancyTargets.size();
vacancyTargets.resize((int)(vF * nTargets));
sprintf(painCave.errMsg, "Removing %d atoms from randomly-selected\n"
"\tsites between %lf and %lf.", (int) vacancyTargets.size(),
vIR, vOR);
painCave.isFatal = 0;
painCave.severity = OPENMD_INFO;
simError();
isVacancy.clear();
for (std::size_t i = 0; i < sites.size(); i++) {
bool vac = false;
for (std::size_t j = 0; j < vacancyTargets.size(); j++) {
if (i == vacancyTargets[j]) vac = true;
}
isVacancy.push_back(vac);
}
} else {
sprintf(painCave.errMsg, "Something is strange about the vacancy\n"
"\tinner or outer radii. Check their values.");
painCave.isFatal = 1;
simError();
}
}
}
/* Get number of lattice sites */
std::size_t nSites = sites.size() - vacancyTargets.size();
// cerr << "sites.size() = " << sites.size() << "\n";
// cerr << "nSites = " << nSites << "\n";
// cerr << "vacancyTargets = " << vacancyTargets.size() << "\n";
std::vector<Component*> components = simParams->getComponents();
std::vector<RealType> molFractions;
std::vector<RealType> shellRadii;
std::vector<int> nMol;
std::map<int, int> componentFromSite;
nComponents = components.size();
// cerr << "nComponents = " << nComponents << "\n";
if (args_info.molFraction_given && args_info.shellRadius_given) {
sprintf(painCave.errMsg, "Specify either molFraction or shellRadius "
"arguments, but not both!");
painCave.isFatal = 1;
simError();
}
if (nComponents == 1) {
molFractions.push_back(1.0);
shellRadii.push_back(rodRadius);
} else if (args_info.molFraction_given) {
if ((int)args_info.molFraction_given == nComponents) {
for (int i = 0; i < nComponents; i++) {
molFractions.push_back(args_info.molFraction_arg[i]);
}
} else if ((int)args_info.molFraction_given == nComponents-1) {
RealType remainingFraction = 1.0;
for (int i = 0; i < nComponents-1; i++) {
molFractions.push_back(args_info.molFraction_arg[i]);
remainingFraction -= molFractions[i];
}
molFractions.push_back(remainingFraction);
} else {
sprintf(painCave.errMsg, "nanorodBuilder can't figure out molFractions "
"for all of the components in the <MetaData> block.");
painCave.isFatal = 1;
simError();
}
} else if ((int)args_info.shellRadius_given) {
if ((int)args_info.shellRadius_given == nComponents) {
for (int i = 0; i < nComponents; i++) {
shellRadii.push_back(args_info.shellRadius_arg[i]);
}
} else if ((int)args_info.shellRadius_given == nComponents-1) {
for (int i = 0; i < nComponents-1; i++) {
shellRadii.push_back(args_info.shellRadius_arg[i]);
}
shellRadii.push_back(rodRadius);
} else {
sprintf(painCave.errMsg, "nanorodBuilder can't figure out the\n"
"\tshell radii for all of the components in the <MetaData> block.");
painCave.isFatal = 1;
simError();
}
} else {
sprintf(painCave.errMsg, "You have a multi-component <MetaData> block,\n"
"\tbut have not specified either molFraction or shellRadius arguments.");
painCave.isFatal = 1;
simError();
}
if (args_info.molFraction_given) {
RealType totalFraction = 0.0;
/* Do some simple sanity checking*/
for (int i = 0; i < nComponents; i++) {
if (molFractions.at(i) < 0.0) {
sprintf(painCave.errMsg, "One of the requested molFractions was"
" less than zero!");
painCave.isFatal = 1;
simError();
}
if (molFractions.at(i) > 1.0) {
sprintf(painCave.errMsg, "One of the requested molFractions was"
" greater than one!");
painCave.isFatal = 1;
simError();
}
totalFraction += molFractions.at(i);
}
if (abs(totalFraction - 1.0) > 1e-6) {
sprintf(painCave.errMsg,
"The sum of molFractions was not close enough to 1.0");
painCave.isFatal = 1;
simError();
}
int remaining = nSites;
for (int i=0; i < nComponents-1; i++) {
nMol.push_back(int((RealType)nSites * molFractions.at(i)));
remaining -= nMol.at(i);
}
nMol.push_back(remaining);
// recompute actual mol fractions and perform final sanity check:
std::size_t totalMolecules = 0;
for (int i=0; i < nComponents; i++) {
molFractions[i] = (RealType)(nMol.at(i))/(RealType)nSites;
totalMolecules += nMol.at(i);
}
if (totalMolecules != nSites) {
sprintf(painCave.errMsg,
"Computed total number of molecules is not equal "
"to the number of lattice sites!");
painCave.isFatal = 1;
simError();
}
} else {
for (unsigned int i = 0; i < shellRadii.size(); i++) {
if (shellRadii.at(i) > rodRadius + 1e-6 ) {
sprintf(painCave.errMsg,
"One of the shellRadius values exceeds the rod Radius.");
painCave.isFatal = 1;
simError();
}
if (shellRadii.at(i) <= 0.0 ) {
sprintf(painCave.errMsg,
"One of the shellRadius values is smaller than zero!");
painCave.isFatal = 1;
simError();
}
}
}
vector<int> ids;
if ((int)args_info.molFraction_given){
// cerr << "molFraction given 2" << "\n";
sprintf(painCave.errMsg,
"Creating a randomized spherically-capped nanorod.");
painCave.isFatal = 0;
painCave.severity = OPENMD_INFO;
simError();
/* Random rod is the default case*/
for (std::size_t i = 0; i < sites.size(); i++)
if (!isVacancy[i]) ids.push_back(i);
std::random_shuffle(ids.begin(), ids.end());
} else{
sprintf(painCave.errMsg, "Creating an fcc nanorod.");
painCave.isFatal = 0;
painCave.severity = OPENMD_INFO;
simError();
// RealType smallestSoFar;
int myComponent = -1;
nMol.clear();
nMol.resize(nComponents);
// cerr << "shellRadii[0] " << shellRadii[0] << "\n";
// cerr << "rodRadius " << rodRadius << "\n";
for (unsigned int i = 0; i < sites.size(); i++) {
myLoc = sites[i];
myR = myLoc.length();
// smallestSoFar = rodRadius;
// cerr << "vac = " << isVacancy[i]<< "\n";
if (!isVacancy[i]) {
// for (int j = 0; j < nComponents; j++) {
// if (myR <= shellRadii[j]) {
// if (shellRadii[j] <= smallestSoFar) {
// smallestSoFar = shellRadii[j];
// myComponent = j;
// }
// }
// }
myComponent = 0;
componentFromSite[i] = myComponent;
nMol[myComponent]++;
// cerr << "nMol for myComp(" << myComponent<<") = " << nMol[myComponent] << "\n";
}
}
}
// cerr << "nMol = " << nMol.at(0) << "\n";
outputFileName = args_info.output_arg;
//creat new .omd file on fly which corrects the number of molecule
createMdFile(inputFileName, outputFileName, nMol);
delete oldInfo;
SimCreator newCreator;
SimInfo* NewInfo = newCreator.createSim(outputFileName, false);
// Place molecules
Molecule* mol;
SimInfo::MoleculeIterator mi;
mol = NewInfo->beginMolecule(mi);
int l = 0;
for (int i = 0; i < nComponents; i++){
locator = new MoLocator(NewInfo->getMoleculeStamp(i),
NewInfo->getForceField());
// cerr << "nMol = " << nMol.at(i) << "\n";
if (!args_info.molFraction_given) {
for (unsigned int n = 0; n < sites.size(); n++) {
if (!isVacancy[n]) {
if (componentFromSite[n] == i) {
mol = NewInfo->getMoleculeByGlobalIndex(l);
locator->placeMol(sites[n], orientations[n], mol);
l++;
}
}
}
} else {
for (int n = 0; n < nMol.at(i); n++) {
mol = NewInfo->getMoleculeByGlobalIndex(l);
locator->placeMol(sites[ids[l]], orientations[ids[l]], mol);
l++;
}
}
}
//fill Hmat
hmat(0, 0)= 10.0*rodRadius;
hmat(0, 1) = 0.0;
hmat(0, 2) = 0.0;
hmat(1, 0) = 0.0;
hmat(1, 1) = 10.0*rodRadius;
hmat(1, 2) = 0.0;
hmat(2, 0) = 0.0;
hmat(2, 1) = 0.0;
hmat(2, 2) = 5.0*rodLength + 2.0*rodRadius;
//set Hmat
NewInfo->getSnapshotManager()->getCurrentSnapshot()->setHmat(hmat);
//create dumpwriter and write out the coordinates
writer = new DumpWriter(NewInfo, outputFileName);
if (writer == NULL) {
sprintf(painCave.errMsg, "Error in creating dumpwriter object ");
painCave.isFatal = 1;
simError();
}
writer->writeDump();
// deleting the writer will put the closing at the end of the dump file
delete writer;
// cleanup a by calling sim error.....
sprintf(painCave.errMsg, "A new OpenMD file called \"%s\" has been "
"generated.\n", outputFileName.c_str());
painCave.isFatal = 0;
painCave.severity = OPENMD_INFO;
simError();
return 0;
}
void ResolverController::dump(DumpWriter& dw, unsigned netId) {
// No lock needed since Bionic's resolver locks all accessed data structures internally.
using android::net::ResolverStats;
std::vector<std::string> servers;
std::vector<std::string> domains;
__res_params params;
std::vector<ResolverStats> stats;
time_t now = time(nullptr);
int rv = getDnsInfo(netId, &servers, &domains, ¶ms, &stats);
dw.incIndent();
if (rv != 0) {
dw.println("getDnsInfo() failed for netid %u", netId);
} else {
if (servers.empty()) {
dw.println("No DNS servers defined");
} else {
dw.println("DNS servers: # IP (total, successes, errors, timeouts, internal errors, "
"RTT avg, last sample)");
dw.incIndent();
for (size_t i = 0 ; i < servers.size() ; ++i) {
if (i < stats.size()) {
const ResolverStats& s = stats[i];
int total = s.successes + s.errors + s.timeouts + s.internal_errors;
if (total > 0) {
int time_delta = (s.last_sample_time > 0) ? now - s.last_sample_time : -1;
dw.println("%s (%d, %d, %d, %d, %d, %dms, %ds)%s", servers[i].c_str(),
total, s.successes, s.errors, s.timeouts, s.internal_errors,
s.rtt_avg, time_delta, s.usable ? "" : " BROKEN");
} else {
dw.println("%s <no data>", servers[i].c_str());
}
} else {
dw.println("%s <no stats>", servers[i].c_str());
}
}
dw.decIndent();
}
if (domains.empty()) {
dw.println("No search domains defined");
} else {
std::string domains_str = android::base::Join(domains, ", ");
dw.println("search domains: %s", domains_str.c_str());
}
if (params.sample_validity != 0) {
dw.println("DNS parameters: sample validity = %us, success threshold = %u%%, "
"samples (min, max) = (%u, %u)", params.sample_validity,
static_cast<unsigned>(params.success_threshold),
static_cast<unsigned>(params.min_samples),
static_cast<unsigned>(params.max_samples));
}
{
std::lock_guard<std::mutex> guard(privateDnsLock);
const auto& mode = privateDnsModes.find(netId);
dw.println("Private DNS mode: %s", getPrivateDnsModeString(
mode != privateDnsModes.end() ? mode->second : PrivateDnsMode::OFF));
const auto& netPair = privateDnsTransports.find(netId);
if (netPair == privateDnsTransports.end()) {
dw.println("No Private DNS servers configured");
} else {
const auto& tracker = netPair->second;
dw.println("Private DNS configuration (%zu entries)", tracker.size());
dw.incIndent();
for (const auto& kv : tracker) {
const auto& server = kv.first;
const auto status = kv.second;
dw.println("%s name{%s} status{%s}",
addrToString(&(server.ss)).c_str(),
server.name.c_str(),
validationStatusToString(status));
}
dw.decIndent();
}
}
}
dw.decIndent();
}
int main(int argc, char* argv[]){
gengetopt_args_info args_info;
string dumpFileName;
string outFileName;
//parse the command line option
if (cmdline_parser (argc, argv, &args_info) != 0) {
exit(1) ;
}
//get the dumpfile name and meta-data file name
if (args_info.input_given){
dumpFileName = args_info.input_arg;
} else {
strcpy( painCave.errMsg,
"No input file name was specified.\n" );
painCave.isFatal = 1;
simError();
}
if (args_info.output_given){
outFileName = args_info.output_arg;
} else {
strcpy( painCave.errMsg,
"No output file name was specified.\n" );
painCave.isFatal = 1;
simError();
}
Vector3i repeat = Vector3i(args_info.repeatX_arg,
args_info.repeatY_arg,
args_info.repeatZ_arg);
Mat3x3d repeatD = Mat3x3d(0.0);
repeatD(0,0) = repeat.x();
repeatD(1,1) = repeat.y();
repeatD(2,2) = repeat.z();
Vector3d translate = Vector3d(args_info.translateX_arg,
args_info.translateY_arg,
args_info.translateZ_arg);
//parse md file and set up the system
SimCreator oldCreator;
SimInfo* oldInfo = oldCreator.createSim(dumpFileName, false);
Globals* simParams = oldInfo->getSimParams();
std::vector<Component*> components = simParams->getComponents();
std::vector<int> nMol;
for (vector<Component*>::iterator i = components.begin();
i !=components.end(); ++i) {
int nMolOld = (*i)->getNMol();
int nMolNew = nMolOld * repeat.x() * repeat.y() * repeat.z();
nMol.push_back(nMolNew);
}
createMdFile(dumpFileName, outFileName, nMol);
SimCreator newCreator;
SimInfo* newInfo = newCreator.createSim(outFileName, false);
DumpReader* dumpReader = new DumpReader(oldInfo, dumpFileName);
int nframes = dumpReader->getNFrames();
DumpWriter* writer = new DumpWriter(newInfo, outFileName);
if (writer == NULL) {
sprintf(painCave.errMsg, "error in creating DumpWriter");
painCave.isFatal = 1;
simError();
}
SimInfo::MoleculeIterator miter;
Molecule::IntegrableObjectIterator iiter;
Molecule::RigidBodyIterator rbIter;
Molecule* mol;
StuntDouble* sd;
StuntDouble* sdNew;
RigidBody* rb;
Mat3x3d oldHmat;
Mat3x3d newHmat;
Snapshot* oldSnap;
Snapshot* newSnap;
Vector3d oldPos;
Vector3d newPos;
for (int i = 0; i < nframes; i++){
cerr << "frame = " << i << "\n";
dumpReader->readFrame(i);
oldSnap = oldInfo->getSnapshotManager()->getCurrentSnapshot();
newSnap = newInfo->getSnapshotManager()->getCurrentSnapshot();
newSnap->setID( oldSnap->getID() );
newSnap->setTime( oldSnap->getTime() );
oldHmat = oldSnap->getHmat();
newHmat = repeatD*oldHmat;
newSnap->setHmat(newHmat);
newSnap->setThermostat( oldSnap->getThermostat() );
newSnap->setBarostat( oldSnap->getBarostat() );
int newIndex = 0;
for (mol = oldInfo->beginMolecule(miter); mol != NULL;
mol = oldInfo->nextMolecule(miter)) {
for (int ii = 0; ii < repeat.x(); ii++) {
for (int jj = 0; jj < repeat.y(); jj++) {
for (int kk = 0; kk < repeat.z(); kk++) {
Vector3d trans = Vector3d(ii, jj, kk);
for (sd = mol->beginIntegrableObject(iiter); sd != NULL;
sd = mol->nextIntegrableObject(iiter)) {
oldPos = sd->getPos() + translate;
oldSnap->wrapVector(oldPos);
newPos = oldPos + trans * oldHmat;
sdNew = newInfo->getIOIndexToIntegrableObject(newIndex);
sdNew->setPos( newPos );
sdNew->setVel( sd->getVel() );
if (sd->isDirectional()) {
sdNew->setA( sd->getA() );
sdNew->setJ( sd->getJ() );
}
newIndex++;
}
}
}
}
}
//update atoms of rigidbody
for (mol = newInfo->beginMolecule(miter); mol != NULL;
mol = newInfo->nextMolecule(miter)) {
//change the positions of atoms which belong to the rigidbodies
for (rb = mol->beginRigidBody(rbIter); rb != NULL;
rb = mol->nextRigidBody(rbIter)) {
rb->updateAtoms();
rb->updateAtomVel();
}
}
writer->writeDump();
}
// deleting the writer will put the closing at the end of the dump file.
delete writer;
delete oldInfo;
}
