ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/visitors/AtomVisitor.cpp

Comparing trunk/src/visitors/AtomVisitor.cpp (file contents):
Revision 1008 by chrisfen, Wed Jul 19 12:35:31 2006 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13		*    notice, this list of conditions and the following disclaimer in the
14		*    documentation and/or other materials provided with the
15		*    distribution.
#	Line 37 | Line 28
28		* arising out of the use of or inability to use software, even if the
29		* University of Notre Dame has been advised of the possibility of
30		* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
40		*/
41
42		#include <cstring>
#	Line 44 | Line 44
44		#include "primitives/DirectionalAtom.hpp"
45		#include "primitives/RigidBody.hpp"
46
47	<	namespace oopse {
47	>	namespace OpenMD {
48		void BaseAtomVisitor::visit(RigidBody *rb) {
49		//vector<Atom*> myAtoms;
50		//vector<Atom*>::iterator atomIter;
#	Line 384 | Line 384 | namespace oopse {
384		AtomData* atomData;
385		GenericData* data;
386		bool haveAtomData;
387	–	AtomType* atomType;
387		//if atom is not linear atom, just skip it
388		if(!isLinearAtom(datom->getType()) || !datom->getAtomType()->isGayBerne())
389		return;
#	Line 409 | Line 408 | namespace oopse {
408		else {
409		sprintf( painCave.errMsg,
410		"Can not cast GenericData to GayBerneParam\n");
411	<	painCave.severity = OOPSE_ERROR;
411	>	painCave.severity = OPENMD_ERROR;
412		painCave.isFatal = 1;
413		simError();
414		}
#	Line 522 | Line 521 | namespace oopse {
521
522		void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
523		std::vector<AtomInfo*> atoms;
524	<	//we need to convert linear into 4 different atoms
525	<	Vector3d c1(0.0, 0.0, -6.25);
527	<	Vector3d c2(0.0, 0.0, -2.1);
528	<	Vector3d c3(0.0, 0.0,  2.1);
529	<	Vector3d c4(0.0, 0.0,  6.25);
524	>	Vector3d c1(0.0, 0.0, 0.0);
525	>	Vector3d c2(0.0, 0.0, 1.0);
526		RotMat3x3d rotMatrix;
527		RotMat3x3d rotTrans;
528		AtomInfo* atomInfo;
529		Vector3d pos;
530		Vector3d newVec;
531	+	Vector3d dVec;
532		Quat4d q;
533		AtomData* atomData;
534		GenericData* data;
#	Line 565 | Line 562 | namespace oopse {
562		rotTrans = rotMatrix.transpose();
563
564		newVec = rotTrans * c1;
565	+	dVec = rotTrans * c2;
566		atomInfo = new AtomInfo;
567	+	atomInfo->atomTypeName = "GB";
568	+	atomInfo->pos[0] = pos[0] + newVec[0];
569	+	atomInfo->pos[1] = pos[1] + newVec[1];
570	+	atomInfo->pos[2] = pos[2] + newVec[2];
571	+	atomInfo->dipole[0] = dVec[0];
572	+	atomInfo->dipole[1] = dVec[1];
573	+	atomInfo->dipole[2] = dVec[2];
574	+	atomInfo->hasVector = true;
575	+	atomInfo->charge = 3.0;
576	+	atomInfo->hasCharge = true;
577	+	atomData->addAtomInfo(atomInfo);
578	+
579	+	//add atom data into atom's property
580	+
581	+	if(!haveAtomData){
582	+	atomData->setID("ATOMDATA");
583	+	datom->addProperty(atomData);
584	+	}
585	+
586	+	setVisited(datom);
587	+
588	+	}
589	+
590	+	const std::string GBLipidAtomVisitor::toString(){
591	+	char buffer[65535];
592	+	std::string result;
593	+
594	+	sprintf(buffer ,"------------------------------------------------------------------\n");
595	+	result += buffer;
596	+
597	+	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
598	+	result += buffer;
599	+
600	+	sprintf(buffer , "Visitor Description: Convert GBlipid into xyz-formatted atom for use with xyz2pov\n");
601	+	result += buffer;
602	+
603	+	sprintf(buffer ,"------------------------------------------------------------------\n");
604	+	result += buffer;
605	+
606	+	return result;
607	+	}
608	+
609	+	bool Ring5gbAtomVisitor::isRing5gbAtom(const std::string& atomType){
610	+	std::set<std::string>::iterator strIter;
611	+	strIter = Ring5gbAtomType.find(atomType);
612	+
613	+	return strIter != Ring5gbAtomType.end() ? true : false;
614	+	}
615	+
616	+	void Ring5gbAtomVisitor::visit(DirectionalAtom* datom){
617	+	std::vector<AtomInfo*> atoms;
618	+	//we need to convert linear into 4 different atoms
619	+	Vector3d c1(0.0, 0.0, -5.5);
620	+	Vector3d c2(0.0, 0.0, -1.8);
621	+	Vector3d c3(0.0, 0.0,  1.8);
622	+	Vector3d c4(0.0, 0.0,  5.5);
623	+	RotMat3x3d rotMatrix;
624	+	RotMat3x3d rotTrans;
625	+	AtomInfo* atomInfo;
626	+	Vector3d pos;
627	+	Vector3d newVec;
628	+	Vector3d dVec;
629	+	Quat4d q;
630	+	AtomData* atomData;
631	+	GenericData* data;
632	+	bool haveAtomData;
633	+
634	+	//if atom is not Ring5GB atom, just skip it
635	+	if(!isRing5gbAtom(datom->getType()))
636	+	return;
637	+
638	+	data = datom->getPropertyByName("ATOMDATA");
639	+	if(data != NULL){
640	+	atomData = dynamic_cast<AtomData*>(data);
641	+	if(atomData == NULL){
642	+	std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
643	+	atomData = new AtomData;
644	+	haveAtomData = false;
645	+	} else {
646	+	haveAtomData = true;
647	+	}
648	+	} else {
649	+	atomData = new AtomData;
650	+	haveAtomData = false;
651	+	}
652	+
653	+
654	+	pos = datom->getPos();
655	+	q = datom->getQ();
656	+	rotMatrix = datom->getA();
657	+
658	+	// We need A^T to convert from body-fixed to space-fixed:
659	+	rotTrans = rotMatrix.transpose();
660	+
661	+	newVec = rotTrans * c1;
662	+	atomInfo = new AtomInfo;
663		atomInfo->atomTypeName = "K";
664		atomInfo->pos[0] = pos[0] + newVec[0];
665		atomInfo->pos[1] = pos[1] + newVec[1];
#	Line 619 | Line 713 | namespace oopse {
713
714		}
715
716	<	const std::string GBLipidAtomVisitor::toString(){
716	>	const std::string Ring5gbAtomVisitor::toString(){
717		char buffer[65535];
718		std::string result;
719
#	Line 629 | Line 723 | namespace oopse {
723		sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
724		result += buffer;
725
726	<	sprintf(buffer , "Visitor Description: Convert GBlipid into 4 different K atoms\n");
726	>	sprintf(buffer , "Visitor Description: Convert Ring5GB into 4 different K atoms\n");
727		result += buffer;
728
729		sprintf(buffer ,"------------------------------------------------------------------\n");
#	Line 638 | Line 732 | namespace oopse {
732		return result;
733		}
734
735	+	bool HeadAtomVisitor::isHeadAtom(const std::string& atomType){
736	+	std::set<std::string>::iterator strIter;
737	+	strIter = HeadAtomType.find(atomType);
738	+
739	+	return strIter != HeadAtomType.end() ? true : false;
740	+	}
741	+
742	+	void HeadAtomVisitor::visit(DirectionalAtom* datom){
743	+	std::vector<AtomInfo*> atoms;
744	+	//we need to convert linear into 2 different atoms
745	+	Vector3d c1(0.0, 0.0, -1.5);
746	+	Vector3d c2(0.0, 0.0, 1.5);
747	+	RotMat3x3d rotMatrix;
748	+	RotMat3x3d rotTrans;
749	+	AtomInfo* atomInfo;
750	+	Vector3d pos;
751	+	Vector3d newVec;
752	+	Vector3d dVec;
753	+	Quat4d q;
754	+	AtomData* atomData;
755	+	GenericData* data;
756	+	bool haveAtomData;
757	+
758	+	//if atom is not Head atom, just skip it
759	+	if(!isHeadAtom(datom->getType()))
760	+	return;
761	+
762	+	data = datom->getPropertyByName("ATOMDATA");
763	+	if(data != NULL){
764	+	atomData = dynamic_cast<AtomData*>(data);
765	+	if(atomData == NULL){
766	+	std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
767	+	atomData = new AtomData;
768	+	haveAtomData = false;
769	+	} else {
770	+	haveAtomData = true;
771	+	}
772	+	} else {
773	+	atomData = new AtomData;
774	+	haveAtomData = false;
775	+	}
776	+
777	+
778	+	pos = datom->getPos();
779	+	q = datom->getQ();
780	+	rotMatrix = datom->getA();
781	+
782	+	// We need A^T to convert from body-fixed to space-fixed:
783	+	rotTrans = rotMatrix.transpose();
784	+
785	+	newVec = rotTrans * c1;
786	+	atomInfo = new AtomInfo;
787	+	atomInfo->atomTypeName = "C";
788	+	atomInfo->pos[0] = pos[0] + newVec[0];
789	+	atomInfo->pos[1] = pos[1] + newVec[1];
790	+	atomInfo->pos[2] = pos[2] + newVec[2];
791	+	atomInfo->dipole[0] = 0.0;
792	+	atomInfo->dipole[1] = 0.0;
793	+	atomInfo->dipole[2] = 0.0;
794	+	atomData->addAtomInfo(atomInfo);
795	+
796	+	newVec = rotTrans * c2;
797	+	atomInfo = new AtomInfo;
798	+	atomInfo->atomTypeName = "O";
799	+	atomInfo->pos[0] = pos[0] + newVec[0];
800	+	atomInfo->pos[1] = pos[1] + newVec[1];
801	+	atomInfo->pos[2] = pos[2] + newVec[2];
802	+	atomInfo->dipole[0] = 0.0;
803	+	atomInfo->dipole[1] = 0.0;
804	+	atomInfo->dipole[2] = 0.0;
805	+	atomData->addAtomInfo(atomInfo);
806	+
807	+	//add atom data into atom's property
808	+
809	+	if(!haveAtomData){
810	+	atomData->setID("ATOMDATA");
811	+	datom->addProperty(atomData);
812	+	}
813	+
814	+	setVisited(datom);
815	+
816	+	}
817	+
818	+	const std::string HeadAtomVisitor::toString(){
819	+	char buffer[65535];
820	+	std::string result;
821	+
822	+	sprintf(buffer ,"------------------------------------------------------------------\n");
823	+	result += buffer;
824	+
825	+	sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
826	+	result += buffer;
827	+
828	+	sprintf(buffer , "Visitor Description: Convert HEAD into C atom and O atom\n");
829	+	result += buffer;
830	+
831	+	sprintf(buffer ,"------------------------------------------------------------------\n");
832	+	result += buffer;
833	+
834	+	return result;
835	+	}
836	+
837	+
838		//----------------------------------------------------------------------------//
839
840		void DefaultAtomVisitor::visit(Atom *atom) {
#	Line 724 | Line 921 | namespace oopse {
921
922		return result;
923		}
924	<	} //namespace oopse
924	>	} //namespace OpenMD

Comparing trunk/src/visitors/AtomVisitor.cpp (property svn:keywords):
Revision 1008 by chrisfen, Wed Jul 19 12:35:31 2006 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines