//__________________________________________________________________________________
void mpiBgmLoop (int rank, int size)
{
long senderID = 0;
_String * resStr = nil;
ReportWarning (_String ("MPI Node:") & (long)rank & " is ready for MPIBgmCacheNodeScores tasks");
// receive serialized Bgm
_String* theMessage = MPIRecvString (-1, senderID);
while (theMessage->sLength) {
_ExecutionList exL (*theMessage);
_PMathObj res = exL.Execute(); // should send this process into CacheNodeScores()
resStr = res ? (_String*)res->toStr() : new _String ("0");
ReportWarning (_String ("MPI Node: ") & (long)rank & " executed HBL with result:\n" & resStr);
if (bgmNamesList.lLength < 1) {
_String errMsg ("Malformed HBL. No valid BGM has been defined.\n");
FlagError (errMsg);
break;
}
}
DeleteObject (theMessage);
}
//__________________________________________________________________________________
void mpiOptimizerLoop (int rank, int size)
{
long senderID = 0;
ReportWarning (_String ("MPI Node:") & (long)rank & " is ready for MPIParallelOptimizer tasks");
if (mpiPartitionOptimizer)
ReportWarning (_String("MPI Partitions mode"));
//printf ("Node %d waiting for a string\n", rank);
_String* theMessage = MPIRecvString (-1,senderID);
while (theMessage->sLength)
{
if (theMessage->beginswith ("#NEXUS"))
{
ReadDataSetFile (nil,true,theMessage);
if (likeFuncNamesList.lLength!=1)
{
_String errMsg ("Malformed MPI likelihood function paraller optimizer startup command. No valid LF has been defined.n\n\n");
FlagError (errMsg);
break;
}
// send back the list of independent variables
_LikelihoodFunction * theLF = (_LikelihoodFunction*)likeFuncList (0);
if (mpiParallelOptimizer && theLF->GetCategoryVars().lLength)
{
_String errMsg ("Likelihood functions spawned off to slave MPI nodes can't have category variables.n\n\n");
FlagError (errMsg);
break;
}
_SimpleList* ivl = & theLF->GetIndependentVars();
_String variableSpec (128L, true);
(variableSpec) << LocateVar(ivl->lData[0])->GetName();
for (long kk = 1; kk < ivl->lLength; kk++)
{
(variableSpec) << ';';
(variableSpec) << LocateVar(ivl->lData[kk])->GetName();
}
ReportWarning (variableSpec);
MPISendString (variableSpec,senderID);
theLF->PrepareToCompute();
theLF->MPI_LF_Compute (senderID, mpiPartitionOptimizer);
theLF->DoneComputing();
PurgeAll (true);
}
DeleteObject (theMessage);
theMessage = MPIRecvString (-1,senderID);
}
DeleteObject (theMessage);
}
//__________________________________________________________________________________
void mpiOptimizerLoop (int rank, int size)
{
long senderID = 0;
ReportWarning (_String ("[MPI] Node:") & (long)rank & " is ready for MPIParallelOptimizer tasks");
if (hyphyMPIOptimizerMode == _hyphyLFMPIModePartitions)
ReportWarning ("[MPI] MPI Partitions mode");
//printf ("Node %d waiting for a string\n", rank);
_String* theMessage = MPIRecvString (-1,senderID);
while (theMessage->sLength)
{
if (theMessage->beginswith ("#NEXUS"))
{
//ReportWarning (*theMessage);
ReadDataSetFile (nil,true,theMessage);
if (likeFuncNamesList.lLength!=1)
{
FlagError ("[MPI] Malformed MPI likelihood function paraller optimizer startup command. Exactly ONE valid LF must be defined.n\n\n");
break;
}
// send back the list of independent variables
_LikelihoodFunction * theLF = (_LikelihoodFunction*)likeFuncList (0);
if (hyphyMPIOptimizerMode == _hyphyLFMPIModeREL && theLF->CountObjects (4))
{
FlagError (_String("[MPI] Likelihood functions spawned off to slave MPI nodes can't have category variables.n\n\n"));
break;
}
_SimpleList* ivl = & theLF->GetIndependentVars();
_String variableSpec (128L, true);
(variableSpec) << LocateVar(ivl->lData[0])->GetName();
for (long kk = 1; kk < ivl->lLength; kk++)
{
(variableSpec) << ';';
(variableSpec) << LocateVar(ivl->lData[kk])->GetName();
}
variableSpec.Finalize();
ReportWarning (_String("[MPI] Sending back the following variable list\n") & variableSpec);
MPISendString (variableSpec,senderID);
theLF->PrepareToCompute();
theLF->MPI_LF_Compute (senderID, !(hyphyMPIOptimizerMode == _hyphyLFMPIModeREL ||
hyphyMPIOptimizerMode == _hyphyLFMPIModeSiteTemplate));
theLF->DoneComputing();
PurgeAll (true);
}
DeleteObject (theMessage);
theMessage = MPIRecvString (-1,senderID);
}
DeleteObject (theMessage);
}
void Device::Open(QString path, bool close) {
this->path = path;
problemReported = false;
if(close)
Close();
// skip opening device pointing to result file
if(path.length() == 0)
return;
// open device file
fd = open(path.toUtf8(), O_RDONLY | O_LARGEFILE | O_SYNC);
if(fd < 0) {
ReportWarning();
}
DropCaches();
// get drive size
device_size = lseek64(fd, 0, SEEK_END);
// set pos to begin of device
SetPos(0);
DriveInfo();
}
void Device::DropCaches() {
// give advice to disable caching
int ret = posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
if(ret)
ReportWarning();
// empty caches
QFile caches("/proc/sys/vm/drop_caches");
caches.open(QIODevice::WriteOnly);
if(caches.isOpen()) {
caches.putChar('3');
caches.close();
} else {
ReportWarning();
}
}
/**
* Reports errors related to unplugged joysticks
* Throttles the errors so that they don't overwhelm the DS
*/
void DriverStation::ReportJoystickUnpluggedWarning(std::string message) {
double currentTime = Timer::GetFPGATimestamp();
if (currentTime > m_nextMessageTime) {
ReportWarning(message);
m_nextMessageTime = currentTime + JOYSTICK_UNPLUGGED_MESSAGE_INTERVAL;
}
}
_PMathObj _Variable::Compute (void) // compute or return the value
{
if (varFormula == nil) { // no formula, just return the value
if (varValue) {
return varValue->Compute();
}
if (varFlags & HY_VARIABLE_NOTSET) {
ReportWarning (_String ("Variable '") & *GetName() & "' was not initialized prior to being used");
}
varValue = new _Constant(theValue);
} else {
//printf ("Recomputing value of %s\n", theName->sData);
if (useGlobalUpdateFlag) {
if ((varFlags & HY_DEP_V_COMPUTED) && varValue) {
return varValue;
} else if (varFormula->HasChanged()||!varValue) {
DeleteObject (varValue);
varValue = (_PMathObj)varFormula->Compute()->makeDynamic();
}
varFlags |= HY_DEP_V_COMPUTED;
} else if (varFormula->HasChanged()||!varValue) {
DeleteObject (varValue);
varValue = (_PMathObj)varFormula->Compute()->makeDynamic();
}
}
return varValue;
}
void _HYPlatformGraphicPane::_DrawPicRes (_HYRect& r, long id)
{
PicHandle aPic = GetPicture (id);
if (aPic)
{
Rect aRect = HYRect2Rect (r);
PictInfo pInfo;
GetPictInfo (aPic,&pInfo,0,0,0,0);
if (aRect.right-aRect.left<=0)
r.right = aRect.right = aRect.left + pInfo.sourceRect.right - pInfo.sourceRect.left;
if (aRect.bottom-aRect.top<=0)
r.bottom = aRect.bottom = aRect.top + pInfo.sourceRect.bottom - pInfo.sourceRect.top;
DrawPicture (aPic, &aRect);
ReleaseResource ((Handle)aPic);
}
else
{
_String errMsg = _String ("No picture resource with ID ") & id;
ReportWarning (errMsg);
}
}
/****************************************************************************\
**
** tInputFile::ReadItem
**
** Reads one parameter from the file. The format is assumed to be a line
** of text that begins with the code "itemCode", followed by a line containing
** the parameter to be read. The function is overloaded according to the
** type of data desired (datType simply governs which overloaded function
** will be called; it is not used by the routines).
**
** Inputs: datType -- dummy variable indicating the data type to be read
** (in the case of the string version, the string read
** is placed here)
** itemCode -- string that describes the parameter to be read
** Returns: the item read (except in the case of the string version)
** Modifications:
** - revised to allow arbitrary ordering of items in infile and/or
** ReadItem calls in code; routine searches through
** list until it either finds the right itemCode or reaches EOF.
** 12/23/97 SL
** - rewritten 11/07/2003 AD
** - can merely issue warning and return zero-value if bool reqParam =
** true. 9/12/03 SL
**
\****************************************************************************/
static
void ReportNonExistingKeyWord(const char *itemCode, bool reqParam ){
std::cerr << "Cannot find '" << itemCode
<< "' in the input file." << std::endl;
if( reqParam )
ReportFatalError( "Missing parameter in input file" );
else
ReportWarning( "Missing parameter in input file, use zero or default value" );
}
Texture::Texture(const char* filename, GLenum image_format, GLint internal_format, GLint level, GLint border)
{
glGenTextures(1, &this->id);
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
FIBITMAP *dib(0);
BYTE* bits(0);
unsigned int width(0), height(0);
GLuint gl_texID;
fif = FreeImage_GetFileType(filename, 0); //pobieranie typu tekstury
if (fif == FIF_UNKNOWN)
fif = FreeImage_GetFIFFromFilename(filename);
if (fif == FIF_UNKNOWN){
ReportWarning("Texture file format undefined");
return;
}
if (FreeImage_FIFSupportsReading(fif)) //sprawdza czy moze odczytac
dib = FreeImage_Load(fif, filename); //odczytuje
if (!dib)
ReportWarning("Could not load texture");
bits = FreeImage_GetBits(dib); //rozmiar piksela
width = FreeImage_GetWidth(dib); //wielkosc tekstury
height = FreeImage_GetHeight(dib);
//if((bits == 0) || (width == 0) || (height == 0))
//ReportWarning("Wrong bits");
glBindTexture(GL_TEXTURE_2D, this->id); //bindowanie i ustawianie parametrow tekstury
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, level, internal_format, width, height, //generowanie tekstury
border, image_format, GL_UNSIGNED_BYTE, bits);
FreeImage_Unload(dib);
}
int main(void)
{
char str[BUFSIZ + 1];
int ErrorCode;
ErrorCode = 1;
while (ErrorMessage[ErrorCode - 1] != NULL) {
sprintf(str, "Test -- Code %d", ErrorCode);
ReportWarning(str, ErrorCode);
++ErrorCode;
}
fprintf(stderr, "\n");
ReportWarning("", 3);
fprintf(stderr,
"\nThe test is SUCCESSFUL if the next line is the same as the line "
"above:\n\n");
ReportError("", 3);
return EXIT_SUCCESS;
}
//__________________________________________________________________________________
_PMathObj _Constant::CChi2 (_PMathObj n)
// chi^2 n d.f. probability up to x
{
_Constant halfn (((_Constant*)n)->theValue*.5),
halfx (theValue*0.5);
if (theValue < 0. || halfn.theValue <= 0.) {
ReportWarning ("CChi2(x,n) only makes sense for both arguments positive");
return new _Constant (0.0);
}
return halfn.IGamma( &halfx);
}
//__________________________________________________________________________________
void ProcessConfigStr (_String& conf)
{
_String errMsg;
for (long i=1; i<conf.sLength; i++)
{
switch (conf.sData[i])
{
case 'p':
case 'P':
{
usePostProcessors = true;
break;
}
case 'c':
case 'C':
{
calculatorMode = true;
break;
}
case 'd':
case 'D':
{
dropIntoDebugMode = true;
break;
}
case 'u':
case 'U':
{
updateMode = true;
break;
}
case 'l':
case 'L':
{
logInputMode = true;
break;
}
//case 'i':
//case 'I':
//{
//pipeMode = true;
//break;
//}
default:
{
errMsg = "Option ";
errMsg = errMsg & conf.sData[i] & " is not valid and is ignored";
ReportWarning (errMsg);
}
}
}
}
//__________________________________________________________________________________
_PMathObj _Constant::InvChi2 (_PMathObj n)
// chi^2 n d.f. probability up to x
{
if (!chi2) {
_String fla ("IGamma(_n_,_x_)");
chi2 = new _Formula (fla, nil);
fla = "_x_^(_n_-1)/Gamma(_n_)/Exp(_x_)";
derchi2 = new _Formula (fla,nil);
}
_Constant halfn (((_Constant*)n)->theValue*.5);
if ((theValue<0)||(halfn.theValue<0)||(theValue>1.0)) {
_String warnMsg ("InvChi2(x,n) only makes sense for n positive, and x in [0,1]");
ReportWarning (warnMsg);
return new _Constant (0.0);
}
LocateVar(dummyVariable2)->SetValue (&halfn);
halfn.SetValue(chi2->Newton(*derchi2,theValue,1e-25,1.e100,LocateVar(dummyVariable1))*2);
return (_PMathObj)halfn.makeDynamic();
}
void MPISwitchNodesToMPIMode (long totalNodeCount)
{
_String message = mpiLoopSwitchToOptimize & hyphyMPIOptimizerMode;
// send a context switch signal
for (long ni = 1; ni <= totalNodeCount; ni++)
MPISendString (message, ni);
// receive confirmation of successful switch
for (long ni = 1; ni <= totalNodeCount; ni++)
{
long fromNode = ni;
_String t (MPIRecvString (ni,fromNode));
if (!t.Equal (&mpiLoopSwitchToOptimize))
{
WarnError (_String("[MPI] Failed to confirm MPI mode switch at node ") & ni);
return;
}
else
ReportWarning (_String("[MPI] Successful mode switch to mode ") & hyphyMPIOptimizerMode & " confirmed from node " & ni);
}
}
bool InitWindow( uint32_t hWnd )
{
if ( !InitialiseOpenGLWindow( hWnd, 0, 0, OpenGL.WindowWidth, OpenGL.WindowHeight ) ) {
Error( "Failed to Initialise OpenGL Window!\n" );
return false;
}
if ( !strcmp( (char*)glGetString( GL_RENDERER ), "GDI Generic" ) )
ReportWarning("You are running in a Non-Accelerated OpenGL!!!\nThings can become really slow");
ValidateUserConfig( );
GlideMsg( OGL_LOG_SEPARATE );
GlideMsg( " Setting in Use: \n" );
GlideMsg( OGL_LOG_SEPARATE );
GlideMsg( "Init Full Screen = %s\n", InternalConfig.InitFullScreen ? "true" : "false" );
GlideMsg( "Fog = %s\n", InternalConfig.FogEnable ? "true" : "false" );
GlideMsg( "Precision Fix = %s\n", InternalConfig.PrecisionFix ? "true" : "false" );
GlideMsg( "Wrap 565 to 5551 = %s\n", InternalConfig.Wrap565to5551 ? "true" : "false" );
GlideMsg( "Texture Memory Size = %d Mb\n", InternalConfig.TextureMemorySize );
GlideMsg( "Frame Buffer Memory Size = %d Mb\n", InternalConfig.FrameBufferMemorySize );
GlideMsg( "MMX is %s\n", InternalConfig.MMXEnable ? "present" : "not present" );
GlideMsg( OGL_LOG_SEPARATE );
#ifdef OGL_DEBUG
GlideMsg( OGL_LOG_SEPARATE );
GlideMsg( "GlideState size = %d\n", sizeof( GlideState ) );
GlideMsg( "GrState size = %d\n", sizeof( GrState ) );
GlideMsg( OGL_LOG_SEPARATE );
#endif
GlideMsg( OGL_LOG_SEPARATE );
GlideMsg( "** Glide Calls **\n" );
GlideMsg( OGL_LOG_SEPARATE );
return true;
}
void TrainModelNN (_String* model, _String* matrix)
{
_String errMsg;
long modelIdx = modelNames.Find(model);
_Parameter verbI;
checkParameter (VerbosityLevelString, verbI, 0.0);
char buffer [128];
if (modelIdx < 0) {
errMsg = *model & " did not refer to an existring model";
} else {
_Variable* boundsMatrix = FetchVar (LocateVarByName (*matrix));
if (boundsMatrix && (boundsMatrix->ObjectClass() == MATRIX)) {
_Matrix * bmatrix = (_Matrix*) boundsMatrix->GetValue ();
if (bmatrix->IsAStringMatrix() && (bmatrix->GetVDim () == 3)) {
_Variable* modelMatrix = LocateVar (modelMatrixIndices.lData[modelIdx]);
_SimpleList modelVariableList;
{
_AVLList mvla (&modelVariableList);
modelMatrix->ScanForVariables (mvla, true);
mvla.ReorderList();
}
if (bmatrix->GetHDim () == modelVariableList.lLength) {
// now map model variables to bounds matrix
_SimpleList variableMap;
_String *myName;
for (long k = 0; k < modelVariableList.lLength; k++) {
myName = ((_FString*)bmatrix->GetFormula(k,0)->Compute())->theString;
long vID = LocateVarByName (*myName);
if (vID < 0) {
break;
}
vID = variableNames.GetXtra (vID);
vID = modelVariableList.Find(vID);
if (vID < 0) {
break;
}
variableMap << vID;
}
if (variableMap.lLength == modelVariableList.lLength) {
_Matrix vBounds (variableMap.lLength,2, false, true);
long k2 = 0;
for (; k2 < variableMap.lLength; k2++) {
_Parameter lb = ((_FString*)bmatrix->GetFormula(k2,1)->Compute())->theString->toNum(),
ub = ((_FString*)bmatrix->GetFormula(k2,2)->Compute())->theString->toNum();
if ( ub>lb || k2) {
vBounds.Store (k2,0,lb);
vBounds.Store (k2,1,ub);
if (ub<=lb && vBounds (k2-1,0) <= vBounds (k2-1,1) && (!CheckEqual(vBounds (k2-1,0),0.0) || !CheckEqual(vBounds (k2-1,1),1.0))) {
break;
}
}
}
if (k2 == modelVariableList.lLength) {
// set up the sampling now
_String fName = ProcessLiteralArgument (&ModelNNFile,nil);
FILE* nnFile = doFileOpen (fName.getStr(), "w");
if (nnFile) {
_Matrix* modelMatrix = (_Matrix*) LocateVar(modelMatrixIndices.lData[modelIdx])->GetValue();
_Parameter mainSteps,
checkSteps,
errorTerm,
loopMax,
hiddenNodes,
absError,
nn1,
nn2;
long fullDimension = modelMatrix->GetHDim() * modelMatrix->GetVDim();
checkParameter (ModelNNTrainingSteps, mainSteps, 10000.0);
checkParameter (ModelNNVerificationSample, checkSteps, 500.0);
checkParameter (ModelNNPrecision, errorTerm, 0.01);
checkParameter (ModelNNTrainingSteps, loopMax, 10);
checkParameter (ModelNNHiddenNodes, hiddenNodes, 5);
checkParameter (ModelNNLearningRate, nn1, .3);
checkParameter (ModelNNPersistenceRate, nn2, .1);
Net** matrixNet = new Net* [fullDimension] ;
for (long i = 0; i < fullDimension; i++) {
checkPointer (matrixNet [i] = new Net (variableMap.lLength,(long)hiddenNodes,1,errorTerm,nn1,nn2,100,200,true));
//matrixNet[i]->verbose = true;
}
checkPointer (matrixNet);
_List tIn,
tOut;
FILE* varSamples = doFileOpen ("variableSamples.out", "w");
fprintf (varSamples, "%s" ,LocateVar(modelVariableList.lData[0])->GetName()->getStr());
for (long vc = 1; vc < modelVariableList.lLength; vc++) {
fprintf (varSamples, ",%s" ,LocateVar(modelVariableList.lData[variableMap.lData[vc]])->GetName()->getStr());
}
fprintf (varSamples, "\n");
for (long itCount = 0; itCount < loopMax; itCount ++) {
if (verbI > 5) {
snprintf (buffer, sizeof(buffer), "\nNeural Network Pass %ld. Building a training set...\n", itCount);
BufferToConsole (buffer);
}
while (tIn.countitems() < mainSteps) {
NNMatrixSampler (0, vBounds, modelVariableList, variableMap, modelMatrix, tIn, tOut);
}
_Matrix inData (mainSteps, variableMap.lLength, false, true);
_Parameter *md = inData.theData;
for (long matrixC = 0; matrixC < mainSteps; matrixC++) {
_Parameter * ed = ((_Matrix*)tIn (matrixC))->theData;
fprintf (varSamples, "\n%g",*ed);
*md = *ed;
ed++;
md++;
for (long entryC = 1; entryC < variableMap.lLength; entryC++, ed++, md++) {
*md = *ed;
fprintf (varSamples, ",%g", *md);
}
}
tIn.Clear();
if (verbI > 5) {
BufferToConsole ( "Done Building Training Set. Training...\n");
}
long lastDone = 0;
for (long cellCount = 0; cellCount < fullDimension; cellCount++) {
Net* thisCell = matrixNet[cellCount];
_Matrix outVector (mainSteps, 1, false, true);
for (long oc = 0; oc < mainSteps; oc++) {
outVector.theData[oc] = ((_Matrix*)tOut(oc))->theData[cellCount];
}
thisCell->studyAll (inData.theData, outVector.theData, mainSteps);
long nowDone = (cellCount+1)*100./fullDimension;
if (nowDone > lastDone) {
snprintf (buffer, sizeof(buffer),"%ld%% done\n", lastDone = nowDone);
BufferToConsole (buffer);
}
}
tOut.Clear();
if (verbI > 5) {
BufferToConsole ( "Done Training. Resampling...\n");
}
_PMathObj tObj = _Constant(0).Time();
_Parameter time1 = tObj->Value(),
time2;
while (tIn.countitems() < checkSteps) {
NNMatrixSampler (0, vBounds, modelVariableList, variableMap, modelMatrix, tIn, tOut);
}
absError = 0.0;
DeleteObject (tObj);
tObj = _Constant(0).Time();
time2 = tObj->Value();
if (verbI > 5) {
snprintf (buffer, sizeof(buffer),"Done Resampling in %g seconds. Computing Error...\n", time2-time1);
BufferToConsole (buffer);
}
_Parameter maxValT,
maxValE;
for (long verCount = 0; verCount < checkSteps; verCount++) {
_Parameter* inData = ((_Matrix*)tIn(verCount))->theData,
* outData = ((_Matrix*)tOut(verCount))->theData;
for (long cellCount = 0; cellCount < fullDimension; cellCount++) {
Net *thisCell = matrixNet[cellCount];
_Parameter estVal = thisCell->eval(inData)[0],
trueVal = outData[cellCount],
localError;
localError = estVal-trueVal;
if (localError < 0) {
localError = -localError;
}
if (absError < localError) {
maxValT = trueVal;
maxValE = estVal;
absError = localError;
}
}
}
DeleteObject (tObj);
tObj = _Constant(0).Time();
time1 = tObj->Value();
DeleteObject (tObj);
if (verbI > 5) {
snprintf (buffer, sizeof(buffer), "Done Error Checking in %g seconds. Got max abs error %g on the pair %g %g\n", time1-time2, absError, maxValT, maxValE);
BufferToConsole (buffer);
}
if (absError <= errorTerm) {
break;
}
}
if (absError > errorTerm) {
ReportWarning (_String("Couldn't achive desired precision in TrainModelNN. Achieved error of ") & absError);
}
fclose (varSamples);
fprintf (nnFile,"{{\n\"%s\"", LocateVar(modelVariableList.lData[0])->GetName()->getStr());
_Matrix newBounds (modelVariableList.lLength, 2, false, true);
if (vBounds(0,0)>vBounds(0,1)) {
newBounds.Store (variableMap.lData[0],0,0.);
newBounds.Store (variableMap.lData[0],1,1.);
} else {
newBounds.Store (variableMap.lData[0],0,vBounds(0,0));
newBounds.Store (variableMap.lData[0],1,vBounds(0,1));
}
for (long varCounter = 1; varCounter < modelVariableList.lLength; varCounter ++) {
fprintf (nnFile,",\n\"%s\"", LocateVar(modelVariableList.lData[varCounter])->GetName()->getStr());
if (vBounds(varCounter,0)>vBounds(varCounter,1)) {
newBounds.Store (variableMap.lData[varCounter],0,0.);
newBounds.Store (variableMap.lData[varCounter],1,1.);
} else {
newBounds.Store (variableMap.lData[varCounter],0,vBounds(varCounter,0));
newBounds.Store (variableMap.lData[varCounter],1,vBounds(varCounter,1));
}
}
fprintf (nnFile,"\n}}\n");
newBounds.toFileStr (nnFile);
for (long i2 = 0; i2 < fullDimension; i2++) {
matrixNet[i2]->save(nnFile);
delete matrixNet [i2];
}
fclose (nnFile);
delete matrixNet;
} else {
errMsg = _String ("Failed to open ") & fName & " for writing";
}
} else {
errMsg = _String ("Invalid variable bounds in row ") & (k2+1) & " of the bounds matrix";
}
} else {
errMsg = *myName & " was not one of the model parameters";
}
} else {
errMsg = *matrix & " must be a have the same number of rows as the number of model parameters";
}
} else {
errMsg = *matrix & " must be a string matrix with 3 columns";
}
} else {
errMsg = *matrix & " was not the identifier of a valid matrix variable";
}
}
if (errMsg.sLength) {
errMsg = errMsg & _String(" in call to TrainModelNN.");
WarnError (errMsg);
}
}
void MessageBoxReporter::ReportError(const std::wstring& message)
{
ReportWarning(message, m_wsDefaultTitle);
}
//__________________________________________________________________________________
void mpiNormalLoop (int rank, int size, _String & baseDir)
{
long senderID = 0;
ReportWarning ("[MPI] Entered mpiNormalLoop");
_String* theMessage = MPIRecvString (-1,senderID), // listen for messages from any node
* resStr = nil;
while (theMessage->sLength) {
setParameter (mpiNodeID, (_Parameter)rank);
setParameter (mpiNodeCount, (_Parameter)size);
//ReportWarning (*theMessage);
DeleteObject (resStr);
resStr = nil;
if (theMessage->startswith (mpiLoopSwitchToOptimize) ) {
hyphyMPIOptimizerMode = theMessage->Cut(mpiLoopSwitchToOptimize.sLength,-1).toNum();
ReportWarning (_String("[MPI] Switched to mpiOptimizer loop with mode ") & hyphyMPIOptimizerMode);
MPISendString (mpiLoopSwitchToOptimize,senderID);
mpiOptimizerLoop (rank,size);
ReportWarning ("[MPI] Returned from mpiOptimizer loop");
hyphyMPIOptimizerMode = _hyphyLFMPIModeNone;
pathNames && & baseDir;
} else if ( theMessage->Equal (&mpiLoopSwitchToBGM) ) {
ReportWarning ("[MPI] Received signal to switch to mpiBgmLoop");
MPISendString (mpiLoopSwitchToBGM, senderID); // feedback to source to confirm receipt of message
mpiBgmLoop (rank, size);
ReportWarning ("[MPI] Returned from mpiBgmLoop");
} else {
if (theMessage->beginswith ("#NEXUS")) {
_String msgCopy (*theMessage);
ReportWarning ("[MPI] Received a function to optimize");
ReadDataSetFile (nil,true,theMessage);
ReportWarning ("[MPI] Done with the optimization");
_Variable* lfName = FetchVar(LocateVarByName(MPI_NEXUS_FILE_RETURN));
if (lfName) {
resStr = (_String*)(lfName->Compute()->toStr());
} else {
_FString *lfID = (_FString*)FetchObjectFromVariableByType (&lf2SendBack, STRING);
if (!lfID) {
FlagError (_String("[MPI] Malformed MPI likelihood function optimization request - did not specify the LF name to return in variable ") & lf2SendBack & ".\n\n\n" );
break;
}
long f = likeFuncNamesList.Find (lfID->theString);
if (f<0) {
FlagError ("[MPI] Malformed MPI likelihood function optimization request - LF name to return did not refer to a well-defined likelihood function.\n\n\n");
break;
}
_Parameter pv;
checkParameter (shortMPIReturn, pv ,0);
resStr = (_String*)checkPointer(new _String (1024L,true));
((_LikelihoodFunction*)likeFuncList (f))->SerializeLF(*resStr,pv>0.5?_hyphyLFSerializeModeShortMPI:_hyphyLFSerializeModeLongMPI);
resStr->Finalize();
}
} else {
_ExecutionList exL (*theMessage);
_PMathObj res = exL.Execute();
resStr = res?(_String*)res->toStr():new _String ("0");
}
checkPointer (resStr);
MPISendString(*resStr,senderID);
_Parameter keepState = 0.0;
checkParameter (preserveSlaveNodeState, keepState, 0.0);
if (keepState < 0.5) {
PurgeAll (true);
pathNames && & baseDir;
}
}
DeleteObject (theMessage);
theMessage = MPIRecvString (-1,senderID);
}
/*MPISendString(empty,senderID);*/
DeleteObject (resStr);
DeleteObject (theMessage);
}
//__________________________________________________________________________________
void _Variable::SetValue (_PMathObj theP, bool dup) // set the value of the var
{
//hasBeenChanged = true;
varFlags &= HY_VARIABLE_SET;
varFlags |= HY_VARIABLE_CHANGED;
long valueClass = theP->ObjectClass();
if (valueClass==NUMBER) {
if (varFormula) {
// also update the fact that this variable is no longer dependent in all declared
// variable containers which contain references to this variable
long i;
for (i = 0; i<variablePtrs.lLength; i++) {
if (freeSlots.Find(i)>=0) {
continue;
}
_Variable* theV = (_Variable*)variablePtrs(i);
if (theV->IsContainer()) {
_VariableContainer* theVC = (_VariableContainer*)theV;
if (!theVC->RemoveDependance (theIndex)) {
ReportWarning ((_String("Can't make variable ")&*GetName()&" independent in the context of "&*theVC->GetName()&" because its template variable is not independent."));
continue;
}
}
}
for (i = 0; i<likeFuncList.lLength; i++)
if (((_String*)likeFuncNamesList(i))->sLength) {
((_LikelihoodFunction*)likeFuncList(i))->UpdateDependent(theIndex);
}
//_Formula::Clear();
delete (varFormula);
varFormula = nil;
}
if (varValue) {
DeleteObject (varValue);
varValue=nil;
}
theValue = theP->Value();
if (!dup) {
DeleteObject (theP);
}
if (theValue<lowerBound || theValue>upperBound) {
if (theValue <= lowerBound+1e-50) {
theValue = lowerBound;
} else {
theValue = upperBound;
}
}
} else {
if (varFormula) {
delete (varFormula);
varFormula = nil;
//theFormula.Clear();
}
if (varValue) {
DeleteObject (varValue);
varValue=nil;
}
if (valueClass==TREE) {
variablePtrs.lData[theIndex] = (long)(((_TheTree*)theP)->makeDynamicCopy(GetName()));
DeleteObject(this);
} else {
if (dup) {
varValue = (_PMathObj)theP->makeDynamic();
} else {
varValue = theP;
}
}
}
}
void _Variable::SetFormula (_Formula& theF) // set the value of the var to a formula
{
bool changeMe = false,
isAConstant = theF.IsAConstant();
_Formula* myF = &theF;
if (isAConstant) {
_PMathObj theP = theF.Compute();
if (theP) {
myF = new _Formula ((_PMathObj)theP->makeDynamic(),false);
checkPointer (myF);
} else {
return;
}
}
_SimpleList vars;
{
_AVLList vA (&vars);
theF.ScanFForVariables (vA,true);
vA.ReorderList();
}
if (vars.BinaryFind(theIndex)>=0) {
_String * sf = (_String*)theF.toStr();
WarnError ((_String("Can't set variable ")&*GetName()&" to "&*sf&" because it would create a circular dependance."));
DeleteObject(sf);
if (&theF!=myF) {
delete myF;
}
return;
}
varFlags &= HY_VARIABLE_SET;
if (varFlags & HY_VARIABLE_CHANGED) {
varFlags -= HY_VARIABLE_CHANGED;
}
if (varFormula) {
delete (varFormula);
varFormula = nil;
} else {
changeMe = true;
}
if (varValue) {
DeleteObject (varValue);
varValue=nil;
}
//_Formula::Duplicate ((BaseRef)myF);
varFormula = new _Formula;
varFormula->Duplicate ((BaseRef)myF);
// mod 20060125 added a call to simplify constants
varFormula->SimplifyConstants ();
// also update the fact that this variable is no longer independent in all declared
// variable containers which contain references to this variable
if (changeMe)
if (deferSetFormula) {
*deferSetFormula << theIndex;
deferIsConstant << isAConstant;
} else {
long i;
_SimpleList tcache;
long iv;
i = variableNames.Traverser (tcache,iv,variableNames.GetRoot());
for (; i >= 0; i = variableNames.Traverser (tcache,iv)) {
_Variable* theV = FetchVar(i);
if (theV->IsContainer()) {
_VariableContainer* theVC = (_VariableContainer*)theV;
if (theVC->SetDependance(theIndex) == -2) {
ReportWarning ((_String("Can't make variable ")&*GetName()&" dependent in the context of "&*theVC->GetName()&" because its template variable is bound by another relation in the global context."));
continue;
}
}
}
{
for (long i = 0; i<likeFuncList.lLength; i++)
if (((_String*)likeFuncNamesList(i))->sLength) {
((_LikelihoodFunction*)likeFuncList(i))->UpdateIndependent(theIndex,isAConstant);
}
}
}
if (&theF!=myF) {
delete myF;
}
}
void dng_info::PostParse (dng_host &host)
{
uint32 index;
fExif->PostParse (host, *fShared.Get ());
fShared->PostParse (host, *fExif.Get ());
for (index = 0; index < fIFDCount; index++)
{
fIFD [index]->PostParse ();
}
for (index = 0; index < fChainedIFDCount; index++)
{
fChainedIFD [index]->PostParse ();
}
if (fShared->fDNGVersion != 0)
{
// Find main IFD.
fMainIndex = -1;
for (index = 0; index < fIFDCount; index++)
{
if (fIFD [index]->fUsesNewSubFileType &&
fIFD [index]->fNewSubFileType == sfMainImage)
{
if (fMainIndex == -1)
{
fMainIndex = index;
}
#if qDNGValidate
else
{
ReportError ("Multiple IFDs marked as main image");
}
#endif
}
else if (fIFD [index]->fNewSubFileType == sfPreviewImage ||
fIFD [index]->fNewSubFileType == sfAltPreviewImage)
{
// Fill in default color space for DNG previews if not included.
if (fIFD [index]->fPreviewInfo.fColorSpace == previewColorSpace_MaxEnum)
{
if (fIFD [index]->fSamplesPerPixel == 1)
{
fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_GrayGamma22;
}
else
{
fIFD [index]->fPreviewInfo.fColorSpace = previewColorSpace_sRGB;
}
}
}
}
// Deal with lossless JPEG bug in early DNG versions.
if (fShared->fDNGVersion < dngVersion_1_1_0_0)
{
if (fMainIndex != -1)
{
fIFD [fMainIndex]->fLosslessJPEGBug16 = true;
}
}
// Warn about Chained IFDs.
#if qDNGValidate
if (fChainedIFDCount > 0)
{
ReportWarning ("This file has Chained IFDs, which will be ignored by DNG readers");
}
#endif
}
}
void dng_info::ParseIFD (dng_host &host,
dng_stream &stream,
dng_exif *exif,
dng_shared *shared,
dng_ifd *ifd,
uint64 ifdOffset,
int64 offsetDelta,
uint32 parentCode)
{
#if qDNGValidate
bool isMakerNote = (parentCode >= tcFirstMakerNoteIFD &&
parentCode <= tcLastMakerNoteIFD);
#endif
stream.SetReadPosition (ifdOffset);
if (ifd)
{
ifd->fThisIFD = ifdOffset;
}
uint32 ifdEntries = stream.Get_uint16 ();
#if qDNGValidate
if (gVerbose)
{
printf ("%s: Offset = %u, Entries = %u\n\n",
LookupParentCode (parentCode),
(unsigned) ifdOffset,
(unsigned) ifdEntries);
}
if ((ifdOffset & 1) && !isMakerNote)
{
char message [256];
sprintf (message,
"%s has odd offset (%u)",
LookupParentCode (parentCode),
(unsigned) ifdOffset);
ReportWarning (message);
}
#endif
uint32 prev_tag_code = 0;
for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++)
{
stream.SetReadPosition (ifdOffset + 2 + tag_index * 12);
uint32 tagCode = stream.Get_uint16 ();
uint32 tagType = stream.Get_uint16 ();
// Minolta 7D files have a bug in the EXIF block where the count
// is wrong, and we run off into next IFD link. So if abort parsing
// if we get a zero code/type combinations.
if (tagCode == 0 && tagType == 0)
{
#if qDNGValidate
char message [256];
sprintf (message,
"%s had zero/zero tag code/type entry",
LookupParentCode (parentCode));
ReportWarning (message);
#endif
return;
}
uint32 tagCount = stream.Get_uint32 ();
#if qDNGValidate
{
if (tag_index > 0 && tagCode <= prev_tag_code && !isMakerNote)
{
char message [256];
sprintf (message,
"%s tags are not sorted in ascending numerical order",
LookupParentCode (parentCode));
ReportWarning (message);
}
}
#endif
prev_tag_code = tagCode;
uint32 tag_type_size = TagTypeSize (tagType);
if (tag_type_size == 0)
{
#if qDNGValidate
{
char message [256];
sprintf (message,
"%s %s has unknown type (%u)",
LookupParentCode (parentCode),
LookupTagCode (parentCode, tagCode),
(unsigned) tagType);
ReportWarning (message);
}
#endif
continue;
}
uint64 tagOffset = ifdOffset + 2 + tag_index * 12 + 8;
if (tagCount * tag_type_size > 4)
{
tagOffset = stream.Get_uint32 ();
#if qDNGValidate
{
if (!(ifdOffset & 1) &&
(tagOffset & 1) &&
!isMakerNote &&
parentCode != tcKodakDCRPrivateIFD &&
parentCode != tcKodakKDCPrivateIFD)
{
char message [256];
sprintf (message,
"%s %s has odd data offset (%u)",
LookupParentCode (parentCode),
LookupTagCode (parentCode, tagCode),
(unsigned) tagOffset);
ReportWarning (message);
}
}
#endif
tagOffset += offsetDelta;
stream.SetReadPosition (tagOffset);
}
ParseTag (host,
stream,
exif,
shared,
ifd,
parentCode,
tagCode,
tagType,
tagCount,
tagOffset,
offsetDelta);
}
stream.SetReadPosition (ifdOffset + 2 + ifdEntries * 12);
uint32 nextIFD = stream.Get_uint32 ();
#if qDNGValidate
if (gVerbose)
{
printf ("NextIFD = %u\n", (unsigned) nextIFD);
}
#endif
if (ifd)
{
ifd->fNextIFD = nextIFD;
}
#if qDNGValidate
if (nextIFD)
{
if (parentCode != 0 &&
(parentCode < tcFirstChainedIFD ||
parentCode > tcLastChainedIFD ))
{
char message [256];
sprintf (message,
"%s has an unexpected non-zero NextIFD (%u)",
LookupParentCode (parentCode),
(unsigned) nextIFD);
ReportWarning (message);
}
}
if (gVerbose)
{
printf ("\n");
}
#endif
}
void dng_info::Parse (dng_host &host,
dng_stream &stream)
{
fTIFFBlockOffset = stream.Position ();
fTIFFBlockOriginalOffset = stream.PositionInOriginalFile ();
// Check byte order indicator.
uint16 byteOrder = stream.Get_uint16 ();
if (byteOrder == byteOrderII)
{
fBigEndian = false;
#if qDNGValidate
if (gVerbose)
{
printf ("\nUses little-endian byte order\n");
}
#endif
stream.SetLittleEndian ();
}
else if (byteOrder == byteOrderMM)
{
fBigEndian = true;
#if qDNGValidate
if (gVerbose)
{
printf ("\nUses big-endian byte order\n");
}
#endif
stream.SetBigEndian ();
}
else
{
#if qDNGValidate
ReportError ("Unknown byte order");
#endif
ThrowBadFormat ();
}
// Check "magic number" indicator.
fMagic = stream.Get_uint16 ();
#if qDNGValidate
if (gVerbose)
{
printf ("Magic number = %u\n\n", (unsigned) fMagic);
}
#endif
ValidateMagic ();
// Parse IFD 0.
uint64 next_offset = stream.Get_uint32 ();
fExif.Reset (host.Make_dng_exif ());
fShared.Reset (host.Make_dng_shared ());
fIFD [0].Reset (host.Make_dng_ifd ());
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
fIFD [0].Get (),
fTIFFBlockOffset + next_offset,
fTIFFBlockOffset,
0);
next_offset = fIFD [0]->fNextIFD;
fIFDCount = 1;
// Parse chained IFDs.
while (next_offset)
{
if (next_offset >= stream.Length ())
{
#if qDNGValidate
{
ReportWarning ("Chained IFD offset past end of stream");
}
#endif
break;
}
// Some TIFF file writers forget about the next IFD offset, so
// validate the IFD at that offset before parsing it.
if (!ValidateIFD (stream,
fTIFFBlockOffset + next_offset,
fTIFFBlockOffset))
{
#if qDNGValidate
{
ReportWarning ("Chained IFD is not valid");
}
#endif
break;
}
if (fChainedIFDCount == kMaxChainedIFDs)
{
#if qDNGValidate
{
ReportWarning ("Chained IFD count exceeds DNG SDK parsing limit");
}
#endif
break;
}
fChainedIFD [fChainedIFDCount].Reset (host.Make_dng_ifd ());
ParseIFD (host,
stream,
NULL,
NULL,
fChainedIFD [fChainedIFDCount].Get (),
fTIFFBlockOffset + next_offset,
fTIFFBlockOffset,
tcFirstChainedIFD + fChainedIFDCount);
next_offset = fChainedIFD [fChainedIFDCount]->fNextIFD;
fChainedIFDCount++;
}
// Parse SubIFDs.
uint32 searchedIFDs = 0;
bool tooManySubIFDs = false;
while (searchedIFDs < fIFDCount && !tooManySubIFDs)
{
uint32 searchLimit = fIFDCount;
for (uint32 searchIndex = searchedIFDs;
searchIndex < searchLimit && !tooManySubIFDs;
searchIndex++)
{
for (uint32 subIndex = 0;
subIndex < fIFD [searchIndex]->fSubIFDsCount;
subIndex++)
{
if (fIFDCount == kMaxSubIFDs + 1)
{
tooManySubIFDs = true;
break;
}
stream.SetReadPosition (fIFD [searchIndex]->fSubIFDsOffset +
subIndex * 4);
uint32 sub_ifd_offset = stream.Get_uint32 ();
fIFD [fIFDCount].Reset (host.Make_dng_ifd ());
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
fIFD [fIFDCount].Get (),
fTIFFBlockOffset + sub_ifd_offset,
fTIFFBlockOffset,
tcFirstSubIFD + fIFDCount - 1);
fIFDCount++;
}
searchedIFDs = searchLimit;
}
}
#if qDNGValidate
{
if (tooManySubIFDs)
{
ReportWarning ("SubIFD count exceeds DNG SDK parsing limit");
}
}
#endif
// Parse EXIF IFD.
if (fShared->fExifIFD)
{
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
NULL,
fTIFFBlockOffset + fShared->fExifIFD,
fTIFFBlockOffset,
tcExifIFD);
}
// Parse GPS IFD.
if (fShared->fGPSInfo)
{
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
NULL,
fTIFFBlockOffset + fShared->fGPSInfo,
fTIFFBlockOffset,
tcGPSInfo);
}
// Parse Interoperability IFD.
if (fShared->fInteroperabilityIFD)
{
// Some Kodak KDC files have bogus Interoperability IFDs, so
// validate the IFD before trying to parse it.
if (ValidateIFD (stream,
fTIFFBlockOffset + fShared->fInteroperabilityIFD,
fTIFFBlockOffset))
{
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
NULL,
fTIFFBlockOffset + fShared->fInteroperabilityIFD,
fTIFFBlockOffset,
tcInteroperabilityIFD);
}
#if qDNGValidate
else
{
ReportWarning ("The Interoperability IFD is not a valid IFD");
}
#endif
}
// Parse Kodak DCR Private IFD.
if (fShared->fKodakDCRPrivateIFD)
{
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
NULL,
fTIFFBlockOffset + fShared->fKodakDCRPrivateIFD,
fTIFFBlockOffset,
tcKodakDCRPrivateIFD);
}
// Parse Kodak KDC Private IFD.
if (fShared->fKodakKDCPrivateIFD)
{
ParseIFD (host,
stream,
fExif.Get (),
fShared.Get (),
NULL,
fTIFFBlockOffset + fShared->fKodakKDCPrivateIFD,
fTIFFBlockOffset,
tcKodakKDCPrivateIFD);
}
// Parse MakerNote tag.
if (fShared->fMakerNoteCount)
{
ParseMakerNote (host,
stream,
(uint32) (fTIFFBlockOffset + fShared->fMakerNoteCount),
fShared->fMakerNoteOffset,
fTIFFBlockOffset,
0,
stream.Length ());
}
// Parse DNGPrivateData tag.
if (fShared->fDNGPrivateDataCount &&
fShared->fDNGVersion)
{
ParseDNGPrivateData (host, stream);
}
#if qDNGValidate
// If we are running dng_validate on stand-alone camera profile file,
// complete the validation of the profile.
if (fMagic == magicExtendedProfile)
{
dng_camera_profile_info &profileInfo = fShared->fCameraProfile;
dng_camera_profile profile;
profile.Parse (stream, profileInfo);
if (profileInfo.fColorPlanes < 3 || !profile.IsValid (profileInfo.fColorPlanes))
{
ReportError ("Invalid camera profile file");
}
}
#endif
}
void _HYChartWindow::_PrintChart(void)
{
_String printTBI ("Chart printing has not yet been implemented\n");
ReportWarning (printTBI);
}
/*******************************************************************************
Function name: Read2DMatrixNetCDF()
Purpose : Function to read a 2D array from a file.
Required :
FileName - name of input file
Matrix - address of array data into
NumberType - code for number type (taken from HDF, see comments at the
beginning of InitFileIO.c for more detail)
NY - Number of rows
NX - Number of columns
NDataSet - number of the dataset to read, i.e. the first matrix in a
file is number 0, etc. (this is not used for the NetCDF file,
since we can retrieve the variable by name).
VarName - Name of variable to retrieve
Returns : Number of elements read
Modifies : Matrix
Comments : NOTE that we cannot modify anything other than the returned
Matrix, because we have to stay compatible with Read2DMatrixBin
*******************************************************************************/
int Read2DMatrixNetCDF(char *FileName, void *Matrix, int NumberType, int NY,
int NX, int NDataSet, ...)
{
const char *Routine = "Read2DMatrixNetCDF";
char Str[BUFSIZE + 1];
char dimname[NC_MAX_NAME + 1];
char *VarName;
int dimids[3];
int ndims;
int ncid;
int ncstatus;
nc_type TempNumberType;
int varid;
size_t index;
double time;
int timid;
size_t count[3];
size_t start[3] = { 0, 0, 0 };
size_t dimlen;
size_t timelen;
va_list ap;
double *Ycoord;
double *Xcoord; /* lat, lon variables */
int LatisAsc, LonisAsc, flag; /* flag */
int lon_varid, lat_varid;
count[0] = 1;
count[1] = NY;
count[2] = NX;
/****************************************************************************/
/* GO THROUGH VARIABLE ARGUMENT LIST */
/****************************************************************************/
va_start(ap, NDataSet);
VarName = va_arg(ap, char *);
index = va_arg(ap, int);
/****************************************************************************/
/* QUERY NETDCF FILE */
/****************************************************************************/
ncstatus = nc_open(FileName, NC_NOWRITE, &ncid);
/* debugging if any file fails to be opened */
//printf("Trying to open %s\n", FileName);
nc_check_err(ncstatus, __LINE__, __FILE__);
/* check whether the variable exists and get its parameters */
ncstatus = nc_inq_varid(ncid, VarName, &varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_var(ncid, varid, 0, &TempNumberType, &ndims, dimids, NULL);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (TempNumberType != NumberType) {
sprintf(Str, "%s: nc_type for %s is different than expected.\n",
FileName, VarName);
ReportWarning(Str, 58);
}
/* make sure that the x and y dimensions have the correct sizes */
ncstatus = nc_inq_dim(ncid, dimids[1], dimname, &dimlen);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_varid(ncid, dimname, &lat_varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (dimlen != NY)
ReportError(VarName, 59);
Ycoord = (double *) calloc(dimlen, sizeof(double));
if (Ycoord == NULL)
ReportError((char *) Routine, 1);
/* Read the latitude coordinate variable data. */
ncstatus = nc_get_var_double(ncid, lat_varid, Ycoord);
nc_check_err(ncstatus, __LINE__, __FILE__);
/* A quick check if the lat, long are in a ascending order.
If so, matrix must be flipped so the first value in the matrix will be
assigned to the lower left corner cell that has lowest X (lon) & Y (lat) value.
(see more comments in the header of this C file). */
LatisAsc = 1;
if( Ycoord[0] > Ycoord[NY - 1] )
LatisAsc = 0;
ncstatus = nc_inq_dim(ncid, dimids[2], dimname, &dimlen);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_varid(ncid, dimname, &lon_varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (dimlen != NX)
ReportError(VarName, 60);
Xcoord = (double *) calloc(NX, sizeof(double));
if (Xcoord == NULL)
ReportError((char *) Routine, 1);
/* Read the latitude coordinate variable data. */
ncstatus = nc_get_var_double(ncid, lon_varid, Xcoord);
nc_check_err(ncstatus, __LINE__, __FILE__);
LonisAsc = 1;
if( Xcoord[0] > Xcoord[NX - 1] )
LonisAsc = 0;
if (LonisAsc == 0){
printf("The current program does not handle the cases when longitude or X \
values in the .nc input in an descending order. You can either change the input \
.nc file format outside of this program. or you can easily modify this program to \
fit your needs. \n");
ReportError("Improper NetCDF input files", 58);
}
//__________________________________________________________________________________
_PMathObj _Constant::IBeta (_PMathObj arg1, _PMathObj arg2)
{
if (theValue<=0.0) {
if (theValue < 0.0) {
_String errMsg;
errMsg = _String ("IBeta is defined for x betweeen 0 and 1. Had: ") & theValue;
ReportWarning (errMsg);
}
return new _Constant (0.0);
}
if (theValue>=1.0) {
if (theValue>1.0) {
_String errMsg;
errMsg = _String ("IBeta is defined for x betweeen 0 and 1. Had: ") & theValue;
ReportWarning (errMsg);
}
return new _Constant (1.0);
}
if ((arg1->ObjectClass()!=NUMBER)||(arg2->ObjectClass()!=NUMBER)) {
_String errMsg ("IBeta called with a non-scalar argument.");
WarnError (errMsg);
return nil;
}
_Constant *ga = (_Constant*)arg1->Gamma(),
*gb = (_Constant*)arg2->Gamma();
if (ga&&gb) {
_Constant *ac = (_Constant*)arg1,
*bc = (_Constant*)arg2;
_Parameter a = ac->Value(),
b = bc->Value(),
x = theValue,
aa,
c,
d,
del,
h,
qab,
qam,
qap,
FPMIN = 1e-100;
bool swap = false;
long m,
m2;
if (x >= (a+1.)/(a+b+2.)) {
swap = true;
c = b;
b = a;
a = c;
x = 1. - x;
}
qab = a+b;
qap = a+1.;
qam = a-1.;
c = 1.;
d = 1. - qab*x/qap;
if ((d<FPMIN)&&(d>-FPMIN)) {
d = FPMIN;
}
d = 1./d;
h = d;
for (m=1; m<100; m++) {
m2 = 2*m;
aa = m*(b-m)*x / ((qam+m2)*(a+m2));
d = 1.+aa*d;
if ((d<FPMIN)&&(d>-FPMIN)) {
d = FPMIN;
}
c = 1.+aa/c;
if ((c<FPMIN)&&(c>-FPMIN)) {
c = FPMIN;
}
d = 1./d;
h*= d*c;
aa = -(a+m)*(qab+m)*x/((a+m2)*(qap+m2));
d = 1.+aa*d;
if ((d<FPMIN)&&(d>-FPMIN)) {
d = FPMIN;
}
c = 1.+aa/c;
if ((c<FPMIN)&&(c>-FPMIN)) {
c = FPMIN;
}
d = 1./d;
del = d*c;
h*= del;
del -= 1.;
if ((del<1.e-14)&&(del>-1.e-14)) {
break;
}
}
_Constant * res = new _Constant (a+b);
ac = (_Constant*)res->Gamma();
c = ac->Value()/(ga->Value()*gb->Value()) *
exp (a*log(x)+b*log(1-x));
if (swap) {
res->theValue = 1.-c*h/a;
} else {
res->theValue = c*h/a;
}
DeleteObject (ac);
DeleteObject (ga);
DeleteObject (gb);
return res;
}
DeleteObject (ga);
DeleteObject (gb);
return nil;
}
void ValidateIISxpressFiles()
{
RS::WinSecurity::SmartSid sidIISWPG;
if (!RS::WinSecurity::WinSecurity::GetAccountSid(_T("IIS_WPG"), sidIISWPG))
{
ReportError(_T("Unable to get the SID for the IIS_WPG group, is IIS installed?"));
}
CRegKey regFilter;
if (regFilter.Open(HKEY_LOCAL_MACHINE, IISXPRESSFILTER_REGKEY, KEY_READ) == ERROR_SUCCESS)
{
if (sidIISWPG.IsValid())
{
RS::WinSecurity::SmartSecurityDescriptor SD;
if (RS::WinSecurity::WinSecurity::GetKeySecurity(regFilter, SD))
{
if (!RS::WinSecurity::WinSecurity::CheckPermissons(SD, sidIISWPG, READ_CONTROL))
{
ReportWarning(_T("The IIS_WPG group does not have permissions for the IISxpress ISAPI filter registry entry"));
}
}
else
{
ReportError(_T("Unable to get the SD for IISxpress ISAPI filter registry entry"));
}
}
TCHAR szFilterInstallPath[512] = _T("");
ULONG nFilterInstallPathSize = _countof(szFilterInstallPath);
if (regFilter.QueryStringValue(IISXPRESS_INSTALLPATH, szFilterInstallPath, &nFilterInstallPathSize) == ERROR_SUCCESS)
{
CPath ISAPIDLLPath(szFilterInstallPath);
ISAPIDLLPath.Append(_T("IISxpress.dll"));
if (ISAPIDLLPath.FileExists())
{
if (sidIISWPG.IsValid())
{
RS::WinSecurity::SmartSecurityDescriptor SD;
if (RS::WinSecurity::WinSecurity::GetFileSecurity(ISAPIDLLPath, SD))
{
if (!RS::WinSecurity::WinSecurity::CheckPermissons(SD, sidIISWPG, STANDARD_RIGHTS_READ))
{
ReportWarning(_T("The IIS_WPG group does not have permissions for the IISxpress ISAPI DLL"));
}
}
else
{
ReportError(_T("Unable to get the SD for the IISxpress ISAPI DLL"));
}
}
}
else
{
ReportError(_T("The file '%s' could not be found"), ISAPIDLLPath.m_strPath);
}
CPath ISAPIPerfDLLPath(szFilterInstallPath);
ISAPIPerfDLLPath.Append(_T("IISxpressPerf.dll"));
if (ISAPIPerfDLLPath.FileExists())
{
if (sidIISWPG.IsValid())
{
RS::WinSecurity::SmartSecurityDescriptor SD;
if (RS::WinSecurity::WinSecurity::GetFileSecurity(ISAPIPerfDLLPath, SD))
{
if (!RS::WinSecurity::WinSecurity::CheckPermissons(SD, sidIISWPG, STANDARD_RIGHTS_READ))
{
ReportWarning(_T("The IIS_WPG group does not have permissions for the IISxpress Perf DLL"));
}
}
else
{
ReportError(_T("Unable to get the SD for the IISxpress Perf DLL"));
}
}
}
else
{
ReportError(_T("The file '%s' could not be found"), ISAPIPerfDLLPath.m_strPath);
}
}
else
{
ReportError(_T("Unable to locate the IISxpress ISAPI filter path registry key"));
}
}
else
{
ReportError(_T("Unable to locate the IISxpress ISAPI filter registry key"));
}
CRegKey regServer;
if (regServer.Open(HKEY_LOCAL_MACHINE, IISXPRESSSERVER_REGKEY, KEY_READ) == ERROR_SUCCESS)
{
TCHAR szServerInstallPath[512] = _T("");
ULONG nServerInstallPathSize = _countof(szServerInstallPath);
if (regServer.QueryStringValue(IISXPRESS_INSTALLPATH, szServerInstallPath, &nServerInstallPathSize) == ERROR_SUCCESS)
{
CPath ServerPSPath(szServerInstallPath);
ServerPSPath.Append(_T("IISxpressServerPS.dll"));
if (ServerPSPath.FileExists())
{
if (sidIISWPG.IsValid())
{
RS::WinSecurity::SmartSecurityDescriptor SD;
if (RS::WinSecurity::WinSecurity::GetFileSecurity(ServerPSPath, SD))
{
if (!RS::WinSecurity::WinSecurity::CheckPermissons(SD, sidIISWPG, STANDARD_RIGHTS_READ))
{
ReportWarning(_T("The IIS_WPG group does not have permissions for the IISxpress PS DLL"));
}
}
else
{
ReportError(_T("Unable to get the SD for the IISxpress PS DLL"));
}
}
}
else
{
ReportError(_T("The file '%s' could not be found"), ServerPSPath.m_strPath);
}
}
else
{
ReportError(_T("Unable to locate the IISxpress ISAPI filter path registry key"));
}
}
else
{
ReportError(_T("Unable to locate the IISxpress Server registry key"));
}
}
void ValidateIISSetup()
{
CIISMetaBase MetaBase;
CComPtr<IMSAdminBase> pAdminBase;
if (MetaBase.Init() != true || MetaBase.GetAdminBase(&pAdminBase) != true)
{
ReportError(_T("Unable to establish a connection to the IIS metabase"));
return;
}
CIISMetaBaseData LoadOrderData;
if (LoadOrderData.ReadData(pAdminBase, L"/LM/W3SVC/Filters", MD_FILTER_LOAD_ORDER))
{
std::wstring sLoadOrder;
if (LoadOrderData.GetAsString(sLoadOrder))
{
std::wstring::size_type nPos = sLoadOrder.find(IISXPRESS_FILTERNAMEW);
if (nPos != std::wstring::npos)
{
std::wstring::size_type expectedLocation = sLoadOrder.size();
expectedLocation -= _countof(IISXPRESS_FILTERNAMEW) - 1;
if (nPos != expectedLocation)
{
ReportWarning(_T("The IISxpress ISAPI filter entry should be the last defined module, please run repair"));
}
}
else
{
ReportError(_T("Unable to find the IISxpress ISAPI entry in the filter load order"));
}
}
else
{
ReportWarning(_T("Unable to read the ISAPI filter load order"));
}
}
else
{
ReportError(_T("Unable to query the ISAPI filter data"));
}
const std::wstring sMBFilterPath = L"/LM/W3SVC/Filters/" IISXPRESS_FILTERNAMEW;
CIISMetaBaseData FilterPathData;
if (FilterPathData.ReadData(pAdminBase, sMBFilterPath.c_str(), MD_FILTER_IMAGE_PATH))
{
std::wstring sFilterPath;
if (FilterPathData.GetAsString(sFilterPath))
{
CFile file;
if (!file.Open(sFilterPath.c_str(), CFile::modeRead | CFile::shareDenyNone))
{
ReportWarning(_T("Unable to open the IISxpress ISAPI filter DLL ('%s'), check that the file exists"), sFilterPath.c_str());
}
file.Close();
}
else
{
ReportWarning(_T("Unable to read the IISxpress ISAPI filter path"));
}
}
else
{
ReportWarning(_T("Unable to query the IISxpress ISAPI filter path"));
}
CIISMetaBaseData FilterStatusData;
if (FilterStatusData.ReadData(pAdminBase, sMBFilterPath.c_str(), MD_FILTER_STATE) == true)
{
DWORD dwFilterState = 0;
if (FilterStatusData.GetAsDWORD(&dwFilterState))
{
if (dwFilterState != 1)
{
ReportWarning(_T("IIS reports that the filter state is %d"), dwFilterState);
}
}
else
{
ReportWarning(_T("Unable to read the IISxpress ISAPI filter state"));
}
}
else
{
ReportError(_T("Unable to query the IISxpress ISAPI filter state"));
}
CIISMetaBaseData FilterWin32StatusData;
if (FilterWin32StatusData.ReadData(pAdminBase, sMBFilterPath.c_str(), MD_WIN32_ERROR) == true)
{
DWORD dwWIN32FilterState = 0;
if (FilterWin32StatusData.GetAsDWORD(&dwWIN32FilterState))
{
if (dwWIN32FilterState != 0)
{
TCHAR szErrorMessage[512] = _T("");
::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwWIN32FilterState, 0x0409, szErrorMessage, _countof(szErrorMessage), NULL);
TCHAR* pchWhitespace = NULL;
while ((pchWhitespace = _tcschr(szErrorMessage, '\n')))
{
*pchWhitespace = ' ';
}
while ((pchWhitespace = _tcschr(szErrorMessage, '\r')))
{
*pchWhitespace = ' ';
}
ReportWarning(_T("IIS reports that the filter WIN32 state is %d, the error is: '%s'"), dwWIN32FilterState, szErrorMessage);
}
}
else
{
ReportWarning(_T("Unable to read the IISxpress ISAPI filter Win32 state"));
}
}
else
{
ReportError(_T("Unable to query the IISxpress ISAPI filter Win32 state"));
}
std::vector<std::wstring> AppPools;
if (MetaBase.EnumKeys(L"/LM/W3SVC/AppPools", AppPools))
{
for (size_t i = 0; i < AppPools.size(); i++)
{
std::wstring appPoolPath = L"/LM/W3SVC/AppPools/" + AppPools[i];
CIISMetaBaseData AppPoolIdentityData;
if (AppPoolIdentityData.ReadData(pAdminBase, appPoolPath.c_str(), MD_APPPOOL_IDENTITY_TYPE) == true)
{
DWORD dwIdentityType = 0;
AppPoolIdentityData.GetAsDWORD(&dwIdentityType);
ReportInfo(_T("AppPool '%s' has identity type %d"), AppPools[i].c_str(), dwIdentityType);
if (dwIdentityType == MD_APPPOOL_IDENTITY_TYPE_SPECIFICUSER)
{
CIISMetaBaseData AppPoolUserData;
if (AppPoolUserData.ReadData(pAdminBase, appPoolPath.c_str(), MD_WAM_USER_NAME) == true)
{
std::wstring sUserName;
if (AppPoolUserData.GetAsString(sUserName))
{
ReportWarning(
_T("The AppPool '%s' has been configured to use user account '%s', ensure this account or IIS_WPG ")
_T("has read/execute permissions to the IISxpress directory ")
_T("and full permissions to the IISxpress Logs directory"),
AppPools[i].c_str(), sUserName.c_str());
}
else
{
ReportError(_T("Unable to read the user name of the AppPool"));
}
}
else
{
ReportError(_T("Unable to query the user name of the AppPool"));
}
}
}
else
{
ReportInfo(_T("AppPool '%s' does not have an identity type"), AppPools[i].c_str());
}
}
}
else
{
ReportError(_T("Unable to query the ISAPI AppPool data"));
}
}
void dng_hue_sat_map::SetDelta (uint32 hueDiv,
uint32 satDiv,
uint32 valDiv,
const HSBModify &modify)
{
if (hueDiv >= fHueDivisions ||
satDiv >= fSatDivisions ||
valDiv >= fValDivisions ||
fDeltas.Buffer () == NULL)
{
DNG_REPORT ("Bad parameters to dng_hue_sat_map::SetDelta");
ThrowProgramError ();
}
// Set this entry.
int32 offset = valDiv * fValStep +
hueDiv * fHueStep +
satDiv;
GetDeltas () [offset] = modify;
// The zero saturation entry is required to have a value scale
// of 1.0f.
if (satDiv == 0)
{
if (modify.fValScale != 1.0f)
{
#if qDNGValidate
ReportWarning ("Value scale for zero saturation entries must be 1.0");
#endif
GetDeltas () [offset] . fValScale = 1.0f;
}
}
// If we are settings the first saturation entry and we have not
// set the zero saturation entry yet, fill in the zero saturation entry
// by extrapolating first saturation entry.
if (satDiv == 1)
{
HSBModify zeroSatModify;
GetDelta (hueDiv, 0, valDiv, zeroSatModify);
if (zeroSatModify.fValScale != 1.0f)
{
zeroSatModify.fHueShift = modify.fHueShift;
zeroSatModify.fSatScale = modify.fSatScale;
zeroSatModify.fValScale = 1.0f;
SetDelta (hueDiv, 0, valDiv, zeroSatModify);
}
}
}
