read_fgtSimuParams() {
// base libraries
gSystem->Load("St_base");
gSystem->Load("StChain");
gSystem->Load("StUtilities");
gSystem->Load("StIOMaker");
gSystem->Load("StarClassLibrary");
// db-related libraries
gSystem->Load("St_Tables");
gSystem->Load("StDbLib");
gSystem->Load("StDbBroker");
gSystem->Load("St_db_Maker");
St_db_Maker *dbMk=new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(20120301,0); // event or run start time, set to your liking
dbMk->SetFlavor("ofl");
dbMk->Init();
dbMk->Make();
TDataSet *DB = 0;
DB = dbMk->GetDataBase("Calibrations/fgt/fgtSimuParams");
if (!DB) {
std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl;
}
St_fgtSimuParams *dataset = 0;
dataset = (St_fgtSimuParams*) DB->Find("fgtSimuParams");
Int_t rows = dataset->GetNRows();
if (rows > 1) {
std::cout << "BAD INFO: found INDEXED table with " << rows << " rows, abort" << std::endl;
return;
}
if (dataset) {
fgtSimuParams_st *table = dataset->GetTable();
int irow=0;
printf(" print fgtSimuParams: comment=%s=\n", table[irow].comment);
for (Int_t i = 0; i < 15; i++) {
// sample output of few params
std::cout << i << "th param : " << table[irow].param[i] << std::endl;
}
} else {
std::cout << "ERROR: dataset does not contain requested table" << std::endl;
return;
}
}
//_____________________________________________________________________________
void StarMCHits::MakeDetectorDescriptors() {
if (! gGeoManager) {
cout << "No gGeoManager" << endl;
return;
}
TDataSet *Detectors = StMaker::GetChain()->GetDataBase("VmcGeometry/Index");
if (! Detectors) {
cout << "No Detectors found in VmcGeometry/Index" << endl;
}
// Make List of sensitive volumes
TObjArray *vols = gGeoManager->GetListOfVolumes();
Int_t nvol = vols->GetEntriesFast();
Int_t nSensVol = 0;
Int_t nsize = 100;
TArrayI Indx(nsize); Int_t *indx = Indx.GetArray();
for (Int_t i = 0; i < nvol; i++) {
TGeoVolume *vol = (TGeoVolume *) vols->At(i);
if (! vol) continue;
TGeoMedium *med = vol->GetMedium();
if (! med) continue;
Int_t isvol = (Int_t) med->GetParam(0);
if (! isvol) continue;
indx[nSensVol] = i;
nSensVol++;
if (nSensVol >= nsize) {
nsize *= 2;
Indx.Set(nsize);
indx = Indx.GetArray();
}
TString Path(MakeDetectorDescriptor(vol->GetName()));
if (Detectors) {
// Check consistency
StarVMCDetector *det = (StarVMCDetector *) Detectors->Find(vol->GetName());
if (! det) {
cout << "Detector description for " << vol->GetName() << "\t" << vol->GetTitle() << " is missing" << endl;
} else {
TString FMT = det->GetFMT();
cout << "Found path:\t" << Path.Data() << endl;
cout << "Set path:\t" << FMT.Data();
if (Path == FMT) cout << " are the same" << endl;
else cout << " are the different" << endl;
}
}
}
}
TestSorter() {
gROOT->Macro("loadMuDst.C");
gSystem->Load("StDbBroker");
gSystem->Load("St_db_Maker");
// get the table
St_db_Maker dbMk("StarDb", "MySQL:StarDb");
dbMk.Init();
TDataSet *DB = dbMk.GetInputDB("Calibrations/emc/map");
St_bemcMap* bemc = (St_bemcMap*)DB->Find("bemcMap");
// build the sorter
TString key="daqID";
TTableSorter sorter(bemc, key);
int matches = 0;
int linearFound = 0;
int sorterFound = 0;
for(short daq=0; daq<4800; ++daq) {
// find row by linear search first
short linearSearchResult = -1;
for(int i=0; i<4800; ++i) {
if( ((*bemc)[i]).daqID == daq ) {
linearSearchResult = i;
linearFound += 1;
break;
}
}
// now try to find daqID using TTableSorter
int sorterResult = sorter[daq];
if(sorterResult > -1) sorterFound += 1;
cout << "daqID " << daq << "\tlinear found row: " << linearSearchResult
<< "\tsorter found row: " << sorterResult << endl;
if(linearSearchResult == sorterResult) matches += 1;
}
cout << "Summary: linear found " << linearFound << ", sorter found " <<
sorterFound << " and we had " << matches << " agreements." << endl;
}
//________________________________________________________________________________
//void Db(const Char_t *tabNam = "Calibrations/tpc/noiseElim",
// void DbS(const Char_t *tabNam =
// "Survey/svt/LadderOnSurvey",Int_t date = 20051101, Int_t time = 0
void MakeSvtWaferOnGlobal(Int_t date = 20050101, Int_t time = 65 ){
TGeoHMatrix GL, WL,LSU,LSH,SHG,WG;
if (dbMk == 0) Load();
dbMk->SetDebug(2);
dbMk->SetDateTime(date,time);
// dbMk->SetFlavor("ofl+laserDV","tpcDriftVelocity");
// dbMk->SetMaxEntryTime(20040520,0);
// to browse 1 database, use this one
TDataSet *set = dbMk->GetDataBase("Geometry/ssd");
if (! set) return; // Positioning of the SSD:
St_Survey *SsdOnGlobal = (St_Survey *) set->Find("SsdOnGlobal");
if (! SsdOnGlobal) {cout << "SsdOnGlobal has not been found" << endl; return;}
Survey_st *OnGlobal = SsdOnGlobal->GetTable(); // SSD and SVT as whole
GL.SetRotation(&OnGlobal->r00);
GL.SetTranslation(&OnGlobal->t0); //cout << "WL\t"; WL.Print();
set = dbMk->GetDataBase("Geometry/svt");
St_Survey *WaferOnLadder = (St_Survey *) set->Find("WaferOnLadder");
St_Survey *LadderOnSurvey = (St_Survey *) set->Find("LadderOnSurvey");
St_Survey *LadderOnShell = (St_Survey *) set->Find("LadderOnShell");
St_Survey *ShellOnGlobal = (St_Survey *) set->Find("ShellOnGlobal");
Int_t NW = WaferOnLadder->GetNRows();
Int_t NL = LadderOnSurvey->GetNRows();
Survey_st *waferOnLadder = WaferOnLadder->GetTable();
Survey_st *ladderOnSurvey = LadderOnSurvey->GetTable();
Survey_st *ladderOnShell = LadderOnShell->GetTable();
Survey_st *shellOnGlobal0 = ShellOnGlobal->GetTable(0);
Survey_st *shellOnGlobal1 = ShellOnGlobal->GetTable(1);
St_svtWafersPosition *svtwafer = new St_svtWafersPosition("svtWafersPosition",216);
svtWafersPosition_st row;
for (Int_t i = 0; i < NW; i++, waferOnLadder++)
{
Int_t Idw = waferOnLadder->Id;
WL.SetRotation(&waferOnLadder->r00);
WL.SetTranslation(&waferOnLadder->t0);
// if (i==0) WL.Print();
Int_t wshell = 0;
Int_t wbarrel = Idw/1000;
Int_t wwafer = (Idw - 1000*wbarrel)/100;
Int_t wladder = Idw%100;
Int_t wlayer = 2*wbarrel + wladder%2 - 1;
// cout << waferOnLadder->Id << " "<< Idw<< " " << 100*wwafer + wladder + 1000*wlayer <<endl;
for ( Int_t j = 0; j < NL; j++, ladderOnSurvey++, ladderOnShell++)
{
Int_t Idl = ladderOnSurvey->Id;
Int_t lbarrel = Idl/1000;
Int_t lladder = Idl%100;
if( wladder == lladder )
{
LSU.SetRotation(&ladderOnSurvey->r00);
LSU.SetTranslation(&ladderOnSurvey->t0);
LSH.SetRotation(&ladderOnShell->r00);
LSH.SetTranslation(&ladderOnShell->t0);
if( (wbarrel == 1 && wladder <= 4) || (wbarrel == 2 && wladder <= 6) || (wbarrel == 3 && wladder <= 8) )
{
SHG.SetRotation(&shellOnGlobal0->r00);
SHG.SetTranslation(&shellOnGlobal0->t0);
}else
{
SHG.SetRotation(&shellOnGlobal1->r00);
SHG.SetTranslation(&shellOnGlobal1->t0);
}
// SsdOnGlobal * ShellOnGlobal * LadderOnShell * LadderOnSurvey * WaferOnLadder
WG = GL * SHG * LSH * LSU * WL; // WG.Print();
// TGeoHMatrix WGInv = WG.Inverse();
Double_t *r = WG.GetRotationMatrix();
Int_t fail = 0;
for (int l = 0; l < 9; l++) {
if (TMath::Abs(r[l]) >= 1.000001) fail++;
}
if (fail) {
cout << "===============" << waferOnLadder->Id << " "<< Idw << " " << 100*wwafer + wladder + 1000*wlayer <<endl;
cout << "WG\t"; WG.Print();
// cout << "SHG\t"; SHG.Print();
// cout << "LSH\t"; LSH.Print();
// cout << "LSU\t"; LSU.Print();
// cout << "WL\t"; WL.Print();
}
row.driftDirection[0] = r[0]; row.normalDirection[0] = r[1]; row.transverseDirection[0] = r[2];
row.driftDirection[1] = r[3]; row.normalDirection[1] = r[4]; row.transverseDirection[1] = r[5];
row.driftDirection[2] = r[6]; row.normalDirection[2] = r[7]; row.transverseDirection[2] = r[8];
Double_t norm;
TVector3 d(row.driftDirection); norm = 1/d.Mag(); d *= norm;
TVector3 t(row.transverseDirection); norm = 1/t.Mag(); t *= norm;
TVector3 n(row.normalDirection);
TVector3 c = d.Cross(t);
if (c.Dot(n) < 0) c *= -1;
d.GetXYZ(row.driftDirection);
t.GetXYZ(row.transverseDirection);
c.GetXYZ(row.normalDirection);
row.ID = 100*wwafer + wladder + 1000*wlayer;
Double_t *wgtr = WG.GetTranslation();
memcpy(row.centerPosition,wgtr, 3*sizeof(Double_t));
svtwafer->AddAt(&row);
break;
}
}
}
ofstream out;
out.open(Form("svtWafersPosition.%8i.%06i.C",date,time));
svtwafer->SavePrimitive(out,"");
out.close();
}
void fms_db_ChannelGeometry(char* opt="readdb", int year = 15) {
TString option(opt);
std::cout << "Opt =" << opt << "\n";
std::cout << "readdb = " << option.Contains("readdb") << "\n";
std::cout << "writedb = " << option.Contains("writedb") << "\n";
std::cout << "\n";
TString storeTime; // storetime is begin time for validity range for WRITING DB
int date,time; // time for READING DB
std::cout << "year = " << year << "\n";
if(year==8){
storeTime="2007-11-09 00:00:02";
date = 20080301;
time = 0;
}else if(year==9){
storeTime="2008-11-09 00:00:01";
date = 20090301;
time = 0;
}else if(year=15){
storeTime="2014-12-20 00:00:00";
date = 20141220;
// date = 20140222;
time = 0;
}
else{
std::cout << "Please specify year\n";
exit;
}
std::cout << "storetime =" << storeTime << "\n";
std::cout << "date,time =" << date <<" "<< time << "\n";
gROOT->Macro("LoadLogger.C");
gSystem->Load("St_base.so");
gSystem->Load("libStDb_Tables.so");
gSystem->Load("StDbLib.so");
// max index dimensions
const Int_t MAXINDEX = 12;
int n=0;
// structure to fill up
fmsChannelGeometry_st g[MAXINDEX];
memset(g,0,sizeof(g));
gSystem->Load("StChain");
gSystem->Load("StBFChain");
gSystem->Load("StUtilities");
gSystem->Load("StIOMaker");
gSystem->Load("StarClassLibrary");
gSystem->Load("St_Tables");
gSystem->Load("StDbLib");
gSystem->Load("StDbBroker");
gSystem->Load("St_db_Maker");
St_db_Maker *dbMk=new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(date,time);
dbMk->SetFlavor("ofl"); // for offline calibrations/mapping
// dbMk->SetFlavor("simu"); // for simulations
dbMk->Init();
dbMk->Make();
// this is done inside ::Make method
TDataSet *DB = 0;
// "dbMk->" will NOT be needed.
// if done inside your FmsDbMaker. Simply use DB = GetInputDb("Geometry/fms")
DB = dbMk->GetInputDB("Geometry/fms/");
if (!DB) { std::cout << "ERROR: no db maker?" << std::endl; }
if(option.Contains("readdb")){
gSystem->Unsetenv("DB_ACCESS_MODE");
gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG");
St_fmsChannelGeometry *db = 0;
db = (St_fmsChannelGeometry*) DB->Find("fmsChannelGeometry");
// fetch data and place it to appropriate structure
if (db) {
std::cout << "Reading fmsMap table\n";
fmsChannelGeometry_st *table = db->GetTable();
n = db->GetNRows();
memcpy(g,table,sizeof(fmsChannelGeometry_st)*n);
} else {
std::cout << "WARNING: No data in fmsChannelGeometry table (wrong timestamp?). Nothing to return, then.\n";
}
}
if(option.Contains("writedb")) {
gSystem->Setenv("DB_ACCESS_MODE","write");
cout << "DB_ACCESS_MODE="<<gSystem->Getenv("DB_ACCESS_MODE")<<endl;
StDbManager* mgr = StDbManager::Instance();
StDbConfigNode* node = mgr->initConfig("Geometry_fms");
StDbTable* wtable = node->addDbTable("fmsChannelGeometry");
mgr->setStoreTime(storeTime.Data());
// input data
/* Detector Name detectorId ew ns type nX nY */
/* FPD-North 0 0 0 0 7 7 */
/* FPD-South 1 0 1 0 7 7 */
/* FPD-North-Pres 2 0 0 1 7 1 */
/* FPD-South-Pres 3 0 1 1 7 1 */
/* FPD-North-SMDV 4 0 0 2 48 1 */
/* FPD-South-SMDV 5 0 1 2 48 1 */
/* FPD-North-SMDH 6 0 0 3 1 48 */
/* FPD-South-SMDH 7 0 1 3 1 48 */
/* FMS-North-Large 8 1 0 4 17 34 */
/* FMS-South-Large 9 1 1 4 17 34 */
/* FMS-North-Small 10 1 0 0 12 24 */
/* FMS-South-Small 11 1 1 0 12 24 */
/* FHC-North 12 1 0 5 9 12 */
/* FHC-South 13 1 1 5 9 12 */
int n=0;
g[n].detectorId = 0; g[n].type=0; g[n].ew=0; g[n].ns=0; g[n].nX= 7; g[n].nY= 7; n++;
g[n].detectorId = 1; g[n].type=0; g[n].ew=0; g[n].ns=1; g[n].nX= 7; g[n].nY= 7; n++;
g[n].detectorId = 2; g[n].type=1; g[n].ew=0; g[n].ns=0; g[n].nX= 7; g[n].nY= 1; n++;
g[n].detectorId = 3; g[n].type=1; g[n].ew=0; g[n].ns=1; g[n].nX= 7; g[n].nY= 1; n++;
if(year>=9){
g[n].detectorId = 4; g[n].type=2; g[n].ew=0; g[n].ns=0; g[n].nX=48; g[n].nY= 1; n++;
g[n].detectorId = 5; g[n].type=2; g[n].ew=0; g[n].ns=1; g[n].nX=48; g[n].nY= 1; n++;
g[n].detectorId = 6; g[n].type=3; g[n].ew=0; g[n].ns=0; g[n].nX= 1; g[n].nY=48; n++;
g[n].detectorId = 7; g[n].type=3; g[n].ew=0; g[n].ns=1; g[n].nX= 1; g[n].nY=48; n++;
}
g[n].detectorId = 8; g[n].type=4; g[n].ew=1; g[n].ns=0; g[n].nX=17; g[n].nY=34; n++;
g[n].detectorId = 9; g[n].type=4; g[n].ew=1; g[n].ns=1; g[n].nX=17; g[n].nY=34; n++;
g[n].detectorId =10; g[n].type=0; g[n].ew=1; g[n].ns=0; g[n].nX=12; g[n].nY=24; n++;
g[n].detectorId =11; g[n].type=0; g[n].ew=1; g[n].ns=1; g[n].nX=12; g[n].nY=24; n++;
// store data in the table
wtable->SetTable((char*)&g,n);
// store table in dBase
mgr->storeDbTable(wtable);
gSystem->Unsetenv("DB_ACCESS_MODE");
std::cout << "Done with database upload \n";
}
printf("n = %d\n",n);
printf(" Id Typ ew ns nX nY\n");
for(int i=0; i<n; i++){
printf("%3d %3d %3d %3d %3d %3d\n",g[i].detectorId,g[i].type,g[i].ew,g[i].ns,g[i].nX,g[i].nY);
}
}
void fpsGain_db(char* opt="", char* year="15sim") {
TString option(opt), yr(year);
TString storeTime; // storetime is begin time for validity range for WRITING DB
int date,time; // time for READING DB
std::cout << "year = " << year << "\n";
if(yr.Contains("15ofl")){
storeTime="2014-12-20 00:00:01";
date = 20141225; time = 0;
}else if(yr.Contains("15sim")){
storeTime="2014-12-10 00:00:02";
date = 20141215; time = 0;
}else{
std::cout << "Please specify valid year tag\n"; exit;
}
std::cout << "Opt =" << opt << "\n";
std::cout << "write = " << option.Contains("writedb") << "\n";
std::cout << "storetime =" << storeTime << "\n";
std::cout << "date,time =" << date <<" "<< time << "\n";
gROOT->Macro("loadlib.C");
const Int_t MAX_DB_INDEX = 252;
fpsGain_st table[MAX_DB_INDEX];
if(option.Contains("writedb")) {
gSystem->Setenv("DB_ACCESS_MODE","write");
StDbManager* mgr = StDbManager::Instance();
StDbConfigNode* node = mgr->initConfig("Calibrations_fps");
StDbTable* dbtable = node->addDbTable("fpsGain");
mgr->setStoreTime(storeTime.Data());
int id=0;
for (Int_t q = 1; q <= 4; q++) {
for (Int_t l = 1; l <= 3; l++) {
for (Int_t s = 1; s <= 21; s++) {
table[id].slatid = id;
int flag=0;
if(q==2 || q==4){
if(s>=20) flag=1;
}
float mip=100.0;
if(l==3) mip=50.0;
if(flag==0){table[id].slatid = id; table[id].MIP=mip;}
else {table[id].slatid = id; table[id].MIP=0;}
printf("id=%3d Q%1dL%1dS%2d mip=%f\n",id,q,l,s,table[id].MIP);
id++;
}
}
}
dbtable->SetTable((char*)&table, MAX_DB_INDEX);
if(yr.Contains("sim")) dbtable->setFlavor("sim");
mgr->storeDbTable(dbtable);
std::cout << "INFO: table saved to database" << std::endl;
}
std::cout << "INFO: Reading database" << std::endl;
gSystem->Unsetenv("DB_ACCESS_MODE");
//gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG");
St_db_Maker *dbMk=new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(date,time); // event or run start time, set to your liking
if(yr.Contains("ofl")) {dbMk->SetFlavor("ofl");}
else if(yr.Contains("sim")) {dbMk->SetFlavor("sim");}
dbMk->Init();
dbMk->Make();
TDataSet *DB = 0;
DB = dbMk->GetDataBase("Calibrations/fps/fpsGain");
if (!DB) std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl;
St_fpsGain *dataset = 0;
dataset = (St_fpsGain*) DB->Find("fpsGain");
if (!dataset) {
td::cout << "ERROR: dataset does not contain requested table" << std::endl;
return;
}
Int_t rows = dataset->GetNRows();
if (rows > 1) {
std::cout << "INFO: found INDEXED table with " << rows << " rows" << std::endl;
}
TDatime val[2];
dbMk->GetValidity((TTable*)dataset,val);
std::cout << "Dataset validity range: [ " << val[0].GetDate() << "." << val[0].GetTime() << " - "
<< val[1].GetDate() << "." << val[1].GetTime() << " ] "
<< std::endl;
fpsGain_st *tbl = dataset->GetTable();
for (Int_t i = 0; i < rows; i++) {
std::cout << Form("Row=%4d slatid=%3d MIP=%8.4f\n",i,
tbl[i].slatid,tbl[i].MIP);
}
}
void fPostStatus_db(
const char* opt = "",
const char* year = "17sim",
const char* input = "fPostStatus.txt",
int readdate = 0,
int readtime = 0)
{
// storeTime is beginning time for validity range in case of WRITING DB
TString option(opt), yr(year), storeTime;
int date, time; // time for READING DB
std::cout <<"year = " <<year <<std::endl;
if (yr.Contains("17sim"))
{
storeTime = "2016-12-10 00:00:00";
date = 20161210;
time = 0;
}
else if (yr.Contains("17ofl"))
{
storeTime = "2016-12-20 00:00:00";
date = 20161220;
time = 0;
}
else { std::cout << "Please specify valid year tag\n"; exit; }
if (readdate > 0) date = readdate;
if (readtime > 0) time = readtime;
std::cout << "Opt =" << opt << "\n";
std::cout << "write = " << option.Contains("writedb") << "\n";
std::cout << "storetime = " << storeTime << "\n";
std::cout << "date, time = " << date <<" "<< time << "\n";
gROOT->Macro("./loadlib.C");
//-------------------------------------------
const Int_t MAX_DB_INDEX = 241;
fpostStatus_st in[MAX_DB_INDEX];
FILE *FP = fopen(input, "r");
if (!FP) { printf("Could not open %s\n", input); exit; }
printf("\nReading %s\n", input);
char line[1000];
int n = 0;
while (fgets(line, 1000, FP) != NULL)
{
sscanf(line,"%hu %hu", &in[n].slatid, &in[n].status);
printf("slatId=%3d status=%1d\n", in[n].slatid, in[n].status);
n++;
}
printf("Found %d entries\n", n);
fclose(FP);
printf("File Closed\n", n);
//-------------------------------------------
#if 1
if (option.Contains("writedb"))
{
gSystem->Setenv("DB_ACCESS_MODE", "write");
StDbManager* mgr = StDbManager::Instance();
StDbConfigNode* node = mgr->initConfig("Calibrations_fps");
StDbTable* dbtable = node->addDbTable("fpostStatus");
mgr->setStoreTime(storeTime.Data());
dbtable->SetTable((char*)&in, MAX_DB_INDEX);
if (yr.Contains("sim")) dbtable->setFlavor("sim");
mgr->storeDbTable(dbtable);
std::cout << "INFO: table saved to database" << std::endl;
}
//-------------------------------------------
if (option.Contains("readdb"))
{
std::cout << "INFO: Reading database" << std::endl;
gSystem->Unsetenv("DB_ACCESS_MODE");
//gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG");
St_db_Maker* dbMk = new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(date, time); // event or run start time, set to your liking
if (yr.Contains("ofl")) { dbMk->SetFlavor("ofl"); }
else if (yr.Contains("sim")) { dbMk->SetFlavor("sim"); }
dbMk->Init();
dbMk->Make();
TDataSet *DB = 0;
DB = dbMk->GetDataBase("Calibrations/fps/fpostStatus");
if (!DB) std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl;
St_fpostStatus *dataset = 0;
dataset = (St_fpostStatus*) DB->Find("fpostStatus");
if (!dataset) { std::cout << "ERROR: dataset does not contain requested table" << std::endl; return; }
Int_t rows = dataset->GetNRows();
if (rows > 1) std::cout << "INFO: found INDEXED table with " << rows << " rows" << std::endl;
TDatime val[2];
dbMk->GetValidity((TTable*)dataset, val);
std::cout << "Dataset validity range: [ " << val[0].GetDate() << "." << val[0].GetTime() << " - "
<< val[1].GetDate() << "." << val[1].GetTime() << " ] " << std::endl;
fpostStatus_st *table = (fpostStatus_st*)dataset->GetTable();
for (Int_t i = 0; i < rows; i++)
{
std::cout << Form("Row=%3d slatid=%3d status=%1d\n", i, table[i].slatid, table[i].status);
}
}
#endif
return;
}//Main
void fpsMap_db(char* opt="", char* year="15sim", char* input="fpsmap.txt") {
TString option(opt), yr(year);
TString storeTime; // storetime is begin time for validity range for WRITING DB
int date,time; // time for READING DB
std::cout << "year = " << year << "\n";
if(yr.Contains("15ofl")){
storeTime="2014-12-20 00:00:3";
date = 20141221; time = 0;
}else if(yr.Contains("15sim")){
storeTime="2014-12-10 00:00:01";
date = 20141210; time = 1;
}else if(yr.Contains("17ofl")){
storeTime="2016-12-20 00:00:00";
date = 20161220; time = 0;
}else if(yr.Contains("17sim")){
storeTime="2016-12-10 00:00:00";
date = 20161210; time = 0;
}else{
std::cout << "Please specify valid year tag\n"; exit;
}
std::cout << "Opt =" << opt << "\n";
std::cout << "write = " << option.Contains("writedb") << "\n";
std::cout << "storetime =" << storeTime << "\n";
std::cout << "date,time =" << date <<" "<< time << "\n";
gROOT->Macro("./loadlib.C");
const Int_t MAX_DB_INDEX = 252;
fpsMap_st in[MAX_DB_INDEX];
for(int i=0; i<MAX_DB_INDEX; i++){
in[i].slatid=i;
in[i].QTaddr=-1;
in[i].QTch=-1;
}
FILE *FP = fopen(input,"r");
if(!FP) { printf("Could not open %s\n",input); exit;}
printf("Reading %s\n",input);
char line[1000], nw[10], dc[10], posi[10];
int id,q,l,s,sipm,sipmbd,feebd,tbox,tgrp,qtaddr,qtch,cbl;
int n=0;
while(fgets(line,1000,FP)!=NULL){
sscanf(line,"%d %d %d %d %d %s %d %d %d %d",
&id,&q,&l,&s,
&sipm,nw,
&tbox,&tgrp,
&qtaddr,&qtch);
//printf("Id=%3d Q=%3d L=%3d S=%3d QTaddr=%1d QTch=%2d\n",id,q,l,s,qtaddr,qtch);
in[id].QTaddr=qtaddr;
in[id].QTch=qtch;
n++;
}
for(int i=0; i<MAX_DB_INDEX; i++){
printf("Id=%3d QTaddr=%1d QTch=%2d\n",in[i].slatid,in[i].QTaddr,in[i].QTch);
}
printf("Found %d entries\n",n);
if(option.Contains("writedb")) {
gSystem->Setenv("DB_ACCESS_MODE","write");
StDbManager* mgr = StDbManager::Instance();
StDbConfigNode* node = mgr->initConfig("Geometry_fps");
StDbTable* dbtable = node->addDbTable("fpsMap");
mgr->setStoreTime(storeTime.Data());
dbtable->SetTable((char*)&in, MAX_DB_INDEX);
if(yr.Contains("sim")) dbtable->setFlavor("sim");
mgr->storeDbTable(dbtable);
std::cout << "INFO: table saved to database" << std::endl;
}
std::cout << "INFO: Reading database" << std::endl;
gSystem->Unsetenv("DB_ACCESS_MODE");
//gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG");
St_db_Maker *dbMk=new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(date,time); // event or run start time, set to your liking
if(yr.Contains("ofl")) {dbMk->SetFlavor("ofl");}
else if(yr.Contains("sim")) {dbMk->SetFlavor("sim");}
dbMk->Init();
dbMk->Make();
TDataSet *DB = 0;
DB = dbMk->GetDataBase("Geometry/fps/fpsMap");
if (!DB) std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl;
St_fpsMap *dataset = 0;
dataset = (St_fpsMap*) DB->Find("fpsMap");
if (!dataset) {
td::cout << "ERROR: dataset does not contain requested table" << std::endl;
return;
}
Int_t rows = dataset->GetNRows();
if (rows > 1) {
std::cout << "INFO: found INDEXED table with " << rows << " rows" << std::endl;
}
TDatime val[2];
dbMk->GetValidity((TTable*)dataset,val);
std::cout << "Dataset validity range: [ " << val[0].GetDate() << "." << val[0].GetTime() << " - "
<< val[1].GetDate() << "." << val[1].GetTime() << " ] "
<< std::endl;
fpsMap_st *table = dataset->GetTable();
for (Int_t i = 0; i < rows; i++) {
std::cout << Form("Row=%4d slatid=%3d QTaddr=%2d QTch=%2d\n",i,
table[i].slatid,
table[i].QTaddr,table[i].QTch);
}
}
void fpsChannelGeometry_db(char* opt="", char* year="15sim") {
TString option(opt), yr(year);
TString storeTime; // storetime is begin time for validity range for WRITING DB
int date,time; // time for READING DB
std::cout << "year = " << year << "\n";
if(yr.Contains("15ofl")){
storeTime="2014-12-20 00:00:01";
date = 20141220; time = 1;
}else if(yr.Contains("15sim")){
storeTime="2014-12-10 00:00:01";
date = 20141210; time = 1;
}else if (yr.Contains("17ofl")){
storeTime="2016-12-20 00:00:00";
date = 20161220; time = 0;
}else if(yr.Contains("17sim")){
storeTime="2016-12-10 00:00:00";
date = 20161210; time = 0;
}else{
std::cout << "Please specify valid year tag\n"; exit;
}
std::cout << "Opt =" << opt << "\n";
std::cout << "write = " << option.Contains("writedb") << "\n";
std::cout << "storetime =" << storeTime << "\n";
std::cout << "date,time =" << date <<" "<< time << "\n";
gROOT->Macro("loadlib.C");
const Int_t MAX_DB_INDEX = 12;
fpsChannelGeometry_st table[MAX_DB_INDEX];
if(option.Contains("writedb")) {
gSystem->Setenv("DB_ACCESS_MODE","write");
StDbManager* mgr = StDbManager::Instance();
StDbConfigNode* node = mgr->initConfig("Geometry_fps");
StDbTable* dbtable = node->addDbTable("fpsChannelGeometry");
mgr->setStoreTime(storeTime.Data());
table[ 0].quad = 1; table[ 0].layer = 1; table[ 0].nslat = 21;
table[ 1].quad = 1; table[ 1].layer = 2; table[ 1].nslat = 21;
table[ 2].quad = 1; table[ 2].layer = 3; table[ 2].nslat = 21;
table[ 3].quad = 2; table[ 3].layer = 1; table[ 3].nslat = 19;
table[ 4].quad = 2; table[ 4].layer = 2; table[ 4].nslat = 19;
table[ 5].quad = 2; table[ 5].layer = 3; table[ 5].nslat = 19;
table[ 6].quad = 3; table[ 6].layer = 1; table[ 6].nslat = 21;
table[ 7].quad = 3; table[ 7].layer = 2; table[ 7].nslat = 21;
table[ 8].quad = 3; table[ 8].layer = 3; table[ 8].nslat = 21;
table[ 9].quad = 4; table[ 9].layer = 1; table[ 9].nslat = 19;
table[10].quad = 4; table[10].layer = 2; table[10].nslat = 19;
table[11].quad = 4; table[11].layer = 3; table[11].nslat = 19;
dbtable->SetTable((char*)&table, MAX_DB_INDEX);
if(yr.Contains("sim")) dbtable->setFlavor("sim");
mgr->storeDbTable(dbtable);
std::cout << "INFO: table saved to database" << std::endl;
}
std::cout << "INFO: Reading database" << std::endl;
gSystem->Unsetenv("DB_ACCESS_MODE");
//gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG");
St_db_Maker *dbMk=new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb");
dbMk->SetDebug();
dbMk->SetDateTime(date,time); // event or run start time, set to your liking
if(yr.Contains("ofl")) {dbMk->SetFlavor("ofl");}
else if(yr.Contains("sim")) {dbMk->SetFlavor("sim");}
dbMk->Init();
dbMk->Make();
TDataSet *DB = 0;
DB = dbMk->GetDataBase("Geometry/fps/fpsChannelGeometry");
if (!DB) std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl;
St_fpsChannelGeometry *dataset = 0;
dataset = (St_fpsChannelGeometry*) DB->Find("fpsChannelGeometry");
if (!dataset) {
td::cout << "ERROR: dataset does not contain requested table" << std::endl;
return;
}
Int_t rows = dataset->GetNRows();
if (rows > 1) {
std::cout << "INFO: found INDEXED table with " << rows << " rows" << std::endl;
}
TDatime val[2];
dbMk->GetValidity((TTable*)dataset,val);
std::cout << "Dataset validity range: [ " << val[0].GetDate() << "." << val[0].GetTime() << " - "
<< val[1].GetDate() << "." << val[1].GetTime() << " ] "
<< std::endl;
fpsChannelGeometry_st *tbl = dataset->GetTable();
for (Int_t i = 0; i < rows; i++) {
std::cout << Form("Row=%4d quad=%1d layer=%1d nslat=%2d\n",i,
tbl[i].quad,tbl[i].layer,tbl[i].nslat);
}
}
