applications/openmd/openmd.cpp

/*
 * Copyright (c) 2010 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 * [6]  Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012).
 */
 
#ifdef IS_MPI
#include <mpi.h>
#endif

#include <fstream>
#include <iostream>
#include <locale>
#include "utils/simError.h"
#include "utils/CaseConversion.hpp"
#include "utils/Revision.hpp"
#include "brains/Register.hpp"
#include "brains/SimCreator.hpp"
#include "brains/SimInfo.hpp"
#include "constraints/ZconstraintForceManager.hpp"
#include "restraints/RestraintForceManager.hpp"
#include "integrators/IntegratorFactory.hpp"
#include "integrators/Integrator.hpp"
#include "optimization/OptimizationFactory.hpp"
#include "optimization/Method.hpp"
#include "optimization/Constraint.hpp"
#include "optimization/Problem.hpp"
#include "optimization/PotentialEnergyObjectiveFunction.hpp"
#include "restraints/ThermoIntegrationForceManager.hpp"

using namespace OpenMD;
using namespace QuantLib;

int main(int argc, char* argv[]){
  
  // first things first, all of the initializations

#ifdef IS_MPI
  MPI_Init( &argc, &argv ); // the MPI communicators
#endif
   
  initSimError();           // the error handler
  //srand48( 1337 );          // the random number generator.

  std::string svnrev(g_REVISION, strnlen(g_REVISION, 20));
  //convert a macro from compiler to a string in c++
  //STR_DEFINE(svnrev, SVN_REV );

  std::string revision;

  if (!svnrev.empty()) {
     revision.assign("  Revision: " + svnrev);
  }

  revision.resize(19,' ');

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif
    std::cerr << 
      "  +--------------------------------------------------------------------------+\n"<<
      "  |    ____                    __  ___ ____                                  |\n"<<
      "  |   / __ \\____  ___  ____   /  |/  // __ \\  The Open Molecular Dynamics    |\n"<<
      "  |  / / / / __ \\/ _ \\/ __ \\ / /|_/ // / / /  Engine (formerly OOPSE).       |\n"<<
      "  | / /_/ / /_/ /  __/ / / // /  / // /_/ /                                  |\n"<<
      "  | \\____/ .___/\\___/_/ /_//_/  /_//_____/    Copyright 2004-2013 by the     |\n"<<
      "  |     /_/                                   University of Notre Dame.      |\n"<<
      "  |                                                                          |\n"<<
      "  |        version " << 
      OPENMD_VERSION_MAJOR << "." << OPENMD_VERSION_MINOR << revision << 
      "     http://www.openmd.org          |\n"<<
      "  |                                                                          |\n"<<
      "  | OpenMD is an OpenScience project.  All source code is available for any  |\n"<<
      "  | use whatsoever under a BSD-style license.                                |\n"<<
      "  |                                                                          |\n"<<
      "  | Support OpenScience!  If you use OpenMD or its source code in your       |\n"<<
      "  | research, please cite the appropriate papers when you publish your work  |\n"<<
      "  | Good starting points are:                                                |\n"<<
      "  |                                                                          |\n"<<
      "  | [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).                  |\n"<<
      "  | [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).               |\n"<<
      "  | [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).              |\n"<<
      "  | [4] Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).                |\n"<<
      "  | [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). |\n"<<
      "  | [6] Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012).                   |\n"<<
      "  +--------------------------------------------------------------------------+\n"<<
      "\n";
    
    if( argc < 2 ){
      strcpy( painCave.errMsg, "Error, a meta-data file is needed to run.\n" );
      painCave.isFatal = 1;
      simError();
    }
#ifdef IS_MPI
  }
#endif
  
  strcpy( checkPointMsg, "Successful number of arguments" );
  errorCheckPoint();

  //register forcefields, integrators and minimizers
  registerAll();

  //create simulation model
  SimCreator creator;
  SimInfo* info = creator.createSim(argv[1]);

  Globals* simParams = info->getSimParams();
  MinimizerParameters* miniPars = simParams->getMinimizerParameters();

  if (miniPars->getUseMinimizer() && simParams->haveEnsemble()) {
    sprintf(painCave.errMsg, "Ensemble keyword can not co-exist with useMinimizer = \"true\" in the minimizer block\n");
    painCave.isFatal = 1;
    simError();        
  }

  if (miniPars->getUseMinimizer()) {
    //create minimizer
    OptimizationMethod* myMinimizer =OptimizationFactory::getInstance()->createOptimization(toUpperCopy(miniPars->getMethod()), info);

    if (myMinimizer == NULL) {
      sprintf(painCave.errMsg, "Optimization Factory can not create %s OptimizationMethod\n",
              miniPars->getMethod().c_str());
      painCave.isFatal = 1;
      simError();
    }

    ForceManager* fman = new ForceManager(info);      
    fman->initialize();

    PotentialEnergyObjectiveFunction potObjf(info, fman); 
    DumpStatusFunction dsf(info);
    DynamicVector<RealType> initCoords = potObjf.setInitialCoords();
    Problem problem(potObjf, *(new NoConstraint()), dsf, initCoords);


    int maxIter = miniPars->getMaxIterations();
    int mssIter = miniPars->getMaxStationaryStateIterations();
    RealType rEps = miniPars->getRootEpsilon();
    RealType fEps = miniPars->getFunctionEpsilon();
    RealType gnEps = miniPars->getGradientNormEpsilon();

    EndCriteria endCriteria(maxIter, mssIter, rEps, fEps, gnEps); 

    myMinimizer->minimize(problem, endCriteria);

    delete myMinimizer;
  } else if (simParams->haveEnsemble()) {
    //create Integrator

    Integrator* myIntegrator = IntegratorFactory::getInstance()->createIntegrator(toUpperCopy(simParams->getEnsemble()), info);
 
    if (myIntegrator == NULL) {
      sprintf(painCave.errMsg, "Integrator Factory can not create %s Integrator\n",
              simParams->getEnsemble().c_str());
      painCave.isFatal = 1;
      simError();
    }
                
    //Thermodynamic Integration Method
    //set the force manager for thermodynamic integration if specified
    if (simParams->getUseThermodynamicIntegration()){
      ForceManager* fman = new ThermoIntegrationForceManager(info);
      myIntegrator->setForceManager(fman);
    }

    // Restraints
    if (simParams->getUseRestraints() && !simParams->getUseThermodynamicIntegration()) {
      ForceManager* fman = new RestraintForceManager(info);
      myIntegrator->setForceManager(fman);
    }

    //Zconstraint-Method
    if (simParams->getNZconsStamps() > 0) {
      info->setNZconstraint(simParams->getNZconsStamps());
      ForceManager* fman = new ZconstraintForceManager(info);
      myIntegrator->setForceManager(fman);
    }
        
    myIntegrator->integrate();
    delete myIntegrator;
  }else {
    sprintf(painCave.errMsg, "Integrator Factory can not create %s Integrator\n",
            simParams->getEnsemble().c_str());
    painCave.isFatal = 1;
    simError();
  }
    
  delete info;


  strcpy( checkPointMsg, "Great googly moogly!  It worked!" );
  errorCheckPoint();

#ifdef IS_MPI  
  MPI_Finalize();
#endif

  return 0 ;
}
Revision:	1976
Committed:	Wed Mar 12 20:01:15 2014 UTC (11 years, 1 month ago) by gezelter
File size:	9433 byte(s)
Log Message:	Revision string moves to its own cpp file that is compiled, and out of a defined string. This will make it a bit easier to migrate to git when the time comes.
#	User	Rev	Content
1	gezelter	1390	/*
2	gezelter	1406	* Copyright (c) 2010 The University of Notre Dame. All Rights Reserved.
3	gezelter	1390	*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			*
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.
16			*
17			* This software is provided "AS IS," without a warranty of any
18			* kind. All express or implied conditions, representations and
19			* warranties, including any implied warranty of merchantability,
20			* fitness for a particular purpose or non-infringement, are hereby
21			* excluded. The University of Notre Dame and its licensors shall not
22			* be liable for any damages suffered by licensee as a result of
23			* using, modifying or distributing the software or its
24			* derivatives. In no event will the University of Notre Dame or its
25			* licensors be liable for any lost revenue, profit or data, or for
26			* direct, indirect, special, consequential, incidental or punitive
27			* damages, however caused and regardless of the theory of liability,
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	gezelter	1879	* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39	gezelter	1782	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41			* [6] Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012).
42	gezelter	1390	*/
43
44			#ifdef IS_MPI
45			#include <mpi.h>
46			#endif
47
48			#include <fstream>
49	gezelter	1790	#include <iostream>
50			#include <locale>
51	gezelter	1390	#include "utils/simError.h"
52			#include "utils/CaseConversion.hpp"
53	gezelter	1976	#include "utils/Revision.hpp"
54	gezelter	1390	#include "brains/Register.hpp"
55			#include "brains/SimCreator.hpp"
56			#include "brains/SimInfo.hpp"
57			#include "constraints/ZconstraintForceManager.hpp"
58			#include "restraints/RestraintForceManager.hpp"
59			#include "integrators/IntegratorFactory.hpp"
60			#include "integrators/Integrator.hpp"
61	gezelter	1782	#include "optimization/OptimizationFactory.hpp"
62			#include "optimization/Method.hpp"
63			#include "optimization/Constraint.hpp"
64			#include "optimization/Problem.hpp"
65			#include "optimization/PotentialEnergyObjectiveFunction.hpp"
66	gezelter	1390	#include "restraints/ThermoIntegrationForceManager.hpp"
67
68			using namespace OpenMD;
69	gezelter	1782	using namespace QuantLib;
70	gezelter	1390
71	gezelter	1796	int main(int argc, char* argv[]){
72	gezelter	1390
73			// first things first, all of the initializations
74
75			#ifdef IS_MPI
76	gezelter	1969	MPI_Init( &argc, &argv ); // the MPI communicators
77	gezelter	1390	#endif
78
79			initSimError(); // the error handler
80	gezelter	1782	//srand48( 1337 ); // the random number generator.
81	gezelter	1461
82	gezelter	1976	std::string svnrev(g_REVISION, strnlen(g_REVISION, 20));
83	gezelter	1461	//convert a macro from compiler to a string in c++
84	gezelter	1976	//STR_DEFINE(svnrev, SVN_REV );
85	gezelter	1462
86	gezelter	1463	std::string revision;
87	gezelter	1461
88	gezelter	1463	if (!svnrev.empty()) {
89			revision.assign(" Revision: " + svnrev);
90			}
91
92			revision.resize(19,' ');
93
94	gezelter	1390	#ifdef IS_MPI
95			if( worldRank == 0 ){
96			#endif
97			std::cerr <<
98	gezelter	1782	" +--------------------------------------------------------------------------+\n"<<
99			" \| ____ __ ___ ____ \|\n"<<
100			" \| / __ \\____ ___ ____ / \|/ // __ \\ The Open Molecular Dynamics \|\n"<<
101			" \| / / / / __ \\/ _ \\/ __ \\ / /\|_/ // / / / Engine (formerly OOPSE). \|\n"<<
102			" \| / /_/ / /_/ / __/ / / // / / // /_/ / \|\n"<<
103	gezelter	1879	" \| \\____/ .___/\\___/_/ /_//_/ /_//_____/ Copyright 2004-2013 by the \|\n"<<
104	gezelter	1782	" \| /_/ University of Notre Dame. \|\n"<<
105			" \| \|\n"<<
106	gezelter	1461	" \| version " <<
107	gezelter	1463	OPENMD_VERSION_MAJOR << "." << OPENMD_VERSION_MINOR << revision <<
108	gezelter	1891	" http://www.openmd.org \|\n"<<
109	gezelter	1782	" \| \|\n"<<
110			" \| OpenMD is an OpenScience project. All source code is available for any \|\n"<<
111			" \| use whatsoever under a BSD-style license. \|\n"<<
112			" \| \|\n"<<
113			" \| Support OpenScience! If you use OpenMD or its source code in your \|\n"<<
114			" \| research, please cite the appropriate papers when you publish your work \|\n"<<
115			" \| Good starting points are: \|\n"<<
116			" \| \|\n"<<
117			" \| [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005). \|\n"<<
118			" \| [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006). \|\n"<<
119	gezelter	1879	" \| [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008). \|\n"<<
120	gezelter	1782	" \| [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010). \|\n"<<
121			" \| [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). \|\n"<<
122			" \| [6] Kuang & Gezelter, Mol. Phys., 110, 691-701 (2012). \|\n"<<
123			" +--------------------------------------------------------------------------+\n"<<
124	gezelter	1390	"\n";
125
126			if( argc < 2 ){
127			strcpy( painCave.errMsg, "Error, a meta-data file is needed to run.\n" );
128			painCave.isFatal = 1;
129			simError();
130			}
131			#ifdef IS_MPI
132			}
133			#endif
134
135			strcpy( checkPointMsg, "Successful number of arguments" );
136			errorCheckPoint();
137
138			//register forcefields, integrators and minimizers
139			registerAll();
140
141			//create simulation model
142			SimCreator creator;
143			SimInfo* info = creator.createSim(argv[1]);
144	gezelter	1782
145	gezelter	1390	Globals* simParams = info->getSimParams();
146	gezelter	1782	MinimizerParameters* miniPars = simParams->getMinimizerParameters();
147	gezelter	1390
148	gezelter	1782	if (miniPars->getUseMinimizer() && simParams->haveEnsemble()) {
149			sprintf(painCave.errMsg, "Ensemble keyword can not co-exist with useMinimizer = \"true\" in the minimizer block\n");
150	gezelter	1390	painCave.isFatal = 1;
151			simError();
152			}
153	gezelter	1782
154			if (miniPars->getUseMinimizer()) {
155	gezelter	1390	//create minimizer
156	gezelter	1782	OptimizationMethod* myMinimizer =OptimizationFactory::getInstance()->createOptimization(toUpperCopy(miniPars->getMethod()), info);
157	gezelter	1390
158			if (myMinimizer == NULL) {
159	gezelter	1782	sprintf(painCave.errMsg, "Optimization Factory can not create %s OptimizationMethod\n",
160			miniPars->getMethod().c_str());
161	gezelter	1390	painCave.isFatal = 1;
162			simError();
163			}
164
165	gezelter	1782	ForceManager* fman = new ForceManager(info);
166			fman->initialize();
167
168			PotentialEnergyObjectiveFunction potObjf(info, fman);
169			DumpStatusFunction dsf(info);
170			DynamicVector<RealType> initCoords = potObjf.setInitialCoords();
171			Problem problem(potObjf, *(new NoConstraint()), dsf, initCoords);
172
173
174			int maxIter = miniPars->getMaxIterations();
175			int mssIter = miniPars->getMaxStationaryStateIterations();
176			RealType rEps = miniPars->getRootEpsilon();
177			RealType fEps = miniPars->getFunctionEpsilon();
178			RealType gnEps = miniPars->getGradientNormEpsilon();
179
180			EndCriteria endCriteria(maxIter, mssIter, rEps, fEps, gnEps);
181
182			myMinimizer->minimize(problem, endCriteria);
183
184	gezelter	1390	delete myMinimizer;
185			} else if (simParams->haveEnsemble()) {
186			//create Integrator
187
188			Integrator* myIntegrator = IntegratorFactory::getInstance()->createIntegrator(toUpperCopy(simParams->getEnsemble()), info);
189
190			if (myIntegrator == NULL) {
191	gezelter	1782	sprintf(painCave.errMsg, "Integrator Factory can not create %s Integrator\n",
192	gezelter	1390	simParams->getEnsemble().c_str());
193			painCave.isFatal = 1;
194			simError();
195			}
196
197			//Thermodynamic Integration Method
198			//set the force manager for thermodynamic integration if specified
199			if (simParams->getUseThermodynamicIntegration()){
200			ForceManager* fman = new ThermoIntegrationForceManager(info);
201			myIntegrator->setForceManager(fman);
202			}
203
204			// Restraints
205			if (simParams->getUseRestraints() && !simParams->getUseThermodynamicIntegration()) {
206			ForceManager* fman = new RestraintForceManager(info);
207			myIntegrator->setForceManager(fman);
208			}
209
210			//Zconstraint-Method
211			if (simParams->getNZconsStamps() > 0) {
212			info->setNZconstraint(simParams->getNZconsStamps());
213			ForceManager* fman = new ZconstraintForceManager(info);
214			myIntegrator->setForceManager(fman);
215			}
216
217			myIntegrator->integrate();
218			delete myIntegrator;
219			}else {
220			sprintf(painCave.errMsg, "Integrator Factory can not create %s Integrator\n",
221			simParams->getEnsemble().c_str());
222			painCave.isFatal = 1;
223			simError();
224			}
225
226			delete info;
227
228
229			strcpy( checkPointMsg, "Great googly moogly! It worked!" );
230			errorCheckPoint();
231
232			#ifdef IS_MPI
233	gezelter	1969	MPI_Finalize();
234	gezelter	1390	#endif
235
236			return 0 ;
237			}