void writeInteratomics(Atom *atoms, int numatoms, const double globalCutoff, const TypeVec &types, double *spaceSize, const SquareSelector<double> &coordCutoffs) { // iterate from numatoms to 1 BondMap bonds(types); CoordinationHistogramData coords(types.size()); Bond *file; size_t *count = new size_t[types.size()]; for (int i = numatoms - 1; i > 0; --i) { memset(count, '\0', sizeof(size_t) * types.size()); // iterate from j-1 to 0 for (int j = numatoms - 1; j >= 0; --j) { if (i == j) { continue; } double distance = getDistance(atoms[i], atoms[j], spaceSize); if (distance <= globalCutoff) { file = bonds.getFile(atoms[i].type, atoms[j].type); file->write(distance); } if (!coordCutoffs.empty() && distance <= coordCutoffs.select(atoms[i].type, atoms[j].type)) { count[atoms[j].type] += 1; } } if (!coordCutoffs.empty()) { for (size_t j = 0; j < types.size(); ++j) { coords.addValue(atoms[i].type, j, count[j]); } } } if (!coordCutoffs.empty()) { writeCoordination(coords, types); } delete[] count; }
AST_MATCHER_P(FunctionDecl, throws, internal::Matcher<Type>, InnerMatcher) { TypeVec ExceptionList = throwsException(&Node); auto NewEnd = llvm::remove_if( ExceptionList, [this, Finder, Builder](const Type *Exception) { return !InnerMatcher.matches(*Exception, Finder, Builder); }); ExceptionList.erase(NewEnd, ExceptionList.end()); return ExceptionList.size(); }
SquareSelector<double> getCoordCutoffs(const TypeVec &types) { vector<string> cutstrs = strsplit(args.getCString("coordinationCutoffs")); if (cutstrs.size() != 0) { if (types.size() == 0) { cerr << "coordinationCutoffs: species not defined" << endl; exit(1); } if (cutstrs.size() < types.size() * types.size()) { cerr << "coordinationCutoffs: too few values. Must be number of species squared" << endl; exit(1); } if (cutstrs.size() > types.size() * types.size()) { cerr << "coordinationCutoffs: too many values. Must be number of species squared" << endl; exit(1); } vector<double> cutoffs(cutstrs.size()); for (size_t i = 0; i < cutstrs.size(); ++i) { double value; if (convert(cutstrs[i].c_str(), &value)) { cerr << "coordinationCutoffs: invalid double value '" << cutstrs[i].c_str() << "'" << endl; exit(1); } cutoffs[i] = value; } return SquareSelector<double>(cutoffs); } return SquareSelector<double>(vector<double>()); }
TypeVec getTypes() { TypeVec types; // init types with predefined species (if any) vector<string> species = strsplit(args.getCString("species")); for (size_t i = 0; i < species.size(); ++i) { types.push_back(Type(species[i].c_str(), types.size())); } return types; }
void writeCoordination(CoordinationHistogramData &coords, const TypeVec &types) { ofstream coordsfile("coords.txt"); for (size_t type1 = 0; type1 < types.size(); ++type1) { for (size_t type2 = 0; type2 < types.size(); ++type2) { coordsfile << types[type1].name.c_str() << "-" << types[type2].name.c_str() << "\t"; CoordinationHistogramData::Bins bins = coords.data[coords.getIndex(type1, type2)]; for (CoordinationHistogramData::Bins::iterator it = bins.begin(); it != bins.end(); ++it) { coordsfile << *it << " "; } coordsfile << endl; } } }
static void DtoCreateNestedContextType(FuncDeclaration* fd) { Logger::println("DtoCreateNestedContextType for %s", fd->toChars()); LOG_SCOPE DtoDeclareFunction(fd); if (fd->ir.irFunc->nestedContextCreated) return; fd->ir.irFunc->nestedContextCreated = true; if (fd->nestedVars.empty()) { // fill nestedVars size_t nnest = fd->closureVars.dim; for (size_t i = 0; i < nnest; ++i) { VarDeclaration* vd = static_cast<VarDeclaration*>(fd->closureVars.data[i]); fd->nestedVars.insert(vd); } } // construct nested variables array if (!fd->nestedVars.empty()) { Logger::println("has nested frame"); // start with adding all enclosing parent frames until a static parent is reached LLStructType* innerFrameType = NULL; unsigned depth = -1; if (!fd->isStatic()) { if (FuncDeclaration* parfd = getParentFunc(fd, true)) { // Make sure the parent has already been analyzed. DtoCreateNestedContextType(parfd); innerFrameType = parfd->ir.irFunc->frameType; if (innerFrameType) depth = parfd->ir.irFunc->depth; } } fd->ir.irFunc->depth = ++depth; Logger::cout() << "Function " << fd->toChars() << " has depth " << depth << '\n'; typedef std::vector<LLType*> TypeVec; TypeVec types; if (depth != 0) { assert(innerFrameType); // Add frame pointer types for all but last frame if (depth > 1) { for (unsigned i = 0; i < (depth - 1); ++i) { types.push_back(innerFrameType->getElementType(i)); } } // Add frame pointer type for last frame types.push_back(LLPointerType::getUnqual(innerFrameType)); } if (Logger::enabled() && depth != 0) { Logger::println("Frame types: "); LOG_SCOPE; for (TypeVec::iterator i = types.begin(); i != types.end(); ++i) Logger::cout() << **i << '\n'; } // Add the direct nested variables of this function, and update their indices to match. // TODO: optimize ordering for minimal space usage? for (std::set<VarDeclaration*>::iterator i=fd->nestedVars.begin(); i!=fd->nestedVars.end(); ++i) { VarDeclaration* vd = *i; if (!vd->ir.irLocal) vd->ir.irLocal = new IrLocal(vd); vd->ir.irLocal->nestedIndex = types.size(); vd->ir.irLocal->nestedDepth = depth; if (vd->isParameter()) { // Parameters will have storage associated with them (to handle byref etc.), // so handle those cases specially by storing a pointer instead of a value. const IrParameter* irparam = vd->ir.irParam; const bool refout = vd->storage_class & (STCref | STCout); const bool lazy = vd->storage_class & STClazy; const bool byref = irparam->arg->byref; const bool isVthisPtr = irparam->isVthis && !byref; if (!(refout || (byref && !lazy)) || isVthisPtr) { // This will be copied to the nesting frame. if (lazy) types.push_back(irparam->value->getType()->getContainedType(0)); else types.push_back(DtoType(vd->type)); } else { types.push_back(irparam->value->getType()); } } else if (isSpecialRefVar(vd)) { types.push_back(DtoType(vd->type->pointerTo())); } else { types.push_back(DtoType(vd->type)); } if (Logger::enabled()) { Logger::cout() << "Nested var '" << vd->toChars() << "' of type " << *types.back() << "\n"; } } LLStructType* frameType = LLStructType::create(gIR->context(), types, std::string("nest.") + fd->toChars()); Logger::cout() << "frameType = " << *frameType << '\n'; // Store type in IrFunction fd->ir.irFunc->frameType = frameType; } else if (FuncDeclaration* parFunc = getParentFunc(fd, true)) { // Propagate context arg properties if the context arg is passed on unmodified. DtoCreateNestedContextType(parFunc); fd->ir.irFunc->frameType = parFunc->ir.irFunc->frameType; fd->ir.irFunc->depth = parFunc->ir.irFunc->depth; } }