O2-DQ User Interface 1.0.0
Loading...
Searching...
No Matches
Functions
o2::aod::dqcuts Namespace Reference

Functions

AnalysisCut * GetAnalysisCut (const char *cutName)
 
AnalysisCompositeCut * GetCompositeCut (const char *cutName)
 

Function Documentation

◆ GetAnalysisCut()

AnalysisCut * GetAnalysisCut ( const char *  cutName)

Definition at line 457 of file tempCutsLibrary.h.

458{
459 //
460 // define here cuts which are likely to be used often
461 //
462 AnalysisCut* cut = new AnalysisCut(cutName, cutName);
463 std::string nameStr = cutName;
464
465 if (!nameStr.compare("eventStandard")) {
466 cut->AddCut(VarManager::kVtxZ, -10.0, 10.0);
467 cut->AddCut(VarManager::kIsINT7, 0.5, 1.5);
468 return cut;
469 }
470
471 if (!nameStr.compare("eventStandardNoINT7")) {
472 cut->AddCut(VarManager::kVtxZ, -10.0, 10.0);
473 return cut;
474 }
475
476 if (!nameStr.compare("eventDimuonStandard")) {
477 cut->AddCut(VarManager::kIsMuonUnlikeLowPt7, 0.5, 1.5);
478 return cut;
479 }
480
481 if (!nameStr.compare("eventMuonStandard")) {
482 cut->AddCut(VarManager::kIsMuonSingleLowPt7, 0.5, 1.5);
483 return cut;
484 }
485
486 if (!nameStr.compare("int7vtxZ5")) {
487 cut->AddCut(VarManager::kVtxZ, -5.0, 5.0);
488 cut->AddCut(VarManager::kIsINT7, 0.5, 1.5);
489 return cut;
490 }
491
492 if (!nameStr.compare("jpsiStandardKine")) {
493 cut->AddCut(VarManager::kPt, 1.0, 1000.0);
494 cut->AddCut(VarManager::kEta, -0.9, 0.9);
495 return cut;
496 }
497
498 if (!nameStr.compare("highPtHadron")) {
499 cut->AddCut(VarManager::kPt, 4.0, 1000.0);
500 cut->AddCut(VarManager::kEta, -0.9, 0.9);
501 cut->AddCut(VarManager::kIsITSrefit, 0.5, 1.5);
502 cut->AddCut(VarManager::kIsTPCrefit, 0.5, 1.5);
503 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
504 cut->AddCut(VarManager::kITSchi2, 0.1, 36.0);
505 cut->AddCut(VarManager::kTPCncls, 70.0, 161.);
506 return cut;
507 }
508
509 if (!nameStr.compare("lmeeStandardKine")) {
510 cut->AddCut(VarManager::kPt, 0.2, 10.0);
511 cut->AddCut(VarManager::kEta, -0.8, 0.8);
512 return cut;
513 }
514
515 if (!nameStr.compare("lmeeLowBKine")) {
516 cut->AddCut(VarManager::kPt, 0.075, 10.0);
517 cut->AddCut(VarManager::kEta, -0.8, 0.8);
518 return cut;
519 }
520
521 if (!nameStr.compare("PIDStandardKine")) {
522 cut->AddCut(VarManager::kPt, 0.1, 1000.0);
523 cut->AddCut(VarManager::kEta, -0.9, 0.9);
524 return cut;
525 }
526
527 if (!nameStr.compare("TightGlobalTrack")) {
528 cut->AddCut(VarManager::kIsSPDfirst, 0.5, 1.5);
529 cut->AddCut(VarManager::kIsITSrefit, 0.5, 1.5);
530 cut->AddCut(VarManager::kIsTPCrefit, 0.5, 1.5);
531 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
532 cut->AddCut(VarManager::kITSchi2, 0.0, 5.0);
533 cut->AddCut(VarManager::kTPCnclsCR, 80.0, 161.);
534 cut->AddCut(VarManager::kITSncls, 3.5, 7.5);
535 return cut;
536 }
537
538 if (!nameStr.compare("TightGlobalTrackRun3")) {
539 cut->AddCut(VarManager::kIsSPDfirst, 0.5, 1.5);
540 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
541 cut->AddCut(VarManager::kITSchi2, 0.0, 5.0);
542 cut->AddCut(VarManager::kTPCnclsCR, 80.0, 161.);
543 cut->AddCut(VarManager::kITSncls, 3.5, 9.);
544 return cut;
545 }
546
547 if (!nameStr.compare("TightTPCTrackRun3")) {
548 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
549 cut->AddCut(VarManager::kTPCnclsCR, 80.0, 161.);
550 return cut;
551 }
552
553 if (!nameStr.compare("electronStandardQuality")) {
554 cut->AddCut(VarManager::kIsSPDany, 0.5, 1.5);
555 cut->AddCut(VarManager::kIsITSrefit, 0.5, 1.5);
556 cut->AddCut(VarManager::kIsTPCrefit, 0.5, 1.5);
557 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
558 cut->AddCut(VarManager::kITSchi2, 0.1, 36.0);
559 cut->AddCut(VarManager::kTPCncls, 100.0, 161.);
560 return cut;
561 }
562
563 if (!nameStr.compare("electronStandardQualityBenchmark")) {
564 cut->AddCut(VarManager::kIsITSrefit, 0.5, 1.5);
565 cut->AddCut(VarManager::kIsTPCrefit, 0.5, 1.5);
566 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
567 cut->AddCut(VarManager::kITSchi2, 0.1, 36.0);
568 cut->AddCut(VarManager::kTPCncls, 70.0, 161.);
569 return cut;
570 }
571
572 if (!nameStr.compare("electronStandardQualityForO2MCdebug")) {
573 cut->AddCut(VarManager::kIsSPDany, 0.5, 1.5);
574 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
575 cut->AddCut(VarManager::kTPCncls, 70, 161.);
576 return cut;
577 }
578
579 if (!nameStr.compare("electronStandardQualityForO2MCdebug2")) {
580 cut->AddCut(VarManager::kIsSPDany, 0.5, 1.5);
581 cut->AddCut(VarManager::kTPCchi2, 0.0, 4.0);
582 cut->AddCut(VarManager::kTPCncls, 100.0, 161.);
583 return cut;
584 }
585
586 if (!nameStr.compare("standardPrimaryTrack")) {
587 cut->AddCut(VarManager::kTrackDCAxy, -1.0, 1.0);
588 cut->AddCut(VarManager::kTrackDCAz, -3.0, 3.0);
589 return cut;
590 }
591
592 TF1* cutLow1 = new TF1("cutLow1", "pol1", 0., 10.);
593 if (!nameStr.compare("electronPID1")) {
594 cutLow1->SetParameters(130., -40.0);
595 cut->AddCut(VarManager::kTPCsignal, 70., 100.);
596 cut->AddCut(VarManager::kTPCsignal, cutLow1, 100.0, false, VarManager::kPin, 0.5, 3.0);
597 return cut;
598 }
599
600 if (!nameStr.compare("electronPID1shiftUp")) {
601 cut->AddCut(VarManager::kTPCsignal, 70. - 0.85, 100. - 0.85);
602 cutLow1->SetParameters(130. - 0.85, -40.0);
603 cut->AddCut(VarManager::kTPCsignal, cutLow1, 100.0 - 0.85, false, VarManager::kPin, 0.5, 3.0);
604 return cut;
605 }
606
607 if (!nameStr.compare("electronPID1shiftDown")) {
608 cut->AddCut(VarManager::kTPCsignal, 70.0 + 0.85, 100.0 + 0.85);
609 cutLow1->SetParameters(130. + 0.85, -40.0);
610 cut->AddCut(VarManager::kTPCsignal, cutLow1, 100.0 + 0.85, false, VarManager::kPin, 0.5, 3.0);
611 return cut;
612 }
613
614 if (!nameStr.compare("electronPID1randomized")) {
615 cutLow1->SetParameters(130., -40.0);
616 cut->AddCut(VarManager::kTPCsignalRandomized, 70., 100.);
617 cut->AddCut(VarManager::kTPCsignalRandomized, cutLow1, 100.0, false, VarManager::kPin, 0.5, 3.0);
618 return cut;
619 }
620
621 if (!nameStr.compare("electronPID2")) {
622 cutLow1->SetParameters(130., -40.0);
623 cut->AddCut(VarManager::kTPCsignal, 73., 100.);
624 cut->AddCut(VarManager::kTPCsignal, cutLow1, 100.0, false, VarManager::kPin, 0.5, 3.0);
625 return cut;
626 }
627
628 if (!nameStr.compare("electronPID3")) {
629 cutLow1->SetParameters(130., -40.0);
630 cut->AddCut(VarManager::kTPCsignal, 60., 110.);
631 cut->AddCut(VarManager::kTPCsignal, cutLow1, 100.0, false, VarManager::kPin, 0.5, 3.0);
632 return cut;
633 }
634
635 if (!nameStr.compare("electronPID2randomized")) {
636 cutLow1->SetParameters(130., -40.0);
637 cut->AddCut(VarManager::kTPCsignalRandomized, 73., 100.);
638 cut->AddCut(VarManager::kTPCsignalRandomized, cutLow1, 100.0, false, VarManager::kPin, 0.5, 3.0);
639 return cut;
640 }
641
642 if (!nameStr.compare("electronPIDnsigma")) {
643 cut->AddCut(VarManager::kTPCnSigmaEl, -3.0, 3.0);
644 cut->AddCut(VarManager::kTPCnSigmaPr, 3.0, 3000.0);
645 cut->AddCut(VarManager::kTPCnSigmaPi, 3.0, 3000.0);
646 return cut;
647 }
648
649 if (!nameStr.compare("electronPIDnsigmaOpen")) {
650 cut->AddCut(VarManager::kTPCnSigmaEl, -4.0, 4.0);
651 cut->AddCut(VarManager::kTPCnSigmaPr, 2.0, 3000.0);
652 cut->AddCut(VarManager::kTPCnSigmaPi, 2.0, 3000.0);
653 return cut;
654 }
655
656 if (!nameStr.compare("electronPIDnsigmaVeryVeryLoose")) {
657 cut->AddCut(VarManager::kTPCnSigmaEl, -4.0, 4.0);
658 cut->AddCut(VarManager::kTPCnSigmaPr, 2.5, 3000.0);
659 cut->AddCut(VarManager::kTPCnSigmaPi, 2.0, 3000.0);
660 return cut;
661 }
662
663 if (!nameStr.compare("electronPIDnsigmaVeryLoose")) {
664 cut->AddCut(VarManager::kTPCnSigmaEl, -4.0, 4.0);
665 cut->AddCut(VarManager::kTPCnSigmaPr, 2.5, 3000.0);
666 cut->AddCut(VarManager::kTPCnSigmaPi, 2.5, 3000.0);
667 return cut;
668 }
669
670 if (!nameStr.compare("electronPIDnsigmaLoose")) {
671 cut->AddCut(VarManager::kTPCnSigmaEl, -3.0, 3.0);
672 cut->AddCut(VarManager::kTPCnSigmaPr, 2.5, 3000.0);
673 cut->AddCut(VarManager::kTPCnSigmaPi, 2.5, 3000.0);
674 return cut;
675 }
676
677 if (!nameStr.compare("electronPIDnsigmaMedium")) {
678 cut->AddCut(VarManager::kTPCnSigmaEl, -3.0, 3.0);
679 cut->AddCut(VarManager::kTPCnSigmaPr, 2.7, 3000.0);
680 cut->AddCut(VarManager::kTPCnSigmaPi, 2.7, 3000.0);
681 return cut;
682 }
683
684 if (!nameStr.compare("kaonPIDnsigma")) {
685 cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0);
686 return cut;
687 }
688
689 if (!nameStr.compare("kaonPIDnsigma")) {
690 cut->AddCut(VarManager::kTPCnSigmaKa, -3.0, 3.0);
691 return cut;
692 }
693
694 if (!nameStr.compare("electronPIDnsigmaRandomized")) {
695 cut->AddCut(VarManager::kTPCnSigmaElRandomized, -3.0, 3.0);
696 cut->AddCut(VarManager::kTPCnSigmaPrRandomized, 3.0, 3000.0);
697 cut->AddCut(VarManager::kTPCnSigmaPiRandomized, 3.0, 3000.0);
698 return cut;
699 }
700
701 if (!nameStr.compare("electronPIDworseRes")) {
702 cut->AddCut(VarManager::kTPCnSigmaEl, -3.0, 3.0);
703 cut->AddCut(VarManager::kTPCnSigmaPr, 3.0 * 0.8, 3000.0); // emulates a 20% degradation in PID resolution
704 cut->AddCut(VarManager::kTPCnSigmaPi, 3.0 * 0.8, 3000.0); // proton and pion rejections are effectively relaxed by 20%
705 return cut;
706 }
707
708 if (!nameStr.compare("electronPIDshift")) {
709 cut->AddCut(VarManager::kTPCnSigmaEl, -3.0, 3.0);
710 cut->AddCut(VarManager::kTPCnSigmaPr, 3.0 - 0.2, 3000.0);
711 cut->AddCut(VarManager::kTPCnSigmaPi, 3.0 - 0.2, 3000.0);
712 return cut;
713 }
714
715 if (!nameStr.compare("tpc_pion_rejection")) {
716 TF1* f1maxPi = new TF1("f1maxPi", "[0]+[1]*x", 0, 10);
717 f1maxPi->SetParameters(85, -50);
718 cut->AddCut(VarManager::kTPCsignal, 70, f1maxPi, true, VarManager::kPin, 0.0, 0.4, false);
719 return cut;
720 }
721
722 if (!nameStr.compare("tpc_pion_band_rejection")) {
723 TF1* f1minPi = new TF1("f1minPi", "[0]+[1]*log(x)", 0, 10);
724 f1minPi->SetParameters(-115, -90);
725 TF1* f1maxPi = new TF1("f1maxPi", "[0]+[1]*log(x)", 0, 10);
726 f1maxPi->SetParameters(-70, -90);
727 cut->AddCut(VarManager::kTPCsignal, f1minPi, f1maxPi, true, VarManager::kPin, 0.05, 0.3, false);
728 return cut;
729 }
730
731 if (!nameStr.compare("tpc_pion_rejection_highp")) {
732 TF1* f1minPi = new TF1("f1minPi", "[0]+[1]*x", 0, 10);
733 f1minPi->SetParameters(60, 4.);
734 cut->AddCut(VarManager::kTPCsignal, f1minPi, 110., false, VarManager::kPin, 0.0, 10, false);
735 return cut;
736 }
737
738 if (!nameStr.compare("tpc_kaon_rejection")) {
739 TF1* f1minKa = new TF1("f1minKa", "[0]+[1]*x", 0, 10);
740 f1minKa->SetParameters(220, -300);
741 TF1* f1maxKa = new TF1("f1maxKa", "[0]+[1]*x", 0, 10);
742 f1maxKa->SetParameters(182.5, -150);
743 cut->AddCut(VarManager::kTPCsignal, f1minKa, f1maxKa, true, VarManager::kPin, 0.4, 0.8, false);
744 return cut;
745 }
746
747 if (!nameStr.compare("tpc_proton_rejection")) {
748 TF1* f1minPr = new TF1("f1minPr", "[0]+[1]*x", 0, 10);
749 f1minPr->SetParameters(170, -100);
750 TF1* f1maxPr = new TF1("f1maxPr", "[0]+[1]*x", 0, 10);
751 f1maxPr->SetParameters(175, -75);
752 cut->AddCut(VarManager::kTPCsignal, f1minPr, f1maxPr, true, VarManager::kPin, 0.8, 1.4, false);
753 return cut;
754 }
755
756 if (!nameStr.compare("tpc_electron")) {
757 cut->AddCut(VarManager::kTPCsignal, 70, 110, false, VarManager::kPin, 0.0, 1e+10, false);
758 return cut;
759 }
760
761 if (!nameStr.compare("tof_electron")) {
762 cut->AddCut(VarManager::kTOFbeta, 0.99, 1.01, false, VarManager::kPin, 0.0, 1e+10, false);
763 return cut;
764 }
765
766 if (!nameStr.compare("tof_electron_loose")) {
767 cut->AddCut(VarManager::kTOFbeta, 0.95, 1.05, false, VarManager::kPin, 0.0, 1e+10, false);
768 return cut;
769 }
770
771 if (!nameStr.compare("pidcalib_ele")) {
772 cut->AddCut(VarManager::kIsLegFromGamma, 0.5, 1.5, false);
773 return cut;
774 }
775
776 if (!nameStr.compare("muonQualityCuts")) {
777 cut->AddCut(VarManager::kEta, -4.0, -2.5);
778 cut->AddCut(VarManager::kMuonRAtAbsorberEnd, 17.6, 89.5);
779 cut->AddCut(VarManager::kMuonPDca, 0.0, 594.0, false, VarManager::kMuonRAtAbsorberEnd, 17.6, 26.5);
780 cut->AddCut(VarManager::kMuonPDca, 0.0, 324.0, false, VarManager::kMuonRAtAbsorberEnd, 26.5, 89.5);
781 cut->AddCut(VarManager::kMuonChi2, 0.0, 1e6);
782 cut->AddCut(VarManager::kMuonChi2MatchMCHMID, 0.0, 1e6); // matching MCH-MID
783 return cut;
784 }
785
786 if (!nameStr.compare("muonQualityCutsMatchingOnly")) {
787 cut->AddCut(VarManager::kEta, -4.0, -2.5);
788 cut->AddCut(VarManager::kMuonChi2, 0.0, 1e6);
789 cut->AddCut(VarManager::kMuonChi2MatchMCHMID, 0.0, 1e6); // matching MCH-MID
790 return cut;
791 }
792
793 if (!nameStr.compare("muonLowPt")) {
794 cut->AddCut(VarManager::kPt, 0.5, 1000.0);
795 return cut;
796 }
797
798 if (!nameStr.compare("muonLowPt2")) {
799 cut->AddCut(VarManager::kPt, 1.0, 1000.0);
800 return cut;
801 }
802
803 if (!nameStr.compare("muonHighPt")) {
804 cut->AddCut(VarManager::kPt, 4.0, 1000.0);
805 return cut;
806 }
807
808 if (!nameStr.compare("muonTightQualityCutsForTests")) {
809 cut->AddCut(VarManager::kEta, -4.0, -2.5);
810 cut->AddCut(VarManager::kMuonRAtAbsorberEnd, 20.0, 60.0);
811 cut->AddCut(VarManager::kMuonPDca, 0.0, 594.0, false, VarManager::kMuonRAtAbsorberEnd, 17.6, 26.5);
812 cut->AddCut(VarManager::kMuonPDca, 0.0, 324.0, false, VarManager::kMuonRAtAbsorberEnd, 26.5, 89.5);
813 cut->AddCut(VarManager::kMuonChi2, 0.0, 1e6);
814 return cut;
815 }
816
817 if (!nameStr.compare("mchTrack")) {
818 cut->AddCut(VarManager::kMuonTrackType, 3.5, 4.5);
819 return cut;
820 }
821
822 if (!nameStr.compare("matchedMchMid")) {
823 cut->AddCut(VarManager::kMuonTrackType, 2.5, 3.5);
824 return cut;
825 }
826
827 if (!nameStr.compare("matchedFwd")) {
828 cut->AddCut(VarManager::kMuonTrackType, 1.5, 2.5);
829 return cut;
830 }
831
832 if (!nameStr.compare("matchedGlobal")) {
833 cut->AddCut(VarManager::kMuonTrackType, -0.5, 0.5);
834 return cut;
835 }
836
837 if (!nameStr.compare("pairNoCut")) {
838 cut->AddCut(VarManager::kMass, 0.0, 1000.0);
839 return cut;
840 }
841
842 if (!nameStr.compare("pairMassLow1")) {
843 cut->AddCut(VarManager::kMass, 2.0, 1000.0);
844 return cut;
845 }
846
847 if (!nameStr.compare("pairMassLow2")) {
848 cut->AddCut(VarManager::kMass, 2.2, 1000.0);
849 return cut;
850 }
851
852 if (!nameStr.compare("pairMassLow3")) {
853 cut->AddCut(VarManager::kMass, 2.5, 1000.0);
854 return cut;
855 }
856
857 if (!nameStr.compare("pairJpsi")) {
858 cut->AddCut(VarManager::kMass, 2.8, 3.3);
859 return cut;
860 }
861
862 if (!nameStr.compare("pairPsi2S")) {
863 cut->AddCut(VarManager::kMass, 3.4, 3.9);
864 return cut;
865 }
866
867 if (!nameStr.compare("pairUpsilon")) {
868 cut->AddCut(VarManager::kMass, 8.0, 11.0);
869 return cut;
870 }
871
872 if (!nameStr.compare("pairPtLow1")) {
873 cut->AddCut(VarManager::kPt, 2.0, 1000.0);
874 return cut;
875 }
876
877 if (!nameStr.compare("pairPtLow2")) {
878 cut->AddCut(VarManager::kPt, 5.0, 1000.0);
879 return cut;
880 }
881
882 if (!nameStr.compare("pairRapidityForward")) {
883 cut->AddCut(VarManager::kRap, 2.5, 4.0);
884 return cut;
885 }
886
887 if (!nameStr.compare("pairDCA")) {
888 cut->AddCut(VarManager::kQuadDCAabsXY, .0, .50);
889 return cut;
890 }
891
892 if (!nameStr.compare("singleDCA")) {
893 cut->AddCut(VarManager::kTrackDCAsigXY, 0.0, 5.);
894 return cut;
895 }
896
897 delete cut;
898 return nullptr;
899}

◆ GetCompositeCut()

AnalysisCompositeCut * GetCompositeCut ( const char *  cutName)

Definition at line 27 of file tempCutsLibrary.h.

28{
29 //
30 // define composie cuts, typically combinations of all the ingredients needed for a full cut
31 //
32 // TODO: Agree on some conventions for the naming
33 // Think of possible customization of the predefined cuts via names
34
35 AnalysisCompositeCut* cut = new AnalysisCompositeCut(cutName, cutName);
36 std::string nameStr = cutName;
37
38 if (!nameStr.compare("jpsiO2MCdebugCuts")) {
39 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
40 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
41 cut->AddCut(GetAnalysisCut("electronPID1"));
42 return cut;
43 }
44
45 if (!nameStr.compare("jpsiBenchmarkCuts")) {
46 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
47 cut->AddCut(GetAnalysisCut("electronStandardQualityBenchmark"));
48 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
49 cut->AddCut(GetAnalysisCut("electronPIDnsigmaOpen"));
50 return cut;
51 }
52
53 if (!nameStr.compare("jpsiO2MCdebugCuts2")) {
54 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
55 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
56 cut->AddCut(GetAnalysisCut("electronPIDnsigma"));
57 return cut;
58 }
59
60 if (!nameStr.compare("jpsiO2MCdebugCuts3")) {
61 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
62 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
63 cut->AddCut(GetAnalysisCut("electronPIDnsigmaMedium"));
64
65 return cut;
66 }
67
68 if (!nameStr.compare("jpsiO2MCdebugCuts4")) {
69 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
70 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
71 cut->AddCut(GetAnalysisCut("electronPIDnsigmaLoose"));
72
73 return cut;
74 }
75
76 if (!nameStr.compare("jpsiO2MCdebugCuts5")) {
77 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
78 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
79 cut->AddCut(GetAnalysisCut("electronPIDnsigmaVeryLoose"));
80
81 return cut;
82 }
83
84 if (!nameStr.compare("jpsiO2MCdebugCuts6")) {
85 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
86 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
87 cut->AddCut(GetAnalysisCut("electronPIDnsigmaVeryVeryLoose"));
88
89 return cut;
90 }
91
92 if (!nameStr.compare("jpsiO2MCdebugCuts7")) {
93 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
94 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
95 cut->AddCut(GetAnalysisCut("electronPIDnsigmaOpen"));
96
97 return cut;
98 }
99
100 if (!nameStr.compare("jpsiO2MCdebugCuts8")) {
101 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
102 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
103 cut->AddCut(GetAnalysisCut("electronPID1shiftUp"));
104 return cut;
105 }
106
107 if (!nameStr.compare("jpsiO2MCdebugCuts9")) {
108 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
109 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
110 cut->AddCut(GetAnalysisCut("electronPID1shiftDown"));
111 return cut;
112 }
113
114 if (!nameStr.compare("jpsiKineAndQuality")) {
115 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
116 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
117 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
118 return cut;
119 }
120
121 if (!nameStr.compare("jpsiPID1")) {
122 cut->AddCut(GetAnalysisCut("jpsiStandardKine")); // standard kine cuts usually are applied via Filter in the task
123 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
124 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
125 cut->AddCut(GetAnalysisCut("electronPID1"));
126 return cut;
127 }
128
129 if (!nameStr.compare("jpsiPID2")) {
130 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
131 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
132 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
133 cut->AddCut(GetAnalysisCut("electronPID2"));
134 return cut;
135 }
136
137 if (!nameStr.compare("jpsiPIDnsigma")) {
138 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
139 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
140 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
141 cut->AddCut(GetAnalysisCut("electronPIDnsigma"));
142 return cut;
143 }
144
145 if (!nameStr.compare("highPtHadron")) {
146 cut->AddCut(GetAnalysisCut("highPtHadron"));
147 return cut;
148 }
149
150 if (!nameStr.compare("PIDCalib")) {
151 cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task
152 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
153 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
154 cut->AddCut(GetAnalysisCut("pidcalib_ele"));
155 return cut;
156 }
157
158 if (!nameStr.compare("NoPID")) {
159 cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task
160 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
161 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
162 return cut;
163 }
164
165 if (!nameStr.compare("kaonPID")) {
166 cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task
167 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
168 cut->AddCut(GetAnalysisCut("kaonPIDnsigma"));
169 return cut;
170 }
171
172 if (!nameStr.compare("kaonPID")) {
173 cut->AddCut(GetAnalysisCut("PIDStandardKine")); // standard kine cuts usually are applied via Filter in the task
174 cut->AddCut(GetAnalysisCut("electronStandardQualityForO2MCdebug"));
175 cut->AddCut(GetAnalysisCut("kaonPIDnsigma"));
176 return cut;
177 }
178
179 //---------------------------------------------------------------------------------------
180 // NOTE: Below there are several TPC pid cuts used for studies of the dE/dx degradation
181 // and its impact on the high lumi pp quarkonia triggers
182 // To be removed when not needed anymore
183 if (!nameStr.compare("jpsiPID1Randomized")) {
184 cut->AddCut(GetAnalysisCut("jpsiStandardKine")); // standard kine cuts usually are applied via Filter in the task
185 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
186 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
187 cut->AddCut(GetAnalysisCut("electronPID1randomized"));
188 return cut;
189 }
190
191 if (!nameStr.compare("jpsiPID2Randomized")) {
192 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
193 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
194 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
195 cut->AddCut(GetAnalysisCut("electronPID2randomized"));
196 return cut;
197 }
198
199 if (!nameStr.compare("jpsiPIDnsigmaRandomized")) {
200 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
201 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
202 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
203 cut->AddCut(GetAnalysisCut("electronPIDnsigmaRandomized"));
204 return cut;
205 }
206
207 if (!nameStr.compare("jpsiPIDworseRes")) {
208 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
209 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
210 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
211 cut->AddCut(GetAnalysisCut("electronPIDworseRes"));
212 return cut;
213 }
214
215 if (!nameStr.compare("jpsiPIDshift")) {
216 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
217 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
218 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
219 cut->AddCut(GetAnalysisCut("electronPIDshift"));
220 return cut;
221 }
222
223 if (!nameStr.compare("jpsiPID1shiftUp")) {
224 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
225 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
226 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
227 cut->AddCut(GetAnalysisCut("electronPID1shiftUp"));
228 return cut;
229 }
230
231 if (!nameStr.compare("jpsiPID1shiftDown")) {
232 cut->AddCut(GetAnalysisCut("jpsiStandardKine"));
233 cut->AddCut(GetAnalysisCut("electronStandardQuality"));
234 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
235 cut->AddCut(GetAnalysisCut("electronPID1shiftDown"));
236 return cut;
237 }
238 // -------------------------------------------------------------------------------------------------
239
240 if (!nameStr.compare("lmeePID_TPChadrejTOFrec")) {
241 cut->AddCut(GetAnalysisCut("lmeeStandardKine"));
242 cut->AddCut(GetAnalysisCut("TightGlobalTrack"));
243 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
244
245 AnalysisCompositeCut* cut_tpc_hadrej = new AnalysisCompositeCut("pid_TPChadrej", "pid_TPChadrej", kTRUE);
246 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_electron"));
247 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_pion_rejection"));
248 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_kaon_rejection"));
249 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_proton_rejection"));
250
251 AnalysisCompositeCut* cut_tof_rec = new AnalysisCompositeCut("pid_tof_rec", "pid_tof_rec", kTRUE);
252 cut_tof_rec->AddCut(GetAnalysisCut("tpc_electron"));
253 cut_tof_rec->AddCut(GetAnalysisCut("tof_electron"));
254
255 AnalysisCompositeCut* cut_pid_OR = new AnalysisCompositeCut("pid_TPChadrejTOFrec", "pid_TPChadrejTOFrec", kFALSE);
256 cut_pid_OR->AddCut(cut_tpc_hadrej);
257 cut_pid_OR->AddCut(cut_tof_rec);
258 cut->AddCut(cut_pid_OR);
259 return cut;
260 }
261
262 if (!nameStr.compare("lmeePID_TPChadrejTOFrecRun3")) {
263 cut->AddCut(GetAnalysisCut("lmeeLowBKine"));
264 cut->AddCut(GetAnalysisCut("TightGlobalTrackRun3"));
265 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
266
267 AnalysisCompositeCut* cut_tpc_hadrej = new AnalysisCompositeCut("pid_TPChadrej", "pid_TPChadrej", kTRUE);
268 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_electron"));
269 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_pion_band_rejection"));
270 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_pion_rejection_highp"));
271 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_kaon_rejection"));
272 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_proton_rejection"));
273
274 AnalysisCompositeCut* cut_tof_rec = new AnalysisCompositeCut("pid_tof_rec", "pid_tof_rec", kTRUE);
275 cut_tof_rec->AddCut(GetAnalysisCut("tpc_electron"));
276 cut_tof_rec->AddCut(GetAnalysisCut("tof_electron_loose"));
277 cut_tof_rec->AddCut(GetAnalysisCut("tpc_pion_rejection_highp"));
278
279 AnalysisCompositeCut* cut_pid_OR = new AnalysisCompositeCut("pid_TPChadrejTOFrec", "pid_TPChadrejTOFrec", kFALSE);
280 cut_pid_OR->AddCut(cut_tpc_hadrej);
281 cut_pid_OR->AddCut(cut_tof_rec);
282 cut->AddCut(cut_pid_OR);
283 return cut;
284 }
285
286 if (!nameStr.compare("lmeePID_TPChadrej")) {
287 cut->AddCut(GetAnalysisCut("lmeeStandardKine"));
288 cut->AddCut(GetAnalysisCut("TightGlobalTrack"));
289 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
290
291 AnalysisCompositeCut* cut_tpc_hadrej = new AnalysisCompositeCut("pid_TPChadrej", "pid_TPChadrej", kTRUE);
292 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_electron"));
293 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_pion_rejection"));
294 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_kaon_rejection"));
295 cut_tpc_hadrej->AddCut(GetAnalysisCut("tpc_proton_rejection"));
296 cut->AddCut(cut_tpc_hadrej);
297 return cut;
298 }
299
300 if (!nameStr.compare("lmeePID_TOFrec")) {
301 cut->AddCut(GetAnalysisCut("lmeeStandardKine"));
302 cut->AddCut(GetAnalysisCut("TightGlobalTrack"));
303 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
304
305 AnalysisCompositeCut* cut_tof_rec = new AnalysisCompositeCut("pid_tof_rec", "pid_tof_rec", kTRUE);
306 cut_tof_rec->AddCut(GetAnalysisCut("tpc_electron"));
307 cut_tof_rec->AddCut(GetAnalysisCut("tof_electron"));
308
309 cut->AddCut(cut_tof_rec);
310 return cut;
311 }
312
313 if (!nameStr.compare("lmee_GlobalTrack")) {
314 cut->AddCut(GetAnalysisCut("lmeeStandardKine"));
315 cut->AddCut(GetAnalysisCut("TightGlobalTrack"));
316 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
317 return cut;
318 }
319
320 if (!nameStr.compare("lmee_GlobalTrackRun3")) {
321 cut->AddCut(GetAnalysisCut("lmeeStandardKine"));
322 cut->AddCut(GetAnalysisCut("TightGlobalTrackRun3"));
323 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
324 return cut;
325 }
326
327 if (!nameStr.compare("lmee_GlobalTrackRun3_lowPt")) {
328 cut->AddCut(GetAnalysisCut("lmeeLowBKine"));
329 cut->AddCut(GetAnalysisCut("TightGlobalTrackRun3"));
330 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
331 return cut;
332 }
333
334 if (!nameStr.compare("lmee_TPCTrackRun3_lowPt")) {
335 cut->AddCut(GetAnalysisCut("lmeeLowBKine"));
336 cut->AddCut(GetAnalysisCut("TightTPCTrackRun3"));
337 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
338 return cut;
339 }
340
341 if (!nameStr.compare("lmee_GlobalTrackRun3_TPC_ePID_lowPt")) {
342 cut->AddCut(GetAnalysisCut("lmeeLowBKine"));
343 cut->AddCut(GetAnalysisCut("TightGlobalTrackRun3"));
344 cut->AddCut(GetAnalysisCut("standardPrimaryTrack"));
345 cut->AddCut(GetAnalysisCut("tpc_electron"));
346 return cut;
347 }
348
349 if (!nameStr.compare("muonQualityCuts")) {
350 cut->AddCut(GetAnalysisCut("muonQualityCuts"));
351 return cut;
352 }
353
354 if (!nameStr.compare("muonLowPt")) {
355 cut->AddCut(GetAnalysisCut("muonLowPt"));
356 cut->AddCut(GetAnalysisCut("muonQualityCuts"));
357 return cut;
358 }
359
360 if (!nameStr.compare("muonLowPt2")) {
361 cut->AddCut(GetAnalysisCut("muonLowPt"));
362 cut->AddCut(GetAnalysisCut("muonQualityCuts"));
363 return cut;
364 }
365
366 if (!nameStr.compare("muonLowPtMatchingOnly")) {
367 cut->AddCut(GetAnalysisCut("muonLowPt"));
368 cut->AddCut(GetAnalysisCut("muonQualityCutsMatchingOnly"));
369 return cut;
370 }
371
372 if (!nameStr.compare("muonHighPt")) {
373 cut->AddCut(GetAnalysisCut("muonHighPt"));
374 cut->AddCut(GetAnalysisCut("muonQualityCuts"));
375 return cut;
376 }
377
378 if (!nameStr.compare("muonTightQualityCutsForTests")) {
379 cut->AddCut(GetAnalysisCut("muonTightQualityCutsForTests"));
380 return cut;
381 }
382
383 if (!nameStr.compare("mchTrack")) {
384 cut->AddCut(GetAnalysisCut("mchTrack"));
385 return cut;
386 }
387
388 if (!nameStr.compare("matchedMchMid")) {
389 cut->AddCut(GetAnalysisCut("matchedMchMid"));
390 return cut;
391 }
392
393 if (!nameStr.compare("matchedFwd")) {
394 cut->AddCut(GetAnalysisCut("matchedFwd"));
395 return cut;
396 }
397
398 if (!nameStr.compare("matchedGlobal")) {
399 cut->AddCut(GetAnalysisCut("matchedGlobal"));
400 return cut;
401 }
402
403 if (!nameStr.compare("pairNoCut")) {
404 cut->AddCut(GetAnalysisCut("pairNoCut"));
405 return cut;
406 }
407
408 if (!nameStr.compare("pairMassLow1")) {
409 cut->AddCut(GetAnalysisCut("pairMassLow1"));
410 return cut;
411 }
412 if (!nameStr.compare("pairMassLow2")) {
413 cut->AddCut(GetAnalysisCut("pairMassLow2"));
414 return cut;
415 }
416 if (!nameStr.compare("pairMassLow3")) {
417 cut->AddCut(GetAnalysisCut("pairMassLow3"));
418 return cut;
419 }
420
421 if (!nameStr.compare("pairJpsi")) {
422 cut->AddCut(GetAnalysisCut("pairJpsi"));
423 return cut;
424 }
425
426 if (!nameStr.compare("pairPsi2S")) {
427 cut->AddCut(GetAnalysisCut("pairPsi2S"));
428 return cut;
429 }
430
431 if (!nameStr.compare("pairUpsilon")) {
432 cut->AddCut(GetAnalysisCut("pairUpsilon"));
433 return cut;
434 }
435
436 if (!nameStr.compare("pairRapidityForward")) {
437 cut->AddCut(GetAnalysisCut("pairRapidityForward"));
438 return cut;
439 }
440
441 if (!nameStr.compare("pairJpsiLowPt1")) {
442 cut->AddCut(GetAnalysisCut("pairJpsi"));
443 cut->AddCut(GetAnalysisCut("pairPtLow1"));
444 return cut;
445 }
446
447 if (!nameStr.compare("pairJpsiLowPt2")) {
448 cut->AddCut(GetAnalysisCut("pairJpsi"));
449 cut->AddCut(GetAnalysisCut("pairPtLow2"));
450 return cut;
451 }
452
453 delete cut;
454 return nullptr;
455}
o2::aod::dqcuts::GetAnalysisCut
AnalysisCut * GetAnalysisCut(const char *cutName)
Definition: tempCutsLibrary.h:457