DynLinTimoshenkoModel.m

Go to the documentation of this file.

namespace models{
namespace beam{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class DynLinTimoshenkoModel
  :public models.BaseFullModel {
    public: /* ( Constant ) */

        static const withHeat = false;
    public: /* ( setObservable ) */

        double PlotFactor = 20;
        double BeamLineWidth = 3;
        integer NumColors = 128;
    public: /* ( Dependent, setObservable ) */

        BeamRefinementFactor;


        CurvedBeamRefinementFactor;

        
    public:

        matrix Points;
        struct Elements;
        logical NonlinearModel = false;
        Supports;


        Loads;


        Materials;


        char ConfigFile;
        data;


        f_neum;
        dir_u;

        dir_T;


        free;
        u_dir;
    public: /* ( Dependent ) */

        matrix ColorMap;
    public:

        maxTemp = 0;
        minTemp = 0;
        cbh;
        RO_raw;


        KR_raw;


        FH_raw;


        RO_factor_global = 1;


        KR_factor_global = 1;

        
    public:

        DynLinTimoshenkoModel(char cfgfile,logical nonlinear) {
            this = this@models.BaseFullModel;

            if nargin < 2
                this.NonlinearModel= false;
                if nargin < 1
                    /* error('no config file given'); */
                    cfgfile = " Simpel1.txt ";
                    fprintf(" No config file specified, using  "" %s "" \n ",cfgfile);
                end
            else
                this.NonlinearModel= nonlinear;
            end
            this.Name= " DynLin Timoschenko Beam ";

            /* % Load geometry from config file */
            path = fileparts(mfilename(" fullpath "));
            this.ConfigFile= fullfile(path,cfgfile);
            [this.Points, this.RO_raw, this.KR_raw, this.FH_raw, raw_mat, this.Supports, this.Loads] = this.read_file(this.ConfigFile);

            this.Materials= models.beam.Material.empty;
            for midx = 1:size(raw_mat,1)
                this.Materials(midx) = models.beam.Material(raw_mat(midx,:));
            end

            this.split_RO;
            this.split_KR;
            /*  Important: call before creating the system! */
            this.preprocess_data;

            /* % Model specifics */
            this.T= 5;
            this.dt= .05;
            this.Data.useFileTrajectoryData;

            /* % Internal setup */
            this.System= models.beam.DynLinTimoshenkoSystem(this);

            /*  Subspace reduction */
            s = spacereduction.PODGreedy;
            s.Eps= 1e-7;
            this.SpaceReducer= s;

            /*  No approximation - core fun is linear */
            this.Approx= [];

            /*  No Parameters */
            this.Sampler= sampling.GridSampler;
            /* this.Sampler.Samples = 20; */

            /* % ODE solver setup */
            o = solvers.MLode15i;
/*              o = solvers.MLWrapper(@ode15i); */
            o.MaxStep= this.dt;
            this.ODESolver= o;

            /*  Train with all inputs */
            this.TrainingInputs= 1:this.System.InputCount;

            /*  Setup JKerMor export */
            je = JKerMorExport;
            je.JavaExportPackage= " models.beam.dynlintimo ";
            je.Short= this.Name;
            je.GeometryExportCallback= @this.exportGeometry;
            je.JaRMoSBaseSource= " C:\Users\CreaByte\Documents\Uni\Software\JaRMoSBase\src ";
            this.JKerMorExport= je;
        }
#if 0 //mtoc++: 'get.ColorMap'
function m = ColorMap() {
            dc = [0:3/this.NumColors:1]^t;
            m = [0*dc dc 1-dc; dc 0*dc+1 0*dc; 0*dc+1 1-dc 0*dc];
        }

#endif

        function  exportGeometry(handle f,char folder,export.JaRMoSExport export) {

            fprintf(f," \t<dimension>3</dimension>\n ");
            fprintf(f," \t<nodes>%d</nodes>\n ",size(this.Points,1));
/*              fprintf(f,'\t<fieldmapping>VERTEX</fieldmapping>\n'); */
            fprintf(f," \t<hasFaces>false</hasFaces>\n ");

            /* % Nodes (including dirichlet points) */
            usedpts = [];
            for i=1:length(this.Elements)
                el = this.Elements[i];
                usedpts = [usedpts el.PointsIdx];/* #ok */

            end
            usedpts = unique(usedpts);

            vert = single(reshape(this.Points(usedpts,:)^t,1,[]));
            export.saveRealVector(vert, " vertices.bin ", folder);

            /*  Dirichlet nodes */
            fprintf(f," \t<hasDirichletNodes>true</hasDirichletNodes>\n ");
            export.saveRealVector(int16(this.dir_u), " dir_nodes.bin ", folder);
            export.saveRealVector(this.u_dir, " dir_values.bin ", folder);

            n = length(this.Elements);
            edges = int16(2*n);
            for i=1:n
                edges((2*i-1):(2*i)) = this.Elements[i].PointsIdx;
            end
            export.saveRealVector(edges, " edges.bin ", folder);
        }
        function  plot(rowvec t,matrix u);

        function  plotSingle(double t,colvec u,handle h);
    
        /* % Getter & Setters */
    public:

        
#if 0 //mtoc++: 'set.BeamRefinementFactor'
function  BeamRefinementFactor(value) {
            [this.Points, this.RO_raw, this.KR_raw] = this.read_file(this.ConfigFile);
            if value ~= this.RO_factor_global
                this.ModelData.SimCache.clearTrajectories;
            end
            this.RO_factor_global= value;
            this.split_RO;
            this.split_KR;
            /*  Update model */
            this.preprocess_data;
            /*  Update system */
            this.System.buildElementDependentComponents;
            /*  Update core function */
            this.System.f.initialize;
        }

#endif


        
#if 0 //mtoc++: 'get.BeamRefinementFactor'
function value = BeamRefinementFactor() {
            value = this.RO_factor_global;
        }

#endif


        
#if 0 //mtoc++: 'set.CurvedBeamRefinementFactor'
function  CurvedBeamRefinementFactor(value) {
            [this.Points, this.RO_raw, this.KR_raw] = this.read_file(this.ConfigFile);
            if value ~= this.KR_factor_global
                this.ModelData.SimCache.clearTrajectories;
            end
            this.KR_factor_global= value;
            this.split_RO;
            this.split_KR;
            /*  Update model */
            this.preprocess_data;
            /*  Update system */
            this.System.buildElementDependentComponents;
            /*  Update core function */
            this.System.f.initialize;
        }

#endif


        
#if 0 //mtoc++: 'get.CurvedBeamRefinementFactor'
function value = CurvedBeamRefinementFactor() {
            value = this.KR_factor_global;
        }

#endif

    
    private:

        function [Points , RO_raw , KR , FH , mat , lager , lasten ] = read_file(file);

        function [data , RO , KR , FH , p ] = preprocess_data(RO_raw,KR_raw,FH_raw,c,supports,loads,gravity,RO_factor_global,KR_factor_global);

        function  split_RO();

        function  split_KR();
    
    public: /* ( Static ) */

        static function  experiment1() {
            m = models.beam.DynLinTimoshenkoModel(" Rohrleitungen z.txt ");
            m.BeamRefinementFactor= 5;
            m.TrainingInputs= 1:m.System.InputCount;
            m.T= 10;
            m.dt= .1;
            m.System.Params(1).Range = [0 2];
            m.System.Params(1).Desired = 10;
            m.System.Params(2).Range = [0 .1];
            m.System.Params(2).Desired = 10;
            m.System.Params(3).Range = 20*[-1 1];
            m.System.Params(3).Desired = 10;
            m.offlineGenerations;
            r = m.buildReducedModel;
            save experiment1 m r;
        }


        static function  test_TimoshenkoModel() {
            m = models.beam.DynLinTimoshenkoModel;
            run(m);
            /*  Nonlinear */
            m = models.beam.DynLinTimoshenkoModel(" Simpel1.txt ",true);
            run(m);

            function run(m)
                for np = 1:4
                    mu = m.getRandomParam;
                    for in = 1:m.System.InputCount
                        fprintf(" Running with input %d, mu=%s\n ",in,num2str(mu));
                        [t,y] = m.simulate(mu,in);
                    end
                end
            end
        }
};
}
}