ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/applications/hydrodynamics/Hydro.cpp
(Generate patch)

Comparing trunk/src/applications/hydrodynamics/Hydro.cpp (file contents):
Revision 891 by tim, Wed Feb 22 20:35:16 2006 UTC vs.
Revision 921 by tim, Wed Mar 29 18:09:26 2006 UTC

# Line 47 | Line 47
47   #include "applications/hydrodynamics/HydrodynamicsModel.hpp"
48   #include "applications/hydrodynamics/HydrodynamicsModelCreator.hpp"
49   #include "applications/hydrodynamics/HydrodynamicsModelFactory.hpp"
50 + #include "applications/hydrodynamics/AnalyticalModel.hpp"
51   #include "applications/hydrodynamics/BeadModel.hpp"
52   #include "applications/hydrodynamics/RoughShell.hpp"
53 + #include "applications/hydrodynamics/ShapeBuilder.hpp"
54   #include "brains/Register.hpp"
55   #include "brains/SimCreator.hpp"
56   #include "brains/SimInfo.hpp"
57 <
57 > #include "utils/StringUtils.hpp"
58 > #include "utils/simError.h"
59 > #include "utils/MemoryUtils.hpp"
60   using namespace oopse;
61  
62 < /** Register different hydrodynamics models */
62 > struct SDShape{
63 >    StuntDouble* sd;
64 >    Shape* shape;
65 > };
66   void registerHydrodynamicsModels();
67  
61 – bool calcHydrodynamicsProp(const std::string& modelType, Molecule* mol, const DynamicProperty& param, const std::string& prefix,double viscosity);
62 –
68   int main(int argc, char* argv[]){
69    //register force fields
70    registerForceFields();    
# Line 89 | Line 94 | int main(int argc, char* argv[]){
94    if (args_info.output_given){
95      prefix = args_info.output_arg;
96    } else {
97 <    prefix = "hydro";    
97 >    prefix = getPrefix(mdFileName);    
98    }
99 <
100 <  DynamicProperty param;
96 <  if (args_info.sigma_given) {
97 <    param.insert(DynamicProperty::value_type("Sigma", args_info.sigma_arg));
98 <  }
99 <  
100 <  
99 >  std::string outputFilename = prefix + ".diff";
100 >    
101    //parse md file and set up the system
102    SimCreator creator;
103    SimInfo* info = creator.createSim(mdFileName, true);
104      
105    SimInfo::MoleculeIterator mi;
106    Molecule* mol;
107 <  Molecule::RigidBodyIterator ri;
108 <  RigidBody* rb;
109 <    //update atoms of rigidbody
110 <  for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
111 <      
112 <      //change the positions of atoms which belong to the rigidbodies
113 <      for (rb = mol->beginRigidBody(ri); rb != NULL; rb = mol->nextRigidBody(ri)) {
114 <        rb->updateAtoms();
115 <      }
107 >  Molecule::IntegrableObjectIterator  ii;
108 >  StuntDouble* integrableObject;
109 >  Mat3x3d identMat;
110 >  identMat(0,0) = 1.0;
111 >  identMat(1,1) = 1.0;
112 >  identMat(2,2) = 1.0;
113 >
114 >  Globals* simParams = info->getSimParams();
115 >  double temperature;
116 >  double viscosity;
117 >
118 >  if (simParams->haveViscosity()) {
119 >    viscosity = simParams->getViscosity();
120 >  } else {
121 >    sprintf(painCave.errMsg, "viscosity must be set\n");
122 >    painCave.isFatal = 1;
123 >    simError();  
124    }
125 <    
125 >
126 >  if (simParams->haveTargetTemp()) {
127 >    temperature = simParams->getTargetTemp();
128 >  } else {
129 >    sprintf(painCave.errMsg, "target temperaturemust be set\n");
130 >    painCave.isFatal = 1;
131 >    simError();  
132 >  }
133 >
134 >  std::map<std::string, SDShape> uniqueStuntDoubles;
135 >  
136    for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
137 <    calcHydrodynamicsProp(args_info.model_arg, mol, param, prefix, args_info.viscosity_arg);
137 >      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
138 >           integrableObject = mol->nextIntegrableObject(ii)) {
139 >          if (uniqueStuntDoubles.find(integrableObject->getType()) ==  uniqueStuntDoubles.end()) {
140 >
141 >            integrableObject->setPos(V3Zero);
142 >            integrableObject->setA(identMat);
143 >            if (integrableObject->isRigidBody()) {
144 >                RigidBody* rb = static_cast<RigidBody*>(integrableObject);
145 >                rb->updateAtoms();
146 >            }
147 >
148 >            SDShape tmp;
149 >            tmp.shape = ShapeBuilder::createShape(integrableObject);
150 >            tmp.sd = integrableObject;    
151 >            uniqueStuntDoubles.insert(std::map<std::string, SDShape>::value_type(integrableObject->getType(), tmp));
152 >
153 >          }
154 >        }
155    }
156 +
157 +
158    
159 +  std::ofstream outputDiff(outputFilename.c_str());
160 +  std::map<std::string, SDShape>::iterator si;
161 +  for (si = uniqueStuntDoubles.begin(); si != uniqueStuntDoubles.end(); ++si) {
162 +      HydrodynamicsModel* model;
163 +      Shape* shape = si->second.shape;
164 +      StuntDouble* sd = si->second.sd;;
165 +      if (args_info.model_given) {  
166 +        model = HydrodynamicsModelFactory::getInstance()->createHydrodynamicsModel(args_info.model_arg, sd, info);
167 +      } else if (shape->hasAnalyticalSolution()) {
168 +        model = new AnalyticalModel(sd, info);
169 +      } else {
170 +        model = new BeadModel(sd, info);
171 +      }
172 +
173 +        model->init();
174 +        
175 +        std::ofstream ofs;
176 +        std::stringstream outputBeads;
177 +        outputBeads << prefix << "_" << model->getStuntDoubleName() << ".xyz";
178 +        ofs.open(outputBeads.str().c_str());        
179 +        model->writeBeads(ofs);
180 +        ofs.close();
181 +
182 +        //if beads option is turned on, skip the calculation
183 +        if (!args_info.beads_flag) {
184 +            shape->calcHydroProps(model, viscosity, temperature);
185 +            model->writeHydroProps(outputDiff);
186 +        }
187 +
188 +        delete model;
189 +  }
190 +
191 +
192 +  //MemoryUtils::deletePointers(shapes);
193    delete info;
194    
195   }
# Line 126 | Line 197 | void registerHydrodynamicsModels() {
197   void registerHydrodynamicsModels() {
198      HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<RoughShell>("RoughShell"));
199      HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<BeadModel>("BeadModel"));
200 +    HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<AnalyticalModel>("AnalyticalModel"));
201  
202   }
203  
132 – bool calcHydrodynamicsProp(const std::string& modelType, Molecule* mol, const DynamicProperty& param, const std::string& prefix,double viscosity) {
133 –    HydrodynamicsModel* hydroModel = HydrodynamicsModelFactory::getInstance()->createHydrodynamicsModel(modelType, mol, param);
134 –    bool ret = false;
135 –    if (hydroModel == NULL) {
136 –        std::cout << "Integrator Factory can not create " << modelType <<std::endl;
137 –    }    
138 –
139 –    if (hydroModel->calcHydrodyanmicsProps(viscosity)) {
140 –        ret = true;
141 –        std::stringstream outputDiffTensor;
142 –        outputDiffTensor << prefix << "_" << mol->getType() << ".diff";
143 –        std::ofstream ofs;
144 –        ofs.open(outputDiffTensor.str().c_str());
145 –        hydroModel->writeDiffCenterAndDiffTensor(ofs);
146 –        ofs.close();
147 –        
148 –        std::stringstream outputBeads;
149 –        outputBeads << prefix << "_" << mol->getType() << ".xyz";
150 –        ofs.open(outputBeads.str().c_str());
151 –        hydroModel->writeBeads(ofs);
152 –        ofs.close();
153 –    }
154 –
155 –    delete hydroModel;
156 –
157 –    return ret;    
158 – }

Diff Legend

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