//___________________________________________________________________________________________ void KVValues::DefineAdditionalValue(KVString name, KVString expr) { if (HasParameter(name.Data())) { Warning("DefineAdditionalValue", "le nom de variable %s est deja utilise", name.Data()); return; } KVString expr2 = expr; KVNumberList* nl = TransformExpression(expr2); if (nl) { if (nl->IsEmpty()) { Warning("DefineAdditionalValue", "la KVNumberList est vide #%s#", nl->GetList()); } else { if (AddFormula(name, expr2)) { LinkParameters(nl); ComputeAdditionalValues(kval_add - 1, kval_add); } } } else { Error("DefineAdditionalValue", "La traduction de l'expression %s a echouee", expr.Data()); } }
KVINDRATelescope* KVINDRA::BuildTelescope(const Char_t* prefix, Int_t module) { // Build telescope from infos in file "$KVROOT/KVFiles/data/indra-struct.[dataset].env" //Info("BuildTelescope", "Building telescope %s",name); KVINDRATelescope* kvt = new KVINDRATelescope; KVString telescopes = fStrucInfos.GetValue(Form("%s.Telescope", prefix), ""); telescopes.Begin(" "); KVString name; while (!telescopes.End()) { name = telescopes.Next(); KVNumberList mods = fStrucInfos.GetValue(Form("%s.Telescope.%s.Modules", prefix, name.Data()), "1-100"); if (mods.Contains(module)) break; } KVString detectors = fStrucInfos.GetValue(Form("INDRA.Telescope.%s.Detectors", name.Data()), ""); Double_t aziwidth = fStrucInfos.GetValue(Form("INDRA.Telescope.%s.AziWidth", name.Data()), 1.0); Double_t dist = fStrucInfos.GetValue(Form("%s.Dist", prefix), 0.0); kvt->SetDistance(dist); detectors.Begin(" "); Int_t idet = 1; while (!detectors.End()) { KVString detector = detectors.Next(); detector.Begin("()"); KVString dettype = detector.Next(); Double_t detthick = detector.Next().Atof(); KVDetector* det = KVDetector::MakeDetector(Form("%s.%s", fDataSet.Data(), dettype.Data()), detthick); kvt->Add(det); Double_t depth = fStrucInfos.GetValue(Form("INDRA.Telescope.%s.Depth.%s", name.Data(), dettype.Data()), 0.); kvt->SetDepth(idet, depth); idet++; } kvt->SetAzimuthalWidth(aziwidth); return kvt; }
void KVLVContainer::ActivateItemsWithColumnData(const Char_t* colname, KVNumberList data, Bool_t activ) { KVLVColumnData* CD = fColData[((KVListView*)GetListView())->GetColumnNumber(colname)]; TGFrameElement* el; TIter next(fList); TGLVEntry* f = 0; Long_t val; data.Begin(); while (!data.End()) { Int_t nd = data.Next(); //printf("nd=%d\n",nd); next.Reset(); Bool_t find = kFALSE; while ((el = (TGFrameElement*) next()) && !find) { f = (TGLVEntry*) el->fFrame; CD->GetData((TObject*)f->GetUserData(), val); if (val == nd) { find = kTRUE; if (activ) ActivateItemFromSelectAll(el); else DeActivateItem(el); } } } fClient->NeedRedraw(this); }
void CsICalib::InitTelescope(Int_t si_num ,Int_t csi_num) { Char_t si_name [128] = "null"; Char_t csi_name [128] = "null"; sprintf(si_name, "SIE_%02i", si_num+1); sprintf(csi_name, "CSI%02i", csi_num+1); Char_t tel_name [128] = "null"; sprintf(tel_name, "SIE_%02i_CSI%02i", si_num+1, csi_num+1); list = 0; // KVList *grid_list = 0; kvid = 0; KVNumberList runList = 0; list = (KVList*) gIDGridManager->GetGrids(); if(list != 0){ Int_t entries = (Int_t) list->GetEntries(); // Int_t kHasGrids = 0; KVIDGrid *tmpGrid = 0; // Int_t nGridsForRun = 0; for(Int_t i=0; i<entries; i++){ tmpGrid = (KVIDGrid*) list->At(i); if(tmpGrid != 0){ runList = (KVNumberList) tmpGrid->GetRuns(); runList.Begin(); while( !runList.End() ){ UInt_t next_val = (UInt_t) runList.Next(); if(next_val == gIndra->GetCurrentRunNumber()){ if(strcmp(tmpGrid->GetName(),tel_name)==0){ kvid = tmpGrid; } } } } } if(kvid != 0){ }else{ /*printf("Error: 'kvid' assignment failed\n"); cout<<"si_num : "<<si_num<<" csi_num : "<<csi_num<<endl; cout<<"name : "<<tel_name<<endl;*/ } }else{ //printf("Error: 'list' assignment failed\n"); } }
void KVAvailableRunsFile::RemoveDuplicateLines(KVNumberList lines_to_be_removed) { // Remove from available runs file all lines whose numbers are in the list //does runlist exist ? if (!OpenAvailableRunsFile()) { Error("Remove", "Error opening available runs file"); return; } //open temporary file TString tmp_file_path(GetFileName()); ofstream tmp_file; KVBase::OpenTempFile(tmp_file_path, tmp_file); //loop over lines in fRunlist file //all lines which are not in list are directly copied to temp file TString line; Int_t line_number=1; line.ReadLine(fRunlist); lines_to_be_removed.Begin(); Int_t next_line_to_remove = 0; if(!lines_to_be_removed.End()) next_line_to_remove = lines_to_be_removed.Next(); while (fRunlist.good()) { if(line_number!=next_line_to_remove) tmp_file << line.Data() << endl; else { if(!lines_to_be_removed.End()) next_line_to_remove = lines_to_be_removed.Next(); } line_number++; line.ReadLine(fRunlist); } CloseAvailableRunsFile(); TString fRunlist_path; AssignAndDelete(fRunlist_path, gSystem->ConcatFileName(GetFilePath(), GetFileName())); //keep lock on runsfile if( !runlist_lock.Lock( fRunlist_path.Data() ) ) return; //close temp file tmp_file.close(); //copy temporary file to KVFiles directory, overwrite previous gSystem->CopyFile(tmp_file_path, fRunlist_path, kTRUE); //set access permissions to 664 gSystem->Chmod(fRunlist_path.Data(), CHMODE(6,6,4)); //delete temp file gSystem->Unlink(tmp_file_path); //unlock runsfile runlist_lock.Release(); }
KVNumberList KVAvailableRunsFile::CheckMultiRunfiles() { //Returns a list with all runs which occur more than once in the available runs file. // //does runlist exist ? // if (!OpenAvailableRunsFile()) { // Error("CheckMultiRunfiles", "Cannot open available runs file"); // return 0; // } // // TString fLine; // TList *run_list = new TList; // fLine.ReadLine(fRunlist); // // KVNumberList multiruns; // // Int_t fRunNumber; // KVDBTable *runs_table = fDataSet->GetDataBase()->GetTable("Runs"); // // while (fRunlist.good()) { // // TObjArray *toks = fLine.Tokenize('|'); // split into fields // KVString kvs(((TObjString *) toks->At(0))->GetString()); // fRunNumber = kvs.Atoi(); // delete toks; // // KVDBRun *a_run = (KVDBRun *) runs_table->GetRecord(fRunNumber); // // if (!run_list->Contains(a_run)) { // //first time that run appears // run_list->Add(a_run); // } else { // //run appears >1 times // multiruns.Add(fRunNumber); // } // // fLine.ReadLine(fRunlist); // } // delete run_list; // CloseAvailableRunsFile(); // // return multiruns; ReadFile(); KVNumberList multiruns; TIter next(fAvailableRuns); KVNameValueList* run; while( (run = (KVNameValueList*)next()) ){ if(run->GetIntValue("Occurs")>1) multiruns.Add(run->GetName()); } return multiruns; }
KVNumberList KVAvailableRunsFile::GetRunList(const KVDBSystem * sys) { //Returns list of available run numbers for this data type. //If 'sys' gives the address of a valid database reaction system, only runs //corresponding to the system will be included. KVNumberList runs; //does runlist exist ? if (!OpenAvailableRunsFile()) { Error("GetRunList", "Cannot open available runs file"); return runs; } TString fLine; fLine.ReadLine(fRunlist); Int_t fRunNumber; KVDBTable *runs_table = 0; KVDataBase* db = fDataSet->GetDataBase(); if (!db){ db = new KVDataBase(); db->AddTable("Runs","List of Runs"); } runs_table = db->GetTable("Runs"); //KVDBTable *runs_table = fDataSet->GetDataBase()->GetTable("Runs"); while (fRunlist.good()) { TObjArray *toks = fLine.Tokenize('|'); // split into fields KVString kvs(((TObjString *) toks->At(0))->GetString()); fRunNumber = kvs.Atoi(); delete toks; if (sys) { // check run is from right system KVDBRun *a_run = (KVDBRun *) runs_table->GetRecord(fRunNumber); if (a_run) { if (a_run->GetSystem() == sys) runs.Add(fRunNumber); } } else { // add all runs to list runs.Add(fRunNumber); } fLine.ReadLine(fRunlist); } CloseAvailableRunsFile(); return runs; }
void CsICalib::InitTelescopeSiTof(Int_t si_num) { Char_t tel_name [128] = "null"; sprintf(tel_name, "SIE%i_TOF",si_num+1); list_sitof = 0; // KVList *grid_list = 0; kvid_sitof = 0; KVNumberList runList = 0; list_sitof = (KVList*) gIDGridManager->GetGrids(); if(list_sitof != 0){ Int_t entries = (Int_t) list_sitof->GetEntries(); // Int_t kHasGrids = 0; KVIDGrid *tmpGrid = 0; // Int_t nGridsForRun = 0; for(Int_t i=0; i<entries; i++){ tmpGrid = (KVIDGrid*) list_sitof->At(i); if(tmpGrid != 0){ runList = (KVNumberList) tmpGrid->GetRuns(); runList.Begin(); while( !runList.End() ){ UInt_t next_val = (UInt_t) runList.Next(); if(next_val == gIndra->GetCurrentRunNumber()){ if(strcmp(tmpGrid->GetName(),tel_name)==0){ kvid_sitof = tmpGrid; } } } } } if(kvid_chiosi != 0){ }else{ printf("Error: 'kvid_sitof' assignment failed\n"); cout<<"name : "<<tel_name<<endl; } }else{ //printf("Error: 'list' assignment failed\n"); } return; }
void KVINDRA::BuildLayer(const Char_t* name) { // Build layer 'name' with infos in file "$KVROOT/KVFiles/data/indra-struct.[dataset].env" KVLayer* layer = new KVLayer; Int_t number = fStrucInfos.GetValue(Form("INDRA.Layer.%s.Number", name), 0); layer->SetName(name); layer->SetNumber(number); Add(layer); Info("BuildLayer", "Building layer %d:%s", number, name); KVNumberList rings = fStrucInfos.GetValue(Form("INDRA.Layer.%s.Rings", name), ""); rings.Begin(); while (!rings.End()) { Int_t ring_num = rings.Next(); TString prefix = Form("INDRA.Layer.%s.Ring.%d", name, ring_num); KVRing* ring = BuildRing(ring_num, prefix); layer->Add(ring); } }
KVRing* KVINDRA::BuildRing(Int_t number, const Char_t* prefix) { // Build ring with infos in file "$KVROOT/KVFiles/data/indra-struct.[dataset].env" KVRing* ring = new KVRing; Info("BuildRing", "Building ring %d (%s)", number, prefix); Double_t thmin = fStrucInfos.GetValue(Form("%s.ThMin", prefix), 0.0); Double_t thmax = fStrucInfos.GetValue(Form("%s.ThMax", prefix), 0.0); Double_t phi_0 = fStrucInfos.GetValue(Form("%s.Phi0", prefix), 0.0); Int_t ntel = fStrucInfos.GetValue(Form("%s.Ntel", prefix), 0); Int_t step = fStrucInfos.GetValue(Form("%s.Step", prefix), 1); Int_t num_first = fStrucInfos.GetValue(Form("%s.Nfirst", prefix), 1); Double_t dphi = fStrucInfos.GetValue(Form("%s.Dphi", prefix), -1.0); KVNumberList absent = fStrucInfos.GetValue(Form("%s.Absent", prefix), ""); ring->SetPolarMinMax(thmin, thmax); KVINDRATelescope* kvt = BuildTelescope(prefix, num_first); Double_t phi_min = phi_0 - 0.5 * (kvt->GetAzimuthalWidth()); phi_min = (phi_min < 0. ? phi_min + 360. : phi_min); dphi = (dphi < 0. ? 360. / ntel : dphi); Double_t phi_max = phi_0 + ((ntel - 1.0) * dphi) + 0.5 * (kvt->GetAzimuthalWidth()); phi_max = (phi_max > 360. ? phi_max - 360. : phi_max); ring->SetAzimuthalMinMax(phi_min, phi_max); ring->SetNumber(number); Double_t phi = phi_0; UInt_t counter = num_first; for (int i = 0; i < ntel; i++) { kvt->SetPolarMinMax(thmin, thmax); kvt->SetPhi(phi); phi = (phi + dphi > 360. ? (phi + dphi - 360.) : (phi + dphi)); kvt->SetNumber(counter); if (!absent.Contains(counter)) ring->Add(kvt); else delete kvt; counter += step; if (i + 1 < ntel) kvt = BuildTelescope(prefix, counter); } ring->SetName(Form("RING_%d", number)); return ring; }
//___________________________________________________________________________________________ void KVValues::ComputeAdditionalValues(Int_t min, Int_t max) { if (min < 0) min = 0; if (max == -1) max = kval_add; KVNumberList* nl = 0; TFormula* fm = 0; for (Int_t ff = min; ff < max; ff += 1) { nl = (KVNumberList*)kpar_add->At(ff); fm = (TFormula*)kform_add->At(ff); nl->Begin(); while (!nl->End()) { Int_t nn = nl->Next(); fm->SetParameter(nn, values[nn]); } values[kval_tot - kval_add + ff] = fm->Eval(0); } }
KVIonRangeTableMaterial* KVRangeYanez::MakeNaturallyOccuringElementMixture(Int_t z) { // create a material containing the naturally occuring isotopes of the given element, // weighted according to their abundance. if (!gNDTManager) { Error("MakeNaturallyOccuringElementMixture", "Nuclear data tables have not been initialised"); return NULL; } KVElementDensity* ed = (KVElementDensity*)gNDTManager->GetData(z, z, "ElementDensity"); if (!ed) { Error("AddElementalMaterial", "No element found in ElementDensity NDT-table with Z=%d", z); return 0x0; } TString state = "solid"; if (ed->IsGas()) state = "gas"; KVRangeYanezMaterial* mat = new KVRangeYanezMaterial(this, ed->GetElementName(), ed->GetElementSymbol(), state, ed->GetValue()); KVNucleus nuc(z); KVNumberList isotopes = nuc.GetKnownARange(); isotopes.Begin(); while (!isotopes.End()) { nuc.SetA(isotopes.Next()); Double_t abundance = nuc.GetAbundance() / 100.; if (abundance > 0.) mat->AddMixtureElement(z, nuc.GetA(), 1, abundance); } mat->Initialize(); return (KVIonRangeTableMaterial*)mat; }
//_____________________________________________________________________________________________________// KVIDGrid* KVIDTelescope::CalculateDeltaE_EGrid(TH2* haa_zz, Bool_t Zonly, Int_t npoints) { //Genere une grille dE-E (perte d'energie - energie residuelle) //Le calcul est fait pour chaque couple comptant de charge (Z) et masse (A) //au moins un coup dans l'histogramme haa_zz definit : // Axe X -> Z // Axe Y -> A // //- Si Zonly=kTRUE (kFALSE par defaut), pour un Z donne, le A choisi est la valeur entiere la //plus proche de la valeur moyenne <A> //- Si Zonly=kFALSE et que pour un Z donne il n'y a qu'un seul A associe, les lignes correspondants //a A-1 et A+1 sont ajoutes //- Si a un Z donne, il n'y a aucun A, pas de ligne tracee //un noyau de A et Z donne n'est considere que s'il retourne KVNucleus::IsKnown() = kTRUE // // Warning : the grid is not added to the list of the telescope and MUST BE DELETED by the user ! if (GetSize() <= 1) return 0; TClass* cl = new TClass(GetDefaultIDGridClass()); KVIDGrid* idgrid = (KVIDGrid*)cl->New(); delete cl; idgrid->AddIDTelescope(this); idgrid->SetOnlyZId(Zonly); KVDetector* det_de = GetDetector(1); if (!det_de) return 0; KVDetector* det_eres = GetDetector(2); if (!det_eres) return 0; KVNucleus part; Info("CalculateDeltaE_EGrid", "Calculating dE-E grid: dE detector = %s, E detector = %s", det_de->GetName(), det_eres->GetName()); KVIDCutLine* B_line = (KVIDCutLine*)idgrid->Add("OK", "KVIDCutLine"); Int_t npoi_bragg = 0; B_line->SetName("Bragg_line"); B_line->SetAcceptedDirection("right"); Double_t SeuilE = 0.1; for (Int_t nx = 1; nx <= haa_zz->GetNbinsX(); nx += 1) { Int_t zz = TMath::Nint(haa_zz->GetXaxis()->GetBinCenter(nx)); KVNumberList nlA; Double_t sumA = 0, sum = 0; for (Int_t ny = 1; ny <= haa_zz->GetNbinsY(); ny += 1) { Double_t stat = haa_zz->GetBinContent(nx, ny); if (stat > 0) { Double_t val = haa_zz->GetYaxis()->GetBinCenter(ny); nlA.Add(TMath::Nint(val)); sumA += val * stat; sum += stat; } } sumA /= sum; Int_t nA = nlA.GetNValues(); if (nA == 0) { Warning("CalculateDeltaE_EGrid", "no count for Z=%d", zz); } else { if (Zonly) { nlA.Clear(); nlA.Add(TMath::Nint(sumA)); } else { if (nA == 1) { Int_t aref = nlA.Last(); nlA.Add(aref - 1); nlA.Add(aref + 1); } } part.SetZ(zz); // printf("zz=%d\n",zz); nlA.Begin(); while (!nlA.End()) { Int_t aa = nlA.Next(); part.SetA(aa); // printf("+ aa=%d known=%d\n",aa,part.IsKnown()); if (part.IsKnown()) { //loop over energy //first find : // ****E1 = energy at which particle passes 1st detector and starts to enter in the 2nd one**** // E2 = energy at which particle passes the 2nd detector //then perform npoints calculations between these two energies and use these //to construct a KVIDZALine Double_t E1, E2; //find E1 //go from SeuilE MeV to det_de->GetEIncOfMaxDeltaE(part.GetZ(),part.GetA())) Double_t E1min = SeuilE, E1max = det_de->GetEIncOfMaxDeltaE(zz, aa); E1 = (E1min + E1max) / 2.; while ((E1max - E1min) > SeuilE) { part.SetEnergy(E1); det_de->Clear(); det_eres->Clear(); det_de->DetectParticle(&part); det_eres->DetectParticle(&part); if (det_eres->GetEnergy() > SeuilE) { //particle got through - decrease energy E1max = E1; E1 = (E1max + E1min) / 2.; } else { //particle stopped - increase energy E1min = E1; E1 = (E1max + E1min) / 2.; } } //add point to Bragg line Double_t dE_B = det_de->GetMaxDeltaE(zz, aa); Double_t E_B = det_de->GetEIncOfMaxDeltaE(zz, aa); Double_t Eres_B = det_de->GetERes(zz, aa, E_B); B_line->SetPoint(npoi_bragg++, Eres_B, dE_B); //find E2 //go from E1 MeV to maximum value where the energy loss formula is valid Double_t E2min = E1, E2max = det_eres->GetEmaxValid(part.GetZ(), part.GetA()); E2 = (E2min + E2max) / 2.; while ((E2max - E2min > SeuilE)) { part.SetEnergy(E2); det_de->Clear(); det_eres->Clear(); det_de->DetectParticle(&part); det_eres->DetectParticle(&part); if (part.GetEnergy() > SeuilE) { //particle got through - decrease energy E2max = E2; E2 = (E2max + E2min) / 2.; } else { //particle stopped - increase energy E2min = E2; E2 = (E2max + E2min) / 2.; } } // printf("z=%d a=%d E1=%lf E2=%lf\n",zz,aa,E1,E2); KVIDZALine* line = (KVIDZALine*)idgrid->Add("ID", "KVIDZALine"); if (TMath::Even(zz)) line->SetLineColor(4); line->SetAandZ(aa, zz); Double_t logE1 = TMath::Log(E1); Double_t logE2 = TMath::Log(E2); Double_t dLog = (logE2 - logE1) / (npoints - 1.); for (Int_t i = 0; i < npoints; i++) { Double_t E = TMath::Exp(logE1 + i * dLog); Double_t Eres = 0.; Int_t niter = 0; while (Eres < SeuilE && niter <= 20) { det_de->Clear(); det_eres->Clear(); part.SetEnergy(E); det_de->DetectParticle(&part); det_eres->DetectParticle(&part); Eres = det_eres->GetEnergy(); E += SeuilE; niter += 1; } if (!(niter > 20)) { Double_t dE = det_de->GetEnergy(); Double_t gEres, gdE; line->GetPoint(i - 1, gEres, gdE); line->SetPoint(i, Eres, dE); } } } } } } return idgrid; }
//___________________________________________________________________________________________ KVNumberList* KVValues::TransformExpression(KVString& expr) { KVNumberList* nl = new KVNumberList(); const char* O = "["; const char* F = "]"; KVString clone; clone.Form("%s", expr.Data()); const char* expression = clone.Data(); Int_t nouvert = 0, nferme = 0; Int_t posouvert = 0, posferme = 0; Int_t nvar = 0; Int_t nsize = clone.Length(); for (Int_t ii = 0; ii <= nsize; ii += 1) { if (expression[ii] == O[0]) { nouvert += 1; posouvert = ii; } else if (expression[ii] == F[0]) { nferme += 1; posferme = ii; KVString st(clone(posouvert + 1, posferme - posouvert - 1)); if (st.IsDigit()) { Int_t idx = st.Atoi(); if (0 <= idx && idx < kval_tot) { nl->Add(idx); nvar += 1; } else { delete nl; return 0; } } else { Int_t idx = GetValuePosition(st.Data()); if (idx == -1) { delete nl; return 0; } nl->Add(idx); nvar += 1; KVString s1; s1.Form("[%s]", st.Data()); KVString s2; s2.Form("[%d]", idx); expr.ReplaceAll(s1, s2); } } else {} } if (nouvert != nferme || nvar != nouvert) { Error("TransformExpr", "nombre [ : %d - nombre de ] : %d - nombre de variables %d", nouvert, nferme, nvar); } return nl; }
void KV_CCIN2P3_GE::Run() { //Processes the job requests for the batch system. //In normal mode, this submits one job for the data analyser fAnalyser //In multijobs mode, this submits one job for each run in the runlist associated to fAnalyser if (!CheckJobParameters()) return; if (MultiJobsMode()) { if (fAnalyser->InheritsFrom("KVDataSetAnalyser")) { //submit jobs for every GetRunsPerJob() runs in runlist KVDataSetAnalyser* ana = dynamic_cast<KVDataSetAnalyser*>(fAnalyser); KVNumberList runs = ana->GetRunList(); runs.Begin(); Int_t remaining_runs = runs.GetNValues(); fCurrJobRunList.Clear(); while (remaining_runs && !runs.End()) { Int_t run = runs.Next(); remaining_runs--; fCurrJobRunList.Add(run); if ((fCurrJobRunList.GetNValues() == GetRunsPerJob()) || runs.End()) { // submit job for GetRunsPerJob() runs (or less if we have reached end of runlist 'runs') ana->SetRuns(fCurrJobRunList, kFALSE); ana->SetFullRunList(runs); SubmitJob(); fCurrJobRunList.Clear(); } } ana->SetRuns(runs, kFALSE); } else if (fAnalyser->InheritsFrom("KVSimDirAnalyser")) { // here we understand "run" to mean "file" KVSimDirAnalyser* ana = dynamic_cast<KVSimDirAnalyser*>(fAnalyser); TList* file_list = ana->GetFileList(); Int_t remaining_runs = ana->GetNumberOfFilesToAnalyse(); fCurrJobRunList.Clear(); TList cur_file_list; TObject* of; TIter it(file_list); Int_t file_no = 1; while ((of = it())) { cur_file_list.Add(of); fCurrJobRunList.Add(file_no); remaining_runs--; file_no++; if ((fCurrJobRunList.GetNValues() == GetRunsPerJob()) || (remaining_runs == 0)) { // submit job for GetRunsPerJob() files (or less if we have reached end of list) ana->SetFileList(&cur_file_list); SubmitJob(); fCurrJobRunList.Clear(); cur_file_list.Clear(); } } ana->SetFileList(file_list); } } else { SubmitJob(); } }
void CsICalib::InitTelescopeChioSi(Int_t ci_num, Int_t si_num) { Char_t si_name [128] = "null"; Char_t ci_name [128] = "null"; sprintf(si_name, "SIE_%02i", si_num+1); sprintf(ci_name, "CI_%02i", ci_num); Char_t tel_name [128] = "null"; //sprintf(tel_name, "CI_%02i_SIE_%02i", ci_num, si_num+1); sprintf(tel_name, "CI_01_SIE_18"); //Similar grids (using energies) for all Chio-Si combinaisons //cout<<"tel_name 1: "<<tel_name<<endl; list_chiosi = 0; // KVList *grid_list = 0; kvid_chiosi = 0; KVNumberList runList = 0; list_chiosi = (KVList*) gIDGridManager->GetGrids(); if(list_chiosi != 0){ //cout<<"list_chiosi!=0"<<endl; Int_t entries = (Int_t) list_chiosi->GetEntries(); // Int_t kHasGrids = 0; KVIDGrid *tmpGrid = 0; // Int_t nGridsForRun = 0; for(Int_t i=0; i<entries; i++){ tmpGrid = (KVIDGrid*) list_chiosi->At(i); if(tmpGrid != 0){ //cout<<"tmpGrid!=0"<<endl; runList = (KVNumberList) tmpGrid->GetRuns(); runList.Begin(); while( !runList.End() ){ UInt_t next_val = (UInt_t) runList.Next(); if(next_val == gIndra->GetCurrentRunNumber()){ //cout<<"next_val : "<<next_val<<endl; //L->Log<<"name : "<<tmpGrid->GetName()<<endl; if(strcmp(tmpGrid->GetName(),tel_name)==0){ //L->Log<<"tel_name 2 : "<<tmpGrid->GetName()<<endl; //cout<<"tel_name 2: "<<tel_name<<endl; kvid_chiosi = tmpGrid; } } } } } if(kvid_chiosi != 0){ }else{ printf("Error: 'kvid_chiosi' assignment failed\n"); cout<<"ci_num : "<<ci_num<<" si_num : "<<si_num+1<<endl; cout<<"name : "<<tel_name<<endl; } }else{ //printf("Error: 'list' assignment failed\n"); } return; }