Merge pull request #781 from KratosMultiphysics/feature/increase-logs

Feature/increase logs

Author: jginternational

kratos.gid/apps/FSI/examples/examples.tcl

@@ -8,15 +8,4 @@ proc FSI::examples::Init { } {
     uplevel #0 [list source [file join $::FSI::dir examples HighRiseBuilding.tcl]]
 }
 
-proc FSI::examples::UpdateMenus { } {
-    set menu_id 7
-    GiDMenu::InsertOption "Kratos" [list "Mok - Channel with flexible wall" ] [incr menu_id] PRE [list ::FSI::examples::MokChannelFlexibleWall] "" "" insertbefore =
-    if {$::Model::SpatialDimension eq "2D"} {
-        GiDMenu::InsertOption "Kratos" [list "Turek benchmark" ] [incr menu_id] PRE [list ::FSI::examples::TurekBenchmark] "" "" insertbefore =
-        GiDMenu::InsertOption "Kratos" [list "High-rise building" ] [incr menu_id] PRE [list ::FSI::examples::HighRiseBuilding] "" "" insertbefore =
-    }
-    GiDMenu::InsertOption "Kratos" [list "---"] [incr menu_id] PRE "" "" "" insertbefore =
-    GiDMenu::UpdateMenus
-}
-
 FSI::examples::Init

kratos.gid/apps/FSI/start.tcl

@@ -45,10 +45,6 @@ proc ::FSI::LoadMyFiles { } {
     uplevel #0 [list source [file join $FSI::dir examples examples.tcl]]
 }
 
-proc ::FSI::CustomMenus { } {
-    FSI::examples::UpdateMenus
-}
-
 proc ::FSI::GetAttribute {name} {
     variable attributes
     set value ""

kratos.gid/kratos.tcl

@@ -8,6 +8,8 @@ namespace eval Kratos {
 
     variable must_write_calc_data
     variable must_exist_calc_data
+
+    variable tmp_init_mesh_time
 }
 
 # Hard minimum GiD Version is 14
@@ -80,6 +82,7 @@ proc Kratos::RegisterGiDEvents { } {
 
     # Preferences window
     GiD_RegisterPluginPreferencesProc Kratos::Event_ModifyPreferencesWindow
+    CreateWidgetsFromXml::ClearCachePreferences
 }
 
 proc Kratos::Event_InitProblemtype { dir } {
@@ -140,6 +143,14 @@ proc Kratos::InitGlobalVariables {dir} {
     set kratos_private(echo_level) 0
     # indent in mdpa files  | 0 ASCII unindented | 1 ASCII indented pretty
     set kratos_private(mdpa_format) 1
+    # Version of the kratos executable
+    set kratos_private(exec_version) "dev"
+    # Allow logs -> 0 No | 1 Only local | 2 Share with dev team
+    set Kratos::kratos_private(allow_logs) 1
+    # git hash of the problemtype
+    set Kratos::kratos_private(problemtype_git_hash) 0    
+    # Place were the logs will be placed
+    set Kratos::kratos_private(model_log_folder) ""
 
     # Variable to store the Kratos menu items
     set kratos_private(MenuItems) [dict create]
@@ -190,6 +201,10 @@ proc Kratos::LoadCommonScripts { } {
 }
 
 proc Kratos::Event_LoadModelSPD { filespd } {
+    after 1 [list Kratos::LoadModelSPD $filespd]
+}
+
+proc Kratos::LoadModelSPD { filespd } {
     variable kratos_private
 
     # Event called if a model exists, so close all the windows while tree isn't loaded
@@ -214,6 +229,8 @@ proc Kratos::Event_LoadModelSPD { filespd } {
     set old_doc [gid_groups_conds::open_XML_file_gzip $filespd]
     set old_root [$old_doc documentElement]
     set old_versionData [$old_root @version]
+    set version_data [dict create model_version $old_versionData ]
+    Kratos::Log "Load model -> [write::tcl2json $version_data]"
 
     # Compare the version number
     if { [package vcompare $versionPT $old_versionData] != 0 } {
@@ -244,15 +261,23 @@ proc Kratos::Event_LoadModelSPD { filespd } {
 
         # Open the tree
         spdAux::OpenTree
+
+        after 500 {set ::Kratos::kratos_private(model_log_folder) [file join [GiD_Info Project ModelName].gid Logs]}
     }
+
 }
 
 proc Kratos::Event_EndProblemtype { } {
+    Kratos::Log "End session"
     # New event system need an unregister
     if {[GidUtils::VersionCmp "14.1.4d"] >= 0 } {
         GiD_UnRegisterEvents PROBLEMTYPE Kratos
+        GiD_UnRegisterPluginPreferencesProc Kratos::Event_ModifyPreferencesWindow
     }
     if {[array exists ::Kratos::kratos_private]} {
+        # Close the log and moves them to the folder
+        Kratos::FlushLog 
+
         # Restore GiD variables that were modified by kratos and must be restored (maybe mesher)
         Kratos::RestoreVariables
 
@@ -359,8 +384,10 @@ proc Kratos::TransformProblemtype {old_dom old_filespd} {
 
 proc Kratos::Event_BeforeMeshGeneration {elementsize} {
     # Prepare things before meshing
-
-
+    variable tmp_init_mesh_time
+    set inittime [clock seconds]
+    set tmp_init_mesh_time $inittime
+    Kratos::Log "Mesh BeforeMeshGeneration start"
     GiD_Process Mescape Meshing MeshCriteria NoMesh Lines 1:end escape escape escape
     GiD_Process Mescape Meshing MeshCriteria NoMesh Surfaces 1:end escape escape escape
     GiD_Process Mescape Meshing MeshCriteria NoMesh Volumes 1:end escape escape escape
@@ -373,6 +400,9 @@ proc Kratos::Event_BeforeMeshGeneration {elementsize} {
     }
     # Maybe the current application needs to do some extra job
     set ret [apps::ExecuteOnCurrentApp BeforeMeshGeneration $elementsize]
+    set endtime [clock seconds]
+    set ttime [expr {$endtime-$inittime}]
+    Kratos::Log "Mesh BeforeMeshGeneration end in [Duration $ttime]"
     return $ret
 }
 
@@ -382,8 +412,14 @@ proc Kratos::Event_MeshProgress { total_percent partial_percents_0 partial_perce
 }
 
 proc Kratos::Event_AfterMeshGeneration {fail} {
+    variable tmp_init_mesh_time
     # Maybe the current application needs to do some extra job
     apps::ExecuteOnCurrentApp AfterMeshGeneration $fail
+    set endtime [clock seconds]
+    set ttime [expr {$endtime-$tmp_init_mesh_time}]
+    Kratos::Log "Mesh end process in [Duration $ttime]"
+    set mesh_data [Kratos::GetMeshBasicData]
+    Kratos::Log "Mesh data -> [write::tcl2json $mesh_data]"
 }
 
 proc Kratos::Event_AfterRenameGroup { oldname newname } {
@@ -484,8 +520,14 @@ proc Kratos::Event_SaveModelSPD { filespd } {
 
     # Let the current app implement it's Save event
     apps::ExecuteOnCurrentApp AfterSaveModel $filespd
+
+    # Log it
+    set Kratos::kratos_private(model_log_folder) [file join [GiD_Info Project ModelName].gid Logs]
+    Kratos::Log "Save model [file tail $filespd ]"
+
 }
 
+
 proc Kratos::Event_ChangedLanguage  { newlan } {
     Kratos::UpdateMenus
 }

kratos.gid/scripts/Controllers/Preferences.xml

@@ -8,6 +8,11 @@
             <option value='0' label='Optimized'/>
             <option value='1' label='Readable'/>
         </combobox>
+        <combobox name='allow_logs' variable='allow_logs' variablemanager='Kratos::ManagePreferences' label='Store logs' help=''>
+            <option value='0' label='No'/>
+            <option value='1' label='Only local, so I will get better support from the developers.'/>
+            <option value='2' label='Share anonymous usage data. (See kratos > View current log) Coming soon :)'/>
+        </combobox>
         <combobox name='echo_level' variable='echo_level' variablemanager='Kratos::ManagePreferences' label='Echo level' help='Show more/less message'>
             <option value='0' label='0'/>
             <option value='1' label='1'/>

kratos.gid/scripts/Controllers/PreferencesWindow.tcl

@@ -11,6 +11,7 @@ proc Kratos::ManagePreferences { cmd name {value ""}} {
         }
         "SetValue" {
             set ::Kratos::kratos_private($name) $value
+            if {$name eq "allow_logs"} {Kratos::InitLog}
         }
         "GetDefaultValue" {
             # same as GetValue
@@ -21,6 +22,9 @@ proc Kratos::ManagePreferences { cmd name {value ""}} {
                 "echo_level" {
                     set ret 0
                 }
+                "allow_logs" {
+                    set ret 1
+                }
                 "mdpa_format" {
                     set ret 1
                 }
@@ -38,7 +42,6 @@ proc Kratos::ModifyPreferencesWindow { root } {
 
     if {[info exists kratos_private(Path)]} {
         set findnode [$root find "name" "general"]      
-        
         if { $findnode != "" } {
             set xml_preferences_filename [file join $kratos_private(Path) scripts Controllers Preferences.xml]
             set xml_data [GidUtils::ReadFile $xml_preferences_filename] 

kratos.gid/scripts/Logs.tcl

@@ -18,31 +18,42 @@ proc Kratos::GetLogFilePath { } {
 
 proc Kratos::InitLog { } {
     variable kratos_private
-    set kratos_private(LogFilename) [clock format [clock seconds] -format "%Y%m%d%H%M%S"].log 
-    set logpath [Kratos::GetLogFilePath]
-    file mkdir [file dirname $logpath]
-    set logfile [open $logpath "a+"];
-    puts $logfile "Kratos Log Session"
-    close $logfile
-    set kratos_private(Log) [list ]
+    
+    if {[info exists Kratos::kratos_private(allow_logs)] && $Kratos::kratos_private(allow_logs)>0} {
+
+        set kratos_private(LogFilename) [clock format [clock seconds] -format "%Y%m%d%H%M%S"].log 
+        set logpath [Kratos::GetLogFilePath]
+        file mkdir [file dirname $logpath]
+        set logfile [open $logpath "a+"];
+        puts $logfile "Kratos Log Session"
+        close $logfile
+        set kratos_private(Log) [list ]
+        
+        Kratos::AutoFlush
+    }
 }
 
 proc Kratos::Log {msg} {
     variable kratos_private
+
+    if {[info exists kratos_private(Log)] &&  $Kratos::kratos_private(allow_logs) > 0} {
 
-    if {[info exists kratos_private(Log)]} {
-        lappend kratos_private(Log) "*~* [clock format [clock seconds] -format {%Y-%m-%d %H:%M:%S}] | $msg"
+        if {[info exists kratos_private(Log)]} {
+            lappend kratos_private(Log) "*~* [clock format [clock seconds] -format {%Z %Y-%m-%d %H:%M:%S }] | $msg"
 
-        # One of the triggers is to flush if we've stored more than 5 
-        if {[llength $kratos_private(Log)] > 5} {
-            Kratos::FlushLog
+            # One of the triggers is to flush if we've stored more than 5 
+            if {[llength $kratos_private(Log)] > 5} {
+                Kratos::FlushLog
+            }
         }
     }
 }
 
 proc Kratos::FlushLog { }  {
     variable kratos_private
+    
     if {[info exists kratos_private(Log)]} {
+        # only disturb the disk if we have something new to write
         if {[llength $kratos_private(Log)] > 0} {
             set logpath [Kratos::GetLogFilePath]
 
@@ -58,15 +69,38 @@ proc Kratos::FlushLog { }  {
             }
 
             set kratos_private(Log) [list ]
+            # Move it to the model, so the user can see and store to get support
+            # Keep the original to keep centralized data to send to the servers
+            if {$Kratos::kratos_private(model_log_folder) ne ""} {
+                Kratos::MoveLogsToFolder $Kratos::kratos_private(model_log_folder) 0
+            }
         }
     }
-    after 5000 {Kratos::FlushLog}
 
 }
 
+proc Kratos::AutoFlush {} {
+    if {[info exists Kratos::kratos_private(allow_logs)] && $Kratos::kratos_private(allow_logs)>0} {
+        after 5000 {Kratos::AutoFlush}
+    }
+}
+
+proc Kratos::ViewLog {} {
+    package require gid_cross_platform
+    FlushLog
+    gid_cross_platform::open_by_extension [Kratos::GetLogFilePath]
+}
+
 #do not save preferences starting with flag gid.exe -c (that specify read only an alternative file)
 if { [GiD_Set SaveGidDefaults] } {
     Kratos::InitLog
-    Kratos::FlushLog
 }
 
+proc Kratos::MoveLogsToFolder {folder {flush_log 1}} {
+    
+    if {[info exists Kratos::kratos_private(allow_logs)] && $Kratos::kratos_private(allow_logs)>0} {
+        if {$flush_log} {FlushLog}
+        if {![file exists $folder]} {file mkdir $folder}
+        file copy -force [Kratos::GetLogFilePath] $folder
+    }
+}

kratos.gid/scripts/Menus.tcl

@@ -134,8 +134,9 @@ proc Kratos::ChangeMenus { } {
     GiDMenu::InsertOption "Kratos" [list "---"] [incr pos] PRE "" "" "" replace =
     GiDMenu::InsertOption "Kratos" [list "Import MDPA"] [incr pos] PRE [list Kratos::ReadPreW] "" "" replace =
     GiDMenu::InsertOption "Kratos" [list "---"] [incr pos] PRE "" "" "" replace =
-    if {[GidUtils::VersionCmp "14.1.4d"] <0 } { set cmd  [list ChangeVariables kratos_preferences] } {set cmd  [list PreferencesWindow kratos_preferences]}
+    if {[GidUtils::VersionCmp "14.1.4d"] <0 } { set cmd  [list ChangeVariables kratos_preferences] } {set cmd [list PreferencesWindow kratos_preferences]}
     GiDMenu::InsertOption "Kratos" [list "Kratos preferences" ] [incr pos] PRE $cmd "" "" replace =
+    GiDMenu::InsertOption "Kratos" [list "View current log" ] [incr pos] PREPOST [list Kratos::ViewLog] "" "" replace =
     GiDMenu::InsertOption "Kratos" [list "About Kratos" ] [incr pos] PREPOST [list Kratos::About] "" "" replace =
     GidChangeDataLabel "Data units" ""
     GidChangeDataLabel "Interval" ""

kratos.gid/scripts/Utils.tcl

@@ -190,9 +190,81 @@ proc Kratos::LoadEnvironment { } {
 # LOGS
 
 proc Kratos::LogInitialData { } {
+    
+    # Get the exec version
+    Kratos::GetExecVersion
+    Kratos::GetProblemtypeGitTag 
+
     set initial_data [dict create]
-    dict set initial_data GiD_Version [GiD_Info gidversion]
-    dict set initial_data Problemtype_Git_Hash "68418871cff2b897f7fb9176827871b339fe5f91"
+    dict set initial_data gid_version [GiD_Info gidversion]
+    dict set initial_data problemtype_git_hash $Kratos::kratos_private(problemtype_git_hash)
+    dict set initial_data problemtype_version $Kratos::kratos_private(Version)
+    dict set initial_data executable_version $Kratos::kratos_private(exec_version)
+    dict set initial_data current_platform $::tcl_platform(platform)
 
     Kratos::Log [write::tcl2json $initial_data]
+}
+
+
+proc Kratos::Duration { int_time } {
+    if {$int_time == 0} {return "0 sec"}
+    set timeList [list]
+    foreach div {86400 3600 60 1} mod {0 24 60 60} name {day hr min sec} {
+        set n [expr {$int_time / $div}]
+        if {$mod > 0} {set n [expr {$n % $mod}]}
+        if {$n > 1} {
+            lappend timeList "$n ${name}s"
+        } elseif {$n == 1} {
+            lappend timeList "$n $name"
+        }
+    }
+    return [join $timeList]
+}
+
+
+proc Kratos::GetExecVersion {} {
+    catch {
+        variable kratos_private
+        set tmp_filename [GidUtils::GetTmpFilename]
+        if { $::tcl_platform(platform) == "unix"} {set command [file join $kratos_private(Path) exec Kratos runkratos]} {set command [file join $kratos_private(Path) exec Kratos runkratos.exe]}
+        set result [exec $command -c "import KratosMultiphysics as Kratos" >> $tmp_filename]
+        set fp [open $tmp_filename r]
+        set file_data [read $fp]
+        close $fp
+        file delete $tmp_filename
+        set data [split $file_data "\n"]
+        foreach line $data {
+            if {[string first "Multi-Physics" $line] > 0} {
+                set kratos_private(exec_version) [string range [string trim $line] 14 end]
+                break;
+            }
+        }
+    }
+}
+proc Kratos::GetProblemtypeGitTag {} {
+    catch {
+        variable kratos_private
+        set tmp_filename [GidUtils::GetTmpFilename]
+        set result [exec git -C $kratos_private(Path) log --format="%H" -n 1 >> $tmp_filename]
+        set fp [open $tmp_filename r]
+        set file_data [read $fp]
+        close $fp
+        file delete $tmp_filename
+        set data [split $file_data "\n"]
+        set kratos_private(problemtype_git_hash) [string trim [string trim [lindex $data 0]] "\""]
+    }
+}
+
+proc Kratos::GetMeshBasicData { } {
+    set result [dict create]
+    foreach element_type [GidUtils::GetElementTypes all] {
+        set ne [GiD_Info Mesh NumElements $element_type]       
+        if { $ne } {
+            dict set result $element_type $ne
+        }
+    }
+    
+    dict set result nodes [GiD_Info Mesh NumNodes] 
+    dict set result is_quadratic [expr [GiD_Info Project Quadratic] && ![GiD_Cartesian get iscartesian] ]
+    return $result   
 }