Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files Community
1
name
stringlengths
1
473k
code
stringlengths
7
647k
asm
stringlengths
4
3.39M
file
stringlengths
8
196
antlr::NoViableAltException::NoViableAltException(antlr::TokenRefCount<antlr::Token>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
NoViableAltException::NoViableAltException( RefToken t, const ANTLR_USE_NAMESPACE(std)string& fileName_ ) : RecognitionException("NoViableAlt",fileName_,t->getLine(),t->getColumn()), token(t), node(nullASTptr) { }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx leaq 0x74879(%rip), %rsi # 0xc8c1b leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movq (%r14), %rax movq (%rax), %rdi movq (%rdi), %rax callq *0x18(%rax) movl %eax, %ebp movq (%r14), %rax movq (%rax), %rdi movq (%rdi), %rax callq *0x10(%rax) leaq 0x8(%rsp), %rsi movq %rbx, %rdi movq %r15, %rdx movl %ebp, %ecx movl %eax, %r8d callq 0x54c5a leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0xc6657(%rip), %rax # 0x11aa48 movq %rax, (%rbx) movq (%r14), %rax testq %rax, %rax je 0x543ff incl 0x8(%rax) leaq 0x50(%rbx), %r15 movq %rax, 0x50(%rbx) leaq 0x58(%rbx), %rdi leaq 0x7453e(%rip), %rax # 0xc8950 movq (%rax), %rsi callq 0x50004 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq %r15, %rdi callq 0x2476c movq %rbx, %rdi callq 0x24790 jmp 0x5444c movq %rax, %r14 jmp 0x5444c movq %rax, %r14 leaq 0x8(%rsp), %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/antlr/NoViableAltException.cpp
antlr::Parser::reportWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Parser::reportWarning(const ANTLR_USE_NAMESPACE(std)string& s) { if ( getFilename()=="" ) ANTLR_USE_NAMESPACE(std)cerr << "warning: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl; else ANTLR_USE_NAMESPACE(std)cerr << getFilename().c_str() << ": warning: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %rax leaq 0x8(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq *0x40(%rax) leaq 0x7c63c(%rip), %rsi # 0xd0eea movq %r15, %rdi callq 0x2251c movl %eax, %ebp movq %r15, %rdi callq 0x13a98 testb %bpl, %bpl je 0x548ed movq 0xc970c(%rip), %rdi # 0x11dfd8 leaq 0x727a9(%rip), %rsi # 0xc707c callq 0x134b0 movq (%rbx), %rsi movq %rax, %rdi callq 0x134b0 movq %rax, %rdi callq 0x13250 jmp 0x54939 movq (%r14), %rax leaq 0x8(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq *0x40(%rax) movq (%r15), %rsi movq 0xc96d0(%rip), %rdi # 0x11dfd8 callq 0x134b0 leaq 0x72766(%rip), %rsi # 0xc707a movq %rax, %rdi callq 0x134b0 movq (%rbx), %rsi movq %rax, %rdi callq 0x134b0 movq %rax, %rdi callq 0x13250 leaq 0x8(%rsp), %rdi callq 0x13a98 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/Parser.cpp
antlr::Parser::traceIn(char const*)
void Parser::traceIn(const char* rname) { traceDepth++; for( int i = 0; i < traceDepth; i++ ) ANTLR_USE_NAMESPACE(std)cout << " "; ANTLR_USE_NAMESPACE(std)cout << "> " << rname << "; LA(1)==" << LT(1)->getText().c_str() << ((inputState->guessing>0)?" [guessing]":"") << ANTLR_USE_NAMESPACE(std)endl; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rsi, %r14 movq %rdi, %rbx movl 0x18(%rdi), %eax incl %eax movl %eax, 0x18(%rdi) xorl %ebp, %ebp movq 0xc95f9(%rip), %r15 # 0x11dfb0 leaq 0x7565f(%rip), %r12 # 0xca01d cmpl %eax, %ebp jge 0x549d4 movq %r15, %rdi movq %r12, %rsi callq 0x134b0 incl %ebp movl 0x18(%rbx), %eax jmp 0x549be movq 0xc95d5(%rip), %rdi # 0x11dfb0 leaq 0x74019(%rip), %rsi # 0xc89fb callq 0x134b0 movq %rax, %rdi movq %r14, %rsi callq 0x134b0 leaq 0x742f6(%rip), %rsi # 0xc8cef movq %rax, %rdi callq 0x134b0 movq %rax, %r14 movq (%rbx), %rax leaq 0x8(%rsp), %r15 pushq $0x1 popq %rdx movq %r15, %rdi movq %rbx, %rsi callq *0x18(%rax) movq (%r15), %rax movq (%rax), %rsi movq (%rsi), %rax leaq 0x10(%rsp), %rdi callq *0x20(%rax) movq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x134b0 movq 0x8(%rbx), %rcx movq (%rcx), %rcx cmpl $0x0, 0x8(%rcx) leaq 0x73f97(%rip), %rcx # 0xc89df leaq 0x7c49b(%rip), %rsi # 0xd0eea cmovgq %rcx, %rsi movq %rax, %rdi callq 0x134b0 movq %rax, %rdi callq 0x13250 leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x2476c addq $0x30, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx jmp 0x54a96 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x2476c movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/antlr/Parser.cpp
antlr::RecognitionException::RecognitionException()
RecognitionException::RecognitionException() : ANTLRException("parsing error") , line(-1) , column(-1) { }
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq 0x74140(%rip), %rsi # 0xc8d09 leaq 0x8(%rsp), %r14 leaq 0x7(%rsp), %rdx movq %r14, %rdi callq 0x1a8b4 movq %rbx, %rdi movq %r14, %rsi callq 0x3239a leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0xc6031(%rip), %rax # 0x11ac28 movq %rax, (%rbx) leaq 0x38(%rbx), %rax movq %rax, 0x28(%rbx) andq $0x0, 0x30(%rbx) movb $0x0, 0x38(%rbx) orq $-0x1, 0x48(%rbx) addq $0x28, %rsp popq %rbx popq %r14 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp
antlr::RecognitionException::RecognitionException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RecognitionException::RecognitionException(const ANTLR_USE_NAMESPACE(std)string& s) : ANTLRException(s) , line(-1) , column(-1) { }
pushq %rbx movq %rdi, %rbx callq 0x3239a leaq 0xc5fea(%rip), %rax # 0x11ac28 movq %rax, (%rbx) leaq 0x38(%rbx), %rax movq %rax, 0x28(%rbx) andq $0x0, 0x30(%rbx) movb $0x0, 0x38(%rbx) orq $-0x1, 0x48(%rbx) popq %rbx retq nop
/OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp
antlr::RecognitionException::getFileLineColumnString[abi:cxx11]() const
string RecognitionException::getFileLineColumnString() const { ANTLR_USE_NAMESPACE(std)string fileLineColumnString; if ( fileName.length() > 0 ) fileLineColumnString = fileName + ":"; if ( line != -1 ) { if ( fileName.length() == 0 ) fileLineColumnString = fileLineColumnString + "line "; fileLineColumnString = fileLineColumnString + line; if ( column != -1 ) fileLineColumnString = fileLineColumnString + ":" + column; fileLineColumnString = fileLineColumnString + ":"; } fileLineColumnString = fileLineColumnString + " "; return fileLineColumnString; }
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) andq $0x0, 0x8(%rdi) movq %rsi, %r14 movb $0x0, 0x10(%rdi) cmpq $0x0, 0x30(%rsi) je 0x54cfd leaq 0x28(%r14), %rsi leaq 0x75312(%rip), %rdx # 0xc9ff1 movq %rsp, %rdi callq 0x1a87c movq %rsp, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x13620 movq %r15, %rdi callq 0x13a98 movl 0x48(%r14), %edx cmpl $-0x1, %edx je 0x54dd2 cmpq $0x0, 0x30(%r14) jne 0x54d3d leaq 0x7066b(%rip), %rdx # 0xc5383 movq %rsp, %rdi movq %rbx, %rsi callq 0x1a87c movq %rsp, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x13620 movq %r15, %rdi callq 0x13a98 movl 0x48(%r14), %edx movq %rsp, %rdi movq %rbx, %rsi callq 0x54ec8 movq %rsp, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x13620 movq %r15, %rdi callq 0x13a98 cmpl $-0x1, 0x4c(%r14) je 0x54daa leaq 0x75285(%rip), %rdx # 0xc9ff1 leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x1a87c movl 0x4c(%r14), %edx movq %rsp, %rdi leaq 0x20(%rsp), %rsi callq 0x54ec8 movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x13620 movq %r14, %rdi callq 0x13a98 leaq 0x20(%rsp), %rdi callq 0x13a98 leaq 0x75240(%rip), %rdx # 0xc9ff1 movq %rsp, %rdi movq %rbx, %rsi callq 0x1a87c movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x13620 movq %r14, %rdi callq 0x13a98 leaq 0x75244(%rip), %rdx # 0xca01d movq %rsp, %rdi movq %rbx, %rsi callq 0x1a87c movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x13620 movq %r14, %rdi callq 0x13a98 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq jmp 0x54e20 movq %rax, %r14 leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0x54e23 jmp 0x54e20 jmp 0x54e20 jmp 0x54e20 jmp 0x54e20 movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp
antlr::RecognitionException::toString[abi:cxx11]() const
string RecognitionException::toString() const { return getFileLineColumnString()+getMessage(); }
pushq %r14 pushq %rbx subq $0x48, %rsp movq %rsi, %r14 movq %rdi, %rbx movq (%rsi), %rax leaq 0x28(%rsp), %rdi callq *0x38(%rax) movq (%r14), %rax leaq 0x8(%rsp), %rdi movq %r14, %rsi callq *0x18(%rax) leaq 0x28(%rsp), %rsi leaq 0x8(%rsp), %rdx movq %rbx, %rdi callq 0x1aa36 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0x13a98 movq %rbx, %rax addq $0x48, %rsp popq %rbx popq %r14 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0x54e9d movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp
antlr::charName[abi:cxx11](int)
string charName(int ch) { if (ch == EOF) return "EOF"; else { ANTLR_USE_NAMESPACE(std)string s; // when you think you've seen it all.. an isprint that crashes... ch = ch & 0xFF; #ifdef ANTLR_CCTYPE_NEEDS_STD if( ANTLR_USE_NAMESPACE(std)isprint( ch ) ) #else if( isprint( ch ) ) #endif { s.append("'"); s += ch; s.append("'"); // s += "'"+ch+"'"; } else { s += "0x"; unsigned int t = ch >> 4; if( t < 10 ) s += t | 0x30; else s += t + 0x37; t = ch & 0xF; if( t < 10 ) s += t | 0x30; else s += t + 0x37; } return s; } }
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx cmpl $-0x1, %esi je 0x54fad movl %esi, %r14d leaq 0x10(%rbx), %rax movq %rax, (%rbx) andq $0x0, 0x8(%rbx) movb $0x0, 0x10(%rbx) movzbl %r14b, %ebp movl %ebp, %edi callq 0x13970 testl %eax, %eax je 0x54fc3 leaq 0x73b65(%rip), %rsi # 0xc8aed movq %rbx, %rdi callq 0x13a10 movsbl %r14b, %esi movq %rbx, %rdi callq 0x13420 leaq 0x73b4a(%rip), %rsi # 0xc8aed movq %rbx, %rdi callq 0x13a10 jmp 0x5501a leaq 0x730c0(%rip), %rsi # 0xc8074 leaq 0xf(%rsp), %rdx movq %rbx, %rdi callq 0x1a8b4 jmp 0x5501a leaq 0x73d73(%rip), %rsi # 0xc8d3d movq %rbx, %rdi callq 0x13a10 movl %ebp, %eax shrl $0x4, %eax leal 0x37(%rax), %ecx orb $0x30, %al cmpl $0xa0, %ebp movzbl %al, %eax movzbl %cl, %ecx cmovbl %eax, %ecx movzbl %cl, %esi movq %rbx, %rdi callq 0x13420 andl $0xf, %r14d leal 0x37(%r14), %eax leal 0x30(%r14), %ecx cmpl $0xa, %r14d movzbl %cl, %ecx movzbl %al, %eax cmovbl %ecx, %eax movzbl %al, %esi movq %rbx, %rdi callq 0x13420 movq %rbx, %rax addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq jmp 0x55028 movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/String.cpp
antlr::Token::toString[abi:cxx11]() const
string Token::toString() const { return "[\""+getText()+"\",<"+type+">]"; }
pushq %r15 pushq %r14 pushq %rbx subq $0x80, %rsp movq %rsi, %r14 movq %rdi, %rbx movq (%rsi), %rax leaq 0x60(%rsp), %r15 movq %r15, %rdi callq *0x20(%rax) leaq 0x7390b(%rip), %rsi # 0xc89b0 movq %rsp, %rdi movq %r15, %rdx callq 0x52329 leaq 0x738fc(%rip), %rdx # 0xc89b3 leaq 0x20(%rsp), %rdi movq %rsp, %rsi callq 0x5230a movl 0x10(%r14), %edx leaq 0x40(%rsp), %rdi leaq 0x20(%rsp), %rsi callq 0x54ec8 leaq 0x73c6c(%rip), %rdx # 0xc8d4a leaq 0x40(%rsp), %rsi movq %rbx, %rdi callq 0x5230a leaq 0x40(%rsp), %rdi callq 0x13a98 leaq 0x20(%rsp), %rdi callq 0x13a98 movq %rsp, %rdi callq 0x13a98 leaq 0x60(%rsp), %rdi callq 0x13a98 movq %rbx, %rax addq $0x80, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx leaq 0x40(%rsp), %rdi callq 0x13a98 jmp 0x55133 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0x55142 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0x5514f movq %rax, %rbx leaq 0x60(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/Token.cpp
antlr::TreeParser::reportError(antlr::RecognitionException const&)
void TreeParser::reportError(const RecognitionException& ex) { ANTLR_USE_NAMESPACE(std)cerr << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl; }
pushq %rbx subq $0x20, %rsp movq (%rsi), %rax movq %rsp, %rbx movq %rbx, %rdi callq *0x10(%rax) movq (%rbx), %rsi movq 0xc8df1(%rip), %rdi # 0x11dfd8 callq 0x134b0 movq %rax, %rdi callq 0x13250 movq %rsp, %rdi callq 0x13a98 addq $0x20, %rsp popq %rbx retq movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/antlr/TreeParser.cpp
OpenMD::ForceField::ForceField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ForceField::ForceField(std::string ffName) : wildCardAtomTypeName_("X") { char* tempPath; tempPath = getenv("FORCE_PARAM_PATH"); if (tempPath == NULL) { // convert a macro from compiler to a string in c++ STR_DEFINE(ffPath_, FRC_PATH); } else { ffPath_ = tempPath; } setForceFieldFileName(ffName + ".frc"); /** * The order of adding section parsers is important. * * OptionSectionParser must come first to set options for other * parsers * * DirectionalAtomTypesSectionParser should be added before * AtomTypesSectionParser, and these two section parsers will * actually create "real" AtomTypes (AtomTypesSectionParser will * create AtomType and DirectionalAtomTypesSectionParser will * create DirectionalAtomType, which is a subclass of AtomType and * should come first). * * Other AtomTypes Section Parsers will not create the "real" * AtomType, they only add and set some attributes of the AtomType * (via the Adapters). Thus ordering of these is not important. * AtomTypesSectionParser should be added before other atom type * * The order of BondTypesSectionParser, BendTypesSectionParser and * TorsionTypesSectionParser, etc. are not important. */ spMan_.push_back(new OptionSectionParser(forceFieldOptions_)); spMan_.push_back(new BaseAtomTypesSectionParser()); spMan_.push_back(new DirectionalAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new AtomTypesSectionParser()); spMan_.push_back( new LennardJonesAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new ChargeAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new MultipoleAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back( new FluctuatingChargeAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new PolarizableAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new GayBerneAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new EAMAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new SCAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new UFFAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new ShapeAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new StickyAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new StickyPowerAtomTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new BondTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new BendTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new TorsionTypesSectionParser(forceFieldOptions_)); spMan_.push_back(new InversionTypesSectionParser(forceFieldOptions_)); spMan_.push_back( new NonBondedInteractionsSectionParser(forceFieldOptions_)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx leaq 0xc590c(%rip), %rax # 0x11adc0 movq %rax, (%rdi) andl $0x0, 0x8(%rdi) leaq 0x18(%rdi), %rax andl $0x0, 0x18(%rdi) andq $0x0, 0x20(%rdi) movq %rax, 0x28(%rdi) movq %rax, 0x30(%rdi) andq $0x0, 0x38(%rdi) andl $0x0, 0x40(%rdi) leaq 0x50(%rdi), %rax andl $0x0, 0x50(%rdi) andq $0x0, 0x58(%rdi) movq %rax, 0x60(%rdi) movq %rax, 0x68(%rdi) andq $0x0, 0x70(%rdi) andl $0x0, 0x78(%rdi) leaq 0x88(%rdi), %rax andl $0x0, 0x88(%rdi) andq $0x0, 0x90(%rdi) movq %rax, 0x98(%rdi) movq %rax, 0xa0(%rdi) andq $0x0, 0xa8(%rdi) andl $0x0, 0xb0(%rdi) leaq 0xc0(%rdi), %rax andl $0x0, 0xc0(%rdi) andq $0x0, 0xc8(%rdi) movq %rax, 0xd0(%rdi) movq %rax, 0xd8(%rdi) andq $0x0, 0xe0(%rdi) andl $0x0, 0xe8(%rdi) leaq 0xf8(%rdi), %rax andl $0x0, 0xf8(%rdi) andq $0x0, 0x100(%rdi) movq %rax, 0x108(%rdi) movq %rax, 0x110(%rdi) andq $0x0, 0x118(%rdi) andl $0x0, 0x120(%rdi) andl $0x0, 0x130(%rdi) andq $0x0, 0x138(%rdi) movq %rsi, %r12 leaq 0x130(%rdi), %rax movq %rax, 0x140(%rdi) movq %rax, 0x148(%rdi) andq $0x0, 0x150(%rdi) leaq 0x158(%rdi), %r14 movq %r14, %rdi callq 0x77320 andl $0x0, 0x810(%rbx) andq $0x0, 0x818(%rbx) leaq 0x810(%rbx), %rax movq %rax, 0x820(%rbx) movq %rax, 0x828(%rbx) andq $0x0, 0x830(%rbx) movabsq $0x6400000000, %rax # imm = 0x6400000000 movq %rax, 0x838(%rbx) leaq 0x840(%rbx), %rax movq %rax, 0x848(%rbx) movq %rax, 0x840(%rbx) andq $0x0, 0x850(%rbx) leaq 0x868(%rbx), %rax movq %rax, 0x858(%rbx) andq $0x0, 0x860(%rbx) leaq 0x838(%rbx), %r15 leaq 0x858(%rbx), %r13 movb $0x0, 0x868(%rbx) leaq 0x878(%rbx), %rdi leaq 0x72d30(%rip), %rsi # 0xc8391 leaq 0x18(%rsp), %rdx movq %rdi, 0x8(%rsp) movq %r13, 0x10(%rsp) callq 0x1a8b4 leaq 0x898(%rbx), %rbp leaq 0x8a8(%rbx), %rax movq %rax, 0x898(%rbx) andq $0x0, 0x8a0(%rbx) movb $0x0, 0x8a8(%rbx) leaq 0x73715(%rip), %rdi # 0xc8db5 callq 0x13610 testq %rax, %rax leaq 0x73717(%rip), %rsi # 0xc8dc6 cmovneq %rax, %rsi movq %r13, %rdi callq 0x13a20 leaq 0x70fd4(%rip), %rdx # 0xc6696 leaq 0x18(%rsp), %rdi movq %r12, %rsi callq 0x1a87c leaq 0x18(%rsp), %rsi movq %rbp, %rdi callq 0x13280 leaq 0x18(%rsp), %rdi callq 0x13a98 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8b8ac movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi callq 0x726d0 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x7320c movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi callq 0x723f0 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x89230 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x73000 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x894ac movq %r15, %rdi movq %r12, %rsi callq 0x8de84 movl $0x80, %edi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x76240 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8d494 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x79118 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x40 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x7343c movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8d674 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x9047c movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8e898 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8fb20 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x8fdf4 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x72d58 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x72a70 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x900c8 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x28 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x88f14 movq %r15, %rdi movq %r12, %rsi callq 0x8de84 pushq $0x78 popq %rdi callq 0x134d0 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi callq 0x89c6c movq %r15, %rdi movq %r12, %rsi callq 0x8de84 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, (%rsp) pushq $0x78 jmp 0x559ef jmp 0x559e1 jmp 0x559e9 jmp 0x559e9 jmp 0x559e9 jmp 0x559e9 jmp 0x559e9 jmp 0x559e1 jmp 0x559e9 jmp 0x559e9 movq %rax, (%rsp) pushq $0x40 jmp 0x559ef jmp 0x559e9 jmp 0x559e1 movq %rax, (%rsp) movl $0x80, %esi jmp 0x559f0 jmp 0x559e1 jmp 0x559e9 jmp 0x559e9 jmp 0x559e1 jmp 0x559e1 movq %rax, (%rsp) pushq $0x28 jmp 0x559ef movq %rax, (%rsp) pushq $0x30 popq %rsi movq %r12, %rdi callq 0x134e0 jmp 0x55a1c movq %rax, (%rsp) leaq 0x18(%rsp), %rdi callq 0x13a98 jmp 0x55a1c jmp 0x55a18 movq %rax, (%rsp) jmp 0x55a2e movq %rax, (%rsp) jmp 0x55a57 movq %rax, (%rsp) movq %rbp, %rdi callq 0x13a98 movq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x808(%rbx), %r12 movq 0x10(%rsp), %rdi callq 0x13a98 movq %r15, %rdi callq 0x8d8e0 movq %r12, %rdi callq 0x59318 movq %r14, %rdi callq 0x57dd8 leaq 0x8(%rbx), %r14 leaq 0x40(%rbx), %r15 leaq 0x78(%rbx), %r12 leaq 0xb0(%rbx), %r13 leaq 0xe8(%rbx), %rbp addq $0x120, %rbx # imm = 0x120 movq %rbx, %rdi callq 0x57f24 movq %rbp, %rdi callq 0x57f46 movq %r13, %rdi callq 0x57f68 movq %r12, %rdi callq 0x57f8a movq %r15, %rdi callq 0x57fac movq %r14, %rdi callq 0x57fce movq (%rsp), %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ForceField::parse(const std::string& filename) { ifstrstream* ffStream; ffStream = openForceFieldFile(filename); spMan_.parse(*ffStream, *this); ForceField::AtomTypeContainer::MapTypeIterator i; AtomType* at; for (at = atomTypeCont_.beginType(i); at != NULL; at = atomTypeCont_.nextType(i)) { // useBase sets the responsibilities, and these have to be done // after the atomTypes and Base types have all been scanned: std::vector<AtomType*> ayb = at->allYourBase(); if (ayb.size() > 1) { for (int j = ayb.size() - 1; j > 0; j--) { ayb[j - 1]->useBase(ayb[j]); } } } delete ffStream; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rdi, %rbx callq 0x55b92 movq %rax, %r14 leaq 0x838(%rbx), %rdi movq %rax, %rsi movq %rbx, %rdx callq 0x8d91e movq 0x28(%rbx), %rax movq %rax, (%rsp) leaq 0x18(%rbx), %rcx cmpq %rcx, %rax je 0x55af3 movq 0x40(%rax), %rsi jmp 0x55af5 xorl %esi, %esi addq $0x8, %rbx leaq 0x8(%rsp), %r15 movq %rsp, %r12 testq %rsi, %rsi je 0x55b66 movq %r15, %rdi callq 0x9ceda movq 0x10(%rsp), %rax subq 0x8(%rsp), %rax sarq $0x3, %rax cmpq $0x2, %rax jb 0x55b4e movl %eax, %eax leaq -0x1(%rax), %r13 testl %r13d, %r13d jle 0x55b4e movq 0x8(%rsp), %rcx movq -0x10(%rcx,%rax,8), %rdi movl %r13d, %eax andl $0x7fffffff, %eax # imm = 0x7FFFFFFF movq (%rcx,%rax,8), %rsi movq (%rdi), %rax callq *0x10(%rax) movq %r13, %rax jmp 0x55b24 movq %r15, %rdi callq 0x5962c movq %rbx, %rdi movq %r12, %rsi callq 0x57ff0 movq %rax, %rsi jmp 0x55b01 movq (%r14), %rax movq %r14, %rdi callq *0x8(%rax) addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x5962c movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getBendType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BendType* ForceField::getBendType(const std::string& at1, const std::string& at2, const std::string& at3) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); // try exact match first BendType* bendType = bendTypeCont_.find(keys); if (bendType) { return bendType; } else { AtomType* atype1; AtomType* atype2; AtomType* atype3; std::vector<std::string> at1key; at1key.push_back(at1); atype1 = atomTypeCont_.find(at1key); std::vector<std::string> at2key; at2key.push_back(at2); atype2 = atomTypeCont_.find(at2key); std::vector<std::string> at3key; at3key.push_back(at3); atype3 = atomTypeCont_.find(at3key); // query atom types for their chains of responsibility std::vector<AtomType*> at1Chain = atype1->allYourBase(); std::vector<AtomType*> at2Chain = atype2->allYourBase(); std::vector<AtomType*> at3Chain = atype3->allYourBase(); std::vector<AtomType*>::iterator i; std::vector<AtomType*>::iterator j; std::vector<AtomType*>::iterator k; int ii = 0; int jj = 0; int kk = 0; int IKscore; std::vector<std::tuple<int, int, std::vector<std::string>>> foundBends; for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { ii = 0; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { kk = 0; for (k = at3Chain.begin(); k != at3Chain.end(); ++k) { IKscore = ii + kk; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); myKeys.push_back((*k)->getName()); BendType* bendType = bendTypeCont_.find(myKeys); if (bendType) { foundBends.push_back(std::make_tuple(jj, IKscore, myKeys)); } kk++; } ii++; } jj++; } if (!foundBends.empty()) { std::sort(foundBends.begin(), foundBends.end()); std::vector<std::string> theKeys = std::get<2>(foundBends[0]); BendType* bestType = bendTypeCont_.find(theKeys); return bestType; } else { // if no exact match found, try wild card match return bendTypeCont_.find(keys, wildCardAtomTypeName_); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x148, %rsp # imm = 0x148 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %rbp movq %rdi, %rbx xorps %xmm0, %xmm0 leaq 0x60(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e leaq 0x60(%rsp), %rdi movq %r12, %rsi callq 0x5801e leaq 0x60(%rsp), %rdi movq %r15, %rsi callq 0x5801e leaq 0x78(%rbx), %rdi leaq 0x60(%rsp), %rsi movq %rdi, 0x10(%rsp) callq 0x583ee movq %rax, %r13 testq %rax, %rax jne 0x563f3 xorps %xmm0, %xmm0 leaq 0x130(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %rbp, %rsi callq 0x5801e leaq 0x8(%rbx), %rbp leaq 0x130(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r13 xorps %xmm0, %xmm0 leaq 0x110(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r12, %rsi callq 0x5801e leaq 0x110(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r12 xorps %xmm0, %xmm0 leaq 0xf0(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r15, %rsi callq 0x5801e leaq 0xf0(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r15 leaq 0xb8(%rsp), %rdi movq %r13, %rsi callq 0x9ceda leaq 0xa0(%rsp), %rdi movq %r12, %rsi callq 0x9ceda movq %rbx, 0x80(%rsp) leaq 0x88(%rsp), %rdi movq %r15, %rsi callq 0x9ceda xorps %xmm0, %xmm0 leaq 0x40(%rsp), %rax movaps %xmm0, (%rax) andq $0x0, 0x10(%rax) movl $0x0, 0xc(%rsp) movq 0xa0(%rsp), %rbx leaq 0x20(%rsp), %r12 leaq 0xd0(%rsp), %r13 cmpq 0xa8(%rsp), %rbx je 0x56339 xorl %ebp, %ebp movq 0xb8(%rsp), %r15 cmpq 0xc0(%rsp), %r15 je 0x5632c movq 0x88(%rsp), %r14 movl %ebp, 0x1c(%rsp) cmpq 0x90(%rsp), %r14 je 0x5631d xorps %xmm0, %xmm0 movaps %xmm0, 0xd0(%rsp) andq $0x0, 0xe0(%rsp) movq (%r15), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%rbx), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%r14), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq 0x10(%rsp), %rdi movq %r13, %rsi callq 0x583ee testq %rax, %rax je 0x5630a movq %r12, %rdi movq %r13, %rsi callq 0x5816a movl %ebp, 0x38(%rsp) movl 0xc(%rsp), %eax movl %eax, 0x3c(%rsp) leaq 0x40(%rsp), %rdi movq %r12, %rsi callq 0x5ad82 movq %r12, %rdi callq 0x1d0d0 movq %r13, %rdi callq 0x1d0d0 addq $0x8, %r14 incl %ebp jmp 0x56250 movl 0x1c(%rsp), %ebp incl %ebp addq $0x8, %r15 jmp 0x56236 incl 0xc(%rsp) addq $0x8, %rbx jmp 0x5621e movq 0x40(%rsp), %rdi movq 0x48(%rsp), %rsi cmpq %rsi, %rdi je 0x5637a callq 0x5af87 movq 0x40(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x5816a leaq 0x20(%rsp), %rsi movq 0x10(%rsp), %rdi callq 0x583ee movq %rax, %r13 leaq 0x20(%rsp), %rdi callq 0x1d0d0 jmp 0x5639b movq 0x80(%rsp), %rdx addq $0x878, %rdx # imm = 0x878 leaq 0x60(%rsp), %rsi movq 0x10(%rsp), %rdi callq 0x5847e movq %rax, %r13 leaq 0x40(%rsp), %rdi callq 0x5868c leaq 0x88(%rsp), %rdi callq 0x5962c leaq 0xa0(%rsp), %rdi callq 0x5962c leaq 0xb8(%rsp), %rdi callq 0x5962c leaq 0xf0(%rsp), %rdi callq 0x1d0d0 leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x60(%rsp), %rdi callq 0x1d0d0 movq %r13, %rax addq $0x148, %rsp # imm = 0x148 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x20(%rsp), %rdi jmp 0x56489 jmp 0x5641e movq %rax, %rbx jmp 0x5648e movq %rax, %rbx jmp 0x564a5 movq %rax, %rbx jmp 0x564b2 jmp 0x56432 movq %rax, %rbx jmp 0x564bf movq %rax, %rbx jmp 0x564cc movq %rax, %rbx jmp 0x564d9 jmp 0x5644c movq %rax, %rbx jmp 0x564e6 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x1d0d0 jmp 0x56481 jmp 0x5647e jmp 0x5646d jmp 0x5647e jmp 0x5646d jmp 0x5647e movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0x56481 jmp 0x5647e movq %rax, %rbx leaq 0xd0(%rsp), %rdi callq 0x1d0d0 leaq 0x40(%rsp), %rdi callq 0x5868c leaq 0x88(%rsp), %rdi callq 0x5962c leaq 0xa0(%rsp), %rdi callq 0x5962c leaq 0xb8(%rsp), %rdi callq 0x5962c leaq 0xf0(%rsp), %rdi callq 0x1d0d0 leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x60(%rsp), %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getTorsionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TorsionType* ForceField::getTorsionType(const std::string& at1, const std::string& at2, const std::string& at3, const std::string& at4) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); keys.push_back(at4); // try exact match first TorsionType* torsionType = torsionTypeCont_.find(keys); if (torsionType) { return torsionType; } else { AtomType* atype1; AtomType* atype2; AtomType* atype3; AtomType* atype4; std::vector<std::string> at1key; at1key.push_back(at1); atype1 = atomTypeCont_.find(at1key); std::vector<std::string> at2key; at2key.push_back(at2); atype2 = atomTypeCont_.find(at2key); std::vector<std::string> at3key; at3key.push_back(at3); atype3 = atomTypeCont_.find(at3key); std::vector<std::string> at4key; at4key.push_back(at4); atype4 = atomTypeCont_.find(at4key); // query atom types for their chains of responsibility std::vector<AtomType*> at1Chain = atype1->allYourBase(); std::vector<AtomType*> at2Chain = atype2->allYourBase(); std::vector<AtomType*> at3Chain = atype3->allYourBase(); std::vector<AtomType*> at4Chain = atype4->allYourBase(); std::vector<AtomType*>::iterator i; std::vector<AtomType*>::iterator j; std::vector<AtomType*>::iterator k; std::vector<AtomType*>::iterator l; int ii = 0; int jj = 0; int kk = 0; int ll = 0; int ILscore; int JKscore; std::vector<std::tuple<int, int, std::vector<std::string>>> foundTorsions; for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { kk = 0; for (k = at3Chain.begin(); k != at3Chain.end(); ++k) { ii = 0; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { ll = 0; for (l = at4Chain.begin(); l != at4Chain.end(); ++l) { ILscore = ii + ll; JKscore = jj + kk; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); myKeys.push_back((*k)->getName()); myKeys.push_back((*l)->getName()); TorsionType* torsionType = torsionTypeCont_.find(myKeys); if (torsionType) { foundTorsions.push_back( std::make_tuple(JKscore, ILscore, myKeys)); } ll++; } ii++; } kk++; } jj++; } if (!foundTorsions.empty()) { std::sort(foundTorsions.begin(), foundTorsions.end()); std::vector<std::string> theKeys = std::get<2>(foundTorsions[0]); TorsionType* bestType = torsionTypeCont_.find(theKeys); return bestType; } else { // if no exact match found, try wild card match for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { kk = 0; for (k = at3Chain.begin(); k != at3Chain.end(); ++k) { ii = 0; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { ll = 0; for (l = at4Chain.begin(); l != at4Chain.end(); ++l) { ILscore = ii + ll; JKscore = jj + kk; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); myKeys.push_back((*k)->getName()); myKeys.push_back((*l)->getName()); TorsionType* torsionType = torsionTypeCont_.find(myKeys, wildCardAtomTypeName_); if (torsionType) { foundTorsions.push_back( std::make_tuple(JKscore, ILscore, myKeys)); } ll++; } ii++; } kk++; } jj++; } if (!foundTorsions.empty()) { std::sort(foundTorsions.begin(), foundTorsions.end()); std::vector<std::string> theKeys = std::get<2>(foundTorsions[0]); TorsionType* bestType = torsionTypeCont_.find(theKeys, wildCardAtomTypeName_); return bestType; } else { return NULL; } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x188, %rsp # imm = 0x188 movq %r8, %rbx movq %rcx, %r12 movq %rdx, %r13 movq %rsi, %r15 movq %rdi, 0x18(%rsp) xorps %xmm0, %xmm0 leaq 0x90(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e leaq 0x90(%rsp), %rdi movq %r13, %rsi callq 0x5801e leaq 0x90(%rsp), %rdi movq %r12, %rsi callq 0x5801e leaq 0x90(%rsp), %rdi movq %rbx, %rsi callq 0x5801e movq 0x18(%rsp), %rax leaq 0xb0(%rax), %rdi leaq 0x90(%rsp), %rsi movq %rdi, 0x48(%rsp) callq 0x586ae movq %rax, %rbp testq %rax, %rax je 0x565aa leaq 0x90(%rsp), %rdi callq 0x1d0d0 movq %rbp, %rax addq $0x188, %rsp # imm = 0x188 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq xorps %xmm0, %xmm0 leaq 0x170(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r15, %rsi callq 0x5801e movq 0x18(%rsp), %rax leaq 0x8(%rax), %rbp leaq 0x170(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r14 xorps %xmm0, %xmm0 leaq 0x150(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r13, %rsi callq 0x5801e leaq 0x150(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r15 xorps %xmm0, %xmm0 leaq 0x130(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r12, %rsi callq 0x5801e leaq 0x130(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r12 xorps %xmm0, %xmm0 leaq 0x110(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %rbx, %rsi callq 0x5801e leaq 0x110(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r13 leaq 0xf8(%rsp), %rdi movq %r14, %rsi callq 0x9ceda leaq 0xe0(%rsp), %rdi movq %r15, %rsi callq 0x9ceda leaq 0xc8(%rsp), %rdi movq %r12, %rsi callq 0x9ceda leaq 0xb0(%rsp), %rdi movq %r13, %rsi callq 0x9ceda xorps %xmm0, %xmm0 leaq 0x50(%rsp), %rax movaps %xmm0, (%rax) andq $0x0, 0x10(%rax) movq $0x0, 0x10(%rsp) movq 0xe0(%rsp), %rax leaq 0x28(%rsp), %r12 leaq 0x70(%rsp), %r13 cmpq 0xe8(%rsp), %rax je 0x56863 movq %rax, 0x20(%rsp) movq $0x0, (%rsp) movq 0xc8(%rsp), %rbx cmpq 0xd0(%rsp), %rbx je 0x56849 movq 0xf8(%rsp), %r15 movq 0x10(%rsp), %rax movq (%rsp), %rcx addl %ecx, %eax movl %eax, 0xc(%rsp) xorl %ebp, %ebp cmpq 0x100(%rsp), %r15 je 0x56836 movq 0xb0(%rsp), %r14 movl %ebp, 0x8(%rsp) cmpq 0xb8(%rsp), %r14 je 0x56827 xorps %xmm0, %xmm0 movaps %xmm0, 0x70(%rsp) andq $0x0, 0x80(%rsp) movq (%r15), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq 0x20(%rsp), %rax movq (%rax), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%rbx), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%r14), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq 0x48(%rsp), %rdi movq %r13, %rsi callq 0x586ae testq %rax, %rax je 0x56814 movq %r12, %rdi movq %r13, %rsi callq 0x5816a movl %ebp, 0x40(%rsp) movl 0xc(%rsp), %eax movl %eax, 0x44(%rsp) leaq 0x50(%rsp), %rdi movq %r12, %rsi callq 0x5ad82 movq %r12, %rdi callq 0x1d0d0 movq %r13, %rdi callq 0x1d0d0 addq $0x8, %r14 incl %ebp jmp 0x5673a movl 0x8(%rsp), %ebp incl %ebp addq $0x8, %r15 jmp 0x56720 movq (%rsp), %rax incl %eax movq %rax, (%rsp) addq $0x8, %rbx jmp 0x566f9 movq 0x10(%rsp), %rax incl %eax movq %rax, 0x10(%rsp) movq 0x20(%rsp), %rax addq $0x8, %rax jmp 0x566d6 movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi cmpq %rsi, %rdi je 0x5691d callq 0x5af87 movq 0x50(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x5816a leaq 0x28(%rsp), %rsi movq 0x48(%rsp), %rdi callq 0x586ae movq %rax, %rbp leaq 0x28(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x5868c leaq 0xb0(%rsp), %rdi callq 0x5962c leaq 0xc8(%rsp), %rdi callq 0x5962c leaq 0xe0(%rsp), %rdi callq 0x5962c leaq 0xf8(%rsp), %rdi callq 0x5962c leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x150(%rsp), %rdi callq 0x1d0d0 leaq 0x170(%rsp), %rdi callq 0x1d0d0 jmp 0x56588 movq 0xe0(%rsp), %rcx addq $0x878, 0x18(%rsp) # imm = 0x878 leaq 0x28(%rsp), %r15 leaq 0x70(%rsp), %r12 cmpq %rax, %rcx je 0x56ad4 movq %rcx, 0x20(%rsp) movq $0x0, (%rsp) movq 0xc8(%rsp), %rbp cmpq 0xd0(%rsp), %rbp je 0x56ab2 movq 0xf8(%rsp), %rbx movq 0x10(%rsp), %rax movq (%rsp), %rcx addl %ecx, %eax movl %eax, 0xc(%rsp) xorl %r13d, %r13d cmpq 0x100(%rsp), %rbx je 0x56a9f movq 0xb0(%rsp), %r14 movl %r13d, 0x8(%rsp) cmpq 0xb8(%rsp), %r14 je 0x56a8e xorps %xmm0, %xmm0 movaps %xmm0, 0x70(%rsp) andq $0x0, 0x80(%rsp) movq (%rbx), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq 0x20(%rsp), %rax movq (%rax), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq (%rbp), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq (%r14), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq 0x48(%rsp), %rdi movq %r12, %rsi movq 0x18(%rsp), %rdx callq 0x5873e testq %rax, %rax je 0x56a7a movq %r15, %rdi movq %r12, %rsi callq 0x5816a movl %r13d, 0x40(%rsp) movl 0xc(%rsp), %eax movl %eax, 0x44(%rsp) leaq 0x50(%rsp), %rdi movq %r15, %rsi callq 0x5ad82 movq %r15, %rdi callq 0x1d0d0 movq %r12, %rdi callq 0x1d0d0 addq $0x8, %r14 incl %r13d jmp 0x56999 movl 0x8(%rsp), %r13d incl %r13d addq $0x8, %rbx jmp 0x5697e movq (%rsp), %rax incl %eax movq %rax, (%rsp) addq $0x8, %rbp jmp 0x56956 movq 0x10(%rsp), %rax incl %eax movq %rax, 0x10(%rsp) movq 0x20(%rsp), %rcx addq $0x8, %rcx movq 0xe8(%rsp), %rax jmp 0x56938 movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi cmpq %rsi, %rdi je 0x56b10 callq 0x5af87 movq 0x50(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x5816a leaq 0x28(%rsp), %rsi movq 0x48(%rsp), %rdi movq 0x18(%rsp), %rdx callq 0x5873e jmp 0x56899 xorl %ebp, %ebp jmp 0x568a6 jmp 0x56b1b jmp 0x56b2a movq %rax, %rbx leaq 0x28(%rsp), %rdi jmp 0x56bc2 jmp 0x56b2a movq %rax, %rbx jmp 0x56bc7 movq %rax, %rbx jmp 0x56bde movq %rax, %rbx jmp 0x56beb movq %rax, %rbx jmp 0x56bf8 jmp 0x56b4c movq %rax, %rbx jmp 0x56c05 movq %rax, %rbx jmp 0x56c12 movq %rax, %rbx jmp 0x56c1f movq %rax, %rbx jmp 0x56c2c jmp 0x56b6e movq %rax, %rbx jmp 0x56c39 jmp 0x56b8c jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bba jmp 0x56bab jmp 0x56bba movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x1d0d0 jmp 0x56bbd jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bab jmp 0x56bba jmp 0x56bba movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 jmp 0x56bbd movq %rax, %rbx leaq 0x70(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x5868c leaq 0xb0(%rsp), %rdi callq 0x5962c leaq 0xc8(%rsp), %rdi callq 0x5962c leaq 0xe0(%rsp), %rdi callq 0x5962c leaq 0xf8(%rsp), %rdi callq 0x5962c leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x150(%rsp), %rdi callq 0x1d0d0 leaq 0x170(%rsp), %rdi callq 0x1d0d0 leaq 0x90(%rsp), %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getInversionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
InversionType* ForceField::getInversionType(const std::string& at1, const std::string& at2, const std::string& at3, const std::string& at4) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); keys.push_back(at4); // try exact match first InversionType* inversionType = inversionTypeCont_.permutedFindSkippingFirstElement(keys); if (inversionType) { return inversionType; } else { AtomType* atype1; AtomType* atype2; AtomType* atype3; AtomType* atype4; std::vector<std::string> at1key; at1key.push_back(at1); atype1 = atomTypeCont_.find(at1key); std::vector<std::string> at2key; at2key.push_back(at2); atype2 = atomTypeCont_.find(at2key); std::vector<std::string> at3key; at3key.push_back(at3); atype3 = atomTypeCont_.find(at3key); std::vector<std::string> at4key; at4key.push_back(at4); atype4 = atomTypeCont_.find(at4key); // query atom types for their chains of responsibility std::vector<AtomType*> at1Chain = atype1->allYourBase(); std::vector<AtomType*> at2Chain = atype2->allYourBase(); std::vector<AtomType*> at3Chain = atype3->allYourBase(); std::vector<AtomType*> at4Chain = atype4->allYourBase(); std::vector<AtomType*>::iterator i; std::vector<AtomType*>::iterator j; std::vector<AtomType*>::iterator k; std::vector<AtomType*>::iterator l; int ii = 0; int jj = 0; int kk = 0; int ll = 0; int Iscore; int JKLscore; std::vector<std::tuple<int, int, std::vector<std::string>>> foundInversions; for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { kk = 0; for (k = at3Chain.begin(); k != at3Chain.end(); ++k) { ii = 0; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { ll = 0; for (l = at4Chain.begin(); l != at4Chain.end(); ++l) { Iscore = ii; JKLscore = jj + kk + ll; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); myKeys.push_back((*k)->getName()); myKeys.push_back((*l)->getName()); InversionType* inversionType = inversionTypeCont_.permutedFindSkippingFirstElement(myKeys); if (inversionType) { foundInversions.push_back( std::make_tuple(Iscore, JKLscore, myKeys)); } ll++; } ii++; } kk++; } jj++; } if (!foundInversions.empty()) { std::sort(foundInversions.begin(), foundInversions.end()); std::vector<std::string> theKeys = std::get<2>(foundInversions[0]); InversionType* bestType = inversionTypeCont_.permutedFindSkippingFirstElement(theKeys); return bestType; } else { // if no exact match found, try wild card match for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { kk = 0; for (k = at3Chain.begin(); k != at3Chain.end(); ++k) { ii = 0; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { ll = 0; for (l = at4Chain.begin(); l != at4Chain.end(); ++l) { Iscore = ii; JKLscore = jj + kk + ll; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); myKeys.push_back((*k)->getName()); myKeys.push_back((*l)->getName()); InversionType* inversionType = inversionTypeCont_.permutedFindSkippingFirstElement( myKeys, wildCardAtomTypeName_); if (inversionType) { foundInversions.push_back( std::make_tuple(Iscore, JKLscore, myKeys)); } ll++; } ii++; } kk++; } jj++; } if (!foundInversions.empty()) { std::sort(foundInversions.begin(), foundInversions.end()); std::vector<std::string> theKeys = std::get<2>(foundInversions[0]); InversionType* bestType = inversionTypeCont_.permutedFindSkippingFirstElement( theKeys, wildCardAtomTypeName_); return bestType; } else { return NULL; } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x188, %rsp # imm = 0x188 movq %r8, %rbx movq %rcx, %r12 movq %rdx, %r13 movq %rsi, %r15 movq %rdi, 0x18(%rsp) xorps %xmm0, %xmm0 leaq 0x90(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e leaq 0x90(%rsp), %rdi movq %r13, %rsi callq 0x5801e leaq 0x90(%rsp), %rdi movq %r12, %rsi callq 0x5801e leaq 0x90(%rsp), %rdi movq %rbx, %rsi callq 0x5801e movq 0x18(%rsp), %rax leaq 0xe8(%rax), %rdi leaq 0x90(%rsp), %rsi movq %rdi, 0x48(%rsp) callq 0x5894c movq %rax, %rbp testq %rax, %rax je 0x56d00 leaq 0x90(%rsp), %rdi callq 0x1d0d0 movq %rbp, %rax addq $0x188, %rsp # imm = 0x188 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq xorps %xmm0, %xmm0 leaq 0x170(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r15, %rsi callq 0x5801e movq 0x18(%rsp), %rax leaq 0x8(%rax), %rbp leaq 0x170(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r14 xorps %xmm0, %xmm0 leaq 0x150(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r13, %rsi callq 0x5801e leaq 0x150(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r15 xorps %xmm0, %xmm0 leaq 0x130(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r12, %rsi callq 0x5801e leaq 0x130(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r12 xorps %xmm0, %xmm0 leaq 0x110(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %rbx, %rsi callq 0x5801e leaq 0x110(%rsp), %rsi movq %rbp, %rdi callq 0x5804a movq %rax, %r13 leaq 0xf8(%rsp), %rdi movq %r14, %rsi callq 0x9ceda leaq 0xe0(%rsp), %rdi movq %r15, %rsi callq 0x9ceda leaq 0xc8(%rsp), %rdi movq %r12, %rsi callq 0x9ceda leaq 0xb0(%rsp), %rdi movq %r13, %rsi callq 0x9ceda xorps %xmm0, %xmm0 leaq 0x50(%rsp), %rax movaps %xmm0, (%rax) andq $0x0, 0x10(%rax) movl $0x0, 0x14(%rsp) movq 0xe0(%rsp), %rax leaq 0x28(%rsp), %r12 leaq 0x70(%rsp), %r13 cmpq 0xe8(%rsp), %rax je 0x56f9f movq %rax, 0x20(%rsp) movq 0xc8(%rsp), %rbx movl 0x14(%rsp), %eax movl %eax, 0xc(%rsp) cmpq 0xd0(%rsp), %rbx je 0x56f8d movl $0x0, 0x10(%rsp) movq 0xf8(%rsp), %r14 cmpq 0x100(%rsp), %r14 je 0x56f80 movq 0xb0(%rsp), %r15 movl 0xc(%rsp), %ebp cmpq 0xb8(%rsp), %r15 je 0x56f73 xorps %xmm0, %xmm0 movaps %xmm0, 0x70(%rsp) andq $0x0, 0x80(%rsp) movq (%r14), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq 0x20(%rsp), %rax movq (%rax), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%rbx), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq (%r15), %rsi movq %r12, %rdi callq 0x9caa0 movq %r13, %rdi movq %r12, %rsi callq 0x59d6c movq %r12, %rdi callq 0x13a98 movq 0x48(%rsp), %rdi movq %r13, %rsi callq 0x5894c testq %rax, %rax je 0x56f60 movq %r12, %rdi movq %r13, %rsi callq 0x5816a movl %ebp, 0x40(%rsp) movl 0x10(%rsp), %eax movl %eax, 0x44(%rsp) leaq 0x50(%rsp), %rdi movq %r12, %rsi callq 0x5ad82 movq %r12, %rdi callq 0x1d0d0 movq %r13, %rdi callq 0x1d0d0 addq $0x8, %r15 incl %ebp jmp 0x56e86 incl 0x10(%rsp) addq $0x8, %r14 jmp 0x56e6c addq $0x8, %rbx incl 0xc(%rsp) jmp 0x56e4e incl 0x14(%rsp) movq 0x20(%rsp), %rax addq $0x8, %rax jmp 0x56e2b movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi cmpq %rsi, %rdi je 0x57059 callq 0x5af87 movq 0x50(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x5816a leaq 0x28(%rsp), %rsi movq 0x48(%rsp), %rdi callq 0x5894c movq %rax, %rbp leaq 0x28(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x5868c leaq 0xb0(%rsp), %rdi callq 0x5962c leaq 0xc8(%rsp), %rdi callq 0x5962c leaq 0xe0(%rsp), %rdi callq 0x5962c leaq 0xf8(%rsp), %rdi callq 0x5962c leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x150(%rsp), %rdi callq 0x1d0d0 leaq 0x170(%rsp), %rdi callq 0x1d0d0 jmp 0x56cde movq 0xe0(%rsp), %rcx addq $0x878, 0x18(%rsp) # imm = 0x878 leaq 0x28(%rsp), %r15 leaq 0x70(%rsp), %r12 cmpq %rax, %rcx je 0x571f4 movq %rcx, 0x20(%rsp) movq 0xc8(%rsp), %rbp movl 0x14(%rsp), %eax movl %eax, 0xc(%rsp) cmpq 0xd0(%rsp), %rbp je 0x571da movl $0x0, 0x10(%rsp) movq 0xf8(%rsp), %rbx cmpq 0x100(%rsp), %rbx je 0x571cd movq 0xb0(%rsp), %r14 movl 0xc(%rsp), %r13d cmpq 0xb8(%rsp), %r14 je 0x571c0 xorps %xmm0, %xmm0 movaps %xmm0, 0x70(%rsp) andq $0x0, 0x80(%rsp) movq (%rbx), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq 0x20(%rsp), %rax movq (%rax), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq (%rbp), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq (%r14), %rsi movq %r15, %rdi callq 0x9caa0 movq %r12, %rdi movq %r15, %rsi callq 0x59d6c movq %r15, %rdi callq 0x13a98 movq 0x48(%rsp), %rdi movq %r12, %rsi movq 0x18(%rsp), %rdx callq 0x589e8 testq %rax, %rax je 0x571ac movq %r15, %rdi movq %r12, %rsi callq 0x5816a movl %r13d, 0x40(%rsp) movl 0x10(%rsp), %eax movl %eax, 0x44(%rsp) leaq 0x50(%rsp), %rdi movq %r15, %rsi callq 0x5ad82 movq %r15, %rdi callq 0x1d0d0 movq %r12, %rdi callq 0x1d0d0 addq $0x8, %r14 incl %r13d jmp 0x570cb incl 0x10(%rsp) addq $0x8, %rbx jmp 0x570b0 addq $0x8, %rbp incl 0xc(%rsp) jmp 0x57092 incl 0x14(%rsp) movq 0x20(%rsp), %rcx addq $0x8, %rcx movq 0xe8(%rsp), %rax jmp 0x57074 movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi cmpq %rsi, %rdi je 0x57230 callq 0x5af87 movq 0x50(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x5816a leaq 0x28(%rsp), %rsi movq 0x48(%rsp), %rdi movq 0x18(%rsp), %rdx callq 0x589e8 jmp 0x56fd5 xorl %ebp, %ebp jmp 0x56fe2 jmp 0x5723b jmp 0x5724a movq %rax, %rbx leaq 0x28(%rsp), %rdi jmp 0x572e2 jmp 0x5724a movq %rax, %rbx jmp 0x572e7 movq %rax, %rbx jmp 0x572fe movq %rax, %rbx jmp 0x5730b movq %rax, %rbx jmp 0x57318 jmp 0x5726c movq %rax, %rbx jmp 0x57325 movq %rax, %rbx jmp 0x57332 movq %rax, %rbx jmp 0x5733f movq %rax, %rbx jmp 0x5734c jmp 0x5728e movq %rax, %rbx jmp 0x57359 jmp 0x572ac jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572da jmp 0x572cb jmp 0x572da movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x1d0d0 jmp 0x572dd jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572cb jmp 0x572da jmp 0x572da movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 jmp 0x572dd movq %rax, %rbx leaq 0x70(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x5868c leaq 0xb0(%rsp), %rdi callq 0x5962c leaq 0xc8(%rsp), %rdi callq 0x5962c leaq 0xe0(%rsp), %rdi callq 0x5962c leaq 0xf8(%rsp), %rdi callq 0x5962c leaq 0x110(%rsp), %rdi callq 0x1d0d0 leaq 0x130(%rsp), %rdi callq 0x1d0d0 leaq 0x150(%rsp), %rdi callq 0x1d0d0 leaq 0x170(%rsp), %rdi callq 0x1d0d0 leaq 0x90(%rsp), %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getNonBondedInteractionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
NonBondedInteractionType* ForceField::getNonBondedInteractionType( const std::string& at1, const std::string& at2) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); // try exact match first NonBondedInteractionType* nbiType = nonBondedInteractionTypeCont_.find(keys); if (nbiType) { return nbiType; } else { AtomType* atype1; AtomType* atype2; std::vector<std::string> at1key; at1key.push_back(at1); atype1 = atomTypeCont_.find(at1key); std::vector<std::string> at2key; at2key.push_back(at2); atype2 = atomTypeCont_.find(at2key); // query atom types for their chains of responsibility std::vector<AtomType*> at1Chain = atype1->allYourBase(); std::vector<AtomType*> at2Chain = atype2->allYourBase(); std::vector<AtomType*>::iterator i; std::vector<AtomType*>::iterator j; int ii = 0; int jj = 0; int nbiTypeScore; std::vector<std::pair<int, std::vector<std::string>>> foundNBI; for (i = at1Chain.begin(); i != at1Chain.end(); ++i) { jj = 0; for (j = at2Chain.begin(); j != at2Chain.end(); ++j) { nbiTypeScore = ii + jj; std::vector<std::string> myKeys; myKeys.push_back((*i)->getName()); myKeys.push_back((*j)->getName()); NonBondedInteractionType* nbiType = nonBondedInteractionTypeCont_.find(myKeys); if (nbiType) { foundNBI.push_back(std::make_pair(nbiTypeScore, myKeys)); } jj++; } ii++; } if (!foundNBI.empty()) { // sort the foundNBI by the score: std::sort(foundNBI.begin(), foundNBI.end()); std::vector<std::string> theKeys = foundNBI[0].second; NonBondedInteractionType* bestType = nonBondedInteractionTypeCont_.find(theKeys); return bestType; } else { // if no exact match found, try wild card match return nonBondedInteractionTypeCont_.find(keys, wildCardAtomTypeName_); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xf8, %rsp movq %rdx, %r15 movq %rsi, %r13 movq %rdi, %rbx xorps %xmm0, %xmm0 leaq 0x50(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e leaq 0x50(%rsp), %rdi movq %r15, %rsi callq 0x5801e leaq 0x120(%rbx), %rdi leaq 0x50(%rsp), %rsi movq %rdi, (%rsp) callq 0x58bd4 movq %rax, %r12 testq %rax, %rax jne 0x575df xorps %xmm0, %xmm0 leaq 0xe0(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r13, %rsi callq 0x5801e leaq 0x8(%rbx), %r13 leaq 0xe0(%rsp), %rsi movq %r13, %rdi callq 0x5804a movq %rax, %r12 xorps %xmm0, %xmm0 leaq 0xc0(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) movq %r15, %rsi callq 0x5801e leaq 0xc0(%rsp), %rsi movq %r13, %rdi callq 0x5804a movq %rax, %r15 leaq 0x88(%rsp), %rdi movq %r12, %rsi callq 0x9ceda movq %rbx, 0x68(%rsp) leaq 0x70(%rsp), %rdi movq %r15, %rsi callq 0x9ceda xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rax movaps %xmm0, (%rax) andq $0x0, 0x10(%rax) movq 0x88(%rsp), %r14 xorl %ebx, %ebx leaq 0x38(%rsp), %r15 leaq 0x30(%rsp), %r13 leaq 0xa0(%rsp), %rbp cmpq 0x90(%rsp), %r14 je 0x57543 movq 0x70(%rsp), %r12 movl %ebx, 0xc(%rsp) cmpq 0x78(%rsp), %r12 je 0x57534 xorps %xmm0, %xmm0 movaps %xmm0, 0xa0(%rsp) andq $0x0, 0xb0(%rsp) movq (%r14), %rsi movq %r13, %rdi callq 0x9caa0 movq %rbp, %rdi movq %r13, %rsi callq 0x59d6c movq %r13, %rdi callq 0x13a98 movq (%r12), %rsi movq %r13, %rdi callq 0x9caa0 movq %rbp, %rdi movq %r13, %rsi callq 0x59d6c movq %r13, %rdi callq 0x13a98 movq (%rsp), %rdi movq %rbp, %rsi callq 0x58bd4 testq %rax, %rax je 0x57521 movl %ebx, 0x30(%rsp) movq %r15, %rdi movq %rbp, %rsi callq 0x5816a leaq 0x10(%rsp), %rdi movq %r13, %rsi callq 0x59efa movq %r15, %rdi callq 0x1d0d0 movq %rbp, %rdi callq 0x1d0d0 addq $0x8, %r12 incl %ebx jmp 0x57490 movl 0xc(%rsp), %ebx incl %ebx addq $0x8, %r14 jmp 0x57479 movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rsi cmpq %rsi, %rdi je 0x57587 callq 0x5a0e7 movq 0x10(%rsp), %rsi addq $0x8, %rsi leaq 0x30(%rsp), %rdi callq 0x5816a leaq 0x30(%rsp), %rsi movq (%rsp), %rdi callq 0x58bd4 movq %rax, %r12 leaq 0x30(%rsp), %rdi callq 0x1d0d0 jmp 0x575a4 movq 0x68(%rsp), %rdx addq $0x878, %rdx # imm = 0x878 leaq 0x50(%rsp), %rsi movq (%rsp), %rdi callq 0x58c64 movq %rax, %r12 leaq 0x10(%rsp), %rdi callq 0x583cc leaq 0x70(%rsp), %rdi callq 0x5962c leaq 0x88(%rsp), %rdi callq 0x5962c leaq 0xc0(%rsp), %rdi callq 0x1d0d0 leaq 0xe0(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x1d0d0 movq %r12, %rax addq $0xf8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x30(%rsp), %rdi jmp 0x57656 jmp 0x5760a movq %rax, %rbx jmp 0x5765b movq %rax, %rbx jmp 0x5766f jmp 0x57616 movq %rax, %rbx jmp 0x5767c movq %rax, %rbx jmp 0x57689 jmp 0x57622 movq %rax, %rbx jmp 0x57696 movq %rax, %rbx movq %r15, %rdi callq 0x1d0d0 jmp 0x5764e jmp 0x5764b jmp 0x5764b jmp 0x5763c jmp 0x5764b movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0x5764e movq %rax, %rbx leaq 0xa0(%rsp), %rdi callq 0x1d0d0 leaq 0x10(%rsp), %rdi callq 0x583cc leaq 0x70(%rsp), %rdi callq 0x5962c leaq 0x88(%rsp), %rdi callq 0x5962c leaq 0xc0(%rsp), %rdi callq 0x1d0d0 leaq 0xe0(%rsp), %rdi callq 0x1d0d0 leaq 0x50(%rsp), %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getExactBendType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BendType* ForceField::getExactBendType(const std::string& at1, const std::string& at2, const std::string& at3) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); return bendTypeCont_.find(keys); }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rcx, %r14 movq %rdx, %r15 movq %rdi, %rbx xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e movq %rsp, %rdi movq %r15, %rsi callq 0x5801e movq %rsp, %rdi movq %r14, %rsi callq 0x5801e addq $0x78, %rbx movq %rsp, %rsi movq %rbx, %rdi callq 0x583ee movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rax addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getExactInversionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
InversionType* ForceField::getExactInversionType(const std::string& at1, const std::string& at2, const std::string& at3, const std::string& at4) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); keys.push_back(at4); return inversionTypeCont_.find(keys); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %rbx xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e movq %rsp, %rdi movq %r12, %rsi callq 0x5801e movq %rsp, %rdi movq %r15, %rsi callq 0x5801e movq %rsp, %rdi movq %r14, %rsi callq 0x5801e addq $0xe8, %rbx movq %rsp, %rsi movq %rbx, %rdi callq 0x58e72 movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::replaceAtomType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::AtomType*)
bool ForceField::replaceAtomType(const std::string& at, AtomType* atomType) { std::vector<std::string> keys; keys.push_back(at); atypeIdentToName[atomType->getIdent()] = at; return atomTypeCont_.replace(keys, atomType); }
pushq %r15 pushq %r14 pushq %rbx subq $0x30, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e movq %rbx, %rdi callq 0x9ca92 leaq 0x808(%r14), %rdi leaq 0xc(%rsp), %rsi movl %eax, (%rsi) callq 0x58f02 movq %rax, %rdi movq %r15, %rsi callq 0x13280 addq $0x8, %r14 leaq 0x10(%rsp), %rsi movq %r14, %rdi movq %rbx, %rdx callq 0x58fb8 movl %eax, %ebx leaq 0x10(%rsp), %rdi callq 0x1d0d0 movl %ebx, %eax addq $0x30, %rsp popq %rbx popq %r14 popq %r15 retq jmp 0x57a07 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::addTorsionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::TorsionType*)
bool ForceField::addTorsionType(const std::string& at1, const std::string& at2, const std::string& at3, const std::string& at4, TorsionType* torsionType) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); keys.push_back(at4); return torsionTypeCont_.add(keys, torsionType); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x20, %rsp movq %r9, %rbx movq %r8, %r15 movq %rcx, %r12 movq %rdx, %r13 movq %rdi, %r14 xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e movq %rsp, %rdi movq %r13, %rsi callq 0x5801e movq %rsp, %rdi movq %r12, %rsi callq 0x5801e movq %rsp, %rdi movq %r15, %rsi callq 0x5801e addq $0xb0, %r14 movq %rsp, %rsi movq %r14, %rdi movq %rbx, %rdx callq 0x5912e movl %eax, %ebx movq %rsp, %rdi callq 0x1d0d0 movl %ebx, %eax addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::addInversionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::InversionType*)
bool ForceField::addInversionType(const std::string& at1, const std::string& at2, const std::string& at3, const std::string& at4, InversionType* inversionType) { std::vector<std::string> keys; keys.push_back(at1); keys.push_back(at2); keys.push_back(at3); keys.push_back(at4); return inversionTypeCont_.add(keys, inversionType); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x20, %rsp movq %r9, %rbx movq %r8, %r15 movq %rcx, %r12 movq %rdx, %r13 movq %rdi, %r14 xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x5801e movq %rsp, %rdi movq %r13, %rsi callq 0x5801e movq %rsp, %rdi movq %r12, %rsi callq 0x5801e movq %rsp, %rdi movq %r15, %rsi callq 0x5801e addq $0xe8, %r14 movq %rsp, %rsi movq %r14, %rdi movq %rbx, %rdx callq 0x59196 movl %eax, %ebx movq %rsp, %rdi callq 0x1d0d0 movl %ebx, %eax addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::ForceField::getRcutFromAtomType(OpenMD::AtomType*)
RealType ForceField::getRcutFromAtomType(AtomType* at) { RealType rcut(0.0); LennardJonesAdapter lja = LennardJonesAdapter(at); if (lja.isLennardJones()) { rcut = 2.5 * lja.getSigma(); } EAMAdapter ea = EAMAdapter(at); if (ea.isEAM()) { switch (ea.getEAMType()) { case eamFuncfl: rcut = max(rcut, ea.getRcut()); break; case eamZhou2001: case eamZhou2004: rcut = max(rcut, ea.getLatticeConstant() * sqrt(10.0) / 2.0); break; default: break; } } SuttonChenAdapter sca = SuttonChenAdapter(at); if (sca.isSuttonChen()) { rcut = max(rcut, 2.0 * sca.getAlpha()); } GayBerneAdapter gba = GayBerneAdapter(at); if (gba.isGayBerne()) { rcut = max(rcut, 2.5 * sqrt(2.0) * max(gba.getD(), gba.getL())); } StickyAdapter sa = StickyAdapter(at); if (sa.isSticky()) { rcut = max(rcut, max(sa.getRu(), sa.getRup())); } return rcut; }
pushq %r14 pushq %rbx subq $0x38, %rsp movq %rsi, %rbx leaq 0x30(%rsp), %rdi movq %rsi, (%rdi) callq 0xad744 xorpd %xmm0, %xmm0 testb %al, %al je 0x57cc9 leaq 0x30(%rsp), %rdi callq 0xad8e4 mulsd 0x710c7(%rip), %xmm0 # 0xc8d90 movsd %xmm0, (%rsp) leaq 0x10(%rsp), %rdi movq %rbx, (%rdi) callq 0xa2094 testb %al, %al je 0x57d25 leaq 0x10(%rsp), %rdi callq 0xa254e leal -0x1(%rax), %ecx cmpl $0x2, %ecx jae 0x57d0d leaq 0x10(%rsp), %rdi callq 0xa25c0 mulsd 0x71095(%rip), %xmm0 # 0xc8d98 mulsd 0x70aa5(%rip), %xmm0 # 0xc87b0 jmp 0x57d1b testl %eax, %eax jne 0x57d25 leaq 0x10(%rsp), %rdi callq 0xa3d62 maxsd (%rsp), %xmm0 movsd %xmm0, (%rsp) leaq 0x28(%rsp), %rdi movq %rbx, (%rdi) callq 0xb4b60 testb %al, %al je 0x57d4e leaq 0x28(%rsp), %rdi callq 0xb4d68 addsd %xmm0, %xmm0 maxsd (%rsp), %xmm0 movsd %xmm0, (%rsp) leaq 0x20(%rsp), %rdi movq %rbx, (%rdi) callq 0xac274 testb %al, %al je 0x57d92 leaq 0x20(%rsp), %r14 movq %r14, %rdi callq 0xac41c movsd %xmm0, 0x8(%rsp) movq %r14, %rdi callq 0xac43a maxsd 0x8(%rsp), %xmm0 mulsd 0x71018(%rip), %xmm0 # 0xc8da0 maxsd (%rsp), %xmm0 movsd %xmm0, (%rsp) leaq 0x18(%rsp), %rdi movq %rbx, (%rdi) callq 0xb4534 testb %al, %al je 0x57dcb leaq 0x18(%rsp), %rbx movq %rbx, %rdi callq 0xb4790 movsd %xmm0, 0x8(%rsp) movq %rbx, %rdi callq 0xb47cc maxsd 0x8(%rsp), %xmm0 maxsd (%rsp), %xmm0 jmp 0x57dd0 movsd (%rsp), %xmm0 addq $0x38, %rsp popq %rbx popq %r14 retq
/OpenMD[P]OpenMD/src/brains/ForceField.cpp
OpenMD::TypeContainer<OpenMD::AtomType, 1>::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
ElemPtr find(KeyType& keys) { assert(keys.size() == SIZE); MapTypeIterator i; i = data_.find(keys); if (i != data_.end()) { return (i->second).second; } KeyType reversedKeys = keys; std::reverse(reversedKeys.begin(), reversedKeys.end()); i = data_.find(reversedKeys); if (i != data_.end()) { return (i->second).second; } else { return NULL; } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r15 movq %rdi, %r12 leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x59b24 movq %rax, %rbx addq $0x10, %r12 cmpq %r12, %rax je 0x58079 movq 0x40(%rbx), %rbx jmp 0x580b5 movq %rsp, %r12 movq %r12, %rdi movq %r15, %rsi callq 0x5816a movq (%r12), %rdi movq 0x8(%r12), %rsi callq 0x59c19 movq %rsp, %rsi movq %r14, %rdi callq 0x59b24 cmpq %rbx, %rax je 0x580ab movq 0x40(%rax), %rbx jmp 0x580ad xorl %ebx, %ebx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x580c6 movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/TypeContainer.hpp
OpenMD::TypeContainer<OpenMD::BondType, 2>::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
ElemPtr find(KeyType& keys) { assert(keys.size() == SIZE); MapTypeIterator i; i = data_.find(keys); if (i != data_.end()) { return (i->second).second; } KeyType reversedKeys = keys; std::reverse(reversedKeys.begin(), reversedKeys.end()); i = data_.find(reversedKeys); if (i != data_.end()) { return (i->second).second; } else { return NULL; } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r15 movq %rdi, %r12 leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x59c9c movq %rax, %rbx addq $0x10, %r12 cmpq %r12, %rax je 0x58109 movq 0x40(%rbx), %rbx jmp 0x58145 movq %rsp, %r12 movq %r12, %rdi movq %r15, %rsi callq 0x5816a movq (%r12), %rdi movq 0x8(%r12), %rsi callq 0x59c19 movq %rsp, %rsi movq %r14, %rdi callq 0x59c9c cmpq %rbx, %rax je 0x5813b movq 0x40(%rax), %rbx jmp 0x5813d xorl %ebx, %ebx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x58156 movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/TypeContainer.hpp
OpenMD::TypeContainer<OpenMD::BondType, 2>::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ElemPtr find(KeyType& keys, const std::string& wildCard) { assert(keys.size() == SIZE); std::vector<KeyTypeIterator> iterCont; KeyType replacedKey; MapTypeIterator i; std::vector<ValueType> foundTypes; while (replaceWithWildCard(iterCont, keys, replacedKey, wildCard)) { i = data_.find(replacedKey); if (i != data_.end()) { foundTypes.push_back(i->second); } } // reverse the order of keys KeyType reversedKeys = keys; std::reverse(reversedKeys.begin(), reversedKeys.end()); // if the reversedKeys is the same as keys, just skip it if (reversedKeys != keys) { // empty the iterator container iterCont.clear(); while (replaceWithWildCard(iterCont, reversedKeys, replacedKey, wildCard)) { i = data_.find(replacedKey); if (i != data_.end()) { foundTypes.push_back(i->second); } } // replaceWithWildCard can not generate this particular sequence, we // have to do it manually KeyType allWildCards(SIZE, wildCard); i = data_.find(allWildCards); if (i != data_.end()) { foundTypes.push_back(i->second); } } typename std::vector<ValueType>::iterator j; j = std::min_element(foundTypes.begin(), foundTypes.end()); return j == foundTypes.end() ? NULL : j->second; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq %rdx, %r14 movq %rsi, %r12 movq %rdi, %rbx xorps %xmm0, %xmm0 leaq 0x30(%rsp), %r13 movaps %xmm0, (%r13) andq $0x0, 0x10(%r13) leaq 0x60(%rsp), %rbp andq $0x0, 0x10(%rbp) leaq 0x10(%rsp), %rax andq $0x0, 0x10(%rax) movaps %xmm0, (%rbp) movaps %xmm0, (%rax) leaq 0x8(%rdi), %r15 addq $0x10, %rbx movq %r13, %rdi movq %r12, %rsi movq %rbp, %rdx movq %r14, %rcx callq 0xb9e28 testb %al, %al je 0x58245 movq %r15, %rdi movq %rbp, %rsi callq 0x59c9c cmpq %rbx, %rax je 0x5820d addq $0x38, %rax leaq 0x10(%rsp), %rdi movq %rax, %rsi callq 0x5a932 jmp 0x5820d leaq 0x48(%rsp), %rdi movq %r12, %rsi callq 0x5816a movq 0x48(%rsp), %rdi movq 0x50(%rsp), %rsi callq 0x59c19 leaq 0x48(%rsp), %rdi movq %r12, %rsi callq 0x5a94f testb %al, %al je 0x58319 movq 0x30(%rsp), %rax cmpq %rax, 0x38(%rsp) je 0x58287 movq %rax, 0x38(%rsp) leaq 0x30(%rsp), %r12 leaq 0x48(%rsp), %r13 leaq 0x60(%rsp), %rbp movq %r12, %rdi movq %r13, %rsi movq %rbp, %rdx movq %r14, %rcx callq 0xb9e28 testb %al, %al je 0x582ce movq %r15, %rdi movq %rbp, %rsi callq 0x59c9c cmpq %rbx, %rax je 0x58296 addq $0x38, %rax leaq 0x10(%rsp), %rdi movq %rax, %rsi callq 0x5a932 jmp 0x58296 leaq 0x80(%rsp), %rdi pushq $0x2 popq %rsi leaq 0xf(%rsp), %rcx movq %r14, %rdx callq 0x5a95a leaq 0x80(%rsp), %rsi movq %r15, %rdi callq 0x59c9c cmpq %rbx, %rax je 0x5830c addq $0x38, %rax leaq 0x10(%rsp), %rdi movq %rax, %rsi callq 0x5a932 leaq 0x80(%rsp), %rdi callq 0x1d0d0 movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rsi callq 0x5ac04 cmpq 0x18(%rsp), %rax je 0x58335 movq 0x8(%rax), %rbx jmp 0x58337 xorl %ebx, %ebx leaq 0x48(%rsp), %rdi callq 0x1d0d0 leaq 0x10(%rsp), %rdi callq 0x5ac60 leaq 0x60(%rsp), %rdi callq 0x1d0d0 leaq 0x30(%rsp), %rdi callq 0x5ac7e movq %rbx, %rax addq $0x98, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x58376 movq %rax, %rbx leaq 0x80(%rsp), %rdi callq 0x1d0d0 jmp 0x58395 jmp 0x58392 jmp 0x58392 jmp 0x583a3 jmp 0x58392 jmp 0x58392 movq %rax, %rbx leaq 0x48(%rsp), %rdi callq 0x1d0d0 jmp 0x583a6 jmp 0x583a3 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x5ac60 leaq 0x60(%rsp), %rdi callq 0x1d0d0 leaq 0x30(%rsp), %rdi callq 0x5ac7e movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/TypeContainer.hpp
OpenMD::TypeContainer<OpenMD::BendType, 3>::find(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
ElemPtr find(KeyType& keys) { assert(keys.size() == SIZE); MapTypeIterator i; i = data_.find(keys); if (i != data_.end()) { return (i->second).second; } KeyType reversedKeys = keys; std::reverse(reversedKeys.begin(), reversedKeys.end()); i = data_.find(reversedKeys); if (i != data_.end()) { return (i->second).second; } else { return NULL; } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r15 movq %rdi, %r12 leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x5acb2 movq %rax, %rbx addq $0x10, %r12 cmpq %r12, %rax je 0x5841d movq 0x40(%rbx), %rbx jmp 0x58459 movq %rsp, %r12 movq %r12, %rdi movq %r15, %rsi callq 0x5816a movq (%r12), %rdi movq 0x8(%r12), %rsi callq 0x59c19 movq %rsp, %rsi movq %r14, %rdi callq 0x5acb2 cmpq %rbx, %rax je 0x5844f movq 0x40(%rax), %rbx jmp 0x58451 xorl %ebx, %ebx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x5846a movq %rax, %rbx movq %rsp, %rdi callq 0x1d0d0 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/TypeContainer.hpp
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint> OpenMD::operator||<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>(OpenMD::ParamConstraintFacade<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>> const&, OpenMD::ParamConstraintFacade<OpenMD::EqualIgnoreCaseConstraint> const&)
inline OrParamConstraint<Cons1T, Cons2T> operator||( const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2) { return OrParamConstraint<Cons1T, Cons2T>( *static_cast<const Cons1T*>(&cons1), *static_cast<const Cons2T*>(&cons2)); }
pushq %r14 pushq %rbx subq $0x448, %rsp # imm = 0x448 movq %rdx, %r14 movq %rdi, %rbx leaq 0x48(%rsp), %rdi callq 0x87516 leaq 0x8(%rsp), %rdi movq %r14, %rsi callq 0x71656 leaq 0x48(%rsp), %rsi leaq 0x8(%rsp), %rdx movq %rbx, %rdi callq 0x87570 leaq 0x8(%rsp), %rdi callq 0x70cc6 leaq 0x48(%rsp), %rdi callq 0x8626e movq %rbx, %rax addq $0x448, %rsp # imm = 0x448 popq %rbx popq %r14 retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x70cc6 jmp 0x85e5b movq %rax, %rbx leaq 0x48(%rsp), %rdi callq 0x8626e movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/io/ParamConstraint.hpp
Parameter<unsigned long>::setData(unsigned long)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
movb $0x0, 0x2a(%rdi) movq %rsi, 0x30(%rdi) movb $0x1, %al retq nop
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
ParameterTraits<std::pair<int, int>>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>&)
static bool convert(std::string v, RepType& r) { OpenMD::StringTokenizer tokenizer(v, " ;,\t\n\r"); if (tokenizer.countTokens() == 2) { int atom1 = tokenizer.nextTokenAsInt(); int atom2 = tokenizer.nextTokenAsInt(); r = std::make_pair(atom1, atom2); return true; } else { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "ParameterManager Error: " "Incorrect number of tokens to make a pair!\n"); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return false; }
pushq %rbp pushq %r14 pushq %rbx subq $0x80, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq 0x46337(%rip), %rsi # 0xcc9dd leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rdx movq %r14, %rsi callq 0xb9030 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0xb912e movl %eax, %ebp cmpl $0x2, %eax jne 0x86701 leaq 0x28(%rsp), %rdi callq 0xb93d6 movl %eax, %r14d leaq 0x28(%rsp), %rdi callq 0xb93d6 movl %r14d, (%rbx) movl %eax, 0x4(%rbx) jmp 0x86730 leaq 0x9899c(%rip), %rbx # 0x11f0a4 leaq 0x462d5(%rip), %rsi # 0xcc9e4 pushq $0x44 popq %rdx movq %rbx, %rdi callq 0x133f0 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x7d0(%rbx) callq 0x2beaa cmpl $0x2, %ebp sete %bl leaq 0x28(%rsp), %rdi callq 0x1a91c movl %ebx, %eax addq $0x80, %rsp popq %rbx popq %r14 popq %rbp retq jmp 0x86766 jmp 0x86766 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0x86773 movq %rax, %rbx jmp 0x86773 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x1a91c movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
pushq %rbp pushq %rbx subq $0x38, %rsp movq %rdi, %rbx xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) andq $0x0, 0x10(%rsp) leaq 0x18(%rsp), %rdi callq 0x13700 leaq 0x18(%rsp), %rdi movq %rsp, %rsi callq 0x86916 movl %eax, %ebp leaq 0x18(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl je 0x868e3 movb $0x0, 0x2a(%rbx) addq $0x30, %rbx movq %rsp, %rsi movq %rbx, %rdi callq 0x4b5ae movq %rsp, %rdi callq 0x1b586 movl %ebp, %eax addq $0x38, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x13a98 jmp 0x86906 movq %rax, %rbx movq %rsp, %rdi callq 0x1b586 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<int>(int)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
subq $0x18, %rsp xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x1b586 xorl %eax, %eax addq $0x18, %rsp retq
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<double>(double)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
subq $0x18, %rsp xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x1b586 xorl %eax, %eax addq $0x18, %rsp retq
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::pair<int, int>>(std::pair<int, int>)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
subq $0x18, %rsp xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) andq $0x0, 0x10(%rdi) callq 0x1b586 xorl %eax, %eax addq $0x18, %rsp retq
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>)
bool internalSetData(T data) { ParamType tmp {}; bool result = ValueType::convert(data, tmp); if (result) { empty_ = false; data_ = tmp; } return result; }
pushq %rbx subq $0x30, %rsp movq %rdi, %rbx xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) andq $0x0, 0x10(%rsp) leaq 0x18(%rsp), %rdi callq 0x4a99a movq %rsp, %rdi leaq 0x18(%rsp), %rsi callq 0x4b5ae leaq 0x18(%rsp), %rdi callq 0x1b586 movb $0x0, 0x2a(%rbx) addq $0x30, %rbx movq %rsp, %rsi movq %rbx, %rdi callq 0x4b5ae movq %rsp, %rdi callq 0x1b586 movb $0x1, %al addq $0x30, %rsp popq %rbx retq movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x1b586 jmp 0x86b7f movq %rax, %rbx movq %rsp, %rdi callq 0x1b586 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/ParameterManager.hpp
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::OrParamConstraint(OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint)
OrParamConstraint(Cons1T cons1, Cons2T cons2) : cons1_(cons1), cons2_(cons2) { std::stringstream iss; iss << cons1_.getConstraintDescription() << " or " << cons2_.getConstraintDescription() << ""; this->description_ = iss.str(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1c8, %rsp # imm = 0x1C8 movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) andq $0x0, 0x8(%rdi) movq %rdx, %r12 movb $0x0, 0x10(%rdi) leaq 0x20(%rdi), %r14 movq %r14, %rdi callq 0x86ce2 leaq 0x240(%rbx), %r15 movq %r15, %rdi movq %r12, %rsi callq 0x71656 leaq 0x40(%rsp), %rdi callq 0x13350 movq %rsp, %rdi movq %r14, %rsi callq 0x13700 leaq 0x50(%rsp), %rdi movq %rsp, %rsi callq 0x13450 leaq 0x4484c(%rip), %rsi # 0xcb5f3 movq %rax, %rdi callq 0x134b0 movq %rax, %r12 leaq 0x20(%rsp), %rdi movq %r15, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r12, %rdi callq 0x13450 leaq 0x4a117(%rip), %rsi # 0xd0eea movq %rax, %rdi callq 0x134b0 leaq 0x20(%rsp), %rdi callq 0x13a98 movq %rsp, %rdi callq 0x13a98 leaq 0x58(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x13620 movq %r14, %rdi callq 0x13a98 leaq 0x40(%rsp), %rdi callq 0x13390 addq $0x1c8, %rsp # imm = 0x1C8 popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x86e2d jmp 0x86e50 movq %rax, %r12 jmp 0x86e5b movq %rax, %r12 jmp 0x86e65 movq %rax, %r12 jmp 0x86e6d movq %rax, %r12 jmp 0x86e75 movq %rax, %r12 leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0x86e53 movq %rax, %r12 movq %rsp, %rdi callq 0x13a98 leaq 0x40(%rsp), %rdi callq 0x13390 movq %r15, %rdi callq 0x70cc6 movq %r14, %rdi callq 0x70ca4 movq %rbx, %rdi callq 0x13a98 movq %r12, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/io/ParamConstraint.hpp
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::OrParamConstraint(OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint)
OrParamConstraint(Cons1T cons1, Cons2T cons2) : cons1_(cons1), cons2_(cons2) { std::stringstream iss; iss << cons1_.getConstraintDescription() << " or " << cons2_.getConstraintDescription() << ""; this->description_ = iss.str(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1c8, %rsp # imm = 0x1C8 movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) andq $0x0, 0x8(%rdi) movq %rdx, %r12 movb $0x0, 0x10(%rdi) leaq 0x20(%rdi), %r14 movq %r14, %rdi callq 0x87372 leaq 0x3c0(%rbx), %r15 movq %r15, %rdi movq %r12, %rsi callq 0x71656 leaq 0x40(%rsp), %rdi callq 0x13350 movq %rsp, %rdi movq %r14, %rsi callq 0x13700 leaq 0x50(%rsp), %rdi movq %rsp, %rsi callq 0x13450 leaq 0x441bc(%rip), %rsi # 0xcb5f3 movq %rax, %rdi callq 0x134b0 movq %rax, %r12 leaq 0x20(%rsp), %rdi movq %r15, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r12, %rdi callq 0x13450 leaq 0x49a87(%rip), %rsi # 0xd0eea movq %rax, %rdi callq 0x134b0 leaq 0x20(%rsp), %rdi callq 0x13a98 movq %rsp, %rdi callq 0x13a98 leaq 0x58(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x13620 movq %r14, %rdi callq 0x13a98 leaq 0x40(%rsp), %rdi callq 0x13390 addq $0x1c8, %rsp # imm = 0x1C8 popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x874bd jmp 0x874e0 movq %rax, %r12 jmp 0x874eb movq %rax, %r12 jmp 0x874f5 movq %rax, %r12 jmp 0x874fd movq %rax, %r12 jmp 0x87505 movq %rax, %r12 leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0x874e3 movq %rax, %r12 movq %rsp, %rdi callq 0x13a98 leaq 0x40(%rsp), %rdi callq 0x13390 movq %r15, %rdi callq 0x70cc6 movq %r14, %rdi callq 0x86290 movq %rbx, %rdi callq 0x13a98 movq %r12, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/io/ParamConstraint.hpp
OpenMD::Polynomial<double>::evaluateDerivative(double const&)
Real evaluateDerivative(const Real& x) { Real result = Real(); ExponentType exponent; CoefficientType coefficient; for (iterator i = polyPairMap_.begin(); i != polyPairMap_.end(); ++i) { exponent = i->first; coefficient = i->second; result += fastpow(x, exponent - 1) * coefficient * exponent; } return result; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %rbx movq %rdi, %r14 movq 0x18(%rdi), %r15 addq $0x8, %r14 xorpd %xmm0, %xmm0 movsd %xmm0, 0x8(%rsp) cmpq %r14, %r15 je 0x9f48c movl 0x20(%r15), %r12d movsd 0x28(%r15), %xmm0 movsd %xmm0, 0x10(%rsp) movsd (%rbx), %xmm0 leal -0x1(%r12), %edi callq 0x9f49e mulsd 0x10(%rsp), %xmm0 cvtsi2sd %r12d, %xmm1 mulsd %xmm0, %xmm1 movsd 0x8(%rsp), %xmm0 addsd %xmm1, %xmm0 movsd %xmm0, 0x8(%rsp) movq %r15, %rdi callq 0x13340 movq %rax, %r15 jmp 0x9f43d movsd 0x8(%rsp), %xmm0 addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq
/OpenMD[P]OpenMD/src/math/Polynomial.hpp
OpenMD::ShiftedMieBondType::~ShiftedMieBondType()
ShiftedMieBondType(RealType mySigma, RealType myEpsilon, int myNrep, int myMatt) : BondType(0.0) { sigma = mySigma; epsilon = myEpsilon; n = myNrep; m = myMatt; rS_ = exp(log(pow(sigma, m - n) * RealType(m) / n)); nmScale_ = n * pow(RealType(n) / m, RealType(m) / (n - m)) / (n - m); RealType rss = rS_ / sigma; RealType rsi = 1.0 / rss; RealType rsn = pow(rsi, n); RealType rsm = pow(rsi, m); potS_ = nmScale_ * epsilon * (rsn - rsm); setEquilibriumBondLength(rS_); }
pushq $0x40 popq %rsi jmp 0x134e0
/OpenMD[P]OpenMD/src/types/ShiftedMieBondType.hpp
OpenMD::BondStamp::BondStamp()
BondStamp::BondStamp() : hasOverride_(false) { DefineOptionalParameterWithDefaultValue(BondOrder, "bondOrder", 1); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx callq 0x4b318 leaq 0x7cf86(%rip), %rax # 0x11cbe0 movq %rax, (%rbx) leaq 0x80(%rbx), %rax movq %rax, 0x70(%rbx) andq $0x0, 0x78(%rbx) xorl %eax, %eax movb %al, 0x80(%rbx) andw $0x0, 0x90(%rbx) movb $0x1, 0x92(%rbx) leaq 0x7ba9d(%rip), %rcx # 0x11b728 movq %rcx, 0x68(%rbx) movb %al, 0xa8(%rbx) leaq 0xc0(%rbx), %rcx movq %rcx, 0xb0(%rbx) andq $0x0, 0xb8(%rbx) leaq 0x68(%rbx), %r14 movb %al, 0xc0(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0xd0(%rbx) andq $0x0, 0xe0(%rbx) leaq 0x2ecd9(%rip), %rsi # 0xce9a7 leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0x70(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 movw $0x101, 0x90(%rbx) # imm = 0x101 movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000 movq %rax, 0x98(%rbx) movb $0x0, 0x92(%rbx) leaq 0x2ec8a(%rip), %rsi # 0xce9a7 leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rbx), %rdi leaq 0x40(%rsp), %rcx movq %rcx, -0x10(%rcx) leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdx cmpq %rax, %rdx je 0x9fd58 movq %rdx, 0x30(%rsp) movq 0x20(%rsp), %rcx movq %rcx, 0x40(%rsp) jmp 0x9fd5e movups (%rax), %xmm0 movups %xmm0, (%rcx) movq 0x18(%rsp), %rcx movq %rax, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rcx, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq %r14, 0x20(%rsi) callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 addq $0x58, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %r15 leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi jmp 0x9fdc3 jmp 0x9fdca movq %rax, %r15 leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0x9fdcd movq %rax, %r15 leaq 0xb0(%rbx), %r12 leaq 0xd0(%rbx), %rdi callq 0x1b586 movq %r12, %rdi callq 0x13a98 movq %r14, %rdi callq 0x5939c movq %rbx, %rdi callq 0x4b358 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/BondStamp.cpp
OpenMD::BondTypeParser::BondTypeParser()
BondTypeParser::BondTypeParser() { stringToEnumMap_["Fixed"] = btFixed; stringToEnumMap_["Harmonic"] = btHarmonic; stringToEnumMap_["Cubic"] = btCubic; stringToEnumMap_["Quartic"] = btQuartic; stringToEnumMap_["Polynomial"] = btPolynomial; stringToEnumMap_["Morse"] = btMorse; stringToEnumMap_["ShiftedMie"] = btShiftedMie; }
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq 0x8(%rdi), %rax andl $0x0, 0x8(%rdi) andq $0x0, 0x10(%rdi) movq %rax, 0x18(%rdi) movq %rax, 0x20(%rdi) andq $0x0, 0x28(%rdi) leaq 0x27a58(%rip), %rsi # 0xc7aa5 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 andl $0x0, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x2798b(%rip), %rsi # 0xc7a08 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x1, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x279bd(%rip), %rsi # 0xc7a6d leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x2, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x27911(%rip), %rsi # 0xc79f4 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x3, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x27995(%rip), %rsi # 0xc7aab leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x4, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x2cd86(%rip), %rsi # 0xccecf leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x5, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x2e8c5(%rip), %rsi # 0xcea41 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xa0a86 movl $0x6, (%rax) leaq 0x8(%rsp), %rdi callq 0x13a98 addq $0x28, %rsp popq %rbx popq %r14 retq jmp 0xa01c8 jmp 0xa01d7 jmp 0xa01c8 jmp 0xa01d7 jmp 0xa01c8 jmp 0xa01d7 jmp 0xa01c8 jmp 0xa01d7 jmp 0xa01c8 jmp 0xa01d7 jmp 0xa01c8 jmp 0xa01d7 movq %rax, %r14 leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0xa01da movq %rax, %r14 movq %rbx, %rdi callq 0x60f66 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/BondTypeParser.cpp
OpenMD::BondTypeParser::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
BondType* BondTypeParser::parseLine(const std::string& line, RealType kScale) { StringTokenizer tokenizer(line); BondType* bondType = NULL; int nTokens = tokenizer.countTokens(); if (nTokens < 1) { throw OpenMDException("BondTypeParser: Not enough tokens"); } BondTypeEnum bt = getBondTypeEnum(tokenizer.nextToken()); nTokens -= 1; switch (bt) { case btFixed: if (nTokens < 1) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); bondType = new FixedBondType(b0); } break; case btHarmonic: if (nTokens < 2) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); RealType kb = tokenizer.nextTokenAsDouble(); kb *= kScale; bondType = new HarmonicBondType(b0, kb); } break; case btCubic: if (nTokens < 5) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); RealType k3 = tokenizer.nextTokenAsDouble(); RealType k2 = tokenizer.nextTokenAsDouble(); RealType k1 = tokenizer.nextTokenAsDouble(); RealType k0 = tokenizer.nextTokenAsDouble(); bondType = new CubicBondType(b0, k3, k2, k1, k0); } break; case btQuartic: if (nTokens < 6) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); RealType k4 = tokenizer.nextTokenAsDouble(); RealType k3 = tokenizer.nextTokenAsDouble(); RealType k2 = tokenizer.nextTokenAsDouble(); RealType k1 = tokenizer.nextTokenAsDouble(); RealType k0 = tokenizer.nextTokenAsDouble(); bondType = new QuarticBondType(b0, k4, k3, k2, k1, k0); } break; case btPolynomial: if (nTokens < 3 || nTokens % 2 != 1) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); nTokens -= 1; int nPairs = nTokens / 2; int power; RealType coefficient; PolynomialBondType* pbt = new PolynomialBondType(b0); for (int i = 0; i < nPairs; ++i) { power = tokenizer.nextTokenAsInt(); coefficient = tokenizer.nextTokenAsDouble(); pbt->setCoefficient(power, coefficient); } } break; case btMorse: if (nTokens < 3) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType b0 = tokenizer.nextTokenAsDouble(); RealType D = tokenizer.nextTokenAsDouble(); RealType beta = tokenizer.nextTokenAsDouble(); bondType = new MorseBondType(b0, D, beta); } break; case btShiftedMie: if (nTokens < 4) { throw OpenMDException("BondTypeParser: Not enough tokens"); } else { RealType sigma = tokenizer.nextTokenAsDouble(); RealType epsilon = tokenizer.nextTokenAsDouble(); int nRep = tokenizer.nextTokenAsInt(); int mAtt = tokenizer.nextTokenAsInt(); bondType = new ShiftedMieBondType(sigma, epsilon, nRep, mAtt); } break; case btUnknown: default: throw OpenMDException("BondTypeParser: Unknown Bond Type"); } return bondType; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xb0, %rsp movsd %xmm0, 0x8(%rsp) movq %rsi, %rbx movq %rdi, %r14 leaq 0x24db5(%rip), %rsi # 0xc5085 leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x50(%rsp), %rdi leaq 0x18(%rsp), %rdx movq %rbx, %rsi callq 0xb9030 leaq 0x18(%rsp), %rdi callq 0x13a98 leaq 0x50(%rsp), %rdi callq 0xb912e movl %eax, %ebx testl %eax, %eax jle 0xa06f8 leaq 0x18(%rsp), %rdi leaq 0x50(%rsp), %rsi callq 0xb91ec leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0xa0a6a movl %eax, %ebp leaq 0x18(%rsp), %rdi callq 0x13a98 cmpl $0x6, %ebp ja 0xa0746 movl %ebp, %eax leaq 0x2e67f(%rip), %rcx # 0xce9c8 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax cmpl $0x1, %ebx je 0xa0794 leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) pushq $0x10 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c898(%rip), %rax # 0x11cc20 movq %rax, (%r14) jmp 0xa06db cmpl $0x4, %ebx jb 0xa0965 movl %ebx, %eax andl $0x1, %eax jne 0xa0965 leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) pushq $0x40 popq %rdi callq 0x134d0 movq %rax, %r15 movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c8f7(%rip), %rax # 0x11ccc8 movq %rax, (%r15) movq %r15, %rax addq $0x18, %rax andl $0x0, 0x18(%r15) andq $0x0, 0x20(%r15) movq %rax, 0x28(%r15) movq %rax, 0x30(%r15) andq $0x0, 0x38(%r15) addl $-0x2, %ebx shrl %ebx xorl %r14d, %r14d leaq 0x50(%rsp), %r12 subl $0x1, %ebx jb 0xa06db movq %r12, %rdi callq 0xb93d6 movl %eax, %ebp movq %r12, %rdi callq 0xb9476 movq %r15, %rdi movl %ebp, %esi callq 0xa0aec jmp 0xa03ff cmpl $0x5, %ebx jbe 0xa07e2 leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x38(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x48(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x40(%rsp) pushq $0x30 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c7ac(%rip), %rax # 0x11cc48 movq %rax, (%r14) movsd 0x10(%rsp), %xmm0 movsd %xmm0, 0x10(%r14) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0x18(%r14) movsd 0x48(%rsp), %xmm0 movsd %xmm0, 0x20(%r14) movsd 0x40(%rsp), %xmm0 movsd %xmm0, 0x28(%r14) jmp 0xa06db cmpl $0x6, %ebx jbe 0xa0830 leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x38(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x48(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x40(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0xa8(%rsp) pushq $0x38 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c72b(%rip), %rax # 0x11cc88 movq %rax, (%r14) movsd 0x10(%rsp), %xmm0 movsd %xmm0, 0x10(%r14) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0x18(%r14) movsd 0x48(%rsp), %xmm0 movsd %xmm0, 0x20(%r14) movsd 0x40(%rsp), %xmm0 movsd %xmm0, 0x28(%r14) movsd 0xa8(%rsp), %xmm0 movsd %xmm0, 0x30(%r14) jmp 0xa06db cmpl $0x2, %ebx jbe 0xa087e leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x38(%rsp) pushq $0x18 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x38(%rsp), %xmm1 mulsd 0x8(%rsp), %xmm1 movsd 0x10(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c3aa(%rip), %rax # 0x11c9a0 movq %rax, (%r14) movsd %xmm1, 0x10(%r14) jmp 0xa06db cmpl $0x3, %ebx jbe 0xa08cc leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x38(%rsp) pushq $0x20 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rax) leaq 0x7c6ae(%rip), %rax # 0x11cd08 movq %rax, (%r14) movsd 0x10(%rsp), %xmm0 movsd %xmm0, 0x10(%r14) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0x18(%r14) jmp 0xa06db cmpl $0x4, %ebx jbe 0xa091a leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x8(%rsp) leaq 0x50(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rdi callq 0xb93d6 movl %eax, %ebx leaq 0x50(%rsp), %rdi callq 0xb93d6 movl %eax, %ebp pushq $0x40 popq %rdi callq 0x134d0 movq %rax, %r14 movq %rax, %rdi movsd 0x8(%rsp), %xmm0 movsd 0x10(%rsp), %xmm1 movl %ebx, %esi movl %ebp, %edx callq 0x9f53e leaq 0x50(%rsp), %rdi callq 0x1a91c movq %r14, %rax addq $0xb0, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e342(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x793ee(%rip), %rsi # 0x119b20 leaq -0x7ce1f(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e316(%rip), %rsi # 0xcea6e leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x793a0(%rip), %rsi # 0x119b20 leaq -0x7ce6d(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e2a6(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x79352(%rip), %rsi # 0x119b20 leaq -0x7cebb(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e258(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x79304(%rip), %rsi # 0x119b20 leaq -0x7cf09(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e20a(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x792b6(%rip), %rsi # 0x119b20 leaq -0x7cf57(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e1bc(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x79268(%rip), %rsi # 0x119b20 leaq -0x7cfa5(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e16e(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x7921a(%rip), %rsi # 0x119b20 leaq -0x7cff3(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e120(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x791cc(%rip), %rsi # 0x119b20 leaq -0x7d041(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa09ae pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x2e0d5(%rip), %rsi # 0xcea4c leaq 0x18(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x79181(%rip), %rsi # 0x119b20 leaq -0x7d08c(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 jmp 0xa0a0c jmp 0xa0a20 movq %rax, %rbx pushq $0x40 popq %rsi movq %r14, %rdi callq 0x134e0 jmp 0xa0a57 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 jmp 0xa0a54 movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xa0a23 jmp 0xa0a57 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xa0a57 movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x13a98 jmp 0xa0a57 jmp 0xa0a54 jmp 0xa0a54 movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x13a98 jmp 0xa0a61 movq %rax, %rbx jmp 0xa0a61 movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x1a91c movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/BondTypeParser.cpp
OpenMD::QuarticBondType::calcForce(double, double&, double&)
virtual void calcForce(RealType r, RealType& V, RealType& dVdr) { RealType dr = r - r0; RealType dr2 = dr * dr; RealType dr3 = dr2 * dr; RealType dr4 = dr3 * dr; V = k0_ + k1_ * dr + k2_ * dr2 + k3_ * dr3 + k4_ * dr4; dVdr = k1_ + 2.0 * k2_ * dr + 3.0 * k3_ * dr2 + 4.0 * k4_ * dr3; }
subsd 0x8(%rdi), %xmm0 movapd %xmm0, %xmm2 mulsd %xmm0, %xmm2 movapd %xmm0, %xmm1 mulsd %xmm2, %xmm1 movapd %xmm0, %xmm3 movsd 0x28(%rdi), %xmm4 mulsd %xmm0, %xmm4 addsd 0x30(%rdi), %xmm4 mulsd %xmm1, %xmm3 movsd 0x20(%rdi), %xmm5 mulsd %xmm2, %xmm5 addsd %xmm4, %xmm5 movsd 0x18(%rdi), %xmm4 mulsd %xmm1, %xmm4 mulsd 0x10(%rdi), %xmm3 addsd %xmm5, %xmm4 addsd %xmm4, %xmm3 movsd %xmm3, (%rsi) movsd 0x20(%rdi), %xmm3 addsd %xmm3, %xmm3 mulsd %xmm0, %xmm3 addsd 0x28(%rdi), %xmm3 movsd 0x18(%rdi), %xmm0 mulsd 0x27bdb(%rip), %xmm0 # 0xc87d8 movsd 0x10(%rdi), %xmm4 mulsd %xmm2, %xmm0 mulsd 0x2db3a(%rip), %xmm4 # 0xce748 addsd %xmm3, %xmm0 mulsd %xmm1, %xmm4 addsd %xmm0, %xmm4 movsd %xmm4, (%rdx) retq nop
/OpenMD[P]OpenMD/src/types/QuarticBondType.hpp
OpenMD::MorseBondType::calcForce(double, double&, double&)
virtual void calcForce(RealType r, RealType& V, RealType& dVdr) { RealType dr, eterm, eterm2; dr = r - r0; eterm = exp(-beta * dr); eterm2 = eterm * eterm; V = De * (1 - 2.0 * eterm + eterm2); dVdr = 2.0 * De * beta * (eterm - eterm2); }
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 subsd 0x8(%rdi), %xmm0 movsd 0x18(%rdi), %xmm1 xorpd 0x25e80(%rip), %xmm1 # 0xc6b40 mulsd %xmm1, %xmm0 callq 0x13980 movapd %xmm0, %xmm1 mulsd %xmm0, %xmm1 movapd %xmm0, %xmm2 addsd %xmm0, %xmm2 movsd 0x2433f(%rip), %xmm3 # 0xc5020 subsd %xmm2, %xmm3 addsd %xmm1, %xmm3 mulsd 0x10(%r15), %xmm3 movsd %xmm3, (%r14) movsd 0x10(%r15), %xmm2 addsd %xmm2, %xmm2 mulsd 0x18(%r15), %xmm2 subsd %xmm1, %xmm0 mulsd %xmm2, %xmm0 movsd %xmm0, (%rbx) popq %rbx popq %r14 popq %r15 retq
/OpenMD[P]OpenMD/src/types/MorseBondType.hpp
OpenMD::Component::Component()
Component::Component() : moleculeStamp_(NULL) { DefineParameter(Type, "type"); DefineParameter(NMol, "nMol"); DefineParameter(Region, "region"); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx callq 0x4b318 leaq 0x7bc33(%rip), %rax # 0x11cd48 movq %rax, (%rbx) leaq 0x68(%rbx), %r14 movq %r14, %rdi callq 0x70946 leaq 0xd0(%rbx), %rax movq %rax, 0xc0(%rbx) andq $0x0, 0xc8(%rbx) xorl %eax, %eax movb %al, 0xd0(%rbx) andw $0x0, 0xe0(%rbx) leaq 0xb8(%rbx), %rcx movq %rcx, 0x50(%rsp) movb $0x1, %cl movb %cl, 0xe2(%rbx) leaq 0x7a63b(%rip), %rdx # 0x11b7a0 movq %rdx, 0xb8(%rbx) leaq 0xe8(%rbx), %r12 leaq 0x100(%rbx), %rsi movq %rsi, 0xf0(%rbx) andq $0x0, 0xf8(%rbx) movb %al, 0x100(%rbx) andw $0x0, 0x110(%rbx) movb %cl, 0x112(%rbx) movq %rdx, 0xe8(%rbx) andq $0x0, 0x118(%rbx) leaq 0x2ac12(%rip), %rsi # 0xcbdc5 leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rdx callq 0x1a8b4 leaq 0x70(%rbx), %rdi leaq 0x28(%rsp), %rsi callq 0x13280 leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x2abe4(%rip), %rsi # 0xcbdc5 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rbx), %r13 leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x18(%rsp), %rbp movq -0x10(%rbp), %rax cmpq %rbp, %rax je 0xa121c movq %rax, 0x28(%rsp) movq 0x18(%rsp), %rax movq %rax, 0x38(%rsp) jmp 0xa1224 movups (%rbp), %xmm0 movups %xmm0, (%r15) movq 0x10(%rsp), %rax movq %rbp, 0x8(%rsp) andq $0x0, 0x10(%rsp) leaq 0x28(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x18(%rsp) movq %r14, 0x20(%rsi) movq %r13, %rdi callq 0x7144c leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x2d892(%rip), %rsi # 0xceafb leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rdx callq 0x1a8b4 leaq 0xc0(%rbx), %rdi leaq 0x28(%rsp), %rsi callq 0x13280 leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x2d861(%rip), %rsi # 0xceafb leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movq %r15, 0x28(%rsp) movq 0x8(%rsp), %rax cmpq %rbp, %rax je 0xa12c9 movq %rax, 0x28(%rsp) movq 0x18(%rsp), %rax movq %rax, 0x38(%rsp) jmp 0xa12d1 movups (%rbp), %xmm0 movups %xmm0, (%r15) movq 0x10(%rsp), %rax movq %rbp, 0x8(%rsp) andq $0x0, 0x10(%rsp) leaq 0x28(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x18(%rsp) movq 0x50(%rsp), %rax movq %rax, 0x20(%rsi) movq %r13, %rdi callq 0x7144c leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x2d7e5(%rip), %rsi # 0xceb00 leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rdx callq 0x1a8b4 leaq 0xf0(%rbx), %rdi leaq 0x28(%rsp), %rsi callq 0x13280 leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x2d7b4(%rip), %rsi # 0xceb00 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x1a8b4 movq %r15, 0x28(%rsp) movq 0x8(%rsp), %rax cmpq %rbp, %rax je 0xa137b movq %rax, 0x28(%rsp) movq 0x18(%rsp), %rax movq %rax, 0x38(%rsp) jmp 0xa1383 movups (%rbp), %xmm0 movups %xmm0, (%r15) movq 0x10(%rsp), %rax movq %rbp, 0x8(%rsp) andq $0x0, 0x10(%rsp) leaq 0x28(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x18(%rsp) movq %r12, 0x20(%rsi) movq %r13, %rdi callq 0x7144c leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0xa13e0 jmp 0xa1405 jmp 0xa13f6 jmp 0xa1405 jmp 0xa13e0 jmp 0xa1405 jmp 0xa13f6 jmp 0xa1405 movq %rax, %r13 leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi jmp 0xa13fe jmp 0xa1405 movq %rax, %r13 leaq 0x28(%rsp), %rdi callq 0x13a98 jmp 0xa1408 movq %rax, %r13 movq %r12, %rdi callq 0x5939c movq 0x50(%rsp), %rdi callq 0x5939c movq %r14, %rdi callq 0x5937c movq %rbx, %rdi callq 0x4b358 movq %r13, %rdi callq 0x13960 movq %rax, %r13 jmp 0xa1422 nop
/OpenMD[P]OpenMD/src/types/Component.cpp
OpenMD::Component::validate()
void Component::validate() { CheckParameter(Type, isNotEmpty()); CheckParameter(NMol, isPositive()); CheckParameter(Region, isNonNegative()); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx cmpb $0x0, 0x92(%rdi) movabsq $0x100000001, %r13 # imm = 0x100000001 jne 0xa154d leaq 0x28(%rsp), %rdi callq 0x8d130 leaq 0x98(%rbx), %rsi leaq 0x8(%rsp), %rdi callq 0x13700 leaq 0x8(%rsp), %rdi movq 0x8(%rdi), %r14 callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0x13a98 testq %r14, %r14 jne 0xa154d movq 0x70(%rbx), %r14 leaq 0x8(%rsp), %r15 movq %r15, %rdi callq 0x8d130 leaq 0x28(%rsp), %rdi movq %r15, %rsi callq 0x13700 leaq 0x28(%rsp), %r15 movq (%r15), %r8 leaq 0x7db8f(%rip), %r12 # 0x11f0a4 leaq 0x2a096(%rip), %rdx # 0xcb5b2 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi movq %r14, %rcx xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa cmpb $0x0, 0xe2(%rbx) jne 0xa15e1 leaq 0x28(%rsp), %r14 movq %r14, %rdi callq 0x8d163 movl 0xe4(%rbx), %ebp movq %r14, %rdi callq 0x13a98 testl %ebp, %ebp jg 0xa15e1 movq 0xc0(%rbx), %r14 leaq 0x8(%rsp), %r15 movq %r15, %rdi callq 0x8d163 leaq 0x28(%rsp), %rdi movq %r15, %rsi callq 0x13700 leaq 0x28(%rsp), %r15 movq (%r15), %r8 leaq 0x7dafb(%rip), %r12 # 0x11f0a4 leaq 0x2a002(%rip), %rdx # 0xcb5b2 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi movq %r14, %rcx xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa cmpb $0x0, 0x112(%rbx) jne 0xa1674 leaq 0x28(%rsp), %r14 movq %r14, %rdi callq 0x8d18d movl 0x114(%rbx), %ebp movq %r14, %rdi callq 0x13a98 testl %ebp, %ebp jns 0xa1674 movq 0xf0(%rbx), %rbx leaq 0x8(%rsp), %r14 movq %r14, %rdi callq 0x8d18d leaq 0x28(%rsp), %rdi movq %r14, %rsi callq 0x13700 leaq 0x28(%rsp), %r14 movq (%r14), %r8 leaq 0x7da67(%rip), %r15 # 0x11f0a4 leaq 0x29f6e(%rip), %rdx # 0xcb5b2 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi movq %rbx, %rcx xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0xa1687 jmp 0xa1687 movq %rax, %rbx leaq 0x8(%rsp), %rdi jmp 0xa1699 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/Component.cpp
OpenMD::Component::findMoleculeStamp(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, OpenMD::MoleculeStamp*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, OpenMD::MoleculeStamp*>>> const&)
bool Component::findMoleculeStamp( const std::map<std::string, MoleculeStamp*>& molStamps) { bool ret = false; std::map<std::string, MoleculeStamp*>::const_iterator i; i = molStamps.find(getType()); if (i != molStamps.end()) { moleculeStamp_ = i->second; ret = true; } return ret; }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq 0x98(%rdi), %rsi movq %rsp, %r15 movq %r15, %rdi callq 0x13700 movq %rbx, %rdi movq %r15, %rsi callq 0xa1714 movq %rax, %r15 movq %rsp, %rdi callq 0x13a98 addq $0x8, %rbx cmpq %rbx, %r15 je 0xa16f1 movq 0x40(%r15), %rax movq %rax, 0x118(%r14) cmpq %rbx, %r15 setne %al addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/Component.cpp
OpenMD::ConstraintStamp::ConstraintStamp()
ConstraintStamp::ConstraintStamp() { DefineParameter(ConstrainedDistance, "constrainedDistance"); DefineOptionalParameterWithDefaultValue(PrintConstraintForce, "printConstraintForce", false); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx callq 0x4b318 leaq 0x7b5df(%rip), %rax # 0x11cd88 movq %rax, (%rbx) leaq 0x80(%rbx), %rax movq %rax, 0x70(%rbx) andq $0x0, 0x78(%rbx) leaq 0x68(%rbx), %r14 xorl %eax, %eax movb %al, 0x80(%rbx) andw $0x0, 0x90(%rbx) movb $0x1, %cl movb %cl, 0x92(%rbx) leaq 0x79f49(%rip), %rdx # 0x11b728 movq %rdx, 0x68(%rbx) leaq 0xb8(%rbx), %rdx movq %rdx, 0xa8(%rbx) andq $0x0, 0xb0(%rbx) movb %al, 0xb8(%rbx) andw $0x0, 0xc8(%rbx) leaq 0xa0(%rbx), %r15 movb %cl, 0xca(%rbx) leaq 0x79e95(%rip), %rax # 0x11b6b0 movq %rax, 0xa0(%rbx) leaq 0x2d2f2(%rip), %rsi # 0xceb1b leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0x70(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x2d2c4(%rip), %rsi # 0xceb1b leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rbx), %r12 leaq 0x40(%rsp), %rbp movq %rbp, -0x10(%rbp) leaq 0x20(%rsp), %r13 movq -0x10(%r13), %rax cmpq %r13, %rax je 0xa1892 movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xa189b movups (%r13), %xmm0 movups %xmm0, (%rbp) movq 0x18(%rsp), %rax movq %r13, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq %r14, 0x20(%rsi) movq %r12, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x2d24f(%rip), %rsi # 0xceb2f leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0xa8(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 movl $0x101, 0xc8(%rbx) # imm = 0x101 leaq 0x2d214(%rip), %rsi # 0xceb2f leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 movq %rbp, 0x30(%rsp) movq 0x10(%rsp), %rax cmpq %r13, %rax je 0xa194a movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xa1953 movups (%r13), %xmm0 movups %xmm0, (%rbp) movq 0x18(%rsp), %rax movq %r13, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq %r15, 0x20(%rsi) movq %r12, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0xa19a8 jmp 0xa19cd jmp 0xa19be jmp 0xa19cd movq %rax, %r12 leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi jmp 0xa19c6 jmp 0xa19cd movq %rax, %r12 leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0xa19d0 movq %rax, %r12 movq %r15, %rdi callq 0x5939c movq %r14, %rdi callq 0x5939c movq %rbx, %rdi callq 0x4b358 movq %r12, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/ConstraintStamp.cpp
OpenMD::ConstraintStamp::validate()
void ConstraintStamp::validate() { DataHolder::validate(); CheckParameter(ConstrainedDistance, isNonNegative()); }
pushq %r15 pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdi, %rbx callq 0x4b392 cmpb $0x0, 0x92(%rbx) jne 0xa1af3 leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x8d18d movsd 0x98(%rbx), %xmm0 movsd %xmm0, 0x8(%rsp) movq %r14, %rdi callq 0x13a98 xorpd %xmm0, %xmm0 movsd 0x8(%rsp), %xmm1 ucomisd %xmm0, %xmm1 jae 0xa1af3 movq 0x70(%rbx), %rbx leaq 0x10(%rsp), %r14 movq %r14, %rdi callq 0x8d18d leaq 0x30(%rsp), %rdi movq %r14, %rsi callq 0x13700 leaq 0x30(%rsp), %r14 movq (%r14), %r8 leaq 0x7d5f2(%rip), %r15 # 0x11f0a4 leaq 0x29af9(%rip), %rdx # 0xcb5b2 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi movq %rbx, %rcx xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x7d0(%r15) callq 0x2beaa addq $0x50, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/ConstraintStamp.cpp
OpenMD::DirectionalAdapter::makeDirectional(OpenMD::SquareMatrix3<double>)
void DirectionalAdapter::makeDirectional(Mat3x3d I) { if (isDirectional()) { at_->removeProperty(DirectionalTypeID); } DirectionalAtypeParameters directionalParam {}; directionalParam.I = I; at_->addProperty(std::make_shared<DirectionalAtypeData>(DirectionalTypeID, directionalParam)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rsi, %r14 movq %rdi, %rbx callq 0xa1bd8 testb %al, %al je 0xa1dcb movq (%rbx), %rdi leaq 0x81722(%rip), %rsi # 0x1234e8 callq 0x9c8dc leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x1e636 movq %r15, %rdi movq %r14, %rsi callq 0x1e688 movq (%rbx), %r12 leaq 0x816fb(%rip), %rsi # 0x1234e8 movq %rsp, %rdi movq %r15, %rdx callq 0xa1eab leaq 0x18(%rsp), %r14 leaq 0x8(%rsp), %rbx movaps -0x8(%rbx), %xmm0 movaps %xmm0, -0x8(%r14) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%rbx) leaq 0x10(%rsp), %rsi movq %r12, %rdi callq 0x9c83e movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 addq $0x68, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %r15 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/DirectionalAdapter.cpp
OpenMD::EAMAdapter::getEAMParam()
EAMParameters EAMAdapter::getEAMParam() { if (!isEAM()) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getEAMParam was passed an atomType (%s)\n" "\tthat does not appear to be an EAM atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(EAMtypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getEAMParam could not find EAM\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<EAMData> eamData = std::dynamic_pointer_cast<EAMData>(data); if (eamData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getEAMParam could not convert\n" "\tGenericData to EAMData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return eamData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xa2094 movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xa2112 movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x7cfbd(%rip), %r12 # 0x11f0a4 leaq 0x2ccaa(%rip), %rdx # 0xced98 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x813ec(%rip), %rdx # 0x123508 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xa2176 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x7cf59(%rip), %r12 # 0x11f0a4 leaq 0x2cca4(%rip), %rdx # 0xcedf6 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xa437b movq (%r15), %rsi testq %rsi, %rsi jne 0xa21d8 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x7cefa(%rip), %r15 # 0x11f0a4 leaq 0x2cc8e(%rip), %rdx # 0xcee3f movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0xa43d0 leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xa220d jmp 0xa2212 movq %rax, %rbx jmp 0xa221f movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::EAMAdapter::getFuncflParam()
FuncflParameters EAMAdapter::getFuncflParam() { if (!isEAM()) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getFuncflParam was passed an atomType (%s)\n" "\tthat does not appear to be an EAM atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(FuncflTypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getFuncflParam could not find Funcfl\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<FuncflData> funcflData = std::dynamic_pointer_cast<FuncflData>(data); if (funcflData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getFuncflParam could not convert\n" "\tGenericData to FuncflData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return funcflData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xa2094 movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xa22a0 movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x7ce2f(%rip), %r12 # 0x11f0a4 leaq 0x2cc17(%rip), %rdx # 0xcee93 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x8127e(%rip), %rdx # 0x123528 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xa2304 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x7cdcb(%rip), %r12 # 0x11f0a4 leaq 0x2cc14(%rip), %rdx # 0xceef4 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xa43fe movq (%r15), %rsi testq %rsi, %rsi jne 0xa2366 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x7cd6c(%rip), %r15 # 0x11f0a4 leaq 0x2cc04(%rip), %rdx # 0xcef43 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0xa4454 leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xa239b jmp 0xa23a0 movq %rax, %rbx jmp 0xa23ad movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::EAMAdapter::getZhouParam()
ZhouParameters EAMAdapter::getZhouParam() { if (!isEAM()) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getZhouParam was passed an atomType (%s)\n" "\tthat does not appear to be an EAM atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(ZhouTypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getZhouParam could not find Zhou\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<ZhouData> zhouData = std::dynamic_pointer_cast<ZhouData>(data); if (zhouData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "EAMAdapter::getZhouParam could not convert\n" "\tGenericData to ZhouData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return zhouData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xa2094 movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xa242e movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x7cca1(%rip), %r12 # 0x11f0a4 leaq 0x2cb93(%rip), %rdx # 0xcef9d movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x81110(%rip), %rdx # 0x123548 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xa2492 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x7cc3d(%rip), %r12 # 0x11f0a4 leaq 0x2cb8e(%rip), %rdx # 0xceffc movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xa44df movq (%r15), %rsi testq %rsi, %rsi jne 0xa24f4 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x7cbde(%rip), %r15 # 0x11f0a4 leaq 0x2cb7a(%rip), %rdx # 0xcf047 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0xa4534 leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xa2529 jmp 0xa252e movq %rax, %rbx jmp 0xa253b movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::EAMAdapter::makeFuncfl(double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double, int, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
void EAMAdapter::makeFuncfl(RealType latticeConstant, std::string latticeType, int nrho, RealType drho, int nr, RealType dr, RealType rcut, vector<RealType> Z, vector<RealType> rho, vector<RealType> F) { if (isEAM()) { at_->removeProperty(EAMtypeID); at_->removeProperty(FuncflTypeID); } EAMParameters eamParam {}; FuncflParameters funcflParam {}; eamParam.eamType = eamFuncfl; eamParam.latticeConstant = latticeConstant; eamParam.latticeType = latticeType; funcflParam.nrho = nrho; funcflParam.drho = drho; funcflParam.nr = nr; funcflParam.dr = dr; funcflParam.rcut = rcut; funcflParam.Z = Z; funcflParam.rho = rho; funcflParam.F = F; at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam)); at_->addProperty(std::make_shared<FuncflData>(FuncflTypeID, funcflParam)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %r9, %r15 movq %r8, %r12 movsd %xmm3, 0x20(%rsp) movsd %xmm2, 0x18(%rsp) movl %ecx, %ebp movsd %xmm1, 0x10(%rsp) movl %edx, %r13d movq %rsi, %rbx movsd %xmm0, 0x28(%rsp) movq %rdi, %r14 callq 0xa2094 testb %al, %al je 0xa2913 movq (%r14), %rdi leaq 0x80c09(%rip), %rsi # 0x123508 callq 0x9c8dc movq (%r14), %rdi leaq 0x80c1a(%rip), %rsi # 0x123528 callq 0x9c8dc leaq 0xf0(%rsp), %rax movq %rax, -0x10(%rax) andq $0x0, -0x8(%rax) andl $0x0, 0x30(%rsp) andq $0x0, 0x38(%rsp) leaq 0xe0(%rsp), %rdi andl $0x0, 0x40(%rsp) movb $0x0, (%rax) andq $0x0, 0x48(%rsp) andl $0x0, 0x50(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x58(%rsp) movups %xmm0, 0x68(%rsp) movups %xmm0, 0x78(%rsp) movups %xmm0, 0x88(%rsp) movups %xmm0, 0x98(%rsp) andq $0x0, 0xa8(%rsp) andl $0x0, -0x18(%rax) movsd 0x28(%rsp), %xmm0 movsd %xmm0, 0x10(%rax) movq %rbx, %rsi callq 0x13280 leaq 0x68(%rsp), %rdi movl %r13d, -0x28(%rdi) movsd 0x10(%rsp), %xmm0 movsd %xmm0, -0x20(%rdi) movl %ebp, -0x18(%rdi) movsd 0x18(%rsp), %xmm0 movsd %xmm0, -0x10(%rdi) movsd 0x20(%rsp), %xmm0 movsd %xmm0, -0x8(%rdi) movq %r12, %rsi callq 0x4b5ae leaq 0x80(%rsp), %rdi movq %r15, %rsi callq 0x4b5ae movq 0x140(%rsp), %rsi leaq 0x98(%rsp), %rdi callq 0x4b5ae movq (%r14), %rbx leaq 0x80b18(%rip), %rsi # 0x123508 movq %rsp, %rdi leaq 0xd8(%rsp), %rdx callq 0xa464f leaq 0xc8(%rsp), %r12 leaq 0x8(%rsp), %r15 movaps -0x8(%r15), %xmm0 movaps %xmm0, -0x8(%r12) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r15) leaq 0xc0(%rsp), %rsi movq %rbx, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 movq (%r14), %rbx leaq 0x80ade(%rip), %rsi # 0x123528 movq %rsp, %rdi leaq 0x30(%rsp), %rdx callq 0xa4670 leaq 0xb8(%rsp), %r15 leaq 0x8(%rsp), %r14 movaps -0x8(%r14), %xmm0 movaps %xmm0, -0x8(%r15) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r14) leaq 0xb0(%rsp), %rsi movq %rbx, %rdi callq 0x9c83e movq %r15, %rdi callq 0x28296 movq %r14, %rdi callq 0x28296 leaq 0x30(%rsp), %rdi callq 0xa462c leaq 0xe0(%rsp), %rdi callq 0x13a98 addq $0x108, %rsp # imm = 0x108 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq %r15, %rdi callq 0x28296 movq %r14, %rdi jmp 0xa2adf jmp 0xa2ae8 movq %rax, %rbx movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 jmp 0xa2aeb jmp 0xa2ae8 movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0xa462c leaq 0xe0(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::EAMAdapter::makeZhou2004(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double, double, double, double, double, double, double, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, double, double, double, double)
void EAMAdapter::makeZhou2004(std::string latticeType, RealType re, RealType fe, RealType rhoe, RealType rhos, RealType alpha, RealType beta, RealType A, RealType B, RealType kappa, RealType lambda, std::vector<RealType> Fn, std::vector<RealType> F, RealType eta, RealType Fe, RealType rhol, RealType rhoh) { if (isEAM()) { at_->removeProperty(EAMtypeID); at_->removeProperty(ZhouTypeID); } EAMParameters eamParam {}; ZhouParameters zhouParam {}; eamParam.eamType = eamZhou2004; toUpper(latticeType); eamParam.latticeType = latticeType; // default to FCC if we don't specify HCP or BCC: if (latticeType == "HCP") eamParam.latticeConstant = re; else if (latticeType == "BCC") eamParam.latticeConstant = 2.0 * re / sqrt(3.0); else eamParam.latticeConstant = 2.0 * re / sqrt(2.0); zhouParam.re = re; zhouParam.fe = fe; zhouParam.rhoe = rhoe; zhouParam.alpha = alpha; zhouParam.beta = beta; zhouParam.A = A; zhouParam.B = B; zhouParam.kappa = kappa; zhouParam.lambda = lambda; zhouParam.Fn = Fn; zhouParam.F = F; zhouParam.eta = eta; zhouParam.Fe = Fe; zhouParam.rhos = rhos; zhouParam.rhol = rhol; zhouParam.rhoh = rhoh; at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam)); at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1b8, %rsp # imm = 0x1B8 movq %rcx, %r15 movq %rdx, %r12 movsd %xmm7, 0x48(%rsp) movsd %xmm6, 0x40(%rsp) movsd %xmm5, 0x38(%rsp) movsd %xmm4, 0x30(%rsp) movsd %xmm3, 0x18(%rsp) movsd %xmm2, 0x28(%rsp) movsd %xmm1, 0x20(%rsp) movsd %xmm0, 0x10(%rsp) movq %rsi, %r13 movq %rdi, %r14 callq 0xa2094 testb %al, %al je 0xa2e96 movq (%r14), %rdi leaq 0x80686(%rip), %rsi # 0x123508 callq 0x9c8dc movq (%r14), %rdi leaq 0x806b7(%rip), %rsi # 0x123548 callq 0x9c8dc leaq 0x80(%rsp), %rbx leaq 0x90(%rsp), %rbp movq %rbp, -0x10(%rbp) andq $0x0, -0x8(%rbp) movb $0x0, (%rbp) andq $0x0, 0x10(%rbp) leaq 0xa8(%rsp), %rdi movl $0x110, %edx # imm = 0x110 xorl %esi, %esi callq 0x13290 movl $0x2, -0x18(%rbp) movq %rsp, %rbp movq %rbp, %rdi callq 0x13a70 movq %r13, %rdi movq %rbp, %rsi callq 0x22507 movq %rsp, %rdi callq 0x13730 movq %rbx, %rdi movq %r13, %rsi callq 0x13280 leaq 0x108(%rsp), %rbp leaq 0x2c192(%rip), %rsi # 0xcf09d movq %r13, %rdi callq 0x2251c movsd 0x10(%rsp), %xmm1 movapd %xmm1, %xmm0 testb %al, %al jne 0xa2f54 leaq 0x2c179(%rip), %rsi # 0xcf0a1 movq %r13, %rdi callq 0x2251c movsd 0x10(%rsp), %xmm1 movapd %xmm1, %xmm0 addsd %xmm1, %xmm0 testb %al, %al je 0xa2f4c divsd 0x2be46(%rip), %xmm0 # 0xced90 jmp 0xa2f54 divsd 0x2be34(%rip), %xmm0 # 0xced88 movsd %xmm0, 0xa0(%rsp) movsd %xmm1, 0xa8(%rsp) movsd 0x20(%rsp), %xmm0 movsd %xmm0, 0xb0(%rsp) movsd 0x28(%rsp), %xmm0 movsd %xmm0, 0xb8(%rsp) movsd 0x30(%rsp), %xmm0 movsd %xmm0, 0xc0(%rsp) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0xc8(%rsp) movsd 0x40(%rsp), %xmm0 movsd %xmm0, 0xd0(%rsp) movsd 0x48(%rsp), %xmm0 movsd %xmm0, 0xd8(%rsp) movsd 0x1f0(%rsp), %xmm0 movsd %xmm0, 0xe0(%rsp) movsd 0x1f8(%rsp), %xmm0 movsd %xmm0, 0xe8(%rsp) movq %rbp, %rdi movq %r12, %rsi callq 0x4b5ae leaq 0xf0(%rsp), %rdi movq %r15, %rsi callq 0x4b5ae movsd 0x218(%rsp), %xmm0 movsd 0x210(%rsp), %xmm1 movsd 0x208(%rsp), %xmm2 movsd 0x200(%rsp), %xmm3 movsd %xmm3, 0x120(%rsp) movsd %xmm2, 0x128(%rsp) movsd 0x18(%rsp), %xmm2 movsd %xmm2, 0x130(%rsp) movsd %xmm1, 0x138(%rsp) movsd %xmm0, 0x140(%rsp) movq (%r14), %r12 leaq 0x804a8(%rip), %rsi # 0x123508 movq %rsp, %rdi leaq 0x78(%rsp), %rdx callq 0xa464f leaq 0x68(%rsp), %r13 leaq 0x8(%rsp), %r15 movaps -0x8(%r15), %xmm0 movaps %xmm0, -0x8(%r13) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r15) leaq 0x60(%rsp), %rsi movq %r12, %rdi callq 0x9c83e movq %r13, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 movq (%r14), %r14 leaq 0x80498(%rip), %rsi # 0x123548 movq %rsp, %rdi leaq 0xa8(%rsp), %rdx callq 0xa4691 leaq 0x58(%rsp), %r12 leaq 0x8(%rsp), %r15 movaps -0x8(%r15), %xmm0 movaps %xmm0, -0x8(%r12) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r15) leaq 0x50(%rsp), %rsi movq %r14, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 leaq 0xa8(%rsp), %rdi callq 0xa46b2 movq %rbx, %rdi callq 0x13a98 addq $0x1b8, %rsp # imm = 0x1B8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq %r12, %rdi jmp 0xa3131 jmp 0xa314f movq %rax, %r14 movq %r13, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 jmp 0xa3152 jmp 0xa314f movq %rax, %r14 movq %rsp, %rdi callq 0x13730 jmp 0xa3152 movq %rax, %r14 leaq 0xa8(%rsp), %rdi callq 0xa46b2 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::EAMAdapter::makeZhou2005Oxygen(double, double, double, double, double, double, double, double, double, double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
void EAMAdapter::makeZhou2005Oxygen(RealType re, RealType fe, RealType alpha, RealType beta, RealType A, RealType B, RealType kappa, RealType lambda, RealType gamma, RealType nu, std::vector<RealType> OrhoLimits, std::vector<RealType> OrhoE, std::vector<std::vector<RealType>> OF) { if (isEAM()) { at_->removeProperty(EAMtypeID); at_->removeProperty(ZhouTypeID); } EAMParameters eamParam {}; ZhouParameters zhouParam {}; eamParam.eamType = eamZhou2005Oxygen; eamParam.latticeConstant = re; zhouParam.re = re; zhouParam.fe = fe; zhouParam.alpha = alpha; zhouParam.beta = beta; zhouParam.A = A; zhouParam.B = B; zhouParam.kappa = kappa; zhouParam.lambda = lambda; zhouParam.gamma = gamma; zhouParam.nu = nu; zhouParam.OrhoLimits = OrhoLimits; zhouParam.OrhoE = OrhoE; zhouParam.OF = OF; at_->addProperty(std::make_shared<EAMData>(EAMtypeID, eamParam)); at_->addProperty(std::make_shared<ZhouData>(ZhouTypeID, zhouParam)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1c8, %rsp # imm = 0x1C8 movq %rcx, 0x18(%rsp) movq %rdx, %r12 movq %rsi, %r13 movsd %xmm7, 0x58(%rsp) movsd %xmm6, 0x50(%rsp) movsd %xmm5, 0x48(%rsp) movsd %xmm4, 0x40(%rsp) movsd %xmm3, 0x38(%rsp) movsd %xmm2, 0x30(%rsp) movsd %xmm1, 0x28(%rsp) movsd %xmm0, 0x20(%rsp) movq %rdi, %r14 callq 0xa2094 testb %al, %al je 0xa3534 movq (%r14), %rdi leaq 0x7ffe8(%rip), %rsi # 0x123508 callq 0x9c8dc movq (%r14), %rdi leaq 0x80019(%rip), %rsi # 0x123548 callq 0x9c8dc leaq 0xa0(%rsp), %r15 movq %r15, -0x10(%r15) andq $0x0, -0x8(%r15) movb $0x0, (%r15) leaq 0x178(%rsp), %rbp leaq 0xc8(%rsp), %rbx movl $0x100, %edx # imm = 0x100 movq %rbx, %rdi xorl %esi, %esi callq 0x13290 movl $0x4, -0x18(%r15) movsd 0x20(%rsp), %xmm0 movsd %xmm0, 0x10(%r15) movsd %xmm0, -0x10(%rbx) movsd 0x28(%rsp), %xmm0 movsd %xmm0, -0x8(%rbx) movsd 0x30(%rsp), %xmm0 movsd %xmm0, 0x8(%rbx) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0x10(%rbx) movsd 0x40(%rsp), %xmm0 movsd %xmm0, 0x18(%rbx) movsd 0x48(%rsp), %xmm0 movsd %xmm0, 0x20(%rbx) movsd 0x50(%rsp), %xmm0 movsd %xmm0, 0x28(%rbx) movsd 0x58(%rsp), %xmm0 movsd %xmm0, 0x30(%rbx) movsd 0x200(%rsp), %xmm0 movsd %xmm0, -0x10(%rbp) movsd 0x208(%rsp), %xmm0 movsd %xmm0, -0x8(%rbp) movq %rbp, %rdi movq %r13, %rsi callq 0x4b5ae leaq 0x190(%rsp), %rdi movq %r12, %rsi callq 0x4b5ae leaq 0x1a8(%rsp), %rdi movq 0x18(%rsp), %rsi callq 0xa46f0 movq (%r14), %r12 leaq 0x7fee7(%rip), %rsi # 0x123508 movq %rsp, %rdi leaq 0x88(%rsp), %rdx callq 0xa464f leaq 0x78(%rsp), %r13 leaq 0x8(%rsp), %r15 movaps -0x8(%r15), %xmm0 movaps %xmm0, -0x8(%r13) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r15) leaq 0x70(%rsp), %rsi movq %r12, %rdi callq 0x9c83e movq %r13, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 movq (%r14), %r14 leaq 0x7fed4(%rip), %rsi # 0x123548 movq %rsp, %rdi leaq 0xb8(%rsp), %rdx callq 0xa4691 leaq 0x68(%rsp), %r12 leaq 0x8(%rsp), %r15 movaps -0x8(%r15), %xmm0 movaps %xmm0, -0x8(%r12) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r15) leaq 0x60(%rsp), %rsi movq %r14, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 leaq 0xb8(%rsp), %rdi callq 0xa46b2 leaq 0x90(%rsp), %rdi callq 0x13a98 addq $0x1c8, %rsp # imm = 0x1C8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq %r12, %rdi jmp 0xa36fa jmp 0xa370b movq %rax, %r14 movq %r13, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 jmp 0xa370e jmp 0xa370b movq %rax, %r14 leaq 0xb8(%rsp), %rdi callq 0xa46b2 leaq 0x90(%rsp), %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/EAMAdapter.cpp
OpenMD::FixedChargeAdapter::getFixedChargeParam()
FixedChargeAtypeParameters FixedChargeAdapter::getFixedChargeParam() { if (!isFixedCharge()) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FixedChargeAdapter::getFixedChargeParam was passed an atomType " "(%s)\n" "\tthat does not appear to be a fixed charge atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(FCtypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FixedChargeAdapter::getFixedChargeParam could not find fixed " "charge\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<FixedChargeAtypeData> fcData = std::dynamic_pointer_cast<FixedChargeAtypeData>(data); if (fcData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FixedChargeAdapter::getFixedChargeParam could not convert\n" "\tGenericData to FixedChargeAtypeData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return fcData->getData(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx callq 0xa50c4 movabsq $0x100000001, %r12 # imm = 0x100000001 testb %al, %al jne 0xa5139 movq (%rbx), %rsi leaq 0x28(%rsp), %r14 movq %r14, %rdi callq 0x9caa0 movq (%r14), %rcx leaq 0x79f95(%rip), %r15 # 0x11f0a4 leaq 0x2a1cf(%rip), %rdx # 0xcf2e5 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r12, 0x7d0(%r15) callq 0x2beaa movq (%rbx), %rsi leaq 0x7e445(%rip), %rdx # 0x123588 leaq 0x18(%rsp), %r14 movq %r14, %rdi callq 0x9c964 cmpq $0x0, (%r14) jne 0xa519c movq (%rbx), %rsi leaq 0x28(%rsp), %rdi callq 0x9caa0 leaq 0x28(%rsp), %r14 movq (%r14), %rcx leaq 0x79f32(%rip), %r15 # 0x11f0a4 leaq 0x2a1e2(%rip), %rdx # 0xcf35b movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r12, 0x7d0(%r15) callq 0x2beaa leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0xa5307 movq (%r14), %rax testq %rax, %rax jne 0xa5201 movq (%rbx), %rsi leaq 0x28(%rsp), %rdi callq 0x9caa0 leaq 0x28(%rsp), %rbx movq (%rbx), %rcx leaq 0x79ed2(%rip), %r14 # 0x11f0a4 leaq 0x2a1e4(%rip), %rdx # 0xcf3bd movl $0x7d0, %esi # imm = 0x7D0 movq %r14, %rdi xorl %eax, %eax callq 0x13830 movq %rbx, %rdi callq 0x13a98 movq %r12, 0x7d0(%r14) callq 0x2beaa movq 0x8(%rsp), %rax movsd 0x28(%rax), %xmm0 movsd %xmm0, (%rsp) leaq 0x10(%rsp), %rdi callq 0x28296 leaq 0x20(%rsp), %rdi callq 0x28296 movsd (%rsp), %xmm0 addq $0x48, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0xa5234 jmp 0xa5243 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x28296 jmp 0xa5246 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/FixedChargeAdapter.cpp
OpenMD::FixedChargeAdapter::makeFixedCharge(double)
void FixedChargeAdapter::makeFixedCharge(RealType charge) { if (isFixedCharge()) { at_->removeProperty(FCtypeID); } FixedChargeAtypeParameters fcParam {}; fcParam.charge = charge; at_->addProperty(std::make_shared<FixedChargeAtypeData>(FCtypeID, fcParam)); }
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movsd %xmm0, 0x8(%rsp) movq %rdi, %rbx callq 0xa50c4 testb %al, %al je 0xa5288 movq (%rbx), %rdi leaq 0x7e305(%rip), %rsi # 0x123588 callq 0x9c8dc leaq 0x38(%rsp), %rdx movsd 0x8(%rsp), %xmm0 movsd %xmm0, (%rdx) movq (%rbx), %r15 leaq 0x7e2e7(%rip), %rsi # 0x123588 leaq 0x10(%rsp), %rdi callq 0xa535c leaq 0x28(%rsp), %r14 leaq 0x18(%rsp), %rbx movaps -0x8(%rbx), %xmm0 movaps %xmm0, -0x8(%r14) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%rbx) leaq 0x20(%rsp), %rsi movq %r15, %rdi callq 0x9c83e movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %r15 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/FixedChargeAdapter.cpp
OpenMD::FluctuatingChargeAdapter::getFluctuatingChargeParam()
FluctuatingAtypeParameters FluctuatingChargeAdapter::getFluctuatingChargeParam() { if (!isFluctuatingCharge()) { snprintf( painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FluctuatingChargeAdapter::getFluctuatingChargeParam was passed an " "atomType " "(%s)\n" "\tthat does not appear to be a fluctuating charge atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(FQtypeID); if (data == nullptr) { snprintf( painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FluctuatingChargeAdapter::getFluctuatingChargeParam could not find " "fluctuating charge\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<FluctuatingAtypeData> fqData = std::dynamic_pointer_cast<FluctuatingAtypeData>(data); if (fqData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "FluctuatingChargeAdapter::getFluctuatingChargeParam could not " "convert\n" "\tGenericData to FluctuatingAtypeData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return fqData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xa5534 movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xa55b2 movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x79b1d(%rip), %r12 # 0x11f0a4 leaq 0x29f5a(%rip), %rdx # 0xcf4e8 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x7dff4(%rip), %rdx # 0x1235b0 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xa5616 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x79ab9(%rip), %r12 # 0x11f0a4 leaq 0x29f7e(%rip), %rdx # 0xcf570 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xa5cd5 movq (%r15), %rsi testq %rsi, %rsi jne 0xa5678 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x79a5a(%rip), %r15 # 0x11f0a4 leaq 0x29f93(%rip), %rdx # 0xcf5e4 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0xa5d2a leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xa56ad jmp 0xa56b2 movq %rax, %rbx jmp 0xa56bf movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, double, int, double)
void FluctuatingChargeAdapter::makeFluctuatingCharge( RealType chargeMass, RealType electronegativity, RealType hardness, int slaterN, RealType slaterZeta) { if (isFluctuatingCharge()) { at_->removeProperty(FQtypeID); } FluctuatingAtypeParameters fqParam {}; fqParam.chargeMass = chargeMass; fqParam.usesSlaterIntramolecular = true; fqParam.electronegativity = electronegativity; fqParam.hardness = hardness; fqParam.slaterN = slaterN; fqParam.slaterZeta = slaterZeta; fqParam.vself.setCoefficient(1, electronegativity); fqParam.vself.setCoefficient(2, 0.5 * hardness); at_->addProperty(std::make_shared<FluctuatingAtypeData>(FQtypeID, fqParam)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xc0, %rsp movsd %xmm3, 0x20(%rsp) movl %esi, %ebp movsd %xmm2, 0x8(%rsp) movsd %xmm0, 0x10(%rsp) movq %rdi, %r14 movsd %xmm1, 0x18(%rsp) movsd %xmm1, 0x28(%rsp) callq 0xa5534 testb %al, %al je 0xa5946 movq (%r14), %rdi leaq 0x7dc6f(%rip), %rsi # 0x1235b0 callq 0x9c8dc leaq 0x90(%rsp), %rbx movw $0x100, -0x38(%rbx) # imm = 0x100 leaq 0x98(%rsp), %rax andl $0x0, (%rax) andq $0x0, 0x8(%rax) xorps %xmm0, %xmm0 movups %xmm0, -0x38(%rax) movq %rax, 0x10(%rax) movq %rax, 0x18(%rax) andq $0x0, 0x20(%rax) movsd 0x10(%rsp), %xmm0 movsd %xmm0, -0x48(%rax) movsd 0x18(%rsp), %xmm0 movsd %xmm0, -0x28(%rax) movsd 0x8(%rsp), %xmm0 movsd %xmm0, -0x20(%rax) movl %ebp, -0x18(%rax) movsd 0x20(%rsp), %xmm0 movsd %xmm0, -0x10(%rax) pushq $0x1 popq %rsi leaq 0x28(%rsp), %rdx movq %rbx, %rdi callq 0x769ce movsd 0x8(%rsp), %xmm0 mulsd 0x22deb(%rip), %xmm0 # 0xc87b0 leaq 0x30(%rsp), %rdx movsd %xmm0, (%rdx) pushq $0x2 popq %rsi movq %rbx, %rdi callq 0x769ce movq (%r14), %r14 leaq 0x7dbcd(%rip), %rsi # 0x1235b0 leaq 0x30(%rsp), %rdi leaq 0x50(%rsp), %rdx callq 0xa5d55 leaq 0x48(%rsp), %r12 leaq 0x38(%rsp), %r15 movapd -0x8(%r15), %xmm0 movapd %xmm0, -0x8(%r12) xorpd %xmm0, %xmm0 movapd %xmm0, -0x8(%r15) leaq 0x40(%rsp), %rsi movq %r14, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 movq %rbx, %rdi callq 0x76cb0 addq $0xc0, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq %r12, %rdi callq 0x28296 movq %r15, %rdi callq 0x28296 jmp 0xa5a64 jmp 0xa5a61 jmp 0xa5a61 movq %rax, %r14 movq %rbx, %rdi callq 0x76cb0 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, OpenMD::Polynomial<double>)
void FluctuatingChargeAdapter::makeFluctuatingCharge(RealType chargeMass, RealType nValence, DoublePolynomial vs) { if (isFluctuatingCharge()) { at_->removeProperty(FQtypeID); } FluctuatingAtypeParameters fqParam {}; fqParam.chargeMass = chargeMass; fqParam.usesSlaterIntramolecular = false; // old-style EAMPoly has nV = nM fqParam.isMetallic = true; fqParam.nValence = nValence; fqParam.nMobile = nValence; fqParam.vself = vs; at_->addProperty(std::make_shared<FluctuatingAtypeData>(FQtypeID, fqParam)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xa8, %rsp movq %rsi, %r15 movsd %xmm1, 0x8(%rsp) movsd %xmm0, (%rsp) movq %rdi, %r14 callq 0xa5534 testb %al, %al je 0xa5aab movq (%r14), %rdi leaq 0x7db0a(%rip), %rsi # 0x1235b0 callq 0x9c8dc leaq 0x78(%rsp), %rbx andq $0x0, -0x8(%rbx) leaq 0x80(%rsp), %rax andl $0x0, (%rax) andq $0x0, 0x8(%rax) xorps %xmm0, %xmm0 movups %xmm0, -0x28(%rax) andl $0x0, -0x18(%rax) movq %rax, 0x10(%rax) movq %rax, 0x18(%rax) andq $0x0, 0x20(%rax) movsd (%rsp), %xmm0 movsd %xmm0, -0x48(%rax) movw $0x1, -0x40(%rax) movsd 0x8(%rsp), %xmm0 movsd %xmm0, -0x38(%rax) movsd %xmm0, -0x30(%rax) movq %rbx, %rdi movq %r15, %rsi callq 0xa5d76 movq (%r14), %r15 leaq 0x7da9e(%rip), %rsi # 0x1235b0 leaq 0x10(%rsp), %rdi leaq 0x38(%rsp), %rdx callq 0xa5d55 leaq 0x28(%rsp), %r12 leaq 0x18(%rsp), %r14 movaps -0x8(%r14), %xmm0 movaps %xmm0, -0x8(%r12) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r14) leaq 0x20(%rsp), %rsi movq %r15, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x76cb0 addq $0xa8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %r15 movq %r12, %rdi callq 0x28296 movq %r14, %rdi callq 0x28296 jmp 0xa5b8c jmp 0xa5b89 movq %rax, %r15 movq %rbx, %rdi callq 0x76cb0 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp
OpenMD::FluctuatingChargeAdapter::makeFluctuatingCharge(double, double, double, OpenMD::Polynomial<double>)
void FluctuatingChargeAdapter::makeFluctuatingCharge(RealType chargeMass, RealType nValence, RealType nMobile, DoublePolynomial vs) { if (isFluctuatingCharge()) { at_->removeProperty(FQtypeID); } FluctuatingAtypeParameters fqParam {}; fqParam.chargeMass = chargeMass; fqParam.usesSlaterIntramolecular = false; fqParam.isMetallic = true; fqParam.nValence = nValence; fqParam.nMobile = nMobile; fqParam.vself = vs; at_->addProperty(std::make_shared<FluctuatingAtypeData>(FQtypeID, fqParam)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xb8, %rsp movq %rsi, %r15 movsd %xmm2, 0x18(%rsp) movsd %xmm1, 0x10(%rsp) movsd %xmm0, 0x8(%rsp) movq %rdi, %r14 callq 0xa5534 testb %al, %al je 0xa5bda movq (%r14), %rdi leaq 0x7d9db(%rip), %rsi # 0x1235b0 callq 0x9c8dc leaq 0x88(%rsp), %rbx andq $0x0, -0x8(%rbx) leaq 0x90(%rsp), %rax andl $0x0, (%rax) andq $0x0, 0x8(%rax) xorps %xmm0, %xmm0 movups %xmm0, -0x28(%rax) andl $0x0, -0x18(%rax) movq %rax, 0x10(%rax) movq %rax, 0x18(%rax) andq $0x0, 0x20(%rax) movsd 0x8(%rsp), %xmm0 movsd %xmm0, -0x48(%rax) movw $0x1, -0x40(%rax) movsd 0x10(%rsp), %xmm0 movsd %xmm0, -0x38(%rax) movsd 0x18(%rsp), %xmm0 movsd %xmm0, -0x30(%rax) movq %rbx, %rdi movq %r15, %rsi callq 0xa5d76 movq (%r14), %r15 leaq 0x7d965(%rip), %rsi # 0x1235b0 leaq 0x20(%rsp), %rdi leaq 0x48(%rsp), %rdx callq 0xa5d55 leaq 0x38(%rsp), %r12 leaq 0x28(%rsp), %r14 movaps -0x8(%r14), %xmm0 movaps %xmm0, -0x8(%r12) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r14) leaq 0x30(%rsp), %rsi movq %r15, %rdi callq 0x9c83e movq %r12, %rdi callq 0x28296 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x76cb0 addq $0xb8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %r15 movq %r12, %rdi callq 0x28296 movq %r14, %rdi callq 0x28296 jmp 0xa5cc5 jmp 0xa5cc2 movq %rax, %r15 movq %rbx, %rdi callq 0x76cb0 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/FluctuatingChargeAdapter.cpp
OpenMD::InversionTypeParser::parseTypeAndPars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>)
InversionType* InversionTypeParser::parseTypeAndPars( const std::string& type, std::vector<RealType> pars) { std::string line(type); std::vector<RealType>::iterator it; for (it = pars.begin(); it != pars.end(); ++it) { line.append("\t"); line.append(std::to_string(*it)); } return parseLine(line); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r14 movq %rdi, %rbx leaq 0x8(%rsp), %r15 movq %r15, %rdi callq 0x13700 movq (%r14), %rbp leaq 0x243a4(%rip), %r12 # 0xd0ee9 leaq 0x28(%rsp), %r13 cmpq 0x8(%r14), %rbp je 0xacb81 movq %r15, %rdi movq %r12, %rsi callq 0x13a10 movsd (%rbp), %xmm0 movq %r13, %rdi callq 0x9ef88 movq %r15, %rdi movq %r13, %rsi callq 0x13a30 movq %r13, %rdi callq 0x13a98 addq $0x8, %rbp jmp 0xacb4a leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xacbd6 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 movq %rbx, %rax addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0xacbb1 jmp 0xacbb1 movq %rax, %rbx jmp 0xacbc3 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/InversionTypeParser.cpp
OpenMD::InversionTypeParser::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
InversionType* InversionTypeParser::parseLine(const std::string& line) { StringTokenizer tokenizer(line); InversionType* inversionType = NULL; int nTokens = tokenizer.countTokens(); if (nTokens < 1) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } InversionTypeEnum it = getInversionTypeEnum(tokenizer.nextToken()); nTokens -= 1; switch (it) { case itImproperCosine: if (nTokens < 3 || nTokens % 3 != 0) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } else { int nSets = nTokens / 3; std::vector<ImproperCosineInversionParameter> parameters; for (int i = 0; i < nSets; ++i) { ImproperCosineInversionParameter currParam; currParam.kchi = tokenizer.nextTokenAsDouble(); currParam.n = tokenizer.nextTokenAsInt(); currParam.delta = tokenizer.nextTokenAsDouble() / 180.0 * Constants::PI; // convert to rad parameters.push_back(currParam); } inversionType = new ImproperCosineInversionType(parameters); } break; case itAmberImproper: if (nTokens < 1) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } else { RealType v2 = tokenizer.nextTokenAsDouble(); inversionType = new AmberImproperTorsionType(v2); } break; case itHarmonic: if (nTokens < 2) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } else { // Most inversion don't have specific angle information since // they are cosine polynomials. This one is different, // however. To match our other force field files // (particularly for bends): // // d0 should be read in kcal / mol / degrees^2 // phi0 should be read in degrees RealType degreesPerRadian = 180.0 / Constants::PI; // convert to kcal / mol / radians^2 RealType d0 = tokenizer.nextTokenAsDouble() * pow(degreesPerRadian, 2); // convert to radians RealType phi0 = tokenizer.nextTokenAsDouble() / degreesPerRadian; inversionType = new HarmonicInversionType(d0, phi0); } break; /* case itCentralAtomHeight : if (nTokens < 1) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } else { RealType k = tokenizer.nextTokenAsDouble(); inversionType = new CentralAtomHeightInversionType(k); } break; case itDreiding : if (nTokens < 3) { throw OpenMDException("InversionTypeParser: Not enough tokens"); } else { RealType k = tokenizer.nextTokenAsDouble(); inversionType = new CentralAtomHeightInversionType(k); } break; */ case itUnknown: default: throw OpenMDException("InversionTypeParser: Unknown Inversion Type"); } return inversionType; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xa0, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x18493(%rip), %rsi # 0xc5085 movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 leaq 0x48(%rsp), %rdi movq %rsp, %rdx movq %r14, %rsi callq 0xb9030 movq %rsp, %rdi callq 0x13a98 leaq 0x48(%rsp), %rdi callq 0xb912e movl %eax, %r14d testl %eax, %eax jle 0xacdc7 movq %rsp, %rdi leaq 0x48(%rsp), %rsi callq 0xb91ec movq %rsp, %rsi movq %rbx, %rdi callq 0xacfcc movl %eax, %ebx movq %rsp, %rdi callq 0x13a98 testl %ebx, %ebx je 0xacd08 cmpl $0x1, %ebx je 0xacc9c cmpl $0x3, %ebx jne 0xace11 cmpl $0x1, %r14d je 0xacea5 leaq 0x48(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x20(%rsp) pushq $0x40 popq %rdi callq 0x134d0 movq %rax, %r14 movq %rax, %rdi movsd 0x20(%rsp), %xmm0 callq 0xad074 jmp 0xacdaa cmpl $0x2, %r14d jbe 0xace5b leaq 0x48(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x20(%rsp) leaq 0x48(%rsp), %rdi callq 0xb9476 movsd %xmm0, 0x40(%rsp) pushq $0x18 popq %rdi callq 0x134d0 movq %rax, %r14 movsd 0x20(%rsp), %xmm0 mulsd 0x22f69(%rip), %xmm0 # 0xcfc48 movsd 0x40(%rsp), %xmm1 divsd 0x22f63(%rip), %xmm1 # 0xcfc50 leaq 0x7063c(%rip), %rax # 0x11d330 movq %rax, (%r14) movsd %xmm0, 0x8(%r14) movsd %xmm1, 0x10(%r14) jmp 0xacdaa leal -0x1(%r14), %eax pushq $0x3 popq %rcx xorl %edx, %edx divl %ecx cmpl $0x4, %r14d jb 0xaceec testl %edx, %edx jne 0xaceec movl %eax, %ebx xorpd %xmm0, %xmm0 movq %rsp, %r14 movapd %xmm0, (%r14) andq $0x0, 0x10(%r14) leaq 0x48(%rsp), %r15 leaq 0x28(%rsp), %r12 subl $0x1, %ebx jb 0xacd8c movq %r15, %rdi callq 0xb9476 movsd %xmm0, 0x28(%rsp) movq %r15, %rdi callq 0xb93d6 movl %eax, 0x30(%rsp) movq %r15, %rdi callq 0xb9476 divsd 0x1fedf(%rip), %xmm0 # 0xccc50 mulsd 0x1c7f7(%rip), %xmm0 # 0xc9570 movsd %xmm0, 0x38(%rsp) movq %r14, %rdi movq %r12, %rsi callq 0xad04e jmp 0xacd42 pushq $0x38 popq %rdi callq 0x134d0 movq %rax, %r14 movq %rsp, %rsi movq %rax, %rdi callq 0xc32b8 movq %rsp, %rdi callq 0xad560 leaq 0x48(%rsp), %rdi callq 0x1a91c movq %r14, %rax addq $0xa0, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x22efe(%rip), %rsi # 0xcfcd7 movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6cd23(%rip), %rsi # 0x119b20 leaq -0x894ea(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xacf31 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x22edb(%rip), %rsi # 0xcfcfe movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6ccd9(%rip), %rsi # 0x119b20 leaq -0x89534(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xacf31 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x22e6a(%rip), %rsi # 0xcfcd7 movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6cc8f(%rip), %rsi # 0x119b20 leaq -0x8957e(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xacf31 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x22e20(%rip), %rsi # 0xcfcd7 movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6cc45(%rip), %rsi # 0x119b20 leaq -0x895c8(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xacf31 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x22dd9(%rip), %rsi # 0xcfcd7 movq %rsp, %rdi leaq 0x28(%rsp), %rdx callq 0x1a8b4 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6cbfe(%rip), %rsi # 0x119b20 leaq -0x8960f(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xacf65 jmp 0xacf77 jmp 0xacf65 jmp 0xacf77 jmp 0xacf65 jmp 0xacf77 jmp 0xacf65 jmp 0xacf77 movq %rax, %rbx pushq $0x38 popq %rsi movq %r14, %rdi callq 0x134e0 jmp 0xacfb1 jmp 0xacfae movq %rax, %rbx pushq $0x40 popq %rsi movq %r14, %rdi callq 0x134e0 jmp 0xacfb9 jmp 0xacf97 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 testb %bpl, %bpl jne 0xacf7a jmp 0xacfb9 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xacfb9 jmp 0xacf97 jmp 0xacf97 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0xacfb9 jmp 0xacf97 movq %rax, %rbx jmp 0xacfb9 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0xacfc3 movq %rax, %rbx jmp 0xacfc3 movq %rax, %rbx movq %rsp, %rdi callq 0xad560 leaq 0x48(%rsp), %rdi callq 0x1a91c movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/InversionTypeParser.cpp
OpenMD::AmberImproperTorsionType::AmberImproperTorsionType(double)
AmberImproperTorsionType(RealType v2) : PolynomialInversionType(), v2_(v2) { // convert AmberImproper Torsion Type to Polynomial Inversion type RealType c0 = v2; RealType c2 = -v2; setCoefficient(0, c0); setCoefficient(2, c2); }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x10(%rdi), %rax andl $0x0, 0x10(%rdi) andq $0x0, 0x18(%rdi) movq %rax, 0x20(%rdi) movq %rax, 0x28(%rdi) andq $0x0, 0x30(%rdi) leaq 0x701f1(%rip), %rax # 0x11d290 movq %rax, (%rdi) movsd %xmm0, 0x38(%rdi) xorl %esi, %esi movaps %xmm0, (%rsp) callq 0xad0e4 movaps (%rsp), %xmm0 xorps 0x19a83(%rip), %xmm0 # 0xc6b40 pushq $0x2 popq %rsi movq %rbx, %rdi callq 0xad0e4 addq $0x18, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0xad0f8 movq %r14, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/AmberImproperTorsionType.hpp
OpenMD::MoleculeStamp::~MoleculeStamp()
MoleculeStamp::~MoleculeStamp() { Utils::deletePointers(atomStamps_); Utils::deletePointers(bondStamps_); Utils::deletePointers(bendStamps_); Utils::deletePointers(torsionStamps_); Utils::deletePointers(inversionStamps_); Utils::deletePointers(rigidBodyStamps_); Utils::deletePointers(cutoffGroupStamps_); Utils::deletePointers(fragmentStamps_); Utils::deletePointers(constraintStamps_); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq 0x6f2fc(%rip), %rax # 0x11d400 movq %rax, (%rdi) addq $0xe8, %rdi movq %rdi, 0x20(%rsp) callq 0xa9c7a leaq 0x118(%rbx), %rdi movq %rdi, 0x18(%rsp) callq 0xa9ca6 leaq 0x130(%rbx), %rdi movq %rdi, 0x10(%rsp) callq 0xa9cd2 leaq 0x148(%rbx), %rdi movq %rdi, 0x8(%rsp) callq 0xa9cfe leaq 0x160(%rbx), %rbp movq %rbp, %rdi callq 0xa9d2a leaq 0x178(%rbx), %r14 movq %r14, %rdi callq 0xa9d56 leaq 0x190(%rbx), %r15 movq %r15, %rdi callq 0xa9d82 leaq 0x1a8(%rbx), %r12 movq %r12, %rdi callq 0xb1dbc leaq 0x1c0(%rbx), %r13 movq %r13, %rdi callq 0xa9dda leaq 0x1d8(%rbx), %rdi callq 0x253e2 movq %r13, %rdi callq 0xaa3b4 movq %r12, %rdi callq 0xb2030 movq %r15, %rdi callq 0xaa380 movq %r14, %rdi callq 0xaa34c movq %rbp, %rdi callq 0xaa318 movq 0x8(%rsp), %rdi callq 0xaa2e4 movq 0x10(%rsp), %rdi callq 0xaa2b0 movq 0x18(%rsp), %rdi callq 0xaa27c leaq 0x100(%rbx), %rdi callq 0x253e2 movq 0x20(%rsp), %rdi callq 0xaa248 leaq 0xb8(%rbx), %rdi callq 0x5939c leaq 0x68(%rbx), %rdi callq 0x5937c movq %rbx, %rdi addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x4b358 movq %rax, %rdi callq 0x1ab08 nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::validate()
void MoleculeStamp::validate() { DataHolder::validate(); atom2Rigidbody.resize(getNAtoms()); // A negative number means the atom is a free atom, and does not // belong to rigidbody. Every element in atom2Rigidbody has unique // negative number at the very beginning for (unsigned int i = 0; i < atom2Rigidbody.size(); ++i) { atom2Rigidbody[i] = -1 - int(i); } for (std::size_t i = 0; i < getNRigidBodies(); ++i) { RigidBodyStamp* rbStamp = getRigidBodyStamp(i); std::vector<int> members = rbStamp->getMembers(); for (std::vector<int>::iterator j = members.begin(); j != members.end(); ++j) { atom2Rigidbody[*j] = i; } } checkAtoms(); checkBonds(); fillBondInfo(); checkBends(); checkTorsions(); checkInversions(); checkRigidBodies(); checkCutoffGroups(); checkFragments(); checkConstraints(); size_t nrigidAtoms = 0; for (std::size_t i = 0; i < getNRigidBodies(); ++i) { RigidBodyStamp* rbStamp = getRigidBodyStamp(i); nrigidAtoms += rbStamp->getNMembers(); } nintegrable_ = getNAtoms() + getNRigidBodies() - nrigidAtoms; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx callq 0x4b392 leaq 0x1d8(%rbx), %r14 movq 0xf0(%rbx), %rsi subq 0xe8(%rbx), %rsi sarq $0x3, %rsi movq %r14, %rdi callq 0x27cda movq 0x1d8(%rbx), %rax movq 0x1e0(%rbx), %rcx subq %rax, %rcx sarq $0x2, %rcx xorl %esi, %esi pushq $-0x1 popq %rdx movl %esi, %esi cmpq %rsi, %rcx jbe 0xae5a0 movl %edx, (%rax,%rsi,4) incl %esi decl %edx jmp 0xae590 xorl %r12d, %r12d movq %rsp, %r15 movq 0x178(%rbx), %rax movq 0x180(%rbx), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r12 jae 0xae5fe movslq %r12d, %rcx movq (%rax,%rcx,8), %rsi addq $0x70, %rsi movq %r15, %rdi callq 0x2262e movq (%rsp), %rax movq 0x8(%rsp), %rcx movq (%r14), %rdx cmpq %rcx, %rax je 0xae5f1 movslq (%rax), %rsi movl %r12d, (%rdx,%rsi,4) addq $0x4, %rax jmp 0xae5df movq %r15, %rdi callq 0x253e2 incq %r12 jmp 0xae5a6 movq %rbx, %rdi callq 0xae6c2 movq %rbx, %rdi callq 0xae800 movq %rbx, %rdi callq 0xaece8 movq %rbx, %rdi callq 0xaed92 movq %rbx, %rdi callq 0xafb3a movq %rbx, %rdi callq 0xb04b4 movq %rbx, %rdi callq 0xb10e8 movq %rbx, %rdi callq 0xb13a2 movq %rbx, %rdi callq 0xb15c6 movq %rbx, %rdi callq 0xb1704 movq 0x178(%rbx), %rcx movq 0x180(%rbx), %rax subq %rcx, %rax sarq $0x3, %rax xorl %esi, %esi movabsq $0x100000000, %rdi # imm = 0x100000000 movq %rax, %r8 xorl %edx, %edx subq $0x1, %r8 jb 0xae699 movq %rsi, %r9 sarq $0x1d, %r9 movq (%rcx,%r9), %r9 movq 0x78(%r9), %r10 subq 0x70(%r9), %r10 sarq $0x2, %r10 addq %r10, %rdx addq %rdi, %rsi jmp 0xae674 movq 0xf0(%rbx), %rcx subq 0xe8(%rbx), %rcx shrq $0x3, %rcx subl %edx, %eax addl %eax, %ecx movl %ecx, 0x1f0(%rbx) addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkAtoms()
void MoleculeStamp::checkAtoms() { std::vector<AtomStamp*>::iterator ai = std::find( atomStamps_.begin(), atomStamps_.end(), static_cast<AtomStamp*>(NULL)); if (ai != atomStamps_.end()) { std::ostringstream oss; oss << "Error in Molecule " << getName() << ": atom[" << ai - atomStamps_.begin() << "] is missing\n"; throw OpenMDException(oss.str()); } }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x198, %rsp # imm = 0x198 movq %rdi, %rbx movq 0xe8(%rdi), %rdi movq 0xf0(%rbx), %rsi leaq 0x20(%rsp), %rdx andq $0x0, (%rdx) callq 0xab22f cmpq 0xf0(%rbx), %rax jne 0xae705 addq $0x198, %rsp # imm = 0x198 popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x136e0 leaq 0x2130b(%rip), %rsi # 0xcfa27 movq %r15, %rdi callq 0x134b0 movq %rax, %r15 leaq 0x98(%rbx), %rsi movq %rsp, %rdi callq 0x13700 movq %rsp, %rsi movq %r15, %rdi callq 0x13450 leaq 0x2103c(%rip), %rsi # 0xcf784 movq %rax, %rdi callq 0x134b0 subq 0xe8(%rbx), %r14 sarq $0x3, %r14 movq %rax, %rdi movq %r14, %rsi callq 0x13480 leaq 0x2101f(%rip), %rsi # 0xcf78c movq %rax, %rdi callq 0x134b0 movq %rsp, %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %rbx leaq 0x28(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6b374(%rip), %rsi # 0x119b20 leaq -0x8ae99(%rip), %rdx # 0x2391a movq %rbx, %rdi callq 0x13910 movq %rax, %r14 movq %rsp, %rdi callq 0x13a98 testb %bpl, %bpl jne 0xae7d0 jmp 0xae7ee movq %rax, %r14 movq %rbx, %rdi callq 0x13380 jmp 0xae7ee jmp 0xae7dc movq %rax, %r14 movq %rsp, %rdi callq 0x13a98 jmp 0xae7ee jmp 0xae7eb movq %rax, %r14 leaq 0x20(%rsp), %rdi callq 0x13140 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkBonds()
void MoleculeStamp::checkBonds() { std::ostringstream oss; // make sure index is not out of range int natoms = static_cast<int>(getNAtoms()); for (std::size_t i = 0; i < getNBonds(); ++i) { BondStamp* bondStamp = getBondStamp(i); if (bondStamp->getA() > natoms - 1 || bondStamp->getA() < 0 || bondStamp->getB() > natoms - 1 || bondStamp->getB() < 0 || bondStamp->getA() == bondStamp->getB()) { oss << "Error in Molecule " << getName() << ": bond(" << bondStamp->getA() << ", " << bondStamp->getB() << ") is invalid\n"; throw OpenMDException(oss.str()); } } // make sure bonds are unique std::set<std::pair<int, int>> allBonds; for (std::size_t i = 0; i < getNBonds(); ++i) { BondStamp* bondStamp = getBondStamp(i); std::pair<int, int> bondPair(bondStamp->getA(), bondStamp->getB()); // make sure bondPair.first is always less than or equal to // bondPair.third if (bondPair.first > bondPair.second) { std::swap(bondPair.first, bondPair.second); } std::set<std::pair<int, int>>::iterator iter = allBonds.find(bondPair); if (iter != allBonds.end()) { oss << "Error in Molecule " << getName() << ": " << "bond(" << iter->first << ", " << iter->second << ") appears multiple times\n"; throw OpenMDException(oss.str()); } else { allBonds.insert(bondPair); } } // make sure atoms belong to same rigidbody do not bond to each other for (std::size_t i = 0; i < getNBonds(); ++i) { BondStamp* bondStamp = getBondStamp(i); if (atom2Rigidbody[bondStamp->getA()] == atom2Rigidbody[bondStamp->getB()]) { oss << "Error in Molecule " << getName() << ": " << "bond(" << bondStamp->getA() << ", " << bondStamp->getB() << ") belong to same rigidbody " << atom2Rigidbody[bondStamp->getA()] << "\n"; throw OpenMDException(oss.str()); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1d8, %rsp # imm = 0x1D8 movq %rdi, %rbx movabsq $0x100000000, %r13 # imm = 0x100000000 leaq 0x60(%rsp), %rdi callq 0x136e0 movq 0xf0(%rbx), %rdx subq 0xe8(%rbx), %rdx movq 0x118(%rbx), %rax shrq $0x3, %rdx movq %rbx, (%rsp) movq 0x120(%rbx), %rcx movq %rcx, %rsi subq %rax, %rsi sarq $0x3, %rsi incq %rsi xorl %edi, %edi decq %rsi je 0xae96b movq %rdi, %r8 sarq $0x1d, %r8 movq (%rax,%r8), %r15 movl 0xa0(%r15), %r9d cmpl %edx, %r9d jge 0xae899 testl %r9d, %r9d js 0xae899 movl 0xa4(%r15), %r8d cmpl %r8d, %r9d je 0xae899 cmpl %edx, %r8d jge 0xae899 addq %r13, %rdi testl %r8d, %r8d jns 0xae85b leaq 0x21187(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r14 movq (%rsp), %rsi addq $0x98, %rsi leaq 0x30(%rsp), %rdi callq 0x13700 leaq 0x30(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x20ec4(%rip), %rsi # 0xcf79a movq %rax, %rdi callq 0x134b0 movl 0xa0(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x19da0(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0xa4(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x20e90(%rip), %rsi # 0xcf7a2 movq %rax, %rdi callq 0x134b0 leaq 0x30(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x30(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x30(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6b1c9(%rip), %rsi # 0x119b20 leaq -0x8b044(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xaec54 leaq 0x38(%rsp), %rdx andl $0x0, (%rdx) andq $0x0, 0x8(%rdx) movq %rdx, 0x10(%rdx) movq %rdx, 0x18(%rdx) andq $0x0, 0x20(%rdx) xorl %ebp, %ebp leaq 0x30(%rsp), %r15 leaq 0x8(%rsp), %r12 xorl %ebx, %ebx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rbx jae 0xaea0b movq %rbp, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rcx movl 0xa0(%rcx), %eax movl 0xa4(%rcx), %ecx movl %eax, 0x8(%rsp) movl %ecx, 0xc(%rsp) cmpl %ecx, %eax jle 0xae9ca movl %ecx, 0x8(%rsp) movl %eax, 0xc(%rsp) movq %r15, %rdi movq %r12, %rsi callq 0x617bc movq %rax, %r14 leaq 0x38(%rsp), %rax cmpq %rax, %r14 jne 0xaeb7e movq %r15, %rdi movq %r12, %rsi callq 0xab2bc incq %rbx movq (%rsp), %rcx movq 0x118(%rcx), %rax movq 0x120(%rcx), %rcx addq %r13, %rbp jmp 0xae993 movq (%rsp), %rdx movq 0x1d8(%rdx), %rdx incq %rcx xorl %esi, %esi decq %rcx je 0xaeb58 leaq (%rsi,%r13), %rdi sarq $0x1d, %rsi movq (%rax,%rsi), %r15 movslq 0xa0(%r15), %rsi movl (%rdx,%rsi,4), %r8d movslq 0xa4(%r15), %r9 movq %rdi, %rsi cmpl (%rdx,%r9,4), %r8d jne 0xaea1b leaq 0x20fd5(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r14 movq (%rsp), %rax leaq 0x98(%rax), %rsi leaq 0x10(%rsp), %rdi callq 0x13700 leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1a20d(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x20d05(%rip), %rsi # 0xcf79c movq %rax, %rdi callq 0x134b0 movl 0xa0(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x19bdf(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0xa4(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x20cf7(%rip), %rsi # 0xcf7ca movq %rax, %rdi callq 0x134b0 movslq 0xa0(%r15), %rcx movq (%rsp), %rdx movq 0x1d8(%rdx), %rdx movl (%rdx,%rcx,4), %esi movq %rax, %rdi callq 0x13920 leaq 0x1b30c(%rip), %rsi # 0xc9e0b movq %rax, %rdi callq 0x134b0 leaq 0x10(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6afdc(%rip), %rsi # 0x119b20 leaq -0x8b231(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xaec54 leaq 0x30(%rsp), %rdi callq 0x2838c leaq 0x60(%rsp), %rdi callq 0x13140 addq $0x1d8, %rsp # imm = 0x1D8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x20ea2(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r15 movq (%rsp), %rsi addq $0x98, %rsi leaq 0x10(%rsp), %rdi callq 0x13700 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0x13450 leaq 0x1a0da(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x20bd2(%rip), %rsi # 0xcf79c movq %rax, %rdi callq 0x134b0 movl 0x20(%r14), %esi movq %rax, %rdi callq 0x13920 leaq 0x19aaf(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0x24(%r14), %esi movq %rax, %rdi callq 0x13920 leaq 0x20bb0(%rip), %rsi # 0xcf7b0 movq %rax, %rdi callq 0x134b0 leaq 0x10(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x6aedb(%rip), %rsi # 0x119b20 leaq -0x8b332(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xaec58 jmp 0xaec6c movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xaec6f jmp 0xaeccc movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xaeccc movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xaec90 jmp 0xaecd6 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xaecd6 jmp 0xaec9c movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 jmp 0xaeccc jmp 0xaecc9 jmp 0xaecc9 movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0xaecd6 jmp 0xaecc9 jmp 0xaecc9 jmp 0xaecc4 movq %rax, %rbx jmp 0xaecd6 movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x2838c leaq 0x60(%rsp), %rdi callq 0x13140 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::fillBondInfo()
void MoleculeStamp::fillBondInfo() { for (std::size_t i = 0; i < getNBonds(); ++i) { BondStamp* bondStamp = getBondStamp(i); int a = bondStamp->getA(); int b = bondStamp->getB(); AtomStamp* atomA = getAtomStamp(a); AtomStamp* atomB = getAtomStamp(b); atomA->addBond(i); atomA->addBondedAtom(b); atomB->addBond(i); atomB->addBondedAtom(a); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax xorl %ebx, %ebx xorl %r14d, %r14d movq %rdi, (%rsp) movq 0x118(%rdi), %rax movq 0x120(%rdi), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r14 jae 0xaed83 movq %rbx, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rax movslq 0xa0(%rax), %r15 movslq 0xa4(%rax), %r12 movq 0xe8(%rdi), %rax movq (%rax,%r15,8), %r13 movq (%rax,%r12,8), %rbp movq %r13, %rdi movl %r14d, %esi callq 0xaa0ce movq %r13, %rdi movl %r12d, %esi callq 0xaa0e8 movq %rbp, %rdi movl %r14d, %esi callq 0xaa0ce movq %rbp, %rdi movl %r15d, %esi callq 0xaa0e8 movq (%rsp), %rdi incq %r14 movabsq $0x100000000, %rax # imm = 0x100000000 addq %rax, %rbx jmp 0xaecfc addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkTorsions()
void MoleculeStamp::checkTorsions() { std::ostringstream oss; for (std::size_t i = 0; i < getNTorsions(); ++i) { TorsionStamp* torsionStamp = getTorsionStamp(i); std::vector<int> torsionAtoms = torsionStamp->getMembers(); std::vector<int>::iterator j = std::find_if(torsionAtoms.begin(), torsionAtoms.end(), std::bind(std::greater<int>(), std::placeholders::_1, getNAtoms() - 1)); std::vector<int>::iterator k = std::find_if(torsionAtoms.begin(), torsionAtoms.end(), std::bind(std::less<int>(), std::placeholders::_1, 0)); if (j != torsionAtoms.end() || k != torsionAtoms.end()) { oss << "Error in Molecule " << getName() << ": atoms of torsion" << containerToString(torsionAtoms) << " have invalid indices\n"; throw OpenMDException(oss.str()); } if (hasDuplicateElement(torsionAtoms)) { oss << "Error in Molecule " << getName() << " : atoms of torsion" << containerToString(torsionAtoms) << " have duplicated indices\n"; throw OpenMDException(oss.str()); } } for (std::size_t i = 0; i < getNTorsions(); ++i) { TorsionStamp* torsionStamp = getTorsionStamp(i); std::vector<int> torsionAtoms = torsionStamp->getMembers(); std::vector<int> rigidSet(getNRigidBodies(), 0); std::vector<int>::iterator j; for (j = torsionAtoms.begin(); j != torsionAtoms.end(); ++j) { int rigidbodyIndex = atom2Rigidbody[*j]; if (rigidbodyIndex >= 0) { ++rigidSet[rigidbodyIndex]; if (rigidSet[rigidbodyIndex] > 3) { oss << "Error in Molecule " << getName() << ": torsion" << containerToString(torsionAtoms) << "has four atoms on the same rigid body\n"; throw OpenMDException(oss.str()); } } } } std::set<std::tuple<int, int, int, int>> allTorsions; std::set<std::tuple<int, int, int, int>>::iterator iter; for (std::size_t i = 0; i < getNTorsions(); ++i) { TorsionStamp* torsionStamp = getTorsionStamp(i); std::vector<int> torsion = torsionStamp->getMembers(); if (torsion.size() == 3) { int ghostIndex = torsionStamp->getGhostVectorSource(); std::vector<int>::iterator j = std::find(torsion.begin(), torsion.end(), ghostIndex); if (j != torsion.end()) { torsion.insert(j, ghostIndex); } } std::tuple<int, int, int, int> torsionTuple {torsion[0], torsion[1], torsion[2], torsion[3]}; auto& [first, second, third, fourth] = torsionTuple; if (first > fourth) { std::swap(first, fourth); std::swap(second, third); } iter = allTorsions.find(torsionTuple); if (iter == allTorsions.end()) { allTorsions.insert(torsionTuple); } else { oss << "Error in Molecule " << getName() << ": " << "Torsion" << containerToString(torsion) << " appears multiple times\n"; throw OpenMDException(oss.str()); } } for (std::size_t i = 0; i < getNBonds(); ++i) { BondStamp* bondStamp = getBondStamp(i); int b = bondStamp->getA(); int c = bondStamp->getB(); AtomStamp* atomB = getAtomStamp(b); AtomStamp* atomC = getAtomStamp(c); AtomStamp::AtomIter ai2; AtomStamp::AtomIter ai3; for (int a = atomB->getFirstBondedAtom(ai2); a != -1; a = atomB->getNextBondedAtom(ai2)) { if (a == c) continue; for (int d = atomC->getFirstBondedAtom(ai3); d != -1; d = atomC->getNextBondedAtom(ai3)) { if (d == b) continue; std::tuple<int, int, int, int> newTorsion {a, b, c, d}; auto [first, second, third, fourth] = newTorsion; // make sure the first element is always less than or equal // to the fourth element in IntTuple4 if (first > fourth) { std::swap(first, fourth); std::swap(second, third); } if (allTorsions.find(newTorsion) == allTorsions.end()) { allTorsions.insert(newTorsion); TorsionStamp* newTorsionStamp = new TorsionStamp(); newTorsionStamp->setMembers(newTorsion); addTorsionStamp(newTorsionStamp); } } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x248, %rsp # imm = 0x248 movq %rdi, %r12 leaq 0xd0(%rsp), %rdi callq 0x136e0 xorl %r13d, %r13d leaq 0x58(%rsp), %rbx leaq 0xc0(%rsp), %r14 leaq 0xb8(%rsp), %r15 xorl %ebp, %ebp movq %r12, (%rsp) movq 0x148(%r12), %rax movq 0x150(%r12), %rcx movq %rcx, %rdx subq %rax, %rdx sarq $0x3, %rdx cmpq %rdx, %rbp jae 0xafc4d movq %r13, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rsi movl $0x98, %eax addq %rax, %rsi movq %rbx, %rdi callq 0x2262e movq 0x58(%rsp), %rdi movq 0xf0(%r12), %rax subq 0xe8(%r12), %rax movq 0x60(%rsp), %rsi sarq $0x3, %rax decq %rax movq %rax, 0xc8(%rsp) movq %r14, %rdx callq 0xa9fb9 movq %rax, %r12 movq 0x58(%rsp), %rdi movq 0x60(%rsp), %rsi andl $0x0, 0xbc(%rsp) movq %r15, %rdx callq 0xa9fd4 movq 0x60(%rsp), %rcx cmpq %rcx, %r12 jne 0xb00cd cmpq %rcx, %rax jne 0xb00cd movq %rbx, %rdi callq 0xa9fe5 movq (%rsp), %r12 testb %al, %al jne 0xb01a1 movq %rbx, %rdi callq 0x253e2 incq %rbp movabsq $0x100000000, %rax # imm = 0x100000000 addq %rax, %r13 jmp 0xafb79 xorl %r13d, %r13d leaq 0x58(%rsp), %rbx leaq 0x78(%rsp), %r14 leaq 0x28(%rsp), %r15 leaq 0x8(%rsp), %r12 movq (%rsp), %rbp movq %rcx, %rdx subq %rax, %rdx sarq $0x3, %rdx cmpq %rdx, %r13 jae 0xafd24 movslq %r13d, %rcx movq (%rax,%rcx,8), %rsi movl $0x98, %eax addq %rax, %rsi movq %rbx, %rdi callq 0x2262e movq 0x180(%rbp), %rsi subq 0x178(%rbp), %rsi sarq $0x3, %rsi andl $0x0, 0x28(%rsp) movq %r14, %rdi movq %r15, %rdx movq %r12, %rcx callq 0x225d8 movq 0x58(%rsp), %rax movq 0x60(%rsp), %rcx movq 0x1d8(%rbp), %rdx movq 0x78(%rsp), %rsi cmpq %rcx, %rax je 0xafcfa movslq (%rax), %rdi movslq (%rdx,%rdi,4), %rdi testq %rdi, %rdi js 0xafcf4 movl (%rsi,%rdi,4), %r8d leal 0x1(%r8), %r9d movl %r9d, (%rsi,%rdi,4) cmpl $0x3, %r8d jge 0xafff9 addq $0x4, %rax jmp 0xafccd movq %r14, %rdi callq 0x253e2 movq %rbx, %rdi callq 0x253e2 incq %r13 movq (%rsp), %rcx movq 0x148(%rcx), %rax movq 0x150(%rcx), %rcx jmp 0xafc68 leaq 0x30(%rsp), %rdx andl $0x0, (%rdx) andq $0x0, 0x8(%rdx) movq %rdx, 0x10(%rdx) movq %rdx, 0x18(%rdx) andq $0x0, 0x20(%rdx) xorl %ebx, %ebx leaq 0x78(%rsp), %r14 leaq 0x28(%rsp), %r12 leaq 0x90(%rsp), %r13 xorl %r15d, %r15d subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r15 jae 0xafe6a movq %rbx, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rbp leaq 0x98(%rbp), %rsi movq %r14, %rdi callq 0x2262e movq 0x78(%rsp), %rdi movq 0x80(%rsp), %rsi movq %rsi, %rax subq %rdi, %rax cmpq $0xc, %rax jne 0xafdcb movl 0x94(%rbp), %eax movl %eax, 0x8(%rsp) leaq 0x8(%rsp), %rdx callq 0xab5c6 cmpq 0x80(%rsp), %rax je 0xafdc6 movq %r14, %rdi movq %rax, %rsi leaq 0x8(%rsp), %rdx callq 0xaa064 movq 0x78(%rsp), %rdi movq 0x8(%rdi), %xmm0 pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1] movd %xmm1, %edx pshufd $0xe1, %xmm0, %xmm1 # xmm1 = xmm0[1,0,2,3] movq %xmm1, 0x90(%rsp) movl 0x4(%rdi), %eax movl %eax, 0x98(%rsp) movl (%rdi), %ecx movl %ecx, 0x9c(%rsp) cmpl %edx, %ecx jle 0xafe17 movd %eax, %xmm1 movd %ecx, %xmm2 punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1] punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0] movdqa %xmm2, 0x90(%rsp) movq %r12, %rdi movq %r13, %rsi callq 0xab8c6 leaq 0x30(%rsp), %rcx cmpq %rcx, %rax jne 0xb0275 movq %r12, %rdi movq %r13, %rsi callq 0xab982 movq %r14, %rdi callq 0x253e2 incq %r15 movq (%rsp), %rcx movq 0x148(%rcx), %rax movq 0x150(%rcx), %rcx movabsq $0x100000000, %rdx # imm = 0x100000000 addq %rdx, %rbx jmp 0xafd55 xorl %esi, %esi leaq 0x78(%rsp), %r15 movq (%rsp), %rdx movq 0x118(%rdx), %rax movq 0x120(%rdx), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rsi jae 0xaffd0 movq %rsi, 0xa0(%rsp) movslq %esi, %rcx movq (%rax,%rcx,8), %rax movslq 0xa0(%rax), %r12 movslq 0xa4(%rax), %r13 movq 0xe8(%rdx), %rax movq (%rax,%r12,8), %rcx movq (%rax,%r13,8), %r14 andq $0x0, 0x78(%rsp) movq 0x128(%rcx), %rax movq %rax, 0x58(%rsp) movq %rcx, 0xb0(%rsp) addq $0x118, %rcx # imm = 0x118 pushq $-0x1 popq %rbx cmpq %rcx, %rax je 0xafeeb movl 0x20(%rax), %ebx leaq 0x118(%r14), %rax movq %rax, 0xa8(%rsp) cmpl $-0x1, %ebx je 0xaffc0 cmpl %r13d, %ebx je 0xaffa7 movq 0x128(%r14), %rcx movq %rcx, 0x78(%rsp) pushq $-0x1 popq %rax cmpq 0xa8(%rsp), %rcx je 0xaffa2 movl 0x20(%rcx), %eax jmp 0xaffa2 cmpl %r12d, %eax je 0xaff97 movl %eax, 0x8(%rsp) movl %r13d, 0xc(%rsp) movl %r12d, 0x10(%rsp) movl %ebx, 0x14(%rsp) leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rsi callq 0xab8c6 leaq 0x30(%rsp), %rcx cmpq %rcx, %rax jne 0xaff97 leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rsi callq 0xab982 movl $0xf0, %edi callq 0x134d0 movq %rax, %rbp movq %rax, %rdi callq 0xb50e8 movq %rbp, %rdi leaq 0x8(%rsp), %rsi callq 0xb1fc0 movq (%rsp), %rdi movq %rbp, %rsi callq 0xae3a6 movq %r14, %rdi movq %r15, %rsi callq 0xb1f8e cmpl $-0x1, %eax jne 0xaff2a movq 0xb0(%rsp), %rdi leaq 0x58(%rsp), %rsi callq 0xb1f8e movl %eax, %ebx jmp 0xafefa movq 0xa0(%rsp), %rsi incq %rsi jmp 0xafe71 leaq 0x28(%rsp), %rdi callq 0xaa15a leaq 0xd0(%rsp), %rdi callq 0x13140 addq $0x248, %rsp # imm = 0x248 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x1fa27(%rip), %rsi # 0xcfa27 leaq 0xd0(%rsp), %rdi callq 0x134b0 movq %rax, %rbx movq (%rsp), %rsi addq $0x98, %rsi leaq 0x28(%rsp), %rdi callq 0x13700 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f8e1(%rip), %rsi # 0xcf91a movq %rax, %rdi callq 0x134b0 movq %rax, %rbx leaq 0x8(%rsp), %rdi leaq 0x58(%rsp), %rsi callq 0x4b4dd leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f8bd(%rip), %rsi # 0xcf924 movq %rax, %rdi callq 0x134b0 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xd8(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x69a67(%rip), %rsi # 0x119b20 leaq -0x8c7a6(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0353 leaq 0x1f953(%rip), %rsi # 0xcfa27 leaq 0xd0(%rsp), %rdi callq 0x134b0 movq %rax, %rbx movq (%rsp), %rsi addq $0x98, %rsi leaq 0x28(%rsp), %rdi callq 0x13700 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f7fa(%rip), %rsi # 0xcf907 movq %rax, %rdi callq 0x134b0 movq %rax, %rbx leaq 0x8(%rsp), %rdi leaq 0x58(%rsp), %rsi callq 0x4b4dd leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f6bc(%rip), %rsi # 0xcf7f7 movq %rax, %rdi callq 0x134b0 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xd8(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x69993(%rip), %rsi # 0x119b20 leaq -0x8c87a(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0353 leaq 0x1f87f(%rip), %rsi # 0xcfa27 leaq 0xd0(%rsp), %rdi callq 0x134b0 movq %rax, %rbx movq (%rsp), %rsi addq $0x98, %rsi leaq 0x28(%rsp), %rdi callq 0x13700 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f725(%rip), %rsi # 0xcf906 movq %rax, %rdi callq 0x134b0 movq %rax, %rbx leaq 0x8(%rsp), %rdi leaq 0x58(%rsp), %rsi callq 0x4b4dd leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f5ff(%rip), %rsi # 0xcf80e movq %rax, %rdi callq 0x134b0 leaq 0x8(%rsp), %rdi callq 0x13a98 leaq 0x28(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xd8(%rsp), %rsi leaq 0x28(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x698bf(%rip), %rsi # 0x119b20 leaq -0x8c94e(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0353 leaq 0x1f7ab(%rip), %rsi # 0xcfa27 leaq 0xd0(%rsp), %rdi callq 0x134b0 movq %rax, %rbx movq (%rsp), %rsi addq $0x98, %rsi leaq 0x8(%rsp), %rdi callq 0x13700 leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x189e0(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x17838(%rip), %rsi # 0xc7afc movq %rax, %rdi callq 0x134b0 movq %rax, %rbx leaq 0x58(%rsp), %rdi leaq 0x78(%rsp), %rsi callq 0x4b4dd leaq 0x58(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1f4bf(%rip), %rsi # 0xcf7b1 movq %rax, %rdi callq 0x134b0 leaq 0x58(%rsp), %rdi callq 0x13a98 leaq 0x8(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xd8(%rsp), %rsi leaq 0x8(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x697dc(%rip), %rsi # 0x119b20 leaq -0x8ca31(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb036d jmp 0xb042f movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb042f jmp 0xb037e jmp 0xb0395 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0398 jmp 0xb046f movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb046f movq %rax, %rbx leaq 0x58(%rsp), %rdi callq 0x13a98 jmp 0xb0403 jmp 0xb0400 jmp 0xb03b8 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0xb03f4 jmp 0xb03f1 jmp 0xb03f1 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb03e5 jmp 0xb0465 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb0465 jmp 0xb03f1 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 jmp 0xb046f movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0xb042f jmp 0xb042c jmp 0xb0447 jmp 0xb0447 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x13a98 jmp 0xb0454 jmp 0xb042c jmp 0xb0451 jmp 0xb042c jmp 0xb042c movq %rax, %rbx leaq 0x78(%rsp), %rdi callq 0x253e2 jmp 0xb0494 jmp 0xb0491 jmp 0xb0447 jmp 0xb044c jmp 0xb0447 jmp 0xb0447 jmp 0xb0447 movq %rax, %rbx jmp 0xb046f movq %rax, %rbx jmp 0xb049e movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0x13a98 jmp 0xb0465 jmp 0xb0462 movq %rax, %rbx leaq 0x78(%rsp), %rdi callq 0x253e2 leaq 0x58(%rsp), %rdi callq 0x253e2 jmp 0xb049e movq %rax, %rbx movl $0xf0, %esi movq %rbp, %rdi callq 0x134e0 jmp 0xb0494 jmp 0xb0491 jmp 0xb0491 movq %rax, %rbx leaq 0x28(%rsp), %rdi callq 0xaa15a leaq 0xd0(%rsp), %rdi callq 0x13140 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkInversions()
void MoleculeStamp::checkInversions() { std::ostringstream oss; // first we automatically find the other three atoms that // are satellites of an inversion center: for (std::size_t i = 0; i < getNInversions(); ++i) { InversionStamp* inversionStamp = getInversionStamp(i); int center = inversionStamp->getCenter(); std::vector<int> satellites; // Some inversions come pre-programmed with the satellites. If // so, don't add the satellites as they are already there. if (inversionStamp->getNSatellites() != 3) { for (std::size_t j = 0; j < getNBonds(); ++j) { BondStamp* bondStamp = getBondStamp(j); int a = bondStamp->getA(); int b = bondStamp->getB(); if (a == center) { satellites.push_back(b); } if (b == center) { satellites.push_back(a); } } if (satellites.size() == 3) { std::sort(satellites.begin(), satellites.end()); inversionStamp->setSatellites(satellites); } else { oss << "Error in Molecule " << getName() << ": found wrong number" << " of bonds for inversion center " << center; throw OpenMDException(oss.str()); } } } // then we do some sanity checking on the inversions: for (std::size_t i = 0; i < getNInversions(); ++i) { InversionStamp* inversionStamp = getInversionStamp(i); std::vector<int> inversionAtoms = inversionStamp->getSatellites(); // add the central atom to the beginning of the list: inversionAtoms.insert(inversionAtoms.begin(), inversionStamp->getCenter()); std::vector<int>::iterator j = std::find_if(inversionAtoms.begin(), inversionAtoms.end(), std::bind(std::greater<int>(), std::placeholders::_1, getNAtoms() - 1)); std::vector<int>::iterator k = std::find_if(inversionAtoms.begin(), inversionAtoms.end(), std::bind(std::less<int>(), std::placeholders::_1, 0)); if (j != inversionAtoms.end() || k != inversionAtoms.end()) { oss << "Error in Molecule " << getName() << ": atoms of inversion" << containerToString(inversionAtoms) << " have invalid indices\n"; throw OpenMDException(oss.str()); } if (hasDuplicateElement(inversionAtoms)) { oss << "Error in Molecule " << getName() << " : atoms of inversion" << containerToString(inversionAtoms) << " have duplicated indices\n"; throw OpenMDException(oss.str()); } } for (std::size_t i = 0; i < getNInversions(); ++i) { InversionStamp* inversionStamp = getInversionStamp(i); std::vector<int> inversionAtoms = inversionStamp->getSatellites(); inversionAtoms.push_back(inversionStamp->getCenter()); std::vector<int> rigidSet(getNRigidBodies(), 0); std::vector<int>::iterator j; for (j = inversionAtoms.begin(); j != inversionAtoms.end(); ++j) { int rigidbodyIndex = atom2Rigidbody[*j]; if (rigidbodyIndex >= 0) { ++rigidSet[rigidbodyIndex]; if (rigidSet[rigidbodyIndex] > 3) { oss << "Error in Molecule " << getName() << ": inversion centered on atom " << inversionStamp->getCenter() << " has four atoms that belong to same rigidbody " << rigidbodyIndex << "\n"; throw OpenMDException(oss.str()); } } } } std::set<std::tuple<int, int, int, int>> allInversions; std::set<std::tuple<int, int, int, int>>::iterator iter; for (std::size_t i = 0; i < getNInversions(); ++i) { InversionStamp* inversionStamp = getInversionStamp(i); int cent = inversionStamp->getCenter(); std::vector<int> inversion = inversionStamp->getSatellites(); std::tuple<int, int, int, int> inversionTuple { cent, inversion[0], inversion[1], inversion[2]}; auto& [first, second, third, fourth] = inversionTuple; // In OpenMD, the Central atom in an inversion comes first, and // has a special position. The other three atoms can come in // random order, and should be sorted in increasing numerical // order to check for duplicates. This requires three pairwise // swaps: if (third > fourth) std::swap(third, fourth); if (second > third) std::swap(second, third); if (third > fourth) std::swap(third, fourth); iter = allInversions.find(inversionTuple); if (iter == allInversions.end()) { allInversions.insert(inversionTuple); } else { oss << "Error in Molecule " << getName() << ": " << "Inversion" << containerToString(inversion) << " appears multiple times\n"; throw OpenMDException(oss.str()); } } // Next we automatically find the inversion centers that weren't // explicitly created. An inversion center is any atom that has // exactly three bonds to it. Not all inversion centers have // potentials associated with them. for (std::size_t i = 0; i < getNAtoms(); ++i) { AtomStamp* ai = getAtomStamp(i); if (ai->getCoordination() == 3) { AtomStamp::AtomIter ai2; std::vector<int> satellites; for (int a = ai->getFirstBondedAtom(ai2); a != -1; a = ai->getNextBondedAtom(ai2)) { satellites.push_back(a); } if (satellites.size() == 3) { int cent = ai->getIndex(); std::sort(satellites.begin(), satellites.end()); std::tuple<int, int, int, int> newInversion { cent, satellites[0], satellites[1], satellites[2]}; auto [first, second, third, fourth] = newInversion; if (third > fourth) std::swap(third, fourth); if (second > third) std::swap(second, third); if (third > fourth) std::swap(third, fourth); if (allInversions.find(newInversion) == allInversions.end()) { allInversions.insert(newInversion); InversionStamp* newInversionStamp = new InversionStamp(); newInversionStamp->setCenter(cent); newInversionStamp->setSatellites(satellites); addInversionStamp(newInversionStamp); } } else { oss << "Error in Molecule " << getName() << ": found bond mismatch" << " when detecting inversion centers."; throw OpenMDException(oss.str()); } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x238, %rsp # imm = 0x238 movq %rdi, %rbx leaq 0xc0(%rsp), %rdi callq 0x136e0 xorl %r15d, %r15d movq %rsp, %r14 movq 0x160(%rbx), %rax movq 0x168(%rbx), %rcx movq %rcx, %rdx subq %rax, %rdx sarq $0x3, %rdx cmpq %rdx, %r15 jae 0xb05f1 movslq %r15d, %rcx movq (%rax,%rcx,8), %r13 movl 0x98(%r13), %ebp pxor %xmm0, %xmm0 movdqa %xmm0, (%rsp) andq $0x0, 0x10(%rsp) movq 0xa8(%r13), %rax subq 0xa0(%r13), %rax cmpq $0xc, %rax je 0xb05e1 movq %r15, 0x88(%rsp) xorl %r12d, %r12d xorl %r15d, %r15d movq 0x118(%rbx), %rax movq 0x120(%rbx), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r15 jae 0xb05b0 movq %r12, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rax movl 0xa0(%rax), %ecx movl %ecx, 0x20(%rsp) movl 0xa4(%rax), %eax movl %eax, 0x50(%rsp) cmpl %ebp, %ecx jne 0xb058d movq %r14, %rdi leaq 0x50(%rsp), %rsi callq 0x27f56 movl 0x50(%rsp), %eax cmpl %ebp, %eax jne 0xb059e movq %r14, %rdi leaq 0x20(%rsp), %rsi callq 0x27f56 incq %r15 movabsq $0x100000000, %rax # imm = 0x100000000 addq %rax, %r12 jmp 0xb053f movq (%rsp), %rdi movq 0x8(%rsp), %rsi movq %rsi, %rax subq %rdi, %rax cmpq $0xc, %rax jne 0xb0da9 callq 0xabb0d movq 0x88(%rsp), %r15 movq %r13, %rdi movq %r14, %rsi callq 0x4afc0 movq %r14, %rdi callq 0x253e2 incq %r15 jmp 0xb04db xorl %r15d, %r15d leaq 0x50(%rsp), %r14 leaq 0xa8(%rsp), %r13 xorl %r12d, %r12d movq %rcx, %rdx subq %rax, %rdx sarq $0x3, %rdx cmpq %rdx, %r12 jae 0xb06f0 movq %r15, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rbp leaq 0xa0(%rbp), %rsi movq %r14, %rdi callq 0x2262e movq 0x50(%rsp), %rsi movl 0x98(%rbp), %eax movl %eax, 0x20(%rsp) movq %r14, %rdi leaq 0x20(%rsp), %rdx callq 0xabf0e movq 0x50(%rsp), %rdi movq 0xf0(%rbx), %rax subq 0xe8(%rbx), %rax movq 0x58(%rsp), %rsi sarq $0x3, %rax decq %rax movq %rax, 0xb8(%rsp) leaq 0xb0(%rsp), %rdx callq 0xa9fb9 movq %rax, %rbp movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi andl $0x0, 0xac(%rsp) movq %r13, %rdx callq 0xa9fd4 movq 0x58(%rsp), %rcx cmpq %rcx, %rbp jne 0xb0b34 cmpq %rcx, %rax jne 0xb0b34 movq %r14, %rdi callq 0xa9fe5 testb %al, %al jne 0xb0c01 movq %r14, %rdi callq 0x253e2 incq %r12 movq 0x160(%rbx), %rax movq 0x168(%rbx), %rcx movabsq $0x100000000, %rdx # imm = 0x100000000 addq %rdx, %r15 jmp 0xb0604 xorl %r15d, %r15d movq %rsp, %r14 leaq 0x20(%rsp), %r12 movq %rcx, %rdx subq %rax, %rdx sarq $0x3, %rdx cmpq %rdx, %r15 jae 0xb07d1 movslq %r15d, %rcx movq (%rax,%rcx,8), %r13 leaq 0xa0(%r13), %rsi movq %r14, %rdi callq 0x2262e movl 0x98(%r13), %eax movl %eax, 0x20(%rsp) movq %r14, %rdi movq %r12, %rbp movq %r12, %rsi callq 0x2972c movq 0x180(%rbx), %rsi subq 0x178(%rbx), %rsi sarq $0x3, %rsi andl $0x0, 0x20(%rsp) leaq 0x50(%rsp), %rdi movq %rbp, %rdx leaq 0x90(%rsp), %rcx callq 0x225d8 movq (%rsp), %rax movq 0x8(%rsp), %rcx movq 0x1d8(%rbx), %rdx movq 0x50(%rsp), %rsi cmpq %rcx, %rax je 0xb07a9 movslq (%rax), %rdi movslq (%rdx,%rdi,4), %rbp testq %rbp, %rbp js 0xb07a3 movl (%rsi,%rbp,4), %edi leal 0x1(%rdi), %r8d movl %r8d, (%rsi,%rbp,4) cmpl $0x3, %edi jge 0xb0a62 addq $0x4, %rax jmp 0xb077e leaq 0x50(%rsp), %rdi callq 0x253e2 movq %r14, %rdi callq 0x253e2 incq %r15 movq 0x160(%rbx), %rax movq 0x168(%rbx), %rcx jmp 0xb06fb leaq 0x28(%rsp), %rdx andl $0x0, (%rdx) andq $0x0, 0x8(%rdx) movq %rdx, 0x10(%rdx) movq %rdx, 0x18(%rdx) andq $0x0, 0x20(%rdx) xorl %r13d, %r13d leaq 0x20(%rsp), %r15 leaq 0x78(%rsp), %r12 xorl %ebp, %ebp subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rbp jae 0xb08de movq %r13, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rsi movl 0x98(%rsi), %r14d addq $0xa0, %rsi leaq 0x90(%rsp), %rdi callq 0x2262e movq 0x90(%rsp), %rax movl 0x8(%rax), %ecx movl %ecx, 0x78(%rsp) movl 0x4(%rax), %esi movl %esi, 0x7c(%rsp) movl (%rax), %eax movl %eax, 0x80(%rsp) movl %r14d, 0x84(%rsp) cmpl %ecx, %esi jle 0xb0867 movl %ecx, 0x7c(%rsp) movl %esi, 0x78(%rsp) movl %esi, %edx jmp 0xb086b movl %ecx, %edx movl %esi, %ecx cmpl %ecx, %eax jle 0xb087c movl %ecx, 0x80(%rsp) movl %eax, 0x7c(%rsp) jmp 0xb087e movl %ecx, %eax cmpl %edx, %eax jle 0xb088a movl %edx, 0x7c(%rsp) movl %eax, 0x78(%rsp) movq %r15, %rdi movq %r12, %rsi callq 0xab8c6 leaq 0x28(%rsp), %rcx cmpq %rcx, %rax jne 0xb0cce movq %r15, %rdi movq %r12, %rsi callq 0xab982 leaq 0x90(%rsp), %rdi callq 0x253e2 incq %rbp movq 0x160(%rbx), %rax movq 0x168(%rbx), %rcx movabsq $0x100000000, %rdx # imm = 0x100000000 addq %rdx, %r13 jmp 0xb07fa xorl %edx, %edx movq %rsp, %r15 leaq 0x50(%rsp), %r12 leaq 0x90(%rsp), %r13 movq 0xe8(%rbx), %rax movq 0xf0(%rbx), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rdx jae 0xb0a39 movslq %edx, %rcx movq (%rax,%rcx,8), %rbp movq 0x100(%rbp), %rax subq 0xf8(%rbp), %rax cmpq $0xc, %rax jne 0xb0a31 movq %rdx, 0x88(%rsp) pxor %xmm0, %xmm0 movdqa %xmm0, 0x50(%rsp) andq $0x0, 0x60(%rsp) movq 0x128(%rbp), %rcx movq %rcx, 0x90(%rsp) leaq 0x118(%rbp), %rdx pushq $-0x1 popq %rax cmpq %rdx, %rcx je 0xb097e movl 0x20(%rcx), %eax jmp 0xb097e movq %r12, %rdi movq %r15, %rsi callq 0x27f56 movq %rbp, %rdi movq %r13, %rsi callq 0xb1f8e movl %eax, (%rsp) cmpl $-0x1, %eax jne 0xb0968 movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi movq %rsi, %rax subq %rdi, %rax cmpq $0xc, %rax jne 0xb0e5d movl 0xf4(%rbp), %r14d callq 0xabb0d movq 0x50(%rsp), %rax movq 0x4(%rax), %xmm0 pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3] movq %xmm0, (%rsp) movl (%rax), %eax movl %eax, 0x8(%rsp) movl %r14d, 0xc(%rsp) leaq 0x20(%rsp), %rdi movq %r15, %rsi callq 0xab8c6 leaq 0x28(%rsp), %rcx cmpq %rcx, %rax jne 0xb0a21 leaq 0x20(%rsp), %rdi movq %r15, %rsi callq 0xab982 movl $0xf8, %edi callq 0x134d0 movq %rax, %rbp movq %rax, %rdi callq 0xac820 movl %r14d, 0x98(%rbp) movq %rbp, %rdi movq %r12, %rsi callq 0x4afc0 movq %rbx, %rdi movq %rbp, %rsi callq 0xae3c0 movq %r12, %rdi callq 0x253e2 movq 0x88(%rsp), %rdx incq %rdx jmp 0xb08f0 leaq 0x20(%rsp), %rdi callq 0xaa15a leaq 0xc0(%rsp), %rdi callq 0x13140 addq $0x238, %rsp # imm = 0x238 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x1efbe(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1eef5(%rip), %rsi # 0xcf996 movq %rax, %rdi callq 0x134b0 movl 0x98(%r13), %esi movq %rax, %rdi callq 0x13920 leaq 0x1eef5(%rip), %rsi # 0xcf9b4 movq %rax, %rdi callq 0x134b0 movq %rax, %rdi movl %ebp, %esi callq 0x13920 leaq 0x19333(%rip), %rsi # 0xc9e0b movq %rax, %rdi callq 0x134b0 leaq 0x20(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x69000(%rip), %rsi # 0x119b20 leaq -0x8d20d(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0ef8 leaq 0x1eeec(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1ee0e(%rip), %rsi # 0xcf981 movq %rax, %rdi callq 0x134b0 movq %rax, %rbx movq %rsp, %rdi leaq 0x50(%rsp), %rsi callq 0x4b4dd movq %rsp, %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1ec5a(%rip), %rsi # 0xcf7f7 movq %rax, %rdi callq 0x134b0 movq %rsp, %rdi callq 0x13a98 leaq 0x20(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68f33(%rip), %rsi # 0x119b20 leaq -0x8d2da(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0ef8 leaq 0x1ee1f(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1ed40(%rip), %rsi # 0xcf980 movq %rax, %rdi callq 0x134b0 movq %rax, %rbx movq %rsp, %rdi leaq 0x50(%rsp), %rsi callq 0x4b4dd movq %rsp, %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1eba4(%rip), %rsi # 0xcf80e movq %rax, %rdi callq 0x134b0 movq %rsp, %rdi callq 0x13a98 leaq 0x20(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68e66(%rip), %rsi # 0x119b20 leaq -0x8d3a7(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0ef8 leaq 0x1ed52(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx movq %rsp, %rdi movq %rbx, %rsi callq 0x13700 movq %rsp, %rsi movq %r14, %rdi callq 0x13450 leaq 0x17f8c(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x1eccb(%rip), %rsi # 0xcf9e3 movq %rax, %rdi callq 0x134b0 movq %rax, %rbx leaq 0x50(%rsp), %rdi leaq 0x90(%rsp), %rsi callq 0x4b4dd leaq 0x50(%rsp), %rsi movq %rbx, %rdi callq 0x13450 leaq 0x1ea68(%rip), %rsi # 0xcf7b1 movq %rax, %rdi callq 0x134b0 leaq 0x50(%rsp), %rdi callq 0x13a98 movq %rsp, %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68d8b(%rip), %rsi # 0x119b20 leaq -0x8d482(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0ef8 leaq 0x1ec77(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1eb63(%rip), %rsi # 0xcf94b movq %rax, %rdi callq 0x134b0 leaq 0x1eb69(%rip), %rsi # 0xcf960 movq %rax, %rdi callq 0x134b0 movq %rax, %rdi movl %ebp, %esi callq 0x13920 leaq 0x20(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68cd7(%rip), %rsi # 0x119b20 leaq -0x8d536(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb0ef8 leaq 0x1ebc3(%rip), %rsi # 0xcfa27 leaq 0xc0(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx movq %rsp, %rdi movq %rbx, %rsi callq 0x13700 movq %rsp, %rsi movq %r14, %rdi callq 0x13450 leaq 0x1f140(%rip), %rsi # 0xcffd8 movq %rax, %rdi callq 0x134b0 leaq 0x1f147(%rip), %rsi # 0xcffee movq %rax, %rdi callq 0x134b0 movq %rsp, %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0xc8(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movb $0x1, %bpl movq %rsp, %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68c37(%rip), %rsi # 0x119b20 leaq -0x8d5d6(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0f10 jmp 0xb1060 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb1060 jmp 0xb0f21 jmp 0xb0f38 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0f3b jmp 0xb1085 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb1085 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0f62 jmp 0xb10ca movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb10ca movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0f87 jmp 0xb10b1 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb10b1 movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x13a98 jmp 0xb103f jmp 0xb103c jmp 0xb0fad movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0xb1030 jmp 0xb102d jmp 0xb102d movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb0fd8 jmp 0xb10a2 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb10a2 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0xb10b1 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0xb10ca jmp 0xb10ae jmp 0xb10c7 movq %rax, %rbx movl $0xf8, %esi movq %rbp, %rdi callq 0x134e0 jmp 0xb10b1 jmp 0xb10ae jmp 0xb102d movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0xb1085 movq %rax, %rbx movq %rsp, %rdi callq 0x13a98 jmp 0xb1060 jmp 0xb10ae jmp 0xb105d jmp 0xb1082 jmp 0xb1082 jmp 0xb10c7 jmp 0xb10ae jmp 0xb10ae jmp 0xb105d jmp 0xb10ae jmp 0xb105d movq %rax, %rbx leaq 0x90(%rsp), %rdi jmp 0xb10b6 movq %rax, %rbx jmp 0xb10bb jmp 0xb10c7 jmp 0xb1075 jmp 0xb10c7 movq %rax, %rbx jmp 0xb10d2 jmp 0xb1082 jmp 0xb1082 jmp 0xb1082 jmp 0xb1082 movq %rax, %rbx leaq 0x50(%rsp), %rdi jmp 0xb10cd jmp 0xb10c7 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0xb10a2 jmp 0xb109f movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x253e2 jmp 0xb10ca movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x253e2 leaq 0x20(%rsp), %rdi callq 0xaa15a jmp 0xb10d2 movq %rax, %rbx movq %rsp, %rdi callq 0x253e2 leaq 0xc0(%rsp), %rdi callq 0x13140 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkCutoffGroups()
void MoleculeStamp::checkCutoffGroups() { std::vector<AtomStamp*>::iterator ai; std::vector<int>::iterator fai; // add all atoms into freeAtoms_ set for (ai = atomStamps_.begin(); ai != atomStamps_.end(); ++ai) { freeAtoms_.push_back((*ai)->getIndex()); } for (std::size_t i = 0; i < getNCutoffGroups(); ++i) { CutoffGroupStamp* cutoffGroupStamp = getCutoffGroupStamp(i); std::vector<int> cutoffGroupAtoms = cutoffGroupStamp->getMembers(); std::vector<int>::iterator j = std::find_if(cutoffGroupAtoms.begin(), cutoffGroupAtoms.end(), std::bind(std::greater<int>(), std::placeholders::_1, getNAtoms() - 1)); if (j != cutoffGroupAtoms.end()) { std::ostringstream oss; oss << "Error in Molecule " << getName() << ": cutoffGroup" << " is out of range\n"; throw OpenMDException(oss.str()); } for (fai = cutoffGroupAtoms.begin(); fai != cutoffGroupAtoms.end(); ++fai) { // erase the atoms belonging to cutoff groups from freeAtoms_ vector freeAtoms_.erase( std::remove(freeAtoms_.begin(), freeAtoms_.end(), (*fai)), freeAtoms_.end()); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1c8, %rsp # imm = 0x1C8 movq %rdi, %rbx movq 0xe8(%rdi), %r12 leaq 0x100(%rdi), %r14 leaq 0x50(%rsp), %r15 cmpq 0xf0(%rbx), %r12 je 0xb13f1 movq (%r12), %rax movl 0xf4(%rax), %eax movl %eax, 0x50(%rsp) movq %r14, %rdi movq %r15, %rsi callq 0x2972c addq $0x8, %r12 jmp 0xb13c9 xorl %ebp, %ebp leaq 0x8(%rsp), %r15 leaq 0x40(%rsp), %r12 movq 0x190(%rbx), %rax movq 0x198(%rbx), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rbp jae 0xb14ae movslq %ebp, %rcx movq (%rax,%rcx,8), %rsi addq $0x68, %rsi movq %r15, %rdi callq 0x2262e movq 0x8(%rsp), %rdi movq 0xf0(%rbx), %rax subq 0xe8(%rbx), %rax movq 0x10(%rsp), %rsi sarq $0x3, %rax decq %rax movq %rax, 0x48(%rsp) movq %r12, %rdx callq 0xa9fb9 cmpq 0x10(%rsp), %rax jne 0xb14c0 movq 0x8(%rsp), %r13 cmpq %rax, %r13 je 0xb149e movq 0x100(%rbx), %rdi movq 0x108(%rbx), %rsi movq %r13, %rdx callq 0xabff1 movq 0x108(%rbx), %rdx movq %r14, %rdi movq %rax, %rsi callq 0x4f070 addq $0x4, %r13 movq 0x10(%rsp), %rax jmp 0xb1466 movq %r15, %rdi callq 0x253e2 incq %rbp jmp 0xb13fd addq $0x1c8, %rsp # imm = 0x1C8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x50(%rsp), %rdi callq 0x136e0 leaq 0x1e556(%rip), %rsi # 0xcfa27 leaq 0x50(%rsp), %rdi callq 0x134b0 movq %rax, %r14 addq $0x98, %rbx leaq 0x20(%rsp), %rdi movq %rbx, %rsi callq 0x13700 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1e4f3(%rip), %rsi # 0xcf9f9 movq %rax, %rdi callq 0x134b0 leaq 0x1e4f2(%rip), %rsi # 0xcfa07 movq %rax, %rdi callq 0x134b0 leaq 0x20(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x58(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x685c6(%rip), %rsi # 0x119b20 leaq -0x8dc47(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb1580 jmp 0xb159e movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb159e movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x13a98 jmp 0xb159e jmp 0xb159b movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x13140 jmp 0xb15b3 jmp 0xb15b0 jmp 0xb15b0 jmp 0xb15b0 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x253e2 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkFragments()
void MoleculeStamp::checkFragments() { std::vector<FragmentStamp*>::iterator fi = std::find(fragmentStamps_.begin(), fragmentStamps_.end(), static_cast<FragmentStamp*>(NULL)); if (fi != fragmentStamps_.end()) { std::ostringstream oss; oss << "Error in Molecule " << getName() << ":fragment[" << fi - fragmentStamps_.begin() << "] is missing\n"; throw OpenMDException(oss.str()); } }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x198, %rsp # imm = 0x198 movq %rdi, %rbx movq 0x1a8(%rdi), %rdi movq 0x1b0(%rbx), %rsi leaq 0x20(%rsp), %rdx andq $0x0, (%rdx) callq 0xb22ff cmpq 0x1b0(%rbx), %rax jne 0xb1609 addq $0x198, %rsp # imm = 0x198 popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x136e0 leaq 0x1e407(%rip), %rsi # 0xcfa27 movq %r15, %rdi callq 0x134b0 movq %rax, %r15 leaq 0x98(%rbx), %rsi movq %rsp, %rdi callq 0x13700 movq %rsp, %rsi movq %r15, %rdi callq 0x13450 leaq 0x1e9c5(%rip), %rsi # 0xd0011 movq %rax, %rdi callq 0x134b0 subq 0x1a8(%rbx), %r14 sarq $0x3, %r14 movq %rax, %rdi movq %r14, %rsi callq 0x13480 leaq 0x1e11b(%rip), %rsi # 0xcf78c movq %rax, %rdi callq 0x134b0 movq %rsp, %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %rbx leaq 0x28(%rsp), %rsi movq %rsp, %rdi callq 0x13800 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x68470(%rip), %rsi # 0x119b20 leaq -0x8dd9d(%rip), %rdx # 0x2391a movq %rbx, %rdi callq 0x13910 movq %rax, %r14 movq %rsp, %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb16d4 jmp 0xb16f2 movq %rax, %r14 movq %rbx, %rdi callq 0x13380 jmp 0xb16f2 jmp 0xb16e0 movq %rax, %r14 movq %rsp, %rdi callq 0x13a98 jmp 0xb16f2 jmp 0xb16ef movq %rax, %r14 leaq 0x20(%rsp), %rdi callq 0x13140 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::checkConstraints()
void MoleculeStamp::checkConstraints() { std::ostringstream oss; // make sure index is not out of range int natoms = getNAtoms(); for (std::size_t i = 0; i < getNConstraints(); ++i) { ConstraintStamp* constraintStamp = getConstraintStamp(i); if (constraintStamp->getA() > natoms - 1 || constraintStamp->getA() < 0 || constraintStamp->getB() > natoms - 1 || constraintStamp->getB() < 0 || constraintStamp->getA() == constraintStamp->getB()) { oss << "Error in Molecule " << getName() << ": constraint(" << constraintStamp->getA() << ", " << constraintStamp->getB() << ") is invalid\n"; throw OpenMDException(oss.str()); } } // make sure constraints are unique std::set<std::pair<int, int>> allConstraints; for (std::size_t i = 0; i < getNConstraints(); ++i) { ConstraintStamp* constraintStamp = getConstraintStamp(i); std::pair<int, int> constraintPair(constraintStamp->getA(), constraintStamp->getB()); // make sure constraintPair.first is always less than or equal to // constraintPair.third if (constraintPair.first > constraintPair.second) { std::swap(constraintPair.first, constraintPair.second); } std::set<std::pair<int, int>>::iterator iter = allConstraints.find(constraintPair); if (iter != allConstraints.end()) { oss << "Error in Molecule " << getName() << ": " << "constraint(" << iter->first << ", " << iter->second << ") appears multiple times\n"; throw OpenMDException(oss.str()); } else { allConstraints.insert(constraintPair); } } // make sure atoms belong to same rigidbody are not constrained to // each other for (std::size_t i = 0; i < getNConstraints(); ++i) { ConstraintStamp* constraintStamp = getConstraintStamp(i); if (atom2Rigidbody[constraintStamp->getA()] == atom2Rigidbody[constraintStamp->getB()]) { oss << "Error in Molecule " << getName() << ": " << "constraint(" << constraintStamp->getA() << ", " << constraintStamp->getB() << ") belong to same rigidbody " << atom2Rigidbody[constraintStamp->getA()] << "\n"; throw OpenMDException(oss.str()); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1d8, %rsp # imm = 0x1D8 movq %rdi, %rbx movabsq $0x100000000, %r13 # imm = 0x100000000 leaq 0x60(%rsp), %rdi callq 0x136e0 movq 0xf0(%rbx), %rdx subq 0xe8(%rbx), %rdx movq 0x1c0(%rbx), %rax shrq $0x3, %rdx movq %rbx, (%rsp) movq 0x1c8(%rbx), %rcx movq %rcx, %rsi subq %rax, %rsi sarq $0x3, %rsi incq %rsi xorl %edi, %edi decq %rsi je 0xb186f movq %rdi, %r8 sarq $0x1d, %r8 movq (%rax,%r8), %r15 movl 0xd0(%r15), %r9d cmpl %edx, %r9d jge 0xb179d testl %r9d, %r9d js 0xb179d movl 0xd4(%r15), %r8d cmpl %r8d, %r9d je 0xb179d cmpl %edx, %r8d jge 0xb179d addq %r13, %rdi testl %r8d, %r8d jns 0xb175f leaq 0x1e283(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r14 movq (%rsp), %rsi addq $0x98, %rsi leaq 0x30(%rsp), %rdi callq 0x13700 leaq 0x30(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x1e23f(%rip), %rsi # 0xcfa19 movq %rax, %rdi callq 0x134b0 movl 0xd0(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x16e9c(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0xd4(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x1df8c(%rip), %rsi # 0xcf7a2 movq %rax, %rdi callq 0x134b0 leaq 0x30(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x30(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x30(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x682c5(%rip), %rsi # 0x119b20 leaq -0x8df48(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb1b58 leaq 0x38(%rsp), %rdx andl $0x0, (%rdx) andq $0x0, 0x8(%rdx) movq %rdx, 0x10(%rdx) movq %rdx, 0x18(%rdx) andq $0x0, 0x20(%rdx) xorl %ebp, %ebp leaq 0x30(%rsp), %r15 leaq 0x8(%rsp), %r12 xorl %ebx, %ebx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %rbx jae 0xb190f movq %rbp, %rcx sarq $0x1d, %rcx movq (%rax,%rcx), %rcx movl 0xd0(%rcx), %eax movl 0xd4(%rcx), %ecx movl %eax, 0x8(%rsp) movl %ecx, 0xc(%rsp) cmpl %ecx, %eax jle 0xb18ce movl %ecx, 0x8(%rsp) movl %eax, 0xc(%rsp) movq %r15, %rdi movq %r12, %rsi callq 0x617bc movq %rax, %r14 leaq 0x38(%rsp), %rax cmpq %rax, %r14 jne 0xb1a82 movq %r15, %rdi movq %r12, %rsi callq 0xab2bc incq %rbx movq (%rsp), %rcx movq 0x1c0(%rcx), %rax movq 0x1c8(%rcx), %rcx addq %r13, %rbp jmp 0xb1897 movq (%rsp), %rdx movq 0x1d8(%rdx), %rdx incq %rcx xorl %esi, %esi decq %rcx je 0xb1a5c leaq (%rsi,%r13), %rdi sarq $0x1d, %rsi movq (%rax,%rsi), %r15 movslq 0xd0(%r15), %rsi movl (%rdx,%rsi,4), %r8d movslq 0xd4(%r15), %r9 movq %rdi, %rsi cmpl (%rdx,%r9,4), %r8d jne 0xb191f leaq 0x1e0d1(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r14 movq (%rsp), %rax leaq 0x98(%rax), %rsi leaq 0x10(%rsp), %rdi callq 0x13700 leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x13450 leaq 0x17309(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x1e080(%rip), %rsi # 0xcfa1b movq %rax, %rdi callq 0x134b0 movl 0xd0(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x16cdb(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0xd4(%r15), %esi movq %rax, %rdi callq 0x13920 leaq 0x1ddf3(%rip), %rsi # 0xcf7ca movq %rax, %rdi callq 0x134b0 movslq 0xd0(%r15), %rcx movq (%rsp), %rdx movq 0x1d8(%rdx), %rdx movl (%rdx,%rcx,4), %esi movq %rax, %rdi callq 0x13920 leaq 0x18408(%rip), %rsi # 0xc9e0b movq %rax, %rdi callq 0x134b0 leaq 0x10(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x680d8(%rip), %rsi # 0x119b20 leaq -0x8e135(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb1b58 leaq 0x30(%rsp), %rdi callq 0x2838c leaq 0x60(%rsp), %rdi callq 0x13140 addq $0x1d8, %rsp # imm = 0x1D8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x1df9e(%rip), %rsi # 0xcfa27 leaq 0x60(%rsp), %rdi callq 0x134b0 movq %rax, %r15 movq (%rsp), %rsi addq $0x98, %rsi leaq 0x10(%rsp), %rdi callq 0x13700 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0x13450 leaq 0x171d6(%rip), %rsi # 0xc8c95 movq %rax, %rdi callq 0x134b0 leaq 0x1df4d(%rip), %rsi # 0xcfa1b movq %rax, %rdi callq 0x134b0 movl 0x20(%r14), %esi movq %rax, %rdi callq 0x13920 leaq 0x16bab(%rip), %rsi # 0xc8694 movq %rax, %rdi callq 0x134b0 movl 0x24(%r14), %esi movq %rax, %rdi callq 0x13920 leaq 0x1dcac(%rip), %rsi # 0xcf7b0 movq %rax, %rdi callq 0x134b0 leaq 0x10(%rsp), %rdi callq 0x13a98 pushq $0x28 popq %rdi callq 0x13260 movq %rax, %r14 leaq 0x68(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x13800 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x238e4 xorl %ebp, %ebp leaq 0x67fd7(%rip), %rsi # 0x119b20 leaq -0x8e236(%rip), %rdx # 0x2391a movq %r14, %rdi callq 0x13910 jmp 0xb1b5c jmp 0xb1b70 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb1b73 jmp 0xb1bd0 movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb1bd0 movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 testb %bpl, %bpl jne 0xb1b94 jmp 0xb1bda movq %rax, %rbx movq %r14, %rdi callq 0x13380 jmp 0xb1bda jmp 0xb1ba0 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 jmp 0xb1bd0 jmp 0xb1bcd jmp 0xb1bcd movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0xb1bda jmp 0xb1bcd jmp 0xb1bcd jmp 0xb1bc8 movq %rax, %rbx jmp 0xb1bda movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x2838c leaq 0x60(%rsp), %rdi callq 0x13140 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::isBondInSameRigidBody(OpenMD::BondStamp*)
bool MoleculeStamp::isBondInSameRigidBody(BondStamp* bond) { int rbA; int rbB; int consAtomA; int consAtomB; if (!isAtomInRigidBody(bond->getA(), rbA, consAtomA)) return false; if (!isAtomInRigidBody(bond->getB(), rbB, consAtomB)) return false; if (rbB == rbA) return true; else return false; }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %rbx movl 0xa0(%rsi), %esi leaq 0xc(%rsp), %rdx leaq 0x14(%rsp), %rcx callq 0xb1c46 testb %al, %al je 0xb1c3c movl 0xa4(%r14), %esi leaq 0x8(%rsp), %rdx leaq 0x10(%rsp), %rcx movq %rbx, %rdi callq 0xb1c46 testb %al, %al je 0xb1c3c movl 0x8(%rsp), %eax cmpl 0xc(%rsp), %eax sete %al jmp 0xb1c3e xorl %eax, %eax addq $0x18, %rsp popq %rbx popq %r14 retq
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
OpenMD::MoleculeStamp::isAtomInRigidBody(int, int&, int&)
bool MoleculeStamp::isAtomInRigidBody(int atomIndex, int& whichRigidBody, int& consAtomIndex) { whichRigidBody = -1; consAtomIndex = -1; if (atom2Rigidbody[atomIndex] >= 0) { whichRigidBody = atom2Rigidbody[atomIndex]; RigidBodyStamp* rbStamp = getRigidBodyStamp(whichRigidBody); int numAtom = rbStamp->getNMembers(); for (int j = 0; j < numAtom; j++) { if (rbStamp->getMemberAt(j) == atomIndex) { consAtomIndex = j; return true; } } } return false; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rcx, %r14 orl $-0x1, (%rdx) orl $-0x1, (%rcx) movslq %esi, %rax movq 0x1d8(%rdi), %rcx movslq (%rcx,%rax,4), %rax xorl %ebx, %ebx testq %rax, %rax js 0xb1cae movl %esi, %ebp movl %eax, (%rdx) movq 0x178(%rdi), %rcx movq (%rcx,%rax,8), %r15 movq 0x78(%r15), %r12 subq 0x70(%r15), %r12 shrq $0x2, %r12 testl %r12d, %r12d cmovlel %ebx, %r12d cmpl %ebx, %r12d je 0xb1ca5 movq %r15, %rdi movl %ebx, %esi callq 0x605e4 cmpl %ebp, %eax je 0xb1ca9 incl %ebx jmp 0xb1c8e xorl %ebx, %ebx jmp 0xb1cae movl %ebx, (%r14) movb $0x1, %bl movl %ebx, %eax popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.cpp
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>, OpenMD::AtomStamp>(std::vector<OpenMD::AtomStamp*, std::allocator<OpenMD::AtomStamp*>>&, OpenMD::AtomStamp*)
bool addIndexSensitiveStamp(Cont& cont, T* stamp) { // typename Cont::iterator i; unsigned int index = stamp->getIndex(); bool ret = false; size_t size = cont.size(); if (size >= index + 1) { if (cont[index] != NULL) { ret = false; } else { cont[index] = stamp; ret = true; } } else { cont.insert(cont.end(), index - cont.size() + 1, NULL); cont[index] = stamp; ret = true; } return ret; }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rsi, %r14 movl 0xf4(%rdx), %r15d movq (%rsi), %rax movq 0x8(%rsi), %rsi movq %rsi, %rcx subq %rax, %rcx sarq $0x3, %rcx leal 0x1(%r15), %edx cmpq %rdx, %rcx jae 0xb1e3c negq %rcx leaq (%r15,%rcx), %rdx incq %rdx leaq 0x8(%rsp), %rcx andq $0x0, (%rcx) movq %r14, %rdi callq 0xaa41c shlq $0x3, %r15 addq (%r14), %r15 jmp 0xb1e4b cmpq $0x0, (%rax,%r15,8) je 0xb1e47 xorl %eax, %eax jmp 0xb1e50 leaq (%rax,%r15,8), %r15 movq %rbx, (%r15) movb $0x1, %al addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq
/OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp
bool OpenMD::MoleculeStamp::addIndexSensitiveStamp<std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>, OpenMD::RigidBodyStamp>(std::vector<OpenMD::RigidBodyStamp*, std::allocator<OpenMD::RigidBodyStamp*>>&, OpenMD::RigidBodyStamp*)
bool addIndexSensitiveStamp(Cont& cont, T* stamp) { // typename Cont::iterator i; unsigned int index = stamp->getIndex(); bool ret = false; size_t size = cont.size(); if (size >= index + 1) { if (cont[index] != NULL) { ret = false; } else { cont[index] = stamp; ret = true; } } else { cont.insert(cont.end(), index - cont.size() + 1, NULL); cont[index] = stamp; ret = true; } return ret; }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rsi, %r14 movl 0x68(%rdx), %r15d movq (%rsi), %rax movq 0x8(%rsi), %rsi movq %rsi, %rcx subq %rax, %rcx sarq $0x3, %rcx leal 0x1(%r15), %edx cmpq %rdx, %rcx jae 0xb1eab negq %rcx leaq (%r15,%rcx), %rdx incq %rdx leaq 0x8(%rsp), %rcx andq $0x0, (%rcx) movq %r14, %rdi callq 0xaabc8 shlq $0x3, %r15 addq (%r14), %r15 jmp 0xb1eba cmpq $0x0, (%rax,%r15,8) je 0xb1eb6 xorl %eax, %eax jmp 0xb1ebf leaq (%rax,%r15,8), %r15 movq %rbx, (%r15) movb $0x1, %al addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq nop
/OpenMD[P]OpenMD/src/types/MoleculeStamp.hpp
OpenMD::TorsionStamp::setMembers(std::tuple<int, int, int, int> const&)
void setMembers(const std::tuple<int, int, int, int>& tuple) { auto [first, second, third, fourth] = tuple; members_.push_back(first); members_.push_back(second); members_.push_back(third); members_.push_back(fourth); }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movups (%rsi), %xmm0 leaq 0xc(%rsp), %rsi movaps %xmm0, -0xc(%rsi) leaq 0x8(%rsp), %r14 leaq 0x4(%rsp), %r15 addq $0x98, %rbx movq %rbx, %rdi callq 0x27f56 movq %rbx, %rdi movq %r14, %rsi callq 0x27f56 movq %rbx, %rdi movq %r15, %rsi callq 0x27f56 movq %rsp, %rsi movq %rbx, %rdi callq 0x27f56 addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq
/OpenMD[P]OpenMD/src/types/TorsionStamp.hpp
OpenMD::MultipoleAdapter::getMultipoleParam()
MultipoleAtypeParameters MultipoleAdapter::getMultipoleParam() { if (!isMultipole()) { snprintf( painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "MultipoleAdapter::getMultipoleParam was passed an atomType (%s)\n" "\tthat does not appear to be a Multipole atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(MultipoleTypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "MultipoleAdapter::getMultipoleParam could not find Multipole\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<MultipoleAtypeData> multipoleData = std::dynamic_pointer_cast<MultipoleAtypeData>(data); if (multipoleData == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "MultipoleAdapter::getMultipoleParam could not convert\n" "\tGenericData to MultipoleAtypeData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return multipoleData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xb238c movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xb240a movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x6ccc5(%rip), %r12 # 0x11f0a4 leaq 0x1dc4f(%rip), %rdx # 0xd0035 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x71414(%rip), %rdx # 0x123828 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xb246e movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x6cc61(%rip), %r12 # 0x11f0a4 leaq 0x1dc5a(%rip), %rdx # 0xd00a4 movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xb26d3 movq (%r15), %rsi testq %rsi, %rsi jne 0xb24d0 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x6cc02(%rip), %r15 # 0x11f0a4 leaq 0x1dc56(%rip), %rdx # 0xd00ff movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0xb2728 leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xb2505 jmp 0xb250a movq %rax, %rbx jmp 0xb2517 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/MultipoleAdapter.cpp
OpenMD::MultipoleAdapter::makeMultipole(OpenMD::Vector3<double>, OpenMD::SquareMatrix3<double>, bool, bool)
void MultipoleAdapter::makeMultipole(Vector3d dipole, Mat3x3d quadrupole, bool isDipole, bool isQuadrupole) { if (isMultipole()) { at_->removeProperty(MultipoleTypeID); } MultipoleAtypeParameters multipoleParam {}; multipoleParam.dipole = dipole; multipoleParam.quadrupole = quadrupole; multipoleParam.isDipole = isDipole; multipoleParam.isQuadrupole = isQuadrupole; at_->addProperty( std::make_shared<MultipoleAtypeData>(MultipoleTypeID, multipoleParam)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movl %r8d, 0xc(%rsp) movl %ecx, %ebp movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 callq 0xb238c testb %al, %al je 0xb2615 movq (%r14), %rdi leaq 0x71218(%rip), %rsi # 0x123828 callq 0x9c8dc leaq 0x38(%rsp), %r13 andw $0x0, -0x8(%r13) movq %r13, %rdi callq 0x1b928 leaq 0x50(%rsp), %rbx movq %rbx, %rdi callq 0x1e636 movq %r13, %rdi movq %r12, %rsi callq 0x1aff0 movq %rbx, %rdi movq %r15, %rsi callq 0x1e688 movb %bpl, -0x20(%rbx) movl 0xc(%rsp), %eax movb %al, -0x1f(%rbx) movq (%r14), %r15 leaq 0x711c8(%rip), %rsi # 0x123828 leaq 0x10(%rsp), %rdi leaq 0x30(%rsp), %rdx callq 0xb275f leaq 0x28(%rsp), %r14 leaq 0x18(%rsp), %rbx movaps -0x8(%rbx), %xmm0 movaps %xmm0, -0x8(%r14) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%rbx) leaq 0x20(%rsp), %rsi movq %r15, %rdi callq 0x9c83e movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 addq $0x98, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r15 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/MultipoleAdapter.cpp
OpenMD::QuarticTorsionType::calcForce(double, double&, double&)
virtual void calcForce(RealType cosPhi, RealType& V, RealType& dVdcosPhi) { RealType cosPhi2 = cosPhi * cosPhi; RealType cosPhi3 = cosPhi2 * cosPhi; RealType cosPhi4 = cosPhi3 * cosPhi; V = k0_ + k1_ * cosPhi + k2_ * cosPhi2 + k3_ * cosPhi3 + k4_ * cosPhi4; dVdcosPhi = k1_ + 2.0 * k2_ * cosPhi + 3.0 * k3_ * cosPhi2 + 4.0 * k4_ * cosPhi3; }
movapd %xmm0, %xmm2 mulsd %xmm0, %xmm2 movapd %xmm2, %xmm1 mulsd %xmm0, %xmm1 movapd %xmm1, %xmm3 movsd 0x20(%rdi), %xmm4 mulsd %xmm0, %xmm4 addsd 0x28(%rdi), %xmm4 mulsd %xmm0, %xmm3 movsd 0x18(%rdi), %xmm5 mulsd %xmm2, %xmm5 addsd %xmm4, %xmm5 movsd 0x10(%rdi), %xmm4 mulsd %xmm1, %xmm4 mulsd 0x8(%rdi), %xmm3 addsd %xmm5, %xmm4 addsd %xmm4, %xmm3 movsd %xmm3, (%rsi) movsd 0x18(%rdi), %xmm3 addsd %xmm3, %xmm3 mulsd %xmm0, %xmm3 addsd 0x20(%rdi), %xmm3 movsd 0x10(%rdi), %xmm0 mulsd 0x12182(%rip), %xmm0 # 0xc87d8 movsd 0x8(%rdi), %xmm4 mulsd %xmm2, %xmm0 mulsd 0x180e1(%rip), %xmm4 # 0xce748 addsd %xmm3, %xmm0 mulsd %xmm1, %xmm4 addsd %xmm0, %xmm4 movsd %xmm4, (%rdx) retq
/OpenMD[P]OpenMD/src/types/QuarticTorsionType.hpp
OpenMD::OplsTorsionType::~OplsTorsionType()
OplsTorsionType(RealType v1, RealType v2, RealType v3, bool trans180) : PolynomialTorsionType(), v1_(v1), v2_(v2), v3_(v3) { // convert OPLS Torsion Type to Polynomial Torsion type RealType c0 = v2 + 0.5 * (v1 + v3); RealType c1 = 0.5 * (v1 - 3.0 * v3); RealType c2 = -v2; RealType c3 = 2.0 * v3; if (!trans180) { c1 = -c1; c3 = -c3; } setCoefficient(0, c0); setCoefficient(1, c1); setCoefficient(2, c2); setCoefficient(3, c3); }
pushq %rbx movq %rdi, %rbx callq 0xb66ee pushq $0x50 popq %rsi movq %rbx, %rdi popq %rbx jmp 0x134e0 nop
/OpenMD[P]OpenMD/src/types/OplsTorsionType.hpp
OpenMD::HarmonicTorsionType::calcForce(double, double&, double&)
virtual void calcForce(RealType cosPhi, RealType& V, RealType& dVdCosPhi) { // check roundoff if (cosPhi > 1.0) { cosPhi = 1.0; } else if (cosPhi < -1.0) { cosPhi = -1.0; } RealType phi = acos(cosPhi); RealType sinPhi = sqrt(1.0 - cosPhi * cosPhi); // trick to avoid divergence in angles near 0 and pi: if (fabs(sinPhi) < 1.0E-6) { sinPhi = copysign(1.0E-6, sinPhi); } V = 0.5 * d0_ * pow((phi - phi0_), 2); dVdCosPhi = -d0_ * (phi - phi0_) / sinPhi; }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 movsd 0xe8e4(%rip), %xmm2 # 0xc5020 ucomisd %xmm2, %xmm0 ja 0xb6758 movsd 0x1041e(%rip), %xmm1 # 0xc6b68 ucomisd %xmm0, %xmm1 movapd %xmm0, %xmm2 jbe 0xb6758 movapd %xmm1, %xmm2 movsd %xmm2, 0x8(%rsp) movapd %xmm2, %xmm0 callq 0x13490 movapd %xmm0, %xmm4 movsd 0x8(%rsp), %xmm1 mulsd %xmm1, %xmm1 movsd 0xe8a3(%rip), %xmm0 # 0xc5020 subsd %xmm1, %xmm0 xorpd %xmm1, %xmm1 ucomisd %xmm1, %xmm0 jb 0xb6791 sqrtsd %xmm0, %xmm0 jmp 0xb67a2 movsd %xmm4, 0x8(%rsp) callq 0x133d0 movsd 0x8(%rsp), %xmm4 movapd 0x103a6(%rip), %xmm1 # 0xc6b50 andpd %xmm0, %xmm1 movapd 0x1038a(%rip), %xmm2 # 0xc6b40 movapd %xmm0, %xmm3 andpd %xmm2, %xmm3 orpd 0x1a17a(%rip), %xmm3 # 0xd0940 cmpltsd 0x10391(%rip), %xmm1 # 0xc6b60 andpd %xmm1, %xmm3 andnpd %xmm0, %xmm1 orpd %xmm3, %xmm1 movsd 0x8(%r14), %xmm0 mulsd 0x11fc7(%rip), %xmm0 # 0xc87b0 movapd %xmm4, %xmm3 subsd 0x10(%r14), %xmm3 mulsd %xmm3, %xmm3 mulsd %xmm0, %xmm3 movsd %xmm3, (%r15) movsd 0x8(%r14), %xmm0 subsd 0x10(%r14), %xmm4 xorpd %xmm2, %xmm0 mulsd %xmm0, %xmm4 divsd %xmm1, %xmm4 movsd %xmm4, (%rbx) addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq
/OpenMD[P]OpenMD/src/types/HarmonicTorsionType.hpp
OpenMD::UFFAdapter::getUFFParam()
UFFAtypeParameters UFFAdapter::getUFFParam() { if (!isUFF()) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "UFFAdapter::getUFFParam was passed an atomType (%s)\n" "\tthat does not appear to be a UFF atom.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<GenericData> data = at_->getPropertyByName(UFFtypeID); if (data == nullptr) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "UFFAdapter::getUFFParam could not find UFF\n" "\tparameters for atomType %s.\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } std::shared_ptr<UFFAtypeData> uffData = std::dynamic_pointer_cast<UFFAtypeData>(data); if (uffData == NULL) { snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "UFFAdapter::getUFFParam could not convert\n" "\tGenericData to UFFAtypeData for atom type %s\n", at_->getName().c_str()); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } return uffData->getData(); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0xb6db0 movabsq $0x100000001, %r13 # imm = 0x100000001 testb %al, %al jne 0xb6e2e movq (%r14), %rsi leaq 0x20(%rsp), %r15 movq %r15, %rdi callq 0x9caa0 movq (%r15), %rcx leaq 0x682a1(%rip), %r12 # 0x11f0a4 leaq 0x19d25(%rip), %rdx # 0xd0b2f movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq (%r14), %rsi leaq 0x6cc40(%rip), %rdx # 0x123a78 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x9c964 cmpq $0x0, (%r15) jne 0xb6e92 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r15 movq (%r15), %rcx leaq 0x6823d(%rip), %r12 # 0x11f0a4 leaq 0x19d1e(%rip), %rdx # 0xd0b8c movl $0x7d0, %esi # imm = 0x7D0 movq %r12, %rdi xorl %eax, %eax callq 0x13830 movq %r15, %rdi callq 0x13a98 movq %r13, 0x7d0(%r12) callq 0x2beaa movq %rsp, %r15 leaq 0x10(%rsp), %rsi movq %r15, %rdi callq 0xb71fc movq (%r15), %rsi testq %rsi, %rsi jne 0xb6ef4 movq (%r14), %rsi leaq 0x20(%rsp), %rdi callq 0x9caa0 leaq 0x20(%rsp), %r14 movq (%r14), %rcx leaq 0x681de(%rip), %r15 # 0x11f0a4 leaq 0x19d08(%rip), %rdx # 0xd0bd5 movl $0x7d0, %esi # imm = 0x7D0 movq %r15, %rdi xorl %eax, %eax callq 0x13830 movq %r14, %rdi callq 0x13a98 movq %r13, 0x7d0(%r15) callq 0x2beaa movq (%rsp), %rsi addq $0x28, %rsi pushq $0xb popq %rcx movq %rbx, %rdi rep movsq (%rsi), %es:(%rdi) leaq 0x8(%rsp), %rdi callq 0x28296 leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0xb6f2a jmp 0xb6f39 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x28296 jmp 0xb6f3c movq %rax, %rbx leaq 0x18(%rsp), %rdi callq 0x28296 movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/UFFAdapter.cpp
OpenMD::UFFAdapter::makeUFF(double, double, double, double, double, double, double, double, double, double, double)
void UFFAdapter::makeUFF(RealType r1, RealType theta0, RealType x1, RealType D1, RealType zeta, RealType Z1, RealType Vi, RealType Uj, RealType Xi, RealType Hard, RealType Radius) { if (isUFF()) { at_->removeProperty(UFFtypeID); } UFFAtypeParameters uffParam {}; uffParam.r1 = r1; uffParam.theta0 = theta0; uffParam.x1 = x1; uffParam.D1 = D1; uffParam.zeta = zeta; uffParam.Z1 = Z1; uffParam.Vi = Vi; uffParam.Uj = Uj; uffParam.Xi = Xi; uffParam.Hard = Hard; uffParam.Radius = Radius; at_->addProperty(std::make_shared<UFFAtypeData>(UFFtypeID, uffParam)); }
pushq %r15 pushq %r14 pushq %rbx subq $0xc0, %rsp movsd %xmm7, 0x38(%rsp) movsd %xmm6, 0x30(%rsp) movsd %xmm5, 0x28(%rsp) movsd %xmm4, 0x20(%rsp) movsd %xmm3, 0x18(%rsp) movsd %xmm2, 0x10(%rsp) movsd %xmm1, 0x8(%rsp) movsd %xmm0, (%rsp) movq %rdi, %rbx callq 0xb6db0 testb %al, %al je 0xb7104 movq (%rbx), %rdi leaq 0x6c979(%rip), %rsi # 0x123a78 callq 0x9c8dc leaq 0x68(%rsp), %rdx movsd (%rsp), %xmm0 movsd %xmm0, (%rdx) movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x8(%rdx) movsd 0x10(%rsp), %xmm0 movsd %xmm0, 0x10(%rdx) movsd 0x18(%rsp), %xmm0 movsd %xmm0, 0x18(%rdx) movsd 0x20(%rsp), %xmm0 movsd %xmm0, 0x20(%rdx) movsd 0x28(%rsp), %xmm0 movsd %xmm0, 0x28(%rdx) movsd 0x30(%rsp), %xmm0 movsd %xmm0, 0x30(%rdx) movsd 0x38(%rsp), %xmm0 movsd %xmm0, 0x38(%rdx) movsd 0xe0(%rsp), %xmm0 movsd %xmm0, 0x40(%rdx) movsd 0xe8(%rsp), %xmm0 movsd %xmm0, 0x48(%rdx) movsd 0xf0(%rsp), %xmm0 movsd %xmm0, 0x50(%rdx) movq (%rbx), %r15 leaq 0x6c8e5(%rip), %rsi # 0x123a78 leaq 0x40(%rsp), %rdi callq 0xb7251 leaq 0x58(%rsp), %r14 leaq 0x48(%rsp), %rbx movaps -0x8(%rbx), %xmm0 movaps %xmm0, -0x8(%r14) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%rbx) leaq 0x50(%rsp), %rsi movq %r15, %rdi callq 0x9c83e movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 addq $0xc0, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %r15 movq %r14, %rdi callq 0x28296 movq %rbx, %rdi callq 0x28296 movq %r15, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/types/UFFAdapter.cpp
OpenMD::ZConsStamp::ZConsStamp()
ZConsStamp::ZConsStamp() { DefineParameter(MolIndex, "molIndex"); DefineOptionalParameter(Zpos, "zPos"); DefineOptionalParameter(Kratio, "kRatio"); DefineOptionalParameter(CantVel, "cantVel"); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx callq 0x4b318 leaq 0x66513(%rip), %rax # 0x11d978 movq %rax, (%rbx) leaq 0x80(%rbx), %rax movq %rax, 0x70(%rbx) andq $0x0, 0x78(%rbx) leaq 0x68(%rbx), %rax movq %rax, 0x60(%rsp) xorl %eax, %eax movb %al, 0x80(%rbx) andw $0x0, 0x90(%rbx) movb $0x1, %cl movb %cl, 0x92(%rbx) leaq 0x64300(%rip), %rdx # 0x11b7a0 movq %rdx, 0x68(%rbx) leaq 0xb0(%rbx), %rdx movq %rdx, 0xa0(%rbx) andq $0x0, 0xa8(%rbx) movb %al, 0xb0(%rbx) andw $0x0, 0xc0(%rbx) movb %cl, 0xc2(%rbx) leaq 0x64253(%rip), %rdx # 0x11b728 movq %rdx, 0x98(%rbx) leaq 0xe8(%rbx), %rsi movq %rsi, 0xd8(%rbx) andq $0x0, 0xe0(%rbx) movb %al, 0xe8(%rbx) andw $0x0, 0xf8(%rbx) leaq 0x98(%rbx), %rsi movq %rsi, 0x58(%rsp) movb %cl, 0xfa(%rbx) movq %rdx, 0xd0(%rbx) leaq 0x120(%rbx), %rsi movq %rsi, 0x110(%rbx) andq $0x0, 0x118(%rbx) movb %al, 0x120(%rbx) andw $0x0, 0x130(%rbx) leaq 0xd0(%rbx), %r12 leaq 0x108(%rbx), %r13 movb %cl, 0x132(%rbx) movq %rdx, 0x108(%rbx) leaq 0x18ee6(%rip), %rsi # 0xd0445 leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0x70(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x18eb8(%rip), %rsi # 0xd0445 leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 leaq 0x8(%rbx), %rbp leaq 0x40(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x20(%rsp), %r14 movq -0x10(%r14), %rax cmpq %r14, %rax je 0xb75c8 movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xb75d0 movups (%r14), %xmm0 movups %xmm0, (%r15) movq 0x18(%rsp), %rax movq %r14, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq 0x60(%rsp), %rax movq %rax, 0x20(%rsi) movq %rbp, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x196be(%rip), %rsi # 0xd0cd8 leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0xa0(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 movb $0x1, 0xc0(%rbx) leaq 0x19686(%rip), %rsi # 0xd0cd8 leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 movq %r15, 0x30(%rsp) movq 0x10(%rsp), %rax cmpq %r14, %rax je 0xb7681 movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xb7689 movups (%r14), %xmm0 movups %xmm0, (%r15) movq 0x18(%rsp), %rax movq %r14, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq 0x58(%rsp), %rax movq %rax, 0x20(%rsi) movq %rbp, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x1960a(%rip), %rsi # 0xd0cdd leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0xd8(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 movb $0x1, 0xf8(%rbx) leaq 0x195d2(%rip), %rsi # 0xd0cdd leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 movq %r15, 0x30(%rsp) movq 0x10(%rsp), %rax cmpq %r14, %rax je 0xb773a movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xb7742 movups (%r14), %xmm0 movups %xmm0, (%r15) movq 0x18(%rsp), %rax movq %r14, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq %r12, 0x20(%rsi) movq %rbp, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 leaq 0x1955d(%rip), %rsi # 0xd0ce4 leaq 0x30(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1a8b4 leaq 0x110(%rbx), %rdi leaq 0x30(%rsp), %rsi callq 0x13280 leaq 0x30(%rsp), %rdi callq 0x13a98 movb $0x1, 0x130(%rbx) leaq 0x19525(%rip), %rsi # 0xd0ce4 leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 movq %r15, 0x30(%rsp) movq 0x10(%rsp), %rax cmpq %r14, %rax je 0xb77ee movq %rax, 0x30(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x40(%rsp) jmp 0xb77f6 movups (%r14), %xmm0 movups %xmm0, (%r15) movq 0x18(%rsp), %rax movq %r14, 0x10(%rsp) andq $0x0, 0x18(%rsp) leaq 0x30(%rsp), %rsi movq %rax, 0x8(%rsi) movb $0x0, 0x20(%rsp) movq %r13, 0x20(%rsi) movq %rbp, %rdi callq 0x7144c leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi callq 0x13a98 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0xb785b jmp 0xb7880 jmp 0xb7871 jmp 0xb7880 jmp 0xb785b jmp 0xb7880 jmp 0xb7871 jmp 0xb7880 jmp 0xb785b jmp 0xb7880 jmp 0xb7871 jmp 0xb7880 movq %rax, %rbp leaq 0x30(%rsp), %rdi callq 0x13a98 leaq 0x10(%rsp), %rdi jmp 0xb7879 jmp 0xb7880 movq %rax, %rbp leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0xb7883 movq %rax, %rbp movq %r13, %rdi callq 0x5939c movq %r12, %rdi callq 0x5939c movq 0x58(%rsp), %rdi callq 0x5939c movq 0x60(%rsp), %rdi callq 0x5939c movq %rbx, %rdi callq 0x4b358 movq %rbp, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/types/ZconsStamp.cpp
OpenMD::ElementsTable::~ElementsTable()
ElementsTable::~ElementsTable() { std::vector<Element*>::iterator i; for (i = elements_.begin(); i != elements_.end(); ++i) delete *i; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x88(%rdi), %r14 movq 0x88(%rdi), %r12 cmpq 0x90(%rbx), %r12 je 0xb7a7e movq (%r12), %r15 testq %r15, %r15 je 0xb7a6b movq %r15, %rdi callq 0xb85c6 movl $0xa0, %esi movq %r15, %rdi callq 0x134e0 addq $0x8, %r12 jmp 0xb7a51 movq %r14, %rdi callq 0xb87c0 leaq 0x68(%rbx), %rdi callq 0x13a98 leaq 0x48(%rbx), %rdi callq 0x13a98 leaq 0x28(%rbx), %rdi callq 0x13a98 addq $0x8, %rbx movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x13a98
/OpenMD[P]OpenMD/src/utils/ElementsTable.cpp
OpenMD::ElementsTable::GetName[abi:cxx11](int)
std::string ElementsTable::GetName(int atomicnum) { if (!init_) Init(); if (atomicnum < 0 || atomicnum >= static_cast<int>(elements_.size())) return ("Unknown"); return (elements_[atomicnum]->GetName()); }
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx cmpb $0x0, (%rsi) jne 0xb8215 movq %r14, %rdi callq 0xb7d28 testl %ebp, %ebp js 0xb8246 movq 0x88(%r14), %rax movq 0x90(%r14), %rcx subq %rax, %rcx shrq $0x3, %rcx cmpl %ebp, %ecx jle 0xb8246 movl %ebp, %ecx movq (%rax,%rcx,8), %rsi addq $0x28, %rsi movq %rbx, %rdi callq 0x13700 jmp 0xb825a leaq 0x18b0f(%rip), %rsi # 0xd0d5c leaq 0xf(%rsp), %rdx movq %rbx, %rdi callq 0x1a8b4 movq %rbx, %rax addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq
/OpenMD[P]OpenMD/src/utils/ElementsTable.cpp
OpenMD::PropertyMap::removeProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool PropertyMap::removeProperty(const std::string& propName) { std::map<std::string, std::shared_ptr<GenericData>>::iterator iter; iter = propMap_.find(propName); if (iter != propMap_.end()) { propMap_.erase(iter); return true; } else { // logger.warn("Can not find property with name: " + propName); return false; } }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0xb8bda movq %rax, %r15 addq $0x10, %rbx cmpq %rbx, %rax je 0xb8a3d movq %r14, %rdi movq %r15, %rsi callq 0xb8e4e cmpq %rbx, %r15 setne %al popq %rbx popq %r14 popq %r15 retq nop
/OpenMD[P]OpenMD/src/utils/PropertyMap.cpp
OpenMD::PropertyMap::getPropertyByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::shared_ptr<GenericData> PropertyMap::getPropertyByName( const std::string& propName) { std::map<std::string, std::shared_ptr<GenericData>>::iterator iter; iter = propMap_.find(propName); if (iter != propMap_.end()) return iter->second; else return NULL; }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq 0x8(%rsi), %rdi movq %rdx, %rsi callq 0xb8bda addq $0x10, %r14 cmpq %r14, %rax je 0xb8b44 addq $0x40, %rax movq %rbx, %rdi movq %rax, %rsi callq 0x28880 jmp 0xb8b4a xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq nop
/OpenMD[P]OpenMD/src/utils/PropertyMap.cpp
OpenMD::StringTokenizer::StringTokenizer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
StringTokenizer::StringTokenizer(const std::string& str, const std::string& delim) : tokenString_(str), delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()), end_(tokenString_.end()) {}
pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rdi, %rbx callq 0x13700 leaq 0x20(%rbx), %rdi movq %r14, %rsi callq 0x13700 movb $0x0, 0x40(%rbx) movq (%rbx), %rax movq %rax, 0x48(%rbx) addq 0x8(%rbx), %rax movq %rax, 0x50(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::StringTokenizer(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
StringTokenizer::StringTokenizer(std::string::const_iterator& first, std::string::const_iterator& last, const std::string& delim) : tokenString_(first, last), delim_(delim), returnTokens_(false), currentPos_(tokenString_.begin()), end_(tokenString_.end()) {}
pushq %r14 pushq %rbx pushq %rax movq %rcx, %r14 movq %rdi, %rbx movq (%rsi), %rsi movq (%rdx), %rdx leaq 0x10(%rdi), %rax movq %rax, (%rdi) callq 0xb9678 leaq 0x20(%rbx), %rdi movq %r14, %rsi callq 0x13700 movb $0x0, 0x40(%rbx) movq (%rbx), %rax movq %rax, 0x48(%rbx) addq 0x8(%rbx), %rax movq %rax, 0x50(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::StringTokenizer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
StringTokenizer::StringTokenizer(const std::string& str, const std::string& delim, bool returnTokens) : tokenString_(str), delim_(delim), returnTokens_(returnTokens), currentPos_(tokenString_.begin()), end_(tokenString_.end()) {}
pushq %rbp pushq %r14 pushq %rbx movl %ecx, %ebp movq %rdx, %r14 movq %rdi, %rbx callq 0x13700 leaq 0x20(%rbx), %rdi movq %r14, %rsi callq 0x13700 movb %bpl, 0x40(%rbx) movq (%rbx), %rax movq %rax, 0x48(%rbx) addq 0x8(%rbx), %rax movq %rax, 0x50(%rbx) popq %rbx popq %r14 popq %rbp retq movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::countTokens()
int StringTokenizer::countTokens() { std::string::const_iterator tmpIter = currentPos_; int numToken = 0; while (true) { // skip delimiter first while (tmpIter != end_ && isDelimiter(*tmpIter)) { ++tmpIter; if (returnTokens_) { // if delimiter is consider as token ++numToken; } } if (tmpIter == end_) { break; } // encount a token here while (tmpIter != end_ && !isDelimiter(*tmpIter)) { ++tmpIter; } ++numToken; } return numToken; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x48(%rdi), %r14 xorl %ebp, %ebp pushq $0x1 popq %r15 movq %r14, %rax cmpq 0x50(%rbx), %r14 je 0xb9168 movsbl (%r14), %esi movq %rbx, %rdi callq 0xb9118 testb %al, %al je 0xb9164 incq %r14 movzbl 0x40(%rbx), %eax jmp 0xb918e movq 0x50(%rbx), %rax cmpq %rax, %r14 je 0xb9192 cmpq %rax, %r14 je 0xb918b movsbl (%r14), %esi movq %rbx, %rdi callq 0xb9118 testb %al, %al jne 0xb918b incq %r14 movq 0x50(%rbx), %rax jmp 0xb916d movl %r15d, %eax addl %eax, %ebp jmp 0xb9142 movl %ebp, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::nextToken[abi:cxx11]()
std::string StringTokenizer::nextToken() { std::string result; if (currentPos_ != end_) { std::insert_iterator<std::string> insertIter(result, result.begin()); while (currentPos_ != end_ && isDelimiter(*currentPos_)) { if (returnTokens_) { *insertIter++ = *currentPos_++; return result; } ++currentPos_; } while (currentPos_ != end_ && !isDelimiter(*currentPos_)) { *insertIter++ = *currentPos_++; } } return result; }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x10(%rdi), %rdx movq %rdx, (%rdi) andq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) movq 0x48(%rsi), %rax movq 0x50(%rsi), %rcx cmpq %rcx, %rax je 0xb928a movq %rsi, %r14 movq %rbx, 0x8(%rsp) movq %rdx, 0x10(%rsp) cmpq %rcx, %rax je 0xb9274 movsbl (%rax), %esi movq %r14, %rdi callq 0xb9118 testb %al, %al je 0xb9274 movb 0x40(%r14), %cl movq 0x48(%r14), %rsi leaq 0x1(%rsi), %rax movq %rax, 0x48(%r14) cmpb $0x1, %cl je 0xb9280 movq 0x50(%r14), %rcx jmp 0xb9220 movsbl (%rax), %esi movq %r14, %rdi callq 0xb9118 testb %al, %al jne 0xb928a movq 0x48(%r14), %rsi leaq 0x1(%rsi), %rax movq %rax, 0x48(%r14) leaq 0x8(%rsp), %rdi callq 0xb9656 movq 0x48(%r14), %rax cmpq 0x50(%r14), %rax jne 0xb924f jmp 0xb928a leaq 0x8(%rsp), %rdi callq 0xb9656 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r14 retq jmp 0xb9297 movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::nextTokenAsBool()
bool StringTokenizer::nextTokenAsBool() { std::string token = nextToken(); std::istringstream iss(token); bool result; if (iss >> result) { return result; } else { std::cerr << "unable to convert " << token << " to a bool" << std::endl; return false; } }
pushq %rbx subq $0x1b0, %rsp # imm = 0x1B0 movq %rdi, %rsi leaq 0x10(%rsp), %rbx movq %rbx, %rdi callq 0xb91ec leaq 0x30(%rsp), %rdi pushq $0x8 popq %rdx movq %rbx, %rsi callq 0x138c0 leaq 0x30(%rsp), %rdi leaq 0xf(%rsp), %rsi callq 0x13430 movq (%rax), %rcx movq -0x18(%rcx), %rcx testb $0x5, 0x20(%rax,%rcx) je 0xb938e movq 0x64c7e(%rip), %rdi # 0x11dfd8 leaq 0x17b22(%rip), %rsi # 0xd0e83 callq 0x134b0 leaq 0x10(%rsp), %rsi movq %rax, %rdi callq 0x13450 leaq 0x17b1c(%rip), %rsi # 0xd0e96 movq %rax, %rdi callq 0x134b0 movq %rax, %rdi callq 0x13250 xorl %ebx, %ebx jmp 0xb9392 movb 0xf(%rsp), %bl leaq 0x30(%rsp), %rdi callq 0x13230 leaq 0x10(%rsp), %rdi callq 0x13a98 movl %ebx, %eax addq $0x1b0, %rsp # imm = 0x1B0 popq %rbx retq movq %rax, %rbx jmp 0xb93c3 movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13230 leaq 0x10(%rsp), %rdi callq 0x13a98 movq %rbx, %rdi callq 0x13960 nop
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::StringTokenizer::peekNextToken[abi:cxx11]()
std::string StringTokenizer::peekNextToken() { std::string result; std::string::const_iterator tmpIter = currentPos_; if (tmpIter != end_) { std::insert_iterator<std::string> insertIter(result, result.begin()); while (tmpIter != end_ && isDelimiter(*tmpIter)) { if (returnTokens_) { *insertIter++ = *tmpIter++; return result; } ++tmpIter; } while (tmpIter != end_ && !isDelimiter(*tmpIter)) { *insertIter++ = *tmpIter++; } } return result; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x10(%rdi), %rcx movq %rcx, (%rdi) andq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) movq 0x48(%rsi), %r15 movq 0x50(%rsi), %rax cmpq %r15, %rax je 0xb954c movq %rsi, %r14 movq %rbx, 0x8(%rsp) movq %rcx, 0x10(%rsp) cmpq %rax, %r15 je 0xb9537 movsbl (%r15), %esi movq %r14, %rdi callq 0xb9118 testb %al, %al je 0xb9537 cmpb $0x1, 0x40(%r14) je 0xb953f incq %r15 movq 0x50(%r14), %rax jmp 0xb94ee movsbl (%r15), %esi movq %r14, %rdi callq 0xb9118 testb %al, %al jne 0xb954c leaq 0x1(%r15), %r12 leaq 0x8(%rsp), %rdi movq %r15, %rsi callq 0xb9656 movq %r12, %r15 cmpq 0x50(%r14), %r15 jne 0xb9513 jmp 0xb954c leaq 0x8(%rsp), %rdi movq %r15, %rsi callq 0xb9656 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0xb955d movq %rax, %r14 movq %rbx, %rdi callq 0x13a98 movq %r14, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/utils/StringTokenizer.cpp
OpenMD::isEndLine(char*)
int isEndLine(char* line) { char* working_line; char* foo; working_line = strdup(line); foo = strtok(working_line, " ,;\t"); if (foo != NULL) { if (!strcasecmp(foo, "end")) { free(working_line); return 1; } } free(working_line); return 0; }
pushq %rbp pushq %rbx pushq %rax callq 0x139a0 movq %rax, %rbx leaq 0x175b1(%rip), %rsi # 0xd0ee6 movq %rax, %rdi callq 0x137e0 testq %rax, %rax je 0xb9955 leaq 0xe13a(%rip), %rsi # 0xc7a83 movq %rax, %rdi callq 0x13540 testl %eax, %eax je 0xb9959 xorl %ebp, %ebp jmp 0xb995c pushq $0x1 popq %rbp movq %rbx, %rdi callq 0x135e0 movl %ebp, %eax addq $0x8, %rsp popq %rbx popq %rbp retq
/OpenMD[P]OpenMD/src/utils/StringUtils.cpp
OpenMD::RNEMD::RNEMDParameters::requiresElectricField()
bool RNEMDParameters::requiresElectricField() { static bool wasParsed {false}; if (!wasParsed) { StringTokenizer tokenizer(getOutputFields(), " ,;|\t\n\r"); while (tokenizer.hasMoreTokens()) { std::string token(tokenizer.nextToken()); toUpper(token); if (token == "ELECTRICFIELD" || token == "ELECTROSTATICPOTENTIAL") { calculateElectricField_ = true; break; } } wasParsed = true; } return calculateElectricField_; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xa8, %rsp movq %rdi, %rbx cmpb $0x0, 0x6517d(%rip) # 0x123c40 jne 0xbebad leaq 0x6d8(%rbx), %rsi leaq 0x10(%rsp), %rdi callq 0x13700 leaq 0x12682(%rip), %rsi # 0xd1163 leaq 0x30(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x1a8b4 leaq 0x50(%rsp), %rdi leaq 0x10(%rsp), %rsi leaq 0x30(%rsp), %rdx callq 0xb9030 leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x13a98 leaq 0x10(%rsp), %r15 movq %r15, %rdi callq 0x13a98 leaq 0x50(%rsp), %r12 leaq 0x12641(%rip), %r13 # 0xd116b leaq 0x12648(%rip), %rbp # 0xd1179 movq %r12, %rdi callq 0xb91a0 testb %al, %al je 0xbeb9c movq %r15, %rdi movq %r12, %rsi callq 0xb91ec movq %r14, %rdi callq 0x13a70 movq %r15, %rdi movq %r14, %rsi callq 0x22507 movq %r14, %rdi callq 0x13730 movq %r15, %rdi movq %r13, %rsi callq 0x2251c testb %al, %al jne 0xbeb8b movq %r15, %rdi movq %rbp, %rsi callq 0x2251c testb %al, %al jne 0xbeb8b movq %r15, %rdi callq 0x13a98 jmp 0xbeb31 movb $0x1, 0x7a8(%rbx) leaq 0x10(%rsp), %rdi callq 0x13a98 movb $0x1, 0x6509d(%rip) # 0x123c40 leaq 0x50(%rsp), %rdi callq 0x1a91c movb 0x7a8(%rbx), %al addq $0xa8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13a98 jmp 0xbebd7 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x13a98 jmp 0xbec0b movq %rax, %rbx leaq 0x30(%rsp), %rdi callq 0x13730 leaq 0x10(%rsp), %rdi callq 0x13a98 jmp 0xbec01 jmp 0xbebfe movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x1a91c movq %rbx, %rdi callq 0x13960
/OpenMD[P]OpenMD/src/rnemd/RNEMDParameters.cpp