Skip to content

Commit e43685d

Browse files
lubynetslubynets
committed
lowerCamelCase
1 parent abd5072 commit e43685d

1 file changed

Lines changed: 47 additions & 47 deletions

File tree

‎Common/Tools/PID/pidTPCModule.h‎

Lines changed: 47 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -446,9 +446,9 @@ class pidTPCModule
446446
std::vector<float> createNetworkPrediction(TCCDB& ccdb, soa::Join<aod::Collisions, aod::EvSels> const& collisions, M const& mults, T const& tracks, B const& bcs, const size_t size)
447447
{
448448

449-
std::vector<float> network_prediction;
449+
std::vector<float> networkPrediction;
450450

451-
auto start_network_total = std::chrono::high_resolution_clock::now();
451+
auto startNetworkTotal = std::chrono::high_resolution_clock::now();
452452
if (pidTPCopts.autofetchNetworks) {
453453
const auto& bc = bcs.begin();
454454
// Initialise correct TPC response object before NN setup (for NCl normalisation)
@@ -500,18 +500,18 @@ class pidTPCModule
500500
}
501501

502502
// Defining some network parameters
503-
int input_dimensions = network.getNumInputNodes();
504-
int output_dimensions = network.getNumOutputNodes();
505-
const uint64_t track_prop_size = input_dimensions * size;
506-
const uint64_t prediction_size = output_dimensions * size;
503+
int inputDimensions = network.getNumInputNodes();
504+
int outputDimensions = network.getNumOutputNodes();
505+
const uint64_t track_prop_size = inputDimensions * size;
506+
const uint64_t prediction_size = outputDimensions * size;
507507

508-
network_prediction = std::vector<float>(prediction_size * 9); // For each mass hypotheses
508+
networkPrediction = std::vector<float>(prediction_size * 9); // For each mass hypotheses
509509
const float nNclNormalization = response->GetNClNormalization();
510-
float duration_network = 0;
510+
float durationNetwork = 0;
511511

512-
std::vector<float> track_properties(track_prop_size);
513-
uint64_t counter_track_props = 0;
514-
int loop_counter = 0;
512+
std::vector<float> trackProperties(track_prop_size);
513+
uint64_t counterTrackProps = 0;
514+
int loopCounter = 0;
515515

516516
// To load the Hadronic rate once for each collision
517517
float hadronicRateBegin = 0.;
@@ -552,74 +552,74 @@ class pidTPCModule
552552
continue;
553553
}
554554
}
555-
track_properties[counter_track_props] = trk.tpcInnerParam();
556-
track_properties[counter_track_props + 1] = trk.tgl();
557-
track_properties[counter_track_props + 2] = trk.signed1Pt();
558-
track_properties[counter_track_props + 3] = o2::track::pid_constants::sMasses[j];
559-
track_properties[counter_track_props + 4] = (trk.has_collision() && mults.size() > 0) ? mults[trk.collisionId()] / 11000. : 1.;
560-
track_properties[counter_track_props + 5] = std::sqrt(nNclNormalization / trk.tpcNClsFound());
561-
if (input_dimensions == ExpectedInputDimensionsNNV2 && networkVersion == NetworkVersionV2) {
562-
track_properties[counter_track_props + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
555+
trackProperties[counterTrackProps] = trk.tpcInnerParam();
556+
trackProperties[counterTrackProps + 1] = trk.tgl();
557+
trackProperties[counterTrackProps + 2] = trk.signed1Pt();
558+
trackProperties[counterTrackProps + 3] = o2::track::pid_constants::sMasses[j];
559+
trackProperties[counterTrackProps + 4] = (trk.has_collision() && mults.size() > 0) ? mults[trk.collisionId()] / 11000. : 1.;
560+
trackProperties[counterTrackProps + 5] = std::sqrt(nNclNormalization / trk.tpcNClsFound());
561+
if (inputDimensions == ExpectedInputDimensionsNNV2 && networkVersion == NetworkVersionV2) {
562+
trackProperties[counterTrackProps + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
563563
}
564-
if (input_dimensions == ExpectedInputDimensionsNNV3 && networkVersion == NetworkVersionV3) {
565-
track_properties[counter_track_props + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
564+
if (inputDimensions == ExpectedInputDimensionsNNV3 && networkVersion == NetworkVersionV3) {
565+
trackProperties[counterTrackProps + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
566566
if (trk.has_collision() && mults.size() > 0) {
567567
if (collsys == CollisionSystemType::kCollSyspp) {
568-
track_properties[counter_track_props + 7] = hadronicRateForCollision[trk.collisionId()] / 1500.;
568+
trackProperties[counterTrackProps + 7] = hadronicRateForCollision[trk.collisionId()] / 1500.;
569569
} else {
570-
track_properties[counter_track_props + 7] = hadronicRateForCollision[trk.collisionId()] / 50.;
570+
trackProperties[counterTrackProps + 7] = hadronicRateForCollision[trk.collisionId()] / 50.;
571571
}
572572
} else {
573573
// asign Hadronic Rate at beginning of run if track does not belong to a collision
574574
if (collsys == CollisionSystemType::kCollSyspp) {
575-
track_properties[counter_track_props + 7] = hadronicRateBegin / 1500.;
575+
trackProperties[counterTrackProps + 7] = hadronicRateBegin / 1500.;
576576
} else {
577-
track_properties[counter_track_props + 7] = hadronicRateBegin / 50.;
577+
trackProperties[counterTrackProps + 7] = hadronicRateBegin / 50.;
578578
}
579579
}
580580
}
581581

582-
if (input_dimensions == ExpectedInputDimensionsNNV4 && networkVersion == NetworkVersionV4) {
583-
track_properties[counter_track_props + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
582+
if (inputDimensions == ExpectedInputDimensionsNNV4 && networkVersion == NetworkVersionV4) {
583+
trackProperties[counterTrackProps + 6] = (trk.has_collision() && mults.size() > 0) ? collisions.iteratorAt(trk.collisionId()).ft0cOccupancyInTimeRange() / 60000. : 1.;
584584
if (trk.has_collision() && mults.size() > 0) {
585585
if (collsys == CollisionSystemType::kCollSyspp) {
586-
track_properties[counter_track_props + 7] = hadronicRateForCollision[trk.collisionId()] / 1500.;
586+
trackProperties[counterTrackProps + 7] = hadronicRateForCollision[trk.collisionId()] / 1500.;
587587
} else {
588-
track_properties[counter_track_props + 7] = hadronicRateForCollision[trk.collisionId()] / 50.;
588+
trackProperties[counterTrackProps + 7] = hadronicRateForCollision[trk.collisionId()] / 50.;
589589
}
590590
} else {
591591
// asign Hadronic Rate at beginning of run if track does not belong to a collision
592592
if (collsys == CollisionSystemType::kCollSyspp) {
593-
track_properties[counter_track_props + 7] = hadronicRateBegin / 1500.;
593+
trackProperties[counterTrackProps + 7] = hadronicRateBegin / 1500.;
594594
} else {
595-
track_properties[counter_track_props + 7] = hadronicRateBegin / 50.;
595+
trackProperties[counterTrackProps + 7] = hadronicRateBegin / 50.;
596596
}
597597
}
598-
track_properties[counter_track_props + 8] = std::fmod(std::fmod(trk.phi(), 2 * M_PI) + 2 * M_PI, M_PI / 9.0);
598+
trackProperties[counterTrackProps + 8] = std::fmod(std::fmod(trk.phi(), 2 * M_PI) + 2 * M_PI, M_PI / 9.0);
599599
}
600-
counter_track_props += input_dimensions;
600+
counterTrackProps += inputDimensions;
601601
}
602602

603-
auto start_network_eval = std::chrono::high_resolution_clock::now();
604-
float* output_network = network.evalModel(track_properties);
605-
auto stop_network_eval = std::chrono::high_resolution_clock::now();
606-
duration_network += std::chrono::duration<float, std::ratio<1, 1000000000>>(stop_network_eval - start_network_eval).count();
607-
for (uint64_t k = 0; k < prediction_size; k += output_dimensions) {
608-
for (int l = 0; l < output_dimensions; l++) {
609-
network_prediction[k + l + prediction_size * loop_counter] = output_network[k + l];
603+
auto startNetworkEval = std::chrono::high_resolution_clock::now();
604+
float* outputNetwork = network.evalModel(trackProperties);
605+
auto stopNetworkEval = std::chrono::high_resolution_clock::now();
606+
durationNetwork += std::chrono::duration<float, std::ratio<1, 1000000000>>(stopNetworkEval - startNetworkEval).count();
607+
for (uint64_t k = 0; k < prediction_size; k += outputDimensions) {
608+
for (int l = 0; l < outputDimensions; l++) {
609+
networkPrediction[k + l + prediction_size * loopCounter] = outputNetwork[k + l];
610610
}
611611
}
612612

613-
counter_track_props = 0;
614-
loop_counter += 1;
613+
counterTrackProps = 0;
614+
loopCounter += 1;
615615
}
616-
track_properties.clear();
616+
trackProperties.clear();
617617

618-
auto stop_network_total = std::chrono::high_resolution_clock::now();
619-
LOG(debug) << "Neural Network for the TPC PID response correction: Time per track (eval ONNX): " << duration_network / (size * 9) << "ns ; Total time (eval ONNX): " << duration_network / 1000000000 << " s";
620-
LOG(debug) << "Neural Network for the TPC PID response correction: Time per track (eval + overhead): " << std::chrono::duration<float, std::ratio<1, 1000000000>>(stop_network_total - start_network_total).count() / (size * 9) << "ns ; Total time (eval + overhead): " << std::chrono::duration<float, std::ratio<1, 1000000000>>(stop_network_total - start_network_total).count() / 1000000000 << " s";
618+
auto stopNetworkTotal = std::chrono::high_resolution_clock::now();
619+
LOG(debug) << "Neural Network for the TPC PID response correction: Time per track (eval ONNX): " << durationNetwork / (size * 9) << "ns ; Total time (eval ONNX): " << durationNetwork / 1000000000 << " s";
620+
LOG(debug) << "Neural Network for the TPC PID response correction: Time per track (eval + overhead): " << std::chrono::duration<float, std::ratio<1, 1000000000>>(stopNetworkTotal - startNetworkTotal).count() / (size * 9) << "ns ; Total time (eval + overhead): " << std::chrono::duration<float, std::ratio<1, 1000000000>>(stopNetworkTotal - startNetworkTotal).count() / 1000000000 << " s";
621621

622-
return network_prediction;
622+
return networkPrediction;
623623
}
624624

625625
//__________________________________________________

0 commit comments

Comments
 (0)