TextBox::TextBox(int w, int h)
{
shader = LoadShaders("Shaders/Text/textBox.vert", "Shaders/Text/textBox.frag");
WIDTH = w;
HEIGHT = h;
InitParameters();
}
/**
* @fn Initialize()
* @brief Setup the simulation.
*/
void Initialize()
{
// Initialize the UI
InitParameters();
// First initialize extensions.
int err = glewInit();
if (GLEW_OK != err)
{
/* problem: glewInit failed, something is seriously wrong */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit(-1);
}
// Create the Cg context
cgSetErrorCallback(cgErrorCallback);
// Create cgContext.
g_cgContext = cgCreateContext();
// Create and initialize the Flo simulator object
g_pFlo = new Flo(g_iFloWidth, g_iFloHeight);
g_pFlo->Initialize(g_cgContext);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
}
IDirect3DDevice9* CreateDevice9(HINSTANCE dll, IDirect3D9** d3d9, D3DADAPTER_IDENTIFIER9 *d3dai)
{
qDebug("creating d3d9 device...");
typedef IDirect3D9* (WINAPI *Create9Func)(UINT SDKVersion);
Create9Func Create9 = (Create9Func)GetProcAddress(dll, "Direct3DCreate9");
if (!Create9) {
qWarning("Symbol not found: Direct3DCreate9");
return NULL;
}
*d3d9 = Create9(D3D_SDK_VERSION);
if (!(*d3d9)) {
qWarning("Direct3DCreate9 failed");
return NULL;
}
if (d3dai)
DX_WARN((*d3d9)->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, d3dai));
D3DPRESENT_PARAMETERS d3dpp;
InitParameters(&d3dpp);
DWORD flags = D3DCREATE_FPU_PRESERVE | D3DCREATE_MULTITHREADED | D3DCREATE_MIXED_VERTEXPROCESSING;
IDirect3DDevice9 *d3d9dev = NULL;
DX_ENSURE(((*d3d9)->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, GetShellWindow(),// GetDesktopWindow(), //GetShellWindow()?
flags,
&d3dpp, &d3d9dev))
, NULL);
qDebug("IDirect3DDevice9 created");
return d3d9dev;
}
//----------------------------------------------------------
// Ctor
//----------------------------------------------------------
TapCamera::TapCamera() :
dragging_( false ),
pinching_( false ),
momentum_( false ),
ball_radius_( 0.75f ),
pinch_start_distance_SQ_( 0.f ),
camera_rotation_( 0.f ),
camera_rotation_start_( 0.f ),
camera_rotation_now_( 0.f ),
momemtum_steps_( 0.f ),
flip_z_( 0.f )
{
//Init offset
InitParameters();
vec_flip_ = Vec2( 1.f, -1.f );
flip_z_ = -1.f;
vec_pinch_transform_factor_ = Vec3( 1.f, 1.f, 1.f );
vec_ball_center_ = Vec2( 0, 0 );
vec_ball_now_ = Vec2( 0, 0 );
vec_ball_down_ = Vec2( 0, 0 );
vec_pinch_start_ = Vec2( 0, 0 );
vec_pinch_start_center_ = Vec2( 0, 0 );
vec_flip_ = Vec2( 0, 0 );
}
QSimpleTextItem::QSimpleTextItem()
{
sTEXT = "Text"; //默认文本
m_rect.setRect(0,0,100,100); //给背景矩形赋初始值
InitParameters();
}
//Function to Call the above Initialization Function in the Proper Order so as to assure that all inter-dependencies between successive calls are met. The argument defines which branch will be initialized
void PairInitializer::MakeProperInitializations(int branch, IntMatRef Homologies) {
//A. Make General Initializations in proper order to ensure proper tree construction and parameters intialization //{
//1. Initialize the Parameters from the Parameters File
InitParameters();
//2. Initialize the Rand Number Generator Engine by creating a new instance of the BoostRandomGenerator class
InitRandomGenerator();
//3. Initialize the Number of Steps that the left-right subtree resampling will be performed (from the previously created Parameters instance)
InitNumOfSteps();
//4. Initialize the Sequences (i.e. Bare Seqeunces, Initial Alignment, Sequence Headers etc) from the Corresponding Input Files
InitSequences();
//5. Initialize the AlignmentHomologies based on the previously read initial alignment
InitAlignmentHomologies(Homologies);
//6. Initialize (create) the Felsenstein Tree structure based on the red sequences and parameters
InitTree();
//7. Now that the tree structure is ready, Initialize ALL the Substitution Matrices for EVERY possible length of the Tree (and based on the defined - by the parameters - substitution model)
InitOverallSubstitutionMatrices();
//8.In a same way as before, now that the tree structure is ready, Initialize ALL the Felsenstein Pruning Tables for EVERY Node of the tree
InitTreeFPTables();
//}
//B. Proceed to Make Proper Initializations for the variables and parameters concerning ONLY the subtree of interest (i.e. either the left or the right subtree) //{
//1. Initialize the Subtree parameter to be aware of which subtree is being resampled
InitBranch(branch);
//2. Initialize the corresponding SubtreeIdxs for the current subtree
InitBranchIdxs();
//3. Initialize the Lengths corresponding only to the current subtree
InitLengths();
//4. Initialize the FPTables corresponding only to the current subtree
InitFPTables();
//5. Initialize (calculate) the Corresponding RegionHomologies based on the AlignmentHomologies corresponding only to the current fragment
InitRegionHomologies();
//6. Initialize the Start and End Indices for the current subtree
InitStartAndEndIndices();
//7. Initialize the Substitution Matrices corresponding only to the current subtree (and equivalently to the current subtree's lengths)
InitSubstitutionMatrices();
//8. Initialize the Dimensions (based on the previously estimated EndIdxs) corresponding to the current subtree
InitDimensions();
//9. Now that everything is properly initialized, proceed to resample the whole alignment region (considering the given homologies) in order to come up with an evolution history, the Soans, the SoansIdxs and the Tihls for EVERY positon of the Root node (defined by the current subtree)
ResampleHistoryGivenHomologies();
//}
}
RooPolynomialFixEdgeNew::RooPolynomialFixEdgeNew(const RooPolynomialFixEdgeNew& other, const char* name) :
RooAbsPdf(other,name),x("x",this,other.x),
histo(other.histo),yield(other.yield),
c3("c3",this,other.c3),c4("c4",this,other.c4),c5("c5",this,other.c5),
c6("c6",this,other.c6),c7("c7",this,other.c7),c8("c8",this,other.c8),
c9("c9",this,other.c9),c10("c10",this,other.c10)
{
if(!InitParameters())
cout<<"Warning:"<<name<<" paramaters are not right at initialization"<<endl<<endl<<endl;
}
logical OPFunctionDecl :: Call (PropertyHandle *co, ParmList *parm_list, int8 set_operation )
{
logical term = NO;
InitParameters(parm_list);
term = CallIntern(co,set_operation);
DeInitParameters();
return(term);
}
bool CCommonParm::Init(int argc, char *argv[]) {
if (!AnalizeParameters(argc, argv))
return false;
if (!CheckParameters())
return false;
if (!InitParameters())
return false;
return true;
}
//-------------------------------------------------------------------------------
//
// DoParameters
//
// Makes sure we have valid Data and Parameters handle(s). Locks and initializes
// these items.
//
// NOTE:
// This routine is NOT guaranteed to be called by Photoshop. If a user enters the
// CTRL-F keyboard shortcut to invoke the last filter command this routine will
// NOT be called. If the filter is ran by the actions pallete or an automation
// plug in this routine will NOT be called.
//
// NOTE:
// The fields in the gFilterRecord are not all valid at this stage.
//-------------------------------------------------------------------------------
void DoParameters(void)
{
if (gFilterRecord->parameters == NULL)
CreateParametersHandle();
if ((*gDataHandle) == 0)
CreateDataHandle();
if (*gResult == noErr)
{
LockHandles();
InitParameters();
InitData();
}
}
int ActingAsServer(int argc, char* argv[], bool dbg) {
SerialCom comm;
PipeShell shell;
int nPort = 1;
int nBaud = 9600;
int nBits = 8;
int nStop = 1;
char cParity = 'N';
char sIfName[32];
char sLcdDev[32];
int distance = 26000;
int neg_mode = 0;
bool trace_gws = dbg;
bool trace_lcd = false;
bool trace_neg = false;
memset(sIfName, 0x00, 32);
memset(sLcdDev, 0x00, 32);
strcpy(sIfName, "wlan0");
strcpy(sLcdDev, "/dev/ttyS0");
if (svrInitInstance()) {
InitParameters(true);
BufInit(&local_gws_buff);
ScInit(&comm, 0); //nonblock mode
ReadFileConf(&comm, &nPort, &nBaud, &nBits, &nStop, &cParity,
sIfName,sLcdDev,&distance,&neg_mode,
&trace_gws,&trace_lcd,&trace_neg);
ReadCmdLine(argc, argv, &nPort, &nBaud, &nBits, &nStop, &cParity,
&trace_lcd,&trace_neg);
if (false == ScOpen(&comm, nPort, nBaud, nBits, nStop, cParity)) {
ShowStatusBar("%s", "Can not open GWS radio port.\n");
} else {
ShowStatusBar("%s", "GWS port OK.\n");
}
PipeShellInit(&shell);
svrInitCommandHandler(&comm,&shell,sIfName,trace_gws);
ShowStatusBar("%s" VT100_RESET "\n", "gwsman server ready.\n");
if (lcd_main(sLcdDev,distance,neg_mode,trace_lcd,trace_neg) < 0) {
printf("\n\n");
fflush(stdout);
while (svrTestInstance(static_chp.m_semInstance)) usleep(100000);
} else fflush(stdout);
ScExit(&comm);
BufExit(&local_gws_buff);
svrExitCommandHandler();
}
svrExitInstance();
return 1;
}
//-------------------------------------------------------------------------------
//
// DoPrepare
//
// Almost identical to DoParameters. Make sure we have valid Data and Parameters
// handle(s) and lock and initialize as necessary. Sets the bufferSpace and
// maxSpace variables in the gFilterRecord so memory is used at an optimum.
//
// NOTE:
// The fields in the gFilterRecord are not all valid at this stage. We will take a
// guess at the actual tile size information.
//
//-------------------------------------------------------------------------------
void DoPrepare(void)
{
if (gFilterRecord->parameters != NULL && (*gDataHandle) != 0)
LockHandles();
else
{
if (gFilterRecord->parameters == NULL)
CreateParametersHandle();
if ((*gDataHandle) == 0)
CreateDataHandle();
if (*gResult == noErr)
{
LockHandles();
InitParameters();
InitData();
}
}
// we don't need any buffer space
gFilterRecord->bufferSpace = 0;
// give as much memory back to Photoshop as you can
// we only need a tile per plane plus the maskData
// inTileHeight and inTileWidth are invalid at this
// point. Assume the tile size is 256 max.
VRect filterRect = GetFilterRect();
int32 tileHeight = filterRect.bottom - filterRect.top;
int32 tileWidth = filterRect.right - filterRect.left;
if (tileHeight > 256)
tileHeight = 256;
if (tileWidth > 256)
tileWidth = 256;
int32 tileSize = tileHeight * tileWidth;
int32 planes = gFilterRecord->planes;
if (gFilterRecord->maskData != NULL)
planes++;
// duplicate because we have two copies, inData and outData
planes *= 2;
int32 totalSize = tileSize * planes;
// this is worst case and can be dropped considerably
if (gFilterRecord->maxSpace > totalSize)
gFilterRecord->maxSpace = totalSize;
}
RooPolynomialFixEdgeNew::RooPolynomialFixEdgeNew(const char *name, const char *title,RooAbsReal& _x,
TH1*Histo,RooFormula* Yield,RooAbsReal& _c3,RooAbsReal& _c4,RooAbsReal& _c5,
RooAbsReal& _c6,RooAbsReal& _c7,RooAbsReal& _c8,RooAbsReal& _c9,RooAbsReal& _c10) :
RooAbsPdf(name,title),
x("x","Dependent",this,_x),
histo(Histo),
yield(Yield),
c3("c3","c3",this,_c3),
c4("c4","c4",this,_c4),
c5("c5","c5",this,_c5),
c6("c6","c6",this,_c6),
c7("c7","c7",this,_c7),
c8("c8","c8",this,_c8),
c9("c9","c9",this,_c9),
c10("c10","c10",this,_c10)
{
if(!InitParameters())
cout<<"Warning:"<<name<<" paramaters are not right at initialization"<<endl<<endl<<endl;
}
//=======================================================================
//function : ShHealOper_FillHoles()
//purpose : Constructor
//=======================================================================
ShHealOper_FillHoles::ShHealOper_FillHoles ()
{
InitParameters();
}
void TapCamera::Reset( const bool bAnimate )
{
InitParameters();
Update();
}
int main(int argc, char **argv)
{
float *Hydrograph = NULL;
float ***MM5Input = NULL;
float **PrecipLapseMap = NULL;
float **PrismMap = NULL;
unsigned char ***ShadowMap = NULL;
float **SkyViewMap = NULL;
float ***WindModel = NULL;
int MaxStreamID, MaxRoadID;
float SedDiams[NSEDSIZES]; /* Sediment particle diameters (mm) */
clock_t start, finish1;
double runtime = 0.0;
int t = 0;
float roadarea;
time_t tloc;
int flag;
int i;
int j;
int x; /* row counter */
int y; /* column counter */
int shade_offset; /* a fast way of handling arraay position given the number of mm5 input options */
int NStats; /* Number of meteorological stations */
uchar ***MetWeights = NULL; /* 3D array with weights for interpolating meteorological variables between the stations */
int NGraphics; /* number of graphics for X11 */
int *which_graphics; /* which graphics for X11 */
char buffer[32];
AGGREGATED Total = { /* Total or average value of a variable over the entire basin */
{0.0, NULL, NULL, NULL, NULL, 0.0}, /* EVAPPIX */
{0.0, 0.0, 0.0, 0.0, 0.0, NULL, NULL, 0.0, 0, 0.0}, /* PRECIPPIX */
{{0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, 0.0, 0.0, 0.0}, /* PIXRAD */
{0.0, 0.0}, /* RADCLASSPIX */
{0.0, 0.0, 0, NULL, NULL, 0.0, 0, 0.0, 0.0, 0.0, 0.0, NULL,
NULL, NULL, NULL, NULL, NULL, 0.0}, /* ROADSTRUCT*/
{0, 0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, /* SNOWPIX */
{0, 0.0, NULL, NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, /*SOILPIX */
{ 0.0, 0.0, 0.0, 0.0, 0.0}, /*SEDPIX */
{ 0.0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, /*FINEPIX */
0.0, 0.0, 0.0, 0.0, 0.0, 0l, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
};
CHANNEL ChannelData = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL};
DUMPSTRUCT Dump;
EVAPPIX **EvapMap = NULL;
INPUTFILES InFiles;
LAYER Soil;
LAYER Veg;
LISTPTR Input = NULL; /* Linked list with input strings */
MAPSIZE Map; /* Size and location of model area */
MAPSIZE Radar; /* Size and location of area covered by precipitation radar */
MAPSIZE MM5Map; /* Size and location of area covered by MM5 input files */
METLOCATION *Stat = NULL;
OPTIONSTRUCT Options; /* Structure with information which program options to follow */
PIXMET LocalMet; /* Meteorological conditions for current pixel */
FINEPIX ***FineMap = NULL;
PRECIPPIX **PrecipMap = NULL;
RADARPIX **RadarMap = NULL;
RADCLASSPIX **RadMap = NULL;
PIXRAD **RadiationMap = NULL;
ROADSTRUCT **Network = NULL; /* 2D Array with channel information for each pixel */
SNOWPIX **SnowMap = NULL;
MET_MAP_PIX **MetMap = NULL;
SNOWTABLE *SnowAlbedo = NULL;
SOILPIX **SoilMap = NULL;
SEDPIX **SedMap = NULL;
SOILTABLE *SType = NULL;
SEDTABLE *SedType = NULL;
SOLARGEOMETRY SolarGeo; /* Geometry of Sun-Earth system (needed for INLINE radiation calculations */
TIMESTRUCT Time;
TOPOPIX **TopoMap = NULL;
UNITHYDR **UnitHydrograph = NULL;
UNITHYDRINFO HydrographInfo; /* Information about unit hydrograph */
VEGPIX **VegMap = NULL;
VEGTABLE *VType = NULL;
WATERBALANCE Mass = /* parameter for mass balance calculations */
{ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
/*****************************************************************************
Initialization Procedures
*****************************************************************************/
if (argc != 2) {
fprintf(stderr, "\nUsage: %s inputfile\n\n", argv[0]);
fprintf(stderr, "DHSVM uses two output streams: \n");
fprintf(stderr, "Standard Out, for the majority of output \n");
fprintf(stderr, "Standard Error, for the final mass balance \n");
fprintf(stderr, "\nTo pipe output correctly to files: \n");
fprintf(stderr, "(cmd > f1) >& f2 \n");
fprintf(stderr, "where f1 is stdout_file and f2 is stderror_file\n");
exit(EXIT_FAILURE);
}
sprintf(commandline, "%s %s", argv[0], argv[1]);
printf("%s \n", commandline);
fprintf(stderr, "%s \n", commandline);
strcpy(InFiles.Const, argv[1]);
printf("\nRunning DHSVM %s\n", version);
printf("\nSTARTING INITIALIZATION PROCEDURES\n\n");
/* Start recording time */
start = clock();
ReadInitFile(InFiles.Const, &Input);
InitConstants(Input, &Options, &Map, &SolarGeo, &Time);
InitFileIO(Options.FileFormat);
InitTables(Time.NDaySteps, Input, &Options, &SType, &Soil, &VType, &Veg,
&SnowAlbedo);
InitTerrainMaps(Input, &Options, &Map, &Soil, &TopoMap, &SoilMap, &VegMap);
CheckOut(Options.CanopyRadAtt, Veg, Soil, VType, SType, &Map, TopoMap,
VegMap, SoilMap);
if (Options.HasNetwork)
InitChannel(Input, &Map, Time.Dt, &ChannelData, SoilMap, &MaxStreamID, &MaxRoadID, &Options);
else if (Options.Extent != POINT)
InitUnitHydrograph(Input, &Map, TopoMap, &UnitHydrograph,
&Hydrograph, &HydrographInfo);
InitNetwork(Map.NY, Map.NX, Map.DX, Map.DY, TopoMap, SoilMap,
VegMap, VType, &Network, &ChannelData, Veg, &Options);
InitMetSources(Input, &Options, &Map, Soil.MaxLayers, &Time,
&InFiles, &NStats, &Stat, &Radar, &MM5Map);
/* the following piece of code is for the UW PRISM project */
/* for real-time verification of SWE at Snotel sites */
/* Other users, set OPTION.SNOTEL to FALSE, or use TRUE with caution */
if (Options.Snotel == TRUE && Options.Outside == FALSE) {
printf
("Warning: All met stations locations are being set to the vegetation class GLACIER\n");
printf
("Warning: This requires that you have such a vegetation class in your vegetation table\n");
printf("To disable this feature set Snotel OPTION to FALSE\n");
for (i = 0; i < NStats; i++) {
printf("veg type for station %d is %d ", i,
VegMap[Stat[i].Loc.N][Stat[i].Loc.E].Veg);
for (j = 0; j < Veg.NTypes; j++) {
if (VType[j].Index == GLACIER) {
VegMap[Stat[i].Loc.N][Stat[i].Loc.E].Veg = j;
break;
}
}
if (j == Veg.NTypes) { /* glacier class not found */
ReportError("MainDHSVM", 62);
}
printf("setting to glacier type (assumed bare class): %d\n", j);
}
}
InitMetMaps(Time.NDaySteps, &Map, &Radar, &Options, InFiles.WindMapPath,
InFiles.PrecipLapseFile, &PrecipLapseMap, &PrismMap,
&ShadowMap, &SkyViewMap, &EvapMap, &PrecipMap,
&RadarMap, &RadMap, SoilMap, &Soil, VegMap, &Veg, TopoMap,
&MM5Input, &WindModel);
InitInterpolationWeights(&Map, &Options, TopoMap, &MetWeights, Stat, NStats);
InitDump(Input, &Options, &Map, Soil.MaxLayers, Veg.MaxLayers, Time.Dt,
TopoMap, &Dump, &NGraphics, &which_graphics);
if (Options.HasNetwork == TRUE) {
InitChannelDump(&Options, &ChannelData, Dump.Path);
ReadChannelState(Dump.InitStatePath, &(Time.Start), ChannelData.streams);
}
InitSnowMap(&Map, &SnowMap);
InitAggregated(Veg.MaxLayers, Soil.MaxLayers, &Total);
InitModelState(&(Time.Start), &Map, &Options, PrecipMap, SnowMap, SoilMap,
Soil, SType, VegMap, Veg, VType, Dump.InitStatePath,
SnowAlbedo, TopoMap, Network, &HydrographInfo, Hydrograph);
InitNewMonth(&Time, &Options, &Map, TopoMap, PrismMap, ShadowMap,
RadMap, &InFiles, Veg.NTypes, VType, NStats, Stat,
Dump.InitStatePath);
InitNewDay(Time.Current.JDay, &SolarGeo);
if (NGraphics > 0) {
printf("Initialzing X11 display and graphics \n");
InitXGraphics(argc, argv, Map.NY, Map.NX, NGraphics, &MetMap);
}
shade_offset = FALSE;
if (Options.Shading == TRUE)
shade_offset = TRUE;
/* Done with initialization, delete the list with input strings */
DeleteList(Input);
/*****************************************************************************
Sediment Initialization Procedures
*****************************************************************************/
if(Options.Sediment) {
time (&tloc);
srand (tloc);
/* Randomize Random Generator */
/* Commenting the line above and uncommenting the line below
allows for the comparison of scenarios. */
/* srand48 (0); */
printf("\nSTARTING SEDIMENT INITIALIZATION PROCEDURES\n\n");
ReadInitFile(Options.SedFile, &Input);
InitParameters(Input, &Options, &Map, &Network, &ChannelData, TopoMap,
&Time, SedDiams);
InitSedimentTables(Time.NDaySteps, Input, &SedType, &SType, &VType, &Soil, &Veg);
InitFineMaps(Input, &Options, &Map, &Soil, &TopoMap, &SoilMap,
&FineMap);
if (Options.HasNetwork){
printf("Initializing channel sediment\n\n");
InitChannelSedimentDump(&ChannelData, Dump.Path, Options.ChannelRouting);
InitChannelSediment(ChannelData.streams, &Total);
InitChannelSediment(ChannelData.roads, &Total);
}
InitSedMap( &Map, &SedMap);
/* Done with initialization, delete the list with input strings */
DeleteList(Input);
}
/* setup for mass balance calculations */
Aggregate(&Map, &Options, TopoMap, &Soil, &Veg, VegMap, EvapMap, PrecipMap,
RadMap, SnowMap, SoilMap, &Total, VType, Network, SedMap, FineMap,
&ChannelData, &roadarea);
Mass.StartWaterStorage =
Total.Soil.IExcess + Total.CanopyWater + Total.SoilWater + Total.Snow.Swq +
Total.Soil.SatFlow;
Mass.OldWaterStorage = Mass.StartWaterStorage;
if (Options.Sediment) {
Mass.StartChannelSedimentStorage = Total.ChannelSedimentStorage;
Mass.LastChannelSedimentStorage = Mass.StartChannelSedimentStorage;
}
/* computes the number of grid cell contributing to one segment */
if (Options.StreamTemp)
Init_segment_ncell(TopoMap, ChannelData.stream_map, Map.NY, Map.NX, ChannelData.streams);
/*****************************************************************************
Perform Calculations
*****************************************************************************/
while (Before(&(Time.Current), &(Time.End)) ||
IsEqualTime(&(Time.Current), &(Time.End))) {
ResetAggregate(&Soil, &Veg, &Total, &Options);
if (IsNewMonth(&(Time.Current), Time.Dt))
InitNewMonth(&Time, &Options, &Map, TopoMap, PrismMap, ShadowMap,
RadMap, &InFiles, Veg.NTypes, VType, NStats, Stat,
Dump.InitStatePath);
if (IsNewDay(Time.DayStep)) {
InitNewDay(Time.Current.JDay, &SolarGeo);
PrintDate(&(Time.Current), stdout);
printf("\n");
}
/* determine surface erosion and routing scheme */
SedimentFlag(&Options, &Time);
InitNewStep(&InFiles, &Map, &Time, Soil.MaxLayers, &Options, NStats, Stat,
InFiles.RadarFile, &Radar, RadarMap, &SolarGeo, TopoMap, RadMap,
SoilMap, MM5Input, WindModel, &MM5Map);
/* initialize channel/road networks for time step */
if (Options.HasNetwork) {
channel_step_initialize_network(ChannelData.streams);
channel_step_initialize_network(ChannelData.roads);
}
for (y = 0; y < Map.NY; y++) {
for (x = 0; x < Map.NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
if (Options.Shading)
LocalMet =
MakeLocalMetData(y, x, &Map, Time.DayStep, &Options, NStats,
Stat, MetWeights[y][x], TopoMap[y][x].Dem,
&(RadMap[y][x]), &(PrecipMap[y][x]), &Radar,
RadarMap, PrismMap, &(SnowMap[y][x]),
SnowAlbedo, MM5Input, WindModel, PrecipLapseMap,
&MetMap, NGraphics, Time.Current.Month,
SkyViewMap[y][x], ShadowMap[Time.DayStep][y][x],
SolarGeo.SunMax, SolarGeo.SineSolarAltitude);
else
LocalMet =
MakeLocalMetData(y, x, &Map, Time.DayStep, &Options, NStats,
Stat, MetWeights[y][x], TopoMap[y][x].Dem,
&(RadMap[y][x]), &(PrecipMap[y][x]), &Radar,
RadarMap, PrismMap, &(SnowMap[y][x]),
SnowAlbedo, MM5Input, WindModel, PrecipLapseMap,
&MetMap, NGraphics, Time.Current.Month, 0.0,
0.0, SolarGeo.SunMax,
SolarGeo.SineSolarAltitude);
for (i = 0; i < Soil.MaxLayers; i++) {
if (Options.HeatFlux == TRUE) {
if (Options.MM5 == TRUE)
SoilMap[y][x].Temp[i] =
MM5Input[shade_offset + i + N_MM5_MAPS][y][x];
else
SoilMap[y][x].Temp[i] = Stat[0].Data.Tsoil[i];
}
else
SoilMap[y][x].Temp[i] = LocalMet.Tair;
}
MassEnergyBalance(&Options, y, x, SolarGeo.SineSolarAltitude, Map.DX, Map.DY,
Time.Dt, Options.HeatFlux, Options.CanopyRadAtt, Options.RoadRouting,
Options.Infiltration, Veg.MaxLayers, &LocalMet, &(Network[y][x]),
&(PrecipMap[y][x]), &(VType[VegMap[y][x].Veg-1]), &(VegMap[y][x]),
&(SType[SoilMap[y][x].Soil-1]), &(SoilMap[y][x]), &(SnowMap[y][x]),
&(EvapMap[y][x]), &(Total.Rad), &ChannelData, SkyViewMap);
PrecipMap[y][x].SumPrecip += PrecipMap[y][x].Precip;
}
}
}
/* Average all RBM inputs over each segment */
if (Options.StreamTemp) {
channel_grid_avg(ChannelData.streams);
}
#ifndef SNOW_ONLY
/* set sediment inflows to zero - they are incremented elsewhere */
if ((Options.HasNetwork) && (Options.Sediment)){
InitChannelSedInflow(ChannelData.streams);
InitChannelSedInflow(ChannelData.roads);
}
RouteSubSurface(Time.Dt, &Map, TopoMap, VType, VegMap, Network,
SType, SoilMap, &ChannelData, &Time, &Options, Dump.Path,
SedMap, FineMap, SedType, MaxStreamID, SnowMap);
if (Options.HasNetwork)
RouteChannel(&ChannelData, &Time, &Map, TopoMap, SoilMap, &Total,
&Options, Network, SType, PrecipMap, SedMap,
LocalMet.Tair, LocalMet.Rh, SedDiams);
/* Sediment Routing in Channel and output to sediment files */
if ((Options.HasNetwork) && (Options.Sediment)){
SPrintDate(&(Time.Current), buffer);
flag = IsEqualTime(&(Time.Current), &(Time.Start));
if (Options.ChannelRouting){
if (ChannelData.roads != NULL) {
RouteChannelSediment(ChannelData.roads, Time, &Dump, &Total, SedDiams);
channel_save_sed_outflow_text(buffer, ChannelData.roads,
ChannelData.sedroadout,
ChannelData.sedroadflowout, flag);
RouteCulvertSediment(&ChannelData, &Map, TopoMap, SedMap,
&Total, SedDiams);
}
RouteChannelSediment(ChannelData.streams, Time, &Dump, &Total, SedDiams);
channel_save_sed_outflow_text(buffer, ChannelData.streams,
ChannelData.sedstreamout,
ChannelData.sedstreamflowout, flag);
}
else {
if (ChannelData.roads != NULL) {
channel_save_sed_inflow_text(buffer, ChannelData.roads,
ChannelData.sedroadinflow, SedDiams,flag);
}
channel_save_sed_inflow_text(buffer, ChannelData.streams,
ChannelData.sedstreaminflow, SedDiams,flag);
}
SaveChannelSedInflow(ChannelData.roads, &Total);
SaveChannelSedInflow(ChannelData.streams, &Total);
}
if (Options.Extent == BASIN)
RouteSurface(&Map, &Time, TopoMap, SoilMap, &Options,
UnitHydrograph, &HydrographInfo, Hydrograph,
&Dump, VegMap, VType, SType, &ChannelData, SedMap,
PrecipMap, SedType, LocalMet.Tair, LocalMet.Rh, SedDiams);
#endif
if (NGraphics > 0)
draw(&(Time.Current), IsEqualTime(&(Time.Current), &(Time.Start)),
Time.DayStep, &Map, NGraphics, which_graphics, VType,
SType, SnowMap, SoilMap, SedMap, FineMap, VegMap, TopoMap, PrecipMap,
PrismMap, SkyViewMap, ShadowMap, EvapMap, RadMap, MetMap, Network,
&Options);
Aggregate(&Map, &Options, TopoMap, &Soil, &Veg, VegMap, EvapMap, PrecipMap,
RadMap, SnowMap, SoilMap, &Total, VType, Network, SedMap, FineMap,
&ChannelData, &roadarea);
MassBalance(&(Time.Current), &(Dump.Balance), &(Dump.SedBalance), &Total,
&Mass, &Options);
ExecDump(&Map, &(Time.Current), &(Time.Start), &Options, &Dump, TopoMap,
EvapMap, RadiationMap, PrecipMap, RadMap, SnowMap, MetMap, VegMap, &Veg,
SoilMap, SedMap, Network, &ChannelData, FineMap, &Soil, &Total,
&HydrographInfo,Hydrograph);
IncreaseTime(&Time);
t += 1;
}
ExecDump(&Map, &(Time.Current), &(Time.Start), &Options, &Dump, TopoMap,
EvapMap, RadiationMap, PrecipMap, RadMap, SnowMap, MetMap, VegMap, &Veg, SoilMap,
SedMap, Network, &ChannelData, FineMap, &Soil, &Total, &HydrographInfo, Hydrograph);
FinalMassBalance(&(Dump.FinalBalance), &Total, &Mass, &Options, roadarea);
/*printf("\nSTARTING CLEANUP\n\n");
cleanup(&Dump, &ChannelData, &Options);*/
printf("\nEND OF MODEL RUN\n\n");
/* record the run time at the end of each time loop */
finish1 = clock ();
runtime = (finish1-start)/CLOCKS_PER_SEC;
printf("***********************************************************************************");
printf("\nRuntime Summary:\n");
printf("%6.2f hours elapsed for the simulation period of %d hours (%.1f days) \n",
runtime/3600, t*Time.Dt/3600, (float)t*Time.Dt/3600/24);
return EXIT_SUCCESS;
}
Bsemff_BCL::Bsemff_BCL(double m2):Bsemff(m2),Kv(0),Ks(0),bvk(0),bsk(0){
double t0 = mBpi*pow(sqrt(mB0)-sqrt(mH),2);
SetAux(t0);
InitParameters();
}
void TextBox::setSize(ivec2 size)
{
WIDTH = size.x;
HEIGHT = size.y;
InitParameters();
}
/*****************************************************************************
函数名称：QSimpleTextItem(QRectF Rect, QString sText)
函数意义：带参数构造函数
参数含义：Rect文本的背景矩形框大小，sText初始文本
*****************************************************************************/
QSimpleTextItem::QSimpleTextItem(QRectF Rect, QString sText)
{
sTEXT = sText; //默认文本
m_rect = Rect; //给背景矩形赋初始值
InitParameters();
}
/*
______________________________________________________________________________________________
Main
______________________________________________________________________________________________
*/
int main(int argc, char *argv[])
{
// --- Init Cluster variable ---------------------------------------------------------
// carmen 0 => local execution i.e. show time on screen
// carmen 1 => cluster execution i.e. refresh Performance.dat (default)
#if defined PARMPI
// --- MPI Runtime system initialization
// size - total number of processors
// rnak - current CPU
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#else
size=1;
rank=0;
#endif
if (argc == 2)
Cluster = atoi(argv[1]);
// --- Print messages on screen- -----------------------------------------------------
cout << "carmen: begin execution.\n\n";
printf("Carmen %4.2f \n",CarmenVersion);
cout << "Copyright (C) 2000-2005 by Olivier Roussel.\n";
cout << "All rights reserved.\n\n";
#if defined PARMPI
//Synchronize all parallel branches
MPI_Barrier(MPI_COMM_WORLD);
#endif
CPUTime.start();
// --- Create first node of the tree structure ---------------------------------------
Node *Mesh=0;
FineMesh *FMesh=0;
// --- Init global values (See Parameters.h and Parameters.cpp) ----------------------------
cout << "carmen: init computation ...\n";
InitParameters();
// --- Debug output information for parallel execution -------------------------------------
#if defined PARMPI
if (Multiresolution)
{
printf("\nParallel Multiresolution solver not implemented yet!\n");
exit(0);
}
printf("My Rank=%d\n",rank);
// --- Each CPU print his coordinates in the virtual processor cart ------------------------
printf("Cart_i = %d; Cart_j = %d; Cart_k = %d;\n",coords[0],coords[1],coords[2]);
// --- Each CPU print his computation domain
printf("Xmin = %lf; XMax = %lf;\n",XMin[1],XMax[1]);
printf("Ymin = %lf; YMax = %lf;\n",XMin[2],XMax[2]);
printf("Zmin = %lf; ZMax = %lf;\n",XMin[3],XMax[3]);
// --- And the local scale number ----------------------------------------------------------
printf("ScaleNb = %d\n",ScaleNb);
#endif
// --- Allocate ----------------------------------------------------------------------------
if (Multiresolution)
Mesh = new Node;
else
FMesh = new FineMesh;
// --- Init tree structure -----------------------------------------------------------------
if (Multiresolution)
{
InitTree(Mesh);
RefreshTree(Mesh);
}
// --- Compute initial integral values and init time step ----------------------------------
if (Multiresolution)
Mesh->computeIntegral();
else
FMesh->computeIntegral();
// -- Write integral values --
// -- Compute initial time step --
InitTimeStep();
if (rank==0) PrintIntegral("Integral.dat");
// --- Save initial values into files ------------------------------------------------------
if (PrintEvery == 0)
{
if (Multiresolution)
View(Mesh, "Tree_0.dat", "Mesh_0.dat", "Average_0.dat");
else
View(FMesh,"Average_0.dat");
}
// --- When PrintEvery != 0, save initial values into specific name format ---
if (PrintEvery != 0)
{
if (Multiresolution)
ViewEvery(Mesh, 0);
else
ViewEvery(FMesh, 0);
}
// --- Parallel execution only --------------------------------------------
// --- Save to disk DX header for ouput files -----------------------------
// --- This file is needed for the external postprocessing (merging files from the different processors)
#if defined PARMPI
real tempXMin[4];
real tempXMax[4];
// --- Save original task parameters for the parallel execution
int tempScaleNb=ScaleNb;
// --- Simulate sequantial running
ScaleNb=AllTaskScaleNb;
for (int i=0;i<4;i++)
{
tempXMin[i]=XMin[i];
tempXMax[i]=XMax[i];
// --- Simulate sequantial running
XMin[i]=AllXMin[i];
XMax[i]=AllXMax[i];
}
// --- Write header with parameters, as we have run sequantial code
if (rank==0) FMesh->writeHeader("header.txt");
// Restore variables
for (int i=0;i<4;i++)
{
XMin[i]=tempXMin[i];
XMax[i]=tempXMax[i];
}
ScaleNb=tempScaleNb;
#endif
// --- Done ---
cout << "carmen: done.\n";
// --- Write solver type ---
if (Multiresolution)
cout << "carmen: multiresolution (MR) solver.\n";
else
cout << "carmen: finite volume (FV) solver.\n";
// --- Write number of iterations ---
if (IterationNb == 1)
cout << "carmen: compute 1 iteration ...\n";
else
cout << "carmen: compute " << IterationNb << " iterations ...\n";
printf("\n\n\n");
// --- Begin time iteration ----------------------------------------------------------------
for (IterationNo = 1; IterationNo <= IterationNb; IterationNo++)
{
// --- Time evolution procedure ---
if (Multiresolution)
TimeEvolution(Mesh);
else
TimeEvolution(FMesh);
// --- Remesh ---
if (Multiresolution) Remesh(Mesh);
// --- Check CPU Time ---
CPUTime.check();
// --- Write information every (Refresh) iteration ---
if ((IterationNo-1)%Refresh == 0)
{
// - Write integral values -
if (rank==0) PrintIntegral("Integral.dat");
if (Cluster == 0)
ShowTime(CPUTime); // Show time on screen
//else
if (rank==0) Performance("carmen.prf"); // Refresh file "carmen.prf"
}
// --- Backup data every (10*Refresh) iteration ---
if ((IterationNo-1)%(10*Refresh) == 0 && UseBackup)
{
if (Multiresolution)
Backup(Mesh);
else
Backup(FMesh);
}
// --- Print solution if IterationNo = PrintIt1 to PrintIt6 ---
if (Multiresolution)
ViewIteration(Mesh);
else
ViewIteration(FMesh);
// --- Print solution if IterationNo is a multiple of PrintEvery ---
if (PrintEvery != 0)
{
if (IterationNo%PrintEvery == 0)
{
if (Multiresolution)
ViewEvery(Mesh, IterationNo);
else
ViewEvery(FMesh, IterationNo);
}
}
// --- End time iteration ------------------------------------------------------------------
}
// --- Backup final data ------------------------------------------------------------------
IterationNo--;
if (UseBackup)
{
if (Multiresolution)
Backup(Mesh);
else
Backup(FMesh);
}
// --- Write integral values ---------------------------------------------------------------
if (rank==0) PrintIntegral("Integral.dat");
IterationNo++;
// --- Save values into file ---------------------------------------------------------------
if (Multiresolution)
View(Mesh, "Tree.dat", "Mesh.dat", "Average.dat");
else
View(FMesh, "Average.dat");
cout << "\ncarmen: done.\n";
// --- Analyse performance and save it into file -------------------------------------------
if (rank==0) Performance("carmen.prf");
// --- End ---------------------------------------------------------------------------------
if (Multiresolution)
delete Mesh;
else
delete FMesh;
#if defined PARMPI
//free memory for the MPI runtime variables
delete[] disp;
delete[] blocklen;
int sz;
MPI_Buffer_detach(&MPIbuffer,&sz);
// for (int i = 0; i < 4*Dimension; i++) MPI_Request_free(&req[i]);
MPI_Finalize();
#endif
cout <<"carmen: end execution.\n";
return EXIT_SUCCESS;
}
MyFigureGlut::MyFigureGlut(const char* title, int win_width, int win_height, int method)
: FigureGlut(title, win_width, win_height, method)
{
Draw_Method = method;
InitParameters();
}
MyFigureGlut::MyFigureGlut(const char* title, int win_width, int win_height, int* argc, TCHAR* argv[])
: FigureGlut(title, win_width, win_height, argc, argv)
{
InitParameters();
}
int main(int argc, char *argv[])
{
int i,j,k,l,inmethod,outmethod,info,errorstat;
int nogrids,nomeshes,nofile,dim,elementsredone=0;
int nodes3d,elements3d,showmem;
Real mergeeps;
char prefix[MAXFILESIZE];
struct GridType *grids;
struct CellType *cell[MAXCASES];
struct FemType data[MAXCASES];
struct BoundaryType *boundaries[MAXCASES];
struct ElmergridType eg;
showmem = TRUE;
printf("\nStarting program Elmergrid\n");
InitParameters(&eg);
grids = (struct GridType*)malloc((size_t) (MAXCASES)*sizeof(struct GridType));
InitGrid(grids);
info = TRUE;
if(argc <= 1) {
errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);
Instructions();
if(errorstat) Goodbye();
}
if(argc == 2) {
errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);
if(errorstat) Goodbye();
}
else if(argc < 4) {
Instructions();
Goodbye();
}
else {
errorstat = InlineParameters(&eg,argc,argv);
if(errorstat) Goodbye();
}
if(!eg.outmethod || !eg.inmethod) {
printf("Please define the input and output formats\n");
}
if(eg.inmethod != 1) {
if(eg.outmethod == 1 || eg.outmethod == 8 || eg.outmethod == 9 || eg.outmethod == 10) {
printf("input of type %d can't create output of type %d\n",
eg.inmethod,eg.outmethod);
errorstat++;
Goodbye();
}
}
#if 0
if(eg.inmethod != 8 && eg.outmethod == 5) {
printf("To write Easymesh format you need to read easymesh format!\n");
errorstat++;
}
#endif
if(eg.timeron) timer_activate(eg.infofile);
/**********************************/
printf("\nElmergrid loading data:\n");
printf( "-----------------------\n");
dim = eg.dim;
nofile = 0;
nomeshes = 0;
nogrids = 0;
inmethod = eg.inmethod;
outmethod = eg.outmethod;
read_another_file:
timer_show();
switch (inmethod) {
case 1:
if(LoadElmergrid(&grids,&nogrids,eg.filesin[nofile],eg.relh,info) == 1) {
if(dim == 3) ExampleGrid3D(&grids,&nogrids,info);
if(dim == 2) ExampleGrid2D(&grids,&nogrids,info);
if(dim == 1) ExampleGrid1D(&grids,&nogrids,info);
SaveElmergrid(grids,nogrids,eg.filesin[nofile],info);
printf("Because file %s didn't exist, it was created for you.\n",eg.filesin[nofile]);
Goodbye();
}
LoadCommands(eg.filesin[nofile],&eg,grids,2,info);
break;
case 2:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadElmerInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 3:
if(LoadSolutionElmer(&(data[nofile]),TRUE,eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 4:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
if(LoadAnsysInput(&(data[0]),boundaries[0],eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 5:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadAbaqusInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 6:
if(LoadAbaqusOutput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 7:
if(LoadFidapInput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(0 && !eg.usenames) data[nofile].boundarynamesexist = data[nofile].bodynamesexist = FALSE;
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
RenumberBoundaryTypes(&data[nofile],boundaries[nofile],TRUE,0,info);
nomeshes++;
break;
case 8:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadUniversalMesh(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 9:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadComsolMesh(&(data[nofile]),eg.filesin[nofile],info))
Goodbye();
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
nomeshes++;
break;
case 10:
if(LoadFieldviewInput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
nomeshes++;
break;
case 11:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadTriangleInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 12:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadMeditInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 13:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGidInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 14:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGmshInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 15:
if(info) printf("Partitioned solution is fused on-the-fly therefore no other operations may be performed.\n");
FuseSolutionElmerPartitioned(eg.filesin[nofile],eg.filesout[nofile],eg.decimals,eg.partjoin,
eg.saveinterval[0],eg.saveinterval[1],eg.saveinterval[2],info);
if(info) printf("Finishing with the fusion of partitioned Elmer solutions\n");
Goodbye();
break;
#if 0
case 16:
InitializeKnots(&(data[nofile]));
if( Easymesh(argc,argv,&data[nofile].noknots,
&data[nofile].noelements,&sides))
Goodbye();
data[nofile].dim = 2;
data[nofile].coordsystem = COORD_CART2;
data[nofile].maxnodes = 3;
AllocateKnots(&(data[nofile]));
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(EasymeshCopy(&(data[nofile]),boundaries[nofile]))
Goodbye();
nomeshes++;
break;
#endif
case 17:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadNastranInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 18:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadCGsimMesh(&(data[nofile]),eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 19:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGeoInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
default:
Instructions();
Goodbye();
}
nofile++;
if(nofile < eg.nofilesin) {
printf("\nElmergrid loading data from another file:\n");
goto read_another_file;
}
/***********************************/
redoelements:
printf("\nElmergrid creating and manipulating meshes:\n");
printf( "-------------------------------------------\n");
timer_show();
if(nogrids > nomeshes && outmethod != 1) {
nomeshes = nogrids;
for(k=0;k<nogrids;k++) {
CreateCells(&(grids[k]),&(cell[k]),info);
CreateKnots(&(grids[k]),cell[k],&(data[k]),0,0);
boundaries[k] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(j=0;j<MAXBOUNDARIES;j++) {
boundaries[k][j].created = FALSE;
boundaries[k][j].nosides = FALSE;
}
if(grids[k].noboundaries > 0) {
for(j=0;j<grids[k].noboundaries;j++) {
if(grids[k].boundsolid[j] < 4) {
CreateBoundary(cell[k],&(data[k]),&(boundaries[k][j]),
grids[k].boundext[j],grids[k].boundint[j],
1,grids[k].boundtype[j]);
}
else {
CreatePoints(cell[k],&(data[k]),&(boundaries[k][j]),
grids[k].boundext[j],grids[k].boundint[j],
grids[k].boundsolid[j],grids[k].boundtype[j]);
}
}
}
}
}
/* In some formats the dimension for curved 2D meshes seems to be set to 2.
This should fix the problem for all input types. */
if( data->dim < 3 ) {
data->dim = GetCoordinateDimension(data,info);
}
/* Make the discontinous boundary needed, for example, in poor thermal conduction */
for(k=0;k<nomeshes;k++) {
if(!eg.discont) {
for(j=0;j<grids[k].noboundaries;j++)
if(grids[k].boundsolid[j] == 2) {
eg.discontbounds[eg.discont] = grids[k].boundtype[j];
eg.discont++;
}
}
if(eg.discont) {
for(i=1;i<=eg.discont;i++)
SetDiscontinuousBoundary(&(data[k]),boundaries[k],eg.discontbounds[i-1],2,info);
}
}
/* Divide quadrilateral meshes into triangular meshes */
for(k=0;k<nomeshes;k++)
if(nogrids && (eg.triangles || grids[k].triangles == TRUE)) {
Real criticalangle;
criticalangle = MAX(eg.triangleangle , grids[k].triangleangle);
ElementsToTriangles(&data[k],boundaries[k],criticalangle,info);
}
/* Make a boundary layer with two different methods */
if(eg.layers > 0)
for(k=0;k<nomeshes;k++)
CreateBoundaryLayer(&data[k],boundaries[k],eg.layers,
eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
eg.layerparents, eg.layermove, eg.layereps, info);
else if(eg.layers < 0)
for(k=0;k<nomeshes;k++)
CreateBoundaryLayerDivide(&data[k],boundaries[k],abs(eg.layers),
eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
eg.layerparents, info);
/* Take up the infor on rotation */
for(k=0;k<nogrids;k++)
if( grids[k].rotatecurve ) {
eg.rotatecurve = TRUE;
eg.curvezet = grids[k].curvezet;
eg.curverad = grids[k].curverad;
eg.curveangle = grids[k].curveangle;
}
if(outmethod != 1 && dim != 2 && eg.dim != 2) {
j = MAX(nogrids,1);
for(k=0;k<j;k++) {
if(grids[k].dimension == 3 || grids[k].rotate) {
boundaries[j] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++)
boundaries[j][i].created = FALSE;
CreateKnotsExtruded(&(data[k]),boundaries[k],&(grids[k]),
&(data[j]),boundaries[j],info);
if(nogrids) {
elements3d = MAX(eg.elements3d, grids[k].wantedelems3d);
nodes3d = MAX(eg.nodes3d, grids[k].wantednodes3d);
if(elements3d) {
if( abs(data[j].noelements - elements3d) / (1.0*elements3d) > 0.01 && elementsredone < 5 ) {
grids[k].wantedelems *= pow(1.0*elements3d / data[j].noelements, (2.0/3.0));
elementsredone++;
}
else elementsredone = 0;
}
else if(nodes3d) {
if( abs(data[j].noknots - nodes3d) / (1.0*nodes3d) > 0.01 && elementsredone < 5 ) {
grids[k].wantedelems *= pow(1.0*nodes3d / data[j].noknots, (2.0/3.0));
elementsredone++;
}
else elementsredone = 0;
}
if(elementsredone) {
nomeshes = 0;
for(i=0;i < nogrids;i++) SetElementDivision(&(grids[i]),eg.relh,info);
DestroyKnots(&data[j]);
DestroyKnots(&data[k]);
free(cell[k]);
if(info) printf("Iteration %d of elements number targiting %d in 2D\n",
elementsredone,grids[k].wantedelems);
goto redoelements;
}
}
data[k] = data[j];
boundaries[k] = boundaries[j];
}
}
}
/* If the original mesh was given in polar coordinates make the transformation into cartesian ones */
for(k=0;k<nomeshes;k++) {
if(eg.polar || data[k].coordsystem == COORD_POLAR) {
if(!eg.polar) eg.polarradius = grids[k].polarradius;
PolarCoordinates(&data[k],eg.polarradius,info);
}
}
/* If the original mesh was given in cylindrical coordinates make the transformation into cartesian ones */
for(k=0;k<nomeshes;k++) {
if(eg.cylinder || data[k].coordsystem == COORD_CYL) {
CylinderCoordinates(&data[k],info);
}
}
if(1) for(k=0;k<nomeshes;k++)
RotateTranslateScale(&data[k],&eg,info);
/* Rotate may apply to 2d and 3d geometries as well */
for(k=0;k<nomeshes;k++)
if(eg.rotatecurve)
CylindricalCoordinateCurve(&data[k],eg.curvezet,eg.curverad,eg.curveangle);
/* Unite meshes if there are several of them */
if(eg.unitemeshes) {
for(k=1;k<nomeshes;k++)
UniteMeshes(&data[0],&data[k],boundaries[0],boundaries[k],info);
nomeshes = nogrids = 1;
}
if(eg.clone[0] || eg.clone[1] || eg.clone[2]) {
for(k=0;k<nomeshes;k++) {
CloneMeshes(&data[k],boundaries[k],eg.clone,eg.clonesize,FALSE,info);
mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,TRUE,TRUE);
}
}
if(eg.mirror[0] || eg.mirror[1] || eg.mirror[2]) {
for(k=0;k<nomeshes;k++) {
MirrorMeshes(&data[k],boundaries[k],eg.mirror,FALSE,eg.clonesize,eg.mirrorbc,info);
mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,FALSE,TRUE);
}
}
/* Naming convection for the case of several meshes */
if(nomeshes > 1) {
strcpy(prefix,eg.filesout[0]);
for(k=0;k<nomeshes;k++)
sprintf(eg.filesout[k],"%s%d",prefix,k+1);
}
for(k=0;k<nomeshes;k++) {
if(nogrids && grids[k].reduceordermatmax) {
eg.reduce = TRUE;
eg.reducemat1 = grids[k].reduceordermatmin;
eg.reducemat2 = grids[k].reduceordermatmax;
}
if(eg.reduce)
ReduceElementOrder(&data[k],eg.reducemat1,eg.reducemat2);
}
for(k=0;k<nomeshes;k++)
if(eg.increase) IncreaseElementOrder(&data[k],TRUE);
for(k=0;k<nomeshes;k++) {
if(eg.merge)
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,eg.cmerge,FALSE,TRUE);
else if(eg.order == 3)
#if PARTMETIS
ReorderElementsMetis(&data[k],TRUE);
#else
printf("Cannot order nodes by Metis as it is not even compiled!\n");
#endif
else if(eg.order)
ReorderElements(&data[k],boundaries[k],eg.order,eg.corder,TRUE);
if(eg.isoparam)
IsoparametricElements(&data[k],boundaries[k],TRUE,info);
}
ShHealOper_FillHoles::ShHealOper_FillHoles (const TopoDS_Shape& theShape)
{
Init(theShape);
InitParameters();
}
int main(int argc, char *argv[]){
# ifdef UNIX
static char state[256];
initstate(1997,state,256);
# else
Exit_wait(1);
# endif
Set_comment_char(';');
StartTime();
char *cfgfile="Params.dta";
if(argc>1)cfgfile=argv[1];
int no_remove=1;
if(argc>2)if(strstr(argv[2],"new"))no_remove=0;
Open_param_file(cfgfile);
int nions,i;
Read_param("Number of ions: %d",&nions);
Read_param("Ionisation degree: %d",&i);
ion_charge=i;
double imass=1.;
Set_stop(0);
if(Read_param("Ion mass: %lf",&imass)){
printf("Non-symmetric plasma specified!\n");
non_symm=1;
}
char tmpstr[256];
int sep_cm=0;
if(Read_param("Center-of-mass for components: %s",tmpstr)){
if(strstr(tmpstr,"separate")){
printf("Plasma with separated center of masses specified!\n");
sep_cm=1;
}
}
Plasma *TheGas; // allocation of the Gas
double bdens, bTv;
int bq;
int bunch=Read_param("Bunch propagation: %lf, %lf, %d",&bdens,&bTv,&bq);
if(bunch>0){
printf("Bunch in plasma specified!\n");
if(bunch!=3){
msg_error("Invalid bunch specification!\n");
exit(1);
}
bunch=1;
bTv=sqrt(3*nions*i*bTv); // converting temperature to velocity
TheGas=(Plasma *)new PlasmaBunch(bdens,bTv,bq,nions,i,imass);
}
else{
TheGas=new Plasma(nions,i,imass);
bunch=0;
}
Plasma &Gas=*TheGas;
Gas.non_symm=non_symm;
Gas.one_center=1-sep_cm;
char dataname[50];
Read_param("Data name: %s",dataname);
strncpy(Gas.dataname,dataname,50);
char ofile[256], pfile[256]="poten.dat";
strcat(strcpy(pfile,dataname),".pot");
Read_param("Output file: %s",ofile);
if(strstr(ofile,"default")){
strcpy(ofile,dataname);
strcat(ofile,".eq");
}
Read_param("Log file: %s",logfile);
if(strstr(logfile,"default")){
strcpy(logfile,dataname);
strcat(logfile,".log");
}
Parameter *p;
int np=InitParameters(&p);
double T,Gamma;
potspec_t reader;
reader.read_spec(cfgfile);
Gas.potential=reader.potential;
strncpy(Gas.charpot,reader.charpot,50);
/*
Read_param("Potential: %s",tmpstr);
strncpy(Gas.charpot,tmpstr,50);
if(strstr(tmpstr,"Kelbg"))Gas.potential=PotentialKELBG;
else if(strstr(tmpstr,"Lennard-Johnes"))Gas.potential=PotentialJONES;
else if(strstr(tmpstr,"Deutsch"))Gas.potential=PotentialDEUTSCH;
else if(strstr(tmpstr,"Erf"))Gas.potential=PotentialERF;
else if(strstr(tmpstr,"Cutoff")){
if(!strcmp(tmpstr,"Cutoff1")){
Gas.potential=PotentialCUT1;
}
else{
Gas.potential=PotentialCUT;
Read_param("Cutoff value*: %lf",&E_cut);
}
}
else if(strstr(tmpstr,"ln")){
Gas.potential=PotentialLN;
Read_param("Cutoff value*: %lf",&E_cut);
}
else if(strstr(tmpstr,"table")){
Gas.potential=PotentialTAB;
Read_param("Potential table file: %s",tmpstr);
Close_param_file();
ReadPotential(tmpstr);
Open_param_file(cfgfile);
}
else serror("Unknown potential type specified!\n");
Read_param("Pauli part: %s",tmpstr);
if(strstr(tmpstr,"n"))Pauli_part=0;
double Lambda, Lambda_set;
Read_param("R0: %s",tmpstr);
if(strstr(tmpstr,"default"))Lambda_set=0.;
else Lambda_set=atof(tmpstr);
double Clam_ep=1.,Clam_ee=1;
Read_param("e-e R0 coefficient: %lf",&Clam_ee);
Read_param("e-p R0 coefficient: %lf",&Clam_ep);
*/
int ask=0;
Read_param("Dialog: %s",tmpstr);
if(strstr(tmpstr,"y"))ask=1;
auto_rf=0;
Gf=10.;
Read_param("Random force strength: %s",tmpstr);
if(strstr(tmpstr,"auto"))auto_rf=1;
else if(strstr(tmpstr,"fluct"))auto_rf=2;
if(!sscanf(tmpstr,"%lf",&Gf) && auto_rf==0)serror("Can't read Random force strength\n");
Read_param("Scale velocities: %s",tmpstr);
if(strstr(tmpstr,"y"))scale_vel=1;
Read_param("Delta: %lf",&delta);
Read_param("Trajectory write interval: %ld",&wr_int);
if(wr_int<=0)wr_int=-1;
int new_rec=0;
long wr_ions=0, wr_enseq=-1;
Set_stop(0);
if(Read_param("Ions write interval: %ld",&wr_ions)){
new_rec=1;
if(!Read_param("Electrons write sequence: %ld",&wr_enseq))wr_enseq=-1;
}
Set_stop(1);
Read_param("Steps to check equillibrium: %ld",&chk_nsteps);
Read_param("Steps with random force: %ld",&rf_nsteps);
Read_param("Check steps with random force: %ld",&tst_nsteps);
Read_param("Steps in equillibrium: %ld",&eq_nsteps);
Read_param("Time step in equillibrium: %lf",&eq_dt);
Read_param("Time step for random force: %lf",&rf_dt0);
char trfile[256]="trajectory";
int wr_tr=0;
Set_stop(0);
/*int pot_corr=0;
if(Read_param("Potential correction: %s",tmpstr)){
if(strstr(tmpstr,"y")){
pot_corr=1;
strcat(Gas.charpot," corr.");
}
}*/
if(Read_param("Total energy stability: %lf",&stab_acc))e_stab=1;
if(Read_param("Positive cutoff: %lf",&E_negcut))neg_cut=1;
else neg_cut=0;
if(!Read_param("Random generator *:>",tmpstr))strcpy(tmpstr,"3");
cList rndlist(tmpstr);
int nrepeats=1;
if(!Read_param("Repeats: %d",&nrepeats))nrepeats=1;
char mdistrfile[256]="r-r.distrib";
double rr_r0=0., rr_r1=-1.;
if(Read_param("Write r-r distribution: %s",tmpstr)){
if(strstr(tmpstr,"y")){
write_distr=1;
if(!Read_param("r-r file: %s",mdistrfile)||strstr(mdistrfile,"default")){
strcpy(mdistrfile,"%s%d.rr");
}
if(Read_param("r-r range: %lf, %lf",&rr_r0,&rr_r1)!=2){
rr_r0=0.;
rr_r1=-1.;
}
}
}
if(Read_param("Soft step: %s",tmpstr)){
if(strstr(tmpstr,"n"))soft_step=0;
}
if(Read_param("Soft random force: %s",tmpstr)){
if(strstr(tmpstr,"y")){
rf_sw_off=1;
Set_stop(1);
Read_param("Switch off steps: %ld",&sw_nsteps);
Set_stop(0);
}
else rf_sw_off=0;
}
if(Read_param("Relative step: %s",tmpstr)){
if(strstr(tmpstr,"y"))rel_step=1;
}
if(Read_param("Animation : %s",&tmpstr)){
if(strstr(tmpstr,"y")){
if(!Read_param("Film directory: %s",filmdir)||strstr(filmdir,"default")){
strcpy(filmdir,"film/");
}
}
}
in_cs=-1.;
Read_param("Initial cluster size: %lf",&in_cs);
int restart=0,load_fried=0;
int new_input=0;
char inptrj[256];
if(Read_param("Restart: %s",tmpstr)){
if(strstr(tmpstr,"y")){
restart=1;
if(Read_param("Load Friedemann: %s",tmpstr)){
if(strstr(tmpstr,"y"))load_fried=1;
}
if(Read_param("Input from: %s",inptrj))new_input=1;
}
}
long wtype=0;
if(Read_param("Trajectory file: %s",&trfile)){
if(strstr(trfile,"default"))strcpy(trfile,"%s%d.r");
Set_stop(1);
wr_tr=1;
Read_param("In output:>",tmpstr);
if(strstr(tmpstr,"vel"))wtype|=VEL;
if(strstr(tmpstr,"coord"))wtype|=COORD;
if(strstr(tmpstr,"flow"))wtype|=FLOW;
Set_stop(0);
}
else printf("Warning: no trajectory file\n");
int mc_one=0;
int mc_diff=0;
int auto_adjust=1;
double mc_inistep;
int no_equilibr=0;
Set_stop(1);
if(Read_param("Equilibration procedure: %s",tmpstr)){
if(strstr(tmpstr,"monte-carlo")){
Set_stop(1);
mc_equil=1;
Read_param("One particle MC-step: %s",tmpstr);
if(strstr(tmpstr,"y")){
mc_one=1;
// rf_dt0/=Gas.n;
}
Read_paramn(2,"MC step mode and value: %s %lf",tmpstr, &mc_inistep);
if(strstr(tmpstr,"auto"))auto_adjust=1;
else if(strstr(tmpstr,"stable"))auto_adjust=0;
else serror("Unknown MC step mode.\n");
Set_stop(0);
mc_diff=0;
if(Read_param("MC different temperatures: %s",tmpstr)){
if(strstr(tmpstr,"y")){
if(mc_one)serror("Can use different MC temperatures\n"
"only in MC one-particle mode!\n");
mc_diff=1;
}
}
}
else{
mc_equil=0;
if(strstr(tmpstr,"off"))no_equilibr=1;
else if(!strstr(tmpstr,"random-force")){
serror("Unknown equilibration procedure: %s\n",tmpstr);
}
}
}
Set_stop(0);
mc_calc=0;
if(Read_param("Equilibrium calculation: %s",tmpstr)){
if(strstr(tmpstr,"monte-carlo")){
Set_stop(1);
mc_calc=1;
Read_param("One particle MC-step: %s",tmpstr);
if(strstr(tmpstr,"y")){
mc_one=1;
// rf_dt0/=Gas.n;
}
Read_paramn(2,"MC step mode and value: %s %lf",tmpstr, &mc_inistep);
if(strstr(tmpstr,"auto"))auto_adjust=1;
else if(strstr(tmpstr,"stable"))auto_adjust=0;
else serror("Unknown MC step mode.\n");
Set_stop(0);
mc_diff=0;
if(Read_param("MC different temperatures: %s",tmpstr)){
if(strstr(tmpstr,"y")){
if(mc_one)serror("Can use different MC temperatures\n"
"only in MC one-particle mode!\n");
mc_diff=1;
}
}
}
}
//# ifdef UNIX
char out_dirs[250]="./",out_dirl[250]="./";
if(Read_param("Data output directory: %s",out_dirs)){
if(out_dirs[strlen(out_dirs)-1]!='/')strcat(out_dirs,"/");
sprintf(tmpstr,out_dirs,dataname);
strcpy(out_dirs,tmpstr);
# ifdef UNIX
if(mkdir(out_dirs,S_IRWXU|S_IRGRP|S_IROTH)){
if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n",
out_dirs,strerror(errno));
}
sprintf(tmpstr,"cp %s %s%s.cfg",cfgfile,out_dirs,dataname);
//strcat(strcat(tmpstr,dataname),".cfg");
if(system(tmpstr)==-1)
printf("\nExec: %s\n",strerror(errno));
# else
if(_mkdir(out_dirs)){
if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n",
out_dirs,strerror(errno));
}
char cfgfilef[_MAX_PATH], out_dirsf[_MAX_PATH];
_fullpath(cfgfilef, cfgfile, _MAX_PATH);
_fullpath(out_dirsf, out_dirs, _MAX_PATH);
sprintf(tmpstr,"copy %s %s%s.cfg",cfgfilef,out_dirsf,dataname);
//strcat(strcat(tmpstr,dataname),".cfg");
if(system(tmpstr)==-1)
printf("\nExec: %s\n",strerror(errno));
# endif
strcpy(ofile,strcat(strcpy(tmpstr,out_dirs),ofile));
strcpy(mdistrfile,strcat(strcpy(tmpstr,out_dirs),mdistrfile));
strcpy(sfile,strcat(strcpy(tmpstr,out_dirs),sfile));
strcpy(pfile,strcat(strcpy(tmpstr,out_dirs),pfile));
if(wr_film){
strcpy(filmdir,strcat(strcpy(tmpstr,out_dirs),ofile));
# ifdef UNIX
if(mkdir(filmdir,S_IRWXU|S_IRGRP|S_IROTH)){
# else
if(_mkdir(filmdir)){
# endif
if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n",
filmdir,strerror(errno) );
}
strcat(filmdir,dataname);
}
}
if(Read_param("Process output directory: %s",out_dirl)){
if(out_dirl[strlen(out_dirl)]!='/')strcat(out_dirl,"/");
sprintf(tmpstr,out_dirl,dataname);
strcpy(out_dirl,tmpstr);
# ifdef UNIX
if(mkdir(out_dirl,S_IRWXU|S_IRGRP|S_IROTH)){
# else
if(_mkdir(out_dirl)){
# endif
if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n",
out_dirl,strerror(errno));
}
strcpy(logfile,strcat(strcpy(tmpstr,out_dirl),logfile));
strcpy(trfile,strcat(strcpy(tmpstr,out_dirl),trfile));
}
//# endif // UNIX
int spwn_trj=0;
if(Read_param("Spawn trajectories: %s",tmpstr)){
if(strstr(tmpstr,"y")){
spwn_trj=1;
//Read_paramn(1,"Spawn frame: %d",&spwn_frame);
no_test=1; // no RF test for equilibrartion
}
}
Gas.stable_ions=0;
if(Read_param("Stable ions: %s",tmpstr)){
if(strstr(tmpstr,"y")){
Gas.stable_ions=1;
}
}
int repc_i=0;
if(!Read_param("Repeat counter start: %d",&repc_i))repc_i=0;
int irescale=0;
if(Read_param("Ion velocity rescale: %s",tmpstr)){
if(strstr(tmpstr,"y"))irescale=1;
if(strstr(tmpstr,"reset"))irescale=2;
}
/*
int limrescale=0;
if(Read_param("Rescale on electron temperature reached: %lf %ld",&limTe,&limstpe)==2){
limrescale=1;
limspec=0x2;
limrescale_switch(0);
} */
int limrescale=0;
int inc_mes=0;
if(Read_param("Incremental measurement (T0,dT,mes_steps): %lf,%lf,%ld",&incT0,&incdT,&incStp)==3){
inc_mes=1;
fixT=incT0;
limstpe=1;
limstpi=1;
}
Set_stop(1);
Gas.ini_Te=Gas.ini_Ti=1.; // by default equal temperatures
Read_param("Initial velocity distribution: %s",tmpstr);
if(strstr(tmpstr,"maxwell"))in_distr=MAXWELL;
else if(strstr(tmpstr,"max_polak"))in_distr=MAXWELL_P;
else if(strstr(tmpstr,"zero")){
if(mc_equil){
in_distr=MAXWELL;
printf("Warning: setting 'maxwell' initial vel. distribution for MC!\n");
}
else in_distr=ZEROVEL;
}
else if(strstr(tmpstr,"separate")){
in_distr=SEPARATE;
int &ndistr=Gas.idistr;
int nr;
char relstr[200];
for(i=0;i<2;i++){
if(i==0)nr= Read_param("Electron velocity distribution: %s %lf %s",tmpstr,&Gas.ini_Te,relstr);
else{
nr= Read_param("Ion velocity distribution: %s %lf %s",tmpstr,&Gas.ini_Ti,relstr);
Gas.edistr=ndistr;
}
if(nr<2){
serror("Can't read velocity distribution parameters!\n");
}
if(nr>=2){
if(strstr(relstr,"abs")){
if(i==0)Gas.rel_Te=0;
else Gas.rel_Ti=0;
}
}
if(strstr(tmpstr,"maxwell"))ndistr=MAXWELL;
else if(strstr(tmpstr,"max_polak"))ndistr=MAXWELL_P;
else if(strstr(tmpstr,"zero"))ndistr=ZEROVEL;
else {
printf("Warning: unknown distribution '%s', setting to 'zero'\n",tmpstr);
ndistr=ZEROVEL;
}
}
}
else{
printf("Warning: unknown distribution '%s', setting to 'zero'\n",tmpstr);
in_distr=ZEROVEL;
}
Close_param_file();
Statistics sT(&Gas.T),sEcoul(&Gas.Ecoul),sEpotent(&Gas.Epotent),sQuant(&Gas.Quant), sEtot(&Gas.Etot);
Statistics sTi(&Gas.Ti),sTe(&Gas.Te);
const int nstat=7;
Statistics *stats[nstat]={&sT,&sEcoul,&sEpotent,&sQuant,&sEtot,&sTi,&sTe};
SetTableform(GNU);
if(no_remove){
no_remove=CheckData(sfile,ofile,dataname,np,p,ask);
}
if(restart && !wr_tr && !new_input)serror("No trajectory file specified, cannot restart.\n");
if(restart && new_input && wr_tr)
if(!strcmp(trfile,inptrj))
serror("Equal names for input and output trj-files.\n");
FILE *f1;
if(!no_remove || no_remove==2){
if(!no_remove)f1=Err_fopen(ofile,"wt");
else f1=Err_fopen(ofile,"at");
BeginFrame(f1,dataname,np,p);
fprintf(f1,"%9.9s %9.9s %9.9s %9.9s %9.9s %9.9s %9.9s %9.9s\n",
"T","Ecoul","Epotent","Equant","dT","dEcoul","dEpotent","dEquant");
fclose(f1);
}
double t=0;
f1=fopen(logfile,"rt");
if(f1){
if(!restart && !no_remove){
fclose(f1);
remove(logfile);
}
else {// reading 'log' time
fseek(f1,0,SEEK_END);
long pos=ftell(f1)-4;
do{
fseek(f1,pos,SEEK_SET);
if(fgetc(f1)=='\n'){
fscanf(f1,"%lf",&t);
//printf("new t: %f\n",t);
break;
}
pos--;
}while(pos>=0);
fclose(f1);
}
}
int ccount=CurrentCount(np,p);
WriteStatus(!ccount,sfile,dataname,np,p);
do{
//Gamma=get_pc(p[0]);
//T=get_pc(p[1]);
char ctrfile[256];
sprintf(ctrfile,trfile,dataname,ccount);
char ss[100];
sprintf(ss,"%s%d",dataname,ccount);
sprintf(distrfile,mdistrfile,dataname,ccount);
// StatusLine(str,np,p);
//show_status(440,str);
long i,n,m,nf=0;
//Gas.adjustTG(T,Gamma);
AdjustGas(Gas,p,np);
T=Gas.par_T;
Gamma=Gas.par_Gamma;
double me=0.9109534e-30;
double qe=1.602e-19;
double Kb=1.38e-23;
double unit_t=qe*qe/(4*M_PI*8.854e-12)*sqrt(me);
// overcoming g++ bug with -O3
double jojo=Kb*T*1.e4;
//printf("c2: %e\n",jojo);
jojo=jojo*jojo*jojo;
jojo=sqrt(jojo);
//printf("c21: %e\n",jojo);
unit_t/=jojo;
//printf("c3:\n");
double unit_h=Kb*T*1e4*unit_t;
double h_qwer=1.0545887e-34;
reader.calc_lambda(T,Gas.ini_Te,Gas.ini_Ti,Gas.mass);
/*
if(!non_symm){
if(Lambda_set!=0.0){
Lambda=Lambda_set/unit_l;
equal_lambda=0;
}
else {
Lambda=0.179*sqrt(T);
equal_lambda=1;
}
Lambda_pauli=0.179*sqrt(T);
//non_symm=0;
Lambda_ee=Lambda_pp=Lambda*Clam_ee;
if(fabs(Clam_ee-1.)>1e-5)equal_lambda=0;
Lambda_ep=Lambda*Clam_ep;
}
else{
if(Lambda_set!=0.0){
serror("Can not setup lambda for nonsymmetric plasma.\n");
//Lambda=Lambda_set/unit_l;
//Lambda_ep=Lambda*Clam_ep;
//Lambda_ee=Lambda*Clam_ee;
//equal_lambda=0;
}
else{
if(strstr(Gas.charpot,"Deutsch")){
printf("Setting lambda values for Deutsch potential !!!\n");
Lambda_pauli=h_qwer/(unit_h);
Lambda=Lambda_pauli/sqrt(2*M_PI);
double m_ee=0.5, m_pp=0.5*Gas.mass, m_ep=Gas.mass/(1.+Gas.mass);
Lambda_ee=Lambda/sqrt(m_ee);
Lambda_pp=Lambda/sqrt(m_pp);
Lambda_ep=Lambda/sqrt(m_ep);
}
else { //if(strstr(Gas.charpot,"Kelbg")){
printf("Setting lambda values for Kelbg potential !!!\n");
Lambda_pauli=h_qwer/(unit_h);
Lambda=Lambda_pauli;
double m_ee=0.5, m_pp=0.5*Gas.mass, m_ep=Gas.mass/(1.+Gas.mass);
double t_ep=Gas.ini_Te;
double t_pp=Gas.ini_Ti;
double t_ee=Gas.ini_Te;
Lambda_ee=Lambda/sqrt(2*m_ee*t_ee);
Lambda_pp=Lambda/sqrt(2*m_pp*t_pp);
Lambda_ep=Lambda/sqrt(2*m_ep*t_ep);
}
}
} */
if(rel_step)rf_dtcoeff=1./Gas.Wpe;
double kk=(1.602e-19)*(1.602e-19)/(4*M_PI*1.38e-23*T*1e4*8.854e-12);
printf("Simulation parameters:\n");
printf("Gamma =%f\n"
"L=%f=%12e m\n"
"lambda=%f=%12e m\n"
"1/Wp=%f\n"
"Rd=%f\n",Gamma,Gas.L, Gas.L*kk,reader.Lambda,reader.Lambda*kk,1./Gas.Wpe,RDebye);
printf("Density = %1.2e cm^(-3)\n"
"T= %f K\n",Gas.par_density*1e19,T*1e4);
printf("Time step relations:\n");
printf("dtrf*Wp= %f, dteq*Wp= %f\n", (rel_step ? rf_dt0 : rf_dt0*Gas.Wpe),
(rel_step ? eq_dt : eq_dt*Gas.Wpe));
double t_inter=RDebye/sqrt(2*getEmax(Gas));
printf("dtrf/tint= %f, dteq/tint= %f\n", rf_dt0*rf_dtcoeff/t_inter,
eq_dt*rf_dtcoeff/t_inter);
reader.calc_correction(Gas.par_T);
reader.write_pot(pfile, Gas.L);
/*
//if(ccount==1)t/=Gas.Wpe;
if(pot_corr){
//Correction(IONION,Gas.potential,Gas.par_T);
Correction(IONELC,Gas.potential,Gas.par_T);
Correction(ELCELC,Gas.potential,Gas.par_T);
}*/
Statistics rs[nstat];
int repi=0;
int repc=repc_i;
do{ //through nrepeats
printf("\nStarting calculation #%d...\n",repc);
flm_count=0;
if(repc>0){
repi++;
sprintf(tmpstr,"%02d",repc);
if(repi>1){
distrfile[strlen(distrfile)-2]=0;
ctrfile[strlen(ctrfile)-2]=0;
}
strcat(distrfile,tmpstr);
strcat(ctrfile,tmpstr);
}
if(write_distr){
DRRee.init(rr_r0,(rr_r1>0 ? rr_r1 : Gas.L/2),400);
DRRep.init(rr_r0,(rr_r1>0 ? rr_r1 : Gas.L/2),400);
if(non_symm)DRRpp.init(0,(rr_r1>0 ? rr_r1 : Gas.L/2),400);
}
long ftype=wtype;
if(restart){
printf("restarting...\n");
if((mc_equil && spwn_trj) || mc_calc){
mc_equil=-1;
MC = new mc_simm(Gas,mc_inistep*Gas.L /*Gas.L/Gas.n*/,0.5,
mc_one,mc_diff);
if(!MC)serror("Cannot allocate MCsimm\n");
MC->auto_adjust=auto_adjust;
}
else mc_equil=0;
if(!new_input)strcpy(inptrj,ctrfile);
if(load_fried){
LoadFriedemann(inptrj,Gas);
Gas.dt=eq_dt;
if(rel_step)Gas.dt/=Gas.Wpe;
if(eq_nsteps<wr_int)eq_nsteps=wr_int;
m=wr_int;
n=eq_nsteps/m;
Gas.ext_force=void_force1;
wr_tr=0;
ftype=0;
}
else{
Gas.dt=(rel_step ? eq_dt/Gas.Wpe : eq_dt);
Trajectory.Check(inptrj,wtype,Gas,wr_int,wr_ions,wr_enseq,new_input);
if(Trajectory.wtype !=0 && !new_input){
Gas.dt=Trajectory.AdjustInterval(Gas.dt);
}
long stp;
if(!new_input){
stp=Trajectory.ReloadGas(Gas,1);
t=stp*Trajectory.file_dt();
nf=(long)(t/Gas.dt/wr_int+0.01);
}
else{
stp=Trajectory.ReloadGas(Gas,0);
t=0;
nf=0;
}
printf("t= %f, nf= %ld, %f\n",t,nf,(t/Gas.dt/wr_int));
//serror("Restart is not yet implemented !\n");
Gas.ext_force=void_force1;
}
//restart=0;
}
else{
rand_init=rndlist.step();
if(rand_init<0){
rndlist.rewind();
rand_init=rndlist.step();
}
strcat(distrfile,"e");
if((mc_equil && (!spwn_trj || (repc==repc_i && spwn_trj))) || mc_calc){
mc_equil=1;
MC = new mc_simm(Gas,mc_inistep*Gas.L /*Gas.L/Gas.n*/,0.5,
mc_one,mc_diff);
if(!MC)serror("Cannot allocate MCsimm\n");
MC->auto_adjust=auto_adjust;
}
if(!no_equilibr){
if(!spwn_trj || (spwn_trj && repc==repc_i)){
limrescale_switch(0);
Equillibrium(t,Gas,stats,nstat);
limrescale_switch(limrescale);
}
}
else{
Gas.r0=0.05;
Gas.init_config(in_cs,in_distr);
}
distrfile[strlen(distrfile)-1]=0; // deleting 'e'
if(mc_equil){
if(spwn_trj){
Gas.init_vel(in_distr);
}
else if(!mc_calc){
delete MC;
mc_equil=-1;
}
else
mc_equil=1;
}
Gas.dt=eq_dt;
if(rel_step)Gas.dt/=Gas.Wpe;
}
if(irescale){
if(irescale==1)Gas.ivel_scale(1.);
else Gas.init_vel(in_distr);
}
if(eq_nsteps<wr_int)eq_nsteps=wr_int;
if(wr_int>0){
n=eq_nsteps/wr_int;
m=wr_int;
}
else if(eq_nsteps>=500){
n=eq_nsteps/500;
m=500;
}
else{
n=1;
m=eq_nsteps;
}
if(wr_tr && (!restart || new_input || (restart && ftype==0))){
//WriteHeader(ctrfile,wtype,Gas,Gamma,T, ss,m);
// initializing PlasmaRec
Trajectory.Clear();
Trajectory.Init(ctrfile,wtype,Gas,wr_int,wr_ions,wr_enseq);
}
if(wr_tr && (restart && ftype==0)){
//WriteStep(ctrfile,wtype,Gas,0);
}
Statistics statsl[nstat];
Trajectory.valid=wr_tr;
// new cycle
if(bunch){
PlasmaBunch *pb=(PlasmaBunch *)&Gas;
pb->start_bunch();
}
for(i=nf;i<n;i++){
double term_c=1.;
if(Gas.stable_ions)term_c=(double)Gas.ne/Gas.n;
printf("Equilibrium calculation: %f%% complete, T= %f Et=%f\n",(i+1)*100./n,Gas.T,Gas.T*3/2*term_c+Gas.Epotent/Gas.n);
if(StopStatus(sfile,3)){
StopStatus(sfile,-1);
serror("Program interrupted!\n");
}
if(mc_equil && spwn_trj){
mc_equil=1;
double ratio=MC->get_ratio();
if(ratio<1e-10)printf("Estimated randomization steps: infinity\n");
else printf("Estimated randomization steps: %d\n",(int)(Gas.n*Gas.L/MC->dc[1]/ratio));
}
MoveIt(t,m,m,Gas,stats,statsl,nstat);
//if(wr_tr)WriteStep(ctrfile,wtype,Gas,i);
if(write_distr)WriteDRR(distrfile);
if(wr_film)WriteFilm(filmdir,Gas);
}
if(bunch){
PlasmaBunch *pb=(PlasmaBunch *)&Gas;
pb->stop_bunch();
}
if(write_distr)WriteDRR(distrfile);
for(i=0;i<nstat;i++)rs[i]+=*(stats[i]);
repc++;
if(new_input)restart=0;
}while(repc<nrepeats);
if(spwn_trj)delete MC;
f1=Err_fopen(ofile,"at");
MiddleFrame(f1,np,p);
int gn=Gas.n;
//fprintf(f1,"%9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f\n",
// sT.av()*T,sEcoul.av()/gn,sEpotent.av()/gn,sQuant.av()/gn,
// sT.dev()*T,sEcoul.dev()/gn,sEpotent.dev()/gn,sQuant.dev()/gn);
fprintf(f1,"%9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f\n",
rs[0].av()*T,rs[1].av()/gn,rs[2].av()/gn,rs[3].av()/gn,
rs[0].dev()*T,rs[1].dev()/gn,rs[2].dev()/gn,rs[3].dev()/gn);
fclose(f1);
ccount=CycleCount(np,p);
WriteStatus(!ccount,sfile,dataname,np,p);
restart=0;
repc=0;
}while(ccount);
return 0;
}
static int NewWiFiWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
int id,nc;
static char keyupFlag=0;
switch (message)
{
case MSG_CREATE:
wifidhcpflag = gOptions.wifidhcpfunon;
InitWifiWindow(hWnd); //add controls
InitParameters();
curFocusWnd =0;
SetFocusChild(WifiWnd[curFocusWnd]);
UpdateWindow(hWnd,TRUE);
break;
case MSG_ERASEBKGND:
{
HDC hdc = (HDC)wParam;
const RECT* clip = (const RECT*)lParam;
BOOL fGetDC = FALSE;
RECT rcTemp;
if(hdc == 0) {
hdc = GetClientDC(hWnd);
fGetDC = TRUE;
}
if(clip) {
rcTemp = *clip;
ScreenToClient(hWnd, &rcTemp.left, &rcTemp.top);
ScreenToClient(hWnd,&rcTemp.right, &rcTemp.bottom);
IncludeClipRect(hdc, &rcTemp);
}
FillBoxWithBitmap (hdc, 0, 0, gOptions.LCDWidth, 0, &wifibkg);
if(fGetDC) {
ReleaseDC (hdc);
}
return 0;
}
case MSG_PAINT:
hdc=BeginPaint(hWnd);
EndPaint(hWnd,hdc);
return 0;
case MSG_KEYUP:
if(3 == gOptions.TFTKeyLayout){
keyupFlag=1;
}
break;
case MSG_KEYDOWN:
SetMenuTimeOut(time(NULL));
if (3 == gOptions.TFTKeyLayout) {
if (1==keyupFlag) {
keyupFlag=0;
} else {
break;
}
}
if (gOptions.KeyPadBeep){
ExKeyBeep();
}
if ((LOWORD(wParam)==SCANCODE_ESCAPE)){
PostMessage(hWnd, MSG_COMMAND, WIFI_EXIT, 0);
} else if (LOWORD(wParam)==SCANCODE_CURSORBLOCKDOWN) {
char tmpssid[128];
if (curFocusWnd==0) {
GetWindowText(WifiWnd[0], tmpssid, sizeof(tmpssid));
if(tmpssid && strlen(tmpssid)>0) {
if(hIMEWnd!=HWND_INVALID){
SendMessage(hIMEWnd,MSG_CLOSE,0,0L);
hIMEWnd=HWND_INVALID;
}
curFocusWnd++;
}
} else if (curFocusWnd==1) {
if(hIMEWnd!=HWND_INVALID){
SendMessage(hIMEWnd,MSG_CLOSE,0,0L);
hIMEWnd=HWND_INVALID;
}
curFocusWnd++;
} else if(++curFocusWnd>16) {
curFocusWnd=0;
}
if (wifidhcpflag == 1 && curFocusWnd == 3) {
curFocusWnd=15;
}
if (curFocusWnd == 4 || curFocusWnd == 5 ||curFocusWnd == 6 ){
curFocusWnd = 7;
}
if (curFocusWnd == 8 || curFocusWnd == 9 || curFocusWnd == 10){
curFocusWnd = 11;
}
if (curFocusWnd == 12 || curFocusWnd == 13 || curFocusWnd == 14){
curFocusWnd = 15;
}
SetFocusChild(WifiWnd[curFocusWnd]);
return 0;
} else if (LOWORD(wParam)==SCANCODE_CURSORBLOCKUP){
char tmpssid[128];
if(curFocusWnd==0){
GetWindowText(WifiWnd[0], tmpssid, sizeof(tmpssid));
if(tmpssid && strlen(tmpssid)>0){
if(hIMEWnd!=HWND_INVALID){
SendMessage(hIMEWnd,MSG_CLOSE,0,0L);
hIMEWnd=HWND_INVALID;
}
curFocusWnd--;
}
} else if (curFocusWnd==1) {
if(hIMEWnd!=HWND_INVALID){
SendMessage(hIMEWnd,MSG_CLOSE,0,0L);
hIMEWnd=HWND_INVALID;
}
curFocusWnd--;
} else if(--curFocusWnd<0){
curFocusWnd=16;
}
if (wifidhcpflag == 1 && curFocusWnd == 14) {
curFocusWnd= 2;
}
if (curFocusWnd == 10|| curFocusWnd == 11|| curFocusWnd == 12 ||curFocusWnd == 13 ){
curFocusWnd = 7;
} else if (curFocusWnd == 6|| curFocusWnd == 7|| curFocusWnd == 8 || curFocusWnd == 9){
curFocusWnd = 3;
} else if (curFocusWnd == 3 || curFocusWnd == 4 || curFocusWnd == 5){
curFocusWnd = 2;
} else if(curFocusWnd == 14){
curFocusWnd = 11;
}
SetFocusChild(WifiWnd[curFocusWnd]);
return 0;
} else if(LOWORD(wParam)==SCANCODE_F9 ||
((gOptions.TFTKeyLayout==0 || gOptions.TFTKeyLayout==4) && (LOWORD(wParam)==SCANCODE_F11))) {
if((curFocusWnd==0 || curFocusWnd==1) && (gOptions.IMEFunOn==1 && gOptions.TFTKeyLayout!=3))
{
T9IMEWindow(hWnd,0,200,gOptions.LCDWidth, gOptions.LCDHeight,gOptions.HzImeOn);
}
} else if ((LOWORD(wParam)==SCANCODE_CURSORBLOCKLEFT) || (LOWORD(wParam)==SCANCODE_CURSORBLOCKRIGHT)
|| ((gOptions.TFTKeyLayout==3) && LOWORD(wParam)==SCANCODE_BACKSPACE)) {
if ((LOWORD(wParam)==SCANCODE_CURSORBLOCKRIGHT) && gOptions.IMEFunOn==1
&& gOptions.TFTKeyLayout==3 && (curFocusWnd==0 || curFocusWnd==1)) {
T9IMEWindow(hWnd,0,200,gOptions.LCDWidth, gOptions.LCDHeight, 0);
return 0;
}
if(curFocusWnd==2 && ((LOWORD(wParam)==SCANCODE_CURSORBLOCKLEFT || ((gOptions.TFTKeyLayout==3) && LOWORD(wParam)==SCANCODE_BACKSPACE))
||LOWORD(wParam)==SCANCODE_CURSORBLOCKRIGHT)) {
int tmpsel = SendMessage(WifiWnd[curFocusWnd], CB_GETCURSEL, 0, 0);
if (tmpsel == 0) {
SendMessage(WifiWnd[curFocusWnd], CB_SETCURSEL, 1, 0);
dhcpswitch(1);
UpdateWindow(hWnd,TRUE);
wifidhcpflag =1;
} else {
SendMessage(WifiWnd[curFocusWnd], CB_SETCURSEL, 0, 0);
dhcpswitch(0);
UpdateWindow(hWnd,TRUE);
wifidhcpflag = 0;
}
}
if (curFocusWnd >2 && curFocusWnd<15 && wifidhcpflag ==0) {
if (LOWORD(wParam)==SCANCODE_CURSORBLOCKLEFT ){
curFocusWnd --;
if (curFocusWnd == 2){
curFocusWnd =14;
}
}else if (LOWORD(wParam)==SCANCODE_CURSORBLOCKRIGHT){
curFocusWnd ++;
if (curFocusWnd ==15){
curFocusWnd = 3;
}
}
SetFocusChild(WifiWnd[curFocusWnd]);
}
return 0;
} else if ((LOWORD(wParam)==SCANCODE_ENTER) || (LOWORD(wParam)==SCANCODE_F10)) {
char tmpssid[128];
switch(curFocusWnd)
{
case 0:
GetWindowText(WifiWnd[0], tmpssid, sizeof(tmpssid));
if(tmpssid && strlen(tmpssid)>0)
SendMessage(hWnd, MSG_COMMAND, WIFI_SAVE, 0);
else
MessageBox1(hWnd ,LoadStrByID(HIT_ERROR0) ,LoadStrByID(HIT_ERR),MB_OK | MB_ICONINFORMATION);
break;
case 16: //exit
SendMessage(hWnd, MSG_COMMAND, WIFI_EXIT, 0);
break;
default:
SendMessage(hWnd, MSG_COMMAND, WIFI_SAVE, 0);
}
return 0;
} else if(LOWORD(wParam)==SCANCODE_MENU) {
SendMessage(hWnd, MSG_COMMAND, WIFI_SAVE, 0);
return 0;
}
break;
case MSG_COMMAND:
id = LOWORD(wParam);
nc = HIWORD(wParam);
if(id==WIFI_SAVE) {
if(isModified() && SaveNewWiFiSetting(hWnd)) {
MessageBox1(hWnd ,LoadStrByID(HIT_RIGHT) ,LoadStrByID(HIT_RUN),MB_OK| MB_ICONINFORMATION);
if(!ismenutimeout) {
PostMessage(hWnd, MSG_CLOSE, 0, 0);
}
} else if(!ismenutimeout) {
PostMessage(hWnd, MSG_CLOSE, 0, 0);
}
} else if (id==WIFI_EXIT) {
if(isModified() && MessageBox1(hWnd,LoadStrByID(MID_SAVEDATA),LoadStrByID(MID_APPNAME),
MB_OKCANCEL|MB_ICONQUESTION|MB_BASEDONPARENT)==IDOK) {
PostMessage(hWnd, MSG_COMMAND, WIFI_SAVE, 0);
} else if(!ismenutimeout) {
PostMessage(hWnd, MSG_CLOSE, 0, 0);
}
}
break;
case MSG_CLOSE:
if(hIMEWnd!=HWND_INVALID){
SendMessage(hIMEWnd,MSG_CLOSE,0,0);
hIMEWnd=HWND_INVALID;
}
UnloadBitmap(&wifibkg);
//MainWindowCleanup(hWnd);
DestroyMainWindow(hWnd);
return 0;
}
return DefaultMainWinProc(hWnd,message,wParam,lParam);
}
QSimpleTextItem::QSimpleTextItem(QString sText)
{
sTEXT = sText; //默认文本
m_rect.setRect(0,0,100,100); //给背景矩形赋初始值
InitParameters();
}
