1 2 static char help[] = "Basic equation for generator stability analysis.\n"; 3 4 /*F 5 6 \begin{eqnarray} 7 \frac{d \theta}{dt} = \omega_b (\omega - \omega_s) 8 \frac{2 H}{\omega_s}\frac{d \omega}{dt} & = & P_m - P_max \sin(\theta) -D(\omega - \omega_s)\\ 9 \end{eqnarray} 10 11 Ensemble of initial conditions 12 ./ex2 -ensemble -ts_monitor_draw_solution_phase -1,-3,3,3 -ts_adapt_dt_max .01 -ts_monitor -ts_type rosw -pc_type lu -ksp_type preonly 13 14 Fault at .1 seconds 15 ./ex2 -ts_monitor_draw_solution_phase .42,.95,.6,1.05 -ts_adapt_dt_max .01 -ts_monitor -ts_type rosw -pc_type lu -ksp_type preonly 16 17 Initial conditions same as when fault is ended 18 ./ex2 -u 0.496792,1.00932 -ts_monitor_draw_solution_phase .42,.95,.6,1.05 -ts_adapt_dt_max .01 -ts_monitor -ts_type rosw -pc_type lu -ksp_type preonly 19 20 F*/ 21 22 /* 23 Include "petscts.h" so that we can use TS solvers. Note that this 24 file automatically includes: 25 petscsys.h - base PETSc routines petscvec.h - vectors 26 petscmat.h - matrices 27 petscis.h - index sets petscksp.h - Krylov subspace methods 28 petscviewer.h - viewers petscpc.h - preconditioners 29 petscksp.h - linear solvers 30 */ 31 32 #include <petsctao.h> 33 #include <petscts.h> 34 35 typedef struct { 36 TS ts; 37 PetscScalar H,D,omega_b,omega_s,Pmax,Pm,E,V,X,u_s,c; 38 PetscInt beta; 39 PetscReal tf,tcl,dt; 40 } AppCtx; 41 42 PetscErrorCode FormFunction(Tao,Vec,PetscReal*,void*); 43 PetscErrorCode FormGradient(Tao,Vec,Vec,void*); 44 45 /* 46 Defines the ODE passed to the ODE solver 47 */ 48 static PetscErrorCode RHSFunction(TS ts,PetscReal t,Vec U,Vec F,AppCtx *ctx) 49 { 50 PetscScalar *f,Pmax; 51 const PetscScalar *u; 52 53 PetscFunctionBegin; 54 /* The next three lines allow us to access the entries of the vectors directly */ 55 PetscCall(VecGetArrayRead(U,&u)); 56 PetscCall(VecGetArray(F,&f)); 57 if ((t > ctx->tf) && (t < ctx->tcl)) Pmax = 0.0; /* A short-circuit on the generator terminal that drives the electrical power output (Pmax*sin(delta)) to 0 */ 58 else Pmax = ctx->Pmax; 59 60 f[0] = ctx->omega_b*(u[1] - ctx->omega_s); 61 f[1] = (-Pmax*PetscSinScalar(u[0]) - ctx->D*(u[1] - ctx->omega_s) + ctx->Pm)*ctx->omega_s/(2.0*ctx->H); 62 63 PetscCall(VecRestoreArrayRead(U,&u)); 64 PetscCall(VecRestoreArray(F,&f)); 65 PetscFunctionReturn(0); 66 } 67 68 /* 69 Defines the Jacobian of the ODE passed to the ODE solver. See TSSetIJacobian() for the meaning of a and the Jacobian. 70 */ 71 static PetscErrorCode RHSJacobian(TS ts,PetscReal t,Vec U,Mat A,Mat B,AppCtx *ctx) 72 { 73 PetscInt rowcol[] = {0,1}; 74 PetscScalar J[2][2],Pmax; 75 const PetscScalar *u; 76 77 PetscFunctionBegin; 78 PetscCall(VecGetArrayRead(U,&u)); 79 if ((t > ctx->tf) && (t < ctx->tcl)) Pmax = 0.0; /* A short-circuit on the generator terminal that drives the electrical power output (Pmax*sin(delta)) to 0 */ 80 else Pmax = ctx->Pmax; 81 82 J[0][0] = 0; J[0][1] = ctx->omega_b; 83 J[1][1] = -ctx->D*ctx->omega_s/(2.0*ctx->H); J[1][0] = -Pmax*PetscCosScalar(u[0])*ctx->omega_s/(2.0*ctx->H); 84 85 PetscCall(MatSetValues(A,2,rowcol,2,rowcol,&J[0][0],INSERT_VALUES)); 86 PetscCall(VecRestoreArrayRead(U,&u)); 87 88 PetscCall(MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY)); 89 PetscCall(MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY)); 90 if (A != B) { 91 PetscCall(MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY)); 92 PetscCall(MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY)); 93 } 94 PetscFunctionReturn(0); 95 } 96 97 static PetscErrorCode RHSJacobianP(TS ts,PetscReal t,Vec X,Mat A,void *ctx0) 98 { 99 PetscInt row[] = {0,1},col[]={0}; 100 PetscScalar J[2][1]; 101 AppCtx *ctx=(AppCtx*)ctx0; 102 103 PetscFunctionBeginUser; 104 J[0][0] = 0; 105 J[1][0] = ctx->omega_s/(2.0*ctx->H); 106 PetscCall(MatSetValues(A,2,row,1,col,&J[0][0],INSERT_VALUES)); 107 PetscCall(MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY)); 108 PetscCall(MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY)); 109 PetscFunctionReturn(0); 110 } 111 112 static PetscErrorCode CostIntegrand(TS ts,PetscReal t,Vec U,Vec R,AppCtx *ctx) 113 { 114 PetscScalar *r; 115 const PetscScalar *u; 116 117 PetscFunctionBegin; 118 PetscCall(VecGetArrayRead(U,&u)); 119 PetscCall(VecGetArray(R,&r)); 120 r[0] = ctx->c*PetscPowScalarInt(PetscMax(0., u[0]-ctx->u_s),ctx->beta); 121 PetscCall(VecRestoreArray(R,&r)); 122 PetscCall(VecRestoreArrayRead(U,&u)); 123 PetscFunctionReturn(0); 124 } 125 126 static PetscErrorCode DRDUJacobianTranspose(TS ts,PetscReal t,Vec U,Mat DRDU,Mat B,AppCtx *ctx) 127 { 128 PetscScalar ru[1]; 129 const PetscScalar *u; 130 PetscInt row[] = {0},col[] = {0}; 131 132 PetscFunctionBegin; 133 PetscCall(VecGetArrayRead(U,&u)); 134 ru[0] = ctx->c*ctx->beta*PetscPowScalarInt(PetscMax(0., u[0]-ctx->u_s),ctx->beta-1); 135 PetscCall(VecRestoreArrayRead(U,&u)); 136 PetscCall(MatSetValues(DRDU,1,row,1,col,ru,INSERT_VALUES)); 137 PetscCall(MatAssemblyBegin(DRDU,MAT_FINAL_ASSEMBLY)); 138 PetscCall(MatAssemblyEnd(DRDU,MAT_FINAL_ASSEMBLY)); 139 PetscFunctionReturn(0); 140 } 141 142 static PetscErrorCode DRDPJacobianTranspose(TS ts,PetscReal t,Vec U,Mat DRDP,AppCtx *ctx) 143 { 144 PetscFunctionBegin; 145 PetscCall(MatZeroEntries(DRDP)); 146 PetscCall(MatAssemblyBegin(DRDP,MAT_FINAL_ASSEMBLY)); 147 PetscCall(MatAssemblyEnd(DRDP,MAT_FINAL_ASSEMBLY)); 148 PetscFunctionReturn(0); 149 } 150 151 PetscErrorCode ComputeSensiP(Vec lambda,Vec mu,AppCtx *ctx) 152 { 153 PetscScalar *y,sensip; 154 const PetscScalar *x; 155 156 PetscFunctionBegin; 157 PetscCall(VecGetArrayRead(lambda,&x)); 158 PetscCall(VecGetArray(mu,&y)); 159 sensip = 1./PetscSqrtScalar(1.-(ctx->Pm/ctx->Pmax)*(ctx->Pm/ctx->Pmax))/ctx->Pmax*x[0]+y[0]; 160 y[0] = sensip; 161 PetscCall(VecRestoreArray(mu,&y)); 162 PetscCall(VecRestoreArrayRead(lambda,&x)); 163 PetscFunctionReturn(0); 164 } 165 166 int main(int argc,char **argv) 167 { 168 Vec p; 169 PetscScalar *x_ptr; 170 PetscMPIInt size; 171 AppCtx ctx; 172 Vec lowerb,upperb; 173 Tao tao; 174 KSP ksp; 175 PC pc; 176 Vec U,lambda[1],mu[1]; 177 Mat A; /* Jacobian matrix */ 178 Mat Jacp; /* Jacobian matrix */ 179 Mat DRDU,DRDP; 180 PetscInt n = 2; 181 TS quadts; 182 183 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 184 Initialize program 185 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 186 PetscFunctionBeginUser; 187 PetscCall(PetscInitialize(&argc,&argv,NULL,help)); 188 PetscFunctionBeginUser; 189 PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD,&size)); 190 PetscCheck(size == 1,PETSC_COMM_WORLD,PETSC_ERR_WRONG_MPI_SIZE,"This is a uniprocessor example only!"); 191 192 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 193 Set runtime options 194 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 195 PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"Swing equation options",""); 196 { 197 ctx.beta = 2; 198 ctx.c = PetscRealConstant(10000.0); 199 ctx.u_s = PetscRealConstant(1.0); 200 ctx.omega_s = PetscRealConstant(1.0); 201 ctx.omega_b = PetscRealConstant(120.0)*PETSC_PI; 202 ctx.H = PetscRealConstant(5.0); 203 PetscCall(PetscOptionsScalar("-Inertia","","",ctx.H,&ctx.H,NULL)); 204 ctx.D = PetscRealConstant(5.0); 205 PetscCall(PetscOptionsScalar("-D","","",ctx.D,&ctx.D,NULL)); 206 ctx.E = PetscRealConstant(1.1378); 207 ctx.V = PetscRealConstant(1.0); 208 ctx.X = PetscRealConstant(0.545); 209 ctx.Pmax = ctx.E*ctx.V/ctx.X; 210 PetscCall(PetscOptionsScalar("-Pmax","","",ctx.Pmax,&ctx.Pmax,NULL)); 211 ctx.Pm = PetscRealConstant(1.0194); 212 PetscCall(PetscOptionsScalar("-Pm","","",ctx.Pm,&ctx.Pm,NULL)); 213 ctx.tf = PetscRealConstant(0.1); 214 ctx.tcl = PetscRealConstant(0.2); 215 PetscCall(PetscOptionsReal("-tf","Time to start fault","",ctx.tf,&ctx.tf,NULL)); 216 PetscCall(PetscOptionsReal("-tcl","Time to end fault","",ctx.tcl,&ctx.tcl,NULL)); 217 218 } 219 PetscOptionsEnd(); 220 221 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 222 Create necessary matrix and vectors 223 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 224 PetscCall(MatCreate(PETSC_COMM_WORLD,&A)); 225 PetscCall(MatSetSizes(A,n,n,PETSC_DETERMINE,PETSC_DETERMINE)); 226 PetscCall(MatSetType(A,MATDENSE)); 227 PetscCall(MatSetFromOptions(A)); 228 PetscCall(MatSetUp(A)); 229 230 PetscCall(MatCreateVecs(A,&U,NULL)); 231 232 PetscCall(MatCreate(PETSC_COMM_WORLD,&Jacp)); 233 PetscCall(MatSetSizes(Jacp,PETSC_DECIDE,PETSC_DECIDE,2,1)); 234 PetscCall(MatSetFromOptions(Jacp)); 235 PetscCall(MatSetUp(Jacp)); 236 PetscCall(MatCreateDense(PETSC_COMM_WORLD,PETSC_DECIDE,PETSC_DECIDE,1,1,NULL,&DRDP)); 237 PetscCall(MatSetUp(DRDP)); 238 PetscCall(MatCreateDense(PETSC_COMM_WORLD,PETSC_DECIDE,PETSC_DECIDE,1,2,NULL,&DRDU)); 239 PetscCall(MatSetUp(DRDU)); 240 241 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 242 Create timestepping solver context 243 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 244 PetscCall(TSCreate(PETSC_COMM_WORLD,&ctx.ts)); 245 PetscCall(TSSetProblemType(ctx.ts,TS_NONLINEAR)); 246 PetscCall(TSSetEquationType(ctx.ts,TS_EQ_ODE_EXPLICIT)); /* less Jacobian evaluations when adjoint BEuler is used, otherwise no effect */ 247 PetscCall(TSSetType(ctx.ts,TSRK)); 248 PetscCall(TSSetRHSFunction(ctx.ts,NULL,(TSRHSFunction)RHSFunction,&ctx)); 249 PetscCall(TSSetRHSJacobian(ctx.ts,A,A,(TSRHSJacobian)RHSJacobian,&ctx)); 250 PetscCall(TSSetExactFinalTime(ctx.ts,TS_EXACTFINALTIME_MATCHSTEP)); 251 252 PetscCall(MatCreateVecs(A,&lambda[0],NULL)); 253 PetscCall(MatCreateVecs(Jacp,&mu[0],NULL)); 254 PetscCall(TSSetCostGradients(ctx.ts,1,lambda,mu)); 255 PetscCall(TSSetRHSJacobianP(ctx.ts,Jacp,RHSJacobianP,&ctx)); 256 257 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 258 Set solver options 259 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 260 PetscCall(TSSetMaxTime(ctx.ts,PetscRealConstant(1.0))); 261 PetscCall(TSSetTimeStep(ctx.ts,PetscRealConstant(0.01))); 262 PetscCall(TSSetFromOptions(ctx.ts)); 263 264 PetscCall(TSGetTimeStep(ctx.ts,&ctx.dt)); /* save the stepsize */ 265 266 PetscCall(TSCreateQuadratureTS(ctx.ts,PETSC_TRUE,&quadts)); 267 PetscCall(TSSetRHSFunction(quadts,NULL,(TSRHSFunction)CostIntegrand,&ctx)); 268 PetscCall(TSSetRHSJacobian(quadts,DRDU,DRDU,(TSRHSJacobian)DRDUJacobianTranspose,&ctx)); 269 PetscCall(TSSetRHSJacobianP(quadts,DRDP,(TSRHSJacobianP)DRDPJacobianTranspose,&ctx)); 270 PetscCall(TSSetSolution(ctx.ts,U)); 271 272 /* Create TAO solver and set desired solution method */ 273 PetscCall(TaoCreate(PETSC_COMM_WORLD,&tao)); 274 PetscCall(TaoSetType(tao,TAOBLMVM)); 275 276 /* 277 Optimization starts 278 */ 279 /* Set initial solution guess */ 280 PetscCall(VecCreateSeq(PETSC_COMM_WORLD,1,&p)); 281 PetscCall(VecGetArray(p,&x_ptr)); 282 x_ptr[0] = ctx.Pm; 283 PetscCall(VecRestoreArray(p,&x_ptr)); 284 285 PetscCall(TaoSetSolution(tao,p)); 286 /* Set routine for function and gradient evaluation */ 287 PetscCall(TaoSetObjective(tao,FormFunction,(void *)&ctx)); 288 PetscCall(TaoSetGradient(tao,NULL,FormGradient,(void *)&ctx)); 289 290 /* Set bounds for the optimization */ 291 PetscCall(VecDuplicate(p,&lowerb)); 292 PetscCall(VecDuplicate(p,&upperb)); 293 PetscCall(VecGetArray(lowerb,&x_ptr)); 294 x_ptr[0] = 0.; 295 PetscCall(VecRestoreArray(lowerb,&x_ptr)); 296 PetscCall(VecGetArray(upperb,&x_ptr)); 297 x_ptr[0] = PetscRealConstant(1.1); 298 PetscCall(VecRestoreArray(upperb,&x_ptr)); 299 PetscCall(TaoSetVariableBounds(tao,lowerb,upperb)); 300 301 /* Check for any TAO command line options */ 302 PetscCall(TaoSetFromOptions(tao)); 303 PetscCall(TaoGetKSP(tao,&ksp)); 304 if (ksp) { 305 PetscCall(KSPGetPC(ksp,&pc)); 306 PetscCall(PCSetType(pc,PCNONE)); 307 } 308 309 /* SOLVE THE APPLICATION */ 310 PetscCall(TaoSolve(tao)); 311 312 PetscCall(VecView(p,PETSC_VIEWER_STDOUT_WORLD)); 313 /* Free TAO data structures */ 314 PetscCall(TaoDestroy(&tao)); 315 PetscCall(VecDestroy(&p)); 316 PetscCall(VecDestroy(&lowerb)); 317 PetscCall(VecDestroy(&upperb)); 318 319 PetscCall(TSDestroy(&ctx.ts)); 320 PetscCall(VecDestroy(&U)); 321 PetscCall(MatDestroy(&A)); 322 PetscCall(MatDestroy(&Jacp)); 323 PetscCall(MatDestroy(&DRDU)); 324 PetscCall(MatDestroy(&DRDP)); 325 PetscCall(VecDestroy(&lambda[0])); 326 PetscCall(VecDestroy(&mu[0])); 327 PetscCall(PetscFinalize()); 328 return 0; 329 } 330 331 /* ------------------------------------------------------------------ */ 332 /* 333 FormFunction - Evaluates the function 334 335 Input Parameters: 336 tao - the Tao context 337 X - the input vector 338 ptr - optional user-defined context, as set by TaoSetObjectiveAndGradient() 339 340 Output Parameters: 341 f - the newly evaluated function 342 */ 343 PetscErrorCode FormFunction(Tao tao,Vec P,PetscReal *f,void *ctx0) 344 { 345 AppCtx *ctx = (AppCtx*)ctx0; 346 TS ts = ctx->ts; 347 Vec U; /* solution will be stored here */ 348 PetscScalar *u; 349 PetscScalar *x_ptr; 350 Vec q; 351 352 PetscCall(VecGetArrayRead(P,(const PetscScalar**)&x_ptr)); 353 ctx->Pm = x_ptr[0]; 354 PetscCall(VecRestoreArrayRead(P,(const PetscScalar**)&x_ptr)); 355 356 /* reset time */ 357 PetscCall(TSSetTime(ts,0.0)); 358 /* reset step counter, this is critical for adjoint solver */ 359 PetscCall(TSSetStepNumber(ts,0)); 360 /* reset step size, the step size becomes negative after TSAdjointSolve */ 361 PetscCall(TSSetTimeStep(ts,ctx->dt)); 362 /* reinitialize the integral value */ 363 PetscCall(TSGetCostIntegral(ts,&q)); 364 PetscCall(VecSet(q,0.0)); 365 366 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 367 Set initial conditions 368 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 369 PetscCall(TSGetSolution(ts,&U)); 370 PetscCall(VecGetArray(U,&u)); 371 u[0] = PetscAsinScalar(ctx->Pm/ctx->Pmax); 372 u[1] = PetscRealConstant(1.0); 373 PetscCall(VecRestoreArray(U,&u)); 374 375 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 376 Solve nonlinear system 377 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 378 PetscCall(TSSolve(ts,U)); 379 PetscCall(TSGetCostIntegral(ts,&q)); 380 PetscCall(VecGetArray(q,&x_ptr)); 381 *f = -ctx->Pm + x_ptr[0]; 382 PetscCall(VecRestoreArray(q,&x_ptr)); 383 return 0; 384 } 385 386 PetscErrorCode FormGradient(Tao tao,Vec P,Vec G,void *ctx0) 387 { 388 AppCtx *ctx = (AppCtx*)ctx0; 389 TS ts = ctx->ts; 390 Vec U; /* solution will be stored here */ 391 PetscReal ftime; 392 PetscInt steps; 393 PetscScalar *u; 394 PetscScalar *x_ptr,*y_ptr; 395 Vec *lambda,q,*mu; 396 397 PetscCall(VecGetArrayRead(P,(const PetscScalar**)&x_ptr)); 398 ctx->Pm = x_ptr[0]; 399 PetscCall(VecRestoreArrayRead(P,(const PetscScalar**)&x_ptr)); 400 401 /* reset time */ 402 PetscCall(TSSetTime(ts,0.0)); 403 /* reset step counter, this is critical for adjoint solver */ 404 PetscCall(TSSetStepNumber(ts,0)); 405 /* reset step size, the step size becomes negative after TSAdjointSolve */ 406 PetscCall(TSSetTimeStep(ts,ctx->dt)); 407 /* reinitialize the integral value */ 408 PetscCall(TSGetCostIntegral(ts,&q)); 409 PetscCall(VecSet(q,0.0)); 410 411 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 412 Set initial conditions 413 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 414 PetscCall(TSGetSolution(ts,&U)); 415 PetscCall(VecGetArray(U,&u)); 416 u[0] = PetscAsinScalar(ctx->Pm/ctx->Pmax); 417 u[1] = PetscRealConstant(1.0); 418 PetscCall(VecRestoreArray(U,&u)); 419 420 /* Set up to save trajectory before TSSetFromOptions() so that TSTrajectory options can be captured */ 421 PetscCall(TSSetSaveTrajectory(ts)); 422 PetscCall(TSSetFromOptions(ts)); 423 424 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 425 Solve nonlinear system 426 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 427 PetscCall(TSSolve(ts,U)); 428 429 PetscCall(TSGetSolveTime(ts,&ftime)); 430 PetscCall(TSGetStepNumber(ts,&steps)); 431 432 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 433 Adjoint model starts here 434 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 435 PetscCall(TSGetCostGradients(ts,NULL,&lambda,&mu)); 436 /* Set initial conditions for the adjoint integration */ 437 PetscCall(VecGetArray(lambda[0],&y_ptr)); 438 y_ptr[0] = 0.0; y_ptr[1] = 0.0; 439 PetscCall(VecRestoreArray(lambda[0],&y_ptr)); 440 PetscCall(VecGetArray(mu[0],&x_ptr)); 441 x_ptr[0] = PetscRealConstant(-1.0); 442 PetscCall(VecRestoreArray(mu[0],&x_ptr)); 443 444 PetscCall(TSAdjointSolve(ts)); 445 PetscCall(TSGetCostIntegral(ts,&q)); 446 PetscCall(ComputeSensiP(lambda[0],mu[0],ctx)); 447 PetscCall(VecCopy(mu[0],G)); 448 return 0; 449 } 450 451 /*TEST 452 453 build: 454 requires: !complex 455 456 test: 457 args: -viewer_binary_skip_info -ts_adapt_type none -tao_monitor -tao_gatol 0.0 -tao_grtol 1.e-3 -tao_converged_reason 458 459 test: 460 suffix: 2 461 args: -viewer_binary_skip_info -ts_adapt_type none -tao_monitor -tao_gatol 0.0 -tao_grtol 1.e-3 -tao_converged_reason -tao_test_gradient 462 463 TEST*/ 464