C++

// CppStandaloneApplication.cpp : Defines the entry point for the console application.
 
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>
#include <ctime>
#include <functional>
#include <assert.h>
 
// Note - .tlh files will be generated from the .tlb files (above) once the project is compiled.
// Visual Studio will incorrectly continue to report IntelliSense error messages however until it is restarted.
#include "zosapi.h"
 
using namespace std;
using namespace ZOSAPI;
using namespace ZOSAPI_Interfaces;
 
void handleError(std::string msg);
void logInfo(std::string msg);
void finishStandaloneApplication(IZOSAPI_ApplicationPtr TheApplication);
 
bool fileExists(const wchar_t* name) {
    FILE *file;
    errno_t err = _wfopen_s(&file, name, L"r");
    if (err == 0) {
        fclose(file);
        return true;
    } else {
        return false;
    }
}
 
int RunApplication()
{
    CoInitialize(NULL);
 
    // Create the initial connection class
    IZOSAPI_ConnectionPtr TheConnection(__uuidof(ZOSAPI_Connection));
 
 
    // Attempt to create a Standalone connection
    IZOSAPI_ApplicationPtr TheApplication = TheConnection->CreateNewApplication();
    if (TheApplication == nullptr)
    {
        handleError("An unknown error occurred!");
        return -1;
    }
 
    // Check the connection status
    if (!TheApplication->IsValidLicenseForAPI)
    {
        handleError("License check failed!");
        return -1;
    }
    if (TheApplication->Mode != ZOSAPI_Mode::ZOSAPI_Mode_Server)
    {
        handleError("Standlone application was started in the incorrect mode!");
        return -1;
    }
 
    IOpticalSystemPtr TheSystem = TheApplication->PrimarySystem;
 
    // Add your custom code here...
 
    // creates a new API directory
    CreateDirectory(_bstr_t(TheApplication->SamplesDir + "\\API"), NULL);
    CreateDirectory(_bstr_t(TheApplication->SamplesDir + "\\API\\CPP"), NULL);
 
    // Set up primary optical system
    TheSystem = TheApplication->PrimarySystem;
    _bstr_t sampleDir = TheApplication->SamplesDir;
 
    // Open file
    _bstr_t testFile = sampleDir + (_bstr_t)"\\API\\CPP\\e01_new_file_and_quickfocus.zos";
    if (!fileExists(testFile)) {
        cout << "You need to run Example 01 before running this example" << endl;
#if defined(_DEBUG)
    // keeps console open when in debug mode
    system("pause");
#endif
        return false;
    }
    TheSystem->LoadFile(testFile, false);
    _bstr_t testFile2 = sampleDir + (_bstr_t)"\\API\\CPP\\e03_open_file_and_optimise.zos";
    TheSystem->SaveAs(testFile2);
 
    // Get Surfaces
    ILensDataEditorPtr TheLDE = TheSystem->LDE;
    ILDERowPtr Surface_1 = TheLDE->GetSurfaceAt(1);
    ILDERowPtr Surface_2 = TheLDE->GetSurfaceAt(2);
    ILDERowPtr Surface_3 = TheLDE->GetSurfaceAt(3);
 
    // Make thicknesses and radii variable
    Surface_1->ThicknessCell->MakeSolveVariable();
    Surface_2->ThicknessCell->MakeSolveVariable();
    Surface_2->RadiusCell->MakeSolveVariable();
    Surface_3->ThicknessCell->MakeSolveVariable();
 
    // Merit functions
    IMeritFunctionEditorPtr TheMFE = TheSystem->MFE;
    IMFERowPtr Operand_1 = TheMFE->GetOperandAt(1);
    Operand_1->ChangeType(MeritOperandType_ASTI);
    Operand_1->Target = 0.0;
    Operand_1->Weight = 10.0;
 
    IMFERowPtr Operand_2 = TheMFE->InsertNewOperandAt(2);
    Operand_2->ChangeType(MeritOperandType_COMA);
    Operand_2->Target = 0.0;
    Operand_2->Weight = 1.0;
    // Air min/max
    IMFERowPtr Operand_3 = TheMFE->AddOperand();
    Operand_3->ChangeType(MeritOperandType_MNCA);
    Operand_3->Target = 0.5;
    Operand_3->Weight = 1.0;
    IEditorRowPtr castRow = Operand_3;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
    IMFERowPtr Operand_4 = TheMFE->AddOperand();
    Operand_4->ChangeType(MeritOperandType_MXCA);
    Operand_4->Target = 1000;
    Operand_4->Weight = 1.0;
    castRow = Operand_4;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
    IMFERowPtr Operand_5 = TheMFE->AddOperand();
    Operand_5->ChangeType(MeritOperandType_MNEA);
    Operand_5->Target = 0.5;
    Operand_5->Weight = 1.0;
    castRow = Operand_5;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
    // Material min/max
    IMFERowPtr Operand_6 = TheMFE->AddOperand();
    Operand_6->ChangeType(MeritOperandType_MNCG);
    Operand_6->Target = 3.0;
    Operand_6->Weight = 1.0;
    castRow = Operand_6;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
    IMFERowPtr Operand_7 = TheMFE->AddOperand();
    Operand_7->ChangeType(MeritOperandType_MXCG);
    Operand_7->Target = 15.0;
    Operand_7->Weight = 1.0;
    castRow = Operand_7;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
    IMFERowPtr Operand_8 = TheMFE->AddOperand();
    Operand_8->ChangeType(MeritOperandType_MNEG);
    Operand_8->Target = 3.0;
    Operand_8->Weight = 1.0;
    castRow = Operand_8;
    castRow->GetCellAt(2)->IntegerValue = 1;
    castRow->GetCellAt(3)->IntegerValue = 3;
 
    // Local optimisation till completion
    ILocalOptimizationPtr LocalOpt = TheSystem->Tools->OpenLocalOptimization();
    LocalOpt->Algorithm = OptimizationAlgorithm_DampedLeastSquares;
    LocalOpt->Cycles = OptimizationCycles_Automatic;
    LocalOpt->NumberOfCores = 8;
    ISystemToolPtr baseTool = LocalOpt;
    baseTool->RunAndWaitForCompletion();
    baseTool->Close();
 
    // Hammer for 10 seconds
    IHammerOptimizationPtr HammerOpt = TheSystem->Tools->OpenHammerOptimization();
    baseTool = HammerOpt;
    baseTool->RunAndWaitWithTimeout(10);    
    baseTool->Cancel();
    baseTool->WaitForCompletion();
    baseTool->Close();
 
    // Save and close
    TheSystem->Save();
    
    // Clean up
    finishStandaloneApplication(TheApplication);
    
 
    return 0;
}
 
void handleError(std::string msg)
{
    throw new exception(msg.c_str());
}
 
void logInfo(std::string msg)
{
    printf("%s", msg.c_str());
}
 
void finishStandaloneApplication(IZOSAPI_ApplicationPtr TheApplication)
{
    // Note - TheApplication will close automatically when this application exits, so this isn't strictly necessary in most cases
    if (TheApplication != nullptr)
    {
        TheApplication->CloseApplication();
    }
}
 
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    return RunApplication();
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    return RunApplication();
}
ZOS-API interface 2025 R1

Example 03 - C++

C++

Connect with Ansys
