Convert all Velo algorithms.

device/velo/mask_clustering/include/EstimateInputSize.cuh

@@ -20,7 +20,6 @@ namespace velo_estimate_input_size {
     DEVICE_OUTPUT(dev_estimated_input_size_t, unsigned) dev_estimated_input_size;
     DEVICE_OUTPUT(dev_module_candidate_num_t, unsigned) dev_module_candidate_num;
     DEVICE_OUTPUT(dev_cluster_candidates_t, unsigned) dev_cluster_candidates;
-    PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim;
   };
 
   struct velo_estimate_input_size_t : public DeviceAlgorithm, Parameters {
@@ -33,6 +32,6 @@ namespace velo_estimate_input_size {
       const Allen::Context& context) const;
 
   private:
-    Property<block_dim_t> m_block_dim {this, {{16, 16, 1}}};
+    Allen::NewProperty<dim3> m_block_dim {this, "block_dim", {16, 16, 1}, "block dimensions"};
   };
 } // namespace velo_estimate_input_size

device/velo/mask_clustering/include/VeloCalculateNumberOfCandidates.cuh

@@ -17,7 +17,6 @@ namespace velo_calculate_number_of_candidates {
     DEVICE_INPUT(dev_velo_raw_input_types_t, unsigned) dev_velo_raw_input_types;
     DEVICE_OUTPUT(dev_number_of_candidates_t, unsigned) dev_number_of_candidates;
     DEVICE_OUTPUT(dev_velo_bank_index_t, unsigned) dev_velo_bank_index;
-    PROPERTY(block_dim_x_t, "block_dim_x", "block dimension X", unsigned) block_dim_x_prop;
   };
 
   // Algorithm
@@ -31,6 +30,6 @@ namespace velo_calculate_number_of_candidates {
       const Allen::Context& context) const;
 
   private:
-    Property<block_dim_x_t> m_block_dim_x {this, 256};
+    Allen::NewProperty<unsigned> m_block_dim_x {this, "block_dim_x", 256, "block dimension X"};
   };
 } // namespace velo_calculate_number_of_candidates

device/velo/mask_clustering/src/EstimateInputSize.cu

@@ -276,6 +276,6 @@ void velo_estimate_input_size::velo_estimate_input_size_t::operator()(
                      (runtime_options.mep_layout ? global_function(velo_estimate_input_size_kernel<4, true>) :
                                                    global_function(velo_estimate_input_size_kernel<4, false>));
 
-  kernel_fn(dim3(size<dev_event_list_t>(arguments)), property<block_dim_t>(), context)(
+  kernel_fn(dim3(size<dev_event_list_t>(arguments)), m_block_dim.value(), context)(
     arguments, std::get<0>(runtime_options.event_interval));
 }

device/velo/mask_clustering/src/VeloCalculateNumberOfCandidates.cu

@@ -69,7 +69,7 @@ void velo_calculate_number_of_candidates::velo_calculate_number_of_candidates_t:
 
   // Enough blocks to cover all events
   const auto grid_size =
-    dim3((size<dev_event_list_t>(arguments) + property<block_dim_x_t>() - 1) / property<block_dim_x_t>());
+    dim3((size<dev_event_list_t>(arguments) + m_block_dim_x.value() - 1) / m_block_dim_x.value());
 
   auto kernel_fn =
     (bank_version == 2) ?
@@ -81,6 +81,6 @@ void velo_calculate_number_of_candidates::velo_calculate_number_of_candidates_t:
       (runtime_options.mep_layout ? global_function(velo_calculate_number_of_candidates_kernel<4, true>) :
                                     global_function(velo_calculate_number_of_candidates_kernel<4, false>));
 
-  kernel_fn(grid_size, dim3(property<block_dim_x_t>().get()), context)(
+  kernel_fn(grid_size, m_block_dim_x.value(), context)(
     arguments, size<dev_event_list_t>(arguments), std::get<0>(runtime_options.event_interval));
 }

device/velo/search_by_triplet/include/SortByPhi.cuh

@@ -23,7 +23,6 @@ namespace velo_sort_by_phi {
     DEVICE_OUTPUT(dev_sorted_velo_cluster_container_t, char) dev_sorted_velo_cluster_container;
     DEVICE_OUTPUT(dev_hit_permutation_t, unsigned) dev_hit_permutation;
     DEVICE_INPUT(dev_velo_clusters_t, Velo::Clusters) dev_velo_clusters;
-    PROPERTY(block_dim_t, "block_dim", "block dimensions", DeviceDimensions) block_dim;
   };
 
   __device__ void calculate_permutation(
@@ -51,6 +50,6 @@ namespace velo_sort_by_phi {
       const Allen::Context& context) const;
 
   private:
-    Property<block_dim_t> m_block_dim {this, {{2, 64, 1}}};
+    Allen::NewProperty<dim3> m_block_dim {this, "block_dim", {2, 64, 1}, "block dimensions"};
   };
 } // namespace velo_sort_by_phi
\ No newline at end of file

device/velo/search_by_triplet/src/SortByPhi.cu

@@ -29,7 +29,7 @@ void velo_sort_by_phi::velo_sort_by_phi_t::operator()(
 {
   Allen::memset_async<dev_hit_permutation_t>(arguments, 0, context);
 
-  global_function(velo_sort_by_phi)(dim3(size<dev_event_list_t>(arguments)), property<block_dim_t>(), context)(
+  global_function(velo_sort_by_phi)(dim3(size<dev_event_list_t>(arguments)), m_block_dim.value(), context)(
     arguments);
 
   if (property<verbosity_t>() >= logger::debug) {

host/validators/include/HostVeloValidator.h

@@ -14,7 +14,6 @@ namespace host_velo_validator {
     DEVICE_INPUT(dev_velo_track_hits_t, char) dev_velo_track_hits;
     MASK_INPUT(dev_event_list_t) dev_event_list;
     HOST_INPUT(host_mc_events_t, const MCEvents*) host_mc_events;
-    PROPERTY(root_output_filename_t, "root_output_filename", "root output filename", std::string);
   };
 
   struct host_velo_validator_t : public ValidationAlgorithm, Parameters {
@@ -27,6 +26,6 @@ namespace host_velo_validator {
       const Allen::Context&) const;
 
   private:
-    Property<root_output_filename_t> m_root_output_filename {this, "PrCheckerPlots.root"};
+    Allen::NewProperty<std::string> m_root_output_filename {this, "root_output_filename", "PrCheckerPlots.root", "root output filename"};
   };
 } // namespace host_velo_validator

host/validators/src/HostVeloValidator.cpp

@@ -25,6 +25,6 @@ void host_velo_validator::host_velo_validator_t::operator()(
     event_list);
 
   auto& checker =
-    runtime_options.checker_invoker->checker<TrackCheckerVelo>(name(), property<root_output_filename_t>());
+    runtime_options.checker_invoker->checker<TrackCheckerVelo>(name(), m_root_output_filename);
   checker.accumulate(*first<host_mc_events_t>(arguments), tracks, event_list);
 }