v 0.2.2 changed constructor of TestMass and AcmeSim

core/AcmeSim.m

 classdef AcmeSim
 % ACMESIM Summary of this class goes here
 %   Detailed explanation goes here
+%
+% Author: Arthur Reis
+% email: arthur.reis@aei.mpg.de
+% Last revision: 26.jan.2023;
 
     properties
         ModelName
@@ -16,13 +20,11 @@ classdef AcmeSim
         kb = 1.3806e-23; %boltzmann
         T = 300; % K
         flpsdOpts
-% lpsd 
     end
     
     methods
         function obj = AcmeSim(varargin)
             %ACMESIM Construct an instance of this class
-            %   Detailed explanation goes here
             flpsdopts = {'fs',        1,...
                          'Lmin' ,     1,...
                          'order',     0,...
@@ -45,26 +47,156 @@ classdef AcmeSim
             obj.StopTime      = p.Results.StopTime;
             obj.NumberOfSteps = p.Results.NumberOfSteps;
             obj.flpsdOpts     = p.Results.flpsdOpts;
-
             obj.ENBW          = 1/obj.StopTime;
             obj.StepSize      = obj.StopTime/obj.NumberOfSteps;
             obj.Time          = (0:obj.StepSize:(obj.StopTime-obj.StepSize))';
             obj.SampleFrequency = 1/obj.StepSize;   
             obj.Frequencies   = logspace(-log10(obj.StopTime),log10(obj.SampleFrequency/2),100);    
-            obj.flpsdOpts{2} = {obj.SampleFrequency};
+            obj.flpsdOpts{2}  = obj.SampleFrequency;
+            
             % Load simulink model
             obj.ModelHandle = load_system(obj.ModelName);
         end
         
-        function obj = initModel(obj)
-            obj.ModelHandle = load_system(obj.ModelName);
+%         function obj = initModel(obj)
+%             obj.ModelHandle = load_system(obj.ModelName);
+%         end
+% 
+%         function initModelParameters(obj)
+%             get_param(obj.ModelHandle,'ObjectParameters');
+%             set_param(obj.ModelHandle,'StopTime',num2str(obj.StopTime));
+%             set_param(obj.ModelHandle,'MaxStep', num2str(obj.StepSize));
+%            % set_param(obj.ModelHandle)
+%         end
+
+        function cmpnt = addComponent(obj, componentType, varargin)
+            % Wrapper to include the model name
+            model = obj.ModelName;
+            solver = "Variable-step";
+
+            % calls the right constructor
+            switch lower(componentType)
+                case 'electrode'
+                    %Electrode(model, block, area, pos0, V_DC, V_AC, f)
+                    cmpnt = Electrode(varargin{:},'model',model);
+                case 'capacitor'
+                    cmpnt = Capacitor(varargin{:},'model',model);
+                case 'testmass'
+                    cmpnt = TestMass(varargin{:},'model',model, 'solver',solver);
+                otherwise
+                    error('No component match')
+            end
+        end
+
+        function cp = addCapacitor(obj, BlockName, varargin)
+             % Add component Plane Capacitor to acme
+            % Syntax: 
+            %    cp = addCapacitor(obj, BlockName, varargin)
+            % Input:
+            %    BlockName - name of the block in the simulink model, char array
+            %    varargin - 
+            %       eps0 - dielectric constant, default eps0 = 8.854e-12 F/m
+            % Output:
+            %    cp - Capacitor object
+            %
+            % Author: Arthur Reis
+            % email: arthur.reis@aei.mpg.de
+            % Last revision: 30.Jan.2023
+
+            p = inputParser;
+            p.addOptional('Eps0', obj.eps0);
+            p.addOptional('ElectrodePair',['','']);
+            p.parse(varargin{:});
+
+            eps0 = p.Results.Eps0; %#ok<PROPLC> 
+            
+            % TO DO: add to the list of known blocks in acme?
+
+            cp = addComponent(obj,'capacitor', 'BlockName', BlockName,...
+                'Eps0', eps0, 'ElectrodePair',p.Results.ElectrodePair); %#ok<PROPLC> 
+        end
+
+        function el = addElectrode(obj, BlockName, LengthSides, pos0, varargin)
+            % Add component Electrode to acme
+            % Syntax: 
+            %    el = addElectrode(obj, BlockName, LengthSides, pos0, varargin)
+            % Input:
+            %    BlockName - name of the block in the simulink model, char array
+            %    LengthSides - length of the sides of the electrode, in meters,
+            %        1x2 double
+            %    pos0 - initial position of the electrode in along the DoF, in
+            %    meters, i.r.t. CoM
+            %    varargin - 
+            %       V_DC - DC bias of the electrode, V
+            %       V_AC - AC bias of the electrode, Vrms
+            % Output:
+            %    el - Electrode object
+            %
+            % Author: Arthur Reis
+            % email: arthur.reis@aei.mpg.de
+            % Last revision: 27.Jan.2023
+
+            p = inputParser;
+            p.addOptional('V_DC',0);
+            p.addOptional('V_AC',0);
+            p.addOptional('f',0);
+            p.parse(varargin{:});
+
+            V_DC = p.Results.V_DC;
+            V_AC = p.Results.V_AC;
+            f = p.Results.f;
+
+            % TO DO: add to the list of known blocks in acme?
+
+            el = addComponent(obj,'electrode', 'BlockName', BlockName, ...
+                              'LengthSides', LengthSides, 'pos0', pos0, ...
+                              'V_DC', V_DC, 'V_AC', V_AC, 'f', f);
+        end
+
+        function tm = addTestMass(obj, BlockName, LengthSides, gap, varargin)
+            % Add component TestMass to acme
+            % Syntax: 
+            %    tm = addTestMass(obj, BlockName, lengthSides, gap, varargin)
+            % Input:
+            %    BlockName - name of the block in the simulink model, char array
+            %    LengthSides - length of the sides of the electrode, in meters,
+            %        1x2 double
+            %    pos0 - initial position of the electrode in along the DoF, in
+            %    meters, i.r.t. CoM
+            %    varargin - 
+            %       V_DC - DC bias of the electrode, V
+            %       V_AC - AC bias of the electrode, Vrms
+            % Output:
+            %    el - Electrode object
+            %
+            % Author: Arthur Reis
+            % email: arthur.reis@aei.mpg.de
+            % Last revision: 27.Sep.2022;
+
+            
+            % TO DO: add to the list of known blocks in acme?
+
+            tm = addComponent(obj,'testmass',LengthSides, gap, ...
+                'BlockName', BlockName, varargin{:});
+        end
+        
+        function n = noiseTS(obj,noiseASD, varargin)
+            outputmode = 'array';
+            if length(varargin) == 1
+                outputmode = varargin{1};
+            end
+            nTS = timeseriesFromASD(noiseASD, obj.ENBW,...
+                    obj.SampleFrequency, obj.NumberOfSteps);    
+            
+            switch lower(outputmode)
+                case 'ts'
+                    n = nTS;
+                case 'data_only'
+                    n = nTS.Data;
+                case 'array'
+                    n = [obj.Time nTS.Data];
             end
                 
-        function initModelParameters(obj)
-            get_param(obj.ModelHandle,'ObjectParameters');
-            set_param(obj.ModelHandle,'StopTime',num2str(obj.StopTime));
-            set_param(obj.ModelHandle,'MaxStep', num2str(obj.StepSize));
-           % set_param(obj.ModelHandle)
         end
     end
 end

core/component/Capacitor.m

+classdef Capacitor < Component
+    %TESTMASS Summary of this class goes here
+    %   Detailed explanation goes here
+    
+    properties
+        electrodeA 
+        electrodeB 
+        eps0
+    end
+
+    properties (Dependent)
+        gap0
+        c0
+    end
+    
+    methods
+        function obj = Capacitor(varargin)
+            % CAPACITOR Construct an instance of this class
+                     
+            p = inputParser;
+            p.addParameter('Eps0','');
+            p.addParameter('Model', '', @(x) ischar(x));
+            p.addParameter('BlockName', '', @(x) ischar(x));
+            p.addParameter('ElectrodePair','')
+                        
+            p.parse(varargin{:});
+            
+            obj.eps0 = p.Results.Eps0;
+            obj.attachedModel = p.Results.Model;
+            obj.componentBlockName = p.Results.BlockName;
+            obj.componentBlockHandle = obj.getHandle;
+
+            obj.updateFlag = true;
+            obj.updateBlock;
+
+            obj.electrodeA = p.Results.ElectrodePair(1);
+            obj.electrodeB = p.Results.ElectrodePair(2);
+            
+        end
+        
+        function obj = set.eps0(obj, value)
+            obj.eps0 = value;
+            obj.updateBlock;
+        end
+
+        function updateBlock(obj)
+            if obj.updateFlag
+                setPlaneCapacitorBlock(obj.componentBlockHandle,...
+                    obj.eps0, obj.solver); % warning: 1DOF
+            end
+        end
+
+        function g = get.gap0(obj)
+            g = abs(obj.electrodeA.pos0 - obj.electrodeB.pos0);
+        end
+
+        function c = get.c0(obj)
+            area = min(obj.electrodeA.area,obj.electrodeB.area);
+            c    = obj.eps0 * area/obj.gap0;
+        end
+
+        function f = force(obj, V)
+            f = obj.c0 * V^2 /(2*obj.gap0);
+        end
+
+        function v = voltage_from_force(obj, f)
+            v = sqrt(f * 2* obj.gap0/obj.c0 );
+        end
+    end
+end
+

core/component/Component.m

+classdef  Component
+    properties 
+        componentBlockName char
+        componentBlockHandle double
+        attachedModel char
+        updateFlag (1,1) logical = false
+        solver string = "Variable-step"
+    end
+
+    methods 
+       
+        function hd = getHandle(obj)
+            hd = Simulink.findBlocks(obj.attachedModel,'Name',obj.componentBlockHandle);
+        end
+    end
+
+end
+

core/component/Electrode.m

+classdef Electrode < Component
+    %TESTMASS Summary of this class goes here
+    %   Detailed explanation goes here
+    
+    properties
+        sides   (1,2) double
+        attachedOppositeElectrodeBlock char
+        pos0 (1,1) double
+        V_AC
+        V_DC
+        f
+    end
+    
+    properties (Dependent)
+        area (1,1) double
+    end
+
+    methods
+        function obj = Electrode(varargin)
+        
+            p = inputParser;
+            p.addParameter('BlockName', '', @(x) ischar(x));
+            p.addParameter('Model', '', @(x) ischar(x));
+            p.addParameter('LengthSides',[0 0]);
+            p.addParameter('pos0', 0);
+            p.addParameter('V_DC', 0);
+            p.addParameter('V_AC', 0);
+            p.addParameter('f', 0);
+            p.addParameter('solver',obj.solver);
+            p.parse(varargin{:});
+            
+            blockName = p.Results.BlockName;
+            model     = p.Results.Model;
+            sides     = p.Results.LengthSides;
+            pos0      = p.Results.pos0;
+            V_DC      = p.Results.V_DC;
+            V_AC      = p.Results.V_AC;
+            f         = p.Results.f;
+            solver    = p.Results.solver;
+
+            obj.componentBlockName = blockName;
+            obj.attachedModel = model;
+            obj.componentBlockHandle = obj.getHandle;
+            obj.sides = sides;
+            obj.pos0 = pos0;
+            obj.V_AC = V_AC;
+            obj.V_DC = V_DC;
+            obj.f = f;
+            obj.solver = solver;
+            obj.updateFlag = true;
+            updateBlock(obj)
+        end
+        
+              
+        function obj = set.sides(obj, value)
+            obj.sides = value;            
+            obj.updateBlock;
+        end
+        
+        function obj = set.pos0(obj, value, varargin)
+            obj.pos0 = value;
+            obj.updateBlock;
+        end
+
+        function obj = set.V_AC(obj, value, varargin)
+            obj.V_AC = value;
+            obj.updateBlock;
+        end
+
+        function obj = set.V_DC(obj, value, varargin)
+            obj.V_DC = value;
+            obj.updateBlock;
+        end
+
+        function a = get.area(obj)
+            a = obj.sides(1) *obj.sides(2);
+        end
+
+        function updateBlock(obj)
+            if obj.updateFlag %#ok<*MCSUP> 
+                setElectrodeBlock(obj.componentBlockHandle, ...
+                         obj.area, ...
+                         obj.pos0, ...
+                         obj.V_DC,...
+                         obj.V_AC,...
+                         obj.f,...
+                         obj.solver);
+            end
+        end
+
+    end
+
+end
+

core/component/TestMass.m

-classdef TestMass
+classdef TestMass < Component
     %TESTMASS Summary of this class goes here
     %   Detailed explanation goes here
     
     properties
         mass    (1,1) double
-        gaps    (1,3) double
-        areas   (1,3) double
-        sides   (1,3) double
-        volume  (1,1) double
-        density (1,1) double
-        gap  = struct('x', 0, 'y', 0, 'z', 0);
         l    = struct('x', 0, 'y', 0, 'z', 0);
+        gap  = struct('x', 0, 'y', 0, 'z', 0);
         area = struct('x', 0, 'y', 0, 'z', 0);
-%         geometricFactor (1,1) double ...
-%                   {mustBePositive,mustBeLessThanOrEqual(geometricFactor,1)} = 1;
-        attachedDoubleIntegratorBlock char
-      %  attachedDoubleIntegratorBlocks 
-        attachedModel char
+    end
+
+    properties (Dependent)
+        volume  
+        density 
+        sides   
+        gaps    
+        areas   
     end
     
     methods
@@ -34,7 +32,6 @@ classdef TestMass
             %         - m, sizes of gaps, 1x3 double
             %    mass - kg, mass of the test mass
             %    density - kg/m3, density of the material
-            %   [geometricFactor] - ?
                         
             p = inputParser;
             p.addRequired('SideLength');
@@ -43,89 +40,128 @@ classdef TestMass
             p.addParameter('Mass',    0, @(x) isscalar(x));
             p.addParameter('Density', 0, @(x) isscalar(x));
             p.addParameter('Model', '', @(x) ischar(x));
-            p.addParameter('Block', '', @(x) ischar(x));
-            p.addParameter('Blocks', [''], @(x) (x));
-            %p.addParameter('geometricFactor', 1);
+            p.addParameter('BlockName', '', @(x) ischar(x));
+            p.addParameter('BlocksNames', [''], @(x) (x));
+            p.addParameter('Solver','')
+
             p.parse(varargin{:});
            
-            gap = p.Results.Gap;
-            mass = p.Results.Mass;
-            density = p.Results.Density;
-            sideLength = p.Results.SideLength;
-            block = p.Results.Block;
-           % blocks = p.Results.Blocks;
-            model = p.Results.Model;
-            %geometricFactor = p.Results.geometricFactor;
+            massTemp = p.Results.Mass;
+            densityTemp = p.Results.Density;
+            sideLengthTemp = p.Results.SideLength;
+            gapsTemp = p.Results.Gap;
 
-            if ~xor(mass,density)
+            if ~xor(massTemp,densityTemp)
                 error('either mass or density has to be defined')
             end
 
-%            obj.geometricFactor = geometricFactor;
+            obj.l  = TestMass.initSides(sideLengthTemp);
+            obj.gap = TestMass.initGaps(gapsTemp);
+            if massTemp == 0
+                obj.mass = obj.volume*densityTemp;
+            elseif densityTemp == 0
+                obj.mass = massTemp;
+            end
+            
+            obj.componentBlockName = p.Results.BlockName;
+            obj.attachedModel = p.Results.Model;
+            obj.componentBlockHandle = obj.getHandle;
+            obj.updateFlag = true;
+            obj.updateBlock;
+        end
+        
  
-            obj = initGeometry(obj,sideLength,gap);
-            if mass == 0
-                obj.mass = obj.volume*density;
-                obj.density = density;
-            elseif density == 0
-                obj.density = mass/obj.volume;
-                obj.mass = mass;
+        function obj = attachBlock(obj, model, block)
+            obj.attachedModel = model;
+            obj.attachedDoubleIntegratorBlock = block;
         end
 
-            if ~((model=="")||(block==""))
-                obj = attachBlock(obj,model,block);
-                obj = updateBlock(obj);
+        function obj = set.mass(obj, value)
+            obj.mass = value;
+            updateBlock(obj);
         end
 
+        function obj = set.l(obj, value)
+             obj.l = value;
+             updateBlock(obj);
         end
 
-        function obj = initGeometry(obj, sideLength,gap)
-            if length(sideLength) == 3
-                obj.l.x = sideLength(1);
-                obj.l.y = sideLength(2);
-                obj.l.z = sideLength(3);
-            else
-                obj.l.x = sideLength;
-                obj.l.y = sideLength;
-                obj.l.z = sideLength;
+        function obj = set.density(obj, value)
+            obj.mass = value*obj.volume;
+            updateBlock(obj);
         end
 
-            if length(gap) == 3
-                obj.gap.x = gap(1);
-                obj.gap.y = gap(2);
-                obj.gap.z = gap(3);
-            else
-                obj.gap.x = gap;
-                obj.gap.y = gap;
-                obj.gap.z = gap;
+        function v = get.volume(obj)
+              x = obj.l.x;
+              y = obj.l.y;
+              z = obj.l.z;
+              v = x*y*z;
         end
-            obj.area.x = obj.l.y * obj.l.z;
-            obj.area.y = obj.l.x * obj.l.z;
-            obj.area.z = obj.l.x * obj.l.y;
-            obj.volume = obj.l.x * obj.l.y * obj.l.z;
 
-            obj.gaps  = [obj.gap.x  obj.gap.y  obj.gap.z ];
-            obj.sides = [obj.l.x    obj.l.y    obj.l.z   ];
-            obj.areas = [obj.area.x obj.area.y obj.area.z];
+        function d = get.density(obj)
+            d = obj.mass/obj.volume;
+        end
 
+        function s = get.sides(obj)
+            s = [obj.l.x obj.l.y obj.l.z];
         end
 
-        function obj = attachBlock(obj, model, block)
-            obj.attachedModel = model;
-            obj.attachedDoubleIntegratorBlock = block;
+        function g = get.gaps(obj)
+            g = [obj.gap.x obj.gap.y obj.gap.z];
+        end
+
+        function a = get.areas(obj)
+            a = [obj.area.x obj.area.y obj.area.z];
         end
 
         function updateBlock(obj)
-            setDblIntTrans(obj.attachedModel, ...
-                obj.attachedDoubleIntegratorBlock, ...
+            if obj.updateFlag
+            setDblIntBlock(obj.componentBlockHandle,...
                            obj.mass,obj.gap.x); % warning: 1DOF
             end
+        end
 
-        function obj = setDoubleIntegrator(obj,mdl,name,varargin)
-            %METHOD1 Summary of this method goes here
-            %   Detailed explanation goes here
-            obj.doubleIntegratorBlock = setDblIntTrans(mdl,name,obj.mass,obj.gap.x);
+        
+%         function obj = setDoubleIntegrator(obj,mdl,name,varargin)
+%             %METHOD1 Summary of this method goes here
+%             %   Detailed explanation goes here
+%             obj.doubleIntegratorBlock = setDblIntTrans(mdl,name,obj.mass,obj.gap.x);
+%         end
+    end
+
+    methods (Static)
+     function l = initSides(sideLengthTemp)
+            if length(sideLengthTemp) == 3
+                l.x = sideLengthTemp(1);
+                l.y = sideLengthTemp(2);
+                l.z = sideLengthTemp(3);
+            else
+                l.x = sideLengthTemp;
+                l.y = sideLengthTemp;
+                l.z = sideLengthTemp;
+            end
+            sides = [l.x l.y l.z];
      end
+
+     function gap = initGaps(gapTemp)
+            if length(gapTemp) == 3
+                gap.x = gapTemp(1);
+                gap.y = gapTemp(2);
+                gap.z = gapTemp(3);
+            else
+                gap.x = gapTemp;
+                gap.y = gapTemp;
+                gap.z = gapTemp;
+            end
+        end
+
+        function area = initAreas(l)
+            area.x = l.y * l.z;
+            area.y = l.x * l.z;
+            area.z = l.x * l.y;
+        end    
+        
+      
     end
 end
 

core/component/setElectrodeBlock.m

+function blockHandle = setElectrodeBlock(blockHandle, area, pos0, V_DC, V_AC, f, solver)
+% 
+% SETELECTRODE - Sets the initial parameters of a electrode
+% Sets the initial parameters of a electrode, to be paired to form a parallel 
+% plates capacitor. 
+%
+% Syntax: blockHandle = setElectrode(model, block, area, pos0, V_DC, V_AC, f, solver)
+%
+% Inputs:
+%    model - Name of the Simulink model, string;
+%    block - Name of the target instance of the Injection Block, string;
+%    area  - area of the plate, m^s
+%    pos0  - initial/nominal position of the center of the plate, m. 
+%    V_DC  - Offset DC voltage, V;
+%    V_AC  - AC voltage, V (rms), optional;
+%    f     - frequency of the AC voltage, Hz;
+%    solver- type of solver the model will use, parameter;
+%
+% Output:
+%    blockHandle - Simulink block instance handle reference number;
+%
+% See also: 
+%
+% Author: Arthur Reis
+% email: arthur.reis@aei.mpg.de
+% Last revision: 27.Sep.2022;
+
+defaultSolver = "Variable-step";
+%defaultVAC = 0;
+%defaultf = 1;
+
+%p = inputParser;
+
+%addRequired(p, 'model');
+%addRequired(p, 'block');
+%addRequired(p, 'area', @(x) isnumeric(x) && isscalar(x));
+%addRequired(p, 'pos0', @(x) isnumeric(x) && isscalar(x));
+%addRequired(p, 'V_DC', @(x) isnumeric(x) && isscalar(x));
+%addOptional(p, 'V_AC', defaultVAC);
+%addOptional(p, 'f',    defaultf);
+%addParameter(p, "solver", defaultSolver);
+
+%parse(p, varargin{:});            
+
+%blockHandle = Simulink.findBlocks(model,'Name',block);
+set_param(blockHandle,'area',  num2str(area));
+set_param(blockHandle,'pos0',  num2str(pos0));
+set_param(blockHandle,'V_DC0', num2str(V_DC));
+set_param(blockHandle,'V_AC0', num2str(V_AC));
+set_param(blockHandle,'f0',    num2str(f));
+%
+if strcmp(solver,defaultSolver)
+    load_system("electrode");
+    set_param("electrode","SolverType","Variable-step");
+elseif strcmp(solver,'Fixed-step')
+    load_system("electrode");
+    set_param("electrode","SolverType", "Fixed-step")
+end
+end
\ No newline at end of file

core/component/setIfo.m

+
+function blockHandle = setIfo(varargin)
+% SETPLANECAPACITOR - Sets the initial parameters of a capacitor.
+% Sets the initial parameters of a capacitor. Based on a parallel planes capacitor.  
+%
+% Syntax: blockHandle = setPlaneCapacitor(model, block, eps)
+%                           
+% Inputs:
+%    model - Name of the Simulink model, string;
+%    block - Name of the target instance of the Injection Block, string;
+%    eps   - Medium permittivity, F/m, double;
+%    
+% Outputs:
+%    blockHandle - Simulink block instance handle reference number;
+% See also: 
+%
+% References:
+%    Heinzel et al 2003 Class. Quantum Grav. 20 S153
+%    Armano 2022 Phys Rev D
+% Author: Arthur Reis
+% email: arthur.reis@aei.mpg.de
+% Apr 2022; Last revision: 7.Apr.2022;
+defaultEps0 = 8.8541878128e-12;
+defaultSolver = "Variable-step";
+
+p = inputParser;
+addRequired(p, 'model');
+addRequired(p, 'block');
+addOptional(p, 'eps0', defaultEps0, @(x)  isnumeric(x) && isscalar(x));
+addParameter(p, "solver", defaultSolver);
+
+parse(p, varargin{:});   
+
+blockHandle = Simulink.findBlocks(p.Results.model,'Name',p.Results.block);
+set_param(blockHandle,'eps0', num2str(p.Results.eps0));
+
+if strcmp(p.Results.solver,defaultSolver)
+    load_system("planeCapacitor");
+    set_param("planeCapacitor",'SolverType','Variable-step');
+elseif strcmp(p.Results.solver,"Fixed-step")
+    load_system("planeCapacitor");
+    set_param("planeCapacitor", 'SolverType', 'Fixed-step')
+end
+end

core/component/setPlaneCapacitorBlock.m

+function blockHandle = setPlaneCapacitorBlock(blockHandle, eps0, solver)
+% SETPLANECAPACITOR - Sets the initial parameters of a capacitor.
+% Sets the initial parameters of a capacitor. Based on a parallel planes capacitor.  
+%
+% Syntax: blockHandle = setPlaneCapacitor(model, block, eps)
+%                           
+% Inputs:
+%    model - Name of the Simulink model, string;
+%    block - Name of the target instance of the Injection Block, string;
+%    eps   - Medium permittivity, F/m, double;
+%    
+% Outputs:
+%    blockHandle - Simulink block instance handle reference number;
+% See also: 
+%
+% Author: Arthur Reis
+% email: arthur.reis@aei.mpg.de
+% Apr 2022; Last revision: 7.Apr.2022;
+%defaultEps0 = 8.8541878128e-12;
+
+
+set_param(blockHandle,'eps0', num2str(eps0));
+
+if strcmp(solver,'Variable-step')
+    load_system("planeCapacitor");
+    set_param("planeCapacitor",'SolverType','Variable-step');
+elseif strcmp(solver,"Fixed-step")
+    load_system("planeCapacitor");
+    set_param("planeCapacitor", 'SolverType', 'Fixed-step')
+end
+end
\ No newline at end of file

core/dynamics/setDblIntBlock.m

+function blockHandle = setDblIntBlock(blockHandle, varargin)
+%SETDOUBLEINTEGRATOR - Sets the initial parameters of a double interator block. 
+%Sets the initial parameters for one instance of the double integrator SISO, 
+%linear or rotational, block from Acme library. 
+%
+% Syntax: setDoubleIntegrator(model, block, transformation, m, varargin)
+%
+% Inputs:
+%    model - Name of the Simulink model, string
+%    block - Name of the target instance of the Double Integrator Block, string
+%    varargin - m - mass, kg
+%       initial position
+%             - dq0, initial velocity
+%     
+% See also: 
+%
+% Author: Arthur Reis
+% email: arthur.reis@aei.mpg.de
+% Nov 2021; Last revision: 10.Nov.2021;
+
+
+defaultq0  = 0;
+defaultdq0 = 0;
+
+p = inputParser;
+
+addRequired(p, 'm',   @(x) (x > 0) && isnumeric(x) && isscalar(x));
+addRequired(p, 'gap', @(x) (x > 0) && isnumeric(x) && isscalar(x));
+addOptional(p, 'q0',  defaultq0,  @(x) isnumeric(x) && isscalar(x));
+addOptional(p, 'dq0', defaultdq0, @(x) isnumeric(x) && isscalar(x));
+%addParameter(p, 'solver', defaultsolver)
+%addOptional(p, 'dt',  defaultdt,  @(x) isnumeric(x) && isscalar(x));
+parse(p, varargin{:});            
+        
+set_param(blockHandle,'m',  num2str(p.Results.m));
+set_param(blockHandle,'gap',  num2str(p.Results.gap));
+set_param(blockHandle,'q0', num2str(p.Results.q0));
+set_param(blockHandle,'dq0',num2str(p.Results.dq0));
+
+end
+

core/noises/actuationNoise.m

+function [outputArg1,outputArg2] = actuationNoise([f_ng, a_ng],TM)
+%ACTUATIONNOISE Summary of this function goes here
+%   Detailed explanation goes here
+outputArg1 = inputArg1;
+outputArg2 = inputArg2;
+end
+

core/noises/actuationRequirement.m

+function [acc, volt_required] = actuationRequirement(f_ng, a_ng, TM, cap)
+%ACTUATIONREQUIREMENT Calculates required actuation voltage to keep test mass
+% stable
+%   Detailed explanation goes here
+% Input:
+%    [f_ng, a_ng] - ASD (frequencies and amplitudes) of the non gravitational
+%    forces that impact the satellite
+% Output:
+%
+
+%psd = a_ng.^2;
+%loglog(fxx_input_forces, psd)
+acc = sqrt(trapz(f_ng,a_ng.^2)); %mean? acceleration m/s2
+forces_ng = acc*TM.mass;
+volt_required = cap.voltage_from_force(forces_ng);
+end
+