Ascent-beta

Entire Systems As ODEs

Often times simulation software will separate differential equation solving from the rest of the system. Ascent provides more accurate results by collectively solving entire systems within its differential equation engine.

Minimum Phase-Based Integration

Simulations are run by implementing no more than six phases. These phases (init, update, postcalc, check, report, and reset) are the minimum number of phases for the design features allowed. Ascent supports pre, intermediate, and post integration computations, checking mechanisms for stopping the simulation, resetting of parameters to support driving modules, and more.

Phases are implemented as virtual methods inherited by a common asc::Module class.

init

To initialize modules and variables.

update

Handle derivative computations. Discrete parameters can be set within an if(sample()) block.

postcalc

For computations based on integrated states.

check

Check whether the simulation should be stopped.

report

Print or output end of step states.

reset

Reset module variables, to support multiple drivers affecting the same module.

#pragma once

#include "ascent/Link.h"
#include "Eigen/Dense"

class Lorenz : public asc::Module
{
public:
   Eigen::Vector3d x = Eigen::Vector3d::Zero();
   Eigen::Vector3d xd = Eigen::Vector3d::Zero(); // derivative of x

   const double sigma = 10.0;
   const double R = 28.0;
   const double b = 8.0 / 3.0;

   Lorenz(size_t sim);

protected:
   void update();
};

#include "Lorenz.h"

Lorenz::Lorenz(size_t sim) : asc::Module(sim)
{
   addIntegrator(x, xd);

#define ascNS Lorenz
   ascVar(x)
}

void Lorenz::update()
{
   xd[0] = sigma*(x[1] - x[0]);
   xd[1] = R*x[0] - x[1] - x[0] * x[2];
   xd[2] = -b*x[2] + x[0] * x[1];
}

#include "Lorenz.h"

int main()
{
   Lorenz lorenz(0);
   lorenz.name<Lorenz>("lorenz");
   lorenz.x = Eigen::Vector3d(10.0, 1.0, 1.0); // initial conditions

   lorenz.track("t");
   lorenz.track("x");

   lorenz.run(0.01, 50.0); // time step and simulation end time

   lorenz.outputTrack();

   return 0;
}

t,lorenz x
0,10.000000,1.000000,1.000000
0.01,9.269483,3.563663,1.190859
0.02,8.841946,5.921403,1.583097
0.03,8.672069,8.135682,2.148331
0.04,8.724232,10.257212,2.880594
0.05,8.970418,12.323869,3.789982
continued...

Integrators

The programmer doesn't define any of this ordering. The ordering is automatically generated from how module data is accesssed.

Ascent provides a built in engine for efficiently tracking variables.

• Save to .csv file
• Stream via std::stringstream
• Output as csv or JSON formatted std::string

// Define namespace
#define ascNS Lorenz
   ascVar(x) // Variable x can be tracked and scripted

// Track time (t) and x (Eigen::Vector3d)
lorenz.track("t");
lorenz.track("x");

t,lorenz x
0,10.000000,1.000000,1.000000
0.01,9.269483,3.563663,1.190859
0.02,8.841946,5.921403,1.583097
continued...

Easily connect, initialize, and run your models in the embedded ChaiScript engine.

• Handles Eigen linear algebra matrix operations

Ascent uses the fast and mature Eigen C++ linear algebra library, providing straightforward matrix and vector handling.

• Solve differential equations with Eigen vectors and matrices
• Track Eigen vectors and output history to csv files
• Compute time history derivatives and integrals of vectors

Built in JSON API for externally accessing and setting variable states. Powered by the jsoncons library.

• Automatically interpolates data at requested simulation time
• Interchangeable input/output: output from JsonAPI can be directly used as input to a distributed Ascent instance