diff --git a/Homework4/src/main.py b/Homework4/src/main.py
index e786771..84125ab 100644
--- a/Homework4/src/main.py
+++ b/Homework4/src/main.py
@@ -1,97 +1,98 @@
 #!/bin/env python3
 
 import sys
 import argparse
 import pypart
 from pypart import MaterialPointsFactory, ParticlesFactoryInterface
 from pypart import PingPongBallsFactory, PlanetsFactory
 from pypart import CsvWriter
 from pypart import ComputeTemperature
 from pypart import ComputeGravity
 from pypart import ComputeVerletIntegration
+
 # help(pypart)
 
 def main(nsteps,freq,filename,particle_type,timestep):
 
     #print(pypart.__file__)
 
     if particle_type == "planet":
         PlanetsFactory.getInstance()
     elif particle_type == "ping_pong":
         PingPongBallsFactory.getInstance()
     elif particle_type == "material_point":
         MaterialPointsFactory.getInstance()
     else:
         print("Unknown particle type: ", particle_type)
         sys.exit(-1)
 
     factory = ParticlesFactoryInterface.getInstance()
 
     def createComputes(self, timestep):
 
         if particle_type == "planet":
     
             try:
                 compute_grav = ComputeGravity()
                 compute_verlet = ComputeVerletIntegration(timestep)
         
                 G = 6.67384e-11 # m^3 * kg^-1 * s^-2
                 UA = 149597870.700 # km
                 earth_mass = 5.97219e24 # kg
                 G /= (UA * 1e3)**3 # UA^3 * kg^-1 * s^-2
                 G *= earth_mass    # UA^3 * earth_mass^-1 * s^-2
                 G *= (60*60*24)**2 # UA^3 * earth_mass^-1 * day^-2
         
                 compute_grav.setG(G)
                 compute_verlet.addInteraction(compute_grav)
                 self.system_evolution.addCompute(compute_verlet)
             
             except Exception as e:
                 help(compute_grav)
                 raise e
         
         elif particle_type == 'material_points':
         
             try:
                 compute_temp = ComputeTemperature()
                 compute_temp.conductivity = 1
                 compute_temp.L = 2
                 compute_temp.capacity = 1
                 compute_temp.density = 1
                 compute_temp.deltat = 1
                 self.system_evolution.addCompute(compute_temp)
             except Exception as e:
                 help(compute_temp)
                 raise e
 
     evol = factory.createSimulation(filename, timestep, createComputes)
 
     dumper = CsvWriter("out.csv")
     dumper.write(evol.getSystem())
     
     evol.setNSteps(nsteps)
     evol.setDumpFreq(freq)
     evol.evolve()
 
 if __name__ == "__main__":
 
     parser = argparse.ArgumentParser(description='Particles code')
     parser.add_argument('nsteps', type=int,
                         help='specify the number of steps to perform')
     parser.add_argument('freq', type=int,
                         help='specify the frequency for dumps')
     parser.add_argument('filename', type=str,
                         help='start/input filename')
     parser.add_argument('particle_type', type=str,
                         help='particle type')
     parser.add_argument('timestep', type=float,
                         help='timestep')
     
     args = parser.parse_args()
     nsteps = args.nsteps
     freq = args.freq
     filename = args.filename
     particle_type = args.particle_type
     timestep = args.timestep
 
     main(nsteps,freq,filename,particle_type,timestep)
diff --git a/Homework4/src/pypart.cc b/Homework4/src/pypart.cc
index ca04f02..72b5af1 100644
--- a/Homework4/src/pypart.cc
+++ b/Homework4/src/pypart.cc
@@ -1,32 +1,32 @@
 #include <functional>
 #include <iostream>
 #include <pybind11/pybind11.h>
 
 #include "csv_writer.hh"
 #include "compute.hh"
 #include "compute_temperature.hh"
 #include "material_points_factory.hh"
 #include "particles_factory_interface.hh"
 #include "ping_pong_balls_factory.hh"
 #include "planets_factory.hh"
 #include "system_evolution.hh"
 
 namespace py = pybind11;
 
 PYBIND11_MODULE(pypart, m) {
     m.doc() = "Python binding for the particles code.";
     
     // Class System
     py::class_<System>(m, "System");
     
     // Class SystemEvolution
     py::class_<SystemEvolution, std::unique_ptr<SystemEvolution>>(m, "SystemEvolution",
                                                                   py::dynamic_attr())
         .def(py::init([](std::unique_ptr<System>()){return std::unique_ptr<SystemEvolution>();}),
              py::return_value_policy::move)
-        .def("addCompute",  &SystemEvolution::addCompute)
         .def("evolve",      &SystemEvolution::evolve)
+        .def("addCompute",  &SystemEvolution::addCompute)
         .def("getSystem",   &SystemEvolution::getSystem, py::return_value_policy::reference)
         .def("setNSteps",   &SystemEvolution::setNSteps)
-        .def("setDumpFreq", &SystemEvolution::setDumpFreq)
+        .def("setDumpFreq", &SystemEvolution::setDumpFreq);
 }