User:Karthik0112358

C S Karthik is an undergraduate at IIT-Bombay and is working on addition of an rSQP optimiser for ASCEND during GSOC2011.

Goals

The reduced space SQP (rSQP) algorithm has seen many applications in large-scale engineering models. I intend to accept an input and parse it such that the solver can act on it. Further I am going to take up various test cases and check for bugs/inconsistencies. And if time permits I would like to write an optimization algorithm/code which, based on the given input, decides which is the best solver to send the input to.

Progress reports

June 20

I have worked on a skeletal code (this is an addition to previous skeletal code- in other words providing some flesh to the skeleton) where I try to determine a row entry of the mass matrix.

//This is just a function. I am not sure where to place it (either in a separate place or with in the previous skeletal code).
int coefficient_find(struct rel_relation *rel, const var_filter_t *filter,int32 *count){
   const struct var_variable **vlist=NULL;
   int32 len,c;
   int status;
   assert(rel!=NULL && filter!=NULL);
   len = rel_n_incidences(rel);
   vlist = rel_incidence_list(rel);
   *count = 0;
   status =(int32)Coefficient_Calculator(rel_instance(rel)); 
   for (c=0; c < len; c++) {
      if (var_apply_filter(vlist[c],filter)) {
         variables[*count] = var_sindex(vlist[c]);
         (*count)++;
      }
   }
}

Again here I have tried to get a required version of relman_diff2() of ascend/system/relman.c. So in crux the entire task boils down to rewriting RelationCalcResidGradSafe() of ascend/compiler/relation_util.c into a function which gets the coefficients of the derivative terms - Coefficient_Calculator(). I will get a code out for that.

As of now I have a partial code for Coefficient_Calculator():

int Coefficient_Calculator(struct Instance *i){
   struct relation *r;
   enum Expr_enum reltype;
   int dummy_int;
   r = (struct relation *)GetInstanceRelation(i, &reltype);
   if( r == NULL ) {
      ERROR_REPORTER_HERE(ASC_PROG_ERR,"null relation\n");
      return -1;
   }
//At this point of writing the code, I realize the significance of why John Pye had asked me to understand expression-evaluation data structures. I need to write cases for reltype. I need some thinking.   
}

June 19

So here is some skeletal-code:

//Include necessary headers.
int massmatrix(slv_system_t sys,  struct massmatrixStruct *mass, const rel_filter_t *rfilter, const var_filter_t *vfilter){
// here there might be some more parameters to accept. I haven't figured it out yet. Although I think some filter parameters need to be shaken up a little.
   struct var_variable **svars;
   struct rel_relation **srels;
   mtx_coord_t coord;
//the above declarations are self explanatory.
   int i,j,n,nsr,nsv,nr,nv;
//first count the rels
   nsr = slv_get_num_solvers_rels(sys);
   nr = slv_count_solvers_rels(sys,rfilter);
   srels = slv_get_solvers_rel_list(sys);
//and vars
   nsv = slv_get_num_solvers_vars(sys);
   nv = slv_count_solvers_vars(sys,vfilter);
   svars = slv_get_solvers_var_list(sys);
//allocate space for lists
   mass->vars = ASC_NEW_ARRAY(struct var_variable*, nv);
   mass->rels = ASC_NEW_ARRAY(struct rel_relation*, nr);
   vartocol = ASC_NEW_ARRAY(int,nsv);
//So till here code looks neat. Gets slightly messy from now on.
//now create a the lists of vars and rels, and temp mapping array
   n = 0;
   for(i=0;i<nsr;++i){
      if(rel_apply_filter(srels[i],rfilter)){
         mass->rels[n++] = srels[i];
      }
   }
   asc_assert(n==nr);
   n = 0;
   for(i=0;i<nsv;++i){
      if(var_apply_filter(svars[i],vfilter)){         
         vartocol[i]=n;
         mass->vars[n++] = svars[i];
      }else{
         vartocol[i]=-1;
      }
   }
   asc_assert(n==nv);
//now create a matrix
   mass->M = mtx_create();
   mtx_set_order(mass->M, MAX(nv,nr));
   for(i=0;i<nr;++i){
//Need to write a function, so that I can call it here which basically takes the relation and finds the coefficients of all first order derivatives. 
      for(j=0;j<n;++j){
         mtx_set_value(mass->M,mtx_coord(&coord,i,vartocol[/* need to figure equivalent here*/]),/*put the equivalent figured here too*/);
      }
//Check for errors in doing above 2 operations via function call
   }
   mass->n_rels = nr;
   mass->n_vars = nv;
}
/*
I would define the structure massmatrix in the header as:
struct massmatrixStruct{
   mtx_matrix_t M;
   struct rel_relation **rels;
   struct var_variable **vars;
   int n_rels, n_vars;
}; 
*/

I know I haven't followed the coding style of Ascend. I will modify code ASAP.

June 17

After giving it some thought, I think the structure of the mass matrix function should look more like system_jacobian() which is present in jacobian.c in ascend/system. Will sketch a pseudo code out after better clarity.

I am trying to see how to utilize doxy:System Structure, as I see potential information regarding extracting coefficients of y_i^' in equation. Since I am asked not to access the structure directly, I am looking through its implementation in slv_client.h.

After reading ascend/system/slv_client.h comments (which I might add are very descriptive and helpful), I realize the importance of the rel_relation structure as this contains the equation data. I have stopped trying to understand struct system and focus back on rel_relation.

So here is a plan. I replicate the entire set of codes required to find the Jacobian matrix. Now from what I know entries to the Jacobian are done row wise. Now Jacobian(mXn matrix) is found out for functions F : Rⁿ → R^m. However with the mass matrix problem, I am dealing with equations. So, my idea is to manipulate these equations into functions and replace the content of the (i,j) entry (by replacing the code which writes the content) into Jacobian with a different set of code, so that we get desirable result. Will get back on this.

June 16

• Reading relman_diff2() and trying to understand what are the input variables, which header to include, etc. Got some nice help from http://www.ascend4.org/doxy/d0/d7e/a00770.html#ga9469a6f8ff5a7d0eec8a1cad74732fdf. Came with some pseudo code

#include <ascend/compiler/rel_blackbox.h>
//#include <ascend/compiler/relation.h>
//#include <ascend/compiler/relation_util.h>
//#include <ascend/compiler/relation_io.h>
//#include "mass_matrix.h"
//#include "slv_server.h"
#define IPTR(i) ((struct Instance *)(i))
#define KILL 0 /* compile dead code if kill = 1 */
#define REIMPLEMENT 0 /* code that needs to be reimplemented */
#define rel_tmpalloc_array(nelts,type)  \
   ((nelts) > 0 ? (type *)tmpalloc((nelts)*sizeof(type)) : NULL)
static double dsolve_scratch = 0.0;        /* some workspace */
#define DSOLVE_TOLERANCE 1.0e-08                /* no longer needed */
#define BROKENKIRK 0
/* return 0 on success (derivatives, variables and count are output vars too) */
int massmatrix(struct rel_relation *rel, const var_filter_t *filter
        ,real64 *derivatives, int32 *variables
        ,int32 *count){
  const struct var_variable **vlist=NULL;
  int32 len,c;
  int status;
  //CONSOLE_DEBUG("In Function: relman_diff2");
  assert(rel!=NULL && filter!=NULL);
  len = rel_n_incidences(rel);//this gives me the length of incidence- which I think is the number of columns of mass matrix
  vlist = rel_incidence_list(rel);//have to write rel_mass_matrix() which basically does the same thing
  *count = 0;

    for (c=0; c < len; c++) {
     //write the stuff here
     
      }

    return status;

}

June 15

• Trying to understand about expression-evaluation data structures by reading the following c code: ascend/system/relman.c.
• Re-reading Developer's Manual for better clarity.
• Checked out contents of Moocho and broadly read basic documentation.
• Installing MOOCHO: Downloaded trilinos-10.6.4-Source.tar.gz. As first step of the installation, I downloaded CMake. In the last step of Installation of CMake, I got the following error:

CMake Error at cmake_install.cmake:36 (FILE): file cannot create directory: /usr/local/doc/cmake-2.8. Maybe need administrative privileges.

make: *** [install] Error 1

Further on trying to install Trilinos, with the following commands, I got the following error :

~/SOME_BUILD_DIR$ cmake \

> -D CMAKE_BUILD_TYPE:STRING=DEBUG \

> -D Trilinos ENABLE <moocho>:BOOL=ON \

> -D Trilinos_ENABLE_TESTS:BOOL=ON \

> -D DART_TESTING_TIMEOUT:STRING=600 \

> $EXTRA_ARGS \

> {TRILINOS_HOME}

bash: moocho: No such file or directory

I contacted Bartlett, Roscoe A (rabartl@sandia.gov) via email regarding this problem. Hoping for an early reply.

June 13 - June 19

• Use of valgrind did not provide much insight. Karthik: add DETAILS of what you found here please -- Jpye 07:53, 16 June 2011 (UTC)

June 6 - June 12

Finding a temporary fix for the mass matrix problem. I have split the task as to finding solution to 2 problems:

• (i) Making sure algebraic equations are being sent to solver.
• (ii) Writing a feasible mass matrix function to generate the mass matrix. This depends on (i).

Regarding Solving Part (i), I made an outside link and was able to capture all the variables involved. Trying to use them to find total number of equations. In completing part (ii) I am facing "INSUFFICIENT MEMORY" problem. Trying to fix that too. I am at present able to count total number of variables, solver variables, independent variables and number of differential equations. I would like to figure out a way to count number of free variables.

I have been able to find a solution to part(i), but it has 2 constraints,

• If number of total variables>>total number of equations, then the max number of substeps has to be reduced.
• The solution involves providing data outside given data structures and thus cannot employed as it is to ascend.

As far as part (ii) goes, there seems to be a simple fix. I am trying to figure it out through Valgrind's Memory loss method.

May 30 - June 5

• Completed reading Mathematical and High-Level Overview of MOOCHO.

May 23 - May 29

• Continue reading Mathematical and High-Level Overview of MOOCHO.

Prior to 23 May 2011:

Related to rSQP:

• Started reading Mathematical and High-Level Overview of MOOCHO. However was later redirected to chapter 12 (Nonlinear programming) of "Operations Research: Applications and Algorithms" from Winston, 1994, 3rd (or a later) Ed., Duxbury Press (Belmont, California) as a preliminary reading for mathematical background.
• Completed reading chapter 12 (Nonlinear programming) of "Operations Research: Applications and Algorithms".
• Re-reading Mathematical and High-Level Overview of MOOCHO.
• Revisited theory behind the Simplex Algorithm from "Introduction to Algorithms", 3rd Edition, Page 864-879 authored by Cormen, Leisersin, Rivest, Stein.

Related to Radau5:

• Investigated code ascend/integrator/integrator.h and ascend/integrator/integrator.c to understand the data structures used.
• Devised and tried implementation of various for the mass matrix problem in solvers/radau5/asc_radau5.c.
• Settled on the idea of replacing neq with total number of equations as compared to the previous implementation of number of states.