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 892 by tim, Thu Feb 23 23:16:43 2006 UTC vs.
Revision 977 by tim, Thu May 25 16:27:27 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 + void writeHydroProps(std::ostream& os);
68  
61 – bool calcHydrodynamicsProp(const std::string& modelType, StuntDouble* sd, const DynamicProperty& param, std::ostream& os,  const std::string& prefix);
62 –
69   int main(int argc, char* argv[]){
70    //register force fields
71    registerForceFields();    
# Line 89 | Line 95 | int main(int argc, char* argv[]){
95    if (args_info.output_given){
96      prefix = args_info.output_arg;
97    } else {
98 <    prefix = "hydro";    
98 >    prefix = getPrefix(mdFileName);    
99    }
100    std::string outputFilename = prefix + ".diff";
101 <
96 <  DynamicProperty param;
97 <  param.insert(DynamicProperty::value_type("Viscosity", args_info.viscosity_arg));
98 <  param.insert(DynamicProperty::value_type("Temperature", args_info.temperature_arg));
99 <  
100 <  if (args_info.sigma_given) {
101 <    param.insert(DynamicProperty::value_type("Sigma", args_info.sigma_arg));
102 <  }
103 <  
104 <  
101 >    
102    //parse md file and set up the system
103    SimCreator creator;
104    SimInfo* info = creator.createSim(mdFileName, true);
# Line 114 | Line 111 | int main(int argc, char* argv[]){
111    identMat(0,0) = 1.0;
112    identMat(1,1) = 1.0;
113    identMat(2,2) = 1.0;
114 <  
114 >
115 >  Globals* simParams = info->getSimParams();
116 >  RealType temperature;
117 >  RealType viscosity;
118 >
119 >  if (simParams->haveViscosity()) {
120 >    viscosity = simParams->getViscosity();
121 >  } else {
122 >    sprintf(painCave.errMsg, "viscosity must be set\n");
123 >    painCave.isFatal = 1;
124 >    simError();  
125 >  }
126 >
127 >  if (simParams->haveTargetTemp()) {
128 >    temperature = simParams->getTargetTemp();
129 >  } else {
130 >    sprintf(painCave.errMsg, "target temperature must be set\n");
131 >    painCave.isFatal = 1;
132 >    simError();  
133 >  }
134  
135 <  std::map<std::string, StuntDouble*> uniqueStuntDoubles;
135 >  std::map<std::string, SDShape> uniqueStuntDoubles;
136    
137    for (mol = info->beginMolecule(mi); mol != NULL; mol = info->nextMolecule(mi)) {
138        for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
139             integrableObject = mol->nextIntegrableObject(ii)) {
140            if (uniqueStuntDoubles.find(integrableObject->getType()) ==  uniqueStuntDoubles.end()) {
141 <            uniqueStuntDoubles.insert(std::map<std::string, StuntDouble*>::value_type(integrableObject->getType(), integrableObject));
141 >
142              integrableObject->setPos(V3Zero);
143              integrableObject->setA(identMat);
144              if (integrableObject->isRigidBody()) {
145                  RigidBody* rb = static_cast<RigidBody*>(integrableObject);
146                  rb->updateAtoms();
147              }
148 +
149 +            SDShape tmp;
150 +            tmp.shape = ShapeBuilder::createShape(integrableObject);
151 +            tmp.sd = integrableObject;    
152 +            uniqueStuntDoubles.insert(std::map<std::string, SDShape>::value_type(integrableObject->getType(), tmp));
153 +
154            }
155          }
156    }
157  
158 <  std::map<std::string, StuntDouble*>::iterator iter;
158 >
159 >  
160    std::ofstream outputDiff(outputFilename.c_str());
161 <  for (iter = uniqueStuntDoubles.begin(); iter != uniqueStuntDoubles.end(); ++iter) {
162 <    calcHydrodynamicsProp(args_info.model_arg, iter->second, param, outputDiff, prefix);
161 >  std::map<std::string, SDShape>::iterator si;
162 >  for (si = uniqueStuntDoubles.begin(); si != uniqueStuntDoubles.end(); ++si) {
163 >      HydrodynamicsModel* model;
164 >      Shape* shape = si->second.shape;
165 >      StuntDouble* sd = si->second.sd;;
166 >      if (args_info.model_given) {  
167 >        model = HydrodynamicsModelFactory::getInstance()->createHydrodynamicsModel(args_info.model_arg, sd, info);
168 >      } else if (shape->hasAnalyticalSolution()) {
169 >        model = new AnalyticalModel(sd, info);
170 >      } else {
171 >        model = new BeadModel(sd, info);
172 >      }
173 >
174 >        model->init();
175 >        
176 >        std::ofstream ofs;
177 >        std::stringstream outputBeads;
178 >        outputBeads << prefix << "_" << model->getStuntDoubleName() << ".xyz";
179 >        ofs.open(outputBeads.str().c_str());        
180 >        model->writeBeads(ofs);
181 >        ofs.close();
182 >
183 >        //if beads option is turned on, skip the calculation
184 >        if (!args_info.beads_flag) {
185 >          model->calcHydroProps(shape, viscosity, temperature);
186 >          model->writeHydroProps(outputDiff);
187 >        }
188 >        
189 >        delete model;
190    }
191 <  
191 >
192 >
193 >  //MemoryUtils::deletePointers(shapes);
194    delete info;
195    
196   }
# Line 146 | Line 198 | void registerHydrodynamicsModels() {
198   void registerHydrodynamicsModels() {
199      HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<RoughShell>("RoughShell"));
200      HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<BeadModel>("BeadModel"));
201 +    HydrodynamicsModelFactory::getInstance()->registerHydrodynamicsModel(new HydrodynamicsModelBuilder<AnalyticalModel>("AnalyticalModel"));
202  
203   }
151 –
152 – bool calcHydrodynamicsProp(const std::string& modelType, StuntDouble* sd, const DynamicProperty& param, std::ostream& os, const std::string& prefix) {
153 –    HydrodynamicsModel* hydroModel = HydrodynamicsModelFactory::getInstance()->createHydrodynamicsModel(modelType, sd, param);
154 –    bool ret = false;
155 –    if (hydroModel == NULL) {
156 –        std::cout << "Integrator Factory can not create " << modelType <<std::endl;
157 –    }    
158 –
159 –    if (hydroModel->calcHydrodyanmicsProps()) {
160 –        ret = true;        
161 –        hydroModel->writeDiffCenterAndDiffTensor(os);
162 –
163 –        std::ofstream ofs;
164 –        std::stringstream outputBeads;
165 –        outputBeads << prefix << "_" << sd->getType() << ".xyz";
166 –        ofs.open(outputBeads.str().c_str());
167 –        hydroModel->writeBeads(ofs);
168 –        ofs.close();
169 –    }
170 –
171 –    delete hydroModel;
172 –
173 –    return ret;    
174 – }

Diff Legend

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