|
Blender
V2.59
|
00001 00004 /****************************************************************************** 00005 * 00006 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method 00007 * Copyright 2003-2006 Nils Thuerey 00008 * 00009 * Parameter calculator for the LBM Solver class 00010 * 00011 *****************************************************************************/ 00012 00013 #include <sstream> 00014 #include "parametrizer.h" 00015 00016 // debug output flag, has to be off for win32 for some reason... 00017 #define DEBUG_PARAMCHANNELS 0 00018 00020 const char *ParamStrings[] = { 00021 "RelaxTime", 00022 "Reynolds", 00023 "Viscosity", 00024 "SoundSpeed", 00025 "DomainSize", 00026 "GravityForce", 00027 "TimeLength", 00028 "Timestep", 00029 "Size", 00030 "TimeFactor", 00031 "AniFrames", 00032 "AniFrameTime", 00033 "AniStart", 00034 "SurfaceTension", 00035 "Density", 00036 "CellSize", 00037 "GStar", 00038 "MaxSpeed", 00039 "SimMaxSpeed", 00040 "FluidVolHeight", 00041 "NormalizedGStar", 00042 "PSERR", "PSERR", "PSERR", "PSERR" 00043 }; 00044 00045 00046 00047 /****************************************************************************** 00048 * Default constructor 00049 *****************************************************************************/ 00050 Parametrizer::Parametrizer( void ) : 00051 mcViscosity( 8.94e-7 ), 00052 mSoundSpeed( 1500 ), 00053 mDomainSize( 0.1 ), mCellSize( 0.01 ), 00054 mcGravity( ParamVec(0.0) ), 00055 mTimestep(0.0001), mDesiredTimestep(-1.0), 00056 mMaxTimestep(-1.0), 00057 mMinTimestep(-1.0), 00058 mSizex(50), mSizey(50), mSizez(50), 00059 mTimeFactor( 1.0 ), 00060 mcAniFrameTime(0.0001), 00061 mTimeStepScale(1.0), 00062 mAniStart(0.0), 00063 //mExtent(1.0, 1.0, 1.0), //mSurfaceTension( 0.0 ), 00064 mDensity(1000.0), mGStar(0.0001), mFluidVolumeHeight(0.0), 00065 mSimulationMaxSpeed(0.0), 00066 mTadapMaxOmega(2.0), mTadapMaxSpeed(0.1), mTadapLevels(1), 00067 mFrameNum(0), 00068 mSeenValues( 0 ), mCalculatedValues( 0 ) 00069 { 00070 } 00071 00072 00073 /****************************************************************************** 00074 * Destructor 00075 *****************************************************************************/ 00076 Parametrizer::~Parametrizer() 00077 { 00078 /* not much to do... */ 00079 } 00080 00081 /****************************************************************************** 00082 * Init from attr list 00083 *****************************************************************************/ 00084 void Parametrizer::parseAttrList() 00085 { 00086 if(!mpAttrs) { 00087 errFatal("Parametrizer::parseAttrList", "mpAttrs pointer not initialized!", SIMWORLD_INITERROR); 00088 return; 00089 } 00090 00091 // unused 00092 string mSetupType = ""; 00093 mSetupType = mpAttrs->readString("p_setup",mSetupType, "Parametrizer","mSetupType", false); 00094 00095 // real params 00096 if(getAttributeList()->exists("p_viscosity")) { 00097 mcViscosity = mpAttrs->readChannelFloat("p_viscosity"); seenThis( PARAM_VISCOSITY ); } 00098 00099 mSoundSpeed = mpAttrs->readFloat("p_soundspeed",mSoundSpeed, "Parametrizer","mSoundSpeed", false); 00100 if(getAttributeList()->exists("p_soundspeed")) seenThis( PARAM_SOUNDSPEED ); 00101 00102 mDomainSize = mpAttrs->readFloat("p_domainsize",mDomainSize, "Parametrizer","mDomainSize", false); 00103 if(getAttributeList()->exists("p_domainsize")) seenThis( PARAM_DOMAINSIZE ); 00104 if(mDomainSize<=0.0) { 00105 errMsg("Parametrizer::parseAttrList","Invalid real world domain size:"<<mDomainSize<<", resetting to 0.1"); 00106 mDomainSize = 0.1; 00107 } 00108 00109 if(getAttributeList()->exists("p_gravity")) { // || (!mcGravity.isInited()) ) { 00110 mcGravity = mpAttrs->readChannelVec3d("p_gravity"); seenThis( PARAM_GRAVITY ); 00111 } 00112 00113 mTimestep = mpAttrs->readFloat("p_steptime",mTimestep, "Parametrizer","mTimestep", false); 00114 if(getAttributeList()->exists("p_steptime")) seenThis( PARAM_STEPTIME ); 00115 00116 mTimeFactor = mpAttrs->readFloat("p_timefactor",mTimeFactor, "Parametrizer","mTimeFactor", false); 00117 if(getAttributeList()->exists("p_timefactor")) seenThis( PARAM_TIMEFACTOR ); 00118 00119 if(getAttributeList()->exists("p_aniframetime")) { //|| (!mcAniFrameTime.isInited()) ) { 00120 mcAniFrameTime = mpAttrs->readChannelFloat("p_aniframetime");seenThis( PARAM_ANIFRAMETIME ); 00121 } 00122 mTimeStepScale = mpAttrs->readFloat("p_timestepscale",mTimeStepScale, "Parametrizer","mTimeStepScale", false); 00123 00124 mAniStart = mpAttrs->readFloat("p_anistart",mAniStart, "Parametrizer","mAniStart", false); 00125 if(getAttributeList()->exists("p_anistart")) seenThis( PARAM_ANISTART ); 00126 if(mAniStart<0.0) { 00127 errMsg("Parametrizer::parseAttrList","Invalid start time:"<<mAniStart<<", resetting to 0.0"); 00128 mAniStart = 0.0; 00129 } 00130 00131 //mSurfaceTension = mpAttrs->readFloat("p_surfacetension",mSurfaceTension, "Parametrizer","mSurfaceTension", false); 00132 //if(getAttributeList()->exists("p_surfacetension")) seenThis( PARAM_SURFACETENSION ); 00133 00134 mDensity = mpAttrs->readFloat("p_density",mDensity, "Parametrizer","mDensity", false); 00135 if(getAttributeList()->exists("p_density")) seenThis( PARAM_DENSITY ); 00136 00137 ParamFloat cellSize = 0.0; // unused, deprecated 00138 cellSize = mpAttrs->readFloat("p_cellsize",cellSize, "Parametrizer","cellSize", false); 00139 00140 mGStar = mpAttrs->readFloat("p_gstar",mGStar, "Parametrizer","mGStar", false); 00141 if(getAttributeList()->exists("p_gstar")) seenThis( PARAM_GSTAR ); 00142 00143 mNormalizedGStar = mpAttrs->readFloat("p_normgstar",mNormalizedGStar, "Parametrizer","mNormalizedGStar", false); 00144 if(getAttributeList()->exists("p_normgstar")) seenThis( PARAM_NORMALIZEDGSTAR ); 00145 00146 mTadapMaxOmega = mpAttrs->readFloat("p_tadapmaxomega",mTadapMaxOmega, "Parametrizer","mTadapMaxOmega", false); 00147 mTadapMaxSpeed = mpAttrs->readFloat("p_tadapmaxspeed",mTadapMaxSpeed, "Parametrizer","mTadapMaxSpeed", false); 00148 } 00149 00150 /****************************************************************************** 00151 *! advance to next render/output frame 00152 *****************************************************************************/ 00153 void Parametrizer::setFrameNum(int frame) { 00154 mFrameNum = frame; 00155 #if DEBUG_PARAMCHANNELS>0 00156 errMsg("DEBUG_PARAMCHANNELS","setFrameNum frame-num="<<mFrameNum); 00157 #endif // DEBUG_PARAMCHANNELS>0 00158 } 00160 // also used by: mpParam->getCurrentAniFrameTime() , e.g. for velocity dump 00161 ParamFloat Parametrizer::getAniFrameTime( int frame ) { 00162 double frametime = (double)frame; 00163 ParamFloat anift = mcAniFrameTime.get(frametime); 00164 if(anift<0.0) { 00165 ParamFloat resetv = 0.; 00166 errMsg("Parametrizer::setFrameNum","Invalid frame time:"<<anift<<" at frame "<<frame<<", resetting to "<<resetv); 00167 anift = resetv; 00168 } 00169 #if DEBUG_PARAMCHANNELS>0 00170 if((0)|| (DEBUG_PARAMCHANNELS)) errMsg("DEBUG_PARAMCHANNELS","getAniFrameTime frame="<<frame<<", frametime="<<anift<<" "); 00171 #endif // DEBUG_PARAMCHANNELS>0 00172 return anift; 00173 } 00174 00175 /****************************************************************************** 00176 * scale a given speed vector in m/s to lattice values 00177 *****************************************************************************/ 00178 ParamVec Parametrizer::calculateAddForce(ParamVec vec, string usage) 00179 { 00180 ParamVec ret = vec * (mTimestep*mTimestep) /mCellSize; 00181 debMsgStd("Parametrizer::calculateVector", DM_MSG, "scaled vector = "<<ret<<" for '"<<usage<<"', org = "<<vec<<" dt="<<mTimestep ,10); 00182 return ret; 00183 } 00184 00185 00186 /****************************************************************************** 00187 * calculate size of a single cell 00188 *****************************************************************************/ 00189 ParamFloat Parametrizer::calculateCellSize(void) 00190 { 00191 int maxsize = mSizex; // get max size 00192 if(mSizey>maxsize) maxsize = mSizey; 00193 if(mSizez>maxsize) maxsize = mSizez; 00194 maxsize = mSizez; // take along gravity dir for now! 00195 ParamFloat cellSize = 1.0 / (ParamFloat)maxsize; 00196 return cellSize; 00197 } 00198 00199 00200 /*****************************************************************************/ 00201 /* simple calulation functions */ 00202 /*****************************************************************************/ 00203 00205 ParamFloat Parametrizer::calculateOmega( double time ) { 00206 ParamFloat viscStar = calculateLatticeViscosity(time); 00207 ParamFloat relaxTime = (6.0 * viscStar + 1) * 0.5; 00208 #if DEBUG_PARAMCHANNELS>0 00209 errMsg("DEBUG_PARAMCHANNELS","calculateOmega viscStar="<<viscStar<<" relaxtime="<<relaxTime); 00210 #endif // DEBUG_PARAMCHANNELS>0 00211 return (1.0/relaxTime); 00212 } 00213 00215 ParamVec Parametrizer::calculateGravity( double time ) { 00216 ParamVec grav = mcGravity.get(time); 00217 ParamFloat forceFactor = (mTimestep *mTimestep)/mCellSize; 00218 ParamVec latticeGravity = grav * forceFactor; 00219 #if DEBUG_PARAMCHANNELS>0 00220 errMsg("DEBUG_PARAMCHANNELS","calculateGravity grav="<<grav<<" ff"<<forceFactor<<" lattGrav="<<latticeGravity); 00221 #endif // DEBUG_PARAMCHANNELS>0 00222 return latticeGravity; 00223 } 00224 00226 ParamFloat Parametrizer::calculateLatticeViscosity( double time ) { 00227 // check seen values 00228 int reqValues = PARAM_VISCOSITY | PARAM_STEPTIME; 00229 if(!checkSeenValues( reqValues ) ){ 00230 errMsg("Parametrizer::calculateLatticeViscosity"," Missing arguments!"); 00231 } 00232 ParamFloat viscStar = mcViscosity.get(time) * mTimestep / (mCellSize*mCellSize); 00233 #if DEBUG_PARAMCHANNELS>0 00234 errMsg("DEBUG_PARAMCHANNELS","calculateLatticeViscosity viscStar="<<viscStar); 00235 #endif // DEBUG_PARAMCHANNELS>0 00236 return viscStar; 00237 } 00238 00240 int Parametrizer::calculateStepsForSecs( ParamFloat s ) { 00241 return (int)(s/mTimestep); 00242 } 00243 00245 int Parametrizer::calculateAniStart( void ) { 00246 return (int)(mAniStart/mTimestep); 00247 } 00248 00250 int Parametrizer::calculateAniStepsPerFrame(int frame) { 00251 if(!checkSeenValues(PARAM_ANIFRAMETIME)) { 00252 errFatal("Parametrizer::calculateAniStepsPerFrame", "Missing ani frame time argument!", SIMWORLD_INITERROR); 00253 return 1; 00254 } 00255 int value = (int)(getAniFrameTime(frame)/mTimestep); 00256 if((value<0) || (value>1000000)) { 00257 errFatal("Parametrizer::calculateAniStepsPerFrame", "Invalid step-time (="<<value<<") <> ani-frame-time ("<<mTimestep<<") settings, aborting...", SIMWORLD_INITERROR); 00258 return 1; 00259 } 00260 return value; 00261 } 00262 00264 int Parametrizer::calculateNoOfSteps( ParamFloat timelen ) { 00265 return (int)(timelen/mTimestep); 00266 } 00267 00269 //ParamVec Parametrizer::calculateExtent( void ) { 00270 //return mExtent; 00271 //} 00272 00274 //ParamFloat Parametrizer::calculateSurfaceTension( void ) { return mSurfaceTension; } 00275 00277 // explicity scaled by time factor for refinement 00278 ParamFloat Parametrizer::getTimestep( void ) { 00279 return mTimestep; 00280 } 00281 00283 ParamVec Parametrizer::calculateLattVelocityFromRw( ParamVec ivel ) { 00284 ParamVec velvec = ivel; 00285 velvec /= mCellSize; 00286 velvec *= mTimestep; 00287 return velvec; 00288 } 00290 ParamVec Parametrizer::calculateRwVelocityFromLatt( ParamVec ivel ) { 00291 ParamVec velvec = ivel; 00292 velvec *= mCellSize; 00293 velvec /= mTimestep; 00294 return velvec; 00295 } 00296 00297 00299 ParamFloat Parametrizer::getCurrentGStar( void ) { 00300 ParamFloat gStar = mGStar; // check? TODO get from mNormalizedGStar? 00301 if(mFluidVolumeHeight>0.0) { gStar = mGStar/mFluidVolumeHeight; } 00302 return gStar; 00303 } 00304 00305 /****************************************************************************** 00306 * function that tries to calculate all the missing values from the given ones 00307 * prints errors and returns false if thats not possible 00308 *****************************************************************************/ 00309 bool Parametrizer::calculateAllMissingValues( double time, bool silent ) 00310 { 00311 bool init = false; // did we init correctly? 00312 int valuesChecked = 0; 00313 int reqValues; 00314 00315 // we always need the sizes 00316 reqValues = PARAM_SIZE; 00317 valuesChecked |= reqValues; 00318 if(!checkSeenValues(reqValues)) { 00319 errMsg("Parametrizer::calculateAllMissingValues"," Missing size argument!"); 00320 return false; 00321 } 00322 00323 if(!checkSeenValues(PARAM_DOMAINSIZE)) { 00324 errMsg("Parametrizer::calculateAllMissingValues"," Missing domain size argument!"); 00325 return false; 00326 } 00327 int maxsize = mSizex; // get max size 00328 if(mSizey>maxsize) maxsize = mSizey; 00329 if(mSizez>maxsize) maxsize = mSizez; 00330 maxsize = mSizez; // take along gravity dir for now! 00331 mCellSize = ( mDomainSize * calculateCellSize() ); // sets mCellSize 00332 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," max domain resolution="<<(maxsize)<<" cells , cellsize="<<mCellSize ,10); 00333 00334 00335 /* Carolin init , see DA for details */ 00336 ParamFloat maxDeltaT = 0.0; 00337 00338 /* normalized gstar init */ 00339 reqValues = PARAM_NORMALIZEDGSTAR; 00340 valuesChecked |= reqValues; 00341 if(checkSeenValues( reqValues ) ){ 00342 //if(checkSeenValues( PARAM_GSTAR ) ){ if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_WARNING," g star value override by normalizedGStar!",1); } 00343 const ParamFloat normgstarReset = 0.005; 00344 if(mNormalizedGStar<=1e-6) { 00345 errMsg("Parametrizer::calculateAllMissingValues","Invalid NormGstar: "<<mNormalizedGStar<<"... resetting to "<<normgstarReset); 00346 mNormalizedGStar = normgstarReset; 00347 } 00348 00349 mGStar = mNormalizedGStar/maxsize; 00350 00351 // TODO FIXME add use testdata check! 00352 mGStar = mNormalizedGStar/mSizez; 00353 errMsg("Warning","Used z-dir for gstar!"); 00354 00355 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," g star set to "<<mGStar<<" from normalizedGStar="<<mNormalizedGStar ,1); 00356 seenThis(PARAM_GSTAR); 00357 } 00358 00359 reqValues = PARAM_GSTAR | PARAM_VISCOSITY; 00360 if((checkSeenValues(PARAM_SURFACETENSION))) reqValues |= PARAM_DENSITY; // surface tension optional now... 00361 valuesChecked |= reqValues; 00362 if(checkSeenValues( reqValues ) ){ 00363 const ParamFloat gstarReset = 0.0005; 00364 if(getCurrentGStar()<=1e-6) { 00365 errMsg("Parametrizer::calculateAllMissingValues","Invalid Gstar: "<<getCurrentGStar()<<" (set to "<<mGStar<<") ... resetting to "<<gstarReset); 00366 mGStar = gstarReset; 00367 } 00368 00369 ParamFloat gStar = getCurrentGStar(); // mGStar 00370 if(mFluidVolumeHeight>0.0) { 00371 debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," height"<<mFluidVolumeHeight<<" resGStar = "<<gStar, 10); 00372 } 00373 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," g star = "<<gStar, 10); 00374 00375 ParamFloat forceStrength = 0.0; 00376 //if(checkSeenValues(PARAM_GRAVITY)) { forceStrength = norm( calculateGravity(time) ); } 00377 if(checkSeenValues(PARAM_GRAVITY)) { forceStrength = norm( mcGravity.get(time) ); } 00378 00379 // determine max. delta density per timestep trough gravity force 00380 if(forceStrength>0.0) { 00381 maxDeltaT = sqrt( gStar*mCellSize *mTimeStepScale /forceStrength ); 00382 } else { 00383 // use 1 lbm setp = 1 anim step as max 00384 maxDeltaT = getAniFrameTime(0); 00385 } 00386 00387 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," targeted step time = "<<maxDeltaT, 10); 00388 00389 //ParamFloat viscStarFac = mViscosity/(mCellSize*mCellSize); 00390 //if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," viscStarFac = "<<viscStarFac<<" viscosity:"<<mViscosity, 10); 00391 00392 // time step adaptivty, only for caro with max sim speed 00393 ParamFloat setDeltaT = maxDeltaT; 00394 if(mDesiredTimestep>0.0) { 00395 // explicitly set step time according to max velocity in sim 00396 setDeltaT = mDesiredTimestep; 00397 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," desired step time = "<<setDeltaT, 10); 00398 mDesiredTimestep = -1.0; 00399 } else { 00400 // just use max delta t as current 00401 } 00402 00403 // and once for init determine minimal delta t by omega max. 00404 if((mMinTimestep<0.0) || (mMaxTimestep<0.0)) { 00405 ParamFloat minDeltaT; 00406 ParamFloat maxOmega = mTadapMaxOmega; 00407 ParamFloat minRelaxTime = 1.0/maxOmega; 00408 for(int lev=1; lev<mTadapLevels; lev++) { 00409 // make minRelaxTime larger for each level that exists... 00410 minRelaxTime = 2.0 * (minRelaxTime-0.5) + 0.5; 00411 } 00412 maxOmega = 1.0/minRelaxTime; 00413 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," maxOmega="<<maxOmega<<" minRelaxTime="<<minRelaxTime<<" levels="<<mTadapLevels, 1); 00414 // visc-star for min relax time to calculate min delta ta 00415 if(mcViscosity.get(time)>0.0) { 00416 minDeltaT = ((2.0*minRelaxTime-1.0)/6.0) * mCellSize * mCellSize / mcViscosity.get(time); 00417 } else { 00418 // visc=0, this is not physical, but might happen 00419 minDeltaT = 0.0; 00420 } 00421 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," min delta t = "<<minDeltaT<<" , range = " << (maxDeltaT/minDeltaT) ,1); 00422 00423 // sim speed + accel shouldnt exceed 0.1? 00424 mMaxTimestep = maxDeltaT; 00425 mMinTimestep = minDeltaT; 00426 // only use once... 00427 } 00428 00429 setTimestep( setDeltaT ); // set mTimestep to new value 00430 init = true; 00431 } 00432 00433 // finish init 00434 if(init) { 00435 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," omega = "<<calculateOmega(0.0)<<", delt="<<mTimestep,1); 00436 00437 if(checkSeenValues(PARAM_GRAVITY)) { 00438 ParamFloat forceFactor = (mTimestep *mTimestep)/mCellSize; // only used for printing... 00439 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," gravity force = "<<PRINT_NTLVEC(mcGravity.get(time))<<", scaled with "<<forceFactor<<" to "<<calculateGravity(time),1); 00440 } 00441 00442 //mExtent = ParamVec( mCellSize*mSizex, mCellSize*mSizey, mCellSize*mSizez ); 00443 //if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," domain extent = "<<PRINT_NTLVEC(mExtent)<<"m , gs:"<<PRINT_VEC(mSizex,mSizey,mSizez)<<" cs:"<<mCellSize,1); 00444 00445 if(!checkSeenValues(PARAM_ANIFRAMETIME)) { 00446 errFatal("Parametrizer::calculateAllMissingValues"," Warning no ani frame time given!", SIMWORLD_INITERROR); 00447 setAniFrameTimeChannel( mTimestep ); 00448 } 00449 00450 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," ani frame steps = "<<calculateAniStepsPerFrame(mFrameNum)<<" for frame "<<mFrameNum, 1); 00451 00452 if((checkSeenValues(PARAM_ANISTART))&&(calculateAniStart()>0)) { 00453 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," ani start steps = "<<calculateAniStart()<<" ",1); 00454 } 00455 00456 if(! isSimworldOk() ) return false; 00457 // everything ok 00458 return true; 00459 } 00460 00461 // init failed ... failure: 00462 errMsg("Parametrizer::calculateAllMissingValues "," invalid configuration!"); 00463 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues ",DM_WARNING, " values seen:", 1); 00464 for(int i=0;i<PARAM_NUMIDS;i++) { 00465 if(checkSeenValues( 1<<i )) { 00466 if(!silent) debMsgStd(" ",DM_NOTIFY, ParamStrings[i], 1); 00467 } 00468 } 00469 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues ",DM_WARNING, "values checked but missing:", 1); 00470 for(int i=0;i<PARAM_NUMIDS;i++) { 00471 if((!checkSeenValues( 1<<i ))&& 00472 ( (valuesChecked&(1<<i))==(1<<i)) ) { 00473 debMsgStd(" ",DM_IMPORTANT, ParamStrings[i], 1); 00474 } 00475 } 00476 00477 // print values? 00478 return false; 00479 } 00480 00481 00482 /****************************************************************************** 00483 * init debug functions 00484 *****************************************************************************/ 00485 00486 00488 void Parametrizer::setViscosity(ParamFloat set) { 00489 mcViscosity = AnimChannel<ParamFloat>(set); 00490 seenThis( PARAM_VISCOSITY ); 00491 #if DEBUG_PARAMCHANNELS>0 00492 { errMsg("DebugChannels","Parametrizer::mcViscosity set = "<< mcViscosity.printChannel() ); } 00493 #endif // DEBUG_PARAMCHANNELS>0 00494 } 00495 void Parametrizer::initViscosityChannel(vector<ParamFloat> val, vector<double> time) { 00496 mcViscosity = AnimChannel<ParamFloat>(val,time); 00497 seenThis( PARAM_VISCOSITY ); 00498 #if DEBUG_PARAMCHANNELS>0 00499 { errMsg("DebugChannels","Parametrizer::mcViscosity initc = "<< mcViscosity.printChannel() ); } 00500 #endif // DEBUG_PARAMCHANNELS>0 00501 } 00502 00504 void Parametrizer::setGravity(ParamFloat setx, ParamFloat sety, ParamFloat setz) { 00505 mcGravity = AnimChannel<ParamVec>(ParamVec(setx,sety,setz)); 00506 seenThis( PARAM_GRAVITY ); 00507 #if DEBUG_PARAMCHANNELS>0 00508 { errMsg("DebugChannels","Parametrizer::mcGravity set = "<< mcGravity.printChannel() ); } 00509 #endif // DEBUG_PARAMCHANNELS>0 00510 } 00511 void Parametrizer::setGravity(ParamVec set) { 00512 mcGravity = AnimChannel<ParamVec>(set); 00513 seenThis( PARAM_GRAVITY ); 00514 #if DEBUG_PARAMCHANNELS>0 00515 { errMsg("DebugChannels","Parametrizer::mcGravity set = "<< mcGravity.printChannel() ); } 00516 #endif // DEBUG_PARAMCHANNELS>0 00517 } 00518 void Parametrizer::initGravityChannel(vector<ParamVec> val, vector<double> time) { 00519 mcGravity = AnimChannel<ParamVec>(val,time); 00520 seenThis( PARAM_GRAVITY ); 00521 #if DEBUG_PARAMCHANNELS>0 00522 { errMsg("DebugChannels","Parametrizer::mcGravity initc = "<< mcGravity.printChannel() ); } 00523 #endif // DEBUG_PARAMCHANNELS>0 00524 } 00525 00527 void Parametrizer::setAniFrameTimeChannel(ParamFloat set) { 00528 mcAniFrameTime = AnimChannel<ParamFloat>(set); 00529 seenThis( PARAM_ANIFRAMETIME ); 00530 #if DEBUG_PARAMCHANNELS>0 00531 { errMsg("DebugChannels","Parametrizer::mcAniFrameTime set = "<< mcAniFrameTime.printChannel() ); } 00532 #endif // DEBUG_PARAMCHANNELS>0 00533 } 00534 void Parametrizer::initAniFrameTimeChannel(vector<ParamFloat> val, vector<double> time) { 00535 mcAniFrameTime = AnimChannel<ParamFloat>(val,time); 00536 seenThis( PARAM_ANIFRAMETIME ); 00537 #if DEBUG_PARAMCHANNELS>0 00538 { errMsg("DebugChannels","Parametrizer::mcAniFrameTime initc = "<< mcAniFrameTime.printChannel() ); } 00539 #endif // DEBUG_PARAMCHANNELS>0 00540 } 00541 00542 // OLD interface stuff 00543 // reactivate at some point? 00544 00546 //ParamFloat mSurfaceTension; 00548 //void setSurfaceTension(ParamFloat set) { mSurfaceTension = set; seenThis( PARAM_SURFACETENSION ); } 00550 //ParamFloat getSurfaceTension( void ) { return mSurfaceTension; } 00551 /*if((checkSeenValues(PARAM_SURFACETENSION))&&(mSurfaceTension>0.0)) { 00552 ParamFloat massDelta = 1.0; 00553 ParamFloat densityStar = 1.0; 00554 massDelta = mDensity / densityStar *mCellSize*mCellSize*mCellSize; 00555 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," massDelta = "<<massDelta, 10); 00556 00557 mSurfaceTension = mSurfaceTension*mTimestep*mTimestep/massDelta; 00558 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," surface tension = "<<mSurfaceTension<<" ",1); 00559 } // */ 00560 00561 // probably just delete: 00562 00564 //ParamFloat mReynolds; 00565 00567 //void setRelaxTime(ParamFloat set) { mRelaxTime = set; seenThis( PARAM_RELAXTIME ); } 00569 //ParamFloat getRelaxTime( void ) { return mRelaxTime; } 00571 //void setReynolds(ParamFloat set) { mReynolds = set; seenThis( PARAM_REYNOLDS ); } 00573 //ParamFloat getReynolds( void ) { return mReynolds; } 00574 00575 // calculate reynolds number 00576 /*if(mViscosity>0.0) { 00577 ParamFloat maxSpeed = 1.0/6.0; // for rough reynolds approx 00578 ParamFloat reynoldsApprox = -1.0; 00579 ParamFloat gridSpeed = (maxSpeed*mCellSize/mTimestep); 00580 reynoldsApprox = (mDomainSize*gridSpeed) / mViscosity; 00581 if(!silent) debMsgStd("Parametrizer::calculateAllMissingValues",DM_MSG," reynolds number (D="<<mDomainSize<<", assuming V="<<gridSpeed<<")= "<<reynoldsApprox<<" ", 1); 00582 } // */ 00583 00584 //? mRelaxTime = mpAttrs->readFloat("p_relaxtime",mRelaxTime, "Parametrizer","mRelaxTime", false); 00585 //if(getAttributeList()->exists("p_relaxtime")) seenThis( PARAM_RELAXTIME ); 00586 //? mReynolds = mpAttrs->readFloat("p_reynolds",mReynolds, "Parametrizer","mReynolds", false); 00587 //if(getAttributeList()->exists("p_reynolds")) seenThis( PARAM_REYNOLDS ); 00588 00589 //mViscosity = mpAttrs->readFloat("p_viscosity",mViscosity, "Parametrizer","mViscosity", false); 00590 //if(getAttributeList()->exists("p_viscosity") || (!mcViscosity.isInited()) ) { } 00591 //if(getAttributeList()->exists("p_viscosity")) 00592 00593 00594 //ParamFloat viscStar = calculateLatticeViscosity(time); 00595 //RelaxTime = (6.0 * viscStar + 1) * 0.5; 00596 00597