KaliVeda
Toolkit for HIC analysis
KVMultiDetArray.cpp
1 //Created by KVClassFactory on Tue Apr 16 09:45:50 2013
2 //Author: John Frankland,,,
3 
4 #include "KVMultiDetArray.h"
5 #include "KVDetector.h"
6 #include "KVDetectorEvent.h"
7 #include "KVReconstructedEvent.h"
8 #include "KVReconstructedNucleus.h"
9 #include "KVRList.h"
10 #include "KVNucleus.h"
11 #include "KVGroup.h"
12 #include "KVMaterial.h"
13 #include "KVTarget.h"
14 #include "KVIDTelescope.h"
15 #include <KVString.h>
16 #include <TObjString.h>
17 #include <TObjArray.h>
18 #include <KVIDGridManager.h>
19 #include <KVDataSetManager.h>
20 #include <KVUpDater.h>
21 #include "TPluginManager.h"
22 #include "KVDataSet.h"
23 #include "TGeoManager.h"
24 #include "KVHashList.h"
25 #include "KVNameValueList.h"
26 #include "KVUniqueNameList.h"
27 #include "KVIonRangeTable.h"
28 #include "KVRangeTableGeoNavigator.h"
29 #include <KVDataAnalyser.h>
30 #include <KVNamedParameter.h>
31 #include <KVCalibrator.h>
32 #include <KVDBParameterSet.h>
33 #ifdef WITH_RSQLITE
34 #include <KVSQLROOTIDGridManager.h>
35 #endif
36 #ifdef WITH_OPENGL
37 #include <TGLViewer.h>
38 #include <TVirtualPad.h>
39 #endif
40 #ifdef WITH_BUILTIN_GRU
41 #include "KVGANILDataReader.h"
42 #else
43 #include "KVRawDataReader.h"
44 #endif
45 #ifdef WITH_MFM
46 #include "KVMFMDataFileReader.h"
47 #include "MFMEbyedatFrame.h"
48 #endif
49 #ifdef WITH_PROTOBUF
50 #include "KVProtobufDataReader.h"
51 #endif
52 using namespace std;
53 
54 KVMultiDetArray* gMultiDetArray = nullptr;
55 
61 
63 
64 
65 
69  : KVGeoStrucElement(), fTrajectories(kTRUE)
70 {
71  // Default constructor
72  init();
73  gMultiDetArray = this;
74 }
75 
76 
77 
80 
82  : KVGeoStrucElement(name, type), fTrajectories(kTRUE)
83 {
84  // Constructor with name and optional type
85  init();
86  gMultiDetArray = this;
87 }
88 
89 
90 
102 
104 {
105  //Basic initialisation called by constructor.
106  //Creates detectors list fDetectors,
107  //groups list fGroups, identification telescopes list
108  //fIDTelescopes
109  //
110  //The fGroups & fIDTelescopes lists contain objects owned by the multidetector array,
111  //but which may be deleted by other objects (or as a result of the deletion of other
112  //objects: i.e. if all the detectors in a group are deleted, the group itself is destroyed).
113  //We use the ROOT automatic garbage collection to make sure that any object deleted
114  //elsewhere is removed automatically from these lists.
115 
116  fIDTelescopes = new KVHashList();
117  fIDTelescopes->SetOwner(kTRUE); // owns its objects
119 
120  fHitGroups = 0;
121 
122  fTarget = 0;
123  fCurrentRun = 0;
124 
126  fCalibStatusDets = 0;
127  fSimMode = kFALSE;
128 
130 
131  fUpDater = 0;
132 
133  if (!gIDGridManager) new KVIDGridManager;
134 
135  // all trajectories belong to us
137 
138  //all detectors belong to us
140 
141  fRawDataReader = nullptr;
142  fHandledRawData = false;
143 
144  // any extra raw data signals created when reading data belong to us
146 }
147 
148 
149 
152 
154 {
155  //destroy (delete) the MDA and all the associated structure, detectors etc.
156 
158  //destroy all identification telescopes
161  delete fIDTelescopes;
162  }
163  fIDTelescopes = 0;
164 
165  if (gMultiDetArray == this)
166  gMultiDetArray = nullptr;
167 
168  if (fStatusIDTelescopes) {
170  delete fStatusIDTelescopes;
172  }
173  if (fCalibStatusDets) {
175  delete fCalibStatusDets;
176  fCalibStatusDets = 0;
177  }
178 
180 }
181 
182 
183 
184 
185 
187 
189 {
190 
191 
192 
193 }
194 
195 
196 
197 
221 
223 {
224  // Create one or more KVIDTelescope particle-identification objects from the two detectors
225  //
226  // The different ID telescopes are defined as 'Plugin' objects in the file $KVROOT/KVFiles/.kvrootrc :
227  // # The KVMultiDetArray::GetIDTelescopes(KVDetector*de, KVDetector*e) method uses these plugins to
228  // # create KVIDTelescope instances adapted to the specific array geometry and detector types.
229  // # For each pair of detectors we look for a plugin with one of the following names:
230  // # [name_of_dataset].array_name.de_detector_type[de detector thickness]-e_detector_type[de detector thickness]
231  // # Each characteristic in [] brackets may or may not be present in the name; first we test for names
232  // # with these characteristics, then all combinations where one or other of the characteristics is not present.
233  // # In addition, we first test all combinations which begin with [name_of_dataset].
234  // # The first plugin found in this order will be used.
235  // # In addition, if for one of the two detectors there is a plugin called
236  // # [name_of_dataset].array_name.de_detector_type[de detector thickness]
237  // # [name_of_dataset].array_name.e_detector_type[e detector thickness]
238  // # then we add also an instance of this 1-detector identification telescope.
239  //
240  // This method is called by DeduceIdentificationTelescopesFromGeometry
241  // in order to set up all ID telescopes of the array.
242  //
243  // \returns number of ID telescopes created
244  // \param[in] de node corresponding to \f$\Delta E\f$ detector; may be nullptr
245  // \param[in] e residual energy detector; always points to valid object
246 
247  assert(e);
248 
249  Int_t ntels = 0;
250 
251  if (fDataSet == "" && gDataSet) fDataSet = gDataSet->GetName();
252 
253  //look for ID telescopes starting from furthest from target
254  if (e->IsOK()) ntels += try_all_singleID_telescopes(e, list);
255  if (de && (de->GetDetector() != e)) {
256  if (e->IsOK() && de->GetDetector()->IsOK()) ntels += try_all_doubleID_telescopes(de->GetDetector(), e, list);
257  if (de->GetDetector()->IsOK()) ntels += try_all_singleID_telescopes(de->GetDetector(), list);
258  }
259 
260  return ntels;
261 }
262 
263 
264 
282 
284 {
285  // Attempt to find a plugin KVIDTelescope class for making a single-detector
286  // ID telescope from detector *d
287  // We look for plugins with the following signatures (uri):
288  //
289  // [array name].[type]
290  // [array_name].[type][thickness]
291  //
292  // where 'type' is the type of the detector in UPPER or lowercase letters
293  // 'thickness' is the nearest-integer thickness of the detector as returned by d->GetThickness()
294  // In addition, if a dataset is set (gDataSet!=nullptr) we try also for dataset-specific
295  // plugins:
296  //
297  // [dataset].[array name].[type]
298  // [dataset].[array name].[type][thickness]
299  //
300  // Returns number of generated telescopes
301 
302  TString uri = Form("%s.%s", GetName(), d->GetType());
303  Int_t ntels = 0;
304  if (!(ntels += try_upper_and_lower_singleIDtelescope(uri, d, l))) {
305  Int_t d_thick = TMath::Nint(d->GetThickness());
306  uri += d_thick;
307  ntels += try_upper_and_lower_singleIDtelescope(uri, d, l);
308  }
309  return ntels;
310 }
311 
312 
313 
314 
337 
339 {
340  // Attempt to find a plugin KVIDTelescope class for making an ID telescope from detectors de & e.
341  // We look for plugins with the following signatures (uri):
342  //
343  // [array name].[de-type]-[e-type]
344  // [array name].[de-type][thickness]-[e-type]
345  // [array name].[de-type]-[e-type][thickness]
346  // [array name].[de-type][thickness]-[e-type][thickness]
347  //
348  // where 'type' is the type of the detector in UPPER or lowercase letters
349  // 'thickness' is the nearest-integer thickness of the detector.
350  // In addition, if a dataset is set (gDataSet!=nullptr) we try also for dataset-specific
351  // plugins:
352  //
353  // [dataset].[array name].[de-type][thickness]-[e-type][thickness]
354  // [dataset].[array name].[de-type][thickness]-[e-type]
355  // [dataset].[array name].[de-type]-[e-type][thickness]
356  // [dataset].[array name].[de-type]-[e-type]
357  //
358  // if no plugin is found, we return a KVIDTelescope base class object
359  //
360  // Returns 1 (we always generate exactly one telescope)
361 
362  TString de_type = de->GetType();
363  TString e_type = e->GetType();
364  TString de_thick = Form("%d", TMath::Nint(de->GetThickness()));
365  TString e_thick = Form("%d", TMath::Nint(e->GetThickness()));
366 
367  TString uri = de_type + de_thick + "-" + e_type + e_thick;
368  uri.Prepend(Form("%s.", GetName()));
369  if (try_upper_and_lower_doubleIDtelescope(uri, de, e, l)) return 1;
370 
371  uri = de_type + de_thick + "-" + e_type;
372  uri.Prepend(Form("%s.", GetName()));
373  if (try_upper_and_lower_doubleIDtelescope(uri, de, e, l)) return 1;
374 
375  uri = de_type + "-" + e_type + e_thick;
376  uri.Prepend(Form("%s.", GetName()));
377  if (try_upper_and_lower_doubleIDtelescope(uri, de, e, l)) return 1;
378 
379  uri = de_type + "-" + e_type;
380  uri.Prepend(Form("%s.", GetName()));
381  if (try_upper_and_lower_doubleIDtelescope(uri, de, e, l)) return 1;
382 
383  // default id telescope object
384  KVIDTelescope* idt = new KVIDTelescope;
385  uri = de_type + "-" + e_type;
386  idt->SetLabel(uri);
387  // set type as "[DEtype]-[Etype]" where "[*type]" is type of DE/E detectors
388  idt->SetType(Form("%s-%s", de_type.Data(), e_type.Data()));
389  set_up_telescope(de, e, idt, l);
390 
391  return 1;
392 }
393 
394 
395 
403 
405 {
406  // Attempt to find a plugin KVIDTelescope class for making a single-detector
407  // ID telescope from detector *d with the given signature/uri
408  // Both original & all-upper-case versions of uri are tried.
409  // uri is tried both with & without prepended dataset name (if set)
410  // Returns true if successful (the new ID telescope will be added to internal
411  // list fIDTelescopes and also to TCollection* l)
412 
413  if (try_a_singleIDtelescope(uri, d, l)) return true;
414  uri.ToUpper();
415  return try_a_singleIDtelescope(uri, d, l);
416 }
417 
418 
419 
426 
428 {
429  // Attempt to find a plugin KVIDTelescope class for making an ID telescope with the given signature/uri
430  // Both original & all-upper-case versions of uri are tried.
431  // uri is tried both with & without prepended dataset name (if set)
432  // Returns true if successful (the new ID telescope will be added to internal
433  // list fIDTelescopes and also to TCollection* l)
434 
435  if (try_a_doubleIDtelescope(uri, de, e, l)) return true;
436  uri.ToUpper();
437  return try_a_doubleIDtelescope(uri, de, e, l);
438 }
439 
440 
441 
450 
452 {
453  // Attempt to find a plugin KVIDTelescope class for making a single-detector
454  // ID telescope from detector *d with the given signature/uri
455  // Both original & all-upper-case versions of uri are tried.
456  // uri is tried both with & without prepended dataset name (if set)
457  // Returns true if successful (the new ID telescope will be added to internal
458  // list fIDTelescopes and also to TCollection* l)
459 
460  // dataset-specific version takes precedence over default
461  TString duri = uri;
462  if (gDataSet) {
463  // try with dataset name
464  duri.Prepend(Form("%s.", fDataSet.Data()));
465  KVIDTelescope* idt;
466  if ((idt = KVIDTelescope::MakeIDTelescope(duri))) {
468  return true;
469  }
470  }
471 
472  // look for default version
473  KVIDTelescope* idt;
474  if ((idt = KVIDTelescope::MakeIDTelescope(uri))) {
476  return true;
477  }
478 
479  return false;
480 }
481 
482 
483 
490 
491 bool KVMultiDetArray::try_a_doubleIDtelescope(TString uri, KVDetector* de, KVDetector* e, TCollection* l)
492 {
493  // Attempt to find a plugin KVIDTelescope class for making an ID telescope with the given signature/uri
494  // uri is tried both with & without prepended dataset name (if set)
495  // Returns true if successful (the new ID telescope will be added to internal
496  // list fIDTelescopes and also to TCollection* l)
497 
498  // dataset-specific version takes precedence over default
499  TString duri = uri;
500  if (gDataSet) {
501  // try with dataset name
502  duri.Prepend(Form("%s.", fDataSet.Data()));
503  KVIDTelescope* idt;
504  if ((idt = KVIDTelescope::MakeIDTelescope(duri))) {
505  set_up_telescope(de, e, idt, l);
506  return true;
507  }
508  }
509  // look for default version
510  KVIDTelescope* idt;
511  if ((idt = KVIDTelescope::MakeIDTelescope(uri))) {
512  set_up_telescope(de, e, idt, l);
513  return true;
514  }
515 
516  return false;
517 }
518 
519 
520 
523 
524 void KVMultiDetArray::set_up_telescope(KVDetector* de, KVDetector* e, KVIDTelescope* idt, TCollection* l)
525 {
526  // Set up detectors in de-e identification telescope and add to fIDTelescopes and to l
527 
528  idt->AddDetector(de);
529  idt->AddDetector(e);
530  if (de->GetGroup()) {
531  idt->SetGroup(de->GetGroup());
532  }
533  else {
534  idt->SetGroup(e->GetGroup());
535  }
536  // if telescope already exists, we delete this new version and add a reference to
537  // the original into list l
539  if (p) {
540  l->Add(p);
541  delete idt;
542  }
543  else {
544  fIDTelescopes->Add(idt);
545  l->Add(idt);
546  }
547 }
548 
549 
550 
553 
555 {
556  // Set up detector in single-stage identification telescope and add to fIDTelescopes and to l
557 
558  idt->AddDetector(det);
559  idt->SetGroup(det->GetGroup());
560  // if telescope already exists, we delete this new version and add a reference to
561  // the original into list l
563  if (p) {
564  l->Add(p);
565  delete idt;
566  }
567  else {
568  fIDTelescopes->Add(idt);
569  l->Add(idt);
570  }
571 }
572 
573 
574 
575 
579 
581 {
582  //Number groups according to position in list fGroups and set fGr counter to the number
583  //of groups in the list
584  Int_t fGr = 0;
585  KVGroup* g = 0;
586  KVSeqCollection* fGroups = GetStructures()->GetSubListWithType("GROUP");
587  TIter next(fGroups);
588  while ((g = (KVGroup*) next())) {
589  g->SetNumber(++fGr);
590  }
591  delete fGroups;
592 }
593 
594 
595 
598 
600 {
601  //Return pointer to DeltaE-E ID Telescope with "name"
602 
604 }
605 
606 
607 
612 
614 {
615  //Reset all groups (lists of detected particles etc.)
616  //and detectors in groups (energy losses, ACQparams etc. etc.)
617  //and the target if there is one
618 
619  unique_ptr<KVSeqCollection> fGroups(GetStructures()->GetSubListWithType("GROUP"));
620 
621  TIter next(fGroups.get());
622  KVGroup* grp;
623  while ((grp = (KVGroup*) next())) {
624  grp->Reset();
625  }
626  if (GetTarget())
627  GetTarget()->Clear();
628 }
629 
630 
631 
632 
638 
640 {
641  // Sets up calibrators for all detectors with a defined calibration for run
642  // Set parameters for all detectors with links to table "Calibrations" for run
643  // If 'myname' is given, we look in "myname.Calibrations"
644 
645  //Reset all calibrators of all detectors first
646  TIter next(GetDetectors());
647  KVDetector* kvd;
648  while ((kvd = (KVDetector*) next())) kvd->RemoveCalibrators();
649 
650  TString tabname = (myname != "" ? Form("%s.Calibrations", myname.Data()) : "Calibrations");
651  //Info("SetCalibratorParameters", "For array %s in table %s", GetName(), tabname.Data());
652  KVRList* run_links = r->GetLinks(tabname);
653  if (run_links) Info("SetCalibratorParameters", "Found %d calibrations for this run", run_links->GetEntries());
654  else {
655 // Warning("SetCalibratorParameters", "Got no links for %s", tabname.Data());
656 // r->GetKeys()->ls();
657  return;
658  }
659  TIter nxt_link(run_links);
660  KVDBParameterSet* dbps;
661  while ((dbps = (KVDBParameterSet*)nxt_link())) {
662 
663  KVDetector* det = GetDetector(dbps->GetName());
664  if (!det) {
665  Warning("SetCalibratorParameters", "Got parameters for unknown detector: %s", dbps->GetName());
666  continue;
667  }
668 
669  KVNameValueList class_options;
670  KVString clop;
671  if (dbps->HasParameter("CalibOptions")) clop = dbps->GetStringParameter("CalibOptions");
672  if (clop != "") {
673  clop.Begin(",");
674  while (!clop.End()) {
675  KVString clopp = clop.Next(true);
676  clopp.Begin("=");
677  KVString par(clopp.Next(true)), val(clopp.Next(true));
678  class_options.SetValue(par, val);
679  }
680  }
682  cal->SetType(dbps->GetTitle());
683  if (clop != "") {
684  try {
685  cal->SetOptions(class_options);
686  }
687  catch (std::exception& e) {
688  Error("SetCalibratorParameters",
689  "Problem for %s [%s] : %s", det->GetName(), cal->GetType(), e.what());
690  delete cal;
691  continue;
692  }
693  }
694  cal->SetInputSignalType(dbps->GetStringParameter("SignalIn"));
695  cal->SetOutputSignalType(dbps->GetStringParameter("SignalOut"));
696  if (!det->AddCalibrator(cal, dbps->GetParameters())) {
697  // Calibrator invalid - probably input signal is not defined for detector
698  // N.B. 'cal' deleted by KVDetector::AddCalibrator
699  continue;
700  }
701 
702  if (dbps->GetParamNumber() > cal->GetNumberParams()) {
703  Warning("SetCalibratorParameters", "Wrong number of parameters (%d) for calibrator %s for detector %s : should be %d",
704  dbps->GetParamNumber(), dbps->GetTitle(), dbps->GetName(), cal->GetNumberParams());
705  dbps->Print();
706  continue;
707  }
708  for (int i = 0; i < dbps->GetParamNumber(); ++i) {
709  if (i >= cal->GetNumberParams())
710  cal->SetParameter(i, 0);
711  else
712  cal->SetParameter(i, dbps->GetParameter(i));
713  }
714  cal->SetStatus(true);
715  }
716 }
717 
718 
719 
737 
739 {
740  // Detector signals corresponding to raw data acquisition parameters are typically only created and
741  // added to detectors when some raw data has been read including those parameters.
742  //
743  // However, when reconstructing data, we may define identification matrices or calibration formulae
744  // which use these signals before starting to read data. Therefore we need to know beforehand what
745  // detector signals are expected to be available once data has been read.
746  //
747  // These are defined, according to detector types, by variables of the form
748  //
749  //~~~~
750  // [dataset].[array].[detector-type].ExpectedDetectorSignals: [comma-separated list of signal names]
751  //~~~~
752  //
753  // where [dataset] is optionally used to provide dataset-specific definitions.
754  //
755  // Here we add a detector signal of each expected type to each detector of the array
756 
757  TIter it(GetDetectors());
758  KVDetector* det;
759  while ((det = (KVDetector*)it())) {
760  KVString s = KVBase::GetDataSetEnv(fDataSet.Data(), Form("%s.%s.ExpectedDetectorSignals", GetName(), det->GetType()), "");
761  if (s.IsNull()) continue;
762  s.Begin(",");
763  while (!s.End()) {
764  det->AddDetectorSignal(s.Next(kTRUE));
765  }
766  }
767 }
768 
769 
770 
781 
783 {
784  // First step in event reconstruction based on current status of detectors in array.
785  // Fills the given KVDetectorEvent with the list of all groups which have fired.
786  // i.e. loop over all groups of the array and test whether KVGroup::Fired() returns true or false.
787  //
788  // If the list of fired detectors 'fired_dets' is given, then we use this list
789  // to find the associated groups. If not given, or if it is empty, we may use the internal fFiredDetectors list.
790  //
791  // Call method detev->Clear() before reading another event in order to reset all of the hit groups
792  // (including all detectors etc.) and emptying the list.
793 
794  if (!fired_dets || !fired_dets->GetEntries()) {
795  if (fFiredDetectors.GetEntries()) fired_dets = &fFiredDetectors;
796  }
797  if (fired_dets && fired_dets->GetEntries()) {
798  // list of fired detectorsgiven
799  TIter next_det(fired_dets);
800  KVDetector* det = 0;
801  KVGroup* grp = 0;
802  while ((det = (KVDetector*)next_det())) {
803  if ((grp = det->GetGroup()) && grp->GetParents()->Contains(this)) detev->AddGroup(grp);
804  }
805  }
806  else {
807  //loop over groups
808  unique_ptr<KVSeqCollection> fGroups(GetStructures()->GetSubListWithType("GROUP"));
809 
810  TIter next_grp(fGroups.get());
811  KVGroup* grp;
812  while ((grp = (KVGroup*) next_grp())) {
813  if (grp->Fired()) {
814  //if (!fHitGroups->FindObject(grp))
815  // grp->Print();
816  //add new group to list of hit groups
817  detev->AddGroup(grp);
818  }
819  }
820  }
821 }
822 
823 
824 
841 
843 {
844  //Static function which will create and 'Build' the multidetector object corresponding to
845  //a given run of dataset 'dataset_name'. Any previously existing multidetector will be
846  //deleted.
847  //We first activate the given dataset if not already done
848  //
849  //Multidetector arrays are defined as 'Plugin' objects in the file $KVROOT/KVFiles/.kvrootrc :
850  //
851  //Plugin.KVMultiDet: [dataset_name] [classname] [library] "[constructor]()"
852  //
853  //The constructors/macros are always without arguments
854  //
855  //Dataset name is stored in fDataSet
856 
857  // store the run number (if given) so that if the dataset needs to update its database
858  // (which requires building the multidetector by calling MakeMultiDetector()) then it
859  // will build the correct geometry for the run
860  if (run > 0) fMakeMultiDetectorRunNumber = run;
862 
863  if (gDataSetManager && (!gDataSet || (gDataSet != gDataSetManager->GetDataSet(dataset_name)))) {
864  printf("Info in <KVMultiDetArray::MakeMultiDetector>: Changing dataset\n");
865  gDataSetManager->GetDataSet(dataset_name)->cd();
866  }
867 
868  if (gMultiDetArray && gMultiDetArray->GetDataSet() != dataset_name) {
869  printf("Info in <KVMultiDetArray::MakeMultiDetector>: Deleting existing array %s\n", gMultiDetArray->GetName());
870  if (gIDGridManager) {
871  delete gIDGridManager;
872  gIDGridManager = nullptr;
873  }
874  delete gMultiDetArray;
875  gMultiDetArray = nullptr;
876  }
877 
878 
879  // Creation of database when dataset is selected for first time may
880  // include creation of multidetector array (by calling this method)
881  KVMultiDetArray* mda = nullptr;
882  if (!gMultiDetArray) {
883  TPluginHandler* ph;
884  if (!(ph = LoadPlugin(classname.Data(), dataset_name)))
885  return nullptr;
886 
887  //execute constructor/macro for multidetector - assumed without arguments
888  mda = (KVMultiDetArray*) ph->ExecPlugin(0);
889  mda->fDataSet = dataset_name;
890  mda->Build(run);
891  // set dataset-dependent lists of acceptable ID/E codes for reconstructed nuclei
892  KVString codes = GetDataSetEnv(dataset_name, Form("%s.ReconstructedNuclei.AcceptIDCodes", mda->GetName()), "");
893  if (codes != "") mda->fAcceptIDCodes.Set(codes);
894  codes = GetDataSetEnv(dataset_name, Form("%s.ReconstructedNuclei.AcceptECodes", mda->GetName()), "");
895  if (codes != "") mda->fAcceptECodes.Set(codes);
896  // set dataset-dependent condition for seeding reconstructed nuclei
897  mda->SetPartSeedCond(GetDataSetEnv(dataset_name, Form("%s.ReconstructedNuclei.ParticleSeedCond", mda->GetName()), ""));
898 #ifdef WITH_RSQLITE
899  // save contents of grid manager in an SQL-ROOT database if not already done
900  if (fMakeMultiDetectorSetParameters && !gIDGridManager->IsSQLROOT()) {
901  // 'if(fMakeMultiDetectorSetParameters...' ensures that we are not currently building a subarray
902  // of a KVExpSetUp. Grids can only be saved once in a single file after all have been read.
903  TString filepath;
904  if (is_gnuinstall()) {
905  // GNU-style install: use working directory $HOME/.kaliveda
906  filepath = GetWORKDIRFilePath(gDataSet->GetName());
907  }
908  else
909  filepath = gDataSet->GetDataSetDir();
910 
911  filepath += "/idgrids_DB";
912 
913  int n_grids_to_write = gIDGridManager->GetGrids()->GetEntries();
914 
915  // we retrieve the index multiplier for the dataset in case it is >1,
916  // we use it to "correct" the runlists for the grids
917  auto index_multiplier = gDataSet->GetDataSetEnv("DataSet.RunFileIndexMultiplier.raw", 1);
918 
919  // we also set the runlist for any grids which don't have one, to the runlist of the entire dataset.
920  // in other words, grids with no runlist are considered valid for all runs
921  if (n_grids_to_write) {
922  KVSQLROOTFile f(filepath, "recreate");
923 
924  printf("Info in <KVMultiDetArray::MakeMultiDetector>: Saving %d grids in SQL-ROOT database file %s\n",
925  n_grids_to_write, filepath.Data());
926 
927  TIter it(gIDGridManager->GetGrids());
928  KVIDGraph* gr;
929  if(!db) db = gExpDB;
930  while ((gr = (KVIDGraph*)it())) {
931  // self-consistently modify runlist if necessary
932  auto rl = gr->GetRuns().GetListDividedBy(index_multiplier);
933  if(rl.IsEmpty() && db) rl = db->GetRunList();
934  gr->SetRuns(rl);
935  f.WriteObject(gr, {
936  {"IDLabel", gr->GetIDTelescopeLabel()},
937  {"IDTelescopes", gr->GetParameters()->GetStringValue("IDTelescopes")},
938  {"VarX", gr->GetVarX()},
939  {"VarY", gr->GetVarY()},
940  {"Runlist", gr->GetRunList()},
941  }
942  );
943  --n_grids_to_write;
944  if (!(n_grids_to_write % 1000)) printf("Info in <KVMultiDetArray::MakeMultiDetector>: ...%d grids left...\n",
945  n_grids_to_write);
946 
947  }
948  }
949  }
950 #endif
951  }
952  else {
953  mda = gMultiDetArray;
954  }
955  // set parameters if required & allowed & not done yet
957  return mda;
958 }
959 
960 
961 
973 
975 {
976  // Return pointer to KVUpDater defined by dataset for this multidetector, the class used
977  // is defined as a plugin like this:
978  //
979  // # Plugin.KVUpDater: name_of_dataset name_of_class name_of_plugin_library constructor_to_call
980  //
981  // However, if a dataset defines a variable like this:
982  //
983  // [dataset].ExpSetUp.Updater.[multidetector name]: [name_of_dataset for plugin]
984  //
985  // then we use the updater plugin defined for the given dataset
986 
987  if (!fUpDater) {
988  KVString alt_updater = KVBase::GetDataSetEnv(fDataSet, Form("ExpSetUp.Updater.%s", GetName()), "");
989  if (alt_updater != "") fUpDater = KVUpDater::MakeUpDater(alt_updater, this);
991  }
992  Info("GetUpDater", "updater class for dataset %s: %s", fDataSet.Data(), fUpDater->IsA()->GetName());
993  return fUpDater;
994 }
995 
996 
997 
998 
1007 
1008 void KVMultiDetArray::SetParameters(UInt_t run, Bool_t physics_parameters_only)
1009 {
1010  // Set run-dependent parameters of the array.
1011  //
1012  // if physics_parameters_only==false, identification and calibration parameters are set.
1013  // if physics_parameters_only==true, just the minimum necessary for physics analysis of reduced data are set.
1014  //
1015  // This can only be done if gDataSet has been set i.e. a dataset has been chosen,
1016  // otherwise this just has the effect of setting the current run number
1017 
1018  fCurrentRun = run;
1019  KVDataSet* ds = gDataSet;
1020  if (!ds) {
1021  if (gDataSetManager)
1022  ds = gDataSetManager->GetDataSet(fDataSet.Data());
1023  }
1024  if (ds) {
1025  GetUpDater()->SetParameters(run, physics_parameters_only);
1026  SetBit(kParamsSet);
1027  }
1028 }
1029 
1030 
1031 
1032 
1037 
1039 {
1040  //Set identification parameters for run.
1041  //This can only be done if gDataSet has been set i.e. a dataset has been chosen
1042  //Otherwise this just has the effect of setting the current run number
1043 
1044  fCurrentRun = run;
1045  KVDataSet* ds = gDataSet;
1046  if (!ds) {
1047  if (gDataSetManager)
1048  ds = gDataSetManager->GetDataSet(fDataSet.Data());
1049  }
1050  if (ds) {
1053  }
1054 }
1055 
1056 
1057 
1058 
1063 
1065 {
1066  //Set calibration parameters for run.
1067  //This can only be done if gDataSet has been set i.e. a dataset has been chosen
1068  //Otherwise this just has the effect of setting the current run number
1069 
1070  fCurrentRun = run;
1071  KVDataSet* ds = gDataSet;
1072  if (!ds) {
1073  if (gDataSetManager)
1074  ds = gDataSetManager->GetDataSet(fDataSet.Data());
1075  }
1076  if (ds) {
1079  }
1080 }
1081 
1082 
1083 
1084 
1101 
1103 {
1104  //Initialisation of all ACTIVE identification telescopes in the array, i.e. those appearing in a line
1105  //in the .kvrootrc file such as this:
1106  //
1107  //# [dataset name].ActiveIdentifications: [type1] [type2] ...
1108  //
1109  //The 'types' given correspond to the value given by KVIDTelescope::GetLabel(), these are the
1110  //identifiers used to retrieve the different plugin classes in GetIDTelescopes(KVDetector*,KVDetector*,KVList*).
1111  //
1112  //For each type of identification in the list, we retrieve the first identification telescope with this
1113  //label from the list of all ID telescopes, in order to call its KVIDTelescope::SetIdentificationParameters() method.
1114  //This method (when rederived in child classes of KVIDTelescope) initialises the identification objects
1115  //for ALL of the ID telescopes of the same type (class) in the array.
1116  //
1117  //Note that, in general, the parameters of the identifications for a given run are not
1118  //set until SetParameters or SetRunIdentificationParameters is called.
1119 
1120 #ifdef WITH_RSQLITE
1121  // if a KVSQLROOTFile has been filled with the dataset identification parameters we use it.
1122  if (gIDGridManager->IsSQLROOT()) {
1123  // nothing more to do
1124  return;
1125  }
1126  else if (!gDataSet->DataBaseUpdateInProgress())
1127  // the update of the database may have been caused by 1 or more identification files being modified
1128  // (even if they are not part of the database). in this case we read in all the grids again even
1129  // if it has already been done before.
1130  {
1131  TString filepath;
1132  if (is_gnuinstall()) {
1133  // GNU-style install: use working directory $HOME/.kaliveda
1134  filepath = GetWORKDIRFilePath(gDataSet->GetName());
1135  }
1136  else
1137  filepath = gDataSet->GetDataSetDir();
1138 
1139  filepath += "/idgrids_DB";
1140 
1141  if (SearchKVFile(filepath.Data(), filepath)) {
1142  delete gIDGridManager;
1143  gIDGridManager = new KVSQLROOTIDGridManager(filepath);
1144  return;
1145  }
1146  }
1147 #endif
1148 
1149  KVString id_labels = GetDataSetEnv(fDataSet, "ActiveIdentifications", "");
1150  if (id_labels == "" || (gDataSet && !gDataSet->HasCalibIdentInfos())) {
1151  Info("SetIdentifications", "No active identifications");
1152  return;
1153  }
1154  //split list of labels
1155  id_labels.Begin(" ");
1156  int ok(0);
1157  //loop over labels/identification 'types'
1158  while (!id_labels.End()) {
1159 
1160  //get first telescope in list with right label
1162  //set ID parameters for all telescopes of this 'type'
1163  if (idt) {
1164  Info("SetIdentifications", "Initialising %s identifications...", idt->GetLabel());
1165  if (idt->SetIdentificationParameters(this))
1166  Info("SetIdentifications", "OK");
1167  ++ok;
1168  }
1169 
1170  }
1171  if (!ok) {
1172  // None of the labels in the list correspond to telescopes in the array
1173  Warning("SetIdentfications", "No telescopes found with labels given in %s.ActiveIdentifications list: %s",
1174  gDataSet->GetName(), id_labels.Data());
1175  }
1176 }
1177 
1178 
1179 
1180 
1187 
1189 {
1190  // Calls Initialize() method of each identification telescope (see KVIDTelescope
1191  // and derived classes) and sets the general identification code defined for each
1192  // telescope.
1193  //
1194  // Calling this method is essential before identification of particles is attempted.
1195 
1196  TIter next(fIDTelescopes);
1197  KVIDTelescope* idt;
1198  while ((idt = (KVIDTelescope*)next())) {
1199  idt->Initialize();
1201  }
1202 }
1203 
1204 
1205 
1216 
1218 {
1219  // Read all identification grids from the file and add them to the IDGridManager object
1220  // used by this array. This method sets up the links between each grid and the
1221  // IDtelescope(s) it is to be used for, unlike calling
1222  //
1223  // gIDGridManager->ReadAsciiFile(grids)
1224  //
1225  // which does not.
1226  //
1227  // Returns kFALSE if there is a problem reading the file
1228 
1229  if (gIDGridManager->ReadAsciiFile(grids)) {
1230  TIter next(gIDGridManager->GetLastReadGrids());
1231  KVIDGraph* gr;
1232  while ((gr = (KVIDGraph*)next())) FillListOfIDTelescopes(gr);
1233  return kTRUE;
1234  }
1235  return kFALSE;
1236 }
1237 
1238 
1239 
1240 
1244 
1246 {
1247  // Print full status report on ID telescopes in array, using informations stored in
1248  // fStatusIDTelescopes (see GetStatusOfIDTelescopes).
1249 
1250  cout << endl << "-----STATUS OF IDENTIFICATION TELESCOPES";
1251  if (GetCurrentRunNumber()) cout << " FOR RUN "
1252  << GetCurrentRunNumber();
1253  cout << "------" << endl << endl;
1254  //get list of active telescopes
1255  KVString id_labels;
1256  if (gDataSet) id_labels = gDataSet->GetDataSetEnv("ActiveIdentifications");
1257  else {
1258  unique_ptr<KVUniqueNameList> typelist(GetIDTelescopeTypes());
1259  TIter it(typelist.get());
1260  TObjString* type;
1261  while ((type = (TObjString*)it())) {
1262  if (id_labels == "") id_labels += type->GetString().Data();
1263  else {
1264  id_labels += Form(" %s", type->GetString().Data());
1265  }
1266  }
1267  }
1268  if (id_labels == "") {
1269  cout << " *** No active identifications *** " << endl;
1270  return;
1271  }
1272  // iterate over labels
1273  unique_ptr<TObjArray> toks(id_labels.Tokenize(' '));
1274 
1275  //update status infos
1277 
1278  TIter next_type(fStatusIDTelescopes);
1279  TList* id_type_list = 0;
1280  while ((id_type_list = (TList*)next_type())) {
1281 
1282  cout << " *** " << id_type_list->GetName() << " Identifications -------------------" << endl;
1283  if (!toks->FindObject(id_type_list->GetName())) {
1284  cout << " [NOT ACTIVE]" << endl;
1285  }
1286  TList* ok_list = (TList*)id_type_list->FindObject("OK");
1287  TList* notok_list = (TList*)id_type_list->FindObject("NOT OK");
1288  TList* print_list = 0;
1289  Int_t Nok = ok_list->GetEntries();
1290  Int_t Notok = notok_list->GetEntries();
1291  if (Nok && Notok) {
1292  if (Nok < Notok) print_list = ok_list;
1293  else print_list = notok_list;
1294  }
1295  if (Nok && (!Notok)) cout << " ALL telescopes are OK" << endl;
1296  else if (Notok && (!Nok)) cout << " NO telescopes are OK" << endl;
1297  else {
1298  cout << " " << ok_list->GetEntries() << " telescopes are OK, "
1299  << notok_list->GetEntries() << " telescopes are NOT OK" << endl;
1300  cout << " " << print_list->GetName() << " :" << endl;
1301  TIter it(print_list);
1302  TObject* ob = it();
1303  cout << ob->GetName();
1304  while ((ob = it())) cout << "," << ob->GetName();
1305  cout << endl;
1306  }
1307  cout << endl;
1308 
1309  }
1310 }
1311 
1312 
1313 
1314 
1322 
1324 {
1325  // Fill and return pointer to list fStatusIDTelescopes which contains
1326  // a list for each type of ID telescope in the array, each list contains a list
1327  // "OK" with the ID telescopes which have IsReadyForID()=kTRUE, and
1328  // a list "NOT OK" with the others.
1329  //
1330  // The returned TList object must not be deleted (it belongs to the KVMultiDetArray).
1331 
1332  if (!fStatusIDTelescopes) {
1333  fStatusIDTelescopes = new TList;
1335  }
1336  else {
1338  }
1340  TIter next(fIDTelescopes);
1341  KVIDTelescope* idt = 0;
1342  while ((idt = (KVIDTelescope*)next())) {
1343 
1344  TString id_type = idt->GetLabel();
1345  TList* id_type_list = (TList*)fStatusIDTelescopes->FindObject(id_type.Data());
1346  if (!id_type_list) {
1347  id_type_list = new TList;
1348  id_type_list->SetOwner(kTRUE);
1349  id_type_list->SetName(id_type.Data());
1350  fStatusIDTelescopes->Add(id_type_list);
1351  id_type_list->Add(new TList);
1352  ((TList*)id_type_list->At(0))->SetName("OK");
1353  id_type_list->Add(new TList);
1354  ((TList*)id_type_list->At(1))->SetName("NOT OK");
1355  }
1356  if (idt->IsReadyForID())
1357  ((TList*)id_type_list->FindObject("OK"))->Add(idt);
1358  else
1359  ((TList*)id_type_list->FindObject("NOT OK"))->Add(idt);
1360  }
1361  return fStatusIDTelescopes;
1362 }
1363 
1364 
1365 
1366 
1372 
1374 {
1375  // Create, fill and return pointer to a list of TObjString containing the name of each type
1376  // of ID telescope (actually the label) in the array.
1377  //
1378  // Delete the list after use (it owns the TObjString objects)
1379 
1380  KVUniqueNameList* type_list = new KVUniqueNameList(kTRUE);
1381  type_list->SetOwner();
1382  if (!fIDTelescopes || !fIDTelescopes->GetEntries()) return type_list;
1383  TIter next(fIDTelescopes);
1384  KVIDTelescope* idt = 0;
1385  while ((idt = (KVIDTelescope*)next())) {
1386  type_list->Add(new TObjString(idt->GetLabel()));
1387  }
1388  return type_list;
1389 }
1390 
1391 
1392 
1393 
1401 
1403 {
1404  // Create, fill and return pointer to a list of KVIDTelescopes with
1405  // the given type (label) in the array.
1406  // WARNING! - check pointer is not zero (we return NULL if ID telescopes
1407  // list is not defined or empty)
1408  //
1409  // Delete the KVList after use (it does not own the KVIDTelescopes).
1410 
1411  if (!fIDTelescopes || !fIDTelescopes->GetEntries()) return NULL;
1413 }
1414 
1415 
1416 
1417 
1425 
1427 {
1428  // Fill and return pointer to list fCalibStatusDets which contains
1429  // a list for each type of detector in the array, each list contains a list
1430  // "OK" with the detectors which are calibrated, and
1431  // a list "NOT OK" with the others.
1432  //
1433  // The returned TList object must not be deleted (it belongs to the KVMultiDetArray).
1434 
1435  if (!fCalibStatusDets) {
1436  fCalibStatusDets = new TList;
1438  }
1439  else {
1441  }
1442  if (!GetDetectors()->GetEntries()) return fCalibStatusDets;
1443  TIter next(GetDetectors());
1444  KVDetector* det = 0;
1445  while ((det = (KVDetector*)next())) {
1446 
1447  TString type = det->GetType();
1448  TList* type_list = (TList*)fCalibStatusDets->FindObject(type.Data());
1449  if (!type_list) {
1450  type_list = new TList;
1451  type_list->SetOwner(kTRUE);
1452  type_list->SetName(type.Data());
1453  fCalibStatusDets->Add(type_list);
1454  type_list->Add(new TList);
1455  ((TList*)type_list->At(0))->SetName("OK");
1456  type_list->Add(new TList);
1457  ((TList*)type_list->At(1))->SetName("NOT OK");
1458  }
1459  if (det->IsCalibrated())
1460  ((TList*)type_list->FindObject("OK"))->Add(det);
1461  else
1462  ((TList*)type_list->FindObject("NOT OK"))->Add(det);
1463  }
1464  return fCalibStatusDets;
1465 }
1466 
1467 
1468 
1469 
1473 
1475 {
1476  // Print full status report on calibration of detectors in array, using informations stored in
1477  // fCalibStatusDets (see GetCalibrationStatusOfDetectors).
1478 
1479  if (!GetCurrentRunNumber()) {
1480  Info("PrintCalibStatusOfDetectors", "Cannot know status without knowing RUN NUMBER");
1481  return;
1482  }
1483 
1484  cout << endl << "-----------STATUS OF CALIBRATIONS FOR RUN "
1485  << GetCurrentRunNumber() << "------------" << endl << endl;
1486 
1487  //update status infos
1489 
1490  TIter next_type(fCalibStatusDets);
1491  TList* id_type_list = 0;
1492  while ((id_type_list = (TList*)next_type())) {
1493 
1494  cout << " *** " << id_type_list->GetName() << " Detectors -------------------" << endl;
1495  TList* ok_list = (TList*)id_type_list->FindObject("OK");
1496  TList* notok_list = (TList*)id_type_list->FindObject("NOT OK");
1497  TList* print_list = 0;
1498  Int_t Nok = ok_list->GetEntries();
1499  Int_t Notok = notok_list->GetEntries();
1500  if (Nok && Notok) {
1501  if (Nok < Notok) print_list = ok_list;
1502  else print_list = notok_list;
1503  }
1504  if (Nok && (!Notok)) cout << " ALL calibrations are OK" << endl;
1505  else if (Notok && (!Nok)) cout << " NO calibrations are OK" << endl;
1506  else {
1507  cout << " " << ok_list->GetEntries() << " calibrations are OK, "
1508  << notok_list->GetEntries() << " calibrations are NOT OK" << endl;
1509  cout << " " << print_list->GetName() << " :" << endl;
1510  TIter it(print_list);
1511  TObject* ob = it();
1512  cout << ob->GetName();
1513  while ((ob = it())) cout << "," << ob->GetName();
1514  cout << endl;
1515  }
1516  cout << endl;
1517 
1518  }
1519 }
1520 
1521 
1522 
1523 
1539 
1541 {
1542  // Calculate the energy loss in the current target of the multidetector
1543  // for the reconstructed charged particle 'ion', assuming that the current
1544  // energy and momentum of this particle correspond to its state on
1545  // leaving the target.
1546  //
1547  // WARNING: for this correction to work, the target must be in the right 'state':
1548  //
1549  // gMultiDetArray->GetTarget()->SetIncoming(kFALSE);
1550  // gMultiDetArray->GetTarget()->SetOutgoing(kTRUE);
1551  //
1552  // (see KVTarget::GetParticleEIncFromERes).
1553  //
1554  // The returned value is the energy lost in the target in MeV.
1555  // The energy/momentum of 'ion' are not affected.
1556 
1557  if (fTarget && ion) return (fTarget->GetParticleEIncFromERes(ion) - ion->GetEnergy());
1558  return 0;
1559 }
1560 
1561 
1562 
1563 
1566 
1568 {
1569  // Return pointer to the (ROOT) geometry of the array.
1570  return gGeoManager;
1571 }
1572 
1573 
1574 
1576 
1578 {
1579  return fNavigator.get();
1580 }
1581 
1582 
1583 
1602 
1604 {
1605  // Actual thicknesses of detectors can be given in one or more files associated with a dataset/multidetector.
1606  //
1607  // We look for the first of the files
1608  //~~~~
1609  //[array_name].DetectorThicknessFiles.dat
1610  //DetectorThicknessFiles.dat
1611  //~~~~
1612  // which exists for the current dataset, and if found we read each file listed in it.
1613  //
1614  // Otherwise we look for the first of the files
1615  //~~~~
1616  //[array_name].DetectorThicknesses.dat
1617  //DetectorThicknesses.dat
1618  //~~~~
1619  // which exists for the current dataset, and if found we read the thicknesses from it.
1620  //
1621  // See set_detector_thicknesses() for details of the format of the individual thickness files.
1622 
1623  auto find_a_file = [this](const TString& _base_filename)
1624  {
1625  TString filename = TString(GetName()) + "." + _base_filename;
1626  TString fullpath;
1629 
1630  filename = _base_filename;
1633 
1634  return TString();
1635  };
1636 
1637  // look for list of files
1638  auto fullpath = find_a_file("DetectorThicknessFiles.dat");
1639  if(!fullpath.IsNull())
1640  {
1641  KVFileReader fr;
1642  fr.OpenFileToRead(fullpath);
1643  while (fr.IsOK()) {
1644  fr.ReadLine(0);
1645  if (fr.GetCurrentLine().BeginsWith("#") || fr.GetCurrentLine() == "") continue;
1647  }
1648  return;
1649  }
1650 
1651  // look for single file
1652  fullpath = find_a_file("DetectorThicknesses.dat");
1653  if(!fullpath.IsNull()) set_detector_thicknesses(fullpath);
1654 }
1655 
1656 
1657 
1676 
1678 {
1679  // Use file given by fullpath to set the real thicknesses of the detectors.
1680  // Any detector which is not in the file will be left with its nominal thickness.
1681  //
1682  // EXAMPLE FILE:
1683  //
1684  //# thickness of detector DET01 in default units
1685  //DET01: 56.4627
1686  //
1687  //# DET03 has several layers
1688  //DET03.Abs0: 61.34
1689  //DET03.Abs1: 205.62
1690  //
1691  // !!! WARNING !!!
1692  // Single-layer detectors: The units are those defined by default for the detector's
1693  // Get/SetThickness methods.
1694  // Multi-layer: Each layer is a KVMaterial object. The thickness MUST be given in centimetres
1695  // (default thickness unit for KVMaterial).
1696 
1697  TEnv thickdat;
1698  if (thickdat.ReadFile(fullpath, kEnvUser) != 0) {
1699  Error("SetDetectorThicknesses", "Problem opening file %s", fullpath.Data());
1700  return;
1701  }
1702  Info("SetDetectorThicknesses", "Setting thicknesses of detectors from file %s", fullpath.Data());
1703  TIter next(GetDetectors());
1704  KVDetector* det;
1705  while ((det = (KVDetector*)next())) {
1706  if (thickdat.Defined(det->GetName())) {
1707  // simple single layer detector
1708  Double_t thick = thickdat.GetValue(det->GetName(), 0.0);
1709  det->SetThickness(thick);
1710  //Info("SetDetectorThicknesses", "Set thickness of %s to %f", det->GetName(), thick);
1711  }
1712  else {
1713  Char_t i = 0;
1714  TString absname;
1715  absname.Form("%s.Abs%d", det->GetName(), (Int_t)i);
1716  if (thickdat.Defined(absname.Data())) {
1717  // detector with several layers
1718  KVMaterial* abs = 0;
1719  while ((abs = det->GetAbsorber(i))) {
1720  Double_t thick = thickdat.GetValue(absname.Data(), 0.0);
1721  abs->SetThickness(thick);
1722  //Info("SetDetectorThicknesses", "Set thickness of %s.Abs%d to %f", det->GetName(), (Int_t)i, thick);
1723  i++;
1724  absname.Form("%s.Abs%d", det->GetName(), (Int_t)i);
1725  if (!thickdat.Defined(absname.Data())) break;
1726  }
1727  }
1728  }
1729  }
1730 }
1731 
1732 
1733 
1742 
1744 {
1745  // Called by KVGeoImport::ImportGeometry
1746  //
1747  // Creates KVRangeTableGeoNavigator for calculating energy losses of
1748  // particles propagated through array.
1749  //
1750  // If no name and/or title are defined for the array, the name and title of the TGeoManager
1751  // object will be used for the array.
1752 
1753  if (!strcmp(GetName(), "")) SetName(g->GetName());
1754  if (!strcmp(GetTitle(), "")) SetTitle(g->GetTitle());
1756 }
1757 
1758 
1759 
1788 
1790 {
1791  // Method for positioning volumes in detector geometries
1792  //
1793  // Given:
1794  //
1795  // distance [cm] = distance from target (origin) to the CENTRE of the volume in position
1796  // theta [deg] = polar angle of vector from target to centre of volume in position
1797  // phi [deg] = azimuthal angle of vector
1798  //
1799  // this method generates the matrix which is required to position the volume as required
1800  // while also turning the volume so that the side nearest the target (i.e. the entrance
1801  // window of the detector) remains perpendicular to the vector joining the origin and
1802  // the centre of the volume.
1803  //
1804  // If required, a further translation can be given which will be applied to the volume after
1805  // it has been placed with the required orientation at the nominal distance. This can be used
1806  // e.g. for detector misalignment, when detectors are in a structure which guarantees their line
1807  // of sight to be orthogonal to their surface at a nominal distance, but the nominal distance
1808  // is not respected.
1809  //
1810  // Example of use:
1811  //
1812  //~~~~~~~~~~~~
1813  // TGeoVolume* vol;// volume to be positioned
1814  // double depth = vol->GetShape()->GetDZ(); // half-width of volume in direction of target
1815  // // place front of volume at 100cm, with theta=45 deg. and phi=60 deg.
1816  // gGeoManager->GetTopVolume()->AddNode(vol, 1, KVMultiDetArray::GetVolumePositioningMatrix(100+depth,45,60));
1817  //~~~~~~~~~~~~
1818 
1819  TGeoRotation rot;
1820  TGeoTranslation trans;
1821  rot.SetAngles(phi + 90, theta, -90) ;
1822  trans.SetDz(distance) ;
1823  TGeoHMatrix h;
1824  if (postTrans) h = (*postTrans) * rot * trans ;
1825  else h = rot * trans;
1826  TGeoHMatrix* ph = new TGeoHMatrix(h);
1827  return ph;
1828 }
1829 
1830 
1831 
1832 
1836 
1838 {
1839  // For each grid which is valid for this run, we call the KVIDTelescope::SetIDGrid method
1840  // of each associated ID telescope.
1841 
1842  if (gIDGridManager->IsSQLROOT()) {
1843  gIDGridManager->LoadGridsForRun(run);
1844  }
1845 
1846  TIter next(gIDGridManager->GetGrids());
1847  KVIDGraph* gr = 0;
1848  while ((gr = (KVIDGraph*) next())) {
1849  if (!gIDGridManager->IsSQLROOT()) {
1850  if (!gr->GetRuns().Contains((Int_t) run))
1851  continue;
1852  }
1853  else
1855 
1856  TIter nxtid(gr->GetIDTelescopes());
1857  KVIDTelescope* idt;
1858  while ((idt = (KVIDTelescope*) nxtid())) {
1859  idt->SetIDGrid(gr);
1860  }
1861  }
1862 }
1863 
1864 
1868 
1870 {
1871  // Fill list of ID telescopes with which this grid is associated
1872  // from list of names read from ascii file.
1873 
1874  gr->ClearListOfTelescopes();
1875  if (gr->GetParameters()->HasParameter("IDTelescopes")) {
1876  KVString tel_list = gr->GetParameters()->GetStringValue("IDTelescopes");
1877  tel_list.Begin(",");
1878  while (!tel_list.End()) {
1879  TString tel_name = tel_list.Next();
1880  KVIDTelescope* idt = GetIDTelescope(tel_name.Data()) ;
1881  if (idt) gr->AddIDTelescope(idt);
1882  }
1883  }
1884 }
1885 
1886 
1887 
1897 
1899 {
1900  // Use OpenGL viewer to view multidetector geometry
1901  //
1902  // If option="tracks" we draw any tracks corresponding to the last simulated
1903  // event whose detection was simulated with DetectEvent
1904  // If option="tracks:[numberlist]" with a list of numbers,
1905  // it will be interpreted as a KVNumberList containing the Z of tracks to be drawn
1906  // e.g. option="tracks:1-92" draw only tracks with 1<=Z<=92 (no neutrons)
1907  // option="tracks:2" draw only helium isotopes
1908 
1909  GetGeometry()->GetTopVolume()->Draw("ogl");
1910  KVString opt(option);
1911  opt.Begin(":");
1912  if (opt.Next() == "tracks") {
1913  if (!opt.End()) {
1914  KVNumberList zlist(opt.Next());
1915  GetNavigator()->DrawTracks(&zlist);
1916  }
1917  else
1918  GetNavigator()->DrawTracks();
1919  }
1920 #ifdef WITH_OPENGL
1921  TGLViewer* view = (TGLViewer*)gPad->GetViewer3D();
1924  view->SetSmoothLines(kTRUE);
1925  view->SetSmoothPoints(kTRUE);
1926 #endif
1927 }
1928 
1929 
1930 
1932 
1934 {
1935  fNavigator.reset(geo);
1936 }
1937 
1938 
1939 
1944 
1946 {
1947  // Create TH2F histograms for all IDTelescopes of the array
1948  // They will be added to the list
1949  // histograms will have resolution of dimension*dimension
1950 
1952  KVIDTelescope* idt;
1953  while ((idt = (KVIDTelescope*)it())) {
1954  TString name(idt->GetName());
1955  name.ReplaceAll("-", "_");
1956  list->Add(new TH2F(name, Form("Hits in %s", idt->GetName()), dimension, 0., 0., dimension, 0., 0.));
1957  }
1958 }
1959 
1960 
1961 
1964 
1966 {
1967  // Fill TH2F histograms for all IDTelescopes of the array
1968 
1970  KVIDTelescope* idt;
1971  while ((idt = (KVIDTelescope*)it())) {
1972  TString name(idt->GetName());
1973  name.ReplaceAll("-", "_");
1974  TH2F* h = (TH2F*)list->FindObject(name);
1975  if (h) h->Fill(idt->GetIDMapX(), idt->GetIDMapY());
1976  }
1977 }
1978 
1979 
1980 
1983 
1985 {
1986  // Modify the transparency of detector volumes in OpenGL view
1987 
1988  TIter itV(GetGeometry()->GetListOfVolumes());
1989  TGeoVolume* vol;
1990  while ((vol = (TGeoVolume*)itV())) vol->SetTransparency(t);
1991 }
1992 
1993 
1994 
1998 
2000 {
2001  // Calculate all possible (sub-)trajectories
2002  // for particle reconstruction (GetReconTrajectories())
2003 
2004  unique_ptr<KVSeqCollection> groups(GetStructureTypeList("GROUP"));
2005  TIter it(groups.get());
2006  KVGroup* group;
2007  Int_t ntr = 0;
2008  Info("CalculateReconstructionTrajectories", "Calculating trajectories for particle reconstruction:");
2010  std::cout << "\xd" << " -- calculated " << ntr << " reconstruction trajectories" << std::flush;
2011  while ((group = (KVGroup*)it())) {
2012  ntr += group->CalculateReconstructionTrajectories();
2014  std::cout << "\xd" << " -- calculated " << ntr << " reconstruction trajectories" << std::flush;
2015  }
2017  std::cout << " -- calculated " << ntr << " reconstruction trajectories" << std::endl;
2018  else
2019  std::cout << std::endl;
2020 }
2021 
2022 
2023 
2028 
2030 {
2031  // Track over all possible particle trajectories calling GetIDTelescopes(KVDetector*,KVDetector*)
2032  // for each pair of (present & functioning) detectors.
2033  // This will create all possible KVIDTelescope identification objects and put them in list fIDTelescopes
2034 
2035  fIDTelescopes->Delete();
2036  TIter next_traj(GetTrajectories());
2037  KVGeoDNTrajectory* traj;
2038  Int_t count = 0;
2039  Info("DeduceIdentificationTelescopesFromGeometry", "Calculating...");
2041  std::cout << "\xd" << " -- created " << count << " telescopes" << std::flush;
2042  while ((traj = (KVGeoDNTrajectory*)next_traj())) { // loop over all trajectories
2043 
2044  traj->IterateFrom(); // from furthest-out to closest-in detector
2045 
2047  while ((N = traj->GetNextNode())) {
2048  KVGeoDetectorNode* Nplus1 = traj->GetNodeInFront(N);
2049  count += GetIDTelescopes(Nplus1, N->GetDetector(), traj->AccessIDTelescopeList());
2051  std::cout << "\xd" << " -- created " << count << " telescopes" << std::flush;
2052  }
2053  }
2055  std::cout << " -- created " << count << " telescopes" << std::endl;
2056  else
2057  std::cout << std::endl;
2058 }
2059 
2060 
2061 
2065 
2067 {
2068  // Eliminate any trajectories which are just sub-trajectories of others
2069  // For each trajectory in list fTrajectories, we add a reference to the trajectory to each node on the trajectory
2070 
2071  TIter it(&fTrajectories);
2072  KVGeoDNTrajectory* tr;
2073  KVList duplicates;
2074  // look for duplicate sub-trajectories
2075  while ((tr = (KVGeoDNTrajectory*)it())) {
2076  int len_tr = tr->GetN();
2077  TIter it2(&fTrajectories);
2078  KVGeoDNTrajectory* tr2;
2079  while ((tr2 = (KVGeoDNTrajectory*)it2())) {
2080  if ((tr2 != tr) && (len_tr < tr2->GetN()) && (tr2->ContainsPath(tr))) {
2081  duplicates.Add(tr);
2082  break;
2083  }
2084  }
2085  }
2086  // remove duplicates
2087  if (duplicates.GetEntries()) {
2088  TIter it_dup(&duplicates);
2089  while ((tr = (KVGeoDNTrajectory*)it_dup())) {
2090  fTrajectories.Remove(tr);
2091  }
2092  Info("AssociateTrajectoriesAndNodes", "Removed %d duplicated sub-trajectories", duplicates.GetEntries());
2093  }
2094  Info("AssociateTrajectoriesAndNodes", "Calculated %d particle trajectories", fTrajectories.GetEntries());
2095  it.Reset();
2096  while ((tr = (KVGeoDNTrajectory*)it())) {
2097  tr->AddToNodes();
2098  }
2099 }
2100 
2101 
2102 
2104 
2106 {
2107  if (N->GetNTraj() > 1) {
2108  if (!multitraj_nodes.FindObject(N)) { // look for any detectors which are on multiple trajectories
2109  //cout << "multitraj node found: " << N->GetName() << " (" << N->GetNTraj() << ")" << endl;
2110  multitraj_nodes.Add(N);
2111  TIter tr(N->GetTrajectories());
2112  KVGeoDNTrajectory* traj;
2113  while ((traj = (KVGeoDNTrajectory*)tr())) { // for each trajectory associated with detector
2114  if (tried_trajectories.FindObject(traj)) continue; // trajectory already used
2115  tried_trajectories.Add(traj);
2116  traj->IterateFrom();
2117  KVGeoDetectorNode* node;
2118  while ((node = traj->GetNextNode())) { // store names of all detectors on trajectory
2119  detectors_of_group.Add(node);
2120  RecursiveTrajectoryClustering(node, tried_trajectories, multitraj_nodes, detectors_of_group);
2121  }
2122  }
2123  }
2124  }
2125  else if (N->GetNTraj() == 1) {
2126  // single-trajectory node.
2127  // work along trajectory adding nodes to group
2128  KVGeoDNTrajectory* traj = (KVGeoDNTrajectory*)N->GetTrajectories()->First();
2129  if (tried_trajectories.FindObject(traj)) return; // trajectory already used
2130  tried_trajectories.Add(traj);
2131  traj->IterateFrom();
2132  KVGeoDetectorNode* node;
2133  while ((node = traj->GetNextNode())) { // store names of all detectors on trajectory
2134  detectors_of_group.Add(node);
2135  RecursiveTrajectoryClustering(node, tried_trajectories, multitraj_nodes, detectors_of_group);
2136  }
2137  }
2138  else {
2139  // orphan node? single-detector array?
2140  detectors_of_group.Add(N);
2141  }
2142 }
2143 
2144 
2145 
2154 
2156 {
2157  // Create and return pointer to new KVGroupReconstructor for reconstructing particles
2158  // in the given group. Returns nullptr if group is not part of this array.
2159  //
2160  // Plugins for specific arrays can be defined as plugins using the name of the array:
2161  // +Plugin.KVGroupReconstructor: my_array my_group_reconstructor my_lib "my_group_reconstructor()"
2162  //
2163  // If we are in 'SimMode', the default reconstructor is a KVFilterGroupReconstructor
2164 
2165  KVGroupReconstructor* gr(nullptr);
2166  if (GetGroup(g->GetName())) {
2167  // look for plugin
2169  if (!gr) {
2170  if (IsSimMode()) return KVGroupReconstructor::Factory("Filter", g);
2171  else
2172  gr = new KVGroupReconstructor(g);
2173  }
2174  }
2175  return gr;
2176 }
2177 
2178 
2179 
2183 
2185 {
2186  // Call this method just after opening a raw data file in order to perform any
2187  // necessary initialisations, depending on the type of data
2188 
2189 #ifdef WITH_BUILTIN_GRU
2190  if (r->GetDataFormat() == "EBYEDAT")
2191  dynamic_cast<KVGANILDataReader*>(r)->ConnectRawDataParameters();
2192 #endif
2193 }
2194 
2195 
2196 
2201 
2203 {
2204  // Deduce the "groups" in the array from the trajectories
2205  // Any trajectories with 1 or more common detectors define a group.
2206  // The group is constituted of all detectors belonging to the trajectories of the group.
2207 
2208  Info("DeduceGroupsFromTrajectories", "Deducing groups of detectors from trajectories");
2209  Int_t number_of_groups = 0;
2210  TIter next_det(GetDetectors());
2211  unique_ptr<KVSeqCollection> stl(GetStructureTypeList("GROUP"));
2212  if (stl.get() && stl->GetEntries()) {
2213  Info("DeduceGroupsFromTrajectories", "Deleting existing %d groups in array", stl->GetEntries());
2214  ClearStructures("GROUP");
2215  Info("DeduceGroupsFromTrajectories", "Done");
2216  }
2217  KVDetector* det;
2218  KVUniqueNameList tried_trajectories;//avoid double-counting/infinite loops
2219  KVUniqueNameList multitraj_nodes;//avoid double-counting/infinite loops
2220  while ((det = (KVDetector*) next_det())) {
2221  if (det->GetGroup()) continue; // group assignment already done
2222  KVUniqueNameList detectors_of_group;
2223  RecursiveTrajectoryClustering(det->GetNode(), tried_trajectories, multitraj_nodes, detectors_of_group);
2224  if (!detectors_of_group.GetEntries()) continue;
2225  KVGroup* Group = new KVGroup;
2226  Group->SetNumber(++number_of_groups);
2227  Add(Group);
2228  TIter next_node(&detectors_of_group);
2230  while ((d = (KVGeoDetectorNode*)next_node())) Group->Add(d->GetDetector());
2231  }
2232  TIter tr(&fTrajectories);
2233  KVGeoDNTrajectory* t;
2234  Info("DeduceGroupsFromTrajectories", "Filling group trajectory lists");
2235  while ((t = (KVGeoDNTrajectory*)tr())) {
2236  if (t->GetNodeAt(0)->GetDetector()->GetGroup())
2237  t->GetNodeAt(0)->GetDetector()->GetGroup()->AddTrajectory(t);
2238  else {
2239  t->Print();
2240  t->GetNodeAt(0)->GetDetector()->Print();
2241  }
2242  }
2243 }
2244 
2245 
2246 
2250 
2252 {
2253  // Called when required to fill KVReconstructedNucleus::fDetList with pointers to
2254  // the detectors whose names are stored in KVReconstructedNucleus::fDetNames.
2255 
2256  DetList->Clear();
2257  DetNames.Begin("/");
2258  while (!DetNames.End()) {
2259  KVDetector* det = GetDetector(DetNames.Next(kTRUE));
2260  if (det) DetList->Add(det);
2261  }
2262 }
2263 
2264 
2265 
2285 
2287 {
2288  // Set status of particle by comparing its identification/calibration codes
2289  // with those set as acceptable in fAcceptIDCodes and fAcceptECodes.
2290  // The status can be tested with method KVReconstructedNucles::IsOK().
2291  //
2292  // The default lists are defined in variables of the form
2293  //```
2294  // [DataSet].[name].ReconstructedNuclei.AcceptIDCodes: [list]
2295  // [DataSet].[name].ReconstructedNuclei.AcceptECodes: [list]
2296  //```
2297  // where:
2298  // + `DataSet` is an optional dataset name for dataset-specific lists
2299  // + `name` is the name of the multidetector array
2300  // + `list` is a numeric list (KVNumberList format)
2301  //
2302  // The default lists can be overridden using methods AcceptIDCodes(), AcceptECodes(),
2303  // AcceptAllIDCodes() and AcceptAllECodes().
2304  //
2305  // If either list is empty, no selection is made for the corresponding code
2306 
2307  Bool_t ok = kTRUE;
2309  if (!fAcceptECodes.IsEmpty()) ok = ok && fAcceptECodes.Contains(NUC->GetECode());
2310  NUC->SetIsOK(ok);
2311 }
2312 
2313 
2314 #ifdef WITH_BUILTIN_GRU
2315 
2318 
2320 {
2321  // General method for reading raw data in old GANIL ebyedat format
2322  AbstractMethod("handle_raw_data_event_ebyedat");
2323  return kFALSE;
2324 }
2325 
2326 #endif
2327 
2328 
2331 
2333 {
2334  // reset acquisition parameters etc. before reading new raw data event
2335 
2338  fHandledRawData = false;
2339  // reset fired signals
2340  TIter nxt(&fFiredSignals);
2341  KVDetectorSignal* ds;
2342  while ((ds = (KVDetectorSignal*)nxt())) {
2343  ds->SetFired(false);
2344  ds->SetValue(0);
2345  }
2346  fFiredSignals.Clear();
2347 }
2348 
2349 
2350 
2358 
2360 {
2361  // Perform any operations to finalise the description of the multidetector
2362  // which can only be done once the geometry is closed, e.g. use KVGeoImport
2363  // to set up nodes, trajectories, detectors, idtelescopes, etc.
2364  // This has to be kept separate for use with KVExpSetUp which first fills
2365  // a single ROOT geometry with all component KVMultiDetArray geometries,
2366  // then closes the geometry only when all have been built.
2367 }
2368 
2369 
2370 
2373 
2375 {
2376  // Copy any parameters in fReconParameters in to the reconstructed event parameter list
2377  e->GetParameters()->Concatenate(fReconParameters);
2378 }
2379 
2380 
2381 
2394 
2396 {
2397  // values of fired raw data signals (acquisition parameters) from last read raw event
2398  // are copied to the fReconParameters list of parameters to be stored with the
2399  // reconstructed event.
2400  //
2401  // the format for each signal is:
2402  //
2403  // ACQPAR.[array].[detector].[signal]
2404  // ACQPAR.[array].[signal]
2405  //
2406  // in the first case for signals associated with detectors, in the latter case signals
2407  // which are not associated with a detector
2408 
2409  TIter it(GetFiredSignals());
2410  KVDetectorSignal* o;
2411  while ((o = (KVDetectorSignal*)it())) {
2412  fReconParameters.SetValue(Form("ACQPAR.%s.%s", GetName(), o->GetFullName().Data()), o->GetValue());
2413  }
2414 }
2415 
2416 
2417 
2426 
2428 {
2429  // Update array according to last event read using the KVRawDataReader object
2430  // (it is assumed that KVRawDataReader::GetNextEvent() was called before calling this method)
2431  //
2432  // Return kTRUE if raw data was treated
2433  //
2434  // All fired acquisition parameters are written in the fReconParameters list,
2435  // ready to be copied to the reconstructed event
2436 
2437  fRawDataReader = rawdata;
2439  if (rawdata->GetDataFormat() == "MFM") {
2440 #ifdef WITH_MFM
2442 #endif
2443  }
2444  else if (rawdata->GetDataFormat() == "PROTOBUF") {
2445 #ifdef WITH_PROTOBUF
2447 #endif
2448  }
2449  else if (rawdata->GetDataFormat() == "EBYEDAT") {
2450 #ifdef WITH_BUILTIN_GRU
2452 #endif
2453  }
2454  if (fHandledRawData) {
2456  }
2457  return fHandledRawData;
2458 }
2459 
2460 
2461 #ifdef WITH_MFM
2462 
2471 
2473 {
2474  // Update array according to last event read from MFM buffer
2475  // (it is assumed that MFMBufferReader::ReadNextFrame() was called before calling this method)
2476  //
2477  // Return kTRUE if raw data was treated
2478  //
2479  // All fired acquisition parameters are written in the fReconParameters list,
2480  // ready to be copied to the reconstructed event
2481 
2483  bool ok = false;
2484  ok = handle_raw_data_event_mfmfile(bufrdr);
2485  if (ok) {
2487  }
2488  return ok;
2489 }
2490 
2491 #endif
2492 
2493 
2504 
2505 void KVMultiDetArray::add_and_set_detector_signal(KVDetector* detector, KVString detname, Double_t sig_data, KVString sig_type)
2506 {
2507  // Given a pointer to a detector (may be nullptr) try to set the data sig_data in the associated signal
2508  // of the given type, sig_typ.
2509  //
2510  // If the signal does not exist for the detector, it will be created.
2511  //
2512  // If detector pointer is null, the signal will be looked for in fExtraRawDataSignals
2513  // and created if necessary.
2514  //
2515  // All fired detectors and signals are added to the lists fFiredDetectors and fFiredSignals.
2516 
2517  KVDetectorSignal* det_signal = nullptr;
2518  if (detector) {
2519  det_signal = detector->GetDetectorSignal(sig_type);
2520  if (!det_signal) {
2521  det_signal = detector->AddDetectorSignal(sig_type);
2522  }
2523  fFiredDetectors.Add(detector);
2524  }
2525  else {
2526  // raw data not associated with a detector
2527  TString sig_name;
2528  if (detname != "") sig_name = Form("%s.%s", detname.Data(), sig_type.Data());
2529  else sig_name = sig_type;
2530  det_signal = fExtraRawDataSignals.get_object<KVDetectorSignal>(sig_name);
2531  if (!det_signal) {
2532  det_signal = new KVDetectorSignal(sig_name);
2533  fExtraRawDataSignals.Add(det_signal);
2534  }
2535  }
2536  if (det_signal) {
2537  det_signal->SetValue(sig_data);
2538  det_signal->SetFired();
2539  fFiredSignals.Add(det_signal);
2540  }
2541 }
2542 
2543 
2544 
2550 
2552 {
2553  // Take values 'ACQPAR.[array_name].[detname].[signal]' or 'ACQPAR.[array_name].[signal]'
2554  // in the parameter list and use them to set values of raw acquisition parameters.
2555  //
2556  // Any detector signals which don't already exist will be created
2557 
2558  prepare_to_handle_new_raw_data(); // clear previous fired parameters/detectors
2559  int N = l.GetNpar();
2560  for (int i = 0; i < N; ++i) {
2561  KVNamedParameter* np = l.GetParameter(i);
2562 
2563  KVString name(np->GetName());
2564  if (name.BeginsWith("ACQPAR")) {
2565  // 3 '.' => 4 values means associated detector
2566  // 2 '.' => 3 values means no detector
2567  int dots = name.GetNValues(".");
2568  bool with_det = (dots == 4);
2569  assert(with_det || (dots == 3)); // sanity check
2570  name.Begin(".");
2571  name.Next(); // "ACQPAR"
2572  if (name.Next() != GetName()) continue; // check name of array - somebody else's parameter ?
2573  KVString det_name;
2574  KVString sig_type;
2575  KVDetector* det = nullptr;
2576  if (with_det) {
2577  det_name = name.Next();
2578  sig_type = name.Next();
2579  det = GetDetector(det_name);
2580  }
2581  else {
2582  sig_type = name.Next();
2583  }
2584  add_and_set_detector_signal(det, det_name, np->GetDouble(), sig_type);
2585  }
2586  }
2587 }
2588 
2589 
2590 
2609 
2611 {
2612  // We first look for following files with the name given by
2613  //
2614  // [dataset].[name].OoODetectors: [name.OoODetectors.dat]
2615  // which should contain the runlists for each malfunctioning detector.
2616  // If found we add to the experiment database a table '[name].OoO Detectors' where [name] is the name of this array.
2617  //
2618  // [dataset].[name].AbsentDetectors: [name.AbsentDetectors.dat]
2619  // which should contain the runlists for each absent detector.
2620  // If found we add to the experiment database a table '[name].Absent Detectors' where [name] is the name of this array.
2621  //
2622  // Then we look for a file with the name given by
2623  //
2624  // [dataset].[name].CalibrationFiles: [CalibrationFiles.dat]
2625  //
2626  // which should contain the names of files to read with each type of calibration
2627  // If found we add to the experiment database a table '[name].Calibrations' where [name] is the name of this array,
2628  // containing all calibrations as KVDBParameterSet objects with the name of the detector concerned.
2629  db->SetDBType(Form("%sDB", GetName()));
2630  ReadOoODetectors(db);
2631  ReadAbsentDetectors(db);
2633 }
2634 
2635 
2636 
2638 
2640 {
2641  TString basic_name = db->GetCalibFileName(keyw);
2642  if (basic_name == "") {
2643  Info(meth, "No name found for \"%s\" file", keyw);
2644  return "";
2645  }
2646  Info(meth, "Search for %s for dataset %s ...", basic_name.Data(), fDataSet.Data());
2647  TString fp;
2648  SearchKVFile(basic_name.Data(), fp, fDataSet);
2649  if (fp == "") {
2650  Info(meth, "\tNo file found ...");
2651  }
2652  return fp;
2653 }
2654 
2655 
2656 
2658 
2659 unique_ptr<KVFileReader> KVMultiDetArray::GetKVFileReader(KVExpDB* db, const Char_t* meth, const Char_t* keyw)
2660 {
2661 
2662  TString fp = GetFileName(db, meth, keyw);
2663  if (fp == "")
2664  return unique_ptr<KVFileReader>();
2665 
2666  unique_ptr<KVFileReader> fr(new KVFileReader());
2667  if (!fr->OpenFileToRead(fp.Data())) {
2668  Error(meth, "Error in opening file %s", fp.Data());
2669  fr.reset(nullptr);
2670  }
2671  else
2672  Info(meth, "Reading %s file", fp.Data());
2673  return fr;
2674 }
2675 
2676 
2677 
2679 
2681 {
2682 
2683  unique_ptr<KVFileReader> fr = GetKVFileReader(db, "ReadCalibrationFiles()", "CalibrationFiles");
2684  if (!fr.get())
2685  return;
2686 
2687  KVDBTable* calib_table = db->AddTable(Form("%s.Calibrations", GetName()), Form("Calibrations for %s", GetName()));
2688  while (fr->IsOK()) {
2689  fr->ReadLine(0);
2690  if (fr->GetCurrentLine().BeginsWith("#") || fr->GetCurrentLine() == "") {}
2691  else {
2692  ReadCalibFile(fr->GetCurrentLine().Data(), db, calib_table);
2693  }
2694  }
2695  fr->CloseFile();
2696 }
2697 
2698 
2699 
2740 
2741 void KVMultiDetArray::ReadCalibFile(const Char_t* filename, KVExpDB* db, KVDBTable* calib_table)
2742 {
2743  // Read a calibration file with the format
2744  //
2745  //~~~~~~~~~~~~~
2746  // RunList: 1546-7485
2747  // SignalIn: PG
2748  // SignalOut: Volts
2749  // CalibType: ChannelVolt
2750  // CalibOptions: func=pol3,min=0,max=1
2751  // ZRange: 2-92
2752  // [detector1]: 0.0,0.261829,0.0
2753  // [detector2]: 0.1,0.539535,1.2
2754  //~~~~~~~~~~~~~
2755  //
2756  //The `[RunList]` is optional: if not given, the calibration will be applied to all runs in the database.
2757  //
2758  //If different parameters are required for different sets of runs, they should be written in different
2759  //files (all of which are listed in `CalibrationFiles.dat` or `[array].CalibrationFiles.dat`).
2760  //
2761  //The `[CalibClass]`, if given, must correspond to a KVCalibrator plugin name. The list of plugin names and the corresponding
2762  //classes can be retrieved with
2763  //
2764  //~~~~~~~~~~~
2765  //KVBase::GetListOfPlugins("KVCalibrator")
2766  //KVBase::GetListOfPluginURIs("KVCalibrator")
2767  //~~~~~~~~~~~
2768  //
2769  //KVCalibrator objects are added to detectors as required by the contents of calibration files.
2770  //If any detector has an existing calibrator of type `[CalibType]` which is not of the given class
2771  //it will be replaced with a new calibrator corresponding to the plugin.
2772  //
2773  //The `[CalibOptions]` is optional: list in `[CalibOptions]` will be used
2774  //to complete set-up of any new calibrator objects by calling the KVCalibrator::SetOptions()
2775  //method.
2776  //
2777  //`[CalibOptions]` should hold a comma-separated list of `parameter=value` pairs which will be used
2778  //to fill a KVNameValueList for the method call. See the KVCalibrator::SetOptions() method.
2779  //
2780  //`[ZRange]` is an option if several calibrations need to be used to provide the same signal
2781  //for certain detectors depending on the atomic number Z of the particle detected.
2782 
2783 
2784  TString fullpath = "";
2785  if (!SearchKVFile(filename, fullpath, fDataSet)) {
2786  Info("ReadCalibFile", "%s does not exist or not found", filename);
2787  return;
2788  }
2789 
2790  Info("ReadCalibFile", "file : %s found", fullpath.Data());
2791  TEnv env;
2792  env.ReadFile(fullpath, kEnvAll);
2793 
2794  // read options from file
2795  KVNameValueList options;
2796  KVString opt_list = "RunList SignalIn SignalOut CalibType CalibClass CalibOptions ZRange";
2797  opt_list.Begin(" ");
2798  while (!opt_list.End()) {
2799  KVString opt = opt_list.Next();
2800  KVString opt_val = env.GetValue(opt, "");
2801  opt_val.Remove(TString::kBoth, ' ');
2802  options.SetValue(opt, opt_val.Data());
2803  }
2804  // check for stupid spellnig mitskaes
2805  if (TString(env.GetValue("Runlist", "")) != "") {
2806  Warning("ReadCalibFile", "Calibration has 'Runlist' parameter (ignored): %s, did you mean 'RunList'?", env.GetValue("Runlist", ""));
2807  }
2808 
2809  if (options.GetTStringValue("SignalIn") == "") {
2810  Error("ReadCalibFile", "No input signal defined : SignalIn");
2811  return;
2812  }
2813  if (options.GetTStringValue("SignalOut") == "") {
2814  Error("ReadCalibFile", "No output signal defined : SignalOut");
2815  return;
2816  }
2817  if (options.GetTStringValue("CalibType") == "") {
2818  Error("ReadCalibFile", "No calibration type defined : CalibType");
2819  return;
2820  }
2821  Bool_t check_class(options.GetTStringValue("CalibClass") != "");
2822  TString calibrator_class;
2823  if (check_class) {
2824  TPluginHandler* ph = LoadPlugin("KVCalibrator", options.GetStringValue("CalibClass"));
2825  if (ph) calibrator_class = ph->GetClass();
2826  else {
2827  Error("ReadCalibFile", "No calibrator plugin of type %s", options.GetStringValue("CalibClass"));
2828  return;
2829  }
2830  }
2831 
2832  KVString clop;
2833  if (options.HasParameter("CalibOptions")) clop = options.GetStringValue("CalibOptions");
2834 
2835  KVString zrange;
2836  if (options.HasParameter("ZRange")) zrange = options.GetStringValue("ZRange");
2837 
2838  KVNumberList run_list = db->GetRunList();
2839  if (options.GetTStringValue("RunList") != "") {
2840  run_list.Set(options.GetTStringValue("RunList"));
2841  Info("ReadCalibFile", "Calibration used for runs %s", run_list.AsString());
2842  }
2843  else {
2844  Info("ReadCalibFile", "Calibration used for all runs in database");
2845  }
2846 
2847  TIter next(env.GetTable());
2848  TEnvRec* rec = 0;
2849  KVDBParameterSet* par = 0;
2850 
2851  while ((rec = (TEnvRec*)next())) {
2852 
2853  TString sname(rec->GetName());
2854  KVDetector* det = GetDetector(sname);
2855  if (!det) continue;
2856 
2857  KVString lval(rec->GetValue());
2858  par = new KVDBParameterSet(sname.Data(), options.GetStringValue("CalibType"), lval.GetNValues(","));
2859  par->SetParameter("SignalIn", options.GetStringValue("SignalIn"));
2860  par->SetParameter("SignalOut", options.GetStringValue("SignalOut"));
2861  // put infos on required calibrator class into database so that it can be replaced
2862  // as needed in SetCalibratorParameters
2863  par->SetParameter("CalibClass", options.GetStringValue("CalibClass"));
2864  if (clop != "") par->SetParameter("CalibOptions", clop);
2865  if (zrange != "") par->SetParameter("ZRange", zrange);
2866  Int_t np = 0;
2867  lval.Begin(",");
2868  while (!lval.End()) {
2869  par->SetParameter(np++, lval.Next().Atof());
2870  }
2871  calib_table->AddRecord(par);
2872  db->LinkRecordToRunRange(par, run_list);
2873 
2874  }
2875 }
2876 
2877 
2878 #ifdef WITH_MFM
2879 
2885 
2887 {
2888  // Update array according to last event read using the KVMFMDataFileReader object
2889  // (it is assumed that KVRawDataReader::GetNextEvent() was called before calling this method)
2890  //
2891  // Return kTRUE if raw data was treated
2892 
2893  if (mfmreader.IsFrameReadMerge()) {
2894  return handle_raw_data_event_mfmmergeframe(mfmreader.GetMergeManager());
2895  }
2896  else {
2897  return handle_raw_data_event_mfmframe(mfmreader.GetFrameRead());
2898  }
2899  return kFALSE;
2900 }
2901 
2902 
2903 
2907 
2908 Bool_t KVMultiDetArray::handle_raw_data_event_mfmmergeframe(const MFMMergeFrameManager& mergeframe)
2909 {
2910  // Method used to handle merged MFM frames
2911  // We call handle_raw_data_event_mfmframe() for each frame contained in the merge
2912 
2913  Bool_t ok = false;
2914  while (mergeframe.ReadNextFrame()) {
2915  Bool_t me = handle_raw_data_event_mfmframe(mergeframe.GetFrameRead());
2916  ok = (ok || me);
2917  }
2918  return ok;
2919 }
2920 
2921 
2922 
2933 
2935 {
2936  // Method used to treat raw data in MFM format read by KVMFMDataFileReader
2937  //
2938  // Here we dispatch two types of frame - MFMEbyedatFrame & MFMMesytecMDPPFrame -
2939  // to specific methods - handle_raw_data_event_mfmframe_ebyedat() and
2940  // handle_raw_data_event_mfmframe_mesytec_mdpp()
2941  // which need to be implemented in child classes for specific arrays which
2942  // use these data formats.
2943  //
2944  // Return kTRUE if raw data was treated
2945 #ifdef WITH_MESYTEC
2946  if (mfmframe.GetFrameType() == MFM_MESYTEC_MDPP_FRAME_TYPE)
2947  return handle_raw_data_event_mfmframe_mesytec_mdpp((const MFMMesytecMDPPFrame&)mfmframe);
2948 #endif
2949  if (mfmframe.GetFrameType() == MFM_EBY_EN_FRAME_TYPE
2950  || mfmframe.GetFrameType() == MFM_EBY_TS_FRAME_TYPE
2951  || mfmframe.GetFrameType() == MFM_EBY_EN_TS_FRAME_TYPE)
2952  return handle_raw_data_event_mfmframe_ebyedat((const MFMEbyedatFrame&)mfmframe);
2953 
2954  return kFALSE;
2955 }
2956 
2957 
2958 
2961 
2963 {
2964  // Read a raw data event from a EBYEDAT MFM Frame.
2965 
2966  AbstractMethod("handle_raw_data_event_mfmframe_ebyedat");
2967  return kFALSE;
2968 }
2969 
2970 
2971 #ifdef WITH_MESYTEC
2972 
2975 
2977 {
2978  // Read a raw data event from a Mesytec MFM Frame.
2979 
2980  AbstractMethod("handle_raw_data_event_mfmframe_mesytec_mdpp");
2981  return kFALSE;
2982 }
2983 
2984 #endif
2985 #endif
2986 
2987 #ifdef WITH_PROTOBUF
2988 
2990 
2992 {
2993  AbstractMethod("handle_raw_data_event_protobuf");
2994  return kFALSE;
2995 }
2996 
2997 #endif
2998 
2999 
3002 
3004 {
3005  // For each IDtelescope in array, calculate an identification grid
3006 
3007  TIter nxtid(GetListOfIDTelescopes());
3008  KVIDTelescope* idt;
3009  while ((idt = (KVIDTelescope*) nxtid())) {
3010  idt->CalculateDeltaE_EGrid("1-92", 0, 20);
3011  }
3012 }
3013 
3014 
3015 
3020 
3022 {
3023  // Sets status of detectors (KVDetector::IsPresent() and KVDetector::IsWorking()) for a given run of a dataset.
3024  //
3025  // If 'myname' is given, we look in database table "myname.OoODets"
3026 
3027  KVRList* absdet = (myname != "" ? kvrun->GetLinks(Form("%s.Absent Detectors", myname.Data())) : kvrun->GetLinks("Absent Detectors"));
3028  KVRList* ooodet = (myname != "" ? kvrun->GetLinks(Form("%s.OoO Detectors", myname.Data())) : kvrun->GetLinks("OoO Detectors"));
3029 
3030  TIter next(GetDetectors());
3031  KVDetector* det;
3032 
3033  Int_t ndet_absent = 0;
3034  Int_t ndet_ooo = 0;
3035  TString absent_dets, ooo_dets;
3036 
3037  while ((det = (KVDetector*)next())) {
3038  //Test de la presence ou non du detecteur
3039  if (!absdet) {
3040  det->SetPresent();
3041  }
3042  else {
3043  if (absdet->FindObject(det->GetName())) {
3044  det->SetPresent(kFALSE);
3045  if (ndet_absent) absent_dets += ",";
3046  absent_dets += det->GetName();
3047  ndet_absent += 1;
3048  }
3049  else {
3050  det->SetPresent();
3051  }
3052  }
3053  if (det->IsPresent()) {
3054  //Test du bon fonctionnement ou non du detecteur
3055  if (!ooodet) {
3056  det->SetDetecting();
3057  }
3058  else {
3059  if (ooodet->FindObject(det->GetName())) {
3060  det->SetDetecting(kFALSE);
3061  if (ndet_ooo) ooo_dets += ",";
3062  ooo_dets += det->GetName();
3063  ndet_ooo += 1;
3064  }
3065  else {
3066  det->SetDetecting();
3067  }
3068  }
3069  }
3070  }
3071 
3072  if (ndet_absent) Info("CheckStatusOfDetectors", "%d detectors absent during run : %s", ndet_absent, absent_dets.Data());
3073  else Info("CheckStatusOfDetectors", "All detectors present during run");
3074  if (ndet_ooo) Info("CheckStatusOfDetectors", "%d detectors malfunctioned during run : %s", ndet_ooo, ooo_dets.Data());
3075  else Info("CheckStatusOfDetectors", "All detectors functioning during run");
3076 }
3077 
3078 
3079 
3081 
3083 {
3084  CheckStatusOfDetectors(dbr, myname);
3085 }
3086 
3087 
3088 
3103 
3105 {
3106  // Read a file containing runlists for each temporarily non-functioning detector.
3107  //
3108  // The file should be in TEnv format like so:
3109  //
3110  //~~~~
3111  // DET_1: 100-122,541-1938
3112  // DET_2,DET_3: 91-765
3113  //~~~~
3114  //
3115  // i.e. more than one detector can be associated with the same runs (comma-separated list of
3116  // detector names) and the list of runs are given using KVNumberList syntax.
3117  //
3118  // The data is added to the database in a table '[name].OoO Detectors' with the name of this array.
3119 
3120  TString fullpath;
3121  if (!db->FindCalibFile("OoODet", fullpath, GetName())) return;
3122 
3123  Info("ReadOoODetectors()", "Reading lists of out-of-order detectors...");
3124  auto fOoODet = db->AddTable(Form("%s.OoO Detectors", GetName()), "Name of out of order detectors");
3125 
3126  KVDBRecord* dbrec = 0;
3127  TEnv env;
3128  TEnvRec* rec = 0;
3129  env.ReadFile(fullpath.Data(), kEnvAll);
3130  TIter it(env.GetTable());
3131 
3132  while ((rec = (TEnvRec*)it.Next())) {
3133  KVString srec(rec->GetName());
3134  KVNumberList nl(rec->GetValue());
3135  if (srec.Contains(",")) {
3136  srec.Begin(",");
3137  while (!srec.End()) {
3138  dbrec = new KVDBRecord(srec.Next(kTRUE), "OoO Detector");
3139  dbrec->AddKey("Runs", "List of Runs");
3140  fOoODet->AddRecord(dbrec);
3141  db->LinkRecordToRunRange(dbrec, nl);
3142  }
3143  }
3144  else {
3145  dbrec = new KVDBRecord(rec->GetName(), "OoO Detector");
3146  dbrec->AddKey("Runs", "List of Runs");
3147  fOoODet->AddRecord(dbrec);
3148  db->LinkRecordToRunRange(dbrec, nl);
3149  }
3150  }
3151 }
3152 
3153 
3168 
3170 {
3171  // Read a file containing runlists for each temporarily absent/dismounted detector.
3172  //
3173  // The file should be in TEnv format like so:
3174  //
3175  //~~~~
3176  // DET_1: 100-122,541-1938
3177  // DET_2,DET_3: 91-765
3178  //~~~~
3179  //
3180  // i.e. more than one detector can be associated with the same runs (comma-separated list of
3181  // detector names) and the list of runs are given using KVNumberList syntax.
3182  //
3183  // The data is added to the database in a table '[name].Absent Detectors' with the name of this array.
3184 
3185  TString fullpath;
3186  if (!db->FindCalibFile("AbsentDet", fullpath, GetName())) return;
3187 
3188  Info("ReadAbsentDetectors()", "Reading lists of absent/dismounted detectors... file=[%s]", fullpath.Data());
3189  auto fAbsDet = db->AddTable(Form("%s.Absent Detectors", GetName()), "Name of out of order detectors");
3190 
3191  KVDBRecord* dbrec = 0;
3192  TEnv env;
3193  TEnvRec* rec = 0;
3194  env.ReadFile(fullpath.Data(), kEnvAll);
3195  TIter it(env.GetTable());
3196 
3197  while ((rec = (TEnvRec*)it.Next())) {
3198  KVString srec(rec->GetName());
3199  KVNumberList nl(rec->GetValue());
3200  if (srec.Contains(",")) {
3201  srec.Begin(",");
3202  while (!srec.End()) {
3203  dbrec = new KVDBRecord(srec.Next(kTRUE), "Absent Detector");
3204  dbrec->AddKey("Runs", "List of Runs");
3205  fAbsDet->AddRecord(dbrec);
3206  db->LinkRecordToRunRange(dbrec, nl);
3207  }
3208  }
3209  else {
3210  dbrec = new KVDBRecord(rec->GetName(), "Absent Detector");
3211  dbrec->AddKey("Runs", "List of Runs");
3212  fAbsDet->AddRecord(dbrec);
3213  db->LinkRecordToRunRange(dbrec, nl);
3214  }
3215  }
3216 }
3217 
3218 
int Int_t
unsigned int UInt_t
ROOT::R::TRInterface & r
#define SafeDelete(p)
#define d(i)
#define f(i)
#define e(i)
bool Bool_t
unsigned short UShort_t
char Char_t
constexpr Bool_t kFALSE
double Double_t
constexpr Bool_t kTRUE
const char Option_t
kEnvUser
kEnvAll
#define N
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t np
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t Atom_t typelist
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t g
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
R__EXTERN TGeoManager * gGeoManager
char * Form(const char *fmt,...)
#define gPad
void SetLabel(const Char_t *lab)
Definition: KVBase.h:194
virtual const Char_t * GetType() const
Definition: KVBase.h:176
void Error(const char *method, const char *msgfmt,...) const override
Definition: KVBase.cpp:1650
static const Char_t * GetWORKDIRFilePath(const Char_t *namefile="")
Definition: KVBase.cpp:121
const Char_t * GetLabel() const
Definition: KVBase.h:198
static bool is_gnuinstall()
Definition: KVBase.h:274
void Print(Option_t *option="") const override
Definition: KVBase.cpp:389
virtual void SetType(const Char_t *str)
Definition: KVBase.h:172
static ValType GetDataSetEnv(const KVString &dataset, const KVString &type, const ValType &defval)
Definition: KVBase.h:304
static Bool_t SearchKVFile(const Char_t *name, TString &fullpath, const Char_t *kvsubdir="")
Definition: KVBase.cpp:517
static TPluginHandler * LoadPlugin(const Char_t *base, const Char_t *uri="0")
Definition: KVBase.cpp:772
void Warning(const char *method, const char *msgfmt,...) const override
Definition: KVBase.cpp:1637
Base class for all detector calibrations.
Definition: KVCalibrator.h:99
Int_t GetNumberParams() const
Definition: KVCalibrator.h:153
virtual void SetOptions(const KVNameValueList &)
void SetParameter(int i, Double_t par_val) const
Definition: KVCalibrator.h:158
void SetStatus(Bool_t ready)
Definition: KVCalibrator.h:166
void SetOutputSignalType(const TString &type)
Definition: KVCalibrator.h:220
void SetInputSignalType(const TString &type)
Definition: KVCalibrator.h:216
static KVCalibrator * MakeCalibrator(const Char_t *type)
To store calibration parameters in a database ,.
Bool_t HasParameter(const Char_t *name) const
TString GetStringParameter(const TString &name) const
Double_t GetParameter(UShort_t i=0) const
void Print(Option_t *option="") const override
Int_t GetParamNumber() const
void SetParameter(UShort_t i, Double_t val)
const KVNameValueList & GetParameters() const
Record folder for the database.
Definition: KVDBRecord.h:43
virtual Bool_t AddKey(KVDBKey *key, Bool_t check=kTRUE)
Definition: KVDBRecord.cpp:65
virtual KVRList * GetLinks(const Char_t *key) const
Returns the list of records linked to this record in table "key".
Definition: KVDBRecord.cpp:206
Description of an experimental run in database ,,.
Definition: KVDBRun.h:40
Table in a database.
Definition: KVDBTable.h:34
virtual Bool_t AddRecord(KVDBRecord *add)
Definition: KVDBTable.cpp:74
static Bool_t IsRunningBatchAnalysis()
virtual Bool_t AddTable(KVDBTable *table)
Definition: KVDataBase.cpp:84
KVDataSet * GetDataSet(Int_t) const
Return pointer to DataSet using index in list of all datasets, index>=0.
Manage an experimental dataset corresponding to a given experiment or campaign.
Definition: KVDataSet.h:36
const Char_t * GetDataSetDir() const
Definition: KVDataSet.cpp:744
Bool_t HasCalibIdentInfos() const
Definition: KVDataSet.h:229
KVString GetDataSetEnv(const Char_t *type, const Char_t *defval="") const
Definition: KVDataSet.cpp:782
TString GetFullPathToDataSetFile(const Char_t *filename)
Definition: KVDataSet.cpp:1924
void cd() const
Definition: KVDataSet.cpp:760
Bool_t DataBaseUpdateInProgress() const
Definition: KVDataSet.h:74
static Bool_t FindDataSetFile(const TString &dataset, const Char_t *filename)
Definition: KVDataSet.cpp:1958
List of hit groups in a multidetector array.
void AddGroup(KVGroup *grp)
Base class for output signal data produced by a detector.
virtual void SetValue(Double_t x)
virtual Double_t GetValue(const KVNameValueList &params="") const
TString GetFullName() const
void SetFired(Bool_t yes=true)
Base class to describe database of an experiment ,,.
Definition: KVExpDB.h:20
void SetDBType(const TString &s)
Definition: KVExpDB.h:63
TString GetCalibFileName(const Char_t *type) const
Definition: KVExpDB.h:133
const KVNumberList & GetRunList() const
Definition: KVExpDB.h:101
virtual void LinkRecordToRunRange(KVDBRecord *rec, UInt_t first_run, UInt_t last_run)
Definition: KVExpDB.cpp:90
Bool_t FindCalibFile(const Char_t *type, TString &fullpath, const TString &array_name="") const
Definition: KVExpDB.cpp:486
Handle reading columns of numeric data in text files.
Definition: KVFileReader.h:121
KVString GetCurrentLine()
Definition: KVFileReader.h:320
ReadStatus ReadLine(const KVString &pattern="")
Definition: KVFileReader.h:243
Bool_t IsOK()
Definition: KVFileReader.h:231
Bool_t OpenFileToRead(const KVString &filename)
Definition: KVFileReader.h:210
Reads GANIL acquisition files (EBYEDAT)
Path taken by particles through multidetector geometry.
KVGeoDetectorNode * GetNextNode() const
KVSeqCollection * AccessIDTelescopeList()
void AddToNodes()
Add reference to this trajectory to all nodes on it.
void IterateFrom(const KVGeoDetectorNode *node0=nullptr) const
KVGeoDetectorNode * GetNodeInFront(const KVGeoDetectorNode *n) const
Bool_t ContainsPath(const KVGeoDNTrajectory *other) const
KVGeoDetectorNode * GetNodeAt(Int_t i) const
Information on relative positions of detectors & particle trajectories.
KVDetector * GetDetector() const
Base class for propagation of particles through array geometry.
void DrawTracks(KVNumberList *=nullptr)
Base class describing elements of array geometry.
virtual Bool_t Fired(Option_t *opt="any") const
void SetOwnsDetectors(Bool_t yes=kTRUE)
virtual KVDetector * GetDetector(const Char_t *name) const
Return detector in this structure with given name.
const KVSeqCollection * GetDetectors() const
const KVSeqCollection * GetStructures() const
virtual void Add(KVBase *)
KVSeqCollection * GetStructureTypeList(const Char_t *type) const
void ClearStructures(const Char_t *type="")
const KVSeqCollection * GetParents() const
Base class for particle reconstruction in one group of a detector array.
static KVGroupReconstructor * Factory(const TString &plugin="", const KVGroup *g=nullptr)
Group of detectors which can be treated independently of all others in array.
Definition: KVGroup.h:20
void SetNumber(UInt_t num) override
Definition: KVGroup.h:38
void Reset(Option_t *opt="")
Definition: KVGroup.h:45
Extended version of ROOT THashList.
Definition: KVHashList.h:29
Base class for particle identification in a 2D map.
Definition: KVIDGraph.h:32
Handles a stock of identification grids to be used by one or more identification telescopes.
KVList * GetGrids()
virtual void LoadGridsForRun(UInt_t)
Bool_t ReadAsciiFile(const Char_t *filename)
const TList * GetLastReadGrids() const
virtual bool IsSQLROOT() const
Base class for all detectors or associations of detectors in array which can identify charged particl...
Definition: KVIDTelescope.h:84
virtual Double_t GetIDMapY(Option_t *opt="")
virtual Bool_t IsReadyForID()
KVIDGrid * CalculateDeltaE_EGrid(const KVNameValueList &AperZ, Int_t npoints=30, Double_t xfactor=1.)
void SetGroup(KVGroup *kvg)
virtual Double_t GetIDMapX(Option_t *opt="")
static KVIDTelescope * MakeIDTelescope(const Char_t *name)
virtual Bool_t SetIdentificationParameters(const KVMultiDetArray *)
void SetIDGrid(KVIDGraph *)
virtual void AddDetector(KVDetector *d)
virtual void Initialize(void)
Extended TList class which owns its objects by default.
Definition: KVList.h:28
Read MFM format acquisition data.
Description of physical materials used to construct detectors & targets; interface to range tables.
Definition: KVMaterial.h:89
static KVIonRangeTable * GetRangeTable()
Definition: KVMaterial.cpp:158
Base class for describing the geometry of a detector array.
const KVSeqCollection * GetFiredSignals() const
KVNumberList fAcceptECodes
list of acceptable calibration codes for reconstructed nuclei
bool try_a_singleIDtelescope(TString uri, KVDetector *d, TCollection *l)
KVUniqueNameList fExtraRawDataSignals
any signals read from raw data not associated with a detector
KVSeqCollection * GetListOfIDTelescopes() const
KVUniqueNameList * GetIDTelescopeTypes()
void FillListOfIDTelescopes(KVIDGraph *gr) const
virtual Bool_t handle_raw_data_event_mfmframe_ebyedat(const MFMEbyedatFrame &)
Read a raw data event from a EBYEDAT MFM Frame.
KVNumberList fAcceptIDCodes
list of acceptable identification codes for reconstructed nuclei
virtual void GetDetectorEvent(KVDetectorEvent *detev, const TSeqCollection *fired_params=0)
virtual Bool_t handle_raw_data_event_protobuf(KVProtobufDataReader &)
void MakeHistogramsForAllIDTelescopes(KVSeqCollection *list, Int_t dimension=100)
TList * GetStatusOfIDTelescopes()
int try_all_singleID_telescopes(KVDetector *d, TCollection *l)
static Bool_t fCloseGeometryNow
void Draw(Option_t *option="") override
virtual void DeduceIdentificationTelescopesFromGeometry()
static KVMultiDetArray * MakeMultiDetector(const Char_t *dataset_name, Int_t run=-1, TString classname="KVMultiDetArray", KVExpDB *db=nullptr)
std::unique_ptr< KVFileReader > GetKVFileReader(KVExpDB *db, const Char_t *meth, const Char_t *keyw)
virtual Double_t GetTargetEnergyLossCorrection(KVReconstructedNucleus *)
virtual Bool_t handle_raw_data_event_mfmmergeframe(const MFMMergeFrameManager &)
virtual Bool_t handle_raw_data_event_mfmfile(MFMBufferReader &)
void ReadOoODetectors(KVExpDB *db)
Bool_t fHandledRawData
set to true if multidetector handles data in last call to HandleRawData
KVSeqCollection * GetIDTelescopesWithType(const Char_t *type)
TList * fCalibStatusDets
used by GetStatusIDTelescopes
KVDetectorEvent * fHitGroups
list of hit groups in simulation
void ReadAbsentDetectors(KVExpDB *db)
KVTarget * GetTarget()
void RecursiveTrajectoryClustering(KVGeoDetectorNode *N, KVUniqueNameList &tried_trajectories, KVUniqueNameList &multitraj_nodes, KVUniqueNameList &detectors_of_group)
KVSeqCollection * fIDTelescopes
deltaE-E telescopes in groups
UInt_t fCurrentRun
Number of the current run used to call SetParameters.
static Bool_t fMakeMultiDetectorSetParameters
void Clear(Option_t *opt="") override
void CalculateIdentificationGrids()
For each IDtelescope in array, calculate an identification grid.
void prepare_to_handle_new_raw_data()
reset acquisition parameters etc. before reading new raw data event
int try_all_doubleID_telescopes(KVDetector *de, KVDetector *e, TCollection *l)
Bool_t IsSimMode() const
void FillHistogramsForAllIDTelescopes(KVSeqCollection *list)
Fill TH2F histograms for all IDTelescopes of the array.
virtual void set_detector_thicknesses(const TString &)
Bool_t ReadGridsFromAsciiFile(const Char_t *) const
virtual void InitialiseRawDataReading(KVRawDataReader *)
virtual void SetExpectedDetectorSignalNames()
virtual void SetParameters(UInt_t n, Bool_t physics_parameters_only=kFALSE)
virtual void SetDetectorParametersForRun(KVDBRun *, const TString &="")
virtual void copy_fired_parameters_to_recon_param_list()
TString GetDataSet() const
KVGroup * GetGroup(const Char_t *name) const
static TGeoHMatrix * GetVolumePositioningMatrix(Double_t distance, Double_t theta, Double_t phi, TGeoTranslation *postTrans=nullptr)
KVGeoNavigator * GetNavigator() const
KVUpDater * fUpDater
used to set parameters for multidetector
void SetGeometry(TGeoManager *)
virtual void MakeCalibrationTables(KVExpDB *)
virtual ~KVMultiDetArray()
destroy (delete) the MDA and all the associated structure, detectors etc.
virtual void SetRunIdentificationParameters(UShort_t n)
Bool_t HandleRawDataBuffer(MFMBufferReader &)
TString GetFileName(KVExpDB *, const Char_t *meth, const Char_t *keyw)
void CheckStatusOfDetectors(KVDBRun *, const TString &="")
virtual void PerformClosedROOTGeometryOperations()
UInt_t GetCurrentRunNumber() const
void SetDetectorTransparency(Char_t)
Modify the transparency of detector volumes in OpenGL view.
virtual KVGroupReconstructor * GetReconstructorForGroup(const KVGroup *) const
virtual void SetIdentifications()
static Bool_t fMakeMultiDetectorPhysicsParametersOnly
TList * fStatusIDTelescopes
used by GetStatusIDTelescopes
Bool_t fSimMode
=kTRUE in "simulation mode" (use for calculating response to simulated events)
virtual void Build(Int_t run=-1)
virtual void FillDetectorList(KVReconstructedNucleus *rnuc, KVHashList *DetList, const KVString &DetNames)
virtual Bool_t handle_raw_data_event_ebyedat(KVGANILDataReader &)
General method for reading raw data in old GANIL ebyedat format.
const TSeqCollection * GetTrajectories() const
static Bool_t fBuildTarget
KVTarget * fTarget
target used in experiment
virtual void set_up_telescope(KVDetector *de, KVDetector *e, KVIDTelescope *idt, TCollection *l)
Set up detectors in de-e identification telescope and add to fIDTelescopes and to l.
TList * GetCalibrationStatusOfDetectors()
bool try_upper_and_lower_singleIDtelescope(TString uri, KVDetector *d, TCollection *l)
virtual Bool_t handle_raw_data_event_mfmframe(const MFMCommonFrame &)
TGeoManager * GetGeometry() const
Return pointer to the (ROOT) geometry of the array.
KVRawDataReader * fRawDataReader
last raw data reader object used in call to HandleRawData
virtual void SetRawDataFromReconEvent(KVNameValueList &)
void add_and_set_detector_signal(KVDetector *det, KVString detname, Double_t sig_data, KVString sig_type)
static Int_t fMakeMultiDetectorRunNumber
virtual Bool_t HandleRawDataEvent(KVRawDataReader *)
virtual void InitializeIDTelescopes()
KVUniqueNameList fFiredDetectors
list of fired detectors after reading raw data event
virtual void RenumberGroups()
virtual void SetRunCalibrationParameters(UShort_t n)
void PrintStatusOfIDTelescopes()
bool try_upper_and_lower_doubleIDtelescope(TString uri, KVDetector *de, KVDetector *e, TCollection *l)
void PrintCalibStatusOfDetectors()
void ReadCalibrationFiles(KVExpDB *db)
virtual void SetCalibratorParameters(KVDBRun *, const TString &="")
Int_t fFilterType
type of filtering (used by DetectEvent)
virtual void SetPartSeedCond(const Char_t *cond)
std::unique_ptr< KVGeoNavigator > fNavigator
for propagating particles through array geometry
void SetGridsInTelescopes(UInt_t run)
KVIDTelescope * GetIDTelescope(const Char_t *name) const
Return pointer to DeltaE-E ID Telescope with "name".
void CalculateReconstructionTrajectories()
KVUniqueNameList fTrajectories
list of all possible trajectories through detectors of array
virtual void SetIDCodeForIDTelescope(KVIDTelescope *) const
virtual void SetReconParametersInEvent(KVReconstructedEvent *) const
Copy any parameters in fReconParameters in to the reconstructed event parameter list.
KVNameValueList fReconParameters
general purpose list of parameters for storing information on data reconstruction
TString fDataSet
name of associated dataset, used with MakeMultiDetector()
void AssociateTrajectoriesAndNodes()
void ReadCalibFile(const Char_t *filename, KVExpDB *db, KVDBTable *calib_table)
virtual void AcceptParticleForAnalysis(KVReconstructedNucleus *) const
Int_t GetIDTelescopes(KVGeoDetectorNode *, KVDetector *, TCollection *list)
void SetNavigator(KVGeoNavigator *geo)
KVMultiDetArray()
Default constructor.
KVUpDater * GetUpDater()
void DeduceGroupsFromTrajectories()
virtual void set_up_single_stage_telescope(KVDetector *det, KVIDTelescope *idt, TCollection *l)
Set up detector in single-stage identification telescope and add to fIDTelescopes and to l.
bool try_a_doubleIDtelescope(TString uri, KVDetector *de, KVDetector *e, TCollection *l)
virtual Bool_t handle_raw_data_event_mfmframe_mesytec_mdpp(const MFMMesytecMDPPFrame &)
Read a raw data event from a Mesytec MFM Frame.
KVUnownedList fFiredSignals
list of fired signals after reading raw data event
Handles lists of named parameters with different types, a list of KVNamedParameter objects.
void SetValue(const Char_t *name, value_type value)
void Clear(Option_t *opt="") override
const Char_t * GetStringValue(const Char_t *name) const
Bool_t HasParameter(const Char_t *name) const
TString GetTStringValue(const Char_t *name) const
A generic named parameter storing values of different types.
Strings used to represent a set of ranges of values.
Definition: KVNumberList.h:85
Bool_t Contains(Int_t val) const
returns kTRUE if the value 'val' is contained in the ranges defined by the number list
const Char_t * AsString(Int_t maxchars=0) const
void Set(const TString &l)
Definition: KVNumberList.h:135
Bool_t IsEmpty() const
Definition: KVNumberList.h:175
void SetIsOK(Bool_t flag=kTRUE)
Definition: KVParticle.cpp:371
Double_t GetEnergy() const
Definition: KVParticle.h:624
Read Google Protobuf DAQ files.
Wrapper for TRefArray adding some functionality.
Definition: KVRList.h:37
KVBase * FindObject(const Char_t *name, const Char_t *type) const
Definition: KVRList.cpp:106
Propagate particles through array geometry calculating energy losses.
Abstract base class for reading raw (DAQ) data.
virtual TString GetDataFormat() const =0
Event containing KVReconstructedNucleus nuclei reconstructed from hits in detectors.
Nuclei reconstructed from data measured by a detector array .
virtual Int_t GetECode() const
virtual Int_t GetIDCode() const
Combine ROOT file containing objects with SQLite database with info on the objects.
Definition: KVSQLROOTFile.h:76
ID grid manager using KVSQLROOTFile backend.
KaliVeda extensions to ROOT collection classes.
virtual TObject * FindObjectByLabel(const Char_t *) const
T * get_object(const TString &name) const
TObject * Remove(TObject *obj) override
Remove object from list.
void Add(TObject *obj) override
TObject * FindObject(const char *name) const override
KVSeqCollection * GetSubListWithType(const Char_t *retvalue) const
void Clear(Option_t *option="") override
virtual void SetCleanup(Bool_t enable=kTRUE)
void SetOwner(Bool_t enable=kTRUE) override
void Delete(Option_t *option="") override
KVSeqCollection * GetSubListWithLabel(const Char_t *retvalue) const
Extension of ROOT TString class which allows backwards compatibility with ROOT v3....
Definition: KVString.h:73
void Begin(TString delim) const
Definition: KVString.cpp:565
Bool_t End() const
Definition: KVString.cpp:634
KVString Next(Bool_t strip_whitespace=kFALSE) const
Definition: KVString.cpp:695
Int_t GetNValues(TString delim) const
Definition: KVString.cpp:886
Double_t GetParticleEIncFromERes(KVNucleus *, TVector3 *norm=0) override
Definition: KVTarget.cpp:958
void Clear(Option_t *opt="") override
Definition: KVTarget.cpp:748
Optimised list in which named objects can only be placed once.
void Add(TObject *obj) override
Abstract class implementing necessary methods for setting multidetector parameters for each run of th...
Definition: KVUpDater.h:25
virtual void SetParameters(UInt_t, Bool_t physics_parameters_only=kFALSE)
Definition: KVUpDater.cpp:91
static KVUpDater * MakeUpDater(const Char_t *uri, KVMultiDetArray *)
Definition: KVUpDater.cpp:59
virtual void SetCalibrationParameters(UInt_t)
Set calibration parameters for this run.
Definition: KVUpDater.cpp:198
virtual void SetIdentificationParameters(UInt_t)
Definition: KVUpDater.cpp:157
void SetName(const char *name)
const char * GetName() const override
virtual Int_t GetEntries() const
virtual void SetOwner(Bool_t enable=kTRUE)
Bool_t Contains(const char *name) const
THashList * GetTable() const
virtual const char * GetValue(const char *name, const char *dflt) const
virtual Int_t ReadFile(const char *fname, EEnvLevel level)
Bool_t Defined(const char *name) const
void SetStyle(Short_t st)
void SetCurrentCamera(ECameraType camera)
void SetSmoothPoints(Bool_t s)
void SetSmoothLines(Bool_t s)
TGeoVolume * GetTopVolume() const
void SetAngles(Double_t phi, Double_t theta, Double_t psi)
void SetDz(Double_t dz) override
void Draw(Option_t *option="") override
void SetTransparency(Char_t transparency=0)
virtual Int_t Fill(const char *name, Double_t w)
TObject * Next()
void Reset()
TObject * FindObject(const char *name) const override
void Add(TObject *obj) override
void Delete(Option_t *option="") override
TObject * At(Int_t idx) const override
virtual void SetTitle(const char *title="")
const char * GetName() const override
const char * GetTitle() const override
virtual void SetName(const char *name)
void AbstractMethod(const char *method) const
virtual const char * GetName() const
void SetBit(UInt_t f)
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
virtual void Info(const char *method, const char *msgfmt,...) const
const char * GetClass() const
Longptr_t ExecPlugin(int nargs)
Int_t GetEntries() const override
Double_t Atof() const
const char * Data() const
void ToUpper()
TObjArray * Tokenize(const TString &delim) const
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
TString & Prepend(char c, Ssiz_t rep=1)
void Form(const char *fmt,...)
TString & Remove(EStripType s, char c)
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
RVec< PromoteType< T > > abs(const RVec< T > &v)
TGraphErrors * gr
TH1 * h
void init()
rec
Int_t Nint(T x)
TLine l
ClassImp(TPyArg)