Import Geant4 11.1.0 source tree

examples/extended/parallel/MPI/History

@@ -4,6 +4,12 @@ See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
 which **must** added in reverse chronological order (newest at the top). It must **not**
 be used as a substitute for writing good git commit messages!
 
+## 2022-11-09 I. Hrivnacova (MPI-V11-00-03)
+- Updated analysis classes for changes in analysis
+  in analysis-V11-00-*
+- Fixed exMPI04 example failing in sequential mode when
+  MPI ntuple merging is activated   
+
 ## 2022-05-18 Guy Barrand (MPI-V11-00-02)
 - have "toolx" namespace for g4tools code related to MPI, then:
   - namespace tools::mpi becomes toolx::mpi.

examples/extended/parallel/MPI/README.md

@@ -241,13 +241,13 @@ This example is the same as exMPI03 with added ntuple.
 
 - Root output files from application run with `mpiexec -n 4`
   - Sequential application:
-    (3 working ranks, 1 rank dedicated for collecting ntuple data)
-    - dose-merged.root - merged histograms
-    - dose-rank0,1,2.root - histograms data collected on rank 0  before merge
+    (3 working ranks, the last rank dedicated for collecting ntuple data)
+    - dose-merged.root - merged histograms from ranks 0, 1 and 2
+    - dose-rank1,2.root - histograms data collected on rank N before merge
     - dose-rank3  - ntuples merged from ranks 0, 1 and 2
   - MT application:
     (4 working ranks)
-    - dose-merged.root - merged histograms
-    - dose-rank0, 1, 2, 3.root -  histograms data collected on rank N before merge;
-         ntuples merged on rank N from rank threads
+    - dose-merged.root - merged histograms from ranks 0, 1, 2 and 3
+    - dose-rank0,1,2,3.root -  histograms data collected on rank N before merge;
+         ntuples merged on each rank N from rank threads
 

examples/extended/parallel/MPI/examples/exMPI04/src/RunActionMaster.cc

@@ -70,6 +70,7 @@ RunActionMaster::RunActionMaster(G4bool useNtuple, G4bool mergeNtuple)
   Analysis* myana = Analysis::GetAnalysis();
   myana->SetUseNtuple(useNtuple);
   myana->SetMergeNtuple(mergeNtuple);
+  G4cout<<"Book analysis on master on rank: " << G4MPImanager::GetManager()-> GetRank() << G4endl;;
   myana->Book();
 }
 
@@ -213,7 +214,8 @@ RunActionMaster::EndOfRunAction(const G4Run* arun)
     }
   
     //Save histograms *before* MPI merging for rank #0
-    if (rank == 0) {
+    //Can be done only if MPI merging is not activated
+    if (rank == 0 && (fMPIntupleMerger == nullptr) ) {
       Analysis* myana = Analysis::GetAnalysis();
       myana-> Save();
       myana-> Close(false);  // close without resetting histograms
@@ -241,7 +243,9 @@ RunActionMaster::EndOfRunAction(const G4Run* arun)
   if (rank == 0) {
     // Rename files
     G4fs::rename("dose-rank0.root", "dose-merged.root");
-    G4fs::rename("dose-rank0-part.root", "dose-rank0.root");
+    if (fMPIntupleMerger == nullptr) {
+      G4fs::rename("dose-rank0-part.root", "dose-rank0.root");
+    }
   }
 
   G4cout << "===================================================" << G4endl;

examples/extended/parallel/MPI/source/analysis/include/G4RootMpiNtupleFileManager.hh

@@ -56,7 +56,7 @@ class G4RootMpiNtupleFileManager : public  G4RootNtupleFileManager
     // virtual methods from base class
     virtual G4bool ActionAtOpenFile(const G4String& fileName) final;
     virtual G4bool ActionAtWrite() final;
-    virtual G4bool ActionAtCloseFile(G4bool reset) final; 
+    virtual G4bool ActionAtCloseFile() final; 
     virtual G4bool Reset() final;
 
     virtual std::shared_ptr<G4VNtupleManager> CreateNtupleManager() override;

examples/extended/parallel/MPI/source/analysis/include/G4RootMpiPNtupleDescription.hh

@@ -64,7 +64,7 @@ struct G4RootMpiPNtupleDescription
 
   ~G4RootMpiPNtupleDescription()
       {
-         if ( fDescription.fIsNtupleOwner ) delete fNtuple;
+         if ( fDescription.GetIsNtupleOwner() ) delete fNtuple;
       }    
 
   RootNtupleDescription fDescription;

examples/extended/parallel/MPI/source/analysis/include/G4RootMpiPNtupleManager.hh

@@ -44,6 +44,7 @@
 #include "tools/wroot/base_pntuple"
 
 #include <vector>
+#include <string_view>
 
 using std::to_string;
 
@@ -62,8 +63,8 @@ class G4RootMpiPNtupleManager : public G4BaseNtupleManager
   friend class G4RootMpiNtupleFileManager;
 
   public:
-    explicit G4RootMpiPNtupleManager(const G4AnalysisManagerState& state, 
-                                     tools::impi* impi, G4int mpiRank, G4int destinationRank);
+    G4RootMpiPNtupleManager(const G4AnalysisManagerState& state, 
+                            tools::impi* impi, G4int mpiRank, G4int destinationRank);
     ~G4RootMpiPNtupleManager();
 
   private:
@@ -96,6 +97,7 @@ class G4RootMpiPNtupleManager : public G4BaseNtupleManager
     virtual G4bool Merge() final;
 
     // Clear all data
+    virtual G4bool Reset() final;
     virtual void Clear() final;
 
     // Reset
@@ -107,9 +109,16 @@ class G4RootMpiPNtupleManager : public G4BaseNtupleManager
     virtual void  SetActivation(G4int ntupleId, G4bool activation) final;
     virtual G4bool  GetActivation(G4int ntupleId) const final;
 
+    // New cycle option
+    void SetNewCycle(G4bool value) final;
+    G4bool GetNewCycle() const final;
+
     // Access methods
     virtual G4int GetNofNtuples() const final;
 
+    // List ntuples
+    G4bool List(std::ostream& output, G4bool onlyIfActive = true) final;
+
   private:
     G4RootMpiPNtupleDescription*  
       GetNtupleDescriptionInFunction(G4int id, G4String function, G4bool warn = true) const;
@@ -119,6 +128,9 @@ class G4RootMpiPNtupleManager : public G4BaseNtupleManager
     template <typename T> 
     G4bool FillNtupleTColumn(G4int ntupleId, G4int columnId, const T& value);
 
+    // Static data members
+    static constexpr std::string_view fkClass { "G4RootMpiPNtupleManager" };
+
     // Data members
     // G4RootMpiMainNtupleManager* fMpiMainNtupleManager;
     std::shared_ptr<G4RootFileManager> fFileManager;
@@ -127,6 +139,7 @@ class G4RootMpiPNtupleManager : public G4BaseNtupleManager
     tools::impi*  fImpi;
     G4int  fMpiRank;
     G4int  fDestinationRank;
+    G4bool fNewCycle { false };
 };
 
 // inline functions

examples/extended/parallel/MPI/source/analysis/src/G4RootMpiAnalysisManager.cc

@@ -53,6 +53,7 @@ G4RootMpiAnalysisManager::G4RootMpiAnalysisManager(G4bool /*isMaster*/)
 
   // Ntuple file manager
   fNtupleFileManager = std::make_shared<G4RootMpiNtupleFileManager>(fState);
+  SetNtupleFileManager(fNtupleFileManager);
   fNtupleFileManager->SetFileManager(fFileManager);
   fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
 }
@@ -99,62 +100,56 @@ G4bool G4RootMpiAnalysisManager::OpenFileImpl(const G4String& fileName)
     SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
   }
 
-  auto finalResult = true;
+  auto result = true;
 
   // Open file
   // In difference from base class a file is open also on slave ranks
-  auto result = fFileManager->OpenFile(fileName);
-  finalResult = finalResult && result;
+  result &= fFileManager->OpenFile(fileName);
 
   // Open ntuple file(s) and create ntuples from bookings
-  result = fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
-  finalResult = finalResult && result;
+  result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
 
-  return finalResult;
+  return result;
 }  
 
 //_____________________________________________________________________________
 G4bool G4RootMpiAnalysisManager::WriteImpl() 
 {
 
-  auto finalResult = true;
+  auto result = true;
 
   // Call base class method
-  auto result = G4RootAnalysisManager::WriteImpl();
-  finalResult = finalResult && result;
+  result &= G4ToolsAnalysisManager::WriteImpl();
 
   // Write file also on Slave
   // (skipped in base class)
   if ( fNtupleFileManager->GetMergeMode() == G4NtupleMergeMode::kSlave )  {
     // write all open files
-    result = fFileManager->WriteFiles();
-    finalResult = finalResult && result;
+    result &= fFileManager->WriteFiles();
   }
 
-  Message(kVL2, "write", "slave files", "", finalResult);
+  Message(kVL2, "write", "slave files", "", result);
 
-  return finalResult;
+  return result;
 }
 
 //_____________________________________________________________________________
 G4bool G4RootMpiAnalysisManager::CloseFileImpl(G4bool reset)
 {
-  auto finalResult = true;
+  auto result = true;
 
   // Call base class method
-  auto result = G4RootAnalysisManager::CloseFileImpl(reset);
-  finalResult = finalResult && result;
+  result &= G4RootAnalysisManager::CloseFileImpl(reset);
 
   // Close file also on Slave
   // (skipped in base class)
   if ( fNtupleFileManager->GetMergeMode() == G4NtupleMergeMode::kSlave )  {
     // close all open files
-    result = fFileManager->CloseFiles();
-    finalResult = finalResult && result;
+    result &= fFileManager->CloseFiles();
   }
 
-  Message(kVL2, "close", "slave files", "", finalResult);
+  Message(kVL2, "close", "slave files", "", result);
 
-  return finalResult;
+  return result;
 
 }

examples/extended/parallel/MPI/source/analysis/src/G4RootMpiNtupleFileManager.cc

@@ -184,8 +184,6 @@ std::shared_ptr<G4VNtupleManager> G4RootMpiNtupleFileManager::CreateNtupleManage
 //_____________________________________________________________________________
 G4bool G4RootMpiNtupleFileManager::ActionAtOpenFile(const G4String& fileName)
 {
-  auto finalResult = true;
-
   // No MPI merging, call base class
   if ( fNtupleMergeMode == G4NtupleMergeMode::kNone )  {
     return G4RootNtupleFileManager::ActionAtOpenFile(fileName);
@@ -218,7 +216,7 @@ G4bool G4RootMpiNtupleFileManager::ActionAtOpenFile(const G4String& fileName)
     fNtupleBooked = true;
   }
 
-  return finalResult;
+  return true;
 }  
 
 //_____________________________________________________________________________
@@ -229,7 +227,7 @@ G4bool G4RootMpiNtupleFileManager::ActionAtWrite()
     return G4RootNtupleFileManager::ActionAtWrite();
   }
   
-  auto finalResult = true;
+  auto result = true;
 
   G4String ntupleType;
   if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) ntupleType = "main ntuples";
@@ -238,50 +236,32 @@ G4bool G4RootMpiNtupleFileManager::ActionAtWrite()
   Message(kVL4, "merge", ntupleType);
 
   if ( fNtupleMergeMode == G4NtupleMergeMode::kMain )  {
-    auto result = fNtupleManager->Merge();
-    finalResult = result && finalResult;
+    result &= fNtupleManager->Merge();
   }  
   
   if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
-    auto result = fMpiSlaveNtupleManager->Merge();
-    finalResult = result && finalResult;
+    result &= fMpiSlaveNtupleManager->Merge();
   }
 
-  Message(kVL1, "merge", ntupleType, "", finalResult);
+  Message(kVL1, "merge", ntupleType, "", result);
 
-  return finalResult;
+  return result;
 }
 
 //_____________________________________________________________________________
-G4bool G4RootMpiNtupleFileManager::ActionAtCloseFile(G4bool reset)
-{
+G4bool G4RootMpiNtupleFileManager::ActionAtCloseFile()
+{ 
   // No MPI merging, call base class
   if ( fNtupleMergeMode == G4NtupleMergeMode::kNone )  {
-    return G4RootNtupleFileManager::ActionAtCloseFile(reset);
+    return G4RootNtupleFileManager::ActionAtCloseFile();
   }
 
-  auto finalResult = true;
-
-  // reset data
-  if ( reset ) {
-    auto result = Reset();
-    if ( ! result ) {
-        G4ExceptionDescription description;
-        description << "      " << "Resetting data failed";
-        G4Exception("G4RootNtupleFileManager::Write()",
-                  "Analysis_W021", JustWarning, description);
-    } 
-    finalResult = finalResult && result;
+  if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave)  {
+    fMpiSlaveNtupleManager->SetNewCycle(false);
+    return true;
   }
 
-  // close files
-  if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave )  {
-    auto result = CloseNtupleFiles();
-    finalResult = finalResult && result;
-  }
-
-  // MT not yet supported - no files clean-up
-  return finalResult;
+  return CloseNtupleFiles();
 }
 
 //_____________________________________________________________________________
@@ -294,17 +274,15 @@ G4bool G4RootMpiNtupleFileManager::Reset()
     return G4RootNtupleFileManager::Reset();
   }
   
-  auto finalResult = true;
+  auto result = true;
   
   if ( fNtupleMergeMode == G4NtupleMergeMode::kMain )  {
-    auto result = fNtupleManager->Reset();
-    finalResult = result && finalResult;
+    result &= fNtupleManager->Reset();
   }  
 
   if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave )  {
-    auto result = fMpiSlaveNtupleManager->Reset(false);
-    finalResult = result && finalResult;
+    result &= fMpiSlaveNtupleManager->Reset(false);
   }  
 
-  return finalResult;
+  return result;
 }

examples/extended/parallel/MPI/source/analysis/src/G4RootMpiNtupleManager.cc

@@ -76,7 +76,7 @@ G4bool G4RootMpiNtupleManager::Send(G4int id, RootNtupleDescription* ntupleDescr
   // G4cout << "ntuple: " << ntupleDescription->fNtuple << G4endl;
 
   // Get ntuple
-  auto ntuple = ntupleDescription->fNtuple;
+  auto ntuple = ntupleDescription->GetNtuple();
 
   // Get basket sizes    
   std::vector<tools::wroot::branch*> mainBranches;
@@ -166,7 +166,7 @@ G4bool G4RootMpiNtupleManager::InitializeRanks()
   for ( auto ntupleDescription : fNtupleDescriptionVector ) {
 
     // Do not create ntuple if it is inactivated 
-    if ( fState.GetIsActivation() && ( ! ntupleDescription->fActivation ) ) continue;
+    if ( fState.GetIsActivation() && ( ! ntupleDescription->GetActivation() ) ) continue;
 
     auto result = Send(counter++, ntupleDescription);
     finalResult = finalResult && result;
@@ -329,10 +329,10 @@ G4bool G4RootMpiNtupleManager::Merge()
   for ( auto ntupleDescription : fNtupleDescriptionVector ) {
 
     // Do not create ntuple if it is inactivated 
-    if ( fState.GetIsActivation() && ( ! ntupleDescription->fActivation ) ) continue;
+    if ( fState.GetIsActivation() && ( ! ntupleDescription->GetActivation() ) ) continue;
 
     // G4cout << "Go to call merge_number_of_entries" << G4endl;
-    ntupleDescription->fNtuple->merge_number_of_entries();
+    ntupleDescription->GetNtuple()->merge_number_of_entries();
   }
 
   return finalResult;

examples/extended/parallel/MPI/source/analysis/src/G4RootMpiPNtupleManager.cc

@@ -116,7 +116,7 @@ tools::wroot::base_pntuple*  G4RootMpiPNtupleManager::GetNtupleInFunction(
 void G4RootMpiPNtupleManager::CreateNtuple(G4RootMpiPNtupleDescription* ntupleDescription)
 {
   Message(kVL4, "create from booking", "mpi pntuple",
-    ntupleDescription->fDescription.fNtupleBooking.name());
+    ntupleDescription->fDescription.GetNtupleBooking().name());
 
   // Wait for the ntuple data from main
 
@@ -206,27 +206,27 @@ void G4RootMpiPNtupleManager::CreateNtuple(G4RootMpiPNtupleDescription* ntupleDe
     tools::wroot::mpi_ntuple_row_wise* ntuple
       = new tools::wroot::mpi_ntuple_row_wise(
               mainNtupleId, G4cout, byteSwap, compression, seekDirectory,
-              basketSize, ntupleDescription->fDescription.fNtupleBooking, verbose);
+              basketSize, ntupleDescription->fDescription.GetNtupleBooking(), verbose);
     ntupleDescription->fNtuple = ntuple;
     ntupleDescription->fBasePNtuple = ntuple; 
   } else {
     tools::wroot::mpi_ntuple_column_wise* ntuple
       = new tools::wroot::mpi_ntuple_column_wise(
               mainNtupleId, G4cout, byteSwap, compression, seekDirectory,
-              basketSizes, ntupleDescription->fDescription.fNtupleBooking, 
+              basketSizes, ntupleDescription->fDescription.GetNtupleBooking(), 
               rowMode, basketEntries, verbose);
     ntupleDescription->fNtuple = ntuple;
     ntupleDescription->fBasePNtuple = ntuple; 
   }
 
-  ntupleDescription->fDescription.fIsNtupleOwner = true; 
+  ntupleDescription->fDescription.SetIsNtupleOwner(true); 
   ntupleDescription->fImpi = fImpi; 
          // should be not needed 
          // pntuple object is not deleted automatically
   fNtupleVector.push_back(ntupleDescription->fNtuple);  
 
   Message(kVL3, "create from booking", "mpi pntuple",
-    ntupleDescription->fDescription.fNtupleBooking.name());
+    ntupleDescription->fDescription.GetNtupleBooking().name());
 }
 
 //_____________________________________________________________________________
@@ -252,13 +252,13 @@ void G4RootMpiPNtupleManager::CreateNtuplesFromBooking(
   for ( auto ntupleDescription : fNtupleDescriptionVector ) {
 
     // Do not create ntuple if it is inactivated 
-    if ( fState.GetIsActivation() && ( ! ntupleDescription->fDescription.fActivation ) ) continue;
+    if ( fState.GetIsActivation() && ( ! ntupleDescription->fDescription.GetActivation() ) ) continue;
     
     // Do not create ntuple if it already exists
     if ( ntupleDescription->fNtuple ) continue;
     
     Message(kVL4, "create from booking", "mpi pntuple",
-      ntupleDescription->fDescription.fNtupleBooking.name());
+      ntupleDescription->fDescription.GetNtupleBooking().name());
 
     // create ntuple
     CreateNtuple(ntupleDescription);
@@ -268,7 +268,7 @@ void G4RootMpiPNtupleManager::CreateNtuplesFromBooking(
     // FinishTNtuple(ntupleDescription);
 
     Message(kVL3, "create from booking", "mpi pntuple",
-      ntupleDescription->fDescription.fNtupleBooking.name());
+      ntupleDescription->fDescription.GetNtupleBooking().name());
   }
 
 }   
@@ -353,13 +353,13 @@ G4bool G4RootMpiPNtupleManager::Merge()
   for ( auto ntupleDescription : fNtupleDescriptionVector) {
 
     // skip inactivated ntuples
-    if ( ! ntupleDescription->fDescription.fActivation ) continue;
+    if ( ! ntupleDescription->fDescription.GetActivation() ) continue;
   
     // skip if ntuple was already merged and deleted
     // (this happend when the main rank re-opens a new file for merged data)
     if ( ! ntupleDescription->fNtuple ) continue;
   
-    Message(kVL4, "merge", "pntuple", ntupleDescription->fDescription.fNtupleBooking.name());
+    Message(kVL4, "merge", "pntuple", ntupleDescription->fDescription.GetNtupleBooking().name());
 
     // G4cout << "call end_fill " << fImpi 
     //        << " to rank " << ntupleDescription->fMainNtupleRank 
@@ -370,7 +370,7 @@ G4bool G4RootMpiPNtupleManager::Merge()
 
     if ( ! result ) {
       G4ExceptionDescription description;
-      description << "      " << " ntuple " << ntupleDescription->fDescription.fNtupleBooking.name()
+      description << "      " << " ntuple " << ntupleDescription->fDescription.GetNtupleBooking().name()
                   << "end fill has failed.";
       G4Exception("G4RootMpiPNtupleManager::Merge()",
                   "Analysis_W002", JustWarning, description);
@@ -379,12 +379,28 @@ G4bool G4RootMpiPNtupleManager::Merge()
     delete ntupleDescription->fNtuple;
     ntupleDescription->fNtuple = nullptr;
   
-    Message(kVL3, "merge", "pntuple", ntupleDescription->fDescription.fNtupleBooking.name());
+    Message(kVL3, "merge", "pntuple", ntupleDescription->fDescription.GetNtupleBooking().name());
   }
 
   return finalResult;
 }
 
+//_____________________________________________________________________________
+G4bool G4RootMpiPNtupleManager::Reset()
+{
+  // Reset ntuple description, this will delete ntuple if present and
+  // we have its ownership.
+  // The ntuples will be recreated with new cycle or new open file.
+
+  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
+    ntupleDescription->fDescription.Reset();
+  }
+
+  fNtupleVector.clear();
+
+  return true;
+}
+
 //_____________________________________________________________________________
 void G4RootMpiPNtupleManager::Clear()
 {
@@ -420,7 +436,7 @@ void  G4RootMpiPNtupleManager::SetActivation(
   G4bool activation)
 {
   for ( auto ntupleDescription : fNtupleDescriptionVector ) {
-    ntupleDescription->fDescription.fActivation = activation;
+    ntupleDescription->fDescription.SetActivation(activation);
   } 
 }
 
@@ -432,7 +448,7 @@ void  G4RootMpiPNtupleManager::SetActivation(
   auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetActivation");
   if ( ! ntupleDescription ) return;
 
-  ntupleDescription->fDescription.fActivation = activation;
+  ntupleDescription->fDescription.SetActivation(activation);
 }
 
 //_____________________________________________________________________________
@@ -442,7 +458,19 @@ G4bool  G4RootMpiPNtupleManager::GetActivation(
   auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "GetActivation");
   if ( ! ntupleDescription ) return false;
 
-  return ntupleDescription->fDescription.fActivation;
+  return ntupleDescription->fDescription.GetActivation();
+}
+
+//_____________________________________________________________________________
+void G4RootMpiPNtupleManager::SetNewCycle(G4bool value)
+{
+  fNewCycle = value;
+}
+
+//_____________________________________________________________________________
+G4bool G4RootMpiPNtupleManager::GetNewCycle() const
+{
+  return fNewCycle;
 }
 
 //_____________________________________________________________________________
@@ -450,3 +478,10 @@ G4int G4RootMpiPNtupleManager::GetNofNtuples() const
 {
   return fNtupleVector.size();
 }
+
+//_____________________________________________________________________________
+G4bool G4RootMpiPNtupleManager::List(std::ostream& /*output*/, G4bool /*onlyIfActive*/)
+{
+  Warn("Not implemented.", fkClass, "List");
+  return false;
+}

examples/extended/parallel/ThreadsafeScorers/.README.txt

@@ -188,15 +188,15 @@
 
 \section ThreadsafeScorers_s8 TIMEMORY USAGE
 
-    This example demonstrates profiling analysis with timemory
-    (https://github.com/NERSC/timemory).
+   This example demonstrates profiling analysis with timemory
+   (https://github.com/NERSC/timemory).
 
-    - Compile Geant4 with timemory (-DGEANT4_USE_TIMEMORY=ON)
-    - timemory provide timing within the Geant4 source code
-      and within the example (TSRun::RecordEvent)
-    - Analysis is echoed to stdout and generates several output
-      files in a folder based on the name of the executable. In
-      general that folder will be "timemory-{name of executable}-output"
+   - Compile Geant4 with timemory (-DGEANT4_USE_TIMEMORY=ON)
+   - timemory provide timing within the Geant4 source code
+     and within the example (TSRun::RecordEvent)
+   - Analysis is echoed to stdout and generates several output
+     files in a folder based on the name of the executable. In
+     general that folder will be "timemory-{name of executable}-output"
 
 */
 

examples/extended/parallel/ThreadsafeScorers/History

@@ -5,6 +5,9 @@ which **must** added in reverse chronological order (newest at the top). It must
 be used as a substitute for writing good git commit messages!
 
 
+## 2022-11-09 I. Hrivnacova (ThreadsafeScorers-V11-00-01)
+- Fixed Doxygen documentation
+
 ## 2021-12-10 Ben Morgan (ThreadsafeScorers-V11-00-00)
 - Change to new Markdown History format